@1agh/maude 1.0.11 → 1.2.0

package/apps/studio/test/repo-lock.test.ts

@@ -1,350 +0,0 @@
-// Cloud Phase 27 D2 — one writer at a time on the workspace checkout.
-//
-// The lock is the thing standing between "two processes over one working tree"
-// and the preserved dissent's 3 a.m. event, so the properties asserted here are
-// the ones that make it a lock rather than a suggestion: mutual exclusion,
-// release on throw, and a stale holder that unwedges itself without a human.
-
-import { describe, expect, test } from 'bun:test';
-import {
-  mkdirSync,
-  mkdtempSync,
-  readdirSync,
-  readFileSync,
-  rmSync,
-  utimesSync,
-  writeFileSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { HEARTBEAT_MS, REPO_LOCK_FILE, STALE_LOCK_MS, withRepoLock } from '../git/repo-lock.ts';
-
-function makeRepo({ git = true } = {}): string {
-  const root = mkdtempSync(join(tmpdir(), 'maude-repo-lock-'));
-  if (git) mkdirSync(join(root, '.git'), { recursive: true });
-  return root;
-}
-
-const lockFile = (root: string) => join(root, '.git', REPO_LOCK_FILE);
-const sleep = (ms: number) => new Promise<void>((r) => setTimeout(r, ms));
-
-describe('repo lock', () => {
-  test('two holders never overlap — the loser waits rather than failing', async () => {
-    const root = makeRepo();
-    try {
-      const order: string[] = [];
-      let concurrent = 0;
-      let maxConcurrent = 0;
-
-      const contend = (name: string) =>
-        withRepoLock(root, name, async () => {
-          concurrent += 1;
-          maxConcurrent = Math.max(maxConcurrent, concurrent);
-          order.push(`${name}:in`);
-          await sleep(30);
-          order.push(`${name}:out`);
-          concurrent -= 1;
-        });
-
-      await Promise.all([contend('hub:autocommit'), contend('studio:checkout')]);
-
-      // The point of the lock, stated twice: never two inside, and never an
-      // interleaved in/in/out/out — the second entry follows the first exit.
-      expect(maxConcurrent).toBe(1);
-      expect(order[1]).toBe(order[0].replace(':in', ':out'));
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  test('the lock is released when the operation throws', async () => {
-    const root = makeRepo();
-    try {
-      await expect(
-        withRepoLock(root, 'studio:commit', async () => {
-          throw new Error('git exploded');
-        })
-      ).rejects.toThrow('git exploded');
-
-      // Not merely "the file is gone" — the next caller gets in, which is the
-      // property that matters. A lock leaked by a failed commit would stop
-      // every autosave after it.
-      let ran = false;
-      await withRepoLock(root, 'hub:autocommit', async () => {
-        ran = true;
-      });
-      expect(ran).toBe(true);
-      expect(() => readFileSync(lockFile(root))).toThrow();
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  test('a repo with no .git runs unlocked instead of creating one', async () => {
-    const root = makeRepo({ git: false });
-    try {
-      let ran = false;
-      await withRepoLock(root, 'hub:seed', async () => {
-        ran = true;
-      });
-      expect(ran).toBe(true);
-      // It must not have become a repo initializer on the way past.
-      expect(() => readFileSync(join(root, '.git', REPO_LOCK_FILE))).toThrow();
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  test('a stale lock is stolen — a cell that crashed mid-commit unwedges itself', async () => {
-    const root = makeRepo();
-    try {
-      // A holder that still EXISTS as a process (this one) so the steal can only
-      // be attributed to the age, not to the liveness check.
-      writeFileSync(
-        lockFile(root),
-        JSON.stringify({ pid: process.pid, holder: 'hub:autocommit', at: 0, token: 'old' })
-      );
-
-      let ran = false;
-      const warned: string[] = [];
-      await withRepoLock(
-        root,
-        'studio:commit',
-        async () => {
-          ran = true;
-        },
-        {
-          waitMs: 1000,
-          // Age it past the window without waiting for it.
-          now: () => Date.now() + STALE_LOCK_MS + 5_000,
-          log: { warn: (m: string) => warned.push(m), log() {} },
-        }
-      );
-      expect(ran).toBe(true);
-      expect(warned.join(' ')).toContain('hub:autocommit');
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  test('a lock whose process is gone is stolen without waiting out the window', async () => {
-    const root = makeRepo();
-    try {
-      // pid 1 is tini in a cell and always alive, so a pid that cannot exist is
-      // the honest fixture: 2^22 is above every default pid_max.
-      writeFileSync(
-        lockFile(root),
-        JSON.stringify({ pid: 4194304, holder: 'studio:checkout', at: Date.now(), token: 'dead' })
-      );
-
-      let ran = false;
-      await withRepoLock(
-        root,
-        'hub:autocommit',
-        async () => {
-          ran = true;
-        },
-        { waitMs: 500, log: { warn() {}, log() {} } }
-      );
-      expect(ran).toBe(true);
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  test('giving up names the holder rather than hanging', async () => {
-    const root = makeRepo();
-    try {
-      writeFileSync(
-        lockFile(root),
-        JSON.stringify({ pid: process.pid, holder: 'studio:fold', at: Date.now(), token: 'live' })
-      );
-      await expect(
-        withRepoLock(root, 'hub:autocommit', async () => undefined, { waitMs: 120 })
-      ).rejects.toThrow(/studio:fold/);
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  test('releasing never unlinks a lock that was stolen from us', async () => {
-    // The one way a lock can be worse than no lock: a slow holder finishes,
-    // unlinks, and pulls the lock out from under whoever legitimately took it
-    // after the steal.
-    const root = makeRepo();
-    try {
-      const finished = withRepoLock(root, 'hub:autocommit', async () => {
-        // Simulate the steal: somebody reaped us and took it.
-        writeFileSync(
-          lockFile(root),
-          JSON.stringify({
-            pid: process.pid,
-            holder: 'studio:checkout',
-            at: Date.now(),
-            token: 'theirs',
-          })
-        );
-      });
-      await finished;
-      const after = JSON.parse(readFileSync(lockFile(root), 'utf8'));
-      expect(after.holder).toBe('studio:checkout');
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-  test("a lost steal race does not unlink the winner's fresh lock", async () => {
-    // THE MUTUAL-EXCLUSION FAILURE THIS LOCK EXISTS TO PREVENT, REINTRODUCED BY
-    // ITS OWN RECOVERY PATH. Two waiters both see holder A as stale; the first
-    // unlinks and acquires; the second — still acting on its read of A —
-    // unlinks the FIRST's fresh lock and acquires too. Both then run their
-    // critical section over one git index.
-    //
-    // The fixture is aged through its MTIME rather than through a fake clock,
-    // and that distinction is the test: a fake `now` makes every lock look
-    // ancient, including the winner's brand-new one, which is not a state the
-    // real world can produce and would assert something nobody needs.
-    const root = makeRepo();
-    try {
-      writeFileSync(
-        lockFile(root),
-        JSON.stringify({ pid: process.pid, holder: 'hub:autocommit', at: 0, token: 'stale' })
-      );
-      const long_ago = new Date(Date.now() - STALE_LOCK_MS * 4);
-      utimesSync(lockFile(root), long_ago, long_ago);
-
-      let concurrent = 0;
-      let maxConcurrent = 0;
-      const contend = (name: string) =>
-        withRepoLock(
-          root,
-          name,
-          async () => {
-            concurrent += 1;
-            maxConcurrent = Math.max(maxConcurrent, concurrent);
-            await sleep(60);
-            concurrent -= 1;
-          },
-          { waitMs: 5000, log: { warn() {}, log() {} } }
-        );
-
-      await Promise.all([contend('one'), contend('two'), contend('three')]);
-      expect(maxConcurrent).toBe(1);
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  }, 20_000);
-
-  test('a long-but-live holder is not stolen from — the heartbeat says it is alive', async () => {
-    // `pull`, `fold` and `resolve` came under this lock in D2, and they do
-    // NETWORK I/O. Without a heartbeat the staleness test cannot tell "held for
-    // 30 s" from "the holder died 30 s ago", so the next waiter steals the lock
-    // out from under a running merge.
-    const root = makeRepo();
-    try {
-      const order: string[] = [];
-      const slow = withRepoLock(root, 'studio:pull', async () => {
-        order.push('slow:in');
-        await sleep(HEARTBEAT_MS + 400);
-        order.push('slow:out');
-      });
-      await sleep(50);
-      // A waiter whose clock is PAST the staleness window. The heartbeat has
-      // refreshed the mtime, so the lock is not stale by age and the holder is
-      // alive — it must wait, not steal.
-      const waiter = withRepoLock(
-        root,
-        'hub:autocommit',
-        async () => {
-          order.push('waiter:in');
-        },
-        { waitMs: 20_000, log: { warn() {}, log() {} } }
-      );
-      await Promise.all([slow, waiter]);
-      expect(order).toEqual(['slow:in', 'slow:out', 'waiter:in']);
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  }, 30_000);
-
-  test('a hostile holder label cannot forge a log line', async () => {
-    const root = makeRepo();
-    try {
-      writeFileSync(
-        lockFile(root),
-        JSON.stringify({
-          pid: process.pid,
-          holder: 'evil\n[repo-lock] PASS: nothing to see here',
-          at: 0,
-          token: 'x',
-        })
-      );
-      const long_ago = new Date(Date.now() - STALE_LOCK_MS * 4);
-      utimesSync(lockFile(root), long_ago, long_ago);
-      const warned: string[] = [];
-      await withRepoLock(root, 'hub:autocommit', async () => undefined, {
-        waitMs: 2000,
-        log: { warn: (m: string) => warned.push(m), log() {} },
-      });
-      expect(warned.join(' ')).not.toContain('\n');
-      expect(warned.join(' ')).not.toContain('nothing to see here');
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-  test('exactly ONE waiter can steal a dead lock — the steal is a compare-and-swap', async () => {
-    // The `unlink` this replaced could not say no: two waiters both judged the
-    // holder stale, the first unlinked and acquired, and the second unlinked
-    // the FIRST's fresh lock. `rename` fails with ENOENT when the source is
-    // already gone, so only one waiter moves the file aside and the rest go
-    // back around the loop.
-    //
-    // WHAT THIS TEST DOES AND DOES NOT PROVE, because the difference matters.
-    // It asserts the OBSERVABLE contract — one steal, no leftover sidecar,
-    // never two holders. It does NOT reproduce the interleaving that made the
-    // unlink unsafe: that race is between the hub PROCESS and the studio
-    // PROCESS, and inside one bun test the whole read → steal → acquire
-    // sequence runs synchronously, so a single-process harness reaches the same
-    // verdict with either implementation (measured, not assumed). The
-    // correctness argument for `rename` is its atomicity — exactly one caller
-    // can move a given file — and this test guards the contract around it.
-    const root = makeRepo();
-    try {
-      writeFileSync(
-        lockFile(root),
-        JSON.stringify({ pid: 4194304, holder: 'hub:autocommit', at: 0, token: 'dead' })
-      );
-      const long_ago = new Date(Date.now() - STALE_LOCK_MS * 4);
-      utimesSync(lockFile(root), long_ago, long_ago);
-
-      const steals: string[] = [];
-      let concurrent = 0;
-      let maxConcurrent = 0;
-      const contend = (name: string) =>
-        withRepoLock(
-          root,
-          name,
-          async () => {
-            concurrent += 1;
-            maxConcurrent = Math.max(maxConcurrent, concurrent);
-            await sleep(40);
-            concurrent -= 1;
-          },
-          {
-            waitMs: 5000,
-            log: { warn: (m: string) => steals.push(m), log() {} },
-          }
-        );
-
-      await Promise.all([contend('a'), contend('b'), contend('c'), contend('d')]);
-
-      expect(maxConcurrent).toBe(1);
-      // One steal, not four: the other three found the file already gone.
-      expect(steals.filter((m) => m.includes('stole a')).length).toBe(1);
-      // And no sidecar left behind.
-      expect(readdirSync(join(root, '.git')).filter((f) => f.includes('.stale-'))).toEqual([]);
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  }, 20_000);
-});

package/apps/studio/test/report-proxy.test.ts

@@ -1,125 +0,0 @@
-// Regression test for issue-report-a-bug-http-500 (RCA:
-// .ai/logs/rca/issue-report-a-bug-http-500.md). `/_api/report` proxies the
-// dialog's multipart body to `MAUDE_REPORT_URL`. A bare `fetch(endpoint, …)`
-// call inside http.ts silently resolved to this module's OWN same-named
-// fall-through handler instead of the global `fetch` — the request never left
-// the machine, and the route mirrored a bogus local 500 back to the client.
-// These tests boot a real server pointed at a real stub upstream, so a
-// reintroduced shadow (or any other break in the proxy hop) fails loudly
-// instead of only being caught by a mocked-upstream unit test.
-
-import { describe, expect, test } from 'bun:test';
-import { readFileSync } from 'node:fs';
-
-import { bootServer, killProc, makeSandbox, nextPort } from './_helpers.ts';
-
-async function bootStubUpstream(
-  handler: (req: Request) => Response | Promise<Response>
-): Promise<{ url: string; stop: () => void; received: () => number }> {
-  let received = 0;
-  const server = Bun.serve({
-    port: 0,
-    fetch: async (req) => {
-      received += 1;
-      return handler(req);
-    },
-  });
-  return {
-    url: `http://127.0.0.1:${server.port}`,
-    stop: () => server.stop(true),
-    received: () => received,
-  };
-}
-
-describe('/_api/report proxy hop', () => {
-  test('forwards the multipart body verbatim and mirrors a successful upstream response', async () => {
-    const { root } = makeSandbox();
-    let capturedBytes = 0;
-    let capturedHasReportPart = false;
-    const upstream = await bootStubUpstream(async (req) => {
-      const form = await req.formData();
-      capturedHasReportPart = typeof form.get('report') === 'string';
-      // Multipart parsing consumed the body — approximate "did real bytes
-      // arrive" by re-serializing what FormData kept.
-      capturedBytes = [...form.values()].reduce(
-        (n, v) => n + (typeof v === 'string' ? v.length : (v as Blob).size),
-        0
-      );
-      return Response.json({ ok: true, issueNumber: 1, issueUrl: 'https://example.com/issues/1' });
-    });
-
-    const port = nextPort();
-    const proc = await bootServer(root, port, { MAUDE_REPORT_URL: `${upstream.url}/report` });
-    try {
-      const form = new FormData();
-      form.set(
-        'report',
-        JSON.stringify({ schema: 'maude-report/v1', description: 'test', reportId: 'r-0123abcd' })
-      );
-      form.append('screenshot', new Blob([new Uint8Array([1, 2, 3, 4])]), 'shot.png');
-
-      const res = await fetch(`http://localhost:${port}/_api/report`, {
-        method: 'POST',
-        body: form,
-      });
-      expect(res.status).toBe(200);
-      const json = await res.json();
-      expect(json).toEqual({ ok: true, issueNumber: 1, issueUrl: 'https://example.com/issues/1' });
-
-      expect(upstream.received()).toBe(1);
-      expect(capturedHasReportPart).toBe(true);
-      expect(capturedBytes).toBeGreaterThan(0);
-    } finally {
-      await killProc(proc);
-      upstream.stop();
-    }
-  });
-
-  test('an unreachable upstream yields 502 with a JSON error, not a bare 500', async () => {
-    const { root } = makeSandbox();
-    const port = nextPort();
-    // Nothing listens on this port — the fetch itself must fail/timeout.
-    const proc = await bootServer(root, port, { MAUDE_REPORT_URL: 'http://127.0.0.1:1/report' });
-    try {
-      const form = new FormData();
-      form.set(
-        'report',
-        JSON.stringify({ schema: 'maude-report/v1', description: 'test', reportId: 'r-0123abcd' })
-      );
-      const res = await fetch(`http://localhost:${port}/_api/report`, {
-        method: 'POST',
-        body: form,
-      });
-      expect(res.status).toBe(502);
-      const json = await res.json();
-      expect(json).toEqual({ error: 'report service unreachable' });
-    } finally {
-      await killProc(proc);
-    }
-  });
-});
-
-describe('no bare `fetch(` call sites in http.ts', () => {
-  test('every fetch call is either the global fetch (qualified) or a local handler name', () => {
-    const src = readFileSync(new URL('../http.ts', import.meta.url), 'utf8');
-    // A bare `fetch(` immediately preceded by a word-boundary and NOT preceded
-    // by a `.` (member access) or `function ` (declaration) would silently
-    // resolve to this file's own same-named fall-through handler instead of
-    // the global — exactly the bug this test guards against. `handleFallthrough`
-    // is the current, unambiguous name; this assertion also fails if the
-    // handler is ever renamed back to something call-site-ambiguous.
-    const bareFetchCalls = [...src.matchAll(/(?<![.\w])fetch\(/g)];
-    const lines = src.split('\n');
-    // Skip: comment lines (mentioning `fetch(` in prose is fine) and the one
-    // legitimate bare occurrence — the type-signature parameter name
-    // `fetch(req: Request): Promise<Response>;` in the `Api`-shaped interface,
-    // which is a declaration, not a call.
-    const offendingLines = bareFetchCalls
-      .map((m) => src.slice(0, m.index).split('\n').length)
-      .map((line) => ({ line, text: lines[line - 1] ?? '' }))
-      .filter(({ text }) => !/^\s*(\/\/|\*)/.test(text))
-      .filter(({ text }) => !/^\s*fetch\(req: Request\): Promise<Response>;/.test(text));
-
-    expect(offendingLines).toEqual([]);
-  });
-});

package/apps/studio/test/ripple.test.ts

@@ -1,197 +0,0 @@
-// ripple.test.ts — feature-enhanced-video-editing Phase 0 (Task 2). Golden-file
-// fixtures for the pure ripple engine: literal shifts, const-arithmetic
-// trailing-term merges, the TOTAL-follows-const double-shift guard, series
-// TOTAL-only behavior, and the loud structured refusals.
-
-import { describe, expect, test } from 'bun:test';
-
-import {
-  applyRippleAfterClip,
-  collectConsts,
-  RippleError,
-  resolveNum,
-  shiftExpression,
-} from '../ripple.ts';
-
-const CANVAS = '/abs/Canvas.tsx';
-
-describe('shiftExpression', () => {
-  test('literal rewrites in place', () => {
-    expect(shiftExpression('90', 12)).toBe('102');
-    expect(shiftExpression('90', -30)).toBe('60');
-  });
-  test('trailing integer term merges', () => {
-    expect(shiftExpression('A + B - 20', 12)).toBe('A + B - 8');
-    expect(shiftExpression('A + B - 20', 20)).toBe('A + B');
-    expect(shiftExpression('A + 10', -22)).toBe('A - 12');
-  });
-  test('no trailing term → appends', () => {
-    expect(shiftExpression('A', 12)).toBe('A + 12');
-    expect(shiftExpression('A + B', -12)).toBe('A + B - 12');
-  });
-  test('trailing int that is an operand of * stays untouched (appends instead)', () => {
-    expect(shiftExpression('A * 2', 12)).toBe('A * 2 + 12');
-  });
-  test('unsafe charset → null (a call slips the charset but fails resolveNum — the engine refuses there)', () => {
-    expect(shiftExpression('a ? 1 : 2', 12)).toBe(null);
-    expect(resolveNum('fn(A)', { A: 1 })).toBe(null);
-  });
-});
-
-describe('collectConsts + resolveNum', () => {
-  const SRC = 'const A = 40;\nconst B = 50;\nconst TOTAL = A + B - 20;\n';
-  test('derived consts resolve', () => {
-    const c = collectConsts(SRC);
-    expect(c.TOTAL).toBe(70);
-    expect(resolveNum('TOTAL - 10', c)).toBe(60);
-    expect(resolveNum('mystery + 1', c)).toBe(null);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Standalone-Sequence comp (overlay/audio band shape) — literal + expression.
-
-const STANDALONE = [
-  'const A = 90;',
-  'const TOTAL = 300;',
-  'const Comp = () => (',
-  '  <>',
-  '    <Sequence name="one" from={0} durationInFrames={A}><Video src="a.mp4" /></Sequence>',
-  '    <Sequence name="two" from={90} durationInFrames={100}><Video src="b.mp4" /></Sequence>',
-  '    <Sequence name="three" from={A + 100} durationInFrames={110}><Video src="c.mp4" /></Sequence>',
-  '  </>',
-  ');',
-  'function Canvas() {',
-  '  return (',
-  '    <DCArtboard id="a"><VideoComp component={Comp} durationInFrames={TOTAL} fps={30} /></DCArtboard>',
-  '  );',
-  '}',
-].join('\n');
-
-describe('applyRippleAfterClip — standalone sequences', () => {
-  test('shifts literal and expression froms, bumps the TOTAL const', () => {
-    const r = applyRippleAfterClip(CANVAS, STANDALONE, 'a', 'name:one', 12);
-    expect(r.totalEdited).toBe(true);
-    expect(r.shifted).toEqual(['name:two', 'name:three']);
-    expect(r.source).toContain('const TOTAL = 312;');
-    expect(r.source).toContain('from={102}');
-    expect(r.source).toContain('from={A + 112}');
-    // upstream untouched
-    expect(r.source).toContain('from={0}');
-  });
-
-  test('negative delta merges the trailing term back down', () => {
-    const r = applyRippleAfterClip(CANVAS, STANDALONE, 'a', 'name:one', -30);
-    expect(r.source).toContain('const TOTAL = 270;');
-    expect(r.source).toContain('from={60}');
-    expect(r.source).toContain('from={A + 70}');
-  });
-
-  test('delta 0 is a no-op', () => {
-    const r = applyRippleAfterClip(CANVAS, STANDALONE, 'a', 'name:one', 0);
-    expect(r.source).toBe(STANDALONE);
-    expect(r.shifted).toEqual([]);
-  });
-
-  test('only clips AFTER the target shift', () => {
-    const r = applyRippleAfterClip(CANVAS, STANDALONE, 'a', 'name:two', 12);
-    expect(r.shifted).toEqual(['name:three']);
-    expect(r.source).toContain('from={90}'); // "two" itself untouched
-    expect(r.source).toContain('from={A + 112}');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// The double-shift guard — an end card at `from={TOTAL - 60}` already follows
-// the bumped const and must be SKIPPED, not shifted twice.
-
-const COUPLED = [
-  'const TOTAL = 300;',
-  'const Comp = () => (',
-  '  <>',
-  '    <Sequence name="body" from={0} durationInFrames={240}><Video src="a.mp4" /></Sequence>',
-  '    <Sequence name="end" from={TOTAL - 60} durationInFrames={60}><Video src="b.mp4" /></Sequence>',
-  '  </>',
-  ');',
-  'function Canvas() {',
-  '  return (',
-  '    <DCArtboard id="a"><VideoComp component={Comp} durationInFrames={TOTAL} fps={30} /></DCArtboard>',
-  '  );',
-  '}',
-].join('\n');
-
-describe('applyRippleAfterClip — const-coupled froms', () => {
-  test('a from that follows the bumped TOTAL is skipped (no double shift)', () => {
-    const r = applyRippleAfterClip(CANVAS, COUPLED, 'a', 'name:body', 30);
-    expect(r.source).toContain('const TOTAL = 330;');
-    expect(r.source).toContain('from={TOTAL - 60}'); // untouched — follows the const
-    expect(r.shifted).toEqual([]);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// TransitionSeries storyline — series clips get NO from; TOTAL still moves.
-
-const SERIES = [
-  "import { TransitionSeries } from '@remotion/transitions';",
-  'const S1 = 90;',
-  'const S2 = 120;',
-  'const XF = 15;',
-  'const TOTAL = S1 + S2 - XF;',
-  'const Comp = () => (',
-  '  <TransitionSeries>',
-  '    <TransitionSeries.Sequence name="s1" durationInFrames={S1}><Video src="a.mp4" /></TransitionSeries.Sequence>',
-  '    <TransitionSeries.Transition presentation={fade()} timing={linearTiming({ durationInFrames: XF })} />',
-  '    <TransitionSeries.Sequence name="s2" durationInFrames={S2}><Video src="b.mp4" /></TransitionSeries.Sequence>',
-  '  </TransitionSeries>',
-  ');',
-  'function Canvas() {',
-  '  return (',
-  '    <DCArtboard id="a"><VideoComp component={Comp} durationInFrames={TOTAL} fps={30} /></DCArtboard>',
-  '  );',
-  '}',
-].join('\n');
-
-describe('applyRippleAfterClip — series storyline', () => {
-  test('series clips get no from shift; TOTAL const merges the delta', () => {
-    const r = applyRippleAfterClip(CANVAS, SERIES, 'a', 'name:s1', 12);
-    expect(r.totalEdited).toBe(true);
-    expect(r.shifted).toEqual([]);
-    expect(r.source).toContain('const TOTAL = S1 + S2 - XF + 12;');
-    // clip tags untouched
-    expect(r.source).toContain('durationInFrames={S1}');
-    expect(r.source).toContain('durationInFrames={S2}');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Refusals — loud, structured, never a silent mis-shift.
-
-describe('applyRippleAfterClip — refusals', () => {
-  test('unresolvable downstream from refuses with the clip named', () => {
-    const SRC = STANDALONE.replace('from={A + 100}', 'from={computeStart()}');
-    let err: unknown;
-    try {
-      applyRippleAfterClip(CANVAS, SRC, 'a', 'name:one', 12);
-    } catch (e) {
-      err = e;
-    }
-    expect(err).toBeInstanceOf(RippleError);
-    expect(String((err as Error).message)).toContain('name:three');
-  });
-
-  test('unresolvable TOTAL const refuses', () => {
-    const SRC = STANDALONE.replace('const TOTAL = 300;', 'const TOTAL = computeTotal();');
-    expect(() => applyRippleAfterClip(CANVAS, SRC, 'a', 'name:one', 12)).toThrow(RippleError);
-  });
-
-  test('a shift below frame 0 refuses', () => {
-    expect(() => applyRippleAfterClip(CANVAS, STANDALONE, 'a', 'name:one', -120)).toThrow(
-      RippleError
-    );
-  });
-
-  test('unknown clip refuses', () => {
-    expect(() => applyRippleAfterClip(CANVAS, STANDALONE, 'a', 'name:nope', 12)).toThrow();
-  });
-});