@demlik/tea 0.14.0 → 0.16.0

package/dist/resilience/index.js

@@ -1,28 +1,23 @@
-import { MsgType, createResilientCall } from '../chunk-AQ6ZIMEA.js';
-export { canPass, createResilientCall, defaultCircuitPolicy, initBucket, initCircuit, initWindow, liftResilience, onFailure, onSuccess, record, refill, remaining, runCmdDef, tryConsume } from '../chunk-AQ6ZIMEA.js';
+import { createResilientCall } from '../chunk-6NG4V5SB.js';
+export { DEFAULT_RESILIENT_NAME, canPass, createResilientCall, defaultCircuitPolicy, initBucket, initCircuit, initWindow, liftResilience, onFailure, onSuccess, record, refill, remaining, runCmdDef, tryConsume } from '../chunk-6NG4V5SB.js';
 import { defaultRng, initRetry, recordFailure, shouldRetry, nextDelayMs } from '../chunk-VBDU4JL6.js';
-import { subscribeDeadline } from '../chunk-F2US5BW6.js';
-export { cacheEvictMsg, cacheEvictionSub, cacheEvictionSubscribe, deadlineExceeded, deadlineSub, evictExpired, get, has, initCache, remove, set, setTimeoutArmTimer, subscribeDeadline, subscribeWith } from '../chunk-F2US5BW6.js';
-import { Cmd, msgKeysOf, applyCell, fromTimeout, tryInterpret, cmdEdgeOf, subId, without, formOf } from '../chunk-RQULHGYH.js';
-import { z } from 'zod';
+import { unchecked } from '../chunk-4LPY67E4.js';
+export { cacheEvictMsg, cacheEvictionSub, cacheEvictionSubscribe, deadlineExceeded, deadlineMsgType, deadlineSub, deadlines, deadlinesSub, evictExpired, get, has, initCache, nextTimer, remove, set, setTimeoutArmTimer, subscribeDeadline, subscribeWith } from '../chunk-IVJP3GKJ.js';
+import '../chunk-GOX2CYIM.js';
+import { Cmd, without } from '../chunk-CH5KTOEZ.js';
 
+// src/internal/resilience/token-refresh/index.ts
 function initTokenRefresh() {
   return { token: null, stale: false };
 }
 var refreshToken = Cmd.define("refresh_token", {
-  input: z.object({}),
-  ok: z.custom(),
+  input: unchecked(),
+  ok: unchecked(),
   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) {
@@ -45,28 +40,20 @@ function createTokenRefresh(config = {}) {
     }
     return [state, []];
   }
-  function handlers(ports) {
-    return {
-      refresh_token: tryInterpret(
-        () => ports.refresh(),
-        (token) => tokenRefreshedMsg(token),
-        (error) => tokenRefreshFailedMsg(error)
-      )
-    };
-  }
   return {
+    /** The `refresh_token` Cmd def — list it in the machine's `cmds`. */
+    run: refreshToken,
     /** The slice initializer — spread into the consumer's `init`. */
     init: initTokenRefresh,
     needsRefresh,
     on401,
     refreshed,
-    ensureFresh,
-    handlers
+    ensureFresh
   };
 }
 
 // src/internal/resilience/authed-call/index.ts
-function createAuthedCall(config, rng = Math.random) {
+function createAuthedCall(config = {}, rng = Math.random) {
   const rc = createResilientCall(config, rng);
   const tr = createTokenRefresh({ skewMs: config.skewMs });
   function init() {
@@ -94,13 +81,18 @@ function createAuthedCall(config, rng = Math.random) {
       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);
+  function succeed(s, msg) {
+    const settled = clearAuthKey(s, msg.cmd.key);
+    const { call, cmds } = rc.settle(settled.resilience, msg);
+    return liftResilient(settled, [call, cmds]);
+  }
+  function fail(s, msg) {
+    const { call: resilience, cmds } = rc.settle(s.resilience, msg);
+    const next = settleAuthIfDone(
+      { ...s, resilience },
+      msg.cmd.key,
+      resilience
+    );
     return [next, cmds];
   }
   function on401(s, key, at) {
@@ -109,7 +101,7 @@ function createAuthedCall(config, rng = Math.random) {
     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);
+      const [settled] = rc.settleFailed(s.resilience, key, error, at);
       return [{ ...clearAuthKey(s, key), resilience: settled }, []];
     }
     return [
@@ -153,17 +145,17 @@ function createAuthedCall(config, rng = Math.random) {
     }
     return next;
   }
-  function subs(s) {
-    return rc.subs(s.resilience);
+  function deadlines2(s) {
+    return rc.deadlines(s.resilience);
   }
-  function handlers(ports) {
-    const trPorts = { refresh: ports.refresh };
-    return {
-      ...rc.handlers({ run: ports.run }),
-      ...tr.handlers(trPorts)
-    };
+  function timer(s) {
+    return rc.timer(s.resilience);
   }
   return {
+    /** The call's `Cmd.define`d run Cmd — list it in `cmds`. */
+    run: rc.run,
+    /** token-refresh's `refresh_token` Cmd def — list it in `cmds`. */
+    refresh: tr.run,
     init,
     attempt,
     succeed,
@@ -174,8 +166,8 @@ function createAuthedCall(config, rng = Math.random) {
     onTimer,
     /** token-refresh's call-boundary verb, re-exposed for proactive expiry refresh. */
     needsRefresh: (s, at) => tr.needsRefresh(s.auth, at),
-    subs,
-    handlers
+    deadlines: deadlines2,
+    timer
   };
 }
 function liftAuthed(state, [slice, cmds]) {
@@ -213,445 +205,7 @@ async function retryToSuccess(port, policy, opts = {}) {
     }
   }
 }
-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 };
+export { RetryExhaustedError, createAuthedCall, createTokenRefresh, initTokenRefresh, liftAuthed, refreshToken, refreshTokenCmd, retryToSuccess };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map