doxum 0.1.1 → 0.1.3

package/dist/local-sync.d.cts

@@ -0,0 +1,74 @@
+import { c as DocumentRuntime, xt as DocumentSchema } from "./contract-D8kjdfqT.cjs";
+
+//#region core/src/local-sync/json.d.ts
+type JsonPrimitive = null | boolean | number | string;
+type JsonValue = JsonPrimitive | readonly JsonValue[] | {
+  readonly [key: string]: JsonValue;
+};
+type JsonCommandLimits = {
+  readonly maxOperations?: number;
+  readonly maxBytes?: number;
+  readonly maxDepth?: number;
+  readonly maxStringLength?: number;
+};
+type ResolvedJsonLimits = {
+  readonly maxOperations: number;
+  readonly maxBytes: number;
+  readonly maxDepth: number;
+  readonly maxStringLength: number;
+};
+declare const defaultJsonCommandLimits: Readonly<ResolvedJsonLimits>;
+declare class LocalSyncDataError extends Error {
+  constructor(message: string);
+}
+//#endregion
+//#region core/src/local-sync/contract.d.ts
+declare class LocalSyncUnavailableError extends Error {
+  constructor(capability: 'IndexedDB' | 'Web Locks' | 'BroadcastChannel');
+}
+declare class LocalSyncSchemaError extends Error {
+  constructor(documentId: string, expected: number, actual: number);
+}
+declare class LocalSyncConsistencyError extends Error {
+  constructor(message: string);
+}
+declare class LocalSyncReadOnlyError extends Error {
+  constructor();
+}
+declare class LocalSyncUnsupportedOperationError extends Error {
+  constructor();
+}
+declare class LocalSyncDisposedError extends Error {
+  constructor();
+}
+type LocalSyncState = {
+  readonly status: 'leader' | 'follower';
+  readonly headSeq: number;
+  readonly checkpointSeq: number;
+} | {
+  readonly status: 'error';
+  readonly headSeq: number;
+  readonly checkpointSeq: number;
+  readonly error: unknown;
+} | {
+  readonly status: 'disposed';
+};
+type LocalSync = {
+  state(): LocalSyncState;
+  flush(): Promise<void>;
+  dispose(): Promise<void>;
+};
+type AttachLocalSyncOptions<TSchema extends DocumentSchema> = {
+  readonly runtime: DocumentRuntime<TSchema>;
+  readonly database: string;
+  readonly documentId: string;
+  readonly schemaVersion?: number;
+  readonly commandLimits?: JsonCommandLimits;
+  readonly onError?: (error: unknown) => void;
+};
+//#endregion
+//#region core/src/local-sync/session.d.ts
+declare const attachLocalSync: <TSchema extends DocumentSchema>(input: AttachLocalSyncOptions<TSchema>) => Promise<LocalSync>;
+//#endregion
+export { type AttachLocalSyncOptions, type JsonCommandLimits, type JsonPrimitive, type JsonValue, type LocalSync, LocalSyncConsistencyError, LocalSyncDataError, LocalSyncDisposedError, LocalSyncReadOnlyError, LocalSyncSchemaError, type LocalSyncState, LocalSyncUnavailableError, LocalSyncUnsupportedOperationError, attachLocalSync, defaultJsonCommandLimits };
+//# sourceMappingURL=local-sync.d.cts.map

package/dist/local-sync.d.ts

@@ -0,0 +1,74 @@
+import { c as DocumentRuntime, xt as DocumentSchema } from "./contract-BsY1XLiG.js";
+
+//#region core/src/local-sync/json.d.ts
+type JsonPrimitive = null | boolean | number | string;
+type JsonValue = JsonPrimitive | readonly JsonValue[] | {
+  readonly [key: string]: JsonValue;
+};
+type JsonCommandLimits = {
+  readonly maxOperations?: number;
+  readonly maxBytes?: number;
+  readonly maxDepth?: number;
+  readonly maxStringLength?: number;
+};
+type ResolvedJsonLimits = {
+  readonly maxOperations: number;
+  readonly maxBytes: number;
+  readonly maxDepth: number;
+  readonly maxStringLength: number;
+};
+declare const defaultJsonCommandLimits: Readonly<ResolvedJsonLimits>;
+declare class LocalSyncDataError extends Error {
+  constructor(message: string);
+}
+//#endregion
+//#region core/src/local-sync/contract.d.ts
+declare class LocalSyncUnavailableError extends Error {
+  constructor(capability: 'IndexedDB' | 'Web Locks' | 'BroadcastChannel');
+}
+declare class LocalSyncSchemaError extends Error {
+  constructor(documentId: string, expected: number, actual: number);
+}
+declare class LocalSyncConsistencyError extends Error {
+  constructor(message: string);
+}
+declare class LocalSyncReadOnlyError extends Error {
+  constructor();
+}
+declare class LocalSyncUnsupportedOperationError extends Error {
+  constructor();
+}
+declare class LocalSyncDisposedError extends Error {
+  constructor();
+}
+type LocalSyncState = {
+  readonly status: 'leader' | 'follower';
+  readonly headSeq: number;
+  readonly checkpointSeq: number;
+} | {
+  readonly status: 'error';
+  readonly headSeq: number;
+  readonly checkpointSeq: number;
+  readonly error: unknown;
+} | {
+  readonly status: 'disposed';
+};
+type LocalSync = {
+  state(): LocalSyncState;
+  flush(): Promise<void>;
+  dispose(): Promise<void>;
+};
+type AttachLocalSyncOptions<TSchema extends DocumentSchema> = {
+  readonly runtime: DocumentRuntime<TSchema>;
+  readonly database: string;
+  readonly documentId: string;
+  readonly schemaVersion?: number;
+  readonly commandLimits?: JsonCommandLimits;
+  readonly onError?: (error: unknown) => void;
+};
+//#endregion
+//#region core/src/local-sync/session.d.ts
+declare const attachLocalSync: <TSchema extends DocumentSchema>(input: AttachLocalSyncOptions<TSchema>) => Promise<LocalSync>;
+//#endregion
+export { type AttachLocalSyncOptions, type JsonCommandLimits, type JsonPrimitive, type JsonValue, type LocalSync, LocalSyncConsistencyError, LocalSyncDataError, LocalSyncDisposedError, LocalSyncReadOnlyError, LocalSyncSchemaError, type LocalSyncState, LocalSyncUnavailableError, LocalSyncUnsupportedOperationError, attachLocalSync, defaultJsonCommandLimits };
+//# sourceMappingURL=local-sync.d.ts.map

package/dist/local-sync.js

@@ -0,0 +1,476 @@
+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) {
+		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 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 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 (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 = 2;
+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 = (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(value, label);
+	if (parsed > 0) return parsed;
+	throw new LocalSyncConsistencyError(`${label} is malformed in IndexedDB.`);
+};
+const documentRecord = (value) => {
+	if (!isRecord(value)) throw new LocalSyncConsistencyError("Document record is malformed in IndexedDB.");
+	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"),
+		schemaVersion: positiveInteger$1(value.schemaVersion, "document.schemaVersion"),
+		checkpointSeq,
+		headSeq,
+		checkpoint: json(value.checkpoint, "document.checkpoint")
+	});
+};
+const commitRecord = (value) => {
+	if (!isRecord(value)) throw new LocalSyncConsistencyError("Commit record is malformed in IndexedDB.");
+	return Object.freeze({
+		documentId: string(value.documentId, "commit.documentId"),
+		seq: positiveInteger$1(value.seq, "commit.seq"),
+		operations: jsonArray(value.operations, "commit.operations"),
+		createdAt: nonNegativeInteger(value.createdAt, "commit.createdAt")
+	});
+};
+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.deleteObjectStore(ACTORS);
+		};
+		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));
+		},
+		append: async (input) => {
+			const transaction = database.transaction([DOCUMENTS, COMMITS], "readwrite");
+			const documents = transaction.objectStore(DOCUMENTS);
+			const current = await readDocument(transaction, input.documentId);
+			if (current.headSeq !== input.expectedHeadSeq) throw new LocalSyncConsistencyError("Local document advanced before the leader could append its command.");
+			const commit = {
+				documentId: input.documentId,
+				seq: current.headSeq + 1,
+				operations: input.operations,
+				createdAt: Date.now()
+			};
+			documents.put({
+				...current,
+				headSeq: commit.seq
+			});
+			transaction.objectStore(COMMITS).put(commit);
+			await complete(transaction);
+			return Object.freeze(commit);
+		},
+		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 positiveInteger = (value, label) => {
+	if (Number.isSafeInteger(value) && value > 0) return value;
+	throw new TypeError(`${label} must be a positive safe integer.`);
+};
+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.headSeq !== "number" || !Number.isSafeInteger(record.headSeq) || record.headSeq < 0) return void 0;
+	return record;
+};
+const attachLocalSync = async (input) => {
+	const runtime = input.runtime;
+	const databaseName = requiredString(input.database, "database");
+	const documentId = requiredString(input.documentId, "documentId");
+	const schemaVersion = positiveInteger(input.schemaVersion ?? 1, "schemaVersion");
+	const lockManager = locks();
+	const BroadcastChannel = channelConstructor();
+	const timeline = await openIndexedDbTimeline(databaseName);
+	let channel;
+	let unsubscribe;
+	let driver;
+	try {
+		const stored = await timeline.initialize(documentId, schemaVersion, json(runtime.snapshot(), "runtime snapshot"));
+		let headSeq = stored.checkpointSeq;
+		let checkpointSeq = stored.checkpointSeq;
+		let role = "follower";
+		let fault;
+		let closing = false;
+		let disposed = false;
+		let releaseLeadership;
+		let leadershipLease;
+		let queued = Promise.resolve();
+		const fail = (error) => {
+			if (fault || disposed) return;
+			fault = error;
+			try {
+				input.onError?.(error);
+			} catch {}
+		};
+		const assertOpen = () => {
+			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.");
+			if (runRuntime(() => runtime.apply(commit.operations, {
+				source: "remote",
+				history: false
+			})).status !== "committed") throw new LocalSyncConsistencyError("A stored local command could not be applied.");
+			headSeq = commit.seq;
+		};
+		const restore = async (reset = false) => {
+			const current = await timeline.read(documentId);
+			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;
+			}
+			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 enqueue = (run) => {
+			const next = queued.then(run, run);
+			queued = next.then(() => void 0, (error) => {
+				fail(error);
+			});
+			return next;
+		};
+		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 {
+				const operations = jsonArray(commit.operations, "local command operations", input.commandLimits);
+				enqueue(() => persist(operations)).catch(() => void 0);
+			} catch (error) {
+				fail(error);
+			}
+		};
+		const holdLeadership = () => new Promise((resolve) => {
+			releaseLeadership = resolve;
+		});
+		const lead = async (activated) => {
+			if (closing || disposed || fault) return;
+			await restore();
+			if (closing || disposed || fault) return;
+			role = "leader";
+			activated?.();
+			try {
+				await holdLeadership();
+			} finally {
+				releaseLeadership = void 0;
+				if (!closing && !disposed && !fault) role = "follower";
+			}
+		};
+		const watchLeadership = () => {
+			leadershipLease = lockManager.request(`doxum:${documentId}`, { mode: "exclusive" }, async () => {
+				try {
+					await lead();
+				} catch (error) {
+					fail(error);
+				}
+			}).catch((error) => {
+				if (!closing && !disposed) fail(error);
+			});
+		};
+		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();
+		};
+		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.headSeq <= headSeq || closing || disposed || fault) return;
+			enqueue(restore).catch(() => void 0);
+		};
+		await claimInitialLeadership();
+		if (fault) throw fault;
+		return Object.freeze({
+			state: () => {
+				if (disposed) return { status: "disposed" };
+				if (fault) return {
+					status: "error",
+					headSeq,
+					checkpointSeq,
+					error: fault
+				};
+				return {
+					status: role,
+					headSeq,
+					checkpointSeq
+				};
+			},
+			flush: async () => {
+				assertOpen();
+				try {
+					await enqueue(restore);
+				} catch (error) {
+					fail(error);
+					throw error;
+				}
+				assertOpen();
+			},
+			dispose: async () => {
+				if (disposed) return;
+				if (closing) {
+					await queued;
+					return;
+				}
+				closing = true;
+				unsubscribe?.();
+				await queued;
+				releaseLeadership?.();
+				if (role === "leader") await leadershipLease;
+				disposed = true;
+				driver?.dispose();
+				channel?.close();
+				timeline.close();
+			}
+		});
+	} catch (error) {
+		unsubscribe?.();
+		driver?.dispose();
+		channel?.close();
+		timeline.close();
+		throw error;
+	}
+};
+//#endregion
+export { LocalSyncConsistencyError, LocalSyncDataError, LocalSyncDisposedError, LocalSyncReadOnlyError, LocalSyncSchemaError, LocalSyncUnavailableError, LocalSyncUnsupportedOperationError, attachLocalSync, defaultJsonCommandLimits };
+
+//# sourceMappingURL=local-sync.js.map