doxum 0.1.1 → 0.1.2

package/dist/local-sync.cjs

@@ -0,0 +1,660 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_access = require("./access-z56fVqZ2.cjs");
+const require_readable = require("./readable-B8E3FMq6.cjs");
+//#region core/src/local-sync/contract.ts
+var LocalSyncUnavailableError = class extends Error {
+	constructor(capability) {
+		super(`${capability} is required by doxum/local-sync in this environment.`);
+		this.name = "LocalSyncUnavailableError";
+	}
+};
+var LocalSyncSchemaError = class extends Error {
+	constructor(documentId, expected, actual) {
+		super(`Local document '${documentId}' uses schema version ${actual}, but version ${expected} was requested.`);
+		this.name = "LocalSyncSchemaError";
+	}
+};
+var LocalSyncConsistencyError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "LocalSyncConsistencyError";
+	}
+};
+var LocalSyncDisposedError = class extends Error {
+	constructor() {
+		super("Local sync document has been disposed.");
+		this.name = "LocalSyncDisposedError";
+	}
+};
+//#endregion
+//#region core/src/local-sync/json.ts
+const defaultJsonCommandLimits = Object.freeze({
+	maxOperations: 1e3,
+	maxBytes: 1e6,
+	maxDepth: 64,
+	maxStringLength: 256e3
+});
+var LocalSyncDataError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "LocalSyncDataError";
+	}
+};
+const describePath = (path) => path.length === 0 ? "value" : path.join(".");
+const limit = (value, fallback, label) => {
+	if (value === void 0) return fallback;
+	if (Number.isSafeInteger(value) && value > 0) return value;
+	throw new TypeError(`${label} must be a positive safe integer.`);
+};
+const resolveLimits = (input) => ({
+	maxOperations: limit(input?.maxOperations, defaultJsonCommandLimits.maxOperations, "maxOperations"),
+	maxBytes: limit(input?.maxBytes, defaultJsonCommandLimits.maxBytes, "maxBytes"),
+	maxDepth: limit(input?.maxDepth, defaultJsonCommandLimits.maxDepth, "maxDepth"),
+	maxStringLength: limit(input?.maxStringLength, defaultJsonCommandLimits.maxStringLength, "maxStringLength")
+});
+const validate = (value, path, limits, depth, ancestors) => {
+	if (limits && depth > limits.maxDepth) throw new LocalSyncDataError(`${describePath(path)} exceeds the maximum JSON depth.`);
+	if (value === null || typeof value === "boolean") return value;
+	if (typeof value === "string") {
+		if (!limits || value.length <= limits.maxStringLength) return value;
+		throw new LocalSyncDataError(`${describePath(path)} exceeds the maximum string length.`);
+	}
+	if (typeof value === "number") {
+		if (Number.isFinite(value)) return value;
+		throw new LocalSyncDataError(`${describePath(path)} contains a non-finite number.`);
+	}
+	if (Array.isArray(value)) {
+		if (ancestors.has(value)) throw new LocalSyncDataError(`${describePath(path)} contains a cycle.`);
+		ancestors.add(value);
+		try {
+			for (let index = 0; index < value.length; index += 1) validate(value[index], [...path, String(index)], limits, depth + 1, ancestors);
+		} finally {
+			ancestors.delete(value);
+		}
+		return value;
+	}
+	if (require_access.isPlainObject(value)) {
+		if (ancestors.has(value)) throw new LocalSyncDataError(`${describePath(path)} contains a cycle.`);
+		ancestors.add(value);
+		try {
+			for (const [key, entry] of Object.entries(value)) validate(entry, [...path, key], limits, depth + 1, ancestors);
+		} finally {
+			ancestors.delete(value);
+		}
+		return value;
+	}
+	throw new LocalSyncDataError(`${describePath(path)} must be JSON data.`);
+};
+const json = (value, label) => validate(value, [label], void 0, 0, /* @__PURE__ */ new WeakSet());
+const jsonArray = (value, label, input) => {
+	const limits = resolveLimits(input);
+	const parsed = validate(value, [label], limits, 0, /* @__PURE__ */ new WeakSet());
+	if (!Array.isArray(parsed)) throw new LocalSyncDataError(`${label} must be a JSON array.`);
+	if (parsed.length > limits.maxOperations) throw new LocalSyncDataError(`${label} exceeds the maximum operation count.`);
+	const serialized = JSON.stringify(parsed);
+	if (new TextEncoder().encode(serialized).byteLength > limits.maxBytes) throw new LocalSyncDataError(`${label} exceeds the maximum command size.`);
+	return parsed;
+};
+//#endregion
+//#region core/src/local-sync/timeline.ts
+const DATABASE_VERSION = 1;
+const DOCUMENTS = "documents";
+const COMMITS = "commits";
+const ACTORS = "actors";
+const request = (value) => new Promise((resolve, reject) => {
+	value.onsuccess = () => resolve(value.result);
+	value.onerror = () => reject(value.error ?? /* @__PURE__ */ new Error("IndexedDB request failed."));
+});
+const complete = (transaction) => new Promise((resolve, reject) => {
+	transaction.oncomplete = () => resolve();
+	transaction.onabort = () => reject(transaction.error ?? /* @__PURE__ */ new Error("IndexedDB transaction was aborted."));
+	transaction.onerror = () => reject(transaction.error ?? /* @__PURE__ */ new Error("IndexedDB transaction failed."));
+});
+const factory = () => {
+	if (!globalThis.indexedDB) throw new LocalSyncUnavailableError("IndexedDB");
+	return globalThis.indexedDB;
+};
+const keyRange = () => {
+	if (!globalThis.IDBKeyRange) throw new LocalSyncUnavailableError("IndexedDB");
+	return globalThis.IDBKeyRange;
+};
+const string = (value, label) => {
+	if (typeof value === "string") return value;
+	throw new LocalSyncConsistencyError(`${label} is malformed in IndexedDB.`);
+};
+const nonNegativeInteger$1 = (value, label) => {
+	if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) return value;
+	throw new LocalSyncConsistencyError(`${label} is malformed in IndexedDB.`);
+};
+const positiveInteger$1 = (value, label) => {
+	const parsed = nonNegativeInteger$1(value, label);
+	if (parsed > 0) return parsed;
+	throw new LocalSyncConsistencyError(`${label} is malformed in IndexedDB.`);
+};
+const historyEntry = (value, label) => {
+	if (!require_access.isRecord(value)) throw new LocalSyncConsistencyError(`${label} is malformed in IndexedDB.`);
+	const footprint = require_readable.decodeCommandFootprint(value.footprint);
+	if (!footprint) throw new LocalSyncConsistencyError(`${label}.footprint is malformed in IndexedDB.`);
+	return Object.freeze({
+		commandId: string(value.commandId, `${label}.commandId`),
+		operations: jsonArray(value.operations, `${label}.operations`),
+		inverse: jsonArray(value.inverse, `${label}.inverse`),
+		footprint
+	});
+};
+const historyEntries = (value, label) => {
+	if (!Array.isArray(value)) throw new LocalSyncConsistencyError(`${label} is malformed in IndexedDB.`);
+	return Object.freeze(value.map((entry, index) => historyEntry(entry, `${label}.${index}`)));
+};
+const documentRecord = (value) => {
+	if (!require_access.isRecord(value)) throw new LocalSyncConsistencyError("Document record is malformed in IndexedDB.");
+	const checkpointSeq = nonNegativeInteger$1(value.checkpointSeq, "document.checkpointSeq");
+	const headSeq = nonNegativeInteger$1(value.headSeq, "document.headSeq");
+	if (checkpointSeq > headSeq) throw new LocalSyncConsistencyError("Document checkpoint exceeds its head sequence.");
+	return Object.freeze({
+		documentId: string(value.documentId, "document.documentId"),
+		schemaVersion: positiveInteger$1(value.schemaVersion, "document.schemaVersion"),
+		checkpointSeq,
+		headSeq,
+		checkpoint: json(value.checkpoint, "document.checkpoint")
+	});
+};
+const commitRecord = (value) => {
+	if (!require_access.isRecord(value)) throw new LocalSyncConsistencyError("Commit record is malformed in IndexedDB.");
+	const kind = value.kind;
+	if (kind !== "update" && kind !== "undo" && kind !== "redo") throw new LocalSyncConsistencyError("Commit kind is malformed in IndexedDB.");
+	const footprint = require_readable.decodeCommandFootprint(value.footprint);
+	if (!footprint) throw new LocalSyncConsistencyError("Commit footprint is malformed in IndexedDB.");
+	return Object.freeze({
+		documentId: string(value.documentId, "commit.documentId"),
+		seq: positiveInteger$1(value.seq, "commit.seq"),
+		commandId: string(value.commandId, "commit.commandId"),
+		actorId: string(value.actorId, "commit.actorId"),
+		kind,
+		operations: jsonArray(value.operations, "commit.operations"),
+		inverse: jsonArray(value.inverse, "commit.inverse"),
+		footprint,
+		createdAt: nonNegativeInteger$1(value.createdAt, "commit.createdAt")
+	});
+};
+const actorRecord = (value, documentId, actorId) => {
+	if (value === void 0) return Object.freeze({
+		documentId,
+		actorId,
+		undo: Object.freeze([]),
+		redo: Object.freeze([])
+	});
+	if (!require_access.isRecord(value)) throw new LocalSyncConsistencyError("Actor history is malformed in IndexedDB.");
+	const storedDocumentId = string(value.documentId, "actor.documentId");
+	const storedActorId = string(value.actorId, "actor.actorId");
+	if (storedDocumentId !== documentId || storedActorId !== actorId) throw new LocalSyncConsistencyError("Actor history key does not match its record.");
+	return Object.freeze({
+		documentId,
+		actorId,
+		undo: historyEntries(value.undo, "actor.undo"),
+		redo: historyEntries(value.redo, "actor.redo")
+	});
+};
+const nextHistory = (current, change) => {
+	if (change.kind === "record") {
+		const undo = [...current.undo, change.entry];
+		const start = Math.max(0, undo.length - change.capacity);
+		return Object.freeze({
+			documentId: current.documentId,
+			actorId: current.actorId,
+			undo: Object.freeze(undo.slice(start)),
+			redo: Object.freeze([])
+		});
+	}
+	const source = change.kind === "undo" ? current.undo : current.redo;
+	const latest = source[source.length - 1];
+	if (!latest || latest.commandId !== change.expectedCommandId) throw new LocalSyncConsistencyError("Local undo history changed before it could be committed.");
+	if (change.kind === "undo") return Object.freeze({
+		documentId: current.documentId,
+		actorId: current.actorId,
+		undo: Object.freeze(current.undo.slice(0, -1)),
+		redo: Object.freeze([...current.redo, change.entry])
+	});
+	return Object.freeze({
+		documentId: current.documentId,
+		actorId: current.actorId,
+		undo: Object.freeze([...current.undo, change.entry]),
+		redo: Object.freeze(current.redo.slice(0, -1))
+	});
+};
+const deleteCommitsThrough = async (store, documentId, seq) => {
+	const range = keyRange().bound([documentId, 0], [documentId, seq]);
+	await new Promise((resolve, reject) => {
+		const cursor = store.openCursor(range);
+		cursor.onerror = () => reject(cursor.error ?? /* @__PURE__ */ new Error("IndexedDB cursor failed."));
+		cursor.onsuccess = () => {
+			const current = cursor.result;
+			if (!current) {
+				resolve();
+				return;
+			}
+			current.delete();
+			current.continue();
+		};
+	});
+};
+const openIndexedDbTimeline = async (databaseName) => {
+	const database = await new Promise((resolve, reject) => {
+		const open = factory().open(databaseName, DATABASE_VERSION);
+		open.onerror = () => reject(open.error ?? /* @__PURE__ */ new Error("Unable to open IndexedDB."));
+		open.onblocked = () => reject(/* @__PURE__ */ new Error(`IndexedDB database '${databaseName}' is blocked.`));
+		open.onupgradeneeded = () => {
+			const db = open.result;
+			if (!db.objectStoreNames.contains(DOCUMENTS)) db.createObjectStore(DOCUMENTS, { keyPath: "documentId" });
+			if (!db.objectStoreNames.contains(COMMITS)) db.createObjectStore(COMMITS, { keyPath: ["documentId", "seq"] });
+			if (!db.objectStoreNames.contains(ACTORS)) db.createObjectStore(ACTORS, { keyPath: ["documentId", "actorId"] });
+		};
+		open.onsuccess = () => resolve(open.result);
+	});
+	const readDocument = async (transaction, documentId) => {
+		const value = await request(transaction.objectStore(DOCUMENTS).get(documentId));
+		if (value === void 0) throw new LocalSyncConsistencyError(`Local document '${documentId}' does not exist.`);
+		return documentRecord(value);
+	};
+	return {
+		initialize: async (documentId, schemaVersion, checkpoint) => {
+			const transaction = database.transaction(DOCUMENTS, "readwrite");
+			const store = transaction.objectStore(DOCUMENTS);
+			const existing = await request(store.get(documentId));
+			if (existing !== void 0) {
+				const record = documentRecord(existing);
+				if (record.schemaVersion !== schemaVersion) throw new LocalSyncSchemaError(documentId, schemaVersion, record.schemaVersion);
+				await complete(transaction);
+				return record;
+			}
+			const record = {
+				documentId,
+				schemaVersion,
+				checkpointSeq: 0,
+				headSeq: 0,
+				checkpoint
+			};
+			store.put(record);
+			await complete(transaction);
+			return Object.freeze(record);
+		},
+		read: async (documentId) => {
+			const transaction = database.transaction(DOCUMENTS, "readonly");
+			const record = await readDocument(transaction, documentId);
+			await complete(transaction);
+			return record;
+		},
+		tail: async (documentId, afterSeq) => {
+			const transaction = database.transaction(COMMITS, "readonly");
+			const range = keyRange().bound([documentId, afterSeq + 1], [documentId, Number.MAX_SAFE_INTEGER]);
+			const values = await request(transaction.objectStore(COMMITS).getAll(range));
+			await complete(transaction);
+			return Object.freeze(values.map(commitRecord).sort((left, right) => left.seq - right.seq));
+		},
+		history: async (documentId, actorId) => {
+			const transaction = database.transaction(ACTORS, "readonly");
+			const value = await request(transaction.objectStore(ACTORS).get([documentId, actorId]));
+			await complete(transaction);
+			return actorRecord(value, documentId, actorId);
+		},
+		append: async (input) => {
+			const transaction = database.transaction([
+				DOCUMENTS,
+				COMMITS,
+				ACTORS
+			], "readwrite");
+			const documents = transaction.objectStore(DOCUMENTS);
+			const commits = transaction.objectStore(COMMITS);
+			const actors = transaction.objectStore(ACTORS);
+			const current = await readDocument(transaction, input.documentId);
+			if (current.headSeq !== input.expectedHeadSeq) throw new LocalSyncConsistencyError("Local document advanced before the writer lock was acquired.");
+			const actor = actorRecord(await request(actors.get([input.documentId, input.actorId])), input.documentId, input.actorId);
+			const seq = current.headSeq + 1;
+			const commit = {
+				documentId: input.documentId,
+				seq,
+				commandId: input.commandId,
+				actorId: input.actorId,
+				kind: input.kind,
+				operations: input.operations,
+				inverse: input.inverse,
+				footprint: input.footprint,
+				createdAt: Date.now()
+			};
+			const nextDocument = {
+				...current,
+				headSeq: seq
+			};
+			commits.put(commit);
+			documents.put(nextDocument);
+			actors.put(nextHistory(actor, input.history));
+			await complete(transaction);
+			return Object.freeze(commit);
+		},
+		compact: async (documentId, seq, checkpoint) => {
+			const transaction = database.transaction([DOCUMENTS, COMMITS], "readwrite");
+			const current = await readDocument(transaction, documentId);
+			if (seq < current.checkpointSeq || seq > current.headSeq) throw new LocalSyncConsistencyError("Local checkpoint sequence is outside the durable timeline.");
+			const next = {
+				...current,
+				checkpointSeq: seq,
+				checkpoint
+			};
+			transaction.objectStore(DOCUMENTS).put(next);
+			await deleteCommitsThrough(transaction.objectStore(COMMITS), documentId, seq);
+			await complete(transaction);
+			return Object.freeze(next);
+		},
+		close: () => database.close()
+	};
+};
+//#endregion
+//#region core/src/local-sync/session.ts
+const locks = () => {
+	const value = globalThis.navigator?.locks;
+	if (typeof value !== "object" || value === null || !("request" in value) || typeof value.request !== "function") throw new LocalSyncUnavailableError("Web Locks");
+	return value;
+};
+const channelConstructor = () => {
+	const value = globalThis.BroadcastChannel;
+	if (typeof value !== "function") throw new LocalSyncUnavailableError("BroadcastChannel");
+	return value;
+};
+const requiredString = (value, label) => {
+	if (value.length > 0) return value;
+	throw new TypeError(`${label} must not be empty.`);
+};
+const nonNegativeInteger = (value, label) => {
+	if (Number.isSafeInteger(value) && value >= 0) return value;
+	throw new TypeError(`${label} must be a non-negative safe integer.`);
+};
+const positiveInteger = (value, label) => {
+	if (Number.isSafeInteger(value) && value > 0) return value;
+	throw new TypeError(`${label} must be a positive safe integer.`);
+};
+const identifier = () => globalThis.crypto?.randomUUID?.() ?? `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+const notification = (value) => {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const record = value;
+	if (record.kind !== "commit" || typeof record.documentId !== "string" || typeof record.senderId !== "string" || typeof record.headSeq !== "number" || !Number.isSafeInteger(record.headSeq) || record.headSeq < 0) return void 0;
+	return record;
+};
+const localCommit = (commit, stored) => Object.freeze({
+	...commit,
+	seq: stored.seq,
+	commandId: stored.commandId,
+	actorId: stored.actorId
+});
+const operationResult = (result, stored) => {
+	if (result.status !== "committed") throw new LocalSyncConsistencyError("A durable local command could not be applied.");
+	return {
+		status: "committed",
+		commit: localCommit(result.commit, stored),
+		observerErrors: result.observerErrors
+	};
+};
+const openLocalDocument = async (input) => {
+	const databaseName = requiredString(input.database, "database");
+	const documentId = requiredString(input.documentId, "documentId");
+	const actorId = requiredString(input.actorId ?? "local", "actorId");
+	const schemaVersion = positiveInteger(input.schemaVersion ?? 1, "schemaVersion");
+	const historyCapacity = nonNegativeInteger(input.historyCapacity ?? 100, "historyCapacity");
+	const checkpointEvery = nonNegativeInteger(input.checkpointEvery ?? 500, "checkpointEvery");
+	const commandLimits = input.commandLimits;
+	const initial = json(input.initial, "initial document");
+	const lockManager = locks();
+	const BroadcastChannel = channelConstructor();
+	const timeline = await openIndexedDbTimeline(databaseName);
+	let channel;
+	let runtime;
+	try {
+		const stored = await timeline.initialize(documentId, schemaVersion, initial);
+		const documentRuntime = require_readable.createDocument({
+			schema: input.schema,
+			initial: stored.checkpoint,
+			history: false
+		});
+		runtime = documentRuntime;
+		let headSeq = stored.checkpointSeq;
+		let checkpointSeq = stored.checkpointSeq;
+		let queued = Promise.resolve();
+		let fault;
+		let closing = false;
+		let disposed = false;
+		const senderId = identifier();
+		const fail = (error) => {
+			if (closing || disposed || fault) return;
+			fault = error;
+			try {
+				input.onError?.(error);
+			} catch {}
+		};
+		const assertOpen = () => {
+			if (closing || disposed) throw new LocalSyncDisposedError();
+			if (fault) throw fault;
+		};
+		const applyStored = (commit) => {
+			if (commit.seq !== headSeq + 1) throw new LocalSyncConsistencyError("Local commit log contains a sequence gap.");
+			const local = operationResult(documentRuntime.apply(commit.operations, {
+				source: "local",
+				history: false
+			}), commit);
+			if (local.status !== "committed") throw new LocalSyncConsistencyError("A durable local command was not committed.");
+			headSeq = commit.seq;
+			return local.commit;
+		};
+		const catchUp = async () => {
+			const current = await timeline.read(documentId);
+			if (current.schemaVersion !== schemaVersion) throw new LocalSyncConsistencyError("Local document schema changed while this session was open.");
+			if (headSeq < current.checkpointSeq) {
+				const replaced = documentRuntime.replace(current.checkpoint, { source: "system" });
+				if (replaced.status !== "committed" && replaced.status !== "unchanged") throw new LocalSyncConsistencyError("Local checkpoint could not be restored.");
+				headSeq = current.checkpointSeq;
+				checkpointSeq = current.checkpointSeq;
+			}
+			const tail = await timeline.tail(documentId, headSeq);
+			for (const commit of tail) applyStored(commit);
+			if (headSeq !== current.headSeq) throw new LocalSyncConsistencyError("Local commit log does not reach its recorded head sequence.");
+			checkpointSeq = current.checkpointSeq;
+		};
+		const execute = (run) => {
+			const next = queued.then(run, run);
+			queued = next.then(() => void 0, () => void 0);
+			return next;
+		};
+		const withWriter = (run) => lockManager.request(`doxum:${documentId}`, { mode: "exclusive" }, async () => {
+			assertOpen();
+			try {
+				await catchUp();
+			} catch (error) {
+				fail(error);
+				throw error;
+			}
+			return run();
+		});
+		const persistAndApply = async (input) => {
+			try {
+				const storedCommit = await timeline.append({
+					documentId,
+					expectedHeadSeq: headSeq,
+					commandId: input.commandId,
+					actorId,
+					kind: input.kind,
+					operations: input.operations,
+					inverse: input.inverse,
+					footprint: input.footprint,
+					history: input.history
+				});
+				const result = operationResult(documentRuntime.apply(storedCommit.operations, {
+					source: "local",
+					history: false
+				}), storedCommit);
+				headSeq = storedCommit.seq;
+				if (checkpointEvery > 0 && headSeq - checkpointSeq >= checkpointEvery) {
+					const checkpoint = json(documentRuntime.snapshot(), "local checkpoint");
+					checkpointSeq = (await timeline.compact(documentId, headSeq, checkpoint)).checkpointSeq;
+				}
+				channel?.postMessage({
+					kind: "commit",
+					documentId,
+					headSeq,
+					senderId
+				});
+				return result;
+			} catch (error) {
+				fail(error);
+				throw error;
+			}
+		};
+		const replay = (operations) => {
+			const candidate = require_readable.createDocument({
+				schema: input.schema,
+				initial: documentRuntime.snapshot(),
+				history: false
+			});
+			try {
+				return candidate.apply(operations, {
+					source: "local",
+					history: false
+				});
+			} finally {
+				candidate.dispose();
+			}
+		};
+		const applyHistory = async (history, kind) => {
+			const source = kind === "undo" ? history.undo : history.redo;
+			const entry = source[source.length - 1];
+			if (!entry) return {
+				status: "unchanged",
+				revision: documentRuntime.revision()
+			};
+			const preview = replay(kind === "undo" ? entry.inverse : entry.operations);
+			if (preview.status !== "committed") return preview;
+			const operations = jsonArray(preview.commit.operations, `${kind} operations`, commandLimits);
+			const inverse = jsonArray(preview.commit.inverse, `${kind} inverse`, commandLimits);
+			return persistAndApply({
+				commandId: identifier(),
+				kind,
+				operations,
+				inverse,
+				footprint: require_readable.commandFootprint(preview.commit.operations),
+				history: kind === "undo" ? {
+					kind: "undo",
+					expectedCommandId: entry.commandId,
+					entry
+				} : {
+					kind: "redo",
+					expectedCommandId: entry.commandId,
+					entry
+				}
+			});
+		};
+		const initialTail = await timeline.tail(documentId, headSeq);
+		for (const commit of initialTail) applyStored(commit);
+		if (headSeq !== stored.headSeq) throw new LocalSyncConsistencyError("Local commit log does not reach its recorded head sequence.");
+		channel = new BroadcastChannel(`doxum:${databaseName}:${documentId}`);
+		channel.onmessage = (event) => {
+			const message = notification(event.data);
+			if (!message || message.documentId !== documentId || message.senderId === senderId || message.headSeq <= headSeq || closing || disposed) return;
+			execute(() => withWriter(async () => void 0)).catch(() => void 0);
+		};
+		const localDocument = {
+			document: require_readable.asReadable(documentRuntime),
+			state: () => {
+				if (disposed) return { status: "disposed" };
+				if (fault) return {
+					status: "failed",
+					error: fault
+				};
+				return {
+					status: "ready",
+					headSeq,
+					checkpointSeq
+				};
+			},
+			sync: () => execute(() => withWriter(async () => void 0)),
+			update: (run) => {
+				assertOpen();
+				return execute(() => withWriter(async () => {
+					const prepared = documentRuntime.prepare(run);
+					if (prepared.status === "unchanged") return {
+						status: "unchanged",
+						value: prepared.value,
+						revision: documentRuntime.revision(),
+						reports: prepared.reports
+					};
+					if (prepared.status === "rejected") return {
+						status: "rejected",
+						issues: prepared.issues,
+						revision: documentRuntime.revision()
+					};
+					const operations = jsonArray(prepared.operations, "local command operations", commandLimits);
+					const inverse = jsonArray(prepared.inverse, "local command inverse", commandLimits);
+					const commandId = identifier();
+					const result = await persistAndApply({
+						commandId,
+						kind: "update",
+						operations,
+						inverse,
+						footprint: prepared.footprint,
+						history: {
+							kind: "record",
+							entry: Object.freeze({
+								commandId,
+								operations,
+								inverse,
+								footprint: prepared.footprint
+							}),
+							capacity: historyCapacity
+						}
+					});
+					if (result.status !== "committed") throw new LocalSyncConsistencyError("Prepared local command was not committed.");
+					return {
+						status: "committed",
+						value: prepared.value,
+						commit: result.commit,
+						reports: prepared.reports,
+						observerErrors: result.observerErrors
+					};
+				}));
+			},
+			undo: () => {
+				assertOpen();
+				return execute(() => withWriter(async () => applyHistory(await timeline.history(documentId, actorId), "undo")));
+			},
+			redo: () => {
+				assertOpen();
+				return execute(() => withWriter(async () => applyHistory(await timeline.history(documentId, actorId), "redo")));
+			},
+			dispose: async () => {
+				if (disposed) return;
+				if (closing) {
+					await queued;
+					return;
+				}
+				closing = true;
+				await queued;
+				disposed = true;
+				channel?.close();
+				timeline.close();
+				documentRuntime.dispose();
+			}
+		};
+		return Object.freeze(localDocument);
+	} catch (error) {
+		channel?.close();
+		runtime?.dispose();
+		timeline.close();
+		throw error;
+	}
+};
+//#endregion
+exports.LocalSyncConsistencyError = LocalSyncConsistencyError;
+exports.LocalSyncDataError = LocalSyncDataError;
+exports.LocalSyncDisposedError = LocalSyncDisposedError;
+exports.LocalSyncSchemaError = LocalSyncSchemaError;
+exports.LocalSyncUnavailableError = LocalSyncUnavailableError;
+exports.defaultJsonCommandLimits = defaultJsonCommandLimits;
+exports.openLocalDocument = openLocalDocument;
+
+//# sourceMappingURL=local-sync.cjs.map