@odla-ai/kg 0.3.0 → 0.4.0

package/dist/temporal/index.cjs

@@ -20,41 +20,27 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/temporal/index.ts
 var temporal_exports = {};
 __export(temporal_exports, {
+  blendPairs: () => blendPairs,
+  bridgingScores: () => bridgingScores,
   bucketFor: () => bucketFor,
   bucketKey: () => bucketKey,
   bucketRange: () => bucketRange,
-  buildNarrationMaterials: () => buildNarrationMaterials,
-  buildTemporalReport: () => buildTemporalReport,
-  buildTimeline: () => buildTimeline,
-  burstScores: () => burstScores,
   byNodeId: () => byNodeId,
-  detectBursts: () => detectBursts,
-  extractEvents: () => extractEvents,
-  flowFrames: () => flowFrames,
-  forceLayout: () => forceLayout,
+  composeTargets: () => composeTargets,
+  directTargets: () => directTargets,
+  geoPairs: () => geoPairs,
   hash32: () => hash32,
   indexGraph: () => indexGraph,
   labelPropagation: () => labelPropagation,
-  layoutSequence: () => layoutSequence,
-  leadScores: () => leadScores,
   mulberry32: () => mulberry32,
   nodeId: () => nodeId,
-  parseAmount: () => parseAmount,
   parseDateMs: () => parseDateMs,
-  rankEnrichmentCandidates: () => rankEnrichmentCandidates,
-  rankHotspots: () => rankHotspots,
+  projectBridges: () => projectBridges,
+  reifiedBridgeTargets: () => reifiedBridgeTargets,
   resolvePath: () => resolvePath,
-  rollup: () => rollup,
-  seriesKeys: () => seriesKeys,
-  shouldNarrate: () => shouldNarrate,
   shuffle: () => shuffle,
-  snapshotAt: () => snapshotAt,
-  snapshotSeries: () => snapshotSeries,
-  splitTitleBody: () => splitTitleBody,
-  synthesizeBurstSources: () => synthesizeBurstSources,
-  topFlows: () => topFlows,
-  totals: () => totals,
-  trackClusters: () => trackClusters
+  timePairs: () => timePairs,
+  topBridges: () => topBridges
 });
 module.exports = __toCommonJS(temporal_exports);
 
@@ -202,219 +188,6 @@ function resolvePath(g, start, labels) {
   return frontier.slice().sort(byNodeId);
 }
 
-// src/temporal/events.ts
-function parseAmount(v) {
-  if (typeof v === "number") return Number.isFinite(v) ? v : void 0;
-  if (typeof v !== "string") return void 0;
-  const m = /^\$?\s*([\d,]+(?:\.\d+)?)\s*([kKmMbB])?$/.exec(v.trim());
-  if (!m) return void 0;
-  const n = Number(m[1].replace(/,/g, ""));
-  if (!Number.isFinite(n)) return void 0;
-  const suffix = (m[2] ?? "").toLowerCase();
-  const mult = suffix === "k" ? 1e3 : suffix === "m" ? 1e6 : suffix === "b" ? 1e9 : 1;
-  return n * mult;
-}
-function resolveGeo(g, start, spec) {
-  const landing = spec.path?.length ? resolvePath(g, start, spec.path)[0] : start;
-  if (!landing) return void 0;
-  if (spec.attr) {
-    const v = g.node(nodeId(landing))?.attrs[spec.attr];
-    return typeof v === "string" && v !== "" ? v : void 0;
-  }
-  return landing.key;
-}
-function extractEvents(fragment, config) {
-  const g = indexGraph(fragment);
-  const out = [];
-  for (const spec of config.events) {
-    for (const n of g.nodesOf(spec.type)) {
-      const t = parseDateMs(n.attrs[spec.dateAttr]);
-      if (t === null) continue;
-      const self = { type: n.type, key: n.key };
-      const seen = /* @__PURE__ */ new Set();
-      const refs = [];
-      for (const path of spec.attach ?? []) {
-        for (const ref of resolvePath(g, self, path)) {
-          const id = nodeId(ref);
-          if (!seen.has(id)) {
-            seen.add(id);
-            refs.push(ref);
-          }
-        }
-      }
-      refs.sort(byNodeId);
-      const weight = spec.weightOf?.(n.attrs) ?? (spec.weightAttr ? parseAmount(n.attrs[spec.weightAttr]) : void 0) ?? 1;
-      out.push({
-        t,
-        kind: spec.type,
-        node: self,
-        refs,
-        weight,
-        geo: spec.geo ? resolveGeo(g, self, spec.geo) : void 0,
-        geoTo: spec.geoTo ? resolveGeo(g, self, spec.geoTo) : void 0
-      });
-    }
-  }
-  return out.sort((a, b) => a.t - b.t || byNodeId(a.node, b.node));
-}
-
-// src/temporal/series.ts
-function seriesKeys(e, by) {
-  if (by === "kind") return [e.kind];
-  if (by === "geo") return e.geo === void 0 ? [] : [e.geo];
-  if (by === "ref") return e.refs.map(nodeId);
-  const k = by(e);
-  return k === void 0 ? [] : typeof k === "string" ? [k] : k;
-}
-function rollup(events, opts) {
-  const { grain, by = "kind", measure = "count" } = opts;
-  const from = opts.from ?? events[0]?.t;
-  const to = opts.to ?? events[events.length - 1]?.t;
-  if (from === void 0 || to === void 0) return { grain, buckets: [], series: [] };
-  const buckets = bucketRange(from, to, grain);
-  const index = new Map(buckets.map((b, i) => [b.key, i]));
-  const rows = /* @__PURE__ */ new Map();
-  for (const e of events) {
-    const i = index.get(bucketKey(e.t, grain));
-    if (i === void 0) continue;
-    for (const key of seriesKeys(e, by)) {
-      let values = rows.get(key);
-      if (!values) {
-        values = new Array(buckets.length).fill(0);
-        rows.set(key, values);
-      }
-      values[i] = values[i] + (measure === "count" ? 1 : e.weight);
-    }
-  }
-  const series = [...rows.entries()].map(([key, values]) => ({ key, values })).sort((a, b) => a.key < b.key ? -1 : 1);
-  return { grain, buckets, series };
-}
-function totals(set) {
-  const values = new Array(set.buckets.length).fill(0);
-  for (const s of set.series) {
-    s.values.forEach((v, i) => {
-      values[i] = values[i] + v;
-    });
-  }
-  return { key: "total", values };
-}
-
-// src/temporal/hotspots.ts
-function burstScores(values, opts = {}) {
-  const { window = 6, minBaseline = 3, minSigma = 1 } = opts;
-  return values.map((x, i) => {
-    const from = Math.max(0, i - window);
-    const trailing = values.slice(from, i);
-    if (trailing.length < minBaseline) return 0;
-    const mean = trailing.reduce((a, b) => a + b, 0) / trailing.length;
-    const variance = trailing.reduce((a, b) => a + (b - mean) * (b - mean), 0) / trailing.length;
-    const sigma = Math.max(Math.sqrt(variance), Math.sqrt(mean), minSigma);
-    return (x - mean) / sigma;
-  });
-}
-function detectBursts(set, opts = {}) {
-  const { zEnter = 2, zExit = 1 } = opts;
-  const out = [];
-  for (const series of set.series) {
-    const zs = burstScores(series.values, opts);
-    let run = null;
-    zs.forEach((z, i) => {
-      if (run) {
-        if (z >= zExit) {
-          run.end = i;
-          run.peak = Math.max(run.peak, z);
-          run.score += Math.max(0, z);
-          return;
-        }
-        out.push(run);
-        run = null;
-      }
-      if (z >= zEnter) {
-        run = { seriesKey: series.key, start: i, end: i, peak: z, score: z };
-      }
-    });
-    if (run) out.push(run);
-  }
-  return out.sort(
-    (a, b) => b.score - a.score || a.start - b.start || (a.seriesKey < b.seriesKey ? -1 : 1)
-  );
-}
-function rankHotspots(set, events, opts = {}) {
-  const { by = "kind", top = 20, contributorsPer = 5 } = opts;
-  const index = new Map(set.buckets.map((b, i) => [b.key, i]));
-  return detectBursts(set, opts).slice(0, top).map((burst) => {
-    const inRun = events.filter((e) => {
-      const i = index.get(bucketKey(e.t, set.grain));
-      return i !== void 0 && i >= burst.start && i <= burst.end && seriesKeys(e, by).includes(burst.seriesKey);
-    });
-    inRun.sort((a, b) => b.weight - a.weight || a.t - b.t);
-    return {
-      ...burst,
-      bucketKeys: set.buckets.slice(burst.start, burst.end + 1).map((b) => b.key),
-      contributors: inRun.slice(0, contributorsPer)
-    };
-  });
-}
-
-// src/temporal/snapshot.ts
-var PAIR_CAP = 12;
-function buildTimeline(events, opts = {}) {
-  const mode = opts.mode ?? "entities";
-  const firstSeen = /* @__PURE__ */ new Map();
-  const edges = [];
-  const see = (id, t) => {
-    if (!firstSeen.has(id)) firstSeen.set(id, t);
-  };
-  for (const e of events) {
-    const refIds = e.refs.map(nodeId);
-    if (mode === "full") {
-      const self = nodeId(e.node);
-      see(self, e.t);
-      for (const ref of refIds) {
-        see(ref, e.t);
-        const [a, b] = self < ref ? [self, ref] : [ref, self];
-        edges.push({ a, b, t: e.t, kind: e.kind, weight: e.weight });
-      }
-      continue;
-    }
-    for (const ref of refIds) see(ref, e.t);
-    if (refIds.length > PAIR_CAP) continue;
-    for (let i = 0; i < refIds.length; i++) {
-      for (let j = i + 1; j < refIds.length; j++) {
-        const [a, b] = refIds[i] < refIds[j] ? [refIds[i], refIds[j]] : [refIds[j], refIds[i]];
-        edges.push({ a, b, t: e.t, kind: e.kind, weight: e.weight });
-      }
-    }
-  }
-  edges.sort((x, y) => x.t - y.t || (x.a < y.a ? -1 : x.a > y.a ? 1 : x.b < y.b ? -1 : 1));
-  return {
-    events: [...events],
-    nodes: [...firstSeen.keys()].sort(),
-    edges,
-    firstSeen
-  };
-}
-function snapshotAt(timeline, t, opts = {}) {
-  const since = opts.window === void 0 ? -Infinity : t - opts.window;
-  const agg = /* @__PURE__ */ new Map();
-  const activity = /* @__PURE__ */ new Map();
-  for (const e of timeline.edges) {
-    if (e.t > t) break;
-    activity.set(e.a, e.t);
-    activity.set(e.b, e.t);
-    if (e.t <= since) continue;
-    const key = `${e.a}|${e.b}`;
-    const cell = agg.get(key);
-    if (cell) cell.weight += 1;
-    else agg.set(key, { a: e.a, b: e.b, weight: 1 });
-  }
-  const nodes = timeline.nodes.filter((id) => timeline.firstSeen.get(id) <= t);
-  return { t, nodes, edges: [...agg.values()], activity };
-}
-function snapshotSeries(timeline, buckets, opts = {}) {
-  return buckets.map((b) => snapshotAt(timeline, b.end - 1, opts));
-}
-
 // src/temporal/communities.ts
 function labelPropagation(nodes, edges, opts = {}) {
   const { seed = 1, maxRounds = 20 } = opts;
@@ -472,410 +245,154 @@ function labelPropagation(nodes, edges, opts = {}) {
   return new Map(sorted.map((id) => [id, canonical.get(labels.get(id))]));
 }
 
-// src/temporal/clusters.ts
-var jaccard = (a, b) => {
-  let inter = 0;
-  for (const id of b) if (a.has(id)) inter++;
-  return inter / (a.size + b.length - inter);
-};
-function trackClusters(frames, opts = {}) {
-  const minJaccard = opts.minJaccard ?? 0.3;
-  const outFrames = [];
-  const changes = [];
-  let prev = [];
-  for (const frame of frames) {
-    const byLabel = /* @__PURE__ */ new Map();
-    for (const [id, label] of frame.labels) {
-      const list = byLabel.get(label);
-      list ? list.push(id) : byLabel.set(label, [id]);
-    }
-    const current = [...byLabel.values()].map((members) => members.sort());
-    current.sort((a, b) => a[0] < b[0] ? -1 : 1);
-    const prevSets = prev.map((c) => ({ c, set: new Set(c.members) }));
-    const matches = [];
-    current.forEach((members, ci) => {
-      prevSets.forEach(({ set }, pi) => {
-        const j = jaccard(set, members);
-        if (j >= minJaccard) {
-          let shared = 0;
-          for (const id of members) if (set.has(id)) shared++;
-          matches.push({ ci, pi, j, shared });
-        }
-      });
-    });
-    matches.sort((a, b) => b.j - a.j || b.shared - a.shared || a.ci - b.ci);
-    const idOf = /* @__PURE__ */ new Map();
-    const claimedPrev = /* @__PURE__ */ new Map();
-    const matchedPrevBy = /* @__PURE__ */ new Map();
-    for (const m of matches) {
-      const list = matchedPrevBy.get(m.ci);
-      list ? list.push(m.pi) : matchedPrevBy.set(m.ci, [m.pi]);
-      if (!idOf.has(m.ci) && !claimedPrev.has(m.pi)) {
-        idOf.set(m.ci, prev[m.pi].id);
-        claimedPrev.set(m.pi, m.ci);
-      }
-    }
-    const usedIds = /* @__PURE__ */ new Set([...idOf.values(), ...prev.map((c) => c.id)]);
-    const clusters = current.map((members, ci) => {
-      let id = idOf.get(ci);
-      if (!id) {
-        id = `c:${members[0]}`;
-        while (usedIds.has(id)) id += "'";
-        usedIds.add(id);
-        if (outFrames.length > 0) changes.push({ kind: "birth", t: frame.t, id });
-      }
-      return { id, members };
-    });
-    prevSets.forEach(({ c }, pi) => {
-      const winners = matches.filter((m) => m.pi === pi).map((m) => m.ci);
-      if (winners.length >= 2) {
-        changes.push({ kind: "split", t: frame.t, from: c.id, into: winners.map((ci) => clusters[ci].id) });
-      }
-    });
-    for (const [ci, pis] of matchedPrevBy) {
-      if (pis.length >= 2) {
-        changes.push({ kind: "merge", t: frame.t, into: clusters[ci].id, from: pis.map((pi) => prev[pi].id) });
+// src/temporal/lenses.ts
+function reifiedBridgeTargets(fragment, opts) {
+  const bridgesOf = /* @__PURE__ */ new Map();
+  const targetsOf = /* @__PURE__ */ new Map();
+  for (const e of fragment.edges) {
+    if (e.from.type !== opts.reified) continue;
+    const to = `${e.to.type}:${e.to.key}`;
+    if (e.label === opts.bridgeLabel) (bridgesOf.get(e.from.key) ?? bridgesOf.set(e.from.key, []).get(e.from.key)).push(to);
+    if (e.label === opts.targetLabel) (targetsOf.get(e.from.key) ?? targetsOf.set(e.from.key, []).get(e.from.key)).push(to);
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const [reifiedKey, bridges] of bridgesOf) {
+    for (const bridge of bridges) {
+      for (const target of targetsOf.get(reifiedKey) ?? []) {
+        (out.get(bridge) ?? out.set(bridge, /* @__PURE__ */ new Set()).get(bridge)).add(target);
       }
     }
-    const carried = new Set(clusters.map((c) => c.id));
-    for (const c of prev) if (!carried.has(c.id)) changes.push({ kind: "death", t: frame.t, id: c.id });
-    clusters.sort((a, b) => a.id < b.id ? -1 : 1);
-    outFrames.push({ t: frame.t, clusters });
-    prev = clusters;
   }
-  return { frames: outFrames, changes };
+  return out;
 }
-
-// src/temporal/layout.ts
-var initialFor = (id, seed) => {
-  const rand = mulberry32(hash32(id) ^ seed >>> 0);
-  const theta = 2 * Math.PI * rand();
-  const radius = 0.25 + 0.2 * rand();
-  return { x: 0.5 + radius * Math.cos(theta), y: 0.5 + radius * Math.sin(theta) };
-};
-function forceLayout(nodes, edges, opts = {}) {
-  const { iterations = 300, seed = 1, repulsion = 0.1, gravity = 0.5, positions } = opts;
-  const ids = [...nodes].sort();
-  const n = ids.length;
-  if (n === 0) return /* @__PURE__ */ new Map();
-  const k = Math.sqrt(1 / n);
-  const xs = new Float64Array(n);
-  const ys = new Float64Array(n);
-  const index = /* @__PURE__ */ new Map();
-  ids.forEach((id, i) => {
-    index.set(id, i);
-    const p = positions?.get(id) ?? initialFor(id, seed);
-    xs[i] = p.x;
-    ys[i] = p.y;
-  });
-  const links = [];
-  for (const e of edges) {
-    const a = index.get(e.a);
-    const b = index.get(e.b);
-    if (a === void 0 || b === void 0 || a === b) continue;
-    links.push(a < b ? [a, b, Math.min(e.weight ?? 1, 4)] : [b, a, Math.min(e.weight ?? 1, 4)]);
+function directTargets(fragment, label) {
+  const out = /* @__PURE__ */ new Map();
+  for (const e of fragment.edges) {
+    if (e.label !== label) continue;
+    const from = `${e.from.type}:${e.from.key}`;
+    (out.get(from) ?? out.set(from, /* @__PURE__ */ new Set()).get(from)).add(`${e.to.type}:${e.to.key}`);
   }
-  links.sort((p, q) => p[0] - q[0] || p[1] - q[1] || p[2] - q[2]);
-  const dx = new Float64Array(n);
-  const dy = new Float64Array(n);
-  for (let iter = 0; iter < iterations; iter++) {
-    dx.fill(0);
-    dy.fill(0);
-    for (let i = 0; i < n; i++) {
-      for (let j = i + 1; j < n; j++) {
-        let vx = xs[i] - xs[j];
-        let vy = ys[i] - ys[j];
-        let d = Math.hypot(vx, vy);
-        if (d < 1e-6) {
-          const r = mulberry32(hash32(`${ids[i]}|${ids[j]}`))();
-          vx = 1e-4 * Math.cos(r * 7);
-          vy = 1e-4 * Math.sin(r * 7);
-          d = 1e-4;
-        }
-        const force = repulsion * k * k / d;
-        dx[i] = dx[i] + vx / d * force;
-        dy[i] = dy[i] + vy / d * force;
-        dx[j] = dx[j] - vx / d * force;
-        dy[j] = dy[j] - vy / d * force;
-      }
-    }
-    for (const [a, b, w] of links) {
-      const vx = xs[a] - xs[b];
-      const vy = ys[a] - ys[b];
-      const d = Math.max(Math.hypot(vx, vy), 1e-6);
-      const force = d * d / k * w;
-      dx[a] = dx[a] - vx / d * force;
-      dy[a] = dy[a] - vy / d * force;
-      dx[b] = dx[b] + vx / d * force;
-      dy[b] = dy[b] + vy / d * force;
-    }
-    const cap = 0.1 * (1 - iter / iterations) + 2e-3;
-    for (let i = 0; i < n; i++) {
-      const gx = (0.5 - xs[i]) * gravity;
-      const gy = (0.5 - ys[i]) * gravity;
-      let mx = dx[i] + gx;
-      let my = dy[i] + gy;
-      const move = Math.hypot(mx, my);
-      if (move > cap) {
-        mx = mx / move * cap;
-        my = my / move * cap;
+  return out;
+}
+function composeTargets(ab, bc) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [a, bs] of ab) {
+    for (const b of bs) {
+      for (const c of bc.get(b) ?? []) {
+        (out.get(a) ?? out.set(a, /* @__PURE__ */ new Set()).get(a)).add(c);
       }
-      xs[i] = Math.min(1, Math.max(0, xs[i] + mx));
-      ys[i] = Math.min(1, Math.max(0, ys[i] + my));
     }
   }
-  return new Map(ids.map((id, i) => [id, { x: xs[i], y: ys[i] }]));
-}
-function layoutSequence(snapshots, opts = {}) {
-  const { warmIterations = 60, ...base } = opts;
-  const out = [];
-  let prev = base.positions ? new Map(base.positions) : void 0;
-  for (const snap of snapshots) {
-    const frame = forceLayout(snap.nodes, snap.edges, {
-      ...base,
-      iterations: prev ? warmIterations : base.iterations,
-      positions: prev
-    });
-    out.push(frame);
-    prev = frame;
-  }
   return out;
 }
-
-// src/temporal/report.ts
-var DAY2 = 864e5;
-var round2 = (v) => Math.round(v * 100) / 100;
-var isoDay = (t) => new Date(t).toISOString().slice(0, 10);
-function clusterChangeIds(change) {
-  if (change.kind === "merge") return [change.into, ...change.from];
-  if (change.kind === "split") return [change.from, ...change.into];
-  return [change.id];
-}
-function buildTemporalReport(fragment, config, opts = {}) {
-  const events = extractEvents(fragment, config);
-  const now = opts.now ?? events[events.length - 1]?.t ?? 0;
-  const generatedAt = new Date(now).toISOString();
-  if (events.length === 0) {
-    return {
-      generatedAt,
-      window: { from: "", to: "", weeks: [] },
-      totals: { events: 0, nodes: 0, edges: 0 },
-      series: [],
-      leads: [],
-      clusters: { frames: [], changes: [] }
-    };
-  }
-  const attrsOf = new Map(fragment.nodes.map((n) => [nodeId(n), n.attrs]));
-  const str = (id, attr) => {
-    const v = attrsOf.get(id)?.[attr];
-    return typeof v === "string" && v !== "" ? v : void 0;
-  };
-  const windowDays = opts.windowDays ?? 155;
-  const from = Math.max(events[0].t, now - windowDays * DAY2);
-  const weeks = bucketRange(from, now, "week");
-  const weekly = rollup(events, { grain: "week", by: "ref", from, to: now });
-  const leads = rankHotspots(weekly, events, {
-    by: "ref",
-    top: opts.topLeads ?? 8,
-    contributorsPer: opts.contributorsPer ?? 3,
-    ...opts.burst ?? { window: 6 }
-  }).map((h) => ({
-    key: h.seriesKey,
-    type: h.seriesKey.slice(0, Math.max(0, h.seriesKey.indexOf(":"))),
-    // ref keys are always "type:key"
-    name: str(h.seriesKey, "name") ?? h.seriesKey,
-    ...str(h.seriesKey, "city") ? { city: str(h.seriesKey, "city") } : {},
-    ...str(h.seriesKey, "sector") ? { sector: str(h.seriesKey, "sector") } : {},
-    score: round2(h.score),
-    peak: round2(h.peak),
-    window: h.bucketKeys,
-    contributors: h.contributors.map((e) => ({
-      kind: e.kind,
-      key: e.node.key,
-      title: str(nodeId(e.node), "title") ?? str(nodeId(e.node), "round") ?? str(nodeId(e.node), "name") ?? e.node.key,
-      date: isoDay(e.t)
-    }))
-  }));
-  const timeline = buildTimeline(events);
-  const snapshots = snapshotSeries(timeline, weeks);
-  const labelFrames = snapshots.map((s) => ({ t: s.t, labels: labelPropagation(s.nodes, s.edges, { seed: 1 }) }));
-  const tracked = trackClusters(labelFrames);
-  const labelFor = (members) => `${str(members[0], "name") ?? members[0]}${members.length > 1 ? ` +${members.length - 1}` : ""}`;
-  const frames = tracked.frames.map((f, i) => ({
-    week: weeks[i].key,
-    count: f.clusters.length,
-    top: [...f.clusters].sort((a, b) => b.members.length - a.members.length).slice(0, 3).map((c) => ({ id: c.id, size: c.members.length, label: labelFor(c.members) }))
-  }));
-  const changeFloor = weeks[Math.max(0, weeks.length - (opts.changeWeeks ?? 4))].start;
-  const weekOf = (t) => weeks.find((w) => t >= w.start && t < w.end).key;
-  const nameOfCluster = (frameIdx, id) => {
-    for (let i = frameIdx; i >= 0; i--) {
-      const c = tracked.frames[i]?.clusters.find((x) => x.id === id);
-      if (c) return labelFor(c.members);
+function projectBridges(bridges, opts = {}) {
+  const { maxPerBridge = 12, viaCap = 4 } = opts;
+  const acc = /* @__PURE__ */ new Map();
+  for (const [bridge, targetSet] of [...bridges.entries()].sort((x, y) => x[0] < y[0] ? -1 : 1)) {
+    const targets = [...targetSet].sort();
+    if (targets.length < 2 || targets.length > maxPerBridge) continue;
+    for (let i = 0; i < targets.length; i++) {
+      for (let j = i + 1; j < targets.length; j++) {
+        const key = `${targets[i]}|${targets[j]}`;
+        const hit = acc.get(key) ?? { a: targets[i], b: targets[j], w: 0, via: [] };
+        hit.w += 1;
+        if (hit.via.length < viaCap) hit.via.push(bridge);
+        acc.set(key, hit);
+      }
     }
-    return id;
-  };
-  const changes = tracked.changes.filter((c) => c.t >= changeFloor).map((c) => {
-    const frameIdx = tracked.frames.findIndex((f) => f.t === c.t);
-    const ids = clusterChangeIds(c);
-    return { week: weekOf(c.t), kind: c.kind, ids, names: ids.map((id) => nameOfCluster(frameIdx, id)) };
-  });
-  const monthly = rollup(events, {
-    grain: "month",
-    by: "kind",
-    from: now - (opts.monthlyMonths ?? 12) * 30 * DAY2,
-    to: now
-  });
-  const months = monthly.buckets.map((b) => b.key);
-  const series = monthly.series.map((s) => ({ kind: s.key, months, values: s.values }));
-  return {
-    generatedAt,
-    window: { from: isoDay(weeks[0].start), to: isoDay(now), weeks: weeks.map((w) => w.key) },
-    totals: { events: events.length, nodes: timeline.nodes.length, edges: timeline.edges.length },
-    series,
-    leads,
-    clusters: { frames, changes }
-  };
-}
-
-// src/temporal/narrate.ts
-function shouldNarrate(report) {
-  return report.leads.length > 0 || report.clusters.changes.length > 0;
+  }
+  return [...acc.keys()].sort().map((k) => acc.get(k));
 }
-function buildNarrationMaterials(report, opts = {}) {
-  const lines = [];
-  const w = report.window;
-  lines.push(`Window: ${w.weeks[0] ?? w.from}..${w.weeks[w.weeks.length - 1] ?? w.to} (weekly) \xB7 generated ${report.generatedAt.slice(0, 10)}`);
-  lines.push(`Totals: ${report.totals.events} events \xB7 ${report.totals.nodes} nodes \xB7 ${report.totals.edges} edges`);
-  const leads = report.leads.slice(0, opts.topLeads ?? 5);
-  if (leads.length > 0) {
-    lines.push("", `HOTSPOT LEADS (top ${leads.length}):`);
-    for (const lead of leads) {
-      const where = lead.city ?? lead.sector;
-      const evidence = lead.contributors[0];
-      lines.push(
-        `- ${lead.name} (${lead.type}${where ? `, ${where}` : ""}) \u2014 score ${lead.score}, peak z ${lead.peak}, window ${lead.window[0]}..${lead.window[lead.window.length - 1]}` + (evidence ? `; evidence: "${evidence.title}" (${evidence.date})` : "")
-      );
+function timePairs(arrivals, opts = {}) {
+  const { k = 4, halfLifeDays = 30 } = opts;
+  const halfLife = halfLifeDays * 864e5;
+  const rows = [...arrivals.entries()].filter(([, t]) => Number.isFinite(t)).sort((x, y) => x[1] - y[1] || (x[0] < y[0] ? -1 : 1));
+  const acc = /* @__PURE__ */ new Map();
+  for (let i = 0; i < rows.length; i++) {
+    for (let j = i + 1; j < Math.min(rows.length, i + 1 + k); j++) {
+      const [idA, tA] = rows[i];
+      const [idB, tB] = rows[j];
+      const w = Math.pow(0.5, Math.abs(tB - tA) / halfLife);
+      if (w < 0.01) break;
+      const [a, b] = idA < idB ? [idA, idB] : [idB, idA];
+      acc.set(`${a}|${b}`, { a, b, w, via: [] });
     }
   }
-  if (report.clusters.changes.length > 0) {
-    lines.push("", `CLUSTER CHANGES (last weeks):`);
-    for (const c of report.clusters.changes) {
-      const detail = c.kind === "merge" ? `${c.names.slice(1).join(", ")} into ${c.names[0]}` : c.kind === "split" ? `${c.names[0]} into ${c.names.slice(1).join(", ")}` : c.names[0];
-      lines.push(`- ${c.week} ${c.kind}: ${detail}`);
+  return [...acc.keys()].sort().map((key) => acc.get(key));
+}
+function geoPairs(positions, opts = {}) {
+  const { k = 4, halfDist = 0.04 } = opts;
+  const rows = [...positions.entries()].sort((x, y) => x[0] < y[0] ? -1 : 1);
+  const acc = /* @__PURE__ */ new Map();
+  for (let i = 0; i < rows.length; i++) {
+    const dists = [];
+    for (let j = 0; j < rows.length; j++) {
+      if (i === j) continue;
+      const dx = rows[i][1].x - rows[j][1].x;
+      const dy = rows[i][1].y - rows[j][1].y;
+      dists.push({ j, d: Math.hypot(dx, dy) });
     }
-  }
-  if (report.series.length > 0) {
-    lines.push("", "MONTHLY DENSITY:");
-    for (const s of report.series) {
-      const span = s.months.length > 0 ? ` (${s.months[0]}..${s.months[s.months.length - 1]})` : "";
-      lines.push(`- ${s.kind}: ${s.values.join(" ")}${span}`);
+    dists.sort((x, y) => x.d - y.d || x.j - y.j);
+    for (const { j, d } of dists.slice(0, k)) {
+      const w = Math.pow(0.5, d / halfDist);
+      if (w < 0.01) continue;
+      const [a, b] = rows[i][0] < rows[j][0] ? [rows[i][0], rows[j][0]] : [rows[j][0], rows[i][0]];
+      const key = `${a}|${b}`;
+      const prev = acc.get(key);
+      if (!prev || prev.w < w) acc.set(key, { a, b, w, via: [] });
     }
   }
-  return lines.join("\n");
+  return [...acc.keys()].sort().map((key) => acc.get(key));
 }
-function splitTitleBody(text, fallbackTitle) {
-  const trimmed = text.trim();
-  const firstLine = trimmed.split("\n", 1)[0] ?? "";
-  if (firstLine.startsWith("# ")) {
-    return { title: firstLine.slice(2).trim() || fallbackTitle, body: trimmed.slice(firstLine.length).trim() };
+function blendPairs(sets) {
+  const acc = /* @__PURE__ */ new Map();
+  for (const { pairs, weight } of sets) {
+    if (weight <= 0 || pairs.length === 0) continue;
+    const max = Math.max(...pairs.map((p) => p.w));
+    for (const p of pairs) {
+      const key = `${p.a}|${p.b}`;
+      const hit = acc.get(key) ?? { a: p.a, b: p.b, w: 0, via: [] };
+      hit.w += p.w / max * weight;
+      for (const v of p.via) if (hit.via.length < 6 && !hit.via.includes(v)) hit.via.push(v);
+      acc.set(key, hit);
+    }
   }
-  return { title: fallbackTitle, body: trimmed };
+  return [...acc.keys()].sort().map((key) => acc.get(key));
 }
 
-// src/temporal/steer.ts
-function leadScores(report, type = "company") {
-  const out = {};
-  const prefix = `${type}:`;
-  for (const lead of report.leads) {
-    if (lead.key.startsWith(prefix)) out[lead.key.slice(prefix.length)] = lead.score;
+// src/temporal/bridges.ts
+function bridgingScores(edges, labels) {
+  const cross = /* @__PURE__ */ new Map();
+  const foreign = /* @__PURE__ */ new Map();
+  const touch = (id, otherLabel, w) => {
+    cross.set(id, (cross.get(id) ?? 0) + w);
+    (foreign.get(id) ?? foreign.set(id, /* @__PURE__ */ new Set()).get(id)).add(otherLabel);
+  };
+  for (const e of edges) {
+    const la = labels.get(e.a);
+    const lb = labels.get(e.b);
+    if (la === void 0 || lb === void 0 || la === lb) continue;
+    const w = e.weight ?? 1;
+    touch(e.a, lb, w);
+    touch(e.b, la, w);
+  }
+  let max = 0;
+  const raw = /* @__PURE__ */ new Map();
+  for (const [id, w] of cross) {
+    const r = w * foreign.get(id).size;
+    raw.set(id, r);
+    if (r > max) max = r;
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const [id] of labels) {
+    const r = raw.get(id) ?? 0;
+    const own = labels.get(id);
+    const groups = r > 0 ? [own, ...[...foreign.get(id)].sort()] : [own];
+    out.set(id, { score: max > 0 ? r / max : 0, groups });
   }
   return out;
 }
-function rankEnrichmentCandidates(rows, opts) {
-  const scores = opts.scores ?? {};
-  const isComplete = opts.isComplete ?? ((r) => Boolean(r.website && r.city && r.sector));
-  const seen = /* @__PURE__ */ new Set();
-  const eligible = [];
-  for (const row of rows) {
-    const slug = typeof row.slug === "string" ? row.slug : "";
-    if (!slug || seen.has(slug)) continue;
-    seen.add(slug);
-    const score = scores[slug] ?? 0;
-    if (opts.cooling?.has(slug)) continue;
-    if (score <= 0 && isComplete(row)) continue;
-    eligible.push({ slug, name: typeof row.name === "string" ? row.name : slug, score });
-  }
-  return eligible.sort((a, b) => b.score - a.score).slice(0, Math.max(0, opts.limit));
-}
-var BURST_ORIGIN = "burst";
-var MAX_QUERY_CHARS = 120;
-function synthesizeBurstSources(existing, report, opts = {}) {
-  const max = opts.max ?? 4;
-  const kept = existing.filter((s) => s.origin !== BURST_ORIGIN);
-  const queries = report.leads.filter((lead) => lead.type === "company").slice(0, max).map((lead) => {
-    const where = lead.city ?? lead.sector ?? "startup";
-    return `"${lead.name}" ${where} funding OR expansion OR hiring news`.slice(0, MAX_QUERY_CHARS);
-  });
-  if (queries.length === 0) return kept;
-  return [
-    ...kept,
-    {
-      kind: "web-search",
-      name: "Burst sweep (auto)",
-      enabled: true,
-      cadenceHours: opts.cadenceHours ?? 24,
-      watch: "burst",
-      origin: BURST_ORIGIN,
-      queries
-    }
-  ];
-}
-
-// src/temporal/flows.ts
-function flowFrames(events, opts) {
-  const moves = events.filter((e) => e.geo !== void 0 && e.geoTo !== void 0);
-  const from = opts.from ?? moves[0]?.t;
-  const to = opts.to ?? moves[moves.length - 1]?.t;
-  if (from === void 0 || to === void 0) return [];
-  const buckets = bucketRange(from, to, opts.grain);
-  const index = new Map(buckets.map((b, i) => [b.key, i]));
-  const perBucket = buckets.map(() => /* @__PURE__ */ new Map());
-  for (const e of moves) {
-    const i = index.get(bucketKey(e.t, opts.grain));
-    if (i === void 0) continue;
-    const cell = perBucket[i];
-    const key = `${e.geo}\u2192${e.geoTo}`;
-    const flow = cell.get(key);
-    if (flow) {
-      flow.weight += e.weight;
-      flow.count += 1;
-    } else {
-      cell.set(key, { from: e.geo, to: e.geoTo, weight: e.weight, count: 1 });
-    }
-  }
-  const sortFlows = (flows) => flows.sort((a, b) => b.weight - a.weight || (a.from < b.from ? -1 : a.from > b.from ? 1 : a.to < b.to ? -1 : 1));
-  if (!opts.cumulative) {
-    return buckets.map((bucket, i) => ({
-      bucket,
-      flows: sortFlows([...perBucket[i].values()])
-    }));
-  }
-  const acc = /* @__PURE__ */ new Map();
-  return buckets.map((bucket, i) => {
-    for (const [key, flow] of perBucket[i]) {
-      const running = acc.get(key);
-      if (running) {
-        running.weight += flow.weight;
-        running.count += flow.count;
-      } else {
-        acc.set(key, { ...flow });
-      }
-    }
-    return { bucket, flows: sortFlows([...acc.values()].map((f) => ({ ...f }))) };
-  });
-}
-function topFlows(frame, n) {
-  return frame.flows.slice(0, n);
+function topBridges(bridging, n = 5) {
+  return [...bridging.entries()].filter(([, b]) => b.score > 0).sort((x, y) => y[1].score - x[1].score || (x[0] < y[0] ? -1 : 1)).slice(0, n).map(([id, b]) => ({ id, score: Math.round(b.score * 100) / 100, groups: b.groups }));
 }
 //# sourceMappingURL=index.cjs.map