@omega.js/desktop 0.1.0

package/dist/test/suites/renderer/fontawesome.test.js

@@ -0,0 +1,190 @@
+// Renderer-layer suite — verifies the `window.desktop.fontawesome` bridge and the
+// REAL auto-render pipeline: an `<i class="fa-solid fa-*">` inserted into the
+// live DOM gets the bundled SVG injected by renderer.js's MutationObserver.
+//
+// Runs inside a hidden BrowserWindow. Test bodies are reconstructed via
+// `new Function('ctx', body)` — no closures over module scope, so each test
+// inlines its own poll helper.
+
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'renderer',
+  description: 'fontawesome bridge + auto-render',
+  tests: [
+    {
+      name: 'window.desktop.fontawesome.get is exposed and resolves an SVG',
+      run: async (ctx) => {
+        ctx.expect(typeof window.desktop.fontawesome.get).toBe('function');
+        const svg = await window.desktop.fontawesome.get('play');
+        ctx.expect(typeof svg).toBe('string');
+        ctx.expect(svg.startsWith('<svg ')).toBe(true);
+        ctx.expect(svg.includes('fill="currentColor"')).toBe(true);
+      },
+    },
+    {
+      name: 'unknown icons resolve to null over the bridge',
+      run: async (ctx) => {
+        const svg = await window.desktop.fontawesome.get('definitely-not-an-icon-xyz');
+        ctx.expect(svg).toBe(null);
+      },
+    },
+    {
+      name: 'an inserted <i class="fa-solid fa-play"> gets the SVG injected',
+      run: async (ctx) => {
+        const until = async (fn) => {
+          const t0 = Date.now();
+          while (!fn()) {
+            if (Date.now() - t0 > 3000) throw new Error('timed out waiting for icon injection');
+            await new Promise((r) => setTimeout(r, 25));
+          }
+        };
+
+        const el = document.createElement('i');
+        el.className = 'fa-solid fa-play me-2';
+        document.body.appendChild(el);
+
+        await until(() => el.querySelector('svg'));
+        const svg = el.querySelector('svg');
+        ctx.expect(svg.getAttribute('width')).toBe('1em');
+        ctx.expect(svg.getAttribute('fill')).toBe('currentColor');
+        ctx.expect(el.dataset.omegaFa).toBe('solid/play');
+        el.remove();
+      },
+    },
+    {
+      name: 'injected SVGs render with overflow visible (FA Pro 7 glyphs overshoot their viewBox)',
+      run: async (ctx) => {
+        const until = async (fn) => {
+          const t0 = Date.now();
+          while (!fn()) {
+            if (Date.now() - t0 > 3000) throw new Error('timed out waiting for icon injection');
+            await new Promise((r) => setTimeout(r, 25));
+          }
+        };
+
+        // fa-lock draws its shackle above the viewBox top (y=-32 in
+        // 0 0 384 512) — with the SVG-root default (overflow: hidden) the
+        // shackle clips flat. The COMPUTED style is the proof the fix
+        // reaches the paint, not just the markup.
+        const el = document.createElement('i');
+        el.className = 'fa-solid fa-lock';
+        document.body.appendChild(el);
+
+        await until(() => el.querySelector('svg'));
+        ctx.expect(getComputedStyle(el.querySelector('svg')).overflow).toBe('visible');
+        el.remove();
+      },
+    },
+    {
+      name: 'fa-brands picks the brands style; modifier classes are not names',
+      run: async (ctx) => {
+        const until = async (fn) => {
+          const t0 = Date.now();
+          while (!fn()) {
+            if (Date.now() - t0 > 3000) throw new Error('timed out waiting for icon injection');
+            await new Promise((r) => setTimeout(r, 25));
+          }
+        };
+
+        const el = document.createElement('i');
+        el.className = 'fa-brands fa-fw fa-github';
+        document.body.appendChild(el);
+
+        await until(() => el.querySelector('svg'));
+        ctx.expect(el.dataset.omegaFa).toBe('brands/github'); // not 'fw'
+        el.remove();
+      },
+    },
+    {
+      name: 'Pro family/weight classes request the composed style — never a wrong-style fallback (cp111)',
+      run: async (ctx) => {
+        const until = async (fn) => {
+          const t0 = Date.now();
+          while (!fn()) {
+            if (Date.now() - t0 > 3000) throw new Error('timed out waiting for icon mark');
+            await new Promise((r) => setTimeout(r, 25));
+          }
+        };
+
+        // Without a Pro set, `fa-light fa-play` must stay EMPTY (style
+        // 'light' resolves null) — the pre-cp111 renderer ignored the class
+        // and wrongly injected the SOLID glyph. With Pro supplied it lights
+        // up for real; either way an SVG here may only be a non-solid one.
+        const el = document.createElement('i');
+        el.className = 'fa-light fa-play';
+        document.body.appendChild(el);
+
+        await until(() => el.dataset.omegaFa);
+        ctx.expect(el.dataset.omegaFa).toBe('light/play'); // family/weight classes are never names
+        const lightSvg = await window.desktop.fontawesome.get('play', 'light');
+        await new Promise((r) => setTimeout(r, 150));
+        ctx.expect((el.querySelector('svg') !== null)).toBe(lightSvg !== null);
+
+        // sharp + weight composes: `fa-sharp fa-light` asks for sharp-light.
+        const sharpSvg = await window.desktop.fontawesome.get('play', 'sharp-light');
+        const el2 = document.createElement('i');
+        el2.className = 'fa-sharp fa-light fa-play';
+        document.body.appendChild(el2);
+        await until(() => el2.dataset.omegaFa === 'sharp-light/play');
+        await new Promise((r) => setTimeout(r, 150));
+        ctx.expect((el2.querySelector('svg') !== null)).toBe(sharpSvg !== null);
+
+        el.remove();
+        el2.remove();
+      },
+    },
+    {
+      name: 'changing fa-* classes on a RENDERED element re-renders it in place (cp112)',
+      run: async (ctx) => {
+        const until = async (fn) => {
+          const t0 = Date.now();
+          while (!fn()) {
+            if (Date.now() - t0 > 3000) throw new Error('timed out waiting for icon swap');
+            await new Promise((r) => setTimeout(r, 25));
+          }
+        };
+
+        const el = document.createElement('i');
+        el.className = 'fa-solid fa-play';
+        document.body.appendChild(el);
+        await until(() => el.dataset.omegaFa === 'solid/play' && el.querySelector('svg'));
+        const playSvg = el.innerHTML;
+
+        // The dynamic MUST: set fa-{icon} via JS on an EXISTING element.
+        el.className = 'fa-solid fa-lock';
+        await until(() => el.dataset.omegaFa === 'solid/lock' && el.querySelector('svg'));
+        ctx.expect(el.innerHTML !== playSvg).toBe(true);
+
+        // Dropping the icon classes clears the rendered SVG.
+        el.className = 'me-2';
+        await until(() => !el.dataset.omegaFa);
+        ctx.expect(el.querySelector('svg')).toBe(null);
+        el.remove();
+      },
+    },
+    {
+      name: 'unknown icon names leave the element empty (marked, no SVG)',
+      run: async (ctx) => {
+        const until = async (fn) => {
+          const t0 = Date.now();
+          while (!fn()) {
+            if (Date.now() - t0 > 3000) throw new Error('timed out waiting for icon mark');
+            await new Promise((r) => setTimeout(r, 25));
+          }
+        };
+
+        const el = document.createElement('i');
+        el.className = 'fa-solid fa-definitely-not-an-icon-xyz';
+        document.body.appendChild(el);
+
+        await until(() => el.dataset.omegaFa);
+        // Give the (null) resolution a beat to land, then assert no SVG appeared.
+        await new Promise((r) => setTimeout(r, 150));
+        ctx.expect(el.querySelector('svg')).toBe(null);
+        el.remove();
+      },
+    },
+  ],
+});

package/dist/test/suites/renderer/round-trip.test.js

@@ -0,0 +1,107 @@
+// Renderer-layer round-trip tests. The window-omega-surface suite asserts the SHAPE
+// of `window.desktop.*` (functions exist). This suite asserts the BEHAVIOR — that calls
+// from a real renderer process land in main, get processed, and the response or
+// side-effect comes back correctly.
+//
+// Test bodies run inside a BrowserWindow with only `ctx` and `window` in scope —
+// no closures, no require. The main harness pre-registered a couple of test-only
+// IPC channels (desktop:__test:echo, desktop:__test:read-last-log) for these tests to use.
+
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'renderer',
+  description: 'renderer ⇄ main round-trip',
+  tests: [
+    {
+      name: 'window.desktop.ipc.invoke: renderer → main → response',
+      run: async (ctx) => {
+        // Main registered the desktop:__test:echo channel — call it via the bridged ipc.
+        const result = await window.desktop.ipc.invoke('desktop:__test:echo', { hello: 'from-renderer', n: 7 });
+        ctx.expect(result).toBeDefined();
+        ctx.expect(result.echoed).toEqual({ hello: 'from-renderer', n: 7 });
+        ctx.expect(typeof result.ts).toBe('number');
+      },
+    },
+    {
+      name: 'window.desktop.ipc.invoke: unhandled channel rejects',
+      run: async (ctx) => {
+        let threw;
+        try {
+          await window.desktop.ipc.invoke('desktop:__test:does-not-exist');
+        } catch (e) { threw = e; }
+        ctx.expect(threw).toBeDefined();
+      },
+    },
+    {
+      name: 'window.desktop.logger.log forwards to main where it can be read back',
+      run: async (ctx) => {
+        const marker = `__em_test_log_${Date.now()}_${Math.random()}`;
+        window.desktop.logger.log(marker, { extra: 'payload' });
+        // Give main a moment to receive (IPC send is async, no callback).
+        await new Promise((r) => setTimeout(r, 50));
+        const last = await window.desktop.ipc.invoke('desktop:__test:read-last-log');
+        ctx.expect(last).toBeDefined();
+        // The forwarded payload shape is `{ scope, level, args }` — verify our
+        // marker appears in the args. Don't tie to exact shape since the forwarder
+        // serializes via JSON for cloneability.
+        const serialized = JSON.stringify(last);
+        ctx.expect(serialized).toContain(marker);
+      },
+    },
+    {
+      name: 'window.desktop.logger.warn also forwards',
+      run: async (ctx) => {
+        const marker = `__em_test_warn_${Date.now()}_${Math.random()}`;
+        window.desktop.logger.warn(marker);
+        await new Promise((r) => setTimeout(r, 50));
+        const last = await window.desktop.ipc.invoke('desktop:__test:read-last-log');
+        const serialized = JSON.stringify(last);
+        ctx.expect(serialized).toContain(marker);
+      },
+    },
+    {
+      name: 'window.desktop.storage.set → window.desktop.storage.onChange fires across IPC',
+      run: async (ctx) => {
+        // Subscribe FIRST so we don't miss the broadcast.
+        const key = `__em_renderer_change_${Date.now()}`;
+        let received = null;
+        const off = window.desktop.storage.onChange(key, (payload) => { received = payload; });
+        try {
+          await window.desktop.storage.set(key, { changed: true });
+          // Allow the broadcast to round-trip back.
+          for (let i = 0; i < 20 && !received; i++) {
+            await new Promise((r) => setTimeout(r, 50));
+          }
+          ctx.expect(received).toBeDefined();
+          ctx.expect(received.key).toBe(key);
+        } finally {
+          off?.();
+          await window.desktop.storage.delete(key);
+        }
+      },
+    },
+    {
+      name: 'window.desktop.autoUpdater.getStatus round-trips main state',
+      run: async (ctx) => {
+        const status = await window.desktop.autoUpdater.getStatus();
+        ctx.expect(status).toBeDefined();
+        ctx.expect(['idle', 'checking', 'available', 'downloading', 'downloaded', 'not-available', 'error'])
+          .toContain(status.code);
+      },
+    },
+    {
+      name: 'window.desktop.autoUpdater.onStatus subscribes (returns unsub fn)',
+      run: (ctx) => {
+        // The status broadcasts from main are best-effort — outside dev-simulation mode
+        // the auto-updater may not transition during the test window. Just verify the
+        // subscription API works (returns an unsub function) — dev-simulation flow is
+        // exercised separately in main-layer auto-updater.test.js.
+        const off = window.desktop.autoUpdater.onStatus(() => {});
+        ctx.expect(typeof off).toBe('function');
+        off();
+      },
+    },
+  ],
+});

package/dist/test/suites/renderer/theme.test.js

@@ -0,0 +1,118 @@
+// Renderer-layer suite — verifies the `window.desktop.theme` surface and the REAL
+// propagation mechanism: main sets nativeTheme.themeSource → this renderer's
+// `prefers-color-scheme` media query flips → matchMedia listeners fire.
+//
+// Runs inside a hidden BrowserWindow. Test bodies are reconstructed via
+// `new Function('ctx', body)` — no closures over module scope, so each test
+// inlines its own poll helper.
+//
+// The last test restores 'system' + clears the persisted override so the
+// harness leaves no theme residue for later suites.
+
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'renderer',
+  description: 'theme surface + matchMedia propagation',
+  tests: [
+    {
+      name: 'window.desktop.theme has get / set / onChange',
+      run: (ctx) => {
+        ctx.expect(typeof window.desktop.theme.get).toBe('function');
+        ctx.expect(typeof window.desktop.theme.set).toBe('function');
+        ctx.expect(typeof window.desktop.theme.onChange).toBe('function');
+      },
+    },
+    {
+      name: 'get() returns a { source, resolved } pair',
+      run: async (ctx) => {
+        const state = await window.desktop.theme.get();
+        ctx.expect(['system', 'light', 'dark'].includes(state.source)).toBe(true);
+        ctx.expect(['light', 'dark'].includes(state.resolved)).toBe(true);
+      },
+    },
+    {
+      name: 'set("dark") flips prefers-color-scheme in this renderer',
+      run: async (ctx) => {
+        const until = async (fn) => {
+          const t0 = Date.now();
+          while (!fn()) {
+            if (Date.now() - t0 > 3000) throw new Error('timed out waiting for media query flip');
+            await new Promise((r) => setTimeout(r, 25));
+          }
+        };
+        const media = window.matchMedia('(prefers-color-scheme: dark)');
+
+        const state = await window.desktop.theme.set('dark');
+        ctx.expect(state).toEqual({ source: 'dark', resolved: 'dark' });
+        await until(() => media.matches === true);
+        ctx.expect(media.matches).toBe(true);
+      },
+    },
+    {
+      name: 'set("light") flips it back',
+      run: async (ctx) => {
+        const until = async (fn) => {
+          const t0 = Date.now();
+          while (!fn()) {
+            if (Date.now() - t0 > 3000) throw new Error('timed out waiting for media query flip');
+            await new Promise((r) => setTimeout(r, 25));
+          }
+        };
+        const media = window.matchMedia('(prefers-color-scheme: dark)');
+
+        const state = await window.desktop.theme.set('light');
+        ctx.expect(state).toEqual({ source: 'light', resolved: 'light' });
+        await until(() => media.matches === false);
+        ctx.expect(media.matches).toBe(false);
+      },
+    },
+    {
+      name: 'onChange fires on a theme flip and unsubscribes cleanly',
+      run: async (ctx) => {
+        const events = [];
+        const unsub = window.desktop.theme.onChange((payload) => events.push(payload));
+
+        const current = await window.desktop.theme.get();
+        const target = current.resolved === 'dark' ? 'light' : 'dark';
+        await window.desktop.theme.set(target);
+
+        const t0 = Date.now();
+        while (events.length === 0) {
+          if (Date.now() - t0 > 3000) throw new Error('timed out waiting for onChange');
+          await new Promise((r) => setTimeout(r, 25));
+        }
+        ctx.expect(events[0]).toEqual({ resolved: target });
+
+        unsub();
+        const seen = events.length;
+        await window.desktop.theme.set(target === 'dark' ? 'light' : 'dark');
+        await new Promise((r) => setTimeout(r, 200));
+        ctx.expect(events.length).toBe(seen);
+      },
+    },
+    {
+      name: 'set() rejects invalid sources',
+      run: async (ctx) => {
+        let threw = false;
+        try {
+          await window.desktop.theme.set('midnight');
+        } catch (e) {
+          threw = true;
+        }
+        ctx.expect(threw).toBe(true);
+      },
+    },
+    {
+      name: 'restore: back to system + no persisted override left behind',
+      run: async (ctx) => {
+        const state = await window.desktop.theme.set('system');
+        ctx.expect(state.source).toBe('system');
+        await window.desktop.storage.delete('theme.appearance');
+        const has = await window.desktop.storage.has('theme.appearance');
+        ctx.expect(has).toBe(false);
+      },
+    },
+  ],
+});

package/dist/test/suites/renderer/tooltips.test.js

@@ -0,0 +1,166 @@
+// Renderer-layer suite — verifies @omega.js/desktop's zero-setup Bootstrap tooltips: the
+// prebuilt Bootstrap bundle (Popper inlined) loads, every
+// `[data-bs-toggle="tooltip"]` element is auto-initialized (including ones
+// inserted after boot), title changes update the live instance, and removal
+// disposes it. Real DOM, real Bootstrap — the tip element actually renders.
+//
+// The harness wires the renderer Manager in the PRELOAD world (contextIsolation
+// — see harness/renderer-preload.js), so instance-level assertions and the
+// show trigger go through the `window.__emTestTooltip` probe (page-world
+// synthetic mouse events can't reach preload-world listeners). Real
+// hover-in-one-world behavior + `window.bootstrap` page exposure are covered
+// by consumer boot suites.
+//
+// Runs inside a hidden BrowserWindow. Test bodies are reconstructed via
+// `new Function('ctx', body)` — no closures over module scope, so each test
+// inlines its own poll helper.
+
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'renderer',
+  description: 'bootstrap tooltips auto-init',
+  tests: [
+    {
+      name: 'the Bootstrap bundle loads — Tooltip is available',
+      run: (ctx) => {
+        if (!window.__emTestTooltip.available()) {
+          throw new Error(`Bootstrap bundle failed to load: ${window.__emTestTooltip.error() || '(no require error — wiring bailed earlier)'}`);
+        }
+        ctx.expect(window.__emTestTooltip.available()).toBe(true);
+      },
+    },
+    {
+      name: 'an inserted [data-bs-toggle="tooltip"] element is auto-initialized and renders its title',
+      run: async (ctx) => {
+        const until = async (fn) => {
+          const t0 = Date.now();
+          while (!fn()) {
+            if (Date.now() - t0 > 3000) throw new Error('timed out waiting for tooltip');
+            await new Promise((r) => setTimeout(r, 25));
+          }
+        };
+
+        const el = document.createElement('button');
+        el.type = 'button';
+        el.id = 'tt-show';
+        el.setAttribute('data-bs-toggle', 'tooltip');
+        el.setAttribute('data-bs-title', 'Hello from @omega.js/desktop');
+        el.textContent = 'hover me';
+        document.body.appendChild(el);
+
+        // The auto-init observer creates the instance without any consumer code.
+        await until(() => window.__emTestTooltip.hasInstance('tt-show'));
+
+        const shown = window.__emTestTooltip.showDirect('tt-show');
+        ctx.expect(shown).toBe(true);
+        await until(() => document.querySelector('.tooltip .tooltip-inner'));
+        ctx.expect(document.querySelector('.tooltip .tooltip-inner').textContent).toBe('Hello from @omega.js/desktop');
+
+        // Removing the host while shown must clean up the tip (dispose path).
+        el.remove();
+        await until(() => !document.querySelector('.tooltip'));
+      },
+    },
+    {
+      name: 'changing data-bs-title updates the live instance',
+      run: async (ctx) => {
+        const until = async (fn) => {
+          const t0 = Date.now();
+          while (!fn()) {
+            if (Date.now() - t0 > 3000) throw new Error('timed out waiting for tooltip');
+            await new Promise((r) => setTimeout(r, 25));
+          }
+        };
+
+        const el = document.createElement('button');
+        el.type = 'button';
+        el.id = 'tt-retitle';
+        el.setAttribute('data-bs-toggle', 'tooltip');
+        el.setAttribute('data-bs-title', 'before');
+        document.body.appendChild(el);
+        await until(() => window.__emTestTooltip.hasInstance('tt-retitle'));
+
+        el.setAttribute('data-bs-title', 'after');
+        // The observer applies setContent asynchronously (mutation microtask) —
+        // give it a beat, then show and assert the rendered text.
+        await new Promise((r) => setTimeout(r, 100));
+        ctx.expect(window.__emTestTooltip.showDirect('tt-retitle')).toBe(true);
+        await until(() => document.querySelector('.tooltip .tooltip-inner'));
+        ctx.expect(document.querySelector('.tooltip .tooltip-inner').textContent).toBe('after');
+
+        el.remove();
+        await until(() => !document.querySelector('.tooltip'));
+      },
+    },
+    {
+      name: 'a title-only host initializes ONCE and the renderer stays responsive (the observer/dispose loop regression)',
+      run: async (ctx) => {
+        const until = async (fn) => {
+          const t0 = Date.now();
+          while (!fn()) {
+            if (Date.now() - t0 > 3000) throw new Error('timed out waiting for tooltip');
+            await new Promise((r) => setTimeout(r, 25));
+          }
+        };
+
+        // A host with a PLAIN `title` (no data-bs-title): Bootstrap's
+        // constructor MOVES title → data-bs-original-title, which the
+        // observer must read as a live title — reading only title/
+        // data-bs-title made it dispose (which RESTORES title) and re-init
+        // forever: a MutationObserver microtask storm that froze the whole
+        // renderer (found by Somiibo's session-limits boot suite).
+        const el = document.createElement('button');
+        el.type = 'button';
+        el.id = 'tt-title-only';
+        el.setAttribute('data-bs-toggle', 'tooltip');
+        el.setAttribute('title', 'plain title');
+        document.body.appendChild(el);
+
+        await until(() => window.__emTestTooltip.hasInstance('tt-title-only'));
+
+        // The loop starved macrotasks — a timer firing IS the proof the
+        // main thread survived the mutation settling.
+        const responsive = await new Promise((resolve) => setTimeout(() => resolve(true), 150));
+        ctx.expect(responsive).toBe(true);
+
+        // Stable end state: title moved into Bootstrap's bookkeeping, the
+        // instance alive, and the tip renders the original text.
+        ctx.expect(el.hasAttribute('title')).toBe(false);
+        ctx.expect(el.getAttribute('data-bs-original-title')).toBe('plain title');
+        ctx.expect(window.__emTestTooltip.hasInstance('tt-title-only')).toBe(true);
+        ctx.expect(window.__emTestTooltip.showDirect('tt-title-only')).toBe(true);
+        await until(() => document.querySelector('.tooltip .tooltip-inner'));
+        ctx.expect(document.querySelector('.tooltip .tooltip-inner').textContent).toBe('plain title');
+
+        el.remove();
+        await until(() => !document.querySelector('.tooltip'));
+      },
+    },
+    {
+      name: 'removing a tooltip host disposes its instance',
+      run: async (ctx) => {
+        const until = async (fn) => {
+          const t0 = Date.now();
+          while (!fn()) {
+            if (Date.now() - t0 > 3000) throw new Error('timed out waiting for tooltip lifecycle');
+            await new Promise((r) => setTimeout(r, 25));
+          }
+        };
+
+        const el = document.createElement('button');
+        el.type = 'button';
+        el.id = 'tt-dispose';
+        el.setAttribute('data-bs-toggle', 'tooltip');
+        el.setAttribute('data-bs-title', 'bye');
+        document.body.appendChild(el);
+        await until(() => window.__emTestTooltip.hasInstance('tt-dispose'));
+
+        el.remove();
+        await until(() => !window.__emTestTooltip.hasInstance('tt-dispose'));
+        ctx.expect(window.__emTestTooltip.hasInstance('tt-dispose')).toBe(false);
+      },
+    },
+  ],
+});

package/dist/test/suites/renderer/verts.test.js

@@ -0,0 +1,100 @@
+// Renderer-layer suite — verifies the verts auto-bind (ads-system phase 4):
+// a `[data-omega-vert]` element inserted into the live DOM is picked up by
+// renderer.js's MutationObserver wiring and handed to @omega.js/client's verts
+// module with the type pinned to 'house'. The harness preload seeds an
+// AdSense client into the config ON PURPOSE and no inhouse source — proving
+// the pin: the provider lane must never be attempted (no adsbygoogle script,
+// no <ins>), and the source-less house render collapses the host.
+//
+// Runs inside a hidden BrowserWindow. Test bodies are reconstructed via
+// `new Function('ctx', body)` — no closures over module scope, so each test
+// inlines its own poll helper. The binding marker (data-omega-vert-bound) is a
+// DOM attribute because preload-world expandos don't cross contextIsolation.
+
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'renderer',
+  description: 'verts auto-bind — live [data-omega-vert] binding, house-lane pin',
+  tests: [
+    {
+      name: 'an inserted [data-omega-vert] element gets bound to the house lane',
+      run: async (ctx) => {
+        const until = async (fn) => {
+          const t0 = Date.now();
+          while (!fn()) {
+            if (Date.now() - t0 > 3000) throw new Error('timed out waiting for ad binding');
+            await new Promise((r) => setTimeout(r, 25));
+          }
+        };
+
+        const el = document.createElement('div');
+        el.setAttribute('data-omega-vert', 'display');
+        el.setAttribute('data-omega-vert-size', 'banner');
+        document.body.appendChild(el);
+
+        await until(() => el.dataset.omegaVertBound);
+        ctx.expect(el.dataset.omegaVertBound).toBe('house');
+        el.remove();
+      },
+    },
+    {
+      name: 'descendants of an inserted subtree bind too',
+      run: async (ctx) => {
+        const until = async (fn) => {
+          const t0 = Date.now();
+          while (!fn()) {
+            if (Date.now() - t0 > 3000) throw new Error('timed out waiting for ad binding');
+            await new Promise((r) => setTimeout(r, 25));
+          }
+        };
+
+        const wrap = document.createElement('div');
+        wrap.innerHTML = '<section><div id="vertInner" data-omega-vert></div></section>';
+        document.body.appendChild(wrap);
+
+        const inner = document.getElementById('vertInner');
+        await until(() => inner.dataset.omegaVertBound);
+        ctx.expect(inner.dataset.omegaVertBound).toBe('house');
+        wrap.remove();
+      },
+    },
+    {
+      name: 'the provider lane is never attempted — no adsbygoogle script or <ins> despite a configured AdSense client',
+      run: async (ctx) => {
+        const until = async (fn) => {
+          const t0 = Date.now();
+          while (!fn()) {
+            if (Date.now() - t0 > 3000) throw new Error('timed out waiting for ad binding');
+            await new Promise((r) => setTimeout(r, 25));
+          }
+        };
+
+        const el = document.createElement('div');
+        el.setAttribute('data-omega-vert', 'display');
+        document.body.appendChild(el);
+        await until(() => el.dataset.omegaVertBound);
+
+        // Give any (wrong) provider-lane attempt a beat to surface, then
+        // assert the AdSense machinery never touched the page.
+        await new Promise((r) => setTimeout(r, 300));
+        ctx.expect(document.querySelector('script[src*="adsbygoogle"]')).toBe(null);
+        ctx.expect(document.querySelector('ins.adsbygoogle')).toBe(null);
+        el.remove();
+      },
+    },
+    {
+      name: 'elements without data-omega-vert are untouched',
+      run: async (ctx) => {
+        const el = document.createElement('div');
+        el.className = 'not-an-ad';
+        document.body.appendChild(el);
+
+        await new Promise((r) => setTimeout(r, 200));
+        ctx.expect(el.hasAttribute('data-omega-vert-bound')).toBe(false);
+        el.remove();
+      },
+    },
+  ],
+});