doxum 0.1.20 → 0.1.22

package/README.md

@@ -100,9 +100,9 @@ capabilities while retaining selection, subscription and projection support.
 - `map(field(...))`, `map(object(...))`, `map(variant(...))` expose
   `get/has/ids/put/remove/replace`. `put` is an upsert; removing a missing key is a no-op.
 - `table(object(...))` retains `{ ids, byId }` data and exposes
-  `get/has/ids/create/remove/move/replace`.
+  `get/has/ids/create/remove/move/reorder/replace`.
 - `list(field(...), { keyOf })` retains a plain array and exposes
-  `get/has/ids/insert/remove/move/replace`.
+  `get/has/ids/insert/remove/move/reorder/replace`.
 - `tree(field(...))` retains `{ rootId?, nodes }` and exposes topology reads plus
   `insert/remove/move/replace`.
 - `variant(tag, branches)` has a readonly discriminant and whole-value branch replacement.
@@ -116,6 +116,20 @@ Doxum; it does not detect validator mutation or conversion. `parse(model, unknow
 validates and copies schema structure while sharing readonly payloads. Strict parsing
 requires validators for atomic fields; typed in-memory fields can omit them.
 
+A tree may be empty, but payload presence follows the payload field schema exactly.
+`tree(field<T>())` requires every existing node to own a `value` property;
+`tree(optional(field<T>()))` is the explicit sparse-payload form. This is independent
+from `optional(tree(...))`, which controls whether the whole tree member may be absent.
+Missing and present-`undefined` payloads remain distinct when the payload field is optional.
+
+Ordered table/list drafts accept either one key or a key selection in
+`move(key | readonly key[], anchor?)`. A selection is moved as one block while
+preserving its current canonical relative order; the anchor is resolved after the
+selection is removed. Use `reorder(keys)` when the caller already owns the complete
+final order: it requires an exact permutation of current membership and changes no
+member values. Whole-collection `replace(value)` remains a distinct replacement
+operation and is not an order primitive.
+
 Collection `replace` has two forms: `replace(id, value)` replaces one existing
 table/list/tree member without changing order or topology, while `replace(value)`
 replaces the entire map/table/list/tree. Use top-level `replace(parent, key, value)`
@@ -269,8 +283,21 @@ runtime.update(overrides, draft => {
 and eventful external sources. External sources declare `kind: 'value'` or
 `kind: 'collection'`; collection invalidation remains keyed internally. Schema
 `map`, `table`, and `list(field, { keyOf })` paths are all observed as keyed
-collection projections. A schema `list` uses its `keyOf` identity and publishes
-in document order; ordinary array-valued `field(...)` nodes remain scalar values.
+collection projections. Trees expose structural observation without a second
+projection protocol: `path.tree.rootId` is a scalar source,
+`path.tree.nodes` is a keyed collection source, and
+`path.tree.nodes.item(id)` is a single-node value source. A schema `list` uses its
+`keyOf` identity and publishes in document order; ordinary array-valued `field(...)`
+nodes remain scalar values.
+
+Document projection sources route committed groups directly to their observed
+targets, merge affected locations for the current projection batch, then combine the
+previously published snapshot with the canonical final value. A touched tree node
+replaces only that node structure and the necessary ancestor containers; unchanged
+tree-node snapshots keep their identity. Whole aggregate tree values still use the
+public `{ rootId?, nodes: Record }` shape, so changing a node may shallow-copy the
+`nodes` record, while native `tree.nodes` observation remains keyed and touches only
+changed nodes.
 
 For retained state, reverse indexes and keyed patches, use the isolated advanced
 entry point. Whole-value processors use `incremental(...)`; keyed collection

package/dist/{access-B9XDWjHy.js → access-CZXv_DIF.js}

@@ -1,4 +1,4 @@
-import { A as insert$2, C as validate, D as equal, E as afterRemove, I as valid, L as profile, M as keys, O as index, P as move$2, T as isRecord, a as compiledShape, b as contains, g as resolveLocated, k as indexedKeys, m as resolveChild, n as fail, u as nodeAt, w as isPlainObject, x as parent, y as children } from "./issue-DVaGQGeP.js";
+import { B as profile, C as validate, D as index, E as equal, F as matches, I as moveSelection, M as installList, N as keys, O as indexedKeys, P as listSequence, T as isRecord, a as compiledShape, b as contains, g as resolveLocated, i as AddressIndex, j as installKeys, k as insert$2, m as resolveChild, n as fail, u as nodeAt, w as isPlainObject, x as parent, y as children, z as valid } from "./issue-9U6YLYz3.js";
 //#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 (!validate(value)) return issue(address, "Invalid tree structure.", "invalid-tree");
-	if (isRecord(value) && isRecord(value.nodes)) for (const id of Object.keys(value.nodes)) {
-		const entry = value.nodes[id];
-		if (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 (!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) => {
+	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 && 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" && isRecord(left) && 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 && 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" && isRecord(left) && 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 fail(at, "invalid-list-key", "List key must be a string.");
-	const items = current, keys$2 = keys(items, node.keyOf);
-	if (keys$2.index(id) >= 0) return fail(at, "duplicate-list-item", "List key already exists.");
-	if (!valid(keys$2, position)) return fail(at, "invalid-anchor", "Unknown list anchor.");
+	const items = current, keys$1 = keys(items, node.keyOf);
+	if (keys$1.index(id) >= 0) return fail(at, "duplicate-list-item", "List key already exists.");
+	if (!valid(keys$1, position)) return fail(at, "invalid-anchor", "Unknown list anchor.");
 	session.recorder.order(container);
 	session.recorder.member(container, id, session.definition(container, id), -1);
-	insert$2(items, index(keys$2, position), value);
+	insert$2(items, 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 fail(at, "invalid-collection", "Expected an ordered container.");
-	const items = node.kind === "table" ? value.ids : value;
-	const keys$1 = node.kind === "table" ? items : keys(items, node.keyOf);
-	const index = node.kind === "table" ? items.indexOf(id) : keys$1.index(id);
-	if (index < 0) return fail(at, "missing-entity", "Ordered key does not exist.");
-	if (!valid(keys$1, position)) return fail(at, "invalid-anchor", "Unknown order anchor.");
-	const next = afterRemove(keys$1, index, position);
-	if (next === index) return;
-	session.recorder.order(container);
-	move$2(items, index, next);
+	return node;
+};
+const plannedOrder = (at, current, selection, position) => {
+	const plan = moveSelection(current, selection, position);
+	switch (plan.kind) {
+		case "ok": return plan.order;
+		case "duplicate": return fail(at, "invalid-key", "Moved keys must be unique.");
+		case "missing": return fail(at, "missing-entity", "Ordered key does not exist.");
+		case "invalid-anchor": return 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 (equal(order, next)) return;
+		session.recorder.order(container);
+		installKeys(order, next);
+	} else {
+		const items = container.value;
+		const sequence = listSequence(items, node.keyOf);
+		const next = plannedOrder(container.at, sequence.order, selection, position);
+		if (equal(sequence.order, next)) return;
+		session.recorder.order(container);
+		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 (!matches(next, current)) return fail(container.at, "invalid-collection", "Order must contain every key exactly once.");
+		if (equal(current, next)) return;
+		session.recorder.order(container);
+		installKeys(current, next);
+	} else {
+		const items = container.value;
+		const sequence = listSequence(items, node.keyOf);
+		if (!matches(next, sequence.order)) return fail(container.at, "invalid-collection", "Order must contain every key exactly once.");
+		if (equal(sequence.order, next)) return;
+		session.recorder.order(container);
+		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 AddressIndex();
+	membership = new 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, id, position);
+			move(context.session, writable, ids, position);
+		};
+		if (property === "reorder") return (ids) => {
+			const writable = writableCollection(target, node);
+			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 contains(value, id) ? value.nodes[id].value : void 0;
 		};
-		if (property === "has") return (id) => contains(current(), id);
-		if (property === "parent") return (id) => parent(current(), id);
+		if (property === "has") return (id) => {
+			collectTree(context, at, {
+				kind: "node",
+				id
+			});
+			return contains(current(), id);
+		};
+		if (property === "parent") return (id) => {
+			collectTree(context, at, {
+				kind: "node",
+				id
+			});
+			return parent(current(), id);
+		};
 		if (property === "children") return (id) => {
+			collectTree(context, at, {
+				kind: "node",
+				id
+			});
 			const children$1 = 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 {
@@ -769,6 +953,6 @@ const readWith = (runtime, run, dependencies) => {
 	}
 };
 //#endregion
-export { DocumentReentrancyError as a, createAccess as c, ParseError as d, checkKey as f, parse as g, equalValue as h, DocumentDisposedError as i, replace as l, copyValue as m, bindRuntimeAccess as n, TransactionRejected as o, checkValue as p, readWith as r, collectionAccess as s, accessOf as t, snapshot as u };
+export { equalValue as C, equalTreeNode as S, checkKey as _, DocumentReentrancyError as a, copyTreeNode as b, replace as c, affected as d, belongs as f, ParseError as g, visitChangedLocations as h, DocumentDisposedError as i, snapshot as l, same as m, bindRuntimeAccess as n, TransactionRejected as o, indexedAddress as p, readWith as r, createAccess as s, accessOf as t, SubscriptionIndex as u, checkTreePayload as v, parse as w, copyValue as x, checkValue as y };
 
-//# sourceMappingURL=access-B9XDWjHy.js.map
+//# sourceMappingURL=access-CZXv_DIF.js.map