@omega.js/desktop 0.52.0 → 0.54.0

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

@@ -15,11 +15,11 @@ module.exports = defineCases({
   description: 'ipc (main)',
   cleanup: (ctx) => {
     // Always tear down the test channels so suites don't bleed into each other.
-    if (ctx.manager.ipc.hasHandler(TEST_CHANNEL)) {
-      ctx.manager.ipc.unhandle(TEST_CHANNEL);
+    if (ctx.omega.ipc.hasHandler(TEST_CHANNEL)) {
+      ctx.omega.ipc.unhandle(TEST_CHANNEL);
     }
     // Best-effort: drain test listeners.
-    while (ctx.manager.ipc.listenerCount(TEST_LISTEN) > 0) {
+    while (ctx.omega.ipc.listenerCount(TEST_LISTEN) > 0) {
       // off() needs the original fn; nothing left to remove if our local refs are gone.
       // The listenerCount === 0 guard in off() will leave the registry clean once tests unsubscribe themselves.
       break;
@@ -29,26 +29,26 @@ module.exports = defineCases({
     {
       name: 'initialized after boot',
       run: (ctx) => {
-        ctx.expect(ctx.manager.ipc._initialized).toBe(true);
+        ctx.expect(ctx.omega.ipc._initialized).toBe(true);
       },
     },
     {
       name: 'storage handlers are registered on the ipc bus',
       run: (ctx) => {
-        ctx.expect(ctx.manager.ipc.hasHandler('desktop:storage:get')).toBe(true);
-        ctx.expect(ctx.manager.ipc.hasHandler('desktop:storage:set')).toBe(true);
-        ctx.expect(ctx.manager.ipc.hasHandler('desktop:storage:delete')).toBe(true);
-        ctx.expect(ctx.manager.ipc.hasHandler('desktop:storage:has')).toBe(true);
-        ctx.expect(ctx.manager.ipc.hasHandler('desktop:storage:clear')).toBe(true);
+        ctx.expect(ctx.omega.ipc.hasHandler('desktop:storage:get')).toBe(true);
+        ctx.expect(ctx.omega.ipc.hasHandler('desktop:storage:set')).toBe(true);
+        ctx.expect(ctx.omega.ipc.hasHandler('desktop:storage:delete')).toBe(true);
+        ctx.expect(ctx.omega.ipc.hasHandler('desktop:storage:has')).toBe(true);
+        ctx.expect(ctx.omega.ipc.hasHandler('desktop:storage:clear')).toBe(true);
       },
     },
     {
       name: 'handle + invoke round-trip',
       run: async (ctx) => {
-        ctx.manager.ipc.handle(TEST_CHANNEL, (payload) => {
+        ctx.omega.ipc.handle(TEST_CHANNEL, (payload) => {
           return { echoed: payload.value };
         });
-        const result = await ctx.manager.ipc.invoke(TEST_CHANNEL, { value: 42 });
+        const result = await ctx.omega.ipc.invoke(TEST_CHANNEL, { value: 42 });
         ctx.expect(result).toEqual({ echoed: 42 });
       },
     },
@@ -57,15 +57,15 @@ module.exports = defineCases({
       run: (ctx) => {
         // The previous test left TEST_CHANNEL registered.
         ctx.expect(() => {
-          ctx.manager.ipc.handle(TEST_CHANNEL, () => 'dup');
+          ctx.omega.ipc.handle(TEST_CHANNEL, () => 'dup');
         }).toThrow(/already has a handler/);
       },
     },
     {
       name: 'unhandle removes the handler',
       run: (ctx) => {
-        ctx.manager.ipc.unhandle(TEST_CHANNEL);
-        ctx.expect(ctx.manager.ipc.hasHandler(TEST_CHANNEL)).toBe(false);
+        ctx.omega.ipc.unhandle(TEST_CHANNEL);
+        ctx.expect(ctx.omega.ipc.hasHandler(TEST_CHANNEL)).toBe(false);
       },
     },
     {
@@ -73,7 +73,7 @@ module.exports = defineCases({
       run: async (ctx) => {
         let err;
         try {
-          await ctx.manager.ipc.invoke(TEST_CHANNEL, {});
+          await ctx.omega.ipc.invoke(TEST_CHANNEL, {});
         } catch (e) {
           err = e;
         }
@@ -84,28 +84,28 @@ module.exports = defineCases({
     {
       name: 'handler errors propagate through invoke',
       run: async (ctx) => {
-        ctx.manager.ipc.handle(TEST_CHANNEL, () => {
+        ctx.omega.ipc.handle(TEST_CHANNEL, () => {
           throw new Error('boom');
         });
         let err;
         try {
-          await ctx.manager.ipc.invoke(TEST_CHANNEL, {});
+          await ctx.omega.ipc.invoke(TEST_CHANNEL, {});
         } catch (e) {
           err = e;
         }
         ctx.expect(err).toBeDefined();
         ctx.expect(err.message).toBe('boom');
-        ctx.manager.ipc.unhandle(TEST_CHANNEL);
+        ctx.omega.ipc.unhandle(TEST_CHANNEL);
       },
     },
     {
       name: 'on registers a listener and returns an unsubscribe fn',
       run: (ctx) => {
         const fn = () => {};
-        const off = ctx.manager.ipc.on(TEST_LISTEN, fn);
-        ctx.expect(ctx.manager.ipc.listenerCount(TEST_LISTEN)).toBe(1);
+        const off = ctx.omega.ipc.on(TEST_LISTEN, fn);
+        ctx.expect(ctx.omega.ipc.listenerCount(TEST_LISTEN)).toBe(1);
         off();
-        ctx.expect(ctx.manager.ipc.listenerCount(TEST_LISTEN)).toBe(0);
+        ctx.expect(ctx.omega.ipc.listenerCount(TEST_LISTEN)).toBe(0);
       },
     },
     {
@@ -113,13 +113,13 @@ module.exports = defineCases({
       run: (ctx) => {
         const a = () => {};
         const b = () => {};
-        const offA = ctx.manager.ipc.on(TEST_LISTEN, a);
-        const offB = ctx.manager.ipc.on(TEST_LISTEN, b);
-        ctx.expect(ctx.manager.ipc.listenerCount(TEST_LISTEN)).toBe(2);
+        const offA = ctx.omega.ipc.on(TEST_LISTEN, a);
+        const offB = ctx.omega.ipc.on(TEST_LISTEN, b);
+        ctx.expect(ctx.omega.ipc.listenerCount(TEST_LISTEN)).toBe(2);
         offA();
-        ctx.expect(ctx.manager.ipc.listenerCount(TEST_LISTEN)).toBe(1);
+        ctx.expect(ctx.omega.ipc.listenerCount(TEST_LISTEN)).toBe(1);
         offB();
-        ctx.expect(ctx.manager.ipc.listenerCount(TEST_LISTEN)).toBe(0);
+        ctx.expect(ctx.omega.ipc.listenerCount(TEST_LISTEN)).toBe(0);
       },
     },
     {
@@ -127,15 +127,15 @@ module.exports = defineCases({
       run: (ctx) => {
         // Test harness runs with skipWindowCreation: true — no BrowserWindows exist.
         // This must not throw.
-        ctx.manager.ipc.broadcast('desktop:test:broadcast', { hello: 'world' });
+        ctx.omega.ipc.broadcast('desktop:test:broadcast', { hello: 'world' });
         ctx.expect(true).toBe(true);
       },
     },
     {
       name: 'send to a destroyed/null webContents is a safe no-op',
       run: (ctx) => {
-        ctx.manager.ipc.send(null, 'desktop:test:send', {});
-        ctx.manager.ipc.send({ isDestroyed: () => true }, 'desktop:test:send', {});
+        ctx.omega.ipc.send(null, 'desktop:test:send', {});
+        ctx.omega.ipc.send({ isDestroyed: () => true }, 'desktop:test:send', {});
         ctx.expect(true).toBe(true);
       },
     },
@@ -143,22 +143,22 @@ module.exports = defineCases({
       name: 'storage.set triggers ipc broadcast (no throw with zero renderers)',
       run: (ctx) => {
         // storage._broadcast routes through ipc.broadcast — confirm it runs cleanly here.
-        ctx.manager.storage.set('ipc-broadcast-probe', 1);
-        ctx.expect(ctx.manager.storage.get('ipc-broadcast-probe')).toBe(1);
-        ctx.manager.storage.delete('ipc-broadcast-probe');
+        ctx.omega.storage.set('ipc-broadcast-probe', 1);
+        ctx.expect(ctx.omega.storage.get('ipc-broadcast-probe')).toBe(1);
+        ctx.omega.storage.delete('ipc-broadcast-probe');
       },
     },
     {
       name: 'handle rejects non-string channel',
       run: (ctx) => {
-        ctx.expect(() => ctx.manager.ipc.handle('', () => {})).toThrow(/non-empty string/);
-        ctx.expect(() => ctx.manager.ipc.handle(null, () => {})).toThrow(/non-empty string/);
+        ctx.expect(() => ctx.omega.ipc.handle('', () => {})).toThrow(/non-empty string/);
+        ctx.expect(() => ctx.omega.ipc.handle(null, () => {})).toThrow(/non-empty string/);
       },
     },
     {
       name: 'handle rejects non-function handler',
       run: (ctx) => {
-        ctx.expect(() => ctx.manager.ipc.handle('desktop:test:bad', null)).toThrow(/handler must be a function/);
+        ctx.expect(() => ctx.omega.ipc.handle('desktop:test:bad', null)).toThrow(/handler must be a function/);
       },
     },
   ],

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

@@ -10,19 +10,19 @@ module.exports = defineCases({
   layer: 'main',
   description: 'menu (main)',
   cleanup: (ctx) => {
-    ctx.manager.menu.destroy();
+    ctx.omega.menu.destroy();
   },
   tests: [
     {
       name: 'initialize ran (enabled by default)',
       run: (ctx) => {
-        ctx.expect(ctx.manager.menu._initialized).toBe(true);
+        ctx.expect(ctx.omega.menu._initialized).toBe(true);
       },
     },
     {
       name: 'no consumer definition file → default template loaded',
       run: (ctx) => {
-        const items = ctx.manager.menu.getItems();
+        const items = ctx.omega.menu.getItems();
         ctx.expect(Array.isArray(items)).toBe(true);
         ctx.expect(items.length).toBeGreaterThan(0);
 
@@ -36,8 +36,8 @@ module.exports = defineCases({
     {
       name: 'default template renders and Menu.setApplicationMenu was called',
       run: (ctx) => {
-        ctx.expect(ctx.manager.menu.isRendered()).toBe(true);
-        ctx.expect(ctx.manager.menu.getMenu()).toBeTruthy();
+        ctx.expect(ctx.omega.menu.isRendered()).toBe(true);
+        ctx.expect(ctx.omega.menu.getMenu()).toBeTruthy();
       },
     },
     {
@@ -47,15 +47,15 @@ module.exports = defineCases({
           ctx.skip('macOS-only behavior');
         }
         // Menu falls back to brand.name when no productName is configured (lib/menu.js).
-        const productName = ctx.manager.config.app?.productName || ctx.manager.config.brand.name;
-        const items = ctx.manager.menu.getItems();
+        const productName = ctx.omega.config.app?.productName || ctx.omega.config.brand.name;
+        const items = ctx.omega.menu.getItems();
         ctx.expect(items[0].label).toBe(productName);
       },
     },
     {
       name: 'define() runs the builder fn and replaces items',
       run: (ctx) => {
-        ctx.manager.menu.define(({ menu }) => {
+        ctx.omega.menu.define(({ menu }) => {
           menu.menu('Test', [
             { label: 'Hello', click: () => {} },
             { type: 'separator' },
@@ -63,7 +63,7 @@ module.exports = defineCases({
           ]);
         });
 
-        const items = ctx.manager.menu.getItems();
+        const items = ctx.omega.menu.getItems();
         ctx.expect(items.length).toBe(1);
         ctx.expect(items[0].label).toBe('Test');
         ctx.expect(Array.isArray(items[0].submenu)).toBe(true);
@@ -73,28 +73,28 @@ module.exports = defineCases({
     {
       name: 'define() throws on non-function input',
       run: (ctx) => {
-        ctx.expect(() => ctx.manager.menu.define(null)).toThrow(/must be a function/);
+        ctx.expect(() => ctx.omega.menu.define(null)).toThrow(/must be a function/);
       },
     },
     {
       name: 'menu.menu(label, items) appends a top-level entry',
       run: (ctx) => {
-        ctx.manager.menu.define(({ menu }) => {
+        ctx.omega.menu.define(({ menu }) => {
           menu.menu('First', [{ label: 'a' }]);
           menu.menu('Second', [{ label: 'b' }]);
         });
-        const labels = ctx.manager.menu.getItems().map((i) => i.label);
+        const labels = ctx.omega.menu.getItems().map((i) => i.label);
         ctx.expect(labels).toEqual(['First', 'Second']);
       },
     },
     {
       name: 'useDefaults() replaces items with the platform default template',
       run: (ctx) => {
-        ctx.manager.menu.define(({ menu }) => {
+        ctx.omega.menu.define(({ menu }) => {
           menu.menu('Custom', [{ label: 'x' }]);
           menu.useDefaults();
         });
-        const labels = ctx.manager.menu.getItems().map((i) => i.label);
+        const labels = ctx.omega.menu.getItems().map((i) => i.label);
         ctx.expect(labels).toContain('Edit');
         ctx.expect(labels).not.toContain('Custom');
       },
@@ -102,20 +102,20 @@ module.exports = defineCases({
     {
       name: 'clear() empties the items list',
       run: (ctx) => {
-        ctx.manager.menu.define(({ menu }) => {
+        ctx.omega.menu.define(({ menu }) => {
           menu.menu('A', [{ label: 'a' }]);
           menu.clear();
         });
-        ctx.expect(ctx.manager.menu.getItems()).toEqual([]);
+        ctx.expect(ctx.omega.menu.getItems()).toEqual([]);
       },
     },
     {
       name: 'append() adds a raw descriptor at top level',
       run: (ctx) => {
-        ctx.manager.menu.define(({ menu }) => {
+        ctx.omega.menu.define(({ menu }) => {
           menu.append({ label: 'Raw', submenu: [{ label: 'inside' }] });
         });
-        const items = ctx.manager.menu.getItems();
+        const items = ctx.omega.menu.getItems();
         ctx.expect(items.length).toBe(1);
         ctx.expect(items[0].label).toBe('Raw');
       },
@@ -124,16 +124,16 @@ module.exports = defineCases({
       name: 'dynamic label functions are evaluated at resolve time',
       run: (ctx) => {
         let count = 0;
-        ctx.manager.menu.define(({ menu }) => {
+        ctx.omega.menu.define(({ menu }) => {
           menu.menu('Counter', [{ label: () => `Count: ${count}` }]);
         });
 
-        const item = ctx.manager.menu.getItems()[0].submenu[0];
-        const resolved1 = ctx.manager.menu._resolveItem(item);
+        const item = ctx.omega.menu.getItems()[0].submenu[0];
+        const resolved1 = ctx.omega.menu._resolveItem(item);
         ctx.expect(resolved1.label).toBe('Count: 0');
 
         count = 7;
-        const resolved2 = ctx.manager.menu._resolveItem(item);
+        const resolved2 = ctx.omega.menu._resolveItem(item);
         ctx.expect(resolved2.label).toBe('Count: 7');
       },
     },
@@ -141,13 +141,13 @@ module.exports = defineCases({
       name: 'click handlers are wrapped to catch errors',
       run: (ctx) => {
         let called = false;
-        ctx.manager.menu.define(({ menu }) => {
+        ctx.omega.menu.define(({ menu }) => {
           menu.menu('M', [
             { label: 'Boom', click: () => { called = true; throw new Error('boom'); } },
           ]);
         });
-        const inner = ctx.manager.menu.getItems()[0].submenu[0];
-        const resolved = ctx.manager.menu._resolveItem(inner);
+        const inner = ctx.omega.menu.getItems()[0].submenu[0];
+        const resolved = ctx.omega.menu._resolveItem(inner);
         resolved.click(null, null, null);
         ctx.expect(called).toBe(true);
       },
@@ -155,7 +155,7 @@ module.exports = defineCases({
     {
       name: 'submenu items are recursively resolved',
       run: (ctx) => {
-        ctx.manager.menu.define(({ menu }) => {
+        ctx.omega.menu.define(({ menu }) => {
           menu.menu('Top', [
             {
               label: 'Parent',
@@ -166,8 +166,8 @@ module.exports = defineCases({
             },
           ]);
         });
-        const top = ctx.manager.menu.getItems()[0];
-        const resolved = ctx.manager.menu._resolveItem(top);
+        const top = ctx.omega.menu.getItems()[0];
+        const resolved = ctx.omega.menu._resolveItem(top);
         ctx.expect(resolved.submenu[0].label).toBe('Parent');
         ctx.expect(resolved.submenu[0].submenu[0].label).toBe('Dyn child');
         ctx.expect(resolved.submenu[0].submenu[1].type).toBe('separator');
@@ -176,10 +176,10 @@ module.exports = defineCases({
     {
       name: 'default template includes platform-appropriate check-for-updates item',
       run: (ctx) => {
-        ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
+        ctx.omega.menu.define(({ menu: m }) => m.useDefaults());
         // Mac → main/check-for-updates; win/linux → help/check-for-updates.
         const id = process.platform === 'darwin' ? 'main/check-for-updates' : 'help/check-for-updates';
-        const item = ctx.manager.menu.find(id);
+        const item = ctx.omega.menu.find(id);
         ctx.expect(item).toBeTruthy();
         ctx.expect(typeof item.label).toBe('string');
         ctx.expect(typeof item.click).toBe('function');
@@ -188,24 +188,24 @@ module.exports = defineCases({
     {
       name: 'find returns null for unknown id',
       run: (ctx) => {
-        ctx.expect(ctx.manager.menu.find('does-not-exist')).toBe(null);
+        ctx.expect(ctx.omega.menu.find('does-not-exist')).toBe(null);
       },
     },
     {
       name: 'update patches label and re-renders',
       run: (ctx) => {
-        ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
+        ctx.omega.menu.define(({ menu: m }) => m.useDefaults());
         const id = process.platform === 'darwin' ? 'main/check-for-updates' : 'help/check-for-updates';
-        const ok = ctx.manager.menu.update(id, { label: 'PROBE LABEL' });
+        const ok = ctx.omega.menu.update(id, { label: 'PROBE LABEL' });
         ctx.expect(ok).toBe(true);
-        const item = ctx.manager.menu.find(id);
+        const item = ctx.omega.menu.find(id);
         ctx.expect(item.label).toBe('PROBE LABEL');
       },
     },
     {
       name: 'update returns false for unknown id',
       run: (ctx) => {
-        const ok = ctx.manager.menu.update('nope', { label: 'nope' });
+        const ok = ctx.omega.menu.update('nope', { label: 'nope' });
         ctx.expect(ok).toBe(false);
       },
     },
@@ -213,41 +213,41 @@ module.exports = defineCases({
       name: 'remove deletes item from tree',
       run: (ctx) => {
         // Recreate the default template so we have the item to remove (previous test may have mutated).
-        ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
+        ctx.omega.menu.define(({ menu: m }) => m.useDefaults());
         const id = process.platform === 'darwin' ? 'main/check-for-updates' : 'help/check-for-updates';
-        ctx.expect(ctx.manager.menu.find(id)).toBeTruthy();
+        ctx.expect(ctx.omega.menu.find(id)).toBeTruthy();
 
-        const removed = ctx.manager.menu.remove(id);
+        const removed = ctx.omega.menu.remove(id);
         ctx.expect(removed).toBe(true);
-        ctx.expect(ctx.manager.menu.find(id)).toBe(null);
+        ctx.expect(ctx.omega.menu.find(id)).toBe(null);
 
         // Restore for subsequent tests.
-        ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
+        ctx.omega.menu.define(({ menu: m }) => m.useDefaults());
       },
     },
     {
       name: 'insertAfter splices in a new sibling by id-path',
       run: (ctx) => {
-        ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
+        ctx.omega.menu.define(({ menu: m }) => m.useDefaults());
         const anchor = process.platform === 'darwin' ? 'main/check-for-updates' : 'help/check-for-updates';
-        const ok = ctx.manager.menu.insertAfter(anchor, { id: 'main/preferences', label: 'PREF PROBE' });
+        const ok = ctx.omega.menu.insertAfter(anchor, { id: 'main/preferences', label: 'PREF PROBE' });
         ctx.expect(ok).toBe(true);
-        ctx.expect(ctx.manager.menu.find('main/preferences')).toBeTruthy();
+        ctx.expect(ctx.omega.menu.find('main/preferences')).toBeTruthy();
       },
     },
     {
       name: 'auto-updater status updates the menu item label',
       run: async (ctx) => {
-        ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
+        ctx.omega.menu.define(({ menu: m }) => m.useDefaults());
 
         // Force a known state and trigger menu update.
-        ctx.manager.autoUpdater._state = {
+        ctx.omega.autoUpdater._state = {
           code: 'downloaded', version: '5.0.0', percent: 100, error: null, downloadedAt: Date.now(), lastCheckedAt: null,
         };
-        ctx.manager.autoUpdater._updateMenuItem();
+        ctx.omega.autoUpdater._updateMenuItem();
 
         const id = process.platform === 'darwin' ? 'main/check-for-updates' : 'help/check-for-updates';
-        const item = ctx.manager.menu.find(id);
+        const item = ctx.omega.menu.find(id);
         ctx.expect(item.label).toContain('Restart to Update');
         ctx.expect(item.label).toContain('5.0.0');
         ctx.expect(item.enabled).toBe(true);
@@ -256,28 +256,29 @@ module.exports = defineCases({
     {
       name: 'auto-updater downloading status disables item',
       run: (ctx) => {
-        ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
+        ctx.omega.menu.define(({ menu: m }) => m.useDefaults());
 
-        ctx.manager.autoUpdater._state = {
+        ctx.omega.autoUpdater._state = {
           code: 'downloading', version: '5.0.0', percent: 42, error: null, downloadedAt: null, lastCheckedAt: null,
         };
-        ctx.manager.autoUpdater._updateMenuItem();
+        ctx.omega.autoUpdater._updateMenuItem();
 
         const id = process.platform === 'darwin' ? 'main/check-for-updates' : 'help/check-for-updates';
-        const item = ctx.manager.menu.find(id);
+        const item = ctx.omega.menu.find(id);
         ctx.expect(item.label).toContain('42%');
         ctx.expect(item.enabled).toBe(false);
       },
     },
     {
-      name: 'consumer function receives manager + menu builder + defaults',
+      name: 'consumer function receives omega + menu builder + defaults (no manager key)',
       run: (ctx) => {
         let received;
-        ctx.manager.menu.define((arg) => {
+        ctx.omega.menu.define((arg) => {
           received = arg;
           arg.menu.menu('probe', []);
         });
-        ctx.expect(received.manager).toBe(ctx.manager);
+        ctx.expect(received.omega).toBe(ctx.omega);
+        ctx.expect(received.manager).toBeUndefined();
         ctx.expect(typeof received.menu.menu).toBe('function');
         ctx.expect(typeof received.menu.useDefaults).toBe('function');
         ctx.expect(typeof received.menu.clear).toBe('function');
@@ -292,39 +293,39 @@ module.exports = defineCases({
     {
       name: 'menu.has reports presence by id-path',
       run: (ctx) => {
-        ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
-        ctx.expect(ctx.manager.menu.has('edit/copy')).toBe(true);
-        ctx.expect(ctx.manager.menu.has('edit/does-not-exist')).toBe(false);
+        ctx.omega.menu.define(({ menu: m }) => m.useDefaults());
+        ctx.expect(ctx.omega.menu.has('edit/copy')).toBe(true);
+        ctx.expect(ctx.omega.menu.has('edit/does-not-exist')).toBe(false);
       },
     },
     {
       name: 'menu.hide / menu.show toggle visibility by id-path',
       run: (ctx) => {
-        ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
-        ctx.manager.menu.hide('edit/copy');
-        ctx.expect(ctx.manager.menu.find('edit/copy').visible).toBe(false);
-        ctx.manager.menu.show('edit/copy');
-        ctx.expect(ctx.manager.menu.find('edit/copy').visible).toBe(true);
+        ctx.omega.menu.define(({ menu: m }) => m.useDefaults());
+        ctx.omega.menu.hide('edit/copy');
+        ctx.expect(ctx.omega.menu.find('edit/copy').visible).toBe(false);
+        ctx.omega.menu.show('edit/copy');
+        ctx.expect(ctx.omega.menu.find('edit/copy').visible).toBe(true);
       },
     },
     {
       name: 'menu.enable toggles enabled by id-path',
       run: (ctx) => {
-        ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
-        ctx.manager.menu.enable('edit/copy', false);
-        ctx.expect(ctx.manager.menu.find('edit/copy').enabled).toBe(false);
-        ctx.manager.menu.enable('edit/copy');
-        ctx.expect(ctx.manager.menu.find('edit/copy').enabled).toBe(true);
+        ctx.omega.menu.define(({ menu: m }) => m.useDefaults());
+        ctx.omega.menu.enable('edit/copy', false);
+        ctx.expect(ctx.omega.menu.find('edit/copy').enabled).toBe(false);
+        ctx.omega.menu.enable('edit/copy');
+        ctx.expect(ctx.omega.menu.find('edit/copy').enabled).toBe(true);
       },
     },
     {
       name: 'menu.insertBefore splices into a submenu by id-path',
       run: (ctx) => {
-        ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
-        const ok = ctx.manager.menu.insertBefore('edit/copy', { id: 'edit/probe', label: 'PROBE' });
+        ctx.omega.menu.define(({ menu: m }) => m.useDefaults());
+        const ok = ctx.omega.menu.insertBefore('edit/copy', { id: 'edit/probe', label: 'PROBE' });
         ctx.expect(ok).toBe(true);
         // Find the edit submenu and confirm probe is right before copy.
-        const edit = ctx.manager.menu.find('edit');
+        const edit = ctx.omega.menu.find('edit');
         const sub  = edit.submenu;
         const copyIdx  = sub.findIndex((i) => i.id === 'edit/copy');
         const probeIdx = sub.findIndex((i) => i.id === 'edit/probe');
@@ -334,45 +335,45 @@ module.exports = defineCases({
     {
       name: 'menu.appendTo pushes into a submenu (creating it if absent)',
       run: (ctx) => {
-        ctx.manager.menu.define(({ menu: m }) => {
+        ctx.omega.menu.define(({ menu: m }) => {
           m.menu('Tools', []);
         });
-        const ok = ctx.manager.menu.appendTo('Tools', { id: 'tools/x', label: 'X' });
+        const ok = ctx.omega.menu.appendTo('Tools', { id: 'tools/x', label: 'X' });
         // 'Tools' was added with label='Tools' but no id field — appendTo lookups id-path,
         // so this should miss. Use a different anchor that has an id.
         ctx.expect(ok).toBe(false);
 
-        ctx.manager.menu.define(({ menu: m }) => {
+        ctx.omega.menu.define(({ menu: m }) => {
           m.append({ id: 'tools', label: 'Tools', submenu: [] });
         });
-        const ok2 = ctx.manager.menu.appendTo('tools', { id: 'tools/x', label: 'X' });
+        const ok2 = ctx.omega.menu.appendTo('tools', { id: 'tools/x', label: 'X' });
         ctx.expect(ok2).toBe(true);
-        ctx.expect(ctx.manager.menu.find('tools').submenu[0].id).toBe('tools/x');
+        ctx.expect(ctx.omega.menu.find('tools').submenu[0].id).toBe('tools/x');
       },
     },
     {
       name: 'menu deep-path lookup walks segments (view/developer/toggle-devtools)',
       run: (ctx) => {
         // Force isDevelopment() so the dev menu renders.
-        const orig = ctx.manager.isDevelopment;
-        ctx.manager.isDevelopment = () => true;
+        const orig = ctx.omega.isDevelopment;
+        ctx.omega.isDevelopment = () => true;
         try {
-          ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
-          ctx.expect(ctx.manager.menu.has('view/developer')).toBe(true);
-          ctx.expect(ctx.manager.menu.has('view/developer/toggle-devtools')).toBe(true);
+          ctx.omega.menu.define(({ menu: m }) => m.useDefaults());
+          ctx.expect(ctx.omega.menu.has('view/developer')).toBe(true);
+          ctx.expect(ctx.omega.menu.has('view/developer/toggle-devtools')).toBe(true);
         } finally {
-          ctx.manager.isDevelopment = orig;
+          ctx.omega.isDevelopment = orig;
         }
       },
     },
     {
       name: 'view/developer carries the Simulate update submenu (dev only)',
       run: (ctx) => {
-        const orig = ctx.manager.isDevelopment;
-        ctx.manager.isDevelopment = () => true;
+        const orig = ctx.omega.isDevelopment;
+        ctx.omega.isDevelopment = () => true;
         try {
-          ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
-          const item = ctx.manager.menu.find('view/developer/simulate-update');
+          ctx.omega.menu.define(({ menu: m }) => m.useDefaults());
+          const item = ctx.omega.menu.find('view/developer/simulate-update');
           ctx.expect(item).toBeTruthy();
           ctx.expect(item.label).toBe('Simulate update');
           ctx.expect(item.submenu.map((i) => i.id)).toEqual([
@@ -381,37 +382,37 @@ module.exports = defineCases({
             'view/developer/simulate-update/error',
           ]);
         } finally {
-          ctx.manager.isDevelopment = orig;
+          ctx.omega.isDevelopment = orig;
         }
 
-        ctx.manager.isDevelopment = () => false;
+        ctx.omega.isDevelopment = () => false;
         try {
-          ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
-          ctx.expect(ctx.manager.menu.has('view/developer/simulate-update')).toBe(false);
+          ctx.omega.menu.define(({ menu: m }) => m.useDefaults());
+          ctx.expect(ctx.omega.menu.has('view/developer/simulate-update')).toBe(false);
         } finally {
-          ctx.manager.isDevelopment = orig;
+          ctx.omega.isDevelopment = orig;
         }
       },
     },
     {
       name: 'menu development top-level appears only in dev mode',
       run: (ctx) => {
-        const orig = ctx.manager.isDevelopment;
-        ctx.manager.isDevelopment = () => true;
+        const orig = ctx.omega.isDevelopment;
+        ctx.omega.isDevelopment = () => true;
         try {
-          ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
-          ctx.expect(ctx.manager.menu.has('development')).toBe(true);
-          ctx.expect(ctx.manager.menu.has('development/open-logs')).toBe(true);
+          ctx.omega.menu.define(({ menu: m }) => m.useDefaults());
+          ctx.expect(ctx.omega.menu.has('development')).toBe(true);
+          ctx.expect(ctx.omega.menu.has('development/open-logs')).toBe(true);
         } finally {
-          ctx.manager.isDevelopment = orig;
+          ctx.omega.isDevelopment = orig;
         }
 
-        ctx.manager.isDevelopment = () => false;
+        ctx.omega.isDevelopment = () => false;
         try {
-          ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
-          ctx.expect(ctx.manager.menu.has('development')).toBe(false);
+          ctx.omega.menu.define(({ menu: m }) => m.useDefaults());
+          ctx.expect(ctx.omega.menu.has('development')).toBe(false);
         } finally {
-          ctx.manager.isDevelopment = orig;
+          ctx.omega.isDevelopment = orig;
         }
       },
     },