gloomberb 0.9.9 → 0.10.0

package/src/sync/controller.test.ts

@@ -1,8 +1,24 @@
 import { expect, test } from "bun:test";
-import type { AppState } from "../core/state/app/state";
+import {
+  appReducer,
+  createInitialState,
+  type AppAction,
+  type AppState,
+} from "../core/state/app/state";
 import type { TickerRepository } from "../data/ticker-repository";
+import { createDefaultConfig } from "../types/config";
+import {
+  __syncContributorInternalsForTests,
+  coreConfigSyncContributor,
+} from "./core-contributors";
 import { CloudSyncController } from "./controller";
-import type { SyncTransport } from "./types";
+import {
+  SYNC_SNAPSHOT_SCHEMA_VERSION,
+  type SyncContributor,
+  type SyncSnapshot,
+  type SyncSnapshotResponse,
+  type SyncTransport,
+} from "./types";
 
 test("does not push local state when the initial pull fails", async () => {
   let pushes = 0;
@@ -17,7 +33,7 @@ test("does not push local state when the initial pull fails", async () => {
   };
   const controller = new CloudSyncController();
   controller.setRuntime({
-    state: {} as AppState,
+    getState: () => ({} as AppState),
     dispatch: () => {},
     tickerRepository: {} as TickerRepository,
     getContributors: () => [],
@@ -29,3 +45,174 @@ test("does not push local state when the initial pull fails", async () => {
   expect(pushes).toBe(0);
   expect(controller.getStatus()).toMatchObject({ phase: "error", error: "pull failed" });
 });
+
+test("keeps startup layout changes while serializing pull and push", async () => {
+  let state = createInitialState(createDefaultConfig("/tmp/gloomberb-sync-controller-test"));
+  const dispatch = (action: AppAction) => {
+    state = appReducer(state, action);
+  };
+  let resolvePull!: (response: SyncSnapshotResponse) => void;
+  const deferredPull = new Promise<SyncSnapshotResponse>((resolve) => {
+    resolvePull = resolve;
+  });
+  let pulls = 0;
+  const pushes: Array<{
+    snapshot: SyncSnapshot;
+    options?: { baseRevision?: number | null };
+  }> = [];
+  const transport: SyncTransport = {
+    id: "deferred-pull",
+    isAvailable: () => true,
+    pullSnapshot: () => {
+      pulls += 1;
+      return deferredPull;
+    },
+    pushSnapshot: async (snapshot, options) => {
+      pushes.push({ snapshot, options });
+      return { revision: 8, updatedAt: "2026-07-13T10:00:08.000Z" };
+    },
+  };
+  const contributor: SyncContributor = {
+    ...coreConfigSyncContributor,
+    apply: (payload, context) => {
+      const config = __syncContributorInternalsForTests.mergeConfigPayload(
+        context.state.config,
+        payload,
+        context.baselineState.config,
+      );
+      if (config) context.dispatch({ type: "SET_CONFIG", config });
+    },
+  };
+  const controller = new CloudSyncController();
+  controller.setRuntime({
+    getState: () => state,
+    dispatch,
+    tickerRepository: {} as TickerRepository,
+    getContributors: () => [{ pluginId: "test", contributor }],
+    getTransport: () => ({ pluginId: "test", transport }),
+  });
+
+  const startupSync = controller.requestSync({ reason: "startup" });
+  const startupPane = {
+    instanceId: "help:startup",
+    paneId: "help",
+    binding: { kind: "none" as const },
+  };
+  const localLayout = {
+    ...state.config.layout,
+    instances: [...state.config.layout.instances, startupPane],
+    floating: [
+      ...state.config.layout.floating,
+      { instanceId: startupPane.instanceId, x: 4, y: 3, width: 60, height: 20 },
+    ],
+  };
+  dispatch({
+    type: "SET_CONFIG",
+    config: {
+      ...state.config,
+      layout: localLayout,
+      layouts: state.config.layouts.map((saved, index) => (
+        index === state.config.activeLayoutIndex ? { ...saved, layout: localLayout } : saved
+      )),
+    },
+  });
+  const queuedPush = controller.requestSync({ reason: "state-change" });
+
+  const remoteConfig = createDefaultConfig("/remote/path-is-not-synced");
+  remoteConfig.theme = "green";
+  resolvePull({
+    snapshot: {
+      schemaVersion: SYNC_SNAPSHOT_SCHEMA_VERSION,
+      appId: "gloomberb",
+      clientId: "remote-client",
+      createdAt: "2026-07-13T10:00:07.000Z",
+      contributors: {
+        "core.config": {
+          schemaVersion: 1,
+          updatedAt: "2026-07-13T10:00:07.000Z",
+          payload: __syncContributorInternalsForTests.collectCoreConfigPayload(remoteConfig),
+        },
+      },
+    },
+    revision: 7,
+    updatedAt: "2026-07-13T10:00:07.000Z",
+  });
+  await Promise.all([startupSync, queuedPush]);
+
+  const pushedConfig = pushes[0]?.snapshot.contributors["core.config"]?.payload as {
+    layout: AppState["config"]["layout"];
+  };
+  expect(pulls).toBe(1);
+  expect(pushes).toHaveLength(1);
+  expect(pushes[0]?.options).toEqual({ baseRevision: 7 });
+  expect(state.config.theme).toBe("green");
+  expect(state.config.layout.instances).toContainEqual(startupPane);
+  expect(pushedConfig.layout.instances).toContainEqual(startupPane);
+});
+
+test("keeps the latest layout when switching away and back during a pull", async () => {
+  let state = createInitialState(createDefaultConfig("/tmp/gloomberb-sync-layout-roundtrip-test"));
+  const dispatch = (action: AppAction) => {
+    state = appReducer(state, action);
+  };
+  dispatch({ type: "SWITCH_LAYOUT", index: 1 });
+  dispatch({ type: "SWITCH_LAYOUT", index: 0 });
+
+  let resolvePull!: (response: SyncSnapshotResponse) => void;
+  const deferredPull = new Promise<SyncSnapshotResponse>((resolve) => {
+    resolvePull = resolve;
+  });
+  const pushes: SyncSnapshot[] = [];
+  const transport: SyncTransport = {
+    id: "deferred-layout-pull",
+    isAvailable: () => true,
+    pullSnapshot: () => deferredPull,
+    pushSnapshot: async (snapshot) => {
+      pushes.push(snapshot);
+      return { revision: 12, updatedAt: "2026-07-21T10:00:12.000Z" };
+    },
+  };
+  const controller = new CloudSyncController();
+  controller.setRuntime({
+    getState: () => state,
+    dispatch,
+    tickerRepository: {} as TickerRepository,
+    getContributors: () => [{ pluginId: "test", contributor: coreConfigSyncContributor }],
+    getTransport: () => ({ pluginId: "test", transport }),
+  });
+
+  const startupSync = controller.requestSync({ reason: "startup" });
+  dispatch({ type: "SWITCH_LAYOUT", index: 1 });
+  dispatch({ type: "SWITCH_LAYOUT", index: 0 });
+  const queuedPush = controller.requestSync({ reason: "state-change" });
+
+  const remoteConfig = createDefaultConfig("/remote/path-is-not-synced");
+  remoteConfig.theme = "green";
+  remoteConfig.layout = remoteConfig.layouts[1]!.layout;
+  remoteConfig.activeLayoutIndex = 1;
+  resolvePull({
+    snapshot: {
+      schemaVersion: SYNC_SNAPSHOT_SCHEMA_VERSION,
+      appId: "gloomberb",
+      clientId: "remote-client",
+      createdAt: "2026-07-21T10:00:11.000Z",
+      contributors: {
+        "core.config": {
+          schemaVersion: 1,
+          updatedAt: "2026-07-21T10:00:11.000Z",
+          payload: __syncContributorInternalsForTests.collectCoreConfigPayload(remoteConfig),
+        },
+      },
+    },
+    revision: 11,
+    updatedAt: "2026-07-21T10:00:11.000Z",
+  });
+  await Promise.all([startupSync, queuedPush]);
+
+  const pushedConfig = pushes[0]?.contributors["core.config"]?.payload as {
+    activeLayoutIndex: number;
+  };
+  expect(state.config.theme).toBe("green");
+  expect(state.config.activeLayoutIndex).toBe(0);
+  expect(pushedConfig.activeLayoutIndex).toBe(0);
+});

package/src/sync/controller.ts

@@ -23,7 +23,7 @@ export interface CloudSyncStatus {
 }
 
 interface SyncRuntime {
-  state: AppState;
+  getState: () => AppState;
   dispatch: Dispatch<AppAction>;
   tickerRepository: TickerRepository;
   getContributors: () => RegisteredSyncContributor[];
@@ -32,7 +32,6 @@ interface SyncRuntime {
 
 const CLIENT_ID_STORAGE_KEY = "gloomberb.sync.clientId";
 const PUSH_DEBOUNCE_MS = 2500;
-const PULL_MIN_INTERVAL_MS = 60_000;
 
 function nowIso(): string {
   return new Date().toISOString();
@@ -47,6 +46,15 @@ function resolveClientId(): string {
   return id;
 }
 
+function snapshotContentSignature(snapshot: SyncSnapshot): string {
+  return stableStringify(Object.fromEntries(
+    Object.entries(snapshot.contributors).map(([id, contributor]) => [
+      id,
+      { schemaVersion: contributor.schemaVersion, payload: contributor.payload },
+    ]),
+  ));
+}
+
 export class CloudSyncController {
   private runtime: SyncRuntime | null = null;
   private contributors = new Map<string, RegisteredSyncContributor>();
@@ -57,7 +65,6 @@ export class CloudSyncController {
   private syncQueued = false;
   private clientId: string | null = null;
   private lastSignature: string | null = null;
-  private lastPulledAtMs = 0;
   private hasPulledForTransport = new Set<string>();
   private status: CloudSyncStatus = {
     phase: "idle",
@@ -100,16 +107,20 @@ export class CloudSyncController {
     return [...this.transports.values()];
   }
 
-  setRuntime(runtime: SyncRuntime): void {
-    this.runtime = runtime;
-    this.updateAvailability();
+  setRuntime(runtime: SyncRuntime): () => void {
+    if (this.runtime !== runtime) {
+      this.resetOperations();
+      this.runtime = runtime;
+      this.updateAvailability();
+    }
+    return () => this.clearRuntime(runtime);
   }
 
-  clearRuntime(): void {
+  clearRuntime(runtime?: SyncRuntime): void {
+    if (runtime && this.runtime !== runtime) return;
     this.runtime = null;
-    if (this.pushTimer) clearTimeout(this.pushTimer);
-    this.pushTimer = null;
-    this.syncQueued = false;
+    this.resetOperations();
+    this.setStatus({ phase: "disabled", transportId: null, error: null });
   }
 
   subscribe(listener: () => void): () => void {
@@ -124,11 +135,11 @@ export class CloudSyncController {
   schedulePush(reason: string): void {
     const runtime = this.runtime;
     if (!runtime) return;
-    const transport = runtime.getTransport();
-    if (!transport?.transport.isAvailable()) {
+    const registration = runtime.getTransport();
+    if (!registration?.transport.isAvailable()) {
       this.setStatus({
         phase: "disabled",
-        transportId: transport?.transport.id ?? null,
+        transportId: registration?.transport.id ?? null,
         error: null,
       });
       return;
@@ -146,6 +157,7 @@ export class CloudSyncController {
       return this.inFlight;
     }
     const run = this.syncOnce(options).finally(async () => {
+      if (this.inFlight !== run) return;
       this.inFlight = null;
       if (!this.syncQueued) return;
       this.syncQueued = false;
@@ -155,42 +167,36 @@ export class CloudSyncController {
     return run;
   }
 
-  async pullLatest(options: { force?: boolean } = {}): Promise<void> {
-    const runtime = this.runtime;
-    if (!runtime) return;
-    const transport = runtime.getTransport();
-    if (!transport?.transport.isAvailable()) {
-      this.setStatus({ phase: "disabled", transportId: transport?.transport.id ?? null, error: null });
-      return;
-    }
-    const currentMs = Date.now();
-    if (!options.force && currentMs - this.lastPulledAtMs < PULL_MIN_INTERVAL_MS) return;
-    if (await this.runPull(runtime, transport.transport)) {
-      this.lastPulledAtMs = currentMs;
-    }
-  }
-
   private async syncOnce(options: { reason?: string; force?: boolean }): Promise<void> {
     const runtime = this.runtime;
     if (!runtime) return;
-    const transportRegistration = runtime.getTransport();
-    if (!transportRegistration?.transport.isAvailable()) {
-      this.setStatus({ phase: "disabled", transportId: transportRegistration?.transport.id ?? null, error: null });
+    const registration = runtime.getTransport();
+    if (!registration?.transport.isAvailable()) {
+      this.setStatus({
+        phase: "disabled",
+        transportId: registration?.transport.id ?? null,
+        error: null,
+      });
       return;
     }
-    const transport = transportRegistration.transport;
+    const transport = registration.transport;
+
     if (!this.hasPulledForTransport.has(transport.id)) {
+      this.lastSignature = null;
       if (!await this.runPull(runtime, transport)) return;
+      if (!this.isCurrent(runtime, transport)) return;
       this.hasPulledForTransport.add(transport.id);
     }
 
     const snapshot = await this.assembleSnapshot(runtime);
-    const signature = stableStringify(snapshot.contributors);
+    if (!this.isCurrent(runtime, transport)) return;
+    const signature = snapshotContentSignature(snapshot);
     if (!options.force && signature === this.lastSignature) return;
 
     this.setStatus({ phase: "syncing", transportId: transport.id, error: null });
     try {
       const result = await transport.pushSnapshot(snapshot, { baseRevision: this.status.revision });
+      if (!this.isCurrent(runtime, transport)) return;
       this.lastSignature = signature;
       this.setStatus({
         phase: "synced",
@@ -200,6 +206,7 @@ export class CloudSyncController {
         error: null,
       });
     } catch (error) {
+      if (!this.isCurrent(runtime, transport)) return;
       this.setStatus({
         phase: "error",
         transportId: transport.id,
@@ -209,9 +216,30 @@ export class CloudSyncController {
   }
 
   private async runPull(runtime: SyncRuntime, transport: SyncTransport): Promise<boolean> {
+    const baselineState = runtime.getState();
     this.setStatus({ phase: "syncing", transportId: transport.id, error: null });
     try {
       const response = await transport.pullSnapshot();
+      if (!this.isCurrent(runtime, transport)) return false;
+
+      if (response.snapshot) {
+        for (const entry of runtime.getContributors()) {
+          if (!this.isCurrent(runtime, transport)) return false;
+          const payload = response.snapshot.contributors[entry.contributor.id]?.payload;
+          if (payload === undefined || !entry.contributor.apply) continue;
+          await entry.contributor.apply(payload, {
+            snapshot: response.snapshot,
+            baselineState,
+            state: runtime.getState(),
+            getState: runtime.getState,
+            isCurrent: () => this.isCurrent(runtime, transport),
+            dispatch: runtime.dispatch,
+            tickerRepository: runtime.tickerRepository,
+          });
+        }
+      }
+
+      if (!this.isCurrent(runtime, transport)) return false;
       this.setStatus({
         phase: response.snapshot ? "synced" : "idle",
         transportId: transport.id,
@@ -220,19 +248,9 @@ export class CloudSyncController {
         lastSyncAt: response.updatedAt,
         error: null,
       });
-      if (!response.snapshot) return true;
-      for (const entry of runtime.getContributors()) {
-        const payload = response.snapshot.contributors[entry.contributor.id]?.payload;
-        if (payload === undefined || !entry.contributor.apply) continue;
-        await entry.contributor.apply(payload, {
-          snapshot: response.snapshot,
-          state: runtime.state,
-          dispatch: runtime.dispatch,
-          tickerRepository: runtime.tickerRepository,
-        });
-      }
       return true;
     } catch (error) {
+      if (!this.isCurrent(runtime, transport)) return false;
       this.setStatus({
         phase: "error",
         transportId: transport.id,
@@ -247,7 +265,7 @@ export class CloudSyncController {
     const createdAt = nowIso();
     const payloads: SyncSnapshot["contributors"] = {};
     for (const entry of contributors) {
-      const payload = await entry.contributor.collect({ state: runtime.state });
+      const payload = await entry.contributor.collect({ state: runtime.getState() });
       payloads[entry.contributor.id] = {
         schemaVersion: entry.contributor.schemaVersion,
         updatedAt: createdAt,
@@ -263,6 +281,19 @@ export class CloudSyncController {
     };
   }
 
+  private isCurrent(runtime: SyncRuntime, transport: SyncTransport): boolean {
+    return this.runtime === runtime && runtime.getTransport()?.transport === transport;
+  }
+
+  private resetOperations(): void {
+    if (this.pushTimer) clearTimeout(this.pushTimer);
+    this.pushTimer = null;
+    this.inFlight = null;
+    this.syncQueued = false;
+    this.hasPulledForTransport.clear();
+    this.lastSignature = null;
+  }
+
   private updateAvailability(): void {
     const transport = this.runtime?.getTransport() ?? null;
     if (!transport) {

package/src/sync/core-contributors.test.ts

@@ -56,6 +56,92 @@ describe("core sync contributors", () => {
     expect(serialized).toContain("Demo Broker");
   });
 
+  test("normalizes legacy built-in ownership in pulled config", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-sync-test");
+    const layouts = config.layouts.map((savedLayout, index) => index === 0
+      ? {
+        ...savedLayout,
+        paneState: {
+          "portfolio-list:main": {
+            pluginState: {
+              analytics: { metric: "beta", shared: "legacy" },
+              portfolio: { shared: "canonical" },
+            },
+          },
+        },
+      }
+      : savedLayout);
+
+    const merged = __syncContributorInternalsForTests.mergeConfigPayload(config, {
+      disabledPlugins: ["analytics", "kelly-sizer", "changelog", "macro-tv"],
+      pluginConfig: {
+        analytics: { metric: "beta", shared: "legacy" },
+        portfolio: { shared: "canonical" },
+        help: { section: "shortcuts" },
+      },
+      layout: config.layout,
+      layouts,
+      activeLayoutIndex: config.activeLayoutIndex,
+    });
+
+    expect(merged?.disabledPlugins).toEqual(["portfolio", "macro"]);
+    expect(merged?.pluginConfig).toEqual({
+      portfolio: { metric: "beta", shared: "canonical" },
+      application: { section: "shortcuts" },
+    });
+    expect(merged?.layouts[0]?.paneState?.["portfolio-list:main"]?.pluginState).toEqual({
+      portfolio: { metric: "beta", shared: "canonical" },
+    });
+  });
+
+  test("emits legacy aliases for mixed-version config sync", async () => {
+    const config = createDefaultConfig("/tmp/gloomberb-sync-test");
+    config.disabledPlugins = ["portfolio"];
+    config.pluginConfig = {
+      portfolio: { "commonAssumptions:v1": { kellyFraction: 0.5 } },
+    };
+    config.layouts[0] = {
+      ...config.layouts[0]!,
+      paneState: {
+        "portfolio-list:main": {
+          pluginState: {
+            portfolio: { mode: "scenario" },
+          },
+        },
+      },
+    };
+
+    const payload = await coreConfigSyncContributor.collect({
+      state: createInitialState(config),
+    }) as any;
+
+    expect(payload.disabledPlugins).toEqual([
+      "portfolio",
+      "portfolio-list",
+      "analytics",
+      "kelly-sizer",
+    ]);
+    for (const pluginId of ["portfolio", "portfolio-list", "analytics", "kelly-sizer"]) {
+      expect(payload.pluginConfig[pluginId]).toEqual(config.pluginConfig.portfolio);
+      expect(
+        payload.layouts[0].paneState["portfolio-list:main"].pluginState[pluginId],
+      ).toEqual({ mode: "scenario" });
+    }
+  });
+
+  test("ignores malformed synced layout collections", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-sync-test");
+    const merged = __syncContributorInternalsForTests.mergeConfigPayload(config, {
+      layout: config.layout,
+      layouts: null,
+      activeLayoutIndex: 0,
+    });
+
+    expect(merged?.layout).toBe(config.layout);
+    expect(merged?.layouts).toBe(config.layouts);
+    expect(merged?.activeLayoutIndex).toBe(config.activeLayoutIndex);
+  });
+
   test("syncs collection memberships and sanitized positions", async () => {
     const config = createDefaultConfig("/tmp/gloomberb-sync-test");
     config.portfolios = [{
@@ -248,4 +334,39 @@ describe("core sync contributors", () => {
     });
     expect(payload.analyticsByPortfolio.preview).not.toHaveProperty("marketValue");
   });
+
+  test("preserves pulled profile analytics before local market data is ready", async () => {
+    const config = createDefaultConfig("/tmp/gloomberb-sync-test");
+    config.portfolios = [{ id: "main", name: "Main", currency: "USD" }];
+    const state = createInitialState(config);
+
+    await coreCollectionsSyncContributor.apply?.({
+      analyticsByPortfolio: {
+        main: { oneYearReturn: 0.27, spyBeta: 1.1 },
+      },
+      tickers: [],
+    }, {
+      snapshot: {
+        schemaVersion: 1,
+        appId: "gloomberb",
+        clientId: "test-client",
+        createdAt: "2026-07-21T22:03:59.832Z",
+        contributors: {},
+      },
+      baselineState: state,
+      state,
+      getState: () => state,
+      isCurrent: () => true,
+      dispatch: () => {},
+      tickerRepository: {} as never,
+    });
+
+    const payload = await coreCollectionsSyncContributor.collect({ state }) as any;
+    setSyncedProfileAnalytics("main", null);
+
+    expect(payload.analyticsByPortfolio.main).toEqual({
+      oneYearReturn: 0.27,
+      spyBeta: 1.1,
+    });
+  });
 });