@hydranium/protocol 1.0.0-next.10

package/lib/host-diagnostics.js

@@ -0,0 +1,18 @@
+"use strict";
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, 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
+ ********************************************************************************/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HOST_DIAGNOSTICS_PATH = void 0;
+/**
+ * Theia service path the host-diagnostics RPC service is registered under. An
+ * ordinary in-process backend service (`RpcConnectionHandler`), unlike the
+ * socket-forwarded `DATA_SERVER_PATH`.
+ */
+exports.HOST_DIAGNOSTICS_PATH = '/hydranium/host-diagnostics';
+//# sourceMappingURL=host-diagnostics.js.map

package/lib/host-diagnostics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-diagnostics.js","sourceRoot":"","sources":["../src/host-diagnostics.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;AAkDlF;;;;GAIG;AACU,QAAA,qBAAqB,GAAG,6BAA6B,CAAC"}

package/lib/index.d.ts

@@ -0,0 +1,34 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, 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
+ ********************************************************************************/
+export * from './abstract-logger';
+export * from './client';
+export * from './clock';
+export * from './data';
+export * from './browser-runtime';
+export * from './debouncer';
+export * from './errors';
+export * from './host-diagnostics';
+export * from './logger';
+export * from './latency-collector';
+export * from './patch-merge';
+export * from './noop-logger';
+export * from './observable-value';
+export * from './profile-session';
+export * from './profiling';
+export * from './tracer';
+export * from './transfer-diagnostic';
+export * from './transfer-element';
+export * from './model-service';
+export * from './transfer-document';
+export * from './model-server';
+export * from './project';
+export * from './rpc';
+export * from './uri';
+export * from './util';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AASlF,cAAc,mBAAmB,CAAC;AAClC,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,oBAAoB,CAAC;AACnC,cAAc,UAAU,CAAC;AACzB,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,OAAO,CAAC;AACtB,cAAc,OAAO,CAAC;AACtB,cAAc,QAAQ,CAAC"}

package/lib/index.js

@@ -0,0 +1,56 @@
+"use strict";
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, 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
+ ********************************************************************************/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Public API barrel — re-exports every PRODUCTION entry of `@hydranium/protocol`.
+// `./client` and `./data` are re-exported as well as declared standalone, so a
+// consumer wanting the whole production surface needs one specifier while one
+// wanting a narrower graph can still name the subpath. `./testing` is excluded
+// on the opposite constraint: re-exporting it would put the test doubles in
+// every production bundle that imports the root.
+__exportStar(require("./abstract-logger"), exports);
+__exportStar(require("./client"), exports);
+__exportStar(require("./clock"), exports);
+__exportStar(require("./data"), exports);
+__exportStar(require("./browser-runtime"), exports);
+__exportStar(require("./debouncer"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./host-diagnostics"), exports);
+__exportStar(require("./logger"), exports);
+__exportStar(require("./latency-collector"), exports);
+__exportStar(require("./patch-merge"), exports);
+__exportStar(require("./noop-logger"), exports);
+__exportStar(require("./observable-value"), exports);
+__exportStar(require("./profile-session"), exports);
+__exportStar(require("./profiling"), exports);
+__exportStar(require("./tracer"), exports);
+__exportStar(require("./transfer-diagnostic"), exports);
+__exportStar(require("./transfer-element"), exports);
+__exportStar(require("./model-service"), exports);
+__exportStar(require("./transfer-document"), exports);
+__exportStar(require("./model-server"), exports);
+__exportStar(require("./project"), exports);
+__exportStar(require("./rpc"), exports);
+__exportStar(require("./uri"), exports);
+__exportStar(require("./util"), exports);
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;;;;;;;;;;;;;;AAElF,kFAAkF;AAClF,+EAA+E;AAC/E,8EAA8E;AAC9E,+EAA+E;AAC/E,4EAA4E;AAC5E,iDAAiD;AAEjD,oDAAkC;AAClC,2CAAyB;AACzB,0CAAwB;AACxB,yCAAuB;AACvB,oDAAkC;AAClC,8CAA4B;AAC5B,2CAAyB;AACzB,qDAAmC;AACnC,2CAAyB;AACzB,sDAAoC;AACpC,gDAA8B;AAC9B,gDAA8B;AAC9B,qDAAmC;AACnC,oDAAkC;AAClC,8CAA4B;AAC5B,2CAAyB;AACzB,wDAAsC;AACtC,qDAAmC;AACnC,kDAAgC;AAChC,sDAAoC;AACpC,iDAA+B;AAC/B,4CAA0B;AAC1B,wCAAsB;AACtB,wCAAsB;AACtB,yCAAuB"}

package/lib/latency-collector.d.ts

@@ -0,0 +1,126 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, 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 { type Clock, type Stopwatch } from './clock.js';
+/** Latency/throughput for one method over the collection window. */
+export interface MethodLatency {
+    /**
+     * Whatever key the caller passed to {@link LatencyCollector.record} or
+     * {@link LatencyCollector.time} — the framework feeds it RPC and LSP method
+     * names, but nothing enforces that, so two feeds using different spellings
+     * for one operation report as two methods.
+     */
+    method: string;
+    /**
+     * Calls since construction or the last {@link LatencyCollector.reset}, which
+     * is the only thing that clears it. Unaffected by retention: a ring-buffer
+     * collector keeps counting long after it stops keeping samples. Failed calls
+     * are counted — a call that threw still consumed time.
+     */
+    count: number;
+    /**
+     * Milliseconds, nearest-rank over the RETAINED samples rather than over
+     * {@link count} calls, so under `ring-buffer` retention it describes only the
+     * trailing window and can sit well below {@link maxMs}. `0` means no samples
+     * were retained, not that calls were instant.
+     */
+    p50Ms: number;
+    /** Milliseconds, nearest-rank; same retention caveat as {@link p50Ms}. */
+    p99Ms: number;
+    /**
+     * Milliseconds, the slowest single call since the last reset. A lifetime
+     * figure, so a spike that has aged out of a ring buffer still shows here
+     * after the percentiles have forgotten it.
+     */
+    maxMs: number;
+    /**
+     * Milliseconds summed across every call since the last reset, retention
+     * notwithstanding. This is what {@link LatencyCollector.report} ranks on, so
+     * it orders by total cost rather than by per-call slowness.
+     */
+    totalMs: number;
+}
+/** A collector snapshot: the window length and the per-method latencies, hottest first. */
+export interface LatencyReport {
+    /**
+     * Milliseconds elapsed since construction or the last
+     * {@link LatencyCollector.reset}, off the monotonic stopwatch. It bounds the
+     * throughput a caller can derive; it is not the sum of the method totals,
+     * which overlap and can exceed it under concurrency.
+     */
+    windowMs: number;
+    /**
+     * Ordered by {@link MethodLatency.totalMs} descending. A method that was
+     * never called is absent rather than present with zeroes, so an empty array
+     * means nothing ran in the window.
+     */
+    methods: MethodLatency[];
+}
+/**
+ * How many samples a collector retains for percentile estimation. `keep-all`
+ * (the default) stores every duration for exact nearest-rank percentiles — sized
+ * for a bounded diagnostics window that gets read then {@link LatencyCollector.reset}.
+ * `ring-buffer` caps retention at `maxSamplesPerMethod`, keeping only the most
+ * recent samples so a collector left running indefinitely cannot grow without
+ * bound; percentiles then cover that trailing window while `count`/`totalMs`/
+ * `maxMs` remain lifetime totals.
+ */
+export type LatencyRetention = {
+    readonly kind: 'keep-all';
+} | {
+    readonly kind: 'ring-buffer';
+    readonly maxSamplesPerMethod: number;
+};
+/** Per-method state: retained samples (bounded in ring-buffer mode) plus lifetime totals. */
+interface MethodAccumulator {
+    /** Retained durations for percentile estimation; capped in ring-buffer mode. Order is irrelevant (report sorts). */
+    readonly samples: number[];
+    /** Next slot to overwrite once the ring buffer is full (ring-buffer mode only). */
+    writeIndex: number;
+    /** Lifetime call count, unaffected by retention. */
+    count: number;
+    /** Lifetime total duration, unaffected by retention. */
+    totalMs: number;
+    /** Lifetime maximum duration, so a spike that ages out of the window still shows. */
+    maxMs: number;
+}
+/**
+ * Accumulates per-method call durations and reports count + latency percentiles.
+ * Exact (keeps every duration per method) — sized for a diagnostics window, not
+ * unbounded production telemetry; {@link reset} drops the samples and restarts
+ * the window. Feed it via {@link time} (wraps a call) or {@link record} (a
+ * pre-measured duration). Timing rides an injectable {@link Clock} so tests are
+ * deterministic on a fake clock.
+ */
+export declare class LatencyCollector {
+    protected readonly clock: Clock;
+    protected readonly retention: LatencyRetention;
+    protected readonly durations: Map<string, MethodAccumulator>;
+    protected window: Stopwatch;
+    constructor(clock?: Clock, retention?: LatencyRetention);
+    /** Record a pre-measured call duration (ms) for `method`. */
+    record(method: string, durationMs: number): void;
+    /**
+     * Run `call`, record how long it took under `method`, and return its result.
+     * The duration is recorded even when the call throws/rejects (a failed call
+     * still consumed time), then the error propagates.
+     */
+    time<T>(method: string, call: () => Promise<T>): Promise<T>;
+    time<T>(method: string, call: () => T): T;
+    /** Non-destructive snapshot: per-method latencies ordered by total time descending (use {@link reset} to drain). */
+    report(): LatencyReport;
+    /** Drop all samples and restart the window. */
+    reset(): void;
+}
+/**
+ * Render a {@link LatencyReport} as a compact ranked table for a log line or a
+ * command channel — the latency counterpart to `formatProfileReport`.
+ */
+export declare function formatLatencyReport(report: LatencyReport, label?: string): string;
+export {};
+//# sourceMappingURL=latency-collector.d.ts.map

package/lib/latency-collector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"latency-collector.d.ts","sourceRoot":"","sources":["../src/latency-collector.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAalF,OAAO,EAAE,KAAK,KAAK,EAAE,KAAK,SAAS,EAAe,MAAM,YAAY,CAAC;AAErE,oEAAoE;AACpE,MAAM,WAAW,aAAa;IAC3B;;;;;OAKG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;;OAKG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,0EAA0E;IAC1E,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC;CAClB;AAED,2FAA2F;AAC3F,MAAM,WAAW,aAAa;IAC3B;;;;;OAKG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,OAAO,EAAE,aAAa,EAAE,CAAC;CAC3B;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;CAAE,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtI,6FAA6F;AAC7F,UAAU,iBAAiB;IACxB,oHAAoH;IACpH,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAC3B,mFAAmF;IACnF,UAAU,EAAE,MAAM,CAAC;IACnB,oDAAoD;IACpD,KAAK,EAAE,MAAM,CAAC;IACd,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAC;IAChB,qFAAqF;IACrF,KAAK,EAAE,MAAM,CAAC;CAChB;AAWD;;;;;;;GAOG;AACH,qBAAa,gBAAgB;IAKvB,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK;IAC/B,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,gBAAgB;IALjD,SAAS,CAAC,QAAQ,CAAC,SAAS,iCAAwC;IACpE,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC;gBAGN,KAAK,GAAE,KAAyB,EAChC,SAAS,GAAE,gBAAuC;IAQxE,6DAA6D;IAC7D,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IAoBhD;;;;OAIG;IACH,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAC3D,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC;IA2BzC,oHAAoH;IACpH,MAAM,IAAI,aAAa;IAiBvB,+CAA+C;IAC/C,KAAK,IAAI,IAAI;CAIf;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,aAAa,EAAE,KAAK,SAAoB,GAAG,MAAM,CAa5F"}

package/lib/latency-collector.js

@@ -0,0 +1,137 @@
+"use strict";
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, 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
+ ********************************************************************************/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LatencyCollector = void 0;
+exports.formatLatencyReport = formatLatencyReport;
+/*
+ * Per-operation latency/throughput accumulator — the time/throughput axis of a
+ * profiling run (the CPU profile says "where time went in aggregate"; this says
+ * "method X ran N times at p99 Y ms"). It sits on the framework's timing
+ * primitives (`Clock`), not on a Node inspector session, so it is neutral and
+ * lives here in `protocol`: the RPC binder feeds it at one chokepoint and the
+ * LSP connection decorator feeds it at another, both cross-head. A running head
+ * holds one collector and reads `report()` out (e.g. over the diagnostics wire
+ * or into a bundle's `server-latency.json`).
+ */
+const clock_js_1 = require("./clock.js");
+/** Nearest-rank percentile of an ascending-sorted array (empty → 0). */
+function percentile(sortedAscending, percent) {
+    if (sortedAscending.length === 0) {
+        return 0;
+    }
+    const rank = Math.ceil((percent / 100) * sortedAscending.length);
+    return sortedAscending[Math.min(sortedAscending.length - 1, Math.max(0, rank - 1))];
+}
+/**
+ * Accumulates per-method call durations and reports count + latency percentiles.
+ * Exact (keeps every duration per method) — sized for a diagnostics window, not
+ * unbounded production telemetry; {@link reset} drops the samples and restarts
+ * the window. Feed it via {@link time} (wraps a call) or {@link record} (a
+ * pre-measured duration). Timing rides an injectable {@link Clock} so tests are
+ * deterministic on a fake clock.
+ */
+class LatencyCollector {
+    clock;
+    retention;
+    durations = new Map();
+    window;
+    constructor(clock = new clock_js_1.SystemClock(), retention = { kind: 'keep-all' }) {
+        this.clock = clock;
+        this.retention = retention;
+        if (retention.kind === 'ring-buffer' && retention.maxSamplesPerMethod < 1) {
+            throw new RangeError(`ring-buffer maxSamplesPerMethod must be >= 1, got ${retention.maxSamplesPerMethod}`);
+        }
+        this.window = this.clock.stopwatch();
+    }
+    /** Record a pre-measured call duration (ms) for `method`. */
+    record(method, durationMs) {
+        let accumulator = this.durations.get(method);
+        if (!accumulator) {
+            accumulator = { samples: [], writeIndex: 0, count: 0, totalMs: 0, maxMs: 0 };
+            this.durations.set(method, accumulator);
+        }
+        accumulator.count++;
+        accumulator.totalMs += durationMs;
+        if (durationMs > accumulator.maxMs) {
+            accumulator.maxMs = durationMs;
+        }
+        if (this.retention.kind === 'ring-buffer' && accumulator.samples.length >= this.retention.maxSamplesPerMethod) {
+            // Buffer full: overwrite the oldest slot in O(1) (percentiles sort, so order does not matter).
+            accumulator.samples[accumulator.writeIndex] = durationMs;
+            accumulator.writeIndex = (accumulator.writeIndex + 1) % this.retention.maxSamplesPerMethod;
+        }
+        else {
+            accumulator.samples.push(durationMs);
+        }
+    }
+    time(method, call) {
+        const stopwatch = this.clock.stopwatch();
+        const finish = () => this.record(method, stopwatch.elapsedMs);
+        let result;
+        try {
+            result = call();
+        }
+        catch (error) {
+            finish();
+            throw error;
+        }
+        if (result instanceof Promise) {
+            return result.then(value => {
+                finish();
+                return value;
+            }, error => {
+                finish();
+                throw error;
+            });
+        }
+        finish();
+        return result;
+    }
+    /** Non-destructive snapshot: per-method latencies ordered by total time descending (use {@link reset} to drain). */
+    report() {
+        const methods = [];
+        for (const [method, accumulator] of this.durations) {
+            const sorted = [...accumulator.samples].sort((left, right) => left - right);
+            methods.push({
+                method,
+                count: accumulator.count,
+                totalMs: accumulator.totalMs,
+                maxMs: accumulator.maxMs,
+                p50Ms: percentile(sorted, 50),
+                p99Ms: percentile(sorted, 99)
+            });
+        }
+        methods.sort((left, right) => right.totalMs - left.totalMs);
+        return { windowMs: this.window.elapsedMs, methods };
+    }
+    /** Drop all samples and restart the window. */
+    reset() {
+        this.durations.clear();
+        this.window = this.clock.stopwatch();
+    }
+}
+exports.LatencyCollector = LatencyCollector;
+/**
+ * Render a {@link LatencyReport} as a compact ranked table for a log line or a
+ * command channel — the latency counterpart to `formatProfileReport`.
+ */
+function formatLatencyReport(report, label = 'RPC/LSP latency') {
+    const lines = [`${label} (window ${Math.round(report.windowMs)}ms):`];
+    if (report.methods.length === 0) {
+        lines.push('  (no calls recorded)');
+        return lines.join('\n');
+    }
+    for (const methodLatency of report.methods) {
+        lines.push(`  ${methodLatency.method}  n=${methodLatency.count}  total ${Math.round(methodLatency.totalMs)}ms  ` +
+            `p50 ${Math.round(methodLatency.p50Ms)}ms  p99 ${Math.round(methodLatency.p99Ms)}ms  max ${Math.round(methodLatency.maxMs)}ms`);
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=latency-collector.js.map

package/lib/latency-collector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"latency-collector.js","sourceRoot":"","sources":["../src/latency-collector.ts"],"names":[],"mappings":"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"}

package/lib/logger.d.ts

@@ -0,0 +1,119 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, 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
+ ********************************************************************************/
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug' | 'trace';
+export type LogThreshold = 'off' | LogLevel;
+export declare const LEVEL_ORDER: Record<LogThreshold, number>;
+/** Default labels rendered in the log line, padded to 5 chars so timestamps line up across sources. */
+export declare const LEVEL_LABELS: Record<LogLevel, string>;
+/**
+ * Cross-side public logger contract. Every consumer of the framework — browser
+ * client extensions, LSP servers, headless CLIs, tests — programs against this
+ * interface; concrete implementations supply platform-specific delivery
+ * (`AbstractLogger` is the abstract base class that satisfies this contract).
+ *
+ * Global threshold configuration lives on the {@link Logger} namespace
+ * (`Logger.setLevel(...)`, `Logger.getLevel()`, `Logger.isLevelEnabled(...)`).
+ *
+ * Every emit returns this logger so calls can chain (`logger.error(a).debug(b)`),
+ * and every `for` / `sub` / `with` derivation preserves the implementation type.
+ */
+export interface Logger {
+    /** Log a message at error level. */
+    error(message?: string, ...args: unknown[]): this;
+    /** Log a message at warn level. */
+    warn(message?: string, ...args: unknown[]): this;
+    /** Log a message at info level. */
+    info(message?: string, ...args: unknown[]): this;
+    /** Log a message at debug level. */
+    debug(message?: string, ...args: unknown[]): this;
+    /** High-volume diagnostic lines, only emitted at the `'trace'` threshold. */
+    trace(message?: string, ...args: unknown[]): this;
+    /** Log a message at info-level threshold with a `Log` label (rather than `Info`). */
+    log(message?: string, ...args: unknown[]): this;
+    /** Derive a child logger with `component` as a `Foo :: bar`-style suffix. */
+    for(component: string): this;
+    /** Derive a child logger by deepening the existing `Foo :: bar :: baz` chain. */
+    sub(component: string): this;
+    /** Derive a child logger appending `component` as a separate bracket: `[a] [b]`. */
+    with(component: string): this;
+    /**
+     * Derive a child logger labelled with the given URI string. Default behaviour
+     * appends the URI as a bracket via {@link with}; subclasses with workspace
+     * awareness override to display workspace-relative paths. Subclasses MAY
+     * widen the parameter type to accept URI objects directly (TypeScript method
+     * parameter bivariance permits this) — callers typed against the {@link Logger}
+     * interface stringify their URI at the call site.
+     */
+    withUri(uri: string): this;
+    /**
+     * Emit `message` at `threshold`, or do nothing when `threshold === 'off'`.
+     * Lets a caller holding a {@link LogThreshold} emit without a hand-written
+     * `if (level === 'off') return` guard.
+     */
+    logAt(threshold: LogThreshold, message: string): this;
+}
+/**
+ * Companion namespace for the {@link Logger} interface holding global
+ * threshold configuration.
+ *
+ * The threshold is process-wide: every {@link Logger} instance shares one
+ * value, so adopters don't have to wire it through each logger they
+ * construct. The timing facilities that build on a logger — `Tracer.time` /
+ * `Tracer.startTimer` — consult {@link Logger.isLevelEnabled} internally to
+ * short-circuit when the configured level suppresses output.
+ */
+export declare namespace Logger {
+    /** Set the process-wide log threshold. Every {@link Logger} instance picks up the new value live. */
+    function setLevel(level: LogThreshold): void;
+    /** Read the current process-wide log threshold. */
+    function getLevel(): LogThreshold;
+    /**
+     * Whether a message at `level` would be emitted at the current threshold.
+     * Use to guard expensive log-line construction:
+     * `if (Logger.isLevelEnabled('trace')) logger.trace(buildPayload())`.
+     */
+    function isLevelEnabled(level: LogLevel): boolean;
+    /**
+     * Whether a message at `threshold` would be emitted: `false` for `'off'`,
+     * otherwise tracks {@link isLevelEnabled}. Use to gate work behind a
+     * {@link LogThreshold} (which {@link isLevelEnabled} cannot accept).
+     */
+    function isThresholdEnabled(threshold: LogThreshold): boolean;
+}
+/** True when `value` is one of `'off' | 'error' | 'warn' | 'info' | 'debug' | 'trace'`. */
+export declare function isLogThreshold(value: unknown): value is LogThreshold;
+/**
+ * Parse a string-typed configuration value into a {@link LogThreshold}, returning
+ * `undefined` for unset or invalid inputs. Case-insensitive — `'WARN'` / `'warn'`
+ * / `'Warn'` all normalise to `'warn'`. Use to consume LSP / env-var / CLI inputs
+ * without exposing callers to the case-fold detail.
+ */
+export declare function parseLogLevel(value: unknown): LogThreshold | undefined;
+/**
+ * Names of the environment variables the server consults for its launch-time
+ * log configuration. They live in the shared protocol layer because they are
+ * the *contract* between whoever launches a server (the CLI, a test harness, a
+ * container) and the server that reads them — both sides reference one constant
+ * instead of duplicating the literal string.
+ */
+export declare const DEFAULT_LOG_LEVEL_ENV = "HYDRANIUM_LOG_LEVEL";
+/** Env var the server reads its log file-tee target from. See {@link DEFAULT_LOG_LEVEL_ENV}. */
+export declare const DEFAULT_LOG_FILE_ENV = "HYDRANIUM_LOG_FILE";
+/**
+ * Human-readable formatting helpers used in log lines and diagnostic output.
+ */
+export declare namespace Format {
+    /** Format a date as `HH:MM:SS.mmm`. Defaults to `now`. */
+    function timestamp(d?: Date): string;
+    /** Format a millisecond duration: `<1s` as `Nms`, `>=1s` as `N.NNs`. */
+    function elapsed(ms: number): string;
+    /** Format a byte count with a human-readable unit suffix (B/KB/MB/GB/TB). */
+    function bytes(count: number): string;
+}
+//# sourceMappingURL=logger.d.ts.map

package/lib/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;AACrE,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG,QAAQ,CAAC;AAE5C,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,YAAY,EAAE,MAAM,CAA8D,CAAC;AAEpH,uGAAuG;AACvG,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAMjD,CAAC;AAMF;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,MAAM;IACpB,oCAAoC;IACpC,KAAK,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAClD,mCAAmC;IACnC,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IACjD,mCAAmC;IACnC,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IACjD,oCAAoC;IACpC,KAAK,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAClD,6EAA6E;IAC7E,KAAK,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAClD,qFAAqF;IACrF,GAAG,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAChD,6EAA6E;IAC7E,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,iFAAiF;IACjF,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,oFAAoF;IACpF,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B;;;;;;;OAOG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxD;AAED;;;;;;;;;GASG;AACH,yBAAiB,MAAM,CAAC;IACrB,qGAAqG;IACrG,SAAgB,QAAQ,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CAElD;IACD,mDAAmD;IACnD,SAAgB,QAAQ,IAAI,YAAY,CAEvC;IACD;;;;OAIG;IACH,SAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAEvD;IACD;;;;OAIG;IACH,SAAgB,kBAAkB,CAAC,SAAS,EAAE,YAAY,GAAG,OAAO,CAEnE;CACH;AAED,2FAA2F;AAC3F,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAEpE;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY,GAAG,SAAS,CAGtE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,wBAAwB,CAAC;AAC3D,gGAAgG;AAChG,eAAO,MAAM,oBAAoB,uBAAuB,CAAC;AAEzD;;GAEG;AACH,yBAAiB,MAAM,CAAC;IACrB,0DAA0D;IAC1D,SAAgB,SAAS,CAAC,CAAC,GAAE,IAAiB,GAAG,MAAM,CAMtD;IAED,wEAAwE;IACxE,SAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAE1C;IAED,6EAA6E;IAC7E,SAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAY3C;CACH"}

package/lib/logger.js

@@ -0,0 +1,126 @@
+"use strict";
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, 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
+ ********************************************************************************/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Format = exports.DEFAULT_LOG_FILE_ENV = exports.DEFAULT_LOG_LEVEL_ENV = exports.Logger = exports.LEVEL_LABELS = exports.LEVEL_ORDER = void 0;
+exports.isLogThreshold = isLogThreshold;
+exports.parseLogLevel = parseLogLevel;
+exports.LEVEL_ORDER = { off: 0, error: 1, warn: 2, info: 3, debug: 4, trace: 5 };
+/** Default labels rendered in the log line, padded to 5 chars so timestamps line up across sources. */
+exports.LEVEL_LABELS = {
+    error: 'Error',
+    warn: 'Warn',
+    info: 'Info',
+    debug: 'Debug',
+    trace: 'Trace'
+};
+/** Module-global threshold; shared by every `AbstractLogger` instance so derived child
+ *  loggers pick up live updates without each having to subscribe to a configuration source. */
+let currentLevel = 'info';
+/**
+ * Companion namespace for the {@link Logger} interface holding global
+ * threshold configuration.
+ *
+ * The threshold is process-wide: every {@link Logger} instance shares one
+ * value, so adopters don't have to wire it through each logger they
+ * construct. The timing facilities that build on a logger — `Tracer.time` /
+ * `Tracer.startTimer` — consult {@link Logger.isLevelEnabled} internally to
+ * short-circuit when the configured level suppresses output.
+ */
+var Logger;
+(function (Logger) {
+    /** Set the process-wide log threshold. Every {@link Logger} instance picks up the new value live. */
+    function setLevel(level) {
+        currentLevel = level;
+    }
+    Logger.setLevel = setLevel;
+    /** Read the current process-wide log threshold. */
+    function getLevel() {
+        return currentLevel;
+    }
+    Logger.getLevel = getLevel;
+    /**
+     * Whether a message at `level` would be emitted at the current threshold.
+     * Use to guard expensive log-line construction:
+     * `if (Logger.isLevelEnabled('trace')) logger.trace(buildPayload())`.
+     */
+    function isLevelEnabled(level) {
+        return exports.LEVEL_ORDER[level] <= exports.LEVEL_ORDER[currentLevel];
+    }
+    Logger.isLevelEnabled = isLevelEnabled;
+    /**
+     * Whether a message at `threshold` would be emitted: `false` for `'off'`,
+     * otherwise tracks {@link isLevelEnabled}. Use to gate work behind a
+     * {@link LogThreshold} (which {@link isLevelEnabled} cannot accept).
+     */
+    function isThresholdEnabled(threshold) {
+        return threshold !== 'off' && isLevelEnabled(threshold);
+    }
+    Logger.isThresholdEnabled = isThresholdEnabled;
+})(Logger || (exports.Logger = Logger = {}));
+/** True when `value` is one of `'off' | 'error' | 'warn' | 'info' | 'debug' | 'trace'`. */
+function isLogThreshold(value) {
+    return typeof value === 'string' && value in exports.LEVEL_ORDER;
+}
+/**
+ * Parse a string-typed configuration value into a {@link LogThreshold}, returning
+ * `undefined` for unset or invalid inputs. Case-insensitive — `'WARN'` / `'warn'`
+ * / `'Warn'` all normalise to `'warn'`. Use to consume LSP / env-var / CLI inputs
+ * without exposing callers to the case-fold detail.
+ */
+function parseLogLevel(value) {
+    const normalised = typeof value === 'string' ? value.toLowerCase() : undefined;
+    return normalised && isLogThreshold(normalised) ? normalised : undefined;
+}
+/**
+ * Names of the environment variables the server consults for its launch-time
+ * log configuration. They live in the shared protocol layer because they are
+ * the *contract* between whoever launches a server (the CLI, a test harness, a
+ * container) and the server that reads them — both sides reference one constant
+ * instead of duplicating the literal string.
+ */
+exports.DEFAULT_LOG_LEVEL_ENV = 'HYDRANIUM_LOG_LEVEL';
+/** Env var the server reads its log file-tee target from. See {@link DEFAULT_LOG_LEVEL_ENV}. */
+exports.DEFAULT_LOG_FILE_ENV = 'HYDRANIUM_LOG_FILE';
+/**
+ * Human-readable formatting helpers used in log lines and diagnostic output.
+ */
+var Format;
+(function (Format) {
+    /** Format a date as `HH:MM:SS.mmm`. Defaults to `now`. */
+    function timestamp(d = new Date()) {
+        const hh = String(d.getHours()).padStart(2, '0');
+        const mm = String(d.getMinutes()).padStart(2, '0');
+        const ss = String(d.getSeconds()).padStart(2, '0');
+        const ms = String(d.getMilliseconds()).padStart(3, '0');
+        return `${hh}:${mm}:${ss}.${ms}`;
+    }
+    Format.timestamp = timestamp;
+    /** Format a millisecond duration: `<1s` as `Nms`, `>=1s` as `N.NNs`. */
+    function elapsed(ms) {
+        return ms < 1000 ? `${Math.round(ms)}ms` : `${(ms / 1000).toFixed(2)}s`;
+    }
+    Format.elapsed = elapsed;
+    /** Format a byte count with a human-readable unit suffix (B/KB/MB/GB/TB). */
+    function bytes(count) {
+        if (count < 1024) {
+            return `${count}B`;
+        }
+        const units = ['KB', 'MB', 'GB', 'TB'];
+        let value = count / 1024;
+        let unit = 0;
+        while (value >= 1024 && unit < units.length - 1) {
+            value /= 1024;
+            unit++;
+        }
+        return `${value.toFixed(value >= 100 ? 0 : value >= 10 ? 1 : 2)}${units[unit]}`;
+    }
+    Format.bytes = bytes;
+})(Format || (exports.Format = Format = {}));
+//# sourceMappingURL=logger.js.map