@rocicorp/zero 0.25.0-canary.1 → 0.25.0-canary.11

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

@@ -0,0 +1,266 @@
+import { deepEqual } from "../../../shared/src/json.js";
+import { getSizeOfEntry } from "../../../shared/src/size-of-value.js";
+import { emptyHash } from "../hash.js";
+import { emptyDataNodeImpl, parseBTreeNode, newNodeImpl, NODE_LEVEL, NODE_ENTRIES, findLeaf, binarySearch, binarySearchFound, isDataNodeImpl } from "./node.js";
+import { computeSplices, SPLICE_AT, SPLICE_REMOVED, SPLICE_FROM, SPLICE_ADDED } from "./splice.js";
+const NODE_HEADER_SIZE = 11;
+class BTreeRead {
+  _cache = /* @__PURE__ */ new Map();
+  _dagRead;
+  _formatVersion;
+  rootHash;
+  getEntrySize;
+  chunkHeaderSize;
+  constructor(dagRead, formatVersion, root = emptyHash, getEntrySize = getSizeOfEntry, chunkHeaderSize = NODE_HEADER_SIZE) {
+    this._dagRead = dagRead;
+    this._formatVersion = formatVersion;
+    this.rootHash = root;
+    this.getEntrySize = getEntrySize;
+    this.chunkHeaderSize = chunkHeaderSize;
+  }
+  async getNode(hash) {
+    if (hash === emptyHash) {
+      return emptyDataNodeImpl;
+    }
+    const cached = this._cache.get(hash);
+    if (cached) {
+      return cached;
+    }
+    const chunk = await this._dagRead.mustGetChunk(hash);
+    const data = parseBTreeNode(
+      chunk.data,
+      this._formatVersion,
+      this.getEntrySize
+    );
+    const impl = newNodeImpl(
+      data[NODE_ENTRIES],
+      hash,
+      data[NODE_LEVEL],
+      false
+    );
+    this._cache.set(hash, impl);
+    return impl;
+  }
+  async get(key) {
+    const leaf = await findLeaf(key, this.rootHash, this, this.rootHash);
+    const index = binarySearch(key, leaf.entries);
+    if (!binarySearchFound(index, leaf.entries, key)) {
+      return void 0;
+    }
+    return leaf.entries[index][1];
+  }
+  async has(key) {
+    const leaf = await findLeaf(key, this.rootHash, this, this.rootHash);
+    const index = binarySearch(key, leaf.entries);
+    return binarySearchFound(index, leaf.entries, key);
+  }
+  async isEmpty() {
+    const { rootHash } = this;
+    const node = await this.getNode(this.rootHash);
+    if (this.rootHash !== rootHash) {
+      return this.isEmpty();
+    }
+    return node.entries.length === 0;
+  }
+  // We don't do any encoding of the key in the map, so we have no way of
+  // determining from an entry.key alone whether it is a regular key or an
+  // encoded IndexKey in an index map. Without encoding regular map keys the
+  // caller has to deal with encoding and decoding the keys for the index map.
+  scan(fromKey) {
+    return scanForHash(
+      this.rootHash,
+      () => this.rootHash,
+      this.rootHash,
+      fromKey,
+      async (hash) => {
+        const cached = await this.getNode(hash);
+        if (cached) {
+          return [
+            cached.level,
+            cached.isMutable ? cached.entries.slice() : cached.entries
+          ];
+        }
+        const chunk = await this._dagRead.mustGetChunk(hash);
+        return parseBTreeNode(
+          chunk.data,
+          this._formatVersion,
+          this.getEntrySize
+        );
+      }
+    );
+  }
+  async *keys() {
+    const node = await this.getNode(this.rootHash);
+    yield* node.keys(this);
+  }
+  async *entries() {
+    const node = await this.getNode(this.rootHash);
+    yield* node.entriesIter(this);
+  }
+  [Symbol.asyncIterator]() {
+    return this.entries();
+  }
+  async *diff(last) {
+    const [currentNode, lastNode] = await Promise.all([
+      this.getNode(this.rootHash),
+      last.getNode(last.rootHash)
+    ]);
+    yield* diffNodes(lastNode, currentNode, last, this);
+  }
+}
+async function* diffNodes(last, current, lastTree, currentTree) {
+  if (last.level > current.level) {
+    const lastChild = await last.getCompositeChildren(
+      0,
+      last.entries.length,
+      lastTree
+    );
+    yield* diffNodes(lastChild, current, lastTree, currentTree);
+    return;
+  }
+  if (current.level > last.level) {
+    const currentChild = await current.getCompositeChildren(
+      0,
+      current.entries.length,
+      currentTree
+    );
+    yield* diffNodes(last, currentChild, lastTree, currentTree);
+    return;
+  }
+  if (isDataNodeImpl(last) && isDataNodeImpl(current)) {
+    yield* diffEntries(
+      last.entries,
+      current.entries
+    );
+    return;
+  }
+  const initialSplices = computeSplices(
+    last.entries,
+    current.entries
+  );
+  for (const splice of initialSplices) {
+    const [lastChild, currentChild] = await Promise.all([
+      last.getCompositeChildren(
+        splice[SPLICE_AT],
+        splice[SPLICE_REMOVED],
+        lastTree
+      ),
+      current.getCompositeChildren(
+        splice[SPLICE_FROM],
+        splice[SPLICE_ADDED],
+        currentTree
+      )
+    ]);
+    yield* diffNodes(lastChild, currentChild, lastTree, currentTree);
+  }
+}
+function* diffEntries(lastEntries, currentEntries) {
+  const lastLength = lastEntries.length;
+  const currentLength = currentEntries.length;
+  let i = 0;
+  let j = 0;
+  while (i < lastLength && j < currentLength) {
+    const lastKey = lastEntries[i][0];
+    const currentKey = currentEntries[j][0];
+    if (lastKey === currentKey) {
+      if (!deepEqual(lastEntries[i][1], currentEntries[j][1])) {
+        yield {
+          op: "change",
+          key: lastKey,
+          oldValue: lastEntries[i][1],
+          newValue: currentEntries[j][1]
+        };
+      }
+      i++;
+      j++;
+    } else if (lastKey < currentKey) {
+      yield {
+        op: "del",
+        key: lastKey,
+        oldValue: lastEntries[i][1]
+      };
+      i++;
+    } else {
+      yield {
+        op: "add",
+        key: currentKey,
+        newValue: currentEntries[j][1]
+      };
+      j++;
+    }
+  }
+  for (; i < lastLength; i++) {
+    yield {
+      op: "del",
+      key: lastEntries[i][0],
+      oldValue: lastEntries[i][1]
+    };
+  }
+  for (; j < currentLength; j++) {
+    yield {
+      op: "add",
+      key: currentEntries[j][0],
+      newValue: currentEntries[j][1]
+    };
+  }
+}
+async function* scanForHash(expectedRootHash, getRootHash, hash, fromKey, readNode) {
+  if (hash === emptyHash) {
+    return;
+  }
+  const data = await readNode(hash);
+  const entries = data[NODE_ENTRIES];
+  let i = 0;
+  if (fromKey) {
+    i = binarySearch(fromKey, entries);
+  }
+  if (data[NODE_LEVEL] > 0) {
+    for (; i < entries.length; i++) {
+      yield* scanForHash(
+        expectedRootHash,
+        getRootHash,
+        entries[i][1],
+        fromKey,
+        readNode
+      );
+      fromKey = "";
+    }
+  } else {
+    for (; i < entries.length; i++) {
+      const rootHash = getRootHash();
+      if (expectedRootHash !== rootHash) {
+        yield* scanForHash(
+          rootHash,
+          getRootHash,
+          rootHash,
+          entries[i][0],
+          readNode
+        );
+        return;
+      }
+      yield entries[i];
+    }
+  }
+}
+async function allEntriesAsDiff(map, op) {
+  const diff = [];
+  const make = op === "add" ? (entry) => ({
+    op: "add",
+    key: entry[0],
+    newValue: entry[1]
+  }) : (entry) => ({
+    op: "del",
+    key: entry[0],
+    oldValue: entry[1]
+  });
+  for await (const entry of map.entries()) {
+    diff.push(make(entry));
+  }
+  return diff;
+}
+export {
+  BTreeRead,
+  NODE_HEADER_SIZE,
+  allEntriesAsDiff
+};
+//# sourceMappingURL=read.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"read.js","sources":["../../../../../replicache/src/btree/read.ts"],"sourcesContent":["import type {Enum} from '../../../shared/src/enum.ts';\nimport {deepEqual} from '../../../shared/src/json.ts';\nimport {getSizeOfEntry} from '../../../shared/src/size-of-value.ts';\nimport type {Read} from '../dag/store.ts';\nimport type * as FormatVersion from '../format-version-enum.ts';\nimport type {FrozenJSONValue} from '../frozen-json.ts';\nimport {type Hash, emptyHash} from '../hash.ts';\nimport type {DataNodeImpl, InternalNodeImpl} from './node.ts';\nimport {\n  type Entry,\n  type InternalDiff,\n  type InternalDiffOperation,\n  NODE_ENTRIES,\n  NODE_LEVEL,\n  binarySearch,\n  binarySearchFound,\n  emptyDataNodeImpl,\n  findLeaf,\n  isDataNodeImpl,\n  newNodeImpl,\n  parseBTreeNode,\n} from './node.ts';\nimport {\n  SPLICE_ADDED,\n  SPLICE_AT,\n  SPLICE_FROM,\n  SPLICE_REMOVED,\n  computeSplices,\n} from './splice.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\n/**\n * The size of the header of a node. (If we had compile time\n * constants we would have used that).\n *\n * There is a test ensuring this is correct.\n */\nexport const NODE_HEADER_SIZE = 11;\n\nexport class BTreeRead implements AsyncIterable<Entry<FrozenJSONValue>> {\n  protected readonly _cache: Map<Hash, DataNodeImpl | InternalNodeImpl> =\n    new Map();\n\n  protected readonly _dagRead: Read;\n  protected readonly _formatVersion: FormatVersion;\n  rootHash: Hash;\n  readonly getEntrySize: <K, V>(k: K, v: V) => number;\n  readonly chunkHeaderSize: number;\n\n  constructor(\n    dagRead: Read,\n    formatVersion: FormatVersion,\n    root: Hash = emptyHash,\n    getEntrySize: <K, V>(k: K, v: V) => number = getSizeOfEntry,\n    chunkHeaderSize = NODE_HEADER_SIZE,\n  ) {\n    this._dagRead = dagRead;\n    this._formatVersion = formatVersion;\n    this.rootHash = root;\n    this.getEntrySize = getEntrySize;\n    this.chunkHeaderSize = chunkHeaderSize;\n  }\n\n  async getNode(hash: Hash): Promise<DataNodeImpl | InternalNodeImpl> {\n    if (hash === emptyHash) {\n      return emptyDataNodeImpl;\n    }\n\n    const cached = this._cache.get(hash);\n    if (cached) {\n      return cached;\n    }\n\n    const chunk = await this._dagRead.mustGetChunk(hash);\n    const data = parseBTreeNode(\n      chunk.data,\n      this._formatVersion,\n      this.getEntrySize,\n    );\n    const impl = newNodeImpl(\n      data[NODE_ENTRIES] as Entry<FrozenJSONValue>[],\n      hash,\n      data[NODE_LEVEL],\n      false,\n    );\n    this._cache.set(hash, impl);\n    return impl;\n  }\n\n  async get(key: string): Promise<FrozenJSONValue | undefined> {\n    const leaf = await findLeaf(key, this.rootHash, this, this.rootHash);\n    const index = binarySearch(key, leaf.entries);\n    if (!binarySearchFound(index, leaf.entries, key)) {\n      return undefined;\n    }\n    return leaf.entries[index][1];\n  }\n\n  async has(key: string): Promise<boolean> {\n    const leaf = await findLeaf(key, this.rootHash, this, this.rootHash);\n    const index = binarySearch(key, leaf.entries);\n    return binarySearchFound(index, leaf.entries, key);\n  }\n\n  async isEmpty(): Promise<boolean> {\n    const {rootHash} = this;\n    const node = await this.getNode(this.rootHash);\n    // The root hash has changed, so the tree has been modified.\n    if (this.rootHash !== rootHash) {\n      return this.isEmpty();\n    }\n    return node.entries.length === 0;\n  }\n\n  // We don't do any encoding of the key in the map, so we have no way of\n  // determining from an entry.key alone whether it is a regular key or an\n  // encoded IndexKey in an index map. Without encoding regular map keys the\n  // caller has to deal with encoding and decoding the keys for the index map.\n  scan(fromKey: string): AsyncIterableIterator<Entry<FrozenJSONValue>> {\n    return scanForHash(\n      this.rootHash,\n      () => this.rootHash,\n      this.rootHash,\n      fromKey,\n      async hash => {\n        const cached = await this.getNode(hash);\n        if (cached) {\n          return [\n            cached.level,\n            cached.isMutable ? cached.entries.slice() : cached.entries,\n          ];\n        }\n        const chunk = await this._dagRead.mustGetChunk(hash);\n        return parseBTreeNode(\n          chunk.data,\n          this._formatVersion,\n          this.getEntrySize,\n        );\n      },\n    );\n  }\n\n  async *keys(): AsyncIterableIterator<string> {\n    const node = await this.getNode(this.rootHash);\n    yield* node.keys(this);\n  }\n\n  async *entries(): AsyncIterableIterator<Entry<FrozenJSONValue>> {\n    const node = await this.getNode(this.rootHash);\n    yield* node.entriesIter(this);\n  }\n\n  [Symbol.asyncIterator](): AsyncIterableIterator<Entry<FrozenJSONValue>> {\n    return this.entries();\n  }\n\n  async *diff(last: BTreeRead): AsyncIterableIterator<InternalDiffOperation> {\n    const [currentNode, lastNode] = await Promise.all([\n      this.getNode(this.rootHash),\n      last.getNode(last.rootHash),\n    ]);\n    yield* diffNodes(lastNode, currentNode, last, this);\n  }\n}\n\nasync function* diffNodes(\n  last: InternalNodeImpl | DataNodeImpl,\n  current: InternalNodeImpl | DataNodeImpl,\n  lastTree: BTreeRead,\n  currentTree: BTreeRead,\n): AsyncIterableIterator<InternalDiffOperation> {\n  if (last.level > current.level) {\n    // merge all of last's children into a new node\n    // We know last is an internal node because level > 0.\n    const lastChild = (await (last as InternalNodeImpl).getCompositeChildren(\n      0,\n      last.entries.length,\n      lastTree,\n    )) as InternalNodeImpl;\n    yield* diffNodes(lastChild, current, lastTree, currentTree);\n    return;\n  }\n\n  if (current.level > last.level) {\n    // We know current is an internal node because level > 0.\n    const currentChild = (await (\n      current as InternalNodeImpl\n    ).getCompositeChildren(\n      0,\n      current.entries.length,\n      currentTree,\n    )) as InternalNodeImpl;\n    yield* diffNodes(last, currentChild, lastTree, currentTree);\n    return;\n  }\n\n  if (isDataNodeImpl(last) && isDataNodeImpl(current)) {\n    yield* diffEntries(\n      (last as DataNodeImpl).entries,\n      (current as DataNodeImpl).entries,\n    );\n    return;\n  }\n\n  // Now we have two internal nodes with the same level. We compute the diff as\n  // splices for the internal node entries. We then flatten these and call diff\n  // recursively.\n  const initialSplices = computeSplices(\n    (last as InternalNodeImpl).entries,\n    (current as InternalNodeImpl).entries,\n  );\n  for (const splice of initialSplices) {\n    const [lastChild, currentChild] = await Promise.all([\n      (last as InternalNodeImpl).getCompositeChildren(\n        splice[SPLICE_AT],\n        splice[SPLICE_REMOVED],\n        lastTree,\n      ),\n      (current as InternalNodeImpl).getCompositeChildren(\n        splice[SPLICE_FROM],\n        splice[SPLICE_ADDED],\n        currentTree,\n      ),\n    ]);\n    yield* diffNodes(lastChild, currentChild, lastTree, currentTree);\n  }\n}\n\nfunction* diffEntries(\n  lastEntries: readonly Entry<FrozenJSONValue>[],\n  currentEntries: readonly Entry<FrozenJSONValue>[],\n): IterableIterator<InternalDiffOperation> {\n  const lastLength = lastEntries.length;\n  const currentLength = currentEntries.length;\n  let i = 0;\n  let j = 0;\n  while (i < lastLength && j < currentLength) {\n    const lastKey = lastEntries[i][0];\n    const currentKey = currentEntries[j][0];\n    if (lastKey === currentKey) {\n      if (!deepEqual(lastEntries[i][1], currentEntries[j][1])) {\n        yield {\n          op: 'change',\n          key: lastKey,\n          oldValue: lastEntries[i][1],\n          newValue: currentEntries[j][1],\n        };\n      }\n      i++;\n      j++;\n    } else if (lastKey < currentKey) {\n      yield {\n        op: 'del',\n        key: lastKey,\n        oldValue: lastEntries[i][1],\n      };\n      i++;\n    } else {\n      yield {\n        op: 'add',\n        key: currentKey,\n        newValue: currentEntries[j][1],\n      };\n      j++;\n    }\n  }\n  for (; i < lastLength; i++) {\n    yield {\n      op: 'del',\n      key: lastEntries[i][0],\n      oldValue: lastEntries[i][1],\n    };\n  }\n  for (; j < currentLength; j++) {\n    yield {\n      op: 'add',\n      key: currentEntries[j][0],\n      newValue: currentEntries[j][1],\n    };\n  }\n}\n\n// Redefine the type here to allow the optional size in the tuple.\ntype ReadNodeResult = readonly [\n  level: number,\n  data: readonly Entry<FrozenJSONValue>[] | readonly Entry<Hash>[],\n];\n\ntype ReadNode = (hash: Hash) => Promise<ReadNodeResult>;\n\nasync function* scanForHash(\n  expectedRootHash: Hash,\n  getRootHash: () => Hash,\n  hash: Hash,\n  fromKey: string,\n  readNode: ReadNode,\n): AsyncIterableIterator<Entry<FrozenJSONValue>> {\n  if (hash === emptyHash) {\n    return;\n  }\n\n  const data = await readNode(hash);\n  const entries = data[NODE_ENTRIES];\n  let i = 0;\n  if (fromKey) {\n    i = binarySearch(fromKey, entries);\n  }\n  if (data[NODE_LEVEL] > 0) {\n    for (; i < entries.length; i++) {\n      yield* scanForHash(\n        expectedRootHash,\n        getRootHash,\n        (entries[i] as Entry<Hash>)[1],\n        fromKey,\n        readNode,\n      );\n      fromKey = '';\n    }\n  } else {\n    for (; i < entries.length; i++) {\n      const rootHash = getRootHash();\n      // If rootHash changed then we start a new iterator from the key.\n      if (expectedRootHash !== rootHash) {\n        yield* scanForHash(\n          rootHash,\n          getRootHash,\n          rootHash,\n          entries[i][0],\n          readNode,\n        );\n        return;\n      }\n      yield entries[i] as Entry<FrozenJSONValue>;\n    }\n  }\n}\n\nexport async function allEntriesAsDiff(\n  map: BTreeRead,\n  op: 'add' | 'del',\n): Promise<InternalDiff> {\n  const diff: InternalDiffOperation[] = [];\n  const make: (entry: Entry<FrozenJSONValue>) => InternalDiffOperation =\n    op === 'add'\n      ? entry => ({\n          op: 'add',\n          key: entry[0],\n          newValue: entry[1],\n        })\n      : entry => ({\n          op: 'del',\n          key: entry[0],\n          oldValue: entry[1],\n        });\n\n  for await (const entry of map.entries()) {\n    diff.push(make(entry));\n  }\n  return diff;\n}\n"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,83 @@
+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;
+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;
+  }
+}
+export {
+  SPLICE_ADDED,
+  SPLICE_AT,
+  SPLICE_FROM,
+  SPLICE_REMOVED,
+  computeSplices
+};
+//# sourceMappingURL=splice.js.map

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

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

package/out/replicache/src/btree/write.d.ts

@@ -1,6 +1,6 @@
 import type { Enum } from '../../../shared/src/enum.ts';
 import type { Write } from '../dag/store.ts';
-import * as FormatVersion from '../format-version-enum.ts';
+import type * as FormatVersion from '../format-version-enum.ts';
 import type { FrozenJSONValue } from '../frozen-json.ts';
 import { type Hash } from '../hash.ts';
 import { DataNodeImpl, type Entry, InternalNodeImpl } from './node.ts';

package/out/replicache/src/btree/write.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"write.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/btree/write.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,6BAA6B,CAAC;AAItD,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,iBAAiB,CAAC;AAC3C,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAC3D,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAC,KAAK,IAAI,EAA2B,MAAM,YAAY,CAAC;AAC/D,OAAO,EACL,YAAY,EACZ,KAAK,KAAK,EACV,gBAAgB,EAOjB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAC,SAAS,EAAC,MAAM,WAAW,CAAC;AAEpC,KAAK,aAAa,GAAG,IAAI,CAAC,OAAO,aAAa,CAAC,CAAC;AAEhD,qBAAa,UAAW,SAAQ,SAAS;;IAoBvC,UAAkB,QAAQ,EAAE,KAAK,CAAC;IAElC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;gBAGvB,QAAQ,EAAE,KAAK,EACf,aAAa,EAAE,aAAa,EAC5B,IAAI,GAAE,IAAgB,EACtB,OAAO,SAAW,EAClB,OAAO,SAAY,EACnB,YAAY,GAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAuB,EAC3D,eAAe,CAAC,EAAE,MAAM;IAc1B,UAAU,CAAC,IAAI,EAAE,YAAY,GAAG,gBAAgB,GAAG,IAAI;IAOvD,mBAAmB,CACjB,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAC3B,KAAK,EAAE,MAAM,GACZ,gBAAgB;IAMnB,eAAe,CAAC,OAAO,EAAE,KAAK,CAAC,eAAe,CAAC,EAAE,GAAG,YAAY;IAMhE,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,eAAe,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,YAAY;IAC3E,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,gBAAgB;IACpE,WAAW,CACT,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,GAAG,KAAK,CAAC,eAAe,CAAC,EAAE,EACjD,KAAK,EAAE,MAAM,GACZ,gBAAgB,GAAG,YAAY;IAUlC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IA6BvD,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAqBlC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAOtB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAyBvB"}
+{"version":3,"file":"write.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/btree/write.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,6BAA6B,CAAC;AAItD,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,iBAAiB,CAAC;AAC3C,OAAO,KAAK,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAChE,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAC,KAAK,IAAI,EAA2B,MAAM,YAAY,CAAC;AAC/D,OAAO,EACL,YAAY,EACZ,KAAK,KAAK,EACV,gBAAgB,EAOjB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAC,SAAS,EAAC,MAAM,WAAW,CAAC;AAEpC,KAAK,aAAa,GAAG,IAAI,CAAC,OAAO,aAAa,CAAC,CAAC;AAEhD,qBAAa,UAAW,SAAQ,SAAS;;IAoBvC,UAAkB,QAAQ,EAAE,KAAK,CAAC;IAElC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;gBAGvB,QAAQ,EAAE,KAAK,EACf,aAAa,EAAE,aAAa,EAC5B,IAAI,GAAE,IAAgB,EACtB,OAAO,SAAW,EAClB,OAAO,SAAY,EACnB,YAAY,GAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAuB,EAC3D,eAAe,CAAC,EAAE,MAAM;IAc1B,UAAU,CAAC,IAAI,EAAE,YAAY,GAAG,gBAAgB,GAAG,IAAI;IAOvD,mBAAmB,CACjB,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAC3B,KAAK,EAAE,MAAM,GACZ,gBAAgB;IAMnB,eAAe,CAAC,OAAO,EAAE,KAAK,CAAC,eAAe,CAAC,EAAE,GAAG,YAAY;IAMhE,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,eAAe,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,YAAY;IAC3E,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,gBAAgB;IACpE,WAAW,CACT,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,GAAG,KAAK,CAAC,eAAe,CAAC,EAAE,EACjD,KAAK,EAAE,MAAM,GACZ,gBAAgB,GAAG,YAAY;IAUlC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IA6BvD,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAqBlC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAOtB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAyBvB"}

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

@@ -0,0 +1,163 @@
+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 { 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);
+    this.#modified.set(node.hash, node);
+    this._cache.set(node.hash, node);
+  }
+  updateNode(node) {
+    assert(node.isMutable);
+    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;
+    });
+  }
+}
+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;
+}
+export {
+  BTreeWrite
+};
+//# sourceMappingURL=write.js.map

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

@@ -0,0 +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);\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);\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":"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"}

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

@@ -0,0 +1,34 @@
+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: ""
+    }
+  ];
+}
+export {
+  callDefaultFetch
+};
+//# sourceMappingURL=call-default-fetch.js.map

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

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

package/out/replicache/src/connection-loop-delegates.js

@@ -0,0 +1,34 @@
+class ConnectionLoopDelegateImpl {
+  rep;
+  invokeSend;
+  // TODO: Remove the ability to have more than one concurrent connection and update tests.
+  // Bug: https://github.com/rocicorp/replicache-internal/issues/303
+  maxConnections = 1;
+  constructor(rep, invokeSend) {
+    this.rep = rep;
+    this.invokeSend = invokeSend;
+  }
+  get maxDelayMs() {
+    return this.rep.requestOptions.maxDelayMs;
+  }
+  get minDelayMs() {
+    return this.rep.requestOptions.minDelayMs;
+  }
+}
+class PullDelegate extends ConnectionLoopDelegateImpl {
+  debounceDelay = 0;
+  get watchdogTimer() {
+    return this.rep.pullInterval;
+  }
+}
+class PushDelegate extends ConnectionLoopDelegateImpl {
+  get debounceDelay() {
+    return this.rep.pushDelay;
+  }
+  watchdogTimer = null;
+}
+export {
+  PullDelegate,
+  PushDelegate
+};
+//# sourceMappingURL=connection-loop-delegates.js.map