@typeberry/lib 0.4.1-0a3acb2 → 0.4.1-9e565b9

package/index.d.ts

@@ -1008,7 +1008,7 @@ declare class BytesBlob {
    *
    * Last chunk might be smaller than `size`.
    */
-  *chunks(size: number): Generator<BytesBlob, undefined, void> {
+  *chunks(size: number): Generator<BytesBlob> {
     for (let i = 0; i < this.length; i += size) {
       yield BytesBlob.blobFrom(this.raw.subarray(i, i + size));
     }
@@ -3570,497 +3570,6 @@ 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;
 
@@ -4261,20 +3770,17 @@ interface ImmutableHashDictionary<K extends OpaqueHash, V> extends Iterable<[K,
   get(key: K): V | undefined;
 
   /** Iterator over keys of the dictionary. */
-  keys(): Iterator<K>;
+  keys(): Generator<K>;
 
   /** Iterator over values of the dictionary. */
-  values(): Iterator<V>;
+  values(): Generator<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.
- *
- * @deprecated
- * */
-declare class StringHashDictionary<K extends OpaqueHash, V> implements ImmutableHashDictionary<K, V> {
+
+/** A map which uses hashes as keys. */
+declare class HashDictionary<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.
@@ -4354,15 +3860,6 @@ declare class StringHashDictionary<K extends OpaqueHash, V> implements Immutable
   }
 }
 
-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. */
@@ -4954,14 +4451,7 @@ declare class SortedSet<V> extends SortedArray<V> implements ImmutableSortedSet<
   }
 }
 
-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);
-}
+type HashWithZeroedBit<T extends OpaqueHash> = T;
 
 /**
  * A collection of hash-based keys (likely `StateKey`s) which ignores
@@ -4976,18 +4466,22 @@ 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> {
-    return new TruncatedHashDictionary(
-      BlobDictionary.fromEntries<TruncatedHash, V>(
-        Array.from(entries).map(([key, value]) => [getTruncatedKey(key), value]),
-        BLOB_DICTIONARY_THRESHOLD,
-      ),
-    );
+    /** 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));
   }
 
-  private constructor(private readonly dict: BlobDictionary<TruncatedHash, V>) {}
+  /** 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>) {}
 
   [TEST_COMPARE_USING]() {
-    return Array.from(this.dict);
+    return this.dict;
   }
 
   /** Return number of items in the dictionary. */
@@ -4996,27 +4490,31 @@ declare class TruncatedHashDictionary<T extends OpaqueHash, V> {
   }
 
   /** Retrieve a value that matches the key on `TRUNCATED_HASH_SIZE`. */
-  get(key: T | TruncatedHash): V | undefined {
-    const truncatedKey = getTruncatedKey(key);
-    return this.dict.get(truncatedKey);
+  get(fullKey: T | TruncatedHash): V | undefined {
+    this.truncatedKey.raw.set(fullKey.raw.subarray(0, TRUNCATED_HASH_SIZE));
+    return this.dict.get(this.truncatedKey);
   }
 
   /** Return true if the key is present in the dictionary */
-  has(key: T | TruncatedHash): boolean {
-    const truncatedKey = getTruncatedKey(key);
-    return this.dict.has(truncatedKey);
+  has(fullKey: T | TruncatedHash): boolean {
+    this.truncatedKey.raw.set(fullKey.raw.subarray(0, TRUNCATED_HASH_SIZE));
+
+    return this.dict.has(this.truncatedKey);
   }
 
   /** Set or update a value that matches the key on `TRUNCATED_HASH_SIZE`. */
-  set(key: T | TruncatedHash, value: V) {
-    const truncatedKey = getTruncatedKey(key);
-    this.dict.set(truncatedKey, value);
+  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);
   }
 
   /** Remove a value that matches the key on `TRUNCATED_HASH_SIZE`. */
-  delete(key: T | TruncatedHash) {
-    const truncatedKey = getTruncatedKey(key);
-    this.dict.delete(truncatedKey);
+  delete(fullKey: T | TruncatedHash) {
+    this.truncatedKey.raw.set(fullKey.raw.subarray(0, TRUNCATED_HASH_SIZE));
+    this.dict.delete(this.truncatedKey);
   }
 
   /** Iterator over values of the dictionary. */
@@ -5026,7 +4524,9 @@ declare class TruncatedHashDictionary<T extends OpaqueHash, V> {
 
   /** Iterator over entries of the dictionary (with truncated keys) */
   *entries(): Generator<[TruncatedHash, V]> {
-    yield* this.dict.entries();
+    for (const [key, value] of this.dict.entries()) {
+      yield [Bytes.fromBlob(key.raw.subarray(0, TRUNCATED_HASH_SIZE), TRUNCATED_HASH_SIZE).asOpaque(), value];
+    }
   }
 
   [Symbol.iterator]() {
@@ -5036,53 +4536,35 @@ 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_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 };
+  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 };
 }
 
 declare namespace bandersnatch_d_exports {