@systemfsoftware/effect-cell-types 3.0.0 → 4.0.0

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @systemfsoftware/effect-cell-types
 
+## 4.0.0
+
+### Major Changes
+
+- `Workflow.make` now takes two arguments: the command's schema class first, the decider second.
+
+  To migrate, declare the command as a `Schema.Class` or `Schema.TaggedClass` and pass it first. The decider's parameter type is inferred from that class, so its annotation can be dropped. A plain interface, a type alias, an object literal, a `Schema.Struct` and a primitive are all refused at the command position — an interface produces no value to pass, and the others are not schema classes.
+
+  The decider's own contract is unchanged: it still returns a `Result`, and a decision channel of `never`, an error channel of `never`, or an error channel carrying no tag are refused as before.
+
+- `Tagged` no longer ships in the `Workflow` namespace.
+
+  The requirement it expressed is unchanged: a decision error must still carry a tag the consumer can
+  dispatch on, and `UntaggedError` still names the failure when one does not. Replace an annotation
+  that referred to `Workflow.Tagged` with the concrete error type, or with a `Schema.TaggedError`
+  class, which satisfies the channel directly.
+
+### Patch Changes
+
+- The peer requirements for `effect` and for the Effect test-runner integration now accept any compatible `4.0.0-rc` release, instead of demanding one exact release candidate.
+
+  Installing alongside a newer release candidate no longer reports an unmet peer dependency or resolves a second copy of `effect` into the dependency tree.
+
 ## 3.0.0
 
 ### Major Changes

package/README.md

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

package/dist/index.d.ts

@@ -2,9 +2,10 @@ import * as Effect$1 from "effect/Effect";
 import { Effect } from "effect/Effect";
 import * as Result$1 from "effect/Result";
 import { Result } from "effect/Result";
+import * as Schema$1 from "effect/Schema";
 import { Schema, SchemaAST } from "effect";
 declare namespace Workflow_d_exports {
-  export { Inhabited, Tagged, UninhabitedDecision, UninhabitedError, UntaggedError, Workflow, WorkflowBrand, make };
+  export { Inhabited, UninhabitedDecision, UninhabitedError, UntaggedError, Workflow, WorkflowBrand, make };
 }
 /**
  * The nominal brand a workflow carries. `Workflow.make` is the only door that applies it,
@@ -40,10 +41,6 @@ interface UninhabitedError {
 interface UntaggedError {
   readonly __WORKFLOW_ERROR_CHANNEL_CARRIES_NO_TAG__: 'this error carries no _tag the consumer can dispatch on; declare it as an S.TaggedError';
 }
-/** The shape an error channel must have: a tag the consumer dispatches on. */
-interface Tagged {
-  readonly _tag: string;
-}
 /**
  * A decider whose channels are both inhabited, or the marker naming which channel is not.
  *
@@ -56,15 +53,48 @@ interface Tagged {
  */
 type Workflow<Command, Decision, DecisionError> = [Decision] extends [never] ? UninhabitedDecision : [DecisionError] extends [never] ? UninhabitedError : ((command: Command) => Result<Decision, DecisionError>) & WorkflowBrand;
 /**
- * `unknown` when both channels are inhabited and the error carries a tag, so the intersection in
- * {@link make} collapses to the plain `Result` and neither inference nor the authoring surface
- * changes. Otherwise the marker the author must satisfy, which they cannot, which is the point.
+ * `unknown` when the error channel carries a tag a consumer can dispatch on, the {@link UntaggedError}
+ * marker otherwise. Two steps, both load-bearing: `'_tag' extends keyof E` asks whether the key is
+ * there, and `[E['_tag']] extends [string]` asks whether what it holds is dispatchable. Key presence
+ * alone admits `_tag: number`, `_tag?: string` and a `_tag()` method — none of which `Match.tag` can
+ * dispatch on, which is exactly what the marker claims to refuse.
+ *
+ * Both steps read the tag through `keyof` and an indexed access rather than declaring a `_tag`
+ * member, which is why the erased `Tagged` interface cannot come back: stating the requirement as a
+ * shape would write the very member this repo forbids.
+ */
+type DispatchableTag<E> = '_tag' extends keyof E ? [E['_tag']] extends [string] ? unknown : UntaggedError : UntaggedError;
+/**
+ * `unknown` when both channels are inhabited and the error carries a dispatchable tag, so the
+ * intersection in {@link make} collapses to the plain `Result` and neither inference nor the
+ * authoring surface changes. Otherwise the marker the author must satisfy, which they cannot, which
+ * is the point.
  */
-type Inhabited<Decision, DecisionError> = [Decision] extends [never] ? UninhabitedDecision : [DecisionError] extends [never] ? UninhabitedError : [DecisionError] extends [Tagged] ? unknown : UntaggedError;
+type Inhabited<Decision, DecisionError> = [Decision] extends [never] ? UninhabitedDecision : [DecisionError] extends [never] ? UninhabitedError : DispatchableTag<DecisionError>;
 /**
- * Builds a workflow, refusing an uninhabited or untagged channel at this call rather than at
+ * Builds a workflow from the command's schema class and a decider over that class's
+ * instance type, refusing an uninhabited or untagged channel at this call rather than at
  * whoever first calls the result — which for a workflow nothing calls yet is never.
  *
+ * The command is constrained on the **value**, not on a type parameter inferred from the
+ * decider's parameter. That is the whole mechanism. Any constraint on such a parameter is a
+ * structural predicate, and TypeScript cannot say "this type came from a class declaration"
+ * — so a marker placed there is a property, every property is declarable, and
+ * `interface Fake extends Marker {}` satisfies it. A declared type produces no value, so it
+ * cannot reach an argument position at all: there is no marker to smuggle because there is
+ * no marker.
+ *
+ * The three parameters mirror `Schema.Class`'s own bound exactly, and that is load-bearing.
+ * `Class<Self, S, Inherited>` places `S` in both covariant (`S["Type"]`) and contravariant
+ * (`S["fields"]`) positions, so it is invariant in `S`: every *fixed* spelling —
+ * `Class<unknown, Struct<Struct.Fields>, unknown>` and its variants — rejects real command
+ * classes. Generic over `S` accepts them and still refuses a `Struct`, which lacks
+ * `identifier` and `extend`. `Class<any, any, any>` also works and is banned here.
+ *
+ * `Schema.TaggedClass` returns this same `Class` interface, so one constraint covers both
+ * factories with no union. The import is type-only: this package gains no runtime dependency
+ * on Effect Schema, and `make` stays the identity function it always was.
+ *
  * The markers ride the parameter function's return type, not the parameter as `Workflow<C, D, E>`:
  * a conditional type in parameter position resolves `D` and `E` to `unknown` and the markers become
  * unreachable. On the return type both still infer from the `Result` conjunct while the marker
@@ -78,13 +108,28 @@ type Inhabited<Decision, DecisionError> = [Decision] extends [never] ? Uninhabit
  * The narrowing goes through an assertion signature rather than an `as` cast: every narrowing
  * assertion trips `typescript(no-unsafe-type-assertion)`, and a suppression comment would hide the
  * one place this file could lie. It is sound rather than merely permitted — with both channels
- * inhabited `Workflow<C, D, E>` is `(command: C) => Result<D, E>` carrying the {@link WorkflowBrand}
- * conjunct, and otherwise the return type is a marker with no call signature, so the value handed
- * back is unobservable through it. The brand is applied here and nowhere else: the assertion adds
- * no runtime property, so `make` stays the identity function it always was, yet a value that did
- * not pass through this door fails the conjunct wherever a decision is run.
+ * inhabited `Workflow<Self, D, E>` is `(command: Self) => Result<D, E>` carrying the
+ * {@link WorkflowBrand} conjunct, and otherwise the return type is a marker with no call
+ * signature, so the value handed back is unobservable through it. The brand is applied here and
+ * nowhere else: the assertion adds no runtime property, yet a value that did not pass through this
+ * door fails the conjunct wherever a decision is run.
  */
-declare const make: <C, D, E>(decide: (command: C) => Result<D, E> & Inhabited<D, E>) => Workflow<C, D, E>;
+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 };
 }
@@ -333,6 +378,16 @@ interface Vocabulary {
    */
   readonly applier: 'apply';
 }
+/**
+ * The bag the canonical description is built with. It is `Phases` with one member
+ * pinned: `decoded` is the canonical command class, because `canonicalDecide` is a
+ * decider over that class and a decider's parameter is contravariant — a phase typed
+ * `(decoded: unknown) => …` would demand that `unknown` be assignable to the command,
+ * which it is not. Every other member stays `unknown`, so nothing else narrows.
+ */
+interface CanonicalPhases extends Phases {
+  readonly decoded: CanonicalCommand;
+}
 /**
  * A canonical description, built through the public constructors with phases that do
  * nothing. It is exported so a consumer — a generator, a lint rule, a documenter — can
@@ -345,7 +400,7 @@ interface Vocabulary {
  * any other sequence fails to typecheck here — which is what keeps the derived order
  * non-circular: it is read off a value, and the value's shape is enforced by the types.
  */
-declare const canonical: WriteDone<Phases>;
+declare const canonical: WriteDone<CanonicalPhases>;
 declare const vocabulary: Vocabulary;
 declare namespace Policy_d_exports {
   export { Policy };

package/dist/index.mjs

@@ -4,13 +4,36 @@ import * as Effect$1 from "effect/Effect";
 import { dual } from "effect/Function";
 import * as Option from "effect/Option";
 import * as Result$1 from "effect/Result";
+import * as S from "effect/Schema";
 import { Schema } from "effect";
+S.TaggedError()("CanonicalDecideError", {});
+//#endregion
 //#region src/Workflow.ts
 var Workflow_exports = /* @__PURE__ */ __exportAll({ make: () => make });
 /**
-* Builds a workflow, refusing an uninhabited or untagged channel at this call rather than at
+* Builds a workflow from the command's schema class and a decider over that class's
+* instance type, refusing an uninhabited or untagged channel at this call rather than at
 * whoever first calls the result — which for a workflow nothing calls yet is never.
 *
+* The command is constrained on the **value**, not on a type parameter inferred from the
+* decider's parameter. That is the whole mechanism. Any constraint on such a parameter is a
+* structural predicate, and TypeScript cannot say "this type came from a class declaration"
+* — so a marker placed there is a property, every property is declarable, and
+* `interface Fake extends Marker {}` satisfies it. A declared type produces no value, so it
+* cannot reach an argument position at all: there is no marker to smuggle because there is
+* no marker.
+*
+* The three parameters mirror `Schema.Class`'s own bound exactly, and that is load-bearing.
+* `Class<Self, S, Inherited>` places `S` in both covariant (`S["Type"]`) and contravariant
+* (`S["fields"]`) positions, so it is invariant in `S`: every *fixed* spelling —
+* `Class<unknown, Struct<Struct.Fields>, unknown>` and its variants — rejects real command
+* classes. Generic over `S` accepts them and still refuses a `Struct`, which lacks
+* `identifier` and `extend`. `Class<any, any, any>` also works and is banned here.
+*
+* `Schema.TaggedClass` returns this same `Class` interface, so one constraint covers both
+* factories with no union. The import is type-only: this package gains no runtime dependency
+* on Effect Schema, and `make` stays the identity function it always was.
+*
 * The markers ride the parameter function's return type, not the parameter as `Workflow<C, D, E>`:
 * a conditional type in parameter position resolves `D` and `E` to `unknown` and the markers become
 * unreachable. On the return type both still infer from the `Result` conjunct while the marker
@@ -24,24 +47,34 @@ var Workflow_exports = /* @__PURE__ */ __exportAll({ make: () => make });
 * The narrowing goes through an assertion signature rather than an `as` cast: every narrowing
 * assertion trips `typescript(no-unsafe-type-assertion)`, and a suppression comment would hide the
 * one place this file could lie. It is sound rather than merely permitted — with both channels
-* inhabited `Workflow<C, D, E>` is `(command: C) => Result<D, E>` carrying the {@link WorkflowBrand}
-* conjunct, and otherwise the return type is a marker with no call signature, so the value handed
-* back is unobservable through it. The brand is applied here and nowhere else: the assertion adds
-* no runtime property, so `make` stays the identity function it always was, yet a value that did
-* not pass through this door fails the conjunct wherever a decision is run.
+* inhabited `Workflow<Self, D, E>` is `(command: Self) => Result<D, E>` carrying the
+* {@link WorkflowBrand} conjunct, and otherwise the return type is a marker with no call
+* signature, so the value handed back is unobservable through it. The brand is applied here and
+* nowhere else: the assertion adds no runtime property, yet a value that did not pass through this
+* door fails the conjunct wherever a decision is run.
 */
-const make = (decide) => {
+const make = (_command, decide) => {
 	return decide;
 };
 //#endregion
 //#region src/CanonicalDecide.workflow.ts
 /**
+* The canonical command. `Workflow.make` constrains its first argument to a real
+* schema class, so the canonical description needs one too — it carries no fields
+* because the canonical's phases do nothing, and its only job is to be a genuine
+* command value rather than a shape asserted into place.
+*
+* It is declared here rather than in a `*.schema.ts` because this is the owning
+* single-segment `<stem>.workflow.ts`, which `schema-declaration-location` admits.
+*/
+var CanonicalCommand = class extends S.TaggedClass()("CanonicalCommand", {}) {};
+/**
 * The canonical decider. Extracted so `make-file-location` only sees it inside a
 * single-segment `.workflow.ts` file, satisfying the restored taxonomy while
 * preserving the exact phantom-channel contract the `DecidePhase` brand and
 * the interpreter rely on.
 */
-const canonicalDecide = make((_decoded) => Result$1.succeed(void 0));
+const canonicalDecide = make(CanonicalCommand, (_command) => Result$1.succeed(void 0));
 //#endregion
 //#region src/Cell.ts
 var Cell_exports = /* @__PURE__ */ __exportAll({
@@ -246,7 +279,7 @@ const apply = (description, command) => Effect$1.gen(function* () {
 * any other sequence fails to typecheck here — which is what keeps the derived order
 * non-circular: it is read off a value, and the value's shape is enforced by the types.
 */
-const canonical = write(encode(decide(decode(read(() => Effect$1.void), () => Result$1.succeed(void 0)), canonicalDecide), () => void 0), () => Effect$1.void);
+const canonical = write(encode(decide(decode(read(() => Effect$1.void), () => Result$1.succeed(CanonicalCommand.make({}))), canonicalDecide), () => void 0), () => Effect$1.void);
 /**
 * The phase vocabulary, obtained by walking `canonical`. A consumer that needs the phase
 * names, their purity, or their order — a lint rule, a generator, a document — reads them
@@ -324,10 +357,8 @@ var Wire_exports = /* @__PURE__ */ __exportAll({
 * preserved, so a marked struct stays a struct and Effect's inference keeps working.
 */
 const mint = (field) => {
-	assertMinted(field);
 	return field;
 };
-function assertMinted(_field) {}
 const string = mint(Schema.String);
 const number = mint(Schema.Finite);
 const boolean = mint(Schema.Boolean);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@systemfsoftware/effect-cell-types",
   "license": "Apache-2.0",
-  "version": "3.0.0",
+  "version": "4.0.0",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
@@ -32,23 +32,23 @@
     "dist"
   ],
   "devDependencies": {
-    "@effect/vitest": "4.0.0-rc.108",
+    "@effect/vitest": "4.0.0-rc.111",
     "@microsoft/api-extractor": "^7.58.7",
     "@systemfsoftware/arethetypeswrong-cli": "^1.1.1",
     "@types/node": "^24",
-    "effect": "4.0.0-rc.108",
+    "effect": "4.0.0-rc.111",
     "oxlint": "^1.77.0",
     "rimraf": "^6.1.3",
     "tsdown": "^0.22.14",
     "tstyche": "^7.1.0",
     "vitest": "^4.1.10",
-    "@systemfsoftware/effect-gherkin-spec": "2.0.0",
+    "@systemfsoftware/effect-gherkin-spec": "2.0.1",
+    "@systemfsoftware/oxlint-config": "^0.1.0",
     "@systemfsoftware/vitest-config": "^0.1.0",
-    "@systemfsoftware/tsconfig": "^1.3.3",
-    "@systemfsoftware/oxlint-config": "^0.1.0"
+    "@systemfsoftware/tsconfig": "^1.3.3"
   },
   "peerDependencies": {
-    "effect": "4.0.0-rc.108"
+    "effect": "^4.0.0-rc.111"
   },
   "publishConfig": {
     "provenance": true