doxum 0.1.12 → 0.1.13

package/dist/definition-177L4Amk.cjs

@@ -0,0 +1,898 @@
+const require_issue = require("./issue-DhrNdQNg.cjs");
+//#region core/src/schema-value.ts
+var ParseError = class extends TypeError {
+	issues;
+	constructor(issue) {
+		super(`${issue.message} at ${JSON.stringify(issue.address)}`);
+		this.name = "ParseError";
+		this.issues = Object.freeze([Object.freeze({
+			...issue,
+			address: Object.freeze([...issue.address])
+		})]);
+	}
+};
+const issue = (address, message, code = "invalid-value") => ({
+	address,
+	message,
+	code
+});
+const checkScalar = (validator, value, address, strict) => {
+	if (!validator) return strict ? issue(address, "A validator is required to parse an opaque value.", "missing-validator") : void 0;
+	try {
+		const result = typeof validator === "function" ? validator(value) : validator["~standard"].validate(value);
+		if (result && (typeof result === "object" || typeof result === "function") && "then" in result && typeof result.then === "function") return issue(address, "Validators must be synchronous.");
+		if (typeof validator !== "function") {
+			if (!require_issue.isRecord(result)) return issue(address, "Malformed validator result.");
+			if (Array.isArray(result.issues)) {
+				const first = result.issues[0];
+				return issue([...address, ...(first?.path ?? []).map((part) => String(typeof part === "object" ? part.key : part))], first?.message ?? "Value validation failed.");
+			}
+			if (!Object.hasOwn(result, "value")) return issue(address, "Malformed validator result.");
+		}
+		return;
+	} catch (error) {
+		return issue(address, error instanceof Error ? error.message : "Value validation failed.");
+	}
+};
+const checkKey = (validator, value, address) => {
+	if (typeof value !== "string") return issue(address, "Collection keys must be strings.", "invalid-key");
+	const failure = checkScalar(validator, value, address, false);
+	return failure ? {
+		...failure,
+		code: "invalid-key"
+	} : void 0;
+};
+const checkValue = (node, value, address = [], strict = false) => {
+	if (node.optional && value === void 0) return void 0;
+	if (node.kind === "field") return checkScalar(node.validator, value, address, strict);
+	if (node.kind === "object" || node.kind === "variant") {
+		if (!require_issue.isPlainObject(value)) return issue(address, "Expected an object.");
+		if (node.kind === "variant") {
+			const tag = value[node.tag];
+			if (!Object.hasOwn(value, node.tag) || typeof tag !== "string" || !Object.hasOwn(node.variants, tag)) return issue([...address, node.tag], "Unknown variant tag.");
+		}
+		const { members } = require_issue.compiledShape(node, value);
+		for (const key of Reflect.ownKeys(value)) {
+			if (node.kind === "variant" && key === node.tag) continue;
+			if (typeof key !== "string" || !members.has(key)) return issue([...address, String(key)], "Property is not declared in the object schema.");
+		}
+		for (const [key, member] of members) {
+			const child = member.node;
+			if (!Object.prototype.hasOwnProperty.call(value, key) && !child.optional) return issue([...address, key], "Required property is missing.");
+			const failure = checkValue(child, value[key], [...address, key], strict);
+			if (failure) return failure;
+		}
+		return;
+	}
+	if (node.kind === "table" || node.kind === "map") {
+		if (!require_issue.isPlainObject(value)) return issue(address, "Expected a collection object.");
+		const entries = node.kind === "table" ? value.byId : value;
+		if (!require_issue.isPlainObject(entries)) return issue(address, "Expected a byId object.");
+		if (node.kind === "table") {
+			if (!Array.isArray(value.ids) || value.ids.length !== Object.keys(entries).length) return issue(address, "Table ids and entries must agree.");
+			const seen = /* @__PURE__ */ new Set();
+			for (const id of value.ids) {
+				const failure = checkKey(node.key, id, address);
+				if (failure) return failure;
+				if (seen.has(id) || !Object.prototype.hasOwnProperty.call(entries, id)) return issue(address, "Table ids must be unique and reference existing entries.");
+				seen.add(id);
+			}
+		}
+		for (const id of Object.keys(entries)) {
+			const failure = checkKey(node.key, id, [...address, id]) ?? checkValue(node.value, entries[id], [...address, id], strict);
+			if (failure) return failure;
+		}
+		return;
+	}
+	if (node.kind === "list") {
+		if (!Array.isArray(value)) return issue(address, "Expected a list.");
+		const seen = /* @__PURE__ */ new Set();
+		const order = require_issue.keys(value, node.keyOf);
+		for (let i = 0; i < value.length; i++) {
+			const failure = checkValue(node.value, value[i], [...address, String(i)], strict);
+			if (failure) return failure;
+			let key;
+			try {
+				key = order.at(i);
+			} catch {
+				return issue(address, "List keyOf failed.");
+			}
+			if (typeof key !== "string" || seen.has(key)) return issue(address, "List keys must be unique strings.", "invalid-key");
+			seen.add(key);
+		}
+		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;
+		}
+	}
+};
+/** Copy editable structure; atomic payloads retain their immutable ownership contract. */
+const copyValue = (node, value) => {
+	if (value === void 0 || node.kind === "field") return value;
+	require_issue.profile.copy.structure();
+	if ((node.kind === "object" || node.kind === "variant") && require_issue.isRecord(value)) {
+		const result = Object.create(Object.getPrototypeOf(value));
+		const { members } = require_issue.compiledShape(node, value);
+		for (const key of Object.getOwnPropertyNames(value)) Object.defineProperty(result, key, {
+			value: node.kind === "variant" && key === node.tag ? value[key] : copyValue(members.get(key).node, value[key]),
+			writable: true,
+			enumerable: Object.getOwnPropertyDescriptor(value, key)?.enumerable,
+			configurable: true
+		});
+		return result;
+	}
+	if ((node.kind === "table" || node.kind === "map") && require_issue.isRecord(value)) {
+		const entries = node.kind === "table" ? value.byId : value;
+		const result = Object.fromEntries(Object.keys(entries).map((id) => [id, copyValue(node.value, entries[id])]));
+		return node.kind === "table" ? {
+			ids: [...value.ids],
+			byId: result
+		} : result;
+	}
+	if (node.kind === "list") return [...value];
+	if (node.kind === "tree" && require_issue.isRecord(value)) {
+		const entries = value.nodes;
+		return {
+			...value,
+			nodes: Object.fromEntries(Object.entries(entries).map(([id, n]) => [id, {
+				...n,
+				children: [...n.children]
+			}]))
+		};
+	}
+	return value;
+};
+const equalValue = (node, left, right) => {
+	if (Object.is(left, right)) return true;
+	if (node.kind === "field" || left === void 0 || right === void 0) return false;
+	if ((node.kind === "object" || node.kind === "variant") && require_issue.isRecord(left) && require_issue.isRecord(right)) {
+		if (node.kind === "variant" && left[node.tag] !== right[node.tag]) return false;
+		for (const [key, member] of require_issue.compiledShape(node, left).members) {
+			if (Object.hasOwn(left, key) !== Object.hasOwn(right, key)) return false;
+			if (!equalValue(member.node, left[key], right[key])) return false;
+		}
+		return true;
+	}
+	if (node.kind === "list" && Array.isArray(left) && Array.isArray(right)) return left.length === right.length && left.every((v, i) => equalValue(node.value, v, right[i]));
+	if (node.kind === "table" && require_issue.isRecord(left) && require_issue.isRecord(right)) return require_issue.equal(left.ids, right.ids) && equalValue({
+		kind: "map",
+		value: node.value
+	}, left.byId, right.byId);
+	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));
+	}
+	if (node.kind === "map" && require_issue.isRecord(left) && require_issue.isRecord(right)) {
+		const keys = Object.keys(left);
+		return keys.length === Object.keys(right).length && keys.every((key) => Object.hasOwn(right, key) && equalValue(node.value, left[key], right[key]));
+	}
+	return false;
+};
+const parse = (node, input) => {
+	const valueNode = node;
+	const failure = checkValue(valueNode, input, [], true);
+	if (failure) throw new ParseError(failure);
+	return copyValue(valueNode, input);
+};
+//#endregion
+//#region core/src/mutation/operations/map.ts
+function put(session, container, id, value) {
+	if (container.node.kind !== "map") return require_issue.fail(container.at, "invalid-collection", "Expected a map.");
+	session.writeMember(container, id, value, "set");
+}
+function remove$3(session, container, id) {
+	if (container.node.kind !== "map") return require_issue.fail(container.at, "invalid-collection", "Expected a map.");
+	session.writeMember(container, id, void 0, "remove");
+}
+//#endregion
+//#region core/src/mutation/operations/table.ts
+function create(session, container, entries, position) {
+	const { at, node, value } = container;
+	if (node.kind !== "table") return require_issue.fail(at, "invalid-collection", "Expected a table.");
+	const table = value;
+	if (!require_issue.valid(table.ids, position)) return require_issue.fail(at, "invalid-anchor", "Unknown table anchor.");
+	const ids = /* @__PURE__ */ new Set();
+	for (const entry of entries) {
+		if (Object.hasOwn(table.byId, entry.id) || ids.has(entry.id)) return require_issue.fail(at, "duplicate-entity", "Table key already exists.");
+		ids.add(entry.id);
+	}
+	if (!entries.length) return;
+	const index$1 = require_issue.index(table.ids, position);
+	for (const entry of entries) session.writeMember(container, entry.id, entry.value, "set");
+	const length = table.ids.length;
+	table.ids.length += entries.length;
+	table.ids.copyWithin(index$1 + entries.length, index$1, length);
+	for (let i = 0; i < entries.length; i++) table.ids[index$1 + i] = entries[i].id;
+}
+function remove$2(session, container, ids) {
+	const { at, node, value } = container;
+	if (node.kind !== "table") return require_issue.fail(at, "invalid-collection", "Expected a table.");
+	const table = value;
+	for (const id of ids) if (!Object.hasOwn(table.byId, id)) return require_issue.fail(at, "missing-entity", "Table key does not exist.");
+	if (!ids.length) return;
+	const removed = new Set(ids);
+	for (const id of removed) session.writeMember(container, id, void 0, "remove");
+	table.ids = table.ids.filter((id) => !removed.has(id));
+}
+function replace$3(session, container, id, value) {
+	const { at, node, value: tableValue } = container;
+	if (node.kind !== "table") return require_issue.fail(at, "invalid-collection", "Expected a table.");
+	const table = tableValue;
+	if (!Object.hasOwn(table.byId, id)) return require_issue.fail(at.concat(id), "missing-entity", "Table key does not exist.");
+	session.writeMember(container, id, value, "set");
+}
+//#endregion
+//#region core/src/mutation/operations/list.ts
+function insert$1(session, container, value, position) {
+	const { at, node, value: current } = container;
+	if (node.kind !== "list") return require_issue.fail(at, "invalid-list-key", "Expected a list.");
+	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.");
+	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);
+	session.invalidate();
+}
+function replace$2(session, container, id, value) {
+	const { at, node, value: items } = container;
+	if (node.kind !== "list") return require_issue.fail(at, "invalid-list-key", "Expected a list.");
+	const index = require_issue.indexedKeys(items, node.keyOf).index(id);
+	if (index < 0) return require_issue.fail(at, "missing-list-item", "List key does not exist.");
+	session.writeMember(container, id, value, "set", index);
+}
+function remove$1(session, container, id) {
+	const { at, node, value } = container;
+	if (node.kind !== "list") return require_issue.fail(at, "missing-list-item", "List key does not exist.");
+	const index = require_issue.keys(value, node.keyOf).index(id);
+	if (index < 0) return require_issue.fail(at, "missing-list-item", "List key does not exist.");
+	session.writeMember(container, id, void 0, "remove", index);
+}
+//#endregion
+//#region core/src/mutation/operations/tree.ts
+const node = (tree, id) => Object.hasOwn(tree.nodes, id) ? tree.nodes[id] : void 0;
+const positionIndex = (index, length, at) => {
+	if (index !== void 0 && (!Number.isInteger(index) || index < 0)) return require_issue.fail(at, "invalid-tree-index", "Tree index must be nonnegative.");
+	return Math.min(index ?? length, length);
+};
+const insert = (session, container, id, value, position) => {
+	const { at, node: schema, value: tree } = container;
+	if (typeof id !== "string") return require_issue.fail(at, "invalid-key", "Tree keys must be strings.");
+	if (require_issue.contains$1(tree, id)) return require_issue.fail(at, "duplicate-tree-node", "Tree node already exists.");
+	const parentId = position?.parentId;
+	const parent = parentId === void 0 ? void 0 : node(tree, parentId);
+	if (tree.rootId !== void 0 && !parent || tree.rootId === void 0 && parentId !== void 0) return require_issue.fail(at, "missing-tree-parent", "A nonempty tree requires an existing parent.");
+	const index = positionIndex(position?.index, parent?.children.length ?? 0, at);
+	session.validate(schema.value, value, at.concat(id));
+	session.recorder.tree(container, id);
+	if (parentId !== void 0) session.recorder.tree(container, parentId);
+	Object.defineProperty(tree.nodes, id, {
+		value: {
+			...parentId === void 0 ? {} : { parentId },
+			children: [],
+			value
+		},
+		writable: true,
+		configurable: true,
+		enumerable: true
+	});
+	if (parent) parent.children.splice(index, 0, id);
+	else tree.rootId = id;
+	session.invalidate();
+};
+const replace$1 = (session, container, id, value) => {
+	const { at, node: schema, value: tree } = container;
+	const entry = node(tree, id);
+	if (!entry) return require_issue.fail(at, "missing-tree-node", "Tree node does not exist.");
+	if (Object.is(entry.value, value) && Object.hasOwn(entry, "value")) return;
+	session.validate(schema.value, value, at.concat(id));
+	session.recorder.tree(container, id);
+	entry.value = value;
+};
+const remove = (session, container, id) => {
+	const { at, value: tree } = container;
+	const entry = node(tree, id);
+	if (!entry) return require_issue.fail(at, "missing-tree-node", "Tree node does not exist.");
+	const ids = [], stack = [id];
+	while (stack.length) {
+		const current = stack.pop();
+		ids.push(current);
+		for (const child of tree.nodes[current].children) stack.push(child);
+	}
+	for (const key of ids) session.recorder.tree(container, key);
+	if (entry.parentId !== void 0) session.recorder.tree(container, entry.parentId);
+	if (entry.parentId === void 0) delete tree.rootId;
+	else {
+		const children = tree.nodes[entry.parentId].children;
+		children.splice(children.indexOf(id), 1);
+	}
+	for (const key of ids) delete tree.nodes[key];
+	session.invalidate();
+};
+const move$1 = (session, container, id, position) => {
+	const { at, value: tree } = container;
+	const entry = node(tree, id), parentId = position?.parentId;
+	if (!entry) return require_issue.fail(at, "missing-tree-node", "Tree node does not exist.");
+	if (entry.parentId === void 0 || parentId === void 0 || !require_issue.contains$1(tree, parentId)) return require_issue.fail(at, "missing-tree-parent", "Moving requires a non-root node and an existing parent.");
+	for (let ancestor = parentId; ancestor !== void 0; ancestor = tree.nodes[ancestor].parentId) if (ancestor === id) return require_issue.fail(at, "tree-cycle", "Cannot move a node under its descendant.");
+	const old = tree.nodes[entry.parentId], next = tree.nodes[parentId];
+	const index = positionIndex(position?.index, next.children.length - (old === next ? 1 : 0), at);
+	const previous = old.children.indexOf(id);
+	if (old === next && previous === index) return;
+	session.recorder.tree(container, id);
+	session.recorder.tree(container, entry.parentId);
+	session.recorder.tree(container, parentId);
+	old.children.splice(previous, 1);
+	next.children.splice(index, 0, id);
+	entry.parentId = parentId;
+	session.invalidate();
+};
+//#endregion
+//#region core/src/mutation/operations/order.ts
+function move(session, container, id, position) {
+	const { at, node, value } = 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);
+	session.invalidate();
+}
+//#endregion
+//#region core/src/access/scope.ts
+const locations = /* @__PURE__ */ new WeakMap();
+const locationOf = (value) => locations.get(value);
+const addressOf = (target) => {
+	if (target.at) return target.at;
+	require_issue.profile.access("addresses");
+	return target.at = addressOf(target.parent).concat(target.key);
+};
+const assertActive = (context) => {
+	if (context.active && !context.active()) throw new Error("Document access scope has expired.");
+};
+const collect = (context, at, kind = "value", id) => {
+	context.dependencies?.record(kind === "value" ? {
+		kind,
+		at
+	} : {
+		kind,
+		at,
+		...id === void 0 ? {} : { id }
+	});
+};
+const snapshot = (value) => {
+	const location = value && typeof value === "object" ? locationOf(value) : void 0;
+	if (!location) return value;
+	const { context } = location;
+	const at = addressOf(location.target);
+	require_issue.profile.access("snapshots");
+	collect(context, at);
+	const resolved = resolve(context, location.target);
+	if (!resolved.node) throw new Error("The selected schema address no longer exists.");
+	return copyValue(resolved.node, resolved.value);
+};
+const replace = (container, key, value) => {
+	if (!locationOf(container)) throw new TypeError("replace requires scoped document access.");
+	if (typeof key !== "string") throw new TypeError("Document keys must be strings.");
+	Reflect.set(container, key, value);
+};
+const resolve = (context, target) => {
+	assertActive(context);
+	const generation = context.session?.generation ?? 0;
+	if (target.generation !== generation) {
+		require_issue.profile.access("resolutions");
+		if (!target.parent && !target.at.length) {
+			target.node = context.state.schema;
+			target.value = context.state.document;
+		} else {
+			const parent = target.parent && resolve(context, target.parent);
+			const location = parent ? require_issue.resolveChild(parent.node, parent.value, target.key) : require_issue.resolveLocated(context.state.schema, context.state.document, target.at);
+			target.node = location?.node ?? require_issue.nodeAt(context.state.schema, addressOf(target), context.state.document);
+			target.value = location && Object.hasOwn(location.parent, location.key) ? location.parent[location.key] : void 0;
+		}
+		target.generation = generation;
+	}
+	return target;
+};
+const createAccess = (context, initial = []) => {
+	require_issue.profile.access("scopes");
+	const mutable = () => {
+		assertActive(context);
+		if (!context.session) throw new TypeError("Cannot modify read-only document access.");
+		return context.session;
+	};
+	const writableContainer = (target, session) => {
+		if (target.container?.generation === session.generation && "layout" in target.container) return target.container;
+		return target.container = session.bind(addressOf(target), target.node, target.value);
+	};
+	const childAt = (target, key) => {
+		require_issue.profile.access("addresses");
+		return addressOf(target).concat(key);
+	};
+	const access = (target) => {
+		if (target.proxy) return target.proxy;
+		const proxy = new Proxy(target, handler);
+		require_issue.profile.access("proxies");
+		locations.set(proxy, {
+			context,
+			target
+		});
+		target.proxy = proxy;
+		return proxy;
+	};
+	const createTarget = (at, parent, key) => ({
+		at,
+		parent,
+		key,
+		node: void 0,
+		value: void 0,
+		generation: -1,
+		children: void 0,
+		proxy: void 0
+	});
+	const childAccess = (target, member, node, value) => {
+		const key = typeof member === "string" ? member : member.key;
+		if (node.kind === "field" || value === void 0) {
+			if (context.dependencies) collect(context, childAt(target, key));
+			return value;
+		}
+		let children = target.children;
+		let child;
+		if (typeof member !== "string") {
+			if (children?.kind !== "fixed" || children.schema !== target.node) children = {
+				kind: "fixed",
+				schema: target.node,
+				slots: new Array(require_issue.compiledShape(target.node, target.value).members.size)
+			};
+			child = children.slots[member.slot] ??= createTarget(void 0, target, key);
+		} else {
+			if (children?.kind !== "dynamic") children = {
+				kind: "dynamic",
+				keys: /* @__PURE__ */ new Map()
+			};
+			const retained = children.keys.get(key);
+			child = retained ?? createTarget(void 0, target, key);
+			if (!retained) children.keys.set(key, child);
+		}
+		target.children = children;
+		if (child.generation === target.generation) return child.proxy;
+		child.node = node;
+		child.value = value;
+		child.generation = target.generation;
+		return access(child);
+	};
+	const collectionValue = (target, node) => {
+		const current = resolve(context, target);
+		if (current.node !== node || current.value === void 0) throw new TypeError("The collection method belongs to a replaced schema branch.");
+		return current.value;
+	};
+	const writableCollection = (target, node) => {
+		const session = mutable();
+		collectionValue(target, node);
+		return writableContainer(target, session);
+	};
+	const writableTree = (target, node) => {
+		const session = mutable();
+		collectionValue(target, node);
+		if (target.container?.generation === session.generation && !("layout" in target.container)) return target.container;
+		return target.container = session.bindTree(addressOf(target), target.node, target.value);
+	};
+	const replaceCollection = (target, node, value) => {
+		const session = mutable();
+		collectionValue(target, node);
+		session.replace(addressOf(target), value);
+	};
+	const mapMethod = (target, property, node) => {
+		if (property === "ids") return () => {
+			const current = collectionValue(target, node);
+			if (context.dependencies) collect(context, addressOf(target), "collection");
+			return Object.keys(current);
+		};
+		if (property === "has") return (id) => {
+			const current = collectionValue(target, node);
+			if (context.dependencies) collect(context, addressOf(target), "collection", id);
+			return Object.hasOwn(current, id);
+		};
+		if (property === "get") return (id) => {
+			const current = collectionValue(target, node);
+			if (context.dependencies) collect(context, addressOf(target), "collection", id);
+			if (!Object.hasOwn(current, id)) return void 0;
+			if (node.value.kind === "field") {
+				if (context.dependencies) collect(context, childAt(target, id));
+				return current[id];
+			}
+			return childAccess(target, id, node.value, current[id]);
+		};
+		if (property === "put") return (id, value) => {
+			const writable = writableCollection(target, node);
+			put(context.session, writable, id, value);
+		};
+		if (property === "remove") return (id) => {
+			const writable = writableCollection(target, node);
+			remove$3(context.session, writable, id);
+		};
+		if (property === "replace") return (value) => replaceCollection(target, node, value);
+	};
+	const orderedMethod = (target, property, node) => {
+		const at = addressOf(target);
+		if (property === "ids") return () => {
+			const current = collectionValue(target, node);
+			collect(context, at, "collection");
+			return node.kind === "table" ? [...current.ids] : current.map(node.keyOf);
+		};
+		if (property === "has") return (id) => {
+			const current = collectionValue(target, node);
+			collect(context, at, "collection", id);
+			return node.kind === "table" ? Object.hasOwn(current.byId, id) : require_issue.indexedKeys(current, node.keyOf).index(id) >= 0;
+		};
+		if (property === "get") return (id) => {
+			const current = collectionValue(target, node);
+			collect(context, at, "collection", id);
+			const location = require_issue.resolveChild(node, current, id);
+			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) => {
+			const writable = writableCollection(target, node);
+			move(context.session, writable, id, position);
+		};
+	};
+	const tableMethod = (target, property, node) => {
+		if (property === "create") return (input, valueOrPosition, position) => {
+			const writable = writableCollection(target, node);
+			create(context.session, writable, Array.isArray(input) ? input : [{
+				id: input,
+				value: valueOrPosition
+			}], Array.isArray(input) ? valueOrPosition : position);
+		};
+		if (property === "remove") return (ids) => {
+			const writable = writableCollection(target, node);
+			remove$2(context.session, writable, typeof ids === "string" ? [ids] : ids);
+		};
+		if (property === "replace") return (...args) => {
+			const [valueOrId, value] = args;
+			if (args.length === 1) return replaceCollection(target, node, valueOrId);
+			const writable = writableCollection(target, node);
+			replace$3(context.session, writable, valueOrId, value);
+		};
+		return orderedMethod(target, property, node);
+	};
+	const listMethod = (target, property, node) => {
+		if (property === "insert") return (value, position) => {
+			const writable = writableCollection(target, node);
+			insert$1(context.session, writable, value, position);
+		};
+		if (property === "remove") return (id) => {
+			const writable = writableCollection(target, node);
+			remove$1(context.session, writable, id);
+		};
+		if (property === "replace") return (...args) => {
+			const [valueOrId, value] = args;
+			if (args.length === 1) return replaceCollection(target, node, valueOrId);
+			const writable = writableCollection(target, node);
+			replace$2(context.session, writable, valueOrId, value);
+		};
+		return orderedMethod(target, property, node);
+	};
+	const treeMethod = (target, property, node) => {
+		const at = addressOf(target);
+		if (property === "insert") return (id, value, position) => {
+			const writable = writableTree(target, node);
+			insert(context.session, writable, id, value, position);
+		};
+		if (property === "remove") return (id) => {
+			const writable = writableTree(target, node);
+			remove(context.session, writable, id);
+		};
+		if (property === "move") return (id, position) => {
+			const writable = writableTree(target, node);
+			move$1(context.session, writable, id, position);
+		};
+		if (property === "replace") return (...args) => {
+			const [valueOrId, value] = args;
+			if (args.length === 1) return replaceCollection(target, node, valueOrId);
+			const writable = writableTree(target, node);
+			replace$1(context.session, writable, valueOrId, value);
+		};
+		const current = () => {
+			collect(context, at);
+			return collectionValue(target, node);
+		};
+		if (property === "rootId") return () => current().rootId;
+		if (property === "get") return (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 === "children") return (id) => {
+			const children$1 = require_issue.children(current(), id);
+			return children$1 ? [...children$1] : void 0;
+		};
+	};
+	const handler = {
+		get: (target, property) => {
+			const { node, value } = resolve(context, target);
+			if (!node || value === void 0) return void 0;
+			if (typeof property !== "string") return void 0;
+			if (node.kind === "map") return mapMethod(target, property, node);
+			if (node.kind === "table") return tableMethod(target, property, node);
+			if (node.kind === "list") return listMethod(target, property, node);
+			if (node.kind === "tree") return treeMethod(target, property, node);
+			if (node.kind === "variant" && property === node.tag) {
+				collect(context, childAt(target, property));
+				return value[property];
+			}
+			const member = require_issue.compiledShape(node, value)?.members.get(property);
+			if (!member) return void 0;
+			if (member.field) {
+				if (context.dependencies) collect(context, childAt(target, property));
+				return value[property];
+			}
+			return childAccess(target, node.kind === "object" ? member : property, member.node, value[property]);
+		},
+		set: (target, property, value) => {
+			const session = mutable(), { node } = resolve(context, target);
+			if (typeof property !== "string" || !node || node.kind !== "object" && node.kind !== "variant") throw new TypeError("Invalid structural assignment.");
+			if (node.kind === "variant" && node.tag === property) throw new TypeError("Variant discriminants are read-only.");
+			session.assignMember(writableContainer(target, session), property, value);
+			return true;
+		},
+		deleteProperty: (target, property) => {
+			const session = mutable(), { node } = resolve(context, target);
+			if (typeof property !== "string" || node?.kind === "map" || node?.kind === "variant" && node.tag === property) throw new TypeError("Invalid structural deletion.");
+			session.removeMember(writableContainer(target, session), property);
+			return true;
+		},
+		has: (target, property) => {
+			const { node, value } = resolve(context, target);
+			if (typeof property !== "string") return false;
+			if (node?.kind === "map") return false;
+			collect(context, addressOf(target));
+			return value !== void 0 && Object.hasOwn(value, property);
+		},
+		ownKeys: (target) => {
+			const { node, value } = resolve(context, target);
+			if (node?.kind === "map") return [];
+			if (context.dependencies) collect(context, addressOf(target));
+			return value && typeof value === "object" ? Object.keys(value) : [];
+		},
+		getOwnPropertyDescriptor: (target, property) => {
+			const { node, value } = resolve(context, target);
+			if (node?.kind === "map") return void 0;
+			return value && Object.hasOwn(value, property) ? {
+				enumerable: true,
+				configurable: true
+			} : void 0;
+		},
+		defineProperty: () => {
+			assertActive(context);
+			throw new TypeError("Use schema assignments.");
+		},
+		setPrototypeOf: () => {
+			assertActive(context);
+			throw new TypeError("Document prototypes are immutable.");
+		},
+		preventExtensions: () => {
+			assertActive(context);
+			throw new TypeError("Document access cannot be frozen.");
+		}
+	};
+	const root = resolve(context, createTarget(initial, void 0, ""));
+	if (!root.node || root.node.kind === "field" || root.value === void 0) {
+		if (context.dependencies) collect(context, initial);
+		return root.value;
+	}
+	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/projection/definition.ts
+const definitions = /* @__PURE__ */ new WeakMap();
+const define = (definition) => {
+	const handle = Object.freeze({});
+	definitions.set(handle, definition);
+	return handle;
+};
+const definitionOf = (projection) => {
+	const definition = definitions.get(projection);
+	if (!definition) throw new TypeError("Unknown projection definition.");
+	return definition;
+};
+const input = (initial, equality = Object.is) => define({
+	kind: "input",
+	initial,
+	isEqual: equality
+});
+function observe(document, selector) {
+	if ("current" in document && typeof document.current === "function") return defineReadable(document);
+	return define({
+		kind: "document",
+		document,
+		selector
+	});
+}
+function derive(dependencies, compute, equality = Object.is) {
+	if (!Array.isArray(dependencies) || dependencies.some((value) => !definitions.has(value))) throw new TypeError("derive dependencies must be projections.");
+	return define({
+		kind: "derive",
+		dependencies: Object.freeze([...dependencies]),
+		compute,
+		isEqual: equality
+	});
+}
+/** Internal adapters used by the integration boundary, not exported publicly. */
+const defineReadable = (readable, equality = Object.is) => define({
+	kind: "readable",
+	readable,
+	isEqual: equality
+});
+const defineExternalValue = (source) => define({
+	kind: "source-value",
+	source
+});
+const defineExternalCollection = (source) => define({
+	kind: "source-collection",
+	source
+});
+const defineIncrementalValue = (definition) => define({
+	kind: "incremental-value",
+	dependencies: definition.dependencies,
+	build: definition.build,
+	isEqual: definition.isEqual,
+	name: definition.name
+});
+const defineIncrementalCollection = (definition) => define({
+	kind: "incremental-collection",
+	dependencies: definition.dependencies,
+	build: definition.build,
+	isEqual: definition.isEqual,
+	name: definition.name
+});
+//#endregion
+Object.defineProperty(exports, "ParseError", {
+	enumerable: true,
+	get: function() {
+		return ParseError;
+	}
+});
+Object.defineProperty(exports, "checkKey", {
+	enumerable: true,
+	get: function() {
+		return checkKey;
+	}
+});
+Object.defineProperty(exports, "checkValue", {
+	enumerable: true,
+	get: function() {
+		return checkValue;
+	}
+});
+Object.defineProperty(exports, "collectionAccess", {
+	enumerable: true,
+	get: function() {
+		return collectionAccess;
+	}
+});
+Object.defineProperty(exports, "copyValue", {
+	enumerable: true,
+	get: function() {
+		return copyValue;
+	}
+});
+Object.defineProperty(exports, "createAccess", {
+	enumerable: true,
+	get: function() {
+		return createAccess;
+	}
+});
+Object.defineProperty(exports, "defineExternalCollection", {
+	enumerable: true,
+	get: function() {
+		return defineExternalCollection;
+	}
+});
+Object.defineProperty(exports, "defineExternalValue", {
+	enumerable: true,
+	get: function() {
+		return defineExternalValue;
+	}
+});
+Object.defineProperty(exports, "defineIncrementalCollection", {
+	enumerable: true,
+	get: function() {
+		return defineIncrementalCollection;
+	}
+});
+Object.defineProperty(exports, "defineIncrementalValue", {
+	enumerable: true,
+	get: function() {
+		return defineIncrementalValue;
+	}
+});
+Object.defineProperty(exports, "defineReadable", {
+	enumerable: true,
+	get: function() {
+		return defineReadable;
+	}
+});
+Object.defineProperty(exports, "definitionOf", {
+	enumerable: true,
+	get: function() {
+		return definitionOf;
+	}
+});
+Object.defineProperty(exports, "derive", {
+	enumerable: true,
+	get: function() {
+		return derive;
+	}
+});
+Object.defineProperty(exports, "equalValue", {
+	enumerable: true,
+	get: function() {
+		return equalValue;
+	}
+});
+Object.defineProperty(exports, "input", {
+	enumerable: true,
+	get: function() {
+		return input;
+	}
+});
+Object.defineProperty(exports, "observe", {
+	enumerable: true,
+	get: function() {
+		return observe;
+	}
+});
+Object.defineProperty(exports, "parse", {
+	enumerable: true,
+	get: function() {
+		return parse;
+	}
+});
+Object.defineProperty(exports, "replace", {
+	enumerable: true,
+	get: function() {
+		return replace;
+	}
+});
+Object.defineProperty(exports, "snapshot", {
+	enumerable: true,
+	get: function() {
+		return snapshot;
+	}
+});
+
+//# sourceMappingURL=definition-177L4Amk.cjs.map