mutts 1.0.5 → 1.0.7

package/docs/reactive/core.md

@@ -105,7 +105,7 @@ const result = memoized(user)
 **5. Map over arrays:**
 ```typescript
 const source = reactive([1, 2, 3])
-const doubled = mapped(source, x => x * 2)
+const doubled = project(source, ({ value }) => value * 2)
 // [2, 4, 6]
 
 source.push(4)  // doubled automatically becomes [2, 4, 6, 8]
@@ -446,13 +446,13 @@ state.c = 15 // Does NOT trigger effect
 
 ### Async Effects and the `access` Parameter
 
-The `effect` function provides a special `access` parameter with `tracked` and `ascend` functions that restore the active effect context for dependency tracking in asynchronous operations. This is crucial because async functions lose the global active effect context when they yield control.
+The `effect` function provides a special `access` parameter with `tracked` and `ascend` functions that restore the active effect context for dependency tracking in asynchronous operations. 
 
-#### The Problem with Async Effects
+In modern `mutts`, this is powered by the **Zone system**. When you use `configureAsyncZone()`, the active effect context is automatically preserved across `await` points and timers, making manual use of `tracked` optional for these cases.
 
-When an effect function is synchronous, reactive property access automatically tracks dependencies, however, in async functions, the active effect context is lost when the function yields control. 
+#### The Problem with Async Effects
 
-The `access.tracked()` function restores the active effect context for dependency tracking.
+Traditionally, in JavaScript, async functions lose their context when they yield control. 
 
 #### Understanding the active effect context
 
@@ -463,37 +463,42 @@ The reactive system uses a global active effect variable to track which effect i
 effect(() => {
     // active effect = this effect
     const value = state.count // ✅ Tracked (active effect is set)
-    // active effect = this effect (still set)
     const another = state.name // ✅ Tracked (active effect is still set)
 })
 
-// Async effect - active effect is lost after await
+// Async effect WITHOUT configureAsyncZone() - context is lost after await
 effect(async () => {
-    // active effect = this effect
-    const value = state.count // ✅ Tracked (active effect is set)
+    const value = state.count // ✅ Tracked
     
-    await someAsyncOperation() // Function exits, active effect = undefined
+    await someAsyncOperation() 
     
-    // active effect = undefined (lost!)
-    const another = state.name // ❌ NOT tracked (no active effect)
+    // context is lost!
+    const another = state.name // ❌ NOT tracked
 })
 
-// Async effect with access.tracked() - active effect is restored
-effect(async ({ tracked }) => {
-    // active effect = this effect
-    const value = state.count // ✅ Tracked (active effect is set)
+// Async effect WITH configureAsyncZone() - context is preserved
+effect(async () => {
+    const value = state.count // ✅ Tracked
+    
+    await someAsyncOperation() 
     
-    await someAsyncOperation() // Function exits, active effect = undefined
+    // context is automatically restored!
+    const another = state.name // ✅ Tracked
+})
+
+// Using access.tracked() for manual restoration
+effect(async ({ tracked }) => {
+    await someAsyncOperation() 
     
-    // tracked() temporarily restores active effect for the callback
-    const another = tracked(() => state.name) // ✅ Tracked (active effect restored)
+    // Useful for non-patched APIs or explicit scoping
+    const another = tracked(() => state.name) // ✅ Tracked
 })
 ```
 
-#### Key Benefits of `access.tracked()` in Async Effects
+#### Key Benefits of the Zone System
 
-1. **Restored Context**: `access.tracked()` temporarily restores the active effect context for dependency tracking
-2. **Consistent Tracking**: Reactive property access works the same way before and after `await`
+1.  **Automatic Restoration**: With `configureAsyncZone()`, most native async APIs (Promises, timers) automatically preserve the reactive context.
+2.  **Manual Control**: `access.tracked()` allows you to manually "passport" the context into third-party libraries or unmanaged callbacks.
 
 ### Using `ascend` for Parent Effect Tracking
 
@@ -518,8 +523,6 @@ effect(({ ascend }) => {
     }
 })
 ```
-<｜tool▁calls▁begin｜><｜tool▁call▁begin｜>
-grep
 
 **When to use `ascend`:**
 - When creating child effects that should be cleaned up with their parent

package/docs/reactive/debugging.md

@@ -0,0 +1,168 @@
+# Debugging Tools
+
+The `mutts` reactive system provides several built-in tools to help track down synchronization issues, dependency leaks, and infinite loops. These tools are primarily exposed through the `reactiveOptions` object.
+
+> [!WARNING]
+> **Performance Cost**: Most debugging tools incur a significant performance overhead. They should be enabled only during development or within test environments. Re-running computations for discrepancy detection, in particular, effectively doubles the cost of reactive updates.
+
+## The `reactiveOptions` Reference
+
+The `reactiveOptions` object (exported from `mutts/reactive`) allows you to hook into the reactive system's internals.
+
+```typescript
+import { reactiveOptions } from 'mutts/reactive';
+```
+
+### Lifecycle Hooks
+
+These hooks are called during the execution of effects and computed values.
+
+- **`enter(effect: Function)`**: Called when an effect or memoized function starts executing.
+- **`leave(effect: Function)`**: Called when an effect or memoized function finishes.
+- **`touched(obj: any, evolution: Evolution)`**: Called whenever a reactive object is "touched" (accessed or modified). This is the lowest-level hook for observing system activity.
+
+### Effect Chaining & Batching
+
+- **`beginChain(targets: Function[]) / endChain()`**: Called when a batch of effects starts and ends its execution.
+- **`maxEffectChain`**: (Default: `100`) Limits the depth of synchronous effect triggering to prevent stack overflows.
+- **`maxTriggerPerBatch`**: (Default: `10`) Limits how many times a single effect can be triggered within the same batch. Useful for detecting aggressive re-computation or infinite cycles in `cycleHandling: 'none'` mode.
+
+## Cycle Detection
+
+`mutts` automatically detects circular dependencies (e.g., Effect A updates State X, which triggers Effect B, which updates State Y, which triggers Effect A).
+
+### Configuration
+
+You can control how cycles are handled via `reactiveOptions.cycleHandling`:
+
+- **`'none'`** (Default): High-performance FIFO mode. Disables the dependency graph and topological sorting.
+- **`'throw'`**: Throws a `ReactiveError` with a detailed path.
+- **`'warn'`**: Logs a warning but breaks the cycle to allow the application to continue.
+- **`'break'`**: Silently breaks the cycle.
+- **`'strict'`**: Performs a graph check *before* execution to prevent cycles from even starting. This has the highest overhead.
+
+### Topological vs. Flat Mode Detection
+
+| Mode | `cycleHandling` | Detection Method | Error Code |
+| :--- | :--- | :--- | :--- |
+| **Topological** | `'throw'` (or other) | **Mathematical**: Analyzes the dependency graph. | `CYCLE_DETECTED` |
+| **Flat Mode** | `'none'` (Default) | **Heuristic**: Counts executions per batch. | `MAX_REACTION_EXCEEDED` |
+
+In **Topological mode**, the system maintains a transitive closure of all effects, allowing it to know instantly if an effect is its own cause. In **Flat mode**, the system is "blind" to the graph and relies on the execution threshold (`maxTriggerPerBatch`) to interrupt infinite loops.
+
+## Memoization Discrepancy Detection
+
+The most powerful debugging tool in `mutts` is the **Discrepancy Detector**. It helps identify "missing dependencies"—reactive values used inside a computation that the system isn't tracking.
+
+### How it Works
+
+When `reactiveOptions.onMemoizationDiscrepancy` is set:
+1. Every time a `memoize()` function is called, it checks its cache.
+2. If a cached value exists, the function is immediately **executed a second time** in a completely untracked context.
+3. If the results differ, your callback is triggered.
+
+### Usage
+
+```typescript
+reactiveOptions.onMemoizationDiscrepancy = (cached, fresh, fn, args, cause) => {
+    console.error(`Discrepancy in ${fn.name || 'anonymous'}!`, {
+        cached,
+        fresh,
+        cause // 'calculation' or 'comparison'
+    });
+    throw new Error('Memoization discrepancy detected');
+};
+```
+
+If the cause is 'comparison', it means that, at first computation, calling the function twice gives different results.
+
+If the cause is 'calculation', it means that, when asked the value while the cache was still valid, the function returned a different result.
+
+### `isVerificationRun`
+
+During the "second run" of a discrepancy check, `reactiveOptions.isVerificationRun` is set to `true`. You can use this flag in your own code to avoid side effects (like incrementing counters) that should only happen once during the primary execution.
+
+> [!IMPORTANT]
+> Do not modify `isVerificationRun` manually; it is managed by the engine.
+
+## Introspection API
+
+For programmatic analysis of the reactive system, `mutts` provides a dedicated introspection module. This is particularly useful for AI agents and developer tools.
+
+```typescript
+import { enableIntrospection, getDependencyGraph, getMutationHistory, snapshot } from 'mutts/introspection';
+```
+
+### Enabling Introspection
+
+Introspection features (like history tracking) are memory-intensive and disabled by default.
+
+```typescript
+// Enable history tracking (default size: 50)
+enableIntrospection({ historySize: 100 });
+```
+
+### Dependency Graph
+
+You can retrieve the full dependency graph to understand how objects and effects are linked.
+
+```typescript
+const graph = getDependencyGraph();
+// Returns: { nodes: Array<EffectNode | ObjectNode>, edges: Array<GraphEdge> }
+```
+
+### Mutation History
+
+If `enableHistory` is on, you can inspect the sequence of mutations that have occurred.
+
+```typescript
+const history = getMutationHistory();
+// Each record contains type, property, old/new values, and causal source.
+```
+
+## Structured Error Handling
+
+When the reactive system encounters a critical failure (like a cycle or max depth exceeded), it throws a `ReactiveError` containing rich diagnostic information.
+
+### `ReactiveErrorCode`
+
+Always check `error.debugInfo.code` to identify the failure type:
+- `CYCLE_DETECTED`: A circular dependency was found.
+- `MAX_DEPTH_EXCEEDED`: The synchronous effect chain reached `maxEffectChain`.
+- `MAX_REACTION_EXCEEDED`: An effect was triggered too many times in a single batch.
+- `WRITE_IN_COMPUTED`: An attempt was made to modify reactive state inside a `memoize` or `derived` function.
+
+### Rich Debug Info
+
+The `debugInfo` property on `ReactiveError` includes:
+- **`causalChain`**: A string array describing the logical path of modifications leading to the error.
+- **`creationStack`**: The stack trace of where the effect was originally created, helping you locate the source in your code.
+- **`cycle`**: (For `CYCLE_DETECTED`) The names of the effects that form the loop.
+
+## Best Practices for Debugging
+
+### Naming Effects
+
+Always provide a name for your effects to make debug logs and error messages readable:
+
+```typescript
+effect(() => {
+    // ...
+}, { name: 'UpdateSidebarCounter' });
+```
+
+### Activation & Deactivation
+
+Since these are runtime options, you can toggle them based on your environment:
+
+```typescript
+if (process.env.NODE_ENV === 'development') {
+    reactiveOptions.cycleHandling = 'throw';
+    reactiveOptions.onMemoizationDiscrepancy = myHandler;
+    enableIntrospection();
+} else {
+    // Ensure they are off in production for performance
+    reactiveOptions.onMemoizationDiscrepancy = undefined;
+    reactiveOptions.cycleHandling = 'break';
+}
+```

package/docs/reactive/project.md

@@ -12,7 +12,7 @@
 
 - `memoize` caches results but invalidates on `Map.set`, so large effects still re-run.
 - `organized` (designed for `Record` sources) creates per-key effects so downstream work reruns only for the touched key; this matches the desired behaviour.
-- **Gap:** `organized` operates on plain objects: key enumeration relies on property iteration and `ReflectGet/Set`. Registers and other keyed collections (`Map`, `Register`, custom stores) need the same per-entry orchestration without converting to records.
+- **Gap:** `organized` operates on plain objects: key enumeration relies on property iteration and `FoolProof.get/set`. Registers and other keyed collections (`Map`, `Register`, custom stores) need the same per-entry orchestration without converting to records.
 
 ### Completed Evolution: `project` Implementation
 

package/docs/reactive/scan.md

@@ -0,0 +1,78 @@
+# Reactive Scan
+
+The `scan` function perform a reactive accumulation over an array of items. Unlike a standard `Array.reduce`, it is designed to be highly efficient in a reactive system, particularly when items are moved or changed, by returning a reactive array of all intermediate results.
+
+## Overview
+
+In a typical reactive system, calling `array.reduce(...)` inside an `effect` means the entire reduction re-runs every time the array structure or a single item changes.
+
+Reactive `scan` solves this by maintaining a chain of **reactive intermediates**. Each item in the source array is linked to an intermediate that depends on the *previous* intermediate's result.
+
+## Key Features
+
+- **Fine-Grained Reactivity**: Changing a property on an item only re-computes the accumulated value for that item and its successors.
+- **Move Optimization**: If a subsequence of items moves together (e.g., sorting or splicing), their intermediates are reused. As long as an item's predecessor in the array hasn't changed, its accumulated value is hit from the cache.
+- **Duplicate Support**: Correctly handles multiple occurrences of the same object instance.
+- **Memory Safety**: Uses `WeakMap` for intermediate storage, ensuring data is cleared when source items are garbage collected.
+- **Granular Sync**: Uses per-index effects to sync results, preventing broad dependency tracking of the source array in every calculation.
+
+## Basic Usage
+
+```typescript
+import { reactive, scan } from 'mutts/reactive'
+
+const source = reactive([
+  { id: 'A', val: 1 },
+  { id: 'B', val: 2 },
+  { id: 'C', val: 3 },
+])
+
+// result is a reactive array: [1, 3, 6]
+const result = scan(source, (acc, item) => acc + item.val, 0)
+
+// Updating an item only re-computes for that position and successors
+source[1].val = 10
+// result stays [1, 11, 14]
+```
+
+## How it Works
+
+The implementation consists of:
+1. **A Main Effect**: Tracks the structure of the source array (length and item identities). It manages a list of `Intermediate` objects and stays updated on their `prev` links.
+2. **Intermediates**: Class instances that link `val` and `prev`. They expose an `acc` getter decorated with `@memoize`.
+3. **Index Sync Effects**: Granular effects (one per result index) that subscribe to `indexToIntermediate[i].acc`.
+
+This "Project-like" architecture ensures that the main loop only does structural work, while the actual logic propagation is handled by the dependency chain of the intermediates.
+
+## API Reference
+
+```typescript
+function scan<Input extends object, Output>(
+    source: readonly Input[],
+    callback: (acc: Output, val: Input) => Output,
+    initialValue: Output
+): ScanResult<Output>
+```
+
+### Parameters
+- `source`: The source array. All items must be objects (WeakKeys) to enable intermediate caching.
+- `callback`: The accumulator function `(acc, val) => nextAcc`.
+- `initialValue`: The value used as the accumulator for the first item.
+
+### Returns
+A reactive array of accumulated values. It includes a `[cleanup]` symbol that should be called to stop the reactive tracking.
+
+```typescript
+import { cleanup } from 'mutts/reactive'
+// ...
+result[cleanup]()
+```
+
+## Performance Comparison
+
+| Operation | Standard `Array.reduce` in `effect` | Reactive `scan` |
+| :--- | :--- | :--- |
+| **Initial Run** | O(N) calls | O(N) calls |
+| **Modify Item at `i`** | O(N) calls (entire reduction) | O(N-i) calls |
+| **Append Item** | O(N+1) calls | 1 call |
+| **Move Item** | O(N) calls | O(affected chain) |

package/docs/reactive.md

@@ -11,7 +11,8 @@ The Mutts Reactive System documentation has been split into focused sections for
 *   **[Reactive Collections](./reactive/collections.md#collections)**: Map, Set, WeakMap, WeakSet
 *   **[Reactive Arrays](./reactive/collections.md#reactivearray)**: Full array method support
 *   **[Register](./reactive/collections.md#register)**: ID-keyed ordered collections
-*   **[Projections](./reactive/collections.md#projection)**: `project`, `mapped`, `organized`
+*   **[Projections](./reactive/collections.md#projection)**: `project`, `organized`
+*   **[Scan](./reactive/scan.md)**: Reactive scan and accumulation
 
 ## [Advanced Topics](./reactive/advanced.md)
 *   **[Atomic Operations](./reactive/advanced.md#atomic-operations)**: Batching and Bidirectional binding
@@ -20,9 +21,10 @@ The Mutts Reactive System documentation has been split into focused sections for
 *   **[Memoization](./reactive/advanced.md#memoization)**: Caching strategies
 *   **[Debugging](./reactive/advanced.md#debugging-and-development)**: Cycle detection and troubleshooting
 
-## Debugging tools
+## [Debugging and Troubleshooting](./reactive/debugging.md)
+*   **[Reactive Options](./reactive/debugging.md#the-reactiveoptions-reference)**: Global debug hooks and configuration
+*   **[Cycle Detection](./reactive/debugging.md#cycle-detection)**: Configuration and troubleshooting circular dependencies
+*   **[Memoization Discrepancy](./reactive/debugging.md#memoization-discrepancy-detection)**: Identifying missing dependencies
+*   **[Introspection API](./reactive/debugging.md#introspection-api)**: Programmatic analysis and dependency graphs
 
-The reactive system is currently in a gamma state. The interface is quite fixed, the debugging tools are in place but :
-- still unfinished
-- not deactivatable
-- harming the performances of the application
+*   **[Performance](./reactive/debugging.md#performance-cost)**: Understanding the cost of debugging tools

package/docs/std-decorators.md

@@ -1,3 +1,4 @@
+TODO: redo the doc here
 # Standard decorators
 
 A TypeScript library that provides standard decorators that should stop being re-implemented for the 50th time

package/docs/zone.md

@@ -0,0 +1,88 @@
+# Zones (`mutts/zone`)
+
+Zones provide a high-performance **context management system** that follows the execution flow, ensuring your variables "stay put" even across asynchronous boundaries like `Promises`, `setTimeout`, or `queueMicrotask`.
+
+## Basic Usage
+
+A `Zone` represents a piece of storage that is scoped to the current execution block.
+
+```typescript
+import { Zone } from 'mutts/zone';
+
+const myZone = new Zone<string>();
+
+myZone.with("context-value", () => {
+    // Inside this function, the zone is active
+    console.log(myZone.active); // "context-value"
+});
+
+console.log(myZone.active); // undefined
+```
+
+## Async Propagation
+
+By default, zones are lost when an async operation yields control (e.g., after `await`). To fix this, `mutts` provides `configureAsyncZone()`.
+
+```typescript
+import { configureAsyncZone, asyncZone, Zone } from 'mutts/zone';
+
+const requestId = new Zone<string>();
+
+// 1. Tell the global aggregator to track this zone
+asyncZone.add(requestId);
+
+// 2. Patch global async primitives (once per app)
+configureAsyncZone();
+
+// 3. Usage
+requestId.with("req-123", async () => {
+    await somePromise();
+    // Context is automatically preserved across await!
+    console.log(requestId.active); // "req-123"
+});
+```
+
+## Core API
+
+### `AZone<T>` (Abstract)
+The base class for all zone implementations.
+- `active: T | undefined`: The current value in the zone.
+- `with<R>(value: T, fn: () => R): R`: Executes `fn` with `value` set as active.
+- `root<R>(fn: () => R): R`: Executes `fn` with the zone cleared (undefined).
+- `zoned: FunctionWrapper`: A getter that returns a function which, when called, restores the zone to its **current** state.
+
+### `Zone<T>`
+Simple stack-based storage.
+
+### `ZoneHistory<T>`
+A zone wrapper that maintains a `history` of previously active values in the current stack. 
+- Useful for **Cycle Detection**.
+- Prevents re-entering the same value if already in the history.
+- `present: AZone<T>`: Access the current value without the history overhead.
+
+### `ZoneAggregator`
+Combines multiple zones into one.
+- Entering an aggregator (with `.with()`) enters all its member zones.
+- `asyncZone` is a global aggregator used for the async patches.
+
+## Manual Context Bridging
+
+If you are using an API that `mutts` doesn't automatically patch, you can use the `.zoned` capture mechanism:
+
+```typescript
+const wrap = myZone.zoned; // Snapshot the current context
+
+// Pass the wrapper to an unmanaged callback
+externalLib.on('event', () => {
+    wrap(() => {
+        console.log("Context is back:", myZone.active);
+    });
+});
+```
+
+## Integration with Reactivity
+
+The `mutts` reactivity system uses zones internally to track the `activeEffect`. 
+- Every `effect()` execution runs inside the `effectHistory` zone.
+- Circular dependency detection is powered by `ZoneHistory`.
+- Async effects survive `await` because `effectHistory` is a member of the global `asyncZone`.

package/package.json

@@ -1,71 +1,50 @@
 {
   "name": "mutts",
   "description": "Modern UTility TS: A collection of TypeScript utilities",
-  "version": "1.0.5",
-  "main": "dist/index.js",
-  "module": "dist/index.esm.js",
-  "types": "dist/index.d.ts",
+  "version": "1.0.7",
+  "main": "dist/browser.js",
+  "module": "dist/browser.esm.js",
+  "types": "dist/browser.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "source": "./src/index.ts",
-      "import": "./dist/index.esm.js",
-      "require": "./dist/index.js",
-      "script": "./dist/mutts.umd.min.js"
+      "node": {
+        "types": "./dist/node.d.ts",
+        "import": "./dist/node.esm.js",
+        "require": "./dist/node.js"
+      },
+      "default": {
+        "types": "./dist/browser.d.ts",
+        "import": "./dist/browser.esm.js",
+        "require": "./dist/browser.js"
+      }
     },
-    "./decorator": {
-      "types": "./dist/decorator.d.ts",
-      "source": "./src/decorator.ts",
-      "import": "./dist/decorator.esm.js",
-      "require": "./dist/decorator.js"
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.esm.js",
+      "require": "./dist/browser.js"
     },
-    "./reactive": {
-      "types": "./dist/reactive.d.ts",
-      "source": "./src/reactive/index.ts",
-      "import": "./dist/reactive.esm.js",
-      "require": "./dist/reactive.js"
-    },
-    "./eventful": {
-      "types": "./dist/eventful.d.ts",
-      "source": "./src/eventful.ts",
-      "import": "./dist/eventful.esm.js",
-      "require": "./dist/eventful.js"
-    },
-    "./indexable": {
-      "types": "./dist/indexable.d.ts",
-      "source": "./src/indexable.ts",
-      "import": "./dist/indexable.esm.js",
-      "require": "./dist/indexable.js"
-    },
-    "./promiseChain": {
-      "types": "./dist/promiseChain.d.ts",
-      "source": "./src/promiseChain.ts",
-      "import": "./dist/promiseChain.esm.js",
-      "require": "./dist/promiseChain.js"
-    },
-    "./destroyable": {
-      "types": "./dist/destroyable.d.ts",
-      "source": "./src/destroyable.ts",
-      "import": "./dist/destroyable.esm.js",
-      "require": "./dist/destroyable.js"
-    },
-    "./std-decorators": {
-      "types": "./dist/std-decorators.d.ts",
-      "source": "./src/std-decorators.ts",
-      "import": "./dist/std-decorators.esm.js",
-      "require": "./dist/std-decorators.js"
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.esm.js",
+      "require": "./dist/node.js"
     },
     "./src": {
-      "import": "./src/index.ts"
-    },
-    "./src/*": {
-      "import": "./src/*"
+      "node": {
+        "types": "./src/async/node.ts",
+        "import": "./src/async/node.ts"
+      },
+      "default": {
+        "types": "./src/async/browser.ts",
+        "import": "./src/async/browser.ts"
+      }
     },
-    "./umd": {
-      "browser": "./dist/mutts.umd.js"
+    "./src/browser": {
+      "types": "./src/async/browser.ts",
+      "import": "./src/async/browser.ts"
     },
-    "./umd.min": {
-      "browser": "./dist/mutts.umd.min.js"
+    "./src/node": {
+      "types": "./src/async/node.ts",
+      "import": "./src/async/node.ts"
     }
   },
   "files": [
@@ -80,14 +59,14 @@
     "build": "npm run build:js && npm run build:devtools",
     "build:watch": "rollup -c --watch",
     "prepublishOnly": "npm run build",
-    "test": "node --expose-gc node_modules/.bin/jest",
-    "test:coverage": "node --expose-gc node_modules/.bin/jest --coverage",
-    "test:coverage:watch": "node --expose-gc node_modules/.bin/jest --coverage --watch",
-    "test:legacy": "TSCONFIG=tsconfig.legacy.json node node_modules/.bin/jest --detectOpenHandles --testPathPatterns=decorator",
-    "test:modern": "TSCONFIG=tsconfig.modern.json node node_modules/.bin/jest --detectOpenHandles --testPathPatterns=decorator",
-    "test:profile": "RUN_PROFILING=1 node --expose-gc node_modules/.bin/jest --testPathPatterns=profiling",
-    "test:profile:benchmark": "RUN_PROFILING=1 node --expose-gc node_modules/.bin/jest --testPathPatterns=profiling --testNamePattern=benchmark",
-    "test:profile:detailed": "RUN_PROFILING=1 node --prof node_modules/.bin/jest --testPathPatterns=profiling --no-coverage",
+    "test": "NODE_OPTIONS=--expose-gc jest",
+    "test:coverage": "NODE_OPTIONS=--expose-gc jest --coverage",
+    "test:coverage:watch": "NODE_OPTIONS=--expose-gc jest --coverage --watch",
+    "test:legacy": "TSCONFIG=tsconfig.legacy.json jest --detectOpenHandles --testPathPatterns=decorator",
+    "test:modern": "TSCONFIG=tsconfig.modern.json jest --detectOpenHandles --testPathPatterns=decorator",
+    "test:profile": "RUN_PROFILING=1 NODE_OPTIONS=--expose-gc jest --testPathPatterns=profiling",
+    "test:profile:benchmark": "RUN_PROFILING=1 NODE_OPTIONS=--expose-gc jest --testPathPatterns=profiling --testNamePattern=benchmark",
+    "test:profile:detailed": "RUN_PROFILING=1 node --prof node_modules/jest/bin/jest.js --testPathPatterns=profiling --no-coverage",
     "benchmark:save": "tsx tests/profiling/benchmark.ts save",
     "benchmark:compare": "tsx tests/profiling/benchmark.ts compare",
     "benchmark:list": "tsx tests/profiling/benchmark.ts list",
@@ -123,11 +102,14 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.0.6",
+    "@jest/globals": "^30.2.0",
     "@rollup/plugin-commonjs": "^28.0.6",
+    "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.1",
     "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-typescript": "^12.1.4",
     "@types/jest": "^30.0.0",
+    "@types/node": "^22.10.10",
     "jest": "^30.0.4",
     "rollup": "^4.52.2",
     "rollup-plugin-copy": "^3.5.0",