@rocicorp/zero 0.25.0-canary.7 → 0.25.0-canary.8

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

@@ -0,0 +1,51 @@
+import { RWLock } from "@rocicorp/lock";
+import { promiseVoid } from "../../../shared/src/resolved-promises.js";
+import { ReadImpl } from "./read-impl.js";
+import { throwIfStoreClosed } from "./throw-if-closed.js";
+import { WriteImpl } from "./write-impl.js";
+const stores = /* @__PURE__ */ new Map();
+function dropMemStore(name) {
+  stores.delete(name);
+  return promiseVoid;
+}
+class MemStore {
+  #map;
+  #rwLock;
+  #closed = false;
+  constructor(name) {
+    const entry = stores.get(name);
+    let lock;
+    let map;
+    if (entry) {
+      ({ lock, map } = entry);
+    } else {
+      lock = new RWLock();
+      map = /* @__PURE__ */ new Map();
+      stores.set(name, { lock, map });
+    }
+    this.#rwLock = lock;
+    this.#map = map;
+  }
+  async read() {
+    throwIfStoreClosed(this);
+    const release = await this.#rwLock.read();
+    return new ReadImpl(this.#map, release);
+  }
+  async write() {
+    throwIfStoreClosed(this);
+    const release = await this.#rwLock.write();
+    return new WriteImpl(this.#map, release);
+  }
+  close() {
+    this.#closed = true;
+    return promiseVoid;
+  }
+  get closed() {
+    return this.#closed;
+  }
+}
+export {
+  MemStore,
+  dropMemStore
+};
+//# sourceMappingURL=mem-store.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mem-store.js","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"],"names":[],"mappings":";;;;;AAYA,MAAM,6BAAa,IAAA;AAMZ,SAAS,aAAa,MAA6B;AACxD,SAAO,OAAO,IAAI;AAClB,SAAO;AACT;AAgBO,MAAM,SAA0B;AAAA,EAC5B;AAAA,EACA;AAAA,EACT,UAAU;AAAA,EAEV,YAAY,MAAc;AACxB,UAAM,QAAQ,OAAO,IAAI,IAAI;AAC7B,QAAI;AACJ,QAAI;AACJ,QAAI,OAAO;AACT,OAAC,EAAC,MAAM,IAAA,IAAO;AAAA,IACjB,OAAO;AACL,aAAO,IAAI,OAAA;AACX,gCAAU,IAAA;AACV,aAAO,IAAI,MAAM,EAAC,MAAM,KAAI;AAAA,IAC9B;AACA,SAAK,UAAU;AACf,SAAK,OAAO;AAAA,EACd;AAAA,EAEA,MAAM,OAAsB;AAC1B,uBAAmB,IAAI;AACvB,UAAM,UAAU,MAAM,KAAK,QAAQ,KAAA;AACnC,WAAO,IAAI,SAAS,KAAK,MAAM,OAAO;AAAA,EACxC;AAAA,EAEA,MAAM,QAAwB;AAC5B,uBAAmB,IAAI;AACvB,UAAM,UAAU,MAAM,KAAK,QAAQ,MAAA;AACnC,WAAO,IAAI,UAAU,KAAK,MAAM,OAAO;AAAA,EACzC;AAAA,EAEA,QAAuB;AACrB,SAAK,UAAU;AACf,WAAO;AAAA,EACT;AAAA,EAEA,IAAI,SAAkB;AACpB,WAAO,KAAK;AAAA,EACd;AACF;"}

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

@@ -1,16 +1,5 @@
-import {
-  SQLiteStore,
-  dropStore
-} from "./chunk-WPAQ4EPM.js";
-import "./chunk-ASRS2LFV.js";
-import "./chunk-EZM3XBAB.js";
-import "./chunk-424PT5DM.js";
-
-// ../replicache/src/kv/op-sqlite/types.ts
-import { open as openDB } from "@op-engineering/op-sqlite";
-var open = openDB;
-
-// ../replicache/src/kv/op-sqlite/store.ts
+import { SQLiteStore, dropStore } from "../sqlite-store.js";
+import { open } from "./types.js";
 function dropOpSQLiteStore(name) {
   return dropStore(
     name,
@@ -27,7 +16,7 @@ function opSQLiteStoreProvider(opts) {
     drop: dropOpSQLiteStore
   };
 }
-var OpSQLitePreparedStatement = class {
+class OpSQLitePreparedStatement {
   #db;
   #sql;
   constructor(db, sql) {
@@ -41,8 +30,8 @@ var OpSQLitePreparedStatement = class {
   async exec(params) {
     await this.#db.executeRaw(this.#sql, params);
   }
-};
-var OpSQLiteDatabase = class {
+}
+class OpSQLiteDatabase {
   #db;
   #filename;
   constructor(filename, opts) {
@@ -73,8 +62,8 @@ var OpSQLiteDatabase = class {
   execSync(sql) {
     this.#db.executeRawSync(sql, []);
   }
-};
+}
 export {
   opSQLiteStoreProvider
 };
-//# sourceMappingURL=op-sqlite.js.map
+//# sourceMappingURL=store.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","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(name: string): Promise<void> {\n  return dropStore(\n    name,\n    (filename, opts) => new OpSQLiteDatabase(filename, 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: dropOpSQLiteStore,\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 firstValue(params: string[]): Promise<string | undefined> {\n    const rows = await this.#db.executeRaw(this.#sql, params);\n    return rows[0]?.[0];\n  }\n\n  async exec(params: string[]): Promise<void> {\n    await 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"],"names":["name"],"mappings":";;AAeA,SAAS,kBAAkB,MAA6B;AACtD,SAAO;AAAA,IACL;AAAA,IACA,CAAC,UAAU,SAAS,IAAI,iBAAiB,UAAU,IAAI;AAAA,EAAA;AAE3D;AAQO,SAAS,sBACd,MACe;AACf,SAAO;AAAA,IACL,QAAQ,UACN,IAAI;AAAA,MACF;AAAA,MACA,CAACA,OAAM,YAAY,IAAI,iBAAiBA,OAAM,OAAO;AAAA,MACrD;AAAA,IAAA;AAAA,IAEJ,MAAM;AAAA,EAAA;AAEV;AAEA,MAAM,0BAAuD;AAAA,EAClD;AAAA,EACA;AAAA,EAET,YAAY,IAAQ,KAAa;AAC/B,SAAK,MAAM;AACX,SAAK,OAAO;AAAA,EACd;AAAA,EAEA,MAAM,WAAW,QAA+C;AAC9D,UAAM,OAAO,MAAM,KAAK,IAAI,WAAW,KAAK,MAAM,MAAM;AACxD,WAAO,KAAK,CAAC,IAAI,CAAC;AAAA,EACpB;AAAA,EAEA,MAAM,KAAK,QAAiC;AAC1C,UAAM,KAAK,IAAI,WAAW,KAAK,MAAM,MAAM;AAAA,EAC7C;AACF;AAEA,MAAM,iBAA2C;AAAA,EACtC;AAAA,EACA;AAAA,EAET,YAAY,UAAkB,MAA6B;AACzD,SAAK,YAAY;AACjB,UAAM,WAIF,EAAC,MAAM,SAAA;AAEX,QAAI,MAAM,UAAU;AAClB,eAAS,WAAW,KAAK;AAAA,IAC3B;AACA,QAAI,MAAM,eAAe;AACvB,eAAS,gBAAgB,KAAK;AAAA,IAChC;AAEA,SAAK,MAAM,KAAK,QAAQ;AAAA,EAC1B;AAAA,EAEA,QAAc;AACZ,SAAK,IAAI,MAAA;AAAA,EACX;AAAA,EAEA,UAAgB;AAGd,QAAI;AACF,YAAM,SAAS,KAAK,EAAC,MAAM,KAAK,WAAU;AAC1C,aAAO,OAAA;AACP,aAAO,MAAA;AAAA,IACT,SAAS,QAAQ;AAAA,IAEjB;AAAA,EACF;AAAA,EAEA,QAAQ,KAAgC;AACtC,WAAO,IAAI,0BAA0B,KAAK,KAAK,GAAG;AAAA,EACpD;AAAA,EAEA,SAAS,KAAmB;AAC1B,SAAK,IAAI,eAAe,KAAK,CAAA,CAAE;AAAA,EACjC;AACF;"}

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

@@ -0,0 +1,6 @@
+import { open as open$1 } from "@op-engineering/op-sqlite";
+const open = open$1;
+export {
+  open
+};
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","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\n// @ts-expect-error - Module resolution issue with @op-engineering/op-sqlite exports\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"],"names":["openDB"],"mappings":";AAsBO,MAAM,OAAqBA;"}

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

@@ -0,0 +1,27 @@
+import { maybeTransactionIsClosedRejection } from "./throw-if-closed.js";
+class ReadImpl {
+  #map;
+  #release;
+  #closed = false;
+  constructor(map, release) {
+    this.#map = map;
+    this.#release = release;
+  }
+  release() {
+    this.#release();
+    this.#closed = true;
+  }
+  get closed() {
+    return this.#closed;
+  }
+  has(key) {
+    return maybeTransactionIsClosedRejection(this) ?? Promise.resolve(this.#map.has(key));
+  }
+  get(key) {
+    return maybeTransactionIsClosedRejection(this) ?? Promise.resolve(this.#map.get(key));
+  }
+}
+export {
+  ReadImpl
+};
+//# sourceMappingURL=read-impl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"read-impl.js","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"],"names":[],"mappings":";AAIO,MAAM,SAAyB;AAAA,EAC3B;AAAA,EACA;AAAA,EACT,UAAU;AAAA,EAEV,YAAY,KAAmC,SAAqB;AAClE,SAAK,OAAO;AACZ,SAAK,WAAW;AAAA,EAClB;AAAA,EAEA,UAAU;AACR,SAAK,SAAA;AACL,SAAK,UAAU;AAAA,EACjB;AAAA,EAEA,IAAI,SAAkB;AACpB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,IAAI,KAA+B;AACjC,WACE,kCAAkC,IAAI,KACtC,QAAQ,QAAQ,KAAK,KAAK,IAAI,GAAG,CAAC;AAAA,EAEtC;AAAA,EAEA,IAAI,KAAmD;AACrD,WACE,kCAAkC,IAAI,KACtC,QAAQ,QAAQ,KAAK,KAAK,IAAI,GAAG,CAAC;AAAA,EAEtC;AACF;"}

package/out/{chunk-WPAQ4EPM.js → replicache/src/kv/sqlite-store.js}

@@ -1,14 +1,7 @@
-import {
-  throwIfStoreClosed,
-  throwIfTransactionClosed
-} from "./chunk-ASRS2LFV.js";
-import {
-  deepFreeze
-} from "./chunk-EZM3XBAB.js";
-
-// ../replicache/src/kv/sqlite-store.ts
 import { RWLock } from "@rocicorp/lock";
-var SQLiteStore = class {
+import { deepFreeze } from "../frozen-json.js";
+import { throwIfStoreClosed, throwIfTransactionClosed } from "./throw-if-closed.js";
+class SQLiteStore {
   #filename;
   #entry;
   #closed = false;
@@ -53,7 +46,7 @@ var SQLiteStore = class {
   get closed() {
     return this.#closed;
   }
-};
+}
 function safeFilename(name) {
   return name.replace(/[^a-zA-Z0-9]/g, "_");
 }
@@ -79,7 +72,7 @@ function setupDatabase(delegate, opts) {
     del: delegate.prepare("DELETE FROM entry WHERE key = ?")
   };
 }
-var SQLiteStoreRead = class {
+class SQLiteStoreRead {
   #release;
   #closed = false;
   #preparedStatements;
@@ -110,8 +103,8 @@ var SQLiteStoreRead = class {
   get closed() {
     return this.#closed;
   }
-};
-var SQLiteWrite = class {
+}
+class SQLiteWrite {
   #release;
   #dbDelegate;
   #preparedStatements;
@@ -162,8 +155,8 @@ var SQLiteWrite = class {
   get closed() {
     return this.#closed;
   }
-};
-var stores = /* @__PURE__ */ new Map();
+}
+const stores = /* @__PURE__ */ new Map();
 function getOrCreateEntry(name, create, opts) {
   const filename = safeFilename(name);
   const entry = stores.get(filename);
@@ -221,10 +214,13 @@ function dropStore(name, createDelegate) {
   }
   return Promise.resolve();
 }
-
 export {
   SQLiteStore,
+  SQLiteStoreRead,
+  SQLiteWrite,
   clearAllNamedStoresForTesting,
-  dropStore
+  dropStore,
+  safeFilename,
+  setupDatabase
 };
-//# sourceMappingURL=chunk-WPAQ4EPM.js.map
+//# sourceMappingURL=sqlite-store.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-store.js","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  throwIfStoreClosed,\n  throwIfTransactionClosed,\n} from './throw-if-closed.ts';\n\n/**\n * A SQLite prepared statement.\n *\n * `run` executes the statement with optional parameters.\n * `all` executes the statement and returns the result rows.\n * `finalize` releases the statement.\n */\nexport interface PreparedStatement {\n  firstValue(params: string[]): Promise<unknown>;\n  exec(params: string[]): Promise<void>;\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 = safeFilename(name);\n    this.#entry = getOrCreateEntry(name, 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\nexport type PreparedStatements = {\n  has: PreparedStatement;\n  get: 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}\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    put: delegate.prepare(\n      'INSERT OR REPLACE INTO entry (key, value) VALUES (?, ?)',\n    ),\n    del: delegate.prepare('DELETE FROM entry WHERE key = ?'),\n  };\n}\n\nexport class SQLiteStoreRead implements Read {\n  #release: () => void;\n  #closed = false;\n  #preparedStatements: PreparedStatements;\n\n  constructor(release: () => void, preparedStatements: PreparedStatements) {\n    this.#release = release;\n    this.#preparedStatements = preparedStatements;\n  }\n\n  async has(key: string): Promise<boolean> {\n    throwIfTransactionClosed(this);\n    const value = await this.#preparedStatements.has.firstValue([key]);\n    return value !== undefined;\n  }\n\n  async get(key: string): Promise<ReadonlyJSONValue | undefined> {\n    throwIfTransactionClosed(this);\n    const value = await this.#preparedStatements.get.firstValue([key]);\n    if (!value) {\n      return undefined;\n    }\n\n    const parsedValue = JSON.parse(value as string) as ReadonlyJSONValue;\n    return deepFreeze(parsedValue);\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 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    this.#release = release;\n    this.#dbDelegate = dbDelegate;\n    this.#preparedStatements = preparedStatements;\n  }\n\n  async has(key: string): Promise<boolean> {\n    throwIfTransactionClosed(this);\n    const value = await this.#preparedStatements.has.firstValue([key]);\n    return value !== undefined;\n  }\n\n  async get(key: string): Promise<ReadonlyJSONValue | undefined> {\n    throwIfTransactionClosed(this);\n    const value = await this.#preparedStatements.get.firstValue([key]);\n    if (!value) {\n      return undefined;\n    }\n\n    const parsedValue = JSON.parse(value as string) as ReadonlyJSONValue;\n    return deepFreeze(parsedValue);\n  }\n\n  async put(key: string, value: ReadonlyJSONValue): Promise<void> {\n    throwIfTransactionClosed(this);\n    await this.#preparedStatements.put.exec([key, JSON.stringify(value)]);\n  }\n\n  async del(key: string): Promise<void> {\n    throwIfTransactionClosed(this);\n    await this.#preparedStatements.del.exec([key]);\n  }\n\n  // oxlint-disable-next-line require-await\n  async commit(): Promise<void> {\n    throwIfTransactionClosed(this);\n    this.#dbDelegate.execSync('COMMIT');\n    this.#committed = true;\n  }\n\n  release(): void {\n    if (!this.#closed) {\n      this.#closed = true;\n\n      if (!this.#committed) {\n        this.#dbDelegate.execSync('ROLLBACK');\n      }\n\n      this.#release();\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  name: string,\n  create: (filename: string, opts?: SQLiteStoreOptions) => SQLiteDatabase,\n  opts?: SQLiteStoreOptions,\n): StoreEntry {\n  const filename = safeFilename(name);\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): Promise<void> {\n  const filename = safeFilename(name);\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);\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"],"names":[],"mappings":"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"}

package/out/{chunk-ASRS2LFV.js → replicache/src/kv/throw-if-closed.js}

@@ -1,4 +1,3 @@
-// ../replicache/src/kv/throw-if-closed.ts
 function storeError() {
   return new Error("Store is closed");
 }
@@ -24,12 +23,11 @@ function maybeTransactionIsClosedRejection(transaction) {
 function storeIsClosedRejection() {
   return Promise.reject(storeError());
 }
-
 export {
+  maybeTransactionIsClosedRejection,
+  storeIsClosedRejection,
   throwIfStoreClosed,
   throwIfTransactionClosed,
-  transactionIsClosedRejection,
-  maybeTransactionIsClosedRejection,
-  storeIsClosedRejection
+  transactionIsClosedRejection
 };
-//# sourceMappingURL=chunk-ASRS2LFV.js.map
+//# sourceMappingURL=throw-if-closed.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"throw-if-closed.js","sources":["../../../../../replicache/src/kv/throw-if-closed.ts"],"sourcesContent":["function storeError(): Error {\n  return new Error('Store is closed');\n}\n\nfunction 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"],"names":[],"mappings":"AAAA,SAAS,aAAoB;AAC3B,SAAO,IAAI,MAAM,iBAAiB;AACpC;AAEA,SAAS,mBAA0B;AACjC,SAAO,IAAI,MAAM,uBAAuB;AAC1C;AAEO,SAAS,mBAAmB,OAAyC;AAC1E,MAAI,MAAM,QAAQ;AAChB,UAAM,WAAA;AAAA,EACR;AACF;AAEO,SAAS,yBAAyB,aAEhC;AACP,MAAI,YAAY,QAAQ;AACtB,UAAM,iBAAA;AAAA,EACR;AACF;AAEO,SAAS,+BAA+B;AAC7C,SAAO,QAAQ,OAAO,kBAAkB;AAC1C;AAEO,SAAS,kCAAkC,aAEnB;AAC7B,SAAO,YAAY,SAAS,6BAAA,IAAiC;AAC/D;AAEO,SAAS,yBAAyB;AACvC,SAAO,QAAQ,OAAO,YAAY;AACpC;"}

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

@@ -0,0 +1,57 @@
+import { promiseTrue, promiseFalse, promiseVoid } from "../../../shared/src/resolved-promises.js";
+import { deepFreezeAllowUndefined, deepFreeze } from "../frozen-json.js";
+import { transactionIsClosedRejection, maybeTransactionIsClosedRejection } from "./throw-if-closed.js";
+const deleteSentinel = Symbol();
+class WriteImplBase {
+  _pending = /* @__PURE__ */ new Map();
+  #read;
+  constructor(read) {
+    this.#read = read;
+  }
+  has(key) {
+    if (this.#read.closed) {
+      return transactionIsClosedRejection();
+    }
+    switch (this._pending.get(key)) {
+      case void 0:
+        return this.#read.has(key);
+      case deleteSentinel:
+        return promiseFalse;
+      default:
+        return promiseTrue;
+    }
+  }
+  async get(key) {
+    if (this.#read.closed) {
+      return transactionIsClosedRejection();
+    }
+    const v = this._pending.get(key);
+    switch (v) {
+      case deleteSentinel:
+        return void 0;
+      case void 0: {
+        const v2 = await this.#read.get(key);
+        return deepFreezeAllowUndefined(v2);
+      }
+      default:
+        return v;
+    }
+  }
+  put(key, value) {
+    return maybeTransactionIsClosedRejection(this.#read) ?? (this._pending.set(key, deepFreeze(value)), promiseVoid);
+  }
+  del(key) {
+    return maybeTransactionIsClosedRejection(this.#read) ?? (this._pending.set(key, deleteSentinel), promiseVoid);
+  }
+  release() {
+    this.#read.release();
+  }
+  get closed() {
+    return this.#read.closed;
+  }
+}
+export {
+  WriteImplBase,
+  deleteSentinel
+};
+//# sourceMappingURL=write-impl-base.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"write-impl-base.js","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"],"names":["v"],"mappings":";;;AAiBO,MAAM,iBAAiB,OAAA;AAGvB,MAAM,cAAc;AAAA,EACN,+BACb,IAAA;AAAA,EACG;AAAA,EAET,YAAY,MAAY;AACtB,SAAK,QAAQ;AAAA,EACf;AAAA,EAEA,IAAI,KAA+B;AACjC,QAAI,KAAK,MAAM,QAAQ;AACrB,aAAO,6BAAA;AAAA,IACT;AACA,YAAQ,KAAK,SAAS,IAAI,GAAG,GAAA;AAAA,MAC3B,KAAK;AACH,eAAO,KAAK,MAAM,IAAI,GAAG;AAAA,MAC3B,KAAK;AACH,eAAO;AAAA,MACT;AACE,eAAO;AAAA,IAAA;AAAA,EAEb;AAAA,EAEA,MAAM,IAAI,KAAmD;AAC3D,QAAI,KAAK,MAAM,QAAQ;AACrB,aAAO,6BAAA;AAAA,IACT;AACA,UAAM,IAAI,KAAK,SAAS,IAAI,GAAG;AAC/B,YAAQ,GAAA;AAAA,MACN,KAAK;AACH,eAAO;AAAA,MACT,KAAK,QAAW;AACd,cAAMA,KAAI,MAAM,KAAK,MAAM,IAAI,GAAG;AAClC,eAAO,yBAAyBA,EAAC;AAAA,MACnC;AAAA,MACA;AACE,eAAO;AAAA,IAAA;AAAA,EAEb;AAAA,EAEA,IAAI,KAAa,OAA0B;AACzC,WACE,kCAAkC,KAAK,KAAK,MAC3C,KAAK,SAAS,IAAI,KAAK,WAAW,KAAK,CAAC,GAAG;AAAA,EAEhD;AAAA,EAEA,IAAI,KAA4B;AAC9B,WACE,kCAAkC,KAAK,KAAK,MAC3C,KAAK,SAAS,IAAI,KAAK,cAAc,GAAG;AAAA,EAE7C;AAAA,EAEA,UAAgB;AACd,SAAK,MAAM,QAAA;AAAA,EACb;AAAA,EAEA,IAAI,SAAkB;AACpB,WAAO,KAAK,MAAM;AAAA,EACpB;AACF;"}

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

@@ -0,0 +1,30 @@
+import { promiseVoid } from "../../../shared/src/resolved-promises.js";
+import { ReadImpl } from "./read-impl.js";
+import { transactionIsClosedRejection } from "./throw-if-closed.js";
+import { WriteImplBase, deleteSentinel } from "./write-impl-base.js";
+class WriteImpl extends WriteImplBase {
+  #map;
+  constructor(map, release) {
+    super(new ReadImpl(map, release));
+    this.#map = map;
+  }
+  commit() {
+    if (this.closed) {
+      return transactionIsClosedRejection();
+    }
+    this._pending.forEach((value, key) => {
+      if (value === deleteSentinel) {
+        this.#map.delete(key);
+      } else {
+        this.#map.set(key, value);
+      }
+    });
+    this._pending.clear();
+    this.release();
+    return promiseVoid;
+  }
+}
+export {
+  WriteImpl
+};
+//# sourceMappingURL=write-impl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"write-impl.js","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"],"names":[],"mappings":";;;;AAOO,MAAM,kBAAkB,cAA+B;AAAA,EACnD;AAAA,EAET,YAAY,KAAmC,SAAqB;AAClE,UAAM,IAAI,SAAS,KAAK,OAAO,CAAC;AAChC,SAAK,OAAO;AAAA,EACd;AAAA,EAEA,SAAwB;AACtB,QAAI,KAAK,QAAQ;AACf,aAAO,6BAAA;AAAA,IACT;AAGA,SAAK,SAAS,QAAQ,CAAC,OAAO,QAAQ;AACpC,UAAI,UAAU,gBAAgB;AAC5B,aAAK,KAAK,OAAO,GAAG;AAAA,MACtB,OAAO;AACL,aAAK,KAAK,IAAI,KAAK,KAAK;AAAA,MAC1B;AAAA,IACF,CAAC;AACD,SAAK,SAAS,MAAA;AACd,SAAK,QAAA;AACL,WAAO;AAAA,EACT;AACF;"}

package/out/replicache/src/lazy.js

@@ -0,0 +1,13 @@
+function lazy(factory) {
+  let value;
+  return () => {
+    if (value === void 0) {
+      value = factory();
+    }
+    return value;
+  };
+}
+export {
+  lazy
+};
+//# sourceMappingURL=lazy.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lazy.js","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"],"names":[],"mappings":"AAAO,SAAS,KAAQ,SAA2B;AACjD,MAAI;AACJ,SAAO,MAAM;AACX,QAAI,UAAU,QAAW;AACvB,cAAQ,QAAA;AAAA,IACV;AACA,WAAO;AAAA,EACT;AACF;"}

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

@@ -0,0 +1,9 @@
+import { consoleLogSink, TeeLogSink, LogContext } from "@rocicorp/logger";
+function createLogContext(logLevel = "info", logSinks = [consoleLogSink], context) {
+  const logSink = logSinks.length === 1 ? logSinks[0] : new TeeLogSink(logSinks);
+  return new LogContext(logLevel, context, logSink);
+}
+export {
+  createLogContext
+};
+//# sourceMappingURL=log-options.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"log-options.js","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"],"names":[],"mappings":";AAgBO,SAAS,iBACd,WAAqB,QACrB,WAAsB,CAAC,cAAc,GACrC,SACY;AACZ,QAAM,UACJ,SAAS,WAAW,IAAI,SAAS,CAAC,IAAI,IAAI,WAAW,QAAQ;AAC/D,SAAO,IAAI,WAAW,UAAU,SAAS,OAAO;AAClD;"}

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

@@ -0,0 +1,13 @@
+import { Latest } from "./format-version-enum.js";
+function makeIDBName(name, schemaVersion) {
+  return makeIDBNameInternal(name, schemaVersion, Latest);
+}
+function makeIDBNameInternal(name, schemaVersion, formatVersion) {
+  const n = `rep:${name}:${formatVersion}`;
+  return schemaVersion ? `${n}:${schemaVersion}` : n;
+}
+export {
+  makeIDBName,
+  makeIDBNameInternal as makeIDBNameForTesting
+};
+//# sourceMappingURL=make-idb-name.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"make-idb-name.js","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"],"names":["FormatVersion.Latest"],"mappings":";AASO,SAAS,YAAY,MAAc,eAAgC;AACxE,SAAO,oBAAoB,MAAM,eAAeA,MAAoB;AACtE;AAEA,SAAS,oBACP,MACA,eACA,eACQ;AACR,QAAM,IAAI,OAAO,IAAI,IAAI,aAAa;AACtC,SAAO,gBAAgB,GAAG,CAAC,IAAI,aAAa,KAAK;AACnD;"}

package/out/replicache/src/new-client-channel.js

@@ -0,0 +1,51 @@
+import { BroadcastChannel as bc } from "../../shared/src/broadcast-channel.js";
+import { getClientGroup } from "./persist/client-groups.js";
+import { withRead } from "./with-transactions.js";
+function makeChannelNameV0(replicacheName) {
+  return `replicache-new-client-group:${replicacheName}`;
+}
+function makeChannelNameV1(replicacheName) {
+  return `replicache-new-client-group-v1:${replicacheName}`;
+}
+function isNewClientChannelMessageV1(message) {
+  return typeof message === "object" && typeof message.clientGroupID === "string" && typeof message.idbName === "string";
+}
+function initNewClientChannel(replicacheName, idbName, signal, clientGroupID, isNewClientGroup, onUpdateNeeded, perdag) {
+  if (signal.aborted) {
+    return;
+  }
+  const channelV1 = new bc(makeChannelNameV1(replicacheName));
+  if (isNewClientGroup) {
+    channelV1.postMessage({ clientGroupID, idbName });
+    const channelV0 = new bc(makeChannelNameV0(replicacheName));
+    channelV0.postMessage([clientGroupID]);
+    channelV0.close();
+  }
+  channelV1.onmessage = async (e) => {
+    const { data } = e;
+    if (isNewClientChannelMessageV1(data)) {
+      const { clientGroupID: newClientGroupID, idbName: newClientIDBName } = data;
+      if (newClientGroupID !== clientGroupID) {
+        if (newClientIDBName === idbName) {
+          const updateNeeded = await withRead(
+            perdag,
+            async (perdagRead) => await getClientGroup(newClientGroupID, perdagRead) !== void 0
+          );
+          if (updateNeeded) {
+            onUpdateNeeded();
+          }
+        } else {
+          onUpdateNeeded();
+          return;
+        }
+      }
+    }
+  };
+  signal.addEventListener("abort", () => channelV1.close(), { once: true });
+}
+export {
+  initNewClientChannel,
+  makeChannelNameV0 as makeChannelNameV0ForTesting,
+  makeChannelNameV1 as makeChannelNameV1ForTesting
+};
+//# sourceMappingURL=new-client-channel.js.map

package/out/replicache/src/new-client-channel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"new-client-channel.js","sources":["../../../../replicache/src/new-client-channel.ts"],"sourcesContent":["import {BroadcastChannel} from '../../shared/src/broadcast-channel.ts';\nimport type {Read, Store} from './dag/store.ts';\nimport {getClientGroup} from './persist/client-groups.ts';\nimport {withRead} from './with-transactions.ts';\n\n// Older clients (<= replicache@13.0.1), listened on this channel name\n// and *asserted* that the messages received were an array containing exactly\n// one string.\nfunction makeChannelNameV0(replicacheName: string): string {\n  return `replicache-new-client-group:${replicacheName}`;\n}\n\n// This channel name was introduced when we first needed to change the message\n// format.  The design of the messages sent on this channel allows for\n// the message content to be extended in the future in a way that is\n// forward and backwards compatible.  The message format can be extended\n// by adding new *optional* fields.\nfunction makeChannelNameV1(replicacheName: string): string {\n  return `replicache-new-client-group-v1:${replicacheName}`;\n}\n\nexport {\n  makeChannelNameV0 as makeChannelNameV0ForTesting,\n  makeChannelNameV1 as makeChannelNameV1ForTesting,\n};\n\n// This message type can be extended with optional properties.\ntype NewClientChannelMessageV1 = {clientGroupID: string; idbName: string};\n\nfunction isNewClientChannelMessageV1(\n  message: unknown,\n): message is NewClientChannelMessageV1 {\n  return (\n    typeof message === 'object' &&\n    typeof (message as {clientGroupID: unknown}).clientGroupID === 'string' &&\n    typeof (message as {idbName: unknown}).idbName === 'string'\n  );\n}\n\nexport function initNewClientChannel(\n  replicacheName: string,\n  idbName: string,\n  signal: AbortSignal,\n  clientGroupID: string,\n  isNewClientGroup: boolean,\n  onUpdateNeeded: () => void,\n  perdag: Store,\n) {\n  if (signal.aborted) {\n    return;\n  }\n\n  const channelV1 = new BroadcastChannel(makeChannelNameV1(replicacheName));\n  if (isNewClientGroup) {\n    channelV1.postMessage({clientGroupID, idbName});\n    // Send expected format to V0 channel for old clients.\n    const channelV0 = new BroadcastChannel(makeChannelNameV0(replicacheName));\n    channelV0.postMessage([clientGroupID]);\n    channelV0.close();\n  }\n\n  channelV1.onmessage = async (e: MessageEvent) => {\n    const {data} = e;\n    if (isNewClientChannelMessageV1(data)) {\n      const {clientGroupID: newClientGroupID, idbName: newClientIDBName} = data;\n      if (newClientGroupID !== clientGroupID) {\n        if (newClientIDBName === idbName) {\n          // Check if this client can see the new client's newClientGroupID in its\n          // perdag. It should be able to if the clients share persistent\n          // storage. However, with `ReplicacheOption.kvStore`\n          // and `IDBStoreWithMemFallback` clients may not actually share\n          // persistent storage.  If storage is not shared, then there is no point\n          // in updating, since clients cannot sync locally.  If clients do update\n          // in this case, they can continually cause each other to update, since\n          // on each update the clients get assigned a new client group.\n          const updateNeeded = await withRead(\n            perdag,\n            async (perdagRead: Read) =>\n              (await getClientGroup(newClientGroupID, perdagRead)) !==\n              undefined,\n          );\n          if (updateNeeded) {\n            onUpdateNeeded();\n          }\n        } else {\n          // Idb name is different, indicating new schema or format version.\n          // Update to get assigned to newClientIDBName, and hopefully\n          // newClientGroupID.\n          // If storage is not actually shared (i.e. due to\n          // `ReplicacheOption.kvStore`\n          // or `IDBStoreWithMemFallback`) the new client will not\n          // get assigned to newClientGroupID, but should get the\n          // newClientIDBName.\n          // Note: we don't try to read from newClientIDBName to see\n          // if this client shares storage with the new client, because\n          // the newClientIDBName may have a format version this client\n          // cannot read.\n          onUpdateNeeded();\n          return;\n        }\n      }\n    }\n  };\n\n  signal.addEventListener('abort', () => channelV1.close(), {once: true});\n}\n"],"names":["BroadcastChannel"],"mappings":";;;AAQA,SAAS,kBAAkB,gBAAgC;AACzD,SAAO,+BAA+B,cAAc;AACtD;AAOA,SAAS,kBAAkB,gBAAgC;AACzD,SAAO,kCAAkC,cAAc;AACzD;AAUA,SAAS,4BACP,SACsC;AACtC,SACE,OAAO,YAAY,YACnB,OAAQ,QAAqC,kBAAkB,YAC/D,OAAQ,QAA+B,YAAY;AAEvD;AAEO,SAAS,qBACd,gBACA,SACA,QACA,eACA,kBACA,gBACA,QACA;AACA,MAAI,OAAO,SAAS;AAClB;AAAA,EACF;AAEA,QAAM,YAAY,IAAIA,GAAiB,kBAAkB,cAAc,CAAC;AACxE,MAAI,kBAAkB;AACpB,cAAU,YAAY,EAAC,eAAe,QAAA,CAAQ;AAE9C,UAAM,YAAY,IAAIA,GAAiB,kBAAkB,cAAc,CAAC;AACxE,cAAU,YAAY,CAAC,aAAa,CAAC;AACrC,cAAU,MAAA;AAAA,EACZ;AAEA,YAAU,YAAY,OAAO,MAAoB;AAC/C,UAAM,EAAC,SAAQ;AACf,QAAI,4BAA4B,IAAI,GAAG;AACrC,YAAM,EAAC,eAAe,kBAAkB,SAAS,qBAAoB;AACrE,UAAI,qBAAqB,eAAe;AACtC,YAAI,qBAAqB,SAAS;AAShC,gBAAM,eAAe,MAAM;AAAA,YACzB;AAAA,YACA,OAAO,eACJ,MAAM,eAAe,kBAAkB,UAAU,MAClD;AAAA,UAAA;AAEJ,cAAI,cAAc;AAChB,2BAAA;AAAA,UACF;AAAA,QACF,OAAO;AAaL,yBAAA;AACA;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,SAAO,iBAAiB,SAAS,MAAM,UAAU,SAAS,EAAC,MAAM,MAAK;AACxE;"}

package/out/replicache/src/on-persist-channel.js

@@ -0,0 +1,36 @@
+import { assertObject, assertString } from "../../shared/src/asserts.js";
+import { BroadcastChannel as bc } from "../../shared/src/broadcast-channel.js";
+function makeChannelName(replicacheName) {
+  return `replicache-on-persist:${replicacheName}`;
+}
+function assertPersistInfo(value) {
+  assertObject(value);
+  assertString(value.clientGroupID);
+  assertString(value.clientID);
+}
+function initOnPersistChannel(replicacheName, signal, handlePersist) {
+  if (signal.aborted) {
+    return () => void 0;
+  }
+  const channel = new bc(makeChannelName(replicacheName));
+  channel.onmessage = (e) => {
+    const { data } = e;
+    assertPersistInfo(data);
+    handlePersist({
+      clientGroupID: data.clientGroupID,
+      clientID: data.clientID
+    });
+  };
+  signal.addEventListener("abort", () => channel.close(), { once: true });
+  return (persistInfo) => {
+    if (signal.aborted) {
+      return;
+    }
+    channel.postMessage(persistInfo);
+    handlePersist(persistInfo);
+  };
+}
+export {
+  initOnPersistChannel
+};
+//# sourceMappingURL=on-persist-channel.js.map

package/out/replicache/src/on-persist-channel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"on-persist-channel.js","sources":["../../../../replicache/src/on-persist-channel.ts"],"sourcesContent":["import {assertObject, assertString} from '../../shared/src/asserts.ts';\nimport {BroadcastChannel} from '../../shared/src/broadcast-channel.ts';\nimport type {ClientGroupID, ClientID} from './sync/ids.ts';\n\nfunction makeChannelName(replicacheName: string): string {\n  return `replicache-on-persist:${replicacheName}`;\n}\n\nexport type PersistInfo = {\n  clientGroupID: ClientGroupID;\n  clientID: ClientID;\n};\n\nexport type OnPersist = (persistInfo: PersistInfo) => void;\n\ntype HandlePersist = OnPersist;\n\nfunction assertPersistInfo(value: unknown): asserts value is PersistInfo {\n  assertObject(value);\n  assertString(value.clientGroupID);\n  assertString(value.clientID);\n}\n\nexport function initOnPersistChannel(\n  replicacheName: string,\n  signal: AbortSignal,\n  handlePersist: HandlePersist,\n): OnPersist {\n  if (signal.aborted) {\n    return () => undefined;\n  }\n  const channel = new BroadcastChannel(makeChannelName(replicacheName));\n\n  channel.onmessage = e => {\n    const {data} = e;\n    assertPersistInfo(data);\n    handlePersist({\n      clientGroupID: data.clientGroupID,\n      clientID: data.clientID,\n    });\n  };\n\n  signal.addEventListener('abort', () => channel.close(), {once: true});\n\n  return (persistInfo: PersistInfo) => {\n    if (signal.aborted) {\n      return;\n    }\n    channel.postMessage(persistInfo);\n    handlePersist(persistInfo);\n  };\n}\n"],"names":["BroadcastChannel"],"mappings":";;AAIA,SAAS,gBAAgB,gBAAgC;AACvD,SAAO,yBAAyB,cAAc;AAChD;AAWA,SAAS,kBAAkB,OAA8C;AACvE,eAAa,KAAK;AAClB,eAAa,MAAM,aAAa;AAChC,eAAa,MAAM,QAAQ;AAC7B;AAEO,SAAS,qBACd,gBACA,QACA,eACW;AACX,MAAI,OAAO,SAAS;AAClB,WAAO,MAAM;AAAA,EACf;AACA,QAAM,UAAU,IAAIA,GAAiB,gBAAgB,cAAc,CAAC;AAEpE,UAAQ,YAAY,CAAA,MAAK;AACvB,UAAM,EAAC,SAAQ;AACf,sBAAkB,IAAI;AACtB,kBAAc;AAAA,MACZ,eAAe,KAAK;AAAA,MACpB,UAAU,KAAK;AAAA,IAAA,CAChB;AAAA,EACH;AAEA,SAAO,iBAAiB,SAAS,MAAM,QAAQ,SAAS,EAAC,MAAM,MAAK;AAEpE,SAAO,CAAC,gBAA6B;AACnC,QAAI,OAAO,SAAS;AAClB;AAAA,IACF;AACA,YAAQ,YAAY,WAAW;AAC/B,kBAAc,WAAW;AAAA,EAC3B;AACF;"}

package/out/replicache/src/patch-operation.js

@@ -0,0 +1,42 @@
+import { assertArray, assertObject, assertString } from "../../shared/src/asserts.js";
+import { assertJSONObject, assertJSONValue } from "../../shared/src/json.js";
+function assertPatchOperations(p) {
+  assertArray(p);
+  for (const item of p) {
+    assertPatchOperation(item);
+  }
+}
+function assertPatchOperation(p) {
+  assertObject(p);
+  switch (p.op) {
+    case "put":
+      assertString(p.key);
+      assertJSONValue(p.value);
+      break;
+    case "update":
+      assertString(p.key);
+      if (p.merge !== void 0) {
+        assertJSONObject(p.merge);
+      }
+      if (p.constrain !== void 0) {
+        assertArray(p.constrain);
+        for (const key of p.constrain) {
+          assertString(key);
+        }
+      }
+      break;
+    case "del":
+      assertString(p.key);
+      break;
+    case "clear":
+      break;
+    default:
+      throw new Error(
+        `unknown patch op \`${p.op}\`, expected one of \`put\`, \`del\`, \`clear\``
+      );
+  }
+}
+export {
+  assertPatchOperations
+};
+//# sourceMappingURL=patch-operation.js.map

package/out/replicache/src/patch-operation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"patch-operation.js","sources":["../../../../replicache/src/patch-operation.ts"],"sourcesContent":["import {\n  assertArray,\n  assertObject,\n  assertString,\n} from '../../shared/src/asserts.ts';\nimport {\n  type ReadonlyJSONObject,\n  type ReadonlyJSONValue,\n  assertJSONObject,\n  assertJSONValue,\n} from '../../shared/src/json.ts';\n\nexport type PatchOperationInternal =\n  | {\n      readonly op: 'put';\n      readonly key: string;\n      readonly value: ReadonlyJSONValue;\n    }\n  | {\n      readonly op: 'update';\n      readonly key: string;\n      readonly merge?: ReadonlyJSONObject | undefined;\n      readonly constrain?: readonly string[] | undefined;\n    }\n  | {\n      readonly op: 'del';\n      readonly key: string;\n    }\n  | {\n      readonly op: 'clear';\n    };\n\n/**\n * This type describes the patch field in a {@link PullResponse} and it is used\n * to describe how to update the Replicache key-value store.\n */\nexport type PatchOperation =\n  | {\n      readonly op: 'put';\n      readonly key: string;\n      readonly value: ReadonlyJSONValue;\n    }\n  | {\n      readonly op: 'del';\n      readonly key: string;\n    }\n  | {\n      readonly op: 'clear';\n    };\n\nexport function assertPatchOperations(\n  p: unknown,\n): asserts p is PatchOperationInternal[] {\n  assertArray(p);\n  for (const item of p) {\n    assertPatchOperation(item);\n  }\n}\n\nfunction assertPatchOperation(p: unknown): asserts p is PatchOperationInternal {\n  assertObject(p);\n  switch (p.op) {\n    case 'put':\n      assertString(p.key);\n      assertJSONValue(p.value);\n      break;\n    case 'update':\n      assertString(p.key);\n      if (p.merge !== undefined) {\n        assertJSONObject(p.merge);\n      }\n      if (p.constrain !== undefined) {\n        assertArray(p.constrain);\n        for (const key of p.constrain) {\n          assertString(key);\n        }\n      }\n      break;\n    case 'del':\n      assertString(p.key);\n      break;\n    case 'clear':\n      break;\n    default:\n      throw new Error(\n        `unknown patch op \\`${p.op}\\`, expected one of \\`put\\`, \\`del\\`, \\`clear\\``,\n      );\n  }\n}\n"],"names":[],"mappings":";;AAkDO,SAAS,sBACd,GACuC;AACvC,cAAY,CAAC;AACb,aAAW,QAAQ,GAAG;AACpB,yBAAqB,IAAI;AAAA,EAC3B;AACF;AAEA,SAAS,qBAAqB,GAAiD;AAC7E,eAAa,CAAC;AACd,UAAQ,EAAE,IAAA;AAAA,IACR,KAAK;AACH,mBAAa,EAAE,GAAG;AAClB,sBAAgB,EAAE,KAAK;AACvB;AAAA,IACF,KAAK;AACH,mBAAa,EAAE,GAAG;AAClB,UAAI,EAAE,UAAU,QAAW;AACzB,yBAAiB,EAAE,KAAK;AAAA,MAC1B;AACA,UAAI,EAAE,cAAc,QAAW;AAC7B,oBAAY,EAAE,SAAS;AACvB,mBAAW,OAAO,EAAE,WAAW;AAC7B,uBAAa,GAAG;AAAA,QAClB;AAAA,MACF;AACA;AAAA,IACF,KAAK;AACH,mBAAa,EAAE,GAAG;AAClB;AAAA,IACF,KAAK;AACH;AAAA,IACF;AACE,YAAM,IAAI;AAAA,QACR,sBAAsB,EAAE,EAAE;AAAA,MAAA;AAAA,EAC5B;AAEN;"}