react-state-basis 0.2.4 → 0.3.0

package/README.md

@@ -4,240 +4,188 @@
 
 <div align="center">
 
-# 📐 REACT-STATE-BASIS
-### **Behavioral State Analysis for React**
+# 📐 react-state-basis
+### Real-time architectural auditor for React
 
 [![npm version](https://img.shields.io/npm/v/react-state-basis.svg?style=flat-square)](https://www.npmjs.com/package/react-state-basis)
 [![GitHub stars](https://img.shields.io/github/stars/liovic/react-state-basis.svg?style=flat-square)](https://github.com/liovic/react-state-basis/stargazers)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
 
+**Audit your React architecture in development — without changing a single line of component code.**
+
 </div>
 
 ---
 
-### The Core Concept
-In Linear Algebra, a **Basis** is a set of linearly independent vectors that span a space. **Basis** treats your React application as a dynamic system where every state variable is a signal over time.
+## What is react-state-basis?
 
-If two states always update in lockstep, they are **linearly dependent** (redundant). Basis detects these "Dimension Collapses" at runtime and suggests refactoring to derived state (`useMemo`).
+**react-state-basis** is a development-time React utility that analyzes how state behaves *over time* and surfaces architectural issues that are difficult to detect with snapshot-based tools.
 
----
+It focuses on **runtime behavior**, not values — helping you identify redundant state, hidden coupling, unstable update patterns, and effect-driven render loops while your app is running.
 
-## How it Works: The Vectorization Engine
+> This is an architectural diagnostic tool.  
+> It is not a state manager and not a replacement for React DevTools.
 
-Basis doesn't care about the *values* of your state. It monitors the **topology of transitions**.
+---
 
-### 1. The System Tick
-The engine groups all state updates occurring within a **20ms window** (aligned with the 60FPS frame budget) into a single **System Tick**.
+## What problems does it catch?
 
-### 2. State-to-Vector Mapping
-Every hook is mapped to a vector $v$ in a 50-dimensional space $\mathbb{R}^{50}$ representing a sliding window of the last 50 ticks:
-*   `1` = State transition occurred during this tick.
-*   `0` = State remained stagnant.
+In real React applications, many architectural issues don’t show up as errors:
 
-**Example of two redundant (collinear) states:**
-```text
-State A: [0, 1, 0, 0, 1, 0, 1, 0, 1, 0]  <-- vA
-State B: [0, 1, 0, 0, 1, 0, 1, 0, 1, 0]  <-- vB
-Result:  Cosine Similarity = 1.00 (REDUNDANT)
-```
+- Multiple state variables encode the same information
+- Effects create subtle feedback loops
+- Components re-render twice even though nothing “looks wrong”
+- State updates oscillate under load or user interaction
 
-Basis detects synchronization, not identity. Even if the data inside the hooks is different, if they always change at the same time, they are collinear in the state-space."
+These issues emerge **over time**, across renders.
 
-### 3. Real-time Auditing
-Every 5 ticks, Basis calculates the **Cosine Similarity** between all active state vectors. If similarity exceeds **0.88**, an architectural alert is triggered in your console with a suggested fix.
+react-state-basis observes state updates as a timeline and flags structural patterns that indicate architectural debt.
 
 ---
 
-## Ghost Mode: Zero-Overhead Production
-Basis is a **development-only** infrastructure. Using **Conditional Exports**, it automatically swaps itself for a "Zero-Op" version in production:
-*   **Development:** Full Linear Algebra engine and auditor active.
-*   **Production:** Exports raw React hooks directly. **Zero bundle bloat. Zero performance penalty.**
+## Key capabilities
 
----
+- **Temporal State Matrix (HUD)**  
+  A real-time visualization of state activity. If rows pulse together, the architecture is coupled or redundant.
 
-## Quick Start
+- **Redundant state detection**  
+  Identifies state variables that move together and suggests derived alternatives (e.g. `useMemo`).
 
-### 1. Install
-```bash
-npm i react-state-basis
-```
+- **Causality tracing**  
+  Tracks `useEffect → setState` chains to expose hidden double-render cycles.
 
-### 2. Initialize
-```tsx
-import { BasisProvider } from 'react-state-basis';
+- **Stability circuit breaker**  
+  Detects recursive update patterns and halts them before the browser tab locks up.
 
-export default function Root() {
-  return (
-    <BasisProvider debug={true}> {/* Set debug={false} for total silence in dev */}
-       <App />
-    </BasisProvider>
-  );
-}
-```
-**Props:**
-*   `debug (boolean)`: 
-    *   `true` (Default): Enables the real-time diagnostic dashboard, visual system status badge (Web only), and detailed console auditing (including the Circuit Breaker).
-    *   `false`: Completely deactivates the Basis engine. No background analysis, no memory consumption, and no logging. The "Circuit Breaker" is also disabled in this mode to allow for a zero-overhead, raw React experience in development.
+- **Universal support**  
+  Works with **React Web**, **React Native**, and **Expo**.
+
+---
+
+## High-Level Insights
 
-### 3. Drop-in Replacement
-Replace your standard React hook imports with `react-state-basis`. This allows the engine to instrument your state updates without changing your component logic.
+### System Health Report
+For a bird's-eye view of your entire application's state-space, call the global reporter in your browser console or in code :
 
-**Standard Named Imports (Recommended):**
 ```tsx
-// ❌ Change this:
-// import { useState, useEffect } from 'react';
-
-// ✅ To this:
-import { 
-  useState, 
-  useEffect, 
-  useMemo, 
-  useCallback,
-  useContext, 
-  useRef, 
-  useLayoutEffect, 
-  useId, 
-  useSyncExternalStore,
-  useDeferredValue, 
-  useTransition
-} from 'react-state-basis';
-
-function MyComponent() {
-  const [data, setData] = useState([]); // Automatically vectorized and tracked
-}
+window.printBasisReport();
 ```
 
-**Namespace Imports:**
-Basis also supports namespace imports if you prefer to keep your hooks grouped:
-```tsx
-import * as Basis from 'react-state-basis';
+This generates a correlation matrix and calculates your Basis Efficiency Score in real-time.
 
-function MyComponent() {
-  const [count, setCount] = Basis.useState(0); // Also tracked automatically
-}
-```
 ---
 
-## Automated Diagnostics (Babel)
-While Basis works out of the box, hooks will be labeled as `anonymous_state` by default. To get the rich diagnostics seen in the demos (with automatic **filenames** and **variable names**), we highly recommend using our Babel plugin.
+## How it works (high level)
 
-### Vite Integration
-Add Basis to your `vite.config.ts`. It will automatically instrument your hooks during build time:
+During development, react-state-basis observes state updates and compares how they evolve over short time windows.
 
-```typescript
-// vite.config.ts
-import { defineConfig } from 'vite'
-import react from '@vitejs/plugin-react'
+Instead of asking:
+> “What is the state right now?”
+
+It asks:
+> “How does this state behave relative to other states over time?”
+
+This allows the engine to detect redundancy, coupling, and instability that static analysis and snapshot tools can’t see.
+
+Implementation details are intentionally hidden from the public API.  
+The tool is designed to be **used**, not configured.
+
+👉 For a deeper dive into the internal model and formal specification, see the [project Wiki](https://github.com/liovic/react-state-basis/wiki).
+
+---
+
+## See it in action
+
+The optional HUD visualizes your application’s state “heartbeat” using the Canvas API.
+
+Below, Basis detects redundant state, flags effect-driven render loops, and activates the stability circuit breaker in real time.
+
+<p align="center">
+  <img src="./assets/react-state-basis.gif" width="800" alt="React State Basis Demo" />
+</p>
+
+---
+
+## Zero-friction setup (Vite)
+
+As of **v0.3.0**, react-state-basis runs transparently in development.
+
+You do **not** need to modify component imports or wrap individual hooks.
+
+### 1. Install
+```bash
+npm i react-state-basis
+```
+
+### 2. Configure Vite
+
+Add the `basis` plugin to your `vite.config.ts`.
+It instruments React automatically during development.
+
+```tsx
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import { basis } from 'react-state-basis/vite';
 
 export default defineConfig({
   plugins: [
     react({
-      babel: {
-        // Automatically labels useState, useMemo, etc. 
-        plugins: [['react-state-basis/plugin']]
-      }
-    })
+      babel: { plugins: [['react-state-basis/plugin']] }
+    }),
+    basis() // No import changes required
   ]
-})
+});
 ```
 
-### Manual Labeling (Alternative)
-If you prefer not to use Babel, you can manually label any hook by passing a string as the last argument:
+### 3. Initialize the provider
+
+Wrap your root component with `BasisProvider` to enable the engine and HUD.
 
 ```tsx
-const [count, setCount] = useState(0, "MyComponent -> count");
+import { BasisProvider } from 'react-state-basis';
+
+root.render(
+  <BasisProvider debug={true}>
+    <App />
+  </BasisProvider>
+);
 ```
 
----
+### Ignoring files
 
-## High-Level Insights
+If certain files are intentionally noisy (e.g. animation loops or low-level adapters), you can exclude them from auditing.
 
-### System Health Report
-For a bird's-eye view of your entire application's state-space, call the global reporter in your browser console:
+Add this comment at the top of the file:
 
-```javascript
-window.printBasisReport();
+```tsx
+// @basis-ignore
 ```
-This generates a correlation matrix and calculates your **Basis Efficiency Score** in real-time.
-
----
-### React Native & Expo
 
-Basis automatically detects the environment. In mobile environments, it switches to **Headless Mode**-disabling the web badge and formatting all diagnostics for the Metro terminal.
+That file will be skipped by both the Babel plugin and the engine.
 
 ---
 
-## Basis vs Existing Tools
+## Basis vs existing tools
 
 | Feature | React DevTools | Why Did You Render | Basis 📐 |
 | :--- | :---: | :---: | :---: |
 | **Analyzes Values** | ✅ | ✅ | ❌ (Value-agnostic) |
 | **Tracks Timing/Ticks** | ❌ | ❌ | ✅ |
 | **Detects Redundancy** | ❌ | ❌ | ✅ (Linear Dependence) |
-| **Circuit Breaker** | ❌ | ❌ | ✅ (Halts petlje) |
+| **Circuit Breaker** | ❌ | ❌ | ✅ (Halts Loops) |
 | **Prod. Overhead** | Low | Medium | **Zero** (Ghost Mode) |
 
 ---
 
-## Key Capabilities
-
-### 1. Temporal State Matrix (Real-time HUD)
-The "Heartbeat" of your application. Basis injects a high-performance, Zero-Overhead HUD that visualizes your state transitions as a temporal heatmap.
-*   **Signal Visualization:** Watch every `useState`, `useReducer`, and `useEffect` update pulse in real-time.
-*   **Visual Pattern Recognition:** Identify architectural flaws simply by looking at the rhythm of the matrix. If multiple rows pulse together, they likely belong together.
-*   **Zero-Overhead:** Powered by Canvas API and `requestAnimationFrame` polling to ensure your application's performance remains untouched during development.
-
-### 2. Redundant State Detection (Dimension Collapse)
-Basis monitors transition vectors to identify "Dimension Collapses" in your state space.
-*   **Collinearity Alerts:** When multiple states (like `isLoading`, `isSuccess`, `hasData`) update in lockstep, Basis flags them as mathematically redundant.
-*   **Visual Debugging:** Redundant states are automatically highlighted in **Red** within the HUD, providing immediate visual proof that you are storing the same information in multiple places.
-
-### 3. Causal Detective (Double Render Tracker)
-Identify "Double Render Cycles" by tracking the causality chain from effects to state setters.
-*   **Sequence Tracking:** Detects when a state update is a lagging echo of a `useEffect` or `useLayoutEffect`.
-*   **Refactor Insights:** Provides direct console hints to move from manual synchronization to pure, deterministic mathematical projections using `useMemo`.
-
-### 4. Stability Circuit Breaker
-A real-time safety monitor for your execution thread.
-*   **Oscillation Detection:** If high-frequency state oscillation is detected (e.g., a recursive effect loop), Basis forcefully halts the update chain.
-*   **Tab Protection:** Stops the browser thread from locking up, allowing you to catch and fix infinite loops without having to force-quit your browser tab.
-
-### 5. System Health & Efficiency Rank
-Basis performs a global audit of your state space to calculate its **Mathematical Rank**—the actual number of independent information dimensions.
-*   **Efficiency Score:** A real-time KPI for your architecture. A 100% score means every state variable is a unique, non-redundant source of truth.
-*   **Architecture Audit:** Use the global Health Report (`window.printBasisReport()`) to generate a correlation matrix of your entire application state.
-
----
-
-### See it in Action
-<p align="center">
-  <img src="./assets/react-state-basis.gif" width="800" alt="React State Basis Demo" />
-</p>
+## Case study: shadcn-admin audit
 
----
-
-## 🔍 Case Study: Auditing High-Integrity React Architecture
-
-To test the engine against professional standards, Basis was used to audit the [shadcn-admin](https://github.com/satnaing/shadcn-admin) template-a high-quality, production-ready dashboard implementation.
+We ran react-state-basis on a production-ready dashboard to validate its detection engine.
+- Result: 12 / 12 independent state dimensions
+- Insight: Identified a subtle double-render bottleneck in useIsMobile that static tooling missed
 
-<p align="center">
-  <img src="./assets/shadcn-admin.png" width="800" alt="Basis Real World Audit" />
-</p>
 
-### Audit Results: 100% Basis Efficiency
-The project demonstrated exceptional architectural integrity. The engine verified a **100% Efficiency**, confirming that all state variables are linearly independent. This proves that the codebase follows a "Single Source of Truth" philosophy with zero redundant state.
+<p align="center"> <img src="./assets/shadcn-admin.png" width="800" alt="Real World Audit" /> </p>
 
-### Subtle Optimization Caught
-Despite the perfect efficiency score, the **Causality Engine** identified a hidden performance bottleneck:
-*   **Double Render Detection:** Basis flagged a "Double Render Cycle" in the `use-mobile.tsx` hook. It detected that the `isMobile` state was being manually synchronized within a `useEffect`, triggering a secondary render pass. 
-*   **Refactor Insight:** While the logic was correct, Basis revealed the cost of the implementation - a redundant render cycle that occurs before every layout shift.
-
-### Stability Confirmation
-The auditor provided formal verification for the rest of the suite:
-*   **Stable Callbacks:** Verified that `Sidebar` methods were correctly memoized, ensuring child components are protected from unnecessary updates.
-*   **Valid Projections:** Confirmed that complex table logic (pagination and filtering) was implemented as pure mathematical projections, rather than state-syncing.
-
-Math reveals exactly what standard code reviews often miss: the **temporal topology** of your application.
 ---
 
 ## Roadmap
@@ -251,6 +199,8 @@ Math reveals exactly what standard code reviews often miss: the **temporal topol
 - [x] **95% Test Coverage:** Verified mathematical engine.
 
 #### **v0.3.0 - Global State & Ecosystem**
+- [x] **Zero-Config Vite Plugin:** Automatic aliasing for `react` and `react-dom`.
+- [x] **Babel Auto-Instrumentation:** Automatic hook labeling without code changes.
 - [ ] **Zustand Middleware:** Auditing global-to-local state redundancy.
 - [ ] **Redux Integration:** Connecting the causal engine to Redux dispatch cycles.
 - [ ] **CLI Initializer:** `rsb-init` to automatically configure Babel/Vite plugins.
@@ -262,6 +212,5 @@ Math reveals exactly what standard code reviews often miss: the **temporal topol
 
 ---
 
-<div align="center">
-Developed by LP | For engineers who treat software as applied mathematics. 🚀
-</div>
+
+<div align="center"> Developed by LP • A React utility for engineers who care about architectural correctness </div>

package/dist/chunk-GEHMQPV4.mjs

@@ -0,0 +1,28 @@
+// 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;
+    }
+  };
+}
+
+export {
+  basis
+};
+//# sourceMappingURL=chunk-GEHMQPV4.mjs.map

package/dist/chunk-GEHMQPV4.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/vite-plugin.ts"],"sourcesContent":["// src/vite-plugin.ts\n\nimport type { Plugin } from 'vite';\n\nexport function basis(): Plugin {\n  return {\n    name: 'vite-plugin-react-state-basis',\n    enforce: 'pre',\n\n    resolveId(source, importer) {\n      if (source === 'react' || source === 'react-dom' || source === 'react-dom/client') {\n        \n        const isLibraryCore = importer && (\n          (importer.includes('react-state-basis/src') || importer.includes('react-state-basis/dist')) &&\n          !importer.includes('react-state-basis/example')\n        );\n\n        const isYalc = importer && importer.includes('.yalc');\n\n        if (isLibraryCore || isYalc) {\n          return null;\n        }\n\n        const mapping: Record<string, string> = {\n          'react': 'react-state-basis',\n          'react-dom': 'react-state-basis',\n          'react-dom/client': 'react-state-basis/client'\n        };\n\n        return this.resolve(mapping[source], importer, { skipSelf: true });\n      }\n      return null;\n    }\n  };\n}"],"mappings":";AAIO,SAAS,QAAgB;AAC9B,SAAO;AAAA,IACL,MAAM;AAAA,IACN,SAAS;AAAA,IAET,UAAU,QAAQ,UAAU;AAC1B,UAAI,WAAW,WAAW,WAAW,eAAe,WAAW,oBAAoB;AAEjF,cAAM,gBAAgB,cACnB,SAAS,SAAS,uBAAuB,KAAK,SAAS,SAAS,wBAAwB,MACzF,CAAC,SAAS,SAAS,2BAA2B;AAGhD,cAAM,SAAS,YAAY,SAAS,SAAS,OAAO;AAEpD,YAAI,iBAAiB,QAAQ;AAC3B,iBAAO;AAAA,QACT;AAEA,cAAM,UAAkC;AAAA,UACtC,SAAS;AAAA,UACT,aAAa;AAAA,UACb,oBAAoB;AAAA,QACtB;AAEA,eAAO,KAAK,QAAQ,QAAQ,MAAM,GAAG,UAAU,EAAE,UAAU,KAAK,CAAC;AAAA,MACnE;AACA,aAAO;AAAA,IACT;AAAA,EACF;AACF;","names":[]}

package/dist/client.d.mts

@@ -0,0 +1,7 @@
+import * as ReactDOMClient from 'react-dom/client';
+export { ReactDOMClient as default };
+
+declare const createRoot: any;
+declare const hydrateRoot: any;
+
+export { createRoot, hydrateRoot };

package/dist/client.d.ts

@@ -0,0 +1,7 @@
+import * as ReactDOMClient from 'react-dom/client';
+export { ReactDOMClient as default };
+
+declare const createRoot: any;
+declare const hydrateRoot: any;
+
+export { createRoot, hydrateRoot };

package/dist/client.js

@@ -0,0 +1,47 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client.ts
+var client_exports = {};
+__export(client_exports, {
+  createRoot: () => createRoot2,
+  default: () => client_default,
+  hydrateRoot: () => hydrateRoot2
+});
+module.exports = __toCommonJS(client_exports);
+var ReactDOMClient = __toESM(require("react-dom/client"));
+var createRoot2 = ReactDOMClient.createRoot;
+var hydrateRoot2 = ReactDOMClient.hydrateRoot;
+var client_default = ReactDOMClient;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRoot,
+  hydrateRoot
+});
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/client.ts"],"sourcesContent":["// src/client.ts\n\nimport * as ReactDOMClient from 'react-dom/client';\n\nexport const createRoot = (ReactDOMClient as any).createRoot;\nexport const hydrateRoot = (ReactDOMClient as any).hydrateRoot;\n\nexport default ReactDOMClient;"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA,oBAAAA;AAAA,EAAA;AAAA,qBAAAC;AAAA;AAAA;AAEA,qBAAgC;AAEzB,IAAMD,cAAqC;AAC3C,IAAMC,eAAsC;AAEnD,IAAO,iBAAQ;","names":["createRoot","hydrateRoot"]}

package/dist/client.mjs

@@ -0,0 +1,11 @@
+// src/client.ts
+import * as ReactDOMClient from "react-dom/client";
+var createRoot2 = ReactDOMClient.createRoot;
+var hydrateRoot2 = ReactDOMClient.hydrateRoot;
+var client_default = ReactDOMClient;
+export {
+  createRoot2 as createRoot,
+  client_default as default,
+  hydrateRoot2 as hydrateRoot
+};
+//# sourceMappingURL=client.mjs.map

package/dist/client.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/client.ts"],"sourcesContent":["// src/client.ts\n\nimport * as ReactDOMClient from 'react-dom/client';\n\nexport const createRoot = (ReactDOMClient as any).createRoot;\nexport const hydrateRoot = (ReactDOMClient as any).hydrateRoot;\n\nexport default ReactDOMClient;"],"mappings":";AAEA,YAAY,oBAAoB;AAEzB,IAAMA,cAAqC;AAC3C,IAAMC,eAAsC;AAEnD,IAAO,iBAAQ;","names":["createRoot","hydrateRoot"]}

package/dist/index.d.mts

@@ -3,25 +3,49 @@ import React__default, { ReactNode } from 'react';
 export { React };
 export { React as default };
 export { AnchorHTMLAttributes, Attributes, ButtonHTMLAttributes, CSSProperties, ChangeEvent, ComponentProps, ComponentPropsWithRef, ComponentPropsWithoutRef, ComponentType, DependencyList, DetailedHTMLProps, Dispatch, DragEvent, EffectCallback, ElementType, FC, FocusEvent, FormEvent, HTMLAttributes, HTMLProps, InputHTMLAttributes, JSX, Key, KeyboardEvent, MouseEvent, MutableRefObject, PointerEvent, PropsWithChildren, ReactElement, ReactNode, ReactPortal, Reducer, Ref, RefObject, SVGProps, SetStateAction, TouchEvent } from 'react';
+export { basis } from './vite-plugin.mjs';
+import 'vite';
 
-interface BasisConfig {
-    debug: boolean;
+interface BasisEngineState {
+    config: {
+        debug: boolean;
+    };
+    history: Map<string, number[]>;
+    currentTickBatch: Set<string>;
+    redundantLabels: Set<string>;
+    booted: boolean;
+    updateLog: {
+        label: string;
+        ts: number;
+    }[];
+    tick: number;
+    isBatching: boolean;
+    currentEffectSource: string | null;
 }
-declare let config: BasisConfig;
-declare const configureBasis: (newConfig: Partial<BasisConfig>) => void;
+declare const config: {
+    debug: boolean;
+};
 declare const history: Map<string, number[]>;
 declare const currentTickBatch: Set<string>;
-declare const printBasisHealthReport: (threshold?: number) => void;
+declare const configureBasis: (newConfig: Partial<{
+    debug: boolean;
+}>) => void;
+declare const recordUpdate: (label: string) => boolean;
 declare const beginEffectTracking: (label: string) => void;
 declare const endEffectTracking: () => void;
 declare const registerVariable: (label: string) => void;
 declare const unregisterVariable: (label: string) => void;
-declare const recordUpdate: (label: string) => boolean;
+declare const printBasisHealthReport: (threshold?: number) => void;
 declare const __testEngine__: {
-    config: BasisConfig;
-    configureBasis: (newConfig: Partial<BasisConfig>) => void;
+    instance: BasisEngineState;
+    config: {
+        debug: boolean;
+    };
     history: Map<string, number[]>;
     currentTickBatch: Set<string>;
+    configureBasis: (newConfig: Partial<{
+        debug: boolean;
+    }>) => void;
     registerVariable: (label: string) => void;
     recordUpdate: (label: string) => boolean;
     printBasisHealthReport: (threshold?: number) => void;
@@ -87,6 +111,7 @@ declare const StrictMode: React.ExoticComponent<{
 }>;
 declare const Suspense: React.ExoticComponent<React.SuspenseProps>;
 declare const cloneElement: typeof React.cloneElement;
+declare const createElement: typeof React.createElement;
 declare const createRef: typeof React.createRef;
 declare const forwardRef: typeof React.forwardRef;
 declare const isValidElement: typeof React.isValidElement;
@@ -97,4 +122,4 @@ declare const version: string;
 declare const createPortal: any;
 declare const flushSync: any;
 
-export { BasisProvider, Children, Component, Fragment, Profiler, PureComponent, StrictMode, Suspense, __testEngine__, __test__, beginEffectTracking, cloneElement, config, configureBasis, createContext, createPortal, createRef, currentTickBatch, endEffectTracking, flushSync, forwardRef, history, isValidElement, lazy, memo, printBasisHealthReport, recordUpdate, registerVariable, startTransition, unregisterVariable, use, useActionState, useBasisConfig, useCallback, useContext, useDebugValue, useDeferredValue, useEffect, useId, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useOptimistic, useReducer, useRef, useState, useSyncExternalStore, useTransition, version };
+export { BasisProvider, Children, Component, Fragment, Profiler, PureComponent, StrictMode, Suspense, __testEngine__, __test__, beginEffectTracking, cloneElement, config, configureBasis, createContext, createElement, createPortal, createRef, currentTickBatch, endEffectTracking, flushSync, forwardRef, history, isValidElement, lazy, memo, printBasisHealthReport, recordUpdate, registerVariable, startTransition, unregisterVariable, use, useActionState, useBasisConfig, useCallback, useContext, useDebugValue, useDeferredValue, useEffect, useId, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useOptimistic, useReducer, useRef, useState, useSyncExternalStore, useTransition, version };

package/dist/index.d.ts

@@ -3,25 +3,49 @@ import React__default, { ReactNode } from 'react';
 export { React };
 export { React as default };
 export { AnchorHTMLAttributes, Attributes, ButtonHTMLAttributes, CSSProperties, ChangeEvent, ComponentProps, ComponentPropsWithRef, ComponentPropsWithoutRef, ComponentType, DependencyList, DetailedHTMLProps, Dispatch, DragEvent, EffectCallback, ElementType, FC, FocusEvent, FormEvent, HTMLAttributes, HTMLProps, InputHTMLAttributes, JSX, Key, KeyboardEvent, MouseEvent, MutableRefObject, PointerEvent, PropsWithChildren, ReactElement, ReactNode, ReactPortal, Reducer, Ref, RefObject, SVGProps, SetStateAction, TouchEvent } from 'react';
+export { basis } from './vite-plugin.js';
+import 'vite';
 
-interface BasisConfig {
-    debug: boolean;
+interface BasisEngineState {
+    config: {
+        debug: boolean;
+    };
+    history: Map<string, number[]>;
+    currentTickBatch: Set<string>;
+    redundantLabels: Set<string>;
+    booted: boolean;
+    updateLog: {
+        label: string;
+        ts: number;
+    }[];
+    tick: number;
+    isBatching: boolean;
+    currentEffectSource: string | null;
 }
-declare let config: BasisConfig;
-declare const configureBasis: (newConfig: Partial<BasisConfig>) => void;
+declare const config: {
+    debug: boolean;
+};
 declare const history: Map<string, number[]>;
 declare const currentTickBatch: Set<string>;
-declare const printBasisHealthReport: (threshold?: number) => void;
+declare const configureBasis: (newConfig: Partial<{
+    debug: boolean;
+}>) => void;
+declare const recordUpdate: (label: string) => boolean;
 declare const beginEffectTracking: (label: string) => void;
 declare const endEffectTracking: () => void;
 declare const registerVariable: (label: string) => void;
 declare const unregisterVariable: (label: string) => void;
-declare const recordUpdate: (label: string) => boolean;
+declare const printBasisHealthReport: (threshold?: number) => void;
 declare const __testEngine__: {
-    config: BasisConfig;
-    configureBasis: (newConfig: Partial<BasisConfig>) => void;
+    instance: BasisEngineState;
+    config: {
+        debug: boolean;
+    };
     history: Map<string, number[]>;
     currentTickBatch: Set<string>;
+    configureBasis: (newConfig: Partial<{
+        debug: boolean;
+    }>) => void;
     registerVariable: (label: string) => void;
     recordUpdate: (label: string) => boolean;
     printBasisHealthReport: (threshold?: number) => void;
@@ -87,6 +111,7 @@ declare const StrictMode: React.ExoticComponent<{
 }>;
 declare const Suspense: React.ExoticComponent<React.SuspenseProps>;
 declare const cloneElement: typeof React.cloneElement;
+declare const createElement: typeof React.createElement;
 declare const createRef: typeof React.createRef;
 declare const forwardRef: typeof React.forwardRef;
 declare const isValidElement: typeof React.isValidElement;
@@ -97,4 +122,4 @@ declare const version: string;
 declare const createPortal: any;
 declare const flushSync: any;
 
-export { BasisProvider, Children, Component, Fragment, Profiler, PureComponent, StrictMode, Suspense, __testEngine__, __test__, beginEffectTracking, cloneElement, config, configureBasis, createContext, createPortal, createRef, currentTickBatch, endEffectTracking, flushSync, forwardRef, history, isValidElement, lazy, memo, printBasisHealthReport, recordUpdate, registerVariable, startTransition, unregisterVariable, use, useActionState, useBasisConfig, useCallback, useContext, useDebugValue, useDeferredValue, useEffect, useId, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useOptimistic, useReducer, useRef, useState, useSyncExternalStore, useTransition, version };
+export { BasisProvider, Children, Component, Fragment, Profiler, PureComponent, StrictMode, Suspense, __testEngine__, __test__, beginEffectTracking, cloneElement, config, configureBasis, createContext, createElement, createPortal, createRef, currentTickBatch, endEffectTracking, flushSync, forwardRef, history, isValidElement, lazy, memo, printBasisHealthReport, recordUpdate, registerVariable, startTransition, unregisterVariable, use, useActionState, useBasisConfig, useCallback, useContext, useDebugValue, useDeferredValue, useEffect, useId, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useOptimistic, useReducer, useRef, useState, useSyncExternalStore, useTransition, version };