@typeberry/convert 0.5.1 → 0.5.2-03e1aed

package/index.js

@@ -3871,6 +3871,17 @@ module.exports = __nccwpck_require__.p + "ccf8ada94096a8f232f5.js?reed_solomon_w
 /******/ 	__nccwpck_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
 /******/ })();
 /******/ 
+/******/ /* webpack/runtime/make namespace object */
+/******/ (() => {
+/******/ 	// define __esModule on exports
+/******/ 	__nccwpck_require__.r = (exports) => {
+/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 		}
+/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 	};
+/******/ })();
+/******/ 
 /******/ /* webpack/runtime/publicPath */
 /******/ (() => {
 /******/ 	var scriptUrl;
@@ -3913,6 +3924,44 @@ module.exports = __nccwpck_require__.p + "ccf8ada94096a8f232f5.js?reed_solomon_w
 /************************************************************************/
 var __webpack_exports__ = {};
 
+// NAMESPACE OBJECT: ./packages/core/codec/descriptors.ts
+var descriptors_namespaceObject = {};
+__nccwpck_require__.r(descriptors_namespaceObject);
+__nccwpck_require__.d(descriptors_namespaceObject, {
+  Class: () => (Class),
+  TYPICAL_DICTIONARY_LENGTH: () => (TYPICAL_DICTIONARY_LENGTH),
+  bitVecFixLen: () => (bitVecFixLen),
+  bitVecVarLen: () => (bitVecVarLen),
+  blob: () => (blob),
+  bool: () => (bool),
+  bytes: () => (bytes),
+  custom: () => (custom),
+  dictionary: () => (dictionary),
+  forEachDescriptor: () => (forEachDescriptor),
+  i16: () => (i16),
+  i24: () => (i24),
+  i32: () => (i32),
+  i64: () => (i64),
+  i8: () => (i8),
+  nothing: () => (nothing),
+  object: () => (object),
+  optional: () => (optional),
+  pair: () => (pair),
+  readonlyArray: () => (readonlyArray),
+  select: () => (descriptors_select),
+  sequenceFixLen: () => (sequenceFixLen),
+  sequenceVarLen: () => (sequenceVarLen),
+  string: () => (string),
+  u16: () => (u16),
+  u24: () => (u24),
+  u32: () => (u32),
+  u64: () => (u64),
+  u8: () => (u8),
+  union: () => (union),
+  varU32: () => (varU32),
+  varU64: () => (varU64)
+});
+
 ;// CONCATENATED MODULE: ./packages/core/logger/options.ts
 var Level;
 (function (Level) {
@@ -4846,7 +4895,7 @@ function isResult(x) {
 var minimist = __nccwpck_require__(595);
 var minimist_default = /*#__PURE__*/__nccwpck_require__.n(minimist);
 ;// CONCATENATED MODULE: ./bin/convert/package.json
-const package_namespaceObject = {"rE":"0.5.1"};
+const package_namespaceObject = {"rE":"0.5.2"};
 ;// CONCATENATED MODULE: ./packages/core/bytes/bitvec.ts
 
 /**
@@ -6627,6 +6676,48 @@ const pair = (a, b) => {
 };
 /** Custom encoding / decoding logic. */
 const custom = ({ name, sizeHint = { bytes: 0, isExact: false }, }, encode, decode, skip) => Descriptor.new(name, sizeHint, encode, decode, skip);
+/** Tagged union type encoding. */
+const union = (name, variants) => {
+    const keys = Object.keys(variants).map(Number);
+    const variantMap = Object.fromEntries(keys.map((key, idx) => [key, idx]));
+    const indexToKey = Object.fromEntries(keys.map((key, idx) => [idx, key]));
+    // Calculate size hint as the minimum variant size + index size
+    const minVariantSize = Math.max(...keys.map((key) => variants[key].sizeHint.bytes));
+    const sizeHint = {
+        bytes: 1 + minVariantSize, // varU32 index + smallest variant
+        isExact: false,
+    };
+    const encode = (e, x) => {
+        const idx = variantMap[x.kind];
+        if (idx === undefined) {
+            throw new Error(`Unknown variant type: ${x.kind} for ${name}`);
+        }
+        e.varU32(numbers_tryAsU32(idx));
+        const codec = variants[x.kind];
+        // I'm sorry but I can't figure out a better typing here :)
+        codec.encode(e, x);
+    };
+    const decode = (d) => {
+        const idx = d.varU32();
+        const kind = indexToKey[idx];
+        if (kind === undefined) {
+            throw new Error(`Unknown variant index: ${idx} for ${name}`);
+        }
+        const codec = variants[kind];
+        const value = codec.decode(d);
+        return { kind, ...value };
+    };
+    const skip = (s) => {
+        const idx = s.decoder.varU32();
+        const kind = indexToKey[idx];
+        if (kind === undefined) {
+            throw new Error(`Unknown variant index: ${idx} for ${name}`);
+        }
+        const codec = variants[kind];
+        codec.skip(s);
+    };
+    return Descriptor.new(name, sizeHint, encode, decode, skip);
+};
 /** Choose a descriptor depending on the encoding/decoding context. */
 const descriptors_select = ({ name, sizeHint, }, chooser) => {
     const Self = chooser(null);
@@ -6778,6 +6869,11 @@ function sequenceViewFixLen(type, { fixedLength }) {
 
 
 
+// additional re-export of descriptors namespace under `codec`
+// note we export descriptors in top level as well,
+// because writing `codec.codec.u32` when using the library looks weird
+
+const codec_codec = descriptors_namespaceObject;
 
 ;// CONCATENATED MODULE: ./node_modules/@typeberry/native/chunk-CPmnHcRE.js
 //#region rolldown:runtime
@@ -9117,7 +9213,7 @@ function codecWithContext(chooser) {
     const defaultContext = chain_spec_fullChainSpec;
     const { name, sizeHint } = chooser(defaultContext);
     const cache = new Map();
-    return descriptors_select({
+    return codec_codec.select({
         name,
         sizeHint: { bytes: sizeHint.bytes, isExact: false },
     }, (context) => {
@@ -9144,9 +9240,9 @@ function codecWithContext(chooser) {
 /** Codec for a known-size array with length validation. */
 const codecKnownSizeArray = (val, options, _id) => {
     if ("fixedLength" in options) {
-        return readonlyArray(sequenceFixLen(val, options.fixedLength)).convert(seeThrough, sized_array_asKnownSize);
+        return codec_codec.readonlyArray(codec_codec.sequenceFixLen(val, options.fixedLength)).convert(seeThrough, sized_array_asKnownSize);
     }
-    return readonlyArray(sequenceVarLen(val, options)).convert(seeThrough, sized_array_asKnownSize);
+    return codec_codec.readonlyArray(codec_codec.sequenceVarLen(val, options)).convert(seeThrough, sized_array_asKnownSize);
 };
 /** Codec for a fixed-size array with length validation. */
 const codecFixedSizeArray = (val, len) => {
@@ -9155,7 +9251,7 @@ const codecFixedSizeArray = (val, len) => {
             throw new Error(`[${val.name}] Invalid size of fixed-size array. Got ${actual}, expected: ${len}`);
         }
     };
-    return sequenceFixLen(val, len).convert((i) => {
+    return codec_codec.sequenceFixLen(val, len).convert((i) => {
         checkLength(i.length);
         return i;
     }, (o) => {
@@ -9164,7 +9260,7 @@ const codecFixedSizeArray = (val, len) => {
     });
 };
 /** Codec for a hash-dictionary. */
-const codecHashDictionary = (value, extractKey, { typicalLength = TYPICAL_DICTIONARY_LENGTH, compare = (a, b) => extractKey(a).compare(extractKey(b)), } = {}) => {
+const codecHashDictionary = (value, extractKey, { typicalLength = codec_codec.TYPICAL_DICTIONARY_LENGTH, compare = (a, b) => extractKey(a).compare(extractKey(b)), } = {}) => {
     return Descriptor.new(`HashDictionary<${value.name}>[?]`, {
         bytes: typicalLength * value.sizeHint.bytes,
         isExact: false,
@@ -9216,13 +9312,13 @@ class AvailabilityAssurance extends WithDebug {
     bitfield;
     validatorIndex;
     signature;
-    static Codec = Class(AvailabilityAssurance, {
-        anchor: bytes(hash_HASH_SIZE).asOpaque(),
+    static Codec = codec_codec.Class(AvailabilityAssurance, {
+        anchor: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
         bitfield: codecWithContext((context) => {
-            return bitVecFixLen(context.coresCount);
+            return codec_codec.bitVecFixLen(context.coresCount);
         }),
-        validatorIndex: u16.asOpaque(),
-        signature: bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+        validatorIndex: codec_codec.u16.asOpaque(),
+        signature: codec_codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
     });
     static create({ anchor, bitfield, validatorIndex, signature }) {
         return new AvailabilityAssurance(anchor, bitfield, validatorIndex, signature);
@@ -9314,11 +9410,11 @@ class Fault extends WithDebug {
     wasConsideredValid;
     key;
     signature;
-    static Codec = Class(Fault, {
-        workReportHash: bytes(hash_HASH_SIZE).asOpaque(),
-        wasConsideredValid: bool,
-        key: bytes(ED25519_KEY_BYTES).asOpaque(),
-        signature: bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+    static Codec = codec_codec.Class(Fault, {
+        workReportHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        wasConsideredValid: codec_codec.bool,
+        key: codec_codec.bytes(ED25519_KEY_BYTES).asOpaque(),
+        signature: codec_codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
     });
     static create({ workReportHash, wasConsideredValid, key, signature }) {
         return new Fault(workReportHash, wasConsideredValid, key, signature);
@@ -9346,10 +9442,10 @@ class Culprit extends WithDebug {
     workReportHash;
     key;
     signature;
-    static Codec = Class(Culprit, {
-        workReportHash: bytes(hash_HASH_SIZE).asOpaque(),
-        key: bytes(ED25519_KEY_BYTES).asOpaque(),
-        signature: bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+    static Codec = codec_codec.Class(Culprit, {
+        workReportHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        key: codec_codec.bytes(ED25519_KEY_BYTES).asOpaque(),
+        signature: codec_codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
     });
     static create({ workReportHash, key, signature }) {
         return new Culprit(workReportHash, key, signature);
@@ -9374,10 +9470,10 @@ class Judgement extends WithDebug {
     isWorkReportValid;
     index;
     signature;
-    static Codec = Class(Judgement, {
-        isWorkReportValid: bool,
-        index: u16.asOpaque(),
-        signature: bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+    static Codec = codec_codec.Class(Judgement, {
+        isWorkReportValid: codec_codec.bool,
+        index: codec_codec.u16.asOpaque(),
+        signature: codec_codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
     });
     static create({ isWorkReportValid, index, signature }) {
         return new Judgement(isWorkReportValid, index, signature);
@@ -9406,11 +9502,12 @@ class Verdict extends WithDebug {
     workReportHash;
     votesEpoch;
     votes;
-    static Codec = Class(Verdict, {
-        workReportHash: bytes(hash_HASH_SIZE).asOpaque(),
-        votesEpoch: u32.asOpaque(),
+    static Codec = codec_codec.Class(Verdict, {
+        workReportHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        votesEpoch: codec_codec.u32.asOpaque(),
         votes: codecWithContext((context) => {
-            return readonlyArray(sequenceFixLen(Judgement.Codec, context.validatorsSuperMajority))
+            return codec_codec
+                .readonlyArray(codec_codec.sequenceFixLen(Judgement.Codec, context.validatorsSuperMajority))
                 .convert(seeThrough, sized_array_asKnownSize);
         }),
     });
@@ -9452,10 +9549,10 @@ class DisputesExtrinsic extends WithDebug {
     verdicts;
     culprits;
     faults;
-    static Codec = Class(DisputesExtrinsic, {
-        verdicts: sequenceVarLen(Verdict.Codec),
-        culprits: sequenceVarLen(Culprit.Codec),
-        faults: sequenceVarLen(Fault.Codec),
+    static Codec = codec_codec.Class(DisputesExtrinsic, {
+        verdicts: codec_codec.sequenceVarLen(Verdict.Codec),
+        culprits: codec_codec.sequenceVarLen(Culprit.Codec),
+        faults: codec_codec.sequenceVarLen(Fault.Codec),
     });
     static create({ verdicts, culprits, faults }) {
         return new DisputesExtrinsic(verdicts, culprits, faults);
@@ -9501,9 +9598,9 @@ class DisputesExtrinsic extends WithDebug {
 class WorkPackageInfo extends WithDebug {
     workPackageHash;
     segmentTreeRoot;
-    static Codec = Class(WorkPackageInfo, {
-        workPackageHash: bytes(hash_HASH_SIZE).asOpaque(),
-        segmentTreeRoot: bytes(hash_HASH_SIZE).asOpaque(),
+    static Codec = codec_codec.Class(WorkPackageInfo, {
+        workPackageHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        segmentTreeRoot: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
     });
     constructor(
     /** Hash of the described work package. */
@@ -9531,13 +9628,13 @@ class RefineContext extends WithDebug {
     lookupAnchor;
     lookupAnchorSlot;
     prerequisites;
-    static Codec = Class(RefineContext, {
-        anchor: bytes(hash_HASH_SIZE).asOpaque(),
-        stateRoot: bytes(hash_HASH_SIZE).asOpaque(),
-        beefyRoot: bytes(hash_HASH_SIZE).asOpaque(),
-        lookupAnchor: bytes(hash_HASH_SIZE).asOpaque(),
-        lookupAnchorSlot: u32.asOpaque(),
-        prerequisites: sequenceVarLen(bytes(hash_HASH_SIZE).asOpaque()),
+    static Codec = codec_codec.Class(RefineContext, {
+        anchor: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        stateRoot: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        beefyRoot: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        lookupAnchor: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        lookupAnchorSlot: codec_codec.u32.asOpaque(),
+        prerequisites: codec_codec.sequenceVarLen(codec_codec.bytes(hash_HASH_SIZE).asOpaque()),
     });
     static create({ anchor, stateRoot, beefyRoot, lookupAnchor, lookupAnchorSlot, prerequisites, }) {
         return new RefineContext(anchor, stateRoot, beefyRoot, lookupAnchor, lookupAnchorSlot, prerequisites);
@@ -9594,9 +9691,9 @@ const tryAsSegmentIndex = (v) => asOpaqueType(tryAsU16(v));
 class ImportSpec extends WithDebug {
     treeRoot;
     index;
-    static Codec = Class(ImportSpec, {
-        treeRoot: bytes(hash_HASH_SIZE),
-        index: u16.asOpaque(),
+    static Codec = codec_codec.Class(ImportSpec, {
+        treeRoot: codec_codec.bytes(hash_HASH_SIZE),
+        index: codec_codec.u16.asOpaque(),
     });
     static create({ treeRoot, index }) {
         return new ImportSpec(treeRoot, index);
@@ -9618,9 +9715,9 @@ class ImportSpec extends WithDebug {
 class WorkItemExtrinsicSpec extends WithDebug {
     hash;
     len;
-    static Codec = Class(WorkItemExtrinsicSpec, {
-        hash: bytes(hash_HASH_SIZE).asOpaque(),
-        len: u32,
+    static Codec = codec_codec.Class(WorkItemExtrinsicSpec, {
+        hash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        len: codec_codec.u32,
     });
     static create({ hash, len }) {
         return new WorkItemExtrinsicSpec(hash, len);
@@ -9680,19 +9777,19 @@ class work_item_WorkItem extends WithDebug {
     importSegments;
     extrinsic;
     exportCount;
-    static Codec = Class(work_item_WorkItem, {
-        service: u32.asOpaque(),
-        codeHash: bytes(hash_HASH_SIZE).asOpaque(),
-        refineGasLimit: u64.asOpaque(),
-        accumulateGasLimit: u64.asOpaque(),
-        exportCount: u16,
-        payload: blob,
+    static Codec = codec_codec.Class(work_item_WorkItem, {
+        service: codec_codec.u32.asOpaque(),
+        codeHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        refineGasLimit: codec_codec.u64.asOpaque(),
+        accumulateGasLimit: codec_codec.u64.asOpaque(),
+        exportCount: codec_codec.u16,
+        payload: codec_codec.blob,
         importSegments: codecKnownSizeArray(ImportSpec.Codec, {
             minLength: 0,
             maxLength: MAX_NUMBER_OF_SEGMENTS,
             typicalLength: MAX_NUMBER_OF_SEGMENTS,
         }),
-        extrinsic: sequenceVarLen(WorkItemExtrinsicSpec.Codec),
+        extrinsic: codec_codec.sequenceVarLen(WorkItemExtrinsicSpec.Codec),
     });
     static create({ service, codeHash, payload, refineGasLimit, accumulateGasLimit, importSegments, extrinsic, exportCount, }) {
         return new work_item_WorkItem(service, codeHash, payload, refineGasLimit, accumulateGasLimit, importSegments, extrinsic, exportCount);
@@ -9765,13 +9862,13 @@ class work_package_WorkPackage extends WithDebug {
     parametrization;
     context;
     items;
-    static Codec = Class(work_package_WorkPackage, {
-        authCodeHost: u32.asOpaque(),
-        authCodeHash: bytes(hash_HASH_SIZE).asOpaque(),
+    static Codec = codec_codec.Class(work_package_WorkPackage, {
+        authCodeHost: codec_codec.u32.asOpaque(),
+        authCodeHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
         context: RefineContext.Codec,
-        authorization: blob,
-        parametrization: blob,
-        items: sequenceVarLen(work_item_WorkItem.Codec).convert((x) => x, (items) => FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
+        authorization: codec_codec.blob,
+        parametrization: codec_codec.blob,
+        items: codec_codec.sequenceVarLen(work_item_WorkItem.Codec).convert((x) => x, (items) => FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
     });
     static create({ authorization, authCodeHost, authCodeHash, parametrization, context, items, }) {
         return new work_package_WorkPackage(authorization, authCodeHost, authCodeHash, parametrization, context, items);
@@ -9831,30 +9928,22 @@ var WorkExecResultKind;
 class WorkExecResult extends WithDebug {
     kind;
     okBlob;
-    static Codec = custom({
-        name: "WorkExecResult",
-        sizeHint: { bytes: 1, isExact: false },
-    }, (e, x) => {
-        e.varU32(numbers_tryAsU32(x.kind));
-        if (x.kind === WorkExecResultKind.ok && x.okBlob !== null) {
-            e.bytesBlob(x.okBlob);
-        }
-    }, (d) => {
-        const kind = d.varU32();
-        if (kind === WorkExecResultKind.ok) {
-            const blob = d.bytesBlob();
-            return new WorkExecResult(kind, blob);
-        }
-        if (kind > WorkExecResultKind.codeOversize) {
-            throw new Error(`Invalid WorkExecResultKind: ${kind}`);
-        }
-        return new WorkExecResult(kind);
-    }, (s) => {
-        const kind = s.decoder.varU32();
-        if (kind === WorkExecResultKind.ok) {
-            s.bytesBlob();
-        }
-    });
+    static Codec = codec_codec
+        .union("WorkExecResult", {
+        [WorkExecResultKind.ok]: codec_codec.object({ okBlob: codec_codec.blob }),
+        [WorkExecResultKind.outOfGas]: codec_codec.object({}),
+        [WorkExecResultKind.panic]: codec_codec.object({}),
+        [WorkExecResultKind.incorrectNumberOfExports]: codec_codec.object({}),
+        [WorkExecResultKind.digestTooBig]: codec_codec.object({}),
+        [WorkExecResultKind.badCode]: codec_codec.object({}),
+        [WorkExecResultKind.codeOversize]: codec_codec.object({}),
+    })
+        .convert((x) => {
+        if (x.kind === WorkExecResultKind.ok) {
+            return { kind: WorkExecResultKind.ok, okBlob: x.okBlob ?? bytes_BytesBlob.empty() };
+        }
+        return { kind: x.kind };
+    }, (x) => new WorkExecResult(x.kind, x.kind === WorkExecResultKind.ok ? x.okBlob : null));
     constructor(
     /** The execution result tag. */
     kind, 
@@ -9878,12 +9967,12 @@ class WorkRefineLoad extends WithDebug {
     extrinsicCount;
     extrinsicSize;
     exportedSegments;
-    static Codec = Class(WorkRefineLoad, {
-        gasUsed: varU64.asOpaque(),
-        importedSegments: varU32,
-        extrinsicCount: varU32,
-        extrinsicSize: varU32,
-        exportedSegments: varU32,
+    static Codec = codec_codec.Class(WorkRefineLoad, {
+        gasUsed: codec_codec.varU64.asOpaque(),
+        importedSegments: codec_codec.varU32,
+        extrinsicCount: codec_codec.varU32,
+        extrinsicSize: codec_codec.varU32,
+        exportedSegments: codec_codec.varU32,
     });
     static create({ gasUsed, importedSegments, extrinsicCount, extrinsicSize, exportedSegments, }) {
         return new WorkRefineLoad(gasUsed, importedSegments, extrinsicCount, extrinsicSize, exportedSegments);
@@ -9919,11 +10008,11 @@ class WorkResult {
     gas;
     result;
     load;
-    static Codec = Class(WorkResult, {
-        serviceId: u32.asOpaque(),
-        codeHash: bytes(hash_HASH_SIZE).asOpaque(),
-        payloadHash: bytes(hash_HASH_SIZE),
-        gas: u64.asOpaque(),
+    static Codec = codec_codec.Class(WorkResult, {
+        serviceId: codec_codec.u32.asOpaque(),
+        codeHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        payloadHash: codec_codec.bytes(hash_HASH_SIZE),
+        gas: codec_codec.u64.asOpaque(),
         result: WorkExecResult.Codec,
         load: WorkRefineLoad.Codec,
     });
@@ -9990,12 +10079,12 @@ class WorkPackageSpec extends WithDebug {
     erasureRoot;
     exportsRoot;
     exportsCount;
-    static Codec = Class(WorkPackageSpec, {
-        hash: bytes(hash_HASH_SIZE).asOpaque(),
-        length: u32,
-        erasureRoot: bytes(hash_HASH_SIZE),
-        exportsRoot: bytes(hash_HASH_SIZE).asOpaque(),
-        exportsCount: u16,
+    static Codec = codec_codec.Class(WorkPackageSpec, {
+        hash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        length: codec_codec.u32,
+        erasureRoot: codec_codec.bytes(hash_HASH_SIZE),
+        exportsRoot: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        exportsCount: codec_codec.u16,
     });
     static create({ hash, length, erasureRoot, exportsRoot, exportsCount }) {
         return new WorkPackageSpec(hash, length, erasureRoot, exportsRoot, exportsCount);
@@ -10033,20 +10122,20 @@ class WorkReport extends WithDebug {
     segmentRootLookup;
     results;
     authorizationGasUsed;
-    static Codec = Class(WorkReport, {
+    static Codec = codec_codec.Class(WorkReport, {
         workPackageSpec: WorkPackageSpec.Codec,
         context: RefineContext.Codec,
-        coreIndex: varU32.convert((o) => numbers_tryAsU32(o), (i) => {
+        coreIndex: codec_codec.varU32.convert((o) => numbers_tryAsU32(o), (i) => {
             if (!isU16(i)) {
                 throw new Error(`Core index exceeds U16: ${i}`);
             }
             return tryAsCoreIndex(i);
         }),
-        authorizerHash: bytes(hash_HASH_SIZE).asOpaque(),
-        authorizationGasUsed: varU64.asOpaque(),
-        authorizationOutput: blob,
-        segmentRootLookup: readonlyArray(sequenceVarLen(WorkPackageInfo.Codec)),
-        results: sequenceVarLen(WorkResult.Codec).convert((x) => x, (items) => FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
+        authorizerHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        authorizationGasUsed: codec_codec.varU64.asOpaque(),
+        authorizationOutput: codec_codec.blob,
+        segmentRootLookup: codec_codec.readonlyArray(codec_codec.sequenceVarLen(WorkPackageInfo.Codec)),
+        results: codec_codec.sequenceVarLen(WorkResult.Codec).convert((x) => x, (items) => FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
     });
     static create({ workPackageSpec, context, coreIndex, authorizerHash, authorizationOutput, segmentRootLookup, results, authorizationGasUsed, }) {
         return new WorkReport(workPackageSpec, context, coreIndex, authorizerHash, authorizationOutput, segmentRootLookup, results, authorizationGasUsed);
@@ -10094,9 +10183,9 @@ const REQUIRED_CREDENTIALS_RANGE = [2, 3];
 class Credential extends WithDebug {
     validatorIndex;
     signature;
-    static Codec = Class(Credential, {
-        validatorIndex: u16.asOpaque(),
-        signature: bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+    static Codec = codec_codec.Class(Credential, {
+        validatorIndex: codec_codec.u16.asOpaque(),
+        signature: codec_codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
     });
     static create({ validatorIndex, signature }) {
         return new Credential(validatorIndex, signature);
@@ -10120,9 +10209,9 @@ class ReportGuarantee extends WithDebug {
     report;
     slot;
     credentials;
-    static Codec = Class(ReportGuarantee, {
+    static Codec = codec_codec.Class(ReportGuarantee, {
         report: WorkReport.Codec,
-        slot: u32.asOpaque(),
+        slot: codec_codec.u32.asOpaque(),
         credentials: codecKnownSizeArray(Credential.Codec, {
             minLength: REQUIRED_CREDENTIALS_RANGE[0],
             maxLength: REQUIRED_CREDENTIALS_RANGE[1],
@@ -10172,10 +10261,10 @@ function tryAsTicketAttempt(x) {
 class SignedTicket extends WithDebug {
     attempt;
     signature;
-    static Codec = Class(SignedTicket, {
+    static Codec = codec_codec.Class(SignedTicket, {
         // TODO [ToDr] we should verify that attempt is either 0|1|2.
-        attempt: u8.asOpaque(),
-        signature: bytes(BANDERSNATCH_PROOF_BYTES).asOpaque(),
+        attempt: codec_codec.u8.asOpaque(),
+        signature: codec_codec.bytes(BANDERSNATCH_PROOF_BYTES).asOpaque(),
     });
     static create({ attempt, signature }) {
         return new SignedTicket(attempt, signature);
@@ -10194,10 +10283,10 @@ class SignedTicket extends WithDebug {
 class Ticket extends WithDebug {
     id;
     attempt;
-    static Codec = Class(Ticket, {
-        id: bytes(hash_HASH_SIZE),
+    static Codec = codec_codec.Class(Ticket, {
+        id: codec_codec.bytes(hash_HASH_SIZE),
         // TODO [ToDr] we should verify that attempt is either 0|1|2.
-        attempt: u8.asOpaque(),
+        attempt: codec_codec.u8.asOpaque(),
     });
     static create({ id, attempt }) {
         return new Ticket(id, attempt);
@@ -10249,9 +10338,9 @@ const ticketsExtrinsicCodec = codecWithContext((context) => {
 class ValidatorKeys extends WithDebug {
     bandersnatch;
     ed25519;
-    static Codec = Class(ValidatorKeys, {
-        bandersnatch: bytes(BANDERSNATCH_KEY_BYTES).asOpaque(),
-        ed25519: bytes(ED25519_KEY_BYTES).asOpaque(),
+    static Codec = codec_codec.Class(ValidatorKeys, {
+        bandersnatch: codec_codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque(),
+        ed25519: codec_codec.bytes(ED25519_KEY_BYTES).asOpaque(),
     });
     static create({ bandersnatch, ed25519 }) {
         return new ValidatorKeys(bandersnatch, ed25519);
@@ -10268,7 +10357,7 @@ class ValidatorKeys extends WithDebug {
 }
 class TicketsMarker extends WithDebug {
     tickets;
-    static Codec = Class(TicketsMarker, {
+    static Codec = codec_codec.Class(TicketsMarker, {
         tickets: codecPerEpochBlock(Ticket.Codec),
     });
     static create({ tickets }) {
@@ -10290,9 +10379,9 @@ class EpochMarker extends WithDebug {
     entropy;
     ticketsEntropy;
     validators;
-    static Codec = Class(EpochMarker, {
-        entropy: bytes(hash_HASH_SIZE).asOpaque(),
-        ticketsEntropy: bytes(hash_HASH_SIZE).asOpaque(),
+    static Codec = codec_codec.Class(EpochMarker, {
+        entropy: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        ticketsEntropy: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
         validators: codecPerValidator(ValidatorKeys.Codec),
     });
     static create({ entropy, ticketsEntropy, validators }) {
@@ -10329,17 +10418,17 @@ const encodeUnsealedHeader = (view) => {
  * https://graypaper.fluffylabs.dev/#/ab2cdbd/0c66000c7200?v=0.7.2
  */
 class header_Header extends WithDebug {
-    static Codec = Class(header_Header, {
-        parentHeaderHash: bytes(hash_HASH_SIZE).asOpaque(),
-        priorStateRoot: bytes(hash_HASH_SIZE).asOpaque(),
-        extrinsicHash: bytes(hash_HASH_SIZE).asOpaque(),
-        timeSlotIndex: u32.asOpaque(),
-        epochMarker: optional(EpochMarker.Codec),
-        ticketsMarker: optional(TicketsMarker.Codec),
-        bandersnatchBlockAuthorIndex: u16.asOpaque(),
-        entropySource: bytes(bandersnatch_BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
-        offendersMarker: sequenceVarLen(bytes(ED25519_KEY_BYTES).asOpaque()),
-        seal: bytes(bandersnatch_BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
+    static Codec = codec_codec.Class(header_Header, {
+        parentHeaderHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        priorStateRoot: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        extrinsicHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        timeSlotIndex: codec_codec.u32.asOpaque(),
+        epochMarker: codec_codec.optional(EpochMarker.Codec),
+        ticketsMarker: codec_codec.optional(TicketsMarker.Codec),
+        bandersnatchBlockAuthorIndex: codec_codec.u16.asOpaque(),
+        entropySource: codec_codec.bytes(bandersnatch_BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
+        offendersMarker: codec_codec.sequenceVarLen(codec_codec.bytes(ED25519_KEY_BYTES).asOpaque()),
+        seal: codec_codec.bytes(bandersnatch_BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
     });
     static create(h) {
         return Object.assign(header_Header.empty(), h);
@@ -10394,8 +10483,8 @@ class header_Header extends WithDebug {
  * `DescriptorRecord` or `CodecRecord` for some reason.
  */
 class HeaderViewWithHash extends WithHash {
-    static Codec = Class(HeaderViewWithHash, {
-        hash: bytes(hash_HASH_SIZE).asOpaque(),
+    static Codec = codec_codec.Class(HeaderViewWithHash, {
+        hash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
         data: header_Header.Codec.View,
     });
     static create({ hash, data }) {
@@ -10416,9 +10505,9 @@ const headerViewWithHashCodec = HeaderViewWithHash.Codec;
 class Preimage extends WithDebug {
     requester;
     blob;
-    static Codec = Class(Preimage, {
-        requester: u32.asOpaque(),
-        blob: blob,
+    static Codec = codec_codec.Class(Preimage, {
+        requester: codec_codec.u32.asOpaque(),
+        blob: codec_codec.blob,
     });
     static create({ requester, blob }) {
         return new Preimage(requester, blob);
@@ -10433,7 +10522,7 @@ class Preimage extends WithDebug {
         this.blob = blob;
     }
 }
-const preimagesExtrinsicCodec = sequenceVarLen(Preimage.Codec);
+const preimagesExtrinsicCodec = codec_codec.sequenceVarLen(Preimage.Codec);
 
 ;// CONCATENATED MODULE: ./packages/jam/block/block.ts
 
@@ -10459,7 +10548,7 @@ class Extrinsic extends WithDebug {
     guarantees;
     assurances;
     disputes;
-    static Codec = Class(Extrinsic, {
+    static Codec = codec_codec.Class(Extrinsic, {
         tickets: ticketsExtrinsicCodec,
         preimages: preimagesExtrinsicCodec,
         guarantees: guaranteesExtrinsicCodec,
@@ -10512,7 +10601,7 @@ class Extrinsic extends WithDebug {
 class Block extends WithDebug {
     header;
     extrinsic;
-    static Codec = Class(Block, {
+    static Codec = codec_codec.Class(Block, {
         header: header_Header.Codec,
         extrinsic: Extrinsic.Codec,
     });
@@ -11493,10 +11582,10 @@ class Version extends WithDebug {
     major;
     minor;
     patch;
-    static Codec = Class(Version, {
-        major: u8,
-        minor: u8,
-        patch: u8,
+    static Codec = codec_codec.Class(Version, {
+        major: codec_codec.u8,
+        minor: codec_codec.u8,
+        patch: codec_codec.u8,
     });
     static tryFromString(str) {
         const parse = (v) => tryAsU8(Number(v));
@@ -11548,12 +11637,12 @@ class PeerInfo extends WithDebug {
     jamVersion;
     appVersion;
     name;
-    static Codec = Class(PeerInfo, {
-        fuzzVersion: u8,
-        features: u32,
+    static Codec = codec_codec.Class(PeerInfo, {
+        fuzzVersion: codec_codec.u8,
+        features: codec_codec.u32,
         jamVersion: Version.Codec,
         appVersion: Version.Codec,
-        name: string,
+        name: codec_codec.string,
     });
     static create({ fuzzVersion, features, appVersion, jamVersion, name }) {
         return new PeerInfo(fuzzVersion, features, jamVersion, appVersion, name);
@@ -11576,9 +11665,9 @@ class PeerInfo extends WithDebug {
 class AncestryItem extends WithDebug {
     slot;
     headerHash;
-    static Codec = Class(AncestryItem, {
-        slot: u32.asOpaque(),
-        headerHash: bytes(hash_HASH_SIZE).asOpaque(),
+    static Codec = codec_codec.Class(AncestryItem, {
+        slot: codec_codec.u32.asOpaque(),
+        headerHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
     });
     static create({ slot, headerHash }) {
         return new AncestryItem(slot, headerHash);
@@ -11598,9 +11687,9 @@ class AncestryItem extends WithDebug {
 class KeyValue extends WithDebug {
     key;
     value;
-    static Codec = Class(KeyValue, {
-        key: bytes(TRUNCATED_HASH_SIZE),
-        value: blob,
+    static Codec = codec_codec.Class(KeyValue, {
+        key: codec_codec.bytes(TRUNCATED_HASH_SIZE),
+        value: codec_codec.blob,
     });
     static create({ key, value }) {
         return new KeyValue(key, value);
@@ -11612,12 +11701,12 @@ class KeyValue extends WithDebug {
     }
 }
 /** State ::= SEQUENCE OF KeyValue */
-const stateCodec = sequenceVarLen(KeyValue.Codec);
+const stateCodec = codec_codec.sequenceVarLen(KeyValue.Codec);
 /**
  * Ancestry ::= SEQUENCE (SIZE(0..24)) OF AncestryItem
  * Empty when `feature-ancestry` is not supported by both parties
  */
-const ancestryCodec = sequenceVarLen(AncestryItem.Codec, {
+const ancestryCodec = codec_codec.sequenceVarLen(AncestryItem.Codec, {
     minLength: 0,
     maxLength: 24,
 });
@@ -11632,7 +11721,7 @@ class Initialize extends WithDebug {
     header;
     keyvals;
     ancestry;
-    static Codec = Class(Initialize, {
+    static Codec = codec_codec.Class(Initialize, {
         header: header_Header.Codec,
         keyvals: stateCodec,
         ancestry: ancestryCodec,
@@ -11648,14 +11737,14 @@ class Initialize extends WithDebug {
     }
 }
 /** GetState ::= HeaderHash */
-const getStateCodec = bytes(hash_HASH_SIZE).asOpaque();
+const getStateCodec = codec_codec.bytes(hash_HASH_SIZE).asOpaque();
 /** StateRoot ::= StateRootHash */
-const stateRootCodec = bytes(hash_HASH_SIZE).asOpaque();
+const stateRootCodec = codec_codec.bytes(hash_HASH_SIZE).asOpaque();
 /** Error ::= UTF8String */
 class ErrorMessage extends WithDebug {
     message;
-    static Codec = Class(ErrorMessage, {
-        message: string,
+    static Codec = codec_codec.Class(ErrorMessage, {
+        message: codec_codec.string,
     });
     static create({ message }) {
         return new ErrorMessage(message);
@@ -11687,7 +11776,7 @@ var types_MessageType;
  *     error         [255] Error
  * }
  */
-const types_messageCodec = custom({
+const types_messageCodec = codec_codec.custom({
     name: "Message",
     sizeHint: { bytes: 1, isExact: false },
 }, (e, msg) => {
@@ -12053,9 +12142,9 @@ function getRegisters(argsLength) {
 class AccumulationOutput {
     serviceId;
     output;
-    static Codec = Class(AccumulationOutput, {
-        serviceId: u32.asOpaque(),
-        output: bytes(hash_HASH_SIZE),
+    static Codec = codec_codec.Class(AccumulationOutput, {
+        serviceId: codec_codec.u32.asOpaque(),
+        output: codec_codec.bytes(hash_HASH_SIZE),
     });
     static create(a) {
         return new AccumulationOutput(a.serviceId, a.output);
@@ -12146,9 +12235,9 @@ const MAX_REPORT_DEPENDENCIES = 8;
 class NotYetAccumulatedReport extends WithDebug {
     report;
     dependencies;
-    static Codec = Class(NotYetAccumulatedReport, {
+    static Codec = codec_codec.Class(NotYetAccumulatedReport, {
         report: WorkReport.Codec,
-        dependencies: codecKnownSizeArray(bytes(hash_HASH_SIZE).asOpaque(), {
+        dependencies: codecKnownSizeArray(codec_codec.bytes(hash_HASH_SIZE).asOpaque(), {
             typicalLength: MAX_REPORT_DEPENDENCIES / 2,
             maxLength: MAX_REPORT_DEPENDENCIES,
             minLength: 0,
@@ -12175,7 +12264,7 @@ class NotYetAccumulatedReport extends WithDebug {
         this.dependencies = dependencies;
     }
 }
-const accumulationQueueCodec = codecPerEpochBlock(readonlyArray(sequenceVarLen(NotYetAccumulatedReport.Codec)));
+const accumulationQueueCodec = codecPerEpochBlock(codec_codec.readonlyArray(codec_codec.sequenceVarLen(NotYetAccumulatedReport.Codec)));
 
 ;// CONCATENATED MODULE: ./packages/jam/state/common.ts
 
@@ -12208,9 +12297,9 @@ const codecPerCore = (val) => codecWithContext((context) => {
 class AvailabilityAssignment extends WithDebug {
     workReport;
     timeout;
-    static Codec = Class(AvailabilityAssignment, {
+    static Codec = codec_codec.Class(AvailabilityAssignment, {
         workReport: WorkReport.Codec,
-        timeout: u32.asOpaque(),
+        timeout: codec_codec.u32.asOpaque(),
     });
     static create({ workReport, timeout }) {
         return new AvailabilityAssignment(workReport, timeout);
@@ -12225,7 +12314,7 @@ class AvailabilityAssignment extends WithDebug {
         this.timeout = timeout;
     }
 }
-const availabilityAssignmentsCodec = codecPerCore(optional(AvailabilityAssignment.Codec));
+const availabilityAssignmentsCodec = codecPerCore(codec_codec.optional(AvailabilityAssignment.Codec));
 
 ;// CONCATENATED MODULE: ./packages/jam/state/auth.ts
 
@@ -12237,18 +12326,18 @@ const availabilityAssignmentsCodec = codecPerCore(optional(AvailabilityAssignmen
 const MAX_AUTH_POOL_SIZE = O;
 /** `Q`: Size of the authorization queue. */
 const AUTHORIZATION_QUEUE_SIZE = Q;
-const authPoolsCodec = codecPerCore(codecKnownSizeArray(bytes(hash_HASH_SIZE).asOpaque(), {
+const authPoolsCodec = codecPerCore(codecKnownSizeArray(codec_codec.bytes(hash_HASH_SIZE).asOpaque(), {
     minLength: 0,
     maxLength: MAX_AUTH_POOL_SIZE,
     typicalLength: MAX_AUTH_POOL_SIZE,
 }));
-const authQueuesCodec = codecPerCore(codecFixedSizeArray(bytes(hash_HASH_SIZE).asOpaque(), AUTHORIZATION_QUEUE_SIZE));
+const authQueuesCodec = codecPerCore(codecFixedSizeArray(codec_codec.bytes(hash_HASH_SIZE).asOpaque(), AUTHORIZATION_QUEUE_SIZE));
 
 ;// CONCATENATED MODULE: ./packages/jam/state/disputes.ts
 
 
 
-const sortedSetCodec = () => readonlyArray(sequenceVarLen(bytes(hash_HASH_SIZE))).convert((input) => input.array, (output) => {
+const sortedSetCodec = () => codec_codec.readonlyArray(codec_codec.sequenceVarLen(codec_codec.bytes(hash_HASH_SIZE))).convert((input) => input.array, (output) => {
     const typed = output.map((x) => x.asOpaque());
     return SortedSet.fromSortedArray(hashComparator, typed);
 });
@@ -12263,7 +12352,7 @@ class DisputesRecords {
     badSet;
     wonkySet;
     punishSet;
-    static Codec = Class(DisputesRecords, {
+    static Codec = codec_codec.Class(DisputesRecords, {
         goodSet: workReportsSortedSetCodec,
         badSet: workReportsSortedSetCodec,
         wonkySet: workReportsSortedSetCodec,
@@ -12336,10 +12425,10 @@ class BlockState extends WithDebug {
     accumulationResult;
     postStateRoot;
     reported;
-    static Codec = Class(BlockState, {
-        headerHash: bytes(hash_HASH_SIZE).asOpaque(),
-        accumulationResult: bytes(hash_HASH_SIZE),
-        postStateRoot: bytes(hash_HASH_SIZE).asOpaque(),
+    static Codec = codec_codec.Class(BlockState, {
+        headerHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        accumulationResult: codec_codec.bytes(hash_HASH_SIZE),
+        postStateRoot: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
         reported: codecHashDictionary(WorkPackageInfo.Codec, (x) => x.workPackageHash),
     });
     static create({ headerHash, accumulationResult, postStateRoot, reported }) {
@@ -12369,14 +12458,14 @@ class BlockState extends WithDebug {
 class RecentBlocks extends WithDebug {
     blocks;
     accumulationLog;
-    static Codec = Class(RecentBlocks, {
+    static Codec = codec_codec.Class(RecentBlocks, {
         blocks: codecKnownSizeArray(BlockState.Codec, {
             minLength: 0,
             maxLength: MAX_RECENT_HISTORY,
             typicalLength: MAX_RECENT_HISTORY,
         }),
-        accumulationLog: object({
-            peaks: readonlyArray(sequenceVarLen(optional(bytes(hash_HASH_SIZE)))),
+        accumulationLog: codec_codec.object({
+            peaks: codec_codec.readonlyArray(codec_codec.sequenceVarLen(codec_codec.optional(codec_codec.bytes(hash_HASH_SIZE)))),
         }),
     });
     static empty() {
@@ -12409,7 +12498,7 @@ class RecentBlocks extends WithDebug {
 
 
 
-const recentlyAccumulatedCodec = codecPerEpochBlock(sequenceVarLen(bytes(hash_HASH_SIZE).asOpaque()).convert((x) => Array.from(x), (x) => HashSet.from(x)));
+const recentlyAccumulatedCodec = codecPerEpochBlock(codec_codec.sequenceVarLen(codec_codec.bytes(hash_HASH_SIZE).asOpaque()).convert((x) => Array.from(x), (x) => HashSet.from(x)));
 
 ;// CONCATENATED MODULE: ./packages/jam/state/validator-data.ts
 
@@ -12432,11 +12521,11 @@ class ValidatorData extends WithDebug {
     ed25519;
     bls;
     metadata;
-    static Codec = Class(ValidatorData, {
-        bandersnatch: bytes(BANDERSNATCH_KEY_BYTES).asOpaque(),
-        ed25519: bytes(ED25519_KEY_BYTES).asOpaque(),
-        bls: bytes(BLS_KEY_BYTES).asOpaque(),
-        metadata: bytes(VALIDATOR_META_BYTES),
+    static Codec = codec_codec.Class(ValidatorData, {
+        bandersnatch: codec_codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque(),
+        ed25519: codec_codec.bytes(ED25519_KEY_BYTES).asOpaque(),
+        bls: codec_codec.bytes(BLS_KEY_BYTES).asOpaque(),
+        metadata: codec_codec.bytes(VALIDATOR_META_BYTES),
     });
     static create({ ed25519, bandersnatch, bls, metadata }) {
         return new ValidatorData(bandersnatch, ed25519, bls, metadata);
@@ -12469,53 +12558,31 @@ const validatorsDataCodec = codecPerValidator(ValidatorData.Codec);
 
 
 
-
-
 var SafroleSealingKeysKind;
 (function (SafroleSealingKeysKind) {
     SafroleSealingKeysKind[SafroleSealingKeysKind["Tickets"] = 0] = "Tickets";
     SafroleSealingKeysKind[SafroleSealingKeysKind["Keys"] = 1] = "Keys";
 })(SafroleSealingKeysKind || (SafroleSealingKeysKind = {}));
-const codecBandersnatchKey = bytes(BANDERSNATCH_KEY_BYTES).asOpaque();
+const codecBandersnatchKey = codec_codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque();
 class SafroleSealingKeysData extends WithDebug {
     kind;
     keys;
     tickets;
     static Codec = codecWithContext((context) => {
-        return custom({
-            name: "SafroleSealingKeys",
-            sizeHint: { bytes: 1 + hash_HASH_SIZE * context.epochLength, isExact: false },
-        }, (e, x) => {
-            e.varU32(numbers_tryAsU32(x.kind));
+        const keysCodec = codec_codec
+            .sequenceFixLen(codecBandersnatchKey, context.epochLength)
+            .convert((keys) => Array.from(keys), (keys) => tryAsPerEpochBlock(keys, context));
+        const ticketsCodec = codec_codec.sequenceFixLen(Ticket.Codec, context.epochLength).convert((tickets) => Array.from(tickets), (tickets) => tryAsPerEpochBlock(tickets, context));
+        return codec_codec
+            .union("SafroleSealingKeys", {
+            [SafroleSealingKeysKind.Keys]: codec_codec.object({ keys: keysCodec }),
+            [SafroleSealingKeysKind.Tickets]: codec_codec.object({ tickets: ticketsCodec }),
+        })
+            .convert((x) => x, (x) => {
             if (x.kind === SafroleSealingKeysKind.Keys) {
-                e.sequenceFixLen(codecBandersnatchKey, x.keys);
-            }
-            else {
-                e.sequenceFixLen(Ticket.Codec, x.tickets);
+                return SafroleSealingKeysData.keys(x.keys);
             }
-        }, (d) => {
-            const epochLength = context.epochLength;
-            const kind = d.varU32();
-            if (kind === SafroleSealingKeysKind.Keys) {
-                const keys = d.sequenceFixLen(codecBandersnatchKey, epochLength);
-                return SafroleSealingKeysData.keys(tryAsPerEpochBlock(keys, context));
-            }
-            if (kind === SafroleSealingKeysKind.Tickets) {
-                const tickets = d.sequenceFixLen(Ticket.Codec, epochLength);
-                return SafroleSealingKeysData.tickets(tryAsPerEpochBlock(tickets, context));
-            }
-            throw new Error(`Unexpected safrole sealing keys kind: ${kind}`);
-        }, (s) => {
-            const kind = s.decoder.varU32();
-            if (kind === SafroleSealingKeysKind.Keys) {
-                s.sequenceFixLen(codecBandersnatchKey, context.epochLength);
-                return;
-            }
-            if (kind === SafroleSealingKeysKind.Tickets) {
-                s.sequenceFixLen(Ticket.Codec, context.epochLength);
-                return;
-            }
-            throw new Error(`Unexpected safrole sealing keys kind: ${kind}`);
+            return SafroleSealingKeysData.tickets(x.tickets);
         });
     });
     static keys(keys) {
@@ -12536,11 +12603,11 @@ class safrole_data_SafroleData {
     epochRoot;
     sealingKeySeries;
     ticketsAccumulator;
-    static Codec = Class(safrole_data_SafroleData, {
+    static Codec = codec_codec.Class(safrole_data_SafroleData, {
         nextValidatorData: codecPerValidator(ValidatorData.Codec),
-        epochRoot: bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
+        epochRoot: codec_codec.bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
         sealingKeySeries: SafroleSealingKeysData.Codec,
-        ticketsAccumulator: readonlyArray(sequenceVarLen(Ticket.Codec)).convert(seeThrough, sized_array_asKnownSize),
+        ticketsAccumulator: codec_codec.readonlyArray(codec_codec.sequenceVarLen(Ticket.Codec)).convert(seeThrough, sized_array_asKnownSize),
     });
     static create({ nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator }) {
         return new safrole_data_SafroleData(nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator);
@@ -12625,17 +12692,17 @@ class ServiceAccountInfo extends WithDebug {
     created;
     lastAccumulation;
     parentService;
-    static Codec = Class(ServiceAccountInfo, {
-        codeHash: bytes(hash_HASH_SIZE).asOpaque(),
-        balance: u64,
-        accumulateMinGas: u64.convert((x) => x, tryAsServiceGas),
-        onTransferMinGas: u64.convert((x) => x, tryAsServiceGas),
-        storageUtilisationBytes: u64,
-        gratisStorage: u64,
-        storageUtilisationCount: u32,
-        created: u32.convert((x) => x, common_tryAsTimeSlot),
-        lastAccumulation: u32.convert((x) => x, common_tryAsTimeSlot),
-        parentService: u32.convert((x) => x, tryAsServiceId),
+    static Codec = codec_codec.Class(ServiceAccountInfo, {
+        codeHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        balance: codec_codec.u64,
+        accumulateMinGas: codec_codec.u64.convert((x) => x, tryAsServiceGas),
+        onTransferMinGas: codec_codec.u64.convert((x) => x, tryAsServiceGas),
+        storageUtilisationBytes: codec_codec.u64,
+        gratisStorage: codec_codec.u64,
+        storageUtilisationCount: codec_codec.u32,
+        created: codec_codec.u32.convert((x) => x, common_tryAsTimeSlot),
+        lastAccumulation: codec_codec.u32.convert((x) => x, common_tryAsTimeSlot),
+        parentService: codec_codec.u32.convert((x) => x, tryAsServiceId),
     });
     static create(a) {
         return new ServiceAccountInfo(a.codeHash, a.balance, a.accumulateMinGas, a.onTransferMinGas, a.storageUtilisationBytes, a.gratisStorage, a.storageUtilisationCount, a.created, a.lastAccumulation, a.parentService);
@@ -12691,9 +12758,9 @@ class ServiceAccountInfo extends WithDebug {
 class PreimageItem extends WithDebug {
     hash;
     blob;
-    static Codec = Class(PreimageItem, {
-        hash: bytes(hash_HASH_SIZE).asOpaque(),
-        blob: blob,
+    static Codec = codec_codec.Class(PreimageItem, {
+        hash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        blob: codec_codec.blob,
     });
     static create({ hash, blob }) {
         return new PreimageItem(hash, blob);
@@ -12707,9 +12774,9 @@ class PreimageItem extends WithDebug {
 class StorageItem extends WithDebug {
     key;
     value;
-    static Codec = Class(StorageItem, {
-        key: blob.convert((i) => i, (o) => opaque_asOpaqueType(o)),
-        value: blob,
+    static Codec = codec_codec.Class(StorageItem, {
+        key: codec_codec.blob.convert((i) => i, (o) => opaque_asOpaqueType(o)),
+        value: codec_codec.blob,
     });
     static create({ key, value }) {
         return new StorageItem(key, value);
@@ -12770,13 +12837,13 @@ class ValidatorStatistics {
     preImagesSize;
     guarantees;
     assurances;
-    static Codec = Class(ValidatorStatistics, {
-        blocks: u32,
-        tickets: u32,
-        preImages: u32,
-        preImagesSize: u32,
-        guarantees: u32,
-        assurances: u32,
+    static Codec = codec_codec.Class(ValidatorStatistics, {
+        blocks: codec_codec.u32,
+        tickets: codec_codec.u32,
+        preImages: codec_codec.u32,
+        preImagesSize: codec_codec.u32,
+        guarantees: codec_codec.u32,
+        assurances: codec_codec.u32,
     });
     static create({ blocks, tickets, preImages, preImagesSize, guarantees, assurances, }) {
         return new ValidatorStatistics(blocks, tickets, preImages, preImagesSize, guarantees, assurances);
@@ -12806,9 +12873,9 @@ class ValidatorStatistics {
         return new ValidatorStatistics(zero, zero, zero, zero, zero, zero);
     }
 }
-const codecVarU16 = varU32.convert((i) => numbers_tryAsU32(i), (o) => numbers_tryAsU16(o));
+const codecVarU16 = codec_codec.varU32.convert((i) => numbers_tryAsU32(i), (o) => numbers_tryAsU16(o));
 /** Encode/decode unsigned gas. */
-const codecVarGas = varU64.convert((g) => numbers_tryAsU64(g), (i) => tryAsServiceGas(i));
+const codecVarGas = codec_codec.varU64.convert((g) => numbers_tryAsU64(g), (i) => tryAsServiceGas(i));
 /**
  * Single core statistics.
  * Updated per block, based on incoming work reports (`w`).
@@ -12825,14 +12892,14 @@ class CoreStatistics {
     extrinsicCount;
     bundleSize;
     gasUsed;
-    static Codec = Class(CoreStatistics, {
-        dataAvailabilityLoad: varU32,
+    static Codec = codec_codec.Class(CoreStatistics, {
+        dataAvailabilityLoad: codec_codec.varU32,
         popularity: codecVarU16,
         imports: codecVarU16,
         extrinsicCount: codecVarU16,
-        extrinsicSize: varU32,
+        extrinsicSize: codec_codec.varU32,
         exports: codecVarU16,
-        bundleSize: varU32,
+        bundleSize: codec_codec.varU32,
         gasUsed: codecVarGas,
     });
     static create(v) {
@@ -12891,31 +12958,31 @@ class ServiceStatistics {
     onTransfersCount;
     onTransfersGasUsed;
     static Codec = Compatibility.selectIfGreaterOrEqual({
-        fallback: Class(ServiceStatistics, {
+        fallback: codec_codec.Class(ServiceStatistics, {
             providedCount: codecVarU16,
-            providedSize: varU32,
-            refinementCount: varU32,
+            providedSize: codec_codec.varU32,
+            refinementCount: codec_codec.varU32,
             refinementGasUsed: codecVarGas,
             imports: codecVarU16,
             extrinsicCount: codecVarU16,
-            extrinsicSize: varU32,
+            extrinsicSize: codec_codec.varU32,
             exports: codecVarU16,
-            accumulateCount: varU32,
+            accumulateCount: codec_codec.varU32,
             accumulateGasUsed: codecVarGas,
-            onTransfersCount: varU32,
+            onTransfersCount: codec_codec.varU32,
             onTransfersGasUsed: codecVarGas,
         }),
         versions: {
-            [GpVersion.V0_7_1]: Class(ServiceStatistics, {
+            [GpVersion.V0_7_1]: codec_codec.Class(ServiceStatistics, {
                 providedCount: codecVarU16,
-                providedSize: varU32,
-                refinementCount: varU32,
+                providedSize: codec_codec.varU32,
+                refinementCount: codec_codec.varU32,
                 refinementGasUsed: codecVarGas,
                 imports: codecVarU16,
                 extrinsicCount: codecVarU16,
-                extrinsicSize: varU32,
+                extrinsicSize: codec_codec.varU32,
                 exports: codecVarU16,
-                accumulateCount: varU32,
+                accumulateCount: codec_codec.varU32,
                 accumulateGasUsed: codecVarGas,
                 onTransfersCount: ignoreValueWithDefault(numbers_tryAsU32(0)),
                 onTransfersGasUsed: ignoreValueWithDefault(tryAsServiceGas(0)),
@@ -12976,11 +13043,11 @@ class StatisticsData {
     previous;
     cores;
     services;
-    static Codec = Class(StatisticsData, {
+    static Codec = codec_codec.Class(StatisticsData, {
         current: codecPerValidator(ValidatorStatistics.Codec),
         previous: codecPerValidator(ValidatorStatistics.Codec),
         cores: codecPerCore(CoreStatistics.Codec),
-        services: dictionary(u32.asOpaque(), ServiceStatistics.Codec, {
+        services: codec_codec.dictionary(codec_codec.u32.asOpaque(), ServiceStatistics.Codec, {
             sortKeys: (a, b) => a - b,
         }),
     });
@@ -13079,14 +13146,14 @@ class PrivilegedServices {
     assigners;
     autoAccumulateServices;
     /** https://graypaper.fluffylabs.dev/#/ab2cdbd/3bbd023bcb02?v=0.7.2 */
-    static Codec = Class(PrivilegedServices, {
-        manager: u32.asOpaque(),
-        assigners: codecPerCore(u32.asOpaque()),
-        delegator: u32.asOpaque(),
+    static Codec = codec_codec.Class(PrivilegedServices, {
+        manager: codec_codec.u32.asOpaque(),
+        assigners: codecPerCore(codec_codec.u32.asOpaque()),
+        delegator: codec_codec.u32.asOpaque(),
         registrar: Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
-            ? u32.asOpaque()
+            ? codec_codec.u32.asOpaque()
             : ignoreValueWithDefault(tryAsServiceId(2 ** 32 - 1)),
-        autoAccumulateServices: dictionary(u32.asOpaque(), u64.asOpaque(), {
+        autoAccumulateServices: codec_codec.dictionary(codec_codec.u32.asOpaque(), codec_codec.u64.asOpaque(), {
             sortKeys: (a, b) => a - b,
         }),
     });
@@ -13759,15 +13826,15 @@ class InMemoryState extends WithDebug {
         });
     }
 }
-const serviceEntriesCodec = object({
-    storageKeys: sequenceVarLen(blob.convert((i) => i, (o) => opaque_asOpaqueType(o))),
-    preimages: sequenceVarLen(bytes(hash_HASH_SIZE).asOpaque()),
-    lookupHistory: sequenceVarLen(object({
-        hash: bytes(hash_HASH_SIZE).asOpaque(),
-        length: u32,
+const serviceEntriesCodec = codec_codec.object({
+    storageKeys: codec_codec.sequenceVarLen(codec_codec.blob.convert((i) => i, (o) => opaque_asOpaqueType(o))),
+    preimages: codec_codec.sequenceVarLen(codec_codec.bytes(hash_HASH_SIZE).asOpaque()),
+    lookupHistory: codec_codec.sequenceVarLen(codec_codec.object({
+        hash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        length: codec_codec.u32,
     })),
 });
-const serviceDataCodec = dictionary(u32.asOpaque(), serviceEntriesCodec, {
+const serviceDataCodec = codec_codec.dictionary(codec_codec.u32.asOpaque(), serviceEntriesCodec, {
     sortKeys: (a, b) => a - b,
 });
 
@@ -14485,7 +14552,7 @@ var serialize_serialize;
     /** C(6): https://graypaper.fluffylabs.dev/#/7e6ff6a/3bf3013bf301?v=0.6.7 */
     serialize.entropy = {
         key: stateKeys.index(StateKeyIdx.Eta),
-        Codec: codecFixedSizeArray(bytes(hash_HASH_SIZE).asOpaque(), ENTROPY_ENTRIES),
+        Codec: codecFixedSizeArray(codec_codec.bytes(hash_HASH_SIZE).asOpaque(), ENTROPY_ENTRIES),
         extract: (s) => s.entropy,
     };
     /** C(7): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b00023b0002?v=0.6.7 */
@@ -14515,7 +14582,7 @@ var serialize_serialize;
     /** C(11): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b3e023b3e02?v=0.6.7 */
     serialize.timeslot = {
         key: stateKeys.index(StateKeyIdx.Tau),
-        Codec: u32.asOpaque(),
+        Codec: codec_codec.u32.asOpaque(),
         extract: (s) => s.timeslot,
     };
     /** C(12): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b4c023b4c02?v=0.6.7 */
@@ -14545,7 +14612,7 @@ var serialize_serialize;
     /** C(16): https://graypaper.fluffylabs.dev/#/38c4e62/3b46033b4603?v=0.7.0 */
     serialize.accumulationOutputLog = {
         key: stateKeys.index(StateKeyIdx.Theta),
-        Codec: sequenceVarLen(AccumulationOutput.Codec).convert((i) => i.array, (o) => SortedArray.fromSortedArray(accumulationOutputComparator, o)),
+        Codec: codec_codec.sequenceVarLen(AccumulationOutput.Codec).convert((i) => i.array, (o) => SortedArray.fromSortedArray(accumulationOutputComparator, o)),
         extract: (s) => s.accumulationOutputLog,
     };
     /** C(255, s): https://graypaper.fluffylabs.dev/#/85129da/383103383103?v=0.6.3 */
@@ -14568,7 +14635,7 @@ var serialize_serialize;
     /** https://graypaper.fluffylabs.dev/#/85129da/387603387603?v=0.6.3 */
     serialize.serviceLookupHistory = (blake2b, serviceId, hash, len) => ({
         key: stateKeys.serviceLookupHistory(blake2b, serviceId, hash, len),
-        Codec: readonlyArray(sequenceVarLen(u32)),
+        Codec: codec_codec.readonlyArray(codec_codec.sequenceVarLen(codec_codec.u32)),
     });
 })(serialize_serialize || (serialize_serialize = {}));
 /**
@@ -15695,7 +15762,7 @@ function getSafroleData(nextValidatorData, epochRoot, sealingKeySeries, ticketsA
 
 const TYPICAL_STATE_ITEMS = 50;
 const TYPICAL_STATE_ITEM_LEN = 50;
-const stateEntriesSequenceCodec = sequenceVarLen(pair(bytes(TRUNCATED_HASH_SIZE), blob));
+const stateEntriesSequenceCodec = codec_codec.sequenceVarLen(codec_codec.pair(codec_codec.bytes(TRUNCATED_HASH_SIZE), codec_codec.blob));
 /**
  * Full, in-memory state represented as serialized entries dictionary.
  *
@@ -15703,7 +15770,7 @@ const stateEntriesSequenceCodec = sequenceVarLen(pair(bytes(TRUNCATED_HASH_SIZE)
  */
 class state_entries_StateEntries {
     dictionary;
-    static Codec = custom({
+    static Codec = codec_codec.custom({
         name: "StateEntries",
         sizeHint: {
             isExact: false,
@@ -15895,7 +15962,7 @@ function loadState(spec, blake2b, entries) {
 
 
 /** Codec for a map with string keys. */
-const codecMap = (value, extractKey, { typicalLength = TYPICAL_DICTIONARY_LENGTH, compare = (a, b) => {
+const codecMap = (value, extractKey, { typicalLength = codec_codec.TYPICAL_DICTIONARY_LENGTH, compare = (a, b) => {
     const keyA = extractKey(a);
     const keyB = extractKey(b);
     if (keyA < keyB) {
@@ -15938,17 +16005,19 @@ const codecMap = (value, extractKey, { typicalLength = TYPICAL_DICTIONARY_LENGTH
         s.sequenceFixLen(value, len);
     });
 };
-const lookupHistoryItemCodec = object({
-    hash: bytes(hash_HASH_SIZE).asOpaque(),
-    length: u32,
-    slots: readonlyArray(sequenceVarLen(u32.asOpaque()))
+const lookupHistoryItemCodec = codec_codec.object({
+    hash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+    length: codec_codec.u32,
+    slots: codec_codec
+        .readonlyArray(codec_codec.sequenceVarLen(codec_codec.u32.asOpaque()))
         .convert(seeThrough, service_tryAsLookupHistorySlots),
 }, "LookupHistoryItem", ({ hash, length, slots }) => new LookupHistoryItem(hash, length, slots));
-const lookupHistoryEntryCodec = object({
-    key: bytes(hash_HASH_SIZE).asOpaque(),
-    data: sequenceVarLen(lookupHistoryItemCodec),
+const lookupHistoryEntryCodec = codec_codec.object({
+    key: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+    data: codec_codec.sequenceVarLen(lookupHistoryItemCodec),
 });
-const lookupHistoryCodec = sequenceVarLen(lookupHistoryEntryCodec)
+const lookupHistoryCodec = codec_codec
+    .sequenceVarLen(lookupHistoryEntryCodec)
     .convert((dict) => {
     const entries = [];
     for (const [key, data] of dict) {
@@ -15968,9 +16037,9 @@ const lookupHistoryCodec = sequenceVarLen(lookupHistoryEntryCodec)
     return dict;
 });
 class ServiceWithCodec extends InMemoryService {
-    static Codec = Class(ServiceWithCodec, {
-        serviceId: u32.asOpaque(),
-        data: object({
+    static Codec = codec_codec.Class(ServiceWithCodec, {
+        serviceId: codec_codec.u32.asOpaque(),
+        data: codec_codec.object({
             info: ServiceAccountInfo.Codec,
             preimages: codecHashDictionary(PreimageItem.Codec, (x) => x.hash),
             lookupHistory: lookupHistoryCodec,
@@ -15984,7 +16053,7 @@ class ServiceWithCodec extends InMemoryService {
         return new ServiceWithCodec(serviceId, data);
     }
 }
-const inMemoryStateCodec = (spec) => Class(class State extends InMemoryState {
+const inMemoryStateCodec = (spec) => codec_codec.Class(class State extends InMemoryState {
     static create(data) {
         return InMemoryState.new(spec, data);
     }
@@ -15998,11 +16067,12 @@ const inMemoryStateCodec = (spec) => Class(class State extends InMemoryState {
     // gamma_k
     nextValidatorData: codecPerValidator(ValidatorData.Codec),
     // gamma_z
-    epochRoot: bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
+    epochRoot: codec_codec.bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
     // gamma_s
     sealingKeySeries: SafroleSealingKeysData.Codec,
     // gamma_a
-    ticketsAccumulator: readonlyArray(sequenceVarLen(Ticket.Codec))
+    ticketsAccumulator: codec_codec
+        .readonlyArray(codec_codec.sequenceVarLen(Ticket.Codec))
         .convert((x) => x, sized_array_asKnownSize),
     // psi
     disputesRecords: serialize_serialize.disputesRecords.Codec,
@@ -16029,7 +16099,7 @@ const inMemoryStateCodec = (spec) => Class(class State extends InMemoryState {
     // theta
     accumulationOutputLog: serialize_serialize.accumulationOutputLog.Codec,
     // delta
-    services: dictionary(u32.asOpaque(), ServiceWithCodec.Codec, {
+    services: codec_codec.dictionary(codec_codec.u32.asOpaque(), ServiceWithCodec.Codec, {
         sortKeys: (a, b) => a - b,
     }),
 });
@@ -16054,11 +16124,11 @@ class TestState {
         state_root: fromJson.bytes32(),
         keyvals: json.array(StateKeyVal.fromJson),
     };
-    static Codec = object({
-        state_root: bytes(hash_HASH_SIZE).asOpaque(),
-        keyvals: sequenceVarLen(object({
-            key: bytes(TRUNCATED_HASH_SIZE),
-            value: blob,
+    static Codec = codec_codec.object({
+        state_root: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        keyvals: codec_codec.sequenceVarLen(codec_codec.object({
+            key: codec_codec.bytes(TRUNCATED_HASH_SIZE),
+            value: codec_codec.blob,
         })),
     });
     state_root;
@@ -16069,7 +16139,7 @@ class StateTransitionGenesis {
         header: headerFromJson,
         state: TestState.fromJson,
     };
-    static Codec = object({
+    static Codec = codec_codec.object({
         header: header_Header.Codec,
         state: TestState.Codec,
     });
@@ -16082,7 +16152,7 @@ class StateTransition {
         post_state: TestState.fromJson,
         block: blockFromJson(chain_spec_tinyChainSpec),
     };
-    static Codec = object({
+    static Codec = codec_codec.object({
         pre_state: TestState.Codec,
         block: Block.Codec,
         post_state: TestState.Codec,
@@ -19732,11 +19802,8 @@ class interpreter_Interpreter {
             this.memory.reset();
         }
     }
-    printProgram() {
-        const p = assemblify(this.code, this.mask);
-        // biome-ignore lint/suspicious/noConsole: We do want to print that.
-        console.table(p);
-        return p;
+    dumpProgram() {
+        return assemblify(this.code, this.mask);
     }
     runProgram() {
         while (this.nextStep() === Status.OK) { }
@@ -20159,7 +20226,7 @@ const SUPPORTED_TYPES = [
                 if (option === "as-hash") {
                     return looseType({
                         value: blake2b.hashBytes(encoder_Encoder.encodeObject(header_Header.Codec, header, spec)),
-                        encode: bytes(hash_HASH_SIZE),
+                        encode: codec_codec.bytes(hash_HASH_SIZE),
                     });
                 }
                 throw new Error(`Invalid processing option: ${option}`);
@@ -20213,7 +20280,7 @@ const SUPPORTED_TYPES = [
                 if (option === "as-root-hash") {
                     return looseType({
                         value: state_entries_StateEntries.serializeInMemory(spec, blake2b, state).getRootHash(blake2b),
-                        encode: bytes(hash_HASH_SIZE),
+                        encode: codec_codec.bytes(hash_HASH_SIZE),
                     });
                 }
                 throw new Error(`Invalid processing option: ${option}`);
@@ -20268,7 +20335,14 @@ const SUPPORTED_TYPES = [
         decode: StateTransition.Codec,
         json: () => StateTransition.fromJson,
         process: {
-            options: ["as-pre-state", "as-post-state", "as-fuzz-message", "as-block"],
+            options: [
+                "as-pre-state",
+                "as-post-state",
+                "as-fuzz-message",
+                "as-block-fuzz-message",
+                "as-state-fuzz-message",
+                "as-block",
+            ],
             run(spec, data, option, blake2b) {
                 const test = data;
                 if (option === "as-pre-state") {
@@ -20288,6 +20362,10 @@ const SUPPORTED_TYPES = [
                     });
                 }
                 if (option === "as-fuzz-message") {
+                    // biome-ignore lint/suspicious/noConsole: deprecation warning
+                    console.warn("⚠️  Warning: 'as-fuzz-message' is deprecated and will be removed in version 0.6.0. Use 'as-block-fuzz-message' instead.");
+                }
+                if (option === "as-block-fuzz-message" || option === "as-fuzz-message") {
                     const encoded = encoder_Encoder.encodeObject(Block.Codec, test.block, spec);
                     const blockView = decoder_Decoder.decodeObject(Block.Codec.View, encoded, spec);
                     const msg = {
@@ -20299,6 +20377,26 @@ const SUPPORTED_TYPES = [
                         encode: types_messageCodec,
                     });
                 }
+                if (option === "as-state-fuzz-message") {
+                    const init = Initialize.create({
+                        header: header_Header.empty(),
+                        keyvals: test.pre_state.keyvals,
+                        ancestry: [
+                            AncestryItem.create({
+                                headerHash: test.block.header.parentHeaderHash,
+                                slot: common_tryAsTimeSlot(Math.max(0, test.block.header.timeSlotIndex - 1)),
+                            }),
+                        ],
+                    });
+                    const msg = {
+                        type: types_MessageType.Initialize,
+                        value: init,
+                    };
+                    return looseType({
+                        value: msg,
+                        encode: types_messageCodec,
+                    });
+                }
                 throw new Error(`Invalid processing option: ${option}`);
             },
         },