doxum 0.1.32 → 0.1.33

package/README.md

@@ -280,6 +280,29 @@ exposes `read`, `select`, `items`, `update`, `batch`, `scope` and `dispose`.
 `ProjectionScope` mirrors `read`, `select`, `items`, `update`, `batch` and `dispose`, plus
 `own(definitionOrTree)` for lifecycle ownership of lazy projection definitions.
 
+### Commands inside a batch
+
+Ordinary reads use `runtime.read`. A batch can read the latest accepted input state through its callback while projection readers keep the last published view:
+
+```ts
+const count = input(0);
+const doubled = derive({ count }, ({ count }) => count * 2);
+
+function increment() {
+  runtime.batch(read => {
+    runtime.update(count, read(count) + 1);
+  });
+}
+
+runtime.batch(() => {
+  increment();
+  increment();
+});
+runtime.read(doubled); // 4
+```
+
+The borrowed reader supports scalar and collection inputs and expires with its callback. Nested batches settle at the outer boundary. Cross-input commands can read several latest source values without mirrors. Input equality is checked before acceptance; a failed edit leaves earlier successes intact. A batch is not a transaction. See [batch source reads](docs/projections.md#batch-source-reads) for snapshots, errors and lifecycle.
+
 ### Keyed projection
 
 `derive.keyed` preserves a keyed driver's membership and order while deriving entries
@@ -400,6 +423,16 @@ key later creates a new generation. A subscribed missing item stays latent and a
 if the key is later added. Runtime batches follow the net published membership, so a
 remove/add collapsed to an update does not create a false lifecycle break.
 
+### One-to-many keyed derivation
+
+```ts
+const lines = derive.keyed.flatMap(orders, order =>
+  order.lines.map(line => [line.id, line] as const)
+);
+```
+
+Each parent returns ordered `[globalKey, value]` tuples, including zero entries. `flatMap` reuses named/dynamic keyed dependencies and only recomputes invalidated parents. Formal output order follows parent order then child order; parent-only reordering runs no selectors. Duplicate final output keys are errors, and present `undefined` is valid. Same-batch transfers preserve a global key's membership identity. Structural changes can rebuild full order; this is not a claim that every operation costs only the changed entries.
+
 ### Runtime-local keyed state
 
 Use `input.collection` for selection, expanded state, local overrides and other

package/dist/advanced.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_transform = require("./transform-CENhTaVN.cjs");
+const require_transform = require("./transform-CSPGdBe5.cjs");
 const require_record = require("./record-ChYUi8PP.cjs");
 //#region core/src/projection/advanced.ts
 const resetCollectionChange = Object.freeze({ kind: "reset" });

package/dist/advanced.d.cts

@@ -1,4 +1,4 @@
-import { c as ProjectionChange, d as CollectionRead, l as CollectionChange, n as KeyedDependencyValues, o as KeyedProjection, s as Projection, t as KeyedDependencies, u as CollectionDraft } from "./dependency-B1qIJJBL.cjs";
+import { c as ProjectionChange, d as CollectionRead, l as CollectionChange, n as KeyedDependencyValues, o as KeyedProjection, s as Projection, t as KeyedDependencies, u as CollectionDraft } from "./dependency-Cbf3C8eJ.cjs";
 
 //#region core/src/projection/collection/change.d.ts
 declare const collectionChange: {

package/dist/advanced.d.ts

@@ -1,4 +1,4 @@
-import { c as ProjectionChange, d as CollectionRead, l as CollectionChange, n as KeyedDependencyValues, o as KeyedProjection, s as Projection, t as KeyedDependencies, u as CollectionDraft } from "./dependency-BRgPvyN6.js";
+import { c as ProjectionChange, d as CollectionRead, l as CollectionChange, n as KeyedDependencyValues, o as KeyedProjection, s as Projection, t as KeyedDependencies, u as CollectionDraft } from "./dependency-DzxXGYe1.js";
 
 //#region core/src/projection/collection/change.d.ts
 declare const collectionChange: {

package/dist/advanced.js

@@ -1,4 +1,4 @@
-import { D as defineProcessor, S as compileProjectionDependencies, l as assertSynchronous, p as collectionChange, t as createKeyedTransform, w as collectionView } from "./transform-gOtqcdHe.js";
+import { C as compileProjectionDependencies, O as defineProcessor, T as collectionView, r as collectionChange, t as createKeyedTransform, v as assertSynchronous } from "./transform-A9Lx5R2l.js";
 import { n as isPlainObject } from "./record-B2yRhYsc.js";
 //#region core/src/projection/advanced.ts
 const resetCollectionChange = Object.freeze({ kind: "reset" });

package/dist/{dependency-B1qIJJBL.d.cts → dependency-Cbf3C8eJ.d.cts}

@@ -134,7 +134,7 @@ type SameKeyConstraint<DriverKey extends string, Dependency> = Dependency extend
   readonly key: unknown;
 } | {
   readonly keys: unknown;
-} ? unknown : DriverKey extends SourceKey ? unknown : never : unknown;
+} ? unknown : [DriverKey] extends [SourceKey] ? unknown : never : unknown;
 type KeyedDependencies<DriverKey extends string, DriverValue, D extends object> = { readonly [P in keyof D]: P extends string ? KeyedDependency<DriverKey, DriverValue> & SameKeyConstraint<DriverKey, D[P]> : never };
 type KeyedDependencyValues<D extends object> = { readonly [P in keyof D]: D[P] extends {
   readonly source: KeyedProjection<infer K extends string, infer V>;
@@ -144,4 +144,4 @@ type KeyedDependencyValues<D extends object> = { readonly [P in keyof D]: D[P] e
 } ? V | undefined : D[P] extends Projection<infer T> ? T : never };
 //#endregion
 export { ProjectionDisposedError as _, Input as a, ProjectionChange as c, CollectionRead as d, ExternalCollectionEvent as f, ExternalValueSource as g, ExternalValueEvent as h, CollectionInputDraft as i, CollectionChange as l, ExternalCollectionSource as m, KeyedDependencyValues as n, KeyedProjection as o, ExternalCollectionRead as p, CollectionInput as r, Projection as s, KeyedDependencies as t, CollectionDraft as u, ProjectionError as v };
-//# sourceMappingURL=dependency-B1qIJJBL.d.cts.map
+//# sourceMappingURL=dependency-Cbf3C8eJ.d.cts.map

package/dist/{dependency-BRgPvyN6.d.ts → dependency-DzxXGYe1.d.ts}

@@ -134,7 +134,7 @@ type SameKeyConstraint<DriverKey extends string, Dependency> = Dependency extend
   readonly key: unknown;
 } | {
   readonly keys: unknown;
-} ? unknown : DriverKey extends SourceKey ? unknown : never : unknown;
+} ? unknown : [DriverKey] extends [SourceKey] ? unknown : never : unknown;
 type KeyedDependencies<DriverKey extends string, DriverValue, D extends object> = { readonly [P in keyof D]: P extends string ? KeyedDependency<DriverKey, DriverValue> & SameKeyConstraint<DriverKey, D[P]> : never };
 type KeyedDependencyValues<D extends object> = { readonly [P in keyof D]: D[P] extends {
   readonly source: KeyedProjection<infer K extends string, infer V>;
@@ -144,4 +144,4 @@ type KeyedDependencyValues<D extends object> = { readonly [P in keyof D]: D[P] e
 } ? V | undefined : D[P] extends Projection<infer T> ? T : never };
 //#endregion
 export { ProjectionDisposedError as _, Input as a, ProjectionChange as c, CollectionRead as d, ExternalCollectionEvent as f, ExternalValueSource as g, ExternalValueEvent as h, CollectionInputDraft as i, CollectionChange as l, ExternalCollectionSource as m, KeyedDependencyValues as n, KeyedProjection as o, ExternalCollectionRead as p, CollectionInput as r, Projection as s, KeyedDependencies as t, CollectionDraft as u, ProjectionError as v };
-//# sourceMappingURL=dependency-BRgPvyN6.d.ts.map
+//# sourceMappingURL=dependency-DzxXGYe1.d.ts.map

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_transform = require("./transform-CENhTaVN.cjs");
+const require_transform = require("./transform-CSPGdBe5.cjs");
 const require_record = require("./record-ChYUi8PP.cjs");
 const require_driver = require("./driver-CN3dGxQI.cjs");
 //#region core/src/schema/model.ts
@@ -2775,6 +2775,108 @@ const isExternalSource = (source) => {
 	return (candidate.kind === "value" || candidate.kind === "collection") && typeof candidate.current === "function" && typeof candidate.revision === "function" && typeof candidate.subscribe === "function";
 };
 //#endregion
+//#region core/src/projection/keyed/flat-map.ts
+function createKeyedFlatMap(source, dependenciesOrSelect, selectOrEquality, maybeEquality) {
+	const name = "derive.keyed.flatMap";
+	require_transform.assertKeyedProjection(source, `${name} source`);
+	const specs = typeof dependenciesOrSelect === "function" ? void 0 : dependenciesOrSelect;
+	const select = specs === void 0 ? dependenciesOrSelect : selectOrEquality;
+	const equality = specs === void 0 ? selectOrEquality : maybeEquality;
+	if (typeof select !== "function") throw new TypeError(`${name} requires a selector.`);
+	if (equality !== void 0 && typeof equality !== "function") throw new TypeError(`${name} equality must be a function.`);
+	const compiled = require_transform.compileKeyedDependencies(source, specs, name);
+	const [projection] = require_transform.defineProcessor({
+		dependencies: compiled.projections,
+		outputs: [{
+			kind: "collection",
+			equality: equality ?? Object.is
+		}],
+		name,
+		create: () => {
+			const dependencies = require_transform.createKeyedDependencyRuntime(compiled);
+			const childrenByParent = /* @__PURE__ */ new Map();
+			const ownerByOutput = /* @__PURE__ */ new Map();
+			return {
+				evaluate: (evaluation) => {
+					const driver = evaluation.sources[0];
+					const output = evaluation.outputs[0];
+					if (driver.kind !== "collection" || output.kind !== "collection") throw new Error(`${name} requires collection input and output.`);
+					const plan = require_transform.collectKeyedInvalidation(driver, evaluation.sources, dependencies, evaluation.reset);
+					dependencies.prepare(evaluation.sources, plan.rebuild);
+					if (plan.rebuild) {
+						dependencies.clearBindings();
+						childrenByParent.clear();
+						ownerByOutput.clear();
+					}
+					const replaced = new Set(plan.keys);
+					for (const entry of plan.removed) replaced.add(entry.key);
+					const proposals = /* @__PURE__ */ new Map();
+					const segments = /* @__PURE__ */ new Map();
+					let orderDirty = plan.structural;
+					for (const parent of replaced) {
+						if (!driver.read.has(parent)) continue;
+						const value = driver.read.get(parent);
+						const entries = select(value, parent, dependencies.resolve(value, parent, evaluation.sources));
+						require_transform.assertSynchronous(entries);
+						if (!Array.isArray(entries)) throw new TypeError(`${name} selector must return an array of entries.`);
+						const keys = [];
+						for (const entry of entries) {
+							if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string") throw new TypeError(`${name} entries must be [string key, value] tuples.`);
+							const [key, child] = entry;
+							const owner = ownerByOutput.get(key);
+							if (proposals.has(key) || owner !== void 0 && !replaced.has(owner)) throw new TypeError(`${name} duplicate key ${JSON.stringify(key)}.`);
+							proposals.set(key, {
+								parent,
+								value: child
+							});
+							keys.push(key);
+						}
+						const previous = childrenByParent.get(parent);
+						const unchanged = previous ? require_transform.sameArray(previous, keys) : keys.length === 0;
+						if (!unchanged) orderDirty = true;
+						if (keys.length) segments.set(parent, unchanged && previous ? previous : Object.freeze(keys));
+					}
+					if (plan.rebuild) {
+						if (!evaluation.reset) {
+							for (const key of output.previous.ids()) if (!proposals.has(key)) output.output.remove(key);
+						}
+					} else for (const parent of replaced) {
+						const previous = childrenByParent.get(parent);
+						if (previous) for (const key of previous) {
+							if (!proposals.has(key)) output.output.remove(key);
+							ownerByOutput.delete(key);
+						}
+						childrenByParent.delete(parent);
+					}
+					for (const entry of plan.removed) dependencies.remove(entry.key);
+					for (const [parent, keys] of segments) childrenByParent.set(parent, keys);
+					for (const [key, entry] of proposals) {
+						ownerByOutput.set(key, entry.parent);
+						output.output.set(key, entry.value);
+					}
+					if (orderDirty) {
+						const order = [];
+						const parents = driver.read.ids();
+						for (const parent of parents) {
+							const keys = childrenByParent.get(parent);
+							if (keys) for (const key of keys) order.push(key);
+						}
+						require_transform.profile.collectionView.idsScanned(parents.length + order.length);
+						output.output.order(order);
+					}
+					dependencies.remember(evaluation.sources);
+				},
+				release: () => {
+					childrenByParent.clear();
+					ownerByOutput.clear();
+					dependencies.release();
+				}
+			};
+		}
+	});
+	return projection;
+}
+//#endregion
 //#region core/src/projection/keyed/composition.ts
 const assertEquality = (equality, role) => {
 	if (equality !== void 0 && typeof equality !== "function") throw new TypeError(`${role} equality must be a function.`);
@@ -3441,44 +3543,26 @@ function createKeyedGroupBy(source, dependenciesOrSelector, maybeSelector) {
 					const driver = evaluation.sources[0];
 					const output = evaluation.outputs[0];
 					if (driver.kind !== "collection" || output.kind !== "collection") throw new Error("derive.keyed.groupBy requires collection input and output.");
-					dependencies.prepare(evaluation.sources, evaluation.reset);
-					if (evaluation.reset) {
+					const invalidation = require_transform.collectKeyedInvalidation(driver, evaluation.sources, dependencies, evaluation.reset);
+					dependencies.prepare(evaluation.sources, invalidation.rebuild);
+					if (invalidation.rebuild) {
 						rebuild(driver, evaluation.sources, output);
 						dependencies.remember(evaluation.sources);
 						return;
 					}
-					const dirty = /* @__PURE__ */ new Set();
 					const affected = /* @__PURE__ */ new Set();
-					let all = false;
-					let structural = false;
-					let orderDirty = false;
-					if (dependencies.driverChanged(driver)) {
-						const change = driver.change;
-						if (!change || change.kind === "reset") {
-							rebuild(driver, evaluation.sources, output);
-							dependencies.remember(evaluation.sources);
-							return;
-						} else {
-							for (const entry of change.removed) {
-								const changed = removeSourceKey(entry.key, affected);
-								orderDirty ||= changed;
-								dependencies.remove(entry.key);
-								dirty.delete(entry.key);
-							}
-							for (const entry of change.added) dirty.add(entry.key);
-							for (const entry of change.updated) dirty.add(entry.key);
-							structural = Boolean(change.added.length || change.removed.length || change.order);
-							orderDirty ||= structural;
-							if (structural) refreshOrderIndex(driver);
-						}
+					let orderDirty = invalidation.structural;
+					for (const entry of invalidation.removed) {
+						const changed = removeSourceKey(entry.key, affected);
+						orderDirty ||= changed;
+						dependencies.remove(entry.key);
 					}
-					all ||= dependencies.collectInvalidated(evaluation.sources, dirty);
-					if (all) for (const key of driver.read.ids()) dirty.add(key);
-					for (const key of dirty) {
+					if (invalidation.structural) refreshOrderIndex(driver);
+					for (const key of invalidation.keys) {
 						const changed = selectGroups(driver, evaluation.sources, key, affected);
 						orderDirty ||= changed;
 					}
-					if (structural) markAllGroups(output, affected);
+					if (invalidation.structural) markAllGroups(output, affected);
 					publishAffected(affected, output, orderDirty);
 					dependencies.remember(evaluation.sources);
 				},
@@ -3502,6 +3586,7 @@ const keyedDerive = Object.assign(createKeyedDerive, {
 	from: createKeyedFrom,
 	merge: createKeyedMerge,
 	groupBy: createKeyedGroupBy,
+	flatMap: createKeyedFlatMap,
 	singleton: createKeyedSingleton,
 	subset: createKeyedSubset,
 	filter: createKeyedFilter,
@@ -3623,11 +3708,11 @@ var PersistentKeyedIndex = class PersistentKeyedIndex {
 	}
 };
 //#endregion
-//#region core/src/projection/output/collection.ts
-const createPublishedCollection = () => {
-	const values = /* @__PURE__ */ new Map();
-	let ids = Object.freeze([]);
-	let index = PersistentKeyedIndex.empty();
+//#region core/src/projection/collection/state.ts
+const createCollectionState = (initial) => {
+	const values = new Map(initial);
+	let ids = Object.freeze([...values.keys()]);
+	let index = values.size ? PersistentKeyedIndex.from(values) : PersistentKeyedIndex.empty();
 	return {
 		get: (key) => values.get(key),
 		has: (key) => values.has(key),
@@ -3652,7 +3737,7 @@ const createPublishedCollection = () => {
 				}
 			});
 		},
-		publish: (staged, nextIds, reset) => {
+		install: (staged, nextIds, reset) => {
 			if (reset) {
 				values.clear();
 				for (const [key, entry] of staged) if (entry.present) values.set(key, entry.value);
@@ -3671,9 +3756,11 @@ const createPublishedCollection = () => {
 		}
 	};
 };
+//#endregion
+//#region core/src/projection/output/collection.ts
 /** Owns staged keyed intent, exact transitions and published collection state. */
 const createCollectionOutput = (binding) => {
-	const published = createPublishedCollection();
+	const published = createCollectionState();
 	const staged = /* @__PURE__ */ new Map();
 	let nextIds = published.ids();
 	let change;
@@ -3762,12 +3849,18 @@ const createCollectionOutput = (binding) => {
 					continue;
 				}
 				const before = published.get(key);
-				if (!isEqual(before, entry.value)) updatedEntries.push({
+				const equal = isEqual(before, entry.value);
+				require_transform.assertSynchronous(equal);
+				if (!equal) updatedEntries.push({
 					key,
 					before,
 					after: entry.value
 				});
-				else if (!nextReset) staged.delete(key);
+				else if (nextReset) staged.set(key, {
+					present: true,
+					value: before
+				});
+				else staged.delete(key);
 				continue;
 			}
 			if (existed) removedEntries.push({
@@ -3837,7 +3930,7 @@ const createCollectionOutput = (binding) => {
 		revision: () => revision,
 		reset: () => reset,
 		publish: () => {
-			if (change) published.publish(staged, nextIds, change.kind === "reset");
+			if (change) published.install(staged, nextIds, change.kind === "reset");
 			if (change && initialized) revision++;
 			initialized = true;
 		},
@@ -3917,7 +4010,9 @@ const createValueOutput = (binding) => {
 			return false;
 		}
 		const candidate = staged;
-		changed = !initialized || !isEqual(value, candidate);
+		const equal = initialized ? isEqual(value, candidate) : false;
+		require_transform.assertSynchronous(equal);
+		changed = !equal;
 		next = changed ? candidate : value;
 		reset = nextReset;
 		return changed;
@@ -5399,101 +5494,145 @@ const createExternalSourceRegistry = (scheduler, documents) => {
 //#region core/src/projection/source/input.ts
 const materializeInputSource = (scheduler, definition) => {
 	const source = definition.source;
+	if (source.kind !== "value-input" && source.kind !== "collection-input") throw new Error("Invalid projection input source.");
+	const equal = (previous, next) => {
+		const result = source.equality(previous, next);
+		require_transform.assertSynchronous(result);
+		return result;
+	};
 	if (source.kind === "value-input") {
 		let latest = source.initial;
-		const boundary = createValueBoundary(scheduler, "projection input", source.initial, source.equality, () => latest, () => void 0);
+		const boundary = createValueBoundary(scheduler, "projection input", source.initial, Object.is, () => latest, () => void 0);
+		boundary.detach(() => {
+			latest = void 0;
+		});
 		return {
 			...boundary,
-			write: {
+			input: {
 				kind: "value",
+				read: () => latest,
 				set(value) {
-					scheduler.assertIdle();
-					latest = value;
+					const next = scheduler.acceptInput(() => {
+						if (equal(latest, value)) return latest;
+						if (source.equality === Object.is) return value;
+						const published = boundary.output.current();
+						return !Object.is(latest, published) && equal(published, value) ? published : value;
+					});
+					if (Object.is(latest, next)) return;
+					latest = next;
 					boundary.mark();
 					scheduler.run();
 				}
 			}
 		};
 	}
-	if (source.kind !== "collection-input") throw new Error("Invalid projection input source.");
-	const values = new Map(source.initial);
-	const boundary = createCollectionBoundary(scheduler, "projection collection input", () => require_transform.mapRead(values), definition.output.equality, () => void 0);
+	const values = createCollectionState(source.initial);
+	let view;
+	const latest = {
+		get: values.get,
+		has: values.has,
+		ids: values.ids
+	};
+	const boundary = createCollectionBoundary(scheduler, "projection collection input", () => latest, Object.is, () => void 0);
+	boundary.detach(() => {
+		values.release();
+		view = void 0;
+	});
+	const check = () => {
+		scheduler.assertActive();
+		if (boundary.producer.disposed) throw new require_transform.ProjectionDisposedError();
+	};
 	return {
 		...boundary,
-		write: {
+		input: {
 			kind: "collection",
+			read: () => view ??= require_transform.collectionView(values.read(check)),
 			update(run) {
-				scheduler.assertIdle();
-				const staged = /* @__PURE__ */ new Map();
-				const operations = [];
-				let structural = false;
-				let active = true;
-				const draft = Object.freeze({
-					get: (key) => {
-						require_transform.assertScope(() => active);
-						const entry = staged.get(key);
-						return entry ? entry.present ? entry.value : void 0 : values.get(key);
-					},
-					has: (key) => {
-						require_transform.assertScope(() => active);
+				const accepted = scheduler.acceptInput(() => {
+					const staged = /* @__PURE__ */ new Map();
+					const appended = /* @__PURE__ */ new Set();
+					let structural = false;
+					let active = true;
+					const has = (key) => {
 						const entry = staged.get(key);
 						return entry ? entry.present : values.has(key);
-					},
-					set: (key, value) => {
-						require_transform.assertScope(() => active);
-						if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
-						const previous = staged.get(key);
-						structural ||= previous ? !previous.present : !values.has(key);
-						staged.set(key, {
-							present: true,
-							value
-						});
-						operations.push({
-							kind: "set",
-							key,
-							value
-						});
-					},
-					remove: (key) => {
-						require_transform.assertScope(() => active);
-						if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
-						const previous = staged.get(key);
-						const present = previous ? previous.present : values.has(key);
-						structural ||= present;
-						staged.set(key, { present: false });
-						if (present) operations.push({
-							kind: "remove",
-							key
-						});
+					};
+					const draft = Object.freeze({
+						get: (key) => {
+							require_transform.assertScope(() => active);
+							const entry = staged.get(key);
+							return entry ? entry.present ? entry.value : void 0 : values.get(key);
+						},
+						has: (key) => {
+							require_transform.assertScope(() => active);
+							return has(key);
+						},
+						set: (key, value) => {
+							require_transform.assertScope(() => active);
+							if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
+							if (!has(key)) {
+								appended.add(key);
+								structural = true;
+							}
+							staged.set(key, {
+								present: true,
+								value
+							});
+						},
+						remove: (key) => {
+							require_transform.assertScope(() => active);
+							if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
+							if (!has(key)) return;
+							appended.delete(key);
+							structural = true;
+							staged.set(key, { present: false });
+						}
+					});
+					try {
+						require_transform.assertSynchronous(run(draft));
+					} finally {
+						active = false;
 					}
-				});
-				try {
-					require_transform.assertSynchronous(run(draft));
-				} finally {
-					active = false;
-				}
-				if (!operations.length) return;
-				const candidates = /* @__PURE__ */ new Set();
-				const retained = /* @__PURE__ */ new Map();
-				for (const [key, entry] of staged) {
-					const existed = values.has(key);
-					if (entry.present) {
-						if (!existed) {
-							candidates.add(key);
+					const published = source.equality === Object.is ? void 0 : boundary.output.current();
+					for (const [key, entry] of staged) {
+						const existed = values.has(key);
+						if (!entry.present) {
+							if (!existed) staged.delete(key);
 							continue;
 						}
 						const previous = values.get(key);
-						if (source.equality(previous, entry.value)) retained.set(key, previous);
-						else candidates.add(key);
-					} else if (existed) candidates.add(key);
-				}
-				if (!candidates.size && !structural) return;
-				for (const operation of operations) if (operation.kind === "set") values.set(operation.key, operation.value);
-				else values.delete(operation.key);
-				for (const [key, value] of retained) if (values.has(key)) values.set(key, value);
+						let next = entry.value;
+						if (existed && equal(previous, next)) next = previous;
+						else if (published?.has(key)) {
+							const before = published.get(key);
+							if ((!existed || !Object.is(previous, before)) && equal(before, next)) next = before;
+						}
+						if (existed && Object.is(previous, next)) staged.delete(key);
+						else if (!Object.is(entry.value, next)) staged.set(key, {
+							present: true,
+							value: next
+						});
+					}
+					const beforeOrder = values.ids();
+					let order = beforeOrder;
+					if (structural) {
+						const next = [];
+						for (const key of beforeOrder) if (has(key) && !appended.has(key)) next.push(key);
+						for (const key of appended) next.push(key);
+						if (!require_transform.sameArray(beforeOrder, next)) order = Object.freeze(next);
+					}
+					return {
+						staged,
+						order,
+						structural: order !== beforeOrder
+					};
+				});
+				if (!accepted.staged.size && !accepted.structural) return;
+				values.install(accepted.staged, accepted.order, false);
+				view = void 0;
 				boundary.mark({
-					candidates,
-					orderMayChange: structural
+					candidates: accepted.staged.keys(),
+					orderMayChange: accepted.structural
 				});
 				scheduler.run();
 			}
@@ -5790,7 +5929,7 @@ const createProjectionRuntime = (options) => {
 			result = Object.freeze({
 				record: source.producer,
 				outputs: Object.freeze([source.output]),
-				...source.write ? { write: source.write } : {}
+				...source.input ? { input: source.input } : {}
 			});
 		} else {
 			if (definition.owner === void 0 && definition.dependencies.some((dependency) => require_transform.producerOf(dependency).owner !== void 0)) throw new TypeError("A root projection cannot depend on a scoped projection.");
@@ -5875,16 +6014,18 @@ const createProjectionRuntime = (options) => {
 	function selectProjection(projection, selector, equality) {
 		return makeReadable(projection, selector, equality);
 	}
-	const inputWrite = (target, requester) => {
+	const inputAccess = (target, requester) => {
+		scheduler.assertIdle();
+		if (requester && !requester.active) throw new require_transform.ProjectionDisposedError();
 		const ref = require_transform.projectionRef(target);
 		if (ref.output !== 0 || ref.producer.kind !== "source") throw new TypeError("Projection is not an input.");
 		if (ref.producer.source.kind !== "value-input" && ref.producer.source.kind !== "collection-input") throw new TypeError("Projection is not an input.");
-		const write = materializeProducer(ref.producer, requester).write;
-		if (!write) throw new TypeError("Projection input is not writable.");
-		return write;
+		const access = materializeProducer(ref.producer, requester).input;
+		if (!access) throw new TypeError("Projection input is not writable.");
+		return access;
 	};
 	const updateInput = (target, valueOrRun, requester) => {
-		const write = inputWrite(target, requester);
+		const write = inputAccess(target, requester);
 		if (write.kind === "value") {
 			write.set(valueOrRun);
 			return;
@@ -5895,7 +6036,18 @@ const createProjectionRuntime = (options) => {
 	function update(target, valueOrRun) {
 		updateInput(target, valueOrRun);
 	}
-	const batch = (run, options) => scheduler.batch(run, options);
+	const batch = (run, options, requester) => scheduler.batch(() => {
+		let active = true;
+		const read = (target) => {
+			require_transform.assertScope(() => active);
+			return inputAccess(target, requester).read();
+		};
+		try {
+			return run(read);
+		} finally {
+			active = false;
+		}
+	}, options);
 	const disposeScope = (state) => {
 		if (!state.active) return;
 		scheduler.assertIdle();
@@ -5987,7 +6139,7 @@ const createProjectionRuntime = (options) => {
 		}
 		function scopeBatch(run, options) {
 			assertActive();
-			return batch(run, options);
+			return batch(run, options, state);
 		}
 		return Object.freeze({
 			own,