@demlik/tea 0.20.0 → 0.21.0

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

@@ -1,4 +1,4 @@
-import { C as CtxArg } from './runtime-types-DEluQgGO.js';
+import { C as CtxArg } from './runtime-types-BPKp2bGo.js';
 
 /**
  * The default round bound when `opts.maxRounds` is omitted: **100**.

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

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

package/dist/effect/index.d.ts

@@ -1,9 +1,9 @@
-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 { 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-BKJW1Kmq.js';
+import { c as EffectRuntime, d as StoreFailed } from '../run-D0sxbyno.js';
+export { C as CellErrors, e as EffectBootingRuntime, E as EffectInterpret, f as EffectInterpretCell, g as EffectRunOptions, h as EffectRunner, a as EffectSubscribe, I as InterpretServices, i as Stopped, b as SubscribeServices, r as run } from '../run-D0sxbyno.js';
 import '@standard-schema/spec';
-import '../runtime-types-DEluQgGO.js';
+import '../runtime-types-BPKp2bGo.js';
 import 'effect/Cause';
 import 'effect/Types';
 
@@ -35,7 +35,7 @@ import 'effect/Types';
  */
 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>;
 /**
@@ -123,4 +123,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, EffectRuntime, type SpawnSteps, StoreFailed, spawn, stop, tell };

package/dist/effect/index.js

@@ -1,8 +1,8 @@
-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, run } from '../chunk-HU3Y2AZY.js';
+import '../chunk-VM7PMFV5.js';
+import '../chunk-Z7IL735U.js';
+import { Cmd, acceptedTypes, NoCellError } from '../chunk-GAVLND5C.js';
+import { Effect, Scope, Exit, Schema } from 'effect';
 
 var tell = (machine, runtime, msg) => Effect.suspend(
   () => acceptedTypes(machine, runtime.getState()).includes(msg.type) ? runtime.dispatch(msg) : Effect.void
@@ -29,7 +29,45 @@ var spawn = (parentScope, steps) => Effect.uninterruptible(
   })
 );
 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, spawn, stop, tell };
 //# 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/children.ts","../../src/effect/cmd.ts"],"names":["Cmd"],"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;AC1I9B,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 * 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","/**\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, S as Store } from '../runtime-types-BPKp2bGo.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-BKJW1Kmq.js';
+import { S as SubscribeHandler } from '../types-BiXj7k_k.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-VHKDUBXC.js';
+import { describeError } from '../chunk-GAVLND5C.js';
 import { useRef, useSyncExternalStore, useEffect, useCallback, createContext, useMemo, useContext } from 'react';
 import { jsx } from 'react/jsx-runtime';