@omega.js/desktop 0.51.0 → 0.53.0

package/dist/lib/auto-updater.js

@@ -49,16 +49,16 @@ const STORAGE_KEY = 'autoUpdater';
 //      install fires whenever the user eventually walks away. We never re-prompt
 //      for the same version (tracked via `_promptedForVersion`).
 //
-// Consumer hook: `manager.autoUpdater.markActive()` lets app code force-bump the
+// Consumer hook: `omega.autoUpdater.markActive()` lets app code force-bump the
 // activity timestamp from anywhere (e.g. just received an auth event, finished a
 // long-running renderer task, etc.). Use sparingly — the built-in signals cover
 // 99% of real activity.
 //
-// Test mode: when `manager.isTesting()` is true, the threshold collapses to 3s so
+// Test mode: when `omega.isTesting()` is true, the threshold collapses to 3s so
 // integration tests can drive a real download → idle wait → install in ~5s instead
 // of 15min. Both timers (feed-check + idle-eval) likewise drop to 500ms in tests so
 // the full sequence fires inside a test run. Wired in `_idleThresholdMs()` and the
-// initialize() timer setup based on the manager's `isTesting()` helper.
+// initialize() timer setup based on the omega instance's `isTesting()` helper.
 const IDLE_INSTALL_THRESHOLD_MS         = 15 * 60 * 1000;   // 15 min — production
 const IDLE_INSTALL_THRESHOLD_MS_TESTING =      3 * 1000;    // 3 sec  — when isTesting()
 const IDLE_TICK_MS_TESTING              =          500;     // 500ms periodic tick when testing
@@ -109,7 +109,7 @@ function freshState() {
 
 const autoUpdater = {
   _initialized: false,
-  _manager:     null,
+  _omega:       null,
   _library:     null,
   _options:     null,
   _state:       freshState(),
@@ -125,12 +125,12 @@ const autoUpdater = {
   _promptedForVersion: null,           // version string we've already prompted about — never prompt twice for the same version
   _activityHooksWired: false,          // guard: only wire main-side activity listeners once per process
 
-  async initialize(manager) {
-    autoUpdater._manager = manager;
+  async initialize(omega) {
+    autoUpdater._omega = omega;
     autoUpdater._initialized = true;
     autoUpdater._state = freshState();
 
-    const cfg = (manager && manager.config && manager.config.autoUpdate) || {};
+    const cfg = (omega && omega.config && omega.config.autoUpdate) || {};
     autoUpdater._options = { ...DEFAULTS, ...cfg };
 
     if (autoUpdater._options.enabled === false) {
@@ -150,21 +150,21 @@ const autoUpdater = {
     }
 
     // 3. IPC: renderer status query + actions. Unhandle first so re-init is idempotent.
-    if (manager && manager.ipc) {
+    if (omega && omega.ipc) {
       const channels = [
         ['desktop:auto-updater:status',     async () => autoUpdater.getStatus()],
         ['desktop:auto-updater:check-now',  async () => autoUpdater.checkNow({ userInitiated: true })],
         ['desktop:auto-updater:install-now', async () => autoUpdater.installNow()],
       ];
       for (const [chan, fn] of channels) {
-        manager.ipc.unhandle(chan);
-        manager.ipc.handle(chan, fn);
+        omega.ipc.unhandle(chan);
+        omega.ipc.handle(chan, fn);
       }
       // Activity ping from preload (debounced renderer-side mouse/keyboard/focus).
       // Listener (not handle) — fire-and-forget, no response needed. Set-backed
       // listener registry deduplicates same-fn re-adds, so re-init is safe.
-      if (typeof manager.ipc.on === 'function') {
-        manager.ipc.on('desktop:auto-updater:activity', autoUpdater._onActivityIpc);
+      if (typeof omega.ipc.on === 'function') {
+        omega.ipc.on('desktop:auto-updater:activity', autoUpdater._onActivityIpc);
       }
     }
 
@@ -188,10 +188,10 @@ const autoUpdater = {
     //       a downloaded update based on user idle time. Default 1m cadence so a
     //       downloaded update installs promptly when the user steps away.
     //
-    // In tests (`manager.isTesting() === true`) both cadences collapse to
+    // In tests (`omega.isTesting() === true`) both cadences collapse to
     // IDLE_TICK_MS_TESTING (500ms) so an integration test sees the full sequence
     // fire within seconds of a download.
-    const isTesting = manager.isTesting();
+    const isTesting = omega.isTesting();
     const feedInterval = isTesting ? IDLE_TICK_MS_TESTING : autoUpdater._options.feedCheckIntervalMs;
     const idleInterval = isTesting ? IDLE_TICK_MS_TESTING : autoUpdater._options.idleEvalIntervalMs;
 
@@ -281,7 +281,7 @@ const autoUpdater = {
     // Same doctrine as _isSimulating(): a packaged production build may simulate, but
     // only when it was LAUNCHED for QA with OMEGA_DEV_UPDATE set. Without that opt-in a
     // shipped binary must never be talked into faking an update it cannot deliver.
-    if (autoUpdater._manager.isProduction() && !autoUpdater._isSimulating()) {
+    if (autoUpdater._omega.isProduction() && !autoUpdater._isSimulating()) {
       throw new Error('simulate(): refused in a production build. Relaunch with OMEGA_DEV_UPDATE set to simulate updates.');
     }
 
@@ -320,7 +320,7 @@ const autoUpdater = {
 
   // Bump the activity timestamp. Called automatically by the built-in activity hooks
   // (renderer mouse/keyboard, browser-window focus). Consumer code can also call this
-  // directly from anywhere (`manager.autoUpdater.markActive()`) to force-bump on
+  // directly from anywhere (`omega.autoUpdater.markActive()`) to force-bump on
   // app-specific activity.
   markActive() {
     autoUpdater._lastActivityAt = Date.now();
@@ -341,13 +341,13 @@ const autoUpdater = {
       logger.log('Dev mode — skipping real quitAndInstall().');
       return true;
     }
-    // Flip the manager's quit flag so the window-manager close handler lets the
+    // Flip the omega instance's quit flag so the window-manager close handler lets the
     // close events through instead of trapping them with hide-on-close. Without
     // this, quitAndInstall() fires before-quit but the BrowserWindow's close
     // handler (which runs FIRST since it has its own listener) would call
     // event.preventDefault() and the install would just hide the window.
-    if (autoUpdater._manager) {
-      autoUpdater._manager._allowQuit = true;
+    if (autoUpdater._omega) {
+      autoUpdater._omega._allowQuit = true;
     }
     if (autoUpdater._library && typeof autoUpdater._library.quitAndInstall === 'function') {
       autoUpdater._library.quitAndInstall();
@@ -372,10 +372,10 @@ const autoUpdater = {
     autoUpdater._promptedForVersion = null;
     autoUpdater._activityHooksWired = false;
 
-    const m = autoUpdater._manager;
-    if (m && m.ipc && typeof m.ipc.unhandle === 'function') {
+    const omega = autoUpdater._omega;
+    if (omega && omega.ipc && typeof omega.ipc.unhandle === 'function') {
       ['desktop:auto-updater:status', 'desktop:auto-updater:check-now', 'desktop:auto-updater:install-now'].forEach((c) => {
-        m.ipc.unhandle(c);
+        omega.ipc.unhandle(c);
       });
     }
   },
@@ -385,7 +385,7 @@ const autoUpdater = {
   // Auto-updater dev SIMULATION mode — controls whether checkForUpdates() is wired
   // to electron-updater (real) or our synthetic event sequence (fake). Triggered by
   // setting OMEGA_DEV_UPDATE=available|unavailable|error. NOT the same as
-  // `manager.isDevelopment()` (which is the runtime "are we packaged" signal); a
+  // `omega.isDevelopment()` (which is the runtime "are we packaged" signal); a
   // packaged production build can absolutely run with OMEGA_DEV_UPDATE set for QA.
   //
   // The runtime simulate() latches `_devSimulationSession` for the rest of the process
@@ -401,7 +401,7 @@ const autoUpdater = {
   },
 
   _idleThresholdMs() {
-    return autoUpdater._manager.isTesting() ? IDLE_INSTALL_THRESHOLD_MS_TESTING : IDLE_INSTALL_THRESHOLD_MS;
+    return autoUpdater._omega.isTesting() ? IDLE_INSTALL_THRESHOLD_MS_TESTING : IDLE_INSTALL_THRESHOLD_MS;
   },
 
   _readyToCheck() {
@@ -461,7 +461,7 @@ const autoUpdater = {
     // user can't dismiss programmatically — exactly what we don't want firing
     // during automated runs. Tests that want to assert prompt behavior should
     // override `_promptToInstall` per-test (see auto-updater.test.js).
-    if (autoUpdater._manager.isTesting()) {
+    if (autoUpdater._omega.isTesting()) {
       logger.log(`Test mode: _promptToInstall(${version}) — skipped native dialog.`);
       return;
     }
@@ -470,8 +470,8 @@ const autoUpdater = {
     if (!dialog) return;        // renderer/preload context — no dialog API
 
     const focusedWindow = BrowserWindow.getFocusedWindow();
-    const productName = autoUpdater._manager.config.app?.productName
-      || autoUpdater._manager.config.brand.name;
+    const productName = autoUpdater._omega.config.app?.productName
+      || autoUpdater._omega.config.brand.name;
 
     // showMessageBox CAN reject (e.g. dialog destroyed, no display) — wrap just
     // the call. Synchronous setup above doesn't need a try.
@@ -521,9 +521,9 @@ const autoUpdater = {
   },
 
   _broadcastStatus() {
-    const m = autoUpdater._manager;
-    if (m && m.ipc && typeof m.ipc.broadcast === 'function') {
-      m.ipc.broadcast('desktop:auto-updater:status', autoUpdater.getStatus());
+    const omega = autoUpdater._omega;
+    if (omega && omega.ipc && typeof omega.ipc.broadcast === 'function') {
+      omega.ipc.broadcast('desktop:auto-updater:status', autoUpdater.getStatus());
     }
     autoUpdater._updateMenuItem();
     autoUpdater._updateTrayItem();
@@ -551,36 +551,36 @@ const autoUpdater = {
   // Reflect updater state into the @omega.js/desktop Check-for-Updates item. The item lives under
   // `main/check-for-updates` on macOS (App menu) and `help/check-for-updates` on win/linux —
   // we just patch whichever one exists. Consumer can remove either via
-  // manager.menu.remove('main/check-for-updates') in their integrations/menu/index.js.
+  // omega.menu.remove('main/check-for-updates') in their integrations/menu/index.js.
   _updateMenuItem() {
-    const m = autoUpdater._manager;
+    const omega = autoUpdater._omega;
     const { label, enabled } = autoUpdater._menuItemFieldsForState();
 
     // Patch whichever id-path exists. .update() returns false (and warns) if missing,
     // so try both without doubling up on warnings — silence by checking has() first.
-    if (m.menu.has('main/check-for-updates')) {
-      m.menu.update('main/check-for-updates', { label, enabled });
-    } else if (m.menu.has('help/check-for-updates')) {
-      m.menu.update('help/check-for-updates', { label, enabled });
+    if (omega.menu.has('main/check-for-updates')) {
+      omega.menu.update('main/check-for-updates', { label, enabled });
+    } else if (omega.menu.has('help/check-for-updates')) {
+      omega.menu.update('help/check-for-updates', { label, enabled });
     }
   },
 
   // Reflect updater state into the tray's `check-for-updates` item, if present. Same
   // label/enabled semantics as the menu item — keeps both UIs in lockstep.
   _updateTrayItem() {
-    const m = autoUpdater._manager;
+    const omega = autoUpdater._omega;
     const { label, enabled } = autoUpdater._menuItemFieldsForState();
 
-    if (m.tray.has('check-for-updates')) {
-      m.tray.update('check-for-updates', { label, enabled });
+    if (omega.tray.has('check-for-updates')) {
+      omega.tray.update('check-for-updates', { label, enabled });
     }
   },
 
   // 30-day gate ────────────────────────────────────────────────────────────────────
 
   _reconcilePendingUpdate() {
-    const m = autoUpdater._manager;
-    const pending = m.storage.get(`${STORAGE_KEY}.pendingUpdate`);
+    const omega = autoUpdater._omega;
+    const pending = omega.storage.get(`${STORAGE_KEY}.pendingUpdate`);
     if (!pending || !pending.downloadedAt) return;
 
     // A simulated record (written by a build from before the simulator stopped
@@ -590,14 +590,14 @@ const autoUpdater = {
     // force-installs the first REAL download the moment it lands.
     if (pending.version === SIMULATED_VERSION) {
       logger.log(`Discarding simulated pendingUpdate record (v${pending.version}) — the dev simulator never downloaded anything.`);
-      m.storage.set(`${STORAGE_KEY}.pendingUpdate`, null);
+      omega.storage.set(`${STORAGE_KEY}.pendingUpdate`, null);
       return;
     }
 
-    const currentVersion = autoUpdater._manager.getVersion();
+    const currentVersion = autoUpdater._omega.getVersion();
     if (pending.version === currentVersion) {
       logger.log(`Pending update v${pending.version} appears to be applied — clearing flag.`);
-      m.storage.set(`${STORAGE_KEY}.pendingUpdate`, null);
+      omega.storage.set(`${STORAGE_KEY}.pendingUpdate`, null);
       return;
     }
 
@@ -622,10 +622,10 @@ const autoUpdater = {
       return;
     }
 
-    const m = autoUpdater._manager;
-    if (!m || !m.storage) return;
+    const omega = autoUpdater._omega;
+    if (!omega || !omega.storage) return;
 
-    const existing = m.storage.get(`${STORAGE_KEY}.pendingUpdate`);
+    const existing = omega.storage.get(`${STORAGE_KEY}.pendingUpdate`);
     // FIRST download wins for the TIMER — but the stored version must track the
     // NEWEST download, or the clear-on-apply check (version === getVersion())
     // never matches after the install and the stale flag force-installs every
@@ -633,13 +633,13 @@ const autoUpdater = {
     if (existing && existing.downloadedAt) {
       logger.log(`pendingUpdate already recorded (v${existing.version} @ ${new Date(existing.downloadedAt).toISOString()}) — keeping existing timestamp.`);
       if (existing.version !== version) {
-        m.storage.set(`${STORAGE_KEY}.pendingUpdate`, { version, downloadedAt: existing.downloadedAt });
+        omega.storage.set(`${STORAGE_KEY}.pendingUpdate`, { version, downloadedAt: existing.downloadedAt });
       }
       autoUpdater._state.downloadedAt = existing.downloadedAt;
       return;
     }
     const now = Date.now();
-    m.storage.set(`${STORAGE_KEY}.pendingUpdate`, { version, downloadedAt: now });
+    omega.storage.set(`${STORAGE_KEY}.pendingUpdate`, { version, downloadedAt: now });
     autoUpdater._state.downloadedAt = now;
     logger.log(`Recorded pendingUpdate v${version} @ ${new Date(now).toISOString()}`);
   },

package/dist/lib/context-menu.js

@@ -4,7 +4,7 @@
 // context-menu event with a builder API plus the event's `params`:
 //
 //   // src/integrations/context-menu/index.js
-//   module.exports = ({ manager, menu, params, webContents }) => {
+//   module.exports = ({ omega, menu, params, webContents }) => {
 //     // Start from @omega.js/desktop's default template (undo/redo, cut/copy/paste, link items,
 //     // reload, dev-only inspect):
 //     menu.useDefaults();
@@ -44,10 +44,10 @@
 // Building no items (calling no menu.* methods) suppresses the popup entirely.
 //
 // @omega.js/desktop auto-attaches the handler to every BrowserWindow's webContents that
-// goes through `manager.windows.createNamed()`. To attach manually:
-//   manager.contextMenu.attach(webContents)
+// goes through `omega.windows.createNamed()`. To attach manually:
+//   omega.contextMenu.attach(webContents)
 //
-// Disabling at runtime: call `manager.contextMenu.disable()`. Idempotent. After
+// Disabling at runtime: call `omega.contextMenu.disable()`. Idempotent. After
 // disable() the lib stops responding to context-menu events on already-attached
 // webContents — no new menus are shown. No config flag.
 
@@ -61,20 +61,20 @@ const logger = new LoggerLite('context-menu');
 
 const contextMenu = {
   _initialized:  false,
-  _manager:      null,
+  _omega:        null,
   _electron:     null,
   _definitionFn: null,
   _attached:     new WeakSet(), // webContents that already have the listener
 
-  initialize(manager) {
+  initialize(omega) {
     if (contextMenu._initialized) {
       return;
     }
 
-    contextMenu._manager = manager;
+    contextMenu._omega = omega;
 
     if (contextMenu._disabled) {
-      logger.log('initialize — disabled via manager.contextMenu.disable() called pre-init');
+      logger.log('initialize — disabled via omega.contextMenu.disable() called pre-init');
       contextMenu._initialized = true;
       return;
     }
@@ -89,7 +89,7 @@ const contextMenu = {
 
     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') {
         contextMenu._definitionFn = loaded;
       } else if (loaded != null) {
@@ -156,7 +156,7 @@ const contextMenu = {
 
     const fn = contextMenu._definitionFn || contextMenu._defaultFn;
     try {
-      fn({ manager: contextMenu._manager, menu: builder, params, webContents });
+      fn({ omega: contextMenu._omega, menu: builder, params, webContents });
     } catch (e) {
       logger.error('context-menu definition fn threw:', e);
       return [];
@@ -170,7 +170,7 @@ const contextMenu = {
   // Item set + visibility gates mirror the legacy @omega.js/desktop context-menu behavior:
   // undo/redo gated on canUndo/canRedo, edit ops gated on params.isEditable, etc.
   _populateDefaults(items, params) {
-    const m = contextMenu._manager;
+    const omega = contextMenu._omega;
     const flags = params.editFlags || {};
 
     // Undo / redo — only when applicable. Hidden when canUndo/canRedo is false (matches legacy).
@@ -219,7 +219,7 @@ const contextMenu = {
     if (items.length > 0) items.push({ type: 'separator' });
     items.push({ id: 'reload', role: 'reload' });
 
-    if (m.isDevelopment()) {
+    if (omega.isDevelopment()) {
       items.push({ type: 'separator' });
       items.push({ id: 'inspect',         role: 'inspectElement' });
       items.push({ id: 'toggle-devtools', role: 'toggleDevTools' });
@@ -286,7 +286,7 @@ const contextMenu = {
 
   // Disable the context menu entirely. Idempotent. Safe pre- or post-init.
   // After this, _popup() short-circuits — already-attached webContents stop
-  // showing menus on right-click. No way to re-enable; call manager.contextMenu.define()
+  // showing menus on right-click. No way to re-enable; call omega.contextMenu.define()
   // and clear _disabled if you really need to.
   disable() {
     contextMenu._disabled = true;

package/dist/lib/context.js

@@ -1,14 +1,14 @@
 // Runtime context — what we know about the user's machine + their network +
 // the current session. Modeled after @omega.js/backend's `assistant.request.{geolocation,client}`
-// shape so @omega.js/desktop apps + sister projects (@omega.js/backend, UJM, @omega.js/client) all reference the
+// shape so @omega.js/desktop apps + sister projects (@omega.js/backend, @omega.js/client) all reference the
 // same property paths when reading user info.
 //
-// Populated asynchronously during manager.initialize():
+// Populated asynchronously during omega.initialize():
 //
-//   manager.context.geolocation = { ip, country, region, city }      // ipify-fetched
-//   manager.context.client      = { userAgent, locale, platform, arch, mobile }
-//   manager.context.session     = { id, startTime, deviceId }        // desktop-specific
-//   manager.context.app         = { version, environment, isPackaged }
+//   omega.context.geolocation = { ip, country, region, city }      // ipify-fetched
+//   omega.context.client      = { userAgent, locale, platform, arch, mobile }
+//   omega.context.session     = { id, startTime, deviceId }        // desktop-specific
+//   omega.context.app         = { version, environment, isPackaged }
 //
 // Geolocation is fetched from https://api.ipify.org (IP only) and persisted to
 // storage so a subsequent boot offline still reports the last-known IP. The
@@ -37,7 +37,7 @@ const IP_FETCH_TIMEOUT_MS = 5000;
 
 const context = {
   _initialized: false,
-  _manager:     null,
+  _omega:       null,
 
   // Public shape — populated during initialize(). Exported as plain JSON so renderer
   // tests + IPC consumers can read it via structured-clone.
@@ -46,10 +46,10 @@ const context = {
   session:     { id: null, startTime: null, deviceId: null },
   app:         { version: null, environment: null, isPackaged: null },
 
-  async initialize(manager) {
+  async initialize(omega) {
     if (context._initialized) return;
     context._initialized = true;
-    context._manager = manager;
+    context._omega = omega;
 
     // ─── session ──────────────────────────────────────────────────────────────
     context.session.id        = crypto.randomUUID();
@@ -67,14 +67,14 @@ const context = {
     context.app.isPackaged   = app.isPackaged;
 
     // ─── app ──────────────────────────────────────────────────────────────────
-    context.app.version     = manager.getVersion();
-    context.app.environment = manager.getEnvironment();
+    context.app.version     = omega.getVersion();
+    context.app.environment = omega.getEnvironment();
 
     // ─── geolocation ──────────────────────────────────────────────────────────
     // Restore last-known from storage immediately so we always have SOMETHING to
     // work with (offline boot, ipify down, slow network, etc.). Then fire the
     // network fetch in the background — when it lands it overwrites + persists.
-    const cached = manager.storage.get(STORAGE_KEY) || null;
+    const cached = omega.storage.get(STORAGE_KEY) || null;
     if (cached?.geolocation) {
       Object.assign(context.geolocation, cached.geolocation);
     }
@@ -82,8 +82,8 @@ const context = {
     context._fetchGeolocation().catch((e) => logger.warn(`geolocation fetch failed: ${e.message}`));
 
     // IPC: renderer can read the full context block.
-    manager.ipc.unhandle('desktop:context:get');
-    manager.ipc.handle('desktop:context:get', () => context.toJSON());
+    omega.ipc.unhandle('desktop:context:get');
+    omega.ipc.handle('desktop:context:get', () => context.toJSON());
 
     logger.log(`context initialized — session=${context.session.id} deviceId=${context.session.deviceId} platform=${context.client.platform}`);
   },
@@ -97,11 +97,11 @@ const context = {
   //      id it had before its storage was wiped.
   //   3. A generated UUID (the shared derivation's floor), persisted for next boot.
   async _resolveDeviceId() {
-    const m = context._manager;
+    const omega = context._omega;
 
     return core.deriveDeviceId({
-      get:  () => m.storage.get(`${STORAGE_KEY}.deviceId`),
-      set:  (id) => m.storage.set(`${STORAGE_KEY}.deviceId`, id),
+      get:  () => omega.storage.get(`${STORAGE_KEY}.deviceId`),
+      set:  (id) => omega.storage.set(`${STORAGE_KEY}.deviceId`, id),
       seed: () => context._readFirstMac(),
     });
   },
@@ -138,14 +138,14 @@ const context = {
 
     context.geolocation.ip = ip;
     // Persist for next launch so an offline boot still has a usable IP.
-    context._manager.storage.set(`${STORAGE_KEY}.geolocation`, { ...context.geolocation });
+    context._omega.storage.set(`${STORAGE_KEY}.geolocation`, { ...context.geolocation });
   },
 
   // Test/teardown helper. Re-initialize is idempotent guarded; call this first
   // if a test wants to re-run with mutated state.
   shutdown() {
     context._initialized = false;
-    context._manager     = null;
+    context._omega       = null;
   },
 
   // Plain-JSON snapshot — what gets sent over IPC to the renderer.

package/dist/lib/deep-link.js

@@ -7,16 +7,16 @@
 //            warm-start via `app.on('second-instance')` (read from the `additionalData` argument,
 //            which carries the duplicate's real argv; the event's own `argv` is Chromium-processed).
 //
-// Public API on manager.deepLink:
+// Public API on omega.deepLink:
 //
-//   manager.deepLink.on(routeOrPattern, fn)    // register a handler. Returns unsubscribe fn.
-//   manager.deepLink.off(routeOrPattern, fn)
-//   manager.deepLink.dispatch(url)             // manually fire (for testing or custom triggers)
-//   manager.deepLink.getColdStartUrl()         // the deep-link URL the app was launched with, or null
+//   omega.deepLink.on(routeOrPattern, fn)    // register a handler. Returns unsubscribe fn.
+//   omega.deepLink.off(routeOrPattern, fn)
+//   omega.deepLink.dispatch(url)             // manually fire (for testing or custom triggers)
+//   omega.deepLink.getColdStartUrl()         // the deep-link URL the app was launched with, or null
 //
 // Handler signature:
 //
-//   manager.deepLink.on('user/profile/:id', (ctx) => {
+//   omega.deepLink.on('user/profile/:id', (ctx) => {
 //     ctx.url      // 'myapp://user/profile/42?ref=abc'
 //     ctx.scheme   // 'myapp'
 //     ctx.route    // 'user/profile/42'
@@ -38,8 +38,8 @@
 // the fall-through to wildcard handlers (concrete-pattern handlers always run).
 //
 // Built-in routes (registered by @omega.js/desktop, can be overridden by registering your own handler):
-//   auth/token   → manager.omega.handleAuthToken(query.token)  [Pass 2.12 wires this up]
-//   app/show     → manager.windows.show(query.window || 'main')
+//   auth/token   → omega.auth.handleToken(query.authToken)
+//   app/show     → omega.windows.show(query.window || 'main')
 //   app/quit     → app.quit()
 //
 // Built-in handlers run AFTER consumer handlers, so a consumer can shadow any built-in
@@ -51,21 +51,21 @@ const logger = new LoggerLite('deep-link');
 
 const deepLink = {
   _initialized:    false,
-  _manager:        null,
+  _omega:          null,
   _electron:       null,
   _handlers:       [],          // [{ pattern, fn, builtin: bool }]
   _coldStartUrl:   null,        // the URL the app was launched with (if any)
   _wired:          false,       // open-url + second-instance + queueing wired?
   _pendingUrls:    [],          // urls received before whenReady — drained on init
-  _managerReady:   false,       // manager.initialize() finished — safe to dispatch
-  _bootQueue:      [],          // dispatches held until _managerReady (client-bridge et al. are up)
+  _omegaReady:     false,       // omega.initialize() finished — safe to dispatch
+  _bootQueue:      [],          // dispatches held until _omegaReady (auth et al. are up)
 
-  initialize(manager) {
+  initialize(omega) {
     if (deepLink._initialized) {
       return;
     }
 
-    deepLink._manager = manager;
+    deepLink._omega = omega;
     deepLink._electron = require('electron');
 
     deepLink._wireElectronEvents();
@@ -76,9 +76,9 @@ const deepLink = {
     const coldUrl = deepLink._extractUrlFromArgv(process.argv);
     if (coldUrl) {
       deepLink._coldStartUrl = coldUrl;
-      manager.appState.setLaunchedFromDeepLink(true);
-      // _handle queues until markManagerReady() — a cold-start auth/token must
-      // not dispatch before client-bridge has booted Firebase.
+      omega.appState.setLaunchedFromDeepLink(true);
+      // _handle queues until markOmegaReady() — a cold-start auth/token must
+      // not dispatch before auth has booted Firebase.
       deepLink._handle(coldUrl, 'cold-start', { argv: process.argv, cwd: process.cwd() });
     }
 
@@ -88,7 +88,7 @@ const deepLink = {
       deepLink._pendingUrls = [];
       if (!deepLink._coldStartUrl) {
         deepLink._coldStartUrl = urls[0];
-        manager.appState.setLaunchedFromDeepLink(true);
+        omega.appState.setLaunchedFromDeepLink(true);
       }
       urls.forEach((u) => deepLink._handle(u, 'cold-start', { argv: process.argv, cwd: process.cwd() }));
     }
@@ -130,11 +130,11 @@ const deepLink = {
       // Surface the main window. With hidden-mode apps, the consumer typically created
       // `main` with `show: false` at boot, so it's in the registry but invisible — we
       // just need to show it now that the user explicitly asked.
-      const main = deepLink._manager.windows.get('main');
+      const main = deepLink._omega.windows.get('main');
       if (main) {
         logger.log(`second-instance — surfacing main (visible=${main.isVisible()}, minimized=${main.isMinimized()})`);
         if (main.isMinimized()) main.restore();
-        deepLink._manager.windows._ensureDockVisible();
+        deepLink._omega.windows._ensureDockVisible();
         main.show();
         main.focus();
       } else {
@@ -149,10 +149,10 @@ const deepLink = {
   },
 
   _registerBuiltins() {
-    // auth/token — hand off to client-bridge. The receiving end of
-    // manager.getAuthUrl()'s sign-in round-trip: the website's token page redirects
-    // here with ?authToken=<custom-token>. MODERN shape only — legacy-app formats
-    // (?payload=, ?token=) are UJM's concern, not @omega.js/desktop's.
+    // auth/token: hand off to lib/auth.js. The receiving end of
+    // omega.getAuthUrl()'s sign-in round-trip: the website's token page redirects
+    // here with ?authToken=<custom-token>. MODERN shape only — older formats
+    // (?payload=, ?token=) are not read.
     deepLink._handlers.push({
       pattern: 'auth/token',
       builtin: true,
@@ -162,7 +162,7 @@ const deepLink = {
           logger.warn('auth/token: no authToken in query string.');
           return;
         }
-        deepLink._manager.omega.handleAuthToken(token);
+        deepLink._omega.auth.handleToken(token);
       },
     });
 
@@ -172,7 +172,7 @@ const deepLink = {
       builtin: true,
       fn: (ctx) => {
         const name = ctx.query?.window || 'main';
-        deepLink._manager.windows.show(name);
+        deepLink._omega.windows.show(name);
       },
     });
 
@@ -189,7 +189,7 @@ const deepLink = {
   // Pull a `<scheme>://...` URL out of an argv array. Returns null if none of our schemes match.
   _extractUrlFromArgv(argv) {
     if (!Array.isArray(argv)) return null;
-    const schemes = deepLink._manager.protocol.getSchemes();
+    const schemes = deepLink._omega.protocol.getSchemes();
     if (schemes.length === 0) return null;
 
     // Walk argv backward — the URL is typically the last meaningful arg.
@@ -246,13 +246,13 @@ const deepLink = {
     return params;
   },
 
-  // Called by main.js once manager.initialize() completes — every LIB a handler
-  // touches (client-bridge Firebase, the windows registry, tray) is up from here
+  // Called by main.js once omega.initialize() completes — every LIB a handler
+  // touches (auth's Firebase, the windows registry, tray) is up from here
   // on. (Consumer-created windows may still be pending — consumers create them
   // in initialize().then(); app/show on a not-yet-created window warns + drops,
   // same as always.) Any dispatch that arrived earlier drains now.
-  markManagerReady() {
-    deepLink._managerReady = true;
+  markOmegaReady() {
+    deepLink._omegaReady = true;
     const queued = deepLink._bootQueue.slice();
     deepLink._bootQueue = [];
     queued.forEach(({ url, source, env }) => deepLink._handle(url, source, env));
@@ -260,10 +260,10 @@ const deepLink = {
 
   // Run the dispatch pipeline for a single URL.
   _handle(url, source, env) {
-    // Hold every dispatch until the manager is fully initialized — handlers
-    // deref manager surfaces that don't exist yet during boot.
-    if (!deepLink._managerReady) {
-      logger.log(`queueing ${source} dispatch until manager ready — ${url}`);
+    // Hold every dispatch until omega is fully initialized: handlers
+    // deref omega surfaces that do not exist yet during boot.
+    if (!deepLink._omegaReady) {
+      logger.log(`queueing ${source} dispatch until omega ready — ${url}`);
       deepLink._bootQueue.push({ url, source, env });
       return;
     }