@typeberry/convert 0.4.1-69ce381 → 0.4.1-818bae8

package/index.js

@@ -4239,7 +4239,11 @@ class Logger {
     }
 }
 
+;// CONCATENATED MODULE: ./packages/core/utils/env.ts
+const env = typeof process === "undefined" ? {} : process.env;
+
 ;// CONCATENATED MODULE: ./packages/core/utils/compatibility.ts
+
 var GpVersion;
 (function (GpVersion) {
     GpVersion["V0_6_7"] = "0.6.7";
@@ -4259,7 +4263,6 @@ const DEFAULT_SUITE = TestSuite.W3F_DAVXY;
  * Since we are currently at 0.7.1 not 0.7.2, we set our default version accordingly.
  */
 const DEFAULT_VERSION = GpVersion.V0_7_1;
-const env = typeof process === "undefined" ? {} : process.env;
 let CURRENT_VERSION = parseCurrentVersion(env.GP_VERSION) ?? DEFAULT_VERSION;
 let CURRENT_SUITE = parseCurrentSuite(env.TEST_SUITE) ?? DEFAULT_SUITE;
 function parseCurrentVersion(env) {
@@ -4452,7 +4455,7 @@ function lazyInspect(obj) {
 }
 
 ;// CONCATENATED MODULE: ./packages/core/utils/dev.ts
-const dev_env = typeof process === "undefined" ? {} : process.env;
+
 /**
  * The function will produce relative path resolver that is adjusted
  * for package location within the workspace.
@@ -4470,7 +4473,7 @@ const dev_env = typeof process === "undefined" ? {} : process.env;
  * NOTE: the translation happens only for development build! When
  * we build a single library from our project, we no longer mangle the paths.
  */
-const workspacePathFix = dev_env.NODE_ENV === "development"
+const workspacePathFix = env.NODE_ENV === "development"
     ? (workspacePath) => (p) => {
         if (p.startsWith("/")) {
             return p;
@@ -6482,213 +6485,209 @@ function exactHint(bytes) {
         isExact: true,
     };
 }
-/** Descriptors for data types that can be read/written from/to codec. */
-var descriptors_codec;
-(function (codec) {
-    /** Fixed-length bytes sequence. */
-    codec.bytes = (() => {
-        const cache = new Map();
-        return (len) => {
-            let ret = cache.get(len);
-            if (ret === undefined) {
-                ret = Descriptor.new(`Bytes<${len}>`, exactHint(len), (e, v) => e.bytes(v), (d) => d.bytes(len), (s) => s.bytes(len));
-                cache.set(len, ret);
-            }
-            return ret;
-        };
-    })();
-    /** Zero-size `void` value. */
-    codec.nothing = Descriptor.new("void", { bytes: 0, isExact: true }, (_e, _v) => { }, (_d) => { }, (_s) => { });
-    /** Variable-length U32. */
-    codec.varU32 = Descriptor.new("var_u32", { bytes: 4, isExact: false }, (e, v) => e.varU32(v), (d) => d.varU32(), (d) => d.varU32());
-    /** Variable-length U64. */
-    codec.varU64 = Descriptor.new("var_u64", { bytes: 8, isExact: false }, (e, v) => e.varU64(v), (d) => d.varU64(), (d) => d.varU64());
-    /** Unsigned 64-bit number. */
-    codec.u64 = Descriptor.withView("u64", exactHint(8), (e, v) => e.i64(v), (d) => d.u64(), (d) => d.u64(), codec.bytes(8));
-    /** Unsigned 32-bit number. */
-    codec.u32 = Descriptor.withView("u32", exactHint(4), (e, v) => e.i32(v), (d) => d.u32(), (d) => d.u32(), codec.bytes(4));
-    /** Unsigned 24-bit number. */
-    codec.u24 = Descriptor.withView("u24", exactHint(3), (e, v) => e.i24(v), (d) => d.u24(), (d) => d.u24(), codec.bytes(3));
-    /** Unsigned 16-bit number. */
-    codec.u16 = Descriptor.withView("u16", exactHint(2), (e, v) => e.i16(v), (d) => d.u16(), (d) => d.u16(), codec.bytes(2));
-    /** Unsigned 8-bit number. */
-    codec.u8 = Descriptor.new("u8", exactHint(1), (e, v) => e.i8(v), (d) => d.u8(), (d) => d.u8());
-    /** Signed 64-bit number. */
-    codec.i64 = Descriptor.withView("u64", exactHint(8), (e, v) => e.i64(v), (d) => d.i64(), (s) => s.u64(), codec.bytes(8));
-    /** Signed 32-bit number. */
-    codec.i32 = Descriptor.withView("i32", exactHint(4), (e, v) => e.i32(v), (d) => d.i32(), (s) => s.u32(), codec.bytes(4));
-    /** Signed 24-bit number. */
-    codec.i24 = Descriptor.withView("i24", exactHint(3), (e, v) => e.i24(v), (d) => d.i24(), (s) => s.u24(), codec.bytes(3));
-    /** Signed 16-bit number. */
-    codec.i16 = Descriptor.withView("i16", exactHint(2), (e, v) => e.i16(v), (d) => d.i16(), (s) => s.u16(), codec.bytes(2));
-    /** Signed 8-bit number. */
-    codec.i8 = Descriptor.new("i8", exactHint(1), (e, v) => e.i8(v), (d) => d.i8(), (s) => s.u8());
-    /** 1-byte boolean value. */
-    codec.bool = Descriptor.new("bool", exactHint(1), (e, v) => e.bool(v), (d) => d.bool(), (s) => s.bool());
-    /** Variable-length bytes blob. */
-    codec.blob = Descriptor.new("BytesBlob", { bytes: TYPICAL_SEQUENCE_LENGTH, isExact: false }, (e, v) => e.bytesBlob(v), (d) => d.bytesBlob(), (s) => s.bytesBlob());
-    /** String encoded as variable-length bytes blob. */
-    codec.string = Descriptor.withView("string", { bytes: TYPICAL_SEQUENCE_LENGTH, isExact: false }, (e, v) => e.bytesBlob(bytes_BytesBlob.blobFrom(new TextEncoder().encode(v))), (d) => new TextDecoder("utf8", { fatal: true }).decode(d.bytesBlob().raw), (s) => s.bytesBlob(), codec.blob);
-    /** Variable-length bit vector. */
-    codec.bitVecVarLen = Descriptor.new("BitVec[?]", { bytes: TYPICAL_SEQUENCE_LENGTH >>> 3, isExact: false }, (e, v) => e.bitVecVarLen(v), (d) => d.bitVecVarLen(), (s) => s.bitVecVarLen());
-    /** Fixed-length bit vector. */
-    codec.bitVecFixLen = (bitLen) => Descriptor.new(`BitVec[${bitLen}]`, exactHint(bitLen >>> 3), (e, v) => e.bitVecFixLen(v), (d) => d.bitVecFixLen(bitLen), (s) => s.bitVecFixLen(bitLen));
-    /** Optionality wrapper for given type. */
-    codec.optional = (type) => {
-        const self = Descriptor.new(`Optional<${type.name}>`, addSizeHints({ bytes: 1, isExact: false }, type.sizeHint), (e, v) => e.optional(type, v), (d) => d.optional(type), (s) => s.optional(type));
-        if (hasUniqueView(type)) {
-            return Descriptor.withView(self.name, self.sizeHint, self.encode, self.decode, self.skip, codec.optional(type.View));
-        }
-        return self;
-    };
-    /** Variable-length sequence of given type. */
-    codec.sequenceVarLen = (type, options = {
-        minLength: 0,
-        maxLength: 2 ** 32 - 1,
-    }) => {
-        const name = `Sequence<${type.name}>[?]`;
-        const typicalLength = options.typicalLength ?? TYPICAL_SEQUENCE_LENGTH;
-        return Descriptor.withView(name, { bytes: typicalLength * type.sizeHint.bytes, isExact: false }, (e, v) => {
-            validateLength(options, v.length, name);
-            e.sequenceVarLen(type, v);
-        }, (d) => {
-            const len = d.varU32();
-            validateLength(options, len, name);
-            return d.sequenceFixLen(type, len);
-        }, (s) => {
-            const len = s.decoder.varU32();
-            validateLength(options, len, name);
-            return s.sequenceFixLen(type, len);
-        }, sequenceViewVarLen(type, options));
+/** Fixed-length bytes sequence. */
+const bytes = (() => {
+    const cache = new Map();
+    return (len) => {
+        let ret = cache.get(len);
+        if (ret === undefined) {
+            ret = Descriptor.new(`Bytes<${len}>`, exactHint(len), (e, v) => e.bytes(v), (d) => d.bytes(len), (s) => s.bytes(len));
+            cache.set(len, ret);
+        }
+        return ret;
     };
-    /** Fixed-length sequence of given type. */
-    codec.sequenceFixLen = (type, len) => Descriptor.withView(`Sequence<${type.name}>[${len}]`, { bytes: len * type.sizeHint.bytes, isExact: type.sizeHint.isExact }, (e, v) => e.sequenceFixLen(type, v), (d) => d.sequenceFixLen(type, len), (s) => s.sequenceFixLen(type, len), sequenceViewFixLen(type, { fixedLength: len }));
-    /** Small dictionary codec. */
-    codec.dictionary = (key, value, { sortKeys, fixedLength, }) => {
-        const self = Descriptor.new(`Dictionary<${key.name}, ${value.name}>[${fixedLength ?? "?"}]`, {
-            bytes: fixedLength !== undefined
-                ? fixedLength * addSizeHints(key.sizeHint, value.sizeHint).bytes
-                : TYPICAL_DICTIONARY_LENGTH * (addSizeHints(key.sizeHint, value.sizeHint).bytes ?? 0),
-            isExact: fixedLength !== undefined ? key.sizeHint.isExact && value.sizeHint.isExact : false,
-        }, (e, v) => {
-            const data = Array.from(v.entries());
-            data.sort((a, b) => sortKeys(a[0], b[0]));
-            // length prefix
-            if (fixedLength === undefined || fixedLength === 0) {
-                e.varU32(numbers_tryAsU32(data.length));
-            }
-            for (const [k, v] of data) {
-                key.encode(e, k);
-                value.encode(e, v);
+})();
+/** Zero-size `void` value. */
+const nothing = Descriptor.new("void", { bytes: 0, isExact: true }, (_e, _v) => { }, (_d) => { }, (_s) => { });
+/** Variable-length U32. */
+const varU32 = Descriptor.new("var_u32", { bytes: 4, isExact: false }, (e, v) => e.varU32(v), (d) => d.varU32(), (d) => d.varU32());
+/** Variable-length U64. */
+const varU64 = Descriptor.new("var_u64", { bytes: 8, isExact: false }, (e, v) => e.varU64(v), (d) => d.varU64(), (d) => d.varU64());
+/** Unsigned 64-bit number. */
+const u64 = Descriptor.withView("u64", exactHint(8), (e, v) => e.i64(v), (d) => d.u64(), (d) => d.u64(), bytes(8));
+/** Unsigned 32-bit number. */
+const u32 = Descriptor.withView("u32", exactHint(4), (e, v) => e.i32(v), (d) => d.u32(), (d) => d.u32(), bytes(4));
+/** Unsigned 24-bit number. */
+const u24 = Descriptor.withView("u24", exactHint(3), (e, v) => e.i24(v), (d) => d.u24(), (d) => d.u24(), bytes(3));
+/** Unsigned 16-bit number. */
+const u16 = Descriptor.withView("u16", exactHint(2), (e, v) => e.i16(v), (d) => d.u16(), (d) => d.u16(), bytes(2));
+/** Unsigned 8-bit number. */
+const u8 = Descriptor.new("u8", exactHint(1), (e, v) => e.i8(v), (d) => d.u8(), (d) => d.u8());
+/** Signed 64-bit number. */
+const i64 = Descriptor.withView("i64", exactHint(8), (e, v) => e.i64(v), (d) => d.i64(), (s) => s.u64(), bytes(8));
+/** Signed 32-bit number. */
+const i32 = Descriptor.withView("i32", exactHint(4), (e, v) => e.i32(v), (d) => d.i32(), (s) => s.u32(), bytes(4));
+/** Signed 24-bit number. */
+const i24 = Descriptor.withView("i24", exactHint(3), (e, v) => e.i24(v), (d) => d.i24(), (s) => s.u24(), bytes(3));
+/** Signed 16-bit number. */
+const i16 = Descriptor.withView("i16", exactHint(2), (e, v) => e.i16(v), (d) => d.i16(), (s) => s.u16(), bytes(2));
+/** Signed 8-bit number. */
+const i8 = Descriptor.new("i8", exactHint(1), (e, v) => e.i8(v), (d) => d.i8(), (s) => s.u8());
+/** 1-byte boolean value. */
+const bool = Descriptor.new("bool", exactHint(1), (e, v) => e.bool(v), (d) => d.bool(), (s) => s.bool());
+/** Variable-length bytes blob. */
+const blob = Descriptor.new("BytesBlob", { bytes: TYPICAL_SEQUENCE_LENGTH, isExact: false }, (e, v) => e.bytesBlob(v), (d) => d.bytesBlob(), (s) => s.bytesBlob());
+/** String encoded as variable-length bytes blob. */
+const string = Descriptor.withView("string", { bytes: TYPICAL_SEQUENCE_LENGTH, isExact: false }, (e, v) => e.bytesBlob(bytes_BytesBlob.blobFrom(new TextEncoder().encode(v))), (d) => new TextDecoder("utf8", { fatal: true }).decode(d.bytesBlob().raw), (s) => s.bytesBlob(), blob);
+/** Variable-length bit vector. */
+const bitVecVarLen = Descriptor.new("BitVec[?]", { bytes: TYPICAL_SEQUENCE_LENGTH >>> 3, isExact: false }, (e, v) => e.bitVecVarLen(v), (d) => d.bitVecVarLen(), (s) => s.bitVecVarLen());
+/** Fixed-length bit vector. */
+const bitVecFixLen = (bitLen) => Descriptor.new(`BitVec[${bitLen}]`, exactHint(bitLen >>> 3), (e, v) => e.bitVecFixLen(v), (d) => d.bitVecFixLen(bitLen), (s) => s.bitVecFixLen(bitLen));
+/** Optionality wrapper for given type. */
+const optional = (type) => {
+    const self = Descriptor.new(`Optional<${type.name}>`, addSizeHints({ bytes: 1, isExact: false }, type.sizeHint), (e, v) => e.optional(type, v), (d) => d.optional(type), (s) => s.optional(type));
+    if (hasUniqueView(type)) {
+        return Descriptor.withView(self.name, self.sizeHint, self.encode, self.decode, self.skip, optional(type.View));
+    }
+    return self;
+};
+/** Variable-length sequence of given type. */
+const sequenceVarLen = (type, options = {
+    minLength: 0,
+    maxLength: 2 ** 32 - 1,
+}) => {
+    const name = `Sequence<${type.name}>[?]`;
+    const typicalLength = options.typicalLength ?? TYPICAL_SEQUENCE_LENGTH;
+    return Descriptor.withView(name, { bytes: typicalLength * type.sizeHint.bytes, isExact: false }, (e, v) => {
+        validateLength(options, v.length, name);
+        e.sequenceVarLen(type, v);
+    }, (d) => {
+        const len = d.varU32();
+        validateLength(options, len, name);
+        return d.sequenceFixLen(type, len);
+    }, (s) => {
+        const len = s.decoder.varU32();
+        validateLength(options, len, name);
+        return s.sequenceFixLen(type, len);
+    }, sequenceViewVarLen(type, options));
+};
+/** Fixed-length sequence of given type. */
+const sequenceFixLen = (type, len) => Descriptor.withView(`Sequence<${type.name}>[${len}]`, { bytes: len * type.sizeHint.bytes, isExact: type.sizeHint.isExact }, (e, v) => e.sequenceFixLen(type, v), (d) => d.sequenceFixLen(type, len), (s) => s.sequenceFixLen(type, len), sequenceViewFixLen(type, { fixedLength: len }));
+/** Small dictionary codec. */
+const dictionary = (key, value, { sortKeys, fixedLength, }) => {
+    const self = Descriptor.new(`Dictionary<${key.name}, ${value.name}>[${fixedLength ?? "?"}]`, {
+        bytes: fixedLength !== undefined
+            ? fixedLength * addSizeHints(key.sizeHint, value.sizeHint).bytes
+            : TYPICAL_DICTIONARY_LENGTH * (addSizeHints(key.sizeHint, value.sizeHint).bytes ?? 0),
+        isExact: fixedLength !== undefined ? key.sizeHint.isExact && value.sizeHint.isExact : false,
+    }, (e, v) => {
+        const data = Array.from(v.entries());
+        data.sort((a, b) => sortKeys(a[0], b[0]));
+        // length prefix
+        if (fixedLength === undefined) {
+            e.varU32(numbers_tryAsU32(data.length));
+        }
+        for (const [k, v] of data) {
+            key.encode(e, k);
+            value.encode(e, v);
+        }
+    }, (d) => {
+        const map = new Map();
+        const len = fixedLength ?? d.varU32();
+        let prevKey = null;
+        for (let i = 0; i < len; i += 1) {
+            const k = key.decode(d);
+            const v = value.decode(d);
+            if (map.has(k)) {
+                throw new Error(`Duplicate item in the dictionary encoding: "${k}"!`);
             }
-        }, (d) => {
-            const map = new Map();
-            const len = fixedLength ?? d.varU32();
-            let prevKey = null;
-            for (let i = 0; i < len; i += 1) {
-                const k = key.decode(d);
-                const v = value.decode(d);
-                if (map.has(k)) {
-                    throw new Error(`Duplicate item in the dictionary encoding: "${k}"!`);
-                }
-                if (prevKey !== null && sortKeys(prevKey, k) >= 0) {
-                    throw new Error(`The keys in dictionary encoding are not sorted "${prevKey}" >= "${k}"!`);
-                }
-                map.set(k, v);
-                prevKey = k;
+            if (prevKey !== null && sortKeys(prevKey, k) >= 0) {
+                throw new Error(`The keys in dictionary encoding are not sorted "${prevKey}" >= "${k}"!`);
             }
-            return map;
-        }, (s) => {
-            const len = fixedLength ?? s.decoder.varU32();
-            s.sequenceFixLen(key, len);
-            s.sequenceFixLen(value, len);
-        });
-        if (hasUniqueView(value)) {
-            return Descriptor.withView(self.name, self.sizeHint, self.encode, self.decode, self.skip, codec.dictionary(key, value.View, { sortKeys, fixedLength }));
+            map.set(k, v);
+            prevKey = k;
         }
-        return self;
-    };
-    /** Encoding of pair of two values. */
-    codec.pair = (a, b) => {
-        const self = Descriptor.new(`Pair<${a.name}, ${b.name}>`, addSizeHints(a.sizeHint, b.sizeHint), (e, elem) => {
-            a.encode(e, elem[0]);
-            b.encode(e, elem[1]);
-        }, (d) => {
-            const aValue = a.decode(d);
-            const bValue = b.decode(d);
-            return [aValue, bValue];
-        }, (s) => {
-            a.skip(s);
-            b.skip(s);
-        });
-        if (hasUniqueView(a) && hasUniqueView(b)) {
-            return Descriptor.withView(self.name, self.sizeHint, self.encode, self.decode, self.skip, codec.pair(a.View, b.View));
+        return map;
+    }, (s) => {
+        const len = fixedLength ?? s.decoder.varU32();
+        s.sequenceFixLen(key, len);
+        s.sequenceFixLen(value, len);
+    });
+    if (hasUniqueView(value)) {
+        return Descriptor.withView(self.name, self.sizeHint, self.encode, self.decode, self.skip, dictionary(key, value.View, { sortKeys, fixedLength }));
+    }
+    return self;
+};
+/** Encoding of pair of two values. */
+const pair = (a, b) => {
+    const self = Descriptor.new(`Pair<${a.name}, ${b.name}>`, addSizeHints(a.sizeHint, b.sizeHint), (e, elem) => {
+        a.encode(e, elem[0]);
+        b.encode(e, elem[1]);
+    }, (d) => {
+        const aValue = a.decode(d);
+        const bValue = b.decode(d);
+        return [aValue, bValue];
+    }, (s) => {
+        a.skip(s);
+        b.skip(s);
+    });
+    if (hasUniqueView(a) && hasUniqueView(b)) {
+        return Descriptor.withView(self.name, self.sizeHint, self.encode, self.decode, self.skip, pair(a.View, b.View));
+    }
+    return self;
+};
+/** Custom encoding / decoding logic. */
+const custom = ({ name, sizeHint = { bytes: 0, isExact: false }, }, encode, decode, skip) => 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);
+    return Descriptor.withView(name, sizeHint, (e, x) => chooser(e.getContext()).encode(e, x), (d) => chooser(d.getContext()).decode(d), (s) => chooser(s.decoder.getContext()).skip(s), hasUniqueView(Self)
+        ? descriptors_select({
+            name: Self.View.name,
+            sizeHint: Self.View.sizeHint,
+        }, (ctx) => chooser(ctx).View)
+        : Self.View);
+};
+/**
+ * A descriptor for a more complex POJO.
+ *
+ * This descriptor is very similar to `Class`, but it DOES NOT maintain the
+ * prototype chain of the resulting object - we only care about the shape of
+ * the object here.
+ */
+const object = (descriptors, name = "object", create = (o) => o) => {
+    return Class({ name, create }, descriptors);
+};
+/**
+ * A descriptor for a more complex class type.
+ *
+ * The resulting descriptor is able to encode & decode all of the public fields of
+ * the class, given the map of descriptors for each one of them.
+ *
+ * The resulting decoded object will be an instance of given `Class` unlike simpler,
+ * shape-based `object` method.
+ */
+const Class = (Class, descriptors) => {
+    // Calculate a size hint for this class.
+    let sizeHint = exactHint(0);
+    forEachDescriptor(descriptors, (_k, val) => {
+        sizeHint = addSizeHints(sizeHint, val.sizeHint);
+    });
+    const skipper = (s) => {
+        // optimized case for fixed size complex values.
+        if (sizeHint.isExact) {
+            return s.decoder.skip(sizeHint.bytes);
         }
-        return self;
-    };
-    /** Custom encoding / decoding logic. */
-    codec.custom = ({ name, sizeHint = { bytes: 0, isExact: false }, }, encode, decode, skip) => Descriptor.new(name, sizeHint, encode, decode, skip);
-    /** Choose a descriptor depending on the encoding/decoding context. */
-    codec.select = ({ name, sizeHint, }, chooser) => {
-        const Self = chooser(null);
-        return Descriptor.withView(name, sizeHint, (e, x) => chooser(e.getContext()).encode(e, x), (d) => chooser(d.getContext()).decode(d), (s) => chooser(s.decoder.getContext()).skip(s), hasUniqueView(Self)
-            ? codec.select({
-                name: Self.View.name,
-                sizeHint: Self.View.sizeHint,
-            }, (ctx) => chooser(ctx).View)
-            : Self.View);
-    };
-    /**
-     * A descriptor for a more complex POJO.
-     *
-     * This descriptor is very similar to `Class`, but it DOES NOT maintain the
-     * prototype chain of the resulting object - we only care about the shape of
-     * the object here.
-     */
-    codec.object = (descriptors, name = "object", create = (o) => o) => {
-        return codec.Class({ name, create }, descriptors);
-    };
-    /**
-     * A descriptor for a more complex class type.
-     *
-     * The resulting descriptor is able to encode & decode all of the public fields of
-     * the class, given the map of descriptors for each one of them.
-     *
-     * The resulting decoded object will be an instance of given `Class` unlike simpler,
-     * shape-based `object` method.
-     */
-    codec.Class = (Class, descriptors) => {
-        // Calculate a size hint for this class.
-        let sizeHint = exactHint(0);
-        forEachDescriptor(descriptors, (_k, val) => {
-            sizeHint = addSizeHints(sizeHint, val.sizeHint);
+        forEachDescriptor(descriptors, (_key, descriptor) => {
+            descriptor.skip(s);
         });
-        const skipper = (s) => {
-            // optimized case for fixed size complex values.
-            if (sizeHint.isExact) {
-                return s.decoder.skip(sizeHint.bytes);
-            }
-            forEachDescriptor(descriptors, (_key, descriptor) => {
-                descriptor.skip(s);
-            });
-        };
-        const view = objectView(Class, descriptors, sizeHint, skipper);
-        // and create the descriptor for the entire class.
-        return Descriptor.withView(Class.name, sizeHint, (e, t) => {
-            forEachDescriptor(descriptors, (key, descriptor) => {
-                const value = t[key];
-                descriptor.encode(e, value);
-            });
-        }, (d) => {
-            const constructorParams = {};
-            forEachDescriptor(descriptors, (key, descriptor) => {
-                const value = descriptor.decode(d);
-                constructorParams[key] = value;
-            });
-            return Class.create(constructorParams);
-        }, skipper, view);
     };
-})(descriptors_codec || (descriptors_codec = {}));
+    const view = objectView(Class, descriptors, sizeHint, skipper);
+    // and create the descriptor for the entire class.
+    return Descriptor.withView(Class.name, sizeHint, (e, t) => {
+        forEachDescriptor(descriptors, (key, descriptor) => {
+            const value = t[key];
+            descriptor.encode(e, value);
+        });
+    }, (d) => {
+        const constructorParams = {};
+        forEachDescriptor(descriptors, (key, descriptor) => {
+            const value = descriptor.decode(d);
+            constructorParams[key] = value;
+        });
+        return Class.create(constructorParams);
+    }, skipper, view);
+};
 /** Typesafe iteration of every descriptor in the record object. */
 function forEachDescriptor(descriptors, f) {
     for (const key in descriptors) {
@@ -9003,7 +9002,7 @@ var PvmBackend;
 
 
 
-;// CONCATENATED MODULE: ./packages/jam/block/codec.ts
+;// CONCATENATED MODULE: ./packages/jam/block/codec-utils.ts
 
 
 
@@ -9018,7 +9017,7 @@ function codecWithContext(chooser) {
     const defaultContext = chain_spec_fullChainSpec;
     const { name, sizeHint } = chooser(defaultContext);
     const cache = new Map();
-    return descriptors_codec.select({
+    return descriptors_select({
         name,
         sizeHint: { bytes: sizeHint.bytes, isExact: false },
     }, (context) => {
@@ -9045,9 +9044,9 @@ function codecWithContext(chooser) {
 /** Codec for a known-size array with length validation. */
 const codecKnownSizeArray = (val, options, _id) => {
     if ("fixedLength" in options) {
-        return readonlyArray(descriptors_codec.sequenceFixLen(val, options.fixedLength)).convert(seeThrough, sized_array_asKnownSize);
+        return readonlyArray(sequenceFixLen(val, options.fixedLength)).convert(seeThrough, sized_array_asKnownSize);
     }
-    return readonlyArray(descriptors_codec.sequenceVarLen(val, options)).convert(seeThrough, sized_array_asKnownSize);
+    return readonlyArray(sequenceVarLen(val, options)).convert(seeThrough, sized_array_asKnownSize);
 };
 /** Codec for a fixed-size array with length validation. */
 const codecFixedSizeArray = (val, len) => {
@@ -9056,7 +9055,7 @@ const codecFixedSizeArray = (val, len) => {
             throw new Error(`[${val.name}] Invalid size of fixed-size array. Got ${actual}, expected: ${len}`);
         }
     };
-    return descriptors_codec.sequenceFixLen(val, len).convert((i) => {
+    return sequenceFixLen(val, len).convert((i) => {
         checkLength(i.length);
         return i;
     }, (o) => {
@@ -9117,13 +9116,13 @@ class AvailabilityAssurance extends WithDebug {
     bitfield;
     validatorIndex;
     signature;
-    static Codec = descriptors_codec.Class(AvailabilityAssurance, {
-        anchor: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
+    static Codec = Class(AvailabilityAssurance, {
+        anchor: bytes(hash_HASH_SIZE).asOpaque(),
         bitfield: codecWithContext((context) => {
-            return descriptors_codec.bitVecFixLen(context.coresCount);
+            return bitVecFixLen(context.coresCount);
         }),
-        validatorIndex: descriptors_codec.u16.asOpaque(),
-        signature: descriptors_codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+        validatorIndex: u16.asOpaque(),
+        signature: bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
     });
     static create({ anchor, bitfield, validatorIndex, signature }) {
         return new AvailabilityAssurance(anchor, bitfield, validatorIndex, signature);
@@ -9215,11 +9214,11 @@ class Fault extends WithDebug {
     wasConsideredValid;
     key;
     signature;
-    static Codec = descriptors_codec.Class(Fault, {
-        workReportHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        wasConsideredValid: descriptors_codec.bool,
-        key: descriptors_codec.bytes(ED25519_KEY_BYTES).asOpaque(),
-        signature: descriptors_codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+    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 create({ workReportHash, wasConsideredValid, key, signature }) {
         return new Fault(workReportHash, wasConsideredValid, key, signature);
@@ -9247,10 +9246,10 @@ class Culprit extends WithDebug {
     workReportHash;
     key;
     signature;
-    static Codec = descriptors_codec.Class(Culprit, {
-        workReportHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        key: descriptors_codec.bytes(ED25519_KEY_BYTES).asOpaque(),
-        signature: descriptors_codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+    static Codec = Class(Culprit, {
+        workReportHash: bytes(hash_HASH_SIZE).asOpaque(),
+        key: bytes(ED25519_KEY_BYTES).asOpaque(),
+        signature: bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
     });
     static create({ workReportHash, key, signature }) {
         return new Culprit(workReportHash, key, signature);
@@ -9275,10 +9274,10 @@ class Judgement extends WithDebug {
     isWorkReportValid;
     index;
     signature;
-    static Codec = descriptors_codec.Class(Judgement, {
-        isWorkReportValid: descriptors_codec.bool,
-        index: descriptors_codec.u16.asOpaque(),
-        signature: descriptors_codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+    static Codec = Class(Judgement, {
+        isWorkReportValid: bool,
+        index: u16.asOpaque(),
+        signature: bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
     });
     static create({ isWorkReportValid, index, signature }) {
         return new Judgement(isWorkReportValid, index, signature);
@@ -9307,11 +9306,12 @@ class Verdict extends WithDebug {
     workReportHash;
     votesEpoch;
     votes;
-    static Codec = descriptors_codec.Class(Verdict, {
-        workReportHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        votesEpoch: descriptors_codec.u32.asOpaque(),
+    static Codec = Class(Verdict, {
+        workReportHash: bytes(hash_HASH_SIZE).asOpaque(),
+        votesEpoch: u32.asOpaque(),
         votes: codecWithContext((context) => {
-            return readonlyArray(descriptors_codec.sequenceFixLen(Judgement.Codec, context.validatorsSuperMajority)).convert(seeThrough, sized_array_asKnownSize);
+            return readonlyArray(sequenceFixLen(Judgement.Codec, context.validatorsSuperMajority))
+                .convert(seeThrough, sized_array_asKnownSize);
         }),
     });
     static create({ workReportHash, votesEpoch, votes }) {
@@ -9352,10 +9352,10 @@ class DisputesExtrinsic extends WithDebug {
     verdicts;
     culprits;
     faults;
-    static Codec = descriptors_codec.Class(DisputesExtrinsic, {
-        verdicts: descriptors_codec.sequenceVarLen(Verdict.Codec),
-        culprits: descriptors_codec.sequenceVarLen(Culprit.Codec),
-        faults: descriptors_codec.sequenceVarLen(Fault.Codec),
+    static Codec = Class(DisputesExtrinsic, {
+        verdicts: sequenceVarLen(Verdict.Codec),
+        culprits: sequenceVarLen(Culprit.Codec),
+        faults: sequenceVarLen(Fault.Codec),
     });
     static create({ verdicts, culprits, faults }) {
         return new DisputesExtrinsic(verdicts, culprits, faults);
@@ -9401,9 +9401,9 @@ class DisputesExtrinsic extends WithDebug {
 class WorkPackageInfo extends WithDebug {
     workPackageHash;
     segmentTreeRoot;
-    static Codec = descriptors_codec.Class(WorkPackageInfo, {
-        workPackageHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        segmentTreeRoot: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
+    static Codec = Class(WorkPackageInfo, {
+        workPackageHash: bytes(hash_HASH_SIZE).asOpaque(),
+        segmentTreeRoot: bytes(hash_HASH_SIZE).asOpaque(),
     });
     constructor(
     /** Hash of the described work package. */
@@ -9431,13 +9431,13 @@ class RefineContext extends WithDebug {
     lookupAnchor;
     lookupAnchorSlot;
     prerequisites;
-    static Codec = descriptors_codec.Class(RefineContext, {
-        anchor: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        stateRoot: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        beefyRoot: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        lookupAnchor: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        lookupAnchorSlot: descriptors_codec.u32.asOpaque(),
-        prerequisites: descriptors_codec.sequenceVarLen(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque()),
+    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 create({ anchor, stateRoot, beefyRoot, lookupAnchor, lookupAnchorSlot, prerequisites, }) {
         return new RefineContext(anchor, stateRoot, beefyRoot, lookupAnchor, lookupAnchorSlot, prerequisites);
@@ -9494,9 +9494,9 @@ const tryAsSegmentIndex = (v) => asOpaqueType(tryAsU16(v));
 class ImportSpec extends WithDebug {
     treeRoot;
     index;
-    static Codec = descriptors_codec.Class(ImportSpec, {
-        treeRoot: descriptors_codec.bytes(hash_HASH_SIZE),
-        index: descriptors_codec.u16.asOpaque(),
+    static Codec = Class(ImportSpec, {
+        treeRoot: bytes(hash_HASH_SIZE),
+        index: u16.asOpaque(),
     });
     static create({ treeRoot, index }) {
         return new ImportSpec(treeRoot, index);
@@ -9518,9 +9518,9 @@ class ImportSpec extends WithDebug {
 class WorkItemExtrinsicSpec extends WithDebug {
     hash;
     len;
-    static Codec = descriptors_codec.Class(WorkItemExtrinsicSpec, {
-        hash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        len: descriptors_codec.u32,
+    static Codec = Class(WorkItemExtrinsicSpec, {
+        hash: bytes(hash_HASH_SIZE).asOpaque(),
+        len: u32,
     });
     static create({ hash, len }) {
         return new WorkItemExtrinsicSpec(hash, len);
@@ -9581,33 +9581,33 @@ class work_item_WorkItem extends WithDebug {
     extrinsic;
     exportCount;
     static Codec = Compatibility.isGreaterOrEqual(GpVersion.V0_7_0)
-        ? descriptors_codec.Class(work_item_WorkItem, {
-            service: descriptors_codec.u32.asOpaque(),
-            codeHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-            refineGasLimit: descriptors_codec.u64.asOpaque(),
-            accumulateGasLimit: descriptors_codec.u64.asOpaque(),
-            exportCount: descriptors_codec.u16,
-            payload: descriptors_codec.blob,
+        ? Class(work_item_WorkItem, {
+            service: u32.asOpaque(),
+            codeHash: bytes(hash_HASH_SIZE).asOpaque(),
+            refineGasLimit: u64.asOpaque(),
+            accumulateGasLimit: u64.asOpaque(),
+            exportCount: u16,
+            payload: blob,
             importSegments: codecKnownSizeArray(ImportSpec.Codec, {
                 minLength: 0,
                 maxLength: MAX_NUMBER_OF_SEGMENTS,
                 typicalLength: MAX_NUMBER_OF_SEGMENTS,
             }),
-            extrinsic: descriptors_codec.sequenceVarLen(WorkItemExtrinsicSpec.Codec),
+            extrinsic: sequenceVarLen(WorkItemExtrinsicSpec.Codec),
         })
-        : descriptors_codec.Class(work_item_WorkItem, {
-            service: descriptors_codec.u32.asOpaque(),
-            codeHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-            payload: descriptors_codec.blob,
-            refineGasLimit: descriptors_codec.u64.asOpaque(),
-            accumulateGasLimit: descriptors_codec.u64.asOpaque(),
+        : Class(work_item_WorkItem, {
+            service: u32.asOpaque(),
+            codeHash: bytes(hash_HASH_SIZE).asOpaque(),
+            payload: blob,
+            refineGasLimit: u64.asOpaque(),
+            accumulateGasLimit: u64.asOpaque(),
             importSegments: codecKnownSizeArray(ImportSpec.Codec, {
                 minLength: 0,
                 maxLength: MAX_NUMBER_OF_SEGMENTS,
                 typicalLength: MAX_NUMBER_OF_SEGMENTS,
             }),
-            extrinsic: descriptors_codec.sequenceVarLen(WorkItemExtrinsicSpec.Codec),
-            exportCount: descriptors_codec.u16,
+            extrinsic: sequenceVarLen(WorkItemExtrinsicSpec.Codec),
+            exportCount: u16,
         });
     static create({ service, codeHash, payload, refineGasLimit, accumulateGasLimit, importSegments, extrinsic, exportCount, }) {
         return new work_item_WorkItem(service, codeHash, payload, refineGasLimit, accumulateGasLimit, importSegments, extrinsic, exportCount);
@@ -9681,21 +9681,21 @@ class work_package_WorkPackage extends WithDebug {
     context;
     items;
     static Codec = Compatibility.isGreaterOrEqual(GpVersion.V0_7_0)
-        ? descriptors_codec.Class(work_package_WorkPackage, {
-            authCodeHost: descriptors_codec.u32.asOpaque(),
-            authCodeHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        ? Class(work_package_WorkPackage, {
+            authCodeHost: u32.asOpaque(),
+            authCodeHash: bytes(hash_HASH_SIZE).asOpaque(),
             context: RefineContext.Codec,
-            authorization: descriptors_codec.blob,
-            parametrization: descriptors_codec.blob,
-            items: descriptors_codec.sequenceVarLen(work_item_WorkItem.Codec).convert((x) => x, (items) => FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
+            authorization: blob,
+            parametrization: blob,
+            items: sequenceVarLen(work_item_WorkItem.Codec).convert((x) => x, (items) => FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
         })
-        : descriptors_codec.Class(work_package_WorkPackage, {
-            authorization: descriptors_codec.blob,
-            authCodeHost: descriptors_codec.u32.asOpaque(),
-            authCodeHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-            parametrization: descriptors_codec.blob,
+        : Class(work_package_WorkPackage, {
+            authorization: blob,
+            authCodeHost: u32.asOpaque(),
+            authCodeHash: bytes(hash_HASH_SIZE).asOpaque(),
+            parametrization: blob,
             context: RefineContext.Codec,
-            items: descriptors_codec.sequenceVarLen(work_item_WorkItem.Codec).convert((x) => x, (items) => FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
+            items: 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);
@@ -9755,7 +9755,7 @@ var WorkExecResultKind;
 class WorkExecResult extends WithDebug {
     kind;
     okBlob;
-    static Codec = descriptors_codec.custom({
+    static Codec = custom({
         name: "WorkExecResult",
         sizeHint: { bytes: 1, isExact: false },
     }, (e, x) => {
@@ -9802,12 +9802,12 @@ class WorkRefineLoad extends WithDebug {
     extrinsicCount;
     extrinsicSize;
     exportedSegments;
-    static Codec = descriptors_codec.Class(WorkRefineLoad, {
-        gasUsed: descriptors_codec.varU64.asOpaque(),
-        importedSegments: descriptors_codec.varU32,
-        extrinsicCount: descriptors_codec.varU32,
-        extrinsicSize: descriptors_codec.varU32,
-        exportedSegments: descriptors_codec.varU32,
+    static Codec = Class(WorkRefineLoad, {
+        gasUsed: varU64.asOpaque(),
+        importedSegments: varU32,
+        extrinsicCount: varU32,
+        extrinsicSize: varU32,
+        exportedSegments: varU32,
     });
     static create({ gasUsed, importedSegments, extrinsicCount, extrinsicSize, exportedSegments, }) {
         return new WorkRefineLoad(gasUsed, importedSegments, extrinsicCount, extrinsicSize, exportedSegments);
@@ -9843,11 +9843,11 @@ class WorkResult {
     gas;
     result;
     load;
-    static Codec = descriptors_codec.Class(WorkResult, {
-        serviceId: descriptors_codec.u32.asOpaque(),
-        codeHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        payloadHash: descriptors_codec.bytes(hash_HASH_SIZE),
-        gas: descriptors_codec.u64.asOpaque(),
+    static Codec = Class(WorkResult, {
+        serviceId: u32.asOpaque(),
+        codeHash: bytes(hash_HASH_SIZE).asOpaque(),
+        payloadHash: bytes(hash_HASH_SIZE),
+        gas: u64.asOpaque(),
         result: WorkExecResult.Codec,
         load: WorkRefineLoad.Codec,
     });
@@ -9914,12 +9914,12 @@ class WorkPackageSpec extends WithDebug {
     erasureRoot;
     exportsRoot;
     exportsCount;
-    static Codec = descriptors_codec.Class(WorkPackageSpec, {
-        hash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        length: descriptors_codec.u32,
-        erasureRoot: descriptors_codec.bytes(hash_HASH_SIZE),
-        exportsRoot: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        exportsCount: descriptors_codec.u16,
+    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 create({ hash, length, erasureRoot, exportsRoot, exportsCount }) {
         return new WorkPackageSpec(hash, length, erasureRoot, exportsRoot, exportsCount);
@@ -9991,35 +9991,35 @@ class WorkReportNoCodec extends WithDebug {
         this.authorizationGasUsed = authorizationGasUsed;
     }
 }
-const WorkReportCodec = descriptors_codec.Class(WorkReportNoCodec, {
+const WorkReportCodec = Class(WorkReportNoCodec, {
     workPackageSpec: WorkPackageSpec.Codec,
     context: RefineContext.Codec,
-    coreIndex: descriptors_codec.varU32.convert((o) => numbers_tryAsU32(o), (i) => {
+    coreIndex: varU32.convert((o) => numbers_tryAsU32(o), (i) => {
         if (!isU16(i)) {
             throw new Error(`Core index exceeds U16: ${i}`);
         }
         return tryAsCoreIndex(i);
     }),
-    authorizerHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-    authorizationGasUsed: descriptors_codec.varU64.asOpaque(),
-    authorizationOutput: descriptors_codec.blob,
-    segmentRootLookup: readonlyArray(descriptors_codec.sequenceVarLen(WorkPackageInfo.Codec)),
-    results: descriptors_codec.sequenceVarLen(WorkResult.Codec).convert((x) => x, (items) => FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
+    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))),
 });
-const WorkReportCodecPre070 = descriptors_codec.Class(WorkReportNoCodec, {
+const WorkReportCodecPre070 = Class(WorkReportNoCodec, {
     workPackageSpec: WorkPackageSpec.Codec,
     context: RefineContext.Codec,
-    coreIndex: descriptors_codec.varU32.convert((o) => numbers_tryAsU32(o), (i) => {
+    coreIndex: varU32.convert((o) => numbers_tryAsU32(o), (i) => {
         if (!isU16(i)) {
             throw new Error(`Core index exceeds U16: ${i}`);
         }
         return tryAsCoreIndex(i);
     }),
-    authorizerHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-    authorizationOutput: descriptors_codec.blob,
-    segmentRootLookup: readonlyArray(descriptors_codec.sequenceVarLen(WorkPackageInfo.Codec)),
-    results: descriptors_codec.sequenceVarLen(WorkResult.Codec).convert((x) => x, (items) => FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
-    authorizationGasUsed: descriptors_codec.varU64.asOpaque(),
+    authorizerHash: bytes(hash_HASH_SIZE).asOpaque(),
+    authorizationOutput: blob,
+    segmentRootLookup: readonlyArray(sequenceVarLen(WorkPackageInfo.Codec)),
+    results: sequenceVarLen(WorkResult.Codec).convert((x) => x, (items) => FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
+    authorizationGasUsed: varU64.asOpaque(),
 });
 class WorkReport extends WorkReportNoCodec {
     static Codec = Compatibility.isGreaterOrEqual(GpVersion.V0_7_0)
@@ -10038,9 +10038,9 @@ const REQUIRED_CREDENTIALS_RANGE = [2, 3];
 class Credential extends WithDebug {
     validatorIndex;
     signature;
-    static Codec = descriptors_codec.Class(Credential, {
-        validatorIndex: descriptors_codec.u16.asOpaque(),
-        signature: descriptors_codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+    static Codec = Class(Credential, {
+        validatorIndex: u16.asOpaque(),
+        signature: bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
     });
     static create({ validatorIndex, signature }) {
         return new Credential(validatorIndex, signature);
@@ -10064,9 +10064,9 @@ class ReportGuarantee extends WithDebug {
     report;
     slot;
     credentials;
-    static Codec = descriptors_codec.Class(ReportGuarantee, {
+    static Codec = Class(ReportGuarantee, {
         report: WorkReport.Codec,
-        slot: descriptors_codec.u32.asOpaque(),
+        slot: u32.asOpaque(),
         credentials: codecKnownSizeArray(Credential.Codec, {
             minLength: REQUIRED_CREDENTIALS_RANGE[0],
             maxLength: REQUIRED_CREDENTIALS_RANGE[1],
@@ -10116,10 +10116,10 @@ function tryAsTicketAttempt(x) {
 class SignedTicket extends WithDebug {
     attempt;
     signature;
-    static Codec = descriptors_codec.Class(SignedTicket, {
+    static Codec = Class(SignedTicket, {
         // TODO [ToDr] we should verify that attempt is either 0|1|2.
-        attempt: descriptors_codec.u8.asOpaque(),
-        signature: descriptors_codec.bytes(BANDERSNATCH_PROOF_BYTES).asOpaque(),
+        attempt: u8.asOpaque(),
+        signature: bytes(BANDERSNATCH_PROOF_BYTES).asOpaque(),
     });
     static create({ attempt, signature }) {
         return new SignedTicket(attempt, signature);
@@ -10138,10 +10138,10 @@ class SignedTicket extends WithDebug {
 class Ticket extends WithDebug {
     id;
     attempt;
-    static Codec = descriptors_codec.Class(Ticket, {
-        id: descriptors_codec.bytes(hash_HASH_SIZE),
+    static Codec = Class(Ticket, {
+        id: bytes(hash_HASH_SIZE),
         // TODO [ToDr] we should verify that attempt is either 0|1|2.
-        attempt: descriptors_codec.u8.asOpaque(),
+        attempt: u8.asOpaque(),
     });
     static create({ id, attempt }) {
         return new Ticket(id, attempt);
@@ -10193,9 +10193,9 @@ const ticketsExtrinsicCodec = codecWithContext((context) => {
 class ValidatorKeys extends WithDebug {
     bandersnatch;
     ed25519;
-    static Codec = descriptors_codec.Class(ValidatorKeys, {
-        bandersnatch: descriptors_codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque(),
-        ed25519: descriptors_codec.bytes(ED25519_KEY_BYTES).asOpaque(),
+    static Codec = Class(ValidatorKeys, {
+        bandersnatch: bytes(BANDERSNATCH_KEY_BYTES).asOpaque(),
+        ed25519: bytes(ED25519_KEY_BYTES).asOpaque(),
     });
     static create({ bandersnatch, ed25519 }) {
         return new ValidatorKeys(bandersnatch, ed25519);
@@ -10212,7 +10212,7 @@ class ValidatorKeys extends WithDebug {
 }
 class TicketsMarker extends WithDebug {
     tickets;
-    static Codec = descriptors_codec.Class(TicketsMarker, {
+    static Codec = Class(TicketsMarker, {
         tickets: codecPerEpochBlock(Ticket.Codec),
     });
     static create({ tickets }) {
@@ -10234,9 +10234,9 @@ class EpochMarker extends WithDebug {
     entropy;
     ticketsEntropy;
     validators;
-    static Codec = descriptors_codec.Class(EpochMarker, {
-        entropy: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        ticketsEntropy: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
+    static Codec = Class(EpochMarker, {
+        entropy: bytes(hash_HASH_SIZE).asOpaque(),
+        ticketsEntropy: bytes(hash_HASH_SIZE).asOpaque(),
         validators: codecPerValidator(ValidatorKeys.Codec),
     });
     static create({ entropy, ticketsEntropy, validators }) {
@@ -10271,16 +10271,16 @@ const encodeUnsealedHeader = (view) => {
  * Codec descriptor with pre 0.7.0 encoding order
  */
 const legacyDescriptor = {
-    parentHeaderHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-    priorStateRoot: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-    extrinsicHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-    timeSlotIndex: descriptors_codec.u32.asOpaque(),
-    epochMarker: descriptors_codec.optional(EpochMarker.Codec),
-    ticketsMarker: descriptors_codec.optional(TicketsMarker.Codec),
-    offendersMarker: descriptors_codec.sequenceVarLen(descriptors_codec.bytes(ED25519_KEY_BYTES).asOpaque()),
-    bandersnatchBlockAuthorIndex: descriptors_codec.u16.asOpaque(),
-    entropySource: descriptors_codec.bytes(bandersnatch_BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
-    seal: descriptors_codec.bytes(bandersnatch_BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
+    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),
+    offendersMarker: sequenceVarLen(bytes(ED25519_KEY_BYTES).asOpaque()),
+    bandersnatchBlockAuthorIndex: u16.asOpaque(),
+    entropySource: bytes(bandersnatch_BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
+    seal: bytes(bandersnatch_BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
 };
 /**
  * The header of the JAM block.
@@ -10288,19 +10288,19 @@ const legacyDescriptor = {
  * https://graypaper.fluffylabs.dev/#/579bd12/0c66000c7200
  */
 class header_Header extends WithDebug {
-    static Codec = descriptors_codec.Class(header_Header, Compatibility.isLessThan(GpVersion.V0_7_0)
+    static Codec = Class(header_Header, Compatibility.isLessThan(GpVersion.V0_7_0)
         ? legacyDescriptor
         : {
-            parentHeaderHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-            priorStateRoot: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-            extrinsicHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-            timeSlotIndex: descriptors_codec.u32.asOpaque(),
-            epochMarker: descriptors_codec.optional(EpochMarker.Codec),
-            ticketsMarker: descriptors_codec.optional(TicketsMarker.Codec),
-            bandersnatchBlockAuthorIndex: descriptors_codec.u16.asOpaque(),
-            entropySource: descriptors_codec.bytes(bandersnatch_BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
-            offendersMarker: descriptors_codec.sequenceVarLen(descriptors_codec.bytes(ED25519_KEY_BYTES).asOpaque()),
-            seal: descriptors_codec.bytes(bandersnatch_BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
+            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 create(h) {
         return Object.assign(header_Header.empty(), h);
@@ -10355,8 +10355,8 @@ class header_Header extends WithDebug {
  * `DescriptorRecord` or `CodecRecord` for some reason.
  */
 class HeaderViewWithHash extends WithHash {
-    static Codec = descriptors_codec.Class(HeaderViewWithHash, {
-        hash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
+    static Codec = Class(HeaderViewWithHash, {
+        hash: bytes(hash_HASH_SIZE).asOpaque(),
         data: header_Header.Codec.View,
     });
     static create({ hash, data }) {
@@ -10377,9 +10377,9 @@ const headerViewWithHashCodec = HeaderViewWithHash.Codec;
 class Preimage extends WithDebug {
     requester;
     blob;
-    static Codec = descriptors_codec.Class(Preimage, {
-        requester: descriptors_codec.u32.asOpaque(),
-        blob: descriptors_codec.blob,
+    static Codec = Class(Preimage, {
+        requester: u32.asOpaque(),
+        blob: blob,
     });
     static create({ requester, blob }) {
         return new Preimage(requester, blob);
@@ -10394,7 +10394,7 @@ class Preimage extends WithDebug {
         this.blob = blob;
     }
 }
-const preimagesExtrinsicCodec = descriptors_codec.sequenceVarLen(Preimage.Codec);
+const preimagesExtrinsicCodec = sequenceVarLen(Preimage.Codec);
 
 ;// CONCATENATED MODULE: ./packages/jam/block/block.ts
 
@@ -10420,7 +10420,7 @@ class Extrinsic extends WithDebug {
     guarantees;
     assurances;
     disputes;
-    static Codec = descriptors_codec.Class(Extrinsic, {
+    static Codec = Class(Extrinsic, {
         tickets: ticketsExtrinsicCodec,
         preimages: preimagesExtrinsicCodec,
         guarantees: guaranteesExtrinsicCodec,
@@ -10473,7 +10473,7 @@ class Extrinsic extends WithDebug {
 class Block extends WithDebug {
     header;
     extrinsic;
-    static Codec = descriptors_codec.Class(Block, {
+    static Codec = Class(Block, {
         header: header_Header.Codec,
         extrinsic: Extrinsic.Codec,
     });
@@ -11457,10 +11457,10 @@ class Version extends WithDebug {
     major;
     minor;
     patch;
-    static Codec = descriptors_codec.Class(Version, {
-        major: descriptors_codec.u8,
-        minor: descriptors_codec.u8,
-        patch: descriptors_codec.u8,
+    static Codec = Class(Version, {
+        major: u8,
+        minor: u8,
+        patch: u8,
     });
     static tryFromString(str) {
         const parse = (v) => tryAsU8(Number(v));
@@ -11512,12 +11512,12 @@ class PeerInfo extends WithDebug {
     jamVersion;
     appVersion;
     name;
-    static Codec = descriptors_codec.Class(PeerInfo, {
-        fuzzVersion: descriptors_codec.u8,
-        features: descriptors_codec.u32,
+    static Codec = Class(PeerInfo, {
+        fuzzVersion: u8,
+        features: u32,
         jamVersion: Version.Codec,
         appVersion: Version.Codec,
-        name: descriptors_codec.string,
+        name: string,
     });
     static create({ fuzzVersion, features, appVersion, jamVersion, name }) {
         return new PeerInfo(fuzzVersion, features, jamVersion, appVersion, name);
@@ -11540,9 +11540,9 @@ class PeerInfo extends WithDebug {
 class AncestryItem extends WithDebug {
     slot;
     headerHash;
-    static Codec = descriptors_codec.Class(AncestryItem, {
-        slot: descriptors_codec.u32.asOpaque(),
-        headerHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
+    static Codec = Class(AncestryItem, {
+        slot: u32.asOpaque(),
+        headerHash: bytes(hash_HASH_SIZE).asOpaque(),
     });
     static create({ slot, headerHash }) {
         return new AncestryItem(slot, headerHash);
@@ -11562,9 +11562,9 @@ class AncestryItem extends WithDebug {
 class KeyValue extends WithDebug {
     key;
     value;
-    static Codec = descriptors_codec.Class(KeyValue, {
-        key: descriptors_codec.bytes(TRUNCATED_HASH_SIZE),
-        value: descriptors_codec.blob,
+    static Codec = Class(KeyValue, {
+        key: bytes(TRUNCATED_HASH_SIZE),
+        value: blob,
     });
     static create({ key, value }) {
         return new KeyValue(key, value);
@@ -11576,12 +11576,12 @@ class KeyValue extends WithDebug {
     }
 }
 /** State ::= SEQUENCE OF KeyValue */
-const stateCodec = descriptors_codec.sequenceVarLen(KeyValue.Codec);
+const stateCodec = sequenceVarLen(KeyValue.Codec);
 /**
  * Ancestry ::= SEQUENCE (SIZE(0..24)) OF AncestryItem
  * Empty when `feature-ancestry` is not supported by both parties
  */
-const ancestryCodec = descriptors_codec.sequenceVarLen(AncestryItem.Codec, {
+const ancestryCodec = sequenceVarLen(AncestryItem.Codec, {
     minLength: 0,
     maxLength: 24,
 });
@@ -11596,7 +11596,7 @@ class Initialize extends WithDebug {
     header;
     keyvals;
     ancestry;
-    static Codec = descriptors_codec.Class(Initialize, {
+    static Codec = Class(Initialize, {
         header: header_Header.Codec,
         keyvals: stateCodec,
         ancestry: ancestryCodec,
@@ -11612,14 +11612,14 @@ class Initialize extends WithDebug {
     }
 }
 /** GetState ::= HeaderHash */
-const getStateCodec = descriptors_codec.bytes(hash_HASH_SIZE).asOpaque();
+const getStateCodec = bytes(hash_HASH_SIZE).asOpaque();
 /** StateRoot ::= StateRootHash */
-const stateRootCodec = descriptors_codec.bytes(hash_HASH_SIZE).asOpaque();
+const stateRootCodec = bytes(hash_HASH_SIZE).asOpaque();
 /** Error ::= UTF8String */
 class ErrorMessage extends WithDebug {
     message;
-    static Codec = descriptors_codec.Class(ErrorMessage, {
-        message: descriptors_codec.string,
+    static Codec = Class(ErrorMessage, {
+        message: string,
     });
     static create({ message }) {
         return new ErrorMessage(message);
@@ -11651,7 +11651,7 @@ var types_MessageType;
  *     error         [255] Error
  * }
  */
-const types_messageCodec = descriptors_codec.custom({
+const types_messageCodec = custom({
     name: "Message",
     sizeHint: { bytes: 1, isExact: false },
 }, (e, msg) => {
@@ -12015,9 +12015,9 @@ function getRegisters(argsLength) {
 class AccumulationOutput {
     serviceId;
     output;
-    static Codec = descriptors_codec.Class(AccumulationOutput, {
-        serviceId: descriptors_codec.u32.asOpaque(),
-        output: descriptors_codec.bytes(hash_HASH_SIZE),
+    static Codec = Class(AccumulationOutput, {
+        serviceId: u32.asOpaque(),
+        output: bytes(hash_HASH_SIZE),
     });
     static create(a) {
         return new AccumulationOutput(a.serviceId, a.output);
@@ -12110,9 +12110,9 @@ const MAX_REPORT_DEPENDENCIES = 8;
 class NotYetAccumulatedReport extends WithDebug {
     report;
     dependencies;
-    static Codec = descriptors_codec.Class(NotYetAccumulatedReport, {
+    static Codec = Class(NotYetAccumulatedReport, {
         report: WorkReport.Codec,
-        dependencies: codecKnownSizeArray(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(), {
+        dependencies: codecKnownSizeArray(bytes(hash_HASH_SIZE).asOpaque(), {
             typicalLength: MAX_REPORT_DEPENDENCIES / 2,
             maxLength: MAX_REPORT_DEPENDENCIES,
             minLength: 0,
@@ -12139,7 +12139,7 @@ class NotYetAccumulatedReport extends WithDebug {
         this.dependencies = dependencies;
     }
 }
-const accumulationQueueCodec = codecPerEpochBlock(readonlyArray(descriptors_codec.sequenceVarLen(NotYetAccumulatedReport.Codec)));
+const accumulationQueueCodec = codecPerEpochBlock(readonlyArray(sequenceVarLen(NotYetAccumulatedReport.Codec)));
 
 ;// CONCATENATED MODULE: ./packages/jam/state/common.ts
 
@@ -12172,9 +12172,9 @@ const codecPerCore = (val) => codecWithContext((context) => {
 class AvailabilityAssignment extends WithDebug {
     workReport;
     timeout;
-    static Codec = descriptors_codec.Class(AvailabilityAssignment, {
+    static Codec = Class(AvailabilityAssignment, {
         workReport: WorkReport.Codec,
-        timeout: descriptors_codec.u32.asOpaque(),
+        timeout: u32.asOpaque(),
     });
     static create({ workReport, timeout }) {
         return new AvailabilityAssignment(workReport, timeout);
@@ -12189,7 +12189,7 @@ class AvailabilityAssignment extends WithDebug {
         this.timeout = timeout;
     }
 }
-const availabilityAssignmentsCodec = codecPerCore(descriptors_codec.optional(AvailabilityAssignment.Codec));
+const availabilityAssignmentsCodec = codecPerCore(optional(AvailabilityAssignment.Codec));
 
 ;// CONCATENATED MODULE: ./packages/jam/state/auth.ts
 
@@ -12201,18 +12201,18 @@ const availabilityAssignmentsCodec = codecPerCore(descriptors_codec.optional(Ava
 const MAX_AUTH_POOL_SIZE = O;
 /** `Q`: Size of the authorization queue. */
 const AUTHORIZATION_QUEUE_SIZE = Q;
-const authPoolsCodec = codecPerCore(codecKnownSizeArray(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(), {
+const authPoolsCodec = codecPerCore(codecKnownSizeArray(bytes(hash_HASH_SIZE).asOpaque(), {
     minLength: 0,
     maxLength: MAX_AUTH_POOL_SIZE,
     typicalLength: MAX_AUTH_POOL_SIZE,
 }));
-const authQueuesCodec = codecPerCore(codecFixedSizeArray(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(), AUTHORIZATION_QUEUE_SIZE));
+const authQueuesCodec = codecPerCore(codecFixedSizeArray(bytes(hash_HASH_SIZE).asOpaque(), AUTHORIZATION_QUEUE_SIZE));
 
 ;// CONCATENATED MODULE: ./packages/jam/state/disputes.ts
 
 
 
-const sortedSetCodec = () => readonlyArray(descriptors_codec.sequenceVarLen(descriptors_codec.bytes(hash_HASH_SIZE))).convert((input) => input.array, (output) => {
+const sortedSetCodec = () => readonlyArray(sequenceVarLen(bytes(hash_HASH_SIZE))).convert((input) => input.array, (output) => {
     const typed = output.map((x) => x.asOpaque());
     return SortedSet.fromSortedArray(hashComparator, typed);
 });
@@ -12227,7 +12227,7 @@ class DisputesRecords {
     badSet;
     wonkySet;
     punishSet;
-    static Codec = descriptors_codec.Class(DisputesRecords, {
+    static Codec = Class(DisputesRecords, {
         goodSet: workReportsSortedSetCodec,
         badSet: workReportsSortedSetCodec,
         wonkySet: workReportsSortedSetCodec,
@@ -12300,10 +12300,10 @@ class BlockState extends WithDebug {
     accumulationResult;
     postStateRoot;
     reported;
-    static Codec = descriptors_codec.Class(BlockState, {
-        headerHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        accumulationResult: descriptors_codec.bytes(hash_HASH_SIZE),
-        postStateRoot: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
+    static Codec = Class(BlockState, {
+        headerHash: bytes(hash_HASH_SIZE).asOpaque(),
+        accumulationResult: bytes(hash_HASH_SIZE),
+        postStateRoot: bytes(hash_HASH_SIZE).asOpaque(),
         reported: codecHashDictionary(WorkPackageInfo.Codec, (x) => x.workPackageHash),
     });
     static create({ headerHash, accumulationResult, postStateRoot, reported }) {
@@ -12333,14 +12333,14 @@ class BlockState extends WithDebug {
 class RecentBlocks extends WithDebug {
     blocks;
     accumulationLog;
-    static Codec = descriptors_codec.Class(RecentBlocks, {
+    static Codec = Class(RecentBlocks, {
         blocks: codecKnownSizeArray(BlockState.Codec, {
             minLength: 0,
             maxLength: MAX_RECENT_HISTORY,
             typicalLength: MAX_RECENT_HISTORY,
         }),
-        accumulationLog: descriptors_codec.object({
-            peaks: readonlyArray(descriptors_codec.sequenceVarLen(descriptors_codec.optional(descriptors_codec.bytes(hash_HASH_SIZE)))),
+        accumulationLog: object({
+            peaks: readonlyArray(sequenceVarLen(optional(bytes(hash_HASH_SIZE)))),
         }),
     });
     static empty() {
@@ -12373,7 +12373,7 @@ class RecentBlocks extends WithDebug {
 
 
 
-const recentlyAccumulatedCodec = codecPerEpochBlock(descriptors_codec.sequenceVarLen(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque()).convert((x) => Array.from(x), (x) => HashSet.from(x)));
+const recentlyAccumulatedCodec = codecPerEpochBlock(sequenceVarLen(bytes(hash_HASH_SIZE).asOpaque()).convert((x) => Array.from(x), (x) => HashSet.from(x)));
 
 ;// CONCATENATED MODULE: ./packages/jam/state/validator-data.ts
 
@@ -12396,11 +12396,11 @@ class ValidatorData extends WithDebug {
     ed25519;
     bls;
     metadata;
-    static Codec = descriptors_codec.Class(ValidatorData, {
-        bandersnatch: descriptors_codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque(),
-        ed25519: descriptors_codec.bytes(ED25519_KEY_BYTES).asOpaque(),
-        bls: descriptors_codec.bytes(BLS_KEY_BYTES).asOpaque(),
-        metadata: descriptors_codec.bytes(VALIDATOR_META_BYTES),
+    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 create({ ed25519, bandersnatch, bls, metadata }) {
         return new ValidatorData(bandersnatch, ed25519, bls, metadata);
@@ -12440,13 +12440,13 @@ var SafroleSealingKeysKind;
     SafroleSealingKeysKind[SafroleSealingKeysKind["Tickets"] = 0] = "Tickets";
     SafroleSealingKeysKind[SafroleSealingKeysKind["Keys"] = 1] = "Keys";
 })(SafroleSealingKeysKind || (SafroleSealingKeysKind = {}));
-const codecBandersnatchKey = descriptors_codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque();
+const codecBandersnatchKey = bytes(BANDERSNATCH_KEY_BYTES).asOpaque();
 class SafroleSealingKeysData extends WithDebug {
     kind;
     keys;
     tickets;
     static Codec = codecWithContext((context) => {
-        return descriptors_codec.custom({
+        return custom({
             name: "SafroleSealingKeys",
             sizeHint: { bytes: 1 + hash_HASH_SIZE * context.epochLength, isExact: false },
         }, (e, x) => {
@@ -12500,11 +12500,11 @@ class safrole_data_SafroleData {
     epochRoot;
     sealingKeySeries;
     ticketsAccumulator;
-    static Codec = descriptors_codec.Class(safrole_data_SafroleData, {
+    static Codec = Class(safrole_data_SafroleData, {
         nextValidatorData: codecPerValidator(ValidatorData.Codec),
-        epochRoot: descriptors_codec.bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
+        epochRoot: bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
         sealingKeySeries: SafroleSealingKeysData.Codec,
-        ticketsAccumulator: readonlyArray(descriptors_codec.sequenceVarLen(Ticket.Codec)).convert(seeThrough, sized_array_asKnownSize),
+        ticketsAccumulator: readonlyArray(sequenceVarLen(Ticket.Codec)).convert(seeThrough, sized_array_asKnownSize),
     });
     static create({ nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator }) {
         return new safrole_data_SafroleData(nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator);
@@ -12589,17 +12589,17 @@ class ServiceAccountInfo extends WithDebug {
     created;
     lastAccumulation;
     parentService;
-    static Codec = descriptors_codec.Class(ServiceAccountInfo, {
-        codeHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        balance: descriptors_codec.u64,
-        accumulateMinGas: descriptors_codec.u64.convert((x) => x, tryAsServiceGas),
-        onTransferMinGas: descriptors_codec.u64.convert((x) => x, tryAsServiceGas),
-        storageUtilisationBytes: descriptors_codec.u64,
-        gratisStorage: descriptors_codec.u64,
-        storageUtilisationCount: descriptors_codec.u32,
-        created: descriptors_codec.u32.convert((x) => x, common_tryAsTimeSlot),
-        lastAccumulation: descriptors_codec.u32.convert((x) => x, common_tryAsTimeSlot),
-        parentService: descriptors_codec.u32.convert((x) => x, tryAsServiceId),
+    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 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);
@@ -12655,9 +12655,9 @@ class ServiceAccountInfo extends WithDebug {
 class PreimageItem extends WithDebug {
     hash;
     blob;
-    static Codec = descriptors_codec.Class(PreimageItem, {
-        hash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        blob: descriptors_codec.blob,
+    static Codec = Class(PreimageItem, {
+        hash: bytes(hash_HASH_SIZE).asOpaque(),
+        blob: blob,
     });
     static create({ hash, blob }) {
         return new PreimageItem(hash, blob);
@@ -12671,9 +12671,9 @@ class PreimageItem extends WithDebug {
 class StorageItem extends WithDebug {
     key;
     value;
-    static Codec = descriptors_codec.Class(StorageItem, {
-        key: descriptors_codec.blob.convert((i) => i, (o) => opaque_asOpaqueType(o)),
-        value: descriptors_codec.blob,
+    static Codec = Class(StorageItem, {
+        key: blob.convert((i) => i, (o) => opaque_asOpaqueType(o)),
+        value: blob,
     });
     static create({ key, value }) {
         return new StorageItem(key, value);
@@ -12723,8 +12723,8 @@ class LookupHistoryItem {
 
 
 const codecServiceId = Compatibility.isSuite(TestSuite.W3F_DAVXY) || Compatibility.isSuite(TestSuite.JAMDUNA, GpVersion.V0_6_7)
-    ? descriptors_codec.u32.asOpaque()
-    : descriptors_codec.varU32.convert((s) => numbers_tryAsU32(s), (i) => tryAsServiceId(i));
+    ? u32.asOpaque()
+    : varU32.convert((s) => numbers_tryAsU32(s), (i) => tryAsServiceId(i));
 /**
  * Activity Record of a single validator.
  *
@@ -12737,13 +12737,13 @@ class ValidatorStatistics {
     preImagesSize;
     guarantees;
     assurances;
-    static Codec = descriptors_codec.Class(ValidatorStatistics, {
-        blocks: descriptors_codec.u32,
-        tickets: descriptors_codec.u32,
-        preImages: descriptors_codec.u32,
-        preImagesSize: descriptors_codec.u32,
-        guarantees: descriptors_codec.u32,
-        assurances: descriptors_codec.u32,
+    static Codec = Class(ValidatorStatistics, {
+        blocks: u32,
+        tickets: u32,
+        preImages: u32,
+        preImagesSize: u32,
+        guarantees: u32,
+        assurances: u32,
     });
     static create({ blocks, tickets, preImages, preImagesSize, guarantees, assurances, }) {
         return new ValidatorStatistics(blocks, tickets, preImages, preImagesSize, guarantees, assurances);
@@ -12773,9 +12773,9 @@ class ValidatorStatistics {
         return new ValidatorStatistics(zero, zero, zero, zero, zero, zero);
     }
 }
-const codecVarU16 = descriptors_codec.varU32.convert((i) => numbers_tryAsU32(i), (o) => numbers_tryAsU16(o));
+const codecVarU16 = varU32.convert((i) => numbers_tryAsU32(i), (o) => numbers_tryAsU16(o));
 /** Encode/decode unsigned gas. */
-const codecVarGas = descriptors_codec.varU64.convert((g) => numbers_tryAsU64(g), (i) => tryAsServiceGas(i));
+const codecVarGas = varU64.convert((g) => numbers_tryAsU64(g), (i) => tryAsServiceGas(i));
 /**
  * Single core statistics.
  * Updated per block, based on incoming work reports (`w`).
@@ -12793,24 +12793,24 @@ class CoreStatistics {
     bundleSize;
     gasUsed;
     static Codec = Compatibility.isGreaterOrEqual(GpVersion.V0_7_0)
-        ? descriptors_codec.Class(CoreStatistics, {
-            dataAvailabilityLoad: descriptors_codec.varU32,
+        ? Class(CoreStatistics, {
+            dataAvailabilityLoad: varU32,
             popularity: codecVarU16,
             imports: codecVarU16,
             extrinsicCount: codecVarU16,
-            extrinsicSize: descriptors_codec.varU32,
+            extrinsicSize: varU32,
             exports: codecVarU16,
-            bundleSize: descriptors_codec.varU32,
+            bundleSize: varU32,
             gasUsed: codecVarGas,
         })
-        : descriptors_codec.Class(CoreStatistics, {
-            dataAvailabilityLoad: descriptors_codec.varU32,
+        : Class(CoreStatistics, {
+            dataAvailabilityLoad: varU32,
             popularity: codecVarU16,
             imports: codecVarU16,
             exports: codecVarU16,
-            extrinsicSize: descriptors_codec.varU32,
+            extrinsicSize: varU32,
             extrinsicCount: codecVarU16,
-            bundleSize: descriptors_codec.varU32,
+            bundleSize: varU32,
             gasUsed: codecVarGas,
         });
     static create(v) {
@@ -12869,45 +12869,45 @@ class ServiceStatistics {
     onTransfersCount;
     onTransfersGasUsed;
     static Codec = Compatibility.selectIfGreaterOrEqual({
-        fallback: descriptors_codec.Class(ServiceStatistics, {
+        fallback: Class(ServiceStatistics, {
             providedCount: codecVarU16,
-            providedSize: descriptors_codec.varU32,
-            refinementCount: descriptors_codec.varU32,
+            providedSize: varU32,
+            refinementCount: varU32,
             refinementGasUsed: codecVarGas,
             imports: codecVarU16,
             exports: codecVarU16,
-            extrinsicSize: descriptors_codec.varU32,
+            extrinsicSize: varU32,
             extrinsicCount: codecVarU16,
-            accumulateCount: descriptors_codec.varU32,
+            accumulateCount: varU32,
             accumulateGasUsed: codecVarGas,
-            onTransfersCount: descriptors_codec.varU32,
+            onTransfersCount: varU32,
             onTransfersGasUsed: codecVarGas,
         }),
         versions: {
-            [GpVersion.V0_7_0]: descriptors_codec.Class(ServiceStatistics, {
+            [GpVersion.V0_7_0]: Class(ServiceStatistics, {
                 providedCount: codecVarU16,
-                providedSize: descriptors_codec.varU32,
-                refinementCount: descriptors_codec.varU32,
+                providedSize: varU32,
+                refinementCount: varU32,
                 refinementGasUsed: codecVarGas,
                 imports: codecVarU16,
                 extrinsicCount: codecVarU16,
-                extrinsicSize: descriptors_codec.varU32,
+                extrinsicSize: varU32,
                 exports: codecVarU16,
-                accumulateCount: descriptors_codec.varU32,
+                accumulateCount: varU32,
                 accumulateGasUsed: codecVarGas,
-                onTransfersCount: descriptors_codec.varU32,
+                onTransfersCount: varU32,
                 onTransfersGasUsed: codecVarGas,
             }),
-            [GpVersion.V0_7_1]: descriptors_codec.Class(ServiceStatistics, {
+            [GpVersion.V0_7_1]: Class(ServiceStatistics, {
                 providedCount: codecVarU16,
-                providedSize: descriptors_codec.varU32,
-                refinementCount: descriptors_codec.varU32,
+                providedSize: varU32,
+                refinementCount: varU32,
                 refinementGasUsed: codecVarGas,
                 imports: codecVarU16,
                 extrinsicCount: codecVarU16,
-                extrinsicSize: descriptors_codec.varU32,
+                extrinsicSize: varU32,
                 exports: codecVarU16,
-                accumulateCount: descriptors_codec.varU32,
+                accumulateCount: varU32,
                 accumulateGasUsed: codecVarGas,
                 onTransfersCount: ignoreValueWithDefault(numbers_tryAsU32(0)),
                 onTransfersGasUsed: ignoreValueWithDefault(tryAsServiceGas(0)),
@@ -12968,11 +12968,11 @@ class StatisticsData {
     previous;
     cores;
     services;
-    static Codec = descriptors_codec.Class(StatisticsData, {
+    static Codec = Class(StatisticsData, {
         current: codecPerValidator(ValidatorStatistics.Codec),
         previous: codecPerValidator(ValidatorStatistics.Codec),
         cores: codecPerCore(CoreStatistics.Codec),
-        services: descriptors_codec.dictionary(codecServiceId, ServiceStatistics.Codec, {
+        services: dictionary(codecServiceId, ServiceStatistics.Codec, {
             sortKeys: (a, b) => a - b,
         }),
     });
@@ -13071,14 +13071,14 @@ class PrivilegedServices {
     assigners;
     autoAccumulateServices;
     /** https://graypaper.fluffylabs.dev/#/ab2cdbd/3bbd023bcb02?v=0.7.2 */
-    static Codec = descriptors_codec.Class(PrivilegedServices, {
-        manager: descriptors_codec.u32.asOpaque(),
-        assigners: codecPerCore(descriptors_codec.u32.asOpaque()),
-        delegator: descriptors_codec.u32.asOpaque(),
+    static Codec = Class(PrivilegedServices, {
+        manager: u32.asOpaque(),
+        assigners: codecPerCore(u32.asOpaque()),
+        delegator: u32.asOpaque(),
         registrar: Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
-            ? descriptors_codec.u32.asOpaque()
+            ? u32.asOpaque()
             : ignoreValueWithDefault(tryAsServiceId(2 ** 32 - 1)),
-        autoAccumulateServices: descriptors_codec.dictionary(descriptors_codec.u32.asOpaque(), descriptors_codec.u64.asOpaque(), {
+        autoAccumulateServices: dictionary(u32.asOpaque(), u64.asOpaque(), {
             sortKeys: (a, b) => a - b,
         }),
     });
@@ -13751,15 +13751,15 @@ class InMemoryState extends WithDebug {
         });
     }
 }
-const serviceEntriesCodec = descriptors_codec.object({
-    storageKeys: descriptors_codec.sequenceVarLen(descriptors_codec.blob.convert((i) => i, (o) => opaque_asOpaqueType(o))),
-    preimages: descriptors_codec.sequenceVarLen(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque()),
-    lookupHistory: descriptors_codec.sequenceVarLen(descriptors_codec.object({
-        hash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        length: descriptors_codec.u32,
+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 serviceDataCodec = descriptors_codec.dictionary(descriptors_codec.u32.asOpaque(), serviceEntriesCodec, {
+const serviceDataCodec = dictionary(u32.asOpaque(), serviceEntriesCodec, {
     sortKeys: (a, b) => a - b,
 });
 
@@ -14498,7 +14498,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(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(), ENTROPY_ENTRIES),
+        Codec: codecFixedSizeArray(bytes(hash_HASH_SIZE).asOpaque(), ENTROPY_ENTRIES),
         extract: (s) => s.entropy,
     };
     /** C(7): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b00023b0002?v=0.6.7 */
@@ -14528,7 +14528,7 @@ var serialize_serialize;
     /** C(11): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b3e023b3e02?v=0.6.7 */
     serialize.timeslot = {
         key: stateKeys.index(StateKeyIdx.Tau),
-        Codec: descriptors_codec.u32.asOpaque(),
+        Codec: u32.asOpaque(),
         extract: (s) => s.timeslot,
     };
     /** C(12): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b4c023b4c02?v=0.6.7 */
@@ -14558,7 +14558,7 @@ var serialize_serialize;
     /** C(16): https://graypaper.fluffylabs.dev/#/38c4e62/3b46033b4603?v=0.7.0 */
     serialize.accumulationOutputLog = {
         key: stateKeys.index(StateKeyIdx.Theta),
-        Codec: descriptors_codec.sequenceVarLen(AccumulationOutput.Codec).convert((i) => i.array, (o) => SortedArray.fromSortedArray(accumulationOutputComparator, o)),
+        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 */
@@ -14581,7 +14581,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(descriptors_codec.sequenceVarLen(descriptors_codec.u32)),
+        Codec: readonlyArray(sequenceVarLen(u32)),
     });
 })(serialize_serialize || (serialize_serialize = {}));
 /**
@@ -15718,7 +15718,7 @@ function getSafroleData(nextValidatorData, epochRoot, sealingKeySeries, ticketsA
 
 const TYPICAL_STATE_ITEMS = 50;
 const TYPICAL_STATE_ITEM_LEN = 50;
-const stateEntriesSequenceCodec = descriptors_codec.sequenceVarLen(descriptors_codec.pair(descriptors_codec.bytes(TRUNCATED_HASH_SIZE), descriptors_codec.blob));
+const stateEntriesSequenceCodec = sequenceVarLen(pair(bytes(TRUNCATED_HASH_SIZE), blob));
 /**
  * Full, in-memory state represented as serialized entries dictionary.
  *
@@ -15726,7 +15726,7 @@ const stateEntriesSequenceCodec = descriptors_codec.sequenceVarLen(descriptors_c
  */
 class state_entries_StateEntries {
     entries;
-    static Codec = descriptors_codec.custom({
+    static Codec = custom({
         name: "StateEntries",
         sizeHint: {
             isExact: false,
@@ -15949,17 +15949,17 @@ const codecMap = (value, extractKey, { typicalLength = TYPICAL_DICTIONARY_LENGTH
         s.sequenceFixLen(value, len);
     });
 };
-const lookupHistoryItemCodec = descriptors_codec.object({
-    hash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-    length: descriptors_codec.u32,
-    slots: readonlyArray(descriptors_codec.sequenceVarLen(descriptors_codec.u32.asOpaque())).convert(seeThrough, service_tryAsLookupHistorySlots),
+const lookupHistoryItemCodec = object({
+    hash: bytes(hash_HASH_SIZE).asOpaque(),
+    length: u32,
+    slots: readonlyArray(sequenceVarLen(u32.asOpaque()))
+        .convert(seeThrough, service_tryAsLookupHistorySlots),
 }, "LookupHistoryItem", ({ hash, length, slots }) => new LookupHistoryItem(hash, length, slots));
-const lookupHistoryEntryCodec = descriptors_codec.object({
-    key: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-    data: descriptors_codec.sequenceVarLen(lookupHistoryItemCodec),
+const lookupHistoryEntryCodec = object({
+    key: bytes(hash_HASH_SIZE).asOpaque(),
+    data: sequenceVarLen(lookupHistoryItemCodec),
 });
-const lookupHistoryCodec = descriptors_codec
-    .sequenceVarLen(lookupHistoryEntryCodec)
+const lookupHistoryCodec = sequenceVarLen(lookupHistoryEntryCodec)
     .convert((dict) => {
     const entries = [];
     for (const [key, data] of dict) {
@@ -15979,9 +15979,9 @@ const lookupHistoryCodec = descriptors_codec
     return dict;
 });
 class ServiceWithCodec extends InMemoryService {
-    static Codec = descriptors_codec.Class(ServiceWithCodec, {
-        serviceId: descriptors_codec.u32.asOpaque(),
-        data: descriptors_codec.object({
+    static Codec = Class(ServiceWithCodec, {
+        serviceId: u32.asOpaque(),
+        data: object({
             info: ServiceAccountInfo.Codec,
             preimages: codecHashDictionary(PreimageItem.Codec, (x) => x.hash),
             lookupHistory: lookupHistoryCodec,
@@ -15995,7 +15995,7 @@ class ServiceWithCodec extends InMemoryService {
         return new ServiceWithCodec(serviceId, data);
     }
 }
-const inMemoryStateCodec = (spec) => descriptors_codec.Class(class State extends InMemoryState {
+const inMemoryStateCodec = (spec) => Class(class State extends InMemoryState {
     static create(data) {
         return InMemoryState.new(spec, data);
     }
@@ -16009,11 +16009,12 @@ const inMemoryStateCodec = (spec) => descriptors_codec.Class(class State extends
     // gamma_k
     nextValidatorData: codecPerValidator(ValidatorData.Codec),
     // gamma_z
-    epochRoot: descriptors_codec.bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
+    epochRoot: bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
     // gamma_s
     sealingKeySeries: SafroleSealingKeysData.Codec,
     // gamma_a
-    ticketsAccumulator: readonlyArray(descriptors_codec.sequenceVarLen(Ticket.Codec)).convert((x) => x, sized_array_asKnownSize),
+    ticketsAccumulator: readonlyArray(sequenceVarLen(Ticket.Codec))
+        .convert((x) => x, sized_array_asKnownSize),
     // psi
     disputesRecords: serialize_serialize.disputesRecords.Codec,
     // eta
@@ -16039,7 +16040,7 @@ const inMemoryStateCodec = (spec) => descriptors_codec.Class(class State extends
     // theta
     accumulationOutputLog: serialize_serialize.accumulationOutputLog.Codec,
     // delta
-    services: descriptors_codec.dictionary(descriptors_codec.u32.asOpaque(), ServiceWithCodec.Codec, {
+    services: dictionary(u32.asOpaque(), ServiceWithCodec.Codec, {
         sortKeys: (a, b) => a - b,
     }),
 });
@@ -16064,11 +16065,11 @@ class TestState {
         state_root: fromJson.bytes32(),
         keyvals: json.array(StateKeyVal.fromJson),
     };
-    static Codec = descriptors_codec.object({
-        state_root: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        keyvals: descriptors_codec.sequenceVarLen(descriptors_codec.object({
-            key: descriptors_codec.bytes(TRUNCATED_HASH_SIZE),
-            value: descriptors_codec.blob,
+    static Codec = object({
+        state_root: bytes(hash_HASH_SIZE).asOpaque(),
+        keyvals: sequenceVarLen(object({
+            key: bytes(TRUNCATED_HASH_SIZE),
+            value: blob,
         })),
     });
     state_root;
@@ -16079,7 +16080,7 @@ class StateTransitionGenesis {
         header: headerFromJson,
         state: TestState.fromJson,
     };
-    static Codec = descriptors_codec.object({
+    static Codec = object({
         header: header_Header.Codec,
         state: TestState.Codec,
     });
@@ -16092,7 +16093,7 @@ class StateTransition {
         post_state: TestState.fromJson,
         block: blockFromJson(chain_spec_tinyChainSpec),
     };
-    static Codec = descriptors_codec.object({
+    static Codec = object({
         pre_state: TestState.Codec,
         block: Block.Codec,
         post_state: TestState.Codec,
@@ -20150,7 +20151,7 @@ const SUPPORTED_TYPES = [
                 if (option === "as-hash") {
                     return looseType({
                         value: blake2b.hashBytes(encoder_Encoder.encodeObject(header_Header.Codec, header, spec)),
-                        encode: descriptors_codec.bytes(hash_HASH_SIZE),
+                        encode: bytes(hash_HASH_SIZE),
                     });
                 }
                 throw new Error(`Invalid processing option: ${option}`);
@@ -20204,7 +20205,7 @@ const SUPPORTED_TYPES = [
                 if (option === "as-root-hash") {
                     return looseType({
                         value: state_entries_StateEntries.serializeInMemory(spec, blake2b, state).getRootHash(blake2b),
-                        encode: descriptors_codec.bytes(hash_HASH_SIZE),
+                        encode: bytes(hash_HASH_SIZE),
                     });
                 }
                 throw new Error(`Invalid processing option: ${option}`);