@rocicorp/zero 0.26.1-canary.9 → 0.26.2-canary.1

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

@@ -1 +1 @@
-{"version":3,"file":"cookies.js","sources":["../../../../replicache/src/cookies.ts"],"sourcesContent":["import {\n  assertJSONObject,\n  type ReadonlyJSONValue,\n} from '../../shared/src/json.ts';\nimport {stringCompare} from '../../shared/src/string-compare.ts';\nimport type {FrozenJSONValue} from './frozen-json.ts';\n\n/**\n * A cookie is a value that is used to determine the order of snapshots. It\n * needs to be comparable. This can be a `string`, `number` or if you want to\n * use a more complex value, you can use an object with an `order` property. The\n * value `null` is considered to be less than any other cookie and it is used\n * for the first pull when no cookie has been set.\n *\n * The order is the natural order of numbers and strings. If one of the cookies\n * is an object then the value of the `order` property is treated as the cookie\n * when doing comparison.\n *\n * If one of the cookies is a string and the other is a number, the number is\n * fist converted to a string (using `toString()`).\n */\nexport type Cookie =\n  | null\n  | string\n  | number\n  | (ReadonlyJSONValue & {readonly order: number | string});\n\nexport type FrozenCookie =\n  | null\n  | string\n  | number\n  | (FrozenJSONValue & {readonly order: number | string});\n\n/**\n * Compare two cookies.\n * `null` is considered to be less than any other cookie.\n */\nexport function compareCookies(a: Cookie, b: Cookie): number {\n  if (a === b) {\n    return 0;\n  }\n  if (a === null) {\n    return -1;\n  }\n  if (b === null) {\n    return 1;\n  }\n\n  const cva = getCompareValue(a);\n  const cvb = getCompareValue(b);\n\n  // If either a or b is a string. Compare by string.\n  if (typeof cva === 'string' || typeof cvb === 'string') {\n    return stringCompare(String(cva), String(cvb));\n  }\n\n  return cva - cvb;\n}\n\ntype NonNull<T> = T extends null ? never : T;\n\nfunction getCompareValue(cookie: NonNull<Cookie>): string | number {\n  if (typeof cookie === 'string' || typeof cookie === 'number') {\n    return cookie;\n  }\n  return cookie.order;\n}\n\nexport function assertCookie(v: unknown): asserts v is Cookie {\n  if (v === null || typeof v === 'string' || typeof v === 'number') {\n    return;\n  }\n\n  assertJSONObject(v);\n  if (typeof v.order === 'string' || typeof v.order === 'number') {\n    return;\n  }\n\n  throw new Error('Invalid cookie');\n}\n"],"names":[],"mappings":";;AAqCO,SAAS,eAAe,GAAW,GAAmB;AAC3D,MAAI,MAAM,GAAG;AACX,WAAO;AAAA,EACT;AACA,MAAI,MAAM,MAAM;AACd,WAAO;AAAA,EACT;AACA,MAAI,MAAM,MAAM;AACd,WAAO;AAAA,EACT;AAEA,QAAM,MAAM,gBAAgB,CAAC;AAC7B,QAAM,MAAM,gBAAgB,CAAC;AAG7B,MAAI,OAAO,QAAQ,YAAY,OAAO,QAAQ,UAAU;AACtD,WAAO,cAAc,OAAO,GAAG,GAAG,OAAO,GAAG,CAAC;AAAA,EAC/C;AAEA,SAAO,MAAM;AACf;AAIA,SAAS,gBAAgB,QAA0C;AACjE,MAAI,OAAO,WAAW,YAAY,OAAO,WAAW,UAAU;AAC5D,WAAO;AAAA,EACT;AACA,SAAO,OAAO;AAChB;AAEO,SAAS,aAAa,GAAiC;AAC5D,MAAI,MAAM,QAAQ,OAAO,MAAM,YAAY,OAAO,MAAM,UAAU;AAChE;AAAA,EACF;AAEA,mBAAiB,CAAC;AAClB,MAAI,OAAO,EAAE,UAAU,YAAY,OAAO,EAAE,UAAU,UAAU;AAC9D;AAAA,EACF;AAEA,QAAM,IAAI,MAAM,gBAAgB;AAClC;"}
+{"version":3,"file":"cookies.js","names":[],"sources":["../../../../replicache/src/cookies.ts"],"sourcesContent":["import {\n  assertJSONObject,\n  type ReadonlyJSONValue,\n} from '../../shared/src/json.ts';\nimport {stringCompare} from '../../shared/src/string-compare.ts';\nimport type {FrozenJSONValue} from './frozen-json.ts';\n\n/**\n * A cookie is a value that is used to determine the order of snapshots. It\n * needs to be comparable. This can be a `string`, `number` or if you want to\n * use a more complex value, you can use an object with an `order` property. The\n * value `null` is considered to be less than any other cookie and it is used\n * for the first pull when no cookie has been set.\n *\n * The order is the natural order of numbers and strings. If one of the cookies\n * is an object then the value of the `order` property is treated as the cookie\n * when doing comparison.\n *\n * If one of the cookies is a string and the other is a number, the number is\n * fist converted to a string (using `toString()`).\n */\nexport type Cookie =\n  | null\n  | string\n  | number\n  | (ReadonlyJSONValue & {readonly order: number | string});\n\nexport type FrozenCookie =\n  | null\n  | string\n  | number\n  | (FrozenJSONValue & {readonly order: number | string});\n\n/**\n * Compare two cookies.\n * `null` is considered to be less than any other cookie.\n */\nexport function compareCookies(a: Cookie, b: Cookie): number {\n  if (a === b) {\n    return 0;\n  }\n  if (a === null) {\n    return -1;\n  }\n  if (b === null) {\n    return 1;\n  }\n\n  const cva = getCompareValue(a);\n  const cvb = getCompareValue(b);\n\n  // If either a or b is a string. Compare by string.\n  if (typeof cva === 'string' || typeof cvb === 'string') {\n    return stringCompare(String(cva), String(cvb));\n  }\n\n  return cva - cvb;\n}\n\ntype NonNull<T> = T extends null ? never : T;\n\nfunction getCompareValue(cookie: NonNull<Cookie>): string | number {\n  if (typeof cookie === 'string' || typeof cookie === 'number') {\n    return cookie;\n  }\n  return cookie.order;\n}\n\nexport function assertCookie(v: unknown): asserts v is Cookie {\n  if (v === null || typeof v === 'string' || typeof v === 'number') {\n    return;\n  }\n\n  assertJSONObject(v);\n  if (typeof v.order === 'string' || typeof v.order === 'number') {\n    return;\n  }\n\n  throw new Error('Invalid cookie');\n}\n"],"mappings":";;;;;;;AAqCA,SAAgB,eAAe,GAAW,GAAmB;AAC3D,KAAI,MAAM,EACR,QAAO;AAET,KAAI,MAAM,KACR,QAAO;AAET,KAAI,MAAM,KACR,QAAO;CAGT,MAAM,MAAM,gBAAgB,EAAE;CAC9B,MAAM,MAAM,gBAAgB,EAAE;AAG9B,KAAI,OAAO,QAAQ,YAAY,OAAO,QAAQ,SAC5C,QAAO,cAAc,OAAO,IAAI,EAAE,OAAO,IAAI,CAAC;AAGhD,QAAO,MAAM;;AAKf,SAAS,gBAAgB,QAA0C;AACjE,KAAI,OAAO,WAAW,YAAY,OAAO,WAAW,SAClD,QAAO;AAET,QAAO,OAAO;;AAGhB,SAAgB,aAAa,GAAiC;AAC5D,KAAI,MAAM,QAAQ,OAAO,MAAM,YAAY,OAAO,MAAM,SACtD;AAGF,kBAAiB,EAAE;AACnB,KAAI,OAAO,EAAE,UAAU,YAAY,OAAO,EAAE,UAAU,SACpD;AAGF,OAAM,IAAI,MAAM,iBAAiB"}

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

@@ -1,59 +1,53 @@
-import { assertString, assert } from "../../../shared/src/asserts.js";
+import { assert, assertString } from "../../../shared/src/asserts.js";
 import { assertDeepFrozen } from "../frozen-json.js";
+//#region ../replicache/src/dag/chunk.ts
+/**
+* Convert to a Refs when we already know it is sorted and has no duplicates.
+*/
 function asRefs(sortedRefs) {
-  return sortedRefs;
+	return sortedRefs;
 }
+/**
+* Sorts and tags as Refs. If an Array is passed in the array is sorted in
+* place, otherwise a copy of the iterable is created. This checks for duplicates.
+*/
 function toRefs(refs) {
-  if (Array.isArray(refs)) {
-    refs.sort();
-    for (let i = 1; i < refs.length; i++) {
-      assert(refs[i - 1] !== refs[i], "Refs must not have duplicates");
-    }
-    return asRefs(refs);
-  }
-  const refsArray = [...refs];
-  refsArray.sort();
-  return asRefs(refsArray);
-}
-class Chunk {
-  hash;
-  data;
-  /**
-   * Meta is an array of refs. If there are no refs we do not write a meta
-   * chunk.
-   */
-  meta;
-  constructor(hash, data, refs) {
-    assert(
-      !refs.includes(hash),
-      "Chunk cannot reference itself"
-    );
-    assertDeepFrozen(data);
-    this.hash = hash;
-    this.data = data;
-    this.meta = refs;
-  }
+	if (Array.isArray(refs)) {
+		refs.sort();
+		for (let i = 1; i < refs.length; i++) assert(refs[i - 1] !== refs[i], "Refs must not have duplicates");
+		return asRefs(refs);
+	}
+	const refsArray = [...refs];
+	refsArray.sort();
+	return asRefs(refsArray);
 }
+var Chunk = class {
+	hash;
+	data;
+	/**
+	* Meta is an array of refs. If there are no refs we do not write a meta
+	* chunk.
+	*/
+	meta;
+	constructor(hash, data, refs) {
+		assert(!refs.includes(hash), "Chunk cannot reference itself");
+		assertDeepFrozen(data);
+		this.hash = hash;
+		this.data = data;
+		this.meta = refs;
+	}
+};
 function assertRefs(v) {
-  if (!Array.isArray(v)) {
-    throw new Error("Refs must be an array");
-  }
-  if (v.length > 0) {
-    assertString(v[0]);
-    for (let i = 1; i < v.length; i++) {
-      assertString(v[i]);
-    }
-  }
+	if (!Array.isArray(v)) throw new Error("Refs must be an array");
+	if (v.length > 0) {
+		assertString(v[0]);
+		for (let i = 1; i < v.length; i++) assertString(v[i]);
+	}
 }
 function createChunk(data, refs, chunkHasher) {
-  const hash = chunkHasher();
-  return new Chunk(hash, data, refs);
+	return new Chunk(chunkHasher(), data, refs);
 }
-export {
-  Chunk,
-  asRefs,
-  assertRefs,
-  createChunk,
-  toRefs
-};
-//# sourceMappingURL=chunk.js.map
+//#endregion
+export { Chunk, assertRefs, createChunk, toRefs };
+
+//# sourceMappingURL=chunk.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"chunk.js","sources":["../../../../../replicache/src/dag/chunk.ts"],"sourcesContent":["import {assert, assertString} from '../../../shared/src/asserts.ts';\nimport {assertDeepFrozen} from '../frozen-json.ts';\nimport type {Hash} from '../hash.ts';\n\n// By using declare we tell the type system that there is a unique symbol.\n// However, there is no such symbol but the type system does not care.\ndeclare const refsTag: unique symbol;\n\n/**\n * Opaque type representing a Refs. The reason to use an opaque type here is to\n * make sure that Refs are always sorted and have no duplicates.\n */\nexport type Refs = [] | readonly [Hash] | (readonly Hash[] & {[refsTag]: true});\n\n/**\n * Convert to a Refs when we already know it is sorted and has no duplicates.\n */\nexport function asRefs(sortedRefs: Hash[]): Refs {\n  return sortedRefs as unknown as Refs;\n}\n\n/**\n * Sorts and tags as Refs. If an Array is passed in the array is sorted in\n * place, otherwise a copy of the iterable is created. This checks for duplicates.\n */\nexport function toRefs(refs: Hash[] | Set<Hash>): Refs {\n  if (Array.isArray(refs)) {\n    refs.sort();\n    for (let i = 1; i < refs.length; i++) {\n      assert(refs[i - 1] !== refs[i], 'Refs must not have duplicates');\n    }\n    return asRefs(refs);\n  }\n\n  const refsArray = [...refs];\n  refsArray.sort();\n  // no need to check for duplicates as Set cannot have duplicates.\n  return asRefs(refsArray);\n}\n\nexport class Chunk<V = unknown> {\n  readonly hash: Hash;\n  readonly data: V;\n\n  /**\n   * Meta is an array of refs. If there are no refs we do not write a meta\n   * chunk.\n   */\n  readonly meta: Refs;\n\n  constructor(hash: Hash, data: V, refs: Refs) {\n    assert(\n      !(refs as unknown[]).includes(hash),\n      'Chunk cannot reference itself',\n    );\n    assertDeepFrozen(data);\n    this.hash = hash;\n    this.data = data;\n    this.meta = refs;\n  }\n}\n\nexport function assertRefs(v: unknown): asserts v is Refs {\n  if (!Array.isArray(v)) {\n    throw new Error('Refs must be an array');\n  }\n  if (v.length > 0) {\n    assertString(v[0]);\n    for (let i = 1; i < v.length; i++) {\n      assertString(v[i]);\n    }\n  }\n}\n\nexport function createChunk<V>(\n  data: V,\n  refs: Refs,\n  chunkHasher: ChunkHasher,\n): Chunk<V> {\n  const hash = chunkHasher();\n  return new Chunk(hash, data, refs);\n}\n\nexport type CreateChunk = <V>(data: V, refs: Refs) => Chunk<V>;\n\nexport type ChunkHasher = () => Hash;\n\nexport function throwChunkHasher(): Hash {\n  throw new Error('unexpected call to compute chunk hash');\n}\n"],"names":[],"mappings":";;AAiBO,SAAS,OAAO,YAA0B;AAC/C,SAAO;AACT;AAMO,SAAS,OAAO,MAAgC;AACrD,MAAI,MAAM,QAAQ,IAAI,GAAG;AACvB,SAAK,KAAA;AACL,aAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,aAAO,KAAK,IAAI,CAAC,MAAM,KAAK,CAAC,GAAG,+BAA+B;AAAA,IACjE;AACA,WAAO,OAAO,IAAI;AAAA,EACpB;AAEA,QAAM,YAAY,CAAC,GAAG,IAAI;AAC1B,YAAU,KAAA;AAEV,SAAO,OAAO,SAAS;AACzB;AAEO,MAAM,MAAmB;AAAA,EACrB;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA;AAAA,EAET,YAAY,MAAY,MAAS,MAAY;AAC3C;AAAA,MACE,CAAE,KAAmB,SAAS,IAAI;AAAA,MAClC;AAAA,IAAA;AAEF,qBAAiB,IAAI;AACrB,SAAK,OAAO;AACZ,SAAK,OAAO;AACZ,SAAK,OAAO;AAAA,EACd;AACF;AAEO,SAAS,WAAW,GAA+B;AACxD,MAAI,CAAC,MAAM,QAAQ,CAAC,GAAG;AACrB,UAAM,IAAI,MAAM,uBAAuB;AAAA,EACzC;AACA,MAAI,EAAE,SAAS,GAAG;AAChB,iBAAa,EAAE,CAAC,CAAC;AACjB,aAAS,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK;AACjC,mBAAa,EAAE,CAAC,CAAC;AAAA,IACnB;AAAA,EACF;AACF;AAEO,SAAS,YACd,MACA,MACA,aACU;AACV,QAAM,OAAO,YAAA;AACb,SAAO,IAAI,MAAM,MAAM,MAAM,IAAI;AACnC;"}
+{"version":3,"file":"chunk.js","names":[],"sources":["../../../../../replicache/src/dag/chunk.ts"],"sourcesContent":["import {assert, assertString} from '../../../shared/src/asserts.ts';\nimport {assertDeepFrozen} from '../frozen-json.ts';\nimport type {Hash} from '../hash.ts';\n\n// By using declare we tell the type system that there is a unique symbol.\n// However, there is no such symbol but the type system does not care.\ndeclare const refsTag: unique symbol;\n\n/**\n * Opaque type representing a Refs. The reason to use an opaque type here is to\n * make sure that Refs are always sorted and have no duplicates.\n */\nexport type Refs = [] | readonly [Hash] | (readonly Hash[] & {[refsTag]: true});\n\n/**\n * Convert to a Refs when we already know it is sorted and has no duplicates.\n */\nexport function asRefs(sortedRefs: Hash[]): Refs {\n  return sortedRefs as unknown as Refs;\n}\n\n/**\n * Sorts and tags as Refs. If an Array is passed in the array is sorted in\n * place, otherwise a copy of the iterable is created. This checks for duplicates.\n */\nexport function toRefs(refs: Hash[] | Set<Hash>): Refs {\n  if (Array.isArray(refs)) {\n    refs.sort();\n    for (let i = 1; i < refs.length; i++) {\n      assert(refs[i - 1] !== refs[i], 'Refs must not have duplicates');\n    }\n    return asRefs(refs);\n  }\n\n  const refsArray = [...refs];\n  refsArray.sort();\n  // no need to check for duplicates as Set cannot have duplicates.\n  return asRefs(refsArray);\n}\n\nexport class Chunk<V = unknown> {\n  readonly hash: Hash;\n  readonly data: V;\n\n  /**\n   * Meta is an array of refs. If there are no refs we do not write a meta\n   * chunk.\n   */\n  readonly meta: Refs;\n\n  constructor(hash: Hash, data: V, refs: Refs) {\n    assert(\n      !(refs as unknown[]).includes(hash),\n      'Chunk cannot reference itself',\n    );\n    assertDeepFrozen(data);\n    this.hash = hash;\n    this.data = data;\n    this.meta = refs;\n  }\n}\n\nexport function assertRefs(v: unknown): asserts v is Refs {\n  if (!Array.isArray(v)) {\n    throw new Error('Refs must be an array');\n  }\n  if (v.length > 0) {\n    assertString(v[0]);\n    for (let i = 1; i < v.length; i++) {\n      assertString(v[i]);\n    }\n  }\n}\n\nexport function createChunk<V>(\n  data: V,\n  refs: Refs,\n  chunkHasher: ChunkHasher,\n): Chunk<V> {\n  const hash = chunkHasher();\n  return new Chunk(hash, data, refs);\n}\n\nexport type CreateChunk = <V>(data: V, refs: Refs) => Chunk<V>;\n\nexport type ChunkHasher = () => Hash;\n\nexport function throwChunkHasher(): Hash {\n  throw new Error('unexpected call to compute chunk hash');\n}\n"],"mappings":";;;;;;AAiBA,SAAgB,OAAO,YAA0B;AAC/C,QAAO;;;;;;AAOT,SAAgB,OAAO,MAAgC;AACrD,KAAI,MAAM,QAAQ,KAAK,EAAE;AACvB,OAAK,MAAM;AACX,OAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,IAC/B,QAAO,KAAK,IAAI,OAAO,KAAK,IAAI,gCAAgC;AAElE,SAAO,OAAO,KAAK;;CAGrB,MAAM,YAAY,CAAC,GAAG,KAAK;AAC3B,WAAU,MAAM;AAEhB,QAAO,OAAO,UAAU;;AAG1B,IAAa,QAAb,MAAgC;CAC9B;CACA;;;;;CAMA;CAEA,YAAY,MAAY,MAAS,MAAY;AAC3C,SACE,CAAE,KAAmB,SAAS,KAAK,EACnC,gCACD;AACD,mBAAiB,KAAK;AACtB,OAAK,OAAO;AACZ,OAAK,OAAO;AACZ,OAAK,OAAO;;;AAIhB,SAAgB,WAAW,GAA+B;AACxD,KAAI,CAAC,MAAM,QAAQ,EAAE,CACnB,OAAM,IAAI,MAAM,wBAAwB;AAE1C,KAAI,EAAE,SAAS,GAAG;AAChB,eAAa,EAAE,GAAG;AAClB,OAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,IAC5B,cAAa,EAAE,GAAG;;;AAKxB,SAAgB,YACd,MACA,MACA,aACU;AAEV,QAAO,IAAI,MADE,aAAa,EACH,MAAM,KAAK"}

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

@@ -1,120 +1,100 @@
 import { assert, assertNumber } from "../../../shared/src/asserts.js";
 import { isProd } from "../../../shared/src/config.js";
+import "../config.js";
 import { emptyHash } from "../hash.js";
+//#region ../replicache/src/dag/gc.ts
+/**
+* Computes how ref counts should be updated when a dag write is committed.
+* Does not modify the dag store.
+* @param headChanges Heads that were changed by the dag write.
+* @param putChunks Chunks that were put by the dag write.
+* @param delegate Delegate used for getting ref information from the dag store.
+* @returns Map from chunk Hash to changed ref counts.  Chunks with a new ref
+* count of 0 should be deleted.  All hashes in `putChunks` will have an entry
+* (which will be zero if the newly put chunk is not reachable from any head).
+*/
 function computeRefCountUpdates(headChanges, putChunks, delegate) {
-  return new RefCountUpdates(headChanges, putChunks, delegate).compute();
+	return new RefCountUpdates(headChanges, putChunks, delegate).compute();
 }
-class RefCountUpdates {
-  #newHeads;
-  #oldHeads;
-  #putChunks;
-  #delegate;
-  #refsCounted;
-  #refCountUpdates;
-  #loadedRefCountPromises;
-  #isLazyDelegate;
-  constructor(headChanges, putChunks, delegate) {
-    const newHeads = [];
-    const oldHeads = [];
-    for (const changedHead of headChanges) {
-      if (changedHead.old !== changedHead.new) {
-        changedHead.old && oldHeads.push(changedHead.old);
-        changedHead.new && newHeads.push(changedHead.new);
-      }
-    }
-    this.#newHeads = newHeads;
-    this.#oldHeads = oldHeads;
-    this.#putChunks = putChunks;
-    this.#delegate = delegate;
-    this.#refCountUpdates = /* @__PURE__ */ new Map();
-    this.#loadedRefCountPromises = /* @__PURE__ */ new Map();
-    this.#isLazyDelegate = delegate.areRefsCounted !== void 0;
-    this.#refsCounted = this.#isLazyDelegate ? /* @__PURE__ */ new Set() : null;
-  }
-  async compute() {
-    for (const n of this.#newHeads) {
-      await this.#changeRefCount(n, 1);
-    }
-    await Promise.all(
-      Array.from(
-        this.#putChunks.values(),
-        (hash) => this.#ensureRefCountLoaded(hash)
-      )
-    );
-    if (this.#isLazyDelegate) {
-      assert(
-        this.#delegate.areRefsCounted,
-        "Expected delegate.areRefsCounted to be defined"
-      );
-      assert(this.#refsCounted, "Expected refsCounted to be defined");
-      let refCountsUpdated;
-      do {
-        refCountsUpdated = false;
-        for (const hash of this.#putChunks.values()) {
-          if (!this.#delegate.areRefsCounted(hash) && !this.#refsCounted.has(hash) && this.#refCountUpdates.get(hash) !== 0) {
-            await this.#updateRefsCounts(hash, 1);
-            refCountsUpdated = true;
-            break;
-          }
-        }
-      } while (refCountsUpdated);
-    }
-    for (const o of this.#oldHeads) {
-      await this.#changeRefCount(o, -1);
-    }
-    if (!isProd) {
-      for (const [hash, update] of this.#refCountUpdates) {
-        assert(
-          update >= 0,
-          `ref count update must be non-negative. ${hash}:${update}`
-        );
-      }
-    }
-    return this.#refCountUpdates;
-  }
-  async #changeRefCount(hash, delta) {
-    await this.#ensureRefCountLoaded(hash);
-    if (this.#updateRefCount(hash, delta)) {
-      await this.#updateRefsCounts(hash, delta);
-    }
-  }
-  async #updateRefsCounts(hash, delta) {
-    if (hash === emptyHash) {
-      return;
-    }
-    const refs = await this.#delegate.getRefs(hash);
-    if (!isProd) {
-      assert(
-        refs || this.#isLazyDelegate && !this.#putChunks.has(hash),
-        "refs must be defined"
-      );
-    }
-    if (refs !== void 0) {
-      this.#refsCounted?.add(hash);
-      const ps = refs.map((ref) => this.#changeRefCount(ref, delta));
-      await Promise.all(ps);
-    }
-  }
-  #ensureRefCountLoaded(hash) {
-    let p = this.#loadedRefCountPromises.get(hash);
-    if (p === void 0) {
-      p = (async () => {
-        const value = await this.#delegate.getRefCount(hash) || 0;
-        this.#refCountUpdates.set(hash, value);
-        return value;
-      })();
-      this.#loadedRefCountPromises.set(hash, p);
-    }
-    return p;
-  }
-  #updateRefCount(hash, delta) {
-    const oldCount = this.#refCountUpdates.get(hash);
-    assertNumber(oldCount);
-    this.#refCountUpdates.set(hash, oldCount + delta);
-    return oldCount === 0 && delta === 1 || oldCount === 1 && delta === -1;
-  }
-}
-export {
-  computeRefCountUpdates
+var RefCountUpdates = class {
+	#newHeads;
+	#oldHeads;
+	#putChunks;
+	#delegate;
+	#refsCounted;
+	#refCountUpdates;
+	#loadedRefCountPromises;
+	#isLazyDelegate;
+	constructor(headChanges, putChunks, delegate) {
+		const newHeads = [];
+		const oldHeads = [];
+		for (const changedHead of headChanges) if (changedHead.old !== changedHead.new) {
+			changedHead.old && oldHeads.push(changedHead.old);
+			changedHead.new && newHeads.push(changedHead.new);
+		}
+		this.#newHeads = newHeads;
+		this.#oldHeads = oldHeads;
+		this.#putChunks = putChunks;
+		this.#delegate = delegate;
+		this.#refCountUpdates = /* @__PURE__ */ new Map();
+		this.#loadedRefCountPromises = /* @__PURE__ */ new Map();
+		this.#isLazyDelegate = delegate.areRefsCounted !== void 0;
+		this.#refsCounted = this.#isLazyDelegate ? /* @__PURE__ */ new Set() : null;
+	}
+	async compute() {
+		for (const n of this.#newHeads) await this.#changeRefCount(n, 1);
+		await Promise.all(Array.from(this.#putChunks.values(), (hash) => this.#ensureRefCountLoaded(hash)));
+		if (this.#isLazyDelegate) {
+			assert(this.#delegate.areRefsCounted, "Expected delegate.areRefsCounted to be defined");
+			assert(this.#refsCounted, "Expected refsCounted to be defined");
+			let refCountsUpdated;
+			do {
+				refCountsUpdated = false;
+				for (const hash of this.#putChunks.values()) if (!this.#delegate.areRefsCounted(hash) && !this.#refsCounted.has(hash) && this.#refCountUpdates.get(hash) !== 0) {
+					await this.#updateRefsCounts(hash, 1);
+					refCountsUpdated = true;
+					break;
+				}
+			} while (refCountsUpdated);
+		}
+		for (const o of this.#oldHeads) await this.#changeRefCount(o, -1);
+		if (!isProd) for (const [hash, update] of this.#refCountUpdates) assert(update >= 0, `ref count update must be non-negative. ${hash}:${update}`);
+		return this.#refCountUpdates;
+	}
+	async #changeRefCount(hash, delta) {
+		await this.#ensureRefCountLoaded(hash);
+		if (this.#updateRefCount(hash, delta)) await this.#updateRefsCounts(hash, delta);
+	}
+	async #updateRefsCounts(hash, delta) {
+		if (hash === emptyHash) return;
+		const refs = await this.#delegate.getRefs(hash);
+		if (!isProd) assert(refs || this.#isLazyDelegate && !this.#putChunks.has(hash), "refs must be defined");
+		if (refs !== void 0) {
+			this.#refsCounted?.add(hash);
+			const ps = refs.map((ref) => this.#changeRefCount(ref, delta));
+			await Promise.all(ps);
+		}
+	}
+	#ensureRefCountLoaded(hash) {
+		let p = this.#loadedRefCountPromises.get(hash);
+		if (p === void 0) {
+			p = (async () => {
+				const value = await this.#delegate.getRefCount(hash) || 0;
+				this.#refCountUpdates.set(hash, value);
+				return value;
+			})();
+			this.#loadedRefCountPromises.set(hash, p);
+		}
+		return p;
+	}
+	#updateRefCount(hash, delta) {
+		const oldCount = this.#refCountUpdates.get(hash);
+		assertNumber(oldCount);
+		this.#refCountUpdates.set(hash, oldCount + delta);
+		return oldCount === 0 && delta === 1 || oldCount === 1 && delta === -1;
+	}
 };
-//# sourceMappingURL=gc.js.map
+//#endregion
+export { computeRefCountUpdates };
+
+//# sourceMappingURL=gc.js.map

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

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

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

@@ -1,20 +1,18 @@
 import "../hash.js";
+//#region ../replicache/src/dag/key.ts
 function chunkDataKey(hash) {
-  return `c/${hash}/d`;
+	return `c/${hash}/d`;
 }
 function chunkMetaKey(hash) {
-  return `c/${hash}/m`;
+	return `c/${hash}/m`;
 }
 function chunkRefCountKey(hash) {
-  return `c/${hash}/r`;
+	return `c/${hash}/r`;
 }
 function headKey(name) {
-  return `h/${name}`;
+	return `h/${name}`;
 }
-export {
-  chunkDataKey,
-  chunkMetaKey,
-  chunkRefCountKey,
-  headKey
-};
-//# sourceMappingURL=key.js.map
+//#endregion
+export { chunkDataKey, chunkMetaKey, chunkRefCountKey, headKey };
+
+//# sourceMappingURL=key.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"key.js","sources":["../../../../../replicache/src/dag/key.ts"],"sourcesContent":["import {type Hash, parse as parseHash} from '../hash.ts';\nimport * as KeyType from './key-type-enum.ts';\n\nexport function chunkDataKey(hash: Hash): string {\n  return `c/${hash}/d`;\n}\n\nexport function chunkMetaKey(hash: Hash): string {\n  return `c/${hash}/m`;\n}\n\nexport function chunkRefCountKey(hash: Hash): string {\n  return `c/${hash}/r`;\n}\n\nexport function headKey(name: string): string {\n  return `h/${name}`;\n}\n\nexport type Key =\n  | {\n      type: KeyType.ChunkData;\n      hash: Hash;\n    }\n  | {\n      type: KeyType.ChunkMeta;\n      hash: Hash;\n    }\n  | {\n      type: KeyType.ChunkRefCount;\n      hash: Hash;\n    }\n  | {\n      type: KeyType.Head;\n      name: string;\n    };\n\nexport function parse(key: string): Key {\n  const invalidKey = () => new Error(`Invalid key. Got \"${key}\"`);\n  const hash = () => parseHash(key.substring(2, key.length - 2));\n\n  // '/'\n  if (key.charCodeAt(1) === 47) {\n    switch (key.charCodeAt(0)) {\n      // c\n      case 99: {\n        if (key.length < 4 || key.charCodeAt(key.length - 2) !== 47) {\n          throw invalidKey();\n        }\n        switch (key.charCodeAt(key.length - 1)) {\n          case 100: // d\n            return {\n              type: KeyType.ChunkData,\n              hash: hash(),\n            };\n          case 109: // m\n            return {\n              type: KeyType.ChunkMeta,\n              hash: hash(),\n            };\n          case 114: // r\n            return {\n              type: KeyType.ChunkRefCount,\n              hash: hash(),\n            };\n        }\n        break;\n      }\n      case 104: // h\n        return {\n          type: KeyType.Head,\n          name: key.substring(2),\n        };\n    }\n  }\n  throw invalidKey();\n}\n"],"names":[],"mappings":";AAGO,SAAS,aAAa,MAAoB;AAC/C,SAAO,KAAK,IAAI;AAClB;AAEO,SAAS,aAAa,MAAoB;AAC/C,SAAO,KAAK,IAAI;AAClB;AAEO,SAAS,iBAAiB,MAAoB;AACnD,SAAO,KAAK,IAAI;AAClB;AAEO,SAAS,QAAQ,MAAsB;AAC5C,SAAO,KAAK,IAAI;AAClB;"}
+{"version":3,"file":"key.js","names":[],"sources":["../../../../../replicache/src/dag/key.ts"],"sourcesContent":["import {type Hash, parse as parseHash} from '../hash.ts';\nimport * as KeyType from './key-type-enum.ts';\n\nexport function chunkDataKey(hash: Hash): string {\n  return `c/${hash}/d`;\n}\n\nexport function chunkMetaKey(hash: Hash): string {\n  return `c/${hash}/m`;\n}\n\nexport function chunkRefCountKey(hash: Hash): string {\n  return `c/${hash}/r`;\n}\n\nexport function headKey(name: string): string {\n  return `h/${name}`;\n}\n\nexport type Key =\n  | {\n      type: KeyType.ChunkData;\n      hash: Hash;\n    }\n  | {\n      type: KeyType.ChunkMeta;\n      hash: Hash;\n    }\n  | {\n      type: KeyType.ChunkRefCount;\n      hash: Hash;\n    }\n  | {\n      type: KeyType.Head;\n      name: string;\n    };\n\nexport function parse(key: string): Key {\n  const invalidKey = () => new Error(`Invalid key. Got \"${key}\"`);\n  const hash = () => parseHash(key.substring(2, key.length - 2));\n\n  // '/'\n  if (key.charCodeAt(1) === 47) {\n    switch (key.charCodeAt(0)) {\n      // c\n      case 99: {\n        if (key.length < 4 || key.charCodeAt(key.length - 2) !== 47) {\n          throw invalidKey();\n        }\n        switch (key.charCodeAt(key.length - 1)) {\n          case 100: // d\n            return {\n              type: KeyType.ChunkData,\n              hash: hash(),\n            };\n          case 109: // m\n            return {\n              type: KeyType.ChunkMeta,\n              hash: hash(),\n            };\n          case 114: // r\n            return {\n              type: KeyType.ChunkRefCount,\n              hash: hash(),\n            };\n        }\n        break;\n      }\n      case 104: // h\n        return {\n          type: KeyType.Head,\n          name: key.substring(2),\n        };\n    }\n  }\n  throw invalidKey();\n}\n"],"mappings":";;AAGA,SAAgB,aAAa,MAAoB;AAC/C,QAAO,KAAK,KAAK;;AAGnB,SAAgB,aAAa,MAAoB;AAC/C,QAAO,KAAK,KAAK;;AAGnB,SAAgB,iBAAiB,MAAoB;AACnD,QAAO,KAAK,KAAK;;AAGnB,SAAgB,QAAQ,MAAsB;AAC5C,QAAO,KAAK"}