@hydranium/core 1.0.0-next.33 → 1.0.0-next.330

package/lib/util/connection-liveness.js

@@ -6,41 +6,100 @@
  *
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
+import { describeError } from '@hydranium/protocol';
 /**
- * Phrases `vscode-jsonrpc` uses when a call loses its connection. Matched on the
- * message because the condition surfaces in two different shapes:
+ * Phrases that mean a call lost its connection. Matched on the message because
+ * the condition surfaces in shapes that share no discriminator:
  *
  * - a **throw** from `throwIfClosedOrDisposed` (`Connection is disposed.` /
  *   `Connection is closed.`), a `ConnectionError` raised synchronously by
  *   `sendRequest` / `sendNotification` and by `RemoteConsole.send`;
  * - a **rejection** of an already-issued request (`Pending response rejected
  *   since connection got disposed`), a `ResponseError` produced when the
- *   pending-response map is drained on teardown.
+ *   pending-response map is drained on teardown;
+ * - a **write into a destroyed transport** (`Cannot call write after a stream
+ *   was destroyed`), Node's own error for a message the writer queued before
+ *   the connection was disposed and flushed after its stream was destroyed.
+ *   A notification rejects with Node's error itself, which
+ *   {@link isDestroyedStreamError} catches by its code; a request rejects with
+ *   a `ResponseError` that copies only the message, so the phrase is needed
+ *   too.
  *
- * Both are typed, but they are different error classes carrying codes from
- * different enums, so no single code check covers both. Kept
- * lowercase-normalised and anchored on `connection` so an unrelated "disposed"
- * message cannot match.
+ * The typed errors come from different classes carrying codes from different
+ * enums, so no single code check covers them. Kept lowercase-normalised and
+ * anchored on `connection` or `stream` so an unrelated "disposed" message
+ * cannot match.
  */
-const CONNECTION_GONE_PATTERNS = [/connection is disposed/, /connection is closed/, /connection got disposed/, /connection got closed/];
+const CONNECTION_GONE_PATTERNS = [
+    /connection is disposed/,
+    /connection is closed/,
+    /connection got disposed/,
+    /connection got closed/,
+    /after a stream was destroyed/
+];
+const DESTROYED_STREAM_CODE = 'ERR_STREAM_DESTROYED';
+function isDestroyedStreamError(err) {
+    return errorCode(err) === DESTROYED_STREAM_CODE;
+}
+/** `err.code` where `err` is an `Error`, or `undefined` where reading it throws, as a getter or a revoked proxy can. */
+function errorCode(err) {
+    try {
+        return err instanceof Error && 'code' in err ? err.code : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Whether `err` means "the peer is gone", as opposed to a genuine failure of
  * the operation.
  *
- * The distinction is a **log-severity** one, and it matters because the two are
- * indistinguishable at the call site otherwise. Pushing an edit to a language
- * client that has already disconnected is a no-op, not a fault — it happens on
- * every ordinary shutdown, and reporting it at `error` turns routine teardown
- * into something that looks like it needs investigation. A real `applyEdit`
- * failure (the client refused, the request malformed) still deserves `error`.
+ * The two are indistinguishable at the call site otherwise, and callers act on
+ * the answer: a gone peer is logged at `debug` or dropped, a genuine failure is
+ * logged at `error` or re-raised as an unhandled rejection. Pushing an edit to
+ * a language client that has already disconnected is a no-op, not a fault — it
+ * happens on every ordinary shutdown — so a `false` here turns routine teardown
+ * into errors that look like they need investigation. A `true` for a real
+ * `applyEdit` failure (the client refused, the request malformed) hides it.
+ *
+ * Never throws, nor does {@link isClientGoneError}: a caller classifying a
+ * failure would otherwise lose it to a getter or proxy trap of the error.
  *
  * Callers that only need to *survive* a dead connection rather than classify it
  * should just catch — see `LspLogger.emit`, whose fallback path does exactly
  * that, since a logger has nowhere to report a logging failure anyway.
  */
 export function isConnectionGoneError(err) {
-    const message = err instanceof Error ? err.message : String(err);
+    if (isDestroyedStreamError(err)) {
+        return true;
+    }
+    const message = describeError(err);
     const normalized = message.toLowerCase();
     return CONNECTION_GONE_PATTERNS.some(pattern => pattern.test(normalized));
 }
+const SOCKET_GONE_CODES = new Set(['EPIPE', 'ECONNRESET']);
+/** `write EPIPE` / `read ECONNRESET`, as a request's `ResponseError` copies the message. */
+const SOCKET_GONE_PATTERN = /\b(epipe|econnreset)\b/;
+/**
+ * Whether `err` means the client a connection serves has gone: what
+ * {@link isConnectionGoneError} recognises, or a write to a socket the client
+ * closed (`EPIPE`, `ECONNRESET`), matched by code or, for a request, by the
+ * code's name in the message.
+ *
+ * Only for a call whose errors can come from that connection alone. A socket
+ * error names no peer, so where a file system or another socket can fail the
+ * same call, it is a genuine failure and {@link isConnectionGoneError} is the
+ * one to ask.
+ */
+export function isClientGoneError(err) {
+    if (isConnectionGoneError(err)) {
+        return true;
+    }
+    const code = errorCode(err);
+    if (typeof code === 'string' && SOCKET_GONE_CODES.has(code)) {
+        return true;
+    }
+    const message = describeError(err);
+    return SOCKET_GONE_PATTERN.test(message.toLowerCase());
+}
 //# sourceMappingURL=connection-liveness.js.map

package/lib/util/connection-liveness.js.map

@@ -1 +1 @@
-{"version":3,"file":"connection-liveness.js","sourceRoot":"","sources":["../../src/util/connection-liveness.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,wBAAwB,GAAG,CAAC,wBAAwB,EAAE,sBAAsB,EAAE,yBAAyB,EAAE,uBAAuB,CAAC,CAAC;AAExI;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,qBAAqB,CAAC,GAAY;IAC/C,MAAM,OAAO,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACjE,MAAM,UAAU,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IACzC,OAAO,wBAAwB,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;AAC7E,CAAC"}
+{"version":3,"file":"connection-liveness.js","sourceRoot":"","sources":["../../src/util/connection-liveness.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,wBAAwB,GAAG;IAC9B,wBAAwB;IACxB,sBAAsB;IACtB,yBAAyB;IACzB,uBAAuB;IACvB,8BAA8B;CAChC,CAAC;AAEF,MAAM,qBAAqB,GAAG,sBAAsB,CAAC;AAErD,SAAS,sBAAsB,CAAC,GAAY;IACzC,OAAO,SAAS,CAAC,GAAG,CAAC,KAAK,qBAAqB,CAAC;AACnD,CAAC;AAED,wHAAwH;AACxH,SAAS,SAAS,CAAC,GAAY;IAC5B,IAAI,CAAC;QACF,OAAO,GAAG,YAAY,KAAK,IAAI,MAAM,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;IACvE,CAAC;IAAC,MAAM,CAAC;QACN,OAAO,SAAS,CAAC;IACpB,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,qBAAqB,CAAC,GAAY;IAC/C,IAAI,sBAAsB,CAAC,GAAG,CAAC,EAAE,CAAC;QAC/B,OAAO,IAAI,CAAC;IACf,CAAC;IACD,MAAM,OAAO,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC;IACnC,MAAM,UAAU,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IACzC,OAAO,wBAAwB,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;AAC7E,CAAC;AAED,MAAM,iBAAiB,GAAG,IAAI,GAAG,CAAC,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC;AAE3D,4FAA4F;AAC5F,MAAM,mBAAmB,GAAG,wBAAwB,CAAC;AAErD;;;;;;;;;;GAUG;AACH,MAAM,UAAU,iBAAiB,CAAC,GAAY;IAC3C,IAAI,qBAAqB,CAAC,GAAG,CAAC,EAAE,CAAC;QAC9B,OAAO,IAAI,CAAC;IACf,CAAC;IACD,MAAM,IAAI,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC;IAC5B,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAC3D,OAAO,IAAI,CAAC;IACf,CAAC;IACD,MAAM,OAAO,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC;IACnC,OAAO,mBAAmB,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;AAC1D,CAAC"}

package/lib/util/environment.d.ts

@@ -29,6 +29,13 @@ export type ProcessEvent = 'exit' | 'beforeExit' | 'uncaughtException' | 'unhand
  * `process`, no such events).
  */
 export declare function onProcessEvent(event: ProcessEvent, handler: (...args: unknown[]) => void): void;
+/**
+ * Whether a Node-like `process` exposes a writable standard error. A stricter
+ * test for Node than {@link processEnv}, since a bundler can shim
+ * `process.env` into a browser build without a writable stderr. `false`
+ * where reading the stderr throws, as a shim's getter can.
+ */
+export declare function hasProcessStderr(): boolean;
 /**
  * Write already-formatted text to the process's standard error, when a
  * Node-like `process` exposes one. Returns `true` when the text was written and

package/lib/util/environment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../../src/util/environment.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAYlF,wEAAwE;AACxE,wBAAgB,UAAU,IAAI,MAAM,CAAC,UAAU,GAAG,SAAS,CAE1D;AAED,gEAAgE;AAChE,wBAAgB,UAAU,IAAI,MAAM,GAAG,SAAS,CAE/C;AAED;;;;;;;;;GASG;AACH,wBAAgB,2BAA2B,IAAI,OAAO,CAGrD;AAED,2FAA2F;AAC3F,MAAM,MAAM,YAAY,GACrB,MAAM,GAAG,YAAY,GAAG,mBAAmB,GAAG,oBAAoB,GAAG,kBAAkB,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEzI;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,GAAG,IAAI,CAI/F;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAMjD;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAKrG"}
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../../src/util/environment.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAYlF,wEAAwE;AACxE,wBAAgB,UAAU,IAAI,MAAM,CAAC,UAAU,GAAG,SAAS,CAE1D;AAED,gEAAgE;AAChE,wBAAgB,UAAU,IAAI,MAAM,GAAG,SAAS,CAE/C;AAED;;;;;;;;;GASG;AACH,wBAAgB,2BAA2B,IAAI,OAAO,CAGrD;AAED,2FAA2F;AAC3F,MAAM,MAAM,YAAY,GACnB,MAAM,GACN,YAAY,GACZ,mBAAmB,GACnB,oBAAoB,GACpB,kBAAkB,GAClB,SAAS,GACT,QAAQ,GACR,SAAS,GACT,QAAQ,CAAC;AAEd;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,GAAG,IAAI,CAI/F;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAM1C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAMjD;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAKrG"}

package/lib/util/environment.js

@@ -47,6 +47,20 @@ export function onProcessEvent(event, handler) {
         process.on(event, handler);
     }
 }
+/**
+ * Whether a Node-like `process` exposes a writable standard error. A stricter
+ * test for Node than {@link processEnv}, since a bundler can shim
+ * `process.env` into a browser build without a writable stderr. `false`
+ * where reading the stderr throws, as a shim's getter can.
+ */
+export function hasProcessStderr() {
+    try {
+        return typeof process !== 'undefined' && !!process.stderr && typeof process.stderr.write === 'function';
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Write already-formatted text to the process's standard error, when a
  * Node-like `process` exposes one. Returns `true` when the text was written and
@@ -59,7 +73,7 @@ export function onProcessEvent(event, handler) {
  * process inherits when it spawns a head as a child.
  */
 export function writeStderr(text) {
-    if (typeof process === 'undefined' || !process.stderr || typeof process.stderr.write !== 'function') {
+    if (!hasProcessStderr()) {
         return false;
     }
     process.stderr.write(text);

package/lib/util/environment.js.map

@@ -1 +1 @@
-{"version":3,"file":"environment.js","sourceRoot":"","sources":["../../src/util/environment.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,8EAA8E;AAC9E,2EAA2E;AAC3E,gFAAgF;AAChF,4EAA4E;AAC5E,EAAE;AACF,2EAA2E;AAC3E,gFAAgF;AAChF,gFAAgF;AAChF,6EAA6E;AAE7E,wEAAwE;AACxE,MAAM,UAAU,UAAU;IACvB,OAAO,OAAO,OAAO,KAAK,WAAW,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC;AAClF,CAAC;AAED,gEAAgE;AAChE,MAAM,UAAU,UAAU;IACvB,OAAO,OAAO,OAAO,KAAK,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC;AACnE,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,2BAA2B;IACxC,MAAM,QAAQ,GAAG,OAAO,OAAO,KAAK,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;IAC/E,OAAO,QAAQ,KAAK,OAAO,IAAI,QAAQ,KAAK,QAAQ,CAAC;AACxD,CAAC;AAMD;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,KAAmB,EAAE,OAAqC;IACtF,IAAI,OAAO,OAAO,KAAK,WAAW,IAAI,OAAO,OAAO,CAAC,EAAE,KAAK,UAAU,EAAE,CAAC;QACtE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC9B,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,WAAW,CAAC,IAAY;IACrC,IAAI,OAAO,OAAO,KAAK,WAAW,IAAI,CAAC,OAAO,CAAC,MAAM,IAAI,OAAO,OAAO,CAAC,MAAM,CAAC,KAAK,KAAK,UAAU,EAAE,CAAC;QACnG,OAAO,KAAK,CAAC;IAChB,CAAC;IACD,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC3B,OAAO,IAAI,CAAC;AACf,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,kBAAkB;IAC/B,IAAI,OAAO,OAAO,KAAK,WAAW,IAAI,OAAO,OAAO,CAAC,WAAW,KAAK,UAAU,EAAE,CAAC;QAC/E,OAAO,SAAS,CAAC;IACpB,CAAC;IACD,OAAO,OAAO,CAAC,WAAW,EAAE,CAAC;AAChC,CAAC"}
+{"version":3,"file":"environment.js","sourceRoot":"","sources":["../../src/util/environment.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,8EAA8E;AAC9E,2EAA2E;AAC3E,gFAAgF;AAChF,4EAA4E;AAC5E,EAAE;AACF,2EAA2E;AAC3E,gFAAgF;AAChF,gFAAgF;AAChF,6EAA6E;AAE7E,wEAAwE;AACxE,MAAM,UAAU,UAAU;IACvB,OAAO,OAAO,OAAO,KAAK,WAAW,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC;AAClF,CAAC;AAED,gEAAgE;AAChE,MAAM,UAAU,UAAU;IACvB,OAAO,OAAO,OAAO,KAAK,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC;AACnE,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,2BAA2B;IACxC,MAAM,QAAQ,GAAG,OAAO,OAAO,KAAK,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;IAC/E,OAAO,QAAQ,KAAK,OAAO,IAAI,QAAQ,KAAK,QAAQ,CAAC;AACxD,CAAC;AAcD;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,KAAmB,EAAE,OAAqC;IACtF,IAAI,OAAO,OAAO,KAAK,WAAW,IAAI,OAAO,OAAO,CAAC,EAAE,KAAK,UAAU,EAAE,CAAC;QACtE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC9B,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB;IAC7B,IAAI,CAAC;QACF,OAAO,OAAO,OAAO,KAAK,WAAW,IAAI,CAAC,CAAC,OAAO,CAAC,MAAM,IAAI,OAAO,OAAO,CAAC,MAAM,CAAC,KAAK,KAAK,UAAU,CAAC;IAC3G,CAAC;IAAC,MAAM,CAAC;QACN,OAAO,KAAK,CAAC;IAChB,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,WAAW,CAAC,IAAY;IACrC,IAAI,CAAC,gBAAgB,EAAE,EAAE,CAAC;QACvB,OAAO,KAAK,CAAC;IAChB,CAAC;IACD,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC3B,OAAO,IAAI,CAAC;AACf,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,kBAAkB;IAC/B,IAAI,OAAO,OAAO,KAAK,WAAW,IAAI,OAAO,OAAO,CAAC,WAAW,KAAK,UAAU,EAAE,CAAC;QAC/E,OAAO,SAAS,CAAC;IACpB,CAAC;IACD,OAAO,OAAO,CAAC,WAAW,EAAE,CAAC;AAChC,CAAC"}

package/lib/util/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/util/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAEnD;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC1B,mFAAmF;IACnF,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,sGAAsG;IACtG,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;GAQG;AACH,qBAAa,QAAQ,CAAC,CAAC,SAAS,YAAY;IACzC,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,EAAE,CAAM;IACnC,wEAAwE;IACxE,SAAS,CAAC,YAAY,EAAE,SAAS,CAAC,EAAE,GAAG,SAAS,CAAC;IAEjD;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,IAAI,EAAE,CAAC,GAAG,UAAU;IAgB7B,sFAAsF;IACtF,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAU/B,uDAAuD;IACvD,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAIxB,2DAA2D;IAC3D,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAI9B,kCAAkC;IAClC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,GAAG,IAAI,SAAS,CAAC,EAAE;CAMrB"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/util/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAEnD;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC1B,mFAAmF;IACnF,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,sGAAsG;IACtG,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;GAQG;AACH,qBAAa,QAAQ,CAAC,CAAC,SAAS,YAAY;IACzC,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,EAAE,CAAM;IACnC,wEAAwE;IACxE,SAAS,CAAC,YAAY,EAAE,SAAS,CAAC,EAAE,GAAG,SAAS,CAAC;IAEjD;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,IAAI,EAAE,CAAC,GAAG,UAAU,CAc5B;IAED,sFAAsF;IACtF,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAQ9B;IAED,uDAAuD;IACvD,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAEvB;IAED,2DAA2D;IAC3D,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAE7B;IAED,kCAAkC;IAClC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,GAAG,IAAI,SAAS,CAAC,EAAE,CAKlB;CACH"}

package/package.json

@@ -1,33 +1,40 @@
 {
   "name": "@hydranium/core",
-  "version": "1.0.0-next.33",
+  "version": "1.0.0-next.330",
   "description": "Foundational runtime of the hydranium framework: AST coordination layer (services, integrity, AST extension, serialization, multi-client documents) plus the LSP textual head at the /lsp subpath. Consumed by protocol-head packages (@hydranium/data-server, @hydranium/glsp-server).",
   "keywords": [
+    "ast",
     "hydranium",
     "langium",
     "language-server",
     "lsp",
-    "ast",
     "serialization"
   ],
   "homepage": "https://github.com/eclipse-emfcloud/hydranium/tree/main/packages/core",
   "bugs": {
     "url": "https://github.com/eclipse-emfcloud/hydranium/issues"
   },
+  "license": "MIT",
+  "author": {
+    "name": "Hydranium Team"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/eclipse-emfcloud/hydranium.git",
     "directory": "packages/core"
   },
-  "license": "MIT",
-  "author": {
-    "name": "Hydranium Team"
-  },
+  "files": [
+    "lib",
+    "src",
+    "!lib/**/*.tsbuildinfo"
+  ],
+  "type": "module",
   "sideEffects": [
     "./lib/node/index.js",
     "./lib/util/index.js"
   ],
-  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "exports": {
     ".": {
       "types": "./lib/index.d.ts",
@@ -37,18 +44,14 @@
       "types": "./lib/lsp/index.d.ts",
       "default": "./lib/lsp/index.js"
     },
-    "./lib/lsp": {
-      "types": "./lib/lsp/index.d.ts",
-      "default": "./lib/lsp/index.js"
+    "./browser": {
+      "types": "./lib/browser/index.d.ts",
+      "default": "./lib/browser/index.js"
     },
     "./node": {
       "types": "./lib/node/index.d.ts",
       "default": "./lib/node/index.js"
     },
-    "./lib/node": {
-      "types": "./lib/node/index.d.ts",
-      "default": "./lib/node/index.js"
-    },
     "./testing": {
       "types": "./lib/testing/index.d.ts",
       "default": "./lib/testing/index.js"
@@ -57,70 +60,51 @@
       "types": "./lib/testing/node/index.d.ts",
       "default": "./lib/testing/node/index.js"
     },
-    "./lib/testing/node": {
-      "types": "./lib/testing/node/index.d.ts",
-      "default": "./lib/testing/node/index.js"
-    },
-    "./lib/testing": {
-      "types": "./lib/testing/index.d.ts",
-      "default": "./lib/testing/index.js"
-    },
     "./testing/playwright": {
       "types": "./lib/testing/playwright/index.d.ts",
       "default": "./lib/testing/playwright/index.js"
     },
-    "./lib/testing/playwright": {
-      "types": "./lib/testing/playwright/index.d.ts",
-      "default": "./lib/testing/playwright/index.js"
-    },
     "./messages": {
       "types": "./lib/messages/index.d.ts",
       "default": "./lib/messages/index.js"
-    },
-    "./lib/messages": {
-      "types": "./lib/messages/index.d.ts",
-      "default": "./lib/messages/index.js"
     }
   },
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
-  "files": [
-    "lib",
-    "src",
-    "!lib/**/*.tsbuildinfo"
-  ],
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "audit:mutation": "stryker run",
     "audit:mutation:quick": "stryker run --mutate src/langium/model-service/model-service.ts",
-    "build": "tsc -b",
-    "clean": "rimraf lib tsconfig.tsbuildinfo",
-    "lint": "eslint src test --max-warnings 0",
+    "build": "tsc -b tsconfig.browser.json",
+    "clean": "rimraf lib tsconfig.tsbuildinfo tsconfig.browser.tsbuildinfo",
+    "lint": "oxlint --format stylish --config ../../oxlint.config.cjs src test --max-warnings 0",
     "prepack": "node -e \"const m=require('./package.json'),fs=require('node:fs');const missing=[m.main,...Object.values(m.bin||{})].filter(entry=>entry&&!fs.existsSync(entry));if(missing.length){console.error('prepack '+m.name+': not built ('+missing.join(', ')+' missing). Run the build before packing: a files entry that matches nothing is skipped silently, so the tarball would ship src only.');process.exit(1);}\"",
     "test": "npm run typecheck:test && vitest run",
-    "typecheck:test": "tsc --noEmit -p tsconfig.test.json",
-    "watch": "tsc -b -w --preserveWatchOutput"
+    "typecheck:test": "tsc --noEmit -p tsconfig.test.json && tsc --noEmit -p tsconfig.browser.test.json",
+    "watch": "tsc -b tsconfig.browser.json -w --preserveWatchOutput"
   },
   "dependencies": {
     "diff": "^5.2.0"
   },
   "devDependencies": {
-    "@hydranium/langium": "1.0.0-next.33",
-    "@hydranium/protocol": "1.0.0-next.33",
-    "@playwright/test": "^1.40.0",
+    "@hydranium/langium": "1.0.0-next.330",
+    "@hydranium/protocol": "1.0.0-next.330",
+    "@playwright/test": "^1.55.0",
     "@types/diff": "^5.2.0",
+    "fake-indexeddb": "^6.2.5",
     "rimraf": "^5.0.0",
-    "typescript": "^5.8.0",
-    "vscode-jsonrpc": "9.0.1",
-    "vscode-languageserver": "~10.0.1",
-    "vscode-languageserver-protocol": "~3.18.2",
+    "typescript": "^7.0.2",
+    "vscode-jsonrpc": "9.0.0",
+    "vscode-languageserver": "10.0.1",
+    "vscode-languageserver-protocol": "3.18.1",
     "vscode-languageserver-textdocument": "^1.0.12",
     "vscode-languageserver-types": "^3.17.5"
   },
   "peerDependencies": {
-    "@hydranium/langium": "1.0.0-next.33",
-    "@hydranium/protocol": "1.0.0-next.33",
+    "@hydranium/langium": "1.0.0-next.330",
+    "@hydranium/protocol": "1.0.0-next.330",
     "@playwright/test": "^1.40.0",
-    "vscode-jsonrpc": "9.0.1",
+    "vscode-jsonrpc": "^9.0.0",
     "vscode-languageserver": "~10.0.1",
     "vscode-languageserver-protocol": "~3.18.1",
     "vscode-languageserver-textdocument": "^1.0.12",
@@ -134,10 +118,7 @@
   "engines": {
     "node": ">=22.13"
   },
-  "publishConfig": {
-    "access": "public"
-  },
-  "//peerDependencies": "`vscode-jsonrpc` is EXACT rather than a range, because it is one link of an atomic chain with no independently movable link: `vscode-languageserver-protocol` depends on it at exactly 9.0.1, so any other value an adopter supplies is a SECOND physical copy rather than an upgrade. This wire stack breaks on copy identity rather than on structure — `ParameterStructures.auto` is a singleton compared by `===` in connection.js, so a request type built by one copy and sent over a connection owned by the other throws `Unknown parameter structure auto`. A caret or union range was rejected because npm then resolves a `vscode-jsonrpc@8.2.0` tree SILENTLY, with no diagnostic at all, and the failure surfaces only later at server init. Exact does not fail the install either — npm downgrades an unsatisfiable peer to a warning — but it is a NAMED ERESOLVE warning printing the required version beside the found one, and a hard error for anyone installing with `--strict-peer-deps`. It does NOT prevent a NESTED copy — `@eclipse-glsp/*` carries its own exact `vscode-jsonrpc@8.2.0` dependency and root `overrides` do not ship — so a consumer of the GLSP head must pin the chain in its own manifest, and docs/adopting/requirements.md carries the block to paste. This manifest declares the two links ABOVE the transport as well, and they carry `~` for the same reason: each admits exactly what `langium@4.3.1` itself admits, and a wider range reaches a `vscode-languageserver@9` / `vscode-languageserver-protocol@3.17.x` that depends on the 8.x transport, which is the same split one level up. `vscode-languageserver-types` and `vscode-languageserver-textdocument` are deliberately NOT narrowed: both declare zero dependencies and expose structural APIs, so a duplicate of either drags no transport in and no identity check reads it.",
-  "//prepack": "The publish guard, and it deliberately is NOT a `prepare`: npm runs a workspace `prepare` BEFORE the root `postinstall` that applies patches/vscode-jsonrpc+9.0.1.patch, so building there fails on a cold clone and npm rolls the entire install back. `prepack` runs only when a tarball is made (`npm pack`, `npm publish`) and never on install, so it cannot break the install it has no business touching. It FAILS rather than rebuilds, because the rebuild is exactly the part that ordering defeats. What it defends against: `files` lists `lib`, `lib` is gitignored, and a `files` entry matching nothing is skipped SILENTLY — so `npm publish` from an unbuilt tree emits a tarball of `src` and nothing else, with no error.",
-  "//sideEffects": "NOT `false`: two barrels do work at module load that their re-exports do not account for, and a bundler skips an unflagged re-export barrel outright. `node/index.js` calls `installNodeLogFileSink()` and `installNodeWriteLockScope()`, which is how a Node host gets the log file-tee and write-lock reentrancy detection merely by importing `@hydranium/core/node`. `util/index.js` carries a bare `import '@hydranium/langium'` so the `UriUtils` namespace augmentation stays loaded for anything importing from here. Both failures are runtime-only and silent — a missing log file, a `UriUtils.toUri` that is `undefined`."
+  "//peerDependencies": "`vscode-jsonrpc` takes a caret, so the framework shares the transport the LSP connection resolves, which an `init` scaffold pins: each `vscode-languageserver-protocol` release pins its transport exactly, so an exact peer would name a copy a fresh install rarely holds. The caret excludes 8.x, so a tree whose top holds GLSP's copy fails the peer with a named ERESOLVE warning, an error under `--strict-peer-deps`, rather than resolving silently. No peer reaches a NESTED copy, such as GLSP's or one the LSP packages nest. The wire compares message types and `ResponseError`s by copy identity, so the framework sends typed messages by method name and recognises errors with `isResponseError` rather than `instanceof`. This manifest declares the two links ABOVE the transport as well, with `~`: each admits exactly what the pinned `langium` itself admits, and a range reaching back past the 3.18 stack admits a release on the 8.x transport. `vscode-languageserver-types` and `vscode-languageserver-textdocument` are deliberately NOT narrowed: both declare zero dependencies and expose structural APIs, so a duplicate of either drags no transport in and no identity check reads it.",
+  "//prepack": "The publish guard, a `prepack` rather than a `prepare`: `prepack` runs only when a tarball is made (`npm pack`, `npm publish`) and never on install, so it cannot break the install it has no business touching. What it defends against: `files` lists `lib`, `lib` is gitignored, and a `files` entry matching nothing is skipped SILENTLY — so `npm publish` from an unbuilt tree emits a tarball of `src` and nothing else, with no error.",
+  "//sideEffects": "NOT `false`: two barrels do work at module load that their re-exports do not account for, and a bundler skips an unflagged re-export barrel outright. `node/index.js` calls `installNodeLogFileSink()`, `installNodeWriteLockScope()` and `startCpuProfileFromEnv()`, which is how a Node host gets the log file-tee, write-lock reentrancy detection and the `HYDRANIUM_CPU_PROFILE_FILE` profile merely by importing `@hydranium/core/node`. `util/index.js` carries a bare `import '@hydranium/langium'` so the `UriUtils` namespace augmentation stays loaded for anything importing from here. All three failures are runtime-only and silent — a missing log file, a missing profile, a `UriUtils.toUri` that is `undefined`."
 }

package/src/browser/host-heads-in-worker.ts

@@ -0,0 +1,218 @@
+/********************************************************************************
+ * 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 {
+   describeErrorWithStack,
+   isWorkerBootstrapMessage,
+   WORKER_BOOTSTRAP_PHASE,
+   WORKER_ERROR_MESSAGE_TYPE,
+   WORKER_READY_MESSAGE_TYPE,
+   type HeadPorts,
+   type WorkerErrorMessage,
+   type WorkerReadyMessage,
+   type WorkerWorkspace
+} from '@hydranium/protocol';
+import { isOperationCancelled, URI } from '@hydranium/langium';
+import type { ServerSharedServicesMinimal } from '../langium/shared-services.js';
+import { isFileSystemProviderRegistry } from '../langium/workspace/file-system-provider.js';
+import { hasLspConnection, initializeWorkspaceWithoutLsp } from '../langium/workspace/initialize-workspace.js';
+import { PersistentFileSystemProvider } from '../langium/workspace/persistent-file-system-provider.js';
+import { isConnectionGoneError } from '../util/connection-liveness.js';
+
+/**
+ * Report a failure to the page on the worker global, the channel no head is
+ * allowed to bind, which is what keeps it free for this. A report under
+ * {@link WORKER_BOOTSTRAP_PHASE} ends the page's heads; any other phase is
+ * shown there and the heads stay. The stack goes with it: a worker has no log
+ * anyone reads, so the page is the one place the stack can be seen.
+ */
+export function reportWorkerError(phase: string, error: unknown): void {
+   const report: WorkerErrorMessage = { type: WORKER_ERROR_MESSAGE_TYPE, phase, message: describeErrorWithStack(error) };
+   postMessage(report);
+}
+
+/** What the host's `start` hands back: the shared tier, and the readiness of any head that reports it later. */
+export interface StartedHeads {
+   readonly shared: ServerSharedServicesMinimal;
+   /**
+    * The `started` promise of every head that reports a failed start through
+    * one rather than by throwing, such as the GLSP head's. The ready message
+    * waits for them, and a rejection is a failed bootstrap.
+    */
+   readonly started?: ReadonlyArray<Promise<unknown>>;
+}
+
+/** What {@link hostHeadsInWorker} does beyond starting the heads. */
+export interface HostHeadsInWorkerOptions {
+   /**
+    * The workspace root, as the page names it in `initialize`. Given one, the
+    * ready message carries every file under it with its content, and the paths
+    * restored from a {@link PersistentFileSystemProvider}'s store under it.
+    * Left out, the ready message carries no files and nothing is read. Every
+    * file's content goes in one message, so a workspace too large for that
+    * wants a per-document read instead.
+    *
+    * Required when `start` composes no LSP head: the workspace is then brought
+    * up from it before the ready message, which nothing else would do.
+    */
+   readonly rootUri?: string;
+}
+
+/**
+ * Answer the page's bootstrap by starting the heads on its ports, once per
+ * worker, and tell the page when they are up and when something fails.
+ *
+ * `start` is synchronous by type, and that is the ordering contract: every
+ * head's transport starts its port as it is built but drops what arrives
+ * before the head listens, so an `await` between building a head and
+ * listening loses the page's first request with no error. Everything
+ * asynchronous, the filesystem's restore above all, is `prepared`, which is
+ * awaited before `start` is called. It may be a plain value where nothing has
+ * to be awaited.
+ *
+ * Once `start` has returned, every `started` it handed back has resolved and,
+ * without an LSP head, the workspace has been brought up from
+ * {@link HostHeadsInWorkerOptions.rootUri}, the ready message goes out, so a
+ * page never hears of heads that failed to come up, and an uncaught error from
+ * then on is a report rather than the end
+ * of the heads. It carries the workspace's files when
+ * {@link HostHeadsInWorkerOptions.rootUri} is given. Then every document is
+ * built with validation once the workspace has initialised: Langium's initial
+ * build validates nothing, so a page that only opens its ports would see a
+ * server that indexed the workspace and says nothing. An initial build that
+ * a write during startup cancelled is built the same, since every document
+ * exists by then.
+ *
+ * Call it once: a second call answers the same bootstrap with a second set of
+ * heads on the same ports and reports every rejection twice. The worker's
+ * `unhandledrejection` listener is this function's; it drops Langium's
+ * `OperationCancelled` marker, which a build preempted by a write rejects
+ * with, as the Node host does. An uncaught throw needs no listener, since it
+ * reaches the page as the `Worker`'s own `error` event.
+ */
+export function hostHeadsInWorker<TPrepared>(
+   prepared: TPrepared | PromiseLike<TPrepared>,
+   start: (ports: HeadPorts, prepared: TPrepared) => ServerSharedServicesMinimal | StartedHeads,
+   options: HostHeadsInWorkerOptions = {}
+): void {
+   const preparation = Promise.resolve(prepared);
+   // Handled here, so a restore that fails before the bootstrap arrives reaches
+   // the page once, under the bootstrap phase, and not first as an unhandled
+   // rejection.
+   preparation.catch(() => undefined);
+
+   // Rejections only, and not the ones the framework's own handlers already
+   // settle: a rejected LSP handler is caught by the connection, and a failed
+   // workspace walk rejects `workspaceInitialized`, which is reported below.
+   addEventListener('unhandledrejection', event => {
+      if (isOperationCancelled(event.reason)) {
+         // Dropped from the console too, as a Node listener's presence drops
+         // it there; a reported rejection keeps its console entry, the one
+         // place its stack stays navigable.
+         event.preventDefault();
+      } else {
+         reportWorkerError('unhandled rejection', event.reason);
+      }
+   });
+
+   // One bootstrap per worker: the heads are composed against a single shared
+   // Langium tree, so a second would build a second tree over the same seed and
+   // hand out sessions that silently disagree about the workspace.
+   let bootstrapped = false;
+   // The bare global rather than `self.addEventListener`: only the former is
+   // typed against the dedicated worker's event map, where `message` carries a
+   // `MessageEvent`.
+   addEventListener('message', event => {
+      if (bootstrapped || !isWorkerBootstrapMessage(event.data)) {
+         return;
+      }
+      bootstrapped = true;
+      // `.catch` rather than try/catch: a rejected restore, a `start` that
+      // throws and a head whose `started` rejects arrive by the same route, and
+      // all have to reach the page.
+      onBootstrap(event.data.ports).catch((error: unknown) => reportWorkerError(WORKER_BOOTSTRAP_PHASE, error));
+   });
+
+   async function onBootstrap(ports: HeadPorts): Promise<void> {
+      const value = await preparation;
+      const result = start(ports, value);
+      const { shared, started } = 'shared' in result ? result : { shared: result, started: undefined };
+      // Without an LSP head the workspace is brought up here, queued in the step
+      // `start` returns in: a page message is handled in a later task, so no
+      // request settles against a workspace not yet brought up. Its throw is a
+      // rejection, so the awaiting below still handles every head's `started`.
+      const bringUp = hasLspConnection(shared)
+         ? undefined
+         : new Promise<void>(resolve =>
+              resolve(initializeWorkspaceWithoutLsp(shared, options.rootUri === undefined ? undefined : URI.parse(options.rootUri)))
+           );
+      // Safe to await now: every head listens already, so nothing is lost.
+      await Promise.all([...(started ?? []), bringUp]);
+      const ready: WorkerReadyMessage = {
+         type: WORKER_READY_MESSAGE_TYPE,
+         workspace: options.rootUri === undefined ? undefined : readWorkspace(shared, options.rootUri)
+      };
+      postMessage(ready);
+      validateWorkspace(shared).catch((error: unknown) => reportWorkerError('workspace validation', error));
+   }
+}
+
+/**
+ * Every file under `rootUri`, walked through the bound provider, so a file
+ * that exists only in the store is included, which the seed's keys would miss.
+ */
+function readWorkspace(shared: ServerSharedServicesMinimal, rootUri: string): WorkerWorkspace {
+   const provider = shared.workspace.FileSystemProvider;
+   const root = URI.parse(rootUri);
+   // Keys past the root, a trailing slash on it or not.
+   const prefix = `${root.toString().replace(/\/$/, '')}/`;
+   // No prototype, so a file named `__proto__` is a key like any other.
+   const files: Record<string, string> = Object.create(null);
+   const visit = (uri: URI): void => {
+      for (const node of provider.readDirectorySync(uri)) {
+         if (node.isFile) {
+            files[node.uri.toString().slice(prefix.length)] = provider.readFileSync(node.uri);
+         } else {
+            visit(node.uri);
+         }
+      }
+   };
+   visit(root);
+   // The bound slot is the scheme registry, so the provider that holds the
+   // root is the one its scheme selects. Its store may key under another
+   // root, absolutely or unencoded, so a restored path is resolved as the
+   // provider resolves it, and one outside this root names no file here.
+   const holder = isFileSystemProviderRegistry(provider) ? provider.providerFor(root) : provider;
+   // A set, since a store may hold one file under two spellings.
+   const restored = new Set<string>();
+   if (holder instanceof PersistentFileSystemProvider) {
+      for (const path of holder.restoredPaths) {
+         const uri = holder.storeUri(path).toString();
+         if (uri.startsWith(prefix) && Object.hasOwn(files, uri.slice(prefix.length))) {
+            restored.add(uri.slice(prefix.length));
+         }
+      }
+   }
+   return { rootUri, files, restored: [...restored] };
+}
+
+/**
+ * The trailing validating build, after `workspaceInitialized`: building before
+ * it would validate a partial document set. A cancelled or connection-gone
+ * initial build is routine, so it is built through; any other failure is the
+ * caller's to report.
+ */
+async function validateWorkspace(shared: ServerSharedServicesMinimal): Promise<void> {
+   await shared.workspace.WorkspaceManager.workspaceInitialized.catch((error: unknown) => {
+      if (!isOperationCancelled(error) && !isConnectionGoneError(error)) {
+         throw error;
+      }
+   });
+   await shared.workspace.DocumentBuilder.build(shared.workspace.LangiumDocuments.all.toArray(), { validation: true });
+}

package/src/browser/index.ts

@@ -0,0 +1,17 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+
+// Worker-only entry (`@hydranium/core/browser`). Compiled as its own project
+// against `lib.webworker`, so a worker global such as `indexedDB` or
+// `postMessage` resolves here and nowhere else in the package: the portable
+// `.` barrel must stay free of DOM and worker globals, since it also loads in a
+// plain Node consumer.
+export * from './host-heads-in-worker.js';
+export * from './indexeddb-file-system-store.js';
+export * from './start-language-server-in-worker.js';