mutts 1.0.6 → 1.0.7

package/dist/node.d.ts

@@ -0,0 +1,2 @@
+
+export { };

package/dist/node.esm.js

@@ -0,0 +1,45 @@
+import { createHook } from 'node:async_hooks';
+import { a as asyncHooks } from './chunks/index-CNR6QRUl.esm.js';
+export { A as AZone, b as ArrayReadForward, D as DecoratorError, c as Destroyable, d as DestructionError, E as Eventful, F as FoolProof, I as Indexable, e as IterableWeakMap, f as IterableWeakSet, R as ReactiveBase, g as ReactiveError, h as ReactiveErrorCode, i as Register, Z as Zone, j as ZoneAggregator, k as ZoneHistory, l as addBatchCleanup, m as allocated, n as allocatedValues, o as arrayEquals, p as asyncZone, q as atomic, r as biDi, s as buildReactivityGraph, t as cache, u as cached, v as callOnGC, w as chainPromise, x as cleanedBy, y as cleanup, z as contentRef, B as debounce, C as decorator, G as deepCompare, H as deepWatch, J as defer, K as deprecated, L as derived, M as describe, N as destructor, O as effect, P as enableDevTools, Q as forwardArray, S as getActivationLog, T as getActiveProjection, U as getAt, V as getState, W as immutables, X as isCached, Y as isConstructor, _ as isDevtoolsEnabled, $ as isNonReactive, a0 as isOwnAccessor, a1 as isReactive, a2 as legacyDecorator, a3 as memoize, a4 as mixin, a5 as modernDecorator, a6 as named, a7 as organize, a8 as organized, a9 as profileInfo, aa as project, ab as reactive, ac as reactiveOptions, ad as register, ae as registerEffectForDebug, af as registerNativeReactivity, ag as registerObjectForDebug, ah as renamed, ai as root, aj as scan, ak as setAt, al as setEffectName, am as setObjectName, an as tag, ao as throttle, ap as touched, aq as touched1, ar as trackEffect, as as unreactive, at as untracked, au as unwrap, av as watch, aw as zip } from './chunks/index-CNR6QRUl.esm.js';
+
+const hooks = new Set();
+const restorersPerAsyncId = new Map();
+const undoersPerAsyncId = new Map();
+createHook({
+    init(asyncId) {
+        const restorers = new Set();
+        for (const hook of hooks) {
+            restorers.add(hook());
+        }
+        restorersPerAsyncId.set(asyncId, restorers);
+    },
+    before(asyncId) {
+        const restorers = restorersPerAsyncId.get(asyncId);
+        if (restorers) {
+            const undoers = new Set();
+            for (const restore of restorers) {
+                undoers.add(restore());
+            }
+            undoersPerAsyncId.set(asyncId, undoers);
+        }
+    },
+    after(asyncId) {
+        const undoers = undoersPerAsyncId.get(asyncId);
+        if (undoers) {
+            for (const undo of undoers)
+                undo();
+            undoersPerAsyncId.delete(asyncId);
+        }
+    },
+    destroy(asyncId) {
+        restorersPerAsyncId.delete(asyncId);
+        undoersPerAsyncId.delete(asyncId);
+    }
+}).enable();
+asyncHooks.addHook = function (hook) {
+    hooks.add(hook);
+    return () => {
+        hooks.delete(hook);
+    };
+};
+//# sourceMappingURL=node.esm.js.map

package/dist/node.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.esm.js","sources":["../src/async/node.ts"],"sourcesContent":["import { createHook } from 'node:async_hooks'\nimport { Hook, Restorer, asyncHooks } from '.'\n\nconst hooks = new Set<Hook>()\nconst restorersPerAsyncId = new Map<number, Set<Restorer>>()\nconst undoersPerAsyncId = new Map<number, Set<() => void>>()\n\ncreateHook({\n\tinit(asyncId) {\n\t\tconst restorers = new Set<Restorer>()\n\t\tfor (const hook of hooks) {\n\t\t\trestorers.add(hook())\n\t\t}\n\t\trestorersPerAsyncId.set(asyncId, restorers)\n\t},\n\tbefore(asyncId) {\n\t\tconst restorers = restorersPerAsyncId.get(asyncId)\n\t\tif (restorers) {\n\t\t\tconst undoers = new Set<() => void>()\n\t\t\tfor (const restore of restorers) {\n\t\t\t\tundoers.add(restore())\n\t\t\t}\n\t\t\tundoersPerAsyncId.set(asyncId, undoers)\n\t\t}\n\t},\n\tafter(asyncId) {\n\t\tconst undoers = undoersPerAsyncId.get(asyncId)\n\t\tif (undoers) {\n\t\t\tfor (const undo of undoers) undo()\n\t\t\tundoersPerAsyncId.delete(asyncId)\n\t\t}\n\t},\n\tdestroy(asyncId) {\n\t\trestorersPerAsyncId.delete(asyncId)\n\t\tundoersPerAsyncId.delete(asyncId)\n\t}\n}).enable()\n\nasyncHooks.addHook = function (hook: Hook) {\n\thooks.add(hook)\n\treturn () => {\n\t\thooks.delete(hook)\n\t}\n}\n\nexport * from '../index'\n"],"names":[],"mappings":";;;;AAGA,MAAM,KAAK,GAAG,IAAI,GAAG,EAAQ;AAC7B,MAAM,mBAAmB,GAAG,IAAI,GAAG,EAAyB;AAC5D,MAAM,iBAAiB,GAAG,IAAI,GAAG,EAA2B;AAE5D,UAAU,CAAC;AACV,IAAA,IAAI,CAAC,OAAO,EAAA;AACX,QAAA,MAAM,SAAS,GAAG,IAAI,GAAG,EAAY;AACrC,QAAA,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;AACzB,YAAA,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;QACtB;AACA,QAAA,mBAAmB,CAAC,GAAG,CAAC,OAAO,EAAE,SAAS,CAAC;IAC5C,CAAC;AACD,IAAA,MAAM,CAAC,OAAO,EAAA;QACb,MAAM,SAAS,GAAG,mBAAmB,CAAC,GAAG,CAAC,OAAO,CAAC;QAClD,IAAI,SAAS,EAAE;AACd,YAAA,MAAM,OAAO,GAAG,IAAI,GAAG,EAAc;AACrC,YAAA,KAAK,MAAM,OAAO,IAAI,SAAS,EAAE;AAChC,gBAAA,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;YACvB;AACA,YAAA,iBAAiB,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC;QACxC;IACD,CAAC;AACD,IAAA,KAAK,CAAC,OAAO,EAAA;QACZ,MAAM,OAAO,GAAG,iBAAiB,CAAC,GAAG,CAAC,OAAO,CAAC;QAC9C,IAAI,OAAO,EAAE;YACZ,KAAK,MAAM,IAAI,IAAI,OAAO;AAAE,gBAAA,IAAI,EAAE;AAClC,YAAA,iBAAiB,CAAC,MAAM,CAAC,OAAO,CAAC;QAClC;IACD,CAAC;AACD,IAAA,OAAO,CAAC,OAAO,EAAA;AACd,QAAA,mBAAmB,CAAC,MAAM,CAAC,OAAO,CAAC;AACnC,QAAA,iBAAiB,CAAC,MAAM,CAAC,OAAO,CAAC;IAClC;CACA,CAAC,CAAC,MAAM,EAAE;AAEX,UAAU,CAAC,OAAO,GAAG,UAAU,IAAU,EAAA;AACxC,IAAA,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC;AACf,IAAA,OAAO,MAAK;AACX,QAAA,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC;AACnB,IAAA,CAAC;AACF,CAAC"}

package/dist/node.js

@@ -0,0 +1,136 @@
+'use strict';
+
+var node_async_hooks = require('node:async_hooks');
+var index = require('./chunks/index-BFYK02LG.js');
+
+const hooks = new Set();
+const restorersPerAsyncId = new Map();
+const undoersPerAsyncId = new Map();
+node_async_hooks.createHook({
+    init(asyncId) {
+        const restorers = new Set();
+        for (const hook of hooks) {
+            restorers.add(hook());
+        }
+        restorersPerAsyncId.set(asyncId, restorers);
+    },
+    before(asyncId) {
+        const restorers = restorersPerAsyncId.get(asyncId);
+        if (restorers) {
+            const undoers = new Set();
+            for (const restore of restorers) {
+                undoers.add(restore());
+            }
+            undoersPerAsyncId.set(asyncId, undoers);
+        }
+    },
+    after(asyncId) {
+        const undoers = undoersPerAsyncId.get(asyncId);
+        if (undoers) {
+            for (const undo of undoers)
+                undo();
+            undoersPerAsyncId.delete(asyncId);
+        }
+    },
+    destroy(asyncId) {
+        restorersPerAsyncId.delete(asyncId);
+        undoersPerAsyncId.delete(asyncId);
+    }
+}).enable();
+index.asyncHooks.addHook = function (hook) {
+    hooks.add(hook);
+    return () => {
+        hooks.delete(hook);
+    };
+};
+
+exports.AZone = index.AZone;
+exports.ArrayReadForward = index.ArrayReadForward;
+exports.DecoratorError = index.DecoratorError;
+exports.Destroyable = index.Destroyable;
+exports.DestructionError = index.DestructionError;
+exports.Eventful = index.Eventful;
+exports.FoolProof = index.FoolProof;
+exports.Indexable = index.Indexable;
+exports.IterableWeakMap = index.IterableWeakMap;
+exports.IterableWeakSet = index.IterableWeakSet;
+exports.ReactiveBase = index.ReactiveBase;
+exports.ReactiveError = index.ReactiveError;
+Object.defineProperty(exports, "ReactiveErrorCode", {
+	enumerable: true,
+	get: function () { return index.ReactiveErrorCode; }
+});
+exports.Register = index.Register;
+exports.Zone = index.Zone;
+exports.ZoneAggregator = index.ZoneAggregator;
+exports.ZoneHistory = index.ZoneHistory;
+exports.addBatchCleanup = index.addBatchCleanup;
+exports.allocated = index.allocated;
+exports.allocatedValues = index.allocatedValues;
+exports.arrayEquals = index.arrayEquals;
+exports.asyncZone = index.asyncZone;
+exports.atomic = index.atomic;
+exports.biDi = index.biDi;
+exports.buildReactivityGraph = index.buildReactivityGraph;
+exports.cache = index.cache;
+exports.cached = index.cached;
+exports.callOnGC = index.callOnGC;
+exports.chainPromise = index.chainPromise;
+exports.cleanedBy = index.cleanedBy;
+exports.cleanup = index.cleanup;
+exports.contentRef = index.contentRef;
+exports.debounce = index.debounce;
+exports.decorator = index.decorator;
+exports.deepCompare = index.deepCompare;
+exports.deepWatch = index.deepWatch;
+exports.defer = index.defer;
+exports.deprecated = index.deprecated;
+exports.derived = index.derived;
+exports.describe = index.describe;
+exports.destructor = index.destructor;
+exports.effect = index.effect;
+exports.enableDevTools = index.enableDevTools;
+exports.forwardArray = index.forwardArray;
+exports.getActivationLog = index.getActivationLog;
+exports.getActiveProjection = index.getActiveProjection;
+exports.getAt = index.getAt;
+exports.getState = index.getState;
+exports.immutables = index.immutables;
+exports.isCached = index.isCached;
+exports.isConstructor = index.isConstructor;
+exports.isDevtoolsEnabled = index.isDevtoolsEnabled;
+exports.isNonReactive = index.isNonReactive;
+exports.isOwnAccessor = index.isOwnAccessor;
+exports.isReactive = index.isReactive;
+exports.legacyDecorator = index.legacyDecorator;
+exports.memoize = index.memoize;
+exports.mixin = index.mixin;
+exports.modernDecorator = index.modernDecorator;
+exports.named = index.named;
+exports.organize = index.organize;
+exports.organized = index.organized;
+exports.profileInfo = index.profileInfo;
+exports.project = index.project;
+exports.reactive = index.reactive;
+exports.reactiveOptions = index.options;
+exports.register = index.register;
+exports.registerEffectForDebug = index.registerEffectForDebug;
+exports.registerNativeReactivity = index.registerNativeReactivity;
+exports.registerObjectForDebug = index.registerObjectForDebug;
+exports.renamed = index.renamed;
+exports.root = index.root;
+exports.scan = index.scan;
+exports.setAt = index.setAt;
+exports.setEffectName = index.setEffectName;
+exports.setObjectName = index.setObjectName;
+exports.tag = index.tag;
+exports.throttle = index.throttle;
+exports.touched = index.touched;
+exports.touched1 = index.touched1;
+exports.trackEffect = index.trackEffect;
+exports.unreactive = index.unreactive;
+exports.untracked = index.untracked;
+exports.unwrap = index.unwrap;
+exports.watch = index.watch;
+exports.zip = index.zip;
+//# sourceMappingURL=node.js.map

package/dist/node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.js","sources":["../src/async/node.ts"],"sourcesContent":["import { createHook } from 'node:async_hooks'\nimport { Hook, Restorer, asyncHooks } from '.'\n\nconst hooks = new Set<Hook>()\nconst restorersPerAsyncId = new Map<number, Set<Restorer>>()\nconst undoersPerAsyncId = new Map<number, Set<() => void>>()\n\ncreateHook({\n\tinit(asyncId) {\n\t\tconst restorers = new Set<Restorer>()\n\t\tfor (const hook of hooks) {\n\t\t\trestorers.add(hook())\n\t\t}\n\t\trestorersPerAsyncId.set(asyncId, restorers)\n\t},\n\tbefore(asyncId) {\n\t\tconst restorers = restorersPerAsyncId.get(asyncId)\n\t\tif (restorers) {\n\t\t\tconst undoers = new Set<() => void>()\n\t\t\tfor (const restore of restorers) {\n\t\t\t\tundoers.add(restore())\n\t\t\t}\n\t\t\tundoersPerAsyncId.set(asyncId, undoers)\n\t\t}\n\t},\n\tafter(asyncId) {\n\t\tconst undoers = undoersPerAsyncId.get(asyncId)\n\t\tif (undoers) {\n\t\t\tfor (const undo of undoers) undo()\n\t\t\tundoersPerAsyncId.delete(asyncId)\n\t\t}\n\t},\n\tdestroy(asyncId) {\n\t\trestorersPerAsyncId.delete(asyncId)\n\t\tundoersPerAsyncId.delete(asyncId)\n\t}\n}).enable()\n\nasyncHooks.addHook = function (hook: Hook) {\n\thooks.add(hook)\n\treturn () => {\n\t\thooks.delete(hook)\n\t}\n}\n\nexport * from '../index'\n"],"names":["createHook","asyncHooks"],"mappings":";;;;;AAGA,MAAM,KAAK,GAAG,IAAI,GAAG,EAAQ;AAC7B,MAAM,mBAAmB,GAAG,IAAI,GAAG,EAAyB;AAC5D,MAAM,iBAAiB,GAAG,IAAI,GAAG,EAA2B;AAE5DA,2BAAU,CAAC;AACV,IAAA,IAAI,CAAC,OAAO,EAAA;AACX,QAAA,MAAM,SAAS,GAAG,IAAI,GAAG,EAAY;AACrC,QAAA,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;AACzB,YAAA,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;QACtB;AACA,QAAA,mBAAmB,CAAC,GAAG,CAAC,OAAO,EAAE,SAAS,CAAC;IAC5C,CAAC;AACD,IAAA,MAAM,CAAC,OAAO,EAAA;QACb,MAAM,SAAS,GAAG,mBAAmB,CAAC,GAAG,CAAC,OAAO,CAAC;QAClD,IAAI,SAAS,EAAE;AACd,YAAA,MAAM,OAAO,GAAG,IAAI,GAAG,EAAc;AACrC,YAAA,KAAK,MAAM,OAAO,IAAI,SAAS,EAAE;AAChC,gBAAA,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;YACvB;AACA,YAAA,iBAAiB,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC;QACxC;IACD,CAAC;AACD,IAAA,KAAK,CAAC,OAAO,EAAA;QACZ,MAAM,OAAO,GAAG,iBAAiB,CAAC,GAAG,CAAC,OAAO,CAAC;QAC9C,IAAI,OAAO,EAAE;YACZ,KAAK,MAAM,IAAI,IAAI,OAAO;AAAE,gBAAA,IAAI,EAAE;AAClC,YAAA,iBAAiB,CAAC,MAAM,CAAC,OAAO,CAAC;QAClC;IACD,CAAC;AACD,IAAA,OAAO,CAAC,OAAO,EAAA;AACd,QAAA,mBAAmB,CAAC,MAAM,CAAC,OAAO,CAAC;AACnC,QAAA,iBAAiB,CAAC,MAAM,CAAC,OAAO,CAAC;IAClC;CACA,CAAC,CAAC,MAAM,EAAE;AAEXC,gBAAU,CAAC,OAAO,GAAG,UAAU,IAAU,EAAA;AACxC,IAAA,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC;AACf,IAAA,OAAO,MAAK;AACX,QAAA,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC;AACnB,IAAA,CAAC;AACF,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/docs/ai/api-reference.md

@@ -68,8 +68,6 @@ export interface Register<T, K extends PropertyKey = PropertyKey> extends Iterab
 }
 
 export declare function register<T, K extends PropertyKey = PropertyKey>(keyFn: (item: T) => K, initial?: Iterable<T>): Register<T, K>;
-export declare function mapped<T, U>(inputs: readonly T[], compute: (input: T, index: number, output: U[]) => U): readonly U[];
-export declare function reduced<T, U, R extends object = any>(inputs: readonly T[], compute: (input: T, factor: R) => readonly U[]): readonly U[];
 export declare function project<S, R>(source: S, apply: (access: any, target: any) => any): R;
 export declare function organized<S, T>(source: S, apply: (access: any, target: T) => any, baseTarget?: T): T;
 

package/docs/reactive/advanced.md

@@ -1161,10 +1161,6 @@ class Example {
 }
 ```
 
-### Working with `mapped()`
-
-Pair `memoize()` with [`mapped()`](#mapped) to keep derived array elements stable across reorders (see [Identity-preserving mapped arrays](#identity-preserving-mapped-arrays)). Memoizing the mapper ensures each input object is processed at most once and its derived state persists while the input reference lives.
-
 ## Debugging and Development
 
 The `mutts` reactive system includes built-in tools for troubleshooting complex dependency graphs and identifying performance bottlenecks.
@@ -1173,7 +1169,8 @@ For a full guide on debugging, including cycle detection and memoization discrep
 
 ### Quick Summary
 
-- **Cycle Detection**: Automatically catch circular dependencies via `reactiveOptions.cycleHandling`.
+- **Cycle Detection**: Automatically catch circular dependencies via `reactiveOptions.cycleHandling`. Note: Instant mathematical detection requires choosing a mode other than `'none'`.
+- **Flat Mode**: The default `reactiveOptions.cycleHandling = 'none'` provides maximum performance in high-frequency update scenarios by disabling graph maintenance.
 - **Memoization Discrepancy**: Detect "missing dependencies" by running computations twice during development using `reactiveOptions.onMemoizationDiscrepancy`.
 - **Global Hooks**: Use `reactiveOptions.touched`, `enter`, and `leave` to observe system activity.
 

package/docs/reactive/collections.md

@@ -352,115 +352,6 @@ Notes:
 - Assigning to an index (`list[i] = value`) uses the key function to bind that slot to `value`’s key.
 
 ## Class Reactivity
-## Array Mapping
-
-### `mapped()`
-
-Creates a reactive array by mapping over an input array. The mapper receives the current item value, its index, and the previous mapped value for that index.
-
-```typescript
-import { mapped, reactive } from 'mutts/reactive'
-
-const input = reactive([1, 2, 3])
-const doubles = mapped(input, (value, index, oldValue) => value * 2)
-
-console.log(doubles) // [2, 4, 6]
-
-// When input changes, the mapped output updates in place
-input.push(4)
-console.log(doubles) // [2, 4, 6, 8]
-```
-
-**Mapper signature:**
-
-```typescript
-(value: T, index: number, oldValue?: U) => U
-```
-
-- **value**: current element from the input array
-- **index**: current element index
-- **oldValue**: previously computed value at the same index (useful for incremental updates)
-
-**Key features:**
-
-- **Live reactivity**: Output array updates when the input array changes (push/pop/splice/assignments).
-- **Granular recompute**: Only indices that change are recomputed; `oldValue` enables incremental updates.
-- **Simple contract**: Mapper works directly with `(value, index, oldValue)` and can freely return reactive objects.
-
-**Performance characteristics:**
-
-```typescript
-const users = reactive([
-  { name: 'John', age: 30 },
-  { name: 'Jane', age: 25 }
-])
-
-let computeCount = 0
-const processedUsers = mapped(users, (user) => {
-  computeCount++
-  return `${user.name} (${user.age})`
-})
-
-console.log(computeCount) // 2 (initial computation)
-
-// Modify one user - only that index recomputes
-users[0].age = 31
-console.log(processedUsers[0]) // "John (31)"
-console.log(computeCount) // 3
-```
-
-**Advanced usage:**
-
-```typescript
-const orders = reactive([
-  { items: [{ price: 10 }, { price: 20 }] },
-  { items: [{ price: 15 }] }
-])
-
-const orderTotals = mapped(orders, (order) => (
-  order.items.reduce((sum, item) => sum + item.price, 0)
-))
-```
-
-### Identity-preserving mapped arrays
-
-Combine `mapped()` with [`memoize()`](#memoize) when you need to reuse mapped results for the same input identity. The memoized mapper runs at most once per input object, even when the source array is reordered, and it can host additional reactive state that should survive reordering.
-
-```typescript
-import { effect, mapped, memoize, reactive } from 'mutts/reactive'
-
-const inputs = reactive([{ name: 'John' }, { name: 'Jane' }])
-
-const memoizedCard = memoize((user: { name: string }) => {
-  const view: { name?: string; setName(next: string): void } = {
-    setName(next) {
-      user.name = next
-    },
-  }
-
-  effect(() => {
-    view.name = user.name.toUpperCase()
-  })
-
-  return view
-})
-
-const cards = mapped(inputs, (user) => memoizedCard(user))
-
-cards[0].setName('Johnny')
-console.log(cards[0].name) // 'JOHNNY'
-
-// Reorder: cached output follows the original object
-const first = inputs.shift()!
-inputs.push(first)
-console.log(cards[1].name) // still 'JOHNNY'
-```
-
-Use this pattern when:
-
-- You are mapping an array of reactive objects and want to keep derived objects stable across reorders.
-- The mapper returns objects with internal state or nested effects that should survive reordering.
-- You prefer to share memoized helpers across multiple mapped arrays.
 
 ## Projection
 
@@ -468,8 +359,6 @@ Use this pattern when:
 
 `project()` provides a unified API for transforming reactive collections (arrays, records, and maps) into new reactive collections. Each source entry gets its own reactive effect that recomputes only when that specific entry changes, enabling granular updates perfect for rendering pipelines.
 
-**Note:** `project()` is the modern replacement for `mapped()`. It offers the same per-entry reactivity benefits but works across all collection types with a consistent API.
-
 #### Basic Usage
 
 ```typescript
@@ -617,23 +506,10 @@ result[cleanup]() // Stops all effects and cleans up
 - **Data Transformation**: Convert between collection types while maintaining reactivity
 - **Performance Optimization**: Avoid full recomputation when only a few entries change
 
-#### Comparison with `mapped()`
-
-`project()` is designed to eventually replace `mapped()`. Key differences:
-
-- **Unified API**: Works with arrays, records, and maps (vs. `mapped()` only for arrays)
-- **Access Pattern**: Uses an access object with `get()`/`set()` instead of direct value/index parameters
-- **Automatic Target Creation**: Creates its own reactive target container (no need to provide a base target)
-- **Consistent Behavior**: Same per-entry reactivity model across all collection types
-
-For new code, prefer `project()` over `mapped()`. Existing `mapped()` code will continue to work, but consider migrating for better consistency and future features.
-
 ## Record Organization
 
 ### `organized()`
 
-`organized()` is the record companion to [`mapped()`](#mapped). Instead of iterating over numeric indices, it reacts to property additions, updates, and deletions on any `Record<PropertyKey, T>` (plain objects, dictionaries, even reactive proxies) and lets you build **whatever target structure you need**—a new record, nested buckets, a `Map`, or a more elaborate object with metadata.
-
 ```typescript
 import { cleanup, organized, reactive } from 'mutts/reactive'
 
@@ -677,7 +553,6 @@ function organized<
 
 Under the hood there is:
 
-- One effect watching `Reflect.ownKeys(source)` (similar to how `mapped()` tracks `length`)
 - A child effect per key that re-runs whenever that key’s value changes, automatically reusing and replacing the cleanup you returned.
 - Automatic disposal when keys disappear or when `target[cleanup]()` is invoked.
 

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

@@ -25,7 +25,7 @@ These hooks are called during the execution of effects and computed values.
 
 - **`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.
+- **`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
 
@@ -35,11 +35,21 @@ These hooks are called during the execution of effects and computed values.
 
 You can control how cycles are handled via `reactiveOptions.cycleHandling`:
 
-- **`'throw'`** (Default): Throws a `ReactiveError` with a detailed path.
+- **`'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.

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

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