@omega.js/desktop 0.52.0 → 0.54.0

package/dist/defaults/test/README.md

@@ -4,7 +4,7 @@ Drop your project test suites here. The framework auto-runs them alongside its o
 
 ## Layers
 
-Match the framework's four layers — OMEGA Desktop's test runner discovers files by the directory they sit in:
+Match the framework's four layers. OMEGA Desktop's test runner discovers files by the directory they sit in:
 
 | Directory | Runtime | Use for |
 |---|---|---|
@@ -17,19 +17,19 @@ A renderer suite that declares `view: '<name>'` runs against that view of YOUR a
 
 ## Coverage
 
-Every feature ships with tests at every layer it has a surface in — logic (`build`/`main`), UI (`renderer`), end-to-end (`boot`). Skip a layer only when the feature genuinely has no surface there; "the logic test covers it" does not excuse the UI test.
+Every feature ships with tests at every layer it has a surface in: logic (`build`/`main`), UI (`renderer`), end-to-end (`boot`). Skip a layer only when the feature genuinely has no surface there; "the logic test covers it" does not excuse the UI test.
 
 ## Quick example
 
 ```js
 // test/build/my-feature.test.js
-const Manager = require('@omega.js/desktop/build');
+const build = require('@omega.js/desktop/build');
 
 module.exports = {
   layer: 'build',
   description: 'the project config carries a brand id',
   run: (ctx) => {
-    ctx.expect(Manager.getConfig().brand.id).toBeTruthy();
+    ctx.expect(build.getConfig().brand.id).toBeTruthy();
   },
 };
 ```
@@ -38,4 +38,4 @@ That is the standalone form: one test per file. Every `run` receives `ctx`, whos
 
 ## See also
 
-`node_modules/@omega.js/desktop/docs/test-framework.md` — full reference for the test framework (layers, assert API, fixtures, runner internals).
+`node_modules/@omega.js/manager/docs/desktop/test-framework.md`: full reference for the test framework (layers, assert API, fixtures, runner internals).

package/dist/defaults/test/_init.js

@@ -1,6 +1,6 @@
 /**
  * Test lifecycle hook for this project. Runs once before any suite (not a test itself).
- * See @omega.js/desktop/docs/test-framework.md → "test/_init.js".
+ * See @omega.js/manager/docs/desktop/test-framework.md → "test/_init.js".
  */
 
 module.exports = ({ projectRoot }) => ({

package/dist/gulp/main.js

@@ -3,17 +3,17 @@
 delete process.env.ELECTRON_RUN_AS_NODE;
 
 // Libraries
-const Manager = new (require('../build.js'));
-const logger = Manager.logger('main');
-const argv = Manager.getArguments();
+const build = require('../build.js');
+const logger = build.logger('main');
+const argv = build.getArguments();
 const { series, parallel } = require('gulp');
 const path = require('path');
 const glob = require('glob').globSync;
 
 // Load packages
-const package = Manager.getPackage('main');
-const project = Manager.getPackage('project');
-const projectRoot = Manager.getRootPath('project');
+const package = build.getPackage('main');
+const project = build.getPackage('project');
+const projectRoot = build.getRootPath('project');
 
 // Resolve the .env cascade from the project root (shell > app > brand > company)
 // and derive the signing paths the brand's signing tree implies. gulp is its own
@@ -40,7 +40,7 @@ if (sanitizedSigningKeys.length) {
 const attachLogFile = require('../utils/attach-log-file.js');
 const logFileEnv = process.env.OMEGA_LOG_FILE;
 if (logFileEnv !== 'false' && logFileEnv !== '0') {
-  const defaultName = Manager.isBuildMode() ? 'build.log' : 'dev.log';
+  const defaultName = build.isBuildMode() ? 'build.log' : 'dev.log';
   const logPath = (logFileEnv && logFileEnv !== 'true') ? logFileEnv : path.join(projectRoot, 'logs', defaultName);
   attachLogFile(logPath);
   logger.log(`Logs tee'd to ${logPath}`);
@@ -54,7 +54,7 @@ logger.log('Starting...', argv);
 // Auto-load tasks from src/gulp/tasks/*.js
 const tasks = glob('*.js', { cwd: `${__dirname}/tasks` });
 
-// Globals (parity with BXM)
+// Globals (the same pair @omega.js/extension's gulp sets)
 global.tasks = {};
 global.websocket = null;
 
@@ -72,8 +72,7 @@ global.tasks = exports;
 const runConsumerHook = require('../utils/run-consumer-hook.js');
 function makeHookTask(name) {
   const fn = async () => {
-    const Manager = new (require('../build.js'));
-    await runConsumerHook(name, { manager: Manager, projectRoot: process.cwd(), mode: process.env.OMEGA_BUILD_MODE === 'true' ? 'production' : 'development' });
+    await runConsumerHook(name, { build, projectRoot: process.cwd(), mode: process.env.OMEGA_BUILD_MODE === 'true' ? 'production' : 'development' });
   };
   // Set displayName for nicer gulp logs.
   Object.defineProperty(fn, 'name', { value: `hook:${name.replace('/', ':')}` });

package/dist/gulp/tasks/audit.js

@@ -19,14 +19,14 @@
 
 const path    = require('path');
 const jetpack = require('fs-jetpack');
-const Manager = new (require('../../build.js'));
+const build = require('../../build.js');
 const { validateConfig, releasesRepo, hasOmegaConfig, loadConfig } = require('../../vendor/config/index.js');
 
-const logger = Manager.logger('audit');
+const logger = build.logger('audit');
 
 module.exports = function audit(done) {
   const cwd      = process.cwd();
-  const config   = Manager.getConfig();
+  const config   = build.getConfig();
   const errors   = [];
   const warnings = [];
 
@@ -38,18 +38,15 @@ module.exports = function audit(done) {
 
   // 1. Schema-driven config validation. Single source of truth in @omega.js/config
   // (shared schema + the desktop target refinements).
-  const { errors: schemaErrors } = validateConfig(config, { target: 'desktop' });
+  // build.getConfig() attaches `environment`, a build fact: the config is decorated
+  const { errors: schemaErrors } = validateConfig(config, { target: 'desktop', decorated: true });
   errors.push(...schemaErrors);
 
-  // ...and the validator's WARNINGS, which this task used to drop on the floor
-  // while reporting `0 warnings` ([#911](https://github.com/Omega-JS-Stack/omega/issues/911)).
-  // A key the schema does not declare is what a typo looks like, and the
-  // consumer has to see it at build time. They come off the LOAD, the same
-  // resolution `Manager.getConfig()` runs: loadConfig judges what the brand
-  // AUTHORED, before the loader fills its own resolved facts (`company.name`
-  // and friends) and before the build attaches `environment`.
+  // ...and the load's WARNINGS (an undeclared key is an ERROR, above). They
+  // come off the LOAD, the resolution `build.getConfig()` runs, which judges
+  // what the brand AUTHORED before the build attaches its own facts.
   const { warnings: configWarnings } = hasOmegaConfig(cwd)
-    ? loadConfig(cwd, 'desktop', { environment: Manager.getEnvironment() })
+    ? loadConfig(cwd, 'desktop', { environment: build.getEnvironment() })
     : { warnings: [] };
   warnings.push(...configWarnings);
 
@@ -57,14 +54,14 @@ module.exports = function audit(done) {
   // tied to the build pipeline, not the config shape).
   fileMustExist('src/main.js',    'src/main.js');
   fileMustExist('src/preload.js', 'src/preload.js');
-  if (Manager.isPublishMode() || Manager.isBuildMode()) {
+  if (build.isPublishMode() || build.isBuildMode()) {
     // Icon must exist when packaging — dev runs fine with the default Electron icon.
     fileMustExist(config.brand.images?.icon, 'config.brand.images.icon');
   }
   // Publishing needs an ADDRESS for the releases repo, and no repo name is ever
   // typed: @omega.js/config's releasesRepo derives `<brand.id>-releases` under
   // the brand's org, so only a missing org (or brand.id) leaves it unaddressable.
-  if (Manager.isPublishMode() && config.releases?.enabled !== false && !releasesRepo(config)) {
+  if (build.isPublishMode() && config.releases?.enabled !== false && !releasesRepo(config)) {
     errors.push('the releases repo is unaddressable: set repo.org and brand.id. The repo is always "<brand.id>-releases" under that org');
   }
 

package/dist/gulp/tasks/build-config.js

@@ -15,12 +15,12 @@ const path    = require('path');
 const jetpack = require('fs-jetpack');
 const yaml    = require('js-yaml');
 const { deepMerge, enabledFormats, desktopArtifactName, sanitizeProductName, releasesRepo } = require('../../vendor/config/index.js');
-const Manager = new (require('../../build.js'));
+const build = require('../../build.js');
 
 const { writeMacEntitlements } = require('../../lib/sign-helpers/entitlements.js');
 const { resolveAndCopy }       = require('../../lib/sign-helpers/resolve-icons.js');
 
-const logger = Manager.logger('build-config');
+const logger = build.logger('build-config');
 
 module.exports = function buildConfig(done) {
   Promise.resolve().then(async () => {
@@ -28,7 +28,7 @@ module.exports = function buildConfig(done) {
     const distRoot    = require('../../utils/dist-root.js')(projectRoot);
     const distPath    = path.join(distRoot, 'electron-builder.yml');
 
-    const config      = Manager.getConfig();
+    const config      = build.getConfig();
     const startupMode = config.startup?.mode || 'normal';
 
     // 1. Generate entitlements.mac.plist into dist/config/. Consumer overrides live at
@@ -51,7 +51,7 @@ module.exports = function buildConfig(done) {
     // (the cp142 rehearsal catch). The framework resolves the INSTALLED
     // electron from its own module context instead.
     try {
-      builderConfig.electronVersion = Manager.require('electron/package.json').version;
+      builderConfig.electronVersion = require('electron/package.json').version;
       logger.log(`electronVersion → ${builderConfig.electronVersion} (resolved from the installed electron)`);
     } catch (error) {
       logger.log('electronVersion not injected (electron unresolved) — electron-builder falls back to its own detection');
@@ -160,11 +160,11 @@ function expandYear(str) {
 // test assertions).
 function baseConfig(config, extras = {}) {
   // Seed `app` + `brand` so callers (including tests passing bare {}) can deref without
-  // optional-chaining at every site. Matches Manager.getConfig()'s own seeding.
+  // optional-chaining at every site. Matches build.getConfig()'s own seeding.
   config.app   = config.app   || {};
   config.brand = config.brand || {};
 
-  // Manager.getConfig() derives appId from the brand url/id; the literal here
+  // build.getConfig() derives appId from the brand url/id; the literal here
   // only backstops bare test configs. Copyright derives from the BRAND, never
   // a hardcoded company (friction #18).
   const appId       = config.app.appId       || 'app.omega.consumer';
@@ -444,13 +444,13 @@ function baseConfig(config, extras = {}) {
  *
  * @param {object} arch - The resolved per-platform arch lists (`{ mac, linux }`).
  * @param {object} [options]
- * @param {object} [options.mode] - The Manager's mode (`{ build, publish, … }`).
+ * @param {object} [options.mode] - The build module's mode (`{ build, publish, … }`).
  * @param {object} [options.logger] - Logger with `warn` (default: this task's).
  * @throws {Error} in build/publish mode, naming the offending config key.
  */
 function assertArchRules(arch, options) {
   options = options || {};
-  const mode = options.mode || Manager.getMode();
+  const mode = options.mode || build.getMode();
   const warn = (options.logger || logger).warn.bind(options.logger || logger);
 
   const violations = [];

package/dist/gulp/tasks/bundle.js

@@ -15,8 +15,8 @@
 // three entry shapes, the Electron platform/target pair, the externals, the
 // renderer's Node-builtin shim, and the OMEGA_BUILD_JSON bake.
 
-const Manager = new (require('../../build.js'));
-const logger = Manager.logger('bundle');
+const build = require('../../build.js');
+const logger = build.logger('bundle');
 const path = require('path');
 const glob = require('glob').globSync;
 const jetpack = require('fs-jetpack');
@@ -29,8 +29,8 @@ const buildJsonKit = require('../../vendor/devkit/build-json.js');
 const { emptyModulesPlugin } = require('../../vendor/devkit/empty-modules-plugin.js');
 const electronTargets = require('../../utils/electron-targets.js');
 
-const projectRoot   = Manager.getRootPath('project');
-const frameworkRoot = Manager.getRootPath();
+const projectRoot   = build.getRootPath('project');
+const frameworkRoot = build.getRootPath();
 const outputRoot    = require('../../utils/dist-root.js')(projectRoot);
 
 // The renderer runs with contextIsolation on: a browser-like environment with
@@ -73,7 +73,7 @@ function buildFacts({ pkg, mode, dev }) {
 }
 
 // The wrapper's `mode`, the same three keys on every OMEGA surface (#894).
-// Desktop's own `server` verdict stays inside the Manager, which is the only
+// Desktop's own `server` verdict stays inside the build module, which is the only
 // thing that reads it: an artifact records what it WAS BUILT as.
 function artifactMode(mode) {
   return { environment: mode.environment, build: mode.build, publish: mode.publish };
@@ -118,9 +118,9 @@ function composeClientBuildJson({ config, facts, pkg, mode, license }) {
 }
 
 module.exports = function bundleTask(done) {
-  const mode = Manager.getMode();
+  const mode = build.getMode();
   const isProd = mode.environment === 'production';
-  const config = Manager.getConfig();
+  const config = build.getConfig();
 
   // The renderer's @omega.js/client reads `config.dev` to reach the local
   // stack (N7). A renderer has no env and no filesystem walk of its own, so
@@ -149,7 +149,7 @@ module.exports = function bundleTask(done) {
   // license server (a key that cannot be answered for THROWS, which is what
   // gates a bad-key release); a dev build is keyless by definition and never
   // phones home. The answer is stamped into the build blob below.
-  const projectPackage = Manager.getPackage('project');
+  const projectPackage = build.getPackage('project');
   resolveLicenseStamp({ config, production: isProd })
     .then((license) => {
       // OMEGA_BUILD_JSON: frozen at build time. The NODE pair reads it as a
@@ -203,9 +203,9 @@ async function runBundles(buildJson, isProd) {
 
   // esbuild rejects with every error already formatted, so a failed build
   // surfaces through gulp's own callback rather than a hand-rolled reporter.
-  const results = await Promise.all(builds.map(async (build) => ({
-    name: build.name,
-    result: await bundle(build.options),
+  const results = await Promise.all(builds.map(async (entry) => ({
+    name: entry.name,
+    result: await bundle(entry.options),
   })));
 
   // The metafile is what the wrapper turns on for exactly this: what each
@@ -225,7 +225,7 @@ async function runBundles(buildJson, isProd) {
 // version they must compile for.
 function resolveTargets() {
   try {
-    return electronTargets(Manager.require('electron'), { logger });
+    return electronTargets(require('electron'), { logger });
   } catch (e) {
     logger.warn(`Could not resolve electron (${e.message}) — bundles compile with no syntax floor.`);
     return { node: null, chrome: null, electron: null };
@@ -300,13 +300,13 @@ const BAKED_SOURCE_KEYS = bakeSourceKeys('desktop');
  * @param {object} config - The target's resolved omega.json5 config.
  * @param {object} env - The build env.
  * @param {object} [options]
- * @param {object} [options.mode] - The Manager's mode (`{ build, publish, … }`).
+ * @param {object} [options.mode] - The build module's mode (`{ build, publish, … }`).
  * @param {object} [options.logger] - Logger with `warn` (default: this task's).
  * @throws {Error} in build/publish mode, naming every brand-level key and the config path that requires it.
  */
 function assertBakeRules(config, env, options) {
   options = options || {};
-  const mode = options.mode || Manager.getMode();
+  const mode = options.mode || build.getMode();
   const warn = (options.logger || logger).warn.bind(options.logger || logger);
 
   const violations = checkEnvRules(config, env, { target: 'desktop' })
@@ -469,7 +469,7 @@ function rendererBundle(shared) {
       format: 'iife',
       target: shared.targets.chrome,
       dev: shared.dev,
-      // Vendored core assets (#111) — mirrors the alias BXM/UJM use, so
+      // Vendored core assets (#111) — the same alias extension and web use, so
       // renderer code imports shared core modules by a stable name:
       //   import appShell from '__main_assets__/js/core/app-shell.js';
       alias: {
@@ -504,7 +504,7 @@ function nativeExternals() {
     'sqlite3',
   ];
 
-  const consumerPkg = Manager.getPackage('project');
+  const consumerPkg = build.getPackage('project');
   const declared = Object.assign({}, consumerPkg.dependencies || {}, consumerPkg.devDependencies || {});
 
   return Object.keys(declared).filter((name) => NATIVE.includes(name));

package/dist/gulp/tasks/defaults.js

@@ -7,13 +7,13 @@
 // tree, the locality warning. Idempotent and quiet: a converged target writes
 // nothing. The non-gulp verbs (`omega test`, `omega deploy`) call ensureTarget
 // themselves.
-const Manager = new (require('../../build.js'));
-const logger = Manager.logger('defaults');
+const build = require('../../build.js');
+const logger = build.logger('defaults');
 const { ensureTarget } = require('../../commands/lib/ensure-target.js');
 
 module.exports = async function defaults() {
   await ensureTarget({
-    projectDir: Manager.getRootPath('project'),
+    projectDir: build.getRootPath('project'),
     log: (line) => logger.log(line),
     warn: (line) => logger.warn(line),
   });

package/dist/gulp/tasks/distribute.js

@@ -1,6 +1,6 @@
 // STUB — stage consumer src/ + @omega.js/desktop dist/ into .desktop-build/ for the `bundle` task to consume.
-const Manager = new (require('../../build.js'));
-const logger = Manager.logger('distribute');
+const build = require('../../build.js');
+const logger = build.logger('distribute');
 
 module.exports = function distribute(done) {
   logger.log('distribute (stub)');

package/dist/gulp/tasks/html.js

@@ -4,7 +4,7 @@
 // Page template is FRAMEWORK-INTERNAL (`<framework>/dist/config/page-template.html`). Consumers don't ship
 // their own — every view goes through the same shell so the inset titlebar / draggable region /
 // css/js wiring stay consistent. If a consumer needs a different template they can fork via
-// `manager.windows` config, but we no longer look at `<consumer>/config/page-template.html`.
+// `omega.windows` config, but we no longer look at `<consumer>/config/page-template.html`.
 //
 // Body content is itself templated FIRST (so you can use {{ brand.name }} etc. inside the view),
 // then the result is injected into the page template's `{{ content }}` slot.
@@ -15,17 +15,17 @@
 // This lines up with the `bundle` task's entry naming so /assets/js/components/<page.name>.bundle.js
 // and /assets/css/components/<page.name>.bundle.css resolve correctly.
 
-const Manager = new (require('../../build.js'));
-const logger = Manager.logger('html');
+const build = require('../../build.js');
+const logger = build.logger('html');
 const path = require('path');
 const jetpack = require('fs-jetpack');
 
-const projectRoot = Manager.getRootPath('project');
-const packageRoot = Manager.getRootPath('main');
+const projectRoot = build.getRootPath('project');
+const packageRoot = build.getRootPath('main');
 const outputRoot  = require('../../utils/dist-root.js')(projectRoot);
 
-// We require the templating lib directly (rather than going through a Manager singleton)
-// because gulp tasks run pre-Electron, with only the build-time Manager available.
+// We require the templating lib directly (rather than going through the omega instance)
+// because gulp tasks run pre-Electron, with only the build module available.
 const templating = require('../../lib/templating.js');
 
 module.exports = function htmlTask(done) {
@@ -81,9 +81,9 @@ module.exports = function htmlTask(done) {
     const bodyContent = jetpack.read(src);
 
     // Two-pass render: first the body (so it can use {{ brand.name }} etc.), then the outer page.
-    const innerVars = templating.buildPageVars(pageName, { cacheBust }, Manager);
+    const innerVars = templating.buildPageVars(pageName, { cacheBust }, build);
     const renderedBody = templating.render(bodyContent, innerVars);
-    const outerVars = templating.buildPageVars(pageName, { cacheBust, content: renderedBody }, Manager);
+    const outerVars = templating.buildPageVars(pageName, { cacheBust, content: renderedBody }, build);
     const final = templating.render(pageTemplateContent, outerVars);
 
     const dest = path.join(outputRoot, 'views', rel);

package/dist/gulp/tasks/package-quick.js

@@ -15,9 +15,9 @@
 const path    = require('path');
 const jetpack = require('fs-jetpack');
 const yaml    = require('js-yaml');
-const Manager = new (require('../../build.js'));
+const build = require('../../build.js');
 
-const logger = Manager.logger('package-quick');
+const logger = build.logger('package-quick');
 
 module.exports = function packageQuick(done) {
   const projectRoot = process.cwd();
@@ -29,7 +29,7 @@ module.exports = function packageQuick(done) {
 
   let builder;
   try {
-    builder = Manager.require('electron-builder');
+    builder = require('electron-builder');
   } catch (e) {
     return done(new Error(`Could not resolve electron-builder: ${e.message}`));
   }

package/dist/gulp/tasks/package.js

@@ -10,9 +10,9 @@
 
 const path    = require('path');
 const jetpack = require('fs-jetpack');
-const Manager = new (require('../../build.js'));
+const build = require('../../build.js');
 
-const logger = Manager.logger('package');
+const logger = build.logger('package');
 
 module.exports = function packageApp(done) {
   const projectRoot = process.cwd();
@@ -25,7 +25,7 @@ module.exports = function packageApp(done) {
   // Resolve electron-builder from the consumer's node_modules first, then @omega.js/desktop's bundled one.
   let builder;
   try {
-    builder = Manager.require('electron-builder');
+    builder = require('electron-builder');
   } catch (e) {
     return done(new Error(`Could not resolve electron-builder: ${e.message}. Run \`npm i -D electron-builder\` in the consumer.`));
   }

package/dist/gulp/tasks/release.js

@@ -14,9 +14,9 @@
 
 const path    = require('path');
 const jetpack = require('fs-jetpack');
-const Manager = new (require('../../build.js'));
+const build = require('../../build.js');
 
-const logger = Manager.logger('release');
+const logger = build.logger('release');
 
 // The two warnings electron-publish prints when it uploads nothing: one per
 // release (`gitHubPublisher.getOrCreateRelease` returns null with its reason)
@@ -37,7 +37,7 @@ module.exports = function release(done) {
 
   let builder;
   try {
-    builder = Manager.require('electron-builder');
+    builder = require('electron-builder');
   } catch (e) {
     return done(new Error(`Could not resolve electron-builder: ${e.message}. Run \`npm i -D electron-builder\` in the consumer.`));
   }

package/dist/gulp/tasks/sass.js

@@ -10,21 +10,21 @@
 //   - <output-root>/assets/scss              → resolves bare 'brand' to the generated _brand.scss (#912)
 //   - <consumer>/src/assets/scss             → consumer's own modules
 
-const Manager = new (require('../../build.js'));
-const logger = Manager.logger('sass');
+const build = require('../../build.js');
+const logger = build.logger('sass');
 const path = require('path');
 const jetpack = require('fs-jetpack');
 const sass = require('sass');
 const { formatBytes } = require('../../vendor/devkit/bundle.js');
 const { composeBrandTokens, renderBrandScss } = require('../../vendor/devkit/brand-tokens.js');
 
-const projectRoot = Manager.getRootPath('project');
-const packageRoot = Manager.getRootPath('main');
+const projectRoot = build.getRootPath('project');
+const packageRoot = build.getRootPath('main');
 const outputRoot  = require('../../utils/dist-root.js')(projectRoot);
 
 module.exports = function sassTask(done) {
-  const isProd = Manager.getMode().environment === 'production';
-  const config = Manager.getConfig() || {};
+  const isProd = build.getMode().environment === 'production';
+  const config = build.getConfig() || {};
   const themeId = config.theme?.id || 'classy';
 
   // The brand partial ([#912](https://github.com/Omega-JS-Stack/omega/issues/912)):

package/dist/gulp/tasks/serve.js

@@ -4,12 +4,12 @@
 // Future passes will add: livereload websocket, watch + rebuild, renderer reload via webContents.reload(),
 // main reload via app.relaunch().
 
-const Manager = new (require('../../build.js'));
-const logger = Manager.logger('serve');
+const build = require('../../build.js');
+const logger = build.logger('serve');
 const { spawn } = require('child_process');
 const { watchEnvChain } = require('../../vendor/devkit/env-watch.js');
 
-const projectRoot = Manager.getRootPath('project');
+const projectRoot = build.getRootPath('project');
 
 module.exports = function serve(done) {
   // N7: resolve livereload (and CDP when requested) through the allocator —
@@ -22,7 +22,7 @@ module.exports = function serve(done) {
 
 async function resolveServePorts() {
   const { resolvePorts, envPort, CLASSIC_PORTS } = require('../../vendor/config/index.js');
-  const configPins = Manager.getConfig()?.ports || {};
+  const configPins = build.getConfig()?.ports || {};
 
   const wanted = { livereload: envPort('livereload') || CLASSIC_PORTS.livereload };
   const pins = {};

package/dist/hooks/notarize-artifacts.js

@@ -17,7 +17,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const Logger = require('../lib/logger');
+const Logger = require('../vendor/devkit/logger.js');
 const { submit, stapleAndProve, toolRunner } = require('./lib/notarize-tools.js');
 
 const logger = new Logger('notarize-artifacts');

package/dist/hooks/notarize.js

@@ -29,7 +29,7 @@
 const path = require('path');
 const fs   = require('fs');
 const { execute } = require('node-powertools');
-const Logger = require('../lib/logger');
+const Logger = require('../vendor/devkit/logger.js');
 const { stapleAndProve, toolRunner } = require('./lib/notarize-tools.js');
 
 const logger = new Logger('notarize');

package/dist/index.js

@@ -1,14 +1,11 @@
-// Default export — re-exports per-process Managers + version.
-// Most consumers should use the per-process subpath imports instead:
+// Default export: the build-time entry (version + the build module). Each Electron
+// process imports its own ready-made instance from its subpath instead:
 //   require('@omega.js/desktop/main')
-//   require('@omega.js/desktop/renderer')
+//   import omega from '@omega.js/desktop/renderer'
 //   require('@omega.js/desktop/preload')
 const package = require('../package.json');
 
 module.exports = {
-  version:  package.version,
-  Main:     require('./main.js'),
-  Renderer: require('./renderer.js'),
-  Preload:  require('./preload.js'),
-  Build:    require('./build.js'),
+  version: package.version,
+  build:   require('./build.js'),
 };

package/dist/lib/_environment-mixin.js

@@ -0,0 +1,50 @@
+// The main process's environment and backend-URL surface: methods mixed into
+// the `Omega` class (src/main.js) with `Object.assign(Omega.prototype, ...)`, so
+// they stay `omega.getEnvironment()`, `omega.getApiUrl()`, ... on the instance.
+
+const { getEnvironment, isDevelopment, isProduction, isTesting, getVersion } = require('../utils/mode-helpers.js');
+const { getFunctionsUrl, getApiUrl, getWebsiteUrl, getAuthUrl } = require('../utils/url-helpers.js');
+
+module.exports = {
+  // The environment surface (#817): @omega.js/config's ONE implementation,
+  // reading the process's OMEGA_ENVIRONMENT, then this instance's baked
+  // `config.environment`
+  getEnvironment() {
+    return getEnvironment.call(this);
+  },
+
+  isDevelopment() {
+    return isDevelopment.call(this);
+  },
+
+  isProduction() {
+    return isProduction.call(this);
+  },
+
+  isTesting() {
+    return isTesting.call(this);
+  },
+
+  getVersion() {
+    return getVersion();
+  },
+
+  // The backend URL helpers (utils/url-helpers.js): local in development and
+  // testing, the brand's hosts in production. `environment` overrides the
+  // running one.
+  getFunctionsUrl(environment) {
+    return getFunctionsUrl(this, environment);
+  },
+
+  getApiUrl(environment) {
+    return getApiUrl(this, environment);
+  },
+
+  getWebsiteUrl(environment) {
+    return getWebsiteUrl(this, environment);
+  },
+
+  getAuthUrl(environment, returnUrl) {
+    return getAuthUrl(this, environment, returnUrl);
+  },
+};