@odla-ai/kg 0.3.2 → 0.4.1

package/dist/temporal/index.cjs

@@ -25,48 +25,22 @@ __export(temporal_exports, {
   bucketFor: () => bucketFor,
   bucketKey: () => bucketKey,
   bucketRange: () => bucketRange,
-  buildNarrationMaterials: () => buildNarrationMaterials,
-  buildTemporalReport: () => buildTemporalReport,
-  buildTimeline: () => buildTimeline,
-  burstScores: () => burstScores,
   byNodeId: () => byNodeId,
   composeTargets: () => composeTargets,
-  detectBursts: () => detectBursts,
   directTargets: () => directTargets,
-  extractEvents: () => extractEvents,
-  flowFrames: () => flowFrames,
-  forceLayout: () => forceLayout,
   geoPairs: () => geoPairs,
   hash32: () => hash32,
   indexGraph: () => indexGraph,
   labelPropagation: () => labelPropagation,
-  layoutSequence: () => layoutSequence,
-  leadScores: () => leadScores,
-  lensSnapshots: () => lensSnapshots,
-  matchRules: () => matchRules,
   mulberry32: () => mulberry32,
   nodeId: () => nodeId,
-  parseAmount: () => parseAmount,
   parseDateMs: () => parseDateMs,
   projectBridges: () => projectBridges,
-  rankEnrichmentCandidates: () => rankEnrichmentCandidates,
-  rankHotspots: () => rankHotspots,
   reifiedBridgeTargets: () => reifiedBridgeTargets,
   resolvePath: () => resolvePath,
-  rollup: () => rollup,
-  seriesKeys: () => seriesKeys,
-  shouldNarrate: () => shouldNarrate,
   shuffle: () => shuffle,
-  snapshotAt: () => snapshotAt,
-  snapshotSeries: () => snapshotSeries,
-  spatialFindings: () => spatialFindings,
-  splitTitleBody: () => splitTitleBody,
-  synthesizeBurstSources: () => synthesizeBurstSources,
   timePairs: () => timePairs,
-  topBridges: () => topBridges,
-  topFlows: () => topFlows,
-  totals: () => totals,
-  trackClusters: () => trackClusters
+  topBridges: () => topBridges
 });
 module.exports = __toCommonJS(temporal_exports);
 
@@ -214,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;
@@ -484,444 +245,6 @@ 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) });
-      }
-    }
-    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 };
-}
-
-// 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)]);
-  }
-  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;
-      }
-      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);
-    }
-    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;
-}
-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})` : "")
-      );
-    }
-  }
-  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}`);
-    }
-  }
-  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}`);
-    }
-  }
-  return lines.join("\n");
-}
-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() };
-  }
-  return { title: fallbackTitle, body: trimmed };
-}
-
-// 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;
-  }
-  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);
-}
-
-// src/temporal/spatial.ts
-function matchRules(values, rules) {
-  if (!values) return [];
-  return rules.filter((r) => {
-    const v = values[r.metric];
-    if (v === void 0) return false;
-    return r.op === ">=" ? v >= r.threshold : v <= r.threshold;
-  }).map((r) => r.id);
-}
-function spatialFindings(set, metrics, rules, opts = {}) {
-  const { top = 20, requireMatch = false } = opts;
-  const best = /* @__PURE__ */ new Map();
-  for (const burst of detectBursts(set, opts)) {
-    if (!best.has(burst.seriesKey)) best.set(burst.seriesKey, burst);
-  }
-  const findings = [];
-  for (const [region, burst] of best) {
-    const values = metrics[region];
-    const matched = matchRules(values, rules);
-    if (requireMatch && matched.length === 0) continue;
-    const boost = rules.filter((r) => matched.includes(r.id)).reduce((a, r) => a + (r.weight ?? 1), 0);
-    const evidence = {};
-    for (const r of rules) {
-      const v = values?.[r.metric];
-      if (v !== void 0) evidence[r.metric] = v;
-    }
-    findings.push({ region, burst, matched, score: burst.score * (1 + boost), metrics: evidence });
-  }
-  return findings.sort((a, b) => b.score - a.score || (a.region < b.region ? -1 : 1)).slice(0, top);
-}
-
 // src/temporal/lenses.ts
 function reifiedBridgeTargets(fragment, opts) {
   const bridgesOf = /* @__PURE__ */ new Map();
@@ -1036,17 +359,6 @@ function blendPairs(sets) {
   }
   return [...acc.keys()].sort().map((key) => acc.get(key));
 }
-function lensSnapshots(arrivals, pairs, buckets) {
-  const ids = [...arrivals.keys()].sort();
-  return buckets.map((bucket) => {
-    const t = bucket.end - 1;
-    const nodes = ids.filter((id) => arrivals.get(id) <= t);
-    const active = new Set(nodes);
-    const edges = pairs.filter((p) => active.has(p.a) && active.has(p.b)).map((p) => ({ a: p.a, b: p.b, weight: p.w }));
-    const activity = new Map(nodes.map((id) => [id, arrivals.get(id)]));
-    return { t, nodes, edges, activity };
-  });
-}
 
 // src/temporal/bridges.ts
 function bridgingScores(edges, labels) {