@hydranium/client-theia 1.0.0-next.50 → 1.0.0-next.52

package/lib/browser/connection-diagnostics-contribution.d.ts

@@ -0,0 +1,69 @@
+/********************************************************************************
+ * 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 { MessageService } from '@theia/core';
+import { FrontendApplicationContribution } from '@theia/core/lib/browser/frontend-application-contribution';
+import { ConnectionStatus, ConnectionStatusService } from '@theia/core/lib/browser/connection-status-service';
+import { WebSocketConnectionSource } from '@theia/core/lib/browser/messaging/ws-connection-source';
+import { type interfaces } from '@theia/core/shared/inversify';
+import { type ConnectionBufferOverflow } from '../common/framed-socket-write-buffer';
+import { ChannelLogger } from './channel-logger';
+/**
+ * Records the browser side of the websocket lifecycle into the adopter's Output
+ * channel, and tells the user the one thing they cannot recover from on their
+ * own.
+ *
+ * Theia reports an outage only as an "Offline" status-bar item, which cannot
+ * distinguish a plain network drop from the server having stopped answering on a
+ * socket that is still up. The latter is what a connection defect looks like
+ * from here, so the two are logged differently — that distinction is what says
+ * whether reopening an editor helps or only a reload does.
+ *
+ * Purely observational apart from the overflow message: nothing here changes how
+ * the connection behaves.
+ */
+export declare class ConnectionDiagnosticsContribution implements FrontendApplicationContribution {
+    protected readonly connectionSource: WebSocketConnectionSource;
+    protected readonly connectionStatus: ConnectionStatusService;
+    protected readonly logger: ChannelLogger;
+    protected readonly messageService: MessageService;
+    /** Main channels created so far; more than one means the server did not recognise this frontend. */
+    protected channelCount: number;
+    protected socketClosedAt?: number;
+    protected offlineAt?: number;
+    initialize(): void;
+    protected handleSocketOpen(): void;
+    protected handleSocketClose(): void;
+    /**
+     * A second channel means the reconnect was refused and the session discarded.
+     * Only reachable with `reloadOnReconnect` off — with it on, Theia reloads the
+     * page instead of opening another channel.
+     */
+    protected handleChannelOpen(): void;
+    protected handleStatusChange(status: ConnectionStatus): void;
+    /**
+     * The outage outlasted what the buffer can hold, so changes made from here on
+     * are being thrown away rather than queued. Reconnecting resumes sending but
+     * cannot bring those back, which leaves the editor disagreeing with the
+     * server — and without a message the user would see nothing but an editor
+     * that has quietly stopped saving, so say it plainly.
+     */
+    protected handleBufferOverflow(overflow: ConnectionBufferOverflow): void;
+    protected socketId(): string;
+    protected statusName(status: ConnectionStatus): string;
+}
+/**
+ * Bind {@link ConnectionDiagnosticsContribution} as a `FrontendApplicationContribution`.
+ *
+ * Needs a {@link ChannelLogger} binding, so call it from a module that has also
+ * called `bindChannelLogger`. Unlike `bindConnectionResilience` this belongs in a
+ * normal frontend module: it only observes, so it has no reason to run during
+ * preload, and `MessageService` is not available that early.
+ */
+export declare function bindConnectionDiagnostics(bind: interfaces.Bind): void;
+//# sourceMappingURL=connection-diagnostics-contribution.d.ts.map

package/lib/browser/connection-diagnostics-contribution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-diagnostics-contribution.d.ts","sourceRoot":"","sources":["../../src/browser/connection-diagnostics-contribution.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,cAAc,EAAO,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,+BAA+B,EAAE,MAAM,2DAA2D,CAAC;AAC5G,OAAO,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,mDAAmD,CAAC;AAC9G,OAAO,EAAE,yBAAyB,EAAE,MAAM,wDAAwD,CAAC;AACnG,OAAO,EAAsB,KAAK,UAAU,EAAE,MAAM,8BAA8B,CAAC;AACnF,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,sCAAsC,CAAC;AACrF,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGjD;;;;;;;;;;;;;GAaG;AACH,qBACa,iCAAkC,YAAW,+BAA+B;IACnD,SAAS,CAAC,QAAQ,CAAC,gBAAgB,EAAE,yBAAyB,CAAC;IACjE,SAAS,CAAC,QAAQ,CAAC,gBAAgB,EAAE,uBAAuB,CAAC;IACvE,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IACxC,SAAS,CAAC,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;IAE1E,oGAAoG;IACpG,SAAS,CAAC,YAAY,SAAK;IAC3B,SAAS,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IAClC,SAAS,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAE7B,UAAU,IAAI,IAAI;IAalB,SAAS,CAAC,gBAAgB,IAAI,IAAI;IAMlC,SAAS,CAAC,iBAAiB,IAAI,IAAI;IAKnC;;;;OAIG;IACH,SAAS,CAAC,iBAAiB,IAAI,IAAI;IAYnC,SAAS,CAAC,kBAAkB,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI;IAmB5D;;;;;;OAMG;IACH,SAAS,CAAC,oBAAoB,CAAC,QAAQ,EAAE,wBAAwB,GAAG,IAAI;IAUxE,SAAS,CAAC,QAAQ,IAAI,MAAM;IAI5B,SAAS,CAAC,UAAU,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM;CAGxD;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,GAAG,IAAI,CAGrE"}

package/lib/browser/connection-diagnostics-contribution.js

@@ -0,0 +1,153 @@
+"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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionDiagnosticsContribution = void 0;
+exports.bindConnectionDiagnostics = bindConnectionDiagnostics;
+const core_1 = require("@theia/core");
+const frontend_application_contribution_1 = require("@theia/core/lib/browser/frontend-application-contribution");
+const connection_status_service_1 = require("@theia/core/lib/browser/connection-status-service");
+const ws_connection_source_1 = require("@theia/core/lib/browser/messaging/ws-connection-source");
+const inversify_1 = require("@theia/core/shared/inversify");
+const channel_logger_1 = require("./channel-logger");
+const session_aware_connection_source_1 = require("./session-aware-connection-source");
+/**
+ * Records the browser side of the websocket lifecycle into the adopter's Output
+ * channel, and tells the user the one thing they cannot recover from on their
+ * own.
+ *
+ * Theia reports an outage only as an "Offline" status-bar item, which cannot
+ * distinguish a plain network drop from the server having stopped answering on a
+ * socket that is still up. The latter is what a connection defect looks like
+ * from here, so the two are logged differently — that distinction is what says
+ * whether reopening an editor helps or only a reload does.
+ *
+ * Purely observational apart from the overflow message: nothing here changes how
+ * the connection behaves.
+ */
+let ConnectionDiagnosticsContribution = class ConnectionDiagnosticsContribution {
+    connectionSource;
+    connectionStatus;
+    logger;
+    messageService;
+    /** Main channels created so far; more than one means the server did not recognise this frontend. */
+    channelCount = 0;
+    socketClosedAt;
+    offlineAt;
+    initialize() {
+        this.connectionSource.onSocketDidOpen(() => this.handleSocketOpen());
+        this.connectionSource.onSocketDidClose(() => this.handleSocketClose());
+        this.connectionSource.onConnectionDidOpen(() => this.handleChannelOpen());
+        this.connectionStatus.onStatusChange(status => this.handleStatusChange(status));
+        if (this.connectionSource instanceof session_aware_connection_source_1.SessionAwareConnectionSource) {
+            this.connectionSource.onBufferOverflow(overflow => this.handleBufferOverflow(overflow));
+        }
+        // The socket is opened by the preloader, before this contribution exists, so the first
+        // `onSocketDidOpen` has already fired; state the current situation instead.
+        this.logger.info(`diagnostics active; socket ${this.socketId()}, backend ${this.statusName(this.connectionStatus.currentStatus)}`);
+    }
+    handleSocketOpen() {
+        const downFor = this.socketClosedAt === undefined ? '' : ` after ${Date.now() - this.socketClosedAt} ms down`;
+        this.socketClosedAt = undefined;
+        this.logger.info(`websocket connected: socket ${this.socketId()}${downFor}`);
+    }
+    handleSocketClose() {
+        this.socketClosedAt = Date.now();
+        this.logger.info(`websocket disconnected: socket ${this.socketId()}; outgoing messages are buffered until it returns`);
+    }
+    /**
+     * A second channel means the reconnect was refused and the session discarded.
+     * Only reachable with `reloadOnReconnect` off — with it on, Theia reloads the
+     * page instead of opening another channel.
+     */
+    handleChannelOpen() {
+        this.channelCount++;
+        if (this.channelCount === 1) {
+            this.logger.info(`initial channel opened on socket ${this.socketId()}`);
+            return;
+        }
+        this.logger.warn(`new channel #${this.channelCount} on socket ${this.socketId()}: the backend did not recognise this frontend, ` +
+            'so its session was discarded and every pending request rejected');
+    }
+    handleStatusChange(status) {
+        if (status === connection_status_service_1.ConnectionStatus.ONLINE) {
+            const offlineFor = this.offlineAt === undefined ? '' : ` after ${Date.now() - this.offlineAt} ms`;
+            this.offlineAt = undefined;
+            this.logger.info(`backend reachable again${offlineFor}`);
+            return;
+        }
+        this.offlineAt = Date.now();
+        const socket = this.connectionSource.socket;
+        if (socket?.connected) {
+            this.logger.warn(`backend stopped answering while socket ${socket.id} is still connected: nothing this session sends will ` +
+                'arrive, and socket.io will not reconnect on its own. Reload the page to recover.');
+            return;
+        }
+        this.logger.info(`backend unreachable; websocket is disconnected (socket ${this.socketId()})`);
+    }
+    /**
+     * The outage outlasted what the buffer can hold, so changes made from here on
+     * are being thrown away rather than queued. Reconnecting resumes sending but
+     * cannot bring those back, which leaves the editor disagreeing with the
+     * server — and without a message the user would see nothing but an editor
+     * that has quietly stopped saving, so say it plainly.
+     */
+    handleBufferOverflow(overflow) {
+        this.logger.error(`buffer full at ${overflow.maxBytes} bytes holding ${overflow.messages} message(s)`);
+        this.messageService.error(core_1.nls.localize('hydranium/connection/offlineLimitReached', 'Disconnected for too long: recent changes were not sent. Reload the page before continuing.'));
+    }
+    socketId() {
+        return this.connectionSource.socket?.id ?? ws_connection_source_1.WebSocketConnectionSource.NO_CONNECTION;
+    }
+    statusName(status) {
+        return status === connection_status_service_1.ConnectionStatus.ONLINE ? 'online' : 'offline';
+    }
+};
+exports.ConnectionDiagnosticsContribution = ConnectionDiagnosticsContribution;
+__decorate([
+    (0, inversify_1.inject)(ws_connection_source_1.WebSocketConnectionSource),
+    __metadata("design:type", ws_connection_source_1.WebSocketConnectionSource)
+], ConnectionDiagnosticsContribution.prototype, "connectionSource", void 0);
+__decorate([
+    (0, inversify_1.inject)(connection_status_service_1.ConnectionStatusService),
+    __metadata("design:type", Object)
+], ConnectionDiagnosticsContribution.prototype, "connectionStatus", void 0);
+__decorate([
+    (0, inversify_1.inject)(channel_logger_1.ChannelLogger),
+    __metadata("design:type", channel_logger_1.ChannelLogger)
+], ConnectionDiagnosticsContribution.prototype, "logger", void 0);
+__decorate([
+    (0, inversify_1.inject)(core_1.MessageService),
+    __metadata("design:type", core_1.MessageService)
+], ConnectionDiagnosticsContribution.prototype, "messageService", void 0);
+exports.ConnectionDiagnosticsContribution = ConnectionDiagnosticsContribution = __decorate([
+    (0, inversify_1.injectable)()
+], ConnectionDiagnosticsContribution);
+/**
+ * Bind {@link ConnectionDiagnosticsContribution} as a `FrontendApplicationContribution`.
+ *
+ * Needs a {@link ChannelLogger} binding, so call it from a module that has also
+ * called `bindChannelLogger`. Unlike `bindConnectionResilience` this belongs in a
+ * normal frontend module: it only observes, so it has no reason to run during
+ * preload, and `MessageService` is not available that early.
+ */
+function bindConnectionDiagnostics(bind) {
+    bind(ConnectionDiagnosticsContribution).toSelf().inSingletonScope();
+    bind(frontend_application_contribution_1.FrontendApplicationContribution).toService(ConnectionDiagnosticsContribution);
+}
+//# sourceMappingURL=connection-diagnostics-contribution.js.map

package/lib/browser/connection-diagnostics-contribution.js.map

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

package/lib/browser/index.d.ts

@@ -10,4 +10,6 @@ export * from './channel-logger';
 export * from './log-level-preference';
 export * from './browser-capture';
 export * from './memory-diagnostics-contribution';
+export * from './session-aware-connection-source';
+export * from './connection-diagnostics-contribution';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/browser/index.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAGlF,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mCAAmC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/browser/index.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAGlF,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mCAAmC,CAAC;AAClD,cAAc,mCAAmC,CAAC;AAClD,cAAc,uCAAuC,CAAC"}

package/lib/browser/index.js

@@ -27,4 +27,6 @@ __exportStar(require("./channel-logger"), exports);
 __exportStar(require("./log-level-preference"), exports);
 __exportStar(require("./browser-capture"), exports);
 __exportStar(require("./memory-diagnostics-contribution"), exports);
+__exportStar(require("./session-aware-connection-source"), exports);
+__exportStar(require("./connection-diagnostics-contribution"), exports);
 //# sourceMappingURL=index.js.map

package/lib/browser/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/browser/index.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;;;;;;;;;;;;;;AAElF,gFAAgF;AAChF,mDAAiC;AACjC,yDAAuC;AACvC,oDAAkC;AAClC,oEAAkD"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/browser/index.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;;;;;;;;;;;;;;AAElF,gFAAgF;AAChF,mDAAiC;AACjC,yDAAuC;AACvC,oDAAkC;AAClC,oEAAkD;AAClD,oEAAkD;AAClD,wEAAsD"}

package/lib/browser/session-aware-connection-source.d.ts

@@ -0,0 +1,94 @@
+/********************************************************************************
+ * 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 { WebSocketConnectionSource } from '@theia/core/lib/browser/messaging/ws-connection-source';
+import { type Event } from '@theia/core/lib/common/event';
+import { type AbstractChannel } from '@theia/core/lib/common/message-rpc/channel';
+import { type interfaces } from '@theia/core/shared/inversify';
+import { type ConnectionResilienceOptions } from '../common/connection-resilience-options';
+import { type ConnectionBufferOverflow, FramedSocketWriteBuffer } from '../common/framed-socket-write-buffer';
+/**
+ * Sends a message only once the server has confirmed the session, and only
+ * behind anything already queued.
+ *
+ * Theia sends straight away when `socket.connected` is true and buffers
+ * otherwise. The gap is that reconnecting sets that flag immediately, while the
+ * session is only confirmed a round trip later. A message produced in that
+ * window either jumps ahead of older messages still waiting in the buffer, or,
+ * if nothing was waiting, goes out on a socket whose channel the server has not
+ * attached yet and is discarded by a peer with no listener for it.
+ *
+ * Losing one or reordering them is equally unrecoverable for anything that
+ * applies messages by position. Theia's plugin host keeps a line-indexed copy of
+ * every open document, so a single late or missing edit leaves that copy wrong
+ * for good, and the next edit past its end fails.
+ *
+ * The server side needs no equivalent: it adopts its socket and flushes in one
+ * synchronous step, so it has no window of this kind.
+ */
+export declare class SessionAwareConnectionSource extends WebSocketConnectionSource {
+    /**
+     * Whether the server has confirmed, on the socket in use right now, that it
+     * still holds this frontend's session. A connected socket is not enough:
+     * until the handshake is answered the server has not attached its channel to
+     * this socket, and a message sent meanwhile reaches a peer with no listener
+     * for it and is discarded without a trace.
+     */
+    protected sessionResumed: boolean;
+    protected sessionListenersAttached: boolean;
+    /**
+     * Every connect starts a socket the server has not confirmed yet, including
+     * the reconnects socket.io performs on its own. Resetting here rather than on
+     * disconnect also covers a connect that follows no clean disconnect event.
+     */
+    protected handleSocketConnected(): void;
+    /**
+     * Watches the connection handshake for its outcome.
+     *
+     * Attached once, to the socket socket.io reuses across reconnects, and before
+     * the base class adds its own per-negotiation listeners — so this has already
+     * recorded the outcome by the time the base class reacts to it by flushing.
+     */
+    protected trackSessionState(): void;
+    /** Whether a message may go out now, as opposed to waiting in the buffer. */
+    protected get canSend(): boolean;
+    protected createChannel(): AbstractChannel;
+    /** Fires when the buffer runs out of room, so an adopter can say so rather than just stopping. */
+    get onBufferOverflow(): Event<ConnectionBufferOverflow>;
+    /**
+     * The write buffer Theia injected into the base class.
+     *
+     * Reached through a structural view rather than as `this.writeBuffer`,
+     * because that member is `private` in Theia 1.70 and only became `protected`
+     * in 1.71 — and this package compiles against the whole range. The view
+     * asserts nothing the versions disagree about: the field is there in both,
+     * holding whatever `SocketWriteBuffer` is bound, and the check below is what
+     * establishes it is ours.
+     */
+    protected get framedBuffer(): FramedSocketWriteBuffer;
+}
+/**
+ * Replaces the frontend pieces that decide how outgoing messages survive a
+ * reconnect. Every one of them rebinds something Theia's
+ * `messagingFrontendModule` already bound, so this belongs in a module loaded
+ * into the same container.
+ *
+ * It must be a `frontendPreload` module rather than a normal frontend module:
+ * Theia's preloader resolves `WebSocketConnectionSource` (and with it the write
+ * buffer) while loading i18n and OS settings, which happens before any frontend
+ * module is loaded. A rebind there would come too late — the instances would
+ * already exist. All `frontendPreload` modules, by contrast, are loaded before
+ * the preloader constructs anything.
+ *
+ * Does nothing but warn on a Theia too old to expose the buffer binding, so the
+ * package keeps one supported range rather than splitting its floor for this
+ * feature. Returns whether the hardening was installed, for an adopter that
+ * wants to branch on it.
+ */
+export declare function bindConnectionResilience(isBound: interfaces.IsBound, rebind: interfaces.Rebind, options?: ConnectionResilienceOptions): boolean;
+//# sourceMappingURL=session-aware-connection-source.d.ts.map

package/lib/browser/session-aware-connection-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-aware-connection-source.d.ts","sourceRoot":"","sources":["../../src/browser/session-aware-connection-source.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,yBAAyB,EAAE,MAAM,wDAAwD,CAAC;AAEnG,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAC1D,OAAO,EAAE,KAAK,eAAe,EAAqB,MAAM,4CAA4C,CAAC;AAGrG,OAAO,EAAc,KAAK,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAE3E,OAAO,EAAE,KAAK,2BAA2B,EAAE,MAAM,yCAAyC,CAAC;AAC3F,OAAO,EACJ,KAAK,wBAAwB,EAE7B,uBAAuB,EAGzB,MAAM,sCAAsC,CAAC;AAE9C;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBACa,4BAA6B,SAAQ,yBAAyB;IACxE;;;;;;OAMG;IACH,SAAS,CAAC,cAAc,UAAS;IACjC,SAAS,CAAC,wBAAwB,UAAS;IAE3C;;;;OAIG;cACgB,qBAAqB,IAAI,IAAI;IAMhD;;;;;;OAMG;IACH,SAAS,CAAC,iBAAiB,IAAI,IAAI;IAanC,6EAA6E;IAC7E,SAAS,KAAK,OAAO,IAAI,OAAO,CAE/B;cAEkB,aAAa,IAAI,eAAe;IA0BnD,kGAAkG;IAClG,IAAI,gBAAgB,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAEtD;IAED;;;;;;;;;OASG;IACH,SAAS,KAAK,YAAY,IAAI,uBAAuB,CAMpD;CACH;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,wBAAwB,CACrC,OAAO,EAAE,UAAU,CAAC,OAAO,EAC3B,MAAM,EAAE,UAAU,CAAC,MAAM,EACzB,OAAO,GAAE,2BAAgC,GACzC,OAAO,CAST"}

package/lib/browser/session-aware-connection-source.js

@@ -0,0 +1,163 @@
+"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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionAwareConnectionSource = void 0;
+exports.bindConnectionResilience = bindConnectionResilience;
+const ws_connection_source_1 = require("@theia/core/lib/browser/messaging/ws-connection-source");
+const disposable_1 = require("@theia/core/lib/common/disposable");
+const channel_1 = require("@theia/core/lib/common/message-rpc/channel");
+const uint8_array_message_buffer_1 = require("@theia/core/lib/common/message-rpc/uint8-array-message-buffer");
+const connection_management_1 = require("@theia/core/lib/common/messaging/connection-management");
+const inversify_1 = require("@theia/core/shared/inversify");
+const socket_write_buffer_1 = require("@theia/core/lib/common/messaging/socket-write-buffer");
+const framed_socket_write_buffer_1 = require("../common/framed-socket-write-buffer");
+/**
+ * Sends a message only once the server has confirmed the session, and only
+ * behind anything already queued.
+ *
+ * Theia sends straight away when `socket.connected` is true and buffers
+ * otherwise. The gap is that reconnecting sets that flag immediately, while the
+ * session is only confirmed a round trip later. A message produced in that
+ * window either jumps ahead of older messages still waiting in the buffer, or,
+ * if nothing was waiting, goes out on a socket whose channel the server has not
+ * attached yet and is discarded by a peer with no listener for it.
+ *
+ * Losing one or reordering them is equally unrecoverable for anything that
+ * applies messages by position. Theia's plugin host keeps a line-indexed copy of
+ * every open document, so a single late or missing edit leaves that copy wrong
+ * for good, and the next edit past its end fails.
+ *
+ * The server side needs no equivalent: it adopts its socket and flushes in one
+ * synchronous step, so it has no window of this kind.
+ */
+let SessionAwareConnectionSource = class SessionAwareConnectionSource extends ws_connection_source_1.WebSocketConnectionSource {
+    /**
+     * Whether the server has confirmed, on the socket in use right now, that it
+     * still holds this frontend's session. A connected socket is not enough:
+     * until the handshake is answered the server has not attached its channel to
+     * this socket, and a message sent meanwhile reaches a peer with no listener
+     * for it and is discarded without a trace.
+     */
+    sessionResumed = false;
+    sessionListenersAttached = false;
+    /**
+     * Every connect starts a socket the server has not confirmed yet, including
+     * the reconnects socket.io performs on its own. Resetting here rather than on
+     * disconnect also covers a connect that follows no clean disconnect event.
+     */
+    handleSocketConnected() {
+        this.trackSessionState();
+        this.sessionResumed = false;
+        super.handleSocketConnected();
+    }
+    /**
+     * Watches the connection handshake for its outcome.
+     *
+     * Attached once, to the socket socket.io reuses across reconnects, and before
+     * the base class adds its own per-negotiation listeners — so this has already
+     * recorded the outcome by the time the base class reacts to it by flushing.
+     */
+    trackSessionState() {
+        if (this.sessionListenersAttached) {
+            return;
+        }
+        this.sessionListenersAttached = true;
+        this.socket.on(connection_management_1.ConnectionManagementMessages.INITIAL_CONNECT, () => {
+            this.sessionResumed = true;
+        });
+        this.socket.on(connection_management_1.ConnectionManagementMessages.RECONNECT, (hasConnection) => {
+            this.sessionResumed = hasConnection;
+        });
+    }
+    /** Whether a message may go out now, as opposed to waiting in the buffer. */
+    get canSend() {
+        return this.socket.connected && this.sessionResumed;
+    }
+    createChannel() {
+        const toDispose = new disposable_1.DisposableCollection();
+        const messageHandler = (data) => {
+            this.onIncomingMessageActivityEmitter.fire();
+            if (this.currentChannel) {
+                // socket.io hands binary over as ArrayBuffer in the browser.
+                const buffer = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+                this.currentChannel.onMessageEmitter.fire(() => new uint8_array_message_buffer_1.Uint8ArrayReadBuffer(buffer));
+            }
+        };
+        this.socket.on('message', messageHandler);
+        toDispose.push(disposable_1.Disposable.create(() => this.socket.off('message', messageHandler)));
+        return new channel_1.ForwardingChannel('any', () => toDispose.dispose(), () => {
+            const result = new uint8_array_message_buffer_1.Uint8ArrayWriteBuffer();
+            // Says only whether the session can carry a message; the buffer decides whether it may
+            // go ahead of anything already waiting.
+            result.onCommit(buffer => this.framedBuffer.sendOrQueue(this.canSend ? this.socket : undefined, buffer));
+            return result;
+        });
+    }
+    /** Fires when the buffer runs out of room, so an adopter can say so rather than just stopping. */
+    get onBufferOverflow() {
+        return this.framedBuffer.onOverflow;
+    }
+    /**
+     * The write buffer Theia injected into the base class.
+     *
+     * Reached through a structural view rather than as `this.writeBuffer`,
+     * because that member is `private` in Theia 1.70 and only became `protected`
+     * in 1.71 — and this package compiles against the whole range. The view
+     * asserts nothing the versions disagree about: the field is there in both,
+     * holding whatever `SocketWriteBuffer` is bound, and the check below is what
+     * establishes it is ours.
+     */
+    get framedBuffer() {
+        const buffer = this.writeBuffer;
+        if (!(buffer instanceof framed_socket_write_buffer_1.FramedSocketWriteBuffer)) {
+            throw new Error('SessionAwareConnectionSource requires FramedSocketWriteBuffer to be bound');
+        }
+        return buffer;
+    }
+};
+exports.SessionAwareConnectionSource = SessionAwareConnectionSource;
+exports.SessionAwareConnectionSource = SessionAwareConnectionSource = __decorate([
+    (0, inversify_1.injectable)()
+], SessionAwareConnectionSource);
+/**
+ * Replaces the frontend pieces that decide how outgoing messages survive a
+ * reconnect. Every one of them rebinds something Theia's
+ * `messagingFrontendModule` already bound, so this belongs in a module loaded
+ * into the same container.
+ *
+ * It must be a `frontendPreload` module rather than a normal frontend module:
+ * Theia's preloader resolves `WebSocketConnectionSource` (and with it the write
+ * buffer) while loading i18n and OS settings, which happens before any frontend
+ * module is loaded. A rebind there would come too late — the instances would
+ * already exist. All `frontendPreload` modules, by contrast, are loaded before
+ * the preloader constructs anything.
+ *
+ * Does nothing but warn on a Theia too old to expose the buffer binding, so the
+ * package keeps one supported range rather than splitting its floor for this
+ * feature. Returns whether the hardening was installed, for an adopter that
+ * wants to branch on it.
+ */
+function bindConnectionResilience(isBound, rebind, options = {}) {
+    if (!(0, framed_socket_write_buffer_1.supportsConnectionResilience)(isBound)) {
+        (0, framed_socket_write_buffer_1.warnConnectionResilienceUnavailable)('frontend');
+        return false;
+    }
+    // Scopes are kept as Theia declares them: one buffer per connection source, one shared socket owner.
+    rebind(socket_write_buffer_1.SocketWriteBuffer).toDynamicValue(() => (0, framed_socket_write_buffer_1.createFramedSocketWriteBuffer)(options.bufferBytes));
+    rebind(ws_connection_source_1.WebSocketConnectionSource).to(SessionAwareConnectionSource).inSingletonScope();
+    return true;
+}
+//# sourceMappingURL=session-aware-connection-source.js.map

package/lib/browser/session-aware-connection-source.js.map

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

package/lib/common/connection-resilience-options.d.ts

@@ -0,0 +1,24 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+/**
+ * Options for the `bindConnectionResilience` helper each tier exports.
+ *
+ * Lives in `common` rather than beside either helper so the server entry can
+ * name the type without importing the browser module, and the other way round.
+ */
+export interface ConnectionResilienceOptions {
+    /**
+     * Size of the buffer holding messages while the socket is down, in bytes.
+     * Defaults to Theia's own limit. It decides how long an outage can last
+     * before changes start being rejected, so a deployment on a poor network
+     * trades memory for tolerance here.
+     */
+    readonly bufferBytes?: number;
+}
+//# sourceMappingURL=connection-resilience-options.d.ts.map

package/lib/common/connection-resilience-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-resilience-options.d.ts","sourceRoot":"","sources":["../../src/common/connection-resilience-options.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF;;;;;GAKG;AACH,MAAM,WAAW,2BAA2B;IACzC;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAChC"}

package/lib/common/connection-resilience-options.js

@@ -0,0 +1,11 @@
+"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 });
+//# sourceMappingURL=connection-resilience-options.js.map

package/lib/common/connection-resilience-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-resilience-options.js","sourceRoot":"","sources":["../../src/common/connection-resilience-options.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF"}