react-state-basis 0.6.6 → 0.6.7

package/README.md

@@ -168,7 +168,7 @@ A detected pattern is **not automatically a bug**, and Basis does not know the i
 
 Use the results as prompts for investigation rather than as rules for how React code should be written.
 
-[See examples and possible fixes →](https://github.com/liovic/react-state-basis/wiki/The-Forensic-Catalog)
+[See examples and possible fixes →](https://github.com/liovic/react-state-basis/wiki/Detected-patterns)
 
 ---
 
@@ -338,7 +338,7 @@ Basis is designed primarily as a development-time diagnostic tool.
 
 Actual overhead depends on the application and instrumentation configuration.
 
-[See benchmarks →](https://github.com/liovic/react-state-basis/wiki/Performance-Forensics)
+[See benchmarks →](https://github.com/liovic/react-state-basis/wiki/Performance)
 
 ---
 

package/dist/{chunk-WMHY2C6D.mjs → chunk-KIXM6YRX.mjs}

@@ -285,6 +285,10 @@ var shouldLog = (key) => {
   return false;
 };
 var isBooleanLike = (name) => /^(is|has|can|should|did|will|show|hide)(?=[A-Z_])/.test(name);
+var displayName = (raw) => {
+  const { name } = parseLabel(raw);
+  return name.replace(/:\d+$/, "");
+};
 var areSyncSignificant = (metaA, metaB) => {
   const { kSync, densityA, densityB } = countOverlapsCircular(
     metaA.buffer,
@@ -296,95 +300,80 @@ var areSyncSignificant = (metaA, metaB) => {
 };
 var getSuggestedFix = (issue, info) => {
   if (issue.label.includes("Global Event")) {
-    return `These variables update together but live in different hooks/files. Consolidate them into a single %cuseReducer%c or atomic store update.`;
+    return `One interaction is updating state in several places. If that is really one transition, put it in one %cstore / reducer%c. If it is intentional, ignore this.`;
   }
   const violations = issue.violations || [];
   const leaks = violations.filter((v) => v.type === "causal_leak");
   const mirrors = violations.filter((v) => v.type === "context_mirror");
   const duplicates = violations.filter((v) => v.type === "duplicate_state");
   if (mirrors.length > 0) {
-    return `Local state is 'shadowing' Global Context. This creates two sources of truth. Delete the local state and consume the %cContext%c value directly.`;
+    return `A local hook is only tracking context or a store. If it is not a draft, delete it and read the %ccontext / store%c in render.`;
   }
   if (leaks.length > 0) {
-    const targetName = parseLabel(leaks[0].target).name;
+    const targetName = displayName(leaks[0].target);
     if (issue.label.includes("effect")) {
-      return `This Effect triggers a synchronous re-render of ${targetName}. Calculate ${targetName} during the render phase (Derived State) or wrap in %cuseMemo%c if expensive.`;
+      return `An effect is calling setState on ${targetName}, which paints again. If you can compute ${targetName} while rendering, drop the %ceffect%c.`;
     }
-    return `State cascading detected. ${info.name} triggers ${targetName} in a separate frame. Merge them into one object to update simultaneously.`;
+    return `${info.name} updates, then ${targetName} updates on the next frame. If they are one fact, write them in the same %csetState%c.`;
   }
   if (duplicates.length > 0) {
     if (isBooleanLike(info.name)) {
-      return `Boolean Explosion detected. Multiple flags are toggling in sync. Replace impossible states with a single %cstatus%c string ('idle' | 'loading' | 'success').`;
+      return `Several flags move together. One %cstatus%c value avoids impossible combinations.`;
     }
-    return `Redundant State detected. This variable carries no unique information. Derive it from the source variable during render, or use %cuseMemo%c to cache the result.`;
+    return `These hooks move together. If one is just the other in another shape, compute it while %crendering%c.`;
   }
   if (issue.metric === "density") {
-    return `High-Frequency Update. This variable updates faster than the frame rate. Apply %cdebounce%c or move to a Ref to unblock the main thread.`;
+    return `This hook updates faster than a frame. %cDebounce%c it or keep it in a ref if the UI does not need every pulse.`;
   }
-  return `Check the dependency chain of ${info.name}.`;
+  return `Inspect ${info.name} and what updates with it.`;
 };
 var displayHealthReport = (history2, violationMap) => {
   if (!isWeb) return;
   const entries = Array.from(history2.entries());
   if (entries.length === 0) return;
   const topIssues = identifyTopIssues(instance.graph, history2, instance.redundantLabels, violationMap);
-  console.group(`%c \u{1F4CA} BASIS | ARCHITECTURAL HEALTH REPORT `, STYLES.headerIdentity);
+  console.group(`%c BASIS | report `, STYLES.headerIdentity);
   if (topIssues.length > 0) {
-    console.log(
-      `%c\u{1F3AF} REFACTOR PRIORITIES %c(PRIME MOVERS)`,
-      `font-weight: bold; color: ${THEME.identity}; margin-top: 10px;`,
-      `font-weight: normal; color: ${THEME.muted}; font-style: italic;`
-    );
+    console.log(`%cStart here`, `font-weight: bold; color: ${THEME.identity}; margin-top: 10px;`);
     topIssues.forEach((issue, idx) => {
       const info = parseLabel(issue.label);
-      const icon = issue.metric === "influence" ? "\u26A1" : "\u{1F4C8}";
+      const icon = issue.metric === "influence" ? "\u2192" : "\u2022";
       const pColor = idx === 0 ? THEME.problem : idx === 1 ? THEME.solution : THEME.identity;
-      let displayName = info.name;
-      let displayFile = info.file;
-      if (issue.label.includes("Global Event")) {
-        displayName = info.name;
-        displayFile = info.file;
-      }
       console.group(
-        ` %c${idx + 1}%c ${icon} ${displayName} %c(${displayFile})`,
+        ` %c${idx + 1}%c ${icon} ${displayName(issue.label)} %c(${info.file})`,
         `background: ${pColor}; color: ${idx === 1 ? "black" : "white"}; border-radius: 50%; padding: 0 5px;`,
         "font-family: monospace; font-weight: 700;",
-        `color: ${THEME.muted}; font-size: 10px; font-weight: normal; font-style: italic;`
+        `color: ${THEME.muted}; font-size: 10px; font-weight: normal;`
       );
-      console.log(`%c${issue.reason}`, `color: ${THEME.muted}; font-style: italic;`);
+      console.log(`%c${issue.reason}`, `color: ${THEME.muted};`);
       if (issue.violations.length > 0) {
         const byFile = /* @__PURE__ */ new Map();
         issue.violations.forEach((v) => {
           if (issue.label.includes("Global Event") && v.type === "context_mirror") return;
           const { file, name } = parseLabel(v.target);
           if (!byFile.has(file)) byFile.set(file, []);
-          byFile.get(file).push(name);
+          byFile.get(file).push(name.replace(/:\d+$/, ""));
         });
         const impactParts = [];
         byFile.forEach((vars, file) => {
-          const varList = vars.join(", ");
-          impactParts.push(`${file} (${varList})`);
+          impactParts.push(`${file} (${vars.join(", ")})`);
         });
         if (impactParts.length > 0) {
-          console.log(`%cImpacts: %c${impactParts.join(" + ")}`, STYLES.impactLabel, "");
+          console.log(`%cAlso updates: %c${impactParts.join(" \xB7 ")}`, STYLES.impactLabel, "");
         }
       }
       const fix = getSuggestedFix(issue, info);
       const fixParts = fix.split("%c");
       if (fixParts.length === 3) {
         console.log(
-          `%cSolution: %c${fixParts[0]}%c${fixParts[1]}%c${fixParts[2]}`,
+          `%cTry: %c${fixParts[0]}%c${fixParts[1]}%c${fixParts[2]}`,
           STYLES.actionLabel,
           "",
           STYLES.actionPill,
           ""
         );
       } else {
-        console.log(
-          `%cSolution: %c${fix}`,
-          STYLES.actionLabel,
-          ""
-        );
+        console.log(`%cTry: %c${fix}`, STYLES.actionLabel, "");
       }
       console.groupEnd();
     });
@@ -408,135 +397,170 @@ var displayHealthReport = (history2, violationMap) => {
     else independentCount++;
   });
   const totalVars = entries.length;
-  const redundancyScore = (independentCount + clusters.length) / totalVars * 100;
-  let internalEdges = 0;
-  instance.graph.forEach((targets, source) => {
-    if (source.startsWith("Event_Tick_")) return;
-    internalEdges += targets.size;
-  });
-  const causalPenalty = internalEdges / totalVars * 100;
-  let healthScore = redundancyScore - causalPenalty;
-  if (healthScore < 0) healthScore = 0;
-  const scoreColor = healthScore > 85 ? THEME.success : THEME.problem;
   console.log(
-    `%cSystem Efficiency: %c${healthScore.toFixed(1)}%`,
-    STYLES.bold,
-    `color: ${scoreColor}; font-weight: bold;`
+    `%c${independentCount + clusters.length} of ${totalVars} instrumented hooks look independent in this window.`,
+    STYLES.subText
   );
-  console.log(`%cSources of Truth: ${independentCount + clusters.length}/${totalVars} | Causal Leaks: ${internalEdges}`, STYLES.subText);
   if (clusters.length > 0) {
-    console.log(`%cDetected ${clusters.length} Sync Issues:`, `font-weight: bold; color: ${THEME.problem}; margin-top: 10px;`);
+    console.log(
+      `%c${clusters.length} group${clusters.length === 1 ? "" : "s"} that keep updating together:`,
+      `font-weight: bold; color: ${THEME.problem}; margin-top: 10px;`
+    );
     clusters.forEach((cluster, idx) => {
       const clusterMetas = cluster.map((l) => ({
         label: l,
         meta: history2.get(l),
-        name: parseLabel(l).name
+        name: displayName(l)
       }));
       const hasCtx = clusterMetas.some(
         (c) => c.meta.role === "context" /* CONTEXT */ || c.meta.role === "store" /* STORE */
       );
-      const names = clusterMetas.map((c) => {
-        const prefix = c.meta.role === "store" /* STORE */ ? "\u03A3 " : c.meta.role === "context" /* CONTEXT */ ? "\u03A9 " : "";
-        return `${prefix}${c.name}`;
-      }).join(" \u27F7 ");
-      console.group(` %c${idx + 1}%c ${names}`, `background: ${THEME.problem}; color: white; border-radius: 50%; padding: 0 5px;`, "font-family: monospace; font-weight: bold;");
+      const names = clusterMetas.map((c) => c.name).join(", ");
+      console.group(
+        ` %c${idx + 1}%c ${names}`,
+        `background: ${THEME.problem}; color: white; border-radius: 50%; padding: 0 5px;`,
+        "font-family: monospace; font-weight: bold;"
+      );
       if (hasCtx) {
         const hasStore = clusterMetas.some((c) => c.meta.role === "store" /* STORE */);
-        const sourceType = hasStore ? "External Store" : "global context";
-        console.log(`%cDiagnosis: ${hasStore ? "Store" : "Context"} Mirroring. Local state is shadowing ${sourceType}.`, `color: ${THEME.problem};`);
-        console.log(`%cSolution: Use ${sourceType} directly to avoid state drift.`, STYLES.actionLabel);
+        const sourceType = hasStore ? "a store" : "context";
+        console.log(`A local hook is only following ${sourceType}.`);
+        console.log(
+          `%cTry:%c Read ${sourceType} in render if the local value is not a draft.`,
+          STYLES.actionLabel,
+          ""
+        );
       } else {
-        const boolKeywords = ["is", "has", "can", "should", "loading", "success", "error", "active", "enabled", "open", "visible"];
+        const boolKeywords = [
+          "is",
+          "has",
+          "can",
+          "should",
+          "loading",
+          "success",
+          "error",
+          "active",
+          "enabled",
+          "open",
+          "visible"
+        ];
         const boolCount = clusterMetas.filter(
           (c) => boolKeywords.some((kw) => c.name.toLowerCase().startsWith(kw))
         ).length;
-        const isBoolExplosion = cluster.length > 2 && boolCount / cluster.length > 0.5;
-        if (isBoolExplosion) {
-          console.log(`%cDiagnosis:%c Boolean Explosion. Multiple booleans updating in sync.`, STYLES.bold, "");
-          console.log(`%cSolution:%c Combine into a single %cstatus%c string or a %creducer%c.`, STYLES.actionLabel, "", STYLES.actionPill, "", STYLES.actionPill, "");
+        if (cluster.length > 2 && boolCount / cluster.length > 0.5) {
+          console.log(`These flags move together.`);
+          console.log(
+            `%cTry:%c One %cstatus%c instead of several booleans.`,
+            STYLES.actionLabel,
+            "",
+            STYLES.actionPill,
+            ""
+          );
         } else if (cluster.length > 2) {
-          console.log(`%cDiagnosis:%c Sibling Updates. These states respond to the same event.`, STYLES.bold, "");
-          console.log(`%cSolution:%c This may be intentional. If not, consolidate into a %creducer%c.`, STYLES.actionLabel, "", STYLES.actionPill, "");
+          console.log(`These hooks move on the same frames. Often the same click or fetch.`);
+          console.log(
+            `%cTry:%c Leave it if that is intentional. Otherwise one %creducer%c.`,
+            STYLES.actionLabel,
+            "",
+            STYLES.actionPill,
+            ""
+          );
         } else {
-          console.log(`%cDiagnosis:%c Redundant State. Variables always change together.`, STYLES.bold, "");
-          console.log(`%cSolution:%c Derive one from the other via %cuseMemo%c.`, STYLES.actionLabel, "", STYLES.actionPill, "");
+          console.log(`These two hooks keep updating in the same frame.`);
+          console.log(
+            `%cTry:%c If one is derived, compute it while %crendering%c.`,
+            STYLES.actionLabel,
+            "",
+            STYLES.actionPill,
+            ""
+          );
         }
       }
       console.groupEnd();
     });
   } else {
-    console.log("%c\u2728 Your architecture is clean. No redundant state detected.", `color: ${THEME.success}; font-weight: bold;`);
+    console.log(
+      "%cNo hooks were updating in lockstep in this window.",
+      `color: ${THEME.success}; font-weight: bold;`
+    );
   }
   console.groupEnd();
 };
-var displayRedundancyAlert = (labelA, metaA, labelB, metaB, sim) => {
+var displayRedundancyAlert = (labelA, metaA, labelB, metaB, overlap) => {
   if (!isWeb || !shouldLog(`redundant-${labelA}-${labelB}`)) return;
   const infoA = parseLabel(labelA);
-  const infoB = parseLabel(labelB);
+  const nameA = displayName(labelA);
+  const nameB = displayName(labelB);
   const isContextMirror = metaA.role === "local" /* LOCAL */ && metaB.role === "context" /* CONTEXT */ || metaB.role === "local" /* LOCAL */ && metaA.role === "context" /* CONTEXT */;
   const isStoreMirror = metaA.role === "local" /* LOCAL */ && metaB.role === "store" /* STORE */ || metaB.role === "local" /* LOCAL */ && metaA.role === "store" /* STORE */;
-  const alertType = isContextMirror ? "CONTEXT MIRRORING" : isStoreMirror ? "STORE MIRRORING" : "DUPLICATE STATE";
-  console.group(`%c \u264A BASIS | ${alertType} `, STYLES.headerProblem);
-  console.log(`%c\u{1F4CD} Location: %c${infoA.file}`, STYLES.bold, STYLES.location);
-  console.log(`%cIssue:%c ${infoA.name} and ${infoB.name} overlapped on ${(sim * 100).toFixed(0)}% of aligned updates.`, STYLES.bold, "");
+  const alertType = isContextMirror ? "local state follows context" : isStoreMirror ? "local state follows a store" : "hooks moving together";
+  const times = overlap.kSync === 1 ? "time" : "times";
+  console.group(`%c BASIS | ${alertType} `, STYLES.headerProblem);
+  console.log(`%c${infoA.file}`, STYLES.location);
+  console.log(
+    `%c${nameA}%c and %c${nameB}%c updated in the same frame ${overlap.kSync} ${times}.`,
+    STYLES.label,
+    "",
+    STYLES.label,
+    ""
+  );
   if (isContextMirror || isStoreMirror) {
-    const sourceType = isStoreMirror ? "External Store" : "Global Context";
+    const sourceType = isStoreMirror ? "store" : "context";
     console.log(
-      `%cFix:%c Local state is 'shadowing' ${sourceType}. Delete the local state and consume the %c${sourceType}%c value directly.`,
+      `%cTry:%c If this is not a draft, delete the local hook and read the %c${sourceType}%c in render.`,
+      STYLES.bold,
+      "",
+      STYLES.actionPill,
+      ""
+    );
+  } else if (isBooleanLike(nameA) || isBooleanLike(nameB)) {
+    console.log(
+      `%cTry:%c One %cstatus%c instead of several flags.`,
       STYLES.bold,
       "",
       STYLES.actionPill,
       ""
     );
   } else {
-    if (isBooleanLike(infoA.name) || isBooleanLike(infoB.name)) {
-      console.log(
-        `%cFix:%c Boolean Explosion detected. Merge flags into a single %cstatus%c string or %cuseReducer%c.`,
-        STYLES.bold,
-        "",
-        STYLES.actionPill,
-        "",
-        STYLES.actionPill,
-        ""
-      );
-    } else {
-      console.log(
-        `%cFix:%c Redundant State detected. Derive %c${infoB.name}%c from %c${infoA.name}%c during render, or use %cuseMemo%c.`,
-        STYLES.bold,
-        "",
-        STYLES.label,
-        "",
-        STYLES.label,
-        "",
-        STYLES.actionPill,
-        ""
-      );
-    }
+    console.log(
+      `%cTry:%c If %c${nameB}%c is just %c${nameA}%c in another shape, compute it while rendering.`,
+      STYLES.bold,
+      "",
+      STYLES.label,
+      "",
+      STYLES.label,
+      ""
+    );
   }
   console.groupEnd();
 };
-var displayCausalHint = (targetLabel, targetMeta, sourceLabel, sourceMeta) => {
+var displayCausalHint = (targetLabel, _targetMeta, sourceLabel, sourceMeta) => {
   if (!isWeb || !shouldLog(`causal-${sourceLabel}-${targetLabel}`)) return;
   const target = parseLabel(targetLabel);
-  const source = parseLabel(sourceLabel);
-  const headerType = sourceMeta.role === "context" /* CONTEXT */ ? "CONTEXT SYNC LEAK" : sourceMeta.role === "store" /* STORE */ ? "STORE SYNC LEAK" : "DOUBLE RENDER";
+  const sourceName = displayName(sourceLabel);
+  const targetName = displayName(targetLabel);
+  const headerType = sourceMeta.role === "context" /* CONTEXT */ ? "extra render from context" : sourceMeta.role === "store" /* STORE */ ? "extra render from a store" : "extra render";
   const isEffect = sourceLabel.includes("effect") || sourceLabel.includes("useLayoutEffect");
-  console.groupCollapsed(`%c \u26A1 BASIS | ${headerType} `, STYLES.headerProblem);
-  console.log(`%c\u{1F4CD} Location: %c${target.file}`, STYLES.bold, STYLES.location);
-  console.log(`%cIssue:%c ${source.name} triggers ${target.name} in separate frames.`, STYLES.bold, "");
+  console.groupCollapsed(`%c BASIS | ${headerType} `, STYLES.headerProblem);
+  console.log(`%c${target.file}`, STYLES.location);
+  console.log(
+    `%c${sourceName}%c updates %c${targetName}%c on the next frame.`,
+    STYLES.label,
+    "",
+    STYLES.label,
+    ""
+  );
   if (isEffect) {
     console.log(
-      `%cFix:%c Derive %c${target.name}%c during the render phase (remove effect) or wrap in %cuseMemo%c.`,
+      `%cTry:%c If %c${targetName}%c can be computed while rendering, drop the extra setState.`,
       STYLES.bold,
       "",
       STYLES.label,
-      "",
-      STYLES.actionPill,
       ""
     );
   } else {
     console.log(
-      `%cFix:%c Merge %c${target.name}%c with %c${source.name}%c into a single state update.`,
+      `%cTry:%c Write %c${targetName}%c in the same update as %c${sourceName}%c if they are one fact.`,
       STYLES.bold,
       "",
       STYLES.label,
@@ -569,7 +593,7 @@ var displayGraphReport = (graph) => {
   if (!isWeb) return;
   if (graph.nodes.length === 0) {
     console.log(
-      `%c \u{1F4CA} BASIS | CAUSAL GRAPH %c(no data yet)`,
+      `%c BASIS | update graph %c(nothing recorded yet)`,
       STYLES.headerIdentity,
       `color: ${THEME.muted}; font-style: italic;`
     );
@@ -588,17 +612,22 @@ var displayGraphReport = (graph) => {
     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 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}`,
+    `%c BASIS | update graph %c${graph.nodes.length} nodes \xB7 ${graph.edges.length} edges \xB7 ${groups.length} sources \xB7 last ${graph.bufferWindowSize} frames`,
     STYLES.headerIdentity,
-    `color: ${THEME.muted}; font-weight: normal; font-style: italic;`
+    `color: ${THEME.muted}; font-weight: normal;`
   );
   console.log(
-    `%cparent \u2192 child = observed cause \u2192 update. (\xD7N) = times in this window. Event groups with the same fan-out are collapsed.`,
+    `%cparent \u2192 child = what we saw cause an update. (\xD7N) = times in this window. Repeat clicks with the same targets are grouped.`,
     STYLES.subText
   );
   groups.forEach((group) => {
@@ -606,12 +635,12 @@ var displayGraphReport = (graph) => {
     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 icon = isEvent ? "\u2022" : isCtx ? "ctx" : isFx ? "fx" : isUnknown ? "?" : "\u2022";
     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]);
+    const title = isEvent ? `click / event \xB7 ${fanout} update${fanout === 1 ? "" : "s"}${hitLabel}` : formatNode(group.sourceNode, group.sourceIds[0]);
     console.groupCollapsed(
       `%c${icon} %c${title}`,
       `color: ${color};`,
@@ -623,16 +652,16 @@ var displayGraphReport = (graph) => {
       const weight = edge.weight > 1 ? ` (\xD7${edge.weight})` : "";
       if (target?.redundant) {
         console.log(
-          `%c  ${label}%c${weight} %credundant`,
+          `%c  ${label}%c${weight} %cmoving with another hook`,
           `color: ${THEME.muted}; font-family: monospace;`,
-          `color: ${THEME.muted}; font-style: italic;`,
+          `color: ${THEME.muted};`,
           `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;`
+          `color: ${THEME.muted};`
         );
       }
     });
@@ -640,19 +669,26 @@ var displayGraphReport = (graph) => {
   });
   console.groupEnd();
 };
-var displayViolentBreaker = (label, count, threshold) => {
+var displayViolentBreaker = (label, count, _threshold) => {
   if (!isWeb) return;
-  const { name } = parseLabel(label);
-  console.group(`%c \u{1F6D1} BASIS CRITICAL | CIRCUIT BREAKER `, STYLES.headerProblem);
-  console.error(`INFINITE LOOP DETECTED
-Variable: ${name}
-Frequency: ${count} updates/sec`);
-  console.log(`%cACTION: Update BLOCKED to prevent browser freeze.`, `color: ${THEME.problem}; font-weight: bold;`);
+  const name = displayName(label);
+  console.group(`%c BASIS | loop guard `, STYLES.headerProblem);
+  console.error(
+    `${name} updated ${count} times in one second. Basis stopped recording this path so the tab stays usable.`
+  );
+  console.log(
+    `%cReact may still error on its own. Fix the effect that writes a value it also lists as a dependency.`,
+    `color: ${THEME.muted};`
+  );
   console.groupEnd();
 };
 var displayBootLog = (windowSize) => {
   if (!isWeb) return;
-  console.log(`%cBasis%cAuditor%c "Graph Era" (Window: ${windowSize})`, STYLES.basis, STYLES.version, `color: ${THEME.muted}; font-style: italic; margin-left: 8px;`);
+  console.log(
+    `%cBasis%c watching updates (${windowSize}-frame window)`,
+    STYLES.basis,
+    `color: ${THEME.muted}; margin-left: 8px;`
+  );
 };
 
 // src/core/analysis.ts
@@ -693,6 +729,12 @@ var calculateAllSimilarities = (entryA, entryB) => {
     significantLead
   };
 };
+var overlapFrom = (s) => ({
+  kSync: s.kSync,
+  densityA: s.densityA,
+  densityB: s.densityB,
+  cosine: s.sync
+});
 var shouldSkipComparison = (entryA, entryB, dirtyLabels2) => {
   if (entryA.label === entryB.label) return true;
   if (isSameField(entryA.label, entryB.label)) return true;
@@ -717,21 +759,21 @@ var detectRedundancy = (entryA, entryB, similarities, redundantSet, violationMap
   const roleB = entryB.meta.role;
   if (isGlobalSource(roleA) && isGlobalSource(roleB)) return;
   if (similarities.densityA < 2 || similarities.densityB < 2) return;
-  const score = similarities.sync;
+  const overlap = overlapFrom(similarities);
   if (roleA === "local" /* LOCAL */ && isGlobalSource(roleB)) {
     redundantSet.add(entryA.label);
-    pushViolation(violationMap, entryB.label, { type: "context_mirror", target: entryA.label, similarity: score });
-    displayRedundancyAlert(entryA.label, entryA.meta, entryB.label, entryB.meta, score);
+    pushViolation(violationMap, entryB.label, { type: "context_mirror", target: entryA.label, overlap });
+    displayRedundancyAlert(entryA.label, entryA.meta, entryB.label, entryB.meta, overlap);
   } else if (isGlobalSource(roleA) && roleB === "local" /* LOCAL */) {
     redundantSet.add(entryB.label);
-    pushViolation(violationMap, entryA.label, { type: "context_mirror", target: entryB.label, similarity: score });
-    displayRedundancyAlert(entryB.label, entryB.meta, entryA.label, entryA.meta, score);
+    pushViolation(violationMap, entryA.label, { type: "context_mirror", target: entryB.label, overlap });
+    displayRedundancyAlert(entryB.label, entryB.meta, entryA.label, entryA.meta, overlap);
   } else if (roleA === "local" /* LOCAL */ && roleB === "local" /* LOCAL */) {
     redundantSet.add(entryA.label);
     redundantSet.add(entryB.label);
-    pushViolation(violationMap, entryA.label, { type: "duplicate_state", target: entryB.label, similarity: score });
-    pushViolation(violationMap, entryB.label, { type: "duplicate_state", target: entryA.label, similarity: score });
-    displayRedundancyAlert(entryA.label, entryA.meta, entryB.label, entryB.meta, score);
+    pushViolation(violationMap, entryA.label, { type: "duplicate_state", target: entryB.label, overlap });
+    pushViolation(violationMap, entryB.label, { type: "duplicate_state", target: entryA.label, overlap });
+    displayRedundancyAlert(entryA.label, entryA.meta, entryB.label, entryB.meta, overlap);
   }
 };
 var detectCausalLeak = (entryA, entryB, similarities, violationMap, graph) => {
@@ -1095,4 +1137,4 @@ export {
   getBasisGraph,
   printBasisGraph
 };
-//# sourceMappingURL=chunk-WMHY2C6D.mjs.map
+//# sourceMappingURL=chunk-KIXM6YRX.mjs.map