doxum 0.1.22 → 0.1.25

package/README.md

@@ -60,10 +60,14 @@ Committed observer failures are returned in `observerErrors` without rollback.
 ## Read And Observe
 
 ```ts
-import { read, snapshot } from 'doxum';
+import { read, select, snapshot } from 'doxum';
 
 const title = read(document, state => state.title);
 const tasks = read(document, state => snapshot(state.tasks));
+const selectedTitle = select(document, state => state.title);
+const stop = selectedTitle.subscribe(() => {
+  console.log(selectedTitle.current());
+});
 document.subscribe(
   path => path.tasks.item('b').title,
   commit => {
@@ -81,6 +85,10 @@ supported types, while classes/functions need application-specific handling.
 Use ordinary properties for fine-grained reads. Data callbacks read real values;
 path callbacks describe symbolic schema locations, including missing entries.
 Subscription paths compile once during registration.
+`select(document, selector, equality?)` returns a standard `Readable`. Core
+tracks exactly the document locations read by the selector, rebinds dependencies
+when selector branches change, and preserves the previous selected reference and
+publication revision when `equality` reports no result change.
 
 React integration:
 
@@ -91,9 +99,10 @@ const title = useDocumentSelector(document, state => state.title);
 const history = useHistory(document.history);
 ```
 
-React tracks fields actually read and updates dependencies when the selector
-branches. The core has no React dependency. `asReadable(document)` removes write
-capabilities while retaining selection, subscription and projection support.
+Document dependency tracking belongs to Core's `select`; the React adapter only
+subscribes to the resulting `Readable`. The core has no React dependency.
+`document.readonly()` returns a capability-stripped `ReadonlyDocument` alias for
+boundaries that must not receive document write APIs.
 
 ## Containers And Parsing
 
@@ -110,9 +119,11 @@ capabilities while retaining selection, subscription and projection support.
 
 Map/table key validators preserve branded string types through access, paths,
 projection keys and impact queries. Validators are pure, synchronous functions or
-Standard Schema v1 validators. They receive the original value, must not mutate it,
-and their successful output is ignored. Perform transformations before calling
-Doxum; it does not detect validator mutation or conversion. `parse(model, unknown)`
+Standard Schema v1 validators. Function validators are predicates/assertions: return
+`true` or `undefined` for success, `false` for rejection, or throw from an assertion.
+Standard Schema validation must return the original value by identity; transformed
+outputs are rejected. Validators must not mutate their input. Perform transformations
+before calling Doxum. `parse(model, unknown)`
 validates and copies schema structure while sharing readonly payloads. Strict parsing
 requires validators for atomic fields; typed in-memory fields can omit them.
 
@@ -196,6 +207,10 @@ values support reverse replay but are not trusted as local undo data; the runtim
 captures its actual old state. Revision is a local baseline, not a distributed
 conflict-resolution protocol.
 
+Local/system apply may opt out of history with `history: false`. Remote apply uses
+`{ expectedRevision, source: 'remote' }` and always invalidates local history; it has
+no independent history option.
+
 Published ChangeSets are readonly in their entirety, including envelope objects,
 addresses, transitions and order arrays. The runtime reuses validation of its own
 publications and normalized storage input by identity; fresh unknown input still
@@ -222,138 +237,223 @@ with `history: false` close the active group.
 
 ## Projections
 
+Projection definitions are lazy and reusable. A `ProjectionRuntime` owns materialization,
+incremental state, scheduling, publication, batching, recovery and Runtime-local inputs.
+
 ```ts
 import { createProjectionRuntime, derive, input, observe } from 'doxum';
 
 const tasks = observe(document, path => path.tasks);
 const filter = input<'all' | 'open'>('all');
-const visible = derive([tasks, filter], (all, mode) => {
-  if (mode === 'all') return all;
-  return new Map([...all].filter(([, task]) => !task.done));
-});
+
+const visible = derive({ tasks, filter }, ({ tasks, filter }) =>
+  filter === 'all' ? tasks : new Map([...tasks].filter(([, task]) => !task.done))
+);
 
 const runtime = createProjectionRuntime({ onError: console.error });
-runtime.get(visible);
-const selected = runtime.readable(visible, tasks => tasks.get('a'));
+
+const current = runtime.read(visible);
+const selected = runtime.select(visible, tasks => tasks.get('a'));
 const stop = selected.subscribe(() => selected.current());
-runtime.set(filter, 'open');
-runtime.batch({ cause: { action: 'refresh' } }, () => {
-  runtime.set(filter, 'all');
-  document.update(draft => {
-    draft.title = 'Updated';
-  });
-});
+
+runtime.update(filter, 'open');
+runtime.batch(
+  () => {
+    runtime.update(filter, 'all');
+    document.update(draft => {
+      draft.title = 'Updated';
+    });
+  },
+  { cause: { action: 'refresh' } }
+);
+
 stop();
+runtime.dispose();
+```
+
+The stable vocabulary is `read` for a synchronous current value, `select` for a
+`Readable`, and `observe` for declaring a lazy source boundary. `ProjectionRuntime`
+exposes `read`, `select`, `update`, `batch`, `scope` and `dispose`.
+`ProjectionScope` mirrors `read`, `select`, `update`, `batch` and `dispose`, plus
+`own(definitionOrTree)` for lifecycle ownership of lazy projection definitions.
+
+### Keyed projection
+
+`derive.keyed` preserves a keyed driver's membership and order while deriving entries
+independently. The simple form is a per-entry selector:
+
+```ts
+const fieldValues = derive.keyed(records, record => record.values[fieldId]);
 ```
 
-Root projection declarations are lazy and reusable; scoped declarations are
-lazy but tied to their scope. The Runtime owns `get`,
-`readable`, scalar `set`, keyed `update`, `batch`, `scope` and `dispose`;
-materialization, incremental state, publication and recovery stay inside that
-one Runtime. Collection values are
-immutable `ReadonlyMap`-like snapshots, while a `Readable` owns selector
-tracking, equality and subscription lifecycle.
+The output keeps one key per source entry. The selector runs only for affected keys,
+and the optional equality function suppresses `updated` output transitions when the
+derived value is equal.
 
-Local projections share the parent Runtime's scheduler and materialization owner:
+Dynamic joins stay explicit in the dependency graph. Declare keyed lookups and ordinary
+projection dependencies by name:
 
 ```ts
-const scope = runtime.scope();
-const localFilter = scope.input<'all' | 'open'>('all');
-const localVisible = scope.derive([tasks, localFilter], (tasks, filter) =>
-  filter === 'all' ? tasks : new Map([...tasks].filter(([, task]) => !task.done))
+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)
 );
-scope.get(localVisible);
-scope.dispose(); // Releases local producers, state and subscriptions; parent tasks remain.
 ```
 
-For Runtime-local keyed state, `input.collection` publishes the same exact
-`CollectionChange` as document collections. One `update` edits one or many keys
-atomically; the enclosing Runtime batch coalesces accepted edits into one net
-change:
+For `{ source, key }` dependencies, the Runtime owns output-key → source-key bindings
+and reverse invalidation. A missing source entry resolves to `undefined` but remains
+bound, so adding it later invalidates the dependent output keys. An ordinary projection
+dependency invalidates the driver key set when its value changes. Processor code never
+performs imperative Runtime reads to discover dependencies.
+
+### Runtime-local keyed state
+
+Use `input.collection` for selection, expanded state, local overrides and other
+Runtime-local keyed application/UI state:
 
 ```ts
-const overrides = input.collection<string, Task>();
-runtime.update(overrides, draft => {
-  draft.set(taskId, task);
-  draft.remove(oldTaskId);
+const selection = input.collection<RowId, SelectionState>(
+  new Map(),
+  (previous, next) => previous.selected === next.selected
+);
+
+runtime.update(selection, draft => {
+  draft.set(rowId, { selected: true });
+  draft.remove(previousRowId);
 });
 ```
 
-`observe` is the single source boundary for documents, Doxum `Readable` values,
-and eventful external sources. External sources declare `kind: 'value'` or
-`kind: 'collection'`; collection invalidation remains keyed internally. Schema
-`map`, `table`, and `list(field, { keyOf })` paths are all observed as keyed
-collection projections. Trees expose structural observation without a second
-projection protocol: `path.tree.rootId` is a scalar source,
-`path.tree.nodes` is a keyed collection source, and
-`path.tree.nodes.item(id)` is a single-node value source. A schema `list` uses its
-`keyOf` identity and publishes in document order; ordinary array-valued `field(...)`
-nodes remain scalar values.
-
-Document projection sources route committed groups directly to their observed
-targets, merge affected locations for the current projection batch, then combine the
-previously published snapshot with the canonical final value. A touched tree node
-replaces only that node structure and the necessary ancestor containers; unchanged
-tree-node snapshots keep their identity. Whole aggregate tree values still use the
-public `{ rootId?, nodes: Record }` shape, so changing a node may shallow-copy the
-`nodes` record, while native `tree.nodes` observation remains keyed and touches only
-changed nodes.
-
-For retained state, reverse indexes and keyed patches, use the isolated advanced
-entry point. Whole-value processors use `incremental(...)`; keyed collection
-processors use `incremental.collection(...)`:
+Its state is owned by the `ProjectionRuntime`, not the document, history or persistence.
+Updates are synchronous and atomic. It publishes exact keyed `CollectionChange`
+transitions and preserves order. The optional per-entry equality defaults to `Object.is`
+and suppresses equivalent `set` operations. Callback and equality failures leave both
+the published value and the next draft unchanged.
+
+The processor-facing `CollectionChange` type is exported by `doxum/advanced`.
+
+A root input definition can be materialized independently by several runtimes. Wrap any
+definition in `scope.own(...)` when its lifecycle belongs to one scope; scalar inputs,
+keyed inputs, derives and advanced group output trees all use the same ownership API.
+Ownership must be assigned before that definition is first materialized as a root.
+
+### Sources and scopes
+
+`observe` adapts documents, Doxum `Readable` values and exported external source
+contracts. Document `map`, `table` and `list(field, { keyOf })` paths become keyed
+collection projections. Trees reuse the same model: `path.tree.rootId` is scalar,
+`path.tree.nodes` is keyed and `path.tree.nodes.item(id)` is a single-node value source.
+
+```ts
+const scope = runtime.scope();
+const localFilter = scope.own(input<'all' | 'open'>('all'));
+const localVisible = scope.own(
+  derive({ tasks, filter: localFilter }, ({ tasks, filter }) =>
+    filter === 'all' ? tasks : new Map([...tasks].filter(([, task]) => !task.done))
+  )
+);
+
+scope.read(localVisible);
+scope.dispose();
+```
+
+A scope shares its parent Runtime's scheduler and source materialization but owns the
+lifetime of definitions passed to `scope.own`, their materialized producers, state and
+subscriptions. Scoped definitions may depend on root definitions; root definitions and
+sibling scopes cannot depend on scoped definitions. A materialized root definition cannot
+later be converted into a scoped definition.
+
+### Advanced processors
+
+Use `doxum/advanced` only when pure `derive` / `derive.keyed` cannot express retained
+state, cross-key indexes, or direct incremental patches. Dependencies are always named.
+The processor definition is closed and always owns `process()`. Add `state()` only when
+the processor actually needs Runtime-owned retained state.
 
 ```ts
 import { incremental } from 'doxum/advanced';
 
-const doubled = incremental.collection([tasks], ({ sources, output }) => {
-  for (const [id, task] of sources[0]) output.set(id, task.value * 2);
-});
+const doubled = 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.value * 2);
+        }
+        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.value * 2);
+      for (const entry of change.updated) output.set(entry.key, entry.after.value * 2);
+      for (const entry of change.removed) output.remove(entry.key);
+      if (change.order) output.order([...values.tasks.keys()]);
+    },
+  }
+);
+```
+
+`incremental(...)` produces one scalar value projection.
+`incremental.collection(...)` exposes keyed `previous`, `next` and `output`.
+`incremental.group(...)` runs one processor for several atomic output leaves:
 
+```ts
 const render = incremental.group(
-  [tasks],
-  define => ({
-    node: {
+  { tasks },
+  {
+    output: define => ({
       shell: define.collection<string, { readonly title: string }>(),
       content: define.collection<string, string>(),
+      count: define.value<number>(),
+    }),
+    state: () => ({ renders: 0 }),
+    process: ({ values, output, state }) => {
+      state.renders++;
+      for (const [id, task] of values.tasks) {
+        output.shell.set(id, { title: task.title });
+        output.content.set(id, task.title);
+      }
+      output.count.set(values.tasks.size);
     },
-    labels: define.collection<string, string>(),
-    chrome: define.value<{ readonly count: number }>(),
-    revision: define.value<number>(),
-  }),
-  ({ sources, outputs }) => {
-    for (const [id, task] of sources[0]) {
-      outputs.node.shell.set(id, { title: task.title });
-      outputs.node.content.set(id, task.title);
-      outputs.labels.set(id, task.title);
-    }
-    outputs.chrome.set({ count: sources[0].size });
-    outputs.revision.set(sources[0].size);
   }
 );
 ```
 
-Incremental processors receive a dependency-aligned `changes` tuple. Collection
-entries carry `added`/`updated`/`removed` transitions with complete
-`before`/`after` values, so a processor can patch indexes without rescanning the
-collection; scalar dependencies use `undefined` and the initial collection build
-reports `{ kind: 'reset' }`.
-`incremental.group` runs one processor for several named value and keyed collection
-outputs. `define.collection<K, V>(equality?)` creates a keyed leaf;
-`define.value<T>(equality?)` creates an ordinary scalar projection leaf. On an
-initial build or rebuild every value leaf must be set; on an incremental update an
-untouched value leaf keeps its published value. Its static nested namespace is only
-API organization: every leaf is an ordinary `Projection`, all changed leaves publish
-atomically in one causal settle, and downstream processors depend directly on those
-leaves. All leaves reference one producer, so reading any leaf materializes that
-producer once; split groups when outputs do not share computation or atomicity
-requirements. There is no group runtime, output event bus, or per-output runtime.
-
-In React, `useProjection(projection)` reads a value and
-`useProjection(projection, selector, equality?)` tracks keyed reads such as
-`tasks => tasks.get(taskId)`. Unrelated key changes do not execute that selector;
-equality only filters a selector result after a related change. `useInput(input)`
-returns the current value and its Runtime-local setter.
+`define.collection<K,V>(equality?)` and `define.value<T>(equality?)` are output
+declaration methods available only inside `output`. The returned object tree keeps the
+same shape with ordinary `Projection` leaves. Value leaves must be initialized on
+initial build or Runtime recovery; untouched value leaves retain their value during a
+normal incremental run.
+
+`values` and `changes` use the dependency names. Collection changes are exact
+`added` / `updated` / `removed` transitions plus optional `order`; scalar dependency
+changes are `undefined`. `reset` means the processor must reconcile from current source
+values. Ordinary source resets preserve retained state when one exists. If a processor
+faults, the Runtime owns recovery, recreates declared state, and performs a reset
+evaluation. Stateless processors use the same recovery path without a state object.
+
+### React
+
+```ts
+const task = useProjection(tasks, tasks => tasks.get(taskId), equality);
+const [mode, setMode] = useInput(filter);
+const [selectedRows, updateSelectedRows] = useInput(selection);
+```
+
+`useProjection(projection, selector, equality?)` uses the same keyed selector semantics
+as Core. `useInput` handles both scalar `Input<T>` and `CollectionInput<K,V>`; collection
+updates receive a keyed draft callback. `ProjectionProvider` accepts either a
+`ProjectionRuntime` or `ProjectionScope`.
 
 See [projection contracts](docs/projections.md).
 
@@ -364,6 +464,11 @@ runtime. One leader writes synchronously and persists final changes asynchronous
 followers apply the durable sequence in order. `flush()` waits for persistence.
 Durability errors do not roll back an already visible commit.
 
+Operational failures use one `LocalSyncError` contract. Error states and `onError`
+receive that same typed error and preserve an underlying `cause` when one exists.
+Exceptions thrown by consumers of `state.subscribe` stay outside synchronization
+fault state and are not reported through operational `onError`.
+
 The storage format is IndexedDB version 5 with format version 3 records. Earlier
 databases are rejected without upgrading, deleting or converting their data.
 This JSON adapter rejects non-JSON atomic values. Network collaboration and
@@ -395,7 +500,7 @@ It also reports structural generation advances and distinguishes captured order
 baselines from final published order copies. Architecture workloads include order
 round trips and repeated tree edits to expose costs hidden by commit-only benchmarks.
 
-Builds produce root `dist` ESM/CJS/declarations for `doxum`, `doxum/integration`,
+Builds produce root `dist` ESM/CJS/declarations for `doxum`,
 `doxum/local-sync`, `doxum/react` and `doxum/advanced`. Source ownership is described in
 [architecture](docs/architecture.md) and [AGENTS.md](AGENTS.md).
 The runtime shares one transaction lifecycle; complete mutation operations are

package/dist/advanced.cjs

@@ -1,3 +1,238 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_advanced = require("./advanced-GKZ-CZ6a.cjs");
-exports.incremental = require_advanced.incremental;
+const require_scheduler = require("./scheduler-D4VthaaK.cjs");
+const require_record = require("./record-ChYUi8PP.cjs");
+//#region core/src/projection/advanced.ts
+const resetCollectionChange = Object.freeze({ kind: "reset" });
+const publicValue = (source) => source.kind === "value" ? source.value : require_scheduler.collectionView(source.read);
+const compileDependencies = (dependencies) => {
+	if (!require_record.isPlainObject(dependencies) || require_scheduler.isProjection(dependencies)) throw new TypeError("Incremental dependencies must be a plain object.");
+	const names = [];
+	const projections = [];
+	for (const key of Reflect.ownKeys(dependencies)) {
+		if (typeof key !== "string") throw new TypeError("Incremental dependency names must be strings.");
+		const descriptor = Object.getOwnPropertyDescriptor(dependencies, key);
+		if (!descriptor?.enumerable || !("value" in descriptor)) throw new TypeError("Incremental dependencies must be enumerable data properties.");
+		require_scheduler.projectionRef(descriptor.value);
+		names.push(key);
+		projections.push(descriptor.value);
+	}
+	return Object.freeze({
+		names: Object.freeze(names),
+		projections: Object.freeze(projections)
+	});
+};
+const publicInputs = (sources, names, reset) => {
+	const values = Object.create(null);
+	const changes = Object.create(null);
+	for (let index = 0; index < names.length; index++) {
+		const source = sources[index];
+		values[names[index]] = publicValue(source);
+		changes[names[index]] = source.kind === "collection" ? reset ? resetCollectionChange : source.change : void 0;
+	}
+	return Object.freeze({
+		values: Object.freeze(values),
+		changes: Object.freeze(changes)
+	});
+};
+function validateDefinition(definition, allowed, label) {
+	if (!require_record.isPlainObject(definition)) throw new TypeError(`${label} definition must be a plain object.`);
+	const allowedKeys = new Set(allowed);
+	for (const key of Reflect.ownKeys(definition)) {
+		if (typeof key !== "string" || !allowedKeys.has(key)) throw new TypeError(`${label} definition contains an unknown property.`);
+		const descriptor = Object.getOwnPropertyDescriptor(definition, key);
+		if (!descriptor?.enumerable || !("value" in descriptor)) throw new TypeError(`${label} definition must contain enumerable data properties.`);
+	}
+}
+const validateRetainedState = (definition, label) => {
+	if (Object.prototype.hasOwnProperty.call(definition, "state") && typeof definition.state !== "function") throw new TypeError(`${label} state must be a function when provided.`);
+};
+const initializeRetainedState = (definition) => {
+	if (definition.state === void 0) return Object.freeze({});
+	const state = definition.state();
+	require_scheduler.assertSynchronous(state);
+	return Object.freeze({ state });
+};
+function createIncrementalValue(dependencies, definition) {
+	const compiled = compileDependencies(dependencies);
+	validateDefinition(definition, ["state", "process"], "Incremental value");
+	validateRetainedState(definition, "Incremental value");
+	if (typeof definition.process !== "function") throw new TypeError("Incremental value definition requires a process function.");
+	const [projection] = require_scheduler.defineProcessor({
+		dependencies: compiled.projections,
+		outputs: [{
+			kind: "value",
+			equality: Object.is
+		}],
+		create: () => {
+			const state = initializeRetainedState(definition);
+			return { evaluate: (evaluation) => {
+				const output = evaluation.outputs[0];
+				if (output.kind !== "value") throw new Error("Incremental value output is invalid.");
+				const publicInput = publicInputs(evaluation.sources, compiled.names, evaluation.reset);
+				const result = definition.process({
+					values: publicInput.values,
+					changes: publicInput.changes,
+					previous: output.previous,
+					reset: evaluation.reset,
+					cause: evaluation.cause,
+					...state
+				});
+				require_scheduler.assertSynchronous(result);
+				output.output.set(result);
+			} };
+		}
+	});
+	return projection;
+}
+function createIncrementalCollection(dependencies, definition) {
+	const compiled = compileDependencies(dependencies);
+	validateDefinition(definition, ["state", "process"], "Incremental collection");
+	validateRetainedState(definition, "Incremental collection");
+	if (typeof definition.process !== "function") throw new TypeError("Incremental collection definition requires a process function.");
+	const [projection] = require_scheduler.defineProcessor({
+		dependencies: compiled.projections,
+		outputs: [{
+			kind: "collection",
+			equality: Object.is
+		}],
+		create: () => {
+			const state = initializeRetainedState(definition);
+			return { evaluate: (evaluation) => {
+				const output = evaluation.outputs[0];
+				if (output.kind !== "collection") throw new Error("Incremental collection output is invalid.");
+				const publicInput = publicInputs(evaluation.sources, compiled.names, evaluation.reset);
+				require_scheduler.assertSynchronous(definition.process({
+					values: publicInput.values,
+					changes: publicInput.changes,
+					previous: output.previous,
+					next: output.next,
+					reset: evaluation.reset,
+					cause: evaluation.cause,
+					output: output.output,
+					...state
+				}));
+			} };
+		}
+	});
+	return projection;
+}
+const isPlainGroupNamespace = (value, metadata) => require_record.isPlainObject(value) && !metadata.has(value);
+const compileGroupShape = (value, path, metadata, used, outputs) => {
+	if (value !== null && typeof value === "object") {
+		const output = metadata.get(value);
+		if (output) {
+			if (used.has(value)) throw new TypeError("An incremental group output cannot be reused.");
+			used.add(value);
+			const index = outputs.length;
+			outputs.push({
+				kind: output.kind,
+				equality: output.equality,
+				path: Object.freeze([...path])
+			});
+			return index;
+		}
+	}
+	if (!isPlainGroupNamespace(value, metadata)) throw new TypeError("Incremental group outputs must be a static object tree.");
+	for (const key of Reflect.ownKeys(value)) {
+		if (typeof key !== "string") throw new TypeError("Incremental group output names must be strings.");
+		if (!Object.prototype.propertyIsEnumerable.call(value, key)) throw new TypeError("Incremental group namespaces must contain enumerable properties.");
+	}
+	const keys = Object.keys(value);
+	if (!keys.length) throw new TypeError("Incremental group namespaces cannot be empty.");
+	const result = Object.create(null);
+	for (const key of keys) {
+		if (key === "__proto__" || key === "prototype" || key === "constructor") throw new TypeError(`Invalid incremental group output name: ${key}`);
+		const descriptor = Object.getOwnPropertyDescriptor(value, key);
+		if (!descriptor || !("value" in descriptor)) throw new TypeError("Incremental group namespaces cannot contain accessors.");
+		result[key] = compileGroupShape(descriptor.value, [...path, key], metadata, used, outputs);
+	}
+	return Object.freeze(result);
+};
+const hydrateGroupShape = (shape, values) => {
+	if (typeof shape === "number") return values[shape];
+	const result = {};
+	for (const [key, child] of Object.entries(shape)) result[key] = hydrateGroupShape(child, values);
+	return Object.freeze(result);
+};
+const hydrateGroupReads = (shape, outputs, next) => {
+	if (typeof shape === "number") {
+		const output = outputs[shape];
+		return next && output.kind === "value" ? output.next() : next ? output.next : output.previous;
+	}
+	const result = {};
+	for (const [key, child] of Object.entries(shape)) if (typeof child === "number" && next && outputs[child].kind === "value") Object.defineProperty(result, key, {
+		enumerable: true,
+		configurable: false,
+		get: () => outputs[child].next()
+	});
+	else result[key] = hydrateGroupReads(child, outputs, next);
+	return Object.freeze(result);
+};
+function createIncrementalGroup(dependencies, definition) {
+	const compiled = compileDependencies(dependencies);
+	validateDefinition(definition, [
+		"output",
+		"state",
+		"process"
+	], "Incremental group");
+	validateRetainedState(definition, "Incremental group");
+	if (typeof definition.output !== "function" || typeof definition.process !== "function") throw new TypeError("Incremental group definition requires output and process functions.");
+	let active = true;
+	const metadata = /* @__PURE__ */ new Map();
+	const declared = definition.output({
+		collection: (equality = Object.is) => {
+			if (!active) throw new TypeError("Incremental group output declarations are synchronous.");
+			const descriptor = Object.freeze({});
+			metadata.set(descriptor, {
+				kind: "collection",
+				equality
+			});
+			return descriptor;
+		},
+		value: (equality = Object.is) => {
+			if (!active) throw new TypeError("Incremental group output declarations are synchronous.");
+			const descriptor = Object.freeze({});
+			metadata.set(descriptor, {
+				kind: "value",
+				equality
+			});
+			return descriptor;
+		}
+	});
+	require_scheduler.assertSynchronous(declared);
+	active = false;
+	const outputs = [];
+	const used = /* @__PURE__ */ new Set();
+	const shape = compileGroupShape(declared, [], metadata, used, outputs);
+	if (typeof shape === "number") throw new TypeError("Incremental group declarations must return an output namespace.");
+	if (used.size === 0 || used.size !== metadata.size) throw new TypeError("Every incremental group output must be returned by the declaration.");
+	return hydrateGroupShape(shape, require_scheduler.defineProcessor({
+		dependencies: compiled.projections,
+		outputs,
+		create: () => {
+			const state = initializeRetainedState(definition);
+			return { evaluate: (evaluation) => {
+				const publicInput = publicInputs(evaluation.sources, compiled.names, evaluation.reset);
+				require_scheduler.assertSynchronous(definition.process({
+					values: publicInput.values,
+					changes: publicInput.changes,
+					previous: hydrateGroupReads(shape, evaluation.outputs, false),
+					next: hydrateGroupReads(shape, evaluation.outputs, true),
+					output: hydrateGroupShape(shape, evaluation.outputs.map((output) => output.output)),
+					reset: evaluation.reset,
+					cause: evaluation.cause,
+					...state
+				}));
+			} };
+		},
+		name: `processor-group:${outputs.map((output) => output.path?.join(".") ?? "").join(",")}`
+	}));
+}
+const incremental = Object.assign(createIncrementalValue, {
+	collection: createIncrementalCollection,
+	group: createIncrementalGroup
+});
+//#endregion
+exports.incremental = incremental;
+
+//# sourceMappingURL=advanced.cjs.map