@hydranium/protocol 1.0.0-next.23 → 1.0.0-next.230

package/lib/client/rpc-connection.d.ts

@@ -0,0 +1,157 @@
+/********************************************************************************
+ * 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 { MessageConnection } from 'vscode-jsonrpc';
+import { type ResolvedMessage } from '../messages/primitives';
+import { type RpcProxy } from '../rpc';
+import type { DataPort } from './data-port';
+/**
+ * The transport never opened. A complete sentence rather than a fragment: a
+ * fragment is nested inside a sentence the framework does not own, so no
+ * translator controls the whole and the composition cannot be made to read
+ * correctly in every language.
+ */
+export declare const DATA_SERVER_CONNECT_FAILED: import("../messages/primitives").MessageDefinition<"Could not connect to the data server: {detail}">;
+export declare const DATA_SERVER_NOT_READY: import("../messages/primitives").MessageDefinition<"The data server did not become ready: {detail}">;
+/** The one method a connection needs of any server: its startup gate. */
+export interface ReadyServer {
+    waitForReady(): Promise<void>;
+}
+/**
+ * Lifecycle reporting, for a host that raises warm-up UI around the two waits.
+ *
+ * Nothing fires until something asks for the connection — the generation is
+ * built on the first {@link RpcConnection.connected}. A host that wants the
+ * sequence at startup drives that call itself, or a workspace where nobody
+ * opens a document reports neither the connect nor the readiness its UI waits
+ * on.
+ */
+export interface RpcConnectionLifecycle {
+    /** A generation is opening its transport, including on each reconnect. */
+    readonly onConnecting?: () => void;
+    /** The server's readiness gate has settled for a generation. */
+    readonly onReady?: () => void;
+    /**
+     * A generation failed to connect or to become ready. The failure is still
+     * reported through {@link DataPort.reportError} and still rejects the
+     * awaiting caller; this is for a host that also drives its own UI.
+     */
+    readonly onFailed?: (error: unknown) => void;
+}
+/** Everything {@link RpcConnection} needs once a subclass has resolved its defaults. */
+export interface ResolvedRpcConnectionOptions<TClient extends object> {
+    readonly methodNamespace: string;
+    readonly clientMethods: readonly (keyof TClient & string)[];
+    readonly lifecycle: RpcConnectionLifecycle;
+}
+/**
+ * One connection generation: its connection, its proxy, and its readiness.
+ *
+ * Named by the `protected` reconnect seams {@link RpcConnection.currentGeneration}
+ * and {@link RpcConnection.awaitReady}, so an override has to name it too.
+ */
+export interface RpcConnectionGeneration<TServer extends object> {
+    readonly connection: Promise<MessageConnection>;
+    readonly server: RpcProxy<TServer>;
+    /** Set on first use; the shared readiness gate for this generation. */
+    ready?: Promise<void>;
+}
+/**
+ * One JSON-RPC connection to a head, with the three jobs every host adapter
+ * would otherwise re-derive above {@link DataPort}:
+ *
+ * 1. **Build the typed proxy** over the port's connection, with the caller's
+ *    wire prefix and client-method allowlist.
+ * 2. **Own the readiness gate** — `waitForReady` once per connection, shared
+ *    across concurrent callers. A client can connect before the workspace walk
+ *    finishes, and an early request is then answered correctly from an empty
+ *    registry, which reads as a broken project tier rather than as a race.
+ * 3. **Own the reconnect policy**, by dropping its generation when the port
+ *    disposes and building a fresh one on the next request.
+ *
+ * Bounded only by {@link ReadyServer}, so a head serving a slice of the data
+ * protocol — diagnostics alone, or one with methods excluded — is still a
+ * legal server here. `DataConnection` narrows the bound because its sessions
+ * call the document methods; nothing at this layer does.
+ */
+export declare class RpcConnection<TServer extends ReadyServer, TClient extends object> {
+    protected readonly port: DataPort;
+    protected readonly client: TClient;
+    protected readonly methodNamespace: string;
+    protected readonly clientMethods: readonly (keyof TClient & string)[];
+    protected readonly lifecycle: RpcConnectionLifecycle;
+    /** The current generation, or `undefined` before the first request / after a teardown. */
+    protected generation?: RpcConnectionGeneration<TServer>;
+    protected disposed: boolean;
+    protected readonly portDisposeListener: {
+        dispose(): void;
+    };
+    constructor(port: DataPort, client: TClient, options: ResolvedRpcConnectionOptions<TClient>);
+    /**
+     * The connected, READY server proxy.
+     *
+     * Returns the proxy rather than `void` on purpose. A reconnect replaces the
+     * proxy, so a caller that cached one from an earlier call would go on
+     * addressing a dead connection with no error — handing it back per call
+     * makes the stale reference unrepresentable.
+     *
+     * Concurrent callers share one readiness promise, so `waitForReady` is
+     * awaited once per generation and not once per caller.
+     */
+    connected(): Promise<RpcProxy<TServer>>;
+    /**
+     * The current generation's proxy WITHOUT awaiting readiness — calls queue
+     * against the connection promise.
+     *
+     * **Protected, and that is the point.** An early request is answered
+     * correctly from a registry the workspace walk has not filled yet, which
+     * reads as a broken project tier rather than as a race — so every caller has
+     * to interpose the gate, and every caller forgetting to is a silent bug.
+     * {@link connected} is the public route and returns this same proxy once the
+     * gate has settled, which leaves nothing to forget. The one caller that
+     * cannot use it is {@link awaitReady}, whose whole job is running the gate.
+     *
+     * Read per access, never cached: a reconnect replaces the generation, and a
+     * held reference would address the dead one.
+     */
+    protected get server(): RpcProxy<TServer>;
+    /**
+     * Surface a failure the way this host does, through the port's sink.
+     *
+     * Here rather than only on the port so every participant sharing the
+     * connection reports through one route without being handed the transport.
+     */
+    reportError(error: unknown, reported: ResolvedMessage): void;
+    /** Tear down the current connection and stop tracking the port. Idempotent. */
+    dispose(): void;
+    /** The live generation, building one if there is none. */
+    protected currentGeneration(): RpcConnectionGeneration<TServer>;
+    /**
+     * The object whose {@link clientMethods} answer the server on each new
+     * generation: {@link client} itself. A subclass that must see a call before
+     * the client does returns an object that forwards each of them to it.
+     */
+    protected localTarget(): TClient;
+    /** Await the connection and the server's startup gate for one generation. */
+    protected awaitReady(generation: RpcConnectionGeneration<TServer>): Promise<void>;
+    /**
+     * Called once `generation` has passed its readiness gate, whichever request
+     * brought it up. A generation can replace one that failed at readiness
+     * without {@link dropGeneration}, so this, not a drop, is where state kept
+     * on the server is put back. It runs inside the readiness gate, so a throw
+     * from an override fails the generation as a refused gate would.
+     */
+    protected generationReady(_generation: RpcConnectionGeneration<TServer>): void;
+    /**
+     * Discard the current generation, disposing its connection if it opened.
+     * The next {@link connected} builds a fresh one.
+     */
+    protected dropGeneration(): void;
+    protected assertLive(): void;
+}
+//# sourceMappingURL=rpc-connection.d.ts.map

package/lib/client/rpc-connection.d.ts.map

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

package/lib/client/rpc-connection.js

@@ -0,0 +1,214 @@
+"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.RpcConnection = exports.DATA_SERVER_NOT_READY = exports.DATA_SERVER_CONNECT_FAILED = void 0;
+const primitives_1 = require("../messages/primitives");
+const rpc_1 = require("../rpc");
+/**
+ * The transport never opened. A complete sentence rather than a fragment: a
+ * fragment is nested inside a sentence the framework does not own, so no
+ * translator controls the whole and the composition cannot be made to read
+ * correctly in every language.
+ */
+exports.DATA_SERVER_CONNECT_FAILED = (0, primitives_1.defineMessage)('hydranium/protocol/data-server-connect-failed', 'Could not connect to the data server: {detail}');
+exports.DATA_SERVER_NOT_READY = (0, primitives_1.defineMessage)('hydranium/protocol/data-server-not-ready', 'The data server did not become ready: {detail}');
+/** Calls each distinct lifecycle's hooks in order; one passed twice is called once. */
+function composeLifecycles(...lifecycles) {
+    const present = [...new Set(lifecycles)].filter((lifecycle) => lifecycle !== undefined);
+    return {
+        onConnecting: () => present.forEach(lifecycle => lifecycle.onConnecting?.()),
+        onReady: () => present.forEach(lifecycle => lifecycle.onReady?.()),
+        onFailed: error => present.forEach(lifecycle => lifecycle.onFailed?.(error))
+    };
+}
+/**
+ * One JSON-RPC connection to a head, with the three jobs every host adapter
+ * would otherwise re-derive above {@link DataPort}:
+ *
+ * 1. **Build the typed proxy** over the port's connection, with the caller's
+ *    wire prefix and client-method allowlist.
+ * 2. **Own the readiness gate** — `waitForReady` once per connection, shared
+ *    across concurrent callers. A client can connect before the workspace walk
+ *    finishes, and an early request is then answered correctly from an empty
+ *    registry, which reads as a broken project tier rather than as a race.
+ * 3. **Own the reconnect policy**, by dropping its generation when the port
+ *    disposes and building a fresh one on the next request.
+ *
+ * Bounded only by {@link ReadyServer}, so a head serving a slice of the data
+ * protocol — diagnostics alone, or one with methods excluded — is still a
+ * legal server here. `DataConnection` narrows the bound because its sessions
+ * call the document methods; nothing at this layer does.
+ */
+class RpcConnection {
+    port;
+    client;
+    methodNamespace;
+    clientMethods;
+    lifecycle;
+    /** The current generation, or `undefined` before the first request / after a teardown. */
+    generation;
+    disposed = false;
+    portDisposeListener;
+    constructor(port, client, options) {
+        this.port = port;
+        this.client = client;
+        this.methodNamespace = options.methodNamespace;
+        this.clientMethods = options.clientMethods;
+        this.lifecycle = composeLifecycles(port.connectionLifecycle, options.lifecycle);
+        this.portDisposeListener = this.port.onDispose(() => this.dropGeneration());
+    }
+    /**
+     * The connected, READY server proxy.
+     *
+     * Returns the proxy rather than `void` on purpose. A reconnect replaces the
+     * proxy, so a caller that cached one from an earlier call would go on
+     * addressing a dead connection with no error — handing it back per call
+     * makes the stale reference unrepresentable.
+     *
+     * Concurrent callers share one readiness promise, so `waitForReady` is
+     * awaited once per generation and not once per caller.
+     */
+    async connected() {
+        this.assertLive();
+        const generation = this.currentGeneration();
+        if (!generation.ready) {
+            generation.ready = this.awaitReady(generation);
+        }
+        await generation.ready;
+        // Dropped while it opened: its transport is gone, so the call goes to the
+        // next generation, or rejects once this connection is disposed.
+        if (this.generation !== generation) {
+            return this.connected();
+        }
+        return generation.server;
+    }
+    /**
+     * The current generation's proxy WITHOUT awaiting readiness — calls queue
+     * against the connection promise.
+     *
+     * **Protected, and that is the point.** An early request is answered
+     * correctly from a registry the workspace walk has not filled yet, which
+     * reads as a broken project tier rather than as a race — so every caller has
+     * to interpose the gate, and every caller forgetting to is a silent bug.
+     * {@link connected} is the public route and returns this same proxy once the
+     * gate has settled, which leaves nothing to forget. The one caller that
+     * cannot use it is {@link awaitReady}, whose whole job is running the gate.
+     *
+     * Read per access, never cached: a reconnect replaces the generation, and a
+     * held reference would address the dead one.
+     */
+    get server() {
+        this.assertLive();
+        return this.currentGeneration().server;
+    }
+    /**
+     * Surface a failure the way this host does, through the port's sink.
+     *
+     * Here rather than only on the port so every participant sharing the
+     * connection reports through one route without being handed the transport.
+     */
+    reportError(error, reported) {
+        this.port.reportError(error, reported);
+    }
+    /** Tear down the current connection and stop tracking the port. Idempotent. */
+    dispose() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        this.portDisposeListener.dispose();
+        this.dropGeneration();
+    }
+    /** The live generation, building one if there is none. */
+    currentGeneration() {
+        if (this.generation) {
+            return this.generation;
+        }
+        this.lifecycle.onConnecting?.();
+        const connection = this.port.connect();
+        // Rejection is reported here rather than left to float: an unhandled
+        // rejection on a connection promise is the failure mode that reads as
+        // "the model is empty" instead of "the transport never opened".
+        connection.catch((error) => this.port.reportError(error, (0, primitives_1.resolve)(exports.DATA_SERVER_CONNECT_FAILED, { detail: (0, primitives_1.describeError)(error) })));
+        const server = (0, rpc_1.createRpcProxy)(connection, {
+            methodNamespace: this.methodNamespace,
+            localTarget: this.localTarget(),
+            localMethods: this.clientMethods
+        });
+        this.generation = { connection, server };
+        return this.generation;
+    }
+    /**
+     * The object whose {@link clientMethods} answer the server on each new
+     * generation: {@link client} itself. A subclass that must see a call before
+     * the client does returns an object that forwards each of them to it.
+     */
+    localTarget() {
+        return this.client;
+    }
+    /** Await the connection and the server's startup gate for one generation. */
+    async awaitReady(generation) {
+        try {
+            await generation.connection;
+            // Dropped meanwhile: writing the request would hit a closed transport.
+            if (this.generation !== generation) {
+                return;
+            }
+            await generation.server.waitForReady();
+            // Before `onReady`, so a failing restore reports a failure alone.
+            this.generationReady(generation);
+            this.lifecycle.onReady?.();
+        }
+        catch (error) {
+            // A dropped generation's request fails with its transport, which says
+            // nothing about whether the server is ready.
+            if (this.generation !== generation) {
+                return;
+            }
+            this.lifecycle.onFailed?.(error);
+            // Drop the generation so the next request retries rather than
+            // re-awaiting a settled rejection forever.
+            if (this.generation === generation) {
+                this.generation = undefined;
+            }
+            this.port.reportError(error, (0, primitives_1.resolve)(exports.DATA_SERVER_NOT_READY, { detail: (0, primitives_1.describeError)(error) }));
+            throw error;
+        }
+    }
+    /**
+     * Called once `generation` has passed its readiness gate, whichever request
+     * brought it up. A generation can replace one that failed at readiness
+     * without {@link dropGeneration}, so this, not a drop, is where state kept
+     * on the server is put back. It runs inside the readiness gate, so a throw
+     * from an override fails the generation as a refused gate would.
+     */
+    generationReady(_generation) {
+        // Nothing to put back at this layer.
+    }
+    /**
+     * Discard the current generation, disposing its connection if it opened.
+     * The next {@link connected} builds a fresh one.
+     */
+    dropGeneration() {
+        const generation = this.generation;
+        this.generation = undefined;
+        if (!generation) {
+            return;
+        }
+        generation.connection.then(connection => connection.dispose()).catch(() => undefined);
+    }
+    assertLive() {
+        if (this.disposed) {
+            throw new Error(`${this.constructor.name} is disposed`);
+        }
+    }
+}
+exports.RpcConnection = RpcConnection;
+//# sourceMappingURL=rpc-connection.js.map

package/lib/client/rpc-connection.js.map

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

package/lib/client-ids.d.ts

@@ -0,0 +1,45 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+/**
+ * Well-known values of the wire's `clientId` / `sourceClientId` field.
+ *
+ * The framework tracks each document as belonging to one or more "clients" —
+ * typically an LSP-text client (Monaco, VS Code, …), a GLSP diagram client,
+ * and/or a structured-form client — and keys its holds and watches per
+ * `(uri, clientId)`. These three values are not real participants, so a client
+ * minting its own id must avoid them.
+ *
+ * **Here rather than in the server package, because the side that has to
+ * RECOGNISE them is the client.** An inbound `onDocumentUpdated` carries
+ * `sourceClientId`, and a consumer deciding what to do with it is asking which
+ * of these it is — so a frontend would otherwise have to depend on the server
+ * tier to name three strings, and in practice retypes the literal instead.
+ */
+/** Identifier for an LSP-text client (Monaco, VS Code, …). */
+export declare const LANGUAGE_CLIENT_ID = "language-client";
+/**
+ * The id an event names when no single client is behind it: the source of a
+ * `'rebuilt'` event, a document no client authored, or a build with more than
+ * one cause.
+ */
+export declare const UNKNOWN_CLIENT_ID = "unknown";
+/**
+ * Synthetic author id on the `onDocumentUpdated` broadcast a data-server
+ * emits for the build that follows a document's release, once no client holds
+ * it; by default that build reverts the document to its disk content,
+ * discarding unsaved edits. Not a real client: it lets consumers tell the
+ * release broadcast from client-authored updates.
+ */
+export declare const DOCUMENT_RELEASE_CLIENT_ID = "document-release";
+/**
+ * Every id the framework reserves, for a client checking that the identity it
+ * is about to mint collides with none of them.
+ */
+export declare const FRAMEWORK_CLIENT_IDS: readonly string[];
+//# sourceMappingURL=client-ids.d.ts.map

package/lib/client-ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-ids.d.ts","sourceRoot":"","sources":["../src/client-ids.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF;;;;;;;;;;;;;;GAcG;AAEH,8DAA8D;AAC9D,eAAO,MAAM,kBAAkB,oBAAoB,CAAC;AAEpD;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,YAAY,CAAC;AAE3C;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,qBAAqB,CAAC;AAE7D;;;GAGG;AACH,eAAO,MAAM,oBAAoB,EAAE,SAAS,MAAM,EAAwE,CAAC"}

package/lib/client-ids.js

@@ -0,0 +1,48 @@
+"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.FRAMEWORK_CLIENT_IDS = exports.DOCUMENT_RELEASE_CLIENT_ID = exports.UNKNOWN_CLIENT_ID = exports.LANGUAGE_CLIENT_ID = void 0;
+/**
+ * Well-known values of the wire's `clientId` / `sourceClientId` field.
+ *
+ * The framework tracks each document as belonging to one or more "clients" —
+ * typically an LSP-text client (Monaco, VS Code, …), a GLSP diagram client,
+ * and/or a structured-form client — and keys its holds and watches per
+ * `(uri, clientId)`. These three values are not real participants, so a client
+ * minting its own id must avoid them.
+ *
+ * **Here rather than in the server package, because the side that has to
+ * RECOGNISE them is the client.** An inbound `onDocumentUpdated` carries
+ * `sourceClientId`, and a consumer deciding what to do with it is asking which
+ * of these it is — so a frontend would otherwise have to depend on the server
+ * tier to name three strings, and in practice retypes the literal instead.
+ */
+/** Identifier for an LSP-text client (Monaco, VS Code, …). */
+exports.LANGUAGE_CLIENT_ID = 'language-client';
+/**
+ * The id an event names when no single client is behind it: the source of a
+ * `'rebuilt'` event, a document no client authored, or a build with more than
+ * one cause.
+ */
+exports.UNKNOWN_CLIENT_ID = 'unknown';
+/**
+ * Synthetic author id on the `onDocumentUpdated` broadcast a data-server
+ * emits for the build that follows a document's release, once no client holds
+ * it; by default that build reverts the document to its disk content,
+ * discarding unsaved edits. Not a real client: it lets consumers tell the
+ * release broadcast from client-authored updates.
+ */
+exports.DOCUMENT_RELEASE_CLIENT_ID = 'document-release';
+/**
+ * Every id the framework reserves, for a client checking that the identity it
+ * is about to mint collides with none of them.
+ */
+exports.FRAMEWORK_CLIENT_IDS = [exports.LANGUAGE_CLIENT_ID, exports.UNKNOWN_CLIENT_ID, exports.DOCUMENT_RELEASE_CLIENT_ID];
+//# sourceMappingURL=client-ids.js.map

package/lib/client-ids.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-ids.js","sourceRoot":"","sources":["../src/client-ids.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;AAElF;;;;;;;;;;;;;;GAcG;AAEH,8DAA8D;AACjD,QAAA,kBAAkB,GAAG,iBAAiB,CAAC;AAEpD;;;;GAIG;AACU,QAAA,iBAAiB,GAAG,SAAS,CAAC;AAE3C;;;;;;GAMG;AACU,QAAA,0BAA0B,GAAG,kBAAkB,CAAC;AAE7D;;;GAGG;AACU,QAAA,oBAAoB,GAAsB,CAAC,QAAA,kBAAkB,EAAE,QAAA,iBAAiB,EAAE,QAAA,0BAA0B,CAAC,CAAC"}

package/lib/clock.d.ts

@@ -73,7 +73,28 @@ export interface Clock {
      */
     measure<T>(callback: () => Promise<T>): Promise<Timed<T>>;
     measure<T>(callback: () => T): Timed<T>;
+    /**
+     * Settle with `promise`, or with {@link TIMED_OUT} once `ms` have elapsed
+     * first. A promise that rejects first rejects this one; one that rejects
+     * after the timer is ignored. The timer is disposed the moment `promise`
+     * settles, so a won race leaves nothing scheduled, but `promise` itself
+     * runs on: nothing here can cancel it.
+     *
+     * Unlike VS Code's `raceTimeout`, this settles with a sentinel rather than
+     * `undefined`, so a promise resolving to `undefined` is not taken for a
+     * timeout; the caller branches on the result instead of passing an
+     * `onTimeout`.
+     *
+     * A custom implementation extends {@link SystemClock}, whose race runs over
+     * the subclass's {@link setTimer}.
+     */
+    raceTimer<T>(promise: Promise<T>, ms: number): Promise<T | typeof TIMED_OUT>;
 }
+/**
+ * What {@link Clock.raceTimer} settles with when its timer fires first.
+ * Registered under a global key, so two copies of this package agree on it.
+ */
+export declare const TIMED_OUT: unique symbol;
 /**
  * The result of {@link Clock.measure}: a callback's return value paired with
  * its elapsed wall-time in milliseconds. A plain value object — no methods, no
@@ -100,6 +121,10 @@ export interface Timed<T> {
  * Default {@link Clock}: delegates to the platform's `Date.now`,
  * `performance.now`, and `setTimeout`/`clearTimeout`. Bound everywhere in
  * production; swapped for `makeFakeClock` in tests.
+ *
+ * {@link measure} and {@link raceTimer} run over {@link stopwatch} and
+ * {@link setTimer}, so a clock that extends this one and replaces those
+ * measures and races on its own time, as the test clock does.
  */
 export declare class SystemClock implements Clock {
     now(): number;
@@ -107,5 +132,18 @@ export declare class SystemClock implements Clock {
     stopwatch(): Stopwatch;
     measure<T>(callback: () => Promise<T>): Promise<Timed<T>>;
     measure<T>(callback: () => T): Timed<T>;
+    /**
+     * The timer settles the race one microtask after it fires. A real timer
+     * runs only once pending resolutions are delivered, while a fake one fires
+     * inside its `advance`, so settling at once would let a promise already
+     * resolved when `advance` runs lose to a timer it beats in production. The
+     * deferral covers only that promise: one that settles through further
+     * chained reactions, such as a `.then` chain, an async function or
+     * `Promise.allSettled`, can still lose to an `advance` in the same turn,
+     * while it wins on the platform's timer. The handlers go on `promise`
+     * before {@link setTimer} runs, so a `setTimer` that throws still leaves
+     * `promise` observed.
+     */
+    raceTimer<T>(promise: Promise<T>, ms: number): Promise<T | typeof TIMED_OUT>;
 }
 //# sourceMappingURL=clock.d.ts.map

package/lib/clock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clock.d.ts","sourceRoot":"","sources":["../src/clock.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAEpC;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,SAAS;IACvB,mFAAmF;IACnF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,GAAG,IAAI,MAAM,CAAC;IACd;;;;OAIG;IACH,IAAI,IAAI,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,KAAK;IACnB,wEAAwE;IACxE,GAAG,IAAI,MAAM,CAAC;IACd;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU,CAAC;IACvD,yDAAyD;IACzD,SAAS,IAAI,SAAS,CAAC;IACvB;;;;;;OAMG;IACH,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1D,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;CAC1C;AAED;;;;;GAKG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC;IACrB;;;;;OAKG;IACH,MAAM,EAAE,CAAC,CAAC;IACV;;;;;OAKG;IACH,SAAS,EAAE,MAAM,CAAC;CACpB;AAyCD;;;;GAIG;AACH,qBAAa,WAAY,YAAW,KAAK;IACtC,GAAG,IAAI,MAAM;IAIb,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU;IAMtD,SAAS,IAAI,SAAS;IAItB,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACzD,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;CASzC"}
+{"version":3,"file":"clock.d.ts","sourceRoot":"","sources":["../src/clock.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAEpC;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,SAAS;IACvB,mFAAmF;IACnF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,GAAG,IAAI,MAAM,CAAC;IACd;;;;OAIG;IACH,IAAI,IAAI,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,KAAK;IACnB,wEAAwE;IACxE,GAAG,IAAI,MAAM,CAAC;IACd;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU,CAAC;IACvD,yDAAyD;IACzD,SAAS,IAAI,SAAS,CAAC;IACvB;;;;;;OAMG;IACH,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1D,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IACxC;;;;;;;;;;;;;;OAcG;IACH,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,OAAO,SAAS,CAAC,CAAC;CAC/E;AAED;;;GAGG;AACH,eAAO,MAAM,SAAS,eAA6C,CAAC;AAEpE;;;;;GAKG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC;IACrB;;;;;OAKG;IACH,MAAM,EAAE,CAAC,CAAC;IACV;;;;;OAKG;IACH,SAAS,EAAE,MAAM,CAAC;CACpB;AAyCD;;;;;;;;GAQG;AACH,qBAAa,WAAY,YAAW,KAAK;IACtC,GAAG,IAAI,MAAM,CAEZ;IAED,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU,CAIrD;IAED,SAAS,IAAI,SAAS,CAErB;IAED,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1D,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IAUxC;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,OAAO,SAAS,CAAC,CAgB3E;CACH"}

package/lib/clock.js

@@ -8,8 +8,13 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SystemClock = void 0;
+exports.SystemClock = exports.TIMED_OUT = void 0;
 const util_1 = require("./util");
+/**
+ * What {@link Clock.raceTimer} settles with when its timer fires first.
+ * Registered under a global key, so two copies of this package agree on it.
+ */
+exports.TIMED_OUT = Symbol.for('hydranium/protocol/timed-out');
 class SystemStopwatch {
     start = performance.now();
     lastLap = this.start;
@@ -48,6 +53,10 @@ function unrefTimer(handle) {
  * Default {@link Clock}: delegates to the platform's `Date.now`,
  * `performance.now`, and `setTimeout`/`clearTimeout`. Bound everywhere in
  * production; swapped for `makeFakeClock` in tests.
+ *
+ * {@link measure} and {@link raceTimer} run over {@link stopwatch} and
+ * {@link setTimer}, so a clock that extends this one and replaces those
+ * measures and races on its own time, as the test clock does.
  */
 class SystemClock {
     now() {
@@ -69,6 +78,32 @@ class SystemClock {
         }
         return { result: result, elapsedMs: stopwatch.elapsedMs };
     }
+    /**
+     * The timer settles the race one microtask after it fires. A real timer
+     * runs only once pending resolutions are delivered, while a fake one fires
+     * inside its `advance`, so settling at once would let a promise already
+     * resolved when `advance` runs lose to a timer it beats in production. The
+     * deferral covers only that promise: one that settles through further
+     * chained reactions, such as a `.then` chain, an async function or
+     * `Promise.allSettled`, can still lose to an `advance` in the same turn,
+     * while it wins on the platform's timer. The handlers go on `promise`
+     * before {@link setTimer} runs, so a `setTimer` that throws still leaves
+     * `promise` observed.
+     */
+    raceTimer(promise, ms) {
+        return new Promise((resolve, reject) => {
+            // eslint-disable-next-line prefer-const -- with a `const`, a `setTimer` that throws leaves it uninitialised, and the handlers' later read of it is an unhandled ReferenceError
+            let timer;
+            promise.then(value => {
+                timer?.dispose();
+                resolve(value);
+            }, (err) => {
+                timer?.dispose();
+                reject(err);
+            });
+            timer = this.setTimer(() => void Promise.resolve().then(() => resolve(exports.TIMED_OUT)), ms);
+        });
+    }
 }
 exports.SystemClock = SystemClock;
 //# sourceMappingURL=clock.js.map

package/lib/clock.js.map

@@ -1 +1 @@
-{"version":3,"file":"clock.js","sourceRoot":"","sources":["../src/clock.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;AAElF,iCAAoC;AA8FpC,MAAM,eAAe;IACC,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;IACnC,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC;IACrB,OAAO,CAAqB;IAEtC,IAAI,SAAS;QACV,OAAO,CAAC,IAAI,CAAC,OAAO,IAAI,WAAW,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC;IAC3D,CAAC;IAED,GAAG;QACA,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,IAAI,WAAW,CAAC,GAAG,EAAE,CAAC;QAC7C,MAAM,KAAK,GAAG,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC;QAChC,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;QAClB,OAAO,KAAK,CAAC;IAChB,CAAC;IAED,IAAI;QACD,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;YAC9B,IAAI,CAAC,OAAO,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;QACpC,CAAC;QACD,OAAO,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC;IACpC,CAAC;CACH;AAED;;;;;;;;;;GAUG;AACH,SAAS,UAAU,CAAC,MAA8B;IAC/C,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC;AACpB,CAAC;AAED;;;;GAIG;AACH,MAAa,WAAW;IACrB,GAAG;QACA,OAAO,IAAI,CAAC,GAAG,EAAE,CAAC;IACrB,CAAC;IAED,QAAQ,CAAC,QAAoB,EAAE,EAAU;QACtC,MAAM,MAAM,GAAG,UAAU,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;QACxC,UAAU,CAAC,MAAM,CAAC,CAAC;QACnB,OAAO,iBAAU,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC;IACxD,CAAC;IAED,SAAS;QACN,OAAO,IAAI,eAAe,EAAE,CAAC;IAChC,CAAC;IAID,OAAO,CAAI,QAA8B;QACtC,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QACnC,MAAM,MAAM,GAAG,QAAQ,EAAE,CAAC;QAC1B,IAAI,MAAM,YAAY,OAAO,EAAE,CAAC;YAC7B,OAAQ,MAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;QACpG,CAAC;QACD,OAAO,EAAE,MAAM,EAAE,MAAW,EAAE,SAAS,EAAE,SAAS,CAAC,SAAS,EAAE,CAAC;IAClE,CAAC;CACH;AAzBD,kCAyBC"}
+{"version":3,"file":"clock.js","sourceRoot":"","sources":["../src/clock.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;AAElF,iCAAoC;AAuFpC;;;GAGG;AACU,QAAA,SAAS,GAAG,MAAM,CAAC,GAAG,CAAC,8BAA8B,CAAC,CAAC;AAyBpE,MAAM,eAAe;IACC,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;IACnC,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC;IACrB,OAAO,CAAqB;IAEtC,IAAI,SAAS;QACV,OAAO,CAAC,IAAI,CAAC,OAAO,IAAI,WAAW,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC;IAC3D,CAAC;IAED,GAAG;QACA,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,IAAI,WAAW,CAAC,GAAG,EAAE,CAAC;QAC7C,MAAM,KAAK,GAAG,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC;QAChC,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;QAClB,OAAO,KAAK,CAAC;IAChB,CAAC;IAED,IAAI;QACD,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;YAC9B,IAAI,CAAC,OAAO,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;QACpC,CAAC;QACD,OAAO,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC;IACpC,CAAC;CACH;AAED;;;;;;;;;;GAUG;AACH,SAAS,UAAU,CAAC,MAA8B;IAC/C,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC;AACpB,CAAC;AAED;;;;;;;;GAQG;AACH;IACG,GAAG;QACA,OAAO,IAAI,CAAC,GAAG,EAAE,CAAC;IACrB,CAAC;IAED,QAAQ,CAAC,QAAoB,EAAE,EAAU;QACtC,MAAM,MAAM,GAAG,UAAU,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;QACxC,UAAU,CAAC,MAAM,CAAC,CAAC;QACnB,OAAO,iBAAU,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC;IACxD,CAAC;IAED,SAAS;QACN,OAAO,IAAI,eAAe,EAAE,CAAC;IAChC,CAAC;IAID,OAAO,CAAI,QAA8B;QACtC,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QACnC,MAAM,MAAM,GAAG,QAAQ,EAAE,CAAC;QAC1B,IAAI,MAAM,YAAY,OAAO,EAAE,CAAC;YAC7B,OAAQ,MAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;QACpG,CAAC;QACD,OAAO,EAAE,MAAM,EAAE,MAAW,EAAE,SAAS,EAAE,SAAS,CAAC,SAAS,EAAE,CAAC;IAClE,CAAC;IAED;;;;;;;;;;;OAWG;IACH,SAAS,CAAI,OAAmB,EAAE,EAAU;QACzC,OAAO,IAAI,OAAO,CAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC1D,+KAA+K;YAC/K,IAAI,KAA6B,CAAC;YAClC,OAAO,CAAC,IAAI,CACT,KAAK,CAAC,EAAE;gBACL,KAAK,EAAE,OAAO,EAAE,CAAC;gBACjB,OAAO,CAAC,KAAK,CAAC,CAAC;YAClB,CAAC,EACD,CAAC,GAAY,EAAE,EAAE;gBACd,KAAK,EAAE,OAAO,EAAE,CAAC;gBACjB,MAAM,CAAC,GAAG,CAAC,CAAC;YACf,CAAC,CACH,CAAC;YACF,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,QAAA,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QAC1F,CAAC,CAAC,CAAC;IACN,CAAC;CACH"}

package/lib/console-logger.d.ts

@@ -0,0 +1,23 @@
+/********************************************************************************
+ * 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 { AbstractLogger } from './abstract-logger';
+import { type LogLevel, type Logger } from './logger';
+/**
+ * {@link Logger} that writes each line to `console`, at the method matching its
+ * level: the framework's `[Label - time] [component]` prefix and the message,
+ * then any trailing arguments as they are, so a browser console can expand
+ * them. For a browser page, webview or extension host, which has no other sink
+ * to hand. On Node, `info` and `debug` reach stdout, so a process whose stdout
+ * carries a protocol stream must not use it.
+ */
+export declare class ConsoleLogger extends AbstractLogger implements Logger {
+    protected emit(level: LogLevel, label: string, message: string, args: readonly unknown[]): void;
+    protected derive(component: string): this;
+}
+//# sourceMappingURL=console-logger.d.ts.map