@rocicorp/zero 1.6.0-canary.0 → 1.6.0-canary.10

package/out/packages/replicache/src/hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.js","names":[],"sources":["../../../../../replicache/src/hash.ts"],"sourcesContent":["import {assert} from '../../shared/src/asserts.ts';\nimport {randomUint64} from '../../shared/src/random-uint64.ts';\nimport * as valita from '../../shared/src/valita.ts';\n\nexport const STRING_LENGTH = 22;\n\n// We use an opaque type so that we can make sure that a hash is always a hash.\n// TypeScript does not have direct support but we can use a trick described\n// here:\n//\n// https://evertpot.com/opaque-ts-types/\n//\n// The basic idea is to declare a type that cannot be created. We then use\n// functions that cast a string to this type.\n//\n\n// By using declare we tell the type system that there is a unique symbol.\n// However, there is no such symbol but the type system does not care.\ndeclare const hashTag: unique symbol;\n\n/**\n * Opaque type representing a hash. The only way to create one is using `parse`\n * or `hashOf` (except for static unsafe cast of course).\n */\nexport type Hash = string & {[hashTag]: true};\n\n// We are no longer using hashes but due to legacy reason we still refer to\n// them as hashes. We use UUID and counters instead.\nconst hashRe = /^[0-9a-v-]+$/;\n\nexport function parse(s: string): Hash {\n  assertHash(s);\n  return s;\n}\n\nconst emptyUUID = '0'.repeat(STRING_LENGTH);\nexport const emptyHash = emptyUUID as unknown as Hash;\n\n/**\n * Creates a function that generates random hashes.\n */\nexport const newRandomHash = makeNewRandomHashFunctionInternal();\n\nconst fakeHashRe = /^[0-9a-v]{0,8}$/;\n\n/**\n * Creates a function that generates UUID hashes for tests.\n */\nexport function makeNewFakeHashFunction(hashPrefix = 'fake'): () => Hash {\n  assert(fakeHashRe.test(hashPrefix), `Invalid hash prefix: ${hashPrefix}`);\n  let i = 0;\n  return () => {\n    const count = String(i++);\n    return (hashPrefix +\n      '0'.repeat(STRING_LENGTH - hashPrefix.length - count.length) +\n      count) as Hash;\n  };\n}\n\nfunction toStringAndSlice(n: number | bigint, len: number): string {\n  return n.toString(32).slice(-len).padStart(len, '0');\n}\n\n/**\n * This creates an ID that looks like `<RANDOM><COUNTER>`. The random part is\n * a random number encoded with base 32 and the length is 12 characters. The\n * is 10 characters long and encoded as base 32. The total length is 22 characters.\n *\n * Do the math: https://devina.io/collision-calculator\n */\nfunction makeNewRandomHashFunctionInternal(): () => Hash {\n  let base = '';\n  let i = 0;\n\n  return () => {\n    if (!base) {\n      // This needs to be lazy because the cloudflare worker environment will\n      // throw an error if crypto.getRandomValues is used statically.  Specifically:\n      // Error: Some functionality, such as asynchronous I/O, timeouts, and\n      // generating random values, can only be performed while handling a\n      // request.\n      base = toStringAndSlice(randomUint64(), 12);\n    }\n    const tail = toStringAndSlice(i++, 10);\n    return (base + tail) as Hash;\n  };\n}\n\n/**\n * Generates a fake hash useful for testing.\n */\nexport function fakeHash(word: string | number): Hash {\n  if (typeof word === 'number') {\n    word = String(word);\n  }\n  return ('fake' + '0'.repeat(STRING_LENGTH - 4 - word.length) + word) as Hash;\n}\n\nexport function isHash(value: unknown): value is Hash {\n  return typeof value === 'string' && hashRe.test(value);\n}\n\nexport function assertHash(value: unknown): asserts value is Hash {\n  valita.assert(value, hashSchema);\n}\n\nexport const hashSchema = valita.string().assert(isHash, 'Invalid hash');\n"],"mappings":";;AA4BA,IAAM,SAAS;AAQf,IAAa,YADK,IAAI,OAAA,EACG;;;;AAKzB,IAAa,gBAAgB,kCAAkC;AAkB/D,SAAS,iBAAiB,GAAoB,KAAqB;CACjE,OAAO,EAAE,SAAS,EAAE,EAAE,MAAM,CAAC,GAAG,EAAE,SAAS,KAAK,GAAG;AACrD;;;;;;;;AASA,SAAS,oCAAgD;CACvD,IAAI,OAAO;CACX,IAAI,IAAI;CAER,aAAa;EACX,IAAI,CAAC,MAMH,OAAO,iBAAiB,aAAa,GAAG,EAAE;EAE5C,MAAM,OAAO,iBAAiB,KAAK,EAAE;EACrC,OAAQ,OAAO;CACjB;AACF;AAYA,SAAgB,OAAO,OAA+B;CACpD,OAAO,OAAO,UAAU,YAAY,OAAO,KAAK,KAAK;AACvD;AAEA,SAAgB,WAAW,OAAuC;CAChE,OAAc,OAAO,UAAU;AACjC;AAEA,IAAa,aAAa,eAAO,OAAO,EAAE,OAAO,QAAQ,cAAc"}

package/out/packages/replicache/src/http-request-info.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-request-info.js","names":[],"sources":["../../../../../replicache/src/http-request-info.ts"],"sourcesContent":["import {\n  assertNumber,\n  assertObject,\n  assertString,\n} from '../../shared/src/asserts.ts';\n\nexport function assertHTTPRequestInfo(\n  v: unknown,\n): asserts v is HTTPRequestInfo {\n  assertObject(v);\n  assertNumber(v.httpStatusCode);\n  assertString(v.errorMessage);\n}\n\nexport type HTTPRequestInfo = {\n  httpStatusCode: number;\n  errorMessage: string;\n};\n"],"mappings":";;AAMA,SAAgB,sBACd,GAC8B;CAC9B,aAAa,CAAC;CACd,aAAa,EAAE,cAAc;CAC7B,aAAa,EAAE,YAAY;AAC7B"}

package/out/packages/replicache/src/index-defs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-defs.js","names":[],"sources":["../../../../../replicache/src/index-defs.ts"],"sourcesContent":["import * as valita from '../../shared/src/valita.ts';\n\n/**\n * The definition of a single index.\n */\nexport type IndexDefinition = {\n  /**\n   * The prefix, if any, to limit the index over. If not provided the values of\n   * all keys are indexed.\n   */\n  readonly prefix?: string | undefined;\n\n  /**\n   * A [JSON Pointer](https://tools.ietf.org/html/rfc6901) pointing at the sub\n   * value inside each value to index over.\n   *\n   * For example, one might index over users' ages like so:\n   * `{prefix: '/user/', jsonPointer: '/age'}`\n   */\n  readonly jsonPointer: string;\n\n  /**\n   * If `true`, indexing empty values will not emit a warning.  Defaults to `false`.\n   */\n  readonly allowEmpty?: boolean | undefined;\n};\n\nexport const indexDefinitionSchema: valita.Type<IndexDefinition> =\n  valita.readonlyObject({\n    prefix: valita.string().optional(),\n    jsonPointer: valita.string(),\n    allowEmpty: valita.boolean().optional(),\n  });\n\n/**\n * An object as a map defining the indexes. The keys are the index names and the\n * values are the index definitions.\n */\nexport type IndexDefinitions = {readonly [name: string]: IndexDefinition};\n\nexport const indexDefinitionsSchema = valita.readonlyRecord(\n  indexDefinitionSchema,\n);\n\nexport function indexDefinitionEqual(\n  a: IndexDefinition,\n  b: IndexDefinition,\n): boolean {\n  return (\n    a.jsonPointer === b.jsonPointer &&\n    (a.allowEmpty ?? false) === (b.allowEmpty ?? false) &&\n    (a.prefix ?? '') === (b.prefix ?? '')\n  );\n}\n\nexport function indexDefinitionsEqual(\n  a: IndexDefinitions,\n  b: IndexDefinitions,\n): boolean {\n  if (Object.keys(a).length !== Object.keys(b).length) {\n    return false;\n  }\n  for (const [aKey, aValue] of Object.entries(a)) {\n    const bValue = b[aKey];\n    if (!bValue || !indexDefinitionEqual(aValue, bValue)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function assertIndexDefinitions(\n  value: unknown,\n): asserts value is IndexDefinitions {\n  valita.assert(value, indexDefinitionsSchema);\n}\n"],"mappings":";AAwCA,IAAa,yBAAyB,eAZpC,eAAsB;CACpB,QAAQ,eAAO,OAAO,EAAE,SAAS;CACjC,aAAa,eAAO,OAAO;CAC3B,YAAY,eAAO,QAAQ,EAAE,SAAS;AACxC,CASA,CACF;AAEA,SAAgB,qBACd,GACA,GACS;CACT,OACE,EAAE,gBAAgB,EAAE,gBACnB,EAAE,cAAc,YAAY,EAAE,cAAc,WAC5C,EAAE,UAAU,SAAS,EAAE,UAAU;AAEtC;AAEA,SAAgB,sBACd,GACA,GACS;CACT,IAAI,OAAO,KAAK,CAAC,EAAE,WAAW,OAAO,KAAK,CAAC,EAAE,QAC3C,OAAO;CAET,KAAK,MAAM,CAAC,MAAM,WAAW,OAAO,QAAQ,CAAC,GAAG;EAC9C,MAAM,SAAS,EAAE;EACjB,IAAI,CAAC,UAAU,CAAC,qBAAqB,QAAQ,MAAM,GACjD,OAAO;CAEX;CACA,OAAO;AACT"}

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

@@ -0,0 +1,57 @@
+import { SQLiteStore, dropStore } from "../sqlite-store.js";
+import { deleteDatabaseSync, openDatabaseSync } from "expo-sqlite";
+//#region ../replicache/src/kv/expo-sqlite/store.ts
+function dropExpoSQLiteStore(name, opts) {
+	return dropStore(name, (filename) => new ExpoSQLiteDatabase(filename), opts);
+}
+/**
+* Creates a StoreProvider for SQLite-based stores using expo-sqlite.
+* Supports shared connections between multiple store instances with the same name,
+* providing efficient resource utilization and proper transaction isolation.
+*/
+function expoSQLiteStoreProvider(opts) {
+	return {
+		create: (name) => new SQLiteStore(name, (name) => new ExpoSQLiteDatabase(name), opts),
+		drop: (name) => dropExpoSQLiteStore(name, opts)
+	};
+}
+var ExpoSQLitePreparedStatement = class {
+	#statement;
+	constructor(statement) {
+		this.#statement = statement;
+	}
+	async exec(params) {
+		await this.#statement.executeForRawResultAsync(params);
+	}
+	async all(params) {
+		return (await this.#statement.executeForRawResultAsync(params)).getAllAsync();
+	}
+};
+var ExpoSQLiteDatabase = class {
+	#db;
+	#filename;
+	#statements = /* @__PURE__ */ new Set();
+	constructor(filename) {
+		this.#filename = filename;
+		this.#db = openDatabaseSync(filename);
+	}
+	close() {
+		for (const stmt of this.#statements) stmt.finalizeSync();
+		this.#db.closeSync();
+	}
+	destroy() {
+		deleteDatabaseSync(this.#filename);
+	}
+	prepare(sql) {
+		const statement = this.#db.prepareSync(sql);
+		this.#statements.add(statement);
+		return new ExpoSQLitePreparedStatement(statement);
+	}
+	execSync(sql) {
+		this.#db.execSync(sql);
+	}
+};
+//#endregion
+export { expoSQLiteStoreProvider };
+
+//# sourceMappingURL=store.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"idb-store-with-mem-fallback.js","names":["#lc","#name","#store","#withBrainTransplant"],"sources":["../../../../../../replicache/src/kv/idb-store-with-mem-fallback.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {navigator} from '../../../shared/src/navigator.ts';\nimport {promiseVoid} from '../../../shared/src/resolved-promises.ts';\nimport {IDBStore} from './idb-store.ts';\nimport {MemStore, dropMemStore} from './mem-store.ts';\nimport type {Read, Store, Write} from './store.ts';\n\n/**\n * This store uses an {@link IDBStore} by default. If the {@link IDBStore} fails\n * to open the DB with an exception that matches\n * {@link isFirefoxPrivateBrowsingError} we switch out the implementation to use\n * a {@link MemStore} instead.\n *\n * The reason this is relatively complicated is that when {@link IDBStore} is\n * created, it calls `openDatabase` synchronously, but that returns a `Promise`\n * that will reject in the case of Firefox private browsing. We don't await this\n * promise until we call `read` or `write` so we cannot do the switch until\n * then.\n */\n\nexport class IDBStoreWithMemFallback implements Store {\n  readonly #lc: LogContext;\n  readonly #name: string;\n  #store: Store;\n  constructor(lc: LogContext, name: string) {\n    this.#lc = lc;\n    this.#name = name;\n    this.#store = new IDBStore(name);\n  }\n\n  read(): Promise<Read> {\n    return this.#withBrainTransplant(s => s.read());\n  }\n\n  write(): Promise<Write> {\n    return this.#withBrainTransplant(s => s.write());\n  }\n\n  async #withBrainTransplant<T extends Read>(\n    f: (store: Store) => Promise<T>,\n  ): Promise<T> {\n    try {\n      return await f(this.#store);\n    } catch (e) {\n      if (isFirefoxPrivateBrowsingError(e)) {\n        // It is possible that we end up with multiple pending read/write and\n        // they all reject. Make sure we only replace the implementation once.\n        if (this.#store instanceof IDBStore) {\n          this.#lc.info?.(\n            'Switching to MemStore because of Firefox private browsing error',\n          );\n          this.#store = new MemStore(this.#name);\n        }\n        return f(this.#store);\n      }\n      throw e;\n    }\n  }\n\n  close(): Promise<void> {\n    return this.#store.close();\n  }\n\n  get closed(): boolean {\n    return this.#store.closed;\n  }\n}\n\nfunction isFirefoxPrivateBrowsingError(e: unknown): e is DOMException {\n  return (\n    isFirefox() &&\n    e instanceof DOMException &&\n    e.name === 'InvalidStateError' &&\n    e.message ===\n      'A mutation operation was attempted on a database that did not allow mutations.'\n  );\n}\n\nfunction isFirefox(): boolean {\n  return navigator?.userAgent?.includes('Firefox') ?? false;\n}\n\nexport function newIDBStoreWithMemFallback(\n  lc: LogContext,\n  name: string,\n): Store {\n  if (isFirefox()) {\n    return new IDBStoreWithMemFallback(lc, name);\n  }\n  return new IDBStore(name);\n}\n\nexport function dropIDBStoreWithMemFallback(name: string): Promise<void> {\n  if (!isFirefox()) {\n    return dropIDBStore(name);\n  }\n  try {\n    return dropIDBStore(name);\n  } catch (e) {\n    if (isFirefoxPrivateBrowsingError(e)) {\n      return dropMemStore(name);\n    }\n  }\n  return promiseVoid;\n}\n\nfunction 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":";;;;;;;;;;;;;;;;;AAoBA,IAAa,0BAAb,MAAsD;CACpD;CACA;CACA;CACA,YAAY,IAAgB,MAAc;EACxC,KAAKA,MAAM;EACX,KAAKC,QAAQ;EACb,KAAKC,SAAS,IAAI,SAAS,IAAI;CACjC;CAEA,OAAsB;EACpB,OAAO,KAAKC,sBAAqB,MAAK,EAAE,KAAK,CAAC;CAChD;CAEA,QAAwB;EACtB,OAAO,KAAKA,sBAAqB,MAAK,EAAE,MAAM,CAAC;CACjD;CAEA,MAAMA,qBACJ,GACY;EACZ,IAAI;GACF,OAAO,MAAM,EAAE,KAAKD,MAAM;EAC5B,SAAS,GAAG;GACV,IAAI,8BAA8B,CAAC,GAAG;IAGpC,IAAI,KAAKA,kBAAkB,UAAU;KACnC,KAAKF,IAAI,OACP,iEACF;KACA,KAAKE,SAAS,IAAI,SAAS,KAAKD,KAAK;IACvC;IACA,OAAO,EAAE,KAAKC,MAAM;GACtB;GACA,MAAM;EACR;CACF;CAEA,QAAuB;EACrB,OAAO,KAAKA,OAAO,MAAM;CAC3B;CAEA,IAAI,SAAkB;EACpB,OAAO,KAAKA,OAAO;CACrB;AACF;AAEA,SAAS,8BAA8B,GAA+B;CACpE,OACE,UAAU,KACV,aAAa,gBACb,EAAE,SAAS,uBACX,EAAE,YACA;AAEN;AAEA,SAAS,YAAqB;CAC5B,OAAO,gBAAW,WAAW,SAAS,SAAS,KAAK;AACtD;AAEA,SAAgB,2BACd,IACA,MACO;CACP,IAAI,UAAU,GACZ,OAAO,IAAI,wBAAwB,IAAI,IAAI;CAE7C,OAAO,IAAI,SAAS,IAAI;AAC1B;AAEA,SAAgB,4BAA4B,MAA6B;CACvE,IAAI,CAAC,UAAU,GACb,OAAO,aAAa,IAAI;CAE1B,IAAI;EACF,OAAO,aAAa,IAAI;CAC1B,SAAS,GAAG;EACV,IAAI,8BAA8B,CAAC,GACjC,OAAO,aAAa,IAAI;CAE5B;CACA,OAAO;AACT;AAEA,SAAS,aAAa,MAA6B;CACjD,OAAO,IAAI,SAAS,SAAS,WAAW;EACtC,MAAM,MAAM,UAAU,eAAe,IAAI;EACzC,IAAI,kBAAkB,QAAQ;EAC9B,IAAI,gBAAgB,OAAO,IAAI,KAAK;CACtC,CAAC;AACH"}

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

@@ -0,0 +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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"}

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

@@ -0,0 +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"}

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

@@ -0,0 +1,63 @@
+import { SQLiteStore, dropStore } from "../sqlite-store.js";
+import { open } from "./types.js";
+//#region ../replicache/src/kv/op-sqlite/store.ts
+function dropOpSQLiteStore(name, opts) {
+	return dropStore(name, (filename, options) => new OpSQLiteDatabase(filename, options), opts);
+}
+/**
+* Creates a StoreProvider for SQLite-based stores using @op-engineering/op-sqlite.
+* Supports shared connections between multiple store instances with the same name,
+* providing efficient resource utilization and proper transaction isolation.
+* Uses parameterized queries for safety and performance.
+*/
+function opSQLiteStoreProvider(opts) {
+	return {
+		create: (name) => new SQLiteStore(name, (name, options) => new OpSQLiteDatabase(name, options), opts),
+		drop: (name) => dropOpSQLiteStore(name, opts)
+	};
+}
+var OpSQLitePreparedStatement = class {
+	#db;
+	#sql;
+	constructor(db, sql) {
+		this.#db = db;
+		this.#sql = sql;
+	}
+	async exec(params) {
+		await this.#db.executeRaw(this.#sql, params);
+	}
+	all(params) {
+		return this.#db.executeRaw(this.#sql, params);
+	}
+};
+var OpSQLiteDatabase = class {
+	#db;
+	#filename;
+	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.#db = open(openOpts);
+	}
+	close() {
+		this.#db.close();
+	}
+	destroy() {
+		try {
+			const tempDb = open({ name: this.#filename });
+			tempDb.delete();
+			tempDb.close();
+		} catch (_error) {}
+	}
+	prepare(sql) {
+		return new OpSQLitePreparedStatement(this.#db, sql);
+	}
+	execSync(sql) {
+		this.#db.executeRawSync(sql, []);
+	}
+};
+//#endregion
+export { opSQLiteStoreProvider };
+
+//# sourceMappingURL=store.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","names":["#db","#sql","#filename"],"sources":["../../../../../../../replicache/src/kv/op-sqlite/store.ts"],"sourcesContent":["import 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';\nimport {open, type DB} from './types.ts';\n\nexport type OpSQLiteStoreOptions = SQLiteStoreOptions & {\n  // OpSQLite-specific options\n  location?: 'default' | 'Library' | 'Documents' | 'Temporary';\n  encryptionKey?: string;\n};\n\nfunction dropOpSQLiteStore(\n  name: string,\n  opts?: OpSQLiteStoreOptions,\n): Promise<void> {\n  return dropStore(\n    name,\n    (filename, options) => new OpSQLiteDatabase(filename, options),\n    opts,\n  );\n}\n\n/**\n * Creates a StoreProvider for SQLite-based stores using @op-engineering/op-sqlite.\n * Supports shared connections between multiple store instances with the same name,\n * providing efficient resource utilization and proper transaction isolation.\n * Uses parameterized queries for safety and performance.\n */\nexport function opSQLiteStoreProvider(\n  opts?: OpSQLiteStoreOptions,\n): StoreProvider {\n  return {\n    create: name =>\n      new SQLiteStore(\n        name,\n        (name, options) => new OpSQLiteDatabase(name, options),\n        opts,\n      ),\n    drop: name => dropOpSQLiteStore(name, opts),\n  };\n}\n\nclass OpSQLitePreparedStatement implements PreparedStatement {\n  readonly #db: DB;\n  readonly #sql: string;\n\n  constructor(db: DB, sql: string) {\n    this.#db = db;\n    this.#sql = sql;\n  }\n\n  async exec(params: string[]): Promise<void> {\n    await this.#db.executeRaw(this.#sql, params);\n  }\n\n  all(params: string[]): Promise<unknown[][]> {\n    return this.#db.executeRaw(this.#sql, params);\n  }\n}\n\nclass OpSQLiteDatabase implements SQLiteDatabase {\n  readonly #db: DB;\n  readonly #filename: string;\n\n  constructor(filename: string, opts?: OpSQLiteStoreOptions) {\n    this.#filename = filename;\n    const openOpts: {\n      name: string;\n      location?: string;\n      encryptionKey?: string;\n    } = {name: filename};\n\n    if (opts?.location) {\n      openOpts.location = opts.location;\n    }\n    if (opts?.encryptionKey) {\n      openOpts.encryptionKey = opts.encryptionKey;\n    }\n\n    this.#db = open(openOpts);\n  }\n\n  close(): void {\n    this.#db.close();\n  }\n\n  destroy(): void {\n    // OpSQLite uses delete method on the database instance\n    // We need to create a temporary connection to delete the database\n    try {\n      const tempDb = open({name: this.#filename});\n      tempDb.delete();\n      tempDb.close();\n    } catch (_error) {\n      // Database might not exist, which is fine\n    }\n  }\n\n  prepare(sql: string): PreparedStatement {\n    return new OpSQLitePreparedStatement(this.#db, sql);\n  }\n\n  execSync(sql: string): void {\n    this.#db.executeRawSync(sql, []);\n  }\n}\n"],"mappings":";;;AAeA,SAAS,kBACP,MACA,MACe;CACf,OAAO,UACL,OACC,UAAU,YAAY,IAAI,iBAAiB,UAAU,OAAO,GAC7D,IACF;AACF;;;;;;;AAQA,SAAgB,sBACd,MACe;CACf,OAAO;EACL,SAAQ,SACN,IAAI,YACF,OACC,MAAM,YAAY,IAAI,iBAAiB,MAAM,OAAO,GACrD,IACF;EACF,OAAM,SAAQ,kBAAkB,MAAM,IAAI;CAC5C;AACF;AAEA,IAAM,4BAAN,MAA6D;CAC3D;CACA;CAEA,YAAY,IAAQ,KAAa;EAC/B,KAAKA,MAAM;EACX,KAAKC,OAAO;CACd;CAEA,MAAM,KAAK,QAAiC;EAC1C,MAAM,KAAKD,IAAI,WAAW,KAAKC,MAAM,MAAM;CAC7C;CAEA,IAAI,QAAwC;EAC1C,OAAO,KAAKD,IAAI,WAAW,KAAKC,MAAM,MAAM;CAC9C;AACF;AAEA,IAAM,mBAAN,MAAiD;CAC/C;CACA;CAEA,YAAY,UAAkB,MAA6B;EACzD,KAAKC,YAAY;EACjB,MAAM,WAIF,EAAC,MAAM,SAAQ;EAEnB,IAAI,MAAM,UACR,SAAS,WAAW,KAAK;EAE3B,IAAI,MAAM,eACR,SAAS,gBAAgB,KAAK;EAGhC,KAAKF,MAAM,KAAK,QAAQ;CAC1B;CAEA,QAAc;EACZ,KAAKA,IAAI,MAAM;CACjB;CAEA,UAAgB;EAGd,IAAI;GACF,MAAM,SAAS,KAAK,EAAC,MAAM,KAAKE,UAAS,CAAC;GAC1C,OAAO,OAAO;GACd,OAAO,MAAM;EACf,SAAS,QAAQ,CAEjB;CACF;CAEA,QAAQ,KAAgC;EACtC,OAAO,IAAI,0BAA0B,KAAKF,KAAK,GAAG;CACpD;CAEA,SAAS,KAAmB;EAC1B,KAAKA,IAAI,eAAe,KAAK,CAAC,CAAC;CACjC;AACF"}

package/out/packages/replicache/src/kv/op-sqlite/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../../../../../replicache/src/kv/op-sqlite/types.ts"],"sourcesContent":["// Type definitions and imports for @op-engineering/op-sqlite\n// This file isolates the module resolution workarounds needed for this package\n\nimport {open as openDB} from '@op-engineering/op-sqlite';\n\n// Minimal type definitions for @op-engineering/op-sqlite\n// These types are used as fallback since imports have module resolution issues\nexport interface DB {\n  close: () => void;\n  delete: (location?: string) => void;\n  executeRaw: (query: string, params?: string[]) => Promise<string[][]>;\n  executeRawSync: (query: string, params?: string[]) => string[][];\n}\n\nexport type OpenFunction = (params: {\n  name: string;\n  location?: string;\n  encryptionKey?: string;\n}) => DB;\n\n// Export the open function with proper typing\nexport const open: OpenFunction = openDB;\n"],"mappings":";;AAqBA,IAAa,SAAqB"}

package/out/packages/replicache/src/kv/read-impl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-impl.js","names":["#map","#release","#closed"],"sources":["../../../../../../replicache/src/kv/read-impl.ts"],"sourcesContent":["import type {FrozenJSONValue} from '../frozen-json.ts';\nimport type {Read} from './store.ts';\nimport {maybeTransactionIsClosedRejection} from './throw-if-closed.ts';\n\nexport class ReadImpl implements Read {\n  readonly #map: Map<string, FrozenJSONValue>;\n  readonly #release: () => void;\n  #closed = false;\n\n  constructor(map: Map<string, FrozenJSONValue>, release: () => void) {\n    this.#map = map;\n    this.#release = release;\n  }\n\n  release() {\n    this.#release();\n    this.#closed = true;\n  }\n\n  get closed(): boolean {\n    return this.#closed;\n  }\n\n  has(key: string): Promise<boolean> {\n    return (\n      maybeTransactionIsClosedRejection(this) ??\n      Promise.resolve(this.#map.has(key))\n    );\n  }\n\n  get(key: string): Promise<FrozenJSONValue | undefined> {\n    return (\n      maybeTransactionIsClosedRejection(this) ??\n      Promise.resolve(this.#map.get(key))\n    );\n  }\n}\n"],"mappings":";;AAIA,IAAa,WAAb,MAAsC;CACpC;CACA;CACA,UAAU;CAEV,YAAY,KAAmC,SAAqB;EAClE,KAAKA,OAAO;EACZ,KAAKC,WAAW;CAClB;CAEA,UAAU;EACR,KAAKA,SAAS;EACd,KAAKC,UAAU;CACjB;CAEA,IAAI,SAAkB;EACpB,OAAO,KAAKA;CACd;CAEA,IAAI,KAA+B;EACjC,OACE,kCAAkC,IAAI,KACtC,QAAQ,QAAQ,KAAKF,KAAK,IAAI,GAAG,CAAC;CAEtC;CAEA,IAAI,KAAmD;EACrD,OACE,kCAAkC,IAAI,KACtC,QAAQ,QAAQ,KAAKA,KAAK,IAAI,GAAG,CAAC;CAEtC;AACF"}

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

@@ -0,0 +1,301 @@
+import { deepFreeze } from "../frozen-json.js";
+import { maybeTransactionIsClosedRejection, throwIfStoreClosed, transactionError } from "./throw-if-closed.js";
+import { WriteImplBase, deleteSentinel } from "./write-impl-base.js";
+import { RWLock } from "@rocicorp/lock";
+//#region ../replicache/src/kv/sqlite-store.ts
+/**
+* SQLite-based implementation of the Store interface using a configurable delegate.
+* Supports shared connections between multiple store instances with the same name,
+* providing efficient resource utilization and proper transaction isolation.
+* Uses parameterized queries for safety and performance.
+*/
+var SQLiteStore = class {
+	#filename;
+	#entry;
+	#closed = false;
+	constructor(name, create, opts) {
+		this.#filename = resolveFilename(name, opts);
+		this.#entry = getOrCreateEntry(this.#filename, create, opts);
+	}
+	async read() {
+		throwIfStoreClosed(this);
+		const entry = this.#entry;
+		const { db, lock, preparedStatements } = entry;
+		const release = await lock.read();
+		if (entry.activeReaders === 0) db.execSync("BEGIN");
+		entry.activeReaders++;
+		return new SQLiteStoreRead(() => {
+			entry.activeReaders--;
+			if (entry.activeReaders === 0) db.execSync("COMMIT");
+			release();
+		}, preparedStatements);
+	}
+	async write() {
+		throwIfStoreClosed(this);
+		const { lock, db, preparedStatements } = this.#entry;
+		const release = await lock.write();
+		db.execSync("BEGIN IMMEDIATE");
+		return new SQLiteWrite(release, db, preparedStatements);
+	}
+	async close() {
+		if (this.#closed) return;
+		const { lock, db } = this.#entry;
+		const writeRelease = await lock.write();
+		decrementStoreRefCount(this.#filename, db);
+		this.#closed = true;
+		writeRelease();
+	}
+	get closed() {
+		return this.#closed;
+	}
+};
+function safeFilename(name) {
+	return name.replace(/[^a-zA-Z0-9]/g, "_");
+}
+function resolveFilename(name, opts) {
+	const safe = safeFilename(name);
+	const dir = opts?.directory;
+	return dir ? `${dir}/${safe}` : safe;
+}
+/**
+* Common database setup logic shared between expo-sqlite and op-sqlite implementations.
+* Configures SQLite pragmas, creates the entry table, and prepares common statements.
+*/
+function setupDatabase(delegate, opts) {
+	delegate.execSync(`PRAGMA busy_timeout = ${opts?.busyTimeout ?? 200}`);
+	delegate.execSync(`PRAGMA journal_mode = '${opts?.journalMode ?? "WAL"}'`);
+	delegate.execSync(`PRAGMA synchronous = '${opts?.synchronous ?? "NORMAL"}'`);
+	delegate.execSync(`PRAGMA read_uncommitted = ${Boolean(opts?.readUncommitted)}`);
+	delegate.execSync(`
+    CREATE TABLE IF NOT EXISTS entry (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    ) WITHOUT ROWID
+  `);
+	return {
+		has: delegate.prepare(`SELECT 1 FROM entry WHERE key = ? LIMIT 1`),
+		get: delegate.prepare("SELECT value FROM entry WHERE key = ?"),
+		hasMany: delegate.prepare(`SELECT key FROM entry WHERE key IN (SELECT value FROM json_each(?))`),
+		getMany: delegate.prepare(`SELECT key, value FROM entry WHERE key IN (SELECT value FROM json_each(?))`),
+		put: delegate.prepare(`INSERT OR REPLACE INTO entry (key, value)
+   SELECT e.value->>0, e.value->1 FROM json_each(?) e`),
+		del: delegate.prepare(`DELETE FROM entry WHERE key IN (SELECT value FROM json_each(?))`)
+	};
+}
+var CB_STRIDE = 2;
+var CB_RESOLVE = 0;
+var CB_REJECT = 1;
+function rejectAll(callbacks, e) {
+	for (let i = CB_REJECT; i < callbacks.length; i += CB_STRIDE) callbacks[i](e);
+}
+function parseRawValue(raw) {
+	return raw === void 0 ? void 0 : deepFreeze(JSON.parse(raw));
+}
+function resolveGet(resolve, reject, raw) {
+	try {
+		resolve(parseRawValue(raw));
+	} catch (e) {
+		reject(e);
+	}
+}
+async function flushGets(keys, callbacks, ps) {
+	let rows;
+	try {
+		rows = keys.length === 1 ? await ps.get.all([keys[0]]) : await ps.getMany.all([JSON.stringify(keys)]);
+	} catch (e) {
+		rejectAll(callbacks, e);
+		return;
+	}
+	if (keys.length === 1) {
+		resolveGet(callbacks[CB_RESOLVE], callbacks[CB_REJECT], rows[0]?.[0]);
+		return;
+	}
+	const resultMap = new Map(rows);
+	for (let i = 0; i < keys.length; i++) resolveGet(callbacks[i * CB_STRIDE + CB_RESOLVE], callbacks[i * CB_STRIDE + CB_REJECT], resultMap.get(keys[i]));
+}
+async function flushHas(keys, callbacks, ps) {
+	let rows;
+	try {
+		rows = keys.length === 1 ? await ps.has.all([keys[0]]) : await ps.hasMany.all([JSON.stringify(keys)]);
+	} catch (e) {
+		rejectAll(callbacks, e);
+		return;
+	}
+	if (keys.length === 1) {
+		callbacks[CB_RESOLVE](rows.length > 0);
+		return;
+	}
+	const existingKeys = new Set(rows.map((row) => row[0]));
+	for (let i = 0; i < keys.length; i++) callbacks[i * CB_STRIDE + CB_RESOLVE](existingKeys.has(keys[i]));
+}
+var SQLiteStoreRead = class {
+	#release;
+	#preparedStatements;
+	#closed = false;
+	#pendingGetKeys = [];
+	#pendingGetCallbacks = [];
+	#pendingHasKeys = [];
+	#pendingHasCallbacks = [];
+	#scheduled = false;
+	constructor(release, preparedStatements) {
+		this.#release = release;
+		this.#preparedStatements = preparedStatements;
+	}
+	has(key) {
+		return maybeTransactionIsClosedRejection(this) ?? new Promise((resolve, reject) => {
+			this.#pendingHasKeys.push(key);
+			this.#pendingHasCallbacks.push(resolve, reject);
+			this.#scheduleLookup();
+		});
+	}
+	get(key) {
+		return maybeTransactionIsClosedRejection(this) ?? new Promise((resolve, reject) => {
+			this.#pendingGetKeys.push(key);
+			this.#pendingGetCallbacks.push(resolve, reject);
+			this.#scheduleLookup();
+		});
+	}
+	#scheduleLookup() {
+		if (!this.#scheduled) {
+			this.#scheduled = true;
+			queueMicrotask(() => {
+				this.#scheduled = false;
+				const ps = this.#preparedStatements;
+				const getKeys = this.#pendingGetKeys;
+				this.#pendingGetKeys = [];
+				const getCallbacks = this.#pendingGetCallbacks;
+				this.#pendingGetCallbacks = [];
+				const hasKeys = this.#pendingHasKeys;
+				this.#pendingHasKeys = [];
+				const hasCallbacks = this.#pendingHasCallbacks;
+				this.#pendingHasCallbacks = [];
+				if (this.#closed) {
+					const e = transactionError();
+					rejectAll(getCallbacks, e);
+					rejectAll(hasCallbacks, e);
+					return;
+				}
+				if (getKeys.length > 0) flushGets(getKeys, getCallbacks, ps);
+				if (hasKeys.length > 0) flushHas(hasKeys, hasCallbacks, ps);
+			});
+		}
+	}
+	release() {
+		if (!this.#closed) {
+			this.#closed = true;
+			this.#release();
+		}
+	}
+	get closed() {
+		return this.#closed;
+	}
+};
+var SQLiteWrite = class extends WriteImplBase {
+	#release;
+	#dbDelegate;
+	#preparedStatements;
+	#committed = false;
+	#closed = false;
+	constructor(release, dbDelegate, preparedStatements) {
+		super(new SQLiteStoreRead(() => void 0, preparedStatements));
+		this.#release = release;
+		this.#dbDelegate = dbDelegate;
+		this.#preparedStatements = preparedStatements;
+	}
+	async commit() {
+		if (this.#closed) throw transactionError();
+		const deleteKeys = [];
+		for (const entry of this._pending) if (entry[1] === deleteSentinel) {
+			deleteKeys.push(entry[0]);
+			this._pending.delete(entry[0]);
+		}
+		const delP = deleteKeys.length > 0 ? this.#preparedStatements.del.exec([JSON.stringify(deleteKeys)]) : void 0;
+		const putP = this._pending.size > 0 ? this.#preparedStatements.put.exec([JSON.stringify([...this._pending])]) : void 0;
+		if (putP) await putP;
+		if (delP) await delP;
+		this.#dbDelegate.execSync("COMMIT");
+		this._pending.clear();
+		this.#committed = true;
+	}
+	release() {
+		if (!this.#closed) {
+			this.#closed = true;
+			super.release();
+			let rollbackError;
+			if (!this.#committed) try {
+				this.#dbDelegate.execSync("ROLLBACK");
+			} catch (e) {
+				rollbackError = e;
+			}
+			this.#release();
+			if (rollbackError !== void 0) throw rollbackError;
+		}
+	}
+	get closed() {
+		return this.#closed;
+	}
+};
+var stores = /* @__PURE__ */ new Map();
+/**
+* Gets an existing store entry or creates a new one if it doesn't exist.
+* This implements the shared connection pattern where multiple stores with the same
+* name share the same database connection, lock, and delegate.
+*/
+function getOrCreateEntry(filename, create, opts) {
+	const entry = stores.get(filename);
+	if (entry) {
+		entry.refCount++;
+		return entry;
+	}
+	const dbDelegate = create(filename, opts);
+	const preparedStatements = setupDatabase(dbDelegate, opts);
+	const newEntry = {
+		lock: new RWLock(),
+		db: dbDelegate,
+		refCount: 1,
+		activeReaders: 0,
+		preparedStatements
+	};
+	stores.set(filename, newEntry);
+	return newEntry;
+}
+/**
+* Decrements the reference count for a shared store and cleans up resources
+* when the last reference is released.
+*/
+function decrementStoreRefCount(filename, dbDelegate) {
+	const entry = stores.get(filename);
+	if (entry) {
+		entry.refCount--;
+		if (entry.refCount <= 0) {
+			dbDelegate.close();
+			stores.delete(filename);
+		}
+	}
+}
+function clearAllNamedStoresForTesting() {
+	for (const entry of stores.values()) entry.db.close();
+	stores.clear();
+}
+function dropStore(name, createDelegate, opts) {
+	const filename = resolveFilename(name, opts);
+	const entry = stores.get(filename);
+	if (entry) {
+		try {
+			entry.db.close();
+		} catch {}
+		stores.delete(filename);
+	}
+	const tempDelegate = createDelegate(filename, opts);
+	try {
+		tempDelegate.close();
+	} catch {}
+	try {
+		tempDelegate.destroy();
+	} catch {}
+	return Promise.resolve();
+}
+//#endregion
+export { SQLiteStore, clearAllNamedStoresForTesting, dropStore };
+
+//# sourceMappingURL=sqlite-store.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-store.js","names":["#filename","#entry","#closed","#release","#preparedStatements","#pendingHasKeys","#pendingHasCallbacks","#scheduleLookup","#pendingGetKeys","#pendingGetCallbacks","#scheduled","#dbDelegate","#committed"],"sources":["../../../../../../replicache/src/kv/sqlite-store.ts"],"sourcesContent":["import {RWLock} from '@rocicorp/lock';\nimport type {ReadonlyJSONValue} from '../../../shared/src/json.ts';\nimport {deepFreeze} from '../frozen-json.ts';\nimport type {Read, Store, Write} from './store.ts';\nimport {\n  maybeTransactionIsClosedRejection,\n  throwIfStoreClosed,\n  transactionError,\n} from './throw-if-closed.ts';\nimport {deleteSentinel, WriteImplBase} from './write-impl-base.ts';\n\n/**\n * A SQLite prepared statement.\n */\nexport interface PreparedStatement {\n  exec(params: string[]): Promise<void>;\n  all(params: string[]): Promise<unknown[][]>;\n}\n\nexport interface SQLiteDatabase {\n  /**\n   * Close the database connection.\n   */\n  close(): void;\n\n  /**\n   * Destroy or delete the database (e.g. delete file).\n   */\n  destroy(): void;\n\n  /**\n   * Prepare a SQL string, returning a statement you can execute.\n   * E.g. `const stmt = db.prepare(\"SELECT * FROM todos WHERE id=?\");`\n   */\n  prepare(sql: string): PreparedStatement;\n\n  // for PRAGMA statements, schema creation and transaction control.\n  execSync(sql: string): void;\n}\n\nexport type CreateSQLiteDatabase = (\n  filename: string,\n  opts?: SQLiteStoreOptions,\n) => SQLiteDatabase;\n\n/**\n * SQLite-based implementation of the Store interface using a configurable delegate.\n * Supports shared connections between multiple store instances with the same name,\n * providing efficient resource utilization and proper transaction isolation.\n * Uses parameterized queries for safety and performance.\n */\nexport class SQLiteStore implements Store {\n  readonly #filename: string;\n  readonly #entry: StoreEntry;\n\n  #closed = false;\n\n  constructor(\n    name: string,\n    create: CreateSQLiteDatabase,\n    opts?: SQLiteStoreOptions,\n  ) {\n    this.#filename = resolveFilename(name, opts);\n    this.#entry = getOrCreateEntry(this.#filename, create, opts);\n  }\n\n  async read(): Promise<Read> {\n    throwIfStoreClosed(this);\n\n    const entry = this.#entry;\n    const {db, lock, preparedStatements} = entry;\n    const release = await lock.read();\n\n    // Start shared read transaction if this is the first reader\n    // This ensures consistent reads across all concurrent readers\n    if (entry.activeReaders === 0) {\n      db.execSync('BEGIN');\n    }\n    entry.activeReaders++;\n\n    return new SQLiteStoreRead(() => {\n      entry.activeReaders--;\n      // Commit shared read transaction when last reader finishes\n      if (entry.activeReaders === 0) {\n        db.execSync('COMMIT');\n      }\n      release();\n    }, preparedStatements);\n  }\n\n  async write(): Promise<Write> {\n    throwIfStoreClosed(this);\n\n    const {lock, db, preparedStatements} = this.#entry;\n    const release = await lock.write();\n\n    // At this point, RWLock guarantees no active readers\n    // The last reader would have already committed the shared transaction\n\n    db.execSync('BEGIN IMMEDIATE');\n\n    return new SQLiteWrite(release, db, preparedStatements);\n  }\n\n  async close(): Promise<void> {\n    if (this.#closed) {\n      return;\n    }\n\n    const {lock, db} = this.#entry;\n    // Wait for all readers and writers to finish.\n    const writeRelease = await lock.write();\n\n    // Handle reference counting for shared stores - only close database\n    // when this is the last store instance using it\n    decrementStoreRefCount(this.#filename, db);\n\n    this.#closed = true;\n    writeRelease();\n  }\n\n  get closed(): boolean {\n    return this.#closed;\n  }\n}\n\nexport function safeFilename(name: string): string {\n  return name.replace(/[^a-zA-Z0-9]/g, '_');\n}\n\nfunction resolveFilename(name: string, opts?: SQLiteStoreOptions): string {\n  const safe = safeFilename(name);\n  const dir = opts?.directory;\n  return dir ? `${dir}/${safe}` : safe;\n}\n\nexport type PreparedStatements = {\n  has: PreparedStatement;\n  get: PreparedStatement;\n  hasMany: PreparedStatement;\n  getMany: PreparedStatement;\n  put: PreparedStatement;\n  del: PreparedStatement;\n};\n\nexport interface SQLiteStoreOptions {\n  // Common options\n  busyTimeout?: number;\n  journalMode?: 'WAL' | 'DELETE';\n  synchronous?: 'NORMAL' | 'FULL';\n  readUncommitted?: boolean;\n  /** Directory in which to create the SQLite file. Defaults to the process CWD. */\n  directory?: string | undefined;\n}\n\n/**\n * Common database setup logic shared between expo-sqlite and op-sqlite implementations.\n * Configures SQLite pragmas, creates the entry table, and prepares common statements.\n */\n\nexport function setupDatabase(\n  delegate: SQLiteDatabase,\n  opts?: SQLiteStoreOptions,\n): PreparedStatements {\n  // Configure SQLite pragmas for optimal performance\n  delegate.execSync(`PRAGMA busy_timeout = ${opts?.busyTimeout ?? 200}`);\n  delegate.execSync(`PRAGMA journal_mode = '${opts?.journalMode ?? 'WAL'}'`);\n  delegate.execSync(`PRAGMA synchronous = '${opts?.synchronous ?? 'NORMAL'}'`);\n  delegate.execSync(\n    `PRAGMA read_uncommitted = ${Boolean(opts?.readUncommitted)}`,\n  );\n\n  // Create the entry table\n  delegate.execSync(`\n    CREATE TABLE IF NOT EXISTS entry (\n      key TEXT PRIMARY KEY,\n      value TEXT NOT NULL\n    ) WITHOUT ROWID\n  `);\n\n  // Prepare common statements\n  return {\n    has: delegate.prepare(`SELECT 1 FROM entry WHERE key = ? LIMIT 1`),\n    get: delegate.prepare('SELECT value FROM entry WHERE key = ?'),\n    hasMany: delegate.prepare(\n      `SELECT key FROM entry WHERE key IN (SELECT value FROM json_each(?))`,\n    ),\n    getMany: delegate.prepare(\n      `SELECT key, value FROM entry WHERE key IN (SELECT value FROM json_each(?))`,\n    ),\n    put: delegate.prepare(\n      `INSERT OR REPLACE INTO entry (key, value)\n   SELECT e.value->>0, e.value->1 FROM json_each(?) e`,\n    ),\n    del: delegate.prepare(\n      `DELETE FROM entry WHERE key IN (SELECT value FROM json_each(?))`,\n    ),\n  };\n}\n\n// Callbacks are stored as striped pairs: [resolve, reject, resolve, reject, ...]\nconst CB_STRIDE = 2;\nconst CB_RESOLVE = 0;\nconst CB_REJECT = 1;\n\ntype GetResolve = (v: ReadonlyJSONValue | undefined) => void;\ntype HasResolve = (v: boolean) => void;\ntype Reject = (e: unknown) => void;\n\nfunction rejectAll(callbacks: unknown[], e: unknown): void {\n  for (let i = CB_REJECT; i < callbacks.length; i += CB_STRIDE) {\n    (callbacks[i] as Reject)(e);\n  }\n}\n\nfunction parseRawValue(raw: string | undefined): ReadonlyJSONValue | undefined {\n  return raw === undefined\n    ? undefined\n    : deepFreeze(JSON.parse(raw) as ReadonlyJSONValue);\n}\n\nfunction resolveGet(\n  resolve: GetResolve,\n  reject: Reject,\n  raw: string | undefined,\n): void {\n  try {\n    resolve(parseRawValue(raw));\n  } catch (e) {\n    reject(e);\n  }\n}\n\nasync function flushGets(\n  keys: string[],\n  callbacks: unknown[],\n  ps: PreparedStatements,\n): Promise<void> {\n  let rows: unknown[][];\n  try {\n    rows =\n      keys.length === 1\n        ? await ps.get.all([keys[0]])\n        : await ps.getMany.all([JSON.stringify(keys)]);\n  } catch (e) {\n    rejectAll(callbacks, e);\n    return;\n  }\n  if (keys.length === 1) {\n    resolveGet(\n      callbacks[CB_RESOLVE] as GetResolve,\n      callbacks[CB_REJECT] as Reject,\n      rows[0]?.[0] as string | undefined,\n    );\n    return;\n  }\n  const resultMap = new Map(rows as [string, string][]);\n  for (let i = 0; i < keys.length; i++) {\n    resolveGet(\n      callbacks[i * CB_STRIDE + CB_RESOLVE] as GetResolve,\n      callbacks[i * CB_STRIDE + CB_REJECT] as Reject,\n      resultMap.get(keys[i]),\n    );\n  }\n}\n\nasync function flushHas(\n  keys: string[],\n  callbacks: unknown[],\n  ps: PreparedStatements,\n): Promise<void> {\n  let rows: unknown[][];\n  try {\n    rows =\n      keys.length === 1\n        ? await ps.has.all([keys[0]])\n        : await ps.hasMany.all([JSON.stringify(keys)]);\n  } catch (e) {\n    rejectAll(callbacks, e);\n    return;\n  }\n  if (keys.length === 1) {\n    (callbacks[CB_RESOLVE] as HasResolve)(rows.length > 0);\n    return;\n  }\n  const existingKeys = new Set(rows.map(row => row[0] as string));\n  for (let i = 0; i < keys.length; i++) {\n    (callbacks[i * CB_STRIDE + CB_RESOLVE] as HasResolve)(\n      existingKeys.has(keys[i]),\n    );\n  }\n}\n\nexport class SQLiteStoreRead implements Read {\n  readonly #release: () => void;\n  readonly #preparedStatements: PreparedStatements;\n  #closed = false;\n  #pendingGetKeys: string[] = [];\n  #pendingGetCallbacks: unknown[] = [];\n  #pendingHasKeys: string[] = [];\n  #pendingHasCallbacks: unknown[] = [];\n  #scheduled = false;\n\n  constructor(release: () => void, preparedStatements: PreparedStatements) {\n    this.#release = release;\n    this.#preparedStatements = preparedStatements;\n  }\n\n  has(key: string): Promise<boolean> {\n    return (\n      maybeTransactionIsClosedRejection(this) ??\n      new Promise((resolve, reject) => {\n        this.#pendingHasKeys.push(key);\n        this.#pendingHasCallbacks.push(resolve, reject);\n        this.#scheduleLookup();\n      })\n    );\n  }\n\n  get(key: string): Promise<ReadonlyJSONValue | undefined> {\n    return (\n      maybeTransactionIsClosedRejection(this) ??\n      new Promise((resolve, reject) => {\n        this.#pendingGetKeys.push(key);\n        this.#pendingGetCallbacks.push(resolve, reject);\n        this.#scheduleLookup();\n      })\n    );\n  }\n\n  #scheduleLookup(): void {\n    if (!this.#scheduled) {\n      this.#scheduled = true;\n      queueMicrotask(() => {\n        this.#scheduled = false;\n\n        const ps = this.#preparedStatements;\n        const getKeys = this.#pendingGetKeys;\n        this.#pendingGetKeys = [];\n        const getCallbacks = this.#pendingGetCallbacks;\n        this.#pendingGetCallbacks = [];\n        const hasKeys = this.#pendingHasKeys;\n        this.#pendingHasKeys = [];\n        const hasCallbacks = this.#pendingHasCallbacks;\n        this.#pendingHasCallbacks = [];\n\n        if (this.#closed) {\n          const e = transactionError();\n          rejectAll(getCallbacks, e);\n          rejectAll(hasCallbacks, e);\n          return;\n        }\n\n        if (getKeys.length > 0) {\n          void flushGets(getKeys, getCallbacks, ps);\n        }\n        if (hasKeys.length > 0) {\n          void flushHas(hasKeys, hasCallbacks, ps);\n        }\n      });\n    }\n  }\n\n  release(): void {\n    if (!this.#closed) {\n      this.#closed = true;\n      this.#release();\n    }\n  }\n\n  get closed(): boolean {\n    return this.#closed;\n  }\n}\n\nexport class SQLiteWrite extends WriteImplBase implements Write {\n  readonly #release: () => void;\n  readonly #dbDelegate: SQLiteDatabase;\n  readonly #preparedStatements: PreparedStatements;\n  #committed = false;\n  #closed = false;\n\n  constructor(\n    release: () => void,\n    dbDelegate: SQLiteDatabase,\n    preparedStatements: PreparedStatements,\n  ) {\n    super(new SQLiteStoreRead(() => undefined, preparedStatements));\n    this.#release = release;\n    this.#dbDelegate = dbDelegate;\n    this.#preparedStatements = preparedStatements;\n  }\n\n  async commit(): Promise<void> {\n    if (this.#closed) {\n      throw transactionError();\n    }\n\n    const deleteKeys: string[] = [];\n    for (const entry of this._pending) {\n      if (entry[1] === deleteSentinel) {\n        deleteKeys.push(entry[0]);\n        this._pending.delete(entry[0]);\n      }\n    }\n\n    const delP =\n      deleteKeys.length > 0\n        ? this.#preparedStatements.del.exec([JSON.stringify(deleteKeys)])\n        : undefined;\n    const putP =\n      this._pending.size > 0\n        ? this.#preparedStatements.put.exec([\n            JSON.stringify([...this._pending]),\n          ])\n        : undefined;\n\n    if (putP) await putP;\n    if (delP) await delP;\n\n    this.#dbDelegate.execSync('COMMIT');\n    this._pending.clear();\n    this.#committed = true;\n  }\n\n  release(): void {\n    if (!this.#closed) {\n      this.#closed = true;\n      super.release();\n      let rollbackError: unknown;\n      if (!this.#committed) {\n        try {\n          this.#dbDelegate.execSync('ROLLBACK');\n        } catch (e) {\n          rollbackError = e;\n        }\n      }\n      this.#release();\n      if (rollbackError !== undefined) {\n        throw rollbackError;\n      }\n    }\n  }\n\n  get closed(): boolean {\n    return this.#closed;\n  }\n}\n\ntype StoreEntry = {\n  readonly lock: RWLock;\n  readonly db: SQLiteDatabase;\n  refCount: number;\n  activeReaders: number;\n  preparedStatements: PreparedStatements;\n};\n\n// Global map to share database connections between multiple store instances with the same name\nconst stores = new Map<string, StoreEntry>();\n\n/**\n * Gets an existing store entry or creates a new one if it doesn't exist.\n * This implements the shared connection pattern where multiple stores with the same\n * name share the same database connection, lock, and delegate.\n */\nfunction getOrCreateEntry(\n  filename: string,\n  create: (filename: string, opts?: SQLiteStoreOptions) => SQLiteDatabase,\n  opts?: SQLiteStoreOptions,\n): StoreEntry {\n  const entry = stores.get(filename);\n\n  if (entry) {\n    entry.refCount++;\n    return entry;\n  }\n\n  const dbDelegate = create(filename, opts);\n  const preparedStatements = setupDatabase(dbDelegate, opts);\n\n  const lock = new RWLock();\n\n  const newEntry: StoreEntry = {\n    lock,\n    db: dbDelegate,\n    refCount: 1,\n    activeReaders: 0,\n    preparedStatements,\n  };\n  stores.set(filename, newEntry);\n  return newEntry;\n}\n\n/**\n * Decrements the reference count for a shared store and cleans up resources\n * when the last reference is released.\n */\n\nfunction decrementStoreRefCount(\n  filename: string,\n  dbDelegate: SQLiteDatabase,\n): void {\n  const entry = stores.get(filename);\n  if (entry) {\n    entry.refCount--;\n    if (entry.refCount <= 0) {\n      dbDelegate.close();\n      stores.delete(filename);\n    }\n  }\n}\nexport function clearAllNamedStoresForTesting(): void {\n  for (const entry of stores.values()) {\n    entry.db.close();\n  }\n  stores.clear();\n}\n\nexport function dropStore(\n  name: string,\n  createDelegate: (\n    filename: string,\n    opts?: SQLiteStoreOptions,\n  ) => SQLiteDatabase,\n  opts?: SQLiteStoreOptions,\n): Promise<void> {\n  const filename = resolveFilename(name, opts);\n  const entry = stores.get(filename);\n  if (entry) {\n    try {\n      entry.db.close();\n    } catch {\n      // Ignore close errors\n    }\n    stores.delete(filename);\n  }\n\n  // Create a temporary delegate to handle database deletion\n  const tempDelegate = createDelegate(filename, opts);\n  try {\n    // we close the db before destroying it - this\n    // caused an issue with expo-sqlite since it requires this\n    tempDelegate.close();\n  } catch {\n    // Ignore close errors\n  }\n  try {\n    tempDelegate.destroy();\n  } catch {\n    // Destroy errors shouldn't be fatal; the file may already be gone or locked\n  }\n\n  return Promise.resolve();\n}\n"],"mappings":"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"}

package/out/packages/replicache/src/kv/throw-if-closed.js

@@ -0,0 +1,23 @@
+//#region ../replicache/src/kv/throw-if-closed.ts
+function storeError() {
+	return /* @__PURE__ */ new Error("Store is closed");
+}
+function transactionError() {
+	return /* @__PURE__ */ new Error("Transaction is closed");
+}
+function throwIfStoreClosed(store) {
+	if (store.closed) throw storeError();
+}
+function transactionIsClosedRejection() {
+	return Promise.reject(transactionError());
+}
+function maybeTransactionIsClosedRejection(transaction) {
+	return transaction.closed ? transactionIsClosedRejection() : void 0;
+}
+function storeIsClosedRejection() {
+	return Promise.reject(storeError());
+}
+//#endregion
+export { maybeTransactionIsClosedRejection, storeIsClosedRejection, throwIfStoreClosed, transactionError, transactionIsClosedRejection };
+
+//# sourceMappingURL=throw-if-closed.js.map

package/out/packages/replicache/src/kv/throw-if-closed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"throw-if-closed.js","names":[],"sources":["../../../../../../replicache/src/kv/throw-if-closed.ts"],"sourcesContent":["function storeError(): Error {\n  return new Error('Store is closed');\n}\n\nexport function transactionError(): Error {\n  return new Error('Transaction is closed');\n}\n\nexport function throwIfStoreClosed(store: {readonly closed: boolean}): void {\n  if (store.closed) {\n    throw storeError();\n  }\n}\n\nexport function throwIfTransactionClosed(transaction: {\n  readonly closed: boolean;\n}): void {\n  if (transaction.closed) {\n    throw transactionError();\n  }\n}\n\nexport function transactionIsClosedRejection() {\n  return Promise.reject(transactionError());\n}\n\nexport function maybeTransactionIsClosedRejection(transaction: {\n  readonly closed: boolean;\n}): Promise<never> | undefined {\n  return transaction.closed ? transactionIsClosedRejection() : undefined;\n}\n\nexport function storeIsClosedRejection() {\n  return Promise.reject(storeError());\n}\n"],"mappings":";AAAA,SAAS,aAAoB;CAC3B,uBAAO,IAAI,MAAM,iBAAiB;AACpC;AAEA,SAAgB,mBAA0B;CACxC,uBAAO,IAAI,MAAM,uBAAuB;AAC1C;AAEA,SAAgB,mBAAmB,OAAyC;CAC1E,IAAI,MAAM,QACR,MAAM,WAAW;AAErB;AAUA,SAAgB,+BAA+B;CAC7C,OAAO,QAAQ,OAAO,iBAAiB,CAAC;AAC1C;AAEA,SAAgB,kCAAkC,aAEnB;CAC7B,OAAO,YAAY,SAAS,6BAA6B,IAAI,KAAA;AAC/D;AAEA,SAAgB,yBAAyB;CACvC,OAAO,QAAQ,OAAO,WAAW,CAAC;AACpC"}

package/out/packages/replicache/src/kv/write-impl-base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-impl-base.js","names":["#read"],"sources":["../../../../../../replicache/src/kv/write-impl-base.ts"],"sourcesContent":["import type {ReadonlyJSONValue} from '../../../shared/src/json.ts';\nimport {\n  promiseFalse,\n  promiseTrue,\n  promiseVoid,\n} from '../../../shared/src/resolved-promises.ts';\nimport {\n  type FrozenJSONValue,\n  deepFreeze,\n  deepFreezeAllowUndefined,\n} from '../frozen-json.ts';\nimport type {Read} from './store.ts';\nimport {\n  maybeTransactionIsClosedRejection,\n  transactionIsClosedRejection,\n} from './throw-if-closed.ts';\n\nexport const deleteSentinel = Symbol();\ntype DeleteSentinel = typeof deleteSentinel;\n\nexport class WriteImplBase {\n  protected readonly _pending: Map<string, FrozenJSONValue | DeleteSentinel> =\n    new Map();\n  readonly #read: Read;\n\n  constructor(read: Read) {\n    this.#read = read;\n  }\n\n  has(key: string): Promise<boolean> {\n    if (this.#read.closed) {\n      return transactionIsClosedRejection();\n    }\n    switch (this._pending.get(key)) {\n      case undefined:\n        return this.#read.has(key);\n      case deleteSentinel:\n        return promiseFalse;\n      default:\n        return promiseTrue;\n    }\n  }\n\n  async get(key: string): Promise<FrozenJSONValue | undefined> {\n    if (this.#read.closed) {\n      return transactionIsClosedRejection();\n    }\n    const v = this._pending.get(key);\n    switch (v) {\n      case deleteSentinel:\n        return undefined;\n      case undefined: {\n        const v = await this.#read.get(key);\n        return deepFreezeAllowUndefined(v);\n      }\n      default:\n        return v;\n    }\n  }\n\n  put(key: string, value: ReadonlyJSONValue) {\n    return (\n      maybeTransactionIsClosedRejection(this.#read) ??\n      (this._pending.set(key, deepFreeze(value)), promiseVoid)\n    );\n  }\n\n  del(key: string): Promise<void> {\n    return (\n      maybeTransactionIsClosedRejection(this.#read) ??\n      (this._pending.set(key, deleteSentinel), promiseVoid)\n    );\n  }\n\n  release(): void {\n    this.#read.release();\n  }\n\n  get closed(): boolean {\n    return this.#read.closed;\n  }\n}\n"],"mappings":";;;;AAiBA,IAAa,iBAAiB,OAAO;AAGrC,IAAa,gBAAb,MAA2B;CACzB,2BACE,IAAI,IAAI;CACV;CAEA,YAAY,MAAY;EACtB,KAAKA,QAAQ;CACf;CAEA,IAAI,KAA+B;EACjC,IAAI,KAAKA,MAAM,QACb,OAAO,6BAA6B;EAEtC,QAAQ,KAAK,SAAS,IAAI,GAAG,GAA7B;GACE,KAAK,KAAA,GACH,OAAO,KAAKA,MAAM,IAAI,GAAG;GAC3B,KAAK,gBACH,OAAO;GACT,SACE,OAAO;EACX;CACF;CAEA,MAAM,IAAI,KAAmD;EAC3D,IAAI,KAAKA,MAAM,QACb,OAAO,6BAA6B;EAEtC,MAAM,IAAI,KAAK,SAAS,IAAI,GAAG;EAC/B,QAAQ,GAAR;GACE,KAAK,gBACH;GACF,KAAK,KAAA,GAEH,OAAO,yBAAyB,MADhB,KAAKA,MAAM,IAAI,GAAG,CACD;GAEnC,SACE,OAAO;EACX;CACF;CAEA,IAAI,KAAa,OAA0B;EACzC,OACE,kCAAkC,KAAKA,KAAK,MAC3C,KAAK,SAAS,IAAI,KAAK,WAAW,KAAK,CAAC,GAAG;CAEhD;CAEA,IAAI,KAA4B;EAC9B,OACE,kCAAkC,KAAKA,KAAK,MAC3C,KAAK,SAAS,IAAI,KAAK,cAAc,GAAG;CAE7C;CAEA,UAAgB;EACd,KAAKA,MAAM,QAAQ;CACrB;CAEA,IAAI,SAAkB;EACpB,OAAO,KAAKA,MAAM;CACpB;AACF"}

package/out/packages/replicache/src/kv/write-impl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-impl.js","names":["#map"],"sources":["../../../../../../replicache/src/kv/write-impl.ts"],"sourcesContent":["import {promiseVoid} from '../../../shared/src/resolved-promises.ts';\nimport type {FrozenJSONValue} from '../frozen-json.ts';\nimport {ReadImpl} from './read-impl.ts';\nimport type {Write} from './store.ts';\nimport {transactionIsClosedRejection} from './throw-if-closed.ts';\nimport {deleteSentinel, WriteImplBase} from './write-impl-base.ts';\n\nexport class WriteImpl extends WriteImplBase implements Write {\n  readonly #map: Map<string, FrozenJSONValue>;\n\n  constructor(map: Map<string, FrozenJSONValue>, release: () => void) {\n    super(new ReadImpl(map, release));\n    this.#map = map;\n  }\n\n  commit(): Promise<void> {\n    if (this.closed) {\n      return transactionIsClosedRejection();\n    }\n\n    // HOT. Do not allocate entry tuple and destructure.\n    this._pending.forEach((value, key) => {\n      if (value === deleteSentinel) {\n        this.#map.delete(key);\n      } else {\n        this.#map.set(key, value);\n      }\n    });\n    this._pending.clear();\n    this.release();\n    return promiseVoid;\n  }\n}\n"],"mappings":";;;;;AAOA,IAAa,YAAb,cAA+B,cAA+B;CAC5D;CAEA,YAAY,KAAmC,SAAqB;EAClE,MAAM,IAAI,SAAS,KAAK,OAAO,CAAC;EAChC,KAAKA,OAAO;CACd;CAEA,SAAwB;EACtB,IAAI,KAAK,QACP,OAAO,6BAA6B;EAItC,KAAK,SAAS,SAAS,OAAO,QAAQ;GACpC,IAAI,UAAU,gBACZ,KAAKA,KAAK,OAAO,GAAG;QAEpB,KAAKA,KAAK,IAAI,KAAK,KAAK;EAE5B,CAAC;EACD,KAAK,SAAS,MAAM;EACpB,KAAK,QAAQ;EACb,OAAO;CACT;AACF"}

package/out/packages/replicache/src/lazy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy.js","names":[],"sources":["../../../../../replicache/src/lazy.ts"],"sourcesContent":["export function lazy<T>(factory: () => T): () => T {\n  let value: T | undefined;\n  return () => {\n    if (value === undefined) {\n      value = factory();\n    }\n    return value;\n  };\n}\n"],"mappings":";AAAA,SAAgB,KAAQ,SAA2B;CACjD,IAAI;CACJ,aAAa;EACX,IAAI,UAAU,KAAA,GACZ,QAAQ,QAAQ;EAElB,OAAO;CACT;AACF"}

package/out/packages/replicache/src/log-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-options.js","names":[],"sources":["../../../../../replicache/src/log-options.ts"],"sourcesContent":["import {\n  consoleLogSink,\n  LogContext,\n  TeeLogSink,\n  type Context,\n  type LogLevel,\n  type LogSink,\n} from '@rocicorp/logger';\n\n/**\n * Creates a LogContext\n * @param logLevel The log level to use. Default is `'info'`.\n * @param logSinks Destination for logs. Default is `[consoleLogSink]`.\n * @param context Optional: Additional information that can be associated with logs.\n * @returns A LogContext instance configured with the provided options.\n */\nexport function createLogContext(\n  logLevel: LogLevel = 'info',\n  logSinks: LogSink[] = [consoleLogSink],\n  context?: Context,\n): LogContext {\n  const logSink =\n    logSinks.length === 1 ? logSinks[0] : new TeeLogSink(logSinks);\n  return new LogContext(logLevel, context, logSink);\n}\n"],"mappings":";;;;;;;;;AAgBA,SAAgB,iBACd,WAAqB,QACrB,WAAsB,CAAC,cAAc,GACrC,SACY;CAGZ,OAAO,IAAI,WAAW,UAAU,SAD9B,SAAS,WAAW,IAAI,SAAS,KAAK,IAAI,WAAW,QAAQ,CACf;AAClD"}

package/out/packages/replicache/src/make-idb-name.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-idb-name.js","names":[],"sources":["../../../../../replicache/src/make-idb-name.ts"],"sourcesContent":["import * as FormatVersion from './format-version-enum.ts';\n\n/**\n * Returns the name of the IDB database that will be used for a particular Replicache instance.\n * @param name The name of the Replicache instance (i.e., the `name` field of `ReplicacheOptions`).\n * @param schemaVersion The schema version of the database (i.e., the `schemaVersion` field of `ReplicacheOptions`).\n * @returns\n */\n\nexport function makeIDBName(name: string, schemaVersion?: string): string {\n  return makeIDBNameInternal(name, schemaVersion, FormatVersion.Latest);\n}\n\nfunction makeIDBNameInternal(\n  name: string,\n  schemaVersion: string | undefined,\n  formatVersion: number,\n): string {\n  const n = `rep:${name}:${formatVersion}`;\n  return schemaVersion ? `${n}:${schemaVersion}` : n;\n}\n\nexport {makeIDBNameInternal as makeIDBNameForTesting};\n"],"mappings":";;;;;;;AASA,SAAgB,YAAY,MAAc,eAAgC;CACxE,OAAO,oBAAoB,MAAM,eAAe,CAAoB;AACtE;AAEA,SAAS,oBACP,MACA,eACA,eACQ;CACR,MAAM,IAAI,OAAO,KAAK,GAAG;CACzB,OAAO,gBAAgB,GAAG,EAAE,GAAG,kBAAkB;AACnD"}