tryharness 0.7.22 → 0.7.25

package/lib/worktrees.mjs

@@ -6,12 +6,25 @@ import { spawnSync } from "node:child_process";
 // at once without touching each other's files or the person's checkout. Each agent turn is committed on the branch,
 // which gives every turn its diff; merge and discard are the person's, never the swarm's.
 
-const IDENTITY = ["-c", "user.name=Harness", "-c", "user.email=harness@localhost"];
+const IDENTITY = [
+  "-c",
+  "user.name=Harness",
+  "-c",
+  "user.email=harness@localhost",
+];
 const PATCH_LIMIT = 200_000;
 
 function git(cwd, args) {
-  const result = spawnSync("git", [...IDENTITY, ...args], { cwd, encoding: "utf8", maxBuffer: 16 * 1024 * 1024 });
-  return { ok: result.status === 0, out: (result.stdout || "").trim(), err: (result.stderr || "").trim() };
+  const result = spawnSync("git", [...IDENTITY, ...args], {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: 16 * 1024 * 1024,
+  });
+  return {
+    ok: result.status === 0,
+    out: (result.stdout || "").trim(),
+    err: (result.stderr || "").trim(),
+  };
 }
 
 /** The repository a folder is in, and the folder's place inside it; null when it is not in one. */
@@ -21,7 +34,10 @@ export function repositoryOf(folder) {
   if (!top.ok || !top.out) return null;
   const head = git(folder, ["rev-parse", "--verify", "HEAD"]);
   if (!head.ok) return null;
-  return { root: fs.realpathSync(top.out), inside: path.relative(fs.realpathSync(top.out), fs.realpathSync(folder)) };
+  return {
+    root: fs.realpathSync(top.out),
+    inside: path.relative(fs.realpathSync(top.out), fs.realpathSync(folder)),
+  };
 }
 
 /**
@@ -31,20 +47,38 @@ export function repositoryOf(folder) {
  */
 export function mainCheckout(folder) {
   if (!folder || !fs.existsSync(folder)) return folder;
-  const found = git(folder, ["rev-parse", "--path-format=absolute", "--show-toplevel", "--git-common-dir"]);
+  const found = git(folder, [
+    "rev-parse",
+    "--path-format=absolute",
+    "--show-toplevel",
+    "--git-common-dir",
+  ]);
   const [top, common] = found.ok ? found.out.split("\n") : [];
   if (!top || !common || path.basename(common) !== ".git") return folder;
   const main = path.dirname(common);
-  if (!fs.existsSync(main) || fs.realpathSync(main) === fs.realpathSync(top)) return folder;
-  return path.join(main, path.relative(fs.realpathSync(top), fs.realpathSync(folder)));
+  if (!fs.existsSync(main) || fs.realpathSync(main) === fs.realpathSync(top))
+    return folder;
+  return path.join(
+    main,
+    path.relative(fs.realpathSync(top), fs.realpathSync(folder))
+  );
 }
 
-const slug = (text) => String(text).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 32) || "thread";
+const slug = (text) =>
+  String(text)
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "")
+    .slice(0, 32) || "thread";
 
 export function createWorktrees({ store, root }) {
   const key = (threadId) => `worktree:${threadId}`;
-  const get = (threadId) => { const raw = store.meta(key(threadId)); return raw ? JSON.parse(raw) : null; };
-  const save = (threadId, value) => store.meta(key(threadId), value ? JSON.stringify(value) : "null");
+  const get = (threadId) => {
+    const raw = store.meta(key(threadId));
+    return raw ? JSON.parse(raw) : null;
+  };
+  const save = (threadId, value) =>
+    store.meta(key(threadId), value ? JSON.stringify(value) : "null");
 
   /** Where a thread's coding runs work: its worktree when the folder is in a repository, else the folder itself. */
   const folderFor = (thread) => {
@@ -52,27 +86,54 @@ export function createWorktrees({ store, root }) {
     if (!folder) return null;
     const current = get(thread.id);
     if (current?.state === "in_place") return folder;
-    if (current?.state === "t3") return current.path && fs.existsSync(current.path) ? current.path : folder;
-    if (current && current.state === "open" && fs.existsSync(current.path)) return path.join(current.path, current.inside);
+    if (current?.state === "t3")
+      return current.path && fs.existsSync(current.path)
+        ? current.path
+        : folder;
+    if (current && current.state === "open" && fs.existsSync(current.path))
+      return path.join(current.path, current.inside);
     const repo = repositoryOf(folder);
     if (!repo) return folder;
     const where = path.join(root, thread.id);
     const branch = `harness/${slug(thread.objective)}-${thread.id.slice(0, 8)}`;
     const base = git(repo.root, ["rev-parse", "HEAD"]).out;
     fs.mkdirSync(root, { recursive: true });
-    const added = git(repo.root, ["worktree", "add", "-b", branch, where, base]);
-    if (!added.ok) throw new Error(`could not make the thread's copy of ${repo.root}: ${added.err}`);
-    save(thread.id, { state: "open", repo: repo.root, inside: repo.inside, path: where, branch, base });
+    const added = git(repo.root, [
+      "worktree",
+      "add",
+      "-b",
+      branch,
+      where,
+      base,
+    ]);
+    if (!added.ok)
+      throw new Error(
+        `could not make the thread's copy of ${repo.root}: ${added.err}`
+      );
+    save(thread.id, {
+      state: "open",
+      repo: repo.root,
+      inside: repo.inside,
+      path: where,
+      branch,
+      base,
+    });
     return path.join(where, repo.inside);
   };
 
   /** Commits what a turn changed on the thread's branch; the commit is that turn's diff. Null when nothing changed. */
   const commitTurn = (threadId, runId, message) => {
     const tree = get(threadId);
-    if (!tree || tree.state !== "open" || !fs.existsSync(tree.path)) return null;
+    if (!tree || tree.state !== "open" || !fs.existsSync(tree.path))
+      return null;
     git(tree.path, ["add", "-A"]);
     if (git(tree.path, ["diff", "--cached", "--quiet"]).ok) return null;
-    const committed = git(tree.path, ["commit", "-q", "-m", String(message).slice(0, 200)]);
+    const committed = git(tree.path, [
+      "commit",
+      "-q",
+      "-m",
+      String(message).slice(0, 200),
+    ]);
     if (!committed.ok) return null;
     const sha = git(tree.path, ["rev-parse", "HEAD"]).out;
     store.meta(`turn:${runId}`, sha);
@@ -81,30 +142,53 @@ export function createWorktrees({ store, root }) {
 
   const stat = (cwd, range) => {
     const out = git(cwd, ["diff", "--numstat", range]).out;
-    const files = out ? out.split("\n").map((line) => { const [added, removed, file] = line.split("\t"); return { file, added: Number(added) || 0, removed: Number(removed) || 0 }; }) : [];
+    const files = out
+      ? out.split("\n").map((line) => {
+          const [added, removed, file] = line.split("\t");
+          return {
+            file,
+            added: Number(added) || 0,
+            removed: Number(removed) || 0,
+          };
+        })
+      : [];
     return files;
   };
 
   /** What a thread changed: everything since it began, or one turn's commit. */
   const diff = (threadId, runId = null) => {
     const tree = get(threadId);
-    if (!tree) return { ok: false, error: "this thread has no copy of a repository" };
+    if (!tree)
+      return { ok: false, error: "this thread has no copy of a repository" };
     const cwd = fs.existsSync(tree.path) ? tree.path : tree.repo;
     let range;
     if (runId) {
       const sha = store.meta(`turn:${runId}`);
       if (!sha) return { ok: true, files: [], patch: "" };
       range = `${sha}~1..${sha}`;
-    } else range = `${tree.base}..${tree.state === "open" ? "HEAD" : tree.branch}`;
+    } else
+      range = `${tree.base}..${tree.state === "open" ? "HEAD" : tree.branch}`;
     const patch = git(cwd, ["diff", range]).out;
-    return { ok: true, files: stat(cwd, range), patch: patch.length > PATCH_LIMIT ? `${patch.slice(0, PATCH_LIMIT)}\n… (cut here; the rest is on branch ${tree.branch})` : patch, branch: tree.branch, state: tree.state };
+    return {
+      ok: true,
+      files: stat(cwd, range),
+      patch:
+        patch.length > PATCH_LIMIT
+          ? `${patch.slice(0, PATCH_LIMIT)}\n… (cut here; the rest is on branch ${tree.branch})`
+          : patch,
+      branch: tree.branch,
+      state: tree.state,
+    };
   };
 
   const summary = (threadId) => {
     const tree = get(threadId);
     // A thread T3 Code works in keeps its changes in T3's own checkout, where T3 shows and merges them.
     if (!tree || tree.state === "in_place" || tree.state === "t3") return null;
-    const files = tree.state === "open" && fs.existsSync(tree.path) ? stat(tree.path, `${tree.base}..HEAD`).length : 0;
+    const files =
+      tree.state === "open" && fs.existsSync(tree.path)
+        ? stat(tree.path, `${tree.base}..HEAD`).length
+        : 0;
     return { state: tree.state, branch: tree.branch, repo: tree.repo, files };
   };
 
@@ -116,26 +200,54 @@ export function createWorktrees({ store, root }) {
   /** Brings the thread's branch into the branch the person has checked out. A conflict is undone and reported. */
   const merge = (threadId, title) => {
     const tree = get(threadId);
-    if (!tree || tree.state !== "open") return { ok: false, error: "there is nothing of this thread's to merge" };
-    if (!stat(tree.path, `${tree.base}..HEAD`).length) return { ok: false, error: "this thread has not changed anything" };
+    if (!tree || tree.state !== "open")
+      return { ok: false, error: "there is nothing of this thread's to merge" };
+    if (!stat(tree.path, `${tree.base}..HEAD`).length)
+      return { ok: false, error: "this thread has not changed anything" };
     const into = git(tree.repo, ["rev-parse", "--abbrev-ref", "HEAD"]).out;
-    const merged = git(tree.repo, ["merge", "--no-ff", "-m", `Merge ${tree.branch}: ${String(title).slice(0, 120)}`, tree.branch]);
+    const merged = git(tree.repo, [
+      "merge",
+      "--no-ff",
+      "-m",
+      `Merge ${tree.branch}: ${String(title).slice(0, 120)}`,
+      tree.branch,
+    ]);
     if (!merged.ok) {
-      const conflicts = git(tree.repo, ["diff", "--name-only", "--diff-filter=U"]).out.split("\n").filter(Boolean);
+      const conflicts = git(tree.repo, [
+        "diff",
+        "--name-only",
+        "--diff-filter=U",
+      ])
+        .out.split("\n")
+        .filter(Boolean);
       git(tree.repo, ["merge", "--abort"]);
-      return { ok: false, conflict: true, files: conflicts, error: conflicts.length
-        ? `merging into ${into} conflicts in ${conflicts.join(", ")}; nothing was merged`
-        : `git would not merge into ${into}: ${merged.err.split("\n")[0]}; nothing was merged` };
+      return {
+        ok: false,
+        conflict: true,
+        files: conflicts,
+        error: conflicts.length
+          ? `merging into ${into} conflicts in ${conflicts.join(", ")}; nothing was merged`
+          : `git would not merge into ${into}: ${merged.err.split("\n")[0]}; nothing was merged`,
+      };
     }
     retire(tree);
     git(tree.repo, ["branch", "-d", tree.branch]);
-    save(threadId, { ...tree, state: "merged", into, mergedAt: new Date().toISOString() });
+    save(threadId, {
+      ...tree,
+      state: "merged",
+      into,
+      mergedAt: new Date().toISOString(),
+    });
     return { ok: true, into };
   };
 
   const discard = (threadId) => {
     const tree = get(threadId);
-    if (!tree || tree.state !== "open") return { ok: false, error: "there is nothing of this thread's to discard" };
+    if (!tree || tree.state !== "open")
+      return {
+        ok: false,
+        error: "there is nothing of this thread's to discard",
+      };
     retire(tree);
     git(tree.repo, ["branch", "-D", tree.branch]);
     save(threadId, { ...tree, state: "discarded" });
@@ -149,7 +261,11 @@ export function createWorktrees({ store, root }) {
   const moved = (threadId) => {
     const tree = get(threadId);
     if (tree?.state === "open" && fs.existsSync(tree.path)) {
-      if (stat(tree.path, `${tree.base}..HEAD`).length) return { ok: false, error: `this thread changed files on ${tree.branch}; merge or discard them first` };
+      if (stat(tree.path, `${tree.base}..HEAD`).length)
+        return {
+          ok: false,
+          error: `this thread changed files on ${tree.branch}; merge or discard them first`,
+        };
       retire(tree);
       git(tree.repo, ["branch", "-D", tree.branch]);
     }
@@ -168,19 +284,51 @@ export function createWorktrees({ store, root }) {
    */
   const t3Workspace = (thread) => {
     const current = get(thread.id);
-    if (current?.state === "in_place" || current?.inPlace) return { type: "root" };
-    if ((current?.state === "t3" || current?.state === "open") && current.path) return { type: "existing_worktree", worktreePath: current.path, ...(current.branch ? { branch: current.branch } : {}) };
+    if (current?.state === "in_place" || current?.inPlace)
+      return { type: "root" };
+    if ((current?.state === "t3" || current?.state === "open") && current.path)
+      return {
+        type: "existing_worktree",
+        worktreePath: current.path,
+        ...(current.branch ? { branch: current.branch } : {}),
+      };
     const repo = repositoryOf(thread.goal.workspace);
     if (!repo) return { type: "root" };
     const branch = git(repo.root, ["rev-parse", "--abbrev-ref", "HEAD"]).out;
-    return { type: "worktree", baseRef: branch && branch !== "HEAD" ? branch : git(repo.root, ["rev-parse", "HEAD"]).out,
-      branch: `harness/${slug(thread.objective)}-${thread.id.slice(0, 8)}`, startFromOrigin: false };
+    return {
+      type: "worktree",
+      baseRef:
+        branch && branch !== "HEAD"
+          ? branch
+          : git(repo.root, ["rev-parse", "HEAD"]).out,
+      branch: `harness/${slug(thread.objective)}-${thread.id.slice(0, 8)}`,
+      startFromOrigin: false,
+    };
   };
   /** The thread works in T3 Code from now on; `where` and `branch` once T3 has made its checkout. */
   const inT3 = (threadId, where = null, branch = null) => {
     const current = get(threadId);
-    if (current?.state !== "t3" || (where && where !== current.path)) save(threadId, { ...current, ...(current?.state === "in_place" ? { inPlace: true } : {}), state: "t3", path: where ?? current?.path ?? null, branch: branch ?? current?.branch ?? null });
+    if (current?.state !== "t3" || (where && where !== current.path))
+      save(threadId, {
+        ...current,
+        ...(current?.state === "in_place" ? { inPlace: true } : {}),
+        state: "t3",
+        path: where ?? current?.path ?? null,
+        branch: branch ?? current?.branch ?? null,
+      });
   };
 
-  return { folderFor, commitTurn, diff, summary, merge, discard, moved, inPlace, t3Workspace, inT3, get };
+  return {
+    folderFor,
+    commitTurn,
+    diff,
+    summary,
+    merge,
+    discard,
+    moved,
+    inPlace,
+    t3Workspace,
+    inT3,
+    get,
+  };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tryharness",
-  "version": "0.7.22",
+  "version": "0.7.25",
   "description": "Harness Relay: the daemon that turns the agents on this machine into your personal swarm. Memory, history, and work handed between any of them.",
   "bin": {
     "tryharness": "cli.mjs"
@@ -32,15 +32,17 @@
     "@clack/core": "0.5.0",
     "@clack/prompts": "0.11.0",
     "@huggingface/tokenizers": "^0.1.3",
+    "jpeg-js": "0.4.4",
     "node-sqlite3-wasm": "0.8.60",
-    "onnxruntime-web": "1.26.0-dev.20260416-b7804b056c",
+    "onnxruntime-node": "1.24.3",
     "picocolors": "^1.1.1",
+    "pngjs": "7.0.0",
     "qr": "0.4.2",
     "ws": "^8.18.3"
   },
   "optionalDependencies": {
-    "tryharness-desktop-darwin-arm64": "0.7.22",
-    "tryharness-desktop-darwin-x64": "0.7.22",
+    "tryharness-desktop-darwin-arm64": "0.7.25",
+    "tryharness-desktop-darwin-x64": "0.7.25",
     "tryharness-desktop-linux-x64": "0.7.4",
     "tryharness-desktop-win32-x64": "0.7.4"
   }

package/lib/embedder.mjs

@@ -1,156 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { ensureDir } from "./files.mjs";
-
-// The daemon's own embedder for the context space: the same model, quantization, pooling
-// and normalization as the browser (src/shared/memory/embeddingService.ts), so the two
-// sides describe the same space under the same version key. It runs on onnxruntime-web's
-// Node build (wasm, no native addon) with the same tokenizer library transformers.js uses,
-// and mirrors transformers' feature-extraction pipeline step by step: tokenize with special
-// tokens, truncate to the model's 512, pad to the batch, take the [CLS] vector, L2-normalize.
-// Weights are downloaded into the Harness home during setup, never fetched from a browser.
-
-export const EMBEDDING_MODEL = "Xenova/bge-base-en-v1.5";
-export const EMBEDDING_DIMENSIONS = 768;
-export const EMBEDDING_VERSION = "bge-base-en-v1.5:q8:cls:l2:asymmetric:v1";
-const QUERY_PREFIX = "Represent this sentence for searching relevant passages: ";
-const MODEL_FILES = ["config.json", "tokenizer.json", "tokenizer_config.json", "onnx/model_quantized.onnx"];
-const REMOTE = `https://huggingface.co/${EMBEDDING_MODEL}/resolve/main/`;
-// One text per run: a q8 model quantizes per batch tensor, so the same text in different company
-// differs in the last decimals (transformers.js shows the same, cosine 0.992 alone versus batched).
-// Entries arrive one at a time and a vector must not depend on its neighbours, so no batching.
-const BATCH = 1;
-
-export function modelDirectory(modelsDir) {
-  return path.join(modelsDir, ...EMBEDDING_MODEL.split("/"));
-}
-
-/** True when every model file is present and non-empty. */
-export function modelPresent(modelsDir) {
-  const dir = modelDirectory(modelsDir);
-  return MODEL_FILES.every((file) => {
-    try { return fs.statSync(path.join(dir, file)).size > 0; } catch { return false; }
-  });
-}
-
-async function download(url, target, { fetchImpl, log }) {
-  const partial = `${target}.partial`;
-  ensureDir(path.dirname(target));
-  let have = 0;
-  try { have = fs.statSync(partial).size; } catch {}
-  const headers = have > 0 ? { range: `bytes=${have}-` } : {};
-  const response = await fetchImpl(url, { headers, redirect: "follow" });
-  if (response.status === 416) { fs.renameSync(partial, target); return; }
-  if (!response.ok) throw new Error(`download of ${path.basename(target)} failed: HTTP ${response.status}`);
-  const resumed = response.status === 206;
-  const total = Number(response.headers.get("content-length") || 0) + (resumed ? have : 0);
-  const out = fs.createWriteStream(partial, { flags: resumed ? "a" : "w" });
-  let done = resumed ? have : 0;
-  let shown = -1;
-  const name = path.basename(target);
-  for await (const chunk of response.body) {
-    if (!out.write(chunk)) await new Promise((resolve) => out.once("drain", resolve));
-    done += chunk.length;
-    const percent = total ? Math.floor((done / total) * 10) * 10 : -1;
-    if (percent !== shown && percent >= 0) { shown = percent; log?.(`embedder: ${name} ${percent}%`); }
-  }
-  await new Promise((resolve, reject) => { out.end(); out.on("finish", resolve); out.on("error", reject); });
-  if (total && done !== total) throw new Error(`download of ${name} stopped at ${done} of ${total} bytes; run setup again to resume`);
-  fs.renameSync(partial, target);
-}
-
-/** Downloads any missing model file into modelsDir. Idempotent; a partial file resumes. */
-export async function ensureModel({ modelsDir, log = () => {}, fetchImpl = fetch } = {}) {
-  const dir = modelDirectory(modelsDir);
-  const missing = MODEL_FILES.filter((file) => { try { return fs.statSync(path.join(dir, file)).size === 0; } catch { return true; } });
-  if (!missing.length) return { downloaded: [], present: true };
-  log(`embedder: downloading ${EMBEDDING_MODEL} (${missing.length} file${missing.length === 1 ? "" : "s"}, about 110 MB) into ${modelsDir}`);
-  for (const file of missing) await download(REMOTE + file, path.join(dir, file), { fetchImpl, log });
-  log("embedder: ready");
-  return { downloaded: missing, present: true };
-}
-
-function truncate(encoded, maxLength) {
-  for (const key of Object.keys(encoded)) encoded[key] = encoded[key].slice(0, maxLength);
-}
-
-function pad(encoded, maxLength, padId) {
-  for (const key of Object.keys(encoded)) {
-    const fill = key === "input_ids" ? padId : 0;
-    while (encoded[key].length < maxLength) encoded[key].push(fill);
-  }
-}
-
-/**
- * A lazily loaded embedder over local files only. Loading the session takes about half a
- * second and inference runs on the calling thread (onnxruntime-web's Node build has no
- * worker), so each short text holds the event loop for a few tens of milliseconds;
- * callers embed in the background, never inside a request the person is waiting on.
- */
-export function createEmbedder({ modelsDir }) {
-  const dir = modelDirectory(modelsDir);
-  let loading = null;
-  const load = () => {
-    if (loading) return loading;
-    loading = (async () => {
-      if (!modelPresent(modelsDir)) throw new Error(`the embedding model is not present in ${modelsDir}; run npx tryharness to download it`);
-      const [{ Tokenizer }, ort] = await Promise.all([import("@huggingface/tokenizers"), import("onnxruntime-web")]);
-      const tokenizerJson = JSON.parse(fs.readFileSync(path.join(dir, "tokenizer.json"), "utf8"));
-      const tokenizerConfig = JSON.parse(fs.readFileSync(path.join(dir, "tokenizer_config.json"), "utf8"));
-      const modelConfig = JSON.parse(fs.readFileSync(path.join(dir, "config.json"), "utf8"));
-      const tokenizer = new Tokenizer(tokenizerJson, tokenizerConfig);
-      ort.env.wasm.numThreads = 1;
-      const session = await ort.InferenceSession.create(path.join(dir, "onnx", "model_quantized.onnx"), { executionProviders: ["wasm"] });
-      return {
-        ort, tokenizer, session,
-        maxLength: Number(tokenizerConfig.model_max_length) || 512,
-        padId: Number(modelConfig.pad_token_id ?? 0),
-        wantsTypeIds: session.inputNames.includes("token_type_ids"),
-      };
-    })();
-    loading.catch(() => { loading = null; });
-    return loading;
-  };
-
-  const embedBatch = async (texts) => {
-    const { ort, tokenizer, session, maxLength, padId, wantsTypeIds } = await load();
-    const encoded = texts.map((text) => {
-      const { ids, attention_mask, token_type_ids } = tokenizer.encode(text, { add_special_tokens: true, return_token_type_ids: true });
-      return { input_ids: [...ids], attention_mask: [...attention_mask], ...(wantsTypeIds ? { token_type_ids: [...(token_type_ids || ids.map(() => 0))] } : {}) };
-    });
-    const width = Math.min(Math.max(...encoded.map((e) => e.input_ids.length)), maxLength);
-    for (const e of encoded) {
-      if (e.input_ids.length > width) truncate(e, width);
-      else if (e.input_ids.length < width) pad(e, width, padId);
-    }
-    const tensor = (key) => new ort.Tensor("int64", BigInt64Array.from(encoded.flatMap((e) => e[key].map((v) => BigInt(v)))), [texts.length, width]);
-    const feeds = { input_ids: tensor("input_ids"), attention_mask: tensor("attention_mask"), ...(wantsTypeIds ? { token_type_ids: tensor("token_type_ids") } : {}) };
-    const outputs = await session.run(feeds);
-    const hidden = outputs.last_hidden_state;
-    const [, seq, dims] = hidden.dims;
-    const data = hidden.data;
-    return texts.map((_, row) => {
-      const start = row * seq * dims;
-      const vector = new Float32Array(dims);
-      let norm = 0;
-      for (let i = 0; i < dims; i += 1) { vector[i] = data[start + i]; norm += vector[i] * vector[i]; }
-      norm = Math.sqrt(norm) || 1;
-      for (let i = 0; i < dims; i += 1) vector[i] /= norm;
-      return vector;
-    });
-  };
-
-  return {
-    version: EMBEDDING_VERSION,
-    dimensions: EMBEDDING_DIMENSIONS,
-    ready: () => load().then(() => true),
-    async embedDocuments(texts) {
-      const out = [];
-      for (let i = 0; i < texts.length; i += BATCH) out.push(...(await embedBatch(texts.slice(i, i + BATCH))));
-      return out;
-    },
-    async embedQuery(text) {
-      return (await embedBatch([QUERY_PREFIX + text]))[0];
-    },
-  };
-}