@tanstack/browser-db-sqlite-persistence 0.1.2

package/dist/cjs/browser-persistence.cjs

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const dbSqlitePersistenceCore = require("@tanstack/db-sqlite-persistence-core");
+const browserCoordinator = require("./browser-coordinator.cjs");
+const waSqliteDriver = require("./wa-sqlite-driver.cjs");
+function normalizeSchemaMismatchPolicy(policy) {
+  if (policy === `throw`) {
+    return `sync-absent-error`;
+  }
+  return policy;
+}
+function resolveSchemaMismatchPolicy(explicitPolicy, mode) {
+  if (explicitPolicy) {
+    return normalizeSchemaMismatchPolicy(explicitPolicy);
+  }
+  return mode === `sync-present` ? `sync-present-reset` : `sync-absent-error`;
+}
+function createAdapterCacheKey(schemaMismatchPolicy, schemaVersion) {
+  const schemaVersionKey = schemaVersion === void 0 ? `schema:default` : `schema:${schemaVersion}`;
+  return `${schemaMismatchPolicy}|${schemaVersionKey}`;
+}
+function createInternalSQLiteDriver(options) {
+  return new waSqliteDriver.BrowserWASQLiteDriver({
+    database: options.database
+  });
+}
+function resolveAdapterBaseOptions(options) {
+  return {
+    appliedTxPruneMaxRows: options.appliedTxPruneMaxRows,
+    appliedTxPruneMaxAgeSeconds: options.appliedTxPruneMaxAgeSeconds,
+    pullSinceReloadThreshold: options.pullSinceReloadThreshold
+  };
+}
+function createBrowserWASQLitePersistence(options) {
+  const { coordinator, schemaMismatchPolicy } = options;
+  const driver = createInternalSQLiteDriver(options);
+  const adapterBaseOptions = resolveAdapterBaseOptions(options);
+  const resolvedCoordinator = coordinator ?? new dbSqlitePersistenceCore.SingleProcessCoordinator();
+  const adapterCache = /* @__PURE__ */ new Map();
+  const getAdapterForCollection = (mode, schemaVersion) => {
+    const resolvedSchemaMismatchPolicy = resolveSchemaMismatchPolicy(
+      schemaMismatchPolicy,
+      mode
+    );
+    const cacheKey = createAdapterCacheKey(
+      resolvedSchemaMismatchPolicy,
+      schemaVersion
+    );
+    const cachedAdapter = adapterCache.get(cacheKey);
+    if (cachedAdapter) {
+      return cachedAdapter;
+    }
+    const adapter = dbSqlitePersistenceCore.createSQLiteCorePersistenceAdapter({
+      ...adapterBaseOptions,
+      driver,
+      schemaMismatchPolicy: resolvedSchemaMismatchPolicy,
+      ...schemaVersion === void 0 ? {} : { schemaVersion }
+    });
+    adapterCache.set(cacheKey, adapter);
+    if (resolvedCoordinator instanceof browserCoordinator.BrowserCollectionCoordinator) {
+      resolvedCoordinator.setAdapter(adapter);
+    }
+    return adapter;
+  };
+  const createCollectionPersistence = (mode, schemaVersion) => ({
+    adapter: getAdapterForCollection(
+      mode,
+      schemaVersion
+    ),
+    coordinator: resolvedCoordinator
+  });
+  const defaultPersistence = createCollectionPersistence(
+    `sync-absent`,
+    void 0
+  );
+  return {
+    ...defaultPersistence,
+    resolvePersistenceForCollection: ({ mode, schemaVersion }) => createCollectionPersistence(mode, schemaVersion),
+    resolvePersistenceForMode: (mode) => createCollectionPersistence(mode, void 0)
+  };
+}
+exports.createBrowserWASQLitePersistence = createBrowserWASQLitePersistence;
+//# sourceMappingURL=browser-persistence.cjs.map

package/dist/cjs/browser-persistence.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-persistence.cjs","sources":["../../src/browser-persistence.ts"],"sourcesContent":["import {\n  SingleProcessCoordinator,\n  createSQLiteCorePersistenceAdapter,\n} from '@tanstack/db-sqlite-persistence-core'\nimport { BrowserCollectionCoordinator } from './browser-coordinator'\nimport { BrowserWASQLiteDriver } from './wa-sqlite-driver'\nimport type {\n  PersistedCollectionCoordinator,\n  PersistedCollectionMode,\n  PersistedCollectionPersistence,\n  SQLiteCoreAdapterOptions,\n  SQLiteDriver,\n} from '@tanstack/db-sqlite-persistence-core'\nimport type { BrowserWASQLiteDatabase } from './wa-sqlite-driver'\n\nexport type { BrowserWASQLiteDatabase } from './wa-sqlite-driver'\n\ntype BrowserSQLiteCoreSchemaMismatchPolicy =\n  | `sync-present-reset`\n  | `sync-absent-error`\n  | `reset`\n\nexport type BrowserWASQLiteSchemaMismatchPolicy =\n  | BrowserSQLiteCoreSchemaMismatchPolicy\n  | `throw`\n\nexport type BrowserWASQLitePersistenceOptions = Omit<\n  SQLiteCoreAdapterOptions,\n  `driver` | `schemaVersion` | `schemaMismatchPolicy`\n> & {\n  database: BrowserWASQLiteDatabase\n  coordinator?: PersistedCollectionCoordinator\n  schemaMismatchPolicy?: BrowserWASQLiteSchemaMismatchPolicy\n}\n\nfunction normalizeSchemaMismatchPolicy(\n  policy: BrowserWASQLiteSchemaMismatchPolicy,\n): BrowserSQLiteCoreSchemaMismatchPolicy {\n  if (policy === `throw`) {\n    return `sync-absent-error`\n  }\n\n  return policy\n}\n\nfunction resolveSchemaMismatchPolicy(\n  explicitPolicy: BrowserWASQLiteSchemaMismatchPolicy | undefined,\n  mode: PersistedCollectionMode,\n): BrowserSQLiteCoreSchemaMismatchPolicy {\n  if (explicitPolicy) {\n    return normalizeSchemaMismatchPolicy(explicitPolicy)\n  }\n\n  return mode === `sync-present` ? `sync-present-reset` : `sync-absent-error`\n}\n\nfunction createAdapterCacheKey(\n  schemaMismatchPolicy: BrowserSQLiteCoreSchemaMismatchPolicy,\n  schemaVersion: number | undefined,\n): string {\n  const schemaVersionKey =\n    schemaVersion === undefined ? `schema:default` : `schema:${schemaVersion}`\n  return `${schemaMismatchPolicy}|${schemaVersionKey}`\n}\n\nfunction createInternalSQLiteDriver(\n  options: BrowserWASQLitePersistenceOptions,\n): SQLiteDriver {\n  return new BrowserWASQLiteDriver({\n    database: options.database,\n  })\n}\n\nfunction resolveAdapterBaseOptions(\n  options: BrowserWASQLitePersistenceOptions,\n): Omit<\n  SQLiteCoreAdapterOptions,\n  `driver` | `schemaVersion` | `schemaMismatchPolicy`\n> {\n  return {\n    appliedTxPruneMaxRows: options.appliedTxPruneMaxRows,\n    appliedTxPruneMaxAgeSeconds: options.appliedTxPruneMaxAgeSeconds,\n    pullSinceReloadThreshold: options.pullSinceReloadThreshold,\n  }\n}\n\n/**\n * Creates a shared browser wa-sqlite persistence instance that can be reused by\n * many collections on the same database. This is single-tab wiring using\n * SingleProcessCoordinator semantics (no election required).\n */\nexport function createBrowserWASQLitePersistence<\n  T extends object,\n  TKey extends string | number = string | number,\n>(\n  options: BrowserWASQLitePersistenceOptions,\n): PersistedCollectionPersistence<T, TKey> {\n  const { coordinator, schemaMismatchPolicy } = options\n  const driver = createInternalSQLiteDriver(options)\n  const adapterBaseOptions = resolveAdapterBaseOptions(options)\n  const resolvedCoordinator = coordinator ?? new SingleProcessCoordinator()\n  const adapterCache = new Map<\n    string,\n    ReturnType<\n      typeof createSQLiteCorePersistenceAdapter<\n        Record<string, unknown>,\n        string | number\n      >\n    >\n  >()\n\n  const getAdapterForCollection = (\n    mode: PersistedCollectionMode,\n    schemaVersion: number | undefined,\n  ) => {\n    const resolvedSchemaMismatchPolicy = resolveSchemaMismatchPolicy(\n      schemaMismatchPolicy,\n      mode,\n    )\n    const cacheKey = createAdapterCacheKey(\n      resolvedSchemaMismatchPolicy,\n      schemaVersion,\n    )\n    const cachedAdapter = adapterCache.get(cacheKey)\n    if (cachedAdapter) {\n      return cachedAdapter\n    }\n\n    const adapter = createSQLiteCorePersistenceAdapter<\n      Record<string, unknown>,\n      string | number\n    >({\n      ...adapterBaseOptions,\n      driver,\n      schemaMismatchPolicy: resolvedSchemaMismatchPolicy,\n      ...(schemaVersion === undefined ? {} : { schemaVersion }),\n    })\n    adapterCache.set(cacheKey, adapter)\n\n    // Wire the adapter into the multi-tab coordinator so it can handle\n    // leader-side RPCs (applyCommittedTx, pullSince, ensureIndex, etc.)\n    if (resolvedCoordinator instanceof BrowserCollectionCoordinator) {\n      resolvedCoordinator.setAdapter(adapter)\n    }\n\n    return adapter\n  }\n\n  const createCollectionPersistence = (\n    mode: PersistedCollectionMode,\n    schemaVersion: number | undefined,\n  ): PersistedCollectionPersistence<T, TKey> => ({\n    adapter: getAdapterForCollection(\n      mode,\n      schemaVersion,\n    ) as unknown as PersistedCollectionPersistence<T, TKey>[`adapter`],\n    coordinator: resolvedCoordinator,\n  })\n\n  const defaultPersistence = createCollectionPersistence(\n    `sync-absent`,\n    undefined,\n  )\n\n  return {\n    ...defaultPersistence,\n    resolvePersistenceForCollection: ({ mode, schemaVersion }) =>\n      createCollectionPersistence(mode, schemaVersion),\n    resolvePersistenceForMode: (mode) =>\n      createCollectionPersistence(mode, undefined),\n  }\n}\n"],"names":["BrowserWASQLiteDriver","SingleProcessCoordinator","createSQLiteCorePersistenceAdapter","BrowserCollectionCoordinator"],"mappings":";;;;;AAmCA,SAAS,8BACP,QACuC;AACvC,MAAI,WAAW,SAAS;AACtB,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAEA,SAAS,4BACP,gBACA,MACuC;AACvC,MAAI,gBAAgB;AAClB,WAAO,8BAA8B,cAAc;AAAA,EACrD;AAEA,SAAO,SAAS,iBAAiB,uBAAuB;AAC1D;AAEA,SAAS,sBACP,sBACA,eACQ;AACR,QAAM,mBACJ,kBAAkB,SAAY,mBAAmB,UAAU,aAAa;AAC1E,SAAO,GAAG,oBAAoB,IAAI,gBAAgB;AACpD;AAEA,SAAS,2BACP,SACc;AACd,SAAO,IAAIA,eAAAA,sBAAsB;AAAA,IAC/B,UAAU,QAAQ;AAAA,EAAA,CACnB;AACH;AAEA,SAAS,0BACP,SAIA;AACA,SAAO;AAAA,IACL,uBAAuB,QAAQ;AAAA,IAC/B,6BAA6B,QAAQ;AAAA,IACrC,0BAA0B,QAAQ;AAAA,EAAA;AAEtC;AAOO,SAAS,iCAId,SACyC;AACzC,QAAM,EAAE,aAAa,qBAAA,IAAyB;AAC9C,QAAM,SAAS,2BAA2B,OAAO;AACjD,QAAM,qBAAqB,0BAA0B,OAAO;AAC5D,QAAM,sBAAsB,eAAe,IAAIC,iDAAA;AAC/C,QAAM,mCAAmB,IAAA;AAUzB,QAAM,0BAA0B,CAC9B,MACA,kBACG;AACH,UAAM,+BAA+B;AAAA,MACnC;AAAA,MACA;AAAA,IAAA;AAEF,UAAM,WAAW;AAAA,MACf;AAAA,MACA;AAAA,IAAA;AAEF,UAAM,gBAAgB,aAAa,IAAI,QAAQ;AAC/C,QAAI,eAAe;AACjB,aAAO;AAAA,IACT;AAEA,UAAM,UAAUC,wBAAAA,mCAGd;AAAA,MACA,GAAG;AAAA,MACH;AAAA,MACA,sBAAsB;AAAA,MACtB,GAAI,kBAAkB,SAAY,CAAA,IAAK,EAAE,cAAA;AAAA,IAAc,CACxD;AACD,iBAAa,IAAI,UAAU,OAAO;AAIlC,QAAI,+BAA+BC,mBAAAA,8BAA8B;AAC/D,0BAAoB,WAAW,OAAO;AAAA,IACxC;AAEA,WAAO;AAAA,EACT;AAEA,QAAM,8BAA8B,CAClC,MACA,mBAC6C;AAAA,IAC7C,SAAS;AAAA,MACP;AAAA,MACA;AAAA,IAAA;AAAA,IAEF,aAAa;AAAA,EAAA;AAGf,QAAM,qBAAqB;AAAA,IACzB;AAAA,IACA;AAAA,EAAA;AAGF,SAAO;AAAA,IACL,GAAG;AAAA,IACH,iCAAiC,CAAC,EAAE,MAAM,oBACxC,4BAA4B,MAAM,aAAa;AAAA,IACjD,2BAA2B,CAAC,SAC1B,4BAA4B,MAAM,MAAS;AAAA,EAAA;AAEjD;;"}

package/dist/cjs/browser-persistence.d.cts

@@ -0,0 +1,16 @@
+import { PersistedCollectionCoordinator, PersistedCollectionPersistence, SQLiteCoreAdapterOptions } from '@tanstack/db-sqlite-persistence-core';
+import { BrowserWASQLiteDatabase } from './wa-sqlite-driver.cjs';
+export type { BrowserWASQLiteDatabase } from './wa-sqlite-driver.cjs';
+type BrowserSQLiteCoreSchemaMismatchPolicy = `sync-present-reset` | `sync-absent-error` | `reset`;
+export type BrowserWASQLiteSchemaMismatchPolicy = BrowserSQLiteCoreSchemaMismatchPolicy | `throw`;
+export type BrowserWASQLitePersistenceOptions = Omit<SQLiteCoreAdapterOptions, `driver` | `schemaVersion` | `schemaMismatchPolicy`> & {
+    database: BrowserWASQLiteDatabase;
+    coordinator?: PersistedCollectionCoordinator;
+    schemaMismatchPolicy?: BrowserWASQLiteSchemaMismatchPolicy;
+};
+/**
+ * Creates a shared browser wa-sqlite persistence instance that can be reused by
+ * many collections on the same database. This is single-tab wiring using
+ * SingleProcessCoordinator semantics (no election required).
+ */
+export declare function createBrowserWASQLitePersistence<T extends object, TKey extends string | number = string | number>(options: BrowserWASQLitePersistenceOptions): PersistedCollectionPersistence<T, TKey>;

package/dist/cjs/index.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const browserPersistence = require("./browser-persistence.cjs");
+const opfsDatabase = require("./opfs-database.cjs");
+const browserCoordinator = require("./browser-coordinator.cjs");
+const dbSqlitePersistenceCore = require("@tanstack/db-sqlite-persistence-core");
+exports.createBrowserWASQLitePersistence = browserPersistence.createBrowserWASQLitePersistence;
+exports.openBrowserWASQLiteOPFSDatabase = opfsDatabase.openBrowserWASQLiteOPFSDatabase;
+exports.BrowserCollectionCoordinator = browserCoordinator.BrowserCollectionCoordinator;
+Object.defineProperty(exports, "persistedCollectionOptions", {
+  enumerable: true,
+  get: () => dbSqlitePersistenceCore.persistedCollectionOptions
+});
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;"}

package/dist/cjs/index.d.cts

@@ -0,0 +1,8 @@
+export { createBrowserWASQLitePersistence } from './browser-persistence.cjs';
+export { openBrowserWASQLiteOPFSDatabase } from './opfs-database.cjs';
+export { BrowserCollectionCoordinator } from './browser-coordinator.cjs';
+export type { BrowserWASQLiteDatabase, BrowserWASQLitePersistenceOptions, BrowserWASQLiteSchemaMismatchPolicy, } from './browser-persistence.cjs';
+export type { OpenBrowserWASQLiteOPFSDatabaseOptions } from './opfs-database.cjs';
+export type { BrowserCollectionCoordinatorOptions } from './browser-coordinator.cjs';
+export { persistedCollectionOptions } from '@tanstack/db-sqlite-persistence-core';
+export type { PersistedCollectionCoordinator, PersistedCollectionPersistence, } from '@tanstack/db-sqlite-persistence-core';

package/dist/cjs/opfs-database.cjs

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const dbSqlitePersistenceCore = require("@tanstack/db-sqlite-persistence-core");
+const opfsWorker = require("./opfs-worker.cjs");
+const DEFAULT_VFS_NAME = `opfs`;
+class OPFSWorkerRequestError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = `OPFSWorkerRequestError`;
+  }
+}
+function hasOPFSBrowserPrerequisites(globalObject) {
+  const candidate = globalObject;
+  const getDirectory = candidate.navigator?.storage?.getDirectory;
+  const WorkerConstructor = candidate.Worker;
+  return typeof getDirectory === `function` && typeof WorkerConstructor === `function`;
+}
+function createWorkerError(code, message) {
+  if (code === `PERSISTENCE_UNAVAILABLE`) {
+    return new dbSqlitePersistenceCore.PersistenceUnavailableError(message);
+  }
+  if (code === `INVALID_CONFIG`) {
+    return new dbSqlitePersistenceCore.InvalidPersistedCollectionConfigError(message);
+  }
+  return new OPFSWorkerRequestError(code, message);
+}
+function createWorkerRequestIdFactory() {
+  let sequence = 0;
+  const prefix = `opfs-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+  return () => {
+    sequence++;
+    return `${prefix}-${sequence}`;
+  };
+}
+function createOPFSWorkerInstance() {
+  const WorkerConstructor = globalThis.Worker;
+  if (typeof WorkerConstructor !== `function`) {
+    throw new dbSqlitePersistenceCore.PersistenceUnavailableError(
+      `Web Worker support is required for browser OPFS persistence`
+    );
+  }
+  return new opfsWorker();
+}
+async function openBrowserWASQLiteOPFSDatabase(options) {
+  const databaseName = options.databaseName.trim();
+  if (databaseName.length === 0) {
+    throw new dbSqlitePersistenceCore.InvalidPersistedCollectionConfigError(
+      `Browser wa-sqlite databaseName cannot be empty`
+    );
+  }
+  if (!hasOPFSBrowserPrerequisites(globalThis)) {
+    throw new dbSqlitePersistenceCore.PersistenceUnavailableError(
+      `Browser OPFS prerequisites are not available in this runtime`
+    );
+  }
+  const vfsName = options.vfsName ?? DEFAULT_VFS_NAME;
+  const worker = createOPFSWorkerInstance();
+  const nextRequestId = createWorkerRequestIdFactory();
+  const pendingRequests = /* @__PURE__ */ new Map();
+  let disposed = false;
+  const disposeWorker = () => {
+    if (disposed) {
+      return;
+    }
+    disposed = true;
+    worker.removeEventListener(`message`, onMessage);
+    worker.removeEventListener(`error`, onError);
+    worker.removeEventListener(`messageerror`, onMessageError);
+    worker.terminate();
+  };
+  const rejectAllPendingRequests = (error) => {
+    for (const pendingRequest of pendingRequests.values()) {
+      pendingRequest.reject(error);
+    }
+    pendingRequests.clear();
+  };
+  const onMessage = (event) => {
+    const messageEvent = event;
+    const response = messageEvent.data;
+    const pendingRequest = pendingRequests.get(response.requestId);
+    if (!pendingRequest) {
+      return;
+    }
+    pendingRequests.delete(response.requestId);
+    if (response.ok) {
+      pendingRequest.resolve(response.rows ?? []);
+      return;
+    }
+    pendingRequest.reject(createWorkerError(response.code, response.error));
+  };
+  const onError = () => {
+    rejectAllPendingRequests(
+      new dbSqlitePersistenceCore.PersistenceUnavailableError(`OPFS worker terminated unexpectedly`)
+    );
+    disposeWorker();
+  };
+  const onMessageError = () => {
+    rejectAllPendingRequests(
+      new dbSqlitePersistenceCore.PersistenceUnavailableError(
+        `OPFS worker message serialization failed`
+      )
+    );
+    disposeWorker();
+  };
+  worker.addEventListener(`message`, onMessage);
+  worker.addEventListener(`error`, onError);
+  worker.addEventListener(`messageerror`, onMessageError);
+  const sendWorkerRequest = (request) => {
+    if (disposed) {
+      return Promise.reject(
+        new dbSqlitePersistenceCore.InvalidPersistedCollectionConfigError(
+          `Browser OPFS worker connection is closed`
+        )
+      );
+    }
+    const requestId = nextRequestId();
+    return new Promise((resolve, reject) => {
+      pendingRequests.set(requestId, {
+        resolve: (value) => {
+          resolve(value);
+        },
+        reject
+      });
+      try {
+        const payload = {
+          ...request,
+          requestId
+        };
+        worker.postMessage(payload);
+      } catch (error) {
+        pendingRequests.delete(requestId);
+        reject(
+          new dbSqlitePersistenceCore.PersistenceUnavailableError(
+            `Failed to send message to OPFS worker: ${error.message}`
+          )
+        );
+      }
+    });
+  };
+  try {
+    await sendWorkerRequest({
+      type: `init`,
+      databaseName,
+      vfsName
+    });
+  } catch (error) {
+    disposeWorker();
+    throw error;
+  }
+  return {
+    execute: (sql, params = []) => sendWorkerRequest({
+      type: `execute`,
+      sql,
+      params
+    }),
+    close: async () => {
+      let closeError;
+      try {
+        await sendWorkerRequest({
+          type: `close`
+        });
+      } catch (error) {
+        closeError = error;
+      } finally {
+        disposeWorker();
+      }
+      if (closeError) {
+        throw closeError;
+      }
+    }
+  };
+}
+exports.openBrowserWASQLiteOPFSDatabase = openBrowserWASQLiteOPFSDatabase;
+//# sourceMappingURL=opfs-database.cjs.map

package/dist/cjs/opfs-database.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"opfs-database.cjs","sources":["../../src/opfs-database.ts"],"sourcesContent":["import {\n  InvalidPersistedCollectionConfigError,\n  PersistenceUnavailableError,\n} from '@tanstack/db-sqlite-persistence-core'\nimport OPFSWorkerConstructor from './opfs-worker?worker'\nimport type { BrowserWASQLiteDatabase } from './wa-sqlite-driver'\nimport type {\n  BrowserOPFSWorkerErrorCode,\n  BrowserOPFSWorkerRequest,\n  BrowserOPFSWorkerResponse,\n} from './opfs-worker-protocol'\n\nconst DEFAULT_VFS_NAME = `opfs`\ntype BrowserOPFSFeatureGlobal = {\n  navigator?: {\n    storage?: {\n      getDirectory?: () => Promise<unknown>\n    }\n  }\n  Worker?: typeof Worker\n}\n\nexport type OpenBrowserWASQLiteOPFSDatabaseOptions = {\n  databaseName: string\n  vfsName?: string\n}\n\ntype BrowserOPFSWorkerLike = Pick<\n  Worker,\n  `postMessage` | `terminate` | `addEventListener` | `removeEventListener`\n>\n\ntype PendingWorkerRequest = {\n  resolve: (value: unknown) => void\n  reject: (error: Error) => void\n}\n\ntype BrowserOPFSWorkerRequestWithoutId =\n  BrowserOPFSWorkerRequest extends infer TRequest\n    ? TRequest extends { requestId: string }\n      ? Omit<TRequest, `requestId`>\n      : never\n    : never\n\nclass OPFSWorkerRequestError extends Error {\n  constructor(\n    readonly code: BrowserOPFSWorkerErrorCode,\n    message: string,\n  ) {\n    super(message)\n    this.name = `OPFSWorkerRequestError`\n  }\n}\n\nfunction hasOPFSBrowserPrerequisites(globalObject: unknown): boolean {\n  const candidate = globalObject as BrowserOPFSFeatureGlobal\n  const getDirectory = candidate.navigator?.storage?.getDirectory\n  const WorkerConstructor = candidate.Worker\n\n  return (\n    typeof getDirectory === `function` &&\n    typeof WorkerConstructor === `function`\n  )\n}\n\nfunction createWorkerError(\n  code: BrowserOPFSWorkerErrorCode,\n  message: string,\n): Error {\n  if (code === `PERSISTENCE_UNAVAILABLE`) {\n    return new PersistenceUnavailableError(message)\n  }\n  if (code === `INVALID_CONFIG`) {\n    return new InvalidPersistedCollectionConfigError(message)\n  }\n  return new OPFSWorkerRequestError(code, message)\n}\n\nfunction createWorkerRequestIdFactory(): () => string {\n  let sequence = 0\n  const prefix = `opfs-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`\n\n  return () => {\n    sequence++\n    return `${prefix}-${sequence}`\n  }\n}\n\nfunction createOPFSWorkerInstance(): BrowserOPFSWorkerLike {\n  const WorkerConstructor = (\n    globalThis as typeof globalThis & { Worker?: typeof Worker }\n  ).Worker\n  if (typeof WorkerConstructor !== `function`) {\n    throw new PersistenceUnavailableError(\n      `Web Worker support is required for browser OPFS persistence`,\n    )\n  }\n\n  return new (OPFSWorkerConstructor as unknown as new () => BrowserOPFSWorkerLike)()\n}\n\n/**\n * Creates a browser wa-sqlite database handle backed by OPFS and\n * OPFSCoopSyncVFS.\n */\nexport async function openBrowserWASQLiteOPFSDatabase(\n  options: OpenBrowserWASQLiteOPFSDatabaseOptions,\n): Promise<BrowserWASQLiteDatabase> {\n  const databaseName = options.databaseName.trim()\n  if (databaseName.length === 0) {\n    throw new InvalidPersistedCollectionConfigError(\n      `Browser wa-sqlite databaseName cannot be empty`,\n    )\n  }\n\n  if (!hasOPFSBrowserPrerequisites(globalThis)) {\n    throw new PersistenceUnavailableError(\n      `Browser OPFS prerequisites are not available in this runtime`,\n    )\n  }\n\n  const vfsName = options.vfsName ?? DEFAULT_VFS_NAME\n  const worker = createOPFSWorkerInstance()\n  const nextRequestId = createWorkerRequestIdFactory()\n  const pendingRequests = new Map<string, PendingWorkerRequest>()\n  let disposed = false\n\n  const disposeWorker = (): void => {\n    if (disposed) {\n      return\n    }\n    disposed = true\n    worker.removeEventListener(`message`, onMessage)\n    worker.removeEventListener(`error`, onError)\n    worker.removeEventListener(`messageerror`, onMessageError)\n    worker.terminate()\n  }\n\n  const rejectAllPendingRequests = (error: Error): void => {\n    for (const pendingRequest of pendingRequests.values()) {\n      pendingRequest.reject(error)\n    }\n    pendingRequests.clear()\n  }\n\n  const onMessage = (event: Event): void => {\n    const messageEvent = event as MessageEvent<BrowserOPFSWorkerResponse>\n    const response = messageEvent.data\n\n    const pendingRequest = pendingRequests.get(response.requestId)\n    if (!pendingRequest) {\n      return\n    }\n    pendingRequests.delete(response.requestId)\n\n    if (response.ok) {\n      pendingRequest.resolve(response.rows ?? [])\n      return\n    }\n\n    pendingRequest.reject(createWorkerError(response.code, response.error))\n  }\n\n  const onError = (): void => {\n    rejectAllPendingRequests(\n      new PersistenceUnavailableError(`OPFS worker terminated unexpectedly`),\n    )\n    disposeWorker()\n  }\n\n  const onMessageError = (): void => {\n    rejectAllPendingRequests(\n      new PersistenceUnavailableError(\n        `OPFS worker message serialization failed`,\n      ),\n    )\n    disposeWorker()\n  }\n\n  worker.addEventListener(`message`, onMessage)\n  worker.addEventListener(`error`, onError)\n  worker.addEventListener(`messageerror`, onMessageError)\n\n  const sendWorkerRequest = <T>(\n    request: BrowserOPFSWorkerRequestWithoutId,\n  ): Promise<T> => {\n    if (disposed) {\n      return Promise.reject(\n        new InvalidPersistedCollectionConfigError(\n          `Browser OPFS worker connection is closed`,\n        ),\n      )\n    }\n\n    const requestId = nextRequestId()\n    return new Promise<T>((resolve, reject) => {\n      pendingRequests.set(requestId, {\n        resolve: (value) => {\n          resolve(value as T)\n        },\n        reject,\n      })\n      try {\n        const payload = {\n          ...request,\n          requestId,\n        } as BrowserOPFSWorkerRequest\n        worker.postMessage(payload)\n      } catch (error) {\n        pendingRequests.delete(requestId)\n        reject(\n          new PersistenceUnavailableError(\n            `Failed to send message to OPFS worker: ${(error as Error).message}`,\n          ),\n        )\n      }\n    })\n  }\n\n  try {\n    await sendWorkerRequest<void>({\n      type: `init`,\n      databaseName,\n      vfsName,\n    })\n  } catch (error) {\n    disposeWorker()\n    throw error\n  }\n\n  return {\n    execute: <TRow = unknown>(\n      sql: string,\n      params: ReadonlyArray<unknown> = [],\n    ) =>\n      sendWorkerRequest<ReadonlyArray<TRow>>({\n        type: `execute`,\n        sql,\n        params,\n      }),\n    close: async () => {\n      let closeError: unknown\n      try {\n        await sendWorkerRequest<void>({\n          type: `close`,\n        })\n      } catch (error) {\n        closeError = error\n      } finally {\n        disposeWorker()\n      }\n\n      if (closeError) {\n        throw closeError\n      }\n    },\n  }\n}\n"],"names":["PersistenceUnavailableError","InvalidPersistedCollectionConfigError","OPFSWorkerConstructor"],"mappings":"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"}

package/dist/cjs/opfs-database.d.cts

@@ -0,0 +1,10 @@
+import { BrowserWASQLiteDatabase } from './wa-sqlite-driver.cjs';
+export type OpenBrowserWASQLiteOPFSDatabaseOptions = {
+    databaseName: string;
+    vfsName?: string;
+};
+/**
+ * Creates a browser wa-sqlite database handle backed by OPFS and
+ * OPFSCoopSyncVFS.
+ */
+export declare function openBrowserWASQLiteOPFSDatabase(options: OpenBrowserWASQLiteOPFSDatabaseOptions): Promise<BrowserWASQLiteDatabase>;

package/dist/cjs/opfs-worker-protocol.d.cts

@@ -0,0 +1,32 @@
+export type BrowserOPFSWorkerErrorCode = `INVALID_CONFIG` | `PERSISTENCE_UNAVAILABLE` | `INTERNAL`;
+export type BrowserOPFSWorkerInitRequest = {
+    type: `init`;
+    requestId: string;
+    databaseName: string;
+    vfsName: string;
+};
+export type BrowserOPFSWorkerExecuteRequest = {
+    type: `execute`;
+    requestId: string;
+    sql: string;
+    params: ReadonlyArray<unknown>;
+};
+export type BrowserOPFSWorkerCloseRequest = {
+    type: `close`;
+    requestId: string;
+};
+export type BrowserOPFSWorkerRequest = BrowserOPFSWorkerInitRequest | BrowserOPFSWorkerExecuteRequest | BrowserOPFSWorkerCloseRequest;
+export type BrowserOPFSWorkerSuccessResponse = {
+    type: `response`;
+    requestId: string;
+    ok: true;
+    rows?: ReadonlyArray<Record<string, unknown>>;
+};
+export type BrowserOPFSWorkerErrorResponse = {
+    type: `response`;
+    requestId: string;
+    ok: false;
+    code: BrowserOPFSWorkerErrorCode;
+    error: string;
+};
+export type BrowserOPFSWorkerResponse = BrowserOPFSWorkerSuccessResponse | BrowserOPFSWorkerErrorResponse;

package/dist/cjs/opfs-worker.cjs

@@ -0,0 +1,11 @@
+"use strict";
+function WorkerWrapper(options) {
+  return new Worker(
+    "/assets/opfs-worker-CCciqEMo.js",
+    {
+      name: options?.name
+    }
+  );
+}
+module.exports = WorkerWrapper;
+//# sourceMappingURL=opfs-worker.cjs.map

package/dist/cjs/opfs-worker.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"opfs-worker.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;"}

package/dist/cjs/opfs-worker.d.cts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/wa-sqlite-driver.cjs

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const dbSqlitePersistenceCore = require("@tanstack/db-sqlite-persistence-core");
+function assertTransactionCallbackHasDriverArg(fn) {
+  if (fn.length > 0) {
+    return;
+  }
+  throw new dbSqlitePersistenceCore.InvalidPersistedCollectionConfigError(
+    `SQLiteDriver.transaction callback must accept the transaction driver argument`
+  );
+}
+function assertDatabaseShape(database) {
+  if (typeof database.execute !== `function`) {
+    throw new dbSqlitePersistenceCore.InvalidPersistedCollectionConfigError(
+      `Browser wa-sqlite database handle must provide execute(sql, params?)`
+    );
+  }
+}
+class BrowserWASQLiteDriver {
+  constructor(options) {
+    this.queue = Promise.resolve();
+    this.nextSavepointId = 1;
+    this.closed = false;
+    assertDatabaseShape(options.database);
+    this.database = options.database;
+  }
+  async exec(sql) {
+    await this.enqueue(async () => {
+      await this.database.execute(sql);
+    });
+  }
+  async query(sql, params = []) {
+    return this.enqueue(() => this.database.execute(sql, params));
+  }
+  async run(sql, params = []) {
+    await this.enqueue(async () => {
+      await this.database.execute(sql, params);
+    });
+  }
+  async transaction(fn) {
+    assertTransactionCallbackHasDriverArg(fn);
+    return this.enqueue(async () => {
+      await this.database.execute(`BEGIN IMMEDIATE`);
+      try {
+        const result = await fn(this.createTransactionDriver());
+        await this.database.execute(`COMMIT`);
+        return result;
+      } catch (error) {
+        try {
+          await this.database.execute(`ROLLBACK`);
+        } catch {
+        }
+        throw error;
+      }
+    });
+  }
+  async transactionWithDriver(fn) {
+    return this.transaction(fn);
+  }
+  async close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    if (typeof this.database.close === `function`) {
+      await Promise.resolve(this.database.close());
+    }
+  }
+  getDatabase() {
+    return this.database;
+  }
+  createTransactionDriver() {
+    return {
+      exec: (sql) => this.database.execute(sql).then(() => void 0),
+      query: (sql, params = []) => this.database.execute(sql, params),
+      run: (sql, params = []) => this.database.execute(sql, params).then(() => void 0),
+      transaction: (fn) => this.runNestedTransaction(fn),
+      transactionWithDriver: (fn) => this.runNestedTransaction(fn)
+    };
+  }
+  async runNestedTransaction(fn) {
+    assertTransactionCallbackHasDriverArg(fn);
+    const savepointName = `tsdb_sp_${this.nextSavepointId}`;
+    this.nextSavepointId++;
+    await this.database.execute(`SAVEPOINT ${savepointName}`);
+    try {
+      const result = await fn(this.createTransactionDriver());
+      await this.database.execute(`RELEASE SAVEPOINT ${savepointName}`);
+      return result;
+    } catch (error) {
+      await this.database.execute(`ROLLBACK TO SAVEPOINT ${savepointName}`);
+      await this.database.execute(`RELEASE SAVEPOINT ${savepointName}`);
+      throw error;
+    }
+  }
+  enqueue(operation) {
+    const queuedOperation = this.queue.then(operation, operation);
+    this.queue = queuedOperation.then(
+      () => void 0,
+      () => void 0
+    );
+    return queuedOperation;
+  }
+}
+exports.BrowserWASQLiteDriver = BrowserWASQLiteDriver;
+//# sourceMappingURL=wa-sqlite-driver.cjs.map

package/dist/cjs/wa-sqlite-driver.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"wa-sqlite-driver.cjs","sources":["../../src/wa-sqlite-driver.ts"],"sourcesContent":["import { InvalidPersistedCollectionConfigError } from '@tanstack/db-sqlite-persistence-core'\nimport type { SQLiteDriver } from '@tanstack/db-sqlite-persistence-core'\n\nexport type BrowserWASQLiteDatabase = {\n  execute: <TRow = unknown>(\n    sql: string,\n    params?: ReadonlyArray<unknown>,\n  ) => Promise<ReadonlyArray<TRow>>\n  close?: () => Promise<void> | void\n}\n\nexport type BrowserWASQLiteDriverOptions = {\n  database: BrowserWASQLiteDatabase\n}\n\nfunction assertTransactionCallbackHasDriverArg(\n  fn: (transactionDriver: SQLiteDriver) => Promise<unknown>,\n): void {\n  if (fn.length > 0) {\n    return\n  }\n\n  throw new InvalidPersistedCollectionConfigError(\n    `SQLiteDriver.transaction callback must accept the transaction driver argument`,\n  )\n}\n\nfunction assertDatabaseShape(\n  database: BrowserWASQLiteDatabase,\n): asserts database is BrowserWASQLiteDatabase {\n  if (typeof database.execute !== `function`) {\n    throw new InvalidPersistedCollectionConfigError(\n      `Browser wa-sqlite database handle must provide execute(sql, params?)`,\n    )\n  }\n}\n\nexport class BrowserWASQLiteDriver implements SQLiteDriver {\n  private readonly database: BrowserWASQLiteDatabase\n  private queue: Promise<void> = Promise.resolve()\n  private nextSavepointId = 1\n  private closed = false\n\n  constructor(options: BrowserWASQLiteDriverOptions) {\n    assertDatabaseShape(options.database)\n    this.database = options.database\n  }\n\n  async exec(sql: string): Promise<void> {\n    await this.enqueue(async () => {\n      await this.database.execute(sql)\n    })\n  }\n\n  async query<T>(\n    sql: string,\n    params: ReadonlyArray<unknown> = [],\n  ): Promise<ReadonlyArray<T>> {\n    return this.enqueue(() => this.database.execute<T>(sql, params))\n  }\n\n  async run(sql: string, params: ReadonlyArray<unknown> = []): Promise<void> {\n    await this.enqueue(async () => {\n      await this.database.execute(sql, params)\n    })\n  }\n\n  async transaction<T>(\n    fn: (transactionDriver: SQLiteDriver) => Promise<T>,\n  ): Promise<T> {\n    assertTransactionCallbackHasDriverArg(fn)\n\n    return this.enqueue(async () => {\n      await this.database.execute(`BEGIN IMMEDIATE`)\n      try {\n        const result = await fn(this.createTransactionDriver())\n        await this.database.execute(`COMMIT`)\n        return result\n      } catch (error) {\n        try {\n          await this.database.execute(`ROLLBACK`)\n        } catch {\n          // Preserve original transaction error.\n        }\n        throw error\n      }\n    })\n  }\n\n  async transactionWithDriver<T>(\n    fn: (transactionDriver: SQLiteDriver) => Promise<T>,\n  ): Promise<T> {\n    return this.transaction(fn)\n  }\n\n  async close(): Promise<void> {\n    if (this.closed) {\n      return\n    }\n    this.closed = true\n\n    if (typeof this.database.close === `function`) {\n      await Promise.resolve(this.database.close())\n    }\n  }\n\n  getDatabase(): BrowserWASQLiteDatabase {\n    return this.database\n  }\n\n  private createTransactionDriver(): SQLiteDriver {\n    return {\n      exec: (sql) => this.database.execute(sql).then(() => undefined),\n      query: <T>(sql: string, params: ReadonlyArray<unknown> = []) =>\n        this.database.execute<T>(sql, params),\n      run: (sql: string, params: ReadonlyArray<unknown> = []) =>\n        this.database.execute(sql, params).then(() => undefined),\n      transaction: <T>(fn: (transactionDriver: SQLiteDriver) => Promise<T>) =>\n        this.runNestedTransaction(fn),\n      transactionWithDriver: <T>(\n        fn: (transactionDriver: SQLiteDriver) => Promise<T>,\n      ) => this.runNestedTransaction(fn),\n    }\n  }\n\n  private async runNestedTransaction<T>(\n    fn: (transactionDriver: SQLiteDriver) => Promise<T>,\n  ): Promise<T> {\n    assertTransactionCallbackHasDriverArg(fn)\n\n    const savepointName = `tsdb_sp_${this.nextSavepointId}`\n    this.nextSavepointId++\n    await this.database.execute(`SAVEPOINT ${savepointName}`)\n    try {\n      const result = await fn(this.createTransactionDriver())\n      await this.database.execute(`RELEASE SAVEPOINT ${savepointName}`)\n      return result\n    } catch (error) {\n      await this.database.execute(`ROLLBACK TO SAVEPOINT ${savepointName}`)\n      await this.database.execute(`RELEASE SAVEPOINT ${savepointName}`)\n      throw error\n    }\n  }\n\n  private enqueue<T>(operation: () => Promise<T> | T): Promise<T> {\n    const queuedOperation = this.queue.then(operation, operation)\n    this.queue = queuedOperation.then(\n      () => undefined,\n      () => undefined,\n    )\n    return queuedOperation\n  }\n}\n"],"names":["InvalidPersistedCollectionConfigError"],"mappings":"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"}

package/dist/cjs/wa-sqlite-driver.d.cts

@@ -0,0 +1,25 @@
+import { SQLiteDriver } from '@tanstack/db-sqlite-persistence-core';
+export type BrowserWASQLiteDatabase = {
+    execute: <TRow = unknown>(sql: string, params?: ReadonlyArray<unknown>) => Promise<ReadonlyArray<TRow>>;
+    close?: () => Promise<void> | void;
+};
+export type BrowserWASQLiteDriverOptions = {
+    database: BrowserWASQLiteDatabase;
+};
+export declare class BrowserWASQLiteDriver implements SQLiteDriver {
+    private readonly database;
+    private queue;
+    private nextSavepointId;
+    private closed;
+    constructor(options: BrowserWASQLiteDriverOptions);
+    exec(sql: string): Promise<void>;
+    query<T>(sql: string, params?: ReadonlyArray<unknown>): Promise<ReadonlyArray<T>>;
+    run(sql: string, params?: ReadonlyArray<unknown>): Promise<void>;
+    transaction<T>(fn: (transactionDriver: SQLiteDriver) => Promise<T>): Promise<T>;
+    transactionWithDriver<T>(fn: (transactionDriver: SQLiteDriver) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+    getDatabase(): BrowserWASQLiteDatabase;
+    private createTransactionDriver;
+    private runNestedTransaction;
+    private enqueue;
+}

package/dist/esm/browser-coordinator.d.ts

@@ -0,0 +1,67 @@
+import { ApplyLocalMutationsResponse, PersistedCollectionCoordinator, PersistedIndexSpec, PersistedMutationEnvelope, PersistenceAdapter, ProtocolEnvelope, PullSinceResponse } from '@tanstack/db-sqlite-persistence-core';
+import { LoadSubsetOptions } from '@tanstack/db';
+type AdapterWithPullSince = PersistenceAdapter<Record<string, unknown>, string | number> & {
+    pullSince?: (collectionId: string, fromRowVersion: number) => Promise<{
+        latestRowVersion: number;
+        requiresFullReload: true;
+    } | {
+        latestRowVersion: number;
+        requiresFullReload: false;
+        changedKeys: Array<string | number>;
+        deletedKeys: Array<string | number>;
+    }>;
+    getStreamPosition?: (collectionId: string) => Promise<{
+        latestTerm: number;
+        latestSeq: number;
+        latestRowVersion: number;
+    }>;
+};
+export type BrowserCollectionCoordinatorOptions = {
+    dbName: string;
+    adapter?: AdapterWithPullSince;
+};
+export declare class BrowserCollectionCoordinator implements PersistedCollectionCoordinator {
+    private readonly nodeId;
+    private readonly dbName;
+    private adapter;
+    private readonly channel;
+    private readonly collections;
+    private readonly pendingRPCs;
+    private readonly appliedEnvelopeIds;
+    private disposed;
+    /** Method indirection to prevent TypeScript from narrowing `disposed` across awaits */
+    private isDisposed;
+    private requireAdapter;
+    constructor(options: BrowserCollectionCoordinatorOptions);
+    /**
+     * Set or replace the persistence adapter used for leader-side RPC handling.
+     * Called by `createBrowserWASQLitePersistence` to wire the internally-created
+     * adapter into the coordinator.
+     */
+    setAdapter(adapter: AdapterWithPullSince): void;
+    getNodeId(): string;
+    subscribe(collectionId: string, onMessage: (message: ProtocolEnvelope<unknown>) => void): () => void;
+    publish(_collectionId: string, message: ProtocolEnvelope<unknown>): void;
+    isLeader(collectionId: string): boolean;
+    ensureLeadership(collectionId: string): Promise<void>;
+    requestEnsureRemoteSubset(collectionId: string, options: LoadSubsetOptions): Promise<void>;
+    requestEnsurePersistedIndex(collectionId: string, signature: string, spec: PersistedIndexSpec): Promise<void>;
+    requestApplyLocalMutations(collectionId: string, mutations: Array<PersistedMutationEnvelope>): Promise<ApplyLocalMutationsResponse>;
+    pullSince(collectionId: string, fromRowVersion: number): Promise<PullSinceResponse>;
+    dispose(): void;
+    private ensureCollectionState;
+    private acquireLeadership;
+    private releaseLeadership;
+    private emitHeartbeat;
+    private onChannelMessage;
+    private sendRPC;
+    private sendRPCOnce;
+    private handleRPCRequest;
+    private handleEnsureRemoteSubset;
+    private handleEnsurePersistedIndex;
+    private handleApplyLocalMutations;
+    private handlePullSince;
+    private withWriterLock;
+    private pruneAppliedEnvelopeIds;
+}
+export {};