@omega.js/desktop 0.1.0

package/dist/test/suites/main/window-bounds.test.js

@@ -0,0 +1,169 @@
+// Main-process tests for window-manager bounds persistence.
+//
+// Storage key shape: windows.<name>.bounds = { x, y, width, height, maximized, fullscreen }
+// Verified behavior:
+//   - createNamed without saved bounds uses config defaults (no x/y → centered)
+//   - close persists current bounds
+//   - createNamed with saved bounds restores them
+//   - off-screen bounds are clamped (position dropped, size kept)
+//   - persistBounds: false opts out of save AND restore
+
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'main',
+  description: 'window-manager bounds persistence (main)',
+  cleanup: (ctx) => {
+    // Drop everything we wrote so reruns are clean.
+    ctx.manager.storage.delete('windows.settings.bounds');
+    ctx.manager.storage.delete('windows.about.bounds');
+    ctx.manager.storage.delete('windows.bounds-test.bounds');
+    // Make sure no test-leftover windows remain.
+    ['settings', 'about', 'bounds-test'].forEach((name) => {
+      const w = ctx.manager.windows.get(name);
+      if (w) {
+        w._emForceClose = true;
+        w.close();
+      }
+    });
+  },
+  tests: [
+    {
+      name: '_loadBounds returns null when nothing is saved',
+      run: (ctx) => {
+        ctx.manager.storage.delete('windows.bounds-test.bounds');
+        ctx.expect(ctx.manager.windows._loadBounds('bounds-test', ctx.manager)).toBeNull();
+      },
+    },
+    {
+      name: '_loadBounds returns the saved object',
+      run: (ctx) => {
+        const saved = { x: 50, y: 60, width: 800, height: 600 };
+        ctx.manager.storage.set('windows.bounds-test.bounds', saved);
+        ctx.expect(ctx.manager.windows._loadBounds('bounds-test', ctx.manager)).toEqual(saved);
+      },
+    },
+    {
+      name: '_loadBounds rejects malformed entries',
+      run: (ctx) => {
+        ctx.manager.storage.set('windows.bounds-test.bounds', { width: 'oops' });
+        ctx.expect(ctx.manager.windows._loadBounds('bounds-test', ctx.manager)).toBeNull();
+
+        ctx.manager.storage.set('windows.bounds-test.bounds', { width: 50, height: 50 }); // below sanity floor
+        ctx.expect(ctx.manager.windows._loadBounds('bounds-test', ctx.manager)).toBeNull();
+      },
+    },
+    {
+      name: '_clampToDisplays drops x/y when off-screen, keeps width/height',
+      run: (ctx) => {
+        // Way off-screen (huge negative coordinates).
+        const out = ctx.manager.windows._clampToDisplays({
+          x: -99999, y: -99999, width: 800, height: 600,
+        });
+        ctx.expect(out.x).toBeUndefined();
+        ctx.expect(out.y).toBeUndefined();
+        ctx.expect(out.width).toBe(800);
+        ctx.expect(out.height).toBe(600);
+      },
+    },
+    {
+      name: '_clampToDisplays keeps x/y when on-screen',
+      run: (ctx) => {
+        // Use a primary-display point we know is on-screen: (100, 100).
+        const out = ctx.manager.windows._clampToDisplays({
+          x: 100, y: 100, width: 800, height: 600,
+        });
+        ctx.expect(out.x).toBe(100);
+        ctx.expect(out.y).toBe(100);
+      },
+    },
+    {
+      name: 'createNamed restores saved bounds',
+      run: async (ctx) => {
+        // Pre-seed storage with bounds for the about window.
+        const wanted = { x: 120, y: 140, width: 720, height: 540 };
+        ctx.manager.storage.set('windows.about.bounds', wanted);
+
+        const win = await ctx.manager.windows.createNamed('about');
+        ctx.state.win = win;
+        const got = win.getBounds();
+        ctx.expect(got.width).toBe(720);
+        ctx.expect(got.height).toBe(540);
+        // x/y depend on the OS chrome (title bars etc.) but should be at least within a few px of what we asked.
+        ctx.expect(Math.abs(got.x - 120)).toBeLessThan(50);
+        ctx.expect(Math.abs(got.y - 140)).toBeLessThan(50);
+      },
+    },
+    {
+      name: '_saveBoundsNow writes the current bounds to storage',
+      run: (ctx) => {
+        const win = ctx.state.win;
+        ctx.expect(win).toBeTruthy();
+
+        // Move + resize, then trigger save.
+        win.setBounds({ x: 200, y: 220, width: 640, height: 480 });
+        ctx.manager.windows._saveBoundsNow('about');
+
+        const saved = ctx.manager.storage.get('windows.about.bounds');
+        ctx.expect(saved).toBeTruthy();
+        ctx.expect(saved.width).toBe(640);
+        ctx.expect(saved.height).toBe(480);
+        ctx.expect(saved.maximized).toBe(false);
+        ctx.expect(saved.fullscreen).toBe(false);
+      },
+    },
+    {
+      name: 'close flushes the bounds save',
+      run: async (ctx) => {
+        const win = ctx.state.win;
+        win.setBounds({ x: 300, y: 300, width: 555, height: 444 });
+
+        const closedPromise = new Promise((r) => {
+          if (win.isDestroyed()) return r();
+          win.once('closed', r);
+        });
+        ctx.manager.windows.close('about');
+        await closedPromise;
+
+        const saved = ctx.manager.storage.get('windows.about.bounds');
+        ctx.expect(saved.width).toBe(555);
+        ctx.expect(saved.height).toBe(444);
+      },
+    },
+    {
+      name: 'persistBounds: false → no auto-save on resize, no restore on create',
+      run: async (ctx) => {
+        // Pre-seed bounds that SHOULD be ignored when persistBounds: false.
+        ctx.manager.storage.set('windows.about.bounds', { x: 50, y: 60, width: 999, height: 888 });
+
+        // The `windows` config block is no longer required — pass persistBounds via the
+        // call-site overrides arg instead. (The merge order is defaults < JSON config <
+        // overrides, so this works whether or not config.windows.about is set.)
+        try {
+          const win = await ctx.manager.windows.createNamed('about', undefined, { persistBounds: false });
+
+          // Saved 999x888 must NOT have been restored — should fall back to config defaults.
+          const got = win.getBounds();
+          ctx.expect(got.width).not.toBe(999);
+          ctx.expect(got.height).not.toBe(888);
+
+          // Now resize and confirm no auto-save fires past the debounce window.
+          ctx.manager.storage.delete('windows.about.bounds');
+          win.setBounds({ x: 30, y: 30, width: 700, height: 500 });
+          await new Promise((r) => setTimeout(r, 350));
+          ctx.expect(ctx.manager.storage.get('windows.about.bounds')).toBeUndefined();
+
+          const closedPromise = new Promise((r) => win.once('closed', r));
+          ctx.manager.windows.close('about');
+          await closedPromise;
+
+          // close also must NOT have written under persistBounds:false.
+          ctx.expect(ctx.manager.storage.get('windows.about.bounds')).toBeUndefined();
+        } finally {
+          ctx.manager.storage.delete('windows.about.bounds');
+        }
+      },
+    },
+  ],
+});

package/dist/test/suites/main/window-manager.test.js

@@ -0,0 +1,233 @@
+// Main-process tests for lib/window-manager.js — createNamed, dedup, hide/show/close lifecycle.
+//
+// Note: createNamed requires src/views/<view>/index.html to exist on disk in the test cwd.
+// The harness uses @omega.js/desktop's defaults config but runs from @omega.js/desktop's repo root, where there are no built views.
+// So we test the API surface and dedup behavior using the manager's electron handle but skip
+// actual file-loading in createNamed (it logs an error and returns the BrowserWindow anyway,
+// which is enough to verify the registry behavior).
+
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'main',
+  description: 'window-manager (main)',
+  tests: [
+    {
+      name: 'initialize was called during boot',
+      run: (ctx) => {
+        ctx.expect(ctx.manager.windows._initialized).toBe(true);
+      },
+    },
+    {
+      name: 'list returns empty array when no windows are open',
+      run: (ctx) => {
+        // skipWindowCreation: true means no window was auto-created.
+        ctx.expect(Array.isArray(ctx.manager.windows.list())).toBe(true);
+        ctx.expect(ctx.manager.windows.list().length).toBe(0);
+      },
+    },
+    {
+      name: 'get returns null for unknown name',
+      run: (ctx) => {
+        ctx.expect(ctx.manager.windows.get('nonexistent')).toBeNull();
+      },
+    },
+    {
+      name: 'createNamed registers a window in the registry (uses about view)',
+      run: async (ctx) => {
+        // We need a view file. Use @omega.js/desktop's own defaults dir as the cwd-equivalent by setting a custom html path.
+        // For simplicity, just verify createNamed creates a BrowserWindow even when the html file is missing
+        // (loadFile catches the error; the window object still exists in the registry).
+        const win = await ctx.manager.windows.createNamed('about');
+        ctx.state.win = win;
+        ctx.expect(win).toBeTruthy();
+        ctx.expect(ctx.manager.windows.get('about')).toBe(win);
+        ctx.expect(ctx.manager.windows.list()).toContain('about');
+      },
+    },
+    {
+      name: 'createNamed dedups — second call returns the same window',
+      run: async (ctx) => {
+        const again = await ctx.manager.windows.createNamed('about');
+        ctx.expect(again).toBe(ctx.state.win);
+      },
+    },
+    {
+      name: 'hide / show do not throw',
+      run: (ctx) => {
+        ctx.manager.windows.hide('about');
+        ctx.manager.windows.show('about');
+        // No assertion beyond "didn't throw" — visibility is OS-side state we can't reliably read.
+      },
+    },
+    {
+      // wave-5 F6: the rehide path deref'd config.startup.mode bare; a config
+      // without a startup block (schema: optional) threw inside the hide handler.
+      name: '_maybeRehideDock survives a config without a startup block',
+      run: (ctx) => {
+        const orig = ctx.manager.config.startup;
+        delete ctx.manager.config.startup;
+        try {
+          ctx.manager.windows._maybeRehideDock(); // must not throw
+          ctx.expect(ctx.manager.startup.getMode()).toBe('normal');
+        } finally {
+          if (orig !== undefined) ctx.manager.config.startup = orig;
+        }
+      },
+    },
+
+    // ── Test stealth (this harness IS Testing mode, so stealth is active) ────
+    {
+      name: 'stealth: app activation suppressed — dock hidden (accessory policy, macOS)',
+      run: (ctx) => {
+        if (process.platform !== 'darwin') {
+          return ctx.skip('macOS-only — accessory activation policy / dock');
+        }
+        // Both the harness entry (at require time) and Manager.initialize (step 1a)
+        // hide the dock under the stealth predicate, so the launched test app never
+        // activates and never steals keyboard focus.
+        const { app } = require('electron');
+        ctx.expect(app.dock.isVisible()).toBe(false);
+      },
+    },
+    {
+      name: 'stealth surfacing: shown but invisible (opacity 0) and never focused',
+      run: (ctx) => {
+        const { BrowserWindow } = require('electron');
+
+        ctx.expect(ctx.manager.windows._isStealth()).toBe(true);
+
+        const win = new BrowserWindow({ show: false, width: 120, height: 80 });
+        ctx.manager.windows._surface(win, 'stealth-probe');
+
+        // Shown (rendering/timers run like a visible window — NOT hide/minimize,
+        // which would occlusion-throttle) but fully transparent and inactive.
+        ctx.expect(win.isVisible()).toBe(true);
+        ctx.expect(win.getOpacity()).toBe(0);
+        ctx.expect(win.isFocused()).toBe(false);
+
+        win.destroy();
+      },
+    },
+    {
+      name: 'OMEGA_TEST_SHOW=1 opts out: windows surface normally (opacity 1)',
+      run: (ctx) => {
+        const { BrowserWindow } = require('electron');
+
+        process.env.OMEGA_TEST_SHOW = '1';
+        try {
+          ctx.expect(ctx.manager.windows._isStealth()).toBe(false);
+
+          // This probe exercises the real non-stealth _surface branch WITHOUT
+          // stealing the developer's keyboard focus mid-run. Two activation
+          // paths have to be neutralized (measured on macOS):
+          //   1. _ensureDockVisible → dock.show() activates the app
+          //      (TransformProcessType). Pre-flipping the activation policy to
+          //      'regular' makes the dock visible WITHOUT activating, so
+          //      _ensureDockVisible no-ops.
+          //   2. win.show() hands the window keyboard focus — focusable:false
+          //      declines it while still ordering the window front (visible,
+          //      opacity 1), which is what this test asserts.
+          if (process.platform === 'darwin') {
+            require('electron').app.setActivationPolicy('regular');
+          }
+          const win = new BrowserWindow({ show: false, width: 120, height: 80, x: 0, y: 0, focusable: false });
+          ctx.manager.windows._surface(win, 'visible-probe');
+
+          ctx.expect(win.isVisible()).toBe(true);
+          ctx.expect(win.getOpacity()).toBe(1);
+
+          win.destroy();
+        } finally {
+          delete process.env.OMEGA_TEST_SHOW;
+          // Restore the launch-time activation suppression for the rest of the run.
+          if (process.platform === 'darwin') {
+            require('electron').app.dock.hide();
+          }
+        }
+
+        // Flag removed → stealth is back on for the rest of the run.
+        ctx.expect(ctx.manager.windows._isStealth()).toBe(true);
+      },
+    },
+    {
+      name: 'trafficLightPosition passes through to the BrowserWindow (mac)',
+      run: async (ctx) => {
+        if (process.platform !== 'darwin') {
+          return; // trafficLightPosition is a macOS-only BrowserWindow option
+        }
+
+        const win = await ctx.manager.windows.create('tlp-probe', { trafficLightPosition: { x: 26, y: 24 } });
+        ctx.expect(win).toBeTruthy();
+
+        const pos = win.getWindowButtonPosition();
+        ctx.expect(pos).toEqual({ x: 26, y: 24 });
+
+        win.destroy();
+      },
+    },
+    {
+      name: 'close removes the window from the registry',
+      run: async (ctx) => {
+        const win = ctx.manager.windows.get('about');
+        ctx.expect(win).toBeTruthy();
+
+        // close fires asynchronously — wait for the 'closed' event rather than guessing a timeout.
+        const closedPromise = new Promise((resolve) => {
+          if (win.isDestroyed()) return resolve();
+          win.once('closed', resolve);
+        });
+
+        ctx.manager.windows.close('about');
+        await closedPromise;
+
+        ctx.expect(ctx.manager.windows.get('about')).toBeNull();
+      },
+    },
+    {
+      name: 'manager.quit + manager.relaunch exposed and set _allowQuit',
+      run: (ctx) => {
+        ctx.expect(typeof ctx.manager.quit).toBe('function');
+        ctx.expect(typeof ctx.manager.relaunch).toBe('function');
+        ctx.manager._allowQuit = false;
+
+        // Calling quit({force:true}) should set _allowQuit BEFORE invoking app.quit().
+        // We can't actually let app.quit() run mid-test (it'd kill the harness), so we
+        // stub electron.app.quit with a noop, observe the flag, then restore.
+        const electron = require('electron');
+        const origQuit = electron.app.quit;
+        electron.app.quit = () => {};
+        try {
+          ctx.manager.quit({ force: true });
+          ctx.expect(ctx.manager._allowQuit).toBe(true);
+        } finally {
+          electron.app.quit = origQuit;
+          ctx.manager._allowQuit = false;
+        }
+      },
+    },
+    {
+      name: 'auto-updater installNow flips manager._allowQuit',
+      run: (ctx) => {
+        ctx.manager._allowQuit = false;
+
+        // Force the autoUpdater state to "downloaded" + stub the underlying library
+        // so installNow doesn't actually quit the harness.
+        const prevState = ctx.manager.autoUpdater._state;
+        const prevLib   = ctx.manager.autoUpdater._library;
+        ctx.manager.autoUpdater._state = { code: 'downloaded', version: '9.9.9' };
+        ctx.manager.autoUpdater._library = { quitAndInstall: () => {} };
+
+        try {
+          ctx.manager.autoUpdater.installNow();
+          ctx.expect(ctx.manager._allowQuit).toBe(true);
+        } finally {
+          ctx.manager.autoUpdater._state   = prevState;
+          ctx.manager.autoUpdater._library = prevLib;
+          ctx.manager._allowQuit = false;
+        }
+      },
+    },
+  ],
+});

package/dist/test/suites/renderer/analytics-bridge.test.js

@@ -0,0 +1,128 @@
+// Renderer-layer round-trip tests for window.desktop.{analytics,context,usage,remoteConfig}.
+// Verifies the contextBridge surfaces actually round-trip through IPC into main.
+
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'renderer',
+  description: 'analytics + context + usage + remote-config bridges (renderer)',
+  tests: [
+    {
+      name: 'window.desktop.analytics has event / pageview / screenview / setUserProperties / getStatus',
+      run: (ctx) => {
+        ctx.expect(typeof window.desktop.analytics.event).toBe('function');
+        ctx.expect(typeof window.desktop.analytics.pageview).toBe('function');
+        ctx.expect(typeof window.desktop.analytics.screenview).toBe('function');
+        ctx.expect(typeof window.desktop.analytics.setUserProperties).toBe('function');
+        ctx.expect(typeof window.desktop.analytics.getStatus).toBe('function');
+      },
+    },
+    {
+      name: 'window.desktop.analytics.getStatus round-trips main state',
+      run: async (ctx) => {
+        const status = await window.desktop.analytics.getStatus();
+        ctx.expect(status).toBeDefined();
+        // Should always have the enabled boolean — even when analytics is off.
+        ctx.expect(typeof status.enabled).toBe('boolean');
+      },
+    },
+    {
+      name: 'window.desktop.analytics.event is fire-and-forget (no throw)',
+      run: (ctx) => {
+        // No await — send is one-way. Just verify it doesn't throw.
+        window.desktop.analytics.event('renderer_test_event', { from: 'renderer' });
+        window.desktop.analytics.pageview('/test/path');
+        window.desktop.analytics.screenview('TestScreen');
+        ctx.expect(true).toBe(true);
+      },
+    },
+    {
+      // #411: a renderer's own `omega.analytics().event(...)` used to no-op
+      // silently — the embedded client had no way to deliver. It now forwards
+      // over this bridge, and main's sender is the one that fires it.
+      name: 'a renderer-originated omega.analytics() event reaches main\'s sender exactly once, with main\'s identity',
+      run: async (ctx) => {
+        const read = () => window.desktop.ipc.invoke('desktop:__test:read-analytics-sends');
+        const baseline = (await read()).length;
+
+        window.__emTestClientAnalytics.event('vert_click', { vert_id: 'pin-411' });
+
+        // The forward is fire-and-forget IPC — poll until main records it.
+        let sends = [];
+        const t0 = Date.now();
+        while (sends.length <= baseline) {
+          // The client's own state says WHY when this fails: an unbridged one
+          // carries a client id of its own — the identity fork (#411).
+          if (Date.now() - t0 > 3000) throw new Error(`timed out waiting for main to record the forwarded event — client state ${JSON.stringify(window.__emTestClientAnalytics.state())}`);
+          await new Promise((r) => setTimeout(r, 25));
+          sends = await read();
+        }
+
+        const fired = sends.slice(baseline).filter((s) => s.name === 'vert_click');
+        ctx.expect(fired.length).toBe(1);
+        ctx.expect(fired[0].provider).toBe('ga4');
+        ctx.expect(fired[0].payload.vert_id).toBe('pin-411');
+
+        // Main's identity, never a renderer-minted one — asserted on the WIRE
+        // payload: the `client_id` GA would receive is the one main reports
+        // over its own status channel, and the session id is the one main
+        // minted for this launch, with real engagement time.
+        const status = await window.desktop.analytics.getStatus();
+        const snapshot = await window.desktop.context.get();
+        ctx.expect(fired[0].body.client_id).toBe(status.clientId);
+        ctx.expect(fired[0].body.events[0].name).toBe('vert_click');
+        ctx.expect(fired[0].body.events[0].params.session_id).toBe(snapshot.session.id);
+        ctx.expect(fired[0].body.events[0].params.engagement_time_msec > 0).toBe(true);
+      },
+    },
+    {
+      name: 'the bridged renderer holds no sender of its own — no secret, no second device id',
+      run: (ctx) => {
+        const state = window.__emTestClientAnalytics.state();
+        ctx.expect(state.initialized).toBe(true);
+        ctx.expect(state.bridged).toBe(true);
+        ctx.expect(state.secret).toBe(null);
+        ctx.expect(state.clientId).toBe(null);
+      },
+    },
+    {
+      name: 'window.desktop.context.get returns the context snapshot',
+      run: async (ctx) => {
+        const snap = await window.desktop.context.get();
+        ctx.expect(snap).toBeDefined();
+        ctx.expect(snap.session).toBeDefined();
+        ctx.expect(snap.client).toBeDefined();
+        ctx.expect(typeof snap.session.id).toBe('string');
+        ctx.expect(snap.session.id.length).toBe(36);   // uuid
+        ctx.expect(typeof snap.client.platform).toBe('string');
+      },
+    },
+    {
+      name: 'window.desktop.usage.get returns the usage snapshot',
+      run: async (ctx) => {
+        const snap = await window.desktop.usage.get();
+        ctx.expect(snap).toBeDefined();
+        ctx.expect(typeof snap.opens).toBe('number');
+        ctx.expect(typeof snap.hoursTotal).toBe('number');
+        ctx.expect(typeof snap.hoursThisSession).toBe('number');
+      },
+    },
+    {
+      name: 'window.desktop.remoteConfig.get / refreshNow / onUpdate are functions',
+      run: (ctx) => {
+        ctx.expect(typeof window.desktop.remoteConfig.get).toBe('function');
+        ctx.expect(typeof window.desktop.remoteConfig.refreshNow).toBe('function');
+        ctx.expect(typeof window.desktop.remoteConfig.onUpdate).toBe('function');
+      },
+    },
+    {
+      name: 'window.desktop.remoteConfig.onUpdate returns an unsub function',
+      run: (ctx) => {
+        const off = window.desktop.remoteConfig.onUpdate(() => {});
+        ctx.expect(typeof off).toBe('function');
+        off();
+      },
+    },
+  ],
+});

package/dist/test/suites/renderer/cross-context-helpers.test.js

@@ -0,0 +1,131 @@
+// Renderer-layer tests for the cross-context helpers (mode-helpers + url-helpers).
+// Verifies that `manager.isDevelopment / isProduction / isTesting / getVersion`
+// AND `manager.getEnvironment / getApiUrl / getFunctionsUrl / getWebsiteUrl` work
+// end-to-end inside a real renderer process, not just in main.
+//
+// The renderer-preload (test/harness/renderer-preload.js) instantiates a renderer
+// Manager and exposes its helpers via contextBridge as `window.__emTestManager`.
+// Test bodies are stringified + reconstructed via `new Function('ctx', body)` so
+// they only have access to `ctx` and `window` — no closures over module scope.
+
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'renderer',
+  description: 'cross-context helpers (renderer)',
+  tests: [
+    {
+      name: '__emTestManager is exposed by the test preload',
+      run: (ctx) => {
+        ctx.expect(typeof window.__emTestManager).toBe('object');
+        ctx.expect(window.__emTestManager).toBeTruthy();
+      },
+    },
+    {
+      name: 'isTesting() returns true (we are running under OMEGA_TEST_MODE=true)',
+      run: (ctx) => {
+        ctx.expect(window.__emTestManager.isTesting()).toBe(true);
+      },
+    },
+    {
+      name: 'isDevelopment() works (renderer has no app.isPackaged so it falls through)',
+      run: (ctx) => {
+        // In renderer process, `electron.app` is undefined, so the helper falls back
+        // to NODE_ENV / config.em.environment. The test harness seeds config with
+        // environment='production' so this should report false.
+        const v = window.__emTestManager.isDevelopment();
+        ctx.expect(typeof v).toBe('boolean');
+      },
+    },
+    {
+      name: 'environments are mutually exclusive — exactly one of dev/testing/prod is true',
+      run: (ctx) => {
+        const dev  = window.__emTestManager.isDevelopment();
+        const test = window.__emTestManager.isTesting();
+        const prod = window.__emTestManager.isProduction();
+        // We run under OMEGA_TEST_MODE=true → testing wins; dev and prod are both false.
+        ctx.expect(test).toBe(true);
+        ctx.expect(dev).toBe(false);
+        ctx.expect(prod).toBe(false);
+        ctx.expect([dev, test, prod].filter(Boolean).length).toBe(1);
+      },
+    },
+    {
+      name: 'getVersion() returns a string or null without throwing',
+      run: (ctx) => {
+        const v = window.__emTestManager.getVersion();
+        // In renderer, `electron.app` is unavailable and process.cwd()/package.json
+        // resolves to whatever the test harness was launched from — could be either
+        // a string or null. Assert just the shape.
+        ctx.expect(v === null || typeof v === 'string').toBe(true);
+      },
+    },
+    {
+      name: 'getEnvironment(): testing (OMEGA_TEST_MODE) takes precedence over config.em.environment',
+      run: (ctx) => {
+        // The test runner sets OMEGA_TEST_MODE=true, which wins over any config override —
+        // getEnvironment() always reports 'testing' here regardless of em.environment.
+        window.__emTestManager.setConfig('em.environment', 'production');
+        ctx.expect(window.__emTestManager.getEnvironment()).toBe('testing');
+        window.__emTestManager.setConfig('em.environment', 'development');
+        ctx.expect(window.__emTestManager.getEnvironment()).toBe('testing');
+        // Reset.
+        window.__emTestManager.setConfig('em.environment', 'production');
+      },
+    },
+    {
+      name: 'getFunctionsUrl: dev → localhost:5001/<projectId>/us-central1',
+      run: (ctx) => {
+        ctx.expect(window.__emTestManager.getFunctionsUrl('development'))
+          .toBe('http://localhost:5001/demo-app/us-central1');
+      },
+    },
+    {
+      name: 'getFunctionsUrl: prod → us-central1-<projectId>.cloudfunctions.net',
+      run: (ctx) => {
+        ctx.expect(window.__emTestManager.getFunctionsUrl('production'))
+          .toBe('https://us-central1-demo-app.cloudfunctions.net');
+      },
+    },
+    {
+      name: 'getApiUrl: dev → http://localhost:5002',
+      run: (ctx) => {
+        ctx.expect(window.__emTestManager.getApiUrl('development')).toBe('http://localhost:5002');
+      },
+    },
+    {
+      // wave-5 F9 (as amended cp268): API base rides brand.url, never
+      // authDomain — that value is an auth-only concern.
+      name: 'getApiUrl: prod → api.<brand.url host>',
+      run: (ctx) => {
+        ctx.expect(window.__emTestManager.getApiUrl('production'))
+          .toBe('https://api.example.com');
+      },
+    },
+    {
+      name: 'getWebsiteUrl: dev → the classic dev origin https://localhost:4000',
+      run: (ctx) => {
+        ctx.expect(window.__emTestManager.getWebsiteUrl('development')).toBe('https://localhost:4000');
+      },
+    },
+    {
+      name: 'getWebsiteUrl: prod → config.brand.url',
+      run: (ctx) => {
+        ctx.expect(window.__emTestManager.getWebsiteUrl('production')).toBe('https://example.com');
+      },
+    },
+    {
+      name: 'getWebsiteUrl: no-arg resolves local under testing; explicit arg overrides',
+      run: (ctx) => {
+        // The renderer always runs under OMEGA_TEST_MODE (testing wins), so the no-arg form
+        // correctly resolves LOCAL regardless of config — that's the safety guarantee.
+        window.__emTestManager.setConfig('em.environment', 'production');
+        ctx.expect(window.__emTestManager.getWebsiteUrl()).toBe('https://localhost:4000');
+        // An explicit env arg bypasses the current environment and pins the mapping.
+        ctx.expect(window.__emTestManager.getWebsiteUrl('production')).toBe('https://example.com');
+        ctx.expect(window.__emTestManager.getWebsiteUrl('development')).toBe('https://localhost:4000');
+      },
+    },
+  ],
+});