@demlik/tea 0.3.0 → 0.5.0

package/dist/resilient-call/index.js

@@ -1,14 +1,14 @@
-export { createResilientCall, liftResilience } from '../chunk-IXBKFQH5.js';
+export { createResilientCall, liftResilience } from '../chunk-W2S4HK7J.js';
 import '../chunk-JELSZN25.js';
-export { deadlineSub, subscribeDeadline } from '../chunk-RMX4EOQK.js';
+export { deadlineSub, subscribeDeadline } from '../chunk-ZT3MGQB7.js';
 import '../chunk-Q2UM7BXU.js';
 import '../chunk-S2EGRPCM.js';
 import '../chunk-UF4MZSLT.js';
-import '../chunk-2KNLKQVN.js';
-import '../chunk-LYLDCIPH.js';
+import '../chunk-7UU5P2CX.js';
+import '../chunk-QKUWDC4P.js';
 import '../chunk-2YFLOCWX.js';
 import '../chunk-ZJ5AOYBH.js';
-import '../chunk-BP2R7TPP.js';
-import '../chunk-PBDYW2TU.js';
+import '../chunk-PBAYOJJO.js';
+import '../chunk-DBOJ2UC6.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/{runtime-types-gsog27b6.d.ts → runtime-types-uBuVvZqa.d.ts}

@@ -1,4 +1,4 @@
-import { P as Port, C as Cmd, S as Sub, M as Machine, T as Transitions, R as Reducer, I as InterpretDetached, b as PortEmitter } from './core-42kapW0n.js';
+import { P as Port, C as Cmd, S as Sub, M as Machine, T as Transitions, R as Reducer, I as InterpretDetached, b as PortEmitter } from './core-DPYOyOJv.js';
 
 /**
  * @demlik/tea runtime interface surface + pure helpers — the public types,
@@ -68,6 +68,8 @@ declare function __resetPortRegistry(): void;
  *
  * - `"follow-up"` — a follow-up Msg an interpret handler returned rejected when
  *   re-dispatched (the original dispatcher already resolved, so no caller).
+ *   A rejection caused by `stop()`'s own teardown is NOT this phase — see
+ *   `"discard"`.
  * - `"stop-save"` — the final `store.save(state)` inside `stop()` threw
  *   (`stop()` resolves regardless, so without the sink this was silent loss).
  * - `"reduce"` — the pure `update` (reducer) threw synchronously; the configured
@@ -80,8 +82,25 @@ declare function __resetPortRegistry(): void;
  * - `"port-emit"` — a `subscribePort` listener threw during a port emission.
  * - `"sub-cleanup"` — a subscription's cleanup threw (reconcile-removal or
  *   `stop()` teardown).
+ * - `"discard"` — work lost to a teardown the host asked for. Two witnesses,
+ *   both carrying a `RuntimeDiscardNotice`: `stop()` was called while interpret
+ *   handlers were still awaiting (`RuntimeDiscardedError`), and a Msg that
+ *   arrived DURING `stop()`'s drain and so could not be delivered
+ *   (`DispatchDiscardedError`), and teardown work that did not settle inside
+ *   `disposeTimeoutMs` (`DisposeTimeoutNotice`). The one phase that is a
+ *   LIFECYCLE report rather than a failure: legal, merely lossy.
+ * - `"identity-drop"` — the `Identity` filter dropped a message addressed to a
+ *   different instance (`IdentityDropNotice`). Its own phase rather than
+ *   `"discard"`: the loss is the FILTER WORKING, not a teardown, and a host
+ *   routing it (a metric, a 409 back to the caller) wants it apart from
+ *   unmount-time noise. Warn-only, like every `RuntimeDiscardNotice`.
+ *
+ * The phase never decides fatality — the ERROR CLASS does (`RuntimeDiscardNotice`
+ * warns, everything else rethrows). A phase is attached by the report site, so a
+ * consumer sink that throws while handling a `"discard"` report inherits that
+ * phase; keying the warn-only path on it would make the sink's own defect vanish.
  */
-type RuntimeErrorPhase = "follow-up" | "stop-save" | "reduce" | "listener" | "observer" | "event" | "boot" | "port-emit" | "sub-cleanup";
+type RuntimeErrorPhase = "follow-up" | "stop-save" | "reduce" | "listener" | "observer" | "event" | "boot" | "port-emit" | "sub-cleanup" | "discard" | "identity-drop";
 /** Context handed to an `OnError` sink alongside the error itself. */
 interface RuntimeErrorContext {
     readonly phase: RuntimeErrorPhase;
@@ -133,6 +152,101 @@ declare class QuiescenceTimeoutError extends Error {
     readonly _tag: "QuiescenceTimeoutError";
     constructor(iterations: number);
 }
+/**
+ * Base of the LOSSY-BUT-LEGAL teardown facts: work the host discarded by letting
+ * go of a runtime that still had something outstanding. Reported under
+ * `phase: "discard"`, never raised.
+ *
+ * It exists so "is this fatal?" has ONE definition — `error instanceof
+ * RuntimeDiscardNotice` — that the default sink can ask about any error from any
+ * site. The phase cannot answer it: a report site attaches the phase, so a
+ * consumer sink that throws while handling a `"discard"` report carries that
+ * phase into the sink-failure path, and a phase-keyed warn branch would swallow
+ * the sink's own defect. Sub-classing is how a new teardown fact opts into the
+ * warn-only treatment; nothing else can.
+ */
+declare abstract class RuntimeDiscardNotice extends Error {
+}
+/**
+ * Reported to the `OnError` sink under `phase: "discard"` when `stop()` is
+ * called while `interpret` handlers are still awaiting. The host is dropping
+ * its only handle on that work: `stop()` drains the tail, but the listeners,
+ * observers and event handlers that would have consumed the resulting
+ * transitions are gone, so the Cmds' results reach nobody.
+ *
+ * The motivating shape is `@demlik/tea/react`'s `useMachine`, which memoizes on
+ * `[machine, ctx, store]` — a ctx re-derived mid-flight replaces the runtime,
+ * and the in-flight mutation's response arrives for a runtime the UI no longer
+ * renders, silently rewinding the visible state. Never a throw: tearing a
+ * runtime down mid-flight is legal (a navigation does it every time), so this
+ * is surfaced as data, not raised. Mechanizes invariant 6 (no silent failures)
+ * at the teardown seam, the role `QuiescenceTimeoutError` plays for `idle()`.
+ */
+declare class RuntimeDiscardedError extends RuntimeDiscardNotice {
+    readonly pendingCmds: number;
+    readonly name = "RuntimeDiscardedError";
+    readonly _tag: "RuntimeDiscardedError";
+    constructor(pendingCmds: number);
+}
+/**
+ * Reported to the `OnError` sink under `phase: "identity-drop"` when the
+ * `Identity` filter drops a message addressed to a different instance.
+ *
+ * The drop itself is the feature — it is what lets a reducer stop repeating
+ * `if (msg.runId !== state.runId) return`. What was missing is that it was
+ * INVISIBLE: the dispatch resolved exactly like an applied one, so a reusable
+ * Durable Object serving run A and then run B lost every run-B message and
+ * reported success to each caller. The comment claiming "the one observable
+ * enforcement point" described this notice before it existed.
+ *
+ * Never fatal (`RuntimeDiscardNotice`): a mis-addressed message is a normal
+ * consequence of instance reuse, not a defect. A host that wants to act on it
+ * — a metric, a 409 to the caller, a re-route — reads `phase: "identity-drop"`
+ * in its own sink.
+ */
+declare class IdentityDropNotice extends RuntimeDiscardNotice {
+    readonly msgType: string;
+    readonly name = "IdentityDropNotice";
+    readonly _tag: "IdentityDropNotice";
+    constructor(msgType: string);
+}
+/**
+ * Reported to the `OnError` sink under `phase: "discard"` when `stop()`'s wait
+ * for async teardown work hits `disposeTimeoutMs`.
+ *
+ * `stop()` awaits the disposals it started so `await runtime.stop()` can mean
+ * "safe to evict". A `release` that never settles must not turn that guarantee
+ * into a host that never shuts down, so the wait is bounded and expiry is
+ * REPORTED rather than silently tolerated — the resource is genuinely still
+ * open at that point, and only the host can decide what that costs.
+ */
+declare class DisposeTimeoutNotice extends RuntimeDiscardNotice {
+    readonly pendingDisposals: number;
+    readonly timeoutMs: number;
+    readonly name = "DisposeTimeoutNotice";
+    readonly _tag: "DisposeTimeoutNotice";
+    constructor(pendingDisposals: number, timeoutMs: number);
+}
+/**
+ * The rejection of a dispatch that arrived DURING `stop()`'s drain — an in-flight
+ * interpret handler's follow-up Msg, a detached handler's terminal Msg, or a Sub
+ * that is still live because subs are torn down only after the drain. The stop
+ * barrier is absolute (the Msg is refused, never folded), so this names the loss.
+ *
+ * It is the SECOND witness of `RuntimeDiscardedError`'s fact, and it is why the
+ * drain window is a distinct runtime state rather than a plain `stopped` flag:
+ * a Msg refused inside the window was discarded BY the teardown, while the same
+ * refusal after `stop()` has returned is a consumer dispatching into a runtime it
+ * already retired — a real error, and still loud (`phase: "follow-up"`, or the
+ * caller's own rejection). The distinction is the state at refusal time, never
+ * the message text.
+ */
+declare class DispatchDiscardedError extends RuntimeDiscardNotice {
+    readonly msgType: string;
+    readonly name = "DispatchDiscardedError";
+    readonly _tag: "DispatchDiscardedError";
+    constructor(msgType: string);
+}
 /**
  * Define a typed port. `name` is metadata (devtools / debug logs); port identity
  * is by reference. Each definePort call must use a unique `name` — a second call
@@ -334,4 +448,4 @@ declare function wrapDetached<C extends Cmd, M extends {
 }, Allowed extends M, Ctx>(handler: InterpretDetached<C, Allowed, Ctx>): (cmd: C, ctx: Ctx & PortEmitter, dispatch?: (msg: M) => void) => Promise<void>;
 declare function tryInterpret<C extends Cmd, Ok, M, Ctx>(work: (cmd: C, ctx: Ctx) => Promise<Ok>, onOk: (value: Ok, cmd: C) => M, onErr: (error: unknown, cmd: C) => M): (cmd: C, ctx: Ctx) => Promise<M>;
 
-export { type BootingRuntime as B, type CtxArg as C, type DispatchSettle as D, type OnError as O, PortNameCollisionError as P, QuiescenceTimeoutError as Q, type Runtime as R, type Store as S, __resetPortRegistry as _, type Supervision as a, type Branded as b, absurd as c, SubIdCollisionError as d, type RuntimeErrorPhase as e, type RuntimeErrorContext as f, type SupervisionStrategy as g, definePort as h, type Schema as i, type RuntimeRef as j, defineMachine as k, asReducer as l, noop as n, replay as r, schemaMigrate as s, tryInterpret as t, wrapDetached as w };
+export { type BootingRuntime as B, type CtxArg as C, DisposeTimeoutNotice as D, IdentityDropNotice as I, type OnError as O, PortNameCollisionError as P, QuiescenceTimeoutError as Q, type Runtime as R, type Store as S, __resetPortRegistry as _, type Supervision as a, type Branded as b, absurd as c, SubIdCollisionError as d, type RuntimeErrorPhase as e, type RuntimeErrorContext as f, type SupervisionStrategy as g, RuntimeDiscardNotice as h, RuntimeDiscardedError as i, DispatchDiscardedError as j, definePort as k, type Schema as l, type DispatchSettle as m, noop as n, type RuntimeRef as o, defineMachine as p, asReducer as q, replay as r, schemaMigrate as s, tryInterpret as t, wrapDetached as w };

package/dist/saga/index.d.ts

@@ -1,6 +1,6 @@
-import { C as Cmd } from '../core-42kapW0n.js';
+import { C as Cmd } from '../core-DPYOyOJv.js';
 import { QueueItem } from '../work-queue/index.js';
-import '../runtime-types-gsog27b6.js';
+import '../runtime-types-uBuVvZqa.js';
 
 /**
  * @packageDocumentation

package/dist/snapshot/index.d.ts

@@ -1,4 +1,4 @@
-import { C as Cmd, c as Interpret } from '../core-42kapW0n.js';
+import { C as Cmd, c as Interpret } from '../core-DPYOyOJv.js';
 
 /**
  * @demlik/tea/snapshot — periodic state checkpoint to a host store (R2/KV-shaped).

package/dist/snapshot/index.js

@@ -1,5 +1,5 @@
-export { createSnapshot, snapshotFailed, snapshotLoadFailed, snapshotLoaded, snapshotSaved } from '../chunk-MVY5DAMF.js';
-import '../chunk-BP2R7TPP.js';
-import '../chunk-PBDYW2TU.js';
+export { createSnapshot, snapshotFailed, snapshotLoadFailed, snapshotLoaded, snapshotSaved } from '../chunk-KWPB6BM6.js';
+import '../chunk-PBAYOJJO.js';
+import '../chunk-DBOJ2UC6.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/subs/index.d.ts

@@ -1,6 +1,6 @@
-import { S as Sub, P as Port, D as DepKeyedSub, a as SubId } from '../core-42kapW0n.js';
-import { S as SubscribeHandler } from '../types-KbL3W1mj.js';
-import { R as Runtime } from '../runtime-types-gsog27b6.js';
+import { S as Sub, P as Port, e as Dispose, D as DepKeyedSub, a as SubId } from '../core-DPYOyOJv.js';
+import { S as SubscribeHandler } from '../types-C6mXL9wA.js';
+import { R as Runtime } from '../runtime-types-uBuVvZqa.js';
 
 /**
  * The imperative listener target, expressed as the `add`/`remove` pair the
@@ -177,7 +177,7 @@ interface GatedManagedResource<S, TKey, Ctx> {
      * `managed_resource` Sub to the entry whose `owns(sub)` is true, then calls
      * this.
      */
-    readonly subscribe: (sub: ManagedResourceSub<TKey>, ctx: Ctx, dispatch: (msg: never) => void) => () => void;
+    readonly subscribe: (sub: ManagedResourceSub<TKey>, ctx: Ctx, dispatch: (msg: never) => void) => Dispose;
     /**
      * Does this entry own the given Sub? `sub.id === subIdFor(sub.key)` encodes
      * the battery `name`, so a match is unambiguous.
@@ -202,7 +202,7 @@ interface CombinedManagedResources<S, TKey, Ctx> {
      * id encodes the battery `name`). Throws loudly on an unrouted id — a wiring
      * bug, never a silent no-op resource.
      */
-    readonly subscribe: (sub: ManagedResourceSub<TKey>, ctx: Ctx, dispatch: (msg: never) => void) => () => void;
+    readonly subscribe: (sub: ManagedResourceSub<TKey>, ctx: Ctx, dispatch: (msg: never) => void) => Dispose;
 }
 interface DefineManagedResourceOpts<TKey, Handle, Ctx> {
     /**
@@ -222,9 +222,16 @@ interface DefineManagedResourceOpts<TKey, Handle, Ctx> {
     /**
      * Tear the resource down. Runs when the Sub leaves the desired set (phase
      * exited) or when its key changes. MANDATORY — the guaranteed teardown is
-     * the reason this battery exists. May be sync or async; the substrate's
-     * cleanup is fire-and-forget (Rule 2), so a rejected teardown is logged at
-     * the boundary, not surfaced as a Msg.
+     * the reason this battery exists.
+     *
+     * May be sync or async, and an async one is really awaited: the promise is
+     * returned to the substrate, which tracks it and drains it inside `stop()`
+     * (bounded by `run({ disposeTimeoutMs })`). So `await runtime.stop()` means
+     * the release finished — the reading a host evicting an isolate acts on.
+     * MID-RUN teardown (a phase exit, a key change) is still fire-and-forget
+     * (Rule 2): the reconcile pass is synchronous by construction, so it starts
+     * the release and moves on. A rejection is never a Msg — it reaches the
+     * runtime's `onError` sink under `phase: "sub-cleanup"`.
      */
     readonly release: (handle: Handle) => void | Promise<void>;
 }
@@ -283,7 +290,7 @@ interface ManagedResourceBattery<TKey, Handle, Ctx> {
      * Handle in the battery's handle table, and returns a cleanup that runs
      * `release` (and forgets the Handle) on reconcile-out.
      */
-    readonly subscribe: (sub: ManagedResourceSub<TKey>, ctx: Ctx, dispatch: (msg: never) => void) => () => void;
+    readonly subscribe: (sub: ManagedResourceSub<TKey>, ctx: Ctx, dispatch: (msg: never) => void) => Dispose;
     /**
      * Accessor for the live Handle, keyed on `key`. Returns `undefined` when
      * the resource is not currently held (no active sub for that key) — the

package/dist/subs/index.js

@@ -1,7 +1,7 @@
-export { combineManagedResources, defineListener, defineManagedResource, fromBroadcastChannel, fromEventSource, fromEventTarget, fromInterval, fromPort, fromReconnectingWebSocket, fromTransport, fromWebSocket } from '../chunk-LYLDCIPH.js';
+export { combineManagedResources, defineListener, defineManagedResource, fromBroadcastChannel, fromEventSource, fromEventTarget, fromInterval, fromPort, fromReconnectingWebSocket, fromTransport, fromWebSocket } from '../chunk-QKUWDC4P.js';
 export { fromTimeout } from '../chunk-2YFLOCWX.js';
 import '../chunk-ZJ5AOYBH.js';
-import '../chunk-BP2R7TPP.js';
-import '../chunk-PBDYW2TU.js';
+import '../chunk-PBAYOJJO.js';
+import '../chunk-DBOJ2UC6.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/testing/index.d.ts

@@ -1,5 +1,5 @@
-import { C as Cmd, S as Sub, M as Machine } from '../core-42kapW0n.js';
-import { R as Runtime } from '../runtime-types-gsog27b6.js';
+import { C as Cmd, S as Sub, M as Machine } from '../core-DPYOyOJv.js';
+import { R as Runtime } from '../runtime-types-uBuVvZqa.js';
 
 /**
  * The composed Model shape every `withX` wrapper produces: the base machine's

package/dist/testing/index.js

@@ -1,5 +1,5 @@
-import { replay } from '../chunk-BP2R7TPP.js';
-import '../chunk-PBDYW2TU.js';
+import { replay } from '../chunk-PBAYOJJO.js';
+import '../chunk-DBOJ2UC6.js';
 import { expect, vi } from 'vitest';
 
 function assertWrapperFaithful(base, makeWrapped, opts) {

package/dist/throttled-input/index.d.ts

@@ -1,10 +1,10 @@
 import { TtlCache } from '../cache/index.js';
 import { DeadlineSub } from '../deadline/index.js';
 export { DeadlineExceeded as ThrottledInputSettled, subscribeDeadline as subscribeThrottledInput, deadlineExceeded as throttledInputSettled } from '../deadline/index.js';
-import { C as Cmd, S as Sub } from '../core-42kapW0n.js';
+import { C as Cmd, S as Sub } from '../core-DPYOyOJv.js';
 export { Debounced, debounce } from '../debounce/index.js';
 export { Throttled, throttle } from '../throttle/index.js';
-import '../types-KbL3W1mj.js';
+import '../types-C6mXL9wA.js';
 
 /**
  * @demlik/tea/throttled-input — gate a high-frequency input stream into a

package/dist/throttled-input/index.js

@@ -1,13 +1,13 @@
 export { debounce } from '../chunk-J6527VRQ.js';
 export { throttle } from '../chunk-HCEVHFJ7.js';
-import { deadlineSub } from '../chunk-RMX4EOQK.js';
-export { subscribeDeadline as subscribeThrottledInput, deadlineExceeded as throttledInputSettled } from '../chunk-RMX4EOQK.js';
-import { initCache, get, set } from '../chunk-2KNLKQVN.js';
-import '../chunk-LYLDCIPH.js';
+import { deadlineSub } from '../chunk-ZT3MGQB7.js';
+export { subscribeDeadline as subscribeThrottledInput, deadlineExceeded as throttledInputSettled } from '../chunk-ZT3MGQB7.js';
+import { initCache, get, set } from '../chunk-7UU5P2CX.js';
+import '../chunk-QKUWDC4P.js';
 import '../chunk-2YFLOCWX.js';
 import '../chunk-ZJ5AOYBH.js';
-import '../chunk-BP2R7TPP.js';
-import '../chunk-PBDYW2TU.js';
+import '../chunk-PBAYOJJO.js';
+import '../chunk-DBOJ2UC6.js';
 
 // src/throttled-input/index.ts
 var DEFAULT_SUB_ID = "throttled-input:settle";

package/dist/token-refresh/index.d.ts

@@ -1,4 +1,4 @@
-import { C as Cmd, c as Interpret } from '../core-42kapW0n.js';
+import { C as Cmd, c as Interpret } from '../core-DPYOyOJv.js';
 import { M as MsgType } from '../protocol-B5YmJr0d.js';
 
 /**

package/dist/token-refresh/index.js

@@ -1,6 +1,6 @@
-export { createTokenRefresh, initTokenRefresh, refreshTokenCmd, tokenRefreshFailedMsg, tokenRefreshedMsg } from '../chunk-SK5JGUY7.js';
+export { createTokenRefresh, initTokenRefresh, refreshTokenCmd, tokenRefreshFailedMsg, tokenRefreshedMsg } from '../chunk-PUTHY7LR.js';
 import '../chunk-JELSZN25.js';
-import '../chunk-BP2R7TPP.js';
-import '../chunk-PBDYW2TU.js';
+import '../chunk-PBAYOJJO.js';
+import '../chunk-DBOJ2UC6.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/trace-replay/index.d.ts

@@ -1,6 +1,6 @@
-import { C as Cmd, S as Sub, M as Machine } from '../core-42kapW0n.js';
+import { C as Cmd, S as Sub, M as Machine } from '../core-DPYOyOJv.js';
 import { Trace } from '../recorder/index.js';
-import '../runtime-types-gsog27b6.js';
+import '../runtime-types-uBuVvZqa.js';
 
 /**
  * The outcome of {@link replayTrace}.

package/dist/trace-replay/index.js

@@ -1,6 +1,6 @@
-export { deepEqual, replayTrace } from '../chunk-S4O26D7B.js';
+export { deepEqual, replayTrace } from '../chunk-362SZ6CS.js';
 import '../chunk-EWJP3YYP.js';
-import '../chunk-BP2R7TPP.js';
-import '../chunk-PBDYW2TU.js';
+import '../chunk-PBAYOJJO.js';
+import '../chunk-DBOJ2UC6.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/{types-KbL3W1mj.d.ts → types-C6mXL9wA.d.ts}

@@ -1,4 +1,4 @@
-import { S as Sub } from './core-42kapW0n.js';
+import { S as Sub } from './core-DPYOyOJv.js';
 
 type SubscribeHandler<S extends Sub, M, Ctx> = (sub: S, ctx: Ctx, dispatch: (msg: M) => void) => () => void;
 

package/dist/with-deadline/index.d.ts

@@ -1,4 +1,4 @@
-import { S as Sub, C as Cmd, M as Machine } from '../core-42kapW0n.js';
+import { S as Sub, C as Cmd, M as Machine } from '../core-DPYOyOJv.js';
 
 /**
  * @demlik/tea/with-deadline — auto-fail a wrapped machine at T+N, re-arm on

package/dist/with-deadline/index.js

@@ -1,6 +1,6 @@
 import { fromTimeout } from '../chunk-2YFLOCWX.js';
-import '../chunk-BP2R7TPP.js';
-import { msgKeysOf, applyCell, subId } from '../chunk-PBDYW2TU.js';
+import '../chunk-PBAYOJJO.js';
+import { msgKeysOf, applyCell, subId } from '../chunk-DBOJ2UC6.js';
 
 // src/with-deadline/index.ts
 function deadlineExceededMsg(seq) {

package/dist/with-resilience/index.d.ts

@@ -1,7 +1,7 @@
-import { C as Cmd, S as Sub, M as Machine } from '../core-42kapW0n.js';
+import { C as Cmd, S as Sub, M as Machine } from '../core-DPYOyOJv.js';
 import { ResilientConfig, ResilientState } from '../resilient-call/index.js';
 import '../cache/index.js';
-import '../types-KbL3W1mj.js';
+import '../types-C6mXL9wA.js';
 import '../circuit-breaker/index.js';
 import '../deadline/index.js';
 import '../protocol-B5YmJr0d.js';

package/dist/with-resilience/index.js

@@ -1,15 +1,15 @@
-import { createResilientCall } from '../chunk-IXBKFQH5.js';
+import { createResilientCall } from '../chunk-W2S4HK7J.js';
 import { MsgType } from '../chunk-JELSZN25.js';
-import { subscribeDeadline } from '../chunk-RMX4EOQK.js';
+import { subscribeDeadline } from '../chunk-ZT3MGQB7.js';
 import '../chunk-Q2UM7BXU.js';
 import '../chunk-S2EGRPCM.js';
 import '../chunk-UF4MZSLT.js';
-import '../chunk-2KNLKQVN.js';
-import '../chunk-LYLDCIPH.js';
+import '../chunk-7UU5P2CX.js';
+import '../chunk-QKUWDC4P.js';
 import '../chunk-2YFLOCWX.js';
 import '../chunk-ZJ5AOYBH.js';
-import { tryInterpret } from '../chunk-BP2R7TPP.js';
-import { msgKeysOf, applyCell, subId, formOf } from '../chunk-PBDYW2TU.js';
+import { tryInterpret } from '../chunk-PBAYOJJO.js';
+import { msgKeysOf, applyCell, subId, formOf } from '../chunk-DBOJ2UC6.js';
 
 // src/with-resilience/index.ts
 var RC_RETRY_PREFIX = "resilient:retry:";

package/dist/with-telemetry/index.d.ts

@@ -1,4 +1,4 @@
-import { C as Cmd, S as Sub, M as Machine } from '../core-42kapW0n.js';
+import { C as Cmd, S as Sub, M as Machine } from '../core-DPYOyOJv.js';
 
 /**
  * @demlik/tea/with-telemetry — the pattern-setting wrapper of the wrapper tier.

package/dist/with-telemetry/index.js

@@ -1,5 +1,5 @@
-import '../chunk-BP2R7TPP.js';
-import { msgKeysOf, applyCell } from '../chunk-PBDYW2TU.js';
+import '../chunk-PBAYOJJO.js';
+import { msgKeysOf, applyCell } from '../chunk-DBOJ2UC6.js';
 
 // src/with-telemetry/index.ts
 function withTelemetry(base, config = {}) {

package/dist/work-queue/adapter.d.ts

@@ -1,6 +1,6 @@
 import { QueueItem } from './index.js';
-import '../runtime-types-gsog27b6.js';
-import '../core-42kapW0n.js';
+import '../runtime-types-uBuVvZqa.js';
+import '../core-DPYOyOJv.js';
 
 /**
  * @demlik/tea/work-queue/adapter — the verb seam over the pure queue ops.

package/dist/work-queue/index.d.ts

@@ -1,5 +1,5 @@
-import { S as Store } from '../runtime-types-gsog27b6.js';
-import '../core-42kapW0n.js';
+import { S as Store } from '../runtime-types-uBuVvZqa.js';
+import '../core-DPYOyOJv.js';
 
 /**
  * @packageDocumentation

package/dist/work-queue/ops.d.ts

@@ -1,6 +1,6 @@
 import { QueueItem } from './index.js';
-import '../runtime-types-gsog27b6.js';
-import '../core-42kapW0n.js';
+import '../runtime-types-uBuVvZqa.js';
+import '../core-DPYOyOJv.js';
 
 /**
  * Pure queue-lifecycle ops over `QueueItem<I>[]` — the BLESSED delegation

package/dist/workflow/index.d.ts

@@ -1,6 +1,6 @@
-import { D as DeliveryId, E as EffectLedgerEvent } from '../durable-effects-CFRngTNA.js';
-export { a as EffectConfirmed, b as EffectOwed, e as emptyLedger } from '../durable-effects-CFRngTNA.js';
-import { C as Cmd } from '../core-42kapW0n.js';
+import { D as DeliveryId, E as EffectLedgerEvent } from '../durable-effects-B0YpoCHg.js';
+export { a as EffectConfirmed, b as EffectOwed, e as emptyLedger } from '../durable-effects-B0YpoCHg.js';
+import { C as Cmd } from '../core-DPYOyOJv.js';
 
 /**
  * @packageDocumentation

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@demlik/tea",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "TEA-faithful state machine substrate — one package, every host adapter. Core + subs + testing, plus React, Durable Object, Chrome extension, Node, in-memory, work-queue, devtools, and property-testing modules as subpaths.",
   "keywords": [
     "tea",