@hydranium/core 1.0.0-next.267 → 1.0.0-next.269

package/src/node/memory-monitor.ts

@@ -13,7 +13,7 @@ import { type ServerSharedServicesMinimal } from '../langium/shared-services.js'
 
 /** Heap usage ratio (heapUsed / heap_size_limit) above which we emit a warning. */
 export const DEFAULT_MEMORY_WARN_THRESHOLD = 0.85;
-/** Heap usage ratio above which we emit an error-level warning (imminent OOM likely). */
+/** Heap usage ratio above which the warning says out-of-memory is imminent. */
 export const DEFAULT_MEMORY_CRITICAL_THRESHOLD = 0.95;
 /** Cooldown between repeated warnings at the same level, in ms. */
 export const DEFAULT_COOLDOWN_MS = 30_000;
@@ -25,7 +25,7 @@ type Severity = 'ok' | 'warn' | 'critical';
 export interface MemoryMonitorOptions {
    /** Heap-usage ratio (0..1) above which a warning is emitted. Default {@link DEFAULT_MEMORY_WARN_THRESHOLD}. */
    warnThreshold?: number;
-   /** Heap-usage ratio above which an error is emitted (imminent OOM likely). Default {@link DEFAULT_MEMORY_CRITICAL_THRESHOLD}. */
+   /** Heap-usage ratio above which the warning says out-of-memory is imminent. Default {@link DEFAULT_MEMORY_CRITICAL_THRESHOLD}. */
    criticalThreshold?: number;
    /** Sample interval, in ms. Default {@link DEFAULT_MEMORY_INTERVAL_MS}. */
    intervalMs?: number;
@@ -86,9 +86,8 @@ export function startMemoryMonitor(shared: ServerSharedServicesMinimal, options:
             : severity === 'warn'
               ? ' - garbage collection pressure may slow operations'
               : ' - recovered below warning threshold');
-      if (severity === 'critical') {
-         logger.error(message);
-      } else if (severity === 'warn') {
+      // Critical is still a warning: nothing has failed yet.
+      if (severity !== 'ok') {
          logger.warn(message);
       } else {
          logger.info(message);

package/src/node/server-diagnostics.ts

@@ -49,7 +49,7 @@ export function startServerDiagnostics(shared: ServerSharedServicesMinimal, opti
       productName,
       version,
       phaseDetailThresholdMs,
-      ...nodeLogPreambleSections(phaseDetailThresholdMs)
+      ...nodeLogPreambleSections(phaseDetailThresholdMs, options)
    });
    if (options.logInitialMemory ?? true) {
       shared.Tracer.for('Process').memory('Initial Memory');

package/src/node/socket-launcher.ts

@@ -8,7 +8,7 @@
  ********************************************************************************/
 
 import * as net from 'node:net';
-import { Deferred, type Disposable, type Logger } from '@hydranium/protocol';
+import { Deferred, describeErrorWithStack, type Disposable, type Logger } from '@hydranium/protocol';
 import { createMessageConnection, SocketMessageReader, SocketMessageWriter } from 'vscode-jsonrpc/node';
 import type { MessageConnection } from 'vscode-jsonrpc';
 import type { IntegratedServer } from '../launcher/integrated-server.js';
@@ -131,7 +131,7 @@ export function startSocketServer(options: SocketServerOptions, onClientConnecti
          try {
             adopterDisposable.dispose();
          } catch (err) {
-            logger?.warn(`[${tag}] Adopter disposable threw on cleanup: ${(err as Error)?.message ?? err}`);
+            logger?.warn(`[${tag}] Adopter disposable threw on cleanup: ${describeErrorWithStack(err)}`);
          }
          connection.dispose();
          const idx = activeConnections.indexOf(entry);
@@ -164,7 +164,7 @@ export function startSocketServer(options: SocketServerOptions, onClientConnecti
       started.resolve();
    });
    netServer.on('error', err => {
-      logger?.error(`[${tag}] Error: ${err.message}`);
+      logger?.error(`[${tag}] Error: ${describeErrorWithStack(err)}`);
       started.reject(err);
    });
    netServer.on('close', () => {
@@ -174,7 +174,7 @@ export function startSocketServer(options: SocketServerOptions, onClientConnecti
          try {
             entry.adopterDisposable.dispose();
          } catch (err) {
-            logger?.warn(`[${tag}] Adopter disposable threw on shutdown: ${(err as Error)?.message ?? err}`);
+            logger?.warn(`[${tag}] Adopter disposable threw on shutdown: ${describeErrorWithStack(err)}`);
          }
          entry.connection.dispose();
       }

package/src/node/stdio-launcher.ts

@@ -7,7 +7,7 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
-import { Deferred, type Disposable, type Logger } from '@hydranium/protocol';
+import { Deferred, type Disposable, type Logger, describeError, describeErrorWithStack } from '@hydranium/protocol';
 import type { MessageConnection } from 'vscode-jsonrpc';
 import { createMessageConnection, StreamMessageReader, StreamMessageWriter } from 'vscode-jsonrpc/node';
 import type { IntegratedServer } from '../launcher/integrated-server.js';
@@ -115,17 +115,21 @@ export function startStdioServer(
       try {
          adopterDisposable.dispose();
       } catch (err: unknown) {
-         logger?.warn(`[${tag}] Adopter disposable threw on cleanup: ${err instanceof Error ? err.message : String(err)}`);
+         logger?.warn(`[${tag}] Adopter disposable threw on cleanup: ${describeErrorWithStack(err)}`);
       }
       connection.dispose();
       stopped.resolve();
    };
    connection.onClose(() => close());
 
+   // The workspace manager logs a failed initialization itself.
+   let initializing = false;
    const begin = async (): Promise<void> => {
       if (options.workspace !== undefined) {
          logger?.info(`[${tag}] Initializing workspace`);
+         initializing = true;
          await initializeWorkspaceProgrammatically(options.shared, options.workspace);
+         initializing = false;
       }
       // Only now attach the reader — see the ordering note in the doc above.
       connection.listen();
@@ -138,7 +142,11 @@ export function startStdioServer(
          // A failed startup must not leave a half-live head: report it on
          // `started` and tear the connection down rather than listening over an
          // uninitialized workspace.
-         logger?.error(`[${tag}] Startup failed: ${err instanceof Error ? err.message : String(err)}`);
+         if (initializing) {
+            logger?.debug(`[${tag}] Startup failed: the workspace did not initialize. ${describeError(err)}`);
+         } else {
+            logger?.error(`[${tag}] Startup failed: ${describeErrorWithStack(err)}`);
+         }
          started.reject(err);
          close();
       }

package/src/testing/playwright/server-log-capture.ts

@@ -415,6 +415,20 @@ export function forwardBrowserConsole(
    });
 }
 
+/** The label a `Warn` or `Error` entry starts with; continuation lines of a stack never do. */
+const WARN_OR_ERROR_LINE = /^\[(Warn|Error)\s*-/;
+
+/**
+ * The `Warn` and `Error` lines of `text` that no pattern of `allowlist`
+ * matches; its keys are the reasons the lines are expected. A clean run logs
+ * neither: `warn` is an anomaly that was handled and `error` is work that
+ * failed, so either one in a passing spec is a defect or a missing allowance.
+ */
+export function findUnexpectedServerLogLines(text: string, allowlist: Readonly<Record<string, RegExp>> = {}): string[] {
+   const patterns = Object.values(allowlist);
+   return text.split('\n').filter(line => WARN_OR_ERROR_LINE.test(line) && !patterns.some(pattern => pattern.test(line)));
+}
+
 /**
  * Per-test server-log capture, called from a spec's `afterEach` with the test's
  * workspace path:

package/src/testing/playwright/server-log-fixture.ts

@@ -11,7 +11,14 @@
 // The plain functions in `server-log-capture.ts` stay playwright-free; only
 // adopters that use this fixture need `@playwright/test` installed.
 import { test as base, type Fixtures, type PlaywrightTestArgs, type PlaywrightTestOptions } from '@playwright/test';
-import { attachServerLog, markServerLog } from './server-log-capture.js';
+import {
+   attachServerLog,
+   DEFAULT_SERVER_LOG_ATTACH_ENV,
+   findUnexpectedServerLogLines,
+   markServerLog,
+   resolveServerLogPath
+} from './server-log-capture.js';
+import { readServerLogRegion } from './server-log-region.js';
 
 export interface ServerLogFixtures {
    /**
@@ -22,6 +29,21 @@ export interface ServerLogFixtures {
     * `attachServerLog` in `beforeEach` / `afterEach` instead.
     */
    serverLogWorkspace: string;
+   /**
+    * Fail a test whose part of the server log holds a `Warn` or `Error` line
+    * that {@link serverLogAllowlist} does not match. Off by default; reads
+    * nothing when capture is off.
+    */
+   serverLogClean: boolean;
+   /**
+    * The `Warn` and `Error` lines {@link serverLogClean} lets through: each key
+    * is why the line is expected, and its pattern is matched against the whole
+    * line, label and timestamp included. A pattern takes neither the `g` nor
+    * the `y` flag, which make `test` resume from its last match. An object
+    * rather than a list, because Playwright reads an array whose second entry
+    * is an object as a fixture's `[value, options]`.
+    */
+   serverLogAllowlist: Readonly<Record<string, RegExp>>;
 }
 
 /** Full fixture set including the internal side-effect-only auto fixture. */
@@ -36,17 +58,35 @@ interface ServerLogTestFixtures extends ServerLogFixtures {
  * (teardown) — i.e. the `beforeEach` + `afterEach` pair fused into one auto
  * fixture. Compose onto any test base, or use the pre-extended {@link test}.
  * Override `serverLogWorkspace` to wire the workspace; otherwise it's inert.
+ * Set `serverLogClean` to also fail a test on an unexpected `Warn` or `Error`.
  */
 export const serverLogFixtures: Fixtures<ServerLogTestFixtures, object, PlaywrightTestArgs & PlaywrightTestOptions> = {
    serverLogWorkspace: ['', { option: true }],
+   serverLogClean: [false, { option: true }],
+   serverLogAllowlist: [{}, { option: true }],
    serverLogCapture: [
-      async ({ serverLogWorkspace }, use): Promise<void> => {
-         if (serverLogWorkspace) {
-            markServerLog(base.info(), serverLogWorkspace);
+      async ({ serverLogWorkspace, serverLogClean, serverLogAllowlist }, use): Promise<void> => {
+         if (!serverLogWorkspace) {
+            await use(undefined);
+            return;
          }
+         markServerLog(base.info(), serverLogWorkspace);
          await use(undefined);
-         if (serverLogWorkspace) {
-            await attachServerLog(base.info(), serverLogWorkspace);
+         const file = resolveServerLogPath(serverLogWorkspace);
+         const region = file ? readServerLogRegion(file) : '';
+         let problem: string | undefined;
+         if (serverLogClean) {
+            const unexpected = findUnexpectedServerLogLines(region, serverLogAllowlist);
+            if (unexpected.length > 0) {
+               problem = `The server logged ${unexpected.length} unexpected Warn or Error line(s):\n${unexpected.join('\n')}`;
+            }
+         }
+         // The failure-only policy reads the test's status, which failing here
+         // does not change; a run set to attach nothing still attaches nothing.
+         const attachOn = process.env[DEFAULT_SERVER_LOG_ATTACH_ENV] === 'never' ? 'never' : 'always';
+         await attachServerLog(base.info(), serverLogWorkspace, problem ? { attachOn } : {});
+         if (problem) {
+            throw new Error(problem);
          }
       },
       { auto: true }

package/src/testing/playwright/server-log-region.ts

@@ -0,0 +1,32 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+
+import { existsSync, readFileSync } from 'node:fs';
+
+/**
+ * How far each log has been read. A suite starts its app before its first
+ * test's marker, so reading from the marker would leave startup unread.
+ */
+const readUpTo = new Map<string, number>();
+
+/**
+ * The part of `file` written since the last read of it, up to its last complete
+ * line, since the server may be mid-write. Every test reads, checked or not, so
+ * a test that is not checked leaves no lines to the next one.
+ */
+export function readServerLogRegion(file: string): string {
+   if (!existsSync(file)) {
+      return '';
+   }
+   const log = readFileSync(file);
+   const end = log.lastIndexOf('\n') + 1;
+   const text = log.subarray(readUpTo.get(file) ?? 0, end).toString('utf-8');
+   readUpTo.set(file, end);
+   return text;
+}

package/src/util/connection-liveness.ts

@@ -7,6 +7,8 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
+import { describeError } from '@hydranium/protocol';
+
 /**
  * Phrases that mean a call lost its connection. Matched on the message because
  * the condition surfaces in shapes that share no discriminator:
@@ -64,7 +66,7 @@ export function isConnectionGoneError(err: unknown): boolean {
    if (isDestroyedStreamError(err)) {
       return true;
    }
-   const message = err instanceof Error ? err.message : String(err);
+   const message = describeError(err);
    const normalized = message.toLowerCase();
    return CONNECTION_GONE_PATTERNS.some(pattern => pattern.test(normalized));
 }
@@ -92,6 +94,6 @@ export function isClientGoneError(err: unknown): boolean {
    if (err instanceof Error && 'code' in err && typeof err.code === 'string' && SOCKET_GONE_CODES.has(err.code)) {
       return true;
    }
-   const message = err instanceof Error ? err.message : String(err);
+   const message = describeError(err);
    return SOCKET_GONE_PATTERN.test(message.toLowerCase());
 }