ranuts 0.4.1-alpha.1 → 0.5.0

package/dist/src/stream/accumulator.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Folds a {@link StreamChunk} sequence into the blocks it describes.
+ *
+ * A renderer wants "the current text", not "every delta since the start", and rebuilding
+ * that by concatenating in the view is where streaming UIs leak: the view ends up owning
+ * ordering, interleaving, and the block-end/delta reconciliation. This owns all three, so
+ * a view reads a snapshot and renders it.
+ */
+import type { ContentBlock, FinishReason, StreamChunk, TokenUsage } from "./types.js";
+/** Immutable view of everything received so far. */
+export interface StreamSnapshot {
+    /** Completed and in-progress blocks, in `index` order. */
+    readonly blocks: readonly ContentBlock[];
+    /** Latest usage report, once one has arrived. */
+    readonly usage: TokenUsage | undefined;
+    /** Terminal reason, once `finish` has arrived. */
+    readonly finishReason: FinishReason | undefined;
+    /** True once `finish` has arrived. */
+    readonly done: boolean;
+}
+/** Stateful fold over one response's chunks. */
+export interface StreamAccumulator {
+    /**
+     * Applies one chunk.
+     *
+     * A delta for an unseen `index` opens its block, because several providers omit
+     * `block-start` entirely. A `block-end` replaces whatever was accumulated at that index:
+     * the assembled block the provider sent is authoritative.
+     *
+     * @param chunk The chunk to fold in.
+     */
+    push(chunk: StreamChunk): void;
+    /** @returns An immutable view of the current state. */
+    snapshot(): StreamSnapshot;
+    /** @returns Every text block concatenated, in index order. */
+    text(): string;
+    /** @returns Every reasoning block concatenated, in index order. */
+    reasoning(): string;
+    /** @returns Completed tool calls, in index order. */
+    toolCalls(): readonly Extract<ContentBlock, {
+        type: 'tool-call';
+    }>[];
+    /** Discards all state so the instance can fold another response. */
+    reset(): void;
+}
+/**
+ * Creates a fold over one streamed response.
+ *
+ * @returns A fresh accumulator with no state.
+ */
+export declare function createStreamAccumulator(): StreamAccumulator;

package/dist/src/stream/accumulator.js

@@ -0,0 +1,79 @@
+function d(r) {
+  return r === "text" ? {
+    type: "text",
+    text: ""
+  } : r === "reasoning" ? {
+    type: "reasoning",
+    text: ""
+  } : {
+    type: "tool-call",
+    id: "",
+    name: "",
+    arguments: ""
+  };
+}
+function c() {
+  let r = /* @__PURE__ */ new Map(), a, n;
+  const o = (e, t) => {
+    const i = r.get(e);
+    if (i !== void 0 && i.type === t) return i;
+    const l = d(t);
+    return r.set(e, l), l;
+  }, s = () => [...r.entries()].sort(([e], [t]) => e - t).map(([, e]) => e);
+  return {
+    push(e) {
+      switch (e.type) {
+        case "block-start":
+          o(e.index, e.blockType);
+          return;
+        case "text-delta": {
+          const t = o(e.index, "text");
+          t.text += e.text;
+          return;
+        }
+        case "reasoning-delta": {
+          const t = o(e.index, "reasoning");
+          t.text += e.text;
+          return;
+        }
+        case "tool-call-delta": {
+          const t = o(e.index, "tool-call");
+          e.id !== "" && (t.id = e.id), e.name !== void 0 && e.name !== "" && (t.name = e.name), t.arguments += e.argumentsDelta;
+          return;
+        }
+        case "block-end":
+          r.set(e.index, { ...e.block });
+          return;
+        case "usage":
+          a = e.usage;
+          return;
+        case "finish":
+          n = e.reason;
+          return;
+      }
+    },
+    snapshot() {
+      return Object.freeze({
+        blocks: Object.freeze(s().map((e) => Object.freeze({ ...e }))),
+        usage: a === void 0 ? void 0 : Object.freeze({ ...a }),
+        finishReason: n,
+        done: n !== void 0
+      });
+    },
+    text() {
+      return s().reduce((e, t) => t.type === "text" ? e + t.text : e, "");
+    },
+    reasoning() {
+      return s().reduce((e, t) => t.type === "reasoning" ? e + t.text : e, "");
+    },
+    toolCalls() {
+      return s().filter((e) => e.type === "tool-call");
+    },
+    reset() {
+      r = /* @__PURE__ */ new Map(), a = void 0, n = void 0;
+    }
+  };
+}
+export {
+  c as createStreamAccumulator
+};

package/dist/src/stream/budget.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Counting what a conversation costs, and deciding what to drop when it stops fitting.
+ *
+ * A chat client that never does this works for a week and then stops working: every turn
+ * carries the whole history, so the request grows monotonically until the provider refuses
+ * it. The refusal arrives as a wall — the conversation someone was having simply stops.
+ *
+ * Two pieces, deliberately separate:
+ *
+ * - **{@link estimateTokens}** answers "how big is this text" without a tokenizer. It is an
+ *   estimate and named as one. A real tokenizer is a per-model dependency measured in
+ *   megabytes, and this is used to decide *when to act*, not to bill anyone.
+ * - **{@link planCompaction}** answers "what has to go" given sizes and a ceiling. It knows
+ *   nothing about messages, models, or summaries — it takes a list of sizes and returns how
+ *   many leading entries no longer fit. What replaces them is the caller's business.
+ *
+ * @module ranuts/stream
+ */
+import type { TokenUsage } from "./types.js";
+/**
+ * Estimates how many tokens a string costs.
+ *
+ * Deliberately not a tokenizer. Every model's is different, shipping one is megabytes, and
+ * the number is used to decide when to compact rather than to charge anyone. It is
+ * calibrated to be roughly right per script rather than exactly right for one model.
+ *
+ * @param text The text to measure.
+ * @returns An estimated token count, never below one for a non-empty string.
+ */
+export declare function estimateTokens(text: string): number;
+/**
+ * Adds two usage reports.
+ *
+ * Every field is optional and providers differ in which they send, so an absent field on
+ * either side is zero rather than a reason to drop the field: a running total that lost
+ * `outputTokens` the moment one response omitted it would be worse than no total.
+ *
+ * @param total The running total.
+ * @param next The report to add.
+ * @returns A new total.
+ */
+export declare function addUsage(total: TokenUsage | undefined, next: TokenUsage | undefined): TokenUsage;
+/** What a compaction has to fit under, and what it may not touch. */
+export interface CompactionLimits {
+    /** Token ceiling the next request must fit under, including everything the caller adds. */
+    limit: number;
+    /**
+     * How many trailing entries are never compacted.
+     *
+     * The recent turns are what the conversation is currently about; summarizing them is how
+     * a client starts answering the wrong question. Zero is legal and means the caller
+     * accepts that.
+     */
+    keepRecent: number;
+    /**
+     * Estimated size of whatever replaces the compacted entries.
+     *
+     * Required, not defaulted: a summary is not free, and a plan that assumed it was can
+     * return "this fits" for a request that does not.
+     */
+    summaryTokens: number;
+}
+/** What to do with a history that has grown. */
+export interface CompactionPlan {
+    /** How many leading entries to replace with one summary; zero means nothing to do. */
+    compact: number;
+    /** Estimated tokens the request will cost once the plan is applied. */
+    projected: number;
+    /**
+     * Whether {@link CompactionPlan.projected} is under the limit.
+     *
+     * False means the kept entries alone exceed it — a single message longer than the whole
+     * context window, most often. The caller has to decide, and there is nothing this
+     * function can silently do that would not lose the user's own words.
+     */
+    fits: boolean;
+}
+/**
+ * Decides how much of a history no longer fits.
+ *
+ * Leading entries only. A conversation is a sequence, and dropping from the middle leaves
+ * the model reading an exchange with a hole in it; dropping from the front is what a summary
+ * can stand in for.
+ *
+ * @param sizes Estimated tokens per entry, in conversation order.
+ * @param limits The ceiling, the protected tail, and the summary's own cost.
+ * @returns How many leading entries to compact, and whether the result fits.
+ */
+export declare function planCompaction(sizes: readonly number[], limits: CompactionLimits): CompactionPlan;

package/dist/src/stream/budget.js

@@ -0,0 +1,45 @@
+var k = 4, d = /[　-〿぀-ヿ㐀-䶿一-鿿豈-﫿＀-￯가-힯]/u;
+function f(t) {
+  if (t === "") return 0;
+  let n = 0, e = 0;
+  for (const o of t) d.test(o) ? n += 1 : e += 1;
+  return Math.max(1, n + Math.ceil(e / k));
+}
+function m(t, n) {
+  const e = (o, c) => o === void 0 && c === void 0 ? void 0 : (o ?? 0) + (c ?? 0);
+  return {
+    inputTokens: e(t?.inputTokens, n?.inputTokens),
+    outputTokens: e(t?.outputTokens, n?.outputTokens),
+    reasoningTokens: e(t?.reasoningTokens, n?.reasoningTokens),
+    cachedInputTokens: e(t?.cachedInputTokens, n?.cachedInputTokens),
+    totalTokens: e(t?.totalTokens, n?.totalTokens)
+  };
+}
+function l(t, n) {
+  const { limit: e, keepRecent: o, summaryTokens: c } = n, s = t.reduce((p, T) => p + T, 0);
+  if (s <= e) return {
+    compact: 0,
+    projected: s,
+    fits: !0
+  };
+  const i = Math.max(0, t.length - o);
+  let r = 0, u = 0;
+  for (; r < i && c + s - u > e; )
+    u += t[r] ?? 0, r += 1;
+  if (r === 0) return {
+    compact: 0,
+    projected: s,
+    fits: s <= e
+  };
+  const a = c + s - u;
+  return {
+    compact: r,
+    projected: a,
+    fits: a <= e
+  };
+}
+export {
+  m as addUsage,
+  f as estimateTokens,
+  l as planCompaction
+};

package/dist/src/stream/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * `ranuts/stream` — streaming model responses, without a vendor.
+ *
+ * Three layers, each usable alone:
+ *
+ * 1. {@link parseEventStream} turns bytes into Server-Sent Events. Transport only.
+ * 2. {@link StreamChunk} is the provider-neutral vocabulary one response streams in.
+ * 3. {@link createStreamAccumulator} folds those chunks into renderable blocks.
+ * 4. {@link estimateTokens} and {@link planCompaction} decide when a history stops fitting.
+ *
+ * Mapping a vendor's event onto {@link StreamChunk} stays with the caller — that mapping
+ * is the only vendor-specific part, and baking one provider's wire format in here would
+ * make the other two layers unusable for anyone else. {@link mapEventStream} is the seam.
+ *
+ * Runtime: browser and node. No DOM — a stream can be folded in a test or on a server.
+ *
+ * @module ranuts/stream
+ */
+export type { ContentBlock, ContentBlockType, FinishReason, ReasoningBlock, StreamChunk, TextBlock, TokenUsage, ToolCallBlock, } from "./types.js";
+export type { ByteSource, ServerSentEvent } from "./sse.js";
+export { mapEventStream, parseEventStream } from "./sse.js";
+export type { StreamAccumulator, StreamSnapshot } from "./accumulator.js";
+export { createStreamAccumulator } from "./accumulator.js";
+export type { CompactionLimits, CompactionPlan } from "./budget.js";
+export { addUsage, estimateTokens, planCompaction } from "./budget.js";

package/dist/src/stream/index.js

@@ -0,0 +1,11 @@
+import { mapEventStream as e, parseEventStream as m } from "./sse.js";
+import { createStreamAccumulator as a } from "./accumulator.js";
+import { addUsage as p, estimateTokens as i, planCompaction as n } from "./budget.js";
+export {
+  p as addUsage,
+  a as createStreamAccumulator,
+  i as estimateTokens,
+  e as mapEventStream,
+  m as parseEventStream,
+  n as planCompaction
+};

package/dist/src/stream/sse.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Server-Sent Events parsing, to the WHATWG event-stream rules.
+ *
+ * This is the transport half of `ranuts/stream` and knows nothing about models: it turns
+ * bytes into {@link ServerSentEvent} records. Mapping an event's `data` onto
+ * {@link StreamChunk} is the caller's job, because that mapping is vendor-specific while
+ * the framing is not.
+ *
+ * The parts worth not re-deriving: a chunk boundary can fall anywhere, including inside a
+ * multi-byte character and between the two halves of a `\r\n`; `data:` repeats join with
+ * `\n`; exactly one space after the colon is stripped; a line starting with `:` is a
+ * comment (which is how servers keep a connection warm); and a trailing block with no
+ * terminating blank line is still an event.
+ */
+import type { StreamChunk } from "./types.js";
+/** One parsed `text/event-stream` event. */
+export interface ServerSentEvent {
+    /** Joined `data:` payload; `\n` between repeats, no trailing newline. */
+    data: string;
+    /** `event:` field, when the server sent one. */
+    event?: string;
+    /** `id:` field, when the server sent one. */
+    id?: string;
+    /** `retry:` field in milliseconds, when the server sent a valid integer. */
+    retry?: number;
+}
+/** Anything `for await` can walk that yields byte chunks — a `fetch` body, or a fake. */
+export type ByteSource = AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>;
+/**
+ * Parses a byte stream as `text/event-stream`.
+ *
+ * Decoding is streaming, so a multi-byte character split across two network chunks is
+ * reassembled rather than replaced. A final block with no terminating blank line is still
+ * yielded, which is what a server that closes the connection mid-event produces.
+ *
+ * @param source Byte source, typically `response.body`.
+ * @returns Each event in arrival order.
+ */
+export declare function parseEventStream(source: ByteSource): AsyncGenerator<ServerSentEvent>;
+/**
+ * Maps SSE events onto {@link StreamChunk} values using a caller-supplied vendor mapping.
+ *
+ * The mapping returns an array because one wire event commonly carries several normalized
+ * chunks — a delta plus a usage report, or two concurrent tool calls — and returning an
+ * empty array is how a keep-alive or a sentinel such as `[DONE]` is dropped.
+ *
+ * @param source Byte source, typically `response.body`.
+ * @param map Vendor mapping from one event to zero or more chunks.
+ * @returns Each normalized chunk in arrival order.
+ */
+export declare function mapEventStream(source: ByteSource, map: (event: ServerSentEvent) => readonly StreamChunk[]): AsyncGenerator<StreamChunk>;

package/dist/src/stream/sse.js

@@ -0,0 +1,61 @@
+async function* f(r) {
+  if (typeof r[Symbol.asyncIterator] == "function") {
+    yield* r;
+    return;
+  }
+  const t = r.getReader();
+  try {
+    for (; ; ) {
+      const { done: e, value: i } = await t.read();
+      if (e) return;
+      i !== void 0 && (yield i);
+    }
+  } finally {
+    t.releaseLock();
+  }
+}
+function c(r) {
+  const t = [];
+  let e, i, l;
+  for (const n of r.split(`
+`)) {
+    if (n === "" || n.startsWith(":")) continue;
+    const d = n.indexOf(":"), s = d === -1 ? n : n.slice(0, d);
+    let o = d === -1 ? "" : n.slice(d + 1);
+    o.startsWith(" ") && (o = o.slice(1)), s === "data" ? t.push(o) : s === "event" ? e = o : s === "id" && !o.includes("\0") ? i = o : s === "retry" && /^\d+$/.test(o) && (l = Number(o));
+  }
+  if (t.length === 0 && e === void 0 && i === void 0 && l === void 0) return null;
+  const a = { data: t.join(`
+`) };
+  return e !== void 0 && (a.event = e), i !== void 0 && (a.id = i), l !== void 0 && (a.retry = l), a;
+}
+async function* u(r) {
+  const t = new TextDecoder();
+  let e = "", i = !1;
+  for await (const a of f(r)) {
+    e += t.decode(a, { stream: !0 }), e = e.replace(/\r\n?/g, `
+`), i || (e.startsWith("\uFEFF") && (e = e.slice(1)), i = !0);
+    let n = e.indexOf(`
+
+`);
+    for (; n !== -1; ) {
+      const d = e.slice(0, n);
+      e = e.slice(n + 2);
+      const s = c(d);
+      s !== null && (yield s), n = e.indexOf(`
+
+`);
+    }
+  }
+  e += t.decode();
+  const l = c(e.replace(/\r\n?/g, `
+`));
+  l !== null && (yield l);
+}
+async function* y(r, t) {
+  for await (const e of u(r)) yield* t(e);
+}
+export {
+  y as mapEventStream,
+  u as parseEventStream
+};

package/dist/src/stream/types.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Provider-neutral vocabulary for one streamed model response.
+ *
+ * Every mainstream chat completion API streams the same four things — assistant text,
+ * separately-billed reasoning text, tool calls, and a token count — but each names them
+ * differently and interleaves them differently. Normalizing to one union at the edge means
+ * a renderer, an accumulator, and a test fixture never learn a vendor's wire format.
+ *
+ * The union is the contract; the shape below is what makes it usable:
+ *
+ * - **`index` correlates interleaved deltas.** Reasoning and text can arrive interleaved,
+ *   and a response can open several tool calls at once. Consumers group by `index` rather
+ *   than assuming a delta belongs to whatever arrived last.
+ * - **`block-end` carries the assembled block.** A consumer that accumulated the deltas
+ *   itself can adopt or verify it; a consumer that only wants finished blocks can ignore
+ *   every delta.
+ * - **Tool arguments stay raw JSON text.** `argumentsDelta` is never parsed mid-stream:
+ *   half a JSON document is not a value, and pretending otherwise is where streaming tool
+ *   calls usually break.
+ * - **`finish` terminates.** `usage` arrives before it, and nothing follows it. A consumer
+ *   can treat `finish` as the point where its state is complete.
+ *
+ * @module ranuts/stream
+ */
+/** Discriminator for the content a block accumulates. */
+export type ContentBlockType = 'text' | 'reasoning' | 'tool-call';
+/** Assistant prose addressed to the user. */
+export interface TextBlock {
+    type: 'text';
+    text: string;
+}
+/**
+ * Model reasoning, when the provider exposes it. Kept separate from {@link TextBlock}
+ * because it is billed, displayed, and retained differently — a UI usually collapses it,
+ * and it is normally dropped from the history sent back on the next request.
+ */
+export interface ReasoningBlock {
+    type: 'reasoning';
+    text: string;
+}
+/** One tool invocation requested by the model. */
+export interface ToolCallBlock {
+    type: 'tool-call';
+    /** Provider-assigned call id, echoed back with the result. */
+    id: string;
+    /** Tool name; empty until the provider has sent it. */
+    name: string;
+    /** Raw JSON text of the arguments — deliberately unparsed. */
+    arguments: string;
+}
+/** One completed unit of assistant output. */
+export type ContentBlock = TextBlock | ReasoningBlock | ToolCallBlock;
+/**
+ * Why the response ended.
+ *
+ * `tool-calls` is not a failure: the model finished its turn by asking for tools, and the
+ * caller is expected to run them and continue. `aborted` means the consumer stopped the
+ * stream, which is why it is distinct from `error`.
+ */
+export type FinishReason = 'stop' | 'length' | 'tool-calls' | 'content-filter' | 'error' | 'aborted';
+/** Token counts reported for one response. Every field is optional: providers differ. */
+export interface TokenUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    /** Reasoning tokens, where the provider bills them separately from output. */
+    reasoningTokens?: number;
+    /** Input tokens served from a provider-side cache, where reported. */
+    cachedInputTokens?: number;
+    totalTokens?: number;
+}
+/**
+ * One normalized event from a streamed response.
+ *
+ * `block-start` is optional in practice — several providers begin a block with its first
+ * delta — so consumers must tolerate a delta for an index they have not seen.
+ * {@link createStreamAccumulator} does.
+ */
+export type StreamChunk = {
+    type: 'block-start';
+    index: number;
+    blockType: ContentBlockType;
+} | {
+    type: 'text-delta';
+    index: number;
+    text: string;
+} | {
+    type: 'reasoning-delta';
+    index: number;
+    text: string;
+} | {
+    type: 'tool-call-delta';
+    index: number;
+    id: string;
+    name?: string;
+    argumentsDelta: string;
+} | {
+    type: 'block-end';
+    index: number;
+    block: ContentBlock;
+} | {
+    type: 'usage';
+    usage: TokenUsage;
+} | {
+    type: 'finish';
+    reason: FinishReason;
+};

package/dist/src/sw/index.js

@@ -1 +1,52 @@
-var e=()=>globalThis,t=()=>new Response("Network error happened",{status:408,headers:{"Content-Type":"text/plain"}}),c=(e,t)=>"GET"===e.method&&200===t.status,a=(e,t,c,a)=>{const s=a.clone();return e.caches.open(t).then(e=>e.put(c.url,s)).catch(()=>{})},s=async(s,n)=>{const r=n.scope??e(),o=n.shouldCache??c;try{const e=await r.caches.match(s.url);if(e)return e;const t=await r.fetch(s);return o(s,t)&&a(r,n.cacheName,s,t),t}catch{return t()}},n=async(s,n)=>{const r=n.scope??e(),o=n.shouldCache??c;try{const e=await r.fetch(s);return o(s,e)&&a(r,n.cacheName,s,e),e}catch{return await r.caches.match(s.url).catch(()=>{})??t()}},r=async(t,c,a={})=>{const s=a.scope??e(),n=await s.caches.open(t);for(const e of c)try{if(await n.match(e))continue;const t=await s.fetch(e,{cache:"force-cache"});t.ok&&await n.put(e,t.clone())}catch{}},o=async(t,c={})=>{const a=c.scope??e(),s=(await a.caches.keys()).filter(e=>!t.includes(e));return await Promise.all(s.map(e=>a.caches.delete(e))),s},h=t=>{const c=t.scope??e(),a=e=>{const a=e.data;a&&a.type===t.type&&Array.isArray(a.urls)&&e.waitUntil(r(t.cacheName,a.urls,{scope:c}))};return c.addEventListener("message",a),()=>c.removeEventListener("message",a)};export{s as cacheFirst,o as dropCachesExcept,n as networkFirst,r as precache,h as servePrecache};
+var n = () => globalThis, h = () => new Response("Network error happened", {
+  status: 408,
+  headers: { "Content-Type": "text/plain" }
+}), l = (c, a) => c.method === "GET" && a.status === 200, p = (c, a, t, s) => {
+  const e = s.clone();
+  return c.caches.open(a).then((r) => r.put(t.url, e)).catch(() => {
+  });
+}, u = async (c, a) => {
+  const t = a.scope ?? n(), s = a.shouldCache ?? l;
+  try {
+    const e = await t.caches.open(a.cacheName).then((o) => o.match(c.url)).catch(() => {
+    });
+    if (e) return e;
+    const r = await t.fetch(c);
+    return s(c, r) && p(t, a.cacheName, c, r), r;
+  } catch {
+    return h();
+  }
+}, d = async (c, a) => {
+  const t = a.scope ?? n(), s = a.shouldCache ?? l;
+  try {
+    const e = await t.fetch(c);
+    return s(c, e) && p(t, a.cacheName, c, e), e;
+  } catch {
+    return await t.caches.open(a.cacheName).then((e) => e.match(c.url)).catch(() => {
+    }) ?? h();
+  }
+}, i = async (c, a, t = {}) => {
+  const s = t.scope ?? n(), e = await s.caches.open(c);
+  for (const r of a) try {
+    if (await e.match(r)) continue;
+    const o = await s.fetch(r, { cache: "force-cache" });
+    o.ok && await e.put(r, o.clone());
+  } catch {
+  }
+}, f = async (c, a = {}) => {
+  const t = a.scope ?? n(), s = (await t.caches.keys()).filter((e) => !c.includes(e));
+  return await Promise.all(s.map((e) => t.caches.delete(e))), s;
+}, m = (c) => {
+  const a = c.scope ?? n(), t = (s) => {
+    const e = s.data;
+    !e || e.type !== c.type || !Array.isArray(e.urls) || s.waitUntil(i(c.cacheName, e.urls, { scope: a }));
+  };
+  return a.addEventListener("message", t), () => a.removeEventListener("message", t);
+};
+export {
+  u as cacheFirst,
+  f as dropCachesExcept,
+  d as networkFirst,
+  i as precache,
+  m as servePrecache
+};

package/dist/src/utils/async.js

@@ -0,0 +1,49 @@
+var c = () => {
+  let e, r;
+  return {
+    promise: new Promise((o, i) => {
+      e = o, r = i;
+    }),
+    resolve: e,
+    reject: r
+  };
+}, s = class extends Error {
+  constructor(e) {
+    super(e), this.name = "TimeoutError";
+  }
+}, T = (e, r, o = {}) => {
+  const { message: i = `operation timed out after ${r}ms`, onTimeout: m } = o;
+  return new Promise((u, a) => {
+    const t = setTimeout(() => {
+      m?.(), a(new s(i));
+    }, r);
+    e.then((n) => {
+      clearTimeout(t), u(n);
+    }, (n) => {
+      clearTimeout(t), a(n);
+    });
+  });
+}, l = (e, r, o, i) => new Promise((m, u) => {
+  const a = setTimeout(() => {
+    i?.(), m(o);
+  }, r);
+  e.then((t) => {
+    clearTimeout(a), m(t);
+  }, (t) => {
+    clearTimeout(a), u(t);
+  });
+}), w = (e) => new Promise((r) => setTimeout(r, e)), d = () => {
+  let e = 0;
+  return {
+    start: () => ++e,
+    isCurrent: (r) => r === e
+  };
+};
+export {
+  s as TimeoutError,
+  d as createRaceGuard,
+  c as deferred,
+  w as delay,
+  T as withTimeout,
+  l as withTimeoutFallback
+};