doxum 0.1.17 → 0.1.18

package/dist/index.d.cts

@@ -1,5 +1,5 @@
 import { $ as OptionalNode, B as DocumentAddress, C as Draft, E as snapshot, F as MemberChange, G as DocumentTreeValue, H as DocumentListConfig, I as ValueTransition, J as Infer, K as FieldNode, N as Change, P as ChangeSet, Q as ObjectShape, S as DocumentImpact, T as replace, U as DocumentNode, V as DocumentAnchor, W as DocumentTreeNode, X as MapNode, Y as ListNode, Z as ObjectNode, _ as Unsubscribe, _t as Validator, a as DocumentDisposedError, at as VariantNode, b as MutationIssueCode, c as DocumentReentrancyError, ct as list, d as LocalHistory, dt as optional, et as PathValueOf, f as ObserverError, ft as table, g as TransactionResult, gt as ParseIssue, h as TransactionRejected, ht as ParseError, i as DocumentDiagnostic, it as TreeNode, l as DocumentRuntime, lt as map, mt as variant, n as CommitSource, nt as SchemaPath, o as DocumentProblem, ot as VariantShape, p as OperationResult, pt as tree, r as DocumentCommit, rt as TableNode, s as DocumentReadable, st as field, tt as ReadonlyValue, u as HistoryState, ut as object, v as Readable, vt as parse, w as Read, x as CollectionImpact, y as MutationIssue } from "./contract-XmKnroJq.cjs";
-import { a as observe, d as ExternalCollectionSource, f as ExternalValueEvent, h as ProjectionError, i as input, l as ExternalCollectionEvent, m as ProjectionDisposedError, n as Projection, o as CollectionChange, p as ExternalValueSource, r as derive, t as Input, u as ExternalCollectionRead } from "./definition-Bf8Z7xtX.cjs";
+import { _ as ExternalValueSource, c as Projection, d as observe, f as CollectionChange, g as ExternalValueEvent, h as ExternalCollectionSource, l as derive, m as ExternalCollectionRead, o as incremental, p as ExternalCollectionEvent, s as Input, u as input, v as ProjectionDisposedError, y as ProjectionError } from "./advanced-GTwIWcn6.cjs";
 
 //#region core/src/runtime.d.ts
 declare const createDocument: <S extends ObjectNode>(input: {
@@ -18,20 +18,40 @@ type DocumentSelector<TSchema extends ObjectNode, TResult> = (read: Read<TSchema
 declare const read: <TSchema extends ObjectNode, TResult>(runtime: DocumentReadable<TSchema>, selector: DocumentSelector<TSchema, TResult>) => TResult;
 //#endregion
 //#region core/src/projection/runtime.d.ts
+type KeyedDraft<K extends string, V> = {
+  get(key: K): V | undefined;
+  has(key: K): boolean;
+  set(key: K, value: V): void;
+  remove(key: K): void;
+};
 type ProjectionRuntime = {
   get<T>(projection: Projection<T, unknown>): T;
   readable<T>(projection: Projection<T, unknown>): Readable<T>;
   readable<T, R>(projection: Projection<T, unknown>, selector: (value: T) => R, equality?: (previous: R, next: R) => boolean): Readable<R>;
   set<T>(input: Input<T>, value: T): void;
+  update<K extends string, V>(input: Input<ReadonlyMap<K, V>, CollectionChange<K, V>>, run: (draft: KeyedDraft<K, V>) => void): void;
   batch<T>(run: () => T): T;
   batch<T>(options: {
     readonly cause?: unknown;
   }, run: () => T): T;
+  scope(): ProjectionScope;
+  dispose(): void;
+};
+type ProjectionScope = {
+  readonly input: typeof input;
+  readonly derive: typeof derive;
+  readonly incremental: typeof incremental;
+  get<T>(projection: Projection<T, unknown>): T;
+  readable<T>(projection: Projection<T, unknown>): Readable<T>;
+  readable<T, R>(projection: Projection<T, unknown>, selector: (value: T) => R, equality?: (previous: R, next: R) => boolean): Readable<R>;
+  set<T>(input: Input<T>, value: T): void;
+  update<K extends string, V>(input: Input<ReadonlyMap<K, V>, CollectionChange<K, V>>, run: (draft: KeyedDraft<K, V>) => void): void;
+  batch: ProjectionRuntime['batch'];
   dispose(): void;
 };
 declare const createProjectionRuntime: (options?: {
   readonly onError?: (error: ProjectionError) => void;
 }) => ProjectionRuntime;
 //#endregion
-export { type Change, type ChangeSet, type CollectionChange, type CollectionImpact, type CommitSource, type DocumentAddress, type DocumentAnchor, type DocumentCommit, type DocumentDiagnostic, DocumentDisposedError, type DocumentImpact, type DocumentListConfig, type DocumentNode, type DocumentProblem, type DocumentReadable, DocumentReentrancyError, type DocumentRuntime, type DocumentSelector, type DocumentTreeNode, type DocumentTreeValue, type Draft, type ExternalCollectionEvent, type ExternalCollectionRead, type ExternalCollectionSource, type ExternalValueEvent, type ExternalValueSource, type FieldNode, type HistoryState, type Infer, type Input, type ListNode, type LocalHistory, type MapNode, type MemberChange, type MutationIssue, type MutationIssueCode, type ObjectNode, type ObjectShape, type ObserverError, type OperationResult, type OptionalNode, ParseError, type ParseIssue, type PathValueOf, type Projection, ProjectionDisposedError, ProjectionError, type ProjectionRuntime, type Read, type Readable, type ReadonlyValue, type SchemaPath, type TableNode, TransactionRejected, type TransactionResult, type TreeNode, type Unsubscribe, type Validator, type ValueTransition, type VariantNode, type VariantShape, asReadable, createDocument, createProjectionRuntime, derive, field, input, list, map, object, observe, optional, parse, read, replace, snapshot, table, tree, variant };
+export { type Change, type ChangeSet, type CollectionChange, type CollectionImpact, type CommitSource, type DocumentAddress, type DocumentAnchor, type DocumentCommit, type DocumentDiagnostic, DocumentDisposedError, type DocumentImpact, type DocumentListConfig, type DocumentNode, type DocumentProblem, type DocumentReadable, DocumentReentrancyError, type DocumentRuntime, type DocumentSelector, type DocumentTreeNode, type DocumentTreeValue, type Draft, type ExternalCollectionEvent, type ExternalCollectionRead, type ExternalCollectionSource, type ExternalValueEvent, type ExternalValueSource, type FieldNode, type HistoryState, type Infer, type Input, type ListNode, type LocalHistory, type MapNode, type MemberChange, type MutationIssue, type MutationIssueCode, type ObjectNode, type ObjectShape, type ObserverError, type OperationResult, type OptionalNode, ParseError, type ParseIssue, type PathValueOf, type Projection, ProjectionDisposedError, ProjectionError, type ProjectionRuntime, type ProjectionScope, type Read, type Readable, type ReadonlyValue, type SchemaPath, type TableNode, TransactionRejected, type TransactionResult, type TreeNode, type Unsubscribe, type Validator, type ValueTransition, type VariantNode, type VariantShape, asReadable, createDocument, createProjectionRuntime, derive, field, input, list, map, object, observe, optional, parse, read, replace, snapshot, table, tree, variant };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { $ as OptionalNode, B as DocumentAddress, C as Draft, E as snapshot, F as MemberChange, G as DocumentTreeValue, H as DocumentListConfig, I as ValueTransition, J as Infer, K as FieldNode, N as Change, P as ChangeSet, Q as ObjectShape, S as DocumentImpact, T as replace, U as DocumentNode, V as DocumentAnchor, W as DocumentTreeNode, X as MapNode, Y as ListNode, Z as ObjectNode, _ as Unsubscribe, _t as Validator, a as DocumentDisposedError, at as VariantNode, b as MutationIssueCode, c as DocumentReentrancyError, ct as list, d as LocalHistory, dt as optional, et as PathValueOf, f as ObserverError, ft as table, g as TransactionResult, gt as ParseIssue, h as TransactionRejected, ht as ParseError, i as DocumentDiagnostic, it as TreeNode, l as DocumentRuntime, lt as map, mt as variant, n as CommitSource, nt as SchemaPath, o as DocumentProblem, ot as VariantShape, p as OperationResult, pt as tree, r as DocumentCommit, rt as TableNode, s as DocumentReadable, st as field, tt as ReadonlyValue, u as HistoryState, ut as object, v as Readable, vt as parse, w as Read, x as CollectionImpact, y as MutationIssue } from "./contract-CATCCVu5.js";
-import { a as observe, d as ExternalCollectionSource, f as ExternalValueEvent, h as ProjectionError, i as input, l as ExternalCollectionEvent, m as ProjectionDisposedError, n as Projection, o as CollectionChange, p as ExternalValueSource, r as derive, t as Input, u as ExternalCollectionRead } from "./definition-BdLGD8Rq.js";
+import { _ as ExternalValueSource, c as Projection, d as observe, f as CollectionChange, g as ExternalValueEvent, h as ExternalCollectionSource, l as derive, m as ExternalCollectionRead, o as incremental, p as ExternalCollectionEvent, s as Input, u as input, v as ProjectionDisposedError, y as ProjectionError } from "./advanced-c0F3gpLG.js";
 
 //#region core/src/runtime.d.ts
 declare const createDocument: <S extends ObjectNode>(input: {
@@ -18,20 +18,40 @@ type DocumentSelector<TSchema extends ObjectNode, TResult> = (read: Read<TSchema
 declare const read: <TSchema extends ObjectNode, TResult>(runtime: DocumentReadable<TSchema>, selector: DocumentSelector<TSchema, TResult>) => TResult;
 //#endregion
 //#region core/src/projection/runtime.d.ts
+type KeyedDraft<K extends string, V> = {
+  get(key: K): V | undefined;
+  has(key: K): boolean;
+  set(key: K, value: V): void;
+  remove(key: K): void;
+};
 type ProjectionRuntime = {
   get<T>(projection: Projection<T, unknown>): T;
   readable<T>(projection: Projection<T, unknown>): Readable<T>;
   readable<T, R>(projection: Projection<T, unknown>, selector: (value: T) => R, equality?: (previous: R, next: R) => boolean): Readable<R>;
   set<T>(input: Input<T>, value: T): void;
+  update<K extends string, V>(input: Input<ReadonlyMap<K, V>, CollectionChange<K, V>>, run: (draft: KeyedDraft<K, V>) => void): void;
   batch<T>(run: () => T): T;
   batch<T>(options: {
     readonly cause?: unknown;
   }, run: () => T): T;
+  scope(): ProjectionScope;
+  dispose(): void;
+};
+type ProjectionScope = {
+  readonly input: typeof input;
+  readonly derive: typeof derive;
+  readonly incremental: typeof incremental;
+  get<T>(projection: Projection<T, unknown>): T;
+  readable<T>(projection: Projection<T, unknown>): Readable<T>;
+  readable<T, R>(projection: Projection<T, unknown>, selector: (value: T) => R, equality?: (previous: R, next: R) => boolean): Readable<R>;
+  set<T>(input: Input<T>, value: T): void;
+  update<K extends string, V>(input: Input<ReadonlyMap<K, V>, CollectionChange<K, V>>, run: (draft: KeyedDraft<K, V>) => void): void;
+  batch: ProjectionRuntime['batch'];
   dispose(): void;
 };
 declare const createProjectionRuntime: (options?: {
   readonly onError?: (error: ProjectionError) => void;
 }) => ProjectionRuntime;
 //#endregion
-export { type Change, type ChangeSet, type CollectionChange, type CollectionImpact, type CommitSource, type DocumentAddress, type DocumentAnchor, type DocumentCommit, type DocumentDiagnostic, DocumentDisposedError, type DocumentImpact, type DocumentListConfig, type DocumentNode, type DocumentProblem, type DocumentReadable, DocumentReentrancyError, type DocumentRuntime, type DocumentSelector, type DocumentTreeNode, type DocumentTreeValue, type Draft, type ExternalCollectionEvent, type ExternalCollectionRead, type ExternalCollectionSource, type ExternalValueEvent, type ExternalValueSource, type FieldNode, type HistoryState, type Infer, type Input, type ListNode, type LocalHistory, type MapNode, type MemberChange, type MutationIssue, type MutationIssueCode, type ObjectNode, type ObjectShape, type ObserverError, type OperationResult, type OptionalNode, ParseError, type ParseIssue, type PathValueOf, type Projection, ProjectionDisposedError, ProjectionError, type ProjectionRuntime, type Read, type Readable, type ReadonlyValue, type SchemaPath, type TableNode, TransactionRejected, type TransactionResult, type TreeNode, type Unsubscribe, type Validator, type ValueTransition, type VariantNode, type VariantShape, asReadable, createDocument, createProjectionRuntime, derive, field, input, list, map, object, observe, optional, parse, read, replace, snapshot, table, tree, variant };
+export { type Change, type ChangeSet, type CollectionChange, type CollectionImpact, type CommitSource, type DocumentAddress, type DocumentAnchor, type DocumentCommit, type DocumentDiagnostic, DocumentDisposedError, type DocumentImpact, type DocumentListConfig, type DocumentNode, type DocumentProblem, type DocumentReadable, DocumentReentrancyError, type DocumentRuntime, type DocumentSelector, type DocumentTreeNode, type DocumentTreeValue, type Draft, type ExternalCollectionEvent, type ExternalCollectionRead, type ExternalCollectionSource, type ExternalValueEvent, type ExternalValueSource, type FieldNode, type HistoryState, type Infer, type Input, type ListNode, type LocalHistory, type MapNode, type MemberChange, type MutationIssue, type MutationIssueCode, type ObjectNode, type ObjectShape, type ObserverError, type OperationResult, type OptionalNode, ParseError, type ParseIssue, type PathValueOf, type Projection, ProjectionDisposedError, ProjectionError, type ProjectionRuntime, type ProjectionScope, type Read, type Readable, type ReadonlyValue, type SchemaPath, type TableNode, TransactionRejected, type TransactionResult, type TreeNode, type Unsubscribe, type Validator, type ValueTransition, type VariantNode, type VariantShape, asReadable, createDocument, createProjectionRuntime, derive, field, input, list, map, object, observe, optional, parse, read, replace, snapshot, table, tree, variant };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -2,7 +2,7 @@ import { A as insert, D as equal, F as remove, L as profile, M as keys, N as mat
 import { a as ParseError, c as copyValue, i as snapshot, l as equalValue, n as createAccess, o as checkKey, r as replace, s as checkValue, t as collectionAccess, u as parse } from "./scope-d-L87NeC.js";
 import { _ as affected, a as documentReadableOwner, d as accessOf, f as bindRuntimeAccess, g as TransactionRejected, h as DocumentReentrancyError, i as disposeNotification, l as subscribeRoot, m as DocumentDisposedError, n as bindDocumentReadable, o as notify, p as readWith, r as createNotification, s as shareNotification, t as attachProjection, u as subscribeTargets, v as belongs, y as same } from "./notification-IQIJyH3Q.js";
 import { n as bindRuntimeDriver, o as decodeChanges, r as disposeRuntimeDriver, s as sealChanges, t as assertRuntimeWritable } from "./driver-CSnhMjbP.js";
-import { a as input, i as derive, o as observe, r as definitionOf } from "./definition-DUo1lfQ8.js";
+import { a as observe, i as input, n as definitionOf, o as ownDefinition, r as derive, s as ownerOf, t as incremental } from "./advanced-DgRnyRAc.js";
 //#region core/src/schema.ts
 const node = (value) => Object.freeze(value);
 const field = (validator) => node({
@@ -1195,7 +1195,9 @@ const createScheduler = (onError) => {
 		phase = "compute";
 		lock(true);
 		try {
-			pending.forEach((source) => source.consumers.forEach(enqueue));
+			pending.forEach((source) => {
+				if (source.shouldSettle?.() ?? true) source.consumers.forEach(enqueue);
+			});
 			while (heap.length) {
 				const node = pop();
 				if (node.disposed) continue;
@@ -1337,12 +1339,29 @@ const createScheduler = (onError) => {
 		unregisterSource(handle) {
 			const record = records.get(handle);
 			if (record) {
+				assertIdle();
+				if (record.consumers.size) throw new Error("Projection source is still used by a node.");
 				record.disposed = true;
 				pending.delete(record);
 				record.clear();
 				records.delete(handle);
 			}
 		},
+		releaseNode(handle) {
+			assertIdle();
+			const node = records.get(handle);
+			if (!node || !nodes.has(node)) throw new Error("Unknown projection node.");
+			if (node.consumers.size) throw new Error("Projection node is still used by another node.");
+			node.disposed = true;
+			node.sources.forEach((source) => source.consumers.delete(node));
+			node.release();
+			node.clear();
+			nodes.delete(node);
+			records.delete(handle);
+			pending.delete(node);
+			queued.delete(node);
+			emissions.delete(node);
+		},
 		source(handle) {
 			assertActive();
 			const source = records.get(handle);
@@ -1684,6 +1703,149 @@ const createSources = (scheduler) => {
 			}
 		};
 	};
+	const collectionInput = (initial) => {
+		const values = new Map(initial);
+		const touched = /* @__PURE__ */ new Map();
+		let beforeIds;
+		let revision = 0;
+		let cause;
+		const handle = Object.freeze({ kind: "collection" });
+		const change = () => {
+			const added = [];
+			const updated = [];
+			const removed = [];
+			for (const [key, before] of touched) {
+				const afterPresent = values.has(key);
+				if (!before.present && afterPresent) added.push({
+					key,
+					after: values.get(key)
+				});
+				else if (before.present && !afterPresent) removed.push({
+					key,
+					before: before.value
+				});
+				else if (before.present && afterPresent && !Object.is(before.value, values.get(key))) updated.push({
+					key,
+					before: before.value,
+					after: values.get(key)
+				});
+			}
+			let order;
+			if (beforeIds) {
+				const afterIds = [...values.keys()];
+				const beforeKeys = new Set(beforeIds);
+				const afterKeys = new Set(afterIds);
+				const beforeCommon = beforeIds.filter((key) => afterKeys.has(key));
+				const afterCommon = afterIds.filter((key) => beforeKeys.has(key));
+				if (beforeCommon.some((key, index) => key !== afterCommon[index])) order = Object.freeze({
+					before: beforeIds,
+					after: Object.freeze(afterIds)
+				});
+			}
+			if (!added.length && !updated.length && !removed.length && !order) return void 0;
+			return Object.freeze({
+				kind: "incremental",
+				added: Object.freeze(added),
+				updated: Object.freeze(updated),
+				removed: Object.freeze(removed),
+				...order ? { order } : {}
+			});
+		};
+		const record = {
+			consumers: /* @__PURE__ */ new Set(),
+			disposed: false,
+			fault: void 0,
+			revision: () => revision,
+			reset: () => false,
+			shouldSettle: () => change() !== void 0,
+			clear: () => {
+				touched.clear();
+				beforeIds = void 0;
+				cause = void 0;
+			},
+			context: (active) => {
+				assertScope(active);
+				const read = Object.freeze({
+					get: (key) => {
+						assertScope(active);
+						return values.get(key);
+					},
+					has: (key) => {
+						assertScope(active);
+						return values.has(key);
+					},
+					ids: () => {
+						assertScope(active);
+						return Object.freeze([...values.keys()]);
+					}
+				});
+				return Object.freeze({
+					kind: "collection",
+					read,
+					change: change(),
+					revision,
+					cause
+				});
+			}
+		};
+		scheduler.register(handle, record);
+		return {
+			source: handle,
+			update(run) {
+				scheduler.assertIdle();
+				const staged = /* @__PURE__ */ new Map();
+				let active = true;
+				const draft = Object.freeze({
+					get: (key) => {
+						assertScope(() => active);
+						const entry = staged.get(key);
+						return entry ? entry.present ? entry.value : void 0 : values.get(key);
+					},
+					has: (key) => {
+						assertScope(() => active);
+						const entry = staged.get(key);
+						return entry ? entry.present : values.has(key);
+					},
+					set: (key, value) => {
+						assertScope(() => active);
+						if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
+						staged.set(key, {
+							present: true,
+							value
+						});
+					},
+					remove: (key) => {
+						assertScope(() => active);
+						if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
+						staged.set(key, { present: false });
+					}
+				});
+				try {
+					assertSynchronous(run(draft));
+				} finally {
+					active = false;
+				}
+				let changed = false;
+				for (const [key, entry] of staged) {
+					const present = values.has(key);
+					if (entry.present ? present && Object.is(values.get(key), entry.value) : !present) continue;
+					if (!touched.has(key)) touched.set(key, {
+						present,
+						value: values.get(key)
+					});
+					if (!beforeIds && present !== entry.present) beforeIds = Object.freeze([...values.keys()]);
+					if (entry.present) values.set(key, entry.value);
+					else values.delete(key);
+					changed = true;
+				}
+				if (!changed) return;
+				revision++;
+				cause = scheduler.batchContext()?.cause ?? cause;
+				scheduler.capture(record);
+				scheduler.run();
+			}
+		};
+	};
 	const externalValueSource = (port, equal) => {
 		scheduler.assertIdle();
 		const old = externalSources.get(port);
@@ -1876,6 +2038,7 @@ const createSources = (scheduler) => {
 				set
 			});
 		},
+		collectionInput,
 		fromReadable: (readable, options) => {
 			scheduler.assertIdle();
 			if (projectionHandles.has(readable)) throw new Error("Projection nodes must be declared directly as sources.");
@@ -2496,11 +2659,15 @@ const createProjectionGraph = (options) => {
 		fromSource: (source, options) => sources.fromSource(source, options),
 		fromCollectionSource: (source) => sources.fromCollectionSource(source),
 		input: sources.input,
+		collectionInput: sources.collectionInput,
 		fromReadable: sources.fromReadable,
 		value,
 		collection: (spec) => createCollection(scheduler, spec),
 		map,
 		batch: scheduler.batch,
+		assertIdle: scheduler.assertIdle,
+		releaseNode: scheduler.releaseNode,
+		releaseInput: scheduler.unregisterSource,
 		dispose: () => {
 			try {
 				scheduler.dispose();
@@ -2670,16 +2837,27 @@ const sourceOf = (instance) => instance;
 const createProjectionRuntime = (options) => {
 	const runtime = createProjectionGraph({ onError: options?.onError ?? (() => void 0) });
 	const materialized = /* @__PURE__ */ new WeakMap();
-	const materialize = (projection) => {
+	let disposed = false;
+	const scopes = /* @__PURE__ */ new Set();
+	const materialize = (projection, requester) => {
+		const owner = ownerOf(projection);
+		if (owner) {
+			if (owner !== requester) throw new TypeError("Projection belongs to another scope.");
+			if (!requester.active) throw new ProjectionDisposedError();
+		}
 		const old = materialized.get(projection);
 		if (old) return old.node;
 		const definition = definitionOf(projection);
 		let instance;
-		let setter;
+		let write;
 		switch (definition.kind) {
 			case "input": {
 				const input = runtime.input(definition.initial, { isEqual: definition.isEqual });
-				setter = input.set;
+				write = {
+					kind: "value-input",
+					source: input.source,
+					set: input.set
+				};
 				instance = runtime.value({
 					sources: { input: input.source },
 					build: (values) => ({
@@ -2692,6 +2870,16 @@ const createProjectionRuntime = (options) => {
 				});
 				break;
 			}
+			case "collection-input": {
+				const source = runtime.collectionInput(definition.initial);
+				write = {
+					kind: "collection-input",
+					source: source.source,
+					update: source.update
+				};
+				instance = runtime.map(source.source, (_key, value) => value);
+				break;
+			}
 			case "readable": {
 				const source = runtime.fromReadable(definition.readable, { isEqual: definition.isEqual });
 				instance = runtime.value({
@@ -2763,7 +2951,7 @@ const createProjectionRuntime = (options) => {
 				break;
 			}
 			case "derive": {
-				const sources = Object.fromEntries(definition.dependencies.map((dependency, index) => [`d${index}`, sourceOf(materialize(dependency))]));
+				const sources = Object.fromEntries(definition.dependencies.map((dependency, index) => [`d${index}`, sourceOf(materialize(dependency, owner))]));
 				instance = runtime.value({
 					sources,
 					build: (values) => ({
@@ -2777,7 +2965,7 @@ const createProjectionRuntime = (options) => {
 				break;
 			}
 			case "incremental-value": {
-				const sources = Object.fromEntries(Object.entries(definition.dependencies).map(([key, dependency]) => [key, sourceOf(materialize(dependency))]));
+				const sources = Object.fromEntries(Object.entries(definition.dependencies).map(([key, dependency]) => [key, sourceOf(materialize(dependency, owner))]));
 				instance = runtime.value({
 					sources,
 					build: definition.build
@@ -2785,7 +2973,7 @@ const createProjectionRuntime = (options) => {
 				break;
 			}
 			case "incremental-collection": {
-				const sources = Object.fromEntries(Object.entries(definition.dependencies).map(([key, dependency]) => [key, sourceOf(materialize(dependency))]));
+				const sources = Object.fromEntries(Object.entries(definition.dependencies).map(([key, dependency]) => [key, sourceOf(materialize(dependency, owner))]));
 				instance = runtime.collection({
 					sources,
 					build: definition.build,
@@ -2795,14 +2983,19 @@ const createProjectionRuntime = (options) => {
 				break;
 			}
 		}
-		materialized.set(projection, {
+		const record = write ? {
 			node: instance,
-			set: setter
-		});
+			...write
+		} : {
+			kind: "projection",
+			node: instance
+		};
+		materialized.set(projection, record);
+		if (owner) owner.materialized.push(projection);
 		return instance;
 	};
-	const get = (projection) => {
-		const instance = materialize(projection);
+	const get = (projection, requester) => {
+		const instance = materialize(projection, requester);
 		const current = instance.current();
 		if (instance.kind === "collection") {
 			const record = materialized.get(projection) ?? materialized.get(instance);
@@ -2830,11 +3023,11 @@ const createProjectionRuntime = (options) => {
 		}
 		return current;
 	};
-	function readable(projection, selector, equality = Object.is) {
+	const makeReadable = (projection, selector, equality = Object.is, requester) => {
 		if (!selector) return Object.freeze({
-			current: () => get(projection),
-			revision: () => materialize(projection).revision(),
-			subscribe: (listener) => materialize(projection).subscribe(listener)
+			current: () => get(projection, requester),
+			revision: () => materialize(projection, requester).revision(),
+			subscribe: (listener) => materialize(projection, requester).subscribe(listener)
 		});
 		let initialized = false;
 		let value;
@@ -2849,7 +3042,7 @@ const createProjectionRuntime = (options) => {
 		let unsubscribeSource;
 		const listeners = /* @__PURE__ */ new Set();
 		const updateCollectionSnapshot = () => {
-			const current = get(projection);
+			const current = get(projection, requester);
 			previousCollection = isMapLike(current) ? current : void 0;
 		};
 		const evaluate = () => {
@@ -2863,7 +3056,7 @@ const createProjectionRuntime = (options) => {
 			let source;
 			let next;
 			try {
-				source = get(projection);
+				source = get(projection, requester);
 				next = selector(source);
 			} finally {
 				activeTracker = previousTracker;
@@ -2880,30 +3073,30 @@ const createProjectionRuntime = (options) => {
 			}
 			selection = nextSelection;
 			initialized = true;
-			sourceRevision = materialize(projection).revision();
+			sourceRevision = materialize(projection, requester).revision();
 			updateCollectionSnapshot();
 			return changed;
 		};
 		const ensureCurrent = () => {
-			const revision = materialize(projection).revision();
+			const revision = materialize(projection, requester).revision();
 			if (!initialized || !unsubscribeSource && sourceRevision !== revision) evaluate();
 			return value;
 		};
 		const onProjectionChange = (incoming) => {
 			let change = incoming;
 			if (!change && previousCollection) {
-				const current = get(projection);
+				const current = get(projection, requester);
 				if (isMapLike(current)) {
 					change = mapChange(previousCollection, current);
 					previousCollection = current;
 					if (!change) {
-						sourceRevision = materialize(projection).revision();
+						sourceRevision = materialize(projection, requester).revision();
 						return;
 					}
 				} else previousCollection = void 0;
 			}
 			if (!selectionAffects(selection, change)) {
-				sourceRevision = materialize(projection).revision();
+				sourceRevision = materialize(projection, requester).revision();
 				updateCollectionSnapshot();
 				return;
 			}
@@ -2911,12 +3104,12 @@ const createProjectionRuntime = (options) => {
 			const changed = evaluate();
 			if (unsubscribeSource && !sameSelection(previousSelection, selection)) {
 				unsubscribeSource();
-				unsubscribeSource = materialize(projection).subscribe(onProjectionChange);
+				unsubscribeSource = materialize(projection, requester).subscribe(onProjectionChange);
 			}
 			if (changed) Array.from(listeners).forEach((listener) => listener());
 		};
 		const installSource = () => {
-			if (!unsubscribeSource) unsubscribeSource = materialize(projection).subscribe(onProjectionChange);
+			if (!unsubscribeSource) unsubscribeSource = materialize(projection, requester).subscribe(onProjectionChange);
 		};
 		return Object.freeze({
 			current: ensureCurrent,
@@ -2937,18 +3130,134 @@ const createProjectionRuntime = (options) => {
 				};
 			}
 		});
+	};
+	function readable(projection, selector, equality) {
+		return makeReadable(projection, selector, equality);
 	}
+	const setInput = (target, value, requester) => {
+		materialize(target, requester);
+		const record = materialized.get(target);
+		if (record?.kind !== "value-input") throw new TypeError("Projection is not a value input.");
+		record.set(value);
+	};
+	const updateInput = (target, run, requester) => {
+		materialize(target, requester);
+		const record = materialized.get(target);
+		if (record?.kind !== "collection-input") throw new TypeError("Projection is not a collection input.");
+		record.update(run);
+	};
+	const createScope = () => {
+		runtime.assertIdle();
+		const state = {
+			active: true,
+			materialized: [],
+			subscriptions: /* @__PURE__ */ new Set()
+		};
+		scopes.add(state);
+		const assertActive = () => {
+			if (!state.active) throw new ProjectionDisposedError();
+		};
+		const own = (projection) => {
+			assertActive();
+			const definition = definitionOf(projection);
+			const dependencies = definition.kind === "derive" ? definition.dependencies : definition.kind === "incremental-value" || definition.kind === "incremental-collection" ? Object.values(definition.dependencies) : [];
+			for (const dependency of dependencies) {
+				const dependencyOwner = ownerOf(dependency);
+				if (dependencyOwner && dependencyOwner !== state) throw new TypeError("A scope cannot depend on another scope.");
+			}
+			ownDefinition(projection, state);
+			return projection;
+		};
+		const scopedInput = Object.assign((initial, equality) => own(input(initial, equality)), { collection: (initial) => own(input.collection(initial)) });
+		const scopedDerive = (dependencies, compute, equality) => own(derive(dependencies, compute, equality));
+		const scopedIncremental = Object.assign((dependencies, processor) => own(incremental(dependencies, processor)), { collection: (dependencies, processor) => own(incremental.collection(dependencies, processor)) });
+		function scopeReadable(projection, selector, equality) {
+			assertActive();
+			materialize(projection, state);
+			const source = makeReadable(projection, selector, equality, state);
+			return Object.freeze({
+				current: () => {
+					assertActive();
+					return source.current();
+				},
+				revision: () => {
+					assertActive();
+					return source.revision();
+				},
+				subscribe: (listener) => {
+					assertActive();
+					const stop = source.subscribe(listener);
+					let subscribed = true;
+					const unsubscribe = () => {
+						if (!subscribed) return;
+						subscribed = false;
+						state.subscriptions.delete(unsubscribe);
+						stop();
+					};
+					state.subscriptions.add(unsubscribe);
+					return unsubscribe;
+				}
+			});
+		}
+		function scopeBatch(optionsOrCallback, maybeCallback) {
+			assertActive();
+			return typeof optionsOrCallback === "function" ? runtime.batch(optionsOrCallback) : runtime.batch(optionsOrCallback, maybeCallback);
+		}
+		return Object.freeze({
+			input: scopedInput,
+			derive: scopedDerive,
+			incremental: scopedIncremental,
+			get: (projection) => {
+				assertActive();
+				return get(projection, state);
+			},
+			readable: scopeReadable,
+			set: (target, value) => {
+				assertActive();
+				setInput(target, value, state);
+			},
+			update: (target, run) => {
+				assertActive();
+				updateInput(target, run, state);
+			},
+			batch: scopeBatch,
+			dispose: () => {
+				if (!state.active) return;
+				runtime.assertIdle();
+				state.active = false;
+				state.subscriptions.forEach((unsubscribe) => unsubscribe());
+				for (const definition of state.materialized.reverse()) {
+					const record = materialized.get(definition);
+					if (!record) continue;
+					runtime.releaseNode(record.node);
+					if (record.kind !== "projection") runtime.releaseInput(record.source);
+					materialized.delete(definition);
+				}
+				state.materialized.length = 0;
+				scopes.delete(state);
+			}
+		});
+	};
 	const store = {
 		get,
 		readable,
-		set: ((input, value) => {
-			materialize(input);
-			const target = materialized.get(input);
-			if (!target?.set) throw new TypeError("Projection is not an input.");
-			target.set(value);
-		}),
+		set: setInput,
+		update: updateInput,
 		batch: runtime.batch,
-		dispose: runtime.dispose
+		scope: createScope,
+		dispose: () => {
+			if (disposed) return;
+			runtime.assertIdle();
+			disposed = true;
+			for (const scope of scopes) {
+				scope.active = false;
+				scope.subscriptions.forEach((unsubscribe) => unsubscribe());
+				scope.subscriptions.clear();
+				scope.materialized.length = 0;
+			}
+			scopes.clear();
+			runtime.dispose();
+		}
 	};
 	return Object.freeze(store);
 };