@omega.js/desktop 0.51.0 → 0.53.0

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

@@ -16,12 +16,12 @@ module.exports = defineCases({
   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');
+    ctx.omega.storage.delete('windows.settings.bounds');
+    ctx.omega.storage.delete('windows.about.bounds');
+    ctx.omega.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);
+      const w = ctx.omega.windows.get(name);
       if (w) {
         w._emForceClose = true;
         w.close();
@@ -32,33 +32,33 @@ module.exports = defineCases({
     {
       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();
+        ctx.omega.storage.delete('windows.bounds-test.bounds');
+        ctx.expect(ctx.omega.windows._loadBounds('bounds-test', ctx.omega)).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);
+        ctx.omega.storage.set('windows.bounds-test.bounds', saved);
+        ctx.expect(ctx.omega.windows._loadBounds('bounds-test', ctx.omega)).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.omega.storage.set('windows.bounds-test.bounds', { width: 'oops' });
+        ctx.expect(ctx.omega.windows._loadBounds('bounds-test', ctx.omega)).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();
+        ctx.omega.storage.set('windows.bounds-test.bounds', { width: 50, height: 50 }); // below sanity floor
+        ctx.expect(ctx.omega.windows._loadBounds('bounds-test', ctx.omega)).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({
+        const out = ctx.omega.windows._clampToDisplays({
           x: -99999, y: -99999, width: 800, height: 600,
         });
         ctx.expect(out.x).toBeUndefined();
@@ -71,7 +71,7 @@ module.exports = defineCases({
       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({
+        const out = ctx.omega.windows._clampToDisplays({
           x: 100, y: 100, width: 800, height: 600,
         });
         ctx.expect(out.x).toBe(100);
@@ -83,9 +83,9 @@ module.exports = defineCases({
       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);
+        ctx.omega.storage.set('windows.about.bounds', wanted);
 
-        const win = await ctx.manager.windows.createNamed('about');
+        const win = await ctx.omega.windows.createNamed('about');
         ctx.state.win = win;
         const got = win.getBounds();
         ctx.expect(got.width).toBe(720);
@@ -103,9 +103,9 @@ module.exports = defineCases({
 
         // Move + resize, then trigger save.
         win.setBounds({ x: 200, y: 220, width: 640, height: 480 });
-        ctx.manager.windows._saveBoundsNow('about');
+        ctx.omega.windows._saveBoundsNow('about');
 
-        const saved = ctx.manager.storage.get('windows.about.bounds');
+        const saved = ctx.omega.storage.get('windows.about.bounds');
         ctx.expect(saved).toBeTruthy();
         ctx.expect(saved.width).toBe(640);
         ctx.expect(saved.height).toBe(480);
@@ -123,10 +123,10 @@ module.exports = defineCases({
           if (win.isDestroyed()) return r();
           win.once('closed', r);
         });
-        ctx.manager.windows.close('about');
+        ctx.omega.windows.close('about');
         await closedPromise;
 
-        const saved = ctx.manager.storage.get('windows.about.bounds');
+        const saved = ctx.omega.storage.get('windows.about.bounds');
         ctx.expect(saved.width).toBe(555);
         ctx.expect(saved.height).toBe(444);
       },
@@ -135,13 +135,13 @@ module.exports = defineCases({
       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 });
+        ctx.omega.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 });
+          const win = await ctx.omega.windows.createNamed('about', undefined, { persistBounds: false });
 
           // Saved 999x888 must NOT have been restored — should fall back to config defaults.
           const got = win.getBounds();
@@ -149,19 +149,19 @@ module.exports = defineCases({
           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');
+          ctx.omega.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();
+          ctx.expect(ctx.omega.storage.get('windows.about.bounds')).toBeUndefined();
 
           const closedPromise = new Promise((r) => win.once('closed', r));
-          ctx.manager.windows.close('about');
+          ctx.omega.windows.close('about');
           await closedPromise;
 
           // close also must NOT have written under persistBounds:false.
-          ctx.expect(ctx.manager.storage.get('windows.about.bounds')).toBeUndefined();
+          ctx.expect(ctx.omega.storage.get('windows.about.bounds')).toBeUndefined();
         } finally {
-          ctx.manager.storage.delete('windows.about.bounds');
+          ctx.omega.storage.delete('windows.about.bounds');
         }
       },
     },

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

@@ -2,7 +2,7 @@
 //
 // 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
+// So we test the API surface and dedup behavior using the omega instance'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).
 
@@ -16,21 +16,21 @@ module.exports = defineCases({
     {
       name: 'initialize was called during boot',
       run: (ctx) => {
-        ctx.expect(ctx.manager.windows._initialized).toBe(true);
+        ctx.expect(ctx.omega.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);
+        ctx.expect(Array.isArray(ctx.omega.windows.list())).toBe(true);
+        ctx.expect(ctx.omega.windows.list().length).toBe(0);
       },
     },
     {
       name: 'get returns null for unknown name',
       run: (ctx) => {
-        ctx.expect(ctx.manager.windows.get('nonexistent')).toBeNull();
+        ctx.expect(ctx.omega.windows.get('nonexistent')).toBeNull();
       },
     },
     {
@@ -39,25 +39,25 @@ module.exports = defineCases({
         // 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');
+        const win = await ctx.omega.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');
+        ctx.expect(ctx.omega.windows.get('about')).toBe(win);
+        ctx.expect(ctx.omega.windows.list()).toContain('about');
       },
     },
     {
       name: 'createNamed dedups — second call returns the same window',
       run: async (ctx) => {
-        const again = await ctx.manager.windows.createNamed('about');
+        const again = await ctx.omega.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');
+        ctx.omega.windows.hide('about');
+        ctx.omega.windows.show('about');
         // No assertion beyond "didn't throw" — visibility is OS-side state we can't reliably read.
       },
     },
@@ -66,13 +66,13 @@ module.exports = defineCases({
       // 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;
+        const orig = ctx.omega.config.startup;
+        delete ctx.omega.config.startup;
         try {
-          ctx.manager.windows._maybeRehideDock(); // must not throw
-          ctx.expect(ctx.manager.startup.getMode()).toBe('normal');
+          ctx.omega.windows._maybeRehideDock(); // must not throw
+          ctx.expect(ctx.omega.startup.getMode()).toBe('normal');
         } finally {
-          if (orig !== undefined) ctx.manager.config.startup = orig;
+          if (orig !== undefined) ctx.omega.config.startup = orig;
         }
       },
     },
@@ -84,7 +84,7 @@ module.exports = defineCases({
         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)
+        // Both the harness entry (at require time) and omega.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');
@@ -96,10 +96,10 @@ module.exports = defineCases({
       run: (ctx) => {
         const { BrowserWindow } = require('electron');
 
-        ctx.expect(ctx.manager.windows._isStealth()).toBe(true);
+        ctx.expect(ctx.omega.windows._isStealth()).toBe(true);
 
         const win = new BrowserWindow({ show: false, width: 120, height: 80 });
-        ctx.manager.windows._surface(win, 'stealth-probe');
+        ctx.omega.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.
@@ -117,7 +117,7 @@ module.exports = defineCases({
 
         process.env.OMEGA_TEST_SHOW = '1';
         try {
-          ctx.expect(ctx.manager.windows._isStealth()).toBe(false);
+          ctx.expect(ctx.omega.windows._isStealth()).toBe(false);
 
           // This probe exercises the real non-stealth _surface branch WITHOUT
           // stealing the developer's keyboard focus mid-run. Two activation
@@ -133,7 +133,7 @@ module.exports = defineCases({
             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.omega.windows._surface(win, 'visible-probe');
 
           ctx.expect(win.isVisible()).toBe(true);
           ctx.expect(win.getOpacity()).toBe(1);
@@ -148,7 +148,7 @@ module.exports = defineCases({
         }
 
         // Flag removed → stealth is back on for the rest of the run.
-        ctx.expect(ctx.manager.windows._isStealth()).toBe(true);
+        ctx.expect(ctx.omega.windows._isStealth()).toBe(true);
       },
     },
     {
@@ -158,7 +158,7 @@ module.exports = defineCases({
           return; // trafficLightPosition is a macOS-only BrowserWindow option
         }
 
-        const win = await ctx.manager.windows.create('tlp-probe', { trafficLightPosition: { x: 26, y: 24 } });
+        const win = await ctx.omega.windows.create('tlp-probe', { trafficLightPosition: { x: 26, y: 24 } });
         ctx.expect(win).toBeTruthy();
 
         const pos = win.getWindowButtonPosition();
@@ -170,7 +170,7 @@ module.exports = defineCases({
     {
       name: 'close removes the window from the registry',
       run: async (ctx) => {
-        const win = ctx.manager.windows.get('about');
+        const win = ctx.omega.windows.get('about');
         ctx.expect(win).toBeTruthy();
 
         // close fires asynchronously — wait for the 'closed' event rather than guessing a timeout.
@@ -179,18 +179,18 @@ module.exports = defineCases({
           win.once('closed', resolve);
         });
 
-        ctx.manager.windows.close('about');
+        ctx.omega.windows.close('about');
         await closedPromise;
 
-        ctx.expect(ctx.manager.windows.get('about')).toBeNull();
+        ctx.expect(ctx.omega.windows.get('about')).toBeNull();
       },
     },
     {
-      name: 'manager.quit + manager.relaunch exposed and set _allowQuit',
+      name: 'omega.quit + omega.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;
+        ctx.expect(typeof ctx.omega.quit).toBe('function');
+        ctx.expect(typeof ctx.omega.relaunch).toBe('function');
+        ctx.omega._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
@@ -199,33 +199,33 @@ module.exports = defineCases({
         const origQuit = electron.app.quit;
         electron.app.quit = () => {};
         try {
-          ctx.manager.quit({ force: true });
-          ctx.expect(ctx.manager._allowQuit).toBe(true);
+          ctx.omega.quit({ force: true });
+          ctx.expect(ctx.omega._allowQuit).toBe(true);
         } finally {
           electron.app.quit = origQuit;
-          ctx.manager._allowQuit = false;
+          ctx.omega._allowQuit = false;
         }
       },
     },
     {
-      name: 'auto-updater installNow flips manager._allowQuit',
+      name: 'auto-updater installNow flips omega._allowQuit',
       run: (ctx) => {
-        ctx.manager._allowQuit = false;
+        ctx.omega._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: () => {} };
+        const prevState = ctx.omega.autoUpdater._state;
+        const prevLib   = ctx.omega.autoUpdater._library;
+        ctx.omega.autoUpdater._state = { code: 'downloaded', version: '9.9.9' };
+        ctx.omega.autoUpdater._library = { quitAndInstall: () => {} };
 
         try {
-          ctx.manager.autoUpdater.installNow();
-          ctx.expect(ctx.manager._allowQuit).toBe(true);
+          ctx.omega.autoUpdater.installNow();
+          ctx.expect(ctx.omega._allowQuit).toBe(true);
         } finally {
-          ctx.manager.autoUpdater._state   = prevState;
-          ctx.manager.autoUpdater._library = prevLib;
-          ctx.manager._allowQuit = false;
+          ctx.omega.autoUpdater._state   = prevState;
+          ctx.omega.autoUpdater._library = prevLib;
+          ctx.omega._allowQuit = false;
         }
       },
     },

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

@@ -38,15 +38,15 @@ module.exports = defineCases({
       },
     },
     {
-      // #411: a renderer's own `omega.analytics().event(...)` used to no-op
+      // #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',
+      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' });
+        window.__omegaTestClientAnalytics.event('vert_click', { vert_id: 'pin-411' });
 
         // The forward is fire-and-forget IPC — poll until main records it.
         let sends = [];
@@ -54,7 +54,7 @@ module.exports = defineCases({
         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())}`);
+          if (Date.now() - t0 > 3000) throw new Error(`timed out waiting for main to record the forwarded event, client state ${JSON.stringify(window.__omegaTestClientAnalytics.state())}`);
           await new Promise((r) => setTimeout(r, 25));
           sends = await read();
         }
@@ -79,7 +79,7 @@ module.exports = defineCases({
     {
       name: 'the bridged renderer holds no sender of its own — no secret, no second device id',
       run: (ctx) => {
-        const state = window.__emTestClientAnalytics.state();
+        const state = window.__omegaTestClientAnalytics.state();
         ctx.expect(state.initialized).toBe(true);
         ctx.expect(state.bridged).toBe(true);
         ctx.expect(state.secret).toBe(null);

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

@@ -1,12 +1,13 @@
-// 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
+// Renderer-layer tests for the cross-context helpers on the renderer `omega`
+// instance: `isDevelopment / isProduction / isTesting / getEnvironment` and
+// `getApiUrl / getFunctionsUrl` (the @omega.js/client base class's own), plus
+// desktop's `getVersion / getWebsiteUrl` (utils/mode-helpers + utils/url-helpers),
 // 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`.
+// The renderer-preload (test/harness/renderer-preload.js) builds the real renderer
+// instance and exposes its helpers via contextBridge as `window.__omegaTestInstance`.
 // Test bodies are stringified + reconstructed via `new Function('ctx', body)` so
-// they only have access to `ctx` and `window` — no closures over module scope.
+// they only have access to `ctx` and `window`, no closures over module scope.
 
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
 
@@ -16,16 +17,19 @@ module.exports = defineCases({
   description: 'cross-context helpers (renderer)',
   tests: [
     {
-      name: '__emTestManager is exposed by the test preload',
+      name: '__omegaTestInstance is exposed by the test preload, over a built instance',
       run: (ctx) => {
-        ctx.expect(typeof window.__emTestManager).toBe('object');
-        ctx.expect(window.__emTestManager).toBeTruthy();
+        ctx.expect(typeof window.__omegaTestInstance).toBe('object');
+        ctx.expect(window.__omegaTestInstance).toBeTruthy();
+        if (!window.__omegaTestInstance.built()) {
+          throw new Error(`the renderer instance did not build: ${window.__omegaTestInstance.error()}`);
+        }
       },
     },
     {
       name: 'isTesting() returns true (this lane named OMEGA_ENVIRONMENT=testing)',
       run: (ctx) => {
-        ctx.expect(window.__emTestManager.isTesting()).toBe(true);
+        ctx.expect(window.__omegaTestInstance.isTesting()).toBe(true);
       },
     },
     {
@@ -34,7 +38,7 @@ module.exports = defineCases({
         // Nothing here reads app.isPackaged or NODE_ENV any more (#817): the
         // preload has a process, so the lane's OMEGA_ENVIRONMENT answers, and a
         // real renderer bundle answers from the baked config.environment.
-        const v = window.__emTestManager.isDevelopment();
+        const v = window.__omegaTestInstance.isDevelopment();
         ctx.expect(typeof v).toBe('boolean');
         ctx.expect(v).toBe(false);
       },
@@ -42,9 +46,9 @@ module.exports = defineCases({
     {
       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();
+        const dev  = window.__omegaTestInstance.isDevelopment();
+        const test = window.__omegaTestInstance.isTesting();
+        const prod = window.__omegaTestInstance.isProduction();
         // This lane named testing; dev and prod are both false.
         ctx.expect(test).toBe(true);
         ctx.expect(dev).toBe(false);
@@ -55,7 +59,7 @@ module.exports = defineCases({
     {
       name: 'getVersion() returns a string or null without throwing',
       run: (ctx) => {
-        const v = window.__emTestManager.getVersion();
+        const v = window.__omegaTestInstance.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.
@@ -69,32 +73,34 @@ module.exports = defineCases({
         // process to read it from, so it wins over whatever the artifact was
         // baked as (#817). A real renderer bundle has no process and takes the
         // baked word, which is the other half of the same one-input rule.
-        window.__emTestManager.setConfig('environment', 'production');
-        ctx.expect(window.__emTestManager.getEnvironment()).toBe('testing');
-        window.__emTestManager.setConfig('environment', 'development');
-        ctx.expect(window.__emTestManager.getEnvironment()).toBe('testing');
+        window.__omegaTestInstance.setConfig('environment', 'production');
+        ctx.expect(window.__omegaTestInstance.getEnvironment()).toBe('testing');
+        window.__omegaTestInstance.setConfig('environment', 'development');
+        ctx.expect(window.__omegaTestInstance.getEnvironment()).toBe('testing');
         // Reset.
-        window.__emTestManager.setConfig('environment', 'production');
+        window.__omegaTestInstance.setConfig('environment', 'production');
       },
     },
     {
       name: 'getFunctionsUrl: dev → localhost:5001/<projectId>/us-central1',
       run: (ctx) => {
-        ctx.expect(window.__emTestManager.getFunctionsUrl('development'))
+        ctx.expect(window.__omegaTestInstance.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'))
+        ctx.expect(window.__omegaTestInstance.getFunctionsUrl('production'))
           .toBe('https://us-central1-demo-app.cloudfunctions.net');
       },
     },
     {
-      name: 'getApiUrl: dev → http://localhost:5002',
+      // The client's own getApiUrl, the one `omega.request()` calls: a baked
+      // `hosting` port with no `https` one is the emulator on 127.0.0.1
+      name: 'getApiUrl: dev → http://127.0.0.1:5002 (the client base class answers)',
       run: (ctx) => {
-        ctx.expect(window.__emTestManager.getApiUrl('development')).toBe('http://localhost:5002');
+        ctx.expect(window.__omegaTestInstance.getApiUrl('development')).toBe('http://127.0.0.1:5002');
       },
     },
     {
@@ -102,20 +108,20 @@ module.exports = defineCases({
       // authDomain — that value is an auth-only concern.
       name: 'getApiUrl: prod → api.<brand.url host>',
       run: (ctx) => {
-        ctx.expect(window.__emTestManager.getApiUrl('production'))
+        ctx.expect(window.__omegaTestInstance.getApiUrl('production'))
           .toBe('https://api.example.com');
       },
     },
     {
       name: 'getWebsiteUrl: dev → https://localhost:4000, from the baked classic map',
       run: (ctx) => {
-        ctx.expect(window.__emTestManager.getWebsiteUrl('development')).toBe('https://localhost:4000');
+        ctx.expect(window.__omegaTestInstance.getWebsiteUrl('development')).toBe('https://localhost:4000');
       },
     },
     {
       name: 'getWebsiteUrl: prod → config.brand.url',
       run: (ctx) => {
-        ctx.expect(window.__emTestManager.getWebsiteUrl('production')).toBe('https://example.com');
+        ctx.expect(window.__omegaTestInstance.getWebsiteUrl('production')).toBe('https://example.com');
       },
     },
     {
@@ -123,11 +129,11 @@ module.exports = defineCases({
       run: (ctx) => {
         // This lane is testing, so the no-arg form resolves LOCAL regardless of
         // what the artifact was baked as: that's the safety guarantee.
-        window.__emTestManager.setConfig('environment', 'production');
-        ctx.expect(window.__emTestManager.getWebsiteUrl()).toBe('https://localhost:4000');
+        window.__omegaTestInstance.setConfig('environment', 'production');
+        ctx.expect(window.__omegaTestInstance.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');
+        ctx.expect(window.__omegaTestInstance.getWebsiteUrl('production')).toBe('https://example.com');
+        ctx.expect(window.__omegaTestInstance.getWebsiteUrl('development')).toBe('https://localhost:4000');
       },
     },
   ],

package/dist/test/suites/renderer/round-trip.test.js

@@ -37,7 +37,7 @@ module.exports = defineCases({
     {
       name: 'window.desktop.logger.log forwards to main where it can be read back',
       run: async (ctx) => {
-        const marker = `__em_test_log_${Date.now()}_${Math.random()}`;
+        const marker = `__omega_test_log_${Date.now()}_${Math.random()}`;
         window.desktop.logger.log(marker, { extra: 'payload' });
         // Give main a moment to receive (IPC send is async, no callback).
         await new Promise((r) => setTimeout(r, 50));
@@ -53,7 +53,7 @@ module.exports = defineCases({
     {
       name: 'window.desktop.logger.warn also forwards',
       run: async (ctx) => {
-        const marker = `__em_test_warn_${Date.now()}_${Math.random()}`;
+        const marker = `__omega_test_warn_${Date.now()}_${Math.random()}`;
         window.desktop.logger.warn(marker);
         await new Promise((r) => setTimeout(r, 50));
         const last = await window.desktop.ipc.invoke('desktop:__test:read-last-log');
@@ -65,7 +65,7 @@ module.exports = defineCases({
       name: 'window.desktop.storage.set → window.desktop.storage.onChange fires across IPC',
       run: async (ctx) => {
         // Subscribe FIRST so we don't miss the broadcast.
-        const key = `__em_renderer_change_${Date.now()}`;
+        const key = `__omega_renderer_change_${Date.now()}`;
         let received = null;
         const off = window.desktop.storage.onChange(key, (payload) => { received = payload; });
         try {