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

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

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-store.js","names":["#rwLock","#heads","#sourceStore","#chunkHasher","#assertValidHash","#release","#sourceReadOwnedByCaller","#sourceRead","#closed","#refCounts","#refs","#createdChunks","#setHead","#cacheSizeLimit","#getSizeOfChunk","#suspendedDeletes","#cacheChunk","#ensureCacheSizeLimit","#evictsAndDeletesSuspended","#size","#evict","#deleteEntryByHash"],"sources":["../../../../../replicache/src/dag/lazy-store.ts"],"sourcesContent":["import {RWLock} from '@rocicorp/lock';\nimport {joinIterables} from '../../../shared/src/iterables.ts';\nimport {promiseVoid} from '../../../shared/src/resolved-promises.ts';\nimport {getSizeOfValue} from '../../../shared/src/size-of-value.ts';\nimport type {MaybePromise} from '../../../shared/src/types.ts';\nimport type {Hash} from '../hash.ts';\nimport type {Chunk} from './chunk.ts';\nimport {type ChunkHasher, type Refs, createChunk} from './chunk.ts';\nimport {\n  type HeadChange,\n  type RefCountUpdatesDelegate,\n  computeRefCountUpdates,\n} from './gc.ts';\nimport {type Read, type Store, type Write, mustGetChunk} from './store.ts';\n\n/**\n * Dag Store which lazily loads values from a source store and then caches\n * them in an LRU cache.  The memory cache for chunks from the source store\n * size is limited to `sourceCacheSizeLimit` bytes, and values are evicted in an\n * LRU fashion.  The purpose of this store is to avoid holding the entire client\n * view (i.e. the source store's content) in each tab's JavaScript heap.\n *\n * This store's heads are independent from the heads of source store, and are\n * only stored in memory.\n *\n * Chunks which are created via this store's {@link Write} transaction's\n * {@link createChunk} method are assumed to not be persisted to the source\n * store and thus are cached separately from the source store chunks.  These\n * memory-only chunks will not be evicted, and their sizes are not counted\n * towards the source chunk cache size.  A memory-only chunk will be deleted if\n * it is no longer reachable from one of this store's heads.\n *\n * Writes only manipulate the in memory state of this store and do not alter the\n * source store.  Thus values must be written to the source store through a\n * separate process (see {@link persist}).\n *\n * Intended use:\n * 1. source store is the 'perdag', a slower persistent store (i.e.\n *    dag.StoreImpl using a kv.IDBStore)\n * 2. this store's 'main' head is initialized to the hash of a chunk containing\n *    a commit in the source store\n * 3. reads lazily read chunks from the source store and cache them\n * 3. writes are initially made to this store with memory-only chunks\n * 4. writes are asynchronously persisted to the source store through a separate\n *    process (see {@link persist}}. This process gathers memory-only chunks\n *    from this store and then writes them to the source store.  It then informs\n *    this store that these chunks are no longer memory-only by calling\n *    {@link chunksPersisted}, which move these chunks\n *    to this store's LRU cache of source chunks (making them eligible for\n *    eviction).\n *\n * @param sourceStore Store to lazy load and cache values from.\n * @param sourceCacheSizeLimit Size limit in bytes for cache of chunks loaded\n * from `sourceStore`.  This size of a value is determined using\n * `getSizeOfValue`.  Keys do not count towards cache size.  Memory-only chunks\n * do not count towards cache size.\n * @param getSizeOfValue Function for measuring the size in bytes of a value.\n */\nexport class LazyStore implements Store {\n  /**\n   * This lock is used to ensure correct isolation of Reads and Writes.\n   * Multiple Reads are allowed in parallel but only a single Write.  Reads and\n   * Writes see an isolated view of the store (corresponding to the Serializable\n   * level of transaction isolation defined in the SQL standard).\n   *\n   * To ensure these semantics the read lock must be acquired when a Read is\n   * created and held til it is closed, and a Write lock must be acquired when a\n   * Write is created and held til it is committed or closed.\n   *\n   * Code must have a read or write lock to\n   * - read `_heads`\n   * - read `_memOnlyChunks`\n   * - read `_sourceStore`\n   * - read and write `_sourceChunksCache`\n   * - read and write `_refCounts`\n   * - read and write `_refs`\n   * and must have a write lock to\n   * - write `_heads`\n   * - write `_memOnlyChunks`\n   */\n  readonly #rwLock = new RWLock();\n  readonly #heads = new Map<string, Hash>();\n  readonly #sourceStore: Store;\n  readonly #chunkHasher: ChunkHasher;\n  readonly #assertValidHash: (hash: Hash) => void;\n\n  /** The following are protected so testing subclass can access. */\n  protected readonly _memOnlyChunks = new Map<Hash, Chunk>();\n  protected readonly _sourceChunksCache: ChunksCache;\n  /**\n   * Ref counts are maintained so that chunks which are unreachable\n   * from this stores heads can be eagerly and deterministically deleted from\n   * `this._memOnlyChunks` and `this._sourceChunksCache`.\n   *\n   * These ref counts are independent from `this._sourceStore`'s ref counts.\n   * These ref counts are based on reachability from `this._heads`.\n   * A chunk is deleted from `this._memOnlyChunks` or\n   * `this._sourceChunksCache` (which ever it is in) when its ref count becomes\n   * zero.\n   * These ref counts count the refs in `this._heads` and `this._refs`.\n   *\n   * Not all reachable chunk's refs are included in `this._refs`, because this\n   * would require loading all chunks reachable in the source store in a\n   * non-lazy manner. `this._refs` contains the refs of all currently reachable\n   * chunks that were ever in `this._memOnlyChunks` or\n   * `this._sourceChunksCache` (even if they have been evicted).  A\n   * chunk's ref information is lazily discovered and stored in `this._refs` and\n   * counted in `this._refCounts`. A chunk's entries in `this._refs` and\n   * `this._refCounts` are only deleted when a chunk is deleted due to it\n   * becoming unreachable (it is not deleted if the chunk is evicted from the\n   * source-store cache).\n   *\n   * The major implication of this lazy discovery of source store refs, is that\n   * a reachable source store chunk may not be cached when loaded, because it is\n   * not known to be reachable because some of the pertinent refs have not been\n   * discovered.  However, in practice chunks are read by traversing the graph\n   * starting from a head, and all pertinent refs are discovered as part of the\n   * traversal.\n   *\n   * These ref counts can be changed in two ways:\n   * 1. A LazyRead has a cache miss and loads a chunk from the source store that\n   * is reachable from this._heads.  If this chunk's refs are not currently\n   * counted, it will not have an entry in `this._refs`.  In this case, the\n   * chunks refs will be put in `this._refs` and `this._refCounts` will be\n   * updated to count them.\n   * 2. A LazyWrite commit updates a head (which can result in increasing or\n   * decreasing ref count) or puts a reachable chunk (either a `memory-only` or\n   * `source` chunk) that references this hash (increasing ref count).  The\n   * computation of these ref count changes is delegated to the\n   * `computeRefCountUpdates` shared with dag.StoreImpl.  In order to\n   * delegate determining reachability to `computeRefCountUpdates` and defer\n   * this determination until commit time, LazyWrite treats cache misses\n   * as a 'put' of the lazily-loaded chunk.\n   *\n   * A chunk's hash may have an entry in `this._refCounts` without that\n   * chunk have ever been in `this._memOnlyChunks` or `this._sourceChunksCache`.\n   * This is the case when a head or a reachable chunk that was ever in\n   * `this._memOnlyChunks` or `this._sourceChunksCache` references a chunk\n   * which is not currently cached (either because it has not been read, or\n   * because it has been evicted).\n   */\n  protected readonly _refCounts = new Map<Hash, number>();\n  protected readonly _refs = new Map<Hash, readonly Hash[]>();\n\n  constructor(\n    sourceStore: Store,\n    sourceCacheSizeLimit: number,\n    chunkHasher: ChunkHasher,\n    assertValidHash: (hash: Hash) => void,\n    getSizeOfChunk: (chunk: Chunk) => number = getSizeOfValue,\n  ) {\n    this._sourceChunksCache = new ChunksCache(\n      sourceCacheSizeLimit,\n      getSizeOfChunk,\n      this._refCounts,\n      this._refs,\n    );\n    this.#sourceStore = sourceStore;\n    this.#chunkHasher = chunkHasher;\n    this.#assertValidHash = assertValidHash;\n  }\n\n  async read(sourceRead?: Read): Promise<LazyRead> {\n    const release = await this.#rwLock.read();\n    return new LazyRead(\n      this.#heads,\n      this._memOnlyChunks,\n      this._sourceChunksCache,\n      this.#sourceStore,\n      release,\n      this.#assertValidHash,\n      sourceRead,\n    );\n  }\n\n  async write(): Promise<LazyWrite> {\n    const release = await this.#rwLock.write();\n    return new LazyWrite(\n      this.#heads,\n      this._memOnlyChunks,\n      this._sourceChunksCache,\n      this.#sourceStore,\n      this._refCounts,\n      this._refs,\n      release,\n      this.#chunkHasher,\n      this.#assertValidHash,\n    );\n  }\n\n  close(): Promise<void> {\n    return promiseVoid;\n  }\n\n  /**\n   * Does not acquire any lock on the store.\n   */\n  isCached(chunkHash: Hash): boolean {\n    return (\n      this._sourceChunksCache.getWithoutUpdatingLRU(chunkHash) !== undefined\n    );\n  }\n\n  withSuspendedSourceCacheEvictsAndDeletes<T>(\n    fn: () => MaybePromise<T>,\n  ): Promise<T> {\n    return this._sourceChunksCache.withSuspendedEvictsAndDeletes(fn);\n  }\n}\n\nexport class LazyRead implements Read {\n  protected readonly _heads: Map<string, Hash>;\n  protected readonly _memOnlyChunks: Map<Hash, Chunk>;\n  protected readonly _sourceChunksCache: ChunksCache;\n  protected readonly _sourceStore: Store;\n  #sourceRead: Promise<Read> | undefined = undefined;\n  readonly #release: () => void;\n  #closed = false;\n  readonly assertValidHash: (hash: Hash) => void;\n  readonly #sourceReadOwnedByCaller: boolean;\n\n  constructor(\n    heads: Map<string, Hash>,\n    memOnlyChunks: Map<Hash, Chunk>,\n    sourceChunksCache: ChunksCache,\n    sourceStore: Store,\n    release: () => void,\n    assertValidHash: (hash: Hash) => void,\n    // If the lazyRead is being run in the context of an existing\n    // read, or write, from the perdag then we must use _that_\n    // transaction's read. Trying to open our own `sourceRead` will\n    // cause the outer transaction to auto-commit.\n    sourceRead?: Read,\n  ) {\n    this._heads = heads;\n    this._memOnlyChunks = memOnlyChunks;\n    this._sourceChunksCache = sourceChunksCache;\n    this._sourceStore = sourceStore;\n    this.#release = release;\n    this.assertValidHash = assertValidHash;\n    this.#sourceRead =\n      sourceRead !== undefined ? Promise.resolve(sourceRead) : undefined;\n    this.#sourceReadOwnedByCaller = sourceRead !== undefined;\n  }\n\n  isMemOnlyChunkHash(hash: Hash): boolean {\n    return this._memOnlyChunks.has(hash);\n  }\n\n  async hasChunk(hash: Hash): Promise<boolean> {\n    return (await this.getChunk(hash)) !== undefined;\n  }\n\n  async getChunk(hash: Hash): Promise<Chunk | undefined> {\n    const memOnlyChunk = this._memOnlyChunks.get(hash);\n    if (memOnlyChunk !== undefined) {\n      return memOnlyChunk;\n    }\n    let chunk = this._sourceChunksCache.get(hash);\n    if (chunk === undefined) {\n      chunk = await (await this._getSourceRead()).getChunk(hash);\n      if (chunk !== undefined) {\n        this._sourceChunksCache.put(chunk);\n      }\n    }\n    return chunk;\n  }\n\n  mustGetChunk(hash: Hash): Promise<Chunk> {\n    return mustGetChunk(this, hash);\n  }\n\n  getHead(name: string): Promise<Hash | undefined> {\n    return Promise.resolve(this._heads.get(name));\n  }\n\n  release(): void {\n    if (!this.#closed) {\n      this.#release();\n      if (!this.#sourceReadOwnedByCaller) {\n        this.#sourceRead\n          ?.then(read => read.release())\n          // If creation of the read failed there is nothing to release.\n          // Catch to avoid `Uncaught (in promise)` errors being reported.\n          .catch(_ => {});\n      }\n      this.#closed = true;\n    }\n  }\n\n  get closed(): boolean {\n    return this.#closed;\n  }\n\n  protected _getSourceRead(): Promise<Read> {\n    if (!this.#sourceRead) {\n      this.#sourceRead = this._sourceStore.read();\n    }\n    return this.#sourceRead;\n  }\n}\n\nexport class LazyWrite\n  extends LazyRead\n  implements Write, RefCountUpdatesDelegate\n{\n  readonly #refCounts: Map<Hash, number>;\n  readonly #refs: Map<Hash, readonly Hash[]>;\n  readonly #chunkHasher: ChunkHasher;\n  protected readonly _pendingHeadChanges = new Map<string, HeadChange>();\n  protected readonly _pendingMemOnlyChunks = new Map<Hash, Chunk>();\n  protected readonly _pendingCachedChunks = new Map<\n    Hash,\n    {chunk: Chunk; size: number}\n  >();\n  readonly #createdChunks = new Set<Hash>();\n\n  constructor(\n    heads: Map<string, Hash>,\n    memOnlyChunks: Map<Hash, Chunk>,\n    sourceChunksCache: ChunksCache,\n    sourceStore: Store,\n    refCounts: Map<Hash, number>,\n    refs: Map<Hash, readonly Hash[]>,\n    release: () => void,\n    chunkHasher: ChunkHasher,\n    assertValidHash: (hash: Hash) => void,\n  ) {\n    super(\n      heads,\n      memOnlyChunks,\n      sourceChunksCache,\n      sourceStore,\n      release,\n      assertValidHash,\n    );\n    this.#refCounts = refCounts;\n    this.#refs = refs;\n    this.#chunkHasher = chunkHasher;\n  }\n\n  createChunk = <V>(data: V, refs: Refs): Chunk<V> => {\n    const chunk = createChunk(data, refs, this.#chunkHasher);\n    this.#createdChunks.add(chunk.hash);\n    return chunk;\n  };\n\n  putChunk<V>(c: Chunk<V>, size?: number): Promise<void> {\n    const {hash, meta} = c;\n    this.assertValidHash(hash);\n    if (meta.length > 0) {\n      for (const h of meta) {\n        this.assertValidHash(h);\n      }\n    }\n    if (this.#createdChunks.has(hash) || this.isMemOnlyChunkHash(hash)) {\n      this._pendingMemOnlyChunks.set(hash, c);\n    } else {\n      this._pendingCachedChunks.set(hash, {chunk: c, size: size ?? -1});\n    }\n    return promiseVoid;\n  }\n\n  async setHead(name: string, hash: Hash): Promise<void> {\n    await this.#setHead(name, hash);\n  }\n\n  async removeHead(name: string): Promise<void> {\n    await 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 v = this._pendingHeadChanges.get(name);\n    if (v === undefined) {\n      this._pendingHeadChanges.set(name, {new: hash, old: oldHash});\n    } else {\n      // Keep old if existing\n      v.new = hash;\n    }\n  }\n\n  override isMemOnlyChunkHash(hash: Hash): boolean {\n    return (\n      this._pendingMemOnlyChunks.has(hash) || super.isMemOnlyChunkHash(hash)\n    );\n  }\n\n  override async getChunk(hash: Hash): Promise<Chunk | undefined> {\n    const pendingMemOnlyChunk = this._pendingMemOnlyChunks.get(hash);\n    if (pendingMemOnlyChunk !== undefined) {\n      return pendingMemOnlyChunk;\n    }\n    const memOnlyChunk = this._memOnlyChunks.get(hash);\n    if (memOnlyChunk !== undefined) {\n      return memOnlyChunk;\n    }\n    // In order to delegate determining reachability to `computeRefCountUpdates`\n    // and defer this determination until commit time, treat cache misses\n    // as a 'put' of the lazily-loaded chunk.\n    const pendingCachedChunk = this._pendingCachedChunks.get(hash);\n    if (pendingCachedChunk !== undefined) {\n      return pendingCachedChunk.chunk;\n    }\n    let chunk = this._sourceChunksCache.get(hash);\n    if (chunk === undefined) {\n      chunk = await (await this._getSourceRead()).getChunk(hash);\n      if (chunk !== undefined) {\n        this._pendingCachedChunks.set(chunk.hash, {chunk, size: -1});\n      }\n    }\n    return chunk;\n  }\n\n  override getHead(name: string): Promise<Hash | undefined> {\n    const headChange = this._pendingHeadChanges.get(name);\n    if (headChange) {\n      return Promise.resolve(headChange.new);\n    }\n    return super.getHead(name);\n  }\n\n  async commit(): Promise<void> {\n    const pendingChunks = new Set(\n      joinIterables(\n        this._pendingMemOnlyChunks.keys(),\n        this._pendingCachedChunks.keys(),\n      ),\n    );\n    const refCountUpdates = await computeRefCountUpdates(\n      this._pendingHeadChanges.values(),\n      pendingChunks,\n      this,\n    );\n\n    for (const [hash, count] of refCountUpdates) {\n      if (this.isMemOnlyChunkHash(hash)) {\n        if (count === 0) {\n          this.#refCounts.delete(hash);\n          this._memOnlyChunks.delete(hash);\n          this.#refs.delete(hash);\n        } else {\n          this.#refCounts.set(hash, count);\n          const chunk = this._pendingMemOnlyChunks.get(hash);\n          if (chunk) {\n            this.#refs.set(hash, chunk.meta);\n            this._memOnlyChunks.set(hash, chunk);\n          }\n        }\n        refCountUpdates.delete(hash);\n      }\n    }\n\n    this._sourceChunksCache.updateForCommit(\n      this._pendingCachedChunks,\n      refCountUpdates,\n    );\n\n    for (const [name, headChange] of this._pendingHeadChanges) {\n      if (headChange.new) {\n        this._heads.set(name, headChange.new);\n      } else {\n        this._heads.delete(name);\n      }\n    }\n\n    this._pendingMemOnlyChunks.clear();\n    this._pendingCachedChunks.clear();\n    this._pendingHeadChanges.clear();\n    this.release();\n  }\n\n  getRefCount(hash: Hash): number | undefined {\n    return this.#refCounts.get(hash);\n  }\n\n  getRefs(hash: Hash): readonly Hash[] | undefined {\n    const pendingMemOnlyChunk = this._pendingMemOnlyChunks.get(hash);\n    if (pendingMemOnlyChunk) {\n      return pendingMemOnlyChunk.meta;\n    }\n    const memOnlyChunk = this._memOnlyChunks.get(hash);\n    if (memOnlyChunk) {\n      return memOnlyChunk.meta;\n    }\n    const pendingCachedChunk = this._pendingCachedChunks.get(hash);\n    if (pendingCachedChunk !== undefined) {\n      return pendingCachedChunk.chunk.meta;\n    }\n    return this.#refs.get(hash);\n  }\n\n  areRefsCounted(hash: Hash): boolean {\n    return this.#refs.has(hash);\n  }\n\n  chunksPersisted(chunkHashes: readonly Hash[]): void {\n    const chunksToCache = [];\n    for (const chunkHash of chunkHashes) {\n      const chunk = this._memOnlyChunks.get(chunkHash);\n      if (chunk) {\n        this._memOnlyChunks.delete(chunkHash);\n        chunksToCache.push(chunk);\n      }\n    }\n    this._sourceChunksCache.persisted(chunksToCache);\n  }\n}\n\ntype CacheEntry = {\n  chunk: Chunk;\n  size: number;\n};\n\nclass ChunksCache {\n  readonly #cacheSizeLimit: number;\n  readonly #getSizeOfChunk: (chunk: Chunk) => number;\n  readonly #refCounts: Map<Hash, number>;\n  readonly #refs: Map<Hash, readonly Hash[]>;\n  #size = 0;\n  #evictsAndDeletesSuspended = false;\n  readonly #suspendedDeletes: Hash[] = [];\n\n  /**\n   * Iteration order is from least to most recently used.\n   *\n   * Public so that testing subclass can access.\n   */\n  readonly cacheEntries = new Map<Hash, CacheEntry>();\n\n  constructor(\n    cacheSizeLimit: number,\n    getSizeOfChunk: (v: Chunk) => number,\n    refCounts: Map<Hash, number>,\n    refs: Map<Hash, readonly Hash[]>,\n  ) {\n    this.#cacheSizeLimit = cacheSizeLimit;\n    this.#getSizeOfChunk = getSizeOfChunk;\n    this.#refCounts = refCounts;\n    this.#refs = refs;\n  }\n\n  get(hash: Hash): Chunk | undefined {\n    const cacheEntry = this.cacheEntries.get(hash);\n    if (cacheEntry) {\n      // Update order in map for LRU tracking.\n      this.cacheEntries.delete(hash);\n      this.cacheEntries.set(hash, cacheEntry);\n    }\n    return cacheEntry?.chunk;\n  }\n\n  getWithoutUpdatingLRU(hash: Hash): Chunk | undefined {\n    return this.cacheEntries.get(hash)?.chunk;\n  }\n\n  put(chunk: Chunk): void {\n    const {hash} = chunk;\n    // If there is an existing cache entry then the cached value must be\n    // equivalent.  Update order in map for LRU tracking and early return.\n    const oldCacheEntry = this.cacheEntries.get(hash);\n    if (oldCacheEntry) {\n      this.cacheEntries.delete(hash);\n      this.cacheEntries.set(hash, oldCacheEntry);\n      return;\n    }\n\n    // Only cache if there is a ref from a head to this chunk\n    const refCount = this.#refCounts.get(hash);\n    if (refCount === undefined || refCount < 1) {\n      return;\n    }\n    if (!this.#cacheChunk(chunk)) {\n      return;\n    }\n    if (!this.#refs.has(hash)) {\n      for (const refHash of chunk.meta) {\n        this.#refCounts.set(refHash, (this.#refCounts.get(refHash) || 0) + 1);\n      }\n      this.#refs.set(hash, chunk.meta);\n    }\n\n    this.#ensureCacheSizeLimit();\n  }\n\n  #ensureCacheSizeLimit() {\n    if (this.#evictsAndDeletesSuspended) {\n      return;\n    }\n    for (const entry of this.cacheEntries.values()) {\n      if (this.#size <= this.#cacheSizeLimit) {\n        break;\n      }\n      this.#evict(entry);\n    }\n  }\n\n  #cacheChunk(chunk: Chunk, size?: number): boolean {\n    const chunkSize = size ?? this.#getSizeOfChunk(chunk);\n    if (chunkSize > this.#cacheSizeLimit) {\n      // This value cannot be cached due to its size exceeding the\n      // cache size limit, don't evict other entries to try to make\n      // room for it.\n      return false;\n    }\n    this.#size += chunkSize;\n    this.cacheEntries.set(chunk.hash, {chunk, size: chunkSize});\n    return true;\n  }\n\n  #evict(cacheEntry: CacheEntry): void {\n    const {hash} = cacheEntry.chunk;\n    this.#size -= cacheEntry.size;\n    this.cacheEntries.delete(hash);\n  }\n\n  #deleteEntryByHash(hash: Hash): void {\n    this.#refCounts.delete(hash);\n    this.#refs.delete(hash);\n    const cacheEntry = this.cacheEntries.get(hash);\n    if (cacheEntry) {\n      this.#size -= cacheEntry.size;\n      this.cacheEntries.delete(hash);\n    }\n  }\n\n  updateForCommit(\n    chunksToPut: Map<Hash, {chunk: Chunk; size: number}>,\n    refCountUpdates: Map<Hash, number>,\n  ): void {\n    for (const [hash, count] of refCountUpdates) {\n      if (count === 0) {\n        if (!this.#evictsAndDeletesSuspended) {\n          this.#deleteEntryByHash(hash);\n        } else {\n          this.#refCounts.set(hash, 0);\n          this.#suspendedDeletes.push(hash);\n        }\n      } else {\n        this.#refCounts.set(hash, count);\n        const chunkAndSize = chunksToPut.get(hash);\n        if (chunkAndSize) {\n          const {chunk, size} = chunkAndSize;\n          const oldCacheEntry = this.cacheEntries.get(hash);\n          if (oldCacheEntry) {\n            // If there is an existing cache entry then the cached value must be\n            // equivalent.  Update order in map for LRU tracking but avoid\n            // recomputing size and creating a new cache entry.\n            this.cacheEntries.delete(hash);\n            this.cacheEntries.set(hash, oldCacheEntry);\n          } else {\n            this.#cacheChunk(chunk, size !== -1 ? size : undefined);\n            this.#refs.set(hash, chunk.meta);\n          }\n        }\n      }\n    }\n    this.#ensureCacheSizeLimit();\n  }\n\n  persisted(chunks: Iterable<Chunk>) {\n    for (const chunk of chunks) {\n      this.#cacheChunk(chunk);\n    }\n    this.#ensureCacheSizeLimit();\n  }\n\n  async withSuspendedEvictsAndDeletes<T>(\n    fn: () => MaybePromise<T>,\n  ): Promise<T> {\n    this.#evictsAndDeletesSuspended = true;\n    try {\n      return await fn();\n    } finally {\n      this.#evictsAndDeletesSuspended = false;\n      for (const hash of this.#suspendedDeletes) {\n        if (this.#refCounts.get(hash) === 0) {\n          this.#deleteEntryByHash(hash);\n        }\n      }\n      this.#ensureCacheSizeLimit();\n    }\n  }\n}\n"],"mappings":"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"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","names":[],"sources":["../../../../../replicache/src/dag/store.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Hash} from '../hash.ts';\nimport type {Release} from '../with-transactions.ts';\nimport type {Chunk, Refs} from './chunk.ts';\n\nexport interface Store {\n  read(): Promise<Read>;\n  write(): Promise<Write>;\n  close(): Promise<void>;\n}\n\ninterface GetChunk {\n  getChunk(hash: Hash): Promise<Chunk | undefined>;\n}\n\nexport interface MustGetChunk {\n  mustGetChunk(hash: Hash): Promise<Chunk>;\n}\n\nexport interface Read extends GetChunk, MustGetChunk, Release {\n  hasChunk(hash: Hash): Promise<boolean>;\n  getHead(name: string): Promise<Hash | undefined>;\n  get closed(): boolean;\n}\n\nexport interface Write extends Read {\n  createChunk<V>(data: V, refs: Refs): Chunk<V>;\n  putChunk<V>(c: Chunk<V>): Promise<void>;\n  setHead(name: string, hash: Hash): Promise<void>;\n  removeHead(name: string): Promise<void>;\n  assertValidHash(hash: Hash): void;\n  commit(): Promise<void>;\n}\n\nexport class ChunkNotFoundError extends Error {\n  name = 'ChunkNotFoundError';\n  readonly hash: Hash;\n  constructor(hash: Hash) {\n    super(`Chunk not found ${hash}`);\n    this.hash = hash;\n  }\n}\n\nexport async function mustGetChunk(\n  store: GetChunk,\n  hash: Hash,\n): Promise<Chunk> {\n  const chunk = await store.getChunk(hash);\n  if (chunk) {\n    return chunk;\n  }\n  throw new ChunkNotFoundError(hash);\n}\n\nexport async function mustGetHeadHash(\n  name: string,\n  store: Read,\n): Promise<Hash> {\n  const hash = await store.getHead(name);\n  assert(hash, `Missing head ${name}`);\n  return hash;\n}\n"],"mappings":";;AAkCA,IAAa,qBAAb,cAAwC,MAAM;CAC5C,OAAO;CACP;CACA,YAAY,MAAY;EACtB,MAAM,mBAAmB,MAAM;EAC/B,KAAK,OAAO;CACd;AACF;AAEA,eAAsB,aACpB,OACA,MACgB;CAChB,MAAM,QAAQ,MAAM,MAAM,SAAS,IAAI;CACvC,IAAI,OACF,OAAO;CAET,MAAM,IAAI,mBAAmB,IAAI;AACnC;AAEA,eAAsB,gBACpB,MACA,OACe;CACf,MAAM,OAAO,MAAM,MAAM,QAAQ,IAAI;CACrC,OAAO,MAAM,gBAAgB,MAAM;CACnC,OAAO;AACT"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"visitor.js","names":["#dagRead","#seen"],"sources":["../../../../../replicache/src/dag/visitor.ts"],"sourcesContent":["import type {Hash} from '../hash.ts';\nimport type {Chunk} from './chunk.ts';\nimport type {MustGetChunk} from './store.ts';\n\n/**\n * A visitor walks the DAG starting at a given root and visits each chunk.\n */\nexport class Visitor {\n  #seen: Set<Hash> = new Set();\n  #dagRead: MustGetChunk;\n\n  constructor(dagRead: MustGetChunk) {\n    this.#dagRead = dagRead;\n  }\n\n  async visit(h: Hash) {\n    if (this.#seen.has(h)) {\n      return;\n    }\n    this.#seen.add(h);\n    const chunk = await this.#dagRead.mustGetChunk(h);\n    await this.visitChunk(chunk);\n  }\n\n  async visitChunk(chunk: Chunk<unknown>) {\n    await Promise.all(chunk.meta.map(ref => this.visit(ref)));\n  }\n}\n"],"mappings":";;;;AAOA,IAAa,UAAb,MAAqB;CACnB,wBAAmB,IAAI,IAAI;CAC3B;CAEA,YAAY,SAAuB;EACjC,KAAKA,WAAW;CAClB;CAEA,MAAM,MAAM,GAAS;EACnB,IAAI,KAAKC,MAAM,IAAI,CAAC,GAClB;EAEF,KAAKA,MAAM,IAAI,CAAC;EAChB,MAAM,QAAQ,MAAM,KAAKD,SAAS,aAAa,CAAC;EAChD,MAAM,KAAK,WAAW,KAAK;CAC7B;CAEA,MAAM,WAAW,OAAuB;EACtC,MAAM,QAAQ,IAAI,MAAM,KAAK,KAAI,QAAO,KAAK,MAAM,GAAG,CAAC,CAAC;CAC1D;AACF"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"commit.js","names":[],"sources":["../../../../../replicache/src/db/commit.ts"],"sourcesContent":["import {\n  assert,\n  assertArray,\n  assertBoolean,\n  assertNumber,\n  assertObject,\n  assertString,\n  unreachable,\n} from '../../../shared/src/asserts.ts';\nimport {assertJSONValue} from '../../../shared/src/json.ts';\nimport {skipCommitDataAsserts} from '../config.ts';\nimport {type FrozenCookie, compareCookies} from '../cookies.ts';\nimport {type Chunk, type CreateChunk, type Refs, toRefs} from '../dag/chunk.ts';\nimport {type MustGetChunk, type Read, mustGetHeadHash} from '../dag/store.ts';\nimport {\n  type FrozenJSONValue,\n  type FrozenTag,\n  assertDeepFrozen,\n  deepFreeze,\n} from '../frozen-json.ts';\nimport {type Hash, assertHash} from '../hash.ts';\nimport type {IndexDefinition} from '../index-defs.ts';\nimport type {ClientID} from '../sync/ids.ts';\nimport * as MetaType from './meta-type-enum.ts';\n\nexport const DEFAULT_HEAD_NAME = 'main';\n\nexport function commitIsLocalDD31(\n  commit: Commit<Meta>,\n): commit is Commit<LocalMetaDD31> {\n  return isLocalMetaDD31(commit.meta);\n}\n\nexport function commitIsLocal(\n  commit: Commit<Meta>,\n): commit is Commit<LocalMetaDD31> {\n  return commitIsLocalDD31(commit);\n}\n\nexport function commitIsSnapshot(\n  commit: Commit<Meta>,\n): commit is Commit<SnapshotMetaDD31> {\n  return isSnapshotMetaDD31(commit.meta);\n}\n\nexport class Commit<M extends Meta> {\n  readonly chunk: Chunk<CommitData<M>>;\n\n  constructor(chunk: Chunk<CommitData<M>>) {\n    this.chunk = chunk;\n  }\n\n  get meta(): M {\n    return this.chunk.data.meta;\n  }\n\n  get valueHash(): Hash {\n    // Already validated!\n    return this.chunk.data.valueHash;\n  }\n\n  getMutationID(clientID: ClientID, dagRead: MustGetChunk): Promise<number> {\n    return getMutationID(clientID, dagRead, this.meta);\n  }\n\n  async getNextMutationID(\n    clientID: ClientID,\n    dagRead: MustGetChunk,\n  ): Promise<number> {\n    return (await this.getMutationID(clientID, dagRead)) + 1;\n  }\n\n  get indexes(): readonly IndexRecord[] {\n    // Already validated!\n    return this.chunk.data.indexes;\n  }\n}\n\nexport async function getMutationID(\n  clientID: ClientID,\n  dagRead: MustGetChunk,\n  meta: Meta,\n): Promise<number> {\n  switch (meta.type) {\n    case MetaType.SnapshotDD31:\n      return meta.lastMutationIDs[clientID] ?? 0;\n\n    case MetaType.LocalDD31: {\n      if (meta.clientID === clientID) {\n        return meta.mutationID;\n      }\n      const {basisHash} = meta;\n      const basisCommit = await commitFromHash(basisHash, dagRead);\n      return getMutationID(clientID, dagRead, basisCommit.meta);\n    }\n\n    default:\n      unreachable(meta);\n  }\n}\n\n/**\n * Returns the set of local commits from the given `fromCommitHash` back to but not\n * including its base snapshot. If `fromCommitHash` is a snapshot, the returned vector\n * will be empty. When, as typical, `fromCommitHash` is the head of the default chain\n * then the returned commits are the set of pending commits, ie the set of local commits\n * that have not yet been pushed to the data layer.\n *\n * The vector of commits is returned in reverse chain order, that is, starting\n * with the commit with hash `fromCommitHash` and walking backwards.\n */\nexport async function localMutations(\n  fromCommitHash: Hash,\n  dagRead: Read,\n): Promise<Commit<LocalMetaDD31>[]> {\n  const commits = await commitChain(fromCommitHash, dagRead);\n  // Filter does not deal with type narrowing.\n  return commits.filter(c => commitIsLocal(c)) as Commit<LocalMetaDD31>[];\n}\n\nexport async function localMutationsDD31(\n  fromCommitHash: Hash,\n  dagRead: Read,\n): Promise<Commit<LocalMetaDD31>[]> {\n  const commits = await commitChain(fromCommitHash, dagRead);\n  // Filter does not deal with type narrowing.\n  return commits.filter(c => commitIsLocalDD31(c)) as Commit<LocalMetaDD31>[];\n}\n\nexport async function localMutationsGreaterThan(\n  commit: Commit<Meta>,\n  mutationIDLimits: Record<ClientID, number>,\n  dagRead: Read,\n): Promise<Commit<LocalMetaDD31>[]> {\n  const commits: Commit<LocalMetaDD31>[] = [];\n  const remainingMutationIDLimits = new Map(Object.entries(mutationIDLimits));\n  while (!commitIsSnapshot(commit) && remainingMutationIDLimits.size > 0) {\n    if (commitIsLocalDD31(commit)) {\n      const {meta} = commit;\n      const mutationIDLowerLimit = remainingMutationIDLimits.get(meta.clientID);\n      if (mutationIDLowerLimit !== undefined) {\n        if (meta.mutationID <= mutationIDLowerLimit) {\n          remainingMutationIDLimits.delete(meta.clientID);\n        } else {\n          commits.push(commit as Commit<LocalMetaDD31>);\n        }\n      }\n    }\n    const {basisHash} = commit.meta;\n    if (basisHash === null) {\n      throw new Error(`Commit ${commit.chunk.hash} has no basis`);\n    }\n    commit = await commitFromHash(basisHash, dagRead);\n  }\n  return commits;\n}\n\nexport async function baseSnapshotFromHead(\n  name: string,\n  dagRead: Read,\n): Promise<Commit<SnapshotMetaDD31>> {\n  const hash = await dagRead.getHead(name);\n  assert(hash, `Missing head ${name}`);\n  return baseSnapshotFromHash(hash, dagRead);\n}\n\nexport async function baseSnapshotHashFromHash(\n  hash: Hash,\n  dagRead: Read,\n): Promise<Hash> {\n  return (await baseSnapshotFromHash(hash, dagRead)).chunk.hash;\n}\n\nexport async function baseSnapshotFromHash(\n  hash: Hash,\n  dagRead: Read,\n): Promise<Commit<SnapshotMetaDD31>> {\n  const commit = await commitFromHash(hash, dagRead);\n  return baseSnapshotFromCommit(commit, dagRead);\n}\n\nexport async function baseSnapshotFromCommit(\n  commit: Commit<Meta>,\n  dagRead: Read,\n): Promise<Commit<SnapshotMetaDD31>> {\n  while (!commitIsSnapshot(commit)) {\n    const {meta} = commit;\n    if (isLocalMetaDD31(meta)) {\n      commit = await commitFromHash(meta.baseSnapshotHash, dagRead);\n    } else {\n      const {basisHash} = meta;\n      if (basisHash === null) {\n        throw new Error(`Commit ${commit.chunk.hash} has no basis`);\n      }\n      commit = await commitFromHash(basisHash, dagRead);\n    }\n  }\n  return commit;\n}\n\nexport function snapshotMetaParts(\n  c: Commit<SnapshotMetaDD31>,\n  clientID: ClientID,\n): [lastMutationID: number, cookie: FrozenCookie | FrozenJSONValue] {\n  const m = c.meta;\n  const lmid = m.lastMutationIDs[clientID] ?? 0;\n  return [lmid, m.cookieJSON];\n}\n\nexport function compareCookiesForSnapshots(\n  a: Commit<SnapshotMetaDD31>,\n  b: Commit<SnapshotMetaDD31>,\n): number {\n  return compareCookies(a.meta.cookieJSON, b.meta.cookieJSON);\n}\n\n/**\n * Returns all commits from the commit with fromCommitHash to its base snapshot,\n * inclusive of both. Resulting vector is in chain-head-first order (so snapshot\n * comes last).\n */\nexport async function commitChain(\n  fromCommitHash: Hash,\n  dagRead: Read,\n): Promise<Commit<Meta>[]> {\n  let commit = await commitFromHash(fromCommitHash, dagRead);\n  const commits = [];\n  while (!commitIsSnapshot(commit)) {\n    const {meta} = commit;\n    const {basisHash} = meta;\n    if (basisHash === null) {\n      throw new Error(`Commit ${commit.chunk.hash} has no basis`);\n    }\n    commits.push(commit);\n    commit = await commitFromHash(basisHash, dagRead);\n  }\n  commits.push(commit);\n  return commits;\n}\n\nexport async function commitFromHash(\n  hash: Hash,\n  dagRead: MustGetChunk,\n): Promise<Commit<Meta>> {\n  const chunk = await dagRead.mustGetChunk(hash);\n  return fromChunk(chunk);\n}\n\nexport async function commitFromHead(\n  name: string,\n  dagRead: Read,\n): Promise<Commit<Meta>> {\n  const hash = await mustGetHeadHash(name, dagRead);\n  return commitFromHash(hash, dagRead);\n}\n\nexport type LocalMetaDD31 = {\n  readonly type: MetaType.LocalDD31;\n  readonly basisHash: Hash;\n  readonly mutationID: number;\n  readonly mutatorName: string;\n  readonly mutatorArgsJSON: FrozenJSONValue;\n  readonly originalHash: Hash | null;\n  readonly timestamp: number;\n  readonly clientID: ClientID;\n  readonly baseSnapshotHash: Hash;\n};\n\nexport type LocalMeta = LocalMetaDD31;\n\nexport function assertLocalMetaDD31(\n  v: Record<string, unknown>,\n): asserts v is LocalMetaDD31 {\n  // type already asserted\n  assertString(v.clientID);\n  assertNumber(v.mutationID);\n  assertString(v.mutatorName);\n  if (!v.mutatorName) {\n    throw new Error('Missing mutator name');\n  }\n  assertJSONValue(v.mutatorArgsJSON);\n  if (v.originalHash !== null) {\n    assertHash(v.originalHash);\n  }\n  assertNumber(v.timestamp);\n}\n\nexport function isLocalMetaDD31(meta: Meta): meta is LocalMetaDD31 {\n  return meta.type === MetaType.LocalDD31;\n}\n\nexport function assertLocalCommitDD31(\n  c: Commit<Meta>,\n): asserts c is Commit<LocalMetaDD31> {\n  assertLocalMetaDD31(c.meta);\n}\n\nexport type SnapshotMetaDD31 = {\n  readonly type: MetaType.SnapshotDD31;\n  readonly basisHash: Hash | null;\n  readonly lastMutationIDs: Record<ClientID, number>;\n  readonly cookieJSON: FrozenCookie;\n};\n\nexport type SnapshotMeta = SnapshotMetaDD31;\n\nexport function assertSnapshotMetaDD31(\n  v: Record<string, unknown>,\n): asserts v is SnapshotMetaDD31 {\n  // type already asserted\n  if (v.basisHash !== null) {\n    assertHash(v.basisHash);\n  }\n  assertJSONValue(v.cookieJSON);\n  assertLastMutationIDs(v.lastMutationIDs);\n}\n\nfunction assertLastMutationIDs(\n  v: unknown,\n): asserts v is Record<ClientID, number> {\n  assertObject(v);\n  for (const e of Object.values(v)) {\n    assertNumber(e);\n  }\n}\n\nexport type Meta = LocalMetaDD31 | SnapshotMetaDD31;\n\nexport function assertSnapshotCommitDD31(\n  c: Commit<Meta>,\n): asserts c is Commit<SnapshotMetaDD31> {\n  assertSnapshotMetaDD31(c.meta);\n}\n\nfunction isSnapshotMetaDD31(meta: Meta): meta is SnapshotMetaDD31 {\n  return meta.type === MetaType.SnapshotDD31;\n}\n\nfunction assertMeta(v: unknown): asserts v is Meta {\n  assertObject(v);\n  assertDeepFrozen(v);\n  if (v.basisHash !== null) {\n    assertString(v.basisHash);\n  }\n\n  assertNumber(v.type);\n  switch (v.type) {\n    case MetaType.LocalDD31:\n      assertLocalMetaDD31(v);\n      break;\n    case MetaType.SnapshotDD31:\n      assertSnapshotMetaDD31(v);\n      break;\n    default:\n      throw new Error(`Invalid enum value ${v.type}`);\n  }\n}\n\n/**\n * This is the type used for index definitions as defined in the Commit chunk data.\n *\n * Changing this requires a REPLICACHE_FORMAT_VERSION bump.\n */\nexport type ChunkIndexDefinition = {\n  readonly name: string;\n  readonly keyPrefix: string;\n  readonly jsonPointer: string;\n  // Used to not exist\n  readonly allowEmpty?: boolean;\n};\n\nexport function chunkIndexDefinitionEqualIgnoreName(\n  a: ChunkIndexDefinition,\n  b: ChunkIndexDefinition,\n): boolean {\n  return (\n    a.jsonPointer === b.jsonPointer &&\n    (a.allowEmpty ?? false) === (b.allowEmpty ?? false) &&\n    a.keyPrefix === b.keyPrefix\n  );\n}\n\nfunction assertChunkIndexDefinition(\n  v: unknown,\n): asserts v is ChunkIndexDefinition {\n  assertObject(v);\n  assertDeepFrozen(v);\n  assertString(v.name);\n  assertString(v.keyPrefix);\n  assertString(v.jsonPointer);\n  if (v.allowEmpty !== undefined) {\n    assertBoolean(v.allowEmpty);\n  }\n}\n\nexport function toChunkIndexDefinition(\n  name: string,\n  indexDefinition: IndexDefinition,\n): Required<ChunkIndexDefinition> {\n  return {\n    name,\n    keyPrefix: indexDefinition.prefix ?? '',\n    jsonPointer: indexDefinition.jsonPointer,\n    allowEmpty: indexDefinition.allowEmpty ?? false,\n  };\n}\n\nexport type IndexRecord = {\n  readonly definition: ChunkIndexDefinition;\n  readonly valueHash: Hash;\n};\n\nfunction assertIndexRecord(v: unknown): asserts v is IndexRecord {\n  assertObject(v);\n  assertDeepFrozen(v);\n  assertChunkIndexDefinition(v.definition);\n  assertString(v.valueHash);\n}\n\nfunction assertIndexRecords(v: unknown): asserts v is IndexRecord[] {\n  assertArray(v);\n  assertDeepFrozen(v);\n  for (const ir of v) {\n    assertIndexRecord(ir);\n  }\n}\n\nexport function newLocalDD31(\n  createChunk: CreateChunk,\n  basisHash: Hash,\n  baseSnapshotHash: Hash,\n  mutationID: number,\n  mutatorName: string,\n  mutatorArgsJSON: FrozenJSONValue,\n  originalHash: Hash | null,\n  valueHash: Hash,\n  indexes: readonly IndexRecord[],\n  timestamp: number,\n  clientID: ClientID,\n): Commit<LocalMetaDD31> {\n  const meta: LocalMetaDD31 = {\n    type: MetaType.LocalDD31,\n    basisHash,\n    baseSnapshotHash,\n    mutationID,\n    mutatorName,\n    mutatorArgsJSON,\n    originalHash,\n    timestamp,\n    clientID,\n  };\n  return commitFromCommitData(\n    createChunk,\n    makeCommitData(meta, valueHash, indexes),\n  );\n}\n\nexport function newSnapshotDD31(\n  createChunk: CreateChunk,\n  basisHash: Hash | null,\n  lastMutationIDs: Record<ClientID, number>,\n  cookieJSON: FrozenCookie,\n  valueHash: Hash,\n  indexes: readonly IndexRecord[],\n): Commit<SnapshotMetaDD31> {\n  return commitFromCommitData(\n    createChunk,\n    newSnapshotCommitDataDD31(\n      basisHash,\n      lastMutationIDs,\n      cookieJSON,\n      valueHash,\n      indexes,\n    ),\n  );\n}\n\nexport function newSnapshotCommitDataDD31(\n  basisHash: Hash | null,\n  lastMutationIDs: Record<ClientID, number>,\n  cookieJSON: FrozenCookie,\n  valueHash: Hash,\n  indexes: readonly IndexRecord[],\n): CommitData<SnapshotMetaDD31> {\n  const meta: SnapshotMetaDD31 = {\n    type: MetaType.SnapshotDD31,\n    basisHash,\n    lastMutationIDs,\n    cookieJSON,\n  };\n  return makeCommitData(meta, valueHash, indexes);\n}\n\nexport function fromChunk(chunk: Chunk): Commit<Meta> {\n  validateChunk(chunk);\n  return new Commit(chunk);\n}\n\nfunction commitFromCommitData<M extends Meta>(\n  createChunk: CreateChunk,\n  data: CommitData<M>,\n): Commit<M> {\n  return new Commit(createChunk(data, getRefs(data)));\n}\n\nexport function getRefs(data: CommitData<Meta>): Refs {\n  const refs: Set<Hash> = new Set();\n  refs.add(data.valueHash);\n  const {meta} = data;\n  switch (meta.type) {\n    case MetaType.LocalDD31:\n      meta.basisHash && refs.add(meta.basisHash);\n      // Local has weak originalHash\n      break;\n    case MetaType.SnapshotDD31:\n      // Snapshot has weak basisHash\n      break;\n    default:\n      unreachable(meta);\n  }\n\n  for (const index of data.indexes) {\n    refs.add(index.valueHash);\n  }\n\n  return toRefs(refs);\n}\n\nexport type CommitData<M extends Meta> = FrozenTag<{\n  readonly meta: M;\n  readonly valueHash: Hash;\n  readonly indexes: readonly IndexRecord[];\n}>;\n\nexport function makeCommitData<M extends Meta>(\n  meta: M,\n  valueHash: Hash,\n  indexes: readonly IndexRecord[],\n): CommitData<M> {\n  return deepFreeze({\n    meta,\n    valueHash,\n    indexes,\n  }) as unknown as CommitData<M>;\n}\n\nexport function assertCommitData(v: unknown): asserts v is CommitData<Meta> {\n  if (skipCommitDataAsserts) {\n    return;\n  }\n\n  assertObject(v);\n  assertDeepFrozen(v);\n  assertMeta(v.meta);\n  assertString(v.valueHash);\n  assertIndexRecords(v.indexes);\n}\n\nfunction validateChunk(chunk: Chunk): asserts chunk is Chunk<CommitData<Meta>> {\n  const {data} = chunk;\n  assertCommitData(data);\n\n  const seen = new Set();\n  for (const index of data.indexes) {\n    const {name} = index.definition;\n    if (seen.has(name)) {\n      throw new Error(`Duplicate index ${name}`);\n    }\n    seen.add(name);\n  }\n}\n"],"mappings":"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"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../../replicache/src/db/index.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport type {BTreeRead} from '../btree/read.ts';\nimport type {BTreeWrite} from '../btree/write.ts';\nimport type {FrozenJSONObject, FrozenJSONValue} from '../frozen-json.ts';\nimport type {Hash} from '../hash.ts';\nimport type {IndexRecord} from './commit.ts';\nimport * as IndexOperation from './index-operation-enum.ts';\n\ntype IndexOperation = Enum<typeof IndexOperation>;\n\nexport class IndexRead<BTree = BTreeRead> {\n  readonly meta: IndexRecord;\n  readonly map: BTree;\n\n  constructor(meta: IndexRecord, map: BTree) {\n    this.meta = meta;\n    this.map = map;\n  }\n}\n\nexport class IndexWrite extends IndexRead<BTreeWrite> {\n  // Note: does not update self.meta.valueHash (doesn't need to at this point as flush\n  // is only called during commit.)\n  flush(): Promise<Hash> {\n    return this.map.flush();\n  }\n\n  clear(): Promise<void> {\n    return this.map.clear();\n  }\n}\n\n// Index or de-index a single primary entry.\nexport async function indexValue(\n  lc: LogContext,\n  index: BTreeWrite,\n  op: IndexOperation,\n  key: string,\n  val: FrozenJSONValue,\n  jsonPointer: string,\n  allowEmpty: boolean,\n): Promise<void> {\n  try {\n    for (const entry of getIndexKeys(key, val, jsonPointer, allowEmpty)) {\n      switch (op) {\n        case IndexOperation.Add:\n          await index.put(entry, val);\n          break;\n        case IndexOperation.Remove:\n          await index.del(entry);\n          break;\n      }\n    }\n  } catch (e) {\n    // Right now all the errors that index_value() returns are customers dev\n    // problems: either the value is not json, the pointer is into nowhere, etc.\n    // So we ignore them.\n    lc.info?.('Not indexing value', val, ':', e);\n  }\n}\n\n// Gets the set of index keys for a given primary key and value.\nexport function getIndexKeys(\n  primary: string,\n  value: FrozenJSONValue,\n  jsonPointer: string,\n  allowEmpty: boolean,\n): string[] {\n  const target = evaluateJSONPointer(value, jsonPointer);\n  if (target === undefined) {\n    if (allowEmpty) {\n      return [];\n    }\n    throw new Error(`No value at path: ${jsonPointer}`);\n  }\n\n  const values = Array.isArray(target) ? target : [target];\n\n  const indexKeys: string[] = [];\n  for (const value of values) {\n    if (typeof value === 'string') {\n      indexKeys.push(encodeIndexKey([value, primary]));\n    } else {\n      throw new Error('Unsupported target type');\n    }\n  }\n\n  return indexKeys;\n}\n\nexport const KEY_VERSION_0 = '\\u0000';\nexport const KEY_SEPARATOR = '\\u0000';\n\n/**\n * When using indexes the key is a tuple of the secondary key and the primary\n * key.\n */\nexport type IndexKey = readonly [secondary: string, primary: string];\n\n// An index key is encoded to vec of bytes in the following order:\n//   - key version byte(s), followed by\n//   - the secondary key bytes (which for now is a UTF8 encoded string), followed by\n//   - the key separator, a null byte, followed by\n//   - the primary key bytes\n//\n// The null separator byte ensures that if a secondary key A is longer than B then\n// A always sorts after B. Appending the primary key ensures index keys with\n// identical secondary keys sort in primary key order. Secondary keys must not\n// contain a zero (null) byte.\nexport function encodeIndexKey(indexKey: IndexKey): string {\n  const secondary = indexKey[0];\n  const primary = indexKey[1];\n\n  if (secondary.includes('\\u0000')) {\n    throw new Error('Secondary key cannot contain null byte');\n  }\n  return KEY_VERSION_0 + secondary + KEY_SEPARATOR + primary;\n}\n\n// Returns bytes that can be used to scan for the given secondary index value.\n//\n// Consider a scan for start_secondary_key=\"a\" (97). We want to scan with scan\n// key [0, 97]. We could also scan with [0, 97, 0], but then we couldn't use\n// this function for prefix scans, so we lop off the null byte. If we want\n// the scan to be exclusive, we scan with the next greater value, [0, 97, 1]\n// (we disallow zero bytes in secondary keys).\n//\n// Now it gets a little tricky. We also want to be able to scan using the\n// primary key, start_key. When we do this we have to encode the scan key\n// a little differently We essentially have to fix the value of the\n// secondary key so we can vary the start_key. That is, the match on\n// start_secondary_key becomes an exact match.\n//\n// Consider the scan for start_secondary_key=\"a\" and start_key=[2]. We want\n// to scan with [0, 97, 0, 2]. If we want exclusive we want to scan with\n// the next highest value, [0, 97, 0, 2, 0] (zero bytes are allowed in primary\n// keys). So far so good. It is important to notice that we need to\n// be able to distinguish between not wanting use start_key and wanting to\n// use start_key=[]. In the former case we want to scan with the secondary\n// key value, possibly followed by a 1 with no trailing zero byte ([0, 97]\n// or [0, 97, 1]). In the latter case we want to scan by the secondary\n// key value, followed by the zero byte, followed by the primary key value\n// and another zero if it is exclusive ([0, 97, 0] or [0, 97, 0, 0]).\n// This explains why we need the Option around start_key.\nexport function encodeIndexScanKey(\n  secondary: string,\n  primary: string | undefined,\n): string {\n  const k = encodeIndexKey([secondary, primary || '']);\n  if (primary === undefined) {\n    return k.slice(0, k.length - 1);\n  }\n  return k;\n}\n\n// Decodes an IndexKey encoded by encode_index_key.\nexport function decodeIndexKey(encodedIndexKey: string): IndexKey {\n  if (encodedIndexKey[0] !== KEY_VERSION_0) {\n    throw new Error('Invalid version');\n  }\n\n  const versionLen = KEY_VERSION_0.length;\n  const separatorLen = KEY_SEPARATOR.length;\n  const separatorOffset = encodedIndexKey.indexOf(KEY_SEPARATOR, versionLen);\n  if (separatorOffset === -1) {\n    throw new Error('Invalid formatting');\n  }\n\n  const secondary = encodedIndexKey.slice(versionLen, separatorOffset);\n  const primary = encodedIndexKey.slice(separatorOffset + separatorLen);\n  return [secondary, primary];\n}\n\nexport function evaluateJSONPointer(\n  value: FrozenJSONValue,\n  pointer: string,\n): FrozenJSONValue | undefined {\n  function parseIndex(s: string): number | undefined {\n    if (s.startsWith('+') || (s.startsWith('0') && s.length !== 1)) {\n      return undefined;\n    }\n    return parseInt(s, 10);\n  }\n\n  if (pointer === '') {\n    return value;\n  }\n  if (!pointer.startsWith('/')) {\n    throw new Error(`Invalid JSON pointer: ${pointer}`);\n  }\n\n  const tokens = pointer\n    .split('/')\n    .slice(1)\n    .map(x => x.replace(/~1/g, '/').replace(/~0/g, '~'));\n\n  let target = value;\n  for (const token of tokens) {\n    let targetOpt;\n    if (Array.isArray(target)) {\n      const i = parseIndex(token);\n      if (i === undefined) {\n        return undefined;\n      }\n      targetOpt = target[i];\n    } else if (target === null) {\n      return undefined;\n    } else if (typeof target === 'object') {\n      target = target as FrozenJSONObject;\n      targetOpt = target[token];\n    }\n    if (targetOpt === undefined) {\n      return undefined;\n    }\n    target = targetOpt;\n  }\n  return target;\n}\n"],"mappings":"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"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"read.js","names":["#dagRead"],"sources":["../../../../../replicache/src/db/read.ts"],"sourcesContent":["import type {Enum} from '../../../shared/src/enum.ts';\nimport {BTreeRead} from '../btree/read.ts';\nimport type {Read as DagRead} from '../dag/store.ts';\nimport type * as FormatVersion from '../format-version-enum.ts';\nimport type {FrozenJSONValue} from '../frozen-json.ts';\nimport type {Hash} from '../hash.ts';\nimport type {Commit} from './commit.ts';\nimport {\n  DEFAULT_HEAD_NAME,\n  type Meta,\n  commitFromHash,\n  commitFromHead,\n} from './commit.ts';\nimport {IndexRead} from './index.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\nexport class Read {\n  readonly #dagRead: DagRead;\n  map: BTreeRead;\n  readonly indexes: Map<string, IndexRead>;\n\n  constructor(\n    dagRead: DagRead,\n    map: BTreeRead,\n    indexes: Map<string, IndexRead>,\n  ) {\n    this.#dagRead = dagRead;\n    this.map = map;\n    this.indexes = indexes;\n  }\n\n  has(key: string): Promise<boolean> {\n    return this.map.has(key);\n  }\n\n  get(key: string): Promise<FrozenJSONValue | undefined> {\n    return this.map.get(key);\n  }\n\n  isEmpty(): Promise<boolean> {\n    return this.map.isEmpty();\n  }\n\n  getMapForIndex(indexName: string): BTreeRead {\n    const idx = this.indexes.get(indexName);\n    if (idx === undefined) {\n      throw new Error(`Unknown index name: ${indexName}`);\n    }\n    return idx.map;\n  }\n\n  get closed(): boolean {\n    return this.#dagRead.closed;\n  }\n\n  close(): void {\n    this.#dagRead.release();\n  }\n}\n\nexport function readFromDefaultHead(\n  dagRead: DagRead,\n  formatVersion: FormatVersion,\n): Promise<Read> {\n  return readFromHead(DEFAULT_HEAD_NAME, dagRead, formatVersion);\n}\n\nexport async function readFromHead(\n  name: string,\n  dagRead: DagRead,\n  formatVersion: FormatVersion,\n): Promise<Read> {\n  const commit = await commitFromHead(name, dagRead);\n  return readFromCommit(commit, dagRead, formatVersion);\n}\n\nexport async function readFromHash(\n  hash: Hash,\n  dagRead: DagRead,\n  formatVersion: FormatVersion,\n): Promise<Read> {\n  const commit = await commitFromHash(hash, dagRead);\n  return readFromCommit(commit, dagRead, formatVersion);\n}\n\nfunction readFromCommit(\n  commit: Commit<Meta>,\n  dagRead: DagRead,\n  formatVersion: FormatVersion,\n): Read {\n  const indexes = readIndexesForRead(commit, dagRead, formatVersion);\n  const map = new BTreeRead(dagRead, formatVersion, commit.valueHash);\n  return new Read(dagRead, map, indexes);\n}\n\nexport function readIndexesForRead(\n  commit: Commit<Meta>,\n  dagRead: DagRead,\n  formatVersion: FormatVersion,\n): Map<string, IndexRead> {\n  const m = new Map();\n  for (const index of commit.indexes) {\n    m.set(\n      index.definition.name,\n      new IndexRead(\n        index,\n        new BTreeRead(dagRead, formatVersion, index.valueHash),\n      ),\n    );\n  }\n  return m;\n}\n"],"mappings":";;;;AAiBA,IAAa,OAAb,MAAkB;CAChB;CACA;CACA;CAEA,YACE,SACA,KACA,SACA;EACA,KAAKA,WAAW;EAChB,KAAK,MAAM;EACX,KAAK,UAAU;CACjB;CAEA,IAAI,KAA+B;EACjC,OAAO,KAAK,IAAI,IAAI,GAAG;CACzB;CAEA,IAAI,KAAmD;EACrD,OAAO,KAAK,IAAI,IAAI,GAAG;CACzB;CAEA,UAA4B;EAC1B,OAAO,KAAK,IAAI,QAAQ;CAC1B;CAEA,eAAe,WAA8B;EAC3C,MAAM,MAAM,KAAK,QAAQ,IAAI,SAAS;EACtC,IAAI,QAAQ,KAAA,GACV,MAAM,IAAI,MAAM,uBAAuB,WAAW;EAEpD,OAAO,IAAI;CACb;CAEA,IAAI,SAAkB;EACpB,OAAO,KAAKA,SAAS;CACvB;CAEA,QAAc;EACZ,KAAKA,SAAS,QAAQ;CACxB;AACF;AAEA,SAAgB,oBACd,SACA,eACe;CACf,OAAO,aAAa,mBAAmB,SAAS,aAAa;AAC/D;AAEA,eAAsB,aACpB,MACA,SACA,eACe;CAEf,OAAO,eAAe,MADD,eAAe,MAAM,OAAO,GACnB,SAAS,aAAa;AACtD;AAEA,eAAsB,aACpB,MACA,SACA,eACe;CAEf,OAAO,eAAe,MADD,eAAe,MAAM,OAAO,GACnB,SAAS,aAAa;AACtD;AAEA,SAAS,eACP,QACA,SACA,eACM;CACN,MAAM,UAAU,mBAAmB,QAAQ,SAAS,aAAa;CAEjE,OAAO,IAAI,KAAK,SAAS,IADT,UAAU,SAAS,eAAe,OAAO,SAChC,GAAK,OAAO;AACvC;AAEA,SAAgB,mBACd,QACA,SACA,eACwB;CACxB,MAAM,oBAAI,IAAI,IAAI;CAClB,KAAK,MAAM,SAAS,OAAO,SACzB,EAAE,IACA,MAAM,WAAW,MACjB,IAAI,UACF,OACA,IAAI,UAAU,SAAS,eAAe,MAAM,SAAS,CACvD,CACF;CAEF,OAAO;AACT"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"write.js","names":["#dagWrite","#basis","#meta","#clientID","#formatVersion","#generateDiffs"],"sources":["../../../../../replicache/src/db/write.ts"],"sourcesContent":["import 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 {lazy} from '../lazy.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    const oldVal = lazy(() => this.map.get(key));\n    await updateIndexes(lc, this.indexes, key, oldVal, 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 (this.indexes.size > 0) {\n      // TODO(arv): Indexes can use the optimizePatch pattern too.\n      for (const [key, value] of entries) {\n        const oldVal = lazy(() => this.map.get(key));\n        await updateIndexes(lc, this.indexes, key, oldVal, 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    // TODO(arv): This does the binary search twice. We can do better.\n    const oldVal = lazy(() => this.map.get(key));\n    if (oldVal !== undefined) {\n      await updateIndexes(lc, this.indexes, key, oldVal, 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    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  indexes: Map<string, IndexWrite>,\n  key: string,\n  oldValGetter: () => Promise<FrozenJSONValue | undefined>,\n  newVal: FrozenJSONValue | undefined,\n): Promise<void> {\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 oldValGetter();\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 = new Map();\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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"}

package/out/replicache/src/deleted-clients.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deleted-clients.js","names":[],"sources":["../../../../replicache/src/deleted-clients.ts"],"sourcesContent":["import {stringCompare} from '../../shared/src/string-compare.ts';\nimport * as v from '../../shared/src/valita.ts';\nimport type {Read, Write} from './dag/store.ts';\nimport {deepFreeze} from './frozen-json.ts';\nimport {getClients, setClients} from './persist/clients.ts';\nimport {\n  clientGroupIDSchema,\n  clientIDSchema,\n  type ClientGroupID,\n  type ClientID,\n} from './sync/ids.ts';\n\n/**\n * We keep track of deleted clients in the {@linkcode DELETED_CLIENTS_HEAD_NAME}\n * head.\n */\nexport const DELETED_CLIENTS_HEAD_NAME = 'deleted-clients-v2';\n\ntype ClientIDPair = {\n  clientGroupID: ClientGroupID;\n  clientID: ClientID;\n};\n\nexport type DeletedClients = readonly Readonly<ClientIDPair>[];\n\nexport type WritableDeletedClients = ClientIDPair[];\n\nexport const deletedClientsSchema: v.Type<DeletedClients> = v.readonlyArray(\n  v.readonlyObject({\n    clientGroupID: clientGroupIDSchema,\n    clientID: clientIDSchema,\n  }),\n);\n\nfunction compare(a: ClientIDPair, b: ClientIDPair): number {\n  const cg = stringCompare(a.clientGroupID, b.clientGroupID);\n  if (cg !== 0) {\n    return cg;\n  }\n  return stringCompare(a.clientID, b.clientID);\n}\n\nexport function normalizeDeletedClients(\n  deletedClients: DeletedClients,\n): DeletedClients {\n  return deletedClients\n    .toSorted(compare)\n    .filter((item, i, arr) => i === 0 || compare(item, arr[i - 1]) !== 0);\n}\n\nexport function mergeDeletedClients(\n  a: DeletedClients,\n  b: DeletedClients,\n): DeletedClients {\n  const merged: WritableDeletedClients = [];\n  a = normalizeDeletedClients(a);\n  b = normalizeDeletedClients(b);\n  for (let i = 0, j = 0; i < a.length || j < b.length; ) {\n    if (i < a.length && (j >= b.length || compare(a[i], b[j]) < 0)) {\n      merged.push(a[i]);\n      i++;\n    } else if (j < b.length && (i >= a.length || compare(b[j], a[i]) < 0)) {\n      merged.push(b[j]);\n      j++;\n    } else {\n      // equal\n      merged.push(a[i]);\n      i++;\n      j++;\n    }\n  }\n  return merged;\n}\n\nexport function removeFromDeletedClients(\n  old: DeletedClients,\n  toRemove: DeletedClients,\n): DeletedClients {\n  old = normalizeDeletedClients(old);\n  toRemove = normalizeDeletedClients(toRemove);\n  const result: WritableDeletedClients = [];\n  for (let i = 0, j = 0; i < old.length; ) {\n    if (j >= toRemove.length || compare(old[i], toRemove[j]) < 0) {\n      result.push(old[i]);\n      i++;\n    } else if (j < toRemove.length && compare(old[i], toRemove[j]) === 0) {\n      // equal, skip\n      i++;\n      j++;\n    } else {\n      // old[i] > toRemove[j]\n      j++;\n    }\n  }\n  return result;\n}\n\nexport async function setDeletedClients(\n  dagWrite: Write,\n  deletedClients: DeletedClients,\n): Promise<DeletedClients> {\n  // sort and dedupe\n\n  const data = normalizeDeletedClients(deletedClients);\n\n  const chunkData = deepFreeze(data);\n  const chunk = dagWrite.createChunk(chunkData, []);\n  await dagWrite.putChunk(chunk);\n  await dagWrite.setHead(DELETED_CLIENTS_HEAD_NAME, chunk.hash);\n  return data;\n}\n\nexport async function getDeletedClients(\n  dagRead: Read,\n): Promise<DeletedClients> {\n  const hash = await dagRead.getHead(DELETED_CLIENTS_HEAD_NAME);\n  if (hash === undefined) {\n    return [];\n  }\n  const chunk = await dagRead.mustGetChunk(hash);\n\n  const res = v.test(chunk.data, deletedClientsSchema);\n  if (!res.ok) {\n    // If not ok then we ignore this. It might be in the old format but we do\n    // not know the clientGroupID of the old clients.\n    return [];\n  }\n\n  return res.value;\n}\n\n/**\n * Adds deleted clients to the {@linkcode DELETED_CLIENTS_HEAD_NAME} head.\n * @returns the new list of deleted clients (sorted and deduped).\n */\nexport async function addDeletedClients(\n  dagWrite: Write,\n  deletedClientsToAdd: DeletedClients,\n): Promise<DeletedClients> {\n  const oldDeletedClients = await getDeletedClients(dagWrite);\n\n  return setDeletedClients(\n    dagWrite,\n    mergeDeletedClients(oldDeletedClients, deletedClientsToAdd),\n  );\n}\n\nexport async function removeDeletedClients(\n  dagWrite: Write,\n  deletedClientsToRemove: DeletedClients,\n): Promise<DeletedClients> {\n  const oldDeletedClients = await getDeletedClients(dagWrite);\n  return setDeletedClients(\n    dagWrite,\n    removeFromDeletedClients(oldDeletedClients, deletedClientsToRemove),\n  );\n}\n\nexport async function confirmDeletedClients(\n  dagWrite: Write,\n  deletedClientIds: readonly ClientID[],\n  deletedClientGroupIds: readonly ClientGroupID[],\n): Promise<DeletedClients> {\n  const deletedClientIDSet = new Set(deletedClientIds);\n  const deletedClientGroupIDSet = new Set(deletedClientGroupIds);\n  const oldDeletedClients = await getDeletedClients(dagWrite);\n  const clients = new Map(await getClients(dagWrite));\n  for (const clientID of deletedClientIds) {\n    clients.delete(clientID);\n  }\n  for (const clientGroupID of deletedClientGroupIds) {\n    for (const [clientID, client] of clients) {\n      if (client.clientGroupID === clientGroupID) {\n        clients.delete(clientID);\n      }\n    }\n  }\n\n  await setClients(clients, dagWrite);\n\n  return setDeletedClients(\n    dagWrite,\n    oldDeletedClients.filter(\n      ({clientGroupID, clientID}) =>\n        !deletedClientGroupIDSet.has(clientGroupID) &&\n        !deletedClientIDSet.has(clientID),\n    ),\n  );\n}\n"],"mappings":";;;;;;;;;;AAgBA,IAAa,4BAA4B;AAWzC,IAAa,uBAA+C,cAC1D,eAAiB;CACf,eAAe;CACf,UAAU;AACZ,CAAC,CACH;AAEA,SAAS,QAAQ,GAAiB,GAAyB;CACzD,MAAM,KAAK,cAAc,EAAE,eAAe,EAAE,aAAa;CACzD,IAAI,OAAO,GACT,OAAO;CAET,OAAO,cAAc,EAAE,UAAU,EAAE,QAAQ;AAC7C;AAEA,SAAgB,wBACd,gBACgB;CAChB,OAAO,eACJ,SAAS,OAAO,EAChB,QAAQ,MAAM,GAAG,QAAQ,MAAM,KAAK,QAAQ,MAAM,IAAI,IAAI,EAAE,MAAM,CAAC;AACxE;AAEA,SAAgB,oBACd,GACA,GACgB;CAChB,MAAM,SAAiC,CAAC;CACxC,IAAI,wBAAwB,CAAC;CAC7B,IAAI,wBAAwB,CAAC;CAC7B,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,IAAI,EAAE,UAAU,IAAI,EAAE,SAC3C,IAAI,IAAI,EAAE,WAAW,KAAK,EAAE,UAAU,QAAQ,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI;EAC9D,OAAO,KAAK,EAAE,EAAE;EAChB;CACF,OAAO,IAAI,IAAI,EAAE,WAAW,KAAK,EAAE,UAAU,QAAQ,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI;EACrE,OAAO,KAAK,EAAE,EAAE;EAChB;CACF,OAAO;EAEL,OAAO,KAAK,EAAE,EAAE;EAChB;EACA;CACF;CAEF,OAAO;AACT;AAyBA,eAAsB,kBACpB,UACA,gBACyB;CAGzB,MAAM,OAAO,wBAAwB,cAAc;CAEnD,MAAM,YAAY,WAAW,IAAI;CACjC,MAAM,QAAQ,SAAS,YAAY,WAAW,CAAC,CAAC;CAChD,MAAM,SAAS,SAAS,KAAK;CAC7B,MAAM,SAAS,QAAQ,2BAA2B,MAAM,IAAI;CAC5D,OAAO;AACT;AAEA,eAAsB,kBACpB,SACyB;CACzB,MAAM,OAAO,MAAM,QAAQ,QAAQ,yBAAyB;CAC5D,IAAI,SAAS,KAAA,GACX,OAAO,CAAC;CAIV,MAAM,MAAM,MAAO,MAFC,QAAQ,aAAa,IAAI,GAEpB,MAAM,oBAAoB;CACnD,IAAI,CAAC,IAAI,IAGP,OAAO,CAAC;CAGV,OAAO,IAAI;AACb;;;;;AAMA,eAAsB,kBACpB,UACA,qBACyB;CAGzB,OAAO,kBACL,UACA,oBAAoB,MAJU,kBAAkB,QAAQ,GAIjB,mBAAmB,CAC5D;AACF;AAaA,eAAsB,sBACpB,UACA,kBACA,uBACyB;CACzB,MAAM,qBAAqB,IAAI,IAAI,gBAAgB;CACnD,MAAM,0BAA0B,IAAI,IAAI,qBAAqB;CAC7D,MAAM,oBAAoB,MAAM,kBAAkB,QAAQ;CAC1D,MAAM,UAAU,IAAI,IAAI,MAAM,WAAW,QAAQ,CAAC;CAClD,KAAK,MAAM,YAAY,kBACrB,QAAQ,OAAO,QAAQ;CAEzB,KAAK,MAAM,iBAAiB,uBAC1B,KAAK,MAAM,CAAC,UAAU,WAAW,SAC/B,IAAI,OAAO,kBAAkB,eAC3B,QAAQ,OAAO,QAAQ;CAK7B,MAAM,WAAW,SAAS,QAAQ;CAElC,OAAO,kBACL,UACA,kBAAkB,QACf,EAAC,eAAe,eACf,CAAC,wBAAwB,IAAI,aAAa,KAC1C,CAAC,mBAAmB,IAAI,QAAQ,CACpC,CACF;AACF"}

package/out/replicache/src/error-responses.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-responses.js","names":[],"sources":["../../../../replicache/src/error-responses.ts"],"sourcesContent":["import {assert} from '../../shared/src/asserts.ts';\n\nfunction isError(obj: unknown, type: string): boolean {\n  return (\n    typeof obj === 'object' &&\n    obj !== null &&\n    (obj as {error: unknown}).error === type\n  );\n}\n\ntype ErrorResponse = {error: string};\n\nexport function isErrorResponse(obj: object): obj is ErrorResponse {\n  return typeof (obj as {error: unknown}).error === 'string';\n}\n\n/**\n * In certain scenarios the server can signal that it does not know about the\n * client. For example, the server might have lost all of its state (this might\n * happen during the development of the server).\n */\nexport type ClientStateNotFoundResponse = {\n  error: 'ClientStateNotFound';\n};\n\nexport function isClientStateNotFoundResponse(\n  v: unknown,\n): v is ClientStateNotFoundResponse {\n  return isError(v, 'ClientStateNotFound');\n}\n\n/**\n * The server endpoint may respond with a `VersionNotSupported` error if it does\n * not know how to handle the pull, push or schema version.\n */\nexport type VersionNotSupportedResponse = {\n  error: 'VersionNotSupported';\n  versionType?: 'pull' | 'push' | 'schema' | undefined;\n};\n\nexport function isVersionNotSupportedResponse(\n  v: unknown,\n): v is VersionNotSupportedResponse {\n  if (!isError(v, 'VersionNotSupported')) {\n    return false;\n  }\n\n  const {versionType} = v as Record<string, unknown>;\n  switch (versionType) {\n    case undefined:\n    case 'pull':\n    case 'push':\n    case 'schema':\n      return true;\n  }\n\n  return false;\n}\n\nexport function assertVersionNotSupportedResponse(\n  v: unknown,\n): asserts v is VersionNotSupportedResponse {\n  assert(\n    isVersionNotSupportedResponse(v),\n    'Expected a VersionNotSupportedResponse',\n  );\n}\n"],"mappings":";;AAEA,SAAS,QAAQ,KAAc,MAAuB;CACpD,OACE,OAAO,QAAQ,YACf,QAAQ,QACP,IAAyB,UAAU;AAExC;AAIA,SAAgB,gBAAgB,KAAmC;CACjE,OAAO,OAAQ,IAAyB,UAAU;AACpD;AAWA,SAAgB,8BACd,GACkC;CAClC,OAAO,QAAQ,GAAG,qBAAqB;AACzC;AAWA,SAAgB,8BACd,GACkC;CAClC,IAAI,CAAC,QAAQ,GAAG,qBAAqB,GACnC,OAAO;CAGT,MAAM,EAAC,gBAAe;CACtB,QAAQ,aAAR;EACE,KAAK,KAAA;EACL,KAAK;EACL,KAAK;EACL,KAAK,UACH,OAAO;CACX;CAEA,OAAO;AACT;AAEA,SAAgB,kCACd,GAC0C;CAC1C,OACE,8BAA8B,CAAC,GAC/B,wCACF;AACF"}

package/out/replicache/src/frozen-json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"frozen-json.js","names":[],"sources":["../../../../replicache/src/frozen-json.ts"],"sourcesContent":["import {throwInvalidType} from '../../shared/src/asserts.ts';\nimport {skipAssertJSONValue} from '../../shared/src/config.ts';\nimport {hasOwn} from '../../shared/src/has-own.ts';\nimport type {\n  ReadonlyJSONObject,\n  ReadonlyJSONValue,\n} from '../../shared/src/json.ts';\nimport {skipFreeze, skipFrozenAsserts} from './config.ts';\nimport type {Cookie, FrozenCookie} from './cookies.ts';\n\ndeclare const frozenJSONTag: unique symbol;\n\n/**\n * Used to mark a type as having been frozen.\n */\nexport type FrozenTag<T> = T & {readonly [frozenJSONTag]: true};\n\nexport type FrozenJSONValue =\n  | null\n  | string\n  | boolean\n  | number\n  | FrozenJSONArray\n  | FrozenJSONObject;\n\ntype FrozenJSONArray = FrozenTag<ReadonlyArray<FrozenJSONValue>>;\n\nexport type FrozenJSONObject = FrozenTag<{\n  readonly [key: string]: FrozenJSONValue;\n}>;\n\n/**\n * We tag deep frozen objects in debug mode so that we do not have to deep\n * freeze an object more than once.\n */\nconst deepFrozenObjects = new WeakSet<object>();\n\n/**\n * Recursively freezes the passed in value (mutates it) and returns it.\n *\n * This is controlled by `skipFreeze` which is true in release mode.\n */\nexport function deepFreeze(v: Cookie): FrozenCookie;\nexport function deepFreeze(v: ReadonlyJSONValue): FrozenJSONValue;\nexport function deepFreeze(v: ReadonlyJSONValue): FrozenJSONValue {\n  if (skipFreeze) {\n    return v as FrozenJSONValue;\n  }\n\n  deepFreezeInternal(v, []);\n  return v as FrozenJSONValue;\n}\n\nfunction deepFreezeInternal(\n  v: ReadonlyJSONValue | undefined,\n  seen: object[],\n): void {\n  switch (typeof v) {\n    case 'undefined':\n      throw new TypeError('Unexpected value undefined');\n    case 'boolean':\n    case 'number':\n    case 'string':\n      return;\n    case 'object': {\n      if (v === null) {\n        return;\n      }\n\n      if (deepFrozenObjects.has(v)) {\n        return;\n      }\n      deepFrozenObjects.add(v);\n\n      if (seen.includes(v)) {\n        throwInvalidType(v, 'Cyclic JSON object');\n      }\n\n      seen.push(v);\n\n      Object.freeze(v);\n      if (Array.isArray(v)) {\n        deepFreezeArray(v, seen);\n      } else {\n        deepFreezeObject(v as ReadonlyJSONObject, seen);\n      }\n      seen.pop();\n      return;\n    }\n\n    default:\n      throwInvalidType(v, 'JSON value');\n  }\n}\n\nfunction deepFreezeArray(\n  v: ReadonlyArray<ReadonlyJSONValue>,\n  seen: object[],\n): void {\n  for (const item of v) {\n    deepFreezeInternal(item, seen);\n  }\n}\n\nfunction deepFreezeObject(v: ReadonlyJSONObject, seen: object[]): void {\n  for (const k in v) {\n    if (hasOwn(v, k)) {\n      const value = v[k];\n      if (value !== undefined) {\n        deepFreezeInternal(value, seen);\n      }\n    }\n  }\n}\n\nexport function assertFrozenJSONValue(\n  v: unknown,\n): asserts v is FrozenJSONValue {\n  if (skipFrozenAsserts || skipAssertJSONValue) {\n    return;\n  }\n\n  switch (typeof v) {\n    case 'boolean':\n    case 'number':\n    case 'string':\n      return;\n    case 'object':\n      if (v === null) {\n        return;\n      }\n\n      if (isDeepFrozen(v, [])) {\n        return;\n      }\n  }\n  throwInvalidType(v, 'JSON value');\n}\n\nexport function assertDeepFrozen<V>(v: V): asserts v is Readonly<V> {\n  if (skipFrozenAsserts) {\n    return;\n  }\n\n  if (!isDeepFrozen(v, [])) {\n    throw new Error('Expected frozen object');\n  }\n}\n\n/**\n * Recursive deep frozen check.\n *\n * It adds frozen objects to the {@link deepFrozenObjects} WeakSet so that we do\n * not have to check the same object more than once.\n */\nexport function isDeepFrozen(v: unknown, seen: object[]): boolean {\n  switch (typeof v) {\n    case 'boolean':\n    case 'number':\n    case 'string':\n      return true;\n    case 'object':\n      if (v === null) {\n        return true;\n      }\n\n      if (deepFrozenObjects.has(v)) {\n        return true;\n      }\n\n      if (!Object.isFrozen(v)) {\n        return false;\n      }\n\n      if (seen.includes(v)) {\n        throwInvalidType(v, 'Cyclic JSON object');\n      }\n\n      seen.push(v);\n\n      if (Array.isArray(v)) {\n        for (const item of v) {\n          if (!isDeepFrozen(item, seen)) {\n            seen.pop();\n            return false;\n          }\n        }\n      } else {\n        for (const k in v) {\n          if (hasOwn(v, k)) {\n            const value = (v as Record<string, unknown>)[k];\n            if (value !== undefined && !isDeepFrozen(value, seen)) {\n              seen.pop();\n              return false;\n            }\n          }\n        }\n      }\n\n      deepFrozenObjects.add(v);\n      seen.pop();\n      return true;\n\n    default:\n      throwInvalidType(v, 'JSON value');\n  }\n}\n\nexport type P = Parameters<typeof deepFreeze>[0];\nexport type R = ReturnType<typeof deepFreeze>;\nexport function deepFreezeAllowUndefined(v: P | undefined): R | undefined {\n  if (v === undefined) {\n    return undefined;\n  }\n  return deepFreeze(v) as R;\n}\n"],"mappings":";;;;;;;;;AAmCA,IAAM,oCAAoB,IAAI,QAAgB;AAS9C,SAAgB,WAAW,GAAuC;CAChE,IAAI,QACF,OAAO;CAGT,mBAAmB,GAAG,CAAC,CAAC;CACxB,OAAO;AACT;AAEA,SAAS,mBACP,GACA,MACM;CACN,QAAQ,OAAO,GAAf;EACE,KAAK,aACH,MAAM,IAAI,UAAU,4BAA4B;EAClD,KAAK;EACL,KAAK;EACL,KAAK,UACH;EACF,KAAK;GACH,IAAI,MAAM,MACR;GAGF,IAAI,kBAAkB,IAAI,CAAC,GACzB;GAEF,kBAAkB,IAAI,CAAC;GAEvB,IAAI,KAAK,SAAS,CAAC,GACjB,iBAAiB,GAAG,oBAAoB;GAG1C,KAAK,KAAK,CAAC;GAEX,OAAO,OAAO,CAAC;GACf,IAAI,MAAM,QAAQ,CAAC,GACjB,gBAAgB,GAAG,IAAI;QAEvB,iBAAiB,GAAyB,IAAI;GAEhD,KAAK,IAAI;GACT;EAGF,SACE,iBAAiB,GAAG,YAAY;CACpC;AACF;AAEA,SAAS,gBACP,GACA,MACM;CACN,KAAK,MAAM,QAAQ,GACjB,mBAAmB,MAAM,IAAI;AAEjC;AAEA,SAAS,iBAAiB,GAAuB,MAAsB;CACrE,KAAK,MAAM,KAAK,GACd,IAAI,OAAO,GAAG,CAAC,GAAG;EAChB,MAAM,QAAQ,EAAE;EAChB,IAAI,UAAU,KAAA,GACZ,mBAAmB,OAAO,IAAI;CAElC;AAEJ;AA0BA,SAAgB,iBAAoB,GAAgC;CAClE,IAAI,QACF;CAGF,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC,GACrB,MAAM,IAAI,MAAM,wBAAwB;AAE5C;;;;;;;AAQA,SAAgB,aAAa,GAAY,MAAyB;CAChE,QAAQ,OAAO,GAAf;EACE,KAAK;EACL,KAAK;EACL,KAAK,UACH,OAAO;EACT,KAAK;GACH,IAAI,MAAM,MACR,OAAO;GAGT,IAAI,kBAAkB,IAAI,CAAC,GACzB,OAAO;GAGT,IAAI,CAAC,OAAO,SAAS,CAAC,GACpB,OAAO;GAGT,IAAI,KAAK,SAAS,CAAC,GACjB,iBAAiB,GAAG,oBAAoB;GAG1C,KAAK,KAAK,CAAC;GAEX,IAAI,MAAM,QAAQ,CAAC;SACZ,MAAM,QAAQ,GACjB,IAAI,CAAC,aAAa,MAAM,IAAI,GAAG;KAC7B,KAAK,IAAI;KACT,OAAO;IACT;UAGF,KAAK,MAAM,KAAK,GACd,IAAI,OAAO,GAAG,CAAC,GAAG;IAChB,MAAM,QAAS,EAA8B;IAC7C,IAAI,UAAU,KAAA,KAAa,CAAC,aAAa,OAAO,IAAI,GAAG;KACrD,KAAK,IAAI;KACT,OAAO;IACT;GACF;GAIJ,kBAAkB,IAAI,CAAC;GACvB,KAAK,IAAI;GACT,OAAO;EAET,SACE,iBAAiB,GAAG,YAAY;CACpC;AACF;AAIA,SAAgB,yBAAyB,GAAiC;CACxE,IAAI,MAAM,KAAA,GACR;CAEF,OAAO,WAAW,CAAC;AACrB"}

package/out/replicache/src/get-default-puller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-default-puller.js","names":[],"sources":["../../../../replicache/src/get-default-puller.ts"],"sourcesContent":["import {\n  assertNumber,\n  assertObject,\n  assertString,\n} from '../../shared/src/asserts.ts';\nimport {callDefaultFetch} from './call-default-fetch.ts';\nimport {assertCookie} from './cookies.ts';\nimport {\n  isClientStateNotFoundResponse,\n  isVersionNotSupportedResponse,\n} from './error-responses.ts';\nimport {assertHTTPRequestInfo} from './http-request-info.ts';\nimport {assertPatchOperations} from './patch-operation.ts';\nimport type {\n  PullResponseV1,\n  Puller,\n  PullerResult,\n  PullerResultV1,\n} from './puller.ts';\nimport type {PullRequest} from './sync/pull.ts';\n\n/**\n * This creates a default puller which uses HTTP POST to send the pull request.\n */\nexport function getDefaultPuller(rep: {pullURL: string; auth: string}): Puller {\n  async function puller(\n    requestBody: PullRequest,\n    requestID: string,\n  ): Promise<PullerResult> {\n    const [response, httpRequestInfo] = await callDefaultFetch(\n      rep.pullURL,\n      rep.auth,\n      requestID,\n      requestBody,\n    );\n    if (!response) {\n      return {httpRequestInfo};\n    }\n\n    return {\n      response: await response.json(),\n      httpRequestInfo,\n    };\n  }\n\n  defaultPullers.add(puller);\n  return puller;\n}\n\nconst defaultPullers = new WeakSet();\n\nexport function isDefaultPuller(puller: Puller): boolean {\n  return defaultPullers.has(puller);\n}\n\nexport function assertPullResponseV1(v: unknown): asserts v is PullResponseV1 {\n  assertObject(v);\n  if (isClientStateNotFoundResponse(v) || isVersionNotSupportedResponse(v)) {\n    return;\n  }\n  if (v.cookie !== undefined) {\n    assertCookie(v.cookie);\n  }\n  assertLastMutationIDChanges(v.lastMutationIDChanges);\n  assertPatchOperations(v.patch);\n}\n\nfunction assertLastMutationIDChanges(\n  lastMutationIDChanges: unknown,\n): asserts lastMutationIDChanges is Record<string, number> {\n  assertObject(lastMutationIDChanges);\n  for (const [key, value] of Object.entries(lastMutationIDChanges)) {\n    assertString(key);\n    assertNumber(value);\n  }\n}\n\nexport function assertPullerResultV1(v: unknown): asserts v is PullerResultV1 {\n  assertObject(v);\n  assertHTTPRequestInfo(v.httpRequestInfo);\n  if (v.response !== undefined) {\n    assertPullResponseV1(v.response);\n  }\n}\n"],"mappings":";;;;;;;;;;AAwBA,SAAgB,iBAAiB,KAA8C;CAC7E,eAAe,OACb,aACA,WACuB;EACvB,MAAM,CAAC,UAAU,mBAAmB,MAAM,iBACxC,IAAI,SACJ,IAAI,MACJ,WACA,WACF;EACA,IAAI,CAAC,UACH,OAAO,EAAC,gBAAe;EAGzB,OAAO;GACL,UAAU,MAAM,SAAS,KAAK;GAC9B;EACF;CACF;CAEA,eAAe,IAAI,MAAM;CACzB,OAAO;AACT;AAEA,IAAM,iCAAiB,IAAI,QAAQ;AAEnC,SAAgB,gBAAgB,QAAyB;CACvD,OAAO,eAAe,IAAI,MAAM;AAClC;AAEA,SAAgB,qBAAqB,GAAyC;CAC5E,aAAa,CAAC;CACd,IAAI,8BAA8B,CAAC,KAAK,8BAA8B,CAAC,GACrE;CAEF,IAAI,EAAE,WAAW,KAAA,GACf,aAAa,EAAE,MAAM;CAEvB,4BAA4B,EAAE,qBAAqB;CACnD,sBAAsB,EAAE,KAAK;AAC/B;AAEA,SAAS,4BACP,uBACyD;CACzD,aAAa,qBAAqB;CAClC,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,qBAAqB,GAAG;EAChE,aAAa,GAAG;EAChB,aAAa,KAAK;CACpB;AACF;AAEA,SAAgB,qBAAqB,GAAyC;CAC5E,aAAa,CAAC;CACd,sBAAsB,EAAE,eAAe;CACvC,IAAI,EAAE,aAAa,KAAA,GACjB,qBAAqB,EAAE,QAAQ;AAEnC"}

package/out/replicache/src/get-default-pusher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-default-pusher.js","names":[],"sources":["../../../../replicache/src/get-default-pusher.ts"],"sourcesContent":["import {callDefaultFetch} from './call-default-fetch.ts';\nimport {\n  isClientStateNotFoundResponse,\n  isVersionNotSupportedResponse,\n} from './error-responses.ts';\nimport type {Pusher, PusherResult} from './pusher.ts';\nimport type {PushRequest} from './sync/push.ts';\n\n/**\n * This creates a default pusher which uses HTTP POST to send the push request.\n */\nexport function getDefaultPusher(rep: {pushURL: string; auth: string}): Pusher {\n  async function pusher(\n    requestBody: PushRequest,\n    requestID: string,\n  ): Promise<PusherResult> {\n    const [response, httpRequestInfo] = await callDefaultFetch(\n      rep.pushURL,\n      rep.auth,\n      requestID,\n      requestBody,\n    );\n    if (!response) {\n      return {httpRequestInfo};\n    }\n\n    const rv: PusherResult = {\n      httpRequestInfo,\n    };\n\n    let result;\n    try {\n      result = await response.json();\n    } catch {\n      // Ignore JSON parse errors. It is valid to return a non-JSON response.\n      return rv;\n    }\n\n    if (\n      isClientStateNotFoundResponse(result) ||\n      isVersionNotSupportedResponse(result)\n    ) {\n      rv.response = result;\n    }\n\n    return rv;\n  }\n\n  defaultPushers.add(pusher);\n  return pusher;\n}\n\nconst defaultPushers = new WeakSet();\n\nexport function isDefaultPusher(pusher: Pusher): boolean {\n  return defaultPushers.has(pusher);\n}\n"],"mappings":";;;;;;AAWA,SAAgB,iBAAiB,KAA8C;CAC7E,eAAe,OACb,aACA,WACuB;EACvB,MAAM,CAAC,UAAU,mBAAmB,MAAM,iBACxC,IAAI,SACJ,IAAI,MACJ,WACA,WACF;EACA,IAAI,CAAC,UACH,OAAO,EAAC,gBAAe;EAGzB,MAAM,KAAmB,EACvB,gBACF;EAEA,IAAI;EACJ,IAAI;GACF,SAAS,MAAM,SAAS,KAAK;EAC/B,QAAQ;GAEN,OAAO;EACT;EAEA,IACE,8BAA8B,MAAM,KACpC,8BAA8B,MAAM,GAEpC,GAAG,WAAW;EAGhB,OAAO;CACT;CAEA,eAAe,IAAI,MAAM;CACzB,OAAO;AACT;AAEA,IAAM,iCAAiB,IAAI,QAAQ;AAEnC,SAAgB,gBAAgB,QAAyB;CACvD,OAAO,eAAe,IAAI,MAAM;AAClC"}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","names":["#statement","#db","#filename","#statements"],"sources":["../../../../../../replicache/src/kv/expo-sqlite/store.ts"],"sourcesContent":["import {\n  deleteDatabaseSync,\n  openDatabaseSync,\n  type SQLiteDatabase as DB,\n  type SQLiteStatement,\n} from 'expo-sqlite';\nimport type {\n  PreparedStatement,\n  SQLiteDatabase,\n  SQLiteStoreOptions,\n} from '../sqlite-store.ts';\nimport {dropStore, SQLiteStore} from '../sqlite-store.ts';\nimport type {StoreProvider} from '../store.ts';\n\nexport type ExpoSQLiteStoreOptions = SQLiteStoreOptions;\n\nexport function dropExpoSQLiteStore(\n  name: string,\n  opts?: ExpoSQLiteStoreOptions,\n): Promise<void> {\n  return dropStore(name, filename => new ExpoSQLiteDatabase(filename), opts);\n}\n\n/**\n * Creates a StoreProvider for SQLite-based stores using expo-sqlite.\n * Supports shared connections between multiple store instances with the same name,\n * providing efficient resource utilization and proper transaction isolation.\n */\nexport function expoSQLiteStoreProvider(\n  opts?: ExpoSQLiteStoreOptions,\n): StoreProvider {\n  return {\n    create: name =>\n      new SQLiteStore(name, name => new ExpoSQLiteDatabase(name), opts),\n    drop: name => dropExpoSQLiteStore(name, opts),\n  };\n}\n\nclass ExpoSQLitePreparedStatement implements PreparedStatement {\n  readonly #statement: SQLiteStatement;\n\n  constructor(statement: SQLiteStatement) {\n    this.#statement = statement;\n  }\n\n  async exec(params: string[]): Promise<void> {\n    await this.#statement.executeForRawResultAsync(params);\n  }\n\n  async all(params: string[]): Promise<unknown[][]> {\n    const result = await this.#statement.executeForRawResultAsync(params);\n    return result.getAllAsync() as Promise<unknown[][]>;\n  }\n}\n\nclass ExpoSQLiteDatabase implements SQLiteDatabase {\n  readonly #db: DB;\n  readonly #filename: string;\n  readonly #statements: Set<SQLiteStatement> = new Set();\n\n  constructor(filename: string) {\n    this.#filename = filename;\n    this.#db = openDatabaseSync(filename);\n  }\n\n  close(): void {\n    for (const stmt of this.#statements) {\n      stmt.finalizeSync();\n    }\n    this.#db.closeSync();\n  }\n\n  destroy(): void {\n    deleteDatabaseSync(this.#filename);\n  }\n\n  prepare(sql: string): PreparedStatement {\n    const statement = this.#db.prepareSync(sql);\n    this.#statements.add(statement);\n    return new ExpoSQLitePreparedStatement(statement);\n  }\n\n  execSync(sql: string): void {\n    this.#db.execSync(sql);\n  }\n}\n"],"mappings":";;;AAgBA,SAAgB,oBACd,MACA,MACe;CACf,OAAO,UAAU,OAAM,aAAY,IAAI,mBAAmB,QAAQ,GAAG,IAAI;AAC3E;;;;;;AAOA,SAAgB,wBACd,MACe;CACf,OAAO;EACL,SAAQ,SACN,IAAI,YAAY,OAAM,SAAQ,IAAI,mBAAmB,IAAI,GAAG,IAAI;EAClE,OAAM,SAAQ,oBAAoB,MAAM,IAAI;CAC9C;AACF;AAEA,IAAM,8BAAN,MAA+D;CAC7D;CAEA,YAAY,WAA4B;EACtC,KAAKA,aAAa;CACpB;CAEA,MAAM,KAAK,QAAiC;EAC1C,MAAM,KAAKA,WAAW,yBAAyB,MAAM;CACvD;CAEA,MAAM,IAAI,QAAwC;EAEhD,QAAO,MADc,KAAKA,WAAW,yBAAyB,MAAM,GACtD,YAAY;CAC5B;AACF;AAEA,IAAM,qBAAN,MAAmD;CACjD;CACA;CACA,8BAA6C,IAAI,IAAI;CAErD,YAAY,UAAkB;EAC5B,KAAKE,YAAY;EACjB,KAAKD,MAAM,iBAAiB,QAAQ;CACtC;CAEA,QAAc;EACZ,KAAK,MAAM,QAAQ,KAAKE,aACtB,KAAK,aAAa;EAEpB,KAAKF,IAAI,UAAU;CACrB;CAEA,UAAgB;EACd,mBAAmB,KAAKC,SAAS;CACnC;CAEA,QAAQ,KAAgC;EACtC,MAAM,YAAY,KAAKD,IAAI,YAAY,GAAG;EAC1C,KAAKE,YAAY,IAAI,SAAS;EAC9B,OAAO,IAAI,4BAA4B,SAAS;CAClD;CAEA,SAAS,KAAmB;EAC1B,KAAKF,IAAI,SAAS,GAAG;CACvB;AACF"}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"new-client-channel.js","names":[],"sources":["../../../../replicache/src/new-client-channel.ts"],"sourcesContent":["import {BroadcastChannel} from '../../shared/src/broadcast-channel.ts';\nimport type {Read, Store} from './dag/store.ts';\nimport {getClientGroup} from './persist/client-groups.ts';\nimport {withRead} from './with-transactions.ts';\n\n// Older clients (<= replicache@13.0.1), listened on this channel name\n// and *asserted* that the messages received were an array containing exactly\n// one string.\nfunction makeChannelNameV0(replicacheName: string): string {\n  return `replicache-new-client-group:${replicacheName}`;\n}\n\n// This channel name was introduced when we first needed to change the message\n// format.  The design of the messages sent on this channel allows for\n// the message content to be extended in the future in a way that is\n// forward and backwards compatible.  The message format can be extended\n// by adding new *optional* fields.\nfunction makeChannelNameV1(replicacheName: string): string {\n  return `replicache-new-client-group-v1:${replicacheName}`;\n}\n\nexport {\n  makeChannelNameV0 as makeChannelNameV0ForTesting,\n  makeChannelNameV1 as makeChannelNameV1ForTesting,\n};\n\n// This message type can be extended with optional properties.\ntype NewClientChannelMessageV1 = {clientGroupID: string; idbName: string};\n\nfunction isNewClientChannelMessageV1(\n  message: unknown,\n): message is NewClientChannelMessageV1 {\n  return (\n    typeof message === 'object' &&\n    typeof (message as {clientGroupID: unknown}).clientGroupID === 'string' &&\n    typeof (message as {idbName: unknown}).idbName === 'string'\n  );\n}\n\nexport function initNewClientChannel(\n  replicacheName: string,\n  idbName: string,\n  signal: AbortSignal,\n  clientGroupID: string,\n  isNewClientGroup: boolean,\n  onUpdateNeeded: () => void,\n  perdag: Store,\n) {\n  if (signal.aborted) {\n    return;\n  }\n\n  const channelV1 = new BroadcastChannel(makeChannelNameV1(replicacheName));\n  if (isNewClientGroup) {\n    channelV1.postMessage({clientGroupID, idbName});\n    // Send expected format to V0 channel for old clients.\n    const channelV0 = new BroadcastChannel(makeChannelNameV0(replicacheName));\n    channelV0.postMessage([clientGroupID]);\n    channelV0.close();\n  }\n\n  channelV1.onmessage = async (e: MessageEvent) => {\n    const {data} = e;\n    if (isNewClientChannelMessageV1(data)) {\n      const {clientGroupID: newClientGroupID, idbName: newClientIDBName} = data;\n      if (newClientGroupID !== clientGroupID) {\n        if (newClientIDBName === idbName) {\n          // Check if this client can see the new client's newClientGroupID in its\n          // perdag. It should be able to if the clients share persistent\n          // storage. However, with `ReplicacheOption.kvStore`\n          // and `IDBStoreWithMemFallback` clients may not actually share\n          // persistent storage.  If storage is not shared, then there is no point\n          // in updating, since clients cannot sync locally.  If clients do update\n          // in this case, they can continually cause each other to update, since\n          // on each update the clients get assigned a new client group.\n          const updateNeeded = await withRead(\n            perdag,\n            async (perdagRead: Read) =>\n              (await getClientGroup(newClientGroupID, perdagRead)) !==\n              undefined,\n          );\n          if (updateNeeded) {\n            onUpdateNeeded();\n          }\n        } else {\n          // Idb name is different, indicating new schema or format version.\n          // Update to get assigned to newClientIDBName, and hopefully\n          // newClientGroupID.\n          // If storage is not actually shared (i.e. due to\n          // `ReplicacheOption.kvStore`\n          // or `IDBStoreWithMemFallback`) the new client will not\n          // get assigned to newClientGroupID, but should get the\n          // newClientIDBName.\n          // Note: we don't try to read from newClientIDBName to see\n          // if this client shares storage with the new client, because\n          // the newClientIDBName may have a format version this client\n          // cannot read.\n          onUpdateNeeded();\n          return;\n        }\n      }\n    }\n  };\n\n  signal.addEventListener('abort', () => channelV1.close(), {once: true});\n}\n"],"mappings":";;;;AAQA,SAAS,kBAAkB,gBAAgC;CACzD,OAAO,+BAA+B;AACxC;AAOA,SAAS,kBAAkB,gBAAgC;CACzD,OAAO,kCAAkC;AAC3C;AAUA,SAAS,4BACP,SACsC;CACtC,OACE,OAAO,YAAY,YACnB,OAAQ,QAAqC,kBAAkB,YAC/D,OAAQ,QAA+B,YAAY;AAEvD;AAEA,SAAgB,qBACd,gBACA,SACA,QACA,eACA,kBACA,gBACA,QACA;CACA,IAAI,OAAO,SACT;CAGF,MAAM,YAAY,IAAI,GAAiB,kBAAkB,cAAc,CAAC;CACxE,IAAI,kBAAkB;EACpB,UAAU,YAAY;GAAC;GAAe;EAAO,CAAC;EAE9C,MAAM,YAAY,IAAI,GAAiB,kBAAkB,cAAc,CAAC;EACxE,UAAU,YAAY,CAAC,aAAa,CAAC;EACrC,UAAU,MAAM;CAClB;CAEA,UAAU,YAAY,OAAO,MAAoB;EAC/C,MAAM,EAAC,SAAQ;EACf,IAAI,4BAA4B,IAAI,GAAG;GACrC,MAAM,EAAC,eAAe,kBAAkB,SAAS,qBAAoB;GACrE,IAAI,qBAAqB,eACvB,IAAI,qBAAqB;QAenB,MANuB,SACzB,QACA,OAAO,eACJ,MAAM,eAAe,kBAAkB,UAAU,MAClD,KAAA,CACJ,GAEE,eAAe;GAAA,OAEZ;IAaL,eAAe;IACf;GACF;EAEJ;CACF;CAEA,OAAO,iBAAiB,eAAe,UAAU,MAAM,GAAG,EAAC,MAAM,KAAI,CAAC;AACxE"}