@typeberry/jam 0.1.0-b2d0b72 → 0.1.0

package/jam-network/index.js

@@ -25323,18 +25323,30 @@ function isBrowser() {
  * We avoid using `node:assert` to keep compatibility with a browser environment.
  * Note the checks should not have any side effects, since we might decide
  * to remove all of them in a post-processing step.
- *
- * NOTE the function is intended to be used as tagged template string for the performance
- * reasons.
  */
-function debug_check(strings, condition, ...data) {
+function debug_check(condition, message) {
     if (!condition) {
-        // add an empty value so that `data.length === strings.length`
-        data.unshift("");
-        const message = strings.map((v, index) => `${v}${data[index] ?? ""}`);
-        throw new Error(`Assertion failure:${message.join("")}`);
+        throw new Error(`Assertion failure: ${message ?? ""}`);
     }
 }
+function cast(_a, condition) {
+    return condition;
+}
+/**
+ * Yet another function to perform runtime assertions.
+ * This function returns a new type to mark in the code that this value was checked and you don't have to do it again.
+ *
+ * In the post-processing step all usages of this functions should be replaced with simple casting. An example:
+ * const x = checkAndType<number, CheckedNumber>(y);
+ * should be replaced with:
+ * const x = y as CheckedNumber;
+ */
+function ensure(a, condition, message) {
+    if (cast(a, condition)) {
+        return a;
+    }
+    throw new Error(`Assertion failure: ${message ?? ""}`);
+}
 /**
  * The function can be used to make sure that a particular type is `never`
  * at some point in the code.
@@ -25503,7 +25515,7 @@ function result_resultToString(res) {
 const result_Result = {
     /** Create new [`Result`] with `Ok` status. */
     ok: (ok) => {
-        debug_check `${ok !== undefined} 'ok' type cannot be undefined.`;
+        debug_check(ok !== undefined, "`Ok` type cannot be undefined.");
         return {
             isOk: true,
             isError: false,
@@ -25512,7 +25524,7 @@ const result_Result = {
     },
     /** Create new [`Result`] with `Error` status. */
     error: (error, details = "") => {
-        debug_check `${error !== undefined} 'Error' type cannot be undefined.`;
+        debug_check(error !== undefined, "`Error` type cannot be undefined.");
         return {
             isOk: false,
             isError: true,
@@ -25796,10 +25808,7 @@ class bitvec_BitVec {
     constructor(data, bitLength) {
         this.data = data;
         this.bitLength = bitLength;
-        debug_check `
-      ${data.length * 8 >= bitLength}
-      Not enough bytes in the data array. Need ${data.length * 8} has ${bitLength}.
-    `;
+        debug_check(data.length * 8 >= bitLength, `Not enough bytes in the data array. Need ${data.length * 8} has ${bitLength}.`);
         this.byteLength = Math.ceil(bitLength / 8);
     }
     /** Return a raw in-memory representation of this [`BitVec`]. */
@@ -25808,10 +25817,7 @@ class bitvec_BitVec {
     }
     /** Perform OR operation on all bits in place. */
     sumWith(other) {
-        debug_check `
-      ${other.bitLength === this.bitLength}
-      Invalid bit length for sumWith: ${other.bitLength} vs ${this.bitLength}
-    `;
+        debug_check(other.bitLength === this.bitLength, `Invalid bit length for sumWith: ${other.bitLength} vs ${this.bitLength}`);
         const otherRaw = other.raw;
         for (let i = 0; i < this.byteLength; i++) {
             this.data[i] |= otherRaw[i];
@@ -25821,7 +25827,7 @@ class bitvec_BitVec {
      * Set the bit at index `idx` to value `val`.
      */
     setBit(idx, val) {
-        debug_check `${idx >= 0 && idx < this.bitLength} Index out of bounds. Need ${idx} has ${this.bitLength}.`;
+        debug_check(idx < this.bitLength, `Index out of bounds. Need ${idx} has ${this.bitLength}.`);
         const byteIndex = Math.floor(idx / 8);
         const bitIndexInByte = idx % 8;
         const mask = 1 << bitIndexInByte;
@@ -25836,7 +25842,7 @@ class bitvec_BitVec {
      * Return `true` if the bit at index `idx` is set.
      */
     isSet(idx) {
-        debug_check `${idx >= 0 && idx < this.bitLength} Index out of bounds. Need ${idx} has ${this.bitLength}.`;
+        debug_check(idx < this.bitLength, `Index out of bounds. Need ${idx} has ${this.bitLength}.`);
         const byteIndex = Math.floor(idx / 8);
         const bitIndexInByte = idx % 8;
         const mask = 1 << bitIndexInByte;
@@ -26003,7 +26009,7 @@ class bytes_BytesBlob {
     }
     /** Create a new [`BytesBlob`] from an array of bytes. */
     static blobFromNumbers(v) {
-        debug_check `${v.find((x) => (x & 0xff) !== x) === undefined} BytesBlob.blobFromNumbers used with non-byte number array.`;
+        debug_check(v.find((x) => (x & 0xff) !== x) === undefined, "BytesBlob.blobFromNumbers used with non-byte number array.");
         const arr = new Uint8Array(v);
         return new bytes_BytesBlob(arr);
     }
@@ -26047,7 +26053,7 @@ class bytes_Bytes extends bytes_BytesBlob {
     length;
     constructor(raw, len) {
         super(raw);
-        debug_check `${raw.byteLength === len} Given buffer has incorrect size ${raw.byteLength} vs expected ${len}`;
+        debug_check(raw.byteLength === len, `Given buffer has incorrect size ${raw.byteLength} vs expected ${len}`);
         this.length = len;
     }
     /** Create new [`Bytes<X>`] given a backing buffer and it's length. */
@@ -26056,7 +26062,7 @@ class bytes_Bytes extends bytes_BytesBlob {
     }
     /** Create new [`Bytes<X>`] given an array of bytes and it's length. */
     static fromNumbers(v, len) {
-        debug_check `${v.find((x) => (x & 0xff) !== x) === undefined} Bytes.fromNumbers used with non-byte number array.`;
+        debug_check(v.find((x) => (x & 0xff) !== x) === undefined, "Bytes.fromNumbers used with non-byte number array.");
         const x = new Uint8Array(v);
         return new bytes_Bytes(x, len);
     }
@@ -26067,7 +26073,7 @@ class bytes_Bytes extends bytes_BytesBlob {
     // TODO [ToDr] `fill` should have the argments swapped to align with the rest.
     /** Create a [`Bytes<X>`] with all bytes filled with given input number. */
     static fill(len, input) {
-        debug_check `${(input & 0xff) === input} Input has to be a byte.`;
+        debug_check((input & 0xff) === input, "Input has to be a byte.");
         const bytes = bytes_Bytes.zero(len);
         bytes.raw.fill(input, 0, len);
         return bytes;
@@ -26090,7 +26096,7 @@ class bytes_Bytes extends bytes_BytesBlob {
     }
     /** Compare the sequence to another one. */
     isEqualTo(other) {
-        debug_check `${this.length === other.length} Comparing incorrectly typed bytes!`;
+        debug_check(this.length === other.length, "Comparing incorrectly typed bytes!");
         return u8ArraySameLengthEqual(this.raw, other.raw);
     }
     /** Converts current type into some opaque extension. */
@@ -26099,7 +26105,7 @@ class bytes_Bytes extends bytes_BytesBlob {
     }
 }
 function byteFromString(s) {
-    debug_check `${s.length === 2} Two-character string expected`;
+    debug_check(s.length === 2, "Two-character string expected");
     const a = numberFromCharCode(s.charCodeAt(0));
     const b = numberFromCharCode(s.charCodeAt(1));
     return (a << 4) | b;
@@ -26153,53 +26159,42 @@ const bytesBlobComparator = (a, b) => a.compare(b);
 
 ;// CONCATENATED MODULE: ./packages/core/numbers/index.ts
 
-const asTypedNumber = (v) => v;
+const asWithBytesRepresentation = (v) => v;
 const MAX_VALUE_U8 = 0xff;
 const MAX_VALUE_U16 = 0xffff;
 const MAX_VALUE_U32 = 0xffff_ffff;
 const MAX_VALUE_U64 = 0xffffffffffffffffn;
 /** Attempt to cast an input number into U8. */
-const tryAsU8 = (v) => {
-    debug_check `${isU8(v)} input must have one-byte representation, got ${v}`;
-    return asTypedNumber(v);
-};
+const tryAsU8 = (v) => ensure(v, isU8(v), `input must have one-byte representation, got ${v}`);
 /** Check if given number is a valid U8 number. */
 const isU8 = (v) => (v & MAX_VALUE_U8) === v;
 /** Attempt to cast an input number into U16. */
-const numbers_tryAsU16 = (v) => {
-    debug_check `${isU16(v)} input must have two-byte representation, got ${v}`;
-    return asTypedNumber(v);
-};
+const numbers_tryAsU16 = (v) => ensure(v, isU16(v), `input must have two-byte representation, got ${v}`);
 /** Check if given number is a valid U16 number. */
 const isU16 = (v) => (v & MAX_VALUE_U16) === v;
 /** Attempt to cast an input number into U32. */
-const numbers_tryAsU32 = (v) => {
-    debug_check `${isU32(v)} input must have four-byte representation, got ${v}`;
-    return asTypedNumber(v);
-};
+const numbers_tryAsU32 = (v) => ensure(v, isU32(v), `input must have four-byte representation, got ${v}`);
 /** Check if given number is a valid U32 number. */
 const isU32 = (v) => (v & MAX_VALUE_U32) >>> 0 === v;
 /** Attempt to cast an input number into U64. */
 const tryAsU64 = (x) => {
     const v = BigInt(x);
-    debug_check `${isU64(v)} input must have eight-byte representation, got ${x}`;
-    return asTypedNumber(v);
+    return ensure(v, isU64(v), `input must have eight-byte representation, got ${x}`);
 };
 /** Check if given number is a valid U64 number. */
 const isU64 = (v) => (v & MAX_VALUE_U64) === v;
 /** Collate two U32 parts into one U64. */
 const u64FromParts = ({ lower, upper }) => {
     const val = (BigInt(upper) << 32n) + BigInt(lower);
-    return asTypedNumber(val);
+    return asWithBytesRepresentation(val);
 };
 /** Split U64 into lower & upper parts. */
 const u64IntoParts = (v) => {
-    // Number(...) safe: both parts are <= 0xffffffff
-    const lower = Number(v & (2n ** 32n - 1n));
-    const upper = Number(v >> 32n);
+    const lower = v & (2n ** 32n - 1n);
+    const upper = v >> 32n;
     return {
-        lower: asTypedNumber(lower),
-        upper: asTypedNumber(upper),
+        lower: asWithBytesRepresentation(Number(lower)),
+        upper: asWithBytesRepresentation(Number(upper)),
     };
 };
 /**
@@ -26239,8 +26234,8 @@ function numbers_u32AsLeBytes(value) {
  * Interpret 4-byte `Uint8Array` as U32 written as little endian.
  */
 function leBytesAsU32(uint8Array) {
-    check `${uint8Array.length === 4} Input must be a Uint8Array of length 4`;
-    return asTypedNumber(uint8Array[0] | (uint8Array[1] << 8) | (uint8Array[2] << 16) | (uint8Array[3] << 24));
+    check(uint8Array.length === 4, "Input must be a Uint8Array of length 4");
+    return asWithBytesRepresentation(uint8Array[0] | (uint8Array[1] << 8) | (uint8Array[2] << 16) | (uint8Array[3] << 24));
 }
 /** Get the smallest value between U64 a and values given as input parameters. */
 const minU64 = (a, ...values) => values.reduce((min, value) => (value > min ? min : value), a);
@@ -26531,7 +26526,7 @@ class decoder_Decoder {
             this.skip(newOffset - this.offset);
         }
         else {
-            debug_check `${newOffset >= 0} The offset has to be positive`;
+            debug_check(newOffset >= 0, "The offset has to be positive");
             this.offset = newOffset;
         }
     }
@@ -26559,7 +26554,7 @@ class decoder_Decoder {
         return num;
     }
     ensureHasBytes(bytes) {
-        debug_check `${bytes >= 0} Negative number of bytes given.`;
+        debug_check(bytes >= 0, "Negative number of bytes given.");
         if (this.offset + bytes > this.source.length) {
             throw new Error(`Attempting to decode more data than there is left. Need ${bytes}, left: ${this.source.length - this.offset}.`);
         }
@@ -26567,7 +26562,7 @@ class decoder_Decoder {
 }
 const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];
 function decodeVariableLengthExtraBytes(firstByte) {
-    debug_check `${firstByte >= 0 && firstByte < 256} Incorrect byte value: ${firstByte}`;
+    debug_check(firstByte >= 0 && firstByte < 256, `Incorrect byte value: ${firstByte}`);
     for (let i = 0; i < MASKS.length; i++) {
         if (firstByte >= MASKS[i]) {
             return 8 - i;
@@ -26722,7 +26717,7 @@ class descriptor_Descriptor {
 
 
 function tryAsExactBytes(a) {
-    check `${a.isExact} The value is not exact size estimation!`;
+    check(a.isExact, "The value is not exact size estimation!");
     return a.bytes;
 }
 function addSizeHints(a, b) {
@@ -26829,8 +26824,8 @@ class encoder_Encoder {
         // we still allow positive numbers from `[maxNum / 2, maxNum)`.
         // So it does not matter if the argument is a negative value,
         // OR if someone just gave us two-complement already.
-        debug_check `${num < maxNum} Only for numbers up to 2**64 - 1`;
-        debug_check `${-num <= maxNum / 2n} Only for numbers down to -2**63`;
+        debug_check(num < maxNum, "Only for numbers up to 2**64 - 1");
+        debug_check(-num <= maxNum / 2n, "Only for numbers down to -2**63");
         this.ensureBigEnough(8);
         this.dataView.setBigInt64(this.offset, num, true);
         this.offset += 8;
@@ -26894,8 +26889,8 @@ class encoder_Encoder {
         // we still allow positive numbers from `[maxNum / 2, maxNum)`.
         // So it does not matter if the argument is a negative value,
         // OR if someone just gave us two-complement already.
-        debug_check `${num < maxNum} Only for numbers up to 2**${BITS * bytesToEncode} - 1`;
-        debug_check `${-num <= maxNum / 2} Only for numbers down to -2**${BITS * bytesToEncode - 1}`;
+        debug_check(num < maxNum, `Only for numbers up to 2**${BITS * bytesToEncode} - 1`);
+        debug_check(-num <= maxNum / 2, `Only for numbers down to -2**${BITS * bytesToEncode - 1}`);
         this.ensureBigEnough(bytesToEncode);
     }
     /**
@@ -26906,8 +26901,8 @@ class encoder_Encoder {
      * https://graypaper.fluffylabs.dev/#/579bd12/365202365202
      */
     varU32(num) {
-        debug_check `${num >= 0} Only for natural numbers.`;
-        debug_check `${num < 2 ** 32} Only for numbers up to 2**32`;
+        debug_check(num >= 0, "Only for natural numbers.");
+        debug_check(num < 2 ** 32, "Only for numbers up to 2**32");
         this.varU64(BigInt(num));
     }
     /**
@@ -27058,7 +27053,7 @@ class encoder_Encoder {
      * https://graypaper.fluffylabs.dev/#/579bd12/374400374400
      */
     sequenceVarLen(encode, elements) {
-        debug_check `${elements.length <= 2 ** 32} Wow, that's a nice long sequence you've got here.`;
+        debug_check(elements.length <= 2 ** 32, "Wow, that's a nice long sequence you've got here.");
         this.varU32(numbers_tryAsU32(elements.length));
         this.sequenceFixLen(encode, elements);
     }
@@ -27079,7 +27074,7 @@ class encoder_Encoder {
      * anyway, so if we really should throw we will.
      */
     ensureBigEnough(length, options = { silent: false }) {
-        debug_check `${length >= 0} Negative length given`;
+        debug_check(length >= 0, "Negative length given");
         const newLength = this.offset + length;
         if (newLength > MAX_LENGTH) {
             if (options.silent) {
@@ -27215,12 +27210,10 @@ class ObjectView {
     decodeUpTo(field) {
         const index = this.descriptorsKeys.indexOf(field);
         const lastField = this.descriptorsKeys[this.lastDecodedFieldIdx];
-        debug_check `
-      ${this.lastDecodedFieldIdx < index}
-      Unjustified call to 'decodeUpTo' -
+        debug_check(this.lastDecodedFieldIdx < index, `Unjustified call to 'decodeUpTo' -
        the index ($Blobindex}, ${String(field)})
        is already decoded (${this.lastDecodedFieldIdx}, ${String(lastField)}).
-    `;
+      `);
         let lastItem = this.cache.get(lastField);
         const skipper = new Skipper(this.decoder);
         // now skip all of the fields and further populate the cache.
@@ -27236,10 +27229,8 @@ class ObjectView {
             this.cache.set(field, lastItem);
             this.lastDecodedFieldIdx = i;
         }
-        if (lastItem === undefined) {
-            throw new Error("Last item must be set, since the loop turns at least once.");
-        }
-        return lastItem;
+        const last = ensure(lastItem, lastItem !== undefined, "Last item must be set, since the loop turns at least once.");
+        return last;
     }
 }
 /**
@@ -27272,10 +27263,8 @@ class SequenceView {
     *[Symbol.iterator]() {
         for (let i = 0; i < this.length; i++) {
             const val = this.get(i);
-            if (val === undefined) {
-                throw new Error("We are within 0..this.length so all items are defined.");
-            }
-            yield val;
+            const v = ensure(val, val !== undefined, "We are within 0..this.length so all items are defined.");
+            yield v;
         }
     }
     /** Create an array of all views mapped to some particular value. */
@@ -27318,10 +27307,7 @@ class SequenceView {
         return bytes_BytesBlob.blobFrom(this.decoder.source.subarray(this.initialDecoderOffset, this.decoder.bytesRead()));
     }
     decodeUpTo(index) {
-        debug_check `
-      ${this.lastDecodedIdx < index}
-      Unjustified call to 'decodeUpTo' - the index (${index}) is already decoded (${this.lastDecodedIdx}).
-    `;
+        debug_check(this.lastDecodedIdx < index, `Unjustified call to 'decodeUpTo' - the index (${index}) is already decoded (${this.lastDecodedIdx}).`);
         let lastItem = this.cache.get(this.lastDecodedIdx);
         const skipper = new Skipper(this.decoder);
         // now skip all of the fields and further populate the cache.
@@ -27336,10 +27322,8 @@ class SequenceView {
             this.cache.set(i, lastItem);
             this.lastDecodedIdx = i;
         }
-        if (lastItem === undefined) {
-            throw new Error("Last item must be set, since the loop turns at least once.");
-        }
-        return lastItem;
+        const last = ensure(lastItem, lastItem !== undefined, "Last item must be set, since the loop turns at least once.");
+        return last;
     }
 }
 
@@ -27372,10 +27356,7 @@ const TYPICAL_DICTIONARY_LENGTH = 32;
  */
 function readonlyArray(desc) {
     return desc.convert((x) => {
-        debug_check `
-        ${Array.isArray(x)}
-        Non-arrays are not supported as 'readonly': got ${typeof x}, ${x}
-      `;
+        debug_check(Array.isArray(x), `Non-arrays are not supported as 'readonly': got ${typeof x}, ${x}`);
         // NOTE [ToDr] This assumption is incorrect in general, but it's documented
         // in the general note. We avoid `.slice()` the array for performance reasons.
         return x;
@@ -28330,17 +28311,10 @@ async function initAll() {
 	await init.ed25519();
 	await init.reedSolomon();
 }
-function initOnce(doInit) {
-	let ready = null;
-	return async () => {
-		if (ready === null) ready = doInit();
-		return await ready;
-	};
-}
 const init = {
-	bandersnatch: initOnce(async () => await bandersnatch_default({ module_or_path: await bandersnatch_bg_default() })),
-	ed25519: initOnce(async () => await ed25519_wasm_default({ module_or_path: await ed25519_wasm_bg_default() })),
-	reedSolomon: initOnce(async () => await reed_solomon_wasm_default({ module_or_path: await reed_solomon_wasm_bg_default() }))
+	bandersnatch: async () => await bandersnatch_default({ module_or_path: await bandersnatch_bg_default() }),
+	ed25519: async () => await ed25519_wasm_default({ module_or_path: await ed25519_wasm_bg_default() }),
+	reedSolomon: async () => await reed_solomon_wasm_default({ module_or_path: await reed_solomon_wasm_bg_default() })
 };
 
 //#endregion
@@ -28362,7 +28336,7 @@ const BLS_KEY_BYTES = 144;
 /** Derive a Bandersnatch public key from a seed. */
 function bandersnatch_publicKey(seed) {
     const key = bandersnatch.derive_public_key(seed);
-    check `${key[0] === 0} Invalid Bandersnatch public key derived from seed`;
+    check(key[0] === 0, "Invalid Bandersnatch public key derived from seed");
     return Bytes.fromBlob(key.subarray(1), BANDERSNATCH_KEY_BYTES).asOpaque();
 }
 
@@ -28850,7 +28824,7 @@ async function ed25519_verify(input) {
         data.set(signature.raw, offset);
         offset += ED25519_SIGNATURE_BYTES;
         const messageLength = message.length;
-        debug_check `${messageLength < 256} Message needs to be shorter than 256 bytes. Got: ${messageLength}`;
+        debug_check(messageLength < 256, `Message needs to be shorter than 256 bytes. Got: ${messageLength}`);
         data[offset] = messageLength;
         offset += 1;
         data.set(message.raw, offset);
@@ -28879,7 +28853,6 @@ async function verifyBatch(input) {
 
 ;// CONCATENATED MODULE: ./packages/core/hash/hash.ts
 
-
 /**
  * Size of the output of the hash functions.
  *
@@ -28889,7 +28862,6 @@ async function verifyBatch(input) {
 const hash_HASH_SIZE = 32;
 /** A hash without last byte (useful for trie representation). */
 const TRUNCATED_HASH_SIZE = 31;
-const ZERO_HASH = bytes_Bytes.zero(hash_HASH_SIZE);
 /**
  * Container for some object with a hash that is related to this object.
  *
@@ -28934,7 +28906,7 @@ class PageAllocator {
     // TODO [ToDr] Benchmark the performance!
     constructor(hashesPerPage) {
         this.hashesPerPage = hashesPerPage;
-        check `${hashesPerPage > 0 && hashesPerPage >>> 0 === hashesPerPage} Expected a non-zero integer.`;
+        check(hashesPerPage > 0 && hashesPerPage >>> 0 === hashesPerPage, "Expected a non-zero integer.");
         this.resetPage();
     }
     resetPage() {
@@ -29231,8 +29203,8 @@ class MultiMap {
      * if needed.
      */
     constructor(keysLength, keyMappers) {
-        check `${keysLength > 0} Keys cannot be empty.`;
-        check `${keyMappers === undefined || keyMappers.length === keysLength} Incorrect number of key mappers given!`;
+        check(keysLength > 0, "Keys cannot be empty.");
+        check(keyMappers === undefined || keyMappers.length === keysLength, "Incorrect number of key mappers given!");
         this.data = new Map();
         this.keyMappers = keyMappers === undefined ? Array(keysLength).fill(null) : keyMappers;
     }
@@ -29333,7 +29305,7 @@ class FixedSizeArray extends Array {
         this.fixedLength = this.length;
     }
     static new(data, len) {
-        debug_check `${data.length === len} Expected an array of size: ${len}, got: ${data.length}`;
+        debug_check(data.length === len, `Expected an array of size: ${len}, got: ${data.length}`);
         const arr = new FixedSizeArray(len);
         for (let i = 0; i < len; i++) {
             arr[i] = data[i];
@@ -29467,7 +29439,7 @@ class SortedArray {
     }
     /** Create a new SortedSet from two sorted collections. */
     static fromTwoSortedCollections(first, second) {
-        debug_check `${first.comparator === second.comparator} Cannot merge arrays if they do not use the same comparator`;
+        debug_check(first.comparator === second.comparator, "Cannot merge arrays if they do not use the same comparator");
         const comparator = first.comparator;
         const arr1 = first.array;
         const arr1Length = arr1.length;
@@ -29587,7 +29559,7 @@ class sorted_set_SortedSet extends SortedArray {
     }
     /** Create a new SortedSet from two sorted collections. */
     static fromTwoSortedCollections(first, second) {
-        debug_check `${first.comparator === second.comparator} Cannot merge arrays if they do not use the same comparator`;
+        debug_check(first.comparator === second.comparator, "Cannot merge arrays if they do not use the same comparator");
         const comparator = first.comparator;
         if (first.length === 0) {
             return sorted_set_SortedSet.fromSortedArray(comparator, second.array);
@@ -30608,10 +30580,7 @@ const tryAsCoreIndex = (v) => opaque_asOpaqueType(numbers_tryAsU16(v));
 /** Attempt to convert a number into `Epoch`. */
 const tryAsEpoch = (v) => asOpaqueType(tryAsU32(v));
 function tryAsPerValidator(array, spec) {
-    debug_check `
-    ${array.length === spec.validatorsCount}
-    Invalid per-validator array length. Expected ${spec.validatorsCount}, got: ${array.length}
-  `;
+    debug_check(array.length === spec.validatorsCount, `Invalid per-validator array length. Expected ${spec.validatorsCount}, got: ${array.length}`);
     return sized_array_asKnownSize(array);
 }
 const codecPerValidator = (val) => codecWithContext((context) => {
@@ -30620,10 +30589,7 @@ const codecPerValidator = (val) => codecWithContext((context) => {
     });
 });
 function tryAsPerEpochBlock(array, spec) {
-    debug_check `
-    ${array.length === spec.epochLength}
-    Invalid per-epoch-block array length. Expected ${spec.epochLength}, got: ${array.length}
-  `;
+    debug_check(array.length === spec.epochLength, `Invalid per-epoch-block array length. Expected ${spec.epochLength}, got: ${array.length}`);
     return sized_array_asKnownSize(array);
 }
 const codecPerEpochBlock = (val) => codecWithContext((context) => {
@@ -30894,14 +30860,9 @@ class WorkItem extends WithDebug {
 
 
 
-
 /** Verify the value is within the `WorkItemsCount` bounds. */
 function tryAsWorkItemsCount(len) {
-    debug_check `
-    ${len >= MIN_NUMBER_OF_WORK_ITEMS && len <= work_package_MAX_NUMBER_OF_WORK_ITEMS}
-    WorkItemsCount: Expected '${MIN_NUMBER_OF_WORK_ITEMS} <= count <= ${work_package_MAX_NUMBER_OF_WORK_ITEMS}' got ${len}
-  `;
-    return tryAsU8(len);
+    return ensure(len, len >= MIN_NUMBER_OF_WORK_ITEMS && len <= work_package_MAX_NUMBER_OF_WORK_ITEMS, `WorkItemsCount: Expected '${MIN_NUMBER_OF_WORK_ITEMS} <= count <= ${work_package_MAX_NUMBER_OF_WORK_ITEMS}' got ${len}`);
 }
 /** Minimal number of work items in the work package or results in work report. */
 const MIN_NUMBER_OF_WORK_ITEMS = 1;
@@ -32874,10 +32835,7 @@ class AvailabilityAssignment extends WithDebug {
 
 /** Check if given array has correct length before casting to the opaque type. */
 function tryAsPerCore(array, spec) {
-    debug_check `
-    ${array.length === spec.coresCount}
-    Invalid per-core array length. Expected ${spec.coresCount}, got: ${array.length}
-  `;
+    debug_check(array.length === spec.coresCount, `Invalid per-core array length. Expected ${spec.coresCount}, got: ${array.length}`);
     return opaque_asOpaqueType(array);
 }
 const codecPerCore = (val) => codecWithContext((context) => {
@@ -34128,7 +34086,7 @@ class InMemoryState extends WithDebug {
     }
     removeServices(servicesRemoved) {
         for (const serviceId of servicesRemoved ?? []) {
-            debug_check `${this.services.has(serviceId)} Attempting to remove non-existing service: ${serviceId}`;
+            debug_check(this.services.has(serviceId), `Attempting to remove non-existing service: ${serviceId}`);
             this.services.delete(serviceId);
         }
     }
@@ -34145,10 +34103,7 @@ class InMemoryState extends WithDebug {
             }
             else if (kind === state_update_UpdateStorageKind.Remove) {
                 const { key } = action;
-                debug_check `
-          ${service.data.storage.has(key.toString())}
-          Attempting to remove non-existing storage item at ${serviceId}: ${action.key}
-        `;
+                debug_check(service.data.storage.has(key.toString()), `Attempting to remove non-existing storage item at ${serviceId}: ${action.key}`);
                 service.data.storage.delete(key.toString());
             }
             else {
@@ -34831,12 +34786,12 @@ class nodes_TrieNode {
     }
     /** View this node as a branch node */
     asBranchNode() {
-        debug_check `${this.getNodeType() === nodes_NodeType.Branch} not a branch!`;
+        debug_check(this.getNodeType() === nodes_NodeType.Branch);
         return new BranchNode(this);
     }
     /** View this node as a leaf node */
     asLeafNode() {
-        debug_check `${this.getNodeType() !== nodes_NodeType.Branch} not a leaf!`;
+        debug_check(this.getNodeType() !== nodes_NodeType.Branch);
         return new LeafNode(this);
     }
     toString() {
@@ -35324,7 +35279,7 @@ function createSubtreeForBothLeaves(traversedPath, nodes, leafToReplace, leaf) {
  * Return a single bit from `key` located at `bitIndex`.
  */
 function getBit(key, bitIndex) {
-    debug_check `${bitIndex < TRUNCATED_KEY_BITS} invalid bit index passed ${bitIndex}`;
+    debug_check(bitIndex < TRUNCATED_KEY_BITS);
     const byte = bitIndex >>> 3;
     const bit = bitIndex - (byte << 3);
     const mask = 0b10_00_00_00 >>> bit;
@@ -36331,7 +36286,7 @@ class TypedPort {
      * Send a response given the worker that has previously requested something.
      */
     respond(localState, request, data, transferList) {
-        debug_check `${request.kind === "request"}`;
+        debug_check(request.kind === "request");
         this.postMessage({
             kind: "response",
             id: request.id,
@@ -36362,11 +36317,10 @@ class TypedPort {
             throw new Error(`Invalid message: ${JSON.stringify(msg)}.`);
         }
         switch (msg.kind) {
-            case "response": {
-                debug_check `${this.responseListeners.eventNames().indexOf(reqEvent(msg.id)) !== -1}`;
+            case "response":
+                debug_check(this.responseListeners.eventNames().indexOf(reqEvent(msg.id)) !== -1);
                 this.responseListeners.emit(reqEvent(msg.id), null, msg.data, msg.name, msg.localState, msg);
                 break;
-            }
             case "signal":
                 this.listeners.emit("signal", msg.name, msg.data, msg.localState, msg);
                 break;
@@ -36581,9 +36535,9 @@ class MessageChannelStateMachine {
         const promise = new Promise((resolve, reject) => {
             parentPort.once("message", (value) => {
                 try {
-                    debug_check `${value.kind === "request"} The initial message should be a request with channel.`;
-                    debug_check `${value.name === CHANNEL_MESSAGE}`;
-                    debug_check `${value.data instanceof external_node_worker_threads_namespaceObject.MessagePort}`;
+                    debug_check(value.kind === "request", "The initial message should be a request with channel.");
+                    debug_check(value.name === CHANNEL_MESSAGE);
+                    debug_check(value.data instanceof external_node_worker_threads_namespaceObject.MessagePort);
                     const port = new TypedPort(value.data);
                     port.respond(machine.currentState().stateName, value, Ok);
                     resolve(port);
@@ -36663,7 +36617,7 @@ class StateMachine {
     /** Get state object by name. */
     getState(name) {
         const state = this.allStates.get(name);
-        debug_check `${state !== undefined} Unable to retrieve state object for ${name}.`;
+        debug_check(state !== undefined, `Unable to retrieve state object for ${name}.`);
         return state;
     }
     /** Get the currently active state object. */