@omega.js/desktop 0.50.0 → 0.51.0

package/dist/preload.js

@@ -3,6 +3,7 @@
 // Wires contextBridge so renderer code can call `window.desktop.ipc.invoke(...)` without nodeIntegration.
 
 const LoggerLite = require('./lib/logger-lite.js');
+const { ENVIRONMENT_VAR } = require('./vendor/config/environment.js');
 
 function Manager() {
   const self = this;
@@ -27,6 +28,13 @@ Manager.prototype.initialize = async function () {
   // Expose a stable, namespaced surface to the renderer.
   // Real impl in pass 2 will type the channel list and proxy storage through here.
   contextBridge.exposeInMainWorld('desktop', {
+    // The RUNNING environment, for the one context that cannot read it: a page has
+    // no `process`, so its Manager answers `OMEGA_BUILD_JSON.config.environment`,
+    // the word the BUILD was for. A test lane boots a production artifact with
+    // `OMEGA_ENVIRONMENT=testing`, so the two differ there, and a preload is Node
+    // ([#925](https://github.com/Omega-JS-Stack/omega/issues/925)). The renderer
+    // bootstrap applies this over the baked word, so it answers what main answers.
+    environment: process.env[ENVIRONMENT_VAR] || null,
     ipc: {
       invoke: (channel, payload) => ipcRenderer.invoke(channel, payload),
       // Returns an unsubscribe fn (docs/ipc.md contract — same shape as the

package/dist/renderer.js

@@ -1,6 +1,6 @@
 // Renderer-process Manager singleton.
 // Consumer entry (per view): `new (require('@omega.js/desktop/renderer'))().initialize()`.
-// Reads window.OMEGA_BUILD_JSON.config (injected by the bundle task's esbuild `define`), bootstraps @omega.js/client + auth.
+// Reads window.OMEGA_BUILD_JSON.config (the one dist/build.js the view's shell loads, #743), bootstraps @omega.js/client + auth.
 //
 // Auth bridge:
 //   - On init, asks main "I'm at UID X (or null), are we in sync?" via desktop:auth:sync-request.
@@ -32,11 +32,23 @@ Manager.prototype.initialize = async function (overrides) {
   const self = this;
 
   // Merge runtime overrides on top of build-time config.
-  // OMEGA_BUILD_JSON is injected by the bundle task's esbuild `define`; its `banner`
-  // also makes it available on globalThis.OMEGA_BUILD_JSON for DevTools introspection.
-  const buildJson = (typeof OMEGA_BUILD_JSON !== 'undefined' && OMEGA_BUILD_JSON) || {};
+  // OMEGA_BUILD_JSON comes off the window: the view's shell loads the ONE
+  // `dist/build.js` ahead of this bundle (#743), which is also what makes it
+  // readable from DevTools.
+  const buildJson = (typeof window !== 'undefined' && window.OMEGA_BUILD_JSON) || {};
   self.config = Object.assign({}, buildJson.config || {}, overrides || {});
 
+  // The RUNNING environment beats the baked one, exactly as it does in main
+  // ([#925](https://github.com/Omega-JS-Stack/omega/issues/925)). A page has no
+  // `process`, so `isTesting()` here reads `config.environment`, the word the
+  // BUILD was for; the preload does have it and hands it over on the bridge, so a
+  // test lane booting a production artifact gets the same answer in this renderer
+  // that main gives. No second signal: it is the one input, one context removed.
+  const runningEnvironment = (typeof window !== 'undefined' && window.desktop?.environment) || null;
+  if (runningEnvironment) {
+    self.config.environment = runningEnvironment;
+  }
+
   self.logger.log('Initializing @omega.js/desktop (renderer)...');
 
   // Boot @omega.js/client so Firebase Auth is available in this renderer.

package/dist/runner/job-started.js

@@ -0,0 +1,104 @@
+// The self-hosted signer's job-started hook
+// ([#875](https://github.com/Omega-JS-Stack/omega/issues/875)): the box refuses
+// any job that is not a trusted dispatch, before the job's first step runs.
+//
+// The runner runs this file through `ACTIONS_RUNNER_HOOK_JOB_STARTED`, an
+// absolute path in the runner's own `<runner dir>\.env`. A nonzero exit fails
+// the job with this script's output and NOTHING of the job runs: no checkout,
+// no install, and no signtool call against the EV token. GitHub documents the
+// hook at https://docs.github.com/en/actions/how-tos/manage-runners/self-hosted-runners/run-scripts
+// (the docs name `.sh` and `.ps1`; the runner ALSO handles `.js`, running it
+// with its OWN bundled node, per `GetDefaultShellForScript` in
+// `src/Runner.Common/HostContext.cs` of actions/runner v2.319.1, the version
+// `omega runner install` pins). So this is one plain Node file, no PowerShell,
+// and the unit suite runs it on any platform.
+//
+// The three checks, every one of which must pass:
+//   GITHUB_EVENT_NAME  the one trusted dispatch: `workflow_dispatch`
+//   GITHUB_REPOSITORY  listed in allowed-repos.txt
+//   GITHUB_ACTOR       listed in allowed-actors.txt
+// All three are the job's standard environment, exported to the hook by the
+// runner's `_contextEnvAllowlist` (`src/Runner.Worker/GitHubContext.cs`:
+// `actor`, `event_name`, `repository`).
+//
+// Node BUILTINS only, on purpose: this file is installed beside the runner, in
+// the runner home, where there is no `node_modules` to resolve `fs-jetpack`
+// from, and the runner's own node runs it, not the box's.
+const fs   = require('fs');
+const path = require('path');
+
+// ONE trusted event (#923): every publish path (`omega deploy`, a CMS button, a
+// plain HTTP call) dispatches `workflow_dispatch` at the deploy ref, and its
+// actor is the deploy token's user, the same account the box owner signs in as.
+const DISPATCH_EVENTS = ['workflow_dispatch'];
+
+const REPOS_FILE  = 'allowed-repos.txt';
+const ACTORS_FILE = 'allowed-actors.txt';
+
+// One entry per line, `#` comments and blank lines dropped. An unreadable file
+// reads as NO entries, which refuses every job: a guard that cannot read its
+// allow list allows nothing.
+function readList(file) {
+  let raw;
+  try {
+    raw = fs.readFileSync(file, 'utf8');
+  } catch (e) {
+    return [];
+  }
+  return raw.split(/\r?\n/)
+    .map((line) => line.replace(/#.*$/, '').trim())
+    .filter(Boolean);
+}
+
+// `owner/name`, or `owner/*` for every repo of one owner, which is the scope a
+// runner registration already has, and the line `omega runner install` writes.
+// Narrowing it to individual repos is an edit of the file, by hand.
+function repoMatches(repository, entry) {
+  const listed = entry.toLowerCase();
+  const seen   = String(repository || '').toLowerCase();
+  if (listed.endsWith('/*')) return seen.startsWith(listed.slice(0, -1));
+  return seen === listed;
+}
+
+// The verdict, as data: `{ allowed, line }`, one line whatever the answer, so
+// the caller below is only an exit code and a `console.log`.
+function checkJob(env, lists) {
+  const { repos = [], actors = [], reposFile = REPOS_FILE, actorsFile = ACTORS_FILE } = lists || {};
+  const event      = env.GITHUB_EVENT_NAME || '';
+  const repository = env.GITHUB_REPOSITORY || '';
+  const actor      = env.GITHUB_ACTOR || '';
+
+  if (!DISPATCH_EVENTS.includes(event)) {
+    return { allowed: false, line: `Refusing this job: GITHUB_EVENT_NAME is "${event}", and this runner serves ${DISPATCH_EVENTS.join(' and ')} only.` };
+  }
+  if (repos.length === 0) {
+    return { allowed: false, line: `Refusing this job: ${reposFile} lists no repository, so this runner allows none. Run \`npx omega runner install\` on the box, or add one \`owner/name\` per line.` };
+  }
+  if (!repos.some((entry) => repoMatches(repository, entry))) {
+    return { allowed: false, line: `Refusing this job: GITHUB_REPOSITORY is "${repository}", which is not listed in ${reposFile}.` };
+  }
+  if (actors.length === 0) {
+    return { allowed: false, line: `Refusing this job: ${actorsFile} lists no actor, so this runner allows none. Run \`npx omega runner install\` on the box, or add one login per line.` };
+  }
+  if (!actors.some((entry) => entry.toLowerCase() === actor.toLowerCase())) {
+    return { allowed: false, line: `Refusing this job: GITHUB_ACTOR is "${actor}", which is not listed in ${actorsFile}.` };
+  }
+
+  return { allowed: true, line: `Allowing this job: ${event} on ${repository} by ${actor}.` };
+}
+
+// The allow lists sit BESIDE this file, in the runner home the install writes
+// them to, so the hook needs no configuration of its own to find them.
+function loadLists(dir) {
+  const reposFile  = path.join(dir, REPOS_FILE);
+  const actorsFile = path.join(dir, ACTORS_FILE);
+  return { repos: readList(reposFile), actors: readList(actorsFile), reposFile, actorsFile };
+}
+
+if (require.main === module) {
+  const verdict = checkJob(process.env, loadLists(__dirname));
+  console.log(verdict.line);
+  process.exit(verdict.allowed ? 0 : 1);
+}
+
+module.exports = { checkJob, loadLists, readList, repoMatches, DISPATCH_EVENTS, REPOS_FILE, ACTORS_FILE };

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

@@ -6,6 +6,12 @@
   brand: {
     id: 'desktop-fixture',
     name: 'Desktop Fixture Consumer',
+    // The .deb target needs a homepage and a maintainer (#872): build-config
+    // refuses the config without them, so the fixture spells both.
+    url: 'https://desktop-fixture.test',
+    contact: {
+      email: 'support@desktop-fixture.test',
+    },
     images: {
       // Empty → build-config falls back to @omega.js/desktop's bundled default icon (no icon file shipped).
       icon: '',
@@ -27,6 +33,7 @@
   cloud: { provider: 'firebase', config: {} },
   targets: {
     desktop: {
+      type: 'desktop',
       startup: {
         mode: 'normal',
       },

package/dist/test/fixtures/consumer-app/package.json

@@ -7,7 +7,7 @@
   "devDependencies": {
     "@omega.js/desktop": "^0.1.0",
     "electron": ">=42",
-    "electron-builder": ">=26",
+    "electron-builder": ">=26.16.1",
     "gulp": "^5.0.1"
   }
 }

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

@@ -1,7 +1,13 @@
 // Minimal main-window renderer entry for the boot-layer self-test fixture.
 const Manager = require('@omega.js/desktop/renderer');
 
-new Manager().initialize();
+const manager = new Manager();
+manager.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
+// answer is given on.
+window.__omegaManager = manager;
 
 // #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

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

@@ -19,7 +19,8 @@ const { app, BrowserWindow, ipcMain } = require('electron');
 // 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
 // the app finishes launching), so flip the accessory policy here at require time.
-// This process is always a test run (runners/electron.js sets OMEGA_TEST_MODE), so
+// 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
 // activation along with visible windows.
 if (process.platform === 'darwin' && require('../../utils/test-stealth.js')()) {

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

@@ -67,10 +67,19 @@ try {
     ? require(process.env.OMEGA_TEST_RENDERER_MANAGER_PATH)
     : require('@omega.js/desktop/renderer');
   testManager = new RendererManager();
-  // Seed config so getApiUrl / getFunctionsUrl / getWebsiteUrl have something to
-  // read in their prod branches. Tests can mutate this via __emTestManager.config.set().
+  // Seed config the way a real BUILD bakes it, so the URL helpers have the same
+  // inputs here that they have in a shipped renderer. Tests can mutate this via
+  // __emTestManager.config.set().
+  //   `environment` is the build fact every OMEGA surface bakes
+  //   ([#817](https://github.com/Omega-JS-Stack/omega/issues/817)), which is
+  //   what a real renderer (no process.env) answers from.
+  //   `dev.ports` is the resolved local map, whose floor is @omega.js/config's
+  //   classic numbers ([#834](https://github.com/Omega-JS-Stack/omega/issues/834)):
+  //   nothing carries a browser-side copy of them any more, so an artifact
+  //   without the map cannot reach a localhost port at all.
   testManager.config = {
-    em:    { environment: 'production' },
+    environment: 'production',
+    dev:   { ports: { ...require('../../vendor/config/index.js').CLASSIC_PORTS } },
     brand: { url: 'https://example.com' },
     cloud: { provider: 'firebase', config: { projectId: 'demo-app', authDomain: 'demo-app.firebaseapp.com' } },
   };

package/dist/test/runners/boot.js

@@ -28,6 +28,13 @@ const chalk = require('chalk').default;
 const distSnapshot = require('../utils/dist-snapshot.js');
 const { renderEvent } = require('./render-event.js');
 
+// How long a booted app gets to say anything at all before the run is declared
+// failed. Generous: the app under test is the consumer's real one, cold.
+const DEFAULT_BOOT_TIMEOUT_MS = 60000;
+
+// How long the child gets to go down politely before SIGKILL.
+const KILL_GRACE_MS = 2000;
+
 async function runBootTests({ tests, suites, projectRoot, frameworkDistRoot }) {
   suites = suites || [];
 
@@ -148,7 +155,7 @@ async function bootProject({ tests, suites, effectiveRoot, frameworkDistRoot })
   //   OMEGA_TEST_BOOT_SPEC     — JSON file with the test definitions
   // Argv would be cleaner but Electron rejects unknown CLI flags.
   const childEnv = Object.assign({}, process.env, {
-    OMEGA_TEST_MODE:                  'true',   // canonical signal — manager.isTesting() picks it up
+    OMEGA_ENVIRONMENT:             'testing',   // the one environment input (#817): this lane names it
     OMEGA_TEST_BOOT:                  '1',      // boot-runner-specific dispatch marker (main.js reads this to load the harness instead of doing normal init)
     OMEGA_TEST_BOOT_HARNESS:          bootEntry,
     OMEGA_TEST_BOOT_SPEC:             specFile,
@@ -171,8 +178,27 @@ async function bootProject({ tests, suites, effectiveRoot, frameworkDistRoot })
   // @omega.js/desktop's main.js detects OMEGA_TEST_BOOT and `require()`s the boot harness itself after init.
   const args = [testApp.appRoot];
 
+  return runBootChild({ electronBin, args, childEnv, effectiveRoot, specFile, skipEvents, testCount });
+}
+
+// Spawn the booted app, render what its harness emits, and end the run.
+//
+// A boot that never produces harness output is a FAILED run with a report, never a
+// hung runner ([#907](https://github.com/Omega-JS-Stack/omega/issues/907)): the child
+// can block inside initialize(), long before main.js requires the harness, so the
+// per-test timeout in harness/boot-entry.js never gets the chance to fire. The report
+// quotes the last line of the booted app's runtime.log, which is the one clue about
+// where it stopped.
+//
+// The budget is IDLE time, never total run time: every harness line rearms it, so a
+// healthy suite that legitimately runs longer than the budget is left alone and only
+// SILENCE for a whole budget fails the run.
+//
+// `spawnFn`, `timeoutMs` and `killGraceMs` are the seams the build-layer suite drives
+// (suites/build/boot-runner-timeout.test.js), the way the deploy modules take an execFn.
+function runBootChild({ electronBin, args, childEnv, effectiveRoot, specFile, skipEvents, testCount, spawnFn = spawn, timeoutMs = bootTimeoutMs(), killGraceMs = KILL_GRACE_MS }) {
   return new Promise((resolve) => {
-    const child = spawn(electronBin, args, {
+    const child = spawnFn(electronBin, args, {
       cwd: effectiveRoot,
       env: childEnv,
       stdio: ['ignore', 'pipe', 'pipe'],
@@ -184,44 +210,108 @@ async function bootProject({ tests, suites, effectiveRoot, frameworkDistRoot })
     // Suites the module skipped whole: reported before the run they never join.
     skipEvents.forEach((evt) => renderEvent(evt, counts));
 
-    child.stdout.on('data', (chunk) => {
+    let timer = null;
+
+    // Rearmed by every harness line below, so the budget measures SILENCE.
+    function armBudget() {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        console.log(chalk.red(`    ✗ boot: no harness output after ${Math.round(timeoutMs / 1000)}s; last runtime.log line: "${lastRuntimeLogLine(effectiveRoot)}"`));
+        counts.failed += testCount;
+        // Detached BEFORE the counts are handed out: a line the child emits
+        // while it is being killed must not move numbers already reported.
+        cleanup();
+        endChild(child, killGraceMs);
+        resolve(counts);
+      }, timeoutMs);
+    }
+
+    function onStdout(chunk) {
       buffer += chunk.toString();
       let nl;
       while ((nl = buffer.indexOf('\n')) >= 0) {
         const line = buffer.slice(0, nl);
         buffer = buffer.slice(nl + 1);
         if (line.startsWith('__EM_TEST__')) {
+          armBudget();
           renderEvent(JSON.parse(line.slice('__EM_TEST__'.length)), counts);
         } else if (process.env.OMEGA_TEST_DEBUG && line.trim().length > 0) {
           process.stdout.write(chalk.gray(`      ${line}\n`));
         }
       }
-    });
+    }
 
-    child.stderr.on('data', (chunk) => {
+    function onStderr(chunk) {
       if (process.env.OMEGA_TEST_DEBUG) {
         process.stderr.write(chalk.gray(`[boot:stderr] ${chunk.toString()}`));
       }
-    });
+    }
 
-    child.on('error', (err) => {
+    function onError(err) {
       console.log(chalk.red(`    ✗ Failed to spawn boot harness: ${err.message}`));
       counts.failed += 1;
       cleanup();
       resolve(counts);
-    });
+    }
 
-    child.on('exit', () => {
+    function onExit() {
       cleanup();
       resolve(counts);
-    });
+    }
+
+    child.stdout.on('data', onStdout);
+    child.stderr.on('data', onStderr);
+    child.on('error', onError);
+    child.on('exit', onExit);
+
+    armBudget();
 
     function cleanup() {
+      clearTimeout(timer);
+      child.stdout.removeListener('data', onStdout);
+      child.stderr.removeListener('data', onStderr);
+      child.removeListener('error', onError);
+      child.removeListener('exit', onExit);
       try { fs.unlinkSync(specFile); } catch (_) { /* ignore */ }
     }
   });
 }
 
+// The boot budget, overridable with OMEGA_TEST_BOOT_TIMEOUT_MS the way
+// OMEGA_TEST_SKIP_BUILD opts out of the rebuild above.
+function bootTimeoutMs() {
+  const override = Number(process.env.OMEGA_TEST_BOOT_TIMEOUT_MS);
+  return Number.isFinite(override) && override > 0 ? override : DEFAULT_BOOT_TIMEOUT_MS;
+}
+
+// The last non-empty line of the booted app's runtime log: where a blocked boot got to.
+// A boot that died before the logger opened a file has none, which is itself the report.
+function lastRuntimeLogLine(effectiveRoot) {
+  let contents;
+  try {
+    contents = fs.readFileSync(path.join(effectiveRoot, 'logs', 'runtime.log'), 'utf8');
+  } catch (_) {
+    return '(no runtime.log)';
+  }
+
+  const lines = contents.split('\n');
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    if (lines[i].trim().length > 0) return lines[i].trim();
+  }
+  return '(runtime.log is empty)';
+}
+
+// End a child that outlived its budget. Polite first, then SIGKILL: the direct child
+// is the orphan the hang used to leave behind. The grace timer is unref'd so it never
+// holds the runner open on its own.
+function endChild(child, killGraceMs) {
+  try { child.kill(); } catch (_) { /* already gone */ }
+  const grace = setTimeout(() => {
+    try { child.kill('SIGKILL'); } catch (_) { /* already gone */ }
+  }, killGraceMs);
+  if (typeof grace.unref === 'function') grace.unref();
+}
+
 // Serialize the boot-bound renderer suites (`view: '<name>'`) for the spec file, the same
 // shape main-entry.js ships to the harness page (plus the view name). A suite the module
 // skipped whole runs nothing and reports its test count as skipped, exactly as the harness
@@ -411,4 +501,4 @@ function removeFixtureDeps(links) {
   }
 }
 
-module.exports = { runBootTests };
+module.exports = { runBootTests, runBootChild };

package/dist/test/runners/electron.js

@@ -36,7 +36,7 @@ function runElectronTests({ harnessEntry, suiteFiles, rendererSuiteFiles, filter
     }
 
     const childEnv = Object.assign({}, process.env, {
-      OMEGA_TEST_MODE:              'true',   // canonical signal — manager.isTesting() picks it up
+      OMEGA_ENVIRONMENT:          'testing', // the one environment input (#817): this lane names it
       ELECTRON_NO_ATTACH_CONSOLE: '1',
       NODE_OPTIONS:              '',
     });

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

@@ -95,5 +95,59 @@ module.exports = defineCases({
         expect(bundle.includes('data-shell-dismiss')).toBe(true);
       },
     },
+
+    {
+      // #925: the lane spawns this child with OMEGA_ENVIRONMENT=testing and the
+      // artifact it boots was BUILT production, so the booted app used to answer
+      // `production` and every isTesting() gate in it was silently off. The proof
+      // is a gate that writes to the log: auth persistence resolves to `none` in a
+      // test run alone, and that is the line the booted app records. (The emulator
+      // 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 }) => {
+        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
+
+        const log = fs.readFileSync(path.join(projectRoot, 'logs', 'runtime.log'), 'utf8');
+        expect(log.includes('auth persistence: none (test mode)')).toBe(true);
+      },
+    },
+
+    {
+      // #925: a page has no `process`, so its Manager 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 }) => {
+        const { BrowserWindow } = require('electron');
+
+        // The window is created in the consumer's initialize().then(), and its
+        // bootstrap sets the config a moment later; poll for both, the way the
+        // view test above polls for the window.
+        let answer = null;
+        let win = null;
+        for (let i = 0; i < 40; i++) {
+          win = manager.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',
+            );
+            if (answer) break;
+          }
+          await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+
+        const baked = await win.webContents.executeJavaScript('window.OMEGA_BUILD_JSON.config.environment');
+        const bridged = await win.webContents.executeJavaScript('window.desktop.environment');
+
+        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
+      },
+    },
   ],
 });

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

@@ -31,7 +31,7 @@ function stageConsumer(overrides = {}, desktopOverrides = {}) {
     brand: { id: 'testapp', name: 'TestApp', images: { icon: '' } },
     app:   { appId: 'com.test.app', productName: 'TestApp' },
   };
-  const merged = { ...baseConfig, ...overrides, targets: { desktop: desktopOverrides } };
+  const merged = { ...baseConfig, ...overrides, targets: { desktop: { type: 'desktop', ...desktopOverrides } } };
   jetpack.write(path.join(tmp, 'config', 'omega.json5'), JSON.stringify(merged));
 
   return tmp;
@@ -42,7 +42,12 @@ function runAudit(cwd, env = {}) {
     const origCwd = process.cwd();
     // Force build/publish env off — minimal scaffolds don't include icons/cert files.
     // Tests that want to exercise publish-mode checks pass env explicitly.
-    const baseEnv = { OMEGA_BUILD_MODE: '', OMEGA_IS_PUBLISH: '', OMEGA_IS_SERVER: '' };
+    // OMEGA_ENVIRONMENT is NAMED here, not blanked: it is the ONE environment
+    // input ([#817](https://github.com/Omega-JS-Stack/omega/issues/817)), every
+    // lane sets it, and an audit run is a dev-lane read. Naming it also keeps
+    // the value from leaking between cases, because src/build.js writes it at
+    // load from whichever lane flags were set when it was required.
+    const baseEnv = { OMEGA_ENVIRONMENT: 'development', OMEGA_BUILD_MODE: '', OMEGA_IS_PUBLISH: '', OMEGA_IS_SERVER: '' };
     const allEnv  = { ...baseEnv, ...env };
     const origEnv = {};
     for (const k of Object.keys(allEnv)) {
@@ -64,6 +69,22 @@ function runAudit(cwd, env = {}) {
   });
 }
 
+// The audit REPORTS through the logger, so a case that reads the report reads
+// the console the logger writes to (warnings on `warn`, the ok line on `log`).
+async function runAuditCapturing(cwd, env = {}) {
+  const lines = [];
+  const original = { log: console.log, warn: console.warn };
+  console.log = (...args) => lines.push(args.join(' '));
+  console.warn = (...args) => lines.push(args.join(' '));
+
+  try {
+    const err = await runAudit(cwd, env);
+    return { err, output: lines.join('\n') };
+  } finally {
+    Object.assign(console, original);
+  }
+}
+
 module.exports = defineCases({
   type: 'suite',
   layer: 'build',
@@ -81,6 +102,24 @@ module.exports = defineCases({
         }
       },
     },
+    {
+      // #911: the task took only `errors` off validateConfig, so a consumer
+      // read `audit ok (0 warnings)` while the validator's list named real
+      // findings (a key the schema does not declare, which is what a typo
+      // looks like). The report is both lists now.
+      name: 'prints the validator\'s warnings and counts them (#911)',
+      run: async (ctx) => {
+        const tmp = stageConsumer({ brand: { id: 'testapp', name: 'TestApp' } }, { notAKey: true });
+        try {
+          const { err, output } = await runAuditCapturing(tmp);
+          ctx.expect(err).toBeNull();
+          ctx.expect(output).toMatch(/notAKey/);
+          ctx.expect(output).toMatch(/audit ok \(1 warning\)/);
+        } finally {
+          fs.rmSync(tmp, { recursive: true, force: true });
+        }
+      },
+    },
     {
       name: 'fails when brand.id is missing',
       run: async (ctx) => {
@@ -121,10 +160,10 @@ module.exports = defineCases({
       },
     },
     {
-      name: 'publish mode: no releases.repo still passes, since the default names `<brand.id>-releases` (#799)',
+      name: 'publish mode: a bare `releases: {}` passes, since the repo derives as `<brand.id>-releases` (#799, #883)',
       run: async (ctx) => {
         const tmp = stageConsumer(
-          { brand: { id: 'acme', name: 'Acme', images: { icon: 'icon.png' } }, repo: { providers: { github: { org: 'Acme-Org' } } } },
+          { brand: { id: 'acme', name: 'Acme', images: { icon: 'icon.png' } }, repo: { provider: 'github', org: 'Acme-Org' } },
           { releases: {} },
         );
         jetpack.write(path.join(tmp, 'icon.png'), 'stub');
@@ -219,12 +258,12 @@ module.exports = defineCases({
       run: async (ctx) => {
         const tmp = stageConsumer(
           { brand: { id: 'testapp', name: 'TestApp' }, app: { appId: 'com.test.app', productName: 'TestApp' } },
-          { platforms: { win: { signing: { strategy: 'banana' } } } },
+          { platforms: { windows: { signing: { strategy: 'banana' } } } },
         );
         try {
           const err = await runAudit(tmp);
           ctx.expect(err).toBeDefined();
-          ctx.expect(err.message).toMatch(/platforms\.win\.signing\.strategy "banana" is not allowed/);
+          ctx.expect(err.message).toMatch(/platforms\.windows\.signing\.strategy "banana" is not allowed/);
         } finally {
           fs.rmSync(tmp, { recursive: true, force: true });
         }