@rocicorp/zero 1.11.0-canary.1 → 1.11.0-canary.11

package/out/replicache/src/dag/gc.js.map

@@ -1 +1 @@
-{"version":3,"file":"gc.js","names":["#newHeads","#oldHeads","#putChunks","#delegate","#refsCounted","#refCountUpdates","#loadedRefCountPromises","#isLazyDelegate","#changeRefCount","#ensureRefCountLoaded","#updateRefsCounts","#updateRefCount"],"sources":["../../../../../replicache/src/dag/gc.ts"],"sourcesContent":["import {assert, assertNumber} from '../../../shared/src/asserts.ts';\nimport type {MaybePromise} from '../../../shared/src/types.ts';\nimport {skipGCAsserts} from '../config.ts';\nimport {type Hash, emptyHash} from '../hash.ts';\n\nexport type HeadChange = {\n  new: Hash | undefined;\n  old: Hash | undefined;\n};\n\ntype LoadedRefCountPromises = Map<Hash, Promise<number>>;\n\nexport interface RefCountUpdatesDelegate {\n  getRefCount: (hash: Hash) => MaybePromise<number | undefined>;\n  getRefs: (hash: Hash) => MaybePromise<readonly Hash[] | undefined>;\n  /**\n   * Should be implemented if the store lazily loads refs, returning whether\n   * or not the chunks refs have already been counted (i.e. are reflected\n   * in `getRefCount`).\n   *\n   * If defined then:\n   *  - `getRefs` should return undefined for refs that have not been loaded,\n   *    but should never return undefined for hashes in `putChunks`.\n   *  - it is assumed that chunks in `putChunks` may have been reachable before\n   *    the write, but may not have been counted.  This method is used to\n   *    determine if they have been counted or not.  If they have not been\n   *    counted, and are reachable with the write applied, the returned\n   *    ref count updates will include updates for counting them.\n   *\n   * If undefined then:\n   *  - `getRefs` should never return undefined\n   *  - it is assumed that the refs of any chunks which were reachable before\n   *    the write are already counted\n   */\n  areRefsCounted?: (hash: Hash) => boolean;\n}\n\n/**\n * Computes how ref counts should be updated when a dag write is committed.\n * Does not modify the dag store.\n * @param headChanges Heads that were changed by the dag write.\n * @param putChunks Chunks that were put by the dag write.\n * @param delegate Delegate used for getting ref information from the dag store.\n * @returns Map from chunk Hash to changed ref counts.  Chunks with a new ref\n * count of 0 should be deleted.  All hashes in `putChunks` will have an entry\n * (which will be zero if the newly put chunk is not reachable from any head).\n */\nexport function computeRefCountUpdates(\n  headChanges: Iterable<HeadChange>,\n  putChunks: ReadonlySet<Hash>,\n  delegate: RefCountUpdatesDelegate,\n): Promise<Map<Hash, number>> {\n  return new RefCountUpdates(headChanges, putChunks, delegate).compute();\n}\n\nclass RefCountUpdates {\n  readonly #newHeads: Hash[];\n  readonly #oldHeads: Hash[];\n  readonly #putChunks: ReadonlySet<Hash>;\n  readonly #delegate: RefCountUpdatesDelegate;\n  readonly #refsCounted: Set<Hash> | null;\n  readonly #refCountUpdates: Map<Hash, number>;\n  readonly #loadedRefCountPromises: LoadedRefCountPromises;\n  readonly #isLazyDelegate: boolean;\n\n  constructor(\n    headChanges: Iterable<HeadChange>,\n    putChunks: ReadonlySet<Hash>,\n    delegate: RefCountUpdatesDelegate,\n  ) {\n    const newHeads: Hash[] = [];\n    const oldHeads: Hash[] = [];\n    for (const changedHead of headChanges) {\n      if (changedHead.old !== changedHead.new) {\n        changedHead.old && oldHeads.push(changedHead.old);\n        changedHead.new && newHeads.push(changedHead.new);\n      }\n    }\n    this.#newHeads = newHeads;\n    this.#oldHeads = oldHeads;\n    this.#putChunks = putChunks;\n    this.#delegate = delegate;\n    this.#refCountUpdates = new Map();\n    // This map is used to ensure we do not load the ref count key more than once.\n    // Once it is loaded we only operate on a cache of the ref counts.\n    this.#loadedRefCountPromises = new Map();\n    this.#isLazyDelegate = delegate.areRefsCounted !== undefined;\n    this.#refsCounted = this.#isLazyDelegate ? new Set() : null;\n  }\n\n  async compute(): Promise<Map<Hash, number>> {\n    for (const n of this.#newHeads) {\n      await this.#changeRefCount(n, 1);\n    }\n\n    // Now go through the put chunks to ensure each has an entry in\n    // refCountUpdates (zero for new chunks which are not reachable from\n    // newHeads).\n    await Promise.all(\n      Array.from(this.#putChunks.values(), hash =>\n        this.#ensureRefCountLoaded(hash),\n      ),\n    );\n\n    if (this.#isLazyDelegate) {\n      assert(\n        this.#delegate.areRefsCounted,\n        'Expected delegate.areRefsCounted to be defined',\n      );\n      assert(this.#refsCounted, 'Expected refsCounted to be defined');\n      let refCountsUpdated;\n      do {\n        refCountsUpdated = false;\n        for (const hash of this.#putChunks.values()) {\n          if (\n            !this.#delegate.areRefsCounted(hash) &&\n            !this.#refsCounted.has(hash) &&\n            this.#refCountUpdates.get(hash) !== 0\n          ) {\n            await this.#updateRefsCounts(hash, 1);\n            refCountsUpdated = true;\n            break;\n          }\n        }\n      } while (refCountsUpdated);\n    }\n\n    for (const o of this.#oldHeads) {\n      await this.#changeRefCount(o, -1);\n    }\n\n    if (!skipGCAsserts) {\n      for (const [hash, update] of this.#refCountUpdates) {\n        assert(\n          update >= 0,\n          `ref count update must be non-negative. ${hash}:${update}`,\n        );\n      }\n    }\n\n    return this.#refCountUpdates;\n  }\n\n  async #changeRefCount(hash: Hash, delta: number): Promise<void> {\n    // First make sure that we have the ref count in the cache. This is async\n    // because it might need to load the ref count from the store (via the delegate).\n    //\n    // Once we have loaded the ref count all the updates to it are sync to\n    // prevent race conditions.\n    await this.#ensureRefCountLoaded(hash);\n    if (this.#updateRefCount(hash, delta)) {\n      await this.#updateRefsCounts(hash, delta);\n    }\n  }\n\n  async #updateRefsCounts(hash: Hash, delta: number) {\n    if (hash === emptyHash) {\n      return;\n    }\n    const refs = await this.#delegate.getRefs(hash);\n    if (!skipGCAsserts) {\n      assert(\n        refs || (this.#isLazyDelegate && !this.#putChunks.has(hash)),\n        'refs must be defined',\n      );\n    }\n\n    if (refs !== undefined) {\n      this.#refsCounted?.add(hash);\n      const ps = refs.map(ref => this.#changeRefCount(ref, delta));\n      await Promise.all(ps);\n    }\n  }\n\n  #ensureRefCountLoaded(hash: Hash): Promise<number> {\n    // Only get the ref count once.\n    let p = this.#loadedRefCountPromises.get(hash);\n    if (p === undefined) {\n      p = (async () => {\n        const value = (await this.#delegate.getRefCount(hash)) || 0;\n        this.#refCountUpdates.set(hash, value);\n        return value;\n      })();\n      this.#loadedRefCountPromises.set(hash, p);\n    }\n    return p;\n  }\n\n  #updateRefCount(hash: Hash, delta: number): boolean {\n    const oldCount = this.#refCountUpdates.get(hash);\n    assertNumber(oldCount);\n    this.#refCountUpdates.set(hash, oldCount + delta);\n    return (oldCount === 0 && delta === 1) || (oldCount === 1 && delta === -1);\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"gc.js","names":["#newHeads","#oldHeads","#putChunks","#delegate","#refsCounted","#refCountUpdates","#loadedRefCountPromises","#isLazyDelegate","#changeRefCount","#ensureRefCountLoaded","#updateRefsCounts","#updateRefCount"],"sources":["../../../../../replicache/src/dag/gc.ts"],"sourcesContent":["import {assert, assertNumber} from '../../../shared/src/asserts.ts';\nimport {getOrInsertComputed} from '../../../shared/src/map.ts';\nimport type {MaybePromise} from '../../../shared/src/types.ts';\nimport {skipGCAsserts} from '../config.ts';\nimport {type Hash, emptyHash} from '../hash.ts';\nimport {InvalidRefCountError} from './invalid-ref-count-error.ts';\n\nexport type HeadChange = {\n  new: Hash | undefined;\n  old: Hash | undefined;\n};\n\ntype LoadedRefCountPromises = Map<Hash, Promise<number>>;\n\nexport interface RefCountUpdatesDelegate {\n  getRefCount: (hash: Hash) => MaybePromise<number | undefined>;\n  getRefs: (hash: Hash) => MaybePromise<readonly Hash[] | undefined>;\n  /**\n   * Should be implemented if the store lazily loads refs, returning whether\n   * or not the chunks refs have already been counted (i.e. are reflected\n   * in `getRefCount`).\n   *\n   * If defined then:\n   *  - `getRefs` should return undefined for refs that have not been loaded,\n   *    but should never return undefined for hashes in `putChunks`.\n   *  - it is assumed that chunks in `putChunks` may have been reachable before\n   *    the write, but may not have been counted.  This method is used to\n   *    determine if they have been counted or not.  If they have not been\n   *    counted, and are reachable with the write applied, the returned\n   *    ref count updates will include updates for counting them.\n   *\n   * If undefined then:\n   *  - `getRefs` should never return undefined\n   *  - it is assumed that the refs of any chunks which were reachable before\n   *    the write are already counted\n   */\n  areRefsCounted?: (hash: Hash) => boolean;\n}\n\n/**\n * Computes how ref counts should be updated when a dag write is committed.\n * Does not modify the dag store.\n * @param headChanges Heads that were changed by the dag write.\n * @param putChunks Chunks that were put by the dag write.\n * @param delegate Delegate used for getting ref information from the dag store.\n * @returns Map from chunk Hash to changed ref counts.  Chunks with a new ref\n * count of 0 should be deleted.  All hashes in `putChunks` will have an entry\n * (which will be zero if the newly put chunk is not reachable from any head).\n */\nexport function computeRefCountUpdates(\n  headChanges: Iterable<HeadChange>,\n  putChunks: ReadonlySet<Hash>,\n  delegate: RefCountUpdatesDelegate,\n): Promise<Map<Hash, number>> {\n  return new RefCountUpdates(headChanges, putChunks, delegate).compute();\n}\n\nclass RefCountUpdates {\n  readonly #newHeads: Hash[];\n  readonly #oldHeads: Hash[];\n  readonly #putChunks: ReadonlySet<Hash>;\n  readonly #delegate: RefCountUpdatesDelegate;\n  readonly #refsCounted: Set<Hash> | null;\n  readonly #refCountUpdates: Map<Hash, number>;\n  readonly #loadedRefCountPromises: LoadedRefCountPromises;\n  readonly #isLazyDelegate: boolean;\n\n  constructor(\n    headChanges: Iterable<HeadChange>,\n    putChunks: ReadonlySet<Hash>,\n    delegate: RefCountUpdatesDelegate,\n  ) {\n    const newHeads: Hash[] = [];\n    const oldHeads: Hash[] = [];\n    for (const changedHead of headChanges) {\n      if (changedHead.old !== changedHead.new) {\n        changedHead.old && oldHeads.push(changedHead.old);\n        changedHead.new && newHeads.push(changedHead.new);\n      }\n    }\n    this.#newHeads = newHeads;\n    this.#oldHeads = oldHeads;\n    this.#putChunks = putChunks;\n    this.#delegate = delegate;\n    this.#refCountUpdates = new Map();\n    // This map is used to ensure we do not load the ref count key more than once.\n    // Once it is loaded we only operate on a cache of the ref counts.\n    this.#loadedRefCountPromises = new Map();\n    this.#isLazyDelegate = delegate.areRefsCounted !== undefined;\n    this.#refsCounted = this.#isLazyDelegate ? new Set() : null;\n  }\n\n  async compute(): Promise<Map<Hash, number>> {\n    for (const n of this.#newHeads) {\n      await this.#changeRefCount(n, 1);\n    }\n\n    // Now go through the put chunks to ensure each has an entry in\n    // refCountUpdates (zero for new chunks which are not reachable from\n    // newHeads).\n    await Promise.all(\n      Array.from(this.#putChunks.values(), hash =>\n        this.#ensureRefCountLoaded(hash),\n      ),\n    );\n\n    if (this.#isLazyDelegate) {\n      assert(\n        this.#delegate.areRefsCounted,\n        'Expected delegate.areRefsCounted to be defined',\n      );\n      assert(this.#refsCounted, 'Expected refsCounted to be defined');\n      let refCountsUpdated;\n      do {\n        refCountsUpdated = false;\n        for (const hash of this.#putChunks.values()) {\n          if (\n            !this.#delegate.areRefsCounted(hash) &&\n            !this.#refsCounted.has(hash) &&\n            this.#refCountUpdates.get(hash) !== 0\n          ) {\n            await this.#updateRefsCounts(hash, 1);\n            refCountsUpdated = true;\n            break;\n          }\n        }\n      } while (refCountsUpdated);\n    }\n\n    for (const o of this.#oldHeads) {\n      await this.#changeRefCount(o, -1);\n    }\n\n    // A negative count means a chunk that is still referenced had no (or too\n    // low a) ref count in the store, so the store is already corrupt. Always\n    // check this, even in production: writing the negative count would only\n    // spread the corruption, and the typed error lets the store owner recover.\n    // Written as `!(update >= 0)` so that NaN is rejected as well.\n    for (const [hash, update] of this.#refCountUpdates) {\n      if (!(update >= 0)) {\n        throw new InvalidRefCountError(hash, update);\n      }\n    }\n\n    return this.#refCountUpdates;\n  }\n\n  async #changeRefCount(hash: Hash, delta: number): Promise<void> {\n    // First make sure that we have the ref count in the cache. This is async\n    // because it might need to load the ref count from the store (via the delegate).\n    //\n    // Once we have loaded the ref count all the updates to it are sync to\n    // prevent race conditions.\n    await this.#ensureRefCountLoaded(hash);\n    if (this.#updateRefCount(hash, delta)) {\n      await this.#updateRefsCounts(hash, delta);\n    }\n  }\n\n  async #updateRefsCounts(hash: Hash, delta: number) {\n    if (hash === emptyHash) {\n      return;\n    }\n    const refs = await this.#delegate.getRefs(hash);\n    if (!skipGCAsserts) {\n      assert(\n        refs || (this.#isLazyDelegate && !this.#putChunks.has(hash)),\n        'refs must be defined',\n      );\n    }\n\n    if (refs !== undefined) {\n      this.#refsCounted?.add(hash);\n      const ps = refs.map(ref => this.#changeRefCount(ref, delta));\n      await Promise.all(ps);\n    }\n  }\n\n  #ensureRefCountLoaded(hash: Hash): Promise<number> {\n    // Only get the ref count once.\n    return getOrInsertComputed(\n      this.#loadedRefCountPromises,\n      hash,\n      async hash => {\n        const value = (await this.#delegate.getRefCount(hash)) || 0;\n        this.#refCountUpdates.set(hash, value);\n        return value;\n      },\n    );\n  }\n\n  #updateRefCount(hash: Hash, delta: number): boolean {\n    const oldCount = this.#refCountUpdates.get(hash);\n    assertNumber(oldCount);\n    this.#refCountUpdates.set(hash, oldCount + delta);\n    return (oldCount === 0 && delta === 1) || (oldCount === 1 && delta === -1);\n  }\n}\n"],"mappings":"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"}

package/out/replicache/src/dag/invalid-ref-count-error.d.ts

@@ -0,0 +1,12 @@
+import type { Hash } from '../hash.ts';
+/**
+ * Thrown when a ref count read from the store is not a valid Uint16. This
+ * means the store is corrupt (due to some unknown bug) and cannot be repaired.
+ */
+export declare class InvalidRefCountError extends Error {
+    name: string;
+    readonly hash: Hash;
+    readonly value: unknown;
+    constructor(hash: Hash, value: unknown);
+}
+//# sourceMappingURL=invalid-ref-count-error.d.ts.map

package/out/replicache/src/dag/invalid-ref-count-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalid-ref-count-error.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/dag/invalid-ref-count-error.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,YAAY,CAAC;AAErC;;;GAGG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,IAAI,SAA0B;IAC9B,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,YAAY,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAMrC;CACF"}

package/out/replicache/src/dag/invalid-ref-count-error.js

@@ -0,0 +1,19 @@
+//#region ../replicache/src/dag/invalid-ref-count-error.ts
+/**
+* Thrown when a ref count read from the store is not a valid Uint16. This
+* means the store is corrupt (due to some unknown bug) and cannot be repaired.
+*/
+var InvalidRefCountError = class extends Error {
+	name = "InvalidRefCountError";
+	hash;
+	value;
+	constructor(hash, value) {
+		super(`Invalid ref count ${String(value)} for ${hash}. We expect the value to be a Uint16`);
+		this.hash = hash;
+		this.value = value;
+	}
+};
+//#endregion
+export { InvalidRefCountError };
+
+//# sourceMappingURL=invalid-ref-count-error.js.map

package/out/replicache/src/dag/invalid-ref-count-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalid-ref-count-error.js","names":[],"sources":["../../../../../replicache/src/dag/invalid-ref-count-error.ts"],"sourcesContent":["import type {Hash} from '../hash.ts';\n\n/**\n * Thrown when a ref count read from the store is not a valid Uint16. This\n * means the store is corrupt (due to some unknown bug) and cannot be repaired.\n */\nexport class InvalidRefCountError extends Error {\n  name = 'InvalidRefCountError';\n  readonly hash: Hash;\n  readonly value: unknown;\n  constructor(hash: Hash, value: unknown) {\n    super(\n      `Invalid ref count ${String(value)} for ${hash}. We expect the value to be a Uint16`,\n    );\n    this.hash = hash;\n    this.value = value;\n  }\n}\n"],"mappings":";;;;;AAMA,IAAa,uBAAb,cAA0C,MAAM;CAC9C,OAAO;CACP;CACA;CACA,YAAY,MAAY,OAAgB;EACtC,MACE,qBAAqB,OAAO,KAAK,EAAE,OAAO,KAAK,qCACjD;EACA,KAAK,OAAO;EACZ,KAAK,QAAQ;CACf;AACF"}

package/out/replicache/src/dag/store-impl.d.ts

@@ -2,10 +2,20 @@ import { type Hash } from '../hash.ts';
 import type { Read as KVRead, Store as KVStore, Write as KVWrite } from '../kv/store.ts';
 import { Chunk, type ChunkHasher, type Refs } from './chunk.ts';
 import { type RefCountUpdatesDelegate } from './gc.ts';
+import { InvalidRefCountError } from './invalid-ref-count-error.ts';
 import { type Read, type Store, type Write } from './store.ts';
+/**
+ * Called when a write found an invalid ref count in the store. This is the
+ * single place where store corruption is detected, so the owner of the store
+ * can start recovery no matter which code path performed the write.
+ *
+ * The callback runs after the write transaction has been released, so it is
+ * safe for it to close or drop the underlying kv store.
+ */
+export type OnInvalidRefCount = (e: InvalidRefCountError) => void;
 export declare class StoreImpl implements Store {
     #private;
-    constructor(kv: KVStore, chunkHasher: ChunkHasher, assertValidHash: (hash: Hash) => void);
+    constructor(kv: KVStore, chunkHasher: ChunkHasher, assertValidHash: (hash: Hash) => void, onInvalidRefCount?: OnInvalidRefCount | undefined);
     read(): Promise<Read>;
     write(): Promise<Write>;
     close(): Promise<void>;
@@ -24,7 +34,7 @@ export declare class ReadImpl implements Read {
 export declare class WriteImpl extends ReadImpl implements Write, RefCountUpdatesDelegate {
     #private;
     protected readonly _tx: KVWrite;
-    constructor(kvw: KVWrite, chunkHasher: ChunkHasher, assertValidHash: (hash: Hash) => void);
+    constructor(kvw: KVWrite, chunkHasher: ChunkHasher, assertValidHash: (hash: Hash) => void, onInvalidRefCount?: OnInvalidRefCount | undefined);
     createChunk: <V>(data: V, refs: Refs) => Chunk<V>;
     get kvWrite(): KVWrite;
     putChunk(c: Chunk): Promise<void>;

package/out/replicache/src/dag/store-impl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store-impl.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/dag/store-impl.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,KAAK,IAAI,EAAa,MAAM,YAAY,CAAC;AACjD,OAAO,KAAK,EACV,IAAI,IAAI,MAAM,EACd,KAAK,IAAI,OAAO,EAChB,KAAK,IAAI,OAAO,EACjB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,KAAK,EACL,KAAK,WAAW,EAChB,KAAK,IAAI,EAGV,MAAM,YAAY,CAAC;AACpB,OAAO,EAAC,KAAK,uBAAuB,EAAyB,MAAM,SAAS,CAAC;AAE7E,OAAO,EAAC,KAAK,IAAI,EAAE,KAAK,KAAK,EAAE,KAAK,KAAK,EAAe,MAAM,YAAY,CAAC;AAE3E,qBAAa,SAAU,YAAW,KAAK;;IAKrC,YACE,EAAE,EAAE,OAAO,EACX,WAAW,EAAE,WAAW,EACxB,eAAe,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,EAKtC;IAEK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAE1B;IAEK,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC,CAM5B;IAED,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAErB;CACF;AAED,qBAAa,QAAS,YAAW,IAAI;IACnC,SAAS,CAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,eAAe,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;IAE/C,YAAY,EAAE,EAAE,MAAM,EAAE,eAAe,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,EAG5D;IAED,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,CAErC;IAEK,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC,CAoBrD;IAED,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,CAEvC;IAEK,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC,CAOrD;IAED,OAAO,IAAI,IAAI,CAEd;IAED,IAAI,MAAM,IAAI,OAAO,CAEpB;CACF;AAOD,qBAAa,SACX,SAAQ,QACR,YAAW,KAAK,EAAE,uBAAuB;;IAEzC,mBAA2B,GAAG,EAAE,OAAO,CAAC;IAMxC,YACE,GAAG,EAAE,OAAO,EACZ,WAAW,EAAE,WAAW,EACxB,eAAe,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,EAItC;IAED,WAAW,GAAI,CAAC,QAAQ,CAAC,QAAQ,IAAI,KAAG,KAAK,CAAC,CAAC,CAAC,CACH;IAE7C,IAAI,OAAO,IAAI,OAAO,CAErB;IAEK,QAAQ,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAiBtC;IAED,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/C;IAED,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEtC;IAwBK,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAQ5B;IAEK,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAYzD;IAEK,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC,CAOlD;IAyBD,OAAO,IAAI,IAAI,CAEd;CACF"}
+{"version":3,"file":"store-impl.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/dag/store-impl.ts"],"names":[],"mappings":"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"}

package/out/replicache/src/dag/store-impl.js

@@ -1,4 +1,4 @@
-import { assertNumber } from "../../../shared/src/asserts.js";
+import { InvalidRefCountError } from "./invalid-ref-count-error.js";
 import { assertHash } from "../hash.js";
 import { Chunk, assertRefs, createChunk } from "./chunk.js";
 import { computeRefCountUpdates } from "./gc.js";
@@ -9,16 +9,18 @@ var StoreImpl = class {
 	#kv;
 	#chunkHasher;
 	#assertValidHash;
-	constructor(kv, chunkHasher, assertValidHash) {
+	#onInvalidRefCount;
+	constructor(kv, chunkHasher, assertValidHash, onInvalidRefCount) {
 		this.#kv = kv;
 		this.#chunkHasher = chunkHasher;
 		this.#assertValidHash = assertValidHash;
+		this.#onInvalidRefCount = onInvalidRefCount;
 	}
 	async read() {
 		return new ReadImpl(await this.#kv.read(), this.#assertValidHash);
 	}
 	async write() {
-		return new WriteImpl(await this.#kv.write(), this.#chunkHasher, this.#assertValidHash);
+		return new WriteImpl(await this.#kv.write(), this.#chunkHasher, this.#assertValidHash, this.#onInvalidRefCount);
 	}
 	close() {
 		return this.#kv.close();
@@ -68,11 +70,14 @@ var ReadImpl = class {
 };
 var WriteImpl = class extends ReadImpl {
 	#chunkHasher;
+	#onInvalidRefCount;
+	#invalidRefCountError;
 	#putChunks = /* @__PURE__ */ new Set();
 	#changedHeads = /* @__PURE__ */ new Map();
-	constructor(kvw, chunkHasher, assertValidHash) {
+	constructor(kvw, chunkHasher, assertValidHash, onInvalidRefCount) {
 		super(kvw, assertValidHash);
 		this.#chunkHasher = chunkHasher;
+		this.#onInvalidRefCount = onInvalidRefCount;
 	}
 	createChunk = (data, refs) => createChunk(data, refs, this.#chunkHasher);
 	get kvWrite() {
@@ -113,15 +118,20 @@ var WriteImpl = class extends ReadImpl {
 		await p1;
 	}
 	async commit() {
-		const refCountUpdates = await computeRefCountUpdates(this.#changedHeads.values(), this.#putChunks, this);
+		let refCountUpdates;
+		try {
+			refCountUpdates = await computeRefCountUpdates(this.#changedHeads.values(), this.#putChunks, this);
+		} catch (e) {
+			if (e instanceof InvalidRefCountError) this.#invalidRefCountError = e;
+			throw e;
+		}
 		await this.#applyRefCountUpdates(refCountUpdates);
 		await this._tx.commit();
 	}
 	async getRefCount(hash) {
 		const value = await this._tx.get(chunkRefCountKey(hash));
 		if (value === void 0) return;
-		assertNumber(value);
-		if (value < 0 || value > 65535 || value !== (value | 0)) throw new Error(`Invalid ref count ${value}. We expect the value to be a Uint16`);
+		if (typeof value !== "number" || value < 0 || value > 65535 || value !== (value | 0)) throw new InvalidRefCountError(hash, value);
 		return value;
 	}
 	async getRefs(hash) {
@@ -148,7 +158,11 @@ var WriteImpl = class extends ReadImpl {
 		this.#putChunks.delete(hash);
 	}
 	release() {
-		this._tx.release();
+		try {
+			this._tx.release();
+		} finally {
+			if (this.#invalidRefCountError) this.#onInvalidRefCount?.(this.#invalidRefCountError);
+		}
 	}
 };
 //#endregion

package/out/replicache/src/dag/store-impl.js.map

@@ -1 +1 @@
-{"version":3,"file":"store-impl.js","names":["#kv","#chunkHasher","#assertValidHash","#putChunks","#changedHeads","#setHead","#applyRefCountUpdates","#removeAllRelatedKeys"],"sources":["../../../../../replicache/src/dag/store-impl.ts"],"sourcesContent":["import {assertNumber} from '../../../shared/src/asserts.ts';\nimport type {ReadonlyJSONValue} from '../../../shared/src/json.ts';\nimport {type Hash, assertHash} from '../hash.ts';\nimport type {\n  Read as KVRead,\n  Store as KVStore,\n  Write as KVWrite,\n} from '../kv/store.ts';\nimport {\n  Chunk,\n  type ChunkHasher,\n  type Refs,\n  assertRefs,\n  createChunk,\n} from './chunk.ts';\nimport {type RefCountUpdatesDelegate, computeRefCountUpdates} from './gc.ts';\nimport {chunkDataKey, chunkMetaKey, chunkRefCountKey, headKey} from './key.ts';\nimport {type Read, type Store, type Write, mustGetChunk} from './store.ts';\n\nexport class StoreImpl implements Store {\n  readonly #kv: KVStore;\n  readonly #chunkHasher: ChunkHasher;\n  readonly #assertValidHash: (hash: Hash) => void;\n\n  constructor(\n    kv: KVStore,\n    chunkHasher: ChunkHasher,\n    assertValidHash: (hash: Hash) => void,\n  ) {\n    this.#kv = kv;\n    this.#chunkHasher = chunkHasher;\n    this.#assertValidHash = assertValidHash;\n  }\n\n  async read(): Promise<Read> {\n    return new ReadImpl(await this.#kv.read(), this.#assertValidHash);\n  }\n\n  async write(): Promise<Write> {\n    return new WriteImpl(\n      await this.#kv.write(),\n      this.#chunkHasher,\n      this.#assertValidHash,\n    );\n  }\n\n  close(): Promise<void> {\n    return this.#kv.close();\n  }\n}\n\nexport class ReadImpl implements Read {\n  protected readonly _tx: KVRead;\n  readonly assertValidHash: (hash: Hash) => void;\n\n  constructor(kv: KVRead, assertValidHash: (hash: Hash) => void) {\n    this._tx = kv;\n    this.assertValidHash = assertValidHash;\n  }\n\n  hasChunk(hash: Hash): Promise<boolean> {\n    return this._tx.has(chunkDataKey(hash));\n  }\n\n  async getChunk(hash: Hash): Promise<Chunk | undefined> {\n    const dataPromise = this._tx.get(chunkDataKey(hash));\n    const refsPromise = this._tx.get(chunkMetaKey(hash));\n    const data = await dataPromise;\n    if (data === undefined) {\n      refsPromise.catch(() => {\n        // Ignore error since we will return undefined anyway.\n      });\n      return undefined;\n    }\n\n    const refsVal = await refsPromise;\n    let refs: Refs;\n    if (refsVal !== undefined) {\n      assertRefs(refsVal);\n      refs = refsVal;\n    } else {\n      refs = [];\n    }\n    return new Chunk(hash, data, refs);\n  }\n\n  mustGetChunk(hash: Hash): Promise<Chunk> {\n    return mustGetChunk(this, hash);\n  }\n\n  async getHead(name: string): Promise<Hash | undefined> {\n    const data = await this._tx.get(headKey(name));\n    if (data === undefined) {\n      return undefined;\n    }\n    assertHash(data);\n    return data;\n  }\n\n  release(): void {\n    this._tx.release();\n  }\n\n  get closed(): boolean {\n    return this._tx.closed;\n  }\n}\n\ntype HeadChange = {\n  new: Hash | undefined;\n  old: Hash | undefined;\n};\n\nexport class WriteImpl\n  extends ReadImpl\n  implements Write, RefCountUpdatesDelegate\n{\n  declare protected readonly _tx: KVWrite;\n  readonly #chunkHasher: ChunkHasher;\n\n  readonly #putChunks = new Set<Hash>();\n  readonly #changedHeads = new Map<string, HeadChange>();\n\n  constructor(\n    kvw: KVWrite,\n    chunkHasher: ChunkHasher,\n    assertValidHash: (hash: Hash) => void,\n  ) {\n    super(kvw, assertValidHash);\n    this.#chunkHasher = chunkHasher;\n  }\n\n  createChunk = <V>(data: V, refs: Refs): Chunk<V> =>\n    createChunk(data, refs, this.#chunkHasher);\n\n  get kvWrite(): KVWrite {\n    return this._tx;\n  }\n\n  async putChunk(c: Chunk): Promise<void> {\n    const {hash, data, meta} = c;\n    // We never want to write temp hashes to the underlying store.\n    this.assertValidHash(hash);\n    const key = chunkDataKey(hash);\n    // Commit contains InternalValue and Hash which are opaque types.\n    const p1 = this._tx.put(key, data as ReadonlyJSONValue);\n    let p2;\n    if (meta.length > 0) {\n      for (const h of meta) {\n        this.assertValidHash(h);\n      }\n      p2 = this._tx.put(chunkMetaKey(hash), meta);\n    }\n    this.#putChunks.add(hash);\n    await p1;\n    await p2;\n  }\n\n  setHead(name: string, hash: Hash): Promise<void> {\n    return this.#setHead(name, hash);\n  }\n\n  removeHead(name: string): Promise<void> {\n    return this.#setHead(name, undefined);\n  }\n\n  async #setHead(name: string, hash: Hash | undefined): Promise<void> {\n    const oldHash = await this.getHead(name);\n    const hk = headKey(name);\n\n    let p1: Promise<void>;\n    if (hash === undefined) {\n      p1 = this._tx.del(hk);\n    } else {\n      p1 = this._tx.put(hk, hash);\n    }\n\n    const v = this.#changedHeads.get(name);\n    if (v === undefined) {\n      this.#changedHeads.set(name, {new: hash, old: oldHash});\n    } else {\n      // Keep old if existing\n      v.new = hash;\n    }\n\n    await p1;\n  }\n\n  async commit(): Promise<void> {\n    const refCountUpdates = await computeRefCountUpdates(\n      this.#changedHeads.values(),\n      this.#putChunks,\n      this,\n    );\n    await this.#applyRefCountUpdates(refCountUpdates);\n    await this._tx.commit();\n  }\n\n  async getRefCount(hash: Hash): Promise<number | undefined> {\n    const value = await this._tx.get(chunkRefCountKey(hash));\n    if (value === undefined) {\n      return undefined;\n    }\n    assertNumber(value);\n    if (value < 0 || value > 0xffff || value !== (value | 0)) {\n      throw new Error(\n        `Invalid ref count ${value}. We expect the value to be a Uint16`,\n      );\n    }\n    return value;\n  }\n\n  async getRefs(hash: Hash): Promise<readonly Hash[]> {\n    const meta = await this._tx.get(chunkMetaKey(hash));\n    if (meta === undefined) {\n      return [];\n    }\n    assertRefs(meta);\n    return meta;\n  }\n\n  async #applyRefCountUpdates(refCountCache: Map<Hash, number>): Promise<void> {\n    const ps: Promise<void>[] = [];\n    for (const [hash, count] of refCountCache) {\n      if (count === 0) {\n        ps.push(this.#removeAllRelatedKeys(hash));\n      } else {\n        const refCountKey = chunkRefCountKey(hash);\n        ps.push(this._tx.put(refCountKey, count));\n      }\n    }\n    await Promise.all(ps);\n  }\n\n  async #removeAllRelatedKeys(hash: Hash): Promise<void> {\n    await Promise.all([\n      this._tx.del(chunkDataKey(hash)),\n      this._tx.del(chunkMetaKey(hash)),\n      this._tx.del(chunkRefCountKey(hash)),\n    ]);\n\n    this.#putChunks.delete(hash);\n  }\n\n  release(): void {\n    this._tx.release();\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"store-impl.js","names":["#kv","#chunkHasher","#assertValidHash","#onInvalidRefCount","#putChunks","#changedHeads","#setHead","#invalidRefCountError","#applyRefCountUpdates","#removeAllRelatedKeys"],"sources":["../../../../../replicache/src/dag/store-impl.ts"],"sourcesContent":["import type {ReadonlyJSONValue} from '../../../shared/src/json.ts';\nimport {type Hash, assertHash} from '../hash.ts';\nimport type {\n  Read as KVRead,\n  Store as KVStore,\n  Write as KVWrite,\n} from '../kv/store.ts';\nimport {\n  Chunk,\n  type ChunkHasher,\n  type Refs,\n  assertRefs,\n  createChunk,\n} from './chunk.ts';\nimport {type RefCountUpdatesDelegate, computeRefCountUpdates} from './gc.ts';\nimport {InvalidRefCountError} from './invalid-ref-count-error.ts';\nimport {chunkDataKey, chunkMetaKey, chunkRefCountKey, headKey} from './key.ts';\nimport {type Read, type Store, type Write, mustGetChunk} from './store.ts';\n\n/**\n * Called when a write found an invalid ref count in the store. This is the\n * single place where store corruption is detected, so the owner of the store\n * can start recovery no matter which code path performed the write.\n *\n * The callback runs after the write transaction has been released, so it is\n * safe for it to close or drop the underlying kv store.\n */\nexport type OnInvalidRefCount = (e: InvalidRefCountError) => void;\n\nexport class StoreImpl implements Store {\n  readonly #kv: KVStore;\n  readonly #chunkHasher: ChunkHasher;\n  readonly #assertValidHash: (hash: Hash) => void;\n  readonly #onInvalidRefCount: OnInvalidRefCount | undefined;\n\n  constructor(\n    kv: KVStore,\n    chunkHasher: ChunkHasher,\n    assertValidHash: (hash: Hash) => void,\n    onInvalidRefCount?: OnInvalidRefCount | undefined,\n  ) {\n    this.#kv = kv;\n    this.#chunkHasher = chunkHasher;\n    this.#assertValidHash = assertValidHash;\n    this.#onInvalidRefCount = onInvalidRefCount;\n  }\n\n  async read(): Promise<Read> {\n    return new ReadImpl(await this.#kv.read(), this.#assertValidHash);\n  }\n\n  async write(): Promise<Write> {\n    return new WriteImpl(\n      await this.#kv.write(),\n      this.#chunkHasher,\n      this.#assertValidHash,\n      this.#onInvalidRefCount,\n    );\n  }\n\n  close(): Promise<void> {\n    return this.#kv.close();\n  }\n}\n\nexport class ReadImpl implements Read {\n  protected readonly _tx: KVRead;\n  readonly assertValidHash: (hash: Hash) => void;\n\n  constructor(kv: KVRead, assertValidHash: (hash: Hash) => void) {\n    this._tx = kv;\n    this.assertValidHash = assertValidHash;\n  }\n\n  hasChunk(hash: Hash): Promise<boolean> {\n    return this._tx.has(chunkDataKey(hash));\n  }\n\n  async getChunk(hash: Hash): Promise<Chunk | undefined> {\n    const dataPromise = this._tx.get(chunkDataKey(hash));\n    const refsPromise = this._tx.get(chunkMetaKey(hash));\n    const data = await dataPromise;\n    if (data === undefined) {\n      refsPromise.catch(() => {\n        // Ignore error since we will return undefined anyway.\n      });\n      return undefined;\n    }\n\n    const refsVal = await refsPromise;\n    let refs: Refs;\n    if (refsVal !== undefined) {\n      assertRefs(refsVal);\n      refs = refsVal;\n    } else {\n      refs = [];\n    }\n    return new Chunk(hash, data, refs);\n  }\n\n  mustGetChunk(hash: Hash): Promise<Chunk> {\n    return mustGetChunk(this, hash);\n  }\n\n  async getHead(name: string): Promise<Hash | undefined> {\n    const data = await this._tx.get(headKey(name));\n    if (data === undefined) {\n      return undefined;\n    }\n    assertHash(data);\n    return data;\n  }\n\n  release(): void {\n    this._tx.release();\n  }\n\n  get closed(): boolean {\n    return this._tx.closed;\n  }\n}\n\ntype HeadChange = {\n  new: Hash | undefined;\n  old: Hash | undefined;\n};\n\nexport class WriteImpl\n  extends ReadImpl\n  implements Write, RefCountUpdatesDelegate\n{\n  declare protected readonly _tx: KVWrite;\n  readonly #chunkHasher: ChunkHasher;\n  readonly #onInvalidRefCount: OnInvalidRefCount | undefined;\n  #invalidRefCountError: InvalidRefCountError | undefined;\n\n  readonly #putChunks = new Set<Hash>();\n  readonly #changedHeads = new Map<string, HeadChange>();\n\n  constructor(\n    kvw: KVWrite,\n    chunkHasher: ChunkHasher,\n    assertValidHash: (hash: Hash) => void,\n    onInvalidRefCount?: OnInvalidRefCount | undefined,\n  ) {\n    super(kvw, assertValidHash);\n    this.#chunkHasher = chunkHasher;\n    this.#onInvalidRefCount = onInvalidRefCount;\n  }\n\n  createChunk = <V>(data: V, refs: Refs): Chunk<V> =>\n    createChunk(data, refs, this.#chunkHasher);\n\n  get kvWrite(): KVWrite {\n    return this._tx;\n  }\n\n  async putChunk(c: Chunk): Promise<void> {\n    const {hash, data, meta} = c;\n    // We never want to write temp hashes to the underlying store.\n    this.assertValidHash(hash);\n    const key = chunkDataKey(hash);\n    // Commit contains InternalValue and Hash which are opaque types.\n    const p1 = this._tx.put(key, data as ReadonlyJSONValue);\n    let p2;\n    if (meta.length > 0) {\n      for (const h of meta) {\n        this.assertValidHash(h);\n      }\n      p2 = this._tx.put(chunkMetaKey(hash), meta);\n    }\n    this.#putChunks.add(hash);\n    await p1;\n    await p2;\n  }\n\n  setHead(name: string, hash: Hash): Promise<void> {\n    return this.#setHead(name, hash);\n  }\n\n  removeHead(name: string): Promise<void> {\n    return this.#setHead(name, undefined);\n  }\n\n  async #setHead(name: string, hash: Hash | undefined): Promise<void> {\n    const oldHash = await this.getHead(name);\n    const hk = headKey(name);\n\n    let p1: Promise<void>;\n    if (hash === undefined) {\n      p1 = this._tx.del(hk);\n    } else {\n      p1 = this._tx.put(hk, hash);\n    }\n\n    const v = this.#changedHeads.get(name);\n    if (v === undefined) {\n      this.#changedHeads.set(name, {new: hash, old: oldHash});\n    } else {\n      // Keep old if existing\n      v.new = hash;\n    }\n\n    await p1;\n  }\n\n  async commit(): Promise<void> {\n    let refCountUpdates: Map<Hash, number>;\n    try {\n      refCountUpdates = await computeRefCountUpdates(\n        this.#changedHeads.values(),\n        this.#putChunks,\n        this,\n      );\n    } catch (e) {\n      if (e instanceof InvalidRefCountError) {\n        // Reported from release() rather than here: the owner may drop the\n        // store in response and the kv transaction still needs to roll back.\n        this.#invalidRefCountError = e;\n      }\n      throw e;\n    }\n    await this.#applyRefCountUpdates(refCountUpdates);\n    await this._tx.commit();\n  }\n\n  async getRefCount(hash: Hash): Promise<number | undefined> {\n    const value = await this._tx.get(chunkRefCountKey(hash));\n    if (value === undefined) {\n      return undefined;\n    }\n    if (\n      typeof value !== 'number' ||\n      value < 0 ||\n      value > 0xffff ||\n      value !== (value | 0)\n    ) {\n      throw new InvalidRefCountError(hash, value);\n    }\n    return value;\n  }\n\n  async getRefs(hash: Hash): Promise<readonly Hash[]> {\n    const meta = await this._tx.get(chunkMetaKey(hash));\n    if (meta === undefined) {\n      return [];\n    }\n    assertRefs(meta);\n    return meta;\n  }\n\n  async #applyRefCountUpdates(refCountCache: Map<Hash, number>): Promise<void> {\n    const ps: Promise<void>[] = [];\n    for (const [hash, count] of refCountCache) {\n      if (count === 0) {\n        ps.push(this.#removeAllRelatedKeys(hash));\n      } else {\n        const refCountKey = chunkRefCountKey(hash);\n        ps.push(this._tx.put(refCountKey, count));\n      }\n    }\n    await Promise.all(ps);\n  }\n\n  async #removeAllRelatedKeys(hash: Hash): Promise<void> {\n    await Promise.all([\n      this._tx.del(chunkDataKey(hash)),\n      this._tx.del(chunkMetaKey(hash)),\n      this._tx.del(chunkRefCountKey(hash)),\n    ]);\n\n    this.#putChunks.delete(hash);\n  }\n\n  release(): void {\n    try {\n      this._tx.release();\n    } finally {\n      // Report even if the kv release threw (for example a failed SQLite\n      // ROLLBACK): the store is corrupt either way and the owner must still\n      // recover. The release error keeps propagating to the caller.\n      if (this.#invalidRefCountError) {\n        this.#onInvalidRefCount?.(this.#invalidRefCountError);\n      }\n    }\n  }\n}\n"],"mappings":"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"}

package/out/replicache/src/db/rebase.d.ts

@@ -8,7 +8,19 @@ import type { ClientID } from '../sync/ids.ts';
 import type { MutatorDefs } from '../types.ts';
 import { type Commit, type LocalMeta, type Meta } from './commit.ts';
 type FormatVersion = Enum<typeof FormatVersion>;
-export declare function rebaseMutationAndPutCommit(mutation: Commit<LocalMeta>, dagWrite: DagWrite, basis: Hash, mutators: MutatorDefs, lc: LogContext, mutationClientID: ClientID, formatVersion: FormatVersion, zeroData: ZeroTxData | undefined): Promise<Commit<Meta>>;
-export declare function rebaseMutationAndCommit(mutation: Commit<LocalMeta>, dagWrite: DagWrite, basis: Hash, headName: string, mutators: MutatorDefs, lc: LogContext, mutationClientID: ClientID, formatVersion: FormatVersion, zeroData: ZeroTxData | undefined): Promise<Hash>;
+/**
+ * The result of replaying one mutation.
+ *
+ * `zeroData` is the Zero transaction data to use for the next mutation in the
+ * same replay. Each mutation runs against its own fork. On success that fork is
+ * returned, and if the mutator throws the caller gets back the one it passed
+ * in, without the failed mutation's IVM writes. See `rebaseMutation`.
+ */
+export type RebaseResult<T> = {
+    result: T;
+    zeroData: ZeroTxData | undefined;
+};
+export declare function rebaseMutationAndPutCommit(mutation: Commit<LocalMeta>, dagWrite: DagWrite, basis: Hash, mutators: MutatorDefs, lc: LogContext, mutationClientID: ClientID, formatVersion: FormatVersion, zeroData: ZeroTxData | undefined): Promise<RebaseResult<Commit<Meta>>>;
+export declare function rebaseMutationAndCommit(mutation: Commit<LocalMeta>, dagWrite: DagWrite, basis: Hash, headName: string, mutators: MutatorDefs, lc: LogContext, mutationClientID: ClientID, formatVersion: FormatVersion, zeroData: ZeroTxData | undefined): Promise<RebaseResult<Hash>>;
 export {};
 //# sourceMappingURL=rebase.d.ts.map

package/out/replicache/src/db/rebase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rebase.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/db/rebase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,6BAA6B,CAAC;AACtD,OAAO,KAAK,EAAC,KAAK,IAAI,QAAQ,EAAC,MAAM,iBAAiB,CAAC;AACvD,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAC3D,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,YAAY,CAAC;AACrC,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AAE7C,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,aAAa,CAAC;AAC7C,OAAO,EACL,KAAK,MAAM,EACX,KAAK,SAAS,EAEd,KAAK,IAAI,EAIV,MAAM,aAAa,CAAC;AAIrB,KAAK,aAAa,GAAG,IAAI,CAAC,OAAO,aAAa,CAAC,CAAC;AA8EhD,wBAAsB,0BAA0B,CAC9C,QAAQ,EAAE,MAAM,CAAC,SAAS,CAAC,EAC3B,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,IAAI,EACX,QAAQ,EAAE,WAAW,EACrB,EAAE,EAAE,UAAU,EAGd,gBAAgB,EAAE,QAAQ,EAC1B,aAAa,EAAE,aAAa,EAC5B,QAAQ,EAAE,UAAU,GAAG,SAAS,GAC/B,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAYvB;AAED,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,MAAM,CAAC,SAAS,CAAC,EAC3B,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,IAAI,EACX,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,WAAW,EACrB,EAAE,EAAE,UAAU,EAGd,gBAAgB,EAAE,QAAQ,EAC1B,aAAa,EAAE,aAAa,EAC5B,QAAQ,EAAE,UAAU,GAAG,SAAS,GAC/B,OAAO,CAAC,IAAI,CAAC,CAYf"}
+{"version":3,"file":"rebase.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/db/rebase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,6BAA6B,CAAC;AACtD,OAAO,KAAK,EAAC,KAAK,IAAI,QAAQ,EAAC,MAAM,iBAAiB,CAAC;AACvD,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAC3D,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,YAAY,CAAC;AACrC,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AAE7C,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,aAAa,CAAC;AAC7C,OAAO,EACL,KAAK,MAAM,EACX,KAAK,SAAS,EAEd,KAAK,IAAI,EAIV,MAAM,aAAa,CAAC;AAIrB,KAAK,aAAa,GAAG,IAAI,CAAC,OAAO,aAAa,CAAC,CAAC;AAEhD;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI;IAC5B,MAAM,EAAE,CAAC,CAAC;IACV,QAAQ,EAAE,UAAU,GAAG,SAAS,CAAC;CAClC,CAAC;AA8GF,wBAAsB,0BAA0B,CAC9C,QAAQ,EAAE,MAAM,CAAC,SAAS,CAAC,EAC3B,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,IAAI,EACX,QAAQ,EAAE,WAAW,EACrB,EAAE,EAAE,UAAU,EAGd,gBAAgB,EAAE,QAAQ,EAC1B,aAAa,EAAE,aAAa,EAC5B,QAAQ,EAAE,UAAU,GAAG,SAAS,GAC/B,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAYrC;AAED,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,MAAM,CAAC,SAAS,CAAC,EAC3B,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,IAAI,EACX,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,WAAW,EACrB,EAAE,EAAE,UAAU,EAGd,gBAAgB,EAAE,QAAQ,EAC1B,aAAa,EAAE,aAAa,EAC5B,QAAQ,EAAE,UAAU,GAAG,SAAS,GAC/B,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAY7B"}

package/out/replicache/src/db/rebase.js

@@ -14,15 +14,37 @@ async function rebaseMutation(mutation, dagWrite, basisHash, mutators, lc, mutat
 	const nextMutationID = await (await commitFromHash(basisHash, dagWrite)).getNextMutationID(mutationClientID, dagWrite);
 	if (nextMutationID !== localMeta.mutationID) throw new Error(`Inconsistent mutation ID: original: ${localMeta.mutationID}, next: ${nextMutationID} - mutationClientID: ${mutationClientID} mutatorName: ${name}`);
 	if (formatVersion >= 5) assertLocalMetaDD31(localMeta);
-	const dbWrite = await newWriteLocal(basisHash, name, args, mutation.chunk.hash, dagWrite, localMeta.timestamp, mutationClientID, formatVersion);
-	await mutatorImpl(new WriteTransactionImpl(mutationClientID, await dbWrite.getMutationID(), "rebase", zeroData, dbWrite, lc), args);
-	return dbWrite;
+	const newWrite = () => newWriteLocal(basisHash, name, args, mutation.chunk.hash, dagWrite, localMeta.timestamp, mutationClientID, formatVersion);
+	const dbWrite = await newWrite();
+	const txData = zeroData?.fork();
+	const tx = new WriteTransactionImpl(mutationClientID, await dbWrite.getMutationID(), "rebase", txData, dbWrite, lc);
+	try {
+		await mutatorImpl(tx, args);
+	} catch (e) {
+		lc.info?.(`Rebase of mutator ${name} threw, abandoning its prediction`, e);
+		return {
+			result: await newWrite(),
+			zeroData
+		};
+	}
+	return {
+		result: dbWrite,
+		zeroData: txData
+	};
 }
 async function rebaseMutationAndPutCommit(mutation, dagWrite, basis, mutators, lc, mutationClientID, formatVersion, zeroData) {
-	return (await rebaseMutation(mutation, dagWrite, basis, mutators, lc, mutationClientID, formatVersion, zeroData)).putCommit();
+	const { result: tx, zeroData: next } = await rebaseMutation(mutation, dagWrite, basis, mutators, lc, mutationClientID, formatVersion, zeroData);
+	return {
+		result: await tx.putCommit(),
+		zeroData: next
+	};
 }
 async function rebaseMutationAndCommit(mutation, dagWrite, basis, headName, mutators, lc, mutationClientID, formatVersion, zeroData) {
-	return (await rebaseMutation(mutation, dagWrite, basis, mutators, lc, mutationClientID, formatVersion, zeroData)).commit(headName);
+	const { result: dbWrite, zeroData: next } = await rebaseMutation(mutation, dagWrite, basis, mutators, lc, mutationClientID, formatVersion, zeroData);
+	return {
+		result: await dbWrite.commit(headName),
+		zeroData: next
+	};
 }
 //#endregion
 export { rebaseMutationAndCommit, rebaseMutationAndPutCommit };

package/out/replicache/src/db/rebase.js.map

@@ -1 +1 @@
-{"version":3,"file":"rebase.js","names":[],"sources":["../../../../../replicache/src/db/rebase.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport type {Write as DagWrite} from '../dag/store.ts';\nimport * as FormatVersion from '../format-version-enum.ts';\nimport type {Hash} from '../hash.ts';\nimport type {ZeroTxData} from '../replicache-options.ts';\nimport type {ClientID} from '../sync/ids.ts';\nimport {WriteTransactionImpl} from '../transactions.ts';\nimport type {MutatorDefs} from '../types.ts';\nimport {\n  type Commit,\n  type LocalMeta,\n  type LocalMetaDD31,\n  type Meta,\n  assertLocalMetaDD31,\n  commitFromHash,\n  isLocalMetaDD31,\n} from './commit.ts';\nimport type {Write} from './write.ts';\nimport {newWriteLocal} from './write.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\nasync function rebaseMutation(\n  mutation: Commit<LocalMetaDD31>,\n  dagWrite: DagWrite,\n  basisHash: Hash,\n  mutators: MutatorDefs,\n  lc: LogContext,\n  mutationClientID: ClientID,\n  formatVersion: FormatVersion,\n  zeroData: ZeroTxData | undefined,\n): Promise<Write> {\n  const localMeta = mutation.meta;\n  const name = localMeta.mutatorName;\n  if (isLocalMetaDD31(localMeta)) {\n    assert(\n      localMeta.clientID === mutationClientID,\n      'mutationClientID must match clientID of LocalMeta',\n    );\n  }\n  const maybeMutatorImpl = mutators[name];\n  if (!maybeMutatorImpl) {\n    // Developers must not remove mutator names from code deployed with the\n    // same schemaVersion because Replicache needs to be able to replay\n    // mutations during pull.\n    //\n    // If we detect that this has happened, stub in a no-op mutator so that at\n    // least sync can move forward. Note that the server-side mutation will\n    // still get sent. This doesn't remove the queued local mutation, it just\n    // removes its visible effects.\n    lc.error?.(`Cannot rebase unknown mutator ${name}`);\n  }\n  const mutatorImpl =\n    maybeMutatorImpl ||\n    (async () => {\n      // no op\n    });\n\n  const args = localMeta.mutatorArgsJSON;\n\n  const basisCommit = await commitFromHash(basisHash, dagWrite);\n  const nextMutationID = await basisCommit.getNextMutationID(\n    mutationClientID,\n    dagWrite,\n  );\n  if (nextMutationID !== localMeta.mutationID) {\n    throw new Error(\n      `Inconsistent mutation ID: original: ${localMeta.mutationID}, next: ${nextMutationID} - mutationClientID: ${mutationClientID} mutatorName: ${name}`,\n    );\n  }\n\n  if (formatVersion >= FormatVersion.DD31) {\n    assertLocalMetaDD31(localMeta);\n  }\n\n  const dbWrite = await newWriteLocal(\n    basisHash,\n    name,\n    args,\n    mutation.chunk.hash,\n    dagWrite,\n    localMeta.timestamp,\n    mutationClientID,\n    formatVersion,\n  );\n\n  const tx = new WriteTransactionImpl(\n    mutationClientID,\n    await dbWrite.getMutationID(),\n    'rebase',\n    zeroData,\n    dbWrite,\n    lc,\n  );\n  await mutatorImpl(tx, args);\n  return dbWrite;\n}\n\nexport async function rebaseMutationAndPutCommit(\n  mutation: Commit<LocalMeta>,\n  dagWrite: DagWrite,\n  basis: Hash,\n  mutators: MutatorDefs,\n  lc: LogContext,\n  // TODO(greg): mutationClientID can be retrieved from mutation if LocalMeta\n  // is a LocalMetaDD31.  As part of DD31 cleanup we can remove this arg.\n  mutationClientID: ClientID,\n  formatVersion: FormatVersion,\n  zeroData: ZeroTxData | undefined,\n): Promise<Commit<Meta>> {\n  const tx = await rebaseMutation(\n    mutation,\n    dagWrite,\n    basis,\n    mutators,\n    lc,\n    mutationClientID,\n    formatVersion,\n    zeroData,\n  );\n  return tx.putCommit();\n}\n\nexport async function rebaseMutationAndCommit(\n  mutation: Commit<LocalMeta>,\n  dagWrite: DagWrite,\n  basis: Hash,\n  headName: string,\n  mutators: MutatorDefs,\n  lc: LogContext,\n  // TODO(greg): mutationClientID can be retrieved from mutation if LocalMeta\n  // is a LocalMetaDD31.  As part of DD31 cleanup we can remove this arg.\n  mutationClientID: ClientID,\n  formatVersion: FormatVersion,\n  zeroData: ZeroTxData | undefined,\n): Promise<Hash> {\n  const dbWrite = await rebaseMutation(\n    mutation,\n    dagWrite,\n    basis,\n    mutators,\n    lc,\n    mutationClientID,\n    formatVersion,\n    zeroData,\n  );\n  return dbWrite.commit(headName);\n}\n"],"mappings":";;;;;AAwBA,eAAe,eACb,UACA,UACA,WACA,UACA,IACA,kBACA,eACA,UACgB;CAChB,MAAM,YAAY,SAAS;CAC3B,MAAM,OAAO,UAAU;CACvB,IAAI,gBAAgB,SAAS,GAC3B,OACE,UAAU,aAAa,kBACvB,mDACF;CAEF,MAAM,mBAAmB,SAAS;CAClC,IAAI,CAAC,kBASH,GAAG,QAAQ,iCAAiC,MAAM;CAEpD,MAAM,cACJ,qBACC,YAAY,CAEb;CAEF,MAAM,OAAO,UAAU;CAGvB,MAAM,iBAAiB,OAAM,MADH,eAAe,WAAW,QAAQ,GACnB,kBACvC,kBACA,QACF;CACA,IAAI,mBAAmB,UAAU,YAC/B,MAAM,IAAI,MACR,uCAAuC,UAAU,WAAW,UAAU,eAAe,uBAAuB,iBAAiB,gBAAgB,MAC/I;CAGF,IAAI,iBAAiB,GACnB,oBAAoB,SAAS;CAG/B,MAAM,UAAU,MAAM,cACpB,WACA,MACA,MACA,SAAS,MAAM,MACf,UACA,UAAU,WACV,kBACA,aACF;CAUA,MAAM,YAAY,IARH,qBACb,kBACA,MAAM,QAAQ,cAAc,GAC5B,UACA,UACA,SACA,EAEgB,GAAI,IAAI;CAC1B,OAAO;AACT;AAEA,eAAsB,2BACpB,UACA,UACA,OACA,UACA,IAGA,kBACA,eACA,UACuB;CAWvB,QAAO,MAVU,eACf,UACA,UACA,OACA,UACA,IACA,kBACA,eACA,QACF,GACU,UAAU;AACtB;AAEA,eAAsB,wBACpB,UACA,UACA,OACA,UACA,UACA,IAGA,kBACA,eACA,UACe;CAWf,QAAO,MAVe,eACpB,UACA,UACA,OACA,UACA,IACA,kBACA,eACA,QACF,GACe,OAAO,QAAQ;AAChC"}
+{"version":3,"file":"rebase.js","names":[],"sources":["../../../../../replicache/src/db/rebase.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport type {Write as DagWrite} from '../dag/store.ts';\nimport * as FormatVersion from '../format-version-enum.ts';\nimport type {Hash} from '../hash.ts';\nimport type {ZeroTxData} from '../replicache-options.ts';\nimport type {ClientID} from '../sync/ids.ts';\nimport {WriteTransactionImpl} from '../transactions.ts';\nimport type {MutatorDefs} from '../types.ts';\nimport {\n  type Commit,\n  type LocalMeta,\n  type LocalMetaDD31,\n  type Meta,\n  assertLocalMetaDD31,\n  commitFromHash,\n  isLocalMetaDD31,\n} from './commit.ts';\nimport type {Write} from './write.ts';\nimport {newWriteLocal} from './write.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\n/**\n * The result of replaying one mutation.\n *\n * `zeroData` is the Zero transaction data to use for the next mutation in the\n * same replay. Each mutation runs against its own fork. On success that fork is\n * returned, and if the mutator throws the caller gets back the one it passed\n * in, without the failed mutation's IVM writes. See `rebaseMutation`.\n */\nexport type RebaseResult<T> = {\n  result: T;\n  zeroData: ZeroTxData | undefined;\n};\n\nasync function rebaseMutation(\n  mutation: Commit<LocalMetaDD31>,\n  dagWrite: DagWrite,\n  basisHash: Hash,\n  mutators: MutatorDefs,\n  lc: LogContext,\n  mutationClientID: ClientID,\n  formatVersion: FormatVersion,\n  zeroData: ZeroTxData | undefined,\n): Promise<RebaseResult<Write>> {\n  const localMeta = mutation.meta;\n  const name = localMeta.mutatorName;\n  if (isLocalMetaDD31(localMeta)) {\n    assert(\n      localMeta.clientID === mutationClientID,\n      'mutationClientID must match clientID of LocalMeta',\n    );\n  }\n  const maybeMutatorImpl = mutators[name];\n  if (!maybeMutatorImpl) {\n    // Developers must not remove mutator names from code deployed with the\n    // same schemaVersion because Replicache needs to be able to replay\n    // mutations during pull.\n    //\n    // If we detect that this has happened, stub in a no-op mutator so that at\n    // least sync can move forward. Note that the server-side mutation will\n    // still get sent. This doesn't remove the queued local mutation, it just\n    // removes its visible effects.\n    lc.error?.(`Cannot rebase unknown mutator ${name}`);\n  }\n  const mutatorImpl =\n    maybeMutatorImpl ||\n    (async () => {\n      // no op\n    });\n\n  const args = localMeta.mutatorArgsJSON;\n\n  const basisCommit = await commitFromHash(basisHash, dagWrite);\n  const nextMutationID = await basisCommit.getNextMutationID(\n    mutationClientID,\n    dagWrite,\n  );\n  if (nextMutationID !== localMeta.mutationID) {\n    throw new Error(\n      `Inconsistent mutation ID: original: ${localMeta.mutationID}, next: ${nextMutationID} - mutationClientID: ${mutationClientID} mutatorName: ${name}`,\n    );\n  }\n\n  if (formatVersion >= FormatVersion.DD31) {\n    assertLocalMetaDD31(localMeta);\n  }\n\n  const newWrite = () =>\n    newWriteLocal(\n      basisHash,\n      name,\n      args,\n      mutation.chunk.hash,\n      dagWrite,\n      localMeta.timestamp,\n      mutationClientID,\n      formatVersion,\n    );\n\n  const dbWrite = await newWrite();\n\n  // Run the mutator against a fork so that if it throws, its IVM writes are\n  // discarded along with its `Write`.\n  const txData = zeroData?.fork();\n\n  const tx = new WriteTransactionImpl(\n    mutationClientID,\n    await dbWrite.getMutationID(),\n    'rebase',\n    txData,\n    dbWrite,\n    lc,\n  );\n\n  try {\n    await mutatorImpl(tx, args);\n  } catch (e) {\n    // A mutator can throw here without anything being wrong: it is being run\n    // again against a newer server snapshot, so a check that passed when the\n    // user first ran it can fail now. Rethrowing fails the whole rebase, which\n    // in Zero fails the poke and disconnects the client. The mutation stays\n    // pending, so the next poke fails the same way.\n    //\n    // Only the local prediction is dropped. The mutation is still pending and\n    // is still sent to the server, which decides whether it applied.\n    //\n    // `dbWrite` is dropped rather than closed: it shares `dagWrite` with the\n    // caller. Dropping it is enough because a `Write` does not modify anything\n    // outside itself and only writes chunks when it is committed.\n    //\n    // Engine errors raised inside the mutator are retired the same way, rather\n    // than being sorted out here. A client whose state was garbage collected\n    // throws ChunkNotFoundError from its reads, and that is detected on its\n    // next mutation, where replicache-impl converts it to a\n    // ClientStateNotFoundError and calls onClientStateNotFound.\n    lc.info?.(`Rebase of mutator ${name} threw, abandoning its prediction`, e);\n    return {result: await newWrite(), zeroData};\n  }\n\n  return {result: dbWrite, zeroData: txData};\n}\n\nexport async function rebaseMutationAndPutCommit(\n  mutation: Commit<LocalMeta>,\n  dagWrite: DagWrite,\n  basis: Hash,\n  mutators: MutatorDefs,\n  lc: LogContext,\n  // TODO(greg): mutationClientID can be retrieved from mutation if LocalMeta\n  // is a LocalMetaDD31.  As part of DD31 cleanup we can remove this arg.\n  mutationClientID: ClientID,\n  formatVersion: FormatVersion,\n  zeroData: ZeroTxData | undefined,\n): Promise<RebaseResult<Commit<Meta>>> {\n  const {result: tx, zeroData: next} = await rebaseMutation(\n    mutation,\n    dagWrite,\n    basis,\n    mutators,\n    lc,\n    mutationClientID,\n    formatVersion,\n    zeroData,\n  );\n  return {result: await tx.putCommit(), zeroData: next};\n}\n\nexport async function rebaseMutationAndCommit(\n  mutation: Commit<LocalMeta>,\n  dagWrite: DagWrite,\n  basis: Hash,\n  headName: string,\n  mutators: MutatorDefs,\n  lc: LogContext,\n  // TODO(greg): mutationClientID can be retrieved from mutation if LocalMeta\n  // is a LocalMetaDD31.  As part of DD31 cleanup we can remove this arg.\n  mutationClientID: ClientID,\n  formatVersion: FormatVersion,\n  zeroData: ZeroTxData | undefined,\n): Promise<RebaseResult<Hash>> {\n  const {result: dbWrite, zeroData: next} = await rebaseMutation(\n    mutation,\n    dagWrite,\n    basis,\n    mutators,\n    lc,\n    mutationClientID,\n    formatVersion,\n    zeroData,\n  );\n  return {result: await dbWrite.commit(headName), zeroData: next};\n}\n"],"mappings":";;;;;AAqCA,eAAe,eACb,UACA,UACA,WACA,UACA,IACA,kBACA,eACA,UAC8B;CAC9B,MAAM,YAAY,SAAS;CAC3B,MAAM,OAAO,UAAU;CACvB,IAAI,gBAAgB,SAAS,GAC3B,OACE,UAAU,aAAa,kBACvB,mDACF;CAEF,MAAM,mBAAmB,SAAS;CAClC,IAAI,CAAC,kBASH,GAAG,QAAQ,iCAAiC,MAAM;CAEpD,MAAM,cACJ,qBACC,YAAY,CAEb;CAEF,MAAM,OAAO,UAAU;CAGvB,MAAM,iBAAiB,OAAM,MADH,eAAe,WAAW,QAAQ,GACnB,kBACvC,kBACA,QACF;CACA,IAAI,mBAAmB,UAAU,YAC/B,MAAM,IAAI,MACR,uCAAuC,UAAU,WAAW,UAAU,eAAe,uBAAuB,iBAAiB,gBAAgB,MAC/I;CAGF,IAAI,iBAAiB,GACnB,oBAAoB,SAAS;CAG/B,MAAM,iBACJ,cACE,WACA,MACA,MACA,SAAS,MAAM,MACf,UACA,UAAU,WACV,kBACA,aACF;CAEF,MAAM,UAAU,MAAM,SAAS;CAI/B,MAAM,SAAS,UAAU,KAAK;CAE9B,MAAM,KAAK,IAAI,qBACb,kBACA,MAAM,QAAQ,cAAc,GAC5B,UACA,QACA,SACA,EACF;CAEA,IAAI;EACF,MAAM,YAAY,IAAI,IAAI;CAC5B,SAAS,GAAG;EAmBV,GAAG,OAAO,qBAAqB,KAAK,oCAAoC,CAAC;EACzE,OAAO;GAAC,QAAQ,MAAM,SAAS;GAAG;EAAQ;CAC5C;CAEA,OAAO;EAAC,QAAQ;EAAS,UAAU;CAAM;AAC3C;AAEA,eAAsB,2BACpB,UACA,UACA,OACA,UACA,IAGA,kBACA,eACA,UACqC;CACrC,MAAM,EAAC,QAAQ,IAAI,UAAU,SAAQ,MAAM,eACzC,UACA,UACA,OACA,UACA,IACA,kBACA,eACA,QACF;CACA,OAAO;EAAC,QAAQ,MAAM,GAAG,UAAU;EAAG,UAAU;CAAI;AACtD;AAEA,eAAsB,wBACpB,UACA,UACA,OACA,UACA,UACA,IAGA,kBACA,eACA,UAC6B;CAC7B,MAAM,EAAC,QAAQ,SAAS,UAAU,SAAQ,MAAM,eAC9C,UACA,UACA,OACA,UACA,IACA,kBACA,eACA,QACF;CACA,OAAO;EAAC,QAAQ,MAAM,QAAQ,OAAO,QAAQ;EAAG,UAAU;CAAI;AAChE"}

package/out/replicache/src/db/write.js.map

@@ -1 +1 @@
-{"version":3,"file":"write.js","names":["#dagWrite","#basis","#meta","#clientID","#formatVersion","#generateDiffs"],"sources":["../../../../../replicache/src/db/write.ts"],"sourcesContent":["import '../process-env.ts';\nimport type {LogContext} from '@rocicorp/logger';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport {diff} from '../btree/diff.ts';\nimport type {InternalDiff} from '../btree/node.ts';\nimport {BTreeRead, allEntriesAsDiff} from '../btree/read.ts';\nimport {BTreeWrite} from '../btree/write.ts';\nimport type {FrozenCookie} from '../cookies.ts';\nimport type {Write as DagWrite} from '../dag/store.ts';\nimport * as FormatVersion from '../format-version-enum.ts';\nimport type {FrozenJSONValue} from '../frozen-json.ts';\nimport {type Hash, emptyHash} from '../hash.ts';\nimport type {DiffComputationConfig} from '../sync/diff.ts';\nimport {DiffsMap} from '../sync/diff.ts';\nimport type {ClientID} from '../sync/ids.ts';\nimport type {Commit} from './commit.ts';\nimport {\n  type Meta as CommitMeta,\n  type IndexRecord,\n  type Meta,\n  baseSnapshotHashFromHash,\n  commitFromHash,\n  newLocalDD31 as commitNewLocalDD31,\n  newSnapshotDD31 as commitNewSnapshotDD31,\n  getMutationID,\n} from './commit.ts';\nimport * as IndexOperation from './index-operation-enum.ts';\nimport type {IndexRead} from './index.ts';\nimport {IndexWrite, indexValue} from './index.ts';\nimport * as MetaType from './meta-type-enum.ts';\nimport {Read, readIndexesForRead} from './read.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\nexport class Write extends Read {\n  readonly #dagWrite: DagWrite;\n  readonly #basis: Commit<CommitMeta> | undefined;\n  readonly #meta: CommitMeta;\n\n  declare map: BTreeWrite;\n\n  declare readonly indexes: Map<string, IndexWrite>;\n  readonly #clientID: ClientID;\n  readonly #formatVersion: FormatVersion;\n\n  constructor(\n    dagWrite: DagWrite,\n    map: BTreeWrite,\n    basis: Commit<CommitMeta> | undefined,\n    meta: CommitMeta,\n    indexes: Map<string, IndexWrite>,\n    clientID: ClientID,\n    formatVersion: FormatVersion,\n  ) {\n    // TypeScript has trouble\n    super(dagWrite, map, indexes);\n    this.#dagWrite = dagWrite;\n    this.#basis = basis;\n    this.#meta = meta;\n    this.#clientID = clientID;\n    this.#formatVersion = formatVersion;\n\n    // TODO(arv): if (DEBUG) { ...\n    if (basis === undefined) {\n      assert(\n        meta.basisHash === emptyHash,\n        'Expected basisHash to be emptyHash when basis is undefined',\n      );\n    } else {\n      assert(\n        meta.basisHash === basis.chunk.hash,\n        'Expected meta.basisHash to equal basis.chunk.hash',\n      );\n    }\n  }\n\n  /**\n   * The value needs to be frozen since it is kept in memory and used later for\n   * comparison as well as returned in `get`.\n   */\n  async put(\n    lc: LogContext,\n    key: string,\n    value: FrozenJSONValue,\n  ): Promise<void> {\n    if (!process.env.DISABLE_REPLICACHE_INDEXES && this.indexes.size > 0) {\n      await updateIndexes(lc, this.map, this.indexes, key, value);\n    }\n    await this.map.put(key, value);\n  }\n\n  /**\n   * Inserts or updates multiple entries in a single bulk operation. More\n   * efficient than calling {@link put} in a loop because it uses\n   * {@link BTreeWrite.putMany} to build or merge tree nodes in one pass.\n   *\n   * `entries` must be sorted in ascending key order.\n   */\n  async putMany(\n    lc: LogContext,\n    entries: ReadonlyArray<readonly [string, FrozenJSONValue]>,\n  ): Promise<void> {\n    if (entries.length === 0) {\n      return;\n    }\n\n    // Update indexes for all entries\n    if (!process.env.DISABLE_REPLICACHE_INDEXES && this.indexes.size > 0) {\n      // TODO(arv): Indexes can use the optimizePatch pattern too.\n      for (const [key, value] of entries) {\n        await updateIndexes(lc, this.map, this.indexes, key, value);\n      }\n    }\n\n    // BTreeWrite.putMany handles both empty and non-empty trees optimally\n    await this.map.putMany(entries);\n  }\n\n  getMutationID(): Promise<number> {\n    return getMutationID(this.#clientID, this.#dagWrite, this.#meta);\n  }\n\n  async del(lc: LogContext, key: string): Promise<boolean> {\n    if (!process.env.DISABLE_REPLICACHE_INDEXES && this.indexes.size > 0) {\n      await updateIndexes(lc, this.map, this.indexes, key, undefined);\n    }\n    return this.map.del(key);\n  }\n\n  async clear(): Promise<void> {\n    await this.map.clear();\n    const ps = [];\n    for (const idx of this.indexes.values()) {\n      ps.push(idx.clear());\n    }\n    await Promise.all(ps);\n  }\n\n  async putCommit(): Promise<Commit<CommitMeta>> {\n    const valueHash = await this.map.flush();\n    const indexRecords: IndexRecord[] = [];\n\n    for (const index of this.indexes.values()) {\n      const valueHash = await index.flush();\n      const indexRecord: IndexRecord = {\n        definition: index.meta.definition,\n        valueHash,\n      };\n      indexRecords.push(indexRecord);\n    }\n\n    let commit: Commit<Meta>;\n    const meta = this.#meta;\n    switch (meta.type) {\n      case MetaType.LocalDD31: {\n        assert(\n          this.#formatVersion >= FormatVersion.DD31,\n          'Expected formatVersion >= DD31 for LocalDD31 commit',\n        );\n        const {\n          basisHash,\n          mutationID,\n          mutatorName,\n          mutatorArgsJSON,\n          originalHash,\n          timestamp,\n        } = meta;\n        commit = commitNewLocalDD31(\n          this.#dagWrite.createChunk,\n          basisHash,\n          await baseSnapshotHashFromHash(basisHash, this.#dagWrite),\n          mutationID,\n          mutatorName,\n          mutatorArgsJSON,\n          originalHash,\n          valueHash,\n          indexRecords,\n          timestamp,\n          this.#clientID,\n        );\n        break;\n      }\n\n      case MetaType.SnapshotDD31: {\n        assert(\n          this.#formatVersion > FormatVersion.DD31,\n          'Expected formatVersion > DD31 for SnapshotDD31 commit',\n        );\n        const {basisHash, lastMutationIDs, cookieJSON} = meta;\n        commit = commitNewSnapshotDD31(\n          this.#dagWrite.createChunk,\n          basisHash,\n          lastMutationIDs,\n          cookieJSON,\n          valueHash,\n          indexRecords,\n        );\n        break;\n      }\n    }\n    await this.#dagWrite.putChunk(commit.chunk);\n    return commit;\n  }\n\n  // Return value is the hash of the new commit.\n  async commit(headName: string): Promise<Hash> {\n    const commit = await this.putCommit();\n    const commitHash = commit.chunk.hash;\n    await this.#dagWrite.setHead(headName, commitHash);\n    await this.#dagWrite.commit();\n    return commitHash;\n  }\n\n  async commitWithDiffs(\n    headName: string,\n    diffConfig: DiffComputationConfig,\n  ): Promise<[Hash, DiffsMap]> {\n    const commit = this.putCommit();\n    const diffMap = await this.#generateDiffs(diffConfig);\n    const commitHash = (await commit).chunk.hash;\n    await this.#dagWrite.setHead(headName, commitHash);\n    await this.#dagWrite.commit();\n    return [commitHash, diffMap];\n  }\n\n  async #generateDiffs(diffConfig: DiffComputationConfig): Promise<DiffsMap> {\n    const diffsMap = new DiffsMap();\n    if (!diffConfig.shouldComputeDiffs()) {\n      return diffsMap;\n    }\n\n    let valueDiff: InternalDiff = [];\n    if (this.#basis) {\n      const basisMap = new BTreeRead(\n        this.#dagWrite,\n        this.#formatVersion,\n        this.#basis.valueHash,\n      );\n      valueDiff = await diff(basisMap, this.map);\n    }\n    diffsMap.set('', valueDiff);\n    if (process.env.DISABLE_REPLICACHE_INDEXES) {\n      return diffsMap;\n    }\n    let basisIndexes: Map<string, IndexRead>;\n    if (this.#basis) {\n      basisIndexes = readIndexesForRead(\n        this.#basis,\n        this.#dagWrite,\n        this.#formatVersion,\n      );\n    } else {\n      basisIndexes = new Map();\n    }\n\n    for (const [name, index] of this.indexes) {\n      if (!diffConfig.shouldComputeDiffsForIndex(name)) {\n        continue;\n      }\n      const basisIndex = basisIndexes.get(name);\n      assert(index !== basisIndex, 'Expected index to differ from basisIndex');\n\n      const indexDiffResult = await (basisIndex\n        ? diff(basisIndex.map, index.map)\n        : // No basis. All keys are new.\n          allEntriesAsDiff(index.map, 'add'));\n      diffsMap.set(name, indexDiffResult);\n    }\n\n    // Handle indexes in basisIndex but not in this.indexes. All keys are\n    // deleted.\n    for (const [name, basisIndex] of basisIndexes) {\n      if (\n        !this.indexes.has(name) &&\n        diffConfig.shouldComputeDiffsForIndex(name)\n      ) {\n        const indexDiffResult = await allEntriesAsDiff(basisIndex.map, 'del');\n        diffsMap.set(name, indexDiffResult);\n      }\n    }\n    return diffsMap;\n  }\n\n  close(): void {\n    this.#dagWrite.release();\n  }\n}\n\nexport async function newWriteLocal(\n  basisHash: Hash,\n  mutatorName: string,\n  mutatorArgsJSON: FrozenJSONValue,\n  originalHash: Hash | null,\n  dagWrite: DagWrite,\n  timestamp: number,\n  clientID: ClientID,\n  formatVersion: FormatVersion,\n): Promise<Write> {\n  const basis = await commitFromHash(basisHash, dagWrite);\n  const bTreeWrite = new BTreeWrite(dagWrite, formatVersion, basis.valueHash);\n  const mutationID = await basis.getNextMutationID(clientID, dagWrite);\n  const indexes = readIndexesForWrite(basis, dagWrite, formatVersion);\n  assert(\n    formatVersion >= FormatVersion.DD31,\n    'Expected formatVersion >= DD31 for newWriteLocal',\n  );\n  return new Write(\n    dagWrite,\n    bTreeWrite,\n    basis,\n\n    {\n      type: MetaType.LocalDD31,\n      basisHash,\n      baseSnapshotHash: await baseSnapshotHashFromHash(basisHash, dagWrite),\n      mutatorName,\n      mutatorArgsJSON,\n      mutationID,\n      originalHash,\n      timestamp,\n      clientID,\n    },\n    indexes,\n    clientID,\n    formatVersion,\n  );\n}\n\nexport async function newWriteSnapshotDD31(\n  basisHash: Hash,\n  lastMutationIDs: Record<ClientID, number>,\n  cookieJSON: FrozenCookie,\n  dagWrite: DagWrite,\n  clientID: ClientID,\n  formatVersion: FormatVersion,\n): Promise<Write> {\n  const basis = await commitFromHash(basisHash, dagWrite);\n  const bTreeWrite = new BTreeWrite(dagWrite, formatVersion, basis.valueHash);\n  return new Write(\n    dagWrite,\n    bTreeWrite,\n    basis,\n    {basisHash, type: MetaType.SnapshotDD31, lastMutationIDs, cookieJSON},\n    readIndexesForWrite(basis, dagWrite, formatVersion),\n    clientID,\n    formatVersion,\n  );\n}\n\nexport async function updateIndexes(\n  lc: LogContext,\n  map: BTreeRead,\n  indexes: Map<string, IndexWrite>,\n  key: string,\n  newVal: FrozenJSONValue | undefined,\n): Promise<void> {\n  let oldValPromise: Promise<FrozenJSONValue | undefined> | undefined;\n\n  const ps: Promise<void>[] = [];\n  for (const idx of indexes.values()) {\n    const {keyPrefix} = idx.meta.definition;\n    if (!keyPrefix || key.startsWith(keyPrefix)) {\n      const oldVal = await (oldValPromise ??= map.get(key));\n      if (oldVal !== undefined) {\n        ps.push(\n          indexValue(\n            lc,\n            idx.map,\n            IndexOperation.Remove,\n            key,\n            oldVal,\n            idx.meta.definition.jsonPointer,\n            idx.meta.definition.allowEmpty ?? false,\n          ),\n        );\n      }\n      if (newVal !== undefined) {\n        ps.push(\n          indexValue(\n            lc,\n            idx.map,\n            IndexOperation.Add,\n            key,\n            newVal,\n            idx.meta.definition.jsonPointer,\n            idx.meta.definition.allowEmpty ?? false,\n          ),\n        );\n      }\n    }\n  }\n  await Promise.all(ps);\n}\n\nexport function readIndexesForWrite(\n  commit: Commit<CommitMeta>,\n  dagWrite: DagWrite,\n  formatVersion: FormatVersion,\n): Map<string, IndexWrite> {\n  const m: Map<string, IndexWrite> = new Map();\n  if (process.env.DISABLE_REPLICACHE_INDEXES) {\n    return m;\n  }\n  for (const index of commit.indexes) {\n    m.set(\n      index.definition.name,\n      new IndexWrite(\n        index,\n        new BTreeWrite(dagWrite, formatVersion, index.valueHash),\n      ),\n    );\n  }\n  return m;\n}\n\nexport async function createIndexBTree(\n  lc: LogContext,\n  dagWrite: DagWrite,\n  valueMap: BTreeRead,\n  prefix: string,\n  jsonPointer: string,\n  allowEmpty: boolean,\n  formatVersion: FormatVersion,\n): Promise<BTreeWrite> {\n  const indexMap = new BTreeWrite(dagWrite, formatVersion);\n  for await (const entry of valueMap.scan(prefix)) {\n    const key = entry[0];\n    if (!key.startsWith(prefix)) {\n      break;\n    }\n    await indexValue(\n      lc,\n      indexMap,\n      IndexOperation.Add,\n      key,\n      entry[1],\n      jsonPointer,\n      allowEmpty,\n    );\n  }\n  return indexMap;\n}\n"],"mappings":"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"}
+{"version":3,"file":"write.js","names":["#dagWrite","#basis","#meta","#clientID","#formatVersion","#generateDiffs"],"sources":["../../../../../replicache/src/db/write.ts"],"sourcesContent":["import '../process-env.ts';\nimport type {LogContext} from '@rocicorp/logger';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport {diff} from '../btree/diff.ts';\nimport type {InternalDiff} from '../btree/node.ts';\nimport {BTreeRead, allEntriesAsDiff} from '../btree/read.ts';\nimport {BTreeWrite} from '../btree/write.ts';\nimport type {FrozenCookie} from '../cookies.ts';\nimport type {Write as DagWrite} from '../dag/store.ts';\nimport * as FormatVersion from '../format-version-enum.ts';\nimport type {FrozenJSONValue} from '../frozen-json.ts';\nimport {type Hash, emptyHash} from '../hash.ts';\nimport type {DiffComputationConfig} from '../sync/diff.ts';\nimport {DiffsMap} from '../sync/diff.ts';\nimport type {ClientID} from '../sync/ids.ts';\nimport type {Commit} from './commit.ts';\nimport {\n  type Meta as CommitMeta,\n  type IndexRecord,\n  type Meta,\n  baseSnapshotHashFromHash,\n  commitFromHash,\n  newLocalDD31 as commitNewLocalDD31,\n  newSnapshotDD31 as commitNewSnapshotDD31,\n  getMutationID,\n} from './commit.ts';\nimport * as IndexOperation from './index-operation-enum.ts';\nimport type {IndexRead} from './index.ts';\nimport {IndexWrite, indexValue} from './index.ts';\nimport * as MetaType from './meta-type-enum.ts';\nimport {Read, readIndexesForRead} from './read.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\nexport class Write extends Read {\n  readonly #dagWrite: DagWrite;\n  readonly #basis: Commit<CommitMeta> | undefined;\n  readonly #meta: CommitMeta;\n\n  declare map: BTreeWrite;\n\n  declare readonly indexes: Map<string, IndexWrite>;\n  readonly #clientID: ClientID;\n  readonly #formatVersion: FormatVersion;\n\n  constructor(\n    dagWrite: DagWrite,\n    map: BTreeWrite,\n    basis: Commit<CommitMeta> | undefined,\n    meta: CommitMeta,\n    indexes: Map<string, IndexWrite>,\n    clientID: ClientID,\n    formatVersion: FormatVersion,\n  ) {\n    // TypeScript has trouble\n    super(dagWrite, map, indexes);\n    this.#dagWrite = dagWrite;\n    this.#basis = basis;\n    this.#meta = meta;\n    this.#clientID = clientID;\n    this.#formatVersion = formatVersion;\n\n    // TODO(arv): if (DEBUG) { ...\n    if (basis === undefined) {\n      assert(\n        meta.basisHash === emptyHash,\n        'Expected basisHash to be emptyHash when basis is undefined',\n      );\n    } else {\n      assert(\n        meta.basisHash === basis.chunk.hash,\n        'Expected meta.basisHash to equal basis.chunk.hash',\n      );\n    }\n  }\n\n  /**\n   * The value needs to be frozen since it is kept in memory and used later for\n   * comparison as well as returned in `get`.\n   */\n  async put(\n    lc: LogContext,\n    key: string,\n    value: FrozenJSONValue,\n  ): Promise<void> {\n    if (!process.env.DISABLE_REPLICACHE_INDEXES && this.indexes.size > 0) {\n      await updateIndexes(lc, this.map, this.indexes, key, value);\n    }\n    await this.map.put(key, value);\n  }\n\n  /**\n   * Inserts or updates multiple entries in a single bulk operation. More\n   * efficient than calling {@link put} in a loop because it uses\n   * {@link BTreeWrite.putMany} to build or merge tree nodes in one pass.\n   *\n   * `entries` must be sorted in ascending key order.\n   */\n  async putMany(\n    lc: LogContext,\n    entries: ReadonlyArray<readonly [string, FrozenJSONValue]>,\n  ): Promise<void> {\n    if (entries.length === 0) {\n      return;\n    }\n\n    // Update indexes for all entries\n    if (!process.env.DISABLE_REPLICACHE_INDEXES && this.indexes.size > 0) {\n      // TODO(arv): Indexes can use the optimizePatch pattern too.\n      for (const [key, value] of entries) {\n        await updateIndexes(lc, this.map, this.indexes, key, value);\n      }\n    }\n\n    // BTreeWrite.putMany handles both empty and non-empty trees optimally\n    await this.map.putMany(entries);\n  }\n\n  getMutationID(): Promise<number> {\n    return getMutationID(this.#clientID, this.#dagWrite, this.#meta);\n  }\n\n  async del(lc: LogContext, key: string): Promise<boolean> {\n    if (!process.env.DISABLE_REPLICACHE_INDEXES && this.indexes.size > 0) {\n      await updateIndexes(lc, this.map, this.indexes, key, undefined);\n    }\n    return this.map.del(key);\n  }\n\n  async clear(): Promise<void> {\n    await this.map.clear();\n    const ps = [];\n    for (const idx of this.indexes.values()) {\n      ps.push(idx.clear());\n    }\n    await Promise.all(ps);\n  }\n\n  async putCommit(): Promise<Commit<CommitMeta>> {\n    const valueHash = await this.map.flush();\n    const indexRecords: IndexRecord[] = [];\n\n    for (const index of this.indexes.values()) {\n      const valueHash = await index.flush();\n      const indexRecord: IndexRecord = {\n        definition: index.meta.definition,\n        valueHash,\n      };\n      indexRecords.push(indexRecord);\n    }\n\n    let commit: Commit<Meta>;\n    const meta = this.#meta;\n    switch (meta.type) {\n      case MetaType.LocalDD31: {\n        assert(\n          this.#formatVersion >= FormatVersion.DD31,\n          'Expected formatVersion >= DD31 for LocalDD31 commit',\n        );\n        const {\n          basisHash,\n          mutationID,\n          mutatorName,\n          mutatorArgsJSON,\n          originalHash,\n          timestamp,\n        } = meta;\n        commit = commitNewLocalDD31(\n          this.#dagWrite.createChunk,\n          basisHash,\n          await baseSnapshotHashFromHash(basisHash, this.#dagWrite),\n          mutationID,\n          mutatorName,\n          mutatorArgsJSON,\n          originalHash,\n          valueHash,\n          indexRecords,\n          timestamp,\n          this.#clientID,\n        );\n        break;\n      }\n\n      case MetaType.SnapshotDD31: {\n        assert(\n          this.#formatVersion > FormatVersion.DD31,\n          'Expected formatVersion > DD31 for SnapshotDD31 commit',\n        );\n        const {basisHash, lastMutationIDs, cookieJSON} = meta;\n        commit = commitNewSnapshotDD31(\n          this.#dagWrite.createChunk,\n          basisHash,\n          lastMutationIDs,\n          cookieJSON,\n          valueHash,\n          indexRecords,\n        );\n        break;\n      }\n    }\n    await this.#dagWrite.putChunk(commit.chunk);\n    return commit;\n  }\n\n  // Return value is the hash of the new commit.\n  async commit(headName: string): Promise<Hash> {\n    const commit = await this.putCommit();\n    const commitHash = commit.chunk.hash;\n    await this.#dagWrite.setHead(headName, commitHash);\n    await this.#dagWrite.commit();\n    return commitHash;\n  }\n\n  async commitWithDiffs(\n    headName: string,\n    diffConfig: DiffComputationConfig,\n  ): Promise<[Hash, DiffsMap]> {\n    const commit = this.putCommit();\n    const diffMap = await this.#generateDiffs(diffConfig);\n    const commitHash = (await commit).chunk.hash;\n    await this.#dagWrite.setHead(headName, commitHash);\n    await this.#dagWrite.commit();\n    return [commitHash, diffMap];\n  }\n\n  async #generateDiffs(diffConfig: DiffComputationConfig): Promise<DiffsMap> {\n    const diffsMap = new DiffsMap();\n    if (!diffConfig.shouldComputeDiffs()) {\n      return diffsMap;\n    }\n\n    let valueDiff: InternalDiff = [];\n    if (this.#basis) {\n      const basisMap = new BTreeRead(\n        this.#dagWrite,\n        this.#formatVersion,\n        this.#basis.valueHash,\n      );\n      valueDiff = await diff(basisMap, this.map);\n    }\n    diffsMap.set('', valueDiff);\n    if (process.env.DISABLE_REPLICACHE_INDEXES) {\n      return diffsMap;\n    }\n    let basisIndexes: Map<string, IndexRead>;\n    if (this.#basis) {\n      basisIndexes = readIndexesForRead(\n        this.#basis,\n        this.#dagWrite,\n        this.#formatVersion,\n      );\n    } else {\n      basisIndexes = new Map();\n    }\n\n    for (const [name, index] of this.indexes) {\n      if (!diffConfig.shouldComputeDiffsForIndex(name)) {\n        continue;\n      }\n      const basisIndex = basisIndexes.get(name);\n      assert(index !== basisIndex, 'Expected index to differ from basisIndex');\n\n      const indexDiffResult = await (basisIndex\n        ? diff(basisIndex.map, index.map)\n        : // No basis. All keys are new.\n          allEntriesAsDiff(index.map, 'add'));\n      diffsMap.set(name, indexDiffResult);\n    }\n\n    // Handle indexes in basisIndex but not in this.indexes. All keys are\n    // deleted.\n    for (const [name, basisIndex] of basisIndexes) {\n      if (\n        !this.indexes.has(name) &&\n        diffConfig.shouldComputeDiffsForIndex(name)\n      ) {\n        const indexDiffResult = await allEntriesAsDiff(basisIndex.map, 'del');\n        diffsMap.set(name, indexDiffResult);\n      }\n    }\n    return diffsMap;\n  }\n\n  close(): void {\n    this.#dagWrite.release();\n  }\n}\n\nexport async function newWriteLocal(\n  basisHash: Hash,\n  mutatorName: string,\n  mutatorArgsJSON: FrozenJSONValue,\n  originalHash: Hash | null,\n  dagWrite: DagWrite,\n  timestamp: number,\n  clientID: ClientID,\n  formatVersion: FormatVersion,\n): Promise<Write> {\n  const basis = await commitFromHash(basisHash, dagWrite);\n  const bTreeWrite = new BTreeWrite(dagWrite, formatVersion, basis.valueHash);\n  const mutationID = await basis.getNextMutationID(clientID, dagWrite);\n  const indexes = readIndexesForWrite(basis, dagWrite, formatVersion);\n  assert(\n    formatVersion >= FormatVersion.DD31,\n    'Expected formatVersion >= DD31 for newWriteLocal',\n  );\n  return new Write(\n    dagWrite,\n    bTreeWrite,\n    basis,\n\n    {\n      type: MetaType.LocalDD31,\n      basisHash,\n      baseSnapshotHash: await baseSnapshotHashFromHash(basisHash, dagWrite),\n      mutatorName,\n      mutatorArgsJSON,\n      mutationID,\n      originalHash,\n      timestamp,\n      clientID,\n    },\n    indexes,\n    clientID,\n    formatVersion,\n  );\n}\n\nexport async function newWriteSnapshotDD31(\n  basisHash: Hash,\n  lastMutationIDs: Record<ClientID, number>,\n  cookieJSON: FrozenCookie,\n  dagWrite: DagWrite,\n  clientID: ClientID,\n  formatVersion: FormatVersion,\n): Promise<Write> {\n  const basis = await commitFromHash(basisHash, dagWrite);\n  const bTreeWrite = new BTreeWrite(dagWrite, formatVersion, basis.valueHash);\n  return new Write(\n    dagWrite,\n    bTreeWrite,\n    basis,\n    {basisHash, type: MetaType.SnapshotDD31, lastMutationIDs, cookieJSON},\n    readIndexesForWrite(basis, dagWrite, formatVersion),\n    clientID,\n    formatVersion,\n  );\n}\n\nexport async function updateIndexes(\n  lc: LogContext,\n  map: BTreeRead,\n  indexes: Map<string, IndexWrite>,\n  key: string,\n  newVal: FrozenJSONValue | undefined,\n): Promise<void> {\n  let oldValPromise: Promise<FrozenJSONValue | undefined> | undefined;\n\n  const ps: Promise<void>[] = [];\n  for (const idx of indexes.values()) {\n    const {keyPrefix} = idx.meta.definition;\n    if (!keyPrefix || key.startsWith(keyPrefix)) {\n      const oldVal = await (oldValPromise ??= map.get(key));\n      if (oldVal !== undefined) {\n        ps.push(\n          indexValue(\n            lc,\n            idx.map,\n            IndexOperation.Remove,\n            key,\n            oldVal,\n            idx.meta.definition.jsonPointer,\n            idx.meta.definition.allowEmpty ?? false,\n          ),\n        );\n      }\n      if (newVal !== undefined) {\n        ps.push(\n          indexValue(\n            lc,\n            idx.map,\n            IndexOperation.Add,\n            key,\n            newVal,\n            idx.meta.definition.jsonPointer,\n            idx.meta.definition.allowEmpty ?? false,\n          ),\n        );\n      }\n    }\n  }\n  await Promise.all(ps);\n}\n\nexport function readIndexesForWrite(\n  commit: Commit<CommitMeta>,\n  dagWrite: DagWrite,\n  formatVersion: FormatVersion,\n): Map<string, IndexWrite> {\n  const m: Map<string, IndexWrite> = new Map();\n  if (process.env.DISABLE_REPLICACHE_INDEXES) {\n    return m;\n  }\n  for (const index of commit.indexes) {\n    m.set(\n      index.definition.name,\n      new IndexWrite(\n        index,\n        new BTreeWrite(dagWrite, formatVersion, index.valueHash),\n      ),\n    );\n  }\n  return m;\n}\n\nexport async function createIndexBTree(\n  lc: LogContext,\n  dagWrite: DagWrite,\n  valueMap: BTreeRead,\n  prefix: string,\n  jsonPointer: string,\n  allowEmpty: boolean,\n  formatVersion: FormatVersion,\n): Promise<BTreeWrite> {\n  const indexMap = new BTreeWrite(dagWrite, formatVersion);\n  for await (const entry of valueMap.scan(prefix, false)) {\n    const key = entry[0];\n    if (!key.startsWith(prefix)) {\n      break;\n    }\n    await indexValue(\n      lc,\n      indexMap,\n      IndexOperation.Add,\n      key,\n      entry[1],\n      jsonPointer,\n      allowEmpty,\n    );\n  }\n  return indexMap;\n}\n"],"mappings":"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"}

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

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

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

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

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

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

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

@@ -1,14 +1,20 @@
 import type { LogContext } from '@rocicorp/logger';
 import type { Read, Store, Write } from './store.ts';
 /**
- * This store uses an {@link IDBStore} by default. If the {@link IDBStore} fails
- * to open the DB with an exception that matches
- * {@link isFirefoxPrivateBrowsingError} we switch out the implementation to use
- * a {@link MemStore} instead.
+ * This store uses an {@link IDBStore} by default. If `indexedDB.open` rejects
+ * (WebKit's "Unable to open database file on disk" and "Error creating Records
+ * table (13) - database or disk is full", or Firefox private browsing), the
+ * {@link IDBStore} rejects `read()` and `write()` with an {@link IDBOpenError}
+ * and we switch out the implementation to use a {@link MemStore} instead. Any
+ * other error, such as a transaction error on a database that did open, is
+ * rethrown, so a store that has data is never swapped for an empty one behind
+ * the caller's back. Every caller whose call failed with the open error retries
+ * on the memory store, so concurrent first calls all succeed and the switch is
+ * logged once.
  *
  * The reason this is relatively complicated is that when {@link IDBStore} is
  * created, it calls `openDatabase` synchronously, but that returns a `Promise`
- * that will reject in the case of Firefox private browsing. We don't await this
+ * that will reject if the database cannot be opened. We don't await this
  * promise until we call `read` or `write` so we cannot do the switch until
  * then.
  */
@@ -19,6 +25,10 @@ export declare class IDBStoreWithMemFallback implements Store {
     write(): Promise<Write>;
     close(): Promise<void>;
     get closed(): boolean;
+    /**
+     * `'idb'` until an open failure switches this store to memory, then `'mem'`.
+     */
+    get kind(): string | undefined;
 }
 export declare function newIDBStoreWithMemFallback(lc: LogContext, name: string): Store;
 export declare function dropIDBStoreWithMemFallback(name: string): Promise<void>;

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

@@ -1 +1 @@
-{"version":3,"file":"idb-store-with-mem-fallback.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/kv/idb-store-with-mem-fallback.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAKjD,OAAO,KAAK,EAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAC,MAAM,YAAY,CAAC;AAEnD;;;;;;;;;;;GAWG;AAEH,qBAAa,uBAAwB,YAAW,KAAK;;IAInD,YAAY,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAIvC;IAED,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAEpB;IAED,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC,CAEtB;IAuBD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAErB;IAED,IAAI,MAAM,IAAI,OAAO,CAEpB;CACF;AAgBD,wBAAgB,0BAA0B,CACxC,EAAE,EAAE,UAAU,EACd,IAAI,EAAE,MAAM,GACX,KAAK,CAKP;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAYvE"}
+{"version":3,"file":"idb-store-with-mem-fallback.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/kv/idb-store-with-mem-fallback.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAGjD,OAAO,KAAK,EAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAC,MAAM,YAAY,CAAC;AAEnD;;;;;;;;;;;;;;;;;GAiBG;AAEH,qBAAa,uBAAwB,YAAW,KAAK;;IAInD,YAAY,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAIvC;IAED,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAEpB;IAED,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC,CAEtB;IAwBD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAErB;IAED,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,GAAG,SAAS,CAE7B;CACF;AAED,wBAAgB,0BAA0B,CACxC,EAAE,EAAE,UAAU,EACd,IAAI,EAAE,MAAM,GACX,KAAK,CAEP;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAOvE"}