@dikolab/kbdb 0.1.0

package/dist/kbdb-worker.cjs

@@ -0,0 +1,1659 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/worker.ts
+var import_node_fs6 = require("node:fs");
+
+// src/shared/runtime/functions/detect-runtime.ts
+function detectRuntime() {
+  if (typeof globalThis !== "undefined" && "Deno" in globalThis) {
+    return "deno";
+  }
+  return "node";
+}
+
+// src/shared/runtime/functions/get-args.ts
+function getArgs() {
+  if (detectRuntime() === "deno") {
+    const g = globalThis;
+    const deno = g["Deno"];
+    return deno?.args ?? [];
+  }
+  return process.argv.slice(2);
+}
+
+// src/shared/dir-resolver/functions/resolve-base-dir.function.ts
+var import_node_path = require("node:path");
+var import_node_url = require("node:url");
+function resolveScriptDir(entryUrl, entryDirname) {
+  if (entryDirname) return entryDirname;
+  if (entryUrl.startsWith("file:"))
+    return (0, import_node_path.dirname)((0, import_node_url.fileURLToPath)(entryUrl));
+  return (0, import_node_path.dirname)(entryUrl);
+}
+function resolveBaseDir(entryUrl, entryDirname) {
+  const scriptDir = typeof __dirname !== "undefined" ? __dirname : resolveScriptDir(entryUrl, entryDirname);
+  return { scriptDir, cwd: process.cwd() };
+}
+
+// src/shared/dir-resolver/functions/resolve-wasm-dir.function.ts
+var import_node_path2 = require("node:path");
+function resolveWasmDir(scriptDir) {
+  return (0, import_node_path2.join)(scriptDir, "wasm");
+}
+
+// src/shared/worker-daemon/functions/read-config.function.ts
+var import_node_fs = require("node:fs");
+var import_node_path3 = require("node:path");
+
+// src/shared/worker-daemon/constants/daemon-defaults.constant.ts
+var DEFAULT_ITEM_LIMIT = 1e3;
+var DEFAULT_INDEX_LIMIT = 100;
+var DEFAULT_TIMEOUT_MS = 3e5;
+var DEFAULT_ITEM_TTL_MS = 6e4;
+var WORKER_TOML_FILENAME = "worker.toml";
+var DB_FORMAT_VERSION = 1;
+
+// src/shared/worker-daemon/functions/read-config.function.ts
+function readConfig(contextPath) {
+  const configPath = (0, import_node_path3.join)(contextPath, WORKER_TOML_FILENAME);
+  try {
+    const text = (0, import_node_fs.readFileSync)(configPath, "utf-8");
+    return parseWorkerToml(text, contextPath);
+  } catch {
+    return {
+      contextPath,
+      itemLimit: DEFAULT_ITEM_LIMIT,
+      indexLimit: DEFAULT_INDEX_LIMIT,
+      timeoutMs: DEFAULT_TIMEOUT_MS,
+      itemTtlMs: DEFAULT_ITEM_TTL_MS
+    };
+  }
+}
+function parseWorkerToml(text, contextPath) {
+  const config = {
+    contextPath,
+    itemLimit: DEFAULT_ITEM_LIMIT,
+    indexLimit: DEFAULT_INDEX_LIMIT,
+    timeoutMs: DEFAULT_TIMEOUT_MS,
+    itemTtlMs: DEFAULT_ITEM_TTL_MS
+  };
+  const result = { ...config };
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#") || !trimmed.includes("=")) {
+      continue;
+    }
+    const eqIdx = trimmed.indexOf("=");
+    const key = trimmed.slice(0, eqIdx).trim();
+    const value = trimmed.slice(eqIdx + 1).trim();
+    switch (key) {
+      case "item_limit":
+        result.itemLimit = parseInt(value, 10) || DEFAULT_ITEM_LIMIT;
+        break;
+      case "index_limit":
+        result.indexLimit = parseInt(value, 10) || DEFAULT_INDEX_LIMIT;
+        break;
+      case "timeout_ms":
+        result.timeoutMs = parseInt(value, 10) || DEFAULT_TIMEOUT_MS;
+        break;
+      case "item_ttl_ms":
+        result.itemTtlMs = parseInt(value, 10) || DEFAULT_ITEM_TTL_MS;
+        break;
+      default:
+        break;
+    }
+  }
+  return result;
+}
+
+// src/shared/worker-daemon/functions/start-daemon.function.ts
+var import_node_fs5 = require("node:fs");
+var import_node_path8 = require("node:path");
+var import_node_os3 = require("node:os");
+
+// src/shared/hash/functions/compute-sha256.ts
+async function computeSha256(input) {
+  const data = new TextEncoder().encode(input);
+  const hash = await crypto.subtle.digest("SHA-256", data);
+  const bytes = new Uint8Array(hash);
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// src/shared/worker-daemon/classes/worker-daemon.class.ts
+var import_node_fs4 = require("node:fs");
+var import_node_path7 = require("node:path");
+var import_node_os2 = require("node:os");
+
+// src/shared/worker-daemon/functions/load-wasm-modules.function.ts
+var import_node_fs3 = require("node:fs");
+var import_node_path5 = require("node:path");
+
+// src/shared/worker-daemon/functions/create-host-imports.function.ts
+var import_node_fs2 = require("node:fs");
+var import_node_path4 = require("node:path");
+var nodeFsAdapter = {
+  readFileSync: (p) => (0, import_node_fs2.readFileSync)(p),
+  writeFileSync: (p, d) => {
+    (0, import_node_fs2.writeFileSync)(p, d);
+  },
+  renameSync: (o, n) => {
+    (0, import_node_fs2.renameSync)(o, n);
+  },
+  unlinkSync: (p) => {
+    (0, import_node_fs2.unlinkSync)(p);
+  },
+  readdirSync: (p) => (0, import_node_fs2.readdirSync)(p),
+  mkdirSync: (p) => {
+    (0, import_node_fs2.mkdirSync)(p, { recursive: true });
+  },
+  existsSync: (p) => (0, import_node_fs2.existsSync)(p)
+};
+var nullMemory = { memory: null };
+var nullAllocator = { alloc: null };
+function createHostImports(contextPath, memoryRef = nullMemory, fs = nodeFsAdapter, allocator = nullAllocator) {
+  function getBuffer() {
+    if (!memoryRef.memory) {
+      throw new Error("WASM memory not initialized");
+    }
+    return memoryRef.memory.buffer;
+  }
+  function readPathArg(ptr, len) {
+    const bytes = new Uint8Array(getBuffer(), ptr, len);
+    const relative = new TextDecoder().decode(bytes);
+    return (0, import_node_path4.join)(contextPath, relative);
+  }
+  return {
+    /**
+     * Reads a file at the path encoded in shared memory and writes
+     * the result back via the out-pointer protocol.
+     *
+     * `outPtr` and `outLen` are WASM linear-memory addresses. On
+     * success, the host allocates a buffer via `allocator.alloc`,
+     * copies the file data there, and writes the allocated pointer
+     * as a LE u32 to `outPtr` and the data length as a LE u32 to
+     * `outLen`. Returns 0 on success, -1 on error or when the
+     * allocator is not yet available.
+     */
+    host_read_file(pathPtr, pathLen, outPtr, outLen) {
+      try {
+        if (!allocator.alloc) return -1;
+        const filePath = readPathArg(pathPtr, pathLen);
+        const data = fs.readFileSync(filePath);
+        const dataLen = data.byteLength;
+        const dv = new DataView(getBuffer());
+        if (dataLen === 0) {
+          dv.setUint32(outPtr, 0, true);
+          dv.setUint32(outLen, 0, true);
+          return 0;
+        }
+        const dataPtr = allocator.alloc(dataLen);
+        if (dataPtr === 0) return -1;
+        const memView = new Uint8Array(getBuffer());
+        memView.set(
+          new Uint8Array(
+            data.buffer,
+            data.byteOffset,
+            data.byteLength
+          ),
+          dataPtr
+        );
+        dv.setUint32(outPtr, dataPtr, true);
+        dv.setUint32(outLen, dataLen, true);
+        return 0;
+      } catch {
+        return -1;
+      }
+    },
+    /**
+     * Writes bytes from shared memory (`dataPtr`, `dataLen`) to the
+     * file at the path encoded in shared memory. Returns 0 on
+     * success, -1 on error.
+     */
+    host_write_file(pathPtr, pathLen, dataPtr, dataLen) {
+      try {
+        const filePath = readPathArg(pathPtr, pathLen);
+        const data = new Uint8Array(getBuffer(), dataPtr, dataLen);
+        fs.writeFileSync(filePath, data);
+        return 0;
+      } catch {
+        return -1;
+      }
+    },
+    /**
+     * Renames the file at `oldPtr/oldLen` to `newPtr/newLen`.
+     * Both paths are resolved relative to `contextPath`. Returns 0
+     * on success, -1 on error.
+     */
+    host_rename(oldPtr, oldLen, newPtr, newLen) {
+      try {
+        const oldPath = readPathArg(oldPtr, oldLen);
+        const newPath = readPathArg(newPtr, newLen);
+        fs.renameSync(oldPath, newPath);
+        return 0;
+      } catch {
+        return -1;
+      }
+    },
+    /**
+     * Deletes the file at the path encoded in shared memory.
+     * Returns 0 on success, -1 on error.
+     */
+    host_remove_file(pathPtr, pathLen) {
+      try {
+        const filePath = readPathArg(pathPtr, pathLen);
+        fs.unlinkSync(filePath);
+        return 0;
+      } catch {
+        return -1;
+      }
+    },
+    /**
+     * Lists the directory at the path encoded in shared memory and
+     * writes the result back via the out-pointer protocol.
+     *
+     * `outPtr` and `outLen` are WASM linear-memory addresses. On
+     * success, the host allocates a buffer via `allocator.alloc`,
+     * copies a newline-delimited UTF-8 listing there, and writes
+     * the allocated pointer as a LE u32 to `outPtr` and the byte
+     * length as a LE u32 to `outLen`. Returns 0 on success, -1 on
+     * error or when the allocator is not yet available.
+     */
+    host_list_dir(pathPtr, pathLen, outPtr, outLen) {
+      try {
+        if (!allocator.alloc) return -1;
+        const dirPath = readPathArg(pathPtr, pathLen);
+        const entries = fs.readdirSync(dirPath);
+        const text = entries.join("\n");
+        const encoded = new TextEncoder().encode(text);
+        const dv = new DataView(getBuffer());
+        if (encoded.length === 0) {
+          dv.setUint32(outPtr, 0, true);
+          dv.setUint32(outLen, 0, true);
+          return 0;
+        }
+        const dataPtr = allocator.alloc(encoded.length);
+        if (dataPtr === 0) return -1;
+        new Uint8Array(getBuffer(), dataPtr, encoded.length).set(
+          encoded
+        );
+        dv.setUint32(outPtr, dataPtr, true);
+        dv.setUint32(outLen, encoded.length, true);
+        return 0;
+      } catch {
+        return -1;
+      }
+    },
+    /**
+     * Creates the directory at the path encoded in shared memory,
+     * including any missing parent directories (recursive). Returns
+     * 0 on success, -1 on error.
+     */
+    host_mkdir(pathPtr, pathLen) {
+      try {
+        const dirPath = readPathArg(pathPtr, pathLen);
+        fs.mkdirSync(dirPath);
+        return 0;
+      } catch {
+        return -1;
+      }
+    },
+    /**
+     * Checks whether the file at the path encoded in shared memory
+     * exists. Returns 1 if it exists, 0 if it does not.
+     */
+    host_file_exists(pathPtr, pathLen) {
+      const filePath = readPathArg(pathPtr, pathLen);
+      return fs.existsSync(filePath) ? 1 : 0;
+    }
+  };
+}
+
+// src/shared/worker-daemon/functions/load-wasm-modules.function.ts
+async function loadWasmModules(config, wasmDir2) {
+  const memoryRef = { memory: null };
+  const allocator = { alloc: null };
+  const hostImports = createHostImports(
+    config.contextPath,
+    memoryRef,
+    void 0,
+    allocator
+  );
+  const wkPath = (0, import_node_path5.join)(wasmDir2, "kb-worker", "kbdb_worker_bg.wasm");
+  const wkBytes = readWasmFileOrThrow(wkPath, "kb-worker");
+  let wkModule;
+  try {
+    wkModule = await WebAssembly.compile(wkBytes);
+  } catch (err) {
+    rethrow("compile", "kb-worker", err);
+  }
+  let kbWorker;
+  try {
+    kbWorker = await WebAssembly.instantiate(wkModule, {
+      env: { ...hostImports }
+    });
+  } catch (err) {
+    rethrow("instantiate", "kb-worker", err);
+  }
+  const memory = kbWorker.exports["memory"];
+  memoryRef.memory = memory;
+  allocator.alloc = (size) => {
+    const fn_ = kbWorker.exports["kbdb_alloc"];
+    if (typeof fn_ !== "function") return 0;
+    return fn_(size);
+  };
+  return { memory, kbWorker };
+}
+function readWasmFileOrThrow(path, label) {
+  try {
+    const buf = (0, import_node_fs3.readFileSync)(path);
+    return buf.buffer.slice(
+      buf.byteOffset,
+      buf.byteOffset + buf.byteLength
+    );
+  } catch (err) {
+    rethrow("load", label, err, path);
+  }
+}
+function rethrow(stage, label, err, path) {
+  const detail = err instanceof Error ? err.message : String(err);
+  const suffix = path ? ` (path: ${path})` : "";
+  const message = `failed to ${stage} ${label} WASM: ${detail}${suffix}`;
+  console.error(`kbdb-worker: ${message}`);
+  throw new Error(message, { cause: err });
+}
+
+// src/shared/worker-daemon/functions/create-ipc-server.function.ts
+var import_node_net = require("node:net");
+function createIpcServer(socketPath, handler) {
+  const server = (0, import_node_net.createServer)((socket) => {
+    let buffer = "";
+    socket.on("data", (chunk) => {
+      buffer += chunk.toString();
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        void handleLine(line, handler, socket);
+      }
+    });
+    socket.on("error", (err) => {
+      console.error(
+        `kbdb-worker: ipc connection error: ${err.message}`
+      );
+    });
+  });
+  server.on("error", (err) => {
+    console.error(`kbdb-worker: ipc server error: ${err.message}`);
+  });
+  server.listen(socketPath);
+  return server;
+}
+function bigintReplacer(_key, value) {
+  return typeof value === "bigint" ? Number(value) : value;
+}
+async function handleLine(line, handler, socket) {
+  let response;
+  try {
+    const request = JSON.parse(line);
+    response = await handler(request);
+  } catch {
+    response = {
+      jsonrpc: "2.0",
+      id: 0,
+      error: {
+        code: -32700,
+        message: "Parse error"
+      }
+    };
+  }
+  socket.write(JSON.stringify(response, bigintReplacer) + "\n");
+}
+
+// src/shared/platform/functions/get-ipc-path.function.ts
+var import_node_path6 = require("node:path");
+
+// src/shared/platform/functions/get-tmpdir.function.ts
+var import_node_os = require("node:os");
+function getTmpdir() {
+  return (0, import_node_os.tmpdir)();
+}
+
+// src/shared/platform/functions/get-ipc-path.function.ts
+function getIpcPath(ctx) {
+  if (process.platform === "win32") {
+    return `\\\\.\\pipe\\kbdb-${ctx}`;
+  }
+  return (0, import_node_path6.join)(getTmpdir(), `kbdb-${ctx}.sock`);
+}
+
+// src/shared/wasm-codec/functions/encode-string.function.ts
+var encoder = new TextEncoder();
+function encodeString(value) {
+  const utf8 = encoder.encode(value);
+  const result = new Uint8Array(4 + utf8.length);
+  new DataView(result.buffer).setUint32(0, utf8.length, true);
+  result.set(utf8, 4);
+  return result;
+}
+
+// src/shared/wasm-codec/functions/encode-u32.function.ts
+function encodeU32(value) {
+  const result = new Uint8Array(4);
+  new DataView(result.buffer).setUint32(0, value, true);
+  return result;
+}
+
+// src/shared/wasm-codec/functions/encode-option-string.function.ts
+function encodeOptionString(value) {
+  if (value == null) {
+    return new Uint8Array([0]);
+  }
+  const encoded = encodeString(value);
+  const result = new Uint8Array(1 + encoded.length);
+  result[0] = 1;
+  result.set(encoded, 1);
+  return result;
+}
+
+// src/shared/wasm-codec/functions/encode-section-type.function.ts
+function encodeSectionType(kind, mimeType) {
+  if (kind === "text") {
+    return new Uint8Array([0]);
+  }
+  const tag = kind === "code" ? 1 : 2;
+  const mime = mimeType ?? "text/plain";
+  const encoded = encodeString(mime);
+  const result = new Uint8Array(1 + encoded.length);
+  result[0] = tag;
+  result.set(encoded, 1);
+  return result;
+}
+
+// src/shared/wasm-codec/functions/encode-add-section-params.function.ts
+function encodeAddSectionParams(params) {
+  const parts = [
+    encodeSectionType(params.sectionType, params.mimeType),
+    encodeString(params.content),
+    encodeOptionString(params.title),
+    encodeOptionString(params.description),
+    encodeOptionString(params.docid),
+    encodeOptionString(params.typeName)
+  ];
+  const totalLen = parts.reduce((sum, p) => sum + p.length, 0);
+  const result = new Uint8Array(totalLen);
+  let offset = 0;
+  for (const part of parts) {
+    result.set(part, offset);
+    offset += part.length;
+  }
+  return result;
+}
+
+// src/shared/wasm-codec/functions/encode-update-section-params.function.ts
+function encodeUpdateSectionParams(oldKbid, params) {
+  const kbidBytes = encodeString(oldKbid);
+  const paramBytes = encodeAddSectionParams(params);
+  const result = new Uint8Array(kbidBytes.length + paramBytes.length);
+  result.set(kbidBytes, 0);
+  result.set(paramBytes, kbidBytes.length);
+  return result;
+}
+
+// src/shared/wasm-codec/functions/encode-kbid-list.function.ts
+function encodeKbidList(kbids) {
+  if (kbids.length === 0) {
+    return new Uint8Array(0);
+  }
+  const parts = [encodeU32(kbids.length), ...kbids.map(encodeString)];
+  const totalLen = parts.reduce((sum, p) => sum + p.length, 0);
+  const result = new Uint8Array(totalLen);
+  let offset = 0;
+  for (const part of parts) {
+    result.set(part, offset);
+    offset += part.length;
+  }
+  return result;
+}
+
+// src/shared/wasm-codec/functions/encode-group-params.function.ts
+function encodeGroupParams(title, kbids, docType = "") {
+  const titleBytes = encodeString(title);
+  const listBytes = encodeKbidList(kbids);
+  const docTypeBytes = encodeString(docType);
+  const result = new Uint8Array(
+    titleBytes.length + listBytes.length + docTypeBytes.length
+  );
+  result.set(titleBytes, 0);
+  result.set(listBytes, titleBytes.length);
+  result.set(docTypeBytes, titleBytes.length + listBytes.length);
+  return result;
+}
+
+// src/shared/wasm-codec/functions/encode-identifier-list.function.ts
+function encodeIdentifierList(ids) {
+  if (ids.length === 0) {
+    return new Uint8Array(0);
+  }
+  const parts = [encodeU32(ids.length), ...ids.map(encodeString)];
+  const totalLen = parts.reduce((sum, p) => sum + p.length, 0);
+  const result = new Uint8Array(totalLen);
+  let offset = 0;
+  for (const part of parts) {
+    result.set(part, offset);
+    offset += part.length;
+  }
+  return result;
+}
+
+// src/shared/wasm-codec/functions/encode-search-params.function.ts
+var encoder2 = new TextEncoder();
+function encodeSearchParams(query, mode = "and", limit = 20) {
+  return encoder2.encode(`${query}
+${mode}
+${String(limit)}`);
+}
+
+// src/shared/wasm-codec/functions/encode-type-filter-param.function.ts
+function encodeTypeFilterParam(typeStr) {
+  return new TextEncoder().encode(typeStr);
+}
+
+// src/shared/wasm-codec/functions/decode-string.function.ts
+var decoder = new TextDecoder();
+function decodeString(bytes, offset) {
+  const view = new DataView(
+    bytes.buffer,
+    bytes.byteOffset,
+    bytes.byteLength
+  );
+  const len = view.getUint32(offset, true);
+  const value = decoder.decode(
+    bytes.subarray(offset + 4, offset + 4 + len)
+  );
+  return { value, bytesRead: 4 + len };
+}
+
+// src/shared/wasm-codec/functions/decode-u32.function.ts
+function decodeU32(bytes, offset) {
+  const view = new DataView(
+    bytes.buffer,
+    bytes.byteOffset,
+    bytes.byteLength
+  );
+  return {
+    value: view.getUint32(offset, true),
+    bytesRead: 4
+  };
+}
+
+// src/shared/wasm-codec/functions/decode-f32.function.ts
+function decodeF32(bytes, offset) {
+  const view = new DataView(
+    bytes.buffer,
+    bytes.byteOffset,
+    bytes.byteLength
+  );
+  return {
+    value: view.getFloat32(offset, true),
+    bytesRead: 4
+  };
+}
+
+// src/shared/wasm-codec/functions/decode-u64.function.ts
+function decodeU64(bytes, offset) {
+  const view = new DataView(
+    bytes.buffer,
+    bytes.byteOffset,
+    bytes.byteLength
+  );
+  return {
+    value: view.getBigUint64(offset, true),
+    bytesRead: 8
+  };
+}
+
+// src/shared/wasm-codec/functions/decode-scored-results.function.ts
+function decodeScoredResults(bytes) {
+  let offset = 0;
+  const count = decodeU32(bytes, offset);
+  offset += count.bytesRead;
+  const results = [];
+  for (let i = 0; i < count.value; i++) {
+    const kbid = decodeString(bytes, offset);
+    offset += kbid.bytesRead;
+    const score = decodeF32(bytes, offset);
+    offset += score.bytesRead;
+    const matchCount = decodeU32(bytes, offset);
+    offset += matchCount.bytesRead;
+    const matches = [];
+    for (let j = 0; j < matchCount.value; j++) {
+      const term = decodeString(bytes, offset);
+      offset += term.bytesRead;
+      const freq = decodeF32(bytes, offset);
+      offset += freq.bytesRead;
+      matches.push({
+        term: term.value,
+        frequency: freq.value
+      });
+    }
+    results.push({
+      kbid: kbid.value,
+      score: score.value,
+      matches
+    });
+  }
+  return results;
+}
+
+// src/shared/wasm-codec/functions/decode-section-records.function.ts
+function decodeOptionString(bytes, offset) {
+  const tag = bytes[offset];
+  if (tag === 0) {
+    return { value: null, bytesRead: 1 };
+  }
+  const str = decodeString(bytes, offset + 1);
+  return { value: str.value, bytesRead: 1 + str.bytesRead };
+}
+function decodeSectionType(bytes, offset) {
+  const tag = bytes[offset];
+  if (tag === 0) {
+    return { sectionType: "text", bytesRead: 1 };
+  }
+  const mime = decodeString(bytes, offset + 1);
+  const kind = tag === 1 ? "code" : "image";
+  return {
+    sectionType: kind,
+    mimeType: mime.value,
+    bytesRead: 1 + mime.bytesRead
+  };
+}
+function decodeSectionRecords(bytes) {
+  let offset = 0;
+  const count = decodeU32(bytes, offset);
+  offset += count.bytesRead;
+  const records = [];
+  for (let i = 0; i < count.value; i++) {
+    const kbid = decodeString(bytes, offset);
+    offset += kbid.bytesRead;
+    const docid = decodeOptionString(bytes, offset);
+    offset += docid.bytesRead;
+    const st = decodeSectionType(bytes, offset);
+    offset += st.bytesRead;
+    const title = decodeOptionString(bytes, offset);
+    offset += title.bytesRead;
+    const description = decodeOptionString(bytes, offset);
+    offset += description.bytesRead;
+    const content = decodeString(bytes, offset);
+    offset += content.bytesRead;
+    const size = decodeU32(bytes, offset);
+    offset += size.bytesRead;
+    const createdAt = decodeU64(bytes, offset);
+    offset += createdAt.bytesRead;
+    const checksum = decodeString(bytes, offset);
+    offset += checksum.bytesRead;
+    const tokenCount = decodeU32(bytes, offset);
+    offset += tokenCount.bytesRead;
+    const headingTokenCount = decodeU32(bytes, offset);
+    offset += headingTokenCount.bytesRead;
+    const bodyTokenCount = decodeU32(bytes, offset);
+    offset += bodyTokenCount.bytesRead;
+    const codeTokenCount = decodeU32(bytes, offset);
+    offset += codeTokenCount.bytesRead;
+    const typeName = decodeString(bytes, offset);
+    offset += typeName.bytesRead;
+    const record = {
+      kbid: kbid.value,
+      docid: docid.value,
+      sectionType: st.sectionType,
+      title: title.value,
+      description: description.value,
+      content: content.value,
+      size: size.value,
+      createdAt: createdAt.value,
+      checksum: checksum.value,
+      tokenCount: tokenCount.value,
+      headingTokenCount: headingTokenCount.value,
+      bodyTokenCount: bodyTokenCount.value,
+      codeTokenCount: codeTokenCount.value,
+      typeName: typeName.value
+    };
+    if (st.mimeType !== void 0) {
+      record.mimeType = st.mimeType;
+    }
+    records.push(record);
+  }
+  return records;
+}
+
+// src/shared/wasm-codec/functions/decode-section-record-list.function.ts
+function decodeSectionRecordList(bytes) {
+  return decodeSectionRecords(bytes);
+}
+
+// src/shared/wasm-codec/functions/decode-document-manifest.function.ts
+function decodeDocumentManifest(bytes) {
+  let offset = 0;
+  const docid = decodeString(bytes, offset);
+  offset += docid.bytesRead;
+  const title = decodeString(bytes, offset);
+  offset += title.bytesRead;
+  const createdAt = decodeU64(bytes, offset);
+  offset += createdAt.bytesRead;
+  const docType = decodeString(bytes, offset);
+  offset += docType.bytesRead;
+  const count = decodeU32(bytes, offset);
+  offset += count.bytesRead;
+  const sections = [];
+  for (let i = 0; i < count.value; i++) {
+    const kbid = decodeString(bytes, offset);
+    offset += kbid.bytesRead;
+    const position = decodeU32(bytes, offset);
+    offset += position.bytesRead;
+    sections.push({
+      kbid: kbid.value,
+      position: position.value
+    });
+  }
+  return {
+    docid: docid.value,
+    title: title.value,
+    createdAt: createdAt.value,
+    docType: docType.value,
+    sections
+  };
+}
+
+// src/shared/wasm-codec/functions/decode-document-manifest-list.function.ts
+function decodeDocumentManifestList(bytes) {
+  let offset = 0;
+  const count = decodeU32(bytes, offset);
+  offset += count.bytesRead;
+  const manifests = [];
+  for (let i = 0; i < count.value; i++) {
+    const docid = decodeString(bytes, offset);
+    offset += docid.bytesRead;
+    const title = decodeString(bytes, offset);
+    offset += title.bytesRead;
+    const createdAt = decodeU64(bytes, offset);
+    offset += createdAt.bytesRead;
+    const docType = decodeString(bytes, offset);
+    offset += docType.bytesRead;
+    const secCount = decodeU32(bytes, offset);
+    offset += secCount.bytesRead;
+    const sections = [];
+    for (let j = 0; j < secCount.value; j++) {
+      const kbid = decodeString(bytes, offset);
+      offset += kbid.bytesRead;
+      const position = decodeU32(bytes, offset);
+      offset += position.bytesRead;
+      sections.push({
+        kbid: kbid.value,
+        position: position.value
+      });
+    }
+    manifests.push({
+      docid: docid.value,
+      title: title.value,
+      createdAt: createdAt.value,
+      docType: docType.value,
+      sections
+    });
+  }
+  return manifests;
+}
+
+// src/shared/wasm-codec/functions/decode-compose-output.function.ts
+function decodeComposeOutput(bytes) {
+  const md = decodeString(bytes, 0);
+  const totalChars = decodeU64(bytes, md.bytesRead);
+  return {
+    markdown: md.value,
+    totalChars: totalChars.value
+  };
+}
+
+// src/shared/wasm-codec/functions/decode-key-value-text.function.ts
+function decodeKeyValueText(text) {
+  const result = {};
+  for (const line of text.split("\n")) {
+    const idx = line.indexOf("=");
+    if (idx < 0) continue;
+    const key = line.slice(0, idx);
+    const value = line.slice(idx + 1);
+    if (key) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/shared/wasm-codec/functions/decode-remove-flag.function.ts
+function decodeRemoveFlag(bytes) {
+  return bytes.length > 0 && bytes[0] === 1;
+}
+
+// src/shared/worker-daemon/classes/worker-daemon.class.ts
+var WASM_METHOD_MAP = {
+  search: "worker_search",
+  addSection: "worker_add_section",
+  add_section: "worker_add_section",
+  updateSection: "worker_update_section",
+  update_section: "worker_update_section",
+  removeSection: "worker_remove_section",
+  remove_section: "worker_remove_section",
+  readSections: "worker_read_sections",
+  read_sections: "worker_read_sections",
+  groupSections: "worker_group_sections",
+  group_sections: "worker_group_sections",
+  removeGrouping: "worker_remove_grouping",
+  remove_grouping: "worker_remove_grouping",
+  retrieveDocument: "worker_retrieve_doc",
+  retrieve_doc: "worker_retrieve_doc",
+  content: "worker_compose",
+  compose: "worker_compose",
+  integrity_check: "worker_check_integrity",
+  integrityCheck: "worker_check_integrity",
+  gc: "worker_garbage_collect",
+  rebuild_indexes: "worker_rebuild_indexes",
+  rebuildIndexes: "worker_rebuild_indexes",
+  init_directory: "worker_init_directory",
+  initDirectory: "worker_init_directory",
+  migrateDatabase: "worker_migrate",
+  query: "worker_query",
+  get_result_status: "worker_result_status",
+  get_result: "worker_get_result",
+  invalidate: "worker_invalidate",
+  invalidate_all: "worker_invalidate_all",
+  invalidateAll: "worker_invalidate_all",
+  db_status: "worker_status",
+  dbStatus: "worker_status",
+  listByType: "worker_list_by_type",
+  list_by_type: "worker_list_by_type",
+  listDocumentsByType: "worker_list_docs_by_type",
+  list_docs_by_type: "worker_list_docs_by_type"
+};
+var CONFIG_PREFIX = "config_";
+var CONFIG_KEY_MAP = {
+  timeout_ms: "timeoutMs",
+  item_ttl_ms: "itemTtlMs",
+  item_limit: "itemLimit",
+  index_limit: "indexLimit"
+};
+var IpcError = class extends Error {
+  /** JSON-RPC error code. */
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "IpcError";
+  }
+};
+var WorkerDaemon = class {
+  /** Context ID (16-character hex SHA-256 prefix). */
+  ctx;
+  /** Absolute path to the `.kbdb` directory. */
+  targetDir;
+  /** Parsed daemon configuration from `worker.toml`. */
+  config;
+  /** Number of currently active IPC client connections. */
+  get connectionCount() {
+    return this._connectionCount;
+  }
+  _connectionCount = 0;
+  _wasmModules = null;
+  _idleAt = 0;
+  _idleTimer = null;
+  _server = null;
+  _wasmDir;
+  /**
+   * @param ctx - context ID (16-hex characters), the first 16 of
+   *   the SHA-256 hash of `targetDir`
+   * @param targetDir - absolute path to the `.kbdb` directory
+   * @param config - parsed daemon configuration
+   * @param wasmDir - path to the WASM build output directory
+   */
+  constructor(ctx, targetDir, config, wasmDir2) {
+    this.ctx = ctx;
+    this.targetDir = targetDir;
+    this.config = config;
+    this._wasmDir = wasmDir2 ?? "";
+  }
+  // -----------------------------------------------------------------------
+  // Public API
+  // -----------------------------------------------------------------------
+  /**
+   * Validates startup preconditions before WASM module loading.
+   *
+   * Checks that the database directory exists, is readable and
+   * writable, and that `catalog.toml` reports a compatible version.
+   *
+   * @throws {Error} if any precondition fails -- `startDaemon`
+   *   catches this, prints to stderr, and exits with code 1
+   */
+  checkPreconditions() {
+    if (!(0, import_node_fs4.existsSync)(this.targetDir)) {
+      throw new Error(
+        `database directory not found: ${this.targetDir}`
+      );
+    }
+    try {
+      (0, import_node_fs4.accessSync)(
+        this.targetDir,
+        import_node_fs4.constants.R_OK | import_node_fs4.constants.W_OK
+      );
+    } catch {
+      throw new Error(
+        `cannot access database directory: ${this.targetDir} -- permission denied`
+      );
+    }
+    this.checkCatalogVersion();
+  }
+  /**
+   * Starts the daemon: loads WASM modules, writes the PID file,
+   * creates the IPC socket, and begins listening for connections.
+   *
+   * Call `checkPreconditions()` before `start()` to validate the
+   * database directory. The daemon will not start if any precondition
+   * fails.
+   *
+   * @throws when WASM module loading fails or the IPC socket cannot
+   *   be created
+   */
+  async start() {
+    const wasmModules = await loadWasmModules(
+      this.config,
+      this._wasmDir
+    );
+    this._wasmModules = wasmModules;
+    this.initWorkerContext();
+    const pidPath = (0, import_node_path7.join)((0, import_node_os2.tmpdir)(), `kbdb-${this.ctx}.pid`);
+    (0, import_node_fs4.writeFileSync)(pidPath, process.pid.toString());
+    const ipcPath = getIpcPath(this.ctx);
+    if ((0, import_node_fs4.existsSync)(ipcPath)) {
+      try {
+        (0, import_node_fs4.unlinkSync)(ipcPath);
+      } catch {
+      }
+    }
+    const handler = (req) => this.handleRequest(req);
+    this._server = createIpcServer(ipcPath, handler);
+    this._server.on("connection", () => {
+      this.incrementConnections();
+      this.resetIdleTimer();
+    });
+    this._server.on("close", () => {
+      this.decrementConnections();
+      if (this._connectionCount === 0) {
+        this.resetIdleTimer();
+      }
+    });
+    this.resetIdleTimer();
+  }
+  /**
+   * Gracefully shuts down the daemon.
+   *
+   * Stops accepting new connections, clears the idle timer, purges
+   * WASM state, removes the PID file and IPC socket file, then exits
+   * the process.
+   */
+  stop() {
+    if (this._idleTimer !== null) {
+      clearTimeout(this._idleTimer);
+      this._idleTimer = null;
+    }
+    if (this._server !== null) {
+      this._server.close();
+      this._server = null;
+    }
+    this._wasmModules = null;
+    const pidPath = (0, import_node_path7.join)((0, import_node_os2.tmpdir)(), `kbdb-${this.ctx}.pid`);
+    try {
+      (0, import_node_fs4.unlinkSync)(pidPath);
+    } catch {
+    }
+    const ipcPath = getIpcPath(this.ctx);
+    try {
+      (0, import_node_fs4.unlinkSync)(ipcPath);
+    } catch {
+    }
+    const crashPath = (0, import_node_path7.join)((0, import_node_os2.tmpdir)(), `kbdb-${this.ctx}.crash`);
+    try {
+      (0, import_node_fs4.unlinkSync)(crashPath);
+    } catch {
+    }
+    process.exit(0);
+  }
+  /**
+   * Handles a single JSON-RPC 2.0 request.
+   *
+   * Validates context, then routes to a daemon-state handler or a
+   * WASM export. Requests whose `ctx` param does not match the
+   * daemon's context ID are rejected with error code `-32001`.
+   *
+   * @param request - incoming JSON-RPC request
+   * @returns the JSON-RPC response
+   */
+  async handleRequest(request) {
+    const params = request.params;
+    if (params === void 0 || params.ctx !== this.ctx) {
+      return this.errorResponse(
+        request.id,
+        -32001,
+        "context mismatch"
+      );
+    }
+    this.resetIdleTimer();
+    try {
+      const result = await this.dispatch(request.method, params);
+      this._idleAt = Math.floor(Date.now() / 1e3);
+      return {
+        jsonrpc: "2.0",
+        id: request.id,
+        result
+      };
+    } catch (err) {
+      this._idleAt = Math.floor(Date.now() / 1e3);
+      if (err instanceof IpcError) {
+        return this.errorResponse(
+          request.id,
+          err.code,
+          err.message
+        );
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      return this.errorResponse(request.id, -32e3, message);
+    }
+  }
+  /**
+   * Increments the active connection count.
+   *
+   * Call when a new IPC client connects.
+   */
+  incrementConnections() {
+    this._connectionCount++;
+  }
+  /**
+   * Decrements the active connection count, clamped to zero.
+   *
+   * Call when an IPC client disconnects.
+   */
+  decrementConnections() {
+    if (this._connectionCount > 0) {
+      this._connectionCount--;
+    }
+  }
+  /**
+   * Injects pre-built WASM modules for unit testing.
+   *
+   * This method exists solely to support unit tests that cannot
+   * load real WASM binaries. It must not be called in production
+   * code -- production code uses `start()` to load modules.
+   *
+   * @param modules - pre-built WASM module instances
+   * @internal
+   */
+  injectModulesForTesting(modules) {
+    this._wasmModules = modules;
+  }
+  // -----------------------------------------------------------------------
+  // Private helpers
+  // -----------------------------------------------------------------------
+  /** Resets the idle timer; triggers stop() when it fires. */
+  resetIdleTimer() {
+    if (this._idleTimer !== null) {
+      clearTimeout(this._idleTimer);
+    }
+    if (this._connectionCount === 0) {
+      this._idleTimer = setTimeout(() => {
+        this.stop();
+      }, this.config.timeoutMs);
+    }
+  }
+  /** Reads catalog.toml and validates the version field. */
+  checkCatalogVersion() {
+    const catalogPath = (0, import_node_path7.join)(this.targetDir, "catalog.toml");
+    let text;
+    try {
+      text = (0, import_node_fs4.readFileSync)(catalogPath, "utf-8");
+    } catch {
+      throw new Error(
+        `cannot read database directory: ${this.targetDir} -- permission denied`
+      );
+    }
+    const version = parseCatalogVersion(text);
+    if (version === null) {
+      throw new Error(
+        "database version 0 requires migration to version " + String(DB_FORMAT_VERSION) + " -- run `kbdb --migrate` before starting the daemon"
+      );
+    }
+    if (version > DB_FORMAT_VERSION) {
+      throw new Error(
+        "database version " + String(version) + " is newer than kbdb version " + String(DB_FORMAT_VERSION) + " -- upgrade kbdb to open this database"
+      );
+    }
+    if (version < DB_FORMAT_VERSION) {
+      throw new Error(
+        "database version " + String(version) + " requires migration to version " + String(DB_FORMAT_VERSION) + " -- run `kbdb --migrate` before starting the daemon"
+      );
+    }
+  }
+  /** Builds a JSON-RPC error response. */
+  errorResponse(id, code, message) {
+    return {
+      jsonrpc: "2.0",
+      id,
+      error: { code, message }
+    };
+  }
+  /**
+   * Dispatches a request method to the appropriate handler.
+   *
+   * Handles daemon-state methods (`status`, `idle_at`,
+   * `config_{key}`) inline and routes WASM methods to the
+   * correct calling convention for each export.
+   */
+  dispatch(method, params) {
+    if (method === "status") {
+      return this._connectionCount > 0 ? "busy" : "idle";
+    }
+    if (method === "idle_at") {
+      return this._idleAt;
+    }
+    if (method === "checkVersion") {
+      return this.handleCheckVersion(params);
+    }
+    if (method.startsWith(CONFIG_PREFIX)) {
+      return this.handleConfigMethod(method);
+    }
+    const wasmMethod = WASM_METHOD_MAP[method];
+    if (wasmMethod !== void 0) {
+      return this.dispatchWasm(method, wasmMethod, params);
+    }
+    throw new IpcError(-32601, `Method not found: ${method}`);
+  }
+  dispatchWasm(method, wasmExport, params) {
+    if (method === "search" || method === "query") {
+      return this.handleSearch(params);
+    }
+    if (method === "addSection" || method === "add_section") {
+      return this.handleAddSection(params);
+    }
+    if (method === "updateSection" || method === "update_section") {
+      return this.handleUpdateSection(params);
+    }
+    if (method === "removeSection" || method === "remove_section") {
+      return this.handleRemoveSection(params);
+    }
+    if (method === "readSections" || method === "read_sections") {
+      return this.handleReadSections(params);
+    }
+    if (method === "retrieveDocument" || method === "retrieve_doc") {
+      return this.handleRetrieveDoc(params);
+    }
+    if (method === "groupSections" || method === "group_sections") {
+      return this.handleGroupSections(params);
+    }
+    if (method === "removeGrouping" || method === "remove_grouping") {
+      return this.handleRemoveGrouping(params);
+    }
+    if (method === "content" || method === "compose") {
+      return this.handleCompose(params);
+    }
+    if (method === "integrityCheck" || method === "integrity_check") {
+      return this.handleIntegrityCheck();
+    }
+    if (method === "gc") {
+      return this.handleGc();
+    }
+    if (method === "rebuildIndexes" || method === "rebuild_indexes") {
+      return this.handleRebuild();
+    }
+    if (method === "dbStatus" || method === "db_status") {
+      return this.handleDbStatus();
+    }
+    if (method === "initDirectory" || method === "init_directory") {
+      return this.handleInitDirectory(params);
+    }
+    if (method === "invalidate") {
+      return this.handleInvalidate(params);
+    }
+    if (method === "invalidateAll" || method === "invalidate_all") {
+      return this.handleInvalidateAll();
+    }
+    if (method === "get_result_status") {
+      return this.handleResultStatus(params);
+    }
+    if (method === "get_result") {
+      return this.handleGetResult(params);
+    }
+    if (method === "migrateDatabase") {
+      throw new IpcError(
+        -32601,
+        "migrateDatabase is not yet supported"
+      );
+    }
+    if (method === "listByType" || method === "list_by_type") {
+      return this.handleListByType(params);
+    }
+    if (method === "listDocumentsByType" || method === "list_docs_by_type") {
+      return this.handleListDocsByType(params);
+    }
+    return this.invokeWasmRaw(wasmExport, new Uint8Array(0));
+  }
+  // -- Search/query (token-based async) --
+  handleSearch(params) {
+    const query = params["query"] ?? "";
+    const mode = params["mode"] ?? "and";
+    const limit = Number(params["limit"] ?? 20);
+    const encoded = encodeSearchParams(query, mode, limit);
+    const searchFn = this.getExport("worker_search");
+    const ptr = this.wasmAlloc(encoded.length);
+    this.wasmWrite(ptr, encoded);
+    const token = searchFn(ptr, encoded.length);
+    this.wasmFree(ptr, encoded.length);
+    const statusFn = this.getExport("worker_result_status");
+    const status = statusFn(token);
+    if (status === 3) {
+      const getResultFn2 = this.getExport("worker_get_result");
+      getResultFn2(token);
+      const errBytes = this.readReturnSlot();
+      const errMsg = new TextDecoder().decode(errBytes);
+      throw new IpcError(-32e3, errMsg);
+    }
+    const getResultFn = this.getExport("worker_get_result");
+    const rc = getResultFn(token);
+    if (rc === -1) {
+      const errBytes = this.readReturnSlot();
+      throw new IpcError(-32e3, new TextDecoder().decode(errBytes));
+    }
+    const resultBytes = this.readReturnSlot();
+    return decodeScoredResults(resultBytes);
+  }
+  // -- Token status/result (u32 direct params) --
+  handleResultStatus(params) {
+    const token = Number(params["token"] ?? 0);
+    const fn = this.getExport("worker_result_status");
+    const status = fn(token);
+    return { status };
+  }
+  handleGetResult(params) {
+    const token = Number(params["token"] ?? 0);
+    const fn = this.getExport("worker_get_result");
+    const rc = fn(token);
+    if (rc === -1) {
+      const errBytes = this.readReturnSlot();
+      throw new IpcError(-32e3, new TextDecoder().decode(errBytes));
+    }
+    const bytes = this.readReturnSlot();
+    return decodeScoredResults(bytes);
+  }
+  // -- Binary-encoded input methods --
+  handleAddSection(params) {
+    const sectionType = params["sectionType"] ?? "text";
+    const semanticType = sectionType === "text" || sectionType === "code" || sectionType === "image" ? sectionType : "text";
+    const typeName = sectionType !== semanticType ? sectionType : null;
+    const input = {
+      sectionType: semanticType,
+      mimeType: params["mimeType"],
+      content: params["content"] ?? "",
+      title: params["title"] ?? null,
+      description: params["description"] ?? null,
+      docid: params["docid"] ?? null,
+      typeName
+    };
+    const encoded = encodeAddSectionParams(input);
+    const bytes = this.callWasmSync("worker_add_section", encoded);
+    const kbid = new TextDecoder().decode(bytes);
+    return { kbid };
+  }
+  handleUpdateSection(params) {
+    const oldKbid = params["kbid"] ?? "";
+    const updSectionType = params["sectionType"] ?? "text";
+    const updSemanticType = updSectionType === "text" || updSectionType === "code" || updSectionType === "image" ? updSectionType : "text";
+    const updTypeName = updSectionType !== updSemanticType ? updSectionType : null;
+    const input = {
+      sectionType: updSemanticType,
+      mimeType: params["mimeType"],
+      content: params["content"] ?? "",
+      title: params["title"] ?? null,
+      description: params["description"] ?? null,
+      docid: params["docid"] ?? null,
+      typeName: updTypeName
+    };
+    const encoded = encodeUpdateSectionParams(oldKbid, input);
+    const bytes = this.callWasmSync("worker_update_section", encoded);
+    const newKbid = new TextDecoder().decode(bytes);
+    return { kbid: newKbid };
+  }
+  handleReadSections(params) {
+    const kbids = params["kbids"] ?? [];
+    const encoded = encodeKbidList(kbids);
+    const bytes = this.callWasmSync("worker_read_sections", encoded);
+    return decodeSectionRecords(bytes);
+  }
+  handleGroupSections(params) {
+    const title = params["title"] ?? "";
+    const kbids = params["kbids"] ?? [];
+    const docType = params["docType"] ?? "";
+    const encoded = encodeGroupParams(title, kbids, docType);
+    const bytes = this.callWasmSync("worker_group_sections", encoded);
+    const docid = new TextDecoder().decode(bytes);
+    return { docid };
+  }
+  handleCompose(params) {
+    const ids = params["ids"] ?? [];
+    const encoded = encodeIdentifierList(ids);
+    const bytes = this.callWasmSync("worker_compose", encoded);
+    const output = decodeComposeOutput(bytes);
+    return {
+      data: output.markdown,
+      total: Number(output.totalChars)
+    };
+  }
+  // -- Raw UTF-8 string input methods --
+  handleRemoveSection(params) {
+    const kbid = params["kbid"] ?? "";
+    const encoded = new TextEncoder().encode(kbid);
+    const bytes = this.callWasmSync("worker_remove_section", encoded);
+    return { removed: decodeRemoveFlag(bytes) };
+  }
+  handleRetrieveDoc(params) {
+    const docid = params["docid"] ?? "";
+    const encoded = new TextEncoder().encode(docid);
+    const bytes = this.callWasmSync("worker_retrieve_doc", encoded);
+    return decodeDocumentManifest(bytes);
+  }
+  handleRemoveGrouping(params) {
+    const docid = params["docid"] ?? "";
+    const encoded = new TextEncoder().encode(docid);
+    this.callWasmSync("worker_remove_grouping", encoded);
+    return { ok: true };
+  }
+  handleInitDirectory(params) {
+    const path = params["path"] ?? this.targetDir;
+    const encoded = new TextEncoder().encode(path);
+    this.callWasmSync("worker_init_directory", encoded);
+    return { ok: true };
+  }
+  handleInvalidate(params) {
+    const kbid = params["kbid"] ?? "";
+    const encoded = new TextEncoder().encode(kbid);
+    this.callWasmSync("worker_invalidate", encoded);
+    return { ok: true };
+  }
+  handleListByType(params) {
+    const typeStr = params["sectionType"] ?? "";
+    const encoded = encodeTypeFilterParam(typeStr);
+    const bytes = this.callWasmSync("worker_list_by_type", encoded);
+    return decodeSectionRecordList(bytes);
+  }
+  handleListDocsByType(params) {
+    const typeStr = params["docType"] ?? "";
+    const encoded = encodeTypeFilterParam(typeStr);
+    const bytes = this.callWasmSync(
+      "worker_list_docs_by_type",
+      encoded
+    );
+    return decodeDocumentManifestList(bytes);
+  }
+  // -- Zero-arg methods --
+  handleInvalidateAll() {
+    this.callWasmZeroArg("worker_invalidate_all");
+    return { ok: true };
+  }
+  handleDbStatus() {
+    this.callWasmZeroArg("worker_status");
+    const bytes = this.readReturnSlot();
+    const text = new TextDecoder().decode(bytes);
+    return decodeKeyValueText(text);
+  }
+  handleIntegrityCheck() {
+    this.callWasmZeroArg("worker_check_integrity");
+    const bytes = this.readReturnSlot();
+    const text = new TextDecoder().decode(bytes);
+    return decodeKeyValueText(text);
+  }
+  handleGc() {
+    this.callWasmZeroArg("worker_garbage_collect");
+    const bytes = this.readReturnSlot();
+    const text = new TextDecoder().decode(bytes);
+    return decodeKeyValueText(text);
+  }
+  handleRebuild() {
+    this.callWasmZeroArg("worker_rebuild_indexes");
+    return { ok: true };
+  }
+  // -- WASM lifecycle --
+  initWorkerContext() {
+    const pathBytes = new TextEncoder().encode(".");
+    this.callWasmSync("worker_init", pathBytes);
+  }
+  // -- WASM bridge primitives --
+  getExport(name) {
+    if (this._wasmModules === null) {
+      throw new Error("WASM modules not loaded");
+    }
+    const fn = this._wasmModules.kbWorker.exports[name];
+    if (typeof fn !== "function") {
+      throw new Error(`WASM export not found: ${name}`);
+    }
+    return fn;
+  }
+  wasmAlloc(size) {
+    if (size === 0) return 0;
+    const allocFn = this._wasmModules?.kbWorker.exports["kbdb_alloc"];
+    if (typeof allocFn !== "function") return 0;
+    return allocFn(size);
+  }
+  wasmFree(ptr, size) {
+    if (ptr === 0 || size === 0) return;
+    const freeFn = this._wasmModules?.kbWorker.exports["kbdb_free"];
+    if (typeof freeFn === "function") {
+      freeFn(ptr, size);
+    }
+  }
+  wasmWrite(ptr, data) {
+    if (data.length === 0) return;
+    const memory = this._wasmModules?.memory;
+    if (!memory) return;
+    const memView = new Uint8Array(memory.buffer);
+    if (ptr + data.length > memView.length) {
+      throw new Error("WASM memory overflow");
+    }
+    memView.set(data, ptr);
+  }
+  readReturnSlot() {
+    const getPtrFn = this._wasmModules?.kbWorker.exports["get_return_ptr"];
+    const getLenFn = this._wasmModules?.kbWorker.exports["get_return_len"];
+    if (typeof getPtrFn !== "function" || typeof getLenFn !== "function") {
+      return new Uint8Array(0);
+    }
+    const ptr = getPtrFn();
+    const len = getLenFn();
+    if (ptr === 0 || len === 0) {
+      return new Uint8Array(0);
+    }
+    const memory = this._wasmModules?.memory;
+    if (!memory) return new Uint8Array(0);
+    const data = new Uint8Array(memory.buffer, ptr, len).slice();
+    this.wasmFree(ptr, len);
+    return data;
+  }
+  callWasmSync(exportName, input) {
+    const fn = this.getExport(exportName);
+    const ptr = this.wasmAlloc(input.length);
+    this.wasmWrite(ptr, input);
+    const rc = fn(ptr, input.length);
+    this.wasmFree(ptr, input.length);
+    if (rc === -1) {
+      const errBytes = this.readReturnSlot();
+      const errMsg = new TextDecoder().decode(errBytes);
+      throw new IpcError(-32e3, errMsg || exportName + " failed");
+    }
+    return this.readReturnSlot();
+  }
+  callWasmZeroArg(exportName) {
+    const fn = this.getExport(exportName);
+    const rc = fn();
+    if (rc === -1) {
+      const errBytes = this.readReturnSlot();
+      const errMsg = new TextDecoder().decode(errBytes);
+      throw new IpcError(-32e3, errMsg || exportName + " failed");
+    }
+  }
+  invokeWasmRaw(exportName, input) {
+    return this.callWasmSync(exportName, input);
+  }
+  handleCheckVersion(params) {
+    const targetPath = typeof params.targetPath === "string" ? params.targetPath : this.targetDir;
+    const catalogPath = (0, import_node_path7.join)(targetPath, "catalog.toml");
+    let text;
+    try {
+      text = (0, import_node_fs4.readFileSync)(catalogPath, "utf-8");
+    } catch {
+      return {
+        status: "needs_migration",
+        currentVersion: 0,
+        requiredVersion: DB_FORMAT_VERSION
+      };
+    }
+    const version = parseCatalogVersion(text);
+    if (version === null) {
+      return {
+        status: "needs_migration",
+        currentVersion: 0,
+        requiredVersion: DB_FORMAT_VERSION
+      };
+    }
+    if (version > DB_FORMAT_VERSION) {
+      return {
+        status: "too_new",
+        currentVersion: version,
+        requiredVersion: DB_FORMAT_VERSION
+      };
+    }
+    if (version < DB_FORMAT_VERSION) {
+      return {
+        status: "needs_migration",
+        currentVersion: version,
+        requiredVersion: DB_FORMAT_VERSION
+      };
+    }
+    return {
+      status: "compatible",
+      currentVersion: version,
+      requiredVersion: DB_FORMAT_VERSION
+    };
+  }
+  /** Returns a daemon config value by config method name. */
+  handleConfigMethod(method) {
+    const key = method.slice(CONFIG_PREFIX.length);
+    const prop = CONFIG_KEY_MAP[key];
+    if (prop === void 0) {
+      throw new IpcError(-32601, `Method not found: ${method}`);
+    }
+    return this.config[prop];
+  }
+};
+function parseCatalogVersion(text) {
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#")) continue;
+    const match = /^version\s*=\s*(\d+)/.exec(trimmed);
+    if (match?.[1] !== void 0) {
+      return parseInt(match[1], 10);
+    }
+  }
+  return null;
+}
+
+// src/shared/worker-daemon/functions/start-daemon.function.ts
+async function startDaemon(contextPath, wasmDir2) {
+  const config = readConfig(contextPath);
+  const hash = await computeSha256(contextPath);
+  const contextId = hash.slice(0, 16);
+  const daemon = new WorkerDaemon(
+    contextId,
+    contextPath,
+    config,
+    wasmDir2
+  );
+  try {
+    daemon.checkPreconditions();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`kbdb-worker: ${message}`);
+    writeCrashLog(contextId, message);
+    process.exit(1);
+  }
+  try {
+    await daemon.start();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`kbdb-worker: ${message}`);
+    writeCrashLog(contextId, message);
+    process.exit(1);
+  }
+  process.on("SIGTERM", () => {
+    daemon.stop();
+  });
+  process.on("SIGINT", () => {
+    daemon.stop();
+  });
+}
+function writeCrashLog(contextId, message) {
+  try {
+    const crashPath = (0, import_node_path8.join)((0, import_node_os3.tmpdir)(), `kbdb-${contextId}.crash`);
+    const payload = JSON.stringify({
+      error: message,
+      timestamp: Date.now()
+    });
+    (0, import_node_fs5.writeFileSync)(crashPath, payload);
+  } catch {
+  }
+}
+
+// src/shared/worker-daemon/functions/run-worker.function.ts
+var import_node_path9 = require("node:path");
+async function runWorker(argv, deps) {
+  const contextPath = argv[0];
+  if (!contextPath) {
+    return {
+      error: "usage: kbdb-worker <context-path>",
+      exitCode: 1
+    };
+  }
+  const resolved = (0, import_node_path9.resolve)(contextPath);
+  if (!deps.existsSync(resolved)) {
+    return {
+      error: `error: path not found: ${resolved}`,
+      exitCode: 1
+    };
+  }
+  await deps.startDaemon(resolved, deps.wasmDir);
+  return { exitCode: 0 };
+}
+
+// src/worker.ts
+var import_meta = {};
+var baseDir = resolveBaseDir(import_meta.url, import_meta.dirname);
+var wasmDir = resolveWasmDir(baseDir.scriptDir);
+async function main() {
+  const result = await runWorker(getArgs(), {
+    existsSync: import_node_fs6.existsSync,
+    startDaemon,
+    wasmDir
+  });
+  if (result.error) {
+    console.error(result.error);
+  }
+  if (result.exitCode !== 0) {
+    process.exitCode = result.exitCode;
+  }
+}
+main().catch((err) => {
+  console.error(err);
+  process.exitCode = 1;
+});
+//# sourceMappingURL=kbdb-worker.cjs.map