use-browser-llm 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 use-local-llm contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,248 @@
+# use-browser-llm
+
+A headless React hook for running Large Language Models locally in the
+browser via WebGPU — no backend, no API keys, no data leaving the device.
+
+Model inference runs inside a dedicated Web Worker (via
+[`@mlc-ai/web-llm`](https://github.com/mlc-ai/web-llm)), so the main thread
+and your UI never freeze during generation. Model weights are cached in
+IndexedDB across sessions, so repeat visits skip the multi-gigabyte
+re-download.
+
+**This package ships no UI components and no styles — only a hook.** It is
+deliberately headless so it stays lightweight and works with whatever
+design system you already use (Tailwind, Shadcn, CSS Modules, plain CSS,
+anything). You bring the chat bubble, the loading spinner, the button —
+`useBrowserLLM()` only gives you the state and the functions to drive them.
+
+## Requirements
+
+- React 18 or later
+- A browser with [WebGPU](https://caniuse.com/webgpu) support — check the
+  link for current browser coverage, since it's still expanding — see
+  [Handling unsupported browsers](#handling-unsupported-browsers) below for
+  what happens when it's missing
+
+## Install
+
+```sh
+npm install use-browser-llm
+```
+
+## Quickstart
+
+```tsx
+import { useState } from "react";
+import { useBrowserLLM } from "use-browser-llm";
+
+const MODEL_ID = "Llama-3.2-1B-Instruct-q4f16_1-MLC";
+
+export function App() {
+  const { status, progress, generate, isGenerating } = useBrowserLLM(MODEL_ID);
+  const [reply, setReply] = useState("");
+
+  if (status === "loading") {
+    return <p>Loading model… {Math.round(progress * 100)}%</p>;
+  }
+
+  if (status === "error") {
+    return <p>Something went wrong loading the model.</p>;
+  }
+
+  return (
+    <div>
+      <button
+        disabled={status !== "ready" || isGenerating}
+        onClick={async () => {
+          const text = await generate([
+            { role: "user", content: "Say hello in one short sentence." },
+          ]);
+          setReply(text);
+        }}
+      >
+        {isGenerating ? "Generating…" : "Ask"}
+      </button>
+      <p>{reply}</p>
+    </div>
+  );
+}
+```
+
+`useBrowserLLM` takes a model id — any id from
+[`prebuiltAppConfig.model_list`](https://github.com/mlc-ai/web-llm/blob/main/src/config.ts)
+in `@mlc-ai/web-llm` — or `undefined` if you don't want to load a model yet
+(e.g. while the user is still picking one). `status` starts at `"idle"`,
+moves to `"loading"` once a model id is provided, then to `"ready"` or
+`"error"`. `generate()` only resolves once `status === "ready"`; calling it
+earlier rejects immediately (see [Errors](#errors) below).
+
+## Streaming generation
+
+For token-by-token output, use `streamGenerate()` instead of `generate()`.
+It returns an `AsyncGenerator`, so you consume it with `for await`:
+
+```tsx
+import { useState } from "react";
+import { useBrowserLLM } from "use-browser-llm";
+
+export function StreamingExample() {
+  const { status, streamGenerate } = useBrowserLLM(
+    "Llama-3.2-1B-Instruct-q4f16_1-MLC",
+  );
+  const [text, setText] = useState("");
+
+  async function handleAsk() {
+    setText("");
+    for await (const token of streamGenerate([
+      { role: "user", content: "Write a haiku about the ocean." },
+    ])) {
+      setText((prev) => prev + token);
+    }
+  }
+
+  return (
+    <div>
+      <button disabled={status !== "ready"} onClick={handleAsk}>
+        Ask
+      </button>
+      <p>{text}</p>
+    </div>
+  );
+}
+```
+
+Breaking out of the loop early (e.g. a `break` inside the `for await`)
+still stops the underlying worker's inference — you don't need to call
+`abort()` yourself in that case, though you can if you want to stop
+generation from somewhere other than the loop itself (see below).
+
+## Cancellation
+
+Both `generate()` and `streamGenerate()` share one `abort()` function that
+stops generation in the worker itself, not just the promise on the main
+thread:
+
+```tsx
+import { useBrowserLLM } from "use-browser-llm";
+
+export function CancellableExample() {
+  const { status, streamGenerate, abort, isGenerating } = useBrowserLLM(
+    "Llama-3.2-1B-Instruct-q4f16_1-MLC",
+  );
+
+  async function handleAsk() {
+    for await (const token of streamGenerate([
+      { role: "user", content: "Tell me a long story." },
+    ])) {
+      console.log(token);
+    }
+  }
+
+  return (
+    <div>
+      <button disabled={status !== "ready"} onClick={handleAsk}>
+        Ask
+      </button>
+      <button disabled={!isGenerating} onClick={abort}>
+        Stop
+      </button>
+    </div>
+  );
+}
+```
+
+`isGenerating` is `true` for the duration of any `generate()` or
+`streamGenerate()` call, and only one can run at a time — calling either
+while one is already in flight rejects with `HookBusyError` rather than
+silently queuing or corrupting state.
+
+## Handling unsupported browsers
+
+When the browser has no usable WebGPU (missing entirely, no adapter, or
+only a software fallback adapter), `status` resolves straight to
+`"unsupported"` — it never passes through `"loading"`, and no worker is
+ever created. Check for it and render your own fallback UI (this package
+ships none):
+
+```tsx
+import { useBrowserLLM } from "use-browser-llm";
+
+export function UnsupportedFallbackExample() {
+  const { status } = useBrowserLLM("Llama-3.2-1B-Instruct-q4f16_1-MLC");
+
+  if (status === "unsupported") {
+    return (
+      <p>
+        Your browser doesn't support the local AI features on this page. Try the
+        latest Chrome or Edge.
+      </p>
+    );
+  }
+
+  // ...the rest of your component
+  return null;
+}
+```
+
+## Cache status
+
+`cacheStatus` tells you whether the model was already downloaded in a
+previous session, so you can show a different message for "instant load"
+vs. "first-time multi-gigabyte download":
+
+```tsx
+const { cacheStatus } = useBrowserLLM("Llama-3.2-1B-Instruct-q4f16_1-MLC");
+// "idle" | "checking" | "cached" | "downloading"
+```
+
+`cacheStatus` is available before `status` reaches `"ready"`, but for a
+model that loads very quickly it can stay at `"checking"` if the load
+finishes before the cache check itself resolves — check `status` first for
+anything load-gating; `cacheStatus` is informational.
+
+## Errors
+
+- `HookNotReadyError` — rejected by `generate()` (immediately) or thrown
+  from `streamGenerate()`'s async generator (on its first iteration —
+  generators are lazy, so the check runs when you start consuming it, not
+  when you call the function) when called before `status === "ready"`.
+- `HookBusyError` — same timing as above, when calling `generate()`/
+  `streamGenerate()` while one is already in flight.
+- `UnsupportedError` — the `error` value when `status === "unsupported"`;
+  has a `.reason` field (`"no-navigator-gpu"` | `"no-adapter"` |
+  `"fallback-adapter"`).
+- `WorkerCrashError` — the `error` value when `status === "error"` and the
+  cause was the worker crashing or becoming unresponsive, rather than a
+  normal model-load failure.
+
+All are exported from `use-browser-llm` for `instanceof` checks.
+
+## API reference
+
+```ts
+function useBrowserLLM(modelId: string | undefined): {
+  status: "idle" | "loading" | "ready" | "error" | "unsupported";
+  progress: number; // 0-1, meaningful only while status === "loading"
+  error: Error | null; // set for "error" and "unsupported"
+  cacheStatus: "idle" | "checking" | "cached" | "downloading";
+  isGenerating: boolean;
+  generationError: Error | null;
+  generate(messages: ChatMessage[]): Promise<string>;
+  streamGenerate(messages: ChatMessage[]): AsyncGenerator<string, void, void>;
+  abort(): void;
+};
+
+type ChatMessage = {
+  role: "system" | "user" | "assistant";
+  content: string;
+};
+```
+
+`ChatMessage` is a plain, self-contained type — e.g.
+`{ role: "user", content: "..." }` — not a re-export of
+`@mlc-ai/web-llm`'s own message type, so this package's public API never
+requires you to know anything about the underlying engine.
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/dist/index.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Public message shape for generate()/streamGenerate() — deliberately a
+ * narrower, self-contained re-declaration of the common case from
+ * @mlc-ai/web-llm's ChatCompletionMessageParam (system/user/assistant with
+ * plain string content), not an import of it. Importing web-llm's type
+ * directly would put `@mlc-ai/web-llm` in this package's public .d.ts
+ * output, which the package's own architecture rule (only worker.ts ever
+ * references web-llm at the type OR value level) exists to prevent.
+ *
+ * This covers the vast majority of real usage (see README). It's
+ * structurally assignable to ChatCompletionMessageParam[] wherever this
+ * package passes messages into the real engine, so nothing is lost at the
+ * call site — a consumer just doesn't see web-llm's richer (tool-call,
+ * image-content-part) variants reflected in their editor, since this
+ * package doesn't expose them.
+ */
+type ChatRole = "system" | "user" | "assistant";
+interface ChatMessage {
+    role: ChatRole;
+    content: string;
+}
+
+type ModelLoadStatus = "idle" | "loading" | "ready" | "error" | "unsupported";
+type CacheStatus = "idle" | "checking" | "cached" | "downloading";
+interface ModelLoadState {
+    status: ModelLoadStatus;
+    /** 0-1 while status === "loading"; meaningless otherwise. */
+    progress: number;
+    /** Set for both "error" and "unsupported" — check `status` first, this
+     * carries the detail (an UnsupportedError, WorkerCrashError, or
+     * whatever the engine/worker rejected with). */
+    error: Error | null;
+    /** Whether modelId was already in IndexedDB before this load started.
+     * "checking" until the (non-blocking) cache check resolves; settles to
+     * "cached" or "downloading" before status reaches "ready" — but is not
+     * itself a loading gate, so it's still meaningful to read after ready.
+     * Edge case: for a fast/cached model, `status` can reach "ready" before
+     * this check resolves at all — cacheStatus then stays "checking"
+     * indefinitely for that load (the reducer intentionally drops a late
+     * resolution once status is no longer "loading"; see the "cache-status"
+     * case below). */
+    cacheStatus: CacheStatus;
+}
+interface GenerationState {
+    isGenerating: boolean;
+    generationError: Error | null;
+}
+interface UseBrowserLLMResult extends ModelLoadState, GenerationState {
+    generate(messages: ChatMessage[]): Promise<string>;
+    streamGenerate(messages: ChatMessage[]): AsyncGenerator<string, void, void>;
+    /** Stops an in-flight generate()/streamGenerate() call, including the
+     * worker's inference loop — not just the UI-visible promise. */
+    abort(): void;
+}
+/**
+ * Model-loading state machine (P1-04) plus generate/streamGenerate/abort
+ * (P1-05). Cache-status (P1-06) and the unsupported-browser path (P1-07)
+ * extend this hook in later tasks.
+ */
+declare function useBrowserLLM(modelId: string | undefined): UseBrowserLLMResult;
+
+declare class HookNotReadyError extends Error {
+    constructor();
+}
+declare class HookBusyError extends Error {
+    constructor();
+}
+declare class UnsupportedError extends Error {
+    readonly reason: string;
+    constructor(reason: string);
+}
+declare class WorkerCrashError extends Error {
+    constructor(message: string);
+}
+
+declare const USE_BROWSER_LLM_VERSION = "0.1.0";
+
+export { type CacheStatus, type ChatMessage, type ChatRole, type GenerationState, HookBusyError, HookNotReadyError, type ModelLoadState, type ModelLoadStatus, USE_BROWSER_LLM_VERSION, UnsupportedError, type UseBrowserLLMResult, WorkerCrashError, useBrowserLLM };

package/dist/index.js

@@ -0,0 +1,358 @@
+// src/use-browser-llm.ts
+import { useCallback, useEffect, useReducer, useRef, useState } from "react";
+
+// src/engine-client.ts
+import * as Comlink from "comlink";
+
+// src/errors.ts
+var HookNotReadyError = class extends Error {
+  constructor() {
+    super("useBrowserLLM: cannot generate before the model is ready");
+    this.name = "HookNotReadyError";
+  }
+};
+var HookBusyError = class extends Error {
+  constructor() {
+    super("useBrowserLLM: a generation is already in progress");
+    this.name = "HookBusyError";
+  }
+};
+var UnsupportedError = class extends Error {
+  reason;
+  constructor(reason) {
+    super(`useBrowserLLM: WebGPU is unsupported in this browser (${reason})`);
+    this.name = "UnsupportedError";
+    this.reason = reason;
+  }
+};
+var WorkerCrashError = class extends Error {
+  constructor(message) {
+    super(`useBrowserLLM: the worker crashed or stopped responding (${message})`);
+    this.name = "WorkerCrashError";
+  }
+};
+
+// src/engine-client.ts
+function createEngineClient() {
+  const worker = new Worker(new URL("./worker.js", import.meta.url), {
+    type: "module"
+  });
+  const remote = Comlink.wrap(worker);
+  return {
+    loadModel(modelId, onProgress) {
+      return remote.loadModel(modelId, Comlink.proxy(onProgress ?? (() => {
+      })));
+    },
+    generate(messages) {
+      return remote.generate(messages);
+    },
+    streamGenerate(messages, onToken) {
+      return remote.streamGenerate(messages, Comlink.proxy(onToken));
+    },
+    abort() {
+      return remote.abort();
+    },
+    unload() {
+      return remote.unload();
+    },
+    checkCache(modelId) {
+      return remote.checkCache(modelId);
+    },
+    terminate() {
+      worker.terminate();
+    },
+    onCrash(listener) {
+      const handleError = (event) => {
+        listener(new WorkerCrashError(event.message || "uncaught exception"));
+      };
+      const handleMessageError = () => {
+        listener(new WorkerCrashError("failed to deserialize a worker message"));
+      };
+      worker.addEventListener("error", handleError);
+      worker.addEventListener("messageerror", handleMessageError);
+      return () => {
+        worker.removeEventListener("error", handleError);
+        worker.removeEventListener("messageerror", handleMessageError);
+      };
+    }
+  };
+}
+
+// src/detect-webgpu.ts
+async function detectWebGPUSupport() {
+  if (typeof navigator === "undefined" || !("gpu" in navigator)) {
+    return { supported: false, reason: "no-navigator-gpu" };
+  }
+  try {
+    const adapter = await navigator.gpu.requestAdapter();
+    if (!adapter) {
+      return { supported: false, reason: "no-adapter" };
+    }
+    if (adapter.info.isFallbackAdapter) {
+      return { supported: false, reason: "fallback-adapter" };
+    }
+    return { supported: true };
+  } catch {
+    return { supported: false, reason: "no-adapter" };
+  }
+}
+
+// src/to-async-generator.ts
+async function* toAsyncGenerator(run) {
+  const queue = [];
+  let resolveNext = null;
+  let done = false;
+  let error = null;
+  run((token) => {
+    queue.push(token);
+    resolveNext?.();
+    resolveNext = null;
+  }).then(
+    () => {
+      done = true;
+      resolveNext?.();
+      resolveNext = null;
+    },
+    (err) => {
+      error = err;
+      done = true;
+      resolveNext?.();
+      resolveNext = null;
+    }
+  );
+  while (true) {
+    while (queue.length > 0) {
+      yield queue.shift();
+    }
+    if (done) {
+      if (error) {
+        throw error;
+      }
+      return;
+    }
+    await new Promise((resolve) => {
+      resolveNext = resolve;
+    });
+  }
+}
+
+// src/use-browser-llm.ts
+var initialState = {
+  status: "idle",
+  progress: 0,
+  error: null,
+  cacheStatus: "idle"
+};
+var LOAD_INACTIVITY_TIMEOUT_MS = 3e4;
+function reducer(state, action) {
+  switch (action.type) {
+    case "reset":
+      return initialState;
+    case "load-start":
+      return {
+        status: "loading",
+        progress: 0,
+        error: null,
+        cacheStatus: "checking"
+      };
+    case "progress":
+      return { ...state, progress: action.progress };
+    case "cache-status":
+      if (state.status !== "loading") {
+        return state;
+      }
+      return { ...state, cacheStatus: action.cacheStatus };
+    case "ready":
+      return { ...state, status: "ready", progress: 1, error: null };
+    case "error":
+      return { ...state, status: "error", error: action.error };
+    case "unsupported":
+      return {
+        status: "unsupported",
+        progress: 0,
+        error: action.error,
+        cacheStatus: "idle"
+      };
+  }
+}
+function useBrowserLLM(modelId) {
+  const [state, dispatch] = useReducer(reducer, initialState);
+  const clientRef = useRef(null);
+  const statusRef = useRef(state.status);
+  statusRef.current = state.status;
+  const isGeneratingRef = useRef(false);
+  const [isGenerating, setIsGenerating] = useState(false);
+  const [generationError, setGenerationError] = useState(null);
+  useEffect(() => {
+    if (!modelId) {
+      dispatch({ type: "reset" });
+      return;
+    }
+    let cancelled = false;
+    let watchdog = null;
+    let unsubscribeCrash = null;
+    const clearWatchdog = () => {
+      if (watchdog !== null) {
+        clearTimeout(watchdog);
+        watchdog = null;
+      }
+    };
+    const resetWatchdog = () => {
+      clearWatchdog();
+      watchdog = setTimeout(() => {
+        if (!cancelled) {
+          clientRef.current?.terminate();
+          clientRef.current = null;
+          dispatch({
+            type: "error",
+            error: new WorkerCrashError(
+              `no progress for ${LOAD_INACTIVITY_TIMEOUT_MS / 1e3}s \u2014 the worker may have been killed by the browser (e.g. out of memory)`
+            )
+          });
+        }
+      }, LOAD_INACTIVITY_TIMEOUT_MS);
+    };
+    clientRef.current?.terminate();
+    clientRef.current = null;
+    void (async () => {
+      const support = await detectWebGPUSupport();
+      if (cancelled) {
+        return;
+      }
+      if (!support.supported) {
+        dispatch({
+          type: "unsupported",
+          error: new UnsupportedError(support.reason)
+        });
+        return;
+      }
+      const client = createEngineClient();
+      clientRef.current = client;
+      dispatch({ type: "load-start" });
+      resetWatchdog();
+      unsubscribeCrash = client.onCrash((error) => {
+        if (!cancelled) {
+          clearWatchdog();
+          dispatch({ type: "error", error });
+        }
+      });
+      client.loadModel(modelId, (report) => {
+        if (!cancelled) {
+          resetWatchdog();
+          dispatch({ type: "progress", progress: report.progress });
+        }
+      }).then(() => {
+        if (!cancelled) {
+          clearWatchdog();
+          dispatch({ type: "ready" });
+        }
+      }).catch((err) => {
+        if (!cancelled) {
+          clearWatchdog();
+          dispatch({
+            type: "error",
+            error: err instanceof Error ? err : new Error(String(err))
+          });
+        }
+      });
+      client.checkCache(modelId).then((isCached) => {
+        if (!cancelled) {
+          dispatch({
+            type: "cache-status",
+            cacheStatus: isCached ? "cached" : "downloading"
+          });
+        }
+      }).catch(() => {
+      });
+    })();
+    return () => {
+      cancelled = true;
+      clearWatchdog();
+      unsubscribeCrash?.();
+      clientRef.current?.terminate();
+      clientRef.current = null;
+    };
+  }, [modelId]);
+  const generate = useCallback(
+    async (messages) => {
+      if (statusRef.current !== "ready" || !clientRef.current) {
+        throw new HookNotReadyError();
+      }
+      if (isGeneratingRef.current) {
+        throw new HookBusyError();
+      }
+      isGeneratingRef.current = true;
+      setIsGenerating(true);
+      setGenerationError(null);
+      try {
+        return await clientRef.current.generate(messages);
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        setGenerationError(error);
+        throw error;
+      } finally {
+        isGeneratingRef.current = false;
+        setIsGenerating(false);
+      }
+    },
+    []
+  );
+  const streamGenerate = useCallback(
+    (messages) => streamGenerateImpl(
+      statusRef,
+      clientRef,
+      isGeneratingRef,
+      setIsGenerating,
+      setGenerationError,
+      messages
+    ),
+    []
+  );
+  const abort = useCallback(() => {
+    clientRef.current?.abort().catch(() => {
+    });
+  }, []);
+  return {
+    ...state,
+    isGenerating,
+    generationError,
+    generate,
+    streamGenerate,
+    abort
+  };
+}
+async function* streamGenerateImpl(statusRef, clientRef, isGeneratingRef, setIsGenerating, setGenerationError, messages) {
+  if (statusRef.current !== "ready" || !clientRef.current) {
+    throw new HookNotReadyError();
+  }
+  if (isGeneratingRef.current) {
+    throw new HookBusyError();
+  }
+  const client = clientRef.current;
+  isGeneratingRef.current = true;
+  setIsGenerating(true);
+  setGenerationError(null);
+  try {
+    yield* toAsyncGenerator((onToken) => client.streamGenerate(messages, onToken));
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    setGenerationError(error);
+    throw error;
+  } finally {
+    isGeneratingRef.current = false;
+    setIsGenerating(false);
+    client.abort().catch(() => {
+    });
+  }
+}
+
+// src/index.ts
+var USE_BROWSER_LLM_VERSION = "0.1.0";
+export {
+  HookBusyError,
+  HookNotReadyError,
+  USE_BROWSER_LLM_VERSION,
+  UnsupportedError,
+  WorkerCrashError,
+  useBrowserLLM
+};

package/dist/worker.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/worker.js

@@ -0,0 +1,44 @@
+// src/worker.ts
+import * as Comlink from "comlink";
+import { hasModelInCache, MLCEngine } from "@mlc-ai/web-llm";
+
+// src/engine-api-factory.ts
+function createEngineAPI(engine, checkCache) {
+  return {
+    async loadModel(modelId, onProgress) {
+      engine.setInitProgressCallback(onProgress);
+      await engine.reload(modelId);
+    },
+    async generate(messages) {
+      const completion = await engine.chatCompletion({
+        messages,
+        stream: false
+      });
+      return completion.choices[0]?.message.content ?? "";
+    },
+    async streamGenerate(messages, onToken) {
+      const stream = await engine.chatCompletion({
+        messages,
+        stream: true
+      });
+      for await (const chunk of stream) {
+        const token = chunk.choices[0]?.delta.content;
+        if (token) {
+          onToken(token);
+        }
+      }
+    },
+    async abort() {
+      await engine.interruptGenerate();
+    },
+    async unload() {
+      await engine.unload();
+    },
+    async checkCache(modelId) {
+      return checkCache(modelId);
+    }
+  };
+}
+
+// src/worker.ts
+Comlink.expose(createEngineAPI(new MLCEngine(), hasModelInCache));

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "use-browser-llm",
+  "version": "0.1.0",
+  "description": "Headless React hook for running LLMs locally in the browser via WebGPU, with zero backend and complete privacy.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Muhammad-UmairAli/use-browser-llm.git"
+  },
+  "homepage": "https://github.com/Muhammad-UmairAli/use-browser-llm#readme",
+  "bugs": {
+    "url": "https://github.com/Muhammad-UmairAli/use-browser-llm/issues"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "peerDependencies": {
+    "react": ">=18"
+  },
+  "dependencies": {
+    "@mlc-ai/web-llm": "^0.2.79",
+    "comlink": "^4.4.2"
+  },
+  "devDependencies": {
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/react": "^16.3.2",
+    "@types/node": "^22.10.5",
+    "@types/react": "^18.3.18",
+    "@types/react-dom": "^18.3.7",
+    "@vitest/browser": "2.1.9",
+    "@webgpu/types": "^0.1.71",
+    "eslint": "^9.18.0",
+    "eslint-config-prettier": "^9.1.0",
+    "jsdom": "^29.1.1",
+    "playwright": "^1.61.1",
+    "prettier": "^3.4.2",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.3",
+    "typescript-eslint": "^8.19.1",
+    "vitest": "^2.1.8"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.worker.json --noEmit",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "test:integration": "vitest run --config vitest.browser.config.ts"
+  }
+}