@omega.js/desktop 0.51.0 → 0.53.0

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

@@ -3,7 +3,7 @@
 //     harness, " (Development)" in dev, untouched in production
 //   - app.userAgentFallback is set to a branded template via node-powertools.template
 //
-// These are observable side-effects of `manager.initialize()` so we just inspect
+// These are observable side-effects of `omega.initialize()` so we just inspect
 // the live electron `app` after the harness boot.
 
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
@@ -34,7 +34,7 @@ module.exports = defineCases({
         const userData = app.getPath('userData');
         // The wipe ran before storage.initialize(); only files written by THIS
         // boot may exist. A marker from a previous run must never survive.
-        const marker = path.join(userData, '__em-wipe-marker');
+        const marker = path.join(userData, '__omega-wipe-marker');
         ctx.expect(fs.existsSync(marker)).toBe(false);
         // Leave a marker so the NEXT run proves the wipe (self-perpetuating check).
         fs.mkdirSync(userData, { recursive: true });
@@ -63,8 +63,8 @@ module.exports = defineCases({
       name: 'userAgentFallback contains the brand name from config',
       run: (ctx) => {
         const { app } = require('electron');
-        const brand = ctx.manager.config?.brand?.name
-          || ctx.manager.config?.app?.productName
+        const brand = ctx.omega.config?.brand?.name
+          || ctx.omega.config?.app?.productName
           || 'App';
         ctx.expect(app.userAgentFallback).toContain(brand);
       },

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

@@ -13,78 +13,78 @@ module.exports = defineCases({
   description: 'startup (main)',
   cleanup: (ctx) => {
     // Restore default mode so no later suite is affected.
-    if (ctx.manager.config?.startup) {
-      ctx.manager.config.startup.mode = 'normal';
+    if (ctx.omega.config?.startup) {
+      ctx.omega.config.startup.mode = 'normal';
     }
   },
   tests: [
     {
       name: 'initialize ran during boot',
       run: (ctx) => {
-        ctx.expect(ctx.manager.startup._initialized).toBe(true);
+        ctx.expect(ctx.omega.startup._initialized).toBe(true);
       },
     },
     {
       name: 'getMode returns "normal" by default',
       run: (ctx) => {
-        ctx.manager.config.startup.mode = 'normal';
-        ctx.expect(ctx.manager.startup.getMode()).toBe('normal');
+        ctx.omega.config.startup.mode = 'normal';
+        ctx.expect(ctx.omega.startup.getMode()).toBe('normal');
       },
     },
     {
       name: 'getMode honors valid values',
       run: (ctx) => {
         for (const mode of ['normal', 'hidden']) {
-          ctx.manager.config.startup.mode = mode;
-          ctx.expect(ctx.manager.startup.getMode()).toBe(mode);
+          ctx.omega.config.startup.mode = mode;
+          ctx.expect(ctx.omega.startup.getMode()).toBe(mode);
         }
       },
     },
     {
       name: 'getMode falls back to "normal" for unknown values',
       run: (ctx) => {
-        ctx.manager.config.startup.mode = 'banana';
-        ctx.expect(ctx.manager.startup.getMode()).toBe('normal');
+        ctx.omega.config.startup.mode = 'banana';
+        ctx.expect(ctx.omega.startup.getMode()).toBe('normal');
       },
     },
     {
       name: 'getMode rejects deprecated tray-only as unknown (falls back to normal)',
       run: (ctx) => {
         // tray-only was folded into hidden; it's no longer a valid mode.
-        ctx.manager.config.startup.mode = 'tray-only';
-        ctx.expect(ctx.manager.startup.getMode()).toBe('normal');
+        ctx.omega.config.startup.mode = 'tray-only';
+        ctx.expect(ctx.omega.startup.getMode()).toBe('normal');
       },
     },
     {
       name: 'isLaunchHidden true for hidden, false for normal',
       run: (ctx) => {
-        ctx.manager.config.startup.mode = 'normal';
-        ctx.expect(ctx.manager.startup.isLaunchHidden()).toBe(false);
-        ctx.manager.config.startup.mode = 'hidden';
-        ctx.expect(ctx.manager.startup.isLaunchHidden()).toBe(true);
+        ctx.omega.config.startup.mode = 'normal';
+        ctx.expect(ctx.omega.startup.isLaunchHidden()).toBe(false);
+        ctx.omega.config.startup.mode = 'hidden';
+        ctx.expect(ctx.omega.startup.isLaunchHidden()).toBe(true);
       },
     },
     {
       name: 'applyEarly is a no-op outside hidden mode',
       run: (ctx) => {
-        ctx.manager.config.startup.mode = 'normal';
+        ctx.omega.config.startup.mode = 'normal';
         // Just confirm it doesn't throw.
-        ctx.manager.startup.applyEarly();
+        ctx.omega.startup.applyEarly();
         ctx.expect(true).toBe(true);
       },
     },
     {
       name: 'applyEarly does not throw for hidden mode',
       run: (ctx) => {
-        ctx.manager.config.startup.mode = 'hidden';
-        ctx.manager.startup.applyEarly();
+        ctx.omega.config.startup.mode = 'hidden';
+        ctx.omega.startup.applyEarly();
         ctx.expect(true).toBe(true);
       },
     },
     {
       name: 'isOpenAtLogin returns a boolean (or null on platforms without support)',
       run: (ctx) => {
-        const v = ctx.manager.startup.isOpenAtLogin();
+        const v = ctx.omega.startup.isOpenAtLogin();
         ctx.expect(v === null || typeof v === 'boolean').toBe(true);
       },
     },
@@ -92,7 +92,7 @@ module.exports = defineCases({
       name: 'setOpenAtLogin runs without throwing',
       run: (ctx) => {
         // Set to false to avoid actually registering the test harness for login on the dev box.
-        ctx.manager.startup.setOpenAtLogin(false);
+        ctx.omega.startup.setOpenAtLogin(false);
         ctx.expect(true).toBe(true);
       },
     },
@@ -100,17 +100,17 @@ module.exports = defineCases({
       name: 'setOpenAtLogin accepts the object form { enabled, mode }',
       run: (ctx) => {
         // Object form should not throw and should round-trip the args/openAsHidden flags.
-        ctx.manager.startup.setOpenAtLogin({ enabled: false, mode: 'normal' });
-        ctx.manager.startup.setOpenAtLogin({ enabled: true,  mode: 'hidden' });
+        ctx.omega.startup.setOpenAtLogin({ enabled: false, mode: 'normal' });
+        ctx.omega.startup.setOpenAtLogin({ enabled: true,  mode: 'hidden' });
         // Restore to disabled at end so we don't leave the test harness as a login item.
-        ctx.manager.startup.setOpenAtLogin(false);
+        ctx.omega.startup.setOpenAtLogin(false);
         ctx.expect(true).toBe(true);
       },
     },
     {
       name: 'wasLaunchedAtLogin returns a boolean',
       run: (ctx) => {
-        ctx.expect(typeof ctx.manager.startup.wasLaunchedAtLogin()).toBe('boolean');
+        ctx.expect(typeof ctx.omega.startup.wasLaunchedAtLogin()).toBe('boolean');
       },
     },
     {
@@ -119,7 +119,7 @@ module.exports = defineCases({
         // The harness runs unpackaged, so initialize() must have force-OFF'd the login item.
         // Confirm the current OS state reflects that — getLoginItemSettings should report
         // openAtLogin: false. (Note: returns null on platforms without LoginItemSettings.)
-        const live = ctx.manager.startup.isOpenAtLogin();
+        const live = ctx.omega.startup.isOpenAtLogin();
         if (live !== null) {
           ctx.expect(live).toBe(false);
         }

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

@@ -1,6 +1,6 @@
 // Main-process tests for the global raw-BrowserWindow test stealth:
 // utils/stealth-window.js applied by main.js's `browser-window-created` hook
-// (registered during Manager.initialize step 1a-ii — this harness IS Testing
+// (registered during omega.initialize() step 1a-ii — this harness IS Testing
 // mode, so the hook is live).
 //
 // Named windows created through lib/window-manager have their own stealth path

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

@@ -1,6 +1,6 @@
 // Main-process tests for lib/storage.js — round-trip, dot-notation, persistence, broadcast.
 //
-// ctx.manager is a fully-initialized @omega.js/desktop Manager (skipWindowCreation: true).
+// ctx.omega is a fully-initialized @omega.js/desktop main instance (skipWindowCreation: true).
 
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
 
@@ -9,58 +9,58 @@ module.exports = defineCases({
   layer: 'main',
   description: 'storage (main)',
   cleanup: async (ctx) => {
-    ctx.manager.storage.clear();
+    ctx.omega.storage.clear();
   },
   tests: [
     {
       name: 'set + get round-trip',
       run: (ctx) => {
-        ctx.manager.storage.set('hello', 'world');
-        ctx.expect(ctx.manager.storage.get('hello')).toBe('world');
+        ctx.omega.storage.set('hello', 'world');
+        ctx.expect(ctx.omega.storage.get('hello')).toBe('world');
       },
     },
     {
       name: 'get returns default when missing',
       run: (ctx) => {
-        ctx.expect(ctx.manager.storage.get('nope', 'fallback')).toBe('fallback');
-        ctx.expect(ctx.manager.storage.get('nope')).toBeUndefined();
+        ctx.expect(ctx.omega.storage.get('nope', 'fallback')).toBe('fallback');
+        ctx.expect(ctx.omega.storage.get('nope')).toBeUndefined();
       },
     },
     {
       name: 'has reflects presence',
       run: (ctx) => {
-        ctx.manager.storage.set('present', 1);
-        ctx.expect(ctx.manager.storage.has('present')).toBe(true);
-        ctx.expect(ctx.manager.storage.has('absent')).toBe(false);
+        ctx.omega.storage.set('present', 1);
+        ctx.expect(ctx.omega.storage.has('present')).toBe(true);
+        ctx.expect(ctx.omega.storage.has('absent')).toBe(false);
       },
     },
     {
       name: 'delete removes the key',
       run: (ctx) => {
-        ctx.manager.storage.set('temp', 'x');
-        ctx.manager.storage.delete('temp');
-        ctx.expect(ctx.manager.storage.has('temp')).toBe(false);
+        ctx.omega.storage.set('temp', 'x');
+        ctx.omega.storage.delete('temp');
+        ctx.expect(ctx.omega.storage.has('temp')).toBe(false);
       },
     },
     {
       name: 'dot-notation nested paths',
       run: (ctx) => {
-        ctx.manager.storage.set('window.main.bounds', { x: 10, y: 20, w: 800, h: 600 });
-        ctx.expect(ctx.manager.storage.get('window.main.bounds')).toEqual({ x: 10, y: 20, w: 800, h: 600 });
-        ctx.expect(ctx.manager.storage.get('window.main.bounds.w')).toBe(800);
+        ctx.omega.storage.set('window.main.bounds', { x: 10, y: 20, w: 800, h: 600 });
+        ctx.expect(ctx.omega.storage.get('window.main.bounds')).toEqual({ x: 10, y: 20, w: 800, h: 600 });
+        ctx.expect(ctx.omega.storage.get('window.main.bounds.w')).toBe(800);
       },
     },
     {
       name: 'onChange fires for the watched key',
       run: async (ctx) => {
         const calls = [];
-        const unsub = ctx.manager.storage.onChange('watched', (value, previous) => {
+        const unsub = ctx.omega.storage.onChange('watched', (value, previous) => {
           calls.push({ value, previous });
         });
-        ctx.manager.storage.set('watched', 'first');
-        ctx.manager.storage.set('watched', 'second');
+        ctx.omega.storage.set('watched', 'first');
+        ctx.omega.storage.set('watched', 'second');
         unsub();
-        ctx.manager.storage.set('watched', 'third'); // should NOT fire after unsub
+        ctx.omega.storage.set('watched', 'third'); // should NOT fire after unsub
         ctx.expect(calls.length).toBe(2);
         ctx.expect(calls[0].value).toBe('first');
         ctx.expect(calls[1].value).toBe('second');
@@ -70,17 +70,17 @@ module.exports = defineCases({
     {
       name: 'clear empties the store',
       run: (ctx) => {
-        ctx.manager.storage.set('a', 1);
-        ctx.manager.storage.set('b', 2);
-        ctx.manager.storage.clear();
-        ctx.expect(ctx.manager.storage.has('a')).toBe(false);
-        ctx.expect(ctx.manager.storage.has('b')).toBe(false);
+        ctx.omega.storage.set('a', 1);
+        ctx.omega.storage.set('b', 2);
+        ctx.omega.storage.clear();
+        ctx.expect(ctx.omega.storage.has('a')).toBe(false);
+        ctx.expect(ctx.omega.storage.has('b')).toBe(false);
       },
     },
     {
       name: 'getPath returns the on-disk file location',
       run: (ctx) => {
-        const p = ctx.manager.storage.getPath();
+        const p = ctx.omega.storage.getPath();
         ctx.expect(typeof p).toBe('string');
         ctx.expect(p).toMatch(/omega-storage\.json$/);
       },

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

@@ -1,7 +1,7 @@
 // Main-process tests for lib/theme.js — source/resolved round-trip, nativeTheme
 // wiring, persistence, change events (with dedupe), IPC handlers, validation.
 //
-// ctx.manager is a fully-initialized @omega.js/desktop Manager. Every test that mutates the theme
+// ctx.omega is a fully-initialized @omega.js/desktop main instance. Every test that mutates the theme
 // restores it; cleanup() resets to the pre-suite source and clears the persisted
 // override so later suites (and re-runs) start clean.
 
@@ -15,60 +15,60 @@ module.exports = defineCases({
   description: 'theme (main)',
   cleanup: async (ctx) => {
     if (originalSource) {
-      ctx.manager.theme.set(originalSource);
+      ctx.omega.theme.set(originalSource);
     }
-    ctx.manager.storage.delete('theme.appearance');
+    ctx.omega.storage.delete('theme.appearance');
   },
   tests: [
     {
-      name: 'manager.theme is initialized with the full API surface',
+      name: 'omega.theme is initialized with the full API surface',
       run: (ctx) => {
-        originalSource = ctx.manager.theme.get();
-        ctx.expect(ctx.manager.theme._initialized).toBe(true);
-        ctx.expect(typeof ctx.manager.theme.get).toBe('function');
-        ctx.expect(typeof ctx.manager.theme.set).toBe('function');
-        ctx.expect(typeof ctx.manager.theme.resolved).toBe('function');
-        ctx.expect(typeof ctx.manager.theme.onChange).toBe('function');
+        originalSource = ctx.omega.theme.get();
+        ctx.expect(ctx.omega.theme._initialized).toBe(true);
+        ctx.expect(typeof ctx.omega.theme.get).toBe('function');
+        ctx.expect(typeof ctx.omega.theme.set).toBe('function');
+        ctx.expect(typeof ctx.omega.theme.resolved).toBe('function');
+        ctx.expect(typeof ctx.omega.theme.onChange).toBe('function');
       },
     },
     {
       name: 'get() returns a valid source and resolved() a concrete appearance',
       run: (ctx) => {
-        ctx.expect(['system', 'light', 'dark'].includes(ctx.manager.theme.get())).toBe(true);
-        ctx.expect(['light', 'dark'].includes(ctx.manager.theme.resolved())).toBe(true);
+        ctx.expect(['system', 'light', 'dark'].includes(ctx.omega.theme.get())).toBe(true);
+        ctx.expect(['light', 'dark'].includes(ctx.omega.theme.resolved())).toBe(true);
       },
     },
     {
       name: 'set("dark") drives nativeTheme.themeSource, resolution, and persistence',
       run: (ctx) => {
         const { nativeTheme } = require('electron');
-        ctx.manager.theme.set('dark');
-        ctx.expect(ctx.manager.theme.get()).toBe('dark');
-        ctx.expect(ctx.manager.theme.resolved()).toBe('dark');
+        ctx.omega.theme.set('dark');
+        ctx.expect(ctx.omega.theme.get()).toBe('dark');
+        ctx.expect(ctx.omega.theme.resolved()).toBe('dark');
         ctx.expect(nativeTheme.themeSource).toBe('dark');
         ctx.expect(nativeTheme.shouldUseDarkColors).toBe(true);
-        ctx.expect(ctx.manager.storage.get('theme.appearance')).toBe('dark');
+        ctx.expect(ctx.omega.storage.get('theme.appearance')).toBe('dark');
       },
     },
     {
       name: 'set("light") flips the resolution',
       run: (ctx) => {
-        ctx.manager.theme.set('light');
-        ctx.expect(ctx.manager.theme.get()).toBe('light');
-        ctx.expect(ctx.manager.theme.resolved()).toBe('light');
-        ctx.expect(ctx.manager.storage.get('theme.appearance')).toBe('light');
+        ctx.omega.theme.set('light');
+        ctx.expect(ctx.omega.theme.get()).toBe('light');
+        ctx.expect(ctx.omega.theme.resolved()).toBe('light');
+        ctx.expect(ctx.omega.storage.get('theme.appearance')).toBe('light');
       },
     },
     {
       name: 'set("system") returns to following the OS',
       run: (ctx) => {
         const { nativeTheme } = require('electron');
-        ctx.manager.theme.set('system');
-        ctx.expect(ctx.manager.theme.get()).toBe('system');
+        ctx.omega.theme.set('system');
+        ctx.expect(ctx.omega.theme.get()).toBe('system');
         ctx.expect(nativeTheme.themeSource).toBe('system');
         // In system mode the resolution is whatever the OS says — assert coherence,
         // not a specific value (the test machine's OS preference is not ours to pin).
-        ctx.expect(ctx.manager.theme.resolved()).toBe(nativeTheme.shouldUseDarkColors ? 'dark' : 'light');
+        ctx.expect(ctx.omega.theme.resolved()).toBe(nativeTheme.shouldUseDarkColors ? 'dark' : 'light');
       },
     },
     {
@@ -76,7 +76,7 @@ module.exports = defineCases({
       run: (ctx) => {
         let threw = false;
         try {
-          ctx.manager.theme.set('auto');
+          ctx.omega.theme.set('auto');
         } catch (e) {
           threw = true;
         }
@@ -84,7 +84,7 @@ module.exports = defineCases({
 
         threw = false;
         try {
-          ctx.manager.theme.set(undefined);
+          ctx.omega.theme.set(undefined);
         } catch (e) {
           threw = true;
         }
@@ -94,17 +94,17 @@ module.exports = defineCases({
     {
       name: 'onChange fires once per effective change (deduped) and unsubscribes',
       run: (ctx) => {
-        ctx.manager.theme.set('light');
+        ctx.omega.theme.set('light');
 
         const calls = [];
-        const unsub = ctx.manager.theme.onChange((payload) => calls.push(payload));
+        const unsub = ctx.omega.theme.onChange((payload) => calls.push(payload));
 
-        ctx.manager.theme.set('dark');   // change → fires
-        ctx.manager.theme.set('dark');   // no-op → silent
-        ctx.manager.theme.set('light');  // change → fires
+        ctx.omega.theme.set('dark');   // change → fires
+        ctx.omega.theme.set('dark');   // no-op → silent
+        ctx.omega.theme.set('light');  // change → fires
 
         unsub();
-        ctx.manager.theme.set('dark');   // unsubscribed → silent
+        ctx.omega.theme.set('dark');   // unsubscribed → silent
 
         ctx.expect(calls.length).toBe(2);
         ctx.expect(calls[0]).toEqual({ source: 'dark', resolved: 'dark' });
@@ -114,10 +114,10 @@ module.exports = defineCases({
     {
       name: 'desktop:theme:get / desktop:theme:set IPC handlers round-trip',
       run: async (ctx) => {
-        const set = await ctx.manager.ipc.invoke('desktop:theme:set', { source: 'dark' });
+        const set = await ctx.omega.ipc.invoke('desktop:theme:set', { source: 'dark' });
         ctx.expect(set).toEqual({ source: 'dark', resolved: 'dark' });
 
-        const got = await ctx.manager.ipc.invoke('desktop:theme:get');
+        const got = await ctx.omega.ipc.invoke('desktop:theme:get');
         ctx.expect(got).toEqual({ source: 'dark', resolved: 'dark' });
       },
     },
@@ -126,7 +126,7 @@ module.exports = defineCases({
       run: async (ctx) => {
         let threw = false;
         try {
-          await ctx.manager.ipc.invoke('desktop:theme:set', { source: 'midnight' });
+          await ctx.omega.ipc.invoke('desktop:theme:set', { source: 'midnight' });
         } catch (e) {
           threw = true;
         }