@hydranium/protocol 1.0.0-next.33 → 1.0.0-next.331

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/worker-handshake.d.ts

@@ -0,0 +1,86 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+/**
+ * The handshake between a page and the worker hosting its heads, shared by
+ * both ends so neither can drift from the other.
+ *
+ * **Every head gets its own `MessagePort`; none is bound to the worker
+ * global.** The heads share one worker so they share one Langium store, and
+ * that makes the global contended: a head bound to it receives every other
+ * head's traffic, since a JSON-RPC reader filters nothing. The global is
+ * unusable even for a single head: GLSP's worker launcher posts its startup
+ * handshake through the global `postMessage` regardless of the connection it
+ * was configured with, a plain string no JSON-RPC reader can parse.
+ *
+ * The global therefore carries the host protocol: the bootstrap in, the ready
+ * message and failure reports out, and whatever else the host adds for
+ * itself. A message that belongs to a head belongs on that head's port.
+ *
+ * The ports are {@link TransferredMessagePort}s, because this package compiles
+ * without the DOM lib and the structural type is also what rejects a `Worker`
+ * or the worker global at an adopter's call site.
+ */
+import type { TransferredMessagePort } from './post-message-transport';
+/** Discriminator of the bootstrap message a page posts on the worker global. */
+export declare const WORKER_BOOTSTRAP_MESSAGE_TYPE = "hydranium/bootstrap";
+/** One transferred port per head. */
+export interface HeadPorts {
+    readonly lsp: TransferredMessagePort;
+    readonly data: TransferredMessagePort;
+    readonly glsp: TransferredMessagePort;
+}
+/** The one message the worker answers, by starting its heads on the ports. */
+export interface WorkerBootstrapMessage {
+    readonly type: typeof WORKER_BOOTSTRAP_MESSAGE_TYPE;
+    readonly ports: HeadPorts;
+}
+export declare function isWorkerBootstrapMessage(value: unknown): value is WorkerBootstrapMessage;
+/**
+ * Discriminator of the message the worker posts on the global once every head
+ * is up. Until it arrives, the page takes the `Worker`'s `error` event as a
+ * worker that never started and ends the heads; after it, as an uncaught error
+ * the worker runs on from, which it reports and keeps the heads through.
+ */
+export declare const WORKER_READY_MESSAGE_TYPE = "hydranium/ready";
+export interface WorkerReadyMessage {
+    readonly type: typeof WORKER_READY_MESSAGE_TYPE;
+    /** The files the heads came up on, when the worker's host named a root to read them under. */
+    readonly workspace?: WorkerWorkspace;
+}
+/**
+ * What the worker's filesystem holds under {@link rootUri} once its heads are
+ * up, which is what a page opens its editors on: once a store can differ from
+ * the seed, an editor opened on the seed overwrites the restored document.
+ */
+export interface WorkerWorkspace {
+    readonly rootUri: string;
+    /** Every file's content, keyed by its path relative to {@link rootUri}. */
+    readonly files: Readonly<Record<string, string>>;
+    /** The paths of {@link files} that came out of the store rather than the seed. */
+    readonly restored: readonly string[];
+}
+export declare function isWorkerReadyMessage(value: unknown): value is WorkerReadyMessage;
+/**
+ * Discriminator of a failure report the worker posts on the global.
+ *
+ * A worker has no console anyone is looking at, and the failures that matter
+ * most reach nobody by default: a workspace walk that throws has no reply to
+ * reject, so it looks exactly like a workspace with no documents in it.
+ */
+export declare const WORKER_ERROR_MESSAGE_TYPE = "hydranium/worker-error";
+/** The phase a failed bootstrap reports under; no head answers after it. */
+export declare const WORKER_BOOTSTRAP_PHASE = "bootstrap";
+export interface WorkerErrorMessage {
+    readonly type: typeof WORKER_ERROR_MESSAGE_TYPE;
+    /** What the worker was doing, {@link WORKER_BOOTSTRAP_PHASE} for a failed bootstrap. */
+    readonly phase: string;
+    readonly message: string;
+}
+export declare function isWorkerErrorMessage(value: unknown): value is WorkerErrorMessage;
+//# sourceMappingURL=worker-handshake.d.ts.map

package/lib/client/worker-handshake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-handshake.d.ts","sourceRoot":"","sources":["../../src/client/worker-handshake.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAEvE,gFAAgF;AAChF,eAAO,MAAM,6BAA6B,wBAAwB,CAAC;AAEnE,qCAAqC;AACrC,MAAM,WAAW,SAAS;IACvB,QAAQ,CAAC,GAAG,EAAE,sBAAsB,CAAC;IACrC,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAC;IACtC,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAC;CACxC;AAED,8EAA8E;AAC9E,MAAM,WAAW,sBAAsB;IACpC,QAAQ,CAAC,IAAI,EAAE,OAAO,6BAA6B,CAAC;IACpD,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;CAC5B;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,sBAAsB,CAMxF;AAED;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,oBAAoB,CAAC;AAE3D,MAAM,WAAW,kBAAkB;IAChC,QAAQ,CAAC,IAAI,EAAE,OAAO,yBAAyB,CAAC;IAChD,8FAA8F;IAC9F,QAAQ,CAAC,SAAS,CAAC,EAAE,eAAe,CAAC;CACvC;AAED;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACjD,kFAAkF;IAClF,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB,CAEhF;AAED;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,2BAA2B,CAAC;AAElE,4EAA4E;AAC5E,eAAO,MAAM,sBAAsB,cAAc,CAAC;AAElD,MAAM,WAAW,kBAAkB;IAChC,QAAQ,CAAC,IAAI,EAAE,OAAO,yBAAyB,CAAC;IAChD,wFAAwF;IACxF,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC3B;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB,CAMhF"}

package/lib/client/worker-handshake.js

@@ -0,0 +1,51 @@
+"use strict";
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WORKER_BOOTSTRAP_PHASE = exports.WORKER_ERROR_MESSAGE_TYPE = exports.WORKER_READY_MESSAGE_TYPE = exports.WORKER_BOOTSTRAP_MESSAGE_TYPE = void 0;
+exports.isWorkerBootstrapMessage = isWorkerBootstrapMessage;
+exports.isWorkerReadyMessage = isWorkerReadyMessage;
+exports.isWorkerErrorMessage = isWorkerErrorMessage;
+/** Discriminator of the bootstrap message a page posts on the worker global. */
+exports.WORKER_BOOTSTRAP_MESSAGE_TYPE = 'hydranium/bootstrap';
+function isWorkerBootstrapMessage(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const candidate = value;
+    return candidate.type === exports.WORKER_BOOTSTRAP_MESSAGE_TYPE && typeof candidate.ports === 'object' && candidate.ports !== null;
+}
+/**
+ * Discriminator of the message the worker posts on the global once every head
+ * is up. Until it arrives, the page takes the `Worker`'s `error` event as a
+ * worker that never started and ends the heads; after it, as an uncaught error
+ * the worker runs on from, which it reports and keeps the heads through.
+ */
+exports.WORKER_READY_MESSAGE_TYPE = 'hydranium/ready';
+function isWorkerReadyMessage(value) {
+    return typeof value === 'object' && value !== null && value.type === exports.WORKER_READY_MESSAGE_TYPE;
+}
+/**
+ * Discriminator of a failure report the worker posts on the global.
+ *
+ * A worker has no console anyone is looking at, and the failures that matter
+ * most reach nobody by default: a workspace walk that throws has no reply to
+ * reject, so it looks exactly like a workspace with no documents in it.
+ */
+exports.WORKER_ERROR_MESSAGE_TYPE = 'hydranium/worker-error';
+/** The phase a failed bootstrap reports under; no head answers after it. */
+exports.WORKER_BOOTSTRAP_PHASE = 'bootstrap';
+function isWorkerErrorMessage(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const candidate = value;
+    return candidate.type === exports.WORKER_ERROR_MESSAGE_TYPE && typeof candidate.phase === 'string' && typeof candidate.message === 'string';
+}
+//# sourceMappingURL=worker-handshake.js.map

package/lib/client/worker-handshake.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-handshake.js","sourceRoot":"","sources":["../../src/client/worker-handshake.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;;;;AAyBlF,gFAAgF;AACnE,QAAA,6BAA6B,GAAG,qBAAqB,CAAC;AAenE,kCAAyC,KAAc;IACpD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QAC/C,OAAO,KAAK,CAAC;IAChB,CAAC;IACD,MAAM,SAAS,GAAG,KAAwC,CAAC;IAC3D,OAAO,SAAS,CAAC,IAAI,KAAK,QAAA,6BAA6B,IAAI,OAAO,SAAS,CAAC,KAAK,KAAK,QAAQ,IAAI,SAAS,CAAC,KAAK,KAAK,IAAI,CAAC;AAC9H,CAAC;AAED;;;;;GAKG;AACU,QAAA,yBAAyB,GAAG,iBAAiB,CAAC;AAqB3D,8BAAqC,KAAc;IAChD,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAK,KAAqC,CAAC,IAAI,KAAK,QAAA,yBAAyB,CAAC;AACnI,CAAC;AAED;;;;;;GAMG;AACU,QAAA,yBAAyB,GAAG,wBAAwB,CAAC;AAElE,4EAA4E;AAC/D,QAAA,sBAAsB,GAAG,WAAW,CAAC;AASlD,8BAAqC,KAAc;IAChD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QAC/C,OAAO,KAAK,CAAC;IAChB,CAAC;IACD,MAAM,SAAS,GAAG,KAAoC,CAAC;IACvD,OAAO,SAAS,CAAC,IAAI,KAAK,QAAA,yBAAyB,IAAI,OAAO,SAAS,CAAC,KAAK,KAAK,QAAQ,IAAI,OAAO,SAAS,CAAC,OAAO,KAAK,QAAQ,CAAC;AACvI,CAAC"}

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"}