doxum 0.1.23 → 0.1.26

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

@@ -1,136 +1,235 @@
 # Projection 参考
 
-根 Projection 定义惰性且可跨 Runtime 复用；scope 定义惰性但只属于其局部生命周期。默认入口包含 `Projection<T>`、
-`ProjectionRuntime`、`input`、`observe` 和 tuple 形式的 `derive`。
+准确签名见 [API 参考](api.zh-CN.md)。这里说明 ownership、invalidation 与 recovery。
+
+## Ownership 与基础声明
+
+Projection definition 是惰性的。root definition 可跨多个 runtime 复用；scope definition
+属于一个 `ProjectionScope`。公开 `Projection<T>` 本身不保存 materialized value、
+retained state、subscription 或 disposal state。
+`KeyedProjection<K,V>` 是对应的公开 keyed handle，也可以安全出现在下游 package
+生成的声明中。
 
 ```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 visible = derive({ tasks, filter }, ({ tasks, filter }) =>
+  filter === 'all' ? tasks : filterOpen(tasks)
 );
+
 const runtime = createProjectionRuntime({ onError: report });
-runtime.get(visible);
+runtime.read(visible);
+```
+
+`ProjectionRuntime` 是 materialization、retained state、source attachment、settlement、
+publication 与 recovery 的唯一 owner。稳定 verb 为 `read`、`select`、overloaded
+`update`、`batch`、`scope`、`dispose`。
+
+`input(initial, equality?)` 是 scalar Runtime-local state；
+`input.collection(initial?, equality?)` 是 keyed Runtime-local application/UI state。
+两者都不进入 canonical document 的 history/persistence。
+
+## Source boundary
+
+`observe` 是唯一 source declaration 入口，可接入：
+
+- whole `ReadonlyDocument` 或 schema-path selection；
+- Doxum `Readable<T>`；
+- 公开 external value/collection source contract。
+
+Document 的 `map`、`table`、`list(field, { keyOf })` selection 会成为 keyed projection。
+list identity 来自 schema `keyOf`；原子 array-valued field 仍是 scalar。
+
+Tree 复用同一套 source model：
+
+```ts
+const rootId = observe(document, path => path.outline.rootId);
+const nodes = observe(document, path => path.outline.nodes);
+const node = observe(document, path => path.outline.nodes.item(nodeId));
+```
+
+`rootId` 是 scalar，`nodes` 是 keyed，`item(id)` 是单 node value。同一次 document
+commit 影响的 source projection 会在同一个 Runtime causal batch 中 settle。
+
+External collection impact 只是边界 invalidation hint。processor 看到之前，Runtime 会把
+它归一化为精确 `CollectionChange`。
+
+## Pure derive 与 keyed projection
+
+`derive(dependencies, compute, equality?)` 始终使用 named dependency object。
+definition 创建后依赖固定且显式。
+
+一个 keyed driver 拥有 output membership/order 时使用 `derive.keyed`：
+
+```ts
+const fieldValues = derive.keyed(records, record => record.values[fieldId]);
+```
+
+只有受影响 driver entry 会执行 selector。per-entry equality 判定 selected value 相等时，
+该 key 不发布 `updated`；added、removed、order 语义保持不变。
+
+Dynamic keyed lookup 仍使用同一个 API：
+
+```ts
+const cardContent = derive.keyed(
+  items,
+  {
+    record: { source: records, key: item => item.recordId },
+    view: activeView,
+    fields: visibleFields,
+  },
+  (item, itemId, { record, view, fields }) => renderCard(itemId, item, record, view, fields)
+);
 ```
 
-`input(initial, equality?)` 属于每个 Runtime，只能通过
-`runtime.set(input, value)` 写入。`observe(document, selector)` 延迟编译文档
-边界；集合路径发布只读 map-like 快照，省略 selector 时发布整个文档快照。
-现有 Doxum `Readable` 和带事件的 external source 也在这个边界接入。External
-source 通过 `kind: 'value'` 或 `kind: 'collection'` 区分语义，但调用方统一使用
-`observe(source)`。
+普通 Projection dependency 变化时使 driver key set 失效。`{ source, key }` 声明
+output-key → dynamic source-key dependency；Runtime 拥有 forward binding 和 reverse
+invalidation。selected source entry 缺失时仍保留 binding，因此以后新增该 source key
+会正确触发 dependent output key。
 
-schema map、table 和 `list(field, { keyOf })` 都是 keyed collection path。list
-直接使用 schema 的 `keyOf` 作为稳定 identity，并按文档顺序迭代；数组类型的普通
-`field(...)` 仍然是 scalar value observation。
-tree 结构复用相同的 source 类型：`path.tree.rootId` 是 scalar，
-`path.tree.nodes` 是 keyed collection，`path.tree.nodes.item(id)` 是单节点 value。
-tree 的 committed node group 直接路由到受影响的 keyed entry，由现有
-`CollectionOutput` 生成普通 `CollectionChange`；未变化节点的 snapshot identity
-保持稳定。
+这就是 keyed join 协议。不要再添加第二套 join abstraction、wildcard document path
+grammar 或 processor 内 imperative dependency discovery。
 
-External event 不再复用 Runtime context：value event 提供新 `value` 和
-`revision`；collection event 提供稳定的 `previous` read、`revision` 和可选的
-`impact` hint。Runtime 自己计算精确的 `CollectionChange`，processor 不会直接收到
-impact。
+## Runtime 读取、更新与 scope
 
-`derive(dependencies, compute, equality?)` 使用 tuple，依赖在定义创建时固定。
-Processor 不能通过读取另一个 Projection 隐式建立图依赖。
+```ts
+const value = runtime.read(visible);
+const selected = runtime.select(visible, rows => rows.get(rowId), equality);
+const stop = selected.subscribe(listener);
+
+runtime.update(filter, 'open');
+runtime.update(selection, draft => {
+  draft.set(rowId, true);
+  draft.remove(previousRowId);
+});
+
+runtime.batch(run, { cause });
+```
 
-Runtime 的公开脊柱只有：
+`select` 返回标准 `Readable`。keyed selector 追踪相关 key/structure 读取；只有发生
+相关 invalidation 后才执行 selector，随后 equality 决定是否发布结果。
+
+`CollectionInputDraft` 提供 `get`、`has`、`set`、`remove`，同步 edit callback 返回后
+失效。callback throw 时该次 edit 不应用。collection input equality 按 entry 比较，
+默认 `Object.is`，并在接受的本地状态安装前完成；equality 抛错时，published value 与
+下一次 draft 同样保持更新前状态。equal set 不替换存储值，也不发布。
 
 ```ts
-runtime.get(projection);
-const selected = runtime.readable(projection, value => value.get(id));
-selected.subscribe(listener);
-runtime.set(input, value);
-runtime.update(collectionInput, draft => draft.set(id, value));
-runtime.batch({ cause }, run);
 const scope = runtime.scope();
+const localFilter = scope.own(input<'all' | 'open'>('all'));
+const local = scope.own(
+  derive({ tasks, filter: localFilter }, ({ tasks, filter }) =>
+    filter === 'all' ? tasks : filterOpen(tasks)
+  )
+);
+scope.read(local);
+scope.update(localFilter, 'open');
 scope.dispose();
-runtime.dispose();
 ```
 
-`input.collection<K, V>(initial?)` 声明 Runtime 本地 keyed 状态。`update` 的借用 draft
-提供 `get`、`has`、`set`、`remove`；单次 callback 同步且原子，Runtime batch 发布一次
-精确的净 `CollectionChange`。scope 用 `scope.input`、`scope.derive`、
-`scope.incremental` 声明局部投影，直接依赖同一 Runtime 中的根投影；dispose 只释放
-局部 producer、状态和订阅。
+scope 与 parent Runtime 共享 scheduler/materialization owner。`scope.own` 为 projection
+definition 或静态 nested projection tree 赋予 lifecycle。scoped definition 可以依赖
+root definition；root 或 sibling scope 不能依赖 scoped definition，同一个 definition
+也不能属于两个 scope。必须在 definition 首次作为 root materialize 之前确定 scope
+ownership。
+
+## 唯一的 collection change 协议
+
+所有 keyed projection source/output 都使用：
+
+```ts
+type CollectionChange<K extends string, V> =
+  | { kind: 'reset' }
+  | {
+      kind: 'incremental';
+      added: readonly { key: K; after: V }[];
+      updated: readonly { key: K; before: V; after: V }[];
+      removed: readonly { key: K; before: V }[];
+      order?: { before: readonly K[]; after: readonly K[] };
+    };
+```
+
+advanced processor 需要显式标注该 transport type 时，从 `doxum/advanced` 导入
+`CollectionChange`；root projection consumer 不需要从 package root 导入它。
+
+initial materialization 和 source reset 对 advanced processor 报告 `reset`。
+incremental transition 是 settle 后 batch 边界上的 exact net change。
 
-Runtime 的 scheduler/output internals、item handle、rebuild、release 都是内部事实，不是应用层操作；
-只有 `Readable` 自己的 publication revision 为 store 集成保留为公开事实。
-Materialization、keyed storage、故障恢复和释放只有一个 owner。
+## Advanced processor
 
-## 增量 Processor
+只有 retained state、cross-key index 或直接 incremental output patch 无法用
+`derive` / `derive.keyed` 清晰表达时，才从 `doxum/advanced` 引入 `incremental`。
 
-保留状态和 keyed patch 从 `doxum/advanced` 引入：
+所有 advanced processor 都使用 named dependencies，并且 `process` 必需。只有确实需要
+retained state 时才声明 `state()`：
 
 ```ts
-const total = incremental([tasks], ({ sources, previous, state }) => {
-  state.calls = Number(state.calls ?? 0) + 1;
-  return sources[0].size + Number(state.calls) + (previous ?? 0);
-});
+const weights = incremental.collection(
+  { tasks },
+  {
+    state: () => ({ initialized: false }),
+    process: ({ values, changes, output, state, reset }) => {
+      if (reset) {
+        for (const [id, task] of values.tasks) output.set(id, task.weight);
+        output.order([...values.tasks.keys()]);
+        state.initialized = true;
+        return;
+      }
+
+      const change = changes.tasks;
+      if (!change || change.kind === 'reset') return;
+      for (const entry of change.added) output.set(entry.key, entry.after.weight);
+      for (const entry of change.updated) output.set(entry.key, entry.after.weight);
+      for (const entry of change.removed) output.remove(entry.key);
+      if (change.order) output.order([...values.tasks.keys()]);
+    },
+  }
+);
+```
 
-const doubled = incremental.collection([tasks], ({ sources, output }) => {
-  for (const [id, task] of sources[0]) output.set(id, task.value * 2);
-});
+`values`、`changes` 按 dependency 名称读取。scalar dependency 没有 collection change
+metadata。collection processor 额外提供 keyed `previous`、`next` 和 borrowed
+`output` draft。
+
+多输出 processor 使用一个 closed group definition：
 
+```ts
 const render = incremental.group(
-  [tasks],
-  define => ({
-    node: {
-      shell: define.collection<string, Shell>(),
-      content: define.collection<string, Content>(),
+  { tasks },
+  {
+    output: define => ({
+      shell: define.collection<RowId, Shell>(),
+      count: define.value<number>(),
+    }),
+    state: () => ({ runs: 0 }),
+    process: ({ values, output, state }) => {
+      state.runs++;
+      for (const [id, task] of values.tasks) output.shell.set(id, makeShell(task));
+      output.count.set(values.tasks.size);
     },
-    labels: define.collection<string, Label>(),
-    chrome: define.value<Chrome>(),
-    revision: define.value<number>(),
-  }),
-  ({ sources, outputs }) => {
-    for (const [id, task] of sources[0]) {
-      outputs.node.shell.set(id, makeShell(task));
-      outputs.node.content.set(id, makeContent(task));
-      outputs.labels.set(id, makeLabel(task));
-    }
-    outputs.chrome.set(makeChrome(sources[0]));
-    outputs.revision.set(sources[0].size);
   }
 );
 ```
 
-两种 processor context 都包含 `sources`、按依赖位置对齐的 `changes` tuple、
-`previous`、`reset`、`cause` 和持久 `state`。`changes[i]` 只对应第 `i` 个依赖：
-标量依赖为 `undefined`，集合依赖则是 `reset`，或带完整 `before`/`after` 值的
-`added`/`updated`/`removed` 分组，并可选提供 `order.before`/`order.after`。初次
-build 对集合依赖报告 `reset`；一次已提交的 batch 已经合并成一个净 transition。
-`sources` 内的集合值是 callback-local 的惰性 `ReadonlyMap` 视图，不能保存或直接
-返回。`get`/`has` 保持按 key 读取，迭代才显式扫描整个集合。
-
-`incremental.collection(...)` 使用独立的 collection processor 协议，另外提供借用的
-`previous`/`next` keyed read，以及
-只在同步 callback 内有效的 `output` draft。Draft 只有 `set`、`remove`、`order`；
-Runtime 在 callback 返回后校验并 seal，计算 keyed transitions，发布
-一个不可变 map-like 值。reset 或故障恢复由 Runtime 内部完成。
-`incremental.group(...)` 是多个命名 value / keyed collection output 的组合边界。
-`define.value<T>(equality?)` 声明 scalar leaf，`define.collection<K, V>(equality?)`
-声明 keyed leaf。嵌套 namespace 只是静态 API 组织，不是新的 producer、Runtime、scheduler 或事件协议。
-每个叶子都是指向同一个 processor producer 某个 output 的普通 `Projection`；一次 processor 执行先 seal 所有 leaf，再原子发布真正
-变化的 leaf，下游直接依赖这些叶子。initial build / rebuild 必须 set 每个 value leaf；
-普通增量轮次可以不触碰 value leaf，此时保留其现值和 revision。首次读取任一叶子只会
-物化该 producer 一次；scope dispose 也只会释放该 producer 和其保留状态一次。
-
-## React selector 追踪
-
-```tsx
-const task = useProjection(visible, tasks => tasks.get(taskId));
-const [mode, setMode] = useInput(filter);
-```
+`define.collection<K,V>(equality?)`、`define.value<T>(equality?)` 只存在于 `output`
+callback 内。返回的静态 object tree 会映射为同一 producer 的 projection leaves：
+collection 为 `KeyedProjection<K,V>`，value 为 `Projection<T>`。
+initial build 和 Runtime recovery 必须建立每个 value leaf；普通 incremental run 中未触碰
+value leaf 会保留已发布值。
+
+普通 source reset 保留已声明的 retained state。processor fault 的恢复由 Runtime 完成：
+重新创建已声明的 state 并执行 reset evaluation；stateless processor 走同一恢复路径但没有
+state object。没有公开 rebuild token 或手工 recovery hook。
+
+## React
 
-`get`/`has` 记录单 key，`keys` 记录 key/order 结构，`values` 或迭代记录整个
-集合。无关 key 的更新不会执行 selector；相关更新后才执行 selector，并由
-`equality`（默认 `Object.is`）决定 readable 是否发布。这是消费端优化，不会反向
-构建 Projection processor 依赖。
+`ProjectionProvider` 提供 Runtime 或 scope。`useProjection(projection, selector,
+equality?)` 使用同一套 Core selector 语义；`useInput` 同时支持 scalar/collection input。
+Document 读取独立使用：
+
+```ts
+const value = useDocumentSelector(document, selector, equality);
+```
 
-Processor 先于 listener settle。通知期间禁止写入。listener 错误不会回滚已经
-接受的文档 commit；processor 错误交给 Runtime error callback，并由 Runtime
-内部恢复。
+processor 先于 projection listener settle；processing/notifying 时禁止写。
+listener failure 不会 rollback 已接受的 document commit。

package/dist/advanced-CLJCWkHa.d.cts

@@ -1,176 +0,0 @@
-import { F as CollectionPath, K as ObjectNode, N as CollectionEntry, P as CollectionId, U as Infer, X as ReadonlyValue, Y as PathValueOf, Z as SchemaPath, _ as Unsubscribe, b as CollectionImpact, g as Readable, o as DocumentReadable, p as Synchronous } from "./contract-SYJFP0lM.cjs";
-
-//#region core/src/projection/contract.d.ts
-/** The one processor-facing collection transition protocol. */
-type CollectionChange<K extends string, V> = {
-  readonly kind: 'reset';
-} | {
-  readonly kind: 'incremental';
-  readonly added: readonly {
-    readonly key: K;
-    readonly after: V;
-  }[];
-  readonly updated: readonly {
-    readonly key: K;
-    readonly before: V;
-    readonly after: V;
-  }[];
-  readonly removed: readonly {
-    readonly key: K;
-    readonly before: V;
-  }[];
-  readonly order?: {
-    readonly before: readonly K[];
-    readonly after: readonly K[];
-  };
-};
-type CollectionRead<K extends string, V> = {
-  get(key: K): V | undefined;
-  has(key: K): boolean;
-  ids(): readonly K[];
-};
-type ExternalCollectionRead<K extends string, V> = {
-  readonly get: (key: K) => V | undefined;
-  readonly has: (key: K) => boolean;
-  readonly ids: () => readonly K[];
-};
-type ExternalValueSource<T> = {
-  readonly kind: 'value';
-  current(): T;
-  revision(): number;
-  subscribe(listener: (event: ExternalValueEvent<T>) => void): Unsubscribe;
-};
-type ExternalCollectionSource<K extends string, V> = {
-  readonly kind: 'collection';
-  current(): ExternalCollectionRead<K, V>;
-  revision(): number;
-  subscribe(listener: (event: ExternalCollectionEvent<K, V>) => void): Unsubscribe;
-};
-type ExternalValueEvent<T> = {
-  readonly value: T;
-  readonly revision: number;
-  readonly reset?: boolean;
-  readonly cause?: unknown;
-};
-type ExternalCollectionEvent<K extends string, V> = {
-  /** Stable read from the source before this event or external batch. */readonly previous: ExternalCollectionRead<K, V>;
-  readonly revision: number; /** Optional document-style hint; the adapter resolves the canonical change. */
-  readonly impact?: CollectionImpact<K>;
-  readonly cause?: unknown;
-};
-type CollectionDraft<K extends string, V> = {
-  set(key: K, value: V): void;
-  remove(key: K): void;
-  order(ids: readonly K[]): void;
-};
-declare class ProjectionError extends Error {
-  readonly phase: 'processor' | 'listener' | 'source' | 'blocked';
-  readonly identity: string;
-  readonly revisions: readonly number[];
-  constructor(phase: 'processor' | 'listener' | 'source' | 'blocked', identity: string, revisions: readonly number[], cause: unknown);
-}
-declare class ProjectionDisposedError extends Error {
-  constructor();
-}
-//#endregion
-//#region core/src/projection/definition.d.ts
-declare const projectionDefinition: unique symbol;
-declare const projectionChanges: unique symbol;
-declare const writableInput: unique symbol;
-/** A lazy output reference with no materialized Runtime state. */
-type Projection<T, C = undefined> = {
-  readonly [projectionDefinition]: T;
-  readonly [projectionChanges]: C;
-};
-/** A writable source projection. */
-type Input<T, C = undefined> = Projection<T, C> & {
-  readonly [writableInput]: true;
-};
-type ProjectionValues$1<D extends readonly Projection<unknown, unknown>[]> = { readonly [K in keyof D]: D[K] extends Projection<infer T, unknown> ? T : never };
-type Rebuild = {
-  readonly kind: 'rebuild';
-};
-declare const input: (<T>(initial: T, equality?: (previous: T, next: T) => boolean) => Input<T>) & {
-  collection: <K extends string, V>(initial?: ReadonlyMap<K, V>) => Input<ReadonlyMap<K, V>, CollectionChange<K, V>>;
-};
-/** Establish a lazy reactive boundary from a document, readable, or external source. */
-declare function observe<S extends ObjectNode>(document: DocumentReadable<S>): Projection<Infer<S>>;
-declare function observe<T>(source: ExternalValueSource<T>): Projection<T>;
-declare function observe<K extends string, V>(source: ExternalCollectionSource<K, V>): Projection<ReadonlyMap<K, V>, CollectionChange<K, V>>;
-declare function observe<T>(readable: Readable<T>): Projection<T>;
-declare function observe<S extends ObjectNode, P extends CollectionPath>(document: DocumentReadable<S>, selector: (path: SchemaPath<S['shape']>) => P): Projection<ReadonlyMap<CollectionId<P>, ReadonlyValue<CollectionEntry<P>>>, CollectionChange<CollectionId<P>, ReadonlyValue<CollectionEntry<P>>>>;
-declare function observe<S extends ObjectNode, P>(document: DocumentReadable<S>, selector: (path: SchemaPath<S['shape']>) => P): Projection<PathValueOf<P>>;
-declare function derive<const D extends readonly Projection<unknown, unknown>[], T>(dependencies: D, compute: (...values: ProjectionValues$1<D>) => Synchronous<T>, equality?: (previous: T, next: T) => boolean): Projection<T>;
-//#endregion
-//#region core/src/projection/advanced.d.ts
-type ProjectionValues<D extends readonly Projection<unknown, unknown>[]> = { readonly [K in keyof D]: D[K] extends Projection<infer T, unknown> ? T : never };
-type ProjectionChanges<D extends readonly Projection<unknown, unknown>[]> = { readonly [K in keyof D]: D[K] extends Projection<unknown, infer C> ? [C] extends [undefined] ? undefined : C | undefined : undefined };
-type IncrementalValueContext<D extends readonly Projection<unknown, unknown>[], T> = {
-  readonly sources: ProjectionValues<D>;
-  readonly changes: ProjectionChanges<D>;
-  readonly previous: T | undefined;
-  readonly reset: boolean;
-  readonly cause: unknown;
-  readonly state: Record<string, unknown>;
-};
-type IncrementalValueProcessor<D extends readonly Projection<unknown, unknown>[], T> = (context: IncrementalValueContext<D, T>) => T | Rebuild;
-type IncrementalCollectionContext<D extends readonly Projection<unknown, unknown>[], K extends string, V> = {
-  readonly sources: ProjectionValues<D>;
-  readonly changes: ProjectionChanges<D>;
-  readonly previous: CollectionRead<K, V>;
-  readonly next: CollectionRead<K, V>;
-  readonly reset: boolean;
-  readonly cause: unknown;
-  readonly state: Record<string, unknown>;
-  readonly output: CollectionDraft<K, V>;
-};
-type IncrementalCollectionProcessor<D extends readonly Projection<unknown, unknown>[], K extends string, V> = (context: IncrementalCollectionContext<D, K, V>) => void | Rebuild;
-declare const groupOutput: unique symbol;
-type GroupCollectionOutput<K extends string, V> = {
-  readonly [groupOutput]: {
-    readonly kind: 'collection';
-    readonly key: K;
-    readonly value: V;
-  };
-};
-type GroupValueOutput<T> = {
-  readonly [groupOutput]: {
-    readonly kind: 'value';
-    readonly value: T;
-  };
-};
-type GroupOutputShape = {
-  readonly [name: string]: GroupCollectionOutput<string, unknown> | GroupValueOutput<unknown> | GroupOutputShape;
-};
-type IncrementalGroupOutputTree = GroupOutputShape;
-type GroupOutputBuilder = {
-  collection<K extends string, V>(equality?: (previous: V, next: V) => boolean): GroupCollectionOutput<K, V>;
-  value<T>(equality?: (previous: T, next: T) => boolean): GroupValueOutput<T>;
-};
-type IncrementalGroupDefine = GroupOutputBuilder;
-type GroupProjections<O> = O extends GroupCollectionOutput<infer K, infer V> ? Projection<ReadonlyMap<K, V>, CollectionChange<K, V>> : O extends GroupValueOutput<infer T> ? Projection<T> : { readonly [P in keyof O]: GroupProjections<O[P]> };
-type GroupReads<O> = O extends GroupCollectionOutput<infer K, infer V> ? CollectionRead<K, V> : O extends GroupValueOutput<infer T> ? T | undefined : { readonly [P in keyof O]: GroupReads<O[P]> };
-type GroupDrafts<O> = O extends GroupCollectionOutput<infer K, infer V> ? CollectionDraft<K, V> : O extends GroupValueOutput<infer T> ? {
-  set(value: T): void;
-} : { readonly [P in keyof O]: GroupDrafts<O[P]> };
-type IncrementalGroupContext<D extends readonly Projection<unknown, unknown>[], O extends GroupOutputShape> = {
-  readonly sources: ProjectionValues<D>;
-  readonly changes: ProjectionChanges<D>;
-  readonly previous: GroupReads<O>;
-  readonly next: GroupReads<O>;
-  readonly outputs: GroupDrafts<O>;
-  readonly reset: boolean;
-  readonly cause: unknown;
-  readonly state: Record<string, unknown>;
-};
-type IncrementalGroupProcessor<D extends readonly Projection<unknown, unknown>[], O extends GroupOutputShape> = (context: IncrementalGroupContext<D, O>) => void | Rebuild;
-declare function createIncrementalValue<const D extends readonly Projection<unknown, unknown>[], T>(dependencies: D, processor: IncrementalValueProcessor<D, T>): Projection<T>;
-declare function createIncrementalCollection<const D extends readonly Projection<unknown, unknown>[], K extends string, V>(dependencies: D, processor: IncrementalCollectionProcessor<D, K, V>): Projection<ReadonlyMap<K, V>, CollectionChange<K, V>>;
-declare function createIncrementalGroup<const D extends readonly Projection<unknown, unknown>[], const O extends GroupOutputShape>(dependencies: D, defineOutputs: (define: GroupOutputBuilder) => O, processor: IncrementalGroupProcessor<D, O>): GroupProjections<O>;
-declare const incremental: typeof createIncrementalValue & {
-  collection: typeof createIncrementalCollection;
-  group: typeof createIncrementalGroup;
-};
-//#endregion
-export { ProjectionError as C, ProjectionDisposedError as S, ExternalCollectionEvent as _, IncrementalGroupDefine as a, ExternalValueEvent as b, IncrementalValueContext as c, Input as d, Projection as f, CollectionChange as g, observe as h, IncrementalGroupContext as i, IncrementalValueProcessor as l, input as m, IncrementalCollectionContext as n, IncrementalGroupOutputTree as o, derive as p, IncrementalCollectionProcessor as r, IncrementalGroupProcessor as s, GroupProjections as t, incremental as u, ExternalCollectionRead as v, ExternalValueSource as x, ExternalCollectionSource as y };
-//# sourceMappingURL=advanced-CLJCWkHa.d.cts.map