@omega.js/extension 0.1.0

package/dist/test/suites/boot/extension-loads.test.js

@@ -0,0 +1,58 @@
+// Boot-layer test — verifies Chromium can load BXM's fixture consumer
+// extension as unpacked, the manifest validates, the SW comes up, and the
+// popup renders end-to-end. This is the integration equivalent to "did the
+// real consumer extension start without throwing".
+//
+// In BXM's own test run, OMEGA_TEST_BOOT_PROJECT points at the fixture under
+// src/test/fixtures/consumer-extension. In a real consumer's `npx omega test`
+// run, the env var is unset and boot tests target the consumer's own
+// `<cwd>/dist/`.
+
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  type: 'group',
+  layer: 'boot',
+  description: 'fixture consumer — extension loads + boots',
+  tests: [
+    {
+      description: 'extension has a valid ID and MV3 manifest',
+      inspect: async ({ extension, expect }) => {
+        expect(extension.id).toMatch(/^[a-z]{32}$/);
+        expect(extension.manifest.manifest_version).toBe(3);
+        expect(extension.manifest.name).toBe('BXM Fixture Consumer');
+      },
+    },
+    {
+      description: 'manifest exposes a popup URL',
+      inspect: async ({ extension, expect }) => {
+        expect(extension.popupUrl).toMatch(/^chrome-extension:\/\/[a-z]{32}\/popup\.html$/);
+      },
+    },
+    {
+      description: 'service worker target was discovered',
+      inspect: async ({ extension, expect }) => {
+        expect(extension.swTarget).not.toBeNull();
+        expect(extension.swTarget.type()).toBe('service_worker');
+      },
+    },
+    {
+      description: 'popup.html renders with the expected #main-content element',
+      inspect: async ({ extension, page, expect }) => {
+        await page.goto(extension.popupUrl, { waitUntil: 'domcontentloaded' });
+        const text = await page.$eval('#main-content', (el) => el.textContent);
+        expect(text).toContain('Fixture Popup');
+      },
+    },
+    {
+      description: 'background SW responded to a probe message',
+      inspect: async ({ extension, page, expect }) => {
+        // Open any page that has chrome.runtime access — popup works.
+        await page.goto(extension.popupUrl, { waitUntil: 'domcontentloaded' });
+        const reply = await page.evaluate(() => chrome.runtime.sendMessage({ type: 'fixture:hello' }));
+        expect(reply.ok).toBe(true);
+        expect(reply.version).toBe('0.1.0');
+      },
+    },
+  ],
+});

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

@@ -0,0 +1,64 @@
+// Build-layer tests for lib/affiliatizer.js — exercises the pure map data structure
+// (the bulk of its high-value, currently-untested code). `Affiliatizer.initialize()`
+// touches `window.location` / `chrome.storage` and requires a browser context — not
+// testable at this layer. The regex map IS testable: deterministic, no IO, no globals.
+
+const path = require('path');
+
+const Affiliatizer = require(path.join(__dirname, '..', '..', '..', 'lib', 'affiliatizer.js'));
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'build',
+  description: 'lib/affiliatizer — URL-match map',
+  tests: [
+    {
+      name: 'get() returns an array of entries',
+      run: (ctx) => {
+        const map = Affiliatizer.get();
+        ctx.expect(Array.isArray(map)).toBe(true);
+        ctx.expect(map.length).toBeGreaterThan(0);
+      },
+    },
+    {
+      name: 'every entry has { id, match, replace }',
+      run: (ctx) => {
+        for (const entry of Affiliatizer.get()) {
+          ctx.expect(typeof entry.id).toBe('string');
+          ctx.expect(entry.match).toBeInstanceOf(RegExp);
+          ctx.expect(typeof entry.replace).toBe('object');
+        }
+      },
+    },
+    {
+      name: 'entry ids are unique',
+      run: (ctx) => {
+        const ids = Affiliatizer.get().map((e) => e.id);
+        const set = new Set(ids);
+        ctx.expect(set.size).toBe(ids.length);
+      },
+    },
+    {
+      name: 'amazon regex matches amazon.com hostnames',
+      run: (ctx) => {
+        const amazon = Affiliatizer.get().find((e) => e.id === 'amazon');
+        ctx.expect(amazon).toBeDefined();
+        ctx.expect(amazon.match.test('www.amazon.com')).toBe(true);
+        ctx.expect(amazon.match.test('smile.amazon.com')).toBe(true);
+        ctx.expect(amazon.match.test('example.com')).toBe(false);
+      },
+    },
+    {
+      name: 'every entry that has replace.href has a valid URL',
+      run: (ctx) => {
+        for (const entry of Affiliatizer.get()) {
+          if (!entry.replace.href) continue;
+          let threw = false;
+          try { new URL(entry.replace.href); } catch (_) { threw = true; }
+          ctx.expect(threw).toBe(false);
+        }
+      },
+    },
+  ],
+});

package/dist/test/suites/build/app-launch.test.js

@@ -0,0 +1,65 @@
+// Which extension contexts count as a LAUNCH
+// ([#386](https://github.com/Omega-JS-Stack/omega/issues/386), stage E of
+// [#328](https://github.com/Omega-JS-Stack/omega/issues/328) — inventory gap 7:
+// the extension counted nothing about itself).
+//
+// Three of the four client contexts fire `app_launch`: the toolbar popup, the
+// injected page, and the side panel. The OPTIONS page does not — opening
+// settings is maintenance, not a launch, and counting it would inflate the
+// number with visits that are not sessions with the product (Ian's ruling).
+//
+// Static, on the SOURCE: the fire is one call in each context's initialize(),
+// and there is no cheaper way to prove a context does not make it than reading
+// the file the bundle is built from.
+
+const fs = require('fs');
+const path = require('path');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+const SRC = path.join(__dirname, '..', '..', '..');
+
+/** One context's source, with comments blanked — only what RUNS counts. */
+function contextSource(name) {
+  return fs.readFileSync(path.join(SRC, `${name}.js`), 'utf8')
+    .replace(/\/\*[\s\S]*?\*\//g, (block) => block.replace(/[^\n]/g, ' '))
+    .replace(/(^|[^:])\/\/.*$/gm, (match, before) => before + ' '.repeat(match.length - before.length));
+}
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'build',
+  description: 'app_launch — the contexts that count as a launch',
+  tests: [
+    {
+      name: 'the popup, the page and the side panel each fire app_launch once',
+      run: (ctx) => {
+        for (const name of ['popup', 'page', 'sidepanel']) {
+          const source = contextSource(name);
+          const fires = source.match(/trackAppLaunch\(\)/g) || [];
+
+          ctx.expect(fires.length).toBe(1);
+          ctx.expect(source.includes("from './lib/analytics.js'")).toBe(true);
+        }
+      },
+    },
+    {
+      name: 'the options page fires nothing — settings is not a launch',
+      run: (ctx) => {
+        const source = contextSource('options');
+
+        ctx.expect(source.includes('trackAppLaunch')).toBe(false);
+        ctx.expect(source.includes('./lib/analytics.js')).toBe(false);
+      },
+    },
+    {
+      name: 'the launch helper speaks the CANONICAL event, and never throws at a boot',
+      run: (ctx) => {
+        const helper = fs.readFileSync(path.join(SRC, 'lib', 'analytics.js'), 'utf8');
+
+        // The catalog name, through the shared client — no provider, no dialect.
+        ctx.expect(helper.includes("omega.analytics().event('app_launch')")).toBe(true);
+        ctx.expect(helper.includes('try {')).toBe(true);
+      },
+    },
+  ],
+});

package/dist/test/suites/build/attach-log-file.test.js

@@ -0,0 +1,99 @@
+// Build-layer tests for src/utils/attach-log-file.js — the vendored shim over
+// @omega.js/devkit/attach-log-file. Each test attaches, writes, detaches, then
+// inspects the file. The tee's own contract (both sinks, truncation, crash
+// tails, CI skip) is pinned in devkit; this suite pins that the shim the
+// framework's verbs require IS that tee, through the framework's own paths.
+//
+// CRITICAL: these tests run INSIDE a live `npx omega test` process whose own output is being
+// teed to logs/test.log by the singleton. So they must NOT touch the singleton — exercising
+// attach()/detach() on it would detach the live tee mid-run and truncate logs/test.log. Each
+// test uses its OWN `createTee()` instance, which stacks under the live singleton tee and
+// restores it cleanly on detach.
+//
+// Every attach passes an explicit `env` so the tee's CI skip is never what a
+// green run depends on — the suite behaves the same on a laptop and a runner.
+
+const path = require('path');
+const fs   = require('fs');
+const os   = require('os');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+const NO_CI = { env: {} };
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'build',
+  description: 'attach-log-file — tee stdout/stderr to a file',
+  tests: [
+    {
+      name: 'exports the expected surface',
+      run: (ctx) => {
+        const mod = require(path.join(__dirname, '..', '..', '..', 'utils', 'attach-log-file.js'));
+        ctx.expect(typeof mod).toBe('function');
+        ctx.expect(typeof mod.detach).toBe('function');
+        ctx.expect(typeof mod.stripAnsi).toBe('function');
+        ctx.expect(typeof mod.createTee).toBe('function');
+      },
+    },
+    {
+      name: 'stripAnsi removes color escape codes',
+      run: (ctx) => {
+        const { stripAnsi } = require(path.join(__dirname, '..', '..', '..', 'utils', 'attach-log-file.js'));
+        const colored = '\x1B[31mred\x1B[0m and \x1B[32mgreen\x1B[0m';
+        ctx.expect(stripAnsi(colored)).toBe('red and green');
+      },
+    },
+    {
+      name: 'attach + stdout.write + detach: file contains the writes, ANSI stripped',
+      run: (ctx) => {
+        const attach = require(path.join(__dirname, '..', '..', '..', 'utils', 'attach-log-file.js'));
+        // Isolated instance — stacks under the live test.log tee, never clobbers it.
+        const tee = attach.createTee();
+        const tmpPath = path.join(os.tmpdir(), `extension-log-${Date.now()}.log`);
+        try {
+          // attach() returns the DETACH function; the writes themselves are
+          // synchronous fd writes, so there is nothing to flush before reading.
+          const detach = tee.attach(tmpPath, NO_CI);
+          process.stdout.write('hello world\n');
+          process.stdout.write('\x1B[31mcolored\x1B[0m line\n');
+          detach();
+
+          const contents = fs.readFileSync(tmpPath, 'utf8');
+          ctx.expect(contents).toContain('hello world');
+          ctx.expect(contents).toContain('colored line');
+          ctx.expect(contents).not.toContain('\x1B[');
+        } finally {
+          tee.detach();
+          try { fs.unlinkSync(tmpPath); } catch (e) {}
+        }
+      },
+    },
+    {
+      name: 'idempotent: attaching twice with the same path returns the same detach',
+      run: (ctx) => {
+        const attach = require(path.join(__dirname, '..', '..', '..', 'utils', 'attach-log-file.js'));
+        const tee = attach.createTee();
+        const tmpPath = path.join(os.tmpdir(), `extension-log-idem-${Date.now()}.log`);
+        try {
+          const d1 = tee.attach(tmpPath, NO_CI);
+          const d2 = tee.attach(tmpPath, NO_CI);
+          ctx.expect(d1).toBe(d2);
+        } finally {
+          tee.detach();
+          try { fs.unlinkSync(tmpPath); } catch (e) {}
+        }
+      },
+    },
+    {
+      name: 'attach with falsy path returns a no-op detach and patches nothing',
+      run: (ctx) => {
+        const attach = require(path.join(__dirname, '..', '..', '..', 'utils', 'attach-log-file.js'));
+        const tee = attach.createTee();
+        const priorWrite = process.stdout.write;
+        ctx.expect(typeof tee.attach(null, NO_CI)).toBe('function');
+        ctx.expect(typeof tee.attach('', NO_CI)).toBe('function');
+        ctx.expect(process.stdout.write).toBe(priorWrite);
+      },
+    },
+  ],
+});

package/dist/test/suites/build/auth-emulator-gate.test.js

@@ -0,0 +1,118 @@
+// Build-layer pin for the background SW's auth-emulator gate (#46).
+//
+// The SW connects Firebase Auth to the local emulator ONLY on a testing build.
+// Its whole signal is what the bundle task BAKED into OMEGA_BUILD_JSON: a
+// service worker has no `process.env`, so `Manager.isTesting()` resolves from
+// `config.omega.environment` (mode-helpers step 1). This suite drives that for
+// real — the actual composeBuildJson under each build mode, feeding the actual
+// snapshot into the actual mode-helpers — and then pins that the emulator call
+// sits behind exactly that check. background.js itself is a browser-context ES
+// module, so the call site is pinned by source, same model as
+// cache-warming.test.js / verts-binding.test.js.
+//
+// In a real SW `chrome.runtime.getManifest()` also answers (packed → production,
+// unpacked → development); testing still wins because the config check comes first.
+
+const path = require('path');
+const fs   = require('fs');
+const os   = require('os');
+
+const SRC       = path.join(__dirname, '..', '..', '..');
+const TASK_PATH = path.join(SRC, 'gulp', 'tasks', 'bundle.js');
+const helpers   = require(path.join(SRC, 'utils', 'mode-helpers.js'));
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+const BACKGROUND = fs.readFileSync(path.join(SRC, 'background.js'), 'utf8');
+
+// Compose a real snapshot under the given build mode and hand back its `config`
+// blob — exactly what the SW reads out of OMEGA_BUILD_JSON.
+async function bakeConfig(mode) {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'extension-emulator-gate-'));
+  fs.writeFileSync(path.join(tmp, 'package.json'), `{ "name": "gate-ext", "version": "1.0.0" }`);
+
+  const oldCwd = process.cwd();
+  const env = { OMEGA_TEST_MODE: null, OMEGA_BUILD_MODE: null, NODE_ENV: null };
+  if (mode === 'testing')    env.OMEGA_TEST_MODE  = 'true';
+  if (mode === 'production') env.OMEGA_BUILD_MODE = 'true';
+
+  const originals = {};
+  for (const [k, v] of Object.entries(env)) {
+    originals[k] = process.env[k];
+    if (v === null) delete process.env[k]; else process.env[k] = v;
+  }
+  for (const key of Object.keys(require.cache)) {
+    if (key.startsWith(SRC + path.sep)) delete require.cache[key];
+  }
+
+  try {
+    process.chdir(tmp);
+    return (await require(TASK_PATH).composeBuildJson()).config;
+  } finally {
+    process.chdir(oldCwd);
+    for (const [k, v] of Object.entries(originals)) {
+      if (v === undefined) delete process.env[k]; else process.env[k] = v;
+    }
+    for (const key of Object.keys(require.cache)) {
+      if (key.startsWith(SRC + path.sep)) delete require.cache[key];
+    }
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+// The SW's own resolution: no process.env, config-baked signals only.
+function isTestingInServiceWorker(config) {
+  const originals = {};
+  for (const k of ['OMEGA_TEST_MODE', 'OMEGA_BUILD_MODE', 'NODE_ENV']) {
+    originals[k] = process.env[k];
+    delete process.env[k];
+  }
+  try {
+    return helpers.isTesting.call({ config });
+  } finally {
+    for (const [k, v] of Object.entries(originals)) {
+      if (v !== undefined) process.env[k] = v;
+    }
+  }
+}
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'build',
+  description: 'background auth-emulator gate — testing builds only',
+  tests: [
+    {
+      name: 'a testing build bakes environment=testing and the SW resolves isTesting() true',
+      run: async (ctx) => {
+        const config = await bakeConfig('testing');
+        ctx.expect(config.omega.environment).toBe('testing');
+        ctx.expect(isTestingInServiceWorker(config)).toBe(true);
+      },
+    },
+    {
+      name: 'a production build never trips the gate',
+      run: async (ctx) => {
+        const config = await bakeConfig('production');
+        ctx.expect(config.omega.environment).toBe('production');
+        ctx.expect(isTestingInServiceWorker(config)).toBe(false);
+      },
+    },
+    {
+      name: 'a dev build never trips the gate',
+      run: async (ctx) => {
+        const config = await bakeConfig('development');
+        ctx.expect(config.omega.environment).toBe('development');
+        ctx.expect(isTestingInServiceWorker(config)).toBe(false);
+      },
+    },
+    {
+      name: 'the SW calls connectAuthEmulator once, only inside the isTesting() gate',
+      run: (ctx) => {
+        const calls = BACKGROUND.match(/connectAuthEmulator\(/g) || [];
+        ctx.expect(calls.length).toBe(1);
+        ctx.expect(/if \(this\.isTesting\(\)\) \{\s*const port = this\.config\?\.dev\?\.ports\?\.auth \|\| AUTH_EMULATOR_PORT;\s*this\.authLogger\.log\([^\n]*\);\s*connectAuthEmulator\(this\.libraries\.firebaseAuth, `http:\/\/localhost:\$\{port\}`/.test(BACKGROUND)).toBe(true);
+        // The baked map first (#300 — a SW can't read a bumped OMEGA_AUTH_PORT,
+        // so the bake carries it), the classic port as the fallback
+        ctx.expect(BACKGROUND).toMatch(/const AUTH_EMULATOR_PORT = 9099;/);
+      },
+    },
+  ],
+});

package/dist/test/suites/build/auth-triggers.test.js

@@ -0,0 +1,71 @@
+// Build-layer pin for the extension's click-trigger wiring (#16).
+//
+// `omega-signin` and `omega-account` are the extension's OWN triggers (only an
+// extension opens a brand page in a tab), registered on @omega.js/client's shared
+// registry instead of the delegated `document` click listener auth-helpers used
+// to roll itself. auth-helpers.js is a browser-context ES module (it imports the
+// client by bare specifier), so the wiring is pinned by SOURCE — the same model
+// as global-handlers / cache-warming / verts-binding.
+//
+// The whole class of regression is covered, not just the rename: a legacy class
+// name anywhere in the source, or a hand-rolled listener coming back, both fail.
+
+const path = require('path');
+const fs = require('fs');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+const SRC = path.join(__dirname, '..', '..', '..');
+const AUTH_HELPERS = fs.readFileSync(path.join(SRC, 'lib', 'auth-helpers.js'), 'utf8');
+const LEGACY_CLASSES = ['auth-signin-btn', 'auth-signout-btn', 'uj-password-toggle'];
+
+module.exports = defineCases({
+  type: 'group',
+  layer: 'build',
+  description: 'click triggers: omega-signin / omega-account ride the shared registry (#16, #122)',
+  tests: [
+    {
+      name: 'setupAuthEventListeners registers the `signin` trigger, no hand-rolled listener',
+      run: (ctx) => {
+        ctx.expect(AUTH_HELPERS.includes("import { registerTrigger } from '@omega.js/client/modules/triggers.js'")).toBe(true);
+
+        const fnSource = AUTH_HELPERS.slice(AUTH_HELPERS.indexOf('export function setupAuthEventListeners'));
+        ctx.expect(fnSource.includes("registerTrigger('signin'")).toBe(true);
+        ctx.expect(fnSource.includes('openAuthPage(context)')).toBe(true);
+        // The trigger class is the registry's to spell — never written by hand.
+        ctx.expect(fnSource.includes('omega-signin')).toBe(false);
+        ctx.expect(fnSource.includes('addEventListener')).toBe(false);
+      },
+    },
+    {
+      name: 'setupAuthEventListeners registers the `account` trigger, opening /account on the brand site',
+      run: (ctx) => {
+        const fnSource = AUTH_HELPERS.slice(AUTH_HELPERS.indexOf('export function setupAuthEventListeners'));
+        ctx.expect(fnSource.includes("registerTrigger('account'")).toBe(true);
+        // Same resolver as signin: brand.url + tabs.create, only the path differs.
+        ctx.expect(fnSource.includes("openAuthPage(context, { path: '/account' })")).toBe(true);
+        // The trigger class is the registry's to spell — never written by hand.
+        ctx.expect(fnSource.includes('omega-account')).toBe(false);
+      },
+    },
+    {
+      name: 'no legacy trigger class survives anywhere in the extension source',
+      run: (ctx) => {
+        const offenders = [];
+        for (const entry of fs.readdirSync(SRC, { recursive: true, withFileTypes: true })) {
+          if (!entry.isFile() || !/\.(js|html)$/.test(entry.name)) { continue; }
+          const file = path.join(entry.parentPath, entry.name);
+          // The framework's own sources only — `defaults/` is consumer scaffold
+          // markup and is swept the same way. Skipped: node_modules (not ours),
+          // and this suite tree (it NAMES the retired classes on purpose).
+          if (file.includes(`${path.sep}node_modules${path.sep}`)) { continue; }
+          if (file.startsWith(path.join(SRC, 'test') + path.sep)) { continue; }
+          const contents = fs.readFileSync(file, 'utf8');
+          for (const name of LEGACY_CLASSES) {
+            if (contents.includes(name)) { offenders.push(`${path.relative(SRC, file)} → ${name}`); }
+          }
+        }
+        ctx.expect(offenders).toEqual([]);
+      },
+    },
+  ],
+});

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

@@ -0,0 +1,134 @@
+// Build-layer tests for the boot layer's extension-directory discovery (#575).
+//
+// The boot layer promises a SKIP when the consumer has not built yet
+// (docs/test-boot-layer.md). It discovered by existence alone, so it fell
+// through to `<consumer>/dist/` — which exists after any dev run or `omega
+// clean` — loaded the JSON5 source manifest Chrome cannot parse, and hard-failed
+// every boot test instead. A directory only qualifies when its manifest is
+// STRICT JSON; an explicitly named OMEGA_TEST_BOOT_DIR still fails loudly,
+// because that one is the caller's decision, not a fallback.
+//
+// Discovery is asserted directly (no Chromium): the skip/abort verdicts are
+// reached and returned before puppeteer ever launches.
+
+const path = require('path');
+const fs   = require('fs');
+const os   = require('os');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+const BOOT_RUNNER = path.join(__dirname, '..', '..', 'runners', 'boot.js');
+
+// One boot test, enough to make the counts meaningful.
+const TESTS = [{ description: 'boot probe', inspect: async () => {} }];
+
+const JSON5_MANIFEST = `{
+  // the framework-authored source style Chrome refuses
+  manifest_version: 3,
+  name: 'Staged',
+}
+`;
+const STRICT_MANIFEST = JSON.stringify({ manifest_version: 3, name: 'Staged', version: '1.0.0' }, null, 2);
+
+// Stage a consumer project. `manifests` is a relative dir → manifest contents map.
+function stageConsumer(manifests) {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'extension-boot-discovery-'));
+
+  for (const [relative, contents] of Object.entries(manifests)) {
+    fs.mkdirSync(path.join(tmp, relative), { recursive: true });
+    fs.writeFileSync(path.join(tmp, relative, 'manifest.json'), contents);
+  }
+
+  return tmp;
+}
+
+// The self-test run points OMEGA_TEST_BOOT_PROJECT at the in-tree fixture —
+// neutralize both boot env vars so each case sees only what it staged.
+function withBootEnv(vars, fn) {
+  const keys = ['OMEGA_TEST_BOOT_PROJECT', 'OMEGA_TEST_BOOT_DIR'];
+  const previous = {};
+  keys.forEach((key) => { previous[key] = process.env[key]; delete process.env[key]; });
+  Object.entries(vars).forEach(([key, value]) => { process.env[key] = value; });
+
+  return Promise.resolve()
+    .then(fn)
+    .finally(() => {
+      keys.forEach((key) => {
+        if (previous[key] === undefined) delete process.env[key];
+        else process.env[key] = previous[key];
+      });
+    });
+}
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'build',
+  description: 'boot layer — extension-directory discovery',
+  tests: [
+    {
+      name: 'a JSON5 dist/ manifest never qualifies — the run SKIPS as documented (#575)',
+      run: async (ctx) => {
+        const { runBootTests, resolveBootDir } = require(BOOT_RUNNER);
+        const tmp = stageConsumer({ dist: JSON5_MANIFEST });
+
+        try {
+          await withBootEnv({}, async () => {
+            const discovery = resolveBootDir(tmp);
+            ctx.expect(discovery.dir).toBe(null);
+            // The JSON5 copy is REPORTED, so the skip can say why it was passed over
+            ctx.expect(discovery.rejected.length).toBe(1);
+            ctx.expect(discovery.rejected[0].dir).toBe(path.join(tmp, 'dist'));
+
+            const counts = await runBootTests({ tests: TESTS, projectRoot: tmp });
+            ctx.expect(counts.skipped).toBe(TESTS.length);
+            ctx.expect(counts.failed).toBe(0);
+          });
+        } finally {
+          fs.rmSync(tmp, { recursive: true, force: true });
+        }
+      },
+    },
+    {
+      name: 'the packaged strict-JSON manifest wins, and a strict-JSON dist/ still qualifies (#575)',
+      run: async (ctx) => {
+        const { resolveBootDir } = require(BOOT_RUNNER);
+        const both = stageConsumer({ 'packaged/chromium/raw': STRICT_MANIFEST, dist: JSON5_MANIFEST });
+        // The framework's own fixture extension has no `packaged/` step — its
+        // dist/ is already strict JSON, and it must keep booting.
+        const fixtureShape = stageConsumer({ dist: STRICT_MANIFEST });
+
+        try {
+          await withBootEnv({}, async () => {
+            ctx.expect(resolveBootDir(both).dir).toBe(path.join(both, 'packaged', 'chromium', 'raw'));
+            ctx.expect(resolveBootDir(fixtureShape).dir).toBe(path.join(fixtureShape, 'dist'));
+          });
+        } finally {
+          fs.rmSync(both, { recursive: true, force: true });
+          fs.rmSync(fixtureShape, { recursive: true, force: true });
+        }
+      },
+    },
+    {
+      name: 'an explicitly named OMEGA_TEST_BOOT_DIR with a JSON5 manifest still FAILS loudly (#575)',
+      run: async (ctx) => {
+        const { runBootTests, resolveBootDir } = require(BOOT_RUNNER);
+        const tmp = stageConsumer({ dist: JSON5_MANIFEST });
+
+        try {
+          await withBootEnv({ OMEGA_TEST_BOOT_DIR: path.join(tmp, 'dist') }, async () => {
+            const discovery = resolveBootDir(tmp);
+            ctx.expect(discovery.dir).toBe(null);
+            // The caller named this directory — a manifest Chrome cannot parse
+            // there is an error, never a candidate to walk past
+            ctx.expect(discovery.error).toBeInstanceOf(Error);
+
+            const counts = await runBootTests({ tests: TESTS, projectRoot: tmp });
+            ctx.expect(counts.failed).toBe(TESTS.length);
+            ctx.expect(counts.skipped).toBe(0);
+          });
+        } finally {
+          fs.rmSync(tmp, { recursive: true, force: true });
+        }
+      },
+    },
+  ],
+});