@demlik/tea 0.1.0 → 0.1.1

package/dist/extension/test-utils.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/extension/test-utils.ts"],"names":[],"mappings":"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","file":"test-utils.js","sourcesContent":["/**\n * In-memory `chrome.*` mock for tests in this package and any downstream\n * consumer that wants to test against `chromeStorageStore` behavior without\n * a real chrome environment.\n *\n * Currently exposes `chrome.storage.local`, `chrome.runtime` (sendMessage +\n * onMessage), and `chrome.tabs` (sendMessage). The `runtime` and `tabs`\n * surfaces are used by the runtime-bridge tests (`bridge.ts`) to round-trip\n * envelopes between a host runtime and a surface client (sw↔surface) and\n * between a sw client and a per-tab content-script runtime (sw↔content).\n *\n * Extend additional surfaces (alarms, windows, …) only when real consumer\n * tests reach for them — earn each surface through a concrete need.\n */\n\ntype RuntimeListener = (\n  message: unknown,\n  sender: chrome.runtime.MessageSender,\n  sendResponse: (response: unknown) => void,\n) => boolean | undefined | void;\n\ntype StorageChangeListener = (\n  changes: Record<string, chrome.storage.StorageChange>,\n  areaName: chrome.storage.AreaName,\n) => void;\n\ntype AlarmListener = (alarm: chrome.alarms.Alarm) => void;\n\ntype TabActivatedListener = (info: chrome.tabs.OnActivatedInfo) => void;\ntype TabUpdatedListener = (\n  tabId: number,\n  changeInfo: chrome.tabs.OnUpdatedInfo,\n  tab: chrome.tabs.Tab,\n) => void;\ntype TabRemovedListener = (tabId: number, removeInfo: chrome.tabs.OnRemovedInfo) => void;\n\nexport interface FakeChrome {\n  storage: {\n    local: chrome.storage.StorageArea;\n    /**\n     * Top-level `chrome.storage.onChanged` event. Fires for ANY area; consumer\n     * filters by the `areaName` arg. Real chrome semantics: every `set` /\n     * `remove` / `clear` that materially changes a key emits a single\n     * `changes` map keyed by the changed keys.\n     */\n    onChanged: {\n      addListener(listener: StorageChangeListener): void;\n      removeListener(listener: StorageChangeListener): void;\n      hasListener(listener: StorageChangeListener): boolean;\n      hasListeners(): boolean;\n    };\n  };\n  // Subset of `typeof chrome.runtime` covered by the fake — chrome's\n  // ambient typings don't export a single `Runtime` interface, so we\n  // declare the surface inline. Extend when tests reach for more.\n  runtime: {\n    sendMessage: typeof chrome.runtime.sendMessage;\n    onMessage: typeof chrome.runtime.onMessage;\n  };\n  tabs: {\n    sendMessage: typeof chrome.tabs.sendMessage;\n    /**\n     * `chrome.tabs.onActivated` — fires when the active tab in a window\n     * changes. The fake only models the listener registry; tests drive\n     * fires via `__test.fireTabActivated(info)`.\n     */\n    onActivated: {\n      addListener(listener: TabActivatedListener): void;\n      removeListener(listener: TabActivatedListener): void;\n      hasListener(listener: TabActivatedListener): boolean;\n      hasListeners(): boolean;\n    };\n    /**\n     * `chrome.tabs.onUpdated` — fires when a tab is updated (url, title,\n     * status, etc.). Tests drive fires via `__test.fireTabUpdated(...)`.\n     */\n    onUpdated: {\n      addListener(listener: TabUpdatedListener): void;\n      removeListener(listener: TabUpdatedListener): void;\n      hasListener(listener: TabUpdatedListener): boolean;\n      hasListeners(): boolean;\n    };\n    /**\n     * `chrome.tabs.onRemoved` — fires when a tab is closed. Tests drive\n     * fires via `__test.fireTabRemoved(...)`.\n     */\n    onRemoved: {\n      addListener(listener: TabRemovedListener): void;\n      removeListener(listener: TabRemovedListener): void;\n      hasListener(listener: TabRemovedListener): boolean;\n      hasListeners(): boolean;\n    };\n  };\n  /**\n   * `chrome.alarms` — the MV3 periodic timer primitive. The fake tracks\n   * created alarms in a Map keyed by name, models `create` (dedupe by\n   * name) + `clear` (remove from map), and exposes `onAlarm` as a\n   * standard listener registry. Tests drive fires via\n   * `__test.fireAlarm(name)`.\n   */\n  alarms: {\n    create(name: string, alarmInfo: chrome.alarms.AlarmCreateInfo): void;\n    /**\n     * `chrome.alarms.get(name)` — resolves to the Alarm shape Chrome would\n     * return (with `scheduledTime` synthesized at lookup time), or\n     * undefined if no alarm with that name exists. Mirrors the contract\n     * the `ensureQueueAlarm` SW-module-top-level helper checks (\"is this\n     * alarm already present with the right period?\") — see\n     * `apps/extension/extension/entrypoints/background.ts`.\n     */\n    get(name: string): Promise<chrome.alarms.Alarm | undefined>;\n    clear(name: string): Promise<boolean>;\n    onAlarm: {\n      addListener(listener: AlarmListener): void;\n      removeListener(listener: AlarmListener): void;\n      hasListener(listener: AlarmListener): boolean;\n      hasListeners(): boolean;\n    };\n  };\n  /**\n   * Test helpers — not part of the real chrome surface. Lets tests\n   * simulate a content script issuing `chrome.runtime.sendMessage` from\n   * inside a specific tab (chrome auto-tags `sender.tab.id` in that\n   * direction) and remove a tab so `chrome.tabs.sendMessage` rejects\n   * the way real chrome does when the receiver is gone.\n   */\n  __test: {\n    /** Simulate a content-script broadcast tagged with `sender.tab.id`. */\n    sendFromTab(tabId: number, message: unknown): Promise<unknown>;\n    /** Mark a tab as gone — `chrome.tabs.sendMessage(tabId, …)` will reject. */\n    removeTab(tabId: number): void;\n    /** Mark a tab as alive (default for any tabId that hasn't been removed). */\n    addTab(tabId: number): void;\n    /** Fire an alarm — invokes every onAlarm listener with `{ name, ...}`. */\n    fireAlarm(name: string): void;\n    /** Snapshot the alarm registry — tests assert on created/cleared alarms. */\n    getAlarms(): readonly string[];\n    /** Fire `chrome.tabs.onActivated` — drives every listener. */\n    fireTabActivated(info: chrome.tabs.OnActivatedInfo): void;\n    /** Fire `chrome.tabs.onUpdated` — drives every listener. */\n    fireTabUpdated(\n      tabId: number,\n      changeInfo: chrome.tabs.OnUpdatedInfo,\n      tab: chrome.tabs.Tab,\n    ): void;\n    /** Fire `chrome.tabs.onRemoved` — drives every listener. */\n    fireTabRemoved(tabId: number, removeInfo: chrome.tabs.OnRemovedInfo): void;\n  };\n}\n\nexport function fakeChrome(): FakeChrome {\n  const data = new Map<string, unknown>();\n\n  // ─── chrome.storage.onChanged — top-level event ───────────────────────\n  //\n  // Real chrome emits `changes` keyed by every key that actually changed\n  // (oldValue / newValue present). Unchanged keys aren't included. The\n  // fake mirrors that: build the change map inside set/remove/clear, fire\n  // listeners only if the map is non-empty. AreaName is \"local\" here —\n  // the fake only models storage.local; if a future test reaches for\n  // session/sync, add a per-area fake with its own onChanged.\n  const storageListeners = new Set<StorageChangeListener>();\n  function deepEqual(a: unknown, b: unknown): boolean {\n    if (a === b) return true;\n    if (typeof a !== typeof b) return false;\n    if (typeof a !== \"object\" || a === null || b === null) return false;\n    return JSON.stringify(a) === JSON.stringify(b);\n  }\n  function fireStorageChange(changes: Record<string, chrome.storage.StorageChange>): void {\n    if (Object.keys(changes).length === 0) return;\n    for (const listener of Array.from(storageListeners)) {\n      listener(changes, \"local\");\n    }\n  }\n\n  const partial = {\n    async get(\n      keys?: string | string[] | Record<string, unknown> | null,\n    ): Promise<Record<string, unknown>> {\n      // get()              → all entries\n      // get(\"k\")           → { k: v } if present, {} otherwise\n      // get([\"k1\",\"k2\"])   → { k: v } for present keys\n      // get({ k: default}) → { k: v ?? default } per key\n      if (keys === undefined || keys === null) {\n        return Object.fromEntries(data);\n      }\n      if (typeof keys === \"string\") {\n        const v = data.get(keys);\n        return v === undefined ? {} : { [keys]: v };\n      }\n      if (Array.isArray(keys)) {\n        return Object.fromEntries(keys.flatMap((k) => (data.has(k) ? [[k, data.get(k)]] : [])));\n      }\n      const out: Record<string, unknown> = {};\n      for (const [k, def] of Object.entries(keys)) {\n        out[k] = data.has(k) ? data.get(k) : def;\n      }\n      return out;\n    },\n    async set(items: Record<string, unknown>): Promise<void> {\n      const changes: Record<string, chrome.storage.StorageChange> = {};\n      for (const [k, v] of Object.entries(items)) {\n        const prev = data.get(k);\n        // Real chrome only fires onChanged when the value actually\n        // changes — match that to avoid spurious re-renders in tests.\n        if (deepEqual(prev, v)) continue;\n        const change: chrome.storage.StorageChange = { newValue: v };\n        if (data.has(k)) change.oldValue = prev;\n        changes[k] = change;\n        data.set(k, v);\n      }\n      fireStorageChange(changes);\n    },\n    async remove(keys: string | string[]): Promise<void> {\n      const arr = Array.isArray(keys) ? keys : [keys];\n      const changes: Record<string, chrome.storage.StorageChange> = {};\n      for (const k of arr) {\n        if (!data.has(k)) continue;\n        changes[k] = { oldValue: data.get(k) };\n        data.delete(k);\n      }\n      fireStorageChange(changes);\n    },\n    async clear(): Promise<void> {\n      const changes: Record<string, chrome.storage.StorageChange> = {};\n      for (const [k, v] of data) changes[k] = { oldValue: v };\n      data.clear();\n      fireStorageChange(changes);\n    },\n  };\n\n  // The full `chrome.storage.StorageArea` contract has more surface\n  // (getBytesInUse, getKeys, onChanged event, setAccessLevel) than real\n  // consumer tests currently exercise. The cast is local to this test util;\n  // src/index.ts never casts. If a test needs more surface, implement it\n  // here instead of widening the cast.\n  const local = partial as unknown as chrome.storage.StorageArea;\n\n  // ─── chrome.runtime — sendMessage + onMessage round-trip ───────────────\n  //\n  // The fake mirrors MV3 semantics that matter for the bridge:\n  //   - sendMessage delivers to EVERY onMessage listener in arrival order.\n  //   - The first listener that returns `true` (or calls sendResponse\n  //     synchronously) \"wins\" — its sendResponse value resolves the\n  //     sendMessage promise. Listeners that return false/undefined are\n  //     passed over.\n  //   - If no listener handles the message, sendMessage rejects with the\n  //     same shape chrome uses (\"Could not establish connection.\n  //     Receiving end does not exist.\"). The bridge's broadcast path\n  //     swallows this.\n  const runtimeListeners = new Set<RuntimeListener>();\n\n  // Tracks tabs that are \"alive\" from `chrome.tabs.sendMessage`'s point of\n  // view. Unknown tabIds are treated as alive by default (matches the\n  // common test path: assign a number, send to it). Tests can `removeTab`\n  // to simulate disconnection.\n  const removedTabs = new Set<number>();\n\n  /**\n   * Internal dispatch helper. Real chrome distinguishes:\n   *   - `chrome.runtime.sendMessage(msg)` — sender is the extension origin,\n   *     `sender.tab` is undefined; all `chrome.runtime.onMessage` listeners\n   *     hear it.\n   *   - `chrome.tabs.sendMessage(tabId, msg)` — sender is the extension\n   *     origin (still no `sender.tab` on the receiving end's view here, but\n   *     the routing is by tab); only listeners IN that tab receive it. Our\n   *     fake collapses to the same listener set since tests run a single\n   *     \"tab\" of listeners at a time. The routing assertion is enforced by\n   *     callers reading the envelope/tabId pair they sent.\n   *   - Content-script `chrome.runtime.sendMessage(msg)` (the `sendFromTab`\n   *     helper) — chrome auto-tags `sender.tab.id`. SW-side listeners use\n   *     this to filter cross-tab broadcasts.\n   *\n   * `sender` controls which sender object the listeners see.\n   */\n  const dispatch = (message: unknown, sender: chrome.runtime.MessageSender): Promise<unknown> => {\n    return new Promise((resolve, reject) => {\n      let responded = false;\n      const sendResponse = (response: unknown): void => {\n        if (responded) return;\n        responded = true;\n        resolve(response);\n      };\n      const snapshot = Array.from(runtimeListeners);\n      let willRespondAsync = false;\n      for (const listener of snapshot) {\n        const r = listener(message, sender, sendResponse);\n        if (r === true) willRespondAsync = true;\n        if (responded) return;\n      }\n      if (willRespondAsync) return;\n      reject(new Error(\"Could not establish connection. Receiving end does not exist.\"));\n    });\n  };\n\n  const extensionSender: chrome.runtime.MessageSender = {} as chrome.runtime.MessageSender;\n\n  const runtimePartial = {\n    sendMessage(message: unknown): Promise<unknown> {\n      return dispatch(message, extensionSender);\n    },\n    onMessage: {\n      addListener(listener: RuntimeListener): void {\n        runtimeListeners.add(listener);\n      },\n      removeListener(listener: RuntimeListener): void {\n        runtimeListeners.delete(listener);\n      },\n      hasListener(listener: RuntimeListener): boolean {\n        return runtimeListeners.has(listener);\n      },\n      hasListeners(): boolean {\n        return runtimeListeners.size > 0;\n      },\n    },\n  };\n\n  const runtime = runtimePartial as unknown as FakeChrome[\"runtime\"];\n\n  // ─── chrome.tabs.sendMessage — SW → content-script routing ─────────────\n  //\n  // Real chrome routes by tabId; the receiving content script's\n  // `chrome.runtime.onMessage` fires with `sender` representing the\n  // extension (no `sender.tab`). The fake collapses to the shared listener\n  // set since tests run one runtime per process, but enforces the\n  // \"tab gone\" reject so consumers can verify their fire-and-forget\n  // posture.\n  const tabsPartial = {\n    sendMessage(tabId: number, message: unknown): Promise<unknown> {\n      if (removedTabs.has(tabId)) {\n        return Promise.reject(\n          new Error(\n            `Could not establish connection. Receiving end does not exist. (tabId=${tabId})`,\n          ),\n        );\n      }\n      return dispatch(message, extensionSender);\n    },\n  };\n\n  // ─── chrome.tabs.on{Activated,Updated,Removed} — listener registries ────\n  //\n  // Tests drive fires via the __test helpers below. Production-code Sub\n  // factories register/unregister; the fake only models the registry +\n  // dispatch, not the chrome events themselves (no real tabs to observe).\n  const tabActivatedListeners = new Set<TabActivatedListener>();\n  const tabUpdatedListeners = new Set<TabUpdatedListener>();\n  const tabRemovedListeners = new Set<TabRemovedListener>();\n\n  const tabsFull = {\n    ...tabsPartial,\n    onActivated: {\n      addListener(listener: TabActivatedListener): void {\n        tabActivatedListeners.add(listener);\n      },\n      removeListener(listener: TabActivatedListener): void {\n        tabActivatedListeners.delete(listener);\n      },\n      hasListener(listener: TabActivatedListener): boolean {\n        return tabActivatedListeners.has(listener);\n      },\n      hasListeners(): boolean {\n        return tabActivatedListeners.size > 0;\n      },\n    },\n    onUpdated: {\n      addListener(listener: TabUpdatedListener): void {\n        tabUpdatedListeners.add(listener);\n      },\n      removeListener(listener: TabUpdatedListener): void {\n        tabUpdatedListeners.delete(listener);\n      },\n      hasListener(listener: TabUpdatedListener): boolean {\n        return tabUpdatedListeners.has(listener);\n      },\n      hasListeners(): boolean {\n        return tabUpdatedListeners.size > 0;\n      },\n    },\n    onRemoved: {\n      addListener(listener: TabRemovedListener): void {\n        tabRemovedListeners.add(listener);\n      },\n      removeListener(listener: TabRemovedListener): void {\n        tabRemovedListeners.delete(listener);\n      },\n      hasListener(listener: TabRemovedListener): boolean {\n        return tabRemovedListeners.has(listener);\n      },\n      hasListeners(): boolean {\n        return tabRemovedListeners.size > 0;\n      },\n    },\n  };\n\n  const tabs = tabsFull as unknown as FakeChrome[\"tabs\"];\n\n  // ─── chrome.alarms — listener registry + name-keyed alarm map ─────────\n  //\n  // create(name, info) stores `info` keyed by name (dedupe on repeat —\n  // matches real chrome's behavior of replacing the prior alarm). clear()\n  // removes from the map and resolves to `true` if the alarm existed,\n  // `false` otherwise (matches real chrome's contract). onAlarm is a\n  // standard listener registry. The fake does NOT auto-fire alarms based\n  // on `periodInMinutes` — tests drive fires deterministically via\n  // `__test.fireAlarm(name)`.\n  const alarmMap = new Map<string, chrome.alarms.AlarmCreateInfo>();\n  const alarmListeners = new Set<AlarmListener>();\n\n  const alarms: FakeChrome[\"alarms\"] = {\n    create(name: string, alarmInfo: chrome.alarms.AlarmCreateInfo): void {\n      alarmMap.set(name, alarmInfo);\n    },\n    async get(name: string): Promise<chrome.alarms.Alarm | undefined> {\n      const info = alarmMap.get(name);\n      if (info === undefined) return undefined;\n      return {\n        name,\n        scheduledTime: Date.now(),\n        periodInMinutes: info.periodInMinutes,\n      };\n    },\n    async clear(name: string): Promise<boolean> {\n      return alarmMap.delete(name);\n    },\n    onAlarm: {\n      addListener(listener: AlarmListener): void {\n        alarmListeners.add(listener);\n      },\n      removeListener(listener: AlarmListener): void {\n        alarmListeners.delete(listener);\n      },\n      hasListener(listener: AlarmListener): boolean {\n        return alarmListeners.has(listener);\n      },\n      hasListeners(): boolean {\n        return alarmListeners.size > 0;\n      },\n    },\n  };\n\n  return {\n    storage: {\n      local,\n      onChanged: {\n        addListener(listener: StorageChangeListener): void {\n          storageListeners.add(listener);\n        },\n        removeListener(listener: StorageChangeListener): void {\n          storageListeners.delete(listener);\n        },\n        hasListener(listener: StorageChangeListener): boolean {\n          return storageListeners.has(listener);\n        },\n        hasListeners(): boolean {\n          return storageListeners.size > 0;\n        },\n      },\n    },\n    runtime,\n    tabs,\n    alarms,\n    __test: {\n      sendFromTab(tabId: number, message: unknown): Promise<unknown> {\n        const taggedSender = { tab: { id: tabId } } as chrome.runtime.MessageSender;\n        return dispatch(message, taggedSender);\n      },\n      removeTab(tabId: number): void {\n        removedTabs.add(tabId);\n      },\n      addTab(tabId: number): void {\n        removedTabs.delete(tabId);\n      },\n      fireAlarm(name: string): void {\n        const info = alarmMap.get(name);\n        if (info === undefined) return;\n        // Real chrome's Alarm shape carries `name`, `scheduledTime`, and\n        // `periodInMinutes`. The fake stamps `scheduledTime` at fire time\n        // and forwards the period from the create call.\n        const alarm: chrome.alarms.Alarm = {\n          name,\n          scheduledTime: Date.now(),\n          periodInMinutes: info.periodInMinutes,\n        };\n        for (const listener of Array.from(alarmListeners)) {\n          listener(alarm);\n        }\n      },\n      getAlarms(): readonly string[] {\n        return Array.from(alarmMap.keys());\n      },\n      fireTabActivated(info: chrome.tabs.OnActivatedInfo): void {\n        for (const listener of Array.from(tabActivatedListeners)) {\n          listener(info);\n        }\n      },\n      fireTabUpdated(\n        tabId: number,\n        changeInfo: chrome.tabs.OnUpdatedInfo,\n        tab: chrome.tabs.Tab,\n      ): void {\n        for (const listener of Array.from(tabUpdatedListeners)) {\n          listener(tabId, changeInfo, tab);\n        }\n      },\n      fireTabRemoved(tabId: number, removeInfo: chrome.tabs.OnRemovedInfo): void {\n        for (const listener of Array.from(tabRemovedListeners)) {\n          listener(tabId, removeInfo);\n        }\n      },\n    },\n  };\n}\n"]}
+{"version":3,"sources":["../../src/extension/test-utils.ts"],"names":[],"mappings":"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","file":"test-utils.js","sourcesContent":["/**\n * In-memory `chrome.*` mock for tests in this package and any downstream\n * consumer that wants to test against `chromeStorageStore` behavior without\n * a real chrome environment.\n *\n * Currently exposes `chrome.storage.local`, `chrome.runtime` (sendMessage +\n * onMessage), and `chrome.tabs` (sendMessage). The `runtime` and `tabs`\n * surfaces are used by the runtime-bridge tests (`bridge.ts`) to round-trip\n * envelopes between a host runtime and a surface client (sw↔surface) and\n * between a sw client and a per-tab content-script runtime (sw↔content).\n *\n * Extend additional surfaces (alarms, windows, …) only when real consumer\n * tests reach for them — earn each surface through a concrete need.\n */\n\ntype RuntimeListener = (\n  message: unknown,\n  sender: chrome.runtime.MessageSender,\n  sendResponse: (response: unknown) => void,\n  // biome-ignore lint/suspicious/noConfusingVoidType: mirrors the chrome.runtime.onMessage listener return type (boolean | undefined | void)\n) => boolean | undefined | void;\n\ntype StorageChangeListener = (\n  changes: Record<string, chrome.storage.StorageChange>,\n  areaName: chrome.storage.AreaName,\n) => void;\n\ntype AlarmListener = (alarm: chrome.alarms.Alarm) => void;\n\ntype TabActivatedListener = (info: chrome.tabs.OnActivatedInfo) => void;\ntype TabUpdatedListener = (\n  tabId: number,\n  changeInfo: chrome.tabs.OnUpdatedInfo,\n  tab: chrome.tabs.Tab,\n) => void;\ntype TabRemovedListener = (\n  tabId: number,\n  removeInfo: chrome.tabs.OnRemovedInfo,\n) => void;\n\nexport interface FakeChrome {\n  storage: {\n    local: chrome.storage.StorageArea;\n    /**\n     * Top-level `chrome.storage.onChanged` event. Fires for ANY area; consumer\n     * filters by the `areaName` arg. Real chrome semantics: every `set` /\n     * `remove` / `clear` that materially changes a key emits a single\n     * `changes` map keyed by the changed keys.\n     */\n    onChanged: {\n      addListener(listener: StorageChangeListener): void;\n      removeListener(listener: StorageChangeListener): void;\n      hasListener(listener: StorageChangeListener): boolean;\n      hasListeners(): boolean;\n    };\n  };\n  // Subset of `typeof chrome.runtime` covered by the fake — chrome's\n  // ambient typings don't export a single `Runtime` interface, so we\n  // declare the surface inline. Extend when tests reach for more.\n  runtime: {\n    sendMessage: typeof chrome.runtime.sendMessage;\n    onMessage: typeof chrome.runtime.onMessage;\n  };\n  tabs: {\n    sendMessage: typeof chrome.tabs.sendMessage;\n    /**\n     * `chrome.tabs.onActivated` — fires when the active tab in a window\n     * changes. The fake only models the listener registry; tests drive\n     * fires via `__test.fireTabActivated(info)`.\n     */\n    onActivated: {\n      addListener(listener: TabActivatedListener): void;\n      removeListener(listener: TabActivatedListener): void;\n      hasListener(listener: TabActivatedListener): boolean;\n      hasListeners(): boolean;\n    };\n    /**\n     * `chrome.tabs.onUpdated` — fires when a tab is updated (url, title,\n     * status, etc.). Tests drive fires via `__test.fireTabUpdated(...)`.\n     */\n    onUpdated: {\n      addListener(listener: TabUpdatedListener): void;\n      removeListener(listener: TabUpdatedListener): void;\n      hasListener(listener: TabUpdatedListener): boolean;\n      hasListeners(): boolean;\n    };\n    /**\n     * `chrome.tabs.onRemoved` — fires when a tab is closed. Tests drive\n     * fires via `__test.fireTabRemoved(...)`.\n     */\n    onRemoved: {\n      addListener(listener: TabRemovedListener): void;\n      removeListener(listener: TabRemovedListener): void;\n      hasListener(listener: TabRemovedListener): boolean;\n      hasListeners(): boolean;\n    };\n  };\n  /**\n   * `chrome.alarms` — the MV3 periodic timer primitive. The fake tracks\n   * created alarms in a Map keyed by name, models `create` (dedupe by\n   * name) + `clear` (remove from map), and exposes `onAlarm` as a\n   * standard listener registry. Tests drive fires via\n   * `__test.fireAlarm(name)`.\n   */\n  alarms: {\n    create(name: string, alarmInfo: chrome.alarms.AlarmCreateInfo): void;\n    /**\n     * `chrome.alarms.get(name)` — resolves to the Alarm shape Chrome would\n     * return (with `scheduledTime` synthesized at lookup time), or\n     * undefined if no alarm with that name exists. Mirrors the contract\n     * the `ensureQueueAlarm` SW-module-top-level helper checks (\"is this\n     * alarm already present with the right period?\") — see\n     * `apps/extension/extension/entrypoints/background.ts`.\n     */\n    get(name: string): Promise<chrome.alarms.Alarm | undefined>;\n    clear(name: string): Promise<boolean>;\n    onAlarm: {\n      addListener(listener: AlarmListener): void;\n      removeListener(listener: AlarmListener): void;\n      hasListener(listener: AlarmListener): boolean;\n      hasListeners(): boolean;\n    };\n  };\n  /**\n   * Test helpers — not part of the real chrome surface. Lets tests\n   * simulate a content script issuing `chrome.runtime.sendMessage` from\n   * inside a specific tab (chrome auto-tags `sender.tab.id` in that\n   * direction) and remove a tab so `chrome.tabs.sendMessage` rejects\n   * the way real chrome does when the receiver is gone.\n   */\n  __test: {\n    /** Simulate a content-script broadcast tagged with `sender.tab.id`. */\n    sendFromTab(tabId: number, message: unknown): Promise<unknown>;\n    /** Mark a tab as gone — `chrome.tabs.sendMessage(tabId, …)` will reject. */\n    removeTab(tabId: number): void;\n    /** Mark a tab as alive (default for any tabId that hasn't been removed). */\n    addTab(tabId: number): void;\n    /** Fire an alarm — invokes every onAlarm listener with `{ name, ...}`. */\n    fireAlarm(name: string): void;\n    /** Snapshot the alarm registry — tests assert on created/cleared alarms. */\n    getAlarms(): readonly string[];\n    /** Fire `chrome.tabs.onActivated` — drives every listener. */\n    fireTabActivated(info: chrome.tabs.OnActivatedInfo): void;\n    /** Fire `chrome.tabs.onUpdated` — drives every listener. */\n    fireTabUpdated(\n      tabId: number,\n      changeInfo: chrome.tabs.OnUpdatedInfo,\n      tab: chrome.tabs.Tab,\n    ): void;\n    /** Fire `chrome.tabs.onRemoved` — drives every listener. */\n    fireTabRemoved(tabId: number, removeInfo: chrome.tabs.OnRemovedInfo): void;\n  };\n}\n\nexport function fakeChrome(): FakeChrome {\n  const data = new Map<string, unknown>();\n\n  // ─── chrome.storage.onChanged — top-level event ───────────────────────\n  //\n  // Real chrome emits `changes` keyed by every key that actually changed\n  // (oldValue / newValue present). Unchanged keys aren't included. The\n  // fake mirrors that: build the change map inside set/remove/clear, fire\n  // listeners only if the map is non-empty. AreaName is \"local\" here —\n  // the fake only models storage.local; if a future test reaches for\n  // session/sync, add a per-area fake with its own onChanged.\n  const storageListeners = new Set<StorageChangeListener>();\n  function deepEqual(a: unknown, b: unknown): boolean {\n    if (a === b) return true;\n    if (typeof a !== typeof b) return false;\n    if (typeof a !== \"object\" || a === null || b === null) return false;\n    return JSON.stringify(a) === JSON.stringify(b);\n  }\n  function fireStorageChange(\n    changes: Record<string, chrome.storage.StorageChange>,\n  ): void {\n    if (Object.keys(changes).length === 0) return;\n    for (const listener of Array.from(storageListeners)) {\n      listener(changes, \"local\");\n    }\n  }\n\n  const partial = {\n    async get(\n      keys?: string | string[] | Record<string, unknown> | null,\n    ): Promise<Record<string, unknown>> {\n      // get()              → all entries\n      // get(\"k\")           → { k: v } if present, {} otherwise\n      // get([\"k1\",\"k2\"])   → { k: v } for present keys\n      // get({ k: default}) → { k: v ?? default } per key\n      if (keys === undefined || keys === null) {\n        return Object.fromEntries(data);\n      }\n      if (typeof keys === \"string\") {\n        const v = data.get(keys);\n        return v === undefined ? {} : { [keys]: v };\n      }\n      if (Array.isArray(keys)) {\n        return Object.fromEntries(\n          keys.flatMap((k) => (data.has(k) ? [[k, data.get(k)]] : [])),\n        );\n      }\n      const out: Record<string, unknown> = {};\n      for (const [k, def] of Object.entries(keys)) {\n        out[k] = data.has(k) ? data.get(k) : def;\n      }\n      return out;\n    },\n    async set(items: Record<string, unknown>): Promise<void> {\n      const changes: Record<string, chrome.storage.StorageChange> = {};\n      for (const [k, v] of Object.entries(items)) {\n        const prev = data.get(k);\n        // Real chrome only fires onChanged when the value actually\n        // changes — match that to avoid spurious re-renders in tests.\n        if (deepEqual(prev, v)) continue;\n        const change: chrome.storage.StorageChange = { newValue: v };\n        if (data.has(k)) change.oldValue = prev;\n        changes[k] = change;\n        data.set(k, v);\n      }\n      fireStorageChange(changes);\n    },\n    async remove(keys: string | string[]): Promise<void> {\n      const arr = Array.isArray(keys) ? keys : [keys];\n      const changes: Record<string, chrome.storage.StorageChange> = {};\n      for (const k of arr) {\n        if (!data.has(k)) continue;\n        changes[k] = { oldValue: data.get(k) };\n        data.delete(k);\n      }\n      fireStorageChange(changes);\n    },\n    async clear(): Promise<void> {\n      const changes: Record<string, chrome.storage.StorageChange> = {};\n      for (const [k, v] of data) changes[k] = { oldValue: v };\n      data.clear();\n      fireStorageChange(changes);\n    },\n  };\n\n  // The full `chrome.storage.StorageArea` contract has more surface\n  // (getBytesInUse, getKeys, onChanged event, setAccessLevel) than real\n  // consumer tests currently exercise. The cast is local to this test util;\n  // src/index.ts never casts. If a test needs more surface, implement it\n  // here instead of widening the cast.\n  const local = partial as unknown as chrome.storage.StorageArea;\n\n  // ─── chrome.runtime — sendMessage + onMessage round-trip ───────────────\n  //\n  // The fake mirrors MV3 semantics that matter for the bridge:\n  //   - sendMessage delivers to EVERY onMessage listener in arrival order.\n  //   - The first listener that returns `true` (or calls sendResponse\n  //     synchronously) \"wins\" — its sendResponse value resolves the\n  //     sendMessage promise. Listeners that return false/undefined are\n  //     passed over.\n  //   - If no listener handles the message, sendMessage rejects with the\n  //     same shape chrome uses (\"Could not establish connection.\n  //     Receiving end does not exist.\"). The bridge's broadcast path\n  //     swallows this.\n  const runtimeListeners = new Set<RuntimeListener>();\n\n  // Tracks tabs that are \"alive\" from `chrome.tabs.sendMessage`'s point of\n  // view. Unknown tabIds are treated as alive by default (matches the\n  // common test path: assign a number, send to it). Tests can `removeTab`\n  // to simulate disconnection.\n  const removedTabs = new Set<number>();\n\n  /**\n   * Internal dispatch helper. Real chrome distinguishes:\n   *   - `chrome.runtime.sendMessage(msg)` — sender is the extension origin,\n   *     `sender.tab` is undefined; all `chrome.runtime.onMessage` listeners\n   *     hear it.\n   *   - `chrome.tabs.sendMessage(tabId, msg)` — sender is the extension\n   *     origin (still no `sender.tab` on the receiving end's view here, but\n   *     the routing is by tab); only listeners IN that tab receive it. Our\n   *     fake collapses to the same listener set since tests run a single\n   *     \"tab\" of listeners at a time. The routing assertion is enforced by\n   *     callers reading the envelope/tabId pair they sent.\n   *   - Content-script `chrome.runtime.sendMessage(msg)` (the `sendFromTab`\n   *     helper) — chrome auto-tags `sender.tab.id`. SW-side listeners use\n   *     this to filter cross-tab broadcasts.\n   *\n   * `sender` controls which sender object the listeners see.\n   */\n  const dispatch = (\n    message: unknown,\n    sender: chrome.runtime.MessageSender,\n  ): Promise<unknown> => {\n    return new Promise((resolve, reject) => {\n      let responded = false;\n      const sendResponse = (response: unknown): void => {\n        if (responded) return;\n        responded = true;\n        resolve(response);\n      };\n      const snapshot = Array.from(runtimeListeners);\n      let willRespondAsync = false;\n      for (const listener of snapshot) {\n        const r = listener(message, sender, sendResponse);\n        if (r === true) willRespondAsync = true;\n        if (responded) return;\n      }\n      if (willRespondAsync) return;\n      reject(\n        new Error(\n          \"Could not establish connection. Receiving end does not exist.\",\n        ),\n      );\n    });\n  };\n\n  const extensionSender: chrome.runtime.MessageSender =\n    {} as chrome.runtime.MessageSender;\n\n  const runtimePartial = {\n    sendMessage(message: unknown): Promise<unknown> {\n      return dispatch(message, extensionSender);\n    },\n    onMessage: {\n      addListener(listener: RuntimeListener): void {\n        runtimeListeners.add(listener);\n      },\n      removeListener(listener: RuntimeListener): void {\n        runtimeListeners.delete(listener);\n      },\n      hasListener(listener: RuntimeListener): boolean {\n        return runtimeListeners.has(listener);\n      },\n      hasListeners(): boolean {\n        return runtimeListeners.size > 0;\n      },\n    },\n  };\n\n  const runtime = runtimePartial as unknown as FakeChrome[\"runtime\"];\n\n  // ─── chrome.tabs.sendMessage — SW → content-script routing ─────────────\n  //\n  // Real chrome routes by tabId; the receiving content script's\n  // `chrome.runtime.onMessage` fires with `sender` representing the\n  // extension (no `sender.tab`). The fake collapses to the shared listener\n  // set since tests run one runtime per process, but enforces the\n  // \"tab gone\" reject so consumers can verify their fire-and-forget\n  // posture.\n  const tabsPartial = {\n    sendMessage(tabId: number, message: unknown): Promise<unknown> {\n      if (removedTabs.has(tabId)) {\n        return Promise.reject(\n          new Error(\n            `Could not establish connection. Receiving end does not exist. (tabId=${tabId})`,\n          ),\n        );\n      }\n      return dispatch(message, extensionSender);\n    },\n  };\n\n  // ─── chrome.tabs.on{Activated,Updated,Removed} — listener registries ────\n  //\n  // Tests drive fires via the __test helpers below. Production-code Sub\n  // factories register/unregister; the fake only models the registry +\n  // dispatch, not the chrome events themselves (no real tabs to observe).\n  const tabActivatedListeners = new Set<TabActivatedListener>();\n  const tabUpdatedListeners = new Set<TabUpdatedListener>();\n  const tabRemovedListeners = new Set<TabRemovedListener>();\n\n  const tabsFull = {\n    ...tabsPartial,\n    onActivated: {\n      addListener(listener: TabActivatedListener): void {\n        tabActivatedListeners.add(listener);\n      },\n      removeListener(listener: TabActivatedListener): void {\n        tabActivatedListeners.delete(listener);\n      },\n      hasListener(listener: TabActivatedListener): boolean {\n        return tabActivatedListeners.has(listener);\n      },\n      hasListeners(): boolean {\n        return tabActivatedListeners.size > 0;\n      },\n    },\n    onUpdated: {\n      addListener(listener: TabUpdatedListener): void {\n        tabUpdatedListeners.add(listener);\n      },\n      removeListener(listener: TabUpdatedListener): void {\n        tabUpdatedListeners.delete(listener);\n      },\n      hasListener(listener: TabUpdatedListener): boolean {\n        return tabUpdatedListeners.has(listener);\n      },\n      hasListeners(): boolean {\n        return tabUpdatedListeners.size > 0;\n      },\n    },\n    onRemoved: {\n      addListener(listener: TabRemovedListener): void {\n        tabRemovedListeners.add(listener);\n      },\n      removeListener(listener: TabRemovedListener): void {\n        tabRemovedListeners.delete(listener);\n      },\n      hasListener(listener: TabRemovedListener): boolean {\n        return tabRemovedListeners.has(listener);\n      },\n      hasListeners(): boolean {\n        return tabRemovedListeners.size > 0;\n      },\n    },\n  };\n\n  const tabs = tabsFull as unknown as FakeChrome[\"tabs\"];\n\n  // ─── chrome.alarms — listener registry + name-keyed alarm map ─────────\n  //\n  // create(name, info) stores `info` keyed by name (dedupe on repeat —\n  // matches real chrome's behavior of replacing the prior alarm). clear()\n  // removes from the map and resolves to `true` if the alarm existed,\n  // `false` otherwise (matches real chrome's contract). onAlarm is a\n  // standard listener registry. The fake does NOT auto-fire alarms based\n  // on `periodInMinutes` — tests drive fires deterministically via\n  // `__test.fireAlarm(name)`.\n  const alarmMap = new Map<string, chrome.alarms.AlarmCreateInfo>();\n  const alarmListeners = new Set<AlarmListener>();\n\n  const alarms: FakeChrome[\"alarms\"] = {\n    create(name: string, alarmInfo: chrome.alarms.AlarmCreateInfo): void {\n      alarmMap.set(name, alarmInfo);\n    },\n    async get(name: string): Promise<chrome.alarms.Alarm | undefined> {\n      const info = alarmMap.get(name);\n      if (info === undefined) return undefined;\n      return {\n        name,\n        scheduledTime: Date.now(),\n        periodInMinutes: info.periodInMinutes,\n      };\n    },\n    async clear(name: string): Promise<boolean> {\n      return alarmMap.delete(name);\n    },\n    onAlarm: {\n      addListener(listener: AlarmListener): void {\n        alarmListeners.add(listener);\n      },\n      removeListener(listener: AlarmListener): void {\n        alarmListeners.delete(listener);\n      },\n      hasListener(listener: AlarmListener): boolean {\n        return alarmListeners.has(listener);\n      },\n      hasListeners(): boolean {\n        return alarmListeners.size > 0;\n      },\n    },\n  };\n\n  return {\n    storage: {\n      local,\n      onChanged: {\n        addListener(listener: StorageChangeListener): void {\n          storageListeners.add(listener);\n        },\n        removeListener(listener: StorageChangeListener): void {\n          storageListeners.delete(listener);\n        },\n        hasListener(listener: StorageChangeListener): boolean {\n          return storageListeners.has(listener);\n        },\n        hasListeners(): boolean {\n          return storageListeners.size > 0;\n        },\n      },\n    },\n    runtime,\n    tabs,\n    alarms,\n    __test: {\n      sendFromTab(tabId: number, message: unknown): Promise<unknown> {\n        const taggedSender = {\n          tab: { id: tabId },\n        } as chrome.runtime.MessageSender;\n        return dispatch(message, taggedSender);\n      },\n      removeTab(tabId: number): void {\n        removedTabs.add(tabId);\n      },\n      addTab(tabId: number): void {\n        removedTabs.delete(tabId);\n      },\n      fireAlarm(name: string): void {\n        const info = alarmMap.get(name);\n        if (info === undefined) return;\n        // Real chrome's Alarm shape carries `name`, `scheduledTime`, and\n        // `periodInMinutes`. The fake stamps `scheduledTime` at fire time\n        // and forwards the period from the create call.\n        const alarm: chrome.alarms.Alarm = {\n          name,\n          scheduledTime: Date.now(),\n          periodInMinutes: info.periodInMinutes,\n        };\n        for (const listener of Array.from(alarmListeners)) {\n          listener(alarm);\n        }\n      },\n      getAlarms(): readonly string[] {\n        return Array.from(alarmMap.keys());\n      },\n      fireTabActivated(info: chrome.tabs.OnActivatedInfo): void {\n        for (const listener of Array.from(tabActivatedListeners)) {\n          listener(info);\n        }\n      },\n      fireTabUpdated(\n        tabId: number,\n        changeInfo: chrome.tabs.OnUpdatedInfo,\n        tab: chrome.tabs.Tab,\n      ): void {\n        for (const listener of Array.from(tabUpdatedListeners)) {\n          listener(tabId, changeInfo, tab);\n        }\n      },\n      fireTabRemoved(\n        tabId: number,\n        removeInfo: chrome.tabs.OnRemovedInfo,\n      ): void {\n        for (const listener of Array.from(tabRemovedListeners)) {\n          listener(tabId, removeInfo);\n        }\n      },\n    },\n  };\n}\n"]}

package/dist/fan-out/index.d.ts

@@ -0,0 +1,239 @@
+import { C as Cmd, P as Port } from '../core-CymXZCeY.js';
+import { QueueItem } from '../work-queue/index.js';
+import '../index.js';
+
+/**
+ * @demlik/tea/fan-out — scatter-gather over a bounded-concurrency work list.
+ *
+ * The Level-2 combinator that fans a batch of items out across at most
+ * `concurrency` in-flight effects, gathers each item's result (or error), and
+ * — once every item has settled — fires an optional `join` over the collected
+ * results. It is the "map a list through an effect, but never run more than N
+ * at once" knob.
+ *
+ * The recipe (which bricks it composes):
+ *   - `../work-queue` — fan-out's tracked items ARE work-queue items. Each
+ *     item carries the same `{ id, status, input }` lifecycle vocabulary
+ *     (`pending → running → done | failed`). The slice this knob owns is four
+ *     partitions over that one lifecycle, so the work-queue's status taxonomy
+ *     is the substrate rather than a parallel invention. We reuse its
+ *     `QueueItem<I>` / `QueueItemStatus` TYPES and delegate the ledger
+ *     transitions to its BLESSED pure ops (`@demlik/tea/work-queue/ops`):
+ *     `scatter` mints each pending record with `enqueueOp`, and `launchUpTo`
+ *     flips `pending → running` with `claimNextOp` (one positional claim per
+ *     launch). The lone exception is `settleOne`'s `running → done|failed`
+ *     flip — it must match "first id-match that is still `running`" to settle
+ *     exactly one of a DUPLICATE id, a status predicate the ops surface can't
+ *     express, so fan-out owns that one index (see `settleOne`). The async
+ *     `createQueue(store)` adapter is NOT used here because its `load → mutate
+ *     → save` reads the clock and lives at an I/O boundary, while a combinator's
+ *     verbs must be pure (invariant 2) — fan-out reaches the underlying ops
+ *     directly instead, the same route `monitored-run` / `idempotent-intake`
+ *     take. The slice lives in the Model instead — durable + replayable, the
+ *     two non-negotiables every knob preserves.
+ *
+ * Typical wiring (combinator form — splice the hooks into your machine):
+ *
+ *   const fan = createFanOut<Url, Report>({
+ *     concurrency: 4,
+ *     idOf: (url) => url,                                 // stable, pure identity
+ *     of: (url) => ({ type: "crawl", url }),              // the per-item effect, as data
+ *     join: (results) => ({ type: "report_done", results }),
+ *   });
+ *
+ *   // in `update`:
+ *   start_crawl:  (s, m) => { const [fanOut, cmds] = fan.scatter(s.fanOut, m.urls);
+ *                             return [{ ...s, fanOut }, cmds]; },
+ *   crawl_ok:     (s, m) => { const [fanOut, cmds] = fan.itemOk(s.fanOut, m.id, m.report);
+ *                             return [{ ...s, fanOut }, cmds]; },
+ *   crawl_err:    (s, m) => { const [fanOut, cmds] = fan.itemErr(s.fanOut, m.id, m.error);
+ *                             return [{ ...s, fanOut }, cmds]; },
+ *
+ * Every verb is PURE: it returns a NEW slice plus the Cmds to perform (the
+ * `of(item)` effects for newly-launched items, and at most one `join` Cmd when
+ * the batch completes). The reducer never reads a clock or RNG — item identity
+ * is supplied by the caller's `idOf` so `scatter` is deterministic, and the
+ * launch effects are plain data the runtime performs (invariant 3).
+ *
+ * `handlers(ports)` is the I/O splice: it wires the runtime side that actually
+ * runs each launched `of(item)` Cmd. Because `of` already produces a fully
+ * caller-defined Cmd, fan-out does NOT own the interpret handler for it — the
+ * consumer's own `interpret` performs the effect and routes Ok/Err back to the
+ * `itemOk` / `itemErr` verbs (the same shape resilient-fetch uses with
+ * `tryInterpret`). `handlers` therefore exposes the one piece fan-out CAN
+ * pre-wire generically: emitting the gathered batch onto a typed Port when the
+ * batch completes, for consumers that observe completion out-of-band rather
+ * than through the `join` Cmd.
+ *
+ * NOT a substrate primitive: it depends only on `../work-queue`'s pure types +
+ * blessed ops and `../index`'s `Cmd` / `Port` types. Consumers reach it via the
+ * `@demlik/tea/fan-out` subpath.
+ */
+
+/**
+ * One settled-OK item: the original `input` and the `result` its effect
+ * produced. Mirrors the spec slice's `done: {item, result}[]` — `item` is the
+ * caller's input value (not the internal `QueueItem` envelope), so a consumer
+ * reading `done` gets back exactly what it scattered.
+ */
+interface FanOutDone<I, R> {
+    /** The original scattered input value. */
+    readonly item: I;
+    /** The result the item's effect produced, routed in via `itemOk`. */
+    readonly result: R;
+}
+/**
+ * One settled-error item: the original `input` and the `error` its effect
+ * surfaced. `error` is `unknown` — fan-out carries it forward verbatim (an
+ * `Error`, a tagged result, a string) for the consumer's reducer to read,
+ * never interpreting it (same discipline as `retry-backoff`'s `lastError`).
+ */
+interface FanOutFailed<I> {
+    /** The original scattered input value. */
+    readonly item: I;
+    /** The error the item's effect surfaced, routed in via `itemErr`. Carried, never interpreted. */
+    readonly error: unknown;
+}
+/**
+ * The slice this knob owns — four partitions over the work-queue item
+ * lifecycle, plus the work-queue records the verbs thread the lifecycle
+ * through.
+ *
+ * Why both the spec's four arrays AND `items`:
+ *   - The four arrays (`pending` / `running` / `done` / `failed`) are the
+ *     SPEC's public read surface — what a consumer's view renders and what
+ *     `isComplete` reads. They hold caller-facing values (`I`, or
+ *     `FanOutDone` / `FanOutFailed`), not the internal id-bearing envelope.
+ *   - `items` is the work-queue ledger: one `QueueItem<I>` per scattered item,
+ *     carrying the stable `id` (from `config.idOf`) that `itemOk` / `itemErr`
+ *     address and the `status` that decides launch-eligibility. It is the
+ *     single source of truth; the four arrays are a derived projection kept in
+ *     lockstep so consumers never re-scan `items` to render a partition.
+ *
+ * Every field is `readonly` and the whole slice is JSON-serializable (plain
+ * arrays + the work-queue's plain `QueueItem` records), so it round-trips
+ * through a consumer's `Store<S>` unchanged — durable across DO eviction.
+ */
+interface FanOutState<I, R> {
+    /** Items accepted but not yet launched (queue back-pressure beyond `concurrency`). */
+    readonly pending: readonly I[];
+    /** Items whose `of(item)` effect is in flight (size never exceeds `concurrency`). */
+    readonly running: readonly I[];
+    /** Items whose effect resolved OK, with the result it produced. */
+    readonly done: readonly FanOutDone<I, R>[];
+    /** Items whose effect failed, with the error it surfaced. */
+    readonly failed: readonly FanOutFailed<I>[];
+    /**
+     * The work-queue ledger: one record per scattered item, keyed by the
+     * caller's `idOf`. The single source of truth the four arrays project from.
+     */
+    readonly items: readonly QueueItem<I>[];
+    /**
+     * Index into `done` where the CURRENT wave's OK results begin. `done` is
+     * append-only and accumulates across every wave (so a consumer reading
+     * `done` sees the full history), but `join` must fold only the wave that
+     * just drained — not the cumulative total. A wave opens when `scatter`
+     * enqueues into a slice with nothing in flight; this marks `done.length` at
+     * that moment so `join` receives exactly `done.slice(waveDoneFrom)`.
+     */
+    readonly waveDoneFrom: number;
+    /**
+     * Index into `failed` where the current wave's failures begin. Symmetric to
+     * `waveDoneFrom` — the wave boundary over the failure partition. Carried for
+     * a consumer that wants to read only the current wave's failures; `join`
+     * itself folds only OK results.
+     */
+    readonly waveFailedFrom: number;
+    /**
+     * Whether the current wave has already fired its `join`. `join` fires at most
+     * once per wave — set `true` at the completion edge so a stale settle that
+     * re-reaches `isComplete` cannot re-fire it. A new `scatter` that opens a wave
+     * resets it to `false`.
+     */
+    readonly joined: boolean;
+}
+/**
+ * The knob. `concurrency` caps how many `of(item)` effects are in flight at
+ * once; `idOf` mints a stable, PURE identity per item (so `scatter` is
+ * deterministic and `itemOk` / `itemErr` can address an item by id); `of`
+ * turns an item into the launch Cmd; `join` (optional) turns the gathered
+ * results into a single completion Cmd fired exactly once when every item has
+ * settled.
+ *
+ * Field optionality follows the resilient-call rule — omit `join`, omit the
+ * completion Cmd (a consumer that observes `isComplete` itself, or wires the
+ * `handlers` Port, doesn't need one).
+ */
+interface FanOutConfig<I, R, C extends Cmd, J extends Cmd> {
+    /** Max in-flight `of(item)` effects. Clamped to `>= 1` (a 0/negative cap would deadlock). */
+    readonly concurrency: number;
+    /**
+     * Stable, deterministic identity for an item. PURE — no clock, no RNG. The
+     * id is what `itemOk` / `itemErr` address, so it must survive a round-trip
+     * through the durable slice and match across the launch → settle gap. For
+     * value-unique inputs (URLs, ids) this is often the identity function; for
+     * structural inputs, a content hash or a caller-assigned key.
+     */
+    readonly idOf: (item: I) => string;
+    /** The per-item effect, as data. Performed by the consumer's own `interpret`. */
+    readonly of: (item: I) => C;
+    /**
+     * Optional: fold the gathered done-results into a single completion Cmd,
+     * fired exactly once at the transition that empties `pending` + `running`.
+     * Omit to drive completion off `isComplete` (or the `handlers` Port) instead.
+     */
+    readonly join?: (results: readonly R[]) => J;
+}
+/** The starting slice: nothing scattered yet. */
+declare function initFanOut<I, R>(): FanOutState<I, R>;
+/**
+ * Whether every scattered item has settled (no `pending`, no `running`).
+ * Derived — reads the slice, never mutates. The verbs use it to decide when to
+ * fire `join`; consumers can read it directly to branch their own phase.
+ *
+ * An empty fan-out (nothing ever scattered) is NOT complete: completion is "a
+ * non-empty batch fully drained," so `isComplete(initFanOut())` is `false` and
+ * a `scatter([])` of zero items also reads `false` (there was no batch to
+ * complete). This keeps `join` from firing on a degenerate empty scatter.
+ */
+declare function isComplete<I, R>(state: FanOutState<I, R>): boolean;
+/**
+ * Optional Port for observing batch completion out-of-band. When a consumer
+ * passes `handlers(ports)` a `complete` Port, the runtime side can emit the
+ * gathered results onto it the moment `isComplete` flips true — distinct from
+ * the in-band `join` Cmd (which threads back through `update`). Use the Port
+ * for "tell the outside world the batch finished" without folding a completion
+ * signal into the consumer's Msg union.
+ */
+interface FanOutPorts<R> {
+    /** Fires once with every gathered done-result when the batch completes. */
+    readonly complete: Port<readonly R[]>;
+}
+/**
+ * Build the fan-out knob from `config`. Returns the uniform combinator
+ * contract: `init` for the owned slice, the three settle verbs + the derived
+ * `isComplete`, and `handlers` for the optional out-of-band completion Port.
+ *
+ * No `subs` — fan-out runs no timers (the spec pins "Subs: none"). The
+ * per-item effect's lifetime is owned by the consumer's `interpret`, and
+ * completion is a pure function of the settle Msgs, so there is nothing
+ * continuous to subscribe to.
+ */
+declare function createFanOut<I, R, C extends Cmd = Cmd, J extends Cmd = Cmd>(config: FanOutConfig<I, R, C, J>): {
+    init: () => FanOutState<I, R>;
+    scatter: (state: FanOutState<I, R>, items: readonly I[]) => readonly [FanOutState<I, R>, readonly C[]];
+    itemOk: (state: FanOutState<I, R>, id: string, result: R) => readonly [FanOutState<I, R>, readonly (C | J)[]];
+    itemErr: (state: FanOutState<I, R>, id: string, error: unknown) => readonly [FanOutState<I, R>, readonly (C | J)[]];
+    isComplete: typeof isComplete;
+    handlers: (ports: FanOutPorts<R>) => {
+        /**
+         * Emit the gathered done-results onto `ports.complete` iff `state` is a
+         * just-completed batch. Idempotency is the caller's concern (call it once
+         * per transition via `observe`); emitting to a Port with no subscribers
+         * is a no-op at the runtime, so an extra call is harmless.
+         */
+        emitOnComplete(emit: <T>(port: Port<T>, value: T) => void, state: FanOutState<I, R>): void;
+    };
+};
+
+export { type FanOutConfig, type FanOutDone, type FanOutFailed, type FanOutPorts, type FanOutState, createFanOut, initFanOut, isComplete };

package/dist/fan-out/index.js

@@ -0,0 +1,5 @@
+export { createFanOut, initFanOut, isComplete } from '../chunk-UV6UWGEO.js';
+import '../chunk-HJO6VNQI.js';
+import '../chunk-TGG26XMK.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/fan-out/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/idempotency/adapter.d.ts

@@ -0,0 +1,62 @@
+import { IdempotencyStore } from './index.js';
+
+/**
+ * @demlik/tea/idempotency/adapter — the verb seam over the pure idempotency ops.
+ *
+ * The functions in `./index` (`seen` / `recall` / `remember` / `evictExpired`
+ * / `initStore`) are the BLESSED transitions, but their names and the
+ * `IdempotencyStore<V>` shape they read/return are the STORE's vocabulary. A
+ * consumer that owns an `IdempotencyStore<V>` slice (`idempotent-intake`,
+ * `poller`) used to import those functions by name and call them directly, so
+ * a change to the op surface — or to `IdempotencyStore`'s fields — cascaded to
+ * every call site.
+ *
+ * `IdempotencyMemory<V>` is the insulating interface: five VERBS (`isSeen` /
+ * `recall` / `remember` / `evict` / `init`) consumers depend on instead of the
+ * raw functions. The verbs keep the ops' pure contract — no I/O, no `Date.now`
+ * (the clock is injected as `now`) — so a consumer folding the adapter through
+ * its reducer stays inside invariant 2 (pure transitions). `isSeen` renames the
+ * blessed `seen` predicate (a noun-y `seen` reads ambiguously as a slice field;
+ * the verb form states the question it answers), and `evict` is the verb form
+ * of `evictExpired`.
+ *
+ * `idempotencyMemory<V>()` is the canonical implementation, a thin binding of
+ * the blessed ops. Because the verbs are the only surface consumers touch, an
+ * `IdempotencyStore` shape change is absorbed HERE rather than at the consumer
+ * call sites.
+ *
+ * INTERNAL seam (no public-API port): consumers import the adapter from this
+ * subpath the same way they imported the ops. The ops remain exported from
+ * `./index` for any call site that genuinely wants a function directly.
+ */
+
+/**
+ * The verb interface over an `IdempotencyStore<V>`. Each verb mirrors a blessed
+ * op's pure contract but speaks the consumer's dedupe vocabulary, so the
+ * consumer never names a store function or reaches into an `IdempotencyStore`
+ * field it did not put there.
+ */
+interface IdempotencyMemory<V> {
+    /** Create an empty store, optionally bounded by `capacity` and/or `ttlMs`. */
+    init(opts?: {
+        capacity?: number;
+        ttlMs?: number;
+    }): IdempotencyStore<V>;
+    /** True iff `key` is present AND not expired at `now`. Read-only. */
+    isSeen(store: IdempotencyStore<V>, key: string, now: number): boolean;
+    /** The cached value for `key` if present and unexpired at `now`. Read-only. */
+    recall(store: IdempotencyStore<V>, key: string, now: number): V | undefined;
+    /** Record `key → value` at `now`, enforcing the store's bounds. Returns a new store. */
+    remember(store: IdempotencyStore<V>, key: string, value: V, now: number): IdempotencyStore<V>;
+    /** Drop every entry expired at `now`. Returns a new store. */
+    evict(store: IdempotencyStore<V>, now: number): IdempotencyStore<V>;
+}
+/**
+ * The canonical `IdempotencyMemory<V>`, binding each verb to its blessed op.
+ * Pure and stateless — call once at module scope in a consumer and fold its
+ * verbs through the reducer. An `IdempotencyStore` shape change is absorbed by
+ * re-binding a verb here, not at the consumers.
+ */
+declare function idempotencyMemory<V>(): IdempotencyMemory<V>;
+
+export { type IdempotencyMemory, idempotencyMemory };

package/dist/idempotency/adapter.js

@@ -0,0 +1,4 @@
+export { idempotencyMemory } from '../chunk-BYQUGDD3.js';
+import '../chunk-K575PT4S.js';
+//# sourceMappingURL=adapter.js.map
+//# sourceMappingURL=adapter.js.map

package/dist/idempotency/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"adapter.js"}

package/dist/idempotency/index.js

@@ -1,58 +1,3 @@
-// src/idempotency/index.ts
-function initStore(opts) {
-  return {
-    entries: {},
-    order: [],
-    capacity: opts?.capacity,
-    ttlMs: opts?.ttlMs
-  };
-}
-function isExpired(entry, nowMs, ttlMs) {
-  if (ttlMs === void 0) return false;
-  return nowMs - entry.atMs >= ttlMs;
-}
-function seen(store, key, nowMs) {
-  const entry = store.entries[key];
-  if (entry === void 0) return false;
-  return !isExpired(entry, nowMs, store.ttlMs);
-}
-function recall(store, key, nowMs) {
-  const entry = store.entries[key];
-  if (entry === void 0 || isExpired(entry, nowMs, store.ttlMs))
-    return void 0;
-  return entry.value;
-}
-function evictExpired(store, nowMs) {
-  if (store.ttlMs === void 0) return store;
-  const nextEntries = {};
-  const nextOrder = [];
-  for (const key of store.order) {
-    const entry = store.entries[key];
-    if (entry === void 0) continue;
-    if (isExpired(entry, nowMs, store.ttlMs)) continue;
-    nextEntries[key] = entry;
-    nextOrder.push(key);
-  }
-  return { ...store, entries: nextEntries, order: nextOrder };
-}
-function remember(store, key, value, nowMs) {
-  const pruned = evictExpired(store, nowMs);
-  const nextEntries = {
-    ...pruned.entries
-  };
-  nextEntries[key] = { value, atMs: nowMs };
-  const nextOrder = pruned.order.filter((k) => k !== key);
-  nextOrder.push(key);
-  if (store.capacity !== void 0) {
-    while (nextOrder.length > store.capacity) {
-      const oldest = nextOrder.shift();
-      if (oldest === void 0) break;
-      delete nextEntries[oldest];
-    }
-  }
-  return { ...store, entries: nextEntries, order: nextOrder };
-}
-
-export { evictExpired, initStore, recall, remember, seen };
+export { evictExpired, initStore, recall, remember, seen } from '../chunk-K575PT4S.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/idempotency/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/idempotency/index.ts"],"names":[],"mappings":";AAuFO,SAAS,UAAa,IAAA,EAGL;AACtB,EAAA,OAAO;AAAA,IACL,SAAS,EAAC;AAAA,IACV,OAAO,EAAC;AAAA,IACR,UAAU,IAAA,EAAM,QAAA;AAAA,IAChB,OAAO,IAAA,EAAM;AAAA,GACf;AACF;AAUA,SAAS,SAAA,CACP,KAAA,EACA,KAAA,EACA,KAAA,EACS;AACT,EAAA,IAAI,KAAA,KAAU,QAAW,OAAO,KAAA;AAChC,EAAA,OAAO,KAAA,GAAQ,MAAM,IAAA,IAAQ,KAAA;AAC/B;AAQO,SAAS,IAAA,CACd,KAAA,EACA,GAAA,EACA,KAAA,EACS;AACT,EAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,OAAA,CAAQ,GAAG,CAAA;AAC/B,EAAA,IAAI,KAAA,KAAU,QAAW,OAAO,KAAA;AAChC,EAAA,OAAO,CAAC,SAAA,CAAU,KAAA,EAAO,KAAA,EAAO,MAAM,KAAK,CAAA;AAC7C;AASO,SAAS,MAAA,CACd,KAAA,EACA,GAAA,EACA,KAAA,EACe;AACf,EAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,OAAA,CAAQ,GAAG,CAAA;AAC/B,EAAA,IAAI,UAAU,MAAA,IAAa,SAAA,CAAU,KAAA,EAAO,KAAA,EAAO,MAAM,KAAK,CAAA;AAC5D,IAAA,OAAO,MAAA;AACT,EAAA,OAAO,KAAA,CAAM,KAAA;AACf;AAQO,SAAS,YAAA,CACd,OACA,KAAA,EACqB;AACrB,EAAA,IAAI,KAAA,CAAM,KAAA,KAAU,MAAA,EAAW,OAAO,KAAA;AACtC,EAAA,MAAM,cAAmD,EAAC;AAC1D,EAAA,MAAM,YAAsB,EAAC;AAG7B,EAAA,KAAA,MAAW,GAAA,IAAO,MAAM,KAAA,EAAO;AAC7B,IAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,OAAA,CAAQ,GAAG,CAAA;AAC/B,IAAA,IAAI,UAAU,MAAA,EAAW;AACzB,IAAA,IAAI,SAAA,CAAU,KAAA,EAAO,KAAA,EAAO,KAAA,CAAM,KAAK,CAAA,EAAG;AAC1C,IAAA,WAAA,CAAY,GAAG,CAAA,GAAI,KAAA;AACnB,IAAA,SAAA,CAAU,KAAK,GAAG,CAAA;AAAA,EACpB;AACA,EAAA,OAAO,EAAE,GAAG,KAAA,EAAO,OAAA,EAAS,WAAA,EAAa,OAAO,SAAA,EAAU;AAC5D;AAoBO,SAAS,QAAA,CACd,KAAA,EACA,GAAA,EACA,KAAA,EACA,KAAA,EACqB;AAErB,EAAA,MAAM,MAAA,GAAS,YAAA,CAAa,KAAA,EAAO,KAAK,CAAA;AAKxC,EAAA,MAAM,WAAA,GAAmD;AAAA,IACvD,GAAG,MAAA,CAAO;AAAA,GACZ;AACA,EAAA,WAAA,CAAY,GAAG,CAAA,GAAI,EAAE,KAAA,EAAO,MAAM,KAAA,EAAM;AACxC,EAAA,MAAM,YAAY,MAAA,CAAO,KAAA,CAAM,OAAO,CAAC,CAAA,KAAM,MAAM,GAAG,CAAA;AACtD,EAAA,SAAA,CAAU,KAAK,GAAG,CAAA;AAKlB,EAAA,IAAI,KAAA,CAAM,aAAa,MAAA,EAAW;AAChC,IAAA,OAAO,SAAA,CAAU,MAAA,GAAS,KAAA,CAAM,QAAA,EAAU;AACxC,MAAA,MAAM,MAAA,GAAS,UAAU,KAAA,EAAM;AAC/B,MAAA,IAAI,WAAW,MAAA,EAAW;AAC1B,MAAA,OAAO,YAAY,MAAM,CAAA;AAAA,IAC3B;AAAA,EACF;AAEA,EAAA,OAAO,EAAE,GAAG,KAAA,EAAO,OAAA,EAAS,WAAA,EAAa,OAAO,SAAA,EAAU;AAC5D","file":"index.js","sourcesContent":["/**\n * @demlik/tea/idempotency — dedupe-by-key + last-result cache as pure state + ops.\n *\n * Same shape as `@demlik/tea/work-queue`'s `ops.ts` and `@demlik/tea/rate-limit`:\n * a state type plus pure transition functions. Host-agnostic by construction —\n * no `Date.now()`, no timers, no I/O. The caller injects the clock (`nowMs`)\n * and wires the result into its own reducer / interpret. This keeps the store\n * inside TEA's invariant 2 (transitions are pure: same inputs → same outputs,\n * no `Date.now`) so a consumer can fold it through `update` and exercise it\n * with `replay` / the pbt fold without a fake clock.\n *\n * Every op returns a NEW store value and never mutates its input (invariant 1 —\n * state is a value, not a place). `seen` / `recall` are read-shaped predicates;\n * `remember` / `evictExpired` return a new store.\n *\n * The use case: a webhook receiver, a retried queue message, or a repeated user\n * action arrives carrying an idempotency key. `seen(store, key, now)` answers\n * \"did I already process this?\"; `recall(store, key, now)` returns the cached\n * result so the duplicate request gets the SAME response the original produced\n * rather than re-running the side effect. `remember(store, key, value, now)`\n * records the key + its result after the first run.\n *\n * Two eviction policies keep the store bounded, both injected at `initStore`:\n *\n *   - **`ttlMs`** — an entry expires `ttlMs` after the `atMs` it was remembered\n *     at. `seen` / `recall` treat an expired entry as absent; `evictExpired`\n *     (and every `remember`) physically drops it. Without a TTL, entries live\n *     until evicted by capacity. The cutoff is half-open: an entry exactly\n *     `ttlMs` old is expired (`age >= ttlMs` drops it), matching `rate-limit`'s\n *     window edge — a key remembered at `t` no longer counts at `t + ttlMs`.\n *   - **`capacity`** — at most `capacity` entries are retained. When a\n *     `remember` would push the count past `capacity` (after expiry eviction),\n *     the OLDEST entries by insertion `order` are dropped until the count fits.\n *     Without a capacity, the store grows unbounded (TTL alone bounds it).\n *\n * `order` is the insertion-order index that capacity eviction reads — the keys\n * oldest-first. It is the store's own LRU-by-insertion ledger, kept in lockstep\n * with `entries` so `entries` never needs to be sorted to find the oldest.\n *\n * **Overwrite semantics** (decided + pinned by tests): re-`remember`ing an\n * existing key is an UPDATE, not a no-op. It (1) overwrites `value`, (2)\n * refreshes `atMs` to the new `nowMs` — so the TTL clock restarts and a\n * frequently-seen key never expires — and (3) moves the key to the NEWEST\n * position in `order` — so capacity eviction treats a re-remembered key as\n * fresh, not as a stale candidate for eviction. This makes `remember` behave\n * like \"touch\": a key actively being re-seen is kept alive on both the TTL and\n * capacity axes.\n *\n * NOT exported from the package root — reached via the `@demlik/tea/idempotency`\n * subpath, same one-shape-per-package rule as `work-queue`, `rate-limit`, and\n * `do`.\n */\n\n/**\n * A cached entry: the result `value` the original request produced and the\n * clock reading `atMs` it was remembered at. `atMs` is the TTL anchor — expiry\n * is measured from here, and a re-`remember` refreshes it. Both fields are\n * plain data so the whole store is trivially JSON-serializable into a\n * consumer's `Store<S>`.\n */\nexport interface IdempotencyEntry<V> {\n  readonly value: V;\n  readonly atMs: number;\n}\n\n/**\n * The dedupe store: a map of `key → entry`, an insertion-`order` ledger\n * (oldest-first) that capacity eviction reads, and the two optional bounds.\n *\n * `entries` and `order` are kept in lockstep — every key in `order` has an\n * entry and vice versa. `capacity` / `ttlMs` are carried on the store (not\n * passed per-op) so a single value fully describes the policy; a consumer\n * persists the store and rehydrates the same bounds without re-deriving them.\n */\nexport interface IdempotencyStore<V> {\n  readonly entries: Readonly<Record<string, IdempotencyEntry<V>>>;\n  readonly order: readonly string[];\n  readonly capacity?: number;\n  readonly ttlMs?: number;\n}\n\n/**\n * Create an empty store. `capacity` and `ttlMs` are both optional — omit both\n * for an unbounded cache, supply either or both to bound by count, age, or\n * both. Stored on the returned value so every later op reads the policy off\n * the store rather than from a re-passed argument.\n */\nexport function initStore<V>(opts?: {\n  capacity?: number;\n  ttlMs?: number;\n}): IdempotencyStore<V> {\n  return {\n    entries: {},\n    order: [],\n    capacity: opts?.capacity,\n    ttlMs: opts?.ttlMs,\n  };\n}\n\n/**\n * Whether `entry` (remembered at `entry.atMs`) is expired at `nowMs` under\n * `ttlMs`. Half-open: an entry exactly `ttlMs` old is expired (`age >= ttlMs`),\n * matching `rate-limit`'s window-edge cutoff. A `nowMs` before `atMs` (clock\n * skewed backwards) yields a negative age — never expired, the safe direction\n * (a duplicate is still deduped rather than re-run). When `ttlMs` is undefined\n * the entry never expires by age.\n */\nfunction isExpired<V>(\n  entry: IdempotencyEntry<V>,\n  nowMs: number,\n  ttlMs: number | undefined,\n): boolean {\n  if (ttlMs === undefined) return false;\n  return nowMs - entry.atMs >= ttlMs;\n}\n\n/**\n * True iff `key` is present AND not expired at `nowMs`. This is the dedupe\n * predicate: a webhook / retried message / repeated action whose key returns\n * `true` has already been processed and should be short-circuited (paired with\n * `recall` to return the original result). PURE — reads only, never mutates.\n */\nexport function seen<V>(\n  store: IdempotencyStore<V>,\n  key: string,\n  nowMs: number,\n): boolean {\n  const entry = store.entries[key];\n  if (entry === undefined) return false;\n  return !isExpired(entry, nowMs, store.ttlMs);\n}\n\n/**\n * The cached `value` for `key` if present and unexpired at `nowMs`, else\n * `undefined`. Use after `seen` returns `true` to replay the original result to\n * a duplicate request. An expired entry reads as absent (returns `undefined`)\n * even though it is physically still in `entries` until the next `remember` /\n * `evictExpired` drops it. PURE — reads only, never mutates.\n */\nexport function recall<V>(\n  store: IdempotencyStore<V>,\n  key: string,\n  nowMs: number,\n): V | undefined {\n  const entry = store.entries[key];\n  if (entry === undefined || isExpired(entry, nowMs, store.ttlMs))\n    return undefined;\n  return entry.value;\n}\n\n/**\n * Drop every entry expired at `nowMs` (older than `ttlMs`). Returns a NEW store\n * with the survivors; `order` is rebuilt to drop the same keys, preserving the\n * relative insertion order of the survivors. A no-TTL store returns an\n * equivalent store (nothing ages out). PURE — the input store is never mutated.\n */\nexport function evictExpired<V>(\n  store: IdempotencyStore<V>,\n  nowMs: number,\n): IdempotencyStore<V> {\n  if (store.ttlMs === undefined) return store;\n  const nextEntries: Record<string, IdempotencyEntry<V>> = {};\n  const nextOrder: string[] = [];\n  // Walk `order` (not `Object.keys`) so the surviving order ledger keeps the\n  // exact relative insertion order capacity eviction depends on.\n  for (const key of store.order) {\n    const entry = store.entries[key];\n    if (entry === undefined) continue; // defensive: order/entries kept in lockstep\n    if (isExpired(entry, nowMs, store.ttlMs)) continue;\n    nextEntries[key] = entry;\n    nextOrder.push(key);\n  }\n  return { ...store, entries: nextEntries, order: nextOrder };\n}\n\n/**\n * Record `key → value` at `nowMs`, then enforce both bounds. PURE — returns a\n * new store; the input is untouched.\n *\n * Order of operations (each step matters):\n *   1. **Expiry eviction** — drop everything older than `ttlMs` first, so an\n *      expired key never occupies a capacity slot the new entry could take, and\n *      a stale entry under the same `key` is cleared before the overwrite.\n *   2. **Insert / overwrite** — write the new entry. If `key` already exists,\n *      this is an UPDATE: `value` is overwritten, `atMs` is refreshed to\n *      `nowMs` (restarting the TTL clock), and the key is moved to the NEWEST\n *      position in `order` (removed from wherever it sat, appended at the end).\n *      See the module-level \"Overwrite semantics\" note.\n *   3. **Capacity eviction** — if the entry count now exceeds `capacity`, drop\n *      the OLDEST keys by `order` until the count fits. Because step 2 moves a\n *      re-remembered key to the newest position, an actively re-seen key is\n *      never the eviction victim.\n */\nexport function remember<V>(\n  store: IdempotencyStore<V>,\n  key: string,\n  value: V,\n  nowMs: number,\n): IdempotencyStore<V> {\n  // Step 1 — expire first so stale entries free capacity slots before insert.\n  const pruned = evictExpired(store, nowMs);\n\n  // Step 2 — insert/overwrite. Drop any prior position of `key` from order,\n  // then append it as newest. `delete` on a fresh shallow copy keeps the input\n  // store untouched (invariant 1).\n  const nextEntries: Record<string, IdempotencyEntry<V>> = {\n    ...pruned.entries,\n  };\n  nextEntries[key] = { value, atMs: nowMs };\n  const nextOrder = pruned.order.filter((k) => k !== key);\n  nextOrder.push(key);\n\n  // Step 3 — capacity eviction. Drop oldest (front of `order`) until the count\n  // fits. `capacity <= 0` evicts everything just inserted down to the bound;\n  // `undefined` capacity skips eviction entirely.\n  if (store.capacity !== undefined) {\n    while (nextOrder.length > store.capacity) {\n      const oldest = nextOrder.shift();\n      if (oldest === undefined) break; // order emptied — nothing left to evict\n      delete nextEntries[oldest];\n    }\n  }\n\n  return { ...store, entries: nextEntries, order: nextOrder };\n}\n"]}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}