@omega.js/desktop 0.51.0 → 0.53.0

package/dist/lib/fontawesome.js

@@ -12,8 +12,8 @@
 //      partial Pro supply never loses icons the free set has.
 //
 // Main-side API:
-//   manager.fontawesome.get(name, style)  → svg string | null   ('play', 'solid')
-//   manager.fontawesome.has(name, style)  → boolean
+//   omega.fontawesome.get(name, style)  → svg string | null   ('play', 'solid')
+//   omega.fontawesome.has(name, style)  → boolean
 //
 // Renderer-side (preload contextBridge):
 //   window.desktop.fontawesome.get(name, style) → Promise<svg string | null>
@@ -54,17 +54,17 @@ const logger = new LoggerLite('fontawesome');
 
 const fontawesome = {
   _initialized: false,
-  _manager: null,
+  _omega: null,
   _roots: [],
   _aliasMap: null,
   _cache: new Map(),
 
-  initialize(manager) {
+  initialize(omega) {
     if (fontawesome._initialized) {
       return;
     }
 
-    fontawesome._manager = manager;
+    fontawesome._omega = omega;
     fontawesome._roots = fontawesome._resolveRoots();
 
     fontawesome._registerIpc();

package/dist/lib/ipc.js

@@ -15,7 +15,7 @@
 //   window.desktop.ipc.send(channel, payload)                  // fire-and-forget renderer → main
 //
 // All framework-internal channels are prefixed `desktop:` (e.g. `desktop:storage:get`);
-// the test harness keeps its own `desktop:__test:*` channels (parked internals, like EM_* env vars).
+// the test harness keeps its own `desktop:__test:*` channels (parked internals, like the OMEGA_TEST_* env vars).
 // Consumers can register their own channels under any namespace they want.
 
 const LoggerLite = require('./logger-lite.js');
@@ -24,18 +24,18 @@ const logger = new LoggerLite('ipc');
 
 const ipc = {
   _initialized: false,
-  _manager:     null,
+  _omega:       null,
   _handlers:    {}, // channel -> handler fn
   _listeners:   {}, // channel -> Set<fn>
   _ipcMain:     null,
   _electron:    null,
 
-  initialize(manager) {
+  initialize(omega) {
     if (ipc._initialized) {
       return;
     }
 
-    ipc._manager = manager;
+    ipc._omega = omega;
     ipc._electron = require('electron');
     ipc._ipcMain = ipc._electron.ipcMain;
     // No ipcMain in renderer/preload — those contexts use ipcRenderer instead.

package/dist/lib/menu.js

@@ -3,13 +3,13 @@
 // @omega.js/desktop looks for the consumer's `src/integrations/menu/index.js` and calls it with a builder API:
 //
 //   // src/integrations/menu/index.js
-//   module.exports = ({ manager, menu, defaults }) => {
+//   module.exports = ({ omega, menu, defaults }) => {
 //     // Use the platform-aware default template as a starting point...
 //     menu.useDefaults();
 //
 //     // ...or build from scratch:
 //     menu.menu('File', [
-//       { id: 'file/new', label: 'New Window', accelerator: 'CmdOrCtrl+N', click: () => manager.windows.show('main') },
+//       { id: 'file/new', label: 'New Window', accelerator: 'CmdOrCtrl+N', click: () => omega.windows.show('main') },
 //       { type: 'separator' },
 //       { role: 'quit' },
 //     ]);
@@ -28,7 +28,7 @@
 //   menu.clear()              // start over
 //   menu.append(item)         // append a top-level descriptor (rare; prefer menu())
 //
-// Id-path API (during definition AND at runtime via `manager.menu.*`):
+// Id-path API (during definition AND at runtime via `omega.menu.*`):
 //   .find(idPath) / .has(idPath)
 //   .update(idPath, patch)        — Object.assign + re-render
 //   .remove(idPath)               — splice + re-render
@@ -59,7 +59,7 @@
 //     development/open-user-data, development/open-logs, development/open-app-config,
 //     development/test-error
 //
-// Disabling at runtime: call `manager.menu.disable()` from anywhere in main —
+// Disabling at runtime: call `omega.menu.disable()` from anywhere in main,
 // idempotent, calls Menu.setApplicationMenu(null) (or null on Windows/Linux to hide
 // the menu bar). No config flag.
 
@@ -73,21 +73,21 @@ const logger = new LoggerLite('menu');
 
 const menu = {
   _initialized: false,
-  _manager:     null,
+  _omega:       null,
   _menu:        null,    // electron Menu instance (after _render)
   _items:       [],      // top-level descriptors
   _electron:    null,
   _definitionFn: null,
 
-  initialize(manager) {
+  initialize(omega) {
     if (menu._initialized) {
       return;
     }
 
-    menu._manager = manager;
+    menu._omega = omega;
 
     if (menu._disabled) {
-      logger.log('initialize — disabled via manager.menu.disable() called pre-init');
+      logger.log('initialize — disabled via omega.menu.disable() called pre-init');
       menu._initialized = true;
       return;
     }
@@ -102,7 +102,7 @@ const menu = {
 
     if (fs.existsSync(absPath)) {
       const loadConsumerFile = require('../utils/load-consumer-file.js');
-      const loaded = loadConsumerFile(absPath, logger);
+      const loaded = loadConsumerFile(absPath);
       if (typeof loaded === 'function') {
         menu._definitionFn = loaded;
       } else if (loaded != null) {
@@ -117,7 +117,7 @@ const menu = {
 
     if (menu._definitionFn) {
       try {
-        menu._definitionFn({ manager, menu: builder, defaults: menu._defaultTemplate() });
+        menu._definitionFn({ omega, menu: builder, defaults: menu._defaultTemplate() });
       } catch (e) {
         logger.error('menu definition fn threw:', e);
       }
@@ -131,8 +131,8 @@ const menu = {
     // Reflect current auto-updater state into the menu item now that the menu exists.
     // (The auto-updater initializes before menu in the boot sequence, so its initial state
     // wasn't reflected in the menu yet.)
-    if (manager.autoUpdater._updateMenuItem) {
-      manager.autoUpdater._updateMenuItem();
+    if (omega.autoUpdater._updateMenuItem) {
+      omega.autoUpdater._updateMenuItem();
     }
 
     logger.log(`initialize — top-level menus=${menu._items.length}`);
@@ -168,12 +168,12 @@ const menu = {
   // is informed by the legacy @omega.js/desktop template (preferences, relaunch,
   // dev tools nested under view/developer, top-level development menu).
   _defaultTemplate() {
-    const m = menu._manager;
+    const omega = menu._omega;
     const isMac        = process.platform === 'darwin';
-    const productName  = m.config.app?.productName || m.config.brand.name;
-    const brandUrl     = m.config.brand.url || null;
-    const brandName    = m.config.brand.name;
-    const isDev        = m.isDevelopment();
+    const productName  = omega.config.app?.productName || omega.config.brand.name;
+    const brandUrl     = omega.config.brand.url || null;
+    const brandName    = omega.config.brand.name;
+    const isDev        = omega.isDevelopment();
 
     // @omega.js/desktop's built-in "Check for Updates..." item. Click defaults to invoking auto-updater
     // check; auto-updater hook updates label/enabled dynamically based on status.
@@ -183,9 +183,9 @@ const menu = {
       id: idPath,
       label: 'Check for Updates...',
       click: () => {
-        const status = m.autoUpdater.getStatus();
-        if (status.code === 'downloaded') m.autoUpdater.installNow();
-        else m.autoUpdater.checkNow({ userInitiated: true });
+        const status = omega.autoUpdater.getStatus();
+        if (status.code === 'downloaded') omega.autoUpdater.installNow();
+        else omega.autoUpdater.checkNow({ userInitiated: true });
       },
     });
 
@@ -197,7 +197,7 @@ const menu = {
       id: `view/developer/simulate-update/${scenario}`,
       label,
       click: () => {
-        m.autoUpdater.simulate(scenario)
+        omega.autoUpdater.simulate(scenario)
           .then((status) => logger.log(`simulate(${scenario}) → ${status.code}`))
           .catch((e) => logger.warn(`simulate(${scenario}) failed: ${e.message}`));
       },
@@ -211,7 +211,7 @@ const menu = {
       accelerator: 'CommandOrControl+,',
       visible: false,
       click: () => {
-        m.windows.show('settings');
+        omega.windows.show('settings');
       },
     };
 
@@ -351,7 +351,7 @@ const menu = {
           const { shell } = require('electron');
           // Route through getWebsiteUrl() so dev runs open localhost:4000 instead
           // of punching out to the live brand site.
-          const safe = sanitizeURL(m.getWebsiteUrl());
+          const safe = sanitizeURL(omega.getWebsiteUrl());
           if (safe) shell.openExternal(safe);
         },
       });
@@ -477,7 +477,7 @@ const menu = {
       throw new Error('menu.define: fn must be a function');
     }
     menu._items = [];
-    fn({ manager: menu._manager, menu: menu._buildBuilder(), defaults: menu._defaultTemplate() });
+    fn({ omega: menu._omega, menu: menu._buildBuilder(), defaults: menu._defaultTemplate() });
     menu._render();
   },
 
@@ -511,7 +511,7 @@ const menu = {
   isDisabled() { return Boolean(menu._disabled); },
 };
 
-// Mix the id-path API directly onto the singleton so `manager.menu.update(...)` works at runtime.
+// Mix the id-path API directly onto the singleton so `omega.menu.update(...)` works at runtime.
 Object.assign(menu, buildIdApi({
   getItems: () => menu._items,
   render:   () => menu._render(),

package/dist/lib/protocol.js

@@ -14,17 +14,17 @@ const logger = new LoggerLite('protocol');
 
 const protocol = {
   _initialized: false,
-  _manager:     null,
+  _omega:       null,
   _electron:    null,
   _hasLock:     true,
   _schemes:     [],
 
-  initialize(manager) {
+  initialize(omega) {
     if (protocol._initialized) {
       return;
     }
 
-    protocol._manager = manager;
+    protocol._omega = omega;
     protocol._electron = require('electron');
 
     // `app` is only defined in the main process. In renderer/preload (and in
@@ -57,9 +57,9 @@ const protocol = {
     // Register custom URL scheme. Always derived from brand.id — `<brand.id>://...` is
     // the one and only scheme. No config knob; if you need multiple schemes for the same app,
     // call `app.setAsDefaultProtocolClient(extra)` yourself in main.js.
-    const schemes = [manager.config.brand.id];
+    const schemes = [omega.config.brand.id];
     protocol._schemes = schemes;
-    if (manager.isProduction()) {
+    if (omega.isProduction()) {
       schemes.forEach((scheme) => {
         if (process.platform === 'win32' || process.platform === 'linux') {
           app.setAsDefaultProtocolClient(scheme, process.execPath, [process.cwd()]);

package/dist/lib/remote-config.js

@@ -32,14 +32,14 @@ const DEFAULTS = Object.freeze({
 //     const required = cfg?.versionRequired || '0.0.0';
 //     if (semver.lt(app.getVersion(), required)) showForceUpdateDialog();
 //   };
-//   checkVersion(manager.remoteConfig.get());                  // run at boot with defaults/cache
-//   manager.remoteConfig.on('update', checkVersion);           // re-run on every fresh fetch
+//   checkVersion(omega.remoteConfig.get());                  // run at boot with defaults/cache
+//   omega.remoteConfig.on('update', checkVersion);           // re-run on every fresh fetch
 //
 // API:
-//   manager.remoteConfig.get()                   → entire data (defaults | cache | latest fetch)
-//   manager.remoteConfig.get('versionRequired')  → dot-path lookup
-//   manager.remoteConfig.on('update', fn)        → subscribe; returns unsub fn
-//   manager.remoteConfig.refreshNow()            → force a fetch right now (Promise<data | null>)
+//   omega.remoteConfig.get()                   → entire data (defaults | cache | latest fetch)
+//   omega.remoteConfig.get('versionRequired')  → dot-path lookup
+//   omega.remoteConfig.on('update', fn)        → subscribe; returns unsub fn
+//   omega.remoteConfig.refreshNow()            → force a fetch right now (Promise<data | null>)
 
 const LoggerLite       = require('./logger-lite.js');
 const fetch            = require('wonderful-fetch');
@@ -53,17 +53,17 @@ const FETCH_TIMEOUT_MS = 60 * 1000;       // 60s — generous; this is a once-an
 
 const remoteConfig = {
   _initialized: false,
-  _manager:     null,
+  _omega:       null,
   _data:        null,
   _intervalId:  null,
   _listeners:   new Set(),
   _url:         null,
   _enabled:     true,
 
-  initialize(manager) {
+  initialize(omega) {
     if (remoteConfig._initialized) return;
     remoteConfig._initialized = true;
-    remoteConfig._manager = manager;
+    remoteConfig._omega = omega;
 
     // Always seed with safe defaults FIRST so any caller reading `get()` between
     // `initialize()` and the first successful fetch sees usable values (status:
@@ -74,16 +74,16 @@ const remoteConfig = {
     // (disabled / no URL / transport gate) — the preload exposes these invokes
     // unconditionally, so an unregistered handler would reject every renderer
     // call instead of serving the defaults the early-return paths promise.
-    manager.ipc.unhandle('desktop:remote-config:get');
-    manager.ipc.handle('desktop:remote-config:get',         (path) => remoteConfig.get(path));
-    manager.ipc.unhandle('desktop:remote-config:refresh-now');
-    manager.ipc.handle('desktop:remote-config:refresh-now', () => remoteConfig.refreshNow());
+    omega.ipc.unhandle('desktop:remote-config:get');
+    omega.ipc.handle('desktop:remote-config:get',         (path) => remoteConfig.get(path));
+    omega.ipc.unhandle('desktop:remote-config:refresh-now');
+    omega.ipc.handle('desktop:remote-config:refresh-now', () => remoteConfig.refreshNow());
     // Broadcast updates to renderers.
     remoteConfig.on('update', (data) => {
-      manager.ipc.broadcast('desktop:remote-config:update', data);
+      omega.ipc.broadcast('desktop:remote-config:update', data);
     });
 
-    const cfg = manager.config.remoteConfig || {};
+    const cfg = omega.config.remoteConfig || {};
     remoteConfig._enabled = cfg.enabled !== false;       // default on
 
     if (!remoteConfig._enabled) {
@@ -95,8 +95,8 @@ const remoteConfig = {
     // brand.url + the legacy convention path.
     if (cfg.url) {
       remoteConfig._url = cfg.url;
-    } else if (manager.config.brand.url) {
-      const base = String(manager.config.brand.url).replace(/\/$/, '');
+    } else if (omega.config.brand.url) {
+      const base = String(omega.config.brand.url).replace(/\/$/, '');
       remoteConfig._url = `${base}/data/resources/main.json`;
     }
 
@@ -115,7 +115,7 @@ const remoteConfig = {
 
     // Restore cached data on top of defaults (last-known-good wins over defaults
     // until the next successful fetch lands).
-    const cached = manager.storage.get(STORAGE_KEY);
+    const cached = omega.storage.get(STORAGE_KEY);
     if (cached && typeof cached === 'object') {
       remoteConfig._data = { ...DEFAULTS, ...cached };
     }
@@ -127,9 +127,9 @@ const remoteConfig = {
     // Cadence: match auto-updater's feed-check (same "occasionally network-hits-the-internet"
     // job category). Auto-updater is wired BEFORE remote-config in boot sequence
     // so `_options` is always populated; testing collapses to 500ms via isTesting().
-    const interval = manager.isTesting()
+    const interval = omega.isTesting()
       ? 500
-      : manager.autoUpdater._options.feedCheckIntervalMs;
+      : omega.autoUpdater._options.feedCheckIntervalMs;
     remoteConfig._intervalId = setInterval(() => {
       remoteConfig.refreshNow().catch((e) => logger.warn(`periodic fetch failed: ${formatFetchError(e)}`));
     }, interval);
@@ -190,7 +190,7 @@ const remoteConfig = {
     // Layer fresh fetch on top of defaults so consumers can omit fields from
     // their hosted JSON and @omega.js/desktop still has sensible values.
     remoteConfig._data = { ...DEFAULTS, ...data };
-    remoteConfig._manager.storage.set(STORAGE_KEY, data);
+    remoteConfig._omega.storage.set(STORAGE_KEY, data);
     remoteConfig._emit('update', remoteConfig._data);
     logger.log(`remote-config refreshed (${remoteConfig._url})`);
     return remoteConfig._data;
@@ -210,7 +210,7 @@ const remoteConfig = {
     if (remoteConfig._intervalId) clearInterval(remoteConfig._intervalId);
     remoteConfig._intervalId = null;
     remoteConfig._initialized = false;
-    remoteConfig._manager     = null;
+    remoteConfig._omega       = null;
     remoteConfig._data        = null;
     remoteConfig._listeners.clear();
     remoteConfig._url         = null;

package/dist/lib/remote-scripts.js

@@ -10,14 +10,14 @@
 // Fetch timeout:  60s
 //
 // The file is plain JavaScript fetched as text. It runs as an async function
-// body with `manager` and `require` in scope — full main-process access.
+// body with `omega` and `require` in scope: full main-process access.
 // Dedup is automatic: the script's content hash is stored in electron-store and
 // the same script won't re-execute until the content changes.
 //
 // API:
-//   manager.remoteScripts.refreshNow()    → force-fetch + execute if changed
-//   manager.remoteScripts.getLastRun()    → { hash, timestamp } or null
-//   manager.remoteScripts.clearExecuted() → wipe stored hash (forces re-run next poll)
+//   omega.remoteScripts.refreshNow()    → force-fetch + execute if changed
+//   omega.remoteScripts.getLastRun()    → { hash, timestamp } or null
+//   omega.remoteScripts.clearExecuted() → wipe stored hash (forces re-run next poll)
 
 const LoggerLite           = require('./logger-lite.js');
 const fetch                = require('wonderful-fetch');
@@ -31,17 +31,17 @@ const FETCH_TIMEOUT_MS = 60 * 1000;
 
 const remoteScripts = {
   _initialized: false,
-  _manager:     null,
+  _omega:       null,
   _url:         null,
   _enabled:     false,
   _intervalId:  null,
 
-  initialize(manager) {
+  initialize(omega) {
     if (remoteScripts._initialized) return;
     remoteScripts._initialized = true;
-    remoteScripts._manager = manager;
+    remoteScripts._omega = omega;
 
-    const cfg = manager.config.remoteScripts || {};
+    const cfg = omega.config.remoteScripts || {};
     remoteScripts._enabled = cfg.enabled === true;
 
     if (!remoteScripts._enabled) {
@@ -51,8 +51,8 @@ const remoteScripts = {
 
     if (cfg.url) {
       remoteScripts._url = cfg.url;
-    } else if (manager.config.brand.url) {
-      const base = String(manager.config.brand.url).replace(/\/$/, '');
+    } else if (omega.config.brand.url) {
+      const base = String(omega.config.brand.url).replace(/\/$/, '');
       remoteScripts._url = `${base}/data/scripts/main.js`;
     }
 
@@ -72,9 +72,9 @@ const remoteScripts = {
     remoteScripts.refreshNow()
       .catch((e) => logger.warn(`initial fetch failed: ${formatFetchError(e)}`));
 
-    const interval = manager.isTesting()
+    const interval = omega.isTesting()
       ? 500
-      : manager.autoUpdater._options.feedCheckIntervalMs;
+      : omega.autoUpdater._options.feedCheckIntervalMs;
     remoteScripts._intervalId = setInterval(() => {
       remoteScripts.refreshNow()
         .catch((e) => logger.warn(`periodic fetch failed: ${formatFetchError(e)}`));
@@ -114,31 +114,31 @@ const remoteScripts = {
       logger.error(`remote-scripts: script threw: ${e.message}`);
     }
 
-    remoteScripts._manager.storage.set(STORAGE_KEY, { hash, timestamp: Date.now() });
+    remoteScripts._omega.storage.set(STORAGE_KEY, { hash, timestamp: Date.now() });
     return { hash };
   },
 
   getLastRun() {
-    if (!remoteScripts._manager) return null;
-    return remoteScripts._manager.storage.get(STORAGE_KEY) || null;
+    if (!remoteScripts._omega) return null;
+    return remoteScripts._omega.storage.get(STORAGE_KEY) || null;
   },
 
   clearExecuted() {
-    if (!remoteScripts._manager) return;
-    remoteScripts._manager.storage.set(STORAGE_KEY, null);
+    if (!remoteScripts._omega) return;
+    remoteScripts._omega.storage.set(STORAGE_KEY, null);
   },
 
   // ─── Internals ──────────────────────────────────────────────────────────────
 
   async _execute(code) {
-    const manager = remoteScripts._manager;
+    const omega = remoteScripts._omega;
 
     // The real `require`, handed to the script: it is compiled by
     // `new AsyncFunction`, so it has no module scope of its own and no bundler
     // ever sees its body.
     const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
-    const fn = new AsyncFunction('manager', 'require', code);
-    await fn(manager, require);
+    const fn = new AsyncFunction('omega', 'require', code);
+    await fn(omega, require);
   },
 
   _hash(str) {
@@ -149,7 +149,7 @@ const remoteScripts = {
     if (remoteScripts._intervalId) clearInterval(remoteScripts._intervalId);
     remoteScripts._intervalId  = null;
     remoteScripts._initialized = false;
-    remoteScripts._manager     = null;
+    remoteScripts._omega       = null;
     remoteScripts._url         = null;
     remoteScripts._enabled     = false;
   },