@tanstack-ai-browser/prompt-api 0.2.0 → 0.2.2

package/dist/adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"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"}

package/dist/adapter.js

@@ -250,7 +250,8 @@ export class PromptApiTextAdapter extends BaseTextAdapter {
             const completionTokens = Math.max(0, written - markers);
             return {
                 ...buildBaseUsage({ promptTokens, completionTokens, totalTokens: promptTokens + completionTokens }),
-                ...(goesOn && { promptTokensDetails: { cachedTokens: held } })
+                // A new session read all of it in this step: none was cached.
+                promptTokensDetails: { cachedTokens: goesOn ? held : 0 }
             };
         }
         catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack-ai-browser/prompt-api",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "TanStack AI adapter for the browser's built-in language model (the Prompt API: Gemini Nano in Chrome, Phi-4-mini in Edge)",
   "license": "MIT",
   "author": "daveycodez",

package/src/adapter.test.ts

@@ -531,7 +531,7 @@ test("a reply reports its tokens: what the session held, and the prompt and the
   // Less an empty message's count: the turn markers a session counts around any message.
   const reply = measured("Hello there") - measured("")
   // A new session read what it holds in this step: nothing cached.
-  assert.deepEqual(await step(first), { promptTokens: prompt, completionTokens: reply, totalTokens: prompt + reply })
+  assert.deepEqual(await step(first), { promptTokens: prompt, completionTokens: reply, totalTokens: prompt + reply, promptTokensDetails: { cachedTokens: 0 } })
 
   // The thread's kept session doesn't read what it holds again: only the new message.
   Object.assign(control.sessions[0], { contextUsage: 300 })

package/src/adapter.ts

@@ -348,7 +348,8 @@ export class PromptApiTextAdapter extends BaseTextAdapter<
       const completionTokens = Math.max(0, written - markers)
       return {
         ...buildBaseUsage({ promptTokens, completionTokens, totalTokens: promptTokens + completionTokens }),
-        ...(goesOn && { promptTokensDetails: { cachedTokens: held } })
+        // A new session read all of it in this step: none was cached.
+        promptTokensDetails: { cachedTokens: goesOn ? held : 0 }
       }
     } catch {
       return undefined

package/dist/limit.d.ts

@@ -1,119 +0,0 @@
-/**
- * Output token limits, emulated. The Prompt API has no output cap (a prompt
- * takes only `signal`, `responseConstraint` and
- * `omitResponseConstraintInput`), so the adapter holds the reply to a limit
- * itself, for `maxCompletionTokens`.
- *
- * Chrome runs one operation at a time per model, so the model can't count
- * text while it writes it. The limit is estimated during the generation
- * (from a ratio calibrated on the request before it starts), the generation
- * is stopped by an internal abort a little past the limit, and the text is
- * measured and trimmed exactly once the model is idle again.
- */
-import type { LanguageModelSession } from "./types.js";
-/** `maxCompletionTokens`, validated like the other adapters validate it. */
-export declare function outputTokenLimit(options: {
-    maxCompletionTokens?: number;
-} | undefined): number | undefined;
-/** The cap's report in `usage.providerUsageDetails`, when a cap was set. */
-export type PromptApiOutputLimitUsage = {
-    outputTokenLimit: number;
-    outputTokenMeasurement: "estimate-then-context-usage";
-    outputTokenLimitEnforcement: "best-effort";
-    outputTokenLimitReached: boolean;
-};
-export declare const outputLimitUsage: (limit: number | undefined, reached: boolean) => PromptApiOutputLimitUsage | undefined;
-/** A message's text, without its images or audio. */
-type TextBearing = {
-    content: string | ReadonlyArray<{
-        type: string;
-        value?: unknown;
-    }>;
-};
-/** The text of a prompt input (or of messages), without images or audio. */
-export declare function textOfInput(input: string | ReadonlyArray<TextBearing>): string;
-/**
- * Live emission stops once the estimate passes this share of the limit, or
- * once the text passes the limit in UTF-8 bytes. Text sent live can't be
- * taken back, so it must stay within the limit whatever the estimate says:
- * no token is shorter than a byte, so text of at most `limit` bytes holds at
- * most `limit` tokens, however much denser the reply is than the calibration
- * text. The share keeps longer limits from streaming up to the last token
- * live, where a low estimate would leave nothing to trim.
- */
-export declare const LIVE_FRACTION = 0.75;
-/**
- * Generation is stopped once the estimate passes STOP_FACTOR × limit +
- * STOP_SLACK tokens: past the limit, so the exact trim afterwards finds the
- * limit's worth of text unless the reply holds a fifth fewer tokens per byte
- * than the calibration text (the estimate is then high by more than 1.25×).
- * The slack covers short limits, where a chunk or two of noise is a large
- * share; 8 tokens is about 0.15 s of Gemini Nano's decoding.
- */
-export declare const STOP_FACTOR = 1.25;
-export declare const STOP_SLACK = 8;
-/**
- * The text a limit's tokens-per-byte ratio is calibrated on: the request's
- * own text first, then earlier messages (most recent first) while it's
- * under 64 bytes, then a fixed reference sentence if it still is.
- */
-export declare function calibrationSample(texts: ReadonlyArray<string>): string;
-/** What a limiter kept, once the generation has stopped. */
-export type LimitResult = {
-    /** The text within the limit: everything sent live, and `held`. */
-    text: string;
-    /** The part of `text` held back during generation, to send now. */
-    held: string;
-    /** `text`'s tokens, measured. */
-    tokens: number;
-    /**
-     * The limit ended the text: the exact count reached it, or the limiter
-     * stopped the generation (even if the estimate ran high and the count
-     * fell short: the reply was still cut for the limit).
-     */
-    reached: boolean;
-};
-/** Holds streamed text to a token limit without calling the model mid-stream. */
-export type TokenLimiter = {
-    /** All the text received so far. */
-    readonly text: string;
-    /** The estimate passed the stop line: stop the generation. */
-    readonly stopped: boolean;
-    /**
-     * Takes the next piece of text and returns what can be sent live now
-     * (all of it, or nothing once text is held back). Never calls the model.
-     */
-    push(delta: string): string;
-    /**
-     * Once the generation has stopped (the model is idle, so measuring is
-     * instant): the exact count, trimmed to the longest prefix within the
-     * limit, never shorter than what was already sent live.
-     */
-    finish(): Promise<LimitResult>;
-};
-/**
- * A limiter for one generation. Chrome runs one operation at a time per
- * model: `measureContextUsage` (on any session or clone) and `clone()` wait
- * until a generation in progress finishes, so nothing can be measured while
- * the model writes. Instead, before generating, `sample` (the request's
- * text) is measured to calibrate a bytes-per-token ratio; while generating,
- * tokens are estimated from UTF-8 bytes with it; once the generation has
- * stopped, `finish()` measures exactly and trims.
- *
- * Bytes per token, not characters: it varies much less across scripts (a
- * CJK character is 3 bytes and about a token; English runs about 4 bytes a
- * token), and no token is shorter than a byte, so the ratio's floor of 1 is
- * the hard bound tokens ≤ bytes.
- */
-export declare function tokenLimiter(session: LanguageModelSession, limit: number, sample: string, signal: AbortSignal | undefined): Promise<TokenLimiter>;
-/**
- * An abort signal for one generation that follows the caller's (with its
- * reason) and that `stop()` aborts on its own, never touching the caller's.
- */
-export declare function internalAbort(signal: AbortSignal | undefined, reason: string): {
-    signal: AbortSignal;
-    stop: () => void;
-    dispose: () => void | undefined;
-};
-export {};
-//# sourceMappingURL=limit.d.ts.map

package/dist/limit.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"limit.d.ts","sourceRoot":"","sources":["../src/limit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AAEtD,4EAA4E;AAC5E,wBAAgB,gBAAgB,CAAC,OAAO,EAAE;IAAE,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,sBAMrF;AAED,4EAA4E;AAC5E,MAAM,MAAM,yBAAyB,GAAG;IACtC,gBAAgB,EAAE,MAAM,CAAA;IACxB,sBAAsB,EAAE,6BAA6B,CAAA;IACrD,2BAA2B,EAAE,aAAa,CAAA;IAC1C,uBAAuB,EAAE,OAAO,CAAA;CACjC,CAAA;AAED,eAAO,MAAM,gBAAgB,GAC3B,OAAO,MAAM,GAAG,SAAS,EACzB,SAAS,OAAO,KACf,yBAAyB,GAAG,SAQxB,CAAA;AAiBP,qDAAqD;AACrD,KAAK,WAAW,GAAG;IAAE,OAAO,EAAE,MAAM,GAAG,aAAa,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC,CAAA;CAAE,CAAA;AAEzF,4EAA4E;AAC5E,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,CAAC,WAAW,CAAC,GAAG,MAAM,CAY9E;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,OAAO,CAAA;AACjC;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,OAAO,CAAA;AAC/B,eAAO,MAAM,UAAU,IAAI,CAAA;AAY3B;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,MAAM,CAatE;AAED,4DAA4D;AAC5D,MAAM,MAAM,WAAW,GAAG;IACxB,mEAAmE;IACnE,IAAI,EAAE,MAAM,CAAA;IACZ,mEAAmE;IACnE,IAAI,EAAE,MAAM,CAAA;IACZ,iCAAiC;IACjC,MAAM,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,iFAAiF;AACjF,MAAM,MAAM,YAAY,GAAG;IACzB,oCAAoC;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,8DAA8D;IAC9D,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB;;;OAGG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;IAC3B;;;;OAIG;IACH,MAAM,IAAI,OAAO,CAAC,WAAW,CAAC,CAAA;CAC/B,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,YAAY,CAChC,OAAO,EAAE,oBAAoB,EAC7B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,OAAO,CAAC,YAAY,CAAC,CAqEvB;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,EAAE,MAAM,EAAE,MAAM;;;;EAU5E"}

package/dist/limit.js

@@ -1,203 +0,0 @@
-/** `maxCompletionTokens`, validated like the other adapters validate it. */
-export function outputTokenLimit(options) {
-    const limit = options?.maxCompletionTokens;
-    if (limit !== undefined && (!Number.isSafeInteger(limit) || limit < 0)) {
-        throw new RangeError("maxCompletionTokens must be a nonnegative safe integer.");
-    }
-    return limit;
-}
-export const outputLimitUsage = (limit, reached) => limit === undefined
-    ? undefined
-    : {
-        outputTokenLimit: limit,
-        outputTokenMeasurement: "estimate-then-context-usage",
-        outputTokenLimitEnforcement: "best-effort",
-        outputTokenLimitReached: reached
-    };
-/** UTF-8 bytes of a string: an upper bound on its tokens. */
-function utf8Bytes(text) {
-    let bytes = 0;
-    for (let i = 0; i < text.length; i++) {
-        const code = text.charCodeAt(i);
-        if (code < 0x80)
-            bytes += 1;
-        else if (code < 0x800)
-            bytes += 2;
-        else if (code >= 0xd800 && code < 0xdc00 && i + 1 < text.length) {
-            bytes += 4;
-            i++;
-        }
-        else
-            bytes += 3;
-    }
-    return bytes;
-}
-/** The text of a prompt input (or of messages), without images or audio. */
-export function textOfInput(input) {
-    if (typeof input === "string")
-        return input;
-    return input
-        .map((message) => typeof message.content === "string"
-        ? message.content
-        : message.content
-            .map((part) => (part.type === "text" && typeof part.value === "string" ? part.value : ""))
-            .join(""))
-        .filter(Boolean)
-        .join("\n");
-}
-/**
- * Live emission stops once the estimate passes this share of the limit, or
- * once the text passes the limit in UTF-8 bytes. Text sent live can't be
- * taken back, so it must stay within the limit whatever the estimate says:
- * no token is shorter than a byte, so text of at most `limit` bytes holds at
- * most `limit` tokens, however much denser the reply is than the calibration
- * text. The share keeps longer limits from streaming up to the last token
- * live, where a low estimate would leave nothing to trim.
- */
-export const LIVE_FRACTION = 0.75;
-/**
- * Generation is stopped once the estimate passes STOP_FACTOR × limit +
- * STOP_SLACK tokens: past the limit, so the exact trim afterwards finds the
- * limit's worth of text unless the reply holds a fifth fewer tokens per byte
- * than the calibration text (the estimate is then high by more than 1.25×).
- * The slack covers short limits, where a chunk or two of noise is a large
- * share; 8 tokens is about 0.15 s of Gemini Nano's decoding.
- */
-export const STOP_FACTOR = 1.25;
-export const STOP_SLACK = 8;
-/** Calibration text shorter than this (UTF-8 bytes) is too noisy alone. */
-const MIN_SAMPLE_BYTES = 64;
-/** Calibration measures at most this many characters of text. */
-const MAX_SAMPLE_CHARS = 4000;
-/**
- * Calibrates when the conversation has almost no text ("hi"): measured with
- * the model's own tokenizer like any other text, never a fixed ratio.
- */
-const REFERENCE_TEXT = "The quick brown fox jumps over the lazy dog, then rests in the warm afternoon sun while the farmer counts his sheep.";
-/**
- * The text a limit's tokens-per-byte ratio is calibrated on: the request's
- * own text first, then earlier messages (most recent first) while it's
- * under 64 bytes, then a fixed reference sentence if it still is.
- */
-export function calibrationSample(texts) {
-    let sample = "";
-    for (const text of texts) {
-        if (!text)
-            continue;
-        if (sample && utf8Bytes(sample) >= MIN_SAMPLE_BYTES)
-            break;
-        sample = sample ? `${sample}\n${text}` : text;
-    }
-    if (utf8Bytes(sample) < MIN_SAMPLE_BYTES) {
-        sample = sample ? `${sample}\n${REFERENCE_TEXT}` : REFERENCE_TEXT;
-    }
-    if (sample.length <= MAX_SAMPLE_CHARS)
-        return sample;
-    const end = sample.charCodeAt(MAX_SAMPLE_CHARS - 1);
-    return sample.slice(0, end >= 0xd800 && end < 0xdc00 ? MAX_SAMPLE_CHARS - 1 : MAX_SAMPLE_CHARS);
-}
-/**
- * A limiter for one generation. Chrome runs one operation at a time per
- * model: `measureContextUsage` (on any session or clone) and `clone()` wait
- * until a generation in progress finishes, so nothing can be measured while
- * the model writes. Instead, before generating, `sample` (the request's
- * text) is measured to calibrate a bytes-per-token ratio; while generating,
- * tokens are estimated from UTF-8 bytes with it; once the generation has
- * stopped, `finish()` measures exactly and trims.
- *
- * Bytes per token, not characters: it varies much less across scripts (a
- * CJK character is 3 bytes and about a token; English runs about 4 bytes a
- * token), and no token is shorter than a byte, so the ratio's floor of 1 is
- * the hard bound tokens ≤ bytes.
- */
-export async function tokenLimiter(session, limit, sample, signal) {
-    const options = signal ? [{ signal }] : [];
-    let overhead;
-    const measure = async (text) => {
-        signal?.throwIfAborted();
-        if (!text)
-            return 0;
-        overhead ??= await session.measureContextUsage("", ...options);
-        return Math.max(0, (await session.measureContextUsage(text, ...options)) - overhead);
-    };
-    const sampleTokens = limit > 0 ? await measure(sample) : 0;
-    const bytesPerToken = Math.max(1, utf8Bytes(sample) / Math.max(1, sampleTokens));
-    const liveLine = LIVE_FRACTION * limit;
-    const stopLine = STOP_FACTOR * limit + STOP_SLACK;
-    let text = "";
-    let emitted = "";
-    let holding = false;
-    let bytes = 0;
-    let stopped = limit === 0;
-    const estimate = () => bytes / bytesPerToken;
-    const check = () => {
-        if (estimate() >= stopLine)
-            stopped = true;
-    };
-    return {
-        get text() { return text; },
-        get stopped() { return stopped; },
-        push(delta) {
-            if (!delta)
-                return "";
-            text += delta;
-            bytes += utf8Bytes(delta);
-            check();
-            if (!holding && estimate() <= liveLine && bytes <= limit) {
-                emitted += delta;
-                return delta;
-            }
-            holding = true;
-            return "";
-        },
-        async finish() {
-            const tokens = await measure(text);
-            if (tokens <= limit) {
-                return { text, held: text.slice(emitted.length), tokens, reached: stopped || tokens >= limit };
-            }
-            // Over the limit: keep the longest prefix within it, searching by code
-            // point from what was sent live. Token counts need not be monotonic in
-            // the prefix, so the chosen prefix is verified afterwards.
-            const points = Array.from(text);
-            const start = Array.from(emitted).length;
-            let low = start;
-            let high = points.length - 1;
-            let accepted = emitted;
-            while (low <= high) {
-                const middle = Math.floor((low + high) / 2);
-                const prefix = points.slice(0, middle).join("");
-                if ((await measure(prefix)) <= limit) {
-                    accepted = prefix;
-                    low = middle + 1;
-                }
-                else
-                    high = middle - 1;
-            }
-            let acceptedPoints = Array.from(accepted);
-            let count = await measure(accepted);
-            while (count > limit && acceptedPoints.length > start) {
-                acceptedPoints = acceptedPoints.slice(0, -1);
-                accepted = acceptedPoints.join("");
-                count = await measure(accepted);
-            }
-            return { text: accepted, held: accepted.slice(emitted.length), tokens: count, reached: true };
-        }
-    };
-}
-/**
- * An abort signal for one generation that follows the caller's (with its
- * reason) and that `stop()` aborts on its own, never touching the caller's.
- */
-export function internalAbort(signal, reason) {
-    const internal = new AbortController();
-    const cancel = () => internal.abort(signal?.reason);
-    if (signal?.aborted)
-        cancel();
-    else
-        signal?.addEventListener("abort", cancel, { once: true });
-    return {
-        signal: internal.signal,
-        stop: () => internal.abort(new DOMException(reason, "AbortError")),
-        dispose: () => signal?.removeEventListener("abort", cancel)
-    };
-}

package/dist/reasoning.d.ts

@@ -1,42 +0,0 @@
-import type { ModelMessage, ReasoningRequest } from "@tanstack/ai";
-import type { LanguageModelInput, LanguageModelMessage, LanguageModelSession } from "./types.js";
-export type PromptApiReasoning = {
-    levels: "off" | "high";
-    budget: true;
-};
-export type PromptApiReasoningUsage = {
-    reasoningEmulated: true;
-    reasoningTokenMeasurement: "context-usage";
-    reasoningBudgetEnforcement: "best-effort";
-    thinkingTokens: number;
-    thinkingBudgetTokens?: number;
-    thinkingBudgetExhausted: boolean;
-    reasoningMs: number;
-};
-export type DraftReasoningResult = {
-    notes: string;
-    usage: PromptApiReasoningUsage;
-    capReached: boolean;
-};
-export declare function promptReasoningOptions(request: ReasoningRequest | undefined): {
-    enabled: boolean;
-    budget: number | undefined;
-};
-/**
- * The draft's instruction, quoting the user's latest message: after a tool
- * result, the newest user message is this instruction itself, and small
- * models took it for the message to reply to.
- */
-export declare function draftInstruction(messages: ReadonlyArray<ModelMessage>): LanguageModelMessage;
-export declare function withWorkingNotes(input: LanguageModelInput, notes: string): LanguageModelInput;
-/**
- * Two-pass adapter emulation, not hidden native model reasoning or native
- * token control. The draft stops at the thinking `budget` and at `cap`, the
- * output tokens left for the whole reply (`maxCompletionTokens`, which counts
- * the draft too), whichever comes first; `capReached` says the cap stopped it.
- * Under a limit, the draft is held to it as `tokenLimiter` holds any reply:
- * estimated while it streams, stopped a little past the limit, then measured
- * and trimmed exactly (the rest of the notes streams once the draft stops).
- */
-export declare function draftReasoning(session: LanguageModelSession, input: LanguageModelInput, conversation: ReadonlyArray<ModelMessage>, signal: AbortSignal | undefined, budget?: number, cap?: number): AsyncGenerator<string, DraftReasoningResult>;
-//# sourceMappingURL=reasoning.d.ts.map

package/dist/reasoning.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reasoning.d.ts","sourceRoot":"","sources":["../src/reasoning.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAIlE,OAAO,KAAK,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AAEhG,MAAM,MAAM,kBAAkB,GAAG;IAAE,MAAM,EAAE,KAAK,GAAG,MAAM,CAAC;IAAC,MAAM,EAAE,IAAI,CAAA;CAAE,CAAA;AACzE,MAAM,MAAM,uBAAuB,GAAG;IACpC,iBAAiB,EAAE,IAAI,CAAA;IACvB,yBAAyB,EAAE,eAAe,CAAA;IAC1C,0BAA0B,EAAE,aAAa,CAAA;IACzC,cAAc,EAAE,MAAM,CAAA;IACtB,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B,uBAAuB,EAAE,OAAO,CAAA;IAChC,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AACD,MAAM,MAAM,oBAAoB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,uBAAuB,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAE,CAAA;AAEzG,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,gBAAgB,GAAG,SAAS;;;EAK3E;AAKD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,aAAa,CAAC,YAAY,CAAC,GAAG,oBAAoB,CAQ5F;AACD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,kBAAkB,EAAE,KAAK,EAAE,MAAM,GAAG,kBAAkB,CAI7F;AAED;;;;;;;;GAQG;AACH,wBAAuB,cAAc,CAAC,OAAO,EAAE,oBAAoB,EAAE,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,aAAa,CAAC,YAAY,CAAC,EAAE,MAAM,EAAE,WAAW,GAAG,SAAS,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,cAAc,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAkDvP"}

package/dist/reasoning.js

@@ -1,113 +0,0 @@
-import { calibrationSample, internalAbort, smallest, textOfInput, tokenLimiter } from "./limit.js";
-import { contentText } from "./messages.js";
-export function promptReasoningOptions(request) {
-    const budget = request?.budgetTokens;
-    if (budget !== undefined && (!Number.isSafeInteger(budget) || budget < 0))
-        throw new RangeError("reasoning.budgetTokens must be a nonnegative safe integer.");
-    if (request?.level !== undefined && request.level !== "off" && request.level !== "high")
-        throw new RangeError("Prompt API emulated reasoning supports off or high.");
-    return { enabled: request?.level === "high", budget };
-}
-/** The longest quote of the user's message the draft instruction carries. */
-const QUOTE_CHARS = 500;
-/**
- * The draft's instruction, quoting the user's latest message: after a tool
- * result, the newest user message is this instruction itself, and small
- * models took it for the message to reply to.
- */
-export function draftInstruction(messages) {
-    const latest = [...messages].reverse().find((m) => m.role === "user");
-    const text = latest ? contentText(latest.content).trim().replace(/\s+/g, " ") : "";
-    const quote = text.length > QUOTE_CHARS ? `${text.slice(0, QUOTE_CHARS - 1)}…` : text;
-    return {
-        role: "user",
-        content: `Now write notes for yourself before replying to the user's latest message${quote ? `, "${quote}"` : ""}: what's needed, what you already have, and what to do next. Don't call tools or write the reply yet.`
-    };
-}
-export function withWorkingNotes(input, notes) {
-    if (!notes)
-        return input;
-    const messages = typeof input === "string" ? [{ role: "user", content: input }] : input;
-    return [...messages, { role: "user", content: `Working notes to verify against the conversation:\n${notes}\nNow produce the final response or required tool call.` }];
-}
-/**
- * Two-pass adapter emulation, not hidden native model reasoning or native
- * token control. The draft stops at the thinking `budget` and at `cap`, the
- * output tokens left for the whole reply (`maxCompletionTokens`, which counts
- * the draft too), whichever comes first; `capReached` says the cap stopped it.
- * Under a limit, the draft is held to it as `tokenLimiter` holds any reply:
- * estimated while it streams, stopped a little past the limit, then measured
- * and trimmed exactly (the rest of the notes streams once the draft stops).
- */
-export async function* draftReasoning(session, input, conversation, signal, budget, cap) {
-    signal?.throwIfAborted();
-    if (budget !== undefined && (!Number.isSafeInteger(budget) || budget < 0))
-        throw new RangeError("reasoning.budgetTokens must be a nonnegative safe integer.");
-    const began = performance.now();
-    const limit = smallest(budget, cap);
-    const usage = (tokens, exhausted) => ({ reasoningEmulated: true, reasoningTokenMeasurement: "context-usage", reasoningBudgetEnforcement: "best-effort", thinkingTokens: tokens, ...(budget !== undefined && { thinkingBudgetTokens: budget }), thinkingBudgetExhausted: exhausted, reasoningMs: performance.now() - began });
-    if (limit === 0)
-        return { notes: "", usage: usage(0, budget === 0), capReached: cap === 0 };
-    let draft;
-    let limiter;
-    const stopper = internalAbort(signal, "Emulated reasoning budget reached");
-    try {
-        draft = await session.clone({ signal });
-        const messages = typeof input === "string" ? [{ role: "user", content: input }] : input;
-        const prompt = [...messages, draftInstruction(conversation)];
-        // Calibrated while the model is idle; nothing is measured mid-draft.
-        if (limit !== undefined)
-            limiter = await tokenLimiter(session, limit, calibrationSample([textOfInput(prompt)]), signal);
-        const stream = draft.promptStreaming(prompt, { signal: stopper.signal });
-        let notes = "";
-        try {
-            for await (const piece of stream) {
-                signal?.throwIfAborted();
-                const parts = Array.isArray(piece) ? piece : [piece];
-                const delta = parts.map(part => typeof part === "string" ? part : part.type === "text" ? String(part.value) : "").join("");
-                if (!delta)
-                    continue;
-                if (!limiter) {
-                    notes += delta;
-                    yield delta;
-                    continue;
-                }
-                const live = limiter.push(delta);
-                if (limiter.stopped)
-                    stopper.stop();
-                if (live)
-                    yield live;
-                if (limiter.stopped)
-                    break;
-            }
-        }
-        catch (error) {
-            signal?.throwIfAborted();
-            if (!limiter?.stopped)
-                throw error;
-        }
-        signal?.throwIfAborted();
-        if (!limiter)
-            return { notes, usage: usage(await notesTokens(session, notes, signal), false), capReached: false };
-        // The draft has stopped: the model is idle, so the exact count is instant.
-        const kept = await limiter.finish();
-        if (kept.held)
-            yield kept.held;
-        return { notes: kept.text, usage: usage(kept.tokens, kept.reached && limit === budget), capReached: kept.reached && limit === cap };
-    }
-    finally {
-        stopper.dispose();
-        // Stops a draft left unread.
-        if (!stopper.signal.aborted)
-            stopper.stop();
-        draft?.destroy();
-    }
-}
-/** Tokens of finished notes, less the empty message's overhead. */
-async function notesTokens(session, notes, signal) {
-    if (!notes)
-        return 0;
-    const options = signal ? [{ signal }] : [];
-    const overhead = await session.measureContextUsage("", ...options);
-    return Math.max(0, (await session.measureContextUsage(notes, ...options)) - overhead);
-}

package/dist/sessions.d.ts

@@ -1,48 +0,0 @@
-import type { PromptMessage } from "./messages.js";
-import type { LanguageModelCreateOptions, LanguageModelSession } from "./types.js";
-/** A session lent to one model call. */
-export type Lease = {
-    session: LanguageModelSession;
-    /** Tokens the session had already read and didn't read again. */
-    cachedTokens: number;
-    /** Time spent creating the session (reading the conversation), in ms. */
-    createMs: number;
-    /** Why the thread's kept session couldn't be used, if it had one. */
-    miss?: string;
-    /** Whether this call reused a previously prepared input prefix. */
-    reused: boolean;
-    /** Whether the browser dropped old turns to make room since the lease began. */
-    overflowed: () => boolean;
-    /** Gives the session back, having read `history` (after the system prompt). */
-    release: (history: Array<PromptMessage>) => void;
-    /** Frees this session; for an isolated call, only its working clone is freed. */
-    discard: () => void;
-};
-/**
- * A session for a conversation that has read `system` and `prior`: the
- * thread's own if it has read a start of them (the rest is appended), else
- * a new one. `media` caches the images and audio loaded for the call.
- */
-type SessionOptions = {
-    threadId: string | undefined;
-    system: string;
-    prior: Array<PromptMessage>;
-    options: LanguageModelCreateOptions;
-    signal: AbortSignal | undefined;
-    media?: Map<string, Promise<Blob>>;
-    /** Generate on a disposable clone of a cached, unmodified input-prefix session. */
-    isolated?: boolean;
-    /** Disable managed cross-request reuse and retention for this lease only. */
-    retain?: boolean;
-    /** The browser's download of its model, 0 to 1, if a new session starts it. */
-    onDownloadProgress?: (progress: number) => void;
-};
-export declare function leaseSession(options: SessionOptions): Promise<Lease>;
-/**
- * Frees every session kept, as when the page no longer needs the model.
- * Sessions a call holds, or is still creating, finish that call and are
- * freed when it ends instead of going back in the cache.
- */
-export declare function destroyPromptApiSessions(): void;
-export {};
-//# sourceMappingURL=sessions.d.ts.map

package/dist/sessions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sessions.d.ts","sourceRoot":"","sources":["../src/sessions.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAClD,OAAO,KAAK,EACV,0BAA0B,EAC1B,oBAAoB,EACrB,MAAM,YAAY,CAAA;AAwBnB,wCAAwC;AACxC,MAAM,MAAM,KAAK,GAAG;IAClB,OAAO,EAAE,oBAAoB,CAAA;IAC7B,iEAAiE;IACjE,YAAY,EAAE,MAAM,CAAA;IACpB,yEAAyE;IACzE,QAAQ,EAAE,MAAM,CAAA;IAChB,qEAAqE;IACrE,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,mEAAmE;IACnE,MAAM,EAAE,OAAO,CAAA;IACf,gFAAgF;IAChF,UAAU,EAAE,MAAM,OAAO,CAAA;IACzB,+EAA+E;IAC/E,OAAO,EAAE,CAAC,OAAO,EAAE,KAAK,CAAC,aAAa,CAAC,KAAK,IAAI,CAAA;IAChD,iFAAiF;IACjF,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB,CAAA;AAED;;;;GAIG;AACH,KAAK,cAAc,GAAG;IACpB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAA;IAC5B,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,KAAK,CAAC,aAAa,CAAC,CAAA;IAC3B,OAAO,EAAE,0BAA0B,CAAA;IACnC,MAAM,EAAE,WAAW,GAAG,SAAS,CAAA;IAC/B,KAAK,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,mFAAmF;IACnF,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,6EAA6E;IAC7E,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,+EAA+E;IAC/E,kBAAkB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;CAChD,CAAA;AA6BD,wBAAsB,YAAY,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,KAAK,CAAC,CA8D1E;AA4KD;;;;GAIG;AACH,wBAAgB,wBAAwB,SAQvC"}

package/dist/sessions.js

@@ -1,275 +0,0 @@
-/**
- * Sessions by conversation. A Prompt API session holds the conversation
- * it has read (the model's cache), so each thread keeps its own: when the
- * next request extends what the session has read (a follow-up, or the step
- * after a tool call), only the new messages are read. Anything else (an
- * edited or regenerated message, another system prompt) starts a new
- * session from the whole conversation.
- */
-import { createLanguageModel } from "./model.js";
-import { keyOf, toLanguageModelMessages } from "./messages.js";
-/** Sessions kept at once, most recently used first; older ones are freed. */
-const MAX_SESSIONS = 4;
-const entries = new Map();
-const preparing = new Map();
-/** Counts unloads: a session created across one isn't cached. */
-let generation = 0;
-const startsWith = (list, start) => start.length <= list.length && start.every((key, i) => list[i] === key);
-/** Serialize base preparation only; independent clones generate concurrently. */
-async function lockPreparation(key, signal) {
-    const previous = preparing.get(key) ?? Promise.resolve();
-    let unlock = () => undefined;
-    const done = new Promise(resolve => { unlock = resolve; });
-    const queued = previous.then(() => done);
-    preparing.set(key, queued);
-    void queued.then(() => { if (preparing.get(key) === queued)
-        preparing.delete(key); });
-    try {
-        await new Promise((resolve, reject) => {
-            const cancel = () => reject(signal?.reason);
-            signal?.addEventListener("abort", cancel, { once: true });
-            void previous.then(() => {
-                signal?.removeEventListener("abort", cancel);
-                if (signal?.aborted)
-                    reject(signal.reason);
-                else
-                    resolve();
-            });
-        });
-        return unlock;
-    }
-    catch (error) {
-        // An aborted waiter releases its place without letting later callers pass
-        // the earlier preparation that is still in flight.
-        unlock();
-        throw error;
-    }
-}
-export async function leaseSession(options) {
-    options.signal?.throwIfAborted();
-    const { threadId, isolated, system, prior } = options;
-    const setup = JSON.stringify({ system, options: options.options });
-    // Separate namespaces prevent structured finalization from replacing a chat/tool
-    // session. Stateless calls can share an identical base without inventing a thread.
-    const cacheKey = options.retain === false ? undefined : isolated
-        ? JSON.stringify(["structured", threadId ?? null, threadId ? null : setup])
-        : threadId ? JSON.stringify(["chat", threadId]) : undefined;
-    const unlock = isolated && cacheKey !== undefined ? await lockPreparation(cacheKey, options.signal) : undefined;
-    try {
-        let recreated = false;
-        for (;;) {
-            const base = await leasePooledSession({ ...options, cacheKey });
-            // A non-retained session is already isolated: generate directly on it and
-            // destroy it when the call ends, without preparing an extra clone.
-            if (!isolated || options.retain === false)
-                return base;
-            const started = performance.now();
-            let copy;
-            try {
-                copy = await base.session.clone({ signal: options.signal });
-                options.signal?.throwIfAborted();
-                let overflowed = false;
-                const onOverflow = () => { overflowed = true; };
-                copy.addEventListener("contextoverflow", onOverflow);
-                const baseOverflowed = base.overflowed();
-                // Only preparation touches the base. Release it before generation so concurrent
-                // callers can clone it too; generated JSON and draft notes never enter it.
-                base.release(prior);
-                const session = copy;
-                let destroyed = false;
-                const destroy = () => {
-                    if (destroyed)
-                        return;
-                    destroyed = true;
-                    session.removeEventListener("contextoverflow", onOverflow);
-                    session.destroy();
-                };
-                return {
-                    ...base,
-                    session,
-                    createMs: base.createMs + performance.now() - started,
-                    overflowed: () => baseOverflowed || overflowed,
-                    release: destroy,
-                    discard: destroy
-                };
-            }
-            catch (error) {
-                copy?.destroy();
-                // Aborting a clone must not destroy its healthy cached parent.
-                if (options.signal?.aborted)
-                    base.release(prior);
-                else
-                    base.discard();
-                // A stale browser session can fail at clone() before any generation starts.
-                // Recreate that prefix once, just as the streaming path does.
-                if (!options.signal?.aborted && base.reused && !recreated && error instanceof DOMException && error.name === "InvalidStateError") {
-                    recreated = true;
-                    continue;
-                }
-                throw error;
-            }
-        }
-    }
-    finally {
-        unlock?.();
-    }
-}
-async function leasePooledSession({ cacheKey, system, prior, options, signal, media, onDownloadProgress }) {
-    const setup = JSON.stringify({ system, options });
-    const keys = prior.map(keyOf);
-    const entry = cacheKey ? entries.get(cacheKey) : undefined;
-    let miss;
-    if (entry) {
-        miss = entry.busy
-            ? "another call of this thread holds its session"
-            : entry.setup !== setup
-                ? "the system prompt, tools or options changed"
-                : startsWith(keys, entry.history)
-                    ? undefined
-                    : "the conversation changed (an edited, regenerated or rewritten message)";
-    }
-    if (entry && !miss) {
-        entry.busy = true;
-        // Most recently used last.
-        entries.delete(cacheKey);
-        entries.set(cacheKey, entry);
-        const cachedTokens = entry.session.contextUsage;
-        const started = performance.now();
-        const gap = prior.slice(entry.history.length);
-        entry.overflowed = false;
-        try {
-            if (gap.length > 0) {
-                await entry.session.append(await toLanguageModelMessages(gap, media), {
-                    signal
-                });
-            }
-            entry.history = keys;
-            return {
-                ...lease(cacheKey, entry, cachedTokens, performance.now() - started),
-                reused: true
-            };
-        }
-        catch (error) {
-            drop(cacheKey, entry);
-            if (signal?.aborted)
-                throw error;
-            // The session couldn't take them (it was destroyed, say): start over.
-            miss = `the kept session failed (${error instanceof Error ? error.message : String(error)})`;
-        }
-    }
-    // Another run of this thread holds its session (it shouldn't happen):
-    // this one gets a session of its own, freed when it ends.
-    const shared = !entry?.busy;
-    if (entry && shared && cacheKey)
-        drop(cacheKey, entry);
-    const startedIn = generation;
-    const started = performance.now();
-    const created = {
-        session: await createSession(system, prior, options, signal, media, onDownloadProgress),
-        setup,
-        history: keys,
-        busy: true,
-        overflowed: false
-    };
-    created.session.addEventListener("contextoverflow", () => {
-        created.overflowed = true;
-    });
-    // Unloaded while it was created: the call uses it, then it's freed.
-    const kept = cacheKey !== undefined && shared && startedIn === generation;
-    if (kept) {
-        entries.set(cacheKey, created);
-        trimIdleSessions();
-    }
-    return {
-        ...lease(kept ? cacheKey : undefined, created, 0, performance.now() - started),
-        reused: false,
-        ...(miss && { miss })
-    };
-}
-function lease(threadId, entry, cachedTokens, createMs) {
-    return {
-        session: entry.session,
-        cachedTokens,
-        createMs,
-        overflowed: () => entry.overflowed,
-        release: (history) => {
-            if (!threadId || entries.get(threadId) !== entry)
-                return entry.session.destroy();
-            entry.history = history.map(keyOf);
-            entry.busy = false;
-            trimIdleSessions();
-        },
-        discard: () => {
-            if (threadId)
-                drop(threadId, entry);
-            else
-                entry.session.destroy();
-        }
-    };
-}
-/** Busy entries can exceed the bound temporarily; evict oldest idle entries on return. */
-function trimIdleSessions() {
-    for (const [id, entry] of entries) {
-        if (entries.size <= MAX_SESSIONS)
-            break;
-        if (!entry.busy)
-            drop(id, entry);
-    }
-}
-function drop(threadId, entry) {
-    if (entries.get(threadId) === entry)
-        entries.delete(threadId);
-    entry.session.destroy();
-}
-/** The conversation without its oldest turn: up to the next user message. */
-function withoutOldestTurn(messages) {
-    const next = messages.findIndex((m, i) => i > 0 && m.role === "user");
-    return next > 0 ? messages.slice(next) : [];
-}
-/**
- * A new session that has read the system prompt and the conversation. Only
- * the system prompt is an initial prompt, which the browser never drops;
- * the conversation is appended, so when it later outgrows the context the
- * browser drops its oldest turns. If it doesn't fit now, its oldest turns
- * are left out (measured first, not tried) until it does.
- */
-async function createSession(system, prior, options, signal, media, onDownloadProgress) {
-    const session = await createLanguageModel({
-        ...options,
-        ...(system && { initialPrompts: [{ role: "system", content: system }] })
-    }, signal, onDownloadProgress);
-    try {
-        let rest = prior;
-        while (rest.length > 0) {
-            const input = await toLanguageModelMessages(rest, media);
-            const room = session.contextWindow - session.contextUsage;
-            const needed = await session.measureContextUsage(input, { signal });
-            if (needed <= room) {
-                await session.append(input, { signal });
-                break;
-            }
-            rest = withoutOldestTurn(rest);
-        }
-        return session;
-    }
-    catch (error) {
-        session.destroy();
-        throw error;
-    }
-}
-/**
- * Frees every session kept, as when the page no longer needs the model.
- * Sessions a call holds, or is still creating, finish that call and are
- * freed when it ends instead of going back in the cache.
- */
-export function destroyPromptApiSessions() {
-    generation++;
-    for (const [id, entry] of [...entries]) {
-        // A busy entry is only detached: its lease sees it's no longer the
-        // thread's and destroys the session on release.
-        if (entry.busy)
-            entries.delete(id);
-        else
-            drop(id, entry);
-    }
-}

package/dist/shared-load.d.ts

@@ -1,48 +0,0 @@
-/**
- * The callers waiting on one shared model load: their progress callbacks
- * and how many still wait. A caller whose signal aborts stops waiting at
- * once and hears nothing more; when the last caller still waiting aborts,
- * the load is cancelled. (Kept in step with the same file in the other
- * runtime packages.)
- */
-/** A download's progress, from 0 to 1. */
-type DownloadProgressCallback = (progress: number) => void;
-/** What an aborted `create()` rejects with. */
-export declare function abortError(): DOMException;
-/** Calls a progress callback; one that throws doesn't stop the load. */
-export declare function callProgress(listener: DownloadProgressCallback, progress: number): void;
-export type WaitOptions = {
-    onDownloadProgress?: DownloadProgressCallback;
-    signal?: AbortSignal;
-    /**
-     * Whether this caller aborting last cancels the load (true by default).
-     * A chat's own wait passes false: it stops waiting, and the download goes
-     * on for the next chat.
-     */
-    cancels?: boolean;
-    /** What this caller rejects with when it aborts: an AbortError by default. */
-    reason?: (signal: AbortSignal) => unknown;
-};
-export declare class LoadWaiters {
-    private readonly cancel;
-    /** Each callback, with how many waiting callers use it: called once per report. */
-    private readonly callbacks;
-    private waiting;
-    private settled;
-    /** `cancel` stops the load: called when the last caller still waiting aborts. */
-    constructor(cancel: () => void);
-    /** Reports progress to the callers still waiting. */
-    report(progress: number): void;
-    /** The load settled (ready, failed or replaced): nothing more to report or cancel. */
-    settle(): void;
-    /**
-     * `load`'s result for one more caller. Aborting `signal` rejects this
-     * caller at once and stops its reports; if it was the last caller waiting
-     * (and `cancels`), the load is cancelled. The promise is fine to leave
-     * unawaited. Check the signal before starting the load: an aborted one
-     * rejects here without waiting.
-     */
-    wait<T>(load: Promise<T>, options?: WaitOptions): Promise<T>;
-}
-export {};
-//# sourceMappingURL=shared-load.d.ts.map

package/dist/shared-load.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shared-load.d.ts","sourceRoot":"","sources":["../src/shared-load.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,0CAA0C;AAC1C,KAAK,wBAAwB,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;AAE1D,+CAA+C;AAC/C,wBAAgB,UAAU,IAAI,YAAY,CAEzC;AAED,wEAAwE;AACxE,wBAAgB,YAAY,CAAC,QAAQ,EAAE,wBAAwB,EAAE,QAAQ,EAAE,MAAM,QAMhF;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,kBAAkB,CAAC,EAAE,wBAAwB,CAAA;IAC7C,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,8EAA8E;IAC9E,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAA;CAC1C,CAAA;AAED,qBAAa,WAAW;IAOV,OAAO,CAAC,QAAQ,CAAC,MAAM;IANnC,mFAAmF;IACnF,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA8C;IACxE,OAAO,CAAC,OAAO,CAAI;IACnB,OAAO,CAAC,OAAO,CAAQ;IAEvB,iFAAiF;gBACpD,MAAM,EAAE,MAAM,IAAI;IAE/C,qDAAqD;IACrD,MAAM,CAAC,QAAQ,EAAE,MAAM;IAIvB,sFAAsF;IACtF,MAAM;IAMN;;;;;;OAMG;IACH,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,CAAC,CAAC;CA8CjE"}

package/dist/shared-load.js

@@ -1,103 +0,0 @@
-/**
- * The callers waiting on one shared model load: their progress callbacks
- * and how many still wait. A caller whose signal aborts stops waiting at
- * once and hears nothing more; when the last caller still waiting aborts,
- * the load is cancelled. (Kept in step with the same file in the other
- * runtime packages.)
- */
-/** What an aborted `create()` rejects with. */
-export function abortError() {
-    return new DOMException("The model load was aborted.", "AbortError");
-}
-/** Calls a progress callback; one that throws doesn't stop the load. */
-export function callProgress(listener, progress) {
-    try {
-        listener(progress);
-    }
-    catch (error) {
-        console.error(error);
-    }
-}
-export class LoadWaiters {
-    cancel;
-    /** Each callback, with how many waiting callers use it: called once per report. */
-    callbacks = new Map();
-    waiting = 0;
-    settled = false;
-    /** `cancel` stops the load: called when the last caller still waiting aborts. */
-    constructor(cancel) {
-        this.cancel = cancel;
-    }
-    /** Reports progress to the callers still waiting. */
-    report(progress) {
-        for (const listener of [...this.callbacks.keys()])
-            callProgress(listener, progress);
-    }
-    /** The load settled (ready, failed or replaced): nothing more to report or cancel. */
-    settle() {
-        this.settled = true;
-        this.callbacks.clear();
-        this.waiting = 0;
-    }
-    /**
-     * `load`'s result for one more caller. Aborting `signal` rejects this
-     * caller at once and stops its reports; if it was the last caller waiting
-     * (and `cancels`), the load is cancelled. The promise is fine to leave
-     * unawaited. Check the signal before starting the load: an aborted one
-     * rejects here without waiting.
-     */
-    wait(load, options = {}) {
-        const { onDownloadProgress, signal, cancels = true, reason = abortError } = options;
-        if (signal?.aborted)
-            return quiet(Promise.reject(reason(signal)));
-        if (this.settled)
-            return quiet(load);
-        this.waiting++;
-        if (onDownloadProgress) {
-            this.callbacks.set(onDownloadProgress, (this.callbacks.get(onDownloadProgress) ?? 0) + 1);
-        }
-        let left = false;
-        const leave = () => {
-            if (left)
-                return;
-            left = true;
-            if (this.settled)
-                return;
-            this.waiting--;
-            if (!onDownloadProgress)
-                return;
-            const count = (this.callbacks.get(onDownloadProgress) ?? 0) - 1;
-            if (count > 0)
-                this.callbacks.set(onDownloadProgress, count);
-            else
-                this.callbacks.delete(onDownloadProgress);
-        };
-        if (!signal) {
-            load.then(leave, leave);
-            return quiet(load);
-        }
-        return quiet(new Promise((resolve, reject) => {
-            const onAbort = () => {
-                leave();
-                reject(reason(signal));
-                if (cancels && !this.settled && this.waiting === 0)
-                    this.cancel();
-            };
-            signal.addEventListener("abort", onAbort, { once: true });
-            load.then((value) => {
-                signal.removeEventListener("abort", onAbort);
-                leave();
-                resolve(value);
-            }, (error) => {
-                signal.removeEventListener("abort", onAbort);
-                leave();
-                reject(error);
-            });
-        }));
-    }
-}
-/** `promise`, with a rejection that's fine to leave unhandled. */
-function quiet(promise) {
-    promise.catch(() => undefined);
-    return promise;
-}

package/dist/store.d.ts

@@ -1,8 +0,0 @@
-/** A value that can be read, set and watched. Framework-free. */
-export type Store<T> = {
-    get: () => T;
-    set: (value: T) => void;
-    subscribe: (listener: () => void) => () => void;
-};
-export declare function createStore<T>(initial: T): Store<T>;
-//# sourceMappingURL=store.d.ts.map

package/dist/store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":"AAAA,iEAAiE;AACjE,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI;IACrB,GAAG,EAAE,MAAM,CAAC,CAAA;IACZ,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAA;IACvB,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAA;CAChD,CAAA;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAgBnD"}

package/dist/store.js

@@ -1,17 +0,0 @@
-export function createStore(initial) {
-    let value = initial;
-    const listeners = new Set();
-    return {
-        get: () => value,
-        set: (next) => {
-            value = next;
-            listeners.forEach((listener) => listener());
-        },
-        subscribe: (listener) => {
-            listeners.add(listener);
-            return () => {
-                listeners.delete(listener);
-            };
-        }
-    };
-}