@omega.js/desktop 0.52.0 → 0.53.0

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

@@ -2,6 +2,13 @@
 
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
 
+// Every library src/main.js assigns, by its property name
+const LIBS = [
+  'storage', 'theme', 'fontawesome', 'sentry', 'protocol', 'deepLink', 'authFlow', 'appState',
+  'ipc', 'autoUpdater', 'tray', 'menu', 'contextMenu', 'startup', 'auth', 'windows', 'context',
+  'usage', 'remoteConfig', 'remoteScripts', 'analytics', 'restartManager',
+];
+
 module.exports = defineCases({
   type: 'group',
   layer: 'main',
@@ -10,67 +17,48 @@ module.exports = defineCases({
     {
       name: 'config was loaded',
       run: (ctx) => {
-        ctx.expect(ctx.manager.config).toBeTruthy();
-        ctx.expect(ctx.manager.config.brand.id).toBeTruthy();
+        ctx.expect(ctx.omega.config).toBeTruthy();
+        ctx.expect(ctx.omega.config.brand.id).toBeTruthy();
       },
     },
     {
-      name: 'storage initialized',
-      run: (ctx) => ctx.expect(ctx.manager.storage._initialized).toBe(true),
-    },
-    {
-      name: 'sentry initialized',
-      run: (ctx) => ctx.expect(ctx.manager.sentry._initialized).toBe(true),
-    },
-    {
-      name: 'protocol initialized',
-      run: (ctx) => ctx.expect(ctx.manager.protocol._initialized).toBe(true),
-    },
-    {
-      name: 'deep-link initialized',
-      run: (ctx) => ctx.expect(ctx.manager.deepLink._initialized).toBe(true),
-    },
-    {
-      name: 'app-state initialized',
-      run: (ctx) => ctx.expect(ctx.manager.appState._initialized).toBe(true),
-    },
-    {
-      name: 'ipc initialized',
-      run: (ctx) => ctx.expect(ctx.manager.ipc._initialized).toBe(true),
-    },
-    {
-      name: 'auto-updater initialized',
-      run: (ctx) => ctx.expect(ctx.manager.autoUpdater._initialized).toBe(true),
-    },
-    {
-      name: 'tray initialized',
-      run: (ctx) => ctx.expect(ctx.manager.tray._initialized).toBe(true),
-    },
-    {
-      name: 'menu initialized',
-      run: (ctx) => ctx.expect(ctx.manager.menu._initialized).toBe(true),
-    },
-    {
-      name: 'context-menu initialized',
-      run: (ctx) => ctx.expect(ctx.manager.contextMenu._initialized).toBe(true),
-    },
-    {
-      name: 'startup initialized',
-      run: (ctx) => ctx.expect(ctx.manager.startup._initialized).toBe(true),
+      // The 22 libraries, each a plain property of the one instance and each
+      // brought up by initialize(). `auth` is the main-side auth (lib/auth.js);
+      // the old `omega` property that held it is gone.
+      name: 'every library is on the instance and initialized',
+      run: (ctx) => {
+        for (const name of LIBS) {
+          ctx.expect(Boolean(ctx.omega[name])).toBe(true);
+          if (ctx.omega[name]._initialized !== true) {
+            throw new Error(`omega.${name} was not initialized by the boot`);
+          }
+        }
+        ctx.expect(LIBS.length).toBe(22);
+        ctx.expect(ctx.omega.omega).toBeUndefined();
+      },
     },
     {
-      name: 'client-bridge initialized',
-      run: (ctx) => ctx.expect(ctx.manager.omega._initialized).toBe(true),
+      // The one instance a consumer's main.js requires IS the one the harness booted
+      name: 'the module exports ONE instance, and .Omega is its constructor',
+      run: (ctx) => {
+        const main = require('../../../main.js');
+        ctx.expect(main).toBe(ctx.omega);
+        ctx.expect(typeof main.Omega).toBe('function');
+        ctx.expect(main).toBeInstanceOf(main.Omega);
+        ctx.expect(main.constructor).toBe(main.Omega);
+      },
     },
     {
-      name: 'window-manager initialized',
-      run: (ctx) => ctx.expect(ctx.manager.windows._initialized).toBe(true),
+      name: 'ready settled with the instance',
+      run: async (ctx) => {
+        ctx.expect(await ctx.omega.ready).toBe(ctx.omega);
+      },
     },
     {
       name: 'getEnvironment returns testing under the test harness',
       run: (ctx) => {
         // The harness spawn names OMEGA_ENVIRONMENT=testing, the one input.
-        ctx.expect(ctx.manager.getEnvironment()).toBe('testing');
+        ctx.expect(ctx.omega.getEnvironment()).toBe('testing');
       },
     },
   ],

package/dist/test/suites/main/context-menu.test.js

@@ -12,13 +12,13 @@ module.exports = defineCases({
   description: 'context-menu (main)',
   cleanup: (ctx) => {
     // Reset to the built-in default fn so subsequent test runs aren't affected.
-    ctx.manager.contextMenu._definitionFn = null;
+    ctx.omega.contextMenu._definitionFn = null;
   },
   tests: [
     {
       name: 'initialize ran (enabled by default)',
       run: (ctx) => {
-        ctx.expect(ctx.manager.contextMenu._initialized).toBe(true);
+        ctx.expect(ctx.omega.contextMenu._initialized).toBe(true);
       },
     },
     {
@@ -30,19 +30,19 @@ module.exports = defineCases({
         // In the test harness, appRoot() === app.getAppPath() === the @omega.js/desktop harness dir, which
         // differs from process.cwd() (the consumer project dir when run from a consumer).
         // Comparing against process.cwd() made this assert a false mismatch in consumers:
-        // the consumer has src/integrations/context-menu/index.js, but the manager never
+        // the consumer has src/integrations/context-menu/index.js, but the omega instance never
         // looks there — it looks under appRoot(). Keying the expectation off appRoot() makes
         // the invariant self-consistent in both the @omega.js/desktop self-test and any consumer run.
         const appRoot = require('../../../utils/app-root.js')();
         const consumerFile = path.join(appRoot, 'src', 'integrations', 'context-menu', 'index.js');
         const hasConsumer = fs.existsSync(consumerFile);
-        ctx.expect(ctx.manager.contextMenu.hasCustomDefinition()).toBe(hasConsumer);
+        ctx.expect(ctx.omega.contextMenu.hasCustomDefinition()).toBe(hasConsumer);
       },
     },
     {
       name: 'default fn: editable params produce cut/copy/paste',
       run: (ctx) => {
-        const items = ctx.manager.contextMenu.buildItems({
+        const items = ctx.omega.contextMenu.buildItems({
           isEditable: true,
           editFlags: { canCut: true, canCopy: true, canPaste: true },
         });
@@ -55,7 +55,7 @@ module.exports = defineCases({
     {
       name: 'default fn: text selection produces copy only',
       run: (ctx) => {
-        const items = ctx.manager.contextMenu.buildItems({
+        const items = ctx.omega.contextMenu.buildItems({
           isEditable: false,
           selectionText: 'hello world',
         });
@@ -68,7 +68,7 @@ module.exports = defineCases({
     {
       name: 'default fn: link adds Open / Copy Address items',
       run: (ctx) => {
-        const items = ctx.manager.contextMenu.buildItems({
+        const items = ctx.omega.contextMenu.buildItems({
           linkURL: 'https://example.com',
         });
         const labels = items.filter((i) => i.label).map((i) => i.label);
@@ -80,27 +80,27 @@ module.exports = defineCases({
       name: 'default fn: empty params → only the always-on items (reload)',
       run: (ctx) => {
         // Force isDevelopment false so dev-only items don't appear.
-        const orig = ctx.manager.isDevelopment;
-        ctx.manager.isDevelopment = () => false;
+        const orig = ctx.omega.isDevelopment;
+        ctx.omega.isDevelopment = () => false;
         try {
-          const items = ctx.manager.contextMenu.buildItems({});
+          const items = ctx.omega.contextMenu.buildItems({});
           // With no editFlags, no selection, no link → only `reload` is always-on.
           const ids = items.filter((i) => i.id).map((i) => i.id);
           ctx.expect(ids).toEqual(['reload']);
         } finally {
-          ctx.manager.isDevelopment = orig;
+          ctx.omega.isDevelopment = orig;
         }
       },
     },
     {
       name: 'define() replaces the fn',
       run: (ctx) => {
-        ctx.manager.contextMenu.define(({ menu, params }) => {
+        ctx.omega.contextMenu.define(({ menu, params }) => {
           menu.item({ label: `Selected: ${params.selectionText}` });
         });
-        ctx.expect(ctx.manager.contextMenu.hasCustomDefinition()).toBe(true);
+        ctx.expect(ctx.omega.contextMenu.hasCustomDefinition()).toBe(true);
 
-        const items = ctx.manager.contextMenu.buildItems({ selectionText: 'foo' });
+        const items = ctx.omega.contextMenu.buildItems({ selectionText: 'foo' });
         ctx.expect(items.length).toBe(1);
         ctx.expect(items[0].label).toBe('Selected: foo');
       },
@@ -108,18 +108,18 @@ module.exports = defineCases({
     {
       name: 'define() throws on non-function input',
       run: (ctx) => {
-        ctx.expect(() => ctx.manager.contextMenu.define(null)).toThrow(/must be a function/);
+        ctx.expect(() => ctx.omega.contextMenu.define(null)).toThrow(/must be a function/);
       },
     },
     {
       name: 'menu.separator() pushes a separator descriptor',
       run: (ctx) => {
-        ctx.manager.contextMenu.define(({ menu }) => {
+        ctx.omega.contextMenu.define(({ menu }) => {
           menu.item({ label: 'A' });
           menu.separator();
           menu.item({ label: 'B' });
         });
-        const items = ctx.manager.contextMenu.buildItems({});
+        const items = ctx.omega.contextMenu.buildItems({});
         ctx.expect(items.length).toBe(3);
         ctx.expect(items[1].type).toBe('separator');
       },
@@ -127,24 +127,25 @@ module.exports = defineCases({
     {
       name: 'menu.submenu() builds a nested submenu',
       run: (ctx) => {
-        ctx.manager.contextMenu.define(({ menu }) => {
+        ctx.omega.contextMenu.define(({ menu }) => {
           menu.submenu('More', [{ label: 'X' }, { label: 'Y' }]);
         });
-        const items = ctx.manager.contextMenu.buildItems({});
+        const items = ctx.omega.contextMenu.buildItems({});
         ctx.expect(items[0].label).toBe('More');
         ctx.expect(items[0].submenu.length).toBe(2);
       },
     },
     {
-      name: 'definition fn receives manager, params, webContents',
+      name: 'definition fn receives omega, params, webContents (no manager key)',
       run: (ctx) => {
         let received;
-        ctx.manager.contextMenu.define((arg) => {
+        ctx.omega.contextMenu.define((arg) => {
           received = arg;
           arg.menu.item({ label: 'probe' });
         });
-        ctx.manager.contextMenu.buildItems({ x: 100, y: 200 }, { id: 'fake-wc' });
-        ctx.expect(received.manager).toBe(ctx.manager);
+        ctx.omega.contextMenu.buildItems({ x: 100, y: 200 }, { id: 'fake-wc' });
+        ctx.expect(received.omega).toBe(ctx.omega);
+        ctx.expect(received.manager).toBeUndefined();
         ctx.expect(received.params).toEqual({ x: 100, y: 200 });
         ctx.expect(received.webContents).toEqual({ id: 'fake-wc' });
         ctx.expect(typeof received.menu.item).toBe('function');
@@ -156,12 +157,12 @@ module.exports = defineCases({
       name: '_resolveItem evaluates dynamic labels',
       run: (ctx) => {
         let n = 0;
-        const resolved = ctx.manager.contextMenu._resolveItem({
+        const resolved = ctx.omega.contextMenu._resolveItem({
           label: () => `Items: ${n}`,
         });
         ctx.expect(resolved.label).toBe('Items: 0');
         n = 4;
-        const resolved2 = ctx.manager.contextMenu._resolveItem({ label: () => `Items: ${n}` });
+        const resolved2 = ctx.omega.contextMenu._resolveItem({ label: () => `Items: ${n}` });
         ctx.expect(resolved2.label).toBe('Items: 4');
       },
     },
@@ -169,7 +170,7 @@ module.exports = defineCases({
       name: '_resolveItem wraps click handlers to swallow errors',
       run: (ctx) => {
         let called = false;
-        const resolved = ctx.manager.contextMenu._resolveItem({
+        const resolved = ctx.omega.contextMenu._resolveItem({
           label: 'X',
           click: () => { called = true; throw new Error('nope'); },
         });
@@ -185,8 +186,8 @@ module.exports = defineCases({
         const mockWC = {
           on: (evt, fn) => { calls.push({ evt, fn }); },
         };
-        ctx.manager.contextMenu.attach(mockWC);
-        ctx.manager.contextMenu.attach(mockWC); // second call should be a no-op
+        ctx.omega.contextMenu.attach(mockWC);
+        ctx.omega.contextMenu.attach(mockWC); // second call should be a no-op
         ctx.expect(calls.length).toBe(1);
         ctx.expect(calls[0].evt).toBe('context-menu');
       },
@@ -194,8 +195,8 @@ module.exports = defineCases({
     {
       name: 'menu.useDefaults() ships id-tagged items (cut, copy, paste, ...)',
       run: (ctx) => {
-        ctx.manager.contextMenu.define(({ menu }) => { menu.useDefaults(); });
-        const items = ctx.manager.contextMenu.buildItems({
+        ctx.omega.contextMenu.define(({ menu }) => { menu.useDefaults(); });
+        const items = ctx.omega.contextMenu.buildItems({
           isEditable: true,
           editFlags: { canCut: true, canCopy: true, canPaste: true },
         });
@@ -208,11 +209,11 @@ module.exports = defineCases({
     {
       name: 'menu.remove() drops an item by id within the event',
       run: (ctx) => {
-        ctx.manager.contextMenu.define(({ menu }) => {
+        ctx.omega.contextMenu.define(({ menu }) => {
           menu.useDefaults();
           menu.remove('paste');
         });
-        const items = ctx.manager.contextMenu.buildItems({
+        const items = ctx.omega.contextMenu.buildItems({
           isEditable: true,
           editFlags: { canCut: true, canCopy: true, canPaste: true },
         });
@@ -225,11 +226,11 @@ module.exports = defineCases({
     {
       name: 'menu.insertAfter splices a new item by id',
       run: (ctx) => {
-        ctx.manager.contextMenu.define(({ menu }) => {
+        ctx.omega.contextMenu.define(({ menu }) => {
           menu.useDefaults();
           menu.insertAfter('copy', { id: 'search', label: 'Search...' });
         });
-        const items = ctx.manager.contextMenu.buildItems({
+        const items = ctx.omega.contextMenu.buildItems({
           isEditable: false,
           selectionText: 'foo',
         });
@@ -243,11 +244,11 @@ module.exports = defineCases({
     {
       name: 'menu.update() patches a default item before popup',
       run: (ctx) => {
-        ctx.manager.contextMenu.define(({ menu }) => {
+        ctx.omega.contextMenu.define(({ menu }) => {
           menu.useDefaults();
           menu.update('copy', { label: 'CUSTOM COPY' });
         });
-        const items = ctx.manager.contextMenu.buildItems({
+        const items = ctx.omega.contextMenu.buildItems({
           isEditable: false,
           selectionText: 'foo',
         });
@@ -259,7 +260,7 @@ module.exports = defineCases({
     {
       name: 'defaults: undo/redo appear when canUndo/canRedo flags set',
       run: (ctx) => {
-        const items = ctx.manager.contextMenu.buildItems({
+        const items = ctx.omega.contextMenu.buildItems({
           isEditable: true,
           editFlags: { canUndo: true, canRedo: true, canCut: true, canCopy: true, canPaste: true },
         });
@@ -271,7 +272,7 @@ module.exports = defineCases({
     {
       name: 'defaults: paste-and-match-style appears in editable contexts',
       run: (ctx) => {
-        const items = ctx.manager.contextMenu.buildItems({
+        const items = ctx.omega.contextMenu.buildItems({
           isEditable: true,
           editFlags: { canCut: true, canCopy: true, canPaste: true },
         });
@@ -282,14 +283,14 @@ module.exports = defineCases({
     {
       name: 'defaults: reload always present',
       run: (ctx) => {
-        const orig = ctx.manager.isDevelopment;
-        ctx.manager.isDevelopment = () => false;
+        const orig = ctx.omega.isDevelopment;
+        ctx.omega.isDevelopment = () => false;
         try {
-          const items = ctx.manager.contextMenu.buildItems({ selectionText: 'hi' });
+          const items = ctx.omega.contextMenu.buildItems({ selectionText: 'hi' });
           const ids = items.filter((i) => i.id).map((i) => i.id);
           ctx.expect(ids).toContain('reload');
         } finally {
-          ctx.manager.isDevelopment = orig;
+          ctx.omega.isDevelopment = orig;
         }
       },
     },
@@ -297,13 +298,13 @@ module.exports = defineCases({
       name: 'menu.find / menu.has work within event builder',
       run: (ctx) => {
         let foundCopy, hasCut, hasNope;
-        ctx.manager.contextMenu.define(({ menu }) => {
+        ctx.omega.contextMenu.define(({ menu }) => {
           menu.useDefaults();
           foundCopy = menu.find('copy');
           hasCut    = menu.has('cut');
           hasNope   = menu.has('does-not-exist');
         });
-        ctx.manager.contextMenu.buildItems({
+        ctx.omega.contextMenu.buildItems({
           isEditable: true,
           editFlags: { canCut: true, canCopy: true, canPaste: true },
         });
@@ -315,11 +316,11 @@ module.exports = defineCases({
     {
       name: 'menu.insertBefore splices a new item by id',
       run: (ctx) => {
-        ctx.manager.contextMenu.define(({ menu }) => {
+        ctx.omega.contextMenu.define(({ menu }) => {
           menu.useDefaults();
           menu.insertBefore('copy', { id: 'pre-copy', label: 'BEFORE COPY' });
         });
-        const items = ctx.manager.contextMenu.buildItems({
+        const items = ctx.omega.contextMenu.buildItems({
           isEditable: false,
           selectionText: 'foo',
         });
@@ -332,12 +333,12 @@ module.exports = defineCases({
     {
       name: 'menu.hide / menu.enable / menu.show within event',
       run: (ctx) => {
-        ctx.manager.contextMenu.define(({ menu }) => {
+        ctx.omega.contextMenu.define(({ menu }) => {
           menu.useDefaults();
           menu.hide('copy');
           menu.enable('paste', false);
         });
-        const items = ctx.manager.contextMenu.buildItems({
+        const items = ctx.omega.contextMenu.buildItems({
           isEditable: true,
           editFlags: { canCut: true, canCopy: true, canPaste: true },
         });
@@ -350,12 +351,12 @@ module.exports = defineCases({
     {
       name: 'menu.appendTo pushes into a submenu created via menu.submenu(...)',
       run: (ctx) => {
-        ctx.manager.contextMenu.define(({ menu }) => {
+        ctx.omega.contextMenu.define(({ menu }) => {
           // Build a parent submenu with an id.
           menu.item({ id: 'more', label: 'More', submenu: [] });
           menu.appendTo('more', { id: 'extra', label: 'Extra' });
         });
-        const items = ctx.manager.contextMenu.buildItems({});
+        const items = ctx.omega.contextMenu.buildItems({});
         const more = items.find((i) => i.id === 'more');
         ctx.expect(more).toBeTruthy();
         ctx.expect(more.submenu[0].id).toBe('extra');

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

@@ -13,16 +13,16 @@ module.exports = defineCases({
   description: 'context (main)',
   tests: [
     {
-      name: 'context module wired on manager + initialized during boot',
+      name: 'context module wired on omega + initialized during boot',
       run: (ctx) => {
-        ctx.expect(ctx.manager.context).toBeDefined();
-        ctx.expect(ctx.manager.context._initialized).toBe(true);
+        ctx.expect(ctx.omega.context).toBeDefined();
+        ctx.expect(ctx.omega.context._initialized).toBe(true);
       },
     },
     {
       name: 'session has id (UUID), startTime (ISO), deviceId (string)',
       run: (ctx) => {
-        const s = ctx.manager.context.session;
+        const s = ctx.omega.context.session;
         ctx.expect(typeof s.id).toBe('string');
         ctx.expect(s.id.length).toBe(36);
         ctx.expect(typeof s.startTime).toBe('string');
@@ -34,10 +34,10 @@ module.exports = defineCases({
     {
       name: 'deviceId is stable — re-init preserves the same id',
       run: async (ctx) => {
-        const before = ctx.manager.context.session.deviceId;
-        ctx.manager.context.shutdown();
-        await ctx.manager.context.initialize(ctx.manager);
-        const after = ctx.manager.context.session.deviceId;
+        const before = ctx.omega.context.session.deviceId;
+        ctx.omega.context.shutdown();
+        await ctx.omega.context.initialize(ctx.omega);
+        const after = ctx.omega.context.session.deviceId;
         ctx.expect(after).toBe(before);
       },
     },
@@ -63,14 +63,14 @@ module.exports = defineCases({
       // that hands a wiped install back the id it had before.
       name: 'deviceId derives from the injected MAC seed and persists to storage',
       run: async (ctx) => {
-        const storage = ctx.manager.storage;
+        const storage = ctx.omega.storage;
         const saved = storage.get('context.deviceId');
 
         try {
           // A wiped install: nothing stored, so the seed decides
           storage.delete('context.deviceId');
-          const derived = await ctx.manager.context._resolveDeviceId();
-          const mac = ctx.manager.context._readFirstMac();
+          const derived = await ctx.omega.context._resolveDeviceId();
+          const mac = ctx.omega.context._readFirstMac();
 
           if (mac) {
             ctx.expect(derived).toBe(mac);
@@ -82,7 +82,7 @@ module.exports = defineCases({
           ctx.expect(storage.get('context.deviceId')).toBe(derived);
 
           storage.set('context.deviceId', 'stored-wins-over-the-seed');
-          ctx.expect(await ctx.manager.context._resolveDeviceId()).toBe('stored-wins-over-the-seed');
+          ctx.expect(await ctx.omega.context._resolveDeviceId()).toBe('stored-wins-over-the-seed');
         } finally {
           if (saved) storage.set('context.deviceId', saved);
           else storage.delete('context.deviceId');
@@ -93,38 +93,38 @@ module.exports = defineCases({
       name: 'client.platform is set (matches os.platform())',
       run: (ctx) => {
         const expected = require('os').platform();
-        ctx.expect(ctx.manager.context.client.platform).toBe(expected);
+        ctx.expect(ctx.omega.context.client.platform).toBe(expected);
       },
     },
     {
       name: 'client.arch is set',
       run: (ctx) => {
-        ctx.expect(typeof ctx.manager.context.client.arch).toBe('string');
-        ctx.expect(ctx.manager.context.client.arch.length > 0).toBe(true);
+        ctx.expect(typeof ctx.omega.context.client.arch).toBe('string');
+        ctx.expect(ctx.omega.context.client.arch.length > 0).toBe(true);
       },
     },
     {
       name: 'client.mobile is false on desktop',
       run: (ctx) => {
-        ctx.expect(ctx.manager.context.client.mobile).toBe(false);
+        ctx.expect(ctx.omega.context.client.mobile).toBe(false);
       },
     },
     {
-      name: 'app.environment matches manager.getEnvironment()',
+      name: 'app.environment matches omega.getEnvironment()',
       run: (ctx) => {
-        ctx.expect(ctx.manager.context.app.environment).toBe(ctx.manager.getEnvironment());
+        ctx.expect(ctx.omega.context.app.environment).toBe(ctx.omega.getEnvironment());
       },
     },
     {
-      name: 'app.version matches manager.getVersion()',
+      name: 'app.version matches omega.getVersion()',
       run: (ctx) => {
-        ctx.expect(ctx.manager.context.app.version).toBe(ctx.manager.getVersion());
+        ctx.expect(ctx.omega.context.app.version).toBe(ctx.omega.getVersion());
       },
     },
     {
       name: 'toJSON returns plain JSON snapshot (structured-cloneable)',
       run: (ctx) => {
-        const snap = ctx.manager.context.toJSON();
+        const snap = ctx.omega.context.toJSON();
         ctx.expect(snap.geolocation).toBeDefined();
         ctx.expect(snap.client).toBeDefined();
         ctx.expect(snap.session).toBeDefined();
@@ -137,7 +137,7 @@ module.exports = defineCases({
     {
       name: '_readFirstMac returns null or a MAC-shaped string',
       run: (ctx) => {
-        const mac = ctx.manager.context._readFirstMac();
+        const mac = ctx.omega.context._readFirstMac();
         if (mac !== null) {
           ctx.expect(mac).toMatch(/^[0-9a-f]{2}(:[0-9a-f]{2}){5}$/i);
         }
@@ -146,9 +146,9 @@ module.exports = defineCases({
     {
       name: 'IPC handler desktop:context:get returns the snapshot',
       run: async (ctx) => {
-        const snap = await ctx.manager.ipc.invoke('desktop:context:get');
-        ctx.expect(snap.session.id).toBe(ctx.manager.context.session.id);
-        ctx.expect(snap.client.platform).toBe(ctx.manager.context.client.platform);
+        const snap = await ctx.omega.ipc.invoke('desktop:context:get');
+        ctx.expect(snap.session.id).toBe(ctx.omega.context.session.id);
+        ctx.expect(snap.client.platform).toBe(ctx.omega.context.client.platform);
       },
     },
   ],