@systemfsoftware/effect-cell-types 3.0.0 → 5.0.0

package/CHANGELOG.md

@@ -1,5 +1,86 @@
 # @systemfsoftware/effect-cell-types
 
+## 5.0.0
+
+### Major Changes
+
+- A phase can no longer require a service. `Phases` drops `readContext` and
+  `writeContext`, and a read or write phase must return an effect whose context is
+  `never`.
+
+  Those two members were a claim about what a phase needed that nothing
+  recomputed. Whenever the surrounding stage was generic over `Phases`, the
+  compiler could not see through the type parameter to what the phase body
+  actually reached for, so declaring `never` for a body requiring four services
+  was accepted. The description then compiled clean and the missing service
+  surfaced only wherever it was finally applied, or nowhere at all.
+
+  Services now arrive the same way a phase's other inputs already do: as
+  parameters. Resolve them where you build the description, take them as an
+  argument, and provide them to the phase's own effect with
+  `Effect.provideContext`. Both mistakes that used to pass now fail — claiming
+  less than the body needs leaves the phase's context wider than `never`, which
+  the phase type rejects, and claiming more than it needs widens the requirement
+  of whoever builds the description, which surfaces where that builder is run.
+
+  `apply` therefore derives a context of `never` for every description, and a
+  caller can no longer be handed a requirement it never agreed to.
+
+- The wire surface is now the seven symbols it always claimed to be: the mark,
+  the minted types, `mint`, `Fields` and `wire`. Fifteen convenience wrappers
+  around the schema library are gone. A member you built with a wrapper decodes
+  to exactly what it decoded to before; only the spelling changed.
+
+  To migrate, wrap the schema library member in `mint` where you used a wrapper:
+
+  - `string`, `number`, `boolean`, `integer` → `mint(S.String)`,
+    `mint(S.Finite)`, `mint(S.Boolean)`, `mint(S.Int)`
+  - `literal(...v)` → `mint(S.Literals([...v]))`; `union(...m)` →
+    `mint(S.Union([...m]))`; `tuple(...t)` → `mint(S.Tuple([...t]))`
+  - `nullOr(m)` / `undefinedOr(m)` / `nullishOr(m)` / `array(m)` /
+    `optional(m)` / `record(k, v)` / `suspend(t)` → the same letter under
+    `mint`, e.g. `mint(S.NullOr(m))`, `mint(S.Array(m))`, `mint(S.Record(k, v))`
+  - `refine(m, predicate)` → `mint(S.refine(predicate)(m))`
+
+### Minor Changes
+
+- A write phase now receives what its own layer's read gathered, as a second
+  argument after the encoded output.
+
+  This is for the common shape where a write persists or reports on what the read
+  found while the decision in between narrowed to what it needed. Until now such a
+  write had no channel for that value, so the layer had to keep it in a mutable
+  binding beside the description — assigned during the read, read back during the
+  write — and then guard at runtime against a value that was in fact always there.
+  The argument replaces that binding and the guard with it.
+
+  Writes that do not want the value are unchanged: a write declaring a single
+  parameter still satisfies the phase type, so nothing you have already written
+  needs to move.
+
+## 4.0.0
+
+### Major Changes
+
+- `Workflow.make` now takes two arguments: the command's schema class first, the decider second.
+
+  To migrate, declare the command as a `Schema.Class` or `Schema.TaggedClass` and pass it first. The decider's parameter type is inferred from that class, so its annotation can be dropped. A plain interface, a type alias, an object literal, a `Schema.Struct` and a primitive are all refused at the command position — an interface produces no value to pass, and the others are not schema classes.
+
+  The decider's own contract is unchanged: it still returns a `Result`, and a decision channel of `never`, an error channel of `never`, or an error channel carrying no tag are refused as before.
+
+- `Tagged` no longer ships in the `Workflow` namespace.
+
+  The requirement it expressed is unchanged: a decision error must still carry a tag the consumer can
+  dispatch on, and `UntaggedError` still names the failure when one does not. Replace an annotation
+  that referred to `Workflow.Tagged` with the concrete error type, or with a `Schema.TaggedError`
+  class, which satisfies the channel directly.
+
+### Patch Changes
+
+- The peer requirements for `effect` and for the Effect test-runner integration now accept any compatible `4.0.0-rc` release, instead of demanding one exact release candidate.
+
+  Installing alongside a newer release candidate no longer reports an unmet peer dependency or resolves a second copy of `effect` into the dependency tree.
+
 ## 3.0.0
 
 ### Major Changes

package/README.md

@@ -23,22 +23,28 @@ can satisfy, so the mistake is a compile error with the remediation attached (be
 
 ## The constructor
 
-Executors build a workflow from a plain decider with `make` — runtime identity, one cast across the branded return:
+Executors build a workflow from the command's schema class and a decider over that class — runtime identity, one assertion across the branded return:
 
 ```ts
 import { make } from '@systemfsoftware/effect-cell-types'
 import { Result } from 'effect'
+import * as S from 'effect/Schema'
+
+export class DecideInput extends S.Class<DecideInput>('DecideInput')({
+  exitSuccess: S.Boolean,
+}) {}
 
-export const decide = make<DecideInput, RestartDecision, RestartDecisionExhausted>(
-  (
-    input,
-  ) => (input.exitSuccess
+export const decide = make(
+  DecideInput,
+  (input) => (input.exitSuccess
     ? Result.succeed(new RestartDecisionContinue())
     : Result.fail(new RestartDecisionExhausted())),
 )
 ```
 
-The parameter is the plain function type, not `Workflow<C, D, E>`: the `never`-channel conditional lives on the **return** type, so a total decision (`Result<Decision, never>`) resolves to `UninhabitedError` and the call site fails with "This expression is not callable", while a `Promise`- or bare-value-returning decider is rejected at the argument. `make` is a runtime value, so consumers need it as an ordinary import only where they construct workflows; everywhere else `import type` still erases at compile time.
+The command is constrained on the **value**, not on a type parameter inferred from the decider's parameter, and that is the whole mechanism. A constraint on such a parameter is a structural predicate, and TypeScript cannot express "this type came from a class declaration" — so a marker placed there is just a property, and `interface Fake extends Marker {}` satisfies it. A declared type produces no value, so it cannot reach an argument position at all: an interface at the command position is refused with "only refers to a type, but is being used as a value here". `Schema.Class` and `Schema.TaggedClass` are both accepted; a `Schema.Struct`, a plain class, an object literal and a primitive are each refused.
+
+No type argument needs writing: the command type comes from the class, so the decider's parameter needs no annotation. The `never`-channel conditional still lives on the **return** type, so a total decision (`Result<Decision, never>`) resolves to `UninhabitedError` and the call site fails with "This expression is not callable", while a `Promise`- or bare-value-returning decider is rejected at the argument. `make` is a runtime value, so consumers need it as an ordinary import only where they construct workflows; everywhere else `import type` still erases at compile time.
 
 ## Worked example
 
@@ -92,7 +98,8 @@ const restartIndicesFor = (
   )
 
 export const decideRestart = Workflow.make(
-  (input: DecideInput): Result.Result<
+  DecideInput,
+  (input): Result.Result<
     RestartDecisionContinue | RestartDecisionRestart,
     RestartDecisionExhausted
   > =>
@@ -113,25 +120,28 @@ export const decideRestart = Workflow.make(
 )
 ```
 
-The shape to copy: one exported decision built by `Workflow.make`, whose body returns
-`Result` values via `Result.succeed` and `Result.fail`. The constructor infers the channels
-from the annotated return and is the only door to the `WorkflowBrand` conjunct — annotating
-a function `Workflow<…>` directly is now refused wherever the brand is demanded, because a
-workflow that never passed through `make` is not a decision anything may run. The error
-channel is a real variant (`RestartDecisionExhausted`) — giving up is a decision the caller
-must branch on, so declaring the error channel `never` is rejected, not allowed.
+The shape to copy: one exported decision built by `Workflow.make`, taking the command's
+schema class and a decider over that class, whose body returns `Result` values via
+`Result.succeed` and `Result.fail`. The command channel comes from the class, the decision
+and error channels are inferred from the annotated return, and `make` is the only door to
+the `WorkflowBrand` conjunct — annotating a function `Workflow<…>` directly is still refused
+wherever the brand is demanded, because a workflow that never passed through `make` is not a
+decision anything may run. The error channel is a real variant (`RestartDecisionExhausted`) —
+giving up is a decision the caller must branch on, so declaring the error channel `never` is
+rejected, not allowed.
 
 ## What it rejects at compile time
 
-All five violations fail `tsc`; the messages below are what `tsc` reports (verified against this package and `effect@4.0.0-rc.108`).
+All six violations fail `tsc`; the messages below are what `tsc` reports (verified against this package and `effect@4.0.0-rc.108`).
 
-| Violation                              | `tsc` reports                                                                             | Why it is rejected                                                                                                         |
-| -------------------------------------- | ----------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
-| A `Promise` return                     | `Type 'Promise<Decision>' is not assignable to type 'Result<Decision, Err>'`              | a workflow is a synchronous pure decision; async work belongs in the executor shell around it                              |
-| An `Effect` return                     | `Type 'Effect<Decision, never, never>' is not assignable to type 'Result<Decision, Err>'` | the workflow returns a value, not an effect handle; the executor runs effects and hands the workflow its input             |
-| `never` decision channel               | `Type '...' is not assignable to type 'UninhabitedDecision'`                              | a workflow that can never produce a decision can never succeed                                                             |
-| `never` error channel                  | `Type '...' is not assignable to type 'UninhabitedError'`                                 | a workflow that cannot fail decides nothing; move it to a `*.kernel.ts`                                                    |
-| A bare decider handed to `Cell.decide` | `Type '(command: Cmd) => Result<Dec, Err>' is not assignable to type 'WorkflowBrand'`     | only a `Workflow.make` value satisfies `DecidePhase`; a lambda that skipped `make` is not a decision a description may run |
+| Violation                                 | `tsc` reports                                                                             | Why it is rejected                                                                                                         |
+| ----------------------------------------- | ----------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
+| A `Promise` return                        | `Type 'Promise<Decision>' is not assignable to type 'Result<Decision, Err>'`              | a workflow is a synchronous pure decision; async work belongs in the executor shell around it                              |
+| An `Effect` return                        | `Type 'Effect<Decision, never, never>' is not assignable to type 'Result<Decision, Err>'` | the workflow returns a value, not an effect handle; the executor runs effects and hands the workflow its input             |
+| `never` decision channel                  | `Type '...' is not assignable to type 'UninhabitedDecision'`                              | a workflow that can never produce a decision can never succeed                                                             |
+| `never` error channel                     | `Type '...' is not assignable to type 'UninhabitedError'`                                 | a workflow that cannot fail decides nothing; move it to a `*.kernel.ts`                                                    |
+| A bare decider handed to `Cell.decide`    | `Type '(command: Cmd) => Result<Dec, Err>' is not assignable to type 'WorkflowBrand'`     | only a `Workflow.make` value satisfies `DecidePhase`; a lambda that skipped `make` is not a decision a description may run |
+| A plain interface at the command position | `'Cmd' only refers to a type, but is being used as a value here`                          | the command is constrained on the value, and a declared type produces none — so there is no marker to smuggle              |
 
 The two `never` cases are where the content-vs-filename distinction pays off. `Workflow<C, never, E>` resolves to `UninhabitedDecision` and `Workflow<C, D, never>` to `UninhabitedError` — interfaces whose only property is required and whose _type_ is the remediation, so the compile error points at the fix:
 
@@ -159,17 +169,17 @@ the outcome once:
 import { Workflow } from '@systemfsoftware/effect-cell-types'
 import { Result } from 'effect'
 import * as Match from 'effect/Match'
+import * as S from 'effect/Schema'
 
 class Decision {}
 class Err {
   constructor(readonly reason: string) {}
 }
-interface Input {
-  readonly valid: boolean
-}
+class Input extends S.Class<Input>('Input')({ valid: S.Boolean }) {}
 
 const decide = Workflow.make(
-  (input: Input): Result.Result<Decision, Err> =>
+  Input,
+  (input): Result.Result<Decision, Err> =>
     Result.gen(function*() {
       const outcome = Match.value(input).pipe(
         Match.when({ valid: false }, () => Result.fail(new Err('invalid input'))),
@@ -192,7 +202,8 @@ type — so an unreachable error channel is rejected rather than silently allowe
 
 ```ts
 const decide = Workflow.make(
-  (input: Input): Result.Result<Decision, Err> =>
+  Input,
+  (input): Result.Result<Decision, Err> =>
     Result.gen(function*() {
       return new Decision()
     }),

package/dist/index.d.ts

@@ -2,9 +2,10 @@ import * as Effect$1 from "effect/Effect";
 import { Effect } from "effect/Effect";
 import * as Result$1 from "effect/Result";
 import { Result } from "effect/Result";
-import { Schema, SchemaAST } from "effect";
+import * as Schema$1 from "effect/Schema";
+import { Schema } from "effect";
 declare namespace Workflow_d_exports {
-  export { Inhabited, Tagged, UninhabitedDecision, UninhabitedError, UntaggedError, Workflow, WorkflowBrand, make };
+  export { Inhabited, UninhabitedDecision, UninhabitedError, UntaggedError, Workflow, WorkflowBrand, make };
 }
 /**
  * The nominal brand a workflow carries. `Workflow.make` is the only door that applies it,
@@ -40,10 +41,6 @@ interface UninhabitedError {
 interface UntaggedError {
   readonly __WORKFLOW_ERROR_CHANNEL_CARRIES_NO_TAG__: 'this error carries no _tag the consumer can dispatch on; declare it as an S.TaggedError';
 }
-/** The shape an error channel must have: a tag the consumer dispatches on. */
-interface Tagged {
-  readonly _tag: string;
-}
 /**
  * A decider whose channels are both inhabited, or the marker naming which channel is not.
  *
@@ -56,15 +53,48 @@ interface Tagged {
  */
 type Workflow<Command, Decision, DecisionError> = [Decision] extends [never] ? UninhabitedDecision : [DecisionError] extends [never] ? UninhabitedError : ((command: Command) => Result<Decision, DecisionError>) & WorkflowBrand;
 /**
- * `unknown` when both channels are inhabited and the error carries a tag, so the intersection in
- * {@link make} collapses to the plain `Result` and neither inference nor the authoring surface
- * changes. Otherwise the marker the author must satisfy, which they cannot, which is the point.
+ * `unknown` when the error channel carries a tag a consumer can dispatch on, the {@link UntaggedError}
+ * marker otherwise. Two steps, both load-bearing: `'_tag' extends keyof E` asks whether the key is
+ * there, and `[E['_tag']] extends [string]` asks whether what it holds is dispatchable. Key presence
+ * alone admits `_tag: number`, `_tag?: string` and a `_tag()` method — none of which `Match.tag` can
+ * dispatch on, which is exactly what the marker claims to refuse.
+ *
+ * Both steps read the tag through `keyof` and an indexed access rather than declaring a `_tag`
+ * member, which is why the erased `Tagged` interface cannot come back: stating the requirement as a
+ * shape would write the very member this repo forbids.
+ */
+type DispatchableTag<E> = '_tag' extends keyof E ? [E['_tag']] extends [string] ? unknown : UntaggedError : UntaggedError;
+/**
+ * `unknown` when both channels are inhabited and the error carries a dispatchable tag, so the
+ * intersection in {@link make} collapses to the plain `Result` and neither inference nor the
+ * authoring surface changes. Otherwise the marker the author must satisfy, which they cannot, which
+ * is the point.
  */
-type Inhabited<Decision, DecisionError> = [Decision] extends [never] ? UninhabitedDecision : [DecisionError] extends [never] ? UninhabitedError : [DecisionError] extends [Tagged] ? unknown : UntaggedError;
+type Inhabited<Decision, DecisionError> = [Decision] extends [never] ? UninhabitedDecision : [DecisionError] extends [never] ? UninhabitedError : DispatchableTag<DecisionError>;
 /**
- * Builds a workflow, refusing an uninhabited or untagged channel at this call rather than at
+ * Builds a workflow from the command's schema class and a decider over that class's
+ * instance type, refusing an uninhabited or untagged channel at this call rather than at
  * whoever first calls the result — which for a workflow nothing calls yet is never.
  *
+ * The command is constrained on the **value**, not on a type parameter inferred from the
+ * decider's parameter. That is the whole mechanism. Any constraint on such a parameter is a
+ * structural predicate, and TypeScript cannot say "this type came from a class declaration"
+ * — so a marker placed there is a property, every property is declarable, and
+ * `interface Fake extends Marker {}` satisfies it. A declared type produces no value, so it
+ * cannot reach an argument position at all: there is no marker to smuggle because there is
+ * no marker.
+ *
+ * The three parameters mirror `Schema.Class`'s own bound exactly, and that is load-bearing.
+ * `Class<Self, S, Inherited>` places `S` in both covariant (`S["Type"]`) and contravariant
+ * (`S["fields"]`) positions, so it is invariant in `S`: every *fixed* spelling —
+ * `Class<unknown, Struct<Struct.Fields>, unknown>` and its variants — rejects real command
+ * classes. Generic over `S` accepts them and still refuses a `Struct`, which lacks
+ * `identifier` and `extend`. `Class<any, any, any>` also works and is banned here.
+ *
+ * `Schema.TaggedClass` returns this same `Class` interface, so one constraint covers both
+ * factories with no union. The import is type-only: this package gains no runtime dependency
+ * on Effect Schema, and `make` stays the identity function it always was.
+ *
  * The markers ride the parameter function's return type, not the parameter as `Workflow<C, D, E>`:
  * a conditional type in parameter position resolves `D` and `E` to `unknown` and the markers become
  * unreachable. On the return type both still infer from the `Result` conjunct while the marker
@@ -78,13 +108,28 @@ type Inhabited<Decision, DecisionError> = [Decision] extends [never] ? Uninhabit
  * The narrowing goes through an assertion signature rather than an `as` cast: every narrowing
  * assertion trips `typescript(no-unsafe-type-assertion)`, and a suppression comment would hide the
  * one place this file could lie. It is sound rather than merely permitted — with both channels
- * inhabited `Workflow<C, D, E>` is `(command: C) => Result<D, E>` carrying the {@link WorkflowBrand}
- * conjunct, and otherwise the return type is a marker with no call signature, so the value handed
- * back is unobservable through it. The brand is applied here and nowhere else: the assertion adds
- * no runtime property, so `make` stays the identity function it always was, yet a value that did
- * not pass through this door fails the conjunct wherever a decision is run.
+ * inhabited `Workflow<Self, D, E>` is `(command: Self) => Result<D, E>` carrying the
+ * {@link WorkflowBrand} conjunct, and otherwise the return type is a marker with no call
+ * signature, so the value handed back is unobservable through it. The brand is applied here and
+ * nowhere else: the assertion adds no runtime property, yet a value that did not pass through this
+ * door fails the conjunct wherever a decision is run.
+ */
+declare const make: <Self, S extends Schema$1.Constraint & {
+  readonly fields: Schema$1.Struct.Fields;
+}, Inherited, D, E>(_command: Schema$1.Class<Self, S, Inherited>, decide: (command: Self) => Result<D, E> & Inhabited<D, E>) => Workflow<Self, D, E>;
+//#endregion
+//#region src/CanonicalDecide.workflow.d.ts
+declare const CanonicalCommand_base: Schema$1.Class<CanonicalCommand, Schema$1.TaggedStruct<"CanonicalCommand", {}>, {}>;
+/**
+ * The canonical command. `Workflow.make` constrains its first argument to a real
+ * schema class, so the canonical description needs one too — it carries no fields
+ * because the canonical's phases do nothing, and its only job is to be a genuine
+ * command value rather than a shape asserted into place.
+ *
+ * It is declared here rather than in a `*.schema.ts` because this is the owning
+ * single-segment `<stem>.workflow.ts`, which `schema-declaration-location` admits.
  */
-declare const make: <C, D, E>(decide: (command: C) => Result<D, E> & Inhabited<D, E>) => Workflow<C, D, E>;
+declare class CanonicalCommand extends CanonicalCommand_base {}
 declare namespace Cell_d_exports {
   export { Convention, DESCRIPTION_MODULE, DecideDone, DecideNode, DecidePhase, DecodeDone, DecodeNode, DecodePhase, Description, EncodeDone, EncodeNode, EncodePhase, IO_CELLS, IoCellClassification, Layer, Phase, PhaseFact, Phases, ReadDone, ReadNode, ReadPhase, Vocabulary, WriteDone, WriteNode, WritePhase, apply, canonical, decide, decode, encode, read, vocabulary, write };
 }
@@ -107,16 +152,23 @@ interface Phases {
   readonly decodeError: unknown;
   readonly readError: unknown;
   readonly writeError: unknown;
-  readonly readContext: unknown;
-  readonly writeContext: unknown;
 }
 /**
  * A read gathers what the decision needs, and may gather a product across its interior;
  * that interior is not type-visible, so no I/O count is claimed or enforced here. A step that
  * mutates in order to report — bumping a counter and returning the resulting rate — is one
  * such product, and belongs here rather than in a layer of its own.
+ *
+ * The context channel is pinned `never`: a phase requires nothing. Services are resolved by
+ * whoever builds the description and handed to the phase as ordinary parameters, which is
+ * the same edge that already gathers the read's inputs. The alternative — a `readContext`
+ * member on the bag — let an author write `never` for a body that reaches for a service, and
+ * nothing checked the claim: under a stage generic over `Phases` the compiler cannot see the
+ * lambda's requirement at all, so the description compiled and the missing service surfaced
+ * only where it was finally applied, or nowhere. Pinning it makes the lie unrepresentable
+ * instead of merely discouraged, and leaves `apply`'s derived `R` honestly `never`.
  */
-type ReadPhase<P extends Phases> = (command: P['command']) => Effect$1.Effect<P['raw'], P['readError'], P['readContext']>;
+type ReadPhase<P extends Phases> = (command: P['command']) => Effect$1.Effect<P['raw'], P['readError'], never>;
 /** Validation. Its `Left` is fatal: it reaches the derived error channel and no write runs. */
 type DecodePhase<P extends Phases> = (raw: P['raw']) => Result$1.Result<P['decoded'], P['decodeError']>;
 /**
@@ -131,7 +183,19 @@ type DecodePhase<P extends Phases> = (raw: P['raw']) => Result$1.Result<P['decod
 type DecidePhase<P extends Phases> = ((decoded: P['decoded']) => Result$1.Result<P['decision'], P['decisionError']>) & WorkflowBrand;
 /** Shapes what the write consumes. Total, so it receives both branches of the decision. */
 type EncodePhase<P extends Phases> = (outcome: Result$1.Result<P['decision'], P['decisionError']>) => P['output'];
-type WritePhase<P extends Phases> = (output: P['output']) => Effect$1.Effect<P['response'], P['writeError'], P['writeContext']>;
+/**
+ * The write. It receives the encoded `output` and, as a second argument, the `raw` its own
+ * layer's read gathered.
+ *
+ * `raw` is there because a write is frequently the point that persists or reports what the
+ * read found, while the decision in between deliberately narrows to what it needed. Without
+ * this argument such a write has no channel for it and the layer smuggles the value through
+ * a closure — a `let` beside the description, assigned in the read and consulted in the
+ * write, which then needs a runtime guard for a value the fold has already produced. The
+ * argument is second, and a write that does not want it declares one parameter: a unary
+ * function satisfies this type, so every write written before it existed is unchanged.
+ */
+type WritePhase<P extends Phases> = (output: P['output'], raw: P['raw']) => Effect$1.Effect<P['response'], P['writeError'], never>;
 /**
  * The invocation shape a folding consumer must use to call a phase's `run`:
  * - `'effect'` — `run` returns an `Effect`; yield it. (read, write)
@@ -305,7 +369,7 @@ declare const write: {
  * description's response is the last layer's. No scope is opened and interruptibility is
  * untouched, so a `Scope.Scope` a phase requires reaches the caller as part of the derived `R`.
  */
-declare const apply: <P extends Phases>(description: WriteDone<P>, command: P['command']) => Effect$1.Effect<P["response"], P["decodeError"] | P["readError"] | P["writeError"], P["readContext"] | P["writeContext"]>;
+declare const apply: <P extends Phases>(description: WriteDone<P>, command: P['command']) => Effect$1.Effect<P["response"], P["decodeError"] | P["readError"] | P["writeError"], never>;
 /** One phase's vocabulary entry: what it is called, its purity, its invocation shape. */
 interface PhaseFact {
   readonly name: Phase<Phases>['name'];
@@ -333,6 +397,16 @@ interface Vocabulary {
    */
   readonly applier: 'apply';
 }
+/**
+ * The bag the canonical description is built with. It is `Phases` with one member
+ * pinned: `decoded` is the canonical command class, because `canonicalDecide` is a
+ * decider over that class and a decider's parameter is contravariant — a phase typed
+ * `(decoded: unknown) => …` would demand that `unknown` be assignable to the command,
+ * which it is not. Every other member stays `unknown`, so nothing else narrows.
+ */
+interface CanonicalPhases extends Phases {
+  readonly decoded: CanonicalCommand;
+}
 /**
  * A canonical description, built through the public constructors with phases that do
  * nothing. It is exported so a consumer — a generator, a lint rule, a documenter — can
@@ -345,20 +419,20 @@ interface Vocabulary {
  * any other sequence fails to typecheck here — which is what keeps the derived order
  * non-circular: it is read off a value, and the value's shape is enforced by the types.
  */
-declare const canonical: WriteDone<Phases>;
+declare const canonical: WriteDone<CanonicalPhases>;
 declare const vocabulary: Vocabulary;
 declare namespace Policy_d_exports {
   export { Policy };
 }
 type Policy<A, E, R> = (self: Effect<A, E, R>) => Effect<A, E, R>;
 declare namespace Wire_d_exports {
-  export { AnyMinted, Fields, Mark, Minted, MintedField, array, boolean, integer, literal, mint, nullOr, nullishOr, number, optional, record, refine, string, suspend, tuple, undefinedOr, union, wire };
+  export { AnyMinted, Fields, Mark, Minted, MintedField, mint, wire };
 }
 /**
  * Marker a wire member carries once this workspace declares its type. The property type is the
  * fix, so the compiler diagnostic names it.
  *
- * It sits on the schema, never on the decoded value: `Schema.Type<typeof Wire.string>` is `string`.
+ * It sits on the schema, never on the decoded value: `Schema.Type<typeof Wire.mint(S.String)>` is `string`.
  */
 interface Mark {
   readonly __WIRE_MEMBER_IS_NOT_BUILT_FROM_THE_ALPHABET__: 'this member names a type this workspace does not declare; build it from Wire, or admit a foreign schema deliberately with Wire.mint';
@@ -372,8 +446,7 @@ type Minted<A, I = A> = Schema.Codec<A, I> & Mark;
 /** Any marked schema, for constraint positions. */
 type AnyMinted = Schema.Top & Mark;
 /**
- * Any marked struct member — a schema, or a property signature from {@link optional}.
- *
+ * Any marked struct member — a schema, or a property signature from `S.optional`.
  * The permissive `Constraint` arm rather than a narrower schema type, whose `never` variants
  * would fail the assignability check before the marker is reached, leaving the diagnostic to
  * report an unrelated type error.
@@ -382,37 +455,11 @@ type MintedField = Schema.Constraint & Mark;
 /**
  * Mark a member whose type this workspace declares.
  *
- * Prefer the alphabet below; reach for this only to admit a schema the alphabet cannot express,
- * including a vendor's own. The value returned is the one passed in, and its concrete type is
- * preserved, so a marked struct stays a struct and Effect's inference keeps working.
+ * The value returned is the one passed in, and its concrete type is preserved, so a marked
+ * struct stays a struct and Effect's inference keeps working. Reach for it to admit anything
+ * the schema library can express, including a vendor's own schema — deliberately.
  */
 declare const mint: <Field extends Schema.Constraint>(field: Field) => Field & Mark;
-declare const string: Schema.String & Mark;
-declare const number: Schema.Finite & Mark;
-declare const boolean: Schema.Boolean & Mark;
-declare const integer: Schema.Int & Mark;
-declare const literal: <const Literals extends ReadonlyArray<SchemaAST.LiteralValue>>(...literals: Literals) => Schema.Literals<Literals> & Mark;
-declare const nullOr: <A, I>(member: Minted<A, I>) => Minted<A | null, I | null>;
-declare const undefinedOr: <A, I>(member: Minted<A, I>) => Minted<A | undefined, I | undefined>;
-declare const nullishOr: <A, I>(member: Minted<A, I>) => Minted<A | null | undefined, I | null | undefined>;
-declare const array: <A, I>(member: Minted<A, I>) => Minted<ReadonlyArray<A>, ReadonlyArray<I>>;
-/** A field that may be absent from the payload entirely, as distinct from present and `undefined`. */
-declare const optional: <Member extends AnyMinted>(member: Member) => Schema.optional<Member> & Mark;
-declare const record: <K extends Schema.Record.Key & Mark, V extends AnyMinted>(key: K, value: V) => Schema.$Record<K, V> & Mark;
-declare const union: <Members extends readonly [AnyMinted, AnyMinted, ...Array<AnyMinted>]>(...members: Members) => Schema.Union<Members> & Mark;
-declare const tuple: <Elements extends ReadonlyArray<AnyMinted>>(...elements: Elements) => Schema.Tuple<Elements> & Mark;
-declare const suspend: <A, I>(thunk: () => Minted<A, I>) => Minted<A, I>;
-/**
- * Constrain a member's values. Effect's own `member.pipe(Schema.check(Schema.isMinLength(1)))`
- * preserves the mark, but returns the schema with the concrete decode/encode pair fused; this
- * combinator is the alphabet's own shape for the same operation, so a refined member keeps the
- * declaration this workspace makes of its type.
- *
- * `S.refine` needs a type-guard as its predicate argument; the workspace's predicate is a plain
- * `(a: A) => boolean` that narrows nothing, so a truth-preserving `value is A` guard is written
- * at this one call site rather than widening the public signature.
- */
-declare const refine: <A, I>(member: Minted<A, I>, predicate: (a: A) => boolean, annotations?: Schema.Annotations.Filter) => Minted<A, I>;
 type Fields = Record<string, MintedField>;
 declare const wire: <F extends Fields>(fields: F) => Schema.Struct<F> & Mark;
 //#endregion

package/dist/index.mjs

@@ -4,13 +4,36 @@ import * as Effect$1 from "effect/Effect";
 import { dual } from "effect/Function";
 import * as Option from "effect/Option";
 import * as Result$1 from "effect/Result";
+import * as S from "effect/Schema";
 import { Schema } from "effect";
+S.TaggedError()("CanonicalDecideError", {});
+//#endregion
 //#region src/Workflow.ts
 var Workflow_exports = /* @__PURE__ */ __exportAll({ make: () => make });
 /**
-* Builds a workflow, refusing an uninhabited or untagged channel at this call rather than at
+* Builds a workflow from the command's schema class and a decider over that class's
+* instance type, refusing an uninhabited or untagged channel at this call rather than at
 * whoever first calls the result — which for a workflow nothing calls yet is never.
 *
+* The command is constrained on the **value**, not on a type parameter inferred from the
+* decider's parameter. That is the whole mechanism. Any constraint on such a parameter is a
+* structural predicate, and TypeScript cannot say "this type came from a class declaration"
+* — so a marker placed there is a property, every property is declarable, and
+* `interface Fake extends Marker {}` satisfies it. A declared type produces no value, so it
+* cannot reach an argument position at all: there is no marker to smuggle because there is
+* no marker.
+*
+* The three parameters mirror `Schema.Class`'s own bound exactly, and that is load-bearing.
+* `Class<Self, S, Inherited>` places `S` in both covariant (`S["Type"]`) and contravariant
+* (`S["fields"]`) positions, so it is invariant in `S`: every *fixed* spelling —
+* `Class<unknown, Struct<Struct.Fields>, unknown>` and its variants — rejects real command
+* classes. Generic over `S` accepts them and still refuses a `Struct`, which lacks
+* `identifier` and `extend`. `Class<any, any, any>` also works and is banned here.
+*
+* `Schema.TaggedClass` returns this same `Class` interface, so one constraint covers both
+* factories with no union. The import is type-only: this package gains no runtime dependency
+* on Effect Schema, and `make` stays the identity function it always was.
+*
 * The markers ride the parameter function's return type, not the parameter as `Workflow<C, D, E>`:
 * a conditional type in parameter position resolves `D` and `E` to `unknown` and the markers become
 * unreachable. On the return type both still infer from the `Result` conjunct while the marker
@@ -24,24 +47,34 @@ var Workflow_exports = /* @__PURE__ */ __exportAll({ make: () => make });
 * The narrowing goes through an assertion signature rather than an `as` cast: every narrowing
 * assertion trips `typescript(no-unsafe-type-assertion)`, and a suppression comment would hide the
 * one place this file could lie. It is sound rather than merely permitted — with both channels
-* inhabited `Workflow<C, D, E>` is `(command: C) => Result<D, E>` carrying the {@link WorkflowBrand}
-* conjunct, and otherwise the return type is a marker with no call signature, so the value handed
-* back is unobservable through it. The brand is applied here and nowhere else: the assertion adds
-* no runtime property, so `make` stays the identity function it always was, yet a value that did
-* not pass through this door fails the conjunct wherever a decision is run.
+* inhabited `Workflow<Self, D, E>` is `(command: Self) => Result<D, E>` carrying the
+* {@link WorkflowBrand} conjunct, and otherwise the return type is a marker with no call
+* signature, so the value handed back is unobservable through it. The brand is applied here and
+* nowhere else: the assertion adds no runtime property, yet a value that did not pass through this
+* door fails the conjunct wherever a decision is run.
 */
-const make = (decide) => {
+const make = (_command, decide) => {
 	return decide;
 };
 //#endregion
 //#region src/CanonicalDecide.workflow.ts
 /**
+* The canonical command. `Workflow.make` constrains its first argument to a real
+* schema class, so the canonical description needs one too — it carries no fields
+* because the canonical's phases do nothing, and its only job is to be a genuine
+* command value rather than a shape asserted into place.
+*
+* It is declared here rather than in a `*.schema.ts` because this is the owning
+* single-segment `<stem>.workflow.ts`, which `schema-declaration-location` admits.
+*/
+var CanonicalCommand = class extends S.TaggedClass()("CanonicalCommand", {}) {};
+/**
 * The canonical decider. Extracted so `make-file-location` only sees it inside a
 * single-segment `.workflow.ts` file, satisfying the restored taxonomy while
 * preserving the exact phantom-channel contract the `DecidePhase` brand and
 * the interpreter rely on.
 */
-const canonicalDecide = make((_decoded) => Result$1.succeed(void 0));
+const canonicalDecide = make(CanonicalCommand, (_command) => Result$1.succeed(void 0));
 //#endregion
 //#region src/Cell.ts
 var Cell_exports = /* @__PURE__ */ __exportAll({
@@ -185,9 +218,15 @@ const runLayer = (layer, command) => Effect$1.gen(function* () {
 	const last = phases[phases.length - 1];
 	if (!last || last.name !== "write") return yield* Effect$1.die(/* @__PURE__ */ new Error("effect-cell-types: a layer reached the interpreter without a write phase closing it"));
 	let value = command;
+	let raw = command;
 	for (const phase of phases.slice(0, -1)) switch (phase.convention) {
 		case "effect":
-			value = yield* phase.run(value);
+			if (phase.name === "read") {
+				value = yield* phase.run(value);
+				raw = value;
+				break;
+			}
+			value = yield* phase.run(value, raw);
 			break;
 		case "either-fail":
 			value = yield* Result$1.match(phase.run(value), {
@@ -207,7 +246,7 @@ const runLayer = (layer, command) => Effect$1.gen(function* () {
 			return yield* Effect$1.die(/* @__PURE__ */ new Error(`effect-cell-types: unknown phase convention ${String(unreachable)}`));
 		}
 	}
-	return yield* last.run(value);
+	return yield* last.run(value, raw);
 });
 /**
 * Applies a description. The return type is deliberately not annotated: `gen` accumulates
@@ -246,7 +285,7 @@ const apply = (description, command) => Effect$1.gen(function* () {
 * any other sequence fails to typecheck here — which is what keeps the derived order
 * non-circular: it is read off a value, and the value's shape is enforced by the types.
 */
-const canonical = write(encode(decide(decode(read(() => Effect$1.void), () => Result$1.succeed(void 0)), canonicalDecide), () => void 0), () => Effect$1.void);
+const canonical = write(encode(decide(decode(read(() => Effect$1.void), () => Result$1.succeed(CanonicalCommand.make({}))), canonicalDecide), () => void 0), () => Effect$1.void);
 /**
 * The phase vocabulary, obtained by walking `canonical`. A consumer that needs the phase
 * names, their purity, or their order — a lint rule, a generator, a document — reads them
@@ -279,81 +318,38 @@ var Policy_exports = /* @__PURE__ */ __exportAll({});
 *
 * ```ts
 * import { Wire } from '@systemfsoftware/effect-cell-types'
-* import { Schema } from 'effect'
+* import { Effect, Schema as S } from 'effect'
 *
 * const Invoice = Wire.wire({
-*   id: Wire.string,
-*   amountDue: Wire.nullOr(Wire.number),
-*   status: Wire.literal('draft', 'open', 'paid'),
-*   lineItems: Wire.array(Wire.string),
-*   metadata: Wire.record(Wire.string, Wire.string),
-*   deleted: Wire.optional(Wire.boolean),
+*   id: Wire.mint(S.String),
+*   amountDue: Wire.mint(S.NullOr(Wire.mint(S.Finite))),
+*   status: Wire.mint(S.Literals(['draft', 'open', 'paid'])),
+*   lineItems: Wire.mint(S.Array(Wire.mint(S.String))),
+*   metadata: Wire.mint(S.Record(Wire.mint(S.String), Wire.mint(S.String))),
+*   deleted: Wire.mint(S.optional(Wire.mint(S.Boolean))),
 * })
 *
 * // Decodes to your own type — `{ id: string; amountDue: number | null; ... }`.
-* const invoice = Schema.decodeUnknownSync(Invoice)(payload)
+* const invoice = yield* Schema.decode(Invoice)(payload)
 * ```
 *
-* Only declarations that use the alphabet are constrained, and {@link mint} admits a foreign
-* schema deliberately. It is a guardrail, not a security boundary.
+* Only declarations that name members through {@link mint} are constrained, and mint admits a
+* foreign schema deliberately. It is a guardrail, not a security boundary.
 */
 var Wire_exports = /* @__PURE__ */ __exportAll({
-	array: () => array,
-	boolean: () => boolean,
-	integer: () => integer,
-	literal: () => literal,
 	mint: () => mint,
-	nullOr: () => nullOr,
-	nullishOr: () => nullishOr,
-	number: () => number,
-	optional: () => optional,
-	record: () => record,
-	refine: () => refine,
-	string: () => string,
-	suspend: () => suspend,
-	tuple: () => tuple,
-	undefinedOr: () => undefinedOr,
-	union: () => union,
 	wire: () => wire
 });
 /**
 * Mark a member whose type this workspace declares.
 *
-* Prefer the alphabet below; reach for this only to admit a schema the alphabet cannot express,
-* including a vendor's own. The value returned is the one passed in, and its concrete type is
-* preserved, so a marked struct stays a struct and Effect's inference keeps working.
+* The value returned is the one passed in, and its concrete type is preserved, so a marked
+* struct stays a struct and Effect's inference keeps working. Reach for it to admit anything
+* the schema library can express, including a vendor's own schema — deliberately.
 */
 const mint = (field) => {
-	assertMinted(field);
 	return field;
 };
-function assertMinted(_field) {}
-const string = mint(Schema.String);
-const number = mint(Schema.Finite);
-const boolean = mint(Schema.Boolean);
-const integer = mint(Schema.Int);
-const literal = (...literals) => mint(Schema.Literals(literals));
-const nullOr = (member) => mint(Schema.NullOr(member));
-const undefinedOr = (member) => mint(Schema.UndefinedOr(member));
-const nullishOr = (member) => mint(Schema.NullishOr(member));
-const array = (member) => mint(Schema.Array(member));
-/** A field that may be absent from the payload entirely, as distinct from present and `undefined`. */
-const optional = (member) => mint(Schema.optional(member));
-const record = (key, value) => mint(Schema.Record(key, value));
-const union = (...members) => mint(Schema.Union(members));
-const tuple = (...elements) => mint(Schema.Tuple(elements));
-const suspend = (thunk) => mint(Schema.suspend(thunk));
-/**
-* Constrain a member's values. Effect's own `member.pipe(Schema.check(Schema.isMinLength(1)))`
-* preserves the mark, but returns the schema with the concrete decode/encode pair fused; this
-* combinator is the alphabet's own shape for the same operation, so a refined member keeps the
-* declaration this workspace makes of its type.
-*
-* `S.refine` needs a type-guard as its predicate argument; the workspace's predicate is a plain
-* `(a: A) => boolean` that narrows nothing, so a truth-preserving `value is A` guard is written
-* at this one call site rather than widening the public signature.
-*/
-const refine = (member, predicate, annotations) => mint(Schema.refine((value) => predicate(value), annotations)(member));
 const wire = (fields) => mint(Schema.Struct(fields));
 //#endregion
 export { Cell_exports as Cell, Policy_exports as Policy, Wire_exports as Wire, Workflow_exports as Workflow };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@systemfsoftware/effect-cell-types",
   "license": "Apache-2.0",
-  "version": "3.0.0",
+  "version": "5.0.0",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
@@ -32,23 +32,23 @@
     "dist"
   ],
   "devDependencies": {
-    "@effect/vitest": "4.0.0-rc.108",
+    "@effect/vitest": "4.0.0-rc.112",
     "@microsoft/api-extractor": "^7.58.7",
     "@systemfsoftware/arethetypeswrong-cli": "^1.1.1",
     "@types/node": "^24",
-    "effect": "4.0.0-rc.108",
+    "effect": "^4.0.0-rc.112",
     "oxlint": "^1.77.0",
     "rimraf": "^6.1.3",
     "tsdown": "^0.22.14",
     "tstyche": "^7.1.0",
     "vitest": "^4.1.10",
-    "@systemfsoftware/effect-gherkin-spec": "2.0.0",
-    "@systemfsoftware/vitest-config": "^0.1.0",
+    "@systemfsoftware/effect-gherkin-spec": "2.0.1",
     "@systemfsoftware/tsconfig": "^1.3.3",
-    "@systemfsoftware/oxlint-config": "^0.1.0"
+    "@systemfsoftware/oxlint-config": "^0.1.0",
+    "@systemfsoftware/vitest-config": "^0.1.0"
   },
   "peerDependencies": {
-    "effect": "4.0.0-rc.108"
+    "effect": "^4.0.0-rc.112"
   },
   "publishConfig": {
     "provenance": true
@@ -58,7 +58,6 @@
     "build": "tsdown && pnpm api:check",
     "typecheck": "tsc --noEmit --incremental",
     "test": "vitest run --passWithNoTests",
-    "test:run": "vitest run --passWithNoTests",
     "test:types": "TSTYCHE_TYPESCRIPT_MODULE=tstyche-typescript tstyche",
     "api:check": "api-extractor run",
     "api:update": "api-extractor run --local",