doxum 0.1.12 → 0.1.14

package/README.md

@@ -60,10 +60,10 @@ Committed observer failures are returned in `observerErrors` without rollback.
 ## Read And Observe
 
 ```ts
-import { select, snapshot } from 'doxum';
+import { read, snapshot } from 'doxum';
 
-const title = select(document, state => state.title);
-const tasks = select(document, state => snapshot(state.tasks));
+const title = read(document, state => state.title);
+const tasks = read(document, state => snapshot(state.tasks));
 document.subscribe(
   path => path.tasks.item('b').title,
   commit => {
@@ -209,44 +209,53 @@ with `history: false` close the active group.
 ## Projections
 
 ```ts
-import { createProjectionStore, input, project } from 'doxum';
+import { createProjectionRuntime, derive, input, observe } from 'doxum';
 
-const titles = project(
-  document,
-  path => path.tasks,
-  (id, task) => `${id}: ${task.title}`
-);
-const count = project({ titles }, ({ titles }) => titles.ids().length);
-const zoom = input(1);
-const scaled = project({ count, zoom }, ({ count, zoom }) => count * zoom);
-
-const store = createProjectionStore({ onError: console.error });
-store.get(scaled);
-store.set(zoom, 2);
-const title = store.item(titles, taskId); // Stable Readable<string | undefined>.
+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 runtime = createProjectionRuntime({ onError: console.error });
+runtime.get(visible);
+runtime.set(filter, 'open');
+runtime.batch({ cause: { action: 'refresh' } }, () => {
+  runtime.set(filter, 'all');
+  document.update(draft => {
+    draft.title = 'Updated';
+  });
+});
 ```
 
-Projection declarations are lazy and reusable. A `ProjectionStore` owns
-materialized values, subscriptions, batching, processor state and disposal.
-`project(document, path)` binds a document collection; adding a mapper performs
-incremental keyed mapping. `project(readable)` bridges an external readable.
-Pure computations receive current values. Advanced processors use tagged specs:
-`project({ kind: 'value', sources, build })` and
-`project({ kind: 'collection', sources, build })`.
-Document collection events provide scoped `read.get/has/ids`, final candidate
-keys, order dirtiness, commits and reset state.
-Ordinary mappers intentionally model only one-source, same-key transforms.
-Cross-collection relationships use an advanced collection processor with explicit,
-application-owned dependency indexes; processor reads are not tracked automatically.
-For per-key observation, `store.item(collection, key)` returns a stable `Readable`
-that only notifies for that key. React components use
-`useProjectionItem(collection, key)`; unrelated keys and order-only changes do not
-rerender the component.
-
-Processors settle before external listeners. `store.batch` defers graph
-settlement and projection notifications, but document commits/listeners remain
-synchronous. Projection readers inside the batch see the last publication.
-Dispose projection stores with their owning service.
+Projection declarations are lazy and reusable. The only Runtime operations are
+`get`, `subscribe`, `set`, `batch` and `dispose`; materialization, incremental
+state, publication and recovery stay inside the Runtime. Collection values are
+immutable `ReadonlyMap`-like snapshots, so callers do not hold lifecycle handles.
+
+`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.
+
+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(...)`:
+
+```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);
+});
+```
+
+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.
+
 See [projection contracts](docs/projections.md).
 
 ## Local Sync
@@ -288,7 +297,7 @@ baselines from final published order copies. Architecture workloads include orde
 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`,
-`doxum/local-sync` and `doxum/react`. Source ownership is described in
+`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
 organized by domain under `core/src/mutation/operations`, with access, first-touch

package/dist/advanced.cjs

@@ -0,0 +1,116 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_definition = require("./definition-BDW6i7fp.cjs");
+//#region core/src/projection/advanced.ts
+const dependenciesOf = (dependencies) => Object.fromEntries(dependencies.map((dependency, index) => [`d${index}`, dependency]));
+const sourceChange = (sources) => {
+	for (const source of Object.values(sources)) if (source && typeof source === "object" && "change" in source && source.change !== void 0) return source.change;
+};
+const sourceCause = (sources) => {
+	for (const source of Object.values(sources)) if (source && typeof source === "object" && "cause" in source && source.cause !== void 0) return source.cause;
+};
+const publicSource = (source) => {
+	if (!source || typeof source !== "object") return source;
+	if ("value" in source) return source.value;
+	if ("read" in source) {
+		const read = source.read;
+		if (read && typeof read === "object" && "ids" in read && typeof read.ids === "function") {
+			const result = /* @__PURE__ */ new Map();
+			for (const id of read.ids()) result.set(id, read.get(id));
+			return result;
+		}
+		return require_definition.snapshot(read);
+	}
+	if ("ids" in source && typeof source.ids === "function") {
+		const result = /* @__PURE__ */ new Map();
+		const read = source;
+		for (const id of read.ids()) result.set(id, read.get(id));
+		return result;
+	}
+	return source;
+};
+const publicTuple = (sources) => Object.keys(sources).sort((left, right) => Number(left.slice(1)) - Number(right.slice(1))).map((key) => publicSource(sources[key]));
+const normalizeValue = (result) => result && typeof result === "object" && result.kind === "value" ? {
+	value: result.value,
+	state: result.state
+} : { value: result };
+function createIncrementalValue(dependencies, processor) {
+	const dependencyMap = dependenciesOf(dependencies);
+	let state = Object.create(null);
+	let current;
+	const build = (sources) => {
+		state = Object.create(null);
+		const result = processor({
+			sources: publicTuple(sources),
+			previous: void 0,
+			reset: true,
+			change: void 0,
+			cause: sourceCause(sources),
+			state
+		});
+		if (result && typeof result === "object" && "kind" in result) throw new TypeError("Initial incremental processor cannot rebuild.");
+		const normalized = normalizeValue(result);
+		current = normalized.value;
+		if (normalized.state) state = normalized.state;
+		return {
+			value: current,
+			update: (nextSources) => {
+				const next = processor({
+					sources: publicTuple(nextSources),
+					previous: current,
+					reset: false,
+					change: sourceChange(nextSources),
+					cause: sourceCause(nextSources),
+					state
+				});
+				if (next && typeof next === "object" && "kind" in next) return next;
+				const nextValue = normalizeValue(next);
+				current = nextValue.value;
+				if (nextValue.state) state = nextValue.state;
+				return {
+					kind: "changed",
+					value: current
+				};
+			}
+		};
+	};
+	return require_definition.defineIncrementalValue({
+		dependencies: dependencyMap,
+		build
+	});
+}
+function createIncrementalCollection(dependencies, processor) {
+	const dependencyMap = dependenciesOf(dependencies);
+	let state = Object.create(null);
+	const build = (input) => {
+		state = Object.create(null);
+		if (processor({
+			sources: publicTuple(input.sources),
+			previous: input.previous,
+			next: input.next,
+			reset: true,
+			change: void 0,
+			cause: sourceCause(input.sources),
+			state,
+			output: input.writer
+		})?.kind === "rebuild") throw new TypeError("Initial incremental collection processor cannot rebuild.");
+		return { update: (nextInput) => processor({
+			sources: publicTuple(nextInput.sources),
+			previous: nextInput.previous,
+			next: nextInput.next,
+			reset: false,
+			change: sourceChange(nextInput.sources),
+			cause: sourceCause(nextInput.sources),
+			state,
+			output: nextInput.writer
+		}) };
+	};
+	return require_definition.defineIncrementalCollection({
+		dependencies: dependencyMap,
+		build
+	});
+}
+const incremental = Object.assign(createIncrementalValue, { collection: createIncrementalCollection });
+//#endregion
+exports.incremental = incremental;
+
+//# sourceMappingURL=advanced.cjs.map

package/dist/advanced.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"advanced.cjs","names":["snapshot","defineIncrementalValue","defineIncrementalCollection"],"sources":["../core/src/projection/advanced.ts"],"sourcesContent":["import type { Projection, ProjectionValues, PublicCollection } from './definition';\nimport { defineIncrementalCollection, defineIncrementalValue } from './definition';\nimport type { CollectionDraft, CollectionRead, GraphSources } from './contract';\nimport { snapshot } from '../access/scope';\n\nexport type IncrementalState = Record<string, unknown>;\n\nexport type IncrementalValueContext<S, T> = {\n  readonly sources: S;\n  readonly previous: T | undefined;\n  readonly reset: boolean;\n  readonly change: unknown;\n  readonly cause: unknown;\n  readonly state: IncrementalState;\n};\n\nexport type IncrementalValueProcessor<S, T> = (\n  context: IncrementalValueContext<S, T>\n) =>\n  | T\n  | { readonly kind: 'value'; readonly value: T; readonly state?: IncrementalState }\n  | { readonly kind: 'rebuild' };\n\nexport type IncrementalCollectionContext<S, K extends string, V> = {\n  readonly sources: S;\n  readonly previous: CollectionRead<K, V>;\n  readonly next: CollectionRead<K, V>;\n  readonly change: unknown;\n  readonly reset: boolean;\n  readonly cause: unknown;\n  readonly state: IncrementalState;\n  readonly output: CollectionDraft<K, V>;\n};\n\nexport type IncrementalCollectionProcessor<S, K extends string, V> = (\n  context: IncrementalCollectionContext<S, K, V>\n) => void | { readonly kind: 'rebuild' };\n\ntype DependencyMap<D extends readonly Projection<unknown>[]> = {\n  readonly [K in keyof D as `d${Extract<K, number>}`]: D[K];\n};\n\nconst dependenciesOf = <D extends readonly Projection<unknown>[]>(dependencies: D): GraphSources =>\n  Object.fromEntries(\n    dependencies.map((dependency, index) => [`d${index}`, dependency])\n  ) as unknown as GraphSources;\n\nconst sourceChange = (sources: Record<string, unknown>): unknown => {\n  for (const source of Object.values(sources)) {\n    if (\n      source &&\n      typeof source === 'object' &&\n      'change' in source &&\n      (source as { readonly change?: unknown }).change !== undefined\n    )\n      return (source as { readonly change?: unknown }).change;\n  }\n  return undefined;\n};\n\nconst sourceCause = (sources: Record<string, unknown>): unknown => {\n  for (const source of Object.values(sources)) {\n    if (\n      source &&\n      typeof source === 'object' &&\n      'cause' in source &&\n      (source as { readonly cause?: unknown }).cause !== undefined\n    )\n      return (source as { readonly cause?: unknown }).cause;\n  }\n  return undefined;\n};\n\nconst publicSource = (source: unknown): unknown => {\n  if (!source || typeof source !== 'object') return source;\n  if ('value' in source) return (source as { readonly value: unknown }).value;\n  if ('read' in source) {\n    const read = (source as { readonly read: unknown }).read;\n    if (\n      read &&\n      typeof read === 'object' &&\n      'ids' in read &&\n      typeof (read as { ids?: unknown }).ids === 'function'\n    ) {\n      const result = new Map<string, unknown>();\n      for (const id of (read as CollectionRead<string, unknown>).ids())\n        result.set(id, (read as CollectionRead<string, unknown>).get(id));\n      return result;\n    }\n    return snapshot(read);\n  }\n  if ('ids' in source && typeof (source as { ids?: unknown }).ids === 'function') {\n    const result = new Map<string, unknown>();\n    const read = source as CollectionRead<string, unknown>;\n    for (const id of read.ids()) result.set(id, read.get(id));\n    return result;\n  }\n  return source;\n};\n\nconst publicTuple = (sources: Record<string, unknown>): readonly unknown[] =>\n  Object.keys(sources)\n    .sort((left, right) => Number(left.slice(1)) - Number(right.slice(1)))\n    .map(key => publicSource(sources[key]));\n\nconst normalizeValue = <T>(\n  result: T | { readonly kind: 'value'; readonly value: T; readonly state?: IncrementalState }\n): { value: T; state?: IncrementalState } =>\n  result && typeof result === 'object' && (result as { readonly kind?: unknown }).kind === 'value'\n    ? {\n        value: (result as { readonly value: T }).value,\n        state: (result as { readonly state?: IncrementalState }).state,\n      }\n    : { value: result as T };\n\nfunction createIncrementalValue<const D extends readonly Projection<unknown>[], T>(\n  dependencies: D,\n  processor: IncrementalValueProcessor<ProjectionValues<D>, T>\n): Projection<T> {\n  const dependencyMap = dependenciesOf(dependencies);\n  let state: IncrementalState = Object.create(null) as IncrementalState;\n  let current!: T;\n  const build = (sources: Record<string, unknown>) => {\n    state = Object.create(null) as IncrementalState;\n    const result = processor({\n      sources: publicTuple(sources) as ProjectionValues<D>,\n      previous: undefined,\n      reset: true,\n      change: undefined,\n      cause: sourceCause(sources),\n      state,\n    });\n    if (result && typeof result === 'object' && 'kind' in result)\n      throw new TypeError('Initial incremental processor cannot rebuild.');\n    const normalized = normalizeValue(result as T);\n    current = normalized.value;\n    if (normalized.state) state = normalized.state;\n    return {\n      value: current,\n      update: (nextSources: Record<string, unknown>) => {\n        const next = processor({\n          sources: publicTuple(nextSources) as ProjectionValues<D>,\n          previous: current,\n          reset: false,\n          change: sourceChange(nextSources),\n          cause: sourceCause(nextSources),\n          state,\n        });\n        if (next && typeof next === 'object' && 'kind' in next) return next;\n        const nextValue = normalizeValue(next as T);\n        current = nextValue.value;\n        if (nextValue.state) state = nextValue.state;\n        return { kind: 'changed', value: current } as const;\n      },\n    };\n  };\n  return defineIncrementalValue({ dependencies: dependencyMap, build: build as never });\n}\n\nfunction createIncrementalCollection<\n  const D extends readonly Projection<unknown>[],\n  K extends string,\n  V,\n>(\n  dependencies: D,\n  processor: IncrementalCollectionProcessor<ProjectionValues<D>, K, V>\n): Projection<PublicCollection<K, V>> {\n  const dependencyMap = dependenciesOf(dependencies);\n  let state: IncrementalState = Object.create(null) as IncrementalState;\n  const build = (input: {\n    readonly sources: Record<string, unknown>;\n    readonly previous: CollectionRead<K, V>;\n    readonly next: CollectionRead<K, V>;\n    readonly writer: CollectionDraft<K, V>;\n  }) => {\n    state = Object.create(null) as IncrementalState;\n    const result = processor({\n      sources: publicTuple(input.sources) as ProjectionValues<D>,\n      previous: input.previous,\n      next: input.next,\n      reset: true,\n      change: undefined,\n      cause: sourceCause(input.sources),\n      state,\n      output: input.writer,\n    });\n    if (result?.kind === 'rebuild')\n      throw new TypeError('Initial incremental collection processor cannot rebuild.');\n    return {\n      update: (nextInput: typeof input) =>\n        processor({\n          sources: publicTuple(nextInput.sources) as ProjectionValues<D>,\n          previous: nextInput.previous,\n          next: nextInput.next,\n          reset: false,\n          change: sourceChange(nextInput.sources),\n          cause: sourceCause(nextInput.sources),\n          state,\n          output: nextInput.writer,\n        }),\n    };\n  };\n  return defineIncrementalCollection({ dependencies: dependencyMap, build: build as never });\n}\n\nexport const incremental = Object.assign(createIncrementalValue, {\n  collection: createIncrementalCollection,\n});\n\nexport type IncrementalDependencies<D extends readonly Projection<unknown>[]> = DependencyMap<D>;\n"],"mappings":"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"}

package/dist/advanced.d.cts

@@ -0,0 +1,42 @@
+import { i as PublicCollection, l as CollectionDraft, n as Projection, r as ProjectionValues, u as CollectionRead } from "./definition-DN6yW2vi.cjs";
+
+//#region core/src/projection/advanced.d.ts
+type IncrementalState = Record<string, unknown>;
+type IncrementalValueContext<S, T> = {
+  readonly sources: S;
+  readonly previous: T | undefined;
+  readonly reset: boolean;
+  readonly change: unknown;
+  readonly cause: unknown;
+  readonly state: IncrementalState;
+};
+type IncrementalValueProcessor<S, T> = (context: IncrementalValueContext<S, T>) => T | {
+  readonly kind: 'value';
+  readonly value: T;
+  readonly state?: IncrementalState;
+} | {
+  readonly kind: 'rebuild';
+};
+type IncrementalCollectionContext<S, K extends string, V> = {
+  readonly sources: S;
+  readonly previous: CollectionRead<K, V>;
+  readonly next: CollectionRead<K, V>;
+  readonly change: unknown;
+  readonly reset: boolean;
+  readonly cause: unknown;
+  readonly state: IncrementalState;
+  readonly output: CollectionDraft<K, V>;
+};
+type IncrementalCollectionProcessor<S, K extends string, V> = (context: IncrementalCollectionContext<S, K, V>) => void | {
+  readonly kind: 'rebuild';
+};
+type DependencyMap<D extends readonly Projection<unknown>[]> = { readonly [K in keyof D as `d${Extract<K, number>}`]: D[K] };
+declare function createIncrementalValue<const D extends readonly Projection<unknown>[], T>(dependencies: D, processor: IncrementalValueProcessor<ProjectionValues<D>, T>): Projection<T>;
+declare function createIncrementalCollection<const D extends readonly Projection<unknown>[], K extends string, V>(dependencies: D, processor: IncrementalCollectionProcessor<ProjectionValues<D>, K, V>): Projection<PublicCollection<K, V>>;
+declare const incremental: typeof createIncrementalValue & {
+  collection: typeof createIncrementalCollection;
+};
+type IncrementalDependencies<D extends readonly Projection<unknown>[]> = DependencyMap<D>;
+//#endregion
+export { IncrementalCollectionContext, IncrementalCollectionProcessor, IncrementalDependencies, IncrementalState, IncrementalValueContext, IncrementalValueProcessor, incremental };
+//# sourceMappingURL=advanced.d.cts.map

package/dist/advanced.d.ts

@@ -0,0 +1,42 @@
+import { i as PublicCollection, l as CollectionDraft, n as Projection, r as ProjectionValues, u as CollectionRead } from "./definition-Dr8tHwTD.js";
+
+//#region core/src/projection/advanced.d.ts
+type IncrementalState = Record<string, unknown>;
+type IncrementalValueContext<S, T> = {
+  readonly sources: S;
+  readonly previous: T | undefined;
+  readonly reset: boolean;
+  readonly change: unknown;
+  readonly cause: unknown;
+  readonly state: IncrementalState;
+};
+type IncrementalValueProcessor<S, T> = (context: IncrementalValueContext<S, T>) => T | {
+  readonly kind: 'value';
+  readonly value: T;
+  readonly state?: IncrementalState;
+} | {
+  readonly kind: 'rebuild';
+};
+type IncrementalCollectionContext<S, K extends string, V> = {
+  readonly sources: S;
+  readonly previous: CollectionRead<K, V>;
+  readonly next: CollectionRead<K, V>;
+  readonly change: unknown;
+  readonly reset: boolean;
+  readonly cause: unknown;
+  readonly state: IncrementalState;
+  readonly output: CollectionDraft<K, V>;
+};
+type IncrementalCollectionProcessor<S, K extends string, V> = (context: IncrementalCollectionContext<S, K, V>) => void | {
+  readonly kind: 'rebuild';
+};
+type DependencyMap<D extends readonly Projection<unknown>[]> = { readonly [K in keyof D as `d${Extract<K, number>}`]: D[K] };
+declare function createIncrementalValue<const D extends readonly Projection<unknown>[], T>(dependencies: D, processor: IncrementalValueProcessor<ProjectionValues<D>, T>): Projection<T>;
+declare function createIncrementalCollection<const D extends readonly Projection<unknown>[], K extends string, V>(dependencies: D, processor: IncrementalCollectionProcessor<ProjectionValues<D>, K, V>): Projection<PublicCollection<K, V>>;
+declare const incremental: typeof createIncrementalValue & {
+  collection: typeof createIncrementalCollection;
+};
+type IncrementalDependencies<D extends readonly Projection<unknown>[]> = DependencyMap<D>;
+//#endregion
+export { IncrementalCollectionContext, IncrementalCollectionProcessor, IncrementalDependencies, IncrementalState, IncrementalValueContext, IncrementalValueProcessor, incremental };
+//# sourceMappingURL=advanced.d.ts.map

package/dist/advanced.js

@@ -0,0 +1,115 @@
+import { n as defineIncrementalValue, t as defineIncrementalCollection, u as snapshot } from "./definition-wOvuklwp.js";
+//#region core/src/projection/advanced.ts
+const dependenciesOf = (dependencies) => Object.fromEntries(dependencies.map((dependency, index) => [`d${index}`, dependency]));
+const sourceChange = (sources) => {
+	for (const source of Object.values(sources)) if (source && typeof source === "object" && "change" in source && source.change !== void 0) return source.change;
+};
+const sourceCause = (sources) => {
+	for (const source of Object.values(sources)) if (source && typeof source === "object" && "cause" in source && source.cause !== void 0) return source.cause;
+};
+const publicSource = (source) => {
+	if (!source || typeof source !== "object") return source;
+	if ("value" in source) return source.value;
+	if ("read" in source) {
+		const read = source.read;
+		if (read && typeof read === "object" && "ids" in read && typeof read.ids === "function") {
+			const result = /* @__PURE__ */ new Map();
+			for (const id of read.ids()) result.set(id, read.get(id));
+			return result;
+		}
+		return snapshot(read);
+	}
+	if ("ids" in source && typeof source.ids === "function") {
+		const result = /* @__PURE__ */ new Map();
+		const read = source;
+		for (const id of read.ids()) result.set(id, read.get(id));
+		return result;
+	}
+	return source;
+};
+const publicTuple = (sources) => Object.keys(sources).sort((left, right) => Number(left.slice(1)) - Number(right.slice(1))).map((key) => publicSource(sources[key]));
+const normalizeValue = (result) => result && typeof result === "object" && result.kind === "value" ? {
+	value: result.value,
+	state: result.state
+} : { value: result };
+function createIncrementalValue(dependencies, processor) {
+	const dependencyMap = dependenciesOf(dependencies);
+	let state = Object.create(null);
+	let current;
+	const build = (sources) => {
+		state = Object.create(null);
+		const result = processor({
+			sources: publicTuple(sources),
+			previous: void 0,
+			reset: true,
+			change: void 0,
+			cause: sourceCause(sources),
+			state
+		});
+		if (result && typeof result === "object" && "kind" in result) throw new TypeError("Initial incremental processor cannot rebuild.");
+		const normalized = normalizeValue(result);
+		current = normalized.value;
+		if (normalized.state) state = normalized.state;
+		return {
+			value: current,
+			update: (nextSources) => {
+				const next = processor({
+					sources: publicTuple(nextSources),
+					previous: current,
+					reset: false,
+					change: sourceChange(nextSources),
+					cause: sourceCause(nextSources),
+					state
+				});
+				if (next && typeof next === "object" && "kind" in next) return next;
+				const nextValue = normalizeValue(next);
+				current = nextValue.value;
+				if (nextValue.state) state = nextValue.state;
+				return {
+					kind: "changed",
+					value: current
+				};
+			}
+		};
+	};
+	return defineIncrementalValue({
+		dependencies: dependencyMap,
+		build
+	});
+}
+function createIncrementalCollection(dependencies, processor) {
+	const dependencyMap = dependenciesOf(dependencies);
+	let state = Object.create(null);
+	const build = (input) => {
+		state = Object.create(null);
+		if (processor({
+			sources: publicTuple(input.sources),
+			previous: input.previous,
+			next: input.next,
+			reset: true,
+			change: void 0,
+			cause: sourceCause(input.sources),
+			state,
+			output: input.writer
+		})?.kind === "rebuild") throw new TypeError("Initial incremental collection processor cannot rebuild.");
+		return { update: (nextInput) => processor({
+			sources: publicTuple(nextInput.sources),
+			previous: nextInput.previous,
+			next: nextInput.next,
+			reset: false,
+			change: sourceChange(nextInput.sources),
+			cause: sourceCause(nextInput.sources),
+			state,
+			output: nextInput.writer
+		}) };
+	};
+	return defineIncrementalCollection({
+		dependencies: dependencyMap,
+		build
+	});
+}
+const incremental = Object.assign(createIncrementalValue, { collection: createIncrementalCollection });
+//#endregion
+export { incremental };
+
+//# sourceMappingURL=advanced.js.map

package/dist/advanced.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"advanced.js","names":[],"sources":["../core/src/projection/advanced.ts"],"sourcesContent":["import type { Projection, ProjectionValues, PublicCollection } from './definition';\nimport { defineIncrementalCollection, defineIncrementalValue } from './definition';\nimport type { CollectionDraft, CollectionRead, GraphSources } from './contract';\nimport { snapshot } from '../access/scope';\n\nexport type IncrementalState = Record<string, unknown>;\n\nexport type IncrementalValueContext<S, T> = {\n  readonly sources: S;\n  readonly previous: T | undefined;\n  readonly reset: boolean;\n  readonly change: unknown;\n  readonly cause: unknown;\n  readonly state: IncrementalState;\n};\n\nexport type IncrementalValueProcessor<S, T> = (\n  context: IncrementalValueContext<S, T>\n) =>\n  | T\n  | { readonly kind: 'value'; readonly value: T; readonly state?: IncrementalState }\n  | { readonly kind: 'rebuild' };\n\nexport type IncrementalCollectionContext<S, K extends string, V> = {\n  readonly sources: S;\n  readonly previous: CollectionRead<K, V>;\n  readonly next: CollectionRead<K, V>;\n  readonly change: unknown;\n  readonly reset: boolean;\n  readonly cause: unknown;\n  readonly state: IncrementalState;\n  readonly output: CollectionDraft<K, V>;\n};\n\nexport type IncrementalCollectionProcessor<S, K extends string, V> = (\n  context: IncrementalCollectionContext<S, K, V>\n) => void | { readonly kind: 'rebuild' };\n\ntype DependencyMap<D extends readonly Projection<unknown>[]> = {\n  readonly [K in keyof D as `d${Extract<K, number>}`]: D[K];\n};\n\nconst dependenciesOf = <D extends readonly Projection<unknown>[]>(dependencies: D): GraphSources =>\n  Object.fromEntries(\n    dependencies.map((dependency, index) => [`d${index}`, dependency])\n  ) as unknown as GraphSources;\n\nconst sourceChange = (sources: Record<string, unknown>): unknown => {\n  for (const source of Object.values(sources)) {\n    if (\n      source &&\n      typeof source === 'object' &&\n      'change' in source &&\n      (source as { readonly change?: unknown }).change !== undefined\n    )\n      return (source as { readonly change?: unknown }).change;\n  }\n  return undefined;\n};\n\nconst sourceCause = (sources: Record<string, unknown>): unknown => {\n  for (const source of Object.values(sources)) {\n    if (\n      source &&\n      typeof source === 'object' &&\n      'cause' in source &&\n      (source as { readonly cause?: unknown }).cause !== undefined\n    )\n      return (source as { readonly cause?: unknown }).cause;\n  }\n  return undefined;\n};\n\nconst publicSource = (source: unknown): unknown => {\n  if (!source || typeof source !== 'object') return source;\n  if ('value' in source) return (source as { readonly value: unknown }).value;\n  if ('read' in source) {\n    const read = (source as { readonly read: unknown }).read;\n    if (\n      read &&\n      typeof read === 'object' &&\n      'ids' in read &&\n      typeof (read as { ids?: unknown }).ids === 'function'\n    ) {\n      const result = new Map<string, unknown>();\n      for (const id of (read as CollectionRead<string, unknown>).ids())\n        result.set(id, (read as CollectionRead<string, unknown>).get(id));\n      return result;\n    }\n    return snapshot(read);\n  }\n  if ('ids' in source && typeof (source as { ids?: unknown }).ids === 'function') {\n    const result = new Map<string, unknown>();\n    const read = source as CollectionRead<string, unknown>;\n    for (const id of read.ids()) result.set(id, read.get(id));\n    return result;\n  }\n  return source;\n};\n\nconst publicTuple = (sources: Record<string, unknown>): readonly unknown[] =>\n  Object.keys(sources)\n    .sort((left, right) => Number(left.slice(1)) - Number(right.slice(1)))\n    .map(key => publicSource(sources[key]));\n\nconst normalizeValue = <T>(\n  result: T | { readonly kind: 'value'; readonly value: T; readonly state?: IncrementalState }\n): { value: T; state?: IncrementalState } =>\n  result && typeof result === 'object' && (result as { readonly kind?: unknown }).kind === 'value'\n    ? {\n        value: (result as { readonly value: T }).value,\n        state: (result as { readonly state?: IncrementalState }).state,\n      }\n    : { value: result as T };\n\nfunction createIncrementalValue<const D extends readonly Projection<unknown>[], T>(\n  dependencies: D,\n  processor: IncrementalValueProcessor<ProjectionValues<D>, T>\n): Projection<T> {\n  const dependencyMap = dependenciesOf(dependencies);\n  let state: IncrementalState = Object.create(null) as IncrementalState;\n  let current!: T;\n  const build = (sources: Record<string, unknown>) => {\n    state = Object.create(null) as IncrementalState;\n    const result = processor({\n      sources: publicTuple(sources) as ProjectionValues<D>,\n      previous: undefined,\n      reset: true,\n      change: undefined,\n      cause: sourceCause(sources),\n      state,\n    });\n    if (result && typeof result === 'object' && 'kind' in result)\n      throw new TypeError('Initial incremental processor cannot rebuild.');\n    const normalized = normalizeValue(result as T);\n    current = normalized.value;\n    if (normalized.state) state = normalized.state;\n    return {\n      value: current,\n      update: (nextSources: Record<string, unknown>) => {\n        const next = processor({\n          sources: publicTuple(nextSources) as ProjectionValues<D>,\n          previous: current,\n          reset: false,\n          change: sourceChange(nextSources),\n          cause: sourceCause(nextSources),\n          state,\n        });\n        if (next && typeof next === 'object' && 'kind' in next) return next;\n        const nextValue = normalizeValue(next as T);\n        current = nextValue.value;\n        if (nextValue.state) state = nextValue.state;\n        return { kind: 'changed', value: current } as const;\n      },\n    };\n  };\n  return defineIncrementalValue({ dependencies: dependencyMap, build: build as never });\n}\n\nfunction createIncrementalCollection<\n  const D extends readonly Projection<unknown>[],\n  K extends string,\n  V,\n>(\n  dependencies: D,\n  processor: IncrementalCollectionProcessor<ProjectionValues<D>, K, V>\n): Projection<PublicCollection<K, V>> {\n  const dependencyMap = dependenciesOf(dependencies);\n  let state: IncrementalState = Object.create(null) as IncrementalState;\n  const build = (input: {\n    readonly sources: Record<string, unknown>;\n    readonly previous: CollectionRead<K, V>;\n    readonly next: CollectionRead<K, V>;\n    readonly writer: CollectionDraft<K, V>;\n  }) => {\n    state = Object.create(null) as IncrementalState;\n    const result = processor({\n      sources: publicTuple(input.sources) as ProjectionValues<D>,\n      previous: input.previous,\n      next: input.next,\n      reset: true,\n      change: undefined,\n      cause: sourceCause(input.sources),\n      state,\n      output: input.writer,\n    });\n    if (result?.kind === 'rebuild')\n      throw new TypeError('Initial incremental collection processor cannot rebuild.');\n    return {\n      update: (nextInput: typeof input) =>\n        processor({\n          sources: publicTuple(nextInput.sources) as ProjectionValues<D>,\n          previous: nextInput.previous,\n          next: nextInput.next,\n          reset: false,\n          change: sourceChange(nextInput.sources),\n          cause: sourceCause(nextInput.sources),\n          state,\n          output: nextInput.writer,\n        }),\n    };\n  };\n  return defineIncrementalCollection({ dependencies: dependencyMap, build: build as never });\n}\n\nexport const incremental = Object.assign(createIncrementalValue, {\n  collection: createIncrementalCollection,\n});\n\nexport type IncrementalDependencies<D extends readonly Projection<unknown>[]> = DependencyMap<D>;\n"],"mappings":"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"}

package/dist/{contract-CeAnEPBA.d.ts → contract-BT53Gg94.d.ts}

@@ -143,6 +143,9 @@ declare const collectionKey: unique symbol;
 type PathMarker<TValue> = {
   readonly [pathValue]: TValue;
 };
+type PathValueOf<T> = T extends {
+  readonly [pathValue]: infer TValue;
+} ? TValue : never;
 type SchemaPathFor<S extends ObjectShape = ObjectShape, TValue = unknown> = { readonly [K in keyof S]: PathValue<S[K]> } & PathMarker<TValue>;
 type SchemaPath<S extends ObjectShape = ObjectShape> = SchemaPathFor<S, ShapeValue<S>>;
 type PathPick<S extends ObjectNode = ObjectNode> = (path: SchemaPath<S['shape']>) => PathMarker<unknown>;
@@ -315,8 +318,6 @@ type ReplaceParentAccess = {
   }>, true, unknown];
 };
 declare const replace: <T extends object & ReplaceParentAccess, K extends keyof Snapshot<T>>(container: T, key: K, value: NoInfer<Snapshot<T>[K]>) => void;
-/** Projection collection contexts use the same scoped access, with explicit collection tools. */
-type CollectionAccess<K extends string, N extends ValueSchemaNode> = TableAccess<K, N, false>;
 //#endregion
 //#region core/src/impact.d.ts
 type CollectionImpact<K> = {
@@ -454,5 +455,5 @@ type DocumentRuntime<S extends ObjectNode> = DocumentReadable<S> & {
   dispose(): void;
 };
 //#endregion
-export { ObjectShape as $, debugKey as A, CollectionPath as B, CollectionAccess as C, snapshot as D, replace as E, ChangeSet as F, DocumentTreeNode as G, DocumentAnchor as H, MemberChange as I, ImpactTarget as J, DocumentTreeValue as K, ValueTransition as L, read as M, resolveAddress as N, AddressRef as O, Change as P, ObjectNode as Q, CollectionId as R, DocumentImpact as S, Read as T, DocumentListConfig as U, DocumentAddress as V, DocumentNode as W, ListNode as X, Infer as Y, MapNode as Z, Unsubscribe as _, ParseError as _t, DocumentDisposedError as a, TreeNode as at, MutationIssueCode as b, parse as bt, DocumentReentrancyError as c, VariantShape as ct, LocalHistory as d, map as dt, OptionalNode as et, ObserverError as f, object as ft, TransactionResult as g, variant as gt, TransactionRejected as h, tree as ht, DocumentDiagnostic as i, TableNode as it, overlaps as j, contains as k, DocumentRuntime as l, field as lt, Synchronous as m, table as mt, CommitSource as n, ReadonlyValue as nt, DocumentProblem as o, ValueSchemaNode as ot, OperationResult as p, optional as pt, FieldNode as q, DocumentCommit as r, SchemaPath as rt, DocumentReadable as s, VariantNode as st, CommitListener as t, PathPick as tt, HistoryState as u, list as ut, Readable as v, ParseIssue as vt, Draft as w, CollectionImpact as x, MutationIssue as y, Validator as yt, CollectionNode as z };
-//# sourceMappingURL=contract-CeAnEPBA.d.ts.map
+export { OptionalNode as $, overlaps as A, DocumentAddress as B, Draft as C, AddressRef as D, snapshot as E, MemberChange as F, DocumentTreeValue as G, DocumentListConfig as H, ValueTransition as I, Infer as J, FieldNode as K, CollectionId as L, resolveAddress as M, Change as N, contains as O, ChangeSet as P, ObjectShape as Q, CollectionNode as R, DocumentImpact as S, replace as T, DocumentNode as U, DocumentAnchor as V, DocumentTreeNode as W, MapNode as X, ListNode as Y, ObjectNode as Z, Unsubscribe as _, Validator as _t, DocumentDisposedError as a, VariantNode as at, MutationIssueCode as b, DocumentReentrancyError as c, list as ct, LocalHistory as d, optional as dt, PathValueOf as et, ObserverError as f, table as ft, TransactionResult as g, ParseIssue as gt, TransactionRejected as h, ParseError as ht, DocumentDiagnostic as i, TreeNode as it, read as j, debugKey as k, DocumentRuntime as l, map as lt, Synchronous as m, variant as mt, CommitSource as n, SchemaPath as nt, DocumentProblem as o, VariantShape as ot, OperationResult as p, tree as pt, ImpactTarget as q, DocumentCommit as r, TableNode as rt, DocumentReadable as s, field as st, CommitListener as t, ReadonlyValue as tt, HistoryState as u, object as ut, Readable as v, parse as vt, Read as w, CollectionImpact as x, MutationIssue as y, CollectionPath as z };
+//# sourceMappingURL=contract-BT53Gg94.d.ts.map

package/dist/{contract-DtGVSXSK.d.cts → contract-XmKnroJq.d.cts}

@@ -143,6 +143,9 @@ declare const collectionKey: unique symbol;
 type PathMarker<TValue> = {
   readonly [pathValue]: TValue;
 };
+type PathValueOf<T> = T extends {
+  readonly [pathValue]: infer TValue;
+} ? TValue : never;
 type SchemaPathFor<S extends ObjectShape = ObjectShape, TValue = unknown> = { readonly [K in keyof S]: PathValue<S[K]> } & PathMarker<TValue>;
 type SchemaPath<S extends ObjectShape = ObjectShape> = SchemaPathFor<S, ShapeValue<S>>;
 type PathPick<S extends ObjectNode = ObjectNode> = (path: SchemaPath<S['shape']>) => PathMarker<unknown>;
@@ -315,8 +318,6 @@ type ReplaceParentAccess = {
   }>, true, unknown];
 };
 declare const replace: <T extends object & ReplaceParentAccess, K extends keyof Snapshot<T>>(container: T, key: K, value: NoInfer<Snapshot<T>[K]>) => void;
-/** Projection collection contexts use the same scoped access, with explicit collection tools. */
-type CollectionAccess<K extends string, N extends ValueSchemaNode> = TableAccess<K, N, false>;
 //#endregion
 //#region core/src/impact.d.ts
 type CollectionImpact<K> = {
@@ -454,5 +455,5 @@ type DocumentRuntime<S extends ObjectNode> = DocumentReadable<S> & {
   dispose(): void;
 };
 //#endregion
-export { ObjectShape as $, debugKey as A, CollectionPath as B, CollectionAccess as C, snapshot as D, replace as E, ChangeSet as F, DocumentTreeNode as G, DocumentAnchor as H, MemberChange as I, ImpactTarget as J, DocumentTreeValue as K, ValueTransition as L, read as M, resolveAddress as N, AddressRef as O, Change as P, ObjectNode as Q, CollectionId as R, DocumentImpact as S, Read as T, DocumentListConfig as U, DocumentAddress as V, DocumentNode as W, ListNode as X, Infer as Y, MapNode as Z, Unsubscribe as _, ParseError as _t, DocumentDisposedError as a, TreeNode as at, MutationIssueCode as b, parse as bt, DocumentReentrancyError as c, VariantShape as ct, LocalHistory as d, map as dt, OptionalNode as et, ObserverError as f, object as ft, TransactionResult as g, variant as gt, TransactionRejected as h, tree as ht, DocumentDiagnostic as i, TableNode as it, overlaps as j, contains as k, DocumentRuntime as l, field as lt, Synchronous as m, table as mt, CommitSource as n, ReadonlyValue as nt, DocumentProblem as o, ValueSchemaNode as ot, OperationResult as p, optional as pt, FieldNode as q, DocumentCommit as r, SchemaPath as rt, DocumentReadable as s, VariantNode as st, CommitListener as t, PathPick as tt, HistoryState as u, list as ut, Readable as v, ParseIssue as vt, Draft as w, CollectionImpact as x, MutationIssue as y, Validator as yt, CollectionNode as z };
-//# sourceMappingURL=contract-DtGVSXSK.d.cts.map
+export { OptionalNode as $, overlaps as A, DocumentAddress as B, Draft as C, AddressRef as D, snapshot as E, MemberChange as F, DocumentTreeValue as G, DocumentListConfig as H, ValueTransition as I, Infer as J, FieldNode as K, CollectionId as L, resolveAddress as M, Change as N, contains as O, ChangeSet as P, ObjectShape as Q, CollectionNode as R, DocumentImpact as S, replace as T, DocumentNode as U, DocumentAnchor as V, DocumentTreeNode as W, MapNode as X, ListNode as Y, ObjectNode as Z, Unsubscribe as _, Validator as _t, DocumentDisposedError as a, VariantNode as at, MutationIssueCode as b, DocumentReentrancyError as c, list as ct, LocalHistory as d, optional as dt, PathValueOf as et, ObserverError as f, table as ft, TransactionResult as g, ParseIssue as gt, TransactionRejected as h, ParseError as ht, DocumentDiagnostic as i, TreeNode as it, read as j, debugKey as k, DocumentRuntime as l, map as lt, Synchronous as m, variant as mt, CommitSource as n, SchemaPath as nt, DocumentProblem as o, VariantShape as ot, OperationResult as p, tree as pt, ImpactTarget as q, DocumentCommit as r, TableNode as rt, DocumentReadable as s, field as st, CommitListener as t, ReadonlyValue as tt, HistoryState as u, object as ut, Readable as v, parse as vt, Read as w, CollectionImpact as x, MutationIssue as y, CollectionPath as z };
+//# sourceMappingURL=contract-XmKnroJq.d.cts.map