@systemfsoftware/effect-cell-types 8.0.0 → 8.2.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @systemfsoftware/effect-cell-types
 
+## 8.2.0
+
+### Minor Changes
+
+- Build a cell as a typed continuation chain: `Sandwich.read` takes the read effect and each step exposes only the phase that may follow, so a misordered chain fails to compile with a missing-method error naming the lawful next steps. Pure fillings (`decode`, `encode`) accept only `Sandwich.pure` thunks, and every finished cell carries a recorded `phases` tuple naming the steps it runs. The record-spec authoring surface is retired: build chains with `Sandwich.read` instead.
+
+## 8.1.0
+
+### Minor Changes
+
+- `collectAll` now declares an error channel of `never`: the composed cell cannot fail, because every per-item refusal is delivered to the fold as a `Result`. Composed cells no longer carry the item error channel in their type.
+
+  `Workflow.andThen` now composes two total workflows (components whose error channel is `never`) into a total workflow. Error-carrying chains are unchanged.
+
+  `Workflow.make` and `Workflow.total` now refuse decision unions whose variants declare the family brand as a narrow unique-symbol type instead of the documented class-field idiom. Declare the brand as a `readonly [T] = T` field on each `S.TaggedClass` variant: the field initializer widens the slot to the general `symbol` type, and the predicate keys on that widened slot. A `typeof`-annotated slot stays narrow and is refused with `UnsharedTypeId` — including the idiom hand-written as an interface. An interface annotating the slot as plain `symbol` is structurally identical to the class idiom and is accepted.
+
 ## 8.0.0
 
 ### Major Changes

package/README.md

@@ -15,8 +15,8 @@ When both channels are inhabited, `Workflow<Command, Decision, Error>` is the fu
 `(command: Command) => Result<Decision, Error>` carrying the nominal `WorkflowBrand`
 conjunct — a phantom readonly TypeId-keyed field that no runtime property backs. The brand
 is what makes the workbook nominal: `Workflow.make` is the only constructor that applies
-it, and every surface that runs a decision — the `decide` member a `Cell.layer` spec
-demands — requires it, so a decision that skipped `make` is a compile error at the call site that would have run it, with the brand named in the diagnostic. A `never` channel does
+it, and every surface that runs a decision — the chain's `decide` slot demands it —
+requires it, so a decision that skipped `make` is a compile error at the call site that would have run it, with the brand named in the diagnostic. A `never` channel does
 not silently collapse to that function: it resolves to a marker interface that no function
 can satisfy, so the mistake is a compile error with the remediation attached (below). The
 success channel is shaped the same way: `Workflow.make` refuses a decision channel that is
@@ -133,22 +133,80 @@ decision anything may run. The error channel is a real variant (`RestartDecision
 giving up is a decision the caller must branch on, so declaring the error channel `never` is
 rejected, not allowed.
 
+## Building a cell: the `Sandwich` chain
+
+A cell is authored as a typed continuation chain, not a record of phases. `Sandwich.read` takes the impure read effect and returns only the lawful next steps; each step composes its `run` at construction and exposes only what may follow, so a misordered chain fails to compile with a missing-method error whose displayed type names the lawful next steps. There is no interpreter: composition happens step by step inside the constructors. Every finished cell carries a recorded `phases` tuple — a type-level literal plus a matching runtime array, both produced by the constructors.
+
+| Step     | Exposes next                                    | Channel law                                                      |
+| -------- | ----------------------------------------------- | ---------------------------------------------------------------- |
+| `read`   | `decode`, `decide`                              | `I` consumed; `Raw` produced; `E`/`R` from the `Effect`          |
+| `decode` | `decide`                                        | a `Sandwich.pure` phase; its refusal fails the cell              |
+| `decide` | `encode` (decoded chain) or `write` (raw chain) | a `Workflow.make` value; the outcome is a value, never a failure |
+| `encode` | `write`                                         | a `Sandwich.pure` phase shaping the outcome `Result`             |
+| `write`  | —                                               | `Out` plus `Raw` in (or unary `Out` alone); `Resp`/`E`/`R` out   |
+
+A short chain skips the filling's middle steps — `read → decide → write` — and records exactly those three phases:
+
+```ts
+import { Sandwich, type Workflow } from '@systemfsoftware/effect-cell-types'
+import { Effect, Result } from 'effect'
+
+// The reader's own domain: a command, its raw reading, and a decide outcome.
+interface Command {
+  readonly id: string
+}
+interface Raw {
+  readonly bytes: string
+}
+
+// `admit` is a `Workflow.make` value over the decoded form, built as in
+// "The constructor" above; `render` turns its outcome into a string.
+declare const admit: Workflow<Decoded, Admitted, Malformed>
+declare const render: (outcome: Result.Result<Admitted, Malformed>) => string
+
+const cell = Sandwich.read((command: Command) => Effect.succeed(new Decoded({ length: command.id.length }))).decide(
+  admit,
+).write(
+  (outcome: Result.Result<Admitted, Malformed>) => Effect.sync(() => render(outcome)),
+)
+
+cell.phases // ['read', 'decide', 'write']
+```
+
+A full chain fills `decode` and `encode` with `Sandwich.pure` phases — synchronous `Result`-returning thunks, the only values the slots accept, so no `Effect` can be evaluated inside them:
+
+```ts
+const full = Sandwich.read((command: Command) => Effect.succeed({ bytes: command.id })).decode(
+  Sandwich.pure((raw: Raw): Result.Result<Decoded, Malformed> =>
+    Result.succeed(new Decoded({ length: raw.bytes.length }))
+  ),
+).decide(admit).encode(
+  Sandwich.pure((outcome: Result.Result<Admitted, Malformed>): Result.Result<string, never> =>
+    Result.succeed(render(outcome))
+  ),
+).write((line: string, raw: Raw) => Effect.succeed(`${line}<-${raw.bytes}`))
+
+full.phases // ['read', 'decode', 'decide', 'encode', 'write']
+```
+
+The `decide` refusal is an outcome, not a failure: it travels to `encode` and `write` as a `Result` value. A `decode` refusal fails the cell and the run stops there.
+
 ## What it rejects at compile time
 
 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; fold the function into its owning module                                            |
-| An untagged error variant                 | `Type '...' is not assignable to type 'UntaggedError'`                                    | an error variant needs a `_tag` a consumer can dispatch on; declare the errors as `S.TaggedError` instances                      |
-| A single-variant decision channel         | `Type '...' is not assignable to type 'SingleVariantDecision'`                            | a decision chooses between at least two distinguishable outcomes; one variant is a calculation wearing a decision's shape        |
-| An untagged decision variant              | `Type '...' is not assignable to type 'UntaggedDecision'`                                 | a decision variant needs a `_tag` a consumer can dispatch on; declare the variants as `S.TaggedClass` instances                  |
-| Decision variants with no shared TypeId   | `Type '...' is not assignable to type 'UnsharedTypeId'`                                   | one decision family carries one TypeId — a `Symbol.for` brand on every variant class                                             |
-| A bare decider in a `Cell.layer` spec     | `Type '(command: Cmd) => Result<Dec, Err>' is not assignable to type 'WorkflowBrand'`     | only a `Workflow.make` value satisfies the `decide` member; 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                    |
+| 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; fold the function into its owning module                                     |
+| An untagged error variant                 | `Type '...' is not assignable to type 'UntaggedError'`                                    | an error variant needs a `_tag` a consumer can dispatch on; declare the errors as `S.TaggedError` instances               |
+| A single-variant decision channel         | `Type '...' is not assignable to type 'SingleVariantDecision'`                            | a decision chooses between at least two distinguishable outcomes; one variant is a calculation wearing a decision's shape |
+| An untagged decision variant              | `Type '...' is not assignable to type 'UntaggedDecision'`                                 | a decision variant needs a `_tag` a consumer can dispatch on; declare the variants as `S.TaggedClass` instances           |
+| Decision variants with no shared TypeId   | `Type '...' is not assignable to type 'UnsharedTypeId'`                                   | one decision family carries one TypeId — a `Symbol.for` brand on every variant class                                      |
+| A bare decider in a `decide` slot         | `Type '(command: Cmd) => Result<Dec, Err>' is not assignable to type 'WorkflowBrand'`     | only a `Workflow.make` value satisfies the `decide` slot; a lambda that skipped `make` is not a decision a chain 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:
 

package/dist/index.d.ts

@@ -5,89 +5,11 @@ import { Result } from "effect/Result";
 import { Kind, TypeLambda } from "effect/HKT";
 import { Layer } from "effect/Layer";
 import * as Schema from "effect/Schema";
-//#region src/Facts.d.ts
-declare const DESCRIPTION_MODULE: '@systemfsoftware/effect-cell-types';
-declare const IO_CELLS: {
-  readonly cells: readonly ['store', 'adapter'];
-  readonly sources: readonly ['effect/Clock', 'effect/System'];
-};
-type IoCellClassification = typeof IO_CELLS;
-type PhaseName = 'read' | 'decode' | 'decide' | 'encode' | 'write';
-declare namespace Workflow_d_exports {
-  export { Inhabited, SingleVariantDecision, UninhabitedDecision, UninhabitedError, UnsharedTypeId, UntaggedDecision, UntaggedError, Workflow, WorkflowBrand, andThen$1 as andThen, make, total };
-}
-declare const WorkflowTypeId: unique symbol;
-type WorkflowTypeId = typeof WorkflowTypeId;
-interface WorkflowBrand {
-  readonly [WorkflowTypeId]: WorkflowTypeId;
-}
-interface UninhabitedDecision {
-  readonly __WORKFLOW_DECISION_CHANNEL_IS_NEVER__: 'this workflow can never succeed; give it a decision variant it can return';
-}
-interface UninhabitedError {
-  readonly __WORKFLOW_ERROR_CHANNEL_IS_NEVER__: 'this workflow cannot fail, so it decides nothing; give it an error variant or fold the function into its owning module';
-}
-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';
-}
-interface SingleVariantDecision {
-  readonly __WORKFLOW_DECISION_CHANNEL_HAS_ONE_VARIANT__: 'this workflow decides one outcome, which is not a decision; add the variant it chooses between, or fold the function into its owning module';
-}
-interface UntaggedDecision {
-  readonly __WORKFLOW_DECISION_CHANNEL_CARRIES_NO_TAG__: 'a decision variant carries no _tag the consumer can dispatch on; declare the variants as S.TaggedClass instances';
-}
-interface UnsharedTypeId {
-  readonly __WORKFLOW_DECISION_VARIANTS_DO_NOT_SHARE_A_TYPE_ID__: 'the decision variants must share one TypeId — a Symbol.for family brand on each variant class';
-}
-type AtLeastTwoDistinct<T, U = T> = U extends unknown ? [T] extends [U] ? false : true : never;
-type TaggedMembers<D> = D extends unknown ? '_tag' extends keyof D ? [D['_tag']] extends [string] ? true : false : false : never;
-type MutuallyAssignable<A, B> = [A] extends [B] ? ([B] extends [A] ? true : false) : false;
-type BrandSlotIsTheGeneralSymbol<D, K extends PropertyKey> = D extends unknown ? K extends keyof D ? MutuallyAssignable<D[K], symbol> : false : never;
-type SharedTypeId<D> = [{ [K in keyof D]: [K] extends [symbol] ? ([BrandSlotIsTheGeneralSymbol<D, K>] extends [true] ? K : never) : never; }[keyof D]] extends [never] ? UnsharedTypeId : unknown;
-type DecisionShape<D> = [unknown] extends [D] ? unknown : AtLeastTwoDistinct<D> extends false ? SingleVariantDecision : boolean extends TaggedMembers<D> ? UntaggedDecision : SharedTypeId<D>;
-type Workflow<Command, Decision, DecisionError> = [Decision] extends [never] ? UninhabitedDecision : [DecisionError] extends [never] ? UninhabitedError : ((command: Command) => Result<Decision, DecisionError>) & WorkflowBrand;
-type DispatchableTag<E> = '_tag' extends keyof E ? [E['_tag']] extends [string] ? unknown : UntaggedError : UntaggedError;
-type Inhabited<Decision, DecisionError> = [Decision] extends [never] ? UninhabitedDecision : [DecisionError] extends [never] ? UninhabitedError : DecisionShape<Decision> & DispatchableTag<DecisionError>;
-declare const make: <Self, S extends Schema.Constraint & {
-  readonly fields: Schema.Struct.Fields;
-}, Inherited, D, E>(_command: Schema.Class<Self, S, Inherited>, decide: (command: Self) => Result<D, E> & Inhabited<D, E>) => Workflow<Self, D, E>;
-/**
- * Brands a decision that cannot fail. `make` refuses a `never` error channel outright
- * (`UninhabitedError`); this is the door for the decider that genuinely decides everything.
- * The decision must still choose between at least two tagged variants sharing one TypeId, so
- * `SingleVariantDecision`, `UntaggedDecision`, and `UnsharedTypeId` still fire.
- *
- * The command schema class comes first, exactly as in {@link make}, so the command channel
- * stays pinned to the class rather than an inferred annotation. The decider's return carries
- * `DecisionShape` written out: the `Workflow` alias is a deferred conditional, and in
- * parameter position it collapses the whole parameter to `unknown` while the decision
- * channel is still generic.
- */
-declare const total: <Self, S extends Schema.Constraint & {
-  readonly fields: Schema.Struct.Fields;
-}, Inherited, D>(_command: Schema.Class<Self, S, Inherited>, decide: (command: Self) => Result<D, never> & DecisionShape<D>) => ((command: Self) => Result<D, never>) & WorkflowBrand;
-/**
- * Composes two workflows: what the upstream decides becomes the command the downstream decides
- * on, and a refusal short-circuits the pair. The return type dispatches on the component error
- * union — two components that cannot fail publish the total form, because the `Workflow` alias
- * refuses a `never` channel; a carried error publishes the union as before.
- */
-declare const andThen$1: <Ctx, SelfA, SA extends Schema.Constraint & {
-  readonly fields: Schema.Struct.Fields;
-}, InheritedA, D1, E1, SelfB extends {
-  readonly decision: D1;
-  readonly ctx: Ctx;
-}, D2, E2>(_commandA: Schema.Class<SelfA, SA, InheritedA>, upstream: ((command: SelfA) => Result<D1, E1>) & WorkflowBrand, commandB: {
-  new (props: {
-    readonly decision: D1;
-    readonly ctx: Ctx;
-  }): SelfB;
-}, ctx: NoInfer<Ctx>, downstream: ((command: SelfB) => Result<D2, E2>) & WorkflowBrand) => [E1 | E2] extends [never] ? ((command: SelfA) => Result<D2, never>) & WorkflowBrand : Workflow<SelfA, D2, E1 | E2>;
 declare namespace Cell_d_exports {
-  export { Cell, CellTypeId, DESCRIPTION_MODULE, IO_CELLS, IoCellClassification, Kind$1 as Kind, PhaseName, Run, TypeLambda$1 as TypeLambda, Vocabulary, andThen, collect, collectAll, gate, layer, map, mapInput, provide, vocabulary, zip };
+  export { Cell, CellTypeId, Kind$1 as Kind, Run, TypeLambda$1 as TypeLambda, andThen$1 as andThen, collect, collectAll, gate, map, mapInput, provide, zip };
 }
 /**
- * The nominal brand every `Cell` carries. `Cell.layer` is the only door that applies it.
+ * The nominal brand every `Cell` carries. The `Sandwich` chain's `write` is the only door that applies it.
  */
 declare const CellTypeId: unique symbol;
 /**
@@ -120,48 +42,6 @@ type Kind$1<I, E, R, A> = Kind<TypeLambda$1, I, E, R, A>;
  * `Run<I, A, E, R>` is `Cell<I, A, E, R>['run']`.
  */
 type Run<I, A, E, R> = Cell<I, A, E, R>['run'];
-interface LayerCore<I, Raw, RE, RR, Dec, DE, Resp, WE, WR> {
-  readonly read: (command: I) => Effect.Effect<Raw, RE, RR>;
-  readonly decide: ((decoded: Raw) => Result$1.Result<Dec, DE>) & WorkflowBrand;
-  readonly write: (output: Result$1.Result<Dec, DE>, raw: Raw) => Effect.Effect<Resp, WE, WR>;
-}
-interface LayerShortSpec<I, Raw, RE, RR, Dec, DE, Resp, WE, WR> extends LayerCore<I, Raw, RE, RR, Dec, DE, Resp, WE, WR> {
-  readonly decode?: never;
-  readonly encode?: never;
-}
-interface LayerLongSpec<I, Raw, RE, RR, Dcd, DecE, Dec, DE, Out, Resp, WE, WR> extends Omit<LayerCore<I, Raw, RE, RR, Dec, DE, Resp, WE, WR>, 'decide' | 'write'> {
-  readonly decode: (raw: Raw) => Result$1.Result<Dcd, DecE>;
-  readonly decide: ((decoded: Dcd) => Result$1.Result<Dec, DE>) & WorkflowBrand;
-  readonly encode: (outcome: Result$1.Result<Dec, DE>) => Out;
-  readonly write: (output: Out, raw: Raw) => Effect.Effect<Resp, WE, WR>;
-}
-/**
- * Builds a Cell from one sandwich.
- *
- * Short form — `read` produces the value `decide` rules on, and the decide outcome is what
- * `write` receives:
- *
- * ```ts
- * import { Cell, Workflow } from '@systemfsoftware/effect-cell-types'
- * import { Effect, Result } from 'effect'
- *
- * declare const decideAdmission: Workflow<CliArgs, Verdict, Refusal>
- * declare class CliArgs { readonly target: string }
- * declare class Verdict { readonly ok: boolean }
- * declare class Refusal { readonly _tag: 'Refused' }
- *
- * const cell = Cell.layer({
- *   read: (args: CliArgs) => Effect.succeed(args),
- *   decide: decideAdmission,
- *   write: (outcome: Result.Result<Verdict, Refusal>, raw: CliArgs) => Effect.void,
- * })
- * ```
- *
- * Long form — `decode` and `encode` adapt each side of `decide`; both are required together,
- * and a spec carrying one without the other fails inference.
- */
-declare function layer<I, Raw, RE, RR, Dec, DE, Resp, WE, WR>(spec: LayerShortSpec<I, Raw, RE, RR, Dec, DE, Resp, WE, WR>): Cell<I, Resp, RE | WE, RR | WR>;
-declare function layer<I, Raw, RE, RR, Dcd, DecE, Dec, DE, Out, Resp, WE, WR>(spec: LayerLongSpec<I, Raw, RE, RR, Dcd, DecE, Dec, DE, Out, Resp, WE, WR>): Cell<I, Resp, RE | DecE | WE, RR | WR>;
 /**
  * Transforms the Cell's response.
  */
@@ -180,7 +60,7 @@ declare const mapInput: {
  * Feeds this Cell's response to the next Cell as its input. The error and service channels
  * union.
  */
-declare const andThen: {
+declare const andThen$1: {
   <B, E2, R2>(that: Cell<never, B, E2, R2>): <I, A, E, R>(self: Cell<I, A, E, R>) => Cell<I, B, E | E2, R | R2>;
   <I, A, E, R, B, E2, R2>(self: Cell<I, A, E, R>, that: Cell<A, B, E2, R2>): Cell<I, B, E | E2, R | R2>;
 };
@@ -226,19 +106,110 @@ declare const provide: {
   <RIn, LE, ROut>(layer: Layer<ROut, LE, RIn>): <I, A, E, R>(self: Cell<I, A, E, R>) => Cell<I, A, E | LE, RIn | Exclude<R, ROut>>;
   <I, A, E, R, RIn, LE, ROut>(self: Cell<I, A, E, R>, layer: Layer<ROut, LE, RIn>): Cell<I, A, E | LE, RIn | Exclude<R, ROut>>;
 };
+declare namespace Workflow_d_exports {
+  export { Inhabited, SingleVariantDecision, UninhabitedDecision, UninhabitedError, UnsharedTypeId, UntaggedDecision, UntaggedError, Workflow, WorkflowBrand, andThen, make, total };
+}
+declare const WorkflowTypeId: unique symbol;
+type WorkflowTypeId = typeof WorkflowTypeId;
+interface WorkflowBrand {
+  readonly [WorkflowTypeId]: WorkflowTypeId;
+}
+interface UninhabitedDecision {
+  readonly __WORKFLOW_DECISION_CHANNEL_IS_NEVER__: 'this workflow can never succeed; give it a decision variant it can return';
+}
+interface UninhabitedError {
+  readonly __WORKFLOW_ERROR_CHANNEL_IS_NEVER__: 'this workflow cannot fail, so it decides nothing; give it an error variant or fold the function into its owning module';
+}
+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';
+}
+interface SingleVariantDecision {
+  readonly __WORKFLOW_DECISION_CHANNEL_HAS_ONE_VARIANT__: 'this workflow decides one outcome, which is not a decision; add the variant it chooses between, or fold the function into its owning module';
+}
+interface UntaggedDecision {
+  readonly __WORKFLOW_DECISION_CHANNEL_CARRIES_NO_TAG__: 'a decision variant carries no _tag the consumer can dispatch on; declare the variants as S.TaggedClass instances';
+}
+interface UnsharedTypeId {
+  readonly __WORKFLOW_DECISION_VARIANTS_DO_NOT_SHARE_A_TYPE_ID__: 'the decision variants must share one TypeId — a Symbol.for family brand on each variant class';
+}
+type AtLeastTwoDistinct<T, U = T> = U extends unknown ? [T] extends [U] ? false : true : never;
+type TaggedMembers<D> = D extends unknown ? '_tag' extends keyof D ? [D['_tag']] extends [string] ? true : false : false : never;
+type MutuallyAssignable<A, B> = [A] extends [B] ? ([B] extends [A] ? true : false) : false;
+type BrandSlotIsTheGeneralSymbol<D, K extends PropertyKey> = D extends unknown ? K extends keyof D ? MutuallyAssignable<D[K], symbol> : false : never;
+type SharedTypeId<D> = [{ [K in keyof D]: [K] extends [symbol] ? ([BrandSlotIsTheGeneralSymbol<D, K>] extends [true] ? K : never) : never; }[keyof D]] extends [never] ? UnsharedTypeId : unknown;
+type DecisionShape<D> = [unknown] extends [D] ? unknown : AtLeastTwoDistinct<D> extends false ? SingleVariantDecision : boolean extends TaggedMembers<D> ? UntaggedDecision : SharedTypeId<D>;
+type Workflow<Command, Decision, DecisionError> = [Decision] extends [never] ? UninhabitedDecision : [DecisionError] extends [never] ? UninhabitedError : ((command: Command) => Result<Decision, DecisionError>) & WorkflowBrand;
+type DispatchableTag<E> = '_tag' extends keyof E ? [E['_tag']] extends [string] ? unknown : UntaggedError : UntaggedError;
+type Inhabited<Decision, DecisionError> = [Decision] extends [never] ? UninhabitedDecision : [DecisionError] extends [never] ? UninhabitedError : DecisionShape<Decision> & DispatchableTag<DecisionError>;
+declare const make: <Self, S extends Schema.Constraint & {
+  readonly fields: Schema.Struct.Fields;
+}, Inherited, D, E>(_command: Schema.Class<Self, S, Inherited>, decide: (command: Self) => Result<D, E> & Inhabited<D, E>) => Workflow<Self, D, E>;
 /**
- * The facts the lint plugin judges a spec body by, as a const table. The order the
- * interpreter runs is the text of {@link layerRunner}; the table states only what a
- * rule cannot read off a type: which phases are pure, and what counts as I/O.
+ * Brands a decision that cannot fail. `make` refuses a `never` error channel outright
+ * (`UninhabitedError`); this is the door for the decider that genuinely decides everything.
+ * The decision must still choose between at least two tagged variants sharing one TypeId, so
+ * `SingleVariantDecision`, `UntaggedDecision`, and `UnsharedTypeId` still fire.
+ *
+ * The command schema class comes first, exactly as in {@link make}, so the command channel
+ * stays pinned to the class rather than an inferred annotation. The decider's return carries
+ * `DecisionShape` written out: the `Workflow` alias is a deferred conditional, and in
+ * parameter position it collapses the whole parameter to `unknown` while the decision
+ * channel is still generic.
+ */
+declare const total: <Self, S extends Schema.Constraint & {
+  readonly fields: Schema.Struct.Fields;
+}, Inherited, D>(_command: Schema.Class<Self, S, Inherited>, decide: (command: Self) => Result<D, never> & DecisionShape<D>) => ((command: Self) => Result<D, never>) & WorkflowBrand;
+/**
+ * Composes two workflows: what the upstream decides becomes the command the downstream decides
+ * on, and a refusal short-circuits the pair. The return type dispatches on the component error
+ * union — two components that cannot fail publish the total form, because the `Workflow` alias
+ * refuses a `never` channel; a carried error publishes the union as before.
  */
-interface Vocabulary {
-  readonly module: typeof DESCRIPTION_MODULE;
-  readonly ioCells: IoCellClassification;
-  readonly byKind: {
-    readonly pure: readonly PhaseName[];
+declare const andThen: <Ctx, SelfA, SA extends Schema.Constraint & {
+  readonly fields: Schema.Struct.Fields;
+}, InheritedA, D1, E1, SelfB extends {
+  readonly decision: D1;
+  readonly ctx: Ctx;
+}, D2, E2>(_commandA: Schema.Class<SelfA, SA, InheritedA>, upstream: ((command: SelfA) => Result<D1, E1>) & WorkflowBrand, commandB: {
+  new (props: {
+    readonly decision: D1;
+    readonly ctx: Ctx;
+  }): SelfB;
+}, ctx: NoInfer<Ctx>, downstream: ((command: SelfB) => Result<D2, E2>) & WorkflowBrand) => [E1 | E2] extends [never] ? ((command: SelfA) => Result<D2, never>) & WorkflowBrand : Workflow<SelfA, D2, E1 | E2>;
+declare namespace Sandwich_d_exports {
+  export { DecodedChain, DecodedDecidedChain, EncodedChain, PurePhase, RawDecidedChain, ReadChain, pure, read };
+}
+declare const PurePhaseBrand: unique symbol;
+type PurePhaseBrand = typeof PurePhaseBrand;
+type PurePhase<In, Out, E = never> = ((input: In) => Result$1.Result<Out, E>) & {
+  readonly [PurePhaseBrand]: true;
+};
+declare const pure: <In, Out, E = never>(fn: (input: In) => Result$1.Result<Out, E>) => PurePhase<In, Out, E>;
+interface ReadChain<I, Raw, RE, RR> {
+  readonly 'sentence: must decode or decide after read': true;
+  decode<Dcd, DecE>(phase: PurePhase<Raw, Dcd, DecE>): DecodedChain<I, Raw, Dcd, RE, DecE, RR>;
+  decide<Dec, DE>(workflow: ((decoded: Raw) => Result$1.Result<Dec, DE>) & WorkflowBrand): RawDecidedChain<I, Raw, Dec, DE, RE, RR>;
+}
+interface DecodedChain<I, Raw, Dcd, RE, DecE, RR> {
+  readonly 'sentence: must decide after decode': true;
+  decide<Dec, DE>(workflow: ((decoded: Dcd) => Result$1.Result<Dec, DE>) & WorkflowBrand): DecodedDecidedChain<I, Raw, Dec, DE, RE, DecE, RR>;
+}
+interface RawDecidedChain<I, Raw, Dec, DE, RE, RR> {
+  readonly 'sentence: must write after decide on raw chain': true;
+  write<Resp, WE, WR>(run: (output: Result$1.Result<Dec, DE>, raw: Raw) => Effect.Effect<Resp, WE, WR>): Cell<I, Resp, RE | WE, RR | WR> & {
+    readonly phases: readonly ['read', 'decide', 'write'];
+  };
+}
+interface DecodedDecidedChain<I, Raw, Dec, DE, RE, DecE, RR> {
+  readonly 'sentence: must encode after decide on decoded chain': true;
+  encode<Out>(phase: PurePhase<Result$1.Result<Dec, DE>, Out, never>): EncodedChain<I, Raw, Out, RE, DecE, RR>;
+}
+interface EncodedChain<I, Raw, Out, RE, DecE, RR> {
+  readonly 'sentence: must write after encode': true;
+  write<Resp, WE, WR>(run: (output: Out, raw: Raw) => Effect.Effect<Resp, WE, WR>): Cell<I, Resp, RE | DecE | WE, RR | WR> & {
+    readonly phases: readonly ['read', 'decode', 'decide', 'encode', 'write'];
   };
-  readonly composer: 'layer';
 }
-declare const vocabulary: Vocabulary;
+declare const read: <I, Raw, RE, RR>(run: (command: I) => Effect.Effect<Raw, RE, RR>) => ReadChain<I, Raw, RE, RR>;
 //#endregion
-export { Cell_d_exports as Cell, Workflow_d_exports as Workflow };
+export { Cell_d_exports as Cell, Sandwich_d_exports as Sandwich, Workflow_d_exports as Workflow };

package/dist/index.mjs

@@ -4,122 +4,49 @@ import { dual } from "effect/Function";
 import * as Option from "effect/Option";
 import * as Result$1 from "effect/Result";
 import { flatMap } from "effect/Result";
-//#region src/Facts.ts
-const DESCRIPTION_MODULE = "@systemfsoftware/effect-cell-types";
-const IO_CELLS = {
-	cells: ["store", "adapter"],
-	sources: ["effect/Clock", "effect/System"]
-};
-//#endregion
-//#region src/Workflow.ts
-var Workflow_exports = /* @__PURE__ */ __exportAll({
-	andThen: () => andThen$1,
-	make: () => make$1,
-	total: () => total
-});
-const make$1 = (_command, decide) => {
-	return decide;
-};
-/**
-* Brands a decision that cannot fail. `make` refuses a `never` error channel outright
-* (`UninhabitedError`); this is the door for the decider that genuinely decides everything.
-* The decision must still choose between at least two tagged variants sharing one TypeId, so
-* `SingleVariantDecision`, `UntaggedDecision`, and `UnsharedTypeId` still fire.
-*
-* The command schema class comes first, exactly as in {@link make}, so the command channel
-* stays pinned to the class rather than an inferred annotation. The decider's return carries
-* `DecisionShape` written out: the `Workflow` alias is a deferred conditional, and in
-* parameter position it collapses the whole parameter to `unknown` while the decision
-* channel is still generic.
-*/
-const total = (_command, decide) => {
-	return decide;
-};
-/**
-* Composes two workflows: what the upstream decides becomes the command the downstream decides
-* on, and a refusal short-circuits the pair. The return type dispatches on the component error
-* union — two components that cannot fail publish the total form, because the `Workflow` alias
-* refuses a `never` channel; a carried error publishes the union as before.
-*/
-const andThen$1 = (_commandA, upstream, commandB, ctx, downstream) => {
-	const composed = (command) => flatMap(upstream(command), (decision) => downstream(new commandB({
-		decision,
-		ctx
-	})));
-	return composed;
-};
-//#endregion
 //#region src/Cell.ts
 var Cell_exports = /* @__PURE__ */ __exportAll({
 	CellTypeId: () => CellTypeId,
-	DESCRIPTION_MODULE: () => DESCRIPTION_MODULE,
-	IO_CELLS: () => IO_CELLS,
-	andThen: () => andThen,
+	andThen: () => andThen$1,
 	collect: () => collect,
 	collectAll: () => collectAll,
 	gate: () => gate,
-	layer: () => layer,
 	map: () => map,
 	mapInput: () => mapInput,
 	provide: () => provide,
-	vocabulary: () => vocabulary,
 	zip: () => zip
 });
 /**
-* The nominal brand every `Cell` carries. `Cell.layer` is the only door that applies it.
+* The nominal brand every `Cell` carries. The `Sandwich` chain's `write` is the only door that applies it.
 */
 const CellTypeId = Symbol.for("@systemfsoftware/effect-cell-types/Cell");
-const make = (run) => ({
+const make$1 = (run) => ({
 	[CellTypeId]: CellTypeId,
 	run
 });
 /**
-* The interpreter. Order is the text: read, then decode, then decide, then encode, then
-* write. The `E` channel is the sandwich's truth — read, decode, and write failures;
-* a decide refusal is the outcome the encode and write receive, not a failure.
-*/
-const layerRunner = (spec) => {
-	if ("decode" in spec && "encode" in spec) return (input) => Effect.gen(function* () {
-		const raw = yield* spec.read(input);
-		const decoded = yield* Result$1.match(spec.decode(raw), {
-			onFailure: Effect.fail,
-			onSuccess: Effect.succeed
-		});
-		const outcome = spec.decide(decoded);
-		return yield* spec.write(spec.encode(outcome), raw);
-	});
-	return (input) => Effect.gen(function* () {
-		const raw = yield* spec.read(input);
-		const outcome = spec.decide(raw);
-		return yield* spec.write(outcome, raw);
-	});
-};
-function layer(spec) {
-	return make(layerRunner(spec));
-}
-/**
 * Transforms the Cell's response.
 */
-const map = dual(2, (self, f) => make((input) => Effect.map(self.run(input), f)));
+const map = dual(2, (self, f) => make$1((input) => Effect.map(self.run(input), f)));
 /**
 * Transforms the Cell's input.
 */
-const mapInput = dual(2, (self, f) => make((input) => self.run(f(input))));
+const mapInput = dual(2, (self, f) => make$1((input) => self.run(f(input))));
 /**
 * Feeds this Cell's response to the next Cell as its input. The error and service channels
 * union.
 */
-const andThen = dual(2, (self, that) => make((input) => Effect.flatMap(self.run(input), (response) => that.run(response))));
+const andThen$1 = dual(2, (self, that) => make$1((input) => Effect.flatMap(self.run(input), (response) => that.run(response))));
 /**
 * Runs both Cells against the same input and tuples the responses. Fails fast: when one
 * side refuses, the other's write never runs.
 */
-const zip = dual(2, (self, that) => make((input) => Effect.zipWith(self.run(input), that.run(input), (a, b) => [a, b])));
+const zip = dual(2, (self, that) => make$1((input) => Effect.zipWith(self.run(input), that.run(input), (a, b) => [a, b])));
 /**
 * Runs the inner Cell on the value this Cell read, yielding `Option.none` when it read none.
 * A skip is an absence, never a refusal; the error and service channels union.
 */
-const gate = dual(2, (self, inner) => make((input) => Effect.flatMap(self.run(input), (read) => Option.match(read, {
+const gate = dual(2, (self, inner) => make$1((input) => Effect.flatMap(self.run(input), (read) => Option.match(read, {
 	onNone: () => Effect.succeed(Option.none()),
 	onSome: (raw) => Effect.map(inner.run(raw), Option.some)
 }))));
@@ -127,28 +54,131 @@ const gate = dual(2, (self, inner) => make((input) => Effect.flatMap(self.run(in
 * Runs the Cell once per item, in order, and folds the responses into one value. The error
 * and service channels are unchanged; the first refusal ends the run.
 */
-const collect = dual(2, (self, fold) => make((items) => Effect.map(Effect.forEach(items, (item) => self.run(item)), (responses) => fold(responses))));
+const collect = dual(2, (self, fold) => make$1((items) => Effect.map(Effect.forEach(items, (item) => self.run(item)), (responses) => fold(responses))));
 /**
 * Runs the Cell once per item, in order, and folds every outcome — each a `Result.Result` —
 * into one value. Unlike {@link collect}, no refusal ends the run: every item is attempted
 * and its failure travels to the fold.
 */
-const collectAll = dual(2, (self, fold) => make((items) => Effect.map(Effect.forEach(items, (item) => Effect.result(self.run(item))), (results) => fold(results))));
+const collectAll = dual(2, (self, fold) => make$1((items) => Effect.map(Effect.forEach(items, (item) => Effect.result(self.run(item))), (results) => fold(results))));
 /**
 * Provides a Layer to the Cell, eliminating the services the layer builds from `R`. This is
 * the one composition-root elimination; the resulting Cell still demands the layer's input
 * services. A missing provide is a compile error at the run site.
 */
-const provide = dual(2, (self, layer) => make((input) => Effect.provide(self.run(input), layer)));
-const vocabulary = {
-	module: DESCRIPTION_MODULE,
-	ioCells: IO_CELLS,
-	byKind: { pure: [
-		"decode",
-		"decide",
-		"encode"
-	] },
-	composer: "layer"
+const provide = dual(2, (self, layer) => make$1((input) => Effect.provide(self.run(input), layer)));
+//#endregion
+//#region src/Workflow.ts
+var Workflow_exports = /* @__PURE__ */ __exportAll({
+	andThen: () => andThen,
+	make: () => make,
+	total: () => total
+});
+const make = (_command, decide) => {
+	return decide;
+};
+/**
+* Brands a decision that cannot fail. `make` refuses a `never` error channel outright
+* (`UninhabitedError`); this is the door for the decider that genuinely decides everything.
+* The decision must still choose between at least two tagged variants sharing one TypeId, so
+* `SingleVariantDecision`, `UntaggedDecision`, and `UnsharedTypeId` still fire.
+*
+* The command schema class comes first, exactly as in {@link make}, so the command channel
+* stays pinned to the class rather than an inferred annotation. The decider's return carries
+* `DecisionShape` written out: the `Workflow` alias is a deferred conditional, and in
+* parameter position it collapses the whole parameter to `unknown` while the decision
+* channel is still generic.
+*/
+const total = (_command, decide) => {
+	return decide;
+};
+/**
+* Composes two workflows: what the upstream decides becomes the command the downstream decides
+* on, and a refusal short-circuits the pair. The return type dispatches on the component error
+* union — two components that cannot fail publish the total form, because the `Workflow` alias
+* refuses a `never` channel; a carried error publishes the union as before.
+*/
+const andThen = (_commandA, upstream, commandB, ctx, downstream) => {
+	const composed = (command) => flatMap(upstream(command), (decision) => downstream(new commandB({
+		decision,
+		ctx
+	})));
+	return composed;
+};
+//#endregion
+//#region src/Sandwich.ts
+var Sandwich_exports = /* @__PURE__ */ __exportAll({
+	pure: () => pure,
+	read: () => read
+});
+const PurePhaseBrand = Symbol.for("@systemfsoftware/effect-cell-types/PurePhase");
+const pure = (fn) => Object.assign(fn, { [PurePhaseBrand]: true });
+const read = (run) => {
+	const decode = (phase) => {
+		const decide = (workflow) => {
+			const encode = (encodePhase) => {
+				const write = (writeRun) => {
+					const composed = (input) => Effect.gen(function* () {
+						const raw = yield* run(input);
+						const outcome = workflow(yield* Result$1.match(phase(raw), {
+							onFailure: Effect.fail,
+							onSuccess: Effect.succeed
+						}));
+						return yield* writeRun(Result$1.getOrThrow(encodePhase(outcome)), raw);
+					});
+					return {
+						[CellTypeId]: CellTypeId,
+						run: composed,
+						phases: [
+							"read",
+							"decode",
+							"decide",
+							"encode",
+							"write"
+						]
+					};
+				};
+				return {
+					"sentence: must write after encode": true,
+					write
+				};
+			};
+			return {
+				"sentence: must encode after decide on decoded chain": true,
+				encode
+			};
+		};
+		return {
+			"sentence: must decide after decode": true,
+			decide
+		};
+	};
+	const decide = (workflow) => {
+		const write = (writeRun) => {
+			const composed = (input) => Effect.gen(function* () {
+				const raw = yield* run(input);
+				return yield* writeRun(workflow(raw), raw);
+			});
+			return {
+				[CellTypeId]: CellTypeId,
+				run: composed,
+				phases: [
+					"read",
+					"decide",
+					"write"
+				]
+			};
+		};
+		return {
+			"sentence: must write after decide on raw chain": true,
+			write
+		};
+	};
+	return {
+		"sentence: must decode or decide after read": true,
+		decode,
+		decide
+	};
 };
 //#endregion
-export { Cell_exports as Cell, Workflow_exports as Workflow };
+export { Cell_exports as Cell, Sandwich_exports as Sandwich, Workflow_exports as Workflow };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@systemfsoftware/effect-cell-types",
   "license": "Apache-2.0",
-  "version": "8.0.0",
+  "version": "8.2.0",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
@@ -34,7 +34,7 @@
   "devDependencies": {
     "@effect/vitest": "4.0.0-rc.112",
     "@microsoft/api-extractor": "^7.58.7",
-    "@systemfsoftware/arethetypeswrong-cli": "^4.1.0",
+    "@systemfsoftware/arethetypeswrong-cli": "^4.2.0",
     "@types/node": "^24",
     "effect": "4.0.0-rc.112",
     "oxlint": "^1.77.0",
@@ -42,8 +42,8 @@
     "tsdown": "^0.22.14",
     "tstyche": "^7.1.0",
     "vitest": "^4",
-    "@systemfsoftware/effect-gherkin-spec": "4.0.2",
     "@systemfsoftware/oxlint-config": "^0.1.0",
+    "@systemfsoftware/effect-gherkin-spec": "4.0.2",
     "@systemfsoftware/tsconfig": "^1.3.4",
     "@systemfsoftware/vitest-config": "^0.1.0"
   },