@omega.js/desktop 0.50.0 → 0.51.0

package/dist/test/suites/build/validate-config.test.js

@@ -56,11 +56,11 @@ module.exports = defineCases({
       },
     },
     {
-      name: 'platforms.win.signing.strategy enum enforced under desktop',
+      name: 'platforms.windows.signing.strategy enum enforced under desktop',
       run: (ctx) => {
-        const cfg = { ...VALID, platforms: { win: { signing: { strategy: 'banana' } } } };
+        const cfg = { ...VALID, platforms: { windows: { signing: { strategy: 'banana' } } } };
         const { errors } = validateConfig(cfg, { target: 'desktop' });
-        ctx.expect(errors.some((e) => e.includes('platforms.win.signing.strategy'))).toBe(true);
+        ctx.expect(errors.some((e) => e.includes('platforms.windows.signing.strategy'))).toBe(true);
       },
     },
     {

package/dist/test/suites/main/auth-flow.test.js

@@ -20,17 +20,28 @@ function get(url) {
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
 // Stub the externals for one test body. Returns { opened, tokens, shown, restore }.
+//
+// The baked `dev` block is staged too: the sign-in chain starts at
+// getWebsiteUrl(), which since
+// [#834](https://github.com/Omega-JS-Stack/omega/issues/834) answers from the
+// resolved dev map the bundle task bakes (whose floor is @omega.js/config's
+// classic numbers) and throws when an artifact carries none. The harness manager
+// loads src/defaults' config, which has no build behind it, so a real dev
+// artifact's block is stated here.
 function stubExternals(ctx) {
   const electron = require('electron');
+  const { CLASSIC_PORTS } = require('../../../vendor/config/index.js');
   const opened = [];
   const tokens = [];
   const shown = [];
   const origOpen = electron.shell.openExternal;
   const origHandle = ctx.manager.omega.handleAuthToken;
   const origShow = ctx.manager.windows.show;
+  const origDev = ctx.manager.config.dev;
   electron.shell.openExternal = async (url) => { opened.push(url); };
   ctx.manager.omega.handleAuthToken = (t) => { tokens.push(t); };
   ctx.manager.windows.show = (name) => { shown.push(name); };
+  ctx.manager.config.dev = { ports: { ...CLASSIC_PORTS } };
   return {
     opened,
     tokens,
@@ -39,6 +50,7 @@ function stubExternals(ctx) {
       electron.shell.openExternal = origOpen;
       ctx.manager.omega.handleAuthToken = origHandle;
       ctx.manager.windows.show = origShow;
+      if (origDev !== undefined) ctx.manager.config.dev = origDev; else delete ctx.manager.config.dev;
       ctx.manager.authFlow.cancel();
     },
   };

package/dist/test/suites/main/auth-persistence.test.js

@@ -25,22 +25,24 @@ module.exports = defineCases({
   description: 'auth-persistence (main)',
   tests: [
     {
-      name: 'resolve(): default is safeStorage; explicit none disables; unknown warns to null',
+      name: 'resolve(): a test run is none, whatever the config says',
       run: async (ctx) => {
         const m = ctx.manager;
+        ctx.expect(m.isTesting()).toBe(true);
         m.config.omega = m.config.omega || {};
         const orig = m.config.omega.authPersistence;
         try {
+          // Unset, and explicitly asking for the vault, both land on none: the harness
+          // never signs a real user in, so it never asks the OS keychain
+          // ([#907](https://github.com/Omega-JS-Stack/omega/issues/907)).
           delete m.config.omega.authPersistence;
-          const def = await authPersistence.resolve(m);
-          // Default resolves to safeStorage when the OS vault is available, null otherwise —
-          // both are valid environments; assert it never picks something else.
-          if (def) ctx.expect(def.name).toBe('safeStorage');
+          ctx.expect(await authPersistence.resolve(m)).toBeNull();
+          ctx.expect(authPersistence.getActive()).toBeNull();
 
-          m.config.omega.authPersistence = 'none';
+          m.config.omega.authPersistence = 'safeStorage';
           ctx.expect(await authPersistence.resolve(m)).toBeNull();
 
-          m.config.omega.authPersistence = 'does-not-exist';
+          m.config.omega.authPersistence = 'none';
           ctx.expect(await authPersistence.resolve(m)).toBeNull();
         } finally {
           if (orig !== undefined) m.config.omega.authPersistence = orig;
@@ -50,23 +52,18 @@ module.exports = defineCases({
       },
     },
     {
-      name: 'register(): validates the strategy surface and makes it selectable',
+      name: 'register(): validates the strategy surface and adds it to the registry',
       run: async (ctx) => {
-        const m = ctx.manager;
         ctx.expect(() => authPersistence.register('bad', {})).toThrow(/must implement/);
 
         authPersistence.register('desktop-test-custom', fakeStrategy());
-        m.config.omega = m.config.omega || {};
-        const orig = m.config.omega.authPersistence;
         try {
-          m.config.omega.authPersistence = 'desktop-test-custom';
-          const active = await authPersistence.resolve(m);
-          ctx.expect(active.name).toBe('desktop-test-custom');
+          // Selection by config is proven at the build layer, on a production manager:
+          // under test mode resolve() answers none before it reads a thing.
+          ctx.expect(authPersistence._strategies['desktop-test-custom'].name).toBe('desktop-test-custom');
+          ctx.expect(await authPersistence._strategies['desktop-test-custom'].available()).toBe(true);
         } finally {
-          if (orig !== undefined) m.config.omega.authPersistence = orig;
-          else delete m.config.omega.authPersistence;
           delete authPersistence._strategies['desktop-test-custom'];
-          await authPersistence.resolve(m);
         }
       },
     },

package/dist/test/suites/main/auto-updater.test.js

@@ -1006,7 +1006,7 @@ module.exports = defineCases({
     // ─── Mode helpers (@omega.js/backend-pattern: isDevelopment / isProduction / isTesting) ────
 
     {
-      name: 'manager.isTesting() returns true under OMEGA_TEST_MODE (set by test runner)',
+      name: 'manager.isTesting() returns true under OMEGA_ENVIRONMENT=testing (named by the test runner)',
       run: (ctx) => {
         ctx.expect(typeof ctx.manager.isTesting).toBe('function');
         ctx.expect(ctx.manager.isTesting()).toBe(true);
@@ -1015,7 +1015,7 @@ module.exports = defineCases({
     {
       name: 'manager.isDevelopment() is false during tests (testing takes precedence)',
       run: (ctx) => {
-        // The test runs unpackaged, but OMEGA_TEST_MODE=true → testing wins, so this is a
+        // The test runs unpackaged, but the lane named testing, so this is a
         // TEST environment, not development. isDevelopment() is therefore false.
         ctx.expect(typeof ctx.manager.isDevelopment).toBe('function');
         ctx.expect(ctx.manager.isDevelopment()).toBe(false);

package/dist/test/suites/main/boot-sequence.test.js

@@ -69,7 +69,7 @@ module.exports = defineCases({
     {
       name: 'getEnvironment returns testing under the test harness',
       run: (ctx) => {
-        // The harness spawn sets OMEGA_TEST_MODE=true → testing wins over everything.
+        // The harness spawn names OMEGA_ENVIRONMENT=testing, the one input.
         ctx.expect(ctx.manager.getEnvironment()).toBe('testing');
       },
     },

package/dist/test/suites/main/client-bridge.integration.test.js

@@ -1,23 +1,14 @@
 // Integration tests for client-bridge — actually hits Firebase.
 //
-// Skipped automatically unless OMEGA_TEST_FIREBASE_ADMIN_KEY (or GOOGLE_APPLICATION_CREDENTIALS)
-// points to a Firebase service-account JSON file. This keeps `npx omega test` fast & green
-// offline / on machines without backend creds.
+// The SIGN-IN proof lives in #904: web, desktop and extension each sign in as a
+// persona the backend emulator seeds, so this suite no longer mints a custom
+// token from a service account and asks a brand for no test credential at all.
 //
-// To run:
-//   1. Install firebase-admin: `npm i -D firebase-admin` (already in @omega.js/desktop's devDeps)
-//   2. Drop a service-account JSON in a safe place
-//   3. Set OMEGA_TEST_FIREBASE_ADMIN_KEY=/path/to/file.json (or use GOOGLE_APPLICATION_CREDENTIALS)
-//   4. Optionally OMEGA_TEST_USER_UID=your-test-uid (defaults to 'desktop-test-user')
-//   5. `npx omega test`
+// To run: `npx omega test --extended` (the cases below need a cloud.config in
+// src/defaults/config/omega.json5 to have any Firebase to talk to).
 
-const fs = require('fs');
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
 
-const ADMIN_KEY = process.env.OMEGA_TEST_FIREBASE_ADMIN_KEY
-                || process.env.GOOGLE_APPLICATION_CREDENTIALS
-                || null;
-const USER_UID = process.env.OMEGA_TEST_USER_UID || 'desktop-test-user';
 // These hit REAL Firebase, so they're gated behind extended mode (the cross-framework
 // `TEST_EXTENDED_MODE` opt-in). `npx omega test --extended` (or TEST_EXTENDED_MODE=true) runs
 // them; default is skip so `npx omega test` stays fast + offline-safe.
@@ -26,13 +17,6 @@ const EXTENDED_OPTED_IN = process.env.TEST_EXTENDED_MODE === 'true'
 
 function checkSkipReason() {
   if (!EXTENDED_OPTED_IN) return 'extended tests skipped — pass --extended or set TEST_EXTENDED_MODE=true';
-  if (!ADMIN_KEY) return 'no OMEGA_TEST_FIREBASE_ADMIN_KEY / GOOGLE_APPLICATION_CREDENTIALS';
-  if (!fs.existsSync(ADMIN_KEY)) return `service-account file not found at ${ADMIN_KEY}`;
-  try {
-    require.resolve('firebase-admin');
-  } catch (e) {
-    return 'firebase-admin not installed (run: npm i -D firebase-admin)';
-  }
   return null;
 }
 
@@ -58,37 +42,6 @@ module.exports = defineCases({
         ctx.expect(ctx.manager.omega._firebaseAuth).toBeTruthy();
       },
     },
-    {
-      name: 'admin can mint a custom token, bridge can sign in with it',
-      run: async (ctx) => {
-        if (!ctx.manager.omega._firebaseAuth) {
-          ctx.skip('firebase not loaded');
-        }
-
-        const admin = require('firebase-admin');
-        if (!admin.apps.length) {
-          admin.initializeApp({
-            credential: admin.credential.cert(require(ADMIN_KEY)),
-          });
-        }
-
-        // Mint a custom token for the test UID.
-        const token = await admin.auth().createCustomToken(USER_UID);
-        ctx.expect(typeof token).toBe('string');
-
-        // Hand it to the bridge.
-        const result = await ctx.manager.omega.handleAuthToken(token);
-
-        if (!result.success) {
-          ctx.skip(`signInWithCustomToken failed: ${result.error || 'unknown'} — likely a project mismatch (cloud.config.projectId vs service-account project)`);
-        }
-        ctx.expect(result.user.uid).toBe(USER_UID);
-
-        // Bridge state should reflect the signed-in user.
-        const current = ctx.manager.omega.getCurrentUser();
-        ctx.expect(current?.uid).toBe(USER_UID);
-      },
-    },
     {
       name: 'sign-out clears the current user and broadcasts',
       run: async (ctx) => {
@@ -100,35 +53,5 @@ module.exports = defineCases({
         ctx.expect(ctx.manager.omega.getCurrentUser()).toBeNull();
       },
     },
-    {
-      name: 'onAuthChange fires when state changes',
-      run: async (ctx) => {
-        if (!ctx.manager.omega._firebaseAuth) {
-          ctx.skip('firebase not loaded');
-        }
-
-        const admin = require('firebase-admin');
-        if (!admin.apps.length) {
-          admin.initializeApp({
-            credential: admin.credential.cert(require(ADMIN_KEY)),
-          });
-        }
-
-        const calls = [];
-        const off = ctx.manager.omega.onAuthChange((snap) => calls.push(snap));
-
-        try {
-          const token = await admin.auth().createCustomToken(USER_UID);
-          await ctx.manager.omega.handleAuthToken(token);
-
-          // Give onAuthStateChanged a tick to fire.
-          await new Promise((r) => setTimeout(r, 200));
-          ctx.expect(calls.length).toBeGreaterThan(0);
-          ctx.expect(calls[calls.length - 1]?.uid).toBe(USER_UID);
-        } finally {
-          off();
-        }
-      },
-    },
   ],
 });

package/dist/test/suites/main/client-bridge.test.js

@@ -1,7 +1,8 @@
 // Main-process tests for lib/client-bridge.js — unit-level coverage that doesn't hit Firebase.
 //
 // Real Firebase integration tests live in client-bridge.integration.test.js
-// (gated on OMEGA_TEST_FIREBASE_ADMIN_KEY presence).
+// (gated on extended mode); the sign-in proof itself is #904's, through a
+// persona the backend emulator seeds.
 
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
 
@@ -187,10 +188,10 @@ module.exports = defineCases({
           connectAuthEmulator: (auth, url, opts) => connects.push({ auth, url, opts }),
         };
 
-        const run = (isTesting) => {
+        const run = (isTesting, dev) => {
           bridge._firebaseAuth = null;
           bridge._manager = {
-            config: { cloud: { config: { apiKey: 'AIza-test', projectId: 'demo-desktop' } } },
+            config: { cloud: { config: { apiKey: 'AIza-test', projectId: 'demo-desktop' } }, ...(dev ? { dev } : {}) },
             isTesting: () => isTesting,
           };
           return bridge._getFirebaseAuth(null);
@@ -203,17 +204,29 @@ module.exports = defineCases({
           ctx.expect(run(false)).toBe(authInstance);
           ctx.expect(connects.length).toBe(0);
 
-          // testing shape — classic 9099 when no resolved port is on the env channel
-          ctx.expect(run(true)).toBe(authInstance);
+          // testing shape: the port comes from the map the bundle baked, which
+          // carries @omega.js/config's classic 9099 as its floor
+          // ([#834](https://github.com/Omega-JS-Stack/omega/issues/834)).
+          ctx.expect(run(true, { ports: { auth: 9099 } })).toBe(authInstance);
           ctx.expect(connects.length).toBe(1);
           ctx.expect(connects[0].auth).toBe(authInstance);
           ctx.expect(connects[0].url).toBe('http://localhost:9099');
 
           // a bumped port arrives on OMEGA_AUTH_PORT (N7)
           process.env.OMEGA_AUTH_PORT = '9199';
-          run(true);
+          run(true, { ports: { auth: 9099 } });
           ctx.expect(connects.length).toBe(2);
           ctx.expect(connects[1].url).toBe('http://localhost:9199');
+
+          // Neither channel is a broken artifact, and it says so by name
+          // rather than dialling a port nothing identity-checks (#834).
+          delete process.env.OMEGA_AUTH_PORT;
+          let threw;
+          try { run(true); } catch (e) { threw = e; }
+          ctx.expect(threw).toBeDefined();
+          ctx.expect(threw.message).toMatch(/dev port for `auth`/);
+          ctx.expect(threw.message).toMatch(/bundle task/);
+          ctx.expect(connects.length).toBe(2);
         } finally {
           bridge._firebase       = saved.firebase;
           bridge._firebaseModule = saved.module;

package/dist/test/suites/main/deep-link.test.js

@@ -270,6 +270,60 @@ module.exports = defineCases({
         }
       },
     },
+    {
+      // #921: Electron re-serializes the duplicate's command line before second-instance
+      // fires (switches first, values detached at the end), so the duplicate's REAL argv
+      // rides along in additionalData. The event list below carries no url on purpose, so
+      // the case can only pass by reading the fourth argument.
+      name: 'second-instance reads argv/cwd from additionalData when it rides along',
+      run: (ctx) => {
+        const brandId = ctx.manager.config.brand.id;
+        const url = `${brandId}://dup/launch?k=v`;
+        let received;
+        const off = ctx.manager.deepLink.on('dup/launch', (c) => { received = c; });
+
+        try {
+          ctx.manager.protocol._electron.app.emit(
+            'second-instance',
+            {},
+            ['/bin/app', '--title', '--message', '--allow-file-access-from-files', 'B', 'two'],
+            '/x',
+            { argv: ['/bin/app', '--title', 'B', url], cwd: '/y' },
+          );
+
+          ctx.expect(received).toBeTruthy();
+          ctx.expect(received.url).toBe(url);
+          ctx.expect(received.route).toBe('dup/launch');
+          ctx.expect(received.query).toEqual({ k: 'v' });
+          ctx.expect(received.source).toBe('warm-start');
+          ctx.expect(received.argv).toEqual(['/bin/app', '--title', 'B', url]);
+          ctx.expect(received.cwd).toBe('/y');
+        } finally {
+          off();
+        }
+      },
+    },
+    {
+      // A duplicate built before #921 passes no object, so the event's own argv still dispatches.
+      name: 'second-instance falls back to the event argv when no additionalData rides along',
+      run: (ctx) => {
+        const brandId = ctx.manager.config.brand.id;
+        const url = `${brandId}://dup/fallback?k=v`;
+        let received;
+        const off = ctx.manager.deepLink.on('dup/fallback', (c) => { received = c; });
+
+        try {
+          ctx.manager.protocol._electron.app.emit('second-instance', {}, ['/bin/app', url], '/z');
+
+          ctx.expect(received).toBeTruthy();
+          ctx.expect(received.url).toBe(url);
+          ctx.expect(received.argv).toEqual(['/bin/app', url]);
+          ctx.expect(received.cwd).toBe('/z');
+        } finally {
+          off();
+        }
+      },
+    },
     {
       name: 'handler errors do not stop subsequent handlers',
       run: (ctx) => {

package/dist/test/suites/main/startup-paths-and-ua.test.js

@@ -18,7 +18,7 @@ module.exports = defineCases({
       run: (ctx) => {
         const { app } = require('electron');
         const userData = app.getPath('userData');
-        // OMEGA_TEST_MODE=true → isTesting() → dedicated " (Testing)" dir, wiped at
+        // OMEGA_ENVIRONMENT=testing → isTesting() → dedicated " (Testing)" dir, wiped at
         // boot, so test runs never read or pollute dev ("(Development)") or
         // production data on the same machine.
         ctx.expect(typeof userData).toBe('string');

package/dist/test/suites/main/url-helpers.test.js

@@ -5,17 +5,19 @@
 // The manager (already bootstrapped by the test harness) is the natural object under test.
 
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+const { CLASSIC_PORTS, CLASSIC_DEV_ORIGIN } = require('../../../vendor/config/index.js');
 
-// Every case that pins a CLASSIC local answer silences the whole baked `dev`
-// block: the `dev.ports` map (#745) and the `dev.origin` the website publishes
-// (#747). The harness manager loads src/defaults' config, which carries no `dev`
-// block, so today this is a no-op guard; it exists so a harness that one day
-// seeds a real build blob cannot turn these classic pins red.
-function withoutBakedPorts(manager, fn) {
+// Every case that pins a CLASSIC local answer states the baked `dev` block a
+// real dev artifact carries: since
+// [#834](https://github.com/Omega-JS-Stack/omega/issues/834) the bundle task
+// bakes the classic map as the FLOOR of the resolved one, so the classics reach
+// these helpers the way they reach a shipped dev build, from @omega.js/config,
+// and no copy of the numbers lives in this file or in url-helpers.js.
+function withClassicBakedPorts(manager, fn) {
   const original = manager.config.dev;
-  delete manager.config.dev;
+  manager.config.dev = { ports: { ...CLASSIC_PORTS } };
   try { return fn(); } finally {
-    if (original !== undefined) manager.config.dev = original;
+    if (original !== undefined) manager.config.dev = original; else delete manager.config.dev;
   }
 }
 
@@ -25,54 +27,62 @@ module.exports = defineCases({
   description: 'url-helpers (cross-context)',
   tests: [
     {
-      name: 'getEnvironment: testing (OMEGA_TEST_MODE) wins; else config.em.environment',
+      // The environment reads ONE input
+      // ([#817](https://github.com/Omega-JS-Stack/omega/issues/817)): the
+      // `OMEGA_ENVIRONMENT` variable the lane set, and the baked
+      // `config.environment` when the process has none (a packaged app, which
+      // has no parent lane to inherit from). The legacy `config.em.environment`
+      // override is gone with the copy that read it, and so are the
+      // app.isPackaged / OMEGA_BUILD_MODE / NODE_ENV sniffs.
+      name: 'getEnvironment: the process input, then the baked config.environment',
       run: (ctx) => {
         const m = ctx.manager;
-        const orig = m.config?.em?.environment;
-        const origTest = process.env.OMEGA_TEST_MODE;
-        m.config.em = m.config.em || {};
+        const origConfigEnv = m.config.environment;
+        const origVar = process.env.OMEGA_ENVIRONMENT;
         try {
-          // Testing takes precedence over the config override.
-          process.env.OMEGA_TEST_MODE = 'true';
-          m.config.em.environment = 'production';
-          ctx.expect(m.getEnvironment()).toBe('testing');
-          // With testing cleared, the config override is honored.
-          delete process.env.OMEGA_TEST_MODE;
-          m.config.em.environment = 'development';
-          ctx.expect(m.getEnvironment()).toBe('development');
-          m.config.em.environment = 'production';
-          ctx.expect(m.getEnvironment()).toBe('production');
+          // The lane's variable is the answer wherever it exists.
+          m.config.environment = 'production';
+          for (const name of ['development', 'testing', 'production']) {
+            process.env.OMEGA_ENVIRONMENT = name;
+            ctx.expect(m.getEnvironment()).toBe(name);
+          }
+
+          // With no variable, the artifact's own baked word answers.
+          delete process.env.OMEGA_ENVIRONMENT;
+          for (const name of ['development', 'testing', 'production']) {
+            m.config.environment = name;
+            ctx.expect(m.getEnvironment()).toBe(name);
+          }
+
+          // Neither is a loud error, never a default.
+          delete m.config.environment;
+          let threw;
+          try { m.getEnvironment(); } catch (e) { threw = e; }
+          ctx.expect(threw).toBeDefined();
+          ctx.expect(threw.message).toMatch(/OMEGA_ENVIRONMENT/);
         } finally {
-          m.config.em.environment = orig;
-          if (origTest === undefined) delete process.env.OMEGA_TEST_MODE; else process.env.OMEGA_TEST_MODE = origTest;
+          if (origConfigEnv !== undefined) m.config.environment = origConfigEnv; else delete m.config.environment;
+          if (origVar !== undefined) process.env.OMEGA_ENVIRONMENT = origVar; else delete process.env.OMEGA_ENVIRONMENT;
         }
       },
     },
     {
-      // In the MAIN process, app.isPackaged is the authoritative signal and beats the
-      // OMEGA_BUILD_MODE fallback. The test harness is unpackaged, so once testing + config are
-      // cleared, getEnvironment() resolves to 'development' from app.isPackaged === false —
-      // regardless of OMEGA_BUILD_MODE. (The OMEGA_BUILD_MODE fallback only applies where `app` is
-      // unavailable: renderer / preload / plain Node — covered by the build-layer manager test.)
-      name: 'getEnvironment: app.isPackaged (unpackaged → development) wins over OMEGA_BUILD_MODE in main',
+      // The three checks DERIVE from getEnvironment(), on the REAL main-process
+      // Manager, so they can never disagree with it.
+      name: 'the three is*() checks derive from it, and exactly one is true',
       run: (ctx) => {
         const m = ctx.manager;
-        const origEnv  = m.config?.em?.environment;
-        const origBuild = process.env.OMEGA_BUILD_MODE;
-        const origTest = process.env.OMEGA_TEST_MODE;
-        if (m.config.em) delete m.config.em.environment;
-        delete process.env.OMEGA_TEST_MODE; // isolate from testing precedence
+        const origVar = process.env.OMEGA_ENVIRONMENT;
         try {
-          // Unpackaged harness → 'development' even with OMEGA_BUILD_MODE set (app.isPackaged wins).
-          process.env.OMEGA_BUILD_MODE = 'true';
-          ctx.expect(m.getEnvironment()).toBe('development');
-          delete process.env.OMEGA_BUILD_MODE;
-          ctx.expect(m.getEnvironment()).toBe('development');
+          for (const name of ['development', 'testing', 'production']) {
+            process.env.OMEGA_ENVIRONMENT = name;
+            ctx.expect(m.isDevelopment()).toBe(name === 'development');
+            ctx.expect(m.isTesting()).toBe(name === 'testing');
+            ctx.expect(m.isProduction()).toBe(name === 'production');
+            ctx.expect([m.isDevelopment(), m.isTesting(), m.isProduction()].filter(Boolean).length).toBe(1);
+          }
         } finally {
-          if (origEnv !== undefined) m.config.em.environment = origEnv;
-          if (origBuild !== undefined) process.env.OMEGA_BUILD_MODE = origBuild;
-          else delete process.env.OMEGA_BUILD_MODE;
-          if (origTest !== undefined) process.env.OMEGA_TEST_MODE = origTest;
+          if (origVar !== undefined) process.env.OMEGA_ENVIRONMENT = origVar; else delete process.env.OMEGA_ENVIRONMENT;
         }
       },
     },
@@ -85,7 +95,7 @@ module.exports = defineCases({
         const orig = m.config.cloud.config.projectId;
         m.config.cloud.config.projectId = 'demo-app';
         try {
-          withoutBakedPorts(m, () => {
+          withClassicBakedPorts(m, () => {
             ctx.expect(m.getFunctionsUrl('development')).toBe('http://localhost:5001/demo-app/us-central1');
           });
         } finally { m.config.cloud.config.projectId = orig; }
@@ -121,14 +131,14 @@ module.exports = defineCases({
       },
     },
     {
-      name: 'getApiUrl: dev returns http://localhost:5002 (no published ports)',
+      name: 'getApiUrl: dev returns http://localhost:5002 from the baked classic map',
       run: (ctx) => {
         const origHttps = process.env.OMEGA_HTTPS_PORT;
         const origHosting = process.env.OMEGA_HOSTING_PORT;
         delete process.env.OMEGA_HTTPS_PORT;
         delete process.env.OMEGA_HOSTING_PORT;
         try {
-          withoutBakedPorts(ctx.manager, () => {
+          withClassicBakedPorts(ctx.manager, () => {
             ctx.expect(ctx.manager.getApiUrl('development')).toBe('http://localhost:5002');
           });
         } finally {
@@ -147,7 +157,7 @@ module.exports = defineCases({
         delete process.env.OMEGA_HTTPS_PORT;
         delete process.env.OMEGA_HOSTING_PORT;
         try {
-          withoutBakedPorts(ctx.manager, () => {
+          withClassicBakedPorts(ctx.manager, () => {
             ctx.expect(ctx.manager.getApiUrl('testing')).toBe('http://localhost:5002');
           });
         } finally {
@@ -243,12 +253,12 @@ module.exports = defineCases({
       },
     },
     {
-      name: 'getWebsiteUrl: dev returns the classic dev origin https://localhost:4000',
+      name: 'getWebsiteUrl: dev returns https://localhost:4000 from the baked classic map',
       run: (ctx) => {
         const orig = process.env.OMEGA_WEBSITE_PORT;
         delete process.env.OMEGA_WEBSITE_PORT;
         try {
-          withoutBakedPorts(ctx.manager, () => {
+          withClassicBakedPorts(ctx.manager, () => {
             ctx.expect(ctx.manager.getWebsiteUrl('development')).toBe('https://localhost:4000');
           });
         } finally {
@@ -326,7 +336,7 @@ module.exports = defineCases({
         const origId = m.config.brand.id;
         m.config.brand.id = 'demo';
         try {
-          withoutBakedPorts(m, () => {
+          withClassicBakedPorts(m, () => {
             const url = new URL(m.getAuthUrl('development'));
             ctx.expect(url.origin).toBe('https://localhost:4000');
             ctx.expect(url.pathname).toBe('/signin');
@@ -372,10 +382,12 @@ module.exports = defineCases({
         m.config.brand.id = 'demo';
         try {
           const loopback = 'http://127.0.0.1:49152/auth/token?state=abc';
-          const url = new URL(m.getAuthUrl('development', loopback));
-          const tokenUrl = new URL(url.searchParams.get('authReturnUrl'));
-          ctx.expect(tokenUrl.pathname).toBe('/token');
-          ctx.expect(tokenUrl.searchParams.get('authReturnUrl')).toBe(loopback);
+          withClassicBakedPorts(m, () => {
+            const url = new URL(m.getAuthUrl('development', loopback));
+            const tokenUrl = new URL(url.searchParams.get('authReturnUrl'));
+            ctx.expect(tokenUrl.pathname).toBe('/token');
+            ctx.expect(tokenUrl.searchParams.get('authReturnUrl')).toBe(loopback);
+          });
         } finally {
           if (origId !== undefined) m.config.brand.id = origId; else delete m.config.brand.id;
         }
@@ -388,39 +400,36 @@ module.exports = defineCases({
         const orig = m.config.brand?.id;
         if (m.config.brand) delete m.config.brand.id;
         try {
-          let threw;
-          try { m.getAuthUrl('development'); } catch (e) { threw = e; }
-          ctx.expect(threw).toBeDefined();
-          ctx.expect(threw.message).toMatch(/brand\.id/);
+          withClassicBakedPorts(m, () => {
+            let threw;
+            try { m.getAuthUrl('development'); } catch (e) { threw = e; }
+            ctx.expect(threw).toBeDefined();
+            ctx.expect(threw.message).toMatch(/brand\.id/);
+          });
         } finally {
           if (orig !== undefined) m.config.brand.id = orig;
         }
       },
     },
     {
-      name: 'getWebsiteUrl: respects current environment (config override) when no arg passed',
+      // With no argument, the getters take the CURRENT environment, which is
+      // the one input (#817): whatever the lane named for this process.
+      name: 'getWebsiteUrl: respects the current environment when no arg passed',
       run: (ctx) => {
         const m = ctx.manager;
-        const origEnv = m.config.em?.environment;
-        const origTest = process.env.OMEGA_TEST_MODE;
-        m.config.em = m.config.em || {};
+        const origVar = process.env.OMEGA_ENVIRONMENT;
         m.config.brand = m.config.brand || {};
         const origUrl = m.config.brand.url;
         m.config.brand.url = 'https://example.com';
-        // Clear OMEGA_TEST_MODE so the config override is exercised — otherwise testing wins
-        // (correctly) and every URL resolves local regardless of config.
-        delete process.env.OMEGA_TEST_MODE;
         try {
-          m.config.em.environment = 'development';
-          withoutBakedPorts(m, () => {
+          process.env.OMEGA_ENVIRONMENT = 'development';
+          withClassicBakedPorts(m, () => {
             ctx.expect(m.getWebsiteUrl()).toBe('https://localhost:4000');
           });
-          m.config.em.environment = 'production';
+          process.env.OMEGA_ENVIRONMENT = 'production';
           ctx.expect(m.getWebsiteUrl()).toBe('https://example.com');
         } finally {
-          if (origEnv !== undefined) m.config.em.environment = origEnv;
-          else delete m.config.em.environment;
-          if (origTest !== undefined) process.env.OMEGA_TEST_MODE = origTest;
+          if (origVar !== undefined) process.env.OMEGA_ENVIRONMENT = origVar; else delete process.env.OMEGA_ENVIRONMENT;
           m.config.brand.url = origUrl;
         }
       },