@happyvertical/smrt-svelte 0.51.11 → 0.51.13

package/dist/browser-ai/adapters/llm/webllm-inference-backend.test.js

@@ -0,0 +1,646 @@
+/**
+ * The local (`webllm`) inference backend.
+ *
+ * Two invariants this suite exists to pin:
+ *
+ * 1. **An unusable local backend reports `unavailable`, not `idle`.** The path
+ *    only auto-selects `ready`, so a device without WebGPU must not sit in a
+ *    state a caller might promote — and `load()` on one must fail rather than
+ *    start a download that can never work.
+ * 2. **A turn the adapter cannot represent is refused, not degraded.** The
+ *    adapter is a text-only conversation contract; silently rewriting a `tool`
+ *    observation or dropping `options.tools` would let a model answer as
+ *    though it had seen context (or tools) it never received.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+const getLLMMock = vi.hoisted(() => vi.fn());
+vi.mock('./factory.js', () => ({ getLLM: getLLMMock }));
+import { createWebLlmInferenceBackend } from './webllm-inference-backend.js';
+const originalNavigator = Object.getOwnPropertyDescriptor(globalThis, 'navigator');
+/** jsdom has no `navigator.gpu`; detectCapabilities keys off `'gpu' in navigator`. */
+function withWebGpu() {
+    Object.defineProperty(globalThis, 'navigator', {
+        value: { ...globalThis.navigator, gpu: {} },
+        configurable: true,
+    });
+}
+function makeAdapter() {
+    let initState = 'uninitialized';
+    let failure = null;
+    const calls = {
+        ensure: [],
+        chat: [],
+        stream: [],
+        unload: 0,
+    };
+    return {
+        type: 'webllm',
+        get initState() {
+            return initState;
+        },
+        currentModel: null,
+        calls,
+        setInitState(state) {
+            initState = state;
+        },
+        fail(error) {
+            failure = error;
+        },
+        async ensureInitialized(modelId, onProgress) {
+            calls.ensure.push(modelId);
+            initState = 'initializing';
+            onProgress?.({
+                state: 'downloading',
+                bytesLoaded: 10,
+                bytesTotal: 40,
+                percent: 25,
+            });
+            initState = 'ready';
+        },
+        async chat(messages, options) {
+            calls.chat.push({ messages, options });
+            if (failure)
+                throw failure;
+            return {
+                content: 'reply',
+                usage: { promptTokens: 1, completionTokens: 2, totalTokens: 3 },
+                model: 'm',
+                finishReason: 'stop',
+            };
+        },
+        async *stream(messages, options) {
+            calls.stream.push({ messages, options });
+            options?.onToken?.('a');
+            yield 'a';
+        },
+        async unloadModel() {
+            calls.unload += 1;
+            initState = 'uninitialized';
+        },
+        async dispose() { },
+    };
+}
+function progressOf(backend) {
+    return backend.progress;
+}
+async function expectPathError(run, code) {
+    const error = await run().then(() => undefined, (thrown) => thrown);
+    expect(error).toMatchObject({ name: 'InferencePathError', code });
+}
+describe('createWebLlmInferenceBackend', () => {
+    beforeEach(() => {
+        // Default jsdom navigator: no `gpu`, so the backend is unavailable.
+        Object.defineProperty(globalThis, 'navigator', {
+            value: { ...globalThis.navigator },
+            configurable: true,
+        });
+    });
+    afterEach(() => {
+        if (originalNavigator) {
+            Object.defineProperty(globalThis, 'navigator', originalNavigator);
+        }
+        vi.unstubAllGlobals();
+    });
+    it('reports unavailable without WebGPU, so auto-selection skips it', () => {
+        const backend = createWebLlmInferenceBackend({ adapter: makeAdapter() });
+        expect(backend.status).toBe('unavailable');
+        expect(backend.kind).toBe('local');
+    });
+    it('defaults its id to "local" and accepts an override', () => {
+        expect(createWebLlmInferenceBackend().id).toBe('local');
+        expect(createWebLlmInferenceBackend({ id: 'on-device' }).id).toBe('on-device');
+    });
+    it('reports idle before a load, ready after, once WebGPU exists', async () => {
+        withWebGpu();
+        const adapter = makeAdapter();
+        const backend = createWebLlmInferenceBackend({ adapter });
+        expect(backend.status).toBe('idle');
+        await backend.load();
+        expect(backend.status).toBe('ready');
+    });
+    it('refuses to load without WebGPU rather than starting a doomed download', async () => {
+        const adapter = makeAdapter();
+        const backend = createWebLlmInferenceBackend({ adapter });
+        await expectPathError(() => backend.load(), 'no_usable_backend');
+        expect(adapter.calls.ensure).toEqual([]);
+    });
+    it('exposes adapter progress during a load and clears it after', async () => {
+        withWebGpu();
+        const adapter = makeAdapter();
+        const backend = createWebLlmInferenceBackend({ adapter });
+        let during;
+        const load = backend.load(() => {
+            during = progressOf(backend);
+        });
+        await load;
+        expect(during).toMatchObject({ percent: 25, bytesLoaded: 10 });
+        expect(progressOf(backend)).toBeUndefined();
+    });
+    it('forwards the requested model to the adapter', async () => {
+        withWebGpu();
+        const adapter = makeAdapter();
+        const backend = createWebLlmInferenceBackend({
+            adapter,
+            model: 'SmolLM2-360M-Instruct-q4f16_1-MLC',
+        });
+        await backend.load();
+        expect(adapter.calls.ensure).toEqual(['SmolLM2-360M-Instruct-q4f16_1-MLC']);
+    });
+    it('reports loading while a load is in flight', async () => {
+        withWebGpu();
+        const adapter = makeAdapter();
+        // The gate is built before `load()` so the resolver exists synchronously —
+        // `ensureAdapter()` is async, so the adapter's own promise is created a
+        // tick later and a deferred resolver assigned inside it would not exist
+        // yet.
+        let release = () => { };
+        const gate = new Promise((resolve) => {
+            release = resolve;
+        });
+        adapter.ensureInitialized = async () => {
+            await gate;
+            adapter.setInitState('ready');
+        };
+        const backend = createWebLlmInferenceBackend({ adapter });
+        const load = backend.load();
+        // The adapter has not flipped `initState` yet; status must still say so.
+        expect(backend.status).toBe('loading');
+        release();
+        await load;
+        expect(backend.status).toBe('ready');
+    });
+    it('reports error status when the adapter failed', () => {
+        withWebGpu();
+        const adapter = makeAdapter();
+        adapter.setInitState('error');
+        expect(createWebLlmInferenceBackend({ adapter }).status).toBe('error');
+    });
+    it('keeps a failed load visible as an error, not as idle', async () => {
+        withWebGpu();
+        const adapter = makeAdapter();
+        adapter.ensureInitialized = async () => {
+            // The real adapter records the failure in `initState` before rethrowing.
+            adapter.setInitState('error');
+            throw new Error('no WebGPU device');
+        };
+        const backend = createWebLlmInferenceBackend({ adapter });
+        await expect(backend.load()).rejects.toThrow('no WebGPU device');
+        // `idle` would read as "never loaded", so a control would offer Load rather
+        // than Retry for a load that just failed, and the failure would be visible
+        // only to the one caller holding the rejected promise.
+        expect(backend.status).toBe('error');
+        expect(progressOf(backend)).toMatchObject({ state: 'error' });
+    });
+    it('refuses tool definitions on both chat and stream', async () => {
+        withWebGpu();
+        const adapter = makeAdapter();
+        const backend = createWebLlmInferenceBackend({ adapter });
+        const messages = [{ role: 'user', content: 'hi' }];
+        const tools = [
+            { type: 'function', function: { name: 'product_list' } },
+        ];
+        await expectPathError(() => backend.chat([...messages], { tools: [...tools] }), 'unsupported_message');
+        await expectPathError(async () => {
+            for await (const _chunk of backend.stream([...messages], {
+                tools: [...tools],
+            })) {
+                /* drain */
+            }
+        }, 'unsupported_message');
+        // Neither refusal may reach the adapter.
+        expect(adapter.calls.chat).toEqual([]);
+        expect(adapter.calls.stream).toEqual([]);
+    });
+    it('refuses a tool-role message rather than rewriting it', async () => {
+        withWebGpu();
+        const adapter = makeAdapter();
+        const backend = createWebLlmInferenceBackend({ adapter });
+        await expectPathError(() => backend.chat([
+            { role: 'user', content: 'hi' },
+            { role: 'tool', content: '{"rows":[]}' },
+        ]), 'unsupported_message');
+        expect(adapter.calls.chat).toEqual([]);
+    });
+    it('refuses a message carrying tool_calls rather than dropping the record', async () => {
+        withWebGpu();
+        const adapter = makeAdapter();
+        const backend = createWebLlmInferenceBackend({ adapter });
+        // The old mapper inspected only `role` and `content`, so this shape was
+        // accepted and its tool calls silently discarded — the model would then
+        // answer as though the call had never happened.
+        await expectPathError(() => backend.chat([
+            {
+                role: 'assistant',
+                content: '',
+                tool_calls: [
+                    {
+                        id: 'c1',
+                        type: 'function',
+                        function: { name: 'product_list', arguments: '{}' },
+                    },
+                ],
+            },
+        ]), 'unsupported_message');
+        expect(adapter.calls.chat).toEqual([]);
+    });
+    it('refuses a toolChoice even with no tools listed', async () => {
+        withWebGpu();
+        const adapter = makeAdapter();
+        const backend = createWebLlmInferenceBackend({ adapter });
+        await expectPathError(() => backend.chat([{ role: 'user', content: 'hi' }], {
+            toolChoice: 'none',
+        }), 'unsupported_message');
+        await expectPathError(async () => {
+            for await (const _chunk of backend.stream([{ role: 'user', content: 'hi' }], { toolChoice: 'auto' })) {
+                /* drain */
+            }
+        }, 'unsupported_message');
+        expect(adapter.calls.chat).toEqual([]);
+        expect(adapter.calls.stream).toEqual([]);
+    });
+    it('refuses multimodal content rather than dropping it', async () => {
+        withWebGpu();
+        const backend = createWebLlmInferenceBackend({ adapter: makeAdapter() });
+        await expectPathError(() => backend.chat([
+            {
+                role: 'user',
+                content: [{ type: 'text', text: 'look' }],
+            },
+        ]), 'unsupported_message');
+    });
+    it('passes text messages through unchanged and maps the response', async () => {
+        withWebGpu();
+        const adapter = makeAdapter();
+        const backend = createWebLlmInferenceBackend({ adapter });
+        const response = await backend.chat([{ role: 'user', content: 'hi' }]);
+        expect(adapter.calls.chat[0].messages).toEqual([
+            { role: 'user', content: 'hi' },
+        ]);
+        expect(response).toEqual({
+            content: 'reply',
+            usage: { promptTokens: 1, completionTokens: 2, totalTokens: 3 },
+            model: 'm',
+            finishReason: 'stop',
+        });
+    });
+    it('omits a finish reason the mirrored response has no member for', async () => {
+        withWebGpu();
+        const adapter = makeAdapter();
+        adapter.chat = async () => ({
+            content: 'partial',
+            finishReason: 'error',
+        });
+        const backend = createWebLlmInferenceBackend({ adapter });
+        // `AIResponse.finishReason` has no `'error'` member; a completed response
+        // simply carries none rather than inventing a value.
+        await expect(backend.chat([{ role: 'user', content: 'hi' }])).resolves.toEqual({ content: 'partial' });
+    });
+    it('routes onProgress to the adapter token sink and forwards options', async () => {
+        withWebGpu();
+        const adapter = makeAdapter();
+        const backend = createWebLlmInferenceBackend({ adapter });
+        const onProgress = vi.fn();
+        const chunks = [];
+        for await (const chunk of backend.stream([{ role: 'user', content: 'hi' }], {
+            temperature: 0.4,
+            maxTokens: 12,
+            topP: 0.9,
+            stop: 'END',
+            onProgress,
+        })) {
+            chunks.push(chunk);
+        }
+        expect(chunks).toEqual(['a']);
+        expect(onProgress).toHaveBeenCalledWith('a');
+        expect(adapter.calls.stream[0].options).toMatchObject({
+            temperature: 0.4,
+            maxTokens: 12,
+            topP: 0.9,
+            // The adapter takes `string[]`; a scalar caller value is normalized.
+            stop: ['END'],
+            onToken: onProgress,
+        });
+    });
+    it('clears progress and returns to idle on unload', async () => {
+        withWebGpu();
+        const adapter = makeAdapter();
+        const backend = createWebLlmInferenceBackend({ adapter });
+        await backend.load();
+        await backend.unload();
+        expect(adapter.calls.unload).toBe(1);
+        expect(progressOf(backend)).toBeUndefined();
+        expect(backend.status).toBe('idle');
+    });
+    it('shares one load between concurrent callers', async () => {
+        withWebGpu();
+        const adapter = makeAdapter();
+        const backend = createWebLlmInferenceBackend({ adapter });
+        // Two concurrent callers must join one attempt. A second attempt would
+        // reach the adapter's own `initializing` poll, which settles only on
+        // `ready` or `error` — so a release landing in between strands it.
+        await Promise.all([backend.load(), backend.load(), backend.load()]);
+        expect(adapter.calls.ensure.length).toBe(1);
+        expect(backend.status).toBe('ready');
+    });
+    it('is a no-op when the adapter is already ready', async () => {
+        withWebGpu();
+        const adapter = makeAdapter();
+        const backend = createWebLlmInferenceBackend({ adapter });
+        await backend.load();
+        const ensures = adapter.calls.ensure.length;
+        const again = backend.load();
+        // Read in the same tick: a second load must not toggle the backend through
+        // `loading`, the state auto-selection is told to skip.
+        expect(backend.status).toBe('ready');
+        await again;
+        expect(adapter.calls.ensure.length).toBe(ensures);
+        expect(backend.status).toBe('ready');
+    });
+    it('releases a load that overlaps an unload', async () => {
+        withWebGpu();
+        const adapter = makeAdapter();
+        const backend = createWebLlmInferenceBackend({ adapter });
+        const pending = backend.load();
+        await backend.unload();
+        await pending;
+        // The model finished loading after the caller released it, so it must be
+        // released again rather than reporting `ready` on a released backend.
+        expect(adapter.calls.unload).toBe(2);
+        expect(backend.status).toBe('idle');
+        expect(progressOf(backend)).toBeUndefined();
+    });
+    it('keeps the model a later load published when an earlier one is superseded', async () => {
+        withWebGpu();
+        const adapter = makeAdapter();
+        const inner = adapter.ensureInitialized.bind(adapter);
+        let releaseFirst = () => { };
+        const firstGate = new Promise((resolve) => {
+            releaseFirst = resolve;
+        });
+        let calls = 0;
+        adapter.ensureInitialized = async (modelId, onProgress) => {
+            calls += 1;
+            // Hold the FIRST attempt open so the second finishes ahead of it. Both
+            // attempts share one adapter, so that is the ordering in which a stale
+            // attempt's cleanup would destroy the model the newer attempt published.
+            if (calls === 1)
+                await firstGate;
+            return inner(modelId, onProgress);
+        };
+        const backend = createWebLlmInferenceBackend({ adapter });
+        const discarded = backend.load();
+        await backend.unload();
+        const second = backend.load();
+        await second;
+        releaseFirst();
+        await discarded;
+        expect(backend.status).toBe('ready');
+    });
+    it('releases a superseded model when the newer load then fails', async () => {
+        withWebGpu();
+        const adapter = makeAdapter();
+        const inner = adapter.ensureInitialized.bind(adapter);
+        let releaseFirst = () => { };
+        const firstGate = new Promise((resolve) => {
+            releaseFirst = resolve;
+        });
+        let failSecond = () => { };
+        const secondGate = new Promise((_resolve, reject) => {
+            failSecond = reject;
+        });
+        let calls = 0;
+        adapter.ensureInitialized = async (modelId, onProgress) => {
+            calls += 1;
+            if (calls === 1) {
+                await firstGate;
+                return inner(modelId, onProgress);
+            }
+            await secondGate;
+            return inner(modelId, onProgress);
+        };
+        const backend = createWebLlmInferenceBackend({ adapter });
+        const discarded = backend.load();
+        await backend.unload();
+        const second = backend.load();
+        const secondSettled = expect(second).rejects.toThrow('second init failed');
+        // The first attempt finishes while the second is in flight, so it must NOT
+        // release then — the second owns the adapter.
+        releaseFirst();
+        await discarded;
+        // Now the second fails: nothing else can discharge the deferred release, so
+        // a fully initialized model would stay resident with no owner.
+        failSecond(new Error('second init failed'));
+        await secondSettled;
+        expect(adapter.calls.unload).toBe(2);
+        // The release above resets the adapter's own state, so the failure has to be
+        // durable in the backend or this reads `idle` — "never loaded" — and the
+        // control offers Load instead of Retry.
+        expect(backend.status).toBe('error');
+        expect(progressOf(backend)).toMatchObject({ state: 'error' });
+    });
+    it('does not resurrect a model a later unload released', async () => {
+        withWebGpu();
+        const adapter = makeAdapter();
+        const inner = adapter.ensureInitialized.bind(adapter);
+        let releaseCold = () => { };
+        const coldGate = new Promise((resolve) => {
+            releaseCold = resolve;
+        });
+        let calls = 0;
+        adapter.ensureInitialized = async (modelId, onProgress) => {
+            calls += 1;
+            // The first attempt stays cold, so it finishes after everything else.
+            if (calls === 1)
+                await coldGate;
+            return inner(modelId, onProgress);
+        };
+        const backend = createWebLlmInferenceBackend({ adapter });
+        const cold = backend.load();
+        await backend.unload();
+        await backend.load();
+        await backend.unload();
+        releaseCold();
+        await cold;
+        // The cold attempt re-established the model on the shared adapter; since
+        // the caller released it again, it must not be left resident and `ready`.
+        expect(backend.status).toBe('idle');
+    });
+    it('notifies subscribers on a load transition', async () => {
+        withWebGpu();
+        const backend = createWebLlmInferenceBackend({ adapter: makeAdapter() });
+        const listener = vi.fn();
+        const unsubscribe = backend.subscribe(listener);
+        await backend.load();
+        expect(listener).toHaveBeenCalled();
+        unsubscribe();
+    });
+    it('unsubscribing stops notifications', async () => {
+        withWebGpu();
+        const backend = createWebLlmInferenceBackend({ adapter: makeAdapter() });
+        const listener = vi.fn();
+        backend.subscribe(listener)();
+        await backend.load();
+        expect(listener).not.toHaveBeenCalled();
+    });
+});
+describe('createWebLlmInferenceBackend adapter construction', () => {
+    beforeEach(() => {
+        Object.defineProperty(globalThis, 'navigator', {
+            value: { ...globalThis.navigator, gpu: {} },
+            configurable: true,
+        });
+        getLLMMock.mockReset();
+    });
+    afterEach(() => {
+        if (originalNavigator) {
+            Object.defineProperty(globalThis, 'navigator', originalNavigator);
+        }
+    });
+    it('forwards a supplied module loader to the adapter factory', async () => {
+        const adapter = makeAdapter();
+        getLLMMock.mockResolvedValue(adapter);
+        const loadModule = () => Promise.resolve({ CreateMLCEngine: vi.fn() });
+        // A browser cannot resolve a bare specifier, so this passthrough is the
+        // only way a host that owns `@mlc-ai/web-llm` can make the local backend
+        // work at all.
+        await createWebLlmInferenceBackend({ loadModule }).chat([
+            { role: 'user', content: 'hi' },
+        ]);
+        expect(getLLMMock).toHaveBeenCalledWith({ loadModule });
+    });
+    it('pins the configured model as the adapter default', async () => {
+        const adapter = makeAdapter();
+        getLLMMock.mockResolvedValue(adapter);
+        // A turn that names no model resolves the adapter's DEFAULT, so the model
+        // `load()` ensures has to be that default — otherwise the first turn unloads
+        // it and downloads another behind the message.
+        await createWebLlmInferenceBackend({ model: 'wanted' }).chat([
+            { role: 'user', content: 'hi' },
+        ]);
+        expect(getLLMMock).toHaveBeenCalledWith({ defaultModel: 'wanted' });
+    });
+    it('targets the ensured model on a turn, not the adapter default', async () => {
+        withWebGpu();
+        const adapter = makeAdapter();
+        adapter.setInitState('ready');
+        adapter.currentModel = 'wanted';
+        const backend = createWebLlmInferenceBackend({ adapter, model: 'wanted' });
+        await backend.chat([{ role: 'user', content: 'hi' }]);
+        // A turn that names no model must resolve the one this backend ensures: the
+        // adapter would otherwise fall back to its own default, unload the model
+        // `load()` bound, and download another behind the message.
+        expect(adapter.calls.chat.at(-1)?.options).toMatchObject({
+            model: 'wanted',
+        });
+    });
+    it('does not let a superseded failure release the current model', async () => {
+        withWebGpu();
+        const adapter = makeAdapter();
+        const inner = adapter.ensureInitialized.bind(adapter);
+        const gates = [];
+        let calls = 0;
+        adapter.ensureInitialized = async (modelId, onProgress) => {
+            calls += 1;
+            const attempt = calls;
+            await new Promise((resolve) => {
+                gates[attempt] = resolve;
+            });
+            // The middle attempt fails AFTER the third one has published.
+            if (attempt === 2)
+                throw new Error('second init failed');
+            return inner(modelId, onProgress);
+        };
+        const backend = createWebLlmInferenceBackend({ adapter });
+        const first = backend.load();
+        await backend.unload();
+        const second = backend.load();
+        await backend.unload();
+        const third = backend.load();
+        // Microtask-driven (no wall clock): wait until each attempt has reached its
+        // await before releasing any gate.
+        const until = async (ready) => {
+            for (let i = 0; i < 100 && !ready(); i += 1)
+                await Promise.resolve();
+        };
+        await until(() => typeof gates[3] === 'function');
+        // The oldest attempt finishes while the third is in flight, so it defers.
+        gates[1]();
+        await until(() => typeof gates[3] === 'function');
+        // The third publishes the model this backend now owns.
+        gates[3]();
+        await third;
+        // The middle attempt then fails: its epoch is superseded, so it says
+        // nothing about who owns the adapter now.
+        gates[2]();
+        await second.catch(() => undefined);
+        await first.catch(() => undefined);
+        expect(backend.status).toBe('ready');
+    });
+    it('does not orphan a model a newer attempt already published', async () => {
+        withWebGpu();
+        const adapter = makeAdapter();
+        const inner = adapter.ensureInitialized.bind(adapter);
+        const gates = [];
+        let calls = 0;
+        adapter.ensureInitialized = async (modelId, onProgress) => {
+            calls += 1;
+            const attempt = calls;
+            if (attempt === 3)
+                throw new Error('third init failed');
+            await new Promise((resolve) => {
+                gates[attempt] = resolve;
+            });
+            return inner(modelId, onProgress);
+        };
+        // A configured model the adapter does not hold keeps `load()` from
+        // short-circuiting on `ready`, so the third attempt really runs.
+        const backend = createWebLlmInferenceBackend({
+            adapter,
+            model: 'wanted',
+        });
+        const until = async (ready) => {
+            for (let i = 0; i < 100 && !ready(); i += 1)
+                await Promise.resolve();
+        };
+        const first = backend.load();
+        await backend.unload();
+        const second = backend.load();
+        await until(() => typeof gates[2] === 'function');
+        // The newer attempt publishes first, so the adapter's ONE model is its own.
+        gates[2]();
+        await second;
+        // The stale attempt then completes — it must not claim that model.
+        gates[1]();
+        await first.catch(() => undefined);
+        const unloads = adapter.calls.unload;
+        await backend.load().catch(() => undefined);
+        // Only the explicit unload released anything: the failed load must not
+        // dispose the model the second attempt still owns.
+        expect(adapter.calls.unload).toBe(unloads);
+    });
+    it('still loads when the shared adapter is ready on another model', async () => {
+        withWebGpu();
+        const adapter = makeAdapter();
+        adapter.setInitState('ready');
+        adapter.currentModel = 'other-model';
+        const backend = createWebLlmInferenceBackend({ adapter, model: 'wanted' });
+        await backend.load();
+        // `ready` on a DIFFERENT model must not short-circuit: the caller asked for
+        // this backend's model, and skipping would hand the turn to the model the
+        // adapter happens to hold.
+        expect(adapter.calls.ensure).toEqual(['wanted']);
+    });
+    it('constructs the adapter once for concurrent callers', async () => {
+        const adapter = makeAdapter();
+        getLLMMock.mockResolvedValue(adapter);
+        const backend = createWebLlmInferenceBackend({});
+        await Promise.all([
+            backend.chat([{ role: 'user', content: 'a' }]),
+            backend.chat([{ role: 'user', content: 'b' }]),
+            backend.load(),
+        ]);
+        // Two callers must not each build an unshared adapter — and, with it, start
+        // a second multi-hundred-megabyte download.
+        expect(getLLMMock).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/browser-ai/adapters/llm/webllm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webllm.d.ts","sourceRoot":"","sources":["../../../../src/browser-ai/adapters/llm/webllm.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH,OAAO,KAAK,EAEV,SAAS,EACT,UAAU,EACX,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EACV,UAAU,EACV,eAAe,EACf,cAAc,EACd,UAAU,EAEV,WAAW,EACX,aAAa,EACd,MAAM,YAAY,CAAC;AAwDpB;;GAEG;AACH,qBAAa,aAAc,YAAW,UAAU;IAC9C,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAU;IAElC,OAAO,CAAC,UAAU,CAA8B;IAChD,OAAO,CAAC,aAAa,CAAuB;IAC5C,OAAO,CAAC,OAAO,CAAgB;IAG/B,OAAO,CAAC,MAAM,CAA6B;gBAE/B,OAAO,GAAE,aAAkB;IAOvC,IAAI,SAAS,IAAI,SAAS,CAEzB;IAED,IAAI,YAAY,IAAI,MAAM,GAAG,IAAI,CAEhC;IAEK,iBAAiB,CACrB,OAAO,CAAC,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,IAAI,CAAC;YAoFF,YAAY;IAWpB,eAAe,IAAI,OAAO,CAAC,eAAe,CAAC;IAsB3C,IAAI,CACR,QAAQ,EAAE,UAAU,EAAE,EACtB,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,WAAW,CAAC;IAoChB,MAAM,CACX,QAAQ,EAAE,UAAU,EAAE,EACtB,OAAO,GAAE,cAAmB,GAC3B,aAAa,CAAC,MAAM,CAAC;IA+BlB,OAAO,CACX,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,cAAc,GAAG;QAAE,YAAY,CAAC,EAAE,MAAM,CAAA;KAAO,GACvD,OAAO,CAAC,MAAM,CAAC;IAmBZ,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAM1C,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAa5B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAG/B"}
+{"version":3,"file":"webllm.d.ts","sourceRoot":"","sources":["../../../../src/browser-ai/adapters/llm/webllm.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH,OAAO,KAAK,EAEV,SAAS,EACT,UAAU,EACX,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EACV,UAAU,EACV,eAAe,EACf,cAAc,EACd,UAAU,EAEV,WAAW,EACX,aAAa,EACd,MAAM,YAAY,CAAC;AAwDpB;;GAEG;AACH,qBAAa,aAAc,YAAW,UAAU;IAC9C,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAU;IAElC,OAAO,CAAC,UAAU,CAA8B;IAChD,OAAO,CAAC,aAAa,CAAuB;IAC5C,OAAO,CAAC,OAAO,CAAgB;IAG/B,OAAO,CAAC,MAAM,CAA6B;gBAE/B,OAAO,GAAE,aAAkB;IAOvC,IAAI,SAAS,IAAI,SAAS,CAEzB;IAED,IAAI,YAAY,IAAI,MAAM,GAAG,IAAI,CAEhC;IAEK,iBAAiB,CACrB,OAAO,CAAC,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,IAAI,CAAC;YA6FF,YAAY;IAuBpB,eAAe,IAAI,OAAO,CAAC,eAAe,CAAC;IAsB3C,IAAI,CACR,QAAQ,EAAE,UAAU,EAAE,EACtB,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,WAAW,CAAC;IAoChB,MAAM,CACX,QAAQ,EAAE,UAAU,EAAE,EACtB,OAAO,GAAE,cAAmB,GAC3B,aAAa,CAAC,MAAM,CAAC;IA+BlB,OAAO,CACX,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,cAAc,GAAG;QAAE,YAAY,CAAC,EAAE,MAAM,CAAA;KAAO,GACvD,OAAO,CAAC,MAAM,CAAC;IAmBZ,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAM1C,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAa5B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAG/B"}