doxum 0.1.12 → 0.1.13

package/skills/doxum-runtime/references/patterns.zh-CN.md

@@ -84,24 +84,18 @@ document.apply(
 ## 投影与 React
 
 ```ts
-const titles = project(
-  document,
-  path => path.tasks,
-  (_id, task) => task.title
-);
-const total = project({ titles }, ({ titles }) => titles.ids().length);
+const tasks = observe(document, path => path.tasks);
+const titles = derive([tasks], tasks => new Map([...tasks].map(([id, task]) => [id, task.title])));
+const total = derive([titles], titles => titles.size);
 const zoom = input(1);
-const scaled = project({ total, zoom }, ({ total, zoom }) => total * zoom);
-const store = createProjectionStore({ onError: console.error });
-store.get(scaled);
-const title = store.item(titles, taskId);
+const scaled = derive([total, zoom], (total, zoom) => total * zoom);
+const runtime = createProjectionRuntime({ onError: console.error });
+runtime.get(scaled);
+const title = runtime.get(tasks).get(taskId);
 ```
 
-投影定义使用 `useProjection` 和一个 store，document.history 等既有 Readable
-使用 `useReadable` 或 `useHistory`。观察一个物化集合键时使用
-`useProjectionItem(titles, taskId)`，它忽略其他键和纯顺序变化。自定义集合 processor 通过
-writer.set/remove/order/replace 暂存输出，
-previous/next 读取只在作用域内有效。candidates 汇总整个 batch，以最终状态派生输出。
-React 追踪实际读取，但 processor 依赖仍显式声明。只有 source 键影响同名输出键时
-才使用 mapper。跨集合 join 应声明全部 source，并按
-[Projection 参考](projections.zh-CN.md)维护领域反向依赖索引。
+React 使用 Runtime 上下文中的 `useProjection` 读取 Projection，单键读取写成
+`useProjection(projection, selector)`；`useInput` 返回值和 setter。高级集合 processor
+从 `doxum/advanced` 引入，在同步 callback 中使用
+`output.set/remove/order/replace` 与 previous/next。Processor 依赖仍显式声明，
+React selector 追踪只属于消费端。

package/skills/doxum-runtime/references/projections.en.md

@@ -1,220 +1,77 @@
-# Doxum Projection Reference
-
-Use this reference when choosing, implementing, or reviewing a projection. The
-[public long-form contract](../../../docs/projections.md) provides a complete join
-example; source code inspection should not be necessary for normal application work.
-
-## Choose The Form
-
-| Relationship                                  | API                                               |
-| --------------------------------------------- | ------------------------------------------------- |
-| Whole document source                         | `project(document)`                               |
-| Target-limited document source                | `project(document, [pick, ...])`                  |
-| Document collection source                    | `project(document, pick)`                         |
-| One source key to the same output key         | `project(collection, mapper)`                     |
-| Pure current values to one value              | `project(sources, compute)`                       |
-| Stateful incremental value                    | `project({ kind: 'value', sources, build })`      |
-| Multiple sources or cross-key collection work | `project({ kind: 'collection', sources, build })` |
-| Application input                             | `input(initial)` and `store.set(input, value)`    |
-| Existing `Readable`                           | `project(readable)`                               |
-
-Definitions are lazy and reusable. `createProjectionStore({ onError })` owns one
-materialization graph. Every store has independent published values, revisions,
-inputs, subscriptions, processor instances, and closure indexes.
-
-An ordinary mapper is deliberately limited to:
-
-```text
-source key K changed -> output key K may change
-```
-
-It rebuilds on reset and follows source order, but does not track reads performed
-inside the mapper. Never read another collection in a mapper and assume it becomes
-a dependency. Declare all sources in an advanced processor instead.
+# Projection Reference
 
-## Source Event Contract
-
-Advanced processors receive events, not just current values:
+Projection definitions are lazy and reusable. The public core consists of
+`Projection<T>`, `ProjectionRuntime`, `input`, `observe`, and tuple `derive`.
 
 ```ts
-type ValueEvent<T> = {
-  value: T;
-  previous: T;
-  changed: boolean;
-  revision: number;
-  reset: boolean;
-};
-
-type CollectionEvent<K extends string, V> = {
-  get(key: K): V | undefined;
-  has(key: K): boolean;
-  ids(): readonly K[];
-  change: CollectionImpact<K> | undefined;
-  revision: number;
-  reset: boolean;
-};
-
-type DocumentEvent<S> = {
-  read: Read<S>;
-  revision: number;
-  commits: readonly DocumentCommit<S>[];
-  reset: boolean;
-};
-
-type DocumentCollectionEvent<S, N, K extends string> = {
-  read: CollectionAccess<K, N>;
-  revision: number;
-  commits: readonly DocumentCommit<S>[];
-  reset: boolean;
-  candidates: { keys: readonly K[]; orderDirty: boolean };
-};
+const tasks = observe(document, path => path.tasks);
+const filter = input<'all' | 'open'>('all');
+const visible = derive([tasks, filter], (tasks, filter) =>
+  filter === 'all' ? tasks : new Map([...tasks].filter(([, task]) => !task.done))
+);
+const runtime = createProjectionRuntime({ onError: report });
+runtime.get(visible);
 ```
 
-Projected collection `change` is incremental (`added`, `removed`, `updated`,
-`orderChanged`), reset, or undefined. Document collection candidates are the
-union across all relevant commits in a store batch. A later commit may cancel an
-earlier one without removing its candidate key. Always derive from final `read`
-state. Use `commit.impact.collection(pick)` for per-commit relationship changes.
+`input(initial, equality?)` is Runtime-local and can be written only with
+`runtime.set(input, value)`. `observe(document, selector)` compiles a document
+boundary lazily. Collection paths publish immutable map-like snapshots; the
+whole-document form publishes a snapshot of the root. Existing Doxum Readables
+can also be observed at this boundary.
 
-Across a batch, a value event's `previous` is the pre-batch value and `value` is
-the final value. A net-zero document transaction produces no commit or candidates.
+`derive(dependencies, compute, equality?)` takes a tuple. Dependencies are
+explicit and fixed when the definition is created. Processors must not discover
+graph dependencies by reading other projections.
 
-## Advanced Value Processor
+The Runtime API is intentionally small:
 
 ```ts
-const value = project({
-  kind: 'value',
-  sources,
-  build: events => ({
-    value: buildValue(events),
-    update: events =>
-      needsRebuild(events)
-        ? { kind: 'rebuild' }
-        : changed(events)
-          ? { kind: 'changed', value: updateValue(events) }
-          : { kind: 'unchanged' },
-  }),
-});
+runtime.get(projection);
+runtime.subscribe(projection, listener);
+runtime.set(input, value);
+runtime.batch({ cause }, run);
+runtime.dispose();
 ```
 
-Prefer `project(sources, compute)` unless retained state prevents meaningful work.
+There is no public revision, item handle, rebuild or release operation. Runtime
+materialization, keyed storage, recovery and disposal are one owner.
 
-## Advanced Collection Processor
+## Incremental processors
+
+Import retained-state processors from `doxum/advanced`:
 
 ```ts
-const result = project({
-  kind: 'collection',
-  sources,
-  name: 'optional diagnostic name',
-  isEqual: Object.is,
-  build: ({ sources, previous, next, writer }) => {
-    // Build the complete output and any store-local indexes.
-    return {
-      update: ({ sources, previous, next, writer }) => {
-        // Stage only affected keys, or return { kind: 'rebuild' }.
-      },
-    };
-  },
+const total = incremental([tasks], ({ sources, previous, state }) => {
+  state.calls = Number(state.calls ?? 0) + 1;
+  return sources[0].size + Number(state.calls) + (previous ?? 0);
 });
-```
-
-`build` runs on first materialization, source reset, explicit `store.rebuild`, an
-update-requested rebuild, and fault recovery. Build starts from a cleared output
-and must stage the complete result. Its closure state is local to one store and
-must be reconstructible from sources.
 
-`update` runs when a declared source participates in settlement. Returning
-`{ kind: 'rebuild' }` discards staged update writes and performs a fresh build.
-All callbacks are synchronous; Promises and thenables are rejected. Reads and
-writes during processing or notification must not reenter a source or document.
-
-`previous`, `next`, source readers, and `writer` are borrowed for the current
-synchronous callback only:
-
-- `previous` sees only published output.
-- `next` immediately sees current staged writes.
-- `writer.set(key, value)` stages presence.
-- `writer.remove(key)` stages absence; a missing removal is a no-op.
-- Repeated operations on one key use the last operation.
-- `writer.order(ids)` supplies the entire next order, with every key exactly once.
-- `writer.replace(entries)` clears and replaces all output in entry order; keys
-  must be unique.
-
-Staged output publishes atomically. Equality defaults to `Object.is`; equal sets
-keep the old reference. Net-zero output does not increment revision or notify.
-
-## Cross-Collection Join Pattern
+const doubled = incremental.collection([tasks], ({ sources, output }) => {
+  for (const [id, task] of sources[0]) output.set(id, task.value * 2);
+});
+```
 
-Do not add a generic join abstraction. The domain owns missing references,
-cardinality, reconnect, delete, ordering, and result-key policy. Model the join as
-an advanced collection with explicit sources and indexes.
+Value contexts expose `sources`, `previous`, `reset`, `change`, `cause` and a
+retained `state` object. `incremental.collection(...)` uses a separate
+collection processor protocol and additionally exposes borrowed
+`previous`/`next` keyed reads and a callback-local `output` draft. Draft methods are
+`set`, `remove`, `order`, and `replace`; the Runtime validates and seals them after
+the synchronous callback, computes keyed transitions and publishes one immutable
+map-like value. Reset or fault recovery is internal.
 
-For routes derived from `edges(from, to)` and node geometry, maintain:
+## React selector tracking
 
-```text
-endpoints: edgeId -> [fromNodeId, toNodeId]
-adjacency: nodeId -> Set<edgeId>
+```tsx
+const task = useProjection(visible, tasks => tasks.get(taskId));
+const [mode, setMode] = useInput(filter);
 ```
 
-On build, scan edges once, populate both indexes, and write the complete routes.
-On an edge event:
-
-1. Read exact changed edge ids from each commit's collection impact.
-2. Detach every changed id from its old endpoints.
-3. Read final edge state; attach its final endpoints, or delete its forward entry.
-4. Add that edge id to the affected output set.
-
-On a node collection event, map added/updated/removed node ids through `adjacency`
-and add only adjacent edges to the affected set. Finally read current endpoint
-geometry and set or remove each affected route. Rebuild on either source reset.
-
-After an edge reconnects, the old node must no longer select it. Deleting an edge
-must remove both forward and reverse entries. Missing endpoint behavior is an
-explicit domain decision. Do not scan all edges for every node change unless the
-known collection size makes that tradeoff intentional.
-
-Closure indexes are not part of the writer's staged transaction. An uncaught
-processor failure triggers fresh-build recovery, but a processor that catches a
-failure and continues keeps its own mutations. Perform fallible work before
-mutating live indexes, stage temporary index changes and commit them on success,
-or request a complete rebuild.
-
-## Batching, Faults, And Lifetime
-
-`store.batch` defers projection settlement and projection listeners only. Document
-commits and document listeners remain synchronous. Reads inside the batch return
-the last publication; settlement after the outer batch uses final source state.
-There is no cross-document rollback.
-
-Processor or writer validation failure publishes no partial output. The runtime
-may retry with a fresh build; persistent failure faults that projection and blocks
-its descendants while independent branches continue. Reads then throw
-`ProjectionError`. A later source update or `store.rebuild(projection)` can recover.
-`onError` also receives source, blocked, and listener failures. Listener failures
-never undo published projection state or accepted document commits.
-
-`store.release(projection)` releases an independently releasable materialization;
-do not release a node still used by a materialized downstream projection.
-`store.dispose()` invalidates the complete graph and releases its subscriptions.
-
-For one materialized collection entry, `store.item(collection, key)` returns a
-stable `Readable<V | undefined>`. It follows the key through add, update, remove,
-and recreation; other keys and order-only changes do not notify it. React uses
-`useProjectionItem(collection, key, store?)`. Key or store changes replace the
-subscription. The hook internally observes membership even when both absent and
-present values read as `undefined`. Raw document collection sources are not valid
-inputs; use `useDocumentSelector` for canonical document items.
-
-## Review Checklist
-
-- All result-changing sources are declared.
-- Candidate selection covers add, update, remove, reconnect, and missing reference.
-- Batch logic reads final state instead of replaying imagined intermediate states.
-- Reset and explicit rebuild reconstruct complete output, order, and indexes.
-- Build never depends on prior output or a previous processor closure.
-- `writer.order` is complete and valid whenever used.
-- Equal values preserve references; unrelated changes produce no output revision.
-- Item consumers use keyed readables/hooks instead of whole-collection value projections.
-- A thrown update cannot silently corrupt closure indexes.
-- Tests cover unrelated commits, dynamic dependencies, stable references, reset,
-  batch behavior, recovery, and disposal.
+Collection `get`/`has` records one key, `keys` records key/order structure, and
+`values`/iteration records the whole collection. Unrelated key changes do not run
+the selector. After a related update, the selector's equality (default
+`Object.is`) decides whether React re-renders. This tracking exists only at the
+consumer boundary; projection dependencies remain explicit.
+
+Processors settle before listeners. Writes are forbidden during notification.
+Listener errors do not roll back an accepted document commit; processor errors use
+the Runtime error callback and internal recovery.

package/skills/doxum-runtime/references/projections.zh-CN.md

@@ -1,203 +1,73 @@
-# Doxum Projection 参考
+# Projection 参考
 
-设计、实现或审查 projection 时使用本文。[公开完整契约](../../../docs/projections.md)
-提供完整 join 示例；正常应用开发不应再要求阅读运行时源码。
+Projection 定义是惰性、可复用的。默认入口只保留 `Projection<T>`、
+`ProjectionRuntime`、`input`、`observe` 和 tuple 形式的 `derive`。
 
-## 选择定义形式
-
-| 依赖关系                       | API                                               |
-| ------------------------------ | ------------------------------------------------- |
-| 整个文档作为 source            | `project(document)`                               |
-| 只关注指定文档路径             | `project(document, [pick, ...])`                  |
-| 一个文档集合 source            | `project(document, pick)`                         |
-| 一个 source 键映射到同名输出键 | `project(collection, mapper)`                     |
-| 当前 source 值纯计算出一个值   | `project(sources, compute)`                       |
-| 有状态增量 value               | `project({ kind: 'value', sources, build })`      |
-| 多 source 或跨键集合计算       | `project({ kind: 'collection', sources, build })` |
-| 应用输入                       | `input(initial)` 与 `store.set(input, value)`     |
-| 既有 `Readable`                | `project(readable)`                               |
-
-定义是惰性、可复用的描述。`createProjectionStore({ onError })` 拥有一个物化图。
-同一定义在不同 store 内分别拥有发布值、revision、input、订阅、processor 实例和闭包索引。
-
-普通 mapper 的契约有意限制为：
-
-```text
-source 键 K 变化 -> 输出键 K 可能变化
+```ts
+const tasks = observe(document, path => path.tasks);
+const filter = input<'all' | 'open'>('all');
+const visible = derive([tasks, filter], (tasks, filter) =>
+  filter === 'all' ? tasks : new Map([...tasks].filter(([, task]) => !task.done))
+);
+const runtime = createProjectionRuntime({ onError: report });
+runtime.get(visible);
 ```
 
-它在 reset 时重建并跟随 source 顺序，但不会追踪 mapper 内的读取。不要在 mapper
-里读取另一个集合并假定它自动成为依赖；应改用 advanced processor，并显式声明所有 source。
+`input(initial, equality?)` 属于每个 Runtime，只能通过
+`runtime.set(input, value)` 写入。`observe(document, selector)` 延迟编译文档
+边界；集合路径发布只读 map-like 快照，省略 selector 时发布整个文档快照。
+现有 Doxum `Readable` 也可以在这个边界接入。
 
-## Source Event 契约
+`derive(dependencies, compute, equality?)` 使用 tuple，依赖在定义创建时固定。
+Processor 不能通过读取另一个 Projection 隐式建立图依赖。
 
-advanced processor 接收 event，而不只是当前值：
+Runtime 的公开脊柱只有：
 
 ```ts
-type ValueEvent<T> = {
-  value: T;
-  previous: T;
-  changed: boolean;
-  revision: number;
-  reset: boolean;
-};
-
-type CollectionEvent<K extends string, V> = {
-  get(key: K): V | undefined;
-  has(key: K): boolean;
-  ids(): readonly K[];
-  change: CollectionImpact<K> | undefined;
-  revision: number;
-  reset: boolean;
-};
-
-type DocumentEvent<S> = {
-  read: Read<S>;
-  revision: number;
-  commits: readonly DocumentCommit<S>[];
-  reset: boolean;
-};
-
-type DocumentCollectionEvent<S, N, K extends string> = {
-  read: CollectionAccess<K, N>;
-  revision: number;
-  commits: readonly DocumentCommit<S>[];
-  reset: boolean;
-  candidates: { keys: readonly K[]; orderDirty: boolean };
-};
+runtime.get(projection);
+runtime.subscribe(projection, listener);
+runtime.set(input, value);
+runtime.batch({ cause }, run);
+runtime.dispose();
 ```
 
-投影集合的 `change` 可能是 incremental（`added`、`removed`、`updated`、
-`orderChanged`）、reset 或 undefined。文档集合的 candidates 是一个 store batch
-内所有相关 commit 的并集。后续 commit 即使抵消早先变化，也不会移除候选键。
-必须用最终 `read` 状态计算输出。需要维护关系索引时，用
-`commit.impact.collection(pick)` 取得每次 commit 的精确变化。
+revision、item handle、rebuild、release 都是 Runtime 内部事实，不是应用层操作。
+Materialization、keyed storage、故障恢复和释放只有一个 owner。
 
-batch 中 value event 的 `previous` 是 batch 前的值，`value` 是最终值。
-单个净零文档事务不会产生 commit 或 candidates。
+## 增量 Processor
 
-## Advanced Value Processor
+保留状态和 keyed patch 从 `doxum/advanced` 引入：
 
 ```ts
-const value = project({
-  kind: 'value',
-  sources,
-  build: events => ({
-    value: buildValue(events),
-    update: events =>
-      needsRebuild(events)
-        ? { kind: 'rebuild' }
-        : changed(events)
-          ? { kind: 'changed', value: updateValue(events) }
-          : { kind: 'unchanged' },
-  }),
+const total = incremental([tasks], ({ sources, previous, state }) => {
+  state.calls = Number(state.calls ?? 0) + 1;
+  return sources[0].size + Number(state.calls) + (previous ?? 0);
 });
-```
-
-除非保留状态能避免有意义的工作，否则优先使用 `project(sources, compute)`。
-
-## Advanced Collection Processor
 
-```ts
-const result = project({
-  kind: 'collection',
-  sources,
-  name: 'optional diagnostic name',
-  isEqual: Object.is,
-  build: ({ sources, previous, next, writer }) => {
-    // 构建完整输出和 store 局部索引。
-    return {
-      update: ({ sources, previous, next, writer }) => {
-        // 只暂存受影响的键，或返回 { kind: 'rebuild' }。
-      },
-    };
-  },
+const doubled = incremental.collection([tasks], ({ sources, output }) => {
+  for (const [id, task] of sources[0]) output.set(id, task.value * 2);
 });
 ```
 
-首次物化、source reset、显式 `store.rebuild`、update 请求 rebuild 以及 fault
-恢复时会调用 `build`。build 从已清空的输出开始，必须写出完整结果。
-其闭包状态只属于一个 store，并且必须能完全由 sources 重建。
-
-任一已声明 source 参与结算时调用 `update`。返回 `{ kind: 'rebuild' }` 会丢弃
-本次 update 暂存的写入，并执行全新 build。所有回调同步执行；Promise 和 thenable
-会被拒绝。processing 或 notification 中的读取和写入不得重入 source 或 document。
-
-`previous`、`next`、source reader 和 `writer` 都只在当前同步回调内有效：
-
-- `previous` 只看到已发布输出。
-- `next` 立即看到当前暂存的写入。
-- `writer.set(key, value)` 暂存存在值。
-- `writer.remove(key)` 暂存缺失；删除不存在的键是 no-op。
-- 同一键多次操作以最后一次为准。
-- `writer.order(ids)` 提供完整 next 顺序，每个输出键必须恰好出现一次。
-- `writer.replace(entries)` 清空并按 entries 顺序替换全部输出，键不能重复。
+Value context 包含 `sources`、`previous`、`reset`、`change`、`cause` 和持久
+`state`。`incremental.collection(...)` 使用独立的 collection processor 协议，
+另外提供借用的 `previous`/`next` keyed read，以及
+只在同步 callback 内有效的 `output` draft。Draft 只有 `set`、`remove`、`order`、
+`replace`；Runtime 在 callback 返回后校验并 seal，计算 keyed transitions，发布
+一个不可变 map-like 值。reset 或故障恢复由 Runtime 内部完成。
 
-暂存输出原子发布。相等判断默认使用 `Object.is`，相等的 set 保留旧引用。
-净零输出不增加 revision，也不通知 listener。
+## React selector 追踪
 
-## 跨集合 Join 模式
-
-不要增加通用 join 抽象。缺失引用、基数、重连、删除、顺序和结果键策略都属于领域逻辑。
-应使用带显式 sources 和索引的 advanced collection 表达 join。
-
-例如 route 由 `edges(from, to)` 和 node 几何信息计算，维护：
-
-```text
-endpoints: edgeId -> [fromNodeId, toNodeId]
-adjacency: nodeId -> Set<edgeId>
+```tsx
+const task = useProjection(visible, tasks => tasks.get(taskId));
+const [mode, setMode] = useInput(filter);
 ```
 
-build 时扫描一次 edges，填充两个索引并写出全部 routes。edge 变化时：
-
-1. 从每个 commit 的 collection impact 读取精确变化的 edge id。
-2. 将每个变化 id 从旧 endpoints 中解绑。
-3. 读取最终 edge 状态；绑定其最终 endpoints，或删除其正向索引。
-4. 将该 edge id 加入受影响输出集合。
-
-node 集合变化时，把 added/updated/removed node id 通过 `adjacency` 映射为相邻
-edge，并只将这些 edge 加入受影响集合。最后读取当前 endpoint 几何信息，对每个
-受影响 route 执行 set 或 remove。任一 source reset 都应 rebuild。
-
-edge 重连后，旧 node 不得再选中它；删除 edge 必须同时移除正向和反向索引。
-endpoint 缺失时的行为由领域显式定义。除非集合规模已知且权衡明确，不要在每次
-node 变化时扫描全部 edges。
-
-闭包索引不属于 writer 的 staged transaction。未捕获的 processor 失败会触发 fresh
-build 恢复，但 processor 如果自行捕获失败后继续执行，其索引修改会保留。先完成可能
-失败的工作再修改活动索引，或在临时状态上暂存索引变化并在成功后提交，或请求完整 rebuild。
-
-## Batch、Fault 与生命周期
-
-`store.batch` 只推迟 projection 结算和 projection listener；文档 commit 和文档
-listener 仍同步执行。batch 内读取返回上次发布值，最外层 batch 结束后根据最终
-source 状态结算。不提供跨文档回滚。
-
-processor 或 writer 校验失败不会发布部分输出。runtime 可以用新 build 重试；
-持续失败会使该 projection fault，并阻塞下游，独立分支仍继续工作。此时读取抛
-`ProjectionError`。后续 source 更新或 `store.rebuild(projection)` 可以恢复。
-`onError` 还接收 source、blocked 和 listener 失败。listener 失败不会撤销已发布
-projection 状态或已接受的文档 commit。
-
-`store.release(projection)` 释放可独立释放的物化结果；仍被已物化下游使用的节点
-不能释放。`store.dispose()` 使整个图失效并解除其全部订阅。
-
-观察一个物化集合项时，`store.item(collection, key)` 返回稳定的
-`Readable<V | undefined>`。它贯穿 add、update、remove 和 recreate；其他键和纯顺序
-变化不会通知它。React 使用 `useProjectionItem(collection, key, store?)`，key 或 store
-变化时替换订阅。hook 内部会观察 membership，即使 absent 与 present 值都读作
-`undefined`。原始文档集合 source 不能作为输入；canonical 文档项使用
-`useDocumentSelector`。
-
-## 审查清单
-
-- 所有能改变结果的 source 都已声明。
-- 候选选择覆盖 add、update、remove、reconnect 和缺失引用。
-- batch 逻辑读取最终状态，而不是模拟中间状态。
-- reset 和显式 rebuild 能重建完整输出、顺序和索引。
-- build 不依赖旧输出或旧 processor 闭包。
-- 使用 `writer.order` 时提供完整且有效的顺序。
-- 相等结果保留引用；无关变化不产生输出 revision。
-- 单项消费者使用 keyed readable/hook，而不是整个集合的 value projection。
-- update 抛错不会悄悄破坏闭包索引。
-- 测试覆盖无关 commit、动态依赖、稳定引用、reset、batch、恢复和 disposal。
+`get`/`has` 记录单 key，`keys` 记录 key/order 结构，`values` 或迭代记录整个
+集合。无关 key 的更新不会执行 selector；相关更新后才执行 selector，并由
+`equality`（默认 `Object.is`）决定是否重渲染。这是消费端优化，不会反向构建
+Projection processor 依赖。
+
+Processor 先于 listener settle。通知期间禁止写入。listener 错误不会回滚已经
+接受的文档 commit；processor 错误交给 Runtime error callback，并由 Runtime
+内部恢复。

package/dist/integration-BShL68Nc.cjs

@@ -1,30 +0,0 @@
-const require_store = require("./store-DBv58dns.cjs");
-//#region core/src/access/dependency.ts
-const createDependencyTracker = () => {
-	const targets = [];
-	return {
-		record: (value) => {
-			if (!targets.some((entry) => require_store.same(entry, value))) targets.push(value);
-		},
-		snapshot: () => Object.freeze(targets.slice())
-	};
-};
-//#endregion
-//#region core/src/integration.ts
-const track = (runtime, selector) => {
-	const dependencies = createDependencyTracker();
-	const value = require_store.readWith(runtime, selector, dependencies);
-	return Object.freeze({
-		value,
-		targets: dependencies.snapshot()
-	});
-};
-//#endregion
-Object.defineProperty(exports, "track", {
-	enumerable: true,
-	get: function() {
-		return track;
-	}
-});
-
-//# sourceMappingURL=integration-BShL68Nc.cjs.map

package/dist/integration-BShL68Nc.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"integration-BShL68Nc.cjs","names":["readWith"],"sources":["../core/src/access/dependency.ts","../core/src/integration.ts"],"sourcesContent":["import type { ImpactTarget } from '../schema';\nimport * as impactTarget from '../impact-target';\n\nexport type DependencyTracker = {\n  readonly record: (target: ImpactTarget<unknown>) => void;\n  readonly snapshot: () => readonly ImpactTarget<unknown>[];\n};\n\nexport const createDependencyTracker = (): DependencyTracker => {\n  const targets: ImpactTarget<unknown>[] = [];\n  return {\n    record: value => {\n      if (!targets.some(entry => impactTarget.same(entry, value))) targets.push(value);\n    },\n    snapshot: () => Object.freeze(targets.slice()),\n  };\n};\n","import type { ObjectNode, ImpactTarget } from './schema';\nimport type { Read } from './access/scope';\nimport type { DocumentReadable } from './runtime/contract';\nimport { createDependencyTracker } from './access/dependency';\nimport { readWith } from './runtime/access';\nexport { projectionStoreDebug } from './projection/store';\nexport type { AddressRef } from './address';\nexport { contains, debugKey, overlaps, read as readAddress, resolveAddress } from './address';\nexport { subscribeDependencies } from './runtime/notification';\nexport { same as sameTarget } from './impact-target';\nexport type { ImpactTarget } from './schema';\n\nexport type TrackedSelection<TValue> = {\n  readonly value: TValue;\n  readonly targets: readonly ImpactTarget<unknown>[];\n};\n\n// Framework adapters receive one immutable result instead of coordinating a\n// mutable collector with the reader's scoped lifetime themselves.\nexport const track = <TSchema extends ObjectNode, TValue>(\n  runtime: DocumentReadable<TSchema>,\n  selector: (read: Read<TSchema>) => TValue\n): TrackedSelection<TValue> => {\n  const dependencies = createDependencyTracker();\n  const value = readWith(runtime, selector, dependencies);\n  return Object.freeze({ value, targets: dependencies.snapshot() });\n};\n"],"mappings":";;AAQA,MAAa,gCAAmD;CAC9D,MAAM,UAAmC,EAAE;AAC3C,QAAO;EACL,SAAQ,UAAS;AACf,OAAI,CAAC,QAAQ,MAAK,UAAA,cAAA,KAA2B,OAAO,MAAM,CAAC,CAAE,SAAQ,KAAK,MAAM;;EAElF,gBAAgB,OAAO,OAAO,QAAQ,OAAO,CAAC;EAC/C;;;;ACIH,MAAa,SACX,SACA,aAC6B;CAC7B,MAAM,eAAe,yBAAyB;CAC9C,MAAM,QAAQA,cAAAA,SAAS,SAAS,UAAU,aAAa;AACvD,QAAO,OAAO,OAAO;EAAE;EAAO,SAAS,aAAa,UAAU;EAAE,CAAC"}

package/dist/integration-CWjttg7H.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"integration-CWjttg7H.js","names":["impactTarget.same"],"sources":["../core/src/access/dependency.ts","../core/src/integration.ts"],"sourcesContent":["import type { ImpactTarget } from '../schema';\nimport * as impactTarget from '../impact-target';\n\nexport type DependencyTracker = {\n  readonly record: (target: ImpactTarget<unknown>) => void;\n  readonly snapshot: () => readonly ImpactTarget<unknown>[];\n};\n\nexport const createDependencyTracker = (): DependencyTracker => {\n  const targets: ImpactTarget<unknown>[] = [];\n  return {\n    record: value => {\n      if (!targets.some(entry => impactTarget.same(entry, value))) targets.push(value);\n    },\n    snapshot: () => Object.freeze(targets.slice()),\n  };\n};\n","import type { ObjectNode, ImpactTarget } from './schema';\nimport type { Read } from './access/scope';\nimport type { DocumentReadable } from './runtime/contract';\nimport { createDependencyTracker } from './access/dependency';\nimport { readWith } from './runtime/access';\nexport { projectionStoreDebug } from './projection/store';\nexport type { AddressRef } from './address';\nexport { contains, debugKey, overlaps, read as readAddress, resolveAddress } from './address';\nexport { subscribeDependencies } from './runtime/notification';\nexport { same as sameTarget } from './impact-target';\nexport type { ImpactTarget } from './schema';\n\nexport type TrackedSelection<TValue> = {\n  readonly value: TValue;\n  readonly targets: readonly ImpactTarget<unknown>[];\n};\n\n// Framework adapters receive one immutable result instead of coordinating a\n// mutable collector with the reader's scoped lifetime themselves.\nexport const track = <TSchema extends ObjectNode, TValue>(\n  runtime: DocumentReadable<TSchema>,\n  selector: (read: Read<TSchema>) => TValue\n): TrackedSelection<TValue> => {\n  const dependencies = createDependencyTracker();\n  const value = readWith(runtime, selector, dependencies);\n  return Object.freeze({ value, targets: dependencies.snapshot() });\n};\n"],"mappings":";;AAQA,MAAa,gCAAmD;CAC9D,MAAM,UAAmC,EAAE;AAC3C,QAAO;EACL,SAAQ,UAAS;AACf,OAAI,CAAC,QAAQ,MAAK,UAASA,KAAkB,OAAO,MAAM,CAAC,CAAE,SAAQ,KAAK,MAAM;;EAElF,gBAAgB,OAAO,OAAO,QAAQ,OAAO,CAAC;EAC/C;;;;ACIH,MAAa,SACX,SACA,aAC6B;CAC7B,MAAM,eAAe,yBAAyB;CAC9C,MAAM,QAAQ,SAAS,SAAS,UAAU,aAAa;AACvD,QAAO,OAAO,OAAO;EAAE;EAAO,SAAS,aAAa,UAAU;EAAE,CAAC"}