fix(sdk): resend outstanding methods on SDK reconnect, skip _reconnectStopper

The full fire('reset') was firing accounts-base's _reconnectStopper, which
retries login with the captured `result.token` from the original
callLoginMethod scope. After force-logout, that token is the stale one
the server just invalidated. The retry runs on a wait:true block that
queues AHEAD of the test's own loginByUserState; the stopper's
userCallback then calls makeClientLoggedOut, which clobbers the
credentials the test just injected, and the test's queued login never
sends a frame.

With the ddp-streamer ws.close() change, useForceLogout now reliably
fires (the notify-user/<uid>/force_logout stream message arrives before
the socket closes), so we don't need accounts-base's reconnect-time
relogin retry at all. We still need to resend in-flight methods so that
tests like message-actions / report-message / e2ee-encryption-decryption
don't wedge.

Mirror onReset's _handleOutstandingMethodsOnReset +
_sendOutstandingMethodBlocksMessages + _resendSubscriptions directly,
skipping _callOnReconnectAndSendAppropriateOutstandingMethods (which is
where _reconnectStopper would fire).

Also drop the diagnostic logging now that we have a fix in mind.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: ggazzo

apps/meteor/client/meteor/overrides/stubMeteorStream.ts

@@ -1,4 +1,3 @@
-import { Accounts } from 'meteor/accounts-base';
 import { DDPCommon } from 'meteor/ddp-common';
 import { Meteor } from 'meteor/meteor';
 import { Tracker } from 'meteor/tracker';
@@ -214,67 +213,51 @@ queueMicrotask(() => {
 });
 
 // When the underlying SDK socket reconnects (e.g. after a server-side
-// ws.terminate from force-logout in microservices), Meteor's connection sees
-// no transport event because the stub keeps reporting 'connected'. As a
-// result, Meteor's normal reconnect machinery — `_streamHandlers.onReset` →
-// `_callOnReconnectAndSendAppropriateOutstandingMethods` → DDP.onReconnect
-// callbacks → the per-call `_reconnectStopper` that retries login with the
-// latest stored token (and calls `makeClientLoggedOut` on failure) — never
-// fires. The user is left with stale credentials.
+// ws.terminate / ws.close from force-logout in microservices), Meteor's
+// connection sees no transport event because the stub keeps reporting
+// 'connected'. Methods that were sent but not yet completed on the prior
+// SDK session are stranded with sentMessage=true, so any test that fires a
+// method right when the socket churns wedges (message-actions /
+// report-message / e2ee-encryption-decryption all timed out before this).
 //
-// Fire `reset` on every subsequent SDK 'connected' event so accounts-base's
-// onReconnect callback retries login with whatever's currently in
-// localStorage AND so methods that were sent but not yet completed get
-// resent on the new session (skipping this part wedges tests that fire a
-// method right when the SDK socket churns: message-actions / report-message
-// / e2ee-encryption-decryption all timed out without it). The first connect
-// is handled by the queueMicrotask above; skip it here. The "method result
-// but no methods outstanding" warnings that the resent blocks generate are
-// caught and suppressed by the bridge's async catch in
-// ddpSdkCollectionBridge.
+// Resend the in-flight method blocks on every subsequent SDK 'connected'
+// event. Mirror everything Meteor's `_streamHandlers.onReset` does EXCEPT
+// invoke `DDP._reconnectHook` callbacks: the per-call `_reconnectStopper`
+// that callLoginMethod registers (accounts_client.js:292) retries login
+// with the captured `result.token` from the *original* successful login,
+// which is now the stale token the server just invalidated. That retry
+// runs on a `wait:true` block which queues *ahead of* the test's own
+// loginByUserState login; if it fails (it will), the stopper's userCallback
+// calls `makeClientLoggedOut`, which clobbers the credentials the test
+// just injected — and the test's queued login then never sends a frame
+// because the stopper's wait block drains in a way that confuses the
+// outstanding queue. Force-logout cleanup is now handled by the
+// `useForceLogout` client hook (notify-user/<uid>/force_logout stream
+// message) which arrives reliably since DDPStreamer.ts:62 was switched to
+// ws.close(). The first connect is handled by the queueMicrotask above;
+// skip it here.
 const sdk = getDdpSdk();
 let firstConnectHandled = false;
-let reconnectCount = 0;
 sdk.connection.on('connected', () => {
 	if (!firstConnectHandled) {
 		firstConnectHandled = true;
-		console.warn('[stubMeteorStream] first SDK connected (no reset)');
 		return;
 	}
-	reconnectCount += 1;
-	const storedToken = typeof window !== 'undefined' ? window.localStorage.getItem('Meteor.loginToken') : null;
-	console.warn(`[stubMeteorStream] SDK reconnect #${reconnectCount} — firing reset`, {
-		storedToken: storedToken ? `${storedToken.slice(0, 6)}…` : null,
-		userId: (Meteor.connection as unknown as { _userId?: string | null })._userId ?? null,
-	});
 	try {
-		fire('reset');
+		const c = conn as unknown as {
+			_outstandingMethodBlocks: Array<{ wait: boolean; methods: unknown[] }>;
+			_sendOutstandingMethodBlocksMessages(blocks: Array<{ wait: boolean; methods: unknown[] }>): void;
+			_streamHandlers: {
+				_handleOutstandingMethodsOnReset?: () => void;
+				_resendSubscriptions?: () => void;
+			};
+		};
+		c._streamHandlers._handleOutstandingMethodsOnReset?.();
+		const oldBlocks = c._outstandingMethodBlocks;
+		c._outstandingMethodBlocks = [];
+		c._sendOutstandingMethodBlocksMessages(oldBlocks);
+		c._streamHandlers._resendSubscriptions?.();
 	} catch (err) {
-		console.warn('[stubMeteorStream] reset on SDK reconnect failed', err);
+		console.warn('[stubMeteorStream] custom reset on SDK reconnect failed', err);
 	}
 });
-
-// Diagnostic: wrap _pollStoredLoginToken to log every call so we can see
-// whether the test's loginByUserState actually triggers a login on the
-// failing :87 cycle, or whether it short-circuits because the cached
-// _lastLoginTokenWhenPolled still matches what's in storage.
-{
-	const acc = Accounts as unknown as {
-		_pollStoredLoginToken?: () => void;
-		_lastLoginTokenWhenPolled?: string | null;
-		_storedLoginToken?: () => string | null;
-	};
-	const originalPoll = acc._pollStoredLoginToken;
-	if (typeof originalPoll === 'function') {
-		acc._pollStoredLoginToken = function patchedPoll(this: typeof acc): void {
-			const current = acc._storedLoginToken?.() ?? null;
-			const last = acc._lastLoginTokenWhenPolled ?? null;
-			console.warn('[stubMeteorStream] _pollStoredLoginToken', {
-				current: current ? `${current.slice(0, 6)}…` : null,
-				last: last ? `${last.slice(0, 6)}…` : null,
-				willFire: current !== last,
-			});
-			return originalPoll.call(this);
-		};
-	}
-}