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

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

@@ -0,0 +1,515 @@
+import { RWLock } from "@rocicorp/lock";
+import { joinIterables } from "../../../shared/src/iterables.js";
+import { promiseVoid } from "../../../shared/src/resolved-promises.js";
+import { getSizeOfValue } from "../../../shared/src/size-of-value.js";
+import { createChunk } from "./chunk.js";
+import { computeRefCountUpdates } from "./gc.js";
+import { mustGetChunk } from "./store.js";
+class LazyStore {
+  /**
+   * This lock is used to ensure correct isolation of Reads and Writes.
+   * Multiple Reads are allowed in parallel but only a single Write.  Reads and
+   * Writes see an isolated view of the store (corresponding to the Serializable
+   * level of transaction isolation defined in the SQL standard).
+   *
+   * To ensure these semantics the read lock must be acquired when a Read is
+   * created and held til it is closed, and a Write lock must be acquired when a
+   * Write is created and held til it is committed or closed.
+   *
+   * Code must have a read or write lock to
+   * - read `_heads`
+   * - read `_memOnlyChunks`
+   * - read `_sourceStore`
+   * - read and write `_sourceChunksCache`
+   * - read and write `_refCounts`
+   * - read and write `_refs`
+   * and must have a write lock to
+   * - write `_heads`
+   * - write `_memOnlyChunks`
+   */
+  #rwLock = new RWLock();
+  #heads = /* @__PURE__ */ new Map();
+  #sourceStore;
+  #chunkHasher;
+  #assertValidHash;
+  /** The following are protected so testing subclass can access. */
+  _memOnlyChunks = /* @__PURE__ */ new Map();
+  _sourceChunksCache;
+  /**
+   * Ref counts are maintained so that chunks which are unreachable
+   * from this stores heads can be eagerly and deterministically deleted from
+   * `this._memOnlyChunks` and `this._sourceChunksCache`.
+   *
+   * These ref counts are independent from `this._sourceStore`'s ref counts.
+   * These ref counts are based on reachability from `this._heads`.
+   * A chunk is deleted from `this._memOnlyChunks` or
+   * `this._sourceChunksCache` (which ever it is in) when its ref count becomes
+   * zero.
+   * These ref counts count the refs in `this._heads` and `this._refs`.
+   *
+   * Not all reachable chunk's refs are included in `this._refs`, because this
+   * would require loading all chunks reachable in the source store in a
+   * non-lazy manner. `this._refs` contains the refs of all currently reachable
+   * chunks that were ever in `this._memOnlyChunks` or
+   * `this._sourceChunksCache` (even if they have been evicted).  A
+   * chunk's ref information is lazily discovered and stored in `this._refs` and
+   * counted in `this._refCounts`. A chunk's entries in `this._refs` and
+   * `this._refCounts` are only deleted when a chunk is deleted due to it
+   * becoming unreachable (it is not deleted if the chunk is evicted from the
+   * source-store cache).
+   *
+   * The major implication of this lazy discovery of source store refs, is that
+   * a reachable source store chunk may not be cached when loaded, because it is
+   * not known to be reachable because some of the pertinent refs have not been
+   * discovered.  However, in practice chunks are read by traversing the graph
+   * starting from a head, and all pertinent refs are discovered as part of the
+   * traversal.
+   *
+   * These ref counts can be changed in two ways:
+   * 1. A LazyRead has a cache miss and loads a chunk from the source store that
+   * is reachable from this._heads.  If this chunk's refs are not currently
+   * counted, it will not have an entry in `this._refs`.  In this case, the
+   * chunks refs will be put in `this._refs` and `this._refCounts` will be
+   * updated to count them.
+   * 2. A LazyWrite commit updates a head (which can result in increasing or
+   * decreasing ref count) or puts a reachable chunk (either a `memory-only` or
+   * `source` chunk) that references this hash (increasing ref count).  The
+   * computation of these ref count changes is delegated to the
+   * `computeRefCountUpdates` shared with dag.StoreImpl.  In order to
+   * delegate determining reachability to `computeRefCountUpdates` and defer
+   * this determination until commit time, LazyWrite treats cache misses
+   * as a 'put' of the lazily-loaded chunk.
+   *
+   * A chunk's hash may have an entry in `this._refCounts` without that
+   * chunk have ever been in `this._memOnlyChunks` or `this._sourceChunksCache`.
+   * This is the case when a head or a reachable chunk that was ever in
+   * `this._memOnlyChunks` or `this._sourceChunksCache` references a chunk
+   * which is not currently cached (either because it has not been read, or
+   * because it has been evicted).
+   */
+  _refCounts = /* @__PURE__ */ new Map();
+  _refs = /* @__PURE__ */ new Map();
+  constructor(sourceStore, sourceCacheSizeLimit, chunkHasher, assertValidHash, getSizeOfChunk = getSizeOfValue) {
+    this._sourceChunksCache = new ChunksCache(
+      sourceCacheSizeLimit,
+      getSizeOfChunk,
+      this._refCounts,
+      this._refs
+    );
+    this.#sourceStore = sourceStore;
+    this.#chunkHasher = chunkHasher;
+    this.#assertValidHash = assertValidHash;
+  }
+  async read(sourceRead) {
+    const release = await this.#rwLock.read();
+    return new LazyRead(
+      this.#heads,
+      this._memOnlyChunks,
+      this._sourceChunksCache,
+      this.#sourceStore,
+      release,
+      this.#assertValidHash,
+      sourceRead
+    );
+  }
+  async write() {
+    const release = await this.#rwLock.write();
+    return new LazyWrite(
+      this.#heads,
+      this._memOnlyChunks,
+      this._sourceChunksCache,
+      this.#sourceStore,
+      this._refCounts,
+      this._refs,
+      release,
+      this.#chunkHasher,
+      this.#assertValidHash
+    );
+  }
+  close() {
+    return promiseVoid;
+  }
+  /**
+   * Does not acquire any lock on the store.
+   */
+  isCached(chunkHash) {
+    return this._sourceChunksCache.getWithoutUpdatingLRU(chunkHash) !== void 0;
+  }
+  withSuspendedSourceCacheEvictsAndDeletes(fn) {
+    return this._sourceChunksCache.withSuspendedEvictsAndDeletes(fn);
+  }
+}
+class LazyRead {
+  _heads;
+  _memOnlyChunks;
+  _sourceChunksCache;
+  _sourceStore;
+  #sourceRead = void 0;
+  #release;
+  #closed = false;
+  assertValidHash;
+  #sourceReadOwnedByCaller;
+  constructor(heads, memOnlyChunks, sourceChunksCache, sourceStore, release, assertValidHash, sourceRead) {
+    this._heads = heads;
+    this._memOnlyChunks = memOnlyChunks;
+    this._sourceChunksCache = sourceChunksCache;
+    this._sourceStore = sourceStore;
+    this.#release = release;
+    this.assertValidHash = assertValidHash;
+    this.#sourceRead = sourceRead !== void 0 ? Promise.resolve(sourceRead) : void 0;
+    this.#sourceReadOwnedByCaller = sourceRead !== void 0;
+  }
+  isMemOnlyChunkHash(hash) {
+    return this._memOnlyChunks.has(hash);
+  }
+  async hasChunk(hash) {
+    return await this.getChunk(hash) !== void 0;
+  }
+  async getChunk(hash) {
+    const memOnlyChunk = this._memOnlyChunks.get(hash);
+    if (memOnlyChunk !== void 0) {
+      return memOnlyChunk;
+    }
+    let chunk = this._sourceChunksCache.get(hash);
+    if (chunk === void 0) {
+      chunk = await (await this._getSourceRead()).getChunk(hash);
+      if (chunk !== void 0) {
+        this._sourceChunksCache.put(chunk);
+      }
+    }
+    return chunk;
+  }
+  mustGetChunk(hash) {
+    return mustGetChunk(this, hash);
+  }
+  getHead(name) {
+    return Promise.resolve(this._heads.get(name));
+  }
+  release() {
+    if (!this.#closed) {
+      this.#release();
+      if (!this.#sourceReadOwnedByCaller) {
+        this.#sourceRead?.then((read) => read.release()).catch((_) => {
+        });
+      }
+      this.#closed = true;
+    }
+  }
+  get closed() {
+    return this.#closed;
+  }
+  _getSourceRead() {
+    if (!this.#sourceRead) {
+      this.#sourceRead = this._sourceStore.read();
+    }
+    return this.#sourceRead;
+  }
+}
+class LazyWrite extends LazyRead {
+  #refCounts;
+  #refs;
+  #chunkHasher;
+  _pendingHeadChanges = /* @__PURE__ */ new Map();
+  _pendingMemOnlyChunks = /* @__PURE__ */ new Map();
+  _pendingCachedChunks = /* @__PURE__ */ new Map();
+  #createdChunks = /* @__PURE__ */ new Set();
+  constructor(heads, memOnlyChunks, sourceChunksCache, sourceStore, refCounts, refs, release, chunkHasher, assertValidHash) {
+    super(
+      heads,
+      memOnlyChunks,
+      sourceChunksCache,
+      sourceStore,
+      release,
+      assertValidHash
+    );
+    this.#refCounts = refCounts;
+    this.#refs = refs;
+    this.#chunkHasher = chunkHasher;
+  }
+  createChunk = (data, refs) => {
+    const chunk = createChunk(data, refs, this.#chunkHasher);
+    this.#createdChunks.add(chunk.hash);
+    return chunk;
+  };
+  putChunk(c, size) {
+    const { hash, meta } = c;
+    this.assertValidHash(hash);
+    if (meta.length > 0) {
+      for (const h of meta) {
+        this.assertValidHash(h);
+      }
+    }
+    if (this.#createdChunks.has(hash) || this.isMemOnlyChunkHash(hash)) {
+      this._pendingMemOnlyChunks.set(hash, c);
+    } else {
+      this._pendingCachedChunks.set(hash, { chunk: c, size: size ?? -1 });
+    }
+    return promiseVoid;
+  }
+  async setHead(name, hash) {
+    await this.#setHead(name, hash);
+  }
+  async removeHead(name) {
+    await this.#setHead(name, void 0);
+  }
+  async #setHead(name, hash) {
+    const oldHash = await this.getHead(name);
+    const v = this._pendingHeadChanges.get(name);
+    if (v === void 0) {
+      this._pendingHeadChanges.set(name, { new: hash, old: oldHash });
+    } else {
+      v.new = hash;
+    }
+  }
+  isMemOnlyChunkHash(hash) {
+    return this._pendingMemOnlyChunks.has(hash) || super.isMemOnlyChunkHash(hash);
+  }
+  async getChunk(hash) {
+    const pendingMemOnlyChunk = this._pendingMemOnlyChunks.get(hash);
+    if (pendingMemOnlyChunk !== void 0) {
+      return pendingMemOnlyChunk;
+    }
+    const memOnlyChunk = this._memOnlyChunks.get(hash);
+    if (memOnlyChunk !== void 0) {
+      return memOnlyChunk;
+    }
+    const pendingCachedChunk = this._pendingCachedChunks.get(hash);
+    if (pendingCachedChunk !== void 0) {
+      return pendingCachedChunk.chunk;
+    }
+    let chunk = this._sourceChunksCache.get(hash);
+    if (chunk === void 0) {
+      chunk = await (await this._getSourceRead()).getChunk(hash);
+      if (chunk !== void 0) {
+        this._pendingCachedChunks.set(chunk.hash, { chunk, size: -1 });
+      }
+    }
+    return chunk;
+  }
+  getHead(name) {
+    const headChange = this._pendingHeadChanges.get(name);
+    if (headChange) {
+      return Promise.resolve(headChange.new);
+    }
+    return super.getHead(name);
+  }
+  async commit() {
+    const pendingChunks = new Set(
+      joinIterables(
+        this._pendingMemOnlyChunks.keys(),
+        this._pendingCachedChunks.keys()
+      )
+    );
+    const refCountUpdates = await computeRefCountUpdates(
+      this._pendingHeadChanges.values(),
+      pendingChunks,
+      this
+    );
+    for (const [hash, count] of refCountUpdates) {
+      if (this.isMemOnlyChunkHash(hash)) {
+        if (count === 0) {
+          this.#refCounts.delete(hash);
+          this._memOnlyChunks.delete(hash);
+          this.#refs.delete(hash);
+        } else {
+          this.#refCounts.set(hash, count);
+          const chunk = this._pendingMemOnlyChunks.get(hash);
+          if (chunk) {
+            this.#refs.set(hash, chunk.meta);
+            this._memOnlyChunks.set(hash, chunk);
+          }
+        }
+        refCountUpdates.delete(hash);
+      }
+    }
+    this._sourceChunksCache.updateForCommit(
+      this._pendingCachedChunks,
+      refCountUpdates
+    );
+    for (const [name, headChange] of this._pendingHeadChanges) {
+      if (headChange.new) {
+        this._heads.set(name, headChange.new);
+      } else {
+        this._heads.delete(name);
+      }
+    }
+    this._pendingMemOnlyChunks.clear();
+    this._pendingCachedChunks.clear();
+    this._pendingHeadChanges.clear();
+    this.release();
+  }
+  getRefCount(hash) {
+    return this.#refCounts.get(hash);
+  }
+  getRefs(hash) {
+    const pendingMemOnlyChunk = this._pendingMemOnlyChunks.get(hash);
+    if (pendingMemOnlyChunk) {
+      return pendingMemOnlyChunk.meta;
+    }
+    const memOnlyChunk = this._memOnlyChunks.get(hash);
+    if (memOnlyChunk) {
+      return memOnlyChunk.meta;
+    }
+    const pendingCachedChunk = this._pendingCachedChunks.get(hash);
+    if (pendingCachedChunk !== void 0) {
+      return pendingCachedChunk.chunk.meta;
+    }
+    return this.#refs.get(hash);
+  }
+  areRefsCounted(hash) {
+    return this.#refs.has(hash);
+  }
+  chunksPersisted(chunkHashes) {
+    const chunksToCache = [];
+    for (const chunkHash of chunkHashes) {
+      const chunk = this._memOnlyChunks.get(chunkHash);
+      if (chunk) {
+        this._memOnlyChunks.delete(chunkHash);
+        chunksToCache.push(chunk);
+      }
+    }
+    this._sourceChunksCache.persisted(chunksToCache);
+  }
+}
+class ChunksCache {
+  #cacheSizeLimit;
+  #getSizeOfChunk;
+  #refCounts;
+  #refs;
+  #size = 0;
+  #evictsAndDeletesSuspended = false;
+  #suspendedDeletes = [];
+  /**
+   * Iteration order is from least to most recently used.
+   *
+   * Public so that testing subclass can access.
+   */
+  cacheEntries = /* @__PURE__ */ new Map();
+  constructor(cacheSizeLimit, getSizeOfChunk, refCounts, refs) {
+    this.#cacheSizeLimit = cacheSizeLimit;
+    this.#getSizeOfChunk = getSizeOfChunk;
+    this.#refCounts = refCounts;
+    this.#refs = refs;
+  }
+  get(hash) {
+    const cacheEntry = this.cacheEntries.get(hash);
+    if (cacheEntry) {
+      this.cacheEntries.delete(hash);
+      this.cacheEntries.set(hash, cacheEntry);
+    }
+    return cacheEntry?.chunk;
+  }
+  getWithoutUpdatingLRU(hash) {
+    return this.cacheEntries.get(hash)?.chunk;
+  }
+  put(chunk) {
+    const { hash } = chunk;
+    const oldCacheEntry = this.cacheEntries.get(hash);
+    if (oldCacheEntry) {
+      this.cacheEntries.delete(hash);
+      this.cacheEntries.set(hash, oldCacheEntry);
+      return;
+    }
+    const refCount = this.#refCounts.get(hash);
+    if (refCount === void 0 || refCount < 1) {
+      return;
+    }
+    if (!this.#cacheChunk(chunk)) {
+      return;
+    }
+    if (!this.#refs.has(hash)) {
+      for (const refHash of chunk.meta) {
+        this.#refCounts.set(refHash, (this.#refCounts.get(refHash) || 0) + 1);
+      }
+      this.#refs.set(hash, chunk.meta);
+    }
+    this.#ensureCacheSizeLimit();
+  }
+  #ensureCacheSizeLimit() {
+    if (this.#evictsAndDeletesSuspended) {
+      return;
+    }
+    for (const entry of this.cacheEntries.values()) {
+      if (this.#size <= this.#cacheSizeLimit) {
+        break;
+      }
+      this.#evict(entry);
+    }
+  }
+  #cacheChunk(chunk, size) {
+    const chunkSize = size ?? this.#getSizeOfChunk(chunk);
+    if (chunkSize > this.#cacheSizeLimit) {
+      return false;
+    }
+    this.#size += chunkSize;
+    this.cacheEntries.set(chunk.hash, { chunk, size: chunkSize });
+    return true;
+  }
+  #evict(cacheEntry) {
+    const { hash } = cacheEntry.chunk;
+    this.#size -= cacheEntry.size;
+    this.cacheEntries.delete(hash);
+  }
+  #deleteEntryByHash(hash) {
+    this.#refCounts.delete(hash);
+    this.#refs.delete(hash);
+    const cacheEntry = this.cacheEntries.get(hash);
+    if (cacheEntry) {
+      this.#size -= cacheEntry.size;
+      this.cacheEntries.delete(hash);
+    }
+  }
+  updateForCommit(chunksToPut, refCountUpdates) {
+    for (const [hash, count] of refCountUpdates) {
+      if (count === 0) {
+        if (!this.#evictsAndDeletesSuspended) {
+          this.#deleteEntryByHash(hash);
+        } else {
+          this.#refCounts.set(hash, 0);
+          this.#suspendedDeletes.push(hash);
+        }
+      } else {
+        this.#refCounts.set(hash, count);
+        const chunkAndSize = chunksToPut.get(hash);
+        if (chunkAndSize) {
+          const { chunk, size } = chunkAndSize;
+          const oldCacheEntry = this.cacheEntries.get(hash);
+          if (oldCacheEntry) {
+            this.cacheEntries.delete(hash);
+            this.cacheEntries.set(hash, oldCacheEntry);
+          } else {
+            this.#cacheChunk(chunk, size !== -1 ? size : void 0);
+            this.#refs.set(hash, chunk.meta);
+          }
+        }
+      }
+    }
+    this.#ensureCacheSizeLimit();
+  }
+  persisted(chunks) {
+    for (const chunk of chunks) {
+      this.#cacheChunk(chunk);
+    }
+    this.#ensureCacheSizeLimit();
+  }
+  async withSuspendedEvictsAndDeletes(fn) {
+    this.#evictsAndDeletesSuspended = true;
+    try {
+      return await fn();
+    } finally {
+      this.#evictsAndDeletesSuspended = false;
+      for (const hash of this.#suspendedDeletes) {
+        if (this.#refCounts.get(hash) === 0) {
+          this.#deleteEntryByHash(hash);
+        }
+      }
+      this.#ensureCacheSizeLimit();
+    }
+  }
+}
+export {
+  LazyRead,
+  LazyStore,
+  LazyWrite
+};
+//# sourceMappingURL=lazy-store.js.map

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

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