@graphrefly/ts 0.0.0

package/dist/reactive-collection-storage-D-KmjE0J.d.cts

@@ -0,0 +1,217 @@
+import { Q as StateNode, d as Graph } from './graph-s23RbbFO.cjs';
+import { N as Node } from './types-bNMSWKqF.cjs';
+import { AgenticMemoryStrictJsonValue, AgenticMemoryRecordFrame, AgenticMemoryRecord } from './solutions/index.cjs';
+import { f as KvStorageTier, d as AppendLogStorageTier } from './append-log-DisvEReb.cjs';
+import { b as LoadReactiveCollectionStateOptions, a as IndexRow, n as ReactiveIndexOptions, j as ReactiveIndex, o as ReactiveIndexRestoreState, p as ReactiveListRestoreState, q as ReactiveLogRestoreState, r as ReactiveMapRestoreState } from './reactive-collection-BxBqtIOE.cjs';
+import { b as ReactiveListOptions, d as ReactiveLogOptions, g as ReactiveMapOptions, R as ReactiveList, c as ReactiveLog, e as ReactiveMap } from './reactive-map-D-g3dv8I.cjs';
+
+declare const AGENTIC_MEMORY_RECORD_SNAPSHOT_FORMAT: "graphrefly.agenticMemory.records.snapshot";
+declare const AGENTIC_MEMORY_RECORD_CHANGE_FORMAT: "graphrefly.agenticMemory.records.change";
+declare const AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION: 1;
+interface AgenticMemoryRecordSnapshotFrame<TJson extends AgenticMemoryStrictJsonValue = AgenticMemoryStrictJsonValue> {
+    readonly format: typeof AGENTIC_MEMORY_RECORD_SNAPSHOT_FORMAT;
+    readonly version: typeof AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION;
+    readonly changeCursor: number;
+    readonly records: readonly AgenticMemoryRecordFrame<TJson>[];
+}
+interface AgenticMemoryRecordChangeFrame<TJson extends AgenticMemoryStrictJsonValue = AgenticMemoryStrictJsonValue> {
+    readonly format: typeof AGENTIC_MEMORY_RECORD_CHANGE_FORMAT;
+    readonly version: typeof AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION;
+    readonly change: {
+        readonly kind: "replaceAll";
+        readonly records: readonly AgenticMemoryRecordFrame<TJson>[];
+    };
+}
+interface AgenticMemoryRecordsRestoreState<TJson extends AgenticMemoryStrictJsonValue = AgenticMemoryStrictJsonValue> {
+    readonly records: readonly AgenticMemoryRecord<TJson>[];
+    readonly source: "empty" | "changes" | "snapshot" | "snapshot+changes";
+    readonly snapshot: {
+        readonly found: boolean;
+        readonly changeCursor: number;
+    };
+    readonly changes: {
+        readonly applied: number;
+        readonly cursor: number;
+    };
+}
+interface LoadAgenticMemoryRecordsStateOptions {
+    readonly snapshotStore: KvStorageTier<unknown>;
+    readonly snapshotKey?: string;
+    readonly storagePrefix?: string;
+    readonly changeLog?: AppendLogStorageTier<unknown>;
+}
+interface AgenticMemoryRecordsPersistenceCursor {
+    readonly kind: "persistence.cursor";
+    readonly changeSeq: number;
+    readonly snapshotWrites: number;
+    readonly changeWrites: number;
+}
+interface AgenticMemoryRecordsPersistenceStatus {
+    readonly state: "starting" | "ready" | "flushing" | "errored" | "disposed";
+    readonly pending: number;
+    readonly writes: number;
+    readonly errors: number;
+    readonly cursor: AgenticMemoryRecordsPersistenceCursor;
+}
+interface AgenticMemoryRecordsPersistenceError {
+    readonly phase: "snapshot" | "change";
+    readonly message: string;
+    readonly cursor: AgenticMemoryRecordsPersistenceCursor;
+}
+interface PersistAgenticMemoryRecordsOptions {
+    readonly name?: string;
+    readonly snapshotStore: KvStorageTier<unknown>;
+    readonly snapshotKey?: string;
+    readonly storagePrefix?: string;
+    readonly changeLog?: AppendLogStorageTier<unknown>;
+    readonly initialChangeCursor?: number;
+    readonly snapshotOnAttach?: boolean;
+    readonly snapshotEveryChanges?: number;
+}
+interface AgenticMemoryRecordsPersistenceHandle {
+    readonly ready: StateNode<boolean>;
+    readonly status: StateNode<AgenticMemoryRecordsPersistenceStatus>;
+    readonly error: StateNode<AgenticMemoryRecordsPersistenceError | null>;
+    readonly cursor: StateNode<AgenticMemoryRecordsPersistenceCursor>;
+    flush(done?: (status: AgenticMemoryRecordsPersistenceStatus) => void): void;
+    snapshot(done?: (status: AgenticMemoryRecordsPersistenceStatus) => void): void;
+    dispose(done?: (status: AgenticMemoryRecordsPersistenceStatus) => void): void;
+}
+interface OpenPersistentAgenticMemoryRecordsOptions<TJson extends AgenticMemoryStrictJsonValue> extends LoadAgenticMemoryRecordsStateOptions, Omit<PersistAgenticMemoryRecordsOptions, "snapshotStore" | "changeLog" | "initialChangeCursor"> {
+    readonly graph: Graph;
+    readonly name?: string;
+    readonly initial?: readonly AgenticMemoryRecord<TJson>[];
+}
+interface PersistentAgenticMemoryRecords<TJson extends AgenticMemoryStrictJsonValue> {
+    readonly records: StateNode<readonly AgenticMemoryRecord<TJson>[]>;
+    readonly persistence: AgenticMemoryRecordsPersistenceHandle;
+    readonly loaded: AgenticMemoryRecordsRestoreState<TJson>;
+}
+declare function agenticMemoryRecordsSnapshotKey(storagePrefix?: string): string;
+declare function agenticMemoryRecordSnapshotFrame<TJson extends AgenticMemoryStrictJsonValue = AgenticMemoryStrictJsonValue>(records: readonly AgenticMemoryRecord<TJson>[], opts?: {
+    readonly changeCursor?: number;
+}): AgenticMemoryRecordSnapshotFrame<TJson>;
+declare function agenticMemoryRecordChangeFrame<TJson extends AgenticMemoryStrictJsonValue = AgenticMemoryStrictJsonValue>(records: readonly AgenticMemoryRecord<TJson>[]): AgenticMemoryRecordChangeFrame<TJson>;
+declare function assertAgenticMemoryRecordSnapshotFrame<TJson extends AgenticMemoryStrictJsonValue = AgenticMemoryStrictJsonValue>(value: unknown): AgenticMemoryRecordSnapshotFrame<TJson>;
+declare function assertAgenticMemoryRecordChangeFrame<TJson extends AgenticMemoryStrictJsonValue = AgenticMemoryStrictJsonValue>(value: unknown): AgenticMemoryRecordChangeFrame<TJson>;
+declare function loadAgenticMemoryRecordsState<TJson extends AgenticMemoryStrictJsonValue = AgenticMemoryStrictJsonValue>(opts: LoadAgenticMemoryRecordsStateOptions): Promise<AgenticMemoryRecordsRestoreState<TJson>>;
+declare function persistAgenticMemoryRecords<TJson extends AgenticMemoryStrictJsonValue = AgenticMemoryStrictJsonValue>(graph: Graph, records: Node<readonly AgenticMemoryRecord<TJson>[]>, opts: PersistAgenticMemoryRecordsOptions): AgenticMemoryRecordsPersistenceHandle;
+declare function openPersistentAgenticMemoryRecords<TJson extends AgenticMemoryStrictJsonValue = AgenticMemoryStrictJsonValue>(opts: OpenPersistentAgenticMemoryRecordsOptions<TJson>): Promise<PersistentAgenticMemoryRecords<TJson>>;
+
+type PersistableKind = "reactiveList" | "reactiveLog" | "reactiveMap" | "reactiveIndex";
+type PersistableCollection<T, K extends PersistableKind> = K extends "reactiveList" ? ReactiveList<T> : K extends "reactiveLog" ? ReactiveLog<T> : K extends "reactiveMap" ? ReactiveMap<unknown, T> : ReactiveIndex<unknown, T>;
+/** D161 adapter write-progress cursor; this is not a domain replay or wire-bridge cursor. */
+interface ReactiveCollectionPersistenceCursor {
+    readonly kind: "persistence.cursor";
+    readonly collection: PersistableKind;
+    readonly changeSeq: number;
+    readonly snapshotWrites: number;
+    readonly changeWrites: number;
+}
+/** D161 graph-visible persistence sidecar status fact. */
+interface ReactiveCollectionPersistenceStatus {
+    readonly state: "starting" | "ready" | "flushing" | "errored" | "disposed";
+    readonly pending: number;
+    readonly writes: number;
+    readonly errors: number;
+    readonly cursor: ReactiveCollectionPersistenceCursor;
+}
+/** D161 graph-visible persistence sidecar error fact. */
+interface ReactiveCollectionPersistenceError {
+    readonly phase: "snapshot" | "change";
+    readonly message: string;
+    readonly cursor: ReactiveCollectionPersistenceCursor;
+}
+/** Options for the D161 graph-bound persistence sidecar over a reactive collection. */
+interface PersistReactiveCollectionOptions<K extends PersistableKind = PersistableKind> {
+    readonly kind: K;
+    readonly name?: string;
+    readonly snapshotStore: KvStorageTier<unknown>;
+    readonly snapshotKey?: string;
+    readonly storagePrefix?: string;
+    readonly changeLog?: AppendLogStorageTier<unknown>;
+    /** Adapter write cursor seed for wrappers that already folded a change log. */
+    readonly initialChangeCursor?: number;
+    /** Default true: write one durable baseline when the adapter attaches. */
+    readonly snapshotOnAttach?: boolean;
+    /** Optional snapshot cadence. Manual snapshots remain available via handle.snapshot(). */
+    readonly snapshotEveryChanges?: number;
+}
+/** D161 sidecar controls; flush waits for queued storage promises to settle, not fsync. */
+interface ReactiveCollectionPersistenceHandle {
+    readonly ready: StateNode<boolean>;
+    readonly status: StateNode<ReactiveCollectionPersistenceStatus>;
+    readonly error: StateNode<ReactiveCollectionPersistenceError | null>;
+    readonly cursor: StateNode<ReactiveCollectionPersistenceCursor>;
+    flush(done?: (status: ReactiveCollectionPersistenceStatus) => void): void;
+    snapshot(done?: (status: ReactiveCollectionPersistenceStatus) => void): void;
+    dispose(done?: (status: ReactiveCollectionPersistenceStatus) => void): void;
+}
+/**
+ * D161 graph-bound sidecar over an existing collection. It writes passive storage frames and
+ * exposes adapter progress as graph-visible DATA facts; it never restores or mutates the collection.
+ */
+declare function persistReactiveCollection<T, K extends PersistableKind>(graph: Graph, collection: PersistableCollection<T, K>, opts: PersistReactiveCollectionOptions<K>): ReactiveCollectionPersistenceHandle;
+type CollectionOptionsWithoutGraphName<T> = Omit<T, "graph" | "name">;
+/** Options for D161 load -> restore -> persist composition for reactiveList. */
+interface OpenPersistentReactiveListOptions<T> extends LoadReactiveCollectionStateOptions, Omit<PersistReactiveCollectionOptions<"reactiveList">, "kind" | "snapshotStore" | "changeLog" | "initialChangeCursor"> {
+    readonly graph: Graph;
+    readonly name?: string;
+    readonly initial?: readonly T[];
+    readonly collection?: CollectionOptionsWithoutGraphName<ReactiveListOptions>;
+}
+/** Options for D161 load -> restore -> persist composition for reactiveLog. */
+interface OpenPersistentReactiveLogOptions<T> extends LoadReactiveCollectionStateOptions, Omit<PersistReactiveCollectionOptions<"reactiveLog">, "kind" | "snapshotStore" | "changeLog" | "initialChangeCursor"> {
+    readonly graph: Graph;
+    readonly name?: string;
+    readonly initial?: readonly T[];
+    readonly collection?: CollectionOptionsWithoutGraphName<ReactiveLogOptions>;
+}
+/** Options for D161 load -> restore -> persist composition for reactiveMap. */
+interface OpenPersistentReactiveMapOptions<K, V> extends LoadReactiveCollectionStateOptions, Omit<PersistReactiveCollectionOptions<"reactiveMap">, "kind" | "snapshotStore" | "changeLog" | "initialChangeCursor"> {
+    readonly graph: Graph;
+    readonly name?: string;
+    readonly initial?: readonly (readonly [K, V])[];
+    readonly collection?: CollectionOptionsWithoutGraphName<ReactiveMapOptions<K, V>>;
+}
+/** Options for D161 load -> restore -> persist composition for reactiveIndex. */
+interface OpenPersistentReactiveIndexOptions<K, V> extends LoadReactiveCollectionStateOptions, Omit<PersistReactiveCollectionOptions<"reactiveIndex">, "kind" | "snapshotStore" | "changeLog" | "initialChangeCursor"> {
+    readonly graph: Graph;
+    readonly name?: string;
+    readonly initial?: readonly IndexRow<K, V>[];
+    readonly collection?: CollectionOptionsWithoutGraphName<ReactiveIndexOptions>;
+}
+/** Return value for D161 persistent reactiveList composition. */
+interface PersistentReactiveList<T> {
+    readonly collection: ReactiveList<T>;
+    readonly persistence: ReactiveCollectionPersistenceHandle;
+    readonly loaded: ReactiveListRestoreState<T>;
+}
+/** Return value for D161 persistent reactiveLog composition. */
+interface PersistentReactiveLog<T> {
+    readonly collection: ReactiveLog<T>;
+    readonly persistence: ReactiveCollectionPersistenceHandle;
+    readonly loaded: ReactiveLogRestoreState<T>;
+}
+/** Return value for D161 persistent reactiveMap composition. */
+interface PersistentReactiveMap<K, V> {
+    readonly collection: ReactiveMap<K, V>;
+    readonly persistence: ReactiveCollectionPersistenceHandle;
+    readonly loaded: ReactiveMapRestoreState<K, V>;
+}
+/** Return value for D161 persistent reactiveIndex composition. */
+interface PersistentReactiveIndex<K, V> {
+    readonly collection: ReactiveIndex<K, V>;
+    readonly persistence: ReactiveCollectionPersistenceHandle;
+    readonly loaded: ReactiveIndexRestoreState<K, V>;
+}
+/** D161 convenience wrapper: passive load, sync restoreReactiveList, then sidecar persist. */
+declare function openPersistentReactiveList<T = unknown>(opts: OpenPersistentReactiveListOptions<T>): Promise<PersistentReactiveList<T>>;
+/** D161 convenience wrapper: passive load, sync restoreReactiveLog, then sidecar persist. */
+declare function openPersistentReactiveLog<T = unknown>(opts: OpenPersistentReactiveLogOptions<T>): Promise<PersistentReactiveLog<T>>;
+/** D161 convenience wrapper: passive load, sync restoreReactiveMap, then sidecar persist. */
+declare function openPersistentReactiveMap<K = unknown, V = unknown>(opts: OpenPersistentReactiveMapOptions<K, V>): Promise<PersistentReactiveMap<K, V>>;
+/** D161 convenience wrapper: passive load, sync restoreReactiveIndex, then sidecar persist. */
+declare function openPersistentReactiveIndex<K = unknown, V = unknown>(opts: OpenPersistentReactiveIndexOptions<K, V>): Promise<PersistentReactiveIndex<K, V>>;
+
+export { AGENTIC_MEMORY_RECORD_CHANGE_FORMAT as A, assertAgenticMemoryRecordSnapshotFrame as B, loadAgenticMemoryRecordsState as C, openPersistentAgenticMemoryRecords as D, openPersistentReactiveIndex as E, openPersistentReactiveList as F, openPersistentReactiveLog as G, openPersistentReactiveMap as H, persistAgenticMemoryRecords as I, persistReactiveCollection as J, type LoadAgenticMemoryRecordsStateOptions as L, type OpenPersistentAgenticMemoryRecordsOptions as O, type PersistAgenticMemoryRecordsOptions as P, type ReactiveCollectionPersistenceCursor as R, AGENTIC_MEMORY_RECORD_SNAPSHOT_FORMAT as a, AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION as b, type AgenticMemoryRecordChangeFrame as c, type AgenticMemoryRecordSnapshotFrame as d, type AgenticMemoryRecordsPersistenceCursor as e, type AgenticMemoryRecordsPersistenceError as f, type AgenticMemoryRecordsPersistenceHandle as g, type AgenticMemoryRecordsPersistenceStatus as h, type AgenticMemoryRecordsRestoreState as i, type OpenPersistentReactiveIndexOptions as j, type OpenPersistentReactiveListOptions as k, type OpenPersistentReactiveLogOptions as l, type OpenPersistentReactiveMapOptions as m, type PersistReactiveCollectionOptions as n, type PersistentAgenticMemoryRecords as o, type PersistentReactiveIndex as p, type PersistentReactiveList as q, type PersistentReactiveLog as r, type PersistentReactiveMap as s, type ReactiveCollectionPersistenceError as t, type ReactiveCollectionPersistenceHandle as u, type ReactiveCollectionPersistenceStatus as v, agenticMemoryRecordChangeFrame as w, agenticMemoryRecordSnapshotFrame as x, agenticMemoryRecordsSnapshotKey as y, assertAgenticMemoryRecordChangeFrame as z };

package/dist/reactive-map-BcB4KsQR.d.ts

@@ -0,0 +1,256 @@
+import { N as Node } from './types-h12mNYbq.js';
+import { J as CollectionCoreOptions, s as ReactiveOpt, L as ListChange, V as ViewCachePolicy, c as LogChange, t as ReactiveView, u as RetentionPolicy, M as MapChange } from './reactive-collection-Cb1II1Fi.js';
+
+/**
+ * Reactive positional list (CSP-2.8, D54/D60) — the two-port collection template.
+ *
+ * Shape (D60 + review #2): a mutable array BACKEND (the single materialized state) + the shared
+ * {@link collectionCore} two ports — a DELTA stream ({@link ReactiveList.delta}, one event per
+ * mutation, O(1)) and a lazy pull SNAPSHOT ({@link ReactiveList.snapshot}, materialized only on a
+ * cone-routed RESUME demand). Mutation input is D54 A3 hybrid: ergonomic imperative methods (the
+ * external boundary, state-verb-legitimate, D4) + `appendFrom(src)` widening (an in-graph producer
+ * drives the list with zero imperative glue). Synchronous quick-reads (`at`/`size`/`toArray`) are
+ * the deliberately-non-reactive peek for cold/imperative reads (D60).
+ *
+ * Per-language (D6/D24, never in parity, no conformance — the substrate pull is already C-16).
+ */
+
+type ReactiveListOpt<T> = ReactiveOpt<T>;
+interface ReactiveListOptions extends CollectionCoreOptions {
+    /**
+     * Head-trim capacity policy (D72). A static number caps the list locally; a Node-valued maxSize
+     * must be graph-bound and becomes a declared policy dep that trims on policy changes.
+     */
+    maxSize?: ReactiveListOpt<number>;
+}
+interface ReactiveList<T> {
+    /** DELTA stream: one {@link ListChange} per mutation (O(1)). Subscribe to observe events. */
+    readonly delta: Node<ListChange<T>>;
+    /** SNAPSHOT pull node: demand via `ctx.upNext([[RESUME, pullId]])` → one `readonly T[]` (lazy O(n)). */
+    readonly snapshot: Node<readonly T[]>;
+    /** The snapshot node's pullId — write it verbatim into the demander's fn (D59). */
+    readonly pullId: symbol;
+    /** Current entry count (O(1), synchronous non-reactive read). */
+    readonly size: number;
+    /** Positional access (O(1)); negative indices Python-style; `undefined` out of range. Sync read. */
+    at(index: number): T | undefined;
+    /** Full current contents (O(n), fresh defensive copy). Sync non-reactive read (cold-start peek). */
+    toArray(): readonly T[];
+    append(value: T): void;
+    /** Append all values; one delta event + one snapshot-arm. No-op if `values` is empty. */
+    appendMany(values: readonly T[]): void;
+    /** Insert at `index` (0..size). Throws `RangeError` out of range. */
+    insert(index: number, value: T): void;
+    /** Insert all at `index` as one op. No-op if `values` is empty. Throws out of range. */
+    insertMany(index: number, values: readonly T[]): void;
+    /** Remove and return the value at `index` (default last; negative Python-style). Throws if empty/out of range. */
+    pop(index?: number): T;
+    clear(): void;
+    /** D54 widening: every value from `src` is appended. Returns a disposer. */
+    appendFrom(src: Node<T>): () => void;
+    /** Release the widening subscriptions (idempotent). */
+    dispose(): void;
+}
+/**
+ * Create a reactive list (D54/D60). The DELTA + SNAPSHOT ports + pullId come from the shared
+ * {@link collectionCore}; this layer adds the typed list method surface + backend.
+ *
+ * @example
+ * ```ts
+ * const list = reactiveList<number>([1]);
+ * // observe events:
+ * list.delta.subscribe((m) => { if (m[0] === "DATA") console.log("Δ", m[1]); });
+ * list.append(2);                 // delta: {kind:"append", value:2}
+ * // demand the snapshot (a downstream consumer, holding `list.snapshot` upstream, runs):
+ * //   ctx.upNext([["RESUME", list.pullId]]);  → SNAPSHOT delivers [1, 2]
+ * list.toArray();                 // [1, 2]   (synchronous non-reactive read)
+ * ```
+ */
+declare function reactiveList<T>(initial?: readonly T[], options?: ReactiveListOptions): ReactiveList<T>;
+
+/**
+ * Reactive append-only log (CSP-2.8, D54/D60) — two-port collection with incremental views.
+ *
+ * Shape = the shared {@link collectionCore} two ports over an array (or ring-buffer if `maxSize`)
+ * BACKEND (D60). Specializations (D60 #5 / review #5):
+ *   - SNAPSHOT (the full `readonly T[]`) is the lazy pull port like the others, BUT the log's main
+ *     consumption is INCREMENTAL: `tail()` / `slice()` / `scan()` re-derive on the DELTA backbone
+ *     (dep=[delta]), folding each appended value as it arrives — NOT re-scanning a pushed full array.
+ *   - `append(undefined)` throws: `undefined` is the substrate SENTINEL (R-data-payload / R-sentinel),
+ *     not a valid value.
+ *   - empty log: the snapshot is `[]` (a real empty array); a never-appended `scan` seeds its initial.
+ *     There is NO `[[RESOLVED]]`-for-empty dual role (D49 narrowed RESOLVED to undirty-only, D60 #5b).
+ *   - `attach(upstream)` = the D54 widening (a declared input-fold dep), NOT an imperative subscribe.
+ *   - {@link mergeReactiveLogs} is a DECLARED-DEP merge (deps=[...delta streams]), NOT the old
+ *     internal-subscribe island (D45 must-fix, D60 #5e).
+ *   - storage persistence = D57 (binding-layer observe-sink), out of scope here.
+ *
+ * Per-language (D6/D24, never in parity, no conformance — the substrate pull is already C-16).
+ */
+
+interface ReactiveLogOptions extends CollectionCoreOptions {
+    /** Ring-buffer cap: appends past `maxSize` evict the oldest (head-trim, append-only-safe). */
+    maxSize?: number;
+    /** Static D80 memo policy for D121 light views. Eviction does not dispose returned views. */
+    viewCache?: ViewCachePolicy;
+}
+interface ReactiveLog<T> {
+    readonly delta: Node<LogChange<T>>;
+    /** SNAPSHOT pull node: demand → full `readonly T[]` (lazy O(n)). For incremental use {@link tail}, {@link slice}, or {@link scan}. */
+    readonly snapshot: Node<readonly T[]>;
+    readonly pullId: symbol;
+    /** Entry count (O(1)). Sync non-reactive read. */
+    readonly size: number;
+    /** Positional access (O(1)); negative Python-style; `undefined` out of range. Sync read. */
+    at(index: number): T | undefined;
+    /** Full contents (O(n) fresh copy). Sync non-reactive read (cold-start peek). */
+    toArray(): readonly T[];
+    /** Append one value. Throws on `undefined` (substrate SENTINEL, R-data-payload). */
+    append(value: T): void;
+    /** Append many; one delta event. No-op if empty. Throws if any value is `undefined`. */
+    appendMany(values: readonly T[]): void;
+    clear(): void;
+    /** Remove the first `n` entries (clamped to size). */
+    trimHead(n: number): void;
+    /**
+     * Incremental tail view: a derived node emitting the last `n` entries, recomputed on each delta
+     * (dep=[delta], D60 #5a). Memoized per `n` until {@link dispose}; use stable ranges for
+     * long-lived logs. Subscribe to keep it live.
+     */
+    tail(n: number): Node<readonly T[]>;
+    /**
+     * Incremental positional view: a derived node emitting `toArray().slice(start, stop)`,
+     * recomputed on each delta (dep=[delta], D60 #5a). Memoized per `[start, stop]` until
+     * {@link dispose}; use stable ranges for long-lived logs.
+     */
+    slice(start: number, stop?: number): Node<readonly T[]>;
+    /**
+     * D121 light page view: `delta` forwards parent log mutations, and `snapshot` is a pull node
+     * that materializes the current page on demand.
+     */
+    page(offset: number, limit: number): ReactiveView<LogChange<T>, readonly T[]>;
+    /**
+     * Incremental running aggregate over appended values (dep=[delta], D60 #5a). O(1) per append —
+     * folds only the new values each delta; resets on `clear`/`trimHead` (a non-append delta) via a
+     * full re-fold. Emits the current accumulator on every mutation; seeds `initial` on an empty log.
+     */
+    scan<A>(initial: A, step: (acc: A, value: T) => A): Node<A>;
+    /** D54 widening: every value from `src` is appended. Returns a disposer. */
+    attach(src: Node<T>): () => void;
+    dispose(): void;
+}
+/**
+ * Create an append-only reactive log (D54/D60). DELTA + lazy pull SNAPSHOT + pullId via
+ * {@link collectionCore}; this layer adds the typed append surface + incremental view/scan.
+ */
+declare function reactiveLog<T>(initial?: readonly T[], options?: ReactiveLogOptions): ReactiveLog<T>;
+/**
+ * Fan-in N reactive logs into one merged DELTA stream (D60 #5e — a DECLARED-DEP merge, NOT the old
+ * internal-subscribe island). The returned node declares each log's `delta` as a dep (`partial`)
+ * and re-emits every change it sees — describe shows `log[i].delta → merged` truthfully (D45).
+ * For the merged SNAPSHOT, fold the merged delta with {@link ReactiveLog.scan}-style logic, or
+ * demand each source's snapshot independently.
+ */
+declare function mergeReactiveLogs<T>(logs: readonly ReactiveLog<T>[]): Node<LogChange<T>>;
+/**
+ * Standalone incremental scan over a reactive log. Equivalent to `log.scan(initial, step)`;
+ * provided for pipe-builder and helper-composition call sites.
+ */
+declare function scanLog<T, A>(log: ReactiveLog<T>, initial: A, step: (acc: A, value: T) => A): Node<A>;
+
+/**
+ * Reactive key–value map (CSP-2.8, D54/D60/D68) — two-port collection with policy opts.
+ *
+ * Shape = the shared {@link collectionCore} two ports over a `Map` BACKEND (D60). Specializations
+ * (D60 #3 / review #3):
+ *   - TTL/LRU are node-as-opt policies (D68). Static `maxSize` / `defaultTtl` values become constant
+ *     policy deps; Node-valued opts are declared deps. The graph-visible `reactiveMap.apply` node is
+ *     the normal backend mutation path and emits the public delta payloads it materializes.
+ *   - LAZY TTL (no background timer): expiry is checked at read (`get`/`has`) + at synchronous
+ *     snapshot materialization (`toMap`/`pruneExpired`). A read/prune that deletes an expired key
+ *     emits the normal delta `delete{reason:"expired"}` (D61). Snapshot demand uses an internal pull
+ *     `snapshotPrep` node: it prunes expired entries and reads the backend once, then public
+ *     `snapshot` and `delta` derive from that declared prep payload. No snapshot fn drives its own
+ *     dep (D37).
+ *   - delete-reason enum {expired|lru-evict|archived|explicit} on the delta (D60 #3c).
+ *   - LRU `maxSize`: an over-cap `set` evicts the oldest, emitting a `delete{reason:"lru-evict"}`.
+ *     A live-key `get`/`has` touches LRU order WITHOUT a version bump (internal, D60 #3d).
+ *   - retention (score-archive, D72): `retention.maxSize` is a value-or-Node numeric policy and
+ *     the static scorer selects archive victims through the normal `reactiveMap.apply` path.
+ *
+ * Per-language (D6/D24, never in parity, no conformance — the substrate pull is already C-16).
+ */
+
+type ReactiveMapOpt<T> = ReactiveOpt<T>;
+interface ReactiveMapRetentionEntry<K, V> {
+    readonly key: K;
+    readonly value: V;
+}
+interface ReactiveMapRetentionPolicy<K, V> extends RetentionPolicy<ReactiveMapRetentionEntry<K, V>> {
+    /** Archive capacity. Unlike LRU, zero is allowed and archives every live entry. */
+    readonly maxSize?: ReactiveMapOpt<number>;
+    /** Higher scores are retained; lowest finite scores are archived first. */
+    score(entry: ReactiveMapRetentionEntry<K, V>): number;
+}
+interface ReactiveMapOptions<K = unknown, V = unknown> extends CollectionCoreOptions {
+    /**
+     * LRU cap as a node-as-opt policy (D68). A static number is a constant policy config; a Node must
+     * be graph-bound and becomes a declared dep of `reactiveMap.apply`.
+     */
+    maxSize?: ReactiveMapOpt<number>;
+    /**
+     * Default TTL in milliseconds as a node-as-opt policy (D68). Per-call `set(...,{ttl})` overrides.
+     * Lazy expiry only; no active timer in this cut.
+     */
+    defaultTtl?: ReactiveMapOpt<number>;
+    /**
+     * Score-based retention/archive policy (D72). The scorer is static local code; only maxSize can be
+     * a Node-valued policy, keeping graph describe data serializable while apply owns the mutation.
+     */
+    retention?: ReactiveMapRetentionPolicy<K, V>;
+    /** Static D80 memo policy for D121 light views. Eviction does not dispose returned views. */
+    viewCache?: ViewCachePolicy;
+    /** Injectable monotonic-ish clock for TTL (default `Date.now`). Graph-local clock = follow-up (D26). */
+    now?: () => number;
+}
+interface ReactiveMap<K, V> {
+    readonly delta: Node<MapChange<K, V>>;
+    readonly snapshot: Node<ReadonlyMap<K, V>>;
+    readonly pullId: symbol;
+    /** Raw entry count (O(1)); may include not-yet-pruned expired entries. Sync non-reactive read. */
+    readonly size: number;
+    /** Get a live value (prunes the key if expired). Sync read. */
+    get(key: K): V | undefined;
+    /** Live-key existence (prunes if expired). Sync read. */
+    has(key: K): boolean;
+    /** Current live (non-expired) entries (fresh copy). Sync non-reactive read (cold-start peek). */
+    toMap(): ReadonlyMap<K, V>;
+    /**
+     * D121 light selected-map view. `delta` forwards parent map mutations, and `snapshot` is a pull
+     * node that materializes the currently matching live entries on demand.
+     */
+    select(predicate: (value: V, key: K) => boolean): ReactiveView<MapChange<K, V>, ReadonlyMap<K, V>>;
+    set(key: K, value: V, opts?: {
+        ttl?: number;
+    }): void;
+    /** Bulk set; one delta event per entry, one snapshot-arm. No-op if empty. */
+    setMany(entries: Iterable<readonly [K, V]>, opts?: {
+        ttl?: number;
+    }): void;
+    delete(key: K): void;
+    /** Bulk delete; one delta per removed key. No-op if none present. */
+    deleteMany(keys: Iterable<K>): void;
+    clear(): void;
+    /** Explicitly prune expired entries; every removed key emits `delete{reason:"expired"}` (D61). */
+    pruneExpired(): void;
+    /** D54 widening: every `[key, value]` from `src` is set. Returns a disposer. */
+    setFrom(src: Node<readonly [K, V]>): () => void;
+    dispose(): void;
+}
+/**
+ * Create a reactive map (D54/D60). DELTA stream of {@link MapChange} + lazy pull SNAPSHOT (a
+ * `ReadonlyMap`) + pullId via {@link collectionCore}; this layer adds the typed map surface.
+ */
+declare function reactiveMap<K, V>(options?: ReactiveMapOptions<K, V>): ReactiveMap<K, V>;
+
+export { type ReactiveList as R, type ReactiveListOpt as a, type ReactiveListOptions as b, type ReactiveLog as c, type ReactiveLogOptions as d, type ReactiveMap as e, type ReactiveMapOpt as f, type ReactiveMapOptions as g, type ReactiveMapRetentionEntry as h, type ReactiveMapRetentionPolicy as i, reactiveLog as j, reactiveMap as k, mergeReactiveLogs as m, reactiveList as r, scanLog as s };