@trestleinc/replicate 1.2.0-preview.1 → 1.2.0-preview.2

package/dist/client/index.d.ts

@@ -117,6 +117,13 @@ declare class NonRetriableError extends Error {
 //#region src/client/services/seq.d.ts
 type Seq = number;
 //#endregion
+//#region src/client/services/awareness.d.ts
+interface UserIdentity {
+  name?: string;
+  color?: string;
+  avatar?: string;
+}
+//#endregion
 //#region src/shared/types.d.ts
 /** ProseMirror-compatible JSON for XmlFragment serialization */
 interface XmlFragmentJSON {
@@ -206,16 +213,11 @@ interface EditorBinding {
   /** Cleanup - call when unmounting editor */
   destroy(): void;
 }
-/** Utilities exposed on collection.utils */
+interface ProseOptions {
+  user?: UserIdentity;
+}
 interface ConvexCollectionUtils<T extends object> {
-  /**
-   * Get an editor binding for a prose field.
-   * Waits for Y.Doc to be ready (IndexedDB loaded) before returning.
-   * @param document - The document ID
-   * @param field - The prose field name (must be in `prose` config)
-   * @returns Promise resolving to EditorBinding
-   */
-  prose(document: string, field: ProseFields<T>): Promise<EditorBinding>;
+  prose(document: string, field: ProseFields<T>, options?: ProseOptions): Promise<EditorBinding>;
 }
 type LazyCollectionConfig<TSchema extends z.ZodObject<z.ZodRawShape>> = Omit<ConvexCollectionConfig<z.infer<TSchema>, TSchema, string>, "persistence" | "material">;
 interface LazyCollection<T extends object> {
@@ -262,23 +264,6 @@ declare namespace prose$1 {
  */
 declare function memoryPersistence(): Persistence;
 //#endregion
-//#region src/client/persistence/sqlite/browser.d.ts
-interface SqlJsDatabase {
-  run(sql: string, params?: unknown): unknown;
-  prepare(sql: string): {
-    bind(params?: unknown): void;
-    step(): boolean;
-    getAsObject(): Record<string, unknown>;
-    free(): void;
-  };
-  export(): Uint8Array;
-  close(): void;
-}
-interface SqlJsStatic {
-  Database: new (data?: ArrayLike<number> | Buffer | null) => SqlJsDatabase;
-}
-declare function createBrowserSqlitePersistence(SQL: SqlJsStatic, dbName: string): Promise<Persistence>;
-//#endregion
 //#region src/client/persistence/sqlite/native.d.ts
 interface OPSQLiteDatabase {
   execute(sql: string, params?: unknown[]): Promise<{
@@ -288,20 +273,52 @@ interface OPSQLiteDatabase {
 }
 declare function createNativeSqlitePersistence(db: OPSQLiteDatabase, _dbName: string): Promise<Persistence>;
 //#endregion
-//#region src/client/persistence/indexeddb.d.ts
-declare function createIndexedDBPersistence(dbName: string): Promise<Persistence>;
-//#endregion
 //#region src/client/persistence/custom.d.ts
 declare function createCustomPersistence(adapter: StorageAdapter): Persistence;
 //#endregion
+//#region src/client/persistence/pglite.d.ts
+interface PGliteInterface {
+  query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<{
+    rows: T[];
+  }>;
+  exec(sql: string): Promise<unknown>;
+  close(): Promise<void>;
+}
+declare function createPGlitePersistence(pg: PGliteInterface): Promise<Persistence>;
+/**
+ * Creates a singleton PGlite persistence factory.
+ * Use this to ensure the PGlite WASM module is only loaded once,
+ * even when shared across multiple collections.
+ *
+ * @example
+ * ```typescript
+ * // src/lib/pglite.ts
+ * import { persistence } from "@trestleinc/replicate/client";
+ *
+ * export const pglite = persistence.pglite.once(async () => {
+ *   const { PGlite } = await import("@electric-sql/pglite");
+ *   const { live } = await import("@electric-sql/pglite/live");
+ *   return PGlite.create({ dataDir: "idb://app", extensions: { live } });
+ * });
+ *
+ * // src/collections/useIntervals.ts
+ * import { pglite } from "$lib/pglite";
+ *
+ * export const intervals = collection.create({
+ *   persistence: pglite,
+ *   config: () => ({ ... }),
+ * });
+ * ```
+ */
+declare function oncePGlitePersistence(factory: () => Promise<PGliteInterface>): () => Promise<Persistence>;
+//#endregion
 //#region src/client/persistence/index.d.ts
 declare const persistence: {
-  readonly memory: typeof memoryPersistence;
-  readonly sqlite: {
-    readonly browser: typeof createBrowserSqlitePersistence;
-    readonly native: typeof createNativeSqlitePersistence;
+  readonly pglite: typeof createPGlitePersistence & {
+    once: typeof oncePGlitePersistence;
   };
-  readonly indexeddb: typeof createIndexedDBPersistence;
+  readonly sqlite: typeof createNativeSqlitePersistence;
+  readonly memory: typeof memoryPersistence;
   readonly custom: typeof createCustomPersistence;
 };
 //#endregion
@@ -319,4 +336,4 @@ declare const prose: typeof prose$1 & {
   extract: typeof extract;
 };
 //#endregion
-export { type ConvexCollection, type EditorBinding, type Materialized, type Persistence, type Seq, type StorageAdapter, collection, errors, persistence, prose };
+export { type ConvexCollection, type EditorBinding, type Materialized, type Persistence, type ProseOptions, type Seq, type StorageAdapter, type UserIdentity, collection, errors, persistence, prose };

package/dist/client/index.js

@@ -3090,8 +3090,9 @@ const DEFAULT_THROTTLE_MS = 50;
 * Compatible with TipTap's CollaborationCursor and BlockNote's collaboration.
 */
 function createAwarenessProvider(config$1) {
-	const { convexClient, api, document, client, ydoc, interval = DEFAULT_HEARTBEAT_INTERVAL, syncReady } = config$1;
+	const { convexClient, api, document, client, ydoc, interval = DEFAULT_HEARTBEAT_INTERVAL, syncReady, user } = config$1;
 	const awareness = new Awareness(ydoc);
+	if (user) awareness.setLocalStateField("user", user);
 	let destroyed = false;
 	let visible = true;
 	let heartbeatTimer = null;
@@ -3126,25 +3127,27 @@ function createAwarenessProvider(config$1) {
 	*/
 	const extractUserFromState = (state) => {
 		if (!state) return {};
-		const user = state.user;
-		if (user) return { profile: {
-			name: user.name,
-			color: user.color,
-			avatar: user.avatar
-		} };
+		const user$1 = state.user;
+		if (user$1) {
+			const profile = {};
+			if (typeof user$1.name === "string") profile.name = user$1.name;
+			if (typeof user$1.color === "string") profile.color = user$1.color;
+			if (typeof user$1.avatar === "string") profile.avatar = user$1.avatar;
+			if (Object.keys(profile).length > 0) return { profile };
+		}
 		return {};
 	};
 	const sendToServer = () => {
 		if (destroyed || !visible) return;
 		const localState = awareness.getLocalState();
 		const cursor = extractCursorFromState(localState);
-		const { user, profile } = extractUserFromState(localState);
+		const { user: user$1, profile } = extractUserFromState(localState);
 		const vector = getVector();
 		convexClient.mutation(api.mark, {
 			document,
 			client,
 			cursor,
-			user,
+			user: user$1,
 			profile,
 			interval,
 			vector
@@ -3185,8 +3188,8 @@ function createAwarenessProvider(config$1) {
 					remoteClientIds.set(remote.client, remoteClientId);
 				}
 				const remoteState = { user: {
-					name: remote.profile?.name ?? remote.user ?? "Anonymous",
-					color: remote.profile?.color ?? getColorForClient(remote.client),
+					name: remote.profile?.name ?? remote.user ?? getStableAnonName(remote.client),
+					color: remote.profile?.color ?? getStableAnonColor(remote.client),
 					avatar: remote.profile?.avatar,
 					clientId: remote.client
 				} };
@@ -3300,9 +3303,6 @@ function createAwarenessProvider(config$1) {
 		}
 	};
 }
-/**
-* Hash a string to a positive number for use as clientId.
-*/
 function hashStringToNumber(str) {
 	let hash = 0;
 	for (let i = 0; i < str.length; i++) {
@@ -3312,22 +3312,48 @@ function hashStringToNumber(str) {
 	}
 	return Math.abs(hash);
 }
-/**
-* Generate a color for a client based on their ID.
-*/
-const DEFAULT_COLORS = [
-	"#F87171",
-	"#FB923C",
-	"#FBBF24",
-	"#A3E635",
-	"#34D399",
-	"#22D3EE",
-	"#60A5FA",
-	"#A78BFA",
-	"#F472B6"
+const ANONYMOUS_ADJECTIVES = [
+	"Swift",
+	"Bright",
+	"Calm",
+	"Bold",
+	"Keen",
+	"Quick",
+	"Warm",
+	"Cool",
+	"Sharp",
+	"Gentle"
 ];
-function getColorForClient(clientId) {
-	return DEFAULT_COLORS[hashStringToNumber(clientId) % DEFAULT_COLORS.length];
+const ANONYMOUS_NOUNS = [
+	"Fox",
+	"Owl",
+	"Bear",
+	"Wolf",
+	"Hawk",
+	"Deer",
+	"Lynx",
+	"Crow",
+	"Hare",
+	"Seal"
+];
+const ANONYMOUS_COLORS = [
+	"#9F5944",
+	"#A9704D",
+	"#B08650",
+	"#8A7D3F",
+	"#6E7644",
+	"#8C4A42",
+	"#9E7656",
+	"#9A5240",
+	"#987C4A",
+	"#7A8B6E"
+];
+function getStableAnonName(clientId) {
+	const hash = hashStringToNumber(clientId);
+	return `${ANONYMOUS_ADJECTIVES[hash % ANONYMOUS_ADJECTIVES.length]} ${ANONYMOUS_NOUNS[(hash >> 4) % ANONYMOUS_NOUNS.length]}`;
+}
+function getStableAnonColor(clientId) {
+	return ANONYMOUS_COLORS[(hashStringToNumber(clientId) >> 8) % ANONYMOUS_COLORS.length];
 }
 
 //#endregion
@@ -3352,7 +3378,7 @@ function convexCollectionOptions(config$1) {
 	if (!collection$1) throw new Error("Could not extract collection name from api.stream function reference");
 	const proseFields = schema && schema instanceof ZodObject ? extractProseFields(schema) : [];
 	const proseFieldSet = new Set(proseFields);
-	const utils = { async prose(document, field) {
+	const utils = { async prose(document, field, options) {
 		const fieldStr = field;
 		if (!proseFieldSet.has(fieldStr)) throw new ProseError({
 			document,
@@ -3423,7 +3449,8 @@ function convexCollectionOptions(config$1) {
 			document,
 			client: storedClientId,
 			ydoc: subdoc,
-			syncReady: ctx.synced
+			syncReady: ctx.synced,
+			user: options?.user
 		});
 		return {
 			fragment,
@@ -3650,21 +3677,25 @@ function convexCollectionOptions(config$1) {
 						}).pipe(Effect.provide(seqLayer)));
 						const cursor = ssrCursor ?? persistedCursor;
 						const mux = getContext(collection$1).mutex;
-						const handleSnapshotChange = (bytes, document) => {
+						const handleSnapshotChange = (bytes, document, exists) => {
+							if (!exists && !subdocManager.has(document)) return;
 							cancelAllPending(collection$1);
 							mux(() => {
 								try {
+									const itemBefore = extractDocumentFromSubdoc(subdocManager, document);
 									const update = new Uint8Array(bytes);
 									subdocManager.applyUpdate(document, update, YjsOrigin.Server);
-									const item = extractDocumentFromSubdoc(subdocManager, document);
-									if (item) ops.upsert([item]);
+									const itemAfter = extractDocumentFromSubdoc(subdocManager, document);
+									if (itemAfter) if (itemBefore) ops.upsert([itemAfter]);
+									else ops.insert([itemAfter]);
 								} catch (error) {
 									throw new Error(`Snapshot application failed: ${error}`);
 								}
 							});
 						};
-						const handleDeltaChange = (bytes, document) => {
+						const handleDeltaChange = (bytes, document, exists) => {
 							if (!document) return;
+							if (!exists && !subdocManager.has(document)) return;
 							cancelPending(collection$1, document);
 							setApplyingFromServer(collection$1, document, true);
 							mux(() => {
@@ -3673,7 +3704,8 @@ function convexCollectionOptions(config$1) {
 									const update = new Uint8Array(bytes);
 									subdocManager.applyUpdate(document, update, YjsOrigin.Server);
 									const itemAfter = extractDocumentFromSubdoc(subdocManager, document);
-									if (itemAfter) ops.upsert([itemAfter]);
+									if (itemAfter) if (itemBefore) ops.upsert([itemAfter]);
+									else ops.insert([itemAfter]);
 									else if (itemBefore) ops.delete([itemBefore]);
 								} catch (error) {
 									throw new Error(`Delta application failed for ${document}: ${error}`);
@@ -3687,11 +3719,11 @@ function convexCollectionOptions(config$1) {
 							const { changes, seq: newSeq, compact } = response;
 							const syncedDocuments = /* @__PURE__ */ new Set();
 							for (const change of changes) {
-								const { type, bytes, document } = change;
+								const { type, bytes, document, exists } = change;
 								if (!bytes || !document) continue;
 								syncedDocuments.add(document);
-								if (type === "snapshot") handleSnapshotChange(bytes, document);
-								else handleDeltaChange(bytes, document);
+								if (type === "snapshot") handleSnapshotChange(bytes, document, exists ?? true);
+								else handleDeltaChange(bytes, document, exists ?? true);
 							}
 							if (newSeq !== void 0) {
 								const key = `cursor:${collection$1}`;
@@ -3806,7 +3838,7 @@ function memoryPersistence() {
 
 //#endregion
 //#region src/client/persistence/sqlite/schema.ts
-async function initSchema(executor) {
+async function initSchema$1(executor) {
 	await executor.execute(`
     CREATE TABLE IF NOT EXISTS snapshots (
       collection TEXT PRIMARY KEY,
@@ -3889,108 +3921,6 @@ function createPersistenceFromExecutor(executor) {
 	};
 }
 
-//#endregion
-//#region src/client/persistence/sqlite/browser.ts
-function hasOPFS() {
-	return typeof navigator !== "undefined" && "storage" in navigator && "getDirectory" in navigator.storage;
-}
-async function loadFromOPFS(dbName) {
-	try {
-		const file = await (await (await navigator.storage.getDirectory()).getFileHandle(`${dbName}.sqlite`)).getFile();
-		return new Uint8Array(await file.arrayBuffer());
-	} catch {
-		return null;
-	}
-}
-async function saveToOPFS(dbName, data) {
-	const writable = await (await (await navigator.storage.getDirectory()).getFileHandle(`${dbName}.sqlite`, { create: true })).createWritable();
-	await writable.write(new Uint8Array(data));
-	await writable.close();
-}
-const IDB_STORE = "sqlite-db";
-function openIDB(dbName) {
-	return new Promise((resolve, reject) => {
-		const request = indexedDB.open(`replicate-sqlite-${dbName}`, 1);
-		request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error("IndexedDB open failed"));
-		request.onsuccess = () => resolve(request.result);
-		request.onupgradeneeded = () => {
-			request.result.createObjectStore(IDB_STORE);
-		};
-	});
-}
-async function loadFromIDB(dbName) {
-	try {
-		const db = await openIDB(dbName);
-		return new Promise((resolve) => {
-			const request = db.transaction(IDB_STORE, "readonly").objectStore(IDB_STORE).get("data");
-			request.onsuccess = () => {
-				db.close();
-				resolve(request.result ?? null);
-			};
-			request.onerror = () => {
-				db.close();
-				resolve(null);
-			};
-		});
-	} catch {
-		return null;
-	}
-}
-async function saveToIDB(dbName, data) {
-	const db = await openIDB(dbName);
-	return new Promise((resolve, reject) => {
-		const request = db.transaction(IDB_STORE, "readwrite").objectStore(IDB_STORE).put(data, "data");
-		request.onsuccess = () => {
-			db.close();
-			resolve();
-		};
-		request.onerror = () => {
-			db.close();
-			reject(request.error ?? /* @__PURE__ */ new Error("IndexedDB put failed"));
-		};
-	});
-}
-function createStorageBackend(dbName) {
-	if (hasOPFS()) return {
-		load: () => loadFromOPFS(dbName),
-		save: (data) => saveToOPFS(dbName, data)
-	};
-	return {
-		load: () => loadFromIDB(dbName),
-		save: (data) => saveToIDB(dbName, data)
-	};
-}
-var SqlJsExecutor = class {
-	constructor(db, storage) {
-		this.db = db;
-		this.storage = storage;
-	}
-	async execute(sql, params) {
-		const rows = [];
-		const trimmed = sql.trim().toUpperCase();
-		if (trimmed.startsWith("CREATE") || trimmed.startsWith("INSERT") || trimmed.startsWith("UPDATE") || trimmed.startsWith("DELETE") || trimmed.startsWith("BEGIN") || trimmed.startsWith("COMMIT") || trimmed.startsWith("ROLLBACK")) {
-			this.db.run(sql, params);
-			await this.storage.save(this.db.export());
-			return { rows };
-		}
-		const stmt = this.db.prepare(sql);
-		if (params?.length) stmt.bind(params);
-		while (stmt.step()) rows.push(stmt.getAsObject());
-		stmt.free();
-		return { rows };
-	}
-	close() {
-		this.db.close();
-	}
-};
-async function createBrowserSqlitePersistence(SQL, dbName) {
-	const storage = createStorageBackend(dbName);
-	const existingData = await storage.load();
-	const executor = new SqlJsExecutor(existingData ? new SQL.Database(existingData) : new SQL.Database(), storage);
-	await initSchema(executor);
-	return createPersistenceFromExecutor(executor);
-}
-
 //#endregion
 //#region src/client/persistence/sqlite/native.ts
 var OPSqliteExecutor = class {
@@ -4006,106 +3936,10 @@ var OPSqliteExecutor = class {
 };
 async function createNativeSqlitePersistence(db, _dbName) {
 	const executor = new OPSqliteExecutor(db);
-	await initSchema(executor);
+	await initSchema$1(executor);
 	return createPersistenceFromExecutor(executor);
 }
 
-//#endregion
-//#region src/client/persistence/indexeddb.ts
-const UPDATES_STORE = "updates";
-const SNAPSHOTS_STORE = "snapshots";
-const KV_STORE = "kv";
-function openDatabase(dbName) {
-	return new Promise((resolve, reject) => {
-		const request = indexedDB.open(`replicate-${dbName}`, 1);
-		request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error("IndexedDB open failed"));
-		request.onsuccess = () => resolve(request.result);
-		request.onupgradeneeded = () => {
-			const db = request.result;
-			db.createObjectStore(SNAPSHOTS_STORE);
-			db.createObjectStore(KV_STORE);
-			db.createObjectStore(UPDATES_STORE, { autoIncrement: true }).createIndex("by_collection", "collection", { unique: false });
-		};
-	});
-}
-var IDBKeyValueStore = class {
-	constructor(db) {
-		this.db = db;
-	}
-	get(key) {
-		return new Promise((resolve, reject) => {
-			const request = this.db.transaction(KV_STORE, "readonly").objectStore(KV_STORE).get(key);
-			request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error("IndexedDB get failed"));
-			request.onsuccess = () => resolve(request.result);
-		});
-	}
-	set(key, value) {
-		return new Promise((resolve, reject) => {
-			const request = this.db.transaction(KV_STORE, "readwrite").objectStore(KV_STORE).put(value, key);
-			request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error("IndexedDB set failed"));
-			request.onsuccess = () => resolve();
-		});
-	}
-	del(key) {
-		return new Promise((resolve, reject) => {
-			const request = this.db.transaction(KV_STORE, "readwrite").objectStore(KV_STORE).delete(key);
-			request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error("IndexedDB delete failed"));
-			request.onsuccess = () => resolve();
-		});
-	}
-};
-var IDBPersistenceProvider = class {
-	updateHandler;
-	whenSynced;
-	constructor(db, collection$1, ydoc) {
-		this.db = db;
-		this.collection = collection$1;
-		this.ydoc = ydoc;
-		this.whenSynced = this.loadState();
-		this.updateHandler = (update, origin) => {
-			if (origin !== "idb") this.saveUpdate(update);
-		};
-		this.ydoc.on("update", this.updateHandler);
-	}
-	loadState() {
-		return new Promise((resolve, reject) => {
-			const tx = this.db.transaction([SNAPSHOTS_STORE, UPDATES_STORE], "readonly");
-			const snapshotRequest = tx.objectStore(SNAPSHOTS_STORE).get(this.collection);
-			snapshotRequest.onsuccess = () => {
-				if (snapshotRequest.result) Y.applyUpdate(this.ydoc, snapshotRequest.result, "idb");
-				const updatesRequest = tx.objectStore(UPDATES_STORE).index("by_collection").getAll(this.collection);
-				updatesRequest.onsuccess = () => {
-					const records = updatesRequest.result;
-					for (const record of records) Y.applyUpdate(this.ydoc, record.data, "idb");
-					resolve();
-				};
-				updatesRequest.onerror = () => reject(updatesRequest.error ?? /* @__PURE__ */ new Error("IndexedDB updates load failed"));
-			};
-			snapshotRequest.onerror = () => reject(snapshotRequest.error ?? /* @__PURE__ */ new Error("IndexedDB snapshot load failed"));
-		});
-	}
-	saveUpdate(update) {
-		return new Promise((resolve, reject) => {
-			const request = this.db.transaction(UPDATES_STORE, "readwrite").objectStore(UPDATES_STORE).add({
-				collection: this.collection,
-				data: update
-			});
-			request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error("IndexedDB save update failed"));
-			request.onsuccess = () => resolve();
-		});
-	}
-	destroy() {
-		this.ydoc.off("update", this.updateHandler);
-	}
-};
-async function createIndexedDBPersistence(dbName) {
-	const db = await openDatabase(dbName);
-	return {
-		createDocPersistence: (collection$1, ydoc) => new IDBPersistenceProvider(db, collection$1, ydoc),
-		kv: new IDBKeyValueStore(db)
-	};
-}
-
 //#endregion
 //#region src/client/persistence/custom.ts
 const SNAPSHOT_PREFIX = "snapshot:";
@@ -4170,15 +4004,128 @@ function createCustomPersistence(adapter) {
 	};
 }
 
+//#endregion
+//#region src/client/persistence/pglite.ts
+async function initSchema(pg) {
+	await pg.exec(`
+    CREATE TABLE IF NOT EXISTS snapshots (
+      collection TEXT PRIMARY KEY,
+      data BYTEA NOT NULL,
+      state_vector BYTEA,
+      seq INTEGER DEFAULT 0
+    )
+  `);
+	await pg.exec(`
+    CREATE TABLE IF NOT EXISTS updates (
+      id SERIAL PRIMARY KEY,
+      collection TEXT NOT NULL,
+      data BYTEA NOT NULL
+    )
+  `);
+	await pg.exec(`
+    CREATE INDEX IF NOT EXISTS updates_collection_idx ON updates (collection)
+  `);
+	await pg.exec(`
+    CREATE TABLE IF NOT EXISTS kv (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    )
+  `);
+}
+var PGliteKeyValueStore = class {
+	constructor(pg) {
+		this.pg = pg;
+	}
+	async get(key) {
+		const result = await this.pg.query("SELECT value FROM kv WHERE key = $1", [key]);
+		if (result.rows.length === 0) return void 0;
+		return JSON.parse(result.rows[0].value);
+	}
+	async set(key, value) {
+		await this.pg.query(`INSERT INTO kv (key, value) VALUES ($1, $2)
+       ON CONFLICT (key) DO UPDATE SET value = $2`, [key, JSON.stringify(value)]);
+	}
+	async del(key) {
+		await this.pg.query("DELETE FROM kv WHERE key = $1", [key]);
+	}
+};
+var PGlitePersistenceProvider = class {
+	updateHandler;
+	whenSynced;
+	constructor(pg, collection$1, ydoc) {
+		this.pg = pg;
+		this.collection = collection$1;
+		this.ydoc = ydoc;
+		this.whenSynced = this.loadState();
+		this.updateHandler = (update, origin) => {
+			if (origin !== "pglite") this.saveUpdate(update);
+		};
+		this.ydoc.on("update", this.updateHandler);
+	}
+	async loadState() {
+		const snapshotResult = await this.pg.query("SELECT data FROM snapshots WHERE collection = $1", [this.collection]);
+		if (snapshotResult.rows.length > 0) {
+			const raw = snapshotResult.rows[0].data;
+			const snapshotData = raw instanceof Uint8Array ? raw : new Uint8Array(raw);
+			Y.applyUpdate(this.ydoc, snapshotData, "pglite");
+		}
+		const updatesResult = await this.pg.query("SELECT data FROM updates WHERE collection = $1 ORDER BY id ASC", [this.collection]);
+		for (const row of updatesResult.rows) {
+			const raw = row.data;
+			const updateData = raw instanceof Uint8Array ? raw : new Uint8Array(raw);
+			Y.applyUpdate(this.ydoc, updateData, "pglite");
+		}
+	}
+	async saveUpdate(update) {
+		await this.pg.query("INSERT INTO updates (collection, data) VALUES ($1, $2)", [this.collection, update]);
+	}
+	destroy() {
+		this.ydoc.off("update", this.updateHandler);
+	}
+};
+async function createPGlitePersistence(pg) {
+	await initSchema(pg);
+	return {
+		createDocPersistence: (collection$1, ydoc) => new PGlitePersistenceProvider(pg, collection$1, ydoc),
+		kv: new PGliteKeyValueStore(pg)
+	};
+}
+/**
+* Creates a singleton PGlite persistence factory.
+* Use this to ensure the PGlite WASM module is only loaded once,
+* even when shared across multiple collections.
+*
+* @example
+* ```typescript
+* // src/lib/pglite.ts
+* import { persistence } from "@trestleinc/replicate/client";
+*
+* export const pglite = persistence.pglite.once(async () => {
+*   const { PGlite } = await import("@electric-sql/pglite");
+*   const { live } = await import("@electric-sql/pglite/live");
+*   return PGlite.create({ dataDir: "idb://app", extensions: { live } });
+* });
+*
+* // src/collections/useIntervals.ts
+* import { pglite } from "$lib/pglite";
+*
+* export const intervals = collection.create({
+*   persistence: pglite,
+*   config: () => ({ ... }),
+* });
+* ```
+*/
+function oncePGlitePersistence(factory) {
+	let instance = null;
+	return () => instance ??= factory().then(createPGlitePersistence);
+}
+
 //#endregion
 //#region src/client/persistence/index.ts
 const persistence = {
+	pglite: Object.assign(createPGlitePersistence, { once: oncePGlitePersistence }),
+	sqlite: createNativeSqlitePersistence,
 	memory: memoryPersistence,
-	sqlite: {
-		browser: createBrowserSqlitePersistence,
-		native: createNativeSqlitePersistence
-	},
-	indexeddb: createIndexedDBPersistence,
 	custom: createCustomPersistence
 };