ui5-test-runner 6.0.0-beta.5 → 6.0.1

package/dist/platform/logger/CompressionContext.js

@@ -0,0 +1,117 @@
+import { isDeepStrictEqual } from 'node:util';
+import { split } from '../../utils/shared/string.js';
+export const DIGITS = Array.from({ length: 127 - 32 }, () => 0)
+    .map((_, index) => String.fromCodePoint(32 + index))
+    .join('');
+export const MAX_TIMESTAMP_DIGITS = 7;
+export const MAX_DWORD_DIGITS = 5;
+const MAX_INDEX_DIGITS = 2;
+const CONTEXT_PROCESS_ID = 'p';
+const CONTEXT_SOURCE_ID = 's';
+export class CompressionContext {
+    constructor() { }
+    static create() {
+        return new CompressionContext();
+    }
+    static compressNumber(value, maxLength) {
+        const digits = [];
+        while (value > 0) {
+            const digit = value % DIGITS.length;
+            digits.push(DIGITS[digit]);
+            value = (value - digit) / DIGITS.length;
+        }
+        return digits.join('').padEnd(maxLength, DIGITS[0]);
+    }
+    static uncompressNumber(value) {
+        let result = 0;
+        let factor = 1;
+        for (const digit of value) {
+            const index = DIGITS.indexOf(digit);
+            result += index * factor;
+            factor *= DIGITS.length;
+        }
+        return result;
+    }
+    fail(message) {
+        throw new Error(message);
+    }
+    _compressWithList({ array, value, compress }) {
+        const index = array.findIndex((candidate) => isDeepStrictEqual(candidate, value));
+        if (index !== -1) {
+            const compressed = CompressionContext.compressNumber(index, MAX_INDEX_DIGITS);
+            return {
+                context: '',
+                compressed
+            };
+        }
+        const lastIndex = array.length;
+        array.push(value);
+        return {
+            context: compress(value).join(''),
+            compressed: CompressionContext.compressNumber(lastIndex, MAX_INDEX_DIGITS)
+        };
+    }
+    _uncompressFromList({ type, array, compressed }) {
+        const index = CompressionContext.uncompressNumber(compressed);
+        return array[index] ?? this.fail(`Invalid ${type} index ${index} (length: ${array.length})`);
+    }
+    _processes = [];
+    compressProcess(value) {
+        return this._compressWithList({
+            array: this._processes,
+            value,
+            compress: ({ processId, threadId, isMainThread }) => {
+                return threadId === -1
+                    ? [CONTEXT_PROCESS_ID, CompressionContext.compressNumber(processId, MAX_DWORD_DIGITS)]
+                    : [
+                        CONTEXT_PROCESS_ID,
+                        CompressionContext.compressNumber(processId, MAX_DWORD_DIGITS),
+                        CompressionContext.compressNumber(threadId, MAX_DWORD_DIGITS),
+                        isMainThread ? '!' : ''
+                    ];
+            }
+        });
+    }
+    addProcess(compressed) {
+        const [, cProcessId, cThreadId, cIsMainThread] = split(compressed, 1, MAX_DWORD_DIGITS, MAX_DWORD_DIGITS, 1);
+        if (cThreadId) {
+            this._processes.push({
+                processId: CompressionContext.uncompressNumber(cProcessId),
+                threadId: CompressionContext.uncompressNumber(cThreadId),
+                isMainThread: cIsMainThread === '!'
+            });
+        }
+        else {
+            this._processes.push({
+                processId: CompressionContext.uncompressNumber(cProcessId),
+                threadId: -1,
+                isMainThread: false
+            });
+        }
+    }
+    uncompressProcess(compressed) {
+        return this._uncompressFromList({
+            type: 'process',
+            array: this._processes,
+            compressed
+        });
+    }
+    _sources = [];
+    compressSource(value) {
+        return this._compressWithList({
+            array: this._sources,
+            value,
+            compress: (value) => [CONTEXT_SOURCE_ID, value]
+        });
+    }
+    addSource(compressed) {
+        this._sources.push(compressed.slice(1));
+    }
+    uncompressSource(compressed) {
+        return this._uncompressFromList({
+            type: 'source',
+            array: this._sources,
+            compressed
+        });
+    }
+}

package/dist/platform/logger/allCompressed.js

@@ -1,14 +1,15 @@
 import { Path, Thread, ZLib } from '../index.js';
 import { LogLevel } from './types.js';
 import { toInternalLogAttributes } from './toInternalLogAttributes.js';
-import { createCompressionContext, compress } from './compress.js';
+import { CompressionContext } from './CompressionContext.js';
+import { compress } from './compress.js';
 import { FramedStreamWriter } from '../../utils/node/FramedStreamWriter.js';
+import { traceFileName } from './traceFileName.js';
 export const MAX_BUFFER_COUNT = 50;
 const FLUSH_INTERVAL_MS = 200;
-const compressionContext = createCompressionContext();
-export const workerMain = ({ configuration }) => {
-    const LOG_FILE_NAME = `traces-${new Date().toISOString().slice(0, 19).replaceAll(/[-:]/g, '').replace('T', '-')}.logz`;
-    const stream = FramedStreamWriter.create(Path.join(configuration.reportDir, LOG_FILE_NAME));
+const compressionContext = CompressionContext.create();
+export const workerMain = ({ configuration, startedAt }) => {
+    const stream = FramedStreamWriter.create(Path.join(configuration.reportDir, traceFileName(startedAt)));
     const buffer = [];
     let flushTimeout;
     let writePromise = Promise.resolve();
@@ -37,7 +38,7 @@ export const workerMain = ({ configuration }) => {
     channel.onmessage = (event) => {
         const { data: message } = event;
         if (message.command === 'terminate') {
-            _log({ source: 'logger', message: 'Logger terminating' });
+            _log({ source: 'logger', message: 'logger terminating' });
             channel.close();
             flushBuffer();
             void writePromise.then(() => stream.end());
@@ -46,7 +47,7 @@ export const workerMain = ({ configuration }) => {
             log(message);
         }
     };
-    _log({ source: 'logger', message: 'Logger ready' });
+    _log({ source: 'logger', message: 'logger ready' });
     channel.postMessage({
         command: 'ready',
         source: 'allCompressed'

package/dist/platform/logger/compress.js

@@ -1,123 +1,12 @@
 import { LogLevel } from './types.js';
-import { isDeepStrictEqual } from 'node:util';
 import assert from 'node:assert/strict';
 import { split } from '../../utils/shared/string.js';
-const ASCII_RECORD_SEPARATOR = '\u001E';
-export const DIGITS = Array.from({ length: 127 - 32 })
-    .fill(0)
-    .map((_, index) => String.fromCodePoint(32 + index))
-    .join('');
+import { CompressionContext, MAX_TIMESTAMP_DIGITS } from './CompressionContext.js';
+const ASCII_RECORD_SEPARATOR = '\u{1E}';
 const JSON_VALUE_SEP = ASCII_RECORD_SEPARATOR;
 const MAX_INDEX_DIGITS = 2;
 const CONTEXT_PROCESS_ID = 'p';
 const CONTEXT_SOURCE_ID = 's';
-export const MAX_TIMESTAMP_DIGITS = 7;
-export const MAX_DWORD_DIGITS = 5;
-class Context {
-    static compressNumber(value, maxLength) {
-        const digits = [];
-        while (value > 0) {
-            const digit = value % DIGITS.length;
-            digits.push(DIGITS[digit]);
-            value = (value - digit) / DIGITS.length;
-        }
-        return digits.join('').padEnd(maxLength, DIGITS[0]);
-    }
-    static uncompressNumber(value) {
-        let result = 0;
-        let factor = 1;
-        for (const digit of value) {
-            const index = DIGITS.indexOf(digit);
-            result += index * factor;
-            factor *= DIGITS.length;
-        }
-        return result;
-    }
-    fail(message) {
-        throw new Error(message);
-    }
-    _compressWithList({ array, value, compress }) {
-        const index = array.findIndex((candidate) => isDeepStrictEqual(candidate, value));
-        if (index !== -1) {
-            const compressed = Context.compressNumber(index, MAX_INDEX_DIGITS);
-            return {
-                context: '',
-                compressed
-            };
-        }
-        const lastIndex = array.length;
-        array.push(value);
-        return {
-            context: compress(value).join(''),
-            compressed: Context.compressNumber(lastIndex, MAX_INDEX_DIGITS)
-        };
-    }
-    _uncompressFromList({ type, array, compressed }) {
-        const index = Context.uncompressNumber(compressed);
-        return array[index] ?? this.fail(`Invalid ${type} index ${index} (length: ${array.length})`);
-    }
-    _processes = [];
-    compressProcess(value) {
-        return this._compressWithList({
-            array: this._processes,
-            value,
-            compress: ({ processId, threadId, isMainThread }) => {
-                if (threadId === -1) {
-                    return [CONTEXT_PROCESS_ID, Context.compressNumber(processId, MAX_DWORD_DIGITS)];
-                }
-                return [
-                    CONTEXT_PROCESS_ID,
-                    Context.compressNumber(processId, MAX_DWORD_DIGITS),
-                    Context.compressNumber(threadId, MAX_DWORD_DIGITS),
-                    isMainThread ? '!' : ''
-                ];
-            }
-        });
-    }
-    addProcess(compressed) {
-        const [, cProcessId, cThreadId, cIsMainThread] = split(compressed, 1, MAX_DWORD_DIGITS, MAX_DWORD_DIGITS, 1);
-        if (cThreadId) {
-            this._processes.push({
-                processId: Context.uncompressNumber(cProcessId),
-                threadId: Context.uncompressNumber(cThreadId),
-                isMainThread: cIsMainThread === '!'
-            });
-        }
-        else {
-            this._processes.push({
-                processId: Context.uncompressNumber(cProcessId),
-                threadId: -1,
-                isMainThread: false
-            });
-        }
-    }
-    uncompressProcess(compressed) {
-        return this._uncompressFromList({
-            type: 'process',
-            array: this._processes,
-            compressed
-        });
-    }
-    _sources = [];
-    compressSource(value) {
-        return this._compressWithList({
-            array: this._sources,
-            value,
-            compress: (value) => [CONTEXT_SOURCE_ID, value]
-        });
-    }
-    addSource(compressed) {
-        this._sources.push(compressed.slice(1));
-    }
-    uncompressSource(compressed) {
-        return this._uncompressFromList({
-            type: 'source',
-            array: this._sources,
-            compressed
-        });
-    }
-}
-export const createCompressionContext = () => new Context();
 const LEVEL_MAPPING = {
     [LogLevel.debug]: 'D',
     [LogLevel.info]: 'I',
@@ -138,10 +27,10 @@ const levelSlot = {
 const timestampSlot = {
     width: MAX_TIMESTAMP_DIGITS,
     compress(_, { timestamp }) {
-        return { compressed: Context.compressNumber(timestamp, MAX_TIMESTAMP_DIGITS) };
+        return { compressed: CompressionContext.compressNumber(timestamp, MAX_TIMESTAMP_DIGITS) };
     },
     uncompress(_, compressed) {
-        return { timestamp: Context.uncompressNumber(compressed) };
+        return { timestamp: CompressionContext.uncompressNumber(compressed) };
     }
 };
 const processSlot = {
@@ -167,23 +56,33 @@ const sourceSlot = {
 const pageIdSlot = {
     width: MAX_INDEX_DIGITS,
     compress(_, { pageId }) {
-        return { compressed: Context.compressNumber(pageId === undefined ? 0 : pageId + 1, MAX_INDEX_DIGITS) };
+        return { compressed: CompressionContext.compressNumber(pageId === undefined ? 0 : pageId + 1, MAX_INDEX_DIGITS) };
     },
     uncompress(_, compressed) {
-        const value = Context.uncompressNumber(compressed);
+        const value = CompressionContext.uncompressNumber(compressed);
         return value > 0 ? { pageId: value - 1 } : {};
     }
 };
 const messageAndExtraSlot = {
     width: 0,
     compress(_, { message, data, error }) {
-        const parts = [message.replaceAll(/\r?\n/g, '\r')];
-        if (data || error) {
-            parts.push(JSON_VALUE_SEP, JSON.stringify([data ?? 0, error ?? 0]).replaceAll(/"(\w+)":/g, (_, name) => `${name}${JSON_VALUE_SEP}`));
-        }
+        const parts = [
+            message.replaceAll(/\r?\n/g, '\r'),
+            ...(data || error
+                ? [
+                    JSON_VALUE_SEP,
+                    JSON.stringify([data ?? 0, error ?? 0]).replaceAll(/"(\w+)":/g, (_, name) => `${name}${JSON_VALUE_SEP}`)
+                ]
+                : [])
+        ];
         return { compressed: parts.join('') };
     },
     uncompress(_, compressed) {
+        if (!compressed) {
+            return {
+                message: ''
+            };
+        }
         const startOfJson = compressed.indexOf(JSON_VALUE_SEP);
         if (startOfJson === -1) {
             return { message: compressed.replaceAll('\r', '\n') };
@@ -195,12 +94,12 @@ const messageAndExtraSlot = {
         const [data, error] = JSON.parse(json);
         return {
             message,
-            ...(data ? { data } : {}),
-            ...(error ? { error } : {})
+            ...(data && { data }),
+            ...(error && { error })
         };
     }
 };
-const DATA_LINE_SLOTS = [
+export const DATA_LINE_SLOTS = [
     levelSlot,
     timestampSlot,
     processSlot,
@@ -208,9 +107,9 @@ const DATA_LINE_SLOTS = [
     pageIdSlot,
     messageAndExtraSlot
 ];
-const FIXED_SLOTS = DATA_LINE_SLOTS.filter((s) => s.width > 0);
-const FIXED_SLOT_WIDTHS = FIXED_SLOTS.map((s) => s.width);
-const VARIABLE_SLOTS = DATA_LINE_SLOTS.filter((s) => s.width === 0);
+const FIXED_SLOTS = DATA_LINE_SLOTS.filter((dataSlot) => dataSlot.width > 0);
+const FIXED_SLOT_WIDTHS = FIXED_SLOTS.map((dataSlot) => dataSlot.width);
+const VARIABLE_SLOTS = DATA_LINE_SLOTS.filter((dataSlot) => dataSlot.width === 0);
 assert.ok(VARIABLE_SLOTS.length === 1, 'DATA_LINE_SLOTS must contain exactly one variable-width slot');
 const VARIABLE_SLOT = VARIABLE_SLOTS[0];
 export const _ALL_LOG_ATTRIBUTES_ARE_HANDLED = {
@@ -221,12 +120,13 @@ export const _ALL_LOG_ATTRIBUTES_ARE_HANDLED = {
     isMainThread: processSlot,
     source: sourceSlot,
     pageId: pageIdSlot,
+    forceRender: null,
     message: messageAndExtraSlot,
     data: messageAndExtraSlot,
     error: messageAndExtraSlot
 };
 export const compress = (context, attributes) => {
-    assert.ok(context instanceof Context);
+    assert.ok(context instanceof CompressionContext);
     const contextLines = [];
     const parts = [];
     for (const slot of DATA_LINE_SLOTS) {
@@ -262,7 +162,7 @@ const uncompressLine = (context, line) => {
     return attributes;
 };
 export const uncompress = (context, compressed) => {
-    assert.ok(context instanceof Context);
+    assert.ok(context instanceof CompressionContext);
     const result = [];
     for (const line of compressed.split('\n')) {
         if (!line) {

package/dist/platform/logger/output/BaseLoggerOutput.js

@@ -1,47 +1,61 @@
 import { FileSystem, Path, Terminal } from '../../index.js';
 import { LogLevel } from '../types.js';
 import { ProgressBar } from '../../../utils/shared/ProgressBar.js';
+import { objectValues } from '../../../utils/shared/object.js';
 import { formatDuration } from '../../../utils/shared/string.js';
 import { assert } from '../../assert.js';
 const icons = {
     [LogLevel.debug]: Terminal.BLUE + '<o>',
-    [LogLevel.info]: '   ',
+    [LogLevel.info]: ' '.repeat(3),
     [LogLevel.warn]: Terminal.YELLOW + '/!\\',
     [LogLevel.error]: Terminal.RED + '(X)',
     [LogLevel.fatal]: Terminal.RED + 'o*!'
 };
 const DO_NOT_RENDER_SOURCE = [
     'browser',
+    'browser/agent',
     'browser/console',
     'browser/network',
     'metric',
-    'progress'
+    'process',
+    'process/stdout',
+    'process/stderr',
+    'progress',
+    'server/unhandled'
 ];
 export class BaseLoggerOutput {
     _configuration;
     _startedAt;
+    _debugLog;
     constructor(configuration, startedAt) {
         this._configuration = configuration;
         this._startedAt = startedAt;
+        this._debugLog = configuration.debugLog;
     }
     formatTimestamp(timestamp) {
         return formatDuration(timestamp - this._startedAt);
     }
+    _shouldRender({ source, forceRender, level }) {
+        return (forceRender ||
+            this._debugLog?.includes(source) ||
+            (!DO_NOT_RENDER_SOURCE.includes(source) && level !== LogLevel.debug));
+    }
     render(attributes) {
-        const { level, timestamp, source, message, data, error } = attributes;
-        if (!DO_NOT_RENDER_SOURCE.includes(source) && level !== LogLevel.debug) {
-            return [
-                icons[level],
-                Terminal.MAGENTA,
-                this.formatTimestamp(timestamp),
-                Terminal.WHITE,
-                ' ',
-                message,
-                data ? ` ${JSON.stringify(data)}` : '',
-                error ? ` ${Terminal.RED}${error.name} ${error.message}` : '',
-                '\n'
-            ].join('');
+        if (!this._shouldRender(attributes)) {
+            return;
         }
+        const { level, timestamp, message, data, error } = attributes;
+        return [
+            icons[level],
+            Terminal.MAGENTA,
+            this.formatTimestamp(timestamp),
+            Terminal.WHITE,
+            ' ',
+            message,
+            data ? ` ${JSON.stringify(data)}` : '',
+            error ? ` ${Terminal.RED}${error.name} ${error.message}` : '',
+            '\n'
+        ].join('');
     }
     addToReport(rawText) {
         FileSystem.writeFileSync(Path.join(this._configuration.reportDir, 'output.txt'), rawText, {
@@ -68,11 +82,12 @@ export class BaseLoggerOutput {
         totalNumberOfTests: 0
     };
     _updateOverallProgressSnapshot(data) {
-        if (data.type !== 'unknown') {
-            this._overallprogressSnapshot.totalNumberOfExecutedTests += data.value;
-            this._overallprogressSnapshot.totalNumberOfErrors += data.errors;
-            this._overallprogressSnapshot.totalNumberOfTests += data.max;
+        if (data.type === 'unknown') {
+            return;
         }
+        this._overallprogressSnapshot.totalNumberOfExecutedTests += data.value;
+        this._overallprogressSnapshot.totalNumberOfErrors += data.errors;
+        this._overallprogressSnapshot.totalNumberOfTests += data.max;
     }
     _overallprogress = {
         totalNumberOfExecutedTests: 0,
@@ -81,12 +96,13 @@ export class BaseLoggerOutput {
     };
     _updateOverallProgress() {
         const overallProgress = { ...this._overallprogressSnapshot };
-        for (const pageProgress of Object.values(this._pageProgressMap)) {
-            if (pageProgress.type !== 'unknown') {
-                overallProgress.totalNumberOfExecutedTests += pageProgress.bar.value;
-                overallProgress.totalNumberOfErrors += pageProgress.errors;
-                overallProgress.totalNumberOfTests += pageProgress.bar.max;
+        for (const pageProgress of objectValues(this._pageProgressMap)) {
+            if (pageProgress.type === 'unknown') {
+                continue;
             }
+            overallProgress.totalNumberOfExecutedTests += pageProgress.bar.value;
+            overallProgress.totalNumberOfErrors += pageProgress.errors;
+            overallProgress.totalNumberOfTests += pageProgress.bar.max;
         }
         this._overallprogress = overallProgress;
     }
@@ -146,13 +162,15 @@ export class BaseLoggerOutput {
         return true;
     }
     addAttributesToLoggerOutput(attributes) {
-        if (this.renderAttributes(attributes)) {
-            const rendered = this.render(attributes);
-            if (rendered) {
-                const raw = Terminal.stripVTControlCharacters(rendered);
-                this.addTextToLoggerOutput(rendered, raw);
-                this.addToReport(raw);
-            }
+        if (!this.renderAttributes(attributes)) {
+            return;
+        }
+        const rendered = this.render(attributes);
+        if (!rendered) {
+            return;
         }
+        const raw = Terminal.stripVTControlCharacters(rendered);
+        this.addTextToLoggerOutput(rendered, raw);
+        this.addToReport(raw);
     }
 }

package/dist/platform/logger/output/InteractiveLoggerOutput.js

@@ -44,7 +44,7 @@ export class InteractiveLoggerOutput extends BaseLoggerOutput {
         for (const pageId of this.pageIds) {
             const pageProgress = this.pageProgressMap[pageId];
             const rendered = pageProgress.bar.render(this._terminalWidth - 4);
-            let status = '   ';
+            let status = ' '.repeat(3);
             if (pageProgress.errors) {
                 status = `${Terminal.RED}${Math.min(pageProgress.errors, 999).toString().padEnd(3, ' ')}${Terminal.WHITE}`;
             }

package/dist/platform/logger/output/LlmLoggerOutput.js

@@ -0,0 +1,29 @@
+import { Terminal } from '../../index.js';
+import { LogLevel } from '../types.js';
+import { BaseLoggerOutput } from './BaseLoggerOutput.js';
+const SEVERITY = {
+    [LogLevel.warn]: 'WARN ',
+    [LogLevel.error]: 'ERROR ',
+    [LogLevel.fatal]: 'FATAL '
+};
+export class LlmLoggerOutput extends BaseLoggerOutput {
+    _current;
+    terminalResized() { }
+    closeLoggerOutput() { }
+    addAttributesToLoggerOutput(attributes) {
+        this._current = attributes;
+        super.addAttributesToLoggerOutput(attributes);
+        this._current = undefined;
+    }
+    addTextToLoggerOutput() {
+        const attributes = this._current;
+        if (!attributes) {
+            return;
+        }
+        const { source, pageId, level, message, error } = attributes;
+        const context = pageId === undefined ? source : `${source}#${pageId}`;
+        const severity = SEVERITY[level] ?? '';
+        const details = error ? ` ${error.name}: ${error.message}` : '';
+        Terminal.write(`[${context}] ${severity}${message}${details}\n`);
+    }
+}

package/dist/platform/logger/output/factory.js

@@ -1,8 +1,12 @@
 import { InteractiveLoggerOutput } from './InteractiveLoggerOutput.js';
+import { LlmLoggerOutput } from './LlmLoggerOutput.js';
 import { StaticLoggerOutput } from './StaticLoggerOutput.js';
 export const LoggerOutputFactory = {
     build(configuration, startedAt) {
-        const { ci } = configuration;
+        const { ci, llm } = configuration;
+        if (llm) {
+            return new LlmLoggerOutput(configuration, startedAt);
+        }
         return ci
             ? new StaticLoggerOutput(configuration, startedAt)
             : new InteractiveLoggerOutput(configuration, startedAt);

package/dist/platform/logger/output.js

@@ -1,6 +1,7 @@
 import { Thread } from '../Thread.js';
 import '../logger.js';
 import { LoggerOutputFactory } from './output/factory.js';
+const SORT_WINDOW_MS = 20;
 const fromHexaCode = (value) => ({
     r: Number.parseInt(value.slice(1, 3), 16),
     g: Number.parseInt(value.slice(3, 5), 16),
@@ -8,15 +9,30 @@ const fromHexaCode = (value) => ({
 });
 export const workerMain = ({ configuration, startedAt }) => {
     const loggerOutput = LoggerOutputFactory.build(configuration, startedAt);
+    const queue = [];
+    let flushTimer;
+    const flush = () => {
+        flushTimer = undefined;
+        queue.sort((a, b) => a.timestamp - b.timestamp);
+        for (const message of queue) {
+            loggerOutput.addAttributesToLoggerOutput(message);
+        }
+        queue.length = 0;
+    };
     const channel = Thread.createBroadcastChannel('logger');
     channel.onmessage = (event) => {
         const { data: message } = event;
         if (message.command === 'terminate') {
+            if (flushTimer !== undefined) {
+                clearTimeout(flushTimer);
+                flush();
+            }
             channel.close();
             loggerOutput.closeLoggerOutput();
         }
         else if (message.command === 'log') {
-            loggerOutput.addAttributesToLoggerOutput(message);
+            queue.push(message);
+            flushTimer ??= setTimeout(flush, SORT_WINDOW_MS);
         }
         else if (message.command === 'terminal-resized') {
             loggerOutput.terminalResized(message.width);
@@ -24,7 +40,7 @@ export const workerMain = ({ configuration, startedAt }) => {
     };
     const from = fromHexaCode('#FF5A37');
     const to = fromHexaCode('#FFA42C');
-    const background = '\u001B[40m';
+    const background = '\u{1B}[40m';
     const diff = {
         r: to.r - from.r,
         g: to.g - from.g,
@@ -44,13 +60,15 @@ export const workerMain = ({ configuration, startedAt }) => {
             const r = Math.floor(from.r + (diff.r * index) / width);
             const g = Math.floor(from.g + (diff.g * index) / width);
             const b = Math.floor(from.b + (diff.b * index) / width);
-            return `\u001B[38;2;${r};${g};${b}m` + c;
+            return `\u{1B}[38;2;${r};${g};${b}m` + c;
         })
             .join('') +
-        '\u001B[0m')
+        '\u{1B}[0m')
         .join('\n');
-    loggerOutput.addToReport(rawLogo + '\n');
-    loggerOutput.addTextToLoggerOutput(logo + '\u001B[0m\n', rawLogo + '\n');
+    if (!configuration.noBanner) {
+        loggerOutput.addToReport(rawLogo + '\n');
+        loggerOutput.addTextToLoggerOutput(logo + '\u{1B}[0m\n', rawLogo + '\n');
+    }
     channel.postMessage({
         command: 'ready',
         source: 'output'

package/dist/platform/logger/toInternalLogAttributes.js

@@ -1,8 +1,16 @@
 import { Host } from '../Host.js';
 import { Thread } from '../Thread.js';
 export const toInternalLogAttributes = (attributes, level) => {
-    if (attributes.processId !== undefined) {
-        return {
+    return attributes.processId === undefined
+        ? {
+            timestamp: Date.now(),
+            level,
+            processId: Host.pid,
+            threadId: Thread.threadId,
+            isMainThread: Thread.isMainThread,
+            ...attributes
+        }
+        : {
             timestamp: Date.now(),
             level,
             threadId: 0,
@@ -10,13 +18,4 @@ export const toInternalLogAttributes = (attributes, level) => {
             ...attributes,
             processId: attributes.processId
         };
-    }
-    return {
-        timestamp: Date.now(),
-        level,
-        processId: Host.pid,
-        threadId: Thread.threadId,
-        isMainThread: Thread.isMainThread,
-        ...attributes
-    };
 };

package/dist/platform/logger/traceFileName.js

@@ -0,0 +1 @@
+export const traceFileName = (startedAt) => `traces-${new Date(startedAt).toISOString().slice(0, 19).replaceAll(/[-:]/g, '').replace('T', '-')}.logz`;