react-state-basis 0.4.1 → 0.5.0

package/dist/index.js

@@ -33,11 +33,14 @@ __export(index_exports, {
   BasisProvider: () => BasisProvider,
   basis: () => basis,
   configureBasis: () => configureBasis,
+  createContext: () => createContext,
+  getBasisMetrics: () => getBasisMetrics,
   printBasisHealthReport: () => printBasisHealthReport,
   use: () => use,
-  useActionState: () => useActionState2,
+  useActionState: () => useActionState,
   useBasisConfig: () => useBasisConfig,
   useCallback: () => useCallback,
+  useContext: () => useContext,
   useDebugValue: () => useDebugValue2,
   useDeferredValue: () => useDeferredValue,
   useEffect: () => useEffect,
@@ -46,7 +49,7 @@ __export(index_exports, {
   useInsertionEffect: () => useInsertionEffect2,
   useLayoutEffect: () => useLayoutEffect,
   useMemo: () => useMemo,
-  useOptimistic: () => useOptimistic2,
+  useOptimistic: () => useOptimistic,
   useReducer: () => useReducer,
   useRef: () => useRef,
   useState: () => useState,
@@ -59,10 +62,39 @@ module.exports = __toCommonJS(index_exports);
 var React = __toESM(require("react"));
 var import_react = require("react");
 
+// src/core/math.ts
+var calculateSimilarityCircular = (bufferA, headA, bufferB, headB, offset) => {
+  const L = bufferA.length;
+  let dot = 0, magA = 0, magB = 0;
+  const baseOffset = ((headB - headA + offset) % L + L) % L;
+  for (let i = 0; i < L; i++) {
+    const valA = bufferA[i];
+    let iB = i + baseOffset;
+    if (iB >= L) {
+      iB -= L;
+    }
+    const valB = bufferB[iB];
+    dot += valA * valB;
+    magA += valA * valA;
+    magB += valB * valB;
+  }
+  if (magA === 0 || magB === 0) return 0;
+  return dot / (Math.sqrt(magA) * Math.sqrt(magB));
+};
+var calculateCosineSimilarity = (A, B) => {
+  let dot = 0, magA = 0, magB = 0;
+  for (let i = 0; i < A.length; i++) {
+    dot += A[i] * B[i];
+    magA += A[i] * A[i];
+    magB += B[i] * B[i];
+  }
+  return magA === 0 || magB === 0 ? 0 : dot / (Math.sqrt(magA) * Math.sqrt(magB));
+};
+
 // src/core/logger.ts
 var isWeb = typeof window !== "undefined" && typeof window.document !== "undefined";
 var LAST_LOG_TIMES = /* @__PURE__ */ new Map();
-var LOG_COOLDOWN = 5e3;
+var LOG_COOLDOWN = 3e3;
 var STYLES = {
   basis: "background: #6c5ce7; color: white; font-weight: bold; padding: 2px 6px; border-radius: 3px;",
   version: "background: #a29bfe; color: #2d3436; padding: 2px 6px; border-radius: 3px; margin-left: -4px;",
@@ -71,9 +103,10 @@ var STYLES = {
   headerGreen: "background: #00b894; color: white; font-weight: bold; padding: 4px 8px; border-radius: 4px;",
   label: "background: #dfe6e9; color: #2d3436; padding: 0 4px; border-radius: 3px; font-family: monospace; font-weight: bold; border: 1px solid #b2bec3;",
   location: "color: #0984e3; font-family: monospace; font-weight: bold;",
-  codeBlock: "background: #1e1e1e; color: #9cdcfe; padding: 8px 12px; display: block; margin: 4px 0; border-left: 3px solid #00b894; font-family: monospace; line-height: 1.4; border-radius: 0 3px 3px 0;",
   subText: "color: #636e72; font-size: 11px;",
-  bold: "font-weight: bold;"
+  bold: "font-weight: bold;",
+  action: "color: #00b894; font-weight: bold; border: 1px solid #00b894; padding: 0 4px; border-radius: 3px;",
+  warning: "color: #d63031; font-weight: bold; border: 1px solid #d63031; padding: 0 4px; border-radius: 3px;"
 };
 var parseLabel = (label) => {
   const parts = label.split(" -> ");
@@ -84,384 +117,482 @@ var shouldLog = (key) => {
   const last = LAST_LOG_TIMES.get(key) || 0;
   if (now - last > LOG_COOLDOWN) {
     LAST_LOG_TIMES.set(key, now);
-    if (LAST_LOG_TIMES.size > 100) {
-      const cutoff = now - 36e5;
-      for (const [k, v] of LAST_LOG_TIMES.entries()) {
-        if (v < cutoff) LAST_LOG_TIMES.delete(k);
-      }
-    }
     return true;
   }
   return false;
 };
-var displayBootLog = (windowSize) => {
-  if (!isWeb) return;
-  console.log(
-    `%cBasis%cAuditor%c | Temporal Analysis Active (Window: ${windowSize})`,
-    STYLES.basis,
-    STYLES.version,
-    "color: #636e72; font-style: italic; margin-left: 8px;"
-  );
-};
-var displayRedundancyAlert = (labelA, labelB, sim) => {
+var displayRedundancyAlert = (labelA, metaA, labelB, metaB, sim) => {
   if (!isWeb || !shouldLog(`redundant-${labelA}-${labelB}`)) return;
   const infoA = parseLabel(labelA);
   const infoB = parseLabel(labelB);
-  console.group(`%c \u{1F4D0} BASIS | REDUNDANT PATTERN `, STYLES.headerRed);
+  const isContextMirror = metaA.role === "local" && metaB.role === "context" || metaB.role === "local" && metaA.role === "context";
+  const local = metaA.role === "local" ? infoA : infoB;
+  const context = metaA.role === "context" ? infoA : infoB;
+  console.group(`%c \u264A BASIS | ${isContextMirror ? "CONTEXT MIRRORING" : "DUPLICATE STATE"} `, STYLES.headerRed);
   console.log(`%c\u{1F4CD} Location: %c${infoA.file}`, STYLES.bold, STYLES.location);
-  console.log(
-    `%cObservation:%c %c${infoA.name}%c and %c${infoB.name}%c move together.
-%cOne is likely a direct mirror of the other. Confidence: ${(sim * 100).toFixed(0)}%`,
-    STYLES.bold,
-    "",
-    STYLES.label,
-    "",
-    STYLES.label,
-    "",
-    STYLES.subText
-  );
-  console.log(
-    `%cAction:%c Refactor %c${infoB.name}%c to useMemo.`,
-    "color: #00b894; font-weight: bold;",
-    "",
-    "color: #e84393; font-weight: bold;",
-    ""
-  );
-  console.groupEnd();
-};
-var displayCausalHint = (targetLabel, sourceLabel, method = "math") => {
-  const key = `causal-${sourceLabel}-${targetLabel}`;
-  if (!isWeb || !shouldLog(key)) return;
-  const target = parseLabel(targetLabel);
-  const source = parseLabel(sourceLabel);
-  console.groupCollapsed(
-    `%c \u{1F4A1} BASIS | ${method === "math" ? "DETECTED" : "TRACKED"} SYNC LEAK `,
-    STYLES.headerBlue
-  );
-  console.log(`%c\u{1F4CD} Location: %c${target.file}`, STYLES.bold, STYLES.location);
-  console.log(
-    `%cFlow:%c %c${source.name}%c \u2794 Effect \u2794 %c${target.name}%c`,
-    STYLES.bold,
-    "",
-    STYLES.label,
-    "",
-    STYLES.label,
-    ""
-  );
-  console.log(
-    `%cContext:%c ${method === "math" ? "The engine detected a consistent 20ms lag between these updates." : "This was caught during React effect execution."}
-%cResult:%c This creates a %cDouble Render Cycle%c.`,
-    STYLES.bold,
-    "",
-    STYLES.bold,
-    "",
-    "color: #d63031; font-weight: bold;",
-    ""
-  );
+  if (isContextMirror) {
+    console.log(
+      `%cIssue:%c Local variable %c${local.name}%c is just a copy of Global Context %c${context.name}%c.
+%cConfidence: ${(sim * 100).toFixed(0)}%`,
+      STYLES.bold,
+      "",
+      STYLES.label,
+      "",
+      STYLES.label,
+      "",
+      STYLES.subText
+    );
+    console.log(`%cFix:%c Use the context value directly to avoid state drift.`, STYLES.bold, STYLES.warning);
+  } else {
+    console.log(
+      `%cIssue:%c %c${infoA.name}%c and %c${infoB.name}%c are synchronized (${(sim * 100).toFixed(0)}% correlation).`,
+      STYLES.bold,
+      "",
+      STYLES.label,
+      "",
+      STYLES.label,
+      ""
+    );
+    console.log(
+      `%cFix:%c Merge states or calculate %c${infoB.name}%c from %c${infoA.name}%c via %cuseMemo%c.`,
+      STYLES.bold,
+      "",
+      STYLES.label,
+      "",
+      STYLES.label,
+      "",
+      STYLES.action,
+      ""
+    );
+  }
   console.groupEnd();
 };
-var displayInfiniteLoop = (label) => {
+var displayHealthReport = (history2, threshold) => {
   if (!isWeb) return;
-  const info = parseLabel(label);
-  console.group(`%c \u{1F6D1} BASIS CRITICAL | CIRCUIT BREAKER `, STYLES.headerRed);
-  console.error(`Infinite oscillation on: %c${info.name}%c`, "color: white; background: #d63031; padding: 2px 4px;", "");
-  console.groupEnd();
-};
-var displayHealthReport = (history2, similarityFn, threshold) => {
   const entries = Array.from(history2.entries());
   const totalVars = entries.length;
   if (totalVars === 0) return;
   const clusters = [];
   const processed = /* @__PURE__ */ new Set();
   let independentCount = 0;
-  entries.forEach(([labelA, vecA]) => {
+  entries.forEach(([labelA, metaA]) => {
     if (processed.has(labelA)) return;
     const currentCluster = [labelA];
     processed.add(labelA);
-    entries.forEach(([labelB, vecB]) => {
+    entries.forEach(([labelB, metaB]) => {
       if (labelA === labelB || processed.has(labelB)) return;
-      const sim = similarityFn(vecA, vecB);
+      const sim = calculateCosineSimilarity(metaA.buffer, metaB.buffer);
       if (sim > threshold) {
+        if (metaA.role === "context" && metaB.role === "context") return;
         currentCluster.push(labelB);
         processed.add(labelB);
       }
     });
-    if (currentCluster.length > 1) {
-      clusters.push(currentCluster);
-    } else {
-      independentCount++;
-    }
+    if (currentCluster.length > 1) clusters.push(currentCluster);
+    else independentCount++;
   });
   const systemRank = independentCount + clusters.length;
   const healthScore = systemRank / totalVars * 100;
-  if (isWeb) {
-    console.group(`%c \u{1F4CA} BASIS | ARCHITECTURAL HEALTH REPORT `, STYLES.headerGreen);
-    console.log(
-      `%cArchitectural Health Score: %c${healthScore.toFixed(1)}% %c(State Distribution: ${systemRank}/${totalVars})`,
-      STYLES.bold,
-      `color: ${healthScore > 85 ? "#00b894" : "#d63031"}; font-size: 16px; font-weight: bold;`,
-      "color: #636e72; font-style: italic;"
-    );
-    if (clusters.length > 0) {
-      console.log(`%cDetected ${clusters.length} Synchronized Update Clusters:`, "font-weight: bold; color: #e17055; margin-top: 10px;");
-      clusters.forEach((cluster, idx) => {
-        const names = cluster.map((l) => parseLabel(l).name).join(" \u27F7 ");
-        console.log(` %c${idx + 1}%c ${names}`, "background: #e17055; color: white; border-radius: 50%; padding: 0 5px;", "font-family: monospace;");
-      });
-      console.log("%c\u{1F4A1} Action: Variables in a cluster move together. Try refactoring them into a single state object or use useMemo for derived values.", STYLES.subText);
-    } else {
-      console.log("%c\u2728 All state variables have optimal distribution. Your Basis is healthy.", "color: #00b894; font-weight: bold; margin-top: 10px;");
-    }
-    if (totalVars > 0 && totalVars < 15) {
-      console.groupCollapsed("%cView Full Correlation Matrix", "color: #636e72; font-size: 11px;");
-      const matrix = {};
-      entries.forEach(([labelA]) => {
-        const nameA = parseLabel(labelA).name;
-        matrix[nameA] = {};
-        entries.forEach(([labelB]) => {
-          const nameB = parseLabel(labelB).name;
-          const sim = similarityFn(history2.get(labelA), history2.get(labelB));
-          matrix[nameA][nameB] = sim > threshold ? `\u274C ${(sim * 100).toFixed(0)}%` : `\u2705`;
-        });
-      });
-      console.table(matrix);
+  console.group(`%c \u{1F4CA} BASIS | ARCHITECTURAL HEALTH REPORT `, STYLES.headerGreen);
+  console.log(
+    `%cEfficiency: %c${healthScore.toFixed(1)}% %c(${systemRank}/${totalVars} Sources of Truth)`,
+    STYLES.bold,
+    `color: ${healthScore > 85 ? "#00b894" : "#d63031"}; font-weight: bold;`,
+    STYLES.subText
+  );
+  if (clusters.length > 0) {
+    console.log(`%cDetected ${clusters.length} Sync Issues:`, "font-weight: bold; color: #e17055; margin-top: 10px;");
+    clusters.forEach((cluster, idx) => {
+      const clusterMetas = cluster.map((l) => ({ label: l, meta: history2.get(l), info: parseLabel(l) }));
+      const contexts = clusterMetas.filter((c) => c.meta.role === "context");
+      const locals = clusterMetas.filter((c) => c.meta.role === "local");
+      const names = clusterMetas.map((c) => `${c.meta.role === "context" ? "\u03A9 " : ""}${c.info.name}`).join(" \u27F7 ");
+      console.group(` %c${idx + 1}%c ${names}`, "background: #e17055; color: white; border-radius: 50%; padding: 0 5px;", "font-family: monospace; font-weight: bold;");
+      if (contexts.length > 0) {
+        const ctxNames = contexts.map((c) => c.info.name).join(", ");
+        console.log(`%cDiagnosis:%c Context Mirroring. Variables are copying from %c${ctxNames}%c.`, STYLES.bold, "", STYLES.label, "");
+        console.log(`%cSolution:%c Use the context directly to avoid state drift.`, STYLES.bold, STYLES.action);
+      } else {
+        const isExplosion = locals.length > 2;
+        if (isExplosion) {
+          console.log(`%cDiagnosis:%c Boolean Explosion. Multiple states updating in sync.`, STYLES.bold, "");
+          console.log(`%cSolution:%c Combine into a single %cstatus%c string or a %creducer%c.`, STYLES.bold, "", STYLES.label, "", STYLES.label, "");
+        } 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.bold, "", STYLES.label, "");
+        }
+      }
       console.groupEnd();
-    }
-    console.groupEnd();
+    });
   } else {
-    console.log(`[BASIS HEALTH] Score: ${healthScore.toFixed(1)}% (State Distribution: ${systemRank}/${totalVars})`);
+    console.log("%c\u2728 Your architecture is clean. No redundant state detected.", "color: #00b894; font-weight: bold;");
   }
+  console.groupEnd();
 };
-
-// src/core/math.ts
-var calculateSimilarityWithOffset = (A, B, offsetA, offsetB, length) => {
-  let dot = 0;
-  let magA = 0;
-  let magB = 0;
-  for (let i = 0; i < length; i++) {
-    const valA = A[i + offsetA];
-    const valB = B[i + offsetB];
-    dot += valA * valB;
-    magA += valA * valA;
-    magB += valB * valB;
+var displayCausalHint = (targetLabel, targetMeta, sourceLabel, sourceMeta) => {
+  if (!isWeb || !shouldLog(`causal-${sourceLabel}-${targetLabel}`)) return;
+  const target = parseLabel(targetLabel);
+  const source = parseLabel(sourceLabel);
+  const isContextTrigger = sourceMeta.role === "context";
+  console.groupCollapsed(`%c \u26A1 BASIS | ${isContextTrigger ? "CONTEXT SYNC LEAK" : "DOUBLE RENDER"} `, STYLES.headerBlue);
+  console.log(`%c\u{1F4CD} Location: %c${target.file}`, STYLES.bold, STYLES.location);
+  if (isContextTrigger) {
+    console.log(`%cIssue:%c Context %c${source.name}%c updated, then local %c${target.name}%c followed 1 frame later.`, STYLES.bold, "", STYLES.label, "", STYLES.label, "");
+    console.log(`%cImpact: This forces React to render the component twice for every change.`, STYLES.subText);
+  } else {
+    console.log(`%cIssue:%c %c${source.name}%c triggers %c${target.name}%c in a separate frame.`, STYLES.bold, "", STYLES.label, "", STYLES.label, "");
   }
-  if (magA === 0 || magB === 0) return 0;
-  return dot / (Math.sqrt(magA) * Math.sqrt(magB));
+  console.log(`%cFix:%c Derive %c${target.name}%c during the first render.`, STYLES.bold, STYLES.action, STYLES.label, "");
+  console.groupEnd();
 };
-var calculateCosineSimilarity = (A, B) => {
-  return calculateSimilarityWithOffset(A, B, 0, 0, A.length);
+var displayViolentBreaker = (label, count, threshold) => {
+  if (!isWeb) return;
+  const parts = label.split(" -> ");
+  console.group(`%c \u{1F6D1} BASIS CRITICAL | CIRCUIT BREAKER `, "background: #dc2626; color: white; font-weight: bold; padding: 8px 16px;");
+  console.error(`INFINITE LOOP DETECTED
+Variable: ${parts[1] || label}
+Frequency: ${count} updates/sec`);
+  console.log(`%cACTION: Update BLOCKED to prevent browser freeze.`, "color: #dc2626; font-weight: bold;");
+  console.groupEnd();
+};
+var displayBootLog = (windowSize) => {
+  if (!isWeb) return;
+  console.log(`%cBasis%cAuditor%c | v0.5.x Architectural Forensics Active (Window: ${windowSize})`, STYLES.basis, STYLES.version, "color: #636e72; font-style: italic; margin-left: 8px;");
 };
 
 // src/core/constants.ts
 var WINDOW_SIZE = 50;
 var SIMILARITY_THRESHOLD = 0.88;
 var LOOP_THRESHOLD = 150;
-var LOOP_WINDOW_MS = 1e3;
-var ANALYSIS_INTERVAL = 5;
 var VOLATILITY_THRESHOLD = 25;
 
+// src/core/analysis.ts
+var calculateAllSimilarities = (entryA, entryB) => {
+  const sync = calculateSimilarityCircular(entryA.meta.buffer, entryA.meta.head, entryB.meta.buffer, entryB.meta.head, 0);
+  const bA = calculateSimilarityCircular(entryA.meta.buffer, entryA.meta.head, entryB.meta.buffer, entryB.meta.head, 1);
+  const aB = calculateSimilarityCircular(entryA.meta.buffer, entryA.meta.head, entryB.meta.buffer, entryB.meta.head, -1);
+  return { sync, bA, aB, max: Math.max(sync, bA, aB) };
+};
+var shouldSkipComparison = (entryA, entryB, dirtyLabels2) => {
+  if (entryA.label === entryB.label) return true;
+  if (dirtyLabels2.has(entryB.label) && entryA.label > entryB.label) return true;
+  return false;
+};
+var detectRedundancy = (entryA, entryB, similarities, redundantSet) => {
+  const roleA = entryA.meta.role;
+  const roleB = entryB.meta.role;
+  if (roleA === "context" /* CONTEXT */ && roleB === "context" /* CONTEXT */) return;
+  if (entryA.meta.density < 2 || entryB.meta.density < 2) return;
+  if (roleA === "local" /* LOCAL */ && roleB === "context" /* CONTEXT */) {
+    redundantSet.add(entryA.label);
+    displayRedundancyAlert(entryA.label, entryA.meta, entryB.label, entryB.meta, similarities.max);
+  } else if (roleA === "context" /* CONTEXT */ && roleB === "local" /* LOCAL */) {
+    redundantSet.add(entryB.label);
+    displayRedundancyAlert(entryB.label, entryB.meta, entryA.label, entryA.meta, similarities.max);
+  } else if (roleA === "local" /* LOCAL */ && roleB === "local" /* LOCAL */) {
+    redundantSet.add(entryA.label);
+    redundantSet.add(entryB.label);
+    displayRedundancyAlert(entryA.label, entryA.meta, entryB.label, entryB.meta, similarities.max);
+  }
+};
+var detectCausalLeak = (entryA, entryB, similarities) => {
+  if (entryA.isVolatile || entryB.isVolatile) return;
+  if (similarities.bA === similarities.max) {
+    displayCausalHint(entryB.label, entryB.meta, entryA.label, entryA.meta);
+  } else if (similarities.aB === similarities.max) {
+    displayCausalHint(entryA.label, entryA.meta, entryB.label, entryB.meta);
+  }
+};
+var detectSubspaceOverlap = (dirtyEntries, allEntries, redundantSet, dirtyLabels2) => {
+  let compCount = 0;
+  for (const entryA of dirtyEntries) {
+    for (const entryB of allEntries) {
+      if (shouldSkipComparison(entryA, entryB, dirtyLabels2)) continue;
+      compCount++;
+      const similarities = calculateAllSimilarities(entryA, entryB);
+      if (similarities.max > SIMILARITY_THRESHOLD) {
+        detectRedundancy(entryA, entryB, similarities, redundantSet);
+        detectCausalLeak(entryA, entryB, similarities);
+      }
+    }
+  }
+  return compCount;
+};
+
 // src/engine.ts
-var GLOBAL_KEY = "__BASIS_ENGINE_INSTANCE__";
+var BASIS_INSTANCE_KEY = /* @__PURE__ */ Symbol.for("__basis_engine_instance__");
+var NULL_SIGNAL = {
+  role: "proj" /* PROJECTION */,
+  buffer: new Uint8Array(0),
+  head: 0,
+  density: 0,
+  options: {}
+};
 var getGlobalInstance = () => {
-  const g = typeof window !== "undefined" ? window : global;
-  if (!g[GLOBAL_KEY]) {
-    g[GLOBAL_KEY] = {
+  const root = globalThis;
+  if (!root[BASIS_INSTANCE_KEY]) {
+    root[BASIS_INSTANCE_KEY] = {
       config: { debug: false },
       history: /* @__PURE__ */ new Map(),
       currentTickBatch: /* @__PURE__ */ new Set(),
       redundantLabels: /* @__PURE__ */ new Set(),
       booted: false,
-      updateLog: [],
       tick: 0,
       isBatching: false,
-      currentEffectSource: null
+      currentEffectSource: null,
+      pausedVariables: /* @__PURE__ */ new Set(),
+      metrics: {
+        lastAnalysisTimeMs: 0,
+        comparisonCount: 0,
+        lastAnalysisTimestamp: 0,
+        systemEntropy: 0
+      },
+      alertCount: 0,
+      loopCounters: /* @__PURE__ */ new Map(),
+      lastCleanup: Date.now()
     };
   }
-  return g[GLOBAL_KEY];
+  return root[BASIS_INSTANCE_KEY];
 };
 var instance = getGlobalInstance();
 var config = instance.config;
 var history = instance.history;
-var currentTickBatch = instance.currentTickBatch;
 var redundantLabels = instance.redundantLabels;
-var configureBasis = (newConfig) => {
-  Object.assign(instance.config, newConfig);
-  if (instance.config.debug && !instance.booted) {
-    displayBootLog(WINDOW_SIZE);
-    instance.booted = true;
-  }
-};
-var getTemporalSimilarity = (vecA, vecB) => {
-  const L = vecA.length;
-  const sync = calculateSimilarityWithOffset(vecA, vecB, 0, 0, L);
-  const bFollowsA = calculateSimilarityWithOffset(vecA, vecB, 0, 1, L - 1);
-  const aFollowsB = calculateSimilarityWithOffset(vecA, vecB, 1, 0, L - 1);
-  return { sync, bFollowsA, aFollowsB };
-};
-var getPulseDensity = (vec) => {
-  let sum = 0;
-  for (let i = 0; i < vec.length; i++) sum += vec[i];
-  return sum;
+var currentTickBatch = instance.currentTickBatch;
+var currentTickRegistry = {};
+var dirtyLabels = /* @__PURE__ */ new Set();
+var calculateTickEntropy = (tickIdx) => {
+  let activeCount = 0;
+  const total = instance.history.size;
+  if (total === 0) return 1;
+  instance.history.forEach((meta) => {
+    if (meta.buffer[tickIdx] === 1) activeCount++;
+  });
+  return 1 - activeCount / total;
 };
 var analyzeBasis = () => {
-  if (!instance.config.debug) {
-    instance.redundantLabels.clear();
+  if (!instance.config.debug || dirtyLabels.size === 0) {
     return;
   }
-  const entries = Array.from(instance.history.entries()).map(([label, vec]) => ({
-    label,
-    vec,
-    density: getPulseDensity(vec)
-  })).filter((e) => e.density >= 2);
-  if (entries.length < 2) return;
-  const newRedundant = /* @__PURE__ */ new Set();
-  for (let i = 0; i < entries.length; i++) {
-    for (let j = i + 1; j < entries.length; j++) {
-      const entryA = entries[i];
-      const entryB = entries[j];
-      const { sync, bFollowsA, aFollowsB } = getTemporalSimilarity(entryA.vec, entryB.vec);
-      const maxSim = Math.max(sync, bFollowsA, aFollowsB);
-      if (maxSim > SIMILARITY_THRESHOLD) {
-        const isBothVolatile = entryA.density > VOLATILITY_THRESHOLD && entryB.density > VOLATILITY_THRESHOLD;
-        if (sync === maxSim) {
-          if (!isBothVolatile) {
-            newRedundant.add(entryA.label);
-            newRedundant.add(entryB.label);
-            displayRedundancyAlert(entryA.label, entryB.label, sync);
-          }
-        } else if (bFollowsA === maxSim) {
-          displayCausalHint(entryB.label, entryA.label, "math");
-        } else if (aFollowsB === maxSim) {
-          displayCausalHint(entryA.label, entryB.label, "math");
-        }
+  const scheduler = globalThis.requestIdleCallback || ((cb) => setTimeout(cb, 1));
+  const snapshot = new Set(dirtyLabels);
+  dirtyLabels.clear();
+  scheduler(() => {
+    const analysisStart = performance.now();
+    const allEntries = [];
+    const dirtyEntries = [];
+    instance.history.forEach((meta, label) => {
+      if (meta.options.suppressAll || meta.density === 0) return;
+      const entry = {
+        label,
+        meta,
+        isVolatile: meta.density > VOLATILITY_THRESHOLD
+      };
+      allEntries.push(entry);
+      if (snapshot.has(label)) {
+        dirtyEntries.push(entry);
+      }
+    });
+    if (dirtyEntries.length === 0 || allEntries.length < 2) return;
+    const nextRedundant = /* @__PURE__ */ new Set();
+    instance.redundantLabels.forEach((l) => {
+      if (!snapshot.has(l)) {
+        nextRedundant.add(l);
       }
+    });
+    const compCount = detectSubspaceOverlap(
+      dirtyEntries,
+      allEntries,
+      nextRedundant,
+      snapshot
+    );
+    instance.redundantLabels.clear();
+    nextRedundant.forEach((l) => {
+      instance.redundantLabels.add(l);
+    });
+    instance.metrics.lastAnalysisTimeMs = performance.now() - analysisStart;
+    instance.metrics.comparisonCount = compCount;
+    instance.metrics.lastAnalysisTimestamp = Date.now();
+  });
+};
+var processHeartbeat = () => {
+  instance.tick++;
+  instance.history.forEach((meta, label) => {
+    const oldValue = meta.buffer[meta.head];
+    const newValue = instance.currentTickBatch.has(label) ? 1 : 0;
+    meta.buffer[meta.head] = newValue;
+    if (oldValue !== newValue) {
+      meta.density += newValue - oldValue;
     }
+    meta.head = (meta.head + 1) % WINDOW_SIZE;
+  });
+  const lastHead = instance.history.size > 0 ? instance.tick % WINDOW_SIZE : 0;
+  instance.metrics.systemEntropy = calculateTickEntropy(lastHead);
+  instance.currentTickBatch.clear();
+  currentTickRegistry = {};
+  instance.isBatching = false;
+  if (dirtyLabels.size > 0) {
+    analyzeBasis();
   }
-  instance.redundantLabels.clear();
-  newRedundant.forEach((label) => instance.redundantLabels.add(label));
 };
 var recordUpdate = (label) => {
   if (!instance.config.debug) return true;
+  if (instance.pausedVariables.has(label)) return false;
   const now = Date.now();
-  instance.updateLog.push({ label, ts: now });
-  if (instance.updateLog.length > 200) {
-    instance.updateLog = instance.updateLog.filter((e) => now - e.ts < LOOP_WINDOW_MS);
+  if (now - instance.lastCleanup > 1e3) {
+    instance.loopCounters.clear();
+    instance.lastCleanup = now;
   }
-  const updateCount = instance.updateLog.filter((e) => e.label === label).length;
-  if (updateCount > LOOP_THRESHOLD) {
-    displayInfiniteLoop(label);
+  const count = (instance.loopCounters.get(label) || 0) + 1;
+  instance.loopCounters.set(label, count);
+  if (count > LOOP_THRESHOLD) {
+    displayViolentBreaker(label, count, LOOP_THRESHOLD);
+    instance.pausedVariables.add(label);
     return false;
   }
   if (instance.currentEffectSource && instance.currentEffectSource !== label) {
-    displayCausalHint(label, instance.currentEffectSource, "tracking");
+    const targetMeta = instance.history.get(label);
+    const sourceMeta = instance.history.get(instance.currentEffectSource);
+    if (targetMeta) {
+      const sourceDensity = sourceMeta?.density || 0;
+      const isVolatile = targetMeta.density > VOLATILITY_THRESHOLD || sourceDensity > VOLATILITY_THRESHOLD;
+      if (!isVolatile) {
+        displayCausalHint(label, targetMeta, instance.currentEffectSource, sourceMeta || NULL_SIGNAL);
+      }
+    }
   }
+  if (currentTickRegistry[label]) return true;
+  currentTickRegistry[label] = true;
   instance.currentTickBatch.add(label);
+  dirtyLabels.add(label);
   if (!instance.isBatching) {
     instance.isBatching = true;
-    setTimeout(() => {
-      instance.tick++;
-      instance.history.forEach((vec, l) => {
-        vec.shift();
-        vec.push(instance.currentTickBatch.has(l) ? 1 : 0);
-      });
-      instance.currentTickBatch.clear();
-      instance.isBatching = false;
-      if (instance.tick % ANALYSIS_INTERVAL === 0) {
-        analyzeBasis();
-      }
-    }, 20);
+    requestAnimationFrame(processHeartbeat);
   }
   return true;
 };
-var beginEffectTracking = (label) => {
-  if (instance.config.debug) instance.currentEffectSource = label;
-};
-var endEffectTracking = () => {
-  instance.currentEffectSource = null;
+var configureBasis = (c) => {
+  Object.assign(instance.config, c);
+  if (instance.config.debug && !instance.booted) {
+    displayBootLog(WINDOW_SIZE);
+    instance.booted = true;
+  }
 };
-var registerVariable = (label) => {
-  if (!instance.config.debug) return;
-  if (!instance.history.has(label)) {
-    instance.history.set(label, new Array(WINDOW_SIZE).fill(0));
+var registerVariable = (l, o = {}) => {
+  if (!instance.config.debug || o.suppressAll) return;
+  if (!instance.history.has(l)) {
+    instance.history.set(l, {
+      buffer: new Uint8Array(WINDOW_SIZE),
+      head: 0,
+      density: 0,
+      options: o,
+      role: o.role || "local" /* LOCAL */
+    });
   }
 };
-var unregisterVariable = (label) => {
-  instance.history.delete(label);
+var unregisterVariable = (l) => {
+  instance.history.delete(l);
+  instance.loopCounters.delete(l);
+  instance.pausedVariables.delete(l);
+  instance.redundantLabels.delete(l);
+};
+var beginEffectTracking = (l) => {
+  if (instance.config.debug) instance.currentEffectSource = l;
+};
+var endEffectTracking = () => {
+  instance.currentEffectSource = null;
 };
 var printBasisHealthReport = (threshold = 0.5) => {
-  if (!instance.config.debug) {
-    console.warn("[Basis] Cannot generate report. Debug mode is OFF.");
-    return;
-  }
-  displayHealthReport(instance.history, calculateCosineSimilarity, threshold);
+  if (!instance.config.debug) return;
+  displayHealthReport(instance.history, threshold);
 };
+var getBasisMetrics = () => ({
+  engine: "v0.5.x",
+  hooks: instance.history.size,
+  analysis_ms: instance.metrics.lastAnalysisTimeMs.toFixed(3),
+  entropy: instance.metrics.systemEntropy.toFixed(3)
+});
 if (typeof window !== "undefined") {
   window.printBasisReport = printBasisHealthReport;
+  window.getBasisMetrics = getBasisMetrics;
 }
-var __testEngine__ = {
-  instance,
-  config: instance.config,
-  history: instance.history,
-  currentTickBatch: instance.currentTickBatch,
-  configureBasis,
-  registerVariable,
-  recordUpdate,
-  printBasisHealthReport,
-  beginEffectTracking,
-  endEffectTracking
-};
 
 // src/hooks.ts
 var anonCount = 0;
 var getFallbackLabel = (type) => `anon_${type}_${anonCount++}`;
+var React19 = React;
 function useState(initialState, label) {
   const [val, setVal] = (0, import_react.useState)(initialState);
   const effectiveLabel = (0, import_react.useRef)(label || getFallbackLabel("state")).current;
   (0, import_react.useEffect)(() => {
-    registerVariable(effectiveLabel);
-    return () => unregisterVariable(effectiveLabel);
+    registerVariable(effectiveLabel, { role: "local" /* LOCAL */ });
+    return () => {
+      unregisterVariable(effectiveLabel);
+    };
   }, [effectiveLabel]);
-  const setter = (0, import_react.useCallback)((newValue) => {
+  const setter = (0, import_react.useCallback)((value) => {
     if (recordUpdate(effectiveLabel)) {
-      setVal(newValue);
+      setVal(value);
     }
   }, [effectiveLabel]);
   return [val, setter];
 }
-function useRef(initialValue, _label) {
-  return (0, import_react.useRef)(initialValue);
-}
 function useReducer(reducer, initialArg, init, label) {
-  const isLazyInit = typeof init === "function";
-  const providedLabel = isLazyInit ? label : typeof init === "string" ? init : void 0;
+  const isLazy = typeof init === "function";
+  const providedLabel = label || (typeof init === "string" ? init : void 0);
   const effectiveLabel = (0, import_react.useRef)(providedLabel || getFallbackLabel("reducer")).current;
-  const [state, dispatch] = (0, import_react.useReducer)(
-    reducer,
-    initialArg,
-    isLazyInit ? init : void 0
-  );
+  const [state, dispatch] = isLazy ? (0, import_react.useReducer)(reducer, initialArg, init) : (0, import_react.useReducer)(reducer, initialArg);
   (0, import_react.useEffect)(() => {
-    registerVariable(effectiveLabel);
-    return () => unregisterVariable(effectiveLabel);
+    registerVariable(effectiveLabel, { role: "local" /* LOCAL */ });
+    return () => {
+      unregisterVariable(effectiveLabel);
+    };
   }, [effectiveLabel]);
   const basisDispatch = (0, import_react.useCallback)((action) => {
     if (recordUpdate(effectiveLabel)) {
       dispatch(action);
     }
-  }, [effectiveLabel]);
+  }, [effectiveLabel, dispatch]);
   return [state, basisDispatch];
 }
+function createContext(defaultValue, label) {
+  const context = (0, import_react.createContext)(defaultValue);
+  const effectiveLabel = label || getFallbackLabel("context");
+  Object.defineProperty(context, "_basis_label", {
+    value: effectiveLabel,
+    writable: false,
+    enumerable: false
+  });
+  return context;
+}
+function useContext(context) {
+  const val = (0, import_react.useContext)(context);
+  const label = context._basis_label;
+  (0, import_react.useLayoutEffect)(() => {
+    if (label) {
+      registerVariable(label, { role: "context" /* CONTEXT */ });
+      recordUpdate(label);
+    }
+  }, [val, label]);
+  return val;
+}
 function useMemo(factory, deps, label) {
-  const effectiveLabel = label || "anonymous_projection";
+  const effectiveLabel = (0, import_react.useRef)(label || getFallbackLabel("proj")).current;
   (0, import_react.useEffect)(() => {
-    if (config.debug) console.log(`%c [Basis] Valid Projection: "${effectiveLabel}" `, "color: #2ecc71; font-weight: bold;");
+    registerVariable(effectiveLabel, { role: "proj" /* PROJECTION */ });
+    return () => {
+      unregisterVariable(effectiveLabel);
+    };
   }, [effectiveLabel]);
   return (0, import_react.useMemo)(factory, deps || []);
 }
 function useCallback(callback, deps, label) {
-  const effectiveLabel = label || "anonymous_callback";
+  const effectiveLabel = (0, import_react.useRef)(label || getFallbackLabel("cb")).current;
   (0, import_react.useEffect)(() => {
-    if (config.debug) console.log(`%c [Basis] Stable Callback: "${effectiveLabel}" `, "color: #2ecc71; font-weight: bold;");
+    registerVariable(effectiveLabel, { role: "proj" /* PROJECTION */ });
+    return () => {
+      unregisterVariable(effectiveLabel);
+    };
   }, [effectiveLabel]);
   return (0, import_react.useCallback)(callback, deps);
 }
@@ -469,54 +600,29 @@ function useEffect(effect, deps, label) {
   const effectiveLabel = label || "anonymous_effect";
   (0, import_react.useEffect)(() => {
     beginEffectTracking(effectiveLabel);
-    const cleanup = effect();
+    const destructor = effect();
     endEffectTracking();
-    return cleanup;
+    return typeof destructor === "function" ? destructor : void 0;
   }, deps);
 }
 function useLayoutEffect(effect, deps, label) {
   const effectiveLabel = label || "anonymous_layout_effect";
   (0, import_react.useLayoutEffect)(() => {
     beginEffectTracking(effectiveLabel);
-    const cleanup = effect();
+    const destructor = effect();
     endEffectTracking();
-    return cleanup;
+    return typeof destructor === "function" ? destructor : void 0;
   }, deps);
 }
-function useTransition(_label) {
-  const [isPending, startTransition] = (0, import_react.useTransition)();
-  const effectiveLabel = _label || "anonymous_transition";
-  const basisStartTransition = (callback) => {
-    if (config.debug) console.log(`%c [Basis] Transition Started: "${effectiveLabel}" `, "color: #e67e22; font-weight: bold;");
-    startTransition(callback);
-  };
-  return [isPending, basisStartTransition];
-}
-function useDeferredValue(value, initialValueOrLabel, label) {
-  const isLabelAsSecondArg = typeof initialValueOrLabel === "string" && label === void 0;
-  const actualInitialValue = isLabelAsSecondArg ? void 0 : initialValueOrLabel;
-  const effectiveLabel = isLabelAsSecondArg ? initialValueOrLabel : label || "anonymous_deferred";
-  const deferredValue = (0, import_react.useDeferredValue)(value, actualInitialValue);
-  (0, import_react.useEffect)(() => {
-    if (config.debug && value !== deferredValue) console.log(`%c [Basis] Value Deferred: "${effectiveLabel}" `, "color: #e67e22; font-weight: bold;");
-  }, [value, deferredValue, effectiveLabel]);
-  return deferredValue;
-}
-var useId2 = (label) => React.useId();
-var useDebugValue2 = React.useDebugValue;
-var useImperativeHandle2 = React.useImperativeHandle;
-var useInsertionEffect2 = React.useInsertionEffect;
-var useSyncExternalStore = import_react.useSyncExternalStore;
-function use(usable) {
-  return (0, import_react.use)(usable);
-}
-function useOptimistic2(passthrough, reducer, label) {
-  const effectiveLabel = label || "anonymous_optimistic";
+function useOptimistic(passthrough, reducer, label) {
+  const effectiveLabel = (0, import_react.useRef)(label || getFallbackLabel("optimistic")).current;
   (0, import_react.useEffect)(() => {
-    registerVariable(effectiveLabel);
-    return () => unregisterVariable(effectiveLabel);
+    registerVariable(effectiveLabel, { role: "local" /* LOCAL */ });
+    return () => {
+      unregisterVariable(effectiveLabel);
+    };
   }, [effectiveLabel]);
-  const [state, reactAddOptimistic] = React.useOptimistic(passthrough, reducer);
+  const [state, reactAddOptimistic] = React19.useOptimistic(passthrough, reducer);
   const addOptimistic = (0, import_react.useCallback)((payload) => {
     if (recordUpdate(effectiveLabel)) {
       reactAddOptimistic(payload);
@@ -524,18 +630,16 @@ function useOptimistic2(passthrough, reducer, label) {
   }, [effectiveLabel, reactAddOptimistic]);
   return [state, addOptimistic];
 }
-function useActionState2(action, initialState, permalink, label) {
-  const isLabelAsThirdArg = typeof permalink === "string" && label === void 0;
-  const actualPermalink = isLabelAsThirdArg ? void 0 : permalink;
-  const effectiveLabel = isLabelAsThirdArg ? permalink : label || "anonymous_action_state";
-  const [state, reactDispatch, isPending] = React.useActionState(
-    action,
-    initialState,
-    actualPermalink
-  );
+function useActionState(action, initialState, permalink, label) {
+  const isLabelArg = typeof permalink === "string" && label === void 0;
+  const effectiveLabel = (0, import_react.useRef)(isLabelArg ? permalink : label || getFallbackLabel("action_state")).current;
+  const actualPermalink = isLabelArg ? void 0 : permalink;
+  const [state, reactDispatch, isPending] = React19.useActionState(action, initialState, actualPermalink);
   (0, import_react.useEffect)(() => {
-    registerVariable(effectiveLabel);
-    return () => unregisterVariable(effectiveLabel);
+    registerVariable(effectiveLabel, { role: "local" /* LOCAL */ });
+    return () => {
+      unregisterVariable(effectiveLabel);
+    };
   }, [effectiveLabel]);
   const basisDispatch = (0, import_react.useCallback)((payload) => {
     if (recordUpdate(effectiveLabel)) {
@@ -544,6 +648,15 @@ function useActionState2(action, initialState, permalink, label) {
   }, [effectiveLabel, reactDispatch]);
   return [state, basisDispatch, isPending];
 }
+var useRef = import_react.useRef;
+var useId2 = React.useId;
+var useDebugValue2 = React.useDebugValue;
+var useImperativeHandle2 = React.useImperativeHandle;
+var useInsertionEffect2 = React.useInsertionEffect;
+var useSyncExternalStore = import_react.useSyncExternalStore;
+var useTransition = import_react.useTransition;
+var useDeferredValue = import_react.useDeferredValue;
+var use = React19.use;
 
 // src/context.tsx
 var import_react3 = require("react");
@@ -595,8 +708,15 @@ var BasisHUD = () => {
   const canvasRef = (0, import_react2.useRef)(null);
   (0, import_react2.useEffect)(() => {
     if (!isExpanded) return;
-    let animationFrame;
+    let isMounted = true;
+    let animationFrame = null;
     const draw = () => {
+      if (!isMounted) {
+        if (animationFrame !== null) {
+          cancelAnimationFrame(animationFrame);
+        }
+        return;
+      }
       const canvas = canvasRef.current;
       if (!canvas) return;
       const ctx = canvas.getContext("2d");
@@ -604,28 +724,27 @@ var BasisHUD = () => {
       const entries = Array.from(history.entries());
       const dpr = window.devicePixelRatio || 1;
       const rawWidth = HUD_DIMENSIONS.WINDOW_SIZE * HUD_DIMENSIONS.COL_WIDTH + HUD_DIMENSIONS.LABEL_WIDTH + HUD_DIMENSIONS.PADDING * 2;
-      const rawHeight = Math.max(entries.length * HUD_DIMENSIONS.ROW_HEIGHT + HUD_DIMENSIONS.PADDING * 2, 60);
+      const rawHeight = Math.max(entries.length * HUD_DIMENSIONS.ROW_HEIGHT + HUD_DIMENSIONS.PADDING * 2, 80);
       updateCanvasSize(canvas, rawWidth, rawHeight, dpr);
       ctx.save();
       ctx.scale(dpr, dpr);
       ctx.clearRect(0, 0, rawWidth, rawHeight);
-      if (entries.length === 0) {
-        renderEmptyState(ctx);
-      } else {
-        renderMatrix(ctx, entries);
-      }
+      if (entries.length === 0) renderEmptyState(ctx);
+      else renderMatrix(ctx, entries);
       ctx.restore();
       animationFrame = requestAnimationFrame(draw);
     };
-    draw();
-    return () => cancelAnimationFrame(animationFrame);
+    animationFrame = requestAnimationFrame(draw);
+    return () => {
+      isMounted = false;
+      if (animationFrame !== null) {
+        cancelAnimationFrame(animationFrame);
+      }
+    };
   }, [isExpanded]);
   return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: getHUDContainerStyle(isExpanded), onClick: () => setIsExpanded(!isExpanded), children: [
     /* @__PURE__ */ (0, import_jsx_runtime.jsx)(HUDHeader, { isExpanded }),
-    isExpanded && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: { padding: "10px 14px 15px 14px" }, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("canvas", { ref: canvasRef, style: { display: "block" } }),
-      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(HUDFooter, {})
-    ] })
+    isExpanded && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { style: { padding: "10px 14px 15px 14px" }, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("canvas", { ref: canvasRef, style: { display: "block" } }) })
   ] });
 };
 function updateCanvasSize(canvas, w, h, dpr) {
@@ -644,63 +763,72 @@ function renderEmptyState(ctx) {
   ctx.fillText("Waiting for state transitions...", HUD_DIMENSIONS.PADDING, 30);
 }
 function renderMatrix(ctx, entries) {
-  entries.forEach(([label, vector], rowIndex) => {
-    const y = rowIndex * HUD_DIMENSIONS.ROW_HEIGHT + HUD_DIMENSIONS.PADDING;
-    const stateName = label.split(" -> ")[1] || label;
-    const density = vector.reduce((acc, bit) => acc + bit, 0);
-    const isVolatile = density > 25;
-    const isRedundant = redundantLabels.has(label);
-    vector.forEach((bit, colIndex) => {
-      const x = colIndex * HUD_DIMENSIONS.COL_WIDTH + HUD_DIMENSIONS.PADDING;
-      ctx.fillStyle = bit === 1 ? isRedundant ? HUD_THEME.error : HUD_THEME.success : HUD_THEME.grid;
-      const w = HUD_DIMENSIONS.COL_WIDTH - 1.5;
-      const h = HUD_DIMENSIONS.ROW_HEIGHT - 4;
-      if (ctx.roundRect) {
-        ctx.beginPath();
-        ctx.roundRect(x, y, w, h, HUD_DIMENSIONS.RADIUS);
-        ctx.fill();
+  const L = HUD_DIMENSIONS.WINDOW_SIZE;
+  const colW = HUD_DIMENSIONS.COL_WIDTH;
+  const rowH = HUD_DIMENSIONS.ROW_HEIGHT;
+  const pad = HUD_DIMENSIONS.PADDING;
+  const cellW = colW - 1.5;
+  const cellH = rowH - 4;
+  const gridPath = new Path2D();
+  const successPath = new Path2D();
+  const contextPath = new Path2D();
+  const errorPath = new Path2D();
+  ctx.font = "11px Inter, Menlo, monospace";
+  let rowIndex = 0;
+  for (const [label, meta] of entries) {
+    const y = rowIndex * rowH + pad;
+    const isContext = meta.role === "context";
+    const isRedundant = !isContext && redundantLabels.has(label);
+    const { buffer, head } = meta;
+    let uiPos = 0;
+    const addToPath = (val, xIdx) => {
+      const x = xIdx * colW + pad;
+      if (val === 1) {
+        if (isContext) contextPath.rect(x, y, cellW, cellH);
+        else if (isRedundant) errorPath.rect(x, y, cellW, cellH);
+        else successPath.rect(x, y, cellW, cellH);
       } else {
-        ctx.fillRect(x, y, w, h);
+        gridPath.rect(x, y, cellW, cellH);
       }
-    });
-    const textX = HUD_DIMENSIONS.WINDOW_SIZE * HUD_DIMENSIONS.COL_WIDTH + HUD_DIMENSIONS.PADDING + 10;
-    ctx.fillStyle = isRedundant ? HUD_THEME.error : isVolatile ? HUD_THEME.success : HUD_THEME.text;
-    ctx.font = `${isRedundant || isVolatile ? "600" : "400"} 11px Inter, Menlo, monospace`;
-    let prefix = "";
-    if (isRedundant) prefix = "! ";
-    else if (isVolatile) prefix = "~ ";
-    const cleanName = prefix + stateName;
-    const truncatedName = cleanName.length > 18 ? cleanName.substring(0, 16) + ".." : cleanName;
-    ctx.fillText(truncatedName, textX, y + 9);
-  });
+    };
+    for (let i = head; i < L; i++) addToPath(buffer[i], uiPos++);
+    for (let i = 0; i < head; i++) addToPath(buffer[i], uiPos++);
+    const stateName = label.split(" -> ")[1] || label;
+    const textX = L * colW + pad + 10;
+    ctx.fillStyle = isContext ? HUD_THEME.header : isRedundant ? HUD_THEME.error : HUD_THEME.text;
+    ctx.fillText((isContext ? "\u03A9 " : isRedundant ? "! " : "") + stateName, textX, y + 9);
+    rowIndex++;
+  }
+  ctx.fillStyle = HUD_THEME.grid;
+  ctx.fill(gridPath);
+  ctx.fillStyle = HUD_THEME.success;
+  ctx.fill(successPath);
+  ctx.fillStyle = HUD_THEME.header;
+  ctx.fill(contextPath);
+  ctx.fillStyle = HUD_THEME.error;
+  ctx.fill(errorPath);
 }
-var HUDHeader = ({ isExpanded }) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: {
-  padding: "10px 14px",
-  backgroundColor: isExpanded ? HUD_THEME.header : "transparent",
-  color: isExpanded ? "white" : HUD_THEME.header,
-  fontWeight: 600,
-  fontSize: "11px",
-  letterSpacing: "0.05em",
-  display: "flex",
-  justifyContent: "space-between",
-  alignItems: "center",
-  transition: "background 0.3s"
-}, children: [
-  /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: isExpanded ? "STATE BASIS MATRIX" : "\u{1F4D0} BASIS ACTIVE" }),
-  isExpanded && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { style: { opacity: 0.8, fontSize: "9px" }, children: "R50" })
-] });
-var HUDFooter = () => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: {
-  marginTop: "12px",
-  paddingTop: "8px",
-  borderTop: `1px solid ${HUD_THEME.grid}`,
-  color: HUD_THEME.textDim,
-  fontSize: "9px",
-  display: "flex",
-  justifyContent: "space-between"
-}, children: [
-  /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: "LINEAR DEPENDENCY AUDIT" }),
-  /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: "THRESHOLD 0.88" })
-] });
+var HUDHeader = ({ isExpanded }) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+  "div",
+  {
+    style: {
+      padding: "10px 14px",
+      backgroundColor: isExpanded ? HUD_THEME.header : "transparent",
+      color: isExpanded ? "white" : HUD_THEME.header,
+      fontWeight: 600,
+      fontSize: "11px",
+      letterSpacing: "0.05em",
+      display: "flex",
+      justifyContent: "space-between",
+      alignItems: "center",
+      transition: "background 0.3s"
+    },
+    children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: isExpanded ? "STATE BASIS MATRIX" : "\u{1F4D0} BASIS ACTIVE" }),
+      isExpanded && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { style: { opacity: 0.8, fontSize: "9px" }, children: "v0.5.x" })
+    ]
+  }
+);
 
 // src/context.tsx
 var import_jsx_runtime2 = require("react/jsx-runtime");
@@ -738,11 +866,14 @@ function basis() {
   BasisProvider,
   basis,
   configureBasis,
+  createContext,
+  getBasisMetrics,
   printBasisHealthReport,
   use,
   useActionState,
   useBasisConfig,
   useCallback,
+  useContext,
   useDebugValue,
   useDeferredValue,
   useEffect,