@hydranium/glsp-client-theia 1.0.0-next.32 → 1.0.0-next.321

package/lib/testing/bind-recorder.d.ts

@@ -1,67 +0,0 @@
-/********************************************************************************
- * 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 { interfaces } from 'inversify';
-/**
- * One captured `bind(...)` or `rebind(...)` call on a {@link BindRecorder}.
- *
- * `chain` holds the follow-up methods in invocation order, one string per call,
- * rendered as `name(arg, …)`. Arguments are stringified inline so assertions
- * can compare structure without re-resolving service identifiers.
- */
-export interface BindRecorderEntry {
-    readonly kind: 'bind' | 'rebind';
-    readonly token: unknown;
-    readonly chain: string[];
-}
-/**
- * A spy set of Inversify binding hooks that records every call and its chain.
- * Hand them to a module-factory under test — they satisfy Inversify's
- * `interfaces.Bind` / `interfaces.Rebind` / `interfaces.Unbind` /
- * `interfaces.IsBound` shapes at the call site but never resolve real services.
- *
- * Together they match GLSP's `BindingContext`, so a factory taking the whole
- * context is called as `factory(recorder, options)` — the recorder *is*
- * structurally a context.
- *
- * Use {@link captured} to assert which tokens were touched and with what
- * fluent chain. {@link find} is a small ergonomic helper for the common
- * lookup pattern.
- */
-export interface BindRecorder {
-    readonly bind: interfaces.Bind;
-    readonly rebind: interfaces.Rebind;
-    readonly unbind: interfaces.Unbind;
-    readonly isBound: interfaces.IsBound;
-    readonly captured: readonly BindRecorderEntry[];
-    /** Convenience lookup — returns the first entry matching both `kind` and `token`, or `undefined`. */
-    find(kind: 'bind' | 'rebind', token: unknown): BindRecorderEntry | undefined;
-}
-/** Options for {@link makeBindRecorder}. */
-export interface BindRecorderOptions {
-    /**
-     * What `isBound` answers. Defaults to `true` for every token, matching
-     * production: a head registers its own module *after* the GLSP default
-     * modules, so the tokens a framework module rebinds are already bound. Pass a
-     * list to model a container where only those tokens are bound — e.g. to
-     * exercise a factory's bind-instead-of-rebind fallback.
-     */
-    readonly boundTokens?: readonly unknown[];
-}
-/**
- * Build a {@link BindRecorder} for testing Inversify module factories without a
- * real container: hand it to the factory, then assert over {@link BindRecorder.find}.
- *
- * The `bind` / `rebind` functions return a chained proxy that ignores its
- * arguments structurally but records every method invocation as a string.
- * Stringification: functions → `<className>`, symbols → `Symbol(desc).toString()`,
- * everything else → `String(value)`. This is enough to assert which tokens are
- * involved without dragging real service resolution into the test.
- */
-export declare function makeBindRecorder(options?: BindRecorderOptions): BindRecorder;
-//# sourceMappingURL=bind-recorder.d.ts.map

package/lib/testing/bind-recorder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bind-recorder.d.ts","sourceRoot":"","sources":["../../src/testing/bind-recorder.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE5C;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC;CAC3B;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,YAAY;IAC1B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,MAAM,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,MAAM,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC,OAAO,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAChD,qGAAqG;IACrG,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,EAAE,KAAK,EAAE,OAAO,GAAG,iBAAiB,GAAG,SAAS,CAAC;CAC/E;AAED,4CAA4C;AAC5C,MAAM,WAAW,mBAAmB;IACjC;;;;;;OAMG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;CAC5C;AAuBD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,GAAE,mBAAwB,GAAG,YAAY,CAkChF"}

package/lib/testing/bind-recorder.js

@@ -1,72 +0,0 @@
-"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.makeBindRecorder = makeBindRecorder;
-/** Methods on Inversify's binding builder that the recorder traps verbatim. */
-const RECORDED_CHAIN_METHODS = [
-    'toSelf',
-    'to',
-    'toService',
-    'toConstantValue',
-    'toDynamicValue',
-    'toFactory',
-    'toFunction',
-    'toAutoFactory',
-    'toProvider',
-    'inSingletonScope',
-    'inTransientScope',
-    'inRequestScope',
-    'whenTargetNamed',
-    'whenTargetTagged',
-    'whenInjectedInto',
-    'onActivation',
-    'onDeactivation'
-];
-/**
- * Build a {@link BindRecorder} for testing Inversify module factories without a
- * real container: hand it to the factory, then assert over {@link BindRecorder.find}.
- *
- * The `bind` / `rebind` functions return a chained proxy that ignores its
- * arguments structurally but records every method invocation as a string.
- * Stringification: functions → `<className>`, symbols → `Symbol(desc).toString()`,
- * everything else → `String(value)`. This is enough to assert which tokens are
- * involved without dragging real service resolution into the test.
- */
-function makeBindRecorder(options = {}) {
-    const captured = [];
-    const stringifyArg = (value) => {
-        if (typeof value === 'function') {
-            return `<${value.name || 'fn'}>`;
-        }
-        if (typeof value === 'symbol') {
-            return value.toString();
-        }
-        return String(value);
-    };
-    const beginEntry = (kind, token) => {
-        const entry = { kind, token, chain: [] };
-        captured.push(entry);
-        const proxy = {};
-        for (const method of RECORDED_CHAIN_METHODS) {
-            proxy[method] = (...args) => {
-                entry.chain.push(`${method}(${args.map(stringifyArg).join(', ')})`);
-                return proxy;
-            };
-        }
-        return proxy;
-    };
-    const bind = ((token) => beginEntry('bind', token));
-    const rebind = ((token) => beginEntry('rebind', token));
-    const unbind = (() => undefined);
-    const isBound = ((token) => options.boundTokens?.includes(token) ?? true);
-    const find = (kind, token) => captured.find(entry => entry.kind === kind && entry.token === token);
-    return { bind, rebind, unbind, isBound, captured, find };
-}
-//# sourceMappingURL=bind-recorder.js.map

package/lib/testing/bind-recorder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bind-recorder.js","sourceRoot":"","sources":["../../src/testing/bind-recorder.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;AAoFlF,4CAkCC;AAjED,+EAA+E;AAC/E,MAAM,sBAAsB,GAAG;IAC5B,QAAQ;IACR,IAAI;IACJ,WAAW;IACX,iBAAiB;IACjB,gBAAgB;IAChB,WAAW;IACX,YAAY;IACZ,eAAe;IACf,YAAY;IACZ,kBAAkB;IAClB,kBAAkB;IAClB,gBAAgB;IAChB,iBAAiB;IACjB,kBAAkB;IAClB,kBAAkB;IAClB,cAAc;IACd,gBAAgB;CACT,CAAC;AAEX;;;;;;;;;GASG;AACH,SAAgB,gBAAgB,CAAC,UAA+B,EAAE;IAC/D,MAAM,QAAQ,GAAwB,EAAE,CAAC;IAEzC,MAAM,YAAY,GAAG,CAAC,KAAc,EAAU,EAAE;QAC7C,IAAI,OAAO,KAAK,KAAK,UAAU,EAAE,CAAC;YAC/B,OAAO,IAAI,KAAK,CAAC,IAAI,IAAI,IAAI,GAAG,CAAC;QACpC,CAAC;QACD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC7B,OAAO,KAAK,CAAC,QAAQ,EAAE,CAAC;QAC3B,CAAC;QACD,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;IACxB,CAAC,CAAC;IAEF,MAAM,UAAU,GAAG,CAAC,IAAuB,EAAE,KAAc,EAAW,EAAE;QACrE,MAAM,KAAK,GAAsB,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;QAC5D,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACrB,MAAM,KAAK,GAAoD,EAAE,CAAC;QAClE,KAAK,MAAM,MAAM,IAAI,sBAAsB,EAAE,CAAC;YAC3C,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,IAAe,EAAW,EAAE;gBAC7C,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,MAAM,IAAI,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;gBACpE,OAAO,KAAK,CAAC;YAChB,CAAC,CAAC;QACL,CAAC;QACD,OAAO,KAAK,CAAC;IAChB,CAAC,CAAC;IAEF,MAAM,IAAI,GAAG,CAAC,CAAC,KAAc,EAAE,EAAE,CAAC,UAAU,CAAC,MAAM,EAAE,KAAK,CAAC,CAAoB,CAAC;IAChF,MAAM,MAAM,GAAG,CAAC,CAAC,KAAc,EAAE,EAAE,CAAC,UAAU,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAsB,CAAC;IACtF,MAAM,MAAM,GAAG,CAAC,GAAG,EAAE,CAAC,SAAS,CAAiC,CAAC;IACjE,MAAM,OAAO,GAAG,CAAC,CAAC,KAAc,EAAE,EAAE,CAAC,OAAO,CAAC,WAAW,EAAE,QAAQ,CAAC,KAAK,CAAC,IAAI,IAAI,CAAuB,CAAC;IACzG,MAAM,IAAI,GAAG,CAAC,IAAuB,EAAE,KAAc,EAAiC,EAAE,CACrF,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,IAAI,KAAK,CAAC,KAAK,KAAK,KAAK,CAAC,CAAC;IAExE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;AAC5D,CAAC"}

package/lib/testing/index.d.ts

@@ -1,10 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
- *
- * This program and the accompanying materials are made available under the
- * terms of the MIT License which is available in the project root.
- *
- * SPDX-License-Identifier: MIT
- ********************************************************************************/
-export * from './bind-recorder';
-//# sourceMappingURL=index.d.ts.map

package/lib/testing/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAOlF,cAAc,iBAAiB,CAAC"}

package/lib/testing/index.js

@@ -1,30 +0,0 @@
-"use strict";
-/********************************************************************************
- * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
- *
- * This program and the accompanying materials are made available under the
- * terms of the MIT License which is available in the project root.
- *
- * SPDX-License-Identifier: MIT
- ********************************************************************************/
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-// Subpath barrel for `@hydranium/glsp-client-theia/testing` — the
-// GLSP-module-specific Inversify test double. The cross-head doubles
-// (`makeStubOutputChannelManager`, `makeStubInversifyContext`) live in
-// `@hydranium/client-theia/testing`, alongside the logger they double for.
-__exportStar(require("./bind-recorder"), exports);
-//# sourceMappingURL=index.js.map

package/lib/testing/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;;;;;;;;;;;;;;AAElF,kEAAkE;AAClE,qEAAqE;AACrE,uEAAuE;AACvE,2EAA2E;AAE3E,kDAAgC"}

package/src/browser/action-dispatcher.ts

@@ -1,257 +0,0 @@
-/********************************************************************************
- * 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 Action,
-   ComputedBoundsAction,
-   GLSPActionDispatcher,
-   GLSPModelSource,
-   LocalComputedBoundsAction,
-   MessageAction,
-   RejectAction,
-   RequestAction,
-   RequestBoundsAction,
-   RequestContextActions,
-   RequestModelAction,
-   RequestTypeHintsAction,
-   ResponseAction,
-   ServerAction,
-   SetDirtyStateAction,
-   SetEditModeAction,
-   SetMarkersAction,
-   SetModelAction,
-   SetTypeHintsAction,
-   StatusAction,
-   UpdateModelAction
-} from '@eclipse-glsp/client';
-import { ChannelLogger, ChannelTracer } from '@hydranium/client-theia/lib/browser';
-import { type Tracer } from '@hydranium/protocol';
-import { inject, injectable, unmanaged } from '@theia/core/shared/inversify';
-
-/** Default subset of action kinds the framework dispatcher will log: the GLSP
- *  traffic an observer reading the Output channel typically wants to see. All
- *  are standard `@eclipse-glsp/client` kinds; adopters with custom action kinds
- *  extend via `extraLoggedKinds`. */
-export const HYDRANIUM_DEFAULT_LOGGED_KINDS: ReadonlySet<string> = new Set<string>([
-   SetModelAction.KIND,
-   UpdateModelAction.KIND,
-   RequestBoundsAction.KIND,
-   ComputedBoundsAction.KIND,
-   SetDirtyStateAction.KIND,
-   SetEditModeAction.KIND,
-   SetMarkersAction.KIND,
-   SetTypeHintsAction.KIND,
-   StatusAction.KIND,
-   MessageAction.KIND,
-   RejectAction.KIND,
-   RequestContextActions.KIND,
-   RequestModelAction.KIND,
-   RequestTypeHintsAction.KIND
-]);
-
-/** Default request → response kind pairs for GLSP 'flow' actions that do NOT
- *  carry a requestId/responseId — so the dispatcher matches by kind (FIFO).
- *  Id-based matching still wins when a requestId is present. */
-export const HYDRANIUM_DEFAULT_KIND_PAIRS: ReadonlyMap<string, string> = new Map<string, string>([
-   [RequestModelAction.KIND, SetModelAction.KIND],
-   [RequestTypeHintsAction.KIND, SetTypeHintsAction.KIND],
-   [RequestBoundsAction.KIND, ComputedBoundsAction.KIND]
-]);
-
-/** Additive options. Adopters with custom action kinds pass extras here; the
- *  framework defaults always apply (you cannot un-log a kind the framework
- *  considers worth logging — subclass + override `dispatch` if you must). */
-export interface HydraniumGlspActionDispatcherOptions {
-   readonly extraLoggedKinds?: Iterable<string>;
-   readonly extraKindPairs?: Iterable<readonly [string, string]>;
-   /** Replaces the default `summarize` body entirely. Use for adopter-domain
-    *  action kinds where the framework default returns ''. */
-   readonly summarize?: (action: Action) => string;
-}
-
-/**
- * Wraps every dispatch so action traffic appears in the framework Output
- * channel, interleaved with server log lines. Instrumenting the dispatcher
- * (rather than per-kind handlers) catches ResponseActions that bypass the
- * handler pipeline.
- *
- * The framework defaults cover the standard GLSP kinds worth logging, not every
- * kind the protocol defines. Adopters with custom kinds either pass
- * `extraLoggedKinds` / `extraKindPairs` to the constructor (via a
- * `toDynamicValue` binding) or subclass and override.
- */
-@injectable()
-export class HydraniumGlspActionDispatcher extends GLSPActionDispatcher {
-   @inject(ChannelLogger) protected readonly channel!: ChannelLogger;
-   @inject(ChannelTracer) protected readonly tracer!: Tracer;
-
-   protected readonly loggedKinds: ReadonlySet<string>;
-   protected readonly kindPairs: ReadonlyMap<string, string>;
-   protected readonly kindPairsReverse: ReadonlyMap<string, string>;
-
-   protected pairCounter = 0;
-   /** Pending requests keyed by requestId (for actions that carry one). */
-   protected pendingById = new Map<string, { id: number; start: number }>();
-   /** FIFO queue per response kind, used for `flow` pairs without requestId/responseId. */
-   protected pendingByKind = new Map<string, Array<{ id: number; start: number }>>();
-
-   constructor(@unmanaged() options?: HydraniumGlspActionDispatcherOptions) {
-      super();
-      const extraLogged = options?.extraLoggedKinds ? Array.from(options.extraLoggedKinds) : [];
-      this.loggedKinds = new Set<string>([...HYDRANIUM_DEFAULT_LOGGED_KINDS, ...extraLogged]);
-      const extraPairs = options?.extraKindPairs ? Array.from(options.extraKindPairs) : [];
-      const pairs = new Map<string, string>([...HYDRANIUM_DEFAULT_KIND_PAIRS, ...extraPairs]);
-      this.kindPairs = pairs;
-      this.kindPairsReverse = new Map<string, string>(Array.from(pairs, ([req, res]) => [res, req]));
-      if (options?.summarize) {
-         this.summarize = options.summarize;
-      }
-   }
-
-   override initialize(): Promise<void> {
-      // `initialize()` is called many times; super is idempotent, but our callback registration
-      // isn't. Register the timing log only on the first call (when super.initialized is unset).
-      if (!this.initialized) {
-         this.registerInitTiming();
-      }
-      return super.initialize();
-   }
-
-   /**
-    * Register the one-shot 'model initialized' timing line. Instrumentation
-    * only — guarded so a tracer failure degrades logging rather than aborting
-    * diagram init. `initialize()` runs inside `DiagramLoader.load()`, whose
-    * caller (`GLSPDiagramWidget.onAfterAttach`) neither awaits nor catches the
-    * returned promise; an error thrown here would therefore escape as an
-    * uncaught rejection that blanks the diagram with no server-side signal.
-    */
-   protected registerInitTiming(): void {
-      try {
-         this.tracer.time('Model initialized', () => this.onceModelInitialized(), 'info', { logAfterMs: 0 });
-      } catch (err) {
-         this.channel.error('Failed to register model-initialized timing instrumentation', err);
-      }
-   }
-
-   override dispatch(action: Action): Promise<void> {
-      if (this.loggedKinds.has(action.kind)) {
-         this.logAction(action);
-      }
-      return super.dispatch(action);
-   }
-
-   protected logAction(action: Action): void {
-      const { verb, direction } = this.classify(action);
-      const summary = this.summarize(action);
-      const timing = this.trackPair(action);
-      const parts = [`${verb} action '${action.kind}'`, `[${direction}]`];
-      if (summary) {
-         parts.push(`[${summary}]`);
-      }
-      if (timing) {
-         parts.push(timing);
-      }
-      this.channel.trace(parts.join(' '));
-   }
-
-   protected classify(action: Action): { verb: string; direction: string } {
-      // GLSP marks client-produced computedBounds as ServerAction to suppress forwarding; stays local.
-      if (LocalComputedBoundsAction.is(action)) {
-         return { verb: 'Process', direction: 'client → client' };
-      }
-      // Marked by GLSPModelSource.messageReceived — arrived from the server.
-      if (ServerAction.is(action)) {
-         return { verb: 'Receive', direction: 'server → client' };
-      }
-      // GLSPModelSource is registered as handler for every server-handled kind (configureServeActions),
-      // so its presence means the action will be forwarded to the server.
-      const handlers = this.actionHandlerRegistry.get(action.kind);
-      if (handlers.some(handler => handler instanceof GLSPModelSource)) {
-         return { verb: 'Send', direction: 'client → server' };
-      }
-      return { verb: 'Process', direction: 'client → client' };
-   }
-
-   /** Emit `[request #N]` on the request side, `[response #N, Xms]` on the matching response side.
-    *  Match first by requestId/responseId, then by known kind pairs (FIFO). */
-   protected trackPair(action: Action): string {
-      // Response side.
-      if (ResponseAction.hasValidResponseId(action)) {
-         const entry = this.pendingById.get(action.responseId);
-         if (entry) {
-            this.pendingById.delete(action.responseId);
-            return this.formatResponse(entry);
-         }
-      }
-      if (this.kindPairsReverse.has(action.kind)) {
-         const queue = this.pendingByKind.get(action.kind);
-         const entry = queue?.shift();
-         if (entry) {
-            return this.formatResponse(entry);
-         }
-      }
-      // Request side.
-      if (RequestAction.is(action) && action.requestId) {
-         const entry = { id: ++this.pairCounter, start: performance.now() };
-         this.pendingById.set(action.requestId, entry);
-         return `[request #${entry.id}]`;
-      }
-      if (this.kindPairs.has(action.kind)) {
-         const responseKind = this.kindPairs.get(action.kind)!;
-         const entry = { id: ++this.pairCounter, start: performance.now() };
-         const queue = this.pendingByKind.get(responseKind) ?? [];
-         queue.push(entry);
-         this.pendingByKind.set(responseKind, queue);
-         return `[request #${entry.id}]`;
-      }
-      return '';
-   }
-
-   protected formatResponse(entry: { id: number; start: number }): string {
-      const elapsed = Math.round(performance.now() - entry.start);
-      return `[response #${entry.id}, ${elapsed}ms]`;
-   }
-
-   protected summarize(action: Action): string {
-      if (SetModelAction.is(action) || UpdateModelAction.is(action)) {
-         const root = action.newRoot;
-         return `rootType=${root?.type ?? 'none'} children=${root?.children?.length ?? 0}`;
-      }
-      if (RequestBoundsAction.is(action)) {
-         return `rootType=${action.newRoot.type} children=${action.newRoot.children?.length ?? 0}`;
-      }
-      if (ComputedBoundsAction.is(action)) {
-         return `bounds=${action.bounds.length}`;
-      }
-      if (SetDirtyStateAction.is(action)) {
-         return `isDirty=${action.isDirty} reason=${action.reason ?? 'n/a'}`;
-      }
-      if (SetEditModeAction.is(action)) {
-         return `editMode=${action.editMode}`;
-      }
-      if (SetMarkersAction.is(action)) {
-         return `markers=${action.markers.length}`;
-      }
-      if (StatusAction.is(action) || MessageAction.is(action)) {
-         // severity=NONE with empty message is the conventional 'clear' signal.
-         const clear = action.severity === 'NONE' && !action.message ? ' (clear)' : '';
-         return `severity=${action.severity} message="${action.message.slice(0, 160)}"${clear}`;
-      }
-      if (RejectAction.is(action)) {
-         return `reason="${action.message.slice(0, 160)}"`;
-      }
-      if (SetTypeHintsAction.is(action)) {
-         return `shapes=${action.shapeHints.length} edges=${action.edgeHints.length}`;
-      }
-      if (RequestContextActions.is(action)) {
-         return `contextId=${action.contextId}`;
-      }
-      return '';
-   }
-}

package/src/browser/diagram-loader.ts

@@ -1,173 +0,0 @@
-/********************************************************************************
- * 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 { DiagramLoader, type DiagramLoadingOptions, StatusAction } from '@eclipse-glsp/client';
-import { ChannelLogger } from '@hydranium/client-theia/lib/browser';
-import { Deferred } from '@hydranium/protocol';
-import { inject, injectable } from '@theia/core/shared/inversify';
-
-/**
- * How a diagram load ended. A discriminated union rather than a boolean or a
- * string: a consumer showing a pending indicator has to distinguish "not settled
- * yet" (`undefined`) from either terminal state, and the failed arm has to carry
- * enough for that consumer to decide whether *it* is now the only thing that can
- * report the failure — see {@link DiagramLoadFailure.surfaced}.
- */
-export type DiagramLoadOutcome = DiagramLoadSuccess | DiagramLoadFailure;
-
-export interface DiagramLoadSuccess {
-   readonly status: 'loaded';
-}
-
-export interface DiagramLoadFailure {
-   readonly status: 'failed';
-   /** The thrown value, verbatim. `unknown` because a rejection can be anything. */
-   readonly error: unknown;
-   /**
-    * Whether the `severity: 'ERROR'` {@link StatusAction} reached the action
-    * dispatcher — i.e. whether GLSP's `StatusOverlay` is now displaying this
-    * failure.
-    *
-    * `false` means the report itself failed, which happens when the action
-    * dispatcher is the thing that could not initialize. A consumer that covers
-    * the canvas must then render the failure itself: it is the only surface
-    * left, and removing its overlay would leave a blank diagram whose only
-    * explanation is a line in the Output channel — the exact failure mode this
-    * loader exists to prevent.
-    */
-   readonly surfaced: boolean;
-}
-
-/**
- * Diagram loader that never lets a load failure vanish.
- *
- * `DiagramLoader.load()` orchestrates the full diagram-init path — action
- * dispatcher init, GLSP-client connect + server `initialize`, the first
- * `RequestModelAction`, and the model-initialization constraint. Of these only
- * the `IDiagramStartup` hooks are wrapped by the base loader (it logs them to
- * `console.error`); the dispatcher-init / connection / request-model steps are
- * not. The widget that drives loading
- * (`@eclipse-glsp/theia-integration`'s `GLSPDiagramWidget.onAfterAttach`)
- * calls `load()` *without awaiting or catching it*, so any rejection becomes an
- * uncaught promise rejection visible only in the browser devtools console —
- * nothing reaches the e2e output, the server log, or a Theia log sink, and the
- * diagram just stays blank.
- *
- * This subclass closes that gap: it catches every load failure, routes it to
- * the framework Output channel (the same {@link ChannelLogger} sink the server
- * log and action traffic share, so it is discoverable where a developer already
- * looks), and surfaces a persistent error to the user via a `severity: 'ERROR'`
- * {@link StatusAction} on the diagram's status overlay. It deliberately does
- * **not** rethrow — the caller drops the promise, so rethrowing would only
- * reproduce the uncaught rejection this exists to prevent.
- *
- * It also publishes the load's terminal state ({@link loadOutcome} /
- * {@link onceLoadSettled}) so a pending indicator has one authority to key on.
- * `HydraniumGlspDiagramWidget` uses it to cover the canvas while loading; see
- * {@link settle} for why the signal cannot be derived from the error
- * `StatusAction` instead.
- *
- * Bound by `createGlspClientTheiaModule` via `rebind(DiagramLoader)`.
- */
-@injectable()
-export class HydraniumDiagramLoader extends DiagramLoader {
-   @inject(ChannelLogger) protected readonly channel!: ChannelLogger;
-
-   protected readonly settled = new Deferred<DiagramLoadOutcome>();
-   protected outcome?: DiagramLoadOutcome;
-
-   /** Terminal state of the load, or `undefined` while it is still in flight.
-    *  The synchronous companion of {@link onceLoadSettled}, for a consumer that
-    *  must decide something in the same tick (e.g. whether to show an indicator
-    *  at all when re-attaching an already-loaded diagram). */
-   get loadOutcome(): DiagramLoadOutcome | undefined {
-      return this.outcome;
-   }
-
-   /** Resolves once the load reaches a terminal state — on success **and** on
-    *  failure, so a caller awaiting it cannot hang. Never rejects. */
-   onceLoadSettled(): Promise<DiagramLoadOutcome> {
-      return this.settled.promise;
-   }
-
-   override async load(options?: DiagramLoadingOptions): Promise<void> {
-      try {
-         await super.load(options);
-         this.settle({ status: 'loaded' });
-      } catch (err) {
-         // Report first, settle second, and carry whether the report landed: a
-         // consumer that uncovers the canvas on settle then finds the error
-         // already on the status overlay — or learns that it has to render the
-         // failure itself because nothing else can.
-         const surfaced = await this.reportLoadFailure(err);
-         this.settle({ status: 'failed', error: err, surfaced });
-      }
-   }
-
-   /**
-    * Record the terminal state and release {@link onceLoadSettled}. Idempotent —
-    * the first outcome wins, so a reload cannot flip a settled indicator.
-    *
-    * This runs unconditionally after {@link reportLoadFailure}, *including* when
-    * the status dispatch inside it threw. That is the load-bearing property: when
-    * the action dispatcher is itself the thing that failed to initialize — the
-    * exact failure this class exists for — no `StatusAction` ever lands, so a
-    * consumer observing actions would wait forever. Settling here means a pending
-    * indicator always comes down, and `surfaced: false` tells that consumer it is
-    * now the only thing that can report the failure.
-    */
-   protected settle(outcome: DiagramLoadOutcome): void {
-      if (this.outcome !== undefined) {
-         return;
-      }
-      this.outcome = outcome;
-      this.settled.resolve(outcome);
-   }
-
-   /**
-    * Route a diagram-load failure to the Output channel and the status overlay.
-    * The status dispatch is itself guarded: when the action dispatcher is the
-    * thing that failed to initialize, dispatching may throw too, and a failure
-    * to *report* the failure must not re-escape as an uncaught rejection.
-    *
-    * @returns whether the `StatusAction` reached the dispatcher — i.e. whether the
-    * user can see this failure on the diagram. The channel line always happens, so
-    * the return value is specifically about the *user-visible* report; a `false`
-    * makes {@link DiagramLoadFailure.surfaced} false and hands the job to whoever
-    * is covering the canvas.
-    */
-   protected async reportLoadFailure(err: unknown): Promise<boolean> {
-      const label = this.loadFailureLabel(err);
-      this.channel.error(label, err);
-      try {
-         await this.actionDispatcher.dispatch(StatusAction.create(label, { severity: 'ERROR' }));
-         return true;
-      } catch (statusErr) {
-         this.channel.error('Failed to surface the diagram-load failure on the status overlay', statusErr);
-         return false;
-      }
-   }
-
-   /**
-    * The sentence a failed load is reported with, on every surface that reports
-    * it, and the only seam an adopter rewords or localizes it at. Public
-    * because the canvas overlay is one of those surfaces and lives in another
-    * class: it renders this failure exactly when the `StatusAction` did not
-    * land, so a second copy of the sentence there could only ever drift unseen.
-    */
-   loadFailureLabel(err: unknown): string {
-      return `Diagram failed to load: ${this.formatError(err)}`;
-   }
-
-   /** Render a thrown value as a message. Shared so the channel line, the status
-    *  overlay and any consumer rendering {@link DiagramLoadFailure.error} agree. */
-   protected formatError(err: unknown): string {
-      return err instanceof Error ? err.message : String(err);
-   }
-}