@demlik/tea 0.14.0 → 0.16.0

package/dist/{durable-effects-B0-qGQDy.d.ts → durable-effects-7MTK_jnj.d.ts}

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

package/dist/effect/index.d.ts

@@ -0,0 +1,151 @@
+import { Effect, Stream, Scope } from 'effect';
+import { C as Cmd, E as ErrorsOf, O as OkOfCmd, D as DeclaredErrorsOf, S as Sub, B as BuiltinSubType, a as BuiltinSub, M as Machine } from '../core-BbgtiXdg.js';
+import { C as CtxArg, S as Store, O as OnError, a as Supervision, T as TelemetrySink, B as BootingRuntime } from '../runtime-types-CiVpC0HN.js';
+import '@standard-schema/spec';
+
+/**
+ * The Effect engine's `run` (#283): the same machine the Promise engine runs,
+ * with Effect handlers, Effect sub runners, the caller's Layers and
+ * interruption on stop.
+ *
+ * It runs the one core loop both engines share (`src/internal/engine/loop.ts`)
+ * with the same built-ins in the same order, so a machine folds the same way on
+ * either engine. What this file adds is the Effect edge:
+ *
+ *   - an `interpret` cell returns `Effect<Ok, E, R>`, read with
+ *     `Effect.result`: a success settles `_ok`, a declared failure settles
+ *     `_err`, a defect goes to the error sink;
+ *   - a `subscribe` runner returns a `Stream<Msg>`, drained on its own fiber;
+ *   - every handler and runner fiber runs with the services the caller
+ *     provided, so `R` reaches them from the caller's Layers;
+ *   - stopping interrupts every handler fiber still in flight.
+ */
+
+/**
+ * One Effect `interpret` cell. For a `Cmd.define`d Cmd it succeeds with the
+ * Cmd's `Ok` and fails with one of its declared tags, and the engine mints
+ * `<name>_ok` / `<name>_err` from that (ADR 0021). For a hand-written Cmd it
+ * succeeds with a follow-up Msg or nothing, and a failure rejects the dispatch,
+ * as a throw does on the Promise engine. `R` is whatever services it reads.
+ */
+type EffectInterpretCell<M extends {
+    type: string;
+}, C extends Cmd, R = unknown> = unknown extends ErrorsOf<C> ? (cmd: C) => Effect.Effect<M | void, unknown, R> : (cmd: C) => Effect.Effect<OkOfCmd<C>, DeclaredErrorsOf<C>, R>;
+/**
+ * The Effect engine's `interpret` map: one cell per Cmd variant, each reading
+ * services within `R`.
+ */
+type EffectInterpret<M extends {
+    type: string;
+}, C extends Cmd, R = unknown> = {
+    readonly [K in C["type"]]: EffectInterpretCell<M, Extract<C, {
+        type: K;
+    }>, R>;
+};
+/**
+ * One Effect sub runner: the Sub in, a `Stream` of Msgs out. The engine drains
+ * it on its own fiber and interrupts that fiber when the Sub stops. A stream
+ * that fails reaches the error sink under `"follow-up"`.
+ */
+type EffectRunner<M extends {
+    type: string;
+}, U extends Sub, R = unknown> = (sub: U) => Stream.Stream<M, unknown, R>;
+/**
+ * The Effect engine's `subscribe` map: a runner for every Sub type the machine
+ * declares beyond the built-ins, and optionally one for a built-in, which
+ * replaces the engine's own (#270 R2.1).
+ */
+type EffectSubscribe<M extends {
+    type: string;
+}, U extends Sub, R = unknown> = {
+    readonly [K in Exclude<U["type"], BuiltinSubType>]: EffectRunner<M, Extract<U, {
+        type: K;
+    }>, R>;
+} & {
+    readonly [K in BuiltinSubType]?: EffectRunner<M, Extract<BuiltinSub<M>, {
+        type: K;
+    }>, R>;
+};
+/** The services every cell of an `interpret` map reads. */
+type InterpretServices<I> = {
+    [K in keyof I]: ServicesOfCell<I[K]>;
+}[keyof I];
+type ServicesOfCell<F> = F extends (cmd: never) => Effect.Effect<unknown, unknown, infer R> ? R : never;
+/** The services every runner of a `subscribe` map reads. */
+type SubscribeServices<B> = {
+    [K in keyof B]-?: ServicesOfRunner<NonNullable<B[K]>>;
+}[keyof B];
+type ServicesOfRunner<F> = F extends (sub: never) => Stream.Stream<unknown, unknown, infer R> ? R : never;
+type InterpretOption<C extends Cmd, I> = [C] extends [Cmd<never>] ? {
+    readonly interpret?: I;
+} : {
+    readonly interpret: I;
+};
+type SubscribeOption<U extends Sub, B> = [
+    Exclude<U["type"], BuiltinSubType>
+] extends [never] ? {
+    readonly subscribe?: B;
+} : {
+    readonly subscribe: B;
+};
+/**
+ * The options of the Effect engine's `run`. Beside `interpret` and
+ * `subscribe`, they are the Promise engine's, with the same meaning; see `run`
+ * in `@demlik/tea/promise` for each one's contract.
+ */
+type EffectRunOptions<S, M extends {
+    type: string;
+}, C extends Cmd, U extends Sub, Ctx, E extends {
+    type: string;
+}, I, B> = CtxArg<Ctx> & InterpretOption<C, I> & SubscribeOption<U, B> & {
+    readonly store?: Store<S>;
+    readonly onError?: OnError;
+    /** Stamps `at` on minted Msgs and telemetry. Defaults to `Date.now`. */
+    readonly clock?: () => number;
+    /** Projects each applied transition to the public events `on` serves. */
+    readonly events?: (msg: M, state: S) => readonly E[];
+    /** The policy for a reducer throw. Defaults to `"stop"`. */
+    readonly supervision?: Supervision<S, M>;
+    /** The terminal predicate `result()` and `done()` read. */
+    readonly terminal?: (state: S) => boolean;
+    /** A fire-and-forget sink for every applied transition. */
+    readonly telemetry?: TelemetrySink;
+    /** How long `stop()` waits for async teardown. Defaults to 5_000ms. */
+    readonly disposeTimeoutMs?: number;
+};
+/**
+ * Run `machine` on the Effect engine. The returned Effect needs a `Scope` and
+ * the services its handlers and runners read, and yields the run handle —
+ * the same handle the Promise engine returns, so a host adapter typed against
+ * `RunHandle` takes either.
+ *
+ * Closing the scope stops the run: every handler still in flight is
+ * interrupted (its finalizers run), its Msg is never dispatched, and no Msg is
+ * dispatched after stop. Calling `stop()` on the handle does the same.
+ *
+ * A fenced store is fenced here exactly as on the Promise engine: the check is
+ * one of the built-ins both engines run.
+ *
+ * ```ts
+ * const program = Effect.gen(function* () {
+ *   const rt = yield* run(machine, {
+ *     interpret: {
+ *       fetch: (cmd) =>
+ *         Effect.gen(function* () {
+ *           const api = yield* Api;
+ *           return yield* api.get(cmd.id);
+ *         }),
+ *     },
+ *   });
+ *   yield* Effect.promise(() => rt.dispatch({ type: "go", id: "7" }));
+ * });
+ * Effect.runPromise(program.pipe(Effect.scoped, Effect.provide(ApiLive)));
+ * ```
+ */
+declare function run<S, M extends {
+    type: string;
+}, C extends Cmd, U extends Sub, Ctx, I extends EffectInterpret<M, C> = EffectInterpret<M, C, never>, B extends EffectSubscribe<M, U> = EffectSubscribe<M, U, never>, E extends {
+    type: string;
+} = never>(machine: Machine<S, M, C, U, Ctx>, opts: EffectRunOptions<S, M, C, U, Ctx, E, I, B>): Effect.Effect<BootingRuntime<S, M, E>, never, Scope.Scope | InterpretServices<I> | SubscribeServices<B>>;
+
+export { type EffectInterpret, type EffectInterpretCell, type EffectRunOptions, type EffectRunner, type EffectSubscribe, type InterpretServices, type SubscribeServices, run };

package/dist/effect/index.js

@@ -0,0 +1,98 @@
+import { startLoop, builtinExtensions } from '../chunk-5XU6ZJO2.js';
+import { subEntriesOf, applyCell, Outcome } from '../chunk-CH5KTOEZ.js';
+import { Effect, Stream, Cause, Fiber, Exit, Result } from 'effect';
+
+function timer(sub) {
+  return Stream.fromEffect(Effect.as(Effect.sleep(sub.deps.ms), sub.deps.msg));
+}
+var builtinRunners = { timer };
+function run(machine, opts) {
+  return Effect.gen(function* () {
+    const services = yield* Effect.context();
+    return yield* Effect.acquireRelease(
+      Effect.sync(
+        () => start(
+          machine,
+          opts,
+          Effect.runPromiseExitWith(services),
+          Effect.runForkWith(services)
+        )
+      ),
+      (runtime) => Effect.promise(() => runtime.stop())
+    );
+  });
+}
+function start(machine, opts, runEffect, fork) {
+  const interpret = opts.interpret ?? {};
+  const subscribe = opts.subscribe ?? {};
+  const builtins = builtinRunners;
+  const defined = new Set((machine.cmds ?? []).map((def) => def.cmdType));
+  const interruption = new AbortController();
+  let report = () => {
+  };
+  const edge = (loop) => {
+    report = loop.report;
+    return {};
+  };
+  async function settle(cell, cmd) {
+    const type = cmd.type;
+    const exit = await runEffect(Effect.result(cell(cmd)), {
+      signal: interruption.signal
+    });
+    if (Exit.isFailure(exit)) {
+      if (Cause.hasInterruptsOnly(exit.cause)) return void 0;
+      throw Cause.squash(exit.cause);
+    }
+    const result = exit.value;
+    if (defined.has(type)) {
+      return Result.isSuccess(result) ? Outcome.ok(result.success) : Outcome.err(result.failure);
+    }
+    if (Result.isFailure(result)) throw result.failure;
+    return result.success;
+  }
+  function handlerFor(type) {
+    const cell = interpret[type];
+    if (cell === void 0) return void 0;
+    return (cmd) => settle(cell, cmd);
+  }
+  function runnerFor(type) {
+    const make = subscribe[type] ?? builtins[type];
+    if (make === void 0) return void 0;
+    return (sub, _ctx, dispatch) => {
+      const drain = Stream.runForEach(
+        make(sub),
+        (msg) => Effect.sync(() => dispatch(msg))
+      ).pipe(
+        Effect.catchCause(
+          (cause) => Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.sync(() => report(Cause.squash(cause), "follow-up"))
+        )
+      );
+      const fiber = fork(drain);
+      return () => Effect.runPromise(Fiber.interrupt(fiber));
+    };
+  }
+  const handle = startLoop({
+    init: machine.init,
+    reduce: (state, msg) => applyCell(machine, state, msg),
+    subs: subEntriesOf(machine),
+    runnerFor,
+    handlerFor,
+    store: opts.store,
+    ctx: opts.ctx ?? {},
+    onError: opts.onError,
+    disposeTimeoutMs: opts.disposeTimeoutMs ?? 5e3,
+    idleCap: 1e5,
+    extensions: [...builtinExtensions(machine, opts), edge]
+  });
+  const stopLoop = handle.stop;
+  handle.stop = () => {
+    const stopped = stopLoop();
+    interruption.abort();
+    return stopped;
+  };
+  return handle;
+}
+
+export { run };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/effect/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/effect/run.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["/**\n * The Effect engine's `run` (#283): the same machine the Promise engine runs,\n * with Effect handlers, Effect sub runners, the caller's Layers and\n * interruption on stop.\n *\n * It runs the one core loop both engines share (`src/internal/engine/loop.ts`)\n * with the same built-ins in the same order, so a machine folds the same way on\n * either engine. What this file adds is the Effect edge:\n *\n *   - an `interpret` cell returns `Effect<Ok, E, R>`, read with\n *     `Effect.result`: a success settles `_ok`, a declared failure settles\n *     `_err`, a defect goes to the error sink;\n *   - a `subscribe` runner returns a `Stream<Msg>`, drained on its own fiber;\n *   - every handler and runner fiber runs with the services the caller\n *     provided, so `R` reaches them from the caller's Layers;\n *   - stopping interrupts every handler fiber still in flight.\n */\n\nimport { Cause, Effect, Exit, Fiber, Result, type Scope, Stream } from \"effect\";\nimport { builtinExtensions } from \"../internal/engine/builtins\";\nimport {\n  type ExtensionFactory,\n  type LoopHandler,\n  type LoopRunner,\n  startLoop,\n} from \"../internal/engine/loop\";\nimport type {\n  BuiltinSub,\n  BuiltinSubType,\n  Cmd,\n  DeclaredErrorsOf,\n  ErrorsOf,\n  Machine,\n  OkOfCmd,\n  Sub,\n  TimerSub,\n} from \"../pure/core\";\nimport { applyCell, Outcome, subEntriesOf } from \"../pure/core\";\nimport type {\n  BootingRuntime,\n  CtxArg,\n  OnError,\n  RuntimeErrorPhase,\n  Store,\n  Supervision,\n  TelemetrySink,\n} from \"../runtime-types\";\n\n// === The handler and runner shapes ===\n\n/**\n * One Effect `interpret` cell. For a `Cmd.define`d Cmd it succeeds with the\n * Cmd's `Ok` and fails with one of its declared tags, and the engine mints\n * `<name>_ok` / `<name>_err` from that (ADR 0021). For a hand-written Cmd it\n * succeeds with a follow-up Msg or nothing, and a failure rejects the dispatch,\n * as a throw does on the Promise engine. `R` is whatever services it reads.\n */\nexport type EffectInterpretCell<\n  M extends { type: string },\n  C extends Cmd,\n  R = unknown,\n> =\n  unknown extends ErrorsOf<C>\n    ? // biome-ignore lint/suspicious/noConfusingVoidType: a hand-written Cmd's handler may settle with nothing\n      (cmd: C) => Effect.Effect<M | void, unknown, R>\n    : (cmd: C) => Effect.Effect<OkOfCmd<C>, DeclaredErrorsOf<C>, R>;\n\n/**\n * The Effect engine's `interpret` map: one cell per Cmd variant, each reading\n * services within `R`.\n */\nexport type EffectInterpret<\n  M extends { type: string },\n  C extends Cmd,\n  R = unknown,\n> = {\n  readonly [K in C[\"type\"]]: EffectInterpretCell<M, Extract<C, { type: K }>, R>;\n};\n\n/**\n * One Effect sub runner: the Sub in, a `Stream` of Msgs out. The engine drains\n * it on its own fiber and interrupts that fiber when the Sub stops. A stream\n * that fails reaches the error sink under `\"follow-up\"`.\n */\nexport type EffectRunner<\n  M extends { type: string },\n  U extends Sub,\n  R = unknown,\n> = (sub: U) => Stream.Stream<M, unknown, R>;\n\n/**\n * The Effect engine's `subscribe` map: a runner for every Sub type the machine\n * declares beyond the built-ins, and optionally one for a built-in, which\n * replaces the engine's own (#270 R2.1).\n */\nexport type EffectSubscribe<\n  M extends { type: string },\n  U extends Sub,\n  R = unknown,\n> = {\n  readonly [K in Exclude<U[\"type\"], BuiltinSubType>]: EffectRunner<\n    M,\n    Extract<U, { type: K }>,\n    R\n  >;\n} & {\n  readonly [K in BuiltinSubType]?: EffectRunner<\n    M,\n    Extract<BuiltinSub<M>, { type: K }>,\n    R\n  >;\n};\n\n/** The services every cell of an `interpret` map reads. */\nexport type InterpretServices<I> = {\n  [K in keyof I]: ServicesOfCell<I[K]>;\n}[keyof I];\n\ntype ServicesOfCell<F> = F extends (\n  cmd: never,\n) => Effect.Effect<unknown, unknown, infer R>\n  ? R\n  : never;\n\n/** The services every runner of a `subscribe` map reads. */\nexport type SubscribeServices<B> = {\n  [K in keyof B]-?: ServicesOfRunner<NonNullable<B[K]>>;\n}[keyof B];\n\ntype ServicesOfRunner<F> = F extends (\n  sub: never,\n) => Stream.Stream<unknown, unknown, infer R>\n  ? R\n  : never;\n\n// `interpret` is optional for a machine that emits no Cmd, and `subscribe` for\n// one that declares only built-in Subs — the same requiredness the Promise\n// engine's `RunHandlers` carries.\ntype InterpretOption<C extends Cmd, I> = [C] extends [Cmd<never>]\n  ? { readonly interpret?: I }\n  : { readonly interpret: I };\n\ntype SubscribeOption<U extends Sub, B> = [\n  Exclude<U[\"type\"], BuiltinSubType>,\n] extends [never]\n  ? { readonly subscribe?: B }\n  : { readonly subscribe: B };\n\n/**\n * The options of the Effect engine's `run`. Beside `interpret` and\n * `subscribe`, they are the Promise engine's, with the same meaning; see `run`\n * in `@demlik/tea/promise` for each one's contract.\n */\nexport type EffectRunOptions<\n  S,\n  M extends { type: string },\n  C extends Cmd,\n  U extends Sub,\n  Ctx,\n  E extends { type: string },\n  I,\n  B,\n> = CtxArg<Ctx> &\n  InterpretOption<C, I> &\n  SubscribeOption<U, B> & {\n    readonly store?: Store<S>;\n    readonly onError?: OnError;\n    /** Stamps `at` on minted Msgs and telemetry. Defaults to `Date.now`. */\n    readonly clock?: () => number;\n    /** Projects each applied transition to the public events `on` serves. */\n    readonly events?: (msg: M, state: S) => readonly E[];\n    /** The policy for a reducer throw. Defaults to `\"stop\"`. */\n    readonly supervision?: Supervision<S, M>;\n    /** The terminal predicate `result()` and `done()` read. */\n    readonly terminal?: (state: S) => boolean;\n    /** A fire-and-forget sink for every applied transition. */\n    readonly telemetry?: TelemetrySink;\n    /** How long `stop()` waits for async teardown. Defaults to 5_000ms. */\n    readonly disposeTimeoutMs?: number;\n  };\n\n// === Built-in runners ===\n\n/** `timer`: emit `deps.msg` once, `deps.ms` after the Sub starts. */\nfunction timer<M>(sub: TimerSub<M>): Stream.Stream<M> {\n  return Stream.fromEffect(Effect.as(Effect.sleep(sub.deps.ms), sub.deps.msg));\n}\n\n/** The Effect engine's built-in runners, keyed by the Sub type each runs. */\nconst builtinRunners = { timer } as const satisfies Record<\n  BuiltinSubType,\n  unknown\n>;\n\n// === run ===\n\n/**\n * Run `machine` on the Effect engine. The returned Effect needs a `Scope` and\n * the services its handlers and runners read, and yields the run handle —\n * the same handle the Promise engine returns, so a host adapter typed against\n * `RunHandle` takes either.\n *\n * Closing the scope stops the run: every handler still in flight is\n * interrupted (its finalizers run), its Msg is never dispatched, and no Msg is\n * dispatched after stop. Calling `stop()` on the handle does the same.\n *\n * A fenced store is fenced here exactly as on the Promise engine: the check is\n * one of the built-ins both engines run.\n *\n * ```ts\n * const program = Effect.gen(function* () {\n *   const rt = yield* run(machine, {\n *     interpret: {\n *       fetch: (cmd) =>\n *         Effect.gen(function* () {\n *           const api = yield* Api;\n *           return yield* api.get(cmd.id);\n *         }),\n *     },\n *   });\n *   yield* Effect.promise(() => rt.dispatch({ type: \"go\", id: \"7\" }));\n * });\n * Effect.runPromise(program.pipe(Effect.scoped, Effect.provide(ApiLive)));\n * ```\n */\nexport function run<\n  S,\n  M extends { type: string },\n  C extends Cmd,\n  U extends Sub,\n  Ctx,\n  // The defaults read no services, so an omitted map adds none to `R`.\n  I extends EffectInterpret<M, C> = EffectInterpret<M, C, never>,\n  B extends EffectSubscribe<M, U> = EffectSubscribe<M, U, never>,\n  E extends { type: string } = never,\n>(\n  machine: Machine<S, M, C, U, Ctx>,\n  opts: EffectRunOptions<S, M, C, U, Ctx, E, I, B>,\n): Effect.Effect<\n  BootingRuntime<S, M, E>,\n  never,\n  Scope.Scope | InterpretServices<I> | SubscribeServices<B>\n> {\n  return Effect.gen(function* () {\n    const services = yield* Effect.context<\n      InterpretServices<I> | SubscribeServices<B>\n    >();\n    return yield* Effect.acquireRelease(\n      Effect.sync(() =>\n        start<S, M, C, U, Ctx, E>(\n          machine,\n          opts as EffectRunOptions<S, M, C, U, Ctx, E, unknown, unknown>,\n          Effect.runPromiseExitWith(services) as RunEffect,\n          Effect.runForkWith(services) as ForkEffect,\n        ),\n      ),\n      (runtime) => Effect.promise(() => runtime.stop()),\n    );\n  });\n}\n\n/** Run an erased Effect to its Exit, interruptible through `signal`. */\ntype RunEffect = (\n  effect: Effect.Effect<unknown, unknown>,\n  options: { readonly signal: AbortSignal },\n) => Promise<Exit.Exit<unknown, unknown>>;\n\n/** Fork an erased Effect onto its own fiber. */\ntype ForkEffect = (\n  effect: Effect.Effect<unknown, unknown>,\n) => Fiber.Fiber<unknown, unknown>;\n\ntype AnyCell = (cmd: unknown) => Effect.Effect<unknown, unknown>;\ntype AnyRunner = (sub: Sub) => Stream.Stream<unknown, unknown>;\n\nfunction start<\n  S,\n  M extends { type: string },\n  C extends Cmd,\n  U extends Sub,\n  Ctx,\n  E extends { type: string },\n>(\n  machine: Machine<S, M, C, U, Ctx>,\n  opts: EffectRunOptions<S, M, C, U, Ctx, E, unknown, unknown>,\n  runEffect: RunEffect,\n  fork: ForkEffect,\n): BootingRuntime<S, M, E> {\n  const interpret = ((opts as { interpret?: unknown }).interpret ??\n    {}) as Readonly<Record<string, AnyCell | undefined>>;\n  const subscribe = ((opts as { subscribe?: unknown }).subscribe ??\n    {}) as Readonly<Record<string, AnyRunner | undefined>>;\n  const builtins = builtinRunners as unknown as Readonly<\n    Record<string, AnyRunner | undefined>\n  >;\n  const defined = new Set((machine.cmds ?? []).map((def) => def.cmdType));\n\n  // Aborted on stop: every handler fiber runs under this signal, so aborting\n  // it interrupts all of them at once.\n  const interruption = new AbortController();\n\n  // The loop's error sink, lent to the runners below: a stream that fails\n  // after it started has no caller to reject at.\n  let report: (error: unknown, phase: RuntimeErrorPhase) => void = () => {};\n  const edge: ExtensionFactory<S, M, C> = (loop) => {\n    report = loop.report;\n    return {};\n  };\n\n  // Read the cell's Effect with `Effect.result`, so a declared failure is a\n  // value and only a defect or an interruption is left in the Exit's cause.\n  async function settle(cell: AnyCell, cmd: unknown): Promise<unknown> {\n    const type = (cmd as { type: string }).type;\n    const exit = await runEffect(Effect.result(cell(cmd)), {\n      signal: interruption.signal,\n    });\n    if (Exit.isFailure(exit)) {\n      // Interrupted by stop: nothing to dispatch.\n      if (Cause.hasInterruptsOnly(exit.cause)) return undefined;\n      // A defect. For a defined Cmd the `Cmd.define` edge routes this throw to\n      // the error sink; for a hand-written one it rejects the dispatch.\n      throw Cause.squash(exit.cause);\n    }\n    const result = exit.value as Result.Result<unknown, unknown>;\n    if (defined.has(type)) {\n      return Result.isSuccess(result)\n        ? Outcome.ok(result.success)\n        : Outcome.err(result.failure);\n    }\n    if (Result.isFailure(result)) throw result.failure;\n    return result.success;\n  }\n\n  function handlerFor(type: string): LoopHandler<M> | undefined {\n    const cell = interpret[type];\n    if (cell === undefined) return undefined;\n    return (cmd) => settle(cell, cmd);\n  }\n\n  // A runner's Msgs reach the loop through its `dispatch`, which queues each\n  // one behind the step in progress — never a transition on the stream's own\n  // fiber (spike #260).\n  function runnerFor(type: string): LoopRunner<Ctx, M> | undefined {\n    const make = subscribe[type] ?? builtins[type];\n    if (make === undefined) return undefined;\n    return (sub, _ctx, dispatch) => {\n      const drain = Stream.runForEach(make(sub), (msg) =>\n        Effect.sync(() => dispatch(msg as M)),\n      ).pipe(\n        Effect.catchCause((cause) =>\n          Cause.hasInterruptsOnly(cause)\n            ? Effect.void\n            : Effect.sync(() => report(Cause.squash(cause), \"follow-up\")),\n        ),\n      );\n      const fiber = fork(drain);\n      return () => Effect.runPromise(Fiber.interrupt(fiber));\n    };\n  }\n\n  const handle = startLoop<S, M, C, Ctx>({\n    init: machine.init,\n    reduce: (state, msg) => applyCell<S, M, C>(machine, state, msg),\n    subs: subEntriesOf<S>(machine),\n    runnerFor,\n    handlerFor,\n    store: opts.store,\n    ctx: (opts.ctx ?? {}) as Ctx,\n    onError: opts.onError,\n    disposeTimeoutMs: opts.disposeTimeoutMs ?? 5_000,\n    idleCap: 100_000,\n    extensions: [...builtinExtensions<S, M, C, E>(machine, opts), edge],\n  });\n\n  // Stop closes the gate first, so nothing an interrupted handler leaves\n  // behind is dispatched, then interrupts every handler still in flight so the\n  // drain it waits on can finish.\n  const stopLoop = handle.stop;\n  handle.stop = () => {\n    const stopped = stopLoop();\n    interruption.abort();\n    return stopped;\n  };\n  return handle as unknown as BootingRuntime<S, M, E>;\n}\n"]}

package/dist/extension/index.d.ts

@@ -1,9 +1,8 @@
-import { R as Runtime, S as Store } from '../runtime-types-LWDoi943.js';
+import { R as Runtime, S as Store } from '../runtime-types-CiVpC0HN.js';
 import { ReactNode } from 'react';
-import { S as Sub } from '../core-CTzMJ82M.js';
-import { S as SubscribeHandler } from '../types-DP3f5NIl.js';
-import 'better-result';
-import 'zod';
+import { S as Sub } from '../core-BbgtiXdg.js';
+import { S as SubscribeHandler } from '../types-LxZxGYda.js';
+import '@standard-schema/spec';
 
 /**
  * Runtime bridge — expose a `@demlik/tea` runtime running in one chrome context
@@ -327,9 +326,9 @@ declare function createBackgroundRuntimeContext<S, M extends {
 }>(): BackgroundRuntimeContext<S, M>;
 
 type AlarmSubData = {
-    alarmName: string;
+    readonly alarmName: string;
 };
-declare function fromChromeAlarm<S extends Sub & AlarmSubData, M>(msgFn: (alarm: chrome.alarms.Alarm, sub: S) => M | null): SubscribeHandler<S, M, unknown>;
+declare function fromChromeAlarm<S extends Sub<string, AlarmSubData>, M>(msgFn: (alarm: chrome.alarms.Alarm, sub: S) => M | null): SubscribeHandler<S, M, unknown>;
 
 interface ChromeMessageOpts<S extends Sub, M> {
     /**

package/dist/extension/index.js

@@ -1,5 +1,6 @@
 import { describeError } from '../chunk-G5E74IJB.js';
-import { historyTracker, dispatchIfPresent } from '../chunk-RQULHGYH.js';
+import { historyTracker, dispatchIfPresent } from '../chunk-GOX2CYIM.js';
+import '../chunk-CH5KTOEZ.js';
 import { useRef, useSyncExternalStore, useEffect, useCallback, createContext, useMemo, useContext } from 'react';
 import { jsx } from 'react/jsx-runtime';
 
@@ -249,7 +250,7 @@ function createBackgroundRuntimeContext() {
 function fromChromeAlarm(msgFn) {
   return (sub, _ctx, dispatch) => {
     const listener = (alarm) => {
-      if (alarm.name !== sub.alarmName) return;
+      if (alarm.name !== sub.deps.alarmName) return;
       dispatchIfPresent(dispatch, msgFn(alarm, sub));
     };
     chrome.alarms.onAlarm.addListener(listener);