npm - @typeberry/jam - Versions diffs - 0.1.1-b537c8b → 0.1.1-e48de40 - Mend

@typeberry/jam 0.1.1-b537c8b → 0.1.1-e48de40

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/block-generator/index.js +132 -94
package/block-generator/index.js.map +1 -1
package/importer/index.js +214 -176
package/importer/index.js.map +1 -1
package/index.js +374 -340
package/index.js.map +1 -1
package/jam-network/index.js +198 -162
package/jam-network/index.js.map +1 -1
package/package.json +4 -2

package/index.js CHANGED Viewed

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 import './sourcemap-register.cjs';import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "module";
 import * as __WEBPACK_EXTERNAL_MODULE_lmdb__ from "lmdb";
 /******/ var __webpack_modules__ = ({
@@ -28434,6 +28435,34 @@ class WithDebug {
     }
 }
+;// 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.
+ *
+ * Example:
+ * $ npm start -w @typeberry/jam
+ *
+ * The above command will run `./bin/jam/index.js`, however we would
+ * still want relative paths to be resolved according to top-level workspace
+ * directory.
+ *
+ * So the caller, passes the absolute workspace path as argument and get's
+ * a function that can properly resolve relative paths.
+ *
+ * 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"
+    ? (workspacePath) => (p) => {
+        if (p.startsWith("/")) {
+            return p;
+        }
+        return `${workspacePath}/${p}`;
+    }
+    : () => (p) => p;
 ;// CONCATENATED MODULE: ./packages/core/utils/opaque.ts
 /**
  * @fileoverview `Opaque<Type, Token>` constructs a unique type which is a subset of Type with a
@@ -28777,6 +28806,7 @@ function isResult(x) {
 ;// CONCATENATED MODULE: ./packages/core/bytes/bitvec.ts
 /**
@@ -35148,6 +35178,23 @@ function parseLevel(lvl) {
 ;// CONCATENATED MODULE: ./packages/core/logger/console.ts
 // biome-ignore-all lint/suspicious/noConsole: logger
+function print(level, levelAndName, strings, data) {
+    if (level < levelAndName[0]) {
+        return;
+    }
+    const lvlText = Level[level].padEnd(5);
+    const val = strings.map((v, idx) => `${v}${data[idx]}`);
+    const msg = `${lvlText} [${levelAndName[1]}] ${val}`;
+    if (level === Level.WARN) {
+        console.warn(msg);
+    }
+    else if (level === Level.ERROR) {
+        console.error(msg);
+    }
+    else {
+        console.info(msg);
+    }
+}
 /** An optimized logger that ignores `TRACE`, `DEBUG` and `LOG` messages.
  *
  * Use the `create` method to instantiate the right instance of a more specialized logger.
@@ -35178,109 +35225,91 @@ class ConsoleTransport {
     constructor(options) {
         this.options = options;
     }
-    insane(_moduleName, _val) {
+    insane(_levelAndName, _strings, _data) {
         /* no-op */
     }
-    trace(_moduleName, _val) {
+    trace(_levelAndName, _strings, _data) {
         /* no-op */
     }
-    log(_moduleName, _val) {
+    log(_levelAndName, _strings, _data) {
         /* no-op */
     }
-    info(_moduleName, _val) {
+    info(_levelAndName, _strings, _data) {
         /* no-op */
     }
-    warn(moduleName, val) {
-        this.push(Level.WARN, moduleName, val);
+    warn(levelAndName, strings, data) {
+        print(Level.WARN, levelAndName, strings, data);
     }
-    error(moduleName, val) {
-        this.push(Level.ERROR, moduleName, val);
-    }
-    push(level, moduleName, val) {
-        const shortModule = moduleName.replace(this.options.workingDir, "");
-        const configuredLevel = findLevel(this.options, moduleName);
-        const lvlText = Level[level].padEnd(5);
-        if (level < configuredLevel) {
-            return;
-        }
-        const msg = `${lvlText} [${shortModule}] ${val}`;
-        if (level === Level.WARN) {
-            console.warn(msg);
-        }
-        else if (level === Level.ERROR) {
-            console.error(msg);
-        }
-        else {
-            console.info(msg);
-        }
+    error(levelAndName, strings, data) {
+        print(Level.ERROR, levelAndName, strings, data);
     }
 }
 /**
  * Insane version of console logger - supports insane level.
  */
 class InsaneConsoleLogger extends ConsoleTransport {
-    insane(moduleName, val) {
-        this.push(Level.INSANE, moduleName, val);
+    insane(levelAndName, strings, data) {
+        print(Level.INSANE, levelAndName, strings, data);
     }
-    trace(moduleName, val) {
-        this.push(Level.TRACE, moduleName, val);
+    trace(levelAndName, strings, data) {
+        print(Level.TRACE, levelAndName, strings, data);
     }
-    log(moduleName, val) {
-        this.push(Level.LOG, moduleName, val);
+    log(levelAndName, strings, data) {
+        print(Level.LOG, levelAndName, strings, data);
     }
-    info(moduleName, val) {
-        this.push(Level.INFO, moduleName, val);
+    info(levelAndName, strings, data) {
+        print(Level.INFO, levelAndName, strings, data);
     }
 }
 /**
  * A basic version of console logger - printing everything.
  */
 class TraceConsoleTransport extends ConsoleTransport {
-    insane(_moduleName, _val) {
+    insane(_levelAndName, _strings, _data) {
         /* no-op */
     }
-    trace(moduleName, val) {
-        this.push(Level.TRACE, moduleName, val);
+    trace(levelAndName, strings, data) {
+        print(Level.TRACE, levelAndName, strings, data);
     }
-    log(moduleName, val) {
-        this.push(Level.LOG, moduleName, val);
+    log(levelAndName, strings, data) {
+        print(Level.LOG, levelAndName, strings, data);
     }
-    info(moduleName, val) {
-        this.push(Level.INFO, moduleName, val);
+    info(levelAndName, strings, data) {
+        print(Level.INFO, levelAndName, strings, data);
     }
 }
 /**
  * An optimized version of the logger - completely ignores `TRACE` level calls.
  */
 class LogConsoleTransport extends ConsoleTransport {
-    insane(_moduleName, _val) {
+    insane(_levelAndName, _strings, _data) {
         /* no-op */
     }
-    trace(_moduleName, _val) {
+    trace(_levelAndName, _strings, _data) {
         /* no-op */
     }
-    log(moduleName, val) {
-        this.push(Level.LOG, moduleName, val);
+    log(levelAndName, strings, data) {
+        print(Level.LOG, levelAndName, strings, data);
     }
-    info(moduleName, val) {
-        this.push(Level.INFO, moduleName, val);
+    info(levelAndName, strings, data) {
+        print(Level.INFO, levelAndName, strings, data);
     }
 }
 /**
  * An optimized version of the logger - completely ignores `TRACE` & `DEBUG` level calls.
  */
 class InfoConsoleTransport extends ConsoleTransport {
-    insane(_moduleName, _val) {
+    insane(_levelAndName, _strings, _data) {
         /* no-op */
     }
-    trace(_moduleName, _val) {
+    trace(_levelAndName, _strings, _data) {
         /* no-op */
     }
-    log(_moduleName, _val) {
+    log(_levelAndName, _strings, _data) {
         /* no-op */
     }
-    info(moduleName, val) {
-        this.push(Level.INFO, moduleName, val);
+    info(levelAndName, strings, data) {
+        print(Level.INFO, levelAndName, strings, data);
     }
 }
@@ -35317,11 +35346,6 @@ class Logger {
         const module = moduleName ?? fName;
         return new Logger(module.padStart(8, " "), GLOBAL_CONFIG);
     }
-    /**
-     * Return currently configured level for given module. */
-    static getLevel(moduleName) {
-        return findLevel(GLOBAL_CONFIG.options, moduleName);
-    }
     /**
      * Global configuration of all loggers.
      *
@@ -35352,33 +35376,46 @@ class Logger {
         const options = parseLoggerOptions(input, defaultLevel, workingDir);
         Logger.configureAllFromOptions(options);
     }
+    cachedLevelAndName;
     constructor(moduleName, config) {
         this.moduleName = moduleName;
         this.config = config;
     }
+    /** Return currently configured level for given module. */
+    getLevel() {
+        return this.getLevelAndName()[0];
+    }
+    getLevelAndName() {
+        if (this.cachedLevelAndName === undefined) {
+            const level = findLevel(this.config.options, this.moduleName);
+            const shortName = this.moduleName.replace(this.config.options.workingDir, "");
+            this.cachedLevelAndName = [level, shortName];
+        }
+        return this.cachedLevelAndName;
+    }
     /** Log a message with `INSANE` level. */
-    insane(val) {
-        this.config.transport.insane(this.moduleName, val);
+    insane(strings, ...data) {
+        this.config.transport.insane(this.getLevelAndName(), strings, data);
     }
     /** Log a message with `TRACE` level. */
-    trace(val) {
-        this.config.transport.trace(this.moduleName, val);
+    trace(strings, ...data) {
+        this.config.transport.trace(this.getLevelAndName(), strings, data);
     }
     /** Log a message with `DEBUG`/`LOG` level. */
-    log(val) {
-        this.config.transport.log(this.moduleName, val);
+    log(strings, ...data) {
+        this.config.transport.log(this.getLevelAndName(), strings, data);
     }
     /** Log a message with `INFO` level. */
-    info(val) {
-        this.config.transport.info(this.moduleName, val);
+    info(strings, ...data) {
+        this.config.transport.info(this.getLevelAndName(), strings, data);
     }
     /** Log a message with `WARN` level. */
-    warn(val) {
-        this.config.transport.warn(this.moduleName, val);
+    warn(strings, ...data) {
+        this.config.transport.warn(this.getLevelAndName(), strings, data);
     }
     /** Log a message with `ERROR` level. */
-    error(val) {
-        this.config.transport.error(this.moduleName, val);
+    error(strings, ...data) {
+        this.config.transport.error(this.getLevelAndName(), strings, data);
     }
 }
@@ -35468,15 +35505,15 @@ class NodeConfiguration {
 }
 function loadConfig(configPath) {
     if (configPath === DEFAULT_CONFIG) {
-        logger.log("🔧 Loading DEFAULT config");
+        logger.log `🔧 Loading DEFAULT config`;
         return parseFromJson(configs.default, NodeConfiguration.fromJson);
     }
     if (configPath === DEV_CONFIG) {
-        logger.log("🔧 Loading DEV config");
+        logger.log `🔧 Loading DEV config`;
         return parseFromJson(configs.dev, NodeConfiguration.fromJson);
     }
     try {
-        logger.log(`🔧 Loading config from ${configPath}`);
+        logger.log `🔧 Loading config from ${configPath}`;
         const configFile = external_node_fs_default().readFileSync(configPath, "utf8");
         const parsed = JSON.parse(configFile);
         return parseFromJson(parsed, NodeConfiguration.fromJson);
@@ -39182,7 +39219,7 @@ class LmdbStates {
             await Promise.all([valuesWrite, statesWrite]);
         }
         catch (e) {
-            states_logger.error(`${e}`);
+            states_logger.error `${e}`;
             return result_Result.error(StateUpdateError.Commit);
         }
         return result_Result.ok(result_OK);
@@ -39251,7 +39288,7 @@ function openDatabase(nodeName, genesisHeader, databaseBasePath, { readOnly = fa
     const genesisHeaderHash = hashBytes(genesisHeader).asOpaque();
     const genesisHeaderHashNibbles = genesisHeaderHash.toString().substring(2, 10);
     const dbPath = `${databaseBasePath}/${nodeNameHash}/${genesisHeaderHashNibbles}`;
-    common_logger.info(`🛢️ Opening database at ${dbPath}`);
+    common_logger.info `🛢️ Opening database at ${dbPath}`;
     try {
         return {
             dbPath,
@@ -39273,21 +39310,21 @@ async function initializeDatabase(spec, genesisHeaderHash, rootDb, config, ances
     const states = new LmdbStates(spec, rootDb);
     const header = blocks.getBestHeaderHash();
     const state = blocks.getPostStateRoot(header);
-    common_logger.log(`🛢️ Best header hash: ${header}`);
-    common_logger.log(`🛢️ Best state root: ${state}`);
+    common_logger.log `🛢️ Best header hash: ${header}`;
+    common_logger.log `🛢️ Best state root: ${state}`;
     // DB seems already initialized, just go with what we have.
     const isDbInitialized = state !== null && !state.isEqualTo(bytes_Bytes.zero(hash_HASH_SIZE)) && !header.isEqualTo(bytes_Bytes.zero(hash_HASH_SIZE));
     if (isDbInitialized) {
         await rootDb.db.close();
         return;
     }
-    common_logger.log("🛢️ Database looks fresh. Initializing.");
+    common_logger.log `🛢️ Database looks fresh. Initializing.`;
     // looks like a fresh db, initialize the state.
     const genesisHeader = decoder_Decoder.decodeObject(Header.Codec, config.genesisHeader, spec);
     const genesisExtrinsic = emptyBlock().extrinsic;
     const genesisBlock = Block.create({ header: genesisHeader, extrinsic: genesisExtrinsic });
     const blockView = blockAsView(genesisBlock, spec);
-    common_logger.log(`🧬 Writing genesis block #${genesisHeader.timeSlotIndex}: ${genesisHeaderHash}`);
+    common_logger.log `🧬 Writing genesis block #${genesisHeader.timeSlotIndex}: ${genesisHeaderHash}`;
     const { genesisStateSerialized, genesisStateRootHash } = loadGenesisState(spec, config.genesisState);
     // write to db
     await blocks.insertBlock(new WithHash(genesisHeaderHash, blockView));
@@ -39305,7 +39342,7 @@ function loadGenesisState(spec, data) {
     const stateEntries = state_entries_StateEntries.fromEntriesUnsafe(data.entries());
     const state = serialized_state_SerializedState.fromStateEntries(spec, stateEntries);
     const genesisStateRootHash = stateEntries.getRootHash();
-    common_logger.info(`🧬 Genesis state root: ${genesisStateRootHash}`);
+    common_logger.info `🧬 Genesis state root: ${genesisStateRootHash}`;
     return {
         genesisState: state,
         genesisStateSerialized: stateEntries,
@@ -39444,7 +39481,7 @@ class TypedPort {
                 this.dispatchPortMessage(msg);
             }
             catch (e) {
-                port_logger.error(`[${this.constructor.name}] Failed to dispatch a message: ${e}: ${JSON.stringify(msg)}`);
+                port_logger.error `[${this.constructor.name}] Failed to dispatch a message: ${e}: ${msg}`;
                 throw e;
             }
         });
@@ -39518,7 +39555,7 @@ class TypedPort {
             this.port.postMessage(msg, transferList);
         }
         catch (e) {
-            port_logger.error(`[${this.constructor.name}] Failed to post a message: ${e}: ${JSON.stringify(msg)}`);
+            port_logger.error `[${this.constructor.name}] Failed to post a message: ${e}: ${msg}`;
             throw e;
         }
     }
@@ -39549,7 +39586,7 @@ class TypedPort {
     cleanup(reason) {
         // resolve all pending requests with an error.
         const responseListeners = this.responseListeners.eventNames();
-        for (const ev in responseListeners) {
+        for (const ev of responseListeners) {
             this.responseListeners.emit(ev, new Error(`port is ${reason}`));
         }
     }
@@ -39598,7 +39635,7 @@ class MessageChannelStateMachine {
                 this.dispatchSignal(name, data);
             }
             catch (e) {
-                channel_logger.error(`[${this.constructor.name}] Unable to dispatch signal (${name}): ${e}. ${this.stateInfo(remoteState)}`);
+                channel_logger.error `[${this.constructor.name}] Unable to dispatch signal (${name}): ${e}. ${this.stateInfo(remoteState)}`;
                 throw e;
             }
         });
@@ -39607,7 +39644,7 @@ class MessageChannelStateMachine {
                 await this.dispatchRequest(name, data, msg);
             }
             catch (e) {
-                channel_logger.error(`[${this.constructor.name}] Unable to dispatch request (${name}): ${e}. ${this.stateInfo(remoteState)}`);
+                channel_logger.error `[${this.constructor.name}] Unable to dispatch request (${name}): ${e}. ${this.stateInfo(remoteState)}`;
                 throw e;
             }
         });
@@ -39693,7 +39730,7 @@ class MessageChannelStateMachine {
             this.machine.transition(res.transitionTo.state, res.transitionTo.data);
         }
         if (didStateChangeInMeantime) {
-            channel_logger.warn(`Ignoring obsolete response for an old request: "${name}"`);
+            channel_logger.warn `Ignoring obsolete response for an old request: "${name}"`;
             return;
         }
         return this.port.respond(prevState.stateName, msg, res.response);
@@ -39709,7 +39746,7 @@ class MessageChannelStateMachine {
         }
     }
     transitionTo() {
-        channel_logger.trace(`[${this.machine.name}] transitioned to ${this.currentState()}`);
+        channel_logger.trace `[${this.machine.name}] transitioned to ${this.currentState()}`;
         return this;
     }
     /**
@@ -39729,7 +39766,7 @@ class MessageChannelStateMachine {
             await promise;
         }
         catch (e) {
-            channel_logger.error(JSON.stringify(e));
+            channel_logger.error `${e}`;
         }
         return new MessageChannelStateMachine(machine, port);
     }
@@ -39932,7 +39969,7 @@ class State {
      * actions.
      */
     onActivation(data) {
-        state_logger.trace(`[${this.constructor.name}] Changing state to: ${this}`);
+        state_logger.trace `[${this.constructor.name}] Changing state to: ${this}`;
         this.data = data;
     }
     /**
@@ -40030,7 +40067,7 @@ async function spawnWorkerGeneric(bootstrapPath, logger, mainReadyName, mainRead
     const worker = new external_node_worker_threads_namespaceObject.Worker(bootstrapPath);
     const machine = stateMachineMain(`main->${mainReadyName}`, mainReadyName, mainReadyState);
     const channel = await MessageChannelStateMachine.createAndTransferChannel(machine, worker);
-    logger.trace(`[${machine.name}] Worker spawned ${channel.currentState()}`);
+    logger.trace `[${machine.name}] Worker spawned ${channel.currentState()}`;
     return channel;
 }
@@ -40143,7 +40180,7 @@ class MainReady extends State {
         if (res instanceof Uint8Array) {
             return bytes_Bytes.fromBlob(res, hash_HASH_SIZE).asOpaque();
         }
-        state_machine_logger.error(`Invalid response for getBestStateRootHash. Expected Uint8Array, got: ${res}`);
+        state_machine_logger.error `Invalid response for getBestStateRootHash. Expected Uint8Array, got: ${res}`;
         return bytes_Bytes.zero(hash_HASH_SIZE).asOpaque();
     }
     finish(channel) {
@@ -40191,7 +40228,7 @@ class ImporterReady extends State {
     }
     async getStateEntries(hash) {
         if (this.importer === null) {
-            state_machine_logger.error(`${this.constructor.name} importer not initialized yet!`);
+            state_machine_logger.error `${this.constructor.name} importer not initialized yet!`;
             await new Promise((resolve) => {
                 this.onImporter.once(resolve);
             });
@@ -40205,7 +40242,7 @@ class ImporterReady extends State {
                 response: encoded.raw,
             };
         }
-        state_machine_logger.error(`${this.constructor.name} got invalid request type: ${JSON.stringify(hash)}.`);
+        state_machine_logger.error `${this.constructor.name} got invalid request type: ${JSON.stringify(hash)}.`;
         return {
             response: null,
         };
@@ -40225,7 +40262,7 @@ class ImporterReady extends State {
     }
     async importBlock(block) {
         if (this.importer === null) {
-            state_machine_logger.error(`${this.constructor.name} importer not initialized yet!`);
+            state_machine_logger.error `${this.constructor.name} importer not initialized yet!`;
             await new Promise((resolve) => {
                 this.onImporter.once(resolve);
             });
@@ -40245,8 +40282,8 @@ class ImporterReady extends State {
                 }
             }
             catch (e) {
-                state_machine_logger.error(`Failed to import block: ${e}`);
-                state_machine_logger.error(`${e instanceof Error ? e.stack : ""}`);
+                state_machine_logger.error `Failed to import block: ${e}`;
+                state_machine_logger.error `${e instanceof Error ? e.stack : ""}`;
                 response = result_Result.error(`${e}`);
             }
             const encoded = encoder_Encoder.encodeObject(importBlockResultCodec, response);
@@ -40254,7 +40291,7 @@ class ImporterReady extends State {
                 response: encoded.raw,
             };
         }
-        state_machine_logger.error(`${this.constructor.name} got invalid request type: ${JSON.stringify(block)}.`);
+        state_machine_logger.error `${this.constructor.name} got invalid request type: ${JSON.stringify(block)}.`;
         return {
             response: null,
         };
@@ -40266,7 +40303,7 @@ class ImporterReady extends State {
             this.onBlock.emit(blockView);
         }
         else {
-            state_machine_logger.error(`${this.constructor.name} got invalid signal type: ${JSON.stringify(block)}.`);
+            state_machine_logger.error `${this.constructor.name} got invalid signal type: ${JSON.stringify(block)}.`;
         }
     }
     async endWork() {
@@ -40365,7 +40402,7 @@ class state_machine_MainReady extends State {
             this.onNewBlocks.emit(blocks);
         }
         else {
-            jam_network_state_machine_logger.error(`${this.constructor.name} got invalid signal type: ${JSON.stringify(block)}.`);
+            jam_network_state_machine_logger.error `${this.constructor.name} got invalid signal type: ${JSON.stringify(block)}.`;
         }
     }
     announceHeader(port, header) {
@@ -40403,7 +40440,7 @@ class NetworkReady extends State {
             this.onNewHeader.emit(decoded);
         }
         else {
-            jam_network_state_machine_logger.error(`${this.constructor.name} got invalid signal type: ${JSON.stringify(header)}.`);
+            jam_network_state_machine_logger.error `${this.constructor.name} got invalid signal type: ${JSON.stringify(header)}.`;
         }
     }
     sendBlocks(port, blocks) {
@@ -42111,12 +42148,14 @@ class WriteablePage extends MemoryPage {
 var AccessType;
 (function (AccessType) {
     AccessType[AccessType["READ"] = 0] = "READ";
     AccessType[AccessType["WRITE"] = 1] = "WRITE";
 })(AccessType || (AccessType = {}));
-// const logger = Logger.new(import.meta.filename, "pvm:mem");
+const memory_logger = Logger.new(import.meta.filename, "pvm:mem");
 class Memory {
     sbrkIndex;
     virtualSbrkIndex;
@@ -42147,7 +42186,7 @@ class Memory {
         if (bytes.length === 0) {
             return result_Result.ok(result_OK);
         }
-        // logger.insane(`MEM[${address}] <- ${BytesBlob.blobFrom(bytes)}`);
+        memory_logger.insane `MEM[${address}] <- ${bytes_BytesBlob.blobFrom(bytes)}`;
         const pagesResult = this.getPages(address, bytes.length, AccessType.WRITE);
         if (pagesResult.isError) {
             return result_Result.error(pagesResult.error);
@@ -42214,7 +42253,7 @@ class Memory {
             currentPosition += bytesToRead;
             bytesLeft -= bytesToRead;
         }
-        // logger.insane(`MEM[${startAddress}] => ${BytesBlob.blobFrom(result)}`);
+        memory_logger.insane `MEM[${startAddress}] => ${bytes_BytesBlob.blobFrom(result)}`;
         return result_Result.ok(result_OK);
     }
     sbrk(length) {
@@ -44144,7 +44183,7 @@ class ProgramDecoder {
             return result_Result.ok(new ProgramDecoder(program));
         }
         catch (e) {
-            program_decoder_logger.error(`Invalid program: ${e}`);
+            program_decoder_logger.error `Invalid program: ${e}`;
             return result_Result.error(ProgramDecoderError.InvalidProgramError);
         }
     }
@@ -44310,7 +44349,7 @@ class Interpreter {
         const argsType = instructionArgumentTypeMap[currentInstruction] ?? ArgumentType.NO_ARGUMENTS;
         const argsResult = this.argsDecodingResults[argsType];
         this.argsDecoder.fillArgs(this.pc, argsResult);
-        interpreter_logger.insane(`[PC: ${this.pc}] ${Instruction[currentInstruction]}`);
+        interpreter_logger.insane `[PC: ${this.pc}] ${Instruction[currentInstruction]}`;
         if (!isValidInstruction) {
             this.instructionResult.status = pvm_interpreter_result_Result.PANIC;
         }
@@ -44382,7 +44421,7 @@ class Interpreter {
                     this.status = status_Status.HOST;
                     break;
             }
-            interpreter_logger.insane(`[PC: ${this.pc}] Status: ${pvm_interpreter_result_Result[this.instructionResult.status]}`);
+            interpreter_logger.insane `[PC: ${this.pc}] Status: ${pvm_interpreter_result_Result[this.instructionResult.status]}`;
             return this.status;
         }
         this.pc = this.instructionResult.nextPc;
@@ -44629,7 +44668,7 @@ class host_calls_manager_HostCallsManager {
             return `r${idx}=${value} (0x${value.toString(16)})`;
         })
             .join(", ");
-        host_calls_manager_logger.insane(`[${currentServiceId}] ${context} ${name}${requested}.  Gas: ${gas}. Regs: ${registerValues}.`);
+        host_calls_manager_logger.insane `[${currentServiceId}] ${context} ${name}${requested}.  Gas: ${gas}. Regs: ${registerValues}.`;
     }
 }
 class NoopMissing {
@@ -45237,7 +45276,7 @@ class block_generator_state_machine_MainReady extends State {
             this.onBlock.emit(block);
         }
         else {
-            block_generator_state_machine_logger.error(`${this.constructor.name} got invalid signal type: ${JSON.stringify(block)}.`);
+            block_generator_state_machine_logger.error `${this.constructor.name} got invalid signal type: ${JSON.stringify(block)}.`;
         }
     }
     finish(channel) {
@@ -45292,12 +45331,12 @@ if (!external_node_worker_threads_namespaceObject.isMainThread) {
     channel
         .then((channel) => main(channel))
         .catch((e) => {
-        block_generator_logger.error(e);
+        block_generator_logger.error `${e}`;
         if (e.stack !== undefined) {
-            block_generator_logger.error(e.stack);
+            block_generator_logger.error `${e.stack}`;
         }
         if (e.cause !== undefined) {
-            block_generator_logger.error(e.cause);
+            block_generator_logger.error `${e.cause}`;
         }
     });
 }
@@ -45305,7 +45344,7 @@ if (!external_node_worker_threads_namespaceObject.isMainThread) {
  * The `BlockGenerator` should periodically create new blocks and send them as signals to the main thread.
  */
 async function main(channel) {
-    block_generator_logger.info(`🎁 Block Generator running ${channel.currentState()}`);
+    block_generator_logger.info `🎁 Block Generator running ${channel.currentState()}`;
     // Await the configuration object
     const ready = await channel.waitForState("ready(generator)");
     const config = ready.currentState().getConfig();
@@ -45320,11 +45359,11 @@ async function main(channel) {
             await (0,promises_namespaceObject.setTimeout)(config.chainSpec.slotDuration * 1000);
             counter += 1;
             const newBlock = await generator.nextEncodedBlock();
-            block_generator_logger.trace(`Sending block ${counter}`);
+            block_generator_logger.trace `Sending block ${counter}`;
             worker.sendBlock(port, newBlock);
         }
     });
-    block_generator_logger.info("Block Generator finished. Closing channel.");
+    block_generator_logger.info `Block Generator finished. Closing channel.`;
     // Close the comms to gracefully close the app.
     finished.currentState().close(channel);
 }
@@ -45439,11 +45478,11 @@ class PeersManagement {
     _onPeerDisconnected = [];
     peers = new Map();
     peerConnected(peer) {
-        peers_logger.info(`💡 Peer ${displayId(peer)} connected.`);
+        peers_logger.info `💡 Peer ${displayId(peer)} connected.`;
         const oldPeerData = this.peers.get(peer.id);
         if (oldPeerData !== undefined) {
             // TODO [ToDr] replacing old connection?
-            peers_logger.warn("Replacing older connection.");
+            peers_logger.warn `Replacing older connection.`;
         }
         this.peers.set(peer.id, peer);
         for (const callback of this._onPeerConnected) {
@@ -45451,7 +45490,7 @@ class PeersManagement {
         }
     }
     peerDisconnected(peer) {
-        peers_logger.info(`⚡︎Peer ${displayId(peer)} disconnected.`);
+        peers_logger.info `⚡︎Peer ${displayId(peer)} disconnected.`;
         this.peers.delete(peer.id);
         for (const callback of this._onPeerDisconnected) {
             callback(peer);
@@ -54243,23 +54282,23 @@ var VerifyCertError;
     VerifyCertError[VerifyCertError["IncorrectSignature"] = 4] = "IncorrectSignature";
 })(VerifyCertError || (VerifyCertError = {}));
 async function verifyCertificate(certs) {
-    certificate_logger.log("Incoming peer. Verifying certificate");
+    certificate_logger.log `Incoming peer. Verifying certificate`;
     // Must present exactly one cert
     if (certs.length !== 1) {
-        certificate_logger.log("Rejecting peer with no certificates.");
+        certificate_logger.log `Rejecting peer: expected exactly one certificate, got: ${certs.length}`;
         return result_Result.error(VerifyCertError.NoCertificate);
     }
     // Parse with Node's X509Certificate (accepts PEM or DER)
     const xc = new (external_node_crypto_default()).X509Certificate(certs[0]);
     // Must be Ed25519 key
     if (xc.publicKey.asymmetricKeyType !== CURVE_NAME.toLowerCase()) {
-        certificate_logger.log(`Rejecting peer using non-ed25519 certificate: ${xc.publicKey.asymmetricKeyType}`);
+        certificate_logger.log `Rejecting peer using non-ed25519 certificate: ${xc.publicKey.asymmetricKeyType}`;
         return result_Result.error(VerifyCertError.NotEd25519);
     }
     // Extract raw public key via JWK export
     const jwk = xc.publicKey.export({ format: "jwk" });
     if (jwk.kty !== KEY_TYPE || jwk.crv !== CURVE_NAME) {
-        certificate_logger.log(`Public key type mismatch: ${jwk.kty}, ${jwk.crv}`);
+        certificate_logger.log `Public key type mismatch: ${jwk.kty}, ${jwk.crv}`;
         return result_Result.error(VerifyCertError.PublicKeyTypeMismatch);
     }
     // SAN must be exactly 'e'+base32(rawPub)
@@ -54267,7 +54306,7 @@ async function verifyCertificate(certs) {
     const sanField = xc.subjectAltName ?? "";
     const m = sanField.match(/DNS:([^,]+)/);
     if (m === null || m[1] !== expectedSan) {
-        certificate_logger.log(`AltName mismatch. Expected: '${expectedSan}', got: '${m?.[1]}'`);
+        certificate_logger.log `AltName mismatch. Expected: '${expectedSan}', got: '${m?.[1]}'`;
         return result_Result.error(VerifyCertError.AltNameMismatch);
     }
     const key = Buffer.from(jwk.x ?? "", "base64url");
@@ -54534,19 +54573,19 @@ class QuicNetwork {
         }
         this.started = true;
         await this.socket.start({ host: this.listen.host, port: this.listen.port });
-        quic_network_logger.info(`🛜  QUIC socket on ${this.socket.host}:${this.socket.port}`);
+        quic_network_logger.info `🛜  QUIC socket on ${this.socket.host}:${this.socket.port}`;
         await this.server.start();
-        quic_network_logger.log("🛜  QUIC server listening");
+        quic_network_logger.log `🛜  QUIC server listening`;
     }
     async stop() {
         if (!this.started) {
             throw new Error("Network not started yet!");
         }
-        quic_network_logger.info("Stopping the networking.");
+        quic_network_logger.info `Stopping the networking.`;
         await this.server.stop();
         await this.socket.stop();
         this.started = false;
-        quic_network_logger.info("Networking stopped.");
+        quic_network_logger.info `Networking stopped.`;
     }
     get peers() {
         return this._peers;
@@ -54567,7 +54606,7 @@ clazz, callback) {
             await callback(ev);
         }
         catch (e) {
-            quic_utils_logger.error(`Unhandled exception in ${clazz.name} event handler: ${e}`);
+            quic_utils_logger.error `Unhandled exception in ${clazz.name} event handler: ${e}`;
         }
     });
 }
@@ -54626,7 +54665,7 @@ class QuicPeer {
     streamEvents = new (external_node_events_default())();
     constructor(conn, peerInfo) {
         this.conn = conn;
-        quic_peer_logger.log(`👥 [${peerInfo.id}] peer connected ${conn.remoteHost}:${conn.remotePort}`);
+        quic_peer_logger.log `👥 [${peerInfo.id}] peer connected ${conn.remoteHost}:${conn.remotePort}`;
         this.connectionId = conn.connectionIdShared.toString();
         this.address = {
             host: conn.remoteHost,
@@ -54636,11 +54675,11 @@ class QuicPeer {
         this.key = peerInfo.key;
         addEventListener(conn, EventQUICConnectionStream, (ev) => {
             const stream = ev.detail;
-            quic_peer_logger.log(`🚰  [${this.id}] new stream: [${stream.streamId}]`);
+            quic_peer_logger.log `🚰  [${this.id}] new stream: [${stream.streamId}]`;
             this.streamEvents.emit("stream", new QuicStream(stream));
         });
         addEventListener(conn, EventQUICConnectionError, (err) => {
-            quic_peer_logger.error(`❌ [${this.id}] connection failed: ${err.detail}`);
+            quic_peer_logger.error `❌ [${this.id}] connection failed: ${err.detail}`;
         });
     }
     addOnIncomingStream(streamCallback) {
@@ -54648,11 +54687,11 @@ class QuicPeer {
     }
     openStream() {
         const stream = this.conn.newStream("bidi");
-        quic_peer_logger.log(`🚰 [${this.id}] opening stream: [${stream.streamId}]`);
+        quic_peer_logger.log `🚰 [${this.id}] opening stream: [${stream.streamId}]`;
         return new QuicStream(stream);
     }
     async disconnect() {
-        quic_peer_logger.log(`👋 [${this.id}] disconnecting`);
+        quic_peer_logger.log `👋 [${this.id}] disconnecting`;
         await this.conn.stop({ isApp: true });
     }
 }
@@ -54673,7 +54712,7 @@ const setup_logger = Logger.new(import.meta.filename, "net");
 class Quic {
     /** Setup QUIC socket and start listening for connections. */
     static async setup({ host, port, protocols, key }) {
-        const quicLoggerLvl = Logger.getLevel("net") > Level.TRACE ? LogLevel.WARN : LogLevel.DEBUG;
+        const quicLoggerLvl = setup_logger.getLevel() > Level.TRACE ? LogLevel.WARN : LogLevel.DEBUG;
         const quicLogger = new dist_Logger("quic", quicLoggerLvl, [
             new handlers_StreamHandler(format `${level}:${keys}:${msg}`),
         ]);
@@ -54696,7 +54735,7 @@ class Quic {
             verifyPeer: true,
             verifyCallback: lastConnectedPeer.verifyCallback,
         };
-        setup_logger.info(`🆔 Peer id: ** ${altNameRaw(key.pubKey)}@${host}:${port} ** (pubkey: ${key.pubKey})`);
+        setup_logger.info `🆔 Peer id: ** ${altNameRaw(key.pubKey)}@${host}:${port} ** (pubkey: ${key.pubKey})`;
         // Shared injected UDP socket
         const socket = new dist_QUICSocket({
             logger: quicLogger.getChild("socket"),
@@ -54711,8 +54750,8 @@ class Quic {
         // peer management
         const peers = new PeersManagement();
         // basic error handling
-        addEventListener(server, EventQUICServerError, (error) => setup_logger.error(`🛜  Server error: ${error}`));
-        addEventListener(server, EventQUICServerClose, (ev) => setup_logger.error(`🛜  Server stopped: ${ev}`));
+        addEventListener(server, EventQUICServerError, (error) => setup_logger.error `🛜  Server error: ${error}`);
+        addEventListener(server, EventQUICServerClose, (ev) => setup_logger.error `🛜  Server stopped: ${ev}`);
         // handling incoming session
         addEventListener(server, EventQUICServerConnection, async (ev) => {
             const conn = ev.detail;
@@ -54721,16 +54760,16 @@ class Quic {
                 return;
             }
             if (lastConnectedPeer.info.key.isEqualTo(key.pubKey)) {
-                setup_logger.log(`🛜 Rejecting connection from ourself from ${conn.remoteHost}:${conn.remotePort}`);
+                setup_logger.log `🛜 Rejecting connection from ourself from ${conn.remoteHost}:${conn.remotePort}`;
                 await conn.stop();
                 return;
             }
             if (peers.isConnected(lastConnectedPeer.info.id)) {
-                setup_logger.log(`🛜 Rejecting duplicate connection with peer ${lastConnectedPeer.info.id} from ${conn.remoteHost}:${conn.remotePort}`);
+                setup_logger.log `🛜 Rejecting duplicate connection with peer ${lastConnectedPeer.info.id} from ${conn.remoteHost}:${conn.remotePort}`;
                 await conn.stop();
                 return;
             }
-            setup_logger.log(`🛜 Server handshake with ${conn.remoteHost}:${conn.remotePort}`);
+            setup_logger.log `🛜 Server handshake with ${conn.remoteHost}:${conn.remotePort}`;
             newPeer(conn, lastConnectedPeer.info);
             lastConnectedPeer.info = null;
             await conn.start();
@@ -54753,10 +54792,10 @@ class Quic {
             });
             const client = await clientLater;
             addEventListener(client, EventQUICClientClose, () => {
-                setup_logger.log("⚰️ Client connection closed.");
+                setup_logger.log `⚰️ Client connection closed.`;
             });
             addEventListener(client, EventQUICClientError, (error) => {
-                setup_logger.error(`🔴 Client error: ${error.detail}`);
+                setup_logger.error `🔴 Client error: ${error.detail}`;
             });
             if (peerDetails.info === null) {
                 throw new Error("Client connected, but there is no peer details!");
@@ -54764,7 +54803,7 @@ class Quic {
             if (options.verifyName !== undefined && options.verifyName !== peerDetails.info.id) {
                 throw new Error(`Client connected, but the id didn't match. Expected: ${options.verifyName}, got: ${peerDetails.info.id}`);
             }
-            setup_logger.log(`🤝 Client handshake with: ${peer.host}:${peer.port}`);
+            setup_logger.log `🤝 Client handshake with: ${peer.host}:${peer.port}`;
             return newPeer(client.connection, peerDetails.info);
         }
         function newPeer(conn, peerInfo) {
@@ -54884,10 +54923,10 @@ class Connections {
         for (;;) {
             // increase the reconnection counter
             meta.currentRetry += 1;
-            if (meta.currentRetry >= meta.maxRetries) {
+            if (meta.currentRetry > meta.maxRetries) {
                 // reached max retries for a peer, remove it from tracking.
                 this.peerInfo.delete(id);
-                jamnp_s_peers_logger.log(`[${id}] max retries reached. Removing peer.`);
+                jamnp_s_peers_logger.log `[${id}] max retries reached. Removing peer.`;
                 return;
             }
             // else attempt to connect to a node a bit later.
@@ -54906,7 +54945,7 @@ class Connections {
             }
             // attempt to connect to the peer
             try {
-                jamnp_s_peers_logger.trace(`[${id}] Attempting to connect to peer at ${meta.address.host}:${meta.address.port}.`);
+                jamnp_s_peers_logger.trace `[${id}] Attempting to connect to peer at ${meta.address.host}:${meta.address.port}.`;
                 await this.network.dial(meta.address, { signal, verifyName: meta.peerId });
                 return;
             }
@@ -54915,7 +54954,7 @@ class Connections {
                     return;
                 }
                 // failing to connect, will retry.
-                jamnp_s_peers_logger.trace(`[${id}] attempt failed. Will retry (${meta.currentRetry}/${meta.maxRetries})`);
+                jamnp_s_peers_logger.trace `[${id}] attempt failed. Will retry (${meta.currentRetry}/${meta.maxRetries})`;
             }
         }
     }
@@ -55028,7 +55067,7 @@ class StreamManager {
             // We expect a one-byte identifier first.
             const data = await reader.read();
             bytes = bytes_BytesBlob.blobFrom(data.value !== undefined ? data.value : new Uint8Array());
-            stream_manager_logger.trace(`🚰 --> [${peer.id}:${streamId}] Initial data: ${bytes}`);
+            stream_manager_logger.trace `🚰 --> [${peer.id}:${streamId}] Initial data: ${bytes}`;
         }
         finally {
             reader.releaseLock();
@@ -55042,7 +55081,7 @@ class StreamManager {
         if (handler === undefined) {
             throw new Error(`Unsupported stream kind: ${kind}`);
         }
-        stream_manager_logger.log(`🚰 --> [${peer.id}:${stream.streamId}] Stream identified as: ${kind}`);
+        stream_manager_logger.log `🚰 --> [${peer.id}:${stream.streamId}] Stream identified as: ${kind}`;
         this.registerStream(peer, handler, stream, bytes_BytesBlob.blobFrom(bytes.raw.subarray(1)));
     }
     registerStream(peer, handler, stream, initialData) {
@@ -55052,7 +55091,7 @@ class StreamManager {
             this.streams.delete(streamId);
             this.backgroundTasks.delete(streamId);
             if (kind === StreamErrorKind.Exception) {
-                stream_manager_logger.error(`🚰 --- [${peer.id}:${streamId}] Stream error: ${e}. Disconnecting peer.`);
+                stream_manager_logger.error `🚰 --- [${peer.id}:${streamId}] Stream error: ${e}. Disconnecting peer.`;
             }
             if (kind !== StreamErrorKind.LocalClose) {
                 // whenever we have an error, we are going to inform the handler
@@ -55086,10 +55125,10 @@ async function readStreamForever(peer, handler, quicStream, initialData, reader)
     let isDone = false;
     const callback = handleMessageFragmentation((data) => {
         const bytes = bytes_BytesBlob.blobFrom(new Uint8Array(data));
-        stream_manager_logger.trace(`🚰 --> [${peer.id}:${quicStream.streamId}] ${bytes}`);
+        stream_manager_logger.trace `🚰 --> [${peer.id}:${quicStream.streamId}] ${bytes}`;
         handler.onStreamMessage(quicStream, bytes);
     }, () => {
-        stream_manager_logger.error(`🚰 --> [${peer.id}:${quicStream.streamId}] got too much data. Disconnecting.`);
+        stream_manager_logger.error `🚰 --> [${peer.id}:${quicStream.streamId}] got too much data. Disconnecting.`;
         peer.disconnect();
     });
     for (;;) {
@@ -55098,7 +55137,7 @@ async function readStreamForever(peer, handler, quicStream, initialData, reader)
         // be a promise, so that we can make back pressure here.
         callback(bytes.raw);
         if (isDone) {
-            stream_manager_logger.log(`🚰 --> [${peer.id}:${quicStream.streamId}] remote finished.`);
+            stream_manager_logger.log `🚰 --> [${peer.id}:${quicStream.streamId}] remote finished.`;
             return;
         }
         // await for more data
@@ -55141,7 +55180,7 @@ class QuicStreamSender {
                         return;
                     }
                     const { data, addPrefix } = chunk;
-                    stream_manager_logger.trace(`🚰 <-- [${this.streamId}] write: ${data}`);
+                    stream_manager_logger.trace `🚰 <-- [${this.streamId}] write: ${data}`;
                     if (addPrefix) {
                         await writer.write(encodeMessageLength(data.raw));
                     }
@@ -55158,7 +55197,7 @@ class QuicStreamSender {
     }
     close() {
         handleAsyncErrors(async () => {
-            stream_manager_logger.trace(`🚰 <-- [${this.streamId}] closing`);
+            stream_manager_logger.trace `🚰 <-- [${this.streamId}] closing`;
             if (this.currentWriterPromise !== null) {
                 await this.currentWriterPromise;
             }
@@ -55244,7 +55283,7 @@ class ServerHandler {
     }
     onStreamMessage(sender, message) {
         const request = decoder_Decoder.decodeObject(BlockRequest.Codec, message);
-        ce_128_block_request_logger.log(`[${sender.streamId}] Client has requested: ${request}`);
+        ce_128_block_request_logger.log `[${sender.streamId}] Client has requested: ${request}`;
         const blocks = this.getBlockSequence(sender.streamId, request.headerHash, request.direction, request.maxBlocks);
         sender.bufferAndSend(encoder_Encoder.encodeObject(descriptors_codec.sequenceFixLen(Block.Codec.View, blocks.length), blocks, this.chainSpec));
         sender.close();
@@ -55264,7 +55303,7 @@ class ClientHandler {
             throw new Error("Received an unexpected message from the server.");
         }
         const blocks = decoder_Decoder.decodeSequence(Block.Codec.View, message, this.chainSpec);
-        ce_128_block_request_logger.log(`[${sender.streamId}] Server returned ${blocks.length} blocks in ${message.length} bytes of data.`);
+        ce_128_block_request_logger.log `[${sender.streamId}] Server returned ${blocks.length} blocks in ${message.length} bytes of data.`;
         this.promiseResolvers.get(sender.streamId)?.(blocks);
         this.promiseResolvers.delete(sender.streamId);
     }
@@ -55435,13 +55474,13 @@ class ce_129_state_request_Handler {
     }
     onStreamMessage(sender, message) {
         if (this.isServer) {
-            ce_129_state_request_logger.info(`[${sender.streamId}][server]: Received request.`);
+            ce_129_state_request_logger.info `[${sender.streamId}][server]: Received request.`;
             if (this.getBoundaryNodes === undefined || this.getKeyValuePairs === undefined)
                 return;
             const request = decoder_Decoder.decodeObject(StateRequest.Codec, message);
             const boundaryNodes = this.getBoundaryNodes(request.headerHash, request.startKey, request.endKey);
             const keyValuePairs = this.getKeyValuePairs(request.headerHash, request.startKey, request.endKey);
-            ce_129_state_request_logger.info(`[${sender.streamId}][server]: <-- responding with boundary nodes and key value pairs.`);
+            ce_129_state_request_logger.info `[${sender.streamId}][server]: <-- responding with boundary nodes and key value pairs.`;
             sender.bufferAndSend(encoder_Encoder.encodeObject(descriptors_codec.sequenceVarLen(trieNodeCodec), boundaryNodes));
             sender.bufferAndSend(encoder_Encoder.encodeObject(StateResponse.Codec, StateResponse.create({ keyValuePairs })));
             sender.close();
@@ -55449,11 +55488,11 @@ class ce_129_state_request_Handler {
         }
         if (!this.boundaryNodes.has(sender.streamId)) {
             this.boundaryNodes.set(sender.streamId, decoder_Decoder.decodeObject(descriptors_codec.sequenceVarLen(trieNodeCodec), message));
-            ce_129_state_request_logger.info(`[${sender.streamId}][client]: Received boundary nodes.`);
+            ce_129_state_request_logger.info `[${sender.streamId}][client]: Received boundary nodes.`;
             return;
         }
         this.onResponse.get(sender.streamId)?.(decoder_Decoder.decodeObject(StateResponse.Codec, message));
-        ce_129_state_request_logger.info(`[${sender.streamId}][client]: Received state values.`);
+        ce_129_state_request_logger.info `[${sender.streamId}][client]: Received state values.`;
     }
     onClose(streamId) {
         this.boundaryNodes.delete(streamId);
@@ -55510,7 +55549,7 @@ class ce_131_ce_132_safrole_ticket_distribution_ServerHandler {
     }
     onStreamMessage(sender, message) {
         const ticketDistribution = Decoder.decodeObject(TicketDistributionRequest.Codec, message);
-        ce_131_ce_132_safrole_ticket_distribution_logger.log(`[${sender.streamId}][ce-${this.kind}] Received ticket for epoch ${ticketDistribution.epochIndex}`);
+        ce_131_ce_132_safrole_ticket_distribution_logger.log `[${sender.streamId}][ce-${this.kind}] Received ticket for epoch ${ticketDistribution.epochIndex}`;
         this.onTicketReceived(ticketDistribution.epochIndex, ticketDistribution.ticket);
         sender.close();
     }
@@ -55522,7 +55561,7 @@ class ce_131_ce_132_safrole_ticket_distribution_ClientHandler {
         this.kind = kind;
     }
     onStreamMessage(sender) {
-        ce_131_ce_132_safrole_ticket_distribution_logger.warn(`[${sender.streamId}][ce-${this.kind}] Unexpected message received. Closing.`);
+        ce_131_ce_132_safrole_ticket_distribution_logger.warn `[${sender.streamId}][ce-${this.kind}] Unexpected message received. Closing.`;
         sender.close();
     }
     onClose() { }
@@ -55595,15 +55634,15 @@ class ce_133_work_package_submission_ServerHandler {
 class ce_133_work_package_submission_ClientHandler {
     kind = ce_133_work_package_submission_STREAM_KIND;
     onStreamMessage(sender) {
-        ce_133_work_package_submission_logger.warn(`[${sender.streamId}] Got unexpected message on CE-133 stream. Closing.`);
+        ce_133_work_package_submission_logger.warn `[${sender.streamId}] Got unexpected message on CE-133 stream. Closing.`;
         sender.close();
     }
     onClose() { }
     sendWorkPackage(sender, coreIndex, workPackage, extrinsic) {
         const corePack = CoreWorkPackage.create({ coreIndex, workPackage });
-        ce_133_work_package_submission_logger.trace(`[${sender.streamId}] Sending work package: ${corePack}`);
+        ce_133_work_package_submission_logger.trace `[${sender.streamId}] Sending work package: ${corePack}`;
         sender.bufferAndSend(Encoder.encodeObject(CoreWorkPackage.Codec, corePack));
-        ce_133_work_package_submission_logger.trace(`[${sender.streamId}] Sending extrinsics: ${workPackage.items}`);
+        ce_133_work_package_submission_logger.trace `[${sender.streamId}] Sending extrinsics: ${workPackage.items}`;
         sender.bufferAndSend(Encoder.encodeObject(workItemExtrinsicsCodec(workPackage.items), extrinsic));
         // now close the connection
         sender.close();
@@ -55679,7 +55718,7 @@ class ce_134_work_package_sharing_ServerHandler {
             ce_134_work_package_sharing_ServerHandler.sendWorkReport(sender, workReportHash, signature);
         })
             .catch((error) => {
-            ce_134_work_package_sharing_logger.error(`[${streamId}] Error processing work package: ${error}`);
+            ce_134_work_package_sharing_logger.error `[${streamId}] Error processing work package: ${error}`;
             this.onClose(streamId);
         });
     }
@@ -55696,7 +55735,7 @@ class ce_134_work_package_sharing_ClientHandler {
             throw new Error("Unexpected message received.");
         }
         const response = Decoder.decodeObject(WorkPackageSharingResponse.Codec, message);
-        ce_134_work_package_sharing_logger.info(`[${sender.streamId}] Received work report hash and signature.`);
+        ce_134_work_package_sharing_logger.info `[${sender.streamId}] Received work report hash and signature.`;
         pendingRequest.resolve({ workReportHash: response.workReportHash, signature: response.signature });
         sender.close();
     }
@@ -55709,9 +55748,9 @@ class ce_134_work_package_sharing_ClientHandler {
     }
     async sendWorkPackage(sender, coreIndex, segmentsRootMappings, workPackageBundle) {
         const request = WorkPackageSharingRequest.create({ coreIndex, segmentsRootMappings });
-        ce_134_work_package_sharing_logger.trace(`[${sender.streamId}] Sending core index and segments-root mappings.`);
+        ce_134_work_package_sharing_logger.trace `[${sender.streamId}] Sending core index and segments-root mappings.`;
         sender.bufferAndSend(Encoder.encodeObject(WorkPackageSharingRequest.Codec, request));
-        ce_134_work_package_sharing_logger.trace(`[${sender.streamId}] Sending work package bundle.`);
+        ce_134_work_package_sharing_logger.trace `[${sender.streamId}] Sending work package bundle.`;
         sender.bufferAndSend(Encoder.encodeObject(WorkPackageBundleCodec, workPackageBundle));
         return new Promise((resolve, reject) => {
             this.pendingRequests.set(sender.streamId, { resolve, reject });
@@ -55771,7 +55810,7 @@ class ce_135_work_report_distribution_ServerHandler {
     }
     onStreamMessage(sender, message) {
         const guaranteedWorkReport = Decoder.decodeObject(GuaranteedWorkReport.Codec, message, this.chainSpec);
-        ce_135_work_report_distribution_logger.log(`[${sender.streamId}] Received guaranteed work report.`);
+        ce_135_work_report_distribution_logger.log `[${sender.streamId}] Received guaranteed work report.`;
         this.onWorkReport(guaranteedWorkReport);
         sender.close();
     }
@@ -55784,12 +55823,12 @@ class ce_135_work_report_distribution_ClientHandler {
         this.chainSpec = chainSpec;
     }
     onStreamMessage(sender) {
-        ce_135_work_report_distribution_logger.warn(`[${sender.streamId}] Got unexpected message on CE-135 stream. Closing.`);
+        ce_135_work_report_distribution_logger.warn `[${sender.streamId}] Got unexpected message on CE-135 stream. Closing.`;
         sender.close();
     }
     onClose() { }
     sendWorkReport(sender, workReport) {
-        ce_135_work_report_distribution_logger.trace(`[${sender.streamId}] Sending guaranteed work report.`);
+        ce_135_work_report_distribution_logger.trace `[${sender.streamId}] Sending guaranteed work report.`;
         sender.bufferAndSend(Encoder.encodeObject(GuaranteedWorkReport.Codec, workReport, this.chainSpec));
         sender.close();
     }
@@ -55895,7 +55934,7 @@ class up_0_block_announcement_Handler {
             this.handshakes.set(streamId, handshake);
             // we didn't initiate this handshake, so let's respond
             if (!this.pendingHandshakes.delete(streamId)) {
-                up_0_block_announcement_logger.log(`[${streamId}] <-- responding with a handshake.`);
+                up_0_block_announcement_logger.log `[${streamId}] <-- responding with a handshake.`;
                 sender.bufferAndSend(encoder_Encoder.encodeObject(Handshake.Codec, this.getHandshake()));
             }
             this.onHandshake(streamId, handshake);
@@ -55903,7 +55942,7 @@ class up_0_block_announcement_Handler {
         }
         // it's just an announcement
         const annoucement = decoder_Decoder.decodeObject(Announcement.Codec, message, this.spec);
-        up_0_block_announcement_logger.log(`[${streamId}] --> got blocks announcement: ${annoucement.final}`);
+        up_0_block_announcement_logger.log `[${streamId}] --> got blocks announcement: ${annoucement.final}`;
         this.onAnnouncement(streamId, annoucement);
     }
     onClose(streamId) {
@@ -55916,7 +55955,7 @@ class up_0_block_announcement_Handler {
             return;
         }
         const handshake = this.getHandshake();
-        up_0_block_announcement_logger.trace(`[${streamId}] <-- sending handshake`);
+        up_0_block_announcement_logger.trace `[${streamId}] <-- sending handshake`;
         this.pendingHandshakes.set(sender.streamId, true);
         sender.bufferAndSend(encoder_Encoder.encodeObject(Handshake.Codec, handshake));
     }
@@ -55924,11 +55963,11 @@ class up_0_block_announcement_Handler {
         const { streamId } = sender;
         // only send announcement if we've handshaken
         if (this.handshakes.has(streamId)) {
-            up_0_block_announcement_logger.trace(`[${streamId}] <-- sending block announcement: ${annoucement.final}`);
+            up_0_block_announcement_logger.trace `[${streamId}] <-- sending block announcement: ${annoucement.final}`;
             sender.bufferAndSend(encoder_Encoder.encodeObject(Announcement.Codec, annoucement, this.spec));
         }
         else {
-            up_0_block_announcement_logger.warn(`[${streamId}] <-- no handshake yet, skipping announcement.`);
+            up_0_block_announcement_logger.warn `[${streamId}] <-- no handshake yet, skipping announcement.`;
         }
     }
 }
@@ -56045,7 +56084,7 @@ class SyncTask {
     onUp0Annoucement(peer, announcement) {
         const { hash, slot } = announcement.final;
         const bestHeader = hashHeader(announcement.header, this.spec);
-        sync_logger.info(`[${peer.id}] --> Received new header #${announcement.header.timeSlotIndex}: ${bestHeader.hash}`);
+        sync_logger.info `[${peer.id}] --> Received new header #${announcement.header.timeSlotIndex}: ${bestHeader.hash}`;
         // NOTE [ToDr] Instead of having `Connections` store aux data perhaps
         // we should maintain that directly? However that would require
         // listening to peers connected/disconnected to perfrom some cleanups
@@ -56120,7 +56159,7 @@ class SyncTask {
         const peers = this.connections.getConnectedPeers();
         for (const peerInfo of peers) {
             this.streamManager.withStreamOfKind(peerInfo.peerId, up_0_block_announcement_STREAM_KIND, (handler, sender) => {
-                sync_logger.log(`[${peerInfo.peerId}] <-- Broadcasting new header #${slot}: ${header.hash}`);
+                sync_logger.log `[${peerInfo.peerId}] <-- Broadcasting new header #${slot}: ${header.hash}`;
                 handler.sendAnnouncement(sender, annoucement);
                 return result_OK;
             });
@@ -56134,13 +56173,13 @@ class SyncTask {
         }
         if (res.error === BlockSequenceError.BlockOnFork) {
             // seems that peer is requesting syncing a fork from us, let's bail.
-            sync_logger.warn(`[${peer.id}] <-- Invalid block sequence request: ${startHash} is on a fork.`);
+            sync_logger.warn `[${peer.id}] --> Invalid block sequence request: ${startHash} is on a fork.`;
             return [];
         }
         if (res.error === BlockSequenceError.NoStartBlock) {
             // we don't know about that block at all, so let's just bail.
             // we should probably penalize the peer for sending BS?
-            sync_logger.warn(`[${peer.id}] <-- Invalid block sequence request: ${startHash} missing header or extrinsic.`);
+            sync_logger.warn `[${peer.id}] --> Invalid block sequence request: ${startHash} missing header or extrinsic.`;
             return [];
         }
         debug_assertNever(res.error);
@@ -56160,10 +56199,10 @@ class SyncTask {
         // figure out where others are at
         const othersBest = this.othersBest;
         const blocksToSync = othersBest.slot - ourBestSlot;
-        sync_logger.trace(`Our best. ${ourBestSlot}. Best seen: ${othersBest.slot}`);
+        sync_logger.trace `Our best. ${ourBestSlot}. Best seen: ${othersBest.slot}`;
         if (blocksToSync < 1) {
             this.connections.getPeerCount();
-            sync_logger.trace(`No new blocks. ${peerCount} peers.`);
+            sync_logger.trace `No new blocks. ${peerCount} peers.`;
             return {
                 kind: SyncResult.NoNewBlocks,
                 ours: ourBestSlot,
@@ -56171,7 +56210,7 @@ class SyncTask {
             };
         }
         const requested = [];
-        sync_logger.log(`Sync ${blocksToSync} blocks from ${peerCount} peers.`);
+        sync_logger.log `Sync ${blocksToSync} blocks from ${peerCount} peers.`;
         // NOTE [ToDr] We might be requesting the same blocks from many peers
         // which isn't very optimal, but for now: 🤷
         //
@@ -56197,12 +56236,12 @@ class SyncTask {
             // request as much blocks from that peer as possible.
             this.streamManager.withNewStream(peerInfo.peerRef, STREAM_KIND, (handler, sender) => {
                 handleAsyncErrors(async () => {
-                    sync_logger.log(`Fetching blocks from ${peerInfo.peerId}.`);
+                    sync_logger.log `[${peerInfo.peerId}] <-- Fetching ${bestSlot - ourBestSlot} blocks (${bestHash})`;
                     const blocks = await handler.requestBlockSequence(sender, bestHash, Direction.DescIncl, numbers_tryAsU32(bestSlot - ourBestSlot));
                     blocks.reverse();
                     this.onNewBlocks(blocks, peerInfo.peerId);
                 }, (e) => {
-                    sync_logger.warn(`[${peerInfo.peerId}] --> requesting blocks to import: ${e}`);
+                    sync_logger.warn `[${peerInfo.peerId}] <-- requesting blocks to import: ${e}`;
                 });
                 return result_OK;
             });
@@ -56276,7 +56315,7 @@ function setupPeerListeners(syncTask, network, streamManager) {
         // whenever the peer wants to open a stream with us, let's handle that.
         peer.addOnIncomingStream((stream) => {
             handleAsyncErrors(() => streamManager.onIncomingStream(peer, stream), (e) => {
-                network_logger.error(`[${peer.id}:${stream.streamId}]🚰  Stream error: ${e}. Disconnecting peer.`);
+                network_logger.error `[${peer.id}:${stream.streamId}]🚰  Stream error: ${e}. Disconnecting peer.`;
                 peer.disconnect();
             });
             return result_OK;
@@ -56526,10 +56565,10 @@ class FuzzTarget {
     async onSocketMessage(msg) {
         // attempt to decode the messsage
         const message = decoder_Decoder.decodeObject(messageCodec, msg, this.spec);
-        handler_logger.log(`[${message.type}] incoming message`);
+        handler_logger.log `[${message.type}] incoming message`;
         await processAndRespond(this.spec, message, this.msgHandler, this.sender).catch((e) => {
-            handler_logger.error(`Error while processing fuzz v0 message: ${e}`);
-            handler_logger.error(e);
+            handler_logger.error `Error while processing fuzz v0 message: ${e}`;
+            handler_logger.error `${e}`;
             this.sender.close();
         });
         return;
@@ -56570,17 +56609,17 @@ class FuzzTarget {
                     break;
                 }
                 case MessageType.State: {
-                    handler_logger.log(`--> Received unexpected 'State' message from the fuzzer. Closing.`);
+                    handler_logger.log `--> Received unexpected 'State' message from the fuzzer. Closing.`;
                     sender.close();
                     return;
                 }
                 case MessageType.StateRoot: {
-                    handler_logger.log(`--> Received unexpected 'StateRoot' message from the fuzzer. Closing.`);
+                    handler_logger.log `--> Received unexpected 'StateRoot' message from the fuzzer. Closing.`;
                     sender.close();
                     return;
                 }
                 default: {
-                    handler_logger.log(`--> Received unexpected message type ${JSON.stringify(message)} from the fuzzer. Closing.`);
+                    handler_logger.log `--> Received unexpected message type ${JSON.stringify(message)} from the fuzzer. Closing.`;
                     sender.close();
                     try {
                         debug_assertNever(message);
@@ -56591,17 +56630,17 @@ class FuzzTarget {
                 }
             }
             if (response !== null) {
-                handler_logger.trace(`<-- responding with: ${response.type}`);
+                handler_logger.trace `<-- responding with: ${response.type}`;
                 const encoded = encoder_Encoder.encodeObject(messageCodec, response, spec);
                 sender.send(encoded);
             }
             else {
-                handler_logger.warn(`<-- no response generated for: ${message.type}`);
+                handler_logger.warn `<-- no response generated for: ${message.type}`;
             }
         }
     }
     onClose({ error }) {
-        handler_logger.log(`Closing the handler. Reason: ${error !== undefined ? error.message : "close"}.`);
+        handler_logger.log `Closing the handler. Reason: ${error !== undefined ? error.message : "close"}.`;
     }
 }
@@ -56855,14 +56894,14 @@ class handler_FuzzTarget {
         // attempt to decode the messsage
         try {
             const message = decoder_Decoder.decodeObject(types_messageCodec, msg, this.spec);
-            v1_handler_logger.log(`[${message.type}] incoming message`);
+            v1_handler_logger.log `[${message.type}] incoming message`;
             await this.processAndRespond(message);
         }
         catch (e) {
-            v1_handler_logger.error(`Error while processing fuzz v1 message: ${e}`);
-            v1_handler_logger.error(`${e}`);
+            v1_handler_logger.error `Error while processing fuzz v1 message: ${e}`;
+            v1_handler_logger.error `${e}`;
             if (e instanceof Error) {
-                v1_handler_logger.error(e.stack ?? "");
+                v1_handler_logger.error `${e.stack ?? ""}`;
             }
             this.sender.close();
         }
@@ -56873,7 +56912,7 @@ class handler_FuzzTarget {
             case types_MessageType.PeerInfo: {
                 // only support V1
                 if (message.value.fuzzVersion !== 1) {
-                    v1_handler_logger.warn(`Unsupported fuzzer protocol version: ${message.value.fuzzVersion}. Closing`);
+                    v1_handler_logger.warn `Unsupported fuzzer protocol version: ${message.value.fuzzVersion}. Closing`;
                     this.sender.close();
                     return;
                 }
@@ -56881,9 +56920,9 @@ class handler_FuzzTarget {
                 const ourPeerInfo = await this.msgHandler.getPeerInfo(message.value);
                 // Calculate session features (intersection of both peer features)
                 this.sessionFeatures = message.value.features & ourPeerInfo.features;
-                v1_handler_logger.info(`Handshake completed. Shared features: 0b${this.sessionFeatures.toString(2)}`);
-                v1_handler_logger.log(`Feature ancestry: ${(this.sessionFeatures & Features.Ancestry) !== 0}`);
-                v1_handler_logger.log(`Feature fork: ${(this.sessionFeatures & Features.Fork) !== 0}`);
+                v1_handler_logger.info `Handshake completed. Shared features: 0b${this.sessionFeatures.toString(2)}`;
+                v1_handler_logger.log `Feature ancestry: ${(this.sessionFeatures & Features.Ancestry) !== 0}`;
+                v1_handler_logger.log `Feature fork: ${(this.sessionFeatures & Features.Fork) !== 0}`;
                 response = {
                     type: types_MessageType.PeerInfo,
                     value: ourPeerInfo,
@@ -56923,22 +56962,22 @@ class handler_FuzzTarget {
                 break;
             }
             case types_MessageType.StateRoot: {
-                v1_handler_logger.log(`--> Received unexpected 'StateRoot' message from the fuzzer. Closing.`);
+                v1_handler_logger.log `--> Received unexpected 'StateRoot' message from the fuzzer. Closing.`;
                 this.sender.close();
                 return;
             }
             case types_MessageType.State: {
-                v1_handler_logger.log(`--> Received unexpected 'State' message from the fuzzer. Closing.`);
+                v1_handler_logger.log `--> Received unexpected 'State' message from the fuzzer. Closing.`;
                 this.sender.close();
                 return;
             }
             case types_MessageType.Error: {
-                v1_handler_logger.log(`--> Received unexpected 'Error' message from the fuzzer. Closing.`);
+                v1_handler_logger.log `--> Received unexpected 'Error' message from the fuzzer. Closing.`;
                 this.sender.close();
                 return;
             }
             default: {
-                v1_handler_logger.log(`--> Received unexpected message type ${JSON.stringify(message)} from the fuzzer. Closing.`);
+                v1_handler_logger.log `--> Received unexpected message type ${JSON.stringify(message)} from the fuzzer. Closing.`;
                 this.sender.close();
                 try {
                     debug_assertNever(message);
@@ -56949,16 +56988,16 @@ class handler_FuzzTarget {
             }
         }
         if (response !== null) {
-            v1_handler_logger.trace(`<-- responding with: ${response.type}`);
+            v1_handler_logger.trace `<-- responding with: ${response.type}`;
             const encoded = encoder_Encoder.encodeObject(types_messageCodec, response, this.spec);
             this.sender.send(encoded);
         }
         else {
-            v1_handler_logger.warn(`<-- no response generated for: ${message.type}`);
+            v1_handler_logger.warn `<-- no response generated for: ${message.type}`;
         }
     }
     onClose({ error }) {
-        v1_handler_logger.log(`Closing the v1 handler. Reason: ${error !== undefined ? error.message : "close"}.`);
+        v1_handler_logger.log `Closing the v1 handler. Reason: ${error !== undefined ? error.message : "close"}.`;
     }
     /** Check if a specific feature is enabled in the session */
     hasFeature(feature) {
@@ -57004,7 +57043,7 @@ function startIpcServer(name, newMessageHandler) {
     const logger = Logger.new(import.meta.filename, "ext-ipc");
     // Create the IPC server
     const server = (0,external_node_net_namespaceObject.createServer)((socket) => {
-        logger.log("Client connected");
+        logger.log `Client connected`;
         const messageHandler = newMessageHandler(new IpcSender(socket));
         // Handle incoming data from the client
         socket.on("data", handleMessageFragmentation(async (data) => {
@@ -57016,23 +57055,23 @@ function startIpcServer(name, newMessageHandler) {
                 await messageHandler.onSocketMessage(data);
             }
             catch (e) {
-                logger.error(`Received invalid data on socket: ${e}. Closing connection.`);
+                logger.error `Received invalid data on socket: ${e}. Closing connection.`;
                 socket.end();
             }
             finally {
                 socket.resume();
             }
         }, () => {
-            logger.error("Received too much data on socket. Closing connection.");
+            logger.error `Received too much data on socket. Closing connection.`;
             socket.end();
         }));
         // Handle client disconnection
         socket.on("end", () => {
-            logger.log("Client disconnected");
+            logger.log `Client disconnected`;
             messageHandler.onClose({});
         });
         socket.on("error", (error) => {
-            logger.error(`Socket error: ${error}`);
+            logger.error `Socket error: ${error}`;
             messageHandler.onClose({ error });
             socket.end();
         });
@@ -57047,14 +57086,14 @@ function startIpcServer(name, newMessageHandler) {
         path: socketPath,
         signal: controller.signal,
     }, () => {
-        logger.log(`IPC server is listening at ${socketPath}`);
+        logger.log `IPC server is listening at ${socketPath}`;
     });
     // Handle server errors
     server.on("error", (err) => {
         throw err;
     });
     return () => {
-        logger.info("Closing IPC server.");
+        logger.info `Closing IPC server.`;
         // stop accepting new connections
         server.close();
         // abort the server
@@ -57199,7 +57238,7 @@ class JamnpIpcHandler {
         // decode the message as `StreamEnvelope`
         const envelope = decoder_Decoder.decodeObject(StreamEnvelope.Codec, msg);
         const streamId = envelope.streamId;
-        jamnp_handler_logger.log(`[${streamId}] incoming message: ${envelope.type} ${envelope.data}`);
+        jamnp_handler_logger.log `[${streamId}] incoming message: ${envelope.type} ${envelope.data}`;
         // check if this is a already known stream id
         const streamHandler = this.streams.get(streamId);
         const streamSender = new EnvelopeSender(streamId, this.sender);
@@ -57207,13 +57246,13 @@ class JamnpIpcHandler {
         if (streamHandler === undefined) {
             // closing or message of unknown stream - ignore.
             if (envelope.type !== StreamEnvelopeType.Open) {
-                jamnp_handler_logger.warn(`[${streamId}] (unknown) got invalid type ${envelope.type}.`);
+                jamnp_handler_logger.warn `[${streamId}] (unknown) got invalid type ${envelope.type}.`;
                 return;
             }
             const newStream = decoder_Decoder.decodeObject(NewStream.Codec, envelope.data);
             const handler = this.streamHandlers.get(newStream.streamByte);
             if (handler !== undefined) {
-                jamnp_handler_logger.log(`[${streamId}] new stream for ${handler.kind}`);
+                jamnp_handler_logger.log `[${streamId}] new stream for ${handler.kind}`;
                 // insert the stream
                 this.streams.set(streamId, handler);
                 // Just send back the same stream byte.
@@ -57234,7 +57273,7 @@ class JamnpIpcHandler {
         if (envelope.type !== StreamEnvelopeType.Msg) {
             // display a warning but only if the stream was not pending for confirmation.
             if (!this.pendingStreams.delete(streamId)) {
-                jamnp_handler_logger.warn(`[${streamId}] got invalid type ${envelope.type}.`);
+                jamnp_handler_logger.warn `[${streamId}] got invalid type ${envelope.type}.`;
             }
             return;
         }
@@ -57243,7 +57282,7 @@ class JamnpIpcHandler {
     }
     /** Notify about termination of the underlying socket. */
     onClose({ error }) {
-        jamnp_handler_logger.log(`Closing the handler. Reason: ${error !== undefined ? error.message : "close"}.`);
+        jamnp_handler_logger.log `Closing the handler. Reason: ${error !== undefined ? error.message : "close"}.`;
         // Socket closed - we should probably clear everything.
         for (const [streamId, handler] of this.streams.entries()) {
             handler.onClose(streamId, error === undefined);
@@ -57260,7 +57299,7 @@ class JamnpIpcHandler {
     }
     /** Wait for the handler to be finished either via close or error. */
     waitForEnd() {
-        jamnp_handler_logger.log("Waiting for the handler to be closed.");
+        jamnp_handler_logger.log `Waiting for the handler to be closed.`;
         return this.onEnd.listen;
     }
 }
@@ -57389,7 +57428,7 @@ class FuzzHandler {
     async getSerializedState(value) {
         const state = await this.api.getPostSerializedState(value);
         if (state === null) {
-            ipc_logger.warn(`Fuzzer requested non-existing state for: ${value}`);
+            ipc_logger.warn `Fuzzer requested non-existing state for: ${value}`;
             return [];
         }
         return Array.from(state).map(([key, value]) => {
@@ -57415,7 +57454,7 @@ class FuzzHandler {
         if (res.isOk) {
             return res;
         }
-        ipc_logger.log(`Rejecting block with error: ${res.error}. ${res.details}`);
+        ipc_logger.log `Rejecting block with error: ${res.error}. ${res.details}`;
         return result_Result.error(ErrorMessage.create({ message: res.error }));
     }
     async importBlockV0(value) {
@@ -57423,11 +57462,11 @@ class FuzzHandler {
         if (res.isOk) {
             return res.ok;
         }
-        ipc_logger.warn(`Fuzzer sent incorrect block with error ${res.error}. ${res.details}`);
+        ipc_logger.warn `Fuzzer sent incorrect block with error ${res.error}. ${res.details}`;
         return this.api.getBestStateRootHash();
     }
     async getPeerInfo(value) {
-        ipc_logger.info(`Fuzzer ${value} connected.`);
+        ipc_logger.info `Fuzzer ${value} connected.`;
         return types_PeerInfo.create({
             name: this.api.nodeName,
             appVersion: this.api.nodeVersion,
@@ -57438,7 +57477,7 @@ class FuzzHandler {
         });
     }
     async getPeerInfoV0(value) {
-        ipc_logger.info(`Fuzzer ${value} connected.`);
+        ipc_logger.info `Fuzzer ${value} connected.`;
         return PeerInfo.create({
             name: this.api.nodeName,
             appVersion: this.api.nodeVersion,
@@ -57471,7 +57510,7 @@ if (!external_node_worker_threads_namespaceObject.isMainThread) {
     Logger.configureAll(process.env.JAM_LOG ?? "", Level.LOG);
     const machine = networkStateMachine();
     const channel = MessageChannelStateMachine.receiveChannel(machine, external_node_worker_threads_namespaceObject.parentPort);
-    channel.then((channel) => jam_network_main(channel)).catch((e) => jam_network_logger.error(e));
+    channel.then((channel) => jam_network_main(channel)).catch((e) => jam_network_logger.error `${e}`);
 }
 /**
  * JAM networking worker.
@@ -57482,7 +57521,7 @@ if (!external_node_worker_threads_namespaceObject.isMainThread) {
  */
 async function jam_network_main(channel) {
     await initAll();
-    jam_network_logger.trace(`🛜 Network starting ${channel.currentState()}`);
+    jam_network_logger.trace `🛜 Network starting ${channel.currentState()}`;
     // Await the configuration object
     // TODO [ToDr] The whole state machine needs to die.
     const ready = channel.currentState().stateName !== "ready(network)"
@@ -57493,7 +57532,7 @@ async function jam_network_main(channel) {
         const key = await ed25519_privateKey(config.key);
         const lmdb = new LmdbRoot(config.genericConfig.dbPath);
         const blocks = new LmdbBlocks(config.genericConfig.chainSpec, lmdb);
-        jam_network_logger.info(`🛜 Listening at ${config.host}:${config.port}`);
+        jam_network_logger.info `🛜 Listening at ${config.host}:${config.port}`;
         const network = await setup({
             host: config.host,
             port: config.port,
@@ -57506,7 +57545,7 @@ async function jam_network_main(channel) {
         ready.waitForState("finished").then(() => network.network.stop());
         await network.network.start();
     });
-    jam_network_logger.info("🛜 Network worker finished. Closing channel.");
+    jam_network_logger.info `🛜 Network worker finished. Closing channel.`;
     // Close the comms to gracefuly close the app.
     finished.currentState().close(channel);
 }
@@ -57552,8 +57591,8 @@ async function main_main(config, withRelPath) {
         throw new Error("The main binary cannot be running as a Worker!");
     }
     await initAll();
-    common_logger.info(`🫐 Typeberry ${package_namespaceObject.rE}. GP: ${CURRENT_VERSION} (${CURRENT_SUITE})`);
-    common_logger.info(`🎸 Starting node: ${config.nodeName}.`);
+    common_logger.info `🫐 Typeberry ${package_namespaceObject.rE}. GP: ${CURRENT_VERSION} (${CURRENT_SUITE})`;
+    common_logger.info `🎸 Starting node: ${config.nodeName}.`;
     const chainSpec = getChainSpec(config.node.flavor);
     const { rootDb, dbPath, genesisHeaderHash } = openDatabase(config.nodeName, config.node.chainSpec.genesisHeader, withRelPath(config.node.databaseBasePath));
     // Initialize the database with genesis state and block if there isn't one.
@@ -57596,30 +57635,30 @@ async function main_main(config, withRelPath) {
                 return importer.finish(port);
             });
             await importerFinished.currentState().waitForWorkerToFinish();
-            common_logger.log("[main] ☠️  Closing the extensions");
+            common_logger.log `[main] ☠️  Closing the extensions`;
             closeExtensions();
-            common_logger.log("[main] ☠️  Closing the authorship module");
+            common_logger.log `[main] ☠️  Closing the authorship module`;
             closeAuthorship();
-            common_logger.log("[main] ☠️  Closing the networking module");
+            common_logger.log `[main] ☠️  Closing the networking module`;
             closeNetwork();
-            common_logger.log("[main] 🛢️ Closing the database");
+            common_logger.log `[main] 🛢️ Closing the database`;
             await rootDb.close();
-            common_logger.info("[main] ✅ Done.");
+            common_logger.info `[main] ✅ Done.`;
         },
     };
     return api;
 }
 const initAuthorship = async (importerReady, isAuthoring, config) => {
     if (!isAuthoring) {
-        common_logger.log("✍️  Authorship off: disabled");
+        common_logger.log `✍️  Authorship off: disabled`;
         return () => Promise.resolve();
     }
-    common_logger.info("✍️  Starting block generator.");
+    common_logger.info `✍️  Starting block generator.`;
     const { generator, finish } = await startBlockGenerator(config);
     // relay blocks from generator to importer
     importerReady.doUntil("finished", async (importer, port) => {
         generator.currentState().onBlock.on((b) => {
-            common_logger.log(`✍️  Produced block. Size: [${b.length}]`);
+            common_logger.log `✍️  Produced block. Size: [${b.length}]`;
             importer.sendBlock(port, b);
         });
     });
@@ -57627,7 +57666,7 @@ const initAuthorship = async (importerReady, isAuthoring, config) => {
 };
 const initNetwork = async (importerReady, workerConfig, genesisHeaderHash, networkConfig, bestHeader) => {
     if (networkConfig === null) {
-        common_logger.log("🛜 Networking off: no config");
+        common_logger.log `🛜 Networking off: no config`;
         return () => Promise.resolve();
     }
     const { key, host, port, bootnodes } = networkConfig;
@@ -59577,7 +59616,7 @@ class AccumulateExternalities {
         /** https://graypaper.fluffylabs.dev/#/7e6ff6a/362802362d02?v=0.6.7 */
         const validatorsManager = this.updatedState.getPrivilegedServices().validatorsManager;
         if (validatorsManager !== this.currentServiceId) {
-            accumulate_externalities_logger.trace(`Current service id (${this.currentServiceId}) is not a validators manager. (expected: ${validatorsManager}) and cannot update validators data. Ignoring`);
+            accumulate_externalities_logger.trace `Current service id (${this.currentServiceId}) is not a validators manager. (expected: ${validatorsManager}) and cannot update validators data. Ignoring`;
             return result_Result.error(UnprivilegedError);
         }
         this.updatedState.stateUpdate.validatorsData = validatorsData;
@@ -59592,11 +59631,11 @@ class AccumulateExternalities {
         // NOTE `coreIndex` is already verified in the HC, so this is infallible.
         const currentAuthManager = this.updatedState.getPrivilegedServices().authManager[coreIndex];
         if (currentAuthManager !== this.currentServiceId) {
-            accumulate_externalities_logger.trace(`Current service id (${this.currentServiceId}) is not an auth manager of core ${coreIndex} (expected: ${currentAuthManager}) and cannot update authorization queue. Ignoring`);
+            accumulate_externalities_logger.trace `Current service id (${this.currentServiceId}) is not an auth manager of core ${coreIndex} (expected: ${currentAuthManager}) and cannot update authorization queue. Ignoring`;
             return result_Result.error(UpdatePrivilegesError.UnprivilegedService);
         }
         if (authManager === null && Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)) {
-            accumulate_externalities_logger.trace("The new auth manager is not a valid service id. Ignoring");
+            accumulate_externalities_logger.trace `The new auth manager is not a valid service id. Ignoring`;
             return result_Result.error(UpdatePrivilegesError.InvalidServiceId);
         }
         this.updatedState.stateUpdate.authorizationQueues.set(coreIndex, authQueue);
@@ -60477,7 +60516,7 @@ class Assign {
         const memoryReadResult = memory.loadInto(res, authorizationQueueStart);
         // error while reading the memory.
         if (memoryReadResult.isError) {
-            logger_logger.trace("ASSIGN() <- PANIC");
+            logger_logger.trace `ASSIGN() <- PANIC`;
             return PvmExecution.Panic;
         }
         if (maybeCoreIndex >= this.chainSpec.coresCount) {
@@ -60492,18 +60531,18 @@ class Assign {
         const result = this.partialState.updateAuthorizationQueue(coreIndex, fixedSizeAuthQueue, authManager);
         if (result.isOk) {
             regs.set(IN_OUT_REG, HostCallResult.OK);
-            logger_logger.trace(`ASSIGN(${coreIndex}, ${fixedSizeAuthQueue}) <- OK`);
+            logger_logger.trace `ASSIGN(${coreIndex}, ${fixedSizeAuthQueue}) <- OK`;
             return;
         }
         const e = result.error;
         if (e === UpdatePrivilegesError.UnprivilegedService) {
             regs.set(IN_OUT_REG, HostCallResult.HUH);
-            logger_logger.trace(`ASSIGN(${coreIndex}, ${fixedSizeAuthQueue}) <- HUH`);
+            logger_logger.trace `ASSIGN(${coreIndex}, ${fixedSizeAuthQueue}) <- HUH`;
             return;
         }
         if (e === UpdatePrivilegesError.InvalidServiceId) {
             regs.set(IN_OUT_REG, HostCallResult.WHO);
-            logger_logger.trace(`ASSIGN(${coreIndex}, ${fixedSizeAuthQueue}) <- HUH`);
+            logger_logger.trace `ASSIGN(${coreIndex}, ${fixedSizeAuthQueue}) <- HUH`;
             return;
         }
         debug_assertNever(e);
@@ -60569,7 +60608,7 @@ class Bless {
             decoder.resetTo(0);
             const memoryReadResult = memory.loadInto(result, memIndex);
             if (memoryReadResult.isError) {
-                logger_logger.trace(`BLESS(${manager}, ${validator}) <- PANIC`);
+                logger_logger.trace `BLESS(${manager}, ${validator}) <- PANIC`;
                 return PvmExecution.Panic;
             }
             const { serviceId, gas } = decoder.object(serviceIdAndGasCodec);
@@ -60582,24 +60621,24 @@ class Bless {
         const authorizersDecoder = decoder_Decoder.fromBlob(res);
         const memoryReadResult = memory.loadInto(res, authorization);
         if (memoryReadResult.isError) {
-            logger_logger.trace(`BLESS(${manager}, ${validator}, ${autoAccumulateEntries}) <- PANIC`);
+            logger_logger.trace `BLESS(${manager}, ${validator}, ${autoAccumulateEntries}) <- PANIC`;
             return PvmExecution.Panic;
         }
         const authorizers = tryAsPerCore(authorizersDecoder.sequenceFixLen(descriptors_codec.u32.asOpaque(), this.chainSpec.coresCount), this.chainSpec);
         const updateResult = this.partialState.updatePrivilegedServices(manager, authorizers, validator, autoAccumulateEntries);
         if (updateResult.isOk) {
-            logger_logger.trace(`BLESS(${manager}, ${authorizers}, ${validator}, ${autoAccumulateEntries}) <- OK`);
+            logger_logger.trace `BLESS(${manager}, ${authorizers}, ${validator}, ${autoAccumulateEntries}) <- OK`;
             regs.set(bless_IN_OUT_REG, HostCallResult.OK);
             return;
         }
         const e = updateResult.error;
         if (e === UpdatePrivilegesError.UnprivilegedService) {
-            logger_logger.trace(`BLESS(${manager}, ${authorizers}, ${validator}, ${autoAccumulateEntries}) <- HUH`);
+            logger_logger.trace `BLESS(${manager}, ${authorizers}, ${validator}, ${autoAccumulateEntries}) <- HUH`;
             regs.set(bless_IN_OUT_REG, HostCallResult.HUH);
             return;
         }
         if (e === UpdatePrivilegesError.InvalidServiceId) {
-            logger_logger.trace(`BLESS(${manager}, ${authorizers}, ${validator}, ${autoAccumulateEntries}) <- WHO`);
+            logger_logger.trace `BLESS(${manager}, ${authorizers}, ${validator}, ${autoAccumulateEntries}) <- WHO`;
             regs.set(bless_IN_OUT_REG, HostCallResult.WHO);
             return;
         }
@@ -60629,7 +60668,7 @@ class GasHostCall {
     }
     execute(gas, regs) {
         const gasValue = gas.get();
-        logger_logger.trace(`GAS <- ${gasValue}`);
+        logger_logger.trace `GAS <- ${gasValue}`;
         regs.set(7, numbers_tryAsU64(gasValue));
         return Promise.resolve(undefined);
     }
@@ -60661,7 +60700,7 @@ class Checkpoint {
     async execute(gas, regs) {
         await this.gasHostCall.execute(gas, regs);
         this.partialState.checkpoint();
-        logger_logger.trace("CHECKPOINT()");
+        logger_logger.trace `CHECKPOINT()`;
         return;
     }
 }
@@ -60700,18 +60739,18 @@ class Designate {
         const memoryReadResult = memory.loadInto(res, validatorsStart);
         // error while reading the memory.
         if (memoryReadResult.isError) {
-            logger_logger.trace("DESIGNATE() <- PANIC");
+            logger_logger.trace `DESIGNATE() <- PANIC`;
             return PvmExecution.Panic;
         }
         const decoder = decoder_Decoder.fromBlob(res);
         const validatorsData = decoder.sequenceFixLen(ValidatorData.Codec, this.chainSpec.validatorsCount);
         const result = this.partialState.updateValidatorsData(tryAsPerValidator(validatorsData, this.chainSpec));
         if (result.isError) {
-            logger_logger.trace(`DESIGNATE([${validatorsData[0]}, ${validatorsData[1]}, ...]) <- HUH`);
+            logger_logger.trace `DESIGNATE([${validatorsData[0]}, ${validatorsData[1]}, ...]) <- HUH`;
             regs.set(designate_IN_OUT_REG, HostCallResult.HUH);
         }
         else {
-            logger_logger.trace(`DESIGNATE([${validatorsData[0]}, ${validatorsData[1]}, ...]) <- OK`);
+            logger_logger.trace `DESIGNATE([${validatorsData[0]}, ${validatorsData[1]}, ...]) <- OK`;
             regs.set(designate_IN_OUT_REG, HostCallResult.OK);
         }
     }
@@ -60752,17 +60791,17 @@ class Eject {
         const previousCodeHash = bytes_Bytes.zero(hash_HASH_SIZE).asOpaque();
         const memoryReadResult = memory.loadInto(previousCodeHash.raw, preimageHashStart);
         if (memoryReadResult.isError) {
-            logger_logger.trace(`EJECT(${serviceId}) <- PANIC`);
+            logger_logger.trace `EJECT(${serviceId}) <- PANIC`;
             return PvmExecution.Panic;
         }
         // cannot eject self
         if (serviceId === this.currentServiceId) {
             regs.set(eject_IN_OUT_REG, HostCallResult.WHO);
-            logger_logger.trace(`EJECT(${serviceId}, ${previousCodeHash}) <- WHO`);
+            logger_logger.trace `EJECT(${serviceId}, ${previousCodeHash}) <- WHO`;
             return;
         }
         const result = this.partialState.eject(serviceId, previousCodeHash);
-        logger_logger.trace(`EJECT(${serviceId}, ${previousCodeHash}) <- ${resultToString(result)}`);
+        logger_logger.trace `EJECT(${serviceId}, ${previousCodeHash}) <- ${resultToString(result)}`;
         // All good!
         if (result.isOk) {
             regs.set(eject_IN_OUT_REG, HostCallResult.OK);
@@ -60814,11 +60853,11 @@ class Forget {
         const memoryReadResult = memory.loadInto(hash.raw, hashStart);
         // error while reading the memory.
         if (memoryReadResult.isError) {
-            logger_logger.trace(`FORGET(${hash}, ${length}) <- PANIC`);
+            logger_logger.trace `FORGET(${hash}, ${length}) <- PANIC`;
             return PvmExecution.Panic;
         }
         const result = this.partialState.forgetPreimage(hash.asOpaque(), length);
-        logger_logger.trace(`FORGET(${hash}, ${length}) <- ${resultToString(result)}`);
+        logger_logger.trace `FORGET(${hash}, ${length}) <- ${resultToString(result)}`;
         if (result.isOk) {
             regs.set(forget_IN_OUT_REG, HostCallResult.OK);
         }
@@ -60871,11 +60910,11 @@ class New {
         const memoryReadResult = memory.loadInto(codeHash.raw, codeHashStart);
         // error while reading the memory.
         if (memoryReadResult.isError) {
-            logger_logger.trace(`NEW(${codeHash}, ${codeLength}, ${gas}, ${allowance}, ${gratisStorage}) <- PANIC`);
+            logger_logger.trace `NEW(${codeHash}, ${codeLength}, ${gas}, ${allowance}, ${gratisStorage}) <- PANIC`;
             return PvmExecution.Panic;
         }
         const assignedId = this.partialState.newService(codeHash.asOpaque(), codeLength, gas, allowance, gratisStorage);
-        logger_logger.trace(`NEW(${codeHash}, ${codeLength}, ${gas}, ${allowance}, ${gratisStorage}) <- ${resultToString(assignedId)}`);
+        logger_logger.trace `NEW(${codeHash}, ${codeLength}, ${gas}, ${allowance}, ${gratisStorage}) <- ${resultToString(assignedId)}`;
         if (assignedId.isOk) {
             regs.set(new_IN_OUT_REG, numbers_tryAsU64(assignedId.ok));
             return;
@@ -60930,11 +60969,11 @@ class Provide {
         const preimage = bytes_BytesBlob.blobFrom(new Uint8Array(length));
         const memoryReadResult = memory.loadInto(preimage.raw, preimageStart);
         if (memoryReadResult.isError) {
-            logger_logger.trace(`PROVIDE(${serviceId}, ${preimage.toStringTruncated()}) <- PANIC`);
+            logger_logger.trace `PROVIDE(${serviceId}, ${preimage.toStringTruncated()}) <- PANIC`;
             return PvmExecution.Panic;
         }
         const result = this.partialState.providePreimage(serviceId, preimage);
-        logger_logger.trace(`PROVIDE(${serviceId}, ${preimage.toStringTruncated()}) <- ${resultToString(result)}`);
+        logger_logger.trace `PROVIDE(${serviceId}, ${preimage.toStringTruncated()}) <- ${resultToString(result)}`;
         if (result.isOk) {
             regs.set(provide_IN_OUT_REG, HostCallResult.OK);
             return;
@@ -60988,11 +61027,11 @@ class Query {
         const memoryReadResult = memory.loadInto(hash.raw, hashStart);
         // error while reading the memory.
         if (memoryReadResult.isError) {
-            logger_logger.trace(`QUERY(${hash}, ${length}) <- PANIC`);
+            logger_logger.trace `QUERY(${hash}, ${length}) <- PANIC`;
             return PvmExecution.Panic;
         }
         const result = this.partialState.checkPreimageStatus(hash.asOpaque(), length);
-        logger_logger.trace(`QUERY(${hash}, ${length}) <- ${result}`);
+        logger_logger.trace `QUERY(${hash}, ${length}) <- ${result}`;
         const zero = numbers_tryAsU64(0n);
         if (result === null) {
             regs.set(IN_OUT_REG_1, HostCallResult.NONE);
@@ -61053,11 +61092,11 @@ class Solicit {
         const hash = bytes_Bytes.zero(hash_HASH_SIZE);
         const memoryReadResult = memory.loadInto(hash.raw, hashStart);
         if (memoryReadResult.isError) {
-            logger_logger.trace(`SOLICIT(${hash}, ${length}) <- PANIC`);
+            logger_logger.trace `SOLICIT(${hash}, ${length}) <- PANIC`;
             return PvmExecution.Panic;
         }
         const result = this.partialState.requestPreimage(hash.asOpaque(), length);
-        logger_logger.trace(`SOLICIT(${hash}, ${length}) <- ${resultToString(result)}`);
+        logger_logger.trace `SOLICIT(${hash}, ${length}) <- ${resultToString(result)}`;
         if (result.isOk) {
             regs.set(solicit_IN_OUT_REG, HostCallResult.OK);
             return;
@@ -61129,11 +61168,11 @@ class Transfer {
         const memoryReadResult = memory.loadInto(memo.raw, memoStart);
         // page fault while reading the memory.
         if (memoryReadResult.isError) {
-            logger_logger.trace(`TRANSFER(${destination}, ${amount}, ${onTransferGas}, ${memo}) <- PANIC`);
+            logger_logger.trace `TRANSFER(${destination}, ${amount}, ${onTransferGas}, ${memo}) <- PANIC`;
             return PvmExecution.Panic;
         }
         const transferResult = this.partialState.transfer(destination, amount, onTransferGas, memo);
-        logger_logger.trace(`TRANSFER(${destination}, ${amount}, ${onTransferGas}, ${memo}) <- ${resultToString(transferResult)}`);
+        logger_logger.trace `TRANSFER(${destination}, ${amount}, ${onTransferGas}, ${memo}) <- ${resultToString(transferResult)}`;
         // All good!
         if (transferResult.isOk) {
             regs.set(transfer_IN_OUT_REG, HostCallResult.OK);
@@ -61192,11 +61231,11 @@ class Upgrade {
         const codeHash = bytes_Bytes.zero(hash_HASH_SIZE);
         const memoryReadResult = memory.loadInto(codeHash.raw, codeHashStart);
         if (memoryReadResult.isError) {
-            logger_logger.trace(`UPGRADE(${codeHash}, ${gas}, ${allowance}) <- PANIC`);
+            logger_logger.trace `UPGRADE(${codeHash}, ${gas}, ${allowance}) <- PANIC`;
             return PvmExecution.Panic;
         }
         this.partialState.upgradeService(codeHash.asOpaque(), gas, allowance);
-        logger_logger.trace(`UPGRADE(${codeHash}, ${gas}, ${allowance})`);
+        logger_logger.trace `UPGRADE(${codeHash}, ${gas}, ${allowance})`;
         regs.set(upgrade_IN_OUT_REG, HostCallResult.OK);
     }
 }
@@ -61230,11 +61269,11 @@ class Yield {
         const hash = bytes_Bytes.zero(hash_HASH_SIZE);
         const memoryReadResult = memory.loadInto(hash.raw, hashStart);
         if (memoryReadResult.isError) {
-            logger_logger.trace("YIELD() <- PANIC");
+            logger_logger.trace `YIELD() <- PANIC`;
             return PvmExecution.Panic;
         }
         this.partialState.yield(hash);
-        logger_logger.trace(`YIELD(${hash})`);
+        logger_logger.trace `YIELD(${hash})`;
         regs.set(yield_IN_OUT_REG, HostCallResult.OK);
     }
 }
@@ -61276,10 +61315,10 @@ class Fetch {
         const chunk = value === null ? new Uint8Array() : value.raw.subarray(Number(offset), Number(offset + length));
         const storeResult = memory.storeFrom(output, chunk);
         if (storeResult.isError) {
-            logger_logger.trace(`FETCH(${kind}) <- PANIC`);
+            logger_logger.trace `FETCH(${kind}) <- PANIC`;
             return PvmExecution.Panic;
         }
-        logger_logger.trace(`FETCH(${kind}) <- ${value?.toStringTruncated()}`);
+        logger_logger.trace `FETCH(${kind}) <- ${value?.toStringTruncated()}`;
         // write result
         regs.set(fetch_IN_OUT_REG, value === null ? HostCallResult.NONE : valueLength);
     }
@@ -61438,10 +61477,10 @@ class Info {
         const chunk = encodedInfo.raw.subarray(Number(offset), Number(offset + length));
         const writeResult = memory.storeFrom(outputStart, chunk);
         if (writeResult.isError) {
-            logger_logger.trace(`INFO(${serviceId}) <- PANIC`);
+            logger_logger.trace `INFO(${serviceId}) <- PANIC`;
             return PvmExecution.Panic;
         }
-        logger_logger.trace(`INFO(${serviceId}) <- ${bytes_BytesBlob.blobFrom(chunk)}`);
+        logger_logger.trace `INFO(${serviceId}) <- ${bytes_BytesBlob.blobFrom(chunk)}`;
         if (accountInfo === null) {
             regs.set(info_IN_OUT_REG, HostCallResult.NONE);
             return;
@@ -61502,7 +61541,7 @@ class LogHostCall {
             memory.loadInto(target, targetStart);
         }
         memory.loadInto(message, msgStart);
-        logger_logger.trace(`SERVICE [${this.currentServiceId}] [${lvl}] ${decoder.decode(target)} ${decoder.decode(message)}`);
+        logger_logger.trace `SERVICE [${this.currentServiceId}] [${lvl}] ${decoder.decode(target)} ${decoder.decode(message)}`;
         return Promise.resolve(undefined);
     }
 }
@@ -61542,12 +61581,12 @@ class Lookup {
         const preImageHash = bytes_Bytes.zero(hash_HASH_SIZE);
         const memoryReadResult = memory.loadInto(preImageHash.raw, hashAddress);
         if (memoryReadResult.isError) {
-            logger_logger.trace(`LOOKUP(${serviceId}, ${preImageHash}) <- PANIC`);
+            logger_logger.trace `LOOKUP(${serviceId}, ${preImageHash}) <- PANIC`;
             return PvmExecution.Panic;
         }
         // v
         const preImage = this.account.lookup(serviceId, preImageHash);
-        logger_logger.trace(`LOOKUP(${serviceId}, ${preImageHash}) <- ${preImage?.toStringTruncated()}...`);
+        logger_logger.trace `LOOKUP(${serviceId}, ${preImageHash}) <- ${preImage?.toStringTruncated()}...`;
         const preImageLength = preImage === null ? numbers_tryAsU64(0) : numbers_tryAsU64(preImage.raw.length);
         const preimageBlobOffset = regs.get(10);
         const lengthToWrite = regs.get(11);
@@ -61609,7 +61648,7 @@ class Read {
         const rawKey = bytes_BytesBlob.blobFrom(new Uint8Array(storageKeyLengthClamped));
         const memoryReadResult = memory.loadInto(rawKey.raw, storageKeyStartAddress);
         if (memoryReadResult.isError) {
-            logger_logger.trace(`READ(${serviceId}, ${rawKey}) <- PANIC`);
+            logger_logger.trace `READ(${serviceId}, ${rawKey}) <- PANIC`;
             return PvmExecution.Panic;
         }
         // v
@@ -61627,15 +61666,15 @@ class Read {
         const chunk = value === null ? new Uint8Array(0) : value.raw.subarray(Number(offset), Number(offset + blobLength));
         const memoryWriteResult = memory.storeFrom(destinationAddress, chunk);
         if (memoryWriteResult.isError) {
-            logger_logger.trace(`READ(${serviceId}, ${rawKey}) <- PANIC`);
+            logger_logger.trace `READ(${serviceId}, ${rawKey}) <- PANIC`;
             return PvmExecution.Panic;
         }
         if (value === null) {
-            logger_logger.trace(`READ(${serviceId}, ${rawKey}) <- NONE`);
+            logger_logger.trace `READ(${serviceId}, ${rawKey}) <- NONE`;
             regs.set(read_IN_OUT_REG, HostCallResult.NONE);
             return;
         }
-        logger_logger.trace(`READ(${serviceId}, ${rawKey}) <- ${bytes_BytesBlob.blobFrom(chunk).toStringTruncated()}`);
+        logger_logger.trace `READ(${serviceId}, ${rawKey}) <- ${bytes_BytesBlob.blobFrom(chunk).toStringTruncated()}`;
         regs.set(read_IN_OUT_REG, valueLength);
     }
 }
@@ -61678,7 +61717,7 @@ class Write {
         const rawStorageKey = new Uint8Array(storageKeyLengthClamped);
         const keyLoadingResult = memory.loadInto(rawStorageKey, storageKeyStartAddress);
         if (keyLoadingResult.isError) {
-            logger_logger.trace("WRITE() <- PANIC");
+            logger_logger.trace `WRITE() <- PANIC`;
             return PvmExecution.Panic;
         }
         // k
@@ -61688,14 +61727,14 @@ class Write {
         const valueLoadingResult = memory.loadInto(value, valueStart);
         // Note [MaSo] this is ok to return bcs if valueLength is 0, then this panic won't happen
         if (valueLoadingResult.isError) {
-            logger_logger.trace(`WRITE(${storageKey})}) <- PANIC`);
+            logger_logger.trace `WRITE(${storageKey}) <- PANIC`;
             return PvmExecution.Panic;
         }
         /** https://graypaper.fluffylabs.dev/#/9a08063/33af0133b201?v=0.6.6 */
         const maybeValue = valueLength === 0n ? null : bytes_BytesBlob.blobFrom(value);
         // a
         const result = this.account.write(storageKey, maybeValue);
-        logger_logger.trace(`WRITE(${storageKey}, ${maybeValue?.toStringTruncated()}) <- ${resultToString(result)}`);
+        logger_logger.trace `WRITE(${storageKey}, ${maybeValue?.toStringTruncated()}) <- ${resultToString(result)}`;
         if (result.isError) {
             regs.set(write_IN_OUT_REG, HostCallResult.FULL);
             return;
@@ -61887,18 +61926,18 @@ class Accumulate {
     async pvmAccumulateInvocation(slot, serviceId, operands, gas, entropy, inputStateUpdate) {
         const service = this.state.getService(serviceId);
         if (service === null) {
-            accumulate_logger.log(`Service with id ${serviceId} not found.`);
+            accumulate_logger.log `Service with id ${serviceId} not found.`;
             return result_Result.error(PvmInvocationError.NoService);
         }
         const codeHash = service.getInfo().codeHash;
         // TODO [ToDr] Should we check that the preimage is still available?
         const code = service.getPreimage(codeHash.asOpaque());
         if (code === null) {
-            accumulate_logger.log(`Code with hash ${codeHash} not found for service ${serviceId}.`);
+            accumulate_logger.log `Code with hash ${codeHash} not found for service ${serviceId}.`;
             return result_Result.error(PvmInvocationError.NoPreimage);
         }
         if (code.length > W_C) {
-            accumulate_logger.log(`Code with hash ${codeHash} is too long for service ${serviceId}.`);
+            accumulate_logger.log `Code with hash ${codeHash} is too long for service ${serviceId}.`;
             return result_Result.error(PvmInvocationError.PreimageTooLong);
         }
         const nextServiceId = generateNextServiceId({ serviceId, entropy, timeslot: slot }, this.chainSpec);
@@ -61920,10 +61959,10 @@ class Accumulate {
         if (result.hasStatus()) {
             const status = result.status;
             if (status === status_Status.OOG || status === status_Status.PANIC) {
-                accumulate_logger.trace(`[${serviceId}] accumulate finished with ${status_Status[status]} reverting to checkpoint.`);
+                accumulate_logger.trace `[${serviceId}] accumulate finished with ${status_Status[status]} reverting to checkpoint.`;
                 return result_Result.ok({ stateUpdate: checkpoint, consumedGas: common_tryAsServiceGas(result.consumedGas) });
             }
-            accumulate_logger.trace(`[${serviceId}] accumulate finished with ${status_Status[status]}`);
+            accumulate_logger.trace `[${serviceId}] accumulate finished with ${status_Status[status]}`;
         }
         /**
          * PVM invocation returned a hash so we override whatever `yield` host call
@@ -61948,14 +61987,14 @@ class Accumulate {
      * https://graypaper.fluffylabs.dev/#/7e6ff6a/18d70118d701?v=0.6.7
      */
     async accumulateSingleService(serviceId, operands, gasCost, slot, entropy, inputStateUpdate) {
-        accumulate_logger.log(`Accumulating service ${serviceId}, items: ${operands.length} at slot: ${slot}.`);
+        accumulate_logger.log `Accumulating service ${serviceId}, items: ${operands.length} at slot: ${slot}.`;
         const result = await this.pvmAccumulateInvocation(slot, serviceId, operands, gasCost, entropy, inputStateUpdate);
         if (result.isError) {
             // https://graypaper.fluffylabs.dev/#/7e6ff6a/2fb6012fb601?v=0.6.7
-            accumulate_logger.log(`Accumulation failed for ${serviceId}.`);
+            accumulate_logger.log `Accumulation failed for ${serviceId}.`;
             return { stateUpdate: null, consumedGas: 0n };
         }
-        accumulate_logger.log(`Accumulation successful for ${serviceId}. Consumed: ${result.ok.consumedGas}`);
+        accumulate_logger.log `Accumulation successful for ${serviceId}. Consumed: ${result.ok.consumedGas}`;
         return result.ok;
     }
     /**
@@ -62017,7 +62056,7 @@ class Accumulate {
             if (Compatibility.is(GpVersion.V0_7_0) && serviceId === currentManager) {
                 const newV = currentState.privilegedServices?.validatorsManager;
                 if (currentState.privilegedServices !== null && newV !== undefined && serviceIds.includes(newV)) {
-                    accumulate_logger.info("Entering completely incorrect code that probably reverts validatorsManager change. This is valid in 0.7.0 only and incorrect in 0.7.1+");
+                    accumulate_logger.info `Entering completely incorrect code that probably reverts validatorsManager change. This is valid in 0.7.0 only and incorrect in 0.7.1+`;
                     // Since serviceIds already contains newV, this service gets accumulated twice.
                     // To avoid double-counting, we skip stats and gas cost tracking here.
                     // We need this accumulation to get the correct `validatorsManager`
@@ -62200,13 +62239,13 @@ class DeferredTransfers {
             const isCodeCorrect = code !== null && code.length <= W_C;
             if (!hasTransfers || !isCodeCorrect) {
                 if (code === null) {
-                    deferred_transfers_logger.trace(`Skipping ON_TRANSFER execution for service ${serviceId} because code is null`);
+                    deferred_transfers_logger.trace `Skipping ON_TRANSFER execution for service ${serviceId} because code is null`;
                 }
                 else if (!hasTransfers) {
-                    deferred_transfers_logger.trace(`Skipping ON_TRANSFER execution for service ${serviceId} because there are no transfers`);
+                    deferred_transfers_logger.trace `Skipping ON_TRANSFER execution for service ${serviceId} because there are no transfers`;
                 }
                 else {
-                    deferred_transfers_logger.trace(`Skipping ON_TRANSFER execution for service ${serviceId} because code is too long`);
+                    deferred_transfers_logger.trace `Skipping ON_TRANSFER execution for service ${serviceId} because code is too long`;
                 }
             }
             else {
@@ -62834,7 +62873,7 @@ function verifyRefineContexts(minLookupSlot, contexts, recentBlocksPartialUpdate
             headerChain.isAncestor(context.lookupAnchorSlot, context.lookupAnchor, context.anchor);
         if (!isInChain) {
             if (process.env.SKIP_LOOKUP_ANCHOR_CHECK !== undefined) {
-                verify_contextual_logger.warn(`Lookup anchor check for ${context.lookupAnchor} would fail, but override is active.`);
+                verify_contextual_logger.warn `Lookup anchor check for ${context.lookupAnchor} would fail, but override is active.`;
             }
             else {
                 return result_Result.error(ReportsError.SegmentRootLookupInvalid, `Lookup anchor is not found in chain. Hash: ${context.lookupAnchor} (slot: ${context.lookupAnchorSlot})`);
@@ -63721,7 +63760,7 @@ class OnChain {
             reports: availableReports,
             entropy: entropy[0],
         });
-        chain_stf_logger.log(timerAccumulate());
+        chain_stf_logger.log `${timerAccumulate()}`;
         if (accumulateResult.isError) {
             return stfError(StfErrorKind.Accumulate, accumulateResult);
         }
@@ -63852,7 +63891,7 @@ class Importer {
         this.stf = new OnChain(spec, state, blocks, hasher);
         this.state = state;
         this.currentHash = currentBestHeaderHash;
-        logger.info(`😎 Best time slot: ${state.timeslot} (header hash: ${currentBestHeaderHash})`);
+        logger.info `😎 Best time slot: ${state.timeslot} (header hash: ${currentBestHeaderHash})`;
     }
     async importBlock(block, omitSealVerification) {
         const timer = measure("importBlock");
@@ -63860,20 +63899,20 @@ class Importer {
         const maybeBestHeader = await this.importBlockInternal(block, omitSealVerification);
         if (maybeBestHeader.isOk) {
             const bestHeader = maybeBestHeader.ok;
-            this.logger.info(`🧊 Best block: #${timeSlot} (${bestHeader.hash})`);
-            this.logger.log(timer());
+            this.logger.info `🧊 Best block: #${timeSlot} (${bestHeader.hash})`;
+            this.logger.log `${timer()}`;
             return maybeBestHeader;
         }
-        this.logger.log(`❌ Rejected block #${timeSlot}: ${resultToString(maybeBestHeader)}`);
-        this.logger.log(timer());
+        this.logger.log `❌ Rejected block #${timeSlot}: ${resultToString(maybeBestHeader)}`;
+        this.logger.log `${timer()}`;
         return maybeBestHeader;
     }
     async importBlockInternal(block, omitSealVerification = false) {
         const logger = this.logger;
-        logger.log("🧱 Attempting to import a new block");
+        logger.log `🧱 Attempting to import a new block`;
         const timerVerify = measure("import:verify");
         const hash = await this.verifier.verifyBlock(block);
-        logger.log(timerVerify());
+        logger.log `${timerVerify()}`;
         if (hash.isError) {
             return importerError(ImporterErrorKind.Verifier, hash);
         }
@@ -63893,10 +63932,10 @@ class Importer {
         }
         const timeSlot = block.header.view().timeSlotIndex.materialize();
         const headerHash = hash.ok;
-        logger.log(`🧱 Verified block: Got hash ${headerHash} for block at slot ${timeSlot}.`);
+        logger.log `🧱 Verified block: Got hash ${headerHash} for block at slot ${timeSlot}.`;
         const timerStf = measure("import:stf");
         const res = await this.stf.transition(block, headerHash, omitSealVerification);
-        logger.log(timerStf());
+        logger.log `${timerStf()}`;
         if (res.isError) {
             return importerError(ImporterErrorKind.Stf, res);
         }
@@ -63905,7 +63944,7 @@ class Importer {
         const timerState = measure("import:state");
         const updateResult = await this.states.updateAndSetState(headerHash, this.state, update);
         if (updateResult.isError) {
-            logger.error(`🧱 Unable to update state: ${resultToString(updateResult)}`);
+            logger.error `🧱 Unable to update state: ${resultToString(updateResult)}`;
             return importerError(ImporterErrorKind.Update, updateResult);
         }
         const newState = this.states.getState(headerHash);
@@ -63916,17 +63955,17 @@ class Importer {
         // the state of a parent block to support forks and create a fresh STF.
         this.state.updateBackend(newState.backend);
         this.currentHash = headerHash;
-        logger.log(timerState());
+        logger.log `${timerState()}`;
         // insert new state and the block to DB.
         const timerDb = measure("import:db");
         const writeBlocks = this.blocks.insertBlock(new WithHash(headerHash, block));
         // Computation of the state root may happen asynchronously,
         // but we still need to wait for it before next block can be imported
         const stateRoot = await this.states.getStateRoot(newState);
-        logger.log(`🧱 Storing post-state-root for ${headerHash}: ${stateRoot}.`);
+        logger.log `🧱 Storing post-state-root for ${headerHash}: ${stateRoot}.`;
         const writeStateRoot = this.blocks.setPostStateRoot(headerHash, stateRoot);
         await Promise.all([writeBlocks, writeStateRoot]);
-        logger.log(timerDb());
+        logger.log `${timerDb()}`;
         // finally update the best block
         await this.blocks.setBestHeaderHash(headerHash);
         return result_Result.ok(new WithHash(headerHash, block.header.view()));
@@ -63974,7 +64013,7 @@ if (!external_node_worker_threads_namespaceObject.isMainThread) {
     Logger.configureAll(process.env.JAM_LOG ?? "", Level.LOG);
     const machine = importerStateMachine();
     const channel = MessageChannelStateMachine.receiveChannel(machine, external_node_worker_threads_namespaceObject.parentPort);
-    channel.then((channel) => importer_main(channel)).catch((e) => importer_logger.error(e));
+    channel.then((channel) => importer_main(channel)).catch((e) => importer_logger.error `${e}`);
 }
 const keccakHasher = KeccakHasher.create();
 async function createImporter(config) {
@@ -63996,7 +64035,7 @@ async function createImporter(config) {
  */
 async function importer_main(channel) {
     const wasmPromise = initAll();
-    importer_logger.info(`📥 Importer starting ${channel.currentState()}`);
+    importer_logger.info `📥 Importer starting ${channel.currentState()}`;
     // Await the configuration object
     const ready = await channel.waitForState("ready(importer)");
     let closeDb = async () => { };
@@ -64008,7 +64047,7 @@ async function importer_main(channel) {
         };
         // TODO [ToDr] this is shit, since we have circular dependency.
         worker.setImporter(importer);
-        importer_logger.info("📥 Importer waiting for blocks.");
+        importer_logger.info `📥 Importer waiting for blocks.`;
         worker.onBlock.on(async (block) => {
             const res = await importer.importBlock(block, config.omitSealVerification);
             if (res.isOk) {
@@ -64017,7 +64056,7 @@ async function importer_main(channel) {
         });
         await wasmPromise;
     });
-    importer_logger.info("📥 Importer finished. Closing channel.");
+    importer_logger.info `📥 Importer finished. Closing channel.`;
     // close the database
     await closeDb();
     // Close the comms to gracefuly close the app.
@@ -64038,8 +64077,8 @@ async function importer_main(channel) {
 const zeroHash = bytes_Bytes.zero(hash_HASH_SIZE).asOpaque();
 async function mainImporter(config, withRelPath) {
     await initAll();
-    common_logger.info(`🫐 Typeberry ${package_namespaceObject.rE}. GP: ${CURRENT_VERSION} (${CURRENT_SUITE})`);
-    common_logger.info(`🎸 Starting importer: ${config.nodeName}.`);
+    common_logger.info `🫐 Typeberry ${package_namespaceObject.rE}. GP: ${CURRENT_VERSION} (${CURRENT_SUITE})`;
+    common_logger.info `🎸 Starting importer: ${config.nodeName}.`;
     const chainSpec = getChainSpec(config.node.flavor);
     const { rootDb, dbPath, genesisHeaderHash } = openDatabase(config.nodeName, config.node.chainSpec.genesisHeader, withRelPath(config.node.databaseBasePath));
     // Initialize the database with genesis state and block if there isn't one.
@@ -64066,9 +64105,9 @@ async function mainImporter(config, withRelPath) {
             return importer.getBestStateRootHash() ?? zeroHash;
         },
         async close() {
-            common_logger.log("[main] 🛢️ Closing the database");
+            common_logger.log `[main] 🛢️ Closing the database`;
             await lmdb.close();
-            common_logger.info("[main] ✅ Done.");
+            common_logger.info `[main] ✅ Done.`;
         },
     };
     return api;
@@ -64095,7 +64134,7 @@ function getFuzzDetails() {
     };
 }
 async function mainFuzz(fuzzConfig, withRelPath) {
-    main_fuzz_logger.info(`💨 Fuzzer V${fuzzConfig.version} starting up.`);
+    main_fuzz_logger.info `💨 Fuzzer V${fuzzConfig.version} starting up.`;
     const { jamNodeConfig: config } = fuzzConfig;
     let runningNode = null;
     const fuzzSeed = BigInt(Date.now());
@@ -64165,20 +64204,20 @@ async function mainFuzz(fuzzConfig, withRelPath) {
 const importBlocks = async (node, blocksToImport) => {
     const logger = Logger.new(import.meta.filename, "jam");
-    logger.info(`📖 Reading ${blocksToImport.length} blocks`);
+    logger.info `📖 Reading ${blocksToImport.length} blocks`;
     const reader = startBlocksReader({
         files: blocksToImport,
         chainSpec: node.chainSpec,
     });
     for (const block of reader) {
-        logger.log(`📖 Importing block: #${block.header.view().timeSlotIndex.materialize()}`);
+        logger.log `📖 Importing block: #${block.header.view().timeSlotIndex.materialize()}`;
         const res = await node.importBlock(block);
         if (res.isError) {
-            logger.error(`📖 ${resultToString(res)}`);
+            logger.error `📖 ${resultToString(res)}`;
         }
     }
     // close the importer.
-    logger.info("All blocks scheduled to be imported.");
+    logger.info `All blocks scheduled to be imported.`;
     return await node.close();
 };
 function* startBlocksReader(options) {
@@ -64375,6 +64414,7 @@ function parseFuzzVersion(v) {
 const prepareConfigFile = (args) => {
     const nodeConfig = loadConfig(args.args.configPath);
     const nodeName = args.command === Command.Dev ? `${args.args.nodeName}-${args.args.index}` : args.args.nodeName;
@@ -64401,14 +64441,8 @@ const prepareConfigFile = (args) => {
 };
 if (import.meta.url === (0,external_node_url_namespaceObject.pathToFileURL)(process.argv[1]).href) {
     Logger.configureAll(process.env.JAM_LOG ?? "", Level.LOG);
-    const relPath = `${import.meta.dirname}/../..`;
-    const withRelPath = (p) => {
-        if (p.startsWith("/")) {
-            return p;
-        }
-        return `${relPath}/${p}`;
-    };
     let args;
+    const withRelPath = workspacePathFix(`${import.meta.dirname}/../..`);
     try {
         const parsed = parseArgs(process.argv.slice(2), withRelPath);
         if (parsed === null) {