@typeberry/lib 0.4.1-9e565b9 → 0.4.1-f776cce

package/index.d.ts

@@ -1008,7 +1008,7 @@ declare class BytesBlob {
    *
    * Last chunk might be smaller than `size`.
    */
-  *chunks(size: number): Generator<BytesBlob> {
+  *chunks(size: number): Generator<BytesBlob, undefined, void> {
     for (let i = 0; i < this.length; i += size) {
       yield BytesBlob.blobFrom(this.raw.subarray(i, i + size));
     }
@@ -3570,6 +3570,497 @@ declare class ArrayView<T> implements Iterable<T> {
   }
 }
 
+/** A map which uses byte blobs as keys */
+declare class BlobDictionary<K extends BytesBlob, V> extends WithDebug {
+  /**
+   * The root node of the dictionary.
+   *
+   * This is the main internal data structure that organizes entries
+   * in a tree-like fashion (array-based nodes up to `mapNodeThreshold`,
+   * map-based nodes beyond it). All insertions, updates, and deletions
+   * operate through this structure.
+   */
+  private root: Node<K, V> = Node.withList();
+
+  /**
+   * Auxiliary map that stores references to the original keys and their values.
+   *
+   * - Overriding a value in the main structure does not replace the original key reference.
+   * - Used for efficient iteration over `keys()`, `values()`, `entries()`, and computing `size`.
+   */
+  private keyvals: Map<K, Leaf<K, V>> = new Map();
+
+  /**
+   * Protected constructor used internally by `BlobDictionary.new`
+   * and `BlobDictionary.fromEntries`.
+   *
+   * This enforces controlled instantiation — users should create instances
+   * through the provided static factory methods instead of calling the
+   * constructor directly.
+   *
+   * @param mapNodeThreshold - The threshold that determines when the dictionary
+   * switches from using an array-based (`ListChildren`) node to a map-based (`MapChildren`) node for storing entries.
+   */
+  protected constructor(private mapNodeThreshold: number) {
+    super();
+  }
+
+  /**
+   * Returns the number of entries in the dictionary.
+   *
+   * The count is derived from the auxiliary `keyvals` map, which stores
+   * all original key references and their associated values. This ensures
+   * that the `size` reflects the actual number of entries, independent of
+   * internal overrides in the main `root` structure.
+   *
+   * @returns The total number of entries in the dictionary.
+   */
+  get size(): number {
+    return this.keyvals.size;
+  }
+
+  [TEST_COMPARE_USING]() {
+    const vals: [K, V][] = Array.from(this);
+    vals.sort((a, b) => a[0].compare(b[0]).value);
+    return vals;
+  }
+
+  /**
+   * Creates an empty `BlobDictionary`.
+   *
+   * @param mapNodeThreshold - The threshold that determines when the dictionary
+   * switches from using an array-based (`ListChildren`) node to a map-based (`MapChildren`) node for storing entries.
+   * Defaults to `0`.
+   *
+   * @returns A new, empty `BlobDictionary` instance.
+   */
+  static new<K extends BytesBlob, V>(mapNodeThreshold = 0) {
+    return new BlobDictionary<K, V>(mapNodeThreshold);
+  }
+
+  /**
+   * Creates a new `BlobDictionary` initialized with the given entries.
+   *
+   * @param entries - An array of `[key, value]` pairs used to populate the dictionary.
+   * @param mapNodeThreshold - The threshold that determines when the dictionary
+   * switches from using an array-based (`ListChildren`) node to a map-based (`MapChildren`) node for storing entries.
+   * Defaults to `0`.
+   *
+   * @returns A new `BlobDictionary` containing the provided entries.
+   */
+  static fromEntries<K extends BytesBlob, V>(entries: [K, V][], mapNodeThreshold?: number): BlobDictionary<K, V> {
+    const dict = BlobDictionary.new<K, V>(mapNodeThreshold);
+    for (const [key, value] of entries) {
+      dict.set(key, value);
+    }
+    return dict;
+  }
+  /**
+   * Internal helper that inserts, updates or deletes an entry in the dictionary.
+   *
+   * Behaviour details:
+   * - Passing `undefined` as `value` indicates a deletion. (E.g. `delete` uses `internalSet(key, undefined)`.)
+   * - When an add (new entry) or a delete actually changes the structure, the method returns the affected leaf node.
+   * - When the call only overrides an existing value (no structural add/delete), the method returns `null`.
+   *
+   * This method is intended for internal use by the dictionary implementation and allows `undefined` as a
+   * sentinel value to signal removals.
+   *
+   * @param key - The key to insert, update or remove.
+   * @param value - The value to associate with the key, or `undefined` to remove the key.
+   * @returns The leaf node created or removed on add/delete, or `null` if the operation only overwrote an existing value.
+   */
+  private internalSet(key: K, value: V | undefined): Leaf<K, V> | null {
+    let node: Node<K, V> = this.root;
+    const keyChunkGenerator = key.chunks(CHUNK_SIZE);
+    let depth = 0;
+
+    for (;;) {
+      const maybeKeyChunk = keyChunkGenerator.next().value;
+      if (maybeKeyChunk === undefined) {
+        if (value === undefined) {
+          return node.remove(key);
+        }
+        return node.set(key, value);
+      }
+
+      const keyChunk: KeyChunk = asOpaqueType(maybeKeyChunk);
+
+      if (node.children instanceof ListChildren) {
+        const subkey = BytesBlob.blobFrom(key.raw.subarray(CHUNK_SIZE * depth));
+        const leaf = value !== undefined ? node.children.insert(subkey, { key, value }) : node.children.remove(subkey);
+
+        if (subkey.length > CHUNK_SIZE && node.children.children.length > this.mapNodeThreshold) {
+          node.convertListChildrenToMap();
+        }
+        return leaf;
+      }
+
+      depth += 1;
+
+      const children = node.children;
+      if (children instanceof ListChildren) {
+        throw new Error("We handle list node earlier. If we fall through, we know it's for the `Map` case.");
+      }
+
+      if (children instanceof MapChildren) {
+        const maybeNode = children.getChild(keyChunk);
+
+        if (maybeNode !== undefined) {
+          // simply go one level deeper
+          node = maybeNode;
+        } else {
+          // we are trying to remove an item, but it does not exist
+          if (value === undefined) {
+            return null;
+          }
+
+          // no more child nodes, we insert a new one.
+          const newNode = Node.withList<K, V>();
+          children.setChild(keyChunk, newNode);
+          node = newNode;
+        }
+        continue;
+      }
+
+      assertNever(children);
+    }
+  }
+
+  /**
+   * Adds a new entry to the dictionary or updates the value of an existing key.
+   *
+   * If an entry with the given key already exists, its value is replaced
+   * with the new one.
+   *
+   * @param key - The key to add or update in the dictionary.
+   * @param value - The value to associate with the specified key.
+   * @returns Nothing (`void`).
+   */
+  set(key: K, value: V): void {
+    const leaf = this.internalSet(key, value);
+    if (leaf !== null) {
+      this.keyvals.set(leaf.key, leaf);
+    }
+  }
+
+  /**
+   * Retrieves the value associated with the given key from the dictionary.
+   *
+   * If the key does not exist, this method returns `undefined`.
+   *
+   * @param key - The key whose associated value should be retrieved.
+   * @returns The value associated with the specified key, or `undefined` if the key is not present.
+   */
+  get(key: K): V | undefined {
+    let node: MaybeNode<K, V> = this.root;
+    const pathChunksGenerator = key.chunks(CHUNK_SIZE);
+    let depth = 0;
+
+    while (node !== undefined) {
+      const maybePathChunk = pathChunksGenerator.next().value;
+
+      if (node.children instanceof ListChildren) {
+        const subkey = BytesBlob.blobFrom(key.raw.subarray(depth * CHUNK_SIZE));
+        const child = node.children.find(subkey);
+        if (child !== null) {
+          return child.value;
+        }
+      }
+
+      if (maybePathChunk === undefined) {
+        return node.getLeaf()?.value;
+      }
+
+      if (node.children instanceof MapChildren) {
+        const pathChunk: KeyChunk = asOpaqueType(maybePathChunk);
+        node = node.children.getChild(pathChunk);
+        depth += 1;
+      }
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Checks whether the dictionary contains an entry for the given key.
+   *
+   * ⚠️ **Note:** Avoid using `has(...)` together with `get(...)` in a pattern like this:
+   *
+   * ```ts
+   * if (dict.has(key)) {
+   *   const value = dict.get(key);
+   *   ...
+   * }
+   * ```
+   *
+   * This approach performs two lookups for the same key.
+   *
+   * Instead, prefer the following pattern, which retrieves the value once:
+   *
+   * ```ts
+   * const value = dict.get(key);
+   * if (value !== undefined) {
+   *   ...
+   * }
+   * ```
+   *
+   * @param key - The key to check for.
+   * @returns `true` if the dictionary contains an entry for the given key, otherwise `false`.
+   */
+  has(key: K): boolean {
+    return this.get(key) !== undefined;
+  }
+
+  /**
+   * Removes an entry with the specified key from the dictionary.
+   *
+   * Internally, this calls {@link internalSet} with `undefined` to mark the entry as deleted.
+   *
+   * @param key - The key of the entry to remove.
+   * @returns `true` if an entry was removed (i.e. the key existed), otherwise `false`.
+   */
+  delete(key: K): boolean {
+    const leaf = this.internalSet(key, undefined);
+    if (leaf !== null) {
+      this.keyvals.delete(leaf.key);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Returns an iterator over the keys in the dictionary.
+   *
+   * The iterator yields each key in insertion order.
+   *
+   * @returns An iterator over all keys in the dictionary.
+   */
+  keys(): Iterator<K> & Iterable<K> {
+    return this.keyvals.keys();
+  }
+
+  /**
+   * Returns an iterator over the values in the dictionary.
+   *
+   * The iterator yields each value in insertion order.
+   *
+   * @returns An iterator over all values in the dictionary.
+   */
+  *values(): Iterator<V> & Iterable<V> {
+    for (const leaf of this.keyvals.values()) {
+      yield leaf.value;
+    }
+  }
+
+  /**
+   * Returns an iterator over the `[key, value]` pairs in the dictionary.
+   *
+   * The iterator yields entries in insertion order.
+   *
+   * @returns An iterator over `[key, value]` tuples for each entry in the dictionary.
+   */
+  *entries(): Iterator<[K, V]> & Iterable<[K, V]> {
+    for (const leaf of this.keyvals.values()) {
+      yield [leaf.key, leaf.value];
+    }
+  }
+
+  /**
+   * Default iterator for the dictionary.
+   *
+   * Equivalent to calling {@link entries}.
+   * Enables iteration with `for...of`:
+   *
+   * ```ts
+   * for (const [key, value] of dict) {
+   *   ...
+   * }
+   * ```
+   *
+   * @returns An iterator over `[key, value]` pairs.
+   */
+  [Symbol.iterator](): Iterator<[K, V]> & Iterable<[K, V]> {
+    return this.entries();
+  }
+
+  /**
+   * Creates a new sorted array of values, ordered by their corresponding keys.
+   *
+   * Iterates over all entries in the dictionary and sorts them according
+   * to the provided comparator function applied to the keys.
+   *
+   * @param comparator - A comparator function that can compare two keys.
+   *
+   * @returns A new array containing all values from the dictionary,
+   * sorted according to their keys.
+   */
+  toSortedArray(comparator: Comparator<K>): V[] {
+    const vals: [K, V][] = Array.from(this);
+    vals.sort((a, b) => comparator(a[0], b[0]).value);
+    return vals.map((x) => x[1]);
+  }
+}
+
+declare const CHUNK_SIZE = 6;
+type CHUNK_SIZE = typeof CHUNK_SIZE;
+
+/**
+ * A function to transform a bytes chunk (up to 6 bytes into U48 number)
+ *
+ * Note that it uses 3 additional bits to store length(`value * 8 + len;`),
+ * It is needed to distinguish shorter chunks that have 0s at the end, for example: [1, 2] and [1, 2, 0]
+ * */
+declare function bytesAsU48(bytes: Uint8Array): number {
+  const len = bytes.length;
+
+  check`${len <= CHUNK_SIZE} Length has to be <= ${CHUNK_SIZE}, got: ${len}`;
+
+  let value = bytes[3] | (bytes[2] << 8) | (bytes[1] << 16) | (bytes[0] << 24);
+
+  for (let i = 4; i < bytes.length; i++) {
+    value = value * 256 + bytes[i];
+  }
+
+  return value * 8 + len;
+}
+
+type KeyChunk = Opaque<BytesBlob, `up to ${CHUNK_SIZE} bytes`>;
+type U48 = number;
+type SubKey<_K extends BytesBlob> = BytesBlob;
+type OriginalKeyRef<K> = K;
+type MaybeNode<K extends BytesBlob, V> = Node<K, V> | undefined;
+
+type Leaf<K extends BytesBlob, V> = {
+  key: OriginalKeyRef<K>;
+  value: V;
+};
+
+declare class Node<K extends BytesBlob, V> {
+  convertListChildrenToMap() {
+    if (!(this.children instanceof ListChildren)) {
+      return;
+    }
+    this.children = MapChildren.fromListNode<K, V>(this.children);
+  }
+
+  static withList<K extends BytesBlob, V>(): Node<K, V> {
+    return new Node(undefined, ListChildren.new());
+  }
+
+  static withMap<K extends BytesBlob, V>(): Node<K, V> {
+    return new Node(undefined, MapChildren.new());
+  }
+
+  private constructor(
+    private leaf: Leaf<K, V> | undefined,
+    public children: MapChildren<K, V> | ListChildren<K, V>,
+  ) {}
+
+  getLeaf(): Leaf<K, V> | undefined {
+    return this.leaf;
+  }
+
+  remove(_key: K): Leaf<K, V> | null {
+    if (this.leaf === undefined) {
+      return null;
+    }
+
+    const removedLeaf = this.leaf;
+    this.leaf = undefined;
+    return removedLeaf;
+  }
+
+  set(key: K, value: V): Leaf<K, V> | null {
+    if (this.leaf === undefined) {
+      this.leaf = { key, value };
+      return this.leaf;
+    }
+    this.leaf.value = value;
+    return null;
+  }
+}
+
+declare class ListChildren<K extends BytesBlob, V> {
+  children: [SubKey<K>, Leaf<K, V>][] = [];
+
+  private constructor() {}
+
+  find(key: SubKey<K>): Leaf<K, V> | null {
+    const result = this.children.find((item) => item[0].isEqualTo(key));
+    if (result !== undefined) {
+      return result[1];
+    }
+    return null;
+  }
+
+  remove(key: SubKey<K>): Leaf<K, V> | null {
+    const existingIndex = this.children.findIndex((item) => item[0].isEqualTo(key));
+    if (existingIndex >= 0) {
+      const ret = this.children.splice(existingIndex, 1);
+      return ret[0][1];
+    }
+    return null;
+  }
+
+  insert(key: SubKey<K>, leaf: Leaf<K, V>): Leaf<K, V> | null {
+    const existingIndex = this.children.findIndex((item) => item[0].isEqualTo(key));
+    if (existingIndex >= 0) {
+      const existing = this.children[existingIndex];
+      existing[1].value = leaf.value;
+      return null;
+    }
+
+    this.children.push([key, leaf]);
+    return leaf;
+  }
+
+  static new<K extends BytesBlob, V>() {
+    return new ListChildren<K, V>();
+  }
+}
+
+declare class MapChildren<K extends BytesBlob, V> {
+  children: Map<U48, Node<K, V>> = new Map();
+
+  private constructor() {}
+
+  static new<K extends BytesBlob, V>(): MapChildren<K, V> {
+    return new MapChildren<K, V>();
+  }
+
+  static fromListNode<K extends BytesBlob, T>(node: ListChildren<K, T>): MapChildren<K, T> {
+    const mapNode = new MapChildren<K, T>();
+
+    for (const [key, leaf] of node.children) {
+      const currentKeyChunk: KeyChunk = asOpaqueType(BytesBlob.blobFrom(key.raw.subarray(0, CHUNK_SIZE)));
+      const subKey = BytesBlob.blobFrom(key.raw.subarray(CHUNK_SIZE));
+
+      let child = mapNode.getChild(currentKeyChunk);
+
+      if (child === undefined) {
+        child = Node.withList<K, T>();
+        mapNode.setChild(currentKeyChunk, child);
+      }
+
+      const children = child.children as ListChildren<K, T>;
+      children.insert(subKey, leaf);
+    }
+
+    return mapNode;
+  }
+
+  getChild(keyChunk: KeyChunk) {
+    const chunkAsNumber = bytesAsU48(keyChunk.raw);
+    return this.children.get(chunkAsNumber);
+  }
+
+  setChild(keyChunk: KeyChunk, node: Node<K, V>) {
+    const chunkAsNumber = bytesAsU48(keyChunk.raw);
+    this.children.set(chunkAsNumber, node);
+  }
+}
+
 type ITypedArray = Uint8Array | Uint16Array | Uint32Array;
 type IDataType = string | Buffer | ITypedArray;
 
@@ -3770,17 +4261,20 @@ interface ImmutableHashDictionary<K extends OpaqueHash, V> extends Iterable<[K,
   get(key: K): V | undefined;
 
   /** Iterator over keys of the dictionary. */
-  keys(): Generator<K>;
+  keys(): Iterator<K>;
 
   /** Iterator over values of the dictionary. */
-  values(): Generator<V>;
+  values(): Iterator<V>;
 
   /** Returns an array of the map's values, sorted by their corresponding keys */
   toSortedArray(compare: Comparator<K>): V[];
 }
-
-/** A map which uses hashes as keys. */
-declare class HashDictionary<K extends OpaqueHash, V> implements ImmutableHashDictionary<K, V> {
+/**
+ * A map which uses hashes as keys.
+ *
+ * @deprecated
+ * */
+declare class StringHashDictionary<K extends OpaqueHash, V> implements ImmutableHashDictionary<K, V> {
   // TODO [ToDr] [crit] We can't use `TrieHash` directly in the map,
   // because of the way it's being compared. Hence having `string` here.
   // This has to be benchmarked and re-written to a custom map most likely.
@@ -3860,6 +4354,15 @@ declare class HashDictionary<K extends OpaqueHash, V> implements ImmutableHashDi
   }
 }
 
+declare class HashDictionary<K extends OpaqueHash, V>
+  extends BlobDictionary<K, V>
+  implements ImmutableHashDictionary<K, V>
+{
+  constructor() {
+    super(BLOB_DICTIONARY_THRESHOLD);
+  }
+}
+
 /** Immutable version of the HashSet. */
 interface ImmutableHashSet<V extends OpaqueHash> extends Iterable<V> {
   /** Return number of items in the set. */
@@ -4451,7 +4954,14 @@ declare class SortedSet<V> extends SortedArray<V> implements ImmutableSortedSet<
   }
 }
 
-type HashWithZeroedBit<T extends OpaqueHash> = T;
+declare function getTruncatedKey(key: OpaqueHash | TruncatedHash) {
+  // Always return exactly TRUNCATED_HASH_SIZE bytes.
+  if (key.length === TRUNCATED_HASH_SIZE) {
+    return key;
+  }
+
+  return Bytes.fromBlob(key.raw.subarray(0, TRUNCATED_HASH_SIZE), TRUNCATED_HASH_SIZE);
+}
 
 /**
  * A collection of hash-based keys (likely `StateKey`s) which ignores
@@ -4466,22 +4976,18 @@ declare class TruncatedHashDictionary<T extends OpaqueHash, V> {
   static fromEntries<T extends OpaqueHash, V>(
     entries: Iterable<[T | TruncatedHash, V] | readonly [T | TruncatedHash, V]>,
   ): TruncatedHashDictionary<T, V> {
-    /** Copy key bytes of an entry and replace the last one with 0. */
-    const mapped = Array.from(entries).map<[T, V]>(([key, value]) => {
-      const newKey: T = Bytes.zero(HASH_SIZE).asOpaque();
-      newKey.raw.set(key.raw.subarray(0, TRUNCATED_HASH_SIZE));
-      return [newKey, value];
-    });
-    return new TruncatedHashDictionary(HashDictionary.fromEntries(mapped));
+    return new TruncatedHashDictionary(
+      BlobDictionary.fromEntries<TruncatedHash, V>(
+        Array.from(entries).map(([key, value]) => [getTruncatedKey(key), value]),
+        BLOB_DICTIONARY_THRESHOLD,
+      ),
+    );
   }
 
-  /** A truncated key which we re-use to query the dictionary. */
-  private readonly truncatedKey: T = Bytes.zero(HASH_SIZE).asOpaque();
-
-  private constructor(private readonly dict: HashDictionary<HashWithZeroedBit<T>, V>) {}
+  private constructor(private readonly dict: BlobDictionary<TruncatedHash, V>) {}
 
   [TEST_COMPARE_USING]() {
-    return this.dict;
+    return Array.from(this.dict);
   }
 
   /** Return number of items in the dictionary. */
@@ -4490,31 +4996,27 @@ declare class TruncatedHashDictionary<T extends OpaqueHash, V> {
   }
 
   /** Retrieve a value that matches the key on `TRUNCATED_HASH_SIZE`. */
-  get(fullKey: T | TruncatedHash): V | undefined {
-    this.truncatedKey.raw.set(fullKey.raw.subarray(0, TRUNCATED_HASH_SIZE));
-    return this.dict.get(this.truncatedKey);
+  get(key: T | TruncatedHash): V | undefined {
+    const truncatedKey = getTruncatedKey(key);
+    return this.dict.get(truncatedKey);
   }
 
   /** Return true if the key is present in the dictionary */
-  has(fullKey: T | TruncatedHash): boolean {
-    this.truncatedKey.raw.set(fullKey.raw.subarray(0, TRUNCATED_HASH_SIZE));
-
-    return this.dict.has(this.truncatedKey);
+  has(key: T | TruncatedHash): boolean {
+    const truncatedKey = getTruncatedKey(key);
+    return this.dict.has(truncatedKey);
   }
 
   /** Set or update a value that matches the key on `TRUNCATED_HASH_SIZE`. */
-  set(fullKey: T | TruncatedHash, value: V) {
-    // NOTE we can't use the the shared key here, since the collection will
-    // store the key for us, hence the copy.
-    const key = Bytes.zero(HASH_SIZE);
-    key.raw.set(fullKey.raw.subarray(0, TRUNCATED_HASH_SIZE));
-    this.dict.set(key.asOpaque(), value);
+  set(key: T | TruncatedHash, value: V) {
+    const truncatedKey = getTruncatedKey(key);
+    this.dict.set(truncatedKey, value);
   }
 
   /** Remove a value that matches the key on `TRUNCATED_HASH_SIZE`. */
-  delete(fullKey: T | TruncatedHash) {
-    this.truncatedKey.raw.set(fullKey.raw.subarray(0, TRUNCATED_HASH_SIZE));
-    this.dict.delete(this.truncatedKey);
+  delete(key: T | TruncatedHash) {
+    const truncatedKey = getTruncatedKey(key);
+    this.dict.delete(truncatedKey);
   }
 
   /** Iterator over values of the dictionary. */
@@ -4524,9 +5026,7 @@ declare class TruncatedHashDictionary<T extends OpaqueHash, V> {
 
   /** Iterator over entries of the dictionary (with truncated keys) */
   *entries(): Generator<[TruncatedHash, V]> {
-    for (const [key, value] of this.dict.entries()) {
-      yield [Bytes.fromBlob(key.raw.subarray(0, TRUNCATED_HASH_SIZE), TRUNCATED_HASH_SIZE).asOpaque(), value];
-    }
+    yield* this.dict.entries();
   }
 
   [Symbol.iterator]() {
@@ -4536,35 +5036,53 @@ declare class TruncatedHashDictionary<T extends OpaqueHash, V> {
 
 type index$o_ArrayView<T> = ArrayView<T>;
 declare const index$o_ArrayView: typeof ArrayView;
+type index$o_BlobDictionary<K extends BytesBlob, V> = BlobDictionary<K, V>;
+declare const index$o_BlobDictionary: typeof BlobDictionary;
+type index$o_CHUNK_SIZE = CHUNK_SIZE;
 type index$o_FixedSizeArray<T, N extends number> = FixedSizeArray<T, N>;
 declare const index$o_FixedSizeArray: typeof FixedSizeArray;
 type index$o_HashDictionary<K extends OpaqueHash, V> = HashDictionary<K, V>;
 declare const index$o_HashDictionary: typeof HashDictionary;
 type index$o_HashSet<V extends OpaqueHash> = HashSet<V>;
 declare const index$o_HashSet: typeof HashSet;
-type index$o_HashWithZeroedBit<T extends OpaqueHash> = HashWithZeroedBit<T>;
 type index$o_ImmutableHashDictionary<K extends OpaqueHash, V> = ImmutableHashDictionary<K, V>;
 type index$o_ImmutableHashSet<V extends OpaqueHash> = ImmutableHashSet<V>;
 type index$o_ImmutableSortedArray<V> = ImmutableSortedArray<V>;
 type index$o_ImmutableSortedSet<V> = ImmutableSortedSet<V>;
+type index$o_KeyChunk = KeyChunk;
 type index$o_KeyMapper<K> = KeyMapper<K>;
 type index$o_KeyMappers<TKeys extends readonly unknown[]> = KeyMappers<TKeys>;
 type index$o_KnownSize<T, F extends string> = KnownSize<T, F>;
 type index$o_KnownSizeArray<T, F extends string> = KnownSizeArray<T, F>;
 type index$o_KnownSizeId<X> = KnownSizeId<X>;
+type index$o_Leaf<K extends BytesBlob, V> = Leaf<K, V>;
+type index$o_ListChildren<K extends BytesBlob, V> = ListChildren<K, V>;
+declare const index$o_ListChildren: typeof ListChildren;
+type index$o_MapChildren<K extends BytesBlob, V> = MapChildren<K, V>;
+declare const index$o_MapChildren: typeof MapChildren;
+type index$o_MaybeNode<K extends BytesBlob, V> = MaybeNode<K, V>;
 type index$o_MultiMap<TKeys extends readonly unknown[], TValue> = MultiMap<TKeys, TValue>;
 declare const index$o_MultiMap: typeof MultiMap;
 type index$o_NestedMaps<TKeys extends readonly unknown[], TValue> = NestedMaps<TKeys, TValue>;
+type index$o_Node<K extends BytesBlob, V> = Node<K, V>;
+declare const index$o_Node: typeof Node;
+type index$o_OriginalKeyRef<K> = OriginalKeyRef<K>;
 type index$o_SortedArray<V> = SortedArray<V>;
 declare const index$o_SortedArray: typeof SortedArray;
 type index$o_SortedSet<V> = SortedSet<V>;
 declare const index$o_SortedSet: typeof SortedSet;
+type index$o_StringHashDictionary<K extends OpaqueHash, V> = StringHashDictionary<K, V>;
+declare const index$o_StringHashDictionary: typeof StringHashDictionary;
+type index$o_SubKey<_K extends BytesBlob> = SubKey<_K>;
 type index$o_TruncatedHashDictionary<T extends OpaqueHash, V> = TruncatedHashDictionary<T, V>;
 declare const index$o_TruncatedHashDictionary: typeof TruncatedHashDictionary;
+type index$o_U48 = U48;
 declare const index$o_asKnownSize: typeof asKnownSize;
+declare const index$o_bytesAsU48: typeof bytesAsU48;
+declare const index$o_getTruncatedKey: typeof getTruncatedKey;
 declare namespace index$o {
-  export { index$o_ArrayView as ArrayView, index$o_FixedSizeArray as FixedSizeArray, index$o_HashDictionary as HashDictionary, index$o_HashSet as HashSet, index$o_MultiMap as MultiMap, index$o_SortedArray as SortedArray, index$o_SortedSet as SortedSet, index$o_TruncatedHashDictionary as TruncatedHashDictionary, index$o_asKnownSize as asKnownSize };
-  export type { index$o_HashWithZeroedBit as HashWithZeroedBit, index$o_ImmutableHashDictionary as ImmutableHashDictionary, index$o_ImmutableHashSet as ImmutableHashSet, index$o_ImmutableSortedArray as ImmutableSortedArray, index$o_ImmutableSortedSet as ImmutableSortedSet, index$o_KeyMapper as KeyMapper, index$o_KeyMappers as KeyMappers, index$o_KnownSize as KnownSize, index$o_KnownSizeArray as KnownSizeArray, index$o_KnownSizeId as KnownSizeId, index$o_NestedMaps as NestedMaps };
+  export { index$o_ArrayView as ArrayView, index$o_BlobDictionary as BlobDictionary, index$o_FixedSizeArray as FixedSizeArray, index$o_HashDictionary as HashDictionary, index$o_HashSet as HashSet, index$o_ListChildren as ListChildren, index$o_MapChildren as MapChildren, index$o_MultiMap as MultiMap, index$o_Node as Node, index$o_SortedArray as SortedArray, index$o_SortedSet as SortedSet, index$o_StringHashDictionary as StringHashDictionary, index$o_TruncatedHashDictionary as TruncatedHashDictionary, index$o_asKnownSize as asKnownSize, index$o_bytesAsU48 as bytesAsU48, index$o_getTruncatedKey as getTruncatedKey };
+  export type { index$o_CHUNK_SIZE as CHUNK_SIZE, index$o_ImmutableHashDictionary as ImmutableHashDictionary, index$o_ImmutableHashSet as ImmutableHashSet, index$o_ImmutableSortedArray as ImmutableSortedArray, index$o_ImmutableSortedSet as ImmutableSortedSet, index$o_KeyChunk as KeyChunk, index$o_KeyMapper as KeyMapper, index$o_KeyMappers as KeyMappers, index$o_KnownSize as KnownSize, index$o_KnownSizeArray as KnownSizeArray, index$o_KnownSizeId as KnownSizeId, index$o_Leaf as Leaf, index$o_MaybeNode as MaybeNode, index$o_NestedMaps as NestedMaps, index$o_OriginalKeyRef as OriginalKeyRef, index$o_SubKey as SubKey, index$o_U48 as U48 };
 }
 
 declare namespace bandersnatch_d_exports {