react-state-basis 0.6.4 → 0.6.5

package/dist/index.js

@@ -34,7 +34,9 @@ __export(index_exports, {
   basis: () => basis,
   configureBasis: () => configureBasis,
   createContext: () => createContext,
+  getBasisGraph: () => getBasisGraph,
   getBasisMetrics: () => getBasisMetrics,
+  printBasisGraph: () => printBasisGraph,
   printBasisHealthReport: () => printBasisHealthReport,
   use: () => use,
   useActionState: () => useActionState,
@@ -125,6 +127,27 @@ var calculateSpectralInfluence = (graph, maxIterations = 20, tolerance = 1e-3) =
   }
   return scores;
 };
+var groupEventSources = (nodes, edges) => {
+  const outgoing = /* @__PURE__ */ new Map();
+  edges.forEach((e) => {
+    if (!outgoing.has(e.source)) outgoing.set(e.source, []);
+    outgoing.get(e.source).push(e);
+  });
+  const eventSourceIds = nodes.filter((n) => n.role === "event").map((n) => n.id);
+  const signatureOf = (sourceEdges) => sourceEdges.map((e) => `${e.target}@${e.weight}`).sort().join("|");
+  const buckets = /* @__PURE__ */ new Map();
+  eventSourceIds.forEach((id) => {
+    const sig = signatureOf(outgoing.get(id) || []);
+    if (!buckets.has(sig)) buckets.set(sig, []);
+    buckets.get(sig).push(id);
+  });
+  const groups = Array.from(buckets.values()).map((sourceIds) => ({
+    sourceIds,
+    occurrences: sourceIds.length,
+    edges: (outgoing.get(sourceIds[0]) || []).slice()
+  }));
+  return groups.sort((a, b) => b.edges.length - a.edges.length || b.occurrences - a.occurrences);
+};
 
 // src/core/constants.ts
 var WINDOW_SIZE = 50;
@@ -144,6 +167,7 @@ var parseLabel = (label) => {
   return { file: parts[0] || "Unknown", name: parts[1] || base };
 };
 var isSameField = (labelA, labelB) => stripInstance(labelA) === stripInstance(labelB);
+var isEffectLabel = (name) => /^effect_L\d+(:\d+)?$/.test(name) || name === "anonymous_effect" || name === "anonymous_layout_effect";
 
 // src/core/ranker.ts
 var identifyTopIssues = (graph, history2, redundantLabels2, violationMap) => {
@@ -539,6 +563,99 @@ var displayCausalHint = (targetLabel, targetMeta, sourceLabel, sourceMeta) => {
   }
   console.groupEnd();
 };
+var splitHookLine = (raw) => {
+  const m = raw.match(/^(.*):(\d+)$/);
+  if (!m) return { hook: raw };
+  return { hook: m[1], line: Number(m[2]) };
+};
+var formatHook = (raw) => {
+  const { hook } = splitHookLine(raw);
+  if (!isEffectLabel(hook)) return hook;
+  const lineMatch = hook.match(/L(\d+)$/);
+  return lineMatch ? `effect @ L${lineMatch[1]}` : "effect (anonymous)";
+};
+var formatNode = (node, fallbackId = "?") => {
+  if (!node) return fallbackId;
+  if (node.role === "event") return "Event";
+  const hook = formatHook(node.name || node.id);
+  if (node.file && hook) return `${node.file} \u2192 ${hook}`;
+  return hook || node.id;
+};
+var displayGraphReport = (graph) => {
+  if (!isWeb) return;
+  if (graph.nodes.length === 0) {
+    console.log(
+      `%c \u{1F4CA} BASIS | CAUSAL GRAPH %c(no data yet)`,
+      STYLES.headerIdentity,
+      `color: ${THEME.muted}; font-style: italic;`
+    );
+    return;
+  }
+  const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
+  const outgoing = /* @__PURE__ */ new Map();
+  graph.edges.forEach((e) => {
+    if (!outgoing.has(e.source)) outgoing.set(e.source, []);
+    outgoing.get(e.source).push(e);
+  });
+  const eventGroups = graph.eventGroups.map((g) => ({
+    sourceIds: g.sourceIds,
+    sourceNode: nodeById.get(g.sourceIds[0]),
+    edges: g.edges,
+    occurrences: g.occurrences
+  }));
+  const groupedSourceIds = new Set(graph.eventGroups.flatMap((g) => g.sourceIds));
+  const nonEventGroups = Array.from(outgoing.keys()).filter((id) => !groupedSourceIds.has(id)).map((id) => ({ sourceIds: [id], sourceNode: nodeById.get(id), edges: outgoing.get(id), occurrences: 1 }));
+  const groups = [...eventGroups, ...nonEventGroups].sort(
+    (a, b) => b.edges.length - a.edges.length || b.occurrences - a.occurrences
+  );
+  console.group(
+    `%c \u{1F4CA} BASIS | CAUSAL GRAPH %c${graph.nodes.length} nodes \xB7 ${graph.edges.length} edges \xB7 ${groups.length} sources \xB7 buffer window ${graph.bufferWindowSize}`,
+    STYLES.headerIdentity,
+    `color: ${THEME.muted}; font-weight: normal; font-style: italic;`
+  );
+  console.log(
+    `%cparent \u2192 child = observed cause \u2192 update. (\xD7N) = times in this window. Event groups with the same fan-out are collapsed.`,
+    STYLES.subText
+  );
+  groups.forEach((group) => {
+    const isEvent = group.sourceNode?.role === "event";
+    const isCtx = group.sourceNode?.role === "context" /* CONTEXT */;
+    const isFx = group.sourceNode?.role === "effect";
+    const isUnknown = group.sourceNode?.role === "unknown";
+    const icon = isEvent ? "\u26A1" : isCtx ? "\u03A9" : isFx ? "\u21AF" : isUnknown ? "?" : "\u25CF";
+    const color = isEvent ? THEME.solution : isCtx ? THEME.context : THEME.identity;
+    const fanout = group.edges.length;
+    const hits = group.occurrences;
+    const hitLabel = hits > 1 ? ` \xB7 \xD7${hits}` : "";
+    const title = isEvent ? `Event \xB7 ${fanout} target${fanout === 1 ? "" : "s"}${hitLabel}` : formatNode(group.sourceNode, group.sourceIds[0]);
+    console.groupCollapsed(
+      `%c${icon} %c${title}`,
+      `color: ${color};`,
+      "font-family: monospace; font-weight: 600;"
+    );
+    group.edges.slice().sort((a, b) => b.weight - a.weight).forEach((edge) => {
+      const target = nodeById.get(edge.target);
+      const label = formatNode(target, edge.target);
+      const weight = edge.weight > 1 ? ` (\xD7${edge.weight})` : "";
+      if (target?.redundant) {
+        console.log(
+          `%c  ${label}%c${weight} %credundant`,
+          `color: ${THEME.muted}; font-family: monospace;`,
+          `color: ${THEME.muted}; font-style: italic;`,
+          `color: ${THEME.problem}; font-weight: bold;`
+        );
+      } else {
+        console.log(
+          `%c  ${label}%c${weight}`,
+          `color: ${THEME.muted}; font-family: monospace;`,
+          `color: ${THEME.muted}; font-style: italic;`
+        );
+      }
+    });
+    console.groupEnd();
+  });
+  console.groupEnd();
+};
 var displayViolentBreaker = (label, count, threshold) => {
   if (!isWeb) return;
   const { name } = parseLabel(label);
@@ -925,9 +1042,53 @@ var getBasisMetrics = () => ({
   analysis_ms: instance.metrics.lastAnalysisTimeMs.toFixed(3),
   entropy: instance.metrics.systemEntropy.toFixed(3)
 });
+var getBasisGraph = () => {
+  const nodeIds = /* @__PURE__ */ new Set();
+  const edges = [];
+  instance.graph.forEach((targets, source) => {
+    nodeIds.add(source);
+    targets.forEach((weight, target) => {
+      nodeIds.add(target);
+      edges.push({ source, target, weight });
+    });
+  });
+  const nodes = Array.from(nodeIds).map((id) => {
+    if (id.startsWith("Event_Tick_")) {
+      return { id, name: "Event", file: "(shared trigger)", role: "event", density: null, redundant: false };
+    }
+    const meta = instance.history.get(id);
+    const { file, name } = parseLabel(id);
+    if (!meta) {
+      const role = isEffectLabel(name) ? "effect" : "unknown";
+      return { id, name, file, role, density: null, redundant: false };
+    }
+    return {
+      id,
+      name,
+      file,
+      role: meta.role,
+      density: meta.density,
+      redundant: instance.redundantLabels.has(id)
+    };
+  });
+  return {
+    generatedAt: Date.now(),
+    bufferWindowSize: WINDOW_SIZE,
+    eventTtlMs: EVENT_TTL,
+    nodes,
+    edges,
+    eventGroups: groupEventSources(nodes, edges)
+  };
+};
+var printBasisGraph = () => {
+  if (!instance.config.debug) return;
+  displayGraphReport(getBasisGraph());
+};
 if (typeof window !== "undefined") {
   window.printBasisReport = printBasisHealthReport;
   window.getBasisMetrics = getBasisMetrics;
+  window.getBasisGraph = getBasisGraph;
+  window.printBasisGraph = printBasisGraph;
 }
 
 // src/hooks.ts
@@ -1330,7 +1491,9 @@ function basis() {
   basis,
   configureBasis,
   createContext,
+  getBasisGraph,
   getBasisMetrics,
+  printBasisGraph,
   printBasisHealthReport,
   use,
   useActionState,