doxum 0.1.20 → 0.1.22

package/dist/{access-EQ-XiFyl.cjs → access-D64MFRSm.cjs}

@@ -1,4 +1,4 @@
-const require_issue = require("./issue-DhrNdQNg.cjs");
+const require_issue = require("./issue-Bo0FIO3b.cjs");
 //#region core/src/schema-value.ts
 var ParseError = class extends TypeError {
 	issues;
@@ -103,14 +103,29 @@ const checkValue = (node, value, address = [], strict = false) => {
 		return;
 	}
 	if (!require_issue.validate(value)) return issue(address, "Invalid tree structure.", "invalid-tree");
-	if (require_issue.isRecord(value) && require_issue.isRecord(value.nodes)) for (const id of Object.keys(value.nodes)) {
-		const entry = value.nodes[id];
-		if (require_issue.isRecord(entry) && Object.prototype.hasOwnProperty.call(entry, "value")) {
-			const failure = checkValue(node.value, entry.value, [...address, id], strict);
-			if (failure) return failure;
-		}
+	for (const id of Object.keys(value.nodes)) {
+		const failure = checkTreePayload(node.value, value.nodes[id], [...address, id], strict);
+		if (failure) return failure;
 	}
 };
+const checkTreePayload = (node, value, address, strict = false) => {
+	if (!require_issue.isRecord(value)) return issue(address, "Invalid tree node.", "invalid-tree");
+	const present = Object.prototype.hasOwnProperty.call(value, "value");
+	if (!present && !node.optional) return issue(address, "Tree node value is required.");
+	return present ? checkValue(node, value.value, address, strict) : void 0;
+};
+const copyTreeNode = (value) => {
+	require_issue.profile.copy.treeNode();
+	return {
+		...value,
+		children: [...value.children]
+	};
+};
+const equalTreeNode = (left, right) => {
+	if (left === right) return true;
+	if (!left || !right) return false;
+	return left.parentId === right.parentId && require_issue.equal(left.children, right.children) && Object.hasOwn(left, "value") === Object.hasOwn(right, "value") && Object.is(left.value, right.value);
+};
 /** Copy editable structure; atomic payloads retain their immutable ownership contract. */
 const copyValue = (node, value) => {
 	if (value === void 0 || node.kind === "field") return value;
@@ -139,10 +154,7 @@ const copyValue = (node, value) => {
 		const entries = value.nodes;
 		return {
 			...value,
-			nodes: Object.fromEntries(Object.entries(entries).map(([id, n]) => [id, {
-				...n,
-				children: [...n.children]
-			}]))
+			nodes: Object.fromEntries(Object.entries(entries).map(([id, n]) => [id, copyTreeNode(n)]))
 		};
 	}
 	return value;
@@ -166,7 +178,7 @@ const equalValue = (node, left, right) => {
 	if (node.kind === "tree" && require_issue.isRecord(left) && require_issue.isRecord(right)) {
 		if (left.rootId !== right.rootId) return false;
 		const a = left.nodes, b = right.nodes;
-		return Object.keys(a).length === Object.keys(b).length && Object.keys(a).every((id) => Object.hasOwn(b, id) && a[id].parentId === b[id].parentId && require_issue.equal(a[id].children, b[id].children) && Object.hasOwn(a[id], "value") === Object.hasOwn(b[id], "value") && equalValue(node.value, a[id].value, b[id].value));
+		return Object.keys(a).length === Object.keys(b).length && Object.keys(a).every((id) => Object.hasOwn(b, id) && equalTreeNode(a[id], b[id]));
 	}
 	if (node.kind === "map" && require_issue.isRecord(left) && require_issue.isRecord(right)) {
 		const keys = Object.keys(left);
@@ -235,12 +247,12 @@ function insert$1(session, container, value, position) {
 	session.validate(node.value, value, at);
 	const id = node.keyOf(value);
 	if (typeof id !== "string") return require_issue.fail(at, "invalid-list-key", "List key must be a string.");
-	const items = current, keys$2 = require_issue.keys(items, node.keyOf);
-	if (keys$2.index(id) >= 0) return require_issue.fail(at, "duplicate-list-item", "List key already exists.");
-	if (!require_issue.valid(keys$2, position)) return require_issue.fail(at, "invalid-anchor", "Unknown list anchor.");
+	const items = current, keys$1 = require_issue.keys(items, node.keyOf);
+	if (keys$1.index(id) >= 0) return require_issue.fail(at, "duplicate-list-item", "List key already exists.");
+	if (!require_issue.valid(keys$1, position)) return require_issue.fail(at, "invalid-anchor", "Unknown list anchor.");
 	session.recorder.order(container);
 	session.recorder.member(container, id, session.definition(container, id), -1);
-	require_issue.insert(items, require_issue.index(keys$2, position), value);
+	require_issue.insert(items, require_issue.index(keys$1, position), value);
 	session.invalidate();
 }
 function replace$2(session, container, id, value) {
@@ -338,21 +350,185 @@ const move$1 = (session, container, id, position) => {
 };
 //#endregion
 //#region core/src/mutation/operations/order.ts
-function move(session, container, id, position) {
-	const { at, node, value } = container;
+const assertOrdered = (container) => {
+	const { at, node } = container;
 	if (node.kind !== "table" && node.kind !== "list") return require_issue.fail(at, "invalid-collection", "Expected an ordered container.");
-	const items = node.kind === "table" ? value.ids : value;
-	const keys$1 = node.kind === "table" ? items : require_issue.keys(items, node.keyOf);
-	const index = node.kind === "table" ? items.indexOf(id) : keys$1.index(id);
-	if (index < 0) return require_issue.fail(at, "missing-entity", "Ordered key does not exist.");
-	if (!require_issue.valid(keys$1, position)) return require_issue.fail(at, "invalid-anchor", "Unknown order anchor.");
-	const next = require_issue.afterRemove(keys$1, index, position);
-	if (next === index) return;
-	session.recorder.order(container);
-	require_issue.move(items, index, next);
+	return node;
+};
+const plannedOrder = (at, current, selection, position) => {
+	const plan = require_issue.moveSelection(current, selection, position);
+	switch (plan.kind) {
+		case "ok": return plan.order;
+		case "duplicate": return require_issue.fail(at, "invalid-key", "Moved keys must be unique.");
+		case "missing": return require_issue.fail(at, "missing-entity", "Ordered key does not exist.");
+		case "invalid-anchor": return require_issue.fail(at, "invalid-anchor", "Unknown order anchor.");
+	}
+};
+function move(session, container, ids, position) {
+	const node = assertOrdered(container);
+	const selection = typeof ids === "string" ? [ids] : ids;
+	if (!selection.length) return;
+	if (node.kind === "table") {
+		const order = container.value.ids;
+		const next = plannedOrder(container.at, order, selection, position);
+		if (require_issue.equal(order, next)) return;
+		session.recorder.order(container);
+		require_issue.installKeys(order, next);
+	} else {
+		const items = container.value;
+		const sequence = require_issue.listSequence(items, node.keyOf);
+		const next = plannedOrder(container.at, sequence.order, selection, position);
+		if (require_issue.equal(sequence.order, next)) return;
+		session.recorder.order(container);
+		require_issue.installList(items, node.keyOf, sequence, next);
+	}
+	session.invalidate();
+}
+function reorder(session, container, next) {
+	const node = assertOrdered(container);
+	if (node.kind === "table") {
+		const current = container.value.ids;
+		if (!require_issue.matches(next, current)) return require_issue.fail(container.at, "invalid-collection", "Order must contain every key exactly once.");
+		if (require_issue.equal(current, next)) return;
+		session.recorder.order(container);
+		require_issue.installKeys(current, next);
+	} else {
+		const items = container.value;
+		const sequence = require_issue.listSequence(items, node.keyOf);
+		if (!require_issue.matches(next, sequence.order)) return require_issue.fail(container.at, "invalid-collection", "Order must contain every key exactly once.");
+		if (require_issue.equal(sequence.order, next)) return;
+		session.recorder.order(container);
+		require_issue.installList(items, node.keyOf, sequence, next);
+	}
 	session.invalidate();
 }
 //#endregion
+//#region core/src/impact-target.ts
+const treeRootSegment = "rootId";
+const treeNodesSegment = "nodes";
+const ordinaryNamespace = "\0value";
+const treeNamespace = "\0tree";
+const tree = (at, selection) => ({
+	kind: "value",
+	at,
+	tree: selection
+});
+const address = (target) => "at" in target ? target.at : target.address;
+const id = (target) => target.kind === "collection" && "id" in target ? target.id : void 0;
+const belongs = (target, schema) => !("schema" in target) || target.schema === schema;
+const treeTarget = (target) => "tree" in target ? target.tree : void 0;
+const sameTreeTarget = (left, right) => {
+	if (!left || !right) return left === right;
+	if (left.kind !== right.kind) return false;
+	return left.kind !== "node" || right.kind === "node" && left.id === right.id;
+};
+const same = (left, right) => {
+	if ("schema" in left && "schema" in right && left.schema !== right.schema) return false;
+	if (!sameTreeTarget(treeTarget(left), treeTarget(right))) return false;
+	if (left.kind !== right.kind) return false;
+	const leftAddress = address(left);
+	const rightAddress = address(right);
+	if (leftAddress.length !== rightAddress.length) return false;
+	for (let index = 0; index < leftAddress.length; index += 1) if (leftAddress[index] !== rightAddress[index]) return false;
+	return left.kind !== "collection" || id(left) === id(right);
+};
+const indexedAddress = (target) => {
+	const tree = treeTarget(target);
+	if (tree?.kind === "root") return [
+		treeNamespace,
+		...address(target),
+		treeRootSegment
+	];
+	if (tree?.kind === "nodes") return [
+		treeNamespace,
+		...address(target),
+		treeNodesSegment
+	];
+	if (tree?.kind === "node") return [
+		treeNamespace,
+		...address(target),
+		treeNodesSegment,
+		tree.id
+	];
+	const key = id(target);
+	return key === void 0 ? [ordinaryNamespace, ...address(target)] : [
+		ordinaryNamespace,
+		...address(target),
+		key
+	];
+};
+const visitChangedLocations = (changes, value, order) => {
+	for (const change of changes.changes) {
+		if (change.kind === "reset") continue;
+		if (change.kind === "members") {
+			for (const member of change.members) {
+				value([
+					ordinaryNamespace,
+					...change.at,
+					member.key
+				]);
+				value([
+					treeNamespace,
+					...change.at,
+					member.key
+				]);
+			}
+			if (change.order) order([ordinaryNamespace, ...change.at]);
+			continue;
+		}
+		value([ordinaryNamespace, ...change.at]);
+		if (change.before !== change.after) value([
+			treeNamespace,
+			...change.at,
+			treeRootSegment
+		]);
+		for (const node of change.nodes) value([
+			treeNamespace,
+			...change.at,
+			treeNodesSegment,
+			node.id
+		]);
+	}
+};
+const affected = (target, values, orders) => {
+	const at = indexedAddress(target);
+	return id(target) !== void 0 ? values.hasAncestor(at) : values.overlaps(at) || orders.hasDescendant(at);
+};
+/** Targets are classified once; commit matching never builds a reverse impact index. */
+var SubscriptionIndex = class {
+	ordinary = new require_issue.AddressIndex();
+	membership = new require_issue.AddressIndex();
+	constructor(schema) {
+		this.schema = schema;
+	}
+	add(target, value) {
+		if (!belongs(target, this.schema)) return;
+		(id(target) === void 0 ? this.ordinary : this.membership).add(indexedAddress(target), value);
+	}
+	delete(target, value) {
+		if (!belongs(target, this.schema)) return;
+		(id(target) === void 0 ? this.ordinary : this.membership).delete(indexedAddress(target), value);
+	}
+	collect(changes, visit) {
+		const values = this.ordinary.query(visit);
+		const members = this.membership.query(visit, "descendants");
+		const orders = this.ordinary.query(visit, "ancestors");
+		if (changes.changes.some((change) => change.kind === "reset")) {
+			values([]);
+			members([]);
+			return;
+		}
+		visitChangedLocations(changes, (at) => {
+			values(at);
+			members(at);
+		}, orders);
+	}
+	clear() {
+		this.ordinary.clear();
+		this.membership.clear();
+	}
+};
+//#endregion
 //#region core/src/access/scope.ts
 const locations = /* @__PURE__ */ new WeakMap();
 const locationOf = (value) => locations.get(value);
@@ -374,6 +550,7 @@ const collect = (context, at, kind = "value", id) => {
 		...id === void 0 ? {} : { id }
 	});
 };
+const collectTree = (context, at, selection) => context.dependencies?.record(tree(at, selection));
 const snapshot = (value) => {
 	const location = value && typeof value === "object" ? locationOf(value) : void 0;
 	if (!location) return value;
@@ -546,9 +723,13 @@ const createAccess = (context, initial = []) => {
 			if (!location || !Object.hasOwn(location.parent, location.key)) return void 0;
 			return childAccess(target, id, location.node, location.parent[location.key]);
 		};
-		if (property === "move") return (id, position) => {
+		if (property === "move") return (ids, position) => {
+			const writable = writableCollection(target, node);
+			move(context.session, writable, ids, position);
+		};
+		if (property === "reorder") return (ids) => {
 			const writable = writableCollection(target, node);
-			move(context.session, writable, id, position);
+			reorder(context.session, writable, ids);
 		};
 	};
 	const tableMethod = (target, property, node) => {
@@ -608,18 +789,38 @@ const createAccess = (context, initial = []) => {
 			const writable = writableTree(target, node);
 			replace$1(context.session, writable, valueOrId, value);
 		};
-		const current = () => {
-			collect(context, at);
-			return collectionValue(target, node);
+		const current = () => collectionValue(target, node);
+		if (property === "rootId") return () => {
+			collectTree(context, at, { kind: "root" });
+			return current().rootId;
 		};
-		if (property === "rootId") return () => current().rootId;
 		if (property === "get") return (id) => {
+			collectTree(context, at, {
+				kind: "node",
+				id
+			});
 			const value = current();
 			return require_issue.contains$1(value, id) ? value.nodes[id].value : void 0;
 		};
-		if (property === "has") return (id) => require_issue.contains$1(current(), id);
-		if (property === "parent") return (id) => require_issue.parent(current(), id);
+		if (property === "has") return (id) => {
+			collectTree(context, at, {
+				kind: "node",
+				id
+			});
+			return require_issue.contains$1(current(), id);
+		};
+		if (property === "parent") return (id) => {
+			collectTree(context, at, {
+				kind: "node",
+				id
+			});
+			return require_issue.parent(current(), id);
+		};
 		if (property === "children") return (id) => {
+			collectTree(context, at, {
+				kind: "node",
+				id
+			});
 			const children$1 = require_issue.children(current(), id);
 			return children$1 ? [...children$1] : void 0;
 		};
@@ -699,23 +900,6 @@ const createAccess = (context, initial = []) => {
 	}
 	return access(root);
 };
-const collectionAccess = (context, at) => {
-	const value = createAccess(context, at);
-	if (value === void 0) return {
-		get: () => {
-			assertActive(context);
-		},
-		has: () => {
-			assertActive(context);
-			return false;
-		},
-		ids: () => {
-			assertActive(context);
-			return [];
-		}
-	};
-	return value;
-};
 //#endregion
 //#region core/src/runtime/contract.ts
 var DocumentReentrancyError = class extends Error {
@@ -787,6 +971,12 @@ Object.defineProperty(exports, "ParseError", {
 		return ParseError;
 	}
 });
+Object.defineProperty(exports, "SubscriptionIndex", {
+	enumerable: true,
+	get: function() {
+		return SubscriptionIndex;
+	}
+});
 Object.defineProperty(exports, "TransactionRejected", {
 	enumerable: true,
 	get: function() {
@@ -799,6 +989,18 @@ Object.defineProperty(exports, "accessOf", {
 		return accessOf;
 	}
 });
+Object.defineProperty(exports, "affected", {
+	enumerable: true,
+	get: function() {
+		return affected;
+	}
+});
+Object.defineProperty(exports, "belongs", {
+	enumerable: true,
+	get: function() {
+		return belongs;
+	}
+});
 Object.defineProperty(exports, "bindRuntimeAccess", {
 	enumerable: true,
 	get: function() {
@@ -811,16 +1013,22 @@ Object.defineProperty(exports, "checkKey", {
 		return checkKey;
 	}
 });
+Object.defineProperty(exports, "checkTreePayload", {
+	enumerable: true,
+	get: function() {
+		return checkTreePayload;
+	}
+});
 Object.defineProperty(exports, "checkValue", {
 	enumerable: true,
 	get: function() {
 		return checkValue;
 	}
 });
-Object.defineProperty(exports, "collectionAccess", {
+Object.defineProperty(exports, "copyTreeNode", {
 	enumerable: true,
 	get: function() {
-		return collectionAccess;
+		return copyTreeNode;
 	}
 });
 Object.defineProperty(exports, "copyValue", {
@@ -835,12 +1043,24 @@ Object.defineProperty(exports, "createAccess", {
 		return createAccess;
 	}
 });
+Object.defineProperty(exports, "equalTreeNode", {
+	enumerable: true,
+	get: function() {
+		return equalTreeNode;
+	}
+});
 Object.defineProperty(exports, "equalValue", {
 	enumerable: true,
 	get: function() {
 		return equalValue;
 	}
 });
+Object.defineProperty(exports, "indexedAddress", {
+	enumerable: true,
+	get: function() {
+		return indexedAddress;
+	}
+});
 Object.defineProperty(exports, "parse", {
 	enumerable: true,
 	get: function() {
@@ -859,11 +1079,23 @@ Object.defineProperty(exports, "replace", {
 		return replace;
 	}
 });
+Object.defineProperty(exports, "same", {
+	enumerable: true,
+	get: function() {
+		return same;
+	}
+});
 Object.defineProperty(exports, "snapshot", {
 	enumerable: true,
 	get: function() {
 		return snapshot;
 	}
 });
+Object.defineProperty(exports, "visitChangedLocations", {
+	enumerable: true,
+	get: function() {
+		return visitChangedLocations;
+	}
+});
 
-//# sourceMappingURL=access-EQ-XiFyl.cjs.map
+//# sourceMappingURL=access-D64MFRSm.cjs.map