@systemfsoftware/effect-cell-types 7.0.1 → 8.1.0

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # @systemfsoftware/effect-cell-types
 
+## 8.1.0
+
+### Minor Changes
+
+- `collectAll` now declares an error channel of `never`: the composed cell cannot fail, because every per-item refusal is delivered to the fold as a `Result`. Composed cells no longer carry the item error channel in their type.
+
+  `Workflow.andThen` now composes two total workflows (components whose error channel is `never`) into a total workflow. Error-carrying chains are unchanged.
+
+  `Workflow.make` and `Workflow.total` now refuse decision unions whose variants declare the family brand as a narrow unique-symbol type instead of the documented class-field idiom. Declare the brand as a `readonly [T] = T` field on each `S.TaggedClass` variant: the field initializer widens the slot to the general `symbol` type, and the predicate keys on that widened slot. A `typeof`-annotated slot stays narrow and is refused with `UnsharedTypeId` — including the idiom hand-written as an interface. An interface annotating the slot as plain `symbol` is structurally identical to the class idiom and is accepted.
+
+## 8.0.0
+
+### Major Changes
+
+- The exported `Cell.run` helper is removed. Run a cell through its own arrow instead: `cell.run(input)` replaces `Cell.run(cell, input)`, in both the data-first and the curried form. The helper only forwarded to that arrow, so a migrated call site behaves identically.
+
+  The `Policy` type and `Cell.withPolicy` are removed. An execution strategy — retry, timeout, a restart cap — belongs to the interpreter: it is the only place that knows the write's idempotence and the deadline, and a strategy declared on the published value imposed re-execution of side effects on every consumer. Wrap the run at the edge with Effect's own combinators instead: `Effect.retry(cell.run(input), { times })`.
+
+### Minor Changes
+
+- `Cell.gate` runs one Cell only when another's response carries a value: the value admits it to the inner Cell and the composed response wraps the inner response, carrying nothing skips the inner Cell entirely, and both Cells' error and service channels union.
+
+  `Cell.collect` runs one Cell per item, in order, then folds the responses with a plain function. The first refusal fails the composed Cell with that item's own refusal. `Cell.collectAll` is the accumulate opt-in: an item's refusal travels to the fold as data, so the fold always runs over every result.
+
+  Both combinators are callable in the curried and data-first styles, and neither requires a workflow brand at its call site.
+
+- Two constructors join `Workflow.make`.
+
+  `Workflow.total` brands a decision that cannot fail. A decider whose error channel is `never` no
+  longer becomes a workflow that cannot be called; it carries the workflow brand and is accepted
+  wherever a branded decision is, including `Cell.layer`'s `decide` slot. Like `make`, it takes the
+  command schema class first, and it still refuses a decision with a single variant or a variant
+  carrying no `_tag` to dispatch on.
+
+  `Workflow.andThen` chains two workflows. The first workflow's decision becomes the second workflow's
+  command, the composed workflow's error channel is the union of both components, and a refusal from
+  the first short-circuits — the second never runs. The second workflow's command class is passed as a
+  value, so the composed signature carries no adapter function.
+
 ## 7.0.1
 
 ### Patch Changes

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import * as Effect$1 from "effect/Effect";
-import { Effect } from "effect/Effect";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
 import * as Result$1 from "effect/Result";
 import { Result } from "effect/Result";
 import { Kind, TypeLambda } from "effect/HKT";
@@ -13,12 +13,8 @@ declare const IO_CELLS: {
 };
 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, SingleVariantDecision, UninhabitedDecision, UninhabitedError, UnsharedTypeId, UntaggedDecision, UntaggedError, Workflow, WorkflowBrand, make };
+  export { Inhabited, SingleVariantDecision, UninhabitedDecision, UninhabitedError, UnsharedTypeId, UntaggedDecision, UntaggedError, Workflow, WorkflowBrand, andThen$1 as andThen, make, total };
 }
 declare const WorkflowTypeId: unique symbol;
 type WorkflowTypeId = typeof WorkflowTypeId;
@@ -43,10 +39,11 @@ interface UntaggedDecision {
 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 MutuallyAssignable<A, B> = [A] extends [B] ? ([B] extends [A] ? true : false) : false;
+type BrandSlotIsTheGeneralSymbol<D, K extends PropertyKey> = D extends unknown ? K extends keyof D ? MutuallyAssignable<D[K], symbol> : false : never;
+type SharedTypeId<D> = [{ [K in keyof D]: [K] extends [symbol] ? ([BrandSlotIsTheGeneralSymbol<D, K>] extends [true] ? K : never) : never; }[keyof D]] extends [never] ? UnsharedTypeId : unknown;
 type DecisionShape<D> = [unknown] extends [D] ? unknown : AtLeastTwoDistinct<D> extends false ? SingleVariantDecision : boolean extends TaggedMembers<D> ? UntaggedDecision : SharedTypeId<D>;
 type Workflow<Command, Decision, DecisionError> = [Decision] extends [never] ? UninhabitedDecision : [DecisionError] extends [never] ? UninhabitedError : ((command: Command) => Result<Decision, DecisionError>) & WorkflowBrand;
 type DispatchableTag<E> = '_tag' extends keyof E ? [E['_tag']] extends [string] ? unknown : UntaggedError : UntaggedError;
@@ -54,8 +51,40 @@ type Inhabited<Decision, DecisionError> = [Decision] extends [never] ? Uninhabit
 declare const make: <Self, S extends Schema.Constraint & {
   readonly fields: Schema.Struct.Fields;
 }, Inherited, D, E>(_command: Schema.Class<Self, S, Inherited>, decide: (command: Self) => Result<D, E> & Inhabited<D, E>) => Workflow<Self, D, E>;
+/**
+ * Brands a decision that cannot fail. `make` refuses a `never` error channel outright
+ * (`UninhabitedError`); this is the door for the decider that genuinely decides everything.
+ * The decision must still choose between at least two tagged variants sharing one TypeId, so
+ * `SingleVariantDecision`, `UntaggedDecision`, and `UnsharedTypeId` still fire.
+ *
+ * The command schema class comes first, exactly as in {@link make}, so the command channel
+ * stays pinned to the class rather than an inferred annotation. The decider's return carries
+ * `DecisionShape` written out: the `Workflow` alias is a deferred conditional, and in
+ * parameter position it collapses the whole parameter to `unknown` while the decision
+ * channel is still generic.
+ */
+declare const total: <Self, S extends Schema.Constraint & {
+  readonly fields: Schema.Struct.Fields;
+}, Inherited, D>(_command: Schema.Class<Self, S, Inherited>, decide: (command: Self) => Result<D, never> & DecisionShape<D>) => ((command: Self) => Result<D, never>) & WorkflowBrand;
+/**
+ * Composes two workflows: what the upstream decides becomes the command the downstream decides
+ * on, and a refusal short-circuits the pair. The return type dispatches on the component error
+ * union — two components that cannot fail publish the total form, because the `Workflow` alias
+ * refuses a `never` channel; a carried error publishes the union as before.
+ */
+declare const andThen$1: <Ctx, SelfA, SA extends Schema.Constraint & {
+  readonly fields: Schema.Struct.Fields;
+}, InheritedA, D1, E1, SelfB extends {
+  readonly decision: D1;
+  readonly ctx: Ctx;
+}, D2, E2>(_commandA: Schema.Class<SelfA, SA, InheritedA>, upstream: ((command: SelfA) => Result<D1, E1>) & WorkflowBrand, commandB: {
+  new (props: {
+    readonly decision: D1;
+    readonly ctx: Ctx;
+  }): SelfB;
+}, ctx: NoInfer<Ctx>, downstream: ((command: SelfB) => Result<D2, E2>) & WorkflowBrand) => [E1 | E2] extends [never] ? ((command: SelfA) => Result<D2, never>) & WorkflowBrand : Workflow<SelfA, D2, E1 | E2>;
 declare namespace Cell_d_exports {
-  export { Cell, CellTypeId, DESCRIPTION_MODULE, IO_CELLS, IoCellClassification, Kind$1 as Kind, PhaseName, Run, TypeLambda$1 as TypeLambda, Vocabulary, andThen, layer, map, mapInput, provide, run, vocabulary, withPolicy, zip };
+  export { Cell, CellTypeId, DESCRIPTION_MODULE, IO_CELLS, IoCellClassification, Kind$1 as Kind, PhaseName, Run, TypeLambda$1 as TypeLambda, Vocabulary, andThen, collect, collectAll, gate, layer, map, mapInput, provide, vocabulary, zip };
 }
 /**
  * The nominal brand every `Cell` carries. `Cell.layer` is the only door that applies it.
@@ -73,7 +102,7 @@ type CellTypeId = typeof CellTypeId;
  */
 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>;
+  readonly run: (input: I) => Effect.Effect<A, E, R>;
 }
 /**
  * The type lambda for {@link Cell}, admitting Cell to `Kind` positions.
@@ -92,9 +121,9 @@ type Kind$1<I, E, R, A> = Kind<TypeLambda$1, I, E, R, A>;
  */
 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 read: (command: I) => Effect.Effect<Raw, RE, RR>;
   readonly decide: ((decoded: Raw) => Result$1.Result<Dec, DE>) & WorkflowBrand;
-  readonly write: (output: Result$1.Result<Dec, DE>, raw: Raw) => Effect$1.Effect<Resp, WE, WR>;
+  readonly write: (output: Result$1.Result<Dec, DE>, raw: Raw) => Effect.Effect<Resp, WE, WR>;
 }
 interface LayerShortSpec<I, Raw, RE, RR, Dec, DE, Resp, WE, WR> extends LayerCore<I, Raw, RE, RR, Dec, DE, Resp, WE, WR> {
   readonly decode?: never;
@@ -104,7 +133,7 @@ interface LayerLongSpec<I, Raw, RE, RR, Dcd, DecE, Dec, DE, Out, Resp, WE, WR> e
   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>;
+  readonly write: (output: Out, raw: Raw) => Effect.Effect<Resp, WE, WR>;
 }
 /**
  * Builds a Cell from one sandwich.
@@ -133,10 +162,6 @@ interface LayerLongSpec<I, Raw, RE, RR, Dcd, DecE, Dec, DE, Out, Resp, WE, WR> e
  */
 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>;
-};
 /**
  * Transforms the Cell's response.
  */
@@ -167,6 +192,31 @@ 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>;
 };
+/**
+ * Runs the inner Cell on the value this Cell read, yielding `Option.none` when it read none.
+ * A skip is an absence, never a refusal; the error and service channels union.
+ */
+declare const gate: {
+  <Raw, A, E2, R2>(inner: Cell<Raw, A, E2, R2>): <I, E, R>(self: Cell<I, Option.Option<Raw>, E, R>) => Cell<I, Option.Option<A>, E | E2, R | R2>;
+  <I, Raw, E, R, A, E2, R2>(self: Cell<I, Option.Option<Raw>, E, R>, inner: Cell<Raw, A, E2, R2>): Cell<I, Option.Option<A>, E | E2, R | R2>;
+};
+/**
+ * Runs the Cell once per item, in order, and folds the responses into one value. The error
+ * and service channels are unchanged; the first refusal ends the run.
+ */
+declare const collect: {
+  <I, A, E, R, B>(fold: (responses: readonly A[]) => B): (self: Cell<I, A, E, R>) => Cell<readonly I[], B, E, R>;
+  <I, A, E, R, B>(self: Cell<I, A, E, R>, fold: (responses: readonly A[]) => B): Cell<readonly I[], B, E, R>;
+};
+/**
+ * Runs the Cell once per item, in order, and folds every outcome — each a `Result.Result` —
+ * into one value. Unlike {@link collect}, no refusal ends the run: every item is attempted
+ * and its failure travels to the fold.
+ */
+declare const collectAll: {
+  <I, A, E, R, B>(fold: (results: readonly Result$1.Result<A, E>[]) => B): (self: Cell<I, A, E, R>) => Cell<readonly I[], B, never, R>;
+  <I, A, E, R, B>(self: Cell<I, A, E, R>, fold: (results: readonly Result$1.Result<A, E>[]) => B): Cell<readonly I[], B, never, R>;
+};
 /**
  * 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
@@ -176,14 +226,6 @@ 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>>;
 };
-/**
- * Wraps the Cell's run in a `Policy` — retry, timeout, and their kin — preserving every
- * channel.
- */
-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 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
@@ -199,4 +241,4 @@ interface Vocabulary {
 }
 declare const vocabulary: Vocabulary;
 //#endregion
-export { Cell_d_exports as Cell, Policy_d_exports as Policy, Workflow_d_exports as Workflow };
+export { Cell_d_exports as Cell, Workflow_d_exports as Workflow };

package/dist/index.mjs

@@ -1,7 +1,9 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import * as Effect$1 from "effect/Effect";
+import * as Effect from "effect/Effect";
 import { dual } from "effect/Function";
+import * as Option from "effect/Option";
 import * as Result$1 from "effect/Result";
+import { flatMap } from "effect/Result";
 //#region src/Facts.ts
 const DESCRIPTION_MODULE = "@systemfsoftware/effect-cell-types";
 const IO_CELLS = {
@@ -10,10 +12,42 @@ const IO_CELLS = {
 };
 //#endregion
 //#region src/Workflow.ts
-var Workflow_exports = /* @__PURE__ */ __exportAll({ make: () => make$1 });
+var Workflow_exports = /* @__PURE__ */ __exportAll({
+	andThen: () => andThen$1,
+	make: () => make$1,
+	total: () => total
+});
 const make$1 = (_command, decide) => {
 	return decide;
 };
+/**
+* Brands a decision that cannot fail. `make` refuses a `never` error channel outright
+* (`UninhabitedError`); this is the door for the decider that genuinely decides everything.
+* The decision must still choose between at least two tagged variants sharing one TypeId, so
+* `SingleVariantDecision`, `UntaggedDecision`, and `UnsharedTypeId` still fire.
+*
+* The command schema class comes first, exactly as in {@link make}, so the command channel
+* stays pinned to the class rather than an inferred annotation. The decider's return carries
+* `DecisionShape` written out: the `Workflow` alias is a deferred conditional, and in
+* parameter position it collapses the whole parameter to `unknown` while the decision
+* channel is still generic.
+*/
+const total = (_command, decide) => {
+	return decide;
+};
+/**
+* Composes two workflows: what the upstream decides becomes the command the downstream decides
+* on, and a refusal short-circuits the pair. The return type dispatches on the component error
+* union — two components that cannot fail publish the total form, because the `Workflow` alias
+* refuses a `never` channel; a carried error publishes the union as before.
+*/
+const andThen$1 = (_commandA, upstream, commandB, ctx, downstream) => {
+	const composed = (command) => flatMap(upstream(command), (decision) => downstream(new commandB({
+		decision,
+		ctx
+	})));
+	return composed;
+};
 //#endregion
 //#region src/Cell.ts
 var Cell_exports = /* @__PURE__ */ __exportAll({
@@ -21,13 +55,14 @@ var Cell_exports = /* @__PURE__ */ __exportAll({
 	DESCRIPTION_MODULE: () => DESCRIPTION_MODULE,
 	IO_CELLS: () => IO_CELLS,
 	andThen: () => andThen,
+	collect: () => collect,
+	collectAll: () => collectAll,
+	gate: () => gate,
 	layer: () => layer,
 	map: () => map,
 	mapInput: () => mapInput,
 	provide: () => provide,
-	run: () => run,
 	vocabulary: () => vocabulary,
-	withPolicy: () => withPolicy,
 	zip: () => zip
 });
 /**
@@ -44,16 +79,16 @@ const make = (run) => ({
 * a decide refusal is the outcome the encode and write receive, not a failure.
 */
 const layerRunner = (spec) => {
-	if ("decode" in spec && "encode" in spec) return (input) => Effect$1.gen(function* () {
+	if ("decode" in spec && "encode" in spec) return (input) => Effect.gen(function* () {
 		const raw = yield* spec.read(input);
 		const decoded = yield* Result$1.match(spec.decode(raw), {
-			onFailure: Effect$1.fail,
-			onSuccess: Effect$1.succeed
+			onFailure: Effect.fail,
+			onSuccess: Effect.succeed
 		});
 		const outcome = spec.decide(decoded);
 		return yield* spec.write(spec.encode(outcome), raw);
 	});
-	return (input) => Effect$1.gen(function* () {
+	return (input) => Effect.gen(function* () {
 		const raw = yield* spec.read(input);
 		const outcome = spec.decide(raw);
 		return yield* spec.write(outcome, raw);
@@ -62,11 +97,10 @@ const layerRunner = (spec) => {
 function layer(spec) {
 	return make(layerRunner(spec));
 }
-const run = dual(2, (self, input) => self.run(input));
 /**
 * Transforms the Cell's response.
 */
-const map = dual(2, (self, f) => make((input) => Effect$1.map(self.run(input), f)));
+const map = dual(2, (self, f) => make((input) => Effect.map(self.run(input), f)));
 /**
 * Transforms the Cell's input.
 */
@@ -75,23 +109,37 @@ const mapInput = dual(2, (self, f) => make((input) => self.run(f(input))));
 * Feeds this Cell's response to the next Cell as its input. The error and service channels
 * union.
 */
-const andThen = dual(2, (self, that) => make((input) => Effect$1.flatMap(self.run(input), (response) => that.run(response))));
+const andThen = dual(2, (self, that) => make((input) => Effect.flatMap(self.run(input), (response) => that.run(response))));
 /**
 * Runs both Cells against the same input and tuples the responses. Fails fast: when one
 * side refuses, the other's write never runs.
 */
-const zip = dual(2, (self, that) => make((input) => Effect$1.zipWith(self.run(input), that.run(input), (a, b) => [a, b])));
+const zip = dual(2, (self, that) => make((input) => Effect.zipWith(self.run(input), that.run(input), (a, b) => [a, b])));
+/**
+* Runs the inner Cell on the value this Cell read, yielding `Option.none` when it read none.
+* A skip is an absence, never a refusal; the error and service channels union.
+*/
+const gate = dual(2, (self, inner) => make((input) => Effect.flatMap(self.run(input), (read) => Option.match(read, {
+	onNone: () => Effect.succeed(Option.none()),
+	onSome: (raw) => Effect.map(inner.run(raw), Option.some)
+}))));
+/**
+* Runs the Cell once per item, in order, and folds the responses into one value. The error
+* and service channels are unchanged; the first refusal ends the run.
+*/
+const collect = dual(2, (self, fold) => make((items) => Effect.map(Effect.forEach(items, (item) => self.run(item)), (responses) => fold(responses))));
+/**
+* Runs the Cell once per item, in order, and folds every outcome — each a `Result.Result` —
+* into one value. Unlike {@link collect}, no refusal ends the run: every item is attempted
+* and its failure travels to the fold.
+*/
+const collectAll = dual(2, (self, fold) => make((items) => Effect.map(Effect.forEach(items, (item) => Effect.result(self.run(item))), (results) => fold(results))));
 /**
 * Provides a Layer to the Cell, eliminating the services the layer builds from `R`. This is
 * the one composition-root elimination; the resulting Cell still demands the layer's input
 * services. A missing provide is a compile error at the run site.
 */
-const provide = dual(2, (self, layer) => make((input) => Effect$1.provide(self.run(input), layer)));
-/**
-* Wraps the Cell's run in a `Policy` — retry, timeout, and their kin — preserving every
-* channel.
-*/
-const withPolicy = dual(2, (self, policy) => make((input) => policy(self.run(input))));
+const provide = dual(2, (self, layer) => make((input) => Effect.provide(self.run(input), layer)));
 const vocabulary = {
 	module: DESCRIPTION_MODULE,
 	ioCells: IO_CELLS,
@@ -103,7 +151,4 @@ const vocabulary = {
 	composer: "layer"
 };
 //#endregion
-//#region src/Policy.ts
-var Policy_exports = /* @__PURE__ */ __exportAll({});
-//#endregion
-export { Cell_exports as Cell, Policy_exports as Policy, Workflow_exports as Workflow };
+export { Cell_exports as Cell, Workflow_exports as Workflow };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@systemfsoftware/effect-cell-types",
   "license": "Apache-2.0",
-  "version": "7.0.1",
+  "version": "8.1.0",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
@@ -43,9 +43,9 @@
     "tstyche": "^7.1.0",
     "vitest": "^4",
     "@systemfsoftware/effect-gherkin-spec": "4.0.2",
+    "@systemfsoftware/oxlint-config": "^0.1.0",
     "@systemfsoftware/tsconfig": "^1.3.4",
-    "@systemfsoftware/vitest-config": "^0.1.0",
-    "@systemfsoftware/oxlint-config": "^0.1.0"
+    "@systemfsoftware/vitest-config": "^0.1.0"
   },
   "peerDependencies": {
     "effect": "4.0.0-rc.112"