@modootoday/pmcp 0.9.2 → 0.10.0

package/dist/chunk-JRSR4JBR.js

@@ -0,0 +1,88 @@
+import {
+  createSkillServer
+} from "./chunk-VRZFM2M5.js";
+import {
+  attachMailbox
+} from "./chunk-HNAVQG6R.js";
+
+// src/stdio.ts
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+function resolveRoots(argv, cwd) {
+  const given = argv.filter((arg) => !arg.startsWith("-"));
+  return given.length > 0 ? given : [`${cwd}/node_modules`];
+}
+function serve(catalog, serving = {}) {
+  const options = {
+    ...catalog,
+    ...serving,
+    onReject: ({ path, reason }) => process.stderr.write(`pmcp: skipped ${path}: ${reason}
+`),
+    onWarning: ({ path, reason }) => process.stderr.write(`pmcp: warning ${path}: ${reason}
+`)
+  };
+  return serveStdio(() => createSkillServer(options), {
+    // stdout is the protocol. A diagnostic written there corrupts the stream,
+    // so out-of-band errors go to stderr and nowhere else.
+    onerror: (error) => process.stderr.write(`pmcp: ${error.message}
+`)
+  });
+}
+async function serveWithMailbox(catalog, mailbox, serving = {}) {
+  let stop;
+  const attachment = await attachMailbox({
+    ...mailbox,
+    onExpired: () => {
+      process.stderr.write("pmcp: mailbox attachment expired or superseded\n");
+      void stop?.().catch(() => {
+        process.exitCode = 1;
+      });
+    }
+  });
+  let handle;
+  try {
+    handle = serve(catalog, { ...serving, mailbox: attachment.service });
+  } catch (error) {
+    await attachment.close();
+    throw error;
+  }
+  let shutdown;
+  const onExit = () => {
+    void stop().catch(() => {
+      process.exitCode = 1;
+    });
+  };
+  stop = () => {
+    if (shutdown) return shutdown;
+    process.removeListener("SIGINT", onExit);
+    process.removeListener("SIGTERM", onExit);
+    process.stdin.removeListener("end", onExit);
+    shutdown = (async () => {
+      try {
+        await handle.close();
+      } finally {
+        await attachment.close();
+      }
+    })();
+    return shutdown;
+  };
+  process.once("SIGINT", onExit);
+  process.once("SIGTERM", onExit);
+  process.stdin.once("end", onExit);
+  return stop;
+}
+function main(argv = process.argv.slice(2)) {
+  const scopeArg = argv.find((arg) => arg.startsWith("--scope="));
+  const scopes = scopeArg ? scopeArg.slice("--scope=".length).split(",") : [];
+  serve({
+    roots: resolveRoots(argv, process.cwd()),
+    ...scopes.length > 0 ? { scopes } : {}
+  });
+}
+
+export {
+  resolveRoots,
+  serve,
+  serveWithMailbox,
+  main
+};
+//# sourceMappingURL=chunk-JRSR4JBR.js.map

package/dist/chunk-MSTKY33C.js

@@ -0,0 +1,147 @@
+import {
+  resolveEncoder
+} from "./chunk-XOH2CW6P.js";
+
+// src/config.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { parse } from "smol-toml";
+var CONFIG_FILE = "pmcp.toml";
+function embeddingSection(path, dir, value) {
+  if (value === void 0) return void 0;
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    throw new ConfigError(path, "[embedding] must be a table");
+  const section = value;
+  const allowed = /* @__PURE__ */ new Set([
+    "enabled",
+    "model",
+    "dtype",
+    "dimensions",
+    "revision",
+    "model_path",
+    "cache_dir",
+    "encoder"
+  ]);
+  for (const key of Object.keys(section)) {
+    if (!allowed.has(key))
+      throw new ConfigError(path, `unknown key [embedding] ${key}`);
+  }
+  if (section.enabled !== void 0 && typeof section.enabled !== "boolean")
+    throw new ConfigError(path, "[embedding] enabled must be a boolean");
+  const string = (key) => {
+    const item = section[key];
+    if (item === void 0) return void 0;
+    if (typeof item !== "string" || !item.trim())
+      throw new ConfigError(
+        path,
+        `[embedding] ${key} must be a non-empty string`
+      );
+    return item;
+  };
+  let encoder;
+  if (section.encoder !== void 0) {
+    if (section.encoder === null || typeof section.encoder !== "object" || Array.isArray(section.encoder))
+      throw new ConfigError(path, "[embedding.encoder] must be a table");
+    const source = section.encoder;
+    const keys = /* @__PURE__ */ new Set([
+      "query_prefix",
+      "passage_prefix",
+      "pooling",
+      "projected"
+    ]);
+    for (const key of Object.keys(source)) {
+      if (!keys.has(key))
+        throw new ConfigError(path, `unknown key [embedding.encoder] ${key}`);
+    }
+    encoder = {};
+    if (source.query_prefix !== void 0)
+      encoder = { ...encoder, queryPrefix: source.query_prefix };
+    if (source.passage_prefix !== void 0)
+      encoder = { ...encoder, passagePrefix: source.passage_prefix };
+    if (source.pooling !== void 0)
+      encoder = { ...encoder, pooling: source.pooling };
+    if (source.projected !== void 0)
+      encoder = { ...encoder, projected: source.projected };
+  }
+  const modelPath = string("model_path");
+  const cacheDir = string("cache_dir");
+  const result = {
+    modelId: string("model"),
+    dtype: string("dtype"),
+    dimensions: section.dimensions,
+    revision: string("revision"),
+    encoder,
+    enabled: section.enabled,
+    modelPath: modelPath === void 0 ? void 0 : resolve(dir, modelPath),
+    cacheDir: cacheDir === void 0 ? void 0 : resolve(dir, cacheDir)
+  };
+  try {
+    resolveEncoder(result.modelId, result);
+  } catch (error) {
+    throw new ConfigError(
+      path,
+      error instanceof Error ? error.message : "Invalid embedding configuration"
+    );
+  }
+  return result;
+}
+var ConfigError = class extends Error {
+  constructor(path, message) {
+    super(`${path}: ${message}`);
+    this.name = "ConfigError";
+  }
+};
+var PATH_KEYS = ["roots", "workspaces", "packages", "marketplaces"];
+var CATALOG_KEYS = /* @__PURE__ */ new Set([...PATH_KEYS, "scopes"]);
+function findConfig(start) {
+  let dir = resolve(start);
+  for (; ; ) {
+    const candidate = join(dir, CONFIG_FILE);
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function stringList(path, key, value) {
+  if (!Array.isArray(value) || !value.every((v) => typeof v === "string")) {
+    throw new ConfigError(path, `[catalog] ${key} must be a list of strings`);
+  }
+  return value;
+}
+function readConfig(path) {
+  const absolute = resolve(path);
+  const dir = dirname(absolute);
+  let raw;
+  try {
+    raw = parse(readFileSync(absolute, "utf8"));
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : "unreadable";
+    throw new ConfigError(absolute, reason.split("\n")[0] ?? reason);
+  }
+  const section = raw["catalog"];
+  const embedding = embeddingSection(absolute, dir, raw.embedding);
+  const configured = embedding === void 0 ? {} : { embedding };
+  if (section === void 0)
+    return { path: absolute, dir, catalog: {}, raw, ...configured };
+  if (section === null || typeof section !== "object" || Array.isArray(section)) {
+    throw new ConfigError(absolute, "[catalog] must be a table");
+  }
+  const catalog = {};
+  for (const [key, value] of Object.entries(section)) {
+    if (!CATALOG_KEYS.has(key)) {
+      throw new ConfigError(absolute, `unknown key [catalog] ${key}`);
+    }
+    const list = stringList(absolute, key, value);
+    catalog[key] = key === "scopes" ? list : list.map((p) => resolve(dir, p));
+  }
+  return { path: absolute, dir, catalog, raw, ...configured };
+}
+
+export {
+  CONFIG_FILE,
+  ConfigError,
+  findConfig,
+  readConfig
+};
+//# sourceMappingURL=chunk-MSTKY33C.js.map

package/dist/{chunk-A5NOHVHN.js → chunk-VRZFM2M5.js}

@@ -1,3 +1,10 @@
+import {
+  RUNTIMES,
+  detectRuntime,
+  registerMailboxTools,
+  verifiedRuntimesOf
+} from "./chunk-XOH2CW6P.js";
+
 // src/intent.ts
 function normaliseIntent(intent) {
   return intent.toLowerCase().replaceAll(/[^\p{L}\p{N}\s]/gu, " ").split(/\s+/u).filter(Boolean).join(" ");
@@ -935,6 +942,7 @@ function registerSkillResources(server, skills) {
 }
 
 // src/find.ts
+import { createHash as createHash2 } from "crypto";
 var DEFAULT_FIND_LIMIT = 5;
 function tokens(text) {
   return normaliseIntent(text).split(" ").filter(Boolean);
@@ -977,15 +985,17 @@ async function find(options) {
   if (semantic) {
     const embedder = options.embedder;
     const vectors = options.vectors;
-    let query = options.cache?.get(options.intent) ?? null;
+    const namespace = createHash2("sha256").update(embedder.indexKey ?? embedder.modelId).digest("hex");
+    const cacheKey = `${namespace} ${normaliseIntent(options.intent)}`;
+    let query = options.cache?.get(cacheKey) ?? null;
     if (!query) {
       query = await embedder.embed(options.intent);
-      options.cache?.put(options.intent, query);
+      options.cache?.put(cacheKey, query);
     }
     const scored = [];
     for (const entry of options.entries) {
       const vector = vectors.get(entry.name);
-      if (!vector) continue;
+      if (!vector || vector.length !== query.length) continue;
       scored.push({
         name: entry.name,
         package: entry.package,
@@ -1035,44 +1045,6 @@ function bundleSkill(entry) {
   };
 }
 
-// src/runtime.ts
-import { CLIENT_INFO_META_KEY } from "@modelcontextprotocol/server";
-var RUNTIMES = [
-  "claude-code",
-  "codex-cli",
-  "gemini-cli",
-  "grok-cli",
-  "antigravity"
-];
-var VERIFIED_RUNTIMES_KEY = "verified-runtimes";
-var isRuntime = (value) => RUNTIMES.includes(value);
-function verifiedRuntimesOf(metadata) {
-  const raw = metadata?.[VERIFIED_RUNTIMES_KEY];
-  if (raw === void 0) return [];
-  const words = typeof raw === "string" ? raw.split(/[\s,]+/u) : Array.isArray(raw) ? raw.map((word) => String(word).trim()) : [];
-  return [...new Set(words.filter(isRuntime))];
-}
-var CLIENT_PATTERNS = [
-  [/claude[-_ ]?code/u, "claude-code"],
-  [/codex/u, "codex-cli"],
-  [/gemini/u, "gemini-cli"],
-  [/grok/u, "grok-cli"],
-  [/antigravity/u, "antigravity"]
-];
-function runtimeOfClient(name) {
-  if (!name) return null;
-  const lower = name.toLowerCase();
-  for (const [pattern, runtime] of CLIENT_PATTERNS)
-    if (pattern.test(lower)) return runtime;
-  return null;
-}
-function detectRuntime(server, ctx) {
-  const envelope = ctx?.mcpReq?.envelope;
-  const fromEnvelope = envelope?.[CLIENT_INFO_META_KEY]?.name;
-  if (typeof fromEnvelope === "string") return runtimeOfClient(fromEnvelope);
-  return runtimeOfClient(server.server?.getClientVersion?.()?.name);
-}
-
 // src/server.ts
 import { readFileSync as readFileSync6 } from "fs";
 var DESCRIBE_FILE_LIMIT = FILE_LIST_LIMIT;
@@ -1292,7 +1264,7 @@ function createSkillTools(options) {
 }
 
 // src/extension/entry.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import { readFileSync as readFileSync7, readdirSync as readdirSync4, statSync as statSync6 } from "fs";
 import { basename as basename5, dirname as dirname5, join as join5, relative as relative4, sep as sep3 } from "path";
 var MAX_RESOURCES = 512;
@@ -1304,7 +1276,7 @@ function facts(path) {
   const cached = digests.get(path);
   if (cached?.key === key) return cached;
   const bytes = servedBytes(path, readFileSync7(path));
-  const digest = `sha256:${createHash2("sha256").update(bytes).digest("hex")}`;
+  const digest = `sha256:${createHash3("sha256").update(bytes).digest("hex")}`;
   const fresh = { key, digest, size: bytes.length };
   digests.set(path, fresh);
   return fresh;
@@ -1727,7 +1699,7 @@ function registerReadTool(server, tools) {
 
 // src/mcp.ts
 var SERVER_NAME = "pmcp";
-var SERVER_VERSION = "0.9.2";
+var SERVER_VERSION = "0.10.0";
 function registerSkillTools(server, tools) {
   registerCatalogTool(server, tools);
   registerFindTool(server, tools);
@@ -1743,6 +1715,7 @@ function createSkillServer(options) {
   registerSkillsExtension(server, tools.skills, options.skillsExtension);
   registerSkillResources(server, tools.skills);
   if (options.prompts) registerSkillPrompts(server, tools);
+  if (options.mailbox) registerMailboxTools(server, options.mailbox);
   return registerSkillTools(server, tools);
 }
 
@@ -1782,10 +1755,6 @@ export {
   cosine,
   find,
   bundleSkill,
-  RUNTIMES,
-  verifiedRuntimesOf,
-  runtimeOfClient,
-  detectRuntime,
   DESCRIBE_FILE_LIMIT,
   CATALOG_PAGE_SIZE,
   CATALOG_PAGE_MAX,
@@ -1802,4 +1771,4 @@ export {
   registerSkillTools,
   createSkillServer
 };
-//# sourceMappingURL=chunk-A5NOHVHN.js.map
+//# sourceMappingURL=chunk-VRZFM2M5.js.map

package/dist/chunk-XEH4ZGGJ.js

@@ -0,0 +1,336 @@
+import {
+  normaliseIntent
+} from "./chunk-VRZFM2M5.js";
+import {
+  openSqlite,
+  resolveEncoder
+} from "./chunk-XOH2CW6P.js";
+
+// src/cache.ts
+async function openDatabase(path) {
+  try {
+    return await openSqlite(path);
+  } catch {
+    return null;
+  }
+}
+var DEFAULT_INTENT_CACHE_LIMIT = 4096;
+var SCHEMA = `
+  CREATE TABLE IF NOT EXISTS intent_vector (
+    intent   TEXT    NOT NULL PRIMARY KEY,
+    model_id TEXT    NOT NULL,
+    dims     INTEGER NOT NULL,
+    vector   BLOB    NOT NULL,
+    used_at  INTEGER NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS intent_vector_used_at ON intent_vector (used_at);
+`;
+async function openIntentCache(options) {
+  const opened = await openDatabase(options.path);
+  if (!opened) return null;
+  const { db, provider } = opened;
+  try {
+    db.exec("PRAGMA journal_mode = WAL");
+    db.exec(SCHEMA);
+  } catch {
+    db.close();
+    return null;
+  }
+  const limit = options.limit ?? DEFAULT_INTENT_CACHE_LIMIT;
+  const now = options.now ?? (() => Date.now());
+  let hits = 0;
+  let misses = 0;
+  let mismatched = 0;
+  const selectRow = db.prepare("SELECT model_id, dims, vector FROM intent_vector WHERE intent = ?");
+  const touch = db.prepare(
+    "UPDATE intent_vector SET used_at = ? WHERE intent = ?"
+  );
+  const upsert = db.prepare(
+    `INSERT INTO intent_vector (intent, model_id, dims, vector, used_at)
+     VALUES (?, ?, ?, ?, ?)
+     ON CONFLICT(intent) DO UPDATE SET
+       model_id = excluded.model_id,
+       dims     = excluded.dims,
+       vector   = excluded.vector,
+       used_at  = excluded.used_at`
+  );
+  const countRows = db.prepare(
+    "SELECT count(*) AS n FROM intent_vector"
+  );
+  const evict = db.prepare(
+    `DELETE FROM intent_vector WHERE intent IN (
+       SELECT intent FROM intent_vector ORDER BY used_at ASC LIMIT ?
+     )`
+  );
+  return {
+    get(intent) {
+      const key = normaliseIntent(intent);
+      const row = selectRow.get(key) ?? null;
+      if (!row) {
+        misses += 1;
+        return null;
+      }
+      if (row.model_id !== options.modelId || row.dims !== options.dims) {
+        mismatched += 1;
+        return null;
+      }
+      hits += 1;
+      touch.run(now(), key);
+      const bytes = row.vector;
+      return new Float32Array(
+        bytes.buffer.slice(
+          bytes.byteOffset,
+          bytes.byteOffset + bytes.byteLength
+        )
+      );
+    },
+    put(intent, vector) {
+      if (vector.length !== options.dims) {
+        throw new Error(
+          `intent vector is ${vector.length} wide, cache holds ${options.dims}`
+        );
+      }
+      const key = normaliseIntent(intent);
+      upsert.run(
+        key,
+        options.modelId,
+        options.dims,
+        new Uint8Array(vector.buffer, vector.byteOffset, vector.byteLength),
+        now()
+      );
+      const rows = countRows.get()?.n ?? 0;
+      if (rows > limit) evict.run(rows - limit);
+    },
+    stats() {
+      return {
+        hits,
+        misses,
+        mismatched,
+        rows: countRows.get()?.n ?? 0,
+        provider
+      };
+    },
+    close() {
+      db.close();
+    }
+  };
+}
+
+// src/embed.ts
+import { resolve } from "path";
+var ENTRY_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS entry_vector (
+    name TEXT NOT NULL,
+    model_id TEXT NOT NULL,
+    dims INTEGER NOT NULL,
+    description_hash TEXT NOT NULL,
+    vector BLOB NOT NULL,
+    PRIMARY KEY (name, model_id)
+  );
+`;
+var TRANSFORMERS = "@huggingface/transformers";
+function pretrainedFactory(value) {
+  if (!value || !["object", "function"].includes(typeof value)) return null;
+  const candidate = value;
+  return typeof candidate.from_pretrained === "function" ? candidate : null;
+}
+async function loadProjectedEncoder(module, selected, source, options) {
+  const tokenizers = pretrainedFactory(module.AutoTokenizer);
+  const models = pretrainedFactory(module.AutoModel);
+  if (!tokenizers || !models) return null;
+  const settings = {
+    dtype: selected.dtype,
+    revision: selected.revision,
+    local_files_only: options.localOnly ?? false
+  };
+  if (options.cacheDir !== void 0) settings.cache_dir = options.cacheDir;
+  const modelSettings = { ...settings };
+  if (selected.modelId === "onnx-community/embeddinggemma-2-ONNX") {
+    const configurations = pretrainedFactory(module.AutoConfig);
+    if (!configurations) return null;
+    const config = await configurations.from_pretrained(
+      source,
+      settings
+    );
+    config.vision_config = null;
+    config.audio_config = null;
+    modelSettings.config = config;
+  }
+  const tokenizer = await tokenizers.from_pretrained(source, settings);
+  const model = await models.from_pretrained(source, modelSettings);
+  return async (text) => {
+    const output = await model(
+      tokenizer(text, { padding: true, truncation: true })
+    );
+    const vector = output.sentence_embedding;
+    const gemma = selected.modelId.startsWith("onnx-community/embeddinggemma-");
+    if (!vector || vector.data.length === 0 || gemma && vector.data.length !== 768)
+      throw new Error(
+        "EmbeddingGemma requires its projected 768-dimensional sentence_embedding"
+      );
+    if (!Array.from(vector.data).every(Number.isFinite))
+      throw new Error("EmbeddingGemma returned a non-finite embedding");
+    return vector;
+  };
+}
+async function loadEmbedder(modelId, options = {}) {
+  const selected = resolveEncoder(modelId, options);
+  let module;
+  try {
+    module = options.module ?? await import(TRANSFORMERS);
+  } catch {
+    return null;
+  }
+  let source = options.modelPath ?? selected.modelId;
+  if (options.localOnly && !options.modelPath) {
+    const cache = options.cacheDir ?? module.env?.cacheDir;
+    if (typeof cache !== "string")
+      throw new Error("Provide modelPath or cacheDir for an offline encoder");
+    source = resolve(
+      cache,
+      selected.modelId,
+      selected.revision === "main" ? "." : selected.revision
+    );
+  }
+  const spec = selected.encoder;
+  let encode;
+  if (spec.projected) {
+    const projected = await loadProjectedEncoder(
+      module,
+      selected,
+      source,
+      options
+    );
+    if (!projected) return null;
+    encode = projected;
+  } else {
+    const factory = module.pipeline;
+    if (typeof factory !== "function") return null;
+    encode = await factory("feature-extraction", source, {
+      dtype: selected.dtype,
+      revision: selected.revision,
+      cache_dir: options.cacheDir,
+      local_files_only: options.localOnly ?? false
+    });
+  }
+  let dims = 0;
+  const run = async (text) => {
+    const output = await encode(text, {
+      pooling: spec.pooling,
+      normalize: true
+    });
+    let vector = Float32Array.from(output.data);
+    if (vector.length === 0 || !vector.every(Number.isFinite))
+      throw new Error("Encoder returned an invalid embedding");
+    if (selected.dimensions !== void 0) {
+      if (selected.dimensions > vector.length)
+        throw new Error(
+          "Encoder output is smaller than the requested dimensions"
+        );
+      vector = vector.slice(0, selected.dimensions);
+      const norm = Math.hypot(...vector);
+      if (norm === 0 || !Number.isFinite(norm))
+        throw new Error("Encoder returned a zero embedding");
+      vector = vector.map((value) => value / norm);
+    }
+    dims = vector.length;
+    return vector;
+  };
+  return {
+    modelId: selected.modelId,
+    indexKey: selected.indexKey,
+    get dims() {
+      return dims;
+    },
+    embed: (text) => run(spec.queryPrefix + text),
+    embedPassage: (text) => run(spec.passagePrefix + text)
+  };
+}
+async function encodeEntries(embedder, entries, previous = /* @__PURE__ */ new Map()) {
+  const out = /* @__PURE__ */ new Map();
+  const passage = (text) => embedder.embedPassage ? embedder.embedPassage(text) : embedder.embed(text);
+  for (const entry of entries) {
+    const hash = describeHash(entry.description);
+    const kept = previous.get(entry.name);
+    if (kept && kept.hash === hash) {
+      out.set(entry.name, kept);
+      continue;
+    }
+    out.set(entry.name, { hash, vector: await passage(entry.description) });
+  }
+  return out;
+}
+function describeHash(description) {
+  let hash = 2166136261;
+  for (let i = 0; i < description.length; i++) {
+    hash ^= description.charCodeAt(i);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+async function openEntryVectors(path, options = {}) {
+  const opened = options.readOnly ? await openSqlite(path, options).catch(() => null) : await openDatabase(path);
+  if (opened === null) return null;
+  const db = opened.db;
+  if (!options.readOnly) db.exec(ENTRY_SCHEMA);
+  return {
+    read(modelId) {
+      const out = /* @__PURE__ */ new Map();
+      const rows = db.prepare(
+        "SELECT name, dims, vector FROM entry_vector WHERE model_id = ?"
+      ).all(modelId);
+      for (const row of rows) {
+        const bytes = row.vector;
+        const vector = new Float32Array(
+          bytes.buffer.slice(
+            bytes.byteOffset,
+            bytes.byteOffset + bytes.byteLength
+          )
+        );
+        if (vector.length === row.dims) out.set(row.name, vector);
+      }
+      return out;
+    },
+    stale(modelId, entries) {
+      const rows = db.prepare(
+        "SELECT name, description_hash FROM entry_vector WHERE model_id = ?"
+      ).all(modelId);
+      const stored = new Map(
+        rows.map((row) => [row.name, row.description_hash])
+      );
+      const out = [];
+      for (const [name, description] of entries) {
+        if (stored.get(name) !== describeHash(description)) out.push(name);
+      }
+      return out;
+    },
+    write(modelId, name, description, vector) {
+      db.prepare(
+        `INSERT INTO entry_vector (name, model_id, dims, description_hash, vector)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(name, model_id) DO UPDATE SET
+           dims = excluded.dims,
+           description_hash = excluded.description_hash,
+           vector = excluded.vector`
+      ).run(
+        name,
+        modelId,
+        vector.length,
+        describeHash(description),
+        new Uint8Array(vector.buffer, vector.byteOffset, vector.byteLength)
+      );
+    },
+    close() {
+      db.close();
+    }
+  };
+}
+
+export {
+  DEFAULT_INTENT_CACHE_LIMIT,
+  openIntentCache,
+  loadEmbedder,
+  encodeEntries,
+  openEntryVectors
+};
+//# sourceMappingURL=chunk-XEH4ZGGJ.js.map