@omega.js/desktop 0.52.0 → 0.53.0

package/dist/test/fixtures/consumer-app/config/omega.json5

@@ -29,7 +29,7 @@
       google: { id: '' },
     },
   },
-  // Empty config → client-bridge skips Firebase init (no hang on a fake projectId).
+  // Empty config → lib/auth.js skips Firebase init (no hang on a fake projectId).
   cloud: { provider: 'firebase', config: {} },
   targets: {
     desktop: {

package/dist/test/fixtures/consumer-app/src/assets/js/components/main/index.js

@@ -1,17 +1,14 @@
 // Minimal main-window renderer entry for the boot-layer self-test fixture.
-const Manager = require('@omega.js/desktop/renderer');
+import omega from '@omega.js/desktop/renderer';
 
-const manager = new Manager();
-manager.initialize();
+omega.initialize();
 
 // #925 pins that this renderer answers the lane's environment and not the word
-// baked into the bundle, so the boot inspect needs a handle on the Manager the
+// baked into the bundle, so the boot inspect needs a handle on the instance the
 // answer is given on.
-window.__omegaManager = manager;
+window.__omegaInstance = omega;
 
-// #111 — pins that the vendored core module resolves through the renderer's
-// `__main_assets__` alias AND runs: with no .omega-shell in this window the
-// call registers the shell API on omega._library and returns early, so a
-// module that throws on a vendored surface breaks this fixture's boot.
-window.__omegaAppShell = require('__main_assets__/js/core/app-shell.js').default;
-window.__omegaAppShell();
+// #111 pins that a vendored core module resolves through the renderer's
+// `__main_assets__` alias: an alias that does not resolve fails this fixture's
+// build, and the boot inspect reads the export it bound.
+window.__omegaCreateShell = require('__main_assets__/js/core/app-shell.js').createShell;

package/dist/test/fixtures/consumer-app/src/main.js

@@ -1,15 +1,13 @@
 // Minimal main entry for @omega.js/desktop's boot-layer self-test fixture. Mirrors a real consumer:
 // one-line bootstrap, then create the main window once initialize() resolves. The boot
-// harness (src/test/harness/boot-entry.js) inspects the live manager after this runs.
-const Manager = require('@omega.js/desktop/main');
+// harness (src/test/harness/boot-entry.js) inspects the live instance after this runs.
+const omega = require('@omega.js/desktop/main');
 
-const manager = new Manager();
-
-manager.initialize()
+omega.initialize()
   .then(() => {
-    const { windows, logger } = manager;
+    const { windows, logger } = omega;
 
-    // Force show:false — the boot harness runs headless and only asserts the window
+    // Force show:false: the boot harness runs headless and only asserts the window
     // EXISTS + loaded the built view, never that it's visible on screen.
     windows.create('main', { show: false });
 

package/dist/test/fixtures/consumer-app/src/preload.js

@@ -1,4 +1,4 @@
 // Minimal preload for the boot-layer self-test fixture. Exposes window.desktop to the renderer.
-const Manager = require('@omega.js/desktop/preload');
+const omega = require('@omega.js/desktop/preload');
 
-new Manager().initialize();
+omega.initialize();

package/dist/test/harness/boot-entry.js

@@ -1,6 +1,6 @@
-// Boot harness — invoked from @omega.js/desktop's main.js after manager.initialize() resolves
+// Boot harness: invoked from @omega.js/desktop's main.js (utils/boot-harness.js) after omega.initialize() resolves
 // when OMEGA_TEST_BOOT=1. Reads the spec file pointed to by OMEGA_TEST_BOOT_SPEC,
-// runs each `inspect` against the live manager, emits results, and quits.
+// runs each `inspect` against the live instance, emits results, and quits.
 //
 // Why call from main.js instead of preloading via electron's --require?
 // Because Electron rejects unknown CLI flags, we can't sneak args/preload modules in.
@@ -11,29 +11,31 @@
 // a project view (`view: '<name>'`), each in a real window of this booted app. See
 // runViewSuite() below.
 //
-// Protocol matches main-entry.js — emit `__EM_TEST__` JSON lines on stdout.
+// Protocol matches main-entry.js, emit `__OMEGA_TEST__` JSON lines on stdout.
 
 'use strict';
 
+const { TEST_EVENT_PREFIX } = require('../../utils/test-events.js');
+
 // Belt-and-suspenders for a view suite that never emits `end` (a page that died mid-run).
 // Same 60s ceiling the harness-page renderer lane uses (harness/main-entry.js).
 const VIEW_SUITE_TIMEOUT = 60000;
 
 function emit(obj) {
-  process.stdout.write(`__EM_TEST__${JSON.stringify(obj)}\n`);
+  process.stdout.write(`${TEST_EVENT_PREFIX}${JSON.stringify(obj)}\n`);
 }
 
-async function run(manager) {
+async function run(omega) {
   const { app } = require('electron');
   const path = require('path');
 
-  // Give the consumer's `manager.initialize().then(() => { ... })` callback time
+  // Give the consumer's `omega.initialize().then(() => { ... })` callback time
   // to surface windows / wire up handlers / etc. The harness runs from setImmediate
   // already (which flushes microtasks once), but `windows.create()` is async, so
   // we additionally poll for the main window for up to 3s. Apps that intentionally
   // launch hidden never create a main window — those tests should `if (!win) return`
   // when inspecting window state.
-  await waitForMainWindow(manager, 3000);
+  await waitForMainWindow(omega, 3000);
 
   const specPath = process.env.OMEGA_TEST_BOOT_SPEC;
   if (!specPath) {
@@ -74,7 +76,7 @@ async function run(manager) {
     description:  t.description,
     timeout:      t.timeout || 15000,
     inspect:      new Function('args', 'require', 'process', 'Buffer',
-      `return (async function ({ manager, expect, projectRoot, appRoot, frameworkDistRoot, distSnapshotBefore }) {\n${t.inspectSource}\n})(args)`,
+      `return (async function ({ omega, expect, projectRoot, appRoot, frameworkDistRoot, distSnapshotBefore }) {\n${t.inspectSource}\n})(args)`,
     ),
   }));
 
@@ -88,7 +90,7 @@ async function run(manager) {
     const start = Date.now();
     try {
       await Promise.race([
-        t.inspect(Object.assign({ manager, expect }, args), require, process, Buffer),
+        t.inspect(Object.assign({ omega, expect }, args), require, process, Buffer),
         new Promise((_, reject) => setTimeout(() => reject(new Error('Boot test timeout')), t.timeout)),
       ]);
       const duration = Date.now() - start;
@@ -109,7 +111,7 @@ async function run(manager) {
   // remaining suites unreported. This harness exits through app.exit() below regardless.
   if (viewSuites.length > 0) app.removeAllListeners('window-all-closed');
   for (let i = 0; i < viewSuites.length; i += 1) {
-    const counts = await runViewSuite(viewSuites[i], i, manager, spec);
+    const counts = await runViewSuite(viewSuites[i], i, omega, spec);
     passed  += counts.passed;
     failed  += counts.failed;
     skipped += counts.skipped;
@@ -127,7 +129,7 @@ async function run(manager) {
 // evaluated inside the page, with a shim standing in for the preload bridge it normally
 // talks to. There is exactly one suite loop and one `expect` in this framework, and this is
 // not a second copy of either.
-async function runViewSuite(suite, index, manager, spec) {
+async function runViewSuite(suite, index, omega, spec) {
   const fs   = require('fs');
   const path = require('path');
 
@@ -145,7 +147,7 @@ async function runViewSuite(suite, index, manager, spec) {
     return counts;
   }
 
-  const win = await manager.windows.create(`omega-test-view-${index}`, {
+  const win = await omega.windows.create(`omega-test-view-${index}`, {
     view:          suite.view,
     show:          false,
     persistBounds: false,
@@ -171,11 +173,11 @@ async function runViewSuite(suite, index, manager, spec) {
     //    surface talking to main over IPC; here the page just queues events for the poll
     //    below, since main is right here.
     await win.webContents.executeJavaScript(`
-      window.__emTestQueue = [];
-      window.__emTest = {
+      window.__omegaTestQueue = [];
+      window.__omegaTest = {
         ready() {},
-        emit(evt) { window.__emTestQueue.push(evt); },
-        onSuites(handler) { window.__emTestDeliver = handler; },
+        emit(evt) { window.__omegaTestQueue.push(evt); },
+        onSuites(handler) { window.__omegaTestDeliver = handler; },
       };
       null;
     `);
@@ -187,7 +189,7 @@ async function runViewSuite(suite, index, manager, spec) {
 
     // 3. Deliver this window's one suite. One suite per window, so the entry's `end` event
     //    ends this window's run.
-    await win.webContents.executeJavaScript(`window.__emTestDeliver(${JSON.stringify([suite])}); null;`);
+    await win.webContents.executeJavaScript(`window.__omegaTestDeliver(${JSON.stringify([suite])}); null;`);
 
     // 4. Drain the queue until the run ends. Every event is forwarded verbatim, so the
     //    parent renders a view suite exactly like a harness-page one.
@@ -195,7 +197,7 @@ async function runViewSuite(suite, index, manager, spec) {
     let ended = false;
     while (!ended && Date.now() < deadline) {
       await new Promise((resolve) => setTimeout(resolve, 50));
-      const events = await win.webContents.executeJavaScript('window.__emTestQueue.splice(0)');
+      const events = await win.webContents.executeJavaScript('window.__omegaTestQueue.splice(0)');
       for (const evt of events) {
         emit(evt);
         if (evt.event === 'end') {
@@ -226,10 +228,10 @@ async function runViewSuite(suite, index, manager, spec) {
 
 // Poll for the main window for up to `timeoutMs`. Resolves when it shows up, or after
 // the timeout (no error — agent/hidden apps never create one and that's fine).
-async function waitForMainWindow(manager, timeoutMs) {
+async function waitForMainWindow(omega, timeoutMs) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
-    if (manager?.windows?.get?.('main')) return;
+    if (omega.windows.get('main')) return;
     await new Promise((resolve) => setTimeout(resolve, 25));
   }
 }

package/dist/test/harness/main-entry.js

@@ -13,15 +13,16 @@
 // exits 0 on success / 1 on any failure.
 
 const path = require('path');
+const { TEST_EVENT_PREFIX } = require('../../utils/test-events.js');
 const { app, BrowserWindow, ipcMain } = require('electron');
 
 // macOS: suppress app activation BEFORE ready — launching a regular-policy app
 // steals keyboard focus app-wide even when no window is ever focused. This file
-// only initializes its Manager after whenReady (too late: activation fires when
+// only initializes its instance after whenReady (too late: activation fires when
 // the app finishes launching), so flip the accessory policy here at require time.
 // This process is always a test run (runners/electron.js spawns it naming
 // OMEGA_ENVIRONMENT=testing, the one environment input), so
-// the shared predicate needs no Manager. OMEGA_TEST_SHOW=1 opts back into normal
+// the shared predicate needs no instance. OMEGA_TEST_SHOW=1 opts back into normal
 // activation along with visible windows.
 if (process.platform === 'darwin' && require('../../utils/test-stealth.js')()) {
   app.dock.hide();
@@ -31,7 +32,7 @@ if (process.platform === 'darwin' && require('../../utils/test-stealth.js')()) {
 // the harness Electron (e.g. playwright-core connectOverCDP). Port 0 = an
 // OS-assigned loopback-only port; Chromium writes the resolved port to
 // DevToolsActivePort inside the userData dir that's CURRENT when the DevTools
-// server starts — captured here at require time, because Manager.initialize()
+// server starts, captured here at require time, because omega.initialize()
 // re-paths userData later (post-ready in this harness). runSuites() resolves
 // the port from that file and publishes it as process.env.OMEGA_CDP_PORT.
 if (!app.commandLine.hasSwitch('remote-debugging-port')) {
@@ -73,7 +74,7 @@ const filter = (() => {
 })();
 
 function emit(obj) {
-  process.stdout.write(`__EM_TEST__${JSON.stringify(obj)}\n`);
+  process.stdout.write(`${TEST_EVENT_PREFIX}${JSON.stringify(obj)}\n`);
 }
 
 class SkipError extends Error {
@@ -98,8 +99,8 @@ async function runSuites() {
     await new Promise((resolve) => setTimeout(resolve, 100));
   }
 
-  const Manager = require('../../main.js');
-  const manager = new Manager();
+  // The ONE main-process instance, the same object a consumer's main.js requires
+  const omega = require('../../main.js');
 
   // Test mode: load default config from @omega.js/desktop defaults (since the harness CWD won't have
   // one), resolved for the desktop target via @omega.js/config, and skip window creation
@@ -109,7 +110,7 @@ async function runSuites() {
   const { loadConfig } = require('../../vendor/config/index.js');
   const defaultConfig = loadConfig(path.join(__dirname, '..', '..', 'defaults'), 'desktop').config;
 
-  await manager.initialize(defaultConfig, { skipWindowCreation: true });
+  await omega.initialize(defaultConfig, { skipWindowCreation: true });
 
   // Consumer-scheme containment. Main-layer suites exercise consumer code that
   // loads `<brand.id>://` URLs (tab managers, internal pages), but the consumer's
@@ -151,7 +152,7 @@ async function runSuites() {
     expect: require('../assert.js'),
     state,
     layer: 'main',
-    manager,
+    omega,
     skip(reason) { throw new SkipError(reason); },
   });
 
@@ -200,7 +201,7 @@ async function runSuites() {
   // After main suites finish, optionally run renderer suites in a hidden BrowserWindow.
   if (rendererSuiteFiles.length > 0) {
     try {
-      const r = await runRendererSuites(rendererSuiteFiles, manager);
+      const r = await runRendererSuites(rendererSuiteFiles, omega);
       passed  += r.passed;
       failed  += r.failed;
       skipped += r.skipped;
@@ -217,7 +218,7 @@ async function runSuites() {
 // Spawn a hidden BrowserWindow and run each renderer suite inside it. Each suite file is
 // loaded via require() in main, then its tests are serialized to { name, runSource } and
 // shipped over IPC for the renderer to reconstruct + execute.
-async function runRendererSuites(files, manager) {
+async function runRendererSuites(files, omega) {
   // Serialize suites for transport. We can't ship functions directly via IPC, so we extract
   // the function body of each test's `run` and ship that as a string. The renderer rebuilds
   // it with `new Function('ctx', body)`.
@@ -262,9 +263,9 @@ async function runRendererSuites(files, manager) {
 
   const harnessDir = __dirname;
   // Tell the renderer-preload (running in the BrowserWindow's preload) where to
-  // require() the renderer Manager from. We resolve by absolute path because the
+  // require() the renderer instance from. We resolve by absolute path because the
   // preload runs with the renderer's module resolution scope, not main's.
-  process.env.OMEGA_TEST_RENDERER_MANAGER_PATH = path.resolve(__dirname, '..', '..', 'renderer.js');
+  process.env.OMEGA_TEST_RENDERER_PATH = path.resolve(__dirname, '..', '..', 'renderer.js');
 
   // Register test-only IPC channels so renderer-layer tests can verify round-trip
   // behavior end-to-end (renderer.invoke → main handler → response). Idempotent:
@@ -273,15 +274,15 @@ async function runRendererSuites(files, manager) {
   ipcMain.handle('desktop:__test:echo', (_evt, payload) => ({ echoed: payload, ts: Date.now() }));
   // Forwarded log capture — renderer logger.log(...) sends 'desktop:log:forward'; we
   // accumulate the most recent payload so the renderer test can verify it landed.
-  global.__emTestLastForwardedLog = null;
+  global.__omegaTestLastForwardedLog = null;
   ipcMain.removeAllListeners('desktop:__test:forwarded-log-tap');
   ipcMain.on('desktop:log:forward', (_evt, payload) => {
-    global.__emTestLastForwardedLog = payload;
+    global.__omegaTestLastForwardedLog = payload;
   });
   // Test-only handler the renderer can call to read back the most recently
   // forwarded log payload. Returns null if none yet.
   try { ipcMain.removeHandler('desktop:__test:read-last-log'); } catch (_) { /* ignore */ }
-  ipcMain.handle('desktop:__test:read-last-log', () => global.__emTestLastForwardedLog);
+  ipcMain.handle('desktop:__test:read-last-log', () => global.__omegaTestLastForwardedLog);
   // Analytics sender tap ([#411](https://github.com/Omega-JS-Stack/omega/issues/411)):
   // renderer-originated omega.analytics() calls forward over IPC and must fire
   // through main's ONE sender, so a renderer suite needs to read back what that
@@ -296,17 +297,17 @@ async function runRendererSuites(files, manager) {
   // identity fields), so a suite asserts on `client_id` as GA would receive it
   // rather than on a field the tap made up.
   const analyticsCore = require('../../vendor/analytics/core.js');
-  global.__emTestAnalyticsSends = [];
-  manager.analytics.shutdown();
-  manager.analytics._send = (descriptor) => {
-    global.__emTestAnalyticsSends.push({
+  global.__omegaTestAnalyticsSends = [];
+  omega.analytics.shutdown();
+  omega.analytics._send = (descriptor) => {
+    global.__omegaTestAnalyticsSends.push({
       provider: descriptor.provider,
       name:     descriptor.name,
       payload:  descriptor.payload,
       body:     analyticsCore.buildPayload({
-        clientId:       manager.analytics._clientId,
-        userId:         manager.analytics._userId,
-        userProperties: manager.analytics._userProperties,
+        clientId:       omega.analytics._clientId,
+        userId:         omega.analytics._userId,
+        userProperties: omega.analytics._userProperties,
         eventName:      descriptor.name,
         params:         descriptor.payload,
       }),
@@ -314,10 +315,10 @@ async function runRendererSuites(files, manager) {
     return true;
   };
   process.env.GOOGLE_ANALYTICS_SECRET = 'harness-secret';
-  manager.config.analytics = { providers: { google: { id: 'G-HARNESS1' } } };
-  manager.analytics.initialize(manager);
+  omega.config.analytics = { providers: { google: { id: 'G-HARNESS1' } } };
+  omega.analytics.initialize(omega);
   try { ipcMain.removeHandler('desktop:__test:read-analytics-sends'); } catch (_) { /* ignore */ }
-  ipcMain.handle('desktop:__test:read-analytics-sends', () => global.__emTestAnalyticsSends);
+  ipcMain.handle('desktop:__test:read-analytics-sends', () => global.__omegaTestAnalyticsSends);
   const win = new BrowserWindow({
     show:           false,
     width:          800,
@@ -337,16 +338,16 @@ async function runRendererSuites(files, manager) {
       if (resolved) return;
       resolved = true;
       try { win.destroy(); } catch (_e) { /* noop */ }
-      ipcMain.removeAllListeners('__emTest:ready');
-      ipcMain.removeAllListeners('__emTest:result');
+      ipcMain.removeAllListeners('__omegaTest:ready');
+      ipcMain.removeAllListeners('__omegaTest:result');
       if (err) reject(err); else resolve(val);
     };
 
-    ipcMain.on('__emTest:ready', () => {
-      win.webContents.send('__emTest:suites', suites);
+    ipcMain.on('__omegaTest:ready', () => {
+      win.webContents.send('__omegaTest:suites', suites);
     });
 
-    ipcMain.on('__emTest:result', (_e, evt) => {
+    ipcMain.on('__omegaTest:result', (_e, evt) => {
       // Forward verbatim to stdout — same envelope as main-process events.
       emit(evt);
       if (evt.event === 'result') {

package/dist/test/harness/renderer-entry.js

@@ -1,8 +1,8 @@
 // Renderer test-harness entry. Runs inside the hidden BrowserWindow.
 //
 // Lifecycle:
-//   1. window load → __emTest.ready()
-//   2. main sends suites via __emTest:suites
+//   1. window load → __omegaTest.ready()
+//   2. main sends suites via __omegaTest:suites
 //   3. renderer reconstructs each test fn via new Function('ctx', body), runs it sequentially
 //   4. emits { event, ... } for each result; emits { event: 'end' } when done
 //
@@ -24,7 +24,7 @@
   };
 
   function emit(evt) {
-    try { window.__emTest.emit(evt); } catch (e) { /* harness gone */ }
+    try { window.__omegaTest.emit(evt); } catch (e) { /* harness gone */ }
   }
 
   // Tiny inline expect — mirrors src/test/assert.js minimal surface used by tests.
@@ -162,12 +162,12 @@
     emit({ event: 'end', passed, failed, skipped });
   }
 
-  window.__emTest.onSuites((suites) => {
+  window.__omegaTest.onSuites((suites) => {
     runAll(suites).catch((e) => {
       emit({ event: 'fatal', message: e.message, stack: e.stack });
     });
   });
 
   // Signal ready as soon as the page is parsed.
-  window.__emTest.ready();
+  window.__omegaTest.ready();
 })();