@demlik/tea 0.13.0 → 0.15.0

package/dist/resilience/index.js

@@ -0,0 +1,657 @@
+import { MsgType, createResilientCall } from '../chunk-AYS5N6WY.js';
+export { DEFAULT_RESILIENT_NAME, canPass, createResilientCall, defaultCircuitPolicy, initBucket, initCircuit, initWindow, liftResilience, mountResilientCall, onFailure, onSuccess, record, refill, remaining, runCmdDef, tryConsume } from '../chunk-AYS5N6WY.js';
+import { defaultRng, initRetry, recordFailure, shouldRetry, nextDelayMs } from '../chunk-VBDU4JL6.js';
+import { subscribeDeadline } from '../chunk-22POWGFA.js';
+export { cacheEvictMsg, cacheEvictionSub, cacheEvictionSubscribe, deadlineExceeded, deadlineMsgType, deadlineSub, evictExpired, get, has, initCache, remove, set, setTimeoutArmTimer, subscribeDeadline, subscribeWith } from '../chunk-22POWGFA.js';
+import { Cmd, msgKeysOf, applyCell, fromTimeout, tryInterpret, cmdEdgeOf, subId, without, formOf } from '../chunk-66PY5WYF.js';
+import { z } from 'zod';
+
+function initTokenRefresh() {
+  return { token: null, stale: false };
+}
+var refreshToken = Cmd.define("refresh_token", {
+  input: z.object({}),
+  ok: z.custom(),
+  err: ["token_refresh_failed"]
+});
+function refreshTokenCmd() {
+  return refreshToken({});
+}
+function tokenRefreshedMsg(token) {
+  return { type: MsgType.TokenRefreshed, token };
+}
+function tokenRefreshFailedMsg(error) {
+  return { type: MsgType.TokenRefreshFailed, error };
+}
+function createTokenRefresh(config = {}) {
+  const skewMs = config.skewMs !== void 0 && config.skewMs > 0 ? config.skewMs : 0;
+  function needsRefresh(state, at) {
+    if (state.token === null) return true;
+    if (state.stale) return true;
+    if (!Number.isFinite(state.token.expiresAt)) return true;
+    return at >= state.token.expiresAt - skewMs;
+  }
+  function on401(state) {
+    if (state.stale) return state;
+    return { ...state, stale: true };
+  }
+  function refreshed(state, token) {
+    const normalized = Object.is(token.expiresAt, -0) ? { ...token, expiresAt: 0 } : token;
+    return { ...state, token: normalized, stale: false };
+  }
+  function ensureFresh(state, at) {
+    if (needsRefresh(state, at)) {
+      return [state, [refreshTokenCmd()]];
+    }
+    return [state, []];
+  }
+  function handlers(ports) {
+    return {
+      refresh_token: tryInterpret(
+        () => ports.refresh(),
+        (token) => tokenRefreshedMsg(token),
+        (error) => tokenRefreshFailedMsg(error)
+      )
+    };
+  }
+  return {
+    /** The slice initializer — spread into the consumer's `init`. */
+    init: initTokenRefresh,
+    needsRefresh,
+    on401,
+    refreshed,
+    ensureFresh,
+    handlers
+  };
+}
+
+// src/internal/resilience/authed-call/index.ts
+function createAuthedCall(config, rng = Math.random) {
+  const rc = createResilientCall(config, rng);
+  const tr = createTokenRefresh({ skewMs: config.skewMs });
+  function init() {
+    return {
+      resilience: rc.init(),
+      auth: tr.init(),
+      authRetry: {},
+      pendingAuthRetry: {}
+    };
+  }
+  function liftResilient(s, [resilience, cmds]) {
+    return [{ ...s, resilience }, cmds];
+  }
+  function clearAuthKey(s, key) {
+    return {
+      ...s,
+      authRetry: without(s.authRetry, key),
+      pendingAuthRetry: without(s.pendingAuthRetry, key)
+    };
+  }
+  function attempt(s, key, input, at) {
+    const cleared = clearAuthKey(s, key);
+    return liftResilient(
+      cleared,
+      rc.attempt(cleared.resilience, key, input, at)
+    );
+  }
+  function succeed(s, key, msg) {
+    const settled = clearAuthKey(s, key);
+    return liftResilient(settled, rc.succeed(settled.resilience, key, msg));
+  }
+  function fail(s, key, msg) {
+    const [resilience, cmds] = rc.fail(s.resilience, key, msg);
+    const next = settleAuthIfDone({ ...s, resilience }, key, resilience);
+    return [next, cmds];
+  }
+  function on401(s, key, at) {
+    const spent = s.authRetry[key] ?? 0;
+    const call = s.resilience.calls[key];
+    const input = call?.phase === "running" || call?.phase === "waiting_retry" ? call.input : void 0;
+    if (spent >= 1 || input === void 0) {
+      const error = { _tag: "unauthorized", key };
+      const [settled] = rc.settleFailed(s.resilience, key, error);
+      return [{ ...clearAuthKey(s, key), resilience: settled }, []];
+    }
+    return [
+      {
+        ...s,
+        auth: tr.on401(s.auth),
+        authRetry: { ...s.authRetry, [key]: spent + 1 },
+        pendingAuthRetry: { ...s.pendingAuthRetry, [key]: input }
+      },
+      [refreshTokenCmd()]
+    ];
+  }
+  function installToken(s, token) {
+    return { ...s, auth: tr.refreshed(s.auth, token) };
+  }
+  function onRefreshed(s, at) {
+    const parked = Object.entries(s.pendingAuthRetry);
+    if (parked.length === 0) return [s, []];
+    let resilience = s.resilience;
+    const cmds = [];
+    for (const [key, input] of parked) {
+      const [next, runCmds] = rc.attempt(resilience, key, input, at);
+      resilience = next;
+      cmds.push(...runCmds);
+    }
+    return [{ ...s, resilience, pendingAuthRetry: {} }, cmds];
+  }
+  function onTimer(s, msg) {
+    const [resilience, cmds] = rc.onTimer(s.resilience, msg);
+    const next = settleAuthIfDone({ ...s, resilience }, void 0, resilience);
+    return [next, cmds];
+  }
+  function settleAuthIfDone(s, onlyKey, resilience) {
+    const keys = onlyKey !== void 0 ? [onlyKey] : Object.keys(s.authRetry);
+    let next = s;
+    for (const key of keys) {
+      const phase = resilience.calls[key]?.phase;
+      if (phase === "succeeded" || phase === "failed") {
+        next = clearAuthKey(next, key);
+      }
+    }
+    return next;
+  }
+  function subs(s) {
+    return rc.subs(s.resilience);
+  }
+  function handlers(ports) {
+    const trPorts = { refresh: ports.refresh };
+    return {
+      ...rc.handlers({ run: ports.run }),
+      ...tr.handlers(trPorts)
+    };
+  }
+  return {
+    init,
+    attempt,
+    succeed,
+    fail,
+    on401,
+    installToken,
+    onRefreshed,
+    onTimer,
+    /** token-refresh's call-boundary verb, re-exposed for proactive expiry refresh. */
+    needsRefresh: (s, at) => tr.needsRefresh(s.auth, at),
+    subs,
+    handlers
+  };
+}
+function liftAuthed(state, [slice, cmds]) {
+  return [{ ...state, authed: slice }, cmds];
+}
+
+// src/internal/resilience/retry-to-success/index.ts
+var RetryExhaustedError = class extends Error {
+  constructor(attempts, lastError) {
+    super(
+      `@demlik/tea: retryToSuccess gave up after ${attempts} attempt(s) \u2014 the bounded retry reached maxAttempts without a success. See .lastError for the final failure.`
+    );
+    this.attempts = attempts;
+    this.lastError = lastError;
+  }
+  attempts;
+  lastError;
+  name = "RetryExhaustedError";
+  _tag = "RetryExhaustedError";
+};
+var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function retryToSuccess(port, policy, opts = {}) {
+  const rng = opts.rng ?? defaultRng;
+  const sleep = opts.sleep ?? defaultSleep;
+  let retry = initRetry();
+  for (; ; ) {
+    try {
+      return await port();
+    } catch (error) {
+      retry = recordFailure(retry, error);
+      if (!shouldRetry(retry, policy)) {
+        throw new RetryExhaustedError(retry.attempt, error);
+      }
+      await sleep(nextDelayMs(retry, policy, rng));
+    }
+  }
+}
+function deadlineExceededMsg(seq) {
+  return { type: "$deadline:exceeded", seq };
+}
+var deadlineDecision = Cmd.define("$deadline:decision", {
+  input: z.object({
+    decision: z.enum(["rearm", "expire", "idle"]),
+    /** The slice `seq` AFTER this transition (the re-arm generation now armed). */
+    seq: z.number()
+  }),
+  ok: z.void(),
+  err: []
+});
+function withDeadline(base, config) {
+  const windowMs = config.ms;
+  const isProgress = config.progress;
+  const update = {};
+  const baseMsgKeys = msgKeysOf(base);
+  for (const key of baseMsgKeys) {
+    if (key.startsWith("$deadline:")) {
+      throw new Error(
+        `withDeadline: the base machine declares a reserved "${key}" update cell \u2014 the wrapper owns the "$deadline:" Msg namespace. Rename the base Msg.`
+      );
+    }
+  }
+  for (const key of baseMsgKeys) {
+    update[key] = (state, msg) => {
+      const [nextBase, baseCmds] = applyCell(
+        base,
+        state.base,
+        msg
+      );
+      const armed = state.$deadline.phase === "armed";
+      const counts = armed && (isProgress === void 0 || isProgress(msg));
+      const $deadline = counts ? { phase: "armed", seq: state.$deadline.seq + 1 } : state.$deadline;
+      const next = { base: nextBase, $deadline };
+      const decision = deadlineDecision({
+        decision: counts ? "rearm" : "idle",
+        seq: $deadline.seq
+      });
+      return [next, [...baseCmds, decision]];
+    };
+  }
+  update["$deadline:exceeded"] = (state, msg) => {
+    const m = msg;
+    const fires = state.$deadline.phase === "armed" && m.seq === state.$deadline.seq;
+    const $deadline = fires ? { phase: "exceeded", seq: state.$deadline.seq } : state.$deadline;
+    const next = { base: state.base, $deadline };
+    const decision = deadlineDecision({
+      decision: fires ? "expire" : "idle",
+      seq: $deadline.seq
+    });
+    return [next, [decision]];
+  };
+  const baseInterpret = base.interpret ?? {};
+  if (Object.hasOwn(baseInterpret, "$deadline:decision")) {
+    throw new Error(
+      'withDeadline: the base machine declares a reserved "$deadline:decision" interpret handler \u2014 the wrapper owns the "$deadline:" Cmd namespace. Rename the base handler.'
+    );
+  }
+  const interpret = {
+    ...baseInterpret,
+    "$deadline:decision": async () => {
+    }
+  };
+  const baseSubscriptions = base.subscriptions;
+  const subscriptions = (state) => {
+    const baseSubs = baseSubscriptions ? baseSubscriptions(state.base) : [];
+    if (state.$deadline.phase !== "armed") return baseSubs;
+    const timeout = {
+      id: subId(`$deadline:timeout:${state.$deadline.seq}`),
+      type: "$deadline:timeout",
+      delayMs: windowMs
+    };
+    return [...baseSubs, timeout];
+  };
+  const baseSubscribe = base.subscribe ?? {};
+  if (Object.hasOwn(baseSubscribe, "$deadline:timeout")) {
+    throw new Error(
+      'withDeadline: the base machine declares a reserved "$deadline:timeout" subscribe handler \u2014 the wrapper owns the "$deadline:" Sub namespace. Rename the base handler.'
+    );
+  }
+  const timeoutCell = fromTimeout(
+    (sub) => {
+      const seq = Number(sub.id.slice(sub.id.lastIndexOf(":") + 1));
+      return deadlineExceededMsg(seq);
+    }
+  );
+  const subscribe = {
+    ...baseSubscribe,
+    "$deadline:timeout": timeoutCell
+  };
+  return {
+    init: (loaded, ctx) => {
+      if (loaded !== null) {
+        return [loaded, []];
+      }
+      const [base0, cmds] = base.init(null, ctx);
+      const model = {
+        base: base0,
+        $deadline: { phase: "armed", seq: 0 }
+      };
+      return [model, cmds];
+    },
+    update,
+    subscriptions,
+    subscribe,
+    interpret,
+    // The base's `Cmd.define` list rides through so `run`'s interpret edge
+    // still parses / stamps the base's settled Msgs behind the wrap (#66).
+    ...base.cmds ? { cmds: base.cmds } : {}
+  };
+}
+function resilienceRunCmdDef() {
+  return Cmd.define("$resilience:run", {
+    input: z.custom(),
+    // The carried result is the base interpret handler's resolution (`M | void`).
+    // biome-ignore lint/suspicious/noConfusingVoidType: mirrors `Interpret`'s own `Promise<M | void>`
+    ok: z.custom(),
+    err: ["base_rejected", "deadline_exceeded"]
+  });
+}
+var RC_RETRY_PREFIX = "resilient:retry:";
+var RC_DEADLINE_PREFIX = "resilient:deadline:";
+var WX_RETRY_PREFIX = "$resilience:retry:";
+var WX_DEADLINE_PREFIX = "$resilience:deadline:";
+function toWrapperTimerId(rcId) {
+  if (rcId.startsWith(RC_RETRY_PREFIX))
+    return WX_RETRY_PREFIX + rcId.slice(RC_RETRY_PREFIX.length);
+  if (rcId.startsWith(RC_DEADLINE_PREFIX))
+    return WX_DEADLINE_PREFIX + rcId.slice(RC_DEADLINE_PREFIX.length);
+  return rcId;
+}
+function toRcTimerId(wxId) {
+  if (wxId.startsWith(WX_RETRY_PREFIX))
+    return RC_RETRY_PREFIX + wxId.slice(WX_RETRY_PREFIX.length);
+  if (wxId.startsWith(WX_DEADLINE_PREFIX))
+    return RC_DEADLINE_PREFIX + wxId.slice(WX_DEADLINE_PREFIX.length);
+  return wxId;
+}
+function updateDeclaresMsgKey(machine, key) {
+  if (formOf(machine) === "reducer") {
+    return Object.hasOwn(machine.update, key);
+  }
+  for (const innerTable of Object.values(machine.update)) {
+    if (innerTable !== null && (typeof innerTable === "object" || typeof innerTable === "function") && Object.hasOwn(innerTable, key)) {
+      return true;
+    }
+  }
+  return false;
+}
+function withResilience(base, config, rng = Math.random) {
+  const { target } = config;
+  const keyOf = config.keyOf ?? (() => target);
+  const runCmd = resilienceRunCmdDef();
+  const timeSensitiveBrick = config.circuit !== void 0 || config.rateLimit !== void 0 || config.cache !== void 0 || config.deadline !== void 0;
+  if (timeSensitiveBrick && config.at === void 0) {
+    throw new Error(
+      "withResilience: a time-sensitive brick (circuit / rateLimit / cache / deadline) is configured but `config.at` is missing. The cold-attempt gate needs the REAL wall time the triggering base Msg carries as data (time-as-data) \u2014 without it the gate would fabricate `at = 0`, so a cold attempt after a real-time breaker trip computes a negative cooldown and the breaker NEVER recovers (and a deadline brick fires immediately). Provide `at: (msg) => msg.<wallTimeField>`."
+    );
+  }
+  const atOf = config.at ?? (() => 0);
+  const rc = createResilientCall(config, rng);
+  const update = {};
+  function isBaseMsg(result) {
+    return typeof result === "object" && result !== null && "type" in result;
+  }
+  function foldBase(state, msg, delivering = /* @__PURE__ */ new Set()) {
+    const [nextBase, baseCmds] = applyCell(base, state.base, msg);
+    let next = { base: nextBase, $resilience: state.$resilience };
+    const outCmds = [];
+    const at = atOf(msg);
+    for (const cmd of baseCmds) {
+      if (cmd.type !== target) {
+        outCmds.push(cmd);
+        continue;
+      }
+      const callKey = keyOf(cmd);
+      const [nextSlice, runCmds] = rc.attempt(
+        next.$resilience,
+        callKey,
+        cmd,
+        at
+      );
+      next = { ...next, $resilience: nextSlice };
+      outCmds.push(...renameRunCmds(runCmds));
+      if (runCmds.length === 0 && !delivering.has(callKey)) {
+        const call = nextSlice.calls[callKey];
+        if (call?.phase === "succeeded" && isBaseMsg(call.result)) {
+          const [delivered, moreCmds] = foldBase(
+            next,
+            call.result,
+            /* @__PURE__ */ new Set([...delivering, callKey])
+          );
+          next = delivered;
+          outCmds.push(...moreCmds);
+        }
+      }
+    }
+    return [next, outCmds];
+  }
+  for (const key of msgKeysOf(base)) {
+    update[key] = (state, msg) => foldBase(state, msg);
+  }
+  update["$resilience:ok"] = (state, msg) => {
+    const m = msg;
+    const [slice, runCmds] = rc.succeed(state.$resilience, m.key, {
+      type: MsgType.ResilientOk,
+      key: m.key,
+      result: m.result,
+      at: m.at
+    });
+    const settled = { ...state, $resilience: slice };
+    const settleCmds = renameRunCmds(runCmds);
+    if (!isBaseMsg(m.result)) return [settled, settleCmds];
+    const [next, followCmds] = foldBase(settled, m.result, /* @__PURE__ */ new Set([m.key]));
+    return [next, [...settleCmds, ...followCmds]];
+  };
+  update["$resilience:err"] = (state, msg) => {
+    const m = msg;
+    const [slice, runCmds] = rc.fail(state.$resilience, m.key, {
+      type: MsgType.ResilientErr,
+      key: m.key,
+      error: m.error,
+      at: m.at
+    });
+    return [{ ...state, $resilience: slice }, renameRunCmds(runCmds)];
+  };
+  update["$resilience:timer"] = (state, msg) => {
+    const m = msg;
+    const [slice, runCmds] = rc.onTimer(state.$resilience, {
+      type: "deadline_exceeded",
+      id: toRcTimerId(m.id),
+      atMs: m.atMs
+    });
+    return [{ ...state, $resilience: slice }, renameRunCmds(runCmds)];
+  };
+  function renameRunCmds(runCmds) {
+    return runCmds.map((r) => runCmd({ key: r.key, input: r.input }));
+  }
+  const baseSubscriptions = base.subscriptions;
+  const baseSubscribe = base.subscribe;
+  function subscriptions(state) {
+    const baseSubs = baseSubscriptions ? baseSubscriptions(state.base) : [];
+    const rcSubs = rc.subs(state.$resilience);
+    const timerSubs = rcSubs.map((s) => ({
+      id: subId(toWrapperTimerId(s.id)),
+      type: "$resilience:timer",
+      atMs: s.atMs
+    }));
+    return [...baseSubs, ...timerSubs];
+  }
+  const baseInterpret = base.interpret ?? {};
+  const RESERVED = [
+    "$resilience:run",
+    "$resilience:ok",
+    "$resilience:err",
+    "$resilience:timer"
+  ];
+  const surfaces = [
+    {
+      name: "update",
+      declares: (reserved) => updateDeclaresMsgKey(base, reserved)
+    },
+    {
+      name: "interpret",
+      declares: (reserved) => Object.hasOwn(baseInterpret, reserved)
+    },
+    {
+      name: "subscribe",
+      declares: (reserved) => Object.hasOwn(baseSubscribe ?? {}, reserved)
+    }
+  ];
+  for (const reserved of RESERVED) {
+    for (const surface of surfaces) {
+      if (surface.declares(reserved)) {
+        throw new Error(
+          `withResilience: the base machine declares a reserved "${reserved}" ${surface.name} key \u2014 the wrapper owns the "$resilience:" namespace ($resilience:run / :ok / :err / :timer across update, interpret, and subscribe). Rename the base key.`
+        );
+      }
+    }
+  }
+  if (!Object.hasOwn(baseInterpret, target)) {
+    throw new Error(
+      `withResilience: no base interpret handler for target Cmd "${target}" \u2014 the resilient effect has nothing to perform. The base machine must declare an interpret handler for its target Cmd type.`
+    );
+  }
+  const runHandler = tryInterpret(
+    async (cmd, ctx) => {
+      const inner = cmd.input;
+      const handler = baseInterpret[inner.type];
+      if (handler === void 0) {
+        throw new Error(
+          `withResilience: no base interpret handler for target Cmd "${inner.type}" \u2014 the resilient effect has nothing to perform.`
+        );
+      }
+      return cmdEdgeOf(ctx)(
+        inner,
+        await handler(inner, ctx)
+      );
+    },
+    (result, cmd) => ({
+      type: "$resilience:ok",
+      key: cmd.key,
+      result,
+      at: Date.now()
+    }),
+    (error, cmd) => ({
+      type: "$resilience:err",
+      key: cmd.key,
+      error,
+      at: Date.now()
+    })
+  );
+  const interpret = {
+    ...baseInterpret,
+    "$resilience:run": runHandler
+  };
+  const subscribeMap = {
+    ...baseSubscribe ?? {},
+    "$resilience:timer": (sub, ctx, dispatch) => (
+      // Reuse the deadline subscribe cell wholesale: it arms a one-shot timer
+      // for `max(0, atMs - Date.now())` and fires when the wall clock crosses
+      // `atMs`. We hand it a `DeadlineSub` shape and translate its
+      // `deadline_exceeded` Msg into the wrapper's `$resilience:timer` Msg.
+      subscribeDeadline(
+        { id: sub.id, type: "deadline", atMs: sub.atMs },
+        ctx,
+        (dl) => dispatch({ type: "$resilience:timer", id: dl.id, atMs: dl.atMs })
+      )
+    )
+  };
+  return {
+    init: (loaded, ctx) => {
+      if (loaded !== null) {
+        return [loaded, []];
+      }
+      const [base0, baseCmds] = base.init(null, ctx);
+      let resilience = rc.init();
+      const initCmds = [];
+      for (const cmd of baseCmds) {
+        if (cmd.type !== target) {
+          initCmds.push(cmd);
+          continue;
+        }
+        if (config.deadline !== void 0) {
+          throw new Error(
+            `withResilience: base.init emits the target Cmd "${target}" while a deadline brick is configured. The boot cold attempt has no real wall time (boot is gated at at=0), so the deadline would anchor at 0 + ${config.deadline.ms}ms and its $resilience:deadline Sub would fire IMMEDIATELY (max(0, atMs - now) === 0), failing the boot call instantly. Move the boot effect out of base.init and into a boot Msg dispatched after run() (where the triggering Msg carries a real at via config.at), so the deadline anchors at a real instant. (Boot effects belong in a boot Msg, not init Cmds.)`
+          );
+        }
+        const callKey = keyOf(cmd);
+        const [nextSlice, runCmds] = rc.attempt(resilience, callKey, cmd, 0);
+        resilience = nextSlice;
+        initCmds.push(...renameRunCmds(runCmds));
+      }
+      const model = { base: base0, $resilience: resilience };
+      return [model, initCmds];
+    },
+    update,
+    subscriptions,
+    subscribe: subscribeMap,
+    interpret,
+    // The base's `Cmd.define` list rides through so `run`'s interpret edge
+    // still parses / stamps the base's NON-target settled Msgs behind the
+    // wrap; the target's settle through the carrier above (#66).
+    ...base.cmds ? { cmds: base.cmds } : {}
+  };
+}
+var telemetryEmit = Cmd.define("$telemetry:emit", {
+  input: z.object({ event: z.custom() }),
+  ok: z.void(),
+  err: [],
+  requirements: Cmd.requirements()
+});
+function withTelemetry(base, config = {}) {
+  const project = config.event;
+  const msgKeys = msgKeysOf(base);
+  const update = {};
+  for (const key of msgKeys) {
+    update[key] = (state, msg) => {
+      const [nextBase, baseCmds] = applyCell(base, state.base, msg);
+      const $telemetry = { seq: state.$telemetry.seq + 1 };
+      const next = { base: nextBase, $telemetry };
+      const event = project ? project(msg, state, next) : { seq: $telemetry.seq, msgType: msg.type };
+      const emit = telemetryEmit({ event });
+      return [next, [...baseCmds, emit]];
+    };
+  }
+  const baseInterpret = base.interpret ?? {};
+  if (Object.hasOwn(baseInterpret, "$telemetry:emit")) {
+    throw new Error(
+      'withTelemetry: the base machine declares a reserved "$telemetry:emit" interpret handler \u2014 the wrapper owns the "$telemetry:" Cmd namespace. Rename the base handler.'
+    );
+  }
+  const interpret = {
+    ...baseInterpret,
+    // OBSERVE-ONLY at the boundary: the sink is fire-and-forget. The runtime
+    // `await`s every interpret handler in its dispatch loop, so awaiting the
+    // sink here would let a SLOW sink backpressure the wrapped machine (its
+    // next dispatch waits) and a FAILING sink crash dispatch (the throw would
+    // propagate out of the transition). Both violate the contract: telemetry
+    // must never affect base behavior OR latency. So we DO NOT await — we hand
+    // the event to the sink, normalize its result to a Promise, swallow any
+    // rejection/throw, and return immediately. The handler resolves in the same
+    // microtask the dispatch loop reaches it; the machine never waits on the
+    // sink, and a rejected sink can never become an unhandled rejection.
+    "$telemetry:emit": (cmd, ctx) => {
+      const event = cmd.event.at === void 0 && ctx.clock !== void 0 ? { ...cmd.event, at: ctx.clock() } : cmd.event;
+      try {
+        Promise.resolve(ctx.telemetrySink(event)).catch(() => {
+        });
+      } catch {
+      }
+    }
+  };
+  const baseSubscriptions = base.subscriptions;
+  const baseSubscribe = base.subscribe;
+  return {
+    init: (loaded, ctx) => {
+      if (loaded !== null) {
+        return [loaded, []];
+      }
+      const [base0, cmds] = base.init(null, ctx);
+      const model = { base: base0, $telemetry: { seq: 0 } };
+      return [model, cmds];
+    },
+    update,
+    // Subs merge to the base's, verbatim — telemetry owns no timers. The base
+    // subscribes against its own nested slice.
+    ...baseSubscriptions ? {
+      subscriptions: (state) => baseSubscriptions(state.base)
+    } : {},
+    ...baseSubscribe ? { subscribe: baseSubscribe } : {},
+    interpret,
+    // The base's `Cmd.define` list rides through so `run`'s interpret edge
+    // still parses / stamps the base's settled Msgs behind the wrap (#66).
+    ...base.cmds ? { cmds: base.cmds } : {}
+  };
+}
+
+export { RetryExhaustedError, createAuthedCall, createTokenRefresh, deadlineDecision, deadlineExceededMsg, initTokenRefresh, liftAuthed, refreshToken, refreshTokenCmd, resilienceRunCmdDef, retryToSuccess, telemetryEmit, tokenRefreshFailedMsg, tokenRefreshedMsg, withDeadline, withResilience, withTelemetry };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map