@1agh/maude 1.0.9 → 1.2.0

package/apps/studio/test/text-editability-stamp.test.ts

@@ -1,131 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { applyTextEdit } from '../canvas-edit.ts';
-import { transpileCanvasSource } from '../canvas-pipeline.ts';
-
-// Phase 6 (unified-text-editing) — the build-time `data-cd-editable="text"`
-// marker must agree EXACTLY with applyTextEdit's acceptance (canvas-edit.ts):
-// stamped ⇔ a commit would save. See isInlineEditableText in
-// canvas-pipeline.ts (the mirrored predicate).
-
-const FIXTURE = `export default function Fixture() {
-  return (
-    <div>
-      <h1>Maude desktop E2E</h1>
-      <p>
-        Deterministic, static canvas — proves the native shell booted the
-        sidecar, navigated the webview, and rendered a canvas.
-      </p>
-      <p>Total: {1 + 1} items</p>
-      <span>{title}</span>
-      <h2>{'Quoted title'}</h2>
-      <button>
-        Save
-      </button>
-      <section>
-        <em>nested</em>
-      </section>
-      <div />
-    </div>
-  );
-}
-const title = 'x';
-`;
-
-function stamped(withIds: string, tag: string): boolean {
-  const m = withIds.match(new RegExp(`<${tag}[^>]*>`));
-  if (!m) throw new Error(`tag <${tag}> not found in output`);
-  return m[0].includes('data-cd-editable="text"');
-}
-
-describe('data-cd-editable build-time stamp', () => {
-  const { withIds } = transpileCanvasSource('/virtual/Fixture.tsx', FIXTURE);
-
-  test('single static JSXText gets the marker', () => {
-    expect(stamped(withIds, 'h1')).toBe(true);
-    expect(stamped(withIds, 'button')).toBe(true); // whitespace-framed text
-  });
-
-  test('multi-line static JSXText gets the marker', () => {
-    expect(stamped(withIds, 'p')).toBe(true); // first <p> — static prose
-  });
-
-  test('mixed static+expression content does NOT get the marker', () => {
-    // <p>Total: {1 + 1} items</p> — renders as leaf-looking text nodes, but
-    // the source is mixed → applyTextEdit refuses → must not be offered.
-    const second = withIds.match(/<p[^>]*>Total:/);
-    if (!second) throw new Error('mixed <p> not found');
-    expect(second[0].includes('data-cd-editable')).toBe(false);
-  });
-
-  test('dynamic expression content does NOT get the marker', () => {
-    expect(stamped(withIds, 'span')).toBe(false); // {title}
-  });
-
-  test("{'string literal'} single child DOES get the marker (DDR-150 P1)", () => {
-    expect(stamped(withIds, 'h2')).toBe(true);
-  });
-
-  test('containers and empty elements do NOT get the marker', () => {
-    expect(stamped(withIds, 'section')).toBe(false); // element child
-    const selfClosed = withIds.match(/<div [^>]*\/>/);
-    if (!selfClosed) throw new Error('self-closed div not found');
-    expect(selfClosed[0].includes('data-cd-editable')).toBe(false);
-  });
-
-  test('marker agrees with applyTextEdit acceptance for every stamped element', () => {
-    // Every data-cd-id that carries the marker must be accepted by the
-    // engine; every one without it (that has text-ish content) refused.
-    const opens = withIds.match(/<[a-z][^>]*data-cd-id="[^"]+"[^>]*>/g) ?? [];
-    for (const open of opens) {
-      const id = /data-cd-id="([^"]+)"/.exec(open)?.[1];
-      if (!id) continue;
-      const kind = /data-cd-editable="(text|var)"/.exec(open)?.[1];
-      let accepted = true;
-      try {
-        applyTextEdit('/virtual/Fixture.tsx', withIds, id, 'replacement');
-      } catch {
-        accepted = false;
-      }
-      // `text` (literal) MUST be accepted with no runtime context. `var`
-      // (a {variable}) is traced back at commit and needs occurrence/before —
-      // its acceptance is covered by dynamic-text-edit.test.ts, so only assert
-      // it isn't offered where the engine would hard-refuse a literal edit.
-      // Unmarked text-ish elements MUST be refused (no dead-end editor).
-      if (kind === 'text') {
-        expect(`${open} accepted=${accepted}`).toBe(`${open} accepted=true`);
-      } else if (!kind) {
-        expect(`${open} accepted=${accepted}`).toBe(`${open} accepted=false`);
-      }
-    }
-  });
-});
-
-describe('applyTextEdit sibling integrity (Task 6.3)', () => {
-  test('editing the h1 leaves every sibling byte-identical', () => {
-    const { withIds } = transpileCanvasSource('/virtual/Fixture.tsx', FIXTURE);
-    const h1Id = /<h1[^>]*data-cd-id="([^"]+)"/.exec(withIds)?.[1];
-    if (!h1Id) throw new Error('no h1 id');
-    const { source: out } = applyTextEdit('/virtual/Fixture.tsx', withIds, h1Id, 'New title');
-    // The h1 text changed…
-    expect(out).toMatch(/<h1[^>]*data-cd-editable="text"/);
-    expect(out).toContain('New title');
-    expect(out).not.toContain('Maude desktop E2E');
-    // …and EVERYTHING ELSE is byte-identical: strip the h1 element line from
-    // both versions and compare the rest wholesale.
-    const strip = (s: string) => s.replace(/<h1[^>]*>[^<]*<\/h1>/, '<h1/>');
-    expect(strip(out)).toBe(strip(withIds));
-  });
-
-  test('editing the multi-line p preserves its own whitespace framing', () => {
-    const { withIds } = transpileCanvasSource('/virtual/Fixture.tsx', FIXTURE);
-    const pId = /<p[^>]*data-cd-id="([^"]+)"[^>]*>\s*\n\s*Deterministic/.exec(withIds)?.[1];
-    if (!pId) throw new Error('no p id');
-    const { source: out } = applyTextEdit('/virtual/Fixture.tsx', withIds, pId, 'Short.');
-    // Leading/trailing whitespace of the JSXText survives (JSX indentation).
-    expect(out).toMatch(/<p[^>]*>\s*\n\s*Short\.\s*\n\s*<\/p>/);
-    // Siblings untouched.
-    expect(out).toMatch(/<h1[^>]*data-cd-editable="text"/);
-    expect(out).toContain('Maude desktop E2E');
-    expect(out).toContain('Total: {1 + 1} items');
-  });
-});

package/apps/studio/test/timeline-comp-target.test.ts

@@ -1,139 +0,0 @@
-// timeline-comp-target — issue #75 regression coverage.
-//
-// The Timeline draws the rows of ONE artboard's comp but drives the transport
-// through a targeted postMessage, so "which comp id" is a real decision. The
-// old rule matched the parsed row total against `durationInFrames`; two comps
-// of equal length collapsed onto the FIRST one, so Play moved artboard #1 while
-// the panel showed artboard #2. These tests pin the artboard-first rule.
-
-import { describe, expect, test } from 'bun:test';
-
-import {
-  activeComp,
-  resolveCompTarget,
-  sanitizeArtboardText,
-} from '../client/panels/timeline-comp-target.js';
-
-const comp = (id: string, artboardId: string | null, durationInFrames: number) => ({
-  id,
-  artboardId,
-  durationInFrames,
-  fps: 30,
-  width: 1920,
-  height: 1080,
-  artboardLabel: artboardId,
-});
-
-describe('resolveCompTarget', () => {
-  test('empty / missing comps → null', () => {
-    expect(resolveCompTarget([], { artboardId: 'a' })).toBe(null);
-    // @ts-expect-error — defensive: the shell hands through canvas-origin data.
-    expect(resolveCompTarget(null, {})).toBe(null);
-  });
-
-  test('THE BUG — equal-duration comps resolve by artboard, not by order', () => {
-    const comps = [comp('videocomp-1', 'intro', 150), comp('videocomp-2', 'outro', 150)];
-    expect(resolveCompTarget(comps, { artboardId: 'outro', total: 150 })).toBe('videocomp-2');
-    expect(resolveCompTarget(comps, { artboardId: 'intro', total: 150 })).toBe('videocomp-1');
-  });
-
-  test('an author-set comp id equal to the artboard id also matches', () => {
-    const comps = [comp('intro', null, 150), comp('outro', null, 150)];
-    expect(resolveCompTarget(comps, { artboardId: 'outro', total: 150 })).toBe('outro');
-  });
-
-  test('no artboard known → an UNAMBIGUOUS duration still identifies the comp', () => {
-    const comps = [comp('videocomp-1', 'intro', 150), comp('videocomp-2', 'outro', 90)];
-    expect(resolveCompTarget(comps, { artboardId: null, total: 90 })).toBe('videocomp-2');
-  });
-
-  test('no artboard known + ambiguous duration → first comp (the only guess left)', () => {
-    const comps = [comp('videocomp-1', 'intro', 150), comp('videocomp-2', 'outro', 150)];
-    expect(resolveCompTarget(comps, { artboardId: null, total: 150 })).toBe('videocomp-1');
-  });
-
-  // Adversarial review 2026-08-12 — comp ids and artboard ids are separate
-  // author-chosen namespaces, so the weaker claim must never beat the real one.
-  test('an announced artboard OUTRANKS a comp that merely names itself after it', () => {
-    const comps = [comp('outro', 'intro', 150), comp('videocomp-2', 'outro', 150)];
-    expect(resolveCompTarget(comps, { artboardId: 'outro', total: 150 })).toBe('videocomp-2');
-  });
-
-  // The row parser derives the artboard lexically from the .tsx; canvas-lib
-  // reports the viewport one structurally. When the lexical claim names an
-  // artboard no comp is mounted in, the pan signal must still land the target.
-  test('candidate list — a stale first candidate falls through to the live one', () => {
-    const comps = [comp('videocomp-1', 'intro', 150), comp('videocomp-2', 'outro', 150)];
-    expect(resolveCompTarget(comps, { artboardId: ['ghost', 'outro'], total: 150 })).toBe(
-      'videocomp-2'
-    );
-    // First candidate wins whenever it DOES name a mounted comp.
-    expect(resolveCompTarget(comps, { artboardId: ['intro', 'outro'], total: 150 })).toBe(
-      'videocomp-1'
-    );
-    expect(resolveCompTarget(comps, { artboardId: [null, undefined, 'outro'] })).toBe(
-      'videocomp-2'
-    );
-  });
-
-  test('an artboard with no comp falls back rather than returning null', () => {
-    const comps = [comp('videocomp-1', 'intro', 150)];
-    expect(resolveCompTarget(comps, { artboardId: 'a-still-image-board', total: 150 })).toBe(
-      'videocomp-1'
-    );
-  });
-});
-
-// The artboard label is untrusted canvas-origin text rendered as shell chrome
-// (security-review 2026-08-12): a chip that can be made to read as a different
-// artboard than the transport is scoped to defeats its own purpose.
-describe('sanitizeArtboardText', () => {
-  test('strips bidi overrides + isolates', () => {
-    expect(sanitizeArtboardText('Intro\u202e')).toBe('Intro');
-    expect(sanitizeArtboardText('\u2066Outro\u2069')).toBe('Outro');
-    expect(sanitizeArtboardText('gnp\u202egpj.Hero')).toBe('gnpgpj.Hero');
-  });
-
-  test('strips zero-width, soft hyphen, BOM and C0/C1 controls', () => {
-    expect(sanitizeArtboardText('In\u200btro')).toBe('Intro');
-    expect(sanitizeArtboardText('\ufeffHero\u00ad')).toBe('Hero');
-    expect(sanitizeArtboardText('Line\nBreak\tTab')).toBe('LineBreakTab');
-    expect(sanitizeArtboardText('Bell\u0007')).toBe('Bell');
-  });
-
-  test('an all-invisible label reads as NO label, not as a blank chip', () => {
-    expect(sanitizeArtboardText('\u200b\u200b\u200b')).toBe(null);
-    expect(sanitizeArtboardText('   ')).toBe(null);
-    expect(sanitizeArtboardText('')).toBe(null);
-  });
-
-  test('non-strings are null, never coerced', () => {
-    expect(sanitizeArtboardText(undefined)).toBe(null);
-    expect(sanitizeArtboardText(null)).toBe(null);
-    expect(sanitizeArtboardText(42)).toBe(null);
-    expect(sanitizeArtboardText({ toString: () => 'nope' })).toBe(null);
-  });
-
-  test('caps length, and a cap that lands mid-space still trims', () => {
-    expect(sanitizeArtboardText('x'.repeat(500))).toHaveLength(120);
-    expect(sanitizeArtboardText(`${'x'.repeat(119)} yz`)).toBe('x'.repeat(119));
-  });
-
-  test('ordinary labels survive intact (accents, emoji, punctuation)', () => {
-    expect(sanitizeArtboardText('Přehled — 2. krok')).toBe('Přehled — 2. krok');
-    expect(sanitizeArtboardText('Hero 🎬')).toBe('Hero 🎬');
-  });
-});
-
-describe('activeComp', () => {
-  test('reads meta off the SAME comp the transport targets', () => {
-    const comps = [comp('videocomp-1', 'intro', 150), comp('videocomp-2', 'outro', 90)];
-    expect(activeComp(comps, 'videocomp-2')?.durationInFrames).toBe(90);
-  });
-
-  test('unknown id → first comp (panel still renders); empty → null', () => {
-    const comps = [comp('videocomp-1', 'intro', 150)];
-    expect(activeComp(comps, 'nope')?.id).toBe('videocomp-1');
-    expect(activeComp([], 'x')).toBe(null);
-  });
-});

package/apps/studio/test/timeline-media-cache.test.ts

@@ -1,41 +0,0 @@
-// timeline-media-cache.test.ts — bug fix: dropping a clip on the timeline
-// used to always trim it to a flat 3s instead of its real duration
-// (durationInFrames was `Math.round(fps * 3)` regardless of the probed
-// media length). durationFramesForDrop is the pure decision the drop
-// handler in app.jsx now delegates to.
-
-import { describe, expect, test } from 'bun:test';
-
-import { durationFramesForDrop } from '../client/panels/timeline-media-cache.js';
-
-describe('durationFramesForDrop', () => {
-  test('uses the real probed duration, not the flat 3s default', () => {
-    // A 7.4s clip at 30fps must land at its own length (222 frames), not the
-    // fixed fps*3 = 90 frames the drop handler used to hardcode.
-    expect(durationFramesForDrop(30, 7.4)).toBe(Math.round(30 * 7.4));
-    expect(durationFramesForDrop(30, 7.4)).not.toBe(Math.round(30 * 3));
-  });
-
-  test('rounds to the nearest frame', () => {
-    expect(durationFramesForDrop(24, 2.501)).toBe(60); // 24 * 2.501 = 60.024
-  });
-
-  test('falls back to 3s when no duration was probed (null/failed probe)', () => {
-    expect(durationFramesForDrop(30, null)).toBe(90);
-    expect(durationFramesForDrop(30, undefined)).toBe(90);
-    expect(durationFramesForDrop(30, NaN)).toBe(90);
-  });
-
-  test('falls back to 3s for a non-positive probed duration', () => {
-    expect(durationFramesForDrop(30, 0)).toBe(90);
-    expect(durationFramesForDrop(30, -1)).toBe(90);
-  });
-
-  test('a caller can override the fallback (e.g. synthetic content)', () => {
-    expect(durationFramesForDrop(30, null, 5)).toBe(150);
-  });
-
-  test('never returns less than 1 frame', () => {
-    expect(durationFramesForDrop(30, 0.001)).toBeGreaterThanOrEqual(1);
-  });
-});

package/apps/studio/test/timeline-parse.test.ts

@@ -1,184 +0,0 @@
-// timeline-parse — DDR-148 Timeline sequence/keyframe parser.
-// Pure regex parse of a video-comp's sequence structure + interpolate windows.
-
-import { describe, expect, test } from 'bun:test';
-
-import { parseCompTimeline } from '../client/panels/timeline-parse.js';
-
-const COMP = `
-const A = 45;
-const XF = 15;
-const B = 60;
-const Intro = () => {
-  const frame = useCurrentFrame();
-  const o = interpolate(frame, [0, 14], [0, 1]);
-  const y = interpolate(frame, [10, 30], [24, 0]);
-  return <AbsoluteFill style={{ opacity: o }} />;
-};
-const Payoff = () => {
-  const frame = useCurrentFrame();
-  const s = interpolate(frame, [4, 20], [0.8, 1]);
-  return <AbsoluteFill style={{ transform: 's' }} />;
-};
-function Movie() {
-  return (
-    <TransitionSeries>
-      <TransitionSeries.Sequence durationInFrames={A}><Intro /></TransitionSeries.Sequence>
-      <TransitionSeries.Transition presentation={fade()} timing={linearTiming({ durationInFrames: XF })} />
-      <TransitionSeries.Sequence durationInFrames={B}><Payoff /></TransitionSeries.Sequence>
-    </TransitionSeries>
-  );
-}
-`;
-
-describe('parseCompTimeline', () => {
-  test('parses TransitionSeries sequences with const durations + overlap math', () => {
-    const r = parseCompTimeline(COMP, 90);
-    expect(r.total).toBe(90);
-    expect(r.sequences).toHaveLength(2);
-    expect(r.sequences[0]).toMatchObject({ label: 'Intro', from: 0, duration: 45 });
-    // Payoff starts at 45 - 15 (the transition overlaps back) = 30.
-    expect(r.sequences[1]).toMatchObject({ label: 'Payoff', from: 30, duration: 60 });
-  });
-
-  test('attributes interpolate windows to their sequence, offset to absolute frames', () => {
-    const r = parseCompTimeline(COMP, 90);
-    // Intro's [0,14] + [10,30] stay at from=0.
-    expect(r.sequences[0].keyframes).toEqual([
-      { from: 0, to: 14 },
-      { from: 10, to: 30 },
-    ]);
-    // Payoff's [4,20] is offset by its from=30 → [34,50].
-    expect(r.sequences[1].keyframes).toEqual([{ from: 34, to: 50 }]);
-  });
-
-  test('plain <Sequence from={M} durationInFrames={N}> uses absolute from', () => {
-    const src =
-      'function C(){ return <><Sequence from={20} durationInFrames={40}><Foo/></Sequence></>; }';
-    const r = parseCompTimeline(src, 60);
-    expect(r.sequences[0]).toMatchObject({ label: 'Foo', from: 20, duration: 40 });
-  });
-
-  test('a non-comp / unparseable source yields no sequences (scrub-only)', () => {
-    expect(parseCompTimeline('function C(){ return <div/>; }', 30).sequences).toEqual([]);
-    expect(parseCompTimeline('', 0).sequences).toEqual([]);
-  });
-
-  test('the comp meta total wins over the derived span', () => {
-    const r = parseCompTimeline(COMP, 200);
-    expect(r.total).toBe(200);
-  });
-
-  test('an <Audio> bed becomes its own row spanning the comp (DDR-148 music layer)', () => {
-    const src = `${COMP.replace(
-      '</TransitionSeries>',
-      '</TransitionSeries><Audio src="/.design/assets/music.mp3" />'
-    )}`;
-    const r = parseCompTimeline(src, 90);
-    expect(r.audio).toHaveLength(1);
-    expect(r.audio[0]).toMatchObject({ kind: 'audio', label: 'music.mp3', from: 0, duration: 90 });
-  });
-
-  test('a multi-comp canvas scopes the timeline to the media comp + its total', () => {
-    // Two VideoComps on one canvas: a plain intro (no media) + a reel (has
-    // <Audio>). The parser must show the REEL — its sequences, total, audio.
-    const src = `
-const IT = 40; const RT = 120;
-const Intro = () => <AbsoluteFill/>;
-function Movie(){ return <TransitionSeries><TransitionSeries.Sequence durationInFrames={IT}><Intro/></TransitionSeries.Sequence></TransitionSeries>; }
-const Clip = () => <AbsoluteFill/>;
-function Reel(){ return (<AbsoluteFill><TransitionSeries><TransitionSeries.Sequence durationInFrames={RT}><Clip/></TransitionSeries.Sequence></TransitionSeries><Audio src="/x/song.mp3"/></AbsoluteFill>); }
-export default function Canvas(){ return (<DesignCanvas>
-  <VideoComp component={Movie} durationInFrames={IT} fps={30} width={960} height={540} />
-  <VideoComp component={Reel} durationInFrames={RT} fps={30} width={960} height={540} />
-</DesignCanvas>); }
-`;
-    // The app passes the FIRST comp's duration (the intro, 40) — the parser must
-    // still pick the reel (media) and report its total (120) + audio.
-    const r = parseCompTimeline(src, 40);
-    expect(r.total).toBe(120);
-    expect(r.sequences).toEqual([expect.objectContaining({ label: 'Clip', duration: 120 })]);
-    expect(r.audio).toHaveLength(1);
-    expect(r.audio[0].label).toBe('song.mp3');
-  });
-
-  test('the Timeline scopes to the SELECTED artboard (follows the canvas)', () => {
-    const src = `
-const IT = 40; const RT = 120;
-const Intro = () => <AbsoluteFill/>;
-function Movie(){ return <TransitionSeries><TransitionSeries.Sequence durationInFrames={IT}><Intro/></TransitionSeries.Sequence></TransitionSeries>; }
-const Clip = () => <AbsoluteFill/>;
-function Reel(){ return (<AbsoluteFill><TransitionSeries><TransitionSeries.Sequence durationInFrames={RT}><Clip/></TransitionSeries.Sequence></TransitionSeries><Audio src="/x/song.mp3"/></AbsoluteFill>); }
-export default function Canvas(){ return (<DesignCanvas>
-  <DCArtboard id="intro" width={960} height={540}><VideoComp component={Movie} durationInFrames={IT} fps={30} width={960} height={540} /></DCArtboard>
-  <DCArtboard id="reel" width={960} height={540}><VideoComp component={Reel} durationInFrames={RT} fps={30} width={960} height={540} /></DCArtboard>
-</DesignCanvas>); }
-`;
-    // Selecting the intro artboard shows the INTRO — even though the reel has media.
-    const intro = parseCompTimeline(src, 40, 'intro');
-    expect(intro.total).toBe(40);
-    expect(intro.sequences).toEqual([expect.objectContaining({ label: 'Intro', duration: 40 })]);
-    expect(intro.audio).toHaveLength(0);
-    // Selecting the reel shows the reel + its music.
-    const reel = parseCompTimeline(src, 40, 'reel');
-    expect(reel.total).toBe(120);
-    expect(reel.audio).toHaveLength(1);
-  });
-
-  test('a clips array built via .flatMap() collapses to one generic row (documents the parser limit — see video-comp SKILL.md "Never build ... with .map()/.flatMap()")', () => {
-    const src = `
-const CLIP = 60; const XF = 15;
-const clips = ['assets/a.mp4', 'assets/b.mp4', 'assets/c.mp4', 'assets/d.mp4'];
-const TOTAL = clips.length * CLIP - (clips.length - 1) * XF;
-const ReelClip = ({ src }) => <AbsoluteFill/>;
-function Reel(){
-  return (<AbsoluteFill><TransitionSeries>
-    {clips.flatMap((src, i) => {
-      const seq = <TransitionSeries.Sequence key={\`s\${i}\`} durationInFrames={CLIP}><ReelClip src={src}/></TransitionSeries.Sequence>;
-      if (i === clips.length - 1) return [seq];
-      return [seq, <TransitionSeries.Transition key={\`t\${i}\`} presentation={fade()} timing={linearTiming({ durationInFrames: XF })}/>];
-    })}
-  </TransitionSeries></AbsoluteFill>);
-}
-`;
-    // Only ONE literal <TransitionSeries.Sequence> occurrence exists in the
-    // source text (written once inside the callback) — not the 4 clips that
-    // exist at runtime — and its durationInFrames={CLIP} is fine but the
-    // array-driven TOTAL isn't resolvable arithmetic, so scopedTotal falls
-    // back to the derived span.
-    const r = parseCompTimeline(src, 0);
-    expect(r.sequences).toHaveLength(1);
-    expect(r.sequences[0]).toMatchObject({ label: 'ReelClip', duration: 60 });
-  });
-
-  test('the corrected 4-literal-block worked example (video-comp SKILL.md) parses all 4 named clips + the literal-sum total', () => {
-    const src = `
-const XF = 15;
-const TOTAL = 60 + 60 + 60 + 60 - XF * 3;
-const Clip = ({ src, label }) => <AbsoluteFill/>;
-const Reel = () => (
-  <AbsoluteFill>
-    <TransitionSeries>
-      <TransitionSeries.Sequence name="clip-1" durationInFrames={60}><Clip src="assets/a.mp4" label="01" /></TransitionSeries.Sequence>
-      <TransitionSeries.Transition presentation={fade()} timing={linearTiming({ durationInFrames: XF })} />
-      <TransitionSeries.Sequence name="clip-2" durationInFrames={60}><Clip src="assets/b.mp4" label="02" /></TransitionSeries.Sequence>
-      <TransitionSeries.Transition presentation={fade()} timing={linearTiming({ durationInFrames: XF })} />
-      <TransitionSeries.Sequence name="clip-3" durationInFrames={60}><Clip src="assets/c.mp4" label="03" /></TransitionSeries.Sequence>
-      <TransitionSeries.Transition presentation={fade()} timing={linearTiming({ durationInFrames: XF })} />
-      <TransitionSeries.Sequence name="clip-4" durationInFrames={60}><Clip src="assets/d.mp4" label="04" /></TransitionSeries.Sequence>
-    </TransitionSeries>
-  </AbsoluteFill>
-);
-`;
-    const r = parseCompTimeline(src, 0);
-    expect(r.sequences).toHaveLength(4);
-    expect(r.sequences.map((s) => s.label)).toEqual(['clip-1', 'clip-2', 'clip-3', 'clip-4']);
-    expect(r.sequences.map((s) => s.duration)).toEqual([60, 60, 60, 60]);
-    // Sequence 1 at 0; each next clip starts durationInFrames - XF after the
-    // previous (the transition overlaps back), same crossfade math as the
-    // existing 2-clip test above.
-    expect(r.sequences.map((s) => s.from)).toEqual([0, 45, 90, 135]);
-    // 60*4 - 15*3 = 195, and it's a literal-arithmetic sum the parser resolves.
-    expect(r.total).toBe(195);
-  });
-});

package/apps/studio/test/timeline-scale.test.ts

@@ -1,65 +0,0 @@
-// timeline-scale.test.ts — Task 4 pure zoom/scale helpers.
-
-import { describe, expect, test } from 'bun:test';
-
-import {
-  clampPxPerFrame,
-  fitPxPerFrame,
-  frameToPx,
-  MAX_PX_PER_FRAME,
-  pxToFrame,
-  tickLabel,
-  tickStepFrames,
-  zoomAroundScroll,
-} from '../client/panels/timeline-scale.js';
-
-describe('fit + clamp', () => {
-  test('fit spans the viewport exactly', () => {
-    expect(fitPxPerFrame(900, 900)).toBe(1);
-    expect(fitPxPerFrame(1200, 300)).toBe(4);
-  });
-  test('clamp: never below fit, never above the max', () => {
-    expect(clampPxPerFrame(0.1, 900, 900)).toBe(1); // below fit → fit
-    expect(clampPxPerFrame(100, 900, 900)).toBe(MAX_PX_PER_FRAME);
-    expect(clampPxPerFrame(3, 900, 900)).toBe(3);
-    expect(clampPxPerFrame(null, 900, 900)).toBe(1); // absent → fit
-  });
-});
-
-describe('frame ↔ px round-trip', () => {
-  test('at any scale, px→frame(frame→px) is identity', () => {
-    for (const pxf of [0.5, 1, 3.7, 40]) {
-      expect(pxToFrame(frameToPx(123, pxf), pxf)).toBeCloseTo(123, 6);
-    }
-  });
-});
-
-describe('zoomAroundScroll', () => {
-  test('the anchor frame stays at the same viewport x', () => {
-    const prev = 1;
-    const next = 2;
-    const anchor = 300;
-    const prevScroll = 100; // anchor at viewport x = 200
-    const nextScroll = zoomAroundScroll(prev, next, anchor, prevScroll);
-    expect(frameToPx(anchor, next) - nextScroll).toBeCloseTo(frameToPx(anchor, prev) - prevScroll);
-  });
-  test('never scrolls negative', () => {
-    expect(zoomAroundScroll(2, 1, 10, 0)).toBe(0);
-  });
-});
-
-describe('tickStepFrames — density adapts 1 s → 10 f → 1 f', () => {
-  test('at fit on a long comp, ticks are whole/multi seconds', () => {
-    const step = tickStepFrames(0.3, 30); // 0.3 px/frame → 30f = 9px, needs ≥56px
-    expect(step % 30).toBe(0);
-    expect(step).toBeGreaterThanOrEqual(150);
-  });
-  test('zoomed to 8px/frame → single-frame ticks', () => {
-    expect(tickStepFrames(8, 30)).toBe(10); // 10f = 80px ≥ 56 → 10-frame ticks
-    expect(tickStepFrames(60, 30)).toBe(1); // 1f = 60px ≥ 56
-  });
-  test('labels: seconds at whole seconds, frames otherwise', () => {
-    expect(tickLabel(60, 30)).toBe('2s');
-    expect(tickLabel(45, 30)).toBe('45f');
-  });
-});

package/apps/studio/test/timeline-snap.test.ts

@@ -1,85 +0,0 @@
-// timeline-snap.test.ts — DDR-150 Task 15 (Polish). The pure snap helpers behind
-// clip move/trim: a dragged edge lands on the nearest second-tick / neighbor edge
-// / playhead within a threshold, and Alt (threshold 0) turns it off.
-
-import { describe, expect, test } from 'bun:test';
-
-import {
-  computeSnapTargets,
-  snapFrame,
-  snapThresholdFrames,
-} from '../client/panels/timeline-snap.js';
-
-describe('computeSnapTargets', () => {
-  test('includes 0, comp end, second ticks, neighbor edges, playhead — excludes the moving clip', () => {
-    const targets = computeSnapTargets({
-      fps: 30,
-      totalFrames: 120,
-      clips: [
-        { from: 0, duration: 30 }, // clip 0 — the one being moved (excluded)
-        { from: 45, duration: 30 }, // clip 1 — edges 45 + 75 should appear
-      ],
-      movingIndex: 0,
-      playhead: 88,
-    });
-    expect(targets).toContain(0); // start
-    expect(targets).toContain(120); // comp end
-    expect(targets).toContain(30); // second tick (1s @ 30fps)
-    expect(targets).toContain(60); // second tick (2s)
-    expect(targets).toContain(90); // second tick (3s)
-    expect(targets).toContain(45); // neighbor clip start
-    expect(targets).toContain(75); // neighbor clip end
-    expect(targets).toContain(88); // playhead
-    // the MOVING clip's own edges (0 already a tick; its end 30 is also a tick,
-    // but must not be added as a *clip edge* — dedup keeps it single + sorted)
-    expect(targets).toEqual([...targets].sort((a, b) => a - b));
-    expect(new Set(targets).size).toBe(targets.length); // deduped
-  });
-
-  test('clamps targets to [0, totalFrames]', () => {
-    const targets = computeSnapTargets({
-      fps: 30,
-      totalFrames: 50,
-      clips: [{ from: 40, duration: 40 }], // end 80 is out of range → dropped
-      movingIndex: -1,
-      playhead: 200, // out of range → dropped
-    });
-    expect(Math.max(...targets)).toBeLessThanOrEqual(50);
-    expect(targets).not.toContain(80);
-    expect(targets).not.toContain(200);
-  });
-});
-
-describe('snapFrame', () => {
-  const targets = [0, 30, 45, 60, 90, 120];
-
-  test('snaps to the nearest target within threshold', () => {
-    expect(snapFrame(32, targets, 4)).toBe(30); // 2 away
-    expect(snapFrame(43, targets, 4)).toBe(45); // 2 away
-  });
-
-  test('leaves the candidate unchanged when nothing is in range', () => {
-    expect(snapFrame(52, targets, 4)).toBe(52); // nearest (45/60) is 7/8 away
-  });
-
-  test('picks the CLOSER of two in-range targets', () => {
-    // 47 is 2 from 45 and 13 from 60 → 45.
-    expect(snapFrame(47, targets, 20)).toBe(45);
-  });
-
-  test('threshold 0 (Alt override) never snaps', () => {
-    expect(snapFrame(30, targets, 0)).toBe(30);
-    expect(snapFrame(31, targets, 0)).toBe(31);
-  });
-});
-
-describe('snapThresholdFrames', () => {
-  test('converts an ~8px radius into frames by the row width', () => {
-    // 8px on a 800px row spanning 400 frames → ~4 frames.
-    expect(Math.round(snapThresholdFrames(800, 401, 8))).toBe(4);
-  });
-
-  test('degrades safely on a zero-width row', () => {
-    expect(Number.isFinite(snapThresholdFrames(0, 100))).toBe(true);
-  });
-});