@hydranium/client-theia 1.0.0-next.38 → 1.0.0-next.381

package/lib/common/framed-socket-write-buffer.d.ts

@@ -0,0 +1,173 @@
+/********************************************************************************
+ * 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 { Emitter, type Event } from '@theia/core/lib/common/event';
+import { SocketWriteBuffer } from '@theia/core/lib/common/messaging/socket-write-buffer';
+import { type ConnectionResilienceOptions } from './connection-resilience-options';
+/**
+ * Prefix on every connection log line, deliberately shared by the browser and the
+ * server so one pattern greps a console and a pod log at once.
+ */
+export declare const CONNECTION_LOG_PREFIX = "[connection]";
+/**
+ * The part of a socket this buffer uses. Narrower than the socket type Theia
+ * declares, which keeps the dependency honest and lets the class be tested
+ * without a connection.
+ */
+export interface MessageSink {
+    /** `sequence` travels as a second socket.io argument, which a reader that does not expect it ignores. */
+    send(data: Uint8Array, sequence: number): void;
+}
+/**
+ * Reported when the buffer runs out of room. The message that did not fit is
+ * rejected, and so is every further one for as long as the buffer stays full.
+ * Reconnecting drains it and sending resumes, but whatever was rejected
+ * meanwhile is gone, so the two sides no longer agree about the session.
+ */
+export interface ConnectionBufferOverflow {
+    /** Messages held when the limit was reached. */
+    readonly messages: number;
+    /** Bytes held when the limit was reached. */
+    readonly bytes: number;
+    /** The limit in force, so a reader can tell what to raise it to. */
+    readonly maxBytes: number;
+}
+/**
+ * Holds messages while the peer is away and re-sends them when it returns.
+ *
+ * Theia copies them into one growing byte array and flushes that with a single
+ * `send`. A websocket delivers whole messages rather than a byte stream, so
+ * Theia's encoding adds no length prefix and every reader assumes one delivery
+ * is one message. The concatenated flush breaks that assumption: the reader
+ * decodes the first message and throws away the bytes behind it.
+ *
+ * Changed here: one entry per message, sent one at a time, so each arrives as
+ * its own delivery. The buffer also decides whether a message may go out
+ * directly — see {@link sendOrQueue} — because a caller that decides for itself
+ * is how messages end up overtaking a backlog.
+ *
+ * Unchanged from Theia: exceeding the limit rejects the message rather than
+ * dropping something silently. The limit is settable, since the right value
+ * depends on how long an outage has to survive.
+ *
+ * Added here: every message sent is numbered and kept until the peer
+ * acknowledges it, and {@link flush} resends what is still unacknowledged ahead
+ * of the backlog. A socket whose far end died unnoticed still accepts writes, so
+ * a message is not delivered just because it was sent.
+ *
+ * Logging goes to `console` rather than through a `Logger`. On the browser side
+ * Theia's preloader builds this before any Output channel exists, so there is
+ * nothing else to write to; the {@link CONNECTION_LOG_PREFIX} keeps the lines
+ * findable on both sides.
+ */
+export declare class FramedSocketWriteBuffer extends SocketWriteBuffer {
+    /** Theia's fixed limit, kept as the default. */
+    static readonly DEFAULT_MAX_BYTES: number;
+    /**
+     * Settable so a deployment can trade memory for longer outages.
+     *
+     * Consulted directly rather than through the base class's `maxBufferSize`,
+     * which does not exist before Theia 1.71 — an `override` of it would not
+     * compile against the oldest release this package supports. Nothing is lost:
+     * `buffer`, `flush` and `drain` are all replaced here, so the base's own
+     * limit is never reached.
+     */
+    maxBytes: number;
+    /** Kept copies past this are discarded, so a peer that never acknowledges cannot grow them without bound. */
+    static readonly DEFAULT_MAX_UNACKNOWLEDGED_BYTES: number;
+    /**
+     * Separate from {@link maxBytes}, which counts only what is produced while
+     * the peer is away: copies kept on a healthy connection must not use up the
+     * room an outage needs.
+     */
+    maxUnacknowledgedBytes: number;
+    protected pending: Uint8Array[];
+    protected pendingBytes: number;
+    protected overflowReported: boolean;
+    protected readonly onOverflowEmitter: Emitter<ConnectionBufferOverflow>;
+    protected nextSequence: number;
+    /** Oldest first: {@link acknowledge} stops at the first entry the peer has not accepted. */
+    protected unacknowledged: {
+        readonly sequence: number;
+        readonly data: Uint8Array;
+    }[];
+    protected unacknowledgedBytes: number;
+    protected unacknowledgedOverflowReported: boolean;
+    /**
+     * Whether the peer drops a message it already has. One without the hardening
+     * applies a resent message a second time, so nothing is resent until the
+     * peer has shown otherwise.
+     */
+    protected peerDeduplicates: boolean;
+    /** Fires once per outage when the limit is reached. */
+    get onOverflow(): Event<ConnectionBufferOverflow>;
+    /**
+     * Sends `data` now only if nothing is waiting, and queues it otherwise.
+     *
+     * Callers say whether the peer is ready for a message; the buffer decides
+     * whether it may go ahead of one already waiting. Splitting it this way is
+     * the point: a caller that answers both questions from one flag is how a
+     * fresh message ends up overtaking a backlog.
+     */
+    sendOrQueue(socket: MessageSink | undefined, data: Uint8Array): void;
+    buffer(data: Uint8Array): void;
+    /**
+     * Kept only once `send` returns: a message whose send threw stays in the
+     * backlog, and keeping it as well would send it again under a second number,
+     * which the receiver cannot recognise as a duplicate.
+     */
+    protected send(socket: MessageSink, data: Uint8Array): void;
+    protected keep(sequence: number, data: Uint8Array): void;
+    /**
+     * Records that the peer numbers its messages, which only a peer that also
+     * drops duplicates does, so resending to it is safe.
+     */
+    markPeerDeduplicates(): void;
+    /** Releases every kept message numbered up to `sequence`, which the peer has accepted. */
+    acknowledge(sequence: number): void;
+    /**
+     * Resends what the peer has not acknowledged, under the same numbers, then
+     * sends the backlog. Some of the resent messages may have arrived already;
+     * the receiver recognises them by number and drops them.
+     *
+     * Resends only to a peer known to drop duplicates, and otherwise discards the
+     * copies, leaving any message lost with the old socket lost.
+     */
+    flush(socket: MessageSink): void;
+    drain(): void;
+    /** Whether messages are still waiting to go out. */
+    get hasBacklog(): boolean;
+    protected reportOverflow(): void;
+    /** Also discards the kept copies: a drain ends the session, and resending them would replay it into the next one. */
+    protected reset(): void;
+}
+/** Named in the warning a skipped install emits, so the reader is told what to upgrade to. */
+export declare const REQUIRED_THEIA_HINT = "@theia/core 1.71 or newer";
+/**
+ * Whether this Theia exposes the seam the reconnect hardening replaces.
+ *
+ * Theia only began binding {@link SocketWriteBuffer} in 1.71; before that each
+ * connection built one privately, so there is no binding to rebind and no way
+ * in. Every other API involved has been there throughout, which makes this one
+ * probe the whole compatibility question — and it is a binding check rather
+ * than a version parse, so it answers about the container actually in front of
+ * us instead of a number that may have been overridden or vendored.
+ *
+ * Callers that get `false` must leave Theia's own wiring alone: rebinding half
+ * of it would be worse than not rebinding at all.
+ */
+export declare function supportsConnectionResilience(isBound: (identifier: typeof SocketWriteBuffer) => boolean): boolean;
+/**
+ * The warning a skipped install emits. Says what is lost rather than only what
+ * is missing: the failures this guards against are silent, so an adopter who
+ * never sees this line has no other way to learn the guard is absent.
+ */
+export declare function warnConnectionResilienceUnavailable(tier: 'frontend' | 'backend'): void;
+/** Builds a buffer with the configured limits, or the defaults for any not configured. */
+export declare function createFramedSocketWriteBuffer(options?: ConnectionResilienceOptions): FramedSocketWriteBuffer;
+//# sourceMappingURL=framed-socket-write-buffer.d.ts.map

package/lib/common/framed-socket-write-buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"framed-socket-write-buffer.d.ts","sourceRoot":"","sources":["../../src/common/framed-socket-write-buffer.ts"],"names":[],"mappings":"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"}

package/lib/common/framed-socket-write-buffer.js

@@ -0,0 +1,293 @@
+"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.REQUIRED_THEIA_HINT = exports.FramedSocketWriteBuffer = exports.CONNECTION_LOG_PREFIX = void 0;
+exports.supportsConnectionResilience = supportsConnectionResilience;
+exports.warnConnectionResilienceUnavailable = warnConnectionResilienceUnavailable;
+exports.createFramedSocketWriteBuffer = createFramedSocketWriteBuffer;
+const event_1 = require("@theia/core/lib/common/event");
+const socket_write_buffer_1 = require("@theia/core/lib/common/messaging/socket-write-buffer");
+/**
+ * Prefix on every connection log line, deliberately shared by the browser and the
+ * server so one pattern greps a console and a pod log at once.
+ */
+exports.CONNECTION_LOG_PREFIX = '[connection]';
+/**
+ * Holds messages while the peer is away and re-sends them when it returns.
+ *
+ * Theia copies them into one growing byte array and flushes that with a single
+ * `send`. A websocket delivers whole messages rather than a byte stream, so
+ * Theia's encoding adds no length prefix and every reader assumes one delivery
+ * is one message. The concatenated flush breaks that assumption: the reader
+ * decodes the first message and throws away the bytes behind it.
+ *
+ * Changed here: one entry per message, sent one at a time, so each arrives as
+ * its own delivery. The buffer also decides whether a message may go out
+ * directly — see {@link sendOrQueue} — because a caller that decides for itself
+ * is how messages end up overtaking a backlog.
+ *
+ * Unchanged from Theia: exceeding the limit rejects the message rather than
+ * dropping something silently. The limit is settable, since the right value
+ * depends on how long an outage has to survive.
+ *
+ * Added here: every message sent is numbered and kept until the peer
+ * acknowledges it, and {@link flush} resends what is still unacknowledged ahead
+ * of the backlog. A socket whose far end died unnoticed still accepts writes, so
+ * a message is not delivered just because it was sent.
+ *
+ * Logging goes to `console` rather than through a `Logger`. On the browser side
+ * Theia's preloader builds this before any Output channel exists, so there is
+ * nothing else to write to; the {@link CONNECTION_LOG_PREFIX} keeps the lines
+ * findable on both sides.
+ */
+class FramedSocketWriteBuffer extends socket_write_buffer_1.SocketWriteBuffer {
+    /** Theia's fixed limit, kept as the default. */
+    static DEFAULT_MAX_BYTES = 100 * 1024;
+    /**
+     * Settable so a deployment can trade memory for longer outages.
+     *
+     * Consulted directly rather than through the base class's `maxBufferSize`,
+     * which does not exist before Theia 1.71 — an `override` of it would not
+     * compile against the oldest release this package supports. Nothing is lost:
+     * `buffer`, `flush` and `drain` are all replaced here, so the base's own
+     * limit is never reached.
+     */
+    maxBytes = FramedSocketWriteBuffer.DEFAULT_MAX_BYTES;
+    /** Kept copies past this are discarded, so a peer that never acknowledges cannot grow them without bound. */
+    static DEFAULT_MAX_UNACKNOWLEDGED_BYTES = 1024 * 1024;
+    /**
+     * Separate from {@link maxBytes}, which counts only what is produced while
+     * the peer is away: copies kept on a healthy connection must not use up the
+     * room an outage needs.
+     */
+    maxUnacknowledgedBytes = FramedSocketWriteBuffer.DEFAULT_MAX_UNACKNOWLEDGED_BYTES;
+    pending = [];
+    pendingBytes = 0;
+    overflowReported = false;
+    onOverflowEmitter = new event_1.Emitter();
+    nextSequence = 1;
+    /** Oldest first: {@link acknowledge} stops at the first entry the peer has not accepted. */
+    unacknowledged = [];
+    unacknowledgedBytes = 0;
+    unacknowledgedOverflowReported = false;
+    /**
+     * Whether the peer drops a message it already has. One without the hardening
+     * applies a resent message a second time, so nothing is resent until the
+     * peer has shown otherwise.
+     */
+    peerDeduplicates = false;
+    /** Fires once per outage when the limit is reached. */
+    get onOverflow() {
+        return this.onOverflowEmitter.event;
+    }
+    /**
+     * Sends `data` now only if nothing is waiting, and queues it otherwise.
+     *
+     * Callers say whether the peer is ready for a message; the buffer decides
+     * whether it may go ahead of one already waiting. Splitting it this way is
+     * the point: a caller that answers both questions from one flag is how a
+     * fresh message ends up overtaking a backlog.
+     */
+    sendOrQueue(socket, data) {
+        if (socket && !this.hasBacklog) {
+            this.send(socket, data);
+        }
+        else {
+            this.buffer(data);
+        }
+    }
+    buffer(data) {
+        if (this.pendingBytes + data.byteLength > this.maxBytes) {
+            this.reportOverflow();
+            throw new Error(`Max disconnected buffer size exceeded by adding ${data.byteLength} bytes`);
+        }
+        // Copied for the same reason the base class copies: the caller owns `data`.
+        this.pending.push(data.slice());
+        this.pendingBytes += data.byteLength;
+        if (this.pending.length === 1) {
+            console.info(`${exports.CONNECTION_LOG_PREFIX} buffering messages, the peer is disconnected`);
+        }
+    }
+    /**
+     * Kept only once `send` returns: a message whose send threw stays in the
+     * backlog, and keeping it as well would send it again under a second number,
+     * which the receiver cannot recognise as a duplicate.
+     */
+    send(socket, data) {
+        const sequence = this.nextSequence++;
+        socket.send(data, sequence);
+        this.keep(sequence, data);
+    }
+    keep(sequence, data) {
+        if (this.unacknowledgedBytes + data.byteLength > this.maxUnacknowledgedBytes) {
+            // Said only to a peer known to acknowledge: one without the hardening never does, and
+            // nothing would be resent to it anyway.
+            if (this.peerDeduplicates && !this.unacknowledgedOverflowReported) {
+                this.unacknowledgedOverflowReported = true;
+                console.warn(`${exports.CONNECTION_LOG_PREFIX} the peer has not acknowledged ${this.unacknowledged.length} message(s), ` +
+                    `${this.unacknowledgedBytes} bytes; discarding their copies, so a connection dropped now loses them`);
+            }
+            this.unacknowledged = [];
+            this.unacknowledgedBytes = 0;
+            return;
+        }
+        // Not copied: a committed write buffer hands over a fresh array and is disposed.
+        this.unacknowledged.push({ sequence, data });
+        this.unacknowledgedBytes += data.byteLength;
+    }
+    /**
+     * Records that the peer numbers its messages, which only a peer that also
+     * drops duplicates does, so resending to it is safe.
+     */
+    markPeerDeduplicates() {
+        this.peerDeduplicates = true;
+    }
+    /** Releases every kept message numbered up to `sequence`, which the peer has accepted. */
+    acknowledge(sequence) {
+        this.peerDeduplicates = true;
+        let index = 0;
+        while (index < this.unacknowledged.length && this.unacknowledged[index].sequence <= sequence) {
+            this.unacknowledgedBytes -= this.unacknowledged[index].data.byteLength;
+            index++;
+        }
+        if (index > 0) {
+            this.unacknowledged = this.unacknowledged.slice(index);
+        }
+    }
+    /**
+     * Resends what the peer has not acknowledged, under the same numbers, then
+     * sends the backlog. Some of the resent messages may have arrived already;
+     * the receiver recognises them by number and drops them.
+     *
+     * Resends only to a peer known to drop duplicates, and otherwise discards the
+     * copies, leaving any message lost with the old socket lost.
+     */
+    flush(socket) {
+        if (this.peerDeduplicates) {
+            for (const { sequence, data } of this.unacknowledged) {
+                socket.send(data, sequence);
+            }
+            if (this.unacknowledged.length > 0) {
+                console.info(`${exports.CONNECTION_LOG_PREFIX} resent ${this.unacknowledged.length} unacknowledged message(s), ${this.unacknowledgedBytes} bytes`);
+            }
+        }
+        else {
+            this.unacknowledged = [];
+            this.unacknowledgedBytes = 0;
+        }
+        if (this.pending.length === 0) {
+            return;
+        }
+        const count = this.pending.length;
+        const bytes = this.pendingBytes;
+        // Walked with an index and dropped in one slice, not shifted per message: a shift re-indexes
+        // the whole array, so the drain would cost the square of a backlog `bufferBytes` invites an
+        // adopter to enlarge. Leaving the queue in place is what keeps `hasBacklog` true until the
+        // last message is out, and re-reading the length is what drains one appended by a nested send.
+        let index = 0;
+        try {
+            while (index < this.pending.length) {
+                const message = this.pending[index];
+                this.send(socket, message);
+                index++;
+                this.pendingBytes -= message.byteLength;
+            }
+        }
+        catch (error) {
+            // Said here because nothing retries: Theia flushes once, from a reconnect handler that has
+            // deregistered by now, so the stall would otherwise surface much later as an overflow —
+            // which names the wrong cause, the socket being up rather than absent.
+            console.error(`${exports.CONNECTION_LOG_PREFIX} send failed ${index} message(s) into a ${count}-message backlog; ` +
+                `${this.pending.length - index} still queued and nothing will retry them`, error);
+            throw error;
+        }
+        finally {
+            this.pending = this.pending.slice(index);
+        }
+        this.overflowReported = false;
+        console.info(`${exports.CONNECTION_LOG_PREFIX} sent ${count} buffered message(s), ${bytes} bytes`);
+    }
+    drain() {
+        if (this.pending.length > 0 || this.unacknowledged.length > 0) {
+            console.warn(`${exports.CONNECTION_LOG_PREFIX} discarded ${this.pending.length} buffered message(s), ${this.pendingBytes} bytes, ` +
+                `and ${this.unacknowledged.length} sent but unacknowledged, ${this.unacknowledgedBytes} bytes`);
+        }
+        this.reset();
+    }
+    /** Whether messages are still waiting to go out. */
+    get hasBacklog() {
+        return this.pending.length > 0;
+    }
+    reportOverflow() {
+        if (this.overflowReported) {
+            return;
+        }
+        this.overflowReported = true;
+        const overflow = { messages: this.pending.length, bytes: this.pendingBytes, maxBytes: this.maxBytes };
+        console.error(`${exports.CONNECTION_LOG_PREFIX} buffer full at ${overflow.maxBytes} bytes after ${overflow.messages} message(s); ` +
+            'this message is rejected, and so is every further one until the peer returns');
+        this.onOverflowEmitter.fire(overflow);
+    }
+    /** Also discards the kept copies: a drain ends the session, and resending them would replay it into the next one. */
+    reset() {
+        this.pending = [];
+        this.pendingBytes = 0;
+        this.overflowReported = false;
+        this.nextSequence = 1;
+        this.unacknowledged = [];
+        this.unacknowledgedBytes = 0;
+        this.unacknowledgedOverflowReported = false;
+        this.peerDeduplicates = false;
+    }
+}
+exports.FramedSocketWriteBuffer = FramedSocketWriteBuffer;
+/** Named in the warning a skipped install emits, so the reader is told what to upgrade to. */
+exports.REQUIRED_THEIA_HINT = '@theia/core 1.71 or newer';
+/**
+ * Whether this Theia exposes the seam the reconnect hardening replaces.
+ *
+ * Theia only began binding {@link SocketWriteBuffer} in 1.71; before that each
+ * connection built one privately, so there is no binding to rebind and no way
+ * in. Every other API involved has been there throughout, which makes this one
+ * probe the whole compatibility question — and it is a binding check rather
+ * than a version parse, so it answers about the container actually in front of
+ * us instead of a number that may have been overridden or vendored.
+ *
+ * Callers that get `false` must leave Theia's own wiring alone: rebinding half
+ * of it would be worse than not rebinding at all.
+ */
+function supportsConnectionResilience(isBound) {
+    return isBound(socket_write_buffer_1.SocketWriteBuffer);
+}
+/**
+ * The warning a skipped install emits. Says what is lost rather than only what
+ * is missing: the failures this guards against are silent, so an adopter who
+ * never sees this line has no other way to learn the guard is absent.
+ */
+function warnConnectionResilienceUnavailable(tier) {
+    console.warn(`${exports.CONNECTION_LOG_PREFIX} ${tier} reconnect hardening NOT installed: this Theia does not expose an injectable ` +
+        `socket write buffer (needs ${exports.REQUIRED_THEIA_HINT}). Theia's own behaviour is left in place, which can lose or ` +
+        'reorder messages when a socket drops and reconnects.');
+}
+/** Builds a buffer with the configured limits, or the defaults for any not configured. */
+function createFramedSocketWriteBuffer(options = {}) {
+    const buffer = new FramedSocketWriteBuffer();
+    if (isPositive(options.bufferBytes)) {
+        buffer.maxBytes = options.bufferBytes;
+    }
+    if (isPositive(options.unacknowledgedBytes)) {
+        buffer.maxUnacknowledgedBytes = options.unacknowledgedBytes;
+    }
+    return buffer;
+}
+function isPositive(value) {
+    return typeof value === 'number' && value > 0;
+}
+//# sourceMappingURL=framed-socket-write-buffer.js.map

package/lib/common/framed-socket-write-buffer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"framed-socket-write-buffer.js","sourceRoot":"","sources":["../../src/common/framed-socket-write-buffer.ts"],"names":[],"mappings":"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"}

package/lib/common/inbound-message-sequence.d.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
+ ********************************************************************************/
+/** The socket.io event that carries the highest message number a side has accepted. */
+export declare const ACKNOWLEDGEMENT_EVENT = "hydranium:ack";
+/**
+ * What one side has received on a session: drops a message it already accepted
+ * and acknowledges the rest.
+ *
+ * The peer resends everything unacknowledged when a session resumes, because it
+ * cannot tell which of its messages died with the old socket, so every resumed
+ * session can repeat messages already delivered. Delivering one twice corrupts
+ * anything applied by position, just as losing one does.
+ *
+ * Acknowledges once enough has arrived, and otherwise after a short delay. A
+ * timer alone is not enough: a background tab throttles timers, and the peer
+ * holds every unacknowledged message until the acknowledgement arrives. The
+ * first message of a session is acknowledged at once, because the peer resends
+ * nothing until an acknowledgement shows it may.
+ *
+ * Belongs to one session. A new session numbers from the start again, so it
+ * needs a new instance.
+ */
+export declare class InboundMessageSequence {
+    protected readonly sendAcknowledgement: (sequence: number) => void;
+    static readonly ACKNOWLEDGE_AFTER_MESSAGES = 64;
+    static readonly ACKNOWLEDGE_AFTER_BYTES: number;
+    static readonly ACKNOWLEDGE_DELAY_MS = 100;
+    protected lastAccepted: number;
+    protected messagesSinceAcknowledgement: number;
+    protected bytesSinceAcknowledgement: number;
+    protected acknowledgementTimer: ReturnType<typeof setTimeout> | undefined;
+    constructor(sendAcknowledgement: (sequence: number) => void);
+    /**
+     * Whether to deliver a message that arrived with `sequence`.
+     *
+     * A message without a number comes from a peer that does not number them,
+     * and is delivered as it is. A duplicate is still acknowledged: the peer
+     * resent it because an earlier acknowledgement was lost, and keeps it until
+     * one arrives.
+     *
+     * A skipped number is delivered past, with a warning: the skipped messages
+     * are lost, and this is the one place that can tell.
+     */
+    accept(sequence: unknown, bytes: number): boolean;
+    /** Sends the acknowledgement now rather than waiting for more traffic. */
+    acknowledge(): void;
+    dispose(): void;
+    protected cancelTimer(): void;
+}
+//# sourceMappingURL=inbound-message-sequence.d.ts.map

package/lib/common/inbound-message-sequence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inbound-message-sequence.d.ts","sourceRoot":"","sources":["../../src/common/inbound-message-sequence.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAIlF,uFAAuF;AACvF,eAAO,MAAM,qBAAqB,kBAAkB,CAAC;AAErD;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,sBAAsB;IAUpB,SAAS,CAAC,QAAQ,CAAC,mBAAmB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI;IAT9E,MAAM,CAAC,QAAQ,CAAC,0BAA0B,MAAM;IAChD,MAAM,CAAC,QAAQ,CAAC,uBAAuB,SAAa;IACpD,MAAM,CAAC,QAAQ,CAAC,oBAAoB,OAAO;IAE3C,SAAS,CAAC,YAAY,SAAK;IAC3B,SAAS,CAAC,4BAA4B,SAAK;IAC3C,SAAS,CAAC,yBAAyB,SAAK;IACxC,SAAS,CAAC,oBAAoB,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,SAAS,CAAC;IAE1E,YAA+B,mBAAmB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,EAAI;IAElF;;;;;;;;;;OAUG;IACH,MAAM,CAAC,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CA4BhD;IAED,0EAA0E;IAC1E,WAAW,IAAI,IAAI,CAKlB;IAED,OAAO,IAAI,IAAI,CAEd;IAED,SAAS,CAAC,WAAW,IAAI,IAAI,CAG5B;CACH"}

package/lib/common/inbound-message-sequence.js

@@ -0,0 +1,98 @@
+"use strict";
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InboundMessageSequence = exports.ACKNOWLEDGEMENT_EVENT = void 0;
+const framed_socket_write_buffer_1 = require("./framed-socket-write-buffer");
+/** The socket.io event that carries the highest message number a side has accepted. */
+exports.ACKNOWLEDGEMENT_EVENT = 'hydranium:ack';
+/**
+ * What one side has received on a session: drops a message it already accepted
+ * and acknowledges the rest.
+ *
+ * The peer resends everything unacknowledged when a session resumes, because it
+ * cannot tell which of its messages died with the old socket, so every resumed
+ * session can repeat messages already delivered. Delivering one twice corrupts
+ * anything applied by position, just as losing one does.
+ *
+ * Acknowledges once enough has arrived, and otherwise after a short delay. A
+ * timer alone is not enough: a background tab throttles timers, and the peer
+ * holds every unacknowledged message until the acknowledgement arrives. The
+ * first message of a session is acknowledged at once, because the peer resends
+ * nothing until an acknowledgement shows it may.
+ *
+ * Belongs to one session. A new session numbers from the start again, so it
+ * needs a new instance.
+ */
+class InboundMessageSequence {
+    sendAcknowledgement;
+    static ACKNOWLEDGE_AFTER_MESSAGES = 64;
+    static ACKNOWLEDGE_AFTER_BYTES = 32 * 1024;
+    static ACKNOWLEDGE_DELAY_MS = 100;
+    lastAccepted = 0;
+    messagesSinceAcknowledgement = 0;
+    bytesSinceAcknowledgement = 0;
+    acknowledgementTimer;
+    constructor(sendAcknowledgement) {
+        this.sendAcknowledgement = sendAcknowledgement;
+    }
+    /**
+     * Whether to deliver a message that arrived with `sequence`.
+     *
+     * A message without a number comes from a peer that does not number them,
+     * and is delivered as it is. A duplicate is still acknowledged: the peer
+     * resent it because an earlier acknowledgement was lost, and keeps it until
+     * one arrives.
+     *
+     * A skipped number is delivered past, with a warning: the skipped messages
+     * are lost, and this is the one place that can tell.
+     */
+    accept(sequence, bytes) {
+        if (typeof sequence !== 'number') {
+            return true;
+        }
+        const isFirst = this.lastAccepted === 0;
+        const isNew = sequence > this.lastAccepted;
+        if (isNew) {
+            if (sequence > this.lastAccepted + 1) {
+                const missing = sequence - this.lastAccepted - 1;
+                console.warn(`${framed_socket_write_buffer_1.CONNECTION_LOG_PREFIX} lost ${missing} message(s), numbered ${this.lastAccepted + 1} to ${sequence - 1}; ` +
+                    'they never arrived and nothing will resend them');
+            }
+            this.lastAccepted = sequence;
+        }
+        this.messagesSinceAcknowledgement++;
+        this.bytesSinceAcknowledgement += bytes;
+        if (isFirst ||
+            this.messagesSinceAcknowledgement >= InboundMessageSequence.ACKNOWLEDGE_AFTER_MESSAGES ||
+            this.bytesSinceAcknowledgement >= InboundMessageSequence.ACKNOWLEDGE_AFTER_BYTES) {
+            this.acknowledge();
+        }
+        else {
+            this.acknowledgementTimer ??= setTimeout(() => this.acknowledge(), InboundMessageSequence.ACKNOWLEDGE_DELAY_MS);
+        }
+        return isNew;
+    }
+    /** Sends the acknowledgement now rather than waiting for more traffic. */
+    acknowledge() {
+        this.cancelTimer();
+        this.messagesSinceAcknowledgement = 0;
+        this.bytesSinceAcknowledgement = 0;
+        this.sendAcknowledgement(this.lastAccepted);
+    }
+    dispose() {
+        this.cancelTimer();
+    }
+    cancelTimer() {
+        clearTimeout(this.acknowledgementTimer);
+        this.acknowledgementTimer = undefined;
+    }
+}
+exports.InboundMessageSequence = InboundMessageSequence;
+//# sourceMappingURL=inbound-message-sequence.js.map

package/lib/common/inbound-message-sequence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inbound-message-sequence.js","sourceRoot":"","sources":["../../src/common/inbound-message-sequence.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;AAElF,6EAAqE;AAErE,uFAAuF;AAC1E,QAAA,qBAAqB,GAAG,eAAe,CAAC;AAErD;;;;;;;;;;;;;;;;;GAiBG;AACH;IAUkC,mBAAmB;IATlD,MAAM,CAAU,0BAA0B,GAAG,EAAE,CAAC;IAChD,MAAM,CAAU,uBAAuB,GAAG,EAAE,GAAG,IAAI,CAAC;IACpD,MAAM,CAAU,oBAAoB,GAAG,GAAG,CAAC;IAEjC,YAAY,GAAG,CAAC,CAAC;IACjB,4BAA4B,GAAG,CAAC,CAAC;IACjC,yBAAyB,GAAG,CAAC,CAAC;IAC9B,oBAAoB,CAA4C;IAE1E,YAA+B,mBAA+C;mCAA/C,mBAAmB;IAA+B,CAAC;IAElF;;;;;;;;;;OAUG;IACH,MAAM,CAAC,QAAiB,EAAE,KAAa;QACpC,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;YAChC,OAAO,IAAI,CAAC;QACf,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,KAAK,CAAC,CAAC;QACxC,MAAM,KAAK,GAAG,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC;QAC3C,IAAI,KAAK,EAAE,CAAC;YACT,IAAI,QAAQ,GAAG,IAAI,CAAC,YAAY,GAAG,CAAC,EAAE,CAAC;gBACpC,MAAM,OAAO,GAAG,QAAQ,GAAG,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC;gBACjD,OAAO,CAAC,IAAI,CACT,GAAG,kDAAqB,SAAS,OAAO,yBAAyB,IAAI,CAAC,YAAY,GAAG,CAAC,OAAO,QAAQ,GAAG,CAAC,IAAI;oBAC1G,iDAAiD,CACtD,CAAC;YACL,CAAC;YACD,IAAI,CAAC,YAAY,GAAG,QAAQ,CAAC;QAChC,CAAC;QACD,IAAI,CAAC,4BAA4B,EAAE,CAAC;QACpC,IAAI,CAAC,yBAAyB,IAAI,KAAK,CAAC;QACxC,IACG,OAAO;YACP,IAAI,CAAC,4BAA4B,IAAI,sBAAsB,CAAC,0BAA0B;YACtF,IAAI,CAAC,yBAAyB,IAAI,sBAAsB,CAAC,uBAAuB,EACjF,CAAC;YACA,IAAI,CAAC,WAAW,EAAE,CAAC;QACtB,CAAC;aAAM,CAAC;YACL,IAAI,CAAC,oBAAoB,KAAK,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,sBAAsB,CAAC,oBAAoB,CAAC,CAAC;QACnH,CAAC;QACD,OAAO,KAAK,CAAC;IAChB,CAAC;IAED,0EAA0E;IAC1E,WAAW;QACR,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,4BAA4B,GAAG,CAAC,CAAC;QACtC,IAAI,CAAC,yBAAyB,GAAG,CAAC,CAAC;QACnC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IAC/C,CAAC;IAED,OAAO;QACJ,IAAI,CAAC,WAAW,EAAE,CAAC;IACtB,CAAC;IAES,WAAW;QAClB,YAAY,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;QACxC,IAAI,CAAC,oBAAoB,GAAG,SAAS,CAAC;IACzC,CAAC;CACH"}

package/lib/common/index.d.ts

@@ -0,0 +1,13 @@
+/********************************************************************************
+ * 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 './framed-socket-write-buffer';
+export * from './inbound-message-sequence';
+export * from './connection-resilience-options';
+export * from './clock';
+//# sourceMappingURL=index.d.ts.map