@odla-ai/kg 0.2.4 → 0.3.2

package/dist/temporal/index.cjs

@@ -0,0 +1,1086 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// 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,
+  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
+});
+module.exports = __toCommonJS(temporal_exports);
+
+// src/temporal/prng.ts
+function hash32(s) {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function shuffle(items, rand) {
+  const out = items.slice();
+  for (let i = out.length - 1; i > 0; i--) {
+    const j = Math.floor(rand() * (i + 1));
+    const tmp = out[i];
+    out[i] = out[j];
+    out[j] = tmp;
+  }
+  return out;
+}
+
+// src/temporal/time.ts
+var DAY = 864e5;
+var DATE_ONLY = /^(\d{4})-(\d{2})-(\d{2})$/;
+function parseDateMs(v) {
+  if (typeof v === "number") return Number.isFinite(v) ? v : null;
+  if (typeof v !== "string") return null;
+  const m = DATE_ONLY.exec(v.trim());
+  if (m) {
+    const t2 = Date.UTC(Number(m[1]), Number(m[2]) - 1, Number(m[3]));
+    return new Date(t2).toISOString().slice(0, 10) === m[0].trim() ? t2 : null;
+  }
+  const t = Date.parse(v);
+  return Number.isNaN(t) ? null : t;
+}
+function isoWeek(t) {
+  const d = new Date(t);
+  const midnight = Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate());
+  const dow = new Date(midnight).getUTCDay() || 7;
+  const thursday = midnight + (4 - dow) * DAY;
+  const year = new Date(thursday).getUTCFullYear();
+  const week = Math.floor((thursday - Date.UTC(year, 0, 1)) / DAY / 7) + 1;
+  return { year, week };
+}
+function isoWeekStart(year, week) {
+  const jan4 = Date.UTC(year, 0, 4);
+  const dow = new Date(jan4).getUTCDay() || 7;
+  return jan4 - (dow - 1) * DAY + (week - 1) * 7 * DAY;
+}
+var pad2 = (n) => String(n).padStart(2, "0");
+function bucketKey(t, grain) {
+  const d = new Date(t);
+  if (grain === "month") return `${d.getUTCFullYear()}-${pad2(d.getUTCMonth() + 1)}`;
+  if (grain === "quarter") return `${d.getUTCFullYear()}-Q${Math.floor(d.getUTCMonth() / 3) + 1}`;
+  const { year, week } = isoWeek(t);
+  return `${year}-W${pad2(week)}`;
+}
+function bucketFor(key) {
+  let m = /^(\d{4})-(\d{2})$/.exec(key);
+  if (m) {
+    const [y, mo] = [Number(m[1]), Number(m[2])];
+    return { key, start: Date.UTC(y, mo - 1, 1), end: Date.UTC(y, mo, 1) };
+  }
+  m = /^(\d{4})-Q([1-4])$/.exec(key);
+  if (m) {
+    const [y, q] = [Number(m[1]), Number(m[2])];
+    return { key, start: Date.UTC(y, (q - 1) * 3, 1), end: Date.UTC(y, q * 3, 1) };
+  }
+  m = /^(\d{4})-W(\d{2})$/.exec(key);
+  if (m) {
+    const start = isoWeekStart(Number(m[1]), Number(m[2]));
+    return { key, start, end: start + 7 * DAY };
+  }
+  throw new Error(`not a bucket key: ${key}`);
+}
+function bucketRange(from, to, grain) {
+  const out = [];
+  if (from > to) return out;
+  let cur = bucketFor(bucketKey(from, grain));
+  const last = bucketKey(to, grain);
+  for (; ; ) {
+    out.push(cur);
+    if (cur.key === last) return out;
+    cur = bucketFor(bucketKey(cur.end, grain));
+  }
+}
+
+// src/temporal/adjacency.ts
+function nodeId(ref) {
+  return `${ref.type}:${ref.key}`;
+}
+function byNodeId(a, b) {
+  const ia = nodeId(a);
+  const ib = nodeId(b);
+  return ia < ib ? -1 : ia > ib ? 1 : 0;
+}
+function indexGraph(fragment) {
+  const nodes = /* @__PURE__ */ new Map();
+  const byType = /* @__PURE__ */ new Map();
+  for (const n of fragment.nodes) {
+    nodes.set(nodeId(n), n);
+    const list = byType.get(n.type);
+    list ? list.push(n) : byType.set(n.type, [n]);
+  }
+  const adj = /* @__PURE__ */ new Map();
+  for (const e of fragment.edges) {
+    const k = `${nodeId(e.from)}|${e.label}`;
+    const list = adj.get(k);
+    list ? list.push(e.to) : adj.set(k, [e.to]);
+  }
+  return {
+    node: (id) => nodes.get(id),
+    out: (id, label) => adj.get(`${id}|${label}`) ?? [],
+    nodesOf: (type) => byType.get(type) ?? []
+  };
+}
+function resolvePath(g, start, labels) {
+  let frontier = [start];
+  for (const label of labels) {
+    const seen = /* @__PURE__ */ new Set();
+    const next = [];
+    for (const ref of frontier) {
+      for (const target of g.out(nodeId(ref), label)) {
+        const id = nodeId(target);
+        if (!seen.has(id)) {
+          seen.add(id);
+          next.push(target);
+        }
+      }
+    }
+    frontier = next;
+  }
+  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;
+  const sorted = [...nodes].sort();
+  const labels = new Map(sorted.map((id) => [id, id]));
+  const neighbors = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    if (!labels.has(e.a) || !labels.has(e.b) || e.a === e.b) continue;
+    const w = e.weight ?? 1;
+    let listA = neighbors.get(e.a);
+    if (!listA) neighbors.set(e.a, listA = []);
+    listA.push({ id: e.b, weight: w });
+    let listB = neighbors.get(e.b);
+    if (!listB) neighbors.set(e.b, listB = []);
+    listB.push({ id: e.a, weight: w });
+  }
+  const rand = mulberry32(seed);
+  for (let round = 0; round < maxRounds; round++) {
+    const order = shuffle(sorted, rand);
+    let changed = false;
+    for (const id of order) {
+      const incident = neighbors.get(id);
+      if (!incident || incident.length === 0) continue;
+      const votes = /* @__PURE__ */ new Map();
+      for (const n of incident) {
+        const label = labels.get(n.id);
+        votes.set(label, (votes.get(label) ?? 0) + n.weight);
+      }
+      let best = [];
+      let bestWeight = -Infinity;
+      for (const [label, weight] of votes) {
+        if (weight > bestWeight) {
+          bestWeight = weight;
+          best = [label];
+        } else if (weight === bestWeight) {
+          best.push(label);
+        }
+      }
+      const current = labels.get(id);
+      if (best.includes(current)) continue;
+      best.sort();
+      const pick = best.length === 1 ? best[0] : best[Math.floor(rand() * best.length)];
+      labels.set(id, pick);
+      changed = true;
+    }
+    if (!changed) break;
+  }
+  const members = /* @__PURE__ */ new Map();
+  for (const [id, label] of labels) {
+    const list = members.get(label);
+    list ? list.push(id) : members.set(label, [id]);
+  }
+  const canonical = /* @__PURE__ */ new Map();
+  for (const [label, ids] of members) canonical.set(label, ids[0]);
+  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();
+  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);
+      }
+    }
+  }
+  return out;
+}
+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}`);
+  }
+  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);
+      }
+    }
+  }
+  return out;
+}
+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 [...acc.keys()].sort().map((k) => acc.get(k));
+}
+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: [] });
+    }
+  }
+  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) });
+    }
+    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 [...acc.keys()].sort().map((key) => acc.get(key));
+}
+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 [...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) {
+  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 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