mutts 1.0.10 → 1.0.12

package/docs/reactive/advanced.md

@@ -5,7 +5,7 @@
 The `atomic` function wraps a function to batch all reactive effects triggered within it, ensuring effects run only once after the function completes. It can be used both as a function wrapper and as a decorator.
 
 ```typescript
-import { atomic, reactive, effect } from 'mutts/reactive'
+import { atomic, reactive, effect } from 'mutts'
 
 const state = reactive({ a: 0, b: 0 })
 
@@ -48,7 +48,7 @@ The wrapped function preserves its signature (parameters and return value), and
 While `atomic()` **wraps** a function for later calls, `atom()` **runs** a function immediately and atomically. It always executes right away, even inside a nested batch.
 
 ```typescript
-import { atom, reactive, effect } from 'mutts/reactive'
+import { atom, reactive, effect } from 'mutts'
 
 const state = reactive({ a: 0, b: 0 })
 
@@ -85,9 +85,9 @@ update(1, 2)  // runs when called
 When an effect needs to perform an action that would modify state the effect depends on, this can create a reactive cycle. The `addBatchCleanup` function (also exported as `defer` for semantic clarity) allows you to defer such work until after the current batch of effects completes.
 
 ```typescript
-import { addBatchCleanup, effect, reactive } from 'mutts/reactive'
+import { addBatchCleanup, effect, reactive } from 'mutts'
 // or use the semantic alias:
-// import { defer } from 'mutts/reactive'
+// import { defer } from 'mutts'
 
 const state = reactive({ 
   items: [],
@@ -298,7 +298,7 @@ effect(() => {
 Creates a bidirectional binding between a reactive value and a non-reactive external value (like DOM elements), automatically preventing infinite loops.
 
 ```typescript
-import { biDi, reactive } from 'mutts/reactive'
+import { biDi, reactive } from 'mutts'
 
 const model = reactive({ value: '' })
 
@@ -1142,15 +1142,14 @@ Mutts provides several ways to derive values from reactive state. They differ in
 | `lift(() => ({...}))` | Eager | Reactive object proxy | Yes (per-prop) | **Yes** | `result[cleanup]()` | Derived objects, computed shapes |
 | `morph(source, fn)` | **Lazy** | Reactive proxy | Yes (per-key) | **Yes** | `cleanedBy` | Lazy per-element map with identity tracking |
 | `morph.pure(source, fn)` | **Lazy** | Reactive proxy | Yes (per-key) | **Yes** | `cleanedBy` | Same, but skips per-item dependency tracking |
-| `scan(source, fn, init)` | Eager | Reactive array | Yes (per-index) | **Yes** | `result[cleanup]()` | Running accumulations (prefix sums) |
 | `when(() => cond)` | Eager | Promise\<T\> | N/A | N/A | Auto (on resolve/timeout) | Awaiting a reactive condition |
 | `watch(source, cb)` | Eager | Callback (old/new) | N/A | N/A | Auto (parent/GC) + Returned cleanup | Observing specific changes |
 
 ### Key distinctions
 
 - **Lazy vs Eager**: `memoize` only recomputes when the result is read. Everything else recomputes immediately when dependencies change — even if nobody is consuming the output.
-- **Trackable**: Can downstream effects depend on the result? `memoize`'s return value is trackable because calling it runs inside an effect context. `lift`/`morph`/`scan` return reactive proxies where each property/index is independently trackable.
-- **Identity stable**: `lift`, `morph`, and `scan` return the **same proxy** across recomputations — only changed slots are updated. This is critical for downstream transformations or DOM reconciliation that relies on reference identity.
+- **Trackable**: Can downstream effects depend on the result? `memoize`'s return value is trackable because calling it runs inside an effect context. `lift`/`morph` return reactive proxies where each property/index is independently trackable.
+- **Identity stable**: `lift` and `morph` return the **same proxy** across recomputations — only changed slots are updated. This is critical for downstream transformations or DOM reconciliation that relies on reference identity.
 
 ### Common patterns
 
@@ -1229,7 +1228,7 @@ state.items = fetchedItems // deep touch diffs old vs new per-index — no lift
 **Signature**
 
 ```typescript
-import { morph } from 'mutts/reactive'
+import { morph } from 'mutts'
 
 function morph<I, O>(
   source: readonly I[] | (() => readonly I[]),
@@ -1254,7 +1253,7 @@ function morph<I, O>(
 **Basic usage**
 
 ```typescript
-import { morph, reactive, effect } from 'mutts/reactive'
+import { morph, reactive, effect } from 'mutts'
 
 const items = reactive(['alice', 'bob', 'charlie'])
 const upper = morph(items, name => name.toUpperCase())
@@ -1355,7 +1354,7 @@ pure[0]     // 10 — stale, no per-item effect to invalidate
 **Signature**
 
 ```typescript
-import { memoize } from 'mutts/reactive'
+import { memoize } from 'mutts'
 
 type Memoizable = object | any[] | symbol
 
@@ -1380,7 +1379,7 @@ function memoize<Result>(
 **Basic usage**
 
 ```typescript
-import { effect, memoize, reactive } from 'mutts/reactive'
+import { effect, memoize, reactive } from 'mutts'
 
 const source = reactive({ value: 1 })
 const args = { node: source }
@@ -1426,7 +1425,7 @@ Use `maxArgs` when the memoized function should only consider the first _n_ argu
 A flavored variant that gracefully handles non-WeakKey arguments (primitives, `null`, `undefined`). Instead of throwing, it falls back to recomputing the function without caching.
 
 ```typescript
-import { memoize } from 'mutts/reactive'
+import { memoize } from 'mutts'
 
 const process = memoize.lenient((value: string | { data: string }) => {
   return typeof value === 'string' ? value.toUpperCase() : value.data
@@ -1447,7 +1446,7 @@ This is useful when a memoized function may receive both objects and primitives,
 Apply `@memoize` (or `@memoize.lenient`) to class getters or methods to share the same cache semantics. Getters cache per instance; methods cache per instance and argument tuple.
 
 ```typescript
-import { memoize, reactive } from 'mutts/reactive'
+import { memoize, reactive } from 'mutts'
 
 class Example {
   state = reactive({ count: 0 })

package/docs/reactive/attend.md

@@ -137,6 +137,5 @@ attend(
 | `attend` | — | Reactive lifecycle per key |
 | `organized` | ✅ | Reactive record mapping with access objects |
 | `project` | ❌ | Reactive collection mapping (manages a target + projection context) |
-| `scan` | ❌ | Reactive accumulation (sequential key dependency) |
 
-`project` and `scan` have additional concerns (target management, sequential dependencies) that go beyond `attend`'s independent-key lifecycle model.
+`project` has additional concerns (target management) that go beyond `attend`'s independent-key lifecycle model.

package/docs/reactive/collections.md

@@ -259,153 +259,6 @@ effect(() => {
 })
 ```
 
-### `Register`
-
-`Register` is an ordered, array-like collection that keeps a stable mapping between keys and values. It is useful when you need array semantics (indexable access, ordering, iteration) but also require identity preservation by key—ideal for UI lists keyed by IDs or when you want to memoise entries across reorders.
-
-```typescript
-import { Register } from 'mutts/reactive'
-
-// Create a register where the key comes from the `id` field
-const list = new Register(({id}: { id: number }) => id, [
-    { id: 1, label: 'Alpha' },
-    { id: 2, label: 'Bravo' },
-])
-
-effect(() => {
-    console.log('Length:', list.length)
-    console.log('First label:', list[0]?.label)
-})
-
-// Push uses the key function to keep identities stable
-list.push({ id: 3, label: 'Charlie' })
-
-// Replacing with the same key updates watchers without creating a new identity
-list[0] = { id: 1, label: 'Alpha (updated)' }
-
-// Access by key
-const second = list.get(2) // { id: 2, label: 'Bravo' }
-
-// Duplicate keys share value identity
-list.push({ id: 2, label: 'Bravo (new data)' })
-console.log(list[1] === list[2]) // true
-```
-
-**Highlights:**
-
-- Fully indexable (`list[0]`, `list.at(-1)`, `list.length`, iteration, etc.) thanks to the shared `Indexable` infrastructure.
-- Complete array surface forwarding (`map`, `filter`, `reduce`, `concat`, `reverse`, `sort`, `fill`, `copyWithin`, and more) with reactivity preserved.
-- Stable key/value map under the hood allows quick lookups via `get()`, `hasKey()`, and `indexOfKey()`.
-- When the same key appears multiple times, all slots reference the same underlying value instance, making deduplication and memoisation straightforward.
-- Reordering operations emit index-level touches so list reactivity remains predictable in rendered UIs.
-
-### Register-specific API (beyond Array)
-
-The `Register` exposes additional methods and behaviors that standard arrays do not have:
-
-- `get(key)` / `set(key, value)`
-  - `get(key: K): T | undefined` returns the latest value for a key.
-  - `set(key: K, value: T): void` updates the value for an existing key (no-op if key absent).
-  - Example:
-  ```typescript
-  list.set(2, { id: 2, label: 'Bravo (updated)' })
-  const v = list.get(2)
-  ```
-
-- `hasKey(key)` / `indexOfKey(key)`
-  - `hasKey(key: K): boolean` whether the key is present in any slot.
-  - `indexOfKey(key: K): number` first index at which the key appears, or `-1`.
-
-- `remove(key)` / `removeAt(index)`
-  - `remove(key: K): void` removes all occurrences of `key` from the register.
-  - `removeAt(index: number): T | undefined` removes a single slot by index and returns its value.
-
-- `keep(predicate)`
-  - `keep(predicate: (value: T) => boolean): void` keeps only items for which the predicate returns `true`; items for which it returns `false` are removed. The predicate is evaluated once per distinct key; duplicate keys follow the same decision.
-
-- `update(...values)`
-  - `update(...values: T[]): void` updates existing entries by their key; ignores values whose key is not yet present.
-
-- `upsert(insert, ...values)`
-  - `upsert(insert: (value: T) => void, ...values: T[]): void` updates by key when present, otherwise calls `insert(value)` so you can decide how to insert (e.g. `push`, `unshift`, or `splice`).
-  - Example:
-  ```typescript
-  list.upsert(v => list.push(v), { id: 4, label: 'Delta' }, { id: 2, label: 'Bravo (again)' })
-  ```
-
-- `entries()`
-  - Iterates `[number, value]` pairs in index order: `IterableIterator<[number, T | undefined]>`.
-
-- `keys` / `values`
-  - `keys: ArrayIterator<number>` provides the index iterator (mirrors `Array#keys()`).
-  - `values: IterableIterator<T>` provides an iterator of values (same as default iteration).
-
-- `clear()`
-  - Removes all entries and disposes internal key-tracking effects.
-
-- `toArray()` / `toString()`
-  - `toArray(): T[]` materializes the current values into a plain array.
-  - `toString(): string` returns a concise description like `[Register length=3]`.
-
-### Register CRUD Events
-
-`Register` emits lifecycle events for add, delete, update, and rekey operations. This enables side effects like logging, syncing with external systems, or triggering derived updates.
-
-```typescript
-const list = register(({id}: { id: number }) => id)
-
-// Listen to individual events
-list.on('add', (item, key, index) => {
-    console.log(`Added ${key} at index ${index}:`, item)
-})
-
-list.on('delete', (item, key, index) => {
-    console.log(`Removed ${key} from index ${index}:`, item)
-})
-
-list.on('update', (oldItem, newItem, key, index) => {
-    console.log(`Updated ${key} at index ${index}`)
-})
-
-list.on('rekey', (item, oldKey, newKey, index) => {
-    console.log(`Key changed from ${oldKey} to ${newKey}`)
-})
-
-// Bulk event registration
-list.on({
-    add: (item) => console.log('Added:', item),
-    delete: (item) => console.log('Deleted:', item),
-})
-
-// Global hook - receive all events
-const unhook = list.hook((event, ...args) => {
-    console.log(`Event: ${String(event)}`, args)
-})
-
-// Unsubscribe
-const unsubscribe = list.on('add', handler)
-unsubscribe()
-```
-
-**Event Types:**
-
-| Event | Arguments | Description |
-|-------|-----------|-------------|
-| `add` | `(item, key, index)` | New item added to register |
-| `delete` | `(item, key, index)` | Item removed from register |
-| `update` | `(oldItem, newItem, key, index)` | Item value updated (same key) |
-| `rekey` | `(item, oldKey, newKey, index)` | Item's key changed |
-
-**Use Cases:**
-- Audit logging
-- Syncing with databases
-- Triggering notifications
-- Cascading updates to dependent systems
-
-Notes:
-- Direct length modification via `list.length = n` is not supported; use `splice` instead.
-- Assigning to an index (`list[i] = value`) uses the key function to bind that slot to `value`’s key.
-
 ## Class Reactivity
 
 ## Morphing
@@ -417,7 +270,7 @@ Notes:
 #### Basic Usage
 
 ```typescript
-import { cleanup, morph, reactive } from 'mutts/reactive'
+import { cleanup, morph, reactive } from 'mutts'
 
 // Arrays
 const users = reactive([{ name: 'John', age: 30 }, { name: 'Jane', age: 25 }])
@@ -548,7 +401,7 @@ result[cleanup]() // Stops all effects and cleans up
 ### `organized()`
 
 ```typescript
-import { cleanup, organized, reactive } from 'mutts/reactive'
+import { cleanup, organized, reactive } from 'mutts'
 
 const source = reactive<Record<string, number>>({ apples: 1, oranges: 2 })