@hraness/wordcell 0.21.2 → 0.22.0

package/dist/{index-x6m57nfc.js → index-g5vsqmdy.js}

@@ -2,6 +2,11 @@
 import {
   classifyPlatformUrl
 } from "./index-hgve9rh2.js";
+import {
+  filterCookieProviderResult,
+  readCookieFile,
+  renderCookieHeader
+} from "./index-2gv8y733.js";
 import {
   startNetworkProxy
 } from "./index-w2zc0vwa.js";
@@ -20,63 +25,28 @@ import {
   sanitizeArtifactUrl
 } from "./index-mxxxytys.js";
 import {
-  filterCookieProviderResult,
-  readCookieFile,
-  renderCookieHeader
-} from "./index-2gv8y733.js";
+  findKbPackageRoot,
+  resolvePackageDirectory
+} from "./index-4knsp9qj.js";
 
 // src/clip/acquire.ts
 import {
   chmodSync,
-  existsSync as existsSync2,
+  existsSync,
   lstatSync,
   mkdtempSync,
-  readFileSync as readFileSync2,
+  readFileSync,
   realpathSync,
   rmSync,
   statSync,
   writeFileSync
 } from "fs";
 import { homedir, tmpdir } from "os";
-import { basename, dirname as dirname2, isAbsolute, join as join2, relative, resolve as resolve2, sep } from "path";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "path";
 import { getCookies } from "@steipete/sweet-cookie";
-
-// src/clip/package-root.ts
-import { existsSync, readFileSync } from "fs";
-import { createRequire } from "module";
-import { dirname, join, resolve } from "path";
-function isPackageManifest(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function findKbPackageRoot(startDirectory = import.meta.dir, dependencies = {}) {
-  const exists = dependencies.exists ?? existsSync;
-  const readText = dependencies.readText ?? ((path) => readFileSync(path, "utf8"));
-  let directory = resolve(startDirectory);
-  for (let depth = 0;depth < 8; depth += 1) {
-    const manifestPath = join(directory, "package.json");
-    if (exists(manifestPath)) {
-      try {
-        const parsed = JSON.parse(readText(manifestPath));
-        if (isPackageManifest(parsed) && typeof parsed.name === "string" && parsed.name === "@hraness/wordcell" && typeof parsed.version === "string")
-          return directory;
-      } catch {}
-    }
-    const parent = dirname(directory);
-    if (parent === directory)
-      break;
-    directory = parent;
-  }
-  throw new Error("Could not locate the wordcell package root.");
-}
-function resolvePackageDirectory(packageName, parentUrl = import.meta.url) {
-  const manifest = createRequire(parentUrl).resolve(`${packageName}/package.json`);
-  return dirname(manifest);
-}
-
-// src/clip/acquire.ts
-var agentBrowserBinDirectory = join2(resolvePackageDirectory("agent-browser"), "bin");
+var agentBrowserBinDirectory = join(resolvePackageDirectory("agent-browser"), "bin");
 function agentBrowserCommand() {
-  return [process.execPath, join2(agentBrowserBinDirectory, "agent-browser.js")];
+  return [process.execPath, join(agentBrowserBinDirectory, "agent-browser.js")];
 }
 var inheritedProxyKeys = new Set([
   "ALL_PROXY",
@@ -99,9 +69,9 @@ function isolatedAgentBrowserEnvironment(source, socketDirectory) {
   return environment;
 }
 function createAgentBrowserIsolation(directory) {
-  const configPath = join2(directory, "agent-browser.config.json");
+  const configPath = join(directory, "agent-browser.config.json");
   const socketRoot = process.platform === "win32" ? tmpdir() : "/tmp";
-  const socketDirectory = mkdtempSync(join2(socketRoot, "jc-ab-"));
+  const socketDirectory = mkdtempSync(join(socketRoot, "jc-ab-"));
   try {
     chmodSync(socketDirectory, 448);
     writeFileSync(configPath, `{}
@@ -125,6 +95,7 @@ async function readBoundedStream(stream, maxBytes) {
 }
 async function runCommand(command, timeoutMs, maxOutputBytes, isolation, stdin) {
   const child = Bun.spawn([...command], {
+    env: process.env,
     stdin: stdin === undefined ? "ignore" : new Blob([stdin]),
     stdout: "pipe",
     stderr: "pipe",
@@ -208,7 +179,7 @@ async function runAgentBrowserBatch(globalArgs, commands, options) {
     throw new Error("agent-browser batch failed");
 }
 async function discoverChromeProfiles(timeoutMs = 15000) {
-  const directory = mkdtempSync(join2(tmpdir(), "hraness-wordcell-profiles-"));
+  const directory = mkdtempSync(join(tmpdir(), "hraness-wordcell-profiles-"));
   chmodSync(directory, 448);
   let socketDirectory = null;
   try {
@@ -500,10 +471,10 @@ function browserNavigationReachedTarget(target, before, after, navigationCommand
   return navigationCommandSucceeded && before !== null && navigationIdentity(before) !== afterIdentity;
 }
 async function terminateAgentBrowserSession(session, socketDirectory) {
-  const pidPath = join2(socketDirectory, `${session}.pid`);
-  if (!existsSync2(pidPath))
+  const pidPath = join(socketDirectory, `${session}.pid`);
+  if (!existsSync(pidPath))
     return;
-  const rawPid = readFileSync2(pidPath, "utf8").trim();
+  const rawPid = readFileSync(pidPath, "utf8").trim();
   if (!/^\d+$/.test(rawPid))
     return;
   const pid = Number(rawPid);
@@ -528,7 +499,7 @@ function pathInside(root, target) {
 }
 function canonicalPotentialPath(value, label) {
   const suffix = [];
-  let ancestor = resolve2(value);
+  let ancestor = resolve(value);
   while (true) {
     try {
       lstatSync(ancestor);
@@ -538,12 +509,12 @@ function canonicalPotentialPath(value, label) {
       } catch {
         throw new Error(`${label} contains an unresolved symbolic link.`);
       }
-      return resolve2(canonicalAncestor, ...suffix);
+      return resolve(canonicalAncestor, ...suffix);
     } catch (error) {
       if (error.code !== "ENOENT")
         throw error;
     }
-    const parent = dirname2(ancestor);
+    const parent = dirname(ancestor);
     if (parent === ancestor)
       throw new Error(`${label} has no resolvable filesystem ancestor.`);
     suffix.unshift(basename(ancestor));
@@ -554,7 +525,7 @@ function profilePath(value) {
   const pathLike = isAbsolute(value) || value.startsWith(`.${sep}`) || value.startsWith(`..${sep}`) || value.startsWith(`~${sep}`) || value.includes("/") || value.includes("\\");
   if (!pathLike)
     return null;
-  const expanded = value.startsWith(`~${sep}`) ? join2(homedir(), value.slice(2)) : resolve2(value);
+  const expanded = value.startsWith(`~${sep}`) ? join(homedir(), value.slice(2)) : resolve(value);
   return canonicalPotentialPath(expanded, "Persistent browser profile");
 }
 function assertSafePersistentProfile(options) {
@@ -827,7 +798,7 @@ async function acquireBrowser(options, temporaryDirectory, useDiscoveredProfile
         warnings.push("Rendered text was truncated at its configured output boundary.");
       let screenshotPath;
       if ((options.evidence === "screenshot" || options.evidence === "all") && browserPageProvenanceIntact) {
-        const requestedScreenshotPath = join2(temporaryDirectory, "page.png");
+        const requestedScreenshotPath = join(temporaryDirectory, "page.png");
         screenshotPath = requestedScreenshotPath;
         try {
           await runBrowser(globalArgs, ["screenshot", requestedScreenshotPath], {
@@ -840,7 +811,7 @@ async function acquireBrowser(options, temporaryDirectory, useDiscoveredProfile
             rmSync(requestedScreenshotPath, { force: true });
             warnings.push("Browser screenshot changed pages during capture and was discarded.");
             screenshotPath = undefined;
-          } else if (!existsSync2(requestedScreenshotPath)) {
+          } else if (!existsSync(requestedScreenshotPath)) {
             warnings.push("Browser screenshot was requested but agent-browser did not create it.");
             screenshotPath = undefined;
           }
@@ -1027,7 +998,7 @@ async function acquireFile(options) {
     if (stats.size > options.maxHtmlBytes) {
       throw new Error(`HTML input is ${stats.size} bytes; limit is ${options.maxHtmlBytes}`);
     }
-    return readFileSync2(options.htmlFile, "utf8");
+    return readFileSync(options.htmlFile, "utf8");
   })();
   return {
     body,
@@ -1038,4 +1009,4 @@ async function acquireFile(options) {
   };
 }
 
-export { findKbPackageRoot, agentBrowserCommand, isolatedAgentBrowserEnvironment, discoverChromeProfiles, mergeRenderedTextSnapshots, browserExpansionLimits, browserExpansionScript, readBrowserExpansionTelemetry, browserExpansionWarnings, browserExpansionStayedOnPage, browserNavigationReachedTarget, assertSafePersistentProfile, browserCookieCommands, seedOwnedBrowserCookies, browserProxyArguments, acquireBrowser, acquireHttp, acquireCookieHttp, createCookieRecordReader, createCookieHeaderReader, acquireCookieRecords, acquireCookieHeader, acquireFile };
+export { agentBrowserCommand, isolatedAgentBrowserEnvironment, discoverChromeProfiles, mergeRenderedTextSnapshots, browserExpansionLimits, browserExpansionScript, readBrowserExpansionTelemetry, browserExpansionWarnings, browserExpansionStayedOnPage, browserNavigationReachedTarget, assertSafePersistentProfile, browserCookieCommands, seedOwnedBrowserCookies, browserProxyArguments, acquireBrowser, acquireHttp, acquireCookieHttp, createCookieRecordReader, createCookieHeaderReader, acquireCookieRecords, acquireCookieHeader, acquireFile };

package/dist/{index-115b07ap.js → index-hcw140eb.js}

@@ -1,15 +1,15 @@
 // @bun
+import {
+  fuseRankedCandidates,
+  validateSearchQuery
+} from "./index-gm9t95d9.js";
 import {
   MAX_NOTE_UTF8_BYTES,
   MAX_SCANNED_NOTES,
   MAX_VAULT_UTF8_BYTES,
   VaultScanBudgetError,
   scanVault
-} from "./index-0k2x4nn9.js";
-import {
-  fuseRankedCandidates,
-  validateSearchQuery
-} from "./index-why54q5p.js";
+} from "./index-1tm7bgx7.js";
 
 // src/semantic.ts
 import { createHash as createHash2 } from "crypto";

package/dist/index-j70m75wd.js

@@ -0,0 +1,217 @@
+// @bun
+// src/rerank.ts
+var MAX_RERANK_CANDIDATES = 25;
+var MAX_RERANK_SNIPPET_BYTES = 512;
+var MAX_RERANK_STATE_BYTES = 24 * 1024;
+var MALFORMED_RERANK_RESULT_MESSAGE = "Rerank engine returned a malformed result.";
+var MAX_RERANK_DIAGNOSTIC_BYTES = 512;
+var MAX_RERANK_MODEL_BYTES = 128;
+var MAX_RERANK_TOKEN_COUNT = 1e9;
+function dataRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return null;
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null)
+    return null;
+  const keys = Reflect.ownKeys(value);
+  if (keys.length > MAX_RERANK_CANDIDATES)
+    return null;
+  const output = Object.create(null);
+  for (const key of keys) {
+    if (typeof key !== "string")
+      return null;
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (descriptor === undefined || !("value" in descriptor) || !descriptor.enumerable)
+      return null;
+    output[key] = descriptor.value;
+  }
+  return output;
+}
+function hasOnlyKeys(value, allowed) {
+  return Object.keys(value).every((key) => allowed.includes(key));
+}
+function boundedDiagnostic(value) {
+  return typeof value === "string" && value !== "" && Buffer.byteLength(value, "utf8") <= MAX_RERANK_DIAGNOSTIC_BYTES && !/[\u0000-\u001f\u007f]/u.test(value);
+}
+function tokenCount(value) {
+  return Number.isSafeInteger(value) && value >= 0 && value <= MAX_RERANK_TOKEN_COUNT;
+}
+function inspectRerankDetails(result) {
+  const model = result["model"];
+  if (model !== undefined && (typeof model !== "string" || !/^[\x20-\x7e]+$/u.test(model) || Buffer.byteLength(model, "utf8") > MAX_RERANK_MODEL_BYTES)) {
+    return null;
+  }
+  const rawUsage = result["usage"];
+  let usage;
+  if (rawUsage !== undefined) {
+    const usageRecord = dataRecord(rawUsage);
+    if (usageRecord === null || !hasOnlyKeys(usageRecord, ["inputTokens", "outputTokens"]) || usageRecord["inputTokens"] !== undefined && !tokenCount(usageRecord["inputTokens"]) || usageRecord["outputTokens"] !== undefined && !tokenCount(usageRecord["outputTokens"])) {
+      return null;
+    }
+    usage = {
+      ...usageRecord["inputTokens"] === undefined ? {} : { inputTokens: usageRecord["inputTokens"] },
+      ...usageRecord["outputTokens"] === undefined ? {} : { outputTokens: usageRecord["outputTokens"] }
+    };
+  }
+  const rawAccounting = result["accounting"];
+  let accounting;
+  if (rawAccounting !== undefined) {
+    const record = dataRecord(rawAccounting);
+    if (record === null || !hasOnlyKeys(record, ["candidates", "attempted", "completed", "elapsedMs", "usageComplete"]))
+      return null;
+    const { candidates, attempted, completed, elapsedMs, usageComplete } = record;
+    if (!Number.isSafeInteger(candidates) || candidates < 0 || candidates > MAX_RERANK_CANDIDATES || !Number.isSafeInteger(attempted) || attempted < 0 || attempted > candidates || !Number.isSafeInteger(completed) || completed < 0 || completed > attempted || typeof elapsedMs !== "number" || !Number.isFinite(elapsedMs) || elapsedMs < 0 || elapsedMs > 86400000 || typeof usageComplete !== "boolean" || usageComplete && (completed !== attempted || attempted > 0 && (usage?.inputTokens === undefined || usage.outputTokens === undefined)))
+      return null;
+    accounting = Object.freeze({
+      candidates,
+      attempted,
+      completed,
+      elapsedMs,
+      usageComplete
+    });
+  }
+  return {
+    ...model === undefined ? {} : { model },
+    ...usage === undefined ? {} : { usage: Object.freeze(usage) },
+    ...accounting === undefined ? {} : { accounting }
+  };
+}
+function inspectRerankResult(value) {
+  let details = {};
+  const malformed = () => ({
+    status: "failed",
+    message: MALFORMED_RERANK_RESULT_MESSAGE,
+    ...details
+  });
+  try {
+    const result = dataRecord(value);
+    if (result === null || typeof result["status"] !== "string") {
+      return malformed();
+    }
+    const inspectedDetails = inspectRerankDetails(result);
+    if (inspectedDetails === null)
+      return malformed();
+    details = inspectedDetails;
+    if (result["status"] === "failed" || result["status"] === "unavailable") {
+      if (!hasOnlyKeys(result, ["status", "message", "model", "usage", "accounting"]) || !boundedDiagnostic(result["message"])) {
+        return malformed();
+      }
+      return { status: result["status"], message: result["message"], ...details };
+    }
+    if (result["status"] !== "ready" || !hasOnlyKeys(result, ["status", "ordering", "probabilities", "confidence", "model", "usage", "accounting"])) {
+      return malformed();
+    }
+    if (!Array.isArray(result["ordering"]) || result["ordering"].length > MAX_RERANK_CANDIDATES) {
+      return malformed();
+    }
+    const ordering = [];
+    const rawOrdering = result["ordering"];
+    for (let index = 0;index < rawOrdering.length; index += 1) {
+      const descriptor = Object.getOwnPropertyDescriptor(rawOrdering, String(index));
+      const id = descriptor !== undefined && "value" in descriptor ? descriptor.value : undefined;
+      if (typeof id !== "string" || id === "" || Buffer.byteLength(id, "utf8") > MAX_RERANK_STATE_BYTES) {
+        return malformed();
+      }
+      ordering.push(id);
+    }
+    const rawProbabilities = dataRecord(result["probabilities"]);
+    if (rawProbabilities === null) {
+      return malformed();
+    }
+    const probabilities = Object.create(null);
+    for (const [id, probability] of Object.entries(rawProbabilities)) {
+      if (typeof probability !== "number" || !Number.isFinite(probability) || probability < 0 || probability > 1) {
+        return malformed();
+      }
+      probabilities[id] = probability;
+    }
+    const confidence = result["confidence"];
+    if (confidence !== undefined && (typeof confidence !== "number" || !Number.isFinite(confidence) || confidence < 0 || confidence > 1)) {
+      return malformed();
+    }
+    return {
+      status: "ready",
+      ordering: Object.freeze(ordering),
+      probabilities,
+      ...confidence === undefined ? {} : { confidence },
+      ...details
+    };
+  } catch {
+    return malformed();
+  }
+}
+function failedRerank(hits, message, details) {
+  const result = {
+    status: "failed",
+    message,
+    ...details.model === undefined ? {} : { model: details.model },
+    ...details.usage === undefined ? {} : { usage: details.usage },
+    ...details.accounting === undefined ? {} : { accounting: details.accounting }
+  };
+  return { status: "failed", hits, placements: new Map, result, message };
+}
+function applyRerank(hits, result, expectedWindowIds) {
+  const inspected = inspectRerankResult(result);
+  if (inspected.status !== "ready") {
+    return {
+      status: inspected.status,
+      hits,
+      placements: new Map,
+      result: inspected,
+      message: inspected.message
+    };
+  }
+  const ordering = inspected.ordering;
+  if (expectedWindowIds !== undefined && (ordering.length !== expectedWindowIds.length || expectedWindowIds.some((id) => !ordering.includes(id)))) {
+    return failedRerank(hits, MALFORMED_RERANK_RESULT_MESSAGE, inspected);
+  }
+  const windowIds = new Set;
+  for (const id of ordering) {
+    if (windowIds.has(id)) {
+      return failedRerank(hits, "Rerank ordering contained a duplicate candidate id.", inspected);
+    }
+    windowIds.add(id);
+  }
+  const window = hits.slice(0, ordering.length);
+  const windowById = new Map(window.map((hit) => [hit.id, hit]));
+  for (const id of ordering) {
+    if (!windowById.has(id)) {
+      return failedRerank(hits, "Rerank ordering contained an unknown candidate id.", inspected);
+    }
+  }
+  for (const hit of window) {
+    if (!windowIds.has(hit.id)) {
+      return failedRerank(hits, "Rerank ordering omitted a window candidate id.", inspected);
+    }
+  }
+  const probabilityKeys = Object.keys(inspected.probabilities);
+  for (const id of probabilityKeys) {
+    if (!windowIds.has(id)) {
+      return failedRerank(hits, "Rerank probabilities contained an unknown candidate id.", inspected);
+    }
+  }
+  for (const id of ordering) {
+    if (inspected.probabilities[id] === undefined) {
+      return failedRerank(hits, "Rerank probability for a candidate id was missing or invalid.", inspected);
+    }
+  }
+  const probabilityOf = (id) => inspected.probabilities[id];
+  const sorted = window.toSorted((left, right) => Number(right.identity === true) - Number(left.identity === true) || probabilityOf(right.id) - probabilityOf(left.id) || left.rank - right.rank || left.id.localeCompare(right.id));
+  const placements = new Map;
+  const reordered = sorted.map((hit, index) => {
+    placements.set(hit.id, {
+      baselineRank: hit.rank,
+      rerankRank: index + 1,
+      probability: probabilityOf(hit.id)
+    });
+    return hit.rank === index + 1 ? hit : { ...hit, rank: index + 1 };
+  });
+  return {
+    status: "ready",
+    hits: Object.freeze([...reordered, ...hits.slice(ordering.length)]),
+    placements,
+    result: inspected
+  };
+}
+
+export { MAX_RERANK_CANDIDATES, MAX_RERANK_SNIPPET_BYTES, MAX_RERANK_STATE_BYTES, applyRerank };

package/dist/{index-3ehtt59c.js → index-qwgsmtsz.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   fuseRankedCandidates
-} from "./index-why54q5p.js";
+} from "./index-gm9t95d9.js";
 
 // src/benchmark.ts
 var MAX_BENCHMARK_CASES = 500;

package/dist/{index-bgfzwt4h.js → index-t2bs9xdr.js}

@@ -1,15 +1,15 @@
 // @bun
+import {
+  percolateVault
+} from "./index-nd6nynv2.js";
 import {
   createGraphSnapshot,
   openGraphAuthority
-} from "./index-bcfn9xah.js";
+} from "./index-famy7fhs.js";
 import {
   GraphAuthorityError,
   validateGraphPercolationOptions
 } from "./index-11621h23.js";
-import {
-  percolateVault
-} from "./index-nd6nynv2.js";
 import {
   analyzeVault,
   lookupNote,