From 5fe8c0fd9463c87004a5cd449ad30e0902a81399 Mon Sep 17 00:00:00 2001
From: Jason Kuhrt <jasonkuhrt@me.com>
Date: Sun, 19 Nov 2023 09:32:29 -0500
Subject: [PATCH] feat(@molt/command)!: zod as extension (#249)

---
 packages/@molt/command/README.md              | 240 ++++++++++------
 packages/@molt/command/examples/intro.ts      |   6 +-
 .../@molt/command/examples/kitchen-sink.ts    |   2 +
 packages/@molt/command/examples/prompt.ts     |   2 +
 packages/@molt/command/examples/publish.ts    |   2 +
 packages/@molt/command/package.json           |   2 +-
 packages/@molt/command/src/Command/State.ts   | 173 ------------
 .../src/Command/exclusive/constructor.ts      |  34 ---
 .../command/src/Command/exclusive/types.ts    |  65 -----
 .../command/src/Command/root/constructor.ts   |  92 ------
 .../@molt/command/src/Command/root/types.ts   |  76 -----
 .../src/CommandParameter/CommandParameter.ts  |  84 ------
 .../command/src/CommandParameter/index.ts     |   1 -
 .../command/src/CommandParameter/input.ts     |  39 ---
 .../command/src/CommandParameter/output.ts    |  68 ++---
 .../processor/parameterTypes/basic.ts         |  36 ---
 .../processor/parameterTypes/exclusive.ts     |  56 ----
 .../src/CommandParameter/processor/process.ts |  35 ---
 packages/@molt/command/src/Errors/Errors.ts   |  33 ++-
 packages/@molt/command/src/Help/Help.ts       | 118 ++++----
 .../OpeningArgs/Environment/Environment.ts    |   9 +-
 .../command/src/OpeningArgs/Line/Line.ts      |   9 +-
 .../command/src/OpeningArgs/OpeningArgs.ts    |   7 +-
 .../@molt/command/src/OpeningArgs/helpers.ts  |  11 +-
 .../@molt/command/src/OpeningArgs/types.ts    |  34 +--
 packages/@molt/command/src/Parameter/basic.ts |  50 ++++
 .../@molt/command/src/Parameter/exclusive.ts  |  92 ++++++
 .../src/Parameter/helpers/CommandParameter.ts |  81 ++++++
 .../helpers/environment.ts                    |   7 +-
 .../command/src/Parameter/helpers/types.ts    |   9 +
 packages/@molt/command/src/Parameter/types.ts |  14 +
 .../@molt/command/src/Settings/settings.ts    |  22 +-
 packages/@molt/command/src/Type/helpers.ts    |   4 +-
 .../command/src/Type/types/Scalars/Boolean.ts |   1 +
 .../src/Type/types/Scalars/Enumeration.ts     |   1 +
 .../command/src/Type/types/Scalars/Literal.ts |   1 +
 .../command/src/Type/types/Scalars/Number.ts  |   1 +
 .../command/src/Type/types/Scalars/String.ts  |   1 +
 .../command/src/TypeAdaptors/TypeAdaptors.ts  |   1 -
 .../@molt/command/src/TypeAdaptors/index.ts   |   1 -
 .../command/src/TypeAdaptors/zod/index.ts     |   1 -
 .../command/src/TypeAdaptors/zod/types.ts     |  51 ----
 .../command/src/_entrypoints/extensions.ts    |   1 +
 .../{entrypoints => _entrypoints}/types.ts    |   0
 .../src/builders/command/constructor.ts       | 109 +++++++
 .../command/src/builders/command/state.ts     | 194 +++++++++++++
 .../command/src/builders/command/types.ts     |  70 +++++
 .../src/builders/exclusive/constructor.ts     |  58 ++++
 .../command/src/builders/exclusive/state.ts   |  27 ++
 .../command/src/builders/exclusive/types.ts   |  58 ++++
 packages/@molt/command/src/eventPatterns.ts   |  13 +-
 .../src/executor/helpers/createParameters.ts  |  39 +++
 packages/@molt/command/src/executor/parse.ts  |  27 +-
 packages/@molt/command/src/executor/prompt.ts |   3 +-
 .../{CommandParameter => executor}/types.ts   |   2 -
 packages/@molt/command/src/extension.ts       |  27 ++
 .../zodHelpers => extensions/zod}/guards.ts   |   0
 .../zod/typeAdaptor/runtime.ts}               |  74 ++---
 .../src/extensions/zod/typeAdaptor/types.ts   |  36 +++
 .../zod.ts => extensions/zod/types.ts}        |  15 +-
 .../@molt/command/src/extensions/zod/zod.ts   |  18 ++
 packages/@molt/command/src/helpers.ts         |  24 +-
 packages/@molt/command/src/index_.ts          |   2 +-
 .../@molt/command/src/lib/zodHelpers/index.ts |   1 -
 .../command/src/lib/zodHelpers/index_.ts      |  88 ------
 packages/@molt/command/tests/_/helpers.ts     |   5 +
 .../command/tests/chaining/chaining.spec.ts   |  19 +-
 .../command/tests/environment/case.spec.ts    |   7 +-
 .../tests/environment/global/prefix.spec.ts   |  29 +-
 .../tests/environment/global/toggling.spec.ts |  21 +-
 .../command/tests/environment/parsing.spec.ts |  31 +-
 .../environment/selective/prefix.spec.ts      |   9 +-
 .../environment/selective/toggling.spec.ts    |  24 +-
 .../tests/environment/types/boolean.spec.ts   |   5 +-
 .../@molt/command/tests/exclusive.spec.ts     | 103 ++++---
 .../@molt/command/tests/help/help.spec.ts     |  17 +-
 .../command/tests/help/rendering.spec.ts      | 215 ++++++--------
 .../@molt/command/tests/line/builder.spec.ts  |   8 +-
 .../@molt/command/tests/line/name.spec.ts     |  32 +--
 .../command/tests/line/types/boolean.spec.ts  |  28 +-
 .../command/tests/line/types/enum.spec.ts     |  13 +-
 .../command/tests/line/types/number.spec.ts   |  18 +-
 .../command/tests/line/types/string.spec.ts   |  17 +-
 .../parameters/configurationObject.spec.ts    |  15 +-
 .../tests/parameters/description.spec.ts      |  25 +-
 .../tests/parameters/unionType.spec.ts        |  48 ++--
 .../tests/parameters/zod/nativeEnum.spec.ts   |   5 +-
 .../tests/parameters/zod/number.spec.ts       |   5 +-
 .../tests/parameters/zod/static.spec.ts       |  38 +--
 .../tests/parameters/zod/string.spec.ts       |   7 +-
 .../@molt/command/tests/prompt/prompt.spec.ts | 266 ++++++++----------
 .../command/tests/prompt/settings.spec.ts     |  36 +--
 scripts/release.ts                            |   2 +
 93 files changed, 1706 insertions(+), 1800 deletions(-)
 delete mode 100644 packages/@molt/command/src/Command/State.ts
 delete mode 100644 packages/@molt/command/src/Command/exclusive/constructor.ts
 delete mode 100644 packages/@molt/command/src/Command/exclusive/types.ts
 delete mode 100644 packages/@molt/command/src/Command/root/constructor.ts
 delete mode 100644 packages/@molt/command/src/Command/root/types.ts
 delete mode 100644 packages/@molt/command/src/CommandParameter/CommandParameter.ts
 delete mode 100644 packages/@molt/command/src/CommandParameter/index.ts
 delete mode 100644 packages/@molt/command/src/CommandParameter/input.ts
 delete mode 100644 packages/@molt/command/src/CommandParameter/processor/parameterTypes/basic.ts
 delete mode 100644 packages/@molt/command/src/CommandParameter/processor/parameterTypes/exclusive.ts
 delete mode 100644 packages/@molt/command/src/CommandParameter/processor/process.ts
 create mode 100644 packages/@molt/command/src/Parameter/basic.ts
 create mode 100644 packages/@molt/command/src/Parameter/exclusive.ts
 create mode 100644 packages/@molt/command/src/Parameter/helpers/CommandParameter.ts
 rename packages/@molt/command/src/{CommandParameter/processor => Parameter}/helpers/environment.ts (77%)
 create mode 100644 packages/@molt/command/src/Parameter/helpers/types.ts
 create mode 100644 packages/@molt/command/src/Parameter/types.ts
 delete mode 100644 packages/@molt/command/src/TypeAdaptors/TypeAdaptors.ts
 delete mode 100644 packages/@molt/command/src/TypeAdaptors/index.ts
 delete mode 100644 packages/@molt/command/src/TypeAdaptors/zod/index.ts
 delete mode 100644 packages/@molt/command/src/TypeAdaptors/zod/types.ts
 create mode 100644 packages/@molt/command/src/_entrypoints/extensions.ts
 rename packages/@molt/command/src/{entrypoints => _entrypoints}/types.ts (100%)
 create mode 100644 packages/@molt/command/src/builders/command/constructor.ts
 create mode 100644 packages/@molt/command/src/builders/command/state.ts
 create mode 100644 packages/@molt/command/src/builders/command/types.ts
 create mode 100644 packages/@molt/command/src/builders/exclusive/constructor.ts
 create mode 100644 packages/@molt/command/src/builders/exclusive/state.ts
 create mode 100644 packages/@molt/command/src/builders/exclusive/types.ts
 create mode 100644 packages/@molt/command/src/executor/helpers/createParameters.ts
 rename packages/@molt/command/src/{CommandParameter => executor}/types.ts (89%)
 create mode 100644 packages/@molt/command/src/extension.ts
 rename packages/@molt/command/src/{lib/zodHelpers => extensions/zod}/guards.ts (100%)
 rename packages/@molt/command/src/{TypeAdaptors/zod/zod.ts => extensions/zod/typeAdaptor/runtime.ts} (62%)
 create mode 100644 packages/@molt/command/src/extensions/zod/typeAdaptor/types.ts
 rename packages/@molt/command/src/{CommandParameter/zod.ts => extensions/zod/types.ts} (52%)
 create mode 100644 packages/@molt/command/src/extensions/zod/zod.ts
 delete mode 100644 packages/@molt/command/src/lib/zodHelpers/index.ts
 delete mode 100644 packages/@molt/command/src/lib/zodHelpers/index_.ts

diff --git a/packages/@molt/command/README.md b/packages/@molt/command/README.md
index 506ce2e6..8f2e986e 100644
--- a/packages/@molt/command/README.md
+++ b/packages/@molt/command/README.md
@@ -7,24 +7,25 @@
 - [Installation](#installation)
 - [Example](#example)
 - [Features](#features)
-  - [⛑ Type safe](#%E2%9B%91-type-safe)
-  - [👘 Expressive parameter specification](#%F0%9F%91%98-expressive-parameter-specification)
-  - [📖 Autogenerated help](#%F0%9F%93%96-autogenerated-help)
+  - [⛑ Type Safe](#%E2%9B%91-type-safe)
+  - [👘 Expressive Parameter Specification](#%F0%9F%91%98-expressive-parameter-specification)
+  - [📖 Autogenerated Help](#%F0%9F%93%96-autogenerated-help)
+  - [🧩 Extensible](#%F0%9F%A7%A9-extensible)
 - [Video Introduction](#video-introduction)
 - [Docs](#docs)
+  - [Immutability](#immutability)
   - [Parameter Naming](#parameter-naming)
-    - [Property Name Syntax](#property-name-syntax)
     - [Flag Syntax](#flag-syntax)
     - [Short, Long, & Aliasing](#short-long--aliasing)
     - [Kebab / Camel Case](#kebab--camel-case)
-    - [Type Safety](#type-safety)
+    - [Duplicate Detection](#duplicate-detection)
+    - [Reserved Names](#reserved-names)
+    - [Internal Canonical Form](#internal-canonical-form)
   - [Parameter Types](#parameter-types)
-    - [Zod Support](#zod-support)
     - [Boolean](#boolean)
     - [String](#string)
     - [Number](#number)
     - [Enum](#enum)
-    - [Native Enum](#native-enum)
     - [Union](#union)
   - [Parameter Prompts](#parameter-prompts)
     - [Overview](#overview)
@@ -45,12 +46,14 @@
     - [Case Insensitive](#case-insensitive)
     - [Validation](#validation)
   - [Mutually Exclusive Parameters](#mutually-exclusive-parameters)
-    - [Type Safety](#type-safety-1)
+    - [Type Safety](#type-safety)
     - [Optional](#optional)
     - [Default](#default)
     - [Autogenerated Documentation](#autogenerated-documentation)
   - [Description](#description)
   - [Settings](#settings)
+- [Extensions](#extensions)
+  - [Zod](#zod)
 - [Recipes](#recipes)
   - [Optional Argument With Default Behavior](#optional-argument-with-default-behavior)
 - [Architecture](#architecture)
@@ -60,16 +63,18 @@
 ## Installation
 
 ```
-npm add @molt/command zod
+npm add @molt/command
 ```
 
 ## Example
 
 ```ts
-import { Command } from '../src/index.js'
+import { Command } from '@molt/command'
+import { Zod } from '@molt/command/extensions'
 import { z } from 'zod'
 
 const args = Command.create()
+  .use(Zod)
   .parameter(`filePath`, z.string().describe(`Path to the file to convert.`))
   .parameter(`to`, z.enum([`json`, `yaml`, `toml`]).describe(`Format to convert to.`))
   .parameter(
@@ -104,11 +109,13 @@ $ mybin --help
 
 ## Features
 
-#### ⛑ Type safe
+#### ⛑ Type Safe
 
-#### 👘 Expressive parameter specification
+#### 👘 Expressive Parameter Specification
 
-- Automatic casting and validation based on specified Zod types.
+- Types that determine value parsing (casting)
+- Validations
+- Descriptions
 - Normalization between camel and kebab case and optional dash prefix:
 
   ```ts
@@ -123,13 +130,13 @@ $ mybin --help
   args3.doItC
   ```
 
-- Specify one or multiple (aka. aliases) short and long flags:
+- One or multiple short and/or long names:
 
   ```ts
   Command.create().parameter('-f --force --forcefully', z.boolean()).parse()
   ```
 
-- Use Zod `.default(...)` method for setting default values.
+- Default values:
 
   ```ts
   const args = Command.create().parameter('--path', z.string().default('./a/b/c')).parse()
@@ -137,32 +144,42 @@ $ mybin --help
   args.path === '/over/ride' // $ mybin --path /over/ride
   ```
 
-- Define [mutually exclusive parameters](#mutually-exclusive-parameters) declaratively.
-
-- Use Zod `.describe(...)` to add parameter descriptions in autogenerated docs.
+- [mutually exclusive parameters](#mutually-exclusive-parameters)
 
-- 🤾‍♀️ Expressive argument passing
+- flexible argument passing
 
-  - Pass via environment variables (customizable)
+  - via environment variables (customizable)
 
     ```ts
     const args = Command.create().parameter('--path', z.string()).parse()
     args.path === './a/b/c/' // $ CLI_PARAM_PATH='./a/b/c' mybin
     ```
 
-  - Kebab or camel case flags
+  - via flags in Kebab or camel case
     ```
     $ mybin --do-it
     $ mybin --doIt
     ```
   - Parameter stacking e.g. `mybin -abc` instead of `mybin -a -b -c`
-  - Separator of `=` or space, e.g. `mybin -a=foo -b=bar` or `mybin -a foo -b bar`
+  - Separator symbol of equals or space
+    ```
+    $ mybin -a=foo -b=bar
+    $ mybin -a foo -b bar
+    ```
 
-#### 📖 Autogenerated help
+#### 📖 Autogenerated Help
 
 ![doc](../../../assets/example-doc-mx-params.png)
 ![doc](../../../assets/example-doc-kitchen-sink.png)
 
+#### 🧩 Extensible
+
+- Extend Molt Command with new capabilities tailored to your use-case
+- Zod Extension
+  - Use `z.string()`, `z.boolean` etc.
+  - `.describe(...)` to add description
+  - `.default(...)` to set default value
+
 ## Video Introduction
 
 A [video introduction](https://www.youtube.com/watch?v=UtXM4FKCUDo) if you like that format:
@@ -171,37 +188,48 @@ A [video introduction](https://www.youtube.com/watch?v=UtXM4FKCUDo) if you like
 
 ## Docs
 
-### Parameter Naming
+### Immutability
 
-#### Property Name Syntax
+Molt Command is a fluent API which means methods return a central object of methods allowing you to chain methods one after another.
 
-You can define parameters as a zod object schema using regular property names. These are flags for your CLI but arguments can also be passed by environment variables so in a way this is a neutral form that doesn't privilege either argument passing mechanism.
+Each method in the chain returns a _new version_ of the chain. So for example let's say you had two scripts that had some overlapping requirements. You could factor those requirements out into a common base chain.
 
 ```ts
-const args = Command.create()
-  .parameter('foo', z.string())
-  .parameter('bar', z.number())
-  .parameter('qux', z.boolean())
-  .parse()
+// helpers.ts
+import { Command } from '@molt/command'
+import { Zod } from '@molt/command/extensions'
 
-args.foo
-args.bar
-args.qux
+export const command = Command.create()
+  .use(Zod)
+  .parameter('woof', z.enum(['soft', 'loud', 'deafening']))
+```
+
+```ts
+// foo.ts
+import { command } from './helpers.ts'
+
+const args = command.parameter('bravo', z.boolean())
 ```
 
+```ts
+// bar.ts
+const args = command.parameter('charlie', z.number())
+```
+
+### Parameter Naming
+
 #### Flag Syntax
 
-You can also define them using flag syntax if you prefer. Thanks to `@molt/types` this style doesn't sacrifice any type safety.
+You can define parameters using dash prefixes (flag syntax).
 
 ```ts
+// prettier-ignore
 const args = Command.create()
-  .parameter('--foo', z.string())
-  .parameter('--bar', z.number())
-  .parameter('--qux', z.boolean())
+  .parameter('--foo -f', z.string())
+  .parameter('qux q', z.string())
   .parse()
 
 args.foo
-args.bar
 args.qux
 ```
 
@@ -209,11 +237,6 @@ args.qux
 
 You can give your parameters short and long names, as well as aliases.
 
-A set of parameter names gets normalized into its canonical name internally (again thanks to `@molt/types` this is all represented statically as well). The canonical name choice is as follows:
-
-1. The first long flag
-2. Otherwise the first short flag
-
 ```ts
 const args = Command.create()
   .parameter('--foobar --foo -f ', z.string())
@@ -244,10 +267,15 @@ const args = Command.create()
 
 #### Kebab / Camel Case
 
-You can use kebab or camel case (and likewise your users can pass flags in either style). Canonical form internally uses camel case.
+You can use kebab or camel case.
 
 ```ts
-const args = Command.create().parameter('foo-bar', z.string()).parameter('quxLot', z.string()).parse()
+const args = Command.create()
+  .parameter('--foo-bar', z.string())
+  .parameter('--quxLot', z.string())
+  .parameter('foo-bar-2', z.string())
+  .parameter('quxLot2', z.string())
+  .parse()
 
 // $ mybin --foo-bar moo --qux-lot zoo
 // $ mybin --fooBar moo --quxLot zoo
@@ -255,62 +283,67 @@ args.fooBar === 'moo'
 args.quxLot === 'zoo'
 ```
 
-#### Type Safety
+#### Duplicate Detection
 
-Duplicate parameter names will be caught statically via TypeScript.
+Duplicate parameter names will be caught statically via TypeScript. The following shows examples of the many forms duplication can happen. Note how case and syntax are not contributing factors to uniqueness.
 
 ```ts
 const args = Command.create()
-  .parameter('f foo bar', z.string())
-  .parameter('bar', z.string()) //  <-- TS error: already taken
-  .parameter('f', z.string()) //    <-- TS error: already taken
-  .parameter('foo', z.string()) //  <-- TS error: already taken
-  .parameter('help', z.string()) // <-- TS error: reserved name
-  .parameter('h', z.string()) //    <-- TS error: reserved name
+  .parameter('f foo barBar', z.string())
+  .parameter('bar-bar', z.string()) //  <-- TS error: already taken
+  .parameter('f', z.string()) //        <-- TS error: already taken
+  .parameter('--foo', z.string()) //    <-- TS error: already taken
   .parse()
 ```
 
-### Parameter Types
-
-This section covers how parameters are typed via a subset of Zod schemas and the types used will affect parsing.
+#### Reserved Names
 
-#### Zod Support
-
-Only the following set of Zod types are supported. In addition to the docs below, static typing will raise an error if you pass in something invalid.
+Some names are reserved for use by default.
 
 ```ts
-z.boolean()
-z.string()
-z.enum(['...', '...'])
-z.nativeEnum({'...':'...', '...':'...'})
-z.number()
-z.union([...]) // where ... can be any other type above.
+const args = Command.create()
+  .parameter('help', z.string()) //     <-- TS error: reserved name
+  .parameter('h', z.string()) //        <-- TS error: reserved name
+  .parse()
 ```
 
-Validation methods like `.min(1)` and `.regex(/.../)` should all just work.
+#### Internal Canonical Form
 
-The following modifiers are accepted:
+Internally, the canonical form of a parameter name is the representation that will be used whenever that name has to be referenced. Primarily this means the names you will find on the arguments returned from `.parse`.
 
-```ts
-.optional()
-.default(...)
-```
+The algorithm is:
 
-If both `optional` and `default` are used then `default` takes precedence.
-The `describe` method is used for adding docs. It can show up in any part of the chain. All the following are fine:
+1. The first long name, else first short
+2. Stripped of flag syntax
+3. Using camel case
+
+The following shows an exaggerated example of how the many permutations normalize.
 
 ```ts
-z.string().describe('...').optional()
-z.string().optional().describe('...')
-z.string().min(1).describe('...').optional()
+const args = Command.create()
+  .parameter('--foo-foo f', z.string())
+  .parameter('-q quxQux', z.string())
+  .parameter('a b c --a-b-c', z.string())
+  .parameter('x', z.string())
+  .parameter('-z', z.string())
+  .parse()
+
+args.fooFoo
+args.quxQux
+args.ABC
+args.x
+args.z
 ```
 
+### Parameter Types
+
+This section covers the different kinds of built-in types and how they affect argument parsing.
+
 #### Boolean
 
 - Flag does not accept any arguments.
 - Environment variable accepts `"true"` or `"1"` for `true` and `"false"` or `"0"` for `false`.
 - Negated form of parameters automatically accepted.
-- [Zod docs](https://github.com/colinhacks/zod#booleans)
 
 Examples:
 
@@ -344,7 +377,6 @@ args.force === true
 #### String
 
 - Flag expects an argument.
-- [Zod docs](https://github.com/colinhacks/zod#strings)
 
 ##### Transformations
 
@@ -381,7 +413,6 @@ args.force === true
 
 - Flag expects an argument.
 - Argument is cast via the `Number()` function.
-- [Zod docs](https://github.com/colinhacks/zod#numbers)
 
 ##### Validations
 
@@ -392,12 +423,6 @@ args.force === true
 
 #### Enum
 
-- Flag expects an argument.
-- [Zod docs](https://github.com/colinhacks/zod#zod-enums)
-
-#### Native Enum
-
-- [Zod docs](https://github.com/colinhacks/zod#native-enums)
 - Flag expects an argument.
 
 #### Union
@@ -424,8 +449,6 @@ args.force === true
   Command.create().parameter('xee', z.union([z.string(), z.number()]))
   ```
 
-- [Zod docs](https://github.com/colinhacks/zod#unions)
-
 ##### Help Rendering
 
 - By default help rendering will render something like so:
@@ -1088,6 +1111,47 @@ Settings documentation is not co-located. Documentation for various features wil
 Command.create().settings({...})
 ```
 
+## Extensions
+
+### Zod
+
+The `Zod` extension lets you use Zod schemas wherever types are accepted.
+
+To use this extension you must install `zod` into your project:
+
+```
+npm add zod
+```
+
+The supported Zod types and their mapping is as follows:
+
+| Zod                                                                               | Molt Type             |
+| --------------------------------------------------------------------------------- | --------------------- |
+| [`boolean`](https://github.com/colinhacks/zod#booleans)                           | [`boolean`](#boolean) |
+| [`string`](https://github.com/colinhacks/zod#strings)                             | [`string`](#string)   |
+| [`number`](https://github.com/colinhacks/zod#numbers)                             | [`number`](#number)   |
+| [`enum`](https://github.com/colinhacks/zod#zod-enums)                             | [`enum`](#enum)       |
+| [`nativeEnum`](https://github.com/colinhacks/zod#native-enums)                    | [`enum`](#enum)       |
+| [`union`](https://github.com/colinhacks/zod#unions) (of any other Zod type above) | [`union`](#union)     |
+
+All validation methods are accepted (`.min(1)`, `.regex(/.../)`, `.cuid()`, ...).
+
+The following modifiers are accepted:
+
+```ts
+.optional()
+.default(...)
+```
+
+If both `optional` and `default` are used then `default` takes precedence.
+The `describe` method is used for adding docs. It can show up in any part of the chain. All the following are fine:
+
+```ts
+z.string().describe('...').optional()
+z.string().optional().describe('...')
+z.string().min(1).describe('...').optional()
+```
+
 ## Recipes
 
 ### Optional Argument With Default Behavior
diff --git a/packages/@molt/command/examples/intro.ts b/packages/@molt/command/examples/intro.ts
index 76d86910..e22da9d0 100644
--- a/packages/@molt/command/examples/intro.ts
+++ b/packages/@molt/command/examples/intro.ts
@@ -1,12 +1,12 @@
+import { Zod } from '../src/extensions/zod/zod.js'
 import { Command } from '../src/index.js'
 import { z } from 'zod'
 
 const args = await Command.create()
+  .use(Zod)
   .parameter(`filePath`, z.string().describe(`Path to the file to convert.`))
   .parameter(`to`, z.enum([`json`, `yaml`, `toml`]).describe(`Format to convert to.`))
-  .parameter(`from`, {
-    schema: z.enum([`json`, `yaml`, `toml`]).optional(),
-  })
+  .parameter(`from`, z.enum([`json`, `yaml`, `toml`]).optional())
   .parameter(
     `verbose v`,
     z.boolean().default(false).describe(`Log detailed progress as conversion executes.`),
diff --git a/packages/@molt/command/examples/kitchen-sink.ts b/packages/@molt/command/examples/kitchen-sink.ts
index 5089211a..5e66cf8d 100644
--- a/packages/@molt/command/examples/kitchen-sink.ts
+++ b/packages/@molt/command/examples/kitchen-sink.ts
@@ -1,7 +1,9 @@
+import { Zod } from '../src/_entrypoints/extensions.js'
 import { Command } from '../src/index.js'
 import { z } from 'zod'
 
 const args = Command.create()
+  .use(Zod)
   .description(
     `This is a so-called "kitchen-sink" Molt Command example. Many features are demonstrated here though the overall CLI itself makes no sense. Take a look around, see how the help renders, try running with different inputs, etc.`,
   )
diff --git a/packages/@molt/command/examples/prompt.ts b/packages/@molt/command/examples/prompt.ts
index 13131431..87f4670f 100644
--- a/packages/@molt/command/examples/prompt.ts
+++ b/packages/@molt/command/examples/prompt.ts
@@ -1,7 +1,9 @@
+import { Zod } from '../src/_entrypoints/extensions.js'
 import { Command } from '../src/index.js'
 import { z } from 'zod'
 
 const args = await Command.create()
+  .use(Zod)
   // required
   .parameter(`alpha`, z.string())
   .parameter(`bravo`, z.number())
diff --git a/packages/@molt/command/examples/publish.ts b/packages/@molt/command/examples/publish.ts
index 72e5cbca..8b6f749a 100644
--- a/packages/@molt/command/examples/publish.ts
+++ b/packages/@molt/command/examples/publish.ts
@@ -1,8 +1,10 @@
+import { Zod } from '../src/_entrypoints/extensions.js'
 import { Command } from '../src/index.js'
 import semverRegex from 'semver-regex'
 import { z } from 'zod'
 
 const args = Command.create()
+  .use(Zod)
   .parameter(`githubToken`, z.string())
   .parameter(`publish`, z.boolean().default(true))
   .parameter(`githubRelease`, z.boolean().default(true))
diff --git a/packages/@molt/command/package.json b/packages/@molt/command/package.json
index 877962e5..38f31d04 100644
--- a/packages/@molt/command/package.json
+++ b/packages/@molt/command/package.json
@@ -36,7 +36,7 @@
     },
     "./types": {
       "import": {
-        "types": "./build/esm/entrypoints/types.d.ts"
+        "types": "./build/esm/_entrypoints/types.d.ts"
       }
     }
   },
diff --git a/packages/@molt/command/src/Command/State.ts b/packages/@molt/command/src/Command/State.ts
deleted file mode 100644
index de214747..00000000
--- a/packages/@molt/command/src/Command/State.ts
+++ /dev/null
@@ -1,173 +0,0 @@
-import type { CommandParameter } from '../CommandParameter/index.js'
-import type { Values } from '../helpers.js'
-import type { Type } from '../Type/index.js'
-import type { TypeAdaptors } from '../TypeAdaptors/index.js'
-import type { ExclusiveParameterConfiguration } from './exclusive/types.js'
-import type { ParameterConfiguration } from './root/types.js'
-import type { Name } from '@molt/types'
-import type { Simplify } from 'type-fest'
-
-export namespace State {
-  export interface BaseEmpty extends Base {
-    IsPromptEnabled: false
-    ParametersExclusive: {} // eslint-disable-line
-    Parameters: {} // eslint-disable-line
-  }
-
-  export type Base = {
-    IsPromptEnabled: boolean
-    ParametersExclusive: {
-      [label: string]: {
-        Optional: boolean
-        Parameters: {
-          [canonicalName: string]: {
-            NameParsed: Name.Data.NameParsed
-            NameUnion: string
-            Type: Type.Type
-            Schema: CommandParameter.SomeBasicType
-          }
-        }
-      }
-    }
-    Parameters: {
-      [nameExpression: string]: {
-        NameParsed: Name.Data.NameParsed
-        NameUnion: string
-        Type: Type.Type
-        Schema: CommandParameter.SomeBasicType
-      }
-    }
-  }
-
-  type ReservedParameterNames = 'help' | 'h'
-
-  // prettier-ignore
-  export type ValidateNameExpression<State extends Base, NameExpression extends string> = 
-    Name.Data.IsParseError<Name.Parse<NameExpression, { usedNames: GetUsedNames<State>; reservedNames: ReservedParameterNames }>> extends true
-        ? Name.Parse<NameExpression, { usedNames: GetUsedNames<State>; reservedNames: ReservedParameterNames }>
-        : NameExpression
-
-  export type GetUsedNames<State extends Base> = Values<State['Parameters']>['NameUnion']
-
-  // // prettier-ignore
-  // export type AddParameter<
-  //   State extends Base,
-  //   NameExpression extends string,
-  //   Configuration extends ParameterConfiguration
-  // > =
-  //   Omit<State, 'Parameters'> & {
-  //     Parameters:  State['Parameters'] & { [_ in NameExpression]: CreateParameter<State,NameExpression,Configuration> }
-  //   }
-
-  export type ParametersSchemaObjectBase = Record<string, ParameterConfiguration['schema']>
-
-  export type ParametersConfigBase = Record<
-    string,
-    {
-      schema: ParameterConfiguration['schema']
-      prompt?: CommandParameter.Input.Prompt<any>
-    }
-  >
-
-  // prettier-ignore
-  export type SetExclusiveOptional<
-    State extends Base,
-    Label extends string,
-    Value extends boolean,
-  > = {
-    IsPromptEnabled: State['IsPromptEnabled']
-    Parameters: State['Parameters']
-    ParametersExclusive: Omit<State['ParametersExclusive'], Label> & 
-      {
-        [_ in Label]: {
-          Optional: Value 
-          Parameters: State['ParametersExclusive'][_]['Parameters']
-        }
-      }
-  }
-  // prettier-ignore
-  export type AddExclusiveParameter<
-    State extends Base,
-    Label extends string,
-    NameExpression extends string,
-    Configuration extends ExclusiveParameterConfiguration
-  > =
-    MergeIntoProperty<State, 'ParametersExclusive', {
-      [_ in Label]: {
-        Optional: State['ParametersExclusive'][_]['Optional']
-        Parameters: {
-          [_ in NameExpression as Name.Data.GetCanonicalNameOrErrorFromParseResult<Name.Parse<NameExpression>>]: {
-            Schema: Configuration['schema']
-            Type: TypeAdaptors.Zod.FromZod<Configuration['schema']>
-            NameParsed: Name.Parse<NameExpression, { usedNames: GetUsedNames<State>; reservedNames: ReservedParameterNames }>
-            NameUnion: Name.Data.GetNamesFromParseResult<
-              Name.Parse<NameExpression, { usedNames: GetUsedNames<State>; reservedNames: ReservedParameterNames }>
-            >
-          }
-
-        }
-      }
-    }>
-
-  // prettier-ignore
-  export type CreateParameter<
-    State           extends Base,
-    NameExpression  extends string,
-    Configuration   extends ParameterConfiguration,
-  > = {
-    Schema: Configuration['schema']
-    Type: TypeAdaptors.Zod.FromZod<Configuration['schema']>
-    NameParsed: Name.Parse<NameExpression, { usedNames: GetUsedNames<State>; reservedNames: ReservedParameterNames }>
-    NameUnion: Name.Data.GetNamesFromParseResult<Name.Parse<NameExpression,{ usedNames: GetUsedNames<State>; reservedNames: ReservedParameterNames }>>
-  }
-
-  // prettier-ignore
-  export type ToArgs<State extends Base> =
-    State['IsPromptEnabled'] extends true
-      ? Promise<ToArgs_<State>>
-      : ToArgs_<State>
-
-  // prettier-ignore
-  type ToArgs_<State extends Base> =
-    Simplify<
-      {
-        [Name in keyof State['Parameters'] & string as State['Parameters'][Name]['NameParsed']['canonical']]:
-          Type.Infer<State['Parameters'][Name]['Type']>
-      } &
-      {
-        [Label in keyof State['ParametersExclusive'] & string]:
-          | Simplify<Values<{
-              [Name in keyof State['ParametersExclusive'][Label]['Parameters']]:
-                {
-                  _tag: State['ParametersExclusive'][Label]['Parameters'][Name]['NameParsed']['canonical']
-                  value: Type.Infer<State['ParametersExclusive'][Label]['Parameters'][Name]['Type']>
-                }
-            }>>
-          | (State['ParametersExclusive'][Label]['Optional'] extends true ? undefined : never)
-      }
-    >
-
-  // prettier-ignore
-  export type ToSchema<Spec extends State.Base> = {
-    [K in keyof Spec['Parameters'] & string as Spec['Parameters'][K]['NameParsed']['canonical']]:
-      Spec['Parameters'][K]['Schema']
-  }
-}
-
-/**
- * @see https://stackoverflow.com/questions/50374908/transform-union-type-to-intersection-type
- */
-// eslint-disable-next-line
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void
-  ? I
-  : never
-
-type SetProperty<Obj extends object, PropertyName extends keyof Obj, Value> = Omit<Obj, PropertyName> & {
-  [P in PropertyName]: Value
-}
-
-type MergeIntoProperty<Obj extends object, PropertyName extends keyof Obj, Value> = SetProperty<
-  Obj,
-  PropertyName,
-  Obj[PropertyName] & Value
->
diff --git a/packages/@molt/command/src/Command/exclusive/constructor.ts b/packages/@molt/command/src/Command/exclusive/constructor.ts
deleted file mode 100644
index 28e257f2..00000000
--- a/packages/@molt/command/src/Command/exclusive/constructor.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import type { CommandParameter } from '../../CommandParameter/index.js'
-import type { Pam } from '../../lib/Pam/index.js'
-import type { InternalState, SomeBuilderExclusiveInitial } from './types.js'
-
-export const create = (): SomeBuilderExclusiveInitial => {
-  const _: InternalState = {
-    input: {
-      _tag: `Exclusive`,
-      optionality: { _tag: `required` },
-      parameters: [],
-    } satisfies CommandParameter.Input.Exclusive,
-    typeState: undefined as any, // eslint-disable-line
-  }
-
-  const chain: SomeBuilderExclusiveInitial = {
-    parameter: (nameExpression: string, schemaOrConfiguration) => {
-      const configuration =
-        `schema` in schemaOrConfiguration ? schemaOrConfiguration : { schema: schemaOrConfiguration }
-      _.input.parameters.push({ nameExpression, type: configuration.schema })
-      return chain as any // eslint-disable-line
-    },
-    optional: () => {
-      _.input.optionality = { _tag: `optional` }
-      return chain
-    },
-    default: (tag: string, value: Pam.Value) => {
-      _.input.optionality = { _tag: `default`, tag, value }
-      return chain
-    },
-    _,
-  }
-
-  return chain
-}
diff --git a/packages/@molt/command/src/Command/exclusive/types.ts b/packages/@molt/command/src/Command/exclusive/types.ts
deleted file mode 100644
index 276b20e0..00000000
--- a/packages/@molt/command/src/Command/exclusive/types.ts
+++ /dev/null
@@ -1,65 +0,0 @@
-import type { CommandParameter } from '../../CommandParameter/index.js'
-import type { TypeAdaptors } from '../../TypeAdaptors/index.js'
-import type { RawArgInputs } from '../root/types.js'
-import type { State } from '../State.js'
-import type { z } from 'zod'
-
-export interface ExclusiveParameterConfiguration {
-  schema: CommandParameter.SomeExclusiveZodType
-}
-
-// prettier-ignore
-interface Parameter<State extends State.Base, Label extends string> {
-  <NameExpression extends string, Configuration extends ExclusiveParameterConfiguration   >(name: State.ValidateNameExpression<State, NameExpression>, configuration: Configuration): BuilderExclusiveInitial<State.AddExclusiveParameter<State, Label, NameExpression, Configuration>, Label>
-  <NameExpression extends string, Schema        extends CommandParameter.SomeExclusiveZodType>(name: State.ValidateNameExpression<State, NameExpression>, schema: Schema              ): BuilderExclusiveInitial<State.AddExclusiveParameter<State, Label, NameExpression, {schema:Schema,type:TypeAdaptors.Zod.FromZod<Schema>}>, Label>
-}
-
-/**
- * This property is present to support internal functions. It is not intended to be used by you.
- */
-export type InternalState<State extends State.Base = State.Base> = {
-  /**
-   * Used for build time. Type inference functionality.
-   */
-  typeState: State
-  /**
-   * Used for runtime.
-   */
-  input: CommandParameter.Input.Exclusive
-}
-
-// prettier-ignore
-export interface BuilderExclusiveInitial<State extends State.Base, Label extends string> {
-  _:         InternalState<State>
-  parameter: Parameter<State,Label>
-  optional:  () => BuilderExclusiveAfterOptional<State.SetExclusiveOptional<State, Label, true>>
-  default:  <Tag extends keyof State['ParametersExclusive'][Label]['Parameters']>(tag: Tag, value: z.infer<State['ParametersExclusive'][Label]['Parameters'][Tag]['Schema']>) => BuilderExclusiveAfterDefault<State.SetExclusiveOptional<State,Label,false>>
-}
-
-export type BuilderExclusiveAfterOptional<State extends State.Base> = {
-  _: InternalState<State>
-}
-
-export type BuilderExclusiveAfterDefault<State extends State.Base> = {
-  _: InternalState<State>
-}
-
-export interface BuilderAfterSettings<Spec extends State.Base> {
-  parse: (inputs?: RawArgInputs) => State.ToArgs<Spec>
-}
-
-export interface SomeParameter {
-  (nameExpression: any, type: CommandParameter.SomeExclusiveZodType): any // eslint-disable-line
-  (nameExpression: any, configuration: ExclusiveParameterConfiguration): any // eslint-disable-line
-}
-
-export type SomeBuilderExclusiveInitial = {
-  _: any // eslint-disable-line
-  parameter: SomeParameter
-  optional: any // eslint-disable-line
-  default: (tag: any, value: any) => any // eslint-disable-line
-}
-
-export type SomeBuilderMutuallyExclusiveAfterOptional = BuilderExclusiveAfterOptional<State.Base>
-
-export type SomeBuilderExclusive = SomeBuilderExclusiveInitial | SomeBuilderMutuallyExclusiveAfterOptional
diff --git a/packages/@molt/command/src/Command/root/constructor.ts b/packages/@molt/command/src/Command/root/constructor.ts
deleted file mode 100644
index 915f2911..00000000
--- a/packages/@molt/command/src/Command/root/constructor.ts
+++ /dev/null
@@ -1,92 +0,0 @@
-import type { CommandParameter } from '../../CommandParameter/index.js'
-import { parse } from '../../executor/parse.js'
-import { getLowerCaseEnvironment, lowerCaseObjectKeys } from '../../helpers.js'
-import { Settings } from '../../Settings/index.js'
-import { TypeAdaptors } from '../../TypeAdaptors/index.js'
-import * as ExclusiveBuilder from '../exclusive/constructor.js'
-import type { ParameterConfiguration, RawArgInputs, RootBuilder } from './types.js'
-
-export const create = (): RootBuilder => {
-  const $: State = {
-    newSettingsBuffer: [],
-    settings: null,
-    parameterSpecInputs: {},
-  }
-
-  const $$ = {
-    addParameterBasic: (nameExpression: string, configuration: ParameterConfiguration) => {
-      const prompt = configuration.prompt ?? null
-      const parameter = {
-        _tag: `Basic`,
-        type: configuration.schema,
-        nameExpression: nameExpression,
-        prompt,
-      } satisfies CommandParameter.Input.Basic
-      $.parameterSpecInputs[nameExpression] = parameter
-    },
-  }
-
-  const chain: InternalRootBuilder = {
-    description: (description) => {
-      $.newSettingsBuffer.push({
-        description,
-      })
-      return chain
-    },
-    settings: (newSettings) => {
-      $.newSettingsBuffer.push(newSettings)
-      return chain
-    },
-    parameter: (nameExpression, typeOrConfiguration) => {
-      const configuration =
-        `schema` in typeOrConfiguration
-          ? typeOrConfiguration
-          : { schema: typeOrConfiguration, type: TypeAdaptors.Zod.fromZod(typeOrConfiguration) }
-      $$.addParameterBasic(nameExpression, configuration)
-
-      return chain
-    },
-    parametersExclusive: (label, builderContainer) => {
-      $.parameterSpecInputs[label] = builderContainer(ExclusiveBuilder.create() as any)._.input // eslint-disable-line
-      return chain
-    },
-    parse: (argInputs) => {
-      const argInputsEnvironment = argInputs?.environment
-        ? lowerCaseObjectKeys(argInputs.environment)
-        : getLowerCaseEnvironment()
-      $.settings = {
-        ...Settings.getDefaults(argInputsEnvironment),
-      }
-      $.newSettingsBuffer.forEach((newSettings) =>
-        Settings.change($.settings!, newSettings, argInputsEnvironment),
-      )
-      return parse($.settings, $.parameterSpecInputs, argInputs)
-    },
-  }
-
-  return chain as any
-}
-
-//
-// Internal Types
-//
-
-interface State {
-  settings: null | Settings.Output
-  newSettingsBuffer: Settings.Input[]
-  parameterSpecInputs: Record<string, CommandParameter.Input>
-}
-
-interface Parameter {
-  (nameExpression: string, type: CommandParameter.SomeBasicType): InternalRootBuilder
-  (nameExpression: string, configuration: ParameterConfiguration): InternalRootBuilder
-}
-
-// prettier-ignore
-interface InternalRootBuilder {
-  description: (description: string) => InternalRootBuilder
-  settings: (newSettings: Settings.Input) => InternalRootBuilder
-  parameter: Parameter
-  parametersExclusive: (label: string, builderContainer: any) => InternalRootBuilder
-  parse: (args: RawArgInputs) => object
-}
diff --git a/packages/@molt/command/src/Command/root/types.ts b/packages/@molt/command/src/Command/root/types.ts
deleted file mode 100644
index c9de0b24..00000000
--- a/packages/@molt/command/src/Command/root/types.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-import type { CommandParameter } from '../../CommandParameter/index.js'
-import type { Prompter } from '../../lib/Prompter/Prompter.js'
-import type { OpeningArgs } from '../../OpeningArgs/index.js'
-import type { Settings } from '../../Settings/index.js'
-import type { TypeAdaptors } from '../../TypeAdaptors/index.js'
-import type {
-  BuilderAfterSettings,
-  BuilderExclusiveInitial,
-  SomeBuilderExclusive,
-} from '../exclusive/types.js'
-// eslint-disable-next-line
-import { State } from '../State.js'
-
-export type Schema = CommandParameter.SomeBasicType | CommandParameter.SomeUnionType
-
-export interface ParameterConfiguration {
-  schema: Schema
-  prompt?: CommandParameter.Input.Prompt<TypeAdaptors.Zod.FromZod<this['schema']>>
-}
-
-export type IsHasKey<Obj extends object, Key> = Key extends keyof Obj ? true : false
-
-// prettier-ignore
-export type IsPromptEnabledInParameterSettings<P extends ParameterConfiguration> =
-  IsHasKey<P,'prompt'>                                      extends false     ? false :
-                                                                                IsPromptEnabled<P['prompt']>
-// prettier-ignore
-export type IsPromptEnabledInCommandSettings<P extends Settings.Input<any>> =
-  IsHasKey<P,'prompt'>                                      extends false     ? false :
-                                                                                IsPromptEnabled<P['prompt']>
-
-// prettier-ignore
-export type IsPromptEnabled<P extends CommandParameter.Input.Prompt<any>|undefined> =
-  P                                               extends undefined ? false :
-  P                                               extends false     ? false :
-  P                                               extends true      ? true  :
-  P                                               extends null      ? false :
-  Exclude<P, undefined|boolean|null>['enabled']   extends false     ? false :
-                                                                      true
-
-// prettier-ignore
-export interface RootBuilder<State extends State.Base = State.BaseEmpty> {
-  s: State
-  description                                                                                     (this:void, description:string):
-    RootBuilder<State>
-  parameter<NameExpression extends string, const Configuration extends ParameterConfiguration>    (this:void, name:State.ValidateNameExpression<State,NameExpression>, configuration:Configuration):
-    RootBuilder<{
-      IsPromptEnabled    : State['IsPromptEnabled'] extends true ? true : IsPromptEnabledInParameterSettings<Configuration>
-      ParametersExclusive: State['ParametersExclusive']
-      Parameters         : State['Parameters'] & { [_ in NameExpression]: State.CreateParameter<State,NameExpression,Configuration> }
-    }>
-  parameter<NameExpression extends string, S extends Schema>                                (this:void, name:State.ValidateNameExpression<State,NameExpression>, schema:S):
-    RootBuilder<{
-      IsPromptEnabled    : State['IsPromptEnabled']
-      ParametersExclusive: State['ParametersExclusive']
-      Parameters         : State['Parameters'] & { [_ in NameExpression]: State.CreateParameter<State,NameExpression,{schema:S;type:TypeAdaptors.Zod.FromZod<S>}> }
-    }>
-  parametersExclusive<Label extends string, BuilderExclusive extends SomeBuilderExclusive>  (this:void, label:Label, ExclusiveBuilderContainer: (builder:BuilderExclusiveInitial<State,Label>) => BuilderExclusive):
-    RootBuilder<BuilderExclusive['_']['typeState']>
-  settings                                                                                  <S extends Settings.Input<State.ToSchema<State>>>(this:void, newSettings:S):
-    BuilderAfterSettings<{
-      IsPromptEnabled    : State['IsPromptEnabled'] extends true ? true : IsPromptEnabledInCommandSettings<S>
-      ParametersExclusive: State['ParametersExclusive']
-      Parameters         : State['Parameters']
-    }>
-  parse                                                                                     (this:void, inputs?:RawArgInputs):
-    State.ToArgs<State>
-}
-
-export type RawArgInputs = {
-  line?: OpeningArgs.Line.RawInputs
-  environment?: OpeningArgs.Environment.RawInputs
-  tty?: Prompter
-}
-
-export type SomeArgsNormalized = Record<string, unknown>
diff --git a/packages/@molt/command/src/CommandParameter/CommandParameter.ts b/packages/@molt/command/src/CommandParameter/CommandParameter.ts
deleted file mode 100644
index 263aebee..00000000
--- a/packages/@molt/command/src/CommandParameter/CommandParameter.ts
+++ /dev/null
@@ -1,84 +0,0 @@
-export * from './input.js'
-export * from './output.js'
-export * from './processor/process.js'
-export * from './types.js'
-import { stripeNegatePrefix } from '../helpers.js'
-import type { Type } from '../Type/index.js'
-import type { ValidationResult } from '../Type/Type.js'
-import type { Output } from './output.js'
-import { Either } from 'effect'
-
-export const validate = <T>(parameter: Output.Basic, value: unknown): ValidationResult<T> => {
-  if (parameter.type.optionality._tag === `optional` && value === undefined) return Either.right(value as T)
-  return parameter.type.validate(value)
-}
-
-export const findByName = (name: string, specs: Output[]): null | Output => {
-  for (const spec of specs) {
-    const result = hasName(spec, name)
-    if (result !== null) return spec
-  }
-  return null
-}
-/**
- * Get all the names of a parameter in array form.
- */
-export const getNames = (spec: Output): [string, ...string[]] => {
-  return [
-    ...spec.name.aliases.long,
-    ...spec.name.aliases.short,
-    ...(spec.name.long === null ? [] : [spec.name.long]),
-    ...(spec.name.short === null ? [] : [spec.name.short]),
-  ] as [string, ...string[]]
-}
-
-type NameHit =
-  | {
-      kind: 'long' | 'longAlias'
-      /**
-       * Was the given name in negated format? e.g. noFoo instead of foo
-       */
-      negated: boolean
-    }
-  | {
-      kind: 'short' | 'shortAlias'
-    }
-
-/**
- * Is one of the parameter's names the given name?
- */
-export const hasName = (spec: Output, name: string): null | NameHit => {
-  const result = parameterSpecHasNameDo(spec, name, false)
-
-  if (isOrHasType(spec, `TypeBoolean`)) {
-    const nameWithoutNegatePrefix = stripeNegatePrefix(name)
-    if (nameWithoutNegatePrefix) {
-      return parameterSpecHasNameDo(spec, nameWithoutNegatePrefix, true)
-    }
-  }
-
-  return result
-}
-
-export const isOrHasType = (spec: Output, typeTag: Type.Type['_tag']): boolean => {
-  return spec.type._tag === `TypeUnion`
-    ? (spec.type as Type.Union).members.find((_) => _._tag === typeTag) !== undefined
-    : spec.type._tag === typeTag
-}
-
-const parameterSpecHasNameDo = (
-  spec: Output,
-  name: string,
-  negated: boolean,
-): null | { kind: 'long' | 'longAlias'; negated: boolean } | { kind: 'short' | 'shortAlias' } => {
-  return spec.name.long === name
-    ? { kind: `long`, negated }
-    : spec.name.aliases.long.includes(name)
-    ? { kind: `longAlias`, negated }
-    : // Short names cannot be negated currently so short circuit with the negated check.
-    spec.name.short === name
-    ? { kind: `short` }
-    : spec.name.aliases.short.includes(name)
-    ? { kind: `shortAlias` }
-    : null
-}
diff --git a/packages/@molt/command/src/CommandParameter/index.ts b/packages/@molt/command/src/CommandParameter/index.ts
deleted file mode 100644
index 41c963aa..00000000
--- a/packages/@molt/command/src/CommandParameter/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export * as CommandParameter from './CommandParameter.js'
diff --git a/packages/@molt/command/src/CommandParameter/input.ts b/packages/@molt/command/src/CommandParameter/input.ts
deleted file mode 100644
index 1beeb100..00000000
--- a/packages/@molt/command/src/CommandParameter/input.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-import type { EventPatternsInput } from '../eventPatterns.js'
-import type { Pam } from '../lib/Pam/index.js'
-import type { Type } from '../Type/index.js'
-import type { TypeAdaptors } from '../TypeAdaptors/index.js'
-import type { SomeBasicType, SomeExclusiveZodType, SomeUnionType } from './types.js'
-
-export type Input = Input.Basic | Input.Exclusive
-
-export namespace Input {
-  export type Schema = SomeBasicType | SomeUnionType
-
-  export type Prompt<T extends Type.Type> =
-    | null
-    | boolean
-    | {
-        enabled?: boolean
-        when?: EventPatternsInput<T>
-      }
-
-  export interface Basic {
-    _tag: 'Basic'
-    nameExpression: string
-    type: SomeBasicType | SomeUnionType
-    prompt: Prompt<TypeAdaptors.Zod.FromZod<SomeBasicType>>
-  }
-
-  export interface Exclusive {
-    _tag: 'Exclusive'
-    optionality:
-      | { _tag: 'required' }
-      | { _tag: 'optional' }
-      | { _tag: 'default'; tag: string; value: Pam.Value | (() => Pam.Value) }
-    description?: string
-    parameters: {
-      nameExpression: string
-      type: SomeExclusiveZodType
-    }[]
-  }
-}
diff --git a/packages/@molt/command/src/CommandParameter/output.ts b/packages/@molt/command/src/CommandParameter/output.ts
index 43d39fd1..dff29f5e 100644
--- a/packages/@molt/command/src/CommandParameter/output.ts
+++ b/packages/@molt/command/src/CommandParameter/output.ts
@@ -1,55 +1,23 @@
-import type { EventPatternsInput } from '../eventPatterns.js'
-import type { Pam } from '../lib/Pam/index.js'
-import type { Type } from '../Type/index.js'
-import type { Name as MoltName } from '@molt/types'
+// import type { EventPatternsInput } from '../eventPatterns.js'
+// import type { Pam } from '../lib/Pam/index.js'
+// import type { Type } from '../Type/index.js'
+// import type { Name as MoltName } from '@molt/types'
 
-export type Output = Output.Exclusive | Output.Basic //| Output.Union
+// export type Output = Output.Exclusive | Output.Basic //| Output.Union
 
-export namespace Output {
-  export type Prompt<T extends Type.Type = Type.Type> = {
-    enabled: boolean | null
-    when: EventPatternsInput<T> | null
-  }
+// export namespace Output {
+//   export type Prompt<T extends Type.Type = Type.Type> = {
+//     enabled: boolean | null
+//     when: EventPatternsInput<T> | null
+//   }
 
-  export interface Basic extends Omit<Pam.Parameter, '_tag'> {
-    _tag: 'Basic'
-    environment: Environment
-    prompt: Prompt
-  }
+//   // prettier-ignore
+//   type BasicOptionality =
+//     | { _tag: 'required' }
+//     | { _tag: 'optional' }
+//     | { _tag: 'default', getValue: () => Pam.Value }
 
-  export type BasicData = Omit<Basic, '_tag' | 'optionality'> & {
-    _tag: 'BasicData'
-    optionality: BasicOptionality['_tag']
-  }
+//   export type Environment = null | { enabled: boolean; namespaces: string[] }
 
-  export interface Exclusive {
-    _tag: 'Exclusive'
-    name: Name
-    type: Type.Type
-    description: string | null
-    environment: Environment
-    group: ExclusiveGroup
-  }
-
-  // prettier-ignore
-  export type BasicOptionality = 
-    | { _tag: 'required' }
-    | { _tag: 'optional' }
-    | { _tag: 'default', getValue: () => Pam.Value }
-
-  export type ExclusiveOptionality =
-    | { _tag: 'required' }
-    | { _tag: 'optional' }
-    | { _tag: 'default'; tag: string; getValue: () => Pam.Value }
-
-  export type Environment = null | { enabled: boolean; namespaces: string[] }
-
-  export type Name = MoltName.Data.NameParsed
-
-  export interface ExclusiveGroup {
-    // _tag: 'Exclusive'
-    label: string
-    optionality: ExclusiveOptionality
-    parameters: Record<string, Exclusive>
-  }
-}
+//   export type Name = MoltName.Data.NameParsed
+// }
diff --git a/packages/@molt/command/src/CommandParameter/processor/parameterTypes/basic.ts b/packages/@molt/command/src/CommandParameter/processor/parameterTypes/basic.ts
deleted file mode 100644
index c824b7f3..00000000
--- a/packages/@molt/command/src/CommandParameter/processor/parameterTypes/basic.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import type { Settings } from '../../../index.js'
-import { TypeAdaptors } from '../../../TypeAdaptors/index.js'
-import type { Input } from '../../input.js'
-import type { Output } from '../../output.js'
-import { processEnvironment } from '../helpers/environment.js'
-import { Name } from '@molt/types'
-
-export const processBasic = (
-  expression: string,
-  input: Input.Basic,
-  settings: Settings.Output,
-): Output.Basic => {
-  const name = Name.parse(expression)
-  const environment = processEnvironment(settings, name)
-  const type = TypeAdaptors.Zod.fromZod(input.type)
-  const parameter = {
-    _tag: `Basic`,
-    environment,
-    name,
-    prompt: {
-      enabled:
-        input.prompt === true
-          ? true
-          : input.prompt === false
-          ? false
-          : input.prompt === null
-          ? null
-          : input.prompt.enabled ?? null,
-      when:
-        input.prompt === null ? null : typeof input.prompt === `object` ? input.prompt.when ?? null : null,
-    },
-    type,
-  } satisfies Output.Basic
-
-  return parameter
-}
diff --git a/packages/@molt/command/src/CommandParameter/processor/parameterTypes/exclusive.ts b/packages/@molt/command/src/CommandParameter/processor/parameterTypes/exclusive.ts
deleted file mode 100644
index 929968af..00000000
--- a/packages/@molt/command/src/CommandParameter/processor/parameterTypes/exclusive.ts
+++ /dev/null
@@ -1,56 +0,0 @@
-import type { Settings } from '../../../index.js'
-import { TypeAdaptors } from '../../../TypeAdaptors/index.js'
-import type { Input } from '../../input.js'
-import type { Output } from '../../output.js'
-import { processEnvironment } from '../helpers/environment.js'
-import { Name } from '@molt/types'
-import { Alge } from 'alge'
-
-export const processExclusive = (
-  label: string,
-  input: Input.Exclusive,
-  settings: Settings.Output,
-): Output.Exclusive[] => {
-  const parameters = input.parameters.map((_) => {
-    const name = Name.parse(_.nameExpression)
-    const environment = processEnvironment(settings, name)
-    const type = TypeAdaptors.Zod.fromZod(_.type)
-    const parameter = {
-      _tag: `Exclusive`,
-      description: type.description,
-      type,
-      environment,
-      name,
-      // See comment/code below: (1)
-      group: null as any, // eslint-disable-line
-    } satisfies Output.Exclusive
-    return parameter
-  })
-
-  /**
-   * (1) Link up the group to each value and vice versa. Cannot do this in the above constructor since
-   * it would create a copy of group for each value.
-   */
-  const group: Output.ExclusiveGroup = {
-    label,
-    // Input exclusive default allows default to be value or thunk,
-    // while output is always thunk.
-    optionality: Alge.match(input.optionality)
-      .default(
-        (_): Output.ExclusiveOptionality => ({
-          _tag: `default`,
-          tag: _.tag,
-          getValue: () => (typeof _.value === `function` ? _.value() : _.value),
-        }),
-      )
-      .else((_) => _),
-    parameters: {},
-  }
-
-  parameters.forEach((_) => {
-    _.group = group
-    group.parameters[_.name.canonical] = _
-  })
-
-  return parameters
-}
diff --git a/packages/@molt/command/src/CommandParameter/processor/process.ts b/packages/@molt/command/src/CommandParameter/processor/process.ts
deleted file mode 100644
index 2cdc8eed..00000000
--- a/packages/@molt/command/src/CommandParameter/processor/process.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-import type { Settings } from '../../Settings/index.js'
-import type { Input } from '../input.js'
-import type { Output } from '../output.js'
-import { processBasic } from './parameterTypes/basic.js'
-import { processExclusive } from './parameterTypes/exclusive.js'
-import { Alge } from 'alge'
-import { z } from 'zod'
-
-/**
- * Process the spec input into a normalized spec.
- */
-export const process = (inputs: Record<string, Input>, settings: Settings.Output): Output[] => {
-  const inputsWithHelp: Record<string, Input> = settings.help
-    ? {
-        ...inputs,
-        '-h --help': helpParameter,
-      }
-    : inputs
-  const outputs = Object.entries(inputsWithHelp).flatMap(([expression, input]): Output[] =>
-    Alge.match(input)
-      .Basic((_) => [processBasic(expression, _, settings)])
-      .Exclusive((_) => processExclusive(expression, _, settings))
-      .done(),
-  )
-
-  // dump({ outputs })
-  return outputs
-}
-
-const helpParameter: Input.Basic = {
-  _tag: `Basic`,
-  type: z.boolean().default(false),
-  nameExpression: `-h --help`,
-  prompt: false,
-}
diff --git a/packages/@molt/command/src/Errors/Errors.ts b/packages/@molt/command/src/Errors/Errors.ts
index d37fcbdf..56e303bb 100644
--- a/packages/@molt/command/src/Errors/Errors.ts
+++ b/packages/@molt/command/src/Errors/Errors.ts
@@ -1,5 +1,6 @@
-import type { CommandParameter } from '../CommandParameter/index.js'
 import type { OpeningArgs } from '../OpeningArgs/index.js'
+import type { ParameterExclusive, ParameterExclusiveGroup } from '../Parameter/exclusive.js'
+import type { Parameter } from '../Parameter/types.js'
 
 export namespace Global {
   export class ErrorUnknownParameterViaEnvironment extends Error {
@@ -23,8 +24,8 @@ export namespace Global {
 
 export class ErrorDuplicateLineArg extends Error {
   public override name: 'ErrorDuplicateFlag' = `ErrorDuplicateFlag`
-  public parameter: CommandParameter.Output
-  constructor(params: { parameter: CommandParameter.Output; flagName: string }) {
+  public parameter: Parameter
+  constructor(params: { parameter: Parameter; flagName: string }) {
     const message = `The parameter "${params.flagName}" was passed an argument multiple times via flags.`
     super(message)
     this.parameter = params.parameter
@@ -33,10 +34,10 @@ export class ErrorDuplicateLineArg extends Error {
 
 export class ErrorDuplicateEnvArg extends Error {
   public override name: 'ErrorDuplicateEnvArg' = `ErrorDuplicateEnvArg`
-  public parameter: CommandParameter.Output
+  public parameter: Parameter
   public instances: { value: string; name: string; prefix: string | null }[]
   constructor(params: {
-    parameter: CommandParameter.Output
+    parameter: Parameter
     instances: { value: string; name: string; prefix: string | null }[]
   }) {
     const message = `The parameter "${params.parameter.name.canonical}" was passed an argument multiple times via different parameter aliases in the environment.`
@@ -48,8 +49,8 @@ export class ErrorDuplicateEnvArg extends Error {
 
 export class ErrorFailedToGetDefaultArgument extends Error {
   public override name: 'ErrorFailedToGetDefaultArgument' = `ErrorFailedToGetDefaultArgument`
-  public spec: CommandParameter.Output
-  constructor(params: { spec: CommandParameter.Output; cause: Error }) {
+  public spec: Parameter
+  constructor(params: { spec: Parameter; cause: Error }) {
     const message = `Failed to get default value for ${params.spec.name.canonical}`
     super(message, { cause: params.cause })
     this.spec = params.spec
@@ -58,8 +59,8 @@ export class ErrorFailedToGetDefaultArgument extends Error {
 
 export class ErrorMissingArgument extends Error {
   public override name: 'ErrorMissingArgument' = `ErrorMissingArgument`
-  public spec: CommandParameter.Output
-  constructor(params: { parameter: CommandParameter.Output }) {
+  public spec: Parameter
+  constructor(params: { parameter: Parameter }) {
     const message = `Missing argument for flag "${params.parameter.name.canonical}".`
     super(message)
     this.spec = params.parameter
@@ -68,8 +69,8 @@ export class ErrorMissingArgument extends Error {
 
 export class ErrorMissingArgumentForMutuallyExclusiveParameters extends Error {
   public override name: 'ErrorMissingArgumentForMutuallyExclusiveParameters' = `ErrorMissingArgumentForMutuallyExclusiveParameters`
-  public group: CommandParameter.Output.ExclusiveGroup
-  constructor(params: { group: CommandParameter.Output.ExclusiveGroup }) {
+  public group: ParameterExclusiveGroup
+  constructor(params: { group: ParameterExclusiveGroup }) {
     const message = `Missing argument for one of the following parameters: ${Object.values(
       params.group.parameters,
     )
@@ -82,10 +83,8 @@ export class ErrorMissingArgumentForMutuallyExclusiveParameters extends Error {
 
 export class ErrorArgumentsToMutuallyExclusiveParameters extends Error {
   public override name: 'ErrorArgumentsToMutuallyExclusiveParameters' = `ErrorArgumentsToMutuallyExclusiveParameters`
-  public group: CommandParameter.Output.ExclusiveGroup
-  constructor(params: {
-    offenses: { spec: CommandParameter.Output.Exclusive; arg: OpeningArgs.Argument }[]
-  }) {
+  public group: ParameterExclusiveGroup
+  constructor(params: { offenses: { spec: ParameterExclusive; arg: OpeningArgs.Argument }[] }) {
     const message = `Arguments given to multiple mutually exclusive parameters: ${params.offenses
       .map((_) => _.spec.name.canonical)
       .join(`, `)}`
@@ -96,10 +95,10 @@ export class ErrorArgumentsToMutuallyExclusiveParameters extends Error {
 
 export class ErrorInvalidArgument extends Error {
   public override name: 'ErrorInvalidArgument' = `ErrorInvalidArgument`
-  public spec: CommandParameter.Output
+  public spec: Parameter
   public value: unknown
   constructor(params: {
-    spec: CommandParameter.Output
+    spec: Parameter
     environmentVariableName?: string
     validationErrors: string[]
     value: unknown
diff --git a/packages/@molt/command/src/Help/Help.ts b/packages/@molt/command/src/Help/Help.ts
index 97becb8d..5778df30 100644
--- a/packages/@molt/command/src/Help/Help.ts
+++ b/packages/@molt/command/src/Help/Help.ts
@@ -1,7 +1,7 @@
-import type { CommandParameter } from '../CommandParameter/index.js'
 import { groupBy } from '../lib/prelude.js'
 import { Tex } from '../lib/Tex/index.js'
 import { Text } from '../lib/Text/index.js'
+import type { Parameter } from '../Parameter/types.js'
 import type { Settings } from '../Settings/index.js'
 import { Term } from '../term.js'
 import chalk from 'chalk'
@@ -22,16 +22,12 @@ interface RenderSettings {
   color?: boolean
 }
 
-export const render = (
-  parameters_: CommandParameter.Output[],
-  settings: Settings.Output,
-  _settings?: RenderSettings,
-) => {
+export const render = (parameters_: Parameter[], settings: Settings.Output, _settings?: RenderSettings) => {
   const allParameters = parameters_
-  const specsWithDescription = allParameters.filter((_) => _.type.description !== null)
-  const specsByKind = groupBy(parameters_, `_tag`)
-  const basicSpecs = specsByKind.Basic ?? []
-  const allSpecsWithoutHelp = allParameters
+  const parametersWithDescription = allParameters.filter((_) => _.type.description !== null)
+  const parametersByTag = groupBy(parameters_, `_tag`)
+  const basicParameters = parametersByTag.Basic ?? []
+  const allParametersWithoutHelp = allParameters
     .filter((_) => _.name.canonical !== `help`)
     .sort((_) =>
       _._tag === `Exclusive`
@@ -43,30 +39,32 @@ export const render = (
         : -1,
     )
 
-  const basicAndUnionSpecsWithoutHelp = basicSpecs
+  const parametersBasicWithoutHelp = basicParameters
     .filter((_) => _.name.canonical !== `help`)
     .sort((_) => (_.type.optionality._tag === `optional` ? 1 : -1))
-  const isAcceptsAnyEnvironmentArgs = basicSpecs.filter((_) => _.environment?.enabled).length > 0
+  const isAcceptsAnyEnvironmentArgs = basicParameters.filter((_) => _.environment?.enabled).length > 0
   const isAcceptsAnyMutuallyExclusiveParameters =
-    (specsByKind.Exclusive && specsByKind.Exclusive.length > 0) || false
+    (parametersByTag.Exclusive && parametersByTag.Exclusive.length > 0) || false
   const isEnvironmentEnabled =
     Object.values(settings.parameters.environment).filter((_) => _.enabled).length > 0
 
   const columnTitles = {
     name: `Name`,
-    typeDescription: specsWithDescription.length > 0 ? `Type/Description` : `Type`,
+    typeDescription: parametersWithDescription.length > 0 ? `Type/Description` : `Type`,
     default: `Default`,
     environment: isEnvironmentEnabled ? `Environment (1)` : null,
   }
 
-  const mexGroups = Object.values(groupBy(specsByKind.Exclusive ?? [], (_) => _.group.label)).map(
+  const parametersExclusiveGroups = Object.values(
+    groupBy(parametersByTag.Exclusive ?? [], (_) => _.group.label),
+  ).map(
     (_) => _[0]!.group, // eslint-disable-line
   )
 
   const noteItems: (Tex.Block | string | null)[] = []
 
   if (isAcceptsAnyEnvironmentArgs) {
-    noteItems.push(environmentNote(allSpecsWithoutHelp, settings))
+    noteItems.push(environmentNote(allParametersWithoutHelp, settings))
   }
 
   if (isAcceptsAnyMutuallyExclusiveParameters) {
@@ -99,33 +97,35 @@ export const render = (
             columnTitles.environment ? chalk.underline(Term.colors.mute(columnTitles.environment)) : null,
           )
           .rows([
-            ...basicAndUnionSpecsWithoutHelp.map((spec) => [
-              parameterName(spec),
-              Tex.block({ maxWidth: 40, padding: { right: 9, bottom: 1 } }, spec.type.help(settings)),
-              Tex.block({ maxWidth: 24 }, parameterDefault(spec)),
-              ...(isEnvironmentEnabled ? [parameterEnvironment(spec, settings)] : []),
+            ...parametersBasicWithoutHelp.map((parameter) => [
+              parameterName(parameter),
+              Tex.block({ maxWidth: 40, padding: { right: 9, bottom: 1 } }, parameter.type.help(settings)),
+              Tex.block({ maxWidth: 24 }, parameterDefault(parameter)),
+              ...(isEnvironmentEnabled ? [parameterEnvironment(parameter, settings)] : []),
             ]),
-            ...mexGroups.flatMap((mexGroup) => {
+            ...parametersExclusiveGroups.flatMap((parametersExclusive) => {
               const default_ =
-                mexGroup.optionality._tag === `default`
-                  ? `${mexGroup.optionality.tag}@${String(mexGroup.optionality.getValue())}`
-                  : mexGroup.optionality._tag === `optional`
+                parametersExclusive.optionality._tag === `default`
+                  ? `${parametersExclusive.optionality.tag}@${String(
+                      parametersExclusive.optionality.getValue(),
+                    )}`
+                  : parametersExclusive.optionality._tag === `optional`
                   ? `undefined`
                   : labels.required
               return [
                 [
                   Tex.block(
                     { border: { left: Term.colors.dim(`┌`) } },
-                    Term.colors.dim(`─${mexGroup.label} ${`(2)`}`),
+                    Term.colors.dim(`─${parametersExclusive.label} ${`(2)`}`),
                   ),
                   ``,
                   default_,
                 ],
-                ...Object.values(mexGroup.parameters).map((spec) => [
-                  parameterName(spec),
-                  spec.type.help(settings),
-                  parameterDefault(spec),
-                  ...(isEnvironmentEnabled ? [parameterEnvironment(spec, settings)] : []),
+                ...Object.values(parametersExclusive.parameters).map((parameter) => [
+                  parameterName(parameter),
+                  parameter.type.help(settings),
+                  parameterDefault(parameter),
+                  ...(isEnvironmentEnabled ? [parameterEnvironment(parameter, settings)] : []),
                 ]),
                 [Tex.block({ border: { left: Term.colors.dim(`└`) } }, Term.colors.dim(`─`))],
               ]
@@ -150,9 +150,9 @@ export const render = (
   return output
 }
 
-const environmentNote = (specs: CommandParameter.Output[], settings: Settings.Output) => {
-  const isHasSpecsWithCustomEnvironmentNamespace =
-    specs
+const environmentNote = (parameters: Parameter[], settings: Settings.Output) => {
+  const isHasParametersWithCustomEnvironmentNamespace =
+    parameters
       .filter((_) => _.environment?.enabled)
       .filter(
         (_) =>
@@ -168,7 +168,7 @@ const environmentNote = (specs: CommandParameter.Output[], settings: Settings.Ou
     ` can be passed arguments via environment variables. Command line arguments take precedence. Environment variable names are snake cased versions of the parameter name (or its aliases), case insensitive. `
 
   if (settings.parameters.environment.$default.prefix.length > 0) {
-    if (isHasSpecsWithCustomEnvironmentNamespace) {
+    if (isHasParametersWithCustomEnvironmentNamespace) {
       content += `By default they must be prefixed with`
       content += ` ${Text.joinListEnglish(
         settings.parameters.environment.$default.prefix.map((_) =>
@@ -184,14 +184,14 @@ const environmentNote = (specs: CommandParameter.Output[], settings: Settings.Ou
       )} (case insensitive). `
     }
   } else {
-    content += isHasSpecsWithCustomEnvironmentNamespace
+    content += isHasParametersWithCustomEnvironmentNamespace
       ? `By default there is no prefix, though some parameters deviate (shown in docs). `
       : `There is no prefix.`
   }
 
   content += `Examples:`
 
-  const examples = specs
+  const examples = parameters
     .filter((_) => _.environment?.enabled)
     .slice(0, 3)
     .map((_) =>
@@ -216,18 +216,18 @@ const environmentNote = (specs: CommandParameter.Output[], settings: Settings.Ou
   )
 }
 
-const parameterDefault = (spec: CommandParameter.Output) => {
-  if (spec._tag === `Exclusive`) {
+const parameterDefault = (parameter: Parameter) => {
+  if (parameter._tag === `Exclusive`) {
     return Term.colors.dim(`–`)
   }
 
-  if (spec.type.optionality._tag === `optional`) {
+  if (parameter.type.optionality._tag === `optional`) {
     return Term.colors.secondary(`undefined`)
   }
 
-  if (spec.type.optionality._tag === `default`) {
+  if (parameter.type.optionality._tag === `default`) {
     try {
-      return Term.colors.secondary(String(spec.type.optionality.getValue()))
+      return Term.colors.secondary(String(parameter.type.optionality.getValue()))
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e))
       return chalk.bold(Term.colors.alert(`Error trying to render this default: ${error.message}`))
@@ -241,13 +241,13 @@ const labels = {
   required: chalk.bold(chalk.black(Term.colors.alertBoldBg(` REQUIRED `))),
 }
 
-const parameterName = (spec: CommandParameter.Output) => {
+const parameterName = (parameter: Parameter) => {
   const isRequired =
-    (spec._tag === `Basic` && spec.type.optionality._tag === `required`) ||
-    (spec._tag === `Exclusive` && spec.group.optionality._tag === `required`)
+    (parameter._tag === `Basic` && parameter.type.optionality._tag === `required`) ||
+    (parameter._tag === `Exclusive` && parameter.group.optionality._tag === `required`)
 
   const parameters: Tex.BlockParameters =
-    spec._tag === `Exclusive`
+    parameter._tag === `Exclusive`
       ? {
           border: {
             left: (lineNumber) =>
@@ -264,28 +264,30 @@ const parameterName = (spec: CommandParameter.Output) => {
 
   return Tex.block(parameters, (__) =>
     __.block(
-      isRequired ? Term.colors.positiveBold(spec.name.canonical) : Term.colors.positive(spec.name.canonical),
+      isRequired
+        ? Term.colors.positiveBold(parameter.name.canonical)
+        : Term.colors.positive(parameter.name.canonical),
     )
-      .block(Term.colors.dim(spec.name.aliases.long.join(`, `)) || null)
-      .block(Term.colors.dim(spec.name.short ?? ``) || null)
-      .block(Term.colors.dim(spec.name.aliases.long.join(`, `)) || null),
+      .block(Term.colors.dim(parameter.name.aliases.long.join(`, `)) || null)
+      .block(Term.colors.dim(parameter.name.short ?? ``) || null)
+      .block(Term.colors.dim(parameter.name.aliases.long.join(`, `)) || null),
   )
 }
 
-const parameterEnvironment = (spec: CommandParameter.Output, settings: Settings.Output) => {
-  return spec.environment?.enabled
+const parameterEnvironment = (parameter: Parameter, settings: Settings.Output) => {
+  return parameter.environment?.enabled
     ? Term.colors.secondary(Text.chars.check) +
-        (spec.environment.enabled && spec.environment.namespaces.length === 0
-          ? ` ` + Term.colors.dim(Text.toEnvarNameCase(spec.name.canonical))
-          : spec.environment.enabled &&
-            spec.environment.namespaces.filter(
+        (parameter.environment.enabled && parameter.environment.namespaces.length === 0
+          ? ` ` + Term.colors.dim(Text.toEnvarNameCase(parameter.name.canonical))
+          : parameter.environment.enabled &&
+            parameter.environment.namespaces.filter(
               // TODO settings normalized should store prefix in camel case
               (_) => !settings.parameters.environment.$default.prefix.includes(snakeCase(_)),
             ).length > 0
           ? ` ` +
             Term.colors.dim(
-              spec.environment.namespaces
-                .map((_) => `${Text.toEnvarNameCase(_)}_${Text.toEnvarNameCase(spec.name.canonical)}`)
+              parameter.environment.namespaces
+                .map((_) => `${Text.toEnvarNameCase(_)}_${Text.toEnvarNameCase(parameter.name.canonical)}`)
                 .join(` ${Text.chars.pipe} `),
             )
           : ``)
diff --git a/packages/@molt/command/src/OpeningArgs/Environment/Environment.ts b/packages/@molt/command/src/OpeningArgs/Environment/Environment.ts
index cf7aa748..44ef5eb2 100644
--- a/packages/@molt/command/src/OpeningArgs/Environment/Environment.ts
+++ b/packages/@molt/command/src/OpeningArgs/Environment/Environment.ts
@@ -1,6 +1,7 @@
-import { CommandParameter } from '../../CommandParameter/index.js'
 import { Errors } from '../../Errors/index.js'
 import type { Index, RequireField } from '../../lib/prelude.js'
+import { getNames } from '../../Parameter/helpers/CommandParameter.js'
+import type { Parameter } from '../../Parameter/types.js'
 import { parseSerializedValue } from '../helpers.js'
 import type { EnvironmentArgumentReport } from '../types.js'
 import camelCase from 'lodash.camelcase'
@@ -19,7 +20,7 @@ export interface ParsedInputs {
   reports: Index<EnvironmentArgumentReport>
 }
 
-export const parse = (environment: RawInputs, specs: CommandParameter.Output[]): ParsedInputs => {
+export const parse = (environment: RawInputs, specs: Parameter[]): ParsedInputs => {
   const result: ParsedInputs = {
     globalErrors: [],
     reports: {},
@@ -109,7 +110,7 @@ export const lookupEnvironmentVariableArgument = (
   return environmentVariable
 }
 
-type ParameterSpecOutputWithEnvironment = RequireField<CommandParameter.Output, 'environment'>
+type ParameterSpecOutputWithEnvironment = RequireField<Parameter, 'environment'>
 
 interface Match {
   namespace: null | string
@@ -123,7 +124,7 @@ interface Match {
  * Find out if an environment variable is input to a spec.
  */
 const checkInputMatch = (envar: Envar, spec: ParameterSpecOutputWithEnvironment): null | Match => {
-  const specParameterNames = CommandParameter.getNames(spec)
+  const specParameterNames = getNames(spec)
   for (const name of specParameterNames) {
     if (spec.environment.namespaces.length > 0) {
       for (const namespace of spec.environment.namespaces) {
diff --git a/packages/@molt/command/src/OpeningArgs/Line/Line.ts b/packages/@molt/command/src/OpeningArgs/Line/Line.ts
index 941e910f..81450f99 100644
--- a/packages/@molt/command/src/OpeningArgs/Line/Line.ts
+++ b/packages/@molt/command/src/OpeningArgs/Line/Line.ts
@@ -1,7 +1,8 @@
-import { CommandParameter } from '../../CommandParameter/index.js'
 import { Errors } from '../../Errors/index.js'
 import { stripeNegatePrefixLoose } from '../../helpers.js'
 import type { Index } from '../../lib/prelude.js'
+import { findByName, isOrHasType } from '../../Parameter/helpers/CommandParameter.js'
+import type { Parameter } from '../../Parameter/types.js'
 import { isNegated, parseSerializedValue, stripeDashPrefix } from '../helpers.js'
 import type { ArgumentReport } from '../types.js'
 import camelCase from 'lodash.camelcase'
@@ -21,7 +22,7 @@ interface ParsedInputs {
  * Parse line input into an intermediary representation that is suited to comparison against
  * the parameter specs.
  */
-export const parse = (rawLineInputs: RawInputs, parameters: CommandParameter.Output[]): ParsedInputs => {
+export const parse = (rawLineInputs: RawInputs, parameters: Parameter[]): ParsedInputs => {
   const globalErrors: GlobalParseErrors[] = []
 
   const rawLineInputsPrepared = rawLineInputs
@@ -51,7 +52,7 @@ export const parse = (rawLineInputs: RawInputs, parameters: CommandParameter.Out
        * If union with boolean or boolean then we interpret foo argument as being a boolean.
        * Otherwise it is an error.
        */
-      if (CommandParameter.isOrHasType(pendingReport.parameter, `TypeBoolean`)) {
+      if (isOrHasType(pendingReport.parameter, `TypeBoolean`)) {
         pendingReport.value = {
           value: true,
           _tag: `boolean`,
@@ -75,7 +76,7 @@ export const parse = (rawLineInputs: RawInputs, parameters: CommandParameter.Out
       const flagNameNoDashPrefix = stripeDashPrefix(rawLineInput)
       const flagNameNoDashPrefixCamel = camelCase(flagNameNoDashPrefix)
       const flagNameNoDashPrefixNoNegate = stripeNegatePrefixLoose(flagNameNoDashPrefixCamel)
-      const parameter = CommandParameter.findByName(flagNameNoDashPrefixCamel, parameters)
+      const parameter = findByName(flagNameNoDashPrefixCamel, parameters)
       if (!parameter) {
         globalErrors.push(new Errors.Global.ErrorUnknownFlag({ flagName: flagNameNoDashPrefixNoNegate }))
         continue
diff --git a/packages/@molt/command/src/OpeningArgs/OpeningArgs.ts b/packages/@molt/command/src/OpeningArgs/OpeningArgs.ts
index 1a1983d4..c3053c0e 100644
--- a/packages/@molt/command/src/OpeningArgs/OpeningArgs.ts
+++ b/packages/@molt/command/src/OpeningArgs/OpeningArgs.ts
@@ -1,6 +1,7 @@
-import type { CommandParameter } from '../CommandParameter/index.js'
 import { Errors } from '../Errors/index.js'
 import { errorFromUnknown, groupBy } from '../lib/prelude.js'
+import type { ParameterExclusive } from '../Parameter/exclusive.js'
+import type { Parameter } from '../Parameter/types.js'
 import { Environment } from './Environment/index.js'
 import { Line } from './Line/index.js'
 import type { ArgumentReport, ParseResult } from './types.js'
@@ -14,7 +15,7 @@ export const parse = ({
   line,
   environment,
 }: {
-  parameters: CommandParameter.Output[]
+  parameters: Parameter[]
   line: Line.RawInputs
   environment: Environment.RawInputs
 }): ParseResult => {
@@ -171,7 +172,7 @@ export const parse = ({
     const group = specs[0]!.group // eslint-disable-line
     const argsToGroup = specs
       .map((_) => lineParseResult.reports[_.name.canonical] ?? envParseResult.reports[_.name.canonical])
-      .filter((_): _ is ArgumentReport<CommandParameter.Output.Exclusive> => _ !== undefined)
+      .filter((_): _ is ArgumentReport<ParameterExclusive> => _ !== undefined)
 
     if (argsToGroup.length === 0) {
       if (group.optionality._tag === `optional`) {
diff --git a/packages/@molt/command/src/OpeningArgs/helpers.ts b/packages/@molt/command/src/OpeningArgs/helpers.ts
index ff018a87..02792290 100644
--- a/packages/@molt/command/src/OpeningArgs/helpers.ts
+++ b/packages/@molt/command/src/OpeningArgs/helpers.ts
@@ -1,18 +1,15 @@
-import type { CommandParameter } from '../CommandParameter/index.js'
 import { negateNamePattern } from '../helpers.js'
+import type { Parameter } from '../Parameter/types.js'
 import type { Value } from './types.js'
 import { Either } from 'effect'
 import camelCase from 'lodash.camelcase'
-import { z } from 'zod'
 
 export const stripeDashPrefix = (flagNameInput: string): string => {
   return flagNameInput.replace(/^-+/, ``)
 }
 
-export const zodPassthrough = <T>() => z.any().transform((_) => _ as T)
-
 // prettier-ignore
-export const parseSerializedValue = (name: string, serializedValue: string, spec: CommandParameter.Output): Value => {
+export const parseSerializedValue = (name: string, serializedValue: string, spec: Parameter): Value => {
   const either = spec.type.deserialize(serializedValue)
   if (Either.isLeft(either)) {
     const expectedTypes = spec.type._tag
@@ -35,7 +32,7 @@ export const parseSerializedValue = (name: string, serializedValue: string, spec
  * Is the environment variable input negated? Unlike line input the environment can be
  * namespaced so a bit more work is needed to parse out the name pattern.
  */
-export const isEnvarNegated = (name: string, spec: CommandParameter.Output): boolean => {
+export const isEnvarNegated = (name: string, spec: Parameter): boolean => {
   const nameWithNamespaceStripped = stripeNamespace(name, spec)
   // dump({ nameWithNamespaceStripped })
   return negateNamePattern.test(nameWithNamespaceStripped)
@@ -45,7 +42,7 @@ export const isNegated = (name: string): boolean => {
   return negateNamePattern.test(name)
 }
 
-const stripeNamespace = (name: string, spec: CommandParameter.Output): string => {
+const stripeNamespace = (name: string, spec: Parameter): string => {
   for (const namespace of spec.environment?.namespaces ?? []) {
     if (name.startsWith(namespace)) return camelCase(name.slice(namespace.length))
   }
diff --git a/packages/@molt/command/src/OpeningArgs/types.ts b/packages/@molt/command/src/OpeningArgs/types.ts
index 9a984392..5d1ff23c 100644
--- a/packages/@molt/command/src/OpeningArgs/types.ts
+++ b/packages/@molt/command/src/OpeningArgs/types.ts
@@ -1,18 +1,18 @@
-import type { CommandParameter } from '../CommandParameter/index.js'
 import type { Errors } from '../Errors/index.js'
+import type { ArgumentValue, ArgumentValueMutuallyExclusive } from '../executor/types.js'
+import type { ParameterBasic } from '../Parameter/basic.js'
+import type { ParameterExclusive, ParameterExclusiveGroup } from '../Parameter/exclusive.js'
+import type { Parameter } from '../Parameter/types.js'
 import type { Environment } from './Environment/index.js'
 import type { LocalParseErrors } from './Line/Line.js'
 
-export interface EnvironmentArgumentReport<
-  Parameter extends CommandParameter.Output = CommandParameter.Output,
-> extends Argument {
-  parameter: Parameter
+export interface EnvironmentArgumentReport<$Parameter extends Parameter = Parameter> extends Argument {
+  parameter: $Parameter
   errors: Environment.LocalParseErrors[]
 }
 
-export interface ArgumentReport<Parameter extends CommandParameter.Output = CommandParameter.Output>
-  extends Argument {
-  parameter: Parameter
+export interface ArgumentReport<$Parameter extends Parameter = Parameter> extends Argument {
+  parameter: $Parameter
   errors: LocalParseErrors[]
 }
 
@@ -64,32 +64,32 @@ export type ParseError =
 
 export type ParseResultBasicSupplied = {
   _tag: 'supplied'
-  parameter: CommandParameter.Output.Basic
-  value: CommandParameter.ArgumentValue
+  parameter: ParameterBasic
+  value: ArgumentValue
 }
 
 export type ParseResultBasicError = {
   _tag: 'error'
-  parameter: CommandParameter.Output.Basic
+  parameter: ParameterBasic
   errors: ParseErrorBasic[]
 }
 export type ParseResultBasicOmitted = {
   _tag: 'omitted'
-  parameter: CommandParameter.Output.Basic
+  parameter: ParameterBasic
 }
 
 export type ParseResultBasic = ParseResultBasicSupplied | ParseResultBasicError | ParseResultBasicOmitted
 
 export type ParseResultExclusiveGroupSupplied = {
   _tag: 'supplied'
-  spec: CommandParameter.Output.ExclusiveGroup
-  parameter: CommandParameter.Output.Exclusive
-  value: CommandParameter.ArgumentValueMutuallyExclusive
+  spec: ParameterExclusiveGroup
+  parameter: ParameterExclusive
+  value: ArgumentValueMutuallyExclusive
 }
 
 export type ParseResultExclusiveGroupError = {
   _tag: 'error'
-  parameter: CommandParameter.Output.ExclusiveGroup
+  parameter: ParameterExclusiveGroup
   errors: ParseErrorExclusiveGroup[]
 }
 
@@ -97,7 +97,7 @@ export type ParseResultExclusiveGroup =
   | ParseResultExclusiveGroupSupplied
   | {
       _tag: 'omitted'
-      parameter: CommandParameter.Output.ExclusiveGroup
+      parameter: ParameterExclusiveGroup
     }
   | ParseResultExclusiveGroupError
 
diff --git a/packages/@molt/command/src/Parameter/basic.ts b/packages/@molt/command/src/Parameter/basic.ts
new file mode 100644
index 00000000..910c6497
--- /dev/null
+++ b/packages/@molt/command/src/Parameter/basic.ts
@@ -0,0 +1,50 @@
+import type { BuilderCommandState } from '../builders/command/state.js'
+import type { HKT } from '../helpers.js'
+import type { Settings } from '../index.js'
+import type { Pam } from '../lib/Pam/index.js'
+import type { Optionality } from '../Type/Type.js'
+import { processEnvironment } from './helpers/environment.js'
+import type { Environment, Prompt } from './helpers/types.js'
+import { Name } from '@molt/types'
+
+export interface ParameterBasicInput<
+  $State extends BuilderCommandState.Base = BuilderCommandState.BaseEmpty,
+> {
+  _tag: 'Basic'
+  nameExpression: string
+  type: $State['Type']
+  prompt: Prompt<HKT.Call<$State['TypeMapper'], $State['Type']>>
+}
+
+export interface ParameterBasic extends Omit<Pam.Parameter, '_tag'> {
+  _tag: 'Basic'
+  environment: Environment
+  prompt: Prompt
+}
+
+export const parameterBasicCreate = (
+  input: ParameterBasicInput,
+  settings: Settings.Output,
+): ParameterBasic => {
+  const name = Name.parse(input.nameExpression)
+  const environment = processEnvironment(settings, name)
+  const prompt = input.prompt as boolean | null | { enabled?: boolean; when?: object } // eslint-disable-line
+  const promptEnabled =
+    prompt === true ? true : prompt === false ? false : prompt === null ? null : prompt.enabled ?? null
+  const promptEnabledWhen = prompt === null ? null : typeof prompt === `object` ? prompt.when ?? null : null
+  return {
+    _tag: `Basic`,
+    environment,
+    name,
+    prompt: {
+      enabled: promptEnabled,
+      when: promptEnabledWhen as any, // eslint-disable-line
+    },
+    type: input.type,
+  }
+}
+
+export type ParameterBasicData = Omit<ParameterBasic, '_tag'> & {
+  _tag: 'BasicData'
+  optionality: Optionality['_tag']
+}
diff --git a/packages/@molt/command/src/Parameter/exclusive.ts b/packages/@molt/command/src/Parameter/exclusive.ts
new file mode 100644
index 00000000..597535ef
--- /dev/null
+++ b/packages/@molt/command/src/Parameter/exclusive.ts
@@ -0,0 +1,92 @@
+import type { BuilderCommandState } from '../builders/command/state.js'
+import type { Settings } from '../index.js'
+import type { Pam } from '../lib/Pam/index.js'
+import type { Type } from '../Type/index.js'
+import { processEnvironment } from './helpers/environment.js'
+import type { Environment } from './helpers/types.js'
+import type { Name as MoltName } from '@molt/types'
+import { Name } from '@molt/types'
+import { Alge } from 'alge'
+
+export interface ParameterExclusiveInput<
+  $State extends BuilderCommandState.Base = BuilderCommandState.BaseEmpty,
+> {
+  _tag: 'Exclusive'
+  label: string
+  optionality:
+    | { _tag: 'required' }
+    | { _tag: 'optional' }
+    | { _tag: 'default'; tag: string; value: Pam.Value | (() => Pam.Value) }
+  description?: string
+  parameters: {
+    nameExpression: string
+    type: $State['Type']
+  }[]
+}
+
+export interface ParameterExclusive {
+  _tag: 'Exclusive'
+  name: MoltName.Data.NameParsed
+  type: Type.Type
+  description: string | null
+  environment: Environment
+  group: ParameterExclusiveGroup
+}
+
+export interface ParameterExclusiveGroup {
+  // _tag: 'Exclusive'
+  label: string
+  optionality: ParameterExclusiveOptionality
+  parameters: Record<string, ParameterExclusive>
+}
+
+export type ParameterExclusiveOptionality =
+  | { _tag: 'required' }
+  | { _tag: 'optional' }
+  | { _tag: 'default'; tag: string; getValue: () => Pam.Value }
+
+export const parameterExclusiveCreate = (
+  input: ParameterExclusiveInput,
+  settings: Settings.Output,
+): ParameterExclusive[] => {
+  const parameters: ParameterExclusive[] = input.parameters.map((_) => {
+    const name = Name.parse(_.nameExpression)
+    const environment = processEnvironment(settings, name)
+    return {
+      _tag: `Exclusive`,
+      description: _.type.description,
+      type: _.type,
+      environment,
+      name,
+      // See comment/code below: (1)
+      group: null as any, // eslint-disable-line
+    }
+  })
+
+  /**
+   * (1) Link up the group to each value and vice versa. Cannot do this in the above constructor since
+   * it would create a copy of group for each value.
+   */
+  const group: ParameterExclusiveGroup = {
+    label: input.label,
+    // Input exclusive default allows default to be value or thunk,
+    // while output is always thunk.
+    optionality: Alge.match(input.optionality)
+      .default(
+        (_): ParameterExclusiveOptionality => ({
+          _tag: `default`,
+          tag: _.tag,
+          getValue: () => (typeof _.value === `function` ? _.value() : _.value),
+        }),
+      )
+      .else((_) => _),
+    parameters: {},
+  }
+
+  parameters.forEach((_) => {
+    _.group = group
+    group.parameters[_.name.canonical] = _
+  })
+
+  return parameters
+}
diff --git a/packages/@molt/command/src/Parameter/helpers/CommandParameter.ts b/packages/@molt/command/src/Parameter/helpers/CommandParameter.ts
new file mode 100644
index 00000000..f0dbddaa
--- /dev/null
+++ b/packages/@molt/command/src/Parameter/helpers/CommandParameter.ts
@@ -0,0 +1,81 @@
+import { stripeNegatePrefix } from '../../helpers.js'
+import type { Type } from '../../Type/index.js'
+import type { ValidationResult } from '../../Type/Type.js'
+import type { Parameter } from '../types.js'
+import { Either } from 'effect'
+
+export const validate = <T>(parameter: Parameter, value: unknown): ValidationResult<T> => {
+  if (parameter.type.optionality._tag === `optional` && value === undefined) return Either.right(value as T)
+  return parameter.type.validate(value)
+}
+
+export const findByName = (name: string, specs: Parameter[]): null | Parameter => {
+  for (const spec of specs) {
+    const result = hasName(spec, name)
+    if (result !== null) return spec
+  }
+  return null
+}
+
+/**
+ * Get all the names of a parameter in array form.
+ */
+export const getNames = (parameter: Parameter): [string, ...string[]] => {
+  return [
+    ...parameter.name.aliases.long,
+    ...parameter.name.aliases.short,
+    ...(parameter.name.long === null ? [] : [parameter.name.long]),
+    ...(parameter.name.short === null ? [] : [parameter.name.short]),
+  ] as [string, ...string[]]
+}
+
+type NameHit =
+  | {
+      kind: 'long' | 'longAlias'
+      /**
+       * Was the given name in negated format? e.g. noFoo instead of foo
+       */
+      negated: boolean
+    }
+  | {
+      kind: 'short' | 'shortAlias'
+    }
+
+/**
+ * Is one of the parameter's names the given name?
+ */
+export const hasName = (parameter: Parameter, name: string): null | NameHit => {
+  const result = parameterSpecHasNameDo(parameter, name, false)
+
+  if (isOrHasType(parameter, `TypeBoolean`)) {
+    const nameWithoutNegatePrefix = stripeNegatePrefix(name)
+    if (nameWithoutNegatePrefix) {
+      return parameterSpecHasNameDo(parameter, nameWithoutNegatePrefix, true)
+    }
+  }
+
+  return result
+}
+
+export const isOrHasType = (parameter: Parameter, typeTag: Type.Type['_tag']): boolean => {
+  return parameter.type._tag === `TypeUnion`
+    ? (parameter.type as Type.Union).members.find((_) => _._tag === typeTag) !== undefined
+    : parameter.type._tag === typeTag
+}
+
+const parameterSpecHasNameDo = (
+  parameter: Parameter,
+  name: string,
+  negated: boolean,
+): null | { kind: 'long' | 'longAlias'; negated: boolean } | { kind: 'short' | 'shortAlias' } => {
+  return parameter.name.long === name
+    ? { kind: `long`, negated }
+    : parameter.name.aliases.long.includes(name)
+    ? { kind: `longAlias`, negated }
+    : // Short names cannot be negated currently so short circuit with the negated check.
+    parameter.name.short === name
+    ? { kind: `short` }
+    : parameter.name.aliases.short.includes(name)
+    ? { kind: `shortAlias` }
+    : null
+}
diff --git a/packages/@molt/command/src/CommandParameter/processor/helpers/environment.ts b/packages/@molt/command/src/Parameter/helpers/environment.ts
similarity index 77%
rename from packages/@molt/command/src/CommandParameter/processor/helpers/environment.ts
rename to packages/@molt/command/src/Parameter/helpers/environment.ts
index 092f5a27..f908a19d 100644
--- a/packages/@molt/command/src/CommandParameter/processor/helpers/environment.ts
+++ b/packages/@molt/command/src/Parameter/helpers/environment.ts
@@ -1,11 +1,12 @@
-import type { Settings } from '../../../index.js'
-import type { Output } from '../../output.js'
+import type { Settings } from '../../index.js'
+import type { Environment } from './types.js'
+import type { Name } from '@molt/types'
 import camelCase from 'lodash.camelcase'
 
 /**
  * Parse the specification for a parameter's environment support.
  */
-export const processEnvironment = (settings: Settings.Output, name: Output.Name): Output.Environment => {
+export const processEnvironment = (settings: Settings.Output, name: Name.Data.NameParsed): Environment => {
   const hasEnvironment =
     settings.parameters.environment[name.canonical]?.enabled ??
     settings.parameters.environment.$default.enabled
diff --git a/packages/@molt/command/src/Parameter/helpers/types.ts b/packages/@molt/command/src/Parameter/helpers/types.ts
new file mode 100644
index 00000000..25fa107a
--- /dev/null
+++ b/packages/@molt/command/src/Parameter/helpers/types.ts
@@ -0,0 +1,9 @@
+import type { EventPatternsInput } from '../../eventPatterns.js'
+import type { Type } from '../../Type/index.js'
+
+export type Environment = null | { enabled: boolean; namespaces: string[] }
+
+export type Prompt<T extends Type.Type = Type.Type> = {
+  enabled: boolean | null
+  when: EventPatternsInput<T> | null
+}
diff --git a/packages/@molt/command/src/Parameter/types.ts b/packages/@molt/command/src/Parameter/types.ts
new file mode 100644
index 00000000..288c2f10
--- /dev/null
+++ b/packages/@molt/command/src/Parameter/types.ts
@@ -0,0 +1,14 @@
+import type { EventPatternsInput } from '../eventPatterns.js'
+import type { Type } from '../Type/index.js'
+import type { ParameterBasic } from './basic.js'
+import type { ParameterExclusive } from './exclusive.js'
+
+export type Parameter = ParameterBasic | ParameterExclusive
+
+export type Prompt<T extends Type.Type> =
+  | null
+  | boolean
+  | {
+      enabled?: boolean
+      when?: EventPatternsInput<T>
+    }
diff --git a/packages/@molt/command/src/Settings/settings.ts b/packages/@molt/command/src/Settings/settings.ts
index 71e93e0b..87b4b224 100644
--- a/packages/@molt/command/src/Settings/settings.ts
+++ b/packages/@molt/command/src/Settings/settings.ts
@@ -1,17 +1,15 @@
-import type { State } from '../Command/State.js'
+import type { BuilderCommandState } from '../builders/command/state.js'
 import type { EventPatternsInput, EventPatternsInputAtLeastOne } from '../eventPatterns.js'
 import { eventPatterns } from '../eventPatterns.js'
 import type { Values } from '../helpers.js'
 import { parseEnvironmentVariableBooleanOrThrow } from '../helpers.js'
 import { defaultParameterNamePrefixes } from '../OpeningArgs/Environment/Environment.js'
 import type { Type } from '../Type/index.js'
-import type { TypeAdaptors } from '../TypeAdaptors/index.js'
-import type { Name } from '@molt/types'
 import snakeCase from 'lodash.snakecase'
 
 export type OnErrorReaction = 'exit' | 'throw'
 
-export type InputPrompt<T extends Type.Type> =
+export type PromptInput<T extends Type.Type> =
   | boolean
   | {
       enabled?: boolean
@@ -19,7 +17,7 @@ export type InputPrompt<T extends Type.Type> =
     }
 
 // eslint-disable-next-line
-export interface Input<ParametersObject extends State.ParametersSchemaObjectBase = {}> {
+export interface Input<$State extends BuilderCommandState.Base = BuilderCommandState.BaseEmpty> {
   description?: string
   help?: boolean
   helpOnNoArguments?: boolean
@@ -31,14 +29,13 @@ export interface Input<ParametersObject extends State.ParametersSchemaObjectBase
   }
   onError?: OnErrorReaction
   onOutput?: (output: string, defaultHandler: (output: string) => void) => void
-  prompt?: InputPrompt<TypeAdaptors.Zod.FromZod<Values<ParametersObject>>>
-  // prompt?:
+  prompt?: PromptInput<Values<BuilderCommandState.ToTypes<$State>>>
   parameters?: {
     // prettier-ignore
     environment?:
       | boolean
       | ({
-          [FlagSpecExpression in keyof ParametersObject as Name.Data.GetCanonicalNameOrErrorFromParseResult<Name.Parse<FlagSpecExpression & string>>]?: boolean | SettingInputEnvironmentParameter
+            [NameExpression in keyof $State['Parameters'] as $State['Parameters'][NameExpression]['NameParsed']['canonical']]?: boolean | SettingInputEnvironmentParameter
         } & {
           $default?: boolean | SettingInputEnvironmentParameter
         })
@@ -46,6 +43,7 @@ export interface Input<ParametersObject extends State.ParametersSchemaObjectBase
 }
 
 export interface Output {
+  typeMapper: (value: unknown) => Type.Type
   prompt: {
     enabled: boolean
     when: EventPatternsInput<Type.Type>
@@ -89,13 +87,18 @@ interface Environment {
 }
 
 // eslint-disable-next-line
-export const change = (current: Output, input: Input<{}>, environment: Environment): void => {
+export const change = (
+  current: Output,
+  input: Input<BuilderCommandState.BaseEmpty>,
+  environment: Environment,
+): void => {
   if (input.prompt !== undefined) {
     if (typeof input.prompt === `boolean`) {
       current.prompt.enabled = input.prompt
     } else {
       if (input.prompt.enabled !== undefined) current.prompt.enabled = input.prompt.enabled
       if (input.prompt.when !== undefined) {
+        // @ts-expect-error fixme
         current.prompt.when = input.prompt.when
         // Passing object makes enabled default to true
         if (input.prompt.enabled === undefined) current.prompt.enabled = true
@@ -207,6 +210,7 @@ const isEnvironmentEnabled = (lowercaseEnv: NodeJS.ProcessEnv) => {
 
 export const getDefaults = (lowercaseEnv: NodeJS.ProcessEnv): Output => {
   return {
+    typeMapper: (t) => t as any,
     prompt: {
       enabled: false,
       when: eventPatterns.rejectedMissingOrInvalid,
diff --git a/packages/@molt/command/src/Type/helpers.ts b/packages/@molt/command/src/Type/helpers.ts
index 39325f70..c17dde2d 100644
--- a/packages/@molt/command/src/Type/helpers.ts
+++ b/packages/@molt/command/src/Type/helpers.ts
@@ -9,7 +9,7 @@ export const runtimeIgnore: any = true
 
 export type TypeSymbol = typeof TypeSymbol
 
-export type Optionality<T> =
+export type Optionality<T = unknown> =
   | { _tag: 'required' }
   | { _tag: 'optional' }
   | { _tag: 'default'; getValue: () => T }
@@ -19,7 +19,7 @@ export interface Type<T = any> {
   description: null | string
   [TypeSymbol]: T
   optionality: Optionality<T>
-  validate: (value: unknown) => ValidationResult<T>
+  validate: (value: unknown) => ValidationResult<T | undefined> // can be undefined when optional
   transform?: (value: T) => T
   priority: number
   help: (settings?: any) => string | Tex.Block
diff --git a/packages/@molt/command/src/Type/types/Scalars/Boolean.ts b/packages/@molt/command/src/Type/types/Scalars/Boolean.ts
index 4564943b..d6b3a3e2 100644
--- a/packages/@molt/command/src/Type/types/Scalars/Boolean.ts
+++ b/packages/@molt/command/src/Type/types/Scalars/Boolean.ts
@@ -29,6 +29,7 @@ export const boolean = ({
     priority: 0,
     // eslint-disable-next-line
     validate: (value: unknown) => {
+      if (optionality._tag === `optional` && value === undefined) return Either.right(value)
       return typeof value === `boolean`
         ? Either.right(value)
         : Either.left({ value, errors: [`Value is not a boolean.`] })
diff --git a/packages/@molt/command/src/Type/types/Scalars/Enumeration.ts b/packages/@molt/command/src/Type/types/Scalars/Enumeration.ts
index 03e6a3d3..8c629381 100644
--- a/packages/@molt/command/src/Type/types/Scalars/Enumeration.ts
+++ b/packages/@molt/command/src/Type/types/Scalars/Enumeration.ts
@@ -29,6 +29,7 @@ export const enumeration = <$Members extends Member[]>({
     description: description ?? null,
     [TypeSymbol]: runtimeIgnore, // eslint-disable-line
     validate: (value) => {
+      if (optionality._tag === `optional` && value === undefined) return Either.right(value)
       return members.includes(value as any)
         ? Either.right(value as (typeof members)[number])
         : Either.left({ value, errors: [`Value is not a member of the enum.`] })
diff --git a/packages/@molt/command/src/Type/types/Scalars/Literal.ts b/packages/@molt/command/src/Type/types/Scalars/Literal.ts
index 4cc2c74c..f1f2f36b 100644
--- a/packages/@molt/command/src/Type/types/Scalars/Literal.ts
+++ b/packages/@molt/command/src/Type/types/Scalars/Literal.ts
@@ -28,6 +28,7 @@ export const literal = <const $Value extends LiteralValue>({
     optionality,
     description: description ?? null,
     validate: (_value) => {
+      if (optionality._tag === `optional` && value === undefined) return Either.right(value)
       return _value === value
         ? Either.right(_value as typeof value)
         : Either.left({ value: _value, errors: [`Value is not equal to literal.`] })
diff --git a/packages/@molt/command/src/Type/types/Scalars/Number.ts b/packages/@molt/command/src/Type/types/Scalars/Number.ts
index 12466571..bd396092 100644
--- a/packages/@molt/command/src/Type/types/Scalars/Number.ts
+++ b/packages/@molt/command/src/Type/types/Scalars/Number.ts
@@ -49,6 +49,7 @@ export const number = ({
     },
     help: () => type.displayExpanded(),
     validate: (value) => {
+      if (optionality._tag === `optional` && value === undefined) return Either.right(value)
       const errors: string[] = []
 
       if (typeof value !== `number`) {
diff --git a/packages/@molt/command/src/Type/types/Scalars/String.ts b/packages/@molt/command/src/Type/types/Scalars/String.ts
index c76f7118..ccf1c701 100644
--- a/packages/@molt/command/src/Type/types/Scalars/String.ts
+++ b/packages/@molt/command/src/Type/types/Scalars/String.ts
@@ -91,6 +91,7 @@ export const string = ({
     },
     deserialize: (rawValue) => Either.right(rawValue),
     validate: (value) => {
+      if (optionality._tag === `optional` && value === undefined) return Either.right(value)
       const errors: string[] = []
 
       if (typeof value !== `string`)  return Either.left({ value, errors: [`Value is not a string.`] }) // prettier-ignore
diff --git a/packages/@molt/command/src/TypeAdaptors/TypeAdaptors.ts b/packages/@molt/command/src/TypeAdaptors/TypeAdaptors.ts
deleted file mode 100644
index ddcef967..00000000
--- a/packages/@molt/command/src/TypeAdaptors/TypeAdaptors.ts
+++ /dev/null
@@ -1 +0,0 @@
-export * from './zod/index.js'
diff --git a/packages/@molt/command/src/TypeAdaptors/index.ts b/packages/@molt/command/src/TypeAdaptors/index.ts
deleted file mode 100644
index 98806ca9..00000000
--- a/packages/@molt/command/src/TypeAdaptors/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export * as TypeAdaptors from './TypeAdaptors.js'
diff --git a/packages/@molt/command/src/TypeAdaptors/zod/index.ts b/packages/@molt/command/src/TypeAdaptors/zod/index.ts
deleted file mode 100644
index 9ff9da6c..00000000
--- a/packages/@molt/command/src/TypeAdaptors/zod/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export * as Zod from './zod.js'
diff --git a/packages/@molt/command/src/TypeAdaptors/zod/types.ts b/packages/@molt/command/src/TypeAdaptors/zod/types.ts
deleted file mode 100644
index 4a0044e6..00000000
--- a/packages/@molt/command/src/TypeAdaptors/zod/types.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-// import { ZodHelpers } from '../lib/zodHelpers/index.js'
-// import { stripOptionalAndDefault } from '../lib/zodHelpers/index_.js'
-import type { z } from 'zod'
-
-export type SomeType = SomeBasicType | SomeUnionType
-
-export type SomeBasicParameterType = SomeBasicType | SomeUnionType
-
-type ZodEnumBase = z.ZodEnum<[string, ...string[]]>
-
-type ZodNativeEnumBase = z.ZodNativeEnum<any>
-
-export type SomeBasicType =
-  | SomeBasicTypeScalar
-  | z.ZodOptional<SomeBasicTypeScalar>
-  | z.ZodDefault<SomeBasicTypeScalar>
-
-export type SomeUnionType = SomeUnionTypeScalar | z.ZodOptional<SomeUnionType> | z.ZodDefault<SomeUnionType>
-
-export type SomeExclusiveZodType = SomeBasicTypeScalar
-
-export type SomeUnionTypeScalar = z.ZodUnion<
-  [SomeBasicTypeScalar, SomeBasicTypeScalar, ...SomeBasicTypeScalar[]]
->
-
-// prettier-ignore
-export type SomeBasicTypeScalar =
-  | z.ZodString
-  | ZodEnumBase
-  | ZodNativeEnumBase
-  | z.ZodNumber
-  | z.ZodBoolean
-  | z.ZodLiteral<number>
-  | z.ZodLiteral<string>
-  | z.ZodLiteral<boolean>
-
-// export const isUnionType = (type: SomeBasicType | SomeUnionType): type is SomeUnionType => {
-//   const type_ = stripOptionalAndDefault(type)
-//   const isUnion = type_._def.typeName === z.ZodFirstPartyTypeKind.ZodUnion
-//   return isUnion
-// }
-
-// export const getUnionScalar = (zodType: SomeUnionType): SomeUnionTypeScalar => {
-//   const type = ZodHelpers.stripOptionalAndDefault(zodType)
-//   return type
-// }
-
-// export const getBasicScalar = (zodType: SomeBasicType): SomeBasicTypeScalar => {
-//   const type = ZodHelpers.stripOptionalAndDefault(zodType)
-//   return type
-// }
diff --git a/packages/@molt/command/src/_entrypoints/extensions.ts b/packages/@molt/command/src/_entrypoints/extensions.ts
new file mode 100644
index 00000000..70ed96a1
--- /dev/null
+++ b/packages/@molt/command/src/_entrypoints/extensions.ts
@@ -0,0 +1 @@
+export { Zod } from '../extensions/zod/zod.js'
diff --git a/packages/@molt/command/src/entrypoints/types.ts b/packages/@molt/command/src/_entrypoints/types.ts
similarity index 100%
rename from packages/@molt/command/src/entrypoints/types.ts
rename to packages/@molt/command/src/_entrypoints/types.ts
diff --git a/packages/@molt/command/src/builders/command/constructor.ts b/packages/@molt/command/src/builders/command/constructor.ts
new file mode 100644
index 00000000..2e8e4835
--- /dev/null
+++ b/packages/@molt/command/src/builders/command/constructor.ts
@@ -0,0 +1,109 @@
+import { parse } from '../../executor/parse.js'
+import type { SomeExtension } from '../../extension.js'
+import { getLowerCaseEnvironment, lowerCaseObjectKeys } from '../../helpers.js'
+import type { ParameterBasicInput } from '../../Parameter/basic.js'
+import { Settings } from '../../Settings/index.js'
+import type { Type } from '../../Type/index.js'
+import * as ExclusiveBuilder from '../exclusive/constructor.js'
+import type { BuilderCommandState } from './state.js'
+import { createState } from './state.js'
+import type { CommandBuilder, ParameterConfiguration, RawArgInputs } from './types.js'
+
+export const create = (): CommandBuilder => {
+  return create_(createState())
+}
+
+const create_ = (state: BuilderCommandState): CommandBuilder => {
+  const builder: InternalRootBuilder = {
+    use: (extension) => {
+      const newState = {
+        ...state,
+        typeMapper: extension.typeMapper,
+      }
+      return create_(newState) as any
+    },
+    description: (description) => {
+      const newState = {
+        ...state,
+        newSettingsBuffer: [
+          ...state.newSettingsBuffer,
+          {
+            description,
+          },
+        ],
+      }
+      return create_(newState) as any
+    },
+    settings: (newSettings) => {
+      const newState = {
+        ...state,
+        newSettingsBuffer: [...state.newSettingsBuffer, newSettings],
+      }
+      return create_(newState) as any
+    },
+    parameter: (nameExpression, typeOrConfiguration) => {
+      const configuration = `type` in typeOrConfiguration ? typeOrConfiguration : { type: typeOrConfiguration } // prettier-ignore
+      const prompt = configuration.prompt ?? null
+      const type = state.typeMapper(configuration.type)
+      const parameter = {
+        _tag: `Basic`,
+        type,
+        nameExpression,
+        prompt: prompt as any, // eslint-disable-line
+      } satisfies ParameterBasicInput
+      const newState = {
+        ...state,
+        parameterInputs: {
+          ...state.parameterInputs,
+          [nameExpression]: parameter,
+        },
+      }
+      return create_(newState) as any
+    },
+    parametersExclusive: (label, builderContainer) => {
+      const input = builderContainer(ExclusiveBuilder.create(label, state))._.input // eslint-disable-line
+      const newState = {
+        ...state,
+        parameterInputs: {
+          ...state.parameterInputs,
+          [label]: input, // eslint-disable-line
+        },
+      }
+      return create_(newState) as any
+    },
+    parse: (argInputs) => {
+      const argInputsEnvironment = argInputs?.environment
+        ? lowerCaseObjectKeys(argInputs.environment)
+        : getLowerCaseEnvironment()
+      state.settings = {
+        ...Settings.getDefaults(argInputsEnvironment),
+      }
+      state.newSettingsBuffer.forEach((newSettings) =>
+        Settings.change(state.settings!, newSettings, argInputsEnvironment),
+      )
+      state.settings.typeMapper = state.typeMapper
+      return parse(state.settings, state.parameterInputs, argInputs)
+    },
+  }
+
+  return builder as any
+}
+
+//
+// Internal Types
+//
+
+interface Parameter {
+  (nameExpression: string, type: Type.Type): InternalRootBuilder
+  (nameExpression: string, configuration: ParameterConfiguration): InternalRootBuilder
+}
+
+// prettier-ignore
+interface InternalRootBuilder {
+  use: (extension:SomeExtension) => InternalRootBuilder
+  description: (description: string) => InternalRootBuilder
+  settings: (newSettings: Settings.Input) => InternalRootBuilder
+  parameter: Parameter
+  parametersExclusive: (label: string, builderContainer: any) => InternalRootBuilder
+  parse: (args: RawArgInputs) => object
+}
diff --git a/packages/@molt/command/src/builders/command/state.ts b/packages/@molt/command/src/builders/command/state.ts
new file mode 100644
index 00000000..6a6bed9a
--- /dev/null
+++ b/packages/@molt/command/src/builders/command/state.ts
@@ -0,0 +1,194 @@
+import type { Values } from '../../helpers.js'
+import type { HKT } from '../../helpers.js'
+import type { Settings } from '../../index.js'
+import type { ParameterBasicInput } from '../../Parameter/basic.js'
+import type { ParameterExclusiveInput } from '../../Parameter/exclusive.js'
+import type { Prompt } from '../../Parameter/types.js'
+import type { Type } from '../../Type/index.js'
+import type { ExclusiveParameterConfiguration } from '../exclusive/types.js'
+import type { IsPromptEnabledInParameterSettings, ParameterConfiguration } from './types.js'
+import type { Name } from '@molt/types'
+import type { Objects, Pipe } from 'hotscript'
+import type { Simplify } from 'type-fest'
+
+export const createState = (): BuilderCommandState => {
+  return {
+    typeMapper: (type) => type as any,
+    newSettingsBuffer: [],
+    settings: null,
+    parameterInputs: {},
+  }
+}
+
+export interface BuilderCommandState {
+  typeMapper: (value: unknown) => Type.Type
+  settings: null | Settings.Output
+  newSettingsBuffer: Settings.Input[]
+  parameterInputs: Record<string, ParameterBasicInput | ParameterExclusiveInput>
+}
+
+export namespace BuilderCommandState {
+  export interface TypeMapper<T extends Type.Type = Type.Type> extends HKT.Fn<T, T> {
+    return: T
+  }
+
+  export interface BaseEmpty extends Base {
+    IsPromptEnabled: false
+    ParametersExclusive: {} // eslint-disable-line
+    Parameters: {} // eslint-disable-line
+    Type: Type.Type
+    TypeMapper: HKT.IDFn<Type.Type<unknown>>
+  }
+
+  export type Base = {
+    IsPromptEnabled: boolean
+    Type: Type.Type
+    TypeMapper: HKT.Fn<unknown, Type.Type<unknown>>
+    ParametersExclusive: {
+      [label: string]: {
+        Optional: boolean
+        Parameters: {
+          [canonicalName: string]: {
+            NameParsed: Name.Data.NameParsed
+            NameUnion: string
+            Type: Type.Type
+          }
+        }
+      }
+    }
+    Parameters: {
+      [nameExpression: string]: {
+        NameParsed: Name.Data.NameParsed
+        NameUnion: string
+        Type: Type.Type
+      }
+    }
+  }
+
+  type ReservedParameterNames = 'help' | 'h'
+
+  // prettier-ignore
+  export type ValidateNameExpression<State extends Base, NameExpression extends string> = 
+    Name.Data.IsParseError<Name.Parse<NameExpression, { usedNames: GetUsedNames<State>; reservedNames: ReservedParameterNames }>> extends true
+        ? Name.Parse<NameExpression, { usedNames: GetUsedNames<State>; reservedNames: ReservedParameterNames }>
+        : NameExpression
+
+  export type GetUsedNames<State extends Base> = Values<State['Parameters']>['NameUnion']
+
+  export type ParametersConfigBase = Record<
+    string,
+    {
+      type: ParameterConfiguration['type']
+      prompt?: Prompt<any>
+    }
+  >
+
+  // prettier-ignore
+  export type SetExclusiveOptional<
+    $State extends Base,
+    Label extends string,
+    Value extends boolean,
+  > =
+    Pipe<$State, [
+      Objects.Update<'ParametersExclusive',
+        Objects.Assign<{
+          [_ in Label]: {
+            Optional: Value 
+            Parameters: $State['ParametersExclusive'][_]['Parameters']
+          }
+        }>
+      >
+    ]>
+
+  export type SetIsPromptEnabled<$State extends Base, value extends boolean> = Pipe<
+    $State,
+    [Objects.Update<'IsPromptEnabled', $State['IsPromptEnabled'] extends true ? true : value>]
+  >
+
+  export type AddParameter<
+    $State extends Base,
+    NameExpression extends string,
+    Configuration extends ParameterConfiguration<$State>,
+  > = Pipe<
+    $State,
+    [
+      Objects.Update<
+        'Parameters',
+        Objects.Assign<{
+          [_ in NameExpression]: CreateParameter<$State, NameExpression, Configuration>
+        }>
+      >,
+      Objects.Update<
+        'IsPromptEnabled',
+        $State['IsPromptEnabled'] extends true ? true : IsPromptEnabledInParameterSettings<Configuration>
+      >,
+    ]
+  >
+
+  // prettier-ignore
+  export type AddExclusiveParameter<
+    $State extends Base,
+    Label extends string,
+    NameExpression extends string,
+    Configuration extends ExclusiveParameterConfiguration<$State>
+  > =
+    Pipe<$State, [
+      Objects.Update<'ParametersExclusive',
+        Objects.Assign<$State['ParametersExclusive'] & {
+          [_ in Label]: {
+            Optional: $State['ParametersExclusive'][_]['Optional']
+            Parameters: {
+              [_ in NameExpression as Name.Data.GetCanonicalNameOrErrorFromParseResult<Name.Parse<NameExpression>>]: {
+                Type: HKT.Call<$State['TypeMapper'], Configuration['type']>
+                NameParsed: Name.Parse<NameExpression, { usedNames: GetUsedNames<$State>; reservedNames: ReservedParameterNames }>
+                NameUnion: Name.Data.GetNamesFromParseResult<Name.Parse<NameExpression, { usedNames: GetUsedNames<$State>; reservedNames: ReservedParameterNames }>>
+              }
+
+            }
+          }
+        }
+    >>]>
+
+  // prettier-ignore
+  export type CreateParameter<
+    $State          extends Base,
+    NameExpression  extends string,
+    Configuration   extends ParameterConfiguration<$State>,
+  > = {
+    Type: HKT.Call<$State['TypeMapper'], Configuration['type']>
+    NameParsed: Name.Parse<NameExpression, { usedNames: GetUsedNames<$State>; reservedNames: ReservedParameterNames }>
+    NameUnion: Name.Data.GetNamesFromParseResult<Name.Parse<NameExpression,{ usedNames: GetUsedNames<$State>; reservedNames: ReservedParameterNames }>>
+  }
+
+  // prettier-ignore
+  export type ToArgs<$State extends Base> =
+    $State['IsPromptEnabled'] extends true
+      ? Promise<ToArgs_<$State>>
+      : ToArgs_<$State>
+
+  // prettier-ignore
+  type ToArgs_<$State extends Base> =
+    Simplify<
+      {
+        [Name in keyof $State['Parameters'] & string as $State['Parameters'][Name]['NameParsed']['canonical']]:
+          Type.Infer<$State['Parameters'][Name]['Type']>
+      } &
+      {
+        [Label in keyof $State['ParametersExclusive'] & string]:
+          | Simplify<Values<{
+              [Name in keyof $State['ParametersExclusive'][Label]['Parameters']]:
+                {
+                  _tag: $State['ParametersExclusive'][Label]['Parameters'][Name]['NameParsed']['canonical']
+                  value: Type.Infer<$State['ParametersExclusive'][Label]['Parameters'][Name]['Type']>
+                }
+            }>>
+          | ($State['ParametersExclusive'][Label]['Optional'] extends true ? undefined : never)
+      }
+    >
+
+  // prettier-ignore
+  export type ToTypes<$State extends BuilderCommandState.Base> = {
+    [K in keyof $State['Parameters'] & string as $State['Parameters'][K]['NameParsed']['canonical']]:
+      $State['Parameters'][K]['Type']
+  }
+}
diff --git a/packages/@molt/command/src/builders/command/types.ts b/packages/@molt/command/src/builders/command/types.ts
new file mode 100644
index 00000000..d136523c
--- /dev/null
+++ b/packages/@molt/command/src/builders/command/types.ts
@@ -0,0 +1,70 @@
+import type { SomeExtension } from '../../extension.js'
+import type { HKT } from '../../helpers.js'
+import type { Prompter } from '../../lib/Prompter/Prompter.js'
+import type { OpeningArgs } from '../../OpeningArgs/index.js'
+import type { Prompt } from '../../Parameter/types.js'
+import type { Settings } from '../../Settings/index.js'
+import type { BuilderExclusiveInitial, SomeBuilderExclusive } from '../exclusive/types.js'
+// todo
+// eslint-disable-next-line
+import { BuilderCommandState } from './state.js'
+import type { Objects, Pipe } from 'hotscript'
+
+export interface ParameterConfiguration<
+  $State extends BuilderCommandState.Base = BuilderCommandState.BaseEmpty,
+> {
+  type: $State['Type']
+  prompt?: Prompt<HKT.Call<$State['TypeMapper'], this['type']>>
+}
+
+export type IsHasKey<Obj extends object, Key> = Key extends keyof Obj ? true : false
+
+// prettier-ignore
+export type IsPromptEnabledInParameterSettings<P extends ParameterConfiguration<any>> =
+  IsHasKey<P,'prompt'>                                      extends false     ? false :
+                                                                                IsPromptEnabled<P['prompt']>
+// prettier-ignore
+export type IsPromptEnabledInCommandSettings<P extends Settings.Input<any>> =
+  IsHasKey<P,'prompt'>                                      extends false     ? false :
+                                                                                IsPromptEnabled<P['prompt']>
+
+// prettier-ignore
+export type IsPromptEnabled<P extends Prompt<any>|undefined> =
+  P                                               extends undefined ? false :
+  P                                               extends false     ? false :
+  P                                               extends true      ? true  :
+  P                                               extends null      ? false :
+  Exclude<P, undefined|boolean|null>['enabled']   extends false     ? false :
+                                                                      true
+
+// prettier-ignore
+export interface CommandBuilder<$State extends BuilderCommandState.Base = BuilderCommandState.BaseEmpty> {
+  use<$Extension extends SomeExtension>(extension: $Extension): 
+    CommandBuilder<{
+      IsPromptEnabled: $State['IsPromptEnabled'],
+      Parameters: $State['Parameters'],
+      ParametersExclusive: $State['ParametersExclusive'],
+      Type: $Extension['types']['type']
+      TypeMapper: $Extension['types']['typeMapper']
+    }>
+  description                                                                                             (this:void, description:string):
+    CommandBuilder<$State>
+  parameter<NameExpression extends string, const Configuration extends ParameterConfiguration<$State>>    (this:void, name:BuilderCommandState.ValidateNameExpression<$State,NameExpression>, configuration:Configuration):
+    CommandBuilder<BuilderCommandState.AddParameter<$State,NameExpression,Configuration>>
+  parameter<NameExpression extends string, $Type extends $State['Type']>                                  (this:void, name:BuilderCommandState.ValidateNameExpression<$State,NameExpression>, type:$Type):
+    CommandBuilder<BuilderCommandState.AddParameter<$State, NameExpression, { type: $Type }>>
+  parametersExclusive<Label extends string, BuilderExclusive extends SomeBuilderExclusive<$State>>        (this:void, label:Label, ExclusiveBuilderContainer: (builder:BuilderExclusiveInitial<$State,Label>) => BuilderExclusive):
+    CommandBuilder<BuilderExclusive['_']['typeState']>
+  settings                                                                                  <S extends Settings.Input<$State>>(this:void, newSettings:S):
+    CommandBuilder<Pipe<$State, [Objects.Update<'IsPromptEnabled', Objects.Assign<$State['IsPromptEnabled'] extends true ? true : IsPromptEnabledInCommandSettings<S>>>]>>
+  parse                                                                                                   (this:void, inputs?:RawArgInputs):
+    BuilderCommandState.ToArgs<$State>
+}
+
+export type RawArgInputs = {
+  line?: OpeningArgs.Line.RawInputs
+  environment?: OpeningArgs.Environment.RawInputs
+  tty?: Prompter
+}
+
+export type SomeArgsNormalized = Record<string, unknown>
diff --git a/packages/@molt/command/src/builders/exclusive/constructor.ts b/packages/@molt/command/src/builders/exclusive/constructor.ts
new file mode 100644
index 00000000..3886bc90
--- /dev/null
+++ b/packages/@molt/command/src/builders/exclusive/constructor.ts
@@ -0,0 +1,58 @@
+import type { Pam } from '../../lib/Pam/index.js'
+import type { BuilderCommandState } from '../command/state.js'
+import type { BuilderParameterExclusiveState } from './state.js'
+import { createState } from './state.js'
+import type { SomeBuilderExclusiveInitial } from './types.js'
+
+export const create = (label: string, commandState: BuilderCommandState): SomeBuilderExclusiveInitial => {
+  return create_(commandState, createState(label))
+}
+
+const create_ = (
+  commandState: BuilderCommandState,
+  state: BuilderParameterExclusiveState,
+): SomeBuilderExclusiveInitial => {
+  const builder: SomeBuilderExclusiveInitial = {
+    parameter: (nameExpression: string, typeOrConfiguration) => {
+      const configuration = `type` in typeOrConfiguration ? typeOrConfiguration : { type: typeOrConfiguration } //  prettier-ignore
+      const newState = {
+        ...state,
+        input: {
+          ...state.input,
+          parameters: [
+            ...state.input.parameters,
+            {
+              nameExpression,
+              type: commandState.typeMapper(configuration.type),
+            },
+          ],
+        },
+      }
+      return create_(commandState, newState)
+    },
+
+    optional: () => {
+      const newState = {
+        ...state,
+        input: {
+          ...state.input,
+          optionality: { _tag: `optional` as const },
+        },
+      }
+      return create_(commandState, newState)
+    },
+    default: (tag: string, value: Pam.Value) => {
+      const newState = {
+        ...state,
+        input: {
+          ...state.input,
+          optionality: { _tag: `default` as const, tag, value },
+        },
+      }
+      return create_(commandState, newState)
+    },
+    _: state,
+  }
+
+  return builder
+}
diff --git a/packages/@molt/command/src/builders/exclusive/state.ts b/packages/@molt/command/src/builders/exclusive/state.ts
new file mode 100644
index 00000000..f085c438
--- /dev/null
+++ b/packages/@molt/command/src/builders/exclusive/state.ts
@@ -0,0 +1,27 @@
+import type { ParameterExclusiveInput } from '../../Parameter/exclusive.js'
+import type { BuilderCommandState } from '../command/state.js'
+
+export type BuilderParameterExclusiveState<
+  $State extends BuilderCommandState.Base = BuilderCommandState.Base,
+> = {
+  /**
+   * Used for build time. Type inference functionality.
+   */
+  typeState: $State
+  /**
+   * Used for runtime.
+   */
+  input: ParameterExclusiveInput<$State>
+}
+
+export const createState = (label: string): BuilderParameterExclusiveState => {
+  return {
+    typeState: undefined as any, // eslint-disable-line
+    input: {
+      label,
+      _tag: `Exclusive`,
+      optionality: { _tag: `required` },
+      parameters: [],
+    } satisfies ParameterExclusiveInput,
+  }
+}
diff --git a/packages/@molt/command/src/builders/exclusive/types.ts b/packages/@molt/command/src/builders/exclusive/types.ts
new file mode 100644
index 00000000..1208e955
--- /dev/null
+++ b/packages/@molt/command/src/builders/exclusive/types.ts
@@ -0,0 +1,58 @@
+import type { Type } from '../../Type/index.js'
+import type { BuilderCommandState } from '../command/state.js'
+import type { BuilderParameterExclusiveState } from './state.js'
+
+export interface ExclusiveParameterConfiguration<$State extends BuilderCommandState.Base> {
+  type: $State['Type']
+}
+
+// prettier-ignore
+interface Parameter<$State extends BuilderCommandState.Base, Label extends string> {
+  <NameExpression extends string, Configuration extends ExclusiveParameterConfiguration<$State>   >(name: BuilderCommandState.ValidateNameExpression<$State, NameExpression>, configuration: Configuration):
+    BuilderExclusiveInitial<BuilderCommandState.AddExclusiveParameter<$State, Label, NameExpression, Configuration>, Label>
+
+  <NameExpression extends string, $Type         extends $State['Type']>(name: BuilderCommandState.ValidateNameExpression<$State, NameExpression>, type: $Type              ):
+    // BuilderCommandState.AddExclusiveParameter<$State, Label, NameExpression, { type: $Type }>
+    BuilderExclusiveInitial<BuilderCommandState.AddExclusiveParameter<$State, Label, NameExpression, { type: $Type }>, Label>
+}
+
+// prettier-ignore
+export interface BuilderExclusiveInitial<$State extends BuilderCommandState.Base, Label extends string> {
+  _:
+    BuilderParameterExclusiveState<$State>
+  parameter:
+    Parameter<$State,Label>
+  optional:  () =>
+    BuilderExclusiveAfterOptional<BuilderCommandState.SetExclusiveOptional<$State, Label, true>>
+  default:  <Tag extends keyof $State['ParametersExclusive'][Label]['Parameters']>(tag: Tag, value: Type.Infer<$State['ParametersExclusive'][Label]['Parameters'][Tag]['Type']>) =>
+    BuilderExclusiveAfterDefault<BuilderCommandState.SetExclusiveOptional<$State,Label,false>>
+}
+
+export type BuilderExclusiveAfterOptional<$State extends BuilderCommandState.Base> = {
+  _: BuilderParameterExclusiveState<$State>
+}
+
+export type BuilderExclusiveAfterDefault<$State extends BuilderCommandState.Base> = {
+  _: BuilderParameterExclusiveState<$State>
+}
+
+export interface SomeParameter<$State extends BuilderCommandState.Base> {
+  (nameExpression: any, type: $State['Type']): any // eslint-disable-line
+  (nameExpression: any, configuration: ExclusiveParameterConfiguration<$State>): any // eslint-disable-line
+}
+
+export type SomeBuilderExclusiveInitial<
+  $State extends BuilderCommandState.Base = BuilderCommandState.BaseEmpty,
+> = {
+  _: any // eslint-disable-line
+  parameter: SomeParameter<$State>
+  optional: any // eslint-disable-line
+  default: (tag: any, value: any) => any // eslint-disable-line
+}
+
+export type SomeBuilderMutuallyExclusiveAfterOptional<$State extends BuilderCommandState.Base> =
+  BuilderExclusiveAfterOptional<$State>
+
+export type SomeBuilderExclusive<$State extends BuilderCommandState.Base> =
+  | SomeBuilderExclusiveInitial<$State>
+  | SomeBuilderMutuallyExclusiveAfterOptional<$State>
diff --git a/packages/@molt/command/src/eventPatterns.ts b/packages/@molt/command/src/eventPatterns.ts
index fc7e98ba..47d95e28 100644
--- a/packages/@molt/command/src/eventPatterns.ts
+++ b/packages/@molt/command/src/eventPatterns.ts
@@ -1,6 +1,7 @@
-import type { CommandParameter } from './CommandParameter/index.js'
 import type { Errors } from './Errors/index.js'
+import type { ArgumentValue } from './executor/types.js'
 import type { OpeningArgs } from './OpeningArgs/index.js'
+import type { ParameterBasicData } from './Parameter/basic.js'
 import type { Pattern } from './Pattern/Pattern.js'
 import type { Type } from './Type/index.js'
 
@@ -23,23 +24,23 @@ export type BasicParameterParseEvent =
 
 export interface BasicParameterParseEventOmitted {
   result: 'omitted'
-  spec: CommandParameter.Output.BasicData
+  spec: ParameterBasicData
 }
 
 export interface BasicParameterParseEventAccepted {
   result: 'accepted'
-  spec: CommandParameter.Output.BasicData
-  value: CommandParameter.ArgumentValue
+  spec: ParameterBasicData
+  value: ArgumentValue
 }
 
 export interface BasicParameterParseEventRejected {
   result: 'rejected'
-  spec: CommandParameter.Output.BasicData
+  spec: ParameterBasicData
   error: Errors.ErrorMissingArgument['name'] | Errors.ErrorInvalidArgument['name']
 }
 
 export const createEvent = (parseResult: OpeningArgs.ParseResultBasic) => {
-  const specData: CommandParameter.Output.BasicData = {
+  const specData: ParameterBasicData = {
     ...parseResult.parameter,
     _tag: `BasicData` as const,
     optionality: parseResult.parameter.type.optionality[`_tag`],
diff --git a/packages/@molt/command/src/executor/helpers/createParameters.ts b/packages/@molt/command/src/executor/helpers/createParameters.ts
new file mode 100644
index 00000000..30778df2
--- /dev/null
+++ b/packages/@molt/command/src/executor/helpers/createParameters.ts
@@ -0,0 +1,39 @@
+import type { ParameterBasic, ParameterBasicInput } from '../../Parameter/basic.js'
+import { parameterBasicCreate } from '../../Parameter/basic.js'
+import type { ParameterExclusive, ParameterExclusiveInput } from '../../Parameter/exclusive.js'
+import { parameterExclusiveCreate } from '../../Parameter/exclusive.js'
+import type { Parameter } from '../../Parameter/types.js'
+import type { Settings } from '../../Settings/index.js'
+import { Type } from '../../Type/index.js'
+import { Alge } from 'alge'
+
+/**
+ * Process the spec input into a normalized spec.
+ */
+export const createParameters = (
+  inputs: Record<string, ParameterBasicInput | ParameterExclusiveInput>,
+  settings: Settings.Output,
+): Parameter[] => {
+  const inputsWithHelp: Record<string, ParameterBasicInput | ParameterExclusiveInput> = settings.help
+    ? {
+        ...inputs,
+        '-h --help': helpParameter,
+      }
+    : inputs
+  const outputs = Object.values(inputsWithHelp).flatMap((input): (ParameterBasic | ParameterExclusive)[] =>
+    Alge.match(input)
+      .Basic((input) => [parameterBasicCreate(input, settings)])
+      .Exclusive((input) => parameterExclusiveCreate(input, settings))
+      .done(),
+  )
+
+  // dump({ outputs })
+  return outputs
+}
+
+const helpParameter: ParameterBasicInput = {
+  _tag: `Basic`,
+  type: Type.boolean({ optionality: { _tag: `default`, getValue: () => false } }),
+  nameExpression: `-h --help`,
+  prompt: false as any, // eslint-disable-line
+}
diff --git a/packages/@molt/command/src/executor/parse.ts b/packages/@molt/command/src/executor/parse.ts
index 7bcb07f6..86bbd908 100644
--- a/packages/@molt/command/src/executor/parse.ts
+++ b/packages/@molt/command/src/executor/parse.ts
@@ -1,5 +1,4 @@
-import type { RawArgInputs } from '../Command/root/types.js'
-import { CommandParameter } from '../CommandParameter/index.js'
+import type { RawArgInputs } from '../builders/command/types.js'
 import { createEvent } from '../eventPatterns.js'
 import { Help } from '../Help/index.js'
 import { getLowerCaseEnvironment, lowerCaseObjectKeys } from '../helpers.js'
@@ -11,8 +10,12 @@ import type {
   ParseResultExclusiveGroupError,
   ParseResultExclusiveGroupSupplied,
 } from '../OpeningArgs/OpeningArgs.js'
+import type { ParameterBasic, ParameterBasicInput } from '../Parameter/basic.js'
+import type { ParameterExclusiveInput } from '../Parameter/exclusive.js'
 import { match } from '../Pattern/Pattern.js'
+import { createParameters } from './helpers/createParameters.js'
 import { prompt } from './prompt.js'
+import type { ArgumentValue } from './types.js'
 import { Effect } from 'effect'
 
 export interface ParseProgressPostPromptAnnotation {
@@ -40,7 +43,7 @@ export interface ParseProgressPostPrompt {
       openingParseResult: OpeningArgs.ParseResult['basicParameters'][string]
       prompt: {
         enabled: boolean
-        arg: CommandParameter.ArgumentValue
+        arg: ArgumentValue
       }
     }
   >
@@ -65,7 +68,7 @@ export interface ParseProgressDone {
 
 export const parse = (
   settings: Settings.Output,
-  parameterSpecInputs: Record<string, CommandParameter.Input>,
+  parameterInputs: Record<string, ParameterBasicInput | ParameterExclusiveInput>,
   argInputs: RawArgInputs,
 ) => {
   const testDebuggingNoExit = process.env[`testing_molt`] === `true`
@@ -76,13 +79,13 @@ export const parse = (
     : getLowerCaseEnvironment()
 
   // todo handle concept of specs themselves having errors
-  const specsResult = {
-    specs: CommandParameter.process(parameterSpecInputs, settings),
+  const parametersResult = {
+    parameters: createParameters(parameterInputs, settings),
   }
   // dump(specsResult)
 
   const openingArgsResult = OpeningArgs.parse({
-    parameters: specsResult.specs,
+    parameters: parametersResult.parameters,
     line: argInputsLine,
     environment: argInputsEnvironment,
   })
@@ -108,7 +111,7 @@ export const parse = (
   }
 
   if (argInputsPrompter) {
-    const basicSpecs = specsResult.specs.filter((_): _ is CommandParameter.Output.Basic => _._tag === `Basic`)
+    const basicSpecs = parametersResult.parameters.filter((_): _ is ParameterBasic => _._tag === `Basic`)
     for (const spec of basicSpecs) {
       const promptEnabled =
         (spec.prompt.when !== null && spec.prompt.enabled !== false) ||
@@ -140,7 +143,7 @@ export const parse = (
     openingArgsResult.basicParameters[`help`].value === true
 
   if (askedForHelp) {
-    settings.onOutput(Help.render(specsResult.specs, settings) + `\n`)
+    settings.onOutput(Help.render(parametersResult.parameters, settings) + `\n`)
     if (!testDebuggingNoExit) process.exit(0)
     return undefined as never // When testing, with process.exit mock, we WILL reach this case
   }
@@ -174,7 +177,7 @@ export const parse = (
         argumentErrors.map((_) => _.errors.map((_) => _.message).join(`\nX `)).join(`\nX `) +
         `\n\nHere are the docs for this command:\n`
       settings.onOutput(message + `\n`)
-      settings.onOutput(Help.render(specsResult.specs, settings) + `\n`)
+      settings.onOutput(Help.render(parametersResult.parameters, settings) + `\n`)
     }
     if (settings.onError === `exit` && !testDebuggingNoExit) {
       process.exit(1)
@@ -213,7 +216,7 @@ export const parse = (
                 : null,
             ]
           })
-          .filter((kv): kv is [string, CommandParameter.ArgumentValue] => kv[1] !== null),
+          .filter((kv): kv is [string, ArgumentValue] => kv[1] !== null),
       ),
       ...Object.fromEntries(
         Object.values(parseProgressPostPrompts.mutuallyExclusiveParameters)
@@ -226,7 +229,7 @@ export const parse = (
      * Handle the distinct case of no arguments. Sometimes the CLI author wants this to mean "show help".
      */
     if (settings.helpOnNoArguments && Object.values(args).length === 0) {
-      settings.onOutput(Help.render(specsResult.specs, settings) + `\n`)
+      settings.onOutput(Help.render(parametersResult.parameters, settings) + `\n`)
       if (!testDebuggingNoExit) process.exit(0)
       throw new Error(`missing args`) // When testing, with process.exit mock, we will reach this case
     }
diff --git a/packages/@molt/command/src/executor/prompt.ts b/packages/@molt/command/src/executor/prompt.ts
index 445d1dc0..13ae109f 100644
--- a/packages/@molt/command/src/executor/prompt.ts
+++ b/packages/@molt/command/src/executor/prompt.ts
@@ -1,4 +1,3 @@
-import { CommandParameter } from '../CommandParameter/index.js'
 import type { Prompter } from '../lib/Prompter/index.js'
 import { Tex } from '../lib/Tex/index_.js'
 import { Text } from '../lib/Text/index.js'
@@ -44,7 +43,7 @@ export const prompt = (
         })
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const arg = yield* _(asking)
-        const validationResult = CommandParameter.validate(parameter, arg)
+        const validationResult = parameter.type.validate(arg)
         if (validationResult._tag === `Right`) {
           // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
           args[parameter.name.canonical] = validationResult.right
diff --git a/packages/@molt/command/src/CommandParameter/types.ts b/packages/@molt/command/src/executor/types.ts
similarity index 89%
rename from packages/@molt/command/src/CommandParameter/types.ts
rename to packages/@molt/command/src/executor/types.ts
index 72e0e281..5390b83c 100644
--- a/packages/@molt/command/src/CommandParameter/types.ts
+++ b/packages/@molt/command/src/executor/types.ts
@@ -1,7 +1,5 @@
 import type { Pam } from '../lib/Pam/index.js'
 
-export * from './zod.js'
-
 export type ArgumentValueMutuallyExclusive = {
   _tag: string
   value: Pam.Value
diff --git a/packages/@molt/command/src/extension.ts b/packages/@molt/command/src/extension.ts
new file mode 100644
index 00000000..916b970f
--- /dev/null
+++ b/packages/@molt/command/src/extension.ts
@@ -0,0 +1,27 @@
+import type { HKT } from './helpers.js'
+import { runtimeIgnore } from './Type/helpers.js'
+
+export type SomeExtension = Extension<any, HKT.Fn<any, any>>
+
+export interface Extension<$Type, $TypeMapper extends HKT.Fn<$Type, unknown>> {
+  types: {
+    type: $Type
+    typeMapper: $TypeMapper
+  }
+  name: string
+  typeMapper: (type: $Type) => HKT.Call<$TypeMapper, $Type>
+}
+
+export const createExtension = <$Type extends unknown, $TypeMapper extends HKT.Fn<$Type, unknown>>(params: {
+  name: string
+  type: (type: $Type) => HKT.Call<$TypeMapper, $Type>
+}): Extension<$Type, $TypeMapper> => {
+  return {
+    name: params.name,
+    typeMapper: params.type,
+    types: {
+      type: runtimeIgnore as $Type,
+      typeMapper: runtimeIgnore as $TypeMapper,
+    },
+  }
+}
diff --git a/packages/@molt/command/src/lib/zodHelpers/guards.ts b/packages/@molt/command/src/extensions/zod/guards.ts
similarity index 100%
rename from packages/@molt/command/src/lib/zodHelpers/guards.ts
rename to packages/@molt/command/src/extensions/zod/guards.ts
diff --git a/packages/@molt/command/src/TypeAdaptors/zod/zod.ts b/packages/@molt/command/src/extensions/zod/typeAdaptor/runtime.ts
similarity index 62%
rename from packages/@molt/command/src/TypeAdaptors/zod/zod.ts
rename to packages/@molt/command/src/extensions/zod/typeAdaptor/runtime.ts
index 4c9853cd..04dc11e8 100644
--- a/packages/@molt/command/src/TypeAdaptors/zod/zod.ts
+++ b/packages/@molt/command/src/extensions/zod/typeAdaptor/runtime.ts
@@ -1,41 +1,18 @@
-import { ZodHelpers } from '../../lib/zodHelpers/index.js'
-import { Type } from '../../Type/index.js'
+import { Type } from '../../../Type/index.js'
+import {
+  isBoolean,
+  isDefault,
+  isEnum,
+  isLiteral,
+  isNativeEnum,
+  isNumber,
+  isOptional,
+  isString,
+  isUnion,
+} from '../guards.js'
 import { Alge } from 'alge'
 import type { Simplify } from 'type-fest'
-import { z } from 'zod'
-
-// prettier-ignore
-export type FromZod<ZodType extends z.ZodType> =
-  ZodType extends z.ZodOptional<infer T>
-    ? Type.Union<[FromZodNonOptional<T>, Type.Literal<undefined>]>
-    : FromZodNonOptional<ZodType>
-
-// prettier-ignore
-export type FromZodNonOptional<ZodType extends z.ZodType> =
-  ZodType extends ZodTypeScalar              ? FromZodScalar<ZodType> :
-  ZodType extends z.ZodDefault<infer T>      ? FromZodScalar<T> :
-  ZodType extends z.ZodUnion<infer T>        ? Type.Union<{[i in keyof T]: FromZodScalar<T[i]>}> :
-                                                never
-
-// prettier-ignore
-export type FromZodScalar<ZodType extends ZodTypeScalar> =
-  ZodType extends z.ZodString                                           ? Type.Scalar.String :
-  ZodType extends z.ZodBoolean                                          ? Type.Scalar.Boolean :
-  ZodType extends z.ZodLiteral<infer T extends boolean|string|number>   ? Type.Scalar.Literal<T> :
-  ZodType extends z.ZodNumber                                           ? Type.Scalar.Number :
-  ZodType extends z.ZodEnum<infer T>                                    ? Type.Scalar.Enumeration<T> :
-  ZodType extends z.ZodNativeEnum<infer T extends z.EnumLike>           ? Type.Scalar.Enumeration<EnumerationMembersFromZodEnumLike<T>> :
-                                                                          never
-type EnumerationMembersFromZodEnumLike<T extends z.EnumLike> = T[keyof T][]
-
-type ZodTypeScalar =
-  | z.ZodString
-  | z.ZodBoolean
-  | z.ZodLiteral<any>
-  | z.ZodNumber
-  | z.ZodEnum<any>
-  | z.ZodNativeEnum<any>
-// prettier-ignore
+import type { z } from 'zod'
 
 export const fromZod = (zodType: z.ZodFirstPartySchemaTypes): Type.Type => _fromZod(zodType, {})
 
@@ -44,30 +21,28 @@ const _fromZod = (zodType: z.ZodFirstPartySchemaTypes,previous:{description?:str
   const zt = zodType
   const description = previous.description ?? zt.description
 
-  const isOptional = zt._def.typeName === z.ZodFirstPartyTypeKind.ZodOptional
-  const hasDefault = zt._def.typeName === z.ZodFirstPartyTypeKind.ZodDefault
-  const defaultGetter = hasDefault ? (zt._def.defaultValue as () => unknown) : null
+  const defaultGetter = isDefault(zt) ? (zt._def.defaultValue as () => unknown) : null
   const optionality: Type.Optionality<any> = previous.optionality ?? (defaultGetter
     ? { _tag: `default`, getValue: () => defaultGetter() }
-    : isOptional
+    : isOptional(zt)
     ? { _tag: `optional` }
     : { _tag: `required` })
   
-  if (ZodHelpers.isString(zt)) {
+  if (isString(zt)) {
     const {refinements,transformations} = mapZodStringChecksAndTransformations(zt._def.checks)
     return Type.string({ optionality, refinements, transformations, description })
   }
-  if (ZodHelpers.isNumber(zt)) {
+  if (isNumber(zt)) {
     const {refinements} = mapZodNumberChecksAndTransformations(zt._def.checks)
     return Type.number({ optionality, refinements, description })
   }
-  if (ZodHelpers.isEnum(zt))            return Type.enumeration({ optionality, members: zt._def.values, description }) // eslint-disable-line
-  if (ZodHelpers.isNativeEnum(zt))      return Type.enumeration({ optionality, members: Object.values<any>(zt._def.values), description })
-  if (ZodHelpers.isBoolean(zt))         return Type.boolean({ optionality, description })
-  if (ZodHelpers.isLiteral(zt))         return Type.literal({ optionality, value: zt._def.value, description }) // eslint-disable-line
-  if (ZodHelpers.isDefault(zt))         return _fromZod(zt._def.innerType,{...previous,description,optionality})
-  if (ZodHelpers.isOptional(zt))        return _fromZod(zt._def.innerType,{...previous,description,optionality})
-  if (ZodHelpers.isUnion(zt))           {
+  if (isEnum(zt))            return Type.enumeration({ optionality, members: zt._def.values, description }) // eslint-disable-line
+  if (isNativeEnum(zt))      return Type.enumeration({ optionality, members: Object.values<any>(zt._def.values), description })
+  if (isBoolean(zt))         return Type.boolean({ optionality, description })
+  if (isLiteral(zt))         return Type.literal({ optionality, value: zt._def.value, description }) // eslint-disable-line
+  if (isDefault(zt))         return _fromZod(zt._def.innerType,{...previous,description,optionality})
+  if (isOptional(zt))        return _fromZod(zt._def.innerType,{...previous,description,optionality})
+  if (isUnion(zt))           {
     if (!Array.isArray(zt._def.options)) throw new Error(`Unsupported zodType: ${JSON.stringify(zt[`_def`])}`)
     const members = zt._def.options.map((_: {_def:{description:undefined|string}}) => {
       const description = _._def.description
@@ -75,7 +50,6 @@ const _fromZod = (zodType: z.ZodFirstPartySchemaTypes,previous:{description?:str
     })
     return Type.union({ optionality, members_: members, description })
   }
-  // console.log(zt)
   throw new Error(`Unsupported zodType: ${JSON.stringify(zt[`_def`])}`)
 }
 
diff --git a/packages/@molt/command/src/extensions/zod/typeAdaptor/types.ts b/packages/@molt/command/src/extensions/zod/typeAdaptor/types.ts
new file mode 100644
index 00000000..c537db53
--- /dev/null
+++ b/packages/@molt/command/src/extensions/zod/typeAdaptor/types.ts
@@ -0,0 +1,36 @@
+import type { Type } from '../../../Type/index.js'
+import type { z } from 'zod'
+
+// prettier-ignore
+export type FromZod<ZodType extends z.ZodType> =
+  ZodType extends z.ZodOptional<infer T>
+    ? Type.Union<[FromZodRequired<T>, Type.Literal<undefined>]>
+    : FromZodRequired<ZodType>
+
+// prettier-ignore
+export type FromZodRequired<ZodType extends z.ZodType> =
+  ZodType extends ZodTypeScalar              ? FromZodScalar<ZodType> :
+  ZodType extends z.ZodDefault<infer T>      ? FromZodScalar<T> :
+  ZodType extends z.ZodUnion<infer T>        ? Type.Union<{[i in keyof T]: FromZodScalar<T[i]>}> :
+                                                never
+
+// prettier-ignore
+export type FromZodScalar<ZodType extends ZodTypeScalar> =
+  ZodType extends z.ZodString                                           ? Type.Scalar.String :
+  ZodType extends z.ZodLiteral<infer T extends boolean|string|number>   ? Type.Scalar.Literal<T> :
+  ZodType extends z.ZodNumber                                           ? Type.Scalar.Number :
+  ZodType extends z.ZodBoolean                                          ? Type.Scalar.Boolean :
+  ZodType extends z.ZodEnum<infer T>                                    ? Type.Scalar.Enumeration<T> :
+  ZodType extends z.ZodNativeEnum<infer T extends z.EnumLike>           ? Type.Scalar.Enumeration<EnumerationMembersFromZodEnumLike<T>> :
+                                                                          never
+
+type EnumerationMembersFromZodEnumLike<T extends z.EnumLike> = T[keyof T][]
+
+type ZodTypeScalar =
+  | z.ZodString
+  | z.ZodBoolean
+  | z.ZodLiteral<any>
+  | z.ZodNumber
+  | z.ZodEnum<any>
+  | z.ZodNativeEnum<any>
+// prettier-ignore
diff --git a/packages/@molt/command/src/CommandParameter/zod.ts b/packages/@molt/command/src/extensions/zod/types.ts
similarity index 52%
rename from packages/@molt/command/src/CommandParameter/zod.ts
rename to packages/@molt/command/src/extensions/zod/types.ts
index 26bab26c..c634e5e7 100644
--- a/packages/@molt/command/src/CommandParameter/zod.ts
+++ b/packages/@molt/command/src/extensions/zod/types.ts
@@ -1,24 +1,21 @@
 import type { z } from 'zod'
 
+export type ZodType = SomeBasicType | SomeUnionType
+
 type ZodEnumBase = z.ZodEnum<[string, ...string[]]>
 
 type ZodNativeEnumBase = z.ZodNativeEnum<any>
 
-export type SomeBasicType =
+type SomeBasicType =
   | SomeBasicTypeScalar
   | z.ZodOptional<SomeBasicTypeScalar>
   | z.ZodDefault<SomeBasicTypeScalar>
 
-export type SomeUnionType = SomeUnionTypeScalar | z.ZodOptional<SomeUnionType> | z.ZodDefault<SomeUnionType>
-
-export type SomeExclusiveZodType = SomeBasicTypeScalar
+type SomeUnionType = SomeUnionTypeScalar | z.ZodOptional<SomeUnionType> | z.ZodDefault<SomeUnionType>
 
-export type SomeUnionTypeScalar = z.ZodUnion<
-  [SomeBasicTypeScalar, SomeBasicTypeScalar, ...SomeBasicTypeScalar[]]
->
+type SomeUnionTypeScalar = z.ZodUnion<[SomeBasicTypeScalar, SomeBasicTypeScalar, ...SomeBasicTypeScalar[]]>
 
-// prettier-ignore
-export type SomeBasicTypeScalar =
+type SomeBasicTypeScalar =
   | z.ZodString
   | ZodEnumBase
   | ZodNativeEnumBase
diff --git a/packages/@molt/command/src/extensions/zod/zod.ts b/packages/@molt/command/src/extensions/zod/zod.ts
new file mode 100644
index 00000000..37b3eaca
--- /dev/null
+++ b/packages/@molt/command/src/extensions/zod/zod.ts
@@ -0,0 +1,18 @@
+import { createExtension } from '../../extension.js'
+import type { HKT } from '../../helpers.js'
+import { fromZod } from './typeAdaptor/runtime.js'
+import type { FromZod } from './typeAdaptor/types.js'
+import type { ZodType } from './types.js'
+
+export interface ZodTypeMapper extends HKT.Fn<unknown> {
+  // @ts-expect-error - todo with Pierre
+  return: FromZod<this['params']>
+}
+
+// @ts-expect-error - todo with Pierre
+export const Zod = createExtension<ZodType, ZodTypeMapper>({
+  name: `Zod`,
+  type: (zodType) => {
+    return fromZod(zodType) as any
+  },
+})
diff --git a/packages/@molt/command/src/helpers.ts b/packages/@molt/command/src/helpers.ts
index 5b6b36e7..dc4d377e 100644
--- a/packages/@molt/command/src/helpers.ts
+++ b/packages/@molt/command/src/helpers.ts
@@ -1,6 +1,5 @@
 import { Either } from 'effect'
 import camelCase from 'lodash.camelcase'
-import { z } from 'zod'
 
 export const BooleanLookup = {
   true: true,
@@ -17,8 +16,6 @@ export const stripeDashPrefix = (flagNameInput: string): string => {
   return flagNameInput.replace(/^-+/, ``)
 }
 
-export const zodPassthrough = <T>() => z.any().transform((_) => _ as T)
-
 export type Values<T> = T[keyof T]
 
 export const getLowerCaseEnvironment = (): NodeJS.ProcessEnv => lowerCaseObjectKeys(process.env)
@@ -78,3 +75,24 @@ export const entries = <O extends object>(
 export const casesExhausted = (_: never): never => {
   throw new Error(`Cases exhausted: ${_}`) // eslint-disable-line
 }
+
+export namespace HKT {
+  /**
+   * Model a Higher Kinded Type (HKT).
+   */
+  export interface Fn<Params = unknown, Return = unknown> {
+    params: Params
+    return: Return
+  }
+
+  /**
+   * Apply a Higher Kinded Type (HKT).
+   */
+  export type Call<F extends Fn, P> = (F & { params: P })['return']
+
+  export type ID<T> = IDFn<T>
+
+  export interface IDFn<T> extends HKT.Fn<T> {
+    return: this['params']
+  }
+}
diff --git a/packages/@molt/command/src/index_.ts b/packages/@molt/command/src/index_.ts
index 556abd3b..8f7cca1e 100644
--- a/packages/@molt/command/src/index_.ts
+++ b/packages/@molt/command/src/index_.ts
@@ -1,2 +1,2 @@
-export { create } from './Command/root/constructor.js'
+export { create } from './builders/command/constructor.js'
 export { eventPatterns } from './eventPatterns.js'
diff --git a/packages/@molt/command/src/lib/zodHelpers/index.ts b/packages/@molt/command/src/lib/zodHelpers/index.ts
deleted file mode 100644
index 05cacd44..00000000
--- a/packages/@molt/command/src/lib/zodHelpers/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export * as ZodHelpers from './index_.js'
diff --git a/packages/@molt/command/src/lib/zodHelpers/index_.ts b/packages/@molt/command/src/lib/zodHelpers/index_.ts
deleted file mode 100644
index b7a599b7..00000000
--- a/packages/@molt/command/src/lib/zodHelpers/index_.ts
+++ /dev/null
@@ -1,88 +0,0 @@
-import type { RenameKey } from '../prelude.js'
-import type { Simplify } from 'type-fest'
-import { z } from 'zod'
-
-export * from './guards.js'
-
-export type ZodDateCheck = Simplify<RenameKey<z.ZodDateCheck, 'kind', '_tag'>>
-
-export type ZodNumberCheck = Simplify<RenameKey<z.ZodNumberCheck, 'kind', '_tag'>>
-
-export type ZodStringCheck = Simplify<RenameKey<z.ZodStringCheck, 'kind', '_tag'>>
-
-export type ZodPrimitive = 'ZodBoolean' | 'ZodNumber' | 'ZodString' | 'ZodEnum'
-
-export type Primitive = 'boolean' | 'number' | 'string'
-
-export const stripOptionalAndDefault = <T extends z.ZodFirstPartySchemaTypes>(
-  type: T,
-): Exclude<T, z.ZodOptional<any> | z.ZodDefault<any>> => {
-  if (type instanceof z.ZodOptional) {
-    return stripOptionalAndDefault(type._def.innerType)
-  }
-  if (type instanceof z.ZodDefault) {
-    return stripOptionalAndDefault(type._def.innerType)
-  }
-  return type as any
-}
-
-export const isUnionUnwrapped = (type: z.ZodFirstPartySchemaTypes) => {
-  const type_ = stripOptionalAndDefault(type)
-  const isUnion = type_._def.typeName === z.ZodFirstPartyTypeKind.ZodUnion
-  return isUnion
-}
-
-export const getEnum = (type: z.ZodTypeAny): null | z.ZodEnum<[string, ...string[]]> => {
-  if (!(`_def` in type)) throw new Error(`Expected a Zod schema.`)
-  if (!(`typeName` in type._def)) throw new Error(`Expected a Zod schema.`)
-
-  if (type instanceof z.ZodNullable) {
-    return getEnum(type.unwrap() as z.ZodTypeAny)
-  }
-
-  // eslint-disable-next-line
-  if (type instanceof z.ZodDefault) {
-    // eslint-disable-next-line
-    return getEnum(type._def.innerType)
-  }
-
-  // eslint-disable-next-line
-  if (type instanceof z.ZodOptional) {
-    return getEnum(type.unwrap() as z.ZodTypeAny)
-  }
-
-  if (type instanceof z.ZodEnum) {
-    return type
-  }
-
-  return null
-}
-
-export const getZodPrimitive = (schema: z.ZodTypeAny): ZodPrimitive => {
-  if (!(`_def` in schema)) throw new Error(`Expected a Zod schema.`)
-  if (!(`typeName` in schema._def)) throw new Error(`Expected a Zod schema.`)
-
-  // eslint-disable-next-line
-  if (schema instanceof z.ZodDefault) {
-    // if (schema._def.typeName === `ZodDefault`) {
-    // eslint-disable-next-line
-    return getZodPrimitive(schema._def.innerType)
-  }
-
-  // eslint-disable-next-line
-  if (schema instanceof z.ZodOptional) {
-    // if (schema._def.typeName === `ZodOptional`) {
-    // eslint-disable-next-line
-    return getZodPrimitive(schema._def.innerType)
-  }
-
-  // eslint-disable-next-line
-  return schema._def.typeName
-}
-
-export const ZodPrimitiveToPrimitive = {
-  ZodBoolean: `boolean`,
-  ZodString: `string`,
-  ZodEnum: `string`,
-  ZodNumber: `number`,
-} as const
diff --git a/packages/@molt/command/tests/_/helpers.ts b/packages/@molt/command/tests/_/helpers.ts
index acbf54e8..930456c3 100644
--- a/packages/@molt/command/tests/_/helpers.ts
+++ b/packages/@molt/command/tests/_/helpers.ts
@@ -1,6 +1,11 @@
+import { Zod } from '../../src/_entrypoints/extensions.js'
+import { Command } from '../../src/index.js'
 import { isPromiseLikeValue } from '../../src/lib/prelude.js'
 import { z } from 'zod'
 
+// todo enable throw on all tests
+export const $ = Command.create().use(Zod) //.settings({ onError: `throw` })
+
 export const assertAssignable = <T>(_: T): [T] => 0 as any // eslint-disable-line
 export const as = <T>(): T => undefined as any // eslint-disable-line
 export const n = z.number()
diff --git a/packages/@molt/command/tests/chaining/chaining.spec.ts b/packages/@molt/command/tests/chaining/chaining.spec.ts
index 8740f193..cc17e25a 100644
--- a/packages/@molt/command/tests/chaining/chaining.spec.ts
+++ b/packages/@molt/command/tests/chaining/chaining.spec.ts
@@ -1,4 +1,4 @@
-import { Command } from '../../src/index.js'
+import { $ } from '../_/helpers.js'
 import { describe, expect, it } from 'vitest'
 import { z } from 'zod'
 
@@ -9,35 +9,35 @@ describe(`errors`, () => {
   describe(`reserved flag`, () => {
     it(`help`, () => {
       // @ts-expect-error test
-      Command.create().parameter(`help`, s)
+      $.parameter(`help`, s)
     })
     it(`help`, () => {
       // @ts-expect-error test
-      Command.create().parameter(`h`, s)
+      $.parameter(`h`, s)
     })
     it(`h help`, () => {
       // @ts-expect-error test
-      Command.create().parameter(`h help`, s)
+      $.parameter(`h help`, s)
     })
   })
   describe(`reuse flag`, () => {
     it(`long flag`, () => {
-      c = Command.create().parameter(`alpha`, s)
+      c = $.parameter(`alpha`, s)
       // @ts-expect-error test
       c.parameter(`alpha`, s)
     })
     it(`long flag alias`, () => {
-      c = Command.create().parameter(`alpha bravo`, s)
+      c = $.parameter(`alpha bravo`, s)
       // @ts-expect-error test
       c.parameter(`bravo`, s)
     })
     it(`short flag`, () => {
-      c = Command.create().parameter(`a`, s)
+      c = $.parameter(`a`, s)
       // @ts-expect-error test
       c.parameter(`a`, s)
     })
     it(`short flag alias`, () => {
-      c = Command.create().parameter(`a b`, s)
+      c = $.parameter(`a b`, s)
       // @ts-expect-error test
       c.parameter(`b`, s)
     })
@@ -45,8 +45,7 @@ describe(`errors`, () => {
 })
 
 it(`works`, () => {
-  const args = Command.create()
-    .parameter(`foo`, z.string())
+  const args = $.parameter(`foo`, z.string())
     .parameter(`bar`, z.string())
     .parse({ line: [`--foo`, `1`, `--bar`, `2`] })
   expect(args).toMatchObject({ foo: `1`, bar: `2` })
diff --git a/packages/@molt/command/tests/environment/case.spec.ts b/packages/@molt/command/tests/environment/case.spec.ts
index 89069fab..e64eaca5 100644
--- a/packages/@molt/command/tests/environment/case.spec.ts
+++ b/packages/@molt/command/tests/environment/case.spec.ts
@@ -1,17 +1,16 @@
-import { Command } from '../../src/index.js'
-import { s } from '../_/helpers.js'
+import { $, s } from '../_/helpers.js'
 import { environmentManager } from './__helpers__.js'
 import { expect } from 'vitest'
 import { it } from 'vitest'
 
 it(`snake case environment variables are matched to parameters`, () => {
   environmentManager.set(`cli_param_foo_bar`, `toto`)
-  const args = Command.create().parameter(`fooBar`, s).parse({ line: [] })
+  const args = $.parameter(`fooBar`, s).parse({ line: [] })
   expect(args).toMatchObject({ fooBar: `toto` })
 })
 
 it(`environment variables are read case insensitive`, () => {
   environmentManager.set(`CLI_param_fOo_bAR`, `toto`)
-  const args = Command.create().parameter(`fooBar`, s).parse({ line: [] })
+  const args = $.parameter(`fooBar`, s).parse({ line: [] })
   expect(args).toMatchObject({ fooBar: `toto` })
 })
diff --git a/packages/@molt/command/tests/environment/global/prefix.spec.ts b/packages/@molt/command/tests/environment/global/prefix.spec.ts
index cf1f46fe..db3d4901 100644
--- a/packages/@molt/command/tests/environment/global/prefix.spec.ts
+++ b/packages/@molt/command/tests/environment/global/prefix.spec.ts
@@ -1,35 +1,32 @@
-import { Command } from '../../../src/index.js'
-import { s } from '../../_/helpers.js'
+import { $, s } from '../../_/helpers.js'
 import { stdout } from '../../_/mocks.js'
 import { environmentManager } from '../__helpers__.js'
 import { beforeEach, expect } from 'vitest'
 import { describe, it } from 'vitest'
 
+let args
+
 it(`can be disabled`, () => {
-  const args = Command.create()
-    .parameter(`--foo`, s)
+  args = $.parameter(`--foo`, s)
     .settings({ parameters: { environment: { $default: { prefix: false } } } })
     .parse({ line: [], environment: { foo: `bar` } })
   expect(args).toMatchObject({ foo: `bar` })
 })
 it(`can be customized to a different prefix`, () => {
-  const args = Command.create()
-    .parameter(`--foo`, s)
+  args = $.parameter(`--foo`, s)
     .settings({ parameters: { environment: { $default: { prefix: `FOO` } } } })
     .parse({ line: [], environment: { FOO_foo: `bar` } })
   expect(args).toMatchObject({ foo: `bar` })
 })
 it(`can be customized to multiple accepted different prefixes`, () => {
-  const args = Command.create()
-    .parameter(`--foo`, s)
+  args = $.parameter(`--foo`, s)
     .parameter(`--bar`, s)
     .settings({ parameters: { environment: { $default: { prefix: [`FOO`, `BAR`] } } } })
     .parse({ line: [], environment: { FOO_foo: `qux1`, BAR_bar: `qux2` } })
   expect(args).toMatchObject({ foo: `qux1`, bar: `qux2` })
 })
 it(`defaults to CLI_PARAM or CLI_PARAMETERS`, () => {
-  const args = Command.create()
-    .parameter(`--foo`, s)
+  args = $.parameter(`--foo`, s)
     .parameter(`--bar`, s)
     .parse({
       line: [],
@@ -43,16 +40,14 @@ it(`defaults to CLI_PARAM or CLI_PARAMETERS`, () => {
 describe(`error`, () => {
   it(`when using prefix and there is a typo`, () => {
     // TODO show not just envar prefix in error message json
-    Command.create()
-      .parameter(`--foo`, s)
+    $.parameter(`--foo`, s)
       .settings({ helpOnNoArguments: false })
       .parse({ line: [], environment: { cli_param_bar: `qux1` } })
     expect(stdout.mock.calls).toMatchSnapshot()
   })
   it(`when using multiple prefixes and args passed for all param variations`, () => {
     // TODO show not just envar prefix in error message json
-    Command.create()
-      .parameter(`--foo`, s)
+    $.parameter(`--foo`, s)
       .parameter(`--bar`, s)
       .parse({
         line: [],
@@ -73,18 +68,18 @@ describe(`default environment argument parameter name prefix`, () => {
 
   it(`argument can be passed by CLI_PARAMETER prefix`, () => {
     environmentManager.set(`cli_parameter_foo`, `bar`)
-    const args = Command.create().parameter(`--foo`, s).parse({ line: [] })
+    args = $.parameter(`--foo`, s).parse({ line: [] })
     expect(args).toMatchObject({ foo: `bar` })
   })
   it(`argument can be passed by CLI_PARAM prefix`, () => {
     environmentManager.set(`cli_param_foo`, `bar`)
-    const args = Command.create().parameter(`--foo`, s).parse({ line: [] })
+    args = $.parameter(`--foo`, s).parse({ line: [] })
     expect(args).toMatchObject({ foo: `bar` })
   })
   it(`when both argument CLI_PARAM and CLI_PARAMETER are passed then an error is thrown`, () => {
     environmentManager.set(`cli_param_foo`, `bar1`)
     environmentManager.set(`cli_parameter_foo`, `bar2`)
-    Command.create().parameter(`--foo`, s).settings({ helpOnNoArguments: false }).parse({ line: [] })
+    $.parameter(`--foo`, s).settings({ helpOnNoArguments: false }).parse({ line: [] })
     expect(stdout.mock.calls).toMatchSnapshot()
   })
 })
diff --git a/packages/@molt/command/tests/environment/global/toggling.spec.ts b/packages/@molt/command/tests/environment/global/toggling.spec.ts
index d9adf7d1..484c8ed9 100644
--- a/packages/@molt/command/tests/environment/global/toggling.spec.ts
+++ b/packages/@molt/command/tests/environment/global/toggling.spec.ts
@@ -1,5 +1,4 @@
-import { Command } from '../../../src/index.js'
-import { s } from '../../_/helpers.js'
+import { $, s } from '../../_/helpers.js'
 import { createState, environmentManager } from '../__helpers__.js'
 import { expect } from 'vitest'
 import { it } from 'vitest'
@@ -10,23 +9,20 @@ const output = createState<string>({
 
 it(`is enabled by default`, () => {
   environmentManager.set(`cli_parameter_foo`, `bar`)
-  const args = Command.create().parameter(`--foo`, s).parse({ line: [] })
+  const args = $.parameter(`--foo`, s).parse({ line: [] })
   expect(args).toMatchObject({ foo: `bar` })
 })
 it(`can be enabled by settings`, () => {
   environmentManager.set(`cli_param_foo`, `bar`)
-  const args1 = Command.create()
-    .parameter(`--foo`, s)
+  const args1 = $.parameter(`--foo`, s)
     .settings({ parameters: { environment: true } })
     .parse({ line: [] })
   expect(args1).toMatchObject({ foo: `bar` })
-  const args2 = Command.create()
-    .parameter(`--foo`, s)
+  const args2 = $.parameter(`--foo`, s)
     .settings({ parameters: { environment: { $default: true } } })
     .parse({ line: [] })
   expect(args2).toMatchObject({ foo: `bar` })
-  const args3 = Command.create()
-    .parameter(`--foo`, s)
+  const args3 = $.parameter(`--foo`, s)
     .settings({ parameters: { environment: { $default: { enabled: true } } } })
     .parse({ line: [] })
   expect(args3).toMatchObject({ foo: `bar` })
@@ -34,19 +30,18 @@ it(`can be enabled by settings`, () => {
 it(`can be enabled by environment`, () => {
   environmentManager.set(`ClI_settings_READ_arguments_FROM_ENVIRONMENT`, `true`)
   environmentManager.set(`cli_param_foo`, `bar`)
-  const args = Command.create().parameter(`--foo`, s).parse({ line: [] })
+  const args = $.parameter(`--foo`, s).parse({ line: [] })
   expect(args).toMatchObject({ foo: `bar` })
 })
 it(`can be disabled by environment`, () => {
   environmentManager.set(`ClI_settings_READ_arguments_FROM_ENVIRONMENT`, `false`)
   environmentManager.set(`cli_param_foo`, `foo_env`)
-  const args = Command.create().parameter(`--foo`, s.default(`foo_default`)).parse({ line: [] })
+  const args = $.parameter(`--foo`, s.default(`foo_default`)).parse({ line: [] })
   expect(args).toMatchObject({ foo: `foo_default` })
 })
 it(`environment supersedes settings`, () => {
   expect(() =>
-    Command.create()
-      .parameter(`--foo`, s)
+    $.parameter(`--foo`, s)
       .settings({
         onOutput: output.set,
         parameters: { environment: true },
diff --git a/packages/@molt/command/tests/environment/parsing.spec.ts b/packages/@molt/command/tests/environment/parsing.spec.ts
index 4ee0a264..ebcacbc2 100644
--- a/packages/@molt/command/tests/environment/parsing.spec.ts
+++ b/packages/@molt/command/tests/environment/parsing.spec.ts
@@ -1,5 +1,4 @@
-import { Command } from '../../src/index.js'
-import { b, n, s } from '../_/helpers.js'
+import { $, b, n, s } from '../_/helpers.js'
 import { stdout } from '../_/mocks.js'
 import { environmentManager } from './__helpers__.js'
 import { beforeEach, expect } from 'vitest'
@@ -11,51 +10,51 @@ beforeEach(() => environmentManager.set(`CLI_SETTINGS_READ_ARGUMENTS_FROM_ENVIRO
 describe(`boolean can be parsed`, () => {
   it(`parses value of true`, () => {
     environmentManager.set(`CLI_PARAM_VERBOSE`, `true`)
-    const args = Command.create().parameter(`--verbose`, b).parse({ line: [] })
+    const args = $.parameter(`--verbose`, b).parse({ line: [] })
     expect(args).toMatchObject({ verbose: true })
   })
   it(`parses value of true which overrides a spec default of false`, () => {
     environmentManager.set(`CLI_PARAM_VERBOSE`, `true`)
-    const args = Command.create().parameter(`--verbose`, b.default(false)).parse({ line: [] })
+    const args = $.parameter(`--verbose`, b.default(false)).parse({ line: [] })
     expect(args).toMatchObject({ verbose: true })
   })
   it(`parses value of false`, () => {
     environmentManager.set(`cli_param_verbose`, `false`)
-    const args = Command.create().parameter(`--verbose`, b).parse({ line: [] })
+    const args = $.parameter(`--verbose`, b).parse({ line: [] })
     expect(args).toMatchObject({ verbose: false })
   })
   describe(`alias`, () => {
     it(`parses value of true`, () => {
       environmentManager.set(`cli_param_VERB`, `true`)
-      const args = Command.create().parameter(`--verbose --verb`, z.boolean()).parse({ line: [] })
+      const args = $.parameter(`--verbose --verb`, z.boolean()).parse({ line: [] })
       expect(args).toMatchObject({ verbose: true })
     })
     it(`parses value of false`, () => {
       environmentManager.set(`cli_param_VERB`, `false`)
-      const args = Command.create().parameter(`--verbose --verb`, z.boolean()).parse({ line: [] })
+      const args = $.parameter(`--verbose --verb`, z.boolean()).parse({ line: [] })
       expect(args).toMatchObject({ verbose: false })
     })
   })
   describe(`negated`, () => {
     it(`parses negated name with false value`, () => {
       environmentManager.set(`cli_param_no_foo`, `false`)
-      const args = Command.create().parameter(`--foo`, z.boolean()).parse({ line: [] })
+      const args = $.parameter(`--foo`, z.boolean()).parse({ line: [] })
       expect(args).toMatchObject({ foo: true })
     })
     it(`parses negated name with true value`, () => {
       environmentManager.set(`cli_param_no_foo`, `true`)
-      const args = Command.create().parameter(`--foo`, z.boolean()).parse({ line: [] })
+      const args = $.parameter(`--foo`, z.boolean()).parse({ line: [] })
       expect(args).toMatchObject({ foo: false })
     })
     describe(`alias`, () => {
       it(`parses negated alias name with true value`, () => {
         environmentManager.set(`cli_param_no_foobar`, `true`)
-        const args = Command.create().parameter(`--foo --foobar`, b).parse({ line: [] })
+        const args = $.parameter(`--foo --foobar`, b).parse({ line: [] })
         expect(args).toMatchObject({ foo: false })
       })
       it(`parses negated alias name with false value`, () => {
         environmentManager.set(`cli_param_no_foobar`, `false`)
-        const args = Command.create().parameter(`--foo --foobar`, b).parse({ line: [] })
+        const args = $.parameter(`--foo --foobar`, b).parse({ line: [] })
         expect(args).toMatchObject({ foo: true })
       })
     })
@@ -64,27 +63,25 @@ describe(`boolean can be parsed`, () => {
 
 it(`parses a value specified to be a string`, () => {
   environmentManager.set(`cli_param_foo`, `bar`)
-  const args = Command.create().parameter(`--foo`, s).parse({ line: [] })
+  const args = $.parameter(`--foo`, s).parse({ line: [] })
   expect(args).toMatchObject({ foo: `bar` })
 })
 it(`parses a value specified to be a number`, () => {
   environmentManager.set(`cli_param_foo`, `4.3`)
-  const args = Command.create().parameter(`--foo`, n).parse({ line: [] })
+  const args = $.parameter(`--foo`, n).parse({ line: [] })
   expect(args).toMatchObject({ foo: 4.3 })
 })
 describe(`enum can be parsed`, () => {
   it(`throws an error if the value does not pass validation`, () => {
     environmentManager.set(`cli_param_foo`, `d`)
-    Command.create()
-      .parameter(`--foo`, z.enum([`a`, `b`, `c`]))
-      .parse({ line: [] })
+    $.parameter(`--foo`, z.enum([`a`, `b`, `c`])).parse({ line: [] })
     expect(stdout.mock.calls).toMatchSnapshot()
   })
 })
 
 it(`ignores the letter casing of env name`, () => {
   environmentManager.set(`cLi_PARAM_fOo`, `bar`)
-  const args = Command.create().parameter(`--foo`, s).parse({ line: [] })
+  const args = $.parameter(`--foo`, s).parse({ line: [] })
   expect(args).toMatchObject({ foo: `bar` })
 })
 
diff --git a/packages/@molt/command/tests/environment/selective/prefix.spec.ts b/packages/@molt/command/tests/environment/selective/prefix.spec.ts
index 84d6dfca..9907ae57 100644
--- a/packages/@molt/command/tests/environment/selective/prefix.spec.ts
+++ b/packages/@molt/command/tests/environment/selective/prefix.spec.ts
@@ -1,5 +1,4 @@
-import { Command } from '../../../src/index.js'
-import { s } from '../../_/helpers.js'
+import { $, s } from '../../_/helpers.js'
 import { environmentManager } from '../__helpers__.js'
 import { expect } from 'vitest'
 import { it } from 'vitest'
@@ -10,8 +9,7 @@ it(`just one can have prefix disabled`, () => {
     foo: `foo`,
     cli_param_bar: `bar-prefix`,
   })
-  const args = Command.create()
-    .parameter(`--foo`, s)
+  const args = $.parameter(`--foo`, s)
     .parameter(`--bar`, z.string())
     .settings({ parameters: { environment: { $default: true, foo: { prefix: false } } } })
     .parse({ line: [] })
@@ -23,8 +21,7 @@ it(`all but one can have prefix disabled`, () => {
     bar: `bar`,
     cli_param_foo: `cli_param_foo`,
   })
-  const args = Command.create()
-    .parameter(`--foo`, s)
+  const args = $.parameter(`--foo`, s)
     .parameter(`--bar`, s)
     .settings({
       parameters: { environment: { $default: { enabled: true, prefix: false }, foo: { prefix: true } } },
diff --git a/packages/@molt/command/tests/environment/selective/toggling.spec.ts b/packages/@molt/command/tests/environment/selective/toggling.spec.ts
index 68224a79..9c610a51 100644
--- a/packages/@molt/command/tests/environment/selective/toggling.spec.ts
+++ b/packages/@molt/command/tests/environment/selective/toggling.spec.ts
@@ -1,13 +1,11 @@
-import { Command } from '../../../src/index.js'
-import { s } from '../../_/helpers.js'
+import { $, s } from '../../_/helpers.js'
 import { environmentManager } from '../__helpers__.js'
 import { describe, expect, it } from 'vitest'
 
 it(`can toggle environment on for one parameter`, () => {
   environmentManager.set(`cli_param_foo`, `env1`)
   environmentManager.set(`cli_param_bar`, `env2`)
-  const args = Command.create()
-    .parameter(`--foo`, s.default(`foo`))
+  const args = $.parameter(`--foo`, s.default(`foo`))
     .parameter(`--bar`, s.default(`bar`))
     .settings({ parameters: { environment: { foo: true } } })
     .parse({ line: [] })
@@ -17,8 +15,7 @@ it(`can toggle environment on for one parameter`, () => {
 it(`can change prefix for one parameter`, () => {
   environmentManager.set(`foo`, `foo_env`)
   environmentManager.set(`cli_param_bar`, `bar_env`)
-  const args = Command.create()
-    .parameter(`--foo`, s.default(`foo_default`))
+  const args = $.parameter(`--foo`, s.default(`foo_default`))
     .parameter(`--bar`, s.default(`bar_default`))
     .settings({ parameters: { environment: { foo: { prefix: false }, bar: true } } })
     .parse({ line: [] })
@@ -28,8 +25,7 @@ it(`can change prefix for one parameter`, () => {
 it(`can change default prefix and prefix for one parameter`, () => {
   environmentManager.set(`foo`, `foo_env`)
   environmentManager.set(`param_bar`, `bar_env`)
-  const args = Command.create()
-    .parameter(`--foo`, s.default(`default_foo`))
+  const args = $.parameter(`--foo`, s.default(`default_foo`))
     .parameter(`--bar`, s.default(`default_bar`))
     .settings({
       parameters: {
@@ -46,8 +42,7 @@ it(`can change default prefix and prefix for one parameter`, () => {
 
 describe(`when configuring parameters, environment becomes opt-in`, () => {
   it(`with default not set`, () => {
-    const args = Command.create()
-      .parameter(`--foo`, s.default(`foo`))
+    const args = $.parameter(`--foo`, s.default(`foo`))
       .parameter(`--bar`, s.default(`bar`))
       .parameter(`--qux`, s.default(`qux`))
       .settings({
@@ -64,8 +59,7 @@ describe(`when configuring parameters, environment becomes opt-in`, () => {
     expect(args).toMatchObject({ foo: `foo_env`, bar: `bar`, qux: `qux` })
   })
   it(`even with default configured`, () => {
-    const args = Command.create()
-      .parameter(`--foo`, s.default(`foo`))
+    const args = $.parameter(`--foo`, s.default(`foo`))
       .parameter(`--bar`, s.default(`bar`))
       .parameter(`--qux`, s.default(`qux`))
       .settings({
@@ -82,8 +76,7 @@ describe(`when configuring parameters, environment becomes opt-in`, () => {
   describe(` unless...`, () => {
     it(`default is shorthand true`, () => {
       environmentManager.set({ moo_foo: `moo_foo_env`, cli_param_bar: `bar_env`, cli_param_qux: `qux_env` })
-      const args = Command.create()
-        .parameter(`--foo`, s.default(`foo`))
+      const args = $.parameter(`--foo`, s.default(`foo`))
         .parameter(`--bar`, s.default(`bar`))
         .parameter(`--qux`, s.default(`qux`))
         .settings({ parameters: { environment: { $default: true, foo: { prefix: `MOO` } } } })
@@ -92,8 +85,7 @@ describe(`when configuring parameters, environment becomes opt-in`, () => {
     })
     it(`default is longhand true`, () => {
       environmentManager.set({ moo_foo: `moo_foo_env`, cli_param_bar: `bar_env`, cli_param_qux: `qux_env` })
-      const args = Command.create()
-        .parameter(`--foo`, s.default(`foo`))
+      const args = $.parameter(`--foo`, s.default(`foo`))
         .parameter(`--bar`, s.default(`bar`))
         .parameter(`--qux`, s.default(`qux`))
         .settings({ parameters: { environment: { $default: { enabled: true }, foo: { prefix: `MOO` } } } })
diff --git a/packages/@molt/command/tests/environment/types/boolean.spec.ts b/packages/@molt/command/tests/environment/types/boolean.spec.ts
index 4293637c..5bc9821c 100644
--- a/packages/@molt/command/tests/environment/types/boolean.spec.ts
+++ b/packages/@molt/command/tests/environment/types/boolean.spec.ts
@@ -1,5 +1,4 @@
-import { Command } from '../../../src/index.js'
-import { b } from '../../_/helpers.js'
+import { $, b } from '../../_/helpers.js'
 import { environmentManager } from '../__helpers__.js'
 import { expect, test } from 'vitest'
 
@@ -10,5 +9,5 @@ test.each([
   [`0`, { foo: false }],
 ])(`%s`, (value, expected) => {
   environmentManager.set(`cli_param_foo`, value)
-  expect(Command.create().parameter(`foo`, b).parse({ line: [] })).toMatchObject(expected)
+  expect($.parameter(`foo`, b).parse({ line: [] })).toMatchObject(expected)
 })
diff --git a/packages/@molt/command/tests/exclusive.spec.ts b/packages/@molt/command/tests/exclusive.spec.ts
index 174c96ef..2abd6f83 100644
--- a/packages/@molt/command/tests/exclusive.spec.ts
+++ b/packages/@molt/command/tests/exclusive.spec.ts
@@ -1,19 +1,16 @@
-import type { Settings } from '../src/index.js'
-import { Command } from '../src/index.js'
-import { as, e, s } from './_/helpers.js'
+import { $, as, e, s } from './_/helpers.js'
 import { expectType } from 'tsd'
 import { describe, expect, it } from 'vitest'
 
-let c
-const settings: Settings.Input = { onError: `throw`, helpOnError: false }
+const $$ = $.settings({ onError: `throw`, helpOnError: false })
+let args
 
 describe(`optional`, () => {
   it(`leads to optional type`, () => {
-    c = Command.create()
-      .parametersExclusive(`method`, ($$) => $$.parameter(`v version`, s).parameter(`b bump`, e).optional())
-      .parse({ line: [`-v`, `1.0.0`] })
-
-    expectType<typeof c>(
+    const args = $.parametersExclusive(`method`, ($) =>
+      $.parameter(`v version`, s).parameter(`b bump`, e).optional(),
+    ).parse({ line: [`-v`, `1.0.0`] })
+    expectType<typeof args>(
       as<{
         method:
           | {
@@ -30,69 +27,66 @@ describe(`optional`, () => {
   })
 
   it(`can accept line arg`, () => {
-    c = Command.create()
-      .parametersExclusive(`method`, ($$) => $$.parameter(`v version`, s).parameter(`b bump`, e).optional())
-      .parse({ line: [`-v`, `1.0.0`] })
-    expect(c).toMatchObject({ method: { _tag: `version`, value: `1.0.0` } })
+    args = $.parametersExclusive(`method`, ($) =>
+      $.parameter(`v version`, s).parameter(`b bump`, e).optional(),
+    ).parse({ line: [`-v`, `1.0.0`] })
+    expect(args).toMatchObject({ method: { _tag: `version`, value: `1.0.0` } })
   })
 
   it(`can accept env arg`, () => {
-    c = Command.create()
-      .parametersExclusive(`method`, ($$) => $$.parameter(`v version`, s).parameter(`b bump`, e).optional())
-      .parse({ environment: { cli_param_v: `1.0.0` } })
-    expect(c).toMatchObject({ method: { _tag: `version`, value: `1.0.0` } })
+    args = $.parametersExclusive(`method`, ($) =>
+      $.parameter(`v version`, s).parameter(`b bump`, e).optional(),
+    ).parse({ environment: { cli_param_v: `1.0.0` } })
+    expect(args).toMatchObject({ method: { _tag: `version`, value: `1.0.0` } })
   })
   it(`can accept nothing`, () => {
-    c = Command.create()
-      .parametersExclusive(`method`, ($$) => $$.parameter(`v version`, s).parameter(`b bump`, e).optional())
-      .parse()
-    expect(`method` in c).toBe(false)
+    args = $.parametersExclusive(`method`, ($) =>
+      $.parameter(`v version`, s).parameter(`b bump`, e).optional(),
+    ).parse()
+    expect(`method` in args).toBe(false)
   })
   it(`if two args then error`, () => {
-    const c = Command.create()
-      .parametersExclusive(`method`, ($$) => $$.parameter(`v version`, s).parameter(`b bump`, e).optional())
-      .settings(settings)
-    expect(() => c.parse({ line: [`-v`, `1.0.0`, `-b`, `major`] })).toThrowErrorMatchingSnapshot()
+    expect(() =>
+      $$.parametersExclusive(`method`, ($) =>
+        $.parameter(`v version`, s).parameter(`b bump`, e).optional(),
+      ).parse({ line: [`-v`, `1.0.0`, `-b`, `major`] }),
+    ).toThrowErrorMatchingSnapshot()
   })
 })
 
 describe(`required`, () => {
   it(`if no arg given then error`, () => {
-    const c = Command.create()
-      .parametersExclusive(`method`, ($$) => $$.parameter(`v version`, s).parameter(`b bump`, e))
-      .settings(settings)
-    expect(c.parse).toThrowErrorMatchingSnapshot()
+    expect(
+      $$.parametersExclusive(`method`, ($) => $.parameter(`v version`, s).parameter(`b bump`, e)).parse,
+    ).toThrowErrorMatchingSnapshot()
   })
   it(`if two args then error`, () => {
-    const c = Command.create()
-      .parametersExclusive(`method`, ($$) => $$.parameter(`v version`, s).parameter(`b bump`, e))
-      .settings(settings)
-    expect(() => c.parse({ line: [`-v`, `1.0.0`, `-b`, `major`] })).toThrowErrorMatchingSnapshot()
+    expect(() =>
+      $$.parametersExclusive(`method`, ($$) => $$.parameter(`v version`, s).parameter(`b bump`, e)).parse({
+        line: [`-v`, `1.0.0`, `-b`, `major`],
+      }),
+    ).toThrowErrorMatchingSnapshot()
   })
 })
 
 describe(`default`, () => {
   it(`method params are based on group params defined above`, () => {
-    // prettier-ignore
-    Command.create().parametersExclusive(`method`, ($$) => {
-      const c = $$.parameter(`v version`, s).parameter(`b bump`, e)
-      const m1 = c.default 
+    $.parametersExclusive(`method`, ($) => {
+      const $$ = $.parameter(`v version`, s).parameter(`b bump`, e)
+      const m1 = $$.default
       expectType<Parameters<typeof m1>>(as<[tag: 'version' | 'bump', value: 'any string']>())
-      const m2 = c.default<'version'>
+      const m2 = $$.default<'version'>
       expectType<Parameters<typeof m2>>(as<[tag: 'version', value: 'any string']>())
-      const m3 = c.default<'bump'>
-      expectType<Parameters<typeof m3>>(as<[tag: 'bump', value: 'patch'|'minor'|'major']>())
-      return c
+      const m3 = $$.default<'bump'>
+      expectType<Parameters<typeof m3>>(as<[tag: 'bump', value: 'patch' | 'minor' | 'major']>())
+      return $$
     })
   })
   it(`leads to non-optional type`, () => {
-    const a = Command.create()
-      .parametersExclusive(`method`, ($$) =>
-        $$.parameter(`v version`, s).parameter(`b bump`, e).default(`bump`, `major`),
-      )
-      .settings(settings)
-      .parse()
-    expectType<typeof a>(
+    args = $$.parametersExclusive(`method`, ($) =>
+      $.parameter(`v version`, s).parameter(`b bump`, e).default(`bump`, `major`),
+    ).parse()
+    expectType<typeof args>(
       as<{
         method:
           | {
@@ -107,12 +101,9 @@ describe(`default`, () => {
     )
   })
   it(`used if nothing passed for group`, () => {
-    const a = Command.create()
-      .parametersExclusive(`method`, ($$) =>
-        $$.parameter(`v version`, s).parameter(`b bump`, e).default(`bump`, `patch`),
-      )
-      .settings(settings)
-      .parse()
-    expect(a.method).toMatchObject({ _tag: `bump`, value: `patch` })
+    args = $$.parametersExclusive(`method`, ($) =>
+      $.parameter(`v version`, s).parameter(`b bump`, e).default(`bump`, `patch`),
+    ).parse()
+    expect(args.method).toMatchObject({ _tag: `bump`, value: `patch` })
   })
 })
diff --git a/packages/@molt/command/tests/help/help.spec.ts b/packages/@molt/command/tests/help/help.spec.ts
index eceb9331..3b7e852b 100644
--- a/packages/@molt/command/tests/help/help.spec.ts
+++ b/packages/@molt/command/tests/help/help.spec.ts
@@ -1,5 +1,4 @@
-import { Command } from '../../src/index.js'
-import { s } from '../_/helpers.js'
+import { $, s } from '../_/helpers.js'
 import { expect, test } from 'vitest'
 import { mockProcessExit, mockProcessStdout } from 'vitest-mock-process'
 
@@ -7,30 +6,24 @@ const processExit = mockProcessExit()
 const processStdout = mockProcessStdout()
 
 test(`exits 0`, () => {
-  Command.create()
-    .parameter(`a`, s.optional())
-    .parse({ line: [`-h`] })
+  $.parameter(`a`, s.optional()).parse({ line: [`-h`] })
   expect(processExit.mock.lastCall?.[0]).toBe(0)
 })
 
 test(`can be triggered by -h`, () => {
-  Command.create()
-    .parameter(`a`, s.optional())
-    .parse({ line: [`-h`] })
+  $.parameter(`a`, s.optional()).parse({ line: [`-h`] })
   expect(processExit.mock.lastCall?.[0]).toBe(0)
   expect(processStdout.mock.calls[0]).toMatch(/parameters/i)
 })
 
 test(`can be triggered by --help`, () => {
-  Command.create()
-    .parameter(`a`, s.optional())
-    .parse({ line: [`-h`] })
+  $.parameter(`a`, s.optional()).parse({ line: [`-h`] })
   expect(processExit.mock.lastCall?.[0]).toBe(0)
   expect(processStdout.mock.calls[0]).toMatch(/parameters/i)
 })
 
 test(`can be triggered by passing no arguments`, () => {
-  Command.create().parameter(`a`, s.optional()).parse({ line: [] })
+  $.parameter(`a`, s.optional()).parse({ line: [] })
   expect(processExit.mock.lastCall?.[0]).toBe(0)
   expect(processStdout.mock.calls[0]).toMatch(/parameters/i)
 })
diff --git a/packages/@molt/command/tests/help/rendering.spec.ts b/packages/@molt/command/tests/help/rendering.spec.ts
index bd3c0020..ed72e818 100644
--- a/packages/@molt/command/tests/help/rendering.spec.ts
+++ b/packages/@molt/command/tests/help/rendering.spec.ts
@@ -1,5 +1,4 @@
-import { Command } from '../../src/index.js'
-import { s } from '../_/helpers.js'
+import { $, s } from '../_/helpers.js'
 import { createState } from '../environment/__helpers__.js'
 import stripAnsi from 'strip-ansi'
 import { describe, expect, it } from 'vitest'
@@ -15,8 +14,7 @@ const output = createState<string>({
 const onOutput = output.set
 
 it(`if command has description it is shown`, () => {
-  Command.create()
-    .description(`Blah blah blah`)
+  $.description(`Blah blah blah`)
     .parameter(`foo`, s.optional())
     .settings({ onOutput })
     .parse({ line: [`-h`] })
@@ -25,8 +23,7 @@ it(`if command has description it is shown`, () => {
 })
 
 it(`if there is optional param it is shown`, () => {
-  Command.create()
-    .parameter(`a`, s.optional())
+  $.parameter(`a`, s.optional())
     .settings({ onOutput })
     .parse({ line: [`-h`] })
   expect(stripAnsi(output.value)).toMatchSnapshot(`monochrome`)
@@ -34,8 +31,7 @@ it(`if there is optional param it is shown`, () => {
 })
 
 it(`if parameter has description it is shown`, () => {
-  Command.create()
-    .parameter(`a`, s.optional().describe(`Blah blah blah.`))
+  $.parameter(`a`, s.optional().describe(`Blah blah blah.`))
     .settings({ onOutput })
     .parse({ line: [`-h`] })
   expect(stripAnsi(output.value)).toMatchSnapshot(`monochrome`)
@@ -43,8 +39,7 @@ it(`if parameter has description it is shown`, () => {
 })
 
 it(`long description wraps within column`, () => {
-  Command.create()
-    .parameter(`a`, s.optional().describe(`Blah blah blah. Blah blah blah. Blah blah blah.`))
+  $.parameter(`a`, s.optional().describe(`Blah blah blah. Blah blah blah. Blah blah blah.`))
     .settings({ onOutput })
     .parse({ line: [`-h`] })
   expect(stripAnsi(output.value)).toMatchSnapshot(`monochrome`)
@@ -52,8 +47,7 @@ it(`long description wraps within column`, () => {
 })
 
 it(`if parameter has default it is shown`, () => {
-  Command.create()
-    .parameter(`foo`, s.default(`bar`))
+  $.parameter(`foo`, s.default(`bar`))
     .settings({ onOutput })
     .parse({ line: [`-h`] })
   expect(stripAnsi(output.value)).toMatchSnapshot(`monochrome`)
@@ -61,8 +55,7 @@ it(`if parameter has default it is shown`, () => {
 })
 
 it(`if parameter is optional without default then its default shows up as "undefined"`, () => {
-  Command.create()
-    .parameter(`foo`, s.optional())
+  $.parameter(`foo`, s.optional())
     .settings({ onOutput })
     .parse({ line: [`-h`] })
   expect(stripAnsi(output.value)).toMatchSnapshot(`monochrome`)
@@ -70,13 +63,12 @@ it(`if parameter is optional without default then its default shows up as "undef
 })
 
 it(`if there is an error trying to get default then a nice message is shown`, () => {
-  Command.create()
-    .parameter(
-      `foo`,
-      s.default(() => {
-        throw new Error(`whoops`)
-      }),
-    )
+  $.parameter(
+    `foo`,
+    s.default(() => {
+      throw new Error(`whoops`)
+    }),
+  )
     .settings({ onOutput })
     .parse({ line: [`-h`] })
   expect(stripAnsi(output.value)).toMatchSnapshot(`monochrome`)
@@ -84,13 +76,12 @@ it(`if there is an error trying to get default then a nice message is shown`, ()
 })
 
 it(`if there is an error trying to get default then a nice message is shown`, () => {
-  Command.create()
-    .parameter(
-      `foo`,
-      s.default(() => {
-        throw new Error(`whoops`)
-      }),
-    )
+  $.parameter(
+    `foo`,
+    s.default(() => {
+      throw new Error(`whoops`)
+    }),
+  )
     .settings({ onOutput })
     .parse({ line: [`-h`] })
   expect(stripAnsi(output.value)).toMatchSnapshot(`monochrome`)
@@ -99,7 +90,7 @@ it(`if there is an error trying to get default then a nice message is shown`, ()
 
 it(`enums do not mess up alignment when they are widest line in the column`, () => {
   // prettier-ignore
-  Command.create().parameter(
+  $.parameter(
     `foo`, z.enum([`a`, `b`, `c`, `d`, `e`, `f`, `g`, `h`, `i`, `j`, `k`, `l`, `m`, `n`, `o`, `p`, `q`, `r`, `s`, `t`, `u`, `v`, `w`, `x`, `y`, `z`]),).parameter(
     `bar`, s.optional(),
   ).settings({onOutput}).parse({line:[`-h`]})
@@ -109,8 +100,7 @@ it(`enums do not mess up alignment when they are widest line in the column`, ()
 
 describe(`enum`, () => {
   it(`enum members are listed`, () => {
-    Command.create()
-      .parameter(`foo`, z.enum([`apple`, `dolphin`, `cab`]))
+    $.parameter(`foo`, z.enum([`apple`, `dolphin`, `cab`]))
       .settings({ onOutput })
       .parse({ line: [`-h`] })
     expect(stripAnsi(output.value)).toMatchSnapshot(`monochrome`)
@@ -118,8 +108,7 @@ describe(`enum`, () => {
   })
 
   it(`optional enum members are listed`, () => {
-    Command.create()
-      .parameter(`foo`, z.enum([`apple`, `dolphin`, `cab`]).optional())
+    $.parameter(`foo`, z.enum([`apple`, `dolphin`, `cab`]).optional())
       .settings({ onOutput })
       .parse({ line: [`-h`] })
     expect(stripAnsi(output.value)).toMatchSnapshot(`monochrome`)
@@ -127,8 +116,7 @@ describe(`enum`, () => {
   })
 
   it(`when there is only one enum member it is prefixed with "enum:" to avoid confusion of it looking like the name of a kind of type`, () => {
-    Command.create()
-      .parameter(`foo`, z.enum([`apple`]))
+    $.parameter(`foo`, z.enum([`apple`]))
       .settings({ onOutput })
       .parse({ line: [`-h`] })
     expect(stripAnsi(output.value)).toMatchSnapshot(`monochrome`)
@@ -136,23 +124,22 @@ describe(`enum`, () => {
   })
 
   it(`when there are many members they wrap`, () => {
-    Command.create()
-      .parameter(
-        `foo`,
-        z.enum([
-          `apple`,
-          `baby`,
-          `cannabis`,
-          `dinosaur`,
-          `elephant`,
-          `fanna`,
-          `goat`,
-          `house`,
-          `island`,
-          `jake`,
-          `kilomanjara`,
-        ]),
-      )
+    $.parameter(
+      `foo`,
+      z.enum([
+        `apple`,
+        `baby`,
+        `cannabis`,
+        `dinosaur`,
+        `elephant`,
+        `fanna`,
+        `goat`,
+        `house`,
+        `island`,
+        `jake`,
+        `kilomanjara`,
+      ]),
+    )
       .settings({ onOutput })
       .parse({ line: [`-h`] })
     expect(stripAnsi(output.value)).toMatchSnapshot(`monochrome`)
@@ -162,24 +149,21 @@ describe(`enum`, () => {
 
 describe(`environment`, () => {
   it(`when environment is disabled then environment doc is not shown`, () => {
-    Command.create()
-      .parameter(`foo`, s)
+    $.parameter(`foo`, s)
       .settings({ onOutput, parameters: { environment: false } })
       .parse({ line: [`-h`] })
     expect(stripAnsi(output.value)).toMatchSnapshot(`monochrome`)
     expect(output.value).toMatchSnapshot(`polychrome`)
   })
   it(`when environment is enabled it shows as the last column`, () => {
-    Command.create()
-      .parameter(`foo`, s)
+    $.parameter(`foo`, s)
       .settings({ onOutput, parameters: { environment: true } })
       .parse({ line: [`-h`] })
     expect(stripAnsi(output.value)).toMatchSnapshot(`monochrome`)
     expect(output.value).toMatchSnapshot(`polychrome`)
   })
   it(`when environment is disabled for one parameter it has X indicating that`, () => {
-    Command.create()
-      .parameter(`foo`, s)
+    $.parameter(`foo`, s)
       .parameter(`bar`, s)
       .settings({ onOutput, parameters: { environment: { $default: true, foo: false } } })
       .parse({ line: [`-h`] })
@@ -187,8 +171,7 @@ describe(`environment`, () => {
     expect(output.value).toMatchSnapshot(`polychrome`)
   })
   it(`when environment has custom prefix it is displayed`, () => {
-    Command.create()
-      .parameter(`foo`, s)
+    $.parameter(`foo`, s)
       .parameter(`bar`, s)
       .settings({ onOutput, parameters: { environment: { $default: true, foo: { prefix: `moo` } } } })
       .parse({ line: [`-h`] })
@@ -196,8 +179,7 @@ describe(`environment`, () => {
     expect(output.value).toMatchSnapshot(`polychrome`)
   })
   it(`when environment has multiple custom prefix they are displayed`, () => {
-    Command.create()
-      .parameter(`foo`, s)
+    $.parameter(`foo`, s)
       .parameter(`bar`, s)
       .settings({
         onOutput,
@@ -208,8 +190,7 @@ describe(`environment`, () => {
     expect(output.value).toMatchSnapshot(`polychrome`)
   })
   it(`when environment has no prefix it is displayed`, () => {
-    Command.create()
-      .parameter(`foo`, s)
+    $.parameter(`foo`, s)
       .parameter(`bar`, s)
       .settings({ onOutput, parameters: { environment: { $default: true, foo: { prefix: false } } } })
       .parse({ line: [`-h`] })
@@ -221,8 +202,7 @@ describe(`environment`, () => {
 describe(`exclusive`, () => {
   describe(`optional`, () => {
     it(`shows exclusive parameters as a group`, () => {
-      Command.create()
-        .parametersExclusive(`foo`, (_) => _.parameter(`b bar`, s).parameter(`z baz`, s).optional())
+      $.parametersExclusive(`foo`, (_) => _.parameter(`b bar`, s).parameter(`z baz`, s).optional())
         .settings({ onOutput })
         .parse({
           line: [`-h`],
@@ -233,10 +213,9 @@ describe(`exclusive`, () => {
   })
   describe(`default`, () => {
     it(`shows the group default`, () => {
-      Command.create()
-        .parametersExclusive(`foo`, (_) =>
-          _.parameter(`b bar`, s).parameter(`z baz`, s).default(`bar`, `bar_default`),
-        )
+      $.parametersExclusive(`foo`, (_) =>
+        _.parameter(`b bar`, s).parameter(`z baz`, s).default(`bar`, `bar_default`),
+      )
         .settings({ onOutput })
         .parse({
           line: [`-h`],
@@ -247,10 +226,9 @@ describe(`exclusive`, () => {
   })
   describe(`default with long value`, () => {
     it(`shows the group default`, () => {
-      Command.create()
-        .parametersExclusive(`foo`, (_) =>
-          _.parameter(`b bar`, s).parameter(`z baz`, s).default(`bar`, `bar_defaulttttttttttttttttttttt`),
-        )
+      $.parametersExclusive(`foo`, (_) =>
+        _.parameter(`b bar`, s).parameter(`z baz`, s).default(`bar`, `bar_defaulttttttttttttttttttttt`),
+      )
         .settings({ onOutput })
         .parse({
           line: [`-h`],
@@ -261,10 +239,9 @@ describe(`exclusive`, () => {
   })
   describe(`with environment disabled`, () => {
     it(`shows the group default`, () => {
-      Command.create()
-        .parametersExclusive(`foo`, (_) =>
-          _.parameter(`b bar`, s).parameter(`z baz`, s).default(`bar`, `bar_default`),
-        )
+      $.parametersExclusive(`foo`, (_) =>
+        _.parameter(`b bar`, s).parameter(`z baz`, s).default(`bar`, `bar_default`),
+      )
         .settings({ onOutput, parameters: { environment: false } })
         .parse({
           line: [`-h`],
@@ -278,8 +255,7 @@ describe(`exclusive`, () => {
 describe(`union parameter`, () => {
   describe(`condensed pipe style`, () => {
     it(`used when no descriptions given for anything`, () => {
-      Command.create()
-        .parameter(`b bar`, z.union([z.string(), z.number()]))
+      $.parameter(`b bar`, z.union([z.string(), z.number()]))
         .settings({ onOutput })
         .parse({
           line: [`-h`],
@@ -288,8 +264,7 @@ describe(`union parameter`, () => {
       expect(output.value).toMatchSnapshot(`polychrome`)
     })
     it(`used when only overall description given`, () => {
-      Command.create()
-        .parameter(`b bar`, z.union([z.string(), z.number()]).describe(`Blah blah blah.`))
+      $.parameter(`b bar`, z.union([z.string(), z.number()]).describe(`Blah blah blah.`))
         .settings({ onOutput })
         .parse({
           line: [`-h`],
@@ -300,22 +275,20 @@ describe(`union parameter`, () => {
   })
   describe(`expanded style`, () => {
     it(`can be forced via settings`, () => {
-      Command.create()
-        .parameter(`b bar`, z.union([z.string(), z.number()]))
+      $.parameter(`b bar`, z.union([z.string(), z.number()]))
         .settings({ onOutput, helpRendering: { union: { mode: `expandAlways` } } })
         .parse({ line: [`-h`] })
       expect(stripAnsi(output.value)).toMatchSnapshot(`monochrome`)
       expect(output.value).toMatchSnapshot(`polychrome`)
     })
     it(`shows member on each line if each has description`, () => {
-      Command.create()
-        .parameter(
-          `b bar`,
-          z.union([
-            z.string().describe(`Blah blah blah string.`),
-            z.number().describe(`Blah blah blah number.`),
-          ]),
-        )
+      $.parameter(
+        `b bar`,
+        z.union([
+          z.string().describe(`Blah blah blah string.`),
+          z.number().describe(`Blah blah blah number.`),
+        ]),
+      )
         .settings({ onOutput })
         .parse({
           line: [`-h`],
@@ -324,8 +297,7 @@ describe(`union parameter`, () => {
       expect(output.value).toMatchSnapshot(`polychrome`)
     })
     it(`shows member on each line if at least one has description`, () => {
-      Command.create()
-        .parameter(`b bar`, z.union([z.string(), z.number().describe(`Blah blah blah number.`)]))
+      $.parameter(`b bar`, z.union([z.string(), z.number().describe(`Blah blah blah number.`)]))
         .settings({ onOutput })
         .parse({
           line: [`-h`],
@@ -334,16 +306,15 @@ describe(`union parameter`, () => {
       expect(output.value).toMatchSnapshot(`polychrome`)
     })
     it(`shows overall description above all members when members also have descriptions`, () => {
-      Command.create()
-        .parameter(
-          `b bar`,
-          z
-            .union([
-              z.string().describe(`Blah blah blah string.`),
-              z.number().describe(`Blah blah blah number.`),
-            ])
-            .describe(`Blah blah blah overall.`),
-        )
+      $.parameter(
+        `b bar`,
+        z
+          .union([
+            z.string().describe(`Blah blah blah string.`),
+            z.number().describe(`Blah blah blah number.`),
+          ])
+          .describe(`Blah blah blah overall.`),
+      )
         .settings({ onOutput })
         .parse({
           line: [`-h`],
@@ -353,17 +324,13 @@ describe(`union parameter`, () => {
     })
   })
   it(`shows default when overall has a default`, () => {
-    Command.create()
-      .parameter(
-        `b bar`,
-        z
-          .union([
-            z.string().describe(`Blah blah blah string.`),
-            z.number().describe(`Blah blah blah number.`),
-          ])
-          .default(1)
-          .describe(`Blah blah blah overall.`),
-      )
+    $.parameter(
+      `b bar`,
+      z
+        .union([z.string().describe(`Blah blah blah string.`), z.number().describe(`Blah blah blah number.`)])
+        .default(1)
+        .describe(`Blah blah blah overall.`),
+    )
       .settings({ onOutput })
       .parse({
         line: [`-h`],
@@ -372,17 +339,13 @@ describe(`union parameter`, () => {
     expect(output.value).toMatchSnapshot(`polychrome`)
   })
   it(`shows default as undefined when overall optional`, () => {
-    Command.create()
-      .parameter(
-        `b bar`,
-        z
-          .union([
-            z.string().describe(`Blah blah blah string.`),
-            z.number().describe(`Blah blah blah number.`),
-          ])
-          .optional()
-          .describe(`Blah blah blah overall.`),
-      )
+    $.parameter(
+      `b bar`,
+      z
+        .union([z.string().describe(`Blah blah blah string.`), z.number().describe(`Blah blah blah number.`)])
+        .optional()
+        .describe(`Blah blah blah overall.`),
+    )
       .settings({ onOutput })
       .parse({
         line: [`-h`],
diff --git a/packages/@molt/command/tests/line/builder.spec.ts b/packages/@molt/command/tests/line/builder.spec.ts
index 82cc0f6e..fe6cf8da 100644
--- a/packages/@molt/command/tests/line/builder.spec.ts
+++ b/packages/@molt/command/tests/line/builder.spec.ts
@@ -1,18 +1,16 @@
-import { Command } from '../../src/index.js'
-import { s } from '../_/helpers.js'
+import { $, s } from '../_/helpers.js'
 import { describe, expect, it } from 'vitest'
 
 describe(`.create`, () => {
   it(`creates a parameters definition`, () => {
-    const def = Command.create().parameter(`x`, s)
+    const def = $.parameter(`x`, s)
     expect(def.parse).toBeTypeOf(`function`)
   })
 })
 
 describe(`settings`, () => {
   it(`permits setting a description`, () => {
-    Command.create()
-      .parameter(`x`, s)
+    $.parameter(`x`, s)
       .settings({ description: `foobar` })
       .parse({ line: [`-x`, `foobar`] })
   })
diff --git a/packages/@molt/command/tests/line/name.spec.ts b/packages/@molt/command/tests/line/name.spec.ts
index 515d50f6..8f653d50 100644
--- a/packages/@molt/command/tests/line/name.spec.ts
+++ b/packages/@molt/command/tests/line/name.spec.ts
@@ -1,5 +1,4 @@
-import { Command } from '../../src/index.js'
-import { b, s } from '../_/helpers.js'
+import { $, b, s } from '../_/helpers.js'
 import type { IsExact } from 'conditional-type-checks'
 import { assert } from 'conditional-type-checks'
 import { describe, expect, test } from 'vitest'
@@ -20,7 +19,7 @@ describe(`string`, () => {
 		[`-v --ver`,        [`-v`, `foo`], 							{ ver: `foo` }],
 		[`-v`,              [`-v`, `foo`], 							{ v:   `foo` }],
 	])(`spec %s + input %s = internal %s`, (spec, input, expectedArgs) => {
-		const args = Command.create().parameter(spec as any, s).parse({line:input})
+		const args = $.parameter(spec as any, s).parse({line:input})
 		expect(args).toMatchObject(expectedArgs)
 	})
 })
@@ -40,7 +39,7 @@ describe(`boolean`, () => {
 		[`-v --ver`,        [`-v`], 							{ ver: true }],
 		[`-v`,              [`-v`], 							{ v:   true }],
 	])(`spec %s + input %s = internal %s`, (spec, input, expectedArgs) => {
-		const args = Command.create().parameter(spec as any, b).parse({line:input})
+		const args = $.parameter(spec as any, b).parse({line:input})
 		expect(args).toMatchObject(expectedArgs)
 	})
 })
@@ -51,8 +50,7 @@ describe(`stacked short flags`, () => {
     [[`-ac`], { a: true, b: false, c: true }],
     [[`-abcd`, `foo`], { a: true, b: true, c: true, d: `foo` }],
   ])(`stacked short flag input of %s becomes %s`, (input, expectedArgs) => {
-    const args = Command.create()
-      .parameter(`a`, b.default(false))
+    const args = $.parameter(`a`, b.default(false))
       .parameter(`b`, b.default(false))
       .parameter(`c`, b.default(false))
       .parameter(`d`, s.optional())
@@ -68,7 +66,7 @@ describe(`separator`, () => {
     [[`--foo= `, `bar`], { foo: `bar` }],
     [[`--foo`, `=bar`], { foo: `=bar` }],
   ])(`spec %s becomes %s`, (input, expectedArgs) => {
-    const args = Command.create().parameter(`foo`, s).parse({ line: input })
+    const args = $.parameter(`foo`, s).parse({ line: input })
     expect(args).toMatchObject(expectedArgs)
   })
 })
@@ -82,7 +80,7 @@ describe(`case`, () => {
       [`--fooBar`,  [`--fooBar`, `foo`], { fooBar: `foo` }],
       [`--fooBar`,  [`--foo-bar`, `foo`], { fooBar: `foo` }],
     ])(`spec %s + input %s = internal %s`, (spec, input, expectedArgs) => {
-      const args = Command.create().parameter(spec as any, s).parse({line:input})
+      const args = $.parameter(spec as any, s).parse({line:input})
       expect(args).toMatchObject(expectedArgs)
     })
   })
@@ -99,33 +97,25 @@ describe(`case`, () => {
       [`--fooBar`,  [`--noFooBar`],     { fooBar: false }],
       [`--fooBar`,  [`--no-foo-bar`],   { fooBar: false }],
     ])(`spec %s + input %s = internal %s`, (spec, input, expectedArgs) => {
-      const args = Command.create().parameter(spec as any, b).parse({line:input})
+      const args = $.parameter(spec as any, b).parse({line:input})
       expect(args).toMatchObject(expectedArgs)
     })
   })
 
   test(`kebab case param spec can be passed camel case parameter`, () => {
-    const args = Command.create()
-      .parameter(`--foo-bar`, s)
-      .parse({ line: [`--fooBar`, `foo`] })
+    const args = $.parameter(`--foo-bar`, s).parse({ line: [`--fooBar`, `foo`] })
     assert<IsExact<{ fooBar: string }, typeof args>>(true)
   })
   test(`kebab case param spec can be passed kebab case parameter`, () => {
-    const args = Command.create()
-      .parameter(`--foo-bar`, s)
-      .parse({ line: [`--foo-bar`, `foo`] })
+    const args = $.parameter(`--foo-bar`, s).parse({ line: [`--foo-bar`, `foo`] })
     assert<IsExact<{ fooBar: string }, typeof args>>(true)
   })
   test(`camel case param spec can be passed kebab case parameter`, () => {
-    const args = Command.create()
-      .parameter(`--fooBar`, s)
-      .parse({ line: [`--foo-bar`, `foo`] })
+    const args = $.parameter(`--fooBar`, s).parse({ line: [`--foo-bar`, `foo`] })
     assert<IsExact<{ fooBar: string }, typeof args>>(true)
   })
   test(`camel case param spec can be passed camel case parameter`, () => {
-    const args = Command.create()
-      .parameter(`--fooBar`, s)
-      .parse({ line: [`--fooBar`, `foo`] })
+    const args = $.parameter(`--fooBar`, s).parse({ line: [`--fooBar`, `foo`] })
     assert<IsExact<{ fooBar: string }, typeof args>>(true)
   })
 })
diff --git a/packages/@molt/command/tests/line/types/boolean.spec.ts b/packages/@molt/command/tests/line/types/boolean.spec.ts
index eb93f34a..54cd0421 100644
--- a/packages/@molt/command/tests/line/types/boolean.spec.ts
+++ b/packages/@molt/command/tests/line/types/boolean.spec.ts
@@ -1,37 +1,30 @@
-import { Command } from '../../../src/index.js'
-import { b } from '../../_/helpers.js'
+import { $, b } from '../../_/helpers.js'
 import type { IsExact } from 'conditional-type-checks'
 import { assert } from 'conditional-type-checks'
 import { describe, expect, it } from 'vitest'
 
 it(`implies true`, () => {
-  const args = Command.create()
-    .parameter(`--verbose`, b)
-    .parse({ line: [`--verbose`] })
+  const args = $.parameter(`--verbose`, b).parse({ line: [`--verbose`] })
   assert<IsExact<{ verbose: boolean }, typeof args>>(true)
   expect(args).toMatchObject({ verbose: true })
 })
 
 it(`has a negated variant that implies false`, () => {
-  const args = Command.create()
-    .parameter(`--verbose`, b)
-    .parse({ line: [`--no-verbose`] })
+  const args = $.parameter(`--verbose`, b).parse({ line: [`--no-verbose`] })
   assert<IsExact<{ verbose: boolean }, typeof args>>(true)
   expect(args).toMatchObject({ verbose: false })
 })
 
 describe(`when a parameter default is specified`, () => {
   it(`uses the default value when no input given`, () => {
-    const args = Command.create().parameter(`--verbose`, b.default(false)).parse({ line: [] })
+    const args = $.parameter(`--verbose`, b.default(false)).parse({ line: [] })
     assert<IsExact<{ verbose: boolean }, typeof args>>(true)
     expect(args).toMatchObject({ verbose: false })
   })
   it(`accepts the negated parameter`, () => {
-    const args = Command.create()
-      .parameter(`--verbose`, b.default(true))
-      .parse({
-        line: [`--no-verbose`],
-      })
+    const args = $.parameter(`--verbose`, b.default(true)).parse({
+      line: [`--no-verbose`],
+    })
     assert<IsExact<{ verbose: boolean }, typeof args>>(true)
     expect(args).toMatchObject({ verbose: false })
   })
@@ -39,17 +32,14 @@ describe(`when a parameter default is specified`, () => {
 
 describe(`when parameter is optional`, () => {
   it(`allows no input to be given, resulting in omitted key`, () => {
-    const args = Command.create()
-      .parameter(`--verbose`, b.optional())
+    const args = $.parameter(`--verbose`, b.optional())
       .settings({ helpOnNoArguments: false })
       .parse({ line: [] })
     assert<IsExact<{ verbose: boolean | undefined }, typeof args>>(true)
     expect(Object.keys(args)).not.toContain(`verbose`)
   })
   it(`input can be given`, () => {
-    const args = Command.create()
-      .parameter(`--verbose`, b.optional())
-      .parse({ line: [`--verbose`] })
+    const args = $.parameter(`--verbose`, b.optional()).parse({ line: [`--verbose`] })
     assert<IsExact<{ verbose: boolean | undefined }, typeof args>>(true)
     expect(args).toMatchObject({ verbose: true })
   })
diff --git a/packages/@molt/command/tests/line/types/enum.spec.ts b/packages/@molt/command/tests/line/types/enum.spec.ts
index d825c081..6ebf9b2c 100644
--- a/packages/@molt/command/tests/line/types/enum.spec.ts
+++ b/packages/@molt/command/tests/line/types/enum.spec.ts
@@ -1,28 +1,23 @@
-import { Command } from '../../../src/index.js'
-import { s } from '../../_/helpers.js'
+import { $, s } from '../../_/helpers.js'
 import { stdout } from '../../_/mocks.js'
 import { describe, expect, it } from 'vitest'
 import { z } from 'zod'
 
 describe(`errors`, () => {
   it(`when argument missing (last position)`, () => {
-    Command.create()
-      .parameter(`--mode`, z.enum([`a`, `b`]))
-      .parse({ line: [`--mode`] })
+    $.parameter(`--mode`, z.enum([`a`, `b`])).parse({ line: [`--mode`] })
     expect(stdout.mock.calls).toMatchSnapshot()
   })
   it(`when argument missing (non-last position)`, () => {
     // prettier-ignore
-    Command.create().parameter( `--name`, s).parameter( `--mode`, z.enum([`a`,`b`]) ).parse({line:[` --mode`, `--name`, `joe`]})
+    $.parameter( `--name`, s).parameter( `--mode`, z.enum([`a`,`b`]) ).parse({line:[` --mode`, `--name`, `joe`]})
     expect(stdout.mock.calls).toMatchSnapshot()
   })
   it(`is validated`, () => {
     // const args = Parameters.create({ '--mode': z.enum([`a`, `b`, `c`]) }).parse({line:[`--mode`, `bad`]})
     // assert<IsExact<{ mode: 'a'|'b'|'c' }, typeof args>>(true)
     // expect(args).toMatchObject({ mode: true })
-    Command.create()
-      .parameter(`--mode`, z.enum([`a`, `b`, `c`]))
-      .parse({ line: [`--mode`, `bad`] })
+    $.parameter(`--mode`, z.enum([`a`, `b`, `c`])).parse({ line: [`--mode`, `bad`] })
     expect(stdout.mock.calls).toMatchSnapshot()
   })
 })
diff --git a/packages/@molt/command/tests/line/types/number.spec.ts b/packages/@molt/command/tests/line/types/number.spec.ts
index c0518bbe..3bf78c03 100644
--- a/packages/@molt/command/tests/line/types/number.spec.ts
+++ b/packages/@molt/command/tests/line/types/number.spec.ts
@@ -1,5 +1,4 @@
-import { Command } from '../../../src/index.js'
-import { n } from '../../_/helpers.js'
+import { $, n } from '../../_/helpers.js'
 import { s } from '../../_/helpers.js'
 import { stdout } from '../../_/mocks.js'
 import type { IsExact } from 'conditional-type-checks'
@@ -7,29 +6,22 @@ import { assert } from 'conditional-type-checks'
 import { describe, expect, it } from 'vitest'
 
 it(`casts the input as a number`, () => {
-  const args = Command.create()
-    .parameter(`--age`, n)
-    .parse({ line: [`--age`, `1`] })
+  const args = $.parameter(`--age`, n).parse({ line: [`--age`, `1`] })
   assert<IsExact<{ age: number }, typeof args>>(true)
   expect(args).toMatchObject({ age: 1 })
 })
 
 describe(`errors`, () => {
   it(`validates the  input`, () => {
-    Command.create()
-      .parameter(`--age`, n.int())
-      .parse({ line: [`--age`, `1.1`] })
+    $.parameter(`--age`, n.int()).parse({ line: [`--age`, `1.1`] })
     expect(stdout.mock.calls).toMatchSnapshot()
   })
   it(`throws error when argument missing (last position)`, () => {
-    Command.create()
-      .parameter(`--age`, n)
-      .parse({ line: [`--age`] })
+    $.parameter(`--age`, n).parse({ line: [`--age`] })
     expect(stdout.mock.calls).toMatchSnapshot()
   })
   it(`throws error when argument missing (non-last position)`, () => {
-    Command.create()
-      .parameter(`--name`, s)
+    $.parameter(`--name`, s)
       .parameter(`--age`, n)
       .parse({
         line: [` --age`, `--name`, `joe`],
diff --git a/packages/@molt/command/tests/line/types/string.spec.ts b/packages/@molt/command/tests/line/types/string.spec.ts
index 3c8ffd27..8465d02f 100644
--- a/packages/@molt/command/tests/line/types/string.spec.ts
+++ b/packages/@molt/command/tests/line/types/string.spec.ts
@@ -1,5 +1,4 @@
-import { Command } from '../../../src/index.js'
-import { n, s } from '../../_/helpers.js'
+import { $, n, s } from '../../_/helpers.js'
 import type { IsExact } from 'conditional-type-checks'
 import { assert } from 'conditional-type-checks'
 import { describe, expect, it } from 'vitest'
@@ -16,7 +15,7 @@ describe(`errors`, () => {
   )(`%s`, (_, parameters, input) => {
     expect(() => {
       Object.entries(parameters)
-        .reduce((chain, data) => chain.parameter(data[0] as any, data[1]), Command.create())
+        .reduce((chain, data) => chain.parameter(data[0] as any, data[1]), $)
         .settings({ onError: `throw`, helpOnError: false })
         .parse(input)
     }).toThrowErrorMatchingSnapshot()
@@ -25,23 +24,17 @@ describe(`errors`, () => {
 
 describe(`optional`, () => {
   it(`specified input can be omitted, missing key is possible`, () => {
-    const args = Command.create().parameter(`--foo`, s.optional()).parse({ line: [] })
+    const args = $.parameter(`--foo`, s.optional()).parse({ line: [] })
     assert<IsExact<{ foo: string | undefined }, typeof args>>(true)
     expect(Object.keys(args)).not.toContain(`foo`)
   })
   it(`input can be given`, () => {
-    const args = Command.create()
-      .parameter(`--foo`, s.optional())
-      .parse({ line: [`--foo`, `bar`] })
+    const args = $.parameter(`--foo`, s.optional()).parse({ line: [`--foo`, `bar`] })
     assert<IsExact<{ foo: string | undefined }, typeof args>>(true)
     expect(args).toMatchObject({ foo: `bar` })
   })
 })
 
 it(`is not trimmed by default`, () => {
-  expect(
-    Command.create()
-      .parameter(`name`, s)
-      .parse({ line: [`--name`, `foobar  `] }),
-  ).toMatchSnapshot()
+  expect($.parameter(`name`, s).parse({ line: [`--name`, `foobar  `] })).toMatchSnapshot()
 })
diff --git a/packages/@molt/command/tests/parameters/configurationObject.spec.ts b/packages/@molt/command/tests/parameters/configurationObject.spec.ts
index 1b768cad..9097167e 100644
--- a/packages/@molt/command/tests/parameters/configurationObject.spec.ts
+++ b/packages/@molt/command/tests/parameters/configurationObject.spec.ts
@@ -1,21 +1,18 @@
-import { Command } from '../../src/index.js'
-import { n, s } from '../_/helpers.js'
+import { $, n, s } from '../_/helpers.js'
 import { expectType } from 'tsd'
 import { expect, it } from 'vitest'
 
 it(`parameter can receive configuration object`, () => {
-  const args = Command.create().parameter(`a`, { schema: s.optional() }).parse({ line: [] })
+  const args = $.parameter(`a`, { type: s.optional() }).parse({ line: [] })
   expectType<{ a?: string }>(args)
   expect(args).toMatchObject({})
 })
 
 it(`exclusive parameter builder parameter method can receive configuration object`, () => {
-  const args = Command.create()
-    .parametersExclusive(`foo`, (_) => {
-      const x = _.parameter(`a`, { schema: s }).parameter(`b`, { schema: n })
-      return x
-    })
-    .parse({ line: [`-a`, `abc`] })
+  const args = $.parametersExclusive(`foo`, (_) => {
+    const x = _.parameter(`a`, { type: s }).parameter(`b`, { type: n })
+    return x
+  }).parse({ line: [`-a`, `abc`] })
   expectType<{ foo: { _tag: 'a'; value: string } | { _tag: 'b'; value: number } }>(args)
   expect(args).toMatchObject({ foo: { _tag: `a`, value: `abc` } })
 })
diff --git a/packages/@molt/command/tests/parameters/description.spec.ts b/packages/@molt/command/tests/parameters/description.spec.ts
index bc06a512..cc99ca11 100644
--- a/packages/@molt/command/tests/parameters/description.spec.ts
+++ b/packages/@molt/command/tests/parameters/description.spec.ts
@@ -1,5 +1,4 @@
-import { Command } from '../../src/index.js'
-import { s } from '../_/helpers.js'
+import { $, s } from '../_/helpers.js'
 import stripAnsi from 'strip-ansi'
 import { describe, expect, it } from 'vitest'
 import { mockProcessExit, mockProcessStdout } from 'vitest-mock-process'
@@ -9,33 +8,25 @@ mockProcessExit()
 
 describe(`placement of describe method in zod method chain does not matter`, () => {
   it(`description can trail optional`, () => {
-    Command.create()
-      .parameter(`a`, s.optional().describe(`Blah blah blah.`))
-      .parse({ line: [`-h`] })
+    $.parameter(`a`, s.optional().describe(`Blah blah blah.`)).parse({ line: [`-h`] })
     const output = processStdout.mock.lastCall?.[0] as string
     expect(stripAnsi(output)).toMatch(/Blah blah blah./)
   })
 
   it(`description can lead optional`, () => {
-    Command.create()
-      .parameter(`a`, s.describe(`Blah blah blah.`).optional())
-      .parse({ line: [`-h`] })
+    $.parameter(`a`, s.describe(`Blah blah blah.`).optional()).parse({ line: [`-h`] })
     const output = processStdout.mock.lastCall?.[0] as string
     expect(stripAnsi(output)).toMatch(/Blah blah blah./)
   })
 
   it(`description can trail default`, () => {
-    Command.create()
-      .parameter(`a`, s.default(`x`).describe(`Blah blah blah.`))
-      .parse({ line: [`-h`] })
+    $.parameter(`a`, s.default(`x`).describe(`Blah blah blah.`)).parse({ line: [`-h`] })
     const output = processStdout.mock.lastCall?.[0] as string
     expect(stripAnsi(output)).toMatch(/Blah blah blah./)
   })
 
   it(`description can lead default`, () => {
-    Command.create()
-      .parameter(`a`, s.describe(`Blah blah blah.`).default(`x`))
-      .parse({ line: [`-h`] })
+    $.parameter(`a`, s.describe(`Blah blah blah.`).default(`x`)).parse({ line: [`-h`] })
     const output = processStdout.mock.lastCall?.[0] as string
     expect(stripAnsi(output)).toMatch(/Blah blah blah./)
   })
@@ -44,21 +35,21 @@ describe(`placement of describe method in zod method chain does not matter`, ()
 describe(`when there are multiple describe methods in the zod method chain only the last (outer most) one is used`, () => {
   it(`last description instance wins`, () => {
     // prettier-ignore
-    Command.create().parameter( `a`, s.describe(`Blah blah blah 1.`).describe(`Blah blah blah 2.`) ).parse({ line: [`-h`] })
+    $.parameter( `a`, s.describe(`Blah blah blah 1.`).describe(`Blah blah blah 2.`) ).parse({ line: [`-h`] })
     const output = processStdout.mock.lastCall?.[0] as string
     expect(stripAnsi(output)).toMatch(/Blah blah blah 2./)
   })
 
   it(`last description instance separated by default wins`, () => {
     // prettier-ignore
-    Command.create().parameter( `a`, s.describe(`Blah blah blah 1.`).default(`x`).describe(`Blah blah blah 2.`) ).parse( { line: [`-h`] })
+    $.parameter( `a`, s.describe(`Blah blah blah 1.`).default(`x`).describe(`Blah blah blah 2.`) ).parse( { line: [`-h`] })
     const output = processStdout.mock.lastCall?.[0] as string
     expect(stripAnsi(output)).toMatch(/Blah blah blah 2./)
   })
 
   // prettier-ignore
   it(`last description instance separated by optional wins`, () => {
-    Command.create().parameter( `a`, s.describe(`Blah blah blah 1.`).optional().describe(`Blah blah blah 2.`) ).parse({ line: [`-h`], })
+    $.parameter( `a`, s.describe(`Blah blah blah 1.`).optional().describe(`Blah blah blah 2.`) ).parse({ line: [`-h`], })
     const output = processStdout.mock.lastCall?.[0] as string
     expect(stripAnsi(output)).toMatch(/Blah blah blah 2./)
   })
diff --git a/packages/@molt/command/tests/parameters/unionType.spec.ts b/packages/@molt/command/tests/parameters/unionType.spec.ts
index e883697c..23326d0c 100644
--- a/packages/@molt/command/tests/parameters/unionType.spec.ts
+++ b/packages/@molt/command/tests/parameters/unionType.spec.ts
@@ -1,73 +1,57 @@
-import { Command } from '../../src/index.js'
+import { $, as } from '../_/helpers.js'
 import { expectType } from 'tsd'
 import { expect, it } from 'vitest'
 import { z } from 'zod'
 
 it(`arg static type is the union`, () => {
-  const args = Command.create()
-    .parameter(`x`, z.union([z.string(), z.number()]))
-    .parse({ line: [`-x`, `1`] })
-  expectType<typeof args>(0 as any as { x: string | number })
+  const args = $.parameter(`x`, z.union([z.string(), z.number()])).parse({ line: [`-x`, `1`] })
+  expectType<typeof args>(as<{ x: string | number }>())
 })
 
 it(`spec of number|string parses arg as number if number given`, () => {
-  const args = Command.create()
-    .parameter(`x`, z.union([z.string(), z.number()]))
-    .parse({ line: [`-x`, `1`] })
+  const args = $.parameter(`x`, z.union([z.string(), z.number()])).parse({ line: [`-x`, `1`] })
   expect(typeof args.x).toBe(`number`)
   expect(args.x).toBe(1)
 })
 
 it(`spec of number|string parses arg as string if non-number given`, () => {
-  const args = Command.create()
-    .parameter(`x`, z.union([z.string(), z.number()]))
-    .parse({ line: [`-x`, `1a`] })
+  const args = $.parameter(`x`, z.union([z.string(), z.number()])).parse({ line: [`-x`, `1a`] })
   expect(typeof args.x).toBe(`string`)
   expect(args.x).toBe(`1a`)
 })
 
 it(`spec of number|boolean parses arg as boolean true if bool flag given`, () => {
-  const args = Command.create()
-    .parameter(`x`, z.union([z.boolean(), z.number()]))
-    .parse({ line: [`-x`] })
+  const args = $.parameter(`x`, z.union([z.boolean(), z.number()])).parse({ line: [`-x`] })
   expect(typeof args.x).toBe(`boolean`)
   expect(args.x).toBe(true)
 })
 
 it(`spec of number|boolean parses arg as boolean false if negated bool flag given`, () => {
-  const args = Command.create()
-    .parameter(`xee`, z.union([z.boolean(), z.number()]))
-    .parse({ line: [`--no-xee`] })
+  const args = $.parameter(`xee`, z.union([z.boolean(), z.number()])).parse({ line: [`--no-xee`] })
   expect(typeof args.xee).toBe(`boolean`)
   expect(args.xee).toBe(false)
 })
 
 it(`spec of number|boolean parses arg as boolean false if environment false given`, () => {
-  const args = Command.create()
-    .parameter(`xee`, z.union([z.boolean(), z.number()]))
-    .parse({
-      environment: { cli_param_xee: `false` },
-    })
+  const args = $.parameter(`xee`, z.union([z.boolean(), z.number()])).parse({
+    environment: { cli_param_xee: `false` },
+  })
   expect(typeof args.xee).toBe(`boolean`)
   expect(args.xee).toBe(false)
 })
 
 it(`spec of number|boolean parses arg as boolean true if environment true given`, () => {
-  const args = Command.create()
-    .parameter(`xee`, z.union([z.boolean(), z.number()]))
-    .parse({
-      environment: { cli_param_xee: `true` },
-    })
+  const args = $.parameter(`xee`, z.union([z.boolean(), z.number()])).parse({
+    environment: { cli_param_xee: `true` },
+  })
   expect(typeof args.xee).toBe(`boolean`)
   expect(args.xee).toBe(true)
 })
 
 it(`can use the .or method api sugar of zod`, () => {
-  const args = Command.create()
-    .parameter(`xee`, z.boolean().or(z.number()))
-    .parse({
-      environment: { cli_param_xee: `true` },
-    })
+  const args = $.parameter(`xee`, z.boolean().or(z.number())).parse({
+    environment: { cli_param_xee: `true` },
+  })
   expectType<boolean | number>(args.xee)
   expect(typeof args.xee).toBe(`boolean`)
   expect(args.xee).toBe(true)
diff --git a/packages/@molt/command/tests/parameters/zod/nativeEnum.spec.ts b/packages/@molt/command/tests/parameters/zod/nativeEnum.spec.ts
index 1a5b658d..ee27f376 100644
--- a/packages/@molt/command/tests/parameters/zod/nativeEnum.spec.ts
+++ b/packages/@molt/command/tests/parameters/zod/nativeEnum.spec.ts
@@ -1,10 +1,9 @@
-import { Command } from '../../../src/index.js'
+import { $ } from '../../_/helpers.js'
 import { expect, it } from 'vitest'
 import { z } from 'zod'
 
 it(`works`, () => {
-  const args = Command.create()
-    .parameter(`a`, z.nativeEnum({ a: 1, b: 2 } as const))
+  const args = $.parameter(`a`, z.nativeEnum({ a: 1, b: 2 } as const))
     .settings({ onError: `throw` })
     .parse({ line: [`-a`, `1`] })
   expect(args).toMatchObject({ a: 1 })
diff --git a/packages/@molt/command/tests/parameters/zod/number.spec.ts b/packages/@molt/command/tests/parameters/zod/number.spec.ts
index 05d29adc..5ee1e6f9 100644
--- a/packages/@molt/command/tests/parameters/zod/number.spec.ts
+++ b/packages/@molt/command/tests/parameters/zod/number.spec.ts
@@ -1,5 +1,4 @@
-import { Command } from '../../../src/index.js'
-import { l1, n } from '../../_/helpers.js'
+import { $, l1, n } from '../../_/helpers.js'
 import { describe, expect, it } from 'vitest'
 
 describe(`zod`, () => {
@@ -22,7 +21,7 @@ describe(`zod`, () => {
           // @ts-expect-error todo
           .reduce((chain, data) => {
             return chain.parameter(data[0] as any, data[1])
-          }, Command.create())
+          }, $)
           // @ts-expect-error todo
           .settings({ onError: `throw`, helpOnError: false })
           .parse(input)
diff --git a/packages/@molt/command/tests/parameters/zod/static.spec.ts b/packages/@molt/command/tests/parameters/zod/static.spec.ts
index 1c185a4d..77562a39 100644
--- a/packages/@molt/command/tests/parameters/zod/static.spec.ts
+++ b/packages/@molt/command/tests/parameters/zod/static.spec.ts
@@ -1,32 +1,32 @@
-import { Command } from '../../../src/index.js'
+import { $ } from '../../_/helpers.js'
 import { expectType } from 'tsd'
 import { expect, it } from 'vitest'
 import { z } from 'zod'
 
 // prettier-ignore
 it(`Statically accepts or rejects zod types for the schema`, () => {
- expectType<() => {a:string}>(Command.create().parameter(`a`, z.string()).parse)
-  expectType<() => {a:number}>(Command.create().parameter(`a`, z.number()).parse)
-  expectType<() => {a:boolean}>(Command.create().parameter(`a`, z.boolean()).parse)
-  expectType<() => {a:'a'|'b'}>(Command.create().parameter(`a`, z.enum([`a`, `b`])).parse)
-  expectType<() => {a:'a'|'b'}>(Command.create().parameter(`a`, z.nativeEnum({ a: `a`, b: `b` } as const)).parse)
-  expectType<() => {a:1}>(Command.create().parameter(`a`, z.literal(1)).parse)
-  expectType<() => {a:'a'}>(Command.create().parameter(`a`, z.literal(`a`)).parse)
-  expectType<() => {a:true}>(Command.create().parameter(`a`, z.literal(true)).parse)
-  expectType<() => {a:false}>(Command.create().parameter(`a`, z.literal(false)).parse)
+ expectType<() => {a:string}>($.parameter(`a`, z.string()).parse)
+  expectType<() => {a:number}>($.parameter(`a`, z.number()).parse)
+  expectType<() => {a:boolean}>($.parameter(`a`, z.boolean()).parse)
+  expectType<() => {a:'a'|'b'}>($.parameter(`a`, z.enum([`a`, `b`])).parse)
+  expectType<() => {a:'a'|'b'}>($.parameter(`a`, z.nativeEnum({ a: `a`, b: `b` } as const)).parse)
+  expectType<() => {a:1}>($.parameter(`a`, z.literal(1)).parse)
+  expectType<() => {a:'a'}>($.parameter(`a`, z.literal(`a`)).parse)
+  expectType<() => {a:true}>($.parameter(`a`, z.literal(true)).parse)
+  expectType<() => {a:false}>($.parameter(`a`, z.literal(false)).parse)
   // union
-  expectType<() => {a:true|false|'a'|'b'}>(Command.create().parameter(`a`, z.union([z.boolean(), z.enum([`a`, `b`])])).parse)
-  expectType<() => {a:string|number}>			(Command.create().parameter(`a`, z.union([z.string(), z.number()])).parse)
-  expectType<() => {a:number|'a'|'b'}>		(Command.create().parameter(`a`, z.union([z.number(), z.nativeEnum({ a: `a`, b: `b` } as const)])).parse)
-  expectType<() => {a:1|'a'|true|false}>	(Command.create().parameter(`a`, z.union([z.literal(1), z.literal(`a`), z.literal(true), z.literal(false)])).parse)
+  expectType<() => {a:true|false|'a'|'b'}>($.parameter(`a`, z.union([z.boolean(), z.enum([`a`, `b`])])).parse)
+  expectType<() => {a:string|number}>			($.parameter(`a`, z.union([z.string(), z.number()])).parse)
+  expectType<() => {a:number|'a'|'b'}>		($.parameter(`a`, z.union([z.number(), z.nativeEnum({ a: `a`, b: `b` } as const)])).parse)
+  expectType<() => {a:1|'a'|true|false}>	($.parameter(`a`, z.union([z.literal(1), z.literal(`a`), z.literal(true), z.literal(false)])).parse)
 	// todo key should be ?
 	// optional
-  expectType<() => {a:undefined|string}>(Command.create().parameter(`a`, z.string().optional()).parse)
-  expectType<() => {a:undefined|1}>(Command.create().parameter(`a`, z.literal(1).optional()).parse)
+  expectType<() => {a:undefined|string}>($.parameter(`a`, z.string().optional()).parse)
+  expectType<() => {a:undefined|1}>($.parameter(`a`, z.literal(1).optional()).parse)
 	// default
-	expectType<() => {a:string}>(Command.create().parameter(`a`, z.string().default(`a`)).parse)
-  expectType<() => {a:1}>(Command.create().parameter(`a`, z.literal(1).default(1)).parse)
+	expectType<() => {a:string}>($.parameter(`a`, z.string().default(`a`)).parse)
+  expectType<() => {a:1}>($.parameter(`a`, z.literal(1).default(1)).parse)
 	// unsupported
 	// @ts-expect-error not supported
-	expect(() => Command.create().parameter(`a`, z.unknown())).throws()
+	expect(() => $.parameter(`a`, z.unknown())).throws()
 })
diff --git a/packages/@molt/command/tests/parameters/zod/string.spec.ts b/packages/@molt/command/tests/parameters/zod/string.spec.ts
index 59b41cff..1ac3e249 100644
--- a/packages/@molt/command/tests/parameters/zod/string.spec.ts
+++ b/packages/@molt/command/tests/parameters/zod/string.spec.ts
@@ -1,6 +1,5 @@
 import { entries } from '../../../src/helpers.js'
-import { Command } from '../../../src/index.js'
-import { s } from '../../_/helpers.js'
+import { $, s } from '../../_/helpers.js'
 import { describe, expect, it } from 'vitest'
 import { z } from 'zod'
 
@@ -16,7 +15,7 @@ describe(`zod`, () => {
     )(`%s`, (_, parameters, input) => {
       expect(
         entries(parameters)
-          .reduce((chain, data) => chain.parameter(data[0] as any, data[1]), Command.create())
+          .reduce((chain, data) => chain.parameter(data[0] as any, data[1]), $)
           .parse(input),
       ).toMatchSnapshot()
     })
@@ -49,7 +48,7 @@ describe(`zod`, () => {
     )(`%s`, (_, parameters, input) => {
       expect(() => {
         Object.entries(parameters)
-          .reduce((chain, data) => chain.parameter(data[0] as any, data[1]), Command.create())
+          .reduce((chain, data) => chain.parameter(data[0] as any, data[1]), $)
           .settings({ onError: `throw`, helpOnError: false })
           .parse(input)
       }).toThrowErrorMatchingSnapshot()
diff --git a/packages/@molt/command/tests/prompt/prompt.spec.ts b/packages/@molt/command/tests/prompt/prompt.spec.ts
index e369f2f3..2a745154 100644
--- a/packages/@molt/command/tests/prompt/prompt.spec.ts
+++ b/packages/@molt/command/tests/prompt/prompt.spec.ts
@@ -1,8 +1,7 @@
-import type { ParameterConfiguration } from '../../src/Command/root/types.js'
-import type { Settings } from '../../src/entrypoints/types.js'
-import { Command } from '../../src/index.js'
+import type { BuilderCommandState } from '../../src/builders/command/state.js'
+import type { CommandBuilder } from '../../src/builders/command/types.js'
 import type { KeyPress } from '../../src/lib/KeyPress/index.js'
-import { b, e, l1, n, s, tryCatch } from '../_/helpers.js'
+import { $, b, e, l1, n, s, tryCatch } from '../_/helpers.js'
 import { memoryPrompter } from '../_/mocks/tty.js'
 import stripAnsi from 'strip-ansi'
 import { expectType } from 'tsd'
@@ -11,14 +10,13 @@ import { z } from 'zod'
 
 // TODO test that prompt order is based on order of parameter definition
 
-let parameters: Record<string, ParameterConfiguration>
+const $$ = $.settings({ onError: `throw`, helpOnError: false })
+
 let answers: string[]
 let keyPresses: KeyPress.KeyPressEvent[]
 let line: string[]
-const settings: Settings.Input = {}
 
 beforeEach(() => {
-  parameters = {}
   answers = []
   keyPresses = []
   line = []
@@ -27,16 +25,14 @@ beforeEach(() => {
 describe(`string`, () => {
   describe(`optional`, () => {
     it(`when nothing entered then value is undefined`, async () => {
-      // @ts-expect-error todo
-      parameters = { a: { schema: s.optional(), prompt: { when: { result: `omitted` } } } }
       keyPresses.push({ ctrl: false, meta: false, sequence: ``, shift: false, name: `return` })
-      await run()
+      // @ts-expect-error - todo with Pierre
+      await run($$.parameter(`a`, { type: s.optional(), prompt: { when: { result: `omitted` } } }))
     })
     it(`when esc is pressed the question is skipped`, async () => {
-      // @ts-expect-error todo
-      parameters = { a: { schema: s.optional(), prompt: { when: { result: `omitted` } } } }
       keyPresses.push({ ctrl: false, meta: false, sequence: ``, shift: false, name: `escape` })
-      await run()
+      // @ts-expect-error - todo with Pierre
+      await run($$.parameter(`a`, { type: s.optional(), prompt: { when: { result: `omitted` } } }))
     })
   })
 })
@@ -44,16 +40,14 @@ describe(`string`, () => {
 describe(`number`, () => {
   describe(`optional`, () => {
     it(`when nothing entered then value is undefined`, async () => {
-      // @ts-expect-error todo
-      parameters = { a: { schema: n.optional(), prompt: { when: { result: `omitted` } } } }
       keyPresses.push({ ctrl: false, meta: false, sequence: ``, shift: false, name: `return` })
-      await run()
+      // @ts-expect-error - todo with Pierre
+      await run($$.parameter(`a`, { type: n.optional(), prompt: { when: { result: `omitted` } } }))
     })
     it(`when esc is pressed the question is skipped`, async () => {
-      // @ts-expect-error todo
-      parameters = { a: { schema: n.optional(), prompt: { when: { result: `omitted` } } } }
       keyPresses.push({ ctrl: false, meta: false, sequence: ``, shift: false, name: `escape` })
-      await run()
+      // @ts-expect-error todo
+      await run($$.parameter(`a`, { type: n.optional(), prompt: { when: { result: `omitted` } } }))
     })
   })
 })
@@ -61,35 +55,35 @@ describe(`number`, () => {
 describe(`boolean`, () => {
   describe(`required`, () => {
     it(`defaults to "no"`, async () => {
-      parameters = { a: { schema: b, prompt: true } }
       keyPresses.push({ ctrl: false, meta: false, sequence: ``, shift: false, name: `return` })
-      await run()
+      // @ts-expect-error - todo with Pierre
+      await run($$.parameter(`a`, { type: b, prompt: true }))
     })
     it(`can be toggled to "yes"`, async () => {
-      parameters = { a: { schema: b, prompt: true } }
       keyPresses.push(
         { ctrl: false, meta: false, sequence: ``, shift: false, name: `right` },
         { ctrl: false, meta: false, sequence: ``, shift: false, name: `return` },
       )
-      await run()
+      // @ts-expect-error - todo with Pierre
+      await run($$.parameter(`a`, { type: b, prompt: true }))
     })
     it(`can be toggled to "yes" and then back to "no"`, async () => {
-      parameters = { a: { schema: b, prompt: true } }
       keyPresses.push(
         { ctrl: false, meta: false, sequence: ``, shift: false, name: `right` },
         { ctrl: false, meta: false, sequence: ``, shift: false, name: `left` },
         { ctrl: false, meta: false, sequence: ``, shift: false, name: `return` },
       )
-      await run()
+      // @ts-expect-error - todo with Pierre
+      await run($$.parameter(`a`, { type: b, prompt: true }))
     })
     it(`can use tab to toggle between "yes" and "no"`, async () => {
-      parameters = { a: { schema: b, prompt: true } }
       keyPresses.push(
         { ctrl: false, meta: false, sequence: ``, shift: false, name: `tab` },
         { ctrl: false, meta: false, sequence: ``, shift: false, name: `tab` },
         { ctrl: false, meta: false, sequence: ``, shift: false, name: `return` },
       )
-      await run()
+      // @ts-expect-error - todo with Pierre
+      await run($$.parameter(`a`, { type: b, prompt: true }))
     })
   })
 })
@@ -97,12 +91,12 @@ describe(`boolean`, () => {
 describe(`union`, () => {
   describe(`required`, () => {
     it(`asks user to select member to use"`, async () => {
-      parameters = { a: { schema: z.union([n, b, s]), prompt: true } }
       keyPresses.push({ ctrl: false, meta: false, sequence: ``, shift: false, name: `tab` })
       keyPresses.push({ ctrl: false, meta: false, sequence: ``, shift: false, name: `return` })
       keyPresses.push({ ctrl: false, meta: false, sequence: ``, shift: false, name: `tab` })
       keyPresses.push({ ctrl: false, meta: false, sequence: ``, shift: false, name: `return` })
-      await run()
+      // @ts-expect-error - todo with Pierre
+      await run($$.parameter(`a`, { type: z.union([n, b, s]), prompt: true }))
     })
   })
 })
@@ -110,85 +104,77 @@ describe(`union`, () => {
 describe(`enumeration`, () => {
   describe(`required`, () => {
     it(`defaults to first member`, async () => {
-      parameters = { a: { schema: e, prompt: true } }
       keyPresses.push({ ctrl: false, meta: false, sequence: ``, shift: false, name: `return` })
-      await run()
+      // @ts-expect-error - todo with Pierre
+      await run($$.parameter(`a`, { type: e, prompt: true }))
     })
     it(`can select member rightward with right key`, async () => {
-      parameters = { a: { schema: e, prompt: true } }
       keyPresses.push({ ctrl: false, meta: false, sequence: ``, shift: false, name: `right` })
       keyPresses.push({ ctrl: false, meta: false, sequence: ``, shift: false, name: `return` })
-      await run()
+      // @ts-expect-error - todo with Pierre
+      await run($$.parameter(`a`, { type: e, prompt: true }))
     })
     it(`can select member leftward with left key`, async () => {
-      parameters = { a: { schema: e, prompt: true } }
       keyPresses.push({ ctrl: false, meta: false, sequence: ``, shift: false, name: `right` })
       keyPresses.push({ ctrl: false, meta: false, sequence: ``, shift: false, name: `left` })
       keyPresses.push({ ctrl: false, meta: false, sequence: ``, shift: false, name: `return` })
-      await run()
+      // @ts-expect-error - todo with Pierre
+      await run($$.parameter(`a`, { type: e, prompt: true }))
     })
     describe(`tab`, () => {
       it(`can select member rightward with tab key`, async () => {
-        parameters = { a: { schema: e, prompt: true } }
         keyPresses.push({ ctrl: false, meta: false, sequence: ``, shift: false, name: `tab` })
         keyPresses.push({ ctrl: false, meta: false, sequence: ``, shift: false, name: `return` })
-        await run()
+        // @ts-expect-error - todo with Pierre
+        await run($$.parameter(`a`, { type: e, prompt: true }))
       })
       it(`can select member leftward with shift+tab key`, async () => {
-        parameters = { a: { schema: e, prompt: true } }
         keyPresses.push({ ctrl: false, meta: false, sequence: ``, shift: false, name: `right` })
         keyPresses.push({ ctrl: false, meta: false, sequence: ``, shift: true, name: `tab` })
         keyPresses.push({ ctrl: false, meta: false, sequence: ``, shift: false, name: `return` })
-        await run()
+        // @ts-expect-error - todo with Pierre
+        await run($$.parameter(`a`, { type: e, prompt: true }))
       })
     })
     describe(`loop`, () => {
       it(`right key on last member loops to first member`, async () => {
-        parameters = { a: { schema: e, prompt: true } }
         keyPresses.push({ ctrl: false, meta: false, sequence: ``, shift: false, name: `right` })
         keyPresses.push({ ctrl: false, meta: false, sequence: ``, shift: false, name: `right` })
         keyPresses.push({ ctrl: false, meta: false, sequence: ``, shift: false, name: `right` })
         keyPresses.push({ ctrl: false, meta: false, sequence: ``, shift: false, name: `return` })
-        await run()
+        // @ts-expect-error - todo with Pierre
+        await run($$.parameter(`a`, { type: e, prompt: true }))
       })
       it(`left key on first member loops to last member`, async () => {
-        parameters = { a: { schema: e, prompt: true } }
         keyPresses.push({ ctrl: false, meta: false, sequence: ``, shift: false, name: `left` })
         keyPresses.push({ ctrl: false, meta: false, sequence: ``, shift: false, name: `return` })
-        await run()
+        // @ts-expect-error - todo with Pierre
+        await run($$.parameter(`a`, { type: e, prompt: true }))
       })
     })
   })
 })
 
 it(`can be explicitly disabled`, async () => {
-  parameters = {
-    a: {
-      schema: s,
-      prompt: { enabled: false },
-    },
-  }
   answers = []
   line = []
-  await run()
+  // @ts-expect-error - todo with Pierre
+  await run($$.parameter(`a`, { type: s, prompt: { enabled: false } }))
 })
 
 it(`can be explicitly disabled with a "when" condition present`, async () => {
-  parameters = {
-    a: {
-      schema: s.min(2),
-      prompt: { enabled: false, when: { result: `rejected`, error: `ErrorMissingArgument` } },
-    },
-  }
   answers = []
   line = []
-  await run()
+  await run(
+    // @ts-expect-error - todo with Pierre
+    $$.parameter(`a`, {
+      type: s.min(2),
+      prompt: { enabled: false, when: { result: `rejected`, error: `ErrorMissingArgument` } },
+    }),
+  )
 })
 
 it(`prompt when missing input`, async () => {
-  parameters = {
-    a: { schema: s.min(2), prompt: { when: { result: `rejected`, error: `ErrorMissingArgument` } } },
-  }
   keyPresses.push(
     { ctrl: false, meta: false, sequence: `f`, shift: false, name: `f` },
     { ctrl: false, meta: false, sequence: `o`, shift: false, name: `o` },
@@ -196,13 +182,16 @@ it(`prompt when missing input`, async () => {
     { ctrl: false, meta: false, sequence: ``, shift: false, name: `return` },
   )
   line = []
-  await run()
+  await run(
+    // @ts-expect-error - todo with Pierre
+    $$.parameter(`a`, {
+      type: s.min(2),
+      prompt: { when: { result: `rejected`, error: `ErrorMissingArgument` } },
+    }),
+  )
 })
 
 it(`prompt when invalid input`, async () => {
-  parameters = {
-    a: { schema: s.min(2), prompt: { when: { result: `rejected`, error: `ErrorInvalidArgument` } } },
-  }
   keyPresses.push(
     { ctrl: false, meta: false, sequence: `f`, shift: false, name: `f` },
     { ctrl: false, meta: false, sequence: `o`, shift: false, name: `o` },
@@ -210,16 +199,16 @@ it(`prompt when invalid input`, async () => {
     { ctrl: false, meta: false, sequence: ``, shift: false, name: `return` },
   )
   line = [`-a`, `1`]
-  await run()
+  await run(
+    // @ts-expect-error - todo with Pierre
+    $.parameter(`a`, {
+      type: s.min(2),
+      prompt: { when: { result: `rejected`, error: `ErrorInvalidArgument` } },
+    }),
+  )
 })
 
 it(`prompt when invalid input OR missing input`, async () => {
-  parameters = {
-    a: {
-      schema: s.min(2),
-      prompt: { when: { result: `rejected`, error: [`ErrorInvalidArgument`, `ErrorMissingArgument`] } },
-    },
-  }
   keyPresses.push(
     { ctrl: false, meta: false, sequence: `f`, shift: false, name: `f` },
     { ctrl: false, meta: false, sequence: `o`, shift: false, name: `o` },
@@ -227,17 +216,16 @@ it(`prompt when invalid input OR missing input`, async () => {
     { ctrl: false, meta: false, sequence: ``, shift: false, name: `return` },
   )
   line = [`-a`, `1`]
-  await run()
+  await run(
+    // @ts-expect-error - todo with Pierre
+    $$.parameter(`a`, {
+      type: s.min(2),
+      prompt: { when: { result: `rejected`, error: [`ErrorInvalidArgument`, `ErrorMissingArgument`] } },
+    }),
+  )
 })
 
 it(`prompt when omitted`, async () => {
-  parameters = {
-    a: {
-      schema: s.min(2).optional(),
-      // @ts-expect-error todo
-      prompt: { when: { result: `omitted`, spec: { optionality: [`default`, `optional`] } } },
-    },
-  }
   keyPresses.push(
     { ctrl: false, meta: false, sequence: `f`, shift: false, name: `f` },
     { ctrl: false, meta: false, sequence: `o`, shift: false, name: `o` },
@@ -245,85 +233,78 @@ it(`prompt when omitted`, async () => {
     { ctrl: false, meta: false, sequence: ``, shift: false, name: `return` },
   )
   line = []
-  await run()
+  await run(
+    // @ts-expect-error - todo with Pierre
+    $$.parameter(`a`, {
+      type: s.min(2).optional(),
+      prompt: { when: { result: `omitted`, spec: { optionality: [`default`, `optional`] } } },
+    }),
+  )
 })
 
 it(`static error to match on omitted event on required parameter by .parameter(...)`, () => {
   // @ts-expect-error not available
-  Command.create().parameter(`a`, { schema: s, prompt: { when: { result: `omitted` } } })
+  $.parameter(`a`, { type: s, prompt: { when: { result: `omitted` } } })
   // TODO fix me
   // // Is fine, because parameter is optional.
-  // Command.create().parameter(`a`, {
-  //   schema: s.optional(),
+  // $.parameter(`a`, {
+  //   type: s.optional(),
   //   prompt: { when: { result: `omitted` } },
   // })
 })
 
 it(`can pass just one pattern in multiple pattern syntax`, () => {
-  Command.create()
-    .parameter(`a`, s)
-    .settings({ prompt: { when: [{ result: `accepted` }] } })
+  $.parameter(`a`, s).settings({ prompt: { when: [{ result: `accepted` }] } })
 })
 
 it(`static error to match on omitted event on command level when no parameters have optional`, () => {
   // TODO fix me
-  // Command.create()
+  // $
   //   .parameter(`a`, s)
   //   // @ts-expect-error not available
   //   .settings({ prompt: { when: { result: `omitted` } } })
   // Is fine, because parameter is optional.
-  Command.create()
-    .parameter(`a`, s.optional())
-    .settings({ prompt: { when: { result: `omitted` } } })
+  $.parameter(`a`, s.optional()).settings({ prompt: { when: { result: `omitted` } } })
   // Is fine, because at least one parameter is optional.
-  Command.create()
-    .parameter(`a`, s.optional())
+  $.parameter(`a`, s.optional())
     .parameter(`b`, s)
     .settings({ prompt: { when: { result: `omitted` } } })
 })
 
 // TODO should be able match on common event properties _without_ specifying the event type...
-// Command.create().parameter(`a`, s).settings({
+// $.parameter(`a`, s).settings({
 //   prompt: { when: { spec: { name: { aliases: { long: [`a`, `b`] } } } } },
 // })
 
 // TODO already taken care of by match test suite?
 it(`array value`, () => {
   // Can pass ONE literal match
-  Command.create()
-    .parameter(`a`, s)
-    .settings({
-      prompt: { when: { result: `accepted`, spec: { name: { aliases: { long: [`a`, `b`] } } } } },
-    })
+  $.parameter(`a`, s).settings({
+    prompt: { when: { result: `accepted`, spec: { name: { aliases: { long: [`a`, `b`] } } } } },
+  })
   // can pass an OR literal match
-  Command.create()
-    .parameter(`a`, s)
-    .settings({
-      prompt: { when: { result: `accepted`, spec: { name: { aliases: { long: [[`a`, `b`], [`c`]] } } } } },
-    })
-  Command.create()
-    .parameter(`a`, s)
-    .settings({
-      // @ts-expect-error Cannot pass the array member literal
-      prompt: { when: { result: `accepted`, spec: { name: { aliases: { long: `a` } } } } },
-    })
-  Command.create()
-    .parameter(`a`, s)
-    .settings({
-      // @ts-expect-error Cannot mix OR and ONE matches
-      prompt: { when: { result: `accepted`, spec: { name: { aliases: { long: [`a`, [`b`]] } } } } },
-    })
+  $.parameter(`a`, s).settings({
+    prompt: { when: { result: `accepted`, spec: { name: { aliases: { long: [[`a`, `b`], [`c`]] } } } } },
+  })
+  $.parameter(`a`, s).settings({
+    // @ts-expect-error Cannot pass the array member literal
+    prompt: { when: { result: `accepted`, spec: { name: { aliases: { long: `a` } } } } },
+  })
+  $.parameter(`a`, s).settings({
+    // @ts-expect-error Cannot mix OR and ONE matches
+    prompt: { when: { result: `accepted`, spec: { name: { aliases: { long: [`a`, [`b`]] } } } } },
+  })
 })
 
 // TODO
 // it(`static error when fields from different event types matched in single pattern`, () => {
-//   Command.create()
+//   $
 //     .parameter(`a`, s)
 //     // @ts-expect-error "value" is not available on "rejected" event
 //     .settings({ prompt: { when: { result: `rejected`, value: 1 } } })
 //   // TODO excess properties should be an error in the pattern match but for some reason are not being here.
-//   Command.create().parameter(`a`, {
-//     schema: s,
+//   $.parameter(`a`, {
+//     type: s,
 //     prompt: {
 //       when: {
 //         result: `rejected`,
@@ -339,23 +320,23 @@ it(`array value`, () => {
 
 // prettier-ignore
 it(`Static type tests`, () => {
-  expectType<() => { a: 1 }>(Command.create().parameter(`a`, { schema: l1, prompt: null }).parse)
-  expectType<() => { a: 1 }>(Command.create().parameter(`a`, { schema: l1, prompt: undefined }).parse)
-  expectType<() => { a: 1 }>(Command.create().parameter(`a`, { schema: l1, prompt: {enabled:false} }).parse)
-  expectType<() => { a: 1 }>(Command.create().parameter(`a`, { schema: l1, prompt: {enabled:false,when:{result:`accepted`}} }).parse)
-  expectType<() => { a: 1 }>(Command.create().parameter(`a`, { schema: l1 }).parse)
-  expectType<() => { a: 1 }>(Command.create().parameter(`a`, { schema: l1 }).settings({}).parse)
-  expectType<() => { a: 1 }>(Command.create().parameter(`a`, { schema: l1 }).settings({prompt:false}).parse)
-  expectType<() => { a: 1 }>(Command.create().parameter(`a`, { schema: l1 }).settings({prompt:{enabled:false}}).parse)
-  expectType<() => { a: 1 }>(Command.create().parameter(`a`, { schema: l1 }).settings({prompt:{enabled:false,when:{result:`accepted`}}}).parse)
-  expectType<() => Promise<{ a: 1 }>>(Command.create().parameter(`a`, { schema: l1, prompt: true }).parameter(`b`, {schema:l1,prompt:false}).parse)
-  expectType<() => Promise<{ a: 1 }>>(Command.create().parameter(`a`, { schema: l1, prompt: true }).parse)
-  expectType<() => Promise<{ a: 1 }>>(Command.create().parameter(`a`, { schema: l1, prompt: {enabled:true} }).parse)
-  expectType<() => Promise<{ a: 1 }>>(Command.create().parameter(`a`, { schema: l1, prompt: {when:{result:`accepted`}} }).parse)
-  expectType<() => Promise<{ a: 1 }>>(Command.create().parameter(`a`, { schema: l1, prompt: true }).settings({prompt:false}).parse)
-  expectType<() => Promise<{ a: 1 }>>(Command.create().parameter(`a`, { schema: l1 }).settings({prompt:true}).parse)
-  expectType<() => Promise<{ a: 1 }>>(Command.create().parameter(`a`, { schema: l1 }).settings({prompt:{enabled:true}}).parse)
-  expectType<() => Promise<{ a: 1 }>>(Command.create().parameter(`a`, { schema: l1 }).settings({prompt:{when:{result:`accepted`}}}).parse)
+  expectType<() => { a: 1 }>($.parameter(`a`, { type: l1, prompt: null }).parse)
+  expectType<() => { a: 1 }>($.parameter(`a`, { type: l1, prompt: undefined }).parse)
+  expectType<() => { a: 1 }>($.parameter(`a`, { type: l1, prompt: {enabled:false} }).parse)
+  expectType<() => { a: 1 }>($.parameter(`a`, { type: l1, prompt: {enabled:false,when:{result:`accepted`}} }).parse)
+  expectType<() => { a: 1 }>($.parameter(`a`, { type: l1 }).parse)
+  expectType<() => { a: 1 }>($.parameter(`a`, { type: l1 }).settings({}).parse)
+  expectType<() => { a: 1 }>($.parameter(`a`, { type: l1 }).settings({prompt:false}).parse)
+  expectType<() => { a: 1 }>($.parameter(`a`, { type: l1 }).settings({prompt:{enabled:false}}).parse)
+  expectType<() => { a: 1 }>($.parameter(`a`, { type: l1 }).settings({prompt:{enabled:false,when:{result:`accepted`}}}).parse)
+  expectType<() => Promise<{ a: 1 }>>($.parameter(`a`, { type: l1, prompt: true }).parameter(`b`, {type:l1,prompt:false}).parse)
+  expectType<() => Promise<{ a: 1 }>>($.parameter(`a`, { type: l1, prompt: true }).parse)
+  expectType<() => Promise<{ a: 1 }>>($.parameter(`a`, { type: l1, prompt: {enabled:true} }).parse)
+  expectType<() => Promise<{ a: 1 }>>($.parameter(`a`, { type: l1, prompt: {when:{result:`accepted`}} }).parse)
+  expectType<() => Promise<{ a: 1 }>>($.parameter(`a`, { type: l1, prompt: true }).settings({prompt:false}).parse)
+  expectType<() => Promise<{ a: 1 }>>($.parameter(`a`, { type: l1 }).settings({prompt:true}).parse)
+  expectType<() => Promise<{ a: 1 }>>($.parameter(`a`, { type: l1 }).settings({prompt:{enabled:true}}).parse)
+  expectType<() => Promise<{ a: 1 }>>($.parameter(`a`, { type: l1 }).settings({prompt:{when:{result:`accepted`}}}).parse)
 })
 
 /**
@@ -364,19 +345,12 @@ it(`Static type tests`, () => {
  *
  */
 
-const run = async () => {
+const run = async (
+  $: CommandBuilder<BuilderCommandState.SetIsPromptEnabled<BuilderCommandState.BaseEmpty, true>>,
+) => {
   memoryPrompter.answers.add(answers)
   memoryPrompter.script.keyPress.push(...keyPresses)
-  // eslint-disable-next-line
-  const args = await tryCatch(async () => {
-    // eslint-disable-next-line
-    return await Object.entries(parameters)
-      // @ts-expect-error todo
-      .reduce((chain, data) => chain.parameter(data[0] as any, data[1]), Command.create())
-      // @ts-expect-error todo
-      .settings({ onError: `throw`, helpOnError: false, ...settings })
-      .parse({ line, tty: memoryPrompter })
-  })
+  const args = await tryCatch(() => $.parse({ line, tty: memoryPrompter }))
   expect(args).toMatchSnapshot(`args`)
   expect(memoryPrompter.history.all).toMatchSnapshot(`tty`)
   expect(memoryPrompter.history.all.map((_) => stripAnsi(_))).toMatchSnapshot(`tty strip ansi`)
diff --git a/packages/@molt/command/tests/prompt/settings.spec.ts b/packages/@molt/command/tests/prompt/settings.spec.ts
index edcd0a00..0356c53c 100644
--- a/packages/@molt/command/tests/prompt/settings.spec.ts
+++ b/packages/@molt/command/tests/prompt/settings.spec.ts
@@ -1,13 +1,12 @@
+import type { FromZod } from '../../src/extensions/zod/typeAdaptor/types.js'
 import type { Settings } from '../../src/index.js'
-import { Command } from '../../src/index.js'
 import type { Type } from '../../src/Type/index.js'
-import type { TypeAdaptors } from '../../src/TypeAdaptors/index.js'
-import { s, tryCatch } from '../_/helpers.js'
+import { $, s, tryCatch } from '../_/helpers.js'
 import { memoryPrompter } from '../_/mocks/tty.js'
 import stripAnsi from 'strip-ansi'
 import { describe, expect, it } from 'vitest'
 
-const S = <T extends Type.Type>(settings: Settings.InputPrompt<T>) => settings
+const S = <T extends Type.Type>(settings: Settings.PromptInput<T>) => settings
 const foo = [
   { ctrl: false, meta: false, sequence: `f`, shift: false, name: `f` },
   { ctrl: false, meta: false, sequence: `o`, shift: false, name: `o` },
@@ -19,8 +18,7 @@ describe(`parameter level`, () => {
   it(`can be passed object`, async () => {
     memoryPrompter.script.keyPress.push(...foo)
     const args = await tryCatch(() =>
-      Command.create()
-        .parameter(`a`, { schema: s, prompt: { enabled: true } })
+      $.parameter(`a`, { type: s, prompt: { enabled: true } })
         .settings({ onError: `throw`, helpOnError: false })
         .parse({ line: [], tty: memoryPrompter }),
     )
@@ -34,8 +32,7 @@ describe(`command level`, () => {
   it(`passing object makes enabled default to true`, async () => {
     memoryPrompter.script.keyPress.push(...foo)
     // eslint-disable-next-line
-    const args = await Command.create()
-      .parameter(`a`, { schema: s })
+    const args = await $.parameter(`a`, { type: s })
       .settings({ onError: `throw`, helpOnError: false, prompt: { when: { result: `rejected` } } })
       .parse({ line: [], tty: memoryPrompter })
     expect(args).toMatchSnapshot(`args`)
@@ -46,8 +43,7 @@ describe(`command level`, () => {
 
 it(`prompt is disabled by default`, () => {
   const args = tryCatch(() =>
-    Command.create()
-      .parameter(`a`, { schema: s })
+    $.parameter(`a`, { type: s })
       .settings({ onError: `throw`, helpOnError: false })
       .parse({ line: [], tty: memoryPrompter }),
   )
@@ -59,8 +55,7 @@ it(`prompt is disabled by default`, () => {
 it(`prompt can be enabled by default`, async () => {
   memoryPrompter.script.keyPress.push(...foo)
   const args = await tryCatch(() =>
-    Command.create()
-      .parameter(`a`, { schema: s })
+    $.parameter(`a`, { type: s })
       .settings({ onError: `throw`, helpOnError: false, prompt: { enabled: true } })
       .parse({ line: [], tty: memoryPrompter }),
   )
@@ -71,8 +66,7 @@ it(`prompt can be enabled by default`, async () => {
 
 it(`parameter settings overrides default settings`, () => {
   const args = tryCatch(() =>
-    Command.create()
-      .parameter(`a`, { schema: s, prompt: false })
+    $.parameter(`a`, { type: s, prompt: false })
       .settings({ onError: `throw`, helpOnError: false, prompt: { enabled: true } })
       .parse({ line: [], tty: memoryPrompter }),
   )
@@ -83,7 +77,7 @@ it(`parameter settings overrides default settings`, () => {
 
 describe(`prompt can be toggled by check on error`, () => {
   describe(`toggle to enabled`, () => {
-    const settings = S<TypeAdaptors.Zod.FromZod<typeof s>>({
+    const settings = S<FromZod<typeof s>>({
       enabled: true,
       when: { result: `rejected`, error: `ErrorMissingArgument`, spec: { name: { canonical: `a` } } },
     })
@@ -91,8 +85,7 @@ describe(`prompt can be toggled by check on error`, () => {
       memoryPrompter.script.keyPress.push(...foo)
       // eslint-disable-next-line
       const args = await tryCatch(() =>
-        Command.create()
-          .parameter(`a`, { schema: s })
+        $.parameter(`a`, { type: s })
           .settings({ onError: `throw`, helpOnError: false, prompt: settings })
           .parse({ line: [], tty: memoryPrompter }),
       )
@@ -102,8 +95,7 @@ describe(`prompt can be toggled by check on error`, () => {
     })
     it(`check does not match`, () => {
       const args = tryCatch(() =>
-        Command.create()
-          .parameter(`b`, { schema: s })
+        $.parameter(`b`, { type: s })
           .settings({ onError: `throw`, helpOnError: false, prompt: settings })
           .parse({ line: [], tty: memoryPrompter }),
       )
@@ -117,8 +109,7 @@ describe(`prompt can be toggled by check on error`, () => {
 it(`parameter defaults to custom settings`, async () => {
   memoryPrompter.script.keyPress.push(...foo)
   const args = await tryCatch(() =>
-    Command.create()
-      .parameter(`a`, { schema: s })
+    $.parameter(`a`, { type: s })
       .settings({
         onError: `throw`,
         helpOnError: false,
@@ -155,8 +146,7 @@ it(`can be stack of conditional prompts`, async () => {
   memoryPrompter.script.keyPress.push(...foo)
   // eslint-disable-next-line
   const args = await tryCatch(() =>
-    Command.create()
-      .parameter(`a`, { schema: s.optional() })
+    $.parameter(`a`, { type: s.optional() })
       .settings({ onError: `throw`, helpOnError: false, prompt: settings })
       .parse({ line: [`-a`, `1`], tty: memoryPrompter }),
   )
diff --git a/scripts/release.ts b/scripts/release.ts
index 40e491e6..09a49194 100644
--- a/scripts/release.ts
+++ b/scripts/release.ts
@@ -1,3 +1,4 @@
+import { Zod } from '../packages/@molt/command/src/_entrypoints/extensions.js'
 import { Command } from '../packages/@molt/command/src/index.js'
 import { Octokit } from '@octokit/core'
 import { Alge } from 'alge'
@@ -11,6 +12,7 @@ import { z } from 'zod'
 
 // prettier-ignore
 const args = Command.create()
+  .use(Zod)
   .parameter(`githubToken`, z.string())
   .parameter(`publish`, z.boolean().default(true))
   .parameter(`githubRelease`, z.boolean().default(true))