@systemfsoftware/effect-cell-types 5.0.2 → 6.0.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @systemfsoftware/effect-cell-types
 
+## 6.0.0
+
+### Major Changes
+
+- Cell is one sandwich: build it with `Cell.layer` and run it with `Cell.run`.
+
+  `Cell.apply` and the chained phase constructors (`Cell.read`, `Cell.decode`, `Cell.decide`, `Cell.encode`, `Cell.write`) are removed. `Cell.layer` takes one spec object — `{ read, decide, write }` rules on what the read produced, or add `decode` and `encode` together to adapt both sides of the decision.
+
+  Phase bodies that `yield*` a service publish it on the Cell's requirements channel; provide once with `Cell.provide` or `Effect.provide`. A missing provide is a compile error at the run site.
+
+  New arrows: `map`, `mapInput`, `andThen`, `zip`, `provide`, `withPolicy`. A refused decision reaches your write as the outcome value — only read, decode, and write failures fail the effect. The vocabulary drops `applier`.
+
+  `Cell.canonical`, `CanonicalCommand`, `canonicalDecide`, `PhaseFact`, and the vocabulary's `phases` list and `byKind.impure` partition are removed: the vocabulary is a const table (`module`, `ioCells`, `byKind.pure`, `composer`) and `PhaseName` is now exported. Nothing else read the walked surface; a rule that wants order reads the interpreter, not the table.
+
+- A `Cell` description is now exactly one sandwich: read, decode, decide, encode, write. The `layers` member and the `Layer` type are deleted, `Cell.read` no longer accepts a `previous` argument, and `Cell.apply` runs that single fold; multi-layer replay no longer exists.
+
+  `Cell.layer(spec)` is new: the same description built from one object. `{ read, decide, write }` composes with identity decode and encode; `{ read, decode, decide, encode, write }` is the full form. A spec with only one of decode/encode, or a short-form write that cannot receive the decide outcome, is a compile error.
+
+  The walked vocabulary now names its composing constructor as `Cell.vocabulary.composer`, alongside `applier`.
+
+  Migrating: two layers become two descriptions applied in sequence in the calling `Effect.gen`; a write already receives the read's value as its second parameter.
+
+- Workflow.make now requires the success channel to be a tagged union of at least two schema tagged classes sharing one family TypeId; single-variant, untagged, and unshared-brand decisions are compile errors naming the defect
+
 ## 5.0.2
 
 ### Patch Changes

package/README.md

@@ -15,11 +15,14 @@ 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 — `Cell.decide` and the `DecidePhase` it
-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 `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
 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).
+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
+not a tagged union of at least two schema tagged classes sharing one TypeId — a single
+outcome, an untagged variant, or variants with divergent family brands each resolve to a
+marker interface whose property name is the remediation.
 
 ## The constructor
 
@@ -134,14 +137,18 @@ rejected, not allowed.
 
 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 |
-| 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 `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                    |
 
 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:
 
@@ -153,7 +160,27 @@ export interface UninhabitedDecision {
 
 export interface UninhabitedError {
   readonly __WORKFLOW_ERROR_CHANNEL_IS_NEVER__:
-    'this workflow cannot fail, so it decides nothing; give it an error variant or move it to a *.kernel.ts'
+    'this workflow cannot fail, so it decides nothing; give it an error variant or fold the function into its owning module'
+}
+
+export 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'
+}
+
+export 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'
+}
+
+export 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'
+}
+
+export 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'
 }
 ```
 
@@ -211,7 +238,7 @@ const decide = Workflow.make(
 // tsc: Type 'Result<Decision, unknown>' is not assignable to type 'Result<Decision, Err>'
 ```
 
-If the workflow genuinely cannot fail, the error channel says so — and that is a `*.kernel.ts`, not a workflow.
+If the workflow genuinely cannot fail, the error channel says so — and that is a plain function inside its owning module, not a workflow.
 
 ## A wrong channel breaks the whole consumer cone
 

package/dist/index.d.ts

@@ -2,429 +2,203 @@ 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 * as Schema$1 from "effect/Schema";
 import { Schema } from "effect";
+import { Kind, TypeLambda } from "effect/HKT";
+import { Layer } from "effect/Layer";
+import * as Schema$1 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 Policy_d_exports {
+  export { Policy };
+}
+type Policy<A, E, R> = (self: Effect<A, E, R>) => Effect<A, E, R>;
 declare namespace Workflow_d_exports {
-  export { Inhabited, UninhabitedDecision, UninhabitedError, UntaggedError, Workflow, WorkflowBrand, make };
+  export { Inhabited, SingleVariantDecision, UninhabitedDecision, UninhabitedError, UnsharedTypeId, UntaggedDecision, UntaggedError, Workflow, WorkflowBrand, make };
 }
-/**
- * The nominal brand a workflow carries. `Workflow.make` is the only door that applies it,
- * and every surface that runs a decision — `Cell.decide`, and through it `DecideNode.run`
- * via the `DecidePhase` conjunct — demands it, so a bare decider that skipped `make` is
- * refused by the compiler at the call site that would have run it.
- *
- * The brand is phantom — a readonly TypeId-keyed field that no runtime property ever
- * backs: `assertWorkflow` narrows the same function value without touching it. The
- * `Symbol.for` key follows the repo's branded-class idiom (the instance brands in
- * `restart-decision.workflow.ts`, `hook-verdict.workflow.ts` and `survivors.workflow.ts`)
- * so it is stable across realms; this is the type-level brand that subsumes those
- * instance brands on the workflow shapes.
- */
 declare const WorkflowTypeId: unique symbol;
 type WorkflowTypeId = typeof WorkflowTypeId;
-/** The phantom property `Workflow<C,D,E>` and `Cell.DecidePhase<P>` carry. */
 interface WorkflowBrand {
   readonly [WorkflowTypeId]: WorkflowTypeId;
 }
-/**
- * Marker a workflow resolves to when its decision channel is `never`. The property type is the
- * fix, so the compiler diagnostic names it.
- */
 interface UninhabitedDecision {
   readonly __WORKFLOW_DECISION_CHANNEL_IS_NEVER__: 'this workflow can never succeed; give it a decision variant it can return';
 }
-/** Marker a workflow resolves to when its error channel is `never`. */
 interface UninhabitedError {
-  readonly __WORKFLOW_ERROR_CHANNEL_IS_NEVER__: 'this workflow cannot fail, so it decides nothing; give it an error variant or move it to a *.kernel.ts';
+  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';
 }
-/** Marker a workflow resolves to when its error channel carries no tag to dispatch on. */
 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';
 }
-/**
- * A decider whose channels are both inhabited, or the marker naming which channel is not.
- *
- * `[T] extends [never]` rather than `T extends never`: the tuple wrap stops distribution, without
- * which a `never` channel satisfies the conditional vacuously and is never caught.
- *
- * The inhabited branch carries the nominal brand: `Workflow.make` is the only constructor that
- * applies it, so a bare function annotated `Workflow<C, D, E>` is refused wherever the brand
- * is demanded — which is exactly where a decision gets run.
- */
+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 UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+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 SharedTypeId<D, I = UnionToIntersection<D>> = [keyof { [K in keyof I as I[K] extends K ? (D extends { readonly [P in K]: K; } ? K : never) : never]: 0; }] 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;
-/**
- * `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 : DispatchableTag<DecisionError>;
-/**
- * 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
- * conjunct is what an uninhabited channel fails to satisfy.
- *
- * `E` carries no constraint on purpose. Constraining it gives inference a fallback: where `E` would
- * infer as `never` TypeScript substitutes the constraint instead, the conditional takes its
- * inhabited branch, and a `never` channel passes. The tagged requirement therefore lives in
- * {@link Inhabited}, where nothing can stand in for `never`.
- *
- * 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<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.
- */
+type Inhabited<Decision, DecisionError> = [Decision] extends [never] ? UninhabitedDecision : [DecisionError] extends [never] ? UninhabitedError : DecisionShape<Decision> & DispatchableTag<DecisionError>;
 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 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 };
+  export { Cell, CellTypeId, DESCRIPTION_MODULE, IO_CELLS, IoCellClassification, Kind$1 as Kind, PhaseName, Run, TypeLambda$1 as TypeLambda, Vocabulary, andThen, layer, map, mapInput, provide, run, vocabulary, withPolicy, zip };
 }
 /**
- * The type bag. Every phase's input and output type travels in one record so that a
- * stage's own type arguments are identical across stages, which leaves the sentence
- * member as the only difference a diagnostic can report. Measured: with the payload
- * carried per-stage instead, the compiler reports the mismatch at the argument (TS2345)
- * and the sentence arrives only as a type argument; with the payload in one bag it
- * reports the missing member (TS2741) and the sentence is that member's name.
+ * The nominal brand every `Cell` carries. `Cell.layer` is the only door that applies it.
  */
-interface Phases {
-  readonly command: unknown;
-  readonly raw: unknown;
-  readonly decoded: unknown;
-  readonly decision: unknown;
-  readonly decisionError: unknown;
-  readonly output: unknown;
-  readonly response: unknown;
-  readonly decodeError: unknown;
-  readonly readError: unknown;
-  readonly writeError: unknown;
-}
+declare const CellTypeId: unique symbol;
 /**
- * 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`.
+ * The nominal brand type of {@link CellTypeId}.
  */
-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']>;
+type CellTypeId = typeof CellTypeId;
 /**
- * The decision. Its `Left` is an outcome, not a fault: both branches travel on to the write.
- *
- * The {@link WorkflowBrand} conjunct makes this the one surface a decision must cross
- * branded: only a `Workflow.make` value satisfies it, so a bare lambda handed here is
- * refused by the compiler with the brand conjunct named in the diagnostic. The `run` on
- * a `DecideNode` inherits the conjunct through this type, which keeps the interpreter's
- * fold sound — a description can only carry decisions that came through `make`.
+ * A Cell is one sandwich: a `read` that gathers, a `decide` that refuses or rules, and a
+ * `write` that acts — compiled into a single function from command to response. The `E`
+ * channel carries the infrastructure refusals; the `R` channel carries the services the
+ * phases `yield*`, provided once by the program's composition root.
  */
-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'];
+interface Cell<in I, out A, out E = never, out R = never> {
+  readonly [CellTypeId]: CellTypeId;
+  readonly run: (input: I) => Effect$1.Effect<A, E, R>;
+}
 /**
- * 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.
+ * The type lambda for {@link Cell}, admitting Cell to `Kind` positions.
  */
-type WritePhase<P extends Phases> = (output: P['output'], raw: P['raw']) => Effect$1.Effect<P['response'], P['writeError'], never>;
+interface TypeLambda$1 extends TypeLambda {
+  readonly type: Cell<this['In'], this['Target'], this['Out2'], this['Out1']>;
+}
 /**
- * The invocation shape a folding consumer must use to call a phase's `run`:
- * - `'effect'` — `run` returns an `Effect`; yield it. (read, write)
- * - `'either-fail'` — `run` returns a `Result` whose `Failure` is fatal; fail on `Failure`. (decode)
- * - `'either-pass'` — `run` returns a `Result` that travels forward whole. (decide)
- * - `'total'` — `run` is a plain total function; call it directly. (encode)
- *
- * This is structural data on the record, not one of the five axes: it lets an executing
- * consumer fold the description without knowing which phase it is looking at. The
- * interpreter's switch over `convention` is exhaustively defaulted, so a phase with an
- * invocation shape this module does not know fails at compile time at one named location.
+ * A fully-applied {@link Kind} for Cell: `Kind<I, E, R, A>` is `Cell<I, A, E, R>`.
  */
-type Convention = 'effect' | 'either-fail' | 'either-pass' | 'total';
+type Kind$1<I, E, R, A> = Kind<TypeLambda$1, I, E, R, A>;
 /**
- * One phase record: `name` (the phase name, as data), `kind` (purity), `convention`
- * (the invocation shape), and the phase's `run`. Each phase type has its own record
- * interface so `run` keeps its exact signature. Nothing here discriminates on `name`:
- * the interpreter dispatches on `convention`, and other consumers read `name` as data.
- * A hand-written `_tag` is deliberately absent — a manual `_tag` member is forbidden
- * here (the schema rule prescribes `TaggedStruct`, which cannot describe a function
- * member), and an ordered sequence of phase records is not a `Match`-style tagged union.
+ * The function shape a Cell publishes, read off the Cell type itself. Use it to type a
+ * capability parameter or a callback that hands a Cell's run to a shell:
+ * `Run<I, A, E, R>` is `Cell<I, A, E, R>['run']`.
  */
-interface ReadNode<P extends Phases> {
-  readonly name: 'read';
-  readonly kind: 'impure';
-  readonly convention: 'effect';
-  readonly run: ReadPhase<P>;
+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$1.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$1.Effect<Resp, WE, WR>;
 }
-interface DecodeNode<P extends Phases> {
-  readonly name: 'decode';
-  readonly kind: 'pure';
-  readonly convention: 'either-fail';
-  readonly run: DecodePhase<P>;
+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 DecideNode<P extends Phases> {
-  readonly name: 'decide';
-  readonly kind: 'pure';
-  readonly convention: 'either-pass';
-  readonly run: DecidePhase<P>;
+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$1.Effect<Resp, WE, WR>;
 }
-interface EncodeNode<P extends Phases> {
-  readonly name: 'encode';
-  readonly kind: 'pure';
-  readonly convention: 'total';
-  readonly run: EncodePhase<P>;
-}
-interface WriteNode<P extends Phases> {
-  readonly name: 'write';
-  readonly kind: 'impure';
-  readonly convention: 'effect';
-  readonly run: WritePhase<P>;
-}
-type Phase<P extends Phases> = ReadNode<P> | DecodeNode<P> | DecideNode<P> | EncodeNode<P> | WriteNode<P>;
-/**
- * One impure/pure layer: its phase records in intra-layer execution order. The order is
- * data — the interpreter folds this array and runs each record as its `convention`
- * says, holding no phase sequence of its own. The stage brands are what make a legal
- * description well-ordered at build time; the value's declared order is its execution
- * order.
- */
-interface Layer<P extends Phases> {
-  readonly phases: readonly Phase<P>[];
-}
-/** The description package's own module name — what an import edge would match. */
-declare const DESCRIPTION_MODULE: '@systemfsoftware/effect-cell-types';
 /**
- * The I/O-cell classification: the cells whose calls are I/O, plus the non-cell module
- * sources whose calls are I/O. Written once here; a consumer folds it off the value.
+ * 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 const IO_CELLS: {
-  readonly cells: readonly ['store', 'adapter'];
-  readonly sources: readonly ['effect/Clock', 'effect/System'];
+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>;
+declare const run: {
+  <I>(input: I): <A, E, R>(self: Cell<I, A, E, R>) => Effect$1.Effect<A, E, R>;
+  <I, A, E, R>(self: Cell<I, A, E, R>, input: I): Effect$1.Effect<A, E, R>;
 };
 /**
- * Derived from the value rather than restated beside it: a hand-written twin is a second
- * declaration of axis 5, and the two drift the moment a cell is reclassified in only one.
+ * Transforms the Cell's response.
  */
-type IoCellClassification = typeof IO_CELLS;
+declare const map: {
+  <A, B>(f: (a: A) => B): <I, E, R>(self: Cell<I, A, E, R>) => Cell<I, B, E, R>;
+  <I, A, E, R, B>(self: Cell<I, A, E, R>, f: (a: A) => B): Cell<I, B, E, R>;
+};
 /**
- * The description root, carried by every stage. A consumer folds a stage value to
- * recover the description's whole vocabulary: the phase names and kinds on each
- * record, the intra-layer order in each `phases` array, the package's own module
- * name, and the I/O-cell classification. Nothing about the shape of a legal
- * description is written down anywhere else.
+ * Transforms the Cell's input.
  */
-interface Description<P extends Phases> {
-  readonly module: typeof DESCRIPTION_MODULE;
-  readonly ioCells: IoCellClassification;
-  readonly layers: readonly Layer<P>[];
-}
+declare const mapInput: {
+  <I0, I>(f: (input: I0) => I): <A, E, R>(self: Cell<I, A, E, R>) => Cell<I0, A, E, R>;
+  <I0, I, A, E, R>(self: Cell<I, A, E, R>, f: (input: I0) => I): Cell<I0, A, E, R>;
+};
 /**
- * The stages are siblings, never a hierarchy. Each carries exactly the sentence naming the
- * call that must come next, and none extends another. Measured: under a hierarchy a later
- * stage is assignable to an earlier parameter, so an inversion — decoding what was already
- * decided — compiles. As siblings both the forward skip and the backward inversion are
- * rejected, each diagnostic naming the sentence it is missing.
- *
- * The carrier is deliberately the same type on every stage — `Description` — so the
- * compiler reports the argument rather than the member only when the carrier itself is
- * wrong, and the sentence stays the name a diagnostic reports.
+ * Feeds this Cell's response to the next Cell as its input. The error and service channels
+ * union.
  */
-interface ReadDone<P extends Phases> extends Description<P> {
-  readonly 'call read(command) before decode(raw)': true;
-}
-interface DecodeDone<P extends Phases> extends Description<P> {
-  readonly 'call decode(raw) before decide(decoded)': true;
-}
-interface DecideDone<P extends Phases> extends Description<P> {
-  readonly 'call decide(decoded) before encode(decision)': true;
-}
-interface EncodeDone<P extends Phases> extends Description<P> {
-  readonly 'call encode(decision) before write(output)': true;
-}
-/** Terminal. A description is applied from here, and a further layer opens from here. */
-interface WriteDone<P extends Phases> extends Description<P> {
-  readonly 'call write(output) before applying the description': true;
-}
+declare const andThen: {
+  <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>;
+};
 /**
- * Opens a layer. Passing a prior `WriteDone` opens a second layer over the same bag, so a
- * call site whose real order writes before it can classify is one description carrying two
- * layers rather than two descriptions composed by hand.
- *
- * This one is not dual: it starts the chain, so on the opening layer it has no `self` to
- * receive. Every phase after it is dual, which is what lets a description be written in the
- * order it runs.
+ * Runs both Cells against the same input and tuples the responses. Fails fast: when one
+ * side refuses, the other's write never runs.
  */
-declare const read: <P extends Phases>(run: ReadPhase<P>, previous?: WriteDone<P>) => ReadDone<P>;
+declare const zip: {
+  <I, B, E2, R2>(that: Cell<I, B, E2, R2>): <A, E, R>(self: Cell<I, A, E, R>) => Cell<I, readonly [A, B], E | E2, R | R2>;
+  <I, A, E, R, B, E2, R2>(self: Cell<I, A, E, R>, that: Cell<I, B, E2, R2>): Cell<I, readonly [A, B], E | E2, R | R2>;
+};
 /**
- * The chaining phases are dual, data-last overload declared first. Nesting the constructors
- * reads innermost-first — backwards from the order the phases run — which defeats the point of
- * a type that exists to make that order legible. In `pipe` the call site reads in phase order,
- * and the sentence still arrives as a missing member through it.
- *
- * A `Do`-notation scope binding each phase's result for later phases to read was measured as
- * an alternative: the sentence survives it, even with the scope varying per stage, because an
- * absent member is reported before type arguments are compared. It was not adopted, because a
- * scope the interpreter folds over is type-erased, and reading a phase back out of it needs an
- * assertion this design does not.
+ * 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.
  */
-declare const decode: {
-  <P extends Phases>(run: DecodePhase<P>): (previous: ReadDone<P>) => DecodeDone<P>;
-  <P extends Phases>(previous: ReadDone<P>, run: DecodePhase<P>): DecodeDone<P>;
-};
-declare const decide: {
-  <P extends Phases>(run: DecidePhase<P>): (previous: DecodeDone<P>) => DecideDone<P>;
-  <P extends Phases>(previous: DecodeDone<P>, run: DecidePhase<P>): DecideDone<P>;
-};
-declare const encode: {
-  <P extends Phases>(run: EncodePhase<P>): (previous: DecideDone<P>) => EncodeDone<P>;
-  <P extends Phases>(previous: DecideDone<P>, run: EncodePhase<P>): EncodeDone<P>;
-};
-declare const write: {
-  <P extends Phases>(run: WritePhase<P>): (previous: EncodeDone<P>) => WriteDone<P>;
-  <P extends Phases>(previous: EncodeDone<P>, run: WritePhase<P>): WriteDone<P>;
+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>>;
 };
 /**
- * Applies a description. The return type is deliberately not annotated: `gen` accumulates
- * `E` and `R` from the union of what is actually yielded, so an over-claimed channel is
- * unrepresentable rather than merely discouraged. Annotating it here would let this module
- * promise a failure that no phase can produce.
- *
- * The parameter keeps the terminal `WriteDone<P>` brand. It is not decoration: it is what
- * makes applying a half-built chain — a `ReadDone`, say — a compile error rather than a
- * runtime death, which `test-types/Cell.tst.ts` pins. The brand does not constrain the
- * phases array's order (a literal satisfies it in any order, which is why the interpreter
- * reads the order off the value), but it does constrain chain completion, and that is a
- * guarantee worth the narrower parameter.
- *
- * `forEach` takes no concurrency option here, so the layers run in declared order and the
- * sequence is structural rather than something a caller could pass differently; the
- * 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`.
+ * Wraps the Cell's run in a `Policy` — retry, timeout, and their kin — preserving every
+ * channel.
  */
-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'];
-  readonly kind: Phase<Phases>['kind'];
-  readonly convention: Convention;
-}
+declare const withPolicy: {
+  <A, E, R>(policy: Policy<A, E, R>): <I>(self: Cell<I, A, E, R>) => Cell<I, A, E, R>;
+  <I, A, E, R>(self: Cell<I, A, E, R>, policy: Policy<A, E, R>): Cell<I, A, E, R>;
+};
 /**
- * The five axes as data, for a consumer that has no description of its own to fold.
- *
- * `byKind` groups the walked phase names by their purity. It is here rather than left to
- * each consumer because which phases are pure is this module's own fact, and a consumer
- * that reconstructs it has to pick a proxy — inferring purity from the invocation shape,
- * say — which is a different axis and silently disagrees the moment a pure phase is given
- * an effectful shape or an impure one is not.
+ * 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.
  */
 interface Vocabulary {
   readonly module: typeof DESCRIPTION_MODULE;
   readonly ioCells: IoCellClassification;
-  readonly phases: readonly PhaseFact[];
-  readonly byKind: Readonly<Record<PhaseFact['kind'], readonly PhaseFact['name'][]>>;
-  /**
-   * The export that runs a finished description. A consumer deciding which calls on this module
-   * belong to a description needs the phases *and* the applier; without it the applier is the one
-   * name it has to write down for itself, and one restated name is enough to drift.
-   */
-  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;
+  readonly byKind: {
+    readonly pure: readonly PhaseName[];
+  };
+  readonly composer: 'layer';
 }
-/**
- * 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
- * obtain a real branded description without replaying the constructor chain: spread it
- * and substitute its phase records' `run`s. The records it carries are the same literals
- * the constructors write for real call sites, so the vocabulary below cannot drift from
- * them.
- *
- * Its order is not a choice this module makes. The stage brands admit exactly one chain, so
- * 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<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, mint, wire };
 }

package/dist/index.mjs

@@ -1,311 +1,107 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import * as Arr from "effect/Array";
 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", {});
+//#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({ make: () => make });
-/**
-* 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
-* conjunct is what an uninhabited channel fails to satisfy.
-*
-* `E` carries no constraint on purpose. Constraining it gives inference a fallback: where `E` would
-* infer as `never` TypeScript substitutes the constraint instead, the conditional takes its
-* inhabited branch, and a `never` channel passes. The tagged requirement therefore lives in
-* {@link Inhabited}, where nothing can stand in for `never`.
-*
-* 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<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 = (_command, decide) => {
+var Workflow_exports = /* @__PURE__ */ __exportAll({ make: () => make$1 });
+const make$1 = (_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(CanonicalCommand, (_command) => Result$1.succeed(void 0));
-//#endregion
 //#region src/Cell.ts
 var Cell_exports = /* @__PURE__ */ __exportAll({
+	CellTypeId: () => CellTypeId,
 	DESCRIPTION_MODULE: () => DESCRIPTION_MODULE,
 	IO_CELLS: () => IO_CELLS,
-	apply: () => apply,
-	canonical: () => canonical,
-	decide: () => decide,
-	decode: () => decode,
-	encode: () => encode,
-	read: () => read,
+	andThen: () => andThen,
+	layer: () => layer,
+	map: () => map,
+	mapInput: () => mapInput,
+	provide: () => provide,
+	run: () => run,
 	vocabulary: () => vocabulary,
-	write: () => write
+	withPolicy: () => withPolicy,
+	zip: () => zip
 });
-/** The description package's own module name — what an import edge would match. */
-const DESCRIPTION_MODULE = "@systemfsoftware/effect-cell-types";
 /**
-* The I/O-cell classification: the cells whose calls are I/O, plus the non-cell module
-* sources whose calls are I/O. Written once here; a consumer folds it off the value.
+* The nominal brand every `Cell` carries. `Cell.layer` is the only door that applies it.
 */
-const IO_CELLS = {
-	cells: ["store", "adapter"],
-	sources: ["effect/Clock", "effect/System"]
-};
-const READ_DONE = "call read(command) before decode(raw)";
-const DECODE_DONE = "call decode(raw) before decide(decoded)";
-const DECIDE_DONE = "call decide(decoded) before encode(decision)";
-const ENCODE_DONE = "call encode(decision) before write(output)";
-const WRITE_DONE = "call write(output) before applying the description";
-/** Replaces the open layer with itself plus one more phase record. */
-const intoOpenLayer = (description, phase) => {
-	const layers = description.layers;
-	const last = layers[layers.length - 1];
-	return {
-		module: description.module,
-		ioCells: description.ioCells,
-		layers: [...layers.slice(0, -1), {
-			...last,
-			phases: [...last?.phases ?? [], phase]
-		}]
-	};
-};
+const CellTypeId = Symbol.for("@systemfsoftware/effect-cell-types/Cell");
+const make = (run) => ({
+	[CellTypeId]: CellTypeId,
+	run
+});
 /**
-* Opens a layer. Passing a prior `WriteDone` opens a second layer over the same bag, so a
-* call site whose real order writes before it can classify is one description carrying two
-* layers rather than two descriptions composed by hand.
-*
-* This one is not dual: it starts the chain, so on the opening layer it has no `self` to
-* receive. Every phase after it is dual, which is what lets a description be written in the
-* order it runs.
+* 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 read = (run, previous) => ({
-	[READ_DONE]: true,
-	module: DESCRIPTION_MODULE,
-	ioCells: IO_CELLS,
-	layers: [...previous?.layers ?? [], { phases: [{
-		name: "read",
-		kind: "impure",
-		convention: "effect",
-		run
-	}] }]
-});
+const layerRunner = (spec) => {
+	if ("decode" in spec && "encode" in spec) return (input) => Effect$1.gen(function* () {
+		const raw = yield* spec.read(input);
+		const decoded = yield* Result$1.match(spec.decode(raw), {
+			onFailure: Effect$1.fail,
+			onSuccess: Effect$1.succeed
+		});
+		const outcome = spec.decide(decoded);
+		return yield* spec.write(spec.encode(outcome), raw);
+	});
+	return (input) => Effect$1.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));
+}
+const run = dual(2, (self, input) => self.run(input));
 /**
-* The chaining phases are dual, data-last overload declared first. Nesting the constructors
-* reads innermost-first — backwards from the order the phases run — which defeats the point of
-* a type that exists to make that order legible. In `pipe` the call site reads in phase order,
-* and the sentence still arrives as a missing member through it.
-*
-* A `Do`-notation scope binding each phase's result for later phases to read was measured as
-* an alternative: the sentence survives it, even with the scope varying per stage, because an
-* absent member is reported before type arguments are compared. It was not adopted, because a
-* scope the interpreter folds over is type-erased, and reading a phase back out of it needs an
-* assertion this design does not.
+* Transforms the Cell's response.
 */
-const decode = dual(2, (previous, run) => ({
-	[DECODE_DONE]: true,
-	...intoOpenLayer(previous, {
-		name: "decode",
-		kind: "pure",
-		convention: "either-fail",
-		run
-	})
-}));
-const decide = dual(2, (previous, run) => ({
-	[DECIDE_DONE]: true,
-	...intoOpenLayer(previous, {
-		name: "decide",
-		kind: "pure",
-		convention: "either-pass",
-		run
-	})
-}));
-const encode = dual(2, (previous, run) => ({
-	[ENCODE_DONE]: true,
-	...intoOpenLayer(previous, {
-		name: "encode",
-		kind: "pure",
-		convention: "total",
-		run
-	})
-}));
-const write = dual(2, (previous, run) => ({
-	[WRITE_DONE]: true,
-	...intoOpenLayer(previous, {
-		name: "write",
-		kind: "impure",
-		convention: "effect",
-		run
-	})
-}));
+const map = dual(2, (self, f) => make((input) => Effect$1.map(self.run(input), f)));
 /**
-* The runtime guard that lets the `'total'` case call `EncodePhase` soundly: an encode
-* phase is chained only after a decide, so the value reaching it is the outcome `Result`
-* and `Result.isResult` certifies exactly that. The specific `decision`/`decisionError`
-* members are not observable at runtime, so the guard narrows to them by construction —
-* the same trust the fold places in the chain's order.
+* Transforms the Cell's input.
 */
-const isOutcome = (value) => Result$1.isResult(value);
+const mapInput = dual(2, (self, f) => make((input) => self.run(f(input))));
 /**
-* Runs one layer as the sandwich the value declares: the phase records run in array
-* order, each dispatched on its carried `convention`. There is no phase sequence here —
-* the order is the `phases` array and the invocation shape is the `convention` field,
-* so a description's declared order IS its execution order. The convention switch is
-* exhaustive over the union via its `never` default: a future phase with an invocation
-* shape this module does not know fails at compile time, at this one location.
-*
-* The two `Failure` rules are carried by the phase types rather than chosen here. A `decode`
-* Failure has no downstream consumer — nothing accepts `decodeError` — so its only route is a
-* failure, which is what puts it in the derived error channel. A `decide` Failure cannot be
-* unwrapped, because `EncodePhase` takes the whole `Result`, so its only route is forward as
-* a value. Neither is a decision the interpreter makes.
-*
-* Every layer reachable from a `WriteDone` was built by the five constructors in order, so
-* its last phase is a write and every slot is filled. A layer that is nonetheless empty or
-* not closed by a write is a defect in this module, never a domain outcome, so it dies —
-* the same guard the name-keyed layer used for unfilled slots. `Effect.die` returns
-* `Effect<never>`, which is why the guards cost the derived `E` and `R` nothing.
+* Feeds this Cell's response to the next Cell as its input. The error and service channels
+* union.
 */
-const runLayer = (layer, command) => Effect$1.gen(function* () {
-	const phases = layer.phases;
-	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":
-			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), {
-				onFailure: Effect$1.fail,
-				onSuccess: Effect$1.succeed
-			});
-			break;
-		case "either-pass":
-			value = phase.run(value);
-			break;
-		case "total":
-			if (!isOutcome(value)) return yield* Effect$1.die(/* @__PURE__ */ new Error("effect-cell-types: an encode phase received a value that is not the decide outcome"));
-			value = phase.run(value);
-			break;
-		default: {
-			const unreachable = phase;
-			return yield* Effect$1.die(/* @__PURE__ */ new Error(`effect-cell-types: unknown phase convention ${String(unreachable)}`));
-		}
-	}
-	return yield* last.run(value, raw);
-});
+const andThen = dual(2, (self, that) => make((input) => Effect$1.flatMap(self.run(input), (response) => that.run(response))));
 /**
-* Applies a description. The return type is deliberately not annotated: `gen` accumulates
-* `E` and `R` from the union of what is actually yielded, so an over-claimed channel is
-* unrepresentable rather than merely discouraged. Annotating it here would let this module
-* promise a failure that no phase can produce.
-*
-* The parameter keeps the terminal `WriteDone<P>` brand. It is not decoration: it is what
-* makes applying a half-built chain — a `ReadDone`, say — a compile error rather than a
-* runtime death, which `test-types/Cell.tst.ts` pins. The brand does not constrain the
-* phases array's order (a literal satisfies it in any order, which is why the interpreter
-* reads the order off the value), but it does constrain chain completion, and that is a
-* guarantee worth the narrower parameter.
-*
-* `forEach` takes no concurrency option here, so the layers run in declared order and the
-* sequence is structural rather than something a caller could pass differently; the
-* 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`.
+* Runs both Cells against the same input and tuples the responses. Fails fast: when one
+* side refuses, the other's write never runs.
 */
-const apply = (description, command) => Effect$1.gen(function* () {
-	const responses = yield* Effect$1.forEach(description.layers, (layer) => runLayer(layer, command));
-	return yield* Option.match(Arr.last(responses), {
-		onNone: () => Effect$1.die(/* @__PURE__ */ new Error("effect-cell-types: a description reached the interpreter with no layers")),
-		onSome: Effect$1.succeed
-	});
-});
+const zip = dual(2, (self, that) => make((input) => Effect$1.zipWith(self.run(input), that.run(input), (a, b) => [a, b])));
 /**
-* 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
-* obtain a real branded description without replaying the constructor chain: spread it
-* and substitute its phase records' `run`s. The records it carries are the same literals
-* the constructors write for real call sites, so the vocabulary below cannot drift from
-* them.
-*
-* Its order is not a choice this module makes. The stage brands admit exactly one chain, so
-* 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.
+* 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 canonical = write(encode(decide(decode(read(() => Effect$1.void), () => Result$1.succeed(CanonicalCommand.make({}))), canonicalDecide), () => void 0), () => Effect$1.void);
+const provide = dual(2, (self, layer) => make((input) => Effect$1.provide(self.run(input), layer)));
 /**
-* 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
-* from here instead of restating them, so there is one place a phase is described and the
-* description is the place.
+* Wraps the Cell's run in a `Policy` — retry, timeout, and their kin — preserving every
+* channel.
 */
-const WALKED_PHASES = Arr.flatMap(canonical.layers, (layer) => layer.phases.map(({ convention, kind, name }) => ({
-	convention,
-	kind,
-	name
-})));
+const withPolicy = dual(2, (self, policy) => make((input) => policy(self.run(input))));
 const vocabulary = {
-	module: canonical.module,
-	ioCells: canonical.ioCells,
-	phases: WALKED_PHASES,
-	byKind: {
-		pure: WALKED_PHASES.filter((phase) => phase.kind === "pure").map((phase) => phase.name),
-		impure: WALKED_PHASES.filter((phase) => phase.kind === "impure").map((phase) => phase.name)
-	},
-	applier: "apply"
+	module: DESCRIPTION_MODULE,
+	ioCells: IO_CELLS,
+	byKind: { pure: [
+		"decode",
+		"decide",
+		"encode"
+	] },
+	composer: "layer"
 };
 //#endregion
 //#region src/Policy.ts
@@ -348,8 +144,10 @@ var Wire_exports = /* @__PURE__ */ __exportAll({
 * the schema library can express, including a vendor's own schema — deliberately.
 */
 const mint = (field) => {
+	assertMinted(field);
 	return field;
 };
+function assertMinted(_field) {}
 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": "5.0.2",
+  "version": "6.0.0",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
@@ -10,7 +10,7 @@
   },
   "homepage": "https://github.com/systemfsoftware/systemfsoftware/tree/main/packages/core/effect/cell/types#readme",
   "bugs": "https://github.com/systemfsoftware/systemfsoftware/issues",
-  "description": "Type-level contracts for the repo's cell taxonomy, starting with the Workflow decision channel — branded Workflow<C, D, E> types plus a runtime make constructor every effect kernel can share.",
+  "description": "Type-level contracts for the repo's cell taxonomy, starting with the Workflow decision channel — branded Workflow<C, D, E> types plus a runtime make constructor shared across the repo's cells.",
   "keywords": [
     "effect",
     "effect-ts",