Skip to content

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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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 Worker
if (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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.md
new file mode 100644
index 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