@hydranium/core 1.0.0-next.29 → 1.0.0-next.298

package/lib/util/connection-liveness.js

@@ -6,41 +6,87 @@
  *
  * 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 err instanceof Error && 'code' in err && err.code === DESTROYED_STREAM_CODE;
+}
 /**
  * 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.
  *
  * 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;
+    }
+    if (err instanceof Error && 'code' in err && typeof err.code === 'string' && SOCKET_GONE_CODES.has(err.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,GAAG,YAAY,KAAK,IAAI,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,IAAI,KAAK,qBAAqB,CAAC;AACtF,CAAC;AAED;;;;;;;;;;;;;;;GAeG;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,IAAI,GAAG,YAAY,KAAK,IAAI,MAAM,IAAI,GAAG,IAAI,OAAO,GAAG,CAAC,IAAI,KAAK,QAAQ,IAAI,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAC5G,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.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;;;;;;;;;;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.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;;;;;;;;;;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"}

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.29",
+  "version": "1.0.0-next.298",
   "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.29",
-    "@hydranium/protocol": "1.0.0-next.29",
+    "@hydranium/langium": "1.0.0-next.298",
+    "@hydranium/protocol": "1.0.0-next.298",
     "@playwright/test": "^1.40.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.29",
-    "@hydranium/protocol": "1.0.0-next.29",
+    "@hydranium/langium": "1.0.0-next.298",
+    "@hydranium/protocol": "1.0.0-next.298",
     "@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/index.ts

@@ -0,0 +1,14 @@
+/********************************************************************************
+ * 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` 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 './indexeddb-file-system-store.js';

package/src/browser/indexeddb-file-system-store.ts

@@ -0,0 +1,192 @@
+/********************************************************************************
+ * 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 { FileSystemSeed } from '../langium/workspace/in-memory-file-system-provider.js';
+import type { FileSystemStore } from '../langium/workspace/persistent-file-system-provider.js';
+
+/** Out-of-line keys, so a key is the store path and the value is the content. */
+const OBJECT_STORE_NAME = 'files';
+
+/**
+ * The schema version. A bump needs a migration in `onupgradeneeded`, or every
+ * returning visitor's rows are left in a store the new code never reads.
+ */
+const DATABASE_VERSION = 1;
+
+/**
+ * A {@link FileSystemStore} in `IndexedDB`, so an edit survives a reload.
+ *
+ * # Why IndexedDB and not OPFS
+ *
+ * OPFS is the tempting answer, because `createSyncAccessHandle` gives
+ * SYNCHRONOUS file reads in a worker, which is what Langium's
+ * `FileSystemProvider` needs. It buys nothing here: directory enumeration
+ * (`FileSystemDirectoryHandle.entries()`) is async-only, so a directory index
+ * still has to live in memory, and once it does the file reads are being served
+ * from memory too. IndexedDB is the smaller dependency for the same shape.
+ *
+ * # It holds the DELTA, not the workspace
+ *
+ * Only what has been written lands here, and `PersistentFileSystemProvider` lays
+ * it over the host's seed. So a fixture edited in the host's bundle still
+ * reaches a returning visitor, and this database stays a few kilobytes rather
+ * than a copy of the workspace.
+ *
+ * # A failure is loud, deliberately
+ *
+ * Nothing here degrades to non-persistent operation. A refused open, a blocked
+ * upgrade or an aborted transaction, which is what a quota overrun looks like,
+ * rejects the call, which fails the worker's bootstrap or the save that asked.
+ * The alternative, carrying on without a store, would report a saved workspace
+ * and lose it on the next load. An origin EVICTED between visits is not a
+ * failure this class can see: its database opens empty, which is a first visit,
+ * and the provider is correct in that state. Evicted mid-session, the next
+ * transaction rejects like any other failure.
+ *
+ * # The database is origin-scoped
+ *
+ * Every page on the origin shares a database of the same name, and the user
+ * agent may evict it. The name is the one per-app value and is REQUIRED for
+ * that reason: a default would let two apps on one origin overwrite each
+ * other's edits with nothing reporting it.
+ */
+export class IndexedDbFileSystemStore implements FileSystemStore {
+   /**
+    * Opened once and shared, and NOT kept when it fails: a refused or blocked
+    * open rejects the call that needed it and the next call opens again, so a
+    * cause that has cleared, such as the other tab closing, does not fail every
+    * later save with the first error.
+    */
+   protected connection?: Promise<IDBDatabase>;
+
+   constructor(protected readonly databaseName: string) {}
+
+   async load(): Promise<FileSystemSeed> {
+      const database = await this.open();
+      return new Promise<FileSystemSeed>((resolve, reject) => {
+         const transaction = database.transaction(OBJECT_STORE_NAME, 'readonly');
+         const files = transaction.objectStore(OBJECT_STORE_NAME);
+         const keyRequest = files.getAllKeys();
+         const valueRequest = files.getAll();
+         // Resolved on the TRANSACTION rather than on either request, which is
+         // what guarantees both have landed, and `getAllKeys` and `getAll`
+         // enumerate in the same key order, so they zip.
+         transaction.oncomplete = () => {
+            const keys: IDBValidKey[] = keyRequest.result;
+            const values: unknown[] = valueRequest.result;
+            const seed: Record<string, string> = {};
+            keys.forEach((key, index) => {
+               const value = values[index];
+               // Guarded rather than cast: this database outlives the code that
+               // wrote it, so a row from an older shape must be skipped instead
+               // of reaching the filesystem as non-string content.
+               if (typeof key === 'string' && typeof value === 'string') {
+                  seed[key] = value;
+               }
+            });
+            resolve(seed);
+         };
+         transaction.onabort = () => reject(this.failure(transaction, 'read the stored workspace'));
+      });
+   }
+
+   async write(path: string, content: string): Promise<void> {
+      await this.mutate('store', files => files.put(content, path));
+   }
+
+   async remove(path: string): Promise<void> {
+      await this.mutate('drop', files => files.delete(path));
+   }
+
+   /**
+    * Drop everything, returning the next load to the seed.
+    *
+    * The escape hatch a persistent host needs and a seeded one does not: a saved
+    * document that no longer parses is otherwise restored on every load, and
+    * clearing site data is the only other way out. Not on {@link FileSystemStore},
+    * which the provider never clears.
+    */
+   async clear(): Promise<void> {
+      await this.mutate('clear', files => files.clear());
+   }
+
+   /**
+    * Run one write transaction and settle on its COMPLETION.
+    *
+    * Not on the request's `success`: a request can succeed inside a transaction
+    * that then aborts, which is exactly what a quota overrun looks like, so
+    * resolving early would report a save the database never kept.
+    */
+   protected async mutate(operation: string, act: (files: IDBObjectStore) => void): Promise<void> {
+      const database = await this.open();
+      return new Promise<void>((resolve, reject) => {
+         const transaction = database.transaction(OBJECT_STORE_NAME, 'readwrite');
+         transaction.oncomplete = () => resolve();
+         transaction.onabort = () => reject(this.failure(transaction, operation));
+         act(transaction.objectStore(OBJECT_STORE_NAME));
+      });
+   }
+
+   protected open(): Promise<IDBDatabase> {
+      this.connection ??= this.openDatabase().catch((error: unknown) => {
+         this.connection = undefined;
+         throw error;
+      });
+      return this.connection;
+   }
+
+   protected openDatabase(): Promise<IDBDatabase> {
+      return new Promise<IDBDatabase>((resolve, reject) => {
+         const request = indexedDB.open(this.databaseName, DATABASE_VERSION);
+         let blocked = false;
+         request.onupgradeneeded = () => {
+            // Runs on a first visit and on a version bump. `createObjectStore`
+            // throws if it already exists, so the guard is not defensive: a page
+            // opened twice with the store created once gets here only when the
+            // version moved.
+            if (!request.result.objectStoreNames.contains(OBJECT_STORE_NAME)) {
+               request.result.createObjectStore(OBJECT_STORE_NAME);
+            }
+         };
+         request.onsuccess = () => {
+            const database = request.result;
+            if (blocked) {
+               // Went through once the other tab closed, after this call had
+               // rejected. Nobody holds it, so it is closed rather than left
+               // open to block the NEXT upgrade.
+               database.close();
+               return;
+            }
+            // A newer version opening in another tab asks this one to let go,
+            // and holding on would block that upgrade for as long as this tab
+            // lives. Dropped, so every later call here rejects, which is loud.
+            database.onversionchange = () => {
+               database.close();
+               this.connection = undefined;
+            };
+            resolve(database);
+         };
+         request.onerror = () => reject(request.error ?? new Error(`Cannot open ${this.databaseName}`));
+         // A tab at an older version that lacks the close above holds the
+         // upgrade indefinitely. Reported rather than waited on: the host can say
+         // so, where a hung open looks like a worker that never started.
+         request.onblocked = () => {
+            blocked = true;
+            reject(new Error(`${this.databaseName} is open in another tab at an older version`));
+         };
+      });
+   }
+
+   protected failure(transaction: IDBTransaction, operation: string): Error {
+      // `transaction.error` names the real cause (`QuotaExceededError` above
+      // all); an abort with no error is a caller-side abort, which nothing here
+      // does.
+      return transaction.error ?? new Error(`Failed to ${operation} in ${this.databaseName}`);
+   }
+}