doxum 0.1.1 → 0.1.3

package/dist/index.js

@@ -1,4 +1,6 @@
-import { A as resolveAddress, B as record, C as impact_target_exports, D as nodeAt$1, E as locate, F as field, G as variant, H as single, I as list, L as map, M as set$1, N as profile, O as overlaps, P as dict, R as object, S as id, T as debugKey, U as table, V as schema, W as tree, _ as snapshotPayload, a as schemaOf, b as belongs, c as documentReader, d as deepEqual, f as isRecord, g as sameStructuralValue, h as ownPayload, i as readWith, j as resolveLocated, k as read, l as readerFor, m as operationOwnsStructuralPayload, n as bindRuntimeAccess, o as DocumentDisposedError, p as isStablePayload, r as documentOf, s as DocumentReentrancyError, t as createDependencyTracker, u as cloneValue, v as transferPayload, w as contains, x as bucket, y as address$1, z as optional } from "./dependency-BdEMyquf.js";
+import { A as optional, C as resolveLocated, D as list, E as field, F as tree, I as variant, M as schema, N as single, O as map, P as table, S as resolveAddress, T as dict, _ as debugKey, a as readWith, b as overlaps, c as DocumentReentrancyError, d as address$2, f as belongs, g as contains, h as impact_target_exports, i as documentOf, j as record, k as object, l as documentReader, m as id, n as accessOf, o as schemaOf, p as bucket, r as bindRuntimeAccess, s as DocumentDisposedError, t as createDependencyTracker, u as readerFor, v as locate, w as set$1, x as read, y as nodeAt$1 } from "./dependency-C5_R1tvQ.js";
+import { a as isStablePayload, c as snapshotPayload, i as isRecord, l as transferPayload, n as deepEqual, o as ownPayload, r as isPlainObject, s as sameStructuralValue, t as cloneValue, u as profile } from "./ownership-B-VAPcce.js";
+import { n as bindRuntimeDriver, r as disposeRuntimeDriver, t as assertRuntimeWritable } from "./driver-CbzfW5MR.js";
 //#region core/src/impact.ts
 const emptyCollectionImpact = Object.freeze({
 	kind: "incremental",
@@ -36,9 +38,9 @@ const createImpact = (input) => {
 			profile.impact.affects();
 			if (kind === "reset") return true;
 			if (!belongs(value, input.schema)) return false;
-			if (pathsAffect(address$1(value))) return true;
+			if (pathsAffect(address$2(value))) return true;
 			if (value.kind === "collection") {
-				const collection = findCollection(address$1(value));
+				const collection = findCollection(address$2(value));
 				if (!collection) return false;
 				const id$1 = id(value);
 				if (id$1 !== void 0) return collection.added.has(id$1) || collection.removed.has(id$1) || collection.updated.has(id$1);
@@ -1156,7 +1158,7 @@ const execute = (root, operation, target, copyPayload) => {
 //#region core/src/mutation/journal.ts
 const indexNode = () => ({ children: /* @__PURE__ */ new Map() });
 const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
-const sameAddress = (left, right) => {
+const sameAddress$1 = (left, right) => {
 	if (left.length !== right.length) return false;
 	for (let index = 0; index < left.length; index += 1) if (left[index] !== right[index]) return false;
 	return true;
@@ -1271,7 +1273,7 @@ const restoreRootSubject = (value, subject) => {
 	return restoreChange(value, subject.state);
 };
 const restoreSubject = (value, prefix, subject) => {
-	if (sameAddress(prefix, subject.address)) return restoreRootSubject(value, subject);
+	if (sameAddress$1(prefix, subject.address)) return restoreRootSubject(value, subject);
 	const address = subject.address.slice(prefix.length);
 	if (subject.kind === "value") {
 		writePresence(value, address, subject.before);
@@ -1498,7 +1500,7 @@ const createChangeJournal = (root) => {
 		const candidates = buckets.get(addressHash) ?? [];
 		for (const subject of candidates) {
 			profile.journal.comparison();
-			if (subject.kind === kind && sameAddress(subject.address, address)) return subject;
+			if (subject.kind === kind && sameAddress$1(subject.address, address)) return subject;
 		}
 	}
 	const ownerOf = (address) => {
@@ -1720,7 +1722,7 @@ const createChangeJournal = (root) => {
 			const changeAt = (address, addressHash) => {
 				const candidates = collectionBuckets.get(addressHash) ?? [];
 				collectionBuckets.set(addressHash, candidates);
-				let change = candidates.find((entry) => sameAddress(entry.address, address));
+				let change = candidates.find((entry) => sameAddress$1(entry.address, address));
 				if (!change) {
 					change = {
 						address,
@@ -1764,7 +1766,7 @@ const createChangeJournal = (root) => {
 const has = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
 const stringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
 const positions = (value) => Array.isArray(value) && value.every((entry) => Number.isInteger(entry) && entry >= 0);
-const address = (value) => stringArray(value);
+const address$1 = (value) => stringArray(value);
 const anchor = (value) => {
 	if (!isRecord(value)) return false;
 	if (Number(has(value, "at")) + Number(has(value, "before")) + Number(has(value, "after")) !== 1) return false;
@@ -1785,7 +1787,7 @@ const rejected = (code, message) => ({
 });
 const decode = (input) => {
 	if (!isRecord(input)) return rejected("invalid-operation", "Operation must be an object.");
-	if (!address(input.at)) return rejected("invalid-address", "Operation address is malformed.");
+	if (!address$1(input.at)) return rejected("invalid-address", "Operation address is malformed.");
 	if (typeof input.type !== "string") return rejected("invalid-operation", "Operation type must be a string.");
 	switch (input.type) {
 		case "field.set":
@@ -1821,6 +1823,7 @@ const ownAddress = (value) => {
 	profile.address.arrayCopied();
 	return Object.freeze(value.slice());
 };
+const structuralPayload = (value) => Array.isArray(value) || isPlainObject(value);
 const normalize = (operation) => {
 	profile.mutation.normalized();
 	const copy = {
@@ -1835,23 +1838,34 @@ const normalize = (operation) => {
 	return Object.freeze(copy);
 };
 const publish = (operation) => {
-	if (!operationOwnsStructuralPayload(operation)) return operation;
-	if (operation.type === "entity.create" && operation.entries.every((entry) => isStablePayload(entry.value))) return operation;
+	if (operation.type === "entity.create" && operation.entries.every((entry) => !structuralPayload(entry.value) || isStablePayload(entry.value))) return operation;
+	if ("value" in operation && (!structuralPayload(operation.value) || isStablePayload(operation.value))) return operation;
 	const copy = { ...operation };
 	if (copy.entries) copy.entries = Object.freeze(copy.entries.map((entry) => Object.freeze({
 		id: entry.id,
-		value: isStablePayload(entry.value) ? entry.value : snapshotPayload(entry.value, "commit")
+		value: structuralPayload(entry.value) ? isStablePayload(entry.value) ? entry.value : snapshotPayload(entry.value, "commit") : entry.value
 	})));
-	else if ("value" in copy) copy.value = isStablePayload(copy.value) ? copy.value : snapshotPayload(copy.value, "commit");
+	else if ("value" in copy && structuralPayload(copy.value)) copy.value = isStablePayload(copy.value) ? copy.value : snapshotPayload(copy.value, "commit");
 	return Object.freeze(copy);
 };
+const requiresPayloadCopy = (operation) => {
+	if (operation.type === "entity.create") return operation.entries.some((entry) => isStablePayload(entry.value));
+	return "value" in operation && isStablePayload(operation.value);
+};
 const inverse = (operation) => {
 	const copy = { ...operation };
 	if (copy.anchor) copy.anchor = Object.freeze({ ...copy.anchor });
 	if (copy.keys) copy.keys = Object.freeze([...copy.keys]);
-	if (copy.entries) copy.entries = Object.freeze(copy.entries.map((entry) => Object.freeze({ ...entry })));
+	if (copy.entries) copy.entries = Object.freeze(copy.entries.map((entry) => Object.freeze({
+		id: entry.id,
+		value: structuralPayload(entry.value) ? isStablePayload(entry.value) ? entry.value : snapshotPayload(entry.value, "inverse") : entry.value
+	})));
 	if (copy.ids) copy.ids = Object.freeze([...copy.ids]);
 	if (copy.positions) copy.positions = Object.freeze([...copy.positions]);
+	if ("value" in copy && structuralPayload(copy.value)) {
+		const payload = copy;
+		payload.value = isStablePayload(payload.value) ? payload.value : snapshotPayload(payload.value, "inverse");
+	}
 	return Object.freeze(copy);
 };
 //#endregion
@@ -1859,18 +1873,18 @@ const inverse = (operation) => {
 const createMutationSession = (root, schema, options = {}) => {
 	const steps = [];
 	const journal = createChangeJournal(root);
-	let closed = false;
+	let state = "active";
 	const rollback = () => {
-		if (closed) return;
+		if (state === "rolled-back") return;
 		for (let stepIndex = steps.length - 1; stepIndex >= 0; stepIndex -= 1) for (const inverse of steps[stepIndex].inverse) {
 			const result = execute(root, inverse, resolveLocated(schema, root, inverse.at), true);
 			if (result.status === "rejected") throw new Error(`Document rollback failed: ${result.issue.message}`);
 		}
-		closed = true;
+		state = "rolled-back";
 	};
 	return {
 		apply: (input) => {
-			if (closed) throw new Error("Mutation session is closed.");
+			if (state !== "active") throw new Error("Mutation session is closed.");
 			profile.batch.operation();
 			const decoded = decode(input);
 			if (decoded.status === "rejected") {
@@ -1882,7 +1896,7 @@ const createMutationSession = (root, schema, options = {}) => {
 			const resolved = resolveLocated(schema, root, normalized.at);
 			if (resolved?.collection) profile.batch.collectionResolved();
 			profile.mutation.executed();
-			const result = execute(root, normalized, resolved, options.copyPayload === true);
+			const result = execute(root, normalized, resolved, options.copyPayload === true || requiresPayloadCopy(normalized));
 			if (result.status === "rejected") {
 				profile.batch.rejected();
 				return result.issue;
@@ -1909,9 +1923,9 @@ const createMutationSession = (root, schema, options = {}) => {
 			}
 		},
 		finish: () => {
-			if (closed) throw new Error("Mutation session is closed.");
-			closed = true;
+			if (state !== "active") throw new Error("Mutation session is closed.");
 			const changes = journal.finish();
+			state = "finished";
 			if (changes.status === "unchanged") return { status: "unchanged" };
 			let inverseCount = 0;
 			for (const step of steps) inverseCount += step.inverse.length;
@@ -1948,6 +1962,191 @@ const mutateOperations = (root, schema, operations, options = {}) => {
 	return session.finish();
 };
 //#endregion
+//#region core/src/mutation/footprint.ts
+const sameAddress = (left, right) => left.length === right.length && left.every((segment, index) => segment === right[index]);
+const containsAddress = (parent, child) => parent.length <= child.length && parent.every((segment, index) => segment === child[index]);
+const address = (value) => Array.isArray(value) && value.every((segment) => typeof segment === "string") ? Object.freeze(value.slice()) : void 0;
+const targetKey = (target) => {
+	const at = target.at.join("\0");
+	if (target.kind === "dictionary-key" || target.kind === "list-item") return `${target.kind}:${at}:${target.key}`;
+	if (target.kind === "entity" || target.kind === "tree-node") return `${target.kind}:${at}:${target.id}`;
+	return `${target.kind}:${at}`;
+};
+const freezeTarget = (target) => Object.freeze({
+	...target,
+	at: Object.freeze(target.at.slice())
+});
+const add = (targets, target) => {
+	const stable = freezeTarget(target);
+	targets.set(targetKey(stable), stable);
+};
+const commandFootprint = (operations) => {
+	const targets = /* @__PURE__ */ new Map();
+	for (const operation of operations) switch (operation.type) {
+		case "field.set":
+		case "field.clear":
+		case "variant.replace":
+			add(targets, {
+				kind: "value",
+				at: operation.at
+			});
+			break;
+		case "dict.replace":
+			add(targets, {
+				kind: "dictionary",
+				at: operation.at
+			});
+			break;
+		case "dict.set":
+		case "dict.delete":
+			add(targets, {
+				kind: "dictionary-key",
+				at: operation.at,
+				key: operation.key
+			});
+			break;
+		case "entity.create":
+			add(targets, {
+				kind: "collection",
+				at: operation.at
+			});
+			for (const entry of operation.entries) add(targets, {
+				kind: "entity",
+				at: operation.at,
+				id: entry.id
+			});
+			break;
+		case "entity.remove":
+			add(targets, {
+				kind: "collection",
+				at: operation.at
+			});
+			for (const id of operation.ids) add(targets, {
+				kind: "entity",
+				at: operation.at,
+				id
+			});
+			break;
+		case "entity.move":
+			add(targets, {
+				kind: "collection",
+				at: operation.at
+			});
+			add(targets, {
+				kind: "entity",
+				at: operation.at,
+				id: operation.id
+			});
+			break;
+		case "list.insert":
+		case "list.move":
+		case "list.remove":
+			add(targets, {
+				kind: "list",
+				at: operation.at
+			});
+			add(targets, {
+				kind: "list-item",
+				at: operation.at,
+				key: operation.key
+			});
+			break;
+		case "list.replace":
+			add(targets, {
+				kind: "list",
+				at: operation.at
+			});
+			for (const key of operation.keys) add(targets, {
+				kind: "list-item",
+				at: operation.at,
+				key
+			});
+			break;
+		case "tree.insert":
+		case "tree.move":
+		case "tree.remove":
+		case "tree.set":
+			add(targets, {
+				kind: "tree",
+				at: operation.at
+			});
+			add(targets, {
+				kind: "tree-node",
+				at: operation.at,
+				id: operation.treeNodeId
+			});
+			break;
+		case "tree.replace":
+			add(targets, {
+				kind: "tree",
+				at: operation.at
+			});
+			break;
+	}
+	return Object.freeze(Array.from(targets.values()));
+};
+const overlapsValueAndEntity = (value, entity) => containsAddress([...entity.at, entity.id], value.at) || containsAddress(value.at, [...entity.at, entity.id]);
+const targetsOverlap = (left, right) => {
+	if (left.kind === "value" && right.kind === "value") return containsAddress(left.at, right.at) || containsAddress(right.at, left.at);
+	if (left.kind === "value" && right.kind === "entity") return overlapsValueAndEntity(left, right);
+	if (left.kind === "entity" && right.kind === "value") return overlapsValueAndEntity(right, left);
+	if (left.kind === "dictionary" && right.kind === "dictionary") return sameAddress(left.at, right.at);
+	if (left.kind === "dictionary" && right.kind === "dictionary-key") return sameAddress(left.at, right.at);
+	if (left.kind === "dictionary-key" && right.kind === "dictionary") return sameAddress(left.at, right.at);
+	if (left.kind === "dictionary-key" && right.kind === "dictionary-key") return sameAddress(left.at, right.at) && left.key === right.key;
+	if (left.kind === "collection" && right.kind === "collection") return sameAddress(left.at, right.at);
+	if (left.kind === "collection" && right.kind === "entity") return sameAddress(left.at, right.at);
+	if (left.kind === "entity" && right.kind === "collection") return sameAddress(left.at, right.at);
+	if (left.kind === "entity" && right.kind === "entity") return sameAddress(left.at, right.at) && left.id === right.id;
+	if (left.kind === "list" && (right.kind === "list" || right.kind === "list-item")) return sameAddress(left.at, right.at);
+	if (right.kind === "list" && left.kind === "list-item") return sameAddress(left.at, right.at);
+	if (left.kind === "list-item" && right.kind === "list-item") return sameAddress(left.at, right.at) && left.key === right.key;
+	if (left.kind === "tree" && (right.kind === "tree" || right.kind === "tree-node")) return sameAddress(left.at, right.at);
+	if (right.kind === "tree" && left.kind === "tree-node") return sameAddress(left.at, right.at);
+	if (left.kind === "tree-node" && right.kind === "tree-node") return sameAddress(left.at, right.at) && left.id === right.id;
+	return false;
+};
+const footprintsOverlap = (left, right) => left.some((leftTarget) => right.some((rightTarget) => targetsOverlap(leftTarget, rightTarget)));
+const decodedTarget = (value) => {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const record = value;
+	const at = address(record.at);
+	if (!at || typeof record.kind !== "string") return void 0;
+	switch (record.kind) {
+		case "value":
+		case "dictionary":
+		case "collection":
+		case "list":
+		case "tree": return freezeTarget({
+			kind: record.kind,
+			at
+		});
+		case "dictionary-key":
+		case "list-item": return typeof record.key === "string" ? freezeTarget({
+			kind: record.kind,
+			at,
+			key: record.key
+		}) : void 0;
+		case "entity":
+		case "tree-node": return typeof record.id === "string" ? freezeTarget({
+			kind: record.kind,
+			at,
+			id: record.id
+		}) : void 0;
+		default: return;
+	}
+};
+const decodeCommandFootprint = (value) => {
+	if (!Array.isArray(value)) return void 0;
+	const targets = /* @__PURE__ */ new Map();
+	for (const entry of value) {
+		const target = decodedTarget(entry);
+		if (!target) return void 0;
+		targets.set(targetKey(target), target);
+	}
+	return Object.freeze(Array.from(targets.values()));
+};
+//#endregion
 //#region core/src/runtime/notification.ts
 const ROOT_BUCKET = Symbol("document-root");
 const notifications = /* @__PURE__ */ new WeakMap();
@@ -1970,6 +2169,9 @@ const notificationOf = (runtime) => {
 	if (!value) throw new Error("Unknown Doxum runtime.");
 	return value;
 };
+const shareNotification = (source, target) => {
+	notifications.set(target, notificationOf(source));
+};
 const registerProcessor = (runtime, processor) => {
 	const notification = notificationOf(runtime);
 	const entry = {
@@ -2131,10 +2333,47 @@ const createDocument = (input) => {
 	let busy = false;
 	let runtime;
 	let notification;
-	const assertWritable = () => {
+	const assertWritable = (intent) => {
 		if (state.disposed) throw new DocumentDisposedError();
 		if (busy) throw new DocumentReentrancyError();
+		assertRuntimeWritable(runtime, intent);
+	};
+	const runTransaction = (session, run) => {
+		let reports;
+		let active = true;
+		const transaction = {
+			read: documentReader(input.schema, () => state.document, () => active),
+			write: documentWriter(input.schema, (operation) => {
+				if (!active) throw new Error("Document writer is no longer active.");
+				const rejected = session.apply(operation);
+				if (rejected) throw new RejectedUpdate([rejected]);
+			}),
+			reject: (diagnostic) => {
+				throw new RejectedUpdate((Array.isArray(diagnostic) ? diagnostic : [diagnostic]).map((entry) => publishDiagnostic(entry)));
+			},
+			report: (diagnostic) => {
+				if (!active) throw new Error("Document transaction is no longer active.");
+				(reports ??= []).push(publishDiagnostic(diagnostic));
+			}
+		};
+		try {
+			const value = run(transaction);
+			if (value !== null && typeof value === "object" && typeof value.then === "function") throw new TypeError("Document update callback must be synchronous.");
+			return {
+				value,
+				reports: Object.freeze(reports ? reports.slice() : EMPTY)
+			};
+		} finally {
+			active = false;
+		}
 	};
+	const impactFor = (batch, kind) => createImpact({
+		schema: input.schema,
+		operations: batch.operations,
+		paths: batch.paths,
+		collections: batch.collections,
+		reset: kind === "replace"
+	});
 	const history = createHistory({
 		capacity: input.history === false ? 0 : Math.max(0, input.history?.capacity ?? 100),
 		revision: () => revision,
@@ -2148,13 +2387,7 @@ const createDocument = (input) => {
 			source,
 			operations: batch.operations,
 			inverse: batch.inverse,
-			impact: createImpact({
-				schema: input.schema,
-				operations: batch.operations,
-				paths: batch.paths,
-				collections: batch.collections,
-				reset: kind === "replace"
-			})
+			impact: impactFor(batch, kind)
 		});
 		if (kind === "replace" || source === "remote") history.invalidate();
 		else if (recordHistory && (source === "local" || source === "system")) history.record(batch.operations, batch.inverse);
@@ -2172,7 +2405,10 @@ const createDocument = (input) => {
 		};
 	};
 	function applyBatch(operations, source, recordHistory) {
-		assertWritable();
+		assertWritable({
+			kind: "apply",
+			source
+		});
 		const batch = mutateOperations(state.document, input.schema, operations, { copyPayload: source === "history" });
 		if (batch.status === "rejected") return {
 			status: "rejected",
@@ -2186,6 +2422,7 @@ const createDocument = (input) => {
 		return publish(batch, source, "operations", recordHistory);
 	}
 	runtime = {
+		schema: input.schema,
 		address: {
 			resolve: (address) => resolveAddress(input.schema, address, state.document),
 			read: (address) => read(state.document, address),
@@ -2195,55 +2432,40 @@ const createDocument = (input) => {
 		},
 		revision: () => revision,
 		update: (run, options) => {
-			assertWritable();
+			const source = options?.source ?? "local";
+			assertWritable({
+				kind: "update",
+				source
+			});
 			busy = true;
 			const session = createMutationSession(state.document, input.schema);
-			let reports;
-			let active = true;
-			const transaction = {
-				read: documentReader(input.schema, () => state.document, () => active),
-				write: documentWriter(input.schema, (operation) => {
-					if (!active) throw new Error("Document writer is no longer active.");
-					const rejected = session.apply(operation);
-					if (rejected) throw new RejectedUpdate([rejected]);
-				}),
-				reject: (diagnostic) => {
-					throw new RejectedUpdate((Array.isArray(diagnostic) ? diagnostic : [diagnostic]).map((entry) => publishDiagnostic(entry)));
-				},
-				report: (diagnostic) => {
-					if (!active) throw new Error("Document transaction is no longer active.");
-					(reports ??= []).push(publishDiagnostic(diagnostic));
-				}
-			};
+			let committed = false;
 			try {
-				const value = run(transaction);
-				if (value !== null && typeof value === "object" && typeof value.then === "function") throw new TypeError("Document update callback must be synchronous.");
-				active = false;
-				busy = false;
+				const { value, reports } = runTransaction(session, run);
 				const batch = session.finish();
 				if (batch.status === "unchanged") return {
 					status: "unchanged",
 					value,
 					revision,
-					reports: Object.freeze(reports ?? EMPTY)
+					reports
 				};
 				if (batch.status === "rejected") return {
 					status: "rejected",
 					issues: batch.issues,
 					revision
 				};
-				const result = publish(batch, options?.source ?? "local", "operations", options?.history ?? true);
+				const result = publish(batch, source, "operations", options?.history ?? true);
+				committed = true;
 				return {
 					status: "committed",
 					value,
 					commit: result.commit,
-					reports: Object.freeze(reports ?? EMPTY),
+					reports,
 					observerErrors: result.observerErrors
 				};
 			} catch (error) {
-				active = false;
 				try {
-					session.rollback();
+					if (!committed) session.rollback();
 				} finally {
 					busy = false;
 				}
@@ -2254,13 +2476,64 @@ const createDocument = (input) => {
 				};
 				throw error;
 			} finally {
-				active = false;
+				busy = false;
+			}
+		},
+		prepare: (run) => {
+			assertWritable({ kind: "prepare" });
+			busy = true;
+			const session = createMutationSession(state.document, input.schema);
+			try {
+				const { value, reports } = runTransaction(session, run);
+				const batch = session.finish();
+				if (batch.status === "unchanged") {
+					session.rollback();
+					return {
+						status: "unchanged",
+						value,
+						reports
+					};
+				}
+				if (batch.status === "rejected") {
+					session.rollback();
+					return {
+						status: "rejected",
+						issues: batch.issues
+					};
+				}
+				const impact = impactFor(batch, "operations");
+				session.rollback();
+				return {
+					status: "prepared",
+					value,
+					operations: batch.operations,
+					inverse: batch.inverse,
+					impact,
+					footprint: commandFootprint(batch.operations),
+					reports
+				};
+			} catch (error) {
+				try {
+					session.rollback();
+				} finally {
+					busy = false;
+				}
+				if (error instanceof RejectedUpdate) return {
+					status: "rejected",
+					issues: error.issues
+				};
+				throw error;
+			} finally {
 				busy = false;
 			}
 		},
 		apply: (operations, options) => applyBatch(operations, options?.source ?? "local", options?.history ?? true),
 		replace: (document, options) => {
-			assertWritable();
+			const source = options?.source ?? "system";
+			assertWritable({
+				kind: "replace",
+				source
+			});
 			const invalidTree = invalidDocument(input.schema, document);
 			if (invalidTree) return {
 				status: "rejected",
@@ -2278,7 +2551,11 @@ const createDocument = (input) => {
 				inverse: EMPTY,
 				paths: EMPTY,
 				collections: EMPTY
-			}, options?.source ?? "system", "replace", false);
+			}, source, "replace", false);
+		},
+		snapshot: () => {
+			if (state.disposed) throw new DocumentDisposedError();
+			return cloneValue(state.document, "snapshot");
 		},
 		subscribe: ((targetOrListener, listener) => {
 			if (state.disposed) throw new DocumentDisposedError();
@@ -2293,13 +2570,27 @@ const createDocument = (input) => {
 			state.disposed = true;
 			disposeNotification(notification);
 			history.api.clear();
+			disposeRuntimeDriver(runtime);
 		}
 	};
 	bindRuntimeAccess(runtime, state);
+	bindRuntimeDriver(runtime);
 	notification = createNotification(runtime);
 	return runtime;
 };
 //#endregion
+//#region core/src/runtime/readable.ts
+const asReadable = (runtime) => {
+	const readable = {
+		address: runtime.address,
+		revision: runtime.revision,
+		subscribe: runtime.subscribe
+	};
+	bindRuntimeAccess(readable, accessOf(runtime));
+	shareNotification(runtime, readable);
+	return Object.freeze(readable);
+};
+//#endregion
 //#region core/src/projection/select.ts
 const select = (runtime, selector) => readWith(runtime, selector);
 //#endregion
@@ -2684,6 +2975,6 @@ const createMaterializedView = (runtime, spec) => {
 	return view;
 };
 //#endregion
-export { DocumentDisposedError, DocumentReentrancyError, contains, createCollectionView, createDocument, createMaterializedView, debugKey, dict, field, list, map, object, optional, overlaps, read as readAddress, record, resolveAddress, schema, select, single, table, impact_target_exports as target, tree, variant };
+export { DocumentDisposedError, DocumentReentrancyError, asReadable, commandFootprint, contains, createCollectionView, createDocument, createMaterializedView, debugKey, decodeCommandFootprint, dict, field, footprintsOverlap, list, map, object, optional, overlaps, read as readAddress, record, resolveAddress, schema, select, single, table, impact_target_exports as target, tree, variant };
 
 //# sourceMappingURL=index.js.map