doxum 0.1.2 → 0.1.3

package/dist/local-sync.js

@@ -1,5 +1,5 @@
-import { f as isPlainObject, p as isRecord } from "./access-5D4KKFm7.js";
-import { a as decodeCommandFootprint, i as commandFootprint, n as createDocument, t as asReadable } from "./readable-CIj02gIj.js";
+import { i as isRecord, r as isPlainObject } from "./ownership-B-VAPcce.js";
+import { i as installRuntimeWriteDriver } from "./driver-CbzfW5MR.js";
 //#region core/src/local-sync/contract.ts
 var LocalSyncUnavailableError = class extends Error {
 	constructor(capability) {
@@ -19,9 +19,21 @@ var LocalSyncConsistencyError = class extends Error {
 		this.name = "LocalSyncConsistencyError";
 	}
 };
+var LocalSyncReadOnlyError = class extends Error {
+	constructor() {
+		super("This tab is following the local document and cannot write until it becomes the leader.");
+		this.name = "LocalSyncReadOnlyError";
+	}
+};
+var LocalSyncUnsupportedOperationError = class extends Error {
+	constructor() {
+		super("Local sync persists operation commands. runtime.replace() and externally supplied remote operations are unavailable while it is attached.");
+		this.name = "LocalSyncUnsupportedOperationError";
+	}
+};
 var LocalSyncDisposedError = class extends Error {
 	constructor() {
-		super("Local sync document has been disposed.");
+		super("Local sync has been disposed.");
 		this.name = "LocalSyncDisposedError";
 	}
 };
@@ -96,7 +108,7 @@ const jsonArray = (value, label, input) => {
 };
 //#endregion
 //#region core/src/local-sync/timeline.ts
-const DATABASE_VERSION = 1;
+const DATABASE_VERSION = 2;
 const DOCUMENTS = "documents";
 const COMMITS = "commits";
 const ACTORS = "actors";
@@ -121,34 +133,19 @@ const string = (value, label) => {
 	if (typeof value === "string") return value;
 	throw new LocalSyncConsistencyError(`${label} is malformed in IndexedDB.`);
 };
-const nonNegativeInteger$1 = (value, label) => {
+const nonNegativeInteger = (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);
+	const parsed = nonNegativeInteger(value, label);
 	if (parsed > 0) return parsed;
 	throw new LocalSyncConsistencyError(`${label} is malformed in IndexedDB.`);
 };
-const historyEntry = (value, label) => {
-	if (!isRecord(value)) throw new LocalSyncConsistencyError(`${label} is malformed in IndexedDB.`);
-	const footprint = 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 (!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");
+	const checkpointSeq = nonNegativeInteger(value.checkpointSeq, "document.checkpointSeq");
+	const headSeq = nonNegativeInteger(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"),
@@ -160,81 +157,11 @@ const documentRecord = (value) => {
 };
 const commitRecord = (value) => {
 	if (!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 = 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 (!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();
-		};
+		createdAt: nonNegativeInteger(value.createdAt, "commit.createdAt")
 	});
 };
 const openIndexedDbTimeline = async (databaseName) => {
@@ -246,7 +173,7 @@ const openIndexedDbTimeline = async (databaseName) => {
 			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"] });
+			if (db.objectStoreNames.contains(ACTORS)) db.deleteObjectStore(ACTORS);
 		};
 		open.onsuccess = () => resolve(open.result);
 	});
@@ -290,60 +217,25 @@ const openIndexedDbTimeline = async (databaseName) => {
 			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 transaction = database.transaction([DOCUMENTS, COMMITS], "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;
+			if (current.headSeq !== input.expectedHeadSeq) throw new LocalSyncConsistencyError("Local document advanced before the leader could append its command.");
 			const commit = {
 				documentId: input.documentId,
-				seq,
-				commandId: input.commandId,
-				actorId: input.actorId,
-				kind: input.kind,
+				seq: current.headSeq + 1,
 				operations: input.operations,
-				inverse: input.inverse,
-				footprint: input.footprint,
 				createdAt: Date.now()
 			};
-			const nextDocument = {
+			documents.put({
 				...current,
-				headSeq: seq
-			};
-			commits.put(commit);
-			documents.put(nextDocument);
-			actors.put(nextHistory(actor, input.history));
+				headSeq: commit.seq
+			});
+			transaction.objectStore(COMMITS).put(commit);
 			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()
 	};
 };
@@ -363,66 +255,40 @@ 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;
+	if (record.kind !== "commit" || typeof record.documentId !== "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 attachLocalSync = async (input) => {
+	const runtime = input.runtime;
 	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;
+	let unsubscribe;
+	let driver;
 	try {
-		const stored = await timeline.initialize(documentId, schemaVersion, initial);
-		const documentRuntime = createDocument({
-			schema: input.schema,
-			initial: stored.checkpoint,
-			history: false
-		});
-		runtime = documentRuntime;
+		const stored = await timeline.initialize(documentId, schemaVersion, json(runtime.snapshot(), "runtime snapshot"));
 		let headSeq = stored.checkpointSeq;
 		let checkpointSeq = stored.checkpointSeq;
-		let queued = Promise.resolve();
+		let role = "follower";
 		let fault;
 		let closing = false;
 		let disposed = false;
-		const senderId = identifier();
+		let releaseLeadership;
+		let leadershipLease;
+		let queued = Promise.resolve();
 		const fail = (error) => {
-			if (closing || disposed || fault) return;
+			if (fault || disposed) return;
 			fault = error;
 			try {
 				input.onError?.(error);
@@ -432,198 +298,152 @@ const openLocalDocument = async (input) => {
 			if (closing || disposed) throw new LocalSyncDisposedError();
 			if (fault) throw fault;
 		};
+		const assertLeader = (intent) => {
+			assertOpen();
+			if (role !== "leader") throw new LocalSyncReadOnlyError();
+			if (intent.kind === "replace" || intent.kind === "apply" && intent.source === "remote") throw new LocalSyncUnsupportedOperationError();
+		};
+		const runRuntime = (run) => driver?.run(run) ?? run();
 		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",
+			if (runRuntime(() => runtime.apply(commit.operations, {
+				source: "remote",
 				history: false
-			}), commit);
-			if (local.status !== "committed") throw new LocalSyncConsistencyError("A durable local command was not committed.");
+			})).status !== "committed") throw new LocalSyncConsistencyError("A stored local command could not be applied.");
 			headSeq = commit.seq;
-			return local.commit;
 		};
-		const catchUp = async () => {
+		const restore = async (reset = false) => {
 			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.");
+			if (current.schemaVersion !== schemaVersion) throw new LocalSyncConsistencyError("Local document schema changed while this attachment was open.");
+			if (headSeq > current.headSeq) throw new LocalSyncConsistencyError("The local timeline moved behind this attachment.");
+			if (reset || headSeq < current.checkpointSeq) {
+				if (runRuntime(() => runtime.replace(current.checkpoint, { source: "remote" })).status === "rejected") throw new LocalSyncConsistencyError("The 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 enqueue = (run) => {
 			const next = queued.then(run, run);
-			queued = next.then(() => void 0, () => void 0);
+			queued = next.then(() => void 0, (error) => {
+				fail(error);
+			});
 			return next;
 		};
-		const withWriter = (run) => lockManager.request(`doxum:${documentId}`, { mode: "exclusive" }, async () => {
-			assertOpen();
+		const persist = async (operations) => {
+			const storedCommit = await timeline.append({
+				documentId,
+				expectedHeadSeq: headSeq,
+				operations
+			});
+			if (storedCommit.seq !== headSeq + 1) throw new LocalSyncConsistencyError("A local command was assigned an unexpected sequence.");
+			headSeq = storedCommit.seq;
+			channel?.postMessage({
+				kind: "commit",
+				documentId,
+				headSeq
+			});
+		};
+		const record = (commit) => {
 			try {
-				await catchUp();
+				const operations = jsonArray(commit.operations, "local command operations", input.commandLimits);
+				enqueue(() => persist(operations)).catch(() => void 0);
 			} catch (error) {
 				fail(error);
-				throw error;
 			}
-			return run();
+		};
+		const holdLeadership = () => new Promise((resolve) => {
+			releaseLeadership = resolve;
 		});
-		const persistAndApply = async (input) => {
+		const lead = async (activated) => {
+			if (closing || disposed || fault) return;
+			await restore();
+			if (closing || disposed || fault) return;
+			role = "leader";
+			activated?.();
 			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;
+				await holdLeadership();
+			} finally {
+				releaseLeadership = void 0;
+				if (!closing && !disposed && !fault) role = "follower";
 			}
 		};
-		const replay = (operations) => {
-			const candidate = createDocument({
-				schema: input.schema,
-				initial: documentRuntime.snapshot(),
-				history: false
+		const watchLeadership = () => {
+			leadershipLease = lockManager.request(`doxum:${documentId}`, { mode: "exclusive" }, async () => {
+				try {
+					await lead();
+				} catch (error) {
+					fail(error);
+				}
+			}).catch((error) => {
+				if (!closing && !disposed) fail(error);
 			});
-			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: commandFootprint(preview.commit.operations),
-				history: kind === "undo" ? {
-					kind: "undo",
-					expectedCommandId: entry.commandId,
-					entry
-				} : {
-					kind: "redo",
-					expectedCommandId: entry.commandId,
-					entry
+		const claimInitialLeadership = async () => {
+			let resolve;
+			const claimed = new Promise((done) => {
+				resolve = done;
+			});
+			leadershipLease = lockManager.request(`doxum:${documentId}`, {
+				mode: "exclusive",
+				ifAvailable: true
+			}, async (lock) => {
+				if (lock === null) {
+					resolve(false);
+					return;
 				}
+				try {
+					await lead(() => resolve(true));
+				} catch (error) {
+					fail(error);
+					resolve(false);
+				}
+			}).catch((error) => {
+				if (!closing && !disposed) fail(error);
+				resolve(false);
 			});
+			if (!await claimed && !fault && !closing && !disposed) watchLeadership();
 		};
-		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.");
+		await restore(true);
+		runtime.history.clear();
+		driver = installRuntimeWriteDriver(runtime, { assertWritable: assertLeader });
 		channel = new BroadcastChannel(`doxum:${databaseName}:${documentId}`);
+		unsubscribe = runtime.subscribe((commit) => {
+			if ((commit.source === "local" || commit.source === "system" || commit.source === "history") && !closing && !disposed) record(commit);
+		});
 		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);
+			if (!message || message.documentId !== documentId || message.headSeq <= headSeq || closing || disposed || fault) return;
+			enqueue(restore).catch(() => void 0);
 		};
-		const localDocument = {
-			document: asReadable(documentRuntime),
+		await claimInitialLeadership();
+		if (fault) throw fault;
+		return Object.freeze({
 			state: () => {
 				if (disposed) return { status: "disposed" };
 				if (fault) return {
-					status: "failed",
+					status: "error",
+					headSeq,
+					checkpointSeq,
 					error: fault
 				};
 				return {
-					status: "ready",
+					status: role,
 					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: () => {
+			flush: async () => {
 				assertOpen();
-				return execute(() => withWriter(async () => applyHistory(await timeline.history(documentId, actorId), "undo")));
-			},
-			redo: () => {
+				try {
+					await enqueue(restore);
+				} catch (error) {
+					fail(error);
+					throw error;
+				}
 				assertOpen();
-				return execute(() => withWriter(async () => applyHistory(await timeline.history(documentId, actorId), "redo")));
 			},
 			dispose: async () => {
 				if (disposed) return;
@@ -632,22 +452,25 @@ const openLocalDocument = async (input) => {
 					return;
 				}
 				closing = true;
+				unsubscribe?.();
 				await queued;
+				releaseLeadership?.();
+				if (role === "leader") await leadershipLease;
 				disposed = true;
+				driver?.dispose();
 				channel?.close();
 				timeline.close();
-				documentRuntime.dispose();
 			}
-		};
-		return Object.freeze(localDocument);
+		});
 	} catch (error) {
+		unsubscribe?.();
+		driver?.dispose();
 		channel?.close();
-		runtime?.dispose();
 		timeline.close();
 		throw error;
 	}
 };
 //#endregion
-export { LocalSyncConsistencyError, LocalSyncDataError, LocalSyncDisposedError, LocalSyncSchemaError, LocalSyncUnavailableError, defaultJsonCommandLimits, openLocalDocument };
+export { LocalSyncConsistencyError, LocalSyncDataError, LocalSyncDisposedError, LocalSyncReadOnlyError, LocalSyncSchemaError, LocalSyncUnavailableError, LocalSyncUnsupportedOperationError, attachLocalSync, defaultJsonCommandLimits };
 
 //# sourceMappingURL=local-sync.js.map