@lazily-hub/lazily-js 0.14.0 → 0.16.0

package/README.md

@@ -39,18 +39,20 @@ notes and platform carve-outs lives in
 | Feature | Rust | Python | Kotlin | JS | Dart | Zig | Go | C++ |
 | --------- | :----: | :------: | :------: | :--: | :----: | :---: | :--: | :---: |
 | Reactive graph — `Cell` / `Slot` / `Signal` / `Effect` / memo / batch | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
-| Reactive family (`ReactiveFamily`) — keyed cell/slot family + materialization mode (`#lzmatmode`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
-| Thread-safe reactive family (`ThreadSafeReactiveFamily`) — `Send + Sync` keyed family + materialization confluence (`#lzmatmode`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
-| Async reactive family (`AsyncReactiveFamily`) — keyed family + eventual transparency (`#lzmatmode`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
-| Reactive family sync — membership propagation + materialize-on-ingest + derived-aggregate transparency (`#lzfamilysync`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Keyed-map materialization (`SlotMap`) — mint-on-access derived slots: transparency + deferral (`#lzmatmode`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Thread-safe keyed map (`ThreadSafeSlotMap`) — `Send + Sync` + materialization confluence (`#lzmatmode`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Async keyed map (`AsyncSlotMap`) — eventual transparency (`#lzmatmode`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Keyed-map sync — membership propagation + materialize-on-ingest + derived-aggregate transparency (`#lzfamilysync`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | Thread-safe context (lock-backed) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | Async reactive context | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | Flat state machine | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | Harel state charts | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
-| Keyed cell collections (`CellMap` / `CellTree`) + reconcile | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Keyed reactive maps (`ReactiveMap`: `CellMap` / `SlotMap`) + `CellTree` + reconcile | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | Memoized semantic tree (`SemTree`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | Stable-id alignment (manufactured identity) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | Reactive queue (`QueueCell` SPSC/MPSC + `QueueStorage` adapter) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Merge algebra + `MergeCell` — associative `MergePolicy` (`KeepLatest`/`Sum`/`Max`/`SetUnion`/`RawFifo`), `Cell ≡ MergeCell<KeepLatest>`, `Reactive`/`Source` split (`#relaycell`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| RelayCell — conflating relay + `BackpressurePolicy` + `SpillStore` + `Transport` + Inbox/Outbox + Rate/Window/Expiry/Priority/keyed policies (`#relaycell`) | ✅ | — | — | ✅ | — | — | — | — |
 | Free-text character CRDT (`TextCrdt`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | `TextCrdt` delta sync (`version_vector` / `delta_since` / `apply_delta`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | Move-aware sequence CRDT (`SeqCrdt`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
@@ -62,8 +64,8 @@ notes and platform carve-outs lives in
 | Shared-memory blob path (`ShmBlobArena`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | Cross-process zero-copy transport (`BlobBackend` / shm / arrow) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | Distributed CRDT plane (`CrdtPlaneRuntime` / anti-entropy) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
-| Reliable sync — resync coordinator + at-least-once durable outbox + OR-set/LWW liveness (`#lzsync`) | ✅ | — | ✅ | ✅ | — | — | — | — |
-| Reliable-sync transport seam + full-duplex `SyncDriver` loop (`IpcSink`/`IpcSource`, `#sync-driver`) | ✅ | — | ✅ | ✅ | — | — | — | — |
+| Reliable sync — resync coordinator + at-least-once durable outbox + OR-set/LWW liveness (`#lzsync`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Reliable-sync transport seam + full-duplex `SyncDriver` loop (`IpcSink`/`IpcSource`, `#sync-driver`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | Distributed plane — WebRTC transport + signaling | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | State projection / mirror | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | Causal receipts (`CausalReceipts` outcome projection) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
@@ -76,7 +78,7 @@ notes and platform carve-outs lives in
 
 Two JS ✅ marks are backed by runtime-specific mechanisms while keeping the core isomorphic:
 
-- **Thread-safe** (`ThreadSafeReactiveFamily`, `Thread-safe context`) — cross-realm mutual exclusion via a `SharedArrayBuffer` + `Atomics` reentrant mutex shared across Web Workers / `worker_threads`; degrades to a single-realm guard where shared memory is unavailable (e.g. a browser without cross-origin isolation), which is sound because no shared memory means no cross-realm concurrency.
+- **Thread-safe** (`ThreadSafeReactiveMap`, `Thread-safe context`) — cross-realm mutual exclusion via a `SharedArrayBuffer` + `Atomics` reentrant mutex shared across Web Workers / `worker_threads`; degrades to a single-realm guard where shared memory is unavailable (e.g. a browser without cross-origin isolation), which is sound because no shared memory means no cross-realm concurrency.
 - **C-ABI FFI** — the normative codec + in-process `FfiChannel` are pure-JS and run unchanged in the browser; the Node build additionally binds the real `lazily` shared library (`lazily_ffi_channel_*`) via koffi. Both speak the identical byte contract, so browser and native are drop-in interchangeable.
 
 CRDT convergence and the wire protocol are pinned by the shared conformance fixtures
@@ -89,10 +91,10 @@ and JSON Schemas in `lazily-spec` and the Lean models in `lazily-formal`.
 | `@lazily-hub/lazily-js/transport` | Cross-process zero-copy transport (`#lzzcpy`): `ShmBlobArena`, `InProcessBackend` / `ArrowBackend`, `BlobRouter`, `spillMessage` / `resolveValue`, and the FFI-gated `createShmBackend` (Node/Bun/Deno). Isomorphic — no FFI import; browser-safe |
 | `@lazily-hub/lazily-js/reactive` | Reactive dependency graph: `Context`, `Cell`, `Slot`, `Signal`, `Effect` |
 | `@lazily-hub/lazily-js/reactive-async` | Async reactive graph: `AsyncContext` — Promise-driven slots/effects with revision-guarded stale-completion discard, in-flight dedup, and cancellation |
-| `@lazily-hub/lazily-js/reactive-family` | Unified keyed reactive family: `ReactiveFamily` (`EntryKind` cell/slot × `MaterializationMode` eager/lazy) + `cellFamily` input-cell specialization (`#lzmatmode`) |
-| `@lazily-hub/lazily-js/async-reactive-family` | Async keyed reactive family: `AsyncReactiveFamily` + `asyncCellFamily` over `AsyncContext` — eventual transparency (a pending slot observes `undefined` and resolves to the canonical value; eager ≡ lazy once resolved) (`#lzmatmode`) |
+| `@lazily-hub/lazily-js/reactive-family` | Unified keyed reactive map: `ReactiveMap<K,V,H>` (reactive membership/order, `getOrInsertWith` mint-on-access, `remove`, `move`) + `CellMap` (adds cell-only `set` + eager `entry`/`entryWith`) and `SlotMap` (lazy `getOrInsertWith` + eager `materializeAll`; no `set`) specializations. No eager/lazy mode flag (`#reactivemap`) |
+| `@lazily-hub/lazily-js/async-reactive-family` | Async keyed reactive map: `AsyncReactiveMap` + `AsyncCellMap` / `AsyncSlotMap` over `AsyncContext` — eventual transparency (a pending slot observes `undefined` and resolves to the canonical value; eager ≡ lazy once resolved) (`#reactivemap`) |
 | `@lazily-hub/lazily-js/thread-safe` | Lock-backed reactive context: `ThreadSafeContext` (`Send + Sync` flavor of `Context`) + `AtomicMutex` — a real `SharedArrayBuffer` + `Atomics` reentrant mutex giving cross-worker mutual exclusion; degrades to a single-realm guard where shared memory is unavailable |
-| `@lazily-hub/lazily-js/thread-safe-reactive-family` | Thread-safe keyed reactive family: `ThreadSafeReactiveFamily` + `threadSafeCellFamily` — mutex-guarded present set with first-writer-wins materialization confluence (`#lzmatmode`) |
+| `@lazily-hub/lazily-js/thread-safe-reactive-family` | Thread-safe keyed reactive map: `ThreadSafeReactiveMap` + `ThreadSafeCellMap` / `ThreadSafeSlotMap` — mutex-guarded present set with first-writer-wins materialization confluence (`#reactivemap`) |
 | `@lazily-hub/lazily-js/ffi` | C-ABI FFI boundary (`schemas/ffi.json`): message codec (`encodeMessage` / `decodeMessage` / `validateMessage` / `kindOf`, `LazilyFfiStatus` / `LazilyFfiMessageKind`) + `FfiChannel` FIFO. Isomorphic core (browser shim); the Node build additionally exposes `NativeFfiChannel` / `loadNativeChannel` over the real `lazily_ffi_channel_*` C ABI via koffi |
 | `@lazily-hub/lazily-js/instrumentation` | In-library instrumentation/benchmark API: `benchmark`, `runBenchmarkSuite`, `BenchmarkResult`, `withInstrumentation` — plus opt-in reactive-core counters via `new Context({ instrument: true })` / `instrumentationSnapshot()` |
 | `@lazily-hub/lazily-js/state-machine` | Flat finite-state-machine kernel backed by a reactive `Cell` |
@@ -174,42 +176,46 @@ ctx.setCell(userId, 2); // supersedes any in-flight compute; slot re-resolves
 await ctx.getAsync(profile); // the profile for user 2
 ```
 
-## Reactive family and materialization mode
+## Keyed reactive maps (`ReactiveMap` / `CellMap` / `SlotMap`)
 
-`ReactiveFamily` (from `@lazily-hub/lazily-js/reactive-family`) is the unified
-**keyed reactive family** (`#lzmatmode`): it maps keys to per-entry reactive
-nodes and abstracts over the entry's handle kind. Two orthogonal axes:
+`ReactiveMap<K, V, H>` (from `@lazily-hub/lazily-js/reactive-family`) is the ONE
+unified **keyed reactive collection** (`#reactivemap`): reactive membership +
+order, `getOrInsertWith` mint-on-access, `remove`, and atomic `move`, generic
+over the entry's handle kind. Its two specializations are the concrete types you
+use:
 
-- **Entry kind** — `EntryKind.Cell` entries are input cells (**always
-  materialized**, any mode); `EntryKind.Slot` entries are derived slots (what
-  materialization governs). `cellFamily(...)` is the input-cell specialization.
-- **Materialization mode** — `MaterializationMode.Eager` (**default**) allocates
-  every derived node up front; `MaterializationMode.Lazy` (opt-in) allocates a
-  derived node on its **first read** ("materialize on pull") and caches it.
+- **`CellMap<K, V>`** — input-cell entries. Adds cell-only `set(key, value)` (an
+  input is settable) and eager value-minting (`entry` / `entryWith`).
+- **`SlotMap<K, V>`** — derived-slot entries. `getOrInsertWith(key, factory)`
+  mints a slot on **first access** ("materialize on pull", **lazy**);
+  `materializeAll(keys, factory)` pre-mints the keyset up front (**eager**). A
+  slot's value is derived, so `SlotMap` has **no `set`**.
 
-Mode is **observationally transparent**: a read returns the same value under
-either mode — it changes allocation timing and memory, never results. Lazy pays
-off only for sparsely-touched large keyed address spaces.
+There is **no eager/lazy mode flag** — eager is the pre-mint loop, lazy is
+mint-on-access, and they are **observationally transparent**: a read returns the
+same value either way; only allocation timing and memory change. Lazy pays off
+only for sparsely-touched large keyed address spaces.
 
 ```js
 import { Context } from "@lazily-hub/lazily-js/reactive";
-import { ReactiveFamily } from "@lazily-hub/lazily-js/reactive-family";
+import { SlotMap } from "@lazily-hub/lazily-js/reactive-family";
 
 const ctx = new Context();
 
-// A derived (slot) family of key*3 over a large address space, built lazily:
+// A derived (slot) map of key*3 over a large address space, built lazily:
 // nothing is allocated until a key is read.
-const fam = ReactiveFamily.lazy(ctx, range(0, 1_000_000), (k) => k * 3);
-fam.presentCount(); // 0
-
-fam.observe(5); // 15 — first read materializes just this entry
-fam.presentCount(); // 1
-fam.isPresent(5); // true
-fam.isPresent(6); // false
-
-// Eager builds the same values up front — observationally identical.
-const eager = ReactiveFamily.eager(ctx, [0, 1, 2, 3], (k) => k * 3);
-eager.observe(2) === fam.observe(2); // true
+const map = new SlotMap(ctx);
+map.presentCount(); // 0
+
+map.getOrInsertWith(5, (k) => k * 3); // 15 — first read materializes just this entry
+map.presentCount(); // 1
+map.isPresent(5); // true
+map.isPresent(6); // false
+
+// Eager pre-mints the same values up front — observationally identical.
+const eager = new SlotMap(ctx);
+eager.materializeAll([0, 1, 2, 3], (k) => k * 3);
+eager.get(2) === map.getOrInsertWith(2, (k) => k * 3); // true
 ```
 
 ## State machine and state charts
@@ -504,11 +510,11 @@ lazily-js replays the shared `lazily-spec` fixtures for IPC, agent-doc state,
 keyed collections (`CellMap`, `CellTree`, LIS reconciliation), semantic tree,
 sequence and text CRDTs (incl. `TextCrdt` delta sync, `#lztextsync`:
 `textcrdt_convergence.json` + `textcrdt_delta_sync.json`), manufactured text
-identity, the reactive family / materialization mode (`#lzmatmode`:
+identity, the keyed reactive maps / materialization (`#reactivemap`:
 `materialization/observational_transparency.json`,
 `materialization/deferral_not_deallocation.json`,
 `materialization/entry_kind_orthogonal_to_mode.json` — replayed through the
-single-threaded, async, and thread-safe families), the C-ABI FFI boundary
+single-threaded, async, and thread-safe maps), the C-ABI FFI boundary
 (`schemas/ffi.json`: message codec + channel round-trip over `snapshot_*` /
 `delta_*` wire), Harel state charts, the
 signaling protocol (`signaling/frames.json`,
@@ -532,8 +538,8 @@ names the Lean theorems it mirrors:
 | `Collection` | `collection-properties.test.js` | `setEntryValue_preserves_{membership,order,siblings}`, `moveKey_preserves_{membership,values}`, `moveKey_advances_order`, `addKey_advances_membership_and_order`, `Family.get_idempotent_after_first` |
 | `Tree` | `tree-properties.test.js` | `setNodeValue_preserves_{other_nodes,node_signals}`, `moveChild_preserves_{non_parent,parent_value}`, `moveChild_advances_order_signal_only` |
 | `Materialization` | `reactive-family.test.js` | `observe_canonical`, `eager_lazy_observationally_equivalent`, `eager_materializes_all`, `lazy_defers_slots`, `materialize_present_monotone`, `lazy_present_subset_eager`, `materialize_preserves_observe`, `cell_entries_materialized_in_every_mode`, `slot_entries_deferred_under_lazy` |
-| `Materialization` (thread-safe) | `thread-safe-reactive-family.test.js` | `materialize_present_comm`, `materialize_observe_comm` (materialization confluence) + the base materialization laws replayed through `ThreadSafeReactiveFamily` |
-| `AsyncMaterialization` | `async-reactive-family.test.js` | eventual transparency (a driven async slot resolves to the canonical value; eager ≡ lazy) + present-set monotonicity through `AsyncReactiveFamily` |
+| `Materialization` (thread-safe) | `thread-safe-reactive-family.test.js` | `materialize_present_comm`, `materialize_observe_comm` (materialization confluence) + the base materialization laws replayed through `ThreadSafeSlotMap` |
+| `AsyncMaterialization` | `async-reactive-family.test.js` | eventual transparency (a driven async slot resolves to the canonical value; eager ≡ lazy) + present-set monotonicity through `AsyncSlotMap` |
 | `ThreadSafe` | `thread-safe.test.js` | `flushBatch_empty`, `flushBatch_singleton_eq_setCell` (thread-safe batch refines `setCell`), `flushBatch_dependent_dirty`, `flushBatch_preserves_nondependent_dirty` |
 | `Reconciliation` | `reconciliation-properties.test.js` | `lisBy_longest`, `reconcile_move_minimized`, `reconcile_stable_not_invalidated` |
 | `AsyncSlotState` | `reactive-async.test.js` | `stale_completeOk_discarded`, `current_completeOk_publishes`, `current_completeErr_to_error` |

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lazily-hub/lazily-js",
-  "version": "0.14.0",
-  "description": "Native JavaScript port of the lazily reactive core: a full reactive graph (Cell/Slot/Signal/Effect), sync/async/thread-safe keyed reactive families with materialization mode, the lazily-spec IPC wire types + C-ABI FFI boundary (isomorphic channel + Node native binding), keyed cell collections + LIS reconciliation, the memoized semantic tree, the move-aware sequence CRDT, the Fugue/RGA text CRDT, manufactured text identity, full-Harel state charts, an FFI state-projection consumer, and an in-library instrumentation/benchmark API.",
+  "version": "0.16.0",
+  "description": "Native JavaScript port of the lazily reactive core: a full reactive graph (Cell/Slot/Signal/Effect), sync/async/thread-safe keyed reactive maps (ReactiveMap/CellMap/SlotMap), the lazily-spec IPC wire types + C-ABI FFI boundary (isomorphic channel + Node native binding), keyed cell collections + LIS reconciliation, the memoized semantic tree, the move-aware sequence CRDT, the Fugue/RGA text CRDT, manufactured text identity, full-Harel state charts, an FFI state-projection consumer, and an in-library instrumentation/benchmark API.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -69,6 +69,14 @@
       "types": "./src/queue.d.ts",
       "default": "./src/queue.js"
     },
+    "./merge": {
+      "types": "./src/merge.d.ts",
+      "default": "./src/merge.js"
+    },
+    "./relay": {
+      "types": "./src/relay.d.ts",
+      "default": "./src/relay.js"
+    },
     "./sem-tree": {
       "types": "./src/sem-tree.d.ts",
       "default": "./src/sem-tree.js"
@@ -93,10 +101,6 @@
       "types": "./src/state-projection.d.ts",
       "default": "./src/state-projection.js"
     },
-    "./state-graph-mirror": {
-      "types": "./src/state-graph-mirror.d.ts",
-      "default": "./src/state-graph-mirror.js"
-    },
     "./signaling": {
       "types": "./src/signaling.d.ts",
       "default": "./src/signaling.js"
@@ -107,7 +111,7 @@
     }
   },
   "scripts": {
-    "build": "node --check src/index.js && node --check src/transport.js && node --check src/shm-backend.js && node --check src/reactive.js && node --check src/reactive-async.js && node --check src/reactive-family.js && node --check src/async-reactive-family.js && node --check src/thread-safe.js && node --check src/thread-safe-reactive-family.js && node --check src/ffi.js && node --check src/ffi-node.js && node --check src/instrumentation.js && node --check src/state-machine.js && node --check src/statechart.js && node --check src/collections.js && node --check src/queue.js && node --check src/sem-tree.js && node --check src/stable-id.js && node --check src/seq-crdt.js && node --check src/text-crdt.js && node --check src/utf8-offsets.js && node --check src/lossless-tree-crdt.js && node --check src/state-projection.js && node --check src/state-graph-mirror.js && node --check src/signaling.js && node --check src/distributed.js",
+    "build": "node --check src/index.js && node --check src/transport.js && node --check src/shm-backend.js && node --check src/reactive.js && node --check src/reactive-async.js && node --check src/reactive-family.js && node --check src/async-reactive-family.js && node --check src/thread-safe.js && node --check src/thread-safe-reactive-family.js && node --check src/ffi.js && node --check src/ffi-node.js && node --check src/instrumentation.js && node --check src/state-machine.js && node --check src/statechart.js && node --check src/collections.js && node --check src/queue.js && node --check src/merge.js && node --check src/relay.js && node --check src/sem-tree.js && node --check src/stable-id.js && node --check src/seq-crdt.js && node --check src/text-crdt.js && node --check src/utf8-offsets.js && node --check src/lossless-tree-crdt.js && node --check src/state-projection.js && node --check src/graph-view.js && node --check src/signaling.js && node --check src/distributed.js",
     "test:formal": "node scripts/formal-check.mjs",
     "bench": "node bench/context.bench.mjs",
     "bench:scale": "node --max-old-space-size=8192 bench/scale.bench.mjs",

package/src/async-reactive-family.d.ts

@@ -1,78 +1,55 @@
 import type { AsyncCellHandle, AsyncContext, AsyncSlotHandle } from "./reactive-async.js";
-import type { EntryKind, MaterializationMode } from "./reactive-family.js";
+import type { EntryKind } from "./reactive-family.js";
 
-export { EntryKind, MaterializationMode, DEFAULT_MATERIALIZATION_MODE } from "./reactive-family.js";
+export { EntryKind } from "./reactive-family.js";
 
-export type EntryKindResolver<K> = EntryKind | ((key: K) => EntryKind);
-export type AsyncFamilyHandle = AsyncCellHandle | AsyncSlotHandle;
+/** The entry handle an {@link AsyncReactiveMap} holds. */
+export type AsyncMapHandle = AsyncCellHandle | AsyncSlotHandle;
 
 /**
- * The async keyed reactive family (`#lzmatmode`, async flavor): keys map to
+ * The async keyed reactive collection (`#reactivemap`, async flavor): keys map to
  * per-entry async reactive nodes (input cells resolved synchronously, or derived
- * slots resolved asynchronously), allocated per the family's
- * {@link MaterializationMode}. The transparency law is EVENTUAL — a pending slot
- * observes as `undefined` and resolves to the canonical value.
+ * slots resolved asynchronously). The transparency law is EVENTUAL — a pending
+ * slot observes as `undefined` and resolves to the canonical value. Its two
+ * specializations are {@link AsyncCellMap} and {@link AsyncSlotMap}.
  */
-export class AsyncReactiveFamily<K = unknown, V = unknown> {
-  constructor(
-    ctx: AsyncContext,
-    mode: MaterializationMode,
-    keys: Iterable<K>,
-    factory: (key: K) => V,
-    entryKind?: EntryKindResolver<K>,
-  );
+export class AsyncReactiveMap<K = unknown, V = unknown> {
+  constructor(ctx: AsyncContext, kind?: EntryKind);
 
-  /** Build an eager async family: every declared key's node is allocated now. */
-  static eager<K, V>(
-    ctx: AsyncContext,
-    keys: Iterable<K>,
-    factory: (key: K) => V,
-    entryKind?: EntryKindResolver<K>,
-  ): AsyncReactiveFamily<K, V>;
-
-  /** Build a lazy async family: derived (slot) entries deferred to first read. */
-  static lazy<K, V>(
-    ctx: AsyncContext,
-    keys: Iterable<K>,
-    factory: (key: K) => V,
-    entryKind?: EntryKindResolver<K>,
-  ): AsyncReactiveFamily<K, V>;
-
-  /** Build an async family in the default (eager) mode. */
-  static create<K, V>(
-    ctx: AsyncContext,
-    keys: Iterable<K>,
-    factory: (key: K) => V,
-    entryKind?: EntryKindResolver<K>,
-  ): AsyncReactiveFamily<K, V>;
-
-  /** Materialize (lazy pull) and return the entry handle for `key`. */
-  get(key: K): AsyncFamilyHandle;
+  /** Get the entry handle for `key`, minting via `factory(key)` if absent. */
+  getOrInsertHandle(key: K, factory: (key: K) => V): AsyncMapHandle;
   /** Non-blocking observe: value for a cell/resolved slot, `undefined` if pending. */
   observe(key: K): V | undefined;
-  /** Drive `key` to resolution and return its canonical value. */
-  resolve(key: K): Promise<V>;
-  /** Set a cell entry's value (input entries only). */
-  setCell(key: K, value: V): void;
+  /** Drive `key` to resolution; mint via `factory(key)` if absent. */
+  resolve(key: K, factory?: (key: K) => V): Promise<V>;
+  /** The existing entry handle for `key`, or `undefined`. Non-minting. */
+  handle(key: K): AsyncMapHandle | undefined;
   /** Whether `key` is currently materialized. Non-reactive. */
   isPresent(key: K): boolean;
   /** Currently-materialized keys, in first-materialization order. */
   presentKeys(): K[];
   /** Number of currently-materialized entries. */
   presentCount(): number;
-  /** This family's entry kind for `key`. */
-  entryKind(key: K): EntryKind;
-  /** This family's materialization mode. */
-  readonly mode: MaterializationMode;
+  /** This map's entry kind. */
+  entryKind(): EntryKind;
+}
+
+/**
+ * The async input-cell map: every entry is an always-resolved input cell. Adds
+ * cell-only `set`.
+ */
+export class AsyncCellMap<K = unknown, V = unknown> extends AsyncReactiveMap<K, V> {
+  constructor(ctx: AsyncContext);
+  /** Set the value at `key`, inserting a new input cell if absent. Cell-only. */
+  set(key: K, value: V): void;
 }
 
 /**
- * The input-cell specialization of {@link AsyncReactiveFamily}: a keyed async
- * family whose entries are all input cells (always materialized, always resolved).
+ * The async derived-slot map: entries are derived slots minted lazily on access
+ * or eagerly via `materializeAll`, resolved via `ctx.getAsync`. NO `set`.
  */
-export function asyncCellFamily<K, V>(
-  ctx: AsyncContext,
-  keys: Iterable<K>,
-  factory: (key: K) => V,
-  mode?: MaterializationMode,
-): AsyncReactiveFamily<K, V>;
+export class AsyncSlotMap<K = unknown, V = unknown> extends AsyncReactiveMap<K, V> {
+  constructor(ctx: AsyncContext);
+  /** Eager materialization: pre-mint a derived slot for every key in `keys`. */
+  materializeAll(keys: Iterable<K>, factory: (key: K) => V): void;
+}