doxum 0.1.28 → 0.1.30

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

@@ -1,138 +0,0 @@
-# Doxum Guide
-
-For exact signatures across `doxum`, `doxum/advanced`, `doxum/react`, and
-`doxum/local-sync`, use the [API reference](api.en.md). This guide focuses on choices
-and lifecycle semantics.
-
-## Define, Update And Read
-
-```ts
-import { createDocument, field, map, object, read, snapshot, type Infer } from 'doxum';
-
-const task = object({ title: field<string>(), done: field<boolean>() });
-const model = object({ tasks: map(task) });
-type DocumentValue = Infer<typeof model>;
-const document = createDocument({
-  schema: model,
-  initial: { tasks: { a: { title: 'Write', done: false } } },
-});
-document.update(draft => {
-  const task = draft.tasks.get('a');
-  if (task) task.done = !task.done;
-  draft.tasks.put('b', { title: 'Review', done: false });
-});
-const done = read(document, state => state.tasks.get('a')?.done);
-const tasks = read(document, state => snapshot(state.tasks));
-document.subscribe(
-  path => path.tasks.item('a').done,
-  commit => console.log(commit.changes)
-);
-```
-
-Root object is definition identity; runtime owns its data/revision. Updates are
-synchronous and atomic. Reads see preceding writes. Draft and the Read passed to a
-`read` selector are borrowed for the synchronous callback and must not escape.
-Throw TransactionRejected for expected rejection; ordinary throws
-restore all work and rethrow unchanged. False/undefined returns are business values.
-
-Object exposes editable members; field is atomic, including arrays and objects.
-Atomic values are deeply readonly in Infer and scoped access. Inputs, snapshots,
-commits and history share payload references. Object/variant structure accepts only
-declared own properties (plus the variant discriminant); extra string, symbol and
-non-enumerable properties are rejected. Use maps for dynamic keys and fields for
-arbitrary payload objects. Never mutate payloads through any alias,
-even after removal. Snapshot copies schema structure only; snapshot(rawPayload)
-returns its original readonly reference. Published data is not frozen. Field copiers
-are not supported; mutable exports and serialization belong to application boundaries.
-
-Infer preserves optional properties and flat variant unions. Read/Draft contain
-collection tools. Maps use explicit methods; table/list/tree overload replace for
-member and whole-container replacement. `replace(parent, key, inferValue)` handles
-plain replacement of object or variant members that contain collection data.
-
-## Containers And Validation
-
-| Definition                       | Data          | Draft methods                                             |
-| -------------------------------- | ------------- | --------------------------------------------------------- |
-| map(valueSchema, { key }?)       | record        | get/has/ids/put/remove/replace                            |
-| table(objectOrVariant, { key }?) | ids/byId      | get/has/ids/create/remove/move/reorder/replace            |
-| list(field, { keyOf })           | array         | get/has/ids/insert/remove/move/reorder/replace            |
-| tree(field)                      | rootId?/nodes | get/has/rootId/parent/children/insert/remove/move/replace |
-
-Read scopes expose only read methods. Map supports field/object/variant values;
-put is an upsert and removing a missing key is a no-op. `replace(id, value)` is
-existing-only for table/list/tree, preserves table/list order, and changes only a
-tree payload. `replace(value)` replaces a whole collection. List member replacement
-retains the addressed key. Simple arrays and strokes can be one
-atomic field. Optional supports field/variant/map/list/tree. Absent differs from
-present undefined. Variant tags are readonly; change branch by whole replacement.
-For table/list, `move(key | readonly key[], anchor?)` preserves a moved selection's
-current relative order and resolves the anchor after removal. `reorder(keys)` requires
-an exact permutation of current membership and changes only order.
-Trees may be empty. `tree(field(...))` requires an own `value` on every existing
-node; `tree(optional(field(...)))` explicitly permits missing node payloads, while
-`optional(tree(...))` independently permits the whole tree member to be absent.
-
-Function validators are synchronous predicates/assertions: `true` or `undefined`
-succeeds, `false` rejects, and assertions may throw. Standard Schema v1 validators
-must return the original input by identity; transformed output is rejected. Validators
-must not mutate input. Transform values before entering Doxum. parse(model, unknown) copies validated
-structure and shares readonly payloads; strict parse requires atomic validators.
-Branded map/table keys flow through methods, symbolic paths and impact.
-Path callbacks describe locations, including absent entries, and compile at registration.
-Core `select(document, selector, equality?)` tracks actual reads, changes dependencies
-when branching, and returns a standard `Readable`. React `useDocumentSelector`
-only adapts that Core readable to React.
-
-## Changes And Consumers
-
-Commits contain revision/source/changes/impact. ChangeSet groups members by owning
-container, with direct added/removed/updated transitions and optional before/after
-order in the same group. Order-only groups have empty members; standalone order
-changes and duplicate groups are invalid. Each group is applied completely before
-the next. Touched tree
-nodes retain structural semantics; reset is an explicit whole-document transition.
-Root member groups remain incremental. Net-zero changes do not publish.
-apply(changes, { expectedRevision }) rejects a missing or mismatched local baseline.
-Received before values are untrusted; local undo records actual old state.
-History travels complete ChangeSets; grouped travel is atomic. Local replace is a
-reversible root reset; remote commits invalidate local history. Observer errors occur
-after acceptance.
-
-Use `observe(document, path => path.tasks)` for a collection boundary and
-`derive({ tasks, filter }, ({ tasks, filter }) => ...)` for pure values. Definitions are
-lazy and materialized by one `createProjectionRuntime({ onError })` owner. When a
-keyed source determines output keys/order, map entries independently with
-`derive.keyed(entries, entry => entry.label)`. Dynamic keyed lookup stays in that
-same derivation through a named dependency object; plain Projection members are
-global dependencies, `{ source, key }` members are singular per-output-key lookups,
-and `{ source, keys }` members are ordered plural lookups. The
-selector receives `(entry, key, dependencies)`, while the Runtime owns the
-binding/reverse index and the producer DAG remains explicit. Use isolated
-`doxum/advanced` incremental entry points only for retained state, custom cross-key
-indexes or keyed patches that `derive.keyed` cannot express. See the [projection
-reference](projections.en.md) for lifecycle, draft semantics, selector tracking,
-batching and recovery.
-Tree structure uses the same projection source protocols: observe `path.tree.rootId`
-as a scalar, `path.tree.nodes` as a keyed collection, or
-`path.tree.nodes.item(id)` as a single node. Committed tree-node groups route directly
-to affected keyed entries and the existing `CollectionOutput` publishes ordinary
-`CollectionChange` entries; unrelated nodes keep stable snapshot references instead
-of being resnapshotted.
-`input` and `observe(source)` connect external boundary values, including
-eventful value and collection sources. Dispose the
-Runtime with the owning service. `runtime.batch` defers projection settlement and
-listeners, not document commits or listeners. Reads inside a batch see the last
-publication; no cross-document rollback is provided. React uses one
-`useProjection` hook with an optional selector and `useInput` for setters.
-
-doxum/local-sync attaches IndexedDB and Web Lock leadership. Only the leader writes;
-followers replay contiguous durable sequence. Writes become visible before async
-persistence; flush waits for durability. External replace and external remote-marked
-apply are forbidden while attached. Version 5 / format 3 rejects old storage without
-deleting or migrating it. The adapter accepts JSON values only. Change limits count
-logical members and tree nodes, not just outer groups.
-Limits govern new local commits only; existing durable commits remain readable
-under smaller current limits. Treat the whole published ChangeSet as readonly:
-its identity carries reusable structural validation, not authority to skip local
-revision, schema or actual-before checks.

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

@@ -1,116 +0,0 @@
-# Doxum 使用指南
-
-`doxum`、`doxum/advanced`、`doxum/react`、`doxum/local-sync` 的精确公开签名见
-[API 参考](api.zh-CN.md)。本指南只保留选择原则与生命周期语义。
-
-## 定义、修改与读取
-
-```ts
-import { createDocument, field, map, object, read, snapshot, type Infer } from 'doxum';
-
-const task = object({ title: field<string>(), done: field<boolean>() });
-const model = object({ tasks: map(task) });
-type DocumentValue = Infer<typeof model>;
-const document = createDocument({
-  schema: model,
-  initial: { tasks: { a: { title: 'Write', done: false } } },
-});
-document.update(draft => {
-  const task = draft.tasks.get('a');
-  if (task) task.done = !task.done;
-  draft.tasks.put('b', { title: 'Review', done: false });
-});
-const done = read(document, state => state.tasks.get('a')?.done);
-const tasks = read(document, state => snapshot(state.tasks));
-document.subscribe(
-  path => path.tasks.item('a').done,
-  commit => console.log(commit.changes)
-);
-```
-
-根 object 是定义身份，runtime 拥有状态与 revision。事务同步且原子，修改立即可读。
-Draft 和 `read` selector 接收的 Read 是同步回调内的借用视图，不得逃逸。预期拒绝抛 TransactionRejected；普通异常完整恢复后
-原样抛出。正常返回 false/undefined 是业务结果，不表示拒绝。
-
-object 暴露可编辑成员；field 是原子值，包括对象和数组。Infer 与作用域内原子值深只读；
-输入、快照、commit 和 history 共享 payload 引用，删除后也不能通过任何别名修改它。
-object/variant 结构只接受 schema 声明的自身属性及 variant 判别字段；额外的字符串、Symbol 和不可枚举属性都会被拒绝。
-动态键使用 map，任意对象内部数据使用 field；这个限制不检查 field 的 payload 内部。
-snapshot 只复制 schema 结构；snapshot(rawPayload) 返回原始只读引用。
-发布数据不做运行时冻结，不再支持字段 copier。需要可修改副本或序列化时由应用边界显式处理。
-
-Infer 保留 optional 属性和扁平 variant 联合。Read/Draft 带集合方法。map 使用显式方法；
-table/list/tree 的 replace 同时支持成员和整体替换。含集合数据的 object/variant 成员
-使用 `replace(parent, key, inferValue)` 传入普通 Infer 数据。
-
-## 容器与校验
-
-| 声明                             | 数据          | Draft 方法                                                |
-| -------------------------------- | ------------- | --------------------------------------------------------- |
-| map(valueSchema, { key }?)       | record        | get/has/ids/put/remove/replace                            |
-| table(objectOrVariant, { key }?) | ids/byId      | get/has/ids/create/remove/move/reorder/replace            |
-| list(field, { keyOf })           | 普通数组      | get/has/ids/insert/remove/move/reorder/replace            |
-| tree(field)                      | rootId?/nodes | get/has/rootId/parent/children/insert/remove/move/replace |
-
-Read 只暴露读取方法。map 支持 field/object/variant；put 是 upsert，remove 缺失键是 no-op。
-table/list/tree 的 `replace(id, value)` 只替换已存在成员，保持 table/list 顺序，且 tree
-只改变 payload；`replace(value)` 替换整个集合。list 替换项必须保持寻址键。
-简单数组与笔画可作为一个原子 field。optional 支持 field/variant/map/list/tree，
-缺失与存在的 undefined 不同。variant tag 只读，通过整体替换切换分支。
-table/list 的 `move(key | readonly key[], anchor?)` 会保持 moved selection 当前的相对顺序，
-并在移除 selection 后解析 anchor；`reorder(keys)` 要求与当前 membership 完全一致的排列，
-只改变顺序而不改变成员值。
-tree 可以为空。`tree(field(...))` 要求每个已存在节点都拥有自己的 `value`；只有
-`tree(optional(field(...)))` 才允许节点缺失 payload，而 `optional(tree(...))` 独立控制整棵
-tree 成员是否可以缺失。
-
-函数 validator 是同步 predicate/assertion：返回 `true` 或 `undefined` 成功，
-返回 `false` 拒绝，assertion 也可以 throw。Standard Schema v1 成功时必须按 identity
-返回原输入；transform output 会被拒绝。validator 不得修改输入。数据转换在进入 Doxum 前完成。
-parse(model, unknown) 复制校验后的结构并共享只读 payload；严格解析要求原子字段具备校验器。品牌键贯穿 map/table 方法、
-符号路径和 impact。路径回调描述地址，包括缺失键，订阅注册时解析。
-Core 的 `select(document, selector, equality?)` 追踪实际读取，在选择分支改变时更新
-依赖，并返回标准 `Readable`；React 的 `useDocumentSelector` 只负责把这个 Core
-readable 接到 React。
-
-## 变化与消费者
-
-commit 包含 revision/source/changes/impact。ChangeSet 按所属容器分组，成员以
-added/removed/updated 携带直接 before/after，不使用 Presence 包装。
-顺序变化放在同一 members 分组的可选 order.before/after 中；纯排序的 members 为空。
-不接受独立 order 记录或同地址重复分组，apply 逐组完成成员与顺序安装。
-tree 保留拓扑语义，reset 显式表达整体根过渡；根成员分组仍是增量变化。
-净零事务不发布。
-apply(changes, { expectedRevision }) 拒绝缺失或不匹配的本地基线；来包 before
-不作为本地 undo 真值，记录真实旧状态。history 重放完整 ChangeSet，分组原子旅行。
-本地 replace 是可撤销根重置，remote commit 使 history 失效。
-observerErrors 属于已提交结果。
-
-集合边界使用 `observe(document, path => path.tasks)`，纯派生值使用
-`derive({ tasks, filter }, ({ tasks, filter }) => ...)`。定义是惰性的，由一个
-`createProjectionRuntime({ onError })` owner 物化和管理。当一个 keyed source 决定
-output key/order 时，用 `derive.keyed(entries, entry => entry.label)` 独立映射每个
-entry；跨 collection 的动态 key lookup 继续在同一个 derivation 中用命名依赖对象声明：
-普通 Projection 成员是全局依赖，`{ source, key }` 是 singular lookup，`{ source, keys }`
-是有序 plural lookup，selector
-接收 `(entry, key, dependencies)`。Runtime 拥有 binding/reverse index，producer DAG
-仍保持显式。只有 `derive.keyed` 无法表达的 retained state、自定义跨 key index 或
-keyed patch 才放到隔离的 `doxum/advanced` incremental 入口。生命周期、draft、
-selector 追踪、batch 与故障恢复见 [Projection 参考](projections.zh-CN.md)。
-tree 结构复用同一套 projection source 协议：`path.tree.rootId` 是 scalar，
-`path.tree.nodes` 是 keyed collection，`path.tree.nodes.item(id)` 是单节点 value。
-committed tree node group 直接路由到受影响的 keyed entry，由现有
-`CollectionOutput` 发布普通 `CollectionChange`；未变化节点保持稳定的 snapshot
-引用，不再因单节点变化而全部重新 snapshot。
-`input` 与 `observe(source)` 接入外部边界值，包括带事件的 value 和 collection
-source。随所属服务 dispose Runtime。
-`runtime.batch` 推迟投影结算与通知，但不推迟文档提交和文档通知；内部读取上次发布值，
-不提供跨文档回滚。React 只保留一个带可选 selector 的 `useProjection`，输入使用
-`useInput`。
-
-doxum/local-sync 附着 IndexedDB 和 Web Lock 领导权，只有 leader 写入，
-follower 连续重放 durable seq。先可见后异步落盘，flush 等待持久化。
-附着期间禁止外部 replace 和外部标记 remote 的 apply。版本 5 / 格式 3 拒绝旧存储，
-保留数据且不迁移。适配器仅接收 JSON 值，变化数量限制统计逻辑成员和树节点，不能按外层分组数绕过。
-限额仅约束新产生的本地提交；减小当前限额不影响既有持久化提交的读取。
-整个已发布 ChangeSet 都必须只读，其身份可复用结构校验结果，但不跳过本地 revision、schema 和真实 before 检查。

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

@@ -1,53 +0,0 @@
-# Runtime 不变量
-
-公开调用形态统一放在 [api.zh-CN.md](api.zh-CN.md)；本文只保留影响实现和 review 的不变量。
-
-1. createDocument 唯一拥有 canonical state；Draft、apply、replace 共用 MutationSession。
-   runtime 统一执行、回滚、seal、发布边界，history 同样复用。
-   mutation/operations 按 table/list/order/tree/replay 分类完整操作，session 持有写入内核。
-   scope 经 session 绑定已解析事实，同 generation 复用 handle；这些均为内部实现边界。
-2. 公共读写同步且有作用域，禁止重入写入。失败恢复之前全部工作；普通异常原样抛出，
-   TransactionRejected 转换为 application issues。内部 readWith 返回借用 reader，
-   reader、子 proxy 和 collection method 不得逃逸同步回调。
-3. mutation/changes.ts 统一解析 unknown ChangeSet；schema 为寻址真值。
-   拒绝父子重叠事实与同地址重复分组。逐容器安装成员及可选顺序，不接受独立 order 记录。
-4. ChangeRecorder 按所属容器分组记录首次成员旧值，唯一拥有顺序基线和触及树节点。
-   有序组一次发布 members 与 order；树容器没有普通成员 layout，拒绝 members replay。
-   树命令直接捕获触及节点，不经过 session 回调协议。回滚不调用用户回调或校验器，seal 只发布净变化。
-   capture、restore 和按域 seal 分离；当前顺序确实变化后才复制最终 order，净变化为零也保留执行期间的回滚基线。
-5. 原子值按 Object.is 比较，canonical 结构依所有权契约保留原子引用；
-   快照只复制结构，payload 与 commit、history 共享且只读，不做深复制或发布冻结。
-   validator 直接读取原始输入且必须纯同步；函数形式是 predicate/assertion，
-   Standard Schema 成功时不能 transform canonical value。
-6. list 以稳定键标记身份，替换值必须保留键。anchor 拥有排序语义；
-   tree 拥有双向一致、连通、无环、空树或单根的拓扑约束。
-7. 公开 `Schema` / `ObjectSchema` handle 拥有定义身份，concrete node 留在内部；
-   schema model、path compiler、compiled layout、value validation/copy 各有唯一内部 owner，
-   foundation model/layout 不依赖 document/projection Runtime。runtime、history 和
-   `document.readonly()` alias 共享唯一 RuntimeContext 实例身份。
-   共享路径 compiler 与 Core impact target 算法拥有寻址、身份、相等、
-   分桶和精确匹配；React 只消费 Readable/select 契约。通知直接匹配分组变化，
-   不构建 commit impact 索引。
-8. apply 要求 expectedRevision，记录本地真实旧状态。本地 reset 可撤销，
-   remote commit 使 history 失效；group 在单个 session 中旅行。
-9. projection 显式声明 producer source，先于监听结算，producer DAG 保持静态。
-   `derive.keyed` 用一个命名依赖对象声明额外 source；`{ source, key }` 为每个 output key
-   绑定一个 source key，`{ source, keys }` 绑定有序且无重复的 source-key 集合。物化后的 Runtime
-   拥有这些 binding 和 reverse index，包括当前尚不存在的 source entry。processor
-   不通过 imperative Runtime read 创建图依赖。scope 只通过 `scope.own` 增加 lifecycle
-   ownership；scoped definition 可以依赖 root definition，root 与 sibling scope 不能依赖
-   scoped definition。通知失败不撤销提交；batch 推迟投影发布，不推迟文档提交与文档监听。
-   lazy definition metadata 不负责物化 source；input、observe、source materialization 分层。
-   一个 output object 同时拥有 staged/published state、revision、listener 和 graph-facing
-   consumer capability，只有 scheduler 连接/断开 dependency edge。collection input 的 callback
-   或 entry equality 抛错时不得安装部分 Runtime-local state。cleanup 先摘除 ownership，再穷尽
-   释放；初始化失败释放已创建的 projection resource，同时保留原始异常。document dirty/pending
-   state 只有一个写 owner，structural materialization 只读该状态。
-10. local-sync 使用 Web Lock 领导权和连续 durable seq，先可见后异步持久化。
-    版本 5 / 格式 3 拒绝旧数据库并保留原数据，附着期间禁止外部 replace 和 remote apply。
-11. core 框架无关，公开导出需明确用途；根 dist 为构建产物。
-12. 测试 malformed 输入、部分失败回滚、history、impact、dispose 和大集合工作量。
-    dependency 去重使用 impact target owner 提供的 canonical bucket，再做精确 equality；
-    不得退回全量线性扫描或新增字符串 path grammar。删除旧 API 和平行协议。
-
-网络意图、鉴权、协作撤销、先持久化后可见属于独立需求，不是隐藏 runtime 能力。

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

@@ -1,162 +0,0 @@
-# Doxum Patterns
-
-Exact call shapes and callback fields are listed in the [API reference](api.en.md).
-
-## Payload Or Structure
-
-```ts
-const point = object({ x: field<number>(), y: field<number>() });
-const model = object({
-  position: point,
-  stroke: field<readonly { x: number; y: number }[]>(),
-  rows: list(field<{ id: string; label: string }>(), { keyOf: row => row.id }),
-});
-```
-
-Edit position.x, replace stroke whole, and use rows.replace(key, value) for keyed item edits.
-
-## Complex Replacement
-
-```ts
-const model = object({
-  entries: map(object({ rows: table(object({ title: field<string>() })) })),
-});
-const document = createDocument({
-  schema: model,
-  initial: {
-    entries: {
-      a: { rows: { ids: ['x'], byId: { x: { title: 'First' } } } },
-    },
-  },
-});
-document.update(draft => {
-  const entry = draft.entries.get('a')!;
-  replace(entry, 'rows', {
-    ids: ['y'],
-    byId: { y: { title: 'Replacement' } },
-  });
-});
-```
-
-Use top-level `replace(parent, key, value)` for object/variant members whose Draft
-type contains collection tools. Map membership still uses `put`/`remove`; a
-collection's own `replace(next)` handles replacement when the collection itself is
-the mutation target.
-
-## Domain Keys
-
-```ts
-type PersonId = string & { readonly __person: unique symbol };
-const personId = (value: unknown): PersonId => {
-  if (typeof value !== 'string' || !value.startsWith('person:')) throw new Error('Person ID');
-  return value as PersonId;
-};
-const text = (value: unknown): string => {
-  if (typeof value !== 'string') throw new Error('String required');
-  return value;
-};
-const model = object({ people: map(object({ name: field(text) }), { key: personId }) });
-const initial = parse(model, { people: { 'person:1': { name: 'Ada' } } });
-```
-
-Branded key types flow through map/table methods, symbolic paths and collection impact.
-
-## Ordered Edits, History And Replay
-
-Use table.create/remove/move with anchors such as { at: 'start' } or { before: id }.
-Tree insert/move accept { parentId, index }; index is the final position after removal.
-Never directly edit topology records.
-
-A history group begins with document.history.group(); end() groups completed commits,
-cancel() restores its start. undo/redo travel complete ChangeSets atomically.
-Apply incoming changes with an expectedRevision and adapter-validated transport order.
-Remote commits invalidate local history. Local revision is not a distributed clock.
-
-Incoming member changes share the owning container address:
-
-```ts
-document.apply(
-  {
-    changes: [
-      {
-        kind: 'members',
-        at: ['tasks', 'a'],
-        members: [
-          { key: 'complete', kind: 'updated', before: false, after: true },
-          { key: 'title', kind: 'updated', before: 'First', after: 'Done' },
-        ],
-      },
-    ],
-  },
-  { expectedRevision: document.revision() }
-);
-```
-
-Use one group per container. Added members carry only after, removed members only
-before; present undefined is still a value. Never expand a group into legacy value
-envelopes or treat its container address as whole-container invalidation.
-
-## Projection And React
-
-```ts
-const rows = observe(document, path => path.rows);
-const metadata = observe(document, path => path.metadata);
-const density = input<'compact' | 'comfortable'>('comfortable');
-
-const labels = derive.keyed(rows, row => row.label);
-const decorated = derive.keyed(
-  rows,
-  {
-    meta: { source: metadata, key: row => row.metadataId },
-    density,
-  },
-  (row, _rowId, { meta, density }) => formatRow(row, meta, density)
-);
-const count = derive({ labels }, ({ labels }) => labels.size);
-const selection = input.collection<RowId, boolean>();
-const runtime = createProjectionRuntime({ onError: console.error });
-runtime.read(decorated);
-runtime.read(count);
-runtime.update(density, 'compact');
-runtime.update(selection, draft => draft.set(rowId, true));
-```
-
-Use named-object `derive` for aggregate values. Use `derive.keyed` when one keyed
-driver owns output keys/order. Its named dependency form handles singular/plural dynamic keyed lookups;
-the Runtime owns the binding/reverse index. Use `input.collection` for Runtime-local
-keyed UI/application state rather than canonical document state.
-
-Provide the Runtime or a scope through `ProjectionProvider`. `useProjection` reads
-projections, including `useProjection(projection, selector, equality?)`; `useInput`
-handles both scalar and collection inputs. Document selectors use
-`useDocumentSelector(document, selector, equality?)` independently of the provider.
-
-## Multi-output incremental processor
-
-Use this only when outputs share retained state or cross-key work that pure `derive`
-and `derive.keyed` cannot express:
-
-```ts
-const render = incremental.group(
-  { scene },
-  {
-    output: define => ({
-      cards: define.collection<string, Card>(),
-      count: define.value<number>(),
-    }),
-    state: () => ({ runs: 0 }),
-    process: ({ values, output, state }) => {
-      state.runs++;
-      const cards = buildCards(values.scene);
-      for (const [id, card] of cards) output.cards.set(id, card);
-      output.cards.order([...cards.keys()]);
-      output.count.set(cards.size);
-    },
-  }
-);
-```
-
-`define.value` / `define.collection` exist only inside the `output` declaration.
-The returned nested object mirrors ordinary Projection leaves from one processor.
-Dependencies are named; declare `state()` only when retained state is needed. Runtime
-recovery recreates declared state after a processor fault.

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

@@ -1,159 +0,0 @@
-# Doxum 常见模式
-
-精确调用形态和 callback 字段见 [API 参考](api.zh-CN.md)。
-
-## 原子值与结构
-
-```ts
-const point = object({ x: field<number>(), y: field<number>() });
-const model = object({
-  position: point,
-  stroke: field<readonly { x: number; y: number }[]>(),
-  rows: list(field<{ id: string; label: string }>(), { keyOf: row => row.id }),
-});
-```
-
-position.x 细粒度赋值；stroke 整体替换；rows.replace(key, value) 按稳定键替换项。
-
-## 含集合的整体替换
-
-```ts
-const model = object({
-  entries: map(object({ rows: table(object({ title: field<string>() })) })),
-});
-const document = createDocument({
-  schema: model,
-  initial: {
-    entries: {
-      a: { rows: { ids: ['x'], byId: { x: { title: 'First' } } } },
-    },
-  },
-});
-document.update(draft => {
-  const entry = draft.entries.get('a')!;
-  replace(entry, 'rows', {
-    ids: ['y'],
-    byId: { y: { title: 'Replacement' } },
-  });
-});
-```
-
-Draft 类型含集合方法的 object/variant 成员使用顶层 `replace(parent, key, value)`；
-map membership 仍使用 `put`/`remove`。当集合本身就是 mutation target 时，整体替换
-使用集合自身的 `replace(next)`。
-
-## 领域键
-
-```ts
-type PersonId = string & { readonly __person: unique symbol };
-const personId = (value: unknown): PersonId => {
-  if (typeof value !== 'string' || !value.startsWith('person:')) throw new Error('Person ID');
-  return value as PersonId;
-};
-const text = (value: unknown): string => {
-  if (typeof value !== 'string') throw new Error('String required');
-  return value;
-};
-const model = object({ people: map(object({ name: field(text) }), { key: personId }) });
-const initial = parse(model, { people: { 'person:1': { name: 'Ada' } } });
-```
-
-品牌键类型贯穿 map/table 方法、符号路径和 collection impact。
-
-## 顺序、History 与重放
-
-table.create/remove/move 使用 { at: 'start' } 或 { before: id } 等 anchor。
-tree.insert/move 接收 { parentId, index }，index 表示移除后的最终位置，
-不能直接修改拓扑记录。
-
-document.history.group() 开始分组，end() 分组已完成提交，cancel() 恢复起点；
-undo/redo 原子重放完整 ChangeSet。外部 apply 必须提供 expectedRevision，
-适配器还须校验传输顺序。remote commit 使本地 history 失效；
-本地 revision 不是分布式时钟。
-
-输入的成员变化共享所属容器地址：
-
-```ts
-document.apply(
-  {
-    changes: [
-      {
-        kind: 'members',
-        at: ['tasks', 'a'],
-        members: [
-          { key: 'complete', kind: 'updated', before: false, after: true },
-          { key: 'title', kind: 'updated', before: 'First', after: 'Done' },
-        ],
-      },
-    ],
-  },
-  { expectedRevision: document.revision() }
-);
-```
-
-每个容器只能有一组。added 仅携带 after，removed 仅携带 before；存在的 undefined
-仍是一个值。不要展开成旧 value envelope，也不要将分组地址当作整个容器失效。
-
-## 投影与 React
-
-```ts
-const rows = observe(document, path => path.rows);
-const metadata = observe(document, path => path.metadata);
-const density = input<'compact' | 'comfortable'>('comfortable');
-
-const labels = derive.keyed(rows, row => row.label);
-const decorated = derive.keyed(
-  rows,
-  {
-    meta: { source: metadata, key: row => row.metadataId },
-    density,
-  },
-  (row, _rowId, { meta, density }) => formatRow(row, meta, density)
-);
-const count = derive({ labels }, ({ labels }) => labels.size);
-const selection = input.collection<RowId, boolean>();
-const runtime = createProjectionRuntime({ onError: console.error });
-runtime.read(decorated);
-runtime.read(count);
-runtime.update(density, 'compact');
-runtime.update(selection, draft => draft.set(rowId, true));
-```
-
-聚合值使用 named-object `derive`。一个 keyed driver 拥有 output key/order 时使用
-`derive.keyed`；named dependency form 负责 singular/plural dynamic keyed lookup，binding/reverse
-index 由 Runtime 拥有。`input.collection` 用于 Runtime-local 的 keyed UI/application
-state，不进入 canonical document state。
-
-React 用 `ProjectionProvider` 提供 Runtime 或 scope；`useProjection` 支持
-`useProjection(projection, selector, equality?)`，`useInput` 同时支持 scalar 与
-collection input。Document selector 独立使用
-`useDocumentSelector(document, selector, equality?)`。
-
-## 多输出 incremental processor
-
-只有 pure `derive` / `derive.keyed` 无法表达共享 retained state 或 cross-key work 时使用：
-
-```ts
-const render = incremental.group(
-  { scene },
-  {
-    output: define => ({
-      cards: define.collection<string, Card>(),
-      count: define.value<number>(),
-    }),
-    state: () => ({ runs: 0 }),
-    process: ({ values, output, state }) => {
-      state.runs++;
-      const cards = buildCards(values.scene);
-      for (const [id, card] of cards) output.cards.set(id, card);
-      output.cards.order([...cards.keys()]);
-      output.count.set(cards.size);
-    },
-  }
-);
-```
-
-`define.value` / `define.collection` 只存在于 `output` 声明 callback 内，返回的嵌套
-object 会映射为同一 processor 的普通 Projection leaves。依赖按名称读取；只有需要
-retained state 时才声明 `state()`。processor fault 后由 Runtime 重新创建已声明的 state
-并恢复。