@omega.js/desktop 0.51.0 → 0.53.0

package/dist/test/suites/boot/consumer-app-boots.test.js

@@ -1,8 +1,8 @@
-// Boot-layer self-test — @omega.js/desktop's analog of "does the extension load?" (BXM) / "does the
-// site boot?" (UJM). The boot runner esbuild-builds the bundled fixture consumer
+// Boot-layer self-test — @omega.js/desktop's analog of "does the extension load?" /
+// "does the site boot?". The boot runner esbuild-builds the bundled fixture consumer
 // (src/test/fixtures/consumer-app) into a real main.bundle.js, spawns Electron with
 // it (the actual production boot path — bundled, not the unbundled lib code that the
-// `main` layer exercises), then runs these inspects against the live manager.
+// `main` layer exercises), then runs these inspects against the live omega instance.
 //
 // In @omega.js/desktop's own test run, OMEGA_TEST_BOOT_PROJECT points at the fixture (auto-set in
 // src/commands/test.js when the cwd is the @omega.js/desktop repo). In a real consumer's
@@ -11,7 +11,7 @@
 // boot tests under <cwd>/test/boot/.
 //
 // NOTE: inspect bodies are serialized to the spawned Electron process — no closures over
-// module scope. `require`, `process`, and `Buffer` are injected; { manager, expect,
+// module scope. `require`, `process`, and `Buffer` are injected; { omega, expect,
 // projectRoot, appRoot, frameworkDistRoot, distSnapshotBefore } is the inspect argument
 // (projectRoot = the fixture root; appRoot = the staged target root holding the build).
 
@@ -24,25 +24,25 @@ module.exports = defineCases({
   timeout: 30000,
   tests: [
     {
-      description: 'manager initialized with all core libs wired',
-      inspect: async ({ manager, expect }) => {
-        expect(manager).toBeTruthy();
-        expect(manager._initialized).toBe(true);
-        for (const lib of ['storage', 'ipc', 'windows', 'tray', 'menu', 'contextMenu', 'omega']) {
-          expect(Boolean(manager[lib])).toBe(true);
+      description: 'omega initialized with all core libs wired',
+      inspect: async ({ omega, expect }) => {
+        expect(omega).toBeTruthy();
+        expect(omega._initialized).toBe(true);
+        for (const lib of ['storage', 'ipc', 'windows', 'tray', 'menu', 'contextMenu', 'auth']) {
+          expect(Boolean(omega[lib])).toBe(true);
         }
       },
     },
 
     {
       description: 'the fixture main.js created the main window and loaded the built view',
-      inspect: async ({ manager, expect }) => {
+      inspect: async ({ omega, expect }) => {
         const { BrowserWindow } = require('electron');
 
         // windows.create() runs inside the consumer's initialize().then(); poll for it.
         let url = '';
         for (let i = 0; i < 40; i++) {
-          const win = manager.windows.get('main') || BrowserWindow.getAllWindows()[0];
+          const win = omega.windows.get('main') || BrowserWindow.getAllWindows()[0];
           if (win && !win.isDestroyed()) {
             url = win.webContents.getURL();
             if (url.includes('/views/main/')) break;
@@ -50,23 +50,23 @@ module.exports = defineCases({
           await new Promise((resolve) => setTimeout(resolve, 100));
         }
 
-        expect(Boolean(manager.windows.get('main'))).toBe(true);
+        expect(Boolean(omega.windows.get('main'))).toBe(true);
         expect(url.includes('/views/main/')).toBe(true);
       },
     },
 
     {
       description: 'test stealth: app activation suppressed — dock hidden (macOS)',
-      inspect: async ({ manager, expect }) => {
+      inspect: async ({ omega, expect }) => {
         if (process.platform !== 'darwin') {
           return; // accessory activation policy / dock is macOS-only
         }
-        // Manager.initialize step 1a hides the dock under the stealth predicate,
+        // omega.initialize step 1a hides the dock under the stealth predicate,
         // so the spawned consumer app never activates and never steals keyboard
         // focus from the developer's editor.
         const { app } = require('electron');
         expect(app.dock.isVisible()).toBe(false);
-        expect(manager.isTesting()).toBe(true);
+        expect(omega.isTesting()).toBe(true);
       },
     },
 
@@ -83,8 +83,8 @@ module.exports = defineCases({
     {
       // #111 — the fixture's renderer entry imports the vendored app-shell
       // module through the `__main_assets__` alias. Its declarative contract
-      // showing up in the built bundle proves the whole chain: esbuild alias →
-      // @omega.js/desktop's vendored dist asset → its @omega.js/client import.
+      // showing up in the built bundle proves the chain: esbuild alias →
+      // @omega.js/desktop's vendored dist asset.
       description: 'renderer bundle carries the vendored app-shell module via __main_assets__',
       inspect: async ({ expect, appRoot }) => {
         const fs = require('fs');
@@ -105,12 +105,12 @@ module.exports = defineCases({
       // line the bridge logs next is out of reach here, because the fixture's
       // `cloud.config` is empty and this boot never initializes Firebase auth.)
       description: 'the booted app runs in the lane environment, not the one baked into its bundle (#925)',
-      inspect: async ({ manager, expect, projectRoot }) => {
+      inspect: async ({ omega, expect, projectRoot }) => {
         const fs = require('fs');
         const path = require('path');
 
-        expect(manager.isTesting()).toBe(true);
-        expect(manager.config.environment).toBe('production');   // the artifact IS a production build
+        expect(omega.isTesting()).toBe(true);
+        expect(omega.config.environment).toBe('production');   // the artifact IS a production build
 
         const log = fs.readFileSync(path.join(projectRoot, 'logs', 'runtime.log'), 'utf8');
         expect(log.includes('auth persistence: none (test mode)')).toBe(true);
@@ -118,11 +118,11 @@ module.exports = defineCases({
     },
 
     {
-      // #925: a page has no `process`, so its Manager reads the baked word. The
+      // #925: a page has no `process`, so its instance reads the baked word. The
       // preload hands the running one over on `window.desktop`, and the renderer
       // bootstrap applies it, so this window answers what main answers.
       description: 'the main window renderer answers the lane environment too (#925)',
-      inspect: async ({ manager, expect }) => {
+      inspect: async ({ omega, expect }) => {
         const { BrowserWindow } = require('electron');
 
         // The window is created in the consumer's initialize().then(), and its
@@ -131,10 +131,10 @@ module.exports = defineCases({
         let answer = null;
         let win = null;
         for (let i = 0; i < 40; i++) {
-          win = manager.windows.get('main') || BrowserWindow.getAllWindows()[0];
+          win = omega.windows.get('main') || BrowserWindow.getAllWindows()[0];
           if (win && !win.isDestroyed() && !win.webContents.isLoading()) {
             answer = await win.webContents.executeJavaScript(
-              'window.__omegaManager && window.__omegaManager.config ? window.__omegaManager.getEnvironment() : null',
+              'window.__omegaInstance && window.__omegaInstance.config.environment ? window.__omegaInstance.getEnvironment() : null',
             );
             if (answer) break;
           }
@@ -146,7 +146,38 @@ module.exports = defineCases({
 
         expect(baked).toBe('production');     // what the build baked
         expect(bridged).toBe('testing');      // what the preload read off the lane
-        expect(answer).toBe('testing');       // what the renderer's Manager answers
+        expect(answer).toBe('testing');       // what the renderer's instance answers
+      },
+    },
+
+    {
+      // The renderer builds `omega.shell` from ITSELF with the vendored app
+      // shell's createShell(omega), exactly as web builds it; the fixture binds
+      // the same export through the `__main_assets__` alias (#111).
+      description: 'the main window renderer carries omega.shell, built by createShell(omega)',
+      inspect: async ({ omega, expect }) => {
+        const { BrowserWindow } = require('electron');
+
+        let probe = null;
+        for (let i = 0; i < 40; i++) {
+          const win = omega.windows.get('main') || BrowserWindow.getAllWindows()[0];
+          if (win && !win.isDestroyed() && !win.webContents.isLoading()) {
+            probe = await win.webContents.executeJavaScript(`(() => {
+              const instance = window.__omegaInstance;
+              if (!instance || !instance.shell) return null;
+              return {
+                createShell: typeof window.__omegaCreateShell,
+                isCollapsed: typeof instance.shell.isCollapsed,
+                toggleOpen: typeof instance.shell.toggleOpen,
+                desktopIsBridge: instance.desktop === window.desktop,
+              };
+            })()`);
+            if (probe) break;
+          }
+          await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+
+        expect(probe).toEqual({ createShell: 'function', isCollapsed: 'function', toggleOpen: 'function', desktopIsBridge: true });
       },
     },
   ],

package/dist/test/suites/boot/restart-manager.test.js

@@ -16,8 +16,8 @@ module.exports = defineCases({
   tests: [
     {
       description: 'restartManager wired, bailed as testing, nothing scheduled',
-      inspect: async ({ manager, expect }) => {
-        const rm = manager.restartManager;
+      inspect: async ({ omega, expect }) => {
+        const rm = omega.restartManager;
         expect(Boolean(rm)).toBe(true);
         for (const fn of ['register', 'unregister', 'ensureInstalled', 'ensureRunning', 'getStatus', 'shutdown']) {
           expect(typeof rm[fn]).toBe('function');

package/dist/test/suites/boot/storage-bundled.test.js

@@ -40,19 +40,19 @@ module.exports = defineCases({
 
     {
       description: 'storage is a REAL store through the bundle (not the no-op fallback)',
-      inspect: async ({ manager, expect }) => {
+      inspect: async ({ omega, expect }) => {
         const fs = require('fs');
 
         // The no-op fallback leaves _store null → getPath() null and get() always default.
-        manager.storage.set('desktop:boot:storageProof', 'bundled');
-        expect(manager.storage.get('desktop:boot:storageProof')).toBe('bundled');
+        omega.storage.set('desktop:boot:storageProof', 'bundled');
+        expect(omega.storage.get('desktop:boot:storageProof')).toBe('bundled');
 
-        const storePath = manager.storage.getPath();
+        const storePath = omega.storage.getPath();
         expect(Boolean(storePath)).toBe(true);
         expect(storePath.endsWith('omega-storage.json')).toBe(true);
         expect(fs.existsSync(storePath)).toBe(true);
 
-        manager.storage.delete('desktop:boot:storageProof');
+        omega.storage.delete('desktop:boot:storageProof');
       },
     },
   ],

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

@@ -16,39 +16,39 @@ module.exports = defineCases({
   tests: [
     {
       description: 'page boots with data-bs-theme equal to the resolved appearance',
-      inspect: async ({ manager, expect }) => {
+      inspect: async ({ omega, expect }) => {
         const { BrowserWindow } = require('electron');
 
-        expect(manager.theme._initialized).toBe(true);
-        expect(['light', 'dark'].includes(manager.theme.resolved())).toBe(true);
+        expect(omega.theme._initialized).toBe(true);
+        expect(['light', 'dark'].includes(omega.theme.resolved())).toBe(true);
 
         // Wait for the fixture's main window + view, then for the applier to land
         // (it applies at DOMContentLoaded).
         let attr = null;
         for (let i = 0; i < 50; i++) {
-          const win = manager.windows.get('main') || BrowserWindow.getAllWindows()[0];
+          const win = omega.windows.get('main') || BrowserWindow.getAllWindows()[0];
           if (win && !win.isDestroyed() && win.webContents.getURL().includes('/views/main/')) {
             attr = await win.webContents.executeJavaScript('document.documentElement.getAttribute("data-bs-theme")').catch(() => null);
-            if (attr === manager.theme.resolved()) break;
+            if (attr === omega.theme.resolved()) break;
           }
           await new Promise((resolve) => setTimeout(resolve, 100));
         }
 
-        expect(attr).toBe(manager.theme.resolved());
+        expect(attr).toBe(omega.theme.resolved());
       },
     },
 
     {
       description: 'main-side theme.set() updates the live page attribute (no reload)',
-      inspect: async ({ manager, expect }) => {
+      inspect: async ({ omega, expect }) => {
         const { BrowserWindow } = require('electron');
-        const win = manager.windows.get('main') || BrowserWindow.getAllWindows()[0];
+        const win = omega.windows.get('main') || BrowserWindow.getAllWindows()[0];
         expect(Boolean(win && !win.isDestroyed())).toBe(true);
 
-        const original = manager.theme.get();
-        const target = manager.theme.resolved() === 'dark' ? 'light' : 'dark';
+        const original = omega.theme.get();
+        const target = omega.theme.resolved() === 'dark' ? 'light' : 'dark';
 
-        manager.theme.set(target);
+        omega.theme.set(target);
 
         let attr = null;
         for (let i = 0; i < 50; i++) {
@@ -58,8 +58,8 @@ module.exports = defineCases({
         }
 
         // Restore before asserting so a failure can't strand the flipped state.
-        manager.theme.set(original);
-        manager.storage.delete('theme.appearance');
+        omega.theme.set(original);
+        omega.storage.delete('theme.appearance');
 
         expect(attr).toBe(target);
       },

package/dist/test/suites/build/audit.test.js

@@ -12,7 +12,7 @@ const defineCases = require('../../../vendor/devkit/test/define-cases.js');
 const auditPath = path.join(__dirname, '..', '..', '..', 'gulp', 'tasks', 'audit.js');
 
 function freshAudit() {
-  // Clear require cache so each test gets a clean module (it instantiates Manager at require time).
+  // Clear require cache so each test gets a clean module (it loads the build module at require time).
   delete require.cache[require.resolve(auditPath)];
   return require(auditPath);
 }

package/dist/test/suites/build/auth-persistence-resolve.test.js

@@ -3,7 +3,7 @@
 //
 // The managers are plain objects and `available()` is stubbed, so the production
 // default is provable with no Electron and, above all, with no call into this box's
-// OS keychain. The real-manager half lives in the main suite, which now runs under
+// OS keychain. The real-instance half lives in the main suite, which now runs under
 // the forced test-mode strategy itself.
 
 const path = require('path');
@@ -41,7 +41,7 @@ module.exports = defineCases({
   description: 'auth-persistence resolve(): the production default, and the test-mode override',
   tests: [
     {
-      name: 'a production manager with no config still picks safeStorage; an unknown name warns to null',
+      name: 'a production omega instance with no config still picks safeStorage; an unknown name warns to null',
       run: async (ctx) => {
         const vault = stubSafeStorage();
         const lines = [];
@@ -63,7 +63,7 @@ module.exports = defineCases({
       },
     },
     {
-      name: 'a testing manager gets none before any config read, and the vault is never asked',
+      name: 'a testing omega instance gets none before any config read, and the vault is never asked',
       run: async (ctx) => {
         const vault = stubSafeStorage();
         const lines = [];
@@ -97,13 +97,13 @@ module.exports = defineCases({
           // explicit one alone ([#925](https://github.com/Omega-JS-Stack/omega/issues/925)),
           // and so the real isTesting() answers the lane, not the bake.
           process.env[ENVIRONMENT_VAR] = 'testing';
-          const manager = {
+          const omega = {
             config:    { environment: 'production', omega: { authPersistence: 'safeStorage' } },
             isTesting,
           };
-          ctx.expect(manager.isTesting()).toBe(true);
+          ctx.expect(omega.isTesting()).toBe(true);
 
-          const active = await capture(lines, () => authPersistence.resolve(manager));
+          const active = await capture(lines, () => authPersistence.resolve(omega));
           ctx.expect(active).toBeNull();
           ctx.expect(vault.calls.available).toBe(0);
           ctx.expect(lines.join('\n')).toMatch(/auth persistence: none \(test mode\)/);

package/dist/test/suites/build/boot-fixture.test.js

@@ -15,9 +15,9 @@
 
 const path = require('path');
 
-const Manager = require('../../../build.js');
+const build = require('../../../build.js');
 
-const package = Manager.getPackage('main');
+const package = build.getPackage('main');
 const fixture = require(path.join(__dirname, '..', '..', 'fixtures', 'consumer-app', 'package.json'));
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
 

package/dist/test/suites/build/boot-runner-timeout.test.js

@@ -15,6 +15,7 @@ const jetpack = require('fs-jetpack');
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
 
 const { runBootChild } = require(path.join(__dirname, '..', '..', 'runners', 'boot.js'));
+const { TEST_EVENT_PREFIX } = require(path.join(__dirname, '..', '..', '..', 'utils', 'test-events.js'));
 
 // A project root the runner reads its report clue from. `logLine` null writes no
 // logs/ at all, the boot that died before the logger ever opened a file.
@@ -152,11 +153,11 @@ module.exports = defineCases({
             killGraceMs:   20,
           });
 
-          child.stdout.emit('data', `__EM_TEST__${JSON.stringify({ event: 'result', name: 'the app boots', passed: true, duration: 12 })}\n`);
+          child.stdout.emit('data', `${TEST_EVENT_PREFIX}${JSON.stringify({ event: 'result', name: 'the app boots', passed: true, duration: 12 })}\n`);
           await sleep(150);
-          child.stdout.emit('data', `__EM_TEST__${JSON.stringify({ event: 'result', name: 'a slow suite finishes', passed: true, duration: 12 })}\n`);
+          child.stdout.emit('data', `${TEST_EVENT_PREFIX}${JSON.stringify({ event: 'result', name: 'a slow suite finishes', passed: true, duration: 12 })}\n`);
           await sleep(150);
-          child.stdout.emit('data', `__EM_TEST__${JSON.stringify({ event: 'result', name: 'and another', passed: true, duration: 12 })}\n`);
+          child.stdout.emit('data', `${TEST_EVENT_PREFIX}${JSON.stringify({ event: 'result', name: 'and another', passed: true, duration: 12 })}\n`);
           await sleep(150);
           child.emit('exit', 0);
 
@@ -196,7 +197,7 @@ module.exports = defineCases({
             killGraceMs:   20,
           });
 
-          child.stdout.emit('data', `__EM_TEST__${JSON.stringify({ event: 'result', name: 'a late line', passed: true, duration: 12 })}\n`);
+          child.stdout.emit('data', `${TEST_EVENT_PREFIX}${JSON.stringify({ event: 'result', name: 'a late line', passed: true, duration: 12 })}\n`);
           child.emit('exit', 0);
           await sleep(40);
 
@@ -231,7 +232,7 @@ module.exports = defineCases({
             killGraceMs:   20,
           });
 
-          child.stdout.emit('data', `__EM_TEST__${JSON.stringify({ event: 'result', name: 'the app boots', passed: true, duration: 12 })}\n`);
+          child.stdout.emit('data', `${TEST_EVENT_PREFIX}${JSON.stringify({ event: 'result', name: 'the app boots', passed: true, duration: 12 })}\n`);
           child.emit('exit', 0);
 
           const settled = await pending;

package/dist/test/suites/build/brand-scss.test.js

@@ -29,7 +29,7 @@ function stageConsumer(color) {
 
 /**
  * Run the sass task with the fixture as the project root. Both the task and the
- * build Manager resolve that root at REQUIRE time, so each run gets a fresh
+ * build module resolve that root at REQUIRE time, so each run gets a fresh
  * copy of both.
  */
 function runSassIn(dir) {

package/dist/test/suites/build/build-json-bake.test.js

@@ -133,7 +133,7 @@ module.exports = defineCases({
           ctx.expect(blob.license.status).toBe('licensed');
           ctx.expect(typeof blob.builtAt).toBe('string');
           // The mode is the same THREE keys everywhere (#894): desktop's own
-          // `server` verdict stays inside the Manager.
+          // `server` verdict stays inside the build module.
           ctx.expect(Object.keys(blob.mode).sort()).toEqual(['build', 'environment', 'publish']);
           ctx.expect(blob.mode.environment).toBe('production');
           ctx.expect(blob.mode.build).toBe(true);

package/dist/test/suites/build/cli.test.js

@@ -3,9 +3,9 @@
 const path = require('path');
 const fs = require('fs');
 
-const Manager = require('../../../build.js');
+const build = require('../../../build.js');
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
-const root = Manager.getRootPath('main');
+const root = build.getRootPath('main');
 
 module.exports = defineCases({
   type: 'group',

package/dist/test/suites/build/config-schema.test.js

@@ -10,9 +10,9 @@ const fs = require('fs');
 const JSON5 = require('json5');
 const { loadConfig } = require('../../../vendor/config/index.js');
 
-const Manager = require('../../../build.js');
+const build = require('../../../build.js');
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
-const root = Manager.getRootPath('main');
+const root = build.getRootPath('main');
 const defaultsDir = path.join(root, 'dist', 'defaults');
 const defaultConfigPath = path.join(defaultsDir, 'config', 'omega.json5');
 
@@ -76,7 +76,7 @@ module.exports = defineCases({
       name: 'resolved: has app block (appId + productName may be null — derived from brand)',
       run: (ctx) => {
         // appId and productName are derived from brand.id / brand.name at config-load
-        // time (Manager.getConfig). The raw scaffold leaves them null on purpose so the
+        // time (build.getConfig). The raw scaffold leaves them null on purpose so the
         // user only sets brand.{id,name} once. The `app` block itself must exist for
         // copyright + any future explicit overrides.
         ctx.expect(ctx.state.cfg.app).toBeTruthy();
@@ -96,7 +96,7 @@ module.exports = defineCases({
       run: (ctx) => {
         // Tray, menu, and context-menu use fixed conventional paths
         // (src/integrations/{tray,menu,context-menu}/index.js). Disabling is a runtime
-        // call (manager.tray.disable() etc.), not a config flag. Config carries no entry
+        // call (omega.tray.disable() etc.), not a config flag. Config carries no entry
         // for these in v1 — guard against re-introducing one accidentally.
         ctx.expect(ctx.state.cfg.tray).toBeUndefined();
         ctx.expect(ctx.state.cfg.menu).toBeUndefined();
@@ -125,7 +125,7 @@ module.exports = defineCases({
       name: 'has NO deepLinks config block (scheme = brand.id, routes are runtime)',
       run: (ctx) => {
         // deep-link scheme is auto-derived from brand.id; routes register at runtime via
-        // manager.deepLink.on(). Guard against re-introducing a config block.
+        // omega.deepLink.on(). Guard against re-introducing a config block.
         ctx.expect(ctx.state.cfg.deepLinks).toBeUndefined();
       },
     },

package/dist/test/suites/build/defaults-scaffold.test.js

@@ -9,11 +9,11 @@ const fs = require('fs');
 const os = require('os');
 const jetpack = require('fs-jetpack');
 
-const Manager = require('../../../build.js');
+const build = require('../../../build.js');
 const { renderSecretsBlock } = require('../../../vendor/config/env-delivery.js');
 const { copyDefaults } = require('../../../commands/lib/ensure-target.js');
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
-const package = Manager.getPackage('main');
+const package = build.getPackage('main');
 
 const DEFAULT_MARKER = '# ========== Default Values ==========';
 const CUSTOM_MARKER = '# ========== Custom Values ==========';

package/dist/test/suites/build/deploy-hook.test.js

@@ -57,7 +57,7 @@ async function runDeploy(options) {
   fs.writeFileSync(path.join(tmp, 'package.json'), '{"name":"desktop-deploy-hook-test"}');
   fs.writeFileSync(
     path.join(tmp, 'hooks', 'deploy', 'pre.js'),
-    `module.exports = async (ctx) => { global.__omegaDeployHookRan.push('deploy/pre:' + (ctx.projectRoot === process.cwd() && typeof ctx.manager === 'object' && ctx.mode === 'production' ? 'ctx ok' : 'ctx wrong')); };`,
+    `module.exports = async (ctx) => { global.__omegaDeployHookRan.push('deploy/pre:' + (ctx.projectRoot === process.cwd() && typeof ctx.build === 'object' && ctx.mode === 'production' ? 'ctx ok' : 'ctx wrong')); };`,
   );
 
   const restores = [
@@ -72,7 +72,7 @@ async function runDeploy(options) {
   global.__omegaDeployHookRan = ran;
 
   try {
-    // Required BEFORE the chdir: the verb builds its Manager at load time from
+    // Required BEFORE the chdir: the verb loads its build module at load time from
     // the real target; only the hook lookup reads cwd, at call time.
     const deploy = require(resolved);
     process.chdir(tmp);
@@ -139,7 +139,7 @@ module.exports = defineCases({
   description: 'deploy: the consumer\'s hooks/deploy/pre.js runs before the precheck (#899)',
   tests: [
     {
-      name: 'the hook runs after the scaffold and before the network precheck, with { manager, projectRoot, mode: production }',
+      name: 'the hook runs after the scaffold and before the network precheck, with { build, projectRoot, mode: production }',
       run: async (ctx) => {
         const ran = await runDeploy({});
         ctx.expect(ran).toEqual(['ensure-target', 'deploy/pre:ctx ok', 'precheck', 'STOP AT PRECHECK']);

package/dist/test/suites/build/ensure-target.test.js

@@ -13,13 +13,13 @@ const os = require('os');
 const jetpack = require('fs-jetpack');
 
 const SRC = path.join(__dirname, '..', '..', '..');
-const Manager = require(path.join(SRC, 'build.js'));
+const build = require(path.join(SRC, 'build.js'));
 const { ensureTarget } = require(path.join(SRC, 'commands', 'lib', 'ensure-target.js'));
 const { deployPrecheck } = require(path.join(SRC, 'commands', 'lib', 'deploy-precheck.js'));
 const cli = require(path.join(SRC, 'cli.js'));
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
 
-const package = Manager.getPackage('main');
+const package = build.getPackage('main');
 
 // A consumer whose peer deps are already satisfied — the steady state.
 function stageConsumer(dir) {

package/dist/test/suites/build/env-delivery.test.js

@@ -19,13 +19,13 @@ const { publishSecretKeys, bakeKeys, renderSecretsBlock, WORKFLOW_OWNED_KEYS } =
 const { composeTargetEnv } = require('../../../vendor/config/index.js');
 
 const SRC = path.join(__dirname, '..', '..', '..');
-const Manager = require(path.join(SRC, 'build.js'));
+const build = require(path.join(SRC, 'build.js'));
 const { ensureTarget } = require(path.join(SRC, 'commands', 'lib', 'ensure-target.js'));
 const bundleTask = require(path.join(SRC, 'gulp', 'tasks', 'bundle.js'));
 const { collectTargetSecrets } = require('../../../vendor/devkit/target-secrets.js');
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
 
-const package = Manager.getPackage('main');
+const package = build.getPackage('main');
 
 /** A consumer whose peer deps are already satisfied — the steady state. */
 function stageConsumer() {

package/dist/test/suites/build/esm-only-dependency.test.js

@@ -4,8 +4,8 @@
 // Both Node bundles are CommonJS (`format: 'cjs'`, `platform: 'node'`), and
 // esbuild rewrites `import.meta` to `{}` in that output: a dependency doing
 // `createRequire(import.meta.url)` was handed `undefined` and threw
-// ERR_INVALID_ARG_VALUE the moment a packaged app booted (found porting an
-// electron-manager app that depends on yargs 18). @omega.js/devkit's `bundle()`
+// ERR_INVALID_ARG_VALUE the moment a packaged app booted (an app that depends
+// on yargs 18 does exactly that). @omega.js/devkit's `bundle()`
 // composes the answer for every cjs+node build, so nothing here wires it.
 //
 // The proof is a RUN, not a read of the bundle text: the fixture package

package/dist/test/suites/build/exports.test.js

@@ -3,10 +3,10 @@
 const path = require('path');
 const fs = require('fs');
 
-const Manager = require('../../../build.js');
+const build = require('../../../build.js');
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
-const pkg = Manager.getPackage('main');
-const root = Manager.getRootPath('main');
+const pkg = build.getPackage('main');
+const root = build.getRootPath('main');
 
 module.exports = defineCases({
   type: 'group',
@@ -28,13 +28,14 @@ module.exports = defineCases({
       },
     },
     {
-      name: 'main / renderer / preload / build all loadable',
+      // main and preload load anywhere and export their instance; the renderer
+      // needs its preload's window.desktop, so omega.test.js loads it with one
+      name: 'main / preload / build all loadable',
       run: (ctx) => {
         const fromDist = (subpath) => path.join(root, 'dist', subpath);
-        ctx.expect(typeof require(fromDist('main.js'))).toBe('function');
-        ctx.expect(typeof require(fromDist('renderer.js'))).toBe('function');
-        ctx.expect(typeof require(fromDist('preload.js'))).toBe('function');
-        ctx.expect(typeof require(fromDist('build.js'))).toBe('function');
+        ctx.expect(typeof require(fromDist('main.js'))).toBe('object');
+        ctx.expect(typeof require(fromDist('preload.js'))).toBe('object');
+        ctx.expect(typeof require(fromDist('build.js'))).toBe('object');
       },
     },
     {

package/dist/test/suites/build/get-config.test.js

@@ -1,4 +1,4 @@
-// Build-layer tests for Manager.getConfig() — omega.json5 resolution + derived defaults.
+// Build-layer tests for build.getConfig() — omega.json5 resolution + derived defaults.
 // Stages a temp consumer dir with a config/omega.json5, sets process.cwd()
 // at it, and asserts the resolution + derivation rules.
 
@@ -43,8 +43,8 @@ function loadConfigInDir(dir) {
   }
   try {
     process.chdir(dir);
-    const Manager = require(path.join(__dirname, '..', '..', '..', 'build.js'));
-    return Manager.getConfig();
+    const build = require(path.join(__dirname, '..', '..', '..', 'build.js'));
+    return build.getConfig();
   } finally {
     process.chdir(oldCwd);
   }
@@ -53,7 +53,7 @@ function loadConfigInDir(dir) {
 module.exports = defineCases({
   type: 'suite',
   layer: 'build',
-  description: 'Manager.getConfig — omega.json5 resolution + derived defaults',
+  description: 'build.getConfig — omega.json5 resolution + derived defaults',
   tests: [
     {
       name: 'derives appId from the BRAND: reverse-domain of brand.url, else app.<brand.id> (friction #18)',

package/dist/test/suites/build/manifest-deps.test.js

@@ -24,7 +24,7 @@ const SOURCE_DIRS = ['lib', 'gulp'];
 // The two specifiers that are ALLOWED to be undeclared, each one required inside a
 // try/catch whose catch is the documented behaviour, not a crash:
 //   firebase        @omega.js/client's own dependency; the client bridge falls back
-//                   to no-op mode when it is not there (lib/client-bridge.js)
+//                   to no-op mode when it is not there (lib/auth.js)
 //   app-builder-bin electron-builder's own dependency; blockmap generation is
 //                   best-effort and warns-and-skips (lib/sign-helpers/update-info.js)
 const GUARDED = new Set(['firebase', 'app-builder-bin']);

package/dist/test/suites/build/merge-line-files.test.js

@@ -1,5 +1,5 @@
 // Build-layer tests for utils/merge-line-files.js — verify the .env / .gitignore merge convention
-// (BXM/UJM-style Default + Custom sections) AND the double-quote normalization for .env values.
+// (Default + Custom sections) AND the double-quote normalization for .env values.
 
 const path = require('path');
 const { mergeLineBasedFiles, normalizeEnvLine, DEFAULT_MARKER, CUSTOM_MARKER } =