@demlik/tea 0.20.0 → 0.22.0

package/dist/{drive-loop-Dw1sGSsW.d.ts → drive-loop-DlOEv49c.d.ts}

@@ -1,4 +1,4 @@
-import { C as CtxArg } from './runtime-types-DEluQgGO.js';
+import { C as CtxArg } from './runtime-types-CP-ykwgf.js';
 
 /**
  * The default round bound when `opts.maxRounds` is omitted: **100**.
@@ -124,4 +124,4 @@ declare class DriveNoHandlerError<M, C> extends Error {
  */
 declare function driveTraceOf<M, C>(err: unknown): readonly DriveTraceEntry<M, C>[] | undefined;
 
-export { DriveRoundsExceededError as D, DriveNoHandlerError as a, type DriveOptions as b, type DriveResult as c, DEFAULT_MAX_ROUNDS as d, type DriveCtxArg as e, type DriveTraceEntry as f, driveTraceOf as g };
+export { type DriveOptions as D, type DriveResult as a, DEFAULT_MAX_ROUNDS as b, type DriveCtxArg as c, DriveNoHandlerError as d, DriveRoundsExceededError as e, type DriveTraceEntry as f, driveTraceOf as g };

package/dist/{durable-effects-Ump5lSdO.d.ts → durable-effects-wLWEdy9H.d.ts}

@@ -1,4 +1,4 @@
-import { C as Cmd } from './core-CtvAyPpH.js';
+import { C as Cmd } from './core-DNDAEhO2.js';
 
 /**
  * @demlik/tea/do — the durable pending-effects ledger (substrate primitive #1).

package/dist/effect/index.d.ts

@@ -1,9 +1,10 @@
-import { Scope, Effect } from 'effect';
-import { C as Cmd, S as Sub, M as Machine } from '../core-CtvAyPpH.js';
-import { E as EffectRuntime, S as StoreFailed } from '../run-fiBe7pOG.js';
-export { C as CellErrors, a as EffectBootingRuntime, b as EffectInterpret, c as EffectInterpretCell, d as EffectRunOptions, e as EffectRunner, f as EffectSubscribe, I as InterpretServices, g as Stopped, h as SubscribeServices, r as run } from '../run-fiBe7pOG.js';
+import { T as TellAnswer } from '../loop-DReKGV1X.js';
+import { Scope, Effect, Schema } from 'effect';
+import { C as Cmd$1, c as Sub, M as Machine, k as CmdInput, b as CmdDef, f as TaggedError } from '../core-DNDAEhO2.js';
+import { E as EffectRun } from '../run-Cnw4qXj2.js';
+export { C as CellErrors, a as EffectBootingRun, b as EffectBootingRuntime, c as EffectInterpret, d as EffectInterpretCell, e as EffectRunOptions, f as EffectRunner, g as EffectRuntime, h as EffectSubscribe, I as InterpretServices, S as Stopped, i as StoreFailed, j as SubFailed, k as SubscribeServices, r as run } from '../run-Cnw4qXj2.js';
 import '@standard-schema/spec';
-import '../runtime-types-DEluQgGO.js';
+import '../runtime-types-CP-ykwgf.js';
 import 'effect/Cause';
 import 'effect/Types';
 
@@ -14,30 +15,49 @@ import 'effect/Types';
  * tea still runs one machine per `run` and keeps no table of runs (#312). A
  * host that builds a tree of runs keeps its own table, ids and Msg names, and
  * hands the steps that race to these functions: `spawn` starts a child and
- * enrols it as one step, `stop` stops one child, and `tell` sends the parent a
- * notice it may no longer take.
+ * enrols it as one step, `stop` stops one child, and `tell` puts a Msg on a
+ * run's line without waiting for it.
  */
 
 /**
- * Hand `msg` to a run only when its State has a cell for it, and drop it when
- * the run no longer takes it.
+ * Put `msg` on a run's line and answer at once. The answer means queued, not
+ * handled: the receiver's step has not run yet, and any result comes back later
+ * as its own Msg. So two machines can tell each other from their Cmd handlers
+ * and neither stops. `machine` is the machine `runtime` runs.
  *
- * `machine` is the machine `runtime` runs. The dispatch lands a moment after
- * the check, so a State that changed in between refuses the Msg with a
- * `NoCellError`, and a run that stopped refuses it with `Stopped`. Both mean
- * the run no longer takes the notice, so both are dropped and `tell` succeeds.
- * A failed save stays a `StoreFailed`, and a hand-written cell's declared
- * failure stays that failure.
+ * The answer is `"queued"`, `"stopped"` for a run that is stopping or has
+ * stopped, or `"no_cell"` when its current State has no cell for the Msg. Msgs
+ * already in line have not folded yet, so a Msg that only a queued one makes
+ * acceptable answers `"no_cell"`.
+ *
+ * `runtime` is what `ready` succeeded with, or a spread of it. Those carry the
+ * run's line, and the type asks for it, so an `EffectRuntime` built by hand is a
+ * compile error. So is the handle `run` yielded, with a store or without one: wait
+ * for `ready`.
+ *
+ * `tell` carries no failure in its type. A hand-built object cast past the type
+ * has no line to put a Msg on, and `tell` dies with a defect there.
+ *
+ * What happens after `"queued"` is the receiver's. Two `tell`s from one sender
+ * fold in the order they were sent. A failed save or a cell's failure goes to
+ * the receiver's `onError`, never back to the sender. A Msg whose cell is gone
+ * by its turn is dropped without a word, and a `stop()` that gives up drops
+ * what is still in line and counts it, per Msg type, in its
+ * `DrainTimeoutNotice`.
+ *
+ * Two hand-written waiting `runtime.dispatch(...)` calls into each other, one
+ * from each machine's Cmd handler, still stop both machines: `dispatch` waits,
+ * and tea has no lock-up detector. Use `tell` there.
  *
  * ```ts
- * yield* tell(parent, parentRun, { type: "child_stopped", id });
+ * const answer = yield* tell(parent, parentRun, { type: "child_stopped", id });
  * ```
  */
 declare const tell: <S, M extends {
     type: string;
-}, C extends Cmd, U extends Sub, Ctx, E extends {
+}, C extends Cmd$1, U extends Sub, Ctx, E extends {
     type: string;
-} = never, Err = never>(machine: Machine<S, M, C, U, Ctx>, runtime: EffectRuntime<S, M, E, Err>, msg: NoInfer<M>) => Effect.Effect<void, Err | StoreFailed>;
+} = never, Err = never>(machine: Machine<S, M, C, U, Ctx>, runtime: EffectRun<S, M, E, Err>, msg: NoInfer<M>) => Effect.Effect<TellAnswer>;
 /**
  * The host's own steps of a {@link spawn}. The host owns the table of
  * children, their ids and the parent's Msg names; `spawn` owns the order the
@@ -63,11 +83,14 @@ interface SpawnSteps<A, E = never, R = never> {
     /**
      * Say the child stopped, usually a {@link tell} to the parent. It runs
      * after `remove`, on a fiber of its own that the closing scope never waits
-     * for, so it may wait on the parent.
+     * for, so even a step that does wait cannot hold the close.
      *
      * It cannot fail: nothing reads that fiber, so the step itself handles what
-     * its notice can fail with, such as the `StoreFailed` of a `tell`. A defect
-     * in it is not observed by `spawn` and ends the fiber unseen.
+     * its notice can fail with. A `tell` has nothing to handle. Its argument is the
+     * handle the parent's `ready` gave: a parent handle built by hand, or one straight
+     * from `run`, does not compile. A defect in this step, such as a `tell` on a
+     * hand-built object cast past that type, is not observed by `spawn` and ends the
+     * fiber unseen.
      */
     readonly notify: Effect.Effect<unknown>;
 }
@@ -87,9 +110,14 @@ interface SpawnSteps<A, E = never, R = never> {
  *   - `remove` runs after the child's run has stopped.
  *
  * Nothing reads the fiber `notify` runs on, so `spawn` reports no failure of
- * it and `notify` is typed to have none. The host handles what its notice can
- * fail with inside the step, as the `Effect.catch` below does for a parent
- * whose save failed. A defect in `notify` ends that fiber unseen.
+ * it and `notify` is typed to have none. A `tell` carries no failure, and a
+ * failed save of the parent reaches the parent's own `onError`. A defect in
+ * `notify`, such as a `tell` on a handle cast past its type, ends that fiber
+ * unseen.
+ *
+ * A child whose run fails stops the same way, with no host call: a Sub failure
+ * the Sub did not map to a Msg, or a reducer throw under the default `stop`
+ * strategy, closes the child's scope, so `remove` and `notify` run.
  *
  * `child.run.stop()` is not one of the two ways to stop a child. It stops the
  * run and leaves the scope open, so the entry stays in the table and the
@@ -101,9 +129,7 @@ interface SpawnSteps<A, E = never, R = never> {
  *     Effect.map(run(worker, {}), (run) => ({ run, scope })),
  *   enrol: (child) => Effect.sync(() => children.set(id, child)),
  *   remove: Effect.sync(() => children.delete(id)),
- *   notify: tell(parent, parentRun, { type: "child_stopped", id }).pipe(
- *     Effect.catch((failure) => Effect.logError("notice failed", failure)),
- *   ),
+ *   notify: tell(parent, parentRun, { type: "child_stopped", id }),
  * });
  * ```
  */
@@ -123,4 +149,71 @@ declare const spawn: <A, E = never, R = never>(parentScope: Scope.Scope, steps:
  */
 declare const stop: (scope: Scope.Closeable) => Effect.Effect<void>;
 
-export { EffectRuntime, type SpawnSteps, StoreFailed, spawn, stop, tell };
+/**
+ * The Effect entry's `Cmd`: the core `Cmd` with a `define` that takes plain
+ * Effect schemas (#631). It is a function over the core `Cmd.define`, so the
+ * def it returns is the same `CmdDef` a hand-wrapped call builds.
+ */
+
+/**
+ * An Effect schema that checks a value and hands the same type on. Both sides
+ * are one type, and decoding needs no service.
+ *
+ * tea types a handler's answer by the type the `ok` schema hands on, and checks
+ * that answer by parsing it. A schema whose two sides differ — a
+ * transformation like `Schema.FiniteFromString`, a brand — would refuse the
+ * very value the handler's type asks for, so it does not compile here. Pass
+ * `Schema.toType(schema)` to keep the checks and drop the translation.
+ */
+type CheckingSchema<T> = Schema.Codec<T, NoInfer<T>>;
+declare function define<const Name extends string, Input extends CmdInput, Ok, const Tags extends readonly string[]>(name: Name, spec: {
+    readonly input: CheckingSchema<Input>;
+    readonly ok: CheckingSchema<Ok>;
+    readonly err: Tags;
+}): CmdDef<Name, Input, Ok, TaggedError<Tags[number]>>;
+/**
+ * A Cmd value, as the core types it. Exported beside the `Cmd` helpers so an
+ * Effect user reads both from this entry.
+ */
+type Cmd<T extends string = string, Ok = unknown, E = unknown> = Cmd$1<T, Ok, E>;
+/**
+ * The helpers for building Cmds on the Effect engine. `Cmd.none`, `Cmd.batch`,
+ * `Cmd.when` and `Cmd.whenDefined` are the core's; `Cmd.define` is this
+ * entry's own.
+ */
+declare const Cmd: {
+    /**
+     * Declare a typed Cmd constructor from plain Effect schemas. It returns what
+     * the core `Cmd.define` returns, with each schema passed through
+     * `Schema.toStandardSchemaV1` for you:
+     *
+     *   const fetchUser = Cmd.define("fetch_user", {
+     *     input: Schema.Struct({ id: Schema.String }),
+     *     ok: Schema.Struct({ name: Schema.String }),
+     *     err: ["not_found"],
+     *   });
+     *
+     * `input` and `ok` take a schema that checks and never translates: both of
+     * its sides are one type and decoding needs no service. A transformation, a
+     * brand or a schema that needs a service is a compile error.
+     *
+     * To keep the checks of a transformation or a brand, pass
+     * `Schema.toType(schema)`. That is no way through for a schema that needs a
+     * service: its check lives in the decode step, and `Schema.toType` drops that
+     * step, so the Cmd would compile and never run the check. Run such a check in
+     * the handler.
+     *
+     * A schema whose validation needs a Promise compiles, and is refused with
+     * `AsyncSchemaError` when the Cmd settles, as the core's is.
+     *
+     * It takes Effect schemas only. A zod schema, or any other Standard Schema,
+     * goes to `Cmd.define` from `@demlik/tea`.
+     */
+    readonly define: typeof define;
+    readonly none: readonly never[];
+    readonly batch: <const C extends Cmd$1>(...arrs: readonly (readonly C[])[]) => readonly C[];
+    readonly when: <const C extends Cmd$1>(cond: boolean, cmd: C) => readonly C[];
+    readonly whenDefined: <T, const C extends Cmd$1>(value: T | undefined, build: (value: T) => C) => readonly C[];
+};
+
+export { type CheckingSchema, Cmd, EffectRun, type SpawnSteps, TellAnswer, spawn, stop, tell };

package/dist/effect/index.js

@@ -1,35 +1,49 @@
-export { Stopped, StoreFailed, run } from '../chunk-AIXC33SE.js';
-import '../chunk-UHAQ4PI6.js';
-import '../chunk-A73IJ27X.js';
-import { acceptedTypes, NoCellError } from '../chunk-RKVUVALV.js';
-import { Effect, Scope, Exit } from 'effect';
+export { Stopped, StoreFailed, SubFailed, run, spawn, stop, tell } from '../chunk-SHXUSTHM.js';
+import '../chunk-2A5XTKQQ.js';
+import '../chunk-R2YNDRGL.js';
+import '../chunk-DEAPNMKO.js';
+import { Cmd } from '../chunk-A3QPMX5M.js';
+import { Schema } from 'effect';
 
-var tell = (machine, runtime, msg) => Effect.suspend(
-  () => acceptedTypes(machine, runtime.getState()).includes(msg.type) ? runtime.dispatch(msg) : Effect.void
-).pipe(
-  Effect.catchTag("Stopped", () => Effect.void),
-  Effect.catchDefect(
-    (defect) => defect instanceof NoCellError ? Effect.void : Effect.die(defect)
-  )
-);
-var spawn = (parentScope, steps) => Effect.uninterruptible(
-  Effect.gen(function* () {
-    const scope = yield* Scope.fork(parentScope);
-    yield* Scope.addFinalizer(
-      scope,
-      Effect.andThen(steps.remove, Effect.forkDetach(steps.notify))
-    );
-    const child = yield* steps.start(scope).pipe(
-      Scope.provide(scope),
-      Effect.onError((cause) => Scope.close(scope, Exit.failCause(cause)))
-    );
-    yield* steps.enrol(child);
-    if (scope.state._tag === "Closed") yield* steps.remove;
-    return child;
-  })
-);
-var stop = (scope) => Scope.close(scope, Exit.void);
+function define(name, spec) {
+  return Cmd.define(name, {
+    input: Schema.toStandardSchemaV1(spec.input),
+    ok: Schema.toStandardSchemaV1(spec.ok),
+    err: spec.err
+  });
+}
+var Cmd2 = {
+  ...Cmd,
+  /**
+   * Declare a typed Cmd constructor from plain Effect schemas. It returns what
+   * the core `Cmd.define` returns, with each schema passed through
+   * `Schema.toStandardSchemaV1` for you:
+   *
+   *   const fetchUser = Cmd.define("fetch_user", {
+   *     input: Schema.Struct({ id: Schema.String }),
+   *     ok: Schema.Struct({ name: Schema.String }),
+   *     err: ["not_found"],
+   *   });
+   *
+   * `input` and `ok` take a schema that checks and never translates: both of
+   * its sides are one type and decoding needs no service. A transformation, a
+   * brand or a schema that needs a service is a compile error.
+   *
+   * To keep the checks of a transformation or a brand, pass
+   * `Schema.toType(schema)`. That is no way through for a schema that needs a
+   * service: its check lives in the decode step, and `Schema.toType` drops that
+   * step, so the Cmd would compile and never run the check. Run such a check in
+   * the handler.
+   *
+   * A schema whose validation needs a Promise compiles, and is refused with
+   * `AsyncSchemaError` when the Cmd settles, as the core's is.
+   *
+   * It takes Effect schemas only. A zod schema, or any other Standard Schema,
+   * goes to `Cmd.define` from `@demlik/tea`.
+   */
+  define
+};
 
-export { spawn, stop, tell };
+export { Cmd2 as Cmd };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/effect/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/effect/children.ts"],"names":[],"mappings":";;;;;;AAgCO,IAAM,IAAA,GAAO,CASlB,OAAA,EACA,OAAA,EACA,QAEA,MAAA,CAAO,OAAA;AAAA,EAAQ,MACb,aAAA,CAAc,OAAA,EAAS,OAAA,CAAQ,UAAU,CAAA,CAAE,QAAA,CAAS,GAAA,CAAI,IAAI,CAAA,GACxD,OAAA,CAAQ,QAAA,CAAS,GAAG,IACpB,MAAA,CAAO;AACb,CAAA,CAAE,IAAA;AAAA,EACA,MAAA,CAAO,QAAA,CAAS,SAAA,EAAW,MAAM,OAAO,IAAI,CAAA;AAAA,EAC5C,MAAA,CAAO,WAAA;AAAA,IAAY,CAAC,WAClB,MAAA,YAAkB,WAAA,GAAc,OAAO,IAAA,GAAO,MAAA,CAAO,IAAI,MAAM;AAAA;AAEnE;AAwEK,IAAM,KAAA,GAAQ,CACnB,WAAA,EACA,KAAA,KAEA,MAAA,CAAO,eAAA;AAAA,EACL,MAAA,CAAO,IAAI,aAAa;AACtB,IAAA,MAAM,KAAA,GAAQ,OAAO,KAAA,CAAM,IAAA,CAAK,WAAW,CAAA;AAG3C,IAAA,OAAO,KAAA,CAAM,YAAA;AAAA,MACX,KAAA;AAAA,MACA,MAAA,CAAO,QAAQ,KAAA,CAAM,MAAA,EAAQ,OAAO,UAAA,CAAW,KAAA,CAAM,MAAM,CAAC;AAAA,KAC9D;AACA,IAAA,MAAM,KAAA,GAAQ,OAAO,KAAA,CAAM,KAAA,CAAM,KAAK,CAAA,CAAE,IAAA;AAAA,MACtC,KAAA,CAAM,QAAQ,KAAK,CAAA;AAAA,MACnB,MAAA,CAAO,OAAA,CAAQ,CAAC,KAAA,KAAU,KAAA,CAAM,KAAA,CAAM,KAAA,EAAO,IAAA,CAAK,SAAA,CAAU,KAAK,CAAC,CAAC;AAAA,KACrE;AACA,IAAA,OAAO,KAAA,CAAM,MAAM,KAAK,CAAA;AAExB,IAAA,IAAI,KAAA,CAAM,KAAA,CAAM,IAAA,KAAS,QAAA,SAAiB,KAAA,CAAM,MAAA;AAChD,IAAA,OAAO,KAAA;AAAA,EACT,CAAC;AACH;AAeK,IAAM,OAAO,CAAC,KAAA,KACnB,MAAM,KAAA,CAAM,KAAA,EAAO,KAAK,IAAI","file":"index.js","sourcesContent":["/**\n * Helpers for running child machines under a parent on the Effect engine\n * (#556, ruling R1.1 of #554).\n *\n * tea still runs one machine per `run` and keeps no table of runs (#312). A\n * host that builds a tree of runs keeps its own table, ids and Msg names, and\n * hands the steps that race to these functions: `spawn` starts a child and\n * enrols it as one step, `stop` stops one child, and `tell` sends the parent a\n * notice it may no longer take.\n */\n\nimport { Effect, Exit, Scope } from \"effect\";\nimport type { Cmd, Machine, Sub } from \"../pure/core\";\nimport { acceptedTypes, NoCellError } from \"../pure/core\";\nimport type { StoreFailed } from \"./failures\";\nimport type { EffectRuntime } from \"./handle\";\n\n/**\n * Hand `msg` to a run only when its State has a cell for it, and drop it when\n * the run no longer takes it.\n *\n * `machine` is the machine `runtime` runs. The dispatch lands a moment after\n * the check, so a State that changed in between refuses the Msg with a\n * `NoCellError`, and a run that stopped refuses it with `Stopped`. Both mean\n * the run no longer takes the notice, so both are dropped and `tell` succeeds.\n * A failed save stays a `StoreFailed`, and a hand-written cell's declared\n * failure stays that failure.\n *\n * ```ts\n * yield* tell(parent, parentRun, { type: \"child_stopped\", id });\n * ```\n */\nexport const tell = <\n  S,\n  M extends { type: string },\n  C extends Cmd,\n  U extends Sub,\n  Ctx,\n  E extends { type: string } = never,\n  Err = never,\n>(\n  machine: Machine<S, M, C, U, Ctx>,\n  runtime: EffectRuntime<S, M, E, Err>,\n  msg: NoInfer<M>,\n): Effect.Effect<void, Err | StoreFailed> =>\n  Effect.suspend(() =>\n    acceptedTypes(machine, runtime.getState()).includes(msg.type)\n      ? runtime.dispatch(msg)\n      : Effect.void,\n  ).pipe(\n    Effect.catchTag(\"Stopped\", () => Effect.void),\n    Effect.catchDefect((defect) =>\n      defect instanceof NoCellError ? Effect.void : Effect.die(defect),\n    ),\n  ) as Effect.Effect<void, Err | StoreFailed>;\n\n/**\n * The host's own steps of a {@link spawn}. The host owns the table of\n * children, their ids and the parent's Msg names; `spawn` owns the order the\n * steps run in and keeps an interrupt from landing between them.\n */\nexport interface SpawnSteps<A, E = never, R = never> {\n  /**\n   * Start the child and return what the host keeps for it. It runs with the\n   * child's scope provided, so a `run(machine, opts)` in it belongs to that\n   * scope, and so does anything else it acquires. `scope` is the same scope,\n   * for a host that keeps it to stop the child with `stop`. A failure\n   * closes the child's scope, which runs `remove` and `notify`.\n   */\n  readonly start: (scope: Scope.Closeable) => Effect.Effect<A, E, R>;\n  /** Add the started child to the host's table. */\n  readonly enrol: (child: A) => Effect.Effect<unknown>;\n  /**\n   * Take the child out of the host's table. It runs when the child's scope\n   * closes, after its run has stopped, whether or not `enrol` ran, so it must\n   * be safe on a child the table does not hold.\n   */\n  readonly remove: Effect.Effect<unknown>;\n  /**\n   * Say the child stopped, usually a {@link tell} to the parent. It runs\n   * after `remove`, on a fiber of its own that the closing scope never waits\n   * for, so it may wait on the parent.\n   *\n   * It cannot fail: nothing reads that fiber, so the step itself handles what\n   * its notice can fail with, such as the `StoreFailed` of a `tell`. A defect\n   * in it is not observed by `spawn` and ends the fiber unseen.\n   */\n  readonly notify: Effect.Effect<unknown>;\n}\n\n/**\n * Start a child in a scope forked from `parentScope` and enrol it in the\n * host's table, as one uninterruptible step. Stop a child with `stop`,\n * or by closing its scope; closing `parentScope` stops every child spawned\n * under it.\n *\n * What it guarantees, with no guard in host code:\n *\n *   - the table never holds a child whose scope has closed. The fork, the\n *     removal finalizer, `start` and `enrol` all happen or none do, and a\n *     child whose scope closed before `enrol` is removed again;\n *   - closing a child never waits for the parent. `notify` runs on a detached\n *     fiber, so a parent Cmd handler can stop a child;\n *   - `remove` runs after the child's run has stopped.\n *\n * Nothing reads the fiber `notify` runs on, so `spawn` reports no failure of\n * it and `notify` is typed to have none. The host handles what its notice can\n * fail with inside the step, as the `Effect.catch` below does for a parent\n * whose save failed. A defect in `notify` ends that fiber unseen.\n *\n * `child.run.stop()` is not one of the two ways to stop a child. It stops the\n * run and leaves the scope open, so the entry stays in the table and the\n * parent is not told.\n *\n * ```ts\n * const child = yield* spawn(parentScope, {\n *   start: (scope) =>\n *     Effect.map(run(worker, {}), (run) => ({ run, scope })),\n *   enrol: (child) => Effect.sync(() => children.set(id, child)),\n *   remove: Effect.sync(() => children.delete(id)),\n *   notify: tell(parent, parentRun, { type: \"child_stopped\", id }).pipe(\n *     Effect.catch((failure) => Effect.logError(\"notice failed\", failure)),\n *   ),\n * });\n * ```\n */\nexport const spawn = <A, E = never, R = never>(\n  parentScope: Scope.Scope,\n  steps: SpawnSteps<A, E, R>,\n): Effect.Effect<A, E, Exclude<R, Scope.Scope>> =>\n  Effect.uninterruptible(\n    Effect.gen(function* () {\n      const scope = yield* Scope.fork(parentScope);\n      // Added before `start`, so it runs after everything `start` put in the\n      // scope has been released, the child's run included.\n      yield* Scope.addFinalizer(\n        scope,\n        Effect.andThen(steps.remove, Effect.forkDetach(steps.notify)),\n      );\n      const child = yield* steps.start(scope).pipe(\n        Scope.provide(scope),\n        Effect.onError((cause) => Scope.close(scope, Exit.failCause(cause))),\n      );\n      yield* steps.enrol(child);\n      // A scope that closed under `start` ran `remove` before `enrol`.\n      if (scope.state._tag === \"Closed\") yield* steps.remove;\n      return child;\n    }),\n  );\n\n/**\n * Stop one child that `spawn` started. `scope` is the child's scope,\n * the one its `start` was handed.\n *\n * It closes that scope, so the child's run stops, `remove` takes the entry\n * out of the host's table and `notify` tells the parent. It does not wait for\n * `notify`, so a parent Cmd handler can call it. Stopping a child that has\n * already stopped succeeds and sends no second notice.\n *\n * ```ts\n * yield* stop(child.scope);\n * ```\n */\nexport const stop = (scope: Scope.Closeable): Effect.Effect<void> =>\n  Scope.close(scope, Exit.void);\n"]}
+{"version":3,"sources":["../../src/effect/cmd.ts"],"names":["Cmd"],"mappings":";;;;;;;AA0BA,SAAS,MAAA,CAMP,MACA,IAAA,EAKoD;AACpD,EAAA,OAAO,GAAA,CAAQ,OAAO,IAAA,EAAM;AAAA,IAC1B,KAAA,EAAO,MAAA,CAAO,kBAAA,CAAmB,IAAA,CAAK,KAAK,CAAA;AAAA,IAC3C,EAAA,EAAI,MAAA,CAAO,kBAAA,CAAmB,IAAA,CAAK,EAAE,CAAA;AAAA,IACrC,KAAK,IAAA,CAAK;AAAA,GACX,CAAA;AACH;AAiBO,IAAMA,IAAAA,GAAM;AAAA,EACjB,GAAG,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA4BH;AACF","file":"index.js","sourcesContent":["/**\n * The Effect entry's `Cmd`: the core `Cmd` with a `define` that takes plain\n * Effect schemas (#631). It is a function over the core `Cmd.define`, so the\n * def it returns is the same `CmdDef` a hand-wrapped call builds.\n */\n\nimport { Schema } from \"effect\";\nimport {\n  type CmdDef,\n  type CmdInput,\n  Cmd as CoreCmd,\n  type TaggedError,\n} from \"../pure/core\";\n\n/**\n * An Effect schema that checks a value and hands the same type on. Both sides\n * are one type, and decoding needs no service.\n *\n * tea types a handler's answer by the type the `ok` schema hands on, and checks\n * that answer by parsing it. A schema whose two sides differ — a\n * transformation like `Schema.FiniteFromString`, a brand — would refuse the\n * very value the handler's type asks for, so it does not compile here. Pass\n * `Schema.toType(schema)` to keep the checks and drop the translation.\n */\nexport type CheckingSchema<T> = Schema.Codec<T, NoInfer<T>>;\n\nfunction define<\n  const Name extends string,\n  Input extends CmdInput,\n  Ok,\n  const Tags extends readonly string[],\n>(\n  name: Name,\n  spec: {\n    readonly input: CheckingSchema<Input>;\n    readonly ok: CheckingSchema<Ok>;\n    readonly err: Tags;\n  },\n): CmdDef<Name, Input, Ok, TaggedError<Tags[number]>> {\n  return CoreCmd.define(name, {\n    input: Schema.toStandardSchemaV1(spec.input),\n    ok: Schema.toStandardSchemaV1(spec.ok),\n    err: spec.err,\n  });\n}\n\n/**\n * A Cmd value, as the core types it. Exported beside the `Cmd` helpers so an\n * Effect user reads both from this entry.\n */\nexport type Cmd<T extends string = string, Ok = unknown, E = unknown> = CoreCmd<\n  T,\n  Ok,\n  E\n>;\n\n/**\n * The helpers for building Cmds on the Effect engine. `Cmd.none`, `Cmd.batch`,\n * `Cmd.when` and `Cmd.whenDefined` are the core's; `Cmd.define` is this\n * entry's own.\n */\nexport const Cmd = {\n  ...CoreCmd,\n  /**\n   * Declare a typed Cmd constructor from plain Effect schemas. It returns what\n   * the core `Cmd.define` returns, with each schema passed through\n   * `Schema.toStandardSchemaV1` for you:\n   *\n   *   const fetchUser = Cmd.define(\"fetch_user\", {\n   *     input: Schema.Struct({ id: Schema.String }),\n   *     ok: Schema.Struct({ name: Schema.String }),\n   *     err: [\"not_found\"],\n   *   });\n   *\n   * `input` and `ok` take a schema that checks and never translates: both of\n   * its sides are one type and decoding needs no service. A transformation, a\n   * brand or a schema that needs a service is a compile error.\n   *\n   * To keep the checks of a transformation or a brand, pass\n   * `Schema.toType(schema)`. That is no way through for a schema that needs a\n   * service: its check lives in the decode step, and `Schema.toType` drops that\n   * step, so the Cmd would compile and never run the check. Run such a check in\n   * the handler.\n   *\n   * A schema whose validation needs a Promise compiles, and is refused with\n   * `AsyncSchemaError` when the Cmd settles, as the core's is.\n   *\n   * It takes Effect schemas only. A zod schema, or any other Standard Schema,\n   * goes to `Cmd.define` from `@demlik/tea`.\n   */\n  define,\n} as const;\n"]}

package/dist/extension/index.d.ts

@@ -1,7 +1,7 @@
-import { R as Runtime, M as Migrated, S as Store } from '../runtime-types-DEluQgGO.js';
+import { R as Runtime, M as Migrated, b as Store } from '../runtime-types-CP-ykwgf.js';
 import { ReactNode } from 'react';
-import { S as Sub } from '../core-CtvAyPpH.js';
-import { S as SubscribeHandler } from '../types-CXNzlbAg.js';
+import { c as Sub } from '../core-DNDAEhO2.js';
+import { S as SubscribeHandler } from '../types-S53WDy_h.js';
 import '@standard-schema/spec';
 
 /**

package/dist/extension/index.js

@@ -1,5 +1,5 @@
-import { historyTracker, dispatchIfPresent } from '../chunk-DVNXEB7V.js';
-import { describeError } from '../chunk-RKVUVALV.js';
+import { historyTracker, dispatchIfPresent } from '../chunk-BVFS3ICC.js';
+import { describeError } from '../chunk-A3QPMX5M.js';
 import { useRef, useSyncExternalStore, useEffect, useCallback, createContext, useMemo, useContext } from 'react';
 import { jsx } from 'react/jsx-runtime';