@odla-ai/kg 0.3.0 → 0.3.2

package/dist/temporal/index.d.cts

@@ -550,4 +550,141 @@ declare function flowFrames(events: readonly TemporalEvent[], opts: {
 /** The frame's top-n flows by weight (already the frame's sort order). */
 declare function topFlows(frame: FlowFrame, n: number): Flow[];
 
-export { type Burst, type BurstOptions, type Cluster, type ClusterChange, type ClusterFrame, type EnrichmentCandidate, type EventSpec, type Flow, type FlowFrame, type GeoSpec, type GraphIndex, type Hotspot, type LayoutOptions, type NodeId, type NodeRef, type ReportClusterChange, type ReportLead, type ReportOptions, type Series, type SeriesKeyer, type SeriesSet, type Snapshot, type TemporalConfig, type TemporalEvent, type TemporalReport, type TimeBucket, type TimeGrain, type Timeline, type TimelineEdge, type XY, bucketFor, bucketKey, bucketRange, buildNarrationMaterials, buildTemporalReport, buildTimeline, burstScores, byNodeId, detectBursts, extractEvents, flowFrames, forceLayout, hash32, indexGraph, labelPropagation, layoutSequence, leadScores, mulberry32, nodeId, parseAmount, parseDateMs, rankEnrichmentCandidates, rankHotspots, resolvePath, rollup, seriesKeys, shouldNarrate, shuffle, snapshotAt, snapshotSeries, splitTitleBody, synthesizeBurstSources, topFlows, totals, trackClusters };
+/**
+ * One threshold rule over a region's static metrics. A rule matches when the
+ * region has the metric and its value passes the comparison; regions or
+ * metrics missing from the metric map never match (and never throw).
+ */
+interface SpatialRule {
+    /** Stable identifier, reported on findings (e.g. `"capital-desert"`). */
+    id: string;
+    /** Metric name looked up in the region's metric record. */
+    metric: string;
+    /** Comparison direction against {@link threshold}. */
+    op: ">=" | "<=";
+    threshold: number;
+    /** Additive score boost when matched (finding score × (1 + Σ weights)). Default 1. */
+    weight?: number;
+}
+/** A bursting region, the rules it matched, and its boosted rank score. */
+interface SpatialFinding {
+    /** The series key — the region identifier the events were rolled up by. */
+    region: string;
+    /** The region's strongest burst (highest score) in the set. */
+    burst: Burst;
+    /** Ids of the rules that matched, in the rules' given order. */
+    matched: string[];
+    /** `burst.score × (1 + Σ matched weights)` — rule context amplifies heat. */
+    score: number;
+    /** The region's values for every rule metric it has (evidence for narration). */
+    metrics: Record<string, number>;
+}
+/** Ids of the rules a region's metric record matches, in rule order. */
+declare function matchRules(values: Record<string, number> | undefined, rules: readonly SpatialRule[]): string[];
+/**
+ * Rank spatial anomalies: detect bursts in a geo-keyed SeriesSet (one series
+ * per region — roll up with `by: "geo"`), keep each region's strongest burst,
+ * then amplify by matched metric rules. Deterministic: score desc, then
+ * region asc. `requireMatch` drops regions matching no rule (default keeps
+ * them — a burst is a finding even without metric context).
+ */
+declare function spatialFindings(set: SeriesSet, metrics: Record<string, Record<string, number> | undefined>, rules: readonly SpatialRule[], opts?: BurstOptions & {
+    top?: number;
+    requireMatch?: boolean;
+}): SpatialFinding[];
+
+/** One undirected weighted pair, with (capped) bridging node ids as evidence. */
+interface WeightedPair {
+    a: string;
+    b: string;
+    w: number;
+    via: string[];
+}
+/**
+ * Bridge → target sets through a REIFIED relationship node (affiliation,
+ * funding_round, record): every reified node with a `bridgeLabel` edge to the
+ * bridge and a `targetLabel` edge to a target contributes that target to the
+ * bridge's set. Ids are `type:key`.
+ */
+declare function reifiedBridgeTargets(fragment: GraphFragment, opts: {
+    reified: string;
+    bridgeLabel: string;
+    targetLabel: string;
+}): Map<string, Set<string>>;
+/** Direct-edge targets: `from` node id → set of `to` node ids for one label. */
+declare function directTargets(fragment: GraphFragment, label: string): Map<string, Set<string>>;
+/** Compose A→B with B→C into A→C (e.g. person→companies ∘ company→counties). */
+declare function composeTargets(ab: Map<string, Set<string>>, bc: Map<string, Set<string>>): Map<string, Set<string>>;
+/**
+ * The bipartite projection: targets sharing a bridge become pairs, weight =
+ * number of distinct shared bridges. `maxPerBridge` skips promiscuous hubs
+ * (a bridge touching 40 targets says little about any pair). Deterministic
+ * pair order (a < b, then sorted).
+ */
+declare function projectBridges(bridges: Map<string, Set<string>>, opts?: {
+    maxPerBridge?: number;
+    viaCap?: number;
+}): WeightedPair[];
+/**
+ * Temporal cohort pairs: each node links to its k nearest neighbors in
+ * arrival time, weight decaying with the gap (0.5 per halfLife). Nodes
+ * without a date contribute nothing.
+ */
+declare function timePairs(arrivals: Map<string, number>, opts?: {
+    k?: number;
+    halfLifeDays?: number;
+}): WeightedPair[];
+/**
+ * Spatial proximity pairs: k nearest neighbors in normalized map space,
+ * weight decaying with distance (0.5 per halfDist). Nodes without a
+ * position contribute nothing. O(n²) — fine for the ≤1k-node universes
+ * lenses operate on.
+ */
+declare function geoPairs(positions: Map<string, XY>, opts?: {
+    k?: number;
+    halfDist?: number;
+}): WeightedPair[];
+/**
+ * Blend lens edge sets: each set is normalized to a max weight of 1 (a lens
+ * with big raw counts must not drown the others), scaled by its slider
+ * weight, and summed per pair. Zero-weight lenses drop out entirely.
+ */
+declare function blendPairs(sets: Array<{
+    pairs: WeightedPair[];
+    weight: number;
+}>): WeightedPair[];
+/**
+ * Fabricate the Snapshot series a lens graph replays: at each bucket end,
+ * nodes that have arrived and the blended edges among them. Slots straight
+ * into labelPropagation/trackClusters/layoutSequence.
+ */
+declare function lensSnapshots(arrivals: Map<string, number>, pairs: WeightedPair[], buckets: readonly TimeBucket[]): Snapshot[];
+
+/** One node's brokerage: normalized score + the communities it connects. */
+interface Bridging {
+    /** 0..1, 1 = the frame's strongest connector. */
+    score: number;
+    /** Communities this node touches through its edges (own community first). */
+    groups: string[];
+}
+/**
+ * Score every node's brokerage against a community partition. Edges inside a
+ * community contribute nothing; an edge to a foreign community contributes
+ * its weight, and the total is multiplied by the number of DISTINCT foreign
+ * communities — a node wiring three groups together outranks one with the
+ * same raw weight into a single neighbor group. Scores are normalized to
+ * the frame's max (empty/one-community frames → all zeros).
+ */
+declare function bridgingScores(edges: ReadonlyArray<{
+    a: NodeId;
+    b: NodeId;
+    weight?: number;
+}>, labels: Map<NodeId, string>): Map<NodeId, Bridging>;
+/** The frame's strongest connectors, ranked (ties: id order). */
+declare function topBridges(bridging: Map<NodeId, Bridging>, n?: number): Array<{
+    id: NodeId;
+    score: number;
+    groups: string[];
+}>;
+
+export { type Bridging, type Burst, type BurstOptions, type Cluster, type ClusterChange, type ClusterFrame, type EnrichmentCandidate, type EventSpec, type Flow, type FlowFrame, type GeoSpec, type GraphIndex, type Hotspot, type LayoutOptions, type NodeId, type NodeRef, type ReportClusterChange, type ReportLead, type ReportOptions, type Series, type SeriesKeyer, type SeriesSet, type Snapshot, type SpatialFinding, type SpatialRule, type TemporalConfig, type TemporalEvent, type TemporalReport, type TimeBucket, type TimeGrain, type Timeline, type TimelineEdge, type WeightedPair, type XY, blendPairs, bridgingScores, bucketFor, bucketKey, bucketRange, buildNarrationMaterials, buildTemporalReport, buildTimeline, burstScores, byNodeId, composeTargets, detectBursts, directTargets, extractEvents, flowFrames, forceLayout, geoPairs, hash32, indexGraph, labelPropagation, layoutSequence, leadScores, lensSnapshots, matchRules, mulberry32, nodeId, parseAmount, parseDateMs, projectBridges, rankEnrichmentCandidates, rankHotspots, reifiedBridgeTargets, resolvePath, rollup, seriesKeys, shouldNarrate, shuffle, snapshotAt, snapshotSeries, spatialFindings, splitTitleBody, synthesizeBurstSources, timePairs, topBridges, topFlows, totals, trackClusters };

package/dist/temporal/index.d.ts

@@ -550,4 +550,141 @@ declare function flowFrames(events: readonly TemporalEvent[], opts: {
 /** The frame's top-n flows by weight (already the frame's sort order). */
 declare function topFlows(frame: FlowFrame, n: number): Flow[];
 
-export { type Burst, type BurstOptions, type Cluster, type ClusterChange, type ClusterFrame, type EnrichmentCandidate, type EventSpec, type Flow, type FlowFrame, type GeoSpec, type GraphIndex, type Hotspot, type LayoutOptions, type NodeId, type NodeRef, type ReportClusterChange, type ReportLead, type ReportOptions, type Series, type SeriesKeyer, type SeriesSet, type Snapshot, type TemporalConfig, type TemporalEvent, type TemporalReport, type TimeBucket, type TimeGrain, type Timeline, type TimelineEdge, type XY, bucketFor, bucketKey, bucketRange, buildNarrationMaterials, buildTemporalReport, buildTimeline, burstScores, byNodeId, detectBursts, extractEvents, flowFrames, forceLayout, hash32, indexGraph, labelPropagation, layoutSequence, leadScores, mulberry32, nodeId, parseAmount, parseDateMs, rankEnrichmentCandidates, rankHotspots, resolvePath, rollup, seriesKeys, shouldNarrate, shuffle, snapshotAt, snapshotSeries, splitTitleBody, synthesizeBurstSources, topFlows, totals, trackClusters };
+/**
+ * One threshold rule over a region's static metrics. A rule matches when the
+ * region has the metric and its value passes the comparison; regions or
+ * metrics missing from the metric map never match (and never throw).
+ */
+interface SpatialRule {
+    /** Stable identifier, reported on findings (e.g. `"capital-desert"`). */
+    id: string;
+    /** Metric name looked up in the region's metric record. */
+    metric: string;
+    /** Comparison direction against {@link threshold}. */
+    op: ">=" | "<=";
+    threshold: number;
+    /** Additive score boost when matched (finding score × (1 + Σ weights)). Default 1. */
+    weight?: number;
+}
+/** A bursting region, the rules it matched, and its boosted rank score. */
+interface SpatialFinding {
+    /** The series key — the region identifier the events were rolled up by. */
+    region: string;
+    /** The region's strongest burst (highest score) in the set. */
+    burst: Burst;
+    /** Ids of the rules that matched, in the rules' given order. */
+    matched: string[];
+    /** `burst.score × (1 + Σ matched weights)` — rule context amplifies heat. */
+    score: number;
+    /** The region's values for every rule metric it has (evidence for narration). */
+    metrics: Record<string, number>;
+}
+/** Ids of the rules a region's metric record matches, in rule order. */
+declare function matchRules(values: Record<string, number> | undefined, rules: readonly SpatialRule[]): string[];
+/**
+ * Rank spatial anomalies: detect bursts in a geo-keyed SeriesSet (one series
+ * per region — roll up with `by: "geo"`), keep each region's strongest burst,
+ * then amplify by matched metric rules. Deterministic: score desc, then
+ * region asc. `requireMatch` drops regions matching no rule (default keeps
+ * them — a burst is a finding even without metric context).
+ */
+declare function spatialFindings(set: SeriesSet, metrics: Record<string, Record<string, number> | undefined>, rules: readonly SpatialRule[], opts?: BurstOptions & {
+    top?: number;
+    requireMatch?: boolean;
+}): SpatialFinding[];
+
+/** One undirected weighted pair, with (capped) bridging node ids as evidence. */
+interface WeightedPair {
+    a: string;
+    b: string;
+    w: number;
+    via: string[];
+}
+/**
+ * Bridge → target sets through a REIFIED relationship node (affiliation,
+ * funding_round, record): every reified node with a `bridgeLabel` edge to the
+ * bridge and a `targetLabel` edge to a target contributes that target to the
+ * bridge's set. Ids are `type:key`.
+ */
+declare function reifiedBridgeTargets(fragment: GraphFragment, opts: {
+    reified: string;
+    bridgeLabel: string;
+    targetLabel: string;
+}): Map<string, Set<string>>;
+/** Direct-edge targets: `from` node id → set of `to` node ids for one label. */
+declare function directTargets(fragment: GraphFragment, label: string): Map<string, Set<string>>;
+/** Compose A→B with B→C into A→C (e.g. person→companies ∘ company→counties). */
+declare function composeTargets(ab: Map<string, Set<string>>, bc: Map<string, Set<string>>): Map<string, Set<string>>;
+/**
+ * The bipartite projection: targets sharing a bridge become pairs, weight =
+ * number of distinct shared bridges. `maxPerBridge` skips promiscuous hubs
+ * (a bridge touching 40 targets says little about any pair). Deterministic
+ * pair order (a < b, then sorted).
+ */
+declare function projectBridges(bridges: Map<string, Set<string>>, opts?: {
+    maxPerBridge?: number;
+    viaCap?: number;
+}): WeightedPair[];
+/**
+ * Temporal cohort pairs: each node links to its k nearest neighbors in
+ * arrival time, weight decaying with the gap (0.5 per halfLife). Nodes
+ * without a date contribute nothing.
+ */
+declare function timePairs(arrivals: Map<string, number>, opts?: {
+    k?: number;
+    halfLifeDays?: number;
+}): WeightedPair[];
+/**
+ * Spatial proximity pairs: k nearest neighbors in normalized map space,
+ * weight decaying with distance (0.5 per halfDist). Nodes without a
+ * position contribute nothing. O(n²) — fine for the ≤1k-node universes
+ * lenses operate on.
+ */
+declare function geoPairs(positions: Map<string, XY>, opts?: {
+    k?: number;
+    halfDist?: number;
+}): WeightedPair[];
+/**
+ * Blend lens edge sets: each set is normalized to a max weight of 1 (a lens
+ * with big raw counts must not drown the others), scaled by its slider
+ * weight, and summed per pair. Zero-weight lenses drop out entirely.
+ */
+declare function blendPairs(sets: Array<{
+    pairs: WeightedPair[];
+    weight: number;
+}>): WeightedPair[];
+/**
+ * Fabricate the Snapshot series a lens graph replays: at each bucket end,
+ * nodes that have arrived and the blended edges among them. Slots straight
+ * into labelPropagation/trackClusters/layoutSequence.
+ */
+declare function lensSnapshots(arrivals: Map<string, number>, pairs: WeightedPair[], buckets: readonly TimeBucket[]): Snapshot[];
+
+/** One node's brokerage: normalized score + the communities it connects. */
+interface Bridging {
+    /** 0..1, 1 = the frame's strongest connector. */
+    score: number;
+    /** Communities this node touches through its edges (own community first). */
+    groups: string[];
+}
+/**
+ * Score every node's brokerage against a community partition. Edges inside a
+ * community contribute nothing; an edge to a foreign community contributes
+ * its weight, and the total is multiplied by the number of DISTINCT foreign
+ * communities — a node wiring three groups together outranks one with the
+ * same raw weight into a single neighbor group. Scores are normalized to
+ * the frame's max (empty/one-community frames → all zeros).
+ */
+declare function bridgingScores(edges: ReadonlyArray<{
+    a: NodeId;
+    b: NodeId;
+    weight?: number;
+}>, labels: Map<NodeId, string>): Map<NodeId, Bridging>;
+/** The frame's strongest connectors, ranked (ties: id order). */
+declare function topBridges(bridging: Map<NodeId, Bridging>, n?: number): Array<{
+    id: NodeId;
+    score: number;
+    groups: string[];
+}>;
+
+export { type Bridging, type Burst, type BurstOptions, type Cluster, type ClusterChange, type ClusterFrame, type EnrichmentCandidate, type EventSpec, type Flow, type FlowFrame, type GeoSpec, type GraphIndex, type Hotspot, type LayoutOptions, type NodeId, type NodeRef, type ReportClusterChange, type ReportLead, type ReportOptions, type Series, type SeriesKeyer, type SeriesSet, type Snapshot, type SpatialFinding, type SpatialRule, type TemporalConfig, type TemporalEvent, type TemporalReport, type TimeBucket, type TimeGrain, type Timeline, type TimelineEdge, type WeightedPair, type XY, blendPairs, bridgingScores, bucketFor, bucketKey, bucketRange, buildNarrationMaterials, buildTemporalReport, buildTimeline, burstScores, byNodeId, composeTargets, detectBursts, directTargets, extractEvents, flowFrames, forceLayout, geoPairs, hash32, indexGraph, labelPropagation, layoutSequence, leadScores, lensSnapshots, matchRules, mulberry32, nodeId, parseAmount, parseDateMs, projectBridges, rankEnrichmentCandidates, rankHotspots, reifiedBridgeTargets, resolvePath, rollup, seriesKeys, shouldNarrate, shuffle, snapshotAt, snapshotSeries, spatialFindings, splitTitleBody, synthesizeBurstSources, timePairs, topBridges, topFlows, totals, trackClusters };

package/dist/temporal/index.js

@@ -759,7 +759,202 @@ function flowFrames(events, opts) {
 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 }));
+}
 export {
+  blendPairs,
+  bridgingScores,
   bucketFor,
   bucketKey,
   bucketRange,
@@ -768,21 +963,28 @@ export {
   buildTimeline,
   burstScores,
   byNodeId,
+  composeTargets,
   detectBursts,
+  directTargets,
   extractEvents,
   flowFrames,
   forceLayout,
+  geoPairs,
   hash32,
   indexGraph,
   labelPropagation,
   layoutSequence,
   leadScores,
+  lensSnapshots,
+  matchRules,
   mulberry32,
   nodeId,
   parseAmount,
   parseDateMs,
+  projectBridges,
   rankEnrichmentCandidates,
   rankHotspots,
+  reifiedBridgeTargets,
   resolvePath,
   rollup,
   seriesKeys,
@@ -790,8 +992,11 @@ export {
   shuffle,
   snapshotAt,
   snapshotSeries,
+  spatialFindings,
   splitTitleBody,
   synthesizeBurstSources,
+  timePairs,
+  topBridges,
   topFlows,
   totals,
   trackClusters