@rocicorp/zero 1.6.2 → 1.7.0-canary.1

package/out/zql/src/ivm/view-apply-change.js

@@ -5,150 +5,277 @@ import "./data.js";
 //#region ../zql/src/ivm/view-apply-change.ts
 var refCountSymbol = Symbol("rc");
 var idSymbol = Symbol("id");
-function applyChange(parentEntry, change, schema, relationship, format, withIDs = false) {
+/**
+* Get child nodes from a relationship, handling both lazy (Node) and expanded (ExpandedNode).
+*/
+function* getChildNodes(node, relationship) {
+	const children = node.relationships[relationship];
+	if (Array.isArray(children)) yield* children;
+	else yield* skipYields(children());
+}
+/**
+* Transaction-scoped copy-on-write.
+*
+* `applyChange` is immutable: it path-copies a new spine on every call so the
+* previously-emitted snapshot is never mutated. But within a single transaction
+* (a run of `push()` calls before `flush()`) only the final state is ever
+* observed by a listener, so the intermediate spines are pure allocation/GC
+* churn — making a K-change transaction O(K * spineSize).
+*
+* When the caller passes a WeakSet as the `mutate` argument, objects and arrays
+* that were created or cloned during the current transaction are recorded in it.
+* A helper that needs to modify such an object mutates it in place (it is not
+* yet observed) instead of cloning again. The first touch of a node still
+* copies-on-write (preserving the committed snapshot's references); subsequent
+* touches in the same transaction are in-place. This brings a K-change
+* transaction to O(spineSize + K) while keeping cross-transaction reference
+* stability.
+*
+* The set is module-scoped for the duration of a single (synchronous,
+* non-re-entrant) `applyChange` call and saved/restored around it.
+*
+* It is a WeakSet on purpose: it must not keep transiently-cloned arrays/entries
+* alive. A strong Set would extend their lifetime to the end of the transaction,
+* pushing large clones out of the young generation and adding GC pressure that
+* shows up as a regression on single-change transactions over wide lists. A
+* WeakSet gives the same identity test ("created this transaction?") while
+* letting dead clones be collected as cheaply as in the plain immutable path.
+*/
+var activeDirty;
+/** True if `o` was created/cloned during the current transaction. */
+function owns(o) {
+	return activeDirty !== void 0 && activeDirty.has(o);
+}
+/** Record `o` as owned by the current transaction (no-op outside a txn). */
+function track(o) {
+	activeDirty?.add(o);
+	return o;
+}
+/**
+* Immutable view update. Returns new Entry on change, same Entry if unchanged.
+* Unchanged entries keep identity, enabling shallow comparison optimizations
+* in UI frameworks (React.memo, Solid's fine-grained reactivity, etc).
+*
+* Propagation: recurse DOWN to find target, copy objects on the way UP.
+* Siblings keep original refs. Only the ancestor path is copied.
+*
+*   root {users:[A,B], items:[C,D,E]}    --edit C-->    root' {users:[A,B], items':[C',D,E]}
+*         │ same ref        │                                  │              │
+*         └─────────────────┴── unchanged ──────────────┘     new array     C' new, D/E same
+*
+* `mutate` selects the update strategy:
+* - `false` (default): fully immutable; every changed node is path-copied.
+* - `true`: mutate the tree in place (only safe when it is not yet observed,
+*   e.g. during initial hydration).
+* - a `WeakSet`: transaction-scoped copy-on-write — copy on first touch, then
+*   mutate in place for the rest of the transaction. See `activeDirty` above.
+*/
+function applyChange(parentEntry, change, schema, relationship, format, withIDs = false, mutate = false) {
+	const inPlace = mutate === true;
+	const prevDirty = activeDirty;
+	activeDirty = typeof mutate === "object" ? mutate : void 0;
+	try {
+		return applyChangeInternal(parentEntry, change, schema, relationship, format, withIDs, inPlace);
+	} finally {
+		activeDirty = prevDirty;
+	}
+}
+function applyChangeInternal(parentEntry, change, schema, relationship, format, withIDs, mutate) {
 	if (schema.isHidden) switch (change.type) {
 		case "add":
-		case "remove":
-			for (const [relationship, children] of Object.entries(change.node.relationships)) {
+		case "remove": {
+			let currentParent = parentEntry;
+			for (const relationship of Object.keys(change.node.relationships)) {
 				const childSchema = must(schema.relationships[relationship]);
-				for (const node of skipYields(children())) applyChange(parentEntry, {
+				for (const node of getChildNodes(change.node, relationship)) currentParent = applyChangeInternal(currentParent, {
 					type: change.type,
 					node
-				}, childSchema, relationship, format, withIDs);
+				}, childSchema, relationship, format, withIDs, mutate);
 			}
-			return;
-		case "edit": return;
+			return currentParent;
+		}
+		case "edit": return parentEntry;
 		case "child": {
 			const childSchema = must(schema.relationships[change.child.relationshipName]);
-			applyChange(parentEntry, change.child.change, childSchema, relationship, format, withIDs);
-			return;
+			return applyChangeInternal(parentEntry, change.child.change, childSchema, relationship, format, withIDs, mutate);
 		}
 		default: unreachable(change);
 	}
 	const { singular, relationships: childFormats } = format;
 	switch (change.type) {
-		case "add": {
-			let newEntry;
-			if (singular) {
-				const oldEntry = parentEntry[relationship];
-				if (oldEntry !== void 0) {
-					assert(schema.compareRows(oldEntry, change.node.row) === 0, `Singular relationship '${relationship}' should not have multiple rows. You may need to declare this relationship with the \`many\` helper instead of the \`one\` helper in your schema.`);
-					oldEntry[refCountSymbol]++;
-				} else {
-					newEntry = makeNewMetaEntry(change.node.row, schema, withIDs, 1);
-					parentEntry[relationship] = newEntry;
-				}
-			} else newEntry = addToView(change.node.row, getChildEntryList(parentEntry, relationship), schema, withIDs);
-			if (newEntry) for (const [relationship, children] of Object.entries(change.node.relationships)) {
-				const childSchema = must(schema.relationships[relationship]);
-				const childFormat = childFormats[relationship];
-				if (childFormat === void 0) continue;
-				const newView = childFormat.singular ? void 0 : [];
-				newEntry[relationship] = newView;
-				for (const node of skipYields(children())) applyChange(newEntry, {
-					type: "add",
-					node
-				}, childSchema, relationship, childFormat, withIDs);
+		case "add": if (singular) {
+			const oldEntry = getOptionalSingularEntry(parentEntry, relationship);
+			if (oldEntry !== void 0) {
+				assert(schema.compareRows(oldEntry, change.node.row) === 0, `Singular relationship '${relationship}' should not have multiple rows. You may need to declare this relationship with the \`many\` helper instead of the \`one\` helper in your schema.`);
+				return setRelation(mutate, parentEntry, relationship, incRefCount(mutate, oldEntry));
+			} else {
+				const newEntry = makeNewMetaEntry(change.node.row, schema, withIDs, 1);
+				initializeRelationshipsForNewEntryIfAny(newEntry, change.node, schema, childFormats, withIDs);
+				return setRelation(mutate, parentEntry, relationship, newEntry);
 			}
-			break;
+		} else {
+			const view = getChildEntryList(parentEntry, relationship);
+			const { newEntry, newView } = add(change.node.row, view, schema, withIDs, mutate);
+			if (newEntry) initializeRelationshipsForNewEntryIfAny(newEntry, change.node, schema, childFormats, withIDs);
+			return setRelation(mutate, parentEntry, relationship, newView);
 		}
-		case "remove":
-			if (singular) {
-				const oldEntry = parentEntry[relationship];
-				assert(oldEntry !== void 0, "node does not exist");
-				if (oldEntry[refCountSymbol] === 1) parentEntry[relationship] = void 0;
-				oldEntry[refCountSymbol]--;
-			} else removeAndUpdateRefCount(getChildEntryList(parentEntry, relationship), change.node.row, schema.compareRows);
-			break;
+		case "remove": if (singular) {
+			const oldEntry = getSingularEntry(parentEntry, relationship);
+			if (oldEntry[refCountSymbol] === 1) return setRelation(mutate, parentEntry, relationship, void 0);
+			return setRelation(mutate, parentEntry, relationship, decRefCount(mutate, oldEntry));
+		} else return setRelation(mutate, parentEntry, relationship, removeAndUpdateRefCount(getChildEntryList(parentEntry, relationship), change.node.row, schema.compareRows, mutate));
 		case "child": {
-			let existing;
-			if (singular) existing = getSingularEntry(parentEntry, relationship);
-			else {
-				const view = getChildEntryList(parentEntry, relationship);
-				const bsResult = binarySearch(view, change.node.row, schema.compareRows);
-				assert(bsResult >= 0, "node does not exist");
-				existing = view[bsResult];
-			}
 			const childSchema = must(schema.relationships[change.child.relationshipName]);
 			const childFormat = format.relationships[change.child.relationshipName];
-			if (childFormat !== void 0) applyChange(existing, change.child.change, childSchema, change.child.relationshipName, childFormat, withIDs);
-			break;
-		}
-		case "edit":
+			if (childFormat === void 0) return parentEntry;
 			if (singular) {
-				const existing = parentEntry[relationship];
-				assertMetaEntry(existing);
-				applyEdit(existing, change, schema, withIDs);
+				const existing = getSingularEntry(parentEntry, relationship);
+				const newExisting = applyChangeInternal(existing, change.child.change, childSchema, change.child.relationshipName, childFormat, withIDs, mutate);
+				if (newExisting === existing) return parentEntry;
+				return setRelation(mutate, parentEntry, relationship, newExisting);
 			} else {
 				const view = getChildEntryList(parentEntry, relationship);
-				if (schema.compareRows(change.oldNode.row, change.node.row) !== 0) {
-					const oldBsResult = binarySearch(view, change.oldNode.row, schema.compareRows);
-					assert(oldBsResult >= 0, "old node does not exist");
-					const oldPos = oldBsResult;
-					const oldEntry = view[oldPos];
-					const newBsResult = binarySearch(view, change.node.row, schema.compareRows);
-					const found = newBsResult >= 0;
-					const pos = found ? newBsResult : ~newBsResult;
-					if (oldEntry[refCountSymbol] === 1 && (pos === oldPos || pos - 1 === oldPos)) applyEdit(oldEntry, change, schema, withIDs);
-					else {
-						oldEntry[refCountSymbol]--;
-						let adjustedPos = pos;
-						if (oldEntry[refCountSymbol] === 0) {
-							view.splice(oldPos, 1);
-							adjustedPos = oldPos < pos ? pos - 1 : pos;
-						}
-						let entryToEdit;
-						if (found) entryToEdit = view[adjustedPos];
-						else {
-							view.splice(adjustedPos, 0, oldEntry);
-							entryToEdit = oldEntry;
-							if (oldEntry[refCountSymbol] > 0) view[oldPos] = { ...oldEntry };
-						}
-						entryToEdit[refCountSymbol]++;
-						applyEdit(entryToEdit, change, schema, withIDs);
+				const pos = binarySearch(view, change.node.row, schema.compareRows);
+				assert(pos >= 0, "node does not exist");
+				const existing = view[pos];
+				const newExisting = applyChangeInternal(existing, change.child.change, childSchema, change.child.relationshipName, childFormat, withIDs, mutate);
+				if (newExisting === existing) return parentEntry;
+				assertMetaEntry(newExisting);
+				return setRelation(mutate, parentEntry, relationship, arrayWith(mutate, view, pos, newExisting));
+			}
+		}
+		case "edit": if (singular) return setRelation(mutate, parentEntry, relationship, applyEdit(getSingularEntry(parentEntry, relationship), change, schema, withIDs, mutate));
+		else {
+			const view = getChildEntryList(parentEntry, relationship);
+			if (schema.compareRows(change.oldNode.row, change.node.row) !== 0) {
+				const oldPos = binarySearch(view, change.oldNode.row, schema.compareRows);
+				assert(oldPos >= 0, "old node does not exist");
+				const oldEntry = view[oldPos];
+				const rawPos = binarySearch(view, change.node.row, schema.compareRows);
+				const found = rawPos >= 0;
+				const pos = found ? rawPos : ~rawPos;
+				if (oldEntry[refCountSymbol] === 1 && (pos === oldPos || pos - 1 === oldPos)) return setRelation(mutate, parentEntry, relationship, arrayWith(mutate, view, oldPos, applyEdit(oldEntry, change, schema, withIDs, mutate)));
+				else {
+					const newRefCount = oldEntry[refCountSymbol] - 1;
+					let newView;
+					let adjustedPos = pos;
+					if (newRefCount === 0) {
+						newView = removeAt(mutate, view, oldPos);
+						adjustedPos = oldPos < pos ? pos - 1 : pos;
+					} else newView = arrayWith(mutate, view, oldPos, setRefCount(mutate, oldEntry, newRefCount));
+					if (found) {
+						const existingEntry = newView[adjustedPos];
+						const updatedEntry = setRefCount(mutate, applyEdit(existingEntry, change, schema, withIDs, mutate), existingEntry[refCountSymbol] + 1);
+						return setRelation(mutate, parentEntry, relationship, arrayWith(mutate, newView, adjustedPos, updatedEntry));
+					} else {
+						const movedEntry = setRefCount(mutate, applyEdit(oldEntry, change, schema, withIDs, mutate), 1);
+						return setRelation(mutate, parentEntry, relationship, insertAt(mutate, newView, adjustedPos, movedEntry));
 					}
-				} else {
-					const bsResult = binarySearch(view, change.oldNode.row, schema.compareRows);
-					assert(bsResult >= 0, "node does not exist");
-					applyEdit(view[bsResult], change, schema, withIDs);
 				}
+			} else {
+				const pos = binarySearch(view, change.oldNode.row, schema.compareRows);
+				assert(pos >= 0, "node does not exist");
+				return setRelation(mutate, parentEntry, relationship, arrayWith(mutate, view, pos, applyEdit(view[pos], change, schema, withIDs, mutate)));
 			}
-			break;
+		}
 		default: unreachable(change);
 	}
 }
-function applyEdit(existing, change, schema, withIDs) {
-	Object.assign(existing, change.node.row);
-	if (withIDs) existing[idSymbol] = makeID(change.node.row, schema);
+function applyEdit(existing, change, schema, withIDs, mutate) {
+	const newEntry = (mutate || owns(existing)) && schema.compareRows(change.oldNode.row, change.node.row) === 0 ? Object.assign(existing, change.node.row) : track({
+		...existing,
+		...change.node.row
+	});
+	if (withIDs) return setProperty(mutate, newEntry, idSymbol, makeID(change.node.row, schema));
+	return newEntry;
+}
+/**
+* Initialize child relationships on a newly-added entry by mutating it in place.
+*
+* New nodes don't exist in the view yet, so we can build in-place (no refs to preserve):
+*
+* New nodes don't exist in the view yet, so we can build in-place (no refs to preserve):
+*
+*   Existing node edit (must path-copy):     New node (can build in-place):
+*
+*   view: [A, B, C]                          view: [A, B, _]
+*              │                                         │
+*         edit C.child                              add C with children
+*              │                                         │
+*              ▼                                         ▼
+*   view': [A, B, C']  ◄─ path-copy          view': [A, B, C{children:[...]}]
+*                         up the tree                    └─ built in-place
+*
+* Hidden schemas still use applyChange to collapse junction levels.
+*/
+function initializeRelationshipsForNewEntryIfAny(entry, node, schema, childFormats, withIDs) {
+	let result = entry;
+	for (const relationship of Object.keys(node.relationships)) {
+		const childSchema = must(schema.relationships[relationship]);
+		const childFormat = childFormats[relationship];
+		if (childFormat === void 0) continue;
+		if (childSchema.isHidden || childFormat.singular) {
+			result[relationship] = childFormat.singular ? void 0 : track([]);
+			for (const childNode of getChildNodes(node, relationship)) applyChangeInternal(result, {
+				type: "add",
+				node: childNode
+			}, childSchema, relationship, childFormat, withIDs, true);
+		} else {
+			const childArray = track([]);
+			for (const childNode of getChildNodes(node, relationship)) {
+				const newEntry = makeNewMetaEntry(childNode.row, childSchema, withIDs, 1);
+				const rawPos = binarySearch(childArray, childNode.row, childSchema.compareRows);
+				if (rawPos >= 0) childArray[rawPos][refCountSymbol]++;
+				else {
+					childArray.splice(~rawPos, 0, newEntry);
+					initializeRelationshipsForNewEntryIfAny(newEntry, childNode, childSchema, childFormat.relationships, withIDs);
+				}
+			}
+			result[relationship] = childArray;
+		}
+	}
 }
-function addToView(row, view, schema, withIDs) {
-	const bsResult = binarySearch(view, row, schema.compareRows);
-	if (bsResult >= 0) {
-		view[bsResult][refCountSymbol]++;
-		return;
+function add(row, view, schema, withIDs, mutate) {
+	const rawPos = binarySearch(view, row, schema.compareRows);
+	if (rawPos >= 0) {
+		const existing = view[rawPos];
+		return {
+			newEntry: void 0,
+			newView: arrayWith(mutate, view, rawPos, incRefCount(mutate, existing))
+		};
 	}
-	const pos = ~bsResult;
 	const newEntry = makeNewMetaEntry(row, schema, withIDs, 1);
-	view.splice(pos, 0, newEntry);
-	return newEntry;
+	return {
+		newEntry,
+		newView: insertAt(mutate, view, ~rawPos, newEntry)
+	};
 }
-function removeAndUpdateRefCount(view, row, compareRows) {
-	const bsResult = binarySearch(view, row, compareRows);
-	assert(bsResult >= 0, "node does not exist");
-	const oldEntry = view[bsResult];
-	if (oldEntry[refCountSymbol] === 1) view.splice(bsResult, 1);
-	oldEntry[refCountSymbol]--;
-	return oldEntry;
+function insertAt(mutate, array, index, item) {
+	if (mutate || owns(array)) {
+		array.splice(index, 0, item);
+		return array;
+	}
+	return track(array.toSpliced(index, 0, item));
+}
+function removeAt(mutate, array, index) {
+	if (mutate || owns(array)) {
+		array.splice(index, 1);
+		return array;
+	}
+	return track(array.toSpliced(index, 1));
+}
+function removeAndUpdateRefCount(view, row, compareRows, mutate) {
+	const pos = binarySearch(view, row, compareRows);
+	assert(pos >= 0, "node does not exist");
+	const oldEntry = view[pos];
+	if (oldEntry[refCountSymbol] === 1) return removeAt(mutate, view, pos);
+	return arrayWith(mutate, view, pos, decRefCount(mutate, oldEntry));
 }
 /**
-* Binary search a sorted view.
-*
-* Returns the index of `target` if found (a non-negative integer), or
-* `~insertionIndex` if not found (always negative, following Java's
-* `Arrays.binarySearch` convention). To get the insertion index when
-* not found use the bitwise NOT: `~result`.
-*
-* This avoids allocating a `{pos, found}` result object on every call.
+* Binary search returning a number.
+* - If found at index `i`: returns `i` (>= 0).
+* - If not found, insertion point is `low`: returns `~low` (< 0).
+*   Recover insertion point with `~result`.
 */
 function binarySearch(view, target, comparator) {
 	let low = 0;
@@ -162,34 +289,80 @@ function binarySearch(view, target, comparator) {
 	}
 	return ~low;
 }
-function getChildEntryList(parentEntry, relationship) {
-	const view = parentEntry[relationship];
-	assertArray(view);
-	return view;
-}
+/** Assert value is MetaEntry (has refCountSymbol). */
 function assertMetaEntry(v) {
 	assertNumber(v[refCountSymbol]);
 }
+/** Get singular MetaEntry, throws if missing. */
 function getSingularEntry(parentEntry, relationship) {
-	const e = parentEntry[relationship];
-	assertNumber(e[refCountSymbol]);
-	return e;
+	const entry = parentEntry[relationship];
+	assert(entry !== void 0, "node does not exist");
+	assertMetaEntry(entry);
+	return entry;
+}
+/** Get singular MetaEntry or undefined if not set. */
+function getOptionalSingularEntry(parentEntry, relationship) {
+	const entry = parentEntry[relationship];
+	if (entry === void 0) return;
+	assertMetaEntry(entry);
+	return entry;
+}
+/** Get child array as MetaEntryList. */
+function getChildEntryList(parentEntry, relationship) {
+	const view = parentEntry[relationship];
+	assertArray(view);
+	return view;
 }
+/** Create MetaEntry from row with given refCount. */
 function makeNewMetaEntry(row, schema, withIDs, rc) {
-	if (withIDs) return {
+	if (withIDs) return track({
 		...row,
 		[refCountSymbol]: rc,
 		[idSymbol]: makeID(row, schema)
-	};
-	return {
+	});
+	return track({
 		...row,
 		[refCountSymbol]: rc
-	};
+	});
 }
 function makeID(row, schema) {
 	if (schema.primaryKey.length === 1) return JSON.stringify(row[schema.primaryKey[0]]);
 	return JSON.stringify(schema.primaryKey.map((k) => row[k]));
 }
+function incRefCount(mutate, entry) {
+	return setRefCount(mutate, entry, entry[refCountSymbol] + 1);
+}
+function decRefCount(mutate, entry) {
+	return setRefCount(mutate, entry, entry[refCountSymbol] - 1);
+}
+function setRefCount(mutate, entry, count) {
+	if (mutate || owns(entry)) {
+		entry[refCountSymbol] = count;
+		return entry;
+	}
+	return track({
+		...entry,
+		[refCountSymbol]: count
+	});
+}
+function arrayWith(mutate, array, index, value) {
+	if (mutate || owns(array)) {
+		array[index] = value;
+		return array;
+	}
+	return track(array.with(index, value));
+}
+function setProperty(mutate, parentEntry, key, value) {
+	if (mutate || owns(parentEntry)) {
+		parentEntry[key] = value;
+		return parentEntry;
+	}
+	return track({
+		...parentEntry,
+		[key]: value
+	});
+}
+var setRelation = setProperty;
 //#endregion
 export { applyChange, idSymbol, refCountSymbol };
 

package/out/zql/src/ivm/view-apply-change.js.map

@@ -1 +1 @@
-{"version":3,"file":"view-apply-change.js","names":[],"sources":["../../../../../zql/src/ivm/view-apply-change.ts"],"sourcesContent":["import {\n  assert,\n  assertArray,\n  assertNumber,\n  unreachable,\n} from '../../../shared/src/asserts.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport type {Writable} from '../../../shared/src/writable.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport {type Comparator, type Node} from './data.ts';\nimport {skipYields} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {Entry, Format} from './view.ts';\n\nexport const refCountSymbol = Symbol('rc');\nexport const idSymbol = Symbol('id');\n\ntype MetaEntry = Writable<Entry> & {\n  [refCountSymbol]: number;\n  [idSymbol]?: string | undefined;\n};\ntype MetaEntryList = MetaEntry[];\n\n/**\n * `applyChange` does not consume the `relationships` of `ChildChange#node`,\n * `EditChange#node` and `EditChange#oldNode`.  The `ViewChange` type\n * documents and enforces this via the type system.\n */\nexport type ViewChange =\n  | AddViewChange\n  | RemoveViewChange\n  | ChildViewChange\n  | EditViewChange;\n\nexport type RowOnlyNode = {row: Row};\n\nexport type AddViewChange = {\n  type: 'add';\n  node: Node;\n};\n\nexport type RemoveViewChange = {\n  type: 'remove';\n  node: Node;\n};\n\ntype ChildViewChange = {\n  type: 'child';\n  node: RowOnlyNode;\n  child: {\n    relationshipName: string;\n    change: ViewChange;\n  };\n};\n\ntype EditViewChange = {\n  type: 'edit';\n  node: RowOnlyNode;\n  oldNode: RowOnlyNode;\n};\n\n/**\n * This is a subset of WeakMap but restricted to what we need.\n * @deprecated Not used anymore. This will be removed in the future.\n */\nexport interface RefCountMap {\n  get(entry: Entry): number | undefined;\n  set(entry: Entry, refCount: number): void;\n  delete(entry: Entry): boolean;\n}\n\nexport function applyChange(\n  parentEntry: Entry,\n  change: ViewChange,\n  schema: SourceSchema,\n  relationship: string,\n  format: Format,\n  withIDs = false,\n): void {\n  if (schema.isHidden) {\n    switch (change.type) {\n      case 'add':\n      case 'remove':\n        for (const [relationship, children] of Object.entries(\n          change.node.relationships,\n        )) {\n          const childSchema = must(schema.relationships[relationship]);\n          for (const node of skipYields(children())) {\n            applyChange(\n              parentEntry,\n              {type: change.type, node},\n              childSchema,\n              relationship,\n              format,\n              withIDs,\n            );\n          }\n        }\n        return;\n      case 'edit':\n        // If hidden at this level it means that the hidden row was changed. If\n        // the row was changed in such a way that it would change the\n        // relationships then the edit would have been split into remove and\n        // add.\n        return;\n      case 'child': {\n        const childSchema = must(\n          schema.relationships[change.child.relationshipName],\n        );\n        applyChange(\n          parentEntry,\n          change.child.change,\n          childSchema,\n          relationship,\n          format,\n          withIDs,\n        );\n        return;\n      }\n      default:\n        unreachable(change);\n    }\n  }\n\n  const {singular, relationships: childFormats} = format;\n  switch (change.type) {\n    case 'add': {\n      let newEntry: MetaEntry | undefined;\n\n      if (singular) {\n        const oldEntry = parentEntry[relationship] as MetaEntry | undefined;\n        if (oldEntry !== undefined) {\n          assert(\n            schema.compareRows(oldEntry, change.node.row) === 0,\n            `Singular relationship '${relationship}' should not have multiple rows. You may need to declare this relationship with the \\`many\\` helper instead of the \\`one\\` helper in your schema.`,\n          );\n          // adding same again.\n          oldEntry[refCountSymbol]++;\n        } else {\n          newEntry = makeNewMetaEntry(change.node.row, schema, withIDs, 1);\n\n          (parentEntry as Writable<Entry>)[relationship] = newEntry;\n        }\n      } else {\n        newEntry = addToView(\n          change.node.row,\n          getChildEntryList(parentEntry, relationship),\n          schema,\n          withIDs,\n        );\n      }\n\n      if (newEntry) {\n        for (const [relationship, children] of Object.entries(\n          change.node.relationships,\n        )) {\n          // TODO: Is there a flag to make TypeScript complain that dictionary access might be undefined?\n          const childSchema = must(schema.relationships[relationship]);\n          const childFormat = childFormats[relationship];\n          if (childFormat === undefined) {\n            continue;\n          }\n\n          const newView = childFormat.singular\n            ? undefined\n            : ([] as MetaEntryList);\n          newEntry[relationship] = newView;\n\n          for (const node of skipYields(children())) {\n            applyChange(\n              newEntry,\n              {type: 'add', node},\n              childSchema,\n              relationship,\n              childFormat,\n              withIDs,\n            );\n          }\n        }\n      }\n      break;\n    }\n    case 'remove': {\n      if (singular) {\n        const oldEntry = parentEntry[relationship] as MetaEntry | undefined;\n        assert(oldEntry !== undefined, 'node does not exist');\n        const rc = oldEntry[refCountSymbol];\n        if (rc === 1) {\n          (parentEntry as Writable<Entry>)[relationship] = undefined;\n        }\n        oldEntry[refCountSymbol]--;\n      } else {\n        removeAndUpdateRefCount(\n          getChildEntryList(parentEntry, relationship),\n          change.node.row,\n          schema.compareRows,\n        );\n      }\n      break;\n    }\n    case 'child': {\n      let existing: MetaEntry;\n      if (singular) {\n        existing = getSingularEntry(parentEntry, relationship);\n      } else {\n        const view = getChildEntryList(parentEntry, relationship);\n        const bsResult = binarySearch(\n          view,\n          change.node.row,\n          schema.compareRows,\n        );\n        assert(bsResult >= 0, 'node does not exist');\n        existing = view[bsResult];\n      }\n\n      const childSchema = must(\n        schema.relationships[change.child.relationshipName],\n      );\n      const childFormat = format.relationships[change.child.relationshipName];\n      if (childFormat !== undefined) {\n        applyChange(\n          existing,\n          change.child.change,\n          childSchema,\n          change.child.relationshipName,\n          childFormat,\n          withIDs,\n        );\n      }\n      break;\n    }\n    case 'edit': {\n      if (singular) {\n        const existing = parentEntry[relationship];\n        assertMetaEntry(existing);\n        applyEdit(existing, change, schema, withIDs);\n      } else {\n        const view = getChildEntryList(parentEntry, relationship);\n        // The position of the row in the list may have changed due to the edit.\n        if (schema.compareRows(change.oldNode.row, change.node.row) !== 0) {\n          const oldBsResult = binarySearch(\n            view,\n            change.oldNode.row,\n            schema.compareRows,\n          );\n          assert(oldBsResult >= 0, 'old node does not exist');\n          const oldPos = oldBsResult;\n          const oldEntry = view[oldPos];\n          const newBsResult = binarySearch(\n            view,\n            change.node.row,\n            schema.compareRows,\n          );\n          const found = newBsResult >= 0;\n          const pos = found ? newBsResult : ~newBsResult;\n          // A special case:\n          // when refCount is 1 (so the row is being moved\n          // without leaving a placeholder behind), and the new pos is\n          // the same as the old, or directly after the old (so after the remove\n          // of the old it would be in the same pos):\n          // the row does not need to be moved, it can just be edited in place.\n          if (\n            oldEntry[refCountSymbol] === 1 &&\n            (pos === oldPos || pos - 1 === oldPos)\n          ) {\n            applyEdit(oldEntry, change, schema, withIDs);\n          } else {\n            // Move the row.  If the row has > 1 ref count, an edit should\n            // be received for each ref count.  On the first edit, the original\n            // row is moved, the edit is applied to it and its ref count is set\n            // to 1.  A shallow copy of the row is left at the old pos for\n            // processing of the remaining edit, and the copy's ref count\n            // is decremented.  As each edit is received the ref count of the\n            // copy is decrement, and the ref count of the row at the new\n            // position is incremented.  When the copy's ref count goes to 0,\n            // it is removed.\n            oldEntry[refCountSymbol]--;\n            let adjustedPos = pos;\n            if (oldEntry[refCountSymbol] === 0) {\n              view.splice(oldPos, 1);\n              adjustedPos = oldPos < pos ? pos - 1 : pos;\n            }\n\n            let entryToEdit;\n            if (found) {\n              entryToEdit = view[adjustedPos];\n            } else {\n              view.splice(adjustedPos, 0, oldEntry);\n              entryToEdit = oldEntry;\n              if (oldEntry[refCountSymbol] > 0) {\n                const oldEntryCopy = {...oldEntry};\n                view[oldPos] = oldEntryCopy;\n              }\n            }\n            entryToEdit[refCountSymbol]++;\n            applyEdit(entryToEdit, change, schema, withIDs);\n          }\n        } else {\n          // Position could not have changed, so simply edit in place.\n          const bsResult = binarySearch(\n            view,\n            change.oldNode.row,\n            schema.compareRows,\n          );\n          assert(bsResult >= 0, 'node does not exist');\n          applyEdit(view[bsResult], change, schema, withIDs);\n        }\n      }\n\n      break;\n    }\n    default:\n      unreachable(change);\n  }\n}\n\nfunction applyEdit(\n  existing: MetaEntry,\n  change: EditViewChange,\n  schema: SourceSchema,\n  withIDs: boolean,\n) {\n  Object.assign(existing, change.node.row);\n  if (withIDs) {\n    existing[idSymbol] = makeID(change.node.row, schema);\n  }\n}\n\nfunction addToView(\n  row: Row,\n  view: MetaEntryList,\n  schema: SourceSchema,\n  withIDs: boolean,\n): MetaEntry | undefined {\n  const bsResult = binarySearch(view, row, schema.compareRows);\n\n  if (bsResult >= 0) {\n    view[bsResult][refCountSymbol]++;\n    return undefined;\n  }\n  const pos = ~bsResult;\n  const newEntry = makeNewMetaEntry(row, schema, withIDs, 1);\n  view.splice(pos, 0, newEntry);\n  return newEntry;\n}\n\nfunction removeAndUpdateRefCount(\n  view: MetaEntryList,\n  row: Row,\n  compareRows: Comparator,\n): MetaEntry {\n  const bsResult = binarySearch(view, row, compareRows);\n  assert(bsResult >= 0, 'node does not exist');\n  const oldEntry = view[bsResult];\n  const rc = oldEntry[refCountSymbol];\n  if (rc === 1) {\n    view.splice(bsResult, 1);\n  }\n  oldEntry[refCountSymbol]--;\n\n  return oldEntry;\n}\n\n/**\n * Binary search a sorted view.\n *\n * Returns the index of `target` if found (a non-negative integer), or\n * `~insertionIndex` if not found (always negative, following Java's\n * `Arrays.binarySearch` convention). To get the insertion index when\n * not found use the bitwise NOT: `~result`.\n *\n * This avoids allocating a `{pos, found}` result object on every call.\n */\nfunction binarySearch(\n  view: MetaEntryList,\n  target: Row,\n  comparator: Comparator,\n): number {\n  let low = 0;\n  let high = view.length - 1;\n  while (low <= high) {\n    const mid = (low + high) >>> 1;\n    const comparison = comparator(view[mid] as Row, target as Row);\n    if (comparison < 0) {\n      low = mid + 1;\n    } else if (comparison > 0) {\n      high = mid - 1;\n    } else {\n      return mid; // found\n    }\n  }\n  return ~low; // not found; use ~result to get insertion index\n}\n\nfunction getChildEntryList(\n  parentEntry: Entry,\n  relationship: string,\n): MetaEntryList {\n  const view = parentEntry[relationship];\n  assertArray(view);\n  return view as MetaEntryList;\n}\n\nfunction assertMetaEntry(v: unknown): asserts v is MetaEntry {\n  assertNumber((v as Partial<MetaEntry>)[refCountSymbol]);\n}\n\nfunction getSingularEntry(parentEntry: Entry, relationship: string): MetaEntry {\n  const e = parentEntry[relationship];\n  assertNumber((e as Partial<MetaEntry>)[refCountSymbol]);\n  return e as MetaEntry;\n}\n\nfunction makeNewMetaEntry(\n  row: Row,\n  schema: SourceSchema,\n  withIDs: boolean,\n  rc: number,\n): MetaEntry {\n  if (withIDs) {\n    return {...row, [refCountSymbol]: rc, [idSymbol]: makeID(row, schema)};\n  }\n  return {...row, [refCountSymbol]: rc};\n}\nfunction makeID(row: Row, schema: SourceSchema) {\n  // optimization for case of non-compound primary key\n  if (schema.primaryKey.length === 1) {\n    return JSON.stringify(row[schema.primaryKey[0]]);\n  }\n  return JSON.stringify(schema.primaryKey.map(k => row[k]));\n}\n"],"mappings":"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"}
+{"version":3,"file":"view-apply-change.js","names":[],"sources":["../../../../../zql/src/ivm/view-apply-change.ts"],"sourcesContent":["import {\n  assert,\n  assertArray,\n  assertNumber,\n  unreachable,\n} from '../../../shared/src/asserts.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport type {Writable} from '../../../shared/src/writable.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport {type Comparator, type Node} from './data.ts';\nimport {skipYields} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {Entry, Format} from './view.ts';\n\nexport const refCountSymbol = Symbol('rc');\nexport const idSymbol = Symbol('id');\n\ntype ReadonlyMetaEntry = Entry & {\n  readonly [refCountSymbol]: number;\n  readonly [idSymbol]?: string | undefined;\n};\n\ntype MutableMetaEntry = Writable<ReadonlyMetaEntry>;\n\n/**\n * MetaEntry is an Entry with internal tracking fields for reference counting\n * and stable identity. All entries in the view tree are MetaEntry instances,\n * created through makeNewMetaEntry().\n */\ntype MetaEntry<M extends Mutate> = M extends true\n  ? MutableMetaEntry\n  : ReadonlyMetaEntry;\n\ntype MutableArray<M extends Mutate, T> = M extends true ? T[] : readonly T[];\n\ntype MetaEntryList<M extends Mutate> = MutableArray<M, MetaEntry<M>>;\n\ntype MutableMetaEntryList = MutableMetaEntry[];\n\n/**\n * Node with eagerly-expanded relationships (arrays instead of generators).\n * Used when batching changes to capture source state at push time.\n */\nexport type ExpandedNode = {\n  row: Row;\n  relationships: Record<string, ExpandedNode[]>;\n};\n\n/**\n * A node for view changes. Can be either:\n * - A lazy Node with generator relationships (original behavior)\n * - An ExpandedNode with pre-computed relationship arrays (for batching)\n */\nexport type ViewNode = Node | ExpandedNode;\n\n/**\n * `applyChange` does not consume the `relationships` of `ChildChange#node`,\n * `EditChange#node` and `EditChange#oldNode`.  The `ViewChange` type\n * documents and enforces this via the type system.\n */\nexport type ViewChange =\n  | AddViewChange\n  | RemoveViewChange\n  | ChildViewChange\n  | EditViewChange;\n\nexport type RowOnlyNode = {row: Row};\n\nexport type AddViewChange = {\n  type: 'add';\n  node: ViewNode;\n};\n\nexport type RemoveViewChange = {\n  type: 'remove';\n  node: ViewNode;\n};\n\ntype ChildViewChange = {\n  type: 'child';\n  node: RowOnlyNode;\n  child: {\n    relationshipName: string;\n    change: ViewChange;\n  };\n};\n\ntype EditViewChange = {\n  type: 'edit';\n  node: RowOnlyNode;\n  oldNode: RowOnlyNode;\n};\n\n/**\n * This is a subset of WeakMap but restricted to what we need.\n * @deprecated Not used anymore. This will be removed in the future.\n */\nexport interface RefCountMap {\n  get(entry: Entry): number | undefined;\n  set(entry: Entry, refCount: number): void;\n  delete(entry: Entry): boolean;\n}\n\n/**\n * Get child nodes from a relationship, handling both lazy (Node) and expanded (ExpandedNode).\n */\nfunction* getChildNodes(\n  node: ViewNode,\n  relationship: string,\n): Generator<ViewNode> {\n  const children = node.relationships[relationship];\n  if (Array.isArray(children)) {\n    // ExpandedNode: already an array\n    yield* children;\n  } else {\n    // Node: lazy generator function\n    yield* skipYields(children());\n  }\n}\n\ntype Mutate = boolean;\ntype WithIDs = boolean;\n\n/**\n * Transaction-scoped copy-on-write.\n *\n * `applyChange` is immutable: it path-copies a new spine on every call so the\n * previously-emitted snapshot is never mutated. But within a single transaction\n * (a run of `push()` calls before `flush()`) only the final state is ever\n * observed by a listener, so the intermediate spines are pure allocation/GC\n * churn — making a K-change transaction O(K * spineSize).\n *\n * When the caller passes a WeakSet as the `mutate` argument, objects and arrays\n * that were created or cloned during the current transaction are recorded in it.\n * A helper that needs to modify such an object mutates it in place (it is not\n * yet observed) instead of cloning again. The first touch of a node still\n * copies-on-write (preserving the committed snapshot's references); subsequent\n * touches in the same transaction are in-place. This brings a K-change\n * transaction to O(spineSize + K) while keeping cross-transaction reference\n * stability.\n *\n * The set is module-scoped for the duration of a single (synchronous,\n * non-re-entrant) `applyChange` call and saved/restored around it.\n *\n * It is a WeakSet on purpose: it must not keep transiently-cloned arrays/entries\n * alive. A strong Set would extend their lifetime to the end of the transaction,\n * pushing large clones out of the young generation and adding GC pressure that\n * shows up as a regression on single-change transactions over wide lists. A\n * WeakSet gives the same identity test (\"created this transaction?\") while\n * letting dead clones be collected as cheaply as in the plain immutable path.\n */\nlet activeDirty: WeakSet<object> | undefined;\n\n/** True if `o` was created/cloned during the current transaction. */\nfunction owns(o: object): boolean {\n  return activeDirty !== undefined && activeDirty.has(o);\n}\n\n/** Record `o` as owned by the current transaction (no-op outside a txn). */\nfunction track<T extends object>(o: T): T {\n  activeDirty?.add(o);\n  return o;\n}\n\n/**\n * Immutable view update. Returns new Entry on change, same Entry if unchanged.\n * Unchanged entries keep identity, enabling shallow comparison optimizations\n * in UI frameworks (React.memo, Solid's fine-grained reactivity, etc).\n *\n * Propagation: recurse DOWN to find target, copy objects on the way UP.\n * Siblings keep original refs. Only the ancestor path is copied.\n *\n *   root {users:[A,B], items:[C,D,E]}    --edit C-->    root' {users:[A,B], items':[C',D,E]}\n *         │ same ref        │                                  │              │\n *         └─────────────────┴── unchanged ──────────────┘     new array     C' new, D/E same\n *\n * `mutate` selects the update strategy:\n * - `false` (default): fully immutable; every changed node is path-copied.\n * - `true`: mutate the tree in place (only safe when it is not yet observed,\n *   e.g. during initial hydration).\n * - a `WeakSet`: transaction-scoped copy-on-write — copy on first touch, then\n *   mutate in place for the rest of the transaction. See `activeDirty` above.\n */\nexport function applyChange(\n  parentEntry: Entry,\n  change: ViewChange,\n  schema: SourceSchema,\n  relationship: string,\n  format: Format,\n  withIDs = false,\n  mutate: boolean | WeakSet<object> = false,\n): Entry {\n  // A WeakSet selects copy-on-write; a boolean selects full mutate / immutable.\n  const inPlace = mutate === true;\n  const prevDirty = activeDirty;\n  activeDirty = typeof mutate === 'object' ? mutate : undefined;\n  try {\n    return applyChangeInternal(\n      parentEntry as MetaEntry<typeof inPlace>,\n      change,\n      schema,\n      relationship,\n      format,\n      withIDs,\n      inPlace,\n    );\n  } finally {\n    activeDirty = prevDirty;\n  }\n}\n\nexport function applyChangeInternal<M extends Mutate>(\n  parentEntry: MetaEntry<M>,\n  change: ViewChange,\n  schema: SourceSchema,\n  relationship: string,\n  format: Format,\n  withIDs: WithIDs,\n  mutate: M,\n): MetaEntry<M> {\n  if (schema.isHidden) {\n    switch (change.type) {\n      case 'add':\n      case 'remove': {\n        let currentParent = parentEntry;\n        for (const relationship of Object.keys(change.node.relationships)) {\n          const childSchema = must(schema.relationships[relationship]);\n          for (const node of getChildNodes(change.node, relationship)) {\n            currentParent = applyChangeInternal(\n              currentParent,\n              {type: change.type, node},\n              childSchema,\n              relationship,\n              format,\n              withIDs,\n              mutate,\n            );\n          }\n        }\n        return currentParent;\n      }\n      case 'edit':\n        // If hidden at this level it means that the hidden row was changed. If\n        // the row was changed in such a way that it would change the\n        // relationships then the edit would have been split into remove and\n        // add.\n        return parentEntry;\n      case 'child': {\n        const childSchema = must(\n          schema.relationships[change.child.relationshipName],\n        );\n        return applyChangeInternal(\n          parentEntry,\n          change.child.change,\n          childSchema,\n          relationship,\n          format,\n          withIDs,\n          mutate,\n        );\n      }\n      default:\n        unreachable(change);\n    }\n  }\n\n  const {singular, relationships: childFormats} = format;\n  switch (change.type) {\n    // ADD: Insert row (rc=1) or increment refCount if duplicate.\n    // RefCount tracks when the same row is reachable via multiple edges\n    // within a relationship:\n    //\n    //   issue.labels: [L1, L2]     both point to same creator\n    //        │    │                        │\n    //        ▼    ▼                        ▼\n    //   label.creator ──────────►  [User:rc=2]  (one row, two refs)\n    //\n    //   add(A)      add(A)      remove(A)   remove(A)\n    //     ↓           ↓            ↓           ↓\n    //   [A:rc=1] → [A:rc=2] → [A:rc=1] → (deleted)\n    case 'add': {\n      if (singular) {\n        const oldEntry = getOptionalSingularEntry(parentEntry, relationship);\n        if (oldEntry !== undefined) {\n          // Duplicate add: increment refCount\n          assert(\n            schema.compareRows(oldEntry, change.node.row) === 0,\n            `Singular relationship '${relationship}' should not have multiple rows. You may need to declare this relationship with the \\`many\\` helper instead of the \\`one\\` helper in your schema.`,\n          );\n\n          const newEntry = incRefCount(mutate, oldEntry);\n          return setRelation(mutate, parentEntry, relationship, newEntry);\n        } else {\n          // New row: create with rc=1, initialize nested relationships\n          const newEntry = makeNewMetaEntry(\n            change.node.row,\n            schema,\n            withIDs,\n            1,\n          );\n          initializeRelationshipsForNewEntryIfAny(\n            newEntry,\n            change.node,\n            schema,\n            childFormats,\n            withIDs,\n          );\n          return setRelation(mutate, parentEntry, relationship, newEntry);\n        }\n      } else {\n        // Plural: binary search for position, insert or increment refCount\n        const view = getChildEntryList(parentEntry, relationship);\n        const {newEntry, newView} = add(\n          change.node.row,\n          view,\n          schema,\n          withIDs,\n          mutate,\n        );\n\n        if (newEntry) {\n          initializeRelationshipsForNewEntryIfAny(\n            newEntry,\n            change.node,\n            schema,\n            childFormats,\n            withIDs,\n          );\n        }\n        return setRelation(mutate, parentEntry, relationship, newView);\n      }\n    }\n    // REMOVE: Decrement refCount, physically remove when rc=0.\n    case 'remove': {\n      if (singular) {\n        const oldEntry = getSingularEntry(parentEntry, relationship);\n        const rc = oldEntry[refCountSymbol];\n        if (rc === 1) {\n          return setRelation(mutate, parentEntry, relationship, undefined);\n        }\n        const newEntry = decRefCount(mutate, oldEntry);\n        return setRelation(mutate, parentEntry, relationship, newEntry);\n      } else {\n        const view = getChildEntryList(parentEntry, relationship);\n        const newView = removeAndUpdateRefCount(\n          view,\n          change.node.row,\n          schema.compareRows,\n          mutate,\n        );\n        return setRelation(mutate, parentEntry, relationship, newView);\n      }\n    }\n    // CHILD: Propagate nested change up to this level (leaf-to-root pattern).\n    case 'child': {\n      const childSchema = must(\n        schema.relationships[change.child.relationshipName],\n      );\n      const childFormat = format.relationships[change.child.relationshipName];\n      if (childFormat === undefined) {\n        return parentEntry; // Relationship not in view format\n      }\n\n      if (singular) {\n        const existing = getSingularEntry(parentEntry, relationship);\n        const newExisting = applyChangeInternal(\n          existing,\n          change.child.change,\n          childSchema,\n          change.child.relationshipName,\n          childFormat,\n          withIDs,\n          mutate,\n        );\n        // Preserve identity if child didn't change (enables shallow-compare optimizations).\n        if (newExisting === existing) {\n          return parentEntry;\n        }\n        return setRelation(mutate, parentEntry, relationship, newExisting);\n      } else {\n        // Find the target row in the sorted array via binary search.\n        const view = getChildEntryList(parentEntry, relationship);\n        const pos = binarySearch(view, change.node.row, schema.compareRows);\n        assert(pos >= 0, 'node does not exist');\n        const existing = view[pos];\n        const newExisting = applyChangeInternal(\n          existing,\n          change.child.change,\n          childSchema,\n          change.child.relationshipName,\n          childFormat,\n          withIDs,\n          mutate,\n        );\n        // Preserve identity if descendant didn't change.\n        if (newExisting === existing) {\n          return parentEntry;\n        }\n        // applyChangeInternal preserves MetaEntry structure when input is MetaEntry\n        assertMetaEntry(newExisting);\n        return setRelation(\n          mutate,\n          parentEntry,\n          relationship,\n          arrayWith(mutate, view, pos, newExisting),\n        );\n      }\n    }\n    // EDIT: Update row fields. If sort key changes, row may move position.\n    //\n    // Position change with rc>1 (two query paths reach same row):\n    //\n    //   Before: [A, B(rc=2), C, D]          After: [A, B(rc=1), C, B'(rc=1), D]\n    //                │                                  │            │\n    //           path1 + path2                      path1 ghost    path2 moved\n    //\n    // Why ghost stays: path1 still expects B at old position.\n    // B' appears where path2's sort order places it.\n    case 'edit': {\n      if (singular) {\n        const existing = getSingularEntry(parentEntry, relationship);\n        const newEntry = applyEdit(existing, change, schema, withIDs, mutate);\n        return setRelation(mutate, parentEntry, relationship, newEntry);\n      } else {\n        const view = getChildEntryList(parentEntry, relationship);\n        // Sort key changed: row may need to move\n        if (schema.compareRows(change.oldNode.row, change.node.row) !== 0) {\n          const oldPos = binarySearch(\n            view,\n            change.oldNode.row,\n            schema.compareRows,\n          );\n          assert(oldPos >= 0, 'old node does not exist');\n          const oldEntry = view[oldPos];\n          const rawPos = binarySearch(\n            view,\n            change.node.row,\n            schema.compareRows,\n          );\n          const found = rawPos >= 0;\n          const pos = found ? rawPos : ~rawPos;\n          // A special case:\n          // when refCount is 1 (so the row is being moved without leaving a\n          // placeholder behind), and the new pos is the same as the old, or\n          // directly after the old (so after the remove of the old it would be\n          // in the same pos): the row does not need to be moved, just edited.\n          if (\n            oldEntry[refCountSymbol] === 1 &&\n            (pos === oldPos || pos - 1 === oldPos)\n          ) {\n            const newEntry = applyEdit(\n              oldEntry,\n              change,\n              schema,\n              withIDs,\n              mutate,\n            );\n            return setRelation(\n              mutate,\n              parentEntry,\n              relationship,\n              arrayWith(mutate, view, oldPos, newEntry),\n            );\n          } else {\n            // Move the row. If rc > 1, an edit will be received for each ref.\n            // On first edit: move row, apply edit, set rc=1. Leave a copy at\n            // old pos with decremented rc. As each edit arrives, old copy's rc\n            // decrements and new pos rc increments. When copy rc hits 0, remove.\n            const newRefCount = oldEntry[refCountSymbol] - 1;\n            let newView: MutableMetaEntryList;\n            let adjustedPos = pos;\n\n            if (newRefCount === 0) {\n              newView = removeAt(mutate, view, oldPos);\n              adjustedPos = oldPos < pos ? pos - 1 : pos;\n            } else {\n              const oldEntryCopy = setRefCount(mutate, oldEntry, newRefCount);\n              newView = arrayWith(mutate, view, oldPos, oldEntryCopy);\n            }\n\n            if (found) {\n              // Merge with existing at new pos\n              const existingEntry = newView[adjustedPos];\n              const editedEntry = applyEdit(\n                existingEntry,\n                change,\n                schema,\n                withIDs,\n                mutate,\n              );\n              const updatedEntry = setRefCount(\n                mutate,\n                editedEntry,\n                existingEntry[refCountSymbol] + 1,\n              );\n              return setRelation(\n                mutate,\n                parentEntry,\n                relationship,\n                arrayWith(mutate, newView, adjustedPos, updatedEntry),\n              );\n            } else {\n              // Insert at new pos with rc=1\n              const editedEntry = applyEdit(\n                oldEntry,\n                change,\n                schema,\n                withIDs,\n                mutate,\n              );\n              const movedEntry = setRefCount(mutate, editedEntry, 1);\n              return setRelation(\n                mutate,\n                parentEntry,\n                relationship,\n                insertAt(mutate, newView, adjustedPos, movedEntry),\n              );\n            }\n          }\n        } else {\n          // Sort key unchanged: edit in place\n          const pos = binarySearch(\n            view,\n            change.oldNode.row,\n            schema.compareRows,\n          );\n          assert(pos >= 0, 'node does not exist');\n          const newEntry = applyEdit(\n            view[pos],\n            change,\n            schema,\n            withIDs,\n            mutate,\n          );\n          return setRelation(\n            mutate,\n            parentEntry,\n            relationship,\n            arrayWith(mutate, view, pos, newEntry),\n          );\n        }\n      }\n    }\n    default:\n      unreachable(change);\n  }\n}\n\n/**\n * Batch apply multiple changes to an Entry tree.\n * For small batches or complex cases, falls back to sequential applyChange.\n * Future optimization: O(N + K) batch processing for large K.\n */\nexport function applyChanges(\n  parentEntry: Entry,\n  changes: ViewChange[],\n  schema: SourceSchema,\n  relationship: string,\n  format: Format,\n  withIDs: WithIDs = false,\n  mutate: Mutate = false,\n): Entry {\n  let result = parentEntry;\n  for (const change of changes) {\n    result = applyChange(\n      result,\n      change,\n      schema,\n      relationship,\n      format,\n      withIDs,\n      mutate,\n    );\n  }\n  return result;\n}\n\nfunction applyEdit<M extends Mutate>(\n  existing: MetaEntry<M>,\n  change: EditViewChange,\n  schema: SourceSchema,\n  withIDs: WithIDs,\n  mutate: Mutate,\n): MetaEntry<M> {\n  // In-place edit is safe when fully mutating or when `existing` was already\n  // created/cloned in this transaction (copy-on-write). A primary-key change\n  // always needs a fresh entry so identity tracks the new key.\n  const canMutate = mutate || owns(existing);\n  const newEntry: MutableMetaEntry =\n    canMutate && schema.compareRows(change.oldNode.row, change.node.row) === 0\n      ? Object.assign(existing, change.node.row)\n      : track({...existing, ...change.node.row});\n\n  if (withIDs) {\n    return setProperty(\n      mutate,\n      newEntry,\n      idSymbol,\n      makeID(change.node.row, schema),\n    );\n  }\n  return newEntry;\n}\n\n/**\n * Initialize child relationships on a newly-added entry by mutating it in place.\n *\n * New nodes don't exist in the view yet, so we can build in-place (no refs to preserve):\n *\n * New nodes don't exist in the view yet, so we can build in-place (no refs to preserve):\n *\n *   Existing node edit (must path-copy):     New node (can build in-place):\n *\n *   view: [A, B, C]                          view: [A, B, _]\n *              │                                         │\n *         edit C.child                              add C with children\n *              │                                         │\n *              ▼                                         ▼\n *   view': [A, B, C']  ◄─ path-copy          view': [A, B, C{children:[...]}]\n *                         up the tree                    └─ built in-place\n *\n * Hidden schemas still use applyChange to collapse junction levels.\n */\nfunction initializeRelationshipsForNewEntryIfAny(\n  entry: MutableMetaEntry,\n  node: ViewNode,\n  schema: SourceSchema,\n  childFormats: Record<string, Format>,\n  withIDs: WithIDs,\n): void {\n  let result = entry;\n  for (const relationship of Object.keys(node.relationships)) {\n    const childSchema = must(schema.relationships[relationship]);\n    const childFormat = childFormats[relationship];\n    if (childFormat === undefined) {\n      continue;\n    }\n\n    // Hidden/singular: use applyChange to handle properly\n    if (childSchema.isHidden || childFormat.singular) {\n      const newView = childFormat.singular\n        ? undefined\n        : track([] as MutableMetaEntryList);\n      result[relationship] = newView;\n\n      for (const childNode of getChildNodes(node, relationship)) {\n        applyChangeInternal(\n          result,\n          {type: 'add', node: childNode},\n          childSchema,\n          relationship,\n          childFormat,\n          withIDs,\n          true, // this is a new entry, so we can mutate\n        );\n      }\n    } else {\n      // Plural non-hidden: build array in-place for efficiency\n      const childArray: MutableMetaEntryList = track([]);\n\n      for (const childNode of getChildNodes(node, relationship)) {\n        const newEntry = makeNewMetaEntry(\n          childNode.row,\n          childSchema,\n          withIDs,\n          1,\n        );\n        const rawPos = binarySearch(\n          childArray,\n          childNode.row,\n          childSchema.compareRows,\n        );\n\n        if (rawPos >= 0) {\n          childArray[rawPos][refCountSymbol]++;\n        } else {\n          childArray.splice(~rawPos, 0, newEntry);\n          initializeRelationshipsForNewEntryIfAny(\n            newEntry,\n            childNode,\n            childSchema,\n            childFormat.relationships,\n            withIDs,\n          );\n        }\n      }\n\n      result[relationship] = childArray;\n    }\n  }\n}\n\nfunction add<M extends Mutate>(\n  row: Row,\n  view: MetaEntryList<M>,\n  schema: SourceSchema,\n  withIDs: WithIDs,\n  mutate: M,\n): {\n  newEntry: MutableMetaEntry | undefined;\n  newView: MutableMetaEntryList;\n} {\n  const rawPos = binarySearch(view, row, schema.compareRows);\n\n  if (rawPos >= 0) {\n    const existing = view[rawPos];\n\n    const updated = incRefCount(mutate, existing);\n    return {\n      newEntry: undefined,\n      newView: arrayWith(mutate, view, rawPos, updated),\n    };\n  }\n  const newEntry = makeNewMetaEntry(row, schema, withIDs, 1);\n  return {newEntry, newView: insertAt(mutate, view, ~rawPos, newEntry)};\n}\n\nfunction insertAt<M extends Mutate, T>(\n  mutate: M,\n  array: MutableArray<M, T>,\n  index: number,\n  item: T,\n): T[] {\n  if (mutate || owns(array)) {\n    (array as T[]).splice(index, 0, item);\n    return array as T[];\n  }\n  return track(array.toSpliced(index, 0, item));\n}\n\nfunction removeAt<M extends Mutate, T>(\n  mutate: M,\n  array: MutableArray<M, T>,\n  index: number,\n): T[] {\n  if (mutate || owns(array)) {\n    (array as T[]).splice(index, 1);\n    return array as T[];\n  }\n  return track(array.toSpliced(index, 1));\n}\n\nfunction removeAndUpdateRefCount<M extends Mutate>(\n  view: MetaEntryList<M>,\n  row: Row,\n  compareRows: Comparator,\n  mutate: M,\n): MutableMetaEntryList {\n  const pos = binarySearch(view, row, compareRows);\n  assert(pos >= 0, 'node does not exist');\n  const oldEntry = view[pos];\n  const rc = oldEntry[refCountSymbol];\n  if (rc === 1) {\n    return removeAt(mutate, view, pos);\n  }\n  const newEntry = decRefCount(mutate, oldEntry);\n  return arrayWith(mutate, view, pos, newEntry);\n}\n\n/**\n * Binary search returning a number.\n * - If found at index `i`: returns `i` (>= 0).\n * - If not found, insertion point is `low`: returns `~low` (< 0).\n *   Recover insertion point with `~result`.\n */\nfunction binarySearch(\n  view: MetaEntryList<Mutate>,\n  target: Row,\n  comparator: Comparator,\n): number {\n  let low = 0;\n  let high = view.length - 1;\n  while (low <= high) {\n    const mid = (low + high) >>> 1;\n    // MetaEntry has all Row props; comparator only reads string keys\n    const comparison = comparator(view[mid] as Row, target);\n    if (comparison < 0) {\n      low = mid + 1;\n    } else if (comparison > 0) {\n      high = mid - 1;\n    } else {\n      return mid;\n    }\n  }\n  return ~low;\n}\n\n/** Assert value is MetaEntry (has refCountSymbol). */\nfunction assertMetaEntry<M extends Mutate>(\n  v: unknown,\n): asserts v is MetaEntry<M> {\n  assertNumber((v as Partial<MetaEntry<M>>)[refCountSymbol]);\n}\n\n/** Get singular MetaEntry, throws if missing. */\nfunction getSingularEntry<M extends Mutate>(\n  parentEntry: MetaEntry<M>,\n  relationship: string,\n): MetaEntry<M> {\n  const entry = parentEntry[relationship];\n  assert(entry !== undefined, 'node does not exist');\n  assertMetaEntry(entry);\n  return entry;\n}\n\n/** Get singular MetaEntry or undefined if not set. */\nfunction getOptionalSingularEntry<M extends Mutate>(\n  parentEntry: MetaEntry<M>,\n  relationship: string,\n): MetaEntry<M> | undefined {\n  const entry = parentEntry[relationship];\n  if (entry === undefined) {\n    return undefined;\n  }\n  assertMetaEntry(entry);\n  return entry;\n}\n\n/** Get child array as MetaEntryList. */\nfunction getChildEntryList<M extends Mutate>(\n  parentEntry: MetaEntry<M>,\n  relationship: string,\n): MetaEntryList<M> {\n  const view = parentEntry[relationship];\n  assertArray(view);\n  return view as MetaEntryList<M>;\n}\n\n/** Create MetaEntry from row with given refCount. */\nfunction makeNewMetaEntry(\n  row: Row,\n  schema: SourceSchema,\n  withIDs: WithIDs,\n  rc: number,\n): MutableMetaEntry {\n  // This creates a new MetaEntry from a Row. We never mutate Rows.\n  if (withIDs) {\n    return track({\n      ...row,\n      [refCountSymbol]: rc,\n      [idSymbol]: makeID(row, schema),\n    });\n  }\n  return track({...row, [refCountSymbol]: rc});\n}\n\nfunction makeID(row: Row, schema: SourceSchema) {\n  // optimization for case of non-compound primary key\n  if (schema.primaryKey.length === 1) {\n    return JSON.stringify(row[schema.primaryKey[0]]);\n  }\n  return JSON.stringify(schema.primaryKey.map(k => row[k]));\n}\n\nfunction incRefCount<M extends Mutate>(\n  mutate: M,\n  entry: MetaEntry<M>,\n): MutableMetaEntry {\n  return setRefCount(mutate, entry, entry[refCountSymbol] + 1);\n}\n\nfunction decRefCount<M extends Mutate>(\n  mutate: M,\n  entry: MetaEntry<M>,\n): MutableMetaEntry {\n  return setRefCount(mutate, entry, entry[refCountSymbol] - 1);\n}\n\nfunction setRefCount<M extends Mutate>(\n  mutate: M,\n  entry: MetaEntry<M>,\n  count: number,\n): MutableMetaEntry {\n  if (mutate || owns(entry)) {\n    (entry as MutableMetaEntry)[refCountSymbol] = count;\n    return entry;\n  }\n  return track({...entry, [refCountSymbol]: count});\n}\n\nfunction arrayWith<M extends Mutate, T>(\n  mutate: M,\n  array: MutableArray<M, T>,\n  index: number,\n  value: T,\n): T[] {\n  if (mutate || owns(array)) {\n    (array as T[])[index] = value;\n    return array as T[];\n  }\n  return track(array.with(index, value));\n}\n\nfunction setProperty<\n  M extends Mutate,\n  K extends string | keyof MetaEntry<M>,\n  V,\n>(\n  mutate: M,\n  parentEntry: MetaEntry<M>,\n  key: K,\n  value: V,\n): MutableMetaEntry & {[P in K]: V} {\n  if (mutate || owns(parentEntry)) {\n    (parentEntry as {[P in K]: V})[key] = value;\n    return parentEntry as MutableMetaEntry & {[P in K]: V};\n  }\n  return track({...parentEntry, [key]: value});\n}\n\nconst setRelation: <M extends Mutate>(\n  mutate: M,\n  parentEntry: MetaEntry<M>,\n  relationship: string,\n  value: Entry | Entry[] | undefined,\n) => MutableMetaEntry = setProperty;\n"],"mappings":"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"}