react-state-basis 0.2.3 → 0.3.0

package/dist/index.js

@@ -41,11 +41,13 @@ __export(index_exports, {
   Suspense: () => Suspense2,
   __testEngine__: () => __testEngine__,
   __test__: () => __test__,
+  basis: () => basis,
   beginEffectTracking: () => beginEffectTracking,
   cloneElement: () => cloneElement2,
   config: () => config,
   configureBasis: () => configureBasis,
   createContext: () => createContext2,
+  createElement: () => createElement2,
   createPortal: () => createPortal,
   createRef: () => createRef2,
   currentTickBatch: () => currentTickBatch,
@@ -77,8 +79,8 @@ __export(index_exports, {
   useMemo: () => useMemo,
   useOptimistic: () => useOptimistic2,
   useReducer: () => useReducer,
-  useRef: () => useRef,
-  useState: () => useState,
+  useRef: () => useRef2,
+  useState: () => useState2,
   useSyncExternalStore: () => useSyncExternalStore,
   useTransition: () => useTransition,
   version: () => version2
@@ -307,96 +309,118 @@ var LOOP_WINDOW_MS = 500;
 var ANALYSIS_INTERVAL = 5;
 
 // src/engine.ts
-var config = {
-  debug: false
+var GLOBAL_KEY = "__BASIS_ENGINE_INSTANCE__";
+var getGlobalInstance = () => {
+  const g = typeof window !== "undefined" ? window : global;
+  if (!g[GLOBAL_KEY]) {
+    g[GLOBAL_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
+    };
+  }
+  return g[GLOBAL_KEY];
 };
-var booted = false;
+var instance = getGlobalInstance();
+var config = instance.config;
+var history = instance.history;
+var currentTickBatch = instance.currentTickBatch;
+var redundantLabels = instance.redundantLabels;
 var configureBasis = (newConfig) => {
-  config = { ...config, ...newConfig };
-  if (config.debug && !booted) {
+  Object.assign(instance.config, newConfig);
+  if (instance.config.debug && !instance.booted) {
     displayBootLog(WINDOW_SIZE);
-    booted = true;
+    instance.booted = true;
   }
 };
-var history = /* @__PURE__ */ new Map();
-var currentTickBatch = /* @__PURE__ */ new Set();
-var updateLog = [];
-var currentEffectSource = null;
-var tick = 0;
-var isBatching = false;
 var analyzeBasis = () => {
-  if (!config.debug) return;
-  const entries = Array.from(history.entries());
+  if (!instance.config.debug) {
+    instance.redundantLabels.clear();
+    return;
+  }
+  const entries = Array.from(instance.history.entries());
   if (entries.length < 2) return;
+  const newRedundant = /* @__PURE__ */ new Set();
   entries.forEach(([labelA, vecA], i) => {
     entries.slice(i + 1).forEach(([labelB, vecB]) => {
       const sim = calculateCosineSimilarity(vecA, vecB);
       if (sim > SIMILARITY_THRESHOLD) {
-        displayRedundancyAlert(labelA, labelB, sim, history.size);
+        newRedundant.add(labelA);
+        newRedundant.add(labelB);
+        displayRedundancyAlert(labelA, labelB, sim, instance.history.size);
       }
     });
   });
-};
-var printBasisHealthReport = (threshold = 0.5) => {
-  if (!config.debug) {
-    console.warn("[Basis] Cannot generate report. Debug mode is OFF.");
-    return;
-  }
-  displayHealthReport(history, calculateCosineSimilarity, threshold);
-};
-var beginEffectTracking = (label) => {
-  currentEffectSource = label;
-};
-var endEffectTracking = () => {
-  currentEffectSource = null;
-};
-var registerVariable = (label) => {
-  if (!config.debug) return;
-  if (!history.has(label)) {
-    history.set(label, new Array(WINDOW_SIZE).fill(0));
-  }
-};
-var unregisterVariable = (label) => {
-  history.delete(label);
+  instance.redundantLabels.clear();
+  newRedundant.forEach((label) => instance.redundantLabels.add(label));
 };
 var recordUpdate = (label) => {
-  if (!config.debug) return true;
+  if (!instance.config.debug) return true;
   const now = Date.now();
-  updateLog.push({ label, ts: now });
-  updateLog = updateLog.filter((e) => now - e.ts < LOOP_WINDOW_MS);
-  if (updateLog.filter((e) => e.label === label).length > LOOP_THRESHOLD) {
+  instance.updateLog.push({ label, ts: now });
+  instance.updateLog = instance.updateLog.filter((e) => now - e.ts < LOOP_WINDOW_MS);
+  if (instance.updateLog.filter((e) => e.label === label).length > LOOP_THRESHOLD) {
     displayInfiniteLoop(label);
     return false;
   }
-  if (currentEffectSource && currentEffectSource !== label) {
-    displayCausalHint(label, currentEffectSource);
+  if (instance.currentEffectSource && instance.currentEffectSource !== label) {
+    displayCausalHint(label, instance.currentEffectSource);
   }
-  currentTickBatch.add(label);
-  if (!isBatching) {
-    isBatching = true;
+  instance.currentTickBatch.add(label);
+  if (!instance.isBatching) {
+    instance.isBatching = true;
     setTimeout(() => {
-      tick++;
-      history.forEach((vec, l) => {
+      instance.tick++;
+      instance.history.forEach((vec, l) => {
         vec.shift();
-        vec.push(currentTickBatch.has(l) ? 1 : 0);
+        vec.push(instance.currentTickBatch.has(l) ? 1 : 0);
       });
-      currentTickBatch.clear();
-      isBatching = false;
-      if (tick % ANALYSIS_INTERVAL === 0) {
+      instance.currentTickBatch.clear();
+      instance.isBatching = false;
+      if (instance.tick % ANALYSIS_INTERVAL === 0) {
         analyzeBasis();
       }
     }, 20);
   }
   return true;
 };
+var beginEffectTracking = (label) => {
+  if (instance.config.debug) instance.currentEffectSource = label;
+};
+var endEffectTracking = () => {
+  instance.currentEffectSource = null;
+};
+var registerVariable = (label) => {
+  if (!instance.config.debug) return;
+  if (!instance.history.has(label)) {
+    instance.history.set(label, new Array(WINDOW_SIZE).fill(0));
+  }
+};
+var unregisterVariable = (label) => {
+  instance.history.delete(label);
+};
+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 (typeof window !== "undefined") {
   window.printBasisReport = printBasisHealthReport;
 }
 var __testEngine__ = {
-  config,
+  instance,
+  config: instance.config,
+  history: instance.history,
+  currentTickBatch: instance.currentTickBatch,
   configureBasis,
-  history,
-  currentTickBatch,
   registerVariable,
   recordUpdate,
   printBasisHealthReport,
@@ -405,85 +429,223 @@ var __testEngine__ = {
 };
 
 // src/context.tsx
+var import_react2 = require("react");
+
+// src/ui/BasisHUD.tsx
 var import_react = require("react");
+
+// src/ui/config.ts
+var HUD_DIMENSIONS = {
+  WINDOW_SIZE,
+  ROW_HEIGHT: 16,
+  COL_WIDTH: 5,
+  LABEL_WIDTH: 100,
+  PADDING: 10,
+  RADIUS: 1.5
+};
+var HUD_THEME = {
+  bg: "rgba(15, 23, 42, 0.95)",
+  border: "#334155",
+  header: "#8b5cf6",
+  text: "#f1f5f9",
+  textDim: "#94a3b8",
+  success: "#10b981",
+  error: "#ef4444",
+  grid: "#1e293b"
+};
+var getHUDContainerStyle = (isExpanded) => ({
+  position: "fixed",
+  bottom: "20px",
+  right: "20px",
+  backgroundColor: HUD_THEME.bg,
+  border: `1px solid ${HUD_THEME.border}`,
+  borderRadius: "12px",
+  backdropFilter: "blur(8px)",
+  boxShadow: "0 10px 25px -5px rgba(0, 0, 0, 0.3), 0 8px 10px -6px rgba(0, 0, 0, 0.3)",
+  zIndex: 999999,
+  overflow: "hidden",
+  width: isExpanded ? "380px" : "130px",
+  transition: "all 0.3s cubic-bezier(0.4, 0, 0.2, 1)",
+  cursor: "pointer",
+  userSelect: "none",
+  WebkitUserSelect: "none"
+});
+
+// src/ui/BasisHUD.tsx
 var import_jsx_runtime = require("react/jsx-runtime");
-var BasisContext = (0, import_react.createContext)({ debug: false });
+var BasisHUD = () => {
+  const [isExpanded, setIsExpanded] = (0, import_react.useState)(false);
+  const canvasRef = (0, import_react.useRef)(null);
+  (0, import_react.useEffect)(() => {
+    if (!isExpanded) return;
+    let animationFrame;
+    const draw = () => {
+      const canvas = canvasRef.current;
+      if (!canvas) return;
+      const ctx = canvas.getContext("2d");
+      if (!ctx) return;
+      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);
+      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);
+      }
+      ctx.restore();
+      animationFrame = requestAnimationFrame(draw);
+    };
+    draw();
+    return () => 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, {})
+    ] })
+  ] });
+};
+function updateCanvasSize(canvas, w, h, dpr) {
+  const targetW = Math.floor(w * dpr);
+  const targetH = Math.floor(h * dpr);
+  if (canvas.width !== targetW || canvas.height !== targetH) {
+    canvas.width = targetW;
+    canvas.height = targetH;
+    canvas.style.width = `${w}px`;
+    canvas.style.height = `${h}px`;
+  }
+}
+function renderEmptyState(ctx) {
+  ctx.fillStyle = HUD_THEME.textDim;
+  ctx.font = "11px Inter, sans-serif";
+  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 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();
+      } else {
+        ctx.fillRect(x, y, w, h);
+      }
+    });
+    const textX = HUD_DIMENSIONS.WINDOW_SIZE * HUD_DIMENSIONS.COL_WIDTH + HUD_DIMENSIONS.PADDING + 10;
+    ctx.fillStyle = isRedundant ? HUD_THEME.error : HUD_THEME.text;
+    ctx.font = `${isRedundant ? "600" : "400"} 11px Inter, Menlo, monospace`;
+    const cleanName = isRedundant ? `! ${stateName}` : stateName;
+    const truncatedName = cleanName.length > 18 ? cleanName.substring(0, 16) + ".." : cleanName;
+    ctx.fillText(truncatedName, textX, y + 9);
+  });
+}
+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" })
+] });
+
+// src/context.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var BasisContext = (0, import_react2.createContext)({ debug: false });
 var isWeb2 = typeof window !== "undefined" && typeof window.document !== "undefined";
 var BasisProvider = ({ children, debug = true }) => {
-  (0, import_react.useLayoutEffect)(() => {
+  (0, import_react2.useLayoutEffect)(() => {
     configureBasis({ debug });
     if (isWeb2) {
       window._basis_debug = debug;
     }
   }, [debug]);
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(BasisContext.Provider, { value: { debug }, children: [
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(BasisContext.Provider, { value: { debug }, children: [
     children,
-    debug && isWeb2 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { style: {
-      position: "fixed",
-      bottom: 10,
-      right: 10,
-      background: "black",
-      color: "#0f0",
-      padding: "5px 10px",
-      fontSize: "10px",
-      fontFamily: "monospace",
-      border: "1px solid #0f0",
-      zIndex: 99999,
-      borderRadius: "4px",
-      pointerEvents: "none"
-    }, children: "BASIS_ENGINE: ACTIVE" })
+    debug && isWeb2 && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(BasisHUD, {})
   ] });
 };
-var useBasisConfig = () => (0, import_react.useContext)(BasisContext);
+var useBasisConfig = () => (0, import_react2.useContext)(BasisContext);
 
 // src/hooks.ts
-var React2 = __toESM(require("react"));
-var import_react2 = require("react");
-function useState(initialState, label) {
-  const [val, setVal] = (0, import_react2.useState)(initialState);
+var React3 = __toESM(require("react"));
+var import_react3 = require("react");
+function useState2(initialState, label) {
+  const [val, setVal] = (0, import_react3.useState)(initialState);
   const effectiveLabel = label || "anonymous_state";
-  (0, import_react2.useEffect)(() => {
+  (0, import_react3.useEffect)(() => {
     registerVariable(effectiveLabel);
     return () => unregisterVariable(effectiveLabel);
   }, [effectiveLabel]);
-  const setter = (0, import_react2.useCallback)((newValue) => {
+  const setter = (0, import_react3.useCallback)((newValue) => {
     if (recordUpdate(effectiveLabel)) setVal(newValue);
   }, [effectiveLabel, setVal]);
   return [val, setter];
 }
-function useRef(initialValue, _label) {
-  return (0, import_react2.useRef)(initialValue);
+function useRef2(initialValue, _label) {
+  return (0, import_react3.useRef)(initialValue);
 }
 function useReducer(reducer, initialArg, init, label) {
   const effectiveLabel = typeof init === "string" ? init : label || "anonymous_reducer";
   const reactInit = typeof init === "function" ? init : void 0;
-  const [state, dispatch] = (0, import_react2.useReducer)(reducer, initialArg, reactInit);
-  (0, import_react2.useEffect)(() => {
+  const [state, dispatch] = (0, import_react3.useReducer)(reducer, initialArg, reactInit);
+  (0, import_react3.useEffect)(() => {
     registerVariable(effectiveLabel);
     return () => unregisterVariable(effectiveLabel);
   }, [effectiveLabel]);
-  const basisDispatch = (0, import_react2.useCallback)((action) => {
+  const basisDispatch = (0, import_react3.useCallback)((action) => {
     if (recordUpdate(effectiveLabel)) dispatch(action);
   }, [effectiveLabel, dispatch]);
   return [state, basisDispatch];
 }
 function useMemo(factory, deps, label) {
   const effectiveLabel = label || "anonymous_projection";
-  (0, import_react2.useEffect)(() => {
+  (0, import_react3.useEffect)(() => {
     if (config.debug) console.log(`%c [Basis] Valid Projection: "${effectiveLabel}" `, "color: #2ecc71; font-weight: bold;");
   }, [effectiveLabel]);
-  return (0, import_react2.useMemo)(factory, deps || []);
+  return (0, import_react3.useMemo)(factory, deps || []);
 }
 function useCallback(callback, deps, label) {
   const effectiveLabel = label || "anonymous_callback";
-  (0, import_react2.useEffect)(() => {
+  (0, import_react3.useEffect)(() => {
     if (config.debug) console.log(`%c [Basis] Stable Callback: "${effectiveLabel}" `, "color: #2ecc71; font-weight: bold;");
   }, [effectiveLabel]);
-  return (0, import_react2.useCallback)(callback, deps);
+  return (0, import_react3.useCallback)(callback, deps);
 }
 function useEffect2(effect, deps, label) {
   const effectiveLabel = label || "anonymous_effect";
-  (0, import_react2.useEffect)(() => {
+  (0, import_react3.useEffect)(() => {
     beginEffectTracking(effectiveLabel);
     const cleanup = effect();
     endEffectTracking();
@@ -492,7 +654,7 @@ function useEffect2(effect, deps, label) {
 }
 function useLayoutEffect2(effect, deps, label) {
   const effectiveLabel = label || "anonymous_layout_effect";
-  (0, import_react2.useLayoutEffect)(() => {
+  (0, import_react3.useLayoutEffect)(() => {
     beginEffectTracking(effectiveLabel);
     const cleanup = effect();
     endEffectTracking();
@@ -500,7 +662,7 @@ function useLayoutEffect2(effect, deps, label) {
   }, deps);
 }
 function useTransition(_label) {
-  const [isPending, startTransition3] = (0, import_react2.useTransition)();
+  const [isPending, startTransition3] = (0, import_react3.useTransition)();
   const effectiveLabel = _label || "anonymous_transition";
   const basisStartTransition = (callback) => {
     if (config.debug) console.log(`%c [Basis] Transition Started: "${effectiveLabel}" `, "color: #e67e22; font-weight: bold;");
@@ -512,34 +674,34 @@ 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_react2.useDeferredValue)(value, actualInitialValue);
-  (0, import_react2.useEffect)(() => {
+  const deferredValue = (0, import_react3.useDeferredValue)(value, actualInitialValue);
+  (0, import_react3.useEffect)(() => {
     if (config.debug && value !== deferredValue) console.log(`%c [Basis] Value Deferred: "${effectiveLabel}" `, "color: #e67e22; font-weight: bold;");
   }, [value, deferredValue, effectiveLabel]);
   return deferredValue;
 }
 function createContext2(defaultValue, label) {
-  const context = (0, import_react2.createContext)(defaultValue);
+  const context = (0, import_react3.createContext)(defaultValue);
   if (label) context._basis_label = label;
   return context;
 }
-var useContext2 = import_react2.useContext;
-var useId2 = (label) => React2.useId();
-var useDebugValue2 = React2.useDebugValue;
-var useImperativeHandle2 = React2.useImperativeHandle;
-var useInsertionEffect2 = React2.useInsertionEffect;
-var useSyncExternalStore = import_react2.useSyncExternalStore;
+var useContext2 = import_react3.useContext;
+var useId2 = (label) => React3.useId();
+var useDebugValue2 = React3.useDebugValue;
+var useImperativeHandle2 = React3.useImperativeHandle;
+var useInsertionEffect2 = React3.useInsertionEffect;
+var useSyncExternalStore = import_react3.useSyncExternalStore;
 function use(usable) {
-  return (0, import_react2.use)(usable);
+  return (0, import_react3.use)(usable);
 }
 function useOptimistic2(passthrough, reducer, label) {
   const effectiveLabel = label || "anonymous_optimistic";
-  (0, import_react2.useEffect)(() => {
+  (0, import_react3.useEffect)(() => {
     registerVariable(effectiveLabel);
     return () => unregisterVariable(effectiveLabel);
   }, [effectiveLabel]);
-  const [state, reactAddOptimistic] = React2.useOptimistic(passthrough, reducer);
-  const addOptimistic = (0, import_react2.useCallback)((payload) => {
+  const [state, reactAddOptimistic] = React3.useOptimistic(passthrough, reducer);
+  const addOptimistic = (0, import_react3.useCallback)((payload) => {
     if (recordUpdate(effectiveLabel)) {
       reactAddOptimistic(payload);
     }
@@ -550,16 +712,16 @@ 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] = React2.useActionState(
+  const [state, reactDispatch, isPending] = React3.useActionState(
     action,
     initialState,
     actualPermalink
   );
-  (0, import_react2.useEffect)(() => {
+  (0, import_react3.useEffect)(() => {
     registerVariable(effectiveLabel);
     return () => unregisterVariable(effectiveLabel);
   }, [effectiveLabel]);
-  const basisDispatch = (0, import_react2.useCallback)((payload) => {
+  const basisDispatch = (0, import_react3.useCallback)((payload) => {
     if (recordUpdate(effectiveLabel)) {
       reactDispatch(payload);
     }
@@ -568,6 +730,30 @@ function useActionState2(action, initialState, permalink, label) {
 }
 var __test__ = { registerVariable, unregisterVariable, recordUpdate, beginEffectTracking, endEffectTracking, history, currentTickBatch };
 
+// src/vite-plugin.ts
+function basis() {
+  return {
+    name: "vite-plugin-react-state-basis",
+    enforce: "pre",
+    resolveId(source, importer) {
+      if (source === "react" || source === "react-dom" || source === "react-dom/client") {
+        const isLibraryCore = importer && ((importer.includes("react-state-basis/src") || importer.includes("react-state-basis/dist")) && !importer.includes("react-state-basis/example"));
+        const isYalc = importer && importer.includes(".yalc");
+        if (isLibraryCore || isYalc) {
+          return null;
+        }
+        const mapping = {
+          "react": "react-state-basis",
+          "react-dom": "react-state-basis",
+          "react-dom/client": "react-state-basis/client"
+        };
+        return this.resolve(mapping[source], importer, { skipSelf: true });
+      }
+      return null;
+    }
+  };
+}
+
 // src/index.ts
 var Children2 = ReactNamespace.Children;
 var Component2 = ReactNamespace.Component;
@@ -577,6 +763,7 @@ var PureComponent2 = ReactNamespace.PureComponent;
 var StrictMode2 = ReactNamespace.StrictMode;
 var Suspense2 = ReactNamespace.Suspense;
 var cloneElement2 = ReactNamespace.cloneElement;
+var createElement2 = ReactNamespace.createElement;
 var createRef2 = ReactNamespace.createRef;
 var forwardRef2 = ReactNamespace.forwardRef;
 var isValidElement2 = ReactNamespace.isValidElement;
@@ -601,11 +788,13 @@ var index_default = ReactNamespace;
   Suspense,
   __testEngine__,
   __test__,
+  basis,
   beginEffectTracking,
   cloneElement,
   config,
   configureBasis,
   createContext,
+  createElement,
   createPortal,
   createRef,
   currentTickBatch,