@demlik/tea 0.17.0 → 0.19.0

package/dist/drive-loop-CsUsW3Wo.d.ts

@@ -0,0 +1,127 @@
+import { C as CtxArg } from './runtime-types-BKg2CGMx.js';
+
+/**
+ * The default round bound when `opts.maxRounds` is omitted: **100**.
+ *
+ * A round is one drain of the pending Msgs plus one drain of the Cmds those
+ * folds emitted, so a settling machine costs a handful; 100 is loose enough
+ * that a legitimate retry ladder finishes inside it and tight enough that a
+ * genuine cycle stops rather than hangs.
+ */
+declare const DEFAULT_MAX_ROUNDS = 100;
+/**
+ * One entry of a driven run's history, in dispatch order.
+ *
+ * - `msg` — a Msg folded through the machine's reducer. The seed Msg is the
+ *   first entry of every trace; every later one is a settle Msg a handler
+ *   returned (or fired through its injected `dispatch`), or a Msg a running
+ *   Sub emitted.
+ * - `cmd` — a Cmd handed to an interpret handler. It is recorded BEFORE the
+ *   handler runs, so a trace recovered from a failed handler names the Cmd
+ *   that failed as its last entry.
+ */
+type DriveTraceEntry<M, C> = {
+    readonly kind: "msg";
+    readonly msg: M;
+} | {
+    readonly kind: "cmd";
+    readonly cmd: C;
+};
+/** What a settled `drive` hands back. */
+interface DriveResult<S, M, C> {
+    /** The state after the machine went quiet — no Msg pending, no Cmd unperformed. */
+    readonly state: S;
+    /**
+     * Every Msg folded and every Cmd dispatched, in order. Filtering it to its
+     * `msg` entries and replaying those through `replay` from the same initial
+     * state reproduces {@link DriveResult.state}.
+     */
+    readonly trace: readonly DriveTraceEntry<M, C>[];
+}
+/**
+ * `drive`'s `ctx` field. `CtxArg` widened by exactly one case: a machine
+ * declaring `ctx: undefined` in its `types` block — the pure shape every
+ * how-to on this package writes — may omit it too. `CtxArg` alone keeps `ctx`
+ * REQUIRED there, because `{}` is not assignable to `undefined`, which would
+ * make the common pure call site spell `{ ctx: undefined }` to say nothing.
+ * A machine whose `Ctx` carries a field a handler reads still requires it.
+ */
+type DriveCtxArg<Ctx> = [undefined] extends [Ctx] ? {
+    readonly ctx?: Ctx;
+} : CtxArg<Ctx>;
+/**
+ * The options both `drive`s take. `ctx` is conditionally optional (see
+ * {@link DriveCtxArg}).
+ */
+type DriveOptions<Ctx> = DriveCtxArg<Ctx> & {
+    /**
+     * The round bound. Exceeding it fails the drive with
+     * {@link DriveRoundsExceededError}; `drive` never returns a half-driven
+     * state. Defaults to {@link DEFAULT_MAX_ROUNDS} (100).
+     */
+    readonly maxRounds?: number;
+    /**
+     * The clock that stamps `at` on a `Cmd.define`d Cmd's minted `_ok` / `_err`
+     * Msg — the one `run` takes. Defaults to `Date.now`; pin it for a test that
+     * asserts on `at`.
+     */
+    readonly clock?: () => number;
+};
+/**
+ * Raised when a driven machine is still emitting work after `maxRounds` rounds.
+ * Follows the tea error dialect (`override readonly name`) and carries a `_tag`
+ * discriminant, so a test branches on it by `instanceof` or on the tag.
+ *
+ * It carries the round count it stopped at and the PARTIAL trace up to that
+ * point, which is what a test needs to see the cycle — the bound alone says
+ * only that one exists.
+ */
+declare class DriveRoundsExceededError<M, C> extends Error {
+    /** The bound that was exceeded. */
+    readonly maxRounds: number;
+    /** The round the driver stopped at — always `maxRounds + 1`. */
+    readonly rounds: number;
+    /** Every Msg folded and Cmd dispatched before the driver gave up. */
+    readonly trace: readonly DriveTraceEntry<M, C>[];
+    readonly name = "DriveRoundsExceededError";
+    readonly _tag: "DriveRoundsExceededError";
+    constructor(
+    /** The bound that was exceeded. */
+    maxRounds: number, 
+    /** The round the driver stopped at — always `maxRounds + 1`. */
+    rounds: number, 
+    /** Every Msg folded and Cmd dispatched before the driver gave up. */
+    trace: readonly DriveTraceEntry<M, C>[]);
+}
+/**
+ * Raised when a Cmd reaches `drive` with no handler for its `type` in the
+ * handler record. The record's mapped type makes that a compile error at a
+ * well-typed call site; this is the runtime arm for a handler record assembled
+ * dynamically or cast.
+ */
+declare class DriveNoHandlerError<M, C> extends Error {
+    /** The Cmd `type` nothing in the handler record answered. */
+    readonly cmdType: string;
+    /** Every Msg folded and Cmd dispatched before the miss. */
+    readonly trace: readonly DriveTraceEntry<M, C>[];
+    readonly name = "DriveNoHandlerError";
+    readonly _tag: "DriveNoHandlerError";
+    constructor(
+    /** The Cmd `type` nothing in the handler record answered. */
+    cmdType: string, 
+    /** Every Msg folded and Cmd dispatched before the miss. */
+    trace: readonly DriveTraceEntry<M, C>[]);
+}
+/**
+ * Read back the partial trace `drive` attached to an error a handler failed
+ * with. Returns `undefined` for anything `drive` did not annotate.
+ *
+ * A failing handler's error leaves `drive` UNSWALLOWED — same value, same
+ * `instanceof`, same `_tag` — so a test that already branches on the handler's
+ * own error type keeps doing so. The trace rides along on a non-enumerable
+ * property so it is recoverable without changing how the error prints or
+ * serializes.
+ */
+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 };

package/dist/{durable-effects-CNaw97Be.d.ts → durable-effects-BmUrRA-h.d.ts}

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

package/dist/effect/index.d.ts

@@ -1,151 +1,7 @@
-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-rDbOaJTN.js';
-import { C as CtxArg, S as Store, O as OnError, a as Supervision, T as TelemetrySink, B as BootingRuntime } from '../runtime-types-B62Ucnxr.js';
+export { C as CellErrors, c as EffectBootingRuntime, E as EffectInterpret, d as EffectInterpretCell, e as EffectRunOptions, f as EffectRunner, g as EffectRuntime, a as EffectSubscribe, I as InterpretServices, h as Stopped, i as StoreFailed, b as SubscribeServices, r as run } from '../index-BnsAqn0-.js';
+import 'effect/Cause';
+import 'effect/Types';
+import 'effect';
+import '../core-Ce9ncpuv.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 };
+import '../runtime-types-BKg2CGMx.js';

package/dist/effect/index.js

@@ -1,98 +1,6 @@
-import { startLoop, builtinExtensions } from '../chunk-KWNCM6XM.js';
-import { subEntriesOf, applyCell, Outcome } from '../chunk-K4ETBNKS.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 };
+export { Stopped, StoreFailed, run } from '../chunk-I7E7AD2S.js';
+import '../chunk-AHW2CLPT.js';
+import '../chunk-JVE2LBFJ.js';
+import '../chunk-AIIXV4XB.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/effect/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/effect/run.ts"],"names":[],"mappings":";;;;AAwLA,SAAS,MAAS,GAAA,EAAoC;AACpD,EAAA,OAAO,MAAA,CAAO,UAAA,CAAW,MAAA,CAAO,EAAA,CAAG,MAAA,CAAO,KAAA,CAAM,GAAA,CAAI,IAAA,CAAK,EAAE,CAAA,EAAG,GAAA,CAAI,IAAA,CAAK,GAAG,CAAC,CAAA;AAC7E;AAGA,IAAM,cAAA,GAAiB,EAAE,KAAA,EAAM;AAoCxB,SAAS,GAAA,CAWd,SACA,IAAA,EAKA;AACA,EAAA,OAAO,MAAA,CAAO,IAAI,aAAa;AAC7B,IAAA,MAAM,QAAA,GAAW,OAAO,MAAA,CAAO,OAAA,EAE7B;AACF,IAAA,OAAO,OAAO,MAAA,CAAO,cAAA;AAAA,MACnB,MAAA,CAAO,IAAA;AAAA,QAAK,MACV,KAAA;AAAA,UACE,OAAA;AAAA,UACA,IAAA;AAAA,UACA,MAAA,CAAO,mBAAmB,QAAQ,CAAA;AAAA,UAClC,MAAA,CAAO,YAAY,QAAQ;AAAA;AAC7B,OACF;AAAA,MACA,CAAC,OAAA,KAAY,MAAA,CAAO,QAAQ,MAAM,OAAA,CAAQ,MAAM;AAAA,KAClD;AAAA,EACF,CAAC,CAAA;AACH;AAgBA,SAAS,KAAA,CAQP,OAAA,EACA,IAAA,EACA,SAAA,EACA,IAAA,EACyB;AACzB,EAAA,MAAM,SAAA,GAAc,IAAA,CAAiC,SAAA,IACnD,EAAC;AACH,EAAA,MAAM,SAAA,GAAc,IAAA,CAAiC,SAAA,IACnD,EAAC;AACH,EAAA,MAAM,QAAA,GAAW,cAAA;AAGjB,EAAA,MAAM,OAAA,GAAU,IAAI,GAAA,CAAA,CAAK,OAAA,CAAQ,IAAA,IAAQ,EAAC,EAAG,GAAA,CAAI,CAAC,GAAA,KAAQ,GAAA,CAAI,OAAO,CAAC,CAAA;AAItE,EAAA,MAAM,YAAA,GAAe,IAAI,eAAA,EAAgB;AAIzC,EAAA,IAAI,SAA6D,MAAM;AAAA,EAAC,CAAA;AACxE,EAAA,MAAM,IAAA,GAAkC,CAAC,IAAA,KAAS;AAChD,IAAA,MAAA,GAAS,IAAA,CAAK,MAAA;AACd,IAAA,OAAO,EAAC;AAAA,EACV,CAAA;AAIA,EAAA,eAAe,MAAA,CAAO,MAAe,GAAA,EAAgC;AACnE,IAAA,MAAM,OAAQ,GAAA,CAAyB,IAAA;AACvC,IAAA,MAAM,IAAA,GAAO,MAAM,SAAA,CAAU,MAAA,CAAO,OAAO,IAAA,CAAK,GAAG,CAAC,CAAA,EAAG;AAAA,MACrD,QAAQ,YAAA,CAAa;AAAA,KACtB,CAAA;AACD,IAAA,IAAI,IAAA,CAAK,SAAA,CAAU,IAAI,CAAA,EAAG;AAExB,MAAA,IAAI,KAAA,CAAM,iBAAA,CAAkB,IAAA,CAAK,KAAK,GAAG,OAAO,MAAA;AAGhD,MAAA,MAAM,KAAA,CAAM,MAAA,CAAO,IAAA,CAAK,KAAK,CAAA;AAAA,IAC/B;AACA,IAAA,MAAM,SAAS,IAAA,CAAK,KAAA;AACpB,IAAA,IAAI,OAAA,CAAQ,GAAA,CAAI,IAAI,CAAA,EAAG;AACrB,MAAA,OAAO,MAAA,CAAO,SAAA,CAAU,MAAM,CAAA,GAC1B,OAAA,CAAQ,EAAA,CAAG,MAAA,CAAO,OAAO,CAAA,GACzB,OAAA,CAAQ,GAAA,CAAI,MAAA,CAAO,OAAO,CAAA;AAAA,IAChC;AACA,IAAA,IAAI,MAAA,CAAO,SAAA,CAAU,MAAM,CAAA,QAAS,MAAA,CAAO,OAAA;AAC3C,IAAA,OAAO,MAAA,CAAO,OAAA;AAAA,EAChB;AAEA,EAAA,SAAS,WAAW,IAAA,EAA0C;AAC5D,IAAA,MAAM,IAAA,GAAO,UAAU,IAAI,CAAA;AAC3B,IAAA,IAAI,IAAA,KAAS,QAAW,OAAO,MAAA;AAC/B,IAAA,OAAO,CAAC,GAAA,KAAQ,MAAA,CAAO,IAAA,EAAM,GAAG,CAAA;AAAA,EAClC;AAKA,EAAA,SAAS,UAAU,IAAA,EAA8C;AAC/D,IAAA,MAAM,IAAA,GAAO,SAAA,CAAU,IAAI,CAAA,IAAK,SAAS,IAAI,CAAA;AAC7C,IAAA,IAAI,IAAA,KAAS,QAAW,OAAO,MAAA;AAC/B,IAAA,OAAO,CAAC,GAAA,EAAK,IAAA,EAAM,QAAA,KAAa;AAC9B,MAAA,MAAM,QAAQ,MAAA,CAAO,UAAA;AAAA,QAAW,KAAK,GAAG,CAAA;AAAA,QAAG,CAAC,GAAA,KAC1C,MAAA,CAAO,KAAK,MAAM,QAAA,CAAS,GAAQ,CAAC;AAAA,OACtC,CAAE,IAAA;AAAA,QACA,MAAA,CAAO,UAAA;AAAA,UAAW,CAAC,KAAA,KACjB,KAAA,CAAM,iBAAA,CAAkB,KAAK,IACzB,MAAA,CAAO,IAAA,GACP,MAAA,CAAO,IAAA,CAAK,MAAM,MAAA,CAAO,KAAA,CAAM,OAAO,KAAK,CAAA,EAAG,WAAW,CAAC;AAAA;AAChE,OACF;AACA,MAAA,MAAM,KAAA,GAAQ,KAAK,KAAK,CAAA;AACxB,MAAA,OAAO,MAAM,MAAA,CAAO,UAAA,CAAW,KAAA,CAAM,SAAA,CAAU,KAAK,CAAC,CAAA;AAAA,IACvD,CAAA;AAAA,EACF;AAEA,EAAA,MAAM,SAAS,SAAA,CAAwB;AAAA,IACrC,MAAM,OAAA,CAAQ,IAAA;AAAA,IACd,QAAQ,CAAC,KAAA,EAAO,QAAQ,SAAA,CAAmB,OAAA,EAAS,OAAO,GAAG,CAAA;AAAA,IAC9D,IAAA,EAAM,aAAgB,OAAO,CAAA;AAAA,IAC7B,SAAA;AAAA,IACA,UAAA;AAAA,IACA,OAAO,IAAA,CAAK,KAAA;AAAA,IACZ,GAAA,EAAM,IAAA,CAAK,GAAA,IAAO,EAAC;AAAA,IACnB,SAAS,IAAA,CAAK,OAAA;AAAA,IACd,gBAAA,EAAkB,KAAK,gBAAA,IAAoB,GAAA;AAAA,IAC3C,OAAA,EAAS,GAAA;AAAA,IACT,YAAY,CAAC,GAAG,kBAA8B,OAAA,EAAS,IAAI,GAAG,IAAI;AAAA,GACnE,CAAA;AAKD,EAAA,MAAM,WAAW,MAAA,CAAO,IAAA;AACxB,EAAA,MAAA,CAAO,OAAO,MAAM;AAClB,IAAA,MAAM,UAAU,QAAA,EAAS;AACzB,IAAA,YAAA,CAAa,KAAA,EAAM;AACnB,IAAA,OAAO,OAAA;AAAA,EACT,CAAA;AACA,EAAA,OAAO,MAAA;AACT","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"]}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/extension/index.d.ts

@@ -1,7 +1,7 @@
-import { R as Runtime, S as Store } from '../runtime-types-B62Ucnxr.js';
+import { R as Runtime, M as Migrated, S as Store } from '../runtime-types-BKg2CGMx.js';
 import { ReactNode } from 'react';
-import { S as Sub } from '../core-rDbOaJTN.js';
-import { S as SubscribeHandler } from '../types-DPm5YCDQ.js';
+import { c as Sub } from '../core-Ce9ncpuv.js';
+import { S as SubscribeHandler } from '../types-SzNSHKlV.js';
 import '@standard-schema/spec';
 
 /**
@@ -516,7 +516,9 @@ declare function fakeChrome(): FakeChrome;
  * at the key, or unparseable JSON) — matches @demlik/tea/do's "throw at boot via
  * store.load" contract so tea's `run()` surfaces it predictably. The
  * `parse` callback handles the semantic layer (shape mismatch → return
- * `null`); it must NOT throw, per the `Store<S>.migrate` contract.
+ * `refuse(reason)`, nothing saved → `null`); it must NOT throw, per the
+ * `Store<S>.migrate` contract. A throw or a refusal makes `ready` reject
+ * with `StoreRefusedError`, and nothing is saved.
  *
  * `parse` is REQUIRED because chrome.storage is a real serialization boundary
  * — JSON to disk, then back — and the structural type of what comes back is
@@ -536,6 +538,6 @@ declare function fakeChrome(): FakeChrome;
  * single writer, and that is a precondition to keep, not one this store can
  * enforce. See `docs/explanation/durability-model.md`.
  */
-declare function chromeStorageStore<S>(key: string, parse: (raw: unknown) => S | null, area?: chrome.storage.StorageArea): Store<S>;
+declare function chromeStorageStore<S>(key: string, parse: (raw: unknown) => Migrated<S>, area?: chrome.storage.StorageArea): Store<S>;
 
 export { type BackgroundRuntimeContext, type BridgeClient, type BridgeClientOpts, type BridgeRuntimeOpts, type BridgeTabClientOpts, type ChromeMessageOpts, type ChromeStorageChangeOpts, type ChromeTabsEventOpts, type FakeChrome, type TabsEventName, type UseBackgroundRuntimeOpts, type UseBackgroundRuntimeResult, bridgeClient, bridgeRuntime, bridgeTabClient, chromeStorageStore, createBackgroundRuntimeContext, fakeChrome, fromChromeAlarm, fromChromeMessage, fromChromeStorageChange, fromChromeTabsEvent, passThroughMsg, useBackgroundRuntime };

package/dist/extension/index.js

@@ -1,6 +1,5 @@
-import { describeError } from '../chunk-G5E74IJB.js';
-import { historyTracker, dispatchIfPresent } from '../chunk-C4U5D5HP.js';
-import '../chunk-K4ETBNKS.js';
+import { historyTracker, dispatchIfPresent } from '../chunk-FNGZMVIT.js';
+import { describeError } from '../chunk-AIIXV4XB.js';
 import { useRef, useSyncExternalStore, useEffect, useCallback, createContext, useMemo, useContext } from 'react';
 import { jsx } from 'react/jsx-runtime';