@rocicorp/zero 0.26.1 → 0.26.2-canary.4

package/out/replicache/src/btree/splice.js

@@ -1,83 +1,63 @@
 import { deepEqual } from "../../../shared/src/json.js";
-const SPLICE_UNASSIGNED = -1;
-const SPLICE_AT = 0;
-const SPLICE_REMOVED = 1;
-const SPLICE_ADDED = 2;
-const SPLICE_FROM = 3;
-const KEY = 0;
-const VALUE = 1;
+//#region ../replicache/src/btree/splice.ts
+var SPLICE_UNASSIGNED = -1;
+var KEY = 0;
+var VALUE = 1;
 function* computeSplices(previous, current) {
-  let previousIndex = 0;
-  let currentIndex = 0;
-  let splice;
-  function ensureAssigned(splice2, index) {
-    if (splice2[SPLICE_FROM] === SPLICE_UNASSIGNED) {
-      splice2[SPLICE_FROM] = index;
-    }
-  }
-  function newSplice() {
-    return [previousIndex, 0, 0, SPLICE_UNASSIGNED];
-  }
-  while (previousIndex < previous.length && currentIndex < current.length) {
-    if (previous[previousIndex][KEY] === current[currentIndex][KEY]) {
-      if (deepEqual(
-        // These are really Hash | InternalValue
-        previous[previousIndex][VALUE],
-        current[currentIndex][VALUE]
-      )) {
-        if (splice) {
-          ensureAssigned(splice, 0);
-          yield splice;
-          splice = void 0;
-        }
-      } else {
-        if (!splice) {
-          splice = newSplice();
-        }
-        splice[SPLICE_ADDED]++;
-        splice[SPLICE_REMOVED]++;
-        ensureAssigned(splice, currentIndex);
-      }
-      previousIndex++;
-      currentIndex++;
-    } else if (previous[previousIndex][KEY] < current[currentIndex][KEY]) {
-      if (!splice) {
-        splice = newSplice();
-      }
-      splice[SPLICE_REMOVED]++;
-      previousIndex++;
-    } else {
-      if (!splice) {
-        splice = newSplice();
-      }
-      splice[SPLICE_ADDED]++;
-      ensureAssigned(splice, currentIndex);
-      currentIndex++;
-    }
-  }
-  if (currentIndex < current.length) {
-    if (!splice) {
-      splice = newSplice();
-    }
-    splice[SPLICE_ADDED] += current.length - currentIndex;
-    ensureAssigned(splice, currentIndex);
-  }
-  if (previousIndex < previous.length) {
-    if (!splice) {
-      splice = newSplice();
-    }
-    splice[SPLICE_REMOVED] += previous.length - previousIndex;
-  }
-  if (splice) {
-    ensureAssigned(splice, 0);
-    yield splice;
-  }
+	let previousIndex = 0;
+	let currentIndex = 0;
+	let splice;
+	function ensureAssigned(splice, index) {
+		if (splice[3] === SPLICE_UNASSIGNED) splice[3] = index;
+	}
+	function newSplice() {
+		return [
+			previousIndex,
+			0,
+			0,
+			SPLICE_UNASSIGNED
+		];
+	}
+	while (previousIndex < previous.length && currentIndex < current.length) if (previous[previousIndex][KEY] === current[currentIndex][KEY]) {
+		if (deepEqual(previous[previousIndex][VALUE], current[currentIndex][VALUE])) {
+			if (splice) {
+				ensureAssigned(splice, 0);
+				yield splice;
+				splice = void 0;
+			}
+		} else {
+			if (!splice) splice = newSplice();
+			splice[2]++;
+			splice[1]++;
+			ensureAssigned(splice, currentIndex);
+		}
+		previousIndex++;
+		currentIndex++;
+	} else if (previous[previousIndex][KEY] < current[currentIndex][KEY]) {
+		if (!splice) splice = newSplice();
+		splice[1]++;
+		previousIndex++;
+	} else {
+		if (!splice) splice = newSplice();
+		splice[2]++;
+		ensureAssigned(splice, currentIndex);
+		currentIndex++;
+	}
+	if (currentIndex < current.length) {
+		if (!splice) splice = newSplice();
+		splice[2] += current.length - currentIndex;
+		ensureAssigned(splice, currentIndex);
+	}
+	if (previousIndex < previous.length) {
+		if (!splice) splice = newSplice();
+		splice[1] += previous.length - previousIndex;
+	}
+	if (splice) {
+		ensureAssigned(splice, 0);
+		yield splice;
+	}
 }
-export {
-  SPLICE_ADDED,
-  SPLICE_AT,
-  SPLICE_FROM,
-  SPLICE_REMOVED,
-  computeSplices
-};
-//# sourceMappingURL=splice.js.map
+//#endregion
+export { computeSplices };
+
+//# sourceMappingURL=splice.js.map

package/out/replicache/src/btree/splice.js.map

@@ -1 +1 @@
-{"version":3,"file":"splice.js","sources":["../../../../../replicache/src/btree/splice.ts"],"sourcesContent":["import {deepEqual, type ReadonlyJSONValue} from '../../../shared/src/json.ts';\n\nexport type Splice = [at: number, removed: number, added: number, from: number];\n\nconst SPLICE_UNASSIGNED = -1;\nexport const SPLICE_AT = 0;\nexport const SPLICE_REMOVED = 1;\nexport const SPLICE_ADDED = 2;\nexport const SPLICE_FROM = 3;\n\nconst KEY = 0;\nconst VALUE = 1;\n\ntype Entry<V> = readonly [key: string, value: V, ...rest: unknown[]];\n\nexport function* computeSplices<T>(\n  previous: readonly Entry<T>[],\n  current: readonly Entry<T>[],\n): Generator<Splice, void> {\n  let previousIndex = 0;\n  let currentIndex = 0;\n  let splice: Splice | undefined;\n\n  function ensureAssigned(splice: Splice, index: number): void {\n    if (splice[SPLICE_FROM] === SPLICE_UNASSIGNED) {\n      splice[SPLICE_FROM] = index;\n    }\n  }\n\n  function newSplice(): Splice {\n    return [previousIndex, 0, 0, SPLICE_UNASSIGNED];\n  }\n\n  while (previousIndex < previous.length && currentIndex < current.length) {\n    if (previous[previousIndex][KEY] === current[currentIndex][KEY]) {\n      if (\n        deepEqual(\n          // These are really Hash | InternalValue\n          previous[previousIndex][VALUE] as ReadonlyJSONValue,\n          current[currentIndex][VALUE] as ReadonlyJSONValue,\n        )\n      ) {\n        if (splice) {\n          ensureAssigned(splice, 0);\n          yield splice;\n          splice = undefined;\n        }\n      } else {\n        if (!splice) {\n          splice = newSplice();\n        }\n        splice[SPLICE_ADDED]++;\n        splice[SPLICE_REMOVED]++;\n        ensureAssigned(splice, currentIndex);\n      }\n      previousIndex++;\n      currentIndex++;\n    } else if (previous[previousIndex][KEY] < current[currentIndex][KEY]) {\n      // previous was removed\n      if (!splice) {\n        splice = newSplice();\n      }\n      splice[SPLICE_REMOVED]++;\n\n      previousIndex++;\n    } else {\n      // current was added\n      if (!splice) {\n        splice = newSplice();\n      }\n      splice[SPLICE_ADDED]++;\n      ensureAssigned(splice, currentIndex);\n\n      currentIndex++;\n    }\n  }\n\n  if (currentIndex < current.length) {\n    if (!splice) {\n      splice = newSplice();\n    }\n    splice[SPLICE_ADDED] += current.length - currentIndex;\n    ensureAssigned(splice, currentIndex);\n  }\n\n  if (previousIndex < previous.length) {\n    if (!splice) {\n      splice = newSplice();\n    }\n    splice[SPLICE_REMOVED] += previous.length - previousIndex;\n  }\n\n  if (splice) {\n    ensureAssigned(splice, 0);\n    yield splice;\n  }\n}\n"],"names":["splice"],"mappings":";AAIA,MAAM,oBAAoB;AACnB,MAAM,YAAY;AAClB,MAAM,iBAAiB;AACvB,MAAM,eAAe;AACrB,MAAM,cAAc;AAE3B,MAAM,MAAM;AACZ,MAAM,QAAQ;AAIP,UAAU,eACf,UACA,SACyB;AACzB,MAAI,gBAAgB;AACpB,MAAI,eAAe;AACnB,MAAI;AAEJ,WAAS,eAAeA,SAAgB,OAAqB;AAC3D,QAAIA,QAAO,WAAW,MAAM,mBAAmB;AAC7CA,cAAO,WAAW,IAAI;AAAA,IACxB;AAAA,EACF;AAEA,WAAS,YAAoB;AAC3B,WAAO,CAAC,eAAe,GAAG,GAAG,iBAAiB;AAAA,EAChD;AAEA,SAAO,gBAAgB,SAAS,UAAU,eAAe,QAAQ,QAAQ;AACvE,QAAI,SAAS,aAAa,EAAE,GAAG,MAAM,QAAQ,YAAY,EAAE,GAAG,GAAG;AAC/D,UACE;AAAA;AAAA,QAEE,SAAS,aAAa,EAAE,KAAK;AAAA,QAC7B,QAAQ,YAAY,EAAE,KAAK;AAAA,MAAA,GAE7B;AACA,YAAI,QAAQ;AACV,yBAAe,QAAQ,CAAC;AACxB,gBAAM;AACN,mBAAS;AAAA,QACX;AAAA,MACF,OAAO;AACL,YAAI,CAAC,QAAQ;AACX,mBAAS,UAAA;AAAA,QACX;AACA,eAAO,YAAY;AACnB,eAAO,cAAc;AACrB,uBAAe,QAAQ,YAAY;AAAA,MACrC;AACA;AACA;AAAA,IACF,WAAW,SAAS,aAAa,EAAE,GAAG,IAAI,QAAQ,YAAY,EAAE,GAAG,GAAG;AAEpE,UAAI,CAAC,QAAQ;AACX,iBAAS,UAAA;AAAA,MACX;AACA,aAAO,cAAc;AAErB;AAAA,IACF,OAAO;AAEL,UAAI,CAAC,QAAQ;AACX,iBAAS,UAAA;AAAA,MACX;AACA,aAAO,YAAY;AACnB,qBAAe,QAAQ,YAAY;AAEnC;AAAA,IACF;AAAA,EACF;AAEA,MAAI,eAAe,QAAQ,QAAQ;AACjC,QAAI,CAAC,QAAQ;AACX,eAAS,UAAA;AAAA,IACX;AACA,WAAO,YAAY,KAAK,QAAQ,SAAS;AACzC,mBAAe,QAAQ,YAAY;AAAA,EACrC;AAEA,MAAI,gBAAgB,SAAS,QAAQ;AACnC,QAAI,CAAC,QAAQ;AACX,eAAS,UAAA;AAAA,IACX;AACA,WAAO,cAAc,KAAK,SAAS,SAAS;AAAA,EAC9C;AAEA,MAAI,QAAQ;AACV,mBAAe,QAAQ,CAAC;AACxB,UAAM;AAAA,EACR;AACF;"}
+{"version":3,"file":"splice.js","names":[],"sources":["../../../../../replicache/src/btree/splice.ts"],"sourcesContent":["import {deepEqual, type ReadonlyJSONValue} from '../../../shared/src/json.ts';\n\nexport type Splice = [at: number, removed: number, added: number, from: number];\n\nconst SPLICE_UNASSIGNED = -1;\nexport const SPLICE_AT = 0;\nexport const SPLICE_REMOVED = 1;\nexport const SPLICE_ADDED = 2;\nexport const SPLICE_FROM = 3;\n\nconst KEY = 0;\nconst VALUE = 1;\n\ntype Entry<V> = readonly [key: string, value: V, ...rest: unknown[]];\n\nexport function* computeSplices<T>(\n  previous: readonly Entry<T>[],\n  current: readonly Entry<T>[],\n): Generator<Splice, void> {\n  let previousIndex = 0;\n  let currentIndex = 0;\n  let splice: Splice | undefined;\n\n  function ensureAssigned(splice: Splice, index: number): void {\n    if (splice[SPLICE_FROM] === SPLICE_UNASSIGNED) {\n      splice[SPLICE_FROM] = index;\n    }\n  }\n\n  function newSplice(): Splice {\n    return [previousIndex, 0, 0, SPLICE_UNASSIGNED];\n  }\n\n  while (previousIndex < previous.length && currentIndex < current.length) {\n    if (previous[previousIndex][KEY] === current[currentIndex][KEY]) {\n      if (\n        deepEqual(\n          // These are really Hash | InternalValue\n          previous[previousIndex][VALUE] as ReadonlyJSONValue,\n          current[currentIndex][VALUE] as ReadonlyJSONValue,\n        )\n      ) {\n        if (splice) {\n          ensureAssigned(splice, 0);\n          yield splice;\n          splice = undefined;\n        }\n      } else {\n        if (!splice) {\n          splice = newSplice();\n        }\n        splice[SPLICE_ADDED]++;\n        splice[SPLICE_REMOVED]++;\n        ensureAssigned(splice, currentIndex);\n      }\n      previousIndex++;\n      currentIndex++;\n    } else if (previous[previousIndex][KEY] < current[currentIndex][KEY]) {\n      // previous was removed\n      if (!splice) {\n        splice = newSplice();\n      }\n      splice[SPLICE_REMOVED]++;\n\n      previousIndex++;\n    } else {\n      // current was added\n      if (!splice) {\n        splice = newSplice();\n      }\n      splice[SPLICE_ADDED]++;\n      ensureAssigned(splice, currentIndex);\n\n      currentIndex++;\n    }\n  }\n\n  if (currentIndex < current.length) {\n    if (!splice) {\n      splice = newSplice();\n    }\n    splice[SPLICE_ADDED] += current.length - currentIndex;\n    ensureAssigned(splice, currentIndex);\n  }\n\n  if (previousIndex < previous.length) {\n    if (!splice) {\n      splice = newSplice();\n    }\n    splice[SPLICE_REMOVED] += previous.length - previousIndex;\n  }\n\n  if (splice) {\n    ensureAssigned(splice, 0);\n    yield splice;\n  }\n}\n"],"mappings":";;AAIA,IAAM,oBAAoB;AAM1B,IAAM,MAAM;AACZ,IAAM,QAAQ;AAId,UAAiB,eACf,UACA,SACyB;CACzB,IAAI,gBAAgB;CACpB,IAAI,eAAe;CACnB,IAAI;CAEJ,SAAS,eAAe,QAAgB,OAAqB;AAC3D,MAAI,OAAA,OAAwB,kBAC1B,QAAA,KAAsB;;CAI1B,SAAS,YAAoB;AAC3B,SAAO;GAAC;GAAe;GAAG;GAAG;GAAkB;;AAGjD,QAAO,gBAAgB,SAAS,UAAU,eAAe,QAAQ,OAC/D,KAAI,SAAS,eAAe,SAAS,QAAQ,cAAc,MAAM;AAC/D,MACE,UAEE,SAAS,eAAe,QACxB,QAAQ,cAAc,OACvB;OAEG,QAAQ;AACV,mBAAe,QAAQ,EAAE;AACzB,UAAM;AACN,aAAS,KAAA;;SAEN;AACL,OAAI,CAAC,OACH,UAAS,WAAW;AAEtB,UAAA;AACA,UAAA;AACA,kBAAe,QAAQ,aAAa;;AAEtC;AACA;YACS,SAAS,eAAe,OAAO,QAAQ,cAAc,MAAM;AAEpE,MAAI,CAAC,OACH,UAAS,WAAW;AAEtB,SAAA;AAEA;QACK;AAEL,MAAI,CAAC,OACH,UAAS,WAAW;AAEtB,SAAA;AACA,iBAAe,QAAQ,aAAa;AAEpC;;AAIJ,KAAI,eAAe,QAAQ,QAAQ;AACjC,MAAI,CAAC,OACH,UAAS,WAAW;AAEtB,SAAA,MAAwB,QAAQ,SAAS;AACzC,iBAAe,QAAQ,aAAa;;AAGtC,KAAI,gBAAgB,SAAS,QAAQ;AACnC,MAAI,CAAC,OACH,UAAS,WAAW;AAEtB,SAAA,MAA0B,SAAS,SAAS;;AAG9C,KAAI,QAAQ;AACV,iBAAe,QAAQ,EAAE;AACzB,QAAM"}

package/out/replicache/src/btree/write.js

@@ -1,163 +1,139 @@
-import { Lock } from "@rocicorp/lock";
 import { assert } from "../../../shared/src/asserts.js";
-import { getSizeOfEntry } from "../../../shared/src/size-of-value.js";
-import { toRefs } from "../dag/chunk.js";
 import { emptyHash, newRandomHash } from "../hash.js";
-import { InternalNodeImpl, DataNodeImpl, newNodeImpl, partition, createNewInternalEntryForNode, emptyDataNode, isDataNodeImpl, toChunkData } from "./node.js";
+import { toRefs } from "../dag/chunk.js";
+import { DataNodeImpl, InternalNodeImpl, createNewInternalEntryForNode, emptyDataNode, isDataNodeImpl, newNodeImpl, partition, toChunkData } from "./node.js";
+import { getSizeOfEntry } from "../../../shared/src/size-of-value.js";
 import { BTreeRead } from "./read.js";
-class BTreeWrite extends BTreeRead {
-  /**
-   * This rw lock is used to ensure we do not mutate the btree in parallel. It
-   * would be a problem if we didn't have the lock in cases like this:
-   *
-   * ```ts
-   * const p1 = tree.put('a', 0);
-   * const p2 = tree.put('b', 1);
-   * await p1;
-   * await p2;
-   * ```
-   *
-   * because both `p1` and `p2` would start from the old root hash but a put
-   * changes the root hash so the two concurrent puts would lead to only one of
-   * them actually working, and it is not deterministic which one would finish
-   * last.
-   */
-  #lock = new Lock();
-  #modified = /* @__PURE__ */ new Map();
-  minSize;
-  maxSize;
-  constructor(dagWrite, formatVersion, root = emptyHash, minSize = 8 * 1024, maxSize = 16 * 1024, getEntrySize = getSizeOfEntry, chunkHeaderSize) {
-    super(dagWrite, formatVersion, root, getEntrySize, chunkHeaderSize);
-    this.minSize = minSize;
-    this.maxSize = maxSize;
-  }
-  #addToModified(node) {
-    assert(node.isMutable, "Expected node to be mutable");
-    this.#modified.set(node.hash, node);
-    this._cache.set(node.hash, node);
-  }
-  updateNode(node) {
-    assert(node.isMutable, "Expected node to be mutable");
-    this.#modified.delete(node.hash);
-    node.hash = newRandomHash();
-    this.#addToModified(node);
-  }
-  newInternalNodeImpl(entries, level) {
-    const n = new InternalNodeImpl(entries, newRandomHash(), level, true);
-    this.#addToModified(n);
-    return n;
-  }
-  newDataNodeImpl(entries) {
-    const n = new DataNodeImpl(entries, newRandomHash(), true);
-    this.#addToModified(n);
-    return n;
-  }
-  newNodeImpl(entries, level) {
-    const n = newNodeImpl(entries, newRandomHash(), level, true);
-    this.#addToModified(n);
-    return n;
-  }
-  put(key, value) {
-    return this.#lock.withLock(async () => {
-      const oldRootNode = await this.getNode(this.rootHash);
-      const entrySize = this.getEntrySize(key, value);
-      const rootNode = await oldRootNode.set(key, value, entrySize, this);
-      if (rootNode.getChildNodeSize(this) > this.maxSize) {
-        const headerSize = this.chunkHeaderSize;
-        const partitions = partition(
-          rootNode.entries,
-          (value2) => value2[2],
-          this.minSize - headerSize,
-          this.maxSize - headerSize
-        );
-        const { level } = rootNode;
-        const entries = partitions.map((entries2) => {
-          const node = this.newNodeImpl(entries2, level);
-          return createNewInternalEntryForNode(node, this.getEntrySize);
-        });
-        const newRoot = this.newInternalNodeImpl(entries, level + 1);
-        this.rootHash = newRoot.hash;
-        return;
-      }
-      this.rootHash = rootNode.hash;
-    });
-  }
-  del(key) {
-    return this.#lock.withLock(async () => {
-      const oldRootNode = await this.getNode(this.rootHash);
-      const newRootNode = await oldRootNode.del(key, this);
-      const found = this.rootHash !== newRootNode.hash;
-      if (found) {
-        if (newRootNode.level > 0 && newRootNode.entries.length === 1) {
-          this.rootHash = newRootNode.entries[0][1];
-        } else {
-          this.rootHash = newRootNode.hash;
-        }
-      }
-      return found;
-    });
-  }
-  clear() {
-    return this.#lock.withLock(() => {
-      this.#modified.clear();
-      this.rootHash = emptyHash;
-    });
-  }
-  flush() {
-    return this.#lock.withLock(async () => {
-      const dagWrite = this._dagRead;
-      if (this.rootHash === emptyHash) {
-        const chunk = dagWrite.createChunk(emptyDataNode, []);
-        await dagWrite.putChunk(chunk);
-        return chunk.hash;
-      }
-      const newChunks = [];
-      const newRoot = gatherNewChunks(
-        this.rootHash,
-        newChunks,
-        dagWrite.createChunk,
-        this.#modified,
-        this._formatVersion
-      );
-      await Promise.all(newChunks.map((chunk) => dagWrite.putChunk(chunk)));
-      this.#modified.clear();
-      this.rootHash = newRoot;
-      return newRoot;
-    });
-  }
-}
+import { Lock } from "@rocicorp/lock";
+//#region ../replicache/src/btree/write.ts
+var BTreeWrite = class extends BTreeRead {
+	/**
+	* This rw lock is used to ensure we do not mutate the btree in parallel. It
+	* would be a problem if we didn't have the lock in cases like this:
+	*
+	* ```ts
+	* const p1 = tree.put('a', 0);
+	* const p2 = tree.put('b', 1);
+	* await p1;
+	* await p2;
+	* ```
+	*
+	* because both `p1` and `p2` would start from the old root hash but a put
+	* changes the root hash so the two concurrent puts would lead to only one of
+	* them actually working, and it is not deterministic which one would finish
+	* last.
+	*/
+	#lock = new Lock();
+	#modified = /* @__PURE__ */ new Map();
+	minSize;
+	maxSize;
+	constructor(dagWrite, formatVersion, root = emptyHash, minSize = 8 * 1024, maxSize = 16 * 1024, getEntrySize = getSizeOfEntry, chunkHeaderSize) {
+		super(dagWrite, formatVersion, root, getEntrySize, chunkHeaderSize);
+		this.minSize = minSize;
+		this.maxSize = maxSize;
+	}
+	#addToModified(node) {
+		assert(node.isMutable, "Expected node to be mutable");
+		this.#modified.set(node.hash, node);
+		this._cache.set(node.hash, node);
+	}
+	updateNode(node) {
+		assert(node.isMutable, "Expected node to be mutable");
+		this.#modified.delete(node.hash);
+		node.hash = newRandomHash();
+		this.#addToModified(node);
+	}
+	newInternalNodeImpl(entries, level) {
+		const n = new InternalNodeImpl(entries, newRandomHash(), level, true);
+		this.#addToModified(n);
+		return n;
+	}
+	newDataNodeImpl(entries) {
+		const n = new DataNodeImpl(entries, newRandomHash(), true);
+		this.#addToModified(n);
+		return n;
+	}
+	newNodeImpl(entries, level) {
+		const n = newNodeImpl(entries, newRandomHash(), level, true);
+		this.#addToModified(n);
+		return n;
+	}
+	put(key, value) {
+		return this.#lock.withLock(async () => {
+			const oldRootNode = await this.getNode(this.rootHash);
+			const entrySize = this.getEntrySize(key, value);
+			const rootNode = await oldRootNode.set(key, value, entrySize, this);
+			if (rootNode.getChildNodeSize(this) > this.maxSize) {
+				const headerSize = this.chunkHeaderSize;
+				const partitions = partition(rootNode.entries, (value) => value[2], this.minSize - headerSize, this.maxSize - headerSize);
+				const { level } = rootNode;
+				const entries = partitions.map((entries) => {
+					return createNewInternalEntryForNode(this.newNodeImpl(entries, level), this.getEntrySize);
+				});
+				this.rootHash = this.newInternalNodeImpl(entries, level + 1).hash;
+				return;
+			}
+			this.rootHash = rootNode.hash;
+		});
+	}
+	del(key) {
+		return this.#lock.withLock(async () => {
+			const newRootNode = await (await this.getNode(this.rootHash)).del(key, this);
+			const found = this.rootHash !== newRootNode.hash;
+			if (found) if (newRootNode.level > 0 && newRootNode.entries.length === 1) this.rootHash = newRootNode.entries[0][1];
+			else this.rootHash = newRootNode.hash;
+			return found;
+		});
+	}
+	clear() {
+		return this.#lock.withLock(() => {
+			this.#modified.clear();
+			this.rootHash = emptyHash;
+		});
+	}
+	flush() {
+		return this.#lock.withLock(async () => {
+			const dagWrite = this._dagRead;
+			if (this.rootHash === emptyHash) {
+				const chunk = dagWrite.createChunk(emptyDataNode, []);
+				await dagWrite.putChunk(chunk);
+				return chunk.hash;
+			}
+			const newChunks = [];
+			const newRoot = gatherNewChunks(this.rootHash, newChunks, dagWrite.createChunk, this.#modified, this._formatVersion);
+			await Promise.all(newChunks.map((chunk) => dagWrite.putChunk(chunk)));
+			this.#modified.clear();
+			this.rootHash = newRoot;
+			return newRoot;
+		});
+	}
+};
 function gatherNewChunks(hash, newChunks, createChunk, modified, formatVersion) {
-  const node = modified.get(hash);
-  if (node === void 0) {
-    return hash;
-  }
-  if (isDataNodeImpl(node)) {
-    const chunk2 = createChunk(toChunkData(node, formatVersion), []);
-    newChunks.push(chunk2);
-    return chunk2.hash;
-  }
-  const refs = [];
-  const { entries } = node;
-  for (let i = 0; i < entries.length; i++) {
-    const entry = entries[i];
-    const childHash = entry[1];
-    const newChildHash = gatherNewChunks(
-      childHash,
-      newChunks,
-      createChunk,
-      modified,
-      formatVersion
-    );
-    if (newChildHash !== childHash) {
-      entries[i] = [entry[0], newChildHash, entry[2]];
-    }
-    refs.push(newChildHash);
-  }
-  const chunk = createChunk(toChunkData(node, formatVersion), toRefs(refs));
-  newChunks.push(chunk);
-  return chunk.hash;
+	const node = modified.get(hash);
+	if (node === void 0) return hash;
+	if (isDataNodeImpl(node)) {
+		const chunk = createChunk(toChunkData(node, formatVersion), []);
+		newChunks.push(chunk);
+		return chunk.hash;
+	}
+	const refs = [];
+	const { entries } = node;
+	for (let i = 0; i < entries.length; i++) {
+		const entry = entries[i];
+		const childHash = entry[1];
+		const newChildHash = gatherNewChunks(childHash, newChunks, createChunk, modified, formatVersion);
+		if (newChildHash !== childHash) entries[i] = [
+			entry[0],
+			newChildHash,
+			entry[2]
+		];
+		refs.push(newChildHash);
+	}
+	const chunk = createChunk(toChunkData(node, formatVersion), toRefs(refs));
+	newChunks.push(chunk);
+	return chunk.hash;
 }
-export {
-  BTreeWrite
-};
-//# sourceMappingURL=write.js.map
+//#endregion
+export { BTreeWrite };
+
+//# sourceMappingURL=write.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"write.js","sources":["../../../../../replicache/src/btree/write.ts"],"sourcesContent":["import {Lock} from '@rocicorp/lock';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport type {ReadonlyJSONValue} from '../../../shared/src/json.ts';\nimport {getSizeOfEntry} from '../../../shared/src/size-of-value.ts';\nimport {type Chunk, type CreateChunk, toRefs} from '../dag/chunk.ts';\nimport type {Write} from '../dag/store.ts';\nimport type * as FormatVersion from '../format-version-enum.ts';\nimport type {FrozenJSONValue} from '../frozen-json.ts';\nimport {type Hash, emptyHash, newRandomHash} from '../hash.ts';\nimport {\n  DataNodeImpl,\n  type Entry,\n  InternalNodeImpl,\n  createNewInternalEntryForNode,\n  emptyDataNode,\n  isDataNodeImpl,\n  newNodeImpl,\n  partition,\n  toChunkData,\n} from './node.ts';\nimport {BTreeRead} from './read.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\nexport class BTreeWrite extends BTreeRead {\n  /**\n   * This rw lock is used to ensure we do not mutate the btree in parallel. It\n   * would be a problem if we didn't have the lock in cases like this:\n   *\n   * ```ts\n   * const p1 = tree.put('a', 0);\n   * const p2 = tree.put('b', 1);\n   * await p1;\n   * await p2;\n   * ```\n   *\n   * because both `p1` and `p2` would start from the old root hash but a put\n   * changes the root hash so the two concurrent puts would lead to only one of\n   * them actually working, and it is not deterministic which one would finish\n   * last.\n   */\n  readonly #lock = new Lock();\n  readonly #modified: Map<Hash, DataNodeImpl | InternalNodeImpl> = new Map();\n\n  declare protected _dagRead: Write;\n\n  readonly minSize: number;\n  readonly maxSize: number;\n\n  constructor(\n    dagWrite: Write,\n    formatVersion: FormatVersion,\n    root: Hash = emptyHash,\n    minSize = 8 * 1024,\n    maxSize = 16 * 1024,\n    getEntrySize: <K, V>(k: K, v: V) => number = getSizeOfEntry,\n    chunkHeaderSize?: number,\n  ) {\n    super(dagWrite, formatVersion, root, getEntrySize, chunkHeaderSize);\n\n    this.minSize = minSize;\n    this.maxSize = maxSize;\n  }\n\n  #addToModified(node: DataNodeImpl | InternalNodeImpl): void {\n    assert(node.isMutable, 'Expected node to be mutable');\n    this.#modified.set(node.hash, node);\n    this._cache.set(node.hash, node);\n  }\n\n  updateNode(node: DataNodeImpl | InternalNodeImpl): void {\n    assert(node.isMutable, 'Expected node to be mutable');\n    this.#modified.delete(node.hash);\n    node.hash = newRandomHash();\n    this.#addToModified(node);\n  }\n\n  newInternalNodeImpl(\n    entries: Array<Entry<Hash>>,\n    level: number,\n  ): InternalNodeImpl {\n    const n = new InternalNodeImpl(entries, newRandomHash(), level, true);\n    this.#addToModified(n);\n    return n;\n  }\n\n  newDataNodeImpl(entries: Entry<FrozenJSONValue>[]): DataNodeImpl {\n    const n = new DataNodeImpl(entries, newRandomHash(), true);\n    this.#addToModified(n);\n    return n;\n  }\n\n  newNodeImpl(entries: Entry<FrozenJSONValue>[], level: number): DataNodeImpl;\n  newNodeImpl(entries: Entry<Hash>[], level: number): InternalNodeImpl;\n  newNodeImpl(\n    entries: Entry<Hash>[] | Entry<FrozenJSONValue>[],\n    level: number,\n  ): InternalNodeImpl | DataNodeImpl;\n  newNodeImpl(\n    entries: Entry<Hash>[] | Entry<FrozenJSONValue>[],\n    level: number,\n  ): InternalNodeImpl | DataNodeImpl {\n    const n = newNodeImpl(entries, newRandomHash(), level, true);\n    this.#addToModified(n);\n    return n;\n  }\n\n  put(key: string, value: FrozenJSONValue): Promise<void> {\n    return this.#lock.withLock(async () => {\n      const oldRootNode = await this.getNode(this.rootHash);\n      const entrySize = this.getEntrySize(key, value);\n      const rootNode = await oldRootNode.set(key, value, entrySize, this);\n\n      // We do the rebalancing in the parent so we need to do it here as well.\n      if (rootNode.getChildNodeSize(this) > this.maxSize) {\n        const headerSize = this.chunkHeaderSize;\n        const partitions = partition(\n          rootNode.entries,\n          value => value[2],\n          this.minSize - headerSize,\n          this.maxSize - headerSize,\n        );\n        const {level} = rootNode;\n        const entries: Entry<Hash>[] = partitions.map(entries => {\n          const node = this.newNodeImpl(entries, level);\n          return createNewInternalEntryForNode(node, this.getEntrySize);\n        });\n        const newRoot = this.newInternalNodeImpl(entries, level + 1);\n        this.rootHash = newRoot.hash;\n        return;\n      }\n\n      this.rootHash = rootNode.hash;\n    });\n  }\n\n  del(key: string): Promise<boolean> {\n    return this.#lock.withLock(async () => {\n      const oldRootNode = await this.getNode(this.rootHash);\n      const newRootNode = await oldRootNode.del(key, this);\n\n      // No need to rebalance here since if root gets too small there is nothing\n      // we can do about that.\n      const found = this.rootHash !== newRootNode.hash;\n      if (found) {\n        // Flatten one layer.\n        if (newRootNode.level > 0 && newRootNode.entries.length === 1) {\n          this.rootHash = (newRootNode as InternalNodeImpl).entries[0][1];\n        } else {\n          this.rootHash = newRootNode.hash;\n        }\n      }\n\n      return found;\n    });\n  }\n\n  clear(): Promise<void> {\n    return this.#lock.withLock(() => {\n      this.#modified.clear();\n      this.rootHash = emptyHash;\n    });\n  }\n\n  flush(): Promise<Hash> {\n    return this.#lock.withLock(async () => {\n      const dagWrite = this._dagRead;\n\n      if (this.rootHash === emptyHash) {\n        // Write a chunk for the empty tree.\n        const chunk = dagWrite.createChunk(emptyDataNode, []);\n        await dagWrite.putChunk(chunk as Chunk<ReadonlyJSONValue>);\n        return chunk.hash;\n      }\n\n      const newChunks: Chunk[] = [];\n      const newRoot = gatherNewChunks(\n        this.rootHash,\n        newChunks,\n        dagWrite.createChunk,\n        this.#modified,\n        this._formatVersion,\n      );\n      await Promise.all(newChunks.map(chunk => dagWrite.putChunk(chunk)));\n      this.#modified.clear();\n      this.rootHash = newRoot;\n      return newRoot;\n    });\n  }\n}\n\nfunction gatherNewChunks(\n  hash: Hash,\n  newChunks: Chunk[],\n  createChunk: CreateChunk,\n  modified: Map<Hash, DataNodeImpl | InternalNodeImpl>,\n  formatVersion: FormatVersion,\n): Hash {\n  const node = modified.get(hash);\n  if (node === undefined) {\n    // Not modified, use the original.\n    return hash;\n  }\n\n  if (isDataNodeImpl(node)) {\n    const chunk = createChunk(toChunkData(node, formatVersion), []);\n    newChunks.push(chunk);\n    return chunk.hash;\n  }\n\n  // The BTree cannot have duplicate keys so the child entry hashes are unique.\n  // No need fot a set to dedupe here.\n  const refs: Hash[] = [];\n  const {entries} = node;\n  for (let i = 0; i < entries.length; i++) {\n    const entry = entries[i];\n    const childHash = entry[1];\n    const newChildHash = gatherNewChunks(\n      childHash,\n      newChunks,\n      createChunk,\n      modified,\n      formatVersion,\n    );\n    if (newChildHash !== childHash) {\n      // MUTATES the entries!\n      // Hashes do not change the size of the entry because all hashes have the same length\n      entries[i] = [entry[0], newChildHash, entry[2]];\n    }\n    refs.push(newChildHash);\n  }\n  const chunk = createChunk(toChunkData(node, formatVersion), toRefs(refs));\n  newChunks.push(chunk);\n  return chunk.hash;\n}\n"],"names":["value","entries","chunk"],"mappings":";;;;;;;AAyBO,MAAM,mBAAmB,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiB/B,QAAQ,IAAI,KAAA;AAAA,EACZ,gCAA4D,IAAA;AAAA,EAI5D;AAAA,EACA;AAAA,EAET,YACE,UACA,eACA,OAAa,WACb,UAAU,IAAI,MACd,UAAU,KAAK,MACf,eAA6C,gBAC7C,iBACA;AACA,UAAM,UAAU,eAAe,MAAM,cAAc,eAAe;AAElE,SAAK,UAAU;AACf,SAAK,UAAU;AAAA,EACjB;AAAA,EAEA,eAAe,MAA6C;AAC1D,WAAO,KAAK,WAAW,6BAA6B;AACpD,SAAK,UAAU,IAAI,KAAK,MAAM,IAAI;AAClC,SAAK,OAAO,IAAI,KAAK,MAAM,IAAI;AAAA,EACjC;AAAA,EAEA,WAAW,MAA6C;AACtD,WAAO,KAAK,WAAW,6BAA6B;AACpD,SAAK,UAAU,OAAO,KAAK,IAAI;AAC/B,SAAK,OAAO,cAAA;AACZ,SAAK,eAAe,IAAI;AAAA,EAC1B;AAAA,EAEA,oBACE,SACA,OACkB;AAClB,UAAM,IAAI,IAAI,iBAAiB,SAAS,cAAA,GAAiB,OAAO,IAAI;AACpE,SAAK,eAAe,CAAC;AACrB,WAAO;AAAA,EACT;AAAA,EAEA,gBAAgB,SAAiD;AAC/D,UAAM,IAAI,IAAI,aAAa,SAAS,cAAA,GAAiB,IAAI;AACzD,SAAK,eAAe,CAAC;AACrB,WAAO;AAAA,EACT;AAAA,EAQA,YACE,SACA,OACiC;AACjC,UAAM,IAAI,YAAY,SAAS,cAAA,GAAiB,OAAO,IAAI;AAC3D,SAAK,eAAe,CAAC;AACrB,WAAO;AAAA,EACT;AAAA,EAEA,IAAI,KAAa,OAAuC;AACtD,WAAO,KAAK,MAAM,SAAS,YAAY;AACrC,YAAM,cAAc,MAAM,KAAK,QAAQ,KAAK,QAAQ;AACpD,YAAM,YAAY,KAAK,aAAa,KAAK,KAAK;AAC9C,YAAM,WAAW,MAAM,YAAY,IAAI,KAAK,OAAO,WAAW,IAAI;AAGlE,UAAI,SAAS,iBAAiB,IAAI,IAAI,KAAK,SAAS;AAClD,cAAM,aAAa,KAAK;AACxB,cAAM,aAAa;AAAA,UACjB,SAAS;AAAA,UACT,CAAAA,WAASA,OAAM,CAAC;AAAA,UAChB,KAAK,UAAU;AAAA,UACf,KAAK,UAAU;AAAA,QAAA;AAEjB,cAAM,EAAC,UAAS;AAChB,cAAM,UAAyB,WAAW,IAAI,CAAAC,aAAW;AACvD,gBAAM,OAAO,KAAK,YAAYA,UAAS,KAAK;AAC5C,iBAAO,8BAA8B,MAAM,KAAK,YAAY;AAAA,QAC9D,CAAC;AACD,cAAM,UAAU,KAAK,oBAAoB,SAAS,QAAQ,CAAC;AAC3D,aAAK,WAAW,QAAQ;AACxB;AAAA,MACF;AAEA,WAAK,WAAW,SAAS;AAAA,IAC3B,CAAC;AAAA,EACH;AAAA,EAEA,IAAI,KAA+B;AACjC,WAAO,KAAK,MAAM,SAAS,YAAY;AACrC,YAAM,cAAc,MAAM,KAAK,QAAQ,KAAK,QAAQ;AACpD,YAAM,cAAc,MAAM,YAAY,IAAI,KAAK,IAAI;AAInD,YAAM,QAAQ,KAAK,aAAa,YAAY;AAC5C,UAAI,OAAO;AAET,YAAI,YAAY,QAAQ,KAAK,YAAY,QAAQ,WAAW,GAAG;AAC7D,eAAK,WAAY,YAAiC,QAAQ,CAAC,EAAE,CAAC;AAAA,QAChE,OAAO;AACL,eAAK,WAAW,YAAY;AAAA,QAC9B;AAAA,MACF;AAEA,aAAO;AAAA,IACT,CAAC;AAAA,EACH;AAAA,EAEA,QAAuB;AACrB,WAAO,KAAK,MAAM,SAAS,MAAM;AAC/B,WAAK,UAAU,MAAA;AACf,WAAK,WAAW;AAAA,IAClB,CAAC;AAAA,EACH;AAAA,EAEA,QAAuB;AACrB,WAAO,KAAK,MAAM,SAAS,YAAY;AACrC,YAAM,WAAW,KAAK;AAEtB,UAAI,KAAK,aAAa,WAAW;AAE/B,cAAM,QAAQ,SAAS,YAAY,eAAe,CAAA,CAAE;AACpD,cAAM,SAAS,SAAS,KAAiC;AACzD,eAAO,MAAM;AAAA,MACf;AAEA,YAAM,YAAqB,CAAA;AAC3B,YAAM,UAAU;AAAA,QACd,KAAK;AAAA,QACL;AAAA,QACA,SAAS;AAAA,QACT,KAAK;AAAA,QACL,KAAK;AAAA,MAAA;AAEP,YAAM,QAAQ,IAAI,UAAU,IAAI,WAAS,SAAS,SAAS,KAAK,CAAC,CAAC;AAClE,WAAK,UAAU,MAAA;AACf,WAAK,WAAW;AAChB,aAAO;AAAA,IACT,CAAC;AAAA,EACH;AACF;AAEA,SAAS,gBACP,MACA,WACA,aACA,UACA,eACM;AACN,QAAM,OAAO,SAAS,IAAI,IAAI;AAC9B,MAAI,SAAS,QAAW;AAEtB,WAAO;AAAA,EACT;AAEA,MAAI,eAAe,IAAI,GAAG;AACxB,UAAMC,SAAQ,YAAY,YAAY,MAAM,aAAa,GAAG,EAAE;AAC9D,cAAU,KAAKA,MAAK;AACpB,WAAOA,OAAM;AAAA,EACf;AAIA,QAAM,OAAe,CAAA;AACrB,QAAM,EAAC,YAAW;AAClB,WAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,UAAM,QAAQ,QAAQ,CAAC;AACvB,UAAM,YAAY,MAAM,CAAC;AACzB,UAAM,eAAe;AAAA,MACnB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IAAA;AAEF,QAAI,iBAAiB,WAAW;AAG9B,cAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,cAAc,MAAM,CAAC,CAAC;AAAA,IAChD;AACA,SAAK,KAAK,YAAY;AAAA,EACxB;AACA,QAAM,QAAQ,YAAY,YAAY,MAAM,aAAa,GAAG,OAAO,IAAI,CAAC;AACxE,YAAU,KAAK,KAAK;AACpB,SAAO,MAAM;AACf;"}
+{"version":3,"file":"write.js","names":["#lock","#modified","#addToModified"],"sources":["../../../../../replicache/src/btree/write.ts"],"sourcesContent":["import {Lock} from '@rocicorp/lock';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport type {ReadonlyJSONValue} from '../../../shared/src/json.ts';\nimport {getSizeOfEntry} from '../../../shared/src/size-of-value.ts';\nimport {type Chunk, type CreateChunk, toRefs} from '../dag/chunk.ts';\nimport type {Write} from '../dag/store.ts';\nimport type * as FormatVersion from '../format-version-enum.ts';\nimport type {FrozenJSONValue} from '../frozen-json.ts';\nimport {type Hash, emptyHash, newRandomHash} from '../hash.ts';\nimport {\n  DataNodeImpl,\n  type Entry,\n  InternalNodeImpl,\n  createNewInternalEntryForNode,\n  emptyDataNode,\n  isDataNodeImpl,\n  newNodeImpl,\n  partition,\n  toChunkData,\n} from './node.ts';\nimport {BTreeRead} from './read.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\nexport class BTreeWrite extends BTreeRead {\n  /**\n   * This rw lock is used to ensure we do not mutate the btree in parallel. It\n   * would be a problem if we didn't have the lock in cases like this:\n   *\n   * ```ts\n   * const p1 = tree.put('a', 0);\n   * const p2 = tree.put('b', 1);\n   * await p1;\n   * await p2;\n   * ```\n   *\n   * because both `p1` and `p2` would start from the old root hash but a put\n   * changes the root hash so the two concurrent puts would lead to only one of\n   * them actually working, and it is not deterministic which one would finish\n   * last.\n   */\n  readonly #lock = new Lock();\n  readonly #modified: Map<Hash, DataNodeImpl | InternalNodeImpl> = new Map();\n\n  declare protected _dagRead: Write;\n\n  readonly minSize: number;\n  readonly maxSize: number;\n\n  constructor(\n    dagWrite: Write,\n    formatVersion: FormatVersion,\n    root: Hash = emptyHash,\n    minSize = 8 * 1024,\n    maxSize = 16 * 1024,\n    getEntrySize: <K, V>(k: K, v: V) => number = getSizeOfEntry,\n    chunkHeaderSize?: number,\n  ) {\n    super(dagWrite, formatVersion, root, getEntrySize, chunkHeaderSize);\n\n    this.minSize = minSize;\n    this.maxSize = maxSize;\n  }\n\n  #addToModified(node: DataNodeImpl | InternalNodeImpl): void {\n    assert(node.isMutable, 'Expected node to be mutable');\n    this.#modified.set(node.hash, node);\n    this._cache.set(node.hash, node);\n  }\n\n  updateNode(node: DataNodeImpl | InternalNodeImpl): void {\n    assert(node.isMutable, 'Expected node to be mutable');\n    this.#modified.delete(node.hash);\n    node.hash = newRandomHash();\n    this.#addToModified(node);\n  }\n\n  newInternalNodeImpl(\n    entries: Array<Entry<Hash>>,\n    level: number,\n  ): InternalNodeImpl {\n    const n = new InternalNodeImpl(entries, newRandomHash(), level, true);\n    this.#addToModified(n);\n    return n;\n  }\n\n  newDataNodeImpl(entries: Entry<FrozenJSONValue>[]): DataNodeImpl {\n    const n = new DataNodeImpl(entries, newRandomHash(), true);\n    this.#addToModified(n);\n    return n;\n  }\n\n  newNodeImpl(entries: Entry<FrozenJSONValue>[], level: number): DataNodeImpl;\n  newNodeImpl(entries: Entry<Hash>[], level: number): InternalNodeImpl;\n  newNodeImpl(\n    entries: Entry<Hash>[] | Entry<FrozenJSONValue>[],\n    level: number,\n  ): InternalNodeImpl | DataNodeImpl;\n  newNodeImpl(\n    entries: Entry<Hash>[] | Entry<FrozenJSONValue>[],\n    level: number,\n  ): InternalNodeImpl | DataNodeImpl {\n    const n = newNodeImpl(entries, newRandomHash(), level, true);\n    this.#addToModified(n);\n    return n;\n  }\n\n  put(key: string, value: FrozenJSONValue): Promise<void> {\n    return this.#lock.withLock(async () => {\n      const oldRootNode = await this.getNode(this.rootHash);\n      const entrySize = this.getEntrySize(key, value);\n      const rootNode = await oldRootNode.set(key, value, entrySize, this);\n\n      // We do the rebalancing in the parent so we need to do it here as well.\n      if (rootNode.getChildNodeSize(this) > this.maxSize) {\n        const headerSize = this.chunkHeaderSize;\n        const partitions = partition(\n          rootNode.entries,\n          value => value[2],\n          this.minSize - headerSize,\n          this.maxSize - headerSize,\n        );\n        const {level} = rootNode;\n        const entries: Entry<Hash>[] = partitions.map(entries => {\n          const node = this.newNodeImpl(entries, level);\n          return createNewInternalEntryForNode(node, this.getEntrySize);\n        });\n        const newRoot = this.newInternalNodeImpl(entries, level + 1);\n        this.rootHash = newRoot.hash;\n        return;\n      }\n\n      this.rootHash = rootNode.hash;\n    });\n  }\n\n  del(key: string): Promise<boolean> {\n    return this.#lock.withLock(async () => {\n      const oldRootNode = await this.getNode(this.rootHash);\n      const newRootNode = await oldRootNode.del(key, this);\n\n      // No need to rebalance here since if root gets too small there is nothing\n      // we can do about that.\n      const found = this.rootHash !== newRootNode.hash;\n      if (found) {\n        // Flatten one layer.\n        if (newRootNode.level > 0 && newRootNode.entries.length === 1) {\n          this.rootHash = (newRootNode as InternalNodeImpl).entries[0][1];\n        } else {\n          this.rootHash = newRootNode.hash;\n        }\n      }\n\n      return found;\n    });\n  }\n\n  clear(): Promise<void> {\n    return this.#lock.withLock(() => {\n      this.#modified.clear();\n      this.rootHash = emptyHash;\n    });\n  }\n\n  flush(): Promise<Hash> {\n    return this.#lock.withLock(async () => {\n      const dagWrite = this._dagRead;\n\n      if (this.rootHash === emptyHash) {\n        // Write a chunk for the empty tree.\n        const chunk = dagWrite.createChunk(emptyDataNode, []);\n        await dagWrite.putChunk(chunk as Chunk<ReadonlyJSONValue>);\n        return chunk.hash;\n      }\n\n      const newChunks: Chunk[] = [];\n      const newRoot = gatherNewChunks(\n        this.rootHash,\n        newChunks,\n        dagWrite.createChunk,\n        this.#modified,\n        this._formatVersion,\n      );\n      await Promise.all(newChunks.map(chunk => dagWrite.putChunk(chunk)));\n      this.#modified.clear();\n      this.rootHash = newRoot;\n      return newRoot;\n    });\n  }\n}\n\nfunction gatherNewChunks(\n  hash: Hash,\n  newChunks: Chunk[],\n  createChunk: CreateChunk,\n  modified: Map<Hash, DataNodeImpl | InternalNodeImpl>,\n  formatVersion: FormatVersion,\n): Hash {\n  const node = modified.get(hash);\n  if (node === undefined) {\n    // Not modified, use the original.\n    return hash;\n  }\n\n  if (isDataNodeImpl(node)) {\n    const chunk = createChunk(toChunkData(node, formatVersion), []);\n    newChunks.push(chunk);\n    return chunk.hash;\n  }\n\n  // The BTree cannot have duplicate keys so the child entry hashes are unique.\n  // No need fot a set to dedupe here.\n  const refs: Hash[] = [];\n  const {entries} = node;\n  for (let i = 0; i < entries.length; i++) {\n    const entry = entries[i];\n    const childHash = entry[1];\n    const newChildHash = gatherNewChunks(\n      childHash,\n      newChunks,\n      createChunk,\n      modified,\n      formatVersion,\n    );\n    if (newChildHash !== childHash) {\n      // MUTATES the entries!\n      // Hashes do not change the size of the entry because all hashes have the same length\n      entries[i] = [entry[0], newChildHash, entry[2]];\n    }\n    refs.push(newChildHash);\n  }\n  const chunk = createChunk(toChunkData(node, formatVersion), toRefs(refs));\n  newChunks.push(chunk);\n  return chunk.hash;\n}\n"],"mappings":"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"}

package/out/replicache/src/call-default-fetch.js

@@ -1,34 +1,30 @@
+//#region ../replicache/src/call-default-fetch.ts
+/**
+* Helper function for {@link getDefaultPuller} and {@link getDefaultPusher}.
+*/
 async function callDefaultFetch(url, auth, requestID, requestBody) {
-  const init = {
-    headers: {
-      "Content-type": "application/json",
-      "Authorization": auth,
-      "X-Replicache-RequestID": requestID
-    },
-    body: JSON.stringify(requestBody),
-    method: "POST"
-  };
-  const request = new Request(url, init);
-  const response = await fetch(request);
-  const httpStatusCode = response.status;
-  if (httpStatusCode !== 200) {
-    return [
-      void 0,
-      {
-        httpStatusCode,
-        errorMessage: await response.text()
-      }
-    ];
-  }
-  return [
-    response,
-    {
-      httpStatusCode,
-      errorMessage: ""
-    }
-  ];
+	const init = {
+		headers: {
+			"Content-type": "application/json",
+			"Authorization": auth,
+			"X-Replicache-RequestID": requestID
+		},
+		body: JSON.stringify(requestBody),
+		method: "POST"
+	};
+	const request = new Request(url, init);
+	const response = await fetch(request);
+	const httpStatusCode = response.status;
+	if (httpStatusCode !== 200) return [void 0, {
+		httpStatusCode,
+		errorMessage: await response.text()
+	}];
+	return [response, {
+		httpStatusCode,
+		errorMessage: ""
+	}];
 }
-export {
-  callDefaultFetch
-};
-//# sourceMappingURL=call-default-fetch.js.map
+//#endregion
+export { callDefaultFetch };
+
+//# sourceMappingURL=call-default-fetch.js.map

package/out/replicache/src/call-default-fetch.js.map

@@ -1 +1 @@
-{"version":3,"file":"call-default-fetch.js","sources":["../../../../replicache/src/call-default-fetch.ts"],"sourcesContent":["import type {HTTPRequestInfo} from './http-request-info.ts';\n\n/**\n * Helper function for {@link getDefaultPuller} and {@link getDefaultPusher}.\n */\nexport async function callDefaultFetch<Body>(\n  url: string,\n  auth: string,\n  requestID: string,\n  requestBody: Body,\n): Promise<readonly [Response | undefined, HTTPRequestInfo]> {\n  const init = {\n    headers: {\n      'Content-type': 'application/json',\n      'Authorization': auth,\n      'X-Replicache-RequestID': requestID,\n    },\n    body: JSON.stringify(requestBody),\n    method: 'POST',\n  };\n  const request = new Request(url, init);\n  const response = await fetch(request);\n  const httpStatusCode = response.status;\n  if (httpStatusCode !== 200) {\n    return [\n      undefined,\n      {\n        httpStatusCode,\n        errorMessage: await response.text(),\n      },\n    ];\n  }\n  return [\n    response,\n    {\n      httpStatusCode,\n      errorMessage: '',\n    },\n  ];\n}\n"],"names":[],"mappings":"AAKA,eAAsB,iBACpB,KACA,MACA,WACA,aAC2D;AAC3D,QAAM,OAAO;AAAA,IACX,SAAS;AAAA,MACP,gBAAgB;AAAA,MAChB,iBAAiB;AAAA,MACjB,0BAA0B;AAAA,IAAA;AAAA,IAE5B,MAAM,KAAK,UAAU,WAAW;AAAA,IAChC,QAAQ;AAAA,EAAA;AAEV,QAAM,UAAU,IAAI,QAAQ,KAAK,IAAI;AACrC,QAAM,WAAW,MAAM,MAAM,OAAO;AACpC,QAAM,iBAAiB,SAAS;AAChC,MAAI,mBAAmB,KAAK;AAC1B,WAAO;AAAA,MACL;AAAA,MACA;AAAA,QACE;AAAA,QACA,cAAc,MAAM,SAAS,KAAA;AAAA,MAAK;AAAA,IACpC;AAAA,EAEJ;AACA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,MACE;AAAA,MACA,cAAc;AAAA,IAAA;AAAA,EAChB;AAEJ;"}
+{"version":3,"file":"call-default-fetch.js","names":[],"sources":["../../../../replicache/src/call-default-fetch.ts"],"sourcesContent":["import type {HTTPRequestInfo} from './http-request-info.ts';\n\n/**\n * Helper function for {@link getDefaultPuller} and {@link getDefaultPusher}.\n */\nexport async function callDefaultFetch<Body>(\n  url: string,\n  auth: string,\n  requestID: string,\n  requestBody: Body,\n): Promise<readonly [Response | undefined, HTTPRequestInfo]> {\n  const init = {\n    headers: {\n      'Content-type': 'application/json',\n      'Authorization': auth,\n      'X-Replicache-RequestID': requestID,\n    },\n    body: JSON.stringify(requestBody),\n    method: 'POST',\n  };\n  const request = new Request(url, init);\n  const response = await fetch(request);\n  const httpStatusCode = response.status;\n  if (httpStatusCode !== 200) {\n    return [\n      undefined,\n      {\n        httpStatusCode,\n        errorMessage: await response.text(),\n      },\n    ];\n  }\n  return [\n    response,\n    {\n      httpStatusCode,\n      errorMessage: '',\n    },\n  ];\n}\n"],"mappings":";;;;AAKA,eAAsB,iBACpB,KACA,MACA,WACA,aAC2D;CAC3D,MAAM,OAAO;EACX,SAAS;GACP,gBAAgB;GAChB,iBAAiB;GACjB,0BAA0B;GAC3B;EACD,MAAM,KAAK,UAAU,YAAY;EACjC,QAAQ;EACT;CACD,MAAM,UAAU,IAAI,QAAQ,KAAK,KAAK;CACtC,MAAM,WAAW,MAAM,MAAM,QAAQ;CACrC,MAAM,iBAAiB,SAAS;AAChC,KAAI,mBAAmB,IACrB,QAAO,CACL,KAAA,GACA;EACE;EACA,cAAc,MAAM,SAAS,MAAM;EACpC,CACF;AAEH,QAAO,CACL,UACA;EACE;EACA,cAAc;EACf,CACF"}

package/out/replicache/src/config.js

@@ -0,0 +1,2 @@
+import "../../shared/src/config.js";
+export {};