ui5-test-runner 6.0.0-beta.4 → 6.0.0

package/dist/platform/logger.js

@@ -1,20 +1,27 @@
 import { Exit, ExitShutdownError } from './Exit.js';
 import { Host } from './Host.js';
 import { Terminal } from './Terminal.js';
+import { Path } from './Path.js';
 import { Thread } from './Thread.js';
+import { performance } from 'node:perf_hooks';
 import { LogLevel } from './logger/types.js';
 import { toInternalLogAttributes } from './logger/toInternalLogAttributes.js';
+import { traceFileName } from './logger/traceFileName.js';
 import assert from 'node:assert/strict';
 import { toPlainObject } from '../utils/shared/object.js';
+import { redactSecrets } from '../utils/node/anonymize.js';
 import { toIError } from '../utils/shared/toIError.js';
 const startedAt = Date.now();
 let channel;
 let loggerWorker;
 let consoleWorker;
+let reportDirectory;
 const buffer = [];
 const waitingFor = ['allCompressed', 'output'];
-let ready = !Thread.isMainThread;
+let isReady = !Thread.isMainThread;
+const { promise: startPromise, resolve: startResolve } = Promise.withResolvers();
 let metricsMonitorInterval;
+let lastELU = performance.eventLoopUtilization();
 const terminalResized = (width) => {
     channel?.postMessage({
         command: 'terminal-resized',
@@ -24,13 +31,17 @@ const terminalResized = (width) => {
 const start = () => {
     channel = Thread.createBroadcastChannel('logger');
     metricsMonitorInterval = setInterval(() => {
+        const cpu = Thread.threadCpuUsage();
+        const mem = Host.memoryUsage();
+        const temporaryELU = performance.eventLoopUtilization();
+        const elu = performance.eventLoopUtilization(temporaryELU, lastELU);
+        lastELU = temporaryELU;
+        const heapUsedMB = Math.round(mem.heapUsed / 1024 / 1024);
+        const cpuUserMs = Math.round(cpu.user / 1000);
         logger.debug({
             source: 'metric',
-            message: '',
-            data: {
-                cpu: Thread.threadCpuUsage(),
-                mem: Host.memoryUsage()
-            }
+            message: `heapUsed=${heapUsedMB}MB cpu=${cpuUserMs}ms elu=${elu.utilization.toFixed(3)}`,
+            data: { cpu, mem, elu }
         });
     }, 1000);
     channel.onmessage = (event) => {
@@ -39,17 +50,23 @@ const start = () => {
             terminalResized(Terminal.width);
             const index = waitingFor.indexOf(message.source);
             waitingFor.splice(index, 1);
-            ready = waitingFor.length === 0;
-            if (ready && buffer.length > 0) {
-                for (const buffered of buffer) {
-                    channel.postMessage({
-                        command: 'log',
-                        ...buffered
-                    });
+            isReady = waitingFor.length === 0;
+            if (isReady) {
+                if (buffer.length > 0) {
+                    for (const buffered of buffer) {
+                        channel.postMessage({
+                            command: 'log',
+                            ...buffered
+                        });
+                    }
+                    buffer.length = 0;
                 }
-                buffer.length = 0;
+                startResolve();
             }
         }
+        else if (message.command === 'fatal') {
+            void Exit.shutdown();
+        }
         else if (message.command === 'terminate') {
             clearInterval(metricsMonitorInterval);
             channel.close();
@@ -61,7 +78,7 @@ const log = (level, attributes) => {
     if (attributes.error) {
         allAttributes.error = toIError(attributes.error);
     }
-    if (ready && !stopping) {
+    if (isReady && !stopping) {
         channel.postMessage({
             command: 'log',
             ...allAttributes
@@ -76,26 +93,30 @@ if (!Thread.isMainThread) {
 }
 let stopping;
 export const logger = {
-    start(configuration) {
+    async start(configuration) {
         assert.ok(Thread.isMainThread, 'Call logger.start only in main thread');
         assert.ok(!loggerWorker && !consoleWorker, 'Call logger.start only once');
+        reportDirectory = configuration.reportDir;
         start();
         loggerWorker = Thread.createWorker('platform/logger/allCompressed', {
-            configuration: toPlainObject(configuration)
+            configuration: redactSecrets(toPlainObject(configuration)),
+            startedAt
         });
         consoleWorker = Thread.createWorker('platform/logger/output', {
-            configuration: toPlainObject(configuration),
+            configuration: redactSecrets(toPlainObject(configuration)),
             startedAt
         });
         if (!configuration.ci) {
             Terminal.setRawMode((data) => {
-                if (data.length === 1 && data[0] === 3) {
-                    logger.warn({ source: 'job', message: 'User requested interruption' });
-                    Exit.sigInt();
+                if (!(data.length === 1 && data[0] === 3)) {
+                    return;
                 }
+                logger.warn({ source: 'job', message: 'user requested interruption' });
+                Exit.sigInt();
             });
             Terminal.onResize(terminalResized);
         }
+        return startPromise;
     },
     debug(attributes) {
         log(LogLevel.debug, attributes);
@@ -111,12 +132,22 @@ export const logger = {
     },
     fatal(attributes) {
         log(LogLevel.fatal, attributes);
+        if (Thread.isMainThread) {
+            void Exit.shutdown();
+        }
+        else {
+            channel.postMessage({ command: 'fatal' });
+        }
+        throw new ExitShutdownError();
     },
     async stop() {
         assert.ok(Thread.isMainThread, 'Call logger.stop only in main thread');
         if (stopping) {
             return await stopping;
         }
+        if (reportDirectory !== undefined) {
+            logger.info({ source: 'job', message: `trace file: ${Path.join(reportDirectory, traceFileName(startedAt))}` });
+        }
         const { promise, resolve } = Promise.withResolvers();
         stopping = promise;
         clearInterval(metricsMonitorInterval);

package/dist/platform/mock.js

@@ -1,21 +1,60 @@
 import { vi } from 'vitest';
-import { join } from 'node:path';
-const mockStaticMethodsOfExportedClasses = (actual) => {
+import { basename, extname, join, relative } from 'node:path';
+import { setTimeout } from 'node:timers/promises';
+import { options, defaults } from '../configuration/options.js';
+import assert from 'node:assert';
+export const MOCK_CWD = '~/ui5-test-runner/vitest';
+assert.ok(options[0].name === 'cwd');
+Object.assign(options[0], { default: MOCK_CWD });
+Object.assign(defaults, { cwd: MOCK_CWD });
+const _registry = new WeakMap();
+const functionMembers = (object) => {
+    const out = {};
+    for (const key of Object.getOwnPropertyNames(object)) {
+        if (typeof object[key] === 'function') {
+            out[key] = object[key];
+        }
+    }
+    return out;
+};
+const registerUnmock = (mocked, real) => {
+    _registry.set(mocked, { real: functionMembers(real), mocked: functionMembers(mocked) });
+};
+export const unmock = (target) => {
+    const entry = _registry.get(target);
+    assert.ok(entry, 'unmock: object was not registered as a mocked platform export');
+    Object.assign(target, entry.real);
+    const restore = () => {
+        Object.assign(target, entry.mocked);
+    };
+    return { restore, [Symbol.dispose]: restore };
+};
+const mockMethods = (object, members) => {
+    for (const member of members) {
+        if (typeof object[member] === 'function') {
+            object[member] = vi.fn();
+        }
+    }
+};
+const mockStaticMethodsOfExports = (actual) => {
     const mocked = { ...actual };
     for (const exportName in mocked) {
         const exportValue = mocked[exportName];
         if (typeof exportValue === 'function') {
-            const exportClass = exportValue;
-            for (const staticName of Object.getOwnPropertyNames(exportValue)) {
-                const staticValue = exportClass[staticName];
-                if (typeof staticValue === 'function') {
-                    exportClass[staticName] = vi.fn();
-                }
-            }
+            mockMethods(exportValue, Object.getOwnPropertyNames(exportValue));
+        }
+        else if (typeof exportValue === 'object' && exportValue !== null) {
+            mockMethods(exportValue, Object.keys(exportValue));
         }
     }
     return mocked;
 };
+vi.mock(import('./Crypto.js'), async (importActual) => {
+    const actual = await importActual();
+    const mocked = mockStaticMethodsOfExports(actual);
+    registerUnmock(mocked.Crypto, actual.Crypto);
+    return mocked;
+});
 vi.mock(import('./constants.js'), async (importActual) => {
     const mocked = await importActual();
     return {
@@ -25,8 +64,11 @@ vi.mock(import('./constants.js'), async (importActual) => {
 });
 export const __unregisterExitAsyncTask = vi.fn();
 export let __lastRegisteredExitAsyncTask;
+let _ExitShutdownError;
 vi.mock(import('./Exit.js'), async (importActual) => {
-    const mocked = mockStaticMethodsOfExportedClasses(await importActual());
+    const actual = await importActual();
+    _ExitShutdownError = actual.ExitShutdownError;
+    const mocked = mockStaticMethodsOfExports(actual);
     const { Exit } = mocked;
     vi.mocked(Exit.registerAsyncTask).mockImplementation((task) => {
         __lastRegisteredExitAsyncTask = task;
@@ -35,7 +77,8 @@ vi.mock(import('./Exit.js'), async (importActual) => {
     return mocked;
 });
 vi.mock(import('./FileSystem.js'), async (importActual) => {
-    const mocked = mockStaticMethodsOfExportedClasses(await importActual());
+    const actual = await importActual();
+    const mocked = mockStaticMethodsOfExports(actual);
     const { FileSystem } = mocked;
     const writeStream = {
         write: vi.fn().mockImplementation((_, callback) => callback()),
@@ -44,33 +87,75 @@ vi.mock(import('./FileSystem.js'), async (importActual) => {
     vi.mocked(FileSystem.createWriteStream).mockReturnValue(writeStream);
     const readStream = {};
     vi.mocked(FileSystem.createReadStream).mockReturnValue(readStream);
+    registerUnmock(FileSystem, actual.FileSystem);
+    return mocked;
+});
+vi.mock(import('./Host.js'), async (importActual) => {
+    const actual = await importActual();
+    const mocked = mockStaticMethodsOfExports(actual);
+    const { Host } = mocked;
+    vi.mocked(Host.cpus).mockReturnValue([]);
+    vi.mocked(Host.cwd).mockReturnValue(MOCK_CWD);
+    vi.mocked(Host.tmpdir).mockReturnValue('/tmp');
+    registerUnmock(Host, actual.Host);
+    return mocked;
+});
+vi.mock(import('./Http.js'), async (importActual) => {
+    const actual = await importActual();
+    const mocked = mockStaticMethodsOfExports(actual);
+    registerUnmock(mocked.Http, actual.Http);
+    return mocked;
+});
+vi.mock(import('./Module.js'), async (importActual) => {
+    const actual = await importActual();
+    const mocked = mockStaticMethodsOfExports(actual);
+    registerUnmock(mocked.Module, actual.Module);
     return mocked;
 });
-vi.mock(import('./Host.js'), async (importActual) => mockStaticMethodsOfExportedClasses(await importActual()));
-vi.mock(import('./Http.js'), async (importActual) => mockStaticMethodsOfExportedClasses(await importActual()));
 const logger = {
-    start: vi.fn(),
-    debug: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    fatal: vi.fn(),
+    start: vi.fn(() => Promise.resolve()),
+    debug: vi.fn().mockImplementation((attributes) => console.debug(attributes)),
+    info: vi.fn().mockImplementation((attributes) => console.log(attributes)),
+    warn: vi.fn().mockImplementation((attributes) => console.warn(attributes)),
+    error: vi.fn().mockImplementation((attributes) => console.error(attributes)),
+    fatal: vi.fn().mockImplementation((attributes) => {
+        console.error(attributes);
+        const error = new _ExitShutdownError();
+        error.message = `logger.fatal [${attributes.source}] ${attributes.message}`;
+        if (attributes.error !== undefined) {
+            error.cause = attributes.error;
+        }
+        throw error;
+    }),
     stop: vi.fn()
 };
 vi.mock(import('./logger.js'), () => ({ logger }));
 vi.mock(import('./Path.js'), async (importActual) => {
-    const mocked = mockStaticMethodsOfExportedClasses(await importActual());
+    const actual = await importActual();
+    const mocked = mockStaticMethodsOfExports(actual);
     const { Path } = mocked;
-    vi.mocked(Path.isAbsolute).mockImplementation((path) => path.startsWith('/'));
+    vi.mocked(Path.basename).mockImplementation((path) => basename(path));
+    vi.mocked(Path.dirname).mockImplementation((path) => join(path, '..').replaceAll('\\', '/'));
+    vi.mocked(Path.extname).mockImplementation((path) => extname(path));
+    vi.mocked(Path.isAbsolute).mockImplementation((path) => path.startsWith('/') || path.startsWith('~/'));
     vi.mocked(Path.join).mockImplementation((...arguments_) => join(...arguments_).replaceAll('\\', '/'));
+    vi.mocked(Path.relative).mockImplementation((from, to) => relative(from, to).replaceAll('\\', '/'));
+    registerUnmock(Path, actual.Path);
+    return mocked;
+});
+vi.mock(import('./Process.js'), async (importActual) => {
+    const actual = await importActual();
+    const mocked = mockStaticMethodsOfExports(actual);
+    const { Process } = mocked;
+    vi.mocked(Process.sleep).mockImplementation((ms) => setTimeout(ms));
+    registerUnmock(Process, actual.Process);
     return mocked;
 });
-vi.mock(import('./Process.js'), async (importActual) => mockStaticMethodsOfExportedClasses(await importActual()));
 export let __lastTerminalRawModeCallback = false;
 vi.mock(import('./Terminal.js'), async (importActual) => {
     const actual = await importActual();
     const originalstripVTControlCharacters = actual.Terminal.stripVTControlCharacters;
-    const mocked = mockStaticMethodsOfExportedClasses(actual);
+    const mocked = mockStaticMethodsOfExports(actual);
     const { Terminal } = mocked;
     vi.mocked(Terminal.setRawMode).mockImplementation((callback) => {
         __lastTerminalRawModeCallback = callback;
@@ -79,7 +164,7 @@ vi.mock(import('./Terminal.js'), async (importActual) => {
     return mocked;
 });
 vi.mock(import('./Thread.js'), async (importActual) => {
-    const mocked = mockStaticMethodsOfExportedClasses(await importActual());
+    const mocked = mockStaticMethodsOfExports(await importActual());
     const { Thread } = mocked;
     const channel = {
         postMessage: vi.fn().mockImplementation((data) => {
@@ -93,12 +178,24 @@ vi.mock(import('./Thread.js'), async (importActual) => {
     const worker = eventTarget;
     Object.assign(worker, {
         on: eventTarget.addEventListener.bind(eventTarget),
-        postMessage: vi.fn()
+        postMessage: vi.fn(),
+        unref: vi.fn()
     });
     vi.mocked(Thread.createWorker).mockReturnValue(worker);
     return mocked;
 });
 vi.mock(import('./version.js'), () => ({
-    version: vi.fn().mockResolvedValue('ui5-test-runner@1.2.3')
+    version: vi.fn().mockResolvedValue({ name: 'ui5-test-runner', version: '1.2.3' })
 }));
-vi.mock(import('./ZLib.js'), async (importActual) => mockStaticMethodsOfExportedClasses(await importActual()));
+vi.mock(import('./ZLib.js'), async (importActual) => {
+    const actual = await importActual();
+    const mocked = mockStaticMethodsOfExports(actual);
+    registerUnmock(mocked.ZLib, actual.ZLib);
+    return mocked;
+});
+vi.mock(import('./Url.js'), async (importActual) => {
+    const actual = await importActual();
+    const mocked = mockStaticMethodsOfExports(actual);
+    registerUnmock(mocked.Url, actual.Url);
+    return mocked;
+});

package/dist/platform/version.js

@@ -3,6 +3,5 @@ import { __sourcesRoot } from './constants.js';
 import { Path } from './Path.js';
 import { memoize } from '../utils/shared/memoize.js';
 export const version = memoize(async () => {
-    const { name, version } = JSON.parse(await FileSystem.readFile(Path.join(__sourcesRoot, '../package.json'), 'utf8'));
-    return `${name}@${version}`;
+    return JSON.parse(await FileSystem.readFile(Path.join(__sourcesRoot, '../package.json'), 'utf8'));
 });

package/dist/platform/workerBootstrap.js

@@ -8,7 +8,7 @@ const main = async () => {
         await workerMain(data);
     }
     catch (error) {
-        logger.fatal({ source: 'thread', message: `An error occurred`, error, data: { path } });
+        logger.fatal({ source: 'thread', message: `an error occurred`, error, data: { path } });
     }
     finally {
         logger.debug({

package/dist/reports/initReportBuilder.js

@@ -0,0 +1,18 @@
+import { version } from '../platform/version.js';
+import { Host } from '../platform/index.js';
+import { toPlainObject } from '../utils/shared/object.js';
+import { anonymize } from '../utils/node/anonymize.js';
+import { TestReportBuilder } from '../utils/shared/TestReportBuilder.js';
+export async function initReportBuilder(configuration) {
+    const { name: toolName, version: toolVersion } = await version();
+    const builder = new TestReportBuilder(crypto.randomUUID(), `${toolName}@${toolVersion}`);
+    builder.report.results.tool = { name: toolName, version: toolVersion };
+    builder.report.results.environment = {
+        osPlatform: Host.platform(),
+        osRelease: Host.osRelease(),
+        osVersion: Host.osVersion(),
+        extra: { machine: Host.machine(), cpus: Host.cpus() }
+    };
+    builder.report.extra = { configuration: anonymize(toPlainObject(configuration)) };
+    return builder;
+}

package/dist/reports/junit.js

@@ -0,0 +1,64 @@
+import { FileSystem, Path } from '../platform/index.js';
+function xmlEscape(text) {
+    return text.replaceAll(/[<>&"]/g, (match) => ({ '<': '&lt;', '>': '&gt;', '&': '&amp;', '"': '&quot;' })[match]);
+}
+function groupBySuite(tests) {
+    const suitesByName = new Map();
+    for (const test of tests) {
+        const suiteName = test.suite?.[0] ?? '(root)';
+        let bucket = suitesByName.get(suiteName);
+        if (bucket === undefined) {
+            bucket = [];
+            suitesByName.set(suiteName, bucket);
+        }
+        bucket.push(test);
+    }
+    return suitesByName;
+}
+function testcaseLines(test, suiteName) {
+    const classname = test.suite && test.suite.length > 1 ? test.suite.slice(1).join('.') : suiteName;
+    const lines = [
+        `    <testcase name="${xmlEscape(test.name)}" classname="${xmlEscape(classname)}" time="${(test.duration / 1000).toFixed(3)}">`
+    ];
+    if (test.status === 'skipped' || test.status === 'pending') {
+        lines.push('      <skipped/>');
+    }
+    else if (test.status === 'failed') {
+        const message = test.message ? ` message="${xmlEscape(test.message)}"` : '';
+        lines.push(`      <failure${message}>`);
+        if (test.trace) {
+            lines.push(xmlEscape(test.trace));
+        }
+        lines.push('      </failure>');
+    }
+    const attachments = test.attachments ?? [];
+    for (const attachment of attachments) {
+        lines.push(`      <system-out>[[ATTACHMENT|${attachment.path}]]</system-out>`);
+    }
+    lines.push('    </testcase>');
+    return lines;
+}
+function suiteLines(suiteName, suiteTests) {
+    const failures = suiteTests.filter((t) => t.status === 'failed').length;
+    const skipped = suiteTests.filter((t) => t.status === 'skipped' || t.status === 'pending').length;
+    const time = (suiteTests.reduce((accumulator, t) => accumulator + t.duration, 0) / 1000).toFixed(3);
+    return [
+        `  <testsuite name="${xmlEscape(suiteName)}" tests="${suiteTests.length}" failures="${failures}" skipped="${skipped}" time="${time}">`,
+        ...suiteTests.flatMap((test) => testcaseLines(test, suiteName)),
+        '  </testsuite>'
+    ];
+}
+export function generateJUnitReport(configuration, report) {
+    if (!configuration.junitXmlFilename) {
+        return;
+    }
+    const { summary, tests } = report.results;
+    const time = ((summary.stop - summary.start) / 1000).toFixed(3);
+    const lines = [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        `<testsuites name="ui5-test-runner" tests="${summary.tests}" failures="${summary.failed}" skipped="${summary.skipped}" time="${time}">`,
+        ...[...groupBySuite(tests)].flatMap(([name, suiteTests]) => suiteLines(name, suiteTests)),
+        '</testsuites>'
+    ];
+    FileSystem.writeFileSync(Path.join(configuration.reportDir, configuration.junitXmlFilename), lines.join('\n'), 'utf8');
+}

package/dist/reports/saveReport.js

@@ -0,0 +1,10 @@
+import { FileSystem, Path } from '../platform/index.js';
+import { generateHtmlReport } from './html.js';
+import { generateJUnitReport } from './junit.js';
+import { generateTextReport } from './textReport.js';
+export async function saveReport(configuration, report) {
+    FileSystem.writeFileSync(Path.join(configuration.reportDir, 'report.json'), JSON.stringify(report, undefined, 2), 'utf8');
+    generateTextReport(configuration, report);
+    await generateHtmlReport(configuration, report);
+    generateJUnitReport(configuration, report);
+}

package/dist/reports/textReport.js

@@ -0,0 +1,92 @@
+import { logger } from '../platform/index.js';
+const PASSED_COUNT_WIDTH = 3;
+const pageUrlOf = (test) => {
+    const suite = test.suite ?? [];
+    for (let index = suite.length - 1; index >= 0; --index) {
+        const entry = suite[index];
+        try {
+            const { protocol } = new URL(entry);
+            if (protocol === 'http:' || protocol === 'https:') {
+                return entry;
+            }
+        }
+        catch {
+        }
+    }
+    return suite[0] ?? test.name;
+};
+const moduleOf = (test, pageUrl) => {
+    const suite = test.suite ?? [];
+    const pageIndex = suite.lastIndexOf(pageUrl);
+    const tail = pageIndex === -1 ? suite : suite.slice(pageIndex + 1);
+    return tail.join(' ▶ ');
+};
+const groupByPage = (tests) => {
+    const pages = new Map();
+    for (const test of tests) {
+        const url = pageUrlOf(test);
+        let page = pages.get(url);
+        if (page === undefined) {
+            page = { url, passed: 0, skipped: 0, total: 0, isOpa: false, failures: [] };
+            pages.set(url, page);
+        }
+        ++page.total;
+        if (test.status === 'passed') {
+            ++page.passed;
+        }
+        else if (test.status === 'failed') {
+            page.failures.push(test);
+        }
+        else if (test.status === 'skipped' || test.status === 'pending') {
+            ++page.skipped;
+        }
+        if (test.extra?.type === 'opa') {
+            page.isOpa = true;
+        }
+    }
+    return pages.values().toArray();
+};
+const reportFailures = (page) => {
+    const shown = page.isOpa ? page.failures.slice(0, 1) : page.failures;
+    for (const test of shown) {
+        const module = moduleOf(test, page.url);
+        let message = `[${page.url}]\n` + (module ? `${module} ▶ ${test.name}` : test.name);
+        if (test.message) {
+            message += `\n  ${test.message}`;
+        }
+        if (test.trace) {
+            message += `\n  ${test.trace}`;
+        }
+        logger.error({ source: 'job', message });
+    }
+    if (page.isOpa && page.failures.length > 1) {
+        logger.warn({
+            source: 'job',
+            message: `[${page.url}]\n${page.failures.length} failures; showing first OPA error only`
+        });
+    }
+};
+const statusOf = (page) => {
+    if (page.failures.length > 0) {
+        return 'FAIL';
+    }
+    return page.passed === 0 && page.skipped > 0 ? 'SKIP' : 'PASS';
+};
+export function generateTextReport(_configuration, report) {
+    const pages = groupByPage(report.results.tests);
+    if (pages.length === 0) {
+        return;
+    }
+    logger.info({ source: 'job', message: 'Test report:' });
+    for (const page of pages) {
+        const ratio = `${page.passed.toString().padStart(PASSED_COUNT_WIDTH, ' ')}/${page.total}`;
+        logger.info({ source: 'job', message: `${statusOf(page)} ${ratio}  ${page.url}` });
+    }
+    if (report.results.summary.failed > 0) {
+        for (const page of pages) {
+            if (page.failures.length > 0) {
+                reportFailures(page);
+            }
+        }
+    }
+}

package/dist/reserveLogger.js

@@ -0,0 +1,22 @@
+import { logger } from './platform/index.js';
+export const logReserve = (server) => {
+    server
+        .on('created', () => {
+        logger.debug({ source: 'reserve', message: 'created', data: {} });
+    })
+        .on('ready', (event) => {
+        const { eventName: message, ...data } = event;
+        logger.debug({ source: 'reserve', message, data });
+        logger.info({ source: 'server', message: `server listening on: ${event.url}` });
+    })
+        .on('error', (event) => {
+        const { eventName: message, reason: error, ...data } = event;
+        logger.debug({ source: 'reserve', message, data, error });
+    });
+    for (const eventName of ['incoming', 'redirecting', 'redirected', 'aborted', 'closed']) {
+        server.on(eventName, (event) => {
+            const { eventName: message, ...data } = event;
+            logger.debug({ source: 'reserve', message, data });
+        });
+    }
+};

package/dist/sendToParentProcess.js

@@ -0,0 +1,6 @@
+import { Host, Process } from './platform/index.js';
+export const sendToParentProcess = (message) => {
+    if (Host.env['UI5TR_BATCH_MODE']) {
+        Process.sendToParent(message);
+    }
+};