@ainyc/canonry 4.85.0 → 4.86.0

package/dist/{chunk-I2BJC3DT.js → chunk-23HGQV22.js}

@@ -1832,6 +1832,210 @@ import { z as z18 } from "zod";
 
 // ../contracts/src/discovery.ts
 import { z as z17 } from "zod";
+
+// ../contracts/src/embeddings.ts
+function cosineSimilarity(a, b) {
+  if (a.length === 0 || b.length === 0) {
+    throw new Error("cosineSimilarity: vectors must be non-empty");
+  }
+  if (a.length !== b.length) {
+    throw new Error(`cosineSimilarity: vector length mismatch (${a.length} vs ${b.length})`);
+  }
+  let dot = 0;
+  let magA = 0;
+  let magB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    magA += a[i] * a[i];
+    magB += b[i] * b[i];
+  }
+  if (magA === 0 || magB === 0) return 0;
+  return dot / (Math.sqrt(magA) * Math.sqrt(magB));
+}
+function clusterByCosine(items, vectors, threshold) {
+  if (threshold < 0 || threshold > 1) {
+    throw new Error(`clusterByCosine: threshold must be in [0, 1], got ${threshold}`);
+  }
+  if (items.length !== vectors.length) {
+    throw new Error(`clusterByCosine: items/vectors length mismatch (${items.length} vs ${vectors.length})`);
+  }
+  if (items.length === 0) return [];
+  const parent = items.map((_, i) => i);
+  const find = (x) => {
+    let root = x;
+    while (parent[root] !== root) root = parent[root];
+    let cur = x;
+    while (parent[cur] !== root) {
+      const next = parent[cur];
+      parent[cur] = root;
+      cur = next;
+    }
+    return root;
+  };
+  const union = (a, b) => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) parent[ra] = rb;
+  };
+  for (let i = 0; i < items.length; i++) {
+    for (let j = i + 1; j < items.length; j++) {
+      if (cosineSimilarity(vectors[i], vectors[j]) >= threshold) {
+        union(i, j);
+      }
+    }
+  }
+  const byRoot = /* @__PURE__ */ new Map();
+  for (let i = 0; i < items.length; i++) {
+    const root = find(i);
+    const existing = byRoot.get(root);
+    if (existing) existing.push(i);
+    else byRoot.set(root, [i]);
+  }
+  return Array.from(byRoot.values()).map((indices) => indices.map((idx) => items[idx]));
+}
+function pickClusterRepresentative(cluster) {
+  if (cluster.length === 0) throw new Error("pickClusterRepresentative: cluster is empty");
+  let best = cluster[0];
+  for (let i = 1; i < cluster.length; i++) {
+    if (cluster[i].length < best.length) best = cluster[i];
+  }
+  return best;
+}
+
+// ../contracts/src/url-normalize.ts
+var STRIP_KEYS = /* @__PURE__ */ new Set([
+  // Click identifiers
+  "fbclid",
+  "gclid",
+  "msclkid",
+  "ttclid",
+  "li_fat_id",
+  "igshid",
+  "yclid",
+  "dclid",
+  "gbraid",
+  "wbraid",
+  "bingid",
+  // Mailchimp
+  "mc_cid",
+  "mc_eid",
+  // Google Analytics linkers
+  "_ga",
+  "_gl",
+  // Google Tag Manager debug
+  "gtm_latency",
+  "gtm_debug",
+  // WordPress internal noise
+  "preview",
+  "preview_id",
+  "preview_nonce",
+  "_thumbnail_id",
+  // Common cache-busters/versioning
+  "v",
+  "ver",
+  "version"
+]);
+function shouldStrip(key) {
+  if (STRIP_KEYS.has(key)) return true;
+  if (key.startsWith("utm_")) return true;
+  return false;
+}
+function parseQuery(query) {
+  if (query === "") return [];
+  return query.split("&").map((pair) => {
+    const eq = pair.indexOf("=");
+    if (eq === -1) return { key: pair, value: null };
+    return { key: pair.slice(0, eq), value: pair.slice(eq + 1) };
+  });
+}
+function encodeQuery(pairs) {
+  return pairs.map((p) => p.value === null ? p.key : `${p.key}=${p.value}`).join("&");
+}
+function collapseRootIndex(path) {
+  if (path === "/index.html" || path === "/index.php") return "/";
+  return path;
+}
+function dropTrailingSlash(path) {
+  if (path.length > 1 && path.endsWith("/")) {
+    return path.replace(/\/+$/, "");
+  }
+  return path;
+}
+function absolutizeProjectUrl(url, canonicalDomain) {
+  if (!url) return "";
+  const trimmed = url.trim();
+  if (!trimmed) return "";
+  if (/^https?:\/\//i.test(trimmed)) return trimmed;
+  if (trimmed.startsWith("//")) return `https:${trimmed}`;
+  const host = canonicalDomain.trim().replace(/^https?:\/\//i, "").replace(/\/+$/, "");
+  if (!host) return trimmed;
+  if (trimmed.startsWith("/")) return `https://${host}${trimmed}`;
+  return `https://${host}/${trimmed}`;
+}
+function hostOf(value) {
+  if (value == null) return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  try {
+    const url = trimmed.includes("://") ? new URL(trimmed) : new URL(`https://${trimmed}`);
+    return url.hostname.replace(/^www\./, "").toLowerCase();
+  } catch {
+    return null;
+  }
+}
+function normalizeUrlPath(input) {
+  if (input == null) return null;
+  let trimmed = input.trim();
+  if (trimmed === "") return null;
+  trimmed = trimmed.replace(/&nbsp;/g, " ").replace(/\s+/g, " ").trim();
+  if (trimmed === "" || trimmed === "/") return "/";
+  if (trimmed === "(not set)") return null;
+  trimmed = trimmed.replace(/([a-z0-9])[).]+$/i, "$1");
+  if (trimmed.startsWith("/)") || trimmed.startsWith("/ ")) {
+    trimmed = "/";
+  }
+  if (trimmed.includes(" ")) {
+    trimmed = trimmed.split(" ")[0];
+  }
+  if (trimmed === "" || trimmed === "/") return "/";
+  let pathPart;
+  let queryPart;
+  if (/^https?:\/\//i.test(trimmed)) {
+    let url;
+    try {
+      url = new URL(trimmed);
+    } catch {
+      return null;
+    }
+    pathPart = url.pathname || "/";
+    queryPart = url.search.startsWith("?") ? url.search.slice(1) : url.search;
+  } else {
+    let raw = trimmed;
+    const hashIdx = raw.indexOf("#");
+    if (hashIdx !== -1) raw = raw.slice(0, hashIdx);
+    const qIdx = raw.indexOf("?");
+    if (qIdx === -1) {
+      pathPart = raw;
+      queryPart = "";
+    } else {
+      pathPart = raw.slice(0, qIdx);
+      queryPart = raw.slice(qIdx + 1);
+    }
+  }
+  if (pathPart === "") pathPart = "/";
+  pathPart = collapseRootIndex(pathPart);
+  pathPart = dropTrailingSlash(pathPart);
+  const pairs = parseQuery(queryPart).filter((p) => !shouldStrip(p.key));
+  pairs.sort((a, b) => {
+    if (a.key < b.key) return -1;
+    if (a.key > b.key) return 1;
+    return 0;
+  });
+  if (pairs.length === 0) return pathPart;
+  return `${pathPart}?${encodeQuery(pairs)}`;
+}
+
+// ../contracts/src/discovery.ts
 var discoveryBucketSchema = z17.enum(["cited", "aspirational", "wasted-surface"]);
 var DiscoveryBuckets = discoveryBucketSchema.enum;
 var DEFAULT_DISCOVERY_PROMOTE_BUCKETS = [
@@ -1963,6 +2167,231 @@ var queryProvenanceSchema = z17.union([
   z17.literal("cli"),
   z17.string().regex(/^discovery:.+$/)
 ]);
+var DISCOVERY_HARVEST_MAX_WORDS = 12;
+var DISCOVERY_HARVEST_MIN_CHARS = 3;
+var DISCOVERY_HARVEST_NOVELTY_THRESHOLD = DISCOVERY_DEFAULT_DEDUP_THRESHOLD;
+var DISCOVERY_HARVEST_MIN_ANCHOR_TERMS = 1;
+var DISCOVERY_HARVEST_PHONE_DIGITS = 7;
+var HARVEST_SIGNIFICANT_TOKEN_MIN = 4;
+var HARVEST_STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "with",
+  "near",
+  "best",
+  "top",
+  "your",
+  "you",
+  "are",
+  "how",
+  "what",
+  "does",
+  "this",
+  "that",
+  "from",
+  "into",
+  "about",
+  "who",
+  "why"
+]);
+var HARVEST_NAV_MARKERS = [
+  "address",
+  "directions",
+  "hours",
+  "login",
+  "log in",
+  "sign in",
+  "signin",
+  "phone number",
+  "zip code",
+  "postal code",
+  "email address"
+];
+var discoveryHarvestCandidateSchema = z17.object({
+  query: z17.string().min(1),
+  probeHits: z17.number().int().positive()
+});
+var discoveryHarvestStatsSchema = z17.object({
+  /** Distinct candidates extracted before gating. */
+  rawCandidates: z17.number().int().nonnegative(),
+  /** Candidates that passed every gate. */
+  admitted: z17.number().int().nonnegative(),
+  /** Per-reason rejection tally (each rejected candidate counted exactly once,
+   *  at the first gate it failed). Lexical-gate order: belowFloor → length →
+   *  navigational → duplicate (EXACT already-tracked) → offAnchor; then
+   *  `semanticDuplicate` for candidates dropped by the cosine novelty pass.
+   *  Invariant: `admitted + Σ(rejected) === rawCandidates`. */
+  rejected: z17.object({
+    belowFloor: z17.number().int().nonnegative(),
+    length: z17.number().int().nonnegative(),
+    navigational: z17.number().int().nonnegative(),
+    /** Dropped by the cheap exact-match check against the tracked basket. */
+    duplicate: z17.number().int().nonnegative(),
+    offAnchor: z17.number().int().nonnegative(),
+    /** Dropped by the embedding cosine novelty pass (a paraphrase / synonym /
+     *  stem variant of a tracked query that exact match can't see). 0 when the
+     *  semantic pass did not run — see `semanticNoveltyApplied`. */
+    semanticDuplicate: z17.number().int().nonnegative()
+  })
+});
+var discoveryHarvestDtoSchema = z17.object({
+  sessionId: z17.string(),
+  projectId: z17.string(),
+  /** The provider whose probes were harvested (the session's seed provider).
+   *  Discovery is Gemini-only today; carried so a future multi-provider
+   *  discovery can attribute candidates. */
+  provider: z17.string(),
+  status: discoverySessionStatusSchema,
+  /** Recurrence floor applied: a candidate must have appeared in ≥ this many
+   *  distinct probes to be admitted. */
+  minProbeHits: z17.number().int().positive(),
+  /** Whether the subject-anchor filter actually ran (requested AND the corpus
+   *  had ≥ `DISCOVERY_HARVEST_MIN_ANCHOR_TERMS` significant terms). */
+  anchorApplied: z17.boolean(),
+  /** Whether the embedding cosine novelty pass ran. False when embeddings were
+   *  unavailable (no Gemini key / no tracked queries / no candidates), in which
+   *  case novelty fell back to the cheap exact-match check only. */
+  semanticNoveltyApplied: z17.boolean(),
+  candidates: z17.array(discoveryHarvestCandidateSchema),
+  stats: discoveryHarvestStatsSchema
+});
+function normalizeHarvestQuery(query) {
+  return query.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function harvestTokens(query) {
+  return normalizeHarvestQuery(query).split(/[^a-z0-9]+/).filter(Boolean);
+}
+function significantHarvestTokens(query) {
+  return harvestTokens(query).filter(
+    (t) => t.length >= HARVEST_SIGNIFICANT_TOKEN_MIN && !HARVEST_STOPWORDS.has(t)
+  );
+}
+function longestDigitRun(query) {
+  let max = 0;
+  let run = 0;
+  for (const ch of query) {
+    if (ch >= "0" && ch <= "9") {
+      run++;
+      if (run > max) max = run;
+    } else {
+      run = 0;
+    }
+  }
+  return max;
+}
+function isNavigationalHarvestQuery(query) {
+  const norm = normalizeHarvestQuery(query);
+  if (longestDigitRun(norm) >= DISCOVERY_HARVEST_PHONE_DIGITS) return true;
+  const tokens = new Set(harvestTokens(norm));
+  for (const marker of HARVEST_NAV_MARKERS) {
+    if (marker.includes(" ")) {
+      const re = new RegExp(`(?<![a-z0-9])${marker.replace(/ /g, "\\s+")}(?![a-z0-9])`);
+      if (re.test(norm)) return true;
+    } else if (tokens.has(marker)) {
+      return true;
+    }
+  }
+  return false;
+}
+function buildHarvestAnchorTerms(corpus, domains = []) {
+  const set = /* @__PURE__ */ new Set();
+  for (const text of corpus) {
+    for (const token of significantHarvestTokens(text)) set.add(token);
+  }
+  for (const domain of domains) {
+    const host = hostOf(domain);
+    if (!host) continue;
+    const label = host.replace(/\.[a-z0-9]+$/, "");
+    for (const token of significantHarvestTokens(label)) set.add(token);
+  }
+  return [...set];
+}
+function gateHarvestedSearchQueries(input) {
+  const minProbeHits = Math.max(1, Math.floor(input.minProbeHits ?? 1));
+  const anchorTermSet = new Set(input.anchorTerms ?? []);
+  const applyAnchor = (input.applyAnchor ?? true) && anchorTermSet.size >= DISCOVERY_HARVEST_MIN_ANCHOR_TERMS;
+  const trackedNorm = new Set(
+    input.trackedQueries.map(normalizeHarvestQuery).filter(Boolean)
+  );
+  const stats = {
+    rawCandidates: input.candidates.length,
+    admitted: 0,
+    rejected: { belowFloor: 0, length: 0, navigational: 0, duplicate: 0, offAnchor: 0, semanticDuplicate: 0 }
+  };
+  const admitted = [];
+  for (const candidate of input.candidates) {
+    if (candidate.probeHits < minProbeHits) {
+      stats.rejected.belowFloor++;
+      continue;
+    }
+    const norm = normalizeHarvestQuery(candidate.query);
+    const words = norm ? norm.split(" ").length : 0;
+    if (norm.length < DISCOVERY_HARVEST_MIN_CHARS || words > DISCOVERY_HARVEST_MAX_WORDS) {
+      stats.rejected.length++;
+      continue;
+    }
+    if (isNavigationalHarvestQuery(norm)) {
+      stats.rejected.navigational++;
+      continue;
+    }
+    if (trackedNorm.has(norm)) {
+      stats.rejected.duplicate++;
+      continue;
+    }
+    if (applyAnchor) {
+      const sig = significantHarvestTokens(norm);
+      if (!sig.some((t) => anchorTermSet.has(t))) {
+        stats.rejected.offAnchor++;
+        continue;
+      }
+    }
+    admitted.push({ query: norm, probeHits: candidate.probeHits });
+    stats.admitted++;
+  }
+  admitted.sort((a, b) => b.probeHits - a.probeHits || a.query.localeCompare(b.query));
+  return { admitted, anchorApplied: applyAnchor, stats };
+}
+function applyHarvestSemanticNovelty(input) {
+  const { result, candidateVectors, trackedVectors } = input;
+  const threshold = input.threshold ?? DISCOVERY_HARVEST_NOVELTY_THRESHOLD;
+  if (candidateVectors.length !== result.admitted.length || trackedVectors.length === 0) {
+    return result;
+  }
+  const admitted = [];
+  let semanticDuplicate = 0;
+  for (let i = 0; i < result.admitted.length; i++) {
+    const vec = candidateVectors[i];
+    const isDup = trackedVectors.some((t) => cosineSimilarity(vec, t) >= threshold);
+    if (isDup) semanticDuplicate++;
+    else admitted.push(result.admitted[i]);
+  }
+  return {
+    admitted,
+    anchorApplied: result.anchorApplied,
+    stats: {
+      ...result.stats,
+      admitted: admitted.length,
+      rejected: { ...result.stats.rejected, semanticDuplicate }
+    }
+  };
+}
+function aggregateHarvestedQueries(probes) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const probe of probes) {
+    const seenInProbe = /* @__PURE__ */ new Set();
+    for (const raw of probe.searchQueries) {
+      if (typeof raw !== "string") continue;
+      const norm = normalizeHarvestQuery(raw);
+      if (!norm || seenInProbe.has(norm)) continue;
+      seenInProbe.add(norm);
+      const existing = counts.get(norm);
+      if (existing) existing.probeHits++;
+      else counts.set(norm, { query: norm, probeHits: 1 });
+    }
+  }
+  return [...counts.values()];
+}
 
 // ../contracts/src/surface-class.ts
 var surfaceClassSchema = z18.enum([
@@ -3104,139 +3533,6 @@ function summarizeCheckResults(results) {
   return summary;
 }
 
-// ../contracts/src/url-normalize.ts
-var STRIP_KEYS = /* @__PURE__ */ new Set([
-  // Click identifiers
-  "fbclid",
-  "gclid",
-  "msclkid",
-  "ttclid",
-  "li_fat_id",
-  "igshid",
-  "yclid",
-  "dclid",
-  "gbraid",
-  "wbraid",
-  "bingid",
-  // Mailchimp
-  "mc_cid",
-  "mc_eid",
-  // Google Analytics linkers
-  "_ga",
-  "_gl",
-  // Google Tag Manager debug
-  "gtm_latency",
-  "gtm_debug",
-  // WordPress internal noise
-  "preview",
-  "preview_id",
-  "preview_nonce",
-  "_thumbnail_id",
-  // Common cache-busters/versioning
-  "v",
-  "ver",
-  "version"
-]);
-function shouldStrip(key) {
-  if (STRIP_KEYS.has(key)) return true;
-  if (key.startsWith("utm_")) return true;
-  return false;
-}
-function parseQuery(query) {
-  if (query === "") return [];
-  return query.split("&").map((pair) => {
-    const eq = pair.indexOf("=");
-    if (eq === -1) return { key: pair, value: null };
-    return { key: pair.slice(0, eq), value: pair.slice(eq + 1) };
-  });
-}
-function encodeQuery(pairs) {
-  return pairs.map((p) => p.value === null ? p.key : `${p.key}=${p.value}`).join("&");
-}
-function collapseRootIndex(path) {
-  if (path === "/index.html" || path === "/index.php") return "/";
-  return path;
-}
-function dropTrailingSlash(path) {
-  if (path.length > 1 && path.endsWith("/")) {
-    return path.replace(/\/+$/, "");
-  }
-  return path;
-}
-function absolutizeProjectUrl(url, canonicalDomain) {
-  if (!url) return "";
-  const trimmed = url.trim();
-  if (!trimmed) return "";
-  if (/^https?:\/\//i.test(trimmed)) return trimmed;
-  if (trimmed.startsWith("//")) return `https:${trimmed}`;
-  const host = canonicalDomain.trim().replace(/^https?:\/\//i, "").replace(/\/+$/, "");
-  if (!host) return trimmed;
-  if (trimmed.startsWith("/")) return `https://${host}${trimmed}`;
-  return `https://${host}/${trimmed}`;
-}
-function hostOf(value) {
-  if (value == null) return null;
-  const trimmed = value.trim();
-  if (!trimmed) return null;
-  try {
-    const url = trimmed.includes("://") ? new URL(trimmed) : new URL(`https://${trimmed}`);
-    return url.hostname.replace(/^www\./, "").toLowerCase();
-  } catch {
-    return null;
-  }
-}
-function normalizeUrlPath(input) {
-  if (input == null) return null;
-  let trimmed = input.trim();
-  if (trimmed === "") return null;
-  trimmed = trimmed.replace(/&nbsp;/g, " ").replace(/\s+/g, " ").trim();
-  if (trimmed === "" || trimmed === "/") return "/";
-  if (trimmed === "(not set)") return null;
-  trimmed = trimmed.replace(/([a-z0-9])[).]+$/i, "$1");
-  if (trimmed.startsWith("/)") || trimmed.startsWith("/ ")) {
-    trimmed = "/";
-  }
-  if (trimmed.includes(" ")) {
-    trimmed = trimmed.split(" ")[0];
-  }
-  if (trimmed === "" || trimmed === "/") return "/";
-  let pathPart;
-  let queryPart;
-  if (/^https?:\/\//i.test(trimmed)) {
-    let url;
-    try {
-      url = new URL(trimmed);
-    } catch {
-      return null;
-    }
-    pathPart = url.pathname || "/";
-    queryPart = url.search.startsWith("?") ? url.search.slice(1) : url.search;
-  } else {
-    let raw = trimmed;
-    const hashIdx = raw.indexOf("#");
-    if (hashIdx !== -1) raw = raw.slice(0, hashIdx);
-    const qIdx = raw.indexOf("?");
-    if (qIdx === -1) {
-      pathPart = raw;
-      queryPart = "";
-    } else {
-      pathPart = raw.slice(0, qIdx);
-      queryPart = raw.slice(qIdx + 1);
-    }
-  }
-  if (pathPart === "") pathPart = "/";
-  pathPart = collapseRootIndex(pathPart);
-  pathPart = dropTrailingSlash(pathPart);
-  const pairs = parseQuery(queryPart).filter((p) => !shouldStrip(p.key));
-  pairs.sort((a, b) => {
-    if (a.key < b.key) return -1;
-    if (a.key > b.key) return 1;
-    return 0;
-  });
-  if (pairs.length === 0) return pathPart;
-  return `${pathPart}?${encodeQuery(pairs)}`;
-}
-
 // ../contracts/src/citations.ts
 import { z as z27 } from "zod";
 var citationCoverageProviderSchema = z27.object({
@@ -4293,75 +4589,6 @@ var trafficEventsResponseSchema = z30.object({
   events: z30.array(trafficEventEntrySchema)
 });
 
-// ../contracts/src/embeddings.ts
-function cosineSimilarity(a, b) {
-  if (a.length === 0 || b.length === 0) {
-    throw new Error("cosineSimilarity: vectors must be non-empty");
-  }
-  if (a.length !== b.length) {
-    throw new Error(`cosineSimilarity: vector length mismatch (${a.length} vs ${b.length})`);
-  }
-  let dot = 0;
-  let magA = 0;
-  let magB = 0;
-  for (let i = 0; i < a.length; i++) {
-    dot += a[i] * b[i];
-    magA += a[i] * a[i];
-    magB += b[i] * b[i];
-  }
-  if (magA === 0 || magB === 0) return 0;
-  return dot / (Math.sqrt(magA) * Math.sqrt(magB));
-}
-function clusterByCosine(items, vectors, threshold) {
-  if (threshold < 0 || threshold > 1) {
-    throw new Error(`clusterByCosine: threshold must be in [0, 1], got ${threshold}`);
-  }
-  if (items.length !== vectors.length) {
-    throw new Error(`clusterByCosine: items/vectors length mismatch (${items.length} vs ${vectors.length})`);
-  }
-  if (items.length === 0) return [];
-  const parent = items.map((_, i) => i);
-  const find = (x) => {
-    let root = x;
-    while (parent[root] !== root) root = parent[root];
-    let cur = x;
-    while (parent[cur] !== root) {
-      const next = parent[cur];
-      parent[cur] = root;
-      cur = next;
-    }
-    return root;
-  };
-  const union = (a, b) => {
-    const ra = find(a);
-    const rb = find(b);
-    if (ra !== rb) parent[ra] = rb;
-  };
-  for (let i = 0; i < items.length; i++) {
-    for (let j = i + 1; j < items.length; j++) {
-      if (cosineSimilarity(vectors[i], vectors[j]) >= threshold) {
-        union(i, j);
-      }
-    }
-  }
-  const byRoot = /* @__PURE__ */ new Map();
-  for (let i = 0; i < items.length; i++) {
-    const root = find(i);
-    const existing = byRoot.get(root);
-    if (existing) existing.push(i);
-    else byRoot.set(root, [i]);
-  }
-  return Array.from(byRoot.values()).map((indices) => indices.map((idx) => items[idx]));
-}
-function pickClusterRepresentative(cluster) {
-  if (cluster.length === 0) throw new Error("pickClusterRepresentative: cluster is empty");
-  let best = cluster[0];
-  for (let i = 1; i < cluster.length; i++) {
-    if (cluster[i].length < best.length) best = cluster[i];
-  }
-  return best;
-}
-
 // ../contracts/src/formatting.ts
 function formatRatio(value) {
   if (!Number.isFinite(value) || value === 0) return "0%";
@@ -4736,6 +4963,11 @@ export {
   categorizeSource,
   categorizeSourceWithCompetitors,
   categoryLabel,
+  clusterByCosine,
+  pickClusterRepresentative,
+  absolutizeProjectUrl,
+  hostOf,
+  normalizeUrlPath,
   discoveryBucketSchema,
   DiscoveryBuckets,
   DEFAULT_DISCOVERY_PROMOTE_BUCKETS,
@@ -4754,6 +4986,11 @@ export {
   discoveryPromoteRequestSchema,
   discoveryPromotePreviewSchema,
   discoveryPromoteResultSchema,
+  discoveryHarvestDtoSchema,
+  buildHarvestAnchorTerms,
+  gateHarvestedSearchQueries,
+  applyHarvestSemanticNovelty,
+  aggregateHarvestedQueries,
   surfaceClassLabel,
   surfaceClassFromCompetitorType,
   classifySurfaceFromCategory,
@@ -4815,9 +5052,6 @@ export {
   CheckCategories,
   doctorReportSchema,
   summarizeCheckResults,
-  absolutizeProjectUrl,
-  hostOf,
-  normalizeUrlPath,
   citationVisibilityResponseSchema,
   emptyCitationVisibility,
   citationStateToCited,
@@ -4854,8 +5088,6 @@ export {
   trafficEventKindSchema,
   TrafficEventKinds,
   trafficEventsResponseSchema,
-  clusterByCosine,
-  pickClusterRepresentative,
   formatRatio,
   formatNumber,
   formatDate,