@zakkster/lite-signal 1.1.1 → 1.1.3

package/README.md

@@ -90,6 +90,7 @@ No microtask between `B` and `I`. No promise, no `queueMicrotask`. Just call sta
 - **`dispose(api)`** — universal disposal for signals, computeds, and effect handles. Cross-registry calls are silent no-ops.
 - **`batch(fn)`** — defer effect flush until the outermost batch closes.
 - **`untrack(fn)`** — read without subscribing.
+- **`isTracking()`** — `true` iff a read right now would subscribe (for lazy-allocation wrappers).
 - **`onCleanup(fn)`** — register teardown for the current computation. Works in effects *and* computeds.
 - **`createRegistry(config)`** — isolated pool for tests, plugins, sandboxing.
 - **`stats()`** — pool occupancy snapshot. Used by the demo and easy to wire into perf overlays.
@@ -273,6 +274,28 @@ const value = untrack(() => s());  // read without subscribing
 
 Useful inside computeds/effects when you need a current value but don't want it as a dependency.
 
+### isTracking
+
+```ts
+function makeLazyField(initial) {
+  let s = null, value = initial;
+  return {
+    get() {
+      if (isTracking()) {
+        if (s === null) s = signal(value);   // allocate only when subscribed
+        return s();
+      }
+      return value;
+    },
+    set(v) { value = v; if (s !== null) s.set(v); }
+  };
+}
+```
+
+Returns `true` iff a read right now would record a dependency on the current registry — an observer body is on the stack AND tracking is enabled. Mirrors the engine's own read-trap check (both flags), so it correctly returns `false` inside `untrack`, inside `subscribe` callbacks, inside `onCleanup` bodies, inside `watch` / `when` callbacks, and outside any observer.
+
+For wrapper libraries (lite-store, lite-query, lite-form) gating lazy allocation on the read path. Per-registry — call `registry.isTracking()` if your signals live in a non-default registry.
+
 ### onCleanup
 
 ```ts
@@ -476,7 +499,7 @@ The "0 per fire" property for `watch` is deliberate engineering — the inner `u
 
 ### Tree-shaking
 
-All three primitives live in a separate module (`src/watch.js`) and are re-exported from the main entry. If your bundle doesn't import them, they won't appear in the output — modern ESM tree-shaking (Vite, Rollup, esbuild) handles this reliably.
+All three primitives live in a separate module (`Watch.js`) and are re-exported from the main entry (which binds them to its own `effect`/`untrack`, so there is exactly one engine instance). If your bundle doesn't import them, they won't appear in the output — modern ESM tree-shaking (Vite, Rollup, esbuild) handles this reliably.
 
 ---
 
@@ -537,7 +560,7 @@ Three tiers, all reproducible.
 
 ### Tier 1 — Behavior (unit tests, fast)
 
-`npm test` runs the suite in `test/`. 131 tests across 43 suites covering:
+`npm test` runs the suite in `test/`, covering:
 
 - **`01-core.test.mjs`** — signal/computed/effect basics, equality semantics, NaN/±0, subscribe/peek/update, untrack, batch, cleanup ordering, first-run error recovery, nested object reference-identity gotchas.
 - **`02-topology.test.mjs`** — diamond glitch-freedom, 256-deep and 1024-deep computed chains, wide fan-out (1000 effects from one signal), dynamic dependency switching, conditional fan-out, nested effects, cycle detection (`CycleError`).
@@ -547,6 +570,7 @@ Three tiers, all reproducible.
 - **`07-dispose.test.mjs`** — unified `dispose(api)` across signals, computeds and effect handles, idempotency, cross-registry isolation (per-registry Symbol prevents pool corruption), foreign-value safety, top-level helper routing, 500-cycle balanced churn leaving pool and stats stable.
 - **`08-watch.test.mjs`** — Validates the user-land observer utilities (watch, when, whenAsync). Covers lifecycle teardown, old/new value tracking, and Promise-based asynchronous state resolution.
 - **`09-conformance.test.mjs`** — Industry-standard conformance tests. Validates the engine against extreme edge cases from the johnsoncodehk reactive test suite, ensuring strict zero-GC invariants, correct cleanup isolation, and re-entrant stability.
+- **`10-is-tracking.test.mjs`** — The `isTracking()` observer-context predicate. 11 tests across 5 describe blocks: true inside effect/computed bodies; false inside `untrack`, `subscribe` callbacks, `onCleanup` bodies, and `watch` callbacks (the untracked-window cases that catch an observer-only misimplementation); false outside any observer including at the call site of an unobserved computed read; state-restoration after a thrown body; per-registry isolation; top-level binding.
 
 ```bash
 npm test
@@ -705,11 +729,19 @@ function spawnPlugin(pluginCode) {
 
 ## Conformance
 
-lite-signal v1.1.0 was evaluated against the
+lite-signal is evaluated against the
 [reactive-framework-test-suite](https://github.com/johnsoncodehk/reactive-framework-test-suite),
 the most comprehensive behavioral test battery for JavaScript reactive
 libraries.
 
+As of **v1.1.2**, the conformance items that were open at v1.1.0 — batch revert
+detection (#123 / #132 / #147), throw isolation in flush (#121), and
+inner-write propagation through computed chains (#180 / #213) — are **closed**
+(landed in v1.1.1). The remaining gaps are one deliberate design choice (#179,
+below) and the owner-tree items (#209 / #210), which land with the v1.2
+ownership hybrid. The exact post-1.1.1 pass count is being re-run against the
+upstream suite; per-test results and the runner adapter live in `/conformance/`.
+
 **174 of 177 tests pass (98.3%)**, placing lite-signal **in a tie for second place of sixteen**
 evaluated libraries — just behind alien-signals (177).
 
@@ -732,23 +764,9 @@ more useful to library users than a green checkmark.
 - **Auto-unsubscribe** on first-run effect throws — matches preact, reatom,
   solid. Half the field leaks the subscription.
 
-### What v1.1.0 doesn't do yet
-
-10 tests fail. We've categorized them by intent.
-
-**Targeted for v1.2** (6 tests):
+### What lite-signal does NOT do yet
 
-- **Revert detection inside batches** (#147, #132, #123): writes inside a
-  `batch()` that net to no change still mark dependents as dirty. Vue,
-  Solid, Mobx, and roughly half the field share this behavior. v1.2 will
-  capture pre-batch values per signal and skip propagation on revert.
-- **Throw isolation in batch flush** (#121): if an effect throws during
-  flush, lite-signal currently halts the flush. v1.2 will collect errors,
-  finish the flush, then re-throw as `AggregateError`.
-- **Inner-write propagation through computed chains** (#180, #213): two
-  specific propagation paths where lite-signal disagrees with the field.
-  Both are propagation-order bugs in the recursive computed resolver,
-  not zero-GC tradeoffs.
+The remaining open items, by intent.
 
 **Design choices we will not change** (2 tests):
 
@@ -760,13 +778,14 @@ more useful to library users than a green checkmark.
   effect's own implicit batching. Most libraries behave this way. Wrap the
   batch outside the effect for the intended semantics.
 
-**Opt-in feature, deferred** (2 tests):
+**Landing in v1.2** (2 tests):
 
 - **Solid-style cascading disposal of nested effects** (#209, #210):
-  lite-signal does not maintain an owner tree of parent-child effects.
-  This matches preact, vue, mobx, the TC39 polyfill, Angular, Svelte,
-  tansu, and Solid 1.x. Solid 2 / @solidjs/signals, reatom, and anod
-  implement it. If you need it, please open an issue.
+  the baseline 1.1.x engine maintains no owner tree of parent-child
+  effects — matching preact, vue, mobx, the TC39 polyfill, Angular,
+  Svelte, tansu, and Solid 1.x. The v1.2 ownership hybrid adds an
+  owner tree so nested effects/computeds auto-dispose with their parent;
+  the #209 / #210 conformance tests are wired and skipped until then.
 
 Per-test results, the runner adapter, and reproductions live in
 `/conformance/`.

package/Signal.d.ts

@@ -1,7 +1,7 @@
 /**
  * @zakkster/lite-signal — zero-GC reactive graph.
  *
- * Public type surface for the JavaScript implementation in `src/index.js`.
+ * Public type surface for the JavaScript implementation in `Signal.js`.
  */
 
 // ─── Options ──────────────────────────────────────────────────────────────────
@@ -115,7 +115,7 @@ export interface RegistryConfig {
      *  - `"grow"`: double the pool. Links are bounded by `maxLinks * 16`.
      */
     onCapacityExceeded?: "throw" | "grow";
-    /** Max effect-queue drain passes before a {@link CycleError} is thrown. Default: 100. */
+    /** Max effect-queue drain passes before a flush-cycle `Error` (message prefixed `"CycleError:"`) is thrown. Default: 100. */
     maxFlushPasses?: number;
 }
 
@@ -133,6 +133,10 @@ export interface Registry {
     dispose(api: Disposable): void;
     batch<T>(fn: () => T): T;
     untrack<T>(fn: () => T): T;
+    /** True iff a read RIGHT NOW would record a dependency on this registry.
+     *  False inside `untrack`, `subscribe` callbacks, `onCleanup` bodies, and
+     *  outside any observer. Use for lazy-allocation wrappers like lite-store. */
+    isTracking(): boolean;
     onCleanup(fn: () => void): void;
     stats(): RegistryStats;
     /** Reset everything: nodes, links, queues, global clock. Outstanding dispose
@@ -163,6 +167,8 @@ export function effect(fn: () => void, opts?: EffectOptions): Dispose;
 export function dispose(api: Disposable): void;
 export function batch<T>(fn: () => T): T;
 export function untrack<T>(fn: () => T): T;
+/** Top-level binding of {@link Registry.isTracking} against the default registry. */
+export function isTracking(): boolean;
 export function onCleanup(fn: () => void): void;
 export function stats(): RegistryStats;
 export declare function destroy(): void;
@@ -177,24 +183,24 @@ export interface WatchOptions {
     immediate?: boolean;
 }
 
-//**
-* Track a reactive source and run a callback whenever its projected value
-* changes. The callback receives `(newValue, oldValue, stop)` — the third
-* argument is a dispose function that can be called from inside the callback
-* to terminate the watcher.
-*
-* Internal reads inside the callback are untracked.
-*
-* Uses `Object.is` to guard against the raw-getter case where a dep mutation
-* fires the effect but the projected value is unchanged.
-*
-* @param source    Reactive read function.
-* @param callback  Called with the new and previous values plus a stop handle.
-* @param options   `immediate: true` runs the callback once on registration
-*                  with `oldValue = undefined`.
-* @returns Dispose function. Idempotent and safe to call at any time, including
-*          synchronously during the immediate callback.
-*/
+/**
+ * Track a reactive source and run a callback whenever its projected value
+ * changes. The callback receives `(newValue, oldValue, stop)` — the third
+ * argument is a dispose function that can be called from inside the callback
+ * to terminate the watcher.
+ *
+ * Internal reads inside the callback are untracked.
+ *
+ * Uses `Object.is` to guard against the raw-getter case where a dep mutation
+ * fires the effect but the projected value is unchanged.
+ *
+ * @param source    Reactive read function.
+ * @param callback  Called with the new and previous values plus a stop handle.
+ * @param options   `immediate: true` runs the callback once on registration
+ *                  with `oldValue = undefined`.
+ * @returns Dispose function. Idempotent and safe to call at any time, including
+ *          synchronously during the immediate callback.
+ */
 export function watch<T>(
     source: () => T,
     callback: (newValue: T, oldValue: T | undefined, stop: () => void) => void,

package/Signal.js

@@ -1,5 +1,5 @@
 /**
- * @zakkster/lite-signal
+ * @zakkster/lite-signal v1.1.2
  * --------------------
  * Zero-GC reactive graph.
  *
@@ -143,10 +143,10 @@ export function createRegistry(config = {}) {
     const NODE_PTR = Symbol("node_ptr");
     const NODE_GEN = Symbol("node_gen");
 
-    let currentNodesCapacity = config.maxNodes || 1024;
-    let currentLinkCapacity = config.maxLinks || currentNodesCapacity * 4;
-    const policy = config.onCapacityExceeded || "throw";
-    const maxFlushPasses = config.maxFlushPasses || 100;
+    let currentNodesCapacity = config.maxNodes ?? 1024;
+    let currentLinkCapacity = config.maxLinks ?? currentNodesCapacity * 4;
+    const policy = config.onCapacityExceeded ?? "throw";
+    const maxFlushPasses = config.maxFlushPasses ?? 100;
     const maxLinkLimit = currentLinkCapacity * 16;
 
     // --- ZERO-GC OBJECT POOLS ---
@@ -440,19 +440,21 @@ export function createRegistry(config = {}) {
      * @private
      */
     function markDownstream(startNode) {
-        let stackLen = 0 | 0;
-        markStack[stackLen] = startNode;
-        stackLen = (stackLen + 1) | 0;
+        let stackLen = 0;
+        markStack[stackLen++] = startNode;
 
-        while (stackLen > 0) {
-            stackLen = (stackLen - 1) | 0;
-            const n = markStack[stackLen];
+        while (stackLen !== 0) {
+            const n = markStack[--stackLen];
 
             let link = n.headSub;
             while (link !== null) {
                 const t = link.target;
                 if ((t.markEpoch | 0) !== (globalVersion | 0)) {
                     t.markEpoch = globalVersion | 0;
+                    // flags read stays INSIDE the markEpoch guard on purpose: hoisting it
+                    // above the guard would load t.flags for every already-marked revisit
+                    // too, adding work on exactly the dedup-skip path that markEpoch exists
+                    // to make cheap (diamond / shared-computed fan-out).
                     const flags = t.flags | 0;
 
                     if ((flags & FLAG_EFFECT) !== 0) {
@@ -461,14 +463,12 @@ export function createRegistry(config = {}) {
                         // writes (directly or through computed chains). The effect's evalVersion
                         // is bumped to the post-write globalVersion in its executeEffect finally,
                         // so subsequent unrelated writes still propagate normally.
-                        if ((flags & FLAG_QUEUED) === 0 && (flags & FLAG_COMPUTING) === 0) {
+                        if ((flags & (FLAG_QUEUED | FLAG_COMPUTING)) === 0) {
                             t.flags = flags | FLAG_QUEUED;
-                            activeQueue[activeQueueLen] = t;
-                            activeQueueLen = (activeQueueLen + 1) | 0;
+                            activeQueue[activeQueueLen++] = t;
                         }
                     } else {
-                        markStack[stackLen] = t;
-                        stackLen = (stackLen + 1) | 0;
+                        markStack[stackLen++] = t;
                     }
                 }
                 link = link.nextSub;
@@ -732,14 +732,28 @@ export function createRegistry(config = {}) {
      *        Equality predicate. Returning true short-circuits notification.
      * @returns {Signal<T>}
      */
-    function signal(initial, opts = {}) {
+    function signal(initial, opts) {
         const node = createNode(initial, FLAG_SIGNAL);
-        node.equals = opts.equals !== undefined ? opts.equals : Object.is;
+        // Read opts defensively instead of defaulting to `= {}`: the default allocates
+        // a throwaway object on every no-opts call (the common path) — pure nursery
+        // garbage when mounting many signals.
+        node.equals = (opts !== undefined && opts.equals !== undefined) ? opts.equals : Object.is;
         node.version = globalVersion | 0;
         statSignals = (statSignals + 1) | 0;
 
         const read = () => {
-            if (isTrackingDeps && currentObserver !== null) allocateLink(node, currentObserver);
+            if (isTrackingDeps && currentObserver !== null) {
+                // Inlined cursor fast-path: on stable read order this matches every
+                // time, so we skip a call into the (large, non-inlinable) allocateLink
+                // frame entirely. Only a cursor miss falls through to the cold path,
+                // where allocateLink re-reads the cursor for its relink logic.
+                const expected = activeObserverCurrentDep;
+                if (expected !== null && expected.source === node) {
+                    activeObserverCurrentDep = expected.nextDep;
+                } else {
+                    allocateLink(node, currentObserver);
+                }
+            }
             return node.value;
         };
         read.peek = () => node.value;
@@ -774,11 +788,21 @@ export function createRegistry(config = {}) {
         read.update = (fn) => read.set(fn(node.value));
 
         read.subscribe = (fn) => {
-            let captured;
-            const invokeSub = () => fn(captured);
+            // Single-closure subscription: the read is tracked (it establishes the
+            // dependency), then fn runs untracked. untrack() is inlined here to (a) drop
+            // the second per-subscription closure and (b) save an untrack()+wrapper call
+            // on every fire, not just at setup.
+            // COUPLING: this duplicates untrack()'s isTrackingDeps save/restore. If
+            // untrack ever manages additional state (e.g. currentObserver), mirror it here.
             return effect(() => {
-                captured = read();
-                untrack(invokeSub);
+                const val = read();
+                const prevTracking = isTrackingDeps;
+                isTrackingDeps = false;
+                try {
+                    fn(val);
+                } finally {
+                    isTrackingDeps = prevTracking;
+                }
             });
         };
 
@@ -800,24 +824,39 @@ export function createRegistry(config = {}) {
      *        Equality predicate. Returning true blocks propagation downstream.
      * @returns {Computed<T>}
      */
-    function computed(fn, opts = {}) {
+    function computed(fn, opts) {
         const node = createNode(undefined, FLAG_COMPUTED);
         node.computeFn = fn;
-        node.equals = opts.equals !== undefined ? opts.equals : Object.is;
+        // Defensive opts read; avoids the `= {}` per-call allocation. See signal().
+        node.equals = (opts !== undefined && opts.equals !== undefined) ? opts.equals : Object.is;
         statComputeds = (statComputeds + 1) | 0;
 
         const read = () => {
-            if (isTrackingDeps && currentObserver !== null) allocateLink(node, currentObserver);
+            if (isTrackingDeps && currentObserver !== null) {
+                // Inlined cursor fast-path — see signal() read for rationale.
+                const expected = activeObserverCurrentDep;
+                if (expected !== null && expected.source === node) {
+                    activeObserverCurrentDep = expected.nextDep;
+                } else {
+                    allocateLink(node, currentObserver);
+                }
+            }
             return pullComputed(node);
         };
         read.peek = () => pullComputed(node);
 
         read.subscribe = (fn) => {
-            let captured;
-            const invokeSub = () => fn(captured);
+            // Single-closure subscription — see signal() subscribe for rationale and
+            // the untrack-inlining coupling note.
             return effect(() => {
-                captured = read();
-                untrack(invokeSub);
+                const val = read();
+                const prevTracking = isTrackingDeps;
+                isTrackingDeps = false;
+                try {
+                    fn(val);
+                } finally {
+                    isTrackingDeps = prevTracking;
+                }
             });
         };
 
@@ -842,13 +881,15 @@ export function createRegistry(config = {}) {
      * @returns {() => void}         Dispose function. Idempotent. Safe to call
      *                               after registry.destroy().
      */
-    function effect(fn, opts = {}) {
+    function effect(fn, opts) {
         const node = createNode(undefined, FLAG_EFFECT);
         node.computeFn = fn;
-        node.scheduler = opts.scheduler;
+        // Defensive opts read; avoids the `= {}` per-call allocation. Read scheduler once
+        // and reuse the local for the trampoline check below.
+        const scheduler = opts !== undefined ? opts.scheduler : undefined;
+        node.scheduler = scheduler;
         statEffects = (statEffects + 1) | 0;
 
-        const scheduler = opts.scheduler;
         let firstRunError = null;
         if (scheduler) {
             const gen = node.gen | 0;
@@ -952,6 +993,32 @@ export function createRegistry(config = {}) {
      * @param {() => T} fn
      * @returns {T}
      */
+    /**
+     * Returns true iff a read RIGHT NOW would record a dependency in the current
+     * call stack: an observer body is on the stack AND tracking is enabled.
+     *
+     * Mirrors the engine's own read-trap predicate (both flags checked). Returns
+     * false inside `untrack()`, inside `signal.subscribe`'s callback (which
+     * inlines the same untracked-notify pattern), inside `runCleanup` bodies,
+     * and outside any observer.
+     *
+     * Use case: wrapper libraries (lite-store, lite-query, lite-form) that
+     * lazily allocate reactive primitives on property reads — gating on
+     * isTracking() lets them skip allocation when reads happen outside a
+     * reactive context, preserving the zero-GC contract.
+     *
+     * Cost: two closure-variable loads, one AND, one return. ~1–2 ns.
+     *
+     * Note: per-registry. Wrappers operating against a non-default registry
+     * MUST call that registry's `isTracking()`, not the top-level one — each
+     * registry has its own tracking state.
+     *
+     * @returns {boolean}
+     */
+    function isTracking() {
+        return isTrackingDeps && currentObserver !== null;
+    }
+
     function untrack(fn) {
         const prev = isTrackingDeps;
         isTrackingDeps = false;
@@ -1060,7 +1127,7 @@ export function createRegistry(config = {}) {
         flushErrorBuffer.length = 0; // release the backing array
     }
 
-    return {signal, computed, effect, dispose, batch, untrack, onCleanup, stats, destroy};
+    return {signal, computed, effect, dispose, batch, untrack, onCleanup, stats, destroy, isTracking};
 }
 
 // ─────────────────────────────────────────────────────────────────
@@ -1109,6 +1176,15 @@ export function untrack(fn) {
     return defaultRegistry.untrack(fn);
 }
 
+/**
+ * True iff a read RIGHT NOW would record a dependency on the default registry.
+ * See {@link createRegistry} for the per-registry version. Wrappers operating
+ * against a non-default registry MUST call THAT registry's `isTracking()`.
+ */
+export function isTracking() {
+    return defaultRegistry.isTracking();
+}
+
 /** @type {Registry["onCleanup"]} */
 export function onCleanup(fn) {
     return defaultRegistry.onCleanup(fn);

package/llms.txt

@@ -19,6 +19,7 @@ triggering write — no `queueMicrotask`, no promises, no scheduler ticks.
 - **dispose(api)**: universal disposal. Accepts a signal, computed, or effect dispose handle; idempotent; cross-registry calls are silent no-ops (per-registry `Symbol("node_ptr")` keys the node-identity slot on the returned API function, foreign signals fail the lookup and fall through). Passing an unrelated value is also safe; passing an arbitrary function invokes it (effect-handle contract).
 - **Batch**: `batch(fn)` defers effect flush until the outermost batch closes. Nestable.
 - **Untrack**: `untrack(fn)` reads without subscribing.
+- **isTracking**: `isTracking()` returns true iff a read right now would record a dependency on this registry (for wrappers that lazily allocate signals).
 - **onCleanup**: registers teardown for the current computation; fires before each re-run and once on dispose. Works in effects and computeds.
 - **Registry**: `createRegistry({ maxNodes, maxLinks, onCapacityExceeded, maxFlushPasses })` creates an isolated reactive world with its own pools. Useful for tests, plugins, multi-tenant sandboxes. Top-level helpers use a default registry created at module load.
 - **CapacityError**: thrown when a fixed-size pool is exhausted under the `"throw"` policy, or when a `"grow"` policy hits the 16× starting-capacity ceiling on links.
@@ -46,6 +47,25 @@ triggering write — no `queueMicrotask`, no promises, no scheduler ticks.
 - Stable read order: O(1) per dep via cursor reuse.
 - Chaotic/randomized read order: degrades to O(N) per dep due to list re-insertion.
 
+## Version notes
+
+- **1.1.3**: adds `isTracking()` (top-level + per-registry). Returns true iff a
+  read right now would record a dependency (`isTrackingDeps && currentObserver !== null`).
+  False inside `untrack`, `subscribe` callbacks, `onCleanup` bodies, `watch` /
+  `when` callbacks, and outside any observer. ~1–2 ns. For wrapper libraries
+  (lite-store, lite-query, lite-form) that allocate reactive primitives lazily
+  on property reads. Per-registry: wrappers operating against a non-default
+  registry must call THAT registry's `isTracking()`, not the top-level one.
+  No behavior or engine changes.
+
+
+- **1.1.2** (current): hot-path micro-optimizations, no behavior/API change.
+  Inlined cursor fast-path in `signal`/`computed` reads (stable-order reads skip
+  the `allocateLink` call); zero-allocation creation path (`opts` read defensively
+  instead of defaulting to `{}`); single-closure `subscribe`. Owner-tree
+  conformance items #209/#210 are wired but skipped pending the v1.2 ownership
+  hybrid.
+
 ## When to use
 
 - Animation loops, game HUDs, scoreboards, telemetry overlays.
@@ -70,6 +90,7 @@ function effect(fn: () => void, opts?: { scheduler?: (run: () => void) => void }
 function dispose(api: Signal<any> | Computed<any> | Dispose): void;
 function batch<T>(fn: () => T): T;
 function untrack<T>(fn: () => T): T;
+function isTracking(): boolean;
 function onCleanup(fn: () => void): void;
 function stats(): RegistryStats;
 
@@ -232,7 +253,7 @@ sandbox.destroy();   // entire reactive world reset
 
 ## File layout
 
-- `Signal.js`              — full implementation, ~500 lines, single file.
+- `Signal.js`              — full implementation, single file.
 - `Signal.d.ts`          — TypeScript declarations for all public API.
 - `test/01-core.test.mjs`     — signal/computed/effect basics, equality, untrack.
 - `test/02-topology.test.mjs` — diamonds, chains, fan-out/in, cycle detection.
@@ -243,7 +264,7 @@ sandbox.destroy();   // entire reactive world reset
 - `test/07-dispose.test.mjs` — universal disposal: registry.dispose(api).
 - `test/08-watch.test.mjs` — new watch reactivity tests.
 - `test/09-conformance.test.mjs` — johnsoncodehk/reactive-framework-test-suite conformance fixes tests.
-- `bench/bench.mjs`           — comparative benchmark vs alien-signals, preact, solid.
+- `bench/benchmark.mjs`       — comparative benchmark vs alien-signals, preact, solid.
 - `demo/index.html`           — interactive visualization of the reactive graph.
 
 ## Install

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zakkster/lite-signal",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "Zero-GC reactive graph. Monomorphic object pool, versioned push-pull propagation, 32-bit modular versioning. Built for hot paths and long-running processes.",
   "author": "Zahary Shinikchiev <shinikchiev@yahoo.com>",
   "license": "MIT",
@@ -10,8 +10,9 @@
   "types": "./Signal.d.ts",
   "exports": {
     ".": {
-      "types": "./Signal.d.ts",
+      "node": "./Signal.js",
       "import": "./Signal.js",
+      "types": "./Signal.d.ts",
       "default": "./Signal.js"
     }
   },
@@ -27,6 +28,7 @@
     "test": "node --test --test-reporter=spec",
     "test:gc": "node --expose-gc --test --test-reporter=spec",
     "bench": "node --expose-gc bench/benchmark.mjs",
+    "bench-reactive": "node --expose-gc bench/benchmarkReactive.mjs",
     "verify": "npm test && npm run bench"
   },
   "keywords": [