Repository navigation
v0.32.0 — proof you can read
Proof you can read. Every picture the preview tools make now carries the
edit's names, timecodes and cuts, drawn by the server, and comes back to the
model as an MCP image block beside its path, so a cut is read off the picture
instead of taken on trust. The reports agree with the pictures: one clip
count, every marker, edit points that are not all cuts, and a flash-frame
check that reads the picture as it is seen. No new operations.
preview_render's default size moves and nine outputs change shape; all of
it is under Changed, so a cut in progress can tell which apply.
Not verified in a host UI. The image blocks and the resource link were
checked on the wire through server.call_tool on mcp 1.28.1 and 2.3.0, not
displayed in Claude Desktop.
One rule for lengths, wherever a reader adds them up: whole frames at the
timeline's rate (121f), so a start plus a length is the next start (the
sheet's "5.0s" was 121 frames, and the next clip started at 10:01). One rule
for ranges: in-out with the out-point exclusive, as Final Cut's are, and the
length after it (00:00:05:01–00:00:06:11 · 34f, so out minus in is the
length); no "to", no inclusive out-points. The pictures write the dash as
- because the bundled font has no en dash. One colour rule on every
picture: cyan text is a record time (rec 00:00:15:03, REC 00:00:18:00)
and cyan marks are the cut that lives on it; source times are white or grey;
red is a failure.
Changed (existing outputs moved)
preview_renderis 1280x720 by default (was 854x480;heightstill
sets it). The reply ends with a poster frame (the middle of the timeline)
as an image block and aresource_linkto the MP4.burn_in: truewrites a
second file,<name>_proxy_burnin.mp4, with one opaque true-black chip
inside 5% action safe (64 px in and 36 px up at 1280x720) on every frame:
REC 00:00:18:00 · f432 Bench (L1)(the record time and frame, and what
is ON SCREEN, top layer first),SRC Bench.mov 00:00:00:21(the top
layer's source file and timecode, as Resolve's data burn-in shows it) and,
while it covers a clip,over Squat.mov 00:00:15:20(that clip's file and
source timecode, read through it). It is composited onto the clean proxy AFTER
verify_lanes()has read it: the instrument measures the timeline's
pixels, never our labels.preview_sheetis one composed sheet, not one loose unlabelled PNG per
cut with no paths in the reply: every VIDEO clip in record order, connected
ones included and badged with their lane (#5 L1), each with its number,
name, length in frames, record timecode (rec, cyan) and source in-point
(src: an in-point and a length make the range, so no out-point is
printed to be read as inclusive); in grey, a connected card says what it
plays over (over #4) and that it ends early (ends 1f before #6), two
cards that show the same frames say so (dup 66f with #5, diagnose's
WARN), and a dissolve is a bowtie centred in the gutter on its cut and a
dissolve 12f inline on the card it leads into; a flash in the picture
is ONE red badge, as diagnose counts it once: a red frame round the card
whose picture flashes andflash 1f 00:00:20:03 · src 00:00:17:23under
it; a header with the duration as timecode, the frame rate, the clip count
("6 clips + 1 connected") and the file'ssha256prefix, labelled. At
most 12 frames a page, extra pages numbered, and a page that does not hold
every clip says where the rest are (page 2: #5-#7 and the dissolve); up
to 4 pages inline.layout: "phone"draws two columns on a 780 px page
for a 390 px screen.preview_checkis redrawn (was a 1200x168 ffmpeg tile over a
waveform with no times): 1232 px wide, two BANDS, each a row of four
frames 240 px wide over its own ruler and its own waveform on that band's
time axis (the frames sit at their own times, as in Final Cut's filmstrip
over its waveform); each frame's timecode under it; every ruler label
hangs from its tick, left-anchored as Final Cut draws them, at one fixed
step; the waveform rectified as Final Cut draws it, RMS (cyan) over peak
(grey) up from a baseline in dB, -60 to 0, with 0, -20 and -40 dB ticked
at the band's edge and each label's ink centred on its tick; the dashed
line is the silence detector's own threshold and is labelled with it
(-40 silence, from the value the detection used); every silence of
0.3 s or longer shaded and named once (silence 1.5s (36f)), and in the
next band where it ends (silence to 00:00:06:12), clear of every line.
cutmarks a cut and shows
the frame either side. Newfilepath(the timeline): the frames the edit
removed are dimmed and tagged, the removed span is a grey bar on the ruler
(the edit working, not a failure, so never red), the cut's out-point is
marked on the band it falls in and its in-point on its own (a triangle on
the ruler and a line through the waveform, each at its own time; no
thumbnail is lit), and off the band grid, under a rule and a heading, the
join as played: the last and first kept frames side by side, each
captioned with where it plays and what it is in the file, the record time
read through its own clip (rec 00:00:10:00oversrc 00:00:05:00,
rec 00:00:10:01oversrc 00:00:06:11), and what the edit took, read
from the edit (cut at rec 00:00:10:01,last kept src 00:00:05:00,first kept src 00:00:06:11,
removed 00:00:05:01-00:00:06:11 · 34f,silence 36f, 1f kept each side).framesmust be even, 2 to 8 (two bands of up to four); the
default is still 8. The reply writes every range one way
(src 00:00:03:00–00:00:09:00 · 144f; it said[3s - 9s]and
5.00s to 6.50s).preview_framereturns its frame inline (scaled into the vision budget
when larger; the file keeps full size) and is the frame its timecode names
(ffmpeg returns the first frame at or after a seek; it now seeks a quarter
frame before a seek).burn: trueburnsSRC Squat.mov 00:00:07:06 · f174
inside 5% action safe, the source time in white.detect_scenesadds a picture per page of 3 cuts: the frame before and
the frame after each cut with their own timecodes (00:00:02:11|
00:00:02:12), the record time, the detector's score against its
threshold (ffmpeg'slavfi.scene_score, now recorded and cached with the
scene), the clip, and the scenes with their lengths (the frame timecodes
in white, the record time cyan). "source = timeline"
is said once when every cut's source time is its record time.validate_timelineleads with its verdict (## Verdict: FAIL · 1 FAIL, 2 WARN, 1 INFO, counted from the issues), then the health score; a
✓ PASS/⚠︎ WARN/✗ FAIL/· INFOcolumn with the word beside the
glyph, aFoundcolumn (what each check found, so a PASS is 0) and a
Wherecolumn; issues as a table with a timecode each. Duplicates count
connected clips and are two rows:Duplicate frames, a WARN when two uses
of one file show the same frames, naming the overlap (Bench.mov source 00:00:00:06–00:00:03:00 · 66f) and WHERE those frames play, each record
range read through its clip (00:00:00:00–00:00:02:18, 00:00:17:09–00:00:20:03), andReused source, INFO for different ranges
of one file. Three new checks:Transition handles(the media each side
has against what the transition draws on, in frames, from the parsed asset
lengths:1 checked; Press tail needs 6f, has 6f, Finish head needs 6f, has 6f),Offline media(FAIL when a clip's file is not where the XML
points) andFrame rate and size(each source's rate and size against
the sequence's, read with ffprobe: a rate Final Cut would retime is a WARN;
a source the conform scales up more than 1.5x is a WARN, "640x360 in a
1920x1080 sequence (scaled up 3x: soft, a post house would not pass it)",
and any other size is INFO). ANot checked:line names what it cannot
see (loudness, true peak, black or frozen frames, audio sync). The health
score counts only the checks that ran and says how many ("84% from the 7
checks below"); INFO costs nothing (it cost a point), FAIL -10, WARN -3.
The fix line is printed only for a check that failed, as the grouped call
that runs it (edit · fix_flash_frames,edit · fill_gaps); it named
flat tools for checks that had passed.analyze_timeline: "Clips: 6 clips + 1 connected" (the same words as
the sheet header and the text timeline, which said "7 clips"), "Edit
points: 5 (4 cuts, 1 dissolve)" (was "Total Cuts: 5"), the duration as
timecode and frames;Pacing (spine clips)says what its numbers count
and adds the shortest picture actually on screen, read from the
composited frame ("Shortest on screen: 1f (Squat, flash at
00:00:20:03)"); "Edits/minute: 9.9 · cuts/minute 8.0" (the one
"Cuts/minute" counted the dissolve as a cut); anAudiosection (the
sequence's audio layout and rate, how many clips play sound, each sound
file's channels and sample rate, measured); and aDiagnoseline with
every count diagnose prints, from the same checks ("Verdict FAIL: 1 FAIL
(flash 00:00:20:03), 2 WARN, 1 INFO"), so inspect never reads lighter
than diagnose.preview_timeline: line 1 ends with the file'ssha256prefix; a
time row (every label starting on its own tick, the last one too:30.0s),
a ruler and a legend (^ marker, [=] clip, X dissolve (D in the list), ! flash), a marker row, the lanes above
the spine (a lane clip named beside its bar), the spine with anXon
each transition's cut, the lanes below; then an EDL in fixed columns,
every value under its own header: every clip in record order (number,
trackAVfor picture and sound,VorAotherwise,L1 AVon a lane;
record in and out, length in frames, the transition INTO it in thetr
column as CMX writes it,D 12f, clip, source file, source in and out),
each marker as a^row at its place with its name and kind in the note,
the dissolve as aDrow with its span in the record columns, its name
under clip and "Press > Finish, centred on 00:00:24:22" in the note, and a
flash in the picture as a!row at its time ("flash between Bench (L1)
and Press"). The
render's "Substituted" notes are no longer printed here (preview_render
reports them). Was one#row per clip.preview://serves theviewapp with the timeline inlined (one
JSON block,<escaped), so the resource and the inline app are one
picture. Outside an MCP Apps host it is read only and says so; its edit
controls are visibly off (dashed,aria-disabled). The legacy static
rendererfcpxml/preview.pyand the old checkfcpxml/visual.pyare
deleted: code importingfcpxml.preview.render_timeline_htmlor
fcpxml.visual.visual_checkmust move to
fcpxml.timeline_app.render_page_htmlandfcpxml.proofs.visual_check.- The
viewapp (and sopreview://): zoom to fit fits the whole
sequence however long (an 8 px/s floor ran a 164 s cut 14 s past the edge
with no sign of it); every clip carries its number, inside its box, or
just above it on a leader when the box is too narrow (just below for a
lane under the spine), and the key under the timeline lists every clip, as
many as the header counts; the clip count reads "N clips + M connected";
the role tag is 12 px capitals (it was 9 px); the marker field's
placeholder is the secondary-text grey#8C8C8C, 5.6:1 on its panel (the
browser's#757575default was 4.07:1). - The neutrals are exact greys (
fcpxml/palette.py): panel#121212,
raised#1C1C1Cand the rest r = g = b; they carried a blue tint (18,18,22
and 28,28,34). The frozen logo and card keep the 0.31 greys until they are
regenerated on purpose. - Counted nouns are written out in every tool's output ("1 transition
and 2 markers", "Relinked 2 media references", "Deleted 1 clip"): no
"(s)" anywhere (fcpxml/words.py).
Fixed
- A dissolve after a run of hard cuts failed the full render.
xfade
refuses inputs on different timebases, and aconcatoutput runs on
1/1000000 against a trimmed clip's 1/24; ffmpeg failed the graph and the
fallback rendered every transition as a hard cut and dropped the sound. On
the gym fixture 0.31.0 reports exactly that; 0.32.0 compiles the dissolve
and mixes the audio. Each xfade input is set to 1/24 first. analyze_timelinecounted only timeline-level markers and read
"Markers Total: 0 / Chapters: 0" for a cut with four chapter markers on its
clips. It counts the timeline's, every clip's and every connected clip's.- A flash frame made by a connected clip passed QC.
validate_timeline
checked clip lengths only, so a connected clip ending one frame before the
next cut (one frame of the spine showing between them) read PASS. It now
also reads the composited picture frame by frame, top layer first, and a
run shorter than six frames anywhere in it is a flash: on the gym fixture,
✗ FAIL 00:00:20:03 Flash frame in the picture: Squat shows for 1f between Bench (L1) and Press(one frame is under the two-frame critical line, so
it is a FAIL, as a one-frame clip always was). The fix is checked
against the media and says what it costs: "extend Bench (L1) out by 1f,
to src 00:00:03:01 (Bench.mov has media to 00:00:05:12; the duplicate with
Bench grows to 67f)"; Press has no head media, so it says it cannot start
earlier as a roll; a ripple is offered last with what it moves ("Press,
Finish, 1 transition and 2 markers 1f earlier"). - The warning sign could render as an emoji. Every
⚠the server prints
carries U+FE0E (text presentation); the tests scanserver.pyand
tools/for any glyph with an emoji form, written or escaped.
Added
fcpxml/raster.py: a pure-Python raster with ffmpeg as the encoder and
decoder. No Pillow, nodrawtext(ffmpeg builds without libfreetype
exist), no new required dependency. Text is one bundled open-licence
bitmap font, Spleen 12x24 and 16x32 (BSD-2-Clause;fcpxml/fonts/,
shipped as package data with its licence), scaled by whole pixels.
read_textreads drawn text back off the pixels (PNG, JPEG, H.264) and is
what the timecode gates use. A TrueType face was not added (see Not done).fcpxml/proofs.py: the sheet, the check, the scenes strip, the
burn-in, the text timeline, andpicture_runs(what fills the frame, frame
by frame), on one palette (true black, cyan#00E5FF, red only for a
failure: "media missing" and a flash in the picture; a removed span is the
edit working and is grey).- The legibility rule, from Claude's vision docs
(https://platform.claude.com/docs/en/build-with-claude/vision, "Resolution
and token cost", read 2026-11-13): an image is kept at full size when its
long edge is at most 1,568 px and its ceil(w/28) x ceil(h/28) patches number
at most 1,568 (the brief's "about 1500" is that 1,568; the high-resolution
tier allows 2,576 px and 4,784 patches). Every page stays inside the
standard tier (sheet 1344 px, check 1232 px), capitals are at least 14 px tall
at the size they are delivered at, and a page holds at most 12 frames. An
inline image block is at most 1.5 MB (the docs allow 10 MB of base64 per
image on the API and 5 MB on Bedrock): PNG, else a light JPEG, else the
path alone with a line saying so. demo/fixtures/gym_session.py: the real-footage fixture, the author's
own gym session from the 0.31 hero (silent proxies plus a synthesised
tone), built through the server's own tools: an EDL import, the rests cut
byremove_media_silence, a dissolve, chapter markers and a connected
clip, plus one take with hard cuts fordetect_scenes. Not in the wheel.
Its connected clip ends a frame before the next cut on purpose: it is the
picture-flash test case.fcpxml/words.py:plural(2, "marker")-> "2 markers".- Tests:
test_proofs.py(77),test_visual.pyrewritten for the banded
check (15),test_preview.pyrewritten for the inlined page (10), the page
fit, numbers, key and read-only controls intest_app_labels.py, the font
in the built wheel (test_packaging.py), exact-grey tokens in
test_palette.py. The suite stubs the cmux preview hook, so a test run
never paints a picture beside the author's terminal. The publish job draws
text with the installed wheel's font. The scenes-strip gate names the
ffmpeg backend: with thescenesextra installed, "auto" picks
PySceneDetect, which hands back no per-cut score to read against.
Gates, each broken once in the real code and seen red (2026-11-13)
158 mutations on mcp 1.28.1, all red; 40 of them (the image blocks,
the burn order, the reply text, the scenes strip, diagnose and inspect) also
on mcp 2.3.0 with the intelligence and scenes extras installed, all
red. One control the other way: the check's ruler with ticks four times
denser keeps its labels apart by labelling every third tick, and the gate
accepts it (green). Every gate reads the OUTPUT and compares it
with a truth the test computes from the PARSED timeline with its own
timecode arithmetic.
- The sheet: each cell's
rectimecode read back off the PNG is its clip's
start (red a frame late), the phone page also read at 390 px; the connected
clip has its own#5 L1cell (red with the sheet spine-only); the three
Squat takes differ by their source in and out (red with the source printed
as the record time); starts plus lengths make the next start (red with
lengths in seconds); the header's labelledsha256prefix is the file's
(red unlabelled); the bowtie carries the dissolve's length (red without). - One clip count in the text timeline,
analyze_timelineand the sheet
header (red when the text timeline counts 7); every marker counted (red
timeline-only); "4 cuts, 1 dissolve" (red "5 cuts"). - The check: each thumbnail's centre, read through the ruler DRAWN under it,
is its printed timecode to a frame (red with the ruler at the round-1
scale); every tick within 1 px on every row it claims (red at +2 px); the
removed frames dimmed and tagged, the cut pair's frames and record time
(red undimmed, red with the pair a frame late); the waveform's RMS height in dB and the
threshold dashed on every column (red linear, red without the line); a
silence named once (red twice); the silence box an exact grey (red with
the 0.31 blue-tinted panel). - The burn: every one of the 724 frames' two lines read back (red naming the
spine clip, red with the spine's source, red a frame ahead); the chip
opaque black (red at 70%); burning beforeverify_lanes()fails the lane
instrument on a bottom-left quarter PiP and the clean render verifies (red
whenrender_proxyverifies the burned file); the dissolve renders in the
full graph (red with the timebase reset taken out). - The frame: the chip's file, timecode and frame number (red bare
timecode); the picture is the frame named, decoded by index on testsrc2
(red seeking half a frame after). - The scenes strip: each before and after timecode, the score read against
ffmpeg's own metadata, the before frame decoded by index (red with the
round-1 seek, which showed the frame AFTER the cut on both sides), the
scene list's lengths (red one frame off). - Diagnose: the picture flash at 00:00:20:03 (red spine-only); fix lines only
for what failed (red always printed); connected duplicates and the overlap
(red spine-only); INFO free (red at a point each). - The text timeline: no render notes (red with them back), every EDL row
against the parsed clips. - The page: the whole sequence in the width (red with the 8 px/s floor),
numbers with a key (red never shown), controls marked read only (red
withoutaria-disabled), the role tag 12 px (red at 9). - Round 3, the check: no label within 8 px of a line or mark, read off the
PNG and from the check's own record of its marks (red with the silence
label back at the silence start, under the cut line; the rule itself red
blind and red without its 8 px); the removed span not red anywhere
outside the pictures, and red in source only beside a "red: failure"
comment (red with the bar back in red, with or without a comment); the
padding read from the edit, on a synthesised silence cut 2f after its
start and 1f before its end (red with "1f kept each side" or "34f"
hardcoded, red with the silence a frame long); the out-point found on
band 1 and the in-point on band 2 through each band's own drawn ruler, to
a frame (red with the in-point unmarked, red with it drawn at 06:22, red
with a thumbnail lit); the join 32 px under the bands, under a full-width
rule and its heading, nothing else below the bands (red with no gap, no
rule, no heading); every ruler label hanging from its tick at one step,
never within 8 px of the next (red centred, red pulled in at the edge, red
with denser ticks and no step); 0, -20 and -40 dB labelled at their
heights (red unlabelled, red 6 px off); every range in-out with its
length, exclusive (red with the source range's out inclusive, red with
"to", red with the reply's silences in seconds "to", red with the
picture's hyphen in the reply). - Round 3, the reports: edits and cuts per minute (red with one
"Cuts/minute", red counting the dissolve); duplicate frames and reused
sources on two rows (red merged, red with reuse a WARN); the flash fix
checked against the media (red offering a roll Press has no media for,
red never offering the extension, red with a ripple that names nothing it
moves); handles from the parsed media (red unchecked, red at a guessed
12f, red with a short handle passing), offline media (red never seen),
rate and size (red never seen, red with the rate never compared), the
"Not checked" line (red without), the health counting the checks that ran
(red at a fixed 9); inspect's diagnose line and audio section (red
without each, red with the channels not measured); U+FE0E on every⚠
(red without it, inserver.py's escape and intools/nle.py). - Round 3, the sheet and the text timeline:
over #4(red without), the
flash chip on both cards (red without), "#7 and the dissolve on page 2"
(red without the dissolve), the bowtie centred in the gutter (red on the
picture) and "dissolve 12f in" (red without);30.0sstarting on its
tick (red right-aligned), the!flash row (red without), theDrow on
the grid (red off it, red at the cut only),D 12fon Finish's row (red
without). - Round 3, the page: every clip numbered and keyed, as many as the header
counts, at 980, 1440 and 390 px (red with no outside numbers, red keying
only the unnamed, red with no leader, red with numbers overlapping, red
with the inside numbers hidden), a one-second clip under the spine
numbered below its box (red numbered above), the placeholder at 4.5:1
(red at the browser default). - Round 4, the pictures: each dB label's INK, read off the PNG, centred
within 1 px of its tick (red hung from the tick as round 3 drew it, red
centred by its cell); the dashed line, read through the scale's own 0 and
-20 dB ticks, at the detector's threshold within 1 px at -40 and at -50 dB,
labelled with it, and the -48 dB section silence to one and sound to the
other (red 10 dB off, red with the label hardcoded, red with the detector
ignoring the threshold); each join frame captioned with its rec, read
through its clip, and its src (red with the src time as rec, red with the
clip's start as rec); band 2's silence named (red without); cyan only on
"rec " in every picture, read pixel by pixel on the sheets, the check,
the scenes strip, the frame and a decoded frame of the burned proxy (red
for the frame's src time, the join's src caption, the proxy's layer name,
the sheet's lane chip, the scenes' frame times, the whole join heading);
one red badge on the sheet per FAIL, on the card that flashes (red on two
cards as round 3 drew it, red with the badge's src not read through the
clip), "ends 1f before #6" and "dup 66f with" both cards (red without
each); the proxy chip's record frame, its "over" line read on the hidden
clip's own clock, every frame read back at the action-safe place (red a
frame off, red without the line, red on the top clip's clock, red at 16 px
as round 3 placed it) and the frame chip there too (red at 16 px). - Round 4, the reports: where duplicated frames PLAY, each range mapped back
through its clip to the shared source range (red with clip starts, red
without the offset into the clip); inspect's counts parsed and compared
with validate's (red dropping the WARN, red from the flash check only);
Found0 on every PASS row (red counting what was checked, red with the
column called Count); the verdict line and its counts (red without, red
ignoring a FAIL); the 3x upscale a WARN (red as INFO); "needs 6f, has 6f"
(red "6f of 6f"); "Pacing (spine clips)" and the shortest picture on
screen from the composited frame (red unscoped, red with the longest);
the text timeline parsed by its own header columns, a file or nothing
under source on every row, nothing under clip or source on a marker row,
AV on every clip with sound, the legend and the sha256 (red with V, with
the marker under clip, with the dissolve's clips under source, without
the legend, without the sha); no "(s)" in any string the server, its
tools and the fcpxml modules print, found by parsing them (red with
"(s)" back in the fix and in relink) and the extension's cost (red
without). - Kept from round 1: the image block on the wire and its cap (red dropped,
poster dropped, journal seam, cap ignored), the 6 px font, the 1,568 px
edge, 12 cells, collisions, truncation, red only for failure, the font in
the wheel,<escaped in the page and the page drawing itself.
Not done
- No TrueType path. The bitmap face meets the 14 px rule at every size
delivered, and the read-back gates depend on its exact glyphs; an optional
extra would add a second face for no reader. - The phone sheet takes two pages for seven clips (six cells a page):
four lines under each cell at 2x leave room for three rows. - The ffmpeg scene backend finds 2 of the 3 cuts in the fixture's take
(unchanged; PySceneDetect is thescenesextra, whosedetect()does not
hand back a per-cut score: the strip says "score not recorded" there). - Residue for 0.34, not touched here: the three Squat pieces join in one
frame on the hero's rewind (73 to 74), and 1 px slivers at 103 to 111 as
clips leave.