@openfin/node-adapter 47.100.26 → 47.100.29

package/out/node-adapter.js

@@ -7571,19 +7571,39 @@ let ChannelError$1 = class ChannelError extends Error {
     }
 };
 
-var __classPrivateFieldGet$k = (undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
+/**
+ * Tracks live channel clients by their current endpoint id and routes runtime lifecycle events to them.
+ */
+class ChannelClientStore {
+    // The provider for a channel has gone away: every client on that channel is disconnected.
+    static handleProviderDisconnect(eventPayload) {
+        [...ChannelClientStore.clients.values()].forEach((client) => {
+            if (client.providerIdentity.channelId === eventPayload.channelId) {
+                client[teardown](true, false);
+            }
+        });
+    }
+    // Old providers omit endpoint ids, so a new connection silently replaces the previous client on the channel.
+    static handleEndpointDisconnect(endpointId) {
+        ChannelClientStore.clients.get(endpointId)?.[teardown](false, false);
+    }
+}
+ChannelClientStore.clients = new Map();
+
 var __classPrivateFieldSet$j = (undefined && undefined.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var _ChannelClient_protectedObj, _ChannelClient_strategy, _ChannelClient_close;
-const channelClientsByEndpointId = new Map();
+var __classPrivateFieldGet$k = (undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ChannelClient_currentConnection, _ChannelClient_state, _ChannelClient_wire, _ChannelClient_reestablish, _ChannelClient_unsubscribeBFCache, _ChannelClient_disconnectListener, _ChannelClient_reconnectListener, _ChannelClient_releaseConnection, _ChannelClient_attach, _ChannelClient_sendDisconnectToRuntime, _ChannelClient_reconnect;
+// Key for ChannelClient's internal teardown function. Prevents the need to expose internal functions.
+const teardown = Symbol('teardown');
 /**
  * Instance created to enable use of a channel as a client.  Allows for communication with the
  * {@link ChannelProvider ChannelProvider} by invoking an action on the
@@ -7612,50 +7632,135 @@ class ChannelClient extends ChannelBase {
     /**
      * @internal
      */
-    static closeChannelByEndpointId(id) {
-        const channel = channelClientsByEndpointId.get(id);
-        if (channel) {
-            __classPrivateFieldGet$k(channel, _ChannelClient_close, "f").call(channel);
-        }
+    constructor(config) {
+        super();
+        _ChannelClient_currentConnection.set(this, void 0);
+        _ChannelClient_state.set(this, { status: 'connected' });
+        _ChannelClient_wire.set(this, void 0);
+        _ChannelClient_reestablish.set(this, void 0);
+        _ChannelClient_unsubscribeBFCache.set(this, void 0);
+        _ChannelClient_disconnectListener.set(this, void 0);
+        _ChannelClient_reconnectListener.set(this, void 0);
+        // needs to be bound;
+        this.processAction = (action, payload, senderIdentity) => super.processAction(action, payload, senderIdentity);
+        _ChannelClient_releaseConnection.set(this, async (connection, notifyRuntime) => {
+            connection.strategy.close().catch(() => undefined);
+            if (notifyRuntime) {
+                await __classPrivateFieldGet$k(this, _ChannelClient_sendDisconnectToRuntime, "f").call(this, connection);
+            }
+        });
+        _ChannelClient_attach.set(this, (instance) => {
+            ChannelClientStore.clients.set(instance.routingInfo.endpointId, this);
+            instance.strategy.receive(this.processAction);
+            instance.strategy.onEndpointDisconnect(instance.routingInfo.channelId, () => {
+                // Only a drop of the live endpoint disconnects. During a self-heal the endpoint is already being replaced
+                // and the handshake decides the outcome; after it, closing the replaced strategy (RTC/combined fire this on
+                // close) must not tear down the client now live on a fresh endpoint.
+                if (__classPrivateFieldGet$k(this, _ChannelClient_currentConnection, "f") === instance && __classPrivateFieldGet$k(this, _ChannelClient_state, "f").status === 'connected') {
+                    this[teardown](true).catch((error) => {
+                        // eslint-disable-next-line no-console
+                        console.warn(`Failed to notify the runtime that channel '${instance.routingInfo.channelName}' endpoint ${instance.routingInfo.endpointId} disconnected.`, error);
+                    });
+                }
+            });
+        });
+        _ChannelClient_sendDisconnectToRuntime.set(this, async ({ routingInfo }) => {
+            const { channelName, uuid, name, endpointId } = routingInfo;
+            await __classPrivateFieldGet$k(this, _ChannelClient_wire, "f").sendAction('disconnect-from-channel', { channelName, uuid, name, endpointId });
+        });
+        // Re-handshakes (new endpointId) and swaps in the fresh endpoint. Client-side registrations and middleware live
+        // on `this` (ChannelBase), so they carry over. Overlapping BF-Cache restores share one in-flight handshake.
+        _ChannelClient_reconnect.set(this, async () => {
+            if (__classPrivateFieldGet$k(this, _ChannelClient_state, "f").status === 'connected') {
+                const performReconnect = async () => {
+                    let next;
+                    try {
+                        next = await __classPrivateFieldGet$k(this, _ChannelClient_reestablish, "f").call(this);
+                    }
+                    catch (error) {
+                        // No automatic retry: recovery is up to the onDisconnection handler.
+                        // eslint-disable-next-line no-console
+                        console.warn(`Channel '${__classPrivateFieldGet$k(this, _ChannelClient_currentConnection, "f").routingInfo.channelName}' failed to self-heal after BF-Cache restoration; disconnecting.`, error);
+                        await this[teardown](true).catch((disconnectError) => {
+                            // eslint-disable-next-line no-console
+                            console.warn(`Failed to notify the runtime that channel '${__classPrivateFieldGet$k(this, _ChannelClient_currentConnection, "f").routingInfo.channelName}' disconnected.`, disconnectError);
+                        });
+                        return;
+                    }
+                    // A disconnect() or provider disconnect may have landed while the handshake was in flight; if so,
+                    // tear down the freshly established endpoint instead of resurrecting a closed client.
+                    if (__classPrivateFieldGet$k(this, _ChannelClient_state, "f").status !== 'reconnecting') {
+                        __classPrivateFieldGet$k(this, _ChannelClient_releaseConnection, "f").call(this, next, true).catch(() => undefined);
+                        return;
+                    }
+                    const previous = __classPrivateFieldGet$k(this, _ChannelClient_currentConnection, "f");
+                    __classPrivateFieldSet$j(this, _ChannelClient_currentConnection, next, "f");
+                    __classPrivateFieldGet$k(this, _ChannelClient_attach, "f").call(this, next);
+                    __classPrivateFieldSet$j(this, _ChannelClient_state, { status: 'connected' }, "f");
+                    // A throwing listener must not abort the reconnect.
+                    try {
+                        __classPrivateFieldGet$k(this, _ChannelClient_reconnectListener, "f")?.call(this, {
+                            providerIdentity: this.providerIdentity,
+                            previousEndpointId: previous.routingInfo.endpointId,
+                            endpointId: next.routingInfo.endpointId
+                        });
+                    }
+                    catch (error) {
+                        // eslint-disable-next-line no-console
+                        console.warn(`An unexpected error occurred in a Channel Client Reconnection handler for channel ${next.routingInfo.channelName}`, error);
+                    }
+                    // The old endpoint is typically already gone (navigation); closing is best-effort cleanup.
+                    __classPrivateFieldGet$k(this, _ChannelClient_releaseConnection, "f").call(this, previous, false).catch(() => undefined);
+                };
+                // The endpoint is being replaced: against old providers the handshake supersedes it by id, which must
+                // not close the reconnecting client.
+                ChannelClientStore.clients.delete(__classPrivateFieldGet$k(this, _ChannelClient_currentConnection, "f").routingInfo.endpointId);
+                const reconnectPromise = performReconnect();
+                __classPrivateFieldSet$j(this, _ChannelClient_state, { status: 'reconnecting', waitForReconnection: () => reconnectPromise }, "f");
+            }
+            if (__classPrivateFieldGet$k(this, _ChannelClient_state, "f").status === 'reconnecting') {
+                await __classPrivateFieldGet$k(this, _ChannelClient_state, "f").waitForReconnection();
+            }
+        });
+        __classPrivateFieldSet$j(this, _ChannelClient_currentConnection, config.initialConnection, "f");
+        __classPrivateFieldSet$j(this, _ChannelClient_wire, config.wire, "f");
+        __classPrivateFieldSet$j(this, _ChannelClient_reestablish, config.reestablish, "f");
+        __classPrivateFieldSet$j(this, _ChannelClient_unsubscribeBFCache, __classPrivateFieldGet$k(this, _ChannelClient_wire, "f").environment.onBFCacheRestore(__classPrivateFieldGet$k(this, _ChannelClient_reconnect, "f")), "f");
+        __classPrivateFieldGet$k(this, _ChannelClient_attach, "f").call(this, config.initialConnection);
     }
     /**
      * @internal
-     * closes the corresponding channel and invokes the disconnect listener if an event payload is passed.
-     */
-    static handleProviderDisconnect(eventPayload) {
-        for (const channelClient of channelClientsByEndpointId.values()) {
-            if (channelClient.providerIdentity.channelId === eventPayload.channelId) {
-                channelClient.disconnectListener(eventPayload);
-                __classPrivateFieldGet$k(channelClient, _ChannelClient_close, "f").call(channelClient);
+     * Closes the client. `notifyRuntime` sends `disconnect-from-channel` for the current endpoint; `emitEvent` then
+     * fires the onDisconnection listener, even if notifying the runtime failed.
+     */
+    async [(_ChannelClient_currentConnection = new WeakMap(), _ChannelClient_state = new WeakMap(), _ChannelClient_wire = new WeakMap(), _ChannelClient_reestablish = new WeakMap(), _ChannelClient_unsubscribeBFCache = new WeakMap(), _ChannelClient_disconnectListener = new WeakMap(), _ChannelClient_reconnectListener = new WeakMap(), _ChannelClient_releaseConnection = new WeakMap(), _ChannelClient_attach = new WeakMap(), _ChannelClient_sendDisconnectToRuntime = new WeakMap(), _ChannelClient_reconnect = new WeakMap(), teardown)](emitEvent = false, notifyRuntime = true) {
+        if (__classPrivateFieldGet$k(this, _ChannelClient_state, "f").status !== 'closed') {
+            const identity = this.providerIdentity;
+            const connection = __classPrivateFieldGet$k(this, _ChannelClient_currentConnection, "f");
+            __classPrivateFieldSet$j(this, _ChannelClient_state, { status: 'closed' }, "f");
+            __classPrivateFieldGet$k(this, _ChannelClient_unsubscribeBFCache, "f").call(this);
+            ChannelClientStore.clients.delete(connection.routingInfo.endpointId);
+            try {
+                await __classPrivateFieldGet$k(this, _ChannelClient_releaseConnection, "f").call(this, connection, notifyRuntime);
+            }
+            finally {
+                if (emitEvent) {
+                    try {
+                        __classPrivateFieldGet$k(this, _ChannelClient_disconnectListener, "f")?.call(this, identity);
+                    }
+                    catch (error) {
+                        // eslint-disable-next-line no-console
+                        console.warn(`An unexpected error occurred in a Channel Client Disconnection handler for channel ${identity.channelName}`, error);
+                    }
+                }
             }
         }
     }
-    /**
-     * @internal
-     */
-    constructor(routingInfo, close, strategy) {
-        super();
-        _ChannelClient_protectedObj.set(this, void 0);
-        _ChannelClient_strategy.set(this, void 0);
-        // needs to be bound;
-        this.processAction = (action, payload, senderIdentity) => super.processAction(action, payload, senderIdentity);
-        _ChannelClient_close.set(this, () => {
-            channelClientsByEndpointId.delete(this.endpointId);
-            __classPrivateFieldGet$k(this, _ChannelClient_strategy, "f").close();
-        });
-        __classPrivateFieldSet$j(this, _ChannelClient_protectedObj, new ProtectedItems(routingInfo, close), "f");
-        this.disconnectListener = () => undefined;
-        this.endpointId = routingInfo.endpointId;
-        __classPrivateFieldSet$j(this, _ChannelClient_strategy, strategy, "f");
-        channelClientsByEndpointId.set(this.endpointId, this);
-        strategy.receive(this.processAction);
-    }
     /**
      * a read-only provider identity
      */
     get providerIdentity() {
-        const protectedObj = __classPrivateFieldGet$k(this, _ChannelClient_protectedObj, "f");
-        return protectedObj.providerIdentity;
+        return { ...__classPrivateFieldGet$k(this, _ChannelClient_currentConnection, "f").routingInfo };
     }
     /**
      * Dispatch the given action to the channel provider. Returns a promise that resolves with the response from
@@ -7683,17 +7788,22 @@ class ChannelClient extends ChannelBase {
      * ```
      */
     async dispatch(action, payload) {
-        if (__classPrivateFieldGet$k(this, _ChannelClient_strategy, "f").isEndpointConnected(this.providerIdentity.channelId)) {
-            const callSites = RuntimeError.getCallSite();
-            return __classPrivateFieldGet$k(this, _ChannelClient_strategy, "f").send(this.providerIdentity.channelId, action, payload).catch((e) => {
-                throw new ChannelError$1(e, action, payload, callSites);
-            });
+        // App pageshow handlers run alongside the bfcache restore; sending now would go out on the frozen endpoint.
+        if (__classPrivateFieldGet$k(this, _ChannelClient_state, "f").status === 'reconnecting') {
+            await __classPrivateFieldGet$k(this, _ChannelClient_state, "f").waitForReconnection();
         }
-        throw new Error('The client you are trying to dispatch from is disconnected from the target provider.');
+        const connection = __classPrivateFieldGet$k(this, _ChannelClient_currentConnection, "f");
+        if (!connection.strategy.isEndpointConnected(this.providerIdentity.channelId)) {
+            throw new Error('The client you are trying to dispatch from is disconnected from the target provider.');
+        }
+        const callSites = RuntimeError.getCallSite();
+        return connection.strategy.send(this.providerIdentity.channelId, action, payload).catch((e) => {
+            throw new ChannelError$1(e, action, payload, callSites);
+        });
     }
     /**
-     * Register a listener that is called on provider disconnection. It is passed the disconnection event of the
-     * disconnecting provider.
+     * Register a listener that is called when this client loses its channel: the provider disconnects, the
+     * endpoint drops, or a self-heal fails. It is passed the provider identity.
      *
      * @param listener
      *
@@ -7710,17 +7820,46 @@ class ChannelClient extends ChannelBase {
      * ```
      */
     onDisconnection(listener) {
-        this.disconnectListener = (payload) => {
-            try {
-                listener(payload);
-            }
-            catch (err) {
-                throw new Error(`Error while calling the onDisconnection callback: ${err.message}`);
-            }
-            finally {
-                this.disconnectListener = () => undefined;
-            }
-        };
+        __classPrivateFieldSet$j(this, _ChannelClient_disconnectListener, listener, "f");
+    }
+    /**
+     * Register a listener that is called each time this client transparently self-heals its connection to the
+     * provider.
+     *
+     * @remarks
+     * A channel client's underlying endpoint is torn down while its document sits in the back/forward cache
+     * (bfcache). If the back/forward cache is supported and the document is restored from it, the client
+     * automatically re-handshakes with the provider and swaps in a fresh endpoint; all of this client's
+     * `register`/middleware handlers are preserved, so no re-registration is required.
+     *
+     * A restore is not guaranteed: Chromium may evict a cached document at any time, in which case navigating
+     * back reloads the page and a new client must connect.
+     *
+     * This listener fires once per successful reconnect, after the new endpoint is live, and can fire multiple
+     * times over the client's lifetime. It is triggered when the document is restored from the back/forward
+     * cache (a bfcache `pageshow`). It does not fire for the initial connection, nor after
+     * {@link ChannelClient#disconnect disconnect}. {@link ChannelClient#onDisconnection onDisconnection} fires
+     * when the provider or endpoint goes away.
+     *
+     * The info provides the reconnected {@link OpenFin.ProviderIdentity provider identity} along with
+     * the previous and new endpoint ids.
+     *
+     * @param listener
+     *
+     * @example
+     *
+     * ```js
+     * (async () => {
+     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');
+     *
+     *     client.onReconnection(({ providerIdentity, previousEndpointId, endpointId }) => {
+     *         console.log(`Reconnected to ${providerIdentity.channelName}: ${previousEndpointId} -> ${endpointId}`);
+     *     });
+     * })();
+     * ```
+     */
+    onReconnection(listener) {
+        __classPrivateFieldSet$j(this, _ChannelClient_reconnectListener, listener, "f");
     }
     /**
      * Disconnects the client from the channel.
@@ -7736,28 +7875,16 @@ class ChannelClient extends ChannelBase {
      * ```
      */
     async disconnect() {
-        await this.sendDisconnectAction();
-        __classPrivateFieldGet$k(this, _ChannelClient_close, "f").call(this);
-    }
-    async sendDisconnectAction() {
-        const protectedObj = __classPrivateFieldGet$k(this, _ChannelClient_protectedObj, "f");
-        await protectedObj.close();
+        await this[teardown](false);
     }
     /**
      * @internal
-     * Writing this as a static to keep code together, but in environments with a wire, this will be DI'd into the protectedObject class as close.
+     * Notify the runtime that the current endpoint has disconnected.
      */
-    static async wireClose(wire, providerIdentity, endpointId) {
-        const { channelName, uuid, name } = providerIdentity;
-        await wire.sendAction('disconnect-from-channel', {
-            channelName,
-            uuid,
-            name,
-            endpointId
-        });
+    async sendDisconnectAction() {
+        await this.disconnect();
     }
 }
-_ChannelClient_protectedObj = new WeakMap(), _ChannelClient_strategy = new WeakMap(), _ChannelClient_close = new WeakMap();
 
 function exhaustiveCheck(value, allowed) {
     throw new Error(`Unsupported value: ${value}${allowed ? `\n Supported values are: ${allowed.join('')}` : ''}`);
@@ -8681,7 +8808,7 @@ class MessageReceiver extends Base {
         const endpointIdFromPreviousConnection = this.latestEndpointIdByChannelId.get(channelId);
         if (endpointIdFromPreviousConnection) {
             // Not convinced by this way of doing things, but pushing up for now.
-            ChannelClient.closeChannelByEndpointId(endpointIdFromPreviousConnection);
+            ChannelClientStore.handleEndpointDisconnect(endpointIdFromPreviousConnection);
             // eslint-disable-next-line no-console
             console.warn('You have created a second connection to an older provider. First connection has been removed from the clientMap');
             // eslint-disable-next-line no-console
@@ -9056,7 +9183,7 @@ var __classPrivateFieldGet$e = (undefined && undefined.__classPrivateFieldGet) |
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Channel_connectionManager, _Channel_internalEmitter, _Channel_readyForProvider, _Channel_readyToConnect;
+var _Channel_connectionManager, _Channel_internalEmitter, _Channel_readyForProvider, _Channel_readyToConnect, _Channel_establishConnection;
 function retryDelay(count) {
     const interval = 500; // base delay
     const steps = 10; // How many retries to do before incrementing the delay
@@ -9106,13 +9233,33 @@ class Channel extends EmitterBase {
             await Promise.all([
                 __classPrivateFieldGet$e(this, _Channel_readyForProvider, "f").getValue(),
                 this.on('disconnected', (eventPayload) => {
-                    ChannelClient.handleProviderDisconnect(eventPayload);
+                    ChannelClientStore.handleProviderDisconnect(eventPayload);
                 }),
                 this.on('connected', (...args) => {
                     __classPrivateFieldGet$e(this, _Channel_internalEmitter, "f").emit('connected', ...args);
                 })
             ]).catch(() => new Error('error setting up channel connection listeners'));
         }));
+        // Runs the client handshake (offer -> connect -> strategy). Re-runnable so a ChannelClient can reconnect
+        // with a fresh endpointId; offers are single-use (esp. RTC) so a new offer is created each call.
+        _Channel_establishConnection.set(this, async (channelName, opts, connectionUrl) => {
+            const { offer, rtc: rtcPacket } = await __classPrivateFieldGet$e(this, _Channel_connectionManager, "f").createClientOffer(opts);
+            // getInfo() can hang during a bfcache restore, so reconnects reuse the URL resolved on the first connect;
+            // it cannot change within a client's lifetime.
+            let targetUrl = connectionUrl;
+            if (targetUrl === undefined && (this.fin.me.isFrame || this.fin.me.isView || this.fin.me.isWindow)) {
+                targetUrl = (await this.fin.me.getInfo()).url;
+            }
+            const connectPayload = {
+                channelName,
+                ...opts,
+                offer,
+                connectionUrl: targetUrl
+            };
+            const routingInfo = await this.safeConnect(channelName, opts.wait, connectPayload);
+            const strategy = await __classPrivateFieldGet$e(this, _Channel_connectionManager, "f").createClientStrategy(rtcPacket, routingInfo);
+            return { routingInfo, strategy, connectionUrl: targetUrl };
+        });
         __classPrivateFieldSet$d(this, _Channel_connectionManager, new ConnectionManager(wire), "f");
     }
     /**
@@ -9284,35 +9431,14 @@ class Channel extends EmitterBase {
             throw new Error('Please provide a channelName string to connect to a channel.');
         }
         const opts = { wait: true, ...this.wire.environment.getDefaultChannelOptions().connect, ...options };
-        const { offer, rtc: rtcPacket } = await __classPrivateFieldGet$e(this, _Channel_connectionManager, "f").createClientOffer(opts);
-        let connectionUrl;
-        if (this.fin.me.isFrame || this.fin.me.isView || this.fin.me.isWindow) {
-            connectionUrl = (await this.fin.me.getInfo()).url;
-        }
-        const connectPayload = {
-            channelName,
-            ...opts,
-            offer,
-            connectionUrl
-        };
-        const routingInfo = await this.safeConnect(channelName, opts.wait, connectPayload);
-        const strategy = await __classPrivateFieldGet$e(this, _Channel_connectionManager, "f").createClientStrategy(rtcPacket, routingInfo);
-        const channel = new ChannelClient(routingInfo, () => ChannelClient.wireClose(this.wire, routingInfo, routingInfo.endpointId), strategy);
-        // It is the client's responsibility to handle endpoint disconnection to the provider.
-        // If the endpoint dies, the client will force a disconnection through the core.
-        // The provider does not care about endpoint disconnection.
-        strategy.onEndpointDisconnect(routingInfo.channelId, async () => {
-            try {
-                await channel.sendDisconnectAction();
-            }
-            catch (error) {
-                console.warn(`Something went wrong during disconnect for client with uuid: ${routingInfo.uuid} / name: ${routingInfo.name} / endpointId: ${routingInfo.endpointId}.`);
-            }
-            finally {
-                ChannelClient.handleProviderDisconnect(routingInfo);
-            }
+        const initialConnection = await __classPrivateFieldGet$e(this, _Channel_establishConnection, "f").call(this, channelName, opts);
+        // Never wait on a self-heal: a provider missing at restore has gone away, which is a disconnection. A provider
+        // created later under the same name is a new instance without this client's provider-side state.
+        return new ChannelClient({
+            initialConnection,
+            wire: this.wire,
+            reestablish: () => __classPrivateFieldGet$e(this, _Channel_establishConnection, "f").call(this, channelName, { ...opts, wait: false }, initialConnection.connectionUrl)
         });
-        return channel;
     }
     /**
      * Create a new channel.
@@ -9369,7 +9495,7 @@ class Channel extends EmitterBase {
         return __classPrivateFieldGet$e(this, _Channel_connectionManager, "f").createProvider(options, providerIdentity);
     }
 }
-_Channel_connectionManager = new WeakMap(), _Channel_internalEmitter = new WeakMap(), _Channel_readyForProvider = new WeakMap(), _Channel_readyToConnect = new WeakMap();
+_Channel_connectionManager = new WeakMap(), _Channel_internalEmitter = new WeakMap(), _Channel_readyForProvider = new WeakMap(), _Channel_readyToConnect = new WeakMap(), _Channel_establishConnection = new WeakMap();
 
 /**
  * Entry point for the OpenFin `InterApplicationBus` API (`fin.InterApplicationBus`).
@@ -9403,11 +9529,27 @@ class InterApplicationBus extends Base {
             subscriberRemoved: 'subscriber-removed'
         };
         this.refCounter = new RefCounter();
+        /**
+         * One entry per subscription the runtime knows about, keyed by the same subscription key the
+         * emitter and the ref counter use. Listeners sharing a key share a single entry.
+         */
+        this.activeSubscriptions = new Map();
         this.Channel = new Channel(wire);
         this.emitter = new events.EventEmitter();
         wire.registerMessageHandler(this.onmessage.bind(this));
         this.on = this.emitter.on.bind(this.emitter);
         this.removeAllListeners = this.emitter.removeAllListeners.bind(this.emitter);
+        wire.environment.onBFCacheRestore(() => {
+            Array.from(this.activeSubscriptions.values()).forEach(async (subscription) => {
+                try {
+                    await this.wire.sendAction('subscribe', subscription);
+                }
+                catch (error) {
+                    // eslint-disable-next-line no-console
+                    console.error('Failed to restore InterApplicationBus subscription after bfcache restore', error);
+                }
+            });
+        });
     }
     /**
      * Publishes a message to all applications running on OpenFin Runtime that
@@ -9459,30 +9601,39 @@ class InterApplicationBus extends Base {
      * Subscribes to messages from the specified application on the specified topic.
      * @param source This object is described in the Identity in the typedef
      * @param topic The topic on which the message is sent
-     * @param listener A function that is called when a message has
-     * been received. It is passed the message, uuid and name of the sending application.
+     * @param listener A function that is called when a message has been received. It is passed
+     * two arguments: the message, and the identity (`{ uuid, name }`) of the sender.
      * The message can be either a primitive data type (string, number, or boolean) or
      * composite data type (object, array) that is composed of other primitive or composite
      * data types
      *
+     * @remarks This differs from the legacy `fin.desktop.InterApplicationBus.subscribe` API,
+     * which passes `(message, uuid, name)` as separate arguments.
+     *
      * @example
      * ```js
      * // subscribe to a specified application
-     * fin.InterApplicationBus.subscribe(fin.me, 'topic', sub_msg => console.log(sub_msg)).then(() => console.log('Subscribed to the specified application')).catch(err => console.log(err));
+     * fin.InterApplicationBus.subscribe(fin.me, 'topic', (message, sender) => {
+     *     console.log(`Received from ${sender.uuid}/${sender.name}:`, message);
+     * }).then(() => console.log('Subscribed to the specified application')).catch(err => console.log(err));
      *
      * // subscribe to wildcard
      * fin.InterApplicationBus.subscribe({ uuid: '*' }, 'topic', sub_msg => console.log(sub_msg)).then(() => console.log('Subscribed to *')).catch(err => console.log(err));
      * ```
      */
     subscribe(source, topic, listener) {
-        const subKey = this.createSubscriptionKey(source.uuid, source.name || '*', topic);
+        const sourceWindowName = source.name || '*';
+        const subKey = this.createSubscriptionKey(source.uuid, sourceWindowName, topic);
+        const subscription = {
+            sourceUuid: source.uuid,
+            sourceWindowName,
+            topic,
+            destinationWindowName: this.me.name
+        };
         const sendSubscription = async () => {
-            await this.wire.sendAction('subscribe', {
-                sourceUuid: source.uuid,
-                sourceWindowName: source.name || '*',
-                topic,
-                destinationWindowName: this.me.name
-            });
+            // Journaled before the await so a concurrent unsubscribe can find it.
+            this.activeSubscriptions.set(subKey, subscription);
+            await this.wire.sendAction('subscribe', subscription);
         };
         const alreadySubscribed = () => {
             return Promise.resolve();
@@ -9518,6 +9669,9 @@ class InterApplicationBus extends Base {
         const sourceWindowName = source.name || '*';
         const subKey = this.createSubscriptionKey(source.uuid, sourceWindowName, topic);
         const sendUnsubscription = async () => {
+            // Dropped before the await so that a restoration landing while this unsubscribe is
+            // still in flight does not replay the subscription being torn down.
+            this.activeSubscriptions.delete(subKey);
             await this.wire.sendAction('unsubscribe', {
                 sourceUuid: source.uuid,
                 sourceWindowName,
@@ -9526,6 +9680,9 @@ class InterApplicationBus extends Base {
             });
         };
         const dontSendUnsubscription = () => {
+            // TODO(CORE-2749): never settles - the executor evaluates `r` instead of calling it,
+            // so awaiting a non-final unsubscribe hangs the caller. Should be `Promise.resolve()`,
+            // but that changes long-standing behavior, so it is tracked separately from CORE-2740.
             return new Promise((r) => r).then(() => undefined);
         };
         this.emitter.removeListener(subKey, listener);
@@ -17594,7 +17751,7 @@ class NodeEnvironment extends BaseEnvironment {
         };
     }
     getAdapterVersionSync() {
-        return "47.100.26";
+        return "47.100.29";
     }
     observeBounds(element, onChange) {
         throw new Error('Method not implemented.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfin/node-adapter",
-  "version": "47.100.26",
+  "version": "47.100.29",
   "description": "See README.md",
   "main": "out/node-adapter.js",
   "types": "out/node-adapter.d.ts",
@@ -20,7 +20,7 @@
     "es-toolkit": "^1.39.3",
     "ws": "^7.5.11",
     "tslib": "2.8.1",
-    "@openfin/core": "47.100.26"
+    "@openfin/core": "47.100.29"
   },
   "scripts": {
     "prebuild": "rimraf ./out",