@odla-ai/kg 0.3.0 → 0.3.2

package/dist/temporal/index.cjs

@@ -20,6 +20,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/temporal/index.ts
 var temporal_exports = {};
 __export(temporal_exports, {
+  blendPairs: () => blendPairs,
+  bridgingScores: () => bridgingScores,
   bucketFor: () => bucketFor,
   bucketKey: () => bucketKey,
   bucketRange: () => bucketRange,
@@ -28,21 +30,28 @@ __export(temporal_exports, {
   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,
@@ -50,8 +59,11 @@ __export(temporal_exports, {
   shuffle: () => shuffle,
   snapshotAt: () => snapshotAt,
   snapshotSeries: () => snapshotSeries,
+  spatialFindings: () => spatialFindings,
   splitTitleBody: () => splitTitleBody,
   synthesizeBurstSources: () => synthesizeBurstSources,
+  timePairs: () => timePairs,
+  topBridges: () => topBridges,
   topFlows: () => topFlows,
   totals: () => totals,
   trackClusters: () => trackClusters
@@ -878,4 +890,197 @@ 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 }));
+}
 //# sourceMappingURL=index.cjs.map