@typeberry/jam 0.1.1-e48de40 → 0.1.1

package/jam-network/index.js

@@ -25425,34 +25425,6 @@ 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
@@ -25796,7 +25768,6 @@ function isResult(x) {
 
 
 
-
 ;// CONCATENATED MODULE: ./packages/core/bytes/bitvec.ts
 
 /**
@@ -32165,23 +32136,6 @@ function parseLevel(lvl) {
 ;// CONCATENATED MODULE: ./packages/core/logger/console.ts
 // biome-ignore-all lint/suspicious/noConsole: logger
 
-function print(level, levelAndName, strings, data) {
-    if (level < levelAndName[0]) {
-        return;
-    }
-    const lvlText = Level[level].padEnd(5);
-    const val = strings.map((v, idx) => `${v}${data[idx]}`);
-    const msg = `${lvlText} [${levelAndName[1]}] ${val}`;
-    if (level === Level.WARN) {
-        console.warn(msg);
-    }
-    else if (level === Level.ERROR) {
-        console.error(msg);
-    }
-    else {
-        console.info(msg);
-    }
-}
 /** An optimized logger that ignores `TRACE`, `DEBUG` and `LOG` messages.
  *
  * Use the `create` method to instantiate the right instance of a more specialized logger.
@@ -32212,91 +32166,109 @@ class ConsoleTransport {
     constructor(options) {
         this.options = options;
     }
-    insane(_levelAndName, _strings, _data) {
+    insane(_moduleName, _val) {
         /* no-op */
     }
-    trace(_levelAndName, _strings, _data) {
+    trace(_moduleName, _val) {
         /* no-op */
     }
-    log(_levelAndName, _strings, _data) {
+    log(_moduleName, _val) {
         /* no-op */
     }
-    info(_levelAndName, _strings, _data) {
+    info(_moduleName, _val) {
         /* no-op */
     }
-    warn(levelAndName, strings, data) {
-        print(Level.WARN, levelAndName, strings, data);
+    warn(moduleName, val) {
+        this.push(Level.WARN, moduleName, val);
     }
-    error(levelAndName, strings, data) {
-        print(Level.ERROR, 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);
+        }
     }
 }
 /**
  * Insane version of console logger - supports insane level.
  */
 class InsaneConsoleLogger extends ConsoleTransport {
-    insane(levelAndName, strings, data) {
-        print(Level.INSANE, levelAndName, strings, data);
+    insane(moduleName, val) {
+        this.push(Level.INSANE, moduleName, val);
     }
-    trace(levelAndName, strings, data) {
-        print(Level.TRACE, levelAndName, strings, data);
+    trace(moduleName, val) {
+        this.push(Level.TRACE, moduleName, val);
     }
-    log(levelAndName, strings, data) {
-        print(Level.LOG, levelAndName, strings, data);
+    log(moduleName, val) {
+        this.push(Level.LOG, moduleName, val);
     }
-    info(levelAndName, strings, data) {
-        print(Level.INFO, levelAndName, strings, data);
+    info(moduleName, val) {
+        this.push(Level.INFO, moduleName, val);
     }
 }
 /**
  * A basic version of console logger - printing everything.
  */
 class TraceConsoleTransport extends ConsoleTransport {
-    insane(_levelAndName, _strings, _data) {
+    insane(_moduleName, _val) {
         /* no-op */
     }
-    trace(levelAndName, strings, data) {
-        print(Level.TRACE, levelAndName, strings, data);
+    trace(moduleName, val) {
+        this.push(Level.TRACE, moduleName, val);
     }
-    log(levelAndName, strings, data) {
-        print(Level.LOG, levelAndName, strings, data);
+    log(moduleName, val) {
+        this.push(Level.LOG, moduleName, val);
     }
-    info(levelAndName, strings, data) {
-        print(Level.INFO, levelAndName, strings, data);
+    info(moduleName, val) {
+        this.push(Level.INFO, moduleName, val);
     }
 }
 /**
  * An optimized version of the logger - completely ignores `TRACE` level calls.
  */
 class LogConsoleTransport extends ConsoleTransport {
-    insane(_levelAndName, _strings, _data) {
+    insane(_moduleName, _val) {
         /* no-op */
     }
-    trace(_levelAndName, _strings, _data) {
+    trace(_moduleName, _val) {
         /* no-op */
     }
-    log(levelAndName, strings, data) {
-        print(Level.LOG, levelAndName, strings, data);
+    log(moduleName, val) {
+        this.push(Level.LOG, moduleName, val);
     }
-    info(levelAndName, strings, data) {
-        print(Level.INFO, levelAndName, strings, data);
+    info(moduleName, val) {
+        this.push(Level.INFO, moduleName, val);
     }
 }
 /**
  * An optimized version of the logger - completely ignores `TRACE` & `DEBUG` level calls.
  */
 class InfoConsoleTransport extends ConsoleTransport {
-    insane(_levelAndName, _strings, _data) {
+    insane(_moduleName, _val) {
         /* no-op */
     }
-    trace(_levelAndName, _strings, _data) {
+    trace(_moduleName, _val) {
         /* no-op */
     }
-    log(_levelAndName, _strings, _data) {
+    log(_moduleName, _val) {
         /* no-op */
     }
-    info(levelAndName, strings, data) {
-        print(Level.INFO, levelAndName, strings, data);
+    info(moduleName, val) {
+        this.push(Level.INFO, moduleName, val);
     }
 }
 
@@ -32333,6 +32305,11 @@ 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.
      *
@@ -32363,46 +32340,33 @@ 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(strings, ...data) {
-        this.config.transport.insane(this.getLevelAndName(), strings, data);
+    insane(val) {
+        this.config.transport.insane(this.moduleName, val);
     }
     /** Log a message with `TRACE` level. */
-    trace(strings, ...data) {
-        this.config.transport.trace(this.getLevelAndName(), strings, data);
+    trace(val) {
+        this.config.transport.trace(this.moduleName, val);
     }
     /** Log a message with `DEBUG`/`LOG` level. */
-    log(strings, ...data) {
-        this.config.transport.log(this.getLevelAndName(), strings, data);
+    log(val) {
+        this.config.transport.log(this.moduleName, val);
     }
     /** Log a message with `INFO` level. */
-    info(strings, ...data) {
-        this.config.transport.info(this.getLevelAndName(), strings, data);
+    info(val) {
+        this.config.transport.info(this.moduleName, val);
     }
     /** Log a message with `WARN` level. */
-    warn(strings, ...data) {
-        this.config.transport.warn(this.getLevelAndName(), strings, data);
+    warn(val) {
+        this.config.transport.warn(this.moduleName, val);
     }
     /** Log a message with `ERROR` level. */
-    error(strings, ...data) {
-        this.config.transport.error(this.getLevelAndName(), strings, data);
+    error(val) {
+        this.config.transport.error(this.moduleName, val);
     }
 }
 
@@ -32492,15 +32456,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 = fs.readFileSync(configPath, "utf8");
         const parsed = JSON.parse(configFile);
         return parseFromJson(parsed, NodeConfiguration.fromJson);
@@ -36206,7 +36170,7 @@ class LmdbStates {
             await Promise.all([valuesWrite, statesWrite]);
         }
         catch (e) {
-            states_logger.error `${e}`;
+            states_logger.error(`${e}`);
             return Result.error(StateUpdateError.Commit);
         }
         return Result.ok(OK);
@@ -36315,7 +36279,7 @@ class TypedPort {
                 this.dispatchPortMessage(msg);
             }
             catch (e) {
-                port_logger.error `[${this.constructor.name}] Failed to dispatch a message: ${e}: ${msg}`;
+                port_logger.error(`[${this.constructor.name}] Failed to dispatch a message: ${e}: ${JSON.stringify(msg)}`);
                 throw e;
             }
         });
@@ -36389,7 +36353,7 @@ class TypedPort {
             this.port.postMessage(msg, transferList);
         }
         catch (e) {
-            port_logger.error `[${this.constructor.name}] Failed to post a message: ${e}: ${msg}`;
+            port_logger.error(`[${this.constructor.name}] Failed to post a message: ${e}: ${JSON.stringify(msg)}`);
             throw e;
         }
     }
@@ -36420,7 +36384,7 @@ class TypedPort {
     cleanup(reason) {
         // resolve all pending requests with an error.
         const responseListeners = this.responseListeners.eventNames();
-        for (const ev of responseListeners) {
+        for (const ev in responseListeners) {
             this.responseListeners.emit(ev, new Error(`port is ${reason}`));
         }
     }
@@ -36469,7 +36433,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;
             }
         });
@@ -36478,7 +36442,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;
             }
         });
@@ -36564,7 +36528,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);
@@ -36580,7 +36544,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;
     }
     /**
@@ -36600,7 +36564,7 @@ class MessageChannelStateMachine {
             await promise;
         }
         catch (e) {
-            channel_logger.error `${e}`;
+            channel_logger.error(JSON.stringify(e));
         }
         return new MessageChannelStateMachine(machine, port);
     }
@@ -36803,7 +36767,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;
     }
     /**
@@ -36901,7 +36865,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;
 }
 
@@ -36998,11 +36962,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) {
@@ -37010,7 +36974,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);
@@ -45802,23 +45766,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: expected exactly one certificate, got: ${certs.length}`;
+        certificate_logger.log("Rejecting peer with no certificates.");
         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)
@@ -45826,7 +45790,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");
@@ -46093,19 +46057,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;
@@ -46126,7 +46090,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}`);
         }
     });
 }
@@ -46185,7 +46149,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,
@@ -46195,11 +46159,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) {
@@ -46207,11 +46171,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 });
     }
 }
@@ -46232,7 +46196,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 = setup_logger.getLevel() > Level.TRACE ? LogLevel.WARN : LogLevel.DEBUG;
+        const quicLoggerLvl = Logger.getLevel("net") > Level.TRACE ? LogLevel.WARN : LogLevel.DEBUG;
         const quicLogger = new dist_Logger("quic", quicLoggerLvl, [
             new handlers_StreamHandler(format `${level}:${keys}:${msg}`),
         ]);
@@ -46255,7 +46219,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"),
@@ -46270,8 +46234,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;
@@ -46280,16 +46244,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();
@@ -46312,10 +46276,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!");
@@ -46323,7 +46287,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) {
@@ -46443,10 +46407,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.
@@ -46465,7 +46429,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;
             }
@@ -46474,7 +46438,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})`);
             }
         }
     }
@@ -46587,7 +46551,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();
@@ -46601,7 +46565,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) {
@@ -46611,7 +46575,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
@@ -46645,10 +46609,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 (;;) {
@@ -46657,7 +46621,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
@@ -46700,7 +46664,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));
                     }
@@ -46717,7 +46681,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;
             }
@@ -46803,7 +46767,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_Block.Codec.View, blocks.length), blocks, this.chainSpec));
         sender.close();
@@ -46823,7 +46787,7 @@ class ClientHandler {
             throw new Error("Received an unexpected message from the server.");
         }
         const blocks = decoder_Decoder.decodeSequence(block_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);
     }
@@ -46994,13 +46958,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.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.encodeObject(codec.sequenceVarLen(trieNodeCodec), boundaryNodes));
             sender.bufferAndSend(Encoder.encodeObject(StateResponse.Codec, StateResponse.create({ keyValuePairs })));
             sender.close();
@@ -47008,11 +46972,11 @@ class ce_129_state_request_Handler {
         }
         if (!this.boundaryNodes.has(sender.streamId)) {
             this.boundaryNodes.set(sender.streamId, Decoder.decodeObject(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.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);
@@ -47069,7 +47033,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();
     }
@@ -47081,7 +47045,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() { }
@@ -47154,15 +47118,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();
@@ -47238,7 +47202,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);
         });
     }
@@ -47255,7 +47219,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();
     }
@@ -47268,9 +47232,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 });
@@ -47330,7 +47294,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();
     }
@@ -47343,12 +47307,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();
     }
@@ -47454,7 +47418,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);
@@ -47462,7 +47426,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) {
@@ -47475,7 +47439,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));
     }
@@ -47483,11 +47447,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.`);
         }
     }
 }
@@ -47604,7 +47568,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
@@ -47679,7 +47643,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;
             });
@@ -47693,13 +47657,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);
@@ -47719,10 +47683,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,
@@ -47730,7 +47694,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: 🤷
         //
@@ -47756,12 +47720,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 `[${peerInfo.peerId}] <-- Fetching ${bestSlot - ourBestSlot} blocks (${bestHash})`;
+                    sync_logger.log(`Fetching blocks from ${peerInfo.peerId}.`);
                     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;
             });
@@ -47835,7 +47799,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;
@@ -47926,7 +47890,7 @@ class MainReady extends State {
             this.onNewBlocks.emit(blocks);
         }
         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)}.`);
         }
     }
     announceHeader(port, header) {
@@ -47964,7 +47928,7 @@ class NetworkReady extends State {
             this.onNewHeader.emit(decoded);
         }
         else {
-            state_machine_logger.error `${this.constructor.name} got invalid signal type: ${JSON.stringify(header)}.`;
+            state_machine_logger.error(`${this.constructor.name} got invalid signal type: ${JSON.stringify(header)}.`);
         }
     }
     sendBlocks(port, blocks) {
@@ -48003,7 +47967,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) => main(channel)).catch((e) => jam_network_logger.error `${e}`);
+    channel.then((channel) => main(channel)).catch((e) => jam_network_logger.error(e));
 }
 /**
  * JAM networking worker.
@@ -48014,7 +47978,7 @@ if (!external_node_worker_threads_namespaceObject.isMainThread) {
  */
 async function 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)"
@@ -48025,7 +47989,7 @@ async function 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,
@@ -48038,7 +48002,7 @@ async function 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);
 }