refactor: clarify state ownership - promote windowId to explicit lifecycle atom (phase 2)

frontend/app/app.tsx

@@ -364,7 +364,7 @@ const BadgeAutoClearing = () => {
 const AppInner = () => {
     const prefersReducedMotion = useAtomValue(atoms.prefersReducedMotionAtom);
     const client = useAtomValue(ClientModel.getInstance().clientAtom);
-    const windowData = useAtomValue(GlobalModel.getInstance().windowDataAtom);
+    const windowData = useAtomValue(atoms.windowData);
     const isFullScreen = useAtomValue(atoms.isFullScreen);
 
     if (client == null || windowData == null) {

frontend/app/store/global-atoms.ts

@@ -17,13 +17,21 @@ function initGlobalAtoms(initOpts: GlobalInitOptions) {
     setWaveWindowType(initOpts.isPreview ? "preview" : initOpts.builderId != null ? "builder" : "tab");
     // Tab views are reused across workspace switches, so reinit updates this to the workspace active tab.
     const staticTabIdAtom = atom(initOpts.tabId) as PrimitiveAtom<string>;
+    const windowIdAtom = atom(initOpts.windowId) as PrimitiveAtom<string>;
     const uiContextAtom = atom((get) => {
         const uiContext: UIContext = {
-            windowid: initOpts.windowId,
+            windowid: get(windowIdAtom),
             activetabid: get(staticTabIdAtom),
         };
         return uiContext;
     }) as Atom<UIContext>;
+    const windowDataAtom: Atom<WaveWindow> = atom((get) => {
+        const windowId = get(windowIdAtom);
+        if (windowId == null) {
+            return null;
+        }
+        return WOS.getObjectValue(WOS.makeORef("window", windowId), get);
+    });
 
     const isFullScreenAtom = atom(false) as PrimitiveAtom<boolean>;
     try {
@@ -127,6 +135,8 @@ function initGlobalAtoms(initOpts: GlobalInitOptions) {
         builderId: builderIdAtom,
         builderAppId: builderAppIdAtom,
         uiContext: uiContextAtom,
+        windowId: windowIdAtom,
+        windowData: windowDataAtom,
         workspaceId: workspaceIdAtom,
         workspace: workspaceAtom,
         fullConfigAtom,

frontend/app/store/global-model.ts

@@ -1,24 +1,18 @@
 // Copyright 2025, Command Line Inc
 // SPDX-License-Identifier: Apache-2.0
 
-import * as WOS from "@/app/store/wos";
 import { ClientModel } from "@/app/store/client-model";
 import { getApi } from "@/store/global";
 import * as util from "@/util/util";
-import { atom, Atom } from "jotai";
 
 class GlobalModel {
     private static instance: GlobalModel;
     static readonly IsActiveThrottleMs = 5000;
 
-    windowId: string;
     builderId: string;
     platform: NodeJS.Platform;
     lastSetIsActiveTs = 0;
 
-    windowDataAtom!: Atom<WaveWindow>;
-    workspaceAtom!: Atom<Workspace>;
-
     private constructor() {
         // private constructor for singleton pattern
     }
@@ -32,24 +26,8 @@ class GlobalModel {
 
     async initialize(initOpts: GlobalInitOptions): Promise<void> {
         ClientModel.getInstance().initialize(initOpts.clientId);
-        this.windowId = initOpts.windowId;
         this.builderId = initOpts.builderId;
         this.platform = initOpts.platform;
-
-        this.windowDataAtom = atom((get) => {
-            if (this.windowId == null) {
-                return null;
-            }
-            return WOS.getObjectValue<WaveWindow>(WOS.makeORef("window", this.windowId), get);
-        });
-
-        this.workspaceAtom = atom((get) => {
-            const windowData = get(this.windowDataAtom);
-            if (windowData == null) {
-                return null;
-            }
-            return WOS.getObjectValue(WOS.makeORef("workspace", windowData.workspaceid), get);
-        });
     }
 
     setIsActive(): void {

frontend/preview/mock/mockwaveenv.ts

@@ -163,10 +163,23 @@ function makeMockGlobalAtoms(
         }
         return get(getWaveObjectAtom<Workspace>("workspace:" + wsId));
     });
+    const windowIdAtomMock = atom(null) as PrimitiveAtom<string>;
+    const windowDataAtomMock: Atom<WaveWindow> = atom((get) => {
+        const windowId = get(windowIdAtomMock);
+        if (windowId == null) {
+            return null;
+        }
+        return get(getWaveObjectAtom<WaveWindow>("window:" + windowId));
+    });
     const defaults: GlobalAtomsType = {
         builderId: atom(""),
         builderAppId: atom("") as any,
-        uiContext: atom({ windowid: "", activetabid: tabId ?? "" } as UIContext),
+        uiContext: atom((get) => ({
+            windowid: get(windowIdAtomMock),
+            activetabid: tabId ?? "",
+        })) as Atom<UIContext>,
+        windowId: windowIdAtomMock,
+        windowData: windowDataAtomMock,
         workspaceId: workspaceIdAtom,
         workspace: workspaceAtom,
         fullConfigAtom,

frontend/types/custom.d.ts

@@ -11,6 +11,8 @@ declare global {
         builderId: jotai.Atom<string>; // readonly (for builder mode)
         builderAppId: jotai.PrimitiveAtom<string>; // app being edited in builder mode
         uiContext: jotai.Atom<UIContext>; // driven from windowId, tabId
+        windowId: jotai.PrimitiveAtom<string>; // lifecycle: set by applyWorkspaceContext
+        windowData: jotai.Atom<WaveWindow>; // derived from windowId via WOS
         workspaceId: jotai.PrimitiveAtom<string>;
         workspace: jotai.Atom<Workspace>; // driven from workspaceId via WOS
         fullConfigAtom: jotai.PrimitiveAtom<FullConfigType>; // driven from WOS, settings -- updated via WebSocket

frontend/wave.ts

@@ -148,6 +148,7 @@ async function loadWorkspaceContext(opts: {
 function applyWorkspaceContext(ctx: WorkspaceContext, opts: { tabContext: "own" | "active" }) {
     const tabIdForRenderer = opts.tabContext === "active" ? ctx.activeTabId : ctx.ownTabId;
 
+    globalStore.set(atoms.windowId, ctx.waveWindow.oid);
     globalStore.set(atoms.workspaceId, ctx.workspace.oid);
     globalStore.set(activeTabIdAtom, ctx.activeTabId);
     globalStore.set(atoms.staticTabId, tabIdForRenderer);