doxum 0.1.21 → 0.1.23

package/dist/access-BeSV5ve-.js

@@ -1,816 +0,0 @@
-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, 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-W0hT8u8D.js";
-//#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 (!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 (!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 } = 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 (!isPlainObject(value)) return issue(address, "Expected a collection object.");
-		const entries = node.kind === "table" ? value.byId : value;
-		if (!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 = 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 (!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;
-		}
-	}
-};
-/** Copy editable structure; atomic payloads retain their immutable ownership contract. */
-const copyValue = (node, value) => {
-	if (value === void 0 || node.kind === "field") return value;
-	profile.copy.structure();
-	if ((node.kind === "object" || node.kind === "variant") && isRecord(value)) {
-		const result = Object.create(Object.getPrototypeOf(value));
-		const { members } = 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") && 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" && 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") && isRecord(left) && isRecord(right)) {
-		if (node.kind === "variant" && left[node.tag] !== right[node.tag]) return false;
-		for (const [key, member] of 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" && isRecord(left) && isRecord(right)) return equal(left.ids, right.ids) && equalValue({
-		kind: "map",
-		value: node.value
-	}, left.byId, right.byId);
-	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));
-	}
-	if (node.kind === "map" && isRecord(left) && 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 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 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 fail(at, "invalid-collection", "Expected a table.");
-	const table = value;
-	if (!valid(table.ids, position)) return 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 fail(at, "duplicate-entity", "Table key already exists.");
-		ids.add(entry.id);
-	}
-	if (!entries.length) return;
-	const index$1 = 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 fail(at, "invalid-collection", "Expected a table.");
-	const table = value;
-	for (const id of ids) if (!Object.hasOwn(table.byId, id)) return 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 fail(at, "invalid-collection", "Expected a table.");
-	const table = tableValue;
-	if (!Object.hasOwn(table.byId, id)) return 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 fail(at, "invalid-list-key", "Expected a list.");
-	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$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$1, position), value);
-	session.invalidate();
-}
-function replace$2(session, container, id, value) {
-	const { at, node, value: items } = container;
-	if (node.kind !== "list") return fail(at, "invalid-list-key", "Expected a list.");
-	const index = indexedKeys(items, node.keyOf).index(id);
-	if (index < 0) return 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 fail(at, "missing-list-item", "List key does not exist.");
-	const index = keys(value, node.keyOf).index(id);
-	if (index < 0) return 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 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 fail(at, "invalid-key", "Tree keys must be strings.");
-	if (contains(tree, id)) return 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 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 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 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 fail(at, "missing-tree-node", "Tree node does not exist.");
-	if (entry.parentId === void 0 || parentId === void 0 || !contains(tree, parentId)) return 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 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
-const assertOrdered = (container) => {
-	const { at, node } = container;
-	if (node.kind !== "table" && node.kind !== "list") return fail(at, "invalid-collection", "Expected an ordered container.");
-	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/access/scope.ts
-const locations = /* @__PURE__ */ new WeakMap();
-const locationOf = (value) => locations.get(value);
-const addressOf = (target) => {
-	if (target.at) return target.at;
-	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);
-	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) {
-		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 ? resolveChild(parent.node, parent.value, target.key) : resolveLocated(context.state.schema, context.state.document, target.at);
-			target.node = location?.node ?? 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 = []) => {
-	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) => {
-		profile.access("addresses");
-		return addressOf(target).concat(key);
-	};
-	const access = (target) => {
-		if (target.proxy) return target.proxy;
-		const proxy = new Proxy(target, handler);
-		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(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) : indexedKeys(current, node.keyOf).index(id) >= 0;
-		};
-		if (property === "get") return (id) => {
-			const current = collectionValue(target, node);
-			collect(context, at, "collection", id);
-			const location = 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 (ids, position) => {
-			const writable = writableCollection(target, node);
-			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) => {
-		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 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 === "children") return (id) => {
-			const children$1 = 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 = 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/runtime/contract.ts
-var DocumentReentrancyError = class extends Error {
-	constructor() {
-		super("Document writes cannot be re-entered during an update or notification.");
-		this.name = "DocumentReentrancyError";
-	}
-};
-var DocumentDisposedError = class extends Error {
-	constructor() {
-		super("Doxum runtime has been disposed.");
-		this.name = "DocumentDisposedError";
-	}
-};
-var TransactionRejected = class extends Error {
-	issues;
-	constructor(input) {
-		super("Document update rejected.");
-		this.name = "TransactionRejected";
-		const issues = Array.isArray(input) ? input : [input];
-		this.issues = Object.freeze(issues.map((issue) => Object.freeze({
-			code: issue.code,
-			message: issue.message,
-			source: "application",
-			...issue.address === void 0 ? {} : { address: Object.freeze([...issue.address]) }
-		})));
-	}
-};
-//#endregion
-//#region core/src/runtime/access.ts
-const states = /* @__PURE__ */ new WeakMap();
-const bindRuntimeAccess = (runtime, state) => {
-	states.set(runtime, state);
-};
-const accessOf = (runtime) => {
-	const state = states.get(runtime);
-	if (!state) throw new Error("Unknown Doxum runtime.");
-	return state;
-};
-const readWith = (runtime, run, dependencies) => {
-	const state = accessOf(runtime);
-	if (state.disposed) throw new DocumentDisposedError();
-	state.projectionLocks = (state.projectionLocks ?? 0) + 1;
-	try {
-		return run(createAccess({
-			state,
-			dependencies
-		}));
-	} finally {
-		state.projectionLocks--;
-	}
-};
-//#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 };
-
-//# sourceMappingURL=access-BeSV5ve-.js.map