@rocicorp/zero 0.26.1 → 0.26.2-canary.1

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

@@ -1 +1 @@
-{"version":3,"file":"lazy-store.js","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"],"names":[],"mappings":"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"}
+{"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

@@ -1,183 +1,152 @@
 import { assertNumber } from "../../../shared/src/asserts.js";
 import { assertHash } from "../hash.js";
-import { assertRefs, Chunk, createChunk } from "./chunk.js";
+import { Chunk, assertRefs, createChunk } from "./chunk.js";
 import { computeRefCountUpdates } from "./gc.js";
-import { chunkDataKey, chunkMetaKey, headKey, chunkRefCountKey } from "./key.js";
+import { chunkDataKey, chunkMetaKey, chunkRefCountKey, headKey } from "./key.js";
 import { mustGetChunk } from "./store.js";
-class StoreImpl {
-  #kv;
-  #chunkHasher;
-  #assertValidHash;
-  constructor(kv, chunkHasher, assertValidHash) {
-    this.#kv = kv;
-    this.#chunkHasher = chunkHasher;
-    this.#assertValidHash = assertValidHash;
-  }
-  async read() {
-    return new ReadImpl(await this.#kv.read(), this.#assertValidHash);
-  }
-  async write() {
-    return new WriteImpl(
-      await this.#kv.write(),
-      this.#chunkHasher,
-      this.#assertValidHash
-    );
-  }
-  close() {
-    return this.#kv.close();
-  }
-}
-class ReadImpl {
-  _tx;
-  assertValidHash;
-  constructor(kv, assertValidHash) {
-    this._tx = kv;
-    this.assertValidHash = assertValidHash;
-  }
-  hasChunk(hash) {
-    return this._tx.has(chunkDataKey(hash));
-  }
-  async getChunk(hash) {
-    const data = await this._tx.get(chunkDataKey(hash));
-    if (data === void 0) {
-      return void 0;
-    }
-    const refsVal = await this._tx.get(chunkMetaKey(hash));
-    let refs;
-    if (refsVal !== void 0) {
-      assertRefs(refsVal);
-      refs = refsVal;
-    } else {
-      refs = [];
-    }
-    return new Chunk(hash, data, refs);
-  }
-  mustGetChunk(hash) {
-    return mustGetChunk(this, hash);
-  }
-  async getHead(name) {
-    const data = await this._tx.get(headKey(name));
-    if (data === void 0) {
-      return void 0;
-    }
-    assertHash(data);
-    return data;
-  }
-  release() {
-    this._tx.release();
-  }
-  get closed() {
-    return this._tx.closed;
-  }
-}
-class WriteImpl extends ReadImpl {
-  #chunkHasher;
-  #putChunks = /* @__PURE__ */ new Set();
-  #changedHeads = /* @__PURE__ */ new Map();
-  constructor(kvw, chunkHasher, assertValidHash) {
-    super(kvw, assertValidHash);
-    this.#chunkHasher = chunkHasher;
-  }
-  createChunk = (data, refs) => createChunk(data, refs, this.#chunkHasher);
-  get kvWrite() {
-    return this._tx;
-  }
-  async putChunk(c) {
-    const { hash, data, meta } = c;
-    this.assertValidHash(hash);
-    const key = chunkDataKey(hash);
-    const p1 = this._tx.put(key, data);
-    let p2;
-    if (meta.length > 0) {
-      for (const h of meta) {
-        this.assertValidHash(h);
-      }
-      p2 = this._tx.put(chunkMetaKey(hash), meta);
-    }
-    this.#putChunks.add(hash);
-    await p1;
-    await p2;
-  }
-  setHead(name, hash) {
-    return this.#setHead(name, hash);
-  }
-  removeHead(name) {
-    return this.#setHead(name, void 0);
-  }
-  async #setHead(name, hash) {
-    const oldHash = await this.getHead(name);
-    const hk = headKey(name);
-    let p1;
-    if (hash === void 0) {
-      p1 = this._tx.del(hk);
-    } else {
-      p1 = this._tx.put(hk, hash);
-    }
-    const v = this.#changedHeads.get(name);
-    if (v === void 0) {
-      this.#changedHeads.set(name, { new: hash, old: oldHash });
-    } else {
-      v.new = hash;
-    }
-    await p1;
-  }
-  async commit() {
-    const refCountUpdates = await computeRefCountUpdates(
-      this.#changedHeads.values(),
-      this.#putChunks,
-      this
-    );
-    await this.#applyRefCountUpdates(refCountUpdates);
-    await this._tx.commit();
-  }
-  async getRefCount(hash) {
-    const value = await this._tx.get(chunkRefCountKey(hash));
-    if (value === void 0) {
-      return void 0;
-    }
-    assertNumber(value);
-    if (value < 0 || value > 65535 || value !== (value | 0)) {
-      throw new Error(
-        `Invalid ref count ${value}. We expect the value to be a Uint16`
-      );
-    }
-    return value;
-  }
-  async getRefs(hash) {
-    const meta = await this._tx.get(chunkMetaKey(hash));
-    if (meta === void 0) {
-      return [];
-    }
-    assertRefs(meta);
-    return meta;
-  }
-  async #applyRefCountUpdates(refCountCache) {
-    const ps = [];
-    for (const [hash, count] of refCountCache) {
-      if (count === 0) {
-        ps.push(this.#removeAllRelatedKeys(hash));
-      } else {
-        const refCountKey = chunkRefCountKey(hash);
-        ps.push(this._tx.put(refCountKey, count));
-      }
-    }
-    await Promise.all(ps);
-  }
-  async #removeAllRelatedKeys(hash) {
-    await Promise.all([
-      this._tx.del(chunkDataKey(hash)),
-      this._tx.del(chunkMetaKey(hash)),
-      this._tx.del(chunkRefCountKey(hash))
-    ]);
-    this.#putChunks.delete(hash);
-  }
-  release() {
-    this._tx.release();
-  }
-}
-export {
-  ReadImpl,
-  StoreImpl,
-  WriteImpl
+//#region ../replicache/src/dag/store-impl.ts
+var StoreImpl = class {
+	#kv;
+	#chunkHasher;
+	#assertValidHash;
+	constructor(kv, chunkHasher, assertValidHash) {
+		this.#kv = kv;
+		this.#chunkHasher = chunkHasher;
+		this.#assertValidHash = assertValidHash;
+	}
+	async read() {
+		return new ReadImpl(await this.#kv.read(), this.#assertValidHash);
+	}
+	async write() {
+		return new WriteImpl(await this.#kv.write(), this.#chunkHasher, this.#assertValidHash);
+	}
+	close() {
+		return this.#kv.close();
+	}
 };
-//# sourceMappingURL=store-impl.js.map
+var ReadImpl = class {
+	_tx;
+	assertValidHash;
+	constructor(kv, assertValidHash) {
+		this._tx = kv;
+		this.assertValidHash = assertValidHash;
+	}
+	hasChunk(hash) {
+		return this._tx.has(chunkDataKey(hash));
+	}
+	async getChunk(hash) {
+		const data = await this._tx.get(chunkDataKey(hash));
+		if (data === void 0) return;
+		const refsVal = await this._tx.get(chunkMetaKey(hash));
+		let refs;
+		if (refsVal !== void 0) {
+			assertRefs(refsVal);
+			refs = refsVal;
+		} else refs = [];
+		return new Chunk(hash, data, refs);
+	}
+	mustGetChunk(hash) {
+		return mustGetChunk(this, hash);
+	}
+	async getHead(name) {
+		const data = await this._tx.get(headKey(name));
+		if (data === void 0) return;
+		assertHash(data);
+		return data;
+	}
+	release() {
+		this._tx.release();
+	}
+	get closed() {
+		return this._tx.closed;
+	}
+};
+var WriteImpl = class extends ReadImpl {
+	#chunkHasher;
+	#putChunks = /* @__PURE__ */ new Set();
+	#changedHeads = /* @__PURE__ */ new Map();
+	constructor(kvw, chunkHasher, assertValidHash) {
+		super(kvw, assertValidHash);
+		this.#chunkHasher = chunkHasher;
+	}
+	createChunk = (data, refs) => createChunk(data, refs, this.#chunkHasher);
+	get kvWrite() {
+		return this._tx;
+	}
+	async putChunk(c) {
+		const { hash, data, meta } = c;
+		this.assertValidHash(hash);
+		const key = chunkDataKey(hash);
+		const p1 = this._tx.put(key, data);
+		let p2;
+		if (meta.length > 0) {
+			for (const h of meta) this.assertValidHash(h);
+			p2 = this._tx.put(chunkMetaKey(hash), meta);
+		}
+		this.#putChunks.add(hash);
+		await p1;
+		await p2;
+	}
+	setHead(name, hash) {
+		return this.#setHead(name, hash);
+	}
+	removeHead(name) {
+		return this.#setHead(name, void 0);
+	}
+	async #setHead(name, hash) {
+		const oldHash = await this.getHead(name);
+		const hk = headKey(name);
+		let p1;
+		if (hash === void 0) p1 = this._tx.del(hk);
+		else p1 = this._tx.put(hk, hash);
+		const v = this.#changedHeads.get(name);
+		if (v === void 0) this.#changedHeads.set(name, {
+			new: hash,
+			old: oldHash
+		});
+		else v.new = hash;
+		await p1;
+	}
+	async commit() {
+		const refCountUpdates = await computeRefCountUpdates(this.#changedHeads.values(), this.#putChunks, this);
+		await this.#applyRefCountUpdates(refCountUpdates);
+		await this._tx.commit();
+	}
+	async getRefCount(hash) {
+		const value = await this._tx.get(chunkRefCountKey(hash));
+		if (value === void 0) return;
+		assertNumber(value);
+		if (value < 0 || value > 65535 || value !== (value | 0)) throw new Error(`Invalid ref count ${value}. We expect the value to be a Uint16`);
+		return value;
+	}
+	async getRefs(hash) {
+		const meta = await this._tx.get(chunkMetaKey(hash));
+		if (meta === void 0) return [];
+		assertRefs(meta);
+		return meta;
+	}
+	async #applyRefCountUpdates(refCountCache) {
+		const ps = [];
+		for (const [hash, count] of refCountCache) if (count === 0) ps.push(this.#removeAllRelatedKeys(hash));
+		else {
+			const refCountKey = chunkRefCountKey(hash);
+			ps.push(this._tx.put(refCountKey, count));
+		}
+		await Promise.all(ps);
+	}
+	async #removeAllRelatedKeys(hash) {
+		await Promise.all([
+			this._tx.del(chunkDataKey(hash)),
+			this._tx.del(chunkMetaKey(hash)),
+			this._tx.del(chunkRefCountKey(hash))
+		]);
+		this.#putChunks.delete(hash);
+	}
+	release() {
+		this._tx.release();
+	}
+};
+//#endregion
+export { StoreImpl };
+
+//# sourceMappingURL=store-impl.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"store-impl.js","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 data = await this._tx.get(chunkDataKey(hash));\n    if (data === undefined) {\n      return undefined;\n    }\n\n    const refsVal = await this._tx.get(chunkMetaKey(hash));\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"],"names":[],"mappings":"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"}
+{"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 data = await this._tx.get(chunkDataKey(hash));\n    if (data === undefined) {\n      return undefined;\n    }\n\n    const refsVal = await this._tx.get(chunkMetaKey(hash));\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

@@ -1,27 +1,24 @@
 import { assert } from "../../../shared/src/asserts.js";
-class ChunkNotFoundError extends Error {
-  name = "ChunkNotFoundError";
-  hash;
-  constructor(hash) {
-    super(`Chunk not found ${hash}`);
-    this.hash = hash;
-  }
-}
+//#region ../replicache/src/dag/store.ts
+var ChunkNotFoundError = class extends Error {
+	name = "ChunkNotFoundError";
+	hash;
+	constructor(hash) {
+		super(`Chunk not found ${hash}`);
+		this.hash = hash;
+	}
+};
 async function mustGetChunk(store, hash) {
-  const chunk = await store.getChunk(hash);
-  if (chunk) {
-    return chunk;
-  }
-  throw new ChunkNotFoundError(hash);
+	const chunk = await store.getChunk(hash);
+	if (chunk) return chunk;
+	throw new ChunkNotFoundError(hash);
 }
 async function mustGetHeadHash(name, store) {
-  const hash = await store.getHead(name);
-  assert(hash, `Missing head ${name}`);
-  return hash;
+	const hash = await store.getHead(name);
+	assert(hash, `Missing head ${name}`);
+	return hash;
 }
-export {
-  ChunkNotFoundError,
-  mustGetChunk,
-  mustGetHeadHash
-};
-//# sourceMappingURL=store.js.map
+//#endregion
+export { ChunkNotFoundError, mustGetChunk, mustGetHeadHash };
+
+//# sourceMappingURL=store.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"store.js","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"],"names":[],"mappings":";AAkCO,MAAM,2BAA2B,MAAM;AAAA,EAC5C,OAAO;AAAA,EACE;AAAA,EACT,YAAY,MAAY;AACtB,UAAM,mBAAmB,IAAI,EAAE;AAC/B,SAAK,OAAO;AAAA,EACd;AACF;AAEA,eAAsB,aACpB,OACA,MACgB;AAChB,QAAM,QAAQ,MAAM,MAAM,SAAS,IAAI;AACvC,MAAI,OAAO;AACT,WAAO;AAAA,EACT;AACA,QAAM,IAAI,mBAAmB,IAAI;AACnC;AAEA,eAAsB,gBACpB,MACA,OACe;AACf,QAAM,OAAO,MAAM,MAAM,QAAQ,IAAI;AACrC,SAAO,MAAM,gBAAgB,IAAI,EAAE;AACnC,SAAO;AACT;"}
+{"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;AACtB,QAAM,mBAAmB,OAAO;AAChC,OAAK,OAAO;;;AAIhB,eAAsB,aACpB,OACA,MACgB;CAChB,MAAM,QAAQ,MAAM,MAAM,SAAS,KAAK;AACxC,KAAI,MACF,QAAO;AAET,OAAM,IAAI,mBAAmB,KAAK;;AAGpC,eAAsB,gBACpB,MACA,OACe;CACf,MAAM,OAAO,MAAM,MAAM,QAAQ,KAAK;AACtC,QAAO,MAAM,gBAAgB,OAAO;AACpC,QAAO"}

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

@@ -1,22 +1,24 @@
-class Visitor {
-  #seen = /* @__PURE__ */ new Set();
-  #dagRead;
-  constructor(dagRead) {
-    this.#dagRead = dagRead;
-  }
-  async visit(h) {
-    if (this.#seen.has(h)) {
-      return;
-    }
-    this.#seen.add(h);
-    const chunk = await this.#dagRead.mustGetChunk(h);
-    await this.visitChunk(chunk);
-  }
-  async visitChunk(chunk) {
-    await Promise.all(chunk.meta.map((ref) => this.visit(ref)));
-  }
-}
-export {
-  Visitor
+//#region ../replicache/src/dag/visitor.ts
+/**
+* A visitor walks the DAG starting at a given root and visits each chunk.
+*/
+var Visitor = class {
+	#seen = /* @__PURE__ */ new Set();
+	#dagRead;
+	constructor(dagRead) {
+		this.#dagRead = dagRead;
+	}
+	async visit(h) {
+		if (this.#seen.has(h)) return;
+		this.#seen.add(h);
+		const chunk = await this.#dagRead.mustGetChunk(h);
+		await this.visitChunk(chunk);
+	}
+	async visitChunk(chunk) {
+		await Promise.all(chunk.meta.map((ref) => this.visit(ref)));
+	}
 };
-//# sourceMappingURL=visitor.js.map
+//#endregion
+export { Visitor };
+
+//# sourceMappingURL=visitor.js.map