@rocicorp/zero 1.11.0-canary.3 → 1.11.0-canary.30

package/out/replicache/src/get-kv-store-provider.js

@@ -1,12 +1,12 @@
+import { IDBStore, dropIDBStore } from "./kv/idb-store.js";
 import { MemStore, dropMemStore } from "./kv/mem-store.js";
-import { dropIDBStoreWithMemFallback, newIDBStoreWithMemFallback } from "./kv/idb-store-with-mem-fallback.js";
 //#region ../replicache/src/get-kv-store-provider.ts
-function getKVStoreProvider(lc, kvStore) {
+function getKVStoreProvider(_lc, kvStore) {
 	switch (kvStore) {
 		case "idb":
 		case void 0: return {
-			create: (name) => newIDBStoreWithMemFallback(lc, name),
-			drop: dropIDBStoreWithMemFallback
+			create: (name) => new IDBStore(name),
+			drop: dropIDBStore
 		};
 		case "mem": return {
 			create: (name) => new MemStore(name),

package/out/replicache/src/get-kv-store-provider.js.map

@@ -1 +1 @@
-{"version":3,"file":"get-kv-store-provider.js","names":[],"sources":["../../../../replicache/src/get-kv-store-provider.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {\n  dropIDBStoreWithMemFallback,\n  newIDBStoreWithMemFallback,\n} from './kv/idb-store-with-mem-fallback.ts';\nimport {dropMemStore, MemStore} from './kv/mem-store.ts';\nimport type {StoreProvider} from './kv/store.ts';\n\nexport function getKVStoreProvider(\n  lc: LogContext,\n  kvStore: 'mem' | 'idb' | StoreProvider | undefined,\n): StoreProvider {\n  switch (kvStore) {\n    case 'idb':\n    case undefined:\n      return {\n        create: name => newIDBStoreWithMemFallback(lc, name),\n        drop: dropIDBStoreWithMemFallback,\n      };\n    case 'mem':\n      return {\n        create: name => new MemStore(name),\n        drop: name => dropMemStore(name),\n      };\n    default:\n      return kvStore;\n  }\n}\n"],"mappings":";;;AAQA,SAAgB,mBACd,IACA,SACe;CACf,QAAQ,SAAR;EACE,KAAK;EACL,KAAK,KAAA,GACH,OAAO;GACL,SAAQ,SAAQ,2BAA2B,IAAI,IAAI;GACnD,MAAM;EACR;EACF,KAAK,OACH,OAAO;GACL,SAAQ,SAAQ,IAAI,SAAS,IAAI;GACjC,OAAM,SAAQ,aAAa,IAAI;EACjC;EACF,SACE,OAAO;CACX;AACF"}
+{"version":3,"file":"get-kv-store-provider.js","names":[],"sources":["../../../../replicache/src/get-kv-store-provider.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {dropIDBStore, IDBStore} from './kv/idb-store.ts';\nimport {dropMemStore, MemStore} from './kv/mem-store.ts';\nimport type {StoreProvider} from './kv/store.ts';\n\nexport function getKVStoreProvider(\n  _lc: LogContext,\n  kvStore: 'mem' | 'idb' | StoreProvider | undefined,\n): StoreProvider {\n  switch (kvStore) {\n    case 'idb':\n    case undefined:\n      return {\n        create: name => new IDBStore(name),\n        drop: dropIDBStore,\n      };\n    case 'mem':\n      return {\n        create: name => new MemStore(name),\n        drop: name => dropMemStore(name),\n      };\n    default:\n      return kvStore;\n  }\n}\n"],"mappings":";;;AAKA,SAAgB,mBACd,KACA,SACe;CACf,QAAQ,SAAR;EACE,KAAK;EACL,KAAK,KAAA,GACH,OAAO;GACL,SAAQ,SAAQ,IAAI,SAAS,IAAI;GACjC,MAAM;EACR;EACF,KAAK,OACH,OAAO;GACL,SAAQ,SAAQ,IAAI,SAAS,IAAI;GACjC,OAAM,SAAQ,aAAa,IAAI;EACjC;EACF,SACE,OAAO;CACX;AACF"}

package/out/replicache/src/kv/expo-sqlite/store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../../../../replicache/src/kv/expo-sqlite/store.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAGV,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,aAAa,CAAC;AAE/C,MAAM,MAAM,sBAAsB,GAAG,kBAAkB,CAAC;AAExD,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,sBAAsB,GAC5B,OAAO,CAAC,IAAI,CAAC,CAEf;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,CAAC,EAAE,sBAAsB,GAC5B,aAAa,CAMf"}
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../../../../replicache/src/kv/expo-sqlite/store.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAGV,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,aAAa,CAAC;AAE/C,MAAM,MAAM,sBAAsB,GAAG,kBAAkB,CAAC;AAExD,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,sBAAsB,GAC5B,OAAO,CAAC,IAAI,CAAC,CAEf;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,CAAC,EAAE,sBAAsB,GAC5B,aAAa,CAWf"}

package/out/replicache/src/kv/expo-sqlite/store.js

@@ -1,4 +1,5 @@
 import { SQLiteStore, dropStore } from "../sqlite-store.js";
+import { Lock } from "@rocicorp/lock";
 import { deleteDatabaseSync, openDatabaseSync } from "expo-sqlite";
 //#region ../replicache/src/kv/expo-sqlite/store.ts
 function dropExpoSQLiteStore(name, opts) {
@@ -11,20 +12,42 @@ function dropExpoSQLiteStore(name, opts) {
 */
 function expoSQLiteStoreProvider(opts) {
 	return {
-		create: (name) => new SQLiteStore(name, (name) => new ExpoSQLiteDatabase(name), opts),
+		create: (name) => new SQLiteStore(name, (name) => new ExpoSQLiteDatabase(name), opts, "expo-sqlite"),
 		drop: (name) => dropExpoSQLiteStore(name, opts)
 	};
 }
+/**
+* An expo-sqlite prepared statement is a stateful cursor over a single
+* `sqlite3_stmt`: `executeForRawResultAsync` resets, rebinds and steps the
+* first row, and the returned result's `getAllAsync` then steps the *remaining*
+* rows of whatever the statement is currently bound to. Both are separate
+* native round trips.
+*
+* `SQLiteStore` shares one prepared statement per SQL across all concurrent
+* readers, so without serialization reader B's `executeForRawResultAsync` can
+* rebind the statement inside reader A's await gap, and A's `getAllAsync` then
+* returns B's rows (and B is starved of them). That yields wrong or missing
+* values and, when a ref count delta is computed from such a read and written,
+* a persistently corrupted store.
+*
+* Every call on a statement is therefore run under a per-statement lock so the
+* execute + fetch pair is atomic with respect to other users of that statement.
+*/
 var ExpoSQLitePreparedStatement = class {
 	#statement;
+	#lock = new Lock();
 	constructor(statement) {
 		this.#statement = statement;
 	}
-	async exec(params) {
-		await this.#statement.executeForRawResultAsync(params);
+	exec(params) {
+		return this.#lock.withLock(async () => {
+			await this.#statement.executeForRawResultAsync(params);
+		});
 	}
-	async all(params) {
-		return (await this.#statement.executeForRawResultAsync(params)).getAllAsync();
+	all(params) {
+		return this.#lock.withLock(async () => {
+			return await (await this.#statement.executeForRawResultAsync(params)).getAllAsync();
+		});
 	}
 };
 var ExpoSQLiteDatabase = class {

package/out/replicache/src/kv/expo-sqlite/store.js.map

@@ -1 +1 @@
-{"version":3,"file":"store.js","names":["#statement","#db","#filename","#statements"],"sources":["../../../../../../replicache/src/kv/expo-sqlite/store.ts"],"sourcesContent":["import {\n  deleteDatabaseSync,\n  openDatabaseSync,\n  type SQLiteDatabase as DB,\n  type SQLiteStatement,\n} from 'expo-sqlite';\nimport type {\n  PreparedStatement,\n  SQLiteDatabase,\n  SQLiteStoreOptions,\n} from '../sqlite-store.ts';\nimport {dropStore, SQLiteStore} from '../sqlite-store.ts';\nimport type {StoreProvider} from '../store.ts';\n\nexport type ExpoSQLiteStoreOptions = SQLiteStoreOptions;\n\nexport function dropExpoSQLiteStore(\n  name: string,\n  opts?: ExpoSQLiteStoreOptions,\n): Promise<void> {\n  return dropStore(name, filename => new ExpoSQLiteDatabase(filename), opts);\n}\n\n/**\n * Creates a StoreProvider for SQLite-based stores using expo-sqlite.\n * Supports shared connections between multiple store instances with the same name,\n * providing efficient resource utilization and proper transaction isolation.\n */\nexport function expoSQLiteStoreProvider(\n  opts?: ExpoSQLiteStoreOptions,\n): StoreProvider {\n  return {\n    create: name =>\n      new SQLiteStore(name, name => new ExpoSQLiteDatabase(name), opts),\n    drop: name => dropExpoSQLiteStore(name, opts),\n  };\n}\n\nclass ExpoSQLitePreparedStatement implements PreparedStatement {\n  readonly #statement: SQLiteStatement;\n\n  constructor(statement: SQLiteStatement) {\n    this.#statement = statement;\n  }\n\n  async exec(params: string[]): Promise<void> {\n    await this.#statement.executeForRawResultAsync(params);\n  }\n\n  async all(params: string[]): Promise<unknown[][]> {\n    const result = await this.#statement.executeForRawResultAsync(params);\n    return result.getAllAsync() as Promise<unknown[][]>;\n  }\n}\n\nclass ExpoSQLiteDatabase implements SQLiteDatabase {\n  readonly #db: DB;\n  readonly #filename: string;\n  readonly #statements: Set<SQLiteStatement> = new Set();\n\n  constructor(filename: string) {\n    this.#filename = filename;\n    this.#db = openDatabaseSync(filename);\n  }\n\n  close(): void {\n    for (const stmt of this.#statements) {\n      stmt.finalizeSync();\n    }\n    this.#db.closeSync();\n  }\n\n  destroy(): void {\n    deleteDatabaseSync(this.#filename);\n  }\n\n  prepare(sql: string): PreparedStatement {\n    const statement = this.#db.prepareSync(sql);\n    this.#statements.add(statement);\n    return new ExpoSQLitePreparedStatement(statement);\n  }\n\n  execSync(sql: string): void {\n    this.#db.execSync(sql);\n  }\n}\n"],"mappings":";;;AAgBA,SAAgB,oBACd,MACA,MACe;CACf,OAAO,UAAU,OAAM,aAAY,IAAI,mBAAmB,QAAQ,GAAG,IAAI;AAC3E;;;;;;AAOA,SAAgB,wBACd,MACe;CACf,OAAO;EACL,SAAQ,SACN,IAAI,YAAY,OAAM,SAAQ,IAAI,mBAAmB,IAAI,GAAG,IAAI;EAClE,OAAM,SAAQ,oBAAoB,MAAM,IAAI;CAC9C;AACF;AAEA,IAAM,8BAAN,MAA+D;CAC7D;CAEA,YAAY,WAA4B;EACtC,KAAKA,aAAa;CACpB;CAEA,MAAM,KAAK,QAAiC;EAC1C,MAAM,KAAKA,WAAW,yBAAyB,MAAM;CACvD;CAEA,MAAM,IAAI,QAAwC;EAEhD,QAAO,MADc,KAAKA,WAAW,yBAAyB,MAAM,GACtD,YAAY;CAC5B;AACF;AAEA,IAAM,qBAAN,MAAmD;CACjD;CACA;CACA,8BAA6C,IAAI,IAAI;CAErD,YAAY,UAAkB;EAC5B,KAAKE,YAAY;EACjB,KAAKD,MAAM,iBAAiB,QAAQ;CACtC;CAEA,QAAc;EACZ,KAAK,MAAM,QAAQ,KAAKE,aACtB,KAAK,aAAa;EAEpB,KAAKF,IAAI,UAAU;CACrB;CAEA,UAAgB;EACd,mBAAmB,KAAKC,SAAS;CACnC;CAEA,QAAQ,KAAgC;EACtC,MAAM,YAAY,KAAKD,IAAI,YAAY,GAAG;EAC1C,KAAKE,YAAY,IAAI,SAAS;EAC9B,OAAO,IAAI,4BAA4B,SAAS;CAClD;CAEA,SAAS,KAAmB;EAC1B,KAAKF,IAAI,SAAS,GAAG;CACvB;AACF"}
+{"version":3,"file":"store.js","names":["#statement","#lock","#db","#filename","#statements"],"sources":["../../../../../../replicache/src/kv/expo-sqlite/store.ts"],"sourcesContent":["import {Lock} from '@rocicorp/lock';\nimport {\n  deleteDatabaseSync,\n  openDatabaseSync,\n  type SQLiteDatabase as DB,\n  type SQLiteStatement,\n} from 'expo-sqlite';\nimport type {\n  PreparedStatement,\n  SQLiteDatabase,\n  SQLiteStoreOptions,\n} from '../sqlite-store.ts';\nimport {dropStore, SQLiteStore} from '../sqlite-store.ts';\nimport type {StoreProvider} from '../store.ts';\n\nexport type ExpoSQLiteStoreOptions = SQLiteStoreOptions;\n\nexport function dropExpoSQLiteStore(\n  name: string,\n  opts?: ExpoSQLiteStoreOptions,\n): Promise<void> {\n  return dropStore(name, filename => new ExpoSQLiteDatabase(filename), opts);\n}\n\n/**\n * Creates a StoreProvider for SQLite-based stores using expo-sqlite.\n * Supports shared connections between multiple store instances with the same name,\n * providing efficient resource utilization and proper transaction isolation.\n */\nexport function expoSQLiteStoreProvider(\n  opts?: ExpoSQLiteStoreOptions,\n): StoreProvider {\n  return {\n    create: name =>\n      new SQLiteStore(\n        name,\n        name => new ExpoSQLiteDatabase(name),\n        opts,\n        'expo-sqlite',\n      ),\n    drop: name => dropExpoSQLiteStore(name, opts),\n  };\n}\n\n/**\n * An expo-sqlite prepared statement is a stateful cursor over a single\n * `sqlite3_stmt`: `executeForRawResultAsync` resets, rebinds and steps the\n * first row, and the returned result's `getAllAsync` then steps the *remaining*\n * rows of whatever the statement is currently bound to. Both are separate\n * native round trips.\n *\n * `SQLiteStore` shares one prepared statement per SQL across all concurrent\n * readers, so without serialization reader B's `executeForRawResultAsync` can\n * rebind the statement inside reader A's await gap, and A's `getAllAsync` then\n * returns B's rows (and B is starved of them). That yields wrong or missing\n * values and, when a ref count delta is computed from such a read and written,\n * a persistently corrupted store.\n *\n * Every call on a statement is therefore run under a per-statement lock so the\n * execute + fetch pair is atomic with respect to other users of that statement.\n */\nclass ExpoSQLitePreparedStatement implements PreparedStatement {\n  readonly #statement: SQLiteStatement;\n  readonly #lock = new Lock();\n\n  constructor(statement: SQLiteStatement) {\n    this.#statement = statement;\n  }\n\n  exec(params: string[]): Promise<void> {\n    return this.#lock.withLock(async () => {\n      await this.#statement.executeForRawResultAsync(params);\n    });\n  }\n\n  all(params: string[]): Promise<unknown[][]> {\n    return this.#lock.withLock(async () => {\n      const result = await this.#statement.executeForRawResultAsync(params);\n      // Must be awaited inside the lock so that no other caller can reset the\n      // statement before all rows have been stepped.\n      return (await result.getAllAsync()) as unknown[][];\n    });\n  }\n}\n\nclass ExpoSQLiteDatabase implements SQLiteDatabase {\n  readonly #db: DB;\n  readonly #filename: string;\n  readonly #statements: Set<SQLiteStatement> = new Set();\n\n  constructor(filename: string) {\n    this.#filename = filename;\n    this.#db = openDatabaseSync(filename);\n  }\n\n  close(): void {\n    for (const stmt of this.#statements) {\n      stmt.finalizeSync();\n    }\n    this.#db.closeSync();\n  }\n\n  destroy(): void {\n    deleteDatabaseSync(this.#filename);\n  }\n\n  prepare(sql: string): PreparedStatement {\n    const statement = this.#db.prepareSync(sql);\n    this.#statements.add(statement);\n    return new ExpoSQLitePreparedStatement(statement);\n  }\n\n  execSync(sql: string): void {\n    this.#db.execSync(sql);\n  }\n}\n"],"mappings":";;;;AAiBA,SAAgB,oBACd,MACA,MACe;CACf,OAAO,UAAU,OAAM,aAAY,IAAI,mBAAmB,QAAQ,GAAG,IAAI;AAC3E;;;;;;AAOA,SAAgB,wBACd,MACe;CACf,OAAO;EACL,SAAQ,SACN,IAAI,YACF,OACA,SAAQ,IAAI,mBAAmB,IAAI,GACnC,MACA,aACF;EACF,OAAM,SAAQ,oBAAoB,MAAM,IAAI;CAC9C;AACF;;;;;;;;;;;;;;;;;;AAmBA,IAAM,8BAAN,MAA+D;CAC7D;CACA,QAAiB,IAAI,KAAK;CAE1B,YAAY,WAA4B;EACtC,KAAKA,aAAa;CACpB;CAEA,KAAK,QAAiC;EACpC,OAAO,KAAKC,MAAM,SAAS,YAAY;GACrC,MAAM,KAAKD,WAAW,yBAAyB,MAAM;EACvD,CAAC;CACH;CAEA,IAAI,QAAwC;EAC1C,OAAO,KAAKC,MAAM,SAAS,YAAY;GAIrC,OAAQ,OAAM,MAHO,KAAKD,WAAW,yBAAyB,MAAM,GAG/C,YAAY;EACnC,CAAC;CACH;AACF;AAEA,IAAM,qBAAN,MAAmD;CACjD;CACA;CACA,8BAA6C,IAAI,IAAI;CAErD,YAAY,UAAkB;EAC5B,KAAKG,YAAY;EACjB,KAAKD,MAAM,iBAAiB,QAAQ;CACtC;CAEA,QAAc;EACZ,KAAK,MAAM,QAAQ,KAAKE,aACtB,KAAK,aAAa;EAEpB,KAAKF,IAAI,UAAU;CACrB;CAEA,UAAgB;EACd,mBAAmB,KAAKC,SAAS;CACnC;CAEA,QAAQ,KAAgC;EACtC,MAAM,YAAY,KAAKD,IAAI,YAAY,GAAG;EAC1C,KAAKE,YAAY,IAAI,SAAS;EAC9B,OAAO,IAAI,4BAA4B,SAAS;CAClD;CAEA,SAAS,KAAmB;EAC1B,KAAKF,IAAI,SAAS,GAAG;CACvB;AACF"}

package/out/replicache/src/kv/idb-store.d.ts

@@ -1,3 +1,4 @@
+import { StorageFailureError } from '../storage-failure.ts';
 import type { Read, Store, Write } from './store.ts';
 export declare class IDBStore implements Store {
     #private;
@@ -6,6 +7,7 @@ export declare class IDBStore implements Store {
     write(): Promise<Write>;
     close(): Promise<void>;
     get closed(): boolean;
+    get kind(): string;
 }
 /**
  * This error is thrown when we detect that the IndexedDB has been removed. This
@@ -15,4 +17,20 @@ export declare class IDBStore implements Store {
 export declare class IDBNotFoundError extends Error {
     name: string;
 }
+/**
+ * `read()` and `write()` reject with this error when the initial
+ * `indexedDB.open` failed. The browser's error is the `cause`. A failure after
+ * the database opened, such as a transaction error, is not wrapped.
+ *
+ * It is a `cannot-open` storage failure, or `full` when the browser says so
+ * (WebKit's IndexedDB is SQLite underneath and reports `database or disk is
+ * full`).
+ */
+export declare class IDBOpenError extends StorageFailureError {
+    name: string;
+    constructor(message: string, options: {
+        cause: unknown;
+    });
+}
+export declare function dropIDBStore(name: string): Promise<void>;
 //# sourceMappingURL=idb-store.d.ts.map

package/out/replicache/src/kv/idb-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"idb-store.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/kv/idb-store.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAC,MAAM,YAAY,CAAC;AAUnD,qBAAa,QAAS,YAAW,KAAK;;IAKpC,YAAY,IAAI,EAAE,MAAM,EAEvB;IAED,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAKpB;IAED,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC,CAKtB;IAEK,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAM3B;IAED,IAAI,MAAM,IAAI,OAAO,CAEpB;CA4DF;AAoHD;;;;GAIG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,IAAI,SAAsB;CAC3B"}
+{"version":3,"file":"idb-store.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/kv/idb-store.ts"],"names":[],"mappings":"AAQA,OAAO,EAAC,mBAAmB,EAAC,MAAM,uBAAuB,CAAC;AAC1D,OAAO,KAAK,EAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAC,MAAM,YAAY,CAAC;AAUnD,qBAAa,QAAS,YAAW,KAAK;;IAKpC,YAAY,IAAI,EAAE,MAAM,EAKvB;IAED,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAKpB;IAED,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC,CAKtB;IAEK,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAM3B;IAED,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,IAAI,IAAI,IAAI,MAAM,CAEjB;CA4DF;AAyHD;;;;GAIG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,IAAI,SAAsB;CAC3B;AAID;;;;;;;;GAQG;AACH,qBAAa,YAAa,SAAQ,mBAAmB;IACnD,IAAI,SAAkB;IAEtB,YAAY,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE;QAAC,KAAK,EAAE,OAAO,CAAA;KAAC,EAMrD;CACF;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAMxD"}

package/out/replicache/src/kv/idb-store.js

@@ -2,6 +2,7 @@ import { assertNotNull } from "../../../shared/src/asserts.js";
 import { mustGetBrowserGlobal } from "../../../shared/src/browser-env.js";
 import { promiseVoid } from "../../../shared/src/resolved-promises.js";
 import { deepFreezeAllowUndefined } from "../frozen-json.js";
+import { StorageFailureError } from "../storage-failure.js";
 import { storeIsClosedRejection, transactionIsClosedRejection } from "./throw-if-closed.js";
 import { WriteImplBase, deleteSentinel } from "./write-impl-base.js";
 import { resolver } from "@rocicorp/resolver";
@@ -14,6 +15,7 @@ var IDBStore = class {
 	#idbDeleted = false;
 	constructor(name) {
 		this.#db = openDatabase(name);
+		this.#db.catch(() => void 0);
 	}
 	read() {
 		if (this.#closed) return storeIsClosedRejection();
@@ -30,6 +32,9 @@ var IDBStore = class {
 	get closed() {
 		return this.#closed;
 	}
+	get kind() {
+		return "idb";
+	}
 	async #withReopen(fn) {
 		const reopenExistingDB = async (name) => {
 			const { promise, resolve, reject } = resolver();
@@ -142,7 +147,7 @@ function openDatabase(name) {
 			db.onversionchange = () => db.close();
 			resolve(db);
 		};
-		req.onerror = () => reject(req.error);
+		req.onerror = () => reject(new IDBOpenError(`Failed to open IndexedDB ${name}`, { cause: req.error }));
 	});
 }
 /**
@@ -153,7 +158,30 @@ function openDatabase(name) {
 var IDBNotFoundError = class extends Error {
 	name = "IDBNotFoundError";
 };
+var DISK_FULL = /database or disk is full/;
+/**
+* `read()` and `write()` reject with this error when the initial
+* `indexedDB.open` failed. The browser's error is the `cause`. A failure after
+* the database opened, such as a transaction error, is not wrapped.
+*
+* It is a `cannot-open` storage failure, or `full` when the browser says so
+* (WebKit's IndexedDB is SQLite underneath and reports `database or disk is
+* full`).
+*/
+var IDBOpenError = class extends StorageFailureError {
+	name = "IDBOpenError";
+	constructor(message, options) {
+		super(DISK_FULL.test(String(options.cause)) ? "full" : "cannot-open", message, options);
+	}
+};
+function dropIDBStore(name) {
+	return new Promise((resolve, reject) => {
+		const req = indexedDB.deleteDatabase(name);
+		req.onsuccess = () => resolve();
+		req.onerror = () => reject(req.error);
+	});
+}
 //#endregion
-export { IDBNotFoundError, IDBStore };
+export { IDBNotFoundError, IDBStore, dropIDBStore };
 
 //# sourceMappingURL=idb-store.js.map

package/out/replicache/src/kv/idb-store.js.map

@@ -1 +1 @@
-{"version":3,"file":"idb-store.js","names":["#db","#closed","#withReopen","#idbDeleted","#tx"],"sources":["../../../../../replicache/src/kv/idb-store.ts"],"sourcesContent":["import {resolver} from '@rocicorp/resolver';\nimport {assertNotNull} from '../../../shared/src/asserts.ts';\nimport {mustGetBrowserGlobal} from '../../../shared/src/browser-env.ts';\nimport {promiseVoid} from '../../../shared/src/resolved-promises.ts';\nimport {\n  type FrozenJSONValue,\n  deepFreezeAllowUndefined,\n} from '../frozen-json.ts';\nimport type {Read, Store, Write} from './store.ts';\nimport {\n  storeIsClosedRejection,\n  transactionIsClosedRejection,\n} from './throw-if-closed.ts';\nimport {WriteImplBase, deleteSentinel} from './write-impl-base.ts';\n\nconst RELAXED = {durability: 'relaxed'} as const;\nconst OBJECT_STORE = 'chunks';\n\nexport class IDBStore implements Store {\n  #db: Promise<IDBDatabase>;\n  #closed = false;\n  #idbDeleted = false;\n\n  constructor(name: string) {\n    this.#db = openDatabase(name);\n  }\n\n  read(): Promise<Read> {\n    if (this.#closed) {\n      return storeIsClosedRejection();\n    }\n    return this.#withReopen(readImpl);\n  }\n\n  write(): Promise<Write> {\n    if (this.#closed) {\n      return storeIsClosedRejection();\n    }\n    return this.#withReopen(writeImpl);\n  }\n\n  async close(): Promise<void> {\n    if (!this.#idbDeleted) {\n      const db = await this.#db;\n      db.close();\n    }\n    this.#closed = true;\n  }\n\n  get closed(): boolean {\n    return this.#closed;\n  }\n\n  async #withReopen<R>(fn: (db: IDBDatabase) => R): Promise<R> {\n    // Tries to reopen an IndexedDB, and rejects if the database needs\n    // upgrading (is missing for whatever reason).\n    const reopenExistingDB = async (name: string): Promise<IDBDatabase> => {\n      const {promise, resolve, reject} = resolver<IDBDatabase>();\n      const req = indexedDB.open(name);\n\n      req.onupgradeneeded = () => {\n        const tx = req.transaction;\n        assertNotNull(tx);\n        tx.abort();\n        this.#idbDeleted = true;\n        reject(\n          new IDBNotFoundError(\n            `Expected IndexedDB not found: ${name}. This likely means that the user deleted IndexedDB instances while the app was running. This is non-fatal. The app will continue running in memory until reload.`,\n          ),\n        );\n      };\n\n      req.onsuccess = () => resolve(req.result);\n      req.onerror = () => reject(req.error);\n\n      const db = await promise;\n      db.onversionchange = () => db.close();\n      return db;\n    };\n\n    // We abstract on `readImpl` to work around an issue in Safari. Safari does\n    // not allow any microtask between a transaction is created until it is\n    // first used. We used to use `await read()` here instead of `await\n    // this._db` but then there is a microtask between the creation of the\n    // transaction and the return of this function. By doing `await this._db`\n    // here we only await the db and no await is involved with the transaction.\n    // See https://github.com/jakearchibald/idb-keyval/commit/1af0a00b1a70a678d2f9cf5e74c55a22e57324c5#r55989916\n    const db = await this.#db;\n\n    try {\n      return fn(db);\n    } catch (e: unknown) {\n      if (!this.#closed && e instanceof DOMException) {\n        if (e.name === 'InvalidStateError') {\n          this.#db = reopenExistingDB(db.name);\n          const reopened = await this.#db;\n          return fn(reopened);\n        } else if (e.name === 'NotFoundError') {\n          // This edge-case can happen if the db has been deleted and the\n          // user/developer has DevTools open in certain browsers.\n          // See discussion at https://github.com/rocicorp/replicache-internal/pull/216\n          this.#idbDeleted = true;\n          mustGetBrowserGlobal('indexedDB').deleteDatabase(db.name);\n          throw new IDBNotFoundError(\n            `Expected IndexedDB ${db.name} missing object store. Deleting db. This is non-fatal, the app will continue working in memory until it is reloaded.`,\n          );\n        }\n      }\n      throw e;\n    }\n  }\n}\n\nclass ReadImpl implements Read {\n  readonly #tx: IDBTransaction;\n  #closed = false;\n\n  constructor(tx: IDBTransaction) {\n    this.#tx = tx;\n  }\n\n  has(key: string): Promise<boolean> {\n    if (this.#closed) {\n      return transactionIsClosedRejection();\n    }\n    return new Promise((resolve, reject) => {\n      const req = objectStore(this.#tx).count(key);\n      req.onsuccess = () => resolve(req.result > 0);\n      req.onerror = () => reject(req.error);\n    });\n  }\n\n  get(key: string): Promise<FrozenJSONValue | undefined> {\n    if (this.#closed) {\n      return transactionIsClosedRejection();\n    }\n    return new Promise((resolve, reject) => {\n      const req = objectStore(this.#tx).get(key);\n      req.onsuccess = () => resolve(deepFreezeAllowUndefined(req.result));\n      req.onerror = () => reject(req.error);\n    });\n  }\n\n  release(): void {\n    this.#closed = true;\n    // Do nothing. We rely on IDB locking.\n  }\n\n  get closed(): boolean {\n    return this.#closed;\n  }\n}\n\nclass WriteImpl extends WriteImplBase {\n  readonly #tx: IDBTransaction;\n  #closed = false;\n\n  constructor(tx: IDBTransaction) {\n    super(new ReadImpl(tx));\n    this.#tx = tx;\n  }\n\n  commit(): Promise<void> {\n    if (this.#closed) {\n      return transactionIsClosedRejection();\n    }\n    if (this._pending.size === 0) {\n      return promiseVoid;\n    }\n\n    return new Promise((resolve, reject) => {\n      const tx = this.#tx;\n      const store = objectStore(tx);\n      for (const [key, val] of this._pending) {\n        if (val === deleteSentinel) {\n          store.delete(key);\n        } else {\n          store.put(val, key);\n        }\n      }\n      tx.oncomplete = () => resolve();\n      tx.onerror = () => reject(tx.error);\n    });\n  }\n\n  release(): void {\n    // We rely on IDB locking so no need to do anything here.\n    this.#closed = true;\n    super.release();\n  }\n\n  get closed(): boolean {\n    return this.#closed;\n  }\n}\n\nfunction writeImpl(db: IDBDatabase): Write {\n  const tx = db.transaction(OBJECT_STORE, 'readwrite', RELAXED);\n  return new WriteImpl(tx);\n}\n\nfunction readImpl(db: IDBDatabase): Read {\n  const tx = db.transaction(OBJECT_STORE, 'readonly');\n  return new ReadImpl(tx);\n}\n\nfunction objectStore(tx: IDBTransaction): IDBObjectStore {\n  return tx.objectStore(OBJECT_STORE);\n}\n\nfunction openDatabase(name: string): Promise<IDBDatabase> {\n  const idb = mustGetBrowserGlobal('indexedDB');\n  return new Promise((resolve, reject) => {\n    const req = idb.open(name);\n    req.onupgradeneeded = () => {\n      req.result.createObjectStore(OBJECT_STORE);\n    };\n    req.onsuccess = () => {\n      const db = req.result;\n      // Another tab/process wants to modify the db, so release it.\n      db.onversionchange = () => db.close();\n      resolve(db);\n    };\n    req.onerror = () => reject(req.error);\n  });\n}\n\n/**\n * This error is thrown when we detect that the IndexedDB has been removed. This\n * does not normally happen but can happen during development if the user has\n * DevTools open and deletes the IndexedDB from there.\n */\nexport class IDBNotFoundError extends Error {\n  name = 'IDBNotFoundError';\n}\n"],"mappings":"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"}
+{"version":3,"file":"idb-store.js","names":["#db","#closed","#withReopen","#idbDeleted","#tx"],"sources":["../../../../../replicache/src/kv/idb-store.ts"],"sourcesContent":["import {resolver} from '@rocicorp/resolver';\nimport {assertNotNull} from '../../../shared/src/asserts.ts';\nimport {mustGetBrowserGlobal} from '../../../shared/src/browser-env.ts';\nimport {promiseVoid} from '../../../shared/src/resolved-promises.ts';\nimport {\n  type FrozenJSONValue,\n  deepFreezeAllowUndefined,\n} from '../frozen-json.ts';\nimport {StorageFailureError} from '../storage-failure.ts';\nimport type {Read, Store, Write} from './store.ts';\nimport {\n  storeIsClosedRejection,\n  transactionIsClosedRejection,\n} from './throw-if-closed.ts';\nimport {WriteImplBase, deleteSentinel} from './write-impl-base.ts';\n\nconst RELAXED = {durability: 'relaxed'} as const;\nconst OBJECT_STORE = 'chunks';\n\nexport class IDBStore implements Store {\n  #db: Promise<IDBDatabase>;\n  #closed = false;\n  #idbDeleted = false;\n\n  constructor(name: string) {\n    this.#db = openDatabase(name);\n    // read() and write() surface an open failure as an IDBOpenError. Don't\n    // leave an unhandled rejection when neither is called.\n    this.#db.catch(() => undefined);\n  }\n\n  read(): Promise<Read> {\n    if (this.#closed) {\n      return storeIsClosedRejection();\n    }\n    return this.#withReopen(readImpl);\n  }\n\n  write(): Promise<Write> {\n    if (this.#closed) {\n      return storeIsClosedRejection();\n    }\n    return this.#withReopen(writeImpl);\n  }\n\n  async close(): Promise<void> {\n    if (!this.#idbDeleted) {\n      const db = await this.#db;\n      db.close();\n    }\n    this.#closed = true;\n  }\n\n  get closed(): boolean {\n    return this.#closed;\n  }\n\n  get kind(): string {\n    return 'idb';\n  }\n\n  async #withReopen<R>(fn: (db: IDBDatabase) => R): Promise<R> {\n    // Tries to reopen an IndexedDB, and rejects if the database needs\n    // upgrading (is missing for whatever reason).\n    const reopenExistingDB = async (name: string): Promise<IDBDatabase> => {\n      const {promise, resolve, reject} = resolver<IDBDatabase>();\n      const req = indexedDB.open(name);\n\n      req.onupgradeneeded = () => {\n        const tx = req.transaction;\n        assertNotNull(tx);\n        tx.abort();\n        this.#idbDeleted = true;\n        reject(\n          new IDBNotFoundError(\n            `Expected IndexedDB not found: ${name}. This likely means that the user deleted IndexedDB instances while the app was running. This is non-fatal. The app will continue running in memory until reload.`,\n          ),\n        );\n      };\n\n      req.onsuccess = () => resolve(req.result);\n      req.onerror = () => reject(req.error);\n\n      const db = await promise;\n      db.onversionchange = () => db.close();\n      return db;\n    };\n\n    // We abstract on `readImpl` to work around an issue in Safari. Safari does\n    // not allow any microtask between a transaction is created until it is\n    // first used. We used to use `await read()` here instead of `await\n    // this._db` but then there is a microtask between the creation of the\n    // transaction and the return of this function. By doing `await this._db`\n    // here we only await the db and no await is involved with the transaction.\n    // See https://github.com/jakearchibald/idb-keyval/commit/1af0a00b1a70a678d2f9cf5e74c55a22e57324c5#r55989916\n    const db = await this.#db;\n\n    try {\n      return fn(db);\n    } catch (e: unknown) {\n      if (!this.#closed && e instanceof DOMException) {\n        if (e.name === 'InvalidStateError') {\n          this.#db = reopenExistingDB(db.name);\n          const reopened = await this.#db;\n          return fn(reopened);\n        } else if (e.name === 'NotFoundError') {\n          // This edge-case can happen if the db has been deleted and the\n          // user/developer has DevTools open in certain browsers.\n          // See discussion at https://github.com/rocicorp/replicache-internal/pull/216\n          this.#idbDeleted = true;\n          mustGetBrowserGlobal('indexedDB').deleteDatabase(db.name);\n          throw new IDBNotFoundError(\n            `Expected IndexedDB ${db.name} missing object store. Deleting db. This is non-fatal, the app will continue working in memory until it is reloaded.`,\n          );\n        }\n      }\n      throw e;\n    }\n  }\n}\n\nclass ReadImpl implements Read {\n  readonly #tx: IDBTransaction;\n  #closed = false;\n\n  constructor(tx: IDBTransaction) {\n    this.#tx = tx;\n  }\n\n  has(key: string): Promise<boolean> {\n    if (this.#closed) {\n      return transactionIsClosedRejection();\n    }\n    return new Promise((resolve, reject) => {\n      const req = objectStore(this.#tx).count(key);\n      req.onsuccess = () => resolve(req.result > 0);\n      req.onerror = () => reject(req.error);\n    });\n  }\n\n  get(key: string): Promise<FrozenJSONValue | undefined> {\n    if (this.#closed) {\n      return transactionIsClosedRejection();\n    }\n    return new Promise((resolve, reject) => {\n      const req = objectStore(this.#tx).get(key);\n      req.onsuccess = () => resolve(deepFreezeAllowUndefined(req.result));\n      req.onerror = () => reject(req.error);\n    });\n  }\n\n  release(): void {\n    this.#closed = true;\n    // Do nothing. We rely on IDB locking.\n  }\n\n  get closed(): boolean {\n    return this.#closed;\n  }\n}\n\nclass WriteImpl extends WriteImplBase {\n  readonly #tx: IDBTransaction;\n  #closed = false;\n\n  constructor(tx: IDBTransaction) {\n    super(new ReadImpl(tx));\n    this.#tx = tx;\n  }\n\n  commit(): Promise<void> {\n    if (this.#closed) {\n      return transactionIsClosedRejection();\n    }\n    if (this._pending.size === 0) {\n      return promiseVoid;\n    }\n\n    return new Promise((resolve, reject) => {\n      const tx = this.#tx;\n      const store = objectStore(tx);\n      for (const [key, val] of this._pending) {\n        if (val === deleteSentinel) {\n          store.delete(key);\n        } else {\n          store.put(val, key);\n        }\n      }\n      tx.oncomplete = () => resolve();\n      tx.onerror = () => reject(tx.error);\n    });\n  }\n\n  release(): void {\n    // We rely on IDB locking so no need to do anything here.\n    this.#closed = true;\n    super.release();\n  }\n\n  get closed(): boolean {\n    return this.#closed;\n  }\n}\n\nfunction writeImpl(db: IDBDatabase): Write {\n  const tx = db.transaction(OBJECT_STORE, 'readwrite', RELAXED);\n  return new WriteImpl(tx);\n}\n\nfunction readImpl(db: IDBDatabase): Read {\n  const tx = db.transaction(OBJECT_STORE, 'readonly');\n  return new ReadImpl(tx);\n}\n\nfunction objectStore(tx: IDBTransaction): IDBObjectStore {\n  return tx.objectStore(OBJECT_STORE);\n}\n\nfunction openDatabase(name: string): Promise<IDBDatabase> {\n  const idb = mustGetBrowserGlobal('indexedDB');\n  return new Promise((resolve, reject) => {\n    const req = idb.open(name);\n    req.onupgradeneeded = () => {\n      req.result.createObjectStore(OBJECT_STORE);\n    };\n    req.onsuccess = () => {\n      const db = req.result;\n      // Another tab/process wants to modify the db, so release it.\n      db.onversionchange = () => db.close();\n      resolve(db);\n    };\n    req.onerror = () =>\n      reject(\n        new IDBOpenError(`Failed to open IndexedDB ${name}`, {\n          cause: req.error,\n        }),\n      );\n  });\n}\n\n/**\n * This error is thrown when we detect that the IndexedDB has been removed. This\n * does not normally happen but can happen during development if the user has\n * DevTools open and deletes the IndexedDB from there.\n */\nexport class IDBNotFoundError extends Error {\n  name = 'IDBNotFoundError';\n}\n\nconst DISK_FULL = /database or disk is full/;\n\n/**\n * `read()` and `write()` reject with this error when the initial\n * `indexedDB.open` failed. The browser's error is the `cause`. A failure after\n * the database opened, such as a transaction error, is not wrapped.\n *\n * It is a `cannot-open` storage failure, or `full` when the browser says so\n * (WebKit's IndexedDB is SQLite underneath and reports `database or disk is\n * full`).\n */\nexport class IDBOpenError extends StorageFailureError {\n  name = 'IDBOpenError';\n\n  constructor(message: string, options: {cause: unknown}) {\n    super(\n      DISK_FULL.test(String(options.cause)) ? 'full' : 'cannot-open',\n      message,\n      options,\n    );\n  }\n}\n\nexport function dropIDBStore(name: string): Promise<void> {\n  return new Promise((resolve, reject) => {\n    const req = indexedDB.deleteDatabase(name);\n    req.onsuccess = () => resolve();\n    req.onerror = () => reject(req.error);\n  });\n}\n"],"mappings":"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"}

package/out/replicache/src/kv/mem-fallback-store.d.ts

@@ -0,0 +1,54 @@
+import { type StorageFailureError } from '../storage-failure.ts';
+import type { Read, Store, StoreProvider, Write } from './store.ts';
+/** Whether an instance moved onto a memory store of this name. */
+export declare function isFallbackStore(name: string): boolean;
+/** Creates and drops the memory stores instances fell back to. */
+export declare const fallbackStoreProvider: StoreProvider;
+/**
+ * Wraps a {@link StoreProvider} so that the stores it creates move onto memory
+ * together when their storage fails while the instance is opening (see
+ * `onStorageFailure`): a store whose `create` throws a
+ * {@link StorageFailureError} starts on a {@link MemStore}, and after
+ * {@link fallBack} the other stores switch on their next `read()` or
+ * `write()`. The memory stores keep the same names, so drops reach them too.
+ *
+ * Only before {@link opened}. After that the in-memory dag holds data loaded
+ * from the real store and loads more on demand, which an empty memory store
+ * cannot serve, so a failure is left to the caller. It is still reported, the
+ * first time a transaction fails to begin or to commit on a storage failure,
+ * whichever caller ran it (persist, heartbeat, garbage collection, ...).
+ */
+export declare class MemFallbackStoreProvider implements StoreProvider {
+    #private;
+    constructor(inner: StoreProvider, onFallBack: (failure: StorageFailureError) => void, onFailureAfterOpen: (failure: StorageFailureError) => void);
+    /** Set once the stores have moved onto memory. */
+    get failure(): StorageFailureError | undefined;
+    /** The open has finished; storage failures no longer move the stores. */
+    opened(): void;
+    /**
+     * Moves the stores onto memory if `error` reports a storage failure, the
+     * open has not finished, and they are not on memory already. Returns
+     * whether it moved them.
+     */
+    fallBack(error: unknown): boolean;
+    /**
+     * Reports `error` if it is a storage failure after the open. Before it,
+     * the open's own error handling decides whether to fall back.
+     */
+    report(error: unknown): void;
+    create: (name: string) => MemFallbackStore;
+    drop: (name: string) => Promise<void>;
+}
+export declare class MemFallbackStore implements Store {
+    #private;
+    constructor(name: string, store: Store, provider: MemFallbackStoreProvider);
+    read(): Promise<Read>;
+    write(): Promise<Write>;
+    /** The store currently backing this one: the real store, or memory. */
+    get backing(): Store;
+    close(): Promise<void>;
+    get closed(): boolean;
+    /** `'mem'` from the moment the stores are on memory. */
+    get kind(): string | undefined;
+}
+//# sourceMappingURL=mem-fallback-store.d.ts.map

package/out/replicache/src/kv/mem-fallback-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mem-fallback-store.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/kv/mem-fallback-store.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EAAC,IAAI,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,EAAC,MAAM,YAAY,CAAC;AASlE,kEAAkE;AAClE,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAErD;AAED,kEAAkE;AAClE,eAAO,MAAM,qBAAqB,EAAE,aAMnC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,qBAAa,wBAAyB,YAAW,aAAa;;IAO5D,YACE,KAAK,EAAE,aAAa,EACpB,UAAU,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,IAAI,EAClD,kBAAkB,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,IAAI,EAK3D;IAED,kDAAkD;IAClD,IAAI,OAAO,IAAI,mBAAmB,GAAG,SAAS,CAE7C;IAED,yEAAyE;IACzE,MAAM,IAAI,IAAI,CAEb;IAED;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAWhC;IAED;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAO3B;IAED,MAAM,SAAU,MAAM,KAAG,gBAAgB,CAYvC;IAEF,IAAI,SAAU,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC,CAGG;CACxC;AAED,qBAAa,gBAAiB,YAAW,KAAK;;IAO5C,YAAY,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,wBAAwB,EAKzE;IAEK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAK1B;IAEK,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC,CAK5B;IAOD,uEAAuE;IACvE,IAAI,OAAO,IAAI,KAAK,CAanB;IAED,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAGrB;IAED,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,wDAAwD;IACxD,IAAI,IAAI,IAAI,MAAM,GAAG,SAAS,CAE7B;CACF"}

package/out/replicache/src/kv/mem-fallback-store.js

@@ -0,0 +1,177 @@
+import { getStorageFailure } from "../storage-failure.js";
+import { MemStore, dropMemStore } from "./mem-store.js";
+//#region ../replicache/src/kv/mem-fallback-store.ts
+/**
+* The names of the memory stores instances moved onto after a storage
+* failure, in this process. Unlike the stores of a `kvStore: 'mem'` instance,
+* these are cleared by drops whatever store they are asked to drop from.
+*/
+var fellBack = /* @__PURE__ */ new Set();
+/** Whether an instance moved onto a memory store of this name. */
+function isFallbackStore(name) {
+	return fellBack.has(name);
+}
+/** Creates and drops the memory stores instances fell back to. */
+var fallbackStoreProvider = {
+	create: (name) => new MemStore(name),
+	drop: (name) => {
+		fellBack.delete(name);
+		return dropMemStore(name);
+	}
+};
+/**
+* Wraps a {@link StoreProvider} so that the stores it creates move onto memory
+* together when their storage fails while the instance is opening (see
+* `onStorageFailure`): a store whose `create` throws a
+* {@link StorageFailureError} starts on a {@link MemStore}, and after
+* {@link fallBack} the other stores switch on their next `read()` or
+* `write()`. The memory stores keep the same names, so drops reach them too.
+*
+* Only before {@link opened}. After that the in-memory dag holds data loaded
+* from the real store and loads more on demand, which an empty memory store
+* cannot serve, so a failure is left to the caller. It is still reported, the
+* first time a transaction fails to begin or to commit on a storage failure,
+* whichever caller ran it (persist, heartbeat, garbage collection, ...).
+*/
+var MemFallbackStoreProvider = class {
+	#inner;
+	#onFallBack;
+	#onFailureAfterOpen;
+	#failure;
+	#opened = false;
+	constructor(inner, onFallBack, onFailureAfterOpen) {
+		this.#inner = inner;
+		this.#onFallBack = onFallBack;
+		this.#onFailureAfterOpen = onFailureAfterOpen;
+	}
+	/** Set once the stores have moved onto memory. */
+	get failure() {
+		return this.#failure;
+	}
+	/** The open has finished; storage failures no longer move the stores. */
+	opened() {
+		this.#opened = true;
+	}
+	/**
+	* Moves the stores onto memory if `error` reports a storage failure, the
+	* open has not finished, and they are not on memory already. Returns
+	* whether it moved them.
+	*/
+	fallBack(error) {
+		if (this.#failure !== void 0 || this.#opened) return false;
+		const failure = getStorageFailure(error);
+		if (failure === void 0) return false;
+		this.#failure = failure;
+		this.#onFallBack(failure);
+		return true;
+	}
+	/**
+	* Reports `error` if it is a storage failure after the open. Before it,
+	* the open's own error handling decides whether to fall back.
+	*/
+	report(error) {
+		if (this.#opened && this.#failure === void 0) {
+			const failure = getStorageFailure(error);
+			if (failure !== void 0) this.#onFailureAfterOpen(failure);
+		}
+	}
+	create = (name) => {
+		if (this.#failure === void 0) try {
+			return new MemFallbackStore(name, this.#inner.create(name), this);
+		} catch (e) {
+			if (!this.fallBack(e)) throw e;
+		}
+		fellBack.add(name);
+		return new MemFallbackStore(name, new MemStore(name), this);
+	};
+	drop = (name) => this.#failure === void 0 ? this.#inner.drop(name) : fallbackStoreProvider.drop(name);
+};
+var MemFallbackStore = class {
+	#name;
+	#provider;
+	#store;
+	#onMemory;
+	#closed = false;
+	constructor(name, store, provider) {
+		this.#name = name;
+		this.#store = store;
+		this.#onMemory = store instanceof MemStore;
+		this.#provider = provider;
+	}
+	async read() {
+		return new ReportingRead(await this.backing.read().catch(this.#reportAndRethrow), this.#reportAndRethrow);
+	}
+	async write() {
+		return new ReportingWrite(await this.backing.write().catch(this.#reportAndRethrow), this.#reportAndRethrow);
+	}
+	#reportAndRethrow = (e) => {
+		this.#provider.report(e);
+		throw e;
+	};
+	/** The store currently backing this one: the real store, or memory. */
+	get backing() {
+		if (!this.#onMemory && !this.#closed && this.#provider.failure !== void 0) {
+			this.#store.close().catch(() => void 0);
+			this.#store = new MemStore(this.#name);
+			this.#onMemory = true;
+			fellBack.add(this.#name);
+		}
+		return this.#store;
+	}
+	close() {
+		this.#closed = true;
+		return this.#store.close();
+	}
+	get closed() {
+		return this.#closed || this.#store.closed;
+	}
+	/** `'mem'` from the moment the stores are on memory. */
+	get kind() {
+		return this.backing.kind;
+	}
+};
+/**
+* Reports a transaction that fails to end on a storage failure: its commit,
+* or its release (the SQLite store commits a read transaction and rolls back
+* an uncommitted write there). Not the per-key reads and writes: they are on
+* the hot path, and the SQLite store runs a write's statements in the commit.
+*/
+var ReportingRead = class {
+	_tx;
+	_reportAndRethrow;
+	constructor(tx, reportAndRethrow) {
+		this._tx = tx;
+		this._reportAndRethrow = reportAndRethrow;
+	}
+	has(key) {
+		return this._tx.has(key);
+	}
+	get(key) {
+		return this._tx.get(key);
+	}
+	release() {
+		try {
+			this._tx.release();
+		} catch (e) {
+			this._reportAndRethrow(e);
+		}
+	}
+	get closed() {
+		return this._tx.closed;
+	}
+};
+var ReportingWrite = class extends ReportingRead {
+	put(key, value) {
+		return this._tx.put(key, value);
+	}
+	del(key) {
+		return this._tx.del(key);
+	}
+	commit() {
+		return this._tx.commit().catch(this._reportAndRethrow);
+	}
+};
+//#endregion
+export { MemFallbackStoreProvider, fallbackStoreProvider, isFallbackStore };
+
+//# sourceMappingURL=mem-fallback-store.js.map

package/out/replicache/src/kv/mem-fallback-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mem-fallback-store.js","names":["#inner","#onFallBack","#onFailureAfterOpen","#failure","#opened","#name","#provider","#store","#onMemory","#reportAndRethrow","#closed"],"sources":["../../../../../replicache/src/kv/mem-fallback-store.ts"],"sourcesContent":["import type {ReadonlyJSONValue} from '../../../shared/src/json.ts';\nimport {\n  getStorageFailure,\n  type StorageFailureError,\n} from '../storage-failure.ts';\nimport {dropMemStore, MemStore} from './mem-store.ts';\nimport type {Read, Store, StoreProvider, Write} from './store.ts';\n\n/**\n * The names of the memory stores instances moved onto after a storage\n * failure, in this process. Unlike the stores of a `kvStore: 'mem'` instance,\n * these are cleared by drops whatever store they are asked to drop from.\n */\nconst fellBack = new Set<string>();\n\n/** Whether an instance moved onto a memory store of this name. */\nexport function isFallbackStore(name: string): boolean {\n  return fellBack.has(name);\n}\n\n/** Creates and drops the memory stores instances fell back to. */\nexport const fallbackStoreProvider: StoreProvider = {\n  create: name => new MemStore(name),\n  drop: name => {\n    fellBack.delete(name);\n    return dropMemStore(name);\n  },\n};\n\n/**\n * Wraps a {@link StoreProvider} so that the stores it creates move onto memory\n * together when their storage fails while the instance is opening (see\n * `onStorageFailure`): a store whose `create` throws a\n * {@link StorageFailureError} starts on a {@link MemStore}, and after\n * {@link fallBack} the other stores switch on their next `read()` or\n * `write()`. The memory stores keep the same names, so drops reach them too.\n *\n * Only before {@link opened}. After that the in-memory dag holds data loaded\n * from the real store and loads more on demand, which an empty memory store\n * cannot serve, so a failure is left to the caller. It is still reported, the\n * first time a transaction fails to begin or to commit on a storage failure,\n * whichever caller ran it (persist, heartbeat, garbage collection, ...).\n */\nexport class MemFallbackStoreProvider implements StoreProvider {\n  readonly #inner: StoreProvider;\n  readonly #onFallBack: (failure: StorageFailureError) => void;\n  readonly #onFailureAfterOpen: (failure: StorageFailureError) => void;\n  #failure: StorageFailureError | undefined;\n  #opened = false;\n\n  constructor(\n    inner: StoreProvider,\n    onFallBack: (failure: StorageFailureError) => void,\n    onFailureAfterOpen: (failure: StorageFailureError) => void,\n  ) {\n    this.#inner = inner;\n    this.#onFallBack = onFallBack;\n    this.#onFailureAfterOpen = onFailureAfterOpen;\n  }\n\n  /** Set once the stores have moved onto memory. */\n  get failure(): StorageFailureError | undefined {\n    return this.#failure;\n  }\n\n  /** The open has finished; storage failures no longer move the stores. */\n  opened(): void {\n    this.#opened = true;\n  }\n\n  /**\n   * Moves the stores onto memory if `error` reports a storage failure, the\n   * open has not finished, and they are not on memory already. Returns\n   * whether it moved them.\n   */\n  fallBack(error: unknown): boolean {\n    if (this.#failure !== undefined || this.#opened) {\n      return false;\n    }\n    const failure = getStorageFailure(error);\n    if (failure === undefined) {\n      return false;\n    }\n    this.#failure = failure;\n    this.#onFallBack(failure);\n    return true;\n  }\n\n  /**\n   * Reports `error` if it is a storage failure after the open. Before it,\n   * the open's own error handling decides whether to fall back.\n   */\n  report(error: unknown): void {\n    if (this.#opened && this.#failure === undefined) {\n      const failure = getStorageFailure(error);\n      if (failure !== undefined) {\n        this.#onFailureAfterOpen(failure);\n      }\n    }\n  }\n\n  create = (name: string): MemFallbackStore => {\n    if (this.#failure === undefined) {\n      try {\n        return new MemFallbackStore(name, this.#inner.create(name), this);\n      } catch (e) {\n        if (!this.fallBack(e)) {\n          throw e;\n        }\n      }\n    }\n    fellBack.add(name);\n    return new MemFallbackStore(name, new MemStore(name), this);\n  };\n\n  drop = (name: string): Promise<void> =>\n    this.#failure === undefined\n      ? this.#inner.drop(name)\n      : fallbackStoreProvider.drop(name);\n}\n\nexport class MemFallbackStore implements Store {\n  readonly #name: string;\n  readonly #provider: MemFallbackStoreProvider;\n  #store: Store;\n  #onMemory: boolean;\n  #closed = false;\n\n  constructor(name: string, store: Store, provider: MemFallbackStoreProvider) {\n    this.#name = name;\n    this.#store = store;\n    this.#onMemory = store instanceof MemStore;\n    this.#provider = provider;\n  }\n\n  async read(): Promise<Read> {\n    return new ReportingRead(\n      await this.backing.read().catch(this.#reportAndRethrow),\n      this.#reportAndRethrow,\n    );\n  }\n\n  async write(): Promise<Write> {\n    return new ReportingWrite(\n      await this.backing.write().catch(this.#reportAndRethrow),\n      this.#reportAndRethrow,\n    );\n  }\n\n  readonly #reportAndRethrow = (e: unknown): never => {\n    this.#provider.report(e);\n    throw e;\n  };\n\n  /** The store currently backing this one: the real store, or memory. */\n  get backing(): Store {\n    if (\n      !this.#onMemory &&\n      !this.#closed &&\n      this.#provider.failure !== undefined\n    ) {\n      // Not awaited: a store whose storage failed may not complete its close.\n      this.#store.close().catch(() => undefined);\n      this.#store = new MemStore(this.#name);\n      this.#onMemory = true;\n      fellBack.add(this.#name);\n    }\n    return this.#store;\n  }\n\n  close(): Promise<void> {\n    this.#closed = true;\n    return this.#store.close();\n  }\n\n  get closed(): boolean {\n    return this.#closed || this.#store.closed;\n  }\n\n  /** `'mem'` from the moment the stores are on memory. */\n  get kind(): string | undefined {\n    return this.backing.kind;\n  }\n}\n\n/**\n * Reports a transaction that fails to end on a storage failure: its commit,\n * or its release (the SQLite store commits a read transaction and rolls back\n * an uncommitted write there). Not the per-key reads and writes: they are on\n * the hot path, and the SQLite store runs a write's statements in the commit.\n */\nclass ReportingRead<R extends Read> implements Read {\n  protected readonly _tx: R;\n  protected readonly _reportAndRethrow: (e: unknown) => never;\n\n  constructor(tx: R, reportAndRethrow: (e: unknown) => never) {\n    this._tx = tx;\n    this._reportAndRethrow = reportAndRethrow;\n  }\n\n  has(key: string): Promise<boolean> {\n    return this._tx.has(key);\n  }\n\n  get(key: string): Promise<ReadonlyJSONValue | undefined> {\n    return this._tx.get(key);\n  }\n\n  release(): void {\n    try {\n      this._tx.release();\n    } catch (e) {\n      this._reportAndRethrow(e);\n    }\n  }\n\n  get closed(): boolean {\n    return this._tx.closed;\n  }\n}\n\nclass ReportingWrite extends ReportingRead<Write> implements Write {\n  put(key: string, value: ReadonlyJSONValue): Promise<void> {\n    return this._tx.put(key, value);\n  }\n\n  del(key: string): Promise<void> {\n    return this._tx.del(key);\n  }\n\n  commit(): Promise<void> {\n    return this._tx.commit().catch(this._reportAndRethrow);\n  }\n}\n"],"mappings":";;;;;;;;AAaA,IAAM,2BAAW,IAAI,IAAY;;AAGjC,SAAgB,gBAAgB,MAAuB;CACrD,OAAO,SAAS,IAAI,IAAI;AAC1B;;AAGA,IAAa,wBAAuC;CAClD,SAAQ,SAAQ,IAAI,SAAS,IAAI;CACjC,OAAM,SAAQ;EACZ,SAAS,OAAO,IAAI;EACpB,OAAO,aAAa,IAAI;CAC1B;AACF;;;;;;;;;;;;;;;AAgBA,IAAa,2BAAb,MAA+D;CAC7D;CACA;CACA;CACA;CACA,UAAU;CAEV,YACE,OACA,YACA,oBACA;EACA,KAAKA,SAAS;EACd,KAAKC,cAAc;EACnB,KAAKC,sBAAsB;CAC7B;;CAGA,IAAI,UAA2C;EAC7C,OAAO,KAAKC;CACd;;CAGA,SAAe;EACb,KAAKC,UAAU;CACjB;;;;;;CAOA,SAAS,OAAyB;EAChC,IAAI,KAAKD,aAAa,KAAA,KAAa,KAAKC,SACtC,OAAO;EAET,MAAM,UAAU,kBAAkB,KAAK;EACvC,IAAI,YAAY,KAAA,GACd,OAAO;EAET,KAAKD,WAAW;EAChB,KAAKF,YAAY,OAAO;EACxB,OAAO;CACT;;;;;CAMA,OAAO,OAAsB;EAC3B,IAAI,KAAKG,WAAW,KAAKD,aAAa,KAAA,GAAW;GAC/C,MAAM,UAAU,kBAAkB,KAAK;GACvC,IAAI,YAAY,KAAA,GACd,KAAKD,oBAAoB,OAAO;EAEpC;CACF;CAEA,UAAU,SAAmC;EAC3C,IAAI,KAAKC,aAAa,KAAA,GACpB,IAAI;GACF,OAAO,IAAI,iBAAiB,MAAM,KAAKH,OAAO,OAAO,IAAI,GAAG,IAAI;EAClE,SAAS,GAAG;GACV,IAAI,CAAC,KAAK,SAAS,CAAC,GAClB,MAAM;EAEV;EAEF,SAAS,IAAI,IAAI;EACjB,OAAO,IAAI,iBAAiB,MAAM,IAAI,SAAS,IAAI,GAAG,IAAI;CAC5D;CAEA,QAAQ,SACN,KAAKG,aAAa,KAAA,IACd,KAAKH,OAAO,KAAK,IAAI,IACrB,sBAAsB,KAAK,IAAI;AACvC;AAEA,IAAa,mBAAb,MAA+C;CAC7C;CACA;CACA;CACA;CACA,UAAU;CAEV,YAAY,MAAc,OAAc,UAAoC;EAC1E,KAAKK,QAAQ;EACb,KAAKE,SAAS;EACd,KAAKC,YAAY,iBAAiB;EAClC,KAAKF,YAAY;CACnB;CAEA,MAAM,OAAsB;EAC1B,OAAO,IAAI,cACT,MAAM,KAAK,QAAQ,KAAK,EAAE,MAAM,KAAKG,iBAAiB,GACtD,KAAKA,iBACP;CACF;CAEA,MAAM,QAAwB;EAC5B,OAAO,IAAI,eACT,MAAM,KAAK,QAAQ,MAAM,EAAE,MAAM,KAAKA,iBAAiB,GACvD,KAAKA,iBACP;CACF;CAEA,qBAA8B,MAAsB;EAClD,KAAKH,UAAU,OAAO,CAAC;EACvB,MAAM;CACR;;CAGA,IAAI,UAAiB;EACnB,IACE,CAAC,KAAKE,aACN,CAAC,KAAKE,WACN,KAAKJ,UAAU,YAAY,KAAA,GAC3B;GAEA,KAAKC,OAAO,MAAM,EAAE,YAAY,KAAA,CAAS;GACzC,KAAKA,SAAS,IAAI,SAAS,KAAKF,KAAK;GACrC,KAAKG,YAAY;GACjB,SAAS,IAAI,KAAKH,KAAK;EACzB;EACA,OAAO,KAAKE;CACd;CAEA,QAAuB;EACrB,KAAKG,UAAU;EACf,OAAO,KAAKH,OAAO,MAAM;CAC3B;CAEA,IAAI,SAAkB;EACpB,OAAO,KAAKG,WAAW,KAAKH,OAAO;CACrC;;CAGA,IAAI,OAA2B;EAC7B,OAAO,KAAK,QAAQ;CACtB;AACF;;;;;;;AAQA,IAAM,gBAAN,MAAoD;CAClD;CACA;CAEA,YAAY,IAAO,kBAAyC;EAC1D,KAAK,MAAM;EACX,KAAK,oBAAoB;CAC3B;CAEA,IAAI,KAA+B;EACjC,OAAO,KAAK,IAAI,IAAI,GAAG;CACzB;CAEA,IAAI,KAAqD;EACvD,OAAO,KAAK,IAAI,IAAI,GAAG;CACzB;CAEA,UAAgB;EACd,IAAI;GACF,KAAK,IAAI,QAAQ;EACnB,SAAS,GAAG;GACV,KAAK,kBAAkB,CAAC;EAC1B;CACF;CAEA,IAAI,SAAkB;EACpB,OAAO,KAAK,IAAI;CAClB;AACF;AAEA,IAAM,iBAAN,cAA6B,cAAsC;CACjE,IAAI,KAAa,OAAyC;EACxD,OAAO,KAAK,IAAI,IAAI,KAAK,KAAK;CAChC;CAEA,IAAI,KAA4B;EAC9B,OAAO,KAAK,IAAI,IAAI,GAAG;CACzB;CAEA,SAAwB;EACtB,OAAO,KAAK,IAAI,OAAO,EAAE,MAAM,KAAK,iBAAiB;CACvD;AACF"}

package/out/replicache/src/kv/mem-store.d.ts

@@ -19,5 +19,6 @@ export declare class MemStore implements Store {
     write(): Promise<Write>;
     close(): Promise<void>;
     get closed(): boolean;
+    get kind(): string;
 }
 //# sourceMappingURL=mem-store.d.ts.map

package/out/replicache/src/kv/mem-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mem-store.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/kv/mem-store.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAC,MAAM,YAAY,CAAC;AAUnD,wBAAgB,gCAAgC,IAAI,IAAI,CAEvD;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAGxD;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEjD;AAED;;;;;;;;;GASG;AACH,qBAAa,QAAS,YAAW,KAAK;;IAKpC,YAAY,IAAI,EAAE,MAAM,EAavB;IAEK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAI1B;IAEK,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC,CAI5B;IAED,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAGrB;IAED,IAAI,MAAM,IAAI,OAAO,CAEpB;CACF"}
+{"version":3,"file":"mem-store.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/kv/mem-store.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAC,MAAM,YAAY,CAAC;AAUnD,wBAAgB,gCAAgC,IAAI,IAAI,CAEvD;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAGxD;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEjD;AAED;;;;;;;;;GASG;AACH,qBAAa,QAAS,YAAW,KAAK;;IAKpC,YAAY,IAAI,EAAE,MAAM,EAavB;IAEK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAI1B;IAEK,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC,CAI5B;IAED,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAGrB;IAED,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}

package/out/replicache/src/kv/mem-store.js

@@ -56,6 +56,9 @@ var MemStore = class {
 	get closed() {
 		return this.#closed;
 	}
+	get kind() {
+		return "mem";
+	}
 };
 //#endregion
 export { MemStore, dropMemStore };

package/out/replicache/src/kv/mem-store.js.map

@@ -1 +1 @@
-{"version":3,"file":"mem-store.js","names":["#map","#rwLock","#closed"],"sources":["../../../../../replicache/src/kv/mem-store.ts"],"sourcesContent":["import {RWLock} from '@rocicorp/lock';\nimport {promiseVoid} from '../../../shared/src/resolved-promises.ts';\nimport type {FrozenJSONValue} from '../frozen-json.ts';\nimport {ReadImpl} from './read-impl.ts';\nimport type {Read, Store, Write} from './store.ts';\nimport {throwIfStoreClosed} from './throw-if-closed.ts';\nimport {WriteImpl} from './write-impl.ts';\n\ntype StorageMap = Map<string, FrozenJSONValue>;\n\ntype Value = {readonly lock: RWLock; readonly map: StorageMap};\n\nconst stores = new Map<string, Value>();\n\nexport function clearAllNamedMemStoresForTesting(): void {\n  stores.clear();\n}\n\nexport function dropMemStore(name: string): Promise<void> {\n  stores.delete(name);\n  return promiseVoid;\n}\n\nexport function hasMemStore(name: string): boolean {\n  return stores.has(name);\n}\n\n/**\n * A named in-memory Store implementation.\n *\n * Two (or more) named memory stores with the same name will share the same\n * underlying storage. They will also share the same read/write locks, so that\n * only one write transaction can be running at the same time.\n *\n * @experimental This class is experimental and might be removed or changed\n * in the future without following semver versioning. Please be cautious.\n */\nexport class MemStore implements Store {\n  readonly #map: StorageMap;\n  readonly #rwLock: RWLock;\n  #closed = false;\n\n  constructor(name: string) {\n    const entry = stores.get(name);\n    let lock: RWLock;\n    let map: StorageMap;\n    if (entry) {\n      ({lock, map} = entry);\n    } else {\n      lock = new RWLock();\n      map = new Map();\n      stores.set(name, {lock, map});\n    }\n    this.#rwLock = lock;\n    this.#map = map;\n  }\n\n  async read(): Promise<Read> {\n    throwIfStoreClosed(this);\n    const release = await this.#rwLock.read();\n    return new ReadImpl(this.#map, release);\n  }\n\n  async write(): Promise<Write> {\n    throwIfStoreClosed(this);\n    const release = await this.#rwLock.write();\n    return new WriteImpl(this.#map, release);\n  }\n\n  close(): Promise<void> {\n    this.#closed = true;\n    return promiseVoid;\n  }\n\n  get closed(): boolean {\n    return this.#closed;\n  }\n}\n"],"mappings":";;;;;;AAYA,IAAM,yBAAS,IAAI,IAAmB;AAMtC,SAAgB,aAAa,MAA6B;CACxD,OAAO,OAAO,IAAI;CAClB,OAAO;AACT;;;;;;;;;;;AAgBA,IAAa,WAAb,MAAuC;CACrC;CACA;CACA,UAAU;CAEV,YAAY,MAAc;EACxB,MAAM,QAAQ,OAAO,IAAI,IAAI;EAC7B,IAAI;EACJ,IAAI;EACJ,IAAI,OACF,CAAC,CAAC,MAAM,OAAO;OACV;GACL,OAAO,IAAI,OAAO;GAClB,sBAAM,IAAI,IAAI;GACd,OAAO,IAAI,MAAM;IAAC;IAAM;GAAG,CAAC;EAC9B;EACA,KAAKC,UAAU;EACf,KAAKD,OAAO;CACd;CAEA,MAAM,OAAsB;EAC1B,mBAAmB,IAAI;EACvB,MAAM,UAAU,MAAM,KAAKC,QAAQ,KAAK;EACxC,OAAO,IAAI,SAAS,KAAKD,MAAM,OAAO;CACxC;CAEA,MAAM,QAAwB;EAC5B,mBAAmB,IAAI;EACvB,MAAM,UAAU,MAAM,KAAKC,QAAQ,MAAM;EACzC,OAAO,IAAI,UAAU,KAAKD,MAAM,OAAO;CACzC;CAEA,QAAuB;EACrB,KAAKE,UAAU;EACf,OAAO;CACT;CAEA,IAAI,SAAkB;EACpB,OAAO,KAAKA;CACd;AACF"}
+{"version":3,"file":"mem-store.js","names":["#map","#rwLock","#closed"],"sources":["../../../../../replicache/src/kv/mem-store.ts"],"sourcesContent":["import {RWLock} from '@rocicorp/lock';\nimport {promiseVoid} from '../../../shared/src/resolved-promises.ts';\nimport type {FrozenJSONValue} from '../frozen-json.ts';\nimport {ReadImpl} from './read-impl.ts';\nimport type {Read, Store, Write} from './store.ts';\nimport {throwIfStoreClosed} from './throw-if-closed.ts';\nimport {WriteImpl} from './write-impl.ts';\n\ntype StorageMap = Map<string, FrozenJSONValue>;\n\ntype Value = {readonly lock: RWLock; readonly map: StorageMap};\n\nconst stores = new Map<string, Value>();\n\nexport function clearAllNamedMemStoresForTesting(): void {\n  stores.clear();\n}\n\nexport function dropMemStore(name: string): Promise<void> {\n  stores.delete(name);\n  return promiseVoid;\n}\n\nexport function hasMemStore(name: string): boolean {\n  return stores.has(name);\n}\n\n/**\n * A named in-memory Store implementation.\n *\n * Two (or more) named memory stores with the same name will share the same\n * underlying storage. They will also share the same read/write locks, so that\n * only one write transaction can be running at the same time.\n *\n * @experimental This class is experimental and might be removed or changed\n * in the future without following semver versioning. Please be cautious.\n */\nexport class MemStore implements Store {\n  readonly #map: StorageMap;\n  readonly #rwLock: RWLock;\n  #closed = false;\n\n  constructor(name: string) {\n    const entry = stores.get(name);\n    let lock: RWLock;\n    let map: StorageMap;\n    if (entry) {\n      ({lock, map} = entry);\n    } else {\n      lock = new RWLock();\n      map = new Map();\n      stores.set(name, {lock, map});\n    }\n    this.#rwLock = lock;\n    this.#map = map;\n  }\n\n  async read(): Promise<Read> {\n    throwIfStoreClosed(this);\n    const release = await this.#rwLock.read();\n    return new ReadImpl(this.#map, release);\n  }\n\n  async write(): Promise<Write> {\n    throwIfStoreClosed(this);\n    const release = await this.#rwLock.write();\n    return new WriteImpl(this.#map, release);\n  }\n\n  close(): Promise<void> {\n    this.#closed = true;\n    return promiseVoid;\n  }\n\n  get closed(): boolean {\n    return this.#closed;\n  }\n\n  get kind(): string {\n    return 'mem';\n  }\n}\n"],"mappings":";;;;;;AAYA,IAAM,yBAAS,IAAI,IAAmB;AAMtC,SAAgB,aAAa,MAA6B;CACxD,OAAO,OAAO,IAAI;CAClB,OAAO;AACT;;;;;;;;;;;AAgBA,IAAa,WAAb,MAAuC;CACrC;CACA;CACA,UAAU;CAEV,YAAY,MAAc;EACxB,MAAM,QAAQ,OAAO,IAAI,IAAI;EAC7B,IAAI;EACJ,IAAI;EACJ,IAAI,OACF,CAAC,CAAC,MAAM,OAAO;OACV;GACL,OAAO,IAAI,OAAO;GAClB,sBAAM,IAAI,IAAI;GACd,OAAO,IAAI,MAAM;IAAC;IAAM;GAAG,CAAC;EAC9B;EACA,KAAKC,UAAU;EACf,KAAKD,OAAO;CACd;CAEA,MAAM,OAAsB;EAC1B,mBAAmB,IAAI;EACvB,MAAM,UAAU,MAAM,KAAKC,QAAQ,KAAK;EACxC,OAAO,IAAI,SAAS,KAAKD,MAAM,OAAO;CACxC;CAEA,MAAM,QAAwB;EAC5B,mBAAmB,IAAI;EACvB,MAAM,UAAU,MAAM,KAAKC,QAAQ,MAAM;EACzC,OAAO,IAAI,UAAU,KAAKD,MAAM,OAAO;CACzC;CAEA,QAAuB;EACrB,KAAKE,UAAU;EACf,OAAO;CACT;CAEA,IAAI,SAAkB;EACpB,OAAO,KAAKA;CACd;CAEA,IAAI,OAAe;EACjB,OAAO;CACT;AACF"}

package/out/replicache/src/kv/op-sqlite/store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../../../../replicache/src/kv/op-sqlite/store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,aAAa,CAAC;AAG/C,MAAM,MAAM,oBAAoB,GAAG,kBAAkB,GAAG;IAEtD,QAAQ,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,WAAW,CAAC;IAC7D,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAaF;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,CAAC,EAAE,oBAAoB,GAC1B,aAAa,CAUf"}
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../../../../replicache/src/kv/op-sqlite/store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,aAAa,CAAC;AAG/C,MAAM,MAAM,oBAAoB,GAAG,kBAAkB,GAAG;IAEtD,QAAQ,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,WAAW,CAAC;IAC7D,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAaF;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,CAAC,EAAE,oBAAoB,GAC1B,aAAa,CAWf"}

package/out/replicache/src/kv/op-sqlite/store.js

@@ -12,7 +12,7 @@ function dropOpSQLiteStore(name, opts) {
 */
 function opSQLiteStoreProvider(opts) {
 	return {
-		create: (name) => new SQLiteStore(name, (name, options) => new OpSQLiteDatabase(name, options), opts),
+		create: (name) => new SQLiteStore(name, (name, options) => new OpSQLiteDatabase(name, options), opts, "op-sqlite"),
 		drop: (name) => dropOpSQLiteStore(name, opts)
 	};
 }
@@ -32,12 +32,12 @@ var OpSQLitePreparedStatement = class {
 };
 var OpSQLiteDatabase = class {
 	#db;
-	#filename;
+	#openOpts;
 	constructor(filename, opts) {
-		this.#filename = filename;
 		const openOpts = { name: filename };
 		if (opts?.location) openOpts.location = opts.location;
 		if (opts?.encryptionKey) openOpts.encryptionKey = opts.encryptionKey;
+		this.#openOpts = openOpts;
 		this.#db = open(openOpts);
 	}
 	close() {
@@ -45,7 +45,7 @@ var OpSQLiteDatabase = class {
 	}
 	destroy() {
 		try {
-			const tempDb = open({ name: this.#filename });
+			const tempDb = open(this.#openOpts);
 			tempDb.delete();
 			tempDb.close();
 		} catch (_error) {}