@hraness/wordcell 0.20.0-bootstrap.1

package/dist/index-2gv8y733.js

@@ -0,0 +1,432 @@
+// @bun
+// src/clip/cookies.ts
+import { closeSync, constants, fstatSync, openSync, readSync } from "fs";
+import { resolve } from "path";
+var MAX_COOKIE_RECORDS = 4096;
+var MAX_COOKIE_BYTES = 2 * 1024 * 1024;
+var cookieNamePattern = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+var cookieValuePattern = /^[\x21\x23-\x2B\x2D-\x3A\x3C-\x5B\x5D-\x7E]*$/;
+var quotedCookieValuePattern = /^"[\x21\x23-\x2B\x2D-\x3A\x3C-\x5B\x5D-\x7E]*"$/;
+var cookieDomainPattern = /^[a-z0-9.-]+$/i;
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isUnknownArray = (value) => Array.isArray(value);
+function hasControlCharacter(value) {
+  for (let index = 0;index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code <= 31 || code === 127)
+      return true;
+  }
+  return false;
+}
+function canonicalHostname(value) {
+  const trimmed = value.trim().toLowerCase().replace(/^\.+/, "").replace(/\.$/, "");
+  if (trimmed === "" || trimmed.length > 253 || trimmed.includes("..") || !cookieDomainPattern.test(trimmed)) {
+    return null;
+  }
+  try {
+    const hostname = new URL(`http://${trimmed}/`).hostname.toLowerCase().replace(/\.$/, "");
+    return hostname === "" || hostname.length > 253 ? null : hostname;
+  } catch {
+    return null;
+  }
+}
+function domainMatches(hostname, domain, hostOnly) {
+  return hostname === domain || !hostOnly && hostname.endsWith(`.${domain}`);
+}
+function pathMatches(requestPath, cookiePath) {
+  if (requestPath === cookiePath)
+    return true;
+  if (!requestPath.startsWith(cookiePath))
+    return false;
+  return cookiePath.endsWith("/") || requestPath[cookiePath.length] === "/";
+}
+function safeCookiePath(value) {
+  const path = value === undefined ? "/" : value;
+  if (typeof path !== "string" || !path.startsWith("/") || path.length > 4096 || hasControlCharacter(path))
+    return null;
+  return path;
+}
+function cookieExpiry(value, nowSeconds) {
+  const raw = value.expires ?? value.expirationDate;
+  if (raw === undefined || raw === null)
+    return 0;
+  if (typeof raw !== "number" || !Number.isFinite(raw))
+    return null;
+  if (raw === 0)
+    return 0;
+  if (raw <= nowSeconds || raw > 253402300799)
+    return null;
+  return Math.trunc(raw);
+}
+function cookieSameSite(value) {
+  if (value.sameSite === undefined || value.sameSite === null)
+    return null;
+  if (typeof value.sameSite !== "string")
+    return;
+  switch (value.sameSite.toLowerCase()) {
+    case "strict":
+      return "Strict";
+    case "lax":
+      return "Lax";
+    case "none":
+    case "no_restriction":
+      return "None";
+    case "unspecified":
+      return null;
+    default:
+      return;
+  }
+}
+function candidateDomain(value, target) {
+  const targetHostname = target.hostname.toLowerCase().replace(/^\[|\]$/g, "").replace(/\.$/, "");
+  let rawDomain;
+  if (typeof value.domain === "string")
+    rawDomain = value.domain;
+  else if (value.domain !== undefined)
+    return null;
+  let urlHostname;
+  if (value.url !== undefined) {
+    if (typeof value.url !== "string" || value.url.length > 8192)
+      return null;
+    try {
+      const url = new URL(value.url);
+      if (url.protocol !== "http:" && url.protocol !== "https:" || url.username !== "" || url.password !== "")
+        return null;
+      urlHostname = url.hostname.toLowerCase().replace(/^\[|\]$/g, "").replace(/\.$/, "");
+    } catch {
+      return null;
+    }
+  }
+  if (rawDomain === undefined && urlHostname === undefined) {
+    return { domain: targetHostname, hostOnly: true };
+  }
+  const hadLeadingDot = rawDomain?.trim().startsWith(".") === true;
+  const domain = canonicalHostname(rawDomain ?? urlHostname ?? "");
+  if (domain === null)
+    return null;
+  const explicitHostOnly = value.hostOnly;
+  if (explicitHostOnly !== undefined && typeof explicitHostOnly !== "boolean")
+    return null;
+  const hostOnly = typeof explicitHostOnly === "boolean" ? explicitHostOnly : !hadLeadingDot;
+  if (!domainMatches(targetHostname, domain, hostOnly))
+    return null;
+  if (urlHostname !== undefined && !domainMatches(urlHostname, domain, hostOnly))
+    return null;
+  return { domain, hostOnly };
+}
+function hasSafeUnpartitionedProvenance(value) {
+  for (const field of ["partitionKey", "topFrameSiteKey", "top_frame_site_key", "originAttributes"]) {
+    const provenance = value[field];
+    if (provenance === undefined || provenance === null)
+      continue;
+    if (typeof provenance !== "string" || provenance.trim() !== "")
+      return false;
+  }
+  for (const field of ["partitioned", "partitionKeyOpaque"]) {
+    const flag = value[field];
+    if (flag === undefined || flag === null)
+      continue;
+    if (typeof flag !== "boolean" || flag)
+      return false;
+  }
+  for (const field of ["isPartitionedAttributeSet", "hasCrossSiteAncestor", "has_cross_site_ancestor"]) {
+    const flag = value[field];
+    if (flag === undefined || flag === null)
+      continue;
+    if (flag !== false && flag !== 0 && flag !== "0")
+      return false;
+  }
+  return true;
+}
+function validatedCookie(value, target, nowSeconds) {
+  if (!isRecord(value))
+    return null;
+  if (typeof value.name !== "string" || value.name.length > 1024 || !cookieNamePattern.test(value.name))
+    return null;
+  if (typeof value.value !== "string" || value.value.length > 64 * 1024 || !cookieValuePattern.test(value.value) && !quotedCookieValuePattern.test(value.value))
+    return null;
+  if (!hasSafeUnpartitionedProvenance(value))
+    return null;
+  const domain = candidateDomain(value, target);
+  const path = safeCookiePath(value.path);
+  const expires = cookieExpiry(value, nowSeconds);
+  const sameSite = cookieSameSite(value);
+  if (domain === null || path === null || expires === null || sameSite === undefined)
+    return null;
+  if (!pathMatches(target.pathname || "/", path))
+    return null;
+  if (value.secure !== undefined && typeof value.secure !== "boolean")
+    return null;
+  if (value.httpOnly !== undefined && typeof value.httpOnly !== "boolean")
+    return null;
+  const secure = value.secure === true;
+  if (secure && target.protocol !== "https:")
+    return null;
+  if (sameSite === "None" && !secure)
+    return null;
+  return {
+    name: value.name,
+    value: value.value,
+    domain: domain.domain,
+    hostOnly: domain.hostOnly,
+    path,
+    secure,
+    httpOnly: value.httpOnly === true,
+    sameSite,
+    expires
+  };
+}
+function cookieBytes(cookie) {
+  return Buffer.byteLength(`${cookie.domain}	${cookie.path}	${cookie.name}	${cookie.value}
+`, "utf8");
+}
+function filterCookies(values, target, nowSeconds = Math.floor(Date.now() / 1000)) {
+  const bounded = values.slice(0, MAX_COOKIE_RECORDS);
+  let rejected = Math.max(0, values.length - bounded.length);
+  let totalBytes = 0;
+  const cookies = new Map;
+  for (const value of bounded) {
+    const cookie = validatedCookie(value, target, nowSeconds);
+    if (cookie === null) {
+      rejected += 1;
+      continue;
+    }
+    const key = `${cookie.domain}\x00${cookie.hostOnly ? "host" : "domain"}\x00${cookie.path}\x00${cookie.name}`;
+    const previous = cookies.get(key);
+    const nextBytes = totalBytes - (previous === undefined ? 0 : cookieBytes(previous)) + cookieBytes(cookie);
+    if (nextBytes > MAX_COOKIE_BYTES) {
+      rejected += 1;
+      continue;
+    }
+    cookies.set(key, cookie);
+    totalBytes = nextBytes;
+  }
+  return {
+    cookies: [...cookies.values()].sort((left, right) => right.path.length - left.path.length || left.name.localeCompare(right.name) || left.domain.localeCompare(right.domain)),
+    rejected
+  };
+}
+function jsonCookieArray(value) {
+  if (isUnknownArray(value))
+    return value;
+  return isRecord(value) && isUnknownArray(value.cookies) ? value.cookies : null;
+}
+function parseJson(input) {
+  try {
+    return jsonCookieArray(JSON.parse(input));
+  } catch {
+    return null;
+  }
+}
+function parseBase64Json(input) {
+  const compact = input.replace(/\s+/g, "");
+  if (compact === "" || compact.length > MAX_COOKIE_BYTES * 2 || !/^[a-z0-9+/]+=*$/i.test(compact))
+    return null;
+  try {
+    const decoded = Buffer.from(compact, "base64");
+    return decoded.byteLength > MAX_COOKIE_BYTES ? null : parseJson(decoded.toString("utf8"));
+  } catch {
+    return null;
+  }
+}
+function hasExplicitCookieScope(value) {
+  if (!isRecord(value))
+    return false;
+  return typeof value.domain === "string" && value.domain.trim() !== "" || typeof value.url === "string" && value.url.trim() !== "";
+}
+function parseNetscape(input) {
+  const cookies = [];
+  let looksLikeNetscape = /^# Netscape HTTP Cookie File/im.test(input);
+  let cursor = 0;
+  while (cursor <= input.length && cookies.length <= MAX_COOKIE_RECORDS) {
+    const newline = input.indexOf(`
+`, cursor);
+    const lineEnd = newline === -1 ? input.length : newline;
+    const rawLine = input.slice(cursor, lineEnd).replace(/\r$/, "");
+    cursor = newline === -1 ? input.length + 1 : newline + 1;
+    const line = rawLine.trim();
+    if (line === "" || line.startsWith("#") && !line.startsWith("#HttpOnly_"))
+      continue;
+    if (line.length > 80 * 1024)
+      continue;
+    const columns = line.split("\t", 8);
+    if (columns.length < 7)
+      continue;
+    looksLikeNetscape = true;
+    const rawDomain = columns[0];
+    const includeSubdomains = columns[1];
+    const path = columns[2];
+    const secure = columns[3];
+    const rawExpires = columns[4];
+    const name = columns[5];
+    const value = columns.slice(6).join("\t");
+    if (rawDomain === undefined || includeSubdomains === undefined || path === undefined || secure === undefined || rawExpires === undefined || name === undefined)
+      continue;
+    const httpOnly = rawDomain.startsWith("#HttpOnly_");
+    const domain = httpOnly ? rawDomain.slice("#HttpOnly_".length) : rawDomain;
+    const expires = Number(rawExpires);
+    cookies.push({
+      name,
+      value,
+      domain,
+      hostOnly: includeSubdomains.toUpperCase() !== "TRUE",
+      path,
+      secure: secure.toUpperCase() === "TRUE",
+      httpOnly,
+      ...Number.isFinite(expires) && expires > 0 ? { expires } : {}
+    });
+  }
+  return looksLikeNetscape ? cookies : null;
+}
+function unquote(value) {
+  const trimmed = value.trim();
+  const first = trimmed[0];
+  return (first === "'" || first === '"') && trimmed.at(-1) === first ? trimmed.slice(1, -1) : trimmed;
+}
+function parseCookieHeaderValue(value, target) {
+  const cookies = [];
+  const restrictivePath = target.pathname === "" ? "/" : target.pathname;
+  let cursor = 0;
+  while (cursor <= value.length && cookies.length <= MAX_COOKIE_RECORDS) {
+    const delimiter = value.indexOf(";", cursor);
+    const pairEnd = delimiter === -1 ? value.length : delimiter;
+    const pair = value.slice(cursor, pairEnd);
+    cursor = delimiter === -1 ? value.length + 1 : delimiter + 1;
+    const separator = pair.indexOf("=");
+    if (separator < 1)
+      continue;
+    cookies.push({
+      name: pair.slice(0, separator).trim(),
+      value: pair.slice(separator + 1).trim(),
+      domain: target.hostname,
+      hostOnly: true,
+      path: restrictivePath,
+      secure: target.protocol === "https:",
+      httpOnly: true,
+      sameSite: "Strict"
+    });
+  }
+  return cookies;
+}
+function curlCookieValue(input) {
+  const patterns = [
+    /(?:^|\s)(?:-b|--cookie)(?:=|\s+)(('[^']*')|("[^"]*")|[^\s]+)/i,
+    /(?:^|\s)(?:-H|--header)(?:=|\s+)(('Cookie:\s*[^']*')|("Cookie:\s*[^"]*"))/i
+  ];
+  for (const pattern of patterns) {
+    const raw = pattern.exec(input)?.[1];
+    if (raw === undefined)
+      continue;
+    return { value: unquote(raw).replace(/^Cookie:\s*/i, ""), curl: true };
+  }
+  const header = /^Cookie:\s*([^\r\n]*)$/im.exec(input)?.[1];
+  if (header !== undefined)
+    return { value: header, curl: false };
+  const trimmed = input.trim();
+  return !trimmed.includes(`
+`) && trimmed.includes("=") ? { value: trimmed, curl: false } : null;
+}
+function parseCookiePayload(input, target, nowSeconds = Math.floor(Date.now() / 1000)) {
+  if (Buffer.byteLength(input, "utf8") > MAX_COOKIE_BYTES)
+    return { ok: false, reason: "too-large" };
+  if (input.trim() === "")
+    return { ok: false, reason: "empty" };
+  let values = parseJson(input);
+  let format = "json";
+  if (values === null) {
+    values = parseBase64Json(input);
+    format = "base64-json";
+  }
+  if (values === null) {
+    values = parseNetscape(input);
+    format = "netscape";
+  }
+  if (values === null) {
+    const header = curlCookieValue(input);
+    if (header !== null) {
+      values = parseCookieHeaderValue(header.value, target);
+      format = header.curl ? "curl" : "cookie-header";
+    }
+  }
+  if (values === null)
+    return { ok: false, reason: "invalid" };
+  const scopeProvenance = format === "netscape" || (format === "json" || format === "base64-json") && values.every(hasExplicitCookieScope) ? "explicit" : "target-inferred";
+  const filtered = filterCookies(values, target, nowSeconds);
+  return filtered.cookies.length === 0 ? { ok: false, reason: "empty" } : { ok: true, format, scopeProvenance, ...filtered };
+}
+function readCookieFile(path, target, options = {}) {
+  let descriptor;
+  try {
+    const absolute = resolve(path);
+    const noFollow = "O_NOFOLLOW" in constants ? constants.O_NOFOLLOW : 0;
+    const nonBlocking = "O_NONBLOCK" in constants ? constants.O_NONBLOCK : 0;
+    descriptor = openSync(absolute, constants.O_RDONLY | noFollow | nonBlocking);
+  } catch {
+    return { ok: false, reason: "unavailable" };
+  }
+  try {
+    options.afterOpen?.();
+    const stats = fstatSync(descriptor);
+    if (!stats.isFile())
+      return { ok: false, reason: "unavailable" };
+    if (options.requirePrivate === true && ((stats.mode & 63) !== 0 || typeof process.getuid === "function" && stats.uid !== process.getuid()))
+      return { ok: false, reason: "unsafe-permissions" };
+    if (stats.size > MAX_COOKIE_BYTES)
+      return { ok: false, reason: "too-large" };
+    const chunks = [];
+    const buffer = Buffer.allocUnsafe(64 * 1024);
+    let total = 0;
+    for (;; ) {
+      const count = readSync(descriptor, buffer, 0, buffer.byteLength, null);
+      if (count === 0)
+        break;
+      total += count;
+      if (total > MAX_COOKIE_BYTES)
+        return { ok: false, reason: "too-large" };
+      chunks.push(Buffer.from(buffer.subarray(0, count)));
+    }
+    let text;
+    try {
+      text = new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(chunks, total));
+    } catch {
+      return { ok: false, reason: "invalid" };
+    }
+    return parseCookiePayload(text, target);
+  } catch {
+    return { ok: false, reason: "unavailable" };
+  } finally {
+    closeSync(descriptor);
+  }
+}
+function filterCookieProviderResult(value, target) {
+  if (!isRecord(value) || !Array.isArray(value.cookies)) {
+    return { validShape: false, cookies: [], rejected: 0, providerWarningCount: 0 };
+  }
+  const provenancePreserving = value.cookies.filter((cookie) => isRecord(cookie) && typeof cookie.hostOnly === "boolean");
+  const missingProvenance = value.cookies.length - provenancePreserving.length;
+  const filtered = filterCookies(provenancePreserving, target, Math.floor(Date.now() / 1000));
+  return {
+    validShape: true,
+    ...filtered,
+    rejected: filtered.rejected + missingProvenance,
+    providerWarningCount: Array.isArray(value.warnings) ? value.warnings.length : 0
+  };
+}
+function renderCookieHeader(cookies) {
+  return cookies.map(({ name, value }) => `${name}=${value}`).join("; ");
+}
+function renderNetscapeCookieJar(cookies, target) {
+  const hostname = target.hostname.toLowerCase().replace(/^\[|\]$/g, "");
+  return [
+    "# Netscape HTTP Cookie File",
+    "# Created temporarily by wordcell clip; deleted after media capture.",
+    ...cookies.map((cookie) => {
+      const domain = `${cookie.httpOnly ? "#HttpOnly_" : ""}${hostname}`;
+      return `${domain}	FALSE	${cookie.path}	${cookie.secure ? "TRUE" : "FALSE"}	${cookie.expires}	${cookie.name}	${cookie.value}`;
+    }),
+    ""
+  ].join(`
+`);
+}
+
+export { MAX_COOKIE_RECORDS, MAX_COOKIE_BYTES, filterCookies, parseCookiePayload, readCookieFile, filterCookieProviderResult, renderCookieHeader, renderNetscapeCookieJar };

package/dist/index-3ehtt59c.js

@@ -0,0 +1,199 @@
+// @bun
+import {
+  fuseRankedCandidates
+} from "./index-why54q5p.js";
+
+// src/benchmark.ts
+var MAX_BENCHMARK_CASES = 500;
+var MAX_BENCHMARK_SYSTEMS = 16;
+var MAX_JUDGMENTS_PER_CASE = 1000;
+var MAX_RESULTS_PER_RANKING = 1000;
+var MAX_CUTOFF = 100;
+var MAX_RELEVANCE = 10;
+function checkedCutoff(value) {
+  const cutoff = value ?? 10;
+  if (!Number.isSafeInteger(cutoff) || cutoff < 1 || cutoff > MAX_CUTOFF) {
+    throw new RangeError(`Benchmark cutoff must be an integer from 1 through ${MAX_CUTOFF}.`);
+  }
+  return cutoff;
+}
+function checkedLabel(value, label) {
+  if (value.trim() === "" || value !== value.trim()) {
+    throw new Error(`${label} must be non-empty and have no outer whitespace.`);
+  }
+  return value;
+}
+function validatedJudgments(judgments) {
+  if (judgments.length === 0 || judgments.length > MAX_JUDGMENTS_PER_CASE) {
+    throw new RangeError(`A benchmark case requires from 1 through ${MAX_JUDGMENTS_PER_CASE} judgments.`);
+  }
+  const result = new Map;
+  for (const judgment of judgments) {
+    const id = checkedLabel(judgment.id, "Judgment id");
+    if (result.has(id))
+      throw new Error(`Duplicate judgment id: ${id}`);
+    if (!Number.isSafeInteger(judgment.relevance) || judgment.relevance < 1 || judgment.relevance > MAX_RELEVANCE) {
+      throw new RangeError(`Judgment relevance must be an integer from 1 through ${MAX_RELEVANCE}.`);
+    }
+    result.set(id, judgment.relevance);
+  }
+  return result;
+}
+function validatedRanking(ids) {
+  if (ids.length > MAX_RESULTS_PER_RANKING) {
+    throw new RangeError(`A benchmark ranking may contain at most ${MAX_RESULTS_PER_RANKING} results.`);
+  }
+  const seen = new Set;
+  return ids.map((rawId) => {
+    const id = checkedLabel(rawId, "Ranking result id");
+    if (seen.has(id))
+      throw new Error(`Duplicate ranking result id: ${id}`);
+    seen.add(id);
+    return id;
+  });
+}
+function discount(rank) {
+  return Math.log2(rank + 1);
+}
+function gain(relevance) {
+  return 2 ** relevance - 1;
+}
+function metricsForValidatedRanking(ranking, judgments, cutoff) {
+  const top = ranking.slice(0, cutoff);
+  let relevantRetrieved = 0;
+  let firstRelevantRank = null;
+  let dcg = 0;
+  for (const [index, id] of top.entries()) {
+    const relevance = judgments.get(id) ?? 0;
+    if (relevance === 0)
+      continue;
+    relevantRetrieved += 1;
+    firstRelevantRank ??= index + 1;
+    dcg += gain(relevance) / discount(index + 1);
+  }
+  const idealDcg = [...judgments.values()].toSorted((left, right) => right - left).slice(0, cutoff).reduce((sum, relevance, index) => sum + gain(relevance) / discount(index + 1), 0);
+  return {
+    recallAtK: relevantRetrieved / judgments.size,
+    mrrAtK: firstRelevantRank === null ? 0 : 1 / firstRelevantRank,
+    ndcgAtK: Math.min(1, dcg / idealDcg)
+  };
+}
+function evaluateRanking(ranking, judgments, cutoff = 10) {
+  return metricsForValidatedRanking(validatedRanking(ranking), validatedJudgments(judgments), checkedCutoff(cutoff));
+}
+function averageMetrics(evaluations) {
+  if (evaluations.length === 0) {
+    return { recallAtK: 0, mrrAtK: 0, ndcgAtK: 0 };
+  }
+  const totals = evaluations.reduce((sum, evaluation) => ({
+    recallAtK: sum.recallAtK + evaluation.metrics.recallAtK,
+    mrrAtK: sum.mrrAtK + evaluation.metrics.mrrAtK,
+    ndcgAtK: sum.ndcgAtK + evaluation.metrics.ndcgAtK
+  }), { recallAtK: 0, mrrAtK: 0, ndcgAtK: 0 });
+  return {
+    recallAtK: totals.recallAtK / evaluations.length,
+    mrrAtK: totals.mrrAtK / evaluations.length,
+    ndcgAtK: totals.ndcgAtK / evaluations.length
+  };
+}
+function aggregateSystems(cases, systems) {
+  return systems.map((system) => {
+    const evaluations = cases.map((benchmarkCase) => {
+      const evaluation = benchmarkCase.systems.find((item) => item.system === system);
+      if (evaluation === undefined) {
+        throw new Error(`Missing system ${system} in evaluated case ${benchmarkCase.id}.`);
+      }
+      return evaluation;
+    });
+    return {
+      system,
+      caseCount: evaluations.length,
+      metrics: averageMetrics(evaluations)
+    };
+  });
+}
+function evaluateRetrievalBenchmark(benchmarkCases, options = {}) {
+  const cutoff = checkedCutoff(options.cutoff);
+  if (benchmarkCases.length === 0 || benchmarkCases.length > MAX_BENCHMARK_CASES) {
+    throw new RangeError(`A retrieval benchmark requires from 1 through ${MAX_BENCHMARK_CASES} cases.`);
+  }
+  const caseIds = new Set;
+  let expectedSystems = null;
+  const evaluated = benchmarkCases.map((benchmarkCase) => {
+    const id = checkedLabel(benchmarkCase.id, "Benchmark case id");
+    const queryClass = checkedLabel(benchmarkCase.queryClass, "Query class");
+    if (caseIds.has(id))
+      throw new Error(`Duplicate benchmark case id: ${id}`);
+    caseIds.add(id);
+    const judgments = validatedJudgments(benchmarkCase.judgments);
+    if (benchmarkCase.rankings.length === 0 || benchmarkCase.rankings.length > MAX_BENCHMARK_SYSTEMS) {
+      throw new RangeError(`A benchmark case requires from 1 through ${MAX_BENCHMARK_SYSTEMS} systems.`);
+    }
+    const systemNames = new Set;
+    const systems2 = benchmarkCase.rankings.map((ranking) => {
+      const system = checkedLabel(ranking.system, "Benchmark system");
+      if (systemNames.has(system))
+        throw new Error(`Duplicate benchmark system: ${system}`);
+      systemNames.add(system);
+      return {
+        system,
+        metrics: metricsForValidatedRanking(validatedRanking(ranking.ids), judgments, cutoff)
+      };
+    }).toSorted((left, right) => left.system.localeCompare(right.system));
+    const names = systems2.map(({ system }) => system);
+    if (expectedSystems === null) {
+      expectedSystems = names;
+    } else if (names.length !== expectedSystems.length || names.some((name, index) => name !== expectedSystems?.[index])) {
+      throw new Error("Every benchmark case must contain the same systems.");
+    }
+    return { id, queryClass, systems: systems2 };
+  }).toSorted((left, right) => left.id.localeCompare(right.id));
+  const systems = expectedSystems ?? [];
+  const queryClasses = [...new Set(evaluated.map(({ queryClass }) => queryClass))].toSorted((left, right) => left.localeCompare(right));
+  return {
+    cutoff,
+    cases: evaluated,
+    overall: aggregateSystems(evaluated, systems),
+    byClass: queryClasses.map((queryClass) => {
+      const matching = evaluated.filter((item) => item.queryClass === queryClass);
+      return {
+        queryClass,
+        caseCount: matching.length,
+        systems: aggregateSystems(matching, systems)
+      };
+    })
+  };
+}
+function fixtureCase(id, queryClass, judgments, exact, semanticLike) {
+  const hybrid = fuseRankedCandidates([
+    { name: "exact", weight: 1, ids: exact },
+    { name: "semantic-like", weight: 1, ids: semanticLike }
+  ]).map(({ id: resultId }) => resultId);
+  return {
+    id,
+    queryClass,
+    judgments,
+    rankings: [
+      { system: "exact", ids: exact },
+      { system: "hybrid-rrf", ids: hybrid },
+      { system: "semantic-like", ids: semanticLike }
+    ]
+  };
+}
+function createSyntheticRankFusionFixture() {
+  return [
+    fixtureCase("alias-identity", "identity", [{ id: "write-path", relevance: 3 }, { id: "agent-memory", relevance: 1 }], ["write-path", "agent-memory", "durable-notes"], ["durable-notes", "context-window", "write-path", "agent-memory"]),
+    fixtureCase("literal-title", "identity", [{ id: "repository-context", relevance: 3 }], ["repository-context", "repository-map"], ["repository-map", "repository-context", "shared-context"]),
+    fixtureCase("paraphrased-memory", "conceptual", [{ id: "durable-memory", relevance: 3 }, { id: "write-path", relevance: 1 }], ["chat-history", "context-window", "durable-memory", "write-path"], ["durable-memory", "write-path", "chat-history"]),
+    fixtureCase("meaning-without-keywords", "conceptual", [{ id: "retrieval-fusion", relevance: 3 }, { id: "local-search", relevance: 2 }], ["retrieval-fusion", "ranking-noise", "local-search"], ["embedding-noise", "retrieval-fusion", "local-search"]),
+    fixtureCase("implementation-decision", "mixed", [
+      { id: "decision", relevance: 3 },
+      { id: "evidence", relevance: 2 },
+      { id: "history", relevance: 1 }
+    ], ["decision", "filename-noise", "evidence", "tag-noise", "history"], ["semantic-noise", "evidence", "decision", "history"]),
+    fixtureCase("plan-context", "mixed", [{ id: "active-plan", relevance: 3 }, { id: "prior-rationale", relevance: 2 }], ["active-plan", "status-noise", "prior-rationale"], ["concept-noise", "prior-rationale", "active-plan"])
+  ];
+}
+var createRepresentativeRetrievalFixture = createSyntheticRankFusionFixture;
+
+export { evaluateRanking, evaluateRetrievalBenchmark, createSyntheticRankFusionFixture, createRepresentativeRetrievalFixture };