event-sourced-collection 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 my-tanstack-db-collections contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,377 @@
+# @tanstack-db-collections/event-sourced
+
+Event-sourced local-first database on top of TanStack DB persistence. Every `insert`, `update`, and `delete` is logged to a SQLite event table and synced to your backend when online.
+
+## Install
+
+```bash
+npm install @tanstack-db-collections/event-sourced @tanstack/db @tanstack/db-sqlite-persistence-core
+```
+
+Plus a platform package:
+
+```bash
+# Browser
+npm install @tanstack/browser-db-sqlite-persistence
+
+# React Native
+npm install @tanstack/react-native-db-sqlite-persistence
+```
+
+## Quick start
+
+### 1. Define types
+
+```typescript
+type User = {
+  id: string;
+  name: string;
+  email: string;
+  createdAt: number;
+};
+
+type Todo = {
+  id: string;
+  userId: string;
+  title: string;
+  status: "pending" | "complete";
+  createdAt: number;
+  updatedAt: number;
+};
+
+type AppSettings = {
+  id: string;
+  theme: "light" | "dark";
+  language: string;
+};
+```
+
+### 2. Create the database and collections
+
+Register collections in the `collections` option — that is how they are created. There is no separate `createUsersCollection()` call.
+
+```typescript
+import { createCollection } from "@tanstack/react-db";
+import {
+  BrowserCollectionCoordinator,
+  createBrowserWASQLitePersistence,
+  openBrowserWASQLiteOPFSDatabase,
+  persistedCollectionOptions,
+} from "@tanstack/browser-db-sqlite-persistence";
+import { createEventSourcedDB } from "@tanstack-db-collections/event-sourced";
+import { createBrowserPlatform } from "@tanstack-db-collections/event-sourced/browser";
+
+const platform = await createBrowserPlatform(
+  {
+    openBrowserWASQLiteOPFSDatabase,
+    createBrowserWASQLitePersistence,
+    BrowserCollectionCoordinator,
+  },
+  { databaseName: "my-app.sqlite" },
+);
+
+export const db = await createEventSourcedDB({
+  persistence: platform.persistence,
+  createCollection,
+  persistedCollectionOptions,
+  sync: {
+    pushEvents: (events) => typedRpc.events.push({ events }),
+    pullEvents: ({ since }) => typedRpc.events.pull({ since }),
+  },
+  collections: {
+    users: { getKey: (u: User) => u.id },
+    todos: { getKey: (t: Todo) => t.id },
+    settings: { getKey: (s: AppSettings) => s.id },
+  },
+});
+```
+
+After setup you get:
+
+- `db.collections.users`
+- `db.collections.todos`
+- `db.collections.settings`
+
+Plus two built-in collections that are always available, even with no sync configured:
+
+- `db.collections.outbox` — local mutations waiting to be pushed to the server
+- `db.collections.inbox` — server events that have been pulled to this device
+
+Both are normal queryable collections, so you can visualize sync state directly in your UI (see [Inspecting sync state](#inspecting-sync-state)). `outbox` and `inbox` are reserved ids — defining a collection with either name throws.
+
+### 3. Write data
+
+Use collections like normal TanStack DB. Mutations are logged to the event store automatically.
+
+```typescript
+import { db } from "./db";
+
+const userId = crypto.randomUUID();
+
+db.collections.users.insert({
+  id: userId,
+  name: "Alice",
+  email: "alice@example.com",
+  createdAt: Date.now(),
+});
+
+db.collections.todos.insert({
+  id: crypto.randomUUID(),
+  userId,
+  title: "Buy groceries",
+  status: "pending",
+  createdAt: Date.now(),
+  updatedAt: Date.now(),
+});
+
+db.collections.settings.insert({
+  id: "app",
+  theme: "dark",
+  language: "en",
+});
+
+db.collections.todos.update("todo-id", (draft) => {
+  draft.status = "complete";
+  draft.updatedAt = Date.now();
+});
+
+db.collections.todos.delete("todo-id");
+```
+
+For `settings`, use a fixed id (e.g. `"app"`) as a singleton row:
+
+```typescript
+db.collections.settings.update("app", (draft) => {
+  draft.theme = "light";
+});
+```
+
+### 4. Read data
+
+```typescript
+import { useLiveQuery } from "@tanstack/react-db";
+import { db } from "./db";
+
+function TodoList() {
+  const { data: todos = [] } = useLiveQuery((q) =>
+    q.from({ todo: db.collections.todos }),
+  );
+
+  const { data: users = [] } = useLiveQuery((q) =>
+    q.from({ user: db.collections.users }),
+  );
+
+  const { data: settings = [] } = useLiveQuery((q) =>
+    q.from({ setting: db.collections.settings }),
+  );
+
+  return (
+    <ul>
+      {todos.map((todo) => (
+        <li key={todo.id}>
+          {todo.title} — {users.find((u) => u.id === todo.userId)?.name}
+        </li>
+      ))}
+    </ul>
+  );
+}
+```
+
+### 5. Sync
+
+```typescript
+const result = await db.sync();
+
+window.addEventListener("online", () => db.sync());
+```
+
+## Inspecting sync state
+
+`outbox` and `inbox` are queryable collections. Each row carries a `sync` flag:
+
+- **outbox** — `sync: false` until the event has been pushed to the server successfully. `sync: true` means the server accepted it (and assigned a `globalSeq`). Outbox rows also include `syncStatus`, `attemptCount`, `lastAttemptAt`, `lastError`, `lastErrorCode`, and `retryable` for push diagnostics.
+- **inbox** — `sync: false` until the event has been replayed on top of local data. `sync: true` means it has been applied to the relevant collection.
+
+```typescript
+import { useLiveQuery } from "@tanstack/react-db";
+import { eq } from "@tanstack/db";
+import { db } from "./db";
+
+function SyncStatus() {
+  const { data: unpushed = [] } = useLiveQuery((q) =>
+    q.from({ e: db.collections.outbox }).where(({ e }) => eq(e.sync, false)),
+  );
+
+  const { data: incoming = [] } = useLiveQuery((q) =>
+    q.from({ e: db.collections.inbox }),
+  );
+
+  return (
+    <p>
+      {unpushed.length} pending upload · {incoming.length} received
+    </p>
+  );
+}
+```
+
+## How it works
+
+| Step | What happens |
+| ---- | ------------ |
+| Register collections | `collections: { users, todos, settings }` in `createEventSourcedDB` |
+| Access them | `db.collections.users`, etc. |
+| Write data | `.insert()`, `.update()`, `.delete()` |
+| Log mutations | Each write appends a row to `db.collections.outbox` (`sync: false`) |
+| Read data | `useLiveQuery` against those collections |
+| Sync | `await db.sync()` pushes the outbox and pulls into the inbox |
+
+On push, confirmed outbox rows flip to `sync: true` with their server `globalSeq`. On pull, new server events are written to `inbox` (`sync: false`), replayed into the target collection via `acceptMutations`, then flipped to `sync: true`. The client's own events come back on pull and are written to `inbox` as already applied. The pull cursor is derived from the highest synced `globalSeq` in `inbox` — there is no separate cursor table.
+
+## Server contract
+
+### `POST /api/events`
+
+Request: array of outbound events (`eventId`, `collectionId`, `type`, `key`, `payload`, `timestamp`).
+
+Response:
+
+```json
+{
+  "confirmed": [{ "eventId": "...", "globalSeq": 100 }],
+  "failed": [{ "eventId": "...", "message": "Validation failed", "code": "VALIDATION_ERROR", "retryable": false }]
+}
+```
+
+### `GET /api/events?since={globalSeq}`
+
+Response:
+
+```json
+{
+  "events": [{ "globalSeq": 102, "eventId": "...", "collectionId": "todos", "type": "insert", "key": "...", "payload": {}, "timestamp": 0, "cursor": "102" }],
+  "cursor": "102",
+  "hasMore": false
+}
+```
+
+Minimal PostgreSQL schema:
+
+```sql
+CREATE TABLE events (
+  global_seq        BIGSERIAL PRIMARY KEY,
+  event_id          TEXT NOT NULL UNIQUE,
+  collection_id     TEXT NOT NULL,
+  type              TEXT NOT NULL CHECK (type IN ('insert', 'update', 'delete')),
+  key               TEXT NOT NULL,
+  payload           JSONB NOT NULL,
+  client_timestamp  BIGINT NOT NULL
+);
+
+CREATE INDEX idx_events_global_seq ON events (global_seq);
+```
+
+## Sync Options
+
+You can run fully offline by omitting `sync`. In that mode local mutations still append to `outbox`, and `sync()` is a no-op.
+
+Use typed functions when your app already has RPC/server-function clients:
+
+```typescript
+import type { PullResponse, PushResponse } from "@tanstack-db-collections/event-sourced";
+
+const sync = {
+  pushEvents: async (events): Promise<PushResponse> => {
+    return typedRpc.events.push({ events });
+  },
+  pullEvents: async ({ since }): Promise<PullResponse> => {
+    return typedRpc.events.pull({ since });
+  },
+};
+
+const db = await createEventSourcedDB({ sync, /* ... */ });
+```
+
+Use URLs when you want the built-in HTTP adapter:
+
+```typescript
+const db = await createEventSourcedDB({
+  sync: {
+    pushUrl: "/api/events",
+    pullUrl: "/api/events",
+    headers: () => ({ Authorization: `Bearer ${getAccessToken()}` }),
+  },
+  /* ... */
+});
+```
+
+You can provide only `pushEvents`/`pushUrl` for upload-only sync or only `pullEvents`/`pullUrl` for download-only sync. If both a function and URL are provided for the same direction, the function is used.
+
+For existing integrations, the legacy shapes still work:
+
+```typescript
+import type { SyncTransport } from "@tanstack-db-collections/event-sourced";
+
+const transport: SyncTransport = {
+  async push(events) { /* return confirmed event ids + globalSeq */ },
+  async pull(since) { /* return { events, cursor, hasMore } */ },
+};
+
+const db = await createEventSourcedDB({ sync: transport, /* ... */ });
+```
+
+## React Native
+
+```typescript
+import { createCollection } from "@tanstack/react-native-db";
+import { createReactNativeSQLitePersistence, persistedCollectionOptions } from "@tanstack/react-native-db-sqlite-persistence";
+import { createEventSourcedDB } from "@tanstack-db-collections/event-sourced";
+import { createReactNativePlatform } from "@tanstack-db-collections/event-sourced/react-native";
+import { openDatabase } from "react-native-op-sqlite";
+
+const platform = createReactNativePlatform(
+  { createReactNativeSQLitePersistence },
+  { database: openDatabase({ name: "my-app.sqlite" }) },
+);
+
+export const db = await createEventSourcedDB({
+  persistence: platform.persistence,
+  createCollection,
+  persistedCollectionOptions,
+  collections: {
+    users: { getKey: (u: User) => u.id },
+    todos: { getKey: (t: Todo) => t.id },
+  },
+});
+```
+
+Insert, update, delete, `useLiveQuery`, and `sync()` work the same as in the browser.
+
+## Cleanup
+
+```typescript
+db.dispose();
+await platform.close();
+```
+
+## API
+
+### `createEventSourcedDB(config)`
+
+| Option | Required | Description |
+| ------ | -------- | ----------- |
+| `persistence` | Yes | TanStack DB persistence config |
+| `createCollection` | Yes | TanStack DB `createCollection` |
+| `persistedCollectionOptions` | Yes | From your platform package |
+| `collections` | Yes | Collection definitions (`getKey`, optional `schemaVersion`) — must not use the reserved ids `outbox`/`inbox` |
+| `sync` | No | Offline by default. Accepts typed `pushEvents`/`pullEvents`, URL `pushUrl`/`pullUrl`, legacy URL `push`/`pull`, or legacy `SyncTransport` |
+| `schemaVersion` | No | Default `1` |
+
+Returns `{ collections, sync, manualSync, dispose }`, where `collections` includes your registered collections plus the built-in `outbox` and `inbox`.
+
+### `createBrowserPlatform(deps, config)`
+
+Import from `@tanstack-db-collections/event-sourced/browser`. Sets up browser SQLite + multi-tab coordinator.
+
+### `createReactNativePlatform(deps, config)`
+
+Import from `@tanstack-db-collections/event-sourced/react-native`. Sets up React Native SQLite persistence.

package/dist/browser.d.mts

@@ -0,0 +1,34 @@
+import { x as SQLiteDriver } from "./types-CAT14Tbj.mjs";
+import { PersistedCollectionCoordinator, PersistedCollectionPersistence } from "@tanstack/db-sqlite-persistence-core";
+import { BrowserCollectionCoordinatorOptions, BrowserWASQLiteDatabase as BrowserWASQLiteDatabase$1, BrowserWASQLitePersistenceOptions, OpenBrowserWASQLiteOPFSDatabaseOptions } from "@tanstack/browser-db-sqlite-persistence";
+
+//#region src/platforms/browser-types.d.ts
+type BrowserCoordinatorInstance = PersistedCollectionCoordinator & {
+  dispose: () => void;
+};
+type BrowserPlatformDeps = {
+  openBrowserWASQLiteOPFSDatabase: (options: OpenBrowserWASQLiteOPFSDatabaseOptions) => Promise<BrowserWASQLiteDatabase$1>;
+  createBrowserWASQLitePersistence: (options: BrowserWASQLitePersistenceOptions) => PersistedCollectionPersistence;
+  BrowserCollectionCoordinator: new (options: BrowserCollectionCoordinatorOptions) => BrowserCoordinatorInstance;
+};
+type BrowserPlatformConfig = {
+  databaseName: string;
+  coordinatorDbName?: string;
+};
+type BrowserPlatformResult = {
+  driver: SQLiteDriver;
+  persistence: PersistedCollectionPersistence;
+  close: () => Promise<void>;
+};
+//#endregion
+//#region src/platforms/browser-wa-sqlite-driver.d.ts
+type BrowserWASQLiteDatabase = {
+  execute: <TRow = unknown>(sql: string, params?: ReadonlyArray<unknown>) => Promise<ReadonlyArray<TRow>>;
+  close?: () => Promise<void> | void;
+};
+//#endregion
+//#region src/platforms/browser.d.ts
+declare function createBrowserPlatform(deps: BrowserPlatformDeps, config: BrowserPlatformConfig): Promise<BrowserPlatformResult>;
+//#endregion
+export { type BrowserCoordinatorInstance, type BrowserPlatformConfig, type BrowserPlatformDeps, type BrowserPlatformResult, type BrowserWASQLiteDatabase, createBrowserPlatform };
+//# sourceMappingURL=browser.d.mts.map

package/dist/browser.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.mts","names":[],"sources":["../src/platforms/browser-types.ts","../src/platforms/browser-wa-sqlite-driver.ts","../src/platforms/browser.ts"],"mappings":";;;;;KAQY,0BAAA,GAA6B,8BAA8B;EACrE,OAAO;AAAA;AAAA,KAGG,mBAAA;EACV,+BAAA,GACE,OAAA,EAAS,sCAAA,KACN,OAAA,CAAQ,yBAAA;EACb,gCAAA,GACE,OAAA,EAAS,iCAAA,KACN,8BAAA;EACL,4BAAA,OACE,OAAA,EAAS,mCAAA,KACN,0BAAA;AAAA;AAAA,KAGK,qBAAA;EACV,YAAA;EACA,iBAAiB;AAAA;AAAA,KAGP,qBAAA;EACV,MAAA,EAD+B,YAAA;EAE/B,WAAA,EAAa,8BAAA;EACb,KAAA,QAAa,OAAA;AAAA;;;KC9BH,uBAAA;EACV,OAAA,mBACE,GAAA,UACA,MAAA,GAAS,aAAA,cACN,OAAA,CAAQ,aAAA,CAAc,IAAA;EAC3B,KAAA,SAAc,OAAA;AAAA;;;iBCUM,qBAAA,CACpB,IAAA,EAAM,mBAAA,EACN,MAAA,EAAQ,qBAAA,GACP,OAAA,CAAQ,qBAAA"}

package/dist/browser.mjs

@@ -0,0 +1,107 @@
+//#region src/platforms/browser-wa-sqlite-driver.ts
+function assertTransactionCallbackHasDriverArg(fn) {
+	if (fn.length > 0) return;
+	throw new Error("SQLiteDriver.transaction callback must accept the transaction driver argument");
+}
+function assertDatabaseShape(database) {
+	if (typeof database.execute !== "function") throw new Error("Browser wa-sqlite database handle must provide execute(sql, params?)");
+}
+var BrowserWASQLiteDriver = class {
+	database;
+	queue = Promise.resolve();
+	nextSavepointId = 1;
+	closed = false;
+	constructor(database) {
+		assertDatabaseShape(database);
+		this.database = 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());
+	}
+	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;
+	}
+};
+//#endregion
+//#region src/platforms/browser.ts
+async function createBrowserPlatform(deps, config) {
+	const database = await deps.openBrowserWASQLiteOPFSDatabase({ databaseName: config.databaseName });
+	const coordinator = new deps.BrowserCollectionCoordinator({ dbName: config.coordinatorDbName ?? config.databaseName.replace(/\.sqlite$/, "") });
+	const persistence = deps.createBrowserWASQLitePersistence({
+		database,
+		coordinator
+	});
+	const driver = new BrowserWASQLiteDriver(database);
+	return {
+		driver,
+		persistence,
+		close: async () => {
+			coordinator.dispose();
+			await driver.close();
+		}
+	};
+}
+//#endregion
+export { createBrowserPlatform };
+
+//# sourceMappingURL=browser.mjs.map

package/dist/browser.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.mjs","names":[],"sources":["../src/platforms/browser-wa-sqlite-driver.ts","../src/platforms/browser.ts"],"sourcesContent":["import type { SQLiteDriver } from \"../types\";\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\nfunction assertTransactionCallbackHasDriverArg(\n  fn: (transactionDriver: SQLiteDriver) => Promise<unknown>,\n): void {\n  if (fn.length > 0) {\n    return;\n  }\n\n  throw new Error(\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 Error(\"Browser wa-sqlite database handle must provide execute(sql, params?)\");\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(database: BrowserWASQLiteDatabase) {\n    assertDatabaseShape(database);\n    this.database = 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>(sql: string, params: ReadonlyArray<unknown> = []): 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>(fn: (transactionDriver: SQLiteDriver) => Promise<T>): 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        }\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  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>(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","import type { PersistedCollectionPersistence } from \"../types\";\nimport { BrowserWASQLiteDriver } from \"./browser-wa-sqlite-driver\";\nimport type {\n  BrowserPlatformConfig,\n  BrowserPlatformDeps,\n  BrowserPlatformResult,\n} from \"./browser-types\";\n\nexport type {\n  BrowserCoordinatorInstance,\n  BrowserPlatformConfig,\n  BrowserPlatformDeps,\n  BrowserPlatformResult,\n} from \"./browser-types\";\n\nexport type { BrowserWASQLiteDatabase } from \"./browser-wa-sqlite-driver\";\n\nexport async function createBrowserPlatform(\n  deps: BrowserPlatformDeps,\n  config: BrowserPlatformConfig,\n): Promise<BrowserPlatformResult> {\n  const database = await deps.openBrowserWASQLiteOPFSDatabase({\n    databaseName: config.databaseName,\n  });\n\n  const coordinator = new deps.BrowserCollectionCoordinator({\n    dbName: config.coordinatorDbName ?? config.databaseName.replace(/\\.sqlite$/, \"\"),\n  });\n\n  const persistence = deps.createBrowserWASQLitePersistence({\n    database,\n    coordinator,\n  });\n\n  const driver = new BrowserWASQLiteDriver(database);\n\n  return {\n    driver,\n    persistence,\n    close: async () => {\n      coordinator.dispose();\n      await driver.close();\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/index.d.mts

@@ -0,0 +1,25 @@
+import { A as PersistedCollectionOptionsFn, C as SyncHandlersConfig, D as EventSourcedLogger, E as SyncUrlConfig, O as createEventSourcedLogger, S as ServerEvent, T as SyncTransport, _ as PushEventsFn, a as InboxEntry, b as ReservedCollections, c as ManualSyncResult, d as OutboxEntry, f as OutboxSyncStatus, g as PushConfirmation, h as PullResponse, i as EventSourcedDBConfig, k as CreateCollectionFn, l as MutationType, m as PullEventsFn, n as CollectionMap, o as InferKey, p as PersistedCollectionPersistence, r as EventSourcedDB, s as InferState, t as CollectionDef, u as OutboundEvent, v as PushFailure, w as SyncResult, x as SQLiteDriver, y as PushResponse } from "./types-CAT14Tbj.mjs";
+import { uuidv7 as generateEventId } from "uuidv7";
+
+//#region src/create-event-sourced-db.d.ts
+type CollectionDefConstraint = {
+  getKey: (state: never) => string | number;
+  schemaVersion?: number;
+};
+declare function createEventSourcedDB<const TDefs extends Record<string, CollectionDefConstraint>>(config: EventSourcedDBConfig<TDefs>): Promise<EventSourcedDB<TDefs>>;
+//#endregion
+//#region src/sync.d.ts
+declare function createHttpTransport(config: SyncUrlConfig): SyncTransport;
+declare class SyncPushError extends Error {
+  readonly status: number;
+  readonly body: string;
+  constructor(status: number, body: string);
+}
+declare class SyncPullError extends Error {
+  readonly status: number;
+  readonly body: string;
+  constructor(status: number, body: string);
+}
+//#endregion
+export { type CollectionDef, type CollectionMap, type CreateCollectionFn, type EventSourcedDB, type EventSourcedDBConfig, type EventSourcedLogger, type InboxEntry, type InferKey, type InferState, type ManualSyncResult, type MutationType, type OutboundEvent, type OutboxEntry, type OutboxSyncStatus, type PersistedCollectionOptionsFn, type PersistedCollectionPersistence, type PullEventsFn, type PullResponse, type PushConfirmation, type PushEventsFn, type PushFailure, type PushResponse, type ReservedCollections, type SQLiteDriver, type ServerEvent, type SyncHandlersConfig, SyncPullError, SyncPushError, type SyncResult, type SyncTransport, type SyncUrlConfig, createEventSourcedDB, createEventSourcedLogger, createHttpTransport, generateEventId };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/create-event-sourced-db.ts","../src/sync.ts"],"mappings":";;;;KAuBK,uBAAA;EACH,MAAA,GAAS,KAAA;EACT,aAAA;AAAA;AAAA,iBAsCoB,oBAAA,qBACA,MAAA,SAAe,uBAAA,GACnC,MAAA,EAAQ,oBAAA,CAAqB,KAAA,IAAS,OAAA,CAAQ,cAAA,CAAe,KAAA;;;iBC9C/C,mBAAA,CAAoB,MAAA,EAAQ,aAAA,GAAgB,aAAa;AAAA,cAwI5D,aAAA,SAAsB,KAAK;EAAA,SAEpB,MAAA;EAAA,SACA,IAAA;cADA,MAAA,UACA,IAAA;AAAA;AAAA,cAOP,aAAA,SAAsB,KAAK;EAAA,SAEpB,MAAA;EAAA,SACA,IAAA;cADA,MAAA,UACA,IAAA;AAAA"}