@inerrata-corporation/errata 2.0.17-dev.3549 → 2.0.17-dev.3564

package/consolidate-worker.mjs

@@ -16611,6 +16611,7 @@ function rowToEdge(r) {
   };
 }
 var FINGERPRINT_INDEXED_LABELS = ["Problem", "Vulnerability", "Solution", "RootCause"];
+var NODE_LABELS_CHUNK = 256;
 var SqliteGraphStore = class {
   db;
   // Typed edge lookups build their SQL from the number of types asked for, and
@@ -17113,6 +17114,19 @@ var SqliteGraphStore = class {
     const row = this.stmts.getNode.get(id);
     return row ? rowToNode(row) : null;
   }
+  nodeLabels(ids) {
+    const width = NODE_LABELS_CHUNK;
+    const stmt = this.typedEdgeStmt(
+      `SELECT id, label FROM nodes WHERE id IN (${Array.from({ length: width }, () => "?").join(",")})`
+    );
+    const labels = /* @__PURE__ */ new Map();
+    for (let i = 0; i < ids.length; i += width) {
+      const chunk = ids.slice(i, i + width);
+      while (chunk.length < width) chunk.push(null);
+      for (const row of stmt.all(...chunk)) labels.set(row.id, row.label);
+    }
+    return labels;
+  }
   getEdge(id) {
     const row = this.stmts.getEdge.get(id);
     return row ? rowToEdge(row) : null;

package/errata.mjs

@@ -18445,7 +18445,7 @@ function rowToEdge(r) {
 function openGraphStore(opts) {
   return new SqliteGraphStore(opts);
 }
-var LOCAL_RULE_OVERRIDES, SCHEMA_VERSION, SESSION_REPAIR_KEY, SESSION_EVIDENCE_PREDICATE, SCHEMA_SQL, TEMPORAL_INDEX_SQL, FINGERPRINT_INDEXED_LABELS, SqliteGraphStore;
+var LOCAL_RULE_OVERRIDES, SCHEMA_VERSION, SESSION_REPAIR_KEY, SESSION_EVIDENCE_PREDICATE, SCHEMA_SQL, TEMPORAL_INDEX_SQL, FINGERPRINT_INDEXED_LABELS, NODE_LABELS_CHUNK, SqliteGraphStore;
 var init_store = __esm({
   "../../packages/local-graph/src/store.ts"() {
     "use strict";
@@ -18596,6 +18596,7 @@ CREATE INDEX IF NOT EXISTS nodes_live_description ON nodes(description, label) W
 CREATE INDEX IF NOT EXISTS nodes_anchor_hint_path ON nodes(json_extract(attrs_json, '$.anchorHint.path')) WHERE valid_to IS NULL;
 `;
     FINGERPRINT_INDEXED_LABELS = ["Problem", "Vulnerability", "Solution", "RootCause"];
+    NODE_LABELS_CHUNK = 256;
     SqliteGraphStore = class {
       db;
       // Typed edge lookups build their SQL from the number of types asked for, and
@@ -19098,6 +19099,19 @@ CREATE INDEX IF NOT EXISTS nodes_anchor_hint_path ON nodes(json_extract(attrs_js
         const row = this.stmts.getNode.get(id);
         return row ? rowToNode(row) : null;
       }
+      nodeLabels(ids) {
+        const width = NODE_LABELS_CHUNK;
+        const stmt = this.typedEdgeStmt(
+          `SELECT id, label FROM nodes WHERE id IN (${Array.from({ length: width }, () => "?").join(",")})`
+        );
+        const labels = /* @__PURE__ */ new Map();
+        for (let i2 = 0; i2 < ids.length; i2 += width) {
+          const chunk = ids.slice(i2, i2 + width);
+          while (chunk.length < width) chunk.push(null);
+          for (const row of stmt.all(...chunk)) labels.set(row.id, row.label);
+        }
+        return labels;
+      }
       getEdge(id) {
         const row = this.stmts.getEdge.get(id);
         return row ? rowToEdge(row) : null;
@@ -19600,7 +19614,9 @@ function staticConductance(edgeType) {
   return Math.max(UNKNOWN_CONDUCTANCE, Math.min(1, w / MAX_EDGE_WEIGHT));
 }
 function edgeConductance(edge2) {
-  const staticW = staticConductance(edge2.type);
+  return learnedConductance(staticConductance(edge2.type), edge2);
+}
+function learnedConductance(staticW, edge2) {
   const s = edge2.navSuccesses ?? 0;
   const f = edge2.navFailures ?? 0;
   const betaMean = (1 + s) / (2 + s + f);
@@ -22800,9 +22816,28 @@ var init_uncertainty = __esm({
 });
 
 // ../../packages/math/src/discovery.ts
+function typeRelevance(label) {
+  return TYPE_RELEVANCE[label] ?? DEFAULT_TYPE_RELEVANCE;
+}
+var TYPE_RELEVANCE, DEFAULT_TYPE_RELEVANCE;
 var init_discovery = __esm({
   "../../packages/math/src/discovery.ts"() {
     "use strict";
+    TYPE_RELEVANCE = {
+      Solution: 1,
+      Vulnerability: 0.95,
+      RootCause: 0.9,
+      Pattern: 0.8,
+      Problem: 0.7,
+      Technique: 0.7,
+      AntiPattern: 0.7,
+      Weakness: 0.6,
+      Domain: 0.5,
+      Function: 0.4,
+      Class: 0.4,
+      File: 0.3
+    };
+    DEFAULT_TYPE_RELEVANCE = 0.3;
   }
 });
 
@@ -25340,6 +25375,7 @@ __export(src_exports2, {
   isFragmentFixNote: () => isFragmentFixNote,
   isPlaceholderStatement: () => isPlaceholderStatement,
   isUnfilledPlaceholder: () => isUnfilledPlaceholder,
+  learnedConductance: () => learnedConductance,
   linkProblemToLanguages: () => linkProblemToLanguages,
   linkProblemToPackages: () => linkProblemToPackages,
   linkProblemToSymbols: () => linkProblemToSymbols,
@@ -32175,62 +32211,139 @@ async function rankForText(store, text, candidateIds) {
     (r) => r.score > 0
   );
 }
+function walksRelatedness(type) {
+  if (type === "DEPENDS_ON") return true;
+  if (PAGERANK_EXCLUSIONS.has(type)) return false;
+  return (EDGE_WEIGHT[type] ?? 1) > 0;
+}
+function burstStaticConductance(type, seedLabel) {
+  if (type === "ANCHORED_AT") return BURST_ANCHORED_AT_CONDUCTANCE;
+  if (type === "DEPENDS_ON") return seedLabel === "Package" ? staticConductance(type) : BURST_DEPENDS_ON_FLOOR;
+  return staticConductance(type);
+}
+function burstConductance(edge2, seedLabel) {
+  return learnedConductance(burstStaticConductance(edge2.type, seedLabel), edge2);
+}
 function localBurst(store, seedId, opts = {}) {
-  const maxHops = opts.maxHops ?? 2;
+  const maxHops = opts.maxHops ?? 3;
   const limit = opts.limit ?? 20;
-  const nodeCap = opts.nodeCap ?? 500;
+  const nodeCap = opts.nodeCap ?? 200;
   const seed = store.getNode(seedId);
   if (!seed) return [];
+  const act = /* @__PURE__ */ new Map([[seedId, 1]]);
   const hopOf = /* @__PURE__ */ new Map([[seedId, 0]]);
   const viaOf = /* @__PURE__ */ new Map();
-  let frontier = [seedId];
-  for (let h = 1; h <= maxHops && hopOf.size < nodeCap; h++) {
-    const next = [];
-    for (const id of frontier) {
-      const neigh = [
-        ...store.outEdges(id).map((e) => ({ nb: e.to, via: { edgeType: e.type, parentId: id, forward: true } })),
-        ...store.inEdges(id).map((e) => ({ nb: e.from, via: { edgeType: e.type, parentId: id, forward: false } }))
-      ];
-      for (const { nb, via } of neigh) {
-        if (!hopOf.has(nb)) {
-          hopOf.set(nb, h);
-          viaOf.set(nb, via);
-          next.push(nb);
-          if (hopOf.size >= nodeCap) break;
-        }
-      }
-      if (hopOf.size >= nodeCap) break;
-    }
-    frontier = next;
-  }
-  hopOf.delete(seedId);
+  const expanded = /* @__PURE__ */ new Set();
+  const frontier = new ActivationHeap();
+  frontier.push(seedId, 1);
+  let strongest = 0;
+  while (frontier.size > 0 && expanded.size < nodeCap) {
+    const top = frontier.pop();
+    if (expanded.has(top.id) || top.a < (act.get(top.id) ?? 0)) continue;
+    if (top.a < ACTIVATION_EPSILON || top.a < strongest * BURST_RELATIVE_FLOOR) break;
+    expanded.add(top.id);
+    const hops = hopOf.get(top.id) ?? 0;
+    if (hops >= maxHops) continue;
+    const edges = [
+      ...store.outEdges(top.id).map((e) => ({ e, nb: e.to, forward: true })),
+      ...store.inEdges(top.id).map((e) => ({ e, nb: e.from, forward: false }))
+    ].filter(({ e }) => walksRelatedness(e.type));
+    const damp = BURST_STEP_DAMPING / Math.sqrt(Math.max(1, edges.length));
+    for (const { e, nb, forward } of edges) {
+      if (nb === seedId || expanded.has(nb)) continue;
+      const a = top.a * burstConductance(e, seed.label) * damp;
+      if (a <= (act.get(nb) ?? 0)) continue;
+      act.set(nb, a);
+      if (a > strongest) strongest = a;
+      hopOf.set(nb, hops + 1);
+      viaOf.set(nb, { edgeType: e.type, parentId: top.id, forward });
+      frontier.push(nb, a);
+    }
+  }
+  act.delete(seedId);
   const ctxSeed = seed.embedding.length > 0 ? { seedEmbedding: seed.embedding, seedEmbeddingVersion: seed.attrs["embeddingVersion"] } : {};
   const gated = seed.embedding.length > 0;
-  const nodes = [...hopOf.entries()].map(([id, hops]) => ({ node: store.getNode(id), hops })).filter((x) => x.node != null);
-  const maxPr = Math.max(1e-9, ...nodes.map((x) => x.node.pageRank));
+  const labelOf = store.nodeLabels([...act.keys()]);
+  const pool = (keep) => [...act.entries()].filter(([id]) => keep(labelOf.get(id) ?? "")).sort((x, y) => y[1] - x[1]).slice(0, BURST_SCORED_CANDIDATES);
+  const isKnowledge = (label) => typeRelevance(label) >= KNOWLEDGE_TYPE_RELEVANCE;
+  const reached = [...pool(isKnowledge), ...pool((l) => !isKnowledge(l))].map(([id, a]) => ({ node: store.getNode(id), a })).filter((x) => x.node != null);
+  const maxPr = Math.max(1e-9, ...reached.map((x) => x.node.pageRank));
+  const maxAct = Math.max(1e-12, ...reached.map((x) => x.a));
   const weights = {
     centralityScale: maxPr,
     ...gated ? { semanticFloor: semanticFloorFor(ctxSeed.seedEmbeddingVersion) } : {},
     ...opts.weights
   };
   const now = store.currentIngestSeq();
-  return nodes.map(({ node: node2, hops }) => {
-    const r = scoreCandidate(node2, { ...ctxSeed, hops, decay: nodeFreshness(node2, now) }, weights);
+  return reached.map(({ node: node2, a }) => {
+    const r = scoreCandidate(node2, { ...ctxSeed, decay: nodeFreshness(node2, now) }, weights);
+    const score2 = a / maxAct * r.score * typeRelevance(node2.label);
     const via = viaOf.get(node2.id);
-    return { id: node2.id, score: r.score, components: r.components, node: node2, hops, ...via ? { via } : {} };
+    return { id: node2.id, score: score2, components: r.components, node: node2, hops: hopOf.get(node2.id) ?? 0, ...via ? { via } : {} };
   }).filter((r) => !gated || r.score > 0).sort((a, b) => b.score - a.score).slice(0, limit);
 }
+var BURST_STEP_DAMPING, ACTIVATION_EPSILON, BURST_RELATIVE_FLOOR, BURST_SCORED_CANDIDATES, KNOWLEDGE_TYPE_RELEVANCE, BURST_ANCHORED_AT_CONDUCTANCE, BURST_DEPENDS_ON_FLOOR, ActivationHeap;
 var init_relevance_rank = __esm({
   "../../packages/generalizer/src/relevance-rank.ts"() {
     "use strict";
     init_src3();
     init_src4();
+    init_src5();
+    init_src();
+    BURST_STEP_DAMPING = 0.85;
+    ACTIVATION_EPSILON = 1e-6;
+    BURST_RELATIVE_FLOOR = 0.02;
+    BURST_SCORED_CANDIDATES = 150;
+    KNOWLEDGE_TYPE_RELEVANCE = 0.5;
+    BURST_ANCHORED_AT_CONDUCTANCE = 1 / 3;
+    BURST_DEPENDS_ON_FLOOR = 0.1;
+    ActivationHeap = class {
+      items = [];
+      get size() {
+        return this.items.length;
+      }
+      push(id, a) {
+        const items = this.items;
+        items.push({ id, a });
+        let i2 = items.length - 1;
+        while (i2 > 0) {
+          const p = i2 - 1 >> 1;
+          if (items[p].a >= items[i2].a) break;
+          [items[p], items[i2]] = [items[i2], items[p]];
+          i2 = p;
+        }
+      }
+      pop() {
+        const items = this.items;
+        const top = items[0];
+        const last = items.pop();
+        if (items.length > 0 && last) {
+          items[0] = last;
+          let i2 = 0;
+          for (; ; ) {
+            const l = 2 * i2 + 1, r = l + 1;
+            let m = i2;
+            if (l < items.length && items[l].a > items[m].a) m = l;
+            if (r < items.length && items[r].a > items[m].a) m = r;
+            if (m === i2) break;
+            [items[m], items[i2]] = [items[i2], items[m]];
+            i2 = m;
+          }
+        }
+        return top;
+      }
+    };
   }
 });
 
 // ../../packages/generalizer/src/index.ts
 var src_exports3 = {};
 __export(src_exports3, {
+  BURST_ANCHORED_AT_CONDUCTANCE: () => BURST_ANCHORED_AT_CONDUCTANCE,
+  BURST_DEPENDS_ON_FLOOR: () => BURST_DEPENDS_ON_FLOOR,
+  BURST_RELATIVE_FLOOR: () => BURST_RELATIVE_FLOOR,
+  BURST_SCORED_CANDIDATES: () => BURST_SCORED_CANDIDATES,
+  BURST_STEP_DAMPING: () => BURST_STEP_DAMPING,
   FULL_RESCORE_EVERY: () => FULL_RESCORE_EVERY,
   INCREMENTAL_REGION_MAX_FRACTION: () => INCREMENTAL_REGION_MAX_FRACTION,
   anchorByLine: () => anchorByLine,
@@ -32240,6 +32353,8 @@ __export(src_exports3, {
   attributeRootCause: () => attributeRootCause,
   bindCanonicalNeighbors: () => bindCanonicalNeighbors,
   bindResolvedRegressions: () => bindResolvedRegressions,
+  burstConductance: () => burstConductance,
+  burstStaticConductance: () => burstStaticConductance,
   closeProblem: () => closeProblem,
   codeAnchorProjection: () => codeAnchorProjection,
   commandSignature: () => commandSignature,
@@ -32921,6 +33036,7 @@ var init_consent = __esm({
 });
 
 // src/git-remote.ts
+import { spawnSync } from "node:child_process";
 import { existsSync as existsSync10, readFileSync as readFileSync8, statSync } from "node:fs";
 import { isAbsolute as isAbsolute2, join as join8, resolve as resolve2 } from "node:path";
 function resolveGitDir(root) {
@@ -32968,12 +33084,41 @@ function detectRepoLocator(root, remote) {
   const remotes = readRemotes(root);
   if (remotes.length === 0) return null;
   const pick2 = remote ? remotes.find((r) => r.name === remote) ?? null : remotes.find((r) => r.name === "origin") ?? (remotes.length === 1 ? remotes[0] : null);
-  return pick2 ? normalizeRepoLocator(pick2.url) : null;
+  return pick2 ? normalizeRepoLocator(resolveSshHostAlias(pick2.url)) : null;
+}
+function sshConfigHostname(alias) {
+  if (resolvedAliases.has(alias)) return resolvedAliases.get(alias);
+  let host = null;
+  try {
+    const out2 = spawnSync("ssh", ["-G", alias], { encoding: "utf8", timeout: 3e3, windowsHide: true });
+    if (out2.status === 0) host = /^hostname\s+(\S+)\s*$/im.exec(out2.stdout)?.[1]?.toLowerCase() ?? null;
+  } catch {
+    host = null;
+  }
+  resolvedAliases.set(alias, host);
+  return host;
 }
+function resolveSshHostAlias(remoteUrl, resolveHost = sshConfigHostname) {
+  const raw2 = remoteUrl.trim();
+  const m = SSH_URL_REMOTE.exec(raw2) ?? (/^[a-z][a-z0-9+.-]*:\/\//i.test(raw2) ? null : SSH_SCP_REMOTE.exec(raw2));
+  if (!m) return raw2;
+  const prefix = m[1];
+  const alias = m[2];
+  const rest2 = m[3];
+  if (alias.length === 1 || CANONICAL_FORGE_HOSTS.has(alias.toLowerCase())) return raw2;
+  const real = resolveHost(alias);
+  if (!real || real === alias.toLowerCase()) return raw2;
+  return SSH_URL_REMOTE.test(raw2) ? `${prefix}${real}${rest2}` : `${prefix}${real}:${rest2}`;
+}
+var CANONICAL_FORGE_HOSTS, SSH_SCP_REMOTE, SSH_URL_REMOTE, resolvedAliases;
 var init_git_remote = __esm({
   "src/git-remote.ts"() {
     "use strict";
     init_src();
+    CANONICAL_FORGE_HOSTS = /* @__PURE__ */ new Set(["github.com", "gitlab.com", "bitbucket.org", "codeberg.org"]);
+    SSH_SCP_REMOTE = /^((?:[^@/]+@)?)([^:/@]+):(?!\/\/)(.+)$/;
+    SSH_URL_REMOTE = /^(ssh:\/\/(?:[^@/]+@)?)([^:/@]+)((?::\d+)?\/.*)$/i;
+    resolvedAliases = /* @__PURE__ */ new Map();
   }
 });
 
@@ -82519,7 +82664,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.17-dev.3549" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.17-dev.3564" : "2.0.0-alpha.0";
 var IGNORED_PATH = /[\\/](?:\.git|node_modules|\.errata|\.claude|\.codex|\.cursor|\.turbo|\.next|dist|coverage|test-results|playwright-report|__pycache__)(?:[\\/]|$)/;
 var IGNORED_NOISE = /castalia\.db|eventlog\.sqlite|turn-cursors/;
 var GIT_OP_MUTE_MS = 4e3;
@@ -91723,7 +91868,7 @@ function shouldUseOAuthLogin(flags2, env2 = process.env) {
 }
 
 // src/doctor.ts
-import { spawnSync } from "node:child_process";
+import { spawnSync as spawnSync2 } from "node:child_process";
 
 // src/codex-runtime.ts
 import { readdirSync as readdirSync12, statSync as statSync9 } from "node:fs";
@@ -91758,7 +91903,7 @@ function resolveCodexExecutable(options = {}) {
 // src/doctor.ts
 function installedHarnessVersion(bin) {
   try {
-    const r = spawnSync(bin === "codex" ? resolveCodexExecutable() : bin, ["--version"], { encoding: "utf8", timeout: 3e3, windowsHide: true });
+    const r = spawnSync2(bin === "codex" ? resolveCodexExecutable() : bin, ["--version"], { encoding: "utf8", timeout: 3e3, windowsHide: true });
     if (r.status !== 0 && !r.stdout) return null;
     const m = /(\d+\.\d+\.\d+)/.exec(`${r.stdout ?? ""}${r.stderr ?? ""}`);
     return m ? m[1] : null;
@@ -92876,8 +93021,9 @@ async function cmdInit() {
     console.log("");
     console.log("Privacy: your code, file contents, and raw error text never leave");
     console.log("this machine \u2014 only scrubbed, canonical lessons can (consent-gated).");
-    console.log("Cloud sync + telemetry are OFF in this alpha \u2014 turn them on with:");
-    console.log("    errata consent sync on        # contribute canonical, scrubbed deltas");
+    console.log("Cloud sync + telemetry are OFF until you choose otherwise:");
+    console.log("    errata link                   # per repo: pick its project + what it shares, in the Console");
+    console.log("    errata consent sync on        # machine default for repos you haven't linked");
     console.log("    errata consent telemetry on   # counts-only product metrics");
     console.log("To CONTRIBUTE to the shared graph you must ALSO attest this daemon:");
     console.log("    errata login                  # console sign-in (OAuth) \u2014 grants graph-write");
@@ -92899,7 +93045,7 @@ async function cmdInit() {
       return;
     }
     console.log("");
-    console.log("connecting your cloud account (init links this repo to its project)...");
+    console.log("connecting your cloud account...");
     await cmdLoginOAuth(cfgNow);
     cfgNow = loadConfig();
     if (!hasCloudCredential(cfgNow)) {
@@ -92908,14 +93054,32 @@ async function cmdInit() {
       return;
     }
   }
+  let profileNow = loadProfile(ROOT);
+  if (process.stdout.isTTY && !rest.includes("--no-link") && !rest.includes("--no-login") && profileNow && !profileNow.projectId) {
+    refreshRepoLocator(ROOT, profileNow);
+    if (profileNow.repoLocator) {
+      console.log("");
+      console.log(`linking ${profileNow.repoLocator} to its project (choose org, team and privacy in the Console)...`);
+      await cmdLink(rest.includes("--no-browser") ? ["--no-browser"] : []);
+      if (process.exitCode === 1) {
+        console.log("  (init itself succeeded \u2014 retry the link any time with `errata link`)");
+        process.exitCode = 0;
+      }
+      profileNow = loadProfile(ROOT);
+    }
+  }
   console.log("");
   console.log("Next:");
   console.log("  errata start                 # observe this repo");
   if (!hasCloudCredential(cfgNow)) {
     console.log("  errata login                 # connect a cloud account (or: --token <key>)");
   }
-  if (!cfgNow.consent.sync) {
-    console.log("  errata consent sync on       # contribute scrubbed, canonical lessons");
+  if (!profileNow?.projectId) {
+    if (profileNow?.repoLocator) {
+      console.log("  errata link                  # link this repo to its project (sets its privacy choices)");
+    } else {
+      console.log("  git remote add origin <url>  # then: errata link (a project is found by its remote)");
+    }
   }
   console.log("  errata status                # verify the whole chain");
 }
@@ -93679,6 +93843,8 @@ async function cmdLink(args2) {
     }
     profile.repoRemote = remote;
     profile.repoLocator = loc;
+  } else {
+    refreshRepoLocator(ROOT, profile);
   }
   if (!wantsLocal) {
     if (!profile.repoLocator) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inerrata-corporation/errata",
-  "version": "2.0.17-dev.3549",
+  "version": "2.0.17-dev.3564",
   "description": "errata - local-first observation engine for AI coding agents",
   "type": "module",
   "bin": {

package/pass-worker.mjs

@@ -25640,6 +25640,7 @@ function rowToEdge(r) {
   };
 }
 var FINGERPRINT_INDEXED_LABELS = ["Problem", "Vulnerability", "Solution", "RootCause"];
+var NODE_LABELS_CHUNK = 256;
 var SqliteGraphStore = class {
   db;
   // Typed edge lookups build their SQL from the number of types asked for, and
@@ -26142,6 +26143,19 @@ var SqliteGraphStore = class {
     const row = this.stmts.getNode.get(id);
     return row ? rowToNode(row) : null;
   }
+  nodeLabels(ids) {
+    const width = NODE_LABELS_CHUNK;
+    const stmt = this.typedEdgeStmt(
+      `SELECT id, label FROM nodes WHERE id IN (${Array.from({ length: width }, () => "?").join(",")})`
+    );
+    const labels = /* @__PURE__ */ new Map();
+    for (let i2 = 0; i2 < ids.length; i2 += width) {
+      const chunk = ids.slice(i2, i2 + width);
+      while (chunk.length < width) chunk.push(null);
+      for (const row of stmt.all(...chunk)) labels.set(row.id, row.label);
+    }
+    return labels;
+  }
   getEdge(id) {
     const row = this.stmts.getEdge.get(id);
     return row ? rowToEdge(row) : null;
@@ -28965,6 +28979,10 @@ function codeAnchorProjection(store2, semanticIds, opts = {}) {
 // ../../packages/generalizer/src/embed-code.ts
 init_src();
 
+// ../../packages/generalizer/src/relevance-rank.ts
+init_src();
+var BURST_ANCHORED_AT_CONDUCTANCE = 1 / 3;
+
 // ../../packages/context-writer/src/agents-md.ts
 init_src();