@typeberry/lib 0.5.1-52ed6dc → 0.5.1-a175c9e

package/index.d.ts

@@ -75,72 +75,6 @@ declare const minU64: (a: U64, ...values: U64[]) => U64;
 /** Get the biggest value between U64 a and values given as input parameters. */
 declare const maxU64: (a: U64, ...values: U64[]) => U64;
 
-type index$B_FixedSizeNumber<Bytes extends number> = FixedSizeNumber<Bytes>;
-type index$B_U16 = U16;
-type index$B_U32 = U32;
-type index$B_U64 = U64;
-type index$B_U8 = U8;
-type index$B_WithBytesRepresentation<Bytes extends number> = WithBytesRepresentation<Bytes>;
-declare const index$B___REPRESENTATION_BYTES__: typeof __REPRESENTATION_BYTES__;
-declare const index$B_isU16: typeof isU16;
-declare const index$B_isU32: typeof isU32;
-declare const index$B_isU64: typeof isU64;
-declare const index$B_isU8: typeof isU8;
-declare const index$B_leBytesAsU32: typeof leBytesAsU32;
-declare const index$B_maxU64: typeof maxU64;
-declare const index$B_minU64: typeof minU64;
-declare const index$B_sumU32: typeof sumU32;
-declare const index$B_sumU64: typeof sumU64;
-declare const index$B_tryAsU16: typeof tryAsU16;
-declare const index$B_tryAsU32: typeof tryAsU32;
-declare const index$B_tryAsU64: typeof tryAsU64;
-declare const index$B_tryAsU8: typeof tryAsU8;
-declare const index$B_u32AsLeBytes: typeof u32AsLeBytes;
-declare const index$B_u64FromParts: typeof u64FromParts;
-declare const index$B_u64IntoParts: typeof u64IntoParts;
-declare namespace index$B {
-  export { index$B___REPRESENTATION_BYTES__ as __REPRESENTATION_BYTES__, index$B_isU16 as isU16, index$B_isU32 as isU32, index$B_isU64 as isU64, index$B_isU8 as isU8, index$B_leBytesAsU32 as leBytesAsU32, index$B_maxU64 as maxU64, index$B_minU64 as minU64, index$B_sumU32 as sumU32, index$B_sumU64 as sumU64, index$B_tryAsU16 as tryAsU16, index$B_tryAsU32 as tryAsU32, index$B_tryAsU64 as tryAsU64, index$B_tryAsU8 as tryAsU8, index$B_u32AsLeBytes as u32AsLeBytes, index$B_u64FromParts as u64FromParts, index$B_u64IntoParts as u64IntoParts };
-  export type { index$B_FixedSizeNumber as FixedSizeNumber, Result$1 as Result, index$B_U16 as U16, index$B_U32 as U32, index$B_U64 as U64, index$B_U8 as U8, index$B_WithBytesRepresentation as WithBytesRepresentation };
-}
-
-/** A return value of some comparator. */
-declare enum OrderingValue {
-    /** `self < other` */
-    Less = -1,
-    /** `self === other` */
-    Equal = 0,
-    /** `self > other` */
-    Greater = 1
-}
-/** A class that provides utility methods to check the type of ordering. */
-declare class Ordering {
-    readonly value: OrderingValue;
-    private constructor();
-    static Less: Ordering;
-    static Greater: Ordering;
-    static Equal: Ordering;
-    isLess(): boolean;
-    isGreater(): boolean;
-    isEqual(): boolean;
-    isNotEqual(): boolean;
-    isGreaterOrEqual(): boolean;
-    isLessOrEqual(): boolean;
-}
-/**
- * A type that compares the `self` value to `other` and returns an ordering in respect to `self`.
- *
- * e.g. `self < other => Ordering.Less`, `self > other => Ordering.Greater`
- */
-type Comparator<V> = (self: V, other: V) => Ordering;
-
-type index$A_Comparator<V> = Comparator<V>;
-type index$A_Ordering = Ordering;
-declare const index$A_Ordering: typeof Ordering;
-declare namespace index$A {
-  export { index$A_Ordering as Ordering };
-  export type { index$A_Comparator as Comparator };
-}
-
 declare enum GpVersion {
     V0_7_0 = "0.7.0",
     V0_7_1 = "0.7.1",
@@ -360,64 +294,35 @@ declare class ErrorsCollector {
     exitOrThrow(): this;
 }
 
-/**
- * Utilities that are widely used across typeberry.
- *
- * BIG FAT NOTE: Please think twice or thrice before adding something here.
- * The package should really contain only things that are pretty much essential
- * and used everywhere.
- *
- * It might be much better to create a small package just for the thing you
- * are thinking about adding here. It's easier to later consolide smaller
- * things into this `utils` package than to split it into separate parts
- * as an afterthought.
- */
-
-declare const index$z_CURRENT_SUITE: typeof CURRENT_SUITE;
-declare const index$z_CURRENT_VERSION: typeof CURRENT_VERSION;
-type index$z_Compatibility = Compatibility;
-declare const index$z_Compatibility: typeof Compatibility;
-declare const index$z_DEFAULT_SUITE: typeof DEFAULT_SUITE;
-declare const index$z_DEFAULT_VERSION: typeof DEFAULT_VERSION;
-type index$z_DeepEqualOptions = DeepEqualOptions;
-type index$z_ErrorResult<Error> = ErrorResult<Error>;
-type index$z_ErrorsCollector = ErrorsCollector;
-declare const index$z_ErrorsCollector: typeof ErrorsCollector;
-type index$z_GpVersion = GpVersion;
-declare const index$z_GpVersion: typeof GpVersion;
-declare const index$z_MAX_LENGTH: typeof MAX_LENGTH;
-type index$z_OK = OK;
-type index$z_OkResult<Ok> = OkResult<Ok>;
-type index$z_Opaque<Type, Token extends string> = Opaque<Type, Token>;
-declare const index$z_Result: typeof Result;
-declare const index$z_TEST_COMPARE_USING: typeof TEST_COMPARE_USING;
-type index$z_TaggedError<Kind, Nested> = TaggedError<Kind, Nested>;
-type index$z_TestSuite = TestSuite;
-declare const index$z_TestSuite: typeof TestSuite;
-type index$z_TokenOf<OpaqueType, Type> = TokenOf<OpaqueType, Type>;
-type index$z_WithDebug = WithDebug;
-declare const index$z_WithDebug: typeof WithDebug;
-type index$z_WithOpaque<Token extends string> = WithOpaque<Token>;
-declare const index$z___OPAQUE_TYPE__: typeof __OPAQUE_TYPE__;
-declare const index$z_asOpaqueType: typeof asOpaqueType;
-declare const index$z_assertEmpty: typeof assertEmpty;
-declare const index$z_assertNever: typeof assertNever;
-declare const index$z_check: typeof check;
-declare const index$z_deepEqual: typeof deepEqual;
-declare const index$z_env: typeof env;
-declare const index$z_inspect: typeof inspect;
-declare const index$z_isBrowser: typeof isBrowser;
-declare const index$z_lazyInspect: typeof lazyInspect;
-declare const index$z_measure: typeof measure;
-declare const index$z_now: typeof now;
-declare const index$z_resultToString: typeof resultToString;
-declare const index$z_safeAllocUint8Array: typeof safeAllocUint8Array;
-declare const index$z_seeThrough: typeof seeThrough;
-declare const index$z_workspacePathFix: typeof workspacePathFix;
-declare namespace index$z {
-  export { index$z_CURRENT_SUITE as CURRENT_SUITE, index$z_CURRENT_VERSION as CURRENT_VERSION, index$z_Compatibility as Compatibility, index$z_DEFAULT_SUITE as DEFAULT_SUITE, index$z_DEFAULT_VERSION as DEFAULT_VERSION, index$z_ErrorsCollector as ErrorsCollector, index$z_GpVersion as GpVersion, index$z_MAX_LENGTH as MAX_LENGTH, index$z_Result as Result, index$z_TEST_COMPARE_USING as TEST_COMPARE_USING, index$z_TestSuite as TestSuite, index$z_WithDebug as WithDebug, index$z___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$z_asOpaqueType as asOpaqueType, index$z_assertEmpty as assertEmpty, index$z_assertNever as assertNever, index$z_check as check, index$z_deepEqual as deepEqual, index$z_env as env, index$z_inspect as inspect, index$z_isBrowser as isBrowser, index$z_lazyInspect as lazyInspect, index$z_measure as measure, index$z_now as now, index$z_resultToString as resultToString, index$z_safeAllocUint8Array as safeAllocUint8Array, index$z_seeThrough as seeThrough, index$z_workspacePathFix as workspacePathFix };
-  export type { index$z_DeepEqualOptions as DeepEqualOptions, index$z_ErrorResult as ErrorResult, index$z_OK as OK, index$z_OkResult as OkResult, index$z_Opaque as Opaque, index$z_TaggedError as TaggedError, index$z_TokenOf as TokenOf, index$z_WithOpaque as WithOpaque };
+/** A return value of some comparator. */
+declare enum OrderingValue {
+    /** `self < other` */
+    Less = -1,
+    /** `self === other` */
+    Equal = 0,
+    /** `self > other` */
+    Greater = 1
 }
+/** A class that provides utility methods to check the type of ordering. */
+declare class Ordering {
+    readonly value: OrderingValue;
+    private constructor();
+    static Less: Ordering;
+    static Greater: Ordering;
+    static Equal: Ordering;
+    isLess(): boolean;
+    isGreater(): boolean;
+    isEqual(): boolean;
+    isNotEqual(): boolean;
+    isGreaterOrEqual(): boolean;
+    isLessOrEqual(): boolean;
+}
+/**
+ * A type that compares the `self` value to `other` and returns an ordering in respect to `self`.
+ *
+ * e.g. `self < other => Ordering.Less`, `self > other => Ordering.Greater`
+ */
+type Comparator<V> = (self: V, other: V) => Ordering;
 
 /**
  * A variable-length blob of bytes with a concise text representation.
@@ -528,22 +433,6 @@ declare class BitVec {
     indicesOfSetBits(): Generator<number, void, unknown>;
 }
 
-type index$y_BitVec = BitVec;
-declare const index$y_BitVec: typeof BitVec;
-type index$y_Bytes<T extends number> = Bytes<T>;
-declare const index$y_Bytes: typeof Bytes;
-type index$y_BytesBlob = BytesBlob;
-declare const index$y_BytesBlob: typeof BytesBlob;
-declare const index$y_bytesBlobComparator: typeof bytesBlobComparator;
-declare namespace index$y {
-  export {
-    index$y_BitVec as BitVec,
-    index$y_Bytes as Bytes,
-    index$y_BytesBlob as BytesBlob,
-    index$y_bytesBlobComparator as bytesBlobComparator,
-  };
-}
-
 /** A decoder for some specific type `T` */
 type Decode<T> = {
     /** Decode object of type `T`. */
@@ -1148,7 +1037,7 @@ declare const TYPICAL_DICTIONARY_LENGTH = 32;
  */
 declare function readonlyArray<T, V>(desc: Descriptor<T[], V>): Descriptor<readonly T[], V>;
 /** Fixed-length bytes sequence. */
-declare const bytes: <N extends number>(len: N) => Descriptor<Bytes<N>>;
+declare const bytes$1: <N extends number>(len: N) => Descriptor<Bytes<N>>;
 /** Zero-size `void` value. */
 declare const nothing: Descriptor<void, void>;
 /** Variable-length U32. */
@@ -1254,7 +1143,6 @@ declare const descriptors_bitVecFixLen: typeof bitVecFixLen;
 declare const descriptors_bitVecVarLen: typeof bitVecVarLen;
 declare const descriptors_blob: typeof blob;
 declare const descriptors_bool: typeof bool;
-declare const descriptors_bytes: typeof bytes;
 declare const descriptors_custom: typeof custom;
 declare const descriptors_dictionary: typeof dictionary;
 declare const descriptors_forEachDescriptor: typeof forEachDescriptor;
@@ -1281,82 +1169,11 @@ declare const descriptors_union: typeof union;
 declare const descriptors_varU32: typeof varU32;
 declare const descriptors_varU64: typeof varU64;
 declare namespace descriptors {
-  export { descriptors_Class as Class, descriptors_TYPICAL_DICTIONARY_LENGTH as TYPICAL_DICTIONARY_LENGTH, descriptors_bitVecFixLen as bitVecFixLen, descriptors_bitVecVarLen as bitVecVarLen, descriptors_blob as blob, descriptors_bool as bool, descriptors_bytes as bytes, descriptors_custom as custom, descriptors_dictionary as dictionary, descriptors_forEachDescriptor as forEachDescriptor, descriptors_i16 as i16, descriptors_i24 as i24, descriptors_i32 as i32, descriptors_i64 as i64, descriptors_i8 as i8, descriptors_nothing as nothing, descriptors_object as object, descriptors_optional as optional, descriptors_pair as pair, descriptors_readonlyArray as readonlyArray, descriptors_select as select, descriptors_sequenceFixLen as sequenceFixLen, descriptors_sequenceVarLen as sequenceVarLen, descriptors_string as string, descriptors_u16 as u16, descriptors_u24 as u24, descriptors_u32 as u32, descriptors_u64 as u64, descriptors_u8 as u8, descriptors_union as union, descriptors_varU32 as varU32, descriptors_varU64 as varU64 };
+  export { descriptors_Class as Class, descriptors_TYPICAL_DICTIONARY_LENGTH as TYPICAL_DICTIONARY_LENGTH, descriptors_bitVecFixLen as bitVecFixLen, descriptors_bitVecVarLen as bitVecVarLen, descriptors_blob as blob, descriptors_bool as bool, bytes$1 as bytes, descriptors_custom as custom, descriptors_dictionary as dictionary, descriptors_forEachDescriptor as forEachDescriptor, descriptors_i16 as i16, descriptors_i24 as i24, descriptors_i32 as i32, descriptors_i64 as i64, descriptors_i8 as i8, descriptors_nothing as nothing, descriptors_object as object, descriptors_optional as optional, descriptors_pair as pair, descriptors_readonlyArray as readonlyArray, descriptors_select as select, descriptors_sequenceFixLen as sequenceFixLen, descriptors_sequenceVarLen as sequenceVarLen, descriptors_string as string, descriptors_u16 as u16, descriptors_u24 as u24, descriptors_u32 as u32, descriptors_u64 as u64, descriptors_u8 as u8, descriptors_union as union, descriptors_varU32 as varU32, descriptors_varU64 as varU64 };
   export type { descriptors_SequenceVarLenOptions as SequenceVarLenOptions };
 }
 
-declare const codec: typeof descriptors;
-
-declare const index$x_Class: typeof Class;
-type index$x_ClassConstructor<T> = ClassConstructor<T>;
-type index$x_Codec<T> = Codec<T>;
-type index$x_CodecRecord<T> = CodecRecord<T>;
-type index$x_CodecWithView<T, V> = CodecWithView<T, V>;
-type index$x_Decode<T> = Decode<T>;
-type index$x_Decoder = Decoder;
-declare const index$x_Decoder: typeof Decoder;
-type index$x_DescribedBy<T> = DescribedBy<T>;
-type index$x_Descriptor<T, V = T> = Descriptor<T, V>;
-declare const index$x_Descriptor: typeof Descriptor;
-type index$x_DescriptorRecord<T> = DescriptorRecord<T>;
-type index$x_Encode<T> = Encode<T>;
-type index$x_Encoder = Encoder;
-declare const index$x_Encoder: typeof Encoder;
-type index$x_EndOfDataError = EndOfDataError;
-declare const index$x_EndOfDataError: typeof EndOfDataError;
-type index$x_LengthRange = LengthRange;
-type index$x_ObjectView<T> = ObjectView<T>;
-declare const index$x_ObjectView: typeof ObjectView;
-type index$x_OptionalRecord<T> = OptionalRecord<T>;
-type index$x_PropertyKeys<T> = PropertyKeys<T>;
-type index$x_SequenceVarLenOptions = SequenceVarLenOptions;
-type index$x_SequenceView<T, V = T> = SequenceView<T, V>;
-declare const index$x_SequenceView: typeof SequenceView;
-type index$x_SimpleDescriptorRecord<T> = SimpleDescriptorRecord<T>;
-type index$x_SizeHint = SizeHint;
-declare const index$x_TYPICAL_DICTIONARY_LENGTH: typeof TYPICAL_DICTIONARY_LENGTH;
-type index$x_ViewField<T, V> = ViewField<T, V>;
-declare const index$x_ViewField: typeof ViewField;
-type index$x_ViewOf<T, D extends DescriptorRecord<T>> = ViewOf<T, D>;
-declare const index$x_addSizeHints: typeof addSizeHints;
-declare const index$x_bitVecFixLen: typeof bitVecFixLen;
-declare const index$x_bitVecVarLen: typeof bitVecVarLen;
-declare const index$x_blob: typeof blob;
-declare const index$x_bool: typeof bool;
-declare const index$x_bytes: typeof bytes;
-declare const index$x_codec: typeof codec;
-declare const index$x_custom: typeof custom;
-declare const index$x_decodeVariableLengthExtraBytes: typeof decodeVariableLengthExtraBytes;
-declare const index$x_dictionary: typeof dictionary;
-declare const index$x_forEachDescriptor: typeof forEachDescriptor;
-declare const index$x_i16: typeof i16;
-declare const index$x_i24: typeof i24;
-declare const index$x_i32: typeof i32;
-declare const index$x_i64: typeof i64;
-declare const index$x_i8: typeof i8;
-declare const index$x_nothing: typeof nothing;
-declare const index$x_object: typeof object;
-declare const index$x_optional: typeof optional;
-declare const index$x_pair: typeof pair;
-declare const index$x_readonlyArray: typeof readonlyArray;
-declare const index$x_select: typeof select;
-declare const index$x_sequenceFixLen: typeof sequenceFixLen;
-declare const index$x_sequenceVarLen: typeof sequenceVarLen;
-declare const index$x_string: typeof string;
-declare const index$x_tryAsExactBytes: typeof tryAsExactBytes;
-declare const index$x_u16: typeof u16;
-declare const index$x_u24: typeof u24;
-declare const index$x_u32: typeof u32;
-declare const index$x_u64: typeof u64;
-declare const index$x_u8: typeof u8;
-declare const index$x_union: typeof union;
-declare const index$x_validateLength: typeof validateLength;
-declare const index$x_varU32: typeof varU32;
-declare const index$x_varU64: typeof varU64;
-declare namespace index$x {
-  export { index$x_Class as Class, index$x_Decoder as Decoder, index$x_Descriptor as Descriptor, index$x_Encoder as Encoder, index$x_EndOfDataError as EndOfDataError, index$x_ObjectView as ObjectView, index$x_SequenceView as SequenceView, index$x_TYPICAL_DICTIONARY_LENGTH as TYPICAL_DICTIONARY_LENGTH, index$x_ViewField as ViewField, index$x_addSizeHints as addSizeHints, index$x_bitVecFixLen as bitVecFixLen, index$x_bitVecVarLen as bitVecVarLen, index$x_blob as blob, index$x_bool as bool, index$x_bytes as bytes, index$x_codec as codec, index$x_custom as custom, index$x_decodeVariableLengthExtraBytes as decodeVariableLengthExtraBytes, index$x_dictionary as dictionary, index$x_forEachDescriptor as forEachDescriptor, index$x_i16 as i16, index$x_i24 as i24, index$x_i32 as i32, index$x_i64 as i64, index$x_i8 as i8, index$x_nothing as nothing, index$x_object as object, index$x_optional as optional, index$x_pair as pair, index$x_readonlyArray as readonlyArray, index$x_select as select, index$x_sequenceFixLen as sequenceFixLen, index$x_sequenceVarLen as sequenceVarLen, index$x_string as string, index$x_tryAsExactBytes as tryAsExactBytes, index$x_u16 as u16, index$x_u24 as u24, index$x_u32 as u32, index$x_u64 as u64, index$x_u8 as u8, index$x_union as union, index$x_validateLength as validateLength, index$x_varU32 as varU32, index$x_varU64 as varU64 };
-  export type { index$x_ClassConstructor as ClassConstructor, index$x_Codec as Codec, index$x_CodecRecord as CodecRecord, index$x_CodecWithView as CodecWithView, index$x_Decode as Decode, index$x_DescribedBy as DescribedBy, index$x_DescriptorRecord as DescriptorRecord, index$x_Encode as Encode, index$x_LengthRange as LengthRange, index$x_OptionalRecord as OptionalRecord, Options$1 as Options, index$x_PropertyKeys as PropertyKeys, index$x_SequenceVarLenOptions as SequenceVarLenOptions, index$x_SimpleDescriptorRecord as SimpleDescriptorRecord, index$x_SizeHint as SizeHint, index$x_ViewOf as ViewOf };
-}
+declare const codec$1: typeof descriptors;
 
 /**
  * A utility class providing a readonly view over a portion of an array without copying it.
@@ -1702,25 +1519,6 @@ declare namespace keccak {
   };
 }
 
-type index$w_Blake2b = Blake2b;
-declare const index$w_Blake2b: typeof Blake2b;
-type index$w_Blake2bHash = Blake2bHash;
-type index$w_HASH_SIZE = HASH_SIZE;
-type index$w_KeccakHash = KeccakHash;
-type index$w_OpaqueHash = OpaqueHash;
-type index$w_TRUNCATED_HASH_SIZE = TRUNCATED_HASH_SIZE;
-type index$w_TruncatedHash = TruncatedHash;
-type index$w_WithHash<THash extends OpaqueHash, TData> = WithHash<THash, TData>;
-declare const index$w_WithHash: typeof WithHash;
-type index$w_WithHashAndBytes<THash extends OpaqueHash, TData> = WithHashAndBytes<THash, TData>;
-declare const index$w_WithHashAndBytes: typeof WithHashAndBytes;
-declare const index$w_ZERO_HASH: typeof ZERO_HASH;
-declare const index$w_keccak: typeof keccak;
-declare namespace index$w {
-  export { index$w_Blake2b as Blake2b, index$w_WithHash as WithHash, index$w_WithHashAndBytes as WithHashAndBytes, index$w_ZERO_HASH as ZERO_HASH, index$w_keccak as keccak };
-  export type { index$w_Blake2bHash as Blake2bHash, index$w_HASH_SIZE as HASH_SIZE, index$w_KeccakHash as KeccakHash, index$w_OpaqueHash as OpaqueHash, index$w_TRUNCATED_HASH_SIZE as TRUNCATED_HASH_SIZE, index$w_TruncatedHash as TruncatedHash };
-}
-
 /** Immutable view of the `HashDictionary`. */
 interface ImmutableHashDictionary<K extends OpaqueHash, V> extends Iterable<[K, V]> {
     /** Return number of items in the dictionary. */
@@ -2021,43 +1819,6 @@ declare class TruncatedHashDictionary<T extends OpaqueHash, V> {
     [Symbol.iterator](): Generator<[TruncatedHash, V], any, any>;
 }
 
-type index$v_ArrayView<T> = ArrayView<T>;
-declare const index$v_ArrayView: typeof ArrayView;
-type index$v_BlobDictionary<K extends BytesBlob, V> = BlobDictionary<K, V>;
-declare const index$v_BlobDictionary: typeof BlobDictionary;
-type index$v_FixedSizeArray<T, N extends number> = FixedSizeArray<T, N>;
-declare const index$v_FixedSizeArray: typeof FixedSizeArray;
-type index$v_HashDictionary<K extends OpaqueHash, V> = HashDictionary<K, V>;
-declare const index$v_HashDictionary: typeof HashDictionary;
-type index$v_HashSet<V extends OpaqueHash> = HashSet<V>;
-declare const index$v_HashSet: typeof HashSet;
-type index$v_ImmutableHashDictionary<K extends OpaqueHash, V> = ImmutableHashDictionary<K, V>;
-type index$v_ImmutableHashSet<V extends OpaqueHash> = ImmutableHashSet<V>;
-type index$v_ImmutableSortedArray<V> = ImmutableSortedArray<V>;
-type index$v_ImmutableSortedSet<V> = ImmutableSortedSet<V>;
-type index$v_KeyMapper<K> = KeyMapper<K>;
-type index$v_KnownSize<T, F extends string> = KnownSize<T, F>;
-type index$v_KnownSizeArray<T, F extends string> = KnownSizeArray<T, F>;
-type index$v_KnownSizeId<X> = KnownSizeId<X>;
-type index$v_ListChildren<K extends BytesBlob, V> = ListChildren<K, V>;
-declare const index$v_ListChildren: typeof ListChildren;
-type index$v_MultiMap<TKeys extends readonly unknown[], TValue> = MultiMap<TKeys, TValue>;
-declare const index$v_MultiMap: typeof MultiMap;
-type index$v_SortedArray<V> = SortedArray<V>;
-declare const index$v_SortedArray: typeof SortedArray;
-type index$v_SortedSet<V> = SortedSet<V>;
-declare const index$v_SortedSet: typeof SortedSet;
-type index$v_StringHashDictionary<K extends OpaqueHash, V> = StringHashDictionary<K, V>;
-declare const index$v_StringHashDictionary: typeof StringHashDictionary;
-type index$v_TruncatedHashDictionary<T extends OpaqueHash, V> = TruncatedHashDictionary<T, V>;
-declare const index$v_TruncatedHashDictionary: typeof TruncatedHashDictionary;
-declare const index$v_asKnownSize: typeof asKnownSize;
-declare const index$v_bytesAsU48: typeof bytesAsU48;
-declare namespace index$v {
-  export { index$v_ArrayView as ArrayView, index$v_BlobDictionary as BlobDictionary, index$v_FixedSizeArray as FixedSizeArray, index$v_HashDictionary as HashDictionary, index$v_HashSet as HashSet, index$v_ListChildren as ListChildren, index$v_MultiMap as MultiMap, index$v_SortedArray as SortedArray, index$v_SortedSet as SortedSet, index$v_StringHashDictionary as StringHashDictionary, index$v_TruncatedHashDictionary as TruncatedHashDictionary, index$v_asKnownSize as asKnownSize, index$v_bytesAsU48 as bytesAsU48 };
-  export type { index$v_ImmutableHashDictionary as ImmutableHashDictionary, index$v_ImmutableHashSet as ImmutableHashSet, index$v_ImmutableSortedArray as ImmutableSortedArray, index$v_ImmutableSortedSet as ImmutableSortedSet, index$v_KeyMapper as KeyMapper, index$v_KnownSize as KnownSize, index$v_KnownSizeArray as KnownSizeArray, index$v_KnownSizeId as KnownSizeId };
-}
-
 declare namespace bandersnatch_d_exports {
   export { batch_verify_tickets, __wbg_init$2 as default, derive_public_key, generate_seal, initSync$2 as initSync, ring_commitment, verify_seal, vrf_output_hash };
   export type { InitInput$2 as InitInput, InitOutput$2 as InitOutput, SyncInitInput$2 as SyncInitInput };
@@ -2363,34 +2124,6 @@ declare namespace keyDerivation {
   export type { keyDerivation_BandersnatchSecretSeed as BandersnatchSecretSeed, keyDerivation_Ed25519SecretSeed as Ed25519SecretSeed, keyDerivation_KeySeed as KeySeed, keyDerivation_SEED_SIZE as SEED_SIZE };
 }
 
-type index$u_BANDERSNATCH_KEY_BYTES = BANDERSNATCH_KEY_BYTES;
-type index$u_BANDERSNATCH_PROOF_BYTES = BANDERSNATCH_PROOF_BYTES;
-type index$u_BANDERSNATCH_RING_ROOT_BYTES = BANDERSNATCH_RING_ROOT_BYTES;
-type index$u_BANDERSNATCH_VRF_SIGNATURE_BYTES = BANDERSNATCH_VRF_SIGNATURE_BYTES;
-type index$u_BLS_KEY_BYTES = BLS_KEY_BYTES;
-type index$u_BandersnatchKey = BandersnatchKey;
-type index$u_BandersnatchProof = BandersnatchProof;
-type index$u_BandersnatchRingRoot = BandersnatchRingRoot;
-type index$u_BandersnatchSecretSeed = BandersnatchSecretSeed;
-type index$u_BandersnatchVrfSignature = BandersnatchVrfSignature;
-type index$u_BlsKey = BlsKey;
-type index$u_ED25519_KEY_BYTES = ED25519_KEY_BYTES;
-type index$u_ED25519_PRIV_KEY_BYTES = ED25519_PRIV_KEY_BYTES;
-type index$u_ED25519_SIGNATURE_BYTES = ED25519_SIGNATURE_BYTES;
-type index$u_Ed25519Key = Ed25519Key;
-type index$u_Ed25519Pair = Ed25519Pair;
-declare const index$u_Ed25519Pair: typeof Ed25519Pair;
-type index$u_Ed25519SecretSeed = Ed25519SecretSeed;
-type index$u_Ed25519Signature = Ed25519Signature;
-type index$u_SEED_SIZE = SEED_SIZE;
-declare const index$u_bandersnatch: typeof bandersnatch;
-declare const index$u_ed25519: typeof ed25519;
-declare const index$u_keyDerivation: typeof keyDerivation;
-declare namespace index$u {
-  export { index$u_Ed25519Pair as Ed25519Pair, index$u_bandersnatch as bandersnatch, bandersnatch_d_exports as bandersnatchWasm, index$u_ed25519 as ed25519, initAll as initWasm, index$u_keyDerivation as keyDerivation };
-  export type { index$u_BANDERSNATCH_KEY_BYTES as BANDERSNATCH_KEY_BYTES, index$u_BANDERSNATCH_PROOF_BYTES as BANDERSNATCH_PROOF_BYTES, index$u_BANDERSNATCH_RING_ROOT_BYTES as BANDERSNATCH_RING_ROOT_BYTES, index$u_BANDERSNATCH_VRF_SIGNATURE_BYTES as BANDERSNATCH_VRF_SIGNATURE_BYTES, index$u_BLS_KEY_BYTES as BLS_KEY_BYTES, index$u_BandersnatchKey as BandersnatchKey, index$u_BandersnatchProof as BandersnatchProof, index$u_BandersnatchRingRoot as BandersnatchRingRoot, index$u_BandersnatchSecretSeed as BandersnatchSecretSeed, index$u_BandersnatchVrfSignature as BandersnatchVrfSignature, index$u_BlsKey as BlsKey, index$u_ED25519_KEY_BYTES as ED25519_KEY_BYTES, index$u_ED25519_PRIV_KEY_BYTES as ED25519_PRIV_KEY_BYTES, index$u_ED25519_SIGNATURE_BYTES as ED25519_SIGNATURE_BYTES, index$u_Ed25519Key as Ed25519Key, index$u_Ed25519SecretSeed as Ed25519SecretSeed, index$u_Ed25519Signature as Ed25519Signature, KeySeed as PublicKeySeed, index$u_SEED_SIZE as SEED_SIZE };
-}
-
 /**
  * Estimated number of validators.
  *
@@ -2517,27 +2250,6 @@ declare enum PvmBackend {
     Ananas = 1
 }
 
-type index$t_Bootnode = Bootnode;
-declare const index$t_Bootnode: typeof Bootnode;
-type index$t_ChainSpec = ChainSpec;
-declare const index$t_ChainSpec: typeof ChainSpec;
-declare const index$t_EC_SEGMENT_SIZE: typeof EC_SEGMENT_SIZE;
-declare const index$t_EST_CORES: typeof EST_CORES;
-declare const index$t_EST_EPOCH_LENGTH: typeof EST_EPOCH_LENGTH;
-declare const index$t_EST_VALIDATORS: typeof EST_VALIDATORS;
-declare const index$t_EST_VALIDATORS_SUPER_MAJORITY: typeof EST_VALIDATORS_SUPER_MAJORITY;
-type index$t_PeerAddress = PeerAddress;
-type index$t_PeerId = PeerId;
-type index$t_PvmBackend = PvmBackend;
-declare const index$t_PvmBackend: typeof PvmBackend;
-declare const index$t_PvmBackendNames: typeof PvmBackendNames;
-declare const index$t_fullChainSpec: typeof fullChainSpec;
-declare const index$t_tinyChainSpec: typeof tinyChainSpec;
-declare namespace index$t {
-  export { index$t_Bootnode as Bootnode, index$t_ChainSpec as ChainSpec, index$t_EC_SEGMENT_SIZE as EC_SEGMENT_SIZE, index$t_EST_CORES as EST_CORES, index$t_EST_EPOCH_LENGTH as EST_EPOCH_LENGTH, index$t_EST_VALIDATORS as EST_VALIDATORS, index$t_EST_VALIDATORS_SUPER_MAJORITY as EST_VALIDATORS_SUPER_MAJORITY, index$t_PvmBackend as PvmBackend, index$t_PvmBackendNames as PvmBackendNames, index$t_fullChainSpec as fullChainSpec, index$t_tinyChainSpec as tinyChainSpec };
-  export type { index$t_PeerAddress as PeerAddress, index$t_PeerId as PeerId };
-}
-
 /**
  * Time slot index.
  *
@@ -4230,72 +3942,81 @@ declare namespace codecUtils {
  */
 declare function reencodeAsView<T, V>(codec: Descriptor<T, V>, object: T, chainSpec?: ChainSpec): V;
 
-type index$s_Block = Block;
-declare const index$s_Block: typeof Block;
-type index$s_BlockView = BlockView;
-type index$s_CodeHash = CodeHash;
-type index$s_CoreIndex = CoreIndex;
-type index$s_EntropyHash = EntropyHash;
-type index$s_Epoch = Epoch;
-type index$s_EpochMarker = EpochMarker;
-declare const index$s_EpochMarker: typeof EpochMarker;
-type index$s_EpochMarkerView = EpochMarkerView;
-type index$s_Extrinsic = Extrinsic;
-declare const index$s_Extrinsic: typeof Extrinsic;
-type index$s_ExtrinsicHash = ExtrinsicHash;
-type index$s_ExtrinsicView = ExtrinsicView;
-type index$s_Header = Header;
-declare const index$s_Header: typeof Header;
-type index$s_HeaderHash = HeaderHash;
-type index$s_HeaderView = HeaderView;
-declare const index$s_MAX_NUMBER_OF_SEGMENTS: typeof MAX_NUMBER_OF_SEGMENTS;
-type index$s_PerEpochBlock<T> = PerEpochBlock<T>;
-type index$s_PerValidator<T> = PerValidator<T>;
-type index$s_SEGMENT_BYTES = SEGMENT_BYTES;
-type index$s_Segment = Segment;
-type index$s_SegmentIndex = SegmentIndex;
-type index$s_ServiceGas = ServiceGas;
-type index$s_ServiceId = ServiceId;
-type index$s_StateRootHash = StateRootHash;
-type index$s_TicketsMarker = TicketsMarker;
-declare const index$s_TicketsMarker: typeof TicketsMarker;
-type index$s_TicketsMarkerView = TicketsMarkerView;
-type index$s_TimeSlot = TimeSlot;
-type index$s_ValidatorIndex = ValidatorIndex;
-type index$s_ValidatorKeys = ValidatorKeys;
-declare const index$s_ValidatorKeys: typeof ValidatorKeys;
-declare const index$s_W_E: typeof W_E;
-declare const index$s_W_S: typeof W_S;
-type index$s_WorkReportHash = WorkReportHash;
-declare const index$s_assurances: typeof assurances;
-declare const index$s_codecPerEpochBlock: typeof codecPerEpochBlock;
-declare const index$s_codecPerValidator: typeof codecPerValidator;
-declare const index$s_codecUtils: typeof codecUtils;
-declare const index$s_disputes: typeof disputes;
-declare const index$s_emptyBlock: typeof emptyBlock;
-declare const index$s_encodeUnsealedHeader: typeof encodeUnsealedHeader;
-declare const index$s_guarantees: typeof guarantees;
-declare const index$s_headerViewWithHashCodec: typeof headerViewWithHashCodec;
-declare const index$s_preimage: typeof preimage;
-declare const index$s_reencodeAsView: typeof reencodeAsView;
-declare const index$s_refineContext: typeof refineContext;
-declare const index$s_tickets: typeof tickets;
-declare const index$s_tryAsCoreIndex: typeof tryAsCoreIndex;
-declare const index$s_tryAsEpoch: typeof tryAsEpoch;
-declare const index$s_tryAsPerEpochBlock: typeof tryAsPerEpochBlock;
-declare const index$s_tryAsPerValidator: typeof tryAsPerValidator;
-declare const index$s_tryAsSegmentIndex: typeof tryAsSegmentIndex;
-declare const index$s_tryAsServiceGas: typeof tryAsServiceGas;
-declare const index$s_tryAsServiceId: typeof tryAsServiceId;
-declare const index$s_tryAsTimeSlot: typeof tryAsTimeSlot;
-declare const index$s_tryAsValidatorIndex: typeof tryAsValidatorIndex;
-declare const index$s_workItem: typeof workItem;
-declare const index$s_workPackage: typeof workPackage;
-declare const index$s_workReport: typeof workReport;
-declare const index$s_workResult: typeof workResult;
-declare namespace index$s {
-  export { index$s_Block as Block, index$s_EpochMarker as EpochMarker, index$s_Extrinsic as Extrinsic, index$s_Header as Header, index$s_MAX_NUMBER_OF_SEGMENTS as MAX_NUMBER_OF_SEGMENTS, index$s_TicketsMarker as TicketsMarker, index$s_ValidatorKeys as ValidatorKeys, index$s_W_E as W_E, index$s_W_S as W_S, index$s_assurances as assurances, index$s_codecPerEpochBlock as codecPerEpochBlock, index$s_codecPerValidator as codecPerValidator, index$s_codecUtils as codecUtils, index$s_disputes as disputes, index$s_emptyBlock as emptyBlock, index$s_encodeUnsealedHeader as encodeUnsealedHeader, index$s_guarantees as guarantees, index$s_headerViewWithHashCodec as headerViewWithHashCodec, index$s_preimage as preimage, index$s_reencodeAsView as reencodeAsView, index$s_refineContext as refineContext, index$s_tickets as tickets, index$s_tryAsCoreIndex as tryAsCoreIndex, index$s_tryAsEpoch as tryAsEpoch, index$s_tryAsPerEpochBlock as tryAsPerEpochBlock, index$s_tryAsPerValidator as tryAsPerValidator, index$s_tryAsSegmentIndex as tryAsSegmentIndex, index$s_tryAsServiceGas as tryAsServiceGas, index$s_tryAsServiceId as tryAsServiceId, index$s_tryAsTimeSlot as tryAsTimeSlot, index$s_tryAsValidatorIndex as tryAsValidatorIndex, index$s_workItem as workItem, index$s_workPackage as workPackage, index$s_workReport as workReport, index$s_workResult as workResult };
-  export type { index$s_BlockView as BlockView, index$s_CodeHash as CodeHash, index$s_CoreIndex as CoreIndex, index$s_EntropyHash as EntropyHash, index$s_Epoch as Epoch, index$s_EpochMarkerView as EpochMarkerView, index$s_ExtrinsicHash as ExtrinsicHash, index$s_ExtrinsicView as ExtrinsicView, index$s_HeaderHash as HeaderHash, index$s_HeaderView as HeaderView, index$s_PerEpochBlock as PerEpochBlock, index$s_PerValidator as PerValidator, index$s_SEGMENT_BYTES as SEGMENT_BYTES, index$s_Segment as Segment, index$s_SegmentIndex as SegmentIndex, index$s_ServiceGas as ServiceGas, index$s_ServiceId as ServiceId, index$s_StateRootHash as StateRootHash, index$s_TicketsMarkerView as TicketsMarkerView, index$s_TimeSlot as TimeSlot, index$s_ValidatorIndex as ValidatorIndex, index$s_WorkReportHash as WorkReportHash };
+/**
+ * Block structures and types for JAM protocol.
+ *
+ * This module provides the core block data structures used in the JAM protocol,
+ * including block headers, bodies, and related types.
+ *
+ * @module block
+ */
+
+type block_Block = Block;
+declare const block_Block: typeof Block;
+type block_BlockView = BlockView;
+type block_CodeHash = CodeHash;
+type block_CoreIndex = CoreIndex;
+type block_EntropyHash = EntropyHash;
+type block_Epoch = Epoch;
+type block_EpochMarker = EpochMarker;
+declare const block_EpochMarker: typeof EpochMarker;
+type block_EpochMarkerView = EpochMarkerView;
+type block_Extrinsic = Extrinsic;
+declare const block_Extrinsic: typeof Extrinsic;
+type block_ExtrinsicHash = ExtrinsicHash;
+type block_ExtrinsicView = ExtrinsicView;
+type block_Header = Header;
+declare const block_Header: typeof Header;
+type block_HeaderHash = HeaderHash;
+type block_HeaderView = HeaderView;
+declare const block_MAX_NUMBER_OF_SEGMENTS: typeof MAX_NUMBER_OF_SEGMENTS;
+type block_PerEpochBlock<T> = PerEpochBlock<T>;
+type block_PerValidator<T> = PerValidator<T>;
+type block_SEGMENT_BYTES = SEGMENT_BYTES;
+type block_Segment = Segment;
+type block_SegmentIndex = SegmentIndex;
+type block_ServiceGas = ServiceGas;
+type block_ServiceId = ServiceId;
+type block_StateRootHash = StateRootHash;
+type block_TicketsMarker = TicketsMarker;
+declare const block_TicketsMarker: typeof TicketsMarker;
+type block_TicketsMarkerView = TicketsMarkerView;
+type block_TimeSlot = TimeSlot;
+type block_ValidatorIndex = ValidatorIndex;
+type block_ValidatorKeys = ValidatorKeys;
+declare const block_ValidatorKeys: typeof ValidatorKeys;
+declare const block_W_E: typeof W_E;
+declare const block_W_S: typeof W_S;
+type block_WorkReportHash = WorkReportHash;
+declare const block_assurances: typeof assurances;
+declare const block_codecPerEpochBlock: typeof codecPerEpochBlock;
+declare const block_codecPerValidator: typeof codecPerValidator;
+declare const block_codecUtils: typeof codecUtils;
+declare const block_disputes: typeof disputes;
+declare const block_emptyBlock: typeof emptyBlock;
+declare const block_encodeUnsealedHeader: typeof encodeUnsealedHeader;
+declare const block_guarantees: typeof guarantees;
+declare const block_headerViewWithHashCodec: typeof headerViewWithHashCodec;
+declare const block_preimage: typeof preimage;
+declare const block_reencodeAsView: typeof reencodeAsView;
+declare const block_refineContext: typeof refineContext;
+declare const block_tickets: typeof tickets;
+declare const block_tryAsCoreIndex: typeof tryAsCoreIndex;
+declare const block_tryAsEpoch: typeof tryAsEpoch;
+declare const block_tryAsPerEpochBlock: typeof tryAsPerEpochBlock;
+declare const block_tryAsPerValidator: typeof tryAsPerValidator;
+declare const block_tryAsSegmentIndex: typeof tryAsSegmentIndex;
+declare const block_tryAsServiceGas: typeof tryAsServiceGas;
+declare const block_tryAsServiceId: typeof tryAsServiceId;
+declare const block_tryAsTimeSlot: typeof tryAsTimeSlot;
+declare const block_tryAsValidatorIndex: typeof tryAsValidatorIndex;
+declare const block_workItem: typeof workItem;
+declare const block_workPackage: typeof workPackage;
+declare const block_workReport: typeof workReport;
+declare const block_workResult: typeof workResult;
+declare namespace block {
+  export { block_Block as Block, block_EpochMarker as EpochMarker, block_Extrinsic as Extrinsic, block_Header as Header, block_MAX_NUMBER_OF_SEGMENTS as MAX_NUMBER_OF_SEGMENTS, block_TicketsMarker as TicketsMarker, block_ValidatorKeys as ValidatorKeys, block_W_E as W_E, block_W_S as W_S, block_assurances as assurances, block_codecPerEpochBlock as codecPerEpochBlock, block_codecPerValidator as codecPerValidator, block_codecUtils as codecUtils, block_disputes as disputes, block_emptyBlock as emptyBlock, block_encodeUnsealedHeader as encodeUnsealedHeader, block_guarantees as guarantees, block_headerViewWithHashCodec as headerViewWithHashCodec, block_preimage as preimage, block_reencodeAsView as reencodeAsView, block_refineContext as refineContext, block_tickets as tickets, block_tryAsCoreIndex as tryAsCoreIndex, block_tryAsEpoch as tryAsEpoch, block_tryAsPerEpochBlock as tryAsPerEpochBlock, block_tryAsPerValidator as tryAsPerValidator, block_tryAsSegmentIndex as tryAsSegmentIndex, block_tryAsServiceGas as tryAsServiceGas, block_tryAsServiceId as tryAsServiceId, block_tryAsTimeSlot as tryAsTimeSlot, block_tryAsValidatorIndex as tryAsValidatorIndex, block_workItem as workItem, block_workPackage as workPackage, block_workReport as workReport, block_workResult as workResult };
+  export type { block_BlockView as BlockView, block_CodeHash as CodeHash, block_CoreIndex as CoreIndex, block_EntropyHash as EntropyHash, block_Epoch as Epoch, block_EpochMarkerView as EpochMarkerView, block_ExtrinsicHash as ExtrinsicHash, block_ExtrinsicView as ExtrinsicView, block_HeaderHash as HeaderHash, block_HeaderView as HeaderView, block_PerEpochBlock as PerEpochBlock, block_PerValidator as PerValidator, block_SEGMENT_BYTES as SEGMENT_BYTES, block_Segment as Segment, block_SegmentIndex as SegmentIndex, block_ServiceGas as ServiceGas, block_ServiceId as ServiceId, block_StateRootHash as StateRootHash, block_TicketsMarkerView as TicketsMarkerView, block_TimeSlot as TimeSlot, block_ValidatorIndex as ValidatorIndex, block_WorkReportHash as WorkReportHash };
 }
 
 /** A type that can be read from a JSON-parsed object. */
@@ -4343,20 +4064,6 @@ declare namespace json {
 /** Given already parsed JSON, parse & validate it further to match the expected `jsonDescription` type. */
 declare function parseFromJson<T>(jsonType: unknown, jsonDescription: FromJson<T>, context?: string): T;
 
-type index$r_Builder<TFrom, TInto> = Builder<TFrom, TInto>;
-type index$r_FromJson<T> = FromJson<T>;
-type index$r_FromJsonOptional<TInto> = FromJsonOptional<TInto>;
-type index$r_FromJsonPrimitive<T> = FromJsonPrimitive<T>;
-type index$r_FromJsonWithParser<TFrom, TInto> = FromJsonWithParser<TFrom, TInto>;
-type index$r_ObjectFromJson<T> = ObjectFromJson<T>;
-type index$r_Parser<TFrom, TInto> = Parser<TFrom, TInto>;
-import index$r_json = json;
-declare const index$r_parseFromJson: typeof parseFromJson;
-declare namespace index$r {
-  export { index$r_json as json, index$r_parseFromJson as parseFromJson };
-  export type { index$r_Builder as Builder, index$r_FromJson as FromJson, index$r_FromJsonOptional as FromJsonOptional, index$r_FromJsonPrimitive as FromJsonPrimitive, index$r_FromJsonWithParser as FromJsonWithParser, index$r_ObjectFromJson as ObjectFromJson, index$r_Parser as Parser };
-}
-
 declare const getAssurancesExtrinsicFromJson: (ctx: ChainSpec) => ["array", FromJsonWithParser<unknown, AvailabilityAssurance> | FromJsonWithParser<string, AvailabilityAssurance> | FromJsonWithParser<number, AvailabilityAssurance> | ObjectFromJson<AvailabilityAssurance> | FromJsonOptional<AvailabilityAssurance> | Parser<unknown, AvailabilityAssurance[]>];
 
 declare const blockFromJson: (spec: ChainSpec) => FromJsonWithParser<unknown, Block>;
@@ -4399,23 +4106,211 @@ declare const workReportFromJson: FromJsonWithParser<unknown, WorkReport>;
 
 declare const workResultFromJson: FromJsonWithParser<unknown, WorkResult>;
 
-type index$q_JsonObject<T> = JsonObject<T>;
-declare const index$q_blockFromJson: typeof blockFromJson;
-declare const index$q_disputesExtrinsicFromJson: typeof disputesExtrinsicFromJson;
-import index$q_fromJson = fromJson;
-declare const index$q_getAssurancesExtrinsicFromJson: typeof getAssurancesExtrinsicFromJson;
-declare const index$q_getExtrinsicFromJson: typeof getExtrinsicFromJson;
-declare const index$q_guaranteesExtrinsicFromJson: typeof guaranteesExtrinsicFromJson;
-declare const index$q_headerFromJson: typeof headerFromJson;
-declare const index$q_preimagesExtrinsicFromJson: typeof preimagesExtrinsicFromJson;
-declare const index$q_refineContextFromJson: typeof refineContextFromJson;
-declare const index$q_segmentRootLookupItemFromJson: typeof segmentRootLookupItemFromJson;
-declare const index$q_ticketsExtrinsicFromJson: typeof ticketsExtrinsicFromJson;
-declare const index$q_workReportFromJson: typeof workReportFromJson;
-declare const index$q_workResultFromJson: typeof workResultFromJson;
-declare namespace index$q {
-  export { index$q_blockFromJson as blockFromJson, index$q_disputesExtrinsicFromJson as disputesExtrinsicFromJson, index$q_fromJson as fromJson, index$q_getAssurancesExtrinsicFromJson as getAssurancesExtrinsicFromJson, index$q_getExtrinsicFromJson as getExtrinsicFromJson, index$q_guaranteesExtrinsicFromJson as guaranteesExtrinsicFromJson, index$q_headerFromJson as headerFromJson, index$q_preimagesExtrinsicFromJson as preimagesExtrinsicFromJson, index$q_refineContextFromJson as refineContextFromJson, index$q_segmentRootLookupItemFromJson as segmentRootLookupItemFromJson, index$q_ticketsExtrinsicFromJson as ticketsExtrinsicFromJson, index$q_workReportFromJson as workReportFromJson, index$q_workResultFromJson as workResultFromJson };
-  export type { index$q_JsonObject as JsonObject };
+/**
+ * JSON serialization and deserialization for block structures.
+ *
+ * This module provides utilities for converting JAM block structures to and from
+ * JSON format, useful for debugging, logging, and data interchange.
+ *
+ * @module block-json
+ */
+
+type blockJson_JsonObject<T> = JsonObject<T>;
+declare const blockJson_blockFromJson: typeof blockFromJson;
+declare const blockJson_disputesExtrinsicFromJson: typeof disputesExtrinsicFromJson;
+import blockJson_fromJson = fromJson;
+declare const blockJson_getAssurancesExtrinsicFromJson: typeof getAssurancesExtrinsicFromJson;
+declare const blockJson_getExtrinsicFromJson: typeof getExtrinsicFromJson;
+declare const blockJson_guaranteesExtrinsicFromJson: typeof guaranteesExtrinsicFromJson;
+declare const blockJson_headerFromJson: typeof headerFromJson;
+declare const blockJson_preimagesExtrinsicFromJson: typeof preimagesExtrinsicFromJson;
+declare const blockJson_refineContextFromJson: typeof refineContextFromJson;
+declare const blockJson_segmentRootLookupItemFromJson: typeof segmentRootLookupItemFromJson;
+declare const blockJson_ticketsExtrinsicFromJson: typeof ticketsExtrinsicFromJson;
+declare const blockJson_workReportFromJson: typeof workReportFromJson;
+declare const blockJson_workResultFromJson: typeof workResultFromJson;
+declare namespace blockJson {
+  export { blockJson_blockFromJson as blockFromJson, blockJson_disputesExtrinsicFromJson as disputesExtrinsicFromJson, blockJson_fromJson as fromJson, blockJson_getAssurancesExtrinsicFromJson as getAssurancesExtrinsicFromJson, blockJson_getExtrinsicFromJson as getExtrinsicFromJson, blockJson_guaranteesExtrinsicFromJson as guaranteesExtrinsicFromJson, blockJson_headerFromJson as headerFromJson, blockJson_preimagesExtrinsicFromJson as preimagesExtrinsicFromJson, blockJson_refineContextFromJson as refineContextFromJson, blockJson_segmentRootLookupItemFromJson as segmentRootLookupItemFromJson, blockJson_ticketsExtrinsicFromJson as ticketsExtrinsicFromJson, blockJson_workReportFromJson as workReportFromJson, blockJson_workResultFromJson as workResultFromJson };
+  export type { blockJson_JsonObject as JsonObject };
+}
+
+/**
+ * Byte array utilities and operations.
+ *
+ * This module provides utilities for working with byte arrays, including
+ * conversions, comparisons, and manipulations of binary data.
+ *
+ * @module bytes
+ */
+
+type bytes_BitVec = BitVec;
+declare const bytes_BitVec: typeof BitVec;
+type bytes_Bytes<T extends number> = Bytes<T>;
+declare const bytes_Bytes: typeof Bytes;
+type bytes_BytesBlob = BytesBlob;
+declare const bytes_BytesBlob: typeof BytesBlob;
+declare const bytes_bytesBlobComparator: typeof bytesBlobComparator;
+declare namespace bytes {
+  export {
+    bytes_BitVec as BitVec,
+    bytes_Bytes as Bytes,
+    bytes_BytesBlob as BytesBlob,
+    bytes_bytesBlobComparator as bytesBlobComparator,
+  };
+}
+
+/**
+ * JAM/GP codec implementation for encoding and decoding data.
+ *
+ * This module provides the JAM/GP codec used throughout the
+ * JAM protocol for efficient binary serialization.
+ *
+ * @module codec
+ */
+
+declare const codec_Class: typeof Class;
+type codec_ClassConstructor<T> = ClassConstructor<T>;
+type codec_Codec<T> = Codec<T>;
+type codec_CodecRecord<T> = CodecRecord<T>;
+type codec_CodecWithView<T, V> = CodecWithView<T, V>;
+type codec_Decode<T> = Decode<T>;
+type codec_Decoder = Decoder;
+declare const codec_Decoder: typeof Decoder;
+type codec_DescribedBy<T> = DescribedBy<T>;
+type codec_Descriptor<T, V = T> = Descriptor<T, V>;
+declare const codec_Descriptor: typeof Descriptor;
+type codec_DescriptorRecord<T> = DescriptorRecord<T>;
+type codec_Encode<T> = Encode<T>;
+type codec_Encoder = Encoder;
+declare const codec_Encoder: typeof Encoder;
+type codec_EndOfDataError = EndOfDataError;
+declare const codec_EndOfDataError: typeof EndOfDataError;
+type codec_LengthRange = LengthRange;
+type codec_ObjectView<T> = ObjectView<T>;
+declare const codec_ObjectView: typeof ObjectView;
+type codec_OptionalRecord<T> = OptionalRecord<T>;
+type codec_PropertyKeys<T> = PropertyKeys<T>;
+type codec_SequenceVarLenOptions = SequenceVarLenOptions;
+type codec_SequenceView<T, V = T> = SequenceView<T, V>;
+declare const codec_SequenceView: typeof SequenceView;
+type codec_SimpleDescriptorRecord<T> = SimpleDescriptorRecord<T>;
+type codec_SizeHint = SizeHint;
+declare const codec_TYPICAL_DICTIONARY_LENGTH: typeof TYPICAL_DICTIONARY_LENGTH;
+type codec_ViewField<T, V> = ViewField<T, V>;
+declare const codec_ViewField: typeof ViewField;
+type codec_ViewOf<T, D extends DescriptorRecord<T>> = ViewOf<T, D>;
+declare const codec_addSizeHints: typeof addSizeHints;
+declare const codec_bitVecFixLen: typeof bitVecFixLen;
+declare const codec_bitVecVarLen: typeof bitVecVarLen;
+declare const codec_blob: typeof blob;
+declare const codec_bool: typeof bool;
+declare const codec_custom: typeof custom;
+declare const codec_decodeVariableLengthExtraBytes: typeof decodeVariableLengthExtraBytes;
+declare const codec_dictionary: typeof dictionary;
+declare const codec_forEachDescriptor: typeof forEachDescriptor;
+declare const codec_i16: typeof i16;
+declare const codec_i24: typeof i24;
+declare const codec_i32: typeof i32;
+declare const codec_i64: typeof i64;
+declare const codec_i8: typeof i8;
+declare const codec_nothing: typeof nothing;
+declare const codec_object: typeof object;
+declare const codec_optional: typeof optional;
+declare const codec_pair: typeof pair;
+declare const codec_readonlyArray: typeof readonlyArray;
+declare const codec_select: typeof select;
+declare const codec_sequenceFixLen: typeof sequenceFixLen;
+declare const codec_sequenceVarLen: typeof sequenceVarLen;
+declare const codec_string: typeof string;
+declare const codec_tryAsExactBytes: typeof tryAsExactBytes;
+declare const codec_u16: typeof u16;
+declare const codec_u24: typeof u24;
+declare const codec_u32: typeof u32;
+declare const codec_u64: typeof u64;
+declare const codec_u8: typeof u8;
+declare const codec_union: typeof union;
+declare const codec_validateLength: typeof validateLength;
+declare const codec_varU32: typeof varU32;
+declare const codec_varU64: typeof varU64;
+declare namespace codec {
+  export { codec_Class as Class, codec_Decoder as Decoder, codec_Descriptor as Descriptor, codec_Encoder as Encoder, codec_EndOfDataError as EndOfDataError, codec_ObjectView as ObjectView, codec_SequenceView as SequenceView, codec_TYPICAL_DICTIONARY_LENGTH as TYPICAL_DICTIONARY_LENGTH, codec_ViewField as ViewField, codec_addSizeHints as addSizeHints, codec_bitVecFixLen as bitVecFixLen, codec_bitVecVarLen as bitVecVarLen, codec_blob as blob, codec_bool as bool, bytes$1 as bytes, codec$1 as codec, codec_custom as custom, codec_decodeVariableLengthExtraBytes as decodeVariableLengthExtraBytes, codec_dictionary as dictionary, codec_forEachDescriptor as forEachDescriptor, codec_i16 as i16, codec_i24 as i24, codec_i32 as i32, codec_i64 as i64, codec_i8 as i8, codec_nothing as nothing, codec_object as object, codec_optional as optional, codec_pair as pair, codec_readonlyArray as readonlyArray, codec_select as select, codec_sequenceFixLen as sequenceFixLen, codec_sequenceVarLen as sequenceVarLen, codec_string as string, codec_tryAsExactBytes as tryAsExactBytes, codec_u16 as u16, codec_u24 as u24, codec_u32 as u32, codec_u64 as u64, codec_u8 as u8, codec_union as union, codec_validateLength as validateLength, codec_varU32 as varU32, codec_varU64 as varU64 };
+  export type { codec_ClassConstructor as ClassConstructor, codec_Codec as Codec, codec_CodecRecord as CodecRecord, codec_CodecWithView as CodecWithView, codec_Decode as Decode, codec_DescribedBy as DescribedBy, codec_DescriptorRecord as DescriptorRecord, codec_Encode as Encode, codec_LengthRange as LengthRange, codec_OptionalRecord as OptionalRecord, Options$1 as Options, codec_PropertyKeys as PropertyKeys, codec_SequenceVarLenOptions as SequenceVarLenOptions, codec_SimpleDescriptorRecord as SimpleDescriptorRecord, codec_SizeHint as SizeHint, codec_ViewOf as ViewOf };
+}
+
+/**
+ * Specialized data structures and collections.
+ *
+ * This module provides custom data structures optimized for JAM protocol operations,
+ * including specialized maps, sets, and other collection types.
+ *
+ * @module collections
+ */
+
+type collections_ArrayView<T> = ArrayView<T>;
+declare const collections_ArrayView: typeof ArrayView;
+type collections_BlobDictionary<K extends BytesBlob, V> = BlobDictionary<K, V>;
+declare const collections_BlobDictionary: typeof BlobDictionary;
+type collections_FixedSizeArray<T, N extends number> = FixedSizeArray<T, N>;
+declare const collections_FixedSizeArray: typeof FixedSizeArray;
+type collections_HashDictionary<K extends OpaqueHash, V> = HashDictionary<K, V>;
+declare const collections_HashDictionary: typeof HashDictionary;
+type collections_HashSet<V extends OpaqueHash> = HashSet<V>;
+declare const collections_HashSet: typeof HashSet;
+type collections_ImmutableHashDictionary<K extends OpaqueHash, V> = ImmutableHashDictionary<K, V>;
+type collections_ImmutableHashSet<V extends OpaqueHash> = ImmutableHashSet<V>;
+type collections_ImmutableSortedArray<V> = ImmutableSortedArray<V>;
+type collections_ImmutableSortedSet<V> = ImmutableSortedSet<V>;
+type collections_KeyMapper<K> = KeyMapper<K>;
+type collections_KnownSize<T, F extends string> = KnownSize<T, F>;
+type collections_KnownSizeArray<T, F extends string> = KnownSizeArray<T, F>;
+type collections_KnownSizeId<X> = KnownSizeId<X>;
+type collections_ListChildren<K extends BytesBlob, V> = ListChildren<K, V>;
+declare const collections_ListChildren: typeof ListChildren;
+type collections_MultiMap<TKeys extends readonly unknown[], TValue> = MultiMap<TKeys, TValue>;
+declare const collections_MultiMap: typeof MultiMap;
+type collections_SortedArray<V> = SortedArray<V>;
+declare const collections_SortedArray: typeof SortedArray;
+type collections_SortedSet<V> = SortedSet<V>;
+declare const collections_SortedSet: typeof SortedSet;
+type collections_StringHashDictionary<K extends OpaqueHash, V> = StringHashDictionary<K, V>;
+declare const collections_StringHashDictionary: typeof StringHashDictionary;
+type collections_TruncatedHashDictionary<T extends OpaqueHash, V> = TruncatedHashDictionary<T, V>;
+declare const collections_TruncatedHashDictionary: typeof TruncatedHashDictionary;
+declare const collections_asKnownSize: typeof asKnownSize;
+declare const collections_bytesAsU48: typeof bytesAsU48;
+declare namespace collections {
+  export { collections_ArrayView as ArrayView, collections_BlobDictionary as BlobDictionary, collections_FixedSizeArray as FixedSizeArray, collections_HashDictionary as HashDictionary, collections_HashSet as HashSet, collections_ListChildren as ListChildren, collections_MultiMap as MultiMap, collections_SortedArray as SortedArray, collections_SortedSet as SortedSet, collections_StringHashDictionary as StringHashDictionary, collections_TruncatedHashDictionary as TruncatedHashDictionary, collections_asKnownSize as asKnownSize, collections_bytesAsU48 as bytesAsU48 };
+  export type { collections_ImmutableHashDictionary as ImmutableHashDictionary, collections_ImmutableHashSet as ImmutableHashSet, collections_ImmutableSortedArray as ImmutableSortedArray, collections_ImmutableSortedSet as ImmutableSortedSet, collections_KeyMapper as KeyMapper, collections_KnownSize as KnownSize, collections_KnownSizeArray as KnownSizeArray, collections_KnownSizeId as KnownSizeId };
+}
+
+/**
+ * Configuration types and constants for JAM protocol.
+ *
+ * This module defines the core configuration parameters, constants, and types
+ * used throughout the JAM protocol implementation.
+ *
+ * @module config
+ */
+
+type config_Bootnode = Bootnode;
+declare const config_Bootnode: typeof Bootnode;
+type config_ChainSpec = ChainSpec;
+declare const config_ChainSpec: typeof ChainSpec;
+declare const config_EC_SEGMENT_SIZE: typeof EC_SEGMENT_SIZE;
+declare const config_EST_CORES: typeof EST_CORES;
+declare const config_EST_EPOCH_LENGTH: typeof EST_EPOCH_LENGTH;
+declare const config_EST_VALIDATORS: typeof EST_VALIDATORS;
+declare const config_EST_VALIDATORS_SUPER_MAJORITY: typeof EST_VALIDATORS_SUPER_MAJORITY;
+type config_PeerAddress = PeerAddress;
+type config_PeerId = PeerId;
+type config_PvmBackend = PvmBackend;
+declare const config_PvmBackend: typeof PvmBackend;
+declare const config_PvmBackendNames: typeof PvmBackendNames;
+declare const config_fullChainSpec: typeof fullChainSpec;
+declare const config_tinyChainSpec: typeof tinyChainSpec;
+declare namespace config {
+  export { config_Bootnode as Bootnode, config_ChainSpec as ChainSpec, config_EC_SEGMENT_SIZE as EC_SEGMENT_SIZE, config_EST_CORES as EST_CORES, config_EST_EPOCH_LENGTH as EST_EPOCH_LENGTH, config_EST_VALIDATORS as EST_VALIDATORS, config_EST_VALIDATORS_SUPER_MAJORITY as EST_VALIDATORS_SUPER_MAJORITY, config_PvmBackend as PvmBackend, config_PvmBackendNames as PvmBackendNames, config_fullChainSpec as fullChainSpec, config_tinyChainSpec as tinyChainSpec };
+  export type { config_PeerAddress as PeerAddress, config_PeerId as PeerId };
 }
 
 declare function parseBootnode(v: string): Bootnode;
@@ -4489,32 +4384,78 @@ declare class NodeConfiguration {
 }
 declare function loadConfig(config: string[], withRelPath: (p: string) => string): NodeConfiguration;
 
-declare const index$p_DEFAULT_CONFIG: typeof DEFAULT_CONFIG;
-declare const index$p_DEV_CONFIG: typeof DEV_CONFIG;
-type index$p_JipChainSpec = JipChainSpec;
-declare const index$p_JipChainSpec: typeof JipChainSpec;
-type index$p_KnownChainSpec = KnownChainSpec;
-declare const index$p_KnownChainSpec: typeof KnownChainSpec;
-declare const index$p_NODE_DEFAULTS: typeof NODE_DEFAULTS;
-type index$p_NodeConfiguration = NodeConfiguration;
-declare const index$p_NodeConfiguration: typeof NodeConfiguration;
-declare const index$p_knownChainSpecFromJson: typeof knownChainSpecFromJson;
-declare const index$p_loadConfig: typeof loadConfig;
-declare const index$p_parseBootnode: typeof parseBootnode;
-declare namespace index$p {
+/**
+ * Node-specific configuration utilities.
+ *
+ * This module provides configuration utilities specific to Node.js environments,
+ * including environment variable handling and runtime configuration.
+ *
+ * @module config-node
+ */
+
+declare const configNode_DEFAULT_CONFIG: typeof DEFAULT_CONFIG;
+declare const configNode_DEV_CONFIG: typeof DEV_CONFIG;
+type configNode_JipChainSpec = JipChainSpec;
+declare const configNode_JipChainSpec: typeof JipChainSpec;
+type configNode_KnownChainSpec = KnownChainSpec;
+declare const configNode_KnownChainSpec: typeof KnownChainSpec;
+declare const configNode_NODE_DEFAULTS: typeof NODE_DEFAULTS;
+type configNode_NodeConfiguration = NodeConfiguration;
+declare const configNode_NodeConfiguration: typeof NodeConfiguration;
+declare const configNode_knownChainSpecFromJson: typeof knownChainSpecFromJson;
+declare const configNode_loadConfig: typeof loadConfig;
+declare const configNode_parseBootnode: typeof parseBootnode;
+declare namespace configNode {
   export {
-    index$p_DEFAULT_CONFIG as DEFAULT_CONFIG,
-    index$p_DEV_CONFIG as DEV_CONFIG,
-    index$p_JipChainSpec as JipChainSpec,
-    index$p_KnownChainSpec as KnownChainSpec,
-    index$p_NODE_DEFAULTS as NODE_DEFAULTS,
-    index$p_NodeConfiguration as NodeConfiguration,
-    index$p_knownChainSpecFromJson as knownChainSpecFromJson,
-    index$p_loadConfig as loadConfig,
-    index$p_parseBootnode as parseBootnode,
+    configNode_DEFAULT_CONFIG as DEFAULT_CONFIG,
+    configNode_DEV_CONFIG as DEV_CONFIG,
+    configNode_JipChainSpec as JipChainSpec,
+    configNode_KnownChainSpec as KnownChainSpec,
+    configNode_NODE_DEFAULTS as NODE_DEFAULTS,
+    configNode_NodeConfiguration as NodeConfiguration,
+    configNode_knownChainSpecFromJson as knownChainSpecFromJson,
+    configNode_loadConfig as loadConfig,
+    configNode_parseBootnode as parseBootnode,
   };
 }
 
+/**
+ * Cryptographic primitives and operations.
+ *
+ * This module provides cryptographic functionality including Ed25519, Sr25519,
+ * and BLS signature schemes, key generation, and signing operations.
+ *
+ * @module crypto
+ */
+
+type crypto_BANDERSNATCH_KEY_BYTES = BANDERSNATCH_KEY_BYTES;
+type crypto_BANDERSNATCH_PROOF_BYTES = BANDERSNATCH_PROOF_BYTES;
+type crypto_BANDERSNATCH_RING_ROOT_BYTES = BANDERSNATCH_RING_ROOT_BYTES;
+type crypto_BANDERSNATCH_VRF_SIGNATURE_BYTES = BANDERSNATCH_VRF_SIGNATURE_BYTES;
+type crypto_BLS_KEY_BYTES = BLS_KEY_BYTES;
+type crypto_BandersnatchKey = BandersnatchKey;
+type crypto_BandersnatchProof = BandersnatchProof;
+type crypto_BandersnatchRingRoot = BandersnatchRingRoot;
+type crypto_BandersnatchSecretSeed = BandersnatchSecretSeed;
+type crypto_BandersnatchVrfSignature = BandersnatchVrfSignature;
+type crypto_BlsKey = BlsKey;
+type crypto_ED25519_KEY_BYTES = ED25519_KEY_BYTES;
+type crypto_ED25519_PRIV_KEY_BYTES = ED25519_PRIV_KEY_BYTES;
+type crypto_ED25519_SIGNATURE_BYTES = ED25519_SIGNATURE_BYTES;
+type crypto_Ed25519Key = Ed25519Key;
+type crypto_Ed25519Pair = Ed25519Pair;
+declare const crypto_Ed25519Pair: typeof Ed25519Pair;
+type crypto_Ed25519SecretSeed = Ed25519SecretSeed;
+type crypto_Ed25519Signature = Ed25519Signature;
+type crypto_SEED_SIZE = SEED_SIZE;
+declare const crypto_bandersnatch: typeof bandersnatch;
+declare const crypto_ed25519: typeof ed25519;
+declare const crypto_keyDerivation: typeof keyDerivation;
+declare namespace crypto {
+  export { crypto_Ed25519Pair as Ed25519Pair, crypto_bandersnatch as bandersnatch, bandersnatch_d_exports as bandersnatchWasm, crypto_ed25519 as ed25519, initAll as initWasm, crypto_keyDerivation as keyDerivation };
+  export type { crypto_BANDERSNATCH_KEY_BYTES as BANDERSNATCH_KEY_BYTES, crypto_BANDERSNATCH_PROOF_BYTES as BANDERSNATCH_PROOF_BYTES, crypto_BANDERSNATCH_RING_ROOT_BYTES as BANDERSNATCH_RING_ROOT_BYTES, crypto_BANDERSNATCH_VRF_SIGNATURE_BYTES as BANDERSNATCH_VRF_SIGNATURE_BYTES, crypto_BLS_KEY_BYTES as BLS_KEY_BYTES, crypto_BandersnatchKey as BandersnatchKey, crypto_BandersnatchProof as BandersnatchProof, crypto_BandersnatchRingRoot as BandersnatchRingRoot, crypto_BandersnatchSecretSeed as BandersnatchSecretSeed, crypto_BandersnatchVrfSignature as BandersnatchVrfSignature, crypto_BlsKey as BlsKey, crypto_ED25519_KEY_BYTES as ED25519_KEY_BYTES, crypto_ED25519_PRIV_KEY_BYTES as ED25519_PRIV_KEY_BYTES, crypto_ED25519_SIGNATURE_BYTES as ED25519_SIGNATURE_BYTES, crypto_Ed25519Key as Ed25519Key, crypto_Ed25519SecretSeed as Ed25519SecretSeed, crypto_Ed25519Signature as Ed25519Signature, KeySeed as PublicKeySeed, crypto_SEED_SIZE as SEED_SIZE };
+}
+
 /**
  * Blockchain database interface.
  */
@@ -4755,36 +4696,6 @@ declare class InMemoryTrie {
 }
 declare function findSharedPrefix(a: TruncatedStateKey, b: TruncatedStateKey): number;
 
-type index$o_BranchNode = BranchNode;
-declare const index$o_BranchNode: typeof BranchNode;
-type index$o_InMemoryTrie = InMemoryTrie;
-declare const index$o_InMemoryTrie: typeof InMemoryTrie;
-type index$o_InputKey = InputKey;
-type index$o_LeafNode = LeafNode;
-declare const index$o_LeafNode: typeof LeafNode;
-type index$o_NodeType = NodeType;
-declare const index$o_NodeType: typeof NodeType;
-type index$o_NodesDb = NodesDb;
-declare const index$o_NodesDb: typeof NodesDb;
-declare const index$o_TRIE_NODE_BYTES: typeof TRIE_NODE_BYTES;
-declare const index$o_TRUNCATED_KEY_BITS: typeof TRUNCATED_KEY_BITS;
-type index$o_TRUNCATED_KEY_BYTES = TRUNCATED_KEY_BYTES;
-type index$o_TrieHasher = TrieHasher;
-type index$o_TrieNode = TrieNode;
-declare const index$o_TrieNode: typeof TrieNode;
-type index$o_TrieNodeHash = TrieNodeHash;
-type index$o_TruncatedStateKey = TruncatedStateKey;
-type index$o_ValueHash = ValueHash;
-type index$o_WriteableNodesDb = WriteableNodesDb;
-declare const index$o_WriteableNodesDb: typeof WriteableNodesDb;
-declare const index$o_findSharedPrefix: typeof findSharedPrefix;
-declare const index$o_leafComparator: typeof leafComparator;
-declare const index$o_parseInputKey: typeof parseInputKey;
-declare namespace index$o {
-  export { index$o_BranchNode as BranchNode, index$o_InMemoryTrie as InMemoryTrie, index$o_LeafNode as LeafNode, index$o_NodeType as NodeType, index$o_NodesDb as NodesDb, index$o_TRIE_NODE_BYTES as TRIE_NODE_BYTES, index$o_TRUNCATED_KEY_BITS as TRUNCATED_KEY_BITS, index$o_TrieNode as TrieNode, index$o_WriteableNodesDb as WriteableNodesDb, index$o_findSharedPrefix as findSharedPrefix, index$o_leafComparator as leafComparator, index$o_parseInputKey as parseInputKey };
-  export type { index$o_InputKey as InputKey, StateKey$1 as StateKey, index$o_TRUNCATED_KEY_BYTES as TRUNCATED_KEY_BYTES, index$o_TrieHasher as TrieHasher, index$o_TrieNodeHash as TrieNodeHash, index$o_TruncatedStateKey as TruncatedStateKey, index$o_ValueHash as ValueHash };
-}
-
 /**
  *. Binary merkleization for well-balanced trees.
  *
@@ -5234,15 +5145,6 @@ declare class MerkleMountainRange<H extends OpaqueHash> {
     getPeaks(): MmrPeaks<H>;
 }
 
-type index$n_MerkleMountainRange<H extends OpaqueHash> = MerkleMountainRange<H>;
-declare const index$n_MerkleMountainRange: typeof MerkleMountainRange;
-type index$n_MmrHasher<H extends OpaqueHash> = MmrHasher<H>;
-type index$n_MmrPeaks<H extends OpaqueHash> = MmrPeaks<H>;
-declare namespace index$n {
-  export { index$n_MerkleMountainRange as MerkleMountainRange };
-  export type { index$n_MmrHasher as MmrHasher, index$n_MmrPeaks as MmrPeaks };
-}
-
 /**
  * `H = 8`: The size of recent history, in blocks.
  *
@@ -6226,116 +6128,6 @@ type FieldNames<T> = {
     [K in keyof T]: T[K] extends Function ? never : K;
 }[keyof T];
 
-type index$m_AUTHORIZATION_QUEUE_SIZE = AUTHORIZATION_QUEUE_SIZE;
-type index$m_AccumulationOutput = AccumulationOutput;
-declare const index$m_AccumulationOutput: typeof AccumulationOutput;
-type index$m_AccumulationQueue = AccumulationQueue;
-type index$m_AccumulationQueueView = AccumulationQueueView;
-type index$m_AuthorizationPool = AuthorizationPool;
-type index$m_AuthorizationQueue = AuthorizationQueue;
-type index$m_AvailabilityAssignment = AvailabilityAssignment;
-declare const index$m_AvailabilityAssignment: typeof AvailabilityAssignment;
-type index$m_AvailabilityAssignmentsView = AvailabilityAssignmentsView;
-declare const index$m_BASE_SERVICE_BALANCE: typeof BASE_SERVICE_BALANCE;
-type index$m_BlockState = BlockState;
-declare const index$m_BlockState: typeof BlockState;
-type index$m_BlocksState = BlocksState;
-type index$m_CoreStatistics = CoreStatistics;
-declare const index$m_CoreStatistics: typeof CoreStatistics;
-type index$m_DisputesRecords = DisputesRecords;
-declare const index$m_DisputesRecords: typeof DisputesRecords;
-declare const index$m_ELECTIVE_BYTE_BALANCE: typeof ELECTIVE_BYTE_BALANCE;
-declare const index$m_ELECTIVE_ITEM_BALANCE: typeof ELECTIVE_ITEM_BALANCE;
-type index$m_ENTROPY_ENTRIES = ENTROPY_ENTRIES;
-type index$m_EnumerableState = EnumerableState;
-type index$m_InMemoryService = InMemoryService;
-declare const index$m_InMemoryService: typeof InMemoryService;
-type index$m_InMemoryState = InMemoryState;
-declare const index$m_InMemoryState: typeof InMemoryState;
-type index$m_InMemoryStateFields = InMemoryStateFields;
-type index$m_LookupHistoryItem = LookupHistoryItem;
-declare const index$m_LookupHistoryItem: typeof LookupHistoryItem;
-type index$m_LookupHistorySlots = LookupHistorySlots;
-type index$m_MAX_AUTH_POOL_SIZE = MAX_AUTH_POOL_SIZE;
-type index$m_MAX_RECENT_HISTORY = MAX_RECENT_HISTORY;
-type index$m_NotYetAccumulatedReport = NotYetAccumulatedReport;
-declare const index$m_NotYetAccumulatedReport: typeof NotYetAccumulatedReport;
-type index$m_PerCore<T> = PerCore<T>;
-type index$m_PreimageItem = PreimageItem;
-declare const index$m_PreimageItem: typeof PreimageItem;
-type index$m_PrivilegedServices = PrivilegedServices;
-declare const index$m_PrivilegedServices: typeof PrivilegedServices;
-type index$m_RecentBlocks = RecentBlocks;
-declare const index$m_RecentBlocks: typeof RecentBlocks;
-type index$m_RecentBlocksView = RecentBlocksView;
-type index$m_RecentlyAccumulated = RecentlyAccumulated;
-type index$m_RecentlyAccumulatedView = RecentlyAccumulatedView;
-type index$m_SafroleData = SafroleData;
-declare const index$m_SafroleData: typeof SafroleData;
-type index$m_SafroleDataView = SafroleDataView;
-type index$m_SafroleSealingKeys = SafroleSealingKeys;
-type index$m_SafroleSealingKeysData = SafroleSealingKeysData;
-declare const index$m_SafroleSealingKeysData: typeof SafroleSealingKeysData;
-type index$m_SafroleSealingKeysKind = SafroleSealingKeysKind;
-declare const index$m_SafroleSealingKeysKind: typeof SafroleSealingKeysKind;
-type index$m_Service = Service;
-type index$m_ServiceAccountInfo = ServiceAccountInfo;
-declare const index$m_ServiceAccountInfo: typeof ServiceAccountInfo;
-type index$m_ServiceAccountInfoView = ServiceAccountInfoView;
-type index$m_ServiceData = ServiceData;
-type index$m_ServiceEntries = ServiceEntries;
-type index$m_ServiceStatistics = ServiceStatistics;
-declare const index$m_ServiceStatistics: typeof ServiceStatistics;
-type index$m_ServicesUpdate = ServicesUpdate;
-type index$m_State = State;
-type index$m_StateView = StateView;
-type index$m_StatisticsData = StatisticsData;
-declare const index$m_StatisticsData: typeof StatisticsData;
-type index$m_StatisticsDataView = StatisticsDataView;
-type index$m_StorageItem = StorageItem;
-declare const index$m_StorageItem: typeof StorageItem;
-type index$m_StorageKey = StorageKey;
-type index$m_UpdateError = UpdateError;
-declare const index$m_UpdateError: typeof UpdateError;
-type index$m_UpdatePreimage = UpdatePreimage;
-declare const index$m_UpdatePreimage: typeof UpdatePreimage;
-type index$m_UpdatePreimageKind = UpdatePreimageKind;
-declare const index$m_UpdatePreimageKind: typeof UpdatePreimageKind;
-type index$m_UpdateService = UpdateService;
-declare const index$m_UpdateService: typeof UpdateService;
-type index$m_UpdateServiceKind = UpdateServiceKind;
-declare const index$m_UpdateServiceKind: typeof UpdateServiceKind;
-type index$m_UpdateStorage = UpdateStorage;
-declare const index$m_UpdateStorage: typeof UpdateStorage;
-type index$m_UpdateStorageKind = UpdateStorageKind;
-declare const index$m_UpdateStorageKind: typeof UpdateStorageKind;
-type index$m_VALIDATOR_META_BYTES = VALIDATOR_META_BYTES;
-type index$m_ValidatorData = ValidatorData;
-declare const index$m_ValidatorData: typeof ValidatorData;
-type index$m_ValidatorDataView = ValidatorDataView;
-type index$m_ValidatorStatistics = ValidatorStatistics;
-declare const index$m_ValidatorStatistics: typeof ValidatorStatistics;
-type index$m_WithStateView<V = StateView> = WithStateView<V>;
-declare const index$m_accumulationOutputComparator: typeof accumulationOutputComparator;
-declare const index$m_accumulationQueueCodec: typeof accumulationQueueCodec;
-declare const index$m_authPoolsCodec: typeof authPoolsCodec;
-declare const index$m_authQueuesCodec: typeof authQueuesCodec;
-declare const index$m_availabilityAssignmentsCodec: typeof availabilityAssignmentsCodec;
-declare const index$m_codecPerCore: typeof codecPerCore;
-declare const index$m_codecWithVersion: typeof codecWithVersion;
-declare const index$m_hashComparator: typeof hashComparator;
-declare const index$m_ignoreValueWithDefault: typeof ignoreValueWithDefault;
-declare const index$m_recentlyAccumulatedCodec: typeof recentlyAccumulatedCodec;
-declare const index$m_serviceDataCodec: typeof serviceDataCodec;
-declare const index$m_serviceEntriesCodec: typeof serviceEntriesCodec;
-declare const index$m_tryAsLookupHistorySlots: typeof tryAsLookupHistorySlots;
-declare const index$m_tryAsPerCore: typeof tryAsPerCore;
-declare const index$m_validatorsDataCodec: typeof validatorsDataCodec;
-declare namespace index$m {
-  export { index$m_AccumulationOutput as AccumulationOutput, index$m_AvailabilityAssignment as AvailabilityAssignment, index$m_BASE_SERVICE_BALANCE as BASE_SERVICE_BALANCE, index$m_BlockState as BlockState, index$m_CoreStatistics as CoreStatistics, index$m_DisputesRecords as DisputesRecords, index$m_ELECTIVE_BYTE_BALANCE as ELECTIVE_BYTE_BALANCE, index$m_ELECTIVE_ITEM_BALANCE as ELECTIVE_ITEM_BALANCE, index$m_InMemoryService as InMemoryService, index$m_InMemoryState as InMemoryState, index$m_LookupHistoryItem as LookupHistoryItem, index$m_NotYetAccumulatedReport as NotYetAccumulatedReport, index$m_PreimageItem as PreimageItem, index$m_PrivilegedServices as PrivilegedServices, index$m_RecentBlocks as RecentBlocks, index$m_SafroleData as SafroleData, index$m_SafroleSealingKeysData as SafroleSealingKeysData, index$m_SafroleSealingKeysKind as SafroleSealingKeysKind, index$m_ServiceAccountInfo as ServiceAccountInfo, index$m_ServiceStatistics as ServiceStatistics, index$m_StatisticsData as StatisticsData, index$m_StorageItem as StorageItem, index$m_UpdateError as UpdateError, index$m_UpdatePreimage as UpdatePreimage, index$m_UpdatePreimageKind as UpdatePreimageKind, index$m_UpdateService as UpdateService, index$m_UpdateServiceKind as UpdateServiceKind, index$m_UpdateStorage as UpdateStorage, index$m_UpdateStorageKind as UpdateStorageKind, index$m_ValidatorData as ValidatorData, index$m_ValidatorStatistics as ValidatorStatistics, index$m_accumulationOutputComparator as accumulationOutputComparator, index$m_accumulationQueueCodec as accumulationQueueCodec, index$m_authPoolsCodec as authPoolsCodec, index$m_authQueuesCodec as authQueuesCodec, index$m_availabilityAssignmentsCodec as availabilityAssignmentsCodec, index$m_codecPerCore as codecPerCore, index$m_codecWithVersion as codecWithVersion, index$m_hashComparator as hashComparator, index$m_ignoreValueWithDefault as ignoreValueWithDefault, index$m_recentlyAccumulatedCodec as recentlyAccumulatedCodec, index$m_serviceDataCodec as serviceDataCodec, index$m_serviceEntriesCodec as serviceEntriesCodec, index$m_tryAsLookupHistorySlots as tryAsLookupHistorySlots, index$m_tryAsPerCore as tryAsPerCore, index$m_validatorsDataCodec as validatorsDataCodec };
-  export type { index$m_AUTHORIZATION_QUEUE_SIZE as AUTHORIZATION_QUEUE_SIZE, index$m_AccumulationQueue as AccumulationQueue, index$m_AccumulationQueueView as AccumulationQueueView, index$m_AuthorizationPool as AuthorizationPool, index$m_AuthorizationQueue as AuthorizationQueue, index$m_AvailabilityAssignmentsView as AvailabilityAssignmentsView, index$m_BlocksState as BlocksState, index$m_ENTROPY_ENTRIES as ENTROPY_ENTRIES, index$m_EnumerableState as EnumerableState, index$m_InMemoryStateFields as InMemoryStateFields, index$m_LookupHistorySlots as LookupHistorySlots, index$m_MAX_AUTH_POOL_SIZE as MAX_AUTH_POOL_SIZE, index$m_MAX_RECENT_HISTORY as MAX_RECENT_HISTORY, index$m_PerCore as PerCore, index$m_RecentBlocksView as RecentBlocksView, index$m_RecentlyAccumulated as RecentlyAccumulated, index$m_RecentlyAccumulatedView as RecentlyAccumulatedView, index$m_SafroleDataView as SafroleDataView, index$m_SafroleSealingKeys as SafroleSealingKeys, index$m_Service as Service, index$m_ServiceAccountInfoView as ServiceAccountInfoView, index$m_ServiceData as ServiceData, index$m_ServiceEntries as ServiceEntries, index$m_ServicesUpdate as ServicesUpdate, index$m_State as State, index$m_StateView as StateView, index$m_StatisticsDataView as StatisticsDataView, index$m_StorageKey as StorageKey, index$m_VALIDATOR_META_BYTES as VALIDATOR_META_BYTES, index$m_ValidatorDataView as ValidatorDataView, index$m_WithStateView as WithStateView };
-}
-
 type StateKey = Opaque<OpaqueHash, "stateKey">;
 /** Numeric mapping for state entries. */
 declare enum StateKeyIdx {
@@ -6645,60 +6437,6 @@ declare namespace serialize {
  */
 declare const dumpCodec: Descriptor<BytesBlob, BytesBlob>;
 
-/**
- * JAM State Serialization & Merkleization.
- *
- * https://graypaper.fluffylabs.dev/#/5f542d7/389f00389f00
- *
- * State representations:
- *
- * We maintain two "views" of our chain state:
- *
- * - **InMemoryState**
- *   - Full, canonical state held entirely in memory.
- *   - Complete info on every field, plus lists of services, modules, etc.
- *
- * - **SerializedState<T>**
- *   - Generic wrapper around a serialized snapshot of the state.
- *   - Only the bytes (and minimal metadata) are held up front.
- *   - Three instantiations:
- *     - `SerializedState<Persistence>`: Pure "black-box" serialized blob
- *        (incomplete in-memory view).
- *     - `SerializedState<LeafDb>`: Disk-backed trie storage-leaf nodes live on
- *        disk and load on demand; cheap to update (no data duplication) and re-compute
- *        the `stateRoot`. Used in LMDB.
- *     - `SerializedState<StateEntries>`: serialized state represented as a simple in-memory
- *        hashmap of `key -> value` entries.
- */
-
-type index$l_SerializedService = SerializedService;
-declare const index$l_SerializedService: typeof SerializedService;
-type index$l_SerializedState<T extends SerializedStateBackend = SerializedStateBackend> = SerializedState<T>;
-declare const index$l_SerializedState: typeof SerializedState;
-type index$l_SerializedStateBackend = SerializedStateBackend;
-type index$l_SerializedStateView<T extends SerializedStateBackend> = SerializedStateView<T>;
-declare const index$l_SerializedStateView: typeof SerializedStateView;
-type index$l_StateCodec<T, V = T> = StateCodec<T, V>;
-type index$l_StateEntries = StateEntries;
-declare const index$l_StateEntries: typeof StateEntries;
-type index$l_StateEntryUpdate = StateEntryUpdate;
-type index$l_StateEntryUpdateAction = StateEntryUpdateAction;
-declare const index$l_StateEntryUpdateAction: typeof StateEntryUpdateAction;
-type index$l_StateKey = StateKey;
-type index$l_StateKeyIdx = StateKeyIdx;
-declare const index$l_StateKeyIdx: typeof StateKeyIdx;
-declare const index$l_binaryMerkleization: typeof binaryMerkleization;
-declare const index$l_dumpCodec: typeof dumpCodec;
-declare const index$l_legacyServiceNested: typeof legacyServiceNested;
-declare const index$l_loadState: typeof loadState;
-import index$l_serialize = serialize;
-declare const index$l_serializeStateUpdate: typeof serializeStateUpdate;
-import index$l_stateKeys = stateKeys;
-declare namespace index$l {
-  export { index$l_SerializedService as SerializedService, index$l_SerializedState as SerializedState, index$l_SerializedStateView as SerializedStateView, index$l_StateEntries as StateEntries, index$l_StateEntryUpdateAction as StateEntryUpdateAction, index$l_StateKeyIdx as StateKeyIdx, index$l_binaryMerkleization as binaryMerkleization, index$l_dumpCodec as dumpCodec, index$l_legacyServiceNested as legacyServiceNested, index$l_loadState as loadState, index$l_serialize as serialize, index$l_serializeStateUpdate as serializeStateUpdate, index$l_stateKeys as stateKeys };
-  export type { index$l_SerializedStateBackend as SerializedStateBackend, index$l_StateCodec as StateCodec, index$l_StateEntryUpdate as StateEntryUpdate, index$l_StateKey as StateKey };
-}
-
 /** Error during `LeafDb` creation. */
 declare enum LeafDbError {
     InvalidLeafData = 0
@@ -6821,28 +6559,37 @@ declare class InMemorySerializedStates implements StatesDb<SerializedState<LeafD
     close(): Promise<void>;
 }
 
-type index$k_BlocksDb = BlocksDb;
-type index$k_InMemoryBlocks = InMemoryBlocks;
-declare const index$k_InMemoryBlocks: typeof InMemoryBlocks;
-type index$k_InMemorySerializedStates = InMemorySerializedStates;
-declare const index$k_InMemorySerializedStates: typeof InMemorySerializedStates;
-type index$k_InMemoryStates = InMemoryStates;
-declare const index$k_InMemoryStates: typeof InMemoryStates;
-type index$k_InitStatesDb<T = State> = InitStatesDb<T>;
-type index$k_LeafDb = LeafDb;
-declare const index$k_LeafDb: typeof LeafDb;
-type index$k_LeafDbError = LeafDbError;
-declare const index$k_LeafDbError: typeof LeafDbError;
-type index$k_RootDb<TBlocks = BlocksDb, TStates = StatesDb> = RootDb<TBlocks, TStates>;
-type index$k_SerializedStatesDb = SerializedStatesDb;
-type index$k_StateUpdateError = StateUpdateError;
-declare const index$k_StateUpdateError: typeof StateUpdateError;
-type index$k_StatesDb<T extends State = State> = StatesDb<T>;
-type index$k_ValuesDb = ValuesDb;
-declare const index$k_updateLeafs: typeof updateLeafs;
-declare namespace index$k {
-  export { index$k_InMemoryBlocks as InMemoryBlocks, index$k_InMemorySerializedStates as InMemorySerializedStates, index$k_InMemoryStates as InMemoryStates, index$k_LeafDb as LeafDb, index$k_LeafDbError as LeafDbError, index$k_StateUpdateError as StateUpdateError, index$k_updateLeafs as updateLeafs };
-  export type { index$k_BlocksDb as BlocksDb, index$k_InitStatesDb as InitStatesDb, index$k_RootDb as RootDb, index$k_SerializedStatesDb as SerializedStatesDb, index$k_StatesDb as StatesDb, index$k_ValuesDb as ValuesDb };
+/**
+ * Database abstractions and storage interfaces.
+ *
+ * This module provides database interfaces and abstractions for persistent storage,
+ * supporting various backend implementations.
+ *
+ * @module database
+ */
+
+type database_BlocksDb = BlocksDb;
+type database_InMemoryBlocks = InMemoryBlocks;
+declare const database_InMemoryBlocks: typeof InMemoryBlocks;
+type database_InMemorySerializedStates = InMemorySerializedStates;
+declare const database_InMemorySerializedStates: typeof InMemorySerializedStates;
+type database_InMemoryStates = InMemoryStates;
+declare const database_InMemoryStates: typeof InMemoryStates;
+type database_InitStatesDb<T = State> = InitStatesDb<T>;
+type database_LeafDb = LeafDb;
+declare const database_LeafDb: typeof LeafDb;
+type database_LeafDbError = LeafDbError;
+declare const database_LeafDbError: typeof LeafDbError;
+type database_RootDb<TBlocks = BlocksDb, TStates = StatesDb> = RootDb<TBlocks, TStates>;
+type database_SerializedStatesDb = SerializedStatesDb;
+type database_StateUpdateError = StateUpdateError;
+declare const database_StateUpdateError: typeof StateUpdateError;
+type database_StatesDb<T extends State = State> = StatesDb<T>;
+type database_ValuesDb = ValuesDb;
+declare const database_updateLeafs: typeof updateLeafs;
+declare namespace database {
+  export { database_InMemoryBlocks as InMemoryBlocks, database_InMemorySerializedStates as InMemorySerializedStates, database_InMemoryStates as InMemoryStates, database_LeafDb as LeafDb, database_LeafDbError as LeafDbError, database_StateUpdateError as StateUpdateError, database_updateLeafs as updateLeafs };
+  export type { database_BlocksDb as BlocksDb, database_InitStatesDb as InitStatesDb, database_RootDb as RootDb, database_SerializedStatesDb as SerializedStatesDb, database_StatesDb as StatesDb, database_ValuesDb as ValuesDb };
 }
 
 /**
@@ -6985,29 +6732,38 @@ declare function chunksToShards(spec: ChainSpec, chunks: FixedSizeArray<BytesBlo
 
 declare const initEc: () => Promise<void>;
 
-declare const index$j_N_CHUNKS_REDUNDANCY: typeof N_CHUNKS_REDUNDANCY;
-type index$j_N_CHUNKS_REQUIRED = N_CHUNKS_REQUIRED;
-type index$j_N_CHUNKS_TOTAL = N_CHUNKS_TOTAL;
-type index$j_PIECE_SIZE = PIECE_SIZE;
-type index$j_POINT_LENGTH = POINT_LENGTH;
-declare const index$j_checkConsistency: typeof checkConsistency;
-declare const index$j_chunkingFunction: typeof chunkingFunction;
-declare const index$j_chunksToShards: typeof chunksToShards;
-declare const index$j_decodeData: typeof decodeData;
-declare const index$j_decodeDataAndTrim: typeof decodeDataAndTrim;
-declare const index$j_decodePiece: typeof decodePiece;
-declare const index$j_encodePoints: typeof encodePoints;
-declare const index$j_initEc: typeof initEc;
-declare const index$j_join: typeof join;
-declare const index$j_lace: typeof lace;
-declare const index$j_padAndEncodeData: typeof padAndEncodeData;
-declare const index$j_shardsToChunks: typeof shardsToChunks;
-declare const index$j_split: typeof split;
-declare const index$j_transpose: typeof transpose;
-declare const index$j_unzip: typeof unzip;
-declare namespace index$j {
-  export { index$j_N_CHUNKS_REDUNDANCY as N_CHUNKS_REDUNDANCY, index$j_checkConsistency as checkConsistency, index$j_chunkingFunction as chunkingFunction, index$j_chunksToShards as chunksToShards, index$j_decodeData as decodeData, index$j_decodeDataAndTrim as decodeDataAndTrim, index$j_decodePiece as decodePiece, index$j_encodePoints as encodePoints, index$j_initEc as initEc, index$j_join as join, index$j_lace as lace, index$j_padAndEncodeData as padAndEncodeData, index$j_shardsToChunks as shardsToChunks, index$j_split as split, index$j_transpose as transpose, index$j_unzip as unzip };
-  export type { index$j_N_CHUNKS_REQUIRED as N_CHUNKS_REQUIRED, index$j_N_CHUNKS_TOTAL as N_CHUNKS_TOTAL, index$j_PIECE_SIZE as PIECE_SIZE, index$j_POINT_LENGTH as POINT_LENGTH };
+/**
+ * Erasure coding implementation for data availability.
+ *
+ * This module provides erasure coding functionality used in JAM's data availability
+ * system, enabling data reconstruction from partial information.
+ *
+ * @module erasure-coding
+ */
+
+declare const erasureCoding_N_CHUNKS_REDUNDANCY: typeof N_CHUNKS_REDUNDANCY;
+type erasureCoding_N_CHUNKS_REQUIRED = N_CHUNKS_REQUIRED;
+type erasureCoding_N_CHUNKS_TOTAL = N_CHUNKS_TOTAL;
+type erasureCoding_PIECE_SIZE = PIECE_SIZE;
+type erasureCoding_POINT_LENGTH = POINT_LENGTH;
+declare const erasureCoding_checkConsistency: typeof checkConsistency;
+declare const erasureCoding_chunkingFunction: typeof chunkingFunction;
+declare const erasureCoding_chunksToShards: typeof chunksToShards;
+declare const erasureCoding_decodeData: typeof decodeData;
+declare const erasureCoding_decodeDataAndTrim: typeof decodeDataAndTrim;
+declare const erasureCoding_decodePiece: typeof decodePiece;
+declare const erasureCoding_encodePoints: typeof encodePoints;
+declare const erasureCoding_initEc: typeof initEc;
+declare const erasureCoding_join: typeof join;
+declare const erasureCoding_lace: typeof lace;
+declare const erasureCoding_padAndEncodeData: typeof padAndEncodeData;
+declare const erasureCoding_shardsToChunks: typeof shardsToChunks;
+declare const erasureCoding_split: typeof split;
+declare const erasureCoding_transpose: typeof transpose;
+declare const erasureCoding_unzip: typeof unzip;
+declare namespace erasureCoding {
+  export { erasureCoding_N_CHUNKS_REDUNDANCY as N_CHUNKS_REDUNDANCY, erasureCoding_checkConsistency as checkConsistency, erasureCoding_chunkingFunction as chunkingFunction, erasureCoding_chunksToShards as chunksToShards, erasureCoding_decodeData as decodeData, erasureCoding_decodeDataAndTrim as decodeDataAndTrim, erasureCoding_decodePiece as decodePiece, erasureCoding_encodePoints as encodePoints, erasureCoding_initEc as initEc, erasureCoding_join as join, erasureCoding_lace as lace, erasureCoding_padAndEncodeData as padAndEncodeData, erasureCoding_shardsToChunks as shardsToChunks, erasureCoding_split as split, erasureCoding_transpose as transpose, erasureCoding_unzip as unzip };
+  export type { erasureCoding_N_CHUNKS_REQUIRED as N_CHUNKS_REQUIRED, erasureCoding_N_CHUNKS_TOTAL as N_CHUNKS_TOTAL, erasureCoding_PIECE_SIZE as PIECE_SIZE, erasureCoding_POINT_LENGTH as POINT_LENGTH };
 }
 
 /** A per-client handler of incoming socket messages. */
@@ -7283,45 +7039,82 @@ declare class FuzzTarget implements IpcHandler {
     hasFeature(feature: number): boolean;
 }
 
-type index$i_Ancestry = Ancestry;
-type index$i_AncestryItem = AncestryItem;
-declare const index$i_AncestryItem: typeof AncestryItem;
-type index$i_ErrorMessage = ErrorMessage;
-declare const index$i_ErrorMessage: typeof ErrorMessage;
-type index$i_Features = Features;
-declare const index$i_Features: typeof Features;
-type index$i_FuzzMessageHandler = FuzzMessageHandler;
-type index$i_FuzzTarget = FuzzTarget;
-declare const index$i_FuzzTarget: typeof FuzzTarget;
-type index$i_GetState = GetState;
-type index$i_Initialize = Initialize;
-declare const index$i_Initialize: typeof Initialize;
-type index$i_KeyValue = KeyValue;
-declare const index$i_KeyValue: typeof KeyValue;
-type index$i_Message = Message;
-type index$i_MessageData = MessageData;
-type index$i_MessageType = MessageType;
-declare const index$i_MessageType: typeof MessageType;
-type index$i_PeerInfo = PeerInfo;
-declare const index$i_PeerInfo: typeof PeerInfo;
-type index$i_StateRoot = StateRoot;
-type index$i_Version = Version;
-declare const index$i_Version: typeof Version;
-declare const index$i_ancestryCodec: typeof ancestryCodec;
-declare const index$i_getStateCodec: typeof getStateCodec;
-declare const index$i_messageCodec: typeof messageCodec;
-declare const index$i_stateCodec: typeof stateCodec;
-declare const index$i_stateRootCodec: typeof stateRootCodec;
-declare namespace index$i {
-  export { index$i_AncestryItem as AncestryItem, index$i_ErrorMessage as ErrorMessage, index$i_Features as Features, index$i_FuzzTarget as FuzzTarget, index$i_Initialize as Initialize, index$i_KeyValue as KeyValue, index$i_MessageType as MessageType, index$i_PeerInfo as PeerInfo, index$i_Version as Version, index$i_ancestryCodec as ancestryCodec, index$i_getStateCodec as getStateCodec, index$i_messageCodec as messageCodec, index$i_stateCodec as stateCodec, index$i_stateRootCodec as stateRootCodec };
-  export type { index$i_Ancestry as Ancestry, index$i_FuzzMessageHandler as FuzzMessageHandler, index$i_GetState as GetState, index$i_Message as Message, index$i_MessageData as MessageData, index$i_StateRoot as StateRoot };
-}
-
-type index$h_IpcHandler = IpcHandler;
-type index$h_IpcSender = IpcSender;
-declare namespace index$h {
-  export { index$i as v1 };
-  export type { index$h_IpcHandler as IpcHandler, index$h_IpcSender as IpcSender };
+type index$6_Ancestry = Ancestry;
+type index$6_AncestryItem = AncestryItem;
+declare const index$6_AncestryItem: typeof AncestryItem;
+type index$6_ErrorMessage = ErrorMessage;
+declare const index$6_ErrorMessage: typeof ErrorMessage;
+type index$6_Features = Features;
+declare const index$6_Features: typeof Features;
+type index$6_FuzzMessageHandler = FuzzMessageHandler;
+type index$6_FuzzTarget = FuzzTarget;
+declare const index$6_FuzzTarget: typeof FuzzTarget;
+type index$6_GetState = GetState;
+type index$6_Initialize = Initialize;
+declare const index$6_Initialize: typeof Initialize;
+type index$6_KeyValue = KeyValue;
+declare const index$6_KeyValue: typeof KeyValue;
+type index$6_Message = Message;
+type index$6_MessageData = MessageData;
+type index$6_MessageType = MessageType;
+declare const index$6_MessageType: typeof MessageType;
+type index$6_PeerInfo = PeerInfo;
+declare const index$6_PeerInfo: typeof PeerInfo;
+type index$6_StateRoot = StateRoot;
+type index$6_Version = Version;
+declare const index$6_Version: typeof Version;
+declare const index$6_ancestryCodec: typeof ancestryCodec;
+declare const index$6_getStateCodec: typeof getStateCodec;
+declare const index$6_messageCodec: typeof messageCodec;
+declare const index$6_stateCodec: typeof stateCodec;
+declare const index$6_stateRootCodec: typeof stateRootCodec;
+declare namespace index$6 {
+  export { index$6_AncestryItem as AncestryItem, index$6_ErrorMessage as ErrorMessage, index$6_Features as Features, index$6_FuzzTarget as FuzzTarget, index$6_Initialize as Initialize, index$6_KeyValue as KeyValue, index$6_MessageType as MessageType, index$6_PeerInfo as PeerInfo, index$6_Version as Version, index$6_ancestryCodec as ancestryCodec, index$6_getStateCodec as getStateCodec, index$6_messageCodec as messageCodec, index$6_stateCodec as stateCodec, index$6_stateRootCodec as stateRootCodec };
+  export type { index$6_Ancestry as Ancestry, index$6_FuzzMessageHandler as FuzzMessageHandler, index$6_GetState as GetState, index$6_Message as Message, index$6_MessageData as MessageData, index$6_StateRoot as StateRoot };
+}
+
+/**
+ * Fuzzing protocol support and utilities.
+ *
+ * This module provides utilities and types for protocol fuzzing and testing,
+ * helping ensure robustness of the JAM implementation.
+ *
+ * @module fuzz-proto
+ */
+
+type fuzzProto_IpcHandler = IpcHandler;
+type fuzzProto_IpcSender = IpcSender;
+declare namespace fuzzProto {
+  export { index$6 as v1 };
+  export type { fuzzProto_IpcHandler as IpcHandler, fuzzProto_IpcSender as IpcSender };
+}
+
+/**
+ * Hashing functions and utilities.
+ *
+ * This module provides cryptographic hash functions including Blake2b and other
+ * hashing algorithms used throughout the JAM protocol.
+ *
+ * @module hash
+ */
+
+type hash_Blake2b = Blake2b;
+declare const hash_Blake2b: typeof Blake2b;
+type hash_Blake2bHash = Blake2bHash;
+type hash_HASH_SIZE = HASH_SIZE;
+type hash_KeccakHash = KeccakHash;
+type hash_OpaqueHash = OpaqueHash;
+type hash_TRUNCATED_HASH_SIZE = TRUNCATED_HASH_SIZE;
+type hash_TruncatedHash = TruncatedHash;
+type hash_WithHash<THash extends OpaqueHash, TData> = WithHash<THash, TData>;
+declare const hash_WithHash: typeof WithHash;
+type hash_WithHashAndBytes<THash extends OpaqueHash, TData> = WithHashAndBytes<THash, TData>;
+declare const hash_WithHashAndBytes: typeof WithHashAndBytes;
+declare const hash_ZERO_HASH: typeof ZERO_HASH;
+declare const hash_keccak: typeof keccak;
+declare namespace hash {
+  export { hash_Blake2b as Blake2b, hash_WithHash as WithHash, hash_WithHashAndBytes as WithHashAndBytes, hash_ZERO_HASH as ZERO_HASH, hash_keccak as keccak };
+  export type { hash_Blake2bHash as Blake2bHash, hash_HASH_SIZE as HASH_SIZE, hash_KeccakHash as KeccakHash, hash_OpaqueHash as OpaqueHash, hash_TRUNCATED_HASH_SIZE as TRUNCATED_HASH_SIZE, hash_TruncatedHash as TruncatedHash };
 }
 
 /**
@@ -7495,37 +7288,6 @@ declare function startSameThread<To, From>(protocol: LousyProtocol<To, From>): {
     internal: Internal<LousyProtocol<To, From>>;
 };
 
-type index$g_Api<T> = Api<T>;
-type index$g_Channel = Channel;
-declare const index$g_Channel: typeof Channel;
-type index$g_Destroy = Destroy;
-type index$g_DirectPort = DirectPort;
-declare const index$g_DirectPort: typeof DirectPort;
-type index$g_DirectWorkerConfig<TParams = void, TBlocks = BlocksDb, TStates = StatesDb> = DirectWorkerConfig<TParams, TBlocks, TStates>;
-declare const index$g_DirectWorkerConfig: typeof DirectWorkerConfig;
-type index$g_Envelope<T> = Envelope<T>;
-type index$g_Handler<Req, Res> = Handler<Req, Res>;
-type index$g_HandlerKey<K> = HandlerKey<K>;
-type index$g_Handlers<In> = Handlers<In>;
-type index$g_Internal<T> = Internal<T>;
-type index$g_LousyProtocol<To, From> = LousyProtocol<To, From>;
-type index$g_MessageCodecs<Req, Res> = MessageCodecs<Req, Res>;
-type index$g_MessagesList<T> = MessagesList<T>;
-type index$g_Port = Port;
-type index$g_Protocol<To, From> = Protocol<To, From>;
-type index$g_Rx<To, From> = Rx<To, From>;
-type index$g_Sender<Req, Res> = Sender<Req, Res>;
-type index$g_SenderKey<K> = SenderKey<K>;
-type index$g_Senders<Out> = Senders<Out>;
-type index$g_Tx<To, From> = Tx<To, From>;
-type index$g_WorkerConfig<TParams = void, TBlocks = BlocksDb, TStates = StatesDb> = WorkerConfig<TParams, TBlocks, TStates>;
-declare const index$g_createProtocol: typeof createProtocol;
-declare const index$g_startSameThread: typeof startSameThread;
-declare namespace index$g {
-  export { index$g_Channel as Channel, index$g_DirectPort as DirectPort, index$g_DirectWorkerConfig as DirectWorkerConfig, index$g_createProtocol as createProtocol, index$g_startSameThread as startSameThread };
-  export type { index$g_Api as Api, index$g_Destroy as Destroy, index$g_Envelope as Envelope, index$g_Handler as Handler, index$g_HandlerKey as HandlerKey, index$g_Handlers as Handlers, index$g_Internal as Internal, index$g_LousyProtocol as LousyProtocol, index$g_MessageCodecs as MessageCodecs, index$g_MessagesList as MessagesList, index$g_Port as Port, index$g_Protocol as Protocol, index$g_Rx as Rx, index$g_Sender as Sender, index$g_SenderKey as SenderKey, index$g_Senders as Senders, index$g_Tx as Tx, index$g_WorkerConfig as WorkerConfig };
-}
-
 declare enum Level {
     INSANE = 1,
     TRACE = 2,
@@ -7654,22 +7416,6 @@ declare class Logger {
     error(strings: TemplateStringsArray, ...data: unknown[]): void;
 }
 
-type index$f_ConsoleTransport = ConsoleTransport;
-declare const index$f_ConsoleTransport: typeof ConsoleTransport;
-type index$f_Level = Level;
-declare const index$f_Level: typeof Level;
-type index$f_Logger = Logger;
-declare const index$f_Logger: typeof Logger;
-type index$f_Options = Options;
-type index$f_Transport = Transport;
-type index$f_TransportBuilder = TransportBuilder;
-declare const index$f_findLevel: typeof findLevel;
-declare const index$f_parseLoggerOptions: typeof parseLoggerOptions;
-declare namespace index$f {
-  export { index$f_ConsoleTransport as ConsoleTransport, index$f_Level as Level, index$f_Logger as Logger, index$f_findLevel as findLevel, index$f_parseLoggerOptions as parseLoggerOptions };
-  export type { index$f_Options as Options, index$f_Transport as Transport, index$f_TransportBuilder as TransportBuilder };
-}
-
 /** A U64 version of `Gas`. */
 type BigGas = Opaque<U64, "BigGas[U64]">;
 /** A U32 version of `Gas`. */
@@ -7787,28 +7533,6 @@ interface IPvmInterpreter {
     getExitParam(): U32 | null;
 }
 
-type index$e_BigGas = BigGas;
-type index$e_Gas = Gas;
-type index$e_IGasCounter = IGasCounter;
-type index$e_IMemory = IMemory;
-type index$e_IPvmInterpreter = IPvmInterpreter;
-type index$e_IRegisters = IRegisters;
-declare const index$e_MAX_MEMORY_INDEX: typeof MAX_MEMORY_INDEX;
-declare const index$e_MEMORY_SIZE: typeof MEMORY_SIZE;
-declare const index$e_NO_OF_REGISTERS: typeof NO_OF_REGISTERS;
-declare const index$e_REGISTER_BYTE_SIZE: typeof REGISTER_BYTE_SIZE;
-type index$e_SmallGas = SmallGas;
-type index$e_Status = Status;
-declare const index$e_Status: typeof Status;
-declare const index$e_getPageStartAddress: typeof getPageStartAddress;
-declare const index$e_tryAsBigGas: typeof tryAsBigGas;
-declare const index$e_tryAsGas: typeof tryAsGas;
-declare const index$e_tryAsSmallGas: typeof tryAsSmallGas;
-declare namespace index$e {
-  export { index$e_MAX_MEMORY_INDEX as MAX_MEMORY_INDEX, index$e_MEMORY_SIZE as MEMORY_SIZE, index$e_NO_OF_REGISTERS as NO_OF_REGISTERS, index$e_REGISTER_BYTE_SIZE as REGISTER_BYTE_SIZE, index$e_Status as Status, index$e_getPageStartAddress as getPageStartAddress, index$e_tryAsBigGas as tryAsBigGas, index$e_tryAsGas as tryAsGas, index$e_tryAsSmallGas as tryAsSmallGas };
-  export type { index$e_BigGas as BigGas, index$e_Gas as Gas, index$e_IGasCounter as IGasCounter, index$e_IMemory as IMemory, index$e_IPvmInterpreter as IPvmInterpreter, index$e_IRegisters as IRegisters, PageFault$1 as PageFault, index$e_SmallGas as SmallGas };
-}
-
 type RegisterIndex = Opaque<number, "register index">;
 declare const tryAsRegisterIndex: (index: number) => RegisterIndex;
 declare class Registers implements IRegisters {
@@ -7950,20 +7674,6 @@ declare class HostCalls {
     runProgram(program: Uint8Array, args: Uint8Array, initialPc: number, initialGas: Gas): Promise<ReturnValue>;
 }
 
-type index$d_HostCallHandler = HostCallHandler;
-type index$d_HostCallMemory = HostCallMemory;
-declare const index$d_HostCallMemory: typeof HostCallMemory;
-type index$d_HostCallRegisters = HostCallRegisters;
-declare const index$d_HostCallRegisters: typeof HostCallRegisters;
-type index$d_PvmExecution = PvmExecution;
-declare const index$d_PvmExecution: typeof PvmExecution;
-declare const index$d_traceRegisters: typeof traceRegisters;
-declare const index$d_tryAsHostCallIndex: typeof tryAsHostCallIndex;
-declare namespace index$d {
-  export { index$d_HostCallMemory as HostCallMemory, index$d_HostCallRegisters as HostCallRegisters, HostCallsManager as HostCalls, index$d_PvmExecution as PvmExecution, HostCalls as PvmHostCallExtension, InterpreterInstanceManager as PvmInstanceManager, index$d_traceRegisters as traceRegisters, index$d_tryAsHostCallIndex as tryAsHostCallIndex };
-  export type { index$d_HostCallHandler as HostCallHandler };
-}
-
 /** Size of the transfer memo. */
 declare const TRANSFER_MEMO_BYTES = 128;
 type TRANSFER_MEMO_BYTES = typeof TRANSFER_MEMO_BYTES;
@@ -8369,49 +8079,49 @@ declare class Yield implements HostCallHandler {
     execute(_gas: IGasCounter, regs: HostCallRegisters, memory: HostCallMemory): Promise<PvmExecution | undefined>;
 }
 
-type index$c_Assign = Assign;
-declare const index$c_Assign: typeof Assign;
-type index$c_Bless = Bless;
-declare const index$c_Bless: typeof Bless;
-type index$c_Checkpoint = Checkpoint;
-declare const index$c_Checkpoint: typeof Checkpoint;
-type index$c_Designate = Designate;
-declare const index$c_Designate: typeof Designate;
-type index$c_Eject = Eject;
-declare const index$c_Eject: typeof Eject;
-type index$c_Forget = Forget;
-declare const index$c_Forget: typeof Forget;
-type index$c_New = New;
-declare const index$c_New: typeof New;
-type index$c_Provide = Provide;
-declare const index$c_Provide: typeof Provide;
-type index$c_Query = Query;
-declare const index$c_Query: typeof Query;
-type index$c_Solicit = Solicit;
-declare const index$c_Solicit: typeof Solicit;
-type index$c_Transfer = Transfer;
-declare const index$c_Transfer: typeof Transfer;
-type index$c_Upgrade = Upgrade;
-declare const index$c_Upgrade: typeof Upgrade;
-declare const index$c_VALIDATOR_DATA_BYTES: typeof VALIDATOR_DATA_BYTES;
-type index$c_Yield = Yield;
-declare const index$c_Yield: typeof Yield;
-declare namespace index$c {
+type index$5_Assign = Assign;
+declare const index$5_Assign: typeof Assign;
+type index$5_Bless = Bless;
+declare const index$5_Bless: typeof Bless;
+type index$5_Checkpoint = Checkpoint;
+declare const index$5_Checkpoint: typeof Checkpoint;
+type index$5_Designate = Designate;
+declare const index$5_Designate: typeof Designate;
+type index$5_Eject = Eject;
+declare const index$5_Eject: typeof Eject;
+type index$5_Forget = Forget;
+declare const index$5_Forget: typeof Forget;
+type index$5_New = New;
+declare const index$5_New: typeof New;
+type index$5_Provide = Provide;
+declare const index$5_Provide: typeof Provide;
+type index$5_Query = Query;
+declare const index$5_Query: typeof Query;
+type index$5_Solicit = Solicit;
+declare const index$5_Solicit: typeof Solicit;
+type index$5_Transfer = Transfer;
+declare const index$5_Transfer: typeof Transfer;
+type index$5_Upgrade = Upgrade;
+declare const index$5_Upgrade: typeof Upgrade;
+declare const index$5_VALIDATOR_DATA_BYTES: typeof VALIDATOR_DATA_BYTES;
+type index$5_Yield = Yield;
+declare const index$5_Yield: typeof Yield;
+declare namespace index$5 {
   export {
-    index$c_Assign as Assign,
-    index$c_Bless as Bless,
-    index$c_Checkpoint as Checkpoint,
-    index$c_Designate as Designate,
-    index$c_Eject as Eject,
-    index$c_Forget as Forget,
-    index$c_New as New,
-    index$c_Provide as Provide,
-    index$c_Query as Query,
-    index$c_Solicit as Solicit,
-    index$c_Transfer as Transfer,
-    index$c_Upgrade as Upgrade,
-    index$c_VALIDATOR_DATA_BYTES as VALIDATOR_DATA_BYTES,
-    index$c_Yield as Yield,
+    index$5_Assign as Assign,
+    index$5_Bless as Bless,
+    index$5_Checkpoint as Checkpoint,
+    index$5_Designate as Designate,
+    index$5_Eject as Eject,
+    index$5_Forget as Forget,
+    index$5_New as New,
+    index$5_Provide as Provide,
+    index$5_Query as Query,
+    index$5_Solicit as Solicit,
+    index$5_Transfer as Transfer,
+    index$5_Upgrade as Upgrade,
+    index$5_VALIDATOR_DATA_BYTES as VALIDATOR_DATA_BYTES,
+    index$5_Yield as Yield,
   };
 }
 
@@ -9136,35 +8846,35 @@ declare class Write implements HostCallHandler {
     execute(_gas: IGasCounter, regs: HostCallRegisters, memory: HostCallMemory): Promise<undefined | PvmExecution>;
 }
 
-type index$b_AccountsInfo = AccountsInfo;
-type index$b_AccountsLookup = AccountsLookup;
-type index$b_AccountsRead = AccountsRead;
-type index$b_AccountsWrite = AccountsWrite;
-type index$b_Fetch = Fetch;
-declare const index$b_Fetch: typeof Fetch;
-type index$b_FetchKind = FetchKind;
-declare const index$b_FetchKind: typeof FetchKind;
-type index$b_GasHostCall = GasHostCall;
-declare const index$b_GasHostCall: typeof GasHostCall;
-declare const index$b_HostCallResult: typeof HostCallResult;
-type index$b_IFetchExternalities = IFetchExternalities;
-type index$b_Info = Info;
-declare const index$b_Info: typeof Info;
-declare const index$b_LEN_REG: typeof LEN_REG;
-type index$b_LogHostCall = LogHostCall;
-declare const index$b_LogHostCall: typeof LogHostCall;
-type index$b_Lookup = Lookup;
-declare const index$b_Lookup: typeof Lookup;
-type index$b_Missing = Missing;
-declare const index$b_Missing: typeof Missing;
-type index$b_Read = Read;
-declare const index$b_Read: typeof Read;
-type index$b_Write = Write;
-declare const index$b_Write: typeof Write;
-declare const index$b_codecServiceAccountInfoWithThresholdBalance: typeof codecServiceAccountInfoWithThresholdBalance;
-declare namespace index$b {
-  export { index$b_Fetch as Fetch, index$b_FetchKind as FetchKind, index$b_GasHostCall as GasHostCall, index$b_HostCallResult as HostCallResult, index$b_Info as Info, index$b_LEN_REG as LEN_REG, index$b_LogHostCall as LogHostCall, index$b_Lookup as Lookup, index$b_Missing as Missing, index$b_Read as Read, index$b_Write as Write, index$b_codecServiceAccountInfoWithThresholdBalance as codecServiceAccountInfoWithThresholdBalance };
-  export type { index$b_AccountsInfo as AccountsInfo, index$b_AccountsLookup as AccountsLookup, index$b_AccountsRead as AccountsRead, index$b_AccountsWrite as AccountsWrite, index$b_IFetchExternalities as IFetchExternalities };
+type index$4_AccountsInfo = AccountsInfo;
+type index$4_AccountsLookup = AccountsLookup;
+type index$4_AccountsRead = AccountsRead;
+type index$4_AccountsWrite = AccountsWrite;
+type index$4_Fetch = Fetch;
+declare const index$4_Fetch: typeof Fetch;
+type index$4_FetchKind = FetchKind;
+declare const index$4_FetchKind: typeof FetchKind;
+type index$4_GasHostCall = GasHostCall;
+declare const index$4_GasHostCall: typeof GasHostCall;
+declare const index$4_HostCallResult: typeof HostCallResult;
+type index$4_IFetchExternalities = IFetchExternalities;
+type index$4_Info = Info;
+declare const index$4_Info: typeof Info;
+declare const index$4_LEN_REG: typeof LEN_REG;
+type index$4_LogHostCall = LogHostCall;
+declare const index$4_LogHostCall: typeof LogHostCall;
+type index$4_Lookup = Lookup;
+declare const index$4_Lookup: typeof Lookup;
+type index$4_Missing = Missing;
+declare const index$4_Missing: typeof Missing;
+type index$4_Read = Read;
+declare const index$4_Read: typeof Read;
+type index$4_Write = Write;
+declare const index$4_Write: typeof Write;
+declare const index$4_codecServiceAccountInfoWithThresholdBalance: typeof codecServiceAccountInfoWithThresholdBalance;
+declare namespace index$4 {
+  export { index$4_Fetch as Fetch, index$4_FetchKind as FetchKind, index$4_GasHostCall as GasHostCall, index$4_HostCallResult as HostCallResult, index$4_Info as Info, index$4_LEN_REG as LEN_REG, index$4_LogHostCall as LogHostCall, index$4_Lookup as Lookup, index$4_Missing as Missing, index$4_Read as Read, index$4_Write as Write, index$4_codecServiceAccountInfoWithThresholdBalance as codecServiceAccountInfoWithThresholdBalance };
+  export type { index$4_AccountsInfo as AccountsInfo, index$4_AccountsLookup as AccountsLookup, index$4_AccountsRead as AccountsRead, index$4_AccountsWrite as AccountsWrite, index$4_IFetchExternalities as IFetchExternalities };
 }
 
 /**
@@ -9288,32 +8998,32 @@ declare class Poke implements HostCallHandler {
     execute(_gas: IGasCounter, regs: HostCallRegisters, memory: HostCallMemory): Promise<PvmExecution | undefined>;
 }
 
-type index$a_Export = Export;
-declare const index$a_Export: typeof Export;
-type index$a_Expunge = Expunge;
-declare const index$a_Expunge: typeof Expunge;
-type index$a_HistoricalLookup = HistoricalLookup;
-declare const index$a_HistoricalLookup: typeof HistoricalLookup;
-type index$a_Invoke = Invoke;
-declare const index$a_Invoke: typeof Invoke;
-type index$a_Machine = Machine;
-declare const index$a_Machine: typeof Machine;
-type index$a_Pages = Pages;
-declare const index$a_Pages: typeof Pages;
-type index$a_Peek = Peek;
-declare const index$a_Peek: typeof Peek;
-type index$a_Poke = Poke;
-declare const index$a_Poke: typeof Poke;
-declare namespace index$a {
+type index$3_Export = Export;
+declare const index$3_Export: typeof Export;
+type index$3_Expunge = Expunge;
+declare const index$3_Expunge: typeof Expunge;
+type index$3_HistoricalLookup = HistoricalLookup;
+declare const index$3_HistoricalLookup: typeof HistoricalLookup;
+type index$3_Invoke = Invoke;
+declare const index$3_Invoke: typeof Invoke;
+type index$3_Machine = Machine;
+declare const index$3_Machine: typeof Machine;
+type index$3_Pages = Pages;
+declare const index$3_Pages: typeof Pages;
+type index$3_Peek = Peek;
+declare const index$3_Peek: typeof Peek;
+type index$3_Poke = Poke;
+declare const index$3_Poke: typeof Poke;
+declare namespace index$3 {
   export {
-    index$a_Export as Export,
-    index$a_Expunge as Expunge,
-    index$a_HistoricalLookup as HistoricalLookup,
-    index$a_Invoke as Invoke,
-    index$a_Machine as Machine,
-    index$a_Pages as Pages,
-    index$a_Peek as Peek,
-    index$a_Poke as Poke,
+    index$3_Export as Export,
+    index$3_Expunge as Expunge,
+    index$3_HistoricalLookup as HistoricalLookup,
+    index$3_Invoke as Invoke,
+    index$3_Machine as Machine,
+    index$3_Pages as Pages,
+    index$3_Peek as Peek,
+    index$3_Poke as Poke,
   };
 }
 
@@ -9326,68 +9036,6 @@ declare function writeServiceIdAsLeBytes(serviceId: ServiceId, destination: Uint
 declare function clampU64ToU32(value: U64): U32;
 declare function emptyRegistersBuffer(): Uint8Array;
 
-type index$9_AccumulationStateUpdate = AccumulationStateUpdate;
-declare const index$9_AccumulationStateUpdate: typeof AccumulationStateUpdate;
-declare const index$9_CURRENT_SERVICE_ID: typeof CURRENT_SERVICE_ID;
-type index$9_EjectError = EjectError;
-declare const index$9_EjectError: typeof EjectError;
-type index$9_ForgetPreimageError = ForgetPreimageError;
-declare const index$9_ForgetPreimageError: typeof ForgetPreimageError;
-declare const index$9_HostCallResult: typeof HostCallResult;
-type index$9_InsufficientFundsError = InsufficientFundsError;
-type index$9_MachineId = MachineId;
-type index$9_MachineInstance = MachineInstance;
-declare const index$9_MachineInstance: typeof MachineInstance;
-type index$9_MachineResult = MachineResult;
-type index$9_MachineStatus = MachineStatus;
-type index$9_MemoryOperation = MemoryOperation;
-declare const index$9_MemoryOperation: typeof MemoryOperation;
-type index$9_NewServiceError = NewServiceError;
-declare const index$9_NewServiceError: typeof NewServiceError;
-type index$9_NoMachineError = NoMachineError;
-type index$9_PagesError = PagesError;
-declare const index$9_PagesError: typeof PagesError;
-type index$9_PartialState = PartialState;
-type index$9_PartiallyUpdatedState<T extends StateSlice = StateSlice> = PartiallyUpdatedState<T>;
-declare const index$9_PartiallyUpdatedState: typeof PartiallyUpdatedState;
-type index$9_PeekPokeError = PeekPokeError;
-declare const index$9_PeekPokeError: typeof PeekPokeError;
-type index$9_PendingTransfer = PendingTransfer;
-declare const index$9_PendingTransfer: typeof PendingTransfer;
-type index$9_PreimageStatus = PreimageStatus;
-type index$9_PreimageStatusKind = PreimageStatusKind;
-declare const index$9_PreimageStatusKind: typeof PreimageStatusKind;
-type index$9_ProgramCounter = ProgramCounter;
-type index$9_ProvidePreimageError = ProvidePreimageError;
-declare const index$9_ProvidePreimageError: typeof ProvidePreimageError;
-type index$9_RefineExternalities = RefineExternalities;
-type index$9_RequestPreimageError = RequestPreimageError;
-declare const index$9_RequestPreimageError: typeof RequestPreimageError;
-declare const index$9_SERVICE_ID_BYTES: typeof SERVICE_ID_BYTES;
-type index$9_SegmentExportError = SegmentExportError;
-type index$9_ServiceStateUpdate = ServiceStateUpdate;
-type index$9_TRANSFER_MEMO_BYTES = TRANSFER_MEMO_BYTES;
-type index$9_TransferError = TransferError;
-declare const index$9_TransferError: typeof TransferError;
-type index$9_UnprivilegedError = UnprivilegedError;
-type index$9_UpdatePrivilegesError = UpdatePrivilegesError;
-declare const index$9_UpdatePrivilegesError: typeof UpdatePrivilegesError;
-type index$9_ZeroVoidError = ZeroVoidError;
-declare const index$9_ZeroVoidError: typeof ZeroVoidError;
-declare const index$9_clampU64ToU32: typeof clampU64ToU32;
-declare const index$9_emptyRegistersBuffer: typeof emptyRegistersBuffer;
-declare const index$9_getServiceId: typeof getServiceId;
-declare const index$9_getServiceIdOrCurrent: typeof getServiceIdOrCurrent;
-declare const index$9_slotsToPreimageStatus: typeof slotsToPreimageStatus;
-declare const index$9_toMemoryOperation: typeof toMemoryOperation;
-declare const index$9_tryAsMachineId: typeof tryAsMachineId;
-declare const index$9_tryAsProgramCounter: typeof tryAsProgramCounter;
-declare const index$9_writeServiceIdAsLeBytes: typeof writeServiceIdAsLeBytes;
-declare namespace index$9 {
-  export { index$9_AccumulationStateUpdate as AccumulationStateUpdate, index$9_CURRENT_SERVICE_ID as CURRENT_SERVICE_ID, index$9_EjectError as EjectError, index$9_ForgetPreimageError as ForgetPreimageError, index$9_HostCallResult as HostCallResult, index$9_MachineInstance as MachineInstance, index$9_MemoryOperation as MemoryOperation, index$9_NewServiceError as NewServiceError, index$9_PagesError as PagesError, index$9_PartiallyUpdatedState as PartiallyUpdatedState, index$9_PeekPokeError as PeekPokeError, index$9_PendingTransfer as PendingTransfer, index$9_PreimageStatusKind as PreimageStatusKind, index$9_ProvidePreimageError as ProvidePreimageError, index$9_RequestPreimageError as RequestPreimageError, index$9_SERVICE_ID_BYTES as SERVICE_ID_BYTES, index$9_TransferError as TransferError, index$9_UpdatePrivilegesError as UpdatePrivilegesError, index$9_ZeroVoidError as ZeroVoidError, index$c as accumulate, index$9_clampU64ToU32 as clampU64ToU32, index$9_emptyRegistersBuffer as emptyRegistersBuffer, index$b as general, index$9_getServiceId as getServiceId, index$9_getServiceIdOrCurrent as getServiceIdOrCurrent, codecServiceAccountInfoWithThresholdBalance as hostCallInfoAccount, index$a as refine, index$9_slotsToPreimageStatus as slotsToPreimageStatus, index$9_toMemoryOperation as toMemoryOperation, index$9_tryAsMachineId as tryAsMachineId, index$9_tryAsProgramCounter as tryAsProgramCounter, index$9_writeServiceIdAsLeBytes as writeServiceIdAsLeBytes };
-  export type { index$9_InsufficientFundsError as InsufficientFundsError, index$9_MachineId as MachineId, index$9_MachineResult as MachineResult, index$9_MachineStatus as MachineStatus, index$9_NoMachineError as NoMachineError, index$9_PartialState as PartialState, index$9_PreimageStatus as PreimageStatus, index$9_ProgramCounter as ProgramCounter, index$9_RefineExternalities as RefineExternalities, index$9_SegmentExportError as SegmentExportError, index$9_ServiceStateUpdate as ServiceStateUpdate, index$9_TRANSFER_MEMO_BYTES as TRANSFER_MEMO_BYTES, index$9_UnprivilegedError as UnprivilegedError };
-}
-
 type Input = {
     slot: TimeSlot;
     authorIndex: ValidatorIndex;
@@ -10252,14 +9900,14 @@ declare class FetchExternalities implements IFetchExternalities {
     oneTransferOrOperand(index: U64): BytesBlob | null;
 }
 
-type index$8_AccumulateExternalities = AccumulateExternalities;
-declare const index$8_AccumulateExternalities: typeof AccumulateExternalities;
-type index$8_FetchExternalities = FetchExternalities;
-declare const index$8_FetchExternalities: typeof FetchExternalities;
-type index$8_TransferOrOperand = TransferOrOperand;
-declare namespace index$8 {
-  export { index$8_AccumulateExternalities as AccumulateExternalities, index$8_FetchExternalities as FetchExternalities };
-  export type { index$8_TransferOrOperand as TransferOrOperand };
+type index$2_AccumulateExternalities = AccumulateExternalities;
+declare const index$2_AccumulateExternalities: typeof AccumulateExternalities;
+type index$2_FetchExternalities = FetchExternalities;
+declare const index$2_FetchExternalities: typeof FetchExternalities;
+type index$2_TransferOrOperand = TransferOrOperand;
+declare namespace index$2 {
+  export { index$2_AccumulateExternalities as AccumulateExternalities, index$2_FetchExternalities as FetchExternalities };
+  export type { index$2_TransferOrOperand as TransferOrOperand };
 }
 
 /**
@@ -10272,88 +9920,6 @@ declare function copyAndUpdateState<T extends Partial<State>>(preState: T, state
     [K in keyof T]: T[K];
 };
 
-type index$7_ACCUMULATION_ERROR = ACCUMULATION_ERROR;
-type index$7_Accumulate = Accumulate;
-declare const index$7_Accumulate: typeof Accumulate;
-type index$7_AccumulateInput = AccumulateInput;
-type index$7_AccumulateOptions = AccumulateOptions;
-type index$7_AccumulateResult = AccumulateResult;
-type index$7_AccumulateRoot = AccumulateRoot;
-type index$7_AccumulateState = AccumulateState;
-type index$7_AccumulateStateUpdate = AccumulateStateUpdate;
-type index$7_Assurances = Assurances;
-declare const index$7_Assurances: typeof Assurances;
-type index$7_AssurancesError = AssurancesError;
-declare const index$7_AssurancesError: typeof AssurancesError;
-type index$7_AssurancesInput = AssurancesInput;
-type index$7_AssurancesState = AssurancesState;
-type index$7_AssurancesStateUpdate = AssurancesStateUpdate;
-type index$7_Authorization = Authorization;
-declare const index$7_Authorization: typeof Authorization;
-type index$7_AuthorizationInput = AuthorizationInput;
-type index$7_AuthorizationState = AuthorizationState;
-type index$7_AuthorizationStateUpdate = AuthorizationStateUpdate;
-type index$7_BlockVerifier = BlockVerifier;
-declare const index$7_BlockVerifier: typeof BlockVerifier;
-type index$7_BlockVerifierError = BlockVerifierError;
-declare const index$7_BlockVerifierError: typeof BlockVerifierError;
-type index$7_CountAndGasUsed = CountAndGasUsed;
-type index$7_DbHeaderChain = DbHeaderChain;
-declare const index$7_DbHeaderChain: typeof DbHeaderChain;
-type index$7_DeferredTransfers = DeferredTransfers;
-declare const index$7_DeferredTransfers: typeof DeferredTransfers;
-type index$7_DeferredTransfersErrorCode = DeferredTransfersErrorCode;
-declare const index$7_DeferredTransfersErrorCode: typeof DeferredTransfersErrorCode;
-type index$7_DeferredTransfersResult = DeferredTransfersResult;
-type index$7_DeferredTransfersState = DeferredTransfersState;
-type index$7_Disputes = Disputes;
-declare const index$7_Disputes: typeof Disputes;
-type index$7_DisputesState = DisputesState;
-type index$7_DisputesStateUpdate = DisputesStateUpdate;
-declare const index$7_GAS_TO_INVOKE_WORK_REPORT: typeof GAS_TO_INVOKE_WORK_REPORT;
-type index$7_HeaderChain = HeaderChain;
-type index$7_Input = Input;
-type index$7_Ok = Ok;
-type index$7_OnChain = OnChain;
-declare const index$7_OnChain: typeof OnChain;
-type index$7_Preimages = Preimages;
-declare const index$7_Preimages: typeof Preimages;
-type index$7_PreimagesErrorCode = PreimagesErrorCode;
-declare const index$7_PreimagesErrorCode: typeof PreimagesErrorCode;
-type index$7_PreimagesInput = PreimagesInput;
-type index$7_PreimagesState = PreimagesState;
-type index$7_PreimagesStateUpdate = PreimagesStateUpdate;
-declare const index$7_REPORT_TIMEOUT_GRACE_PERIOD: typeof REPORT_TIMEOUT_GRACE_PERIOD;
-type index$7_RecentHistory = RecentHistory;
-declare const index$7_RecentHistory: typeof RecentHistory;
-type index$7_RecentHistoryInput = RecentHistoryInput;
-type index$7_RecentHistoryPartialInput = RecentHistoryPartialInput;
-type index$7_RecentHistoryState = RecentHistoryState;
-type index$7_RecentHistoryStateUpdate = RecentHistoryStateUpdate;
-type index$7_Reports = Reports;
-declare const index$7_Reports: typeof Reports;
-type index$7_ReportsError = ReportsError;
-declare const index$7_ReportsError: typeof ReportsError;
-type index$7_ReportsInput = ReportsInput;
-type index$7_ReportsOutput = ReportsOutput;
-type index$7_ReportsState = ReportsState;
-type index$7_ReportsStateUpdate = ReportsStateUpdate;
-type index$7_Statistics = Statistics;
-declare const index$7_Statistics: typeof Statistics;
-type index$7_StatisticsState = StatisticsState;
-type index$7_StatisticsStateUpdate = StatisticsStateUpdate;
-type index$7_StfError = StfError;
-type index$7_StfErrorKind = StfErrorKind;
-declare const index$7_StfErrorKind: typeof StfErrorKind;
-type index$7_TransitionHasher = TransitionHasher;
-declare const index$7_TransitionHasher: typeof TransitionHasher;
-declare const index$7_copyAndUpdateState: typeof copyAndUpdateState;
-declare const index$7_stfError: typeof stfError;
-declare namespace index$7 {
-  export { index$7_Accumulate as Accumulate, index$7_Assurances as Assurances, index$7_AssurancesError as AssurancesError, index$7_Authorization as Authorization, index$7_BlockVerifier as BlockVerifier, index$7_BlockVerifierError as BlockVerifierError, index$7_DbHeaderChain as DbHeaderChain, index$7_DeferredTransfers as DeferredTransfers, index$7_DeferredTransfersErrorCode as DeferredTransfersErrorCode, index$7_Disputes as Disputes, index$7_GAS_TO_INVOKE_WORK_REPORT as GAS_TO_INVOKE_WORK_REPORT, index$7_OnChain as OnChain, index$7_Preimages as Preimages, index$7_PreimagesErrorCode as PreimagesErrorCode, index$7_REPORT_TIMEOUT_GRACE_PERIOD as REPORT_TIMEOUT_GRACE_PERIOD, index$7_RecentHistory as RecentHistory, index$7_Reports as Reports, index$7_ReportsError as ReportsError, index$7_Statistics as Statistics, index$7_StfErrorKind as StfErrorKind, index$7_TransitionHasher as TransitionHasher, index$7_copyAndUpdateState as copyAndUpdateState, index$8 as externalities, index$7_stfError as stfError };
-  export type { index$7_ACCUMULATION_ERROR as ACCUMULATION_ERROR, index$7_AccumulateInput as AccumulateInput, index$7_AccumulateOptions as AccumulateOptions, index$7_AccumulateResult as AccumulateResult, index$7_AccumulateRoot as AccumulateRoot, index$7_AccumulateState as AccumulateState, index$7_AccumulateStateUpdate as AccumulateStateUpdate, index$7_AssurancesInput as AssurancesInput, index$7_AssurancesState as AssurancesState, index$7_AssurancesStateUpdate as AssurancesStateUpdate, index$7_AuthorizationInput as AuthorizationInput, index$7_AuthorizationState as AuthorizationState, index$7_AuthorizationStateUpdate as AuthorizationStateUpdate, index$7_CountAndGasUsed as CountAndGasUsed, index$7_DeferredTransfersResult as DeferredTransfersResult, index$7_DeferredTransfersState as DeferredTransfersState, index$7_DisputesState as DisputesState, index$7_DisputesStateUpdate as DisputesStateUpdate, index$7_HeaderChain as HeaderChain, index$7_Input as Input, index$7_Ok as Ok, index$7_PreimagesInput as PreimagesInput, index$7_PreimagesState as PreimagesState, index$7_PreimagesStateUpdate as PreimagesStateUpdate, index$7_RecentHistoryInput as RecentHistoryInput, index$7_RecentHistoryPartialInput as RecentHistoryPartialInput, index$7_RecentHistoryState as RecentHistoryState, index$7_RecentHistoryStateUpdate as RecentHistoryStateUpdate, index$7_ReportsInput as ReportsInput, index$7_ReportsOutput as ReportsOutput, index$7_ReportsState as ReportsState, index$7_ReportsStateUpdate as ReportsStateUpdate, index$7_StatisticsState as StatisticsState, index$7_StatisticsStateUpdate as StatisticsStateUpdate, index$7_StfError as StfError };
-}
-
 declare enum ImporterErrorKind {
     Verifier = 0,
     Stf = 1,
@@ -10788,19 +10354,274 @@ declare function createMetrics(): {
 
 declare const WORKER: url.URL;
 
-type index$6_Config = Config;
-type index$6_ImporterApi = ImporterApi;
-type index$6_ImporterConfig = ImporterConfig;
-declare const index$6_ImporterConfig: typeof ImporterConfig;
-type index$6_ImporterInternal = ImporterInternal;
-declare const index$6_WORKER: typeof WORKER;
-declare const index$6_createImporter: typeof createImporter;
-declare const index$6_createMetrics: typeof createMetrics;
-declare const index$6_main: typeof main;
-declare const index$6_protocol: typeof protocol;
-declare namespace index$6 {
-  export { index$6_ImporterConfig as ImporterConfig, index$6_WORKER as WORKER, index$6_createImporter as createImporter, index$6_createMetrics as createMetrics, index$6_main as main, index$6_protocol as protocol };
-  export type { index$6_Config as Config, index$6_ImporterApi as ImporterApi, index$6_ImporterInternal as ImporterInternal };
+/**
+ * JAM block importer utilities.
+ *
+ * This is the main module implementing JAM blocks importing.
+ *
+ * @module importer
+ */
+
+type importer_Config = Config;
+type importer_ImporterApi = ImporterApi;
+type importer_ImporterConfig = ImporterConfig;
+declare const importer_ImporterConfig: typeof ImporterConfig;
+type importer_ImporterInternal = ImporterInternal;
+declare const importer_WORKER: typeof WORKER;
+declare const importer_createImporter: typeof createImporter;
+declare const importer_createMetrics: typeof createMetrics;
+declare const importer_main: typeof main;
+declare const importer_protocol: typeof protocol;
+declare namespace importer {
+  export { importer_ImporterConfig as ImporterConfig, importer_WORKER as WORKER, importer_createImporter as createImporter, importer_createMetrics as createMetrics, importer_main as main, importer_protocol as protocol };
+  export type { importer_Config as Config, importer_ImporterApi as ImporterApi, importer_ImporterInternal as ImporterInternal };
+}
+
+/**
+ * JAM-specific host call implementations.
+ *
+ * This module provides the host call interface implementations specific to JAM,
+ * enabling communication between the host and guest environments.
+ *
+ * @module jam-host-calls
+ */
+
+type jamHostCalls_AccumulationStateUpdate = AccumulationStateUpdate;
+declare const jamHostCalls_AccumulationStateUpdate: typeof AccumulationStateUpdate;
+declare const jamHostCalls_CURRENT_SERVICE_ID: typeof CURRENT_SERVICE_ID;
+type jamHostCalls_EjectError = EjectError;
+declare const jamHostCalls_EjectError: typeof EjectError;
+type jamHostCalls_ForgetPreimageError = ForgetPreimageError;
+declare const jamHostCalls_ForgetPreimageError: typeof ForgetPreimageError;
+declare const jamHostCalls_HostCallResult: typeof HostCallResult;
+type jamHostCalls_InsufficientFundsError = InsufficientFundsError;
+type jamHostCalls_MachineId = MachineId;
+type jamHostCalls_MachineInstance = MachineInstance;
+declare const jamHostCalls_MachineInstance: typeof MachineInstance;
+type jamHostCalls_MachineResult = MachineResult;
+type jamHostCalls_MachineStatus = MachineStatus;
+type jamHostCalls_MemoryOperation = MemoryOperation;
+declare const jamHostCalls_MemoryOperation: typeof MemoryOperation;
+type jamHostCalls_NewServiceError = NewServiceError;
+declare const jamHostCalls_NewServiceError: typeof NewServiceError;
+type jamHostCalls_NoMachineError = NoMachineError;
+type jamHostCalls_PagesError = PagesError;
+declare const jamHostCalls_PagesError: typeof PagesError;
+type jamHostCalls_PartialState = PartialState;
+type jamHostCalls_PartiallyUpdatedState<T extends StateSlice = StateSlice> = PartiallyUpdatedState<T>;
+declare const jamHostCalls_PartiallyUpdatedState: typeof PartiallyUpdatedState;
+type jamHostCalls_PeekPokeError = PeekPokeError;
+declare const jamHostCalls_PeekPokeError: typeof PeekPokeError;
+type jamHostCalls_PendingTransfer = PendingTransfer;
+declare const jamHostCalls_PendingTransfer: typeof PendingTransfer;
+type jamHostCalls_PreimageStatus = PreimageStatus;
+type jamHostCalls_PreimageStatusKind = PreimageStatusKind;
+declare const jamHostCalls_PreimageStatusKind: typeof PreimageStatusKind;
+type jamHostCalls_ProgramCounter = ProgramCounter;
+type jamHostCalls_ProvidePreimageError = ProvidePreimageError;
+declare const jamHostCalls_ProvidePreimageError: typeof ProvidePreimageError;
+type jamHostCalls_RefineExternalities = RefineExternalities;
+type jamHostCalls_RequestPreimageError = RequestPreimageError;
+declare const jamHostCalls_RequestPreimageError: typeof RequestPreimageError;
+declare const jamHostCalls_SERVICE_ID_BYTES: typeof SERVICE_ID_BYTES;
+type jamHostCalls_SegmentExportError = SegmentExportError;
+type jamHostCalls_ServiceStateUpdate = ServiceStateUpdate;
+type jamHostCalls_TRANSFER_MEMO_BYTES = TRANSFER_MEMO_BYTES;
+type jamHostCalls_TransferError = TransferError;
+declare const jamHostCalls_TransferError: typeof TransferError;
+type jamHostCalls_UnprivilegedError = UnprivilegedError;
+type jamHostCalls_UpdatePrivilegesError = UpdatePrivilegesError;
+declare const jamHostCalls_UpdatePrivilegesError: typeof UpdatePrivilegesError;
+type jamHostCalls_ZeroVoidError = ZeroVoidError;
+declare const jamHostCalls_ZeroVoidError: typeof ZeroVoidError;
+declare const jamHostCalls_clampU64ToU32: typeof clampU64ToU32;
+declare const jamHostCalls_emptyRegistersBuffer: typeof emptyRegistersBuffer;
+declare const jamHostCalls_getServiceId: typeof getServiceId;
+declare const jamHostCalls_getServiceIdOrCurrent: typeof getServiceIdOrCurrent;
+declare const jamHostCalls_slotsToPreimageStatus: typeof slotsToPreimageStatus;
+declare const jamHostCalls_toMemoryOperation: typeof toMemoryOperation;
+declare const jamHostCalls_tryAsMachineId: typeof tryAsMachineId;
+declare const jamHostCalls_tryAsProgramCounter: typeof tryAsProgramCounter;
+declare const jamHostCalls_writeServiceIdAsLeBytes: typeof writeServiceIdAsLeBytes;
+declare namespace jamHostCalls {
+  export { jamHostCalls_AccumulationStateUpdate as AccumulationStateUpdate, jamHostCalls_CURRENT_SERVICE_ID as CURRENT_SERVICE_ID, jamHostCalls_EjectError as EjectError, jamHostCalls_ForgetPreimageError as ForgetPreimageError, jamHostCalls_HostCallResult as HostCallResult, jamHostCalls_MachineInstance as MachineInstance, jamHostCalls_MemoryOperation as MemoryOperation, jamHostCalls_NewServiceError as NewServiceError, jamHostCalls_PagesError as PagesError, jamHostCalls_PartiallyUpdatedState as PartiallyUpdatedState, jamHostCalls_PeekPokeError as PeekPokeError, jamHostCalls_PendingTransfer as PendingTransfer, jamHostCalls_PreimageStatusKind as PreimageStatusKind, jamHostCalls_ProvidePreimageError as ProvidePreimageError, jamHostCalls_RequestPreimageError as RequestPreimageError, jamHostCalls_SERVICE_ID_BYTES as SERVICE_ID_BYTES, jamHostCalls_TransferError as TransferError, jamHostCalls_UpdatePrivilegesError as UpdatePrivilegesError, jamHostCalls_ZeroVoidError as ZeroVoidError, index$5 as accumulate, jamHostCalls_clampU64ToU32 as clampU64ToU32, jamHostCalls_emptyRegistersBuffer as emptyRegistersBuffer, index$4 as general, jamHostCalls_getServiceId as getServiceId, jamHostCalls_getServiceIdOrCurrent as getServiceIdOrCurrent, codecServiceAccountInfoWithThresholdBalance as hostCallInfoAccount, index$3 as refine, jamHostCalls_slotsToPreimageStatus as slotsToPreimageStatus, jamHostCalls_toMemoryOperation as toMemoryOperation, jamHostCalls_tryAsMachineId as tryAsMachineId, jamHostCalls_tryAsProgramCounter as tryAsProgramCounter, jamHostCalls_writeServiceIdAsLeBytes as writeServiceIdAsLeBytes };
+  export type { jamHostCalls_InsufficientFundsError as InsufficientFundsError, jamHostCalls_MachineId as MachineId, jamHostCalls_MachineResult as MachineResult, jamHostCalls_MachineStatus as MachineStatus, jamHostCalls_NoMachineError as NoMachineError, jamHostCalls_PartialState as PartialState, jamHostCalls_PreimageStatus as PreimageStatus, jamHostCalls_ProgramCounter as ProgramCounter, jamHostCalls_RefineExternalities as RefineExternalities, jamHostCalls_SegmentExportError as SegmentExportError, jamHostCalls_ServiceStateUpdate as ServiceStateUpdate, jamHostCalls_TRANSFER_MEMO_BYTES as TRANSFER_MEMO_BYTES, jamHostCalls_UnprivilegedError as UnprivilegedError };
+}
+
+/**
+ * JSON parsing utilities and helpers.
+ *
+ * This module provides enhanced JSON parsing capabilities with support for
+ * JAM-specific data types and structures.
+ *
+ * @module json-parser
+ */
+
+type jsonParser_Builder<TFrom, TInto> = Builder<TFrom, TInto>;
+type jsonParser_FromJson<T> = FromJson<T>;
+type jsonParser_FromJsonOptional<TInto> = FromJsonOptional<TInto>;
+type jsonParser_FromJsonPrimitive<T> = FromJsonPrimitive<T>;
+type jsonParser_FromJsonWithParser<TFrom, TInto> = FromJsonWithParser<TFrom, TInto>;
+type jsonParser_ObjectFromJson<T> = ObjectFromJson<T>;
+type jsonParser_Parser<TFrom, TInto> = Parser<TFrom, TInto>;
+import jsonParser_json = json;
+declare const jsonParser_parseFromJson: typeof parseFromJson;
+declare namespace jsonParser {
+  export { jsonParser_json as json, jsonParser_parseFromJson as parseFromJson };
+  export type { jsonParser_Builder as Builder, jsonParser_FromJson as FromJson, jsonParser_FromJsonOptional as FromJsonOptional, jsonParser_FromJsonPrimitive as FromJsonPrimitive, jsonParser_FromJsonWithParser as FromJsonWithParser, jsonParser_ObjectFromJson as ObjectFromJson, jsonParser_Parser as Parser };
+}
+
+/**
+ * Logging framework and utilities.
+ *
+ * This module provides a structured logging framework with support for different
+ * log levels, formatting, and output targets.
+ *
+ * @module logger
+ */
+
+type logger_ConsoleTransport = ConsoleTransport;
+declare const logger_ConsoleTransport: typeof ConsoleTransport;
+type logger_Level = Level;
+declare const logger_Level: typeof Level;
+type logger_Logger = Logger;
+declare const logger_Logger: typeof Logger;
+type logger_Options = Options;
+type logger_Transport = Transport;
+type logger_TransportBuilder = TransportBuilder;
+declare const logger_findLevel: typeof findLevel;
+declare const logger_parseLoggerOptions: typeof parseLoggerOptions;
+declare namespace logger {
+  export { logger_ConsoleTransport as ConsoleTransport, logger_Level as Level, logger_Logger as Logger, logger_findLevel as findLevel, logger_parseLoggerOptions as parseLoggerOptions };
+  export type { logger_Options as Options, logger_Transport as Transport, logger_TransportBuilder as TransportBuilder };
+}
+
+/**
+ * Merkle Mountain Range implementation.
+ *
+ * This module provides an implementation of Merkle Mountain Range (MMR),
+ * a data structure for efficient append-only Merkle tree operations.
+ *
+ * @module mmr
+ */
+
+type mmr_MerkleMountainRange<H extends OpaqueHash> = MerkleMountainRange<H>;
+declare const mmr_MerkleMountainRange: typeof MerkleMountainRange;
+type mmr_MmrHasher<H extends OpaqueHash> = MmrHasher<H>;
+type mmr_MmrPeaks<H extends OpaqueHash> = MmrPeaks<H>;
+declare namespace mmr {
+  export { mmr_MerkleMountainRange as MerkleMountainRange };
+  export type { mmr_MmrHasher as MmrHasher, mmr_MmrPeaks as MmrPeaks };
+}
+
+/**
+ * Fixed-size numeric types and operations.
+ *
+ * This module provides fixed-size integer types (U8, U16, U32, U64, etc.) and
+ * operations, ensuring consistent numeric behavior across platforms.
+ *
+ * @module numbers
+ */
+
+type numbers_FixedSizeNumber<Bytes extends number> = FixedSizeNumber<Bytes>;
+type numbers_U16 = U16;
+type numbers_U32 = U32;
+type numbers_U64 = U64;
+type numbers_U8 = U8;
+type numbers_WithBytesRepresentation<Bytes extends number> = WithBytesRepresentation<Bytes>;
+declare const numbers___REPRESENTATION_BYTES__: typeof __REPRESENTATION_BYTES__;
+declare const numbers_isU16: typeof isU16;
+declare const numbers_isU32: typeof isU32;
+declare const numbers_isU64: typeof isU64;
+declare const numbers_isU8: typeof isU8;
+declare const numbers_leBytesAsU32: typeof leBytesAsU32;
+declare const numbers_maxU64: typeof maxU64;
+declare const numbers_minU64: typeof minU64;
+declare const numbers_sumU32: typeof sumU32;
+declare const numbers_sumU64: typeof sumU64;
+declare const numbers_tryAsU16: typeof tryAsU16;
+declare const numbers_tryAsU32: typeof tryAsU32;
+declare const numbers_tryAsU64: typeof tryAsU64;
+declare const numbers_tryAsU8: typeof tryAsU8;
+declare const numbers_u32AsLeBytes: typeof u32AsLeBytes;
+declare const numbers_u64FromParts: typeof u64FromParts;
+declare const numbers_u64IntoParts: typeof u64IntoParts;
+declare namespace numbers {
+  export { numbers___REPRESENTATION_BYTES__ as __REPRESENTATION_BYTES__, numbers_isU16 as isU16, numbers_isU32 as isU32, numbers_isU64 as isU64, numbers_isU8 as isU8, numbers_leBytesAsU32 as leBytesAsU32, numbers_maxU64 as maxU64, numbers_minU64 as minU64, numbers_sumU32 as sumU32, numbers_sumU64 as sumU64, numbers_tryAsU16 as tryAsU16, numbers_tryAsU32 as tryAsU32, numbers_tryAsU64 as tryAsU64, numbers_tryAsU8 as tryAsU8, numbers_u32AsLeBytes as u32AsLeBytes, numbers_u64FromParts as u64FromParts, numbers_u64IntoParts as u64IntoParts };
+  export type { numbers_FixedSizeNumber as FixedSizeNumber, Result$1 as Result, numbers_U16 as U16, numbers_U32 as U32, numbers_U64 as U64, numbers_U8 as U8, numbers_WithBytesRepresentation as WithBytesRepresentation };
+}
+
+/**
+ * Ordering and comparison utilities.
+ *
+ * This module provides utilities for ordering, sorting, and comparing values
+ * with support for custom comparison logic.
+ *
+ * @module ordering
+ */
+
+type ordering_Comparator<V> = Comparator<V>;
+type ordering_Ordering = Ordering;
+declare const ordering_Ordering: typeof Ordering;
+type ordering_OrderingValue = OrderingValue;
+declare const ordering_OrderingValue: typeof OrderingValue;
+declare namespace ordering {
+  export { ordering_Ordering as Ordering, ordering_OrderingValue as OrderingValue };
+  export type { ordering_Comparator as Comparator };
+}
+
+/**
+ * PVM host call implementations.
+ *
+ * This module provides the Polka Virtual Machine (PVM) host call interface,
+ * enabling guest programs to interact with the host environment.
+ *
+ * @module pvm-host-calls
+ */
+
+type pvmHostCalls_HostCallHandler = HostCallHandler;
+type pvmHostCalls_HostCallMemory = HostCallMemory;
+declare const pvmHostCalls_HostCallMemory: typeof HostCallMemory;
+type pvmHostCalls_HostCallRegisters = HostCallRegisters;
+declare const pvmHostCalls_HostCallRegisters: typeof HostCallRegisters;
+type pvmHostCalls_PvmExecution = PvmExecution;
+declare const pvmHostCalls_PvmExecution: typeof PvmExecution;
+declare const pvmHostCalls_traceRegisters: typeof traceRegisters;
+declare const pvmHostCalls_tryAsHostCallIndex: typeof tryAsHostCallIndex;
+declare namespace pvmHostCalls {
+  export { pvmHostCalls_HostCallMemory as HostCallMemory, pvmHostCalls_HostCallRegisters as HostCallRegisters, HostCallsManager as HostCalls, pvmHostCalls_PvmExecution as PvmExecution, HostCalls as PvmHostCallExtension, InterpreterInstanceManager as PvmInstanceManager, pvmHostCalls_traceRegisters as traceRegisters, pvmHostCalls_tryAsHostCallIndex as tryAsHostCallIndex };
+  export type { pvmHostCalls_HostCallHandler as HostCallHandler };
+}
+
+/**
+ * PVM interface and program utilities.
+ *
+ * This module provides the core PVM interface definitions, program structures,
+ * and utilities for working with PVM bytecode.
+ *
+ * @module pvm-interface
+ */
+
+type pvmInterface_BigGas = BigGas;
+type pvmInterface_Gas = Gas;
+type pvmInterface_IGasCounter = IGasCounter;
+type pvmInterface_IMemory = IMemory;
+type pvmInterface_IPvmInterpreter = IPvmInterpreter;
+type pvmInterface_IRegisters = IRegisters;
+declare const pvmInterface_MAX_MEMORY_INDEX: typeof MAX_MEMORY_INDEX;
+declare const pvmInterface_MEMORY_SIZE: typeof MEMORY_SIZE;
+declare const pvmInterface_NO_OF_REGISTERS: typeof NO_OF_REGISTERS;
+declare const pvmInterface_REGISTER_BYTE_SIZE: typeof REGISTER_BYTE_SIZE;
+type pvmInterface_SmallGas = SmallGas;
+type pvmInterface_Status = Status;
+declare const pvmInterface_Status: typeof Status;
+declare const pvmInterface_getPageStartAddress: typeof getPageStartAddress;
+declare const pvmInterface_tryAsBigGas: typeof tryAsBigGas;
+declare const pvmInterface_tryAsGas: typeof tryAsGas;
+declare const pvmInterface_tryAsSmallGas: typeof tryAsSmallGas;
+declare namespace pvmInterface {
+  export { pvmInterface_MAX_MEMORY_INDEX as MAX_MEMORY_INDEX, pvmInterface_MEMORY_SIZE as MEMORY_SIZE, pvmInterface_NO_OF_REGISTERS as NO_OF_REGISTERS, pvmInterface_REGISTER_BYTE_SIZE as REGISTER_BYTE_SIZE, pvmInterface_Status as Status, pvmInterface_getPageStartAddress as getPageStartAddress, pvmInterface_tryAsBigGas as tryAsBigGas, pvmInterface_tryAsGas as tryAsGas, pvmInterface_tryAsSmallGas as tryAsSmallGas };
+  export type { pvmInterface_BigGas as BigGas, pvmInterface_Gas as Gas, pvmInterface_IGasCounter as IGasCounter, pvmInterface_IMemory as IMemory, pvmInterface_IPvmInterpreter as IPvmInterpreter, pvmInterface_IRegisters as IRegisters, PageFault$1 as PageFault, pvmInterface_SmallGas as SmallGas };
 }
 
 declare enum ArgumentType {
@@ -11002,35 +10823,35 @@ declare class NibblesDecoder {
 
 declare const instructionArgumentTypeMap: ArgumentType[];
 
-type index$5_Args = Args;
-type index$5_ArgsDecoder = ArgsDecoder;
-declare const index$5_ArgsDecoder: typeof ArgsDecoder;
-type index$5_ArgumentType = ArgumentType;
-declare const index$5_ArgumentType: typeof ArgumentType;
-type index$5_EmptyArgs = EmptyArgs;
-type index$5_ExtendedWitdthImmediateDecoder = ExtendedWitdthImmediateDecoder;
-declare const index$5_ExtendedWitdthImmediateDecoder: typeof ExtendedWitdthImmediateDecoder;
-type index$5_ImmediateDecoder = ImmediateDecoder;
-declare const index$5_ImmediateDecoder: typeof ImmediateDecoder;
-type index$5_NibblesDecoder = NibblesDecoder;
-declare const index$5_NibblesDecoder: typeof NibblesDecoder;
-type index$5_OneImmediateArgs = OneImmediateArgs;
-type index$5_OneOffsetArgs = OneOffsetArgs;
-type index$5_OneRegisterOneExtendedWidthImmediateArgs = OneRegisterOneExtendedWidthImmediateArgs;
-type index$5_OneRegisterOneImmediateArgs = OneRegisterOneImmediateArgs;
-type index$5_OneRegisterOneImmediateOneOffsetArgs = OneRegisterOneImmediateOneOffsetArgs;
-type index$5_OneRegisterTwoImmediatesArgs = OneRegisterTwoImmediatesArgs;
-type index$5_ThreeRegistersArgs = ThreeRegistersArgs;
-type index$5_TwoImmediatesArgs = TwoImmediatesArgs;
-type index$5_TwoRegistersArgs = TwoRegistersArgs;
-type index$5_TwoRegistersOneImmediateArgs = TwoRegistersOneImmediateArgs;
-type index$5_TwoRegistersOneOffsetArgs = TwoRegistersOneOffsetArgs;
-type index$5_TwoRegistersTwoImmediatesArgs = TwoRegistersTwoImmediatesArgs;
-declare const index$5_createResults: typeof createResults;
-declare const index$5_instructionArgumentTypeMap: typeof instructionArgumentTypeMap;
-declare namespace index$5 {
-  export { index$5_ArgsDecoder as ArgsDecoder, index$5_ArgumentType as ArgumentType, index$5_ExtendedWitdthImmediateDecoder as ExtendedWitdthImmediateDecoder, index$5_ImmediateDecoder as ImmediateDecoder, index$5_NibblesDecoder as NibblesDecoder, index$5_createResults as createResults, index$5_instructionArgumentTypeMap as instructionArgumentTypeMap };
-  export type { index$5_Args as Args, index$5_EmptyArgs as EmptyArgs, index$5_OneImmediateArgs as OneImmediateArgs, index$5_OneOffsetArgs as OneOffsetArgs, index$5_OneRegisterOneExtendedWidthImmediateArgs as OneRegisterOneExtendedWidthImmediateArgs, index$5_OneRegisterOneImmediateArgs as OneRegisterOneImmediateArgs, index$5_OneRegisterOneImmediateOneOffsetArgs as OneRegisterOneImmediateOneOffsetArgs, index$5_OneRegisterTwoImmediatesArgs as OneRegisterTwoImmediatesArgs, index$5_ThreeRegistersArgs as ThreeRegistersArgs, index$5_TwoImmediatesArgs as TwoImmediatesArgs, index$5_TwoRegistersArgs as TwoRegistersArgs, index$5_TwoRegistersOneImmediateArgs as TwoRegistersOneImmediateArgs, index$5_TwoRegistersOneOffsetArgs as TwoRegistersOneOffsetArgs, index$5_TwoRegistersTwoImmediatesArgs as TwoRegistersTwoImmediatesArgs };
+type index$1_Args = Args;
+type index$1_ArgsDecoder = ArgsDecoder;
+declare const index$1_ArgsDecoder: typeof ArgsDecoder;
+type index$1_ArgumentType = ArgumentType;
+declare const index$1_ArgumentType: typeof ArgumentType;
+type index$1_EmptyArgs = EmptyArgs;
+type index$1_ExtendedWitdthImmediateDecoder = ExtendedWitdthImmediateDecoder;
+declare const index$1_ExtendedWitdthImmediateDecoder: typeof ExtendedWitdthImmediateDecoder;
+type index$1_ImmediateDecoder = ImmediateDecoder;
+declare const index$1_ImmediateDecoder: typeof ImmediateDecoder;
+type index$1_NibblesDecoder = NibblesDecoder;
+declare const index$1_NibblesDecoder: typeof NibblesDecoder;
+type index$1_OneImmediateArgs = OneImmediateArgs;
+type index$1_OneOffsetArgs = OneOffsetArgs;
+type index$1_OneRegisterOneExtendedWidthImmediateArgs = OneRegisterOneExtendedWidthImmediateArgs;
+type index$1_OneRegisterOneImmediateArgs = OneRegisterOneImmediateArgs;
+type index$1_OneRegisterOneImmediateOneOffsetArgs = OneRegisterOneImmediateOneOffsetArgs;
+type index$1_OneRegisterTwoImmediatesArgs = OneRegisterTwoImmediatesArgs;
+type index$1_ThreeRegistersArgs = ThreeRegistersArgs;
+type index$1_TwoImmediatesArgs = TwoImmediatesArgs;
+type index$1_TwoRegistersArgs = TwoRegistersArgs;
+type index$1_TwoRegistersOneImmediateArgs = TwoRegistersOneImmediateArgs;
+type index$1_TwoRegistersOneOffsetArgs = TwoRegistersOneOffsetArgs;
+type index$1_TwoRegistersTwoImmediatesArgs = TwoRegistersTwoImmediatesArgs;
+declare const index$1_createResults: typeof createResults;
+declare const index$1_instructionArgumentTypeMap: typeof instructionArgumentTypeMap;
+declare namespace index$1 {
+  export { index$1_ArgsDecoder as ArgsDecoder, index$1_ArgumentType as ArgumentType, index$1_ExtendedWitdthImmediateDecoder as ExtendedWitdthImmediateDecoder, index$1_ImmediateDecoder as ImmediateDecoder, index$1_NibblesDecoder as NibblesDecoder, index$1_createResults as createResults, index$1_instructionArgumentTypeMap as instructionArgumentTypeMap };
+  export type { index$1_Args as Args, index$1_EmptyArgs as EmptyArgs, index$1_OneImmediateArgs as OneImmediateArgs, index$1_OneOffsetArgs as OneOffsetArgs, index$1_OneRegisterOneExtendedWidthImmediateArgs as OneRegisterOneExtendedWidthImmediateArgs, index$1_OneRegisterOneImmediateArgs as OneRegisterOneImmediateArgs, index$1_OneRegisterOneImmediateOneOffsetArgs as OneRegisterOneImmediateOneOffsetArgs, index$1_OneRegisterTwoImmediatesArgs as OneRegisterTwoImmediatesArgs, index$1_ThreeRegistersArgs as ThreeRegistersArgs, index$1_TwoImmediatesArgs as TwoImmediatesArgs, index$1_TwoRegistersArgs as TwoRegistersArgs, index$1_TwoRegistersOneImmediateArgs as TwoRegistersOneImmediateArgs, index$1_TwoRegistersOneOffsetArgs as TwoRegistersOneOffsetArgs, index$1_TwoRegistersTwoImmediatesArgs as TwoRegistersTwoImmediatesArgs };
 }
 
 declare class BasicBlocks {
@@ -11203,7 +11024,7 @@ declare class Interpreter implements IPvmInterpreter {
     constructor({ useSbrkGas }?: InterpreterOptions);
     resetJam(program: Uint8Array, args: Uint8Array, pc: number, gas: Gas, hasMetadata?: boolean): void;
     resetGeneric(rawProgram: Uint8Array, pc: number, gas: Gas, maybeRegisters?: Registers, maybeMemory?: Memory): void;
-    printProgram(): (string | number)[][];
+    dumpProgram(): (string | number)[][];
     runProgram(): void;
     nextStep(): Status;
     getPC(): number;
@@ -11277,72 +11098,81 @@ declare const LAST_PAGE = 4294901760;
 declare function alignToSegmentSize(size: number): number;
 declare function alignToPageSize(size: number): number;
 
-declare const index$4_ARGS_SEGMENT: typeof ARGS_SEGMENT;
-declare const index$4_DATA_LEGNTH: typeof DATA_LEGNTH;
-declare const index$4_LAST_PAGE: typeof LAST_PAGE;
-type index$4_MemorySegment = MemorySegment;
-declare const index$4_MemorySegment: typeof MemorySegment;
-declare const index$4_PAGE_SIZE: typeof PAGE_SIZE;
-declare const index$4_SEGMENT_SIZE: typeof SEGMENT_SIZE;
-declare const index$4_STACK_SEGMENT: typeof STACK_SEGMENT;
-type index$4_SpiMemory = SpiMemory;
-declare const index$4_SpiMemory: typeof SpiMemory;
-type index$4_SpiProgram = SpiProgram;
-declare const index$4_SpiProgram: typeof SpiProgram;
-declare const index$4_alignToPageSize: typeof alignToPageSize;
-declare const index$4_alignToSegmentSize: typeof alignToSegmentSize;
-declare const index$4_decodeStandardProgram: typeof decodeStandardProgram;
-declare namespace index$4 {
+declare const index_ARGS_SEGMENT: typeof ARGS_SEGMENT;
+declare const index_DATA_LEGNTH: typeof DATA_LEGNTH;
+declare const index_LAST_PAGE: typeof LAST_PAGE;
+type index_MemorySegment = MemorySegment;
+declare const index_MemorySegment: typeof MemorySegment;
+declare const index_PAGE_SIZE: typeof PAGE_SIZE;
+declare const index_SEGMENT_SIZE: typeof SEGMENT_SIZE;
+declare const index_STACK_SEGMENT: typeof STACK_SEGMENT;
+type index_SpiMemory = SpiMemory;
+declare const index_SpiMemory: typeof SpiMemory;
+type index_SpiProgram = SpiProgram;
+declare const index_SpiProgram: typeof SpiProgram;
+declare const index_alignToPageSize: typeof alignToPageSize;
+declare const index_alignToSegmentSize: typeof alignToSegmentSize;
+declare const index_decodeStandardProgram: typeof decodeStandardProgram;
+declare namespace index {
   export {
-    index$4_ARGS_SEGMENT as ARGS_SEGMENT,
-    index$4_DATA_LEGNTH as DATA_LEGNTH,
-    index$4_LAST_PAGE as LAST_PAGE,
-    index$4_MemorySegment as MemorySegment,
-    index$4_PAGE_SIZE as PAGE_SIZE,
-    index$4_SEGMENT_SIZE as SEGMENT_SIZE,
-    index$4_STACK_SEGMENT as STACK_SEGMENT,
-    index$4_SpiMemory as SpiMemory,
-    index$4_SpiProgram as SpiProgram,
-    index$4_alignToPageSize as alignToPageSize,
-    index$4_alignToSegmentSize as alignToSegmentSize,
-    index$4_decodeStandardProgram as decodeStandardProgram,
+    index_ARGS_SEGMENT as ARGS_SEGMENT,
+    index_DATA_LEGNTH as DATA_LEGNTH,
+    index_LAST_PAGE as LAST_PAGE,
+    index_MemorySegment as MemorySegment,
+    index_PAGE_SIZE as PAGE_SIZE,
+    index_SEGMENT_SIZE as SEGMENT_SIZE,
+    index_STACK_SEGMENT as STACK_SEGMENT,
+    index_SpiMemory as SpiMemory,
+    index_SpiProgram as SpiProgram,
+    index_alignToPageSize as alignToPageSize,
+    index_alignToSegmentSize as alignToSegmentSize,
+    index_decodeStandardProgram as decodeStandardProgram,
   };
 }
 
-type index$3_BasicBlocks = BasicBlocks;
-declare const index$3_BasicBlocks: typeof BasicBlocks;
-type index$3_DebuggerAdapter = DebuggerAdapter;
-declare const index$3_DebuggerAdapter: typeof DebuggerAdapter;
-type index$3_Interpreter = Interpreter;
-declare const index$3_Interpreter: typeof Interpreter;
-type index$3_JumpTable = JumpTable;
-declare const index$3_JumpTable: typeof JumpTable;
-type index$3_Mask = Mask;
-declare const index$3_Mask: typeof Mask;
-type index$3_Memory = Memory;
-declare const index$3_Memory: typeof Memory;
-type index$3_MemoryBuilder = MemoryBuilder;
-declare const index$3_MemoryBuilder: typeof MemoryBuilder;
-type index$3_MemoryIndex = MemoryIndex;
-type index$3_Program = Program;
-declare const index$3_Program: typeof Program;
-type index$3_ProgramDecoder = ProgramDecoder;
-declare const index$3_ProgramDecoder: typeof ProgramDecoder;
-type index$3_ProgramDecoderError = ProgramDecoderError;
-declare const index$3_ProgramDecoderError: typeof ProgramDecoderError;
-type index$3_RegisterIndex = RegisterIndex;
-type index$3_Registers = Registers;
-declare const index$3_Registers: typeof Registers;
-type index$3_SbrkIndex = SbrkIndex;
-declare const index$3_extractCodeAndMetadata: typeof extractCodeAndMetadata;
-declare const index$3_gasCounter: typeof gasCounter;
-declare const index$3_signExtend32To64: typeof signExtend32To64;
-declare const index$3_tryAsMemoryIndex: typeof tryAsMemoryIndex;
-declare const index$3_tryAsRegisterIndex: typeof tryAsRegisterIndex;
-declare const index$3_tryAsSbrkIndex: typeof tryAsSbrkIndex;
-declare namespace index$3 {
-  export { index$3_BasicBlocks as BasicBlocks, index$3_DebuggerAdapter as DebuggerAdapter, index$3_Interpreter as Interpreter, index$3_JumpTable as JumpTable, index$3_Mask as Mask, index$3_Memory as Memory, index$3_MemoryBuilder as MemoryBuilder, index$3_Program as Program, index$3_ProgramDecoder as ProgramDecoder, index$3_ProgramDecoderError as ProgramDecoderError, index$3_Registers as Registers, index$5 as args, index$3_extractCodeAndMetadata as extractCodeAndMetadata, index$3_gasCounter as gasCounter, index$3_signExtend32To64 as signExtend32To64, index$4 as spi, index$3_tryAsMemoryIndex as tryAsMemoryIndex, index$3_tryAsRegisterIndex as tryAsRegisterIndex, index$3_tryAsSbrkIndex as tryAsSbrkIndex };
-  export type { index$3_MemoryIndex as MemoryIndex, index$3_RegisterIndex as RegisterIndex, index$3_SbrkIndex as SbrkIndex };
+/**
+ * Typeberry PVM interpreter.
+ *
+ * This module provides the Polka Virtual Machine interpreter that executes
+ * PVM bytecode with support for all standard PVM operations.
+ *
+ * @module pvm-interpreter
+ */
+
+type pvmInterpreter_BasicBlocks = BasicBlocks;
+declare const pvmInterpreter_BasicBlocks: typeof BasicBlocks;
+type pvmInterpreter_DebuggerAdapter = DebuggerAdapter;
+declare const pvmInterpreter_DebuggerAdapter: typeof DebuggerAdapter;
+type pvmInterpreter_Interpreter = Interpreter;
+declare const pvmInterpreter_Interpreter: typeof Interpreter;
+type pvmInterpreter_JumpTable = JumpTable;
+declare const pvmInterpreter_JumpTable: typeof JumpTable;
+type pvmInterpreter_Mask = Mask;
+declare const pvmInterpreter_Mask: typeof Mask;
+type pvmInterpreter_Memory = Memory;
+declare const pvmInterpreter_Memory: typeof Memory;
+type pvmInterpreter_MemoryBuilder = MemoryBuilder;
+declare const pvmInterpreter_MemoryBuilder: typeof MemoryBuilder;
+type pvmInterpreter_MemoryIndex = MemoryIndex;
+type pvmInterpreter_Program = Program;
+declare const pvmInterpreter_Program: typeof Program;
+type pvmInterpreter_ProgramDecoder = ProgramDecoder;
+declare const pvmInterpreter_ProgramDecoder: typeof ProgramDecoder;
+type pvmInterpreter_ProgramDecoderError = ProgramDecoderError;
+declare const pvmInterpreter_ProgramDecoderError: typeof ProgramDecoderError;
+type pvmInterpreter_RegisterIndex = RegisterIndex;
+type pvmInterpreter_Registers = Registers;
+declare const pvmInterpreter_Registers: typeof Registers;
+type pvmInterpreter_SbrkIndex = SbrkIndex;
+declare const pvmInterpreter_extractCodeAndMetadata: typeof extractCodeAndMetadata;
+declare const pvmInterpreter_gasCounter: typeof gasCounter;
+declare const pvmInterpreter_signExtend32To64: typeof signExtend32To64;
+declare const pvmInterpreter_tryAsMemoryIndex: typeof tryAsMemoryIndex;
+declare const pvmInterpreter_tryAsRegisterIndex: typeof tryAsRegisterIndex;
+declare const pvmInterpreter_tryAsSbrkIndex: typeof tryAsSbrkIndex;
+declare namespace pvmInterpreter {
+  export { pvmInterpreter_BasicBlocks as BasicBlocks, pvmInterpreter_DebuggerAdapter as DebuggerAdapter, pvmInterpreter_Interpreter as Interpreter, pvmInterpreter_JumpTable as JumpTable, pvmInterpreter_Mask as Mask, pvmInterpreter_Memory as Memory, pvmInterpreter_MemoryBuilder as MemoryBuilder, pvmInterpreter_Program as Program, pvmInterpreter_ProgramDecoder as ProgramDecoder, pvmInterpreter_ProgramDecoderError as ProgramDecoderError, pvmInterpreter_Registers as Registers, index$1 as args, pvmInterpreter_extractCodeAndMetadata as extractCodeAndMetadata, pvmInterpreter_gasCounter as gasCounter, pvmInterpreter_signExtend32To64 as signExtend32To64, index as spi, pvmInterpreter_tryAsMemoryIndex as tryAsMemoryIndex, pvmInterpreter_tryAsRegisterIndex as tryAsRegisterIndex, pvmInterpreter_tryAsSbrkIndex as tryAsSbrkIndex };
+  export type { pvmInterpreter_MemoryIndex as MemoryIndex, pvmInterpreter_RegisterIndex as RegisterIndex, pvmInterpreter_SbrkIndex as SbrkIndex };
 }
 
 declare const ENTROPY_BYTES = 32;
@@ -11354,13 +11184,141 @@ type ENTROPY_BYTES = typeof ENTROPY_BYTES;
  */
 declare function fisherYatesShuffle<T>(blake2b: Blake2b, arr: T[], entropy: Bytes<ENTROPY_BYTES>): T[];
 
-declare const index$2_fisherYatesShuffle: typeof fisherYatesShuffle;
-declare namespace index$2 {
+/**
+ * Shuffling algorithms and utilities.
+ *
+ * This module provides deterministic shuffling algorithms used for validator
+ * selection and other randomization needs in the JAM protocol.
+ *
+ * @module shuffling
+ */
+
+declare const shuffling_fisherYatesShuffle: typeof fisherYatesShuffle;
+declare namespace shuffling {
   export {
-    index$2_fisherYatesShuffle as fisherYatesShuffle,
+    shuffling_fisherYatesShuffle as fisherYatesShuffle,
   };
 }
 
+/**
+ * State management and data structures.
+ *
+ * This module provides the core state management functionality for JAM,
+ * including state types, transitions, and persistence operations.
+ *
+ * @module state
+ */
+
+type state_AUTHORIZATION_QUEUE_SIZE = AUTHORIZATION_QUEUE_SIZE;
+type state_AccumulationOutput = AccumulationOutput;
+declare const state_AccumulationOutput: typeof AccumulationOutput;
+type state_AccumulationQueue = AccumulationQueue;
+type state_AccumulationQueueView = AccumulationQueueView;
+type state_AuthorizationPool = AuthorizationPool;
+type state_AuthorizationQueue = AuthorizationQueue;
+type state_AvailabilityAssignment = AvailabilityAssignment;
+declare const state_AvailabilityAssignment: typeof AvailabilityAssignment;
+type state_AvailabilityAssignmentsView = AvailabilityAssignmentsView;
+declare const state_BASE_SERVICE_BALANCE: typeof BASE_SERVICE_BALANCE;
+type state_BlockState = BlockState;
+declare const state_BlockState: typeof BlockState;
+type state_BlocksState = BlocksState;
+type state_CoreStatistics = CoreStatistics;
+declare const state_CoreStatistics: typeof CoreStatistics;
+type state_DisputesRecords = DisputesRecords;
+declare const state_DisputesRecords: typeof DisputesRecords;
+declare const state_ELECTIVE_BYTE_BALANCE: typeof ELECTIVE_BYTE_BALANCE;
+declare const state_ELECTIVE_ITEM_BALANCE: typeof ELECTIVE_ITEM_BALANCE;
+type state_ENTROPY_ENTRIES = ENTROPY_ENTRIES;
+type state_EnumerableState = EnumerableState;
+type state_InMemoryService = InMemoryService;
+declare const state_InMemoryService: typeof InMemoryService;
+type state_InMemoryState = InMemoryState;
+declare const state_InMemoryState: typeof InMemoryState;
+type state_InMemoryStateFields = InMemoryStateFields;
+type state_LookupHistoryItem = LookupHistoryItem;
+declare const state_LookupHistoryItem: typeof LookupHistoryItem;
+type state_LookupHistorySlots = LookupHistorySlots;
+type state_MAX_AUTH_POOL_SIZE = MAX_AUTH_POOL_SIZE;
+type state_MAX_RECENT_HISTORY = MAX_RECENT_HISTORY;
+type state_NotYetAccumulatedReport = NotYetAccumulatedReport;
+declare const state_NotYetAccumulatedReport: typeof NotYetAccumulatedReport;
+type state_PerCore<T> = PerCore<T>;
+type state_PreimageItem = PreimageItem;
+declare const state_PreimageItem: typeof PreimageItem;
+type state_PrivilegedServices = PrivilegedServices;
+declare const state_PrivilegedServices: typeof PrivilegedServices;
+type state_RecentBlocks = RecentBlocks;
+declare const state_RecentBlocks: typeof RecentBlocks;
+type state_RecentBlocksView = RecentBlocksView;
+type state_RecentlyAccumulated = RecentlyAccumulated;
+type state_RecentlyAccumulatedView = RecentlyAccumulatedView;
+type state_SafroleData = SafroleData;
+declare const state_SafroleData: typeof SafroleData;
+type state_SafroleDataView = SafroleDataView;
+type state_SafroleSealingKeys = SafroleSealingKeys;
+type state_SafroleSealingKeysData = SafroleSealingKeysData;
+declare const state_SafroleSealingKeysData: typeof SafroleSealingKeysData;
+type state_SafroleSealingKeysKind = SafroleSealingKeysKind;
+declare const state_SafroleSealingKeysKind: typeof SafroleSealingKeysKind;
+type state_Service = Service;
+type state_ServiceAccountInfo = ServiceAccountInfo;
+declare const state_ServiceAccountInfo: typeof ServiceAccountInfo;
+type state_ServiceAccountInfoView = ServiceAccountInfoView;
+type state_ServiceData = ServiceData;
+type state_ServiceEntries = ServiceEntries;
+type state_ServiceStatistics = ServiceStatistics;
+declare const state_ServiceStatistics: typeof ServiceStatistics;
+type state_ServicesUpdate = ServicesUpdate;
+type state_State = State;
+type state_StateView = StateView;
+type state_StatisticsData = StatisticsData;
+declare const state_StatisticsData: typeof StatisticsData;
+type state_StatisticsDataView = StatisticsDataView;
+type state_StorageItem = StorageItem;
+declare const state_StorageItem: typeof StorageItem;
+type state_StorageKey = StorageKey;
+type state_UpdateError = UpdateError;
+declare const state_UpdateError: typeof UpdateError;
+type state_UpdatePreimage = UpdatePreimage;
+declare const state_UpdatePreimage: typeof UpdatePreimage;
+type state_UpdatePreimageKind = UpdatePreimageKind;
+declare const state_UpdatePreimageKind: typeof UpdatePreimageKind;
+type state_UpdateService = UpdateService;
+declare const state_UpdateService: typeof UpdateService;
+type state_UpdateServiceKind = UpdateServiceKind;
+declare const state_UpdateServiceKind: typeof UpdateServiceKind;
+type state_UpdateStorage = UpdateStorage;
+declare const state_UpdateStorage: typeof UpdateStorage;
+type state_UpdateStorageKind = UpdateStorageKind;
+declare const state_UpdateStorageKind: typeof UpdateStorageKind;
+type state_VALIDATOR_META_BYTES = VALIDATOR_META_BYTES;
+type state_ValidatorData = ValidatorData;
+declare const state_ValidatorData: typeof ValidatorData;
+type state_ValidatorDataView = ValidatorDataView;
+type state_ValidatorStatistics = ValidatorStatistics;
+declare const state_ValidatorStatistics: typeof ValidatorStatistics;
+type state_WithStateView<V = StateView> = WithStateView<V>;
+declare const state_accumulationOutputComparator: typeof accumulationOutputComparator;
+declare const state_accumulationQueueCodec: typeof accumulationQueueCodec;
+declare const state_authPoolsCodec: typeof authPoolsCodec;
+declare const state_authQueuesCodec: typeof authQueuesCodec;
+declare const state_availabilityAssignmentsCodec: typeof availabilityAssignmentsCodec;
+declare const state_codecPerCore: typeof codecPerCore;
+declare const state_codecWithVersion: typeof codecWithVersion;
+declare const state_hashComparator: typeof hashComparator;
+declare const state_ignoreValueWithDefault: typeof ignoreValueWithDefault;
+declare const state_recentlyAccumulatedCodec: typeof recentlyAccumulatedCodec;
+declare const state_serviceDataCodec: typeof serviceDataCodec;
+declare const state_serviceEntriesCodec: typeof serviceEntriesCodec;
+declare const state_tryAsLookupHistorySlots: typeof tryAsLookupHistorySlots;
+declare const state_tryAsPerCore: typeof tryAsPerCore;
+declare const state_validatorsDataCodec: typeof validatorsDataCodec;
+declare namespace state {
+  export { state_AccumulationOutput as AccumulationOutput, state_AvailabilityAssignment as AvailabilityAssignment, state_BASE_SERVICE_BALANCE as BASE_SERVICE_BALANCE, state_BlockState as BlockState, state_CoreStatistics as CoreStatistics, state_DisputesRecords as DisputesRecords, state_ELECTIVE_BYTE_BALANCE as ELECTIVE_BYTE_BALANCE, state_ELECTIVE_ITEM_BALANCE as ELECTIVE_ITEM_BALANCE, state_InMemoryService as InMemoryService, state_InMemoryState as InMemoryState, state_LookupHistoryItem as LookupHistoryItem, state_NotYetAccumulatedReport as NotYetAccumulatedReport, state_PreimageItem as PreimageItem, state_PrivilegedServices as PrivilegedServices, state_RecentBlocks as RecentBlocks, state_SafroleData as SafroleData, state_SafroleSealingKeysData as SafroleSealingKeysData, state_SafroleSealingKeysKind as SafroleSealingKeysKind, state_ServiceAccountInfo as ServiceAccountInfo, state_ServiceStatistics as ServiceStatistics, state_StatisticsData as StatisticsData, state_StorageItem as StorageItem, state_UpdateError as UpdateError, state_UpdatePreimage as UpdatePreimage, state_UpdatePreimageKind as UpdatePreimageKind, state_UpdateService as UpdateService, state_UpdateServiceKind as UpdateServiceKind, state_UpdateStorage as UpdateStorage, state_UpdateStorageKind as UpdateStorageKind, state_ValidatorData as ValidatorData, state_ValidatorStatistics as ValidatorStatistics, state_accumulationOutputComparator as accumulationOutputComparator, state_accumulationQueueCodec as accumulationQueueCodec, state_authPoolsCodec as authPoolsCodec, state_authQueuesCodec as authQueuesCodec, state_availabilityAssignmentsCodec as availabilityAssignmentsCodec, state_codecPerCore as codecPerCore, state_codecWithVersion as codecWithVersion, state_hashComparator as hashComparator, state_ignoreValueWithDefault as ignoreValueWithDefault, state_recentlyAccumulatedCodec as recentlyAccumulatedCodec, state_serviceDataCodec as serviceDataCodec, state_serviceEntriesCodec as serviceEntriesCodec, state_tryAsLookupHistorySlots as tryAsLookupHistorySlots, state_tryAsPerCore as tryAsPerCore, state_validatorsDataCodec as validatorsDataCodec };
+  export type { state_AUTHORIZATION_QUEUE_SIZE as AUTHORIZATION_QUEUE_SIZE, state_AccumulationQueue as AccumulationQueue, state_AccumulationQueueView as AccumulationQueueView, state_AuthorizationPool as AuthorizationPool, state_AuthorizationQueue as AuthorizationQueue, state_AvailabilityAssignmentsView as AvailabilityAssignmentsView, state_BlocksState as BlocksState, state_ENTROPY_ENTRIES as ENTROPY_ENTRIES, state_EnumerableState as EnumerableState, state_InMemoryStateFields as InMemoryStateFields, state_LookupHistorySlots as LookupHistorySlots, state_MAX_AUTH_POOL_SIZE as MAX_AUTH_POOL_SIZE, state_MAX_RECENT_HISTORY as MAX_RECENT_HISTORY, state_PerCore as PerCore, state_RecentBlocksView as RecentBlocksView, state_RecentlyAccumulated as RecentlyAccumulated, state_RecentlyAccumulatedView as RecentlyAccumulatedView, state_SafroleDataView as SafroleDataView, state_SafroleSealingKeys as SafroleSealingKeys, state_Service as Service, state_ServiceAccountInfoView as ServiceAccountInfoView, state_ServiceData as ServiceData, state_ServiceEntries as ServiceEntries, state_ServicesUpdate as ServicesUpdate, state_State as State, state_StateView as StateView, state_StatisticsDataView as StatisticsDataView, state_StorageKey as StorageKey, state_VALIDATOR_META_BYTES as VALIDATOR_META_BYTES, state_ValidatorDataView as ValidatorDataView, state_WithStateView as WithStateView };
+}
+
 declare class JsonPreimageItem {
     static fromJson: FromJsonWithParser<unknown, PreimageItem>;
     hash: PreimageHash;
@@ -11442,29 +11400,75 @@ declare class JsonStatisticsData {
 
 declare const validatorDataFromJson: FromJsonWithParser<unknown, ValidatorData>;
 
-type index$1_JsonCoreStatistics = JsonCoreStatistics;
-declare const index$1_JsonCoreStatistics: typeof JsonCoreStatistics;
-type index$1_JsonService = JsonService;
-declare const index$1_JsonService: typeof JsonService;
-type index$1_JsonStatisticsData = JsonStatisticsData;
-declare const index$1_JsonStatisticsData: typeof JsonStatisticsData;
-type index$1_JsonValidatorStatistics = JsonValidatorStatistics;
-declare const index$1_JsonValidatorStatistics: typeof JsonValidatorStatistics;
-type index$1_ServiceStatisticsEntry = ServiceStatisticsEntry;
-type index$1_TicketsOrKeys = TicketsOrKeys;
-declare const index$1_TicketsOrKeys: typeof TicketsOrKeys;
-declare const index$1_availabilityAssignmentFromJson: typeof availabilityAssignmentFromJson;
-declare const index$1_disputesRecordsFromJson: typeof disputesRecordsFromJson;
-declare const index$1_fullStateDumpFromJson: typeof fullStateDumpFromJson;
-declare const index$1_notYetAccumulatedFromJson: typeof notYetAccumulatedFromJson;
-declare const index$1_recentBlocksHistoryFromJson: typeof recentBlocksHistoryFromJson;
-declare const index$1_reportedWorkPackageFromJson: typeof reportedWorkPackageFromJson;
-declare const index$1_serviceStatisticsEntryFromJson: typeof serviceStatisticsEntryFromJson;
-declare const index$1_ticketFromJson: typeof ticketFromJson;
-declare const index$1_validatorDataFromJson: typeof validatorDataFromJson;
-declare namespace index$1 {
-  export { index$1_JsonCoreStatistics as JsonCoreStatistics, index$1_JsonService as JsonService, index$1_JsonStatisticsData as JsonStatisticsData, index$1_JsonValidatorStatistics as JsonValidatorStatistics, index$1_TicketsOrKeys as TicketsOrKeys, index$1_availabilityAssignmentFromJson as availabilityAssignmentFromJson, index$1_disputesRecordsFromJson as disputesRecordsFromJson, index$1_fullStateDumpFromJson as fullStateDumpFromJson, index$1_notYetAccumulatedFromJson as notYetAccumulatedFromJson, index$1_recentBlocksHistoryFromJson as recentBlocksHistoryFromJson, index$1_reportedWorkPackageFromJson as reportedWorkPackageFromJson, index$1_serviceStatisticsEntryFromJson as serviceStatisticsEntryFromJson, index$1_ticketFromJson as ticketFromJson, index$1_validatorDataFromJson as validatorDataFromJson };
-  export type { index$1_ServiceStatisticsEntry as ServiceStatisticsEntry };
+/**
+ * JSON serialization for state structures.
+ *
+ * This module provides utilities for converting JAM state structures to and from
+ * JSON format for debugging, testing, and data interchange.
+ *
+ * @module state-json
+ */
+
+type stateJson_JsonCoreStatistics = JsonCoreStatistics;
+declare const stateJson_JsonCoreStatistics: typeof JsonCoreStatistics;
+type stateJson_JsonService = JsonService;
+declare const stateJson_JsonService: typeof JsonService;
+type stateJson_JsonStatisticsData = JsonStatisticsData;
+declare const stateJson_JsonStatisticsData: typeof JsonStatisticsData;
+type stateJson_JsonValidatorStatistics = JsonValidatorStatistics;
+declare const stateJson_JsonValidatorStatistics: typeof JsonValidatorStatistics;
+type stateJson_ServiceStatisticsEntry = ServiceStatisticsEntry;
+type stateJson_TicketsOrKeys = TicketsOrKeys;
+declare const stateJson_TicketsOrKeys: typeof TicketsOrKeys;
+declare const stateJson_availabilityAssignmentFromJson: typeof availabilityAssignmentFromJson;
+declare const stateJson_disputesRecordsFromJson: typeof disputesRecordsFromJson;
+declare const stateJson_fullStateDumpFromJson: typeof fullStateDumpFromJson;
+declare const stateJson_notYetAccumulatedFromJson: typeof notYetAccumulatedFromJson;
+declare const stateJson_recentBlocksHistoryFromJson: typeof recentBlocksHistoryFromJson;
+declare const stateJson_reportedWorkPackageFromJson: typeof reportedWorkPackageFromJson;
+declare const stateJson_serviceStatisticsEntryFromJson: typeof serviceStatisticsEntryFromJson;
+declare const stateJson_ticketFromJson: typeof ticketFromJson;
+declare const stateJson_validatorDataFromJson: typeof validatorDataFromJson;
+declare namespace stateJson {
+  export { stateJson_JsonCoreStatistics as JsonCoreStatistics, stateJson_JsonService as JsonService, stateJson_JsonStatisticsData as JsonStatisticsData, stateJson_JsonValidatorStatistics as JsonValidatorStatistics, stateJson_TicketsOrKeys as TicketsOrKeys, stateJson_availabilityAssignmentFromJson as availabilityAssignmentFromJson, stateJson_disputesRecordsFromJson as disputesRecordsFromJson, stateJson_fullStateDumpFromJson as fullStateDumpFromJson, stateJson_notYetAccumulatedFromJson as notYetAccumulatedFromJson, stateJson_recentBlocksHistoryFromJson as recentBlocksHistoryFromJson, stateJson_reportedWorkPackageFromJson as reportedWorkPackageFromJson, stateJson_serviceStatisticsEntryFromJson as serviceStatisticsEntryFromJson, stateJson_ticketFromJson as ticketFromJson, stateJson_validatorDataFromJson as validatorDataFromJson };
+  export type { stateJson_ServiceStatisticsEntry as ServiceStatisticsEntry };
+}
+
+/**
+ * State Merkleization and proof generation.
+ *
+ * This module provides functionality for computing Merkle roots of state data
+ * and generating/verifying Merkle proofs.
+ *
+ * @module state-merkleization
+ */
+
+type stateMerkleization_SerializedService = SerializedService;
+declare const stateMerkleization_SerializedService: typeof SerializedService;
+type stateMerkleization_SerializedState<T extends SerializedStateBackend = SerializedStateBackend> = SerializedState<T>;
+declare const stateMerkleization_SerializedState: typeof SerializedState;
+type stateMerkleization_SerializedStateBackend = SerializedStateBackend;
+type stateMerkleization_SerializedStateView<T extends SerializedStateBackend> = SerializedStateView<T>;
+declare const stateMerkleization_SerializedStateView: typeof SerializedStateView;
+type stateMerkleization_StateCodec<T, V = T> = StateCodec<T, V>;
+type stateMerkleization_StateEntries = StateEntries;
+declare const stateMerkleization_StateEntries: typeof StateEntries;
+type stateMerkleization_StateEntryUpdate = StateEntryUpdate;
+type stateMerkleization_StateEntryUpdateAction = StateEntryUpdateAction;
+declare const stateMerkleization_StateEntryUpdateAction: typeof StateEntryUpdateAction;
+type stateMerkleization_StateKey = StateKey;
+type stateMerkleization_StateKeyIdx = StateKeyIdx;
+declare const stateMerkleization_StateKeyIdx: typeof StateKeyIdx;
+declare const stateMerkleization_binaryMerkleization: typeof binaryMerkleization;
+declare const stateMerkleization_dumpCodec: typeof dumpCodec;
+declare const stateMerkleization_legacyServiceNested: typeof legacyServiceNested;
+declare const stateMerkleization_loadState: typeof loadState;
+import stateMerkleization_serialize = serialize;
+declare const stateMerkleization_serializeStateUpdate: typeof serializeStateUpdate;
+import stateMerkleization_stateKeys = stateKeys;
+declare namespace stateMerkleization {
+  export { stateMerkleization_SerializedService as SerializedService, stateMerkleization_SerializedState as SerializedState, stateMerkleization_SerializedStateView as SerializedStateView, stateMerkleization_StateEntries as StateEntries, stateMerkleization_StateEntryUpdateAction as StateEntryUpdateAction, stateMerkleization_StateKeyIdx as StateKeyIdx, stateMerkleization_binaryMerkleization as binaryMerkleization, stateMerkleization_dumpCodec as dumpCodec, stateMerkleization_legacyServiceNested as legacyServiceNested, stateMerkleization_loadState as loadState, stateMerkleization_serialize as serialize, stateMerkleization_serializeStateUpdate as serializeStateUpdate, stateMerkleization_stateKeys as stateKeys };
+  export type { stateMerkleization_SerializedStateBackend as SerializedStateBackend, stateMerkleization_StateCodec as StateCodec, stateMerkleization_StateEntryUpdate as StateEntryUpdate, stateMerkleization_StateKey as StateKey };
 }
 
 declare class StateKeyVal {
@@ -11558,22 +11562,256 @@ declare class StateTransition {
     block: Block;
 }
 
-type index_StateKeyVal = StateKeyVal;
-declare const index_StateKeyVal: typeof StateKeyVal;
-type index_StateTransition = StateTransition;
-declare const index_StateTransition: typeof StateTransition;
-type index_StateTransitionGenesis = StateTransitionGenesis;
-declare const index_StateTransitionGenesis: typeof StateTransitionGenesis;
-type index_TestState = TestState;
-declare const index_TestState: typeof TestState;
-declare namespace index {
+/**
+ * State test vectors and fixtures.
+ *
+ * This module provides test vectors and fixtures for validating state
+ * operations and ensuring conformance with the JAM specification.
+ *
+ * @module state-vectors
+ */
+
+type stateVectors_StateKeyVal = StateKeyVal;
+declare const stateVectors_StateKeyVal: typeof StateKeyVal;
+type stateVectors_StateTransition = StateTransition;
+declare const stateVectors_StateTransition: typeof StateTransition;
+type stateVectors_StateTransitionGenesis = StateTransitionGenesis;
+declare const stateVectors_StateTransitionGenesis: typeof StateTransitionGenesis;
+type stateVectors_TestState = TestState;
+declare const stateVectors_TestState: typeof TestState;
+declare namespace stateVectors {
   export {
-    index_StateKeyVal as StateKeyVal,
-    index_StateTransition as StateTransition,
-    index_StateTransitionGenesis as StateTransitionGenesis,
-    index_TestState as TestState,
+    stateVectors_StateKeyVal as StateKeyVal,
+    stateVectors_StateTransition as StateTransition,
+    stateVectors_StateTransitionGenesis as StateTransitionGenesis,
+    stateVectors_TestState as TestState,
   };
 }
 
-export { TEST_COMPARE_USING, __OPAQUE_TYPE__, __REPRESENTATION_BYTES__, index$s as block, index$q as block_json, index$y as bytes, index$x as codec, index$v as collections, index$t as config, index$p as config_node, index$u as crypto, index$k as database, index$j as erasure_coding, index$h as fuzz_proto, index$w as hash, index$9 as jam_host_calls, index$r as json_parser, index$f as logger, index$n as mmr, index$B as numbers, index$A as ordering, index$e as pvm, index$d as pvm_host_calls, index$3 as pvm_interpreter, index$2 as shuffling, index$m as state, index$1 as state_json, index$l as state_merkleization, index as state_vectors, index$7 as transition, index$o as trie, index$6 as typeberry, index$z as utils, index$g as workers };
+/**
+ * State transition functions and logic.
+ *
+ * This module provides the state transition functions that define how JAM state
+ * evolves in response to blocks, extrinsics, and other events.
+ *
+ * @module transition
+ */
+
+type transition_ACCUMULATION_ERROR = ACCUMULATION_ERROR;
+type transition_Accumulate = Accumulate;
+declare const transition_Accumulate: typeof Accumulate;
+type transition_AccumulateInput = AccumulateInput;
+type transition_AccumulateOptions = AccumulateOptions;
+type transition_AccumulateResult = AccumulateResult;
+type transition_AccumulateRoot = AccumulateRoot;
+type transition_AccumulateState = AccumulateState;
+type transition_AccumulateStateUpdate = AccumulateStateUpdate;
+type transition_Assurances = Assurances;
+declare const transition_Assurances: typeof Assurances;
+type transition_AssurancesError = AssurancesError;
+declare const transition_AssurancesError: typeof AssurancesError;
+type transition_AssurancesInput = AssurancesInput;
+type transition_AssurancesState = AssurancesState;
+type transition_AssurancesStateUpdate = AssurancesStateUpdate;
+type transition_Authorization = Authorization;
+declare const transition_Authorization: typeof Authorization;
+type transition_AuthorizationInput = AuthorizationInput;
+type transition_AuthorizationState = AuthorizationState;
+type transition_AuthorizationStateUpdate = AuthorizationStateUpdate;
+type transition_BlockVerifier = BlockVerifier;
+declare const transition_BlockVerifier: typeof BlockVerifier;
+type transition_BlockVerifierError = BlockVerifierError;
+declare const transition_BlockVerifierError: typeof BlockVerifierError;
+type transition_CountAndGasUsed = CountAndGasUsed;
+type transition_DbHeaderChain = DbHeaderChain;
+declare const transition_DbHeaderChain: typeof DbHeaderChain;
+type transition_DeferredTransfers = DeferredTransfers;
+declare const transition_DeferredTransfers: typeof DeferredTransfers;
+type transition_DeferredTransfersErrorCode = DeferredTransfersErrorCode;
+declare const transition_DeferredTransfersErrorCode: typeof DeferredTransfersErrorCode;
+type transition_DeferredTransfersResult = DeferredTransfersResult;
+type transition_DeferredTransfersState = DeferredTransfersState;
+type transition_Disputes = Disputes;
+declare const transition_Disputes: typeof Disputes;
+type transition_DisputesState = DisputesState;
+type transition_DisputesStateUpdate = DisputesStateUpdate;
+declare const transition_GAS_TO_INVOKE_WORK_REPORT: typeof GAS_TO_INVOKE_WORK_REPORT;
+type transition_HeaderChain = HeaderChain;
+type transition_Input = Input;
+type transition_Ok = Ok;
+type transition_OnChain = OnChain;
+declare const transition_OnChain: typeof OnChain;
+type transition_Preimages = Preimages;
+declare const transition_Preimages: typeof Preimages;
+type transition_PreimagesErrorCode = PreimagesErrorCode;
+declare const transition_PreimagesErrorCode: typeof PreimagesErrorCode;
+type transition_PreimagesInput = PreimagesInput;
+type transition_PreimagesState = PreimagesState;
+type transition_PreimagesStateUpdate = PreimagesStateUpdate;
+declare const transition_REPORT_TIMEOUT_GRACE_PERIOD: typeof REPORT_TIMEOUT_GRACE_PERIOD;
+type transition_RecentHistory = RecentHistory;
+declare const transition_RecentHistory: typeof RecentHistory;
+type transition_RecentHistoryInput = RecentHistoryInput;
+type transition_RecentHistoryPartialInput = RecentHistoryPartialInput;
+type transition_RecentHistoryState = RecentHistoryState;
+type transition_RecentHistoryStateUpdate = RecentHistoryStateUpdate;
+type transition_Reports = Reports;
+declare const transition_Reports: typeof Reports;
+type transition_ReportsError = ReportsError;
+declare const transition_ReportsError: typeof ReportsError;
+type transition_ReportsInput = ReportsInput;
+type transition_ReportsOutput = ReportsOutput;
+type transition_ReportsState = ReportsState;
+type transition_ReportsStateUpdate = ReportsStateUpdate;
+type transition_Statistics = Statistics;
+declare const transition_Statistics: typeof Statistics;
+type transition_StatisticsState = StatisticsState;
+type transition_StatisticsStateUpdate = StatisticsStateUpdate;
+type transition_StfError = StfError;
+type transition_StfErrorKind = StfErrorKind;
+declare const transition_StfErrorKind: typeof StfErrorKind;
+type transition_TransitionHasher = TransitionHasher;
+declare const transition_TransitionHasher: typeof TransitionHasher;
+declare const transition_copyAndUpdateState: typeof copyAndUpdateState;
+declare const transition_stfError: typeof stfError;
+declare namespace transition {
+  export { transition_Accumulate as Accumulate, transition_Assurances as Assurances, transition_AssurancesError as AssurancesError, transition_Authorization as Authorization, transition_BlockVerifier as BlockVerifier, transition_BlockVerifierError as BlockVerifierError, transition_DbHeaderChain as DbHeaderChain, transition_DeferredTransfers as DeferredTransfers, transition_DeferredTransfersErrorCode as DeferredTransfersErrorCode, transition_Disputes as Disputes, transition_GAS_TO_INVOKE_WORK_REPORT as GAS_TO_INVOKE_WORK_REPORT, transition_OnChain as OnChain, transition_Preimages as Preimages, transition_PreimagesErrorCode as PreimagesErrorCode, transition_REPORT_TIMEOUT_GRACE_PERIOD as REPORT_TIMEOUT_GRACE_PERIOD, transition_RecentHistory as RecentHistory, transition_Reports as Reports, transition_ReportsError as ReportsError, transition_Statistics as Statistics, transition_StfErrorKind as StfErrorKind, transition_TransitionHasher as TransitionHasher, transition_copyAndUpdateState as copyAndUpdateState, index$2 as externalities, transition_stfError as stfError };
+  export type { transition_ACCUMULATION_ERROR as ACCUMULATION_ERROR, transition_AccumulateInput as AccumulateInput, transition_AccumulateOptions as AccumulateOptions, transition_AccumulateResult as AccumulateResult, transition_AccumulateRoot as AccumulateRoot, transition_AccumulateState as AccumulateState, transition_AccumulateStateUpdate as AccumulateStateUpdate, transition_AssurancesInput as AssurancesInput, transition_AssurancesState as AssurancesState, transition_AssurancesStateUpdate as AssurancesStateUpdate, transition_AuthorizationInput as AuthorizationInput, transition_AuthorizationState as AuthorizationState, transition_AuthorizationStateUpdate as AuthorizationStateUpdate, transition_CountAndGasUsed as CountAndGasUsed, transition_DeferredTransfersResult as DeferredTransfersResult, transition_DeferredTransfersState as DeferredTransfersState, transition_DisputesState as DisputesState, transition_DisputesStateUpdate as DisputesStateUpdate, transition_HeaderChain as HeaderChain, transition_Input as Input, transition_Ok as Ok, transition_PreimagesInput as PreimagesInput, transition_PreimagesState as PreimagesState, transition_PreimagesStateUpdate as PreimagesStateUpdate, transition_RecentHistoryInput as RecentHistoryInput, transition_RecentHistoryPartialInput as RecentHistoryPartialInput, transition_RecentHistoryState as RecentHistoryState, transition_RecentHistoryStateUpdate as RecentHistoryStateUpdate, transition_ReportsInput as ReportsInput, transition_ReportsOutput as ReportsOutput, transition_ReportsState as ReportsState, transition_ReportsStateUpdate as ReportsStateUpdate, transition_StatisticsState as StatisticsState, transition_StatisticsStateUpdate as StatisticsStateUpdate, transition_StfError as StfError };
+}
+
+/**
+ * Trie data structures and operations.
+ *
+ * This module provides trie (prefix tree) data structures used for efficient
+ * key-value storage and Merkle proof generation.
+ *
+ * @module trie
+ */
+
+type trie_BranchNode = BranchNode;
+declare const trie_BranchNode: typeof BranchNode;
+type trie_InMemoryTrie = InMemoryTrie;
+declare const trie_InMemoryTrie: typeof InMemoryTrie;
+type trie_InputKey = InputKey;
+type trie_LeafNode = LeafNode;
+declare const trie_LeafNode: typeof LeafNode;
+type trie_NodeType = NodeType;
+declare const trie_NodeType: typeof NodeType;
+type trie_NodesDb = NodesDb;
+declare const trie_NodesDb: typeof NodesDb;
+declare const trie_TRIE_NODE_BYTES: typeof TRIE_NODE_BYTES;
+declare const trie_TRUNCATED_KEY_BITS: typeof TRUNCATED_KEY_BITS;
+type trie_TRUNCATED_KEY_BYTES = TRUNCATED_KEY_BYTES;
+type trie_TrieHasher = TrieHasher;
+type trie_TrieNode = TrieNode;
+declare const trie_TrieNode: typeof TrieNode;
+type trie_TrieNodeHash = TrieNodeHash;
+type trie_TruncatedStateKey = TruncatedStateKey;
+type trie_ValueHash = ValueHash;
+type trie_WriteableNodesDb = WriteableNodesDb;
+declare const trie_WriteableNodesDb: typeof WriteableNodesDb;
+declare const trie_findSharedPrefix: typeof findSharedPrefix;
+declare const trie_leafComparator: typeof leafComparator;
+declare const trie_parseInputKey: typeof parseInputKey;
+declare namespace trie {
+  export { trie_BranchNode as BranchNode, trie_InMemoryTrie as InMemoryTrie, trie_LeafNode as LeafNode, trie_NodeType as NodeType, trie_NodesDb as NodesDb, trie_TRIE_NODE_BYTES as TRIE_NODE_BYTES, trie_TRUNCATED_KEY_BITS as TRUNCATED_KEY_BITS, trie_TrieNode as TrieNode, trie_WriteableNodesDb as WriteableNodesDb, trie_findSharedPrefix as findSharedPrefix, trie_leafComparator as leafComparator, trie_parseInputKey as parseInputKey };
+  export type { trie_InputKey as InputKey, StateKey$1 as StateKey, trie_TRUNCATED_KEY_BYTES as TRUNCATED_KEY_BYTES, trie_TrieHasher as TrieHasher, trie_TrieNodeHash as TrieNodeHash, trie_TruncatedStateKey as TruncatedStateKey, trie_ValueHash as ValueHash };
+}
+
+/**
+ * General utility functions and helpers.
+ *
+ * This module provides a collection of general-purpose utility functions,
+ * type helpers, and common operations used throughout Typeberry.
+ *
+ * @module utils
+ */
+
+declare const utils_CURRENT_SUITE: typeof CURRENT_SUITE;
+declare const utils_CURRENT_VERSION: typeof CURRENT_VERSION;
+type utils_Compatibility = Compatibility;
+declare const utils_Compatibility: typeof Compatibility;
+declare const utils_DEFAULT_SUITE: typeof DEFAULT_SUITE;
+declare const utils_DEFAULT_VERSION: typeof DEFAULT_VERSION;
+type utils_DeepEqualOptions = DeepEqualOptions;
+type utils_ErrorResult<Error> = ErrorResult<Error>;
+type utils_ErrorsCollector = ErrorsCollector;
+declare const utils_ErrorsCollector: typeof ErrorsCollector;
+type utils_GpVersion = GpVersion;
+declare const utils_GpVersion: typeof GpVersion;
+declare const utils_MAX_LENGTH: typeof MAX_LENGTH;
+type utils_OK = OK;
+type utils_OkResult<Ok> = OkResult<Ok>;
+type utils_Opaque<Type, Token extends string> = Opaque<Type, Token>;
+declare const utils_Result: typeof Result;
+declare const utils_TEST_COMPARE_USING: typeof TEST_COMPARE_USING;
+type utils_TaggedError<Kind, Nested> = TaggedError<Kind, Nested>;
+type utils_TestSuite = TestSuite;
+declare const utils_TestSuite: typeof TestSuite;
+type utils_TokenOf<OpaqueType, Type> = TokenOf<OpaqueType, Type>;
+type utils_WithDebug = WithDebug;
+declare const utils_WithDebug: typeof WithDebug;
+type utils_WithOpaque<Token extends string> = WithOpaque<Token>;
+declare const utils___OPAQUE_TYPE__: typeof __OPAQUE_TYPE__;
+declare const utils_asOpaqueType: typeof asOpaqueType;
+declare const utils_assertEmpty: typeof assertEmpty;
+declare const utils_assertNever: typeof assertNever;
+declare const utils_check: typeof check;
+declare const utils_deepEqual: typeof deepEqual;
+declare const utils_env: typeof env;
+declare const utils_inspect: typeof inspect;
+declare const utils_isBrowser: typeof isBrowser;
+declare const utils_lazyInspect: typeof lazyInspect;
+declare const utils_measure: typeof measure;
+declare const utils_now: typeof now;
+declare const utils_resultToString: typeof resultToString;
+declare const utils_safeAllocUint8Array: typeof safeAllocUint8Array;
+declare const utils_seeThrough: typeof seeThrough;
+declare const utils_workspacePathFix: typeof workspacePathFix;
+declare namespace utils {
+  export { utils_CURRENT_SUITE as CURRENT_SUITE, utils_CURRENT_VERSION as CURRENT_VERSION, utils_Compatibility as Compatibility, utils_DEFAULT_SUITE as DEFAULT_SUITE, utils_DEFAULT_VERSION as DEFAULT_VERSION, utils_ErrorsCollector as ErrorsCollector, utils_GpVersion as GpVersion, utils_MAX_LENGTH as MAX_LENGTH, utils_Result as Result, utils_TEST_COMPARE_USING as TEST_COMPARE_USING, utils_TestSuite as TestSuite, utils_WithDebug as WithDebug, utils___OPAQUE_TYPE__ as __OPAQUE_TYPE__, utils_asOpaqueType as asOpaqueType, utils_assertEmpty as assertEmpty, utils_assertNever as assertNever, utils_check as check, utils_deepEqual as deepEqual, utils_env as env, utils_inspect as inspect, utils_isBrowser as isBrowser, utils_lazyInspect as lazyInspect, utils_measure as measure, utils_now as now, utils_resultToString as resultToString, utils_safeAllocUint8Array as safeAllocUint8Array, utils_seeThrough as seeThrough, utils_workspacePathFix as workspacePathFix };
+  export type { utils_DeepEqualOptions as DeepEqualOptions, utils_ErrorResult as ErrorResult, utils_OK as OK, utils_OkResult as OkResult, utils_Opaque as Opaque, utils_TaggedError as TaggedError, utils_TokenOf as TokenOf, utils_WithOpaque as WithOpaque };
+}
+
+/**
+ * Workers API and multi-threading utilities.
+ *
+ * This module provides the Workers API for parallel processing and multi-threading,
+ * enabling efficient utilization of system resources.
+ *
+ * @module workers-api
+ */
+
+type workersApi_Api<T> = Api<T>;
+type workersApi_Channel = Channel;
+declare const workersApi_Channel: typeof Channel;
+type workersApi_Destroy = Destroy;
+type workersApi_DirectPort = DirectPort;
+declare const workersApi_DirectPort: typeof DirectPort;
+type workersApi_DirectWorkerConfig<TParams = void, TBlocks = BlocksDb, TStates = StatesDb> = DirectWorkerConfig<TParams, TBlocks, TStates>;
+declare const workersApi_DirectWorkerConfig: typeof DirectWorkerConfig;
+type workersApi_Envelope<T> = Envelope<T>;
+type workersApi_Handler<Req, Res> = Handler<Req, Res>;
+type workersApi_HandlerKey<K> = HandlerKey<K>;
+type workersApi_Handlers<In> = Handlers<In>;
+type workersApi_Internal<T> = Internal<T>;
+type workersApi_LousyProtocol<To, From> = LousyProtocol<To, From>;
+type workersApi_MessageCodecs<Req, Res> = MessageCodecs<Req, Res>;
+type workersApi_MessagesList<T> = MessagesList<T>;
+type workersApi_Port = Port;
+type workersApi_Protocol<To, From> = Protocol<To, From>;
+type workersApi_Rx<To, From> = Rx<To, From>;
+type workersApi_Sender<Req, Res> = Sender<Req, Res>;
+type workersApi_SenderKey<K> = SenderKey<K>;
+type workersApi_Senders<Out> = Senders<Out>;
+type workersApi_Tx<To, From> = Tx<To, From>;
+type workersApi_WorkerConfig<TParams = void, TBlocks = BlocksDb, TStates = StatesDb> = WorkerConfig<TParams, TBlocks, TStates>;
+declare const workersApi_createProtocol: typeof createProtocol;
+declare const workersApi_startSameThread: typeof startSameThread;
+declare namespace workersApi {
+  export { workersApi_Channel as Channel, workersApi_DirectPort as DirectPort, workersApi_DirectWorkerConfig as DirectWorkerConfig, workersApi_createProtocol as createProtocol, workersApi_startSameThread as startSameThread };
+  export type { workersApi_Api as Api, workersApi_Destroy as Destroy, workersApi_Envelope as Envelope, workersApi_Handler as Handler, workersApi_HandlerKey as HandlerKey, workersApi_Handlers as Handlers, workersApi_Internal as Internal, workersApi_LousyProtocol as LousyProtocol, workersApi_MessageCodecs as MessageCodecs, workersApi_MessagesList as MessagesList, workersApi_Port as Port, workersApi_Protocol as Protocol, workersApi_Rx as Rx, workersApi_Sender as Sender, workersApi_SenderKey as SenderKey, workersApi_Senders as Senders, workersApi_Tx as Tx, workersApi_WorkerConfig as WorkerConfig };
+}
+
+export { TEST_COMPARE_USING, __OPAQUE_TYPE__, __REPRESENTATION_BYTES__, block, blockJson as block_json, bytes, codec, collections, config, configNode as config_node, crypto, database, erasureCoding as erasure_coding, fuzzProto as fuzz_proto, hash, jamHostCalls as jam_host_calls, jsonParser as json_parser, logger, mmr, numbers, ordering, pvmInterface as pvm, pvmHostCalls as pvm_host_calls, pvmInterpreter as pvm_interpreter, shuffling, state, stateJson as state_json, stateMerkleization as state_merkleization, stateVectors as state_vectors, transition, trie, importer as typeberry, utils, workersApi as workers };
 export type { WithBytesRepresentation, WithOpaque };