doxum 0.1.23 → 0.1.26

package/dist/local-sync.d.cts

@@ -1,4 +1,4 @@
-import { K as ObjectNode, c as DocumentRuntime, g as Readable } from "./contract-SYJFP0lM.cjs";
+import { W as ObjectSchema, g as Readable, s as DocumentRuntime } from "./contract-CNR6BS75.cjs";
 
 //#region core/src/local-sync/json.d.ts
 type JsonPrimitive = null | boolean | number | string;
@@ -18,29 +18,17 @@ type ResolvedJsonLimits = {
   readonly maxStringLength: number;
 };
 declare const defaultJsonChangeLimits: Readonly<ResolvedJsonLimits>;
-declare class LocalSyncDataError extends Error {
-  constructor(message: string);
+//#endregion
+//#region core/src/local-sync/error.d.ts
+type LocalSyncErrorCode = 'unavailable' | 'schema-mismatch' | 'consistency' | 'read-only' | 'unsupported-operation' | 'disposed' | 'invalid-data';
+declare class LocalSyncError extends Error {
+  readonly code: LocalSyncErrorCode;
+  constructor(code: LocalSyncErrorCode, message: string, options?: {
+    readonly cause?: unknown;
+  });
 }
 //#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;
@@ -49,7 +37,7 @@ type LocalSyncState = {
   readonly status: 'error';
   readonly headSeq: number;
   readonly checkpointSeq: number;
-  readonly error: unknown;
+  readonly error: LocalSyncError;
 } | {
   readonly status: 'disposed';
 };
@@ -58,17 +46,17 @@ type LocalSync = {
   flush(): Promise<void>;
   dispose(): Promise<void>;
 };
-type AttachLocalSyncOptions<TSchema extends ObjectNode> = {
+type AttachLocalSyncOptions<TSchema extends ObjectSchema<object>> = {
   readonly runtime: DocumentRuntime<TSchema>;
   readonly database: string;
   readonly documentId: string;
   readonly schemaVersion?: number; /** Admission limits for new local commits; durable replay does not reapply them. */
   readonly changeLimits?: JsonChangeLimits;
-  readonly onError?: (error: unknown) => void;
+  readonly onError?: (error: LocalSyncError) => void;
 };
 //#endregion
 //#region core/src/local-sync/session.d.ts
-declare const attachLocalSync: <TSchema extends ObjectNode>(input: AttachLocalSyncOptions<TSchema>) => Promise<LocalSync>;
+declare const attachLocalSync: <TSchema extends ObjectSchema<object>>(input: AttachLocalSyncOptions<TSchema>) => Promise<LocalSync>;
 //#endregion
-export { type AttachLocalSyncOptions, type JsonChangeLimits, type JsonPrimitive, type JsonValue, type LocalSync, LocalSyncConsistencyError, LocalSyncDataError, LocalSyncDisposedError, LocalSyncReadOnlyError, LocalSyncSchemaError, type LocalSyncState, LocalSyncUnavailableError, LocalSyncUnsupportedOperationError, attachLocalSync, defaultJsonChangeLimits };
+export { type AttachLocalSyncOptions, type JsonChangeLimits, type JsonPrimitive, type JsonValue, type LocalSync, LocalSyncError, type LocalSyncErrorCode, type LocalSyncState, attachLocalSync, defaultJsonChangeLimits };
 //# sourceMappingURL=local-sync.d.cts.map

package/dist/local-sync.d.ts

@@ -1,4 +1,4 @@
-import { K as ObjectNode, c as DocumentRuntime, g as Readable } from "./contract-ULPQmiEs.js";
+import { W as ObjectSchema, g as Readable, s as DocumentRuntime } from "./contract-COgxO5sv.js";
 
 //#region core/src/local-sync/json.d.ts
 type JsonPrimitive = null | boolean | number | string;
@@ -18,29 +18,17 @@ type ResolvedJsonLimits = {
   readonly maxStringLength: number;
 };
 declare const defaultJsonChangeLimits: Readonly<ResolvedJsonLimits>;
-declare class LocalSyncDataError extends Error {
-  constructor(message: string);
+//#endregion
+//#region core/src/local-sync/error.d.ts
+type LocalSyncErrorCode = 'unavailable' | 'schema-mismatch' | 'consistency' | 'read-only' | 'unsupported-operation' | 'disposed' | 'invalid-data';
+declare class LocalSyncError extends Error {
+  readonly code: LocalSyncErrorCode;
+  constructor(code: LocalSyncErrorCode, message: string, options?: {
+    readonly cause?: unknown;
+  });
 }
 //#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;
@@ -49,7 +37,7 @@ type LocalSyncState = {
   readonly status: 'error';
   readonly headSeq: number;
   readonly checkpointSeq: number;
-  readonly error: unknown;
+  readonly error: LocalSyncError;
 } | {
   readonly status: 'disposed';
 };
@@ -58,17 +46,17 @@ type LocalSync = {
   flush(): Promise<void>;
   dispose(): Promise<void>;
 };
-type AttachLocalSyncOptions<TSchema extends ObjectNode> = {
+type AttachLocalSyncOptions<TSchema extends ObjectSchema<object>> = {
   readonly runtime: DocumentRuntime<TSchema>;
   readonly database: string;
   readonly documentId: string;
   readonly schemaVersion?: number; /** Admission limits for new local commits; durable replay does not reapply them. */
   readonly changeLimits?: JsonChangeLimits;
-  readonly onError?: (error: unknown) => void;
+  readonly onError?: (error: LocalSyncError) => void;
 };
 //#endregion
 //#region core/src/local-sync/session.d.ts
-declare const attachLocalSync: <TSchema extends ObjectNode>(input: AttachLocalSyncOptions<TSchema>) => Promise<LocalSync>;
+declare const attachLocalSync: <TSchema extends ObjectSchema<object>>(input: AttachLocalSyncOptions<TSchema>) => Promise<LocalSync>;
 //#endregion
-export { type AttachLocalSyncOptions, type JsonChangeLimits, type JsonPrimitive, type JsonValue, type LocalSync, LocalSyncConsistencyError, LocalSyncDataError, LocalSyncDisposedError, LocalSyncReadOnlyError, LocalSyncSchemaError, type LocalSyncState, LocalSyncUnavailableError, LocalSyncUnsupportedOperationError, attachLocalSync, defaultJsonChangeLimits };
+export { type AttachLocalSyncOptions, type JsonChangeLimits, type JsonPrimitive, type JsonValue, type LocalSync, LocalSyncError, type LocalSyncErrorCode, type LocalSyncState, attachLocalSync, defaultJsonChangeLimits };
 //# sourceMappingURL=local-sync.d.ts.map

package/dist/local-sync.js

@@ -1,42 +1,15 @@
-import { d as isRecord, u as isPlainObject } from "./context-DFEaDUv5.js";
-import { i as decodeChanges, n as installRuntimeWriteDriver, r as changeCount } from "./driver-yFfvDMX5.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 appends committed changes. runtime.replace() and externally supplied remote changes are unavailable while it is attached.");
-		this.name = "LocalSyncUnsupportedOperationError";
-	}
-};
-var LocalSyncDisposedError = class extends Error {
-	constructor() {
-		super("Local sync has been disposed.");
-		this.name = "LocalSyncDisposedError";
+import { n as isPlainObject, r as isRecord } from "./record-B2yRhYsc.js";
+import { a as changeCount, n as installRuntimeWriteDriver, o as decodeChanges } from "./driver-B5vdPohL.js";
+//#region core/src/local-sync/error.ts
+var LocalSyncError = class extends Error {
+	code;
+	constructor(code, message, options) {
+		super(message, options);
+		this.name = "LocalSyncError";
+		this.code = code;
 	}
 };
+const normalizeLocalSyncError = (error, code, message) => error instanceof LocalSyncError ? error : new LocalSyncError(code, message, { cause: error });
 //#endregion
 //#region core/src/local-sync/json.ts
 const defaultJsonChangeLimits = Object.freeze({
@@ -45,12 +18,6 @@ const defaultJsonChangeLimits = Object.freeze({
 	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;
@@ -64,18 +31,18 @@ const resolveLimits = (input) => ({
 	maxStringLength: limit(input?.maxStringLength, defaultJsonChangeLimits.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 (limits && depth > limits.maxDepth) throw new LocalSyncError("invalid-data", `${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.`);
+		throw new LocalSyncError("invalid-data", `${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.`);
+		throw new LocalSyncError("invalid-data", `${describePath(path)} contains a non-finite number.`);
 	}
 	if (Array.isArray(value)) {
-		if (ancestors.has(value)) throw new LocalSyncDataError(`${describePath(path)} contains a cycle.`);
+		if (ancestors.has(value)) throw new LocalSyncError("invalid-data", `${describePath(path)} contains a cycle.`);
 		ancestors.add(value);
 		try {
 			for (let index = 0; index < value.length; index += 1) {
@@ -89,7 +56,7 @@ const validate = (value, path, limits, depth, ancestors) => {
 		return value;
 	}
 	if (isPlainObject(value)) {
-		if (ancestors.has(value)) throw new LocalSyncDataError(`${describePath(path)} contains a cycle.`);
+		if (ancestors.has(value)) throw new LocalSyncError("invalid-data", `${describePath(path)} contains a cycle.`);
 		ancestors.add(value);
 		try {
 			for (const key of Object.keys(value)) {
@@ -102,7 +69,7 @@ const validate = (value, path, limits, depth, ancestors) => {
 		}
 		return value;
 	}
-	throw new LocalSyncDataError(`${describePath(path)} must be JSON data.`);
+	throw new LocalSyncError("invalid-data", `${describePath(path)} must be JSON data.`);
 };
 const json = (value, label) => validate(value, [label], void 0, 0, /* @__PURE__ */ new WeakSet());
 const jsonChanges = (value, label, input) => {
@@ -111,13 +78,13 @@ const jsonChanges = (value, label, input) => {
 	try {
 		changes = decodeChanges(value);
 	} catch {
-		throw new LocalSyncDataError(`${label} contains an invalid ChangeSet.`);
+		throw new LocalSyncError("invalid-data", `${label} contains an invalid ChangeSet.`);
 	}
-	if (limits && changeCount(changes) > limits.maxChanges) throw new LocalSyncDataError(`${label} exceeds the maximum change count.`);
+	if (limits && changeCount(changes) > limits.maxChanges) throw new LocalSyncError("invalid-data", `${label} exceeds the maximum change count.`);
 	validate(changes.changes, [label], limits, 0, /* @__PURE__ */ new WeakSet());
 	if (limits) {
 		const serialized = JSON.stringify(changes.changes);
-		if (new TextEncoder().encode(serialized).byteLength > limits.maxBytes) throw new LocalSyncDataError(`${label} exceeds the maximum ChangeSet size.`);
+		if (new TextEncoder().encode(serialized).byteLength > limits.maxBytes) throw new LocalSyncError("invalid-data", `${label} exceeds the maximum ChangeSet size.`);
 	}
 	return changes;
 };
@@ -129,39 +96,39 @@ const DOCUMENTS = "documents";
 const COMMITS = "commits";
 const request = (value) => new Promise((resolve, reject) => {
 	value.onsuccess = () => resolve(value.result);
-	value.onerror = () => reject(value.error ?? /* @__PURE__ */ new Error("IndexedDB request failed."));
+	value.onerror = () => reject(normalizeLocalSyncError(value.error, "unavailable", "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."));
+	transaction.onabort = () => reject(normalizeLocalSyncError(transaction.error, "unavailable", "IndexedDB transaction was aborted."));
+	transaction.onerror = () => reject(normalizeLocalSyncError(transaction.error, "unavailable", "IndexedDB transaction failed."));
 });
 const factory = () => {
-	if (!globalThis.indexedDB) throw new LocalSyncUnavailableError("IndexedDB");
+	if (!globalThis.indexedDB) throw new LocalSyncError("unavailable", "IndexedDB is required by doxum/local-sync in this environment.");
 	return globalThis.indexedDB;
 };
 const keyRange = () => {
-	if (!globalThis.IDBKeyRange) throw new LocalSyncUnavailableError("IndexedDB");
+	if (!globalThis.IDBKeyRange) throw new LocalSyncError("unavailable", "IndexedDB is required by doxum/local-sync in this environment.");
 	return globalThis.IDBKeyRange;
 };
 const string = (value, label) => {
 	if (typeof value === "string") return value;
-	throw new LocalSyncConsistencyError(`${label} is malformed in IndexedDB.`);
+	throw new LocalSyncError("consistency", `${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.`);
+	throw new LocalSyncError("consistency", `${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.`);
+	throw new LocalSyncError("consistency", `${label} is malformed in IndexedDB.`);
 };
 const documentRecord = (value) => {
-	if (!isRecord(value) || value.formatVersion !== FORMAT_VERSION) throw new LocalSyncConsistencyError("Document record is malformed in IndexedDB.");
+	if (!isRecord(value) || value.formatVersion !== FORMAT_VERSION) throw new LocalSyncError("consistency", "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.");
+	if (checkpointSeq > headSeq) throw new LocalSyncError("consistency", "Document checkpoint exceeds its head sequence.");
 	return Object.freeze({
 		formatVersion: FORMAT_VERSION,
 		documentId: string(value.documentId, "document.documentId"),
@@ -172,7 +139,7 @@ const documentRecord = (value) => {
 	});
 };
 const commitRecord = (value) => {
-	if (!isRecord(value) || value.formatVersion !== FORMAT_VERSION) throw new LocalSyncConsistencyError("Commit record is malformed in IndexedDB.");
+	if (!isRecord(value) || value.formatVersion !== FORMAT_VERSION) throw new LocalSyncError("consistency", "Commit record is malformed in IndexedDB.");
 	return Object.freeze({
 		formatVersion: FORMAT_VERSION,
 		documentId: string(value.documentId, "commit.documentId"),
@@ -185,7 +152,7 @@ const openIndexedDbTimeline = async (databaseName) => {
 	const database = await new Promise((resolve, reject) => {
 		let incompatible = false;
 		const open = factory().open(databaseName, DATABASE_VERSION);
-		open.onerror = () => reject(incompatible ? new LocalSyncConsistencyError("Unsupported Doxum storage format. Existing data was left unchanged.") : open.error ?? /* @__PURE__ */ new Error("Unable to open IndexedDB."));
+		open.onerror = () => reject(incompatible ? new LocalSyncError("consistency", "Unsupported Doxum storage format. Existing data was left unchanged.") : open.error ?? /* @__PURE__ */ new Error("Unable to open IndexedDB."));
 		open.onblocked = () => reject(/* @__PURE__ */ new Error(`IndexedDB database '${databaseName}' is blocked.`));
 		open.onupgradeneeded = (event) => {
 			if (event.oldVersion !== 0) {
@@ -201,7 +168,7 @@ const openIndexedDbTimeline = async (databaseName) => {
 	});
 	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.`);
+		if (value === void 0) throw new LocalSyncError("consistency", `Local document '${documentId}' does not exist.`);
 		return documentRecord(value);
 	};
 	return {
@@ -211,7 +178,7 @@ const openIndexedDbTimeline = async (databaseName) => {
 			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);
+				if (record.schemaVersion !== schemaVersion) throw new LocalSyncError("schema-mismatch", `Local document '${documentId}' uses schema version ${record.schemaVersion}, but version ${schemaVersion} was requested.`);
 				await complete(transaction);
 				return record;
 			}
@@ -244,7 +211,7 @@ const openIndexedDbTimeline = async (databaseName) => {
 			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 commit.");
+			if (current.headSeq !== input.expectedHeadSeq) throw new LocalSyncError("consistency", "Local document advanced before the leader could append its commit.");
 			const commit = {
 				formatVersion: FORMAT_VERSION,
 				documentId: input.documentId,
@@ -270,12 +237,12 @@ const openIndexedDbTimeline = async (databaseName) => {
 //#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");
+	if (typeof value !== "object" || value === null || !("request" in value) || typeof value.request !== "function") throw new LocalSyncError("unavailable", "Web Locks is required by doxum/local-sync in this environment.");
 	return value;
 };
 const channelConstructor = () => {
 	const value = globalThis.BroadcastChannel;
-	if (typeof value !== "function") throw new LocalSyncUnavailableError("BroadcastChannel");
+	if (typeof value !== "function") throw new LocalSyncError("unavailable", "BroadcastChannel is required by doxum/local-sync in this environment.");
 	return value;
 };
 const requiredString = (value, label) => {
@@ -299,7 +266,9 @@ const attachLocalSync = async (input) => {
 	const schemaVersion = positiveInteger(input.schemaVersion ?? 1, "schemaVersion");
 	const lockManager = locks();
 	const BroadcastChannel = channelConstructor();
-	const timeline = await openIndexedDbTimeline(databaseName);
+	const timeline = await openIndexedDbTimeline(databaseName).catch((error) => {
+		throw normalizeLocalSyncError(error, "unavailable", "Unable to open local sync storage.");
+	});
 	let channel;
 	let unsubscribe;
 	let driver;
@@ -339,51 +308,55 @@ const attachLocalSync = async (input) => {
 				if (!stateListeners.has(listener)) continue;
 				try {
 					listener();
-				} catch (error) {
-					try {
-						input.onError?.(error);
-					} catch {}
-				}
+				} catch {}
 			}
 		};
 		const fail = (error) => {
-			if (fault || disposed) return;
-			fault = error;
+			const failure = normalizeLocalSyncError(error, "unavailable", "Local synchronization failed.");
+			if (fault || disposed) return fault ?? failure;
+			fault = failure;
 			publishState();
 			try {
-				input.onError?.(error);
+				input.onError?.(failure);
 			} catch {}
+			return failure;
 		};
 		const assertOpen = () => {
-			if (closing || disposed) throw new LocalSyncDisposedError();
+			if (closing || disposed) throw new LocalSyncError("disposed", "Local sync has been disposed.");
 			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();
+			if (role !== "leader") throw new LocalSyncError("read-only", "This tab is following the local document and cannot write until it becomes the leader.");
+			if (intent.kind === "replace" || intent.kind === "apply" && intent.source === "remote") throw new LocalSyncError("unsupported-operation", "Local sync appends committed changes. runtime.replace() and externally supplied remote changes are unavailable while it is attached.");
 		};
 		const runRuntime = (run) => driver?.run(run) ?? run();
+		const replayRuntime = (run, message) => {
+			try {
+				return runRuntime(run);
+			} catch (error) {
+				throw normalizeLocalSyncError(error, "consistency", message);
+			}
+		};
 		const applyStored = (commit) => {
-			if (commit.seq !== headSeq + 1) throw new LocalSyncConsistencyError("Local commit log contains a sequence gap.");
-			if (runRuntime(() => runtime.apply(commit.changes, {
+			if (commit.seq !== headSeq + 1) throw new LocalSyncError("consistency", "Local commit log contains a sequence gap.");
+			if (replayRuntime(() => runtime.apply(commit.changes, {
 				expectedRevision: runtime.revision(),
-				source: "remote",
-				history: false
-			})).status !== "committed") throw new LocalSyncConsistencyError("A stored local ChangeSet could not be applied.");
+				source: "remote"
+			}), "A stored local ChangeSet could not be replayed.").status !== "committed") throw new LocalSyncError("consistency", "A stored local ChangeSet 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 (current.schemaVersion !== schemaVersion) throw new LocalSyncError("consistency", "Local document schema changed while this attachment was open.");
+			if (headSeq > current.headSeq) throw new LocalSyncError("consistency", "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.");
+				if (replayRuntime(() => runtime.replace(current.checkpoint, { source: "remote" }), "The local checkpoint could not be restored.").status === "rejected") throw new LocalSyncError("consistency", "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.");
+			if (headSeq !== current.headSeq) throw new LocalSyncError("consistency", "Local commit log does not reach its recorded head sequence.");
 			checkpointSeq = current.checkpointSeq;
 			publishState();
 		};
@@ -400,7 +373,7 @@ const attachLocalSync = async (input) => {
 				expectedHeadSeq: headSeq,
 				changes
 			});
-			if (storedCommit.seq !== headSeq + 1) throw new LocalSyncConsistencyError("A local commit was assigned an unexpected sequence.");
+			if (storedCommit.seq !== headSeq + 1) throw new LocalSyncError("consistency", "A local commit was assigned an unexpected sequence.");
 			headSeq = storedCommit.seq;
 			publishState();
 			channel?.postMessage({
@@ -492,7 +465,7 @@ const attachLocalSync = async (input) => {
 				current: () => snapshot,
 				revision: () => stateRevision,
 				subscribe: (listener) => {
-					if (disposed) throw new LocalSyncDisposedError();
+					if (disposed) throw new LocalSyncError("disposed", "Local sync has been disposed.");
 					stateListeners.add(listener);
 					return () => {
 						stateListeners.delete(listener);
@@ -504,8 +477,7 @@ const attachLocalSync = async (input) => {
 				try {
 					await enqueue(restore);
 				} catch (error) {
-					fail(error);
-					throw error;
+					throw fail(error);
 				}
 				assertOpen();
 			},
@@ -534,10 +506,10 @@ const attachLocalSync = async (input) => {
 		driver?.dispose();
 		channel?.close();
 		timeline.close();
-		throw error;
+		throw normalizeLocalSyncError(error, "unavailable", "Unable to attach local sync.");
 	}
 };
 //#endregion
-export { LocalSyncConsistencyError, LocalSyncDataError, LocalSyncDisposedError, LocalSyncReadOnlyError, LocalSyncSchemaError, LocalSyncUnavailableError, LocalSyncUnsupportedOperationError, attachLocalSync, defaultJsonChangeLimits };
+export { LocalSyncError, attachLocalSync, defaultJsonChangeLimits };
 
 //# sourceMappingURL=local-sync.js.map