@hydranium/client-theia 1.0.0-next.39 → 1.0.0-next.390

package/src/browser/connection-diagnostics-contribution.ts

@@ -0,0 +1,146 @@
+/********************************************************************************
+ * 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 Stopwatch, SystemClock } from '@hydranium/protocol';
+import { MessageService, nls } 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 { inject, injectable, optional, type interfaces } from '@theia/core/shared/inversify';
+import { Clock } from '../common/clock';
+import { type ConnectionBufferOverflow } from '../common/framed-socket-write-buffer';
+import { ChannelLogger } from './channel-logger';
+import { SessionAwareConnectionSource } from './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.
+ */
+@injectable()
+export class ConnectionDiagnosticsContribution implements FrontendApplicationContribution {
+   @inject(WebSocketConnectionSource) protected readonly connectionSource: WebSocketConnectionSource;
+   @inject(ConnectionStatusService) protected readonly connectionStatus: ConnectionStatusService;
+   @inject(ChannelLogger) protected readonly logger: ChannelLogger;
+   @inject(MessageService) protected readonly messageService: MessageService;
+   /** Times the outages the log reports: the container's {@link Clock}, or a `SystemClock`. */
+   @inject(Clock) @optional() protected readonly clock: Clock = new SystemClock();
+
+   /** Main channels created so far; more than one means the server did not recognise this frontend. */
+   protected channelCount = 0;
+   protected sinceSocketClosed?: Stopwatch;
+   protected sinceOffline?: Stopwatch;
+
+   initialize(): void {
+      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 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.debug(`diagnostics active; socket ${this.socketId()}, backend ${this.statusName(this.connectionStatus.currentStatus)}`);
+   }
+
+   protected handleSocketOpen(): void {
+      const downFor = this.sinceSocketClosed === undefined ? '' : ` after ${Math.round(this.sinceSocketClosed.elapsedMs)} ms down`;
+      this.sinceSocketClosed = undefined;
+      this.logger.info(`websocket connected: socket ${this.socketId()}${downFor}`);
+   }
+
+   protected handleSocketClose(): void {
+      this.sinceSocketClosed = this.clock.stopwatch();
+      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.
+    */
+   protected handleChannelOpen(): void {
+      this.channelCount++;
+      if (this.channelCount === 1) {
+         this.logger.debug(`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'
+      );
+   }
+
+   protected handleStatusChange(status: ConnectionStatus): void {
+      if (status === ConnectionStatus.ONLINE) {
+         const offlineFor = this.sinceOffline === undefined ? '' : ` after ${Math.round(this.sinceOffline.elapsedMs)} ms`;
+         this.sinceOffline = undefined;
+         this.logger.info(`backend reachable again${offlineFor}`);
+         return;
+      }
+      this.sinceOffline = this.clock.stopwatch();
+      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.
+    */
+   protected handleBufferOverflow(overflow: ConnectionBufferOverflow): void {
+      this.logger.error(`buffer full at ${overflow.maxBytes} bytes holding ${overflow.messages} message(s)`);
+      this.messageService.error(
+         nls.localize(
+            'hydranium/connection/offlineLimitReached',
+            'Disconnected for too long: recent changes were not sent. Reload the page before continuing.'
+         )
+      );
+   }
+
+   protected socketId(): string {
+      return this.connectionSource.socket?.id ?? WebSocketConnectionSource.NO_CONNECTION;
+   }
+
+   protected statusName(status: ConnectionStatus): string {
+      return status === ConnectionStatus.ONLINE ? 'online' : 'offline';
+   }
+}
+
+/**
+ * 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 function bindConnectionDiagnostics(bind: interfaces.Bind): void {
+   bind(ConnectionDiagnosticsContribution).toSelf().inSingletonScope();
+   bind(FrontendApplicationContribution).toService(ConnectionDiagnosticsContribution);
+}

package/src/browser/connection-reporter.ts

@@ -0,0 +1,121 @@
+/********************************************************************************
+ * 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, nls, type Progress } from '@theia/core';
+import { inject, injectable, type interfaces } from '@theia/core/shared/inversify';
+
+/** What a head connects to, as the whole sentences reported about it. */
+export interface ConnectionTarget {
+   readonly connectingMessage: string;
+   readonly connectedMessage: string;
+}
+
+/** One connection attempt; it reports exactly one end. */
+export interface ConnectionAttempt {
+   connected(): void;
+   /** Ends the attempt with nothing to report, as when its head is disposed
+    *  or a newer attempt takes over. */
+   cancelled(): void;
+   /**
+    * `message` is the whole sentence to report. `retry`, when given, starts a
+    * fresh attempt at once; a head without one keeps retrying on its own.
+    */
+   failed(message: string, retry?: () => void): void;
+}
+
+/**
+ * How a head's connection attempts reach the user. A head calls
+ * {@link connecting} for every attempt, a reconnect included, and keeps the
+ * attempt's retries and bounds itself; this decides only what is shown. Rebind
+ * the slot to show nothing, or something other than notifications.
+ */
+export interface ConnectionReporter {
+   connecting(target: ConnectionTarget): ConnectionAttempt;
+}
+export const ConnectionReporter = Symbol('ConnectionReporter');
+
+/**
+ * Reports through Theia notifications: an attempt still running after
+ * {@link connectingNoticeDelayMs} shows its progress, and an attempt ends in at
+ * most one notification. A failure is shown once per target until it connects
+ * again, so a head that keeps retrying does not raise one per attempt.
+ */
+@injectable()
+export class DefaultConnectionReporter implements ConnectionReporter {
+   @inject(MessageService) protected readonly messageService!: MessageService;
+
+   protected readonly connectingNoticeDelayMs: number = 3_000;
+   /** Targets whose last reported attempt failed. */
+   protected readonly failing = new Set<ConnectionTarget>();
+
+   connecting(target: ConnectionTarget): ConnectionAttempt {
+      let progress: Promise<Progress> | undefined;
+      const notice = this.failing.has(target)
+         ? undefined
+         : setTimeout(() => (progress = this.showConnecting(target)), this.connectingNoticeDelayMs);
+      let settled = false;
+      const settle = (): boolean => {
+         if (settled) {
+            return false;
+         }
+         settled = true;
+         clearTimeout(notice);
+         void progress?.then(shown => shown.cancel());
+         return true;
+      };
+      return {
+         connected: () => {
+            if (settle() && (this.failing.delete(target) || progress)) {
+               this.showConnected(target);
+            }
+         },
+         cancelled: () => {
+            settle();
+         },
+         failed: (message, retry) => {
+            if (settle() && !this.failing.has(target)) {
+               this.failing.add(target);
+               void this.showFailed(target, message, retry);
+            }
+         }
+      };
+   }
+
+   protected showConnecting(target: ConnectionTarget): Promise<Progress> {
+      return this.messageService.showProgress({ text: target.connectingMessage });
+   }
+
+   protected showConnected(target: ConnectionTarget): void {
+      this.messageService.info(target.connectedMessage);
+   }
+
+   protected async showFailed(target: ConnectionTarget, message: string, retry?: () => void): Promise<void> {
+      if (!retry) {
+         this.messageService.error(message);
+         return;
+      }
+      const label = this.retryLabel();
+      if ((await this.messageService.error(message, label)) === label) {
+         // The retried attempt reports afresh, progress included.
+         this.failing.delete(target);
+         retry();
+      }
+   }
+
+   protected retryLabel(): string {
+      return nls.localize('hydranium/client-theia/connection-retry', 'Retry');
+   }
+}
+
+/** Bind {@link DefaultConnectionReporter} unless the slot is bound already; every head calls this. */
+export function bindConnectionReporter(bind: interfaces.Bind, isBound: interfaces.IsBound): void {
+   if (!isBound(ConnectionReporter)) {
+      bind(ConnectionReporter).to(DefaultConnectionReporter).inSingletonScope();
+   }
+}

package/src/browser/editor-disk-sync.ts

@@ -0,0 +1,253 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+
+import { SystemClock, TIMED_OUT } from '@hydranium/protocol';
+import { FrontendApplicationContribution } from '@theia/core/lib/browser/frontend-application-contribution';
+import { ILogger } from '@theia/core/lib/common/logger';
+import URI from '@theia/core/lib/common/uri';
+import { inject, injectable, optional, type interfaces } from '@theia/core/shared/inversify';
+import { EditorManager } from '@theia/editor/lib/browser/editor-manager';
+import type { EditorWidget } from '@theia/editor/lib/browser/editor-widget';
+import type { FileResourceVersion } from '@theia/filesystem/lib/browser/file-resource';
+import { FileService, type TextFileContent } from '@theia/filesystem/lib/browser/file-service';
+import { Clock } from '../common/clock';
+import { HydraniumFileService } from './hydranium-file-service';
+
+/**
+ * The members of Theia's Monaco editor model {@link EditorDiskSync} reads and
+ * resets. `contentChanges`, `resourceVersion` and `run` are `protected` there,
+ * so {@link isResyncableEditorDocument} checks for them at runtime: a Theia
+ * that renames them yields a document it refuses, and the sync then leaves it
+ * alone.
+ */
+export interface ResyncableEditorDocument {
+   readonly uri: string;
+   readonly dirty: boolean;
+   getText(): string;
+   revert(options: { soft: boolean }): Promise<void>;
+   /** The edits the next save applies to the file, in place of the whole text. */
+   readonly contentChanges: unknown[];
+   /** The file version the next save expects to find on disk. */
+   resourceVersion: FileResourceVersion | undefined;
+   /** Queue `operation` behind the model's saves and syncs in progress. */
+   run(operation: () => Promise<void>): Promise<void>;
+   /** Awaited by each save before it takes the pending edits. */
+   onModelWillSaveModel(listener: () => Promise<void>): { dispose(): void };
+}
+
+/** Whether `document` carries the members of {@link ResyncableEditorDocument}. */
+export function isResyncableEditorDocument(document: object): document is ResyncableEditorDocument {
+   return (
+      'uri' in document &&
+      typeof document.uri === 'string' &&
+      'dirty' in document &&
+      'getText' in document &&
+      typeof document.getText === 'function' &&
+      'revert' in document &&
+      typeof document.revert === 'function' &&
+      'contentChanges' in document &&
+      Array.isArray(document.contentChanges) &&
+      'resourceVersion' in document &&
+      'run' in document &&
+      typeof document.run === 'function' &&
+      'onModelWillSaveModel' in document &&
+      typeof document.onModelWillSaveModel === 'function'
+   );
+}
+
+/**
+ * Keeps a dirty editor's save from applying edits its file already holds, as
+ * the file does once the server saves a document the editor shows unsaved.
+ *
+ * Theia keeps such an editor dirty, and its next save corrupts the file: the
+ * save applies the editor's pending edits to the file rather than writing the
+ * whole text, and the file already holds them, so each is applied twice.
+ * Theia's check that the file has not changed since the editor read it passes
+ * whenever the new file has the old one's size, so no conflict is reported. A
+ * revert alone keeps the pending edits.
+ *
+ * Before each save of the editor it reads the file. When the file holds the
+ * text the buffer held as the save began, it drops the edits pending then and
+ * has the save expect the file's version, so the save writes only the edits
+ * made after that point, a save participant's included, onto the file as it
+ * is. The save is not cancelled: it completes and is reported as saved. Save
+ * All relies on this check, since it saves a diagram and then an editor on the
+ * same file at once, before the file watcher has reported the diagram's write.
+ * The buffer is taken when the save calls its will-save listeners. Theia runs
+ * its save participants one after another, each behind an await, and its
+ * first one awaits before it edits, so none has changed the buffer by then. A
+ * participant ordered ahead of it that edits before its first await makes the
+ * file and the taken text differ, and the save applies every edit again.
+ *
+ * On each change the file watcher reports, it marks the editor clean when the
+ * file holds exactly its buffer. The file is compared with the buffer after
+ * it has been read, and the editor is marked in the same step, so a keystroke
+ * made while the file was read leaves the editor dirty. This sync waits behind
+ * a save in flight: that save drops the edits it sent from the pending ones
+ * when it finishes, and a sync before then would have it drop the edits typed
+ * meanwhile.
+ *
+ * An editor whose file holds neither text is left to Theia's own save,
+ * same-size gap included, and so is one whose file cannot be read within
+ * {@link readTimeoutMs}, or whose check throws.
+ *
+ * Bound by {@link bindEditorDiskSync}.
+ */
+@injectable()
+export class EditorDiskSync implements FrontendApplicationContribution {
+   @inject(FileService) protected readonly fileService!: FileService;
+   @inject(EditorManager) protected readonly editorManager!: EditorManager;
+   @inject(ILogger) protected readonly logger!: ILogger;
+   /** Times {@link readTimeoutMs}: the container's {@link Clock}, or a `SystemClock`. */
+   @inject(Clock) @optional() protected readonly clock: Clock = new SystemClock();
+   /** Whether an editor's document has failed {@link isResyncableEditorDocument}; warned of once. */
+   protected warnedUnsyncable = false;
+   /**
+    * How long a check waits for the file. The editor's save, and every later
+    * save and sync of that editor, waits for the check.
+    */
+   protected readTimeoutMs = 1_000;
+
+   onStart(): void {
+      this.fileService.onDidFilesChange(event => {
+         for (const change of event.changes) {
+            this.checkFile(change.resource);
+         }
+      });
+      this.editorManager.onCreated(widget => this.guardSaves(widget));
+      for (const widget of this.editorManager.all) {
+         this.guardSaves(widget);
+      }
+   }
+
+   /** Check `widget`'s document before each of its saves, for as long as the widget lives. */
+   protected guardSaves(widget: EditorWidget): void {
+      const document = this.resyncable(widget.editor.document);
+      if (document) {
+         const registration = document.onModelWillSaveModel(() => this.isolate(() => this.dropChangesOnDisk(document)));
+         widget.onDidDispose(() => registration.dispose());
+      }
+   }
+
+   /** Check each dirty document an editor shows on `uri`, behind that document's save in flight. */
+   protected checkFile(uri: URI): void {
+      for (const document of this.dirtyDocuments(uri)) {
+         void document.run(() => this.isolate(() => this.syncIfOnDisk(document)));
+      }
+   }
+
+   /** Read the file of `document` if it is dirty, and sync it if the file holds its buffer. */
+   protected async syncIfOnDisk(document: ResyncableEditorDocument): Promise<void> {
+      if (!document.dirty) {
+         return;
+      }
+      const content = await this.readFile(document);
+      if (content && document.getText() === content.value) {
+         this.syncFromDisk(document, { etag: content.etag, mtime: content.mtime, encoding: content.encoding });
+      }
+   }
+
+   /**
+    * Before a save of `document`, drop the edits pending now if its file holds
+    * the buffer as it is now, and take the file's version. The buffer and the
+    * count are taken before the first await, while the save is still calling
+    * its will-save listeners; an edit made after that stays pending, and the
+    * save writes it onto the file.
+    */
+   protected async dropChangesOnDisk(document: ResyncableEditorDocument): Promise<void> {
+      if (!document.dirty) {
+         return;
+      }
+      const text = document.getText();
+      const pending = document.contentChanges.length;
+      const content = await this.readFile(document);
+      if (content?.value === text) {
+         document.contentChanges.splice(0, pending);
+         document.resourceVersion = { etag: content.etag, mtime: content.mtime, encoding: content.encoding };
+      }
+   }
+
+   /**
+    * The file of `document`, or `undefined` when it is gone, cannot be read, or
+    * is not read within {@link readTimeoutMs}.
+    */
+   protected async readFile(document: ResyncableEditorDocument): Promise<TextFileContent | undefined> {
+      const read = this.fileService.read(new URI(document.uri)).catch(() => undefined);
+      const content = await this.clock.raceTimer(read, this.readTimeoutMs);
+      return content === TIMED_OUT ? undefined : content;
+   }
+
+   /**
+    * Run `check`, and log its failure rather than pass it on. A will-save
+    * listener that rejects makes Theia drop the save without writing, and a
+    * sync that rejects goes unhandled.
+    */
+   protected async isolate(check: () => Promise<void>): Promise<void> {
+      try {
+         await check();
+      } catch (err: unknown) {
+         void this.logger.error('EditorDiskSync: checking an editor against its file failed; the editor is left as it is.', err);
+      }
+   }
+
+   /** The dirty documents open in an editor on `uri`, each once however many editors show it. */
+   protected dirtyDocuments(uri: URI): ResyncableEditorDocument[] {
+      const target = uri.toString();
+      const documents = new Set<ResyncableEditorDocument>();
+      for (const widget of this.editorManager.all) {
+         const document = this.resyncable(widget.editor.document);
+         if (document && document.uri === target && document.dirty) {
+            documents.add(document);
+         }
+      }
+      return [...documents];
+   }
+
+   /** `document` if it carries the members the sync resets; otherwise `undefined`, warned of once. */
+   protected resyncable(document: object): ResyncableEditorDocument | undefined {
+      if (isResyncableEditorDocument(document)) {
+         return document;
+      }
+      if (!this.warnedUnsyncable) {
+         this.warnedUnsyncable = true;
+         void this.logger.warn(
+            'EditorDiskSync: an editor document lacks the Monaco model members the sync resets, so such editors are not synced with their files.'
+         );
+      }
+      return undefined;
+   }
+
+   /**
+    * Take `version` as the file `document` was last saved to, with nothing
+    * pending, and mark it clean. Synchronous throughout: a soft revert only
+    * marks the document clean, and reads nothing. The revert also cancels a
+    * save queued behind the sync, which would have written the same text.
+    */
+   protected syncFromDisk(document: ResyncableEditorDocument, version: FileResourceVersion): void {
+      document.contentChanges.splice(0, document.contentChanges.length);
+      document.resourceVersion = version;
+      void document.revert({ soft: true });
+   }
+}
+
+/**
+ * Bind {@link EditorDiskSync} as a frontend contribution and rebind Theia's
+ * `FileService` to {@link HydraniumFileService}, unless `EditorDiskSync` is
+ * bound already. No framework module calls this, because the rebind would
+ * replace a frontend's own `FileService` binding. A subclass of the sync is
+ * rebound after this call: one bound before it skips the whole call.
+ */
+export function bindEditorDiskSync(bind: interfaces.Bind, isBound: interfaces.IsBound, rebind: interfaces.Rebind): void {
+   if (isBound(EditorDiskSync)) {
+      return;
+   }
+   bind(EditorDiskSync).toSelf().inSingletonScope();
+   bind(FrontendApplicationContribution).toService(EditorDiskSync);
+   rebind(FileService).to(HydraniumFileService).inSingletonScope();
+}

package/src/browser/hydranium-file-service.ts

@@ -0,0 +1,56 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+
+import type URI from '@theia/core/lib/common/uri';
+import { injectable } from '@theia/core/shared/inversify';
+import { FileService, type UpdateTextFileOptions } from '@theia/filesystem/lib/browser/file-service';
+import { ETAG_DISABLED } from '@theia/filesystem/lib/common/files';
+
+/**
+ * Theia's `FileService`, refusing an incremental save once the file has
+ * changed since the editor read it.
+ *
+ * Theia's own check, which `write` and `update` share, passes a file whose
+ * mtime moved on when its size still matches the etag the editor read. That
+ * is safe for `write`, which replaces the file with the whole text, but
+ * `update` applies the editor's pending edits to the file as it is, so after a
+ * same-size change, the server saving those very edits included, it applies
+ * them a second time. Here `update` hands that check the etag with a `!`
+ * appended, which no file's etag can match: Theia writes an etag as the mtime
+ * in base 29 followed by the size in base 31, digits and lower-case letters
+ * only. An advanced mtime is then enough for Theia to refuse with its
+ * `FILE_MODIFIED_SINCE`. The editor's save then falls back to `write` with the
+ * whole text, which Theia checks as before: it writes when the size is
+ * unchanged, and asks the user otherwise. A same-size change by another
+ * process is therefore overwritten by that write rather than merged with the
+ * editor's edits. `write` is left as it is.
+ *
+ * It is the safety net behind `EditorDiskSync`, which acts only when the
+ * file holds the editor's buffer: a file holding some of the edits, as when a
+ * save participant ordered ahead of Theia's first one edits before its first
+ * await, is left to this check.
+ *
+ * A write within the file system's mtime resolution of the read goes unseen,
+ * as it does for Theia's own check. A file whose mtime moves while its text
+ * stays the same costs a whole-text write rather than the edits.
+ *
+ * Bound by `bindEditorDiskSync`.
+ */
+@injectable()
+export class HydraniumFileService extends FileService {
+   override update(
+      resource: URI,
+      changes: Parameters<FileService['update']>[1],
+      options: UpdateTextFileOptions
+   ): ReturnType<FileService['update']> {
+      const strict =
+         typeof options.etag === 'string' && options.etag !== ETAG_DISABLED ? { ...options, etag: `${options.etag}!` } : options;
+      return super.update(resource, changes, strict);
+   }
+}

package/src/browser/index.ts

@@ -12,3 +12,8 @@ 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';
+export * from './connection-reporter';
+export * from './editor-disk-sync';
+export * from './hydranium-file-service';

package/src/browser/log-level-preference.ts

@@ -108,7 +108,18 @@ export class LogLevelPreferenceContribution implements FrontendApplicationContri
    protected applyLevel(): void {
       const level = parseLogLevel(this.preferences.get<string>(this.preferenceName));
       if (level) {
+         const previous = Logger.getLevel();
          Logger.setLevel(level);
+         if (previous !== level) {
+            // Through Theia's `ILogger`, which has a threshold of its own and so
+            // is not silenced by the value just applied — the framework logger
+            // this preference governs would drop the line on a switch to `error`.
+            //
+            // Frontend and server announce separately: this preference reaches
+            // the server only if a client delivers it as configuration, so one
+            // line without the other says it did not.
+            this.logger.info(`Log level ${previous} → ${level} (preference '${this.preferenceName}')`);
+         }
       }
    }
 }

package/src/browser/memory-diagnostics-contribution.ts

@@ -11,7 +11,8 @@ import {
    formatLatencyReport,
    type DataServerDiagnosticsProtocol,
    type HostDiagnosticsProtocol,
-   type StartProfilingArgs
+   type StartProfilingArgs,
+   describeError
 } from '@hydranium/protocol';
 import { captureBrowserRuntime, formatBrowserRuntime } from './browser-capture';
 import { CommandContribution, MessageService, nls, type Command, type CommandRegistry } from '@theia/core';
@@ -92,7 +93,7 @@ export class MemoryDiagnosticsContribution implements CommandContribution {
    /** Dimensions the profiling commands capture — the server samples only what is named. */
    protected readonly profileDimensions: StartProfilingArgs = { cpu: true, allocation: true, gc: true, eventLoopDelay: true };
    /** Window length for the "Record Performance Profile" command. */
-   protected readonly recordDurationMs = 10_000;
+   protected readonly recordDurationMs: number = 10_000;
    /**
     * Label of the stop-profiling command, and of the action its start toast
     * offers. One field for both: two literals naming one command can be
@@ -454,7 +455,7 @@ export class MemoryDiagnosticsContribution implements CommandContribution {
    }
 
    protected errorMessage(error: unknown): string {
-      return error instanceof Error ? error.message : String(error);
+      return describeError(error);
    }
 }