@1agh/maude 1.0.9 → 1.2.0

package/apps/studio/test/video-comp.test.ts

@@ -1,270 +0,0 @@
-// video-comp — DDR-148 seek-bridge unit coverage.
-//
-// The Remotion Player's actual frame render needs a real browser (rAF, layout,
-// media) — that determinism ("two seeks to frame N → identical pixels") is an
-// agent-browser live check (Task 11). What IS pure + testable here is the seek
-// BRIDGE the capture spine + Timeline panel drive: the comp registry, the
-// clamped seek routing to each Player, and the serializable snapshot. We stand
-// up happy-dom, install the bridge without mounting a Player, register a fake
-// Player handle (a seekTo/pause spy), and assert the routing contract.
-
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from 'bun:test';
-import { GlobalRegistrator } from '@happy-dom/global-registrator';
-
-import { findArtboardOf, installMaudeSeekBridge } from '../video-comp.tsx';
-
-interface FakePlayer {
-  seekTo: (frame: number) => void;
-  pause: () => void;
-  seeks: number[];
-  pauses: number;
-}
-
-interface SeekWindow {
-  __maudeVideoComps?: Map<
-    string,
-    {
-      id: string;
-      fps: number;
-      durationInFrames: number;
-      width: number;
-      height: number;
-      ref: { current: FakePlayer | null };
-    }
-  >;
-  __maude_seek__?: (frame: number, opts?: { fps?: number }) => Promise<void>;
-  __maude_comps__?: () => Array<{
-    id: string;
-    fps: number;
-    durationInFrames: number;
-    width: number;
-    height: number;
-  }>;
-}
-
-function makeFakePlayer(): FakePlayer {
-  const p: FakePlayer = {
-    seeks: [],
-    pauses: 0,
-    seekTo(frame) {
-      p.seeks.push(frame);
-    },
-    pause() {
-      p.pauses += 1;
-    },
-  };
-  return p;
-}
-
-function registerComp(
-  id: string,
-  meta: { fps: number; durationInFrames: number; width: number; height: number },
-  player: FakePlayer
-): void {
-  const w = window as unknown as SeekWindow;
-  if (!w.__maudeVideoComps) w.__maudeVideoComps = new Map();
-  w.__maudeVideoComps.set(id, { id, ...meta, ref: { current: player } });
-}
-
-beforeAll(() => {
-  GlobalRegistrator.register();
-});
-
-afterAll(async () => {
-  await GlobalRegistrator.unregister();
-});
-
-beforeEach(() => {
-  const w = window as unknown as SeekWindow;
-  w.__maudeVideoComps = undefined;
-  w.__maude_seek__ = undefined;
-  w.__maude_comps__ = undefined;
-});
-
-describe('video-comp seek bridge', () => {
-  test('installs window.__maude_seek__ + __maude_comps__ idempotently', () => {
-    const w = window as unknown as SeekWindow;
-    installMaudeSeekBridge();
-    const seek1 = w.__maude_seek__;
-    const comps1 = w.__maude_comps__;
-    expect(typeof seek1).toBe('function');
-    expect(typeof comps1).toBe('function');
-    installMaudeSeekBridge();
-    // Second install must NOT replace the functions (idempotent).
-    expect(w.__maude_seek__).toBe(seek1);
-    expect(w.__maude_comps__).toBe(comps1);
-  });
-
-  test('__maude_comps__ reflects the live registry (serializable, no functions)', () => {
-    const w = window as unknown as SeekWindow;
-    installMaudeSeekBridge();
-    registerComp(
-      'intro',
-      { fps: 30, durationInFrames: 90, width: 640, height: 360 },
-      makeFakePlayer()
-    );
-    const comps = w.__maude_comps__?.() ?? [];
-    expect(comps).toHaveLength(1);
-    expect(comps[0]).toEqual({
-      id: 'intro',
-      fps: 30,
-      durationInFrames: 90,
-      width: 640,
-      height: 360,
-      // issue #75 — always present in the snapshot (null when the comp was
-      // registered outside an artboard), so the shell can key the transport
-      // target on artboard identity instead of guessing from duration.
-      artboardId: null,
-      artboardLabel: null,
-    });
-    // No ref/functions leak into the snapshot.
-    expect(Object.keys(comps[0])).not.toContain('ref');
-  });
-
-  test('seek routes to every registered Player, paused first', async () => {
-    const w = window as unknown as SeekWindow;
-    installMaudeSeekBridge();
-    const a = makeFakePlayer();
-    const b = makeFakePlayer();
-    registerComp('a', { fps: 30, durationInFrames: 90, width: 640, height: 360 }, a);
-    registerComp('b', { fps: 24, durationInFrames: 48, width: 320, height: 240 }, b);
-    await w.__maude_seek__?.(30);
-    expect(a.seeks).toEqual([30]);
-    expect(b.seeks).toEqual([30]);
-    expect(a.pauses).toBe(1);
-    expect(b.pauses).toBe(1);
-  });
-
-  test('seek clamps into [0, durationInFrames-1] per comp + rounds', async () => {
-    const w = window as unknown as SeekWindow;
-    installMaudeSeekBridge();
-    const a = makeFakePlayer();
-    registerComp('a', { fps: 30, durationInFrames: 90, width: 640, height: 360 }, a);
-    await w.__maude_seek__?.(999); // past the end → clamp to 89
-    await w.__maude_seek__?.(-5); // before the start → clamp to 0
-    await w.__maude_seek__?.(12.6); // fractional → round to 13
-    expect(a.seeks).toEqual([89, 0, 13]);
-  });
-
-  test('two seeks to the same frame issue identical Player calls (determinism contract)', async () => {
-    const w = window as unknown as SeekWindow;
-    installMaudeSeekBridge();
-    const a = makeFakePlayer();
-    registerComp('a', { fps: 30, durationInFrames: 90, width: 640, height: 360 }, a);
-    await w.__maude_seek__?.(42);
-    await w.__maude_seek__?.(42);
-    expect(a.seeks).toEqual([42, 42]);
-  });
-
-  test('a not-yet-ready Player is resilient in UI mode but still RECORDED', async () => {
-    const w = window as unknown as SeekWindow;
-    installMaudeSeekBridge();
-    if (!w.__maudeVideoComps) w.__maudeVideoComps = new Map();
-    w.__maudeVideoComps.set('pending', {
-      id: 'pending',
-      fps: 30,
-      durationInFrames: 90,
-      width: 640,
-      height: 360,
-      ref: { current: null },
-    });
-    // A live scrub of a still-mounting comp must not blow up the UI...
-    const before = w.__maude_seek_failures__ ?? 0;
-    await expect(w.__maude_seek__?.(10)).resolves.toBeUndefined();
-    // ...but it is no longer silent: the capture shim reads this counter and
-    // refuses to encode, because a seek that never landed means a stale frame.
-    expect(w.__maude_seek_failures__ ?? 0).toBeGreaterThan(before);
-  });
-
-  test('capture mode (strict) throws instead of pretending the seek landed', async () => {
-    const w = window as unknown as SeekWindow;
-    installMaudeSeekBridge();
-    if (!w.__maudeVideoComps) w.__maudeVideoComps = new Map();
-    w.__maudeVideoComps.set('pending-strict', {
-      id: 'pending-strict',
-      fps: 30,
-      durationInFrames: 90,
-      width: 640,
-      height: 360,
-      ref: { current: null },
-    });
-    await expect(w.__maude_seek__?.(10, { strict: true })).rejects.toThrow(
-      /refusing to report a seek that did not happen/
-    );
-  });
-});
-
-// issue #75 — a comp's own id is a mount slug (`videocomp-N`) unless the author
-// set one, so the shell can only tell two comps apart by the artboard they are
-// mounted in. This is the resolution that puts that id on the wire.
-describe('findArtboardOf', () => {
-  test('resolves the enclosing artboard id + visible label', () => {
-    document.body.innerHTML = `
-      <article data-dc-screen="outro">
-        <button class="dc-artboard-label sku"><span aria-hidden="true"></span>Outro</button>
-        <div class="dc-artboard-body"><div class="dc-video-comp" data-comp-id="videocomp-2"></div></div>
-      </article>`;
-    const host = document.querySelector('.dc-video-comp');
-    expect(findArtboardOf(host)).toEqual({ artboardId: 'outro', artboardLabel: 'Outro' });
-  });
-
-  test('a comp mounted outside any artboard reports nulls, never throws', () => {
-    document.body.innerHTML = '<div class="dc-video-comp" data-comp-id="bare"></div>';
-    expect(findArtboardOf(document.querySelector('.dc-video-comp'))).toEqual({
-      artboardId: null,
-      artboardLabel: null,
-    });
-    expect(findArtboardOf(null)).toEqual({ artboardId: null, artboardLabel: null });
-  });
-
-  // Adversarial review 2026-08-12 — `.dc-artboard-label` is a class anyone can
-  // write, so the label must come from the element canvas-lib actually renders
-  // (a DIRECT header/button child), not from the first match anywhere below.
-  test('a planted label node cannot outrank the real header', () => {
-    document.body.innerHTML = `
-      <article data-dc-screen="intro">
-        <span class="dc-artboard-label" hidden>Outro</span>
-        <header class="dc-artboard-label sku">Intro</header>
-        <div class="dc-artboard-body"><div class="dc-video-comp"></div></div>
-      </article>`;
-    expect(findArtboardOf(document.querySelector('.dc-video-comp')).artboardLabel).toBe('Intro');
-  });
-
-  test('a nested artboard resolves to the NEAREST board, not the outer label', () => {
-    document.body.innerHTML = `
-      <article data-dc-screen="outer">
-        <header class="dc-artboard-label sku">Outer</header>
-        <article data-dc-screen="inner">
-          <header class="dc-artboard-label sku">Inner</header>
-          <div class="dc-video-comp"></div>
-        </article>
-      </article>`;
-    expect(findArtboardOf(document.querySelector('.dc-video-comp'))).toEqual({
-      artboardId: 'inner',
-      artboardLabel: 'Inner',
-    });
-  });
-
-  test('a label deep in the body is ignored — only a direct header/button counts', () => {
-    document.body.innerHTML = `
-      <article data-dc-screen="intro">
-        <div class="dc-artboard-body">
-          <p class="dc-artboard-label">Outro</p>
-          <div class="dc-video-comp"></div>
-        </div>
-      </article>`;
-    expect(findArtboardOf(document.querySelector('.dc-video-comp'))).toEqual({
-      artboardId: 'intro',
-      artboardLabel: null,
-    });
-  });
-
-  test('an unlabelled artboard still yields its id', () => {
-    document.body.innerHTML =
-      '<article data-dc-screen="intro"><div class="dc-video-comp"></div></article>';
-    expect(findArtboardOf(document.querySelector('.dc-video-comp'))).toEqual({
-      artboardId: 'intro',
-      artboardLabel: null,
-    });
-  });
-});

package/apps/studio/test/video-encode-lib.test.ts

@@ -1,63 +0,0 @@
-// video-encode-lib — frame-clearing contract (feature-fast-video-export Task 6e).
-//
-// `addVideoFrame`/`addGifFrame` run INSIDE the capture Chromium (real
-// OffscreenCanvas + WebCodecs), so the actual pixel behavior needs a live
-// browser — not a `bun:test` concern, mirroring video-render-bridge.test.ts's
-// split between pure routing (tested here at the source level) and live
-// canvas/codec work (manual/agent-browser verification).
-//
-// What IS worth pinning: the DECISION itself. `drawImage` is called with no
-// preceding `clearRect`/`fillRect` reset, so a transparent frame draws OVER
-// whatever the encoder canvas already held — a transparent artboard would
-// ghost the previous frame's pixels through. This was flagged as a "decide
-// deliberately, don't let it drift" item rather than a bug: every capture
-// path today feeds `page.screenshot()` output, which Chromium always
-// composites onto an opaque background (no `omitBackground` capture exists in
-// this codebase), so the ghost case cannot currently occur in practice. If
-// that stops being true — a future capture path starts passing genuinely
-// transparent frames — this test must be touched, which is the point: an
-// accidental `clearRect` add/removal should force a conscious look at this
-// comment, not slip through unnoticed.
-
-import { describe, expect, test } from 'bun:test';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-const SRC = readFileSync(join(import.meta.dir, '..', 'exporters', 'video-encode-lib.ts'), 'utf8');
-
-function body(fnName: string): string {
-  const start = SRC.indexOf(`async ${fnName}(`);
-  const openBrace = SRC.indexOf('{', start);
-  // Cheap brace match — good enough for this file's flat function bodies.
-  let depth = 0;
-  let end = openBrace;
-  for (let i = openBrace; i < SRC.length; i += 1) {
-    if (SRC[i] === '{') depth += 1;
-    else if (SRC[i] === '}') {
-      depth -= 1;
-      if (depth === 0) {
-        end = i;
-        break;
-      }
-    }
-  }
-  return SRC.slice(start, end + 1);
-}
-
-describe('video-encode-lib — frame-clearing decision (pinned, not a bug)', () => {
-  test('addVideoFrame draws without clearing the encoder canvas first', () => {
-    const fn = body('addVideoFrame');
-    expect(fn).toMatch(
-      /ctx\.drawImage\(bmp, 0, 0, vstate\.canvas\.width, vstate\.canvas\.height\)/
-    );
-    expect(fn).not.toMatch(/clearRect|fillRect/);
-  });
-
-  test('addGifFrame draws without clearing the gif canvas first', () => {
-    const fn = body('addGifFrame');
-    expect(fn).toMatch(
-      /ctx\.drawImage\(bmp, 0, 0, gstate\.canvas\.width, gstate\.canvas\.height\)/
-    );
-    expect(fn).not.toMatch(/clearRect|fillRect/);
-  });
-});

package/apps/studio/test/video-render-bridge.test.ts

@@ -1,171 +0,0 @@
-// video-render-bridge — DDR-148 addendum (audio export) unit coverage.
-//
-// The actual renderMediaOnWeb call needs a real browser (WebCodecs, canvas
-// decode) — that's a manual/agent-browser verification (see the DDR-148
-// addendum § Manual verification recipe), not a unit test, mirroring
-// video-comp.test.ts's own split between the pure seek-bridge routing (tested
-// here) and live Player rendering (not). What IS pure + testable: `findCompIdIn`
-// (DOM containment resolution) and the `__maude_render_video__` bridge's
-// routing contract — it must merge the registered comp's component/meta with
-// the caller's opts and delegate to the injected `__maudeRenderVideo__`, and
-// fail clearly when either the comp or the render-lib injection is missing, and
-// PROPAGATE a renderer failure as a rejection (the contract the capture shim's
-// try/catch relies on to fall back to frame-step screenshots — RCA
-// issue-video-mp4-rendermediaonweb-stack-overflow). The shim-level fallback
-// itself (renderMediaOnWeb throws → frame-step, video-only, degraded=true) is
-// verified live against a deep-precompositing comp — see that RCA's repro.
-
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from 'bun:test';
-import { GlobalRegistrator } from '@happy-dom/global-registrator';
-
-import { findCompIdIn, installMaudeSeekBridge } from '../video-comp.tsx';
-
-interface RenderCall {
-  component: unknown;
-  inputProps: unknown;
-  width: number;
-  height: number;
-  fps: number;
-  durationInFrames: number;
-  [k: string]: unknown;
-}
-
-interface RenderWindow {
-  __maudeVideoComps?: Map<
-    string,
-    {
-      id: string;
-      fps: number;
-      durationInFrames: number;
-      width: number;
-      height: number;
-      ref: { current: null };
-      component: unknown;
-      inputProps: Record<string, unknown>;
-    }
-  >;
-  __maude_render_video__?: (compId: string, opts: Record<string, unknown>) => Promise<unknown>;
-  __maudeRenderVideo__?: (opts: RenderCall) => Promise<unknown>;
-}
-
-function registerComp(
-  id: string,
-  meta: { fps: number; durationInFrames: number; width: number; height: number },
-  component: unknown,
-  inputProps: Record<string, unknown> = {}
-): void {
-  const w = window as unknown as RenderWindow;
-  if (!w.__maudeVideoComps) w.__maudeVideoComps = new Map();
-  w.__maudeVideoComps.set(id, { id, ...meta, ref: { current: null }, component, inputProps });
-}
-
-beforeAll(() => {
-  GlobalRegistrator.register();
-});
-
-afterAll(async () => {
-  await GlobalRegistrator.unregister();
-});
-
-beforeEach(() => {
-  const w = window as unknown as RenderWindow;
-  w.__maudeVideoComps = undefined;
-  w.__maudeRenderVideo__ = undefined;
-  (w as unknown as { __maude_render_video__?: unknown }).__maude_render_video__ = undefined;
-  (w as unknown as { __maude_seek__?: unknown }).__maude_seek__ = undefined;
-  (w as unknown as { __maude_comps__?: unknown }).__maude_comps__ = undefined;
-});
-
-describe('findCompIdIn', () => {
-  test('resolves the nearest [data-comp-id] descendant', () => {
-    document.body.innerHTML =
-      '<div data-dc-screen="reel"><div data-comp-id="videocomp-2"><span>x</span></div></div>';
-    const artboard = document.querySelector('[data-dc-screen="reel"]');
-    expect(artboard).not.toBeNull();
-    expect(findCompIdIn(artboard as Element)).toBe('videocomp-2');
-  });
-
-  test('returns null for an artboard with no registered comp (ordinary/CSS artboard)', () => {
-    document.body.innerHTML = '<div data-dc-screen="static"><p>just a div</p></div>';
-    const artboard = document.querySelector('[data-dc-screen="static"]');
-    expect(findCompIdIn(artboard as Element)).toBeNull();
-  });
-});
-
-describe('__maude_render_video__ bridge', () => {
-  test('merges the registered component + meta with caller opts, delegates to __maudeRenderVideo__', async () => {
-    const w = window as unknown as RenderWindow;
-    installMaudeSeekBridge();
-    const FakeComp = () => null;
-    registerComp('reel', { fps: 30, durationInFrames: 228, width: 960, height: 540 }, FakeComp, {
-      title: 'Showreel',
-    });
-    let received: RenderCall | null = null;
-    w.__maudeRenderVideo__ = async (opts) => {
-      received = opts;
-      return { b64: 'AA==', bytes: 2, container: 'mp4', videoCodec: 'h264', audioCodec: 'aac' };
-    };
-    const result = await w.__maude_render_video__?.('reel', {
-      container: 'mp4',
-      scale: 2,
-      muted: false,
-      frameRange: [0, 30],
-    });
-    expect(result).toEqual({
-      b64: 'AA==',
-      bytes: 2,
-      container: 'mp4',
-      videoCodec: 'h264',
-      audioCodec: 'aac',
-    });
-    expect(received).not.toBeNull();
-    const call = received as unknown as RenderCall;
-    expect(call.component).toBe(FakeComp);
-    expect(call.inputProps).toEqual({ title: 'Showreel' });
-    expect(call.width).toBe(960);
-    expect(call.height).toBe(540);
-    expect(call.fps).toBe(30);
-    expect(call.durationInFrames).toBe(228);
-    // Caller opts pass through alongside the merged meta.
-    expect(call.container).toBe('mp4');
-    expect(call.scale).toBe(2);
-    expect(call.muted).toBe(false);
-    expect(call.frameRange).toEqual([0, 30]);
-  });
-
-  test('throws a clear error for an unregistered compId', async () => {
-    const w = window as unknown as RenderWindow;
-    installMaudeSeekBridge();
-    await expect(w.__maude_render_video__?.('nope', { container: 'mp4' })).rejects.toThrow(
-      /no registered video-comp/i
-    );
-  });
-
-  test('throws a clear error when the render-lib bundle was never injected', async () => {
-    const w = window as unknown as RenderWindow;
-    installMaudeSeekBridge();
-    registerComp('reel', { fps: 30, durationInFrames: 90, width: 960, height: 540 }, () => null);
-    // __maudeRenderVideo__ intentionally left unset (simulates a capture that
-    // skipped addScriptTag — e.g. gif/ordinary-artboard export never injects it).
-    await expect(w.__maude_render_video__?.('reel', { container: 'mp4' })).rejects.toThrow(
-      /render-lib bundle not injected/i
-    );
-  });
-
-  test('propagates a renderer failure (e.g. stack overflow) as a rejection the shim can catch', async () => {
-    // The capture shim (_video-playwright.mjs) wraps the __maude_render_video__
-    // page.evaluate in try/catch and degrades to frame-step screenshots when it
-    // rejects. That only works if the bridge surfaces __maudeRenderVideo__'s
-    // throw as a rejection rather than swallowing it — the exact failure mode
-    // of the RCA (@remotion/web-renderer overflowing on deep precompositing).
-    const w = window as unknown as RenderWindow;
-    installMaudeSeekBridge();
-    registerComp('reel', { fps: 30, durationInFrames: 228, width: 960, height: 540 }, () => null);
-    w.__maudeRenderVideo__ = async () => {
-      throw new RangeError('Maximum call stack size exceeded');
-    };
-    await expect(w.__maude_render_video__?.('reel', { container: 'mp4' })).rejects.toThrow(
-      /Maximum call stack size exceeded/
-    );
-  });
-});

package/apps/studio/test/whats-new.test.ts

@@ -1,113 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { mkdtempSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { bestSeenVersion, computeUnseen, parseVer, verGt } from '../client/whats-new-seen.js';
-import { loadWhatsNew, resolveMaudeVersion } from '../whats-new.ts';
-
-describe('whats-new feed loader', () => {
-  test('loads the committed feed with a version + non-empty entries', () => {
-    const feed = loadWhatsNew({ fresh: true });
-    expect(typeof feed.version).toBe('string');
-    expect(Array.isArray(feed.entries)).toBe(true);
-    expect(feed.entries.length).toBeGreaterThan(0);
-  });
-
-  test('every entry has the required shape', () => {
-    for (const e of loadWhatsNew({ fresh: true }).entries) {
-      expect(typeof e.id).toBe('string');
-      expect(e.id).toMatch(/^[a-z0-9][a-z0-9-]*$/);
-      expect(['feature', 'improvement', 'usage', 'fix']).toContain(e.kind);
-      expect(e.title.length).toBeGreaterThan(0);
-      expect(e.summary.length).toBeGreaterThan(0);
-    }
-  });
-
-  test('resolveMaudeVersion resolves a real release version', () => {
-    expect(resolveMaudeVersion()).toMatch(/^\d+\.\d+\.\d+/);
-    // The studio's own manifest is preferred over the design plugin's (it is
-    // the one staged into the cell image), and `0.0.0` — the placeholder both
-    // carried before joining the release line — is never an answer.
-    expect(resolveMaudeVersion()).not.toBe('0.0.0');
-  });
-
-  test('an unversioned root falls through rather than reporting the placeholder', () => {
-    const root = mkdtempSync(join(tmpdir(), 'maude-ver-'));
-    writeFileSync(join(root, 'package.json'), JSON.stringify({ version: '0.0.0' }));
-    // No plugin manifest above a tmpdir either, so this lands on `dev` — a
-    // value obviously not a release, rather than a plausible wrong number.
-    expect(resolveMaudeVersion(root)).toBe('dev');
-  });
-
-  test('a missing feed dir yields empty entries and never throws', () => {
-    const feed = loadWhatsNew({ root: join(import.meta.dir, '__does-not-exist__'), fresh: true });
-    expect(feed.entries).toEqual([]);
-  });
-
-  // Security regression (ethical-hacker creativity finding): the feed MUST
-  // resolve from the maude package root, NEVER a served project's tree. A
-  // hostile served project dropping its own whats-new.json must not inject
-  // entries into the privileged main-origin UI. Pin the boundary so a future
-  // "project-overridable feed" change can't silently erode it.
-  test('default resolution ignores a feed planted in an arbitrary (served-project) dir', () => {
-    const hostile = mkdtempSync(join(tmpdir(), 'mdcc-served-'));
-    writeFileSync(
-      join(hostile, 'whats-new.json'),
-      JSON.stringify({
-        entries: [{ id: 'evil', kind: 'feature', title: 'pwn', summary: 'x' }],
-      })
-    );
-    const feed = loadWhatsNew({ fresh: true }); // no root → package root only
-    expect(feed.entries.some((e) => e.id === 'evil')).toBe(false);
-    expect(feed.entries.length).toBeGreaterThan(0); // still reads the real package feed
-  });
-
-  // Defense-in-depth contract: a rendered learnMore is always an http(s) URL.
-  test('every committed entry learnMore is http(s) (no javascript:/data: scheme)', () => {
-    for (const e of loadWhatsNew({ fresh: true }).entries) {
-      if (e.learnMore != null) expect(e.learnMore).toMatch(/^https?:\/\//);
-    }
-  });
-});
-
-describe('seen logic (browser-safe, shared with the client)', () => {
-  test('parseVer extracts a semver triple', () => {
-    expect(parseVer('0.28.1')).toEqual([0, 28, 1]);
-    expect(parseVer('1.2.3-beta.4')).toEqual([1, 2, 3]);
-    expect(parseVer('dev')).toBeNull();
-  });
-
-  test('verGt compares semver, treating unparseable seen as oldest', () => {
-    expect(verGt('0.29.0', '0.28.1')).toBe(true);
-    expect(verGt('0.28.1', '0.29.0')).toBe(false);
-    expect(verGt('1.0.0', '0.99.99')).toBe(true);
-    expect(verGt('0.28.1', '0.28.1')).toBe(false);
-    expect(verGt('0.28.1', 'dev')).toBe(true);
-    expect(verGt('dev', '0.28.1')).toBe(false);
-  });
-
-  test('pending (null version) entries are always unseen', () => {
-    const u = computeUnseen(
-      [{ id: 'a', version: null, kind: 'feature', title: 't', summary: 's' }],
-      '9.9.9'
-    );
-    expect(u.map((e) => e.id)).toEqual(['a']);
-  });
-
-  test('computeUnseen returns only entries newer than the seen version', () => {
-    const entries = [
-      { id: 'old', version: '0.27.0', kind: 'feature', title: 't', summary: 's' },
-      { id: 'new', version: '0.29.0', kind: 'feature', title: 't', summary: 's' },
-    ];
-    expect(computeUnseen(entries, '0.28.0').map((e) => e.id)).toEqual(['new']);
-    expect(computeUnseen(entries, '0.29.0')).toEqual([]);
-  });
-
-  test('bestSeenVersion picks the highest of feed + entry versions', () => {
-    expect(bestSeenVersion([{ version: '0.29.0' }, { version: '0.27.0' }], '0.28.1')).toBe(
-      '0.29.0'
-    );
-    expect(bestSeenVersion([{ version: '0.20.0' }], '0.28.1')).toBe('0.28.1');
-    expect(bestSeenVersion([{ version: null }], '0.28.1')).toBe('0.28.1');
-  });
-});