browser-extension-manager 1.3.49 → 1.4.0

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

@@ -0,0 +1,123 @@
+// Build-layer tests for cli.js alias resolution. We instantiate Main and call
+// process({ _: ['<alias>'] }) — the resolver looks up the alias map and require()s
+// the command module. To avoid actually running the command, we stub each command
+// to a no-op via require.cache injection before calling process().
+
+const path = require('path');
+
+const CLI_PATH = path.join(__dirname, '..', '..', '..', 'cli.js');
+const COMMANDS_DIR = path.join(__dirname, '..', '..', '..', 'commands');
+
+function stubCommand(name, fn) {
+  const file = path.join(COMMANDS_DIR, `${name}.js`);
+  require.cache[file] = {
+    id:       file,
+    filename: file,
+    loaded:   true,
+    children: [],
+    paths:    [],
+    exports:  fn,
+  };
+}
+
+function unstub(name) {
+  delete require.cache[path.join(COMMANDS_DIR, `${name}.js`)];
+}
+
+function freshCli() {
+  delete require.cache[CLI_PATH];
+  return require(CLI_PATH);
+}
+
+module.exports = {
+  type: 'suite',
+  layer: 'build',
+  description: 'cli — alias resolution + dispatch',
+  tests: [
+    {
+      name: 'positional "test" routes to commands/test.js',
+      run: async (ctx) => {
+        let invoked = false;
+        stubCommand('test', async () => { invoked = true; });
+        try {
+          const Main = freshCli();
+          await new Main().process({ _: ['test'] });
+          ctx.expect(invoked).toBe(true);
+        } finally {
+          unstub('test');
+        }
+      },
+    },
+    {
+      name: 'alias "-t" routes to test command',
+      run: async (ctx) => {
+        let invoked = false;
+        stubCommand('test', async () => { invoked = true; });
+        try {
+          const Main = freshCli();
+          await new Main().process({ _: [], t: true });
+          ctx.expect(invoked).toBe(true);
+        } finally {
+          unstub('test');
+        }
+      },
+    },
+    {
+      name: 'positional "clean" routes to commands/clean.js',
+      run: async (ctx) => {
+        let invoked = false;
+        stubCommand('clean', async () => { invoked = true; });
+        try {
+          const Main = freshCli();
+          await new Main().process({ _: ['clean'] });
+          ctx.expect(invoked).toBe(true);
+        } finally {
+          unstub('clean');
+        }
+      },
+    },
+    {
+      name: 'no command defaults to setup',
+      run: async (ctx) => {
+        let invoked = false;
+        stubCommand('setup', async () => { invoked = true; });
+        try {
+          const Main = freshCli();
+          await new Main().process({ _: [] });
+          ctx.expect(invoked).toBe(true);
+        } finally {
+          unstub('setup');
+        }
+      },
+    },
+    {
+      name: 'unknown command throws "Command not found"',
+      run: async (ctx) => {
+        const Main = freshCli();
+        let threw = false;
+        try {
+          await new Main().process({ _: ['totally-not-a-command-xyz'] });
+        } catch (e) {
+          threw = true;
+          ctx.expect(e.message).toContain('not found');
+        }
+        ctx.expect(threw).toBe(true);
+      },
+    },
+    {
+      name: 'command options are forwarded',
+      run: async (ctx) => {
+        let received = null;
+        stubCommand('test', async (opts) => { received = opts; });
+        try {
+          const Main = freshCli();
+          await new Main().process({ _: ['test'], layer: 'build', filter: 'foo' });
+          ctx.expect(received.layer).toBe('build');
+          ctx.expect(received.filter).toBe('foo');
+        } finally {
+          unstub('test');
+        }
+      },
+    },
+  ],
+};

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

@@ -0,0 +1,47 @@
+// Build-layer test of the test framework's own expect() matchers. Self-test —
+// if this doesn't pass, the test framework itself is broken and downstream
+// suites can't be trusted.
+
+const path = require('path');
+
+const expect = require(path.join(__dirname, '..', '..', 'assert.js'));
+
+module.exports = {
+  type: 'group',
+  layer: 'build',
+  description: 'expect() — matcher self-test',
+  tests: [
+    { name: 'toBe passes on ===',           run: () => expect(1).toBe(1) },
+    { name: 'toBe.not passes on !==',       run: () => expect(1).not.toBe(2) },
+    { name: 'toEqual deep-equals objects',  run: () => expect({ a: [1, 2] }).toEqual({ a: [1, 2] }) },
+    { name: 'toEqual fails on shape diff',  run: () => {
+      let threw = false;
+      try { expect({ a: 1 }).toEqual({ a: 2 }); } catch (_) { threw = true; }
+      if (!threw) throw new Error('expected toEqual to throw');
+    } },
+    { name: 'toBeTruthy / toBeFalsy',       run: () => {
+      expect(1).toBeTruthy();
+      expect(0).toBeFalsy();
+      expect('').toBeFalsy();
+      expect('x').toBeTruthy();
+    } },
+    { name: 'toBeDefined / toBeUndefined',  run: () => {
+      expect(null).toBeDefined();
+      expect(undefined).toBeUndefined();
+    } },
+    { name: 'toContain (string)',           run: () => expect('hello world').toContain('world') },
+    { name: 'toContain (array)',            run: () => expect([1, 2, 3]).toContain(2) },
+    { name: 'toHaveProperty',               run: () => expect({ foo: 1 }).toHaveProperty('foo') },
+    { name: 'toMatch (regex)',              run: () => expect('abc123').toMatch(/^abc\d+$/) },
+    { name: 'toBeGreaterThan / toBeLessThan', run: () => {
+      expect(10).toBeGreaterThan(5);
+      expect(5).toBeLessThan(10);
+    } },
+    { name: 'toThrow on sync function',     run: async () => {
+      await expect(() => { throw new Error('boom'); }).toThrow();
+    } },
+    { name: 'toThrow with regex matcher',   run: async () => {
+      await expect(() => { throw new Error('boom: 42'); }).toThrow(/42$/);
+    } },
+  ],
+};

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

@@ -0,0 +1,52 @@
+// Build-layer test that every entry in package.json#exports is require()-able from
+// the built dist/ tree (or src/ if dist hasn't been built yet — the test resolves
+// relative to whichever directory THIS file lives in).
+//
+// The dist/ paths in package.json#exports point to dist/foo.js — when running the
+// test framework, this file IS the one shipped into dist/test/suites/build/exports.test.js,
+// so the relative path back to dist root via `../../../..` lands at <bxm>/dist, and
+// each export key resolves correctly.
+
+const path = require('path');
+
+// Each export key (e.g. './main' / './lib/logger-lite') maps to a relative dist path.
+// We strip the './dist/' prefix and resolve against `<bxm>/dist` (this file's grandparent
+// chain: dist/test/suites/build → ../../../ → dist).
+const BXM_ROOT_FROM_SUITE = path.resolve(__dirname, '..', '..', '..', '..');
+const DIST_ROOT           = path.resolve(__dirname, '..', '..', '..');
+const pkg = require(path.join(BXM_ROOT_FROM_SUITE, 'package.json'));
+
+// Browser-context modules can't be plain-required from Node (they touch chrome.* /
+// window.* without try/catch around the top-level usage). Skip those — the build-layer
+// only asserts the "node-safe" surface of BXM. Browser-context modules are exercised
+// by the background/view test layers.
+const BROWSER_CONTEXT_KEYS = new Set([
+  '.',
+  './background',
+  './content',
+  './popup',
+  './sidepanel',
+  './options',
+  './page',
+  './offscreen',
+]);
+
+module.exports = {
+  type: 'group',
+  layer: 'build',
+  description: 'package.json#exports — node-safe entries resolve',
+  tests: Object.entries(pkg.exports || {})
+    .filter(([key]) => !BROWSER_CONTEXT_KEYS.has(key))
+    .map(([key, relDistPath]) => ({
+      name: `${key} → ${relDistPath}`,
+      run: (ctx) => {
+        // relDistPath looks like "./dist/lib/logger-lite.js" — strip the leading
+        // "./dist/" and resolve against the suite's actual dist root.
+        const rel = relDistPath.replace(/^\.\/dist\//, '');
+        const abs = path.join(DIST_ROOT, rel);
+        delete require.cache[abs];
+        const mod = require(abs);
+        ctx.expect(mod).toBeDefined();
+      },
+    })),
+};

package/dist/test/suites/build/extension-fallback.test.js

@@ -0,0 +1,41 @@
+// Build-layer test for lib/extension.js — verifies the safe-fallback behavior.
+// When `chrome` / `window` / `browser` globals are absent (Node context), the
+// module's per-API try/catch blocks must swallow the ReferenceError and leave
+// every API property set to null. This is how the same module imports cleanly
+// in background SW, content scripts, AND build-time Node tooling.
+
+const path = require('path');
+
+const ext = require(path.join(__dirname, '..', '..', '..', 'lib', 'extension.js'));
+
+module.exports = {
+  type: 'group',
+  layer: 'build',
+  description: 'lib/extension — safe-fallback in Node context',
+  tests: [
+    {
+      name: 'module exports an object',
+      run: (ctx) => {
+        ctx.expect(typeof ext).toBe('object');
+        ctx.expect(ext).not.toBeNull();
+      },
+    },
+    {
+      name: 'common API slots are null when no chrome global is present',
+      run: (ctx) => {
+        ctx.expect(ext.runtime).toBeNull();
+        ctx.expect(ext.storage).toBeNull();
+        ctx.expect(ext.tabs).toBeNull();
+        ctx.expect(ext.action).toBeNull();
+      },
+    },
+    {
+      name: 'requiring the module did not throw (smoke)',
+      run: (ctx) => {
+        // The fact that we reached this test means require() didn't throw —
+        // record an explicit pass so the suite output documents the property.
+        ctx.expect(true).toBe(true);
+      },
+    },
+  ],
+};

package/dist/test/suites/build/logger-lite.test.js

@@ -0,0 +1,59 @@
+// Build-layer test for lib/logger-lite.js — verifies the timestamp prefix format
+// [HH:MM:SS] name: ... and the five method surface (log/error/warn/info/debug).
+
+const path = require('path');
+
+const Logger = require(path.join(__dirname, '..', '..', '..', 'lib', 'logger-lite.js'));
+
+function captureConsole(method, fn) {
+  const captured = [];
+  const orig = console[method];
+  console[method] = function (...args) { captured.push(args); };
+  try { fn(); } finally { console[method] = orig; }
+  return captured;
+}
+
+module.exports = {
+  type: 'suite',
+  layer: 'build',
+  description: 'lib/logger-lite — timestamp prefix + five-method surface',
+  tests: [
+    {
+      name: 'constructor stores name',
+      run: (ctx) => {
+        const log = new Logger('my-component');
+        ctx.expect(log.name).toBe('my-component');
+      },
+    },
+    {
+      name: 'log() prefixes with [HH:MM:SS] name:',
+      run: (ctx) => {
+        const log = new Logger('feature-x');
+        const captured = captureConsole('log', () => log.log('hello', 'world'));
+        ctx.expect(captured.length).toBe(1);
+        const [prefix, ...rest] = captured[0];
+        ctx.expect(prefix).toMatch(/^\[\d{2}:\d{2}:\d{2}\] feature-x:$/);
+        ctx.expect(rest).toEqual(['hello', 'world']);
+      },
+    },
+    {
+      name: 'exposes log/error/warn/info/debug',
+      run: (ctx) => {
+        const log = new Logger('s');
+        for (const m of ['log', 'error', 'warn', 'info', 'debug']) {
+          ctx.expect(typeof log[m]).toBe('function');
+        }
+      },
+    },
+    {
+      name: 'error() routes through console.error',
+      run: (ctx) => {
+        const log = new Logger('err-comp');
+        const captured = captureConsole('error', () => log.error('boom'));
+        ctx.expect(captured.length).toBe(1);
+        ctx.expect(captured[0][0]).toMatch(/err-comp:/);
+        ctx.expect(captured[0][1]).toBe('boom');
+      },
+    },
+  ],
+};

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

@@ -0,0 +1,162 @@
+// Build-layer tests for Manager.getConfig() / getManifest() / getPackage() / getEnvironment().
+// Stages a temp project dir with config/browser-extension-manager.json + src/manifest.json
+// + package.json, sets process.cwd() to it, then exercises Manager's getters.
+
+const path    = require('path');
+const fs      = require('fs');
+const os      = require('os');
+
+function stageProject(opts = {}) {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'bxm-getconfig-'));
+  if (opts.config !== undefined) {
+    fs.mkdirSync(path.join(tmp, 'config'), { recursive: true });
+    fs.writeFileSync(path.join(tmp, 'config', 'browser-extension-manager.json'), opts.config);
+  }
+  if (opts.manifest !== undefined) {
+    fs.mkdirSync(path.join(tmp, 'src'), { recursive: true });
+    fs.writeFileSync(path.join(tmp, 'src', 'manifest.json'), opts.manifest);
+  }
+  if (opts.pkg !== undefined) {
+    fs.writeFileSync(path.join(tmp, 'package.json'), opts.pkg);
+  }
+  return tmp;
+}
+
+// Runs `fn` with process.cwd() pinned to `dir`. Manager.getConfig() / getManifest()
+// resolve their files against process.cwd() at CALL time, so we hold the chdir until
+// after the test body runs (not just during require()).
+function inDir(dir, fn) {
+  const oldCwd = process.cwd();
+  for (const k of Object.keys(require.cache)) {
+    if (k.includes('/build.js')) delete require.cache[k];
+  }
+  try {
+    process.chdir(dir);
+    return fn(require(path.join(__dirname, '..', '..', '..', 'build.js')));
+  } finally {
+    process.chdir(oldCwd);
+  }
+}
+
+module.exports = {
+  type: 'suite',
+  layer: 'build',
+  description: 'Manager — config / manifest / package / environment getters',
+  tests: [
+    {
+      name: 'getConfig returns parsed JSON5',
+      run: (ctx) => {
+        const tmp = stageProject({ config: `{ brand: { id: 'somiibo', name: 'Somiibo' } }` });
+        try {
+          inDir(tmp, (Manager) => {
+            const cfg = Manager.getConfig();
+            ctx.expect(cfg.brand.id).toBe('somiibo');
+            ctx.expect(cfg.brand.name).toBe('Somiibo');
+          });
+        } finally {
+          fs.rmSync(tmp, { recursive: true, force: true });
+        }
+      },
+    },
+    {
+      name: 'getManifest returns parsed JSON5 from src/manifest.json',
+      run: (ctx) => {
+        const tmp = stageProject({ manifest: `{ manifest_version: 3, name: 'Test', version: '1.0.0' }` });
+        try {
+          inDir(tmp, (Manager) => {
+            const m = Manager.getManifest();
+            ctx.expect(m.manifest_version).toBe(3);
+            ctx.expect(m.name).toBe('Test');
+            ctx.expect(m.version).toBe('1.0.0');
+          });
+        } finally {
+          fs.rmSync(tmp, { recursive: true, force: true });
+        }
+      },
+    },
+    {
+      name: 'getManifest returns {} when src/manifest.json is absent',
+      run: (ctx) => {
+        const tmp = stageProject({});
+        try {
+          inDir(tmp, (Manager) => {
+            ctx.expect(Manager.getManifest()).toEqual({});
+          });
+        } finally {
+          fs.rmSync(tmp, { recursive: true, force: true });
+        }
+      },
+    },
+    {
+      name: 'getPackage("project") reads cwd package.json',
+      run: (ctx) => {
+        const tmp = stageProject({ pkg: `{ "name": "test-ext", "version": "2.0.0" }` });
+        try {
+          inDir(tmp, (Manager) => {
+            const pkg = Manager.getPackage('project');
+            ctx.expect(pkg.name).toBe('test-ext');
+            ctx.expect(pkg.version).toBe('2.0.0');
+          });
+        } finally {
+          fs.rmSync(tmp, { recursive: true, force: true });
+        }
+      },
+    },
+    {
+      name: 'getPackage("main") reads BXM\'s own package.json',
+      run: (ctx) => {
+        const Manager = require(path.join(__dirname, '..', '..', '..', 'build.js'));
+        const pkg = Manager.getPackage('main');
+        ctx.expect(pkg.name).toBe('browser-extension-manager');
+      },
+    },
+    {
+      name: 'getEnvironment returns "development" when BXM_BUILD_MODE !== "true"',
+      run: (ctx) => {
+        const Manager = require(path.join(__dirname, '..', '..', '..', 'build.js'));
+        const original = process.env.BXM_BUILD_MODE;
+        delete process.env.BXM_BUILD_MODE;
+        try {
+          ctx.expect(Manager.getEnvironment()).toBe('development');
+        } finally {
+          if (original !== undefined) process.env.BXM_BUILD_MODE = original;
+        }
+      },
+    },
+    {
+      name: 'getEnvironment returns "production" when BXM_BUILD_MODE === "true"',
+      run: (ctx) => {
+        const Manager = require(path.join(__dirname, '..', '..', '..', 'build.js'));
+        const original = process.env.BXM_BUILD_MODE;
+        process.env.BXM_BUILD_MODE = 'true';
+        try {
+          ctx.expect(Manager.getEnvironment()).toBe('production');
+        } finally {
+          if (original === undefined) delete process.env.BXM_BUILD_MODE;
+          else                        process.env.BXM_BUILD_MODE = original;
+        }
+      },
+    },
+    {
+      name: 'getLiveReloadPort defaults to 35729',
+      run: (ctx) => {
+        const Manager = require(path.join(__dirname, '..', '..', '..', 'build.js'));
+        const original = process.env.BXM_LIVERELOAD_PORT;
+        delete process.env.BXM_LIVERELOAD_PORT;
+        try {
+          ctx.expect(Manager.getLiveReloadPort()).toBe(35729);
+        } finally {
+          if (original !== undefined) process.env.BXM_LIVERELOAD_PORT = original;
+        }
+      },
+    },
+    {
+      name: 'getRootPath("project") returns cwd, getRootPath("main") returns BXM root',
+      run: (ctx) => {
+        const Manager = require(path.join(__dirname, '..', '..', '..', 'build.js'));
+        ctx.expect(Manager.getRootPath('project')).toBe(process.cwd());
+        ctx.expect(Manager.getRootPath('main')).toBe(path.resolve(__dirname, '..', '..', '..', '..'));
+      },
+    },
+  ],
+};

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

@@ -0,0 +1,96 @@
+// Build-layer test for utils/mode-helpers.js — verifies the cross-context helpers
+// (isDevelopment / isProduction / isTesting / getVersion) behave correctly in a
+// Node context (no `chrome` global), driven by env vars + cwd package.json.
+
+const path = require('path');
+const fs   = require('fs');
+const os   = require('os');
+
+const helpers = require(path.join(__dirname, '..', '..', '..', 'utils', 'mode-helpers.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;
+    }
+  }
+}
+
+module.exports = {
+  type: 'suite',
+  layer: 'build',
+  description: 'utils/mode-helpers — cross-context isDevelopment/isTesting/getVersion',
+  tests: [
+    {
+      name: 'exports { attachTo, isDevelopment, isProduction, isTesting, getVersion }',
+      run: (ctx) => {
+        ctx.expect(typeof helpers.attachTo).toBe('function');
+        ctx.expect(typeof helpers.isDevelopment).toBe('function');
+        ctx.expect(typeof helpers.isProduction).toBe('function');
+        ctx.expect(typeof helpers.isTesting).toBe('function');
+        ctx.expect(typeof helpers.getVersion).toBe('function');
+      },
+    },
+    {
+      name: 'isTesting() reads BXM_TEST_MODE env var',
+      run: (ctx) => {
+        withEnv({ BXM_TEST_MODE: 'true' }, () => {
+          ctx.expect(helpers.isTesting()).toBe(true);
+        });
+        withEnv({ BXM_TEST_MODE: null }, () => {
+          ctx.expect(helpers.isTesting()).toBe(false);
+        });
+      },
+    },
+    {
+      name: 'isDevelopment() is true under NODE_ENV=development',
+      run: (ctx) => {
+        withEnv({ NODE_ENV: 'development', BXM_BUILD_MODE: null }, () => {
+          ctx.expect(helpers.isDevelopment()).toBe(true);
+        });
+      },
+    },
+    {
+      name: 'isDevelopment() is false when BXM_BUILD_MODE=true',
+      run: (ctx) => {
+        withEnv({ NODE_ENV: null, BXM_BUILD_MODE: 'true' }, () => {
+          ctx.expect(helpers.isDevelopment()).toBe(false);
+        });
+      },
+    },
+    {
+      name: 'attachTo() mixes helpers into a constructor + its prototype',
+      run: (ctx) => {
+        function FakeManager() {}
+        helpers.attachTo(FakeManager);
+        ctx.expect(typeof FakeManager.isDevelopment).toBe('function');
+        ctx.expect(typeof FakeManager.prototype.isDevelopment).toBe('function');
+        ctx.expect(typeof FakeManager.isTesting).toBe('function');
+        ctx.expect(typeof FakeManager.prototype.isTesting).toBe('function');
+        ctx.expect(typeof FakeManager.getVersion).toBe('function');
+      },
+    },
+    {
+      name: 'getVersion() reads cwd package.json#version in Node context',
+      run: (ctx) => {
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'bxm-modehelpers-'));
+        fs.writeFileSync(path.join(tmp, 'package.json'), JSON.stringify({ name: 'x', version: '9.9.9' }));
+        const oldCwd = process.cwd();
+        try {
+          process.chdir(tmp);
+          ctx.expect(helpers.getVersion()).toBe('9.9.9');
+        } finally {
+          process.chdir(oldCwd);
+          fs.rmSync(tmp, { recursive: true, force: true });
+        }
+      },
+    },
+  ],
+};

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

@@ -0,0 +1,14 @@
+// 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.)
+
+module.exports = {
+  layer: 'view',
+  context: 'options',
+  description: 'view/options — DOM + context attribute',
+  run: async (ctx) => {
+    ctx.expect(document.body.dataset.bxmContext).toBe('options');
+    ctx.expect(document.title).toContain('Options');
+  },
+};

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

@@ -0,0 +1,51 @@
+// 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.
+
+module.exports = {
+  type: 'suite',
+  layer: 'view',
+  context: 'popup',
+  description: 'view/popup — DOM + chrome surface',
+  tests: [
+    {
+      name: 'document is present and body has data-bxm-context="popup"',
+      run: async (ctx) => {
+        ctx.expect(typeof document).toBe('object');
+        ctx.expect(document.body.dataset.bxmContext).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: 'bxm:test:ping' });
+        ctx.expect(reply.pong).toBe(true);
+        ctx.expect(typeof reply.ts).toBe('number');
+      },
+    },
+  ],
+};

package/dist/test/suites/view/sidepanel.test.js

@@ -0,0 +1,14 @@
+// View-layer test for the sidepanel context. Most consumers of BXM use
+// chrome.sidePanel for the Chrome 114+ UI panel surface — verify that
+// the test harness can target it just like popup/options.
+
+module.exports = {
+  layer: 'view',
+  context: 'sidepanel',
+  description: 'view/sidepanel — DOM + context attribute',
+  run: async (ctx) => {
+    ctx.expect(document.body.dataset.bxmContext).toBe('sidepanel');
+    ctx.expect(document.title).toContain('Side Panel');
+    ctx.expect(typeof chrome.runtime.id).toBe('string');
+  },
+};