A local-first personal finance app
:bug: Fix multi tab handover after creating a budget (#9272)
Michael Clark9b4e304256a4
diff --git a/packages/desktop-client/e2e/fixtures.ts b/packages/desktop-client/e2e/fixtures.tsindex ae358db36e..71c5ddd73d 100644--- a/packages/desktop-client/e2e/fixtures.ts+++ b/packages/desktop-client/e2e/fixtures.ts@@ -13,7 +13,7 @@ import type { Browser, Locator, Page } from '@playwright/test';* using the test-scoped `page` fixture — a `page`-fixture override would* be a no-op.*/-const disableAnimationsInitScript = () => {+export const disableAnimationsInitScript = () => {const css = `*, *::before, *::after {transition-duration: 0s !important;transition-delay: 0s !important;diff --git a/packages/desktop-client/e2e/multitab.test.ts b/packages/desktop-client/e2e/multitab.test.tsnew file mode 100644index 0000000000..de7690f9f5--- /dev/null+++ b/packages/desktop-client/e2e/multitab.test.ts@@ -0,0 +1,189 @@+import type { BrowserContext, Page } from '@playwright/test';++import { disableAnimationsInitScript, expect, test } from './fixtures';+import { BudgetPage } from './page-models/budget-page';+import { ConfigurationPage } from './page-models/configuration-page';+import { Navigation } from './page-models/navigation';++// A user agent without "playwright" in it, so the app uses the SharedWorker+// coordinator (leader tab plus followers) instead of a worker per tab+const CHROME_USER_AGENT =+ 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36';++async function addTransactionAndCheck(page: Page, notes: string) {+ const accountPage = await new Navigation(page).goToAccountPage(+ 'Ally Savings',+ );+ await accountPage.waitFor();+ // Queries are answered once the new leader has restored the budget; wait+ // for the data and a moment of quiet before typing into the table+ await expect(accountPage.transactionTableRow.first()).toBeVisible({+ timeout: 60_000,+ });+ await page.waitForTimeout(1000);+ await accountPage.createSingleTransaction({+ payee: 'Kroger',+ notes,+ debit: '12.34',+ });+ // The demo account has later-dated transactions, so look for the note+ await expect(accountPage.transactionTable.getByText(notes)).toBeVisible();+ return accountPage;+}++// Simulates the user switching away from a tab and back+async function hideAndShow(page: Page) {+ for (const state of ['hidden', 'visible']) {+ await page.evaluate(visibility => {+ Object.defineProperty(document, 'visibilityState', {+ value: visibility,+ configurable: true,+ });+ document.dispatchEvent(new Event('visibilitychange'));+ }, state);+ await page.waitForTimeout(500);+ }+}++function budgetedAmount(page: Page, category: string) {+ return page+ .getByTestId('budget-table')+ .getByTestId('row')+ .filter({ hasText: category })+ .first()+ .getByTestId('budget')+ .nth(0);+}++test.describe('Multiple tabs on one budget', () => {+ let context: BrowserContext;+ let leader: Page;+ let follower: Page;++ test.beforeEach(async ({ browser }) => {+ context = await browser.newContext({ userAgent: CHROME_USER_AGENT });+ await context.addInitScript(disableAnimationsInitScript);+ leader = await context.newPage();+ await leader.goto('/');+ await new ConfigurationPage(leader).createTestFile();++ follower = await context.newPage();+ await follower.goto('/');+ await expect(follower.getByTestId('budget-table')).toBeVisible({+ timeout: 60_000,+ });+ });++ test.afterEach(async () => {+ await context?.close();+ });++ test('the follower takes over when the leader tab closes', async () => {+ await leader.close({ runBeforeUnload: true });++ // The follower becomes the leader, restores the budget and keeps working+ await addTransactionAndCheck(follower, 'after takeover');++ // And its writes are persisted+ await follower.waitForTimeout(2000);+ await follower.reload();+ const accountPage = await new Navigation(follower).goToAccountPage(+ 'Ally Savings',+ );+ await accountPage.waitFor({ timeout: 60_000 });+ await expect(+ accountPage.transactionTable.getByText('after takeover'),+ ).toBeVisible();+ });++ test('closing the budget in the leader hands it to the follower', async () => {+ // The leader releases its storage before its worker is terminated+ await leader.evaluate(() => window.__actionsForMenu.closeBudget());+ // The leader is back on the budget list+ await expect(leader.getByText('Test Budget')).toBeVisible({+ timeout: 30_000,+ });++ await addTransactionAndCheck(follower, 'after handover');+ });+ test('a leader that was hidden keeps its budget after resuming', async () => {+ // Switching tabs hides the leader; on return the bridge reports the+ // budget it was told about, which must match the coordinator's view+ await hideAndShow(leader);++ await new BudgetPage(leader).setBudgetedAmount('Food', '123');+ await expect(budgetedAmount(leader, 'Food')).toHaveText('123.00');+ await expect(budgetedAmount(follower, 'Food')).toHaveText('123.00');+ });+});++test.describe('Refreshing a tab', () => {+ test('a tab opened before the budget was created can refresh afterwards', async ({+ browser,+ }) => {+ const context = await browser.newContext({ userAgent: CHROME_USER_AGENT });+ await context.addInitScript(disableAnimationsInitScript);+ const creator = await context.newPage();+ await creator.goto('/');+ // The second tab opens once the first has booted, as a user would+ await creator+ .getByRole('button', { name: 'Try the demo', exact: true })+ .waitFor({ timeout: 60_000 });+ const other = await context.newPage();+ await other.goto('/');+ await other+ .getByRole('button', { name: 'Try the demo', exact: true })+ .waitFor({ timeout: 60_000 });++ // The budget is created in the first tab, which is then switched away+ // from and back, before the second tab is refreshed+ await creator.bringToFront();+ await new ConfigurationPage(creator).createTestFile();+ await hideAndShow(creator);++ await other.reload();+ await expect(+ other.getByText(/Loading global preferences/).first(),+ ).toBeHidden({+ timeout: 30_000,+ });+ await expect(other.getByTestId('budget-table')).toBeVisible({+ timeout: 60_000,+ });+ await context.close();+ });++ test('a tab that closed the budget can refresh while another tab has it open', async ({+ browser,+ }) => {+ const context = await browser.newContext({ userAgent: CHROME_USER_AGENT });+ await context.addInitScript(disableAnimationsInitScript);+ // The first tab creates the budget and goes back to the file list+ const closer = await context.newPage();+ await closer.goto('/');+ await new ConfigurationPage(closer).createTestFile();+ await closer.evaluate(() => window.__actionsForMenu.closeBudget());+ await closer.getByText('Test Budget').waitFor({ timeout: 30_000 });++ // A second tab opens it, then the first is switched to and refreshed+ const opener = await context.newPage();+ await opener.goto('/');+ await opener.getByText('Test Budget').click({ timeout: 30_000 });+ await expect(opener.getByTestId('budget-table')).toBeVisible({+ timeout: 60_000,+ });+ await closer.bringToFront();+ await hideAndShow(closer);+ await closer.reload();++ await expect(+ closer.getByText(/Loading global preferences/).first(),+ ).toBeHidden({+ timeout: 30_000,+ });+ await expect(closer.getByTestId('budget-table')).toBeVisible({+ timeout: 60_000,+ });+ await context.close();+ });+});diff --git a/packages/loot-core/src/platform/client/browser-preload/worker-bridge.test.ts b/packages/loot-core/src/platform/client/browser-preload/worker-bridge.test.tsnew file mode 100644index 0000000000..238d3cadf3--- /dev/null+++ b/packages/loot-core/src/platform/client/browser-preload/worker-bridge.test.ts@@ -0,0 +1,94 @@+import { afterEach, describe, expect, it, vi } from 'vitest';++import { WorkerBridge } from './worker-bridge';++describe('WorkerBridge takeover', () => {+ class FakeBackendWorker {+ static created: FakeBackendWorker[] = [];+ posted: unknown[] = [];+ onmessage: ((event: MessageEvent) => void) | null = null;+ constructor() {+ FakeBackendWorker.created.push(this);+ }+ postMessage(message: unknown) {+ this.posted.push(message);+ }+ addEventListener() {+ // absurd-sql's main-thread helper listens here; nothing to do+ }+ terminate() {+ // Nothing to release in the fake+ }+ }++ function createBridge() {+ FakeBackendWorker.created = [];+ vi.stubGlobal('Worker', FakeBackendWorker);+ const sharedPort = {+ postMessage: vi.fn(),+ start: vi.fn(),+ addEventListener: vi.fn(),+ };+ const bridge = new WorkerBridge(+ sharedPort as unknown as MessagePort,+ new URL('http://localhost/worker.js'),+ );+ const onSharedMessage = sharedPort.addEventListener.mock.calls[0][1] as (+ event: MessageEvent,+ ) => void;+ const fromCoordinator = (data: unknown) =>+ onSharedMessage({ data } as MessageEvent);+ return { bridge, sharedPort, fromCoordinator };+ }++ afterEach(() => {+ vi.unstubAllGlobals();+ });++ it('holds forwarded requests until the restored budget is open', () => {+ const { fromCoordinator } = createBridge();+ fromCoordinator({+ type: '__become-leader',+ initMsg: { type: 'init' },+ budgetToRestore: 'budget-1',+ pendingMsg: null,+ });+ const worker = FakeBackendWorker.created[0];+ expect(worker.posted).toEqual([{ type: 'init' }]);++ // A follower's request arrives before the backend has even connected+ fromCoordinator({ type: '__to-worker', msg: { id: 'q1', name: 'query' } });+ expect(worker.posted).toHaveLength(1);++ worker.onmessage?.({ data: { type: 'connect' } } as MessageEvent);+ expect(worker.posted[1]).toEqual(+ expect.objectContaining({ id: '__restore-budget', name: 'load-budget' }),+ );+ expect(worker.posted).toHaveLength(2);++ worker.onmessage?.({+ data: { type: 'reply', id: '__restore-budget', result: {} },+ } as MessageEvent);+ expect(worker.posted[2]).toEqual({ id: 'q1', name: 'query' });++ // Later requests go straight through+ fromCoordinator({ type: '__to-worker', msg: { id: 'q2', name: 'query' } });+ expect(worker.posted[3]).toEqual({ id: 'q2', name: 'query' });+ });++ it('forwards requests at once when there is nothing to restore', () => {+ const { fromCoordinator } = createBridge();+ fromCoordinator({+ type: '__become-leader',+ initMsg: { type: 'init' },+ budgetToRestore: null,+ pendingMsg: null,+ });+ const worker = FakeBackendWorker.created[0];+ fromCoordinator({ type: '__to-worker', msg: { id: 'q1', name: 'query' } });+ expect(worker.posted).toEqual([+ { type: 'init' },+ { id: 'q1', name: 'query' },+ ]);+ });+});diff --git a/packages/loot-core/src/platform/client/browser-preload/worker-bridge.ts b/packages/loot-core/src/platform/client/browser-preload/worker-bridge.tsindex a124f55ef8..931e8b0276 100644--- a/packages/loot-core/src/platform/client/browser-preload/worker-bridge.ts+++ b/packages/loot-core/src/platform/client/browser-preload/worker-bridge.ts@@ -4,6 +4,8 @@ import { logger } from '#platform/server/log';type BridgeMessage = { type?: string; [key: string]: unknown };+const RESTORE_REQUEST_ID = '__restore-budget';+/** The Worker-like surface the connection layer interacts with. */export type WorkerLike = {onmessage: ((e: MessageEvent) => void) | null;@@ -32,6 +34,9 @@ export class WorkerBridge {_currentBudgetId: string | null;_wasHidden: boolean;_onVisibilityChange: () => void;+ // Requests forwarded while a new leader is still restoring its budget;+ // they would otherwise run against a backend with no database open+ _heldRequests: unknown[] | null;localBackendWorker: Worker | null;backendWorkerUrl: URL;@@ -43,6 +48,7 @@ export class WorkerBridge {this._isInitialized = false;this._currentBudgetId = null;this._wasHidden = document.visibilityState === 'hidden';+ this._heldRequests = null;this.localBackendWorker = null;this.backendWorkerUrl = backendWorkerUrl;@@ -92,6 +98,7 @@ export class WorkerBridge {}_terminateLocalBackendWorker() {+ this._heldRequests = null;if (this.localBackendWorker) {this.localBackendWorker.terminate();this.localBackendWorker = null;@@ -120,7 +127,9 @@ export class WorkerBridge {// Forward requests from SharedWorker to our local Workerif (msg && msg.type === '__to-worker') {- if (this.localBackendWorker) {+ if (this._heldRequests) {+ this._heldRequests.push(msg.msg);+ } else if (this.localBackendWorker) {this.localBackendWorker.postMessage(msg.msg);}return;@@ -225,6 +234,9 @@ export class WorkerBridge {const localWorker = new Worker(this.backendWorkerUrl);this.localBackendWorker = localWorker;initSQLBackend(localWorker);+ // Followers keep sending requests during a takeover; hold them until+ // the restored budget is open (the restore reply releases them)+ this._heldRequests = budgetToRestore ? [] : null;const sharedPort = this._sharedPort;localWorker.onmessage = workerEvent => {@@ -248,7 +260,7 @@ export class WorkerBridge {const id = budgetToRestore;budgetToRestore = null;localWorker.postMessage({- id: '__restore-budget',+ id: RESTORE_REQUEST_ID,name: 'load-budget',args: { id },catchErrors: true,@@ -257,7 +269,7 @@ export class WorkerBridge {// currentBudgetId gets updated when the reply arrives.sharedPort.postMessage({type: '__track-restore',- requestId: '__restore-budget',+ requestId: RESTORE_REQUEST_ID,budgetId: id,});} else if (pendingMsg) {@@ -266,6 +278,17 @@ export class WorkerBridge {localWorker.postMessage(toSend);}}+ if (+ workerMsg.id === RESTORE_REQUEST_ID &&+ this._heldRequests &&+ this.localBackendWorker === localWorker+ ) {+ const held = this._heldRequests;+ this._heldRequests = null;+ for (const request of held) {+ localWorker.postMessage(request);+ }+ }sharedPort.postMessage({ type: '__from-worker', msg: workerMsg });};diff --git a/packages/loot-core/src/platform/client/browser-server/coordinator.test.ts b/packages/loot-core/src/platform/client/browser-server/coordinator.test.tsindex 3fb910530d..83b50ac030 100644--- a/packages/loot-core/src/platform/client/browser-server/coordinator.test.ts+++ b/packages/loot-core/src/platform/client/browser-server/coordinator.test.ts@@ -864,6 +864,244 @@ describe('SharedWorker coordinator', () => {expect(state.budgetGroups.has('new-budget-123')).toBe(true);expect(state.portToBudget.get(creator)).toBe('new-budget-123');});++ it('re-keys a lobby leader that created a budget when its prefs load', () => {+ const leader = connectTab(coordinator);+ sendInit(leader);+ simulateWorkerConnect(leader);+ leader.postMessage.mockClear();++ // The lobby leader creates the demo budget in its own Worker, so no+ // temp group is created for it+ sendMsg(leader, { id: 'cdb-1', name: 'create-demo-budget' });+ sendMsg(leader, {+ type: '__from-worker',+ msg: { type: 'reply', id: 'cdb-1', result: {} },+ });+ sendMsg(leader, { id: 'lp-1', name: 'load-prefs' });+ sendMsg(leader, {+ type: '__from-worker',+ msg: { type: 'reply', id: 'lp-1', result: { id: '_demo-budget' } },+ });++ const state = coordinator.getState();+ expect(state.budgetGroups.has('__lobby')).toBe(false);+ expect(state.portToBudget.get(leader)).toBe('_demo-budget');++ // A second tab on that budget joins as a follower instead of+ // starting a second Worker on the same database+ const follower = connectTab(coordinator);+ sendInit(follower);+ follower.postMessage.mockClear();+ sendMsg(follower, {+ id: 'lb-2',+ name: 'load-budget',+ args: { id: '_demo-budget' },+ });+ expect(follower.postMessage).toHaveBeenCalledWith(+ expect.objectContaining({+ type: '__role-change',+ role: 'FOLLOWER',+ budgetId: '_demo-budget',+ }),+ );+ });++ it('tells a re-keyed leader its budget so resuming keeps it attached', () => {+ const leader = connectTab(coordinator);+ sendInit(leader);+ simulateWorkerConnect(leader);+ sendMsg(leader, { id: 'cdb-1', name: 'create-demo-budget' });+ sendMsg(leader, {+ type: '__from-worker',+ msg: { type: 'reply', id: 'cdb-1', result: {} },+ });+ leader.postMessage.mockClear();+ sendMsg(leader, { id: 'lp-1', name: 'load-prefs' });+ sendMsg(leader, {+ type: '__from-worker',+ msg: { type: 'reply', id: 'lp-1', result: { id: '_demo-budget' } },+ });+ expect(leader.postMessage).toHaveBeenCalledWith(+ expect.objectContaining({+ type: '__role-change',+ role: 'LEADER',+ budgetId: '_demo-budget',+ }),+ );++ // The tab was hidden and comes back, reporting the budget it was told+ leader.postMessage.mockClear();+ sendMsg(leader, { type: '__resume-tab', budgetId: '_demo-budget' });+ expect(leader.postMessage).not.toHaveBeenCalledWith(+ expect.objectContaining({ type: '__role-change', role: 'UNASSIGNED' }),+ );+ const state = coordinator.getState();+ expect(state.budgetGroups.get('_demo-budget').leaderPort).toBe(leader);+ expect(state.portToBudget.get(leader)).toBe('_demo-budget');+ });++ it('keeps a leader that resumes without a budget id and re-announces its role', () => {+ const leader = setupBudgetGroup(coordinator, 'budget-1');+ leader.postMessage.mockClear();++ sendMsg(leader, { type: '__resume-tab', budgetId: null });++ expect(leader.postMessage).toHaveBeenCalledWith(+ expect.objectContaining({+ type: '__role-change',+ role: 'LEADER',+ budgetId: 'budget-1',+ }),+ );+ expect(leader.postMessage).not.toHaveBeenCalledWith(+ expect.objectContaining({ role: 'UNASSIGNED' }),+ );+ const state = coordinator.getState();+ expect(state.budgetGroups.get('budget-1').leaderPort).toBe(leader);+ expect(state.portToBudget.get(leader)).toBe('budget-1');+ expect(state.unassignedPorts.has(leader)).toBe(false);+ });++ it('keeps a follower that resumes with a stale budget id', () => {+ setupBudgetGroup(coordinator, 'budget-1');+ const follower = connectTab(coordinator);+ sendInit(follower);+ sendMsg(follower, {+ id: 'lb-2',+ name: 'load-budget',+ args: { id: 'budget-1' },+ });+ follower.postMessage.mockClear();++ sendMsg(follower, { type: '__resume-tab', budgetId: 'budget-old' });++ expect(follower.postMessage).toHaveBeenCalledWith(+ expect.objectContaining({+ type: '__role-change',+ role: 'FOLLOWER',+ budgetId: 'budget-1',+ }),+ );+ expect(coordinator.getState().budgetGroups.has('budget-old')).toBe(false);+ });++ it('answers a refreshed tab after the leader resumed without its budget id', () => {+ // The creating tab's bridge may lag behind the coordinator (an older+ // build never learned the budget); the coordinator must not strand it+ const leader = connectTab(coordinator);+ sendInit(leader);+ simulateWorkerConnect(leader);+ sendMsg(leader, { id: 'cdb-1', name: 'create-demo-budget' });+ sendMsg(leader, {+ type: '__from-worker',+ msg: { type: 'reply', id: 'cdb-1', result: {} },+ });+ sendMsg(leader, { id: 'lp-1', name: 'load-prefs' });+ sendMsg(leader, {+ type: '__from-worker',+ msg: { type: 'reply', id: 'lp-1', result: { id: '_demo-budget' } },+ });+ sendMsg(leader, { type: '__resume-tab', budgetId: null });++ // Another tab is refreshed: its first request must round-trip+ const refreshed = connectTab(coordinator);+ sendInit(refreshed);+ refreshed.postMessage.mockClear();+ sendMsg(refreshed, { id: 'gp-1', name: 'load-global-prefs' });+ expect(leader.postMessage).toHaveBeenCalledWith(+ expect.objectContaining({+ type: '__to-worker',+ msg: expect.objectContaining({ id: 'gp-1' }),+ }),+ );+ sendMsg(leader, {+ type: '__from-worker',+ msg: { type: 'reply', id: 'gp-1', result: {} },+ });+ expect(refreshed.postMessage).toHaveBeenCalledWith(+ expect.objectContaining({ type: 'reply', id: 'gp-1' }),+ );+ });++ it('does not strand the lobby when its leader resumes claiming another budget', () => {+ // Tab 2 opened first and leads the lobby; tab 1 opens a budget and+ // leads it; tab 2 then resumes reporting that budget, is refreshed,+ // and the fresh tab's first request must be answered+ const lobbyLeader = connectTab(coordinator);+ sendInit(lobbyLeader);+ simulateWorkerConnect(lobbyLeader);+ const opener = connectTab(coordinator);+ sendInit(opener);+ sendMsg(opener, {+ id: 'lb-1',+ name: 'load-budget',+ args: { id: 'budget-1' },+ });+ simulateWorkerConnect(opener);+ sendMsg(opener, {+ type: '__from-worker',+ msg: { type: 'reply', id: 'lb-1', result: {} },+ });++ sendMsg(lobbyLeader, { type: '__resume-tab', budgetId: 'budget-1' });+ sendMsg(lobbyLeader, { type: 'tab-closing' });++ const refreshed = connectTab(coordinator);+ sendInit(refreshed);+ refreshed.postMessage.mockClear();+ sendMsg(refreshed, { id: 'gp-1', name: 'load-global-prefs' });+ expect(opener.postMessage).toHaveBeenCalledWith(+ expect.objectContaining({+ type: '__to-worker',+ msg: expect.objectContaining({ id: 'gp-1' }),+ }),+ );+ sendMsg(opener, {+ type: '__from-worker',+ msg: { type: 'reply', id: 'gp-1', result: {} },+ });+ expect(refreshed.postMessage).toHaveBeenCalledWith(+ expect.objectContaining({ type: 'reply', id: 'gp-1' }),+ );+ // No group may keep a leader that is no longer connected+ const state = coordinator.getState();+ for (const [, group] of state.budgetGroups) {+ expect(state.connectedPorts).toContain(group.leaderPort);+ }+ });++ it('tells a leader it is back in the lobby when it closes the last budget', () => {+ const leader = setupBudgetGroup(coordinator, 'budget-1');+ leader.postMessage.mockClear();+ sendMsg(leader, { id: 'cb-1', name: 'close-budget' });+ sendMsg(leader, {+ type: '__from-worker',+ msg: { type: 'reply', id: 'cb-1', result: 'ok' },+ });+ expect(leader.postMessage).toHaveBeenCalledWith(+ expect.objectContaining({+ type: '__role-change',+ role: 'LEADER',+ budgetId: '__lobby',+ }),+ );+ });++ it('tells a leader it is unassigned when it closes a budget while others run', () => {+ setupBudgetGroup(coordinator, 'budget-1');+ const leader2 = setupBudgetGroup(coordinator, 'budget-2');+ leader2.postMessage.mockClear();+ sendMsg(leader2, { id: 'cb-2', name: 'close-budget' });+ sendMsg(leader2, {+ type: '__from-worker',+ msg: { type: 'reply', id: 'cb-2', result: 'ok' },+ });+ expect(leader2.postMessage).toHaveBeenCalledWith(+ expect.objectContaining({ type: '__role-change', role: 'UNASSIGNED' }),+ );+ expect(coordinator.getState().budgetGroups.has('budget-2')).toBe(false);+ });});// ── Delete budget ───────────────────────────────────────────────────diff --git a/packages/loot-core/src/platform/client/browser-server/coordinator.ts b/packages/loot-core/src/platform/client/browser-server/coordinator.tsindex 3f73219dbb..11b09bcb4f 100644--- a/packages/loot-core/src/platform/client/browser-server/coordinator.ts+++ b/packages/loot-core/src/platform/client/browser-server/coordinator.ts@@ -173,28 +173,37 @@ export function createCoordinator({const wasTracked = isTrackedPort(port);const currentBudget = portToBudget.get(port);const currentGroup = currentBudget ? budgetGroups.get(currentBudget) : null;- const alreadyAttached =- !!normalizedBudgetId &&- currentBudget === normalizedBudgetId &&- !!currentGroup &&- isGroupMember(currentGroup, port);const alreadyUnassigned =!normalizedBudgetId &&!currentBudget &&wasTracked &&unassignedPorts.has(port);- const alreadyOnTemporaryGroup =- !normalizedBudgetId &&- !!currentBudget &&- !!currentGroup &&- currentBudget.startsWith('__') &&- isGroupMember(currentGroup, port);ensureTrackedPort(port);pendingPongs.delete(port);- if (alreadyAttached) {- logState(`Tab resumed on budget "${normalizedBudgetId}"`);+ // A tab that is still a member of its group stays there, whatever its+ // bridge reports. A bridge can lag behind (a role message it never+ // saw); moving such a tab to unassigned would leave its group with a+ // leader that no longer routes, and every tab served by that group+ // would hang. Tell it its role again instead.+ if (currentBudget && currentGroup && isGroupMember(currentGroup, port)) {+ if (+ currentBudget !== normalizedBudgetId &&+ !currentBudget.startsWith('__')+ ) {+ const role = currentGroup.leaderPort === port ? 'LEADER' : 'FOLLOWER';+ port.postMessage({+ type: '__role-change',+ role,+ budgetId: currentBudget,+ });+ logState(+ `Tab resumed on budget "${currentBudget}" as ${role.toLowerCase()} (role re-announced)`,+ );+ } else {+ logState(`Tab resumed on budget "${currentBudget}"`);+ }return;}@@ -203,11 +212,6 @@ export function createCoordinator({return;}- if (alreadyOnTemporaryGroup) {- logState(`Tab resumed on coordinator group "${currentBudget}"`);- return;- }-if (!normalizedBudgetId) {if (budgetGroups.size === 0) {electLeader('__lobby', port);@@ -273,34 +277,8 @@ export function createCoordinator({const budgetId = portToBudget.get(port);portToBudget.delete(port);- if (!budgetId) return;-- const group = budgetGroups.get(budgetId);- if (!group) return;-- if (port === group.leaderPort) {- if (group.followers.size > 0) {- const candidate = group.followers.values().next()- .value as CoordinatorPort;- group.followers.delete(candidate);- logger.log(- `[SharedWorker] Leader left budget "${budgetId}" — promoting follower`,- );- electLeader(budgetId, candidate, budgetId);- } else {- logger.log(- `[SharedWorker] Last tab left budget "${budgetId}" — removing group`,- );- budgetGroups.delete(budgetId);- }- } else {- group.followers.delete(port);- for (const [id, p] of group.requestToPort) {- if (p === port) {- group.requestToPort.delete(id);- group.requestNames.delete(id);- }- }+ if (budgetId) {+ removePortFromGroup(port, budgetId);}}@@ -376,9 +354,31 @@ export function createCoordinator({}}+ // Takes a port out of a group. A leaving leader hands the group to one+ // of its followers, or the group is dissolved when none remain, so a+ // group never keeps a leader that no longer routes for it.function removePortFromGroup(port: CoordinatorPort, budgetId: string) {const group = budgetGroups.get(budgetId);if (!group) return;++ if (port === group.leaderPort) {+ if (group.followers.size > 0) {+ const candidate = group.followers.values().next()+ .value as CoordinatorPort;+ group.followers.delete(candidate);+ logger.log(+ `[SharedWorker] Leader left budget "${budgetId}" — promoting follower`,+ );+ electLeader(budgetId, candidate, budgetId);+ } else {+ logger.log(+ `[SharedWorker] Last tab left budget "${budgetId}" — removing group`,+ );+ budgetGroups.delete(budgetId);+ }+ return;+ }+group.followers.delete(port);for (const [id, p] of group.requestToPort) {if (p === port) {@@ -448,6 +448,22 @@ export function createCoordinator({portToBudget.set(p, newBudgetId);}+ // Bridges learn their budget from role changes. Without this a tab+ // that resumes after being hidden reports its old (or no) budget and+ // is moved to unassigned, which terminates the leader's Worker.+ leaderPort.postMessage({+ type: '__role-change',+ role: 'LEADER',+ budgetId: newBudgetId,+ });+ for (const p of oldGroup.followers) {+ p.postMessage({+ type: '__role-change',+ role: 'FOLLOWER',+ budgetId: newBudgetId,+ });+ }+logger.log(`[SharedWorker] Budget loaded: "${newBudgetId}" (leader + ${oldGroup.followers.size} follower(s))`,);@@ -476,14 +492,22 @@ export function createCoordinator({logState(`Budget "${budgetId}" closed (no tabs remain)`);// if it was the last group, re-establish a lobby so the tab can- // still route messages+ // still route messages. Either way the bridge must learn that it no+ // longer has this budget, or it will report it on its next resume.if (budgetGroups.size === 0) {unassignedPorts.delete(closingPort);const lobbyGroup = createBudgetGroup(closingPort);lobbyGroup.backendConnected = true;budgetGroups.set('__lobby', lobbyGroup);portToBudget.set(closingPort, '__lobby');+ closingPort.postMessage({+ type: '__role-change',+ role: 'LEADER',+ budgetId: '__lobby',+ });logState('Re-established lobby after last budget closed');+ } else {+ closingPort.postMessage({ type: '__role-change', role: 'UNASSIGNED' });}}}@@ -608,13 +632,18 @@ export function createCoordinator({if (workerMsg.type === 'reply' && name === 'close-budget') {handleBudgetClosed(targetPort, portBudget!);}+ // Prefs name the budget the leader's Worker actually has+ // open. A group keyed by a placeholder (the lobby, a+ // creation or deletion) or by a budget this leader has since+ // replaced is re-keyed, so later tabs join it instead of+ // electing a second leader for the same budget.if (workerMsg.type === 'reply' &&name === 'load-prefs' &&portBudget &&- portBudget.startsWith('__creating-') &&workerMsg.result &&- (workerMsg.result as Record<string, unknown>).id+ (workerMsg.result as Record<string, unknown>).id &&+ (workerMsg.result as Record<string, unknown>).id !== portBudget) {handleBudgetLoaded(port,diff --git a/packages/loot-core/vitest.config.ts b/packages/loot-core/vitest.config.tsindex f0f4c6e909..d143eca3e7 100644--- a/packages/loot-core/vitest.config.ts+++ b/packages/loot-core/vitest.config.ts@@ -6,6 +6,7 @@ export default defineConfig({globals: true,setupFiles: ['./src/mocks/setup.ts'],exclude: [+ 'src/platform/client/browser-preload/worker-bridge.test.ts','src/platform/server/sqlite/index.test.ts','src/platform/server/fs/index.test.ts','node_modules',diff --git a/packages/loot-core/vitest.web.config.ts b/packages/loot-core/vitest.web.config.tsindex 3265b7a855..202b7872b1 100644--- a/packages/loot-core/vitest.web.config.ts+++ b/packages/loot-core/vitest.web.config.ts@@ -6,6 +6,7 @@ export default defineConfig({environment: 'jsdom',globals: true,include: [+ 'src/platform/client/browser-preload/worker-bridge.test.ts','src/platform/server/sqlite/index.test.ts','src/platform/server/fs/index.test.ts',],diff --git a/upcoming-release-notes/fix-multitab-takeover.md b/upcoming-release-notes/fix-multitab-takeover.mdnew file mode 100644index 0000000000..e00bcf4ad3--- /dev/null+++ b/upcoming-release-notes/fix-multitab-takeover.md@@ -0,0 +1,6 @@+---+category: Bugfix+authors: [MikesGlitch]+---++Fix multi-tab hand-over: a budget created in one tab is shared with tabs opened later, and requests made while a tab takes over the budget no longer fail