@vostride/agent-qa-knowledge-local 0.0.1 → 0.2.2

package/dist/embedder-worker/worker-entry.cjs

@@ -0,0 +1,1424 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/embedder-worker/worker-entry.ts
+var worker_entry_exports = {};
+__export(worker_entry_exports, {
+  runEmbedderWorker: () => runEmbedderWorker
+});
+module.exports = __toCommonJS(worker_entry_exports);
+var import_node_crypto3 = require("node:crypto");
+var import_node_fs4 = require("node:fs");
+var import_node_http2 = require("node:http");
+var import_node_net2 = require("node:net");
+var import_node_path7 = require("node:path");
+
+// src/embedder-acquire.ts
+var import_node_path5 = require("node:path");
+var import_agent_qa_schema2 = require("@vostride/agent-qa-schema");
+
+// src/embedder-floor.ts
+var import_node_crypto = require("node:crypto");
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var import_node_url = require("node:url");
+var import_meta = {};
+var PACKAGE_NAME = "@vostride/agent-qa-knowledge-local";
+var ASSET_DIRECTORY = "potion-retrieval-32m";
+var BINARY_FILE = "potion-retrieval-32m.i8bin";
+var TOKENIZER_FILE = "tokenizer.json";
+var GOLDEN_FILE = "golden-vectors.json";
+var MANIFEST_FILE = "manifest.json";
+var MODEL_ID = "minishlab/potion-retrieval-32M";
+var MODEL_REVISION = "6fc8051fab2a1e0ee76689cf08c853792ac285e7";
+var FLOOR_MAGIC = "PTNF";
+var FLOOR_FORMAT_VERSION = 1;
+var FLOOR_VOCABULARY_SIZE = 63091;
+var FLOOR_DIMENSION = 512;
+var FLOOR_HEADER_BYTES = 16;
+var MANIFEST_MAX_BYTES = 1024 * 1024;
+var TOKENIZER_MAX_BYTES = 16 * 1024 * 1024;
+var GOLDEN_MAX_BYTES = 8 * 1024 * 1024;
+var SHA256_RE = /^[0-9a-f]{64}$/u;
+var FloorAssetLoadError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "FloorAssetLoadError";
+    this.code = code;
+  }
+};
+var FloorEmbeddingError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "FloorEmbeddingError";
+    this.code = code;
+  }
+};
+var memoizedDefaultAssets;
+var tokenizerRuntime;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function packageRootFromImportMeta() {
+  let current = (0, import_node_path.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
+  while (true) {
+    const packageJsonPath = (0, import_node_path.join)(current, "package.json");
+    if ((0, import_node_fs.existsSync)(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse((0, import_node_fs.readFileSync)(packageJsonPath, "utf8"));
+        if (isRecord(packageJson) && packageJson.name === PACKAGE_NAME) return current;
+      } catch {
+      }
+    }
+    const parent = (0, import_node_path.dirname)(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  throw new FloorAssetLoadError(
+    "package-root-not-found",
+    `could not resolve ${PACKAGE_NAME} from ${(0, import_node_url.fileURLToPath)(import_meta.url)}`
+  );
+}
+function manifestEntry(value, file) {
+  if (!isRecord(value)) {
+    throw new FloorAssetLoadError("manifest-invalid", `manifest files.${file} is invalid`);
+  }
+  if (!Number.isSafeInteger(value.bytes) || Number(value.bytes) <= 0) {
+    throw new FloorAssetLoadError(
+      "manifest-invalid",
+      `manifest files.${file}.bytes must be a positive safe integer`
+    );
+  }
+  if (typeof value.sha256 !== "string" || !SHA256_RE.test(value.sha256)) {
+    throw new FloorAssetLoadError(
+      "manifest-invalid",
+      `manifest files.${file}.sha256 must be a lowercase sha256 digest`
+    );
+  }
+  return { bytes: Number(value.bytes), sha256: value.sha256 };
+}
+function parseManifest(value) {
+  if (!isRecord(value) || value.schemaVersion !== 1 || value.format !== "potion-static-int8") {
+    throw new FloorAssetLoadError("manifest-invalid", "floor manifest identity is invalid");
+  }
+  if (value.modelId !== MODEL_ID || value.revision !== MODEL_REVISION) {
+    throw new FloorAssetLoadError("manifest-invalid", "floor manifest model pin is invalid");
+  }
+  if (!isRecord(value.artifact)) {
+    throw new FloorAssetLoadError("manifest-invalid", "floor manifest artifact is invalid");
+  }
+  const artifact = value.artifact;
+  if (artifact.magic !== FLOOR_MAGIC || artifact.version !== FLOOR_FORMAT_VERSION || artifact.vocabularySize !== FLOOR_VOCABULARY_SIZE || artifact.dimension !== FLOOR_DIMENSION || artifact.quantization !== "symmetric-per-row-int8") {
+    throw new FloorAssetLoadError("manifest-invalid", "floor manifest artifact lock is invalid");
+  }
+  if (!isRecord(value.files)) {
+    throw new FloorAssetLoadError("manifest-invalid", "floor manifest files are invalid");
+  }
+  const manifestFiles = value.files;
+  const requiredFiles = [BINARY_FILE, TOKENIZER_FILE, GOLDEN_FILE];
+  const fileNames = Object.keys(manifestFiles).sort();
+  if (fileNames.length !== requiredFiles.length || requiredFiles.some((file) => !fileNames.includes(file))) {
+    throw new FloorAssetLoadError(
+      "manifest-invalid",
+      "floor manifest must contain exactly the committed runtime payloads"
+    );
+  }
+  return {
+    modelId: MODEL_ID,
+    revision: MODEL_REVISION,
+    artifact: {
+      magic: FLOOR_MAGIC,
+      version: FLOOR_FORMAT_VERSION,
+      vocabularySize: FLOOR_VOCABULARY_SIZE,
+      dimension: FLOOR_DIMENSION,
+      quantization: "symmetric-per-row-int8"
+    },
+    files: Object.fromEntries(
+      requiredFiles.map((file) => [file, manifestEntry(manifestFiles[file], file)])
+    )
+  };
+}
+function readManifest(assetsDir) {
+  const path = (0, import_node_path.join)(assetsDir, MANIFEST_FILE);
+  try {
+    const size = (0, import_node_fs.statSync)(path).size;
+    if (size <= 0 || size > MANIFEST_MAX_BYTES) {
+      throw new FloorAssetLoadError(
+        "manifest-invalid",
+        `floor manifest byte length ${size} is outside the accepted range`
+      );
+    }
+    return parseManifest(JSON.parse((0, import_node_fs.readFileSync)(path, "utf8")));
+  } catch (error) {
+    if (error instanceof FloorAssetLoadError) throw error;
+    throw new FloorAssetLoadError(
+      "manifest-invalid",
+      `could not read floor manifest: ${errorMessage(error)}`,
+      { cause: error }
+    );
+  }
+}
+function expectedBinaryBytes(vocabularySize, dimension) {
+  const scalesBytes = vocabularySize * Float32Array.BYTES_PER_ELEMENT;
+  const weightsBytes = vocabularySize * dimension;
+  const total = FLOOR_HEADER_BYTES + scalesBytes + weightsBytes;
+  if (!Number.isSafeInteger(total)) {
+    throw new FloorAssetLoadError("binary-invalid", "floor binary length is not safe");
+  }
+  return total;
+}
+function assertExpectedFileSize(assetsDir, file, entry, maximumBytes) {
+  let actualBytes;
+  try {
+    actualBytes = (0, import_node_fs.statSync)((0, import_node_path.join)(assetsDir, file)).size;
+  } catch (error) {
+    throw new FloorAssetLoadError(
+      "asset-read-failed",
+      `could not stat floor asset ${file}: ${errorMessage(error)}`,
+      { cause: error }
+    );
+  }
+  if (actualBytes !== entry.bytes || actualBytes <= 0 || actualBytes > maximumBytes) {
+    throw new FloorAssetLoadError(
+      "asset-size-mismatch",
+      `floor asset ${file} has ${actualBytes} bytes; manifest declares ${entry.bytes}`
+    );
+  }
+}
+function readAndVerifyFile(assetsDir, file, entry) {
+  let bytes;
+  try {
+    bytes = (0, import_node_fs.readFileSync)((0, import_node_path.join)(assetsDir, file));
+  } catch (error) {
+    throw new FloorAssetLoadError(
+      "asset-read-failed",
+      `could not read floor asset ${file}: ${errorMessage(error)}`,
+      { cause: error }
+    );
+  }
+  const actualDigest = (0, import_node_crypto.createHash)("sha256").update(bytes).digest("hex");
+  if (actualDigest !== entry.sha256) {
+    throw new FloorAssetLoadError(
+      "digest-mismatch",
+      `floor asset ${file} does not match its committed sha256`
+    );
+  }
+  return bytes;
+}
+function parseBinary(bytes) {
+  if (bytes.byteLength < FLOOR_HEADER_BYTES) {
+    throw new FloorAssetLoadError("binary-invalid", "floor binary is shorter than its header");
+  }
+  const magic = bytes.toString("ascii", 0, 4);
+  const version = bytes.readUInt32LE(4);
+  const vocabularySize = bytes.readUInt32LE(8);
+  const dimension = bytes.readUInt32LE(12);
+  if (magic !== FLOOR_MAGIC || version !== FLOOR_FORMAT_VERSION) {
+    throw new FloorAssetLoadError("binary-invalid", "floor binary magic or version is invalid");
+  }
+  if (vocabularySize !== FLOOR_VOCABULARY_SIZE || dimension !== FLOOR_DIMENSION) {
+    throw new FloorAssetLoadError("binary-invalid", "floor binary dimensions are invalid");
+  }
+  if (bytes.byteLength !== expectedBinaryBytes(vocabularySize, dimension)) {
+    throw new FloorAssetLoadError("binary-invalid", "floor binary length is invalid");
+  }
+  const scales = new Float32Array(vocabularySize);
+  for (let row = 0; row < vocabularySize; row += 1) {
+    const scale = bytes.readFloatLE(FLOOR_HEADER_BYTES + row * Float32Array.BYTES_PER_ELEMENT);
+    if (!Number.isFinite(scale) || scale <= 0) {
+      throw new FloorAssetLoadError("binary-invalid", `floor binary row ${row} has invalid scale`);
+    }
+    scales[row] = scale;
+  }
+  const weightsOffset = FLOOR_HEADER_BYTES + vocabularySize * Float32Array.BYTES_PER_ELEMENT;
+  const weights = new Int8Array(
+    bytes.buffer,
+    bytes.byteOffset + weightsOffset,
+    vocabularySize * dimension
+  );
+  return { vocabularySize, dimension, scales, weights };
+}
+function loadTokenizerRuntime() {
+  tokenizerRuntime ??= import("@huggingface/tokenizers").catch((error) => {
+    tokenizerRuntime = void 0;
+    throw new FloorAssetLoadError(
+      "tokenizer-runtime-unavailable",
+      `could not load the floor tokenizer runtime: ${errorMessage(error)}`,
+      { cause: error }
+    );
+  });
+  return tokenizerRuntime;
+}
+async function parseTokenizer(bytes) {
+  const { Tokenizer } = await loadTokenizerRuntime();
+  try {
+    const tokenizerJson = JSON.parse(bytes.toString("utf8"));
+    if (!isRecord(tokenizerJson)) throw new TypeError("tokenizer.json must contain an object");
+    return new Tokenizer(tokenizerJson, {});
+  } catch (error) {
+    throw new FloorAssetLoadError(
+      "tokenizer-invalid",
+      `could not construct floor tokenizer: ${errorMessage(error)}`,
+      { cause: error }
+    );
+  }
+}
+async function loadFloorAssetsFrom(assetsDir) {
+  const manifest = readManifest(assetsDir);
+  const binaryEntry = manifest.files[BINARY_FILE];
+  const tokenizerEntry = manifest.files[TOKENIZER_FILE];
+  const goldenEntry = manifest.files[GOLDEN_FILE];
+  const binaryExpectedBytes = expectedBinaryBytes(
+    manifest.artifact.vocabularySize,
+    manifest.artifact.dimension
+  );
+  assertExpectedFileSize(assetsDir, BINARY_FILE, binaryEntry, binaryExpectedBytes);
+  if (binaryEntry.bytes !== binaryExpectedBytes) {
+    throw new FloorAssetLoadError(
+      "asset-size-mismatch",
+      `floor binary manifest length must be ${binaryExpectedBytes}`
+    );
+  }
+  assertExpectedFileSize(assetsDir, TOKENIZER_FILE, tokenizerEntry, TOKENIZER_MAX_BYTES);
+  assertExpectedFileSize(assetsDir, GOLDEN_FILE, goldenEntry, GOLDEN_MAX_BYTES);
+  const binaryBytes = readAndVerifyFile(assetsDir, BINARY_FILE, binaryEntry);
+  const tokenizerBytes = readAndVerifyFile(assetsDir, TOKENIZER_FILE, tokenizerEntry);
+  readAndVerifyFile(assetsDir, GOLDEN_FILE, goldenEntry);
+  const binary = parseBinary(binaryBytes);
+  return { ...binary, tokenizer: await parseTokenizer(tokenizerBytes) };
+}
+function loadFloorAssets(options = {}) {
+  if (options.assetsDir !== void 0) return loadFloorAssetsFrom(options.assetsDir);
+  if (memoizedDefaultAssets !== void 0) return memoizedDefaultAssets;
+  const pending = (async () => loadFloorAssetsFrom((0, import_node_path.join)(packageRootFromImportMeta(), "assets", ASSET_DIRECTORY)))();
+  memoizedDefaultAssets = pending;
+  pending.catch(() => {
+    if (memoizedDefaultAssets === pending) memoizedDefaultAssets = void 0;
+  });
+  return pending;
+}
+function embed(assets, rendering, maxTokens) {
+  const encoded = assets.tokenizer.encode(rendering, { add_special_tokens: false }).ids;
+  const tokenIds = maxTokens === void 0 ? encoded : encoded.slice(0, maxTokens);
+  if (tokenIds.length === 0) {
+    throw new FloorEmbeddingError(
+      "empty-token-set",
+      "floor tokenizer produced no tokens for the rendering"
+    );
+  }
+  const means = new Float64Array(assets.dimension);
+  for (const tokenId of tokenIds) {
+    if (!Number.isSafeInteger(tokenId) || tokenId < 0 || tokenId >= assets.vocabularySize) {
+      throw new FloorEmbeddingError(
+        "token-id-out-of-range",
+        `floor tokenizer produced out-of-range token id ${tokenId}`
+      );
+    }
+    const rowOffset = tokenId * assets.dimension;
+    const scale = assets.scales[tokenId];
+    for (let column = 0; column < assets.dimension; column += 1) {
+      means[column] = means[column] + assets.weights[rowOffset + column] * scale;
+    }
+  }
+  let squaredLength = 0;
+  for (let column = 0; column < assets.dimension; column += 1) {
+    const mean = means[column] / tokenIds.length;
+    means[column] = mean;
+    squaredLength += mean * mean;
+  }
+  const length = Math.sqrt(squaredLength);
+  if (!Number.isFinite(length) || length === 0) {
+    throw new FloorEmbeddingError("zero-vector", "floor embedder produced a zero-length vector");
+  }
+  return Float32Array.from(means, (value) => value / length);
+}
+function createFloorEmbedder(options = {}) {
+  const maxTokens = options.maxTokens;
+  if (maxTokens !== void 0 && (!Number.isSafeInteger(maxTokens) || maxTokens <= 0)) {
+    throw new RangeError("maxTokens must be a positive safe integer");
+  }
+  return {
+    async embedDocument(rendering) {
+      return embed(await loadFloorAssets(options), rendering, maxTokens);
+    },
+    async embedQuery(rendering) {
+      return embed(await loadFloorAssets(options), rendering, maxTokens);
+    }
+  };
+}
+
+// src/embedder-native.ts
+var import_node_path3 = require("node:path");
+
+// src/model-cache-dir.ts
+var import_node_os = require("node:os");
+var import_node_path2 = require("node:path");
+var MODEL_CACHE_DIR_ENV_VAR = "AGENT_QA_MODEL_CACHE_DIR";
+function resolveModelCacheDir() {
+  const override = process.env[MODEL_CACHE_DIR_ENV_VAR];
+  if (override) return override;
+  const xdgCacheHome = process.env.XDG_CACHE_HOME;
+  if (xdgCacheHome) return (0, import_node_path2.join)(xdgCacheHome, "agent-qa", "models");
+  return (0, import_node_path2.join)((0, import_node_os.homedir)(), ".cache", "agent-qa", "models");
+}
+
+// src/embedder-native.ts
+var nativePipelines = /* @__PURE__ */ new Map();
+var nativePipelineLoadTail = Promise.resolve();
+var NativeEmbeddingModuleLoadError = class extends Error {
+  constructor(cause) {
+    super("Native embedding module could not be loaded", { cause });
+    this.name = "NativeEmbeddingModuleLoadError";
+  }
+};
+var NativeEmbeddingDimensionError = class extends RangeError {
+  actualDim;
+  expectedDim;
+  constructor(actualDim, expectedDim) {
+    super(`Native embedding dimension ${actualDim} does not match profile dimension ${expectedDim}`);
+    this.name = "NativeEmbeddingDimensionError";
+    this.actualDim = actualDim;
+    this.expectedDim = expectedDim;
+  }
+};
+function validateMaxTokens(maxTokens) {
+  if (maxTokens === void 0) return void 0;
+  if (!Number.isSafeInteger(maxTokens) || maxTokens <= 0) {
+    throw new RangeError("maxTokens must be a positive safe integer");
+  }
+  return maxTokens;
+}
+function pipelineKey(profile) {
+  return `${profile.model_id}@${profile.revision}:${profile.dtype}`;
+}
+function tokenBudgetLabel(maxTokens) {
+  return maxTokens === void 0 ? "uncapped" : String(maxTokens);
+}
+function pinnedModelDirectory(cacheDir, profile) {
+  const root = (0, import_node_path3.resolve)(cacheDir);
+  const directory = (0, import_node_path3.resolve)(root, profile.model_id, profile.revision);
+  if (directory === root || !directory.startsWith(`${root}${import_node_path3.sep}`)) {
+    throw new TypeError(`${profile.model_id} cannot be resolved safely inside the model cache`);
+  }
+  return directory;
+}
+function capTokenizer(extractor, maxTokens) {
+  const tokenizer = extractor.tokenizer;
+  const tokenizerConfig = tokenizer._tokenizerConfig;
+  const modelMaximum = Number(tokenizerConfig?.model_max_length);
+  tokenizer._tokenizerConfig = {
+    ...tokenizerConfig ?? {},
+    model_max_length: Number.isSafeInteger(modelMaximum) && modelMaximum > 0 ? Math.min(modelMaximum, maxTokens) : maxTokens
+  };
+}
+async function withNativePipelineLoadLock(operation) {
+  const previous = nativePipelineLoadTail;
+  let release;
+  nativePipelineLoadTail = new Promise((resolvePending) => {
+    release = resolvePending;
+  });
+  await previous;
+  try {
+    return await operation();
+  } finally {
+    release();
+  }
+}
+async function loadPinnedPipeline(transformers, profile, allowDownload, maxTokens) {
+  return withNativePipelineLoadLock(async () => {
+    const cacheDir = resolveModelCacheDir();
+    transformers.env.cacheDir = cacheDir;
+    const sharedOptions = {
+      cache_dir: cacheDir,
+      local_files_only: !allowDownload,
+      revision: profile.revision
+    };
+    const modelSource = allowDownload ? profile.model_id : pinnedModelDirectory(cacheDir, profile);
+    const originalRemotePathTemplate = transformers.env.remotePathTemplate;
+    const originalAllowRemoteModels = transformers.env.allowRemoteModels;
+    if (allowDownload) {
+      transformers.env.remotePathTemplate = `{model}/resolve/${encodeURIComponent(profile.revision)}/`;
+    } else {
+      transformers.env.allowRemoteModels = false;
+    }
+    try {
+      const [tokenizerResult, modelResult] = await Promise.allSettled([
+        transformers.AutoTokenizer.from_pretrained(modelSource, sharedOptions),
+        transformers.AutoModel.from_pretrained(modelSource, {
+          ...sharedOptions,
+          device: "cpu",
+          dtype: profile.dtype,
+          session_options: profile.session_options
+        })
+      ]);
+      if (tokenizerResult.status === "rejected") {
+        if (modelResult.status === "rejected") {
+          throw modelResult.reason;
+        }
+        await modelResult.value.dispose().catch(() => void 0);
+        throw tokenizerResult.reason;
+      }
+      if (modelResult.status === "rejected") throw modelResult.reason;
+      const tokenizer = tokenizerResult.value;
+      const model = modelResult.value;
+      try {
+        const extractor = new transformers.FeatureExtractionPipeline({
+          task: "feature-extraction",
+          model,
+          tokenizer
+        });
+        if (maxTokens !== void 0) capTokenizer(extractor, maxTokens);
+        return extractor;
+      } catch (error) {
+        await model.dispose().catch(() => void 0);
+        throw error;
+      }
+    } finally {
+      transformers.env.remotePathTemplate = originalRemotePathTemplate;
+      transformers.env.allowRemoteModels = originalAllowRemoteModels;
+    }
+  });
+}
+function acquirePipeline(profile, allowDownload, maxTokens) {
+  const key = pipelineKey(profile);
+  const existing = nativePipelines.get(key);
+  if (existing) {
+    if (existing.maxTokens !== maxTokens) {
+      throw new RangeError(
+        `Native embedding pipeline budget conflict for ${key}: existing maxTokens=${tokenBudgetLabel(existing.maxTokens)}, requested maxTokens=${tokenBudgetLabel(maxTokens)}; one process-lifetime session per model identity permits only the first budget`
+      );
+    }
+    return existing.pipelinePromise;
+  }
+  const pending = (async () => {
+    let transformers;
+    try {
+      transformers = await import("@huggingface/transformers");
+    } catch (error) {
+      throw new NativeEmbeddingModuleLoadError(error);
+    }
+    return loadPinnedPipeline(transformers, profile, allowDownload, maxTokens);
+  })();
+  nativePipelines.set(key, { maxTokens, pipelinePromise: pending });
+  return pending;
+}
+function toEmbedding(data, expectedDim) {
+  const vector = data instanceof Float32Array ? data : Float32Array.from(data);
+  if (vector.length !== expectedDim) {
+    throw new NativeEmbeddingDimensionError(vector.length, expectedDim);
+  }
+  return vector;
+}
+async function createNativeEmbedder(options) {
+  const { profile, allowDownload } = options;
+  const maxTokens = validateMaxTokens(options.maxTokens);
+  const extractor = await acquirePipeline(profile, allowDownload, maxTokens);
+  async function embed2(text, prefix) {
+    const output = await extractor(`${prefix}${text}`, {
+      pooling: "mean",
+      normalize: true
+    });
+    return toEmbedding(output.data, profile.dim);
+  }
+  return {
+    embedDocument: (rendering) => embed2(rendering, profile.doc_prefix),
+    embedQuery: (rendering) => embed2(rendering, profile.query_prefix)
+  };
+}
+
+// src/embedder-worker/worker-registration.ts
+var import_node_crypto2 = require("node:crypto");
+var import_node_fs2 = require("node:fs");
+var import_node_http = require("node:http");
+var import_node_net = require("node:net");
+var import_node_os2 = require("node:os");
+var import_node_path4 = require("node:path");
+var import_zod = require("zod");
+var EMBEDDER_WORKER_REGISTRATION_FILE = "embedder-worker.json";
+var EMBEDDER_WORKER_REGISTRATION_SCHEMA_VERSION = 2;
+var EMBEDDER_WORKER_UNVERIFIABLE_INCARNATION = "unresolved";
+var EMBEDDER_WORKER_PROTOCOL_SCHEMA_VERSION = 2;
+var EMBEDDER_WORKER_SOCKET_PATH_BUDGET_BYTES = 100;
+var MAX_EMBEDDER_WORKER_BODY_BYTES = 4194304;
+var EMBEDDER_WORKER_REQUEST_TIMEOUT_MS = 3e4;
+var EmbedderWorkerTimeoutError = class extends Error {
+  phase;
+  timeoutMs;
+  constructor(phase, timeoutMs) {
+    super(`Embedder worker ${phase} timed out after ${timeoutMs} ms`);
+    this.name = "EmbedderWorkerTimeoutError";
+    this.phase = phase;
+    this.timeoutMs = timeoutMs;
+  }
+};
+var embeddingProfileSchema = import_zod.z.object({
+  model_id: import_zod.z.string().min(1),
+  revision: import_zod.z.string().min(1),
+  dim: import_zod.z.number().int().positive(),
+  dtype: import_zod.z.literal("q8"),
+  pooling: import_zod.z.literal("mean"),
+  normalize: import_zod.z.literal(true),
+  query_prefix: import_zod.z.string(),
+  doc_prefix: import_zod.z.string(),
+  backend: import_zod.z.enum(["node", "static"]),
+  session_options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()),
+  tau_dense: import_zod.z.number().finite()
+}).strict();
+var embedderWorkerRegistrationSchema = import_zod.z.object({
+  schemaVersion: import_zod.z.literal(EMBEDDER_WORKER_REGISTRATION_SCHEMA_VERSION),
+  instanceId: import_zod.z.string().uuid(),
+  pid: import_zod.z.number().int().positive(),
+  socketPath: import_zod.z.string().min(1),
+  profile: embeddingProfileSchema,
+  startedAtMs: import_zod.z.number().int().nonnegative(),
+  /** The registering process's own OS-anchored start-time token, or the unverifiable sentinel. */
+  incarnation: import_zod.z.string().min(1)
+}).strict();
+var singleEmbeddingRequestSchema = import_zod.z.discriminatedUnion("method", [
+  import_zod.z.object({
+    schemaVersion: import_zod.z.literal(EMBEDDER_WORKER_PROTOCOL_SCHEMA_VERSION),
+    method: import_zod.z.literal("embedDocument"),
+    rendering: import_zod.z.string()
+  }).strict(),
+  import_zod.z.object({
+    schemaVersion: import_zod.z.literal(EMBEDDER_WORKER_PROTOCOL_SCHEMA_VERSION),
+    method: import_zod.z.literal("embedQuery"),
+    rendering: import_zod.z.string()
+  }).strict()
+]);
+var embedderWorkerRequestSchema = import_zod.z.discriminatedUnion("method", [
+  ...singleEmbeddingRequestSchema.options,
+  import_zod.z.object({
+    schemaVersion: import_zod.z.literal(EMBEDDER_WORKER_PROTOCOL_SCHEMA_VERSION),
+    method: import_zod.z.literal("embedBatch"),
+    requests: import_zod.z.array(singleEmbeddingRequestSchema).min(1).max(256)
+  }).strict()
+]);
+var embedderWorkerResponseSchema = import_zod.z.object({
+  schemaVersion: import_zod.z.literal(EMBEDDER_WORKER_PROTOCOL_SCHEMA_VERSION),
+  vectors: import_zod.z.array(import_zod.z.array(import_zod.z.number().finite()))
+}).strict();
+function projectHash(projectRoot) {
+  return (0, import_node_crypto2.createHash)("sha256").update((0, import_node_fs2.realpathSync)(projectRoot)).digest("hex").slice(0, 12);
+}
+function embedderWorkerAgentQaRoot(projectRoot = process.cwd()) {
+  return (0, import_node_path4.join)((0, import_node_fs2.realpathSync)(projectRoot), ".agent-qa");
+}
+function embedderWorkerRegistrationPath(agentQaRoot) {
+  return (0, import_node_path4.join)(agentQaRoot, EMBEDDER_WORKER_REGISTRATION_FILE);
+}
+function instanceDiscriminator(instanceId) {
+  const validated = import_zod.z.string().uuid().parse(instanceId);
+  return (0, import_node_crypto2.createHash)("sha256").update(validated).digest("hex").slice(0, 12);
+}
+function embedderWorkerSocketPath(agentQaRoot, projectRoot, instanceId) {
+  const hash = projectHash(projectRoot);
+  const instance = instanceDiscriminator(instanceId);
+  if (process.platform === "win32") {
+    return `\\\\.\\pipe\\agent-qa-embedder-${hash}-${instance}`;
+  }
+  const canonicalAgentQaRoot = (0, import_node_path4.join)((0, import_node_fs2.realpathSync)((0, import_node_path4.dirname)(agentQaRoot)), (0, import_node_path4.basename)(agentQaRoot));
+  const socketFile = `embedder-worker-${instance}.sock`;
+  const projectLocal = (0, import_node_path4.join)(canonicalAgentQaRoot, socketFile);
+  if (Buffer.byteLength(projectLocal) <= EMBEDDER_WORKER_SOCKET_PATH_BUDGET_BYTES) {
+    return projectLocal;
+  }
+  const fallback = (0, import_node_path4.join)((0, import_node_os2.tmpdir)(), `agent-qa-${hash}`, `${instance}.sock`);
+  if (Buffer.byteLength(fallback) > EMBEDDER_WORKER_SOCKET_PATH_BUDGET_BYTES) {
+    throw new Error(
+      `OS temporary directory is too deep for an agent-qa embedder socket: ${fallback}`
+    );
+  }
+  return fallback;
+}
+function prepareEmbedderWorkerSocketParent(socketPath) {
+  if (process.platform === "win32" || socketPath.startsWith("\\\\.\\pipe\\")) return;
+  const parent = (0, import_node_path4.dirname)(socketPath);
+  (0, import_node_fs2.mkdirSync)(parent, { recursive: true, mode: 448 });
+  (0, import_node_fs2.chmodSync)(parent, 448);
+}
+function bestEffortFsyncDirectory(dir) {
+  let fd;
+  try {
+    fd = (0, import_node_fs2.openSync)(dir, "r");
+    (0, import_node_fs2.fsyncSync)(fd);
+  } catch (error) {
+    const code = error.code;
+    if (code !== "ENOENT" && code !== "EINVAL" && code !== "EISDIR" && code !== "EPERM" && code !== "ENOTSUP") {
+      throw error;
+    }
+  } finally {
+    if (fd !== void 0) (0, import_node_fs2.closeSync)(fd);
+  }
+}
+function atomicRewrite(file, text) {
+  const parent = (0, import_node_path4.dirname)(file);
+  (0, import_node_fs2.mkdirSync)(parent, { recursive: true, mode: 448 });
+  (0, import_node_fs2.chmodSync)(parent, 448);
+  const temporary = `${file}.tmp-${(0, import_node_crypto2.randomUUID)()}`;
+  let fd;
+  try {
+    fd = (0, import_node_fs2.openSync)(temporary, "wx", 384);
+    (0, import_node_fs2.writeFileSync)(fd, text, "utf8");
+    (0, import_node_fs2.fsyncSync)(fd);
+    (0, import_node_fs2.closeSync)(fd);
+    fd = void 0;
+    (0, import_node_fs2.renameSync)(temporary, file);
+    bestEffortFsyncDirectory(parent);
+  } finally {
+    if (fd !== void 0) (0, import_node_fs2.closeSync)(fd);
+    (0, import_node_fs2.rmSync)(temporary, { force: true });
+  }
+}
+function writeEmbedderWorkerRegistration(agentQaRoot, registration) {
+  const validated = embedderWorkerRegistrationSchema.parse(registration);
+  atomicRewrite(
+    embedderWorkerRegistrationPath(agentQaRoot),
+    `${JSON.stringify(validated)}
+`
+  );
+}
+function readEmbedderWorkerRegistrationFile(file) {
+  let raw;
+  try {
+    raw = (0, import_node_fs2.readFileSync)(file, "utf8");
+  } catch {
+    return (0, import_node_fs2.existsSync)(file) ? { kind: "malformed" } : { kind: "absent" };
+  }
+  try {
+    const parsedJson = JSON.parse(raw);
+    const parsed = embedderWorkerRegistrationSchema.safeParse(parsedJson);
+    return parsed.success ? { kind: "parsed", registration: parsed.data } : { kind: "malformed" };
+  } catch {
+    return { kind: "malformed" };
+  }
+}
+function readEmbedderWorkerRegistration(agentQaRoot) {
+  return readEmbedderWorkerRegistrationFile(embedderWorkerRegistrationPath(agentQaRoot));
+}
+function embedderWorkerProcessIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = error.code;
+    if (code === "ESRCH") return false;
+    if (code === "EPERM") return true;
+    throw error;
+  }
+}
+function sameRegistration(left, right) {
+  return left.pid === right.pid && left.startedAtMs === right.startedAtMs && left.socketPath === right.socketPath && left.instanceId === right.instanceId && left.incarnation === right.incarnation;
+}
+function removeEmbedderWorkerRegistration(agentQaRoot, expected, options = {}) {
+  const file = embedderWorkerRegistrationPath(agentQaRoot);
+  const parent = (0, import_node_path4.dirname)(file);
+  const quarantine = `${file}.remove-${expected.instanceId}-${(0, import_node_crypto2.randomUUID)()}`;
+  const fsyncDirectory = options.fsyncDirectory ?? bestEffortFsyncDirectory;
+  try {
+    (0, import_node_fs2.renameSync)(file, quarantine);
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+  fsyncDirectory(parent);
+  options.afterQuarantine?.(quarantine);
+  const outcome = readEmbedderWorkerRegistrationFile(quarantine);
+  const quarantinedRegistration = outcome.kind === "parsed" ? outcome.registration : void 0;
+  if (quarantinedRegistration !== void 0 && sameRegistration(quarantinedRegistration, expected)) {
+    (0, import_node_fs2.unlinkSync)(quarantine);
+    fsyncDirectory(parent);
+    return true;
+  }
+  try {
+    (0, import_node_fs2.linkSync)(quarantine, file);
+    fsyncDirectory(parent);
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+  }
+  (0, import_node_fs2.unlinkSync)(quarantine);
+  fsyncDirectory(parent);
+  return false;
+}
+function probeEmbedderWorkerSocket(socketPath) {
+  return new Promise((resolveProbe) => {
+    const socket = (0, import_node_net.connect)(socketPath);
+    socket.once("connect", () => {
+      socket.destroy();
+      resolveProbe(true);
+    });
+    socket.once("error", () => {
+      socket.destroy();
+      resolveProbe(false);
+    });
+  });
+}
+function requestWorker(socketPath, envelope, options) {
+  const body = JSON.stringify(embedderWorkerRequestSchema.parse(envelope));
+  return new Promise((resolveRequest, rejectRequest) => {
+    const requestTimeoutMs = options.requestTimeoutMs ?? EMBEDDER_WORKER_REQUEST_TIMEOUT_MS;
+    const abortController = new AbortController();
+    let responseStream;
+    let timeout;
+    let settled = false;
+    const settle = (outcome) => {
+      if (settled) return false;
+      settled = true;
+      if (timeout !== void 0) clearTimeout(timeout);
+      if (outcome.kind === "resolved") {
+        resolveRequest(outcome.response);
+      } else {
+        try {
+          options.onUnavailable?.(outcome.error);
+        } catch {
+        }
+        rejectRequest(outcome.error);
+      }
+      return true;
+    };
+    const workerRequest = (0, import_node_http.request)(
+      {
+        socketPath,
+        path: "/embed",
+        method: "POST",
+        signal: abortController.signal,
+        headers: {
+          "content-type": "application/json",
+          "content-length": Buffer.byteLength(body)
+        }
+      },
+      (response) => {
+        responseStream = response;
+        const chunks = [];
+        let bytes = 0;
+        response.once("aborted", () => {
+          settle({ kind: "rejected", error: new Error("Embedder worker response was aborted") });
+        });
+        response.once("error", (error) => {
+          settle({ kind: "rejected", error });
+        });
+        response.on("data", (chunk) => {
+          const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+          bytes += buffer.byteLength;
+          if (bytes <= MAX_EMBEDDER_WORKER_BODY_BYTES) chunks.push(buffer);
+        });
+        response.on("end", () => {
+          try {
+            if (bytes > MAX_EMBEDDER_WORKER_BODY_BYTES) {
+              throw new Error("Embedder worker response exceeded the body limit");
+            }
+            const parsedBody = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+            if (response.statusCode !== 200) {
+              const message = import_zod.z.object({ error: import_zod.z.string() }).passthrough().safeParse(parsedBody);
+              throw new Error(
+                message.success ? `Embedder worker rejected the request: ${message.data.error}` : `Embedder worker returned HTTP ${response.statusCode ?? 0}`
+              );
+            }
+            settle({
+              kind: "resolved",
+              response: embedderWorkerResponseSchema.parse(parsedBody)
+            });
+          } catch (error) {
+            settle({ kind: "rejected", error });
+          }
+        });
+      }
+    );
+    workerRequest.once("error", (error) => {
+      const refusal = abortController.signal.aborted ? abortController.signal.reason : error;
+      settle({ kind: "rejected", error: refusal });
+    });
+    timeout = setTimeout(() => {
+      const error = new EmbedderWorkerTimeoutError("request", requestTimeoutMs);
+      if (!settle({ kind: "rejected", error })) return;
+      abortController.abort(error);
+      responseStream?.destroy(error);
+      workerRequest.destroy(error);
+    }, requestTimeoutMs);
+    workerRequest.end(body);
+  });
+}
+function vectorFromResponse(response, expectedDimension) {
+  const [vector] = response.vectors;
+  if (vector === void 0 || response.vectors.length !== 1) {
+    throw new Error("Embedder worker returned an invalid single-vector response");
+  }
+  if (vector.length !== expectedDimension) {
+    throw new Error(
+      `Embedder worker returned dimension ${vector.length}; expected ${expectedDimension}`
+    );
+  }
+  return Float32Array.from(vector);
+}
+function createEmbedderWorkerPort(socketPath, expectedDimension, options = {}) {
+  return {
+    async embedDocument(rendering) {
+      return vectorFromResponse(
+        await requestWorker(socketPath, {
+          schemaVersion: EMBEDDER_WORKER_PROTOCOL_SCHEMA_VERSION,
+          method: "embedDocument",
+          rendering
+        }, options),
+        expectedDimension
+      );
+    },
+    async embedQuery(rendering) {
+      return vectorFromResponse(
+        await requestWorker(socketPath, {
+          schemaVersion: EMBEDDER_WORKER_PROTOCOL_SCHEMA_VERSION,
+          method: "embedQuery",
+          rendering
+        }, options),
+        expectedDimension
+      );
+    }
+  };
+}
+function asEmbeddingProfile(profile) {
+  return profile;
+}
+
+// src/index-open.ts
+var import_node_sqlite = require("node:sqlite");
+var import_agent_qa_schema = require("@vostride/agent-qa-schema");
+
+// src/sqlite-vec-loadable.ts
+var import_sqlite_vec = require("sqlite-vec");
+
+// src/index-open.ts
+function embeddingProfileKey(profile) {
+  return (0, import_agent_qa_schema.canonicalJson)({
+    model_id: profile.model_id,
+    revision: profile.revision,
+    dtype: profile.dtype,
+    dim: profile.dim
+  });
+}
+
+// src/embedder-acquire.ts
+var processCapabilities = /* @__PURE__ */ new Map();
+var injectedCapabilities = /* @__PURE__ */ new WeakMap();
+var injectedCapabilityCaches = /* @__PURE__ */ new Set();
+function resetEmbedderCapability(profile) {
+  if (profile === void 0) {
+    processCapabilities.clear();
+    for (const capabilities of injectedCapabilityCaches) capabilities.clear();
+    injectedCapabilityCaches.clear();
+    return;
+  }
+  const prefix = capabilityProfilePrefix(profile);
+  for (const key of processCapabilities.keys()) {
+    if (key.startsWith(prefix)) processCapabilities.delete(key);
+  }
+  for (const capabilities of injectedCapabilityCaches) {
+    for (const key of capabilities.keys()) {
+      if (key.startsWith(prefix)) capabilities.delete(key);
+    }
+  }
+}
+function isWorkerBackedDiscovery(result) {
+  if (result.kind !== "worker") return false;
+  const candidate = result;
+  return candidate.profile !== void 0 && candidate.embedder !== void 0;
+}
+async function discoverEmbedderWorker(agentQaRoot, options = {}) {
+  const projectRoot = (0, import_node_path5.dirname)(agentQaRoot);
+  const outcome = readEmbedderWorkerRegistration(agentQaRoot);
+  if (outcome.kind !== "parsed") return { kind: "no-worker" };
+  const { registration } = outcome;
+  let expectedSocketPath;
+  try {
+    expectedSocketPath = embedderWorkerSocketPath(
+      agentQaRoot,
+      projectRoot,
+      registration.instanceId
+    );
+  } catch {
+    return { kind: "no-worker" };
+  }
+  if (registration.socketPath !== expectedSocketPath) return { kind: "no-worker" };
+  let pidIsLive;
+  try {
+    pidIsLive = embedderWorkerProcessIsAlive(registration.pid);
+  } catch {
+    return { kind: "no-worker" };
+  }
+  if (!pidIsLive) {
+    removeEmbedderWorkerRegistration(agentQaRoot, registration);
+    return { kind: "no-worker" };
+  }
+  if (!await probeEmbedderWorkerSocket(registration.socketPath)) {
+    removeEmbedderWorkerRegistration(agentQaRoot, registration);
+    return { kind: "no-worker" };
+  }
+  return {
+    kind: "worker",
+    profile: asEmbeddingProfile(registration.profile),
+    embedder: createEmbedderWorkerPort(
+      registration.socketPath,
+      registration.profile.dim,
+      {
+        ...options.requestTimeoutMs === void 0 ? {} : { requestTimeoutMs: options.requestTimeoutMs },
+        onUnavailable: () => {
+          removeEmbedderWorkerRegistration(agentQaRoot, registration);
+          resetEmbedderCapability(asEmbeddingProfile(registration.profile));
+        }
+      }
+    )
+  };
+}
+function errorRecord(error) {
+  return typeof error === "object" && error !== null ? error : void 0;
+}
+function errorText(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isNativeModuleUnavailable(error) {
+  if (error instanceof NativeEmbeddingModuleLoadError) return true;
+  const code = errorRecord(error)?.code;
+  if (code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND" || code === "ERR_DLOPEN_FAILED") {
+    return true;
+  }
+  const message = errorText(error).toLowerCase();
+  return message.includes("cannot find package") || message.includes("cannot find module") || message.includes("could not locate the bindings file");
+}
+function isColdArtifact(error, allowDownload) {
+  if (allowDownload) return false;
+  const code = errorRecord(error)?.code;
+  if (code === "ENOENT") return true;
+  const message = errorText(error).toLowerCase();
+  return message.includes("local_files_only") || message.includes("not found locally") || message.includes("not present in the local cache") || message.includes("not found in the local cache") || message.includes("could not locate file");
+}
+function cacheFor(probes) {
+  if (probes === void 0) return processCapabilities;
+  const existing = injectedCapabilities.get(probes);
+  if (existing !== void 0) {
+    injectedCapabilityCaches.add(existing);
+    return existing;
+  }
+  const created = /* @__PURE__ */ new Map();
+  injectedCapabilities.set(probes, created);
+  injectedCapabilityCaches.add(created);
+  return created;
+}
+function capabilityCacheKey(profile, workerPolicy, agentQaRoot) {
+  const profileKey = embeddingProfileKey(profile);
+  return `${profileKey.length}:${profileKey}:${workerPolicy}:${agentQaRoot}`;
+}
+function capabilityProfilePrefix(profile) {
+  const profileKey = embeddingProfileKey(profile);
+  return `${profileKey.length}:${profileKey}:`;
+}
+async function probeFloor(factory) {
+  try {
+    const embedder = await factory();
+    return {
+      kind: "ready",
+      rung: "floor",
+      profile: import_agent_qa_schema2.STATIC_FLOOR_EMBEDDING_PROFILE,
+      embedder
+    };
+  } catch {
+    return { kind: "lexical-only" };
+  }
+}
+async function probeCapability({
+  preferredProfile,
+  allowDownload,
+  workerPolicy,
+  agentQaRoot,
+  probes
+}) {
+  const discoverWorker = probes?.discoverWorker ?? discoverEmbedderWorker;
+  const nativeFactory = probes?.createNativeEmbedder ?? createNativeEmbedder;
+  const floorFactory = probes?.createFloorEmbedder ?? (async () => {
+    await loadFloorAssets();
+    return createFloorEmbedder();
+  });
+  try {
+    const worker = await discoverWorker(agentQaRoot);
+    if (isWorkerBackedDiscovery(worker) && embeddingProfileKey(worker.profile) === embeddingProfileKey(preferredProfile)) {
+      return {
+        kind: "ready",
+        rung: worker.profile.backend === "static" ? "floor" : "native",
+        profile: worker.profile,
+        embedder: worker.embedder
+      };
+    }
+    if (workerPolicy === "required") {
+      return { kind: "deferred", reason: "worker-unavailable" };
+    }
+  } catch {
+    return {
+      kind: "deferred",
+      reason: workerPolicy === "required" ? "worker-unavailable" : "load-failure"
+    };
+  }
+  if (preferredProfile.backend === "static") return probeFloor(floorFactory);
+  try {
+    const embedder = await nativeFactory({ profile: preferredProfile, allowDownload });
+    return { kind: "ready", rung: "native", profile: preferredProfile, embedder };
+  } catch (error) {
+    if (isNativeModuleUnavailable(error)) return probeFloor(floorFactory);
+    if (isColdArtifact(error, allowDownload)) {
+      return { kind: "deferred", reason: "cold-artifact" };
+    }
+    return { kind: "deferred", reason: "load-failure" };
+  }
+}
+function resolveEmbedderCapability(options) {
+  const preferredProfile = options.preferredProfile ?? import_agent_qa_schema2.DEFAULT_EMBEDDING_PROFILE;
+  const workerPolicy = options.workerPolicy ?? "preferred";
+  if (workerPolicy === "required" && options.agentQaRoot === void 0) {
+    throw new TypeError("workerPolicy required needs an explicit agentQaRoot");
+  }
+  const agentQaRoot = options.agentQaRoot ?? embedderWorkerAgentQaRoot(process.cwd());
+  const capabilities = cacheFor(options.probes);
+  const key = capabilityCacheKey(preferredProfile, workerPolicy, agentQaRoot);
+  const existing = capabilities.get(key);
+  if (existing !== void 0) return existing;
+  const pending = probeCapability({
+    preferredProfile,
+    allowDownload: options.allowDownload,
+    workerPolicy,
+    agentQaRoot,
+    probes: options.probes
+  });
+  capabilities.set(key, pending);
+  return pending;
+}
+
+// src/lease/writer-lease.ts
+var import_node_child_process = require("node:child_process");
+var import_node_fs3 = require("node:fs");
+var import_node_path6 = require("node:path");
+var import_node_sqlite2 = require("node:sqlite");
+var import_zod2 = require("zod");
+var PROCESS_INCARNATION_PS_PATH = "/bin/ps";
+var PROCESS_INCARNATION_PS_ENV = Object.freeze({ LC_ALL: "C", LANG: "C", TZ: "UTC0" });
+var MUTATION_LOCK_TERMINATION_WAIT = new Int32Array(
+  new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)
+);
+var LEASE_GUARD_DIR = "memory/queue/lease-guard";
+var LEASE_GUARD_STALE_MS = 1e4;
+var LEASE_GUARD_WAIT_MS = LEASE_GUARD_STALE_MS + 2e3;
+var LEASE_GUARD_STAGING_STALE_MS = LEASE_GUARD_WAIT_MS + LEASE_GUARD_STALE_MS;
+var LEASE_GUARD_STAGING_PREFIX = `${(0, import_node_path6.basename)(LEASE_GUARD_DIR)}.tmp-`;
+var LEASE_GUARD_RESIDUE_PREFIX = `${(0, import_node_path6.basename)(LEASE_GUARD_DIR)}.residue-`;
+var writerLeaseSchema = import_zod2.z.object({
+  leaseId: import_zod2.z.string().uuid(),
+  pid: import_zod2.z.number().int().positive(),
+  epoch: import_zod2.z.number().int().positive(),
+  heartbeatAtMs: import_zod2.z.number().int().nonnegative()
+}).strict();
+function resolveProcessIncarnation(pid, timeoutMs, psExecutable) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) return void 0;
+  try {
+    if (process.platform === "win32") return void 0;
+    return process.platform === "linux" ? resolveLinuxProcessIncarnation(pid) : resolvePosixProcessIncarnation(pid, timeoutMs, psExecutable);
+  } catch {
+    return void 0;
+  }
+}
+function resolveLinuxProcessIncarnation(pid) {
+  let raw;
+  try {
+    raw = (0, import_node_fs3.readFileSync)(`/proc/${pid}/stat`, "utf8");
+  } catch {
+    return void 0;
+  }
+  const commEnd = raw.lastIndexOf(")");
+  if (commEnd < 0) return void 0;
+  const startTime = raw.slice(commEnd + 1).trim().split(/\s+/)[19];
+  return startTime !== void 0 && /^\d+$/.test(startTime) ? `proc-starttime:${startTime}` : void 0;
+}
+function resolvePosixProcessIncarnation(pid, timeoutMs, psExecutable = PROCESS_INCARNATION_PS_PATH) {
+  const observed = (0, import_node_child_process.spawnSync)(psExecutable, ["-p", String(pid), "-o", "lstart="], {
+    encoding: "utf8",
+    env: PROCESS_INCARNATION_PS_ENV,
+    windowsHide: true,
+    // `spawnSync` reads 0 as "no timeout", so an exhausted budget must never arrive here as 0.
+    ...timeoutMs === void 0 ? {} : { timeout: Math.max(1, Math.ceil(timeoutMs)) }
+  });
+  if (observed.error !== void 0 || observed.status !== 0) return void 0;
+  const lstart = (observed.stdout ?? "").trim();
+  return lstart === "" ? void 0 : `ps-lstart-utc:${lstart}`;
+}
+var leaseGuardOwnerSchema = import_zod2.z.object({
+  pid: import_zod2.z.number().int().positive(),
+  threadId: import_zod2.z.number().int().nonnegative(),
+  token: import_zod2.z.string().uuid(),
+  claimedAtNs: import_zod2.z.string().regex(/^[0-9]+$/)
+}).strict();
+
+// src/embedder-worker/worker-incarnation.ts
+function ownEmbedderWorkerIncarnation() {
+  return resolveProcessIncarnation(process.pid) ?? EMBEDDER_WORKER_UNVERIFIABLE_INCARNATION;
+}
+
+// src/embedder-worker/worker-entry.ts
+var EmbedderWorkerRequestError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EmbedderWorkerRequestError";
+  }
+};
+async function readRequestBody(request2) {
+  const chunks = [];
+  let bytes = 0;
+  for await (const chunk of request2) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    bytes += buffer.byteLength;
+    if (bytes > MAX_EMBEDDER_WORKER_BODY_BYTES) {
+      throw new EmbedderWorkerRequestError(
+        `Embedder request exceeds ${MAX_EMBEDDER_WORKER_BODY_BYTES} bytes`
+      );
+    }
+    chunks.push(buffer);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function parseRequest(request2) {
+  let parsedJson;
+  try {
+    parsedJson = JSON.parse(await readRequestBody(request2));
+  } catch (error) {
+    if (error instanceof EmbedderWorkerRequestError) throw error;
+    throw new EmbedderWorkerRequestError(
+      `Embedder request body must be valid JSON: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const parsed = embedderWorkerRequestSchema.safeParse(parsedJson);
+  if (!parsed.success) {
+    throw new EmbedderWorkerRequestError(
+      parsed.error.issues.map((issue) => `${issue.path.map(String).join(".") || "<root>"}: ${issue.message}`).join("; ")
+    );
+  }
+  return parsed.data;
+}
+function json(response, statusCode, body) {
+  const payload = JSON.stringify(body);
+  response.writeHead(statusCode, {
+    "content-type": "application/json",
+    "content-length": Buffer.byteLength(payload)
+  });
+  response.end(payload);
+}
+async function embedOne(embedder, request2) {
+  return request2.method === "embedDocument" ? embedder.embedDocument(request2.rendering) : embedder.embedQuery(request2.rendering);
+}
+async function serveEmbeddingRequest(embedder, request2) {
+  if (request2.method === "embedBatch") {
+    return Promise.all(request2.requests.map((item) => embedOne(embedder, item)));
+  }
+  return [await embedOne(embedder, request2)];
+}
+function createEmbedderServer(embedder) {
+  return (0, import_node_http2.createServer)((request2, response) => {
+    void (async () => {
+      if (request2.method !== "POST" || request2.url !== "/embed") {
+        json(response, 404, { error: "not-found" });
+        return;
+      }
+      try {
+        const envelope = await parseRequest(request2);
+        const vectors = await serveEmbeddingRequest(embedder, envelope);
+        json(response, 200, {
+          schemaVersion: EMBEDDER_WORKER_PROTOCOL_SCHEMA_VERSION,
+          vectors: vectors.map((vector) => Array.from(vector))
+        });
+      } catch (error) {
+        const statusCode = error instanceof EmbedderWorkerRequestError ? 400 : 500;
+        json(response, statusCode, {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    })();
+  });
+}
+function listen(server, socketPath) {
+  return new Promise((resolveListen, rejectListen) => {
+    const onError = (error) => {
+      server.off("listening", onListening);
+      rejectListen(error);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolveListen();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(socketPath);
+  });
+}
+function probeSocket(socketPath) {
+  return new Promise((resolveProbe) => {
+    const socket = (0, import_node_net2.connect)(socketPath);
+    socket.once("connect", () => {
+      socket.destroy();
+      resolveProbe(true);
+    });
+    socket.once("error", () => {
+      socket.destroy();
+      resolveProbe(false);
+    });
+  });
+}
+async function listenWithStaleRecovery(server, socketPath) {
+  try {
+    await listen(server, socketPath);
+  } catch (error) {
+    const code = error.code;
+    if (code !== "EADDRINUSE" && code !== "EINVAL" || process.platform === "win32") {
+      throw error;
+    }
+    if (await probeSocket(socketPath)) {
+      throw new Error(`Embedder worker socket is already live: ${socketPath}`);
+    }
+    (0, import_node_fs4.rmSync)(socketPath);
+    await listen(server, socketPath);
+  }
+}
+function closeServer(server) {
+  return new Promise((resolveClose, rejectClose) => {
+    server.close((error) => {
+      if (error !== void 0) rejectClose(error);
+      else resolveClose();
+    });
+  });
+}
+async function acquireProcessLocalEmbedder(profile) {
+  const outcome = await resolveEmbedderCapability({
+    preferredProfile: profile,
+    allowDownload: false,
+    probes: {
+      discoverWorker: () => Promise.resolve({ kind: "no-worker" })
+    }
+  });
+  if (outcome.kind !== "ready") {
+    throw new Error(`Embedder worker could not resolve profile: ${outcome.kind}`);
+  }
+  return outcome.embedder;
+}
+async function runEmbedderWorker(options) {
+  const projectRoot = (0, import_node_path7.resolve)(options.projectRoot);
+  const agentQaRoot = embedderWorkerAgentQaRoot(projectRoot);
+  const instanceId = options.instanceId ?? (0, import_node_crypto3.randomUUID)();
+  const socketPath = embedderWorkerSocketPath(agentQaRoot, projectRoot, instanceId);
+  const embedder = await acquireProcessLocalEmbedder(options.profile);
+  const server = createEmbedderServer(embedder);
+  prepareEmbedderWorkerSocketParent(socketPath);
+  await listenWithStaleRecovery(server, socketPath);
+  const registration = {
+    schemaVersion: EMBEDDER_WORKER_REGISTRATION_SCHEMA_VERSION,
+    instanceId,
+    pid: process.pid,
+    socketPath,
+    profile: options.profile,
+    startedAtMs: Date.now(),
+    incarnation: ownEmbedderWorkerIncarnation()
+  };
+  try {
+    if (process.platform !== "win32") (0, import_node_fs4.chmodSync)(socketPath, 384);
+    writeEmbedderWorkerRegistration(agentQaRoot, registration);
+  } catch (error) {
+    await closeServer(server).catch(() => void 0);
+    removeEmbedderWorkerRegistration(agentQaRoot, registration);
+    if (process.platform !== "win32") (0, import_node_fs4.rmSync)(socketPath, { force: true });
+    throw error;
+  }
+  let closePromise;
+  return {
+    registration,
+    close() {
+      closePromise ??= (async () => {
+        try {
+          await closeServer(server);
+        } finally {
+          try {
+            removeEmbedderWorkerRegistration(agentQaRoot, registration);
+          } finally {
+            if (process.platform !== "win32") (0, import_node_fs4.rmSync)(socketPath, { force: true });
+          }
+        }
+      })();
+      return closePromise;
+    }
+  };
+}
+function parseProfile(raw) {
+  if (raw === void 0) throw new Error("Embedder worker requires a profile JSON argument");
+  return asEmbeddingProfile(embeddingProfileSchema.parse(JSON.parse(raw)));
+}
+async function main() {
+  const projectRoot = process.argv[2];
+  if (projectRoot === void 0) throw new Error("Embedder worker requires a project root argument");
+  const handle = await runEmbedderWorker({
+    projectRoot,
+    profile: parseProfile(process.argv[3]),
+    ...process.argv[4] === void 0 ? {} : { instanceId: process.argv[4] }
+  });
+  let stopping = false;
+  const stop = (exitCode) => {
+    if (stopping) return;
+    stopping = true;
+    void handle.close().then(
+      () => process.exit(exitCode),
+      (error) => {
+        process.stderr.write(
+          `Embedder worker cleanup failed: ${error instanceof Error ? error.message : String(error)}
+`
+        );
+        process.exit(1);
+      }
+    );
+  };
+  process.once("SIGTERM", () => stop(0));
+  process.once("SIGINT", () => stop(0));
+}
+var entryBasename = process.argv[1] === void 0 ? void 0 : (0, import_node_path7.basename)(process.argv[1]);
+if (entryBasename === "worker-entry.js" || entryBasename === "worker-entry.cjs") {
+  void main().catch((error) => {
+    process.stderr.write(
+      `Embedder worker failed: ${error instanceof Error ? error.message : String(error)}
+`
+    );
+    process.exitCode = 1;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runEmbedderWorker
+});
+//# sourceMappingURL=worker-entry.cjs.map