@omega.js/desktop 0.52.0 → 0.53.0

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

@@ -11,13 +11,13 @@
 // published, then composes OMEGA_WEBSITE_PORT / the baked port over https, then
 // the classic dev origin ([#747](https://github.com/Omega-JS-Stack/omega/issues/747)).
 //
-// The last case pins the auth emulator port client-bridge connects a testing
+// The last case pins the auth emulator port lib/auth.js connects a testing
 // run to: the same three-step chain, off the same baked map.
 
 const path = require('path');
 
 const helpers = require(path.join(__dirname, '..', '..', '..', 'utils', 'url-helpers.js'));
-const clientBridge = require(path.join(__dirname, '..', '..', '..', 'lib', 'client-bridge.js'));
+const auth = require(path.join(__dirname, '..', '..', '..', 'lib', 'auth.js'));
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
 
 function withEnv(overrides, fn) {
@@ -35,9 +35,9 @@ function withEnv(overrides, fn) {
   }
 }
 
-// The shape the helpers see at runtime: a Manager carrying the resolved config
+// The shape the helpers see at runtime: an omega instance carrying the resolved config
 // (OMEGA_BUILD_JSON.config, `dev` block and all) plus mode-helpers' getEnvironment().
-function fakeManager(environment, ports, origin) {
+function fakeOmega(environment, ports, origin) {
   return {
     getEnvironment: () => environment,
     isTesting: () => environment === 'testing',
@@ -51,11 +51,11 @@ function fakeManager(environment, ports, origin) {
   };
 }
 
-// Run `fn` with the bridge pointed at a stand-in Manager, then put the real one back.
-function withBridgeManager(manager, fn) {
-  const original = clientBridge._manager;
-  clientBridge._manager = manager;
-  try { return fn(); } finally { clientBridge._manager = original; }
+// Run `fn` with auth pointed at a stand-in instance, then put the real one back.
+function withAuthOmega(omega, fn) {
+  const original = auth._omega;
+  auth._omega = omega;
+  try { return fn(); } finally { auth._omega = original; }
 }
 
 // No env channel published: the state a packaged main process is in.
@@ -72,9 +72,11 @@ module.exports = defineCases({
   description: 'utils/url-helpers: every local helper resolves env, then the baked dev.ports, then throws',
   tests: [
     {
-      name: 'exports { attachTo, getApiUrl, localPort, requiredPort }',
+      // Plain functions the `Omega` classes call with themselves as `context`:
+      // no mixin onto a constructor any more
+      name: 'exports { getApiUrl, localPort, requiredPort } and no attachTo',
       run: (ctx) => {
-        ctx.expect(typeof helpers.attachTo).toBe('function');
+        ctx.expect(helpers.attachTo).toBeUndefined();
         ctx.expect(typeof helpers.getApiUrl).toBe('function');
         ctx.expect(typeof helpers.localPort).toBe('function');
         ctx.expect(typeof helpers.requiredPort).toBe('function');
@@ -84,8 +86,8 @@ module.exports = defineCases({
       name: 'a BUMPED baked dev.ports.hosting is the api base in testing',
       run: (ctx) => {
         withEnv(NO_ENV, () => {
-          const manager = fakeManager('testing', { hosting: 5012, auth: 9109 });
-          ctx.expect(helpers.getApiUrl.call(manager)).toBe('http://localhost:5012');
+          const omega = fakeOmega('testing', { hosting: 5012, auth: 9109 });
+          ctx.expect(helpers.getApiUrl(omega)).toBe('http://localhost:5012');
         });
       },
     },
@@ -93,8 +95,8 @@ module.exports = defineCases({
       name: 'a BUMPED baked dev.ports.hosting is the api base in development too',
       run: (ctx) => {
         withEnv(NO_ENV, () => {
-          const manager = fakeManager('development', { hosting: 5012 });
-          ctx.expect(helpers.getApiUrl.call(manager)).toBe('http://localhost:5012');
+          const omega = fakeOmega('development', { hosting: 5012 });
+          ctx.expect(helpers.getApiUrl(omega)).toBe('http://localhost:5012');
         });
       },
     },
@@ -102,8 +104,8 @@ module.exports = defineCases({
       name: 'OMEGA_HOSTING_PORT wins over the baked value',
       run: (ctx) => {
         withEnv({ ...NO_ENV, OMEGA_HOSTING_PORT: '5022' }, () => {
-          const manager = fakeManager('testing', { hosting: 5012 });
-          ctx.expect(helpers.getApiUrl.call(manager)).toBe('http://localhost:5022');
+          const omega = fakeOmega('testing', { hosting: 5012 });
+          ctx.expect(helpers.getApiUrl(omega)).toBe('http://localhost:5022');
         });
       },
     },
@@ -116,9 +118,9 @@ module.exports = defineCases({
       run: (ctx) => {
         withEnv(NO_ENV, () => {
           for (const environment of ['testing', 'development']) {
-            ctx.expect(() => helpers.getApiUrl.call(fakeManager(environment)))
+            ctx.expect(() => helpers.getApiUrl(fakeOmega(environment)))
               .toThrow(/dev port for `hosting`/);
-            ctx.expect(() => helpers.getApiUrl.call(fakeManager(environment)))
+            ctx.expect(() => helpers.getApiUrl(fakeOmega(environment)))
               .toThrow(/bundle task/);
           }
         });
@@ -128,8 +130,8 @@ module.exports = defineCases({
       name: 'OMEGA_HTTPS_PORT means the mkcert proxy is up: https, not hosting',
       run: (ctx) => {
         withEnv({ ...NO_ENV, OMEGA_HTTPS_PORT: '5003' }, () => {
-          const manager = fakeManager('testing', { hosting: 5012 });
-          ctx.expect(helpers.getApiUrl.call(manager)).toBe('https://localhost:5003');
+          const omega = fakeOmega('testing', { hosting: 5012 });
+          ctx.expect(helpers.getApiUrl(omega)).toBe('https://localhost:5003');
         });
       },
     },
@@ -137,8 +139,8 @@ module.exports = defineCases({
       name: 'a baked dev.ports.https does the same with no env published',
       run: (ctx) => {
         withEnv(NO_ENV, () => {
-          const manager = fakeManager('testing', { https: 5003, hosting: 5443 });
-          ctx.expect(helpers.getApiUrl.call(manager)).toBe('https://localhost:5003');
+          const omega = fakeOmega('testing', { https: 5003, hosting: 5443 });
+          ctx.expect(helpers.getApiUrl(omega)).toBe('https://localhost:5003');
         });
       },
     },
@@ -146,8 +148,8 @@ module.exports = defineCases({
       name: 'production ignores every local channel, giving api.<brand host>',
       run: (ctx) => {
         withEnv({ ...NO_ENV, OMEGA_HOSTING_PORT: '5022' }, () => {
-          const manager = fakeManager('production', { hosting: 5012 });
-          ctx.expect(helpers.getApiUrl.call(manager)).toBe('https://api.playground.omegajs.dev');
+          const omega = fakeOmega('production', { hosting: 5012 });
+          ctx.expect(helpers.getApiUrl(omega)).toBe('https://api.playground.omegajs.dev');
         });
       },
     },
@@ -155,8 +157,8 @@ module.exports = defineCases({
       name: 'getFunctionsUrl: a BUMPED baked dev.ports.functions is the functions base',
       run: (ctx) => {
         withEnv(NO_ENV, () => {
-          const manager = fakeManager('development', { functions: 5011 });
-          ctx.expect(helpers.getFunctionsUrl.call(manager))
+          const omega = fakeOmega('development', { functions: 5011 });
+          ctx.expect(helpers.getFunctionsUrl(omega))
             .toBe('http://localhost:5011/demo-app/us-central1');
         });
       },
@@ -165,8 +167,8 @@ module.exports = defineCases({
       name: 'getFunctionsUrl: OMEGA_FUNCTIONS_PORT wins over the baked value',
       run: (ctx) => {
         withEnv({ ...NO_ENV, OMEGA_FUNCTIONS_PORT: '5021' }, () => {
-          const manager = fakeManager('testing', { functions: 5011 });
-          ctx.expect(helpers.getFunctionsUrl.call(manager))
+          const omega = fakeOmega('testing', { functions: 5011 });
+          ctx.expect(helpers.getFunctionsUrl(omega))
             .toBe('http://localhost:5021/demo-app/us-central1');
         });
       },
@@ -175,7 +177,7 @@ module.exports = defineCases({
       name: 'getFunctionsUrl: neither channel → a throw naming the port (#834)',
       run: (ctx) => {
         withEnv(NO_ENV, () => {
-          ctx.expect(() => helpers.getFunctionsUrl.call(fakeManager('development')))
+          ctx.expect(() => helpers.getFunctionsUrl(fakeOmega('development')))
             .toThrow(/dev port for `functions`/);
         });
       },
@@ -184,8 +186,8 @@ module.exports = defineCases({
       name: 'getFunctionsUrl: production ignores every local channel',
       run: (ctx) => {
         withEnv({ ...NO_ENV, OMEGA_FUNCTIONS_PORT: '5021' }, () => {
-          const manager = fakeManager('production', { functions: 5011 });
-          ctx.expect(helpers.getFunctionsUrl.call(manager))
+          const omega = fakeOmega('production', { functions: 5011 });
+          ctx.expect(helpers.getFunctionsUrl(omega))
             .toBe('https://us-central1-demo-app.cloudfunctions.net');
         });
       },
@@ -194,8 +196,8 @@ module.exports = defineCases({
       name: 'getWebsiteUrl: a BUMPED baked dev.ports.website is the website base',
       run: (ctx) => {
         withEnv(NO_ENV, () => {
-          const manager = fakeManager('development', { website: 4001 });
-          ctx.expect(helpers.getWebsiteUrl.call(manager)).toBe('https://localhost:4001');
+          const omega = fakeOmega('development', { website: 4001 });
+          ctx.expect(helpers.getWebsiteUrl(omega)).toBe('https://localhost:4001');
         });
       },
     },
@@ -203,8 +205,8 @@ module.exports = defineCases({
       name: 'getWebsiteUrl: OMEGA_WEBSITE_PORT wins over the baked value',
       run: (ctx) => {
         withEnv({ ...NO_ENV, OMEGA_WEBSITE_PORT: '4002' }, () => {
-          const manager = fakeManager('testing', { website: 4001 });
-          ctx.expect(helpers.getWebsiteUrl.call(manager)).toBe('https://localhost:4002');
+          const omega = fakeOmega('testing', { website: 4001 });
+          ctx.expect(helpers.getWebsiteUrl(omega)).toBe('https://localhost:4002');
         });
       },
     },
@@ -212,7 +214,7 @@ module.exports = defineCases({
       name: 'getWebsiteUrl: neither channel → a throw naming the port (#834)',
       run: (ctx) => {
         withEnv(NO_ENV, () => {
-          ctx.expect(() => helpers.getWebsiteUrl.call(fakeManager('development')))
+          ctx.expect(() => helpers.getWebsiteUrl(fakeOmega('development')))
             .toThrow(/dev port for `website`/);
         });
       },
@@ -224,8 +226,8 @@ module.exports = defineCases({
       name: 'getWebsiteUrl: a baked dev.origin wins over OMEGA_WEBSITE_PORT',
       run: (ctx) => {
         withEnv({ ...NO_ENV, OMEGA_WEBSITE_PORT: '4002' }, () => {
-          const manager = fakeManager('development', { website: 4001 }, 'https://localhost:4123');
-          ctx.expect(helpers.getWebsiteUrl.call(manager)).toBe('https://localhost:4123');
+          const omega = fakeOmega('development', { website: 4001 }, 'https://localhost:4123');
+          ctx.expect(helpers.getWebsiteUrl(omega)).toBe('https://localhost:4123');
         });
       },
     },
@@ -233,7 +235,7 @@ module.exports = defineCases({
       name: 'getWebsiteUrl: OMEGA_WEBSITE_PORT with no baked origin composes over https',
       run: (ctx) => {
         withEnv({ ...NO_ENV, OMEGA_WEBSITE_PORT: '4321' }, () => {
-          ctx.expect(helpers.getWebsiteUrl.call(fakeManager('development'))).toBe('https://localhost:4321');
+          ctx.expect(helpers.getWebsiteUrl(fakeOmega('development'))).toBe('https://localhost:4321');
         });
       },
     },
@@ -258,11 +260,8 @@ module.exports = defineCases({
       name: 'getAuthUrl: dev builds /signin and /token on the https dev origin',
       run: (ctx) => {
         withEnv(NO_ENV, () => {
-          // getAuthUrl calls `this.getWebsiteUrl()`, which attachTo() supplies on a
-          // real Manager — hand the stand-in the same helper.
-          const manager = fakeManager('development', { website: 4000 });
-          manager.getWebsiteUrl = helpers.getWebsiteUrl;
-          const url = new URL(helpers.getAuthUrl.call(manager));
+          const omega = fakeOmega('development', { website: 4000 });
+          const url = new URL(helpers.getAuthUrl(omega));
           ctx.expect(url.origin).toBe('https://localhost:4000');
           ctx.expect(url.pathname).toBe('/signin');
           const tokenUrl = new URL(url.searchParams.get('authReturnUrl'));
@@ -276,31 +275,31 @@ module.exports = defineCases({
       name: 'getWebsiteUrl: production ignores every local channel',
       run: (ctx) => {
         withEnv({ ...NO_ENV, OMEGA_WEBSITE_PORT: '4002' }, () => {
-          const manager = fakeManager('production', { website: 4001 });
-          ctx.expect(helpers.getWebsiteUrl.call(manager)).toBe('https://playground.omegajs.dev');
+          const omega = fakeOmega('production', { website: 4001 });
+          ctx.expect(helpers.getWebsiteUrl(omega)).toBe('https://playground.omegajs.dev');
         });
       },
     },
     {
-      // client-bridge connects a TESTING run's auth to the emulator. Same chain:
+      // lib/auth.js connects a TESTING run's auth to the emulator. Same chain:
       // env, then the baked map, then classic 9099.
-      name: 'the auth emulator port rides the same chain (client-bridge)',
+      name: 'the auth emulator port rides the same chain (lib/auth.js)',
       run: (ctx) => {
         withEnv({ OMEGA_AUTH_PORT: null }, () => {
-          withBridgeManager(fakeManager('testing', { auth: 9109 }), () => {
-            ctx.expect(clientBridge._authEmulatorPort()).toBe(9109);
+          withAuthOmega(fakeOmega('testing', { auth: 9109 }), () => {
+            ctx.expect(auth._authEmulatorPort()).toBe(9109);
           });
           // The classic 9099 used to answer here (#834): nothing identity-checks
           // what holds that port, so a neighbouring project's emulator read as
           // an auth mystery instead of a port problem.
-          withBridgeManager(fakeManager('testing'), () => {
-            ctx.expect(() => clientBridge._authEmulatorPort()).toThrow(/dev port for `auth`/);
-            ctx.expect(() => clientBridge._authEmulatorPort()).toThrow(/bundle task/);
+          withAuthOmega(fakeOmega('testing'), () => {
+            ctx.expect(() => auth._authEmulatorPort()).toThrow(/dev port for `auth`/);
+            ctx.expect(() => auth._authEmulatorPort()).toThrow(/bundle task/);
           });
         });
         withEnv({ OMEGA_AUTH_PORT: '9119' }, () => {
-          withBridgeManager(fakeManager('testing', { auth: 9109 }), () => {
-            ctx.expect(clientBridge._authEmulatorPort()).toBe('9119');
+          withAuthOmega(fakeOmega('testing', { auth: 9109 }), () => {
+            ctx.expect(auth._authEmulatorPort()).toBe('9119');
           });
         });
       },

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

@@ -7,9 +7,9 @@
 const { validateConfig, runSchema, formatErrors, loadConfig } = require('../../../vendor/config/index.js');
 
 const path = require('path');
-const Manager = require('../../../build.js');
+const build = require('../../../build.js');
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
-const root = Manager.getRootPath('main');
+const root = build.getRootPath('main');
 
 // Minimal "good" config — passes every required check.
 const VALID = {

package/dist/test/suites/build/wave5-pins.test.js

@@ -25,10 +25,10 @@ module.exports = defineCases({
     },
     {
       // wave-5 F1: main.js must release the deep-link boot queue after full init.
-      name: 'main.js drains the deep-link boot queue via markManagerReady()',
+      name: 'main.js drains the deep-link boot queue via markOmegaReady()',
       run: (ctx) => {
         const source = fs.readFileSync(path.join(SRC, 'main.js'), 'utf8');
-        ctx.expect(source.includes('deepLink.markManagerReady()')).toBe(true);
+        ctx.expect(source.includes('deepLink.markOmegaReady()')).toBe(true);
       },
     },
   ],

package/dist/test/suites/main/analytics.test.js

@@ -6,7 +6,7 @@ const { v5: uuidv5 } = require('uuid');
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
 
 async function reinit(ctx, env, configOverrides) {
-  ctx.manager.analytics.shutdown();
+  ctx.omega.analytics.shutdown();
   const saved = {
     GOOGLE_ANALYTICS_SECRET: process.env.GOOGLE_ANALYTICS_SECRET,
   };
@@ -14,19 +14,19 @@ async function reinit(ctx, env, configOverrides) {
     if (v == null) delete process.env[k];
     else process.env[k] = v;
   }
-  const cfgOrig = ctx.manager.config.analytics;
+  const cfgOrig = ctx.omega.config.analytics;
   if (configOverrides !== undefined) {
-    ctx.manager.config.analytics = configOverrides;
+    ctx.omega.config.analytics = configOverrides;
   }
-  ctx.manager.analytics.initialize(ctx.manager);
+  ctx.omega.analytics.initialize(ctx.omega);
   return () => {
-    ctx.manager.analytics.shutdown();
+    ctx.omega.analytics.shutdown();
     for (const [k, v] of Object.entries(saved)) {
       if (v == null) delete process.env[k];
       else process.env[k] = v;
     }
-    ctx.manager.config.analytics = cfgOrig;
-    ctx.manager.analytics.initialize(ctx.manager);
+    ctx.omega.config.analytics = cfgOrig;
+    ctx.omega.analytics.initialize(ctx.omega);
   };
 }
 
@@ -35,15 +35,15 @@ module.exports = defineCases({
   layer: 'main',
   description: 'analytics (main)',
   cleanup: async (ctx) => {
-    ctx.manager.analytics.shutdown();
+    ctx.omega.analytics.shutdown();
     delete process.env.GOOGLE_ANALYTICS_SECRET;
-    ctx.manager.analytics.initialize(ctx.manager);
+    ctx.omega.analytics.initialize(ctx.omega);
   },
   tests: [
     {
-      name: 'analytics module wired on manager',
+      name: 'analytics module wired on omega',
       run: (ctx) => {
-        ctx.expect(ctx.manager.analytics).toBeDefined();
+        ctx.expect(ctx.omega.analytics).toBeDefined();
       },
     },
     {
@@ -51,8 +51,8 @@ module.exports = defineCases({
       run: async (ctx) => {
         const restore = await reinit(ctx, {}, { enabled: false });
         try {
-          ctx.expect(ctx.manager.analytics._enabled).toBe(false);
-          ctx.expect(ctx.manager.analytics._clientId).toBe(null);
+          ctx.expect(ctx.omega.analytics._enabled).toBe(false);
+          ctx.expect(ctx.omega.analytics._clientId).toBe(null);
         } finally { await restore(); }
       },
     },
@@ -64,7 +64,7 @@ module.exports = defineCases({
           providers: { google: { id: '' } },
         });
         try {
-          ctx.expect(ctx.manager.analytics._enabled).toBe(false);
+          ctx.expect(ctx.omega.analytics._enabled).toBe(false);
         } finally { await restore(); }
       },
     },
@@ -76,7 +76,7 @@ module.exports = defineCases({
           providers: { google: { id: 'G-TESTID12' } },
         });
         try {
-          ctx.expect(ctx.manager.analytics._enabled).toBe(false);
+          ctx.expect(ctx.omega.analytics._enabled).toBe(false);
         } finally { await restore(); }
       },
     },
@@ -88,14 +88,14 @@ module.exports = defineCases({
           providers: { google: { id: 'G-TESTID12' } },
         });
         try {
-          ctx.expect(ctx.manager.analytics._enabled).toBe(true);
-          ctx.expect(typeof ctx.manager.analytics._clientId).toBe('string');
-          ctx.expect(ctx.manager.analytics._clientId.length).toBe(36);
+          ctx.expect(ctx.omega.analytics._enabled).toBe(true);
+          ctx.expect(typeof ctx.omega.analytics._clientId).toBe('string');
+          ctx.expect(ctx.omega.analytics._clientId.length).toBe(36);
           // Confirm it's a stable derivation: same deviceId + same namespace should
           // produce the same uuidv5 every time.
-          const ns = ctx.manager.analytics._namespace;
-          const deviceId = ctx.manager.context.session.deviceId;
-          ctx.expect(ctx.manager.analytics._clientId).toBe(uuidv5(deviceId, ns));
+          const ns = ctx.omega.analytics._namespace;
+          const deviceId = ctx.omega.context.session.deviceId;
+          ctx.expect(ctx.omega.analytics._clientId).toBe(uuidv5(deviceId, ns));
         } finally { await restore(); }
       },
     },
@@ -105,24 +105,24 @@ module.exports = defineCases({
       // launch a new GA client, so initialize raises instead of limping.
       name: 'no context.session.deviceId: initialize raises (the boot-order invariant)',
       run: async (ctx) => {
-        const savedDeviceId = ctx.manager.context.session.deviceId;
+        const savedDeviceId = ctx.omega.context.session.deviceId;
         const savedSecret   = process.env.GOOGLE_ANALYTICS_SECRET;
-        const savedConfig   = ctx.manager.config.analytics;
+        const savedConfig   = ctx.omega.config.analytics;
 
-        ctx.manager.analytics.shutdown();
-        ctx.manager.context.session.deviceId = null;
+        ctx.omega.analytics.shutdown();
+        ctx.omega.context.session.deviceId = null;
         process.env.GOOGLE_ANALYTICS_SECRET  = 'fake-secret';
-        ctx.manager.config.analytics = { enabled: true, providers: { google: { id: 'G-TESTID12' } } };
+        ctx.omega.config.analytics = { enabled: true, providers: { google: { id: 'G-TESTID12' } } };
 
         try {
-          await ctx.expect(() => ctx.manager.analytics.initialize(ctx.manager)).toThrow(/boot sequence/);
+          await ctx.expect(() => ctx.omega.analytics.initialize(ctx.omega)).toThrow(/boot sequence/);
         } finally {
-          ctx.manager.context.session.deviceId = savedDeviceId;
-          ctx.manager.config.analytics = savedConfig;
+          ctx.omega.context.session.deviceId = savedDeviceId;
+          ctx.omega.config.analytics = savedConfig;
           if (savedSecret == null) delete process.env.GOOGLE_ANALYTICS_SECRET;
           else process.env.GOOGLE_ANALYTICS_SECRET = savedSecret;
-          ctx.manager.analytics.shutdown();
-          ctx.manager.analytics.initialize(ctx.manager);
+          ctx.omega.analytics.shutdown();
+          ctx.omega.analytics.initialize(ctx.omega);
         }
       },
     },
@@ -136,7 +136,7 @@ module.exports = defineCases({
           providers: { google: { id: 'G-TESTID12' } },
         });
         try {
-          const a = ctx.manager.analytics;
+          const a = ctx.omega.analytics;
           const ns = a._namespace;
           a.setUserId('firebase-uid-abc-123');
           const expected = uuidv5('firebase-uid-abc-123', ns);
@@ -153,7 +153,7 @@ module.exports = defineCases({
       run: async (ctx) => {
         // Hand-rolled (not reinit()): the helper's leading shutdown() would
         // wipe the very _pendingUid this test plants.
-        const a = ctx.manager.analytics;
+        const a = ctx.omega.analytics;
         a.shutdown(); // _namespace null — the pre-init state
 
         a.setUserId('early-uid-before-boot');
@@ -161,18 +161,18 @@ module.exports = defineCases({
 
         const savedSecret = process.env.GOOGLE_ANALYTICS_SECRET;
         process.env.GOOGLE_ANALYTICS_SECRET = 'fake-secret';
-        const cfgOrig = ctx.manager.config.analytics;
-        ctx.manager.config.analytics = { enabled: true, providers: { google: { id: 'G-TESTID12' } } };
+        const cfgOrig = ctx.omega.config.analytics;
+        ctx.omega.config.analytics = { enabled: true, providers: { google: { id: 'G-TESTID12' } } };
         try {
-          a.initialize(ctx.manager);
+          a.initialize(ctx.omega);
           ctx.expect(a._pendingUid).toBe(null);
           ctx.expect(a._userId).toBe(uuidv5('early-uid-before-boot', a._namespace));
         } finally {
           a.shutdown();
           if (savedSecret == null) delete process.env.GOOGLE_ANALYTICS_SECRET;
           else process.env.GOOGLE_ANALYTICS_SECRET = savedSecret;
-          ctx.manager.config.analytics = cfgOrig;
-          a.initialize(ctx.manager);
+          ctx.omega.config.analytics = cfgOrig;
+          a.initialize(ctx.omega);
         }
       },
     },
@@ -184,10 +184,10 @@ module.exports = defineCases({
           providers: { google: { id: 'G-TESTID12' } },
         });
         try {
-          ctx.manager.analytics.setUserId('some-uid');
-          ctx.expect(ctx.manager.analytics._userId).not.toBe(null);
-          ctx.manager.analytics.setUserId(null);
-          ctx.expect(ctx.manager.analytics._userId).toBe(null);
+          ctx.omega.analytics.setUserId('some-uid');
+          ctx.expect(ctx.omega.analytics._userId).not.toBe(null);
+          ctx.omega.analytics.setUserId(null);
+          ctx.expect(ctx.omega.analytics._userId).toBe(null);
         } finally { await restore(); }
       },
     },
@@ -203,7 +203,7 @@ module.exports = defineCases({
           providers: { google: { id: 'G-TESTID12' } },
         });
 
-        const a = ctx.manager.analytics;
+        const a = ctx.omega.analytics;
         const origSend = a._send;
         const sent = [];
         a._send = (descriptor) => { sent.push(descriptor); return true; };
@@ -230,7 +230,7 @@ module.exports = defineCases({
     {
       name: '_enrichParams adds session_id + engagement_time_msec',
       run: (ctx) => {
-        const params = ctx.manager.analytics._enrichParams({ custom: 'value' });
+        const params = ctx.omega.analytics._enrichParams({ custom: 'value' });
         ctx.expect(params.custom).toBe('value');
         ctx.expect(typeof params.session_id).toBe('string');
         ctx.expect(typeof params.engagement_time_msec).toBe('number');
@@ -245,7 +245,7 @@ module.exports = defineCases({
         const restore = await reinit(ctx, {}, { enabled: false });
         try {
           // Should not throw.
-          ctx.manager.analytics.event('app_launch', { x: 1 });
+          ctx.omega.analytics.event('app_launch', { x: 1 });
           ctx.expect(true).toBe(true);
         } finally { await restore(); }
       },
@@ -253,28 +253,28 @@ module.exports = defineCases({
     {
       name: 'event() before init queues, queue is bounded',
       run: (ctx) => {
-        const a = ctx.manager.analytics;
+        const a = ctx.omega.analytics;
         a.shutdown();   // back to uninitialized state
         a.event('queued_one');
         a.event('queued_two');
         ctx.expect(a._queue.length).toBe(2);
-        ctx.manager.analytics.initialize(ctx.manager);   // restore for downstream tests
+        ctx.omega.analytics.initialize(ctx.omega);   // restore for downstream tests
       },
     },
     {
       name: 'queue flushes on init',
       run: async (ctx) => {
         // Force a "before init" state with a couple of queued items.
-        ctx.manager.analytics.shutdown();
-        ctx.manager.analytics._queue.push({ name: 'x', params: {} });
-        ctx.manager.analytics._queue.push({ name: 'y', params: {} });
+        ctx.omega.analytics.shutdown();
+        ctx.omega.analytics._queue.push({ name: 'x', params: {} });
+        ctx.omega.analytics._queue.push({ name: 'y', params: {} });
         const restore = await reinit(ctx, { GOOGLE_ANALYTICS_SECRET: 'fake-secret' }, {
           enabled: true,
           providers: { google: { id: 'G-TESTID12' } },
         });
         try {
           // After init, queue should be drained.
-          ctx.expect(ctx.manager.analytics._queue.length).toBe(0);
+          ctx.expect(ctx.omega.analytics._queue.length).toBe(0);
         } finally { await restore(); }
       },
     },
@@ -286,7 +286,7 @@ module.exports = defineCases({
           providers: { google: { id: 'G-TESTID12' } },
         });
         try {
-          const a = ctx.manager.analytics;
+          const a = ctx.omega.analytics;
           // Simulate auth bridge firing.
           a._handleAuthChange({ uid: 'user-123' });
           ctx.expect(a._userId).not.toBe(null);
@@ -304,9 +304,9 @@ module.exports = defineCases({
           providers: { google: { id: 'G-TESTID12' } },
         });
         try {
-          ctx.manager.analytics.setUserProperties({ plan: 'premium', custom_flag: true });
-          ctx.expect(ctx.manager.analytics._userProperties.plan).toEqual({ value: 'premium' });
-          ctx.expect(ctx.manager.analytics._userProperties.custom_flag).toEqual({ value: true });
+          ctx.omega.analytics.setUserProperties({ plan: 'premium', custom_flag: true });
+          ctx.expect(ctx.omega.analytics._userProperties.plan).toEqual({ value: 'premium' });
+          ctx.expect(ctx.omega.analytics._userProperties.custom_flag).toEqual({ value: true });
         } finally { await restore(); }
       },
     },
@@ -318,7 +318,7 @@ module.exports = defineCases({
           providers: { google: { id: 'G-TESTID12' } },
         });
         try {
-          const snap = await ctx.manager.ipc.invoke('desktop:analytics:status');
+          const snap = await ctx.omega.ipc.invoke('desktop:analytics:status');
           ctx.expect(snap.enabled).toBe(true);
           ctx.expect(snap.measurementId).toBe('G-TESTID12');
         } finally { await restore(); }
@@ -327,13 +327,13 @@ module.exports = defineCases({
     {
       name: 'IPC listener desktop:analytics:event routes to analytics.event',
       run: async (ctx) => {
-        const a = ctx.manager.analytics;
+        const a = ctx.omega.analytics;
         const origEvent = a.event;
         let captured = null;
         a.event = (name, params) => { captured = { name, params }; };
         try {
           // Simulate an inbound IPC call (renderer would do ipcRenderer.send).
-          const listeners = ctx.manager.ipc._listeners?.['desktop:analytics:event'];
+          const listeners = ctx.omega.ipc._listeners?.['desktop:analytics:event'];
           ctx.expect(listeners).toBeDefined();
           listeners.forEach((fn) => fn({ name: 'rendererEvent', params: { x: 1 } }));
           ctx.expect(captured).toEqual({ name: 'rendererEvent', params: { x: 1 } });
@@ -348,7 +348,7 @@ module.exports = defineCases({
           providers: { google: { id: 'G-TESTID12' } },
         });
         try {
-          const j = ctx.manager.analytics.toJSON();
+          const j = ctx.omega.analytics.toJSON();
           ctx.expect(j.enabled).toBe(true);
           ctx.expect(j.measurementId).toBe('G-TESTID12');
           ctx.expect(typeof j.clientId).toBe('string');