@typeberry/jam 0.1.1 → 0.1.2-3178190

package/index.js

@@ -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__ = ({
@@ -28243,6 +28244,7 @@ var GpVersion;
     GpVersion["V0_6_7"] = "0.6.7";
     GpVersion["V0_7_0"] = "0.7.0";
     GpVersion["V0_7_1"] = "0.7.1-preview";
+    GpVersion["V0_7_2"] = "0.7.2-preview";
 })(GpVersion || (GpVersion = {}));
 var TestSuite;
 (function (TestSuite) {
@@ -28250,7 +28252,7 @@ var TestSuite;
     TestSuite["JAMDUNA"] = "jamduna";
 })(TestSuite || (TestSuite = {}));
 const DEFAULT_SUITE = TestSuite.W3F_DAVXY;
-const ALL_VERSIONS_IN_ORDER = [GpVersion.V0_6_7, GpVersion.V0_7_0, GpVersion.V0_7_1];
+const ALL_VERSIONS_IN_ORDER = [GpVersion.V0_6_7, GpVersion.V0_7_0, GpVersion.V0_7_1, GpVersion.V0_7_2];
 const env = typeof process === "undefined" ? {} : process.env;
 const DEFAULT_VERSION = GpVersion.V0_7_0;
 let CURRENT_VERSION = parseCurrentVersion(env.GP_VERSION) ?? DEFAULT_VERSION;
@@ -28259,20 +28261,26 @@ function parseCurrentVersion(env) {
     if (env === undefined) {
         return undefined;
     }
-    const version = env;
-    if (!Object.values(GpVersion).includes(version)) {
-        throw new Error(`Configured environment variable GP_VERSION is unknown: '${env}'. Use one of: ${ALL_VERSIONS_IN_ORDER}`);
+    switch (env) {
+        case GpVersion.V0_6_7:
+        case GpVersion.V0_7_0:
+        case GpVersion.V0_7_1:
+        case GpVersion.V0_7_2:
+            return env;
+        default:
+            throw new Error(`Configured environment variable GP_VERSION is unknown: '${env}'. Use one of: ${ALL_VERSIONS_IN_ORDER}`);
     }
-    return version;
 }
 function parseCurrentSuite(env) {
     if (env === undefined)
         return undefined;
-    const val = env;
-    if (!Object.values(TestSuite).includes(val)) {
-        throw new Error(`Configured environment variable TEST_SUITE is unknown: '${env}'. Use one of: ${Object.values(TestSuite)}`);
+    switch (env) {
+        case TestSuite.W3F_DAVXY:
+        case TestSuite.JAMDUNA:
+            return env;
+        default:
+            throw new Error(`Configured environment variable TEST_SUITE is unknown: '${env}'. Use one of: ${Object.values(TestSuite)}`);
     }
-    return val;
 }
 class Compatibility {
     static override(version) {
@@ -28434,6 +28442,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 +28813,7 @@ function isResult(x) {
 
 
 
+
 ;// CONCATENATED MODULE: ./packages/core/bytes/bitvec.ts
 
 /**
@@ -35148,6 +35185,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}${idx < data.length ? data[idx] : ""}`);
+    const msg = `${lvlText} [${levelAndName[1]}] ${val.join("")}`;
+    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 +35232,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 +35353,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 +35383,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 +35512,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 +39226,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 +39295,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 +39317,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 +39349,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 +39488,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 +39562,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 +39593,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 +39642,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 +39651,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 +39737,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 +39753,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 +39773,7 @@ class MessageChannelStateMachine {
             await promise;
         }
         catch (e) {
-            channel_logger.error(JSON.stringify(e));
+            channel_logger.error `${e}`;
         }
         return new MessageChannelStateMachine(machine, port);
     }
@@ -39932,7 +39976,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 +40074,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 +40187,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 +40235,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 +40249,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 +40269,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 +40289,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 +40298,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 +40310,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 +40409,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 +40447,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) {
@@ -41983,6 +42027,17 @@ class PageRange {
         }
         return new PageRange(start, length);
     }
+    /** Returns true if the page range is wrapped (`start` >= `end`) and is not empty */
+    isWrapped() {
+        return this.start >= this.end && !this.isEmpty();
+    }
+    /** Checks if given page number is within the range */
+    isInRange(page) {
+        if (this.isWrapped()) {
+            return page >= this.start || page < this.end;
+        }
+        return page >= this.start && page < this.end;
+    }
     /** Checks if a range is empty (`length === 0`) */
     isEmpty() {
         return this.length === 0;
@@ -42111,12 +42166,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 +42204,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 +42271,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) {
@@ -42360,10 +42417,11 @@ class MemoryBuilder {
       startHeapIndex (${startHeapIndex}) has to be less than or equal to endHeapIndex (${endHeapIndex})
     `;
         this.ensureNotFinalized();
-        const range = MemoryRange.fromStartAndLength(startHeapIndex, endHeapIndex - startHeapIndex);
-        const pages = PageRange.fromMemoryRange(range);
-        for (const pageNumber of pages) {
-            if (this.initialMemory.has(pageNumber)) {
+        const heapRange = MemoryRange.fromStartAndLength(startHeapIndex, endHeapIndex - startHeapIndex);
+        const heapPagesRange = PageRange.fromMemoryRange(heapRange);
+        const initializedPageNumbers = Array.from(this.initialMemory.keys());
+        for (const pageNumber of initializedPageNumbers) {
+            if (heapPagesRange.isInRange(pageNumber)) {
                 throw new IncorrectSbrkIndex();
             }
         }
@@ -44144,7 +44202,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 +44368,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 +44440,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 +44687,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 +45295,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 +45350,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 +45363,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 +45378,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 +45497,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 +45509,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 +54301,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 +54325,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 +54592,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 +54625,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 +54684,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 +54694,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 +54706,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 +54731,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 +54754,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 +54769,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 +54779,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 +54811,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 +54822,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 +54942,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 +54964,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 +54973,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 +55086,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 +55100,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 +55110,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 +55144,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 +55156,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 +55199,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 +55216,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 +55302,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 +55322,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 +55493,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 +55507,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 +55568,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 +55580,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 +55653,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 +55737,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 +55754,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 +55767,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 +55829,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 +55842,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 +55953,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 +55961,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 +55974,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 +55982,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 +56103,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 +56178,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 +56192,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 +56218,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 +56229,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 +56255,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 +56334,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 +56584,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 +56628,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 +56649,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 +56913,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 +56931,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 +56939,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 +56981,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 +57007,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 +57062,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 +57074,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 +57105,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 +57257,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 +57265,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 +57292,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 +57301,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 +57318,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 +57447,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 +57473,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 +57481,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 +57496,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 +57529,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 +57540,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 +57551,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 +57564,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);
 }
@@ -57534,7 +57592,7 @@ async function startNetwork(config) {
 }
 
 ;// CONCATENATED MODULE: ./packages/jam/node/package.json
-const package_namespaceObject = {"rE":"0.1.1"};
+const package_namespaceObject = {"rE":"0.1.2"};
 ;// CONCATENATED MODULE: ./packages/jam/node/main.ts
 
 
@@ -57552,8 +57610,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 +57654,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 +57685,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;
@@ -58833,16 +58891,12 @@ class PartiallyUpdatedState {
      *
      * NOTE the info may be updated compared to what is in the state.
      *
-     * Takes into account newly created services as well.
+     * Takes into account ejected and newly created services as well.
      */
     getServiceInfo(destination) {
         if (destination === null) {
             return null;
         }
-        const isEjected = this.stateUpdate.services.servicesRemoved.some((x) => x === destination);
-        if (isEjected) {
-            return null;
-        }
         const maybeNewService = this.stateUpdate.services.servicesUpdates.find((update) => update.serviceId === destination);
         if (maybeNewService !== undefined) {
             return maybeNewService.action.account;
@@ -59577,7 +59631,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 +59646,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 +60531,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 +60546,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 +60623,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 +60636,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 +60683,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 +60715,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 +60754,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 +60806,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 +60868,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 +60925,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 +60984,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 +61042,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 +61107,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 +61183,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 +61246,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 +61284,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 +61330,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);
     }
@@ -61387,8 +61441,8 @@ var FetchKind;
 
 
 const info_IN_OUT_REG = 7;
-const OFFSET_REG = Compatibility.isSuite(TestSuite.W3F_DAVXY) ? 9 : 11;
-const LEN_REG = Compatibility.isSuite(TestSuite.W3F_DAVXY) ? 10 : 12;
+const OFFSET_REG = Compatibility.isSuite(TestSuite.W3F_DAVXY) || Compatibility.isGreaterOrEqual(GpVersion.V0_7_2) ? 9 : 11;
+const LEN_REG = Compatibility.isSuite(TestSuite.W3F_DAVXY) || Compatibility.isGreaterOrEqual(GpVersion.V0_7_2) ? 10 : 12;
 /**
  * Return info about some account.
  *
@@ -61405,7 +61459,7 @@ const LEN_REG = Compatibility.isSuite(TestSuite.W3F_DAVXY) ? 10 : 12;
  * a = last accumulation timeslot
  * p = parent service
  *
- * https://graypaper.fluffylabs.dev/#/38c4e62/338302338302?v=0.7.0
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/333b00333b00?v=0.7.2
  */
 class Info {
     currentServiceId;
@@ -61435,13 +61489,15 @@ class Info {
         const offset = minU64(regs.get(OFFSET_REG), valueLength);
         // l
         const length = minU64(regs.get(LEN_REG), numbers_tryAsU64(valueLength - offset));
+        // NOTE: casting to `Number` is safe in both places, since we are always bounded
+        // by the actual `encodedInfo.length`, which is equal `96`.
         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;
@@ -61454,7 +61510,7 @@ class Info {
  *
  * Used exclusively by `info` host call.
  *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/337602337602?v=0.6.7
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/33920033b500?v=0.7.2
  */
 const codecServiceAccountInfoWithThresholdBalance = descriptors_codec.object({
     codeHash: descriptors_codec.bytes(hash_HASH_SIZE),
@@ -61502,7 +61558,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 +61598,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 +61665,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 +61683,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 +61734,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 +61744,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 +61943,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 +61976,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 +62004,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;
     }
     /**
@@ -62004,6 +62060,7 @@ class Accumulate {
         const serviceIds = accumulateData.getServiceIds();
         let gasCost = common_tryAsServiceGas(0);
         let currentState = inputStateUpdate;
+        const currentManager = (inputStateUpdate.privilegedServices ?? this.state.privilegedServices).manager;
         for (const serviceId of serviceIds) {
             const checkpoint = AccumulationStateUpdate.copyFrom(currentState);
             const { consumedGas, stateUpdate } = await this.accumulateSingleService(serviceId, accumulateData.getOperands(serviceId), accumulateData.getGasCost(serviceId), slot, entropy, currentState);
@@ -62013,6 +62070,21 @@ class Accumulate {
             serviceStatistics.gasUsed = common_tryAsServiceGas(serviceStatistics.gasUsed + consumedGas);
             statistics.set(serviceId, serviceStatistics);
             currentState = stateUpdate === null ? checkpoint : stateUpdate;
+            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+`;
+                    // 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`
+                    const { stateUpdate } = await this.accumulateSingleService(newV, accumulateData.getOperands(newV), accumulateData.getGasCost(newV), slot, entropy, checkpoint);
+                    const correctV = stateUpdate?.privilegedServices?.validatorsManager ?? this.state.privilegedServices.validatorsManager;
+                    currentState.privilegedServices = PrivilegedServices.create({
+                        ...currentState.privilegedServices,
+                        validatorsManager: correctV,
+                    });
+                }
+            }
         }
         return {
             state: currentState,
@@ -62157,11 +62229,14 @@ class DeferredTransfers {
     async transition({ pendingTransfers, timeslot, servicesUpdate: inputServicesUpdate, entropy, }) {
         // https://graypaper.fluffylabs.dev/#/7e6ff6a/187a03187a03?v=0.6.7
         const transferStatistics = new Map();
-        const services = uniquePreserveOrder(pendingTransfers.flatMap((x) => [x.source, x.destination]));
+        const services = uniquePreserveOrder(pendingTransfers.map((x) => x.destination));
         let currentStateUpdate = AccumulationStateUpdate.new(inputServicesUpdate);
         for (const serviceId of services) {
             const partiallyUpdatedState = new PartiallyUpdatedState(this.state, currentStateUpdate);
-            const transfers = pendingTransfers.filter((pendingTransfer) => pendingTransfer.destination === serviceId);
+            // https://graypaper.fluffylabs.dev/#/38c4e62/18750318ae03?v=0.7.0
+            const transfers = pendingTransfers
+                .filter((pendingTransfer) => pendingTransfer.destination === serviceId)
+                .toSorted((a, b) => a.source - b.source);
             const info = partiallyUpdatedState.getServiceInfo(serviceId);
             if (info === null) {
                 return result_Result.error(DeferredTransfersErrorCode.ServiceInfoNotExist);
@@ -62181,13 +62256,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 {
@@ -62815,7 +62890,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})`);
@@ -63702,7 +63777,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);
         }
@@ -63833,7 +63908,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");
@@ -63841,20 +63916,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);
         }
@@ -63874,10 +63949,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);
         }
@@ -63886,7 +63961,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);
@@ -63897,17 +63972,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()));
@@ -63955,7 +64030,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) {
@@ -63977,7 +64052,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 () => { };
@@ -63989,7 +64064,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) {
@@ -63998,7 +64073,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.
@@ -64019,8 +64094,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.
@@ -64047,9 +64122,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;
@@ -64076,7 +64151,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());
@@ -64146,20 +64221,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) {
@@ -64196,7 +64271,7 @@ function readJsonBlock(file, chainSpec) {
 var minimist = __nccwpck_require__(8595);
 var minimist_default = /*#__PURE__*/__nccwpck_require__.n(minimist);
 ;// CONCATENATED MODULE: ./bin/jam/package.json
-const jam_package_namespaceObject = {"rE":"0.1.1"};
+const jam_package_namespaceObject = {"rE":"0.1.2"};
 ;// CONCATENATED MODULE: ./bin/jam/args.ts
 
 
@@ -64356,6 +64431,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;
@@ -64382,14 +64458,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) {