@rocicorp/zero 1.12.0-canary.2 → 1.12.0-canary.4

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

@@ -1 +1 @@
-{"version":3,"file":"node.js","names":["#childNodeSize","#splice","#mergeAndPartition","#replaceChild"],"sources":["../../../../../replicache/src/btree/node.ts"],"sourcesContent":["import {compareUTF8} from 'compare-utf8';\nimport {newArray} from '../../../shared/src/arrays.ts';\nimport {\n  assert,\n  assertArray,\n  assertNumber,\n  assertString,\n} from '../../../shared/src/asserts.ts';\nimport {binarySearch as binarySearchWithFunc} from '../../../shared/src/binary-search.ts';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport {joinIterables} from '../../../shared/src/iterables.ts';\nimport {\n  type JSONValue,\n  type ReadonlyJSONValue,\n  assertJSONValue,\n} from '../../../shared/src/json.ts';\nimport {getOrInsertComputed} from '../../../shared/src/map.ts';\nimport {skipBTreeNodeAsserts} from '../config.ts';\nimport type {IndexKey} from '../db/index.ts';\nimport * as FormatVersion from '../format-version-enum.ts';\nimport {\n  type FrozenJSONValue,\n  type FrozenTag,\n  assertDeepFrozen,\n  deepFreeze,\n} from '../frozen-json.ts';\nimport {type Hash, emptyHash, newRandomHash} from '../hash.ts';\nimport type {BTreeRead} from './read.ts';\nimport type {BTreeWrite} from './write.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\nexport type Entry<V> = readonly [key: string, value: V, sizeOfEntry: number];\n\nexport const NODE_LEVEL = 0;\nexport const NODE_ENTRIES = 1;\n\n/**\n * The type of B+Tree node chunk data\n */\ntype BaseNode<V> = FrozenTag<\n  readonly [level: number, entries: ReadonlyArray<Entry<V>>]\n>;\nexport type InternalNode = BaseNode<Hash>;\n\nexport type DataNode = BaseNode<FrozenJSONValue>;\n\nexport function makeNodeChunkData<V>(\n  level: number,\n  entries: ReadonlyArray<Entry<V>>,\n  formatVersion: FormatVersion,\n): BaseNode<V> {\n  return deepFreeze([\n    level,\n    (formatVersion >= FormatVersion.V7\n      ? entries\n      : entries.map(e => e.slice(0, 2))) as readonly ReadonlyJSONValue[],\n  ]) as BaseNode<V>;\n}\n\nexport type Node = DataNode | InternalNode;\n\n/**\n * Describes the changes that happened to Replicache after a\n * {@link WriteTransaction} was committed.\n *\n * @experimental This type is experimental and may change in the future.\n */\nexport type Diff = IndexDiff | NoIndexDiff;\n\n/**\n * @experimental This type is experimental and may change in the future.\n */\nexport type IndexDiff = readonly DiffOperation<IndexKey>[];\n\n/**\n * @experimental This type is experimental and may change in the future.\n */\nexport type NoIndexDiff = readonly DiffOperation<string>[];\n\n/**\n * InternalDiff uses string keys even for the secondary index maps.\n */\nexport type InternalDiff = readonly InternalDiffOperation[];\n\nexport type DiffOperationAdd<Key, Value = ReadonlyJSONValue> = {\n  readonly op: 'add';\n  readonly key: Key;\n  readonly newValue: Value;\n};\n\nexport type DiffOperationDel<Key, Value = ReadonlyJSONValue> = {\n  readonly op: 'del';\n  readonly key: Key;\n  readonly oldValue: Value;\n};\n\nexport type DiffOperationChange<Key, Value = ReadonlyJSONValue> = {\n  readonly op: 'change';\n  readonly key: Key;\n  readonly oldValue: Value;\n  readonly newValue: Value;\n};\n\n/**\n * The individual parts describing the changes that happened to the Replicache\n * data. There are three different kinds of operations:\n * - `add`: A new entry was added.\n * - `del`: An entry was deleted.\n * - `change`: An entry was changed.\n *\n * @experimental This type is experimental and may change in the future.\n */\nexport type DiffOperation<Key> =\n  | DiffOperationAdd<Key>\n  | DiffOperationDel<Key>\n  | DiffOperationChange<Key>;\n\n// Duplicated with DiffOperation to make the docs less confusing.\nexport type InternalDiffOperation<Key = string, Value = FrozenJSONValue> =\n  | DiffOperationAdd<Key, Value>\n  | DiffOperationDel<Key, Value>\n  | DiffOperationChange<Key, Value>;\n\n/**\n * Finds the leaf where a key is (if present) or where it should go if not\n * present.\n */\nexport async function findLeaf(\n  key: string,\n  hash: Hash,\n  source: BTreeRead,\n  expectedRootHash: Hash,\n): Promise<DataNodeImpl> {\n  const node = await source.getNode(hash);\n  // The root changed. Try again\n  if (expectedRootHash !== source.rootHash) {\n    return findLeaf(key, source.rootHash, source, source.rootHash);\n  }\n  if (isDataNodeImpl(node)) {\n    return node;\n  }\n  const {entries} = node;\n  let i = binarySearch(key, entries);\n  if (i === entries.length) {\n    i--;\n  }\n  const entry = entries[i];\n  return findLeaf(key, entry[1], source, expectedRootHash);\n}\n\ntype BinarySearchEntries = readonly Entry<unknown>[];\n\n/**\n * Does a binary search over entries\n *\n * If the key found then the return value is the index it was found at.\n *\n * If the key was *not* found then the return value is the index where it should\n * be inserted at\n */\nexport function binarySearch(\n  key: string,\n  entries: BinarySearchEntries,\n): number {\n  return binarySearchFrom(key, entries, 0);\n}\n\n/**\n * Binary search starting from a given index.\n */\nfunction binarySearchFrom(\n  key: string,\n  entries: BinarySearchEntries,\n  start: number,\n): number {\n  const result = binarySearchWithFunc(entries.length - start, i =>\n    compareUTF8(key, entries[start + i][0]),\n  );\n  return start + result;\n}\n\nexport function binarySearchFound(\n  i: number,\n  entries: BinarySearchEntries,\n  key: string,\n): boolean {\n  return i !== entries.length && entries[i][0] === key;\n}\n\nexport function parseBTreeNode(\n  v: unknown,\n  formatVersion: FormatVersion,\n  getSizeOfEntry: <K, V>(key: K, value: V) => number,\n): InternalNode | DataNode {\n  if (skipBTreeNodeAsserts && formatVersion >= FormatVersion.V7) {\n    return v as InternalNode | DataNode;\n  }\n\n  assertArray(v);\n  assertDeepFrozen(v);\n  // Be relaxed about what we accept.\n  assert(v.length >= 2, 'Expected node array to have at least 2 elements');\n  const [level, entries] = v;\n  assertNumber(level);\n  assertArray(entries);\n\n  const f = level > 0 ? assertString : assertJSONValue;\n\n  // For V7 we do not need to change the entries. Just assert that they are correct.\n  if (formatVersion >= FormatVersion.V7) {\n    for (const e of entries) {\n      assertEntry(e, f);\n    }\n    return v as unknown as InternalNode | DataNode;\n  }\n\n  const newEntries = entries.map(e => convertNonV7Entry(e, f, getSizeOfEntry));\n  return [level, newEntries] as unknown as InternalNode | DataNode;\n}\n\nfunction assertEntry(\n  entry: unknown,\n  f:\n    | ((v: unknown) => asserts v is Hash)\n    | ((v: unknown) => asserts v is JSONValue),\n): asserts entry is Entry<Hash | JSONValue> {\n  assertArray(entry);\n  // Be relaxed about what we accept.\n  assert(entry.length >= 3, 'Expected entry array to have at least 3 elements');\n  assertString(entry[0]);\n  f(entry[1]);\n  assertNumber(entry[2]);\n}\n\n/**\n * Converts an entry that was from a format version before V7 to the format\n * wanted by V7.\n */\nfunction convertNonV7Entry(\n  entry: unknown,\n  f:\n    | ((v: unknown) => asserts v is Hash)\n    | ((v: unknown) => asserts v is JSONValue),\n  getSizeOfEntry: <K, V>(key: K, value: V) => number,\n): Entry<Hash | JSONValue> {\n  assertArray(entry);\n  assert(entry.length >= 2, 'Expected entry array to have at least 2 elements');\n  assertString(entry[0]);\n  f(entry[1]);\n  const entrySize = getSizeOfEntry(entry[0], entry[1]);\n  return [entry[0], entry[1], entrySize] as Entry<Hash | JSONValue>;\n}\n\nexport function isInternalNode(node: Node): node is InternalNode {\n  return node[NODE_LEVEL] > 0;\n}\n\nabstract class NodeImpl<Value> {\n  entries: Array<Entry<Value>>;\n  hash: Hash;\n  abstract readonly level: number;\n  readonly isMutable: boolean;\n\n  #childNodeSize = -1;\n\n  constructor(entries: Array<Entry<Value>>, hash: Hash, isMutable: boolean) {\n    this.entries = entries;\n    this.hash = hash;\n    this.isMutable = isMutable;\n  }\n\n  abstract set(\n    key: string,\n    value: FrozenJSONValue,\n    entrySize: number,\n    tree: BTreeWrite,\n  ): Promise<NodeImpl<Value>>;\n\n  abstract putMany(\n    entries: ReadonlyArray<Entry<FrozenJSONValue>>,\n    tree: BTreeWrite,\n  ): Promise<NodeImpl<Value>>;\n\n  abstract del(\n    key: string,\n    tree: BTreeWrite,\n  ): Promise<NodeImpl<Value> | DataNodeImpl>;\n\n  maxKey(): string {\n    // oxlint-disable-next-line typescript/no-non-null-assertion\n    return this.entries.at(-1)![0];\n  }\n\n  getChildNodeSize(tree: BTreeRead): number {\n    if (this.#childNodeSize !== -1) {\n      return this.#childNodeSize;\n    }\n\n    let sum = tree.chunkHeaderSize;\n    for (const entry of this.entries) {\n      sum += entry[2];\n    }\n    return (this.#childNodeSize = sum);\n  }\n\n  protected _updateNode(tree: BTreeWrite) {\n    this.#childNodeSize = -1;\n    tree.updateNode(\n      this as NodeImpl<unknown> as DataNodeImpl | InternalNodeImpl,\n    );\n  }\n}\n\nexport function toChunkData<V>(\n  node: NodeImpl<V>,\n  formatVersion: FormatVersion,\n): BaseNode<V> {\n  return makeNodeChunkData(node.level, node.entries, formatVersion);\n}\n\nexport class DataNodeImpl extends NodeImpl<FrozenJSONValue> {\n  readonly level = 0;\n\n  set(\n    key: string,\n    value: FrozenJSONValue,\n    entrySize: number,\n    tree: BTreeWrite,\n  ): Promise<DataNodeImpl> {\n    let deleteCount: number;\n    const i = binarySearch(key, this.entries);\n    if (!binarySearchFound(i, this.entries, key)) {\n      // Not found, insert.\n      deleteCount = 0;\n    } else {\n      deleteCount = 1;\n    }\n\n    return Promise.resolve(\n      this.#splice(tree, i, deleteCount, [key, value, entrySize]),\n    );\n  }\n\n  putMany(\n    entries: ReadonlyArray<Entry<FrozenJSONValue>>,\n    tree: BTreeWrite,\n  ): Promise<DataNodeImpl> {\n    if (entries.length === 0) {\n      return Promise.resolve(this);\n    }\n\n    // Merge sorted entries with existing entries\n    const merged: Entry<FrozenJSONValue>[] = [];\n    let i = 0; // index in this.entries\n    let j = 0; // index in entries\n\n    while (i < this.entries.length && j < entries.length) {\n      const existingEntry = this.entries[i];\n      const newEntry = entries[j];\n      const cmp = compareUTF8(existingEntry[0], newEntry[0]);\n\n      if (cmp < 0) {\n        merged.push(existingEntry);\n        i++;\n      } else if (cmp > 0) {\n        merged.push(newEntry);\n        j++;\n      } else {\n        // Same key, new entry wins (update)\n        merged.push(newEntry);\n        i++;\n        j++;\n      }\n    }\n\n    // Add remaining entries\n    while (i < this.entries.length) {\n      merged.push(this.entries[i]);\n      i++;\n    }\n    while (j < entries.length) {\n      merged.push(entries[j]);\n      j++;\n    }\n\n    if (this.isMutable) {\n      this.entries = merged;\n      this._updateNode(tree);\n      return Promise.resolve(this);\n    }\n\n    return Promise.resolve(tree.newDataNodeImpl(merged));\n  }\n\n  #splice(\n    tree: BTreeWrite,\n    start: number,\n    deleteCount: number,\n    ...items: Entry<FrozenJSONValue>[]\n  ): DataNodeImpl {\n    if (this.isMutable) {\n      this.entries.splice(start, deleteCount, ...items);\n      this._updateNode(tree);\n      return this;\n    }\n\n    const entries = readonlySplice(this.entries, start, deleteCount, ...items);\n    return tree.newDataNodeImpl(entries);\n  }\n\n  del(key: string, tree: BTreeWrite): Promise<DataNodeImpl> {\n    const i = binarySearch(key, this.entries);\n    if (!binarySearchFound(i, this.entries, key)) {\n      // Not found. Return this without changes.\n      return Promise.resolve(this);\n    }\n\n    // Found. Create new node or mutate existing one.\n    return Promise.resolve(this.#splice(tree, i, 1));\n  }\n\n  async *keys(_tree: BTreeRead): AsyncGenerator<string, void> {\n    for (const entry of this.entries) {\n      yield entry[0];\n    }\n  }\n\n  async *entriesIter(\n    _tree: BTreeRead,\n  ): AsyncGenerator<Entry<FrozenJSONValue>, void> {\n    for (const entry of this.entries) {\n      yield entry;\n    }\n  }\n}\n\nfunction readonlySplice<T>(\n  array: ReadonlyArray<T>,\n  start: number,\n  deleteCount: number,\n  ...items: T[]\n): T[] {\n  const arr = array.slice(0, start);\n  for (let i = 0; i < items.length; i++) {\n    arr.push(items[i]);\n  }\n  for (let i = start + deleteCount; i < array.length; i++) {\n    arr.push(array[i]);\n  }\n  return arr;\n}\n\nexport class InternalNodeImpl extends NodeImpl<Hash> {\n  readonly level: number;\n\n  constructor(\n    entries: Array<Entry<Hash>>,\n    hash: Hash,\n    level: number,\n    isMutable: boolean,\n  ) {\n    super(entries, hash, isMutable);\n    this.level = level;\n  }\n\n  async set(\n    key: string,\n    value: FrozenJSONValue,\n    entrySize: number,\n    tree: BTreeWrite,\n  ): Promise<InternalNodeImpl> {\n    let i = binarySearch(key, this.entries);\n    if (i === this.entries.length) {\n      // We are going to insert into last (right most) leaf.\n      i--;\n    }\n\n    const childHash = this.entries[i][1];\n    const oldChildNode = await tree.getNode(childHash);\n\n    const childNode = await oldChildNode.set(key, value, entrySize, tree);\n\n    const childNodeSize = childNode.getChildNodeSize(tree);\n    if (childNodeSize > tree.maxSize || childNodeSize < tree.minSize) {\n      return this.#mergeAndPartition(tree, i, childNode);\n    }\n\n    const newEntry = createNewInternalEntryForNode(\n      childNode,\n      tree.getEntrySize,\n    );\n    return this.#replaceChild(tree, i, newEntry);\n  }\n\n  async putMany(\n    entries: ReadonlyArray<Entry<FrozenJSONValue>>,\n    tree: BTreeWrite,\n  ): Promise<InternalNodeImpl> {\n    if (entries.length === 0) {\n      return this;\n    }\n\n    // Group entries by child index\n    // Since entries are sorted, we can restrict the binary search range\n    const childGroups: Map<number, Entry<FrozenJSONValue>[]> = new Map();\n\n    let searchStart = 0;\n    for (const entry of entries) {\n      const key = entry[0];\n      // Binary search from searchStart to end (entries are sorted)\n      let i = binarySearchFrom(key, this.entries, searchStart);\n      if (i === this.entries.length) {\n        // Insert into last (right most) leaf.\n        i--;\n      }\n      searchStart = i;\n\n      getOrInsertComputed(childGroups, i, newArray).push(entry);\n    }\n\n    // Process each affected child\n    const newEntries = [...this.entries];\n    const childrenToRebalance: Array<{\n      index: number;\n      node: DataNodeImpl | InternalNodeImpl;\n    }> = [];\n\n    for (const [childIndex, childEntries] of childGroups) {\n      const childHash = this.entries[childIndex][1];\n      const oldChildNode = await tree.getNode(childHash);\n      const childNode = await oldChildNode.putMany(childEntries, tree);\n\n      const childNodeSize = childNode.getChildNodeSize(tree);\n      if (childNodeSize > tree.maxSize || childNodeSize < tree.minSize) {\n        childrenToRebalance.push({index: childIndex, node: childNode});\n      } else {\n        const newEntry = createNewInternalEntryForNode(\n          childNode,\n          tree.getEntrySize,\n        );\n        newEntries[childIndex] = newEntry;\n      }\n    }\n\n    // Handle rebalancing - merge adjacent children that need rebalancing\n    // into contiguous groups and process each group as one unit.\n    //\n    // BUG FIX: Previously, each child was rebalanced independently R-to-L.\n    // When adjacent children (e.g., indices 0 and 1) both needed rebalancing,\n    // child[1] would merge with sibling[0] (the ORIGINAL), then child[0]\n    // would merge with the rebalanced result at position 1, duplicating\n    // child[0]'s data. The fix groups adjacent indices together.\n    if (childrenToRebalance.length > 0) {\n      childrenToRebalance.sort((a, b) => a.index - b.index);\n\n      // Group adjacent indices into contiguous runs, each extended by one\n      // sibling on either side for merge context.\n      const groups: Array<{\n        nodes: Map<number, DataNodeImpl | InternalNodeImpl>;\n        minIndex: number;\n        maxIndex: number;\n      }> = [];\n\n      for (const {index, node} of childrenToRebalance) {\n        const lastGroup = groups.at(-1);\n        // Adjacent to previous group? (within 1 index of the last group's max)\n        if (lastGroup && index <= lastGroup.maxIndex + 1) {\n          lastGroup.nodes.set(index, node);\n          lastGroup.maxIndex = index;\n        } else {\n          groups.push({\n            nodes: new Map([[index, node]]),\n            minIndex: index,\n            maxIndex: index,\n          });\n        }\n      }\n\n      // Process groups from right to left to maintain indices during splices.\n      for (let g = groups.length - 1; g >= 0; g--) {\n        const group = groups[g];\n\n        // Extend range by one sibling on each side for merge context.\n        const startIndex = Math.max(0, group.minIndex - 1);\n        const endIndex = Math.min(newEntries.length - 1, group.maxIndex + 1);\n        const removeCount = endIndex - startIndex + 1;\n\n        // Collect all entries from the range: use the putMany result for\n        // indices that were rebalanced, the current newEntries node otherwise.\n        type IterableHashEntries = Iterable<Entry<Hash>>;\n        const allValues: IterableHashEntries[] = [];\n        for (let idx = startIndex; idx <= endIndex; idx++) {\n          const rebalancedNode = group.nodes.get(idx);\n          if (rebalancedNode) {\n            allValues.push(rebalancedNode.entries as IterableHashEntries);\n          } else {\n            const hash = newEntries[idx][1];\n            const existingNode = await tree.getNode(hash);\n            allValues.push(existingNode.entries as IterableHashEntries);\n          }\n        }\n\n        const level = this.level - 1;\n        const merged = joinIterables(...allValues);\n        const rebalanced = partition(\n          merged,\n          e => e[2],\n          tree.minSize - tree.chunkHeaderSize,\n          tree.maxSize - tree.chunkHeaderSize,\n          entries => {\n            const node = tree.newNodeImpl(entries, level);\n            return createNewInternalEntryForNode(node, tree.getEntrySize);\n          },\n        );\n\n        newEntries.splice(startIndex, removeCount, ...rebalanced);\n      }\n    }\n\n    if (this.isMutable) {\n      this.entries = newEntries;\n      this._updateNode(tree);\n      return this;\n    }\n\n    return tree.newInternalNodeImpl(newEntries, this.level);\n  }\n\n  /**\n   * This merges the child node entries with previous or next sibling and then\n   * partitions the merged entries.\n   */\n  async #mergeAndPartition(\n    tree: BTreeWrite,\n    i: number,\n    childNode: DataNodeImpl | InternalNodeImpl,\n  ): Promise<InternalNodeImpl> {\n    const level = this.level - 1;\n    const thisEntries = this.entries;\n\n    type IterableHashEntries = Iterable<Entry<Hash>>;\n\n    let values: IterableHashEntries;\n    let startIndex: number;\n    let removeCount: number;\n    if (i > 0) {\n      const hash = thisEntries[i - 1][1];\n      const previousSibling = await tree.getNode(hash);\n      values = joinIterables(\n        previousSibling.entries as IterableHashEntries,\n        childNode.entries as IterableHashEntries,\n      );\n      startIndex = i - 1;\n      removeCount = 2;\n    } else if (i < thisEntries.length - 1) {\n      const hash = thisEntries[i + 1][1];\n      const nextSibling = await tree.getNode(hash);\n      values = joinIterables(\n        childNode.entries as IterableHashEntries,\n        nextSibling.entries as IterableHashEntries,\n      );\n      startIndex = i;\n      removeCount = 2;\n    } else {\n      values = childNode.entries as IterableHashEntries;\n      startIndex = i;\n      removeCount = 1;\n    }\n\n    const newEntries = partition(\n      values,\n      value => value[2],\n      tree.minSize - tree.chunkHeaderSize,\n      tree.maxSize - tree.chunkHeaderSize,\n      entries => {\n        const node = tree.newNodeImpl(entries, level);\n        return createNewInternalEntryForNode(node, tree.getEntrySize);\n      },\n    );\n\n    if (this.isMutable) {\n      this.entries.splice(startIndex, removeCount, ...newEntries);\n      this._updateNode(tree);\n      return this;\n    }\n\n    const entries = readonlySplice(\n      thisEntries,\n      startIndex,\n      removeCount,\n      ...newEntries,\n    );\n\n    return tree.newInternalNodeImpl(entries, this.level);\n  }\n\n  #replaceChild(\n    tree: BTreeWrite,\n    index: number,\n    newEntry: Entry<Hash>,\n  ): InternalNodeImpl {\n    if (this.isMutable) {\n      this.entries.splice(index, 1, newEntry);\n      this._updateNode(tree);\n      return this;\n    }\n    const entries = readonlySplice(this.entries, index, 1, newEntry);\n    return tree.newInternalNodeImpl(entries, this.level);\n  }\n\n  async del(\n    key: string,\n    tree: BTreeWrite,\n  ): Promise<InternalNodeImpl | DataNodeImpl> {\n    const i = binarySearch(key, this.entries);\n    if (i === this.entries.length) {\n      // Key is larger than maxKey of rightmost entry so it is not present.\n      return this;\n    }\n\n    const childHash = this.entries[i][1];\n    const oldChildNode = await tree.getNode(childHash);\n    const oldHash = oldChildNode.hash;\n\n    const childNode = await oldChildNode.del(key, tree);\n    if (childNode.hash === oldHash) {\n      // Not changed so not found.\n      return this;\n    }\n\n    if (childNode.entries.length === 0) {\n      // Subtree is now empty. Remove internal node.\n      const entries = readonlySplice(this.entries, i, 1);\n      return tree.newInternalNodeImpl(entries, this.level);\n    }\n\n    if (i === 0 && this.entries.length === 1) {\n      // There was only one node at this level and it was removed. We can return\n      // the modified subtree.\n      return childNode;\n    }\n\n    // The child node is still a good size.\n    if (childNode.getChildNodeSize(tree) > tree.minSize) {\n      // No merging needed.\n      const entry = createNewInternalEntryForNode(childNode, tree.getEntrySize);\n      return this.#replaceChild(tree, i, entry);\n    }\n\n    // Child node size is too small.\n    return this.#mergeAndPartition(tree, i, childNode);\n  }\n\n  async *keys(tree: BTreeRead): AsyncGenerator<string, void> {\n    for (const entry of this.entries) {\n      const childNode = await tree.getNode(entry[1]);\n      yield* childNode.keys(tree);\n    }\n  }\n\n  async *entriesIter(\n    tree: BTreeRead,\n  ): AsyncGenerator<Entry<FrozenJSONValue>, void> {\n    for (const entry of this.entries) {\n      const childNode = await tree.getNode(entry[1]);\n      yield* childNode.entriesIter(tree);\n    }\n  }\n\n  getChildren(\n    start: number,\n    length: number,\n    tree: BTreeRead,\n  ): Promise<Array<InternalNodeImpl | DataNodeImpl>> {\n    const ps: Promise<DataNodeImpl | InternalNodeImpl>[] = [];\n    for (let i = start; i < length && i < this.entries.length; i++) {\n      ps.push(tree.getNode(this.entries[i][1]));\n    }\n    return Promise.all(ps);\n  }\n\n  async getCompositeChildren(\n    start: number,\n    length: number,\n    tree: BTreeRead,\n  ): Promise<InternalNodeImpl | DataNodeImpl> {\n    const {level} = this;\n\n    if (length === 0) {\n      return new InternalNodeImpl([], newRandomHash(), level - 1, true);\n    }\n\n    const output = await this.getChildren(start, start + length, tree);\n\n    if (level > 1) {\n      const entries: Entry<Hash>[] = [];\n      for (const child of output as InternalNodeImpl[]) {\n        entries.push(...child.entries);\n      }\n      return new InternalNodeImpl(entries, newRandomHash(), level - 1, true);\n    }\n\n    assert(level === 1, 'Expected level to be 1');\n    const entries: Entry<FrozenJSONValue>[] = [];\n    for (const child of output as DataNodeImpl[]) {\n      entries.push(...child.entries);\n    }\n    return new DataNodeImpl(entries, newRandomHash(), true);\n  }\n}\n\nexport function newNodeImpl(\n  entries: Array<Entry<FrozenJSONValue>>,\n  hash: Hash,\n  level: number,\n  isMutable: boolean,\n): DataNodeImpl;\nexport function newNodeImpl(\n  entries: Array<Entry<Hash>>,\n  hash: Hash,\n  level: number,\n  isMutable: boolean,\n): InternalNodeImpl;\nexport function newNodeImpl(\n  entries: Array<Entry<FrozenJSONValue>> | Array<Entry<Hash>>,\n  hash: Hash,\n  level: number,\n  isMutable: boolean,\n): DataNodeImpl | InternalNodeImpl;\nexport function newNodeImpl(\n  entries: Array<Entry<FrozenJSONValue>> | Array<Entry<Hash>>,\n  hash: Hash,\n  level: number,\n  isMutable: boolean,\n): DataNodeImpl | InternalNodeImpl {\n  if (level === 0) {\n    return new DataNodeImpl(\n      entries as Entry<FrozenJSONValue>[],\n      hash,\n      isMutable,\n    );\n  }\n  return new InternalNodeImpl(entries as Entry<Hash>[], hash, level, isMutable);\n}\n\nexport function isDataNodeImpl(\n  node: DataNodeImpl | InternalNodeImpl,\n): node is DataNodeImpl {\n  return node.level === 0;\n}\n\nexport function partition<T, R>(\n  values: Iterable<T>,\n  // This is the size of each Entry\n  getSizeOfEntry: (v: T) => number,\n  min: number,\n  max: number,\n  create: (entries: T[]) => R,\n): R[] {\n  const results: R[] = [];\n  let sum = 0;\n  let accum: T[] = [];\n  // The most recently finalized partition, held back until we know it won't be\n  // merged with trailing entries.\n  let lastPartition: T[] | null = null;\n  let lastSize = 0;\n\n  function commitLast() {\n    if (lastPartition !== null) {\n      results.push(create(lastPartition));\n      lastPartition = null;\n    }\n  }\n\n  for (const value of values) {\n    const size = getSizeOfEntry(value);\n    if (size >= max) {\n      if (accum.length > 0) {\n        commitLast();\n        lastPartition = accum;\n        lastSize = sum;\n        accum = [];\n        sum = 0;\n      }\n      commitLast();\n      lastPartition = [value];\n      lastSize = size;\n    } else if (sum + size >= min) {\n      accum.push(value);\n      commitLast();\n      lastPartition = accum;\n      lastSize = sum + size;\n      accum = [];\n      sum = 0;\n    } else {\n      sum += size;\n      accum.push(value);\n    }\n  }\n\n  if (sum > 0) {\n    if (lastPartition !== null && sum + lastSize <= max) {\n      lastPartition.push(...accum);\n      commitLast();\n    } else {\n      commitLast();\n      results.push(create(accum));\n    }\n  } else {\n    commitLast();\n  }\n\n  return results;\n}\n\nexport const emptyDataNode = makeNodeChunkData<ReadonlyJSONValue>(\n  0,\n  [],\n  FormatVersion.Latest,\n);\nexport const emptyDataNodeImpl = new DataNodeImpl([], emptyHash, false);\n\nexport function createNewInternalEntryForNode(\n  node: NodeImpl<unknown>,\n  getSizeOfEntry: <K, V>(k: K, v: V) => number,\n): [string, Hash, number] {\n  const key = node.maxKey();\n  const value = node.hash;\n  const size = getSizeOfEntry(key, value);\n  return [key, value, size];\n}\n"],"mappings":"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"}
+{"version":3,"file":"node.js","names":["binarySearchWithFunc","skipBTreeNodeAsserts"],"sources":["../../../../../replicache/src/btree/node.ts"],"sourcesContent":["import {compareUTF8} from 'compare-utf8';\nimport {newArray} from '../../../shared/src/arrays.ts';\nimport {\n  assert,\n  assertArray,\n  assertNumber,\n  assertString,\n} from '../../../shared/src/asserts.ts';\nimport {binarySearch as binarySearchWithFunc} from '../../../shared/src/binary-search.ts';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport {joinIterables} from '../../../shared/src/iterables.ts';\nimport {\n  type JSONValue,\n  type ReadonlyJSONValue,\n  assertJSONValue,\n} from '../../../shared/src/json.ts';\nimport {getOrInsertComputed} from '../../../shared/src/map.ts';\nimport {skipBTreeNodeAsserts} from '../config.ts';\nimport type {IndexKey} from '../db/index.ts';\nimport * as FormatVersion from '../format-version-enum.ts';\nimport {\n  type FrozenJSONValue,\n  type FrozenTag,\n  assertDeepFrozen,\n  deepFreeze,\n} from '../frozen-json.ts';\nimport {type Hash, emptyHash, newRandomHash} from '../hash.ts';\nimport type {BTreeRead} from './read.ts';\nimport type {BTreeWrite} from './write.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\nexport type Entry<V> = readonly [key: string, value: V, sizeOfEntry: number];\n\nexport const NODE_LEVEL = 0;\nexport const NODE_ENTRIES = 1;\n\n/**\n * The type of B+Tree node chunk data\n */\ntype BaseNode<V> = FrozenTag<\n  readonly [level: number, entries: ReadonlyArray<Entry<V>>]\n>;\nexport type InternalNode = BaseNode<Hash>;\n\nexport type DataNode = BaseNode<FrozenJSONValue>;\n\nexport function makeNodeChunkData<V>(\n  level: number,\n  entries: ReadonlyArray<Entry<V>>,\n  formatVersion: FormatVersion,\n): BaseNode<V> {\n  return deepFreeze([\n    level,\n    (formatVersion >= FormatVersion.V7\n      ? entries\n      : entries.map(e => e.slice(0, 2))) as readonly ReadonlyJSONValue[],\n  ]) as BaseNode<V>;\n}\n\nexport type Node = DataNode | InternalNode;\n\n/**\n * Describes the changes that happened to Replicache after a\n * {@link WriteTransaction} was committed.\n *\n * @experimental This type is experimental and may change in the future.\n */\nexport type Diff = IndexDiff | NoIndexDiff;\n\n/**\n * @experimental This type is experimental and may change in the future.\n */\nexport type IndexDiff = readonly DiffOperation<IndexKey>[];\n\n/**\n * @experimental This type is experimental and may change in the future.\n */\nexport type NoIndexDiff = readonly DiffOperation<string>[];\n\n/**\n * InternalDiff uses string keys even for the secondary index maps.\n */\nexport type InternalDiff = readonly InternalDiffOperation[];\n\nexport type DiffOperationAdd<Key, Value = ReadonlyJSONValue> = {\n  readonly op: 'add';\n  readonly key: Key;\n  readonly newValue: Value;\n};\n\nexport type DiffOperationDel<Key, Value = ReadonlyJSONValue> = {\n  readonly op: 'del';\n  readonly key: Key;\n  readonly oldValue: Value;\n};\n\nexport type DiffOperationChange<Key, Value = ReadonlyJSONValue> = {\n  readonly op: 'change';\n  readonly key: Key;\n  readonly oldValue: Value;\n  readonly newValue: Value;\n};\n\n/**\n * The individual parts describing the changes that happened to the Replicache\n * data. There are three different kinds of operations:\n * - `add`: A new entry was added.\n * - `del`: An entry was deleted.\n * - `change`: An entry was changed.\n *\n * @experimental This type is experimental and may change in the future.\n */\nexport type DiffOperation<Key> =\n  | DiffOperationAdd<Key>\n  | DiffOperationDel<Key>\n  | DiffOperationChange<Key>;\n\n// Duplicated with DiffOperation to make the docs less confusing.\nexport type InternalDiffOperation<Key = string, Value = FrozenJSONValue> =\n  | DiffOperationAdd<Key, Value>\n  | DiffOperationDel<Key, Value>\n  | DiffOperationChange<Key, Value>;\n\n/**\n * Finds the leaf where a key is (if present) or where it should go if not\n * present.\n */\nexport async function findLeaf(\n  key: string,\n  hash: Hash,\n  source: BTreeRead,\n  expectedRootHash: Hash,\n): Promise<DataNodeImpl> {\n  const node = await source.getNode(hash);\n  // The root changed. Try again\n  if (expectedRootHash !== source.rootHash) {\n    return findLeaf(key, source.rootHash, source, source.rootHash);\n  }\n  if (isDataNodeImpl(node)) {\n    return node;\n  }\n  const {entries} = node;\n  let i = binarySearch(key, entries);\n  if (i === entries.length) {\n    i--;\n  }\n  const entry = entries[i];\n  return findLeaf(key, entry[1], source, expectedRootHash);\n}\n\ntype BinarySearchEntries = readonly Entry<unknown>[];\n\n/**\n * Does a binary search over entries\n *\n * If the key found then the return value is the index it was found at.\n *\n * If the key was *not* found then the return value is the index where it should\n * be inserted at\n */\nexport function binarySearch(\n  key: string,\n  entries: BinarySearchEntries,\n): number {\n  return binarySearchFrom(key, entries, 0);\n}\n\n/**\n * Binary search starting from a given index.\n */\nfunction binarySearchFrom(\n  key: string,\n  entries: BinarySearchEntries,\n  start: number,\n): number {\n  const result = binarySearchWithFunc(entries.length - start, i =>\n    compareUTF8(key, entries[start + i][0]),\n  );\n  return start + result;\n}\n\nexport function binarySearchFound(\n  i: number,\n  entries: BinarySearchEntries,\n  key: string,\n): boolean {\n  return i !== entries.length && entries[i][0] === key;\n}\n\nexport function parseBTreeNode(\n  v: unknown,\n  formatVersion: FormatVersion,\n  getSizeOfEntry: <K, V>(key: K, value: V) => number,\n): InternalNode | DataNode {\n  if (skipBTreeNodeAsserts && formatVersion >= FormatVersion.V7) {\n    return v as InternalNode | DataNode;\n  }\n\n  assertArray(v);\n  assertDeepFrozen(v);\n  // Be relaxed about what we accept.\n  assert(v.length >= 2, 'Expected node array to have at least 2 elements');\n  const [level, entries] = v;\n  assertNumber(level);\n  assertArray(entries);\n\n  const f = level > 0 ? assertString : assertJSONValue;\n\n  // For V7 we do not need to change the entries. Just assert that they are correct.\n  if (formatVersion >= FormatVersion.V7) {\n    for (const e of entries) {\n      assertEntry(e, f);\n    }\n    return v as unknown as InternalNode | DataNode;\n  }\n\n  const newEntries = entries.map(e => convertNonV7Entry(e, f, getSizeOfEntry));\n  return [level, newEntries] as unknown as InternalNode | DataNode;\n}\n\nfunction assertEntry(\n  entry: unknown,\n  f:\n    | ((v: unknown) => asserts v is Hash)\n    | ((v: unknown) => asserts v is JSONValue),\n): asserts entry is Entry<Hash | JSONValue> {\n  assertArray(entry);\n  // Be relaxed about what we accept.\n  assert(entry.length >= 3, 'Expected entry array to have at least 3 elements');\n  assertString(entry[0]);\n  f(entry[1]);\n  assertNumber(entry[2]);\n}\n\n/**\n * Converts an entry that was from a format version before V7 to the format\n * wanted by V7.\n */\nfunction convertNonV7Entry(\n  entry: unknown,\n  f:\n    | ((v: unknown) => asserts v is Hash)\n    | ((v: unknown) => asserts v is JSONValue),\n  getSizeOfEntry: <K, V>(key: K, value: V) => number,\n): Entry<Hash | JSONValue> {\n  assertArray(entry);\n  assert(entry.length >= 2, 'Expected entry array to have at least 2 elements');\n  assertString(entry[0]);\n  f(entry[1]);\n  const entrySize = getSizeOfEntry(entry[0], entry[1]);\n  return [entry[0], entry[1], entrySize] as Entry<Hash | JSONValue>;\n}\n\nexport function isInternalNode(node: Node): node is InternalNode {\n  return node[NODE_LEVEL] > 0;\n}\n\nabstract class NodeImpl<Value> {\n  entries: Array<Entry<Value>>;\n  hash: Hash;\n  abstract readonly level: number;\n  readonly isMutable: boolean;\n\n  #childNodeSize = -1;\n\n  constructor(entries: Array<Entry<Value>>, hash: Hash, isMutable: boolean) {\n    this.entries = entries;\n    this.hash = hash;\n    this.isMutable = isMutable;\n  }\n\n  abstract set(\n    key: string,\n    value: FrozenJSONValue,\n    entrySize: number,\n    tree: BTreeWrite,\n  ): Promise<NodeImpl<Value>>;\n\n  abstract putMany(\n    entries: ReadonlyArray<Entry<FrozenJSONValue>>,\n    tree: BTreeWrite,\n  ): Promise<NodeImpl<Value>>;\n\n  abstract del(\n    key: string,\n    tree: BTreeWrite,\n  ): Promise<NodeImpl<Value> | DataNodeImpl>;\n\n  maxKey(): string {\n    // oxlint-disable-next-line typescript/no-non-null-assertion\n    return this.entries.at(-1)![0];\n  }\n\n  getChildNodeSize(tree: BTreeRead): number {\n    if (this.#childNodeSize !== -1) {\n      return this.#childNodeSize;\n    }\n\n    let sum = tree.chunkHeaderSize;\n    for (const entry of this.entries) {\n      sum += entry[2];\n    }\n    return (this.#childNodeSize = sum);\n  }\n\n  protected _updateNode(tree: BTreeWrite) {\n    this.#childNodeSize = -1;\n    tree.updateNode(\n      this as NodeImpl<unknown> as DataNodeImpl | InternalNodeImpl,\n    );\n  }\n}\n\nexport function toChunkData<V>(\n  node: NodeImpl<V>,\n  formatVersion: FormatVersion,\n): BaseNode<V> {\n  return makeNodeChunkData(node.level, node.entries, formatVersion);\n}\n\nexport class DataNodeImpl extends NodeImpl<FrozenJSONValue> {\n  readonly level = 0;\n\n  set(\n    key: string,\n    value: FrozenJSONValue,\n    entrySize: number,\n    tree: BTreeWrite,\n  ): Promise<DataNodeImpl> {\n    let deleteCount: number;\n    const i = binarySearch(key, this.entries);\n    if (!binarySearchFound(i, this.entries, key)) {\n      // Not found, insert.\n      deleteCount = 0;\n    } else {\n      deleteCount = 1;\n    }\n\n    return Promise.resolve(\n      this.#splice(tree, i, deleteCount, [key, value, entrySize]),\n    );\n  }\n\n  putMany(\n    entries: ReadonlyArray<Entry<FrozenJSONValue>>,\n    tree: BTreeWrite,\n  ): Promise<DataNodeImpl> {\n    if (entries.length === 0) {\n      return Promise.resolve(this);\n    }\n\n    // Merge sorted entries with existing entries\n    const merged: Entry<FrozenJSONValue>[] = [];\n    let i = 0; // index in this.entries\n    let j = 0; // index in entries\n\n    while (i < this.entries.length && j < entries.length) {\n      const existingEntry = this.entries[i];\n      const newEntry = entries[j];\n      const cmp = compareUTF8(existingEntry[0], newEntry[0]);\n\n      if (cmp < 0) {\n        merged.push(existingEntry);\n        i++;\n      } else if (cmp > 0) {\n        merged.push(newEntry);\n        j++;\n      } else {\n        // Same key, new entry wins (update)\n        merged.push(newEntry);\n        i++;\n        j++;\n      }\n    }\n\n    // Add remaining entries\n    while (i < this.entries.length) {\n      merged.push(this.entries[i]);\n      i++;\n    }\n    while (j < entries.length) {\n      merged.push(entries[j]);\n      j++;\n    }\n\n    if (this.isMutable) {\n      this.entries = merged;\n      this._updateNode(tree);\n      return Promise.resolve(this);\n    }\n\n    return Promise.resolve(tree.newDataNodeImpl(merged));\n  }\n\n  #splice(\n    tree: BTreeWrite,\n    start: number,\n    deleteCount: number,\n    ...items: Entry<FrozenJSONValue>[]\n  ): DataNodeImpl {\n    if (this.isMutable) {\n      this.entries.splice(start, deleteCount, ...items);\n      this._updateNode(tree);\n      return this;\n    }\n\n    const entries = readonlySplice(this.entries, start, deleteCount, ...items);\n    return tree.newDataNodeImpl(entries);\n  }\n\n  del(key: string, tree: BTreeWrite): Promise<DataNodeImpl> {\n    const i = binarySearch(key, this.entries);\n    if (!binarySearchFound(i, this.entries, key)) {\n      // Not found. Return this without changes.\n      return Promise.resolve(this);\n    }\n\n    // Found. Create new node or mutate existing one.\n    return Promise.resolve(this.#splice(tree, i, 1));\n  }\n\n  async *keys(_tree: BTreeRead): AsyncGenerator<string, void> {\n    for (const entry of this.entries) {\n      yield entry[0];\n    }\n  }\n\n  async *entriesIter(\n    _tree: BTreeRead,\n  ): AsyncGenerator<Entry<FrozenJSONValue>, void> {\n    for (const entry of this.entries) {\n      yield entry;\n    }\n  }\n}\n\nfunction readonlySplice<T>(\n  array: ReadonlyArray<T>,\n  start: number,\n  deleteCount: number,\n  ...items: T[]\n): T[] {\n  const arr = array.slice(0, start);\n  for (let i = 0; i < items.length; i++) {\n    arr.push(items[i]);\n  }\n  for (let i = start + deleteCount; i < array.length; i++) {\n    arr.push(array[i]);\n  }\n  return arr;\n}\n\nexport class InternalNodeImpl extends NodeImpl<Hash> {\n  readonly level: number;\n\n  constructor(\n    entries: Array<Entry<Hash>>,\n    hash: Hash,\n    level: number,\n    isMutable: boolean,\n  ) {\n    super(entries, hash, isMutable);\n    this.level = level;\n  }\n\n  async set(\n    key: string,\n    value: FrozenJSONValue,\n    entrySize: number,\n    tree: BTreeWrite,\n  ): Promise<InternalNodeImpl> {\n    let i = binarySearch(key, this.entries);\n    if (i === this.entries.length) {\n      // We are going to insert into last (right most) leaf.\n      i--;\n    }\n\n    const childHash = this.entries[i][1];\n    const oldChildNode = await tree.getNode(childHash);\n\n    const childNode = await oldChildNode.set(key, value, entrySize, tree);\n\n    const childNodeSize = childNode.getChildNodeSize(tree);\n    if (childNodeSize > tree.maxSize || childNodeSize < tree.minSize) {\n      return this.#mergeAndPartition(tree, i, childNode);\n    }\n\n    const newEntry = createNewInternalEntryForNode(\n      childNode,\n      tree.getEntrySize,\n    );\n    return this.#replaceChild(tree, i, newEntry);\n  }\n\n  async putMany(\n    entries: ReadonlyArray<Entry<FrozenJSONValue>>,\n    tree: BTreeWrite,\n  ): Promise<InternalNodeImpl> {\n    if (entries.length === 0) {\n      return this;\n    }\n\n    // Group entries by child index\n    // Since entries are sorted, we can restrict the binary search range\n    const childGroups: Map<number, Entry<FrozenJSONValue>[]> = new Map();\n\n    let searchStart = 0;\n    for (const entry of entries) {\n      const key = entry[0];\n      // Binary search from searchStart to end (entries are sorted)\n      let i = binarySearchFrom(key, this.entries, searchStart);\n      if (i === this.entries.length) {\n        // Insert into last (right most) leaf.\n        i--;\n      }\n      searchStart = i;\n\n      getOrInsertComputed(childGroups, i, newArray).push(entry);\n    }\n\n    // Process each affected child\n    const newEntries = [...this.entries];\n    const childrenToRebalance: Array<{\n      index: number;\n      node: DataNodeImpl | InternalNodeImpl;\n    }> = [];\n\n    for (const [childIndex, childEntries] of childGroups) {\n      const childHash = this.entries[childIndex][1];\n      const oldChildNode = await tree.getNode(childHash);\n      const childNode = await oldChildNode.putMany(childEntries, tree);\n\n      const childNodeSize = childNode.getChildNodeSize(tree);\n      if (childNodeSize > tree.maxSize || childNodeSize < tree.minSize) {\n        childrenToRebalance.push({index: childIndex, node: childNode});\n      } else {\n        const newEntry = createNewInternalEntryForNode(\n          childNode,\n          tree.getEntrySize,\n        );\n        newEntries[childIndex] = newEntry;\n      }\n    }\n\n    // Handle rebalancing - merge adjacent children that need rebalancing\n    // into contiguous groups and process each group as one unit.\n    //\n    // BUG FIX: Previously, each child was rebalanced independently R-to-L.\n    // When adjacent children (e.g., indices 0 and 1) both needed rebalancing,\n    // child[1] would merge with sibling[0] (the ORIGINAL), then child[0]\n    // would merge with the rebalanced result at position 1, duplicating\n    // child[0]'s data. The fix groups adjacent indices together.\n    if (childrenToRebalance.length > 0) {\n      childrenToRebalance.sort((a, b) => a.index - b.index);\n\n      // Group adjacent indices into contiguous runs, each extended by one\n      // sibling on either side for merge context.\n      const groups: Array<{\n        nodes: Map<number, DataNodeImpl | InternalNodeImpl>;\n        minIndex: number;\n        maxIndex: number;\n      }> = [];\n\n      for (const {index, node} of childrenToRebalance) {\n        const lastGroup = groups.at(-1);\n        // Adjacent to previous group? (within 1 index of the last group's max)\n        if (lastGroup && index <= lastGroup.maxIndex + 1) {\n          lastGroup.nodes.set(index, node);\n          lastGroup.maxIndex = index;\n        } else {\n          groups.push({\n            nodes: new Map([[index, node]]),\n            minIndex: index,\n            maxIndex: index,\n          });\n        }\n      }\n\n      // Process groups from right to left to maintain indices during splices.\n      for (let g = groups.length - 1; g >= 0; g--) {\n        const group = groups[g];\n\n        // Extend range by one sibling on each side for merge context.\n        const startIndex = Math.max(0, group.minIndex - 1);\n        const endIndex = Math.min(newEntries.length - 1, group.maxIndex + 1);\n        const removeCount = endIndex - startIndex + 1;\n\n        // Collect all entries from the range: use the putMany result for\n        // indices that were rebalanced, the current newEntries node otherwise.\n        type IterableHashEntries = Iterable<Entry<Hash>>;\n        const allValues: IterableHashEntries[] = [];\n        for (let idx = startIndex; idx <= endIndex; idx++) {\n          const rebalancedNode = group.nodes.get(idx);\n          if (rebalancedNode) {\n            allValues.push(rebalancedNode.entries as IterableHashEntries);\n          } else {\n            const hash = newEntries[idx][1];\n            const existingNode = await tree.getNode(hash);\n            allValues.push(existingNode.entries as IterableHashEntries);\n          }\n        }\n\n        const level = this.level - 1;\n        const merged = joinIterables(...allValues);\n        const rebalanced = partition(\n          merged,\n          e => e[2],\n          tree.minSize - tree.chunkHeaderSize,\n          tree.maxSize - tree.chunkHeaderSize,\n          entries => {\n            const node = tree.newNodeImpl(entries, level);\n            return createNewInternalEntryForNode(node, tree.getEntrySize);\n          },\n        );\n\n        newEntries.splice(startIndex, removeCount, ...rebalanced);\n      }\n    }\n\n    if (this.isMutable) {\n      this.entries = newEntries;\n      this._updateNode(tree);\n      return this;\n    }\n\n    return tree.newInternalNodeImpl(newEntries, this.level);\n  }\n\n  /**\n   * This merges the child node entries with previous or next sibling and then\n   * partitions the merged entries.\n   */\n  async #mergeAndPartition(\n    tree: BTreeWrite,\n    i: number,\n    childNode: DataNodeImpl | InternalNodeImpl,\n  ): Promise<InternalNodeImpl> {\n    const level = this.level - 1;\n    const thisEntries = this.entries;\n\n    type IterableHashEntries = Iterable<Entry<Hash>>;\n\n    let values: IterableHashEntries;\n    let startIndex: number;\n    let removeCount: number;\n    if (i > 0) {\n      const hash = thisEntries[i - 1][1];\n      const previousSibling = await tree.getNode(hash);\n      values = joinIterables(\n        previousSibling.entries as IterableHashEntries,\n        childNode.entries as IterableHashEntries,\n      );\n      startIndex = i - 1;\n      removeCount = 2;\n    } else if (i < thisEntries.length - 1) {\n      const hash = thisEntries[i + 1][1];\n      const nextSibling = await tree.getNode(hash);\n      values = joinIterables(\n        childNode.entries as IterableHashEntries,\n        nextSibling.entries as IterableHashEntries,\n      );\n      startIndex = i;\n      removeCount = 2;\n    } else {\n      values = childNode.entries as IterableHashEntries;\n      startIndex = i;\n      removeCount = 1;\n    }\n\n    const newEntries = partition(\n      values,\n      value => value[2],\n      tree.minSize - tree.chunkHeaderSize,\n      tree.maxSize - tree.chunkHeaderSize,\n      entries => {\n        const node = tree.newNodeImpl(entries, level);\n        return createNewInternalEntryForNode(node, tree.getEntrySize);\n      },\n    );\n\n    if (this.isMutable) {\n      this.entries.splice(startIndex, removeCount, ...newEntries);\n      this._updateNode(tree);\n      return this;\n    }\n\n    const entries = readonlySplice(\n      thisEntries,\n      startIndex,\n      removeCount,\n      ...newEntries,\n    );\n\n    return tree.newInternalNodeImpl(entries, this.level);\n  }\n\n  #replaceChild(\n    tree: BTreeWrite,\n    index: number,\n    newEntry: Entry<Hash>,\n  ): InternalNodeImpl {\n    if (this.isMutable) {\n      this.entries.splice(index, 1, newEntry);\n      this._updateNode(tree);\n      return this;\n    }\n    const entries = readonlySplice(this.entries, index, 1, newEntry);\n    return tree.newInternalNodeImpl(entries, this.level);\n  }\n\n  async del(\n    key: string,\n    tree: BTreeWrite,\n  ): Promise<InternalNodeImpl | DataNodeImpl> {\n    const i = binarySearch(key, this.entries);\n    if (i === this.entries.length) {\n      // Key is larger than maxKey of rightmost entry so it is not present.\n      return this;\n    }\n\n    const childHash = this.entries[i][1];\n    const oldChildNode = await tree.getNode(childHash);\n    const oldHash = oldChildNode.hash;\n\n    const childNode = await oldChildNode.del(key, tree);\n    if (childNode.hash === oldHash) {\n      // Not changed so not found.\n      return this;\n    }\n\n    if (childNode.entries.length === 0) {\n      // Subtree is now empty. Remove internal node.\n      const entries = readonlySplice(this.entries, i, 1);\n      return tree.newInternalNodeImpl(entries, this.level);\n    }\n\n    if (i === 0 && this.entries.length === 1) {\n      // There was only one node at this level and it was removed. We can return\n      // the modified subtree.\n      return childNode;\n    }\n\n    // The child node is still a good size.\n    if (childNode.getChildNodeSize(tree) > tree.minSize) {\n      // No merging needed.\n      const entry = createNewInternalEntryForNode(childNode, tree.getEntrySize);\n      return this.#replaceChild(tree, i, entry);\n    }\n\n    // Child node size is too small.\n    return this.#mergeAndPartition(tree, i, childNode);\n  }\n\n  async *keys(tree: BTreeRead): AsyncGenerator<string, void> {\n    for (const entry of this.entries) {\n      const childNode = await tree.getNode(entry[1]);\n      yield* childNode.keys(tree);\n    }\n  }\n\n  async *entriesIter(\n    tree: BTreeRead,\n  ): AsyncGenerator<Entry<FrozenJSONValue>, void> {\n    for (const entry of this.entries) {\n      const childNode = await tree.getNode(entry[1]);\n      yield* childNode.entriesIter(tree);\n    }\n  }\n\n  getChildren(\n    start: number,\n    length: number,\n    tree: BTreeRead,\n  ): Promise<Array<InternalNodeImpl | DataNodeImpl>> {\n    const ps: Promise<DataNodeImpl | InternalNodeImpl>[] = [];\n    for (let i = start; i < length && i < this.entries.length; i++) {\n      ps.push(tree.getNode(this.entries[i][1]));\n    }\n    return Promise.all(ps);\n  }\n\n  async getCompositeChildren(\n    start: number,\n    length: number,\n    tree: BTreeRead,\n  ): Promise<InternalNodeImpl | DataNodeImpl> {\n    const {level} = this;\n\n    if (length === 0) {\n      return new InternalNodeImpl([], newRandomHash(), level - 1, true);\n    }\n\n    const output = await this.getChildren(start, start + length, tree);\n\n    if (level > 1) {\n      const entries: Entry<Hash>[] = [];\n      for (const child of output as InternalNodeImpl[]) {\n        entries.push(...child.entries);\n      }\n      return new InternalNodeImpl(entries, newRandomHash(), level - 1, true);\n    }\n\n    assert(level === 1, 'Expected level to be 1');\n    const entries: Entry<FrozenJSONValue>[] = [];\n    for (const child of output as DataNodeImpl[]) {\n      entries.push(...child.entries);\n    }\n    return new DataNodeImpl(entries, newRandomHash(), true);\n  }\n}\n\nexport function newNodeImpl(\n  entries: Array<Entry<FrozenJSONValue>>,\n  hash: Hash,\n  level: number,\n  isMutable: boolean,\n): DataNodeImpl;\nexport function newNodeImpl(\n  entries: Array<Entry<Hash>>,\n  hash: Hash,\n  level: number,\n  isMutable: boolean,\n): InternalNodeImpl;\nexport function newNodeImpl(\n  entries: Array<Entry<FrozenJSONValue>> | Array<Entry<Hash>>,\n  hash: Hash,\n  level: number,\n  isMutable: boolean,\n): DataNodeImpl | InternalNodeImpl;\nexport function newNodeImpl(\n  entries: Array<Entry<FrozenJSONValue>> | Array<Entry<Hash>>,\n  hash: Hash,\n  level: number,\n  isMutable: boolean,\n): DataNodeImpl | InternalNodeImpl {\n  if (level === 0) {\n    return new DataNodeImpl(\n      entries as Entry<FrozenJSONValue>[],\n      hash,\n      isMutable,\n    );\n  }\n  return new InternalNodeImpl(entries as Entry<Hash>[], hash, level, isMutable);\n}\n\nexport function isDataNodeImpl(\n  node: DataNodeImpl | InternalNodeImpl,\n): node is DataNodeImpl {\n  return node.level === 0;\n}\n\nexport function partition<T, R>(\n  values: Iterable<T>,\n  // This is the size of each Entry\n  getSizeOfEntry: (v: T) => number,\n  min: number,\n  max: number,\n  create: (entries: T[]) => R,\n): R[] {\n  const results: R[] = [];\n  let sum = 0;\n  let accum: T[] = [];\n  // The most recently finalized partition, held back until we know it won't be\n  // merged with trailing entries.\n  let lastPartition: T[] | null = null;\n  let lastSize = 0;\n\n  function commitLast() {\n    if (lastPartition !== null) {\n      results.push(create(lastPartition));\n      lastPartition = null;\n    }\n  }\n\n  for (const value of values) {\n    const size = getSizeOfEntry(value);\n    if (size >= max) {\n      if (accum.length > 0) {\n        commitLast();\n        lastPartition = accum;\n        lastSize = sum;\n        accum = [];\n        sum = 0;\n      }\n      commitLast();\n      lastPartition = [value];\n      lastSize = size;\n    } else if (sum + size >= min) {\n      accum.push(value);\n      commitLast();\n      lastPartition = accum;\n      lastSize = sum + size;\n      accum = [];\n      sum = 0;\n    } else {\n      sum += size;\n      accum.push(value);\n    }\n  }\n\n  if (sum > 0) {\n    if (lastPartition !== null && sum + lastSize <= max) {\n      lastPartition.push(...accum);\n      commitLast();\n    } else {\n      commitLast();\n      results.push(create(accum));\n    }\n  } else {\n    commitLast();\n  }\n\n  return results;\n}\n\nexport const emptyDataNode = makeNodeChunkData<ReadonlyJSONValue>(\n  0,\n  [],\n  FormatVersion.Latest,\n);\nexport const emptyDataNodeImpl = new DataNodeImpl([], emptyHash, false);\n\nexport function createNewInternalEntryForNode(\n  node: NodeImpl<unknown>,\n  getSizeOfEntry: <K, V>(k: K, v: V) => number,\n): [string, Hash, number] {\n  const key = node.maxKey();\n  const value = node.hash;\n  const size = getSizeOfEntry(key, value);\n  return [key, value, size];\n}\n"],"mappings":";;;;;;;;;;;;AA+CA,SAAgB,kBACd,OACA,SACA,eACa;CACb,OAAO,WAAW,CAChB,OACC,iBAAiB,IACd,UACA,QAAQ,KAAI,MAAK,EAAE,MAAM,GAAG,CAAC,CAAC,CACpC,CAAC;AACH;;;;;AAsEA,eAAsB,SACpB,KACA,MACA,QACA,kBACuB;CACvB,MAAM,OAAO,MAAM,OAAO,QAAQ,IAAI;CAEtC,IAAI,qBAAqB,OAAO,UAC9B,OAAO,SAAS,KAAK,OAAO,UAAU,QAAQ,OAAO,QAAQ;CAE/D,IAAI,eAAe,IAAI,GACrB,OAAO;CAET,MAAM,EAAC,YAAW;CAClB,IAAI,IAAI,aAAa,KAAK,OAAO;CACjC,IAAI,MAAM,QAAQ,QAChB;CAEF,MAAM,QAAQ,QAAQ;CACtB,OAAO,SAAS,KAAK,MAAM,IAAI,QAAQ,gBAAgB;AACzD;;;;;;;;;AAYA,SAAgB,aACd,KACA,SACQ;CACR,OAAO,iBAAiB,KAAK,SAAS,CAAC;AACzC;;;;AAKA,SAAS,iBACP,KACA,SACA,OACQ;CAIR,OAAO,QAHQA,eAAqB,QAAQ,SAAS,QAAO,MAC1D,YAAY,KAAK,QAAQ,QAAQ,EAAE,CAAC,EAAE,CAEzB;AACjB;AAEA,SAAgB,kBACd,GACA,SACA,KACS;CACT,OAAO,MAAM,QAAQ,UAAU,QAAQ,EAAE,CAAC,OAAO;AACnD;AAEA,SAAgB,eACd,GACA,eACA,gBACyB;CACzB,IAAIC,UAAwB,iBAAiB,GAC3C,OAAO;CAGT,YAAY,CAAC;CACb,iBAAiB,CAAC;CAElB,OAAO,EAAE,UAAU,GAAG,iDAAiD;CACvE,MAAM,CAAC,OAAO,WAAW;CACzB,aAAa,KAAK;CAClB,YAAY,OAAO;CAEnB,MAAM,IAAI,QAAQ,IAAI,eAAe;CAGrC,IAAI,iBAAiB,GAAkB;EACrC,KAAK,MAAM,KAAK,SACd,YAAY,GAAG,CAAC;EAElB,OAAO;CACT;CAGA,OAAO,CAAC,OADW,QAAQ,KAAI,MAAK,kBAAkB,GAAG,GAAG,cAAc,CAC3D,CAAU;AAC3B;AAEA,SAAS,YACP,OACA,GAG0C;CAC1C,YAAY,KAAK;CAEjB,OAAO,MAAM,UAAU,GAAG,kDAAkD;CAC5E,aAAa,MAAM,EAAE;CACrB,EAAE,MAAM,EAAE;CACV,aAAa,MAAM,EAAE;AACvB;;;;;AAMA,SAAS,kBACP,OACA,GAGA,gBACyB;CACzB,YAAY,KAAK;CACjB,OAAO,MAAM,UAAU,GAAG,kDAAkD;CAC5E,aAAa,MAAM,EAAE;CACrB,EAAE,MAAM,EAAE;CACV,MAAM,YAAY,eAAe,MAAM,IAAI,MAAM,EAAE;CACnD,OAAO;EAAC,MAAM;EAAI,MAAM;EAAI;CAAS;AACvC;AAMA,IAAe,WAAf,MAA+B;CAC7B;CACA;CAEA;CAEA,iBAAiB;CAEjB,YAAY,SAA8B,MAAY,WAAoB;EACxE,KAAK,UAAU;EACf,KAAK,OAAO;EACZ,KAAK,YAAY;CACnB;CAmBA,SAAiB;EAEf,OAAO,KAAK,QAAQ,GAAG,EAAE,CAAC,CAAE;CAC9B;CAEA,iBAAiB,MAAyB;EACxC,IAAI,KAAK,mBAAmB,IAC1B,OAAO,KAAK;EAGd,IAAI,MAAM,KAAK;EACf,KAAK,MAAM,SAAS,KAAK,SACvB,OAAO,MAAM;EAEf,OAAQ,KAAK,iBAAiB;CAChC;CAEA,YAAsB,MAAkB;EACtC,KAAK,iBAAiB;EACtB,KAAK,WACH,IACF;CACF;AACF;AAEA,SAAgB,YACd,MACA,eACa;CACb,OAAO,kBAAkB,KAAK,OAAO,KAAK,SAAS,aAAa;AAClE;AAEA,IAAa,eAAb,cAAkC,SAA0B;CAC1D,QAAiB;CAEjB,IACE,KACA,OACA,WACA,MACuB;EACvB,IAAI;EACJ,MAAM,IAAI,aAAa,KAAK,KAAK,OAAO;EACxC,IAAI,CAAC,kBAAkB,GAAG,KAAK,SAAS,GAAG,GAEzC,cAAc;OAEd,cAAc;EAGhB,OAAO,QAAQ,QACb,KAAK,QAAQ,MAAM,GAAG,aAAa;GAAC;GAAK;GAAO;EAAS,CAAC,CAC5D;CACF;CAEA,QACE,SACA,MACuB;EACvB,IAAI,QAAQ,WAAW,GACrB,OAAO,QAAQ,QAAQ,IAAI;EAI7B,MAAM,SAAmC,CAAC;EAC1C,IAAI,IAAI;EACR,IAAI,IAAI;EAER,OAAO,IAAI,KAAK,QAAQ,UAAU,IAAI,QAAQ,QAAQ;GACpD,MAAM,gBAAgB,KAAK,QAAQ;GACnC,MAAM,WAAW,QAAQ;GACzB,MAAM,MAAM,YAAY,cAAc,IAAI,SAAS,EAAE;GAErD,IAAI,MAAM,GAAG;IACX,OAAO,KAAK,aAAa;IACzB;GACF,OAAO,IAAI,MAAM,GAAG;IAClB,OAAO,KAAK,QAAQ;IACpB;GACF,OAAO;IAEL,OAAO,KAAK,QAAQ;IACpB;IACA;GACF;EACF;EAGA,OAAO,IAAI,KAAK,QAAQ,QAAQ;GAC9B,OAAO,KAAK,KAAK,QAAQ,EAAE;GAC3B;EACF;EACA,OAAO,IAAI,QAAQ,QAAQ;GACzB,OAAO,KAAK,QAAQ,EAAE;GACtB;EACF;EAEA,IAAI,KAAK,WAAW;GAClB,KAAK,UAAU;GACf,KAAK,YAAY,IAAI;GACrB,OAAO,QAAQ,QAAQ,IAAI;EAC7B;EAEA,OAAO,QAAQ,QAAQ,KAAK,gBAAgB,MAAM,CAAC;CACrD;CAEA,QACE,MACA,OACA,aACA,GAAG,OACW;EACd,IAAI,KAAK,WAAW;GAClB,KAAK,QAAQ,OAAO,OAAO,aAAa,GAAG,KAAK;GAChD,KAAK,YAAY,IAAI;GACrB,OAAO;EACT;EAEA,MAAM,UAAU,eAAe,KAAK,SAAS,OAAO,aAAa,GAAG,KAAK;EACzE,OAAO,KAAK,gBAAgB,OAAO;CACrC;CAEA,IAAI,KAAa,MAAyC;EACxD,MAAM,IAAI,aAAa,KAAK,KAAK,OAAO;EACxC,IAAI,CAAC,kBAAkB,GAAG,KAAK,SAAS,GAAG,GAEzC,OAAO,QAAQ,QAAQ,IAAI;EAI7B,OAAO,QAAQ,QAAQ,KAAK,QAAQ,MAAM,GAAG,CAAC,CAAC;CACjD;CAEA,OAAO,KAAK,OAAgD;EAC1D,KAAK,MAAM,SAAS,KAAK,SACvB,MAAM,MAAM;CAEhB;CAEA,OAAO,YACL,OAC8C;EAC9C,KAAK,MAAM,SAAS,KAAK,SACvB,MAAM;CAEV;AACF;AAEA,SAAS,eACP,OACA,OACA,aACA,GAAG,OACE;CACL,MAAM,MAAM,MAAM,MAAM,GAAG,KAAK;CAChC,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAChC,IAAI,KAAK,MAAM,EAAE;CAEnB,KAAK,IAAI,IAAI,QAAQ,aAAa,IAAI,MAAM,QAAQ,KAClD,IAAI,KAAK,MAAM,EAAE;CAEnB,OAAO;AACT;AAEA,IAAa,mBAAb,MAAa,yBAAyB,SAAe;CACnD;CAEA,YACE,SACA,MACA,OACA,WACA;EACA,MAAM,SAAS,MAAM,SAAS;EAC9B,KAAK,QAAQ;CACf;CAEA,MAAM,IACJ,KACA,OACA,WACA,MAC2B;EAC3B,IAAI,IAAI,aAAa,KAAK,KAAK,OAAO;EACtC,IAAI,MAAM,KAAK,QAAQ,QAErB;EAGF,MAAM,YAAY,KAAK,QAAQ,EAAE,CAAC;EAGlC,MAAM,YAAY,OAAM,MAFG,KAAK,QAAQ,SAAS,EAAA,CAEZ,IAAI,KAAK,OAAO,WAAW,IAAI;EAEpE,MAAM,gBAAgB,UAAU,iBAAiB,IAAI;EACrD,IAAI,gBAAgB,KAAK,WAAW,gBAAgB,KAAK,SACvD,OAAO,KAAK,mBAAmB,MAAM,GAAG,SAAS;EAGnD,MAAM,WAAW,8BACf,WACA,KAAK,YACP;EACA,OAAO,KAAK,cAAc,MAAM,GAAG,QAAQ;CAC7C;CAEA,MAAM,QACJ,SACA,MAC2B;EAC3B,IAAI,QAAQ,WAAW,GACrB,OAAO;EAKT,MAAM,8BAAqD,IAAI,IAAI;EAEnE,IAAI,cAAc;EAClB,KAAK,MAAM,SAAS,SAAS;GAC3B,MAAM,MAAM,MAAM;GAElB,IAAI,IAAI,iBAAiB,KAAK,KAAK,SAAS,WAAW;GACvD,IAAI,MAAM,KAAK,QAAQ,QAErB;GAEF,cAAc;GAEd,oBAAoB,aAAa,GAAG,QAAQ,CAAC,CAAC,KAAK,KAAK;EAC1D;EAGA,MAAM,aAAa,CAAC,GAAG,KAAK,OAAO;EACnC,MAAM,sBAGD,CAAC;EAEN,KAAK,MAAM,CAAC,YAAY,iBAAiB,aAAa;GACpD,MAAM,YAAY,KAAK,QAAQ,WAAW,CAAC;GAE3C,MAAM,YAAY,OAAM,MADG,KAAK,QAAQ,SAAS,EAAA,CACZ,QAAQ,cAAc,IAAI;GAE/D,MAAM,gBAAgB,UAAU,iBAAiB,IAAI;GACrD,IAAI,gBAAgB,KAAK,WAAW,gBAAgB,KAAK,SACvD,oBAAoB,KAAK;IAAC,OAAO;IAAY,MAAM;GAAS,CAAC;QAM7D,WAAW,cAJM,8BACf,WACA,KAAK,YAEkB;EAE7B;EAUA,IAAI,oBAAoB,SAAS,GAAG;GAClC,oBAAoB,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,KAAK;GAIpD,MAAM,SAID,CAAC;GAEN,KAAK,MAAM,EAAC,OAAO,UAAS,qBAAqB;IAC/C,MAAM,YAAY,OAAO,GAAG,EAAE;IAE9B,IAAI,aAAa,SAAS,UAAU,WAAW,GAAG;KAChD,UAAU,MAAM,IAAI,OAAO,IAAI;KAC/B,UAAU,WAAW;IACvB,OACE,OAAO,KAAK;KACV,uBAAO,IAAI,IAAI,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC;KAC9B,UAAU;KACV,UAAU;IACZ,CAAC;GAEL;GAGA,KAAK,IAAI,IAAI,OAAO,SAAS,GAAG,KAAK,GAAG,KAAK;IAC3C,MAAM,QAAQ,OAAO;IAGrB,MAAM,aAAa,KAAK,IAAI,GAAG,MAAM,WAAW,CAAC;IACjD,MAAM,WAAW,KAAK,IAAI,WAAW,SAAS,GAAG,MAAM,WAAW,CAAC;IACnE,MAAM,cAAc,WAAW,aAAa;IAK5C,MAAM,YAAmC,CAAC;IAC1C,KAAK,IAAI,MAAM,YAAY,OAAO,UAAU,OAAO;KACjD,MAAM,iBAAiB,MAAM,MAAM,IAAI,GAAG;KAC1C,IAAI,gBACF,UAAU,KAAK,eAAe,OAA8B;UACvD;MACL,MAAM,OAAO,WAAW,IAAI,CAAC;MAC7B,MAAM,eAAe,MAAM,KAAK,QAAQ,IAAI;MAC5C,UAAU,KAAK,aAAa,OAA8B;KAC5D;IACF;IAEA,MAAM,QAAQ,KAAK,QAAQ;IAE3B,MAAM,aAAa,UADJ,cAAc,GAAG,SAE9B,IACA,MAAK,EAAE,IACP,KAAK,UAAU,KAAK,iBACpB,KAAK,UAAU,KAAK,kBACpB,YAAW;KAET,OAAO,8BADM,KAAK,YAAY,SAAS,KACF,GAAM,KAAK,YAAY;IAC9D,CACF;IAEA,WAAW,OAAO,YAAY,aAAa,GAAG,UAAU;GAC1D;EACF;EAEA,IAAI,KAAK,WAAW;GAClB,KAAK,UAAU;GACf,KAAK,YAAY,IAAI;GACrB,OAAO;EACT;EAEA,OAAO,KAAK,oBAAoB,YAAY,KAAK,KAAK;CACxD;;;;;CAMA,MAAM,mBACJ,MACA,GACA,WAC2B;EAC3B,MAAM,QAAQ,KAAK,QAAQ;EAC3B,MAAM,cAAc,KAAK;EAIzB,IAAI;EACJ,IAAI;EACJ,IAAI;EACJ,IAAI,IAAI,GAAG;GACT,MAAM,OAAO,YAAY,IAAI,EAAE,CAAC;GAChC,MAAM,kBAAkB,MAAM,KAAK,QAAQ,IAAI;GAC/C,SAAS,cACP,gBAAgB,SAChB,UAAU,OACZ;GACA,aAAa,IAAI;GACjB,cAAc;EAChB,OAAO,IAAI,IAAI,YAAY,SAAS,GAAG;GACrC,MAAM,OAAO,YAAY,IAAI,EAAE,CAAC;GAChC,MAAM,cAAc,MAAM,KAAK,QAAQ,IAAI;GAC3C,SAAS,cACP,UAAU,SACV,YAAY,OACd;GACA,aAAa;GACb,cAAc;EAChB,OAAO;GACL,SAAS,UAAU;GACnB,aAAa;GACb,cAAc;EAChB;EAEA,MAAM,aAAa,UACjB,SACA,UAAS,MAAM,IACf,KAAK,UAAU,KAAK,iBACpB,KAAK,UAAU,KAAK,kBACpB,YAAW;GAET,OAAO,8BADM,KAAK,YAAY,SAAS,KACF,GAAM,KAAK,YAAY;EAC9D,CACF;EAEA,IAAI,KAAK,WAAW;GAClB,KAAK,QAAQ,OAAO,YAAY,aAAa,GAAG,UAAU;GAC1D,KAAK,YAAY,IAAI;GACrB,OAAO;EACT;EAEA,MAAM,UAAU,eACd,aACA,YACA,aACA,GAAG,UACL;EAEA,OAAO,KAAK,oBAAoB,SAAS,KAAK,KAAK;CACrD;CAEA,cACE,MACA,OACA,UACkB;EAClB,IAAI,KAAK,WAAW;GAClB,KAAK,QAAQ,OAAO,OAAO,GAAG,QAAQ;GACtC,KAAK,YAAY,IAAI;GACrB,OAAO;EACT;EACA,MAAM,UAAU,eAAe,KAAK,SAAS,OAAO,GAAG,QAAQ;EAC/D,OAAO,KAAK,oBAAoB,SAAS,KAAK,KAAK;CACrD;CAEA,MAAM,IACJ,KACA,MAC0C;EAC1C,MAAM,IAAI,aAAa,KAAK,KAAK,OAAO;EACxC,IAAI,MAAM,KAAK,QAAQ,QAErB,OAAO;EAGT,MAAM,YAAY,KAAK,QAAQ,EAAE,CAAC;EAClC,MAAM,eAAe,MAAM,KAAK,QAAQ,SAAS;EACjD,MAAM,UAAU,aAAa;EAE7B,MAAM,YAAY,MAAM,aAAa,IAAI,KAAK,IAAI;EAClD,IAAI,UAAU,SAAS,SAErB,OAAO;EAGT,IAAI,UAAU,QAAQ,WAAW,GAAG;GAElC,MAAM,UAAU,eAAe,KAAK,SAAS,GAAG,CAAC;GACjD,OAAO,KAAK,oBAAoB,SAAS,KAAK,KAAK;EACrD;EAEA,IAAI,MAAM,KAAK,KAAK,QAAQ,WAAW,GAGrC,OAAO;EAIT,IAAI,UAAU,iBAAiB,IAAI,IAAI,KAAK,SAAS;GAEnD,MAAM,QAAQ,8BAA8B,WAAW,KAAK,YAAY;GACxE,OAAO,KAAK,cAAc,MAAM,GAAG,KAAK;EAC1C;EAGA,OAAO,KAAK,mBAAmB,MAAM,GAAG,SAAS;CACnD;CAEA,OAAO,KAAK,MAA+C;EACzD,KAAK,MAAM,SAAS,KAAK,SAEvB,QAAO,MADiB,KAAK,QAAQ,MAAM,EAAE,EAAA,CAC5B,KAAK,IAAI;CAE9B;CAEA,OAAO,YACL,MAC8C;EAC9C,KAAK,MAAM,SAAS,KAAK,SAEvB,QAAO,MADiB,KAAK,QAAQ,MAAM,EAAE,EAAA,CAC5B,YAAY,IAAI;CAErC;CAEA,YACE,OACA,QACA,MACiD;EACjD,MAAM,KAAiD,CAAC;EACxD,KAAK,IAAI,IAAI,OAAO,IAAI,UAAU,IAAI,KAAK,QAAQ,QAAQ,KACzD,GAAG,KAAK,KAAK,QAAQ,KAAK,QAAQ,EAAE,CAAC,EAAE,CAAC;EAE1C,OAAO,QAAQ,IAAI,EAAE;CACvB;CAEA,MAAM,qBACJ,OACA,QACA,MAC0C;EAC1C,MAAM,EAAC,UAAS;EAEhB,IAAI,WAAW,GACb,OAAO,IAAI,iBAAiB,CAAC,GAAG,cAAc,GAAG,QAAQ,GAAG,IAAI;EAGlE,MAAM,SAAS,MAAM,KAAK,YAAY,OAAO,QAAQ,QAAQ,IAAI;EAEjE,IAAI,QAAQ,GAAG;GACb,MAAM,UAAyB,CAAC;GAChC,KAAK,MAAM,SAAS,QAClB,QAAQ,KAAK,GAAG,MAAM,OAAO;GAE/B,OAAO,IAAI,iBAAiB,SAAS,cAAc,GAAG,QAAQ,GAAG,IAAI;EACvE;EAEA,OAAO,UAAU,GAAG,wBAAwB;EAC5C,MAAM,UAAoC,CAAC;EAC3C,KAAK,MAAM,SAAS,QAClB,QAAQ,KAAK,GAAG,MAAM,OAAO;EAE/B,OAAO,IAAI,aAAa,SAAS,cAAc,GAAG,IAAI;CACxD;AACF;AAoBA,SAAgB,YACd,SACA,MACA,OACA,WACiC;CACjC,IAAI,UAAU,GACZ,OAAO,IAAI,aACT,SACA,MACA,SACF;CAEF,OAAO,IAAI,iBAAiB,SAA0B,MAAM,OAAO,SAAS;AAC9E;AAEA,SAAgB,eACd,MACsB;CACtB,OAAO,KAAK,UAAU;AACxB;AAEA,SAAgB,UACd,QAEA,gBACA,KACA,KACA,QACK;CACL,MAAM,UAAe,CAAC;CACtB,IAAI,MAAM;CACV,IAAI,QAAa,CAAC;CAGlB,IAAI,gBAA4B;CAChC,IAAI,WAAW;CAEf,SAAS,aAAa;EACpB,IAAI,kBAAkB,MAAM;GAC1B,QAAQ,KAAK,OAAO,aAAa,CAAC;GAClC,gBAAgB;EAClB;CACF;CAEA,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,OAAO,eAAe,KAAK;EACjC,IAAI,QAAQ,KAAK;GACf,IAAI,MAAM,SAAS,GAAG;IACpB,WAAW;IACX,gBAAgB;IAChB,WAAW;IACX,QAAQ,CAAC;IACT,MAAM;GACR;GACA,WAAW;GACX,gBAAgB,CAAC,KAAK;GACtB,WAAW;EACb,OAAO,IAAI,MAAM,QAAQ,KAAK;GAC5B,MAAM,KAAK,KAAK;GAChB,WAAW;GACX,gBAAgB;GAChB,WAAW,MAAM;GACjB,QAAQ,CAAC;GACT,MAAM;EACR,OAAO;GACL,OAAO;GACP,MAAM,KAAK,KAAK;EAClB;CACF;CAEA,IAAI,MAAM,GAAG;EACX,IAAI,kBAAkB,QAAQ,MAAM,YAAY,KAAK;GACnD,cAAc,KAAK,GAAG,KAAK;GAC3B,WAAW;EACb,OAAO;GACL,WAAW;GACX,QAAQ,KAAK,OAAO,KAAK,CAAC;EAC5B;CACF,OACE,WAAW;CAGb,OAAO;AACT;AAEA,IAAa,gBAAgB,kBAC3B,GACA,CAAC,GACD,CACF;AACA,IAAa,oBAAoB,IAAI,aAAa,CAAC,GAAG,WAAW,KAAK;AAEtE,SAAgB,8BACd,MACA,gBACwB;CACxB,MAAM,MAAM,KAAK,OAAO;CACxB,MAAM,QAAQ,KAAK;CAEnB,OAAO;EAAC;EAAK;EADA,eAAe,KAAK,KACb;CAAI;AAC1B"}

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

@@ -21,7 +21,8 @@ var BTreeRead = class {
 		if (hash === emptyHash) return emptyDataNodeImpl;
 		const cached = this._cache.get(hash);
 		if (cached) return cached;
-		const data = parseBTreeNode((await this._dagRead.mustGetChunk(hash)).data, this._formatVersion, this.getEntrySize);
+		const chunk = await this._dagRead.mustGetChunk(hash);
+		const data = parseBTreeNode(chunk.data, this._formatVersion, this.getEntrySize);
 		const impl = newNodeImpl(data[1], hash, data[0], false);
 		this._cache.set(hash, impl);
 		return impl;
@@ -34,7 +35,8 @@ var BTreeRead = class {
 	}
 	async has(key) {
 		const leaf = await findLeaf(key, this.rootHash, this, this.rootHash);
-		return binarySearchFound(binarySearch(key, leaf.entries), leaf.entries, key);
+		const index = binarySearch(key, leaf.entries);
+		return binarySearchFound(index, leaf.entries, key);
 	}
 	async isEmpty() {
 		const { rootHash } = this;

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

@@ -1 +1 @@
-{"version":3,"file":"read.js","names":[],"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  /**\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   *\n   * @param prefetch Read sibling nodes in parallel before traversing them so\n   * stores can batch the reads. This can read nodes that the caller never\n   * visits. Enable it only when the caller expects to consume most of the scan\n   * or explicitly accepts that extra work.\n   */\n  scan(\n    fromKey: string,\n    prefetch: boolean,\n  ): AsyncIterableIterator<Entry<FrozenJSONValue>> {\n    return scanForHash(\n      this.rootHash,\n      () => this.rootHash,\n      this.rootHash,\n      fromKey,\n      async hash => {\n        const {level, isMutable, entries} = await this.getNode(hash);\n        return [level, isMutable ? entries.slice() : entries];\n      },\n      prefetch,\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  prefetch: boolean,\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    if (prefetch) {\n      // Preload children in parallel so the backing store can coalesce their\n      // reads. This can waste work when a caller stops before visiting every\n      // child, so callers must explicitly opt in when they expect to consume\n      // the full scan. Zero currently accepts that tradeoff: startup scans the\n      // entire cached entity range into IVM memory before becoming ready (see\n      // `ZeroRep.init` in packages/zero-client/src/client/zero-rep.ts), and\n      // client views are intended to remain small. If views commonly outgrow\n      // the 100 MB `LAZY_STORE_SOURCE_CHUNK_CACHE_SIZE_LIMIT`, reconsider the\n      // preload window, although batching may still be a useful general\n      // optimization. Longer term, the Replicache/IVM boundary should also be\n      // revisited because materializing entities into `MemorySource`\n      // duplicates B-tree storage.\n      //\n      // The serial scan below preserves traversal order and remains the\n      // authoritative read, so speculative failures are ignored here.\n      await Promise.all(\n        entries\n          .slice(i)\n          .map(entry =>\n            readNode((entry as Entry<Hash>)[1]).catch(() => undefined),\n          ),\n      );\n    }\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        prefetch,\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          prefetch,\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"],"mappings":"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"}
+{"version":3,"file":"read.js","names":[],"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  /**\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   *\n   * @param prefetch Read sibling nodes in parallel before traversing them so\n   * stores can batch the reads. This can read nodes that the caller never\n   * visits. Enable it only when the caller expects to consume most of the scan\n   * or explicitly accepts that extra work.\n   */\n  scan(\n    fromKey: string,\n    prefetch: boolean,\n  ): AsyncIterableIterator<Entry<FrozenJSONValue>> {\n    return scanForHash(\n      this.rootHash,\n      () => this.rootHash,\n      this.rootHash,\n      fromKey,\n      async hash => {\n        const {level, isMutable, entries} = await this.getNode(hash);\n        return [level, isMutable ? entries.slice() : entries];\n      },\n      prefetch,\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  prefetch: boolean,\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    if (prefetch) {\n      // Preload children in parallel so the backing store can coalesce their\n      // reads. This can waste work when a caller stops before visiting every\n      // child, so callers must explicitly opt in when they expect to consume\n      // the full scan. Zero currently accepts that tradeoff: startup scans the\n      // entire cached entity range into IVM memory before becoming ready (see\n      // `ZeroRep.init` in packages/zero-client/src/client/zero-rep.ts), and\n      // client views are intended to remain small. If views commonly outgrow\n      // the 100 MB `LAZY_STORE_SOURCE_CHUNK_CACHE_SIZE_LIMIT`, reconsider the\n      // preload window, although batching may still be a useful general\n      // optimization. Longer term, the Replicache/IVM boundary should also be\n      // revisited because materializing entities into `MemorySource`\n      // duplicates B-tree storage.\n      //\n      // The serial scan below preserves traversal order and remains the\n      // authoritative read, so speculative failures are ignored here.\n      await Promise.all(\n        entries\n          .slice(i)\n          .map(entry =>\n            readNode((entry as Entry<Hash>)[1]).catch(() => undefined),\n          ),\n      );\n    }\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        prefetch,\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          prefetch,\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"],"mappings":"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"}

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

@@ -1 +1 @@
-{"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;EAC3D,IAAI,OAAA,OAAwB,mBAC1B,OAAA,KAAsB;CAE1B;CAEA,SAAS,YAAoB;EAC3B,OAAO;GAAC;GAAe;GAAG;GAAG;EAAiB;CAChD;CAEA,OAAO,gBAAgB,SAAS,UAAU,eAAe,QAAQ,QAC/D,IAAI,SAAS,eAAe,SAAS,QAAQ,cAAc,MAAM;EAC/D,IACE,UAEE,SAAS,eAAe,QACxB,QAAQ,cAAc,MACxB;OAEI,QAAQ;IACV,eAAe,QAAQ,CAAC;IACxB,MAAM;IACN,SAAS,KAAA;GACX;SACK;GACL,IAAI,CAAC,QACH,SAAS,UAAU;GAErB,OAAA;GACA,OAAA;GACA,eAAe,QAAQ,YAAY;EACrC;EACA;EACA;CACF,OAAO,IAAI,SAAS,eAAe,OAAO,QAAQ,cAAc,MAAM;EAEpE,IAAI,CAAC,QACH,SAAS,UAAU;EAErB,OAAA;EAEA;CACF,OAAO;EAEL,IAAI,CAAC,QACH,SAAS,UAAU;EAErB,OAAA;EACA,eAAe,QAAQ,YAAY;EAEnC;CACF;CAGF,IAAI,eAAe,QAAQ,QAAQ;EACjC,IAAI,CAAC,QACH,SAAS,UAAU;EAErB,OAAA,MAAwB,QAAQ,SAAS;EACzC,eAAe,QAAQ,YAAY;CACrC;CAEA,IAAI,gBAAgB,SAAS,QAAQ;EACnC,IAAI,CAAC,QACH,SAAS,UAAU;EAErB,OAAA,MAA0B,SAAS,SAAS;CAC9C;CAEA,IAAI,QAAQ;EACV,eAAe,QAAQ,CAAC;EACxB,MAAM;CACR;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;EAC3D,IAAI,OAAA,OAAwB,mBAC1B,OAAA,KAAsB;CAE1B;CAEA,SAAS,YAAoB;EAC3B,OAAO;GAAC;GAAe;GAAG;GAAG;EAAiB;CAChD;CAEA,OAAO,gBAAgB,SAAS,UAAU,eAAe,QAAQ,QAC/D,IAAI,SAAS,cAAc,CAAC,SAAS,QAAQ,aAAa,CAAC,MAAM;EAC/D,IACE,UAEE,SAAS,cAAc,CAAC,QACxB,QAAQ,aAAa,CAAC,MACxB,GAEI;OAAA,QAAQ;IACV,eAAe,QAAQ,CAAC;IACxB,MAAM;IACN,SAAS,KAAA;GACX;SACK;GACL,IAAI,CAAC,QACH,SAAS,UAAU;GAErB,OAAA,EAAoB;GACpB,OAAA,EAAsB;GACtB,eAAe,QAAQ,YAAY;EACrC;EACA;EACA;CACF,OAAO,IAAI,SAAS,cAAc,CAAC,OAAO,QAAQ,aAAa,CAAC,MAAM;EAEpE,IAAI,CAAC,QACH,SAAS,UAAU;EAErB,OAAA,EAAsB;EAEtB;CACF,OAAO;EAEL,IAAI,CAAC,QACH,SAAS,UAAU;EAErB,OAAA,EAAoB;EACpB,eAAe,QAAQ,YAAY;EAEnC;CACF;CAGF,IAAI,eAAe,QAAQ,QAAQ;EACjC,IAAI,CAAC,QACH,SAAS,UAAU;EAErB,OAAA,MAAwB,QAAQ,SAAS;EACzC,eAAe,QAAQ,YAAY;CACrC;CAEA,IAAI,gBAAgB,SAAS,QAAQ;EACnC,IAAI,CAAC,QACH,SAAS,UAAU;EAErB,OAAA,MAA0B,SAAS,SAAS;CAC9C;CAEA,IAAI,QAAQ;EACV,eAAe,QAAQ,CAAC;EACxB,MAAM;CACR;AACF"}

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

@@ -27,7 +27,7 @@ var BTreeWrite = class extends BTreeRead {
 	#modified = /* @__PURE__ */ new Map();
 	minSize;
 	maxSize;
-	constructor(dagWrite, formatVersion, root = emptyHash, minSize = 8 * 1024, maxSize = 16 * 1024, getEntrySize = getSizeOfEntry, chunkHeaderSize) {
+	constructor(dagWrite, formatVersion, root = emptyHash, minSize = 8192, maxSize = 16384, getEntrySize = getSizeOfEntry, chunkHeaderSize) {
 		super(dagWrite, formatVersion, root, getEntrySize, chunkHeaderSize);
 		this.minSize = minSize;
 		this.maxSize = maxSize;
@@ -67,7 +67,8 @@ var BTreeWrite = class extends BTreeRead {
 				const headerSize = this.chunkHeaderSize;
 				const { level } = rootNode;
 				const entries = partition(rootNode.entries, (value) => value[2], this.minSize - headerSize, this.maxSize - headerSize, (entries) => {
-					return createNewInternalEntryForNode(this.newNodeImpl(entries, level), this.getEntrySize);
+					const node = this.newNodeImpl(entries, level);
+					return createNewInternalEntryForNode(node, this.getEntrySize);
 				});
 				const newRoot = this.newInternalNodeImpl(entries, level + 1);
 				this.rootHash = newRoot.hash;
@@ -119,7 +120,8 @@ var BTreeWrite = class extends BTreeRead {
 			if (rootNode.getChildNodeSize(this) > this.maxSize) {
 				const { level } = rootNode;
 				const entries = partition(rootNode.entries, (e) => e[2], contentMin, contentMax, (partitionEntries) => {
-					return createNewInternalEntryForNode(this.newNodeImpl(partitionEntries, level), this.getEntrySize);
+					const node = this.newNodeImpl(partitionEntries, level);
+					return createNewInternalEntryForNode(node, this.getEntrySize);
 				});
 				const newRoot = this.newInternalNodeImpl(entries, level + 1);
 				this.rootHash = newRoot.hash;
@@ -132,8 +134,10 @@ var BTreeWrite = class extends BTreeRead {
 		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;
+			if (found) {
+				if (newRootNode.level > 0 && newRootNode.entries.length === 1) this.rootHash = newRootNode.entries[0][1];
+				else this.rootHash = newRootNode.hash;
+			}
 			return found;
 		});
 	}

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

@@ -1 +1 @@
-{"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 {level} = rootNode;\n        const entries = partition(\n          rootNode.entries,\n          value => value[2],\n          this.minSize - headerSize,\n          this.maxSize - headerSize,\n          entries => {\n            const node = this.newNodeImpl(entries, level);\n            return createNewInternalEntryForNode(node, this.getEntrySize);\n          },\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  /**\n   * Inserts multiple key-value pairs into the BTree efficiently.\n   * The entries array must be sorted by key.\n   * @param entries - Array of [key, value] tuples, must be sorted by key\n   * @returns Promise that resolves when all entries are inserted\n   */\n  putMany(\n    entries: ReadonlyArray<readonly [string, FrozenJSONValue]>,\n  ): Promise<void> {\n    return this.#lock.withLock(async () => {\n      if (entries.length === 0) {\n        return;\n      }\n\n      // Validate sortedness and convert to sized entries in one pass\n      const sizedEntries: Entry<FrozenJSONValue>[] = entries.map(\n        ([k, v], i) => {\n          if (i > 0) {\n            assert(\n              entries[i - 1][0] < k,\n              `putMany entries must be sorted and unique`,\n            );\n          }\n          return [k, v, this.getEntrySize(k, v)];\n        },\n      );\n\n      // Compute content size constraints\n      const headerSize = this.chunkHeaderSize;\n      const contentMin = this.minSize - headerSize;\n      const contentMax = this.maxSize - headerSize;\n\n      // Fast path: if tree is empty, use bulk loading algorithm\n      if (this.rootHash === emptyHash) {\n        // Build leaf nodes\n        const leafPartitions = partition(\n          sizedEntries,\n          e => e[2],\n          contentMin,\n          contentMax,\n          entries => entries,\n        );\n\n        if (leafPartitions.length === 0) {\n          return;\n        }\n\n        if (leafPartitions.length === 1) {\n          const leaf = this.newDataNodeImpl(leafPartitions[0]);\n          this.rootHash = leaf.hash;\n          return;\n        }\n\n        // Build tree bottom-up - reuse array to avoid allocations\n        let currentLevel: Array<DataNodeImpl | InternalNodeImpl | Entry<Hash>> =\n          leafPartitions.map(entries => this.newDataNodeImpl(entries));\n        let level = 0;\n\n        while (currentLevel.length > 1) {\n          level++;\n\n          // Create entries pointing to current level nodes - reuse array\n          const parentEntriesLength = currentLevel.length;\n          for (let i = 0; i < parentEntriesLength; i++) {\n            currentLevel[i] = createNewInternalEntryForNode(\n              currentLevel[i] as DataNodeImpl | InternalNodeImpl,\n              this.getEntrySize,\n            );\n          }\n\n          // Partition parent entries\n          const parentPartitions = partition(\n            currentLevel as Entry<Hash>[],\n            e => e[2],\n            contentMin,\n            contentMax,\n            entries => entries,\n          );\n\n          // Create internal nodes\n          currentLevel = parentPartitions.map(entries =>\n            this.newInternalNodeImpl(entries, level),\n          );\n        }\n\n        this.rootHash = (\n          currentLevel[0] as DataNodeImpl | InternalNodeImpl\n        ).hash;\n        return;\n      }\n\n      // Slow path: merge with existing tree\n      const oldRootNode = await this.getNode(this.rootHash);\n      const rootNode = await oldRootNode.putMany(sizedEntries, 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 {level} = rootNode;\n        const entries: Entry<Hash>[] = partition(\n          rootNode.entries,\n          e => e[2],\n          contentMin,\n          contentMax,\n          partitionEntries => {\n            const node = this.newNodeImpl(partitionEntries, level);\n            return createNewInternalEntryForNode(node, this.getEntrySize);\n          },\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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"}
+{"version":3,"file":"write.js","names":[],"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 {level} = rootNode;\n        const entries = partition(\n          rootNode.entries,\n          value => value[2],\n          this.minSize - headerSize,\n          this.maxSize - headerSize,\n          entries => {\n            const node = this.newNodeImpl(entries, level);\n            return createNewInternalEntryForNode(node, this.getEntrySize);\n          },\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  /**\n   * Inserts multiple key-value pairs into the BTree efficiently.\n   * The entries array must be sorted by key.\n   * @param entries - Array of [key, value] tuples, must be sorted by key\n   * @returns Promise that resolves when all entries are inserted\n   */\n  putMany(\n    entries: ReadonlyArray<readonly [string, FrozenJSONValue]>,\n  ): Promise<void> {\n    return this.#lock.withLock(async () => {\n      if (entries.length === 0) {\n        return;\n      }\n\n      // Validate sortedness and convert to sized entries in one pass\n      const sizedEntries: Entry<FrozenJSONValue>[] = entries.map(\n        ([k, v], i) => {\n          if (i > 0) {\n            assert(\n              entries[i - 1][0] < k,\n              `putMany entries must be sorted and unique`,\n            );\n          }\n          return [k, v, this.getEntrySize(k, v)];\n        },\n      );\n\n      // Compute content size constraints\n      const headerSize = this.chunkHeaderSize;\n      const contentMin = this.minSize - headerSize;\n      const contentMax = this.maxSize - headerSize;\n\n      // Fast path: if tree is empty, use bulk loading algorithm\n      if (this.rootHash === emptyHash) {\n        // Build leaf nodes\n        const leafPartitions = partition(\n          sizedEntries,\n          e => e[2],\n          contentMin,\n          contentMax,\n          entries => entries,\n        );\n\n        if (leafPartitions.length === 0) {\n          return;\n        }\n\n        if (leafPartitions.length === 1) {\n          const leaf = this.newDataNodeImpl(leafPartitions[0]);\n          this.rootHash = leaf.hash;\n          return;\n        }\n\n        // Build tree bottom-up - reuse array to avoid allocations\n        let currentLevel: Array<DataNodeImpl | InternalNodeImpl | Entry<Hash>> =\n          leafPartitions.map(entries => this.newDataNodeImpl(entries));\n        let level = 0;\n\n        while (currentLevel.length > 1) {\n          level++;\n\n          // Create entries pointing to current level nodes - reuse array\n          const parentEntriesLength = currentLevel.length;\n          for (let i = 0; i < parentEntriesLength; i++) {\n            currentLevel[i] = createNewInternalEntryForNode(\n              currentLevel[i] as DataNodeImpl | InternalNodeImpl,\n              this.getEntrySize,\n            );\n          }\n\n          // Partition parent entries\n          const parentPartitions = partition(\n            currentLevel as Entry<Hash>[],\n            e => e[2],\n            contentMin,\n            contentMax,\n            entries => entries,\n          );\n\n          // Create internal nodes\n          currentLevel = parentPartitions.map(entries =>\n            this.newInternalNodeImpl(entries, level),\n          );\n        }\n\n        this.rootHash = (\n          currentLevel[0] as DataNodeImpl | InternalNodeImpl\n        ).hash;\n        return;\n      }\n\n      // Slow path: merge with existing tree\n      const oldRootNode = await this.getNode(this.rootHash);\n      const rootNode = await oldRootNode.putMany(sizedEntries, 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 {level} = rootNode;\n        const entries: Entry<Hash>[] = partition(\n          rootNode.entries,\n          e => e[2],\n          contentMin,\n          contentMax,\n          partitionEntries => {\n            const node = this.newNodeImpl(partitionEntries, level);\n            return createNewInternalEntryForNode(node, this.getEntrySize);\n          },\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/config.js

@@ -1,2 +1 @@
-import "../../shared/src/config.js";
-export {};
+export { isProd as skipBTreeNodeAsserts, isProd as skipCommitDataAsserts, isProd as skipFreeze, isProd as skipFrozenAsserts, isProd as skipGCAsserts } from "../../shared/src/config.js";

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

@@ -1 +1 @@
-{"version":3,"file":"connection-loop.js","names":["#delegate","#lc","#visibilityWatcher","#closed","#abortSignal","#sendCounter","#sendResolver","#skipSleepsResolver","#pendingResolver","#waitUntilAvailableConnection","#connectionAvailable","#waitingConnectionResolve"],"sources":["../../../../replicache/src/connection-loop.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {resolver} from '@rocicorp/resolver';\nimport type {DocumentVisibilityWatcher} from '../../shared/src/document-visible.ts';\nimport {sleep} from '../../shared/src/sleep.ts';\n\nexport const DEBOUNCE_DELAY_MS = 10;\n\nexport const MIN_DELAY_MS = 30;\nexport const MAX_DELAY_MS = 60_000;\n\ntype SendRecord = {duration: number; ok: boolean};\n\nexport interface ConnectionLoopDelegate {\n  invokeSend(): Promise<boolean>;\n  debounceDelay: number;\n  // If null, no watchdog timer is used.\n  watchdogTimer: number | null;\n  maxConnections: number;\n  maxDelayMs: number;\n  minDelayMs: number;\n}\n\nexport class ConnectionLoop {\n  // ConnectionLoop runs a loop sending network requests (either pushes or\n  // pulls) to the server. Our goal, generally, is to send requests as fast as\n  // we can, but to adjust in case of slowness, network errors, etc. We will\n  // send requests in parallel if the server supports it. We also debounce\n  // pushes since they frequently happen in series very near to one another\n  // (e.g., during drag'n drops).\n  //\n  // The loop flows through the following states forever, until it is closed:\n  //\n  // Pending: Wait for event or watchdog\n  //          |\n  //          v\n  // Debounce: Wait for more events (we debounce pushes)\n  //          |\n  //          v\n  // Wait for available connection (we limit number of parallel requests\n  // allowed)\n  //          |\n  //          v\n  // Wait to send (if requests are taking too long, we will slow down)\n  //          |\n  //          v\n  // Send (asynchronously, wrt the loop)\n  //          |\n  //          v\n  // Back to the pending!\n\n  // Controls whether the next iteration of the loop will wait at the pending\n  // state.\n  #pendingResolver = resolver<void>();\n\n  /**\n   * This resolver is used to allow us to skip sleeps when we do send(true)\n   */\n  #skipSleepsResolver = resolver<void>();\n\n  /**\n   * Resolver for the next send. Never rejects. Returns an error instead since\n   * this resolver is used in cases where they might not be someone waiting,\n   * and we don't want an unhandled promise rejection in that case.\n   */\n  #sendResolver = resolver<undefined | {error: unknown}>();\n\n  readonly #delegate: ConnectionLoopDelegate;\n  #closed = false;\n  #abortSignal = new AbortController();\n\n  /**\n   * Number of pending send calls.\n   *\n   * We keep track of this because if close happens while we are waiting for the\n   * send to resolve we should reject the send promise.\n   */\n  #sendCounter = 0;\n  readonly #lc: LogContext;\n  readonly #visibilityWatcher: DocumentVisibilityWatcher | undefined;\n\n  constructor(\n    lc: LogContext,\n    delegate: ConnectionLoopDelegate,\n    visibilityWatcher?: DocumentVisibilityWatcher,\n  ) {\n    this.#lc = lc;\n    this.#delegate = delegate;\n    this.#visibilityWatcher = visibilityWatcher;\n    void this.run();\n  }\n\n  close(): void {\n    this.#closed = true;\n    this.#abortSignal.abort();\n    if (this.#sendCounter > 0) {\n      this.#sendResolver.resolve({error: closeError()});\n    }\n  }\n\n  /**\n   *\n   * @returns Returns undefined if ok, otherwise it return the error that caused\n   * the send to fail.\n   */\n  async send(now: boolean): Promise<undefined | {error: unknown}> {\n    if (this.#closed) {\n      return {error: closeError()};\n    }\n    this.#sendCounter++;\n    this.#lc.debug?.('send', now);\n    if (now) {\n      this.#skipSleepsResolver.resolve();\n    } else {\n      await this.#visibilityWatcher?.waitForVisible();\n    }\n\n    this.#pendingResolver.resolve();\n\n    const result = await this.#sendResolver.promise;\n    this.#sendCounter--;\n    return result;\n  }\n\n  async run(): Promise<void> {\n    const sendRecords: SendRecord[] = [];\n\n    let recoverResolver = resolver();\n    let lastSendTime;\n\n    // The number of active connections.\n    let counter = 0;\n    const delegate = this.#delegate;\n    const lc = this.#lc;\n    let delay = 0;\n\n    lc.debug?.('Starting connection loop');\n\n    const sleepMaybeSkip: typeof sleep = ms =>\n      Promise.race([this.#skipSleepsResolver.promise, sleep(ms)]);\n\n    while (!this.#closed) {\n      lc.debug?.(\n        didLastSendRequestFail(sendRecords)\n          ? 'Last request failed. Trying again'\n          : 'Waiting for a send',\n      );\n\n      // Wait until send is called or until the watchdog timer fires.\n      const races = [this.#pendingResolver.promise];\n      const t = delegate.watchdogTimer;\n      if (t !== null) {\n        // Wait for the watchdog timer to fire or the abort signal to be triggered.\n        races.push(sleep(t, this.#abortSignal.signal).catch(() => {}));\n      }\n      await Promise.race(races);\n      if (this.#closed) break;\n\n      lc.debug?.('Waiting for debounce');\n      await sleepMaybeSkip(delegate.debounceDelay);\n      if (this.#closed) break;\n      lc.debug?.('debounced');\n\n      // This resolver is used to wait for incoming push calls.\n      this.#pendingResolver = resolver();\n\n      if (counter >= delegate.maxConnections) {\n        lc.debug?.('Too many request in flight. Waiting until one finishes...');\n        await this.#waitUntilAvailableConnection();\n        if (this.#closed) break;\n        lc.debug?.('...finished');\n      }\n\n      // We need to delay the next request even if there are no active requests\n      // in case of error.\n      if (counter > 0 || didLastSendRequestFail(sendRecords)) {\n        delay = computeDelayAndUpdateDurations(delay, delegate, sendRecords);\n        lc.debug?.(\n          didLastSendRequestFail(sendRecords)\n            ? 'Last connection errored. Sleeping for'\n            : 'More than one outstanding connection (' +\n                counter +\n                '). Sleeping for',\n          delay,\n          'ms',\n        );\n      } else {\n        // We set this to 0 here in case minDelayMs is mutated to a lower value\n        // than the old delay so that we still get minDelayMs. This can happen\n        // if we get an error during a run where minDelayMs is larger than the\n        // current value of minDelayMs.\n        delay = 0;\n      }\n\n      const clampedDelay = Math.min(\n        delegate.maxDelayMs,\n        Math.max(delegate.minDelayMs, delay),\n      );\n      if (lastSendTime !== undefined) {\n        const timeSinceLastSend = Date.now() - lastSendTime;\n        if (clampedDelay > timeSinceLastSend) {\n          await Promise.race([\n            sleepMaybeSkip(clampedDelay - timeSinceLastSend),\n            recoverResolver.promise,\n          ]);\n          if (this.#closed) break;\n        }\n      }\n\n      counter++;\n      void (async () => {\n        const start = Date.now();\n        let ok: boolean;\n        let error: unknown;\n        try {\n          lastSendTime = start;\n          lc.debug?.('Sending request');\n          this.#skipSleepsResolver = resolver();\n          ok = await delegate.invokeSend();\n          lc.debug?.('Send returned', ok);\n        } catch (e) {\n          lc.debug?.('Send failed', e);\n          error = e;\n          ok = false;\n        }\n        if (this.#closed) {\n          lc.debug?.('Closed after invokeSend');\n          return;\n        }\n        lc.debug?.('Request done', {duration: Date.now() - start, ok});\n        sendRecords.push({duration: Date.now() - start, ok});\n        if (recovered(sendRecords)) {\n          recoverResolver.resolve();\n          recoverResolver = resolver();\n        }\n        counter--;\n        this.#connectionAvailable();\n        const sendResolver = this.#sendResolver;\n        this.#sendResolver = resolver();\n        if (error) {\n          sendResolver.resolve({error});\n        } else {\n          sendResolver.resolve(undefined);\n        }\n        if (!ok) {\n          // Keep trying\n          this.#pendingResolver.resolve();\n        }\n      })();\n    }\n  }\n\n  #waitingConnectionResolve: (() => void) | undefined = undefined;\n\n  #connectionAvailable() {\n    if (this.#waitingConnectionResolve) {\n      const resolve = this.#waitingConnectionResolve;\n      this.#waitingConnectionResolve = undefined;\n      resolve();\n    }\n  }\n\n  #waitUntilAvailableConnection() {\n    const {promise, resolve} = resolver();\n    this.#waitingConnectionResolve = resolve;\n    return promise;\n  }\n}\n\n// Number of connections to remember when computing the new delay.\nconst CONNECTION_MEMORY_COUNT = 9;\n\nfunction closeError() {\n  return new Error('Closed');\n}\n\n// Computes a new delay based on the previous requests. We use the median of the\n// previous successful request divided by `maxConnections`. When we get errors\n// we do exponential backoff. As soon as we recover from an error we reset back\n// to delegate.minDelayMs.\nfunction computeDelayAndUpdateDurations(\n  delay: number,\n  delegate: ConnectionLoopDelegate,\n  sendRecords: SendRecord[],\n): number {\n  const {length} = sendRecords;\n  if (length === 0) {\n    return delay;\n  }\n\n  // oxlint-disable-next-line typescript/no-non-null-assertion\n  const {ok} = sendRecords.at(-1)!;\n  const {maxConnections, minDelayMs} = delegate;\n\n  if (!ok) {\n    return delay === 0 ? minDelayMs : delay * 2;\n  }\n\n  if (length > 1) {\n    // length > 1\n    const previous: SendRecord = sendRecords[sendRecords.length - 2];\n\n    // Prune\n    while (sendRecords.length > CONNECTION_MEMORY_COUNT) {\n      sendRecords.shift();\n    }\n\n    if (ok && !previous.ok) {\n      // Recovered\n      return minDelayMs;\n    }\n  }\n\n  const med = median(\n    sendRecords.filter(({ok}) => ok).map(({duration}) => duration),\n  );\n\n  return (med / maxConnections) | 0;\n}\n\nfunction median(values: number[]) {\n  values.sort();\n  const {length} = values;\n  const half = length >> 1;\n  if (length % 2 === 1) {\n    return values[half];\n  }\n  return (values[half - 1] + values[half]) / 2;\n}\n\nfunction didLastSendRequestFail(sendRecords: SendRecord[]) {\n  // oxlint-disable-next-line typescript/no-non-null-assertion\n  return sendRecords.length > 0 && !sendRecords.at(-1)!.ok;\n}\n\nfunction recovered(sendRecords: SendRecord[]) {\n  return (\n    sendRecords.length > 1 &&\n    !sendRecords[sendRecords.length - 2].ok &&\n    // oxlint-disable-next-line typescript/no-non-null-assertion\n    sendRecords.at(-1)!.ok\n  );\n}\n"],"mappings":"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"}
+{"version":3,"file":"connection-loop.js","names":[],"sources":["../../../../replicache/src/connection-loop.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {resolver} from '@rocicorp/resolver';\nimport type {DocumentVisibilityWatcher} from '../../shared/src/document-visible.ts';\nimport {sleep} from '../../shared/src/sleep.ts';\n\nexport const DEBOUNCE_DELAY_MS = 10;\n\nexport const MIN_DELAY_MS = 30;\nexport const MAX_DELAY_MS = 60_000;\n\ntype SendRecord = {duration: number; ok: boolean};\n\nexport interface ConnectionLoopDelegate {\n  invokeSend(): Promise<boolean>;\n  debounceDelay: number;\n  // If null, no watchdog timer is used.\n  watchdogTimer: number | null;\n  maxConnections: number;\n  maxDelayMs: number;\n  minDelayMs: number;\n}\n\nexport class ConnectionLoop {\n  // ConnectionLoop runs a loop sending network requests (either pushes or\n  // pulls) to the server. Our goal, generally, is to send requests as fast as\n  // we can, but to adjust in case of slowness, network errors, etc. We will\n  // send requests in parallel if the server supports it. We also debounce\n  // pushes since they frequently happen in series very near to one another\n  // (e.g., during drag'n drops).\n  //\n  // The loop flows through the following states forever, until it is closed:\n  //\n  // Pending: Wait for event or watchdog\n  //          |\n  //          v\n  // Debounce: Wait for more events (we debounce pushes)\n  //          |\n  //          v\n  // Wait for available connection (we limit number of parallel requests\n  // allowed)\n  //          |\n  //          v\n  // Wait to send (if requests are taking too long, we will slow down)\n  //          |\n  //          v\n  // Send (asynchronously, wrt the loop)\n  //          |\n  //          v\n  // Back to the pending!\n\n  // Controls whether the next iteration of the loop will wait at the pending\n  // state.\n  #pendingResolver = resolver<void>();\n\n  /**\n   * This resolver is used to allow us to skip sleeps when we do send(true)\n   */\n  #skipSleepsResolver = resolver<void>();\n\n  /**\n   * Resolver for the next send. Never rejects. Returns an error instead since\n   * this resolver is used in cases where they might not be someone waiting,\n   * and we don't want an unhandled promise rejection in that case.\n   */\n  #sendResolver = resolver<undefined | {error: unknown}>();\n\n  readonly #delegate: ConnectionLoopDelegate;\n  #closed = false;\n  #abortSignal = new AbortController();\n\n  /**\n   * Number of pending send calls.\n   *\n   * We keep track of this because if close happens while we are waiting for the\n   * send to resolve we should reject the send promise.\n   */\n  #sendCounter = 0;\n  readonly #lc: LogContext;\n  readonly #visibilityWatcher: DocumentVisibilityWatcher | undefined;\n\n  constructor(\n    lc: LogContext,\n    delegate: ConnectionLoopDelegate,\n    visibilityWatcher?: DocumentVisibilityWatcher,\n  ) {\n    this.#lc = lc;\n    this.#delegate = delegate;\n    this.#visibilityWatcher = visibilityWatcher;\n    void this.run();\n  }\n\n  close(): void {\n    this.#closed = true;\n    this.#abortSignal.abort();\n    if (this.#sendCounter > 0) {\n      this.#sendResolver.resolve({error: closeError()});\n    }\n  }\n\n  /**\n   *\n   * @returns Returns undefined if ok, otherwise it return the error that caused\n   * the send to fail.\n   */\n  async send(now: boolean): Promise<undefined | {error: unknown}> {\n    if (this.#closed) {\n      return {error: closeError()};\n    }\n    this.#sendCounter++;\n    this.#lc.debug?.('send', now);\n    if (now) {\n      this.#skipSleepsResolver.resolve();\n    } else {\n      await this.#visibilityWatcher?.waitForVisible();\n    }\n\n    this.#pendingResolver.resolve();\n\n    const result = await this.#sendResolver.promise;\n    this.#sendCounter--;\n    return result;\n  }\n\n  async run(): Promise<void> {\n    const sendRecords: SendRecord[] = [];\n\n    let recoverResolver = resolver();\n    let lastSendTime;\n\n    // The number of active connections.\n    let counter = 0;\n    const delegate = this.#delegate;\n    const lc = this.#lc;\n    let delay = 0;\n\n    lc.debug?.('Starting connection loop');\n\n    const sleepMaybeSkip: typeof sleep = ms =>\n      Promise.race([this.#skipSleepsResolver.promise, sleep(ms)]);\n\n    while (!this.#closed) {\n      lc.debug?.(\n        didLastSendRequestFail(sendRecords)\n          ? 'Last request failed. Trying again'\n          : 'Waiting for a send',\n      );\n\n      // Wait until send is called or until the watchdog timer fires.\n      const races = [this.#pendingResolver.promise];\n      const t = delegate.watchdogTimer;\n      if (t !== null) {\n        // Wait for the watchdog timer to fire or the abort signal to be triggered.\n        races.push(sleep(t, this.#abortSignal.signal).catch(() => {}));\n      }\n      await Promise.race(races);\n      if (this.#closed) break;\n\n      lc.debug?.('Waiting for debounce');\n      await sleepMaybeSkip(delegate.debounceDelay);\n      if (this.#closed) break;\n      lc.debug?.('debounced');\n\n      // This resolver is used to wait for incoming push calls.\n      this.#pendingResolver = resolver();\n\n      if (counter >= delegate.maxConnections) {\n        lc.debug?.('Too many request in flight. Waiting until one finishes...');\n        await this.#waitUntilAvailableConnection();\n        if (this.#closed) break;\n        lc.debug?.('...finished');\n      }\n\n      // We need to delay the next request even if there are no active requests\n      // in case of error.\n      if (counter > 0 || didLastSendRequestFail(sendRecords)) {\n        delay = computeDelayAndUpdateDurations(delay, delegate, sendRecords);\n        lc.debug?.(\n          didLastSendRequestFail(sendRecords)\n            ? 'Last connection errored. Sleeping for'\n            : 'More than one outstanding connection (' +\n                counter +\n                '). Sleeping for',\n          delay,\n          'ms',\n        );\n      } else {\n        // We set this to 0 here in case minDelayMs is mutated to a lower value\n        // than the old delay so that we still get minDelayMs. This can happen\n        // if we get an error during a run where minDelayMs is larger than the\n        // current value of minDelayMs.\n        delay = 0;\n      }\n\n      const clampedDelay = Math.min(\n        delegate.maxDelayMs,\n        Math.max(delegate.minDelayMs, delay),\n      );\n      if (lastSendTime !== undefined) {\n        const timeSinceLastSend = Date.now() - lastSendTime;\n        if (clampedDelay > timeSinceLastSend) {\n          await Promise.race([\n            sleepMaybeSkip(clampedDelay - timeSinceLastSend),\n            recoverResolver.promise,\n          ]);\n          if (this.#closed) break;\n        }\n      }\n\n      counter++;\n      void (async () => {\n        const start = Date.now();\n        let ok: boolean;\n        let error: unknown;\n        try {\n          lastSendTime = start;\n          lc.debug?.('Sending request');\n          this.#skipSleepsResolver = resolver();\n          ok = await delegate.invokeSend();\n          lc.debug?.('Send returned', ok);\n        } catch (e) {\n          lc.debug?.('Send failed', e);\n          error = e;\n          ok = false;\n        }\n        if (this.#closed) {\n          lc.debug?.('Closed after invokeSend');\n          return;\n        }\n        lc.debug?.('Request done', {duration: Date.now() - start, ok});\n        sendRecords.push({duration: Date.now() - start, ok});\n        if (recovered(sendRecords)) {\n          recoverResolver.resolve();\n          recoverResolver = resolver();\n        }\n        counter--;\n        this.#connectionAvailable();\n        const sendResolver = this.#sendResolver;\n        this.#sendResolver = resolver();\n        if (error) {\n          sendResolver.resolve({error});\n        } else {\n          sendResolver.resolve(undefined);\n        }\n        if (!ok) {\n          // Keep trying\n          this.#pendingResolver.resolve();\n        }\n      })();\n    }\n  }\n\n  #waitingConnectionResolve: (() => void) | undefined = undefined;\n\n  #connectionAvailable() {\n    if (this.#waitingConnectionResolve) {\n      const resolve = this.#waitingConnectionResolve;\n      this.#waitingConnectionResolve = undefined;\n      resolve();\n    }\n  }\n\n  #waitUntilAvailableConnection() {\n    const {promise, resolve} = resolver();\n    this.#waitingConnectionResolve = resolve;\n    return promise;\n  }\n}\n\n// Number of connections to remember when computing the new delay.\nconst CONNECTION_MEMORY_COUNT = 9;\n\nfunction closeError() {\n  return new Error('Closed');\n}\n\n// Computes a new delay based on the previous requests. We use the median of the\n// previous successful request divided by `maxConnections`. When we get errors\n// we do exponential backoff. As soon as we recover from an error we reset back\n// to delegate.minDelayMs.\nfunction computeDelayAndUpdateDurations(\n  delay: number,\n  delegate: ConnectionLoopDelegate,\n  sendRecords: SendRecord[],\n): number {\n  const {length} = sendRecords;\n  if (length === 0) {\n    return delay;\n  }\n\n  // oxlint-disable-next-line typescript/no-non-null-assertion\n  const {ok} = sendRecords.at(-1)!;\n  const {maxConnections, minDelayMs} = delegate;\n\n  if (!ok) {\n    return delay === 0 ? minDelayMs : delay * 2;\n  }\n\n  if (length > 1) {\n    // length > 1\n    const previous: SendRecord = sendRecords[sendRecords.length - 2];\n\n    // Prune\n    while (sendRecords.length > CONNECTION_MEMORY_COUNT) {\n      sendRecords.shift();\n    }\n\n    if (ok && !previous.ok) {\n      // Recovered\n      return minDelayMs;\n    }\n  }\n\n  const med = median(\n    sendRecords.filter(({ok}) => ok).map(({duration}) => duration),\n  );\n\n  return (med / maxConnections) | 0;\n}\n\nfunction median(values: number[]) {\n  values.sort();\n  const {length} = values;\n  const half = length >> 1;\n  if (length % 2 === 1) {\n    return values[half];\n  }\n  return (values[half - 1] + values[half]) / 2;\n}\n\nfunction didLastSendRequestFail(sendRecords: SendRecord[]) {\n  // oxlint-disable-next-line typescript/no-non-null-assertion\n  return sendRecords.length > 0 && !sendRecords.at(-1)!.ok;\n}\n\nfunction recovered(sendRecords: SendRecord[]) {\n  return (\n    sendRecords.length > 1 &&\n    !sendRecords[sendRecords.length - 2].ok &&\n    // oxlint-disable-next-line typescript/no-non-null-assertion\n    sendRecords.at(-1)!.ok\n  );\n}\n"],"mappings":"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"}

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

@@ -48,6 +48,6 @@ function createChunk(data, refs, chunkHasher) {
 	return new Chunk(chunkHasher(), data, refs);
 }
 //#endregion
-export { Chunk, assertRefs, createChunk, toRefs };
+export { Chunk, asRefs, assertRefs, createChunk, toRefs };
 
 //# sourceMappingURL=chunk.js.map

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

@@ -1 +1 @@
-{"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 {getOrInsertComputed} from '../../../shared/src/map.ts';\nimport type {MaybePromise} from '../../../shared/src/types.ts';\nimport {skipGCAsserts} from '../config.ts';\nimport {type Hash, emptyHash} from '../hash.ts';\nimport {InvalidRefCountError} from './invalid-ref-count-error.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    // A negative count means a chunk that is still referenced had no (or too\n    // low a) ref count in the store, so the store is already corrupt. Always\n    // check this, even in production: writing the negative count would only\n    // spread the corruption, and the typed error lets the store owner recover.\n    // Written as `!(update >= 0)` so that NaN is rejected as well.\n    for (const [hash, update] of this.#refCountUpdates) {\n      if (!(update >= 0)) {\n        throw new InvalidRefCountError(hash, update);\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    return getOrInsertComputed(\n      this.#loadedRefCountPromises,\n      hash,\n      async hash => {\n        const value = (await this.#delegate.getRefCount(hash)) || 0;\n        this.#refCountUpdates.set(hash, value);\n        return value;\n      },\n    );\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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"}
+{"version":3,"file":"gc.js","names":["skipGCAsserts"],"sources":["../../../../../replicache/src/dag/gc.ts"],"sourcesContent":["import {assert, assertNumber} from '../../../shared/src/asserts.ts';\nimport {getOrInsertComputed} from '../../../shared/src/map.ts';\nimport type {MaybePromise} from '../../../shared/src/types.ts';\nimport {skipGCAsserts} from '../config.ts';\nimport {type Hash, emptyHash} from '../hash.ts';\nimport {InvalidRefCountError} from './invalid-ref-count-error.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    // A negative count means a chunk that is still referenced had no (or too\n    // low a) ref count in the store, so the store is already corrupt. Always\n    // check this, even in production: writing the negative count would only\n    // spread the corruption, and the typed error lets the store owner recover.\n    // Written as `!(update >= 0)` so that NaN is rejected as well.\n    for (const [hash, update] of this.#refCountUpdates) {\n      if (!(update >= 0)) {\n        throw new InvalidRefCountError(hash, update);\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    return getOrInsertComputed(\n      this.#loadedRefCountPromises,\n      hash,\n      async hash => {\n        const value = (await this.#delegate.getRefCount(hash)) || 0;\n        this.#refCountUpdates.set(hash, value);\n        return value;\n      },\n    );\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/lazy-store.js

@@ -446,12 +446,13 @@ var ChunksCache = class {
 		}
 	}
 	updateForCommit(chunksToPut, refCountUpdates) {
-		for (const [hash, count] of refCountUpdates) if (count === 0) if (!this.#evictsAndDeletesSuspended) this.#deleteEntryByHash(hash);
-		else {
-			this.#refCounts.set(hash, 0);
-			this.#suspendedDeletes.push(hash);
-		}
-		else {
+		for (const [hash, count] of refCountUpdates) if (count === 0) {
+			if (!this.#evictsAndDeletesSuspended) this.#deleteEntryByHash(hash);
+			else {
+				this.#refCounts.set(hash, 0);
+				this.#suspendedDeletes.push(hash);
+			}
+		} else {
 			this.#refCounts.set(hash, count);
 			const chunkAndSize = chunksToPut.get(hash);
 			if (chunkAndSize) {
@@ -484,6 +485,6 @@ var ChunksCache = class {
 	}
 };
 //#endregion
-export { LazyStore };
+export { LazyRead, LazyStore, LazyWrite };
 
 //# sourceMappingURL=lazy-store.js.map