@omega.js/extension 0.1.0

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

@@ -0,0 +1,48 @@
+// 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'));
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  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,53 @@
+// 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'));
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+// 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 = defineCases({
+  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,82 @@
+// 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'));
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  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);
+      },
+    },
+    {
+      // wave-5 F8: the window[api] probe ran AFTER the chrome probe and won —
+      // in any DOM context window.history (the page's History object) shadowed
+      // chrome.history even when the extension held the permission.
+      name: 'chrome API wins over a window global of the same name (history shadow)',
+      run: (ctx) => {
+        const modPath = require.resolve(path.join(__dirname, '..', '..', '..', 'lib', 'extension.js'));
+        const chromeHistory = { search: () => [] };
+        global.chrome = { history: chromeHistory };
+        global.window = { history: { back: () => {} } }; // DOM History imposter
+        delete require.cache[modPath];
+        try {
+          const fresh = require(modPath);
+          ctx.expect(fresh.history).toBe(chromeHistory);
+        } finally {
+          delete global.chrome;
+          delete global.window;
+          delete require.cache[modPath]; // next require re-resolves in a clean Node context
+        }
+      },
+    },
+    {
+      // wave-5 F8: `self.api = browser.extension[api]` (literal `.api` typo) —
+      // the browser.extension fallback never landed on the named slot.
+      name: 'browser.extension fallback lands on the named API slot (typo pin)',
+      run: (ctx) => {
+        const modPath = require.resolve(path.join(__dirname, '..', '..', '..', 'lib', 'extension.js'));
+        const extTabs = { query: () => [] };
+        global.browser = { extension: { tabs: extTabs } };
+        delete require.cache[modPath];
+        try {
+          const fresh = require(modPath);
+          ctx.expect(fresh.tabs).toBe(extTabs);
+          ctx.expect(fresh.api).toBeUndefined(); // the junk `.api` property must not exist
+        } finally {
+          delete global.browser;
+          delete require.cache[modPath];
+        }
+      },
+    },
+  ],
+});

package/dist/test/suites/build/framework-deps.test.js

@@ -0,0 +1,176 @@
+// Framework-provided dependencies (#87), extension half: a CONSUMER module requires any
+// library @omega.js/extension declares by BARE specifier and it resolves from the
+// FRAMEWORK's own installation — the framework's copy wins even when the consumer
+// installed its own. The mechanism is the resolve hook @omega.js/devkit's bundle
+// wrapper composes from the framework's declared dependency set
+// ([#738](https://github.com/Omega-JS-Stack/omega/issues/738), replacing the ordered
+// `resolve.modules` webpack used), so these tests build a real consumer entry through
+// the wrapper and read the resolved paths back out of the metafile.
+//
+// Both consumer layers live in a temp dir OUTSIDE this monorepo and carry their own
+// node_modules — the same layouts npm produces for a real brand: shared/hoisted copies
+// in the consumer's node_modules, and a framework-private nested copy exactly when the
+// consumer declares a conflicting version. Mirrors
+// @omega.js/desktop's src/test/suites/build/framework-deps.test.js.
+
+const fs   = require('fs');
+const os   = require('os');
+const path = require('path');
+
+const FRAMEWORK_ROOT = path.resolve(__dirname, '..', '..', '..', '..');
+const { bundle } = require('../../../vendor/devkit/bundle.js');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+// Framework-declared deps sampled by the first test: two bare packages plus a subpath
+// import, all of them real `dependencies` of @omega.js/extension and all browser-safe
+// (the extension bundles target the web).
+const SAMPLE = ['json5', 'lodash', 'lodash/merge'];
+
+function write(file, contents) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, contents);
+}
+
+function writePackage(dir, name, version, extra) {
+  write(path.join(dir, 'package.json'), JSON.stringify({ name, version, main: 'index.js', ...extra }));
+}
+
+function packageName(spec) {
+  return spec.startsWith('@') ? spec.split('/').slice(0, 2).join('/') : spec.split('/')[0];
+}
+
+// The installed COPY a specifier resolves to from `fromRoot` — the package directory,
+// not the entry file: which FILE inside it a bundle lands on is chosen by the target's
+// export conditions (a web build takes the browser entry where node's require takes the
+// CJS one), while the contract here is about which copy.
+function packageDirFor(spec, fromRoot) {
+  const name   = packageName(spec);
+  const marker = `${path.sep}node_modules${path.sep}${name}${path.sep}`;
+  const entry  = require.resolve(spec, { paths: [fromRoot] });
+  return entry.slice(0, entry.indexOf(marker) + marker.length - 1);
+}
+
+// Build `src/entry.js` the way the extension lane builds a component bundle, and
+// return every input path the bundle pulled in (absolute, real).
+async function compile({ projectRoot, frameworkRoot }) {
+  const result = await bundle({
+    frameworkRoot,
+    entries: [path.join(projectRoot, 'src', 'entry.js')],
+    outfile: path.join(projectRoot, 'dist', 'entry.bundle.js'),
+    platform: 'browser',
+    format: 'iife',
+    dev: true,
+  });
+
+  return Object.keys(result.metafile.inputs).map((input) => path.resolve(input));
+}
+
+// Whether the bundle pulled a file out of exactly this package directory.
+function bundledFrom(inputs, dir) {
+  return inputs.some((input) => input.startsWith(dir + path.sep));
+}
+
+// A real consumer install: the framework's deps hoisted into the consumer's own
+// node_modules (symlinked to the real installed copies), no nested copies anywhere.
+function stageHoistedConsumer(specs) {
+  // realpath: macOS' /var is a symlink to /private/var, and the resolved module
+  // paths a bundler reports are real paths.
+  const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'omega-extension-framework-deps-')));
+  writePackage(root, 'consumer-extension', '1.0.0');
+
+  specs.forEach((spec) => {
+    const link = path.join(root, 'node_modules', packageName(spec));
+    fs.mkdirSync(path.dirname(link), { recursive: true });
+    if (!fs.existsSync(link)) fs.symlinkSync(packageDirFor(spec, FRAMEWORK_ROOT), link, 'dir');
+  });
+
+  write(path.join(root, 'src', 'entry.js'), specs.map((s) => `require(${JSON.stringify(s)});`).join('\n'));
+  return root;
+}
+
+// A real consumer install with a CONFLICT: the consumer declares its own version of
+// `dupe-pkg`, so npm keeps that copy hoisted and nests the framework's version under
+// the framework package. `shared-pkg` has no conflict — one hoisted copy for both.
+function stageConflictInstall() {
+  const root          = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'omega-extension-framework-deps-dupe-')));
+  const consumerNm    = path.join(root, 'node_modules');
+  const frameworkRoot = path.join(consumerNm, '@omega.js', 'extension');
+
+  writePackage(root, 'consumer-extension', '1.0.0', { dependencies: { 'dupe-pkg': '^1.0.0' } });
+
+  writePackage(path.join(consumerNm, 'dupe-pkg'), 'dupe-pkg', '1.0.0');
+  write(path.join(consumerNm, 'dupe-pkg', 'index.js'), 'module.exports = "CONSUMER_COPY";');
+  write(path.join(consumerNm, 'dupe-pkg', 'sub.js'), 'module.exports = "CONSUMER_SUBPATH";');
+
+  writePackage(path.join(consumerNm, 'shared-pkg'), 'shared-pkg', '1.0.0');
+  write(path.join(consumerNm, 'shared-pkg', 'index.js'), 'module.exports = "SHARED_COPY";');
+
+  // The fixture framework must resolve esbuild the way the real one does — it
+  // has no node_modules of its own, so the monorepo's hoisted copy is what a
+  // walk up from a temp dir must find. Staging it under the CONSUMER's
+  // node_modules is that walk.
+  fs.symlinkSync(packageDirFor('esbuild', FRAMEWORK_ROOT), path.join(consumerNm, 'esbuild'), 'dir');
+
+  writePackage(frameworkRoot, '@omega.js/extension', '1.0.0', {
+    dependencies: { 'dupe-pkg': '^2.0.0', 'shared-pkg': '^1.0.0' },
+  });
+  const nested = path.join(frameworkRoot, 'node_modules', 'dupe-pkg');
+  writePackage(nested, 'dupe-pkg', '2.0.0');
+  write(path.join(nested, 'index.js'), 'module.exports = "FRAMEWORK_COPY";');
+  write(path.join(nested, 'sub.js'), 'module.exports = "FRAMEWORK_SUBPATH";');
+
+  write(path.join(root, 'src', 'entry.js'), [
+    "require('dupe-pkg');",
+    "require('dupe-pkg/sub');",
+    "require('shared-pkg');",
+  ].join('\n'));
+
+  return { root, frameworkRoot };
+}
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'build',
+  description: 'framework-deps — a consumer bundle resolves framework-declared deps from the framework',
+  timeout: 60000,
+  tests: [
+    {
+      name: 'bare specifiers (and subpaths) of framework-declared deps resolve from the framework installation',
+      run: async (ctx) => {
+        const projectRoot = stageHoistedConsumer(SAMPLE);
+        try {
+          const inputs = await compile({ projectRoot, frameworkRoot: FRAMEWORK_ROOT });
+          SAMPLE.forEach((spec) => {
+            ctx.expect(bundledFrom(inputs, packageDirFor(spec, FRAMEWORK_ROOT))).toBe(true);
+          });
+        } finally {
+          fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+      },
+    },
+
+    {
+      name: "the framework's copy wins over a consumer-declared duplicate, subpaths included",
+      run: async (ctx) => {
+        const { root, frameworkRoot } = stageConflictInstall();
+        try {
+          const inputs = await compile({ projectRoot: root, frameworkRoot });
+          const built = fs.readFileSync(path.join(root, 'dist', 'entry.bundle.js'), 'utf8');
+
+          // Both the bare specifier and the subpath land on the framework's nested copy…
+          ctx.expect(built).toContain('FRAMEWORK_COPY');
+          ctx.expect(built).toContain('FRAMEWORK_SUBPATH');
+          ctx.expect(built.includes('CONSUMER_COPY')).toBe(false);
+          ctx.expect(built.includes('CONSUMER_SUBPATH')).toBe(false);
+          ctx.expect(bundledFrom(inputs, path.join(frameworkRoot, 'node_modules', 'dupe-pkg'))).toBe(true);
+
+          // …while a dep with no conflict keeps resolving to the single hoisted copy,
+          // shared by the framework and the consumer alike.
+          ctx.expect(bundledFrom(inputs, path.join(root, 'node_modules', 'shared-pkg'))).toBe(true);
+        } finally {
+          fs.rmSync(root, { recursive: true, force: true });
+        }
+      },
+    },
+  ],
+});

package/dist/test/suites/build/global-handlers.test.js

@@ -0,0 +1,70 @@
+// Build-layer pin for setupGlobalHandlers(): it is called BARE at top level
+// (before any Manager exists) so that MV3 registers the SW listeners before any
+// async work. In an ES module `this` is undefined there, so every `this.<x>`
+// inside that function is a TypeError the moment its listener fires — which is
+// exactly what broke the fresh-install welcome tab ([#90]): the install logger
+// was read off `this`.
+//
+// background.js is a browser-context ES module (top-level importScripts +
+// firebase imports), so node cannot import it — this pins the SOURCE, like
+// cache-warming.test.js does. The whole class of bug is covered, not just the
+// two lines that regressed: NOTHING inside the function body may touch `this`.
+
+const fs = require('fs');
+const path = require('path');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+const SOURCE = fs.readFileSync(path.join(__dirname, '..', '..', '..', 'background.js'), 'utf8');
+
+// The body of `function setupGlobalHandlers() { … }`, by brace matching.
+function globalHandlersBody() {
+  const start = SOURCE.indexOf('function setupGlobalHandlers() {');
+  if (start === -1) { return null; }
+  let depth = 0;
+  for (let i = SOURCE.indexOf('{', start); i < SOURCE.length; i++) {
+    if (SOURCE[i] === '{') { depth++; }
+    if (SOURCE[i] === '}') {
+      depth--;
+      if (depth === 0) { return SOURCE.slice(start, i + 1); }
+    }
+  }
+  return null;
+}
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'build',
+  description: 'background.js setupGlobalHandlers — no `this` in a bare-called function (#90)',
+  tests: [
+    {
+      name: 'it is called bare at top level, before the Manager class',
+      run: (ctx) => {
+        ctx.expect(SOURCE).toMatch(/^setupGlobalHandlers\(\);$/m);
+        ctx.expect(SOURCE.indexOf('setupGlobalHandlers();')).toBeLessThan(SOURCE.indexOf('class Manager'));
+      },
+    },
+    {
+      name: 'its body never references `this` — every listener there would throw',
+      run: (ctx) => {
+        const body = globalHandlersBody();
+        ctx.expect(typeof body).toBe('string');
+        const offenders = (body.match(/\bthis\s*[.[]/g) || []);
+        ctx.expect(offenders.length).toBe(0);
+      },
+    },
+    {
+      name: 'the install listener logs through the module-level installLogger',
+      run: (ctx) => {
+        // Module scope, not an instance property
+        ctx.expect(SOURCE).toMatch(/^const installLogger = new LoggerLite\('install'\);$/m);
+        ctx.expect(/this\.installLogger/.test(SOURCE)).toBe(false);
+
+        const body = globalHandlersBody();
+        // Both fresh-install lines, and the tab open they guard
+        ctx.expect(body).toMatch(/installLogger\.log\('No website configured, skipping install page'\)/);
+        ctx.expect(body).toMatch(/installLogger\.log\('Opening install page:', installedUrl\)/);
+        ctx.expect(body).toMatch(/extension\.tabs\.create\(\{ url: installedUrl \}\)/);
+      },
+    },
+  ],
+});

package/dist/test/suites/build/icon-sheet.test.js

@@ -0,0 +1,74 @@
+// Build-layer pins for the shared icon sheet (#183): icon presentation lives
+// ONCE in @omega.js/web and is vendored here at prepare (package.json
+// omega.vendorAssets → dist/assets/css/core/_fontawesome.scss), so extension
+// surfaces ship the same square glyph-centered box and animation utilities web
+// has instead of the commented-out stub that shipped no icon css at all.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+const PACKAGE_ROOT = path.join(__dirname, '..', '..', '..', '..');
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'build',
+  description: 'icon sheet: vendored cross-target sheet + entry wiring',
+  tests: [
+    {
+      // Fidelity to the web source is the devkit vendor unit test's job (and
+      // the prepare hook fails loud on a missing source). Here we pin that
+      // the shipped sheet carries the contract. No @omega.js/web reference:
+      // dist code never names publishable packages it doesn't depend on.
+      name: 'vendored icon sheet ships the box and the parked animations',
+      run: (ctx) => {
+        const vendored = path.join(PACKAGE_ROOT, 'dist', 'assets', 'css', 'core', '_fontawesome.scss');
+        ctx.expect(fs.existsSync(vendored)).toBe(true);
+
+        const sheet = fs.readFileSync(vendored, 'utf8');
+        ctx.expect(sheet.includes('i[data-omega-fa]')).toBe(true);
+        ctx.expect(sheet.includes('@keyframes fa-spin')).toBe(true);
+        ctx.expect(sheet.includes('prefers-reduced-motion')).toBe(true);
+      },
+    },
+    {
+      name: 'entry compiles the box rule and the reduced-motion park into the output',
+      run: (ctx) => {
+        const sass = require('sass');
+
+        // The entry pulls '_component-specific' from the CONSUMER's dist at
+        // build time (the sass task generates a stub there), so stub it here.
+        const stubDir = fs.mkdtempSync(path.join(os.tmpdir(), 'omega-ext-icons-'));
+        fs.writeFileSync(path.join(stubDir, '_component-specific.scss'), '// test stub\n');
+
+        try {
+          const css = sass.compile(path.join(PACKAGE_ROOT, 'dist', 'assets', 'css', 'omega-extension.scss'), {
+            loadPaths: [
+              path.join(PACKAGE_ROOT, 'dist', 'assets', 'css'),
+              path.join(PACKAGE_ROOT, 'dist', 'assets', 'themes', 'classy'),
+              stubDir,
+            ],
+            quietDeps: true,
+            silenceDeprecations: ['import', 'global-builtin', 'color-functions'],
+          }).css;
+
+          // The shared client renderer stamps data-omega-fa on the <i> it fills
+          // (src/lib/icons.js), so that is the hook the box keys on.
+          const box = css.match(/i\[data-omega-fa\] \{[^}]*\}/);
+          ctx.expect(box !== null).toBe(true);
+          ctx.expect(box[0].includes('display: inline-flex')).toBe(true);
+          ctx.expect(box[0].includes('width: 1em')).toBe(true);
+          ctx.expect(box[0].includes('height: 1em')).toBe(true);
+
+          ctx.expect(css.includes('@keyframes fa-spin')).toBe(true);
+
+          // Its own park block, not just any reduced-motion at-rule the theme ships.
+          ctx.expect(/@media \(prefers-reduced-motion: reduce\) \{\s*\.fa-spin,[^{]*\{\s*animation: none/.test(css)).toBe(true);
+        } finally {
+          fs.rmSync(stubDir, { recursive: true, force: true });
+        }
+      },
+    },
+  ],
+});

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

@@ -0,0 +1,61 @@
+// Build-layer test for lib/logger-lite.js — verifies the runtime identity tag
+// [@omega.js/extension:name] (no timestamp — devtools stamps runtime lines, #12)
+// and the five method surface (log/error/warn/info/debug).
+
+const path = require('path');
+
+const Logger = require(path.join(__dirname, '..', '..', '..', 'lib', 'logger-lite.js'));
+const defineCases = require('../../../vendor/devkit/test/define-cases.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 = defineCases({
+  type: 'suite',
+  layer: 'build',
+  description: 'lib/logger-lite — identity tag 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 [@omega.js/extension:name] and no timestamp',
+      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).toBe('[@omega.js/extension: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]).toBe('[@omega.js/extension:err-comp]');
+        ctx.expect(captured[0][1]).toBe('boom');
+      },
+    },
+  ],
+});