@omega.js/extension 0.1.0

package/dist/test/suites/build/theme-resolve.test.js

@@ -0,0 +1,115 @@
+// Build-layer tests for lib/theme.js — per-framework theme.id resolution (#261).
+//
+// `theme.id` is a SHARED config key, but every framework owns its own theme set:
+// a brand whose website theme is `studymonkey` handed the extension build an id
+// it has no stylesheet for, and the build died on a raw sass "Can't find
+// stylesheet to import" that named neither the config key nor the valid set.
+// Unknown ids now fall back to the extension's default theme with ONE warning.
+
+const path = require('path');
+const fs   = require('fs');
+const os   = require('os');
+
+const { resolveThemeId, DEFAULT_THEME_ID } = require('../../../lib/theme.js');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+// A themes dir shaped like the framework's own: theme dirs plus the `_template`
+// scaffold, which is not a selectable theme.
+function stageThemes() {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'extension-themes-'));
+  for (const name of ['classy', 'bootstrap', 'newsflash', '_template']) {
+    fs.mkdirSync(path.join(tmp, name), { recursive: true });
+  }
+  return tmp;
+}
+
+// Logger that records what it was told (the real ones stamp the identity tag).
+function captureLogger() {
+  const warnings = [];
+  return { warnings, warn: (message) => warnings.push(message), log: () => {} };
+}
+
+module.exports = defineCases({
+  type: 'group',
+  layer: 'build',
+  description: 'theme resolution — unknown ids fall back with one actionable warning',
+  tests: [
+    {
+      name: 'a theme this framework ships resolves to itself, silently',
+      run: (ctx) => {
+        const themesDir = stageThemes();
+        const logger = captureLogger();
+
+        try {
+          ctx.expect(resolveThemeId('bootstrap', { themesDir, logger })).toBe('bootstrap');
+          ctx.expect(logger.warnings.length).toBe(0);
+        } finally {
+          fs.rmSync(themesDir, { recursive: true, force: true });
+        }
+      },
+    },
+    {
+      name: 'no theme.id at all resolves to the framework default, silently',
+      run: (ctx) => {
+        const themesDir = stageThemes();
+        const logger = captureLogger();
+
+        try {
+          ctx.expect(resolveThemeId(undefined, { themesDir, logger })).toBe(DEFAULT_THEME_ID);
+          ctx.expect(logger.warnings.length).toBe(0);
+        } finally {
+          fs.rmSync(themesDir, { recursive: true, force: true });
+        }
+      },
+    },
+    {
+      name: 'an unknown id falls back to the default with ONE warning naming the key, the value, and the valid set',
+      run: (ctx) => {
+        const themesDir = stageThemes();
+        const logger = captureLogger();
+
+        try {
+          ctx.expect(resolveThemeId('studymonkey', { themesDir, logger })).toBe(DEFAULT_THEME_ID);
+          ctx.expect(logger.warnings.length).toBe(1);
+
+          const warning = logger.warnings[0];
+          ctx.expect(warning).toContain('theme.id');
+          ctx.expect(warning).toContain('studymonkey');
+          ctx.expect(warning).toContain(DEFAULT_THEME_ID);
+          ctx.expect(warning).toContain('bootstrap');
+          ctx.expect(warning).toContain('newsflash');
+          // `_template` is a scaffold, never an option to offer
+          ctx.expect(warning.includes('_template')).toBe(false);
+        } finally {
+          fs.rmSync(themesDir, { recursive: true, force: true });
+        }
+      },
+    },
+    {
+      name: 'every resolve site sharing the bad id warns ONCE (sass + bundler, one build)',
+      run: (ctx) => {
+        const themesDir = stageThemes();
+        const logger = captureLogger();
+
+        try {
+          resolveThemeId('brand-only-theme', { themesDir, logger });
+          resolveThemeId('brand-only-theme', { themesDir, logger });
+          resolveThemeId('brand-only-theme', { themesDir, logger });
+          ctx.expect(logger.warnings.length).toBe(1);
+        } finally {
+          fs.rmSync(themesDir, { recursive: true, force: true });
+        }
+      },
+    },
+    {
+      name: 'an unreadable themes dir judges nothing: the id passes through unwarned',
+      run: (ctx) => {
+        const logger = captureLogger();
+        const missing = path.join(os.tmpdir(), 'extension-themes-does-not-exist');
+
+        ctx.expect(resolveThemeId('classy', { themesDir: missing, logger })).toBe('classy');
+        ctx.expect(logger.warnings.length).toBe(0);
+      },
+    },
+  ],
+});

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

@@ -0,0 +1,85 @@
+// Build-layer tests for the translation glue — the engine/cache/providers live
+// in @omega.js/devkit/translate (unit-tested there); these cover the
+// extension-specific pieces: composing a locale's messages.json from the
+// committed per-string cache (EN fallback for gaps, developer descriptions
+// kept in English) and the description source-hash marker round-trip.
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const jetpack = require('fs-jetpack');
+
+const { composeMessages, readTranslatedDescription } = require('../../../gulp/tasks/translate.js');
+const { hashKey, saveCache } = require('../../../vendor/devkit/translate/index.js');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+const EN_MESSAGES = {
+  appName: { message: 'OMEGA', description: 'The name of the extension.' },
+  appNameShort: { message: 'OMEGA', description: 'The short name of the extension.' },
+  btnTooltip: { message: 'Click to open', description: 'Tooltip for the button.' },
+};
+
+module.exports = defineCases({
+  type: 'group',
+  layer: 'build',
+  description: 'translation glue (devkit engine consumers)',
+  tests: [
+    {
+      name: 'composeMessages: cache hits land, gaps fall back to English, descriptions stay English',
+      run: (ctx) => {
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'extension-translate-'));
+
+        // Cache carries a translation for the shared "OMEGA" string only
+        saveCache(tmp, 'es', 'messages', { [hashKey('OMEGA')]: 'OMEGA·es' });
+
+        const composed = composeMessages(EN_MESSAGES, 'es', tmp);
+
+        // Shared source string → both keys get the cached translation
+        ctx.expect(composed.appName.message).toBe('OMEGA·es');
+        ctx.expect(composed.appNameShort.message).toBe('OMEGA·es');
+        // No cache entry → English fallback (file always complete)
+        ctx.expect(composed.btnTooltip.message).toBe('Click to open');
+        // Developer-facing descriptions never translate
+        ctx.expect(composed.appName.description).toBe('The name of the extension.');
+
+        jetpack.remove(tmp);
+      },
+    },
+    {
+      name: 'source edit invalidates: a changed EN message misses the old cache entry',
+      run: (ctx) => {
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'extension-translate-'));
+        saveCache(tmp, 'es', 'messages', { [hashKey('Old tooltip')]: 'Vieja' });
+
+        const composed = composeMessages(
+          { btnTooltip: { message: 'New tooltip', description: 'd' } },
+          'es',
+          tmp
+        );
+
+        ctx.expect(composed.btnTooltip.message).toBe('New tooltip');
+
+        jetpack.remove(tmp);
+      },
+    },
+    {
+      name: 'readTranslatedDescription: strips the source marker, null when absent',
+      run: (ctx) => {
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'extension-translate-'));
+
+        jetpack.write(
+          path.join(tmp, 'es', 'description.md'),
+          `<!-- omega:source ${'a'.repeat(12)} -->\n# La Descripción\n\nHola.`
+        );
+
+        const content = readTranslatedDescription('es', tmp);
+        ctx.expect(content.startsWith('# La Descripción')).toBeTruthy();
+        ctx.expect(content.includes('omega:source')).toBe(false);
+
+        ctx.expect(readTranslatedDescription('fr', tmp)).toBe(null);
+
+        jetpack.remove(tmp);
+      },
+    },
+  ],
+});

package/dist/test/suites/build/url-helpers.test.js

@@ -0,0 +1,119 @@
+// Build-layer test for utils/url-helpers.js — verifies getApiUrl() resolves the
+// LOCAL hosting port from every channel a context can have, in precedence
+// order: the OMEGA_*_PORT env vars (build-time Node + the test harness), then
+// the `dev.ports` block the build bakes into OMEGA_BUILD_JSON (the ONLY channel a
+// browser context has — [#744](https://github.com/Omega-JS-Stack/omega/issues/744)),
+// then the classic defaults.
+
+const path = require('path');
+
+const helpers = require(path.join(__dirname, '..', '..', '..', 'utils', 'url-helpers.js'));
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+function withEnv(overrides, fn) {
+  const originals = {};
+  for (const [k, v] of Object.entries(overrides)) {
+    originals[k] = process.env[k];
+    if (v === null) delete process.env[k];
+    else            process.env[k] = v;
+  }
+  try { return fn(); } finally {
+    for (const [k, v] of Object.entries(originals)) {
+      if (v === undefined) delete process.env[k];
+      else                 process.env[k] = v;
+    }
+  }
+}
+
+// The shape getApiUrl() sees at runtime: a context Manager carrying the parsed
+// baked config plus mode-helpers' getEnvironment().
+function fakeManager(environment, ports) {
+  return {
+    getEnvironment: () => environment,
+    config: {
+      brand: { url: 'https://playground.omegajs.dev' },
+      ...(ports ? { dev: { ports } } : {}),
+    },
+  };
+}
+
+// Neither env channel published — the state every browser context is in.
+const NO_ENV = { OMEGA_HOSTING_PORT: null, OMEGA_HTTPS_PORT: null };
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'build',
+  description: 'utils/url-helpers — getApiUrl resolves env → baked dev.ports → classic',
+  tests: [
+    {
+      name: 'exports { attachTo, getApiUrl }',
+      run: (ctx) => {
+        ctx.expect(typeof helpers.attachTo).toBe('function');
+        ctx.expect(typeof helpers.getApiUrl).toBe('function');
+      },
+    },
+    {
+      name: 'a BUMPED baked dev.ports.hosting is the api base in testing',
+      run: (ctx) => {
+        withEnv(NO_ENV, () => {
+          const manager = fakeManager('testing', { hosting: 5012, auth: 9109 });
+          ctx.expect(helpers.getApiUrl.call(manager)).toBe('http://localhost:5012');
+        });
+      },
+    },
+    {
+      name: 'a BUMPED baked dev.ports.hosting is the api base in development too',
+      run: (ctx) => {
+        withEnv(NO_ENV, () => {
+          const manager = fakeManager('development', { hosting: 5012 });
+          ctx.expect(helpers.getApiUrl.call(manager)).toBe('http://localhost:5012');
+        });
+      },
+    },
+    {
+      name: 'OMEGA_HOSTING_PORT wins over the baked value',
+      run: (ctx) => {
+        withEnv({ ...NO_ENV, OMEGA_HOSTING_PORT: '5022' }, () => {
+          const manager = fakeManager('testing', { hosting: 5012 });
+          ctx.expect(helpers.getApiUrl.call(manager)).toBe('http://localhost:5022');
+        });
+      },
+    },
+    {
+      name: 'neither channel → the classic hosting port 5002',
+      run: (ctx) => {
+        withEnv(NO_ENV, () => {
+          ctx.expect(helpers.getApiUrl.call(fakeManager('testing'))).toBe('http://localhost:5002');
+          ctx.expect(helpers.getApiUrl.call(fakeManager('development'))).toBe('http://localhost:5002');
+        });
+      },
+    },
+    {
+      name: 'OMEGA_HTTPS_PORT means the mkcert proxy is up — https, not hosting',
+      run: (ctx) => {
+        withEnv({ ...NO_ENV, OMEGA_HTTPS_PORT: '5003' }, () => {
+          const manager = fakeManager('testing', { hosting: 5012 });
+          ctx.expect(helpers.getApiUrl.call(manager)).toBe('https://localhost:5003');
+        });
+      },
+    },
+    {
+      name: 'a baked dev.ports.https does the same for a browser context',
+      run: (ctx) => {
+        withEnv(NO_ENV, () => {
+          const manager = fakeManager('testing', { https: 5003, hosting: 5443 });
+          ctx.expect(helpers.getApiUrl.call(manager)).toBe('https://localhost:5003');
+        });
+      },
+    },
+    {
+      name: 'production ignores every local channel — api.<brand host>',
+      run: (ctx) => {
+        withEnv({ ...NO_ENV, OMEGA_HOSTING_PORT: '5022' }, () => {
+          const manager = fakeManager('production', { hosting: 5012 });
+          ctx.expect(helpers.getApiUrl.call(manager)).toBe('https://api.playground.omegajs.dev');
+        });
+      },
+    },
+  ],
+});

package/dist/test/suites/build/verb-logs.test.js

@@ -0,0 +1,43 @@
+// Build-layer test for the verb log lane (#197): `omega test` tees its whole
+// run to <projectRoot>/logs/test.log, ANSI-stripped.
+//
+// This is the integration pin, and it needs no fixture: THIS process IS the
+// `omega test` run, so a line written from here must already be in the file the
+// verb opened. That also guards the regression the isolated-tee fix was for —
+// a suite that clobbers the singleton mid-run would leave the marker (written
+// after those suites) out of the file.
+
+const path = require('path');
+const fs   = require('fs');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'build',
+  description: 'verb logs — the live run is teed to logs/test.log',
+  tests: [
+    {
+      name: 'the running `omega test` writes this line to logs/test.log, ANSI stripped',
+      run: (ctx) => {
+        // The tee deliberately declines under a runner (the runner captures its
+        // own output and wants no logs/ left in the workspace).
+        if (process.env.CI === 'true' || process.env.GITHUB_ACTIONS === 'true') {
+          ctx.skip('the tee is a no-op in CI by design');
+          return;
+        }
+
+        const logPath = path.join(process.cwd(), 'logs', 'test.log');
+        ctx.expect(fs.existsSync(logPath)).toBe(true);
+
+        // Colored on the terminal; the file must hold the bare text.
+        const marker = `verb-log marker ${process.pid}`;
+        console.log(`\x1B[36m${marker}\x1B[0m`);
+
+        const line = fs.readFileSync(logPath, 'utf8')
+          .split('\n')
+          .find((entry) => entry.includes(marker));
+        ctx.expect(line).toBe(marker);
+      },
+    },
+  ],
+});

package/dist/test/suites/build/verts-binding.test.js

@@ -0,0 +1,67 @@
+// Build-layer pin for the verts auto-bind (ads-system phase 4): every page
+// surface (popup/options/sidepanel/page) wires lib/verts.js after
+// omega.initialize(), the binder pins the house lane (extension surfaces
+// never run AdSense — store policy + MV3 CSP), the build-JSON allowlist
+// carries advertising/company through to the client, and content/background/
+// offscreen deliberately do NOT bind. Surface files are browser-context ES
+// modules (window/chrome at module scope), so this pins the SOURCE text
+// rather than importing them — same model as cache-warming.test.js. The
+// binder's runtime behavior (lazy mount, ladder, no-fill) is pinned in
+// @omega.js/client's own suite (client test/verts.test.js).
+
+const fs = require('fs');
+const path = require('path');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+const ROOT = path.join(__dirname, '..', '..', '..');
+const read = (...segments) => fs.readFileSync(path.join(ROOT, ...segments), 'utf8');
+
+const SURFACES = ['popup.js', 'options.js', 'sidepanel.js', 'page.js'];
+const NON_SURFACES = ['content.js', 'background.js', 'offscreen.js'];
+const VERTS_LIB = read('lib', 'verts.js');
+// The build snapshot is baked in by the bundle task ([#743](https://github.com/Omega-JS-Stack/omega/issues/743)).
+const BUNDLE_TASK = read('gulp', 'tasks', 'bundle.js');
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'build',
+  description: 'verts auto-bind — surface wiring + house-lane pin + build-JSON plumbing',
+  tests: [
+    {
+      name: 'every page surface imports and calls wireAds after omega.initialize()',
+      run: (ctx) => {
+        for (const surface of SURFACES) {
+          const source = read(surface);
+          ctx.expect(source).toMatch(/import \{ wireAds \} from '\.\/lib\/verts\.js';/);
+          // The call sits inside initialize(), after the client boot
+          ctx.expect(/await this\.omega\.initialize\(configuration\);[\s\S]*wireAds\(\);/.test(source)).toBe(true);
+        }
+      },
+    },
+    {
+      name: 'content/background/offscreen do NOT auto-bind (host-DOM / no-DOM contexts)',
+      run: (ctx) => {
+        for (const context of NON_SURFACES) {
+          ctx.expect(read(context).includes('wireAds')).toBe(false);
+        }
+      },
+    },
+    {
+      name: 'the binder pins the house lane — mount() type override, no AdSense path',
+      run: (ctx) => {
+        ctx.expect(VERTS_LIB).toMatch(/omega\.verts\(\)\.mount\(\$el, \{ type: 'house' \}\);/);
+        // The wiring marks bound hosts for observability (tests + debugging)
+        ctx.expect(VERTS_LIB).toMatch(/data-omega-vert-bound/);
+        // Live binding: new [data-omega-vert] elements mount on arrival
+        ctx.expect(VERTS_LIB).toMatch(/new MutationObserver\(/);
+      },
+    },
+    {
+      name: 'build-JSON allowlist carries advertising + company to the client',
+      run: (ctx) => {
+        ctx.expect(BUNDLE_TASK).toMatch(/advertising: config\.advertising \|\| \{\},/);
+        ctx.expect(BUNDLE_TASK).toMatch(/company: config\.company \|\| \{\},/);
+      },
+    },
+  ],
+});

package/dist/test/suites/build/wakeup-ping.test.js

@@ -0,0 +1,90 @@
+// Build-layer pin for the extension's wakeup ping
+// ([#644](https://github.com/Omega-JS-Stack/omega/issues/644)).
+//
+// Every surface (popup/options/sidepanel/page) opens by calling
+// syncWithBackground(), and background answers a sync that needs a token by
+// POSTing /omega/user/token — the extension's first backend call, on a function
+// that is cold on the first surface a user opens. The ping goes out before the
+// auth settle, so the cold start burns down while Firebase comes up.
+//
+// auth-helpers.js is a browser-context ES module, but a transport-free one: it
+// takes its context as an argument, so this imports the REAL function rather
+// than pinning its source (the model auth-triggers.test.js had to use for the
+// DOM-bound halves of the same file).
+
+const path = require('path');
+const { pathToFileURL } = require('url');
+
+const { WAKEUP_ROUTE } = require('@omega.js/client/modules/request.js');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+const AUTH_HELPERS = pathToFileURL(path.join(__dirname, '..', '..', '..', 'lib', 'auth-helpers.js')).href;
+
+// A surface's context: the omega singleton and the runtime messaging channel,
+// with everything the sync touches recorded in the order it happened.
+function makeContext({ needsSync = false } = {}) {
+  const requests = [];
+  const timeline = [];
+
+  return {
+    requests,
+    timeline,
+    context: {
+      extension: {
+        runtime: {
+          lastError: null,
+          sendMessage: (message, callback) => {
+            timeline.push(message.command);
+            callback({ needsSync });
+          },
+        },
+      },
+      omega: {
+        request: async (url, options = {}) => {
+          requests.push({ url, options });
+          timeline.push(options.wakeup ? 'wakeup' : url);
+        },
+        auth: () => ({
+          listen: (options, callback) => {
+            timeline.push('auth-settle');
+            callback({ user: null });
+          },
+        }),
+      },
+    },
+  };
+}
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'build',
+  description: 'wakeup ping — a surface warms the backend before it waits on auth (#644)',
+  tests: [
+    {
+      name: 'syncWithBackground fires exactly one wakeup, aimed at the shared route',
+      run: async (ctx) => {
+        const { syncWithBackground } = await import(AUTH_HELPERS);
+        const { context, requests } = makeContext();
+
+        await syncWithBackground(context);
+
+        ctx.expect(requests.length).toBe(1);
+        ctx.expect(requests[0].url).toBe(WAKEUP_ROUTE);
+        ctx.expect(requests[0].options.wakeup).toBe(true);
+      },
+    },
+    {
+      name: 'the ping goes out BEFORE the auth settle and the background round trip',
+      run: async (ctx) => {
+        const { syncWithBackground } = await import(AUTH_HELPERS);
+        const { context, timeline } = makeContext();
+
+        await syncWithBackground(context);
+
+        ctx.expect(timeline[0]).toBe('wakeup');
+        ctx.expect(timeline[1]).toBe('auth-settle');
+        ctx.expect(timeline[2]).toBe('omega:syncAuth');
+      },
+    },
+  ],
+});

package/dist/test/suites/build/wave5-messenger.test.js

@@ -0,0 +1,80 @@
+// Build-layer coverage for wave-5 F7: `manager.messenger` was documented as
+// "wired automatically" but every context assigned null and lib/messaging.js
+// was never instantiated. Behavioral test for the Messaging class + source
+// pins proving each DOM context constructs it (the context Managers are
+// ES modules the bundler owns — not requireable from Node, hence the pins).
+
+const path = require('path');
+const fs = require('fs');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+const SRC = path.join(__dirname, '..', '..', '..');
+const CONTEXTS = ['popup', 'options', 'sidepanel', 'page', 'content'];
+
+module.exports = defineCases({
+  type: 'group',
+  layer: 'build',
+  description: 'lib/messaging + per-context messenger wiring (wave-5 F7)',
+  tests: [
+    {
+      name: 'Messaging registers an onMessage listener and send() targets runtime.sendMessage',
+      run: async (ctx) => {
+        const extPath = require.resolve(path.join(SRC, 'lib', 'extension.js'));
+        const msgPath = require.resolve(path.join(SRC, 'lib', 'messaging.js'));
+        const listeners = [];
+        const sent = [];
+        global.chrome = {
+          runtime: {
+            onMessage: { addListener: (fn) => listeners.push(fn) },
+            sendMessage: async (msg) => { sent.push(msg); },
+          },
+        };
+        delete require.cache[extPath];
+        delete require.cache[msgPath];
+        try {
+          const Messaging = require(msgPath);
+          const messenger = new Messaging({ sender: 'popup' });
+          ctx.expect(listeners.length).toBe(1);
+
+          messenger.send({ destination: 'background', command: 'ping', payload: { a: 1 } });
+          ctx.expect(sent.length).toBe(1);
+          ctx.expect(sent[0].sender).toBe('popup');
+          ctx.expect(sent[0].destination).toBe('background');
+
+          // The degenerate `!init || !init` check claimed to validate sender —
+          // now it actually does.
+          let threw = null;
+          try { new Messaging({}); } catch (e) { threw = e; }
+          ctx.expect(threw).not.toBeNull();
+        } finally {
+          delete global.chrome;
+          delete require.cache[extPath];
+          delete require.cache[msgPath];
+        }
+      },
+    },
+    {
+      // wave-5 (history-lens catch): openAuthPage was the un-flipped half of
+      // the F9 pair — it still built the sign-in URL from authDomain while
+      // background.js watched the brand.url host; the round trip could never
+      // complete. Both ends now speak brand.url.
+      name: 'openAuthPage derives the sign-in URL from brand.url, never authDomain (source pin)',
+      run: (ctx) => {
+        const source = fs.readFileSync(path.join(SRC, 'lib', 'auth-helpers.js'), 'utf8');
+        const fnSource = source.slice(source.indexOf('export function openAuthPage'));
+        ctx.expect(fnSource.includes('brand?.url')).toBe(true);
+        // The old read, gone (comments may still NAME authDomain to warn it off)
+        ctx.expect(fnSource.includes('config?.authDomain')).toBe(false);
+      },
+    },
+    {
+      name: 'every DOM context constructs Messaging with its own sender (source pin)',
+      run: (ctx) => {
+        for (const name of CONTEXTS) {
+          const source = fs.readFileSync(path.join(SRC, `${name}.js`), 'utf8');
+          ctx.expect(source.includes(`new Messaging({ sender: '${name}' })`)).toBe(true);
+        }
+      },
+    },
+  ],
+});

package/dist/test/suites/view/options-and-sidepanel.test.js

@@ -0,0 +1,16 @@
+// View-layer test that the same Manager surface is reachable from the options
+// page. Confirms that view tests can target ANY of popup / options / sidepanel
+// just by setting the `context` field — same `ctx.expect / state / skip` API
+// applies. (Sidepanel is exercised separately in sidepanel.test.js.)
+
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  layer: 'view',
+  context: 'options',
+  description: 'view/options — DOM + context attribute',
+  run: async (ctx) => {
+    ctx.expect(document.body.dataset.omegaContext).toBe('options');
+    ctx.expect(document.title).toContain('Options');
+  },
+});

package/dist/test/suites/view/popup-context.test.js

@@ -0,0 +1,53 @@
+// View-layer smoke for the popup page. Verifies the test code is executing
+// inside a tab that has loaded popup.html (chrome-extension://<id>/popup.html),
+// has DOM + chrome.* APIs, and matches the harness's expected page shape.
+
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'view',
+  context: 'popup',
+  description: 'view/popup — DOM + chrome surface',
+  tests: [
+    {
+      name: 'document is present and body has data-omega-context="popup"',
+      run: async (ctx) => {
+        ctx.expect(typeof document).toBe('object');
+        ctx.expect(document.body.dataset.omegaContext).toBe('popup');
+      },
+    },
+    {
+      name: 'page title matches the harness popup.html',
+      run: async (ctx) => {
+        ctx.expect(document.title).toContain('Popup');
+      },
+    },
+    {
+      name: 'chrome.* APIs are exposed in extension-page context',
+      run: async (ctx) => {
+        ctx.expect(typeof chrome).toBe('object');
+        ctx.expect(typeof chrome.runtime).toBe('object');
+        ctx.expect(typeof chrome.runtime.id).toBe('string');
+        ctx.expect(typeof chrome.storage).toBe('object');
+      },
+    },
+    {
+      name: 'window globals (fetch, URL) are available',
+      run: async (ctx) => {
+        ctx.expect(typeof fetch).toBe('function');
+        ctx.expect(typeof URL).toBe('function');
+        const u = new URL('https://example.com/path?q=1');
+        ctx.expect(u.searchParams.get('q')).toBe('1');
+      },
+    },
+    {
+      name: 'popup ↔ background messaging round-trip',
+      run: async (ctx) => {
+        const reply = await chrome.runtime.sendMessage({ type: 'extension:test:ping' });
+        ctx.expect(reply.pong).toBe(true);
+        ctx.expect(typeof reply.ts).toBe('number');
+      },
+    },
+  ],
+});