{ "format": "driftproof-answers/2", "receipt_hash": "3939420c0ea1f9e5b2bffbff5b7600ac53126a761fa20ca460d68f961727d13d", "model_id": "claude-opus-5-5", "answers": { "464e895b79d0448f63e093c771380750ca8128b92230463b1e2ede6121a8bfb6": "# Headline reveal: discovery to preview\n\nNothing has been run. This sequence stops at the final preview because rendering has not been approved.\n\n### 0. Start of turn\n```bash\nnpx hyperframes usage --json\nnpx hyperframes history begin --who claude --label \"Add headline reveal\"\nnpx hyperframes history --since mine --who claude # see the person's edits since last turn; build on them\n```\n\n### 1. Discovery: search the catalog before writing motion\nDescribe the effect in plain English, not the mechanism:\n```bash\nnpx hyperframes catalog --query \"reveal a headline one line at a time\" --json\n```\nCheck the envelope's `tier`, `dropped`, `unindexed` and `warnings` fields. A weak match on the `words` tier is normal. If the results look thin, I can offer the on-device tier, which is a one-time download of about 33 MB. I would only rerun with it if you agree:\n```bash\nnpx hyperframes catalog --query \"reveal a headline one line at a time\" --on-device -y --json\n```\nIf nothing fits, report the gap using the `report_gap` line from the envelope:\n```bash\nnpx hyperframes feedback --search-miss \"reveal a headline one line at a time\" --wanted \"\" --tier \n```\n\n### 2. Install the match\n`` is the result chosen in step 1. See `/hyperframes-registry` for details.\n```bash\nnpx hyperframes add \n```\n\n### 3. Author\nWire the headline into the composition following `/hyperframes-core`. To see where it lands on the timeline without reading every file:\n```bash\nnpx hyperframes timeline --json\n```\nIf no catalog item fits, write the motion by hand only after the search has come up empty.\n\n### 4. Fast feedback while editing\n```bash\nnpx hyperframes lint\n```\nRepeat after the first HTML pass and after any structural changes.\n\n### 5. Final gate\n`check` already runs lint, so lint isn't repeated before it.\n```bash\nnpx hyperframes check --snapshots\n```\n\n### 6. Visual inspection\nCapture frames across the reveal, plus a midpoint for each sub-composition if `data-composition-src` is used:\n```bash\nnpx hyperframes snapshot --range : --frames 8\nnpx hyperframes snapshot --at ,,\n```\nAt full resolution, look at text edges, line timing, and whether the final state is fully legible.\n\n### 7. Final Studio preview\n```bash\nnpx hyperframes preview --background\n```\n- Verify the URL returns HTTP 200.\n- Hand you the `#project/` link.\n- Ask whether to revise or render.\n- Keep the preview running until review ends.\n\n### 8. Close the turn\n```bash\nnpx hyperframes history end\n```\nIf `check` failed or you say the result got worse, I would run `npx hyperframes history undo --who claude` rather than hand-editing back.\n\n**Not included:** `render`. After you approve, it would start with `npx hyperframes render --quality looks --output out.mp4`, followed by `test -s` and `ffprobe` checks.", "1c13b5da9ade3d11eb0d68f14b588f2c54e1bc9ef8bc48415e7e2b9b14198b9a": "Here's the sequence from discovery to the final preview. It stops at the preview because rendering hasn't been approved.\n\n```bash\n# 0. Open a history turn and see what the person changed since your last turn\nnpx hyperframes history begin --who claude --label \"Add headline reveal\"\nnpx hyperframes history --since mine --who claude\n\n# 1. Discovery: describe the effect you want, in English, not the mechanism\nnpx hyperframes catalog --query \"reveal a headline one line at a time\" --json\n# Read `tier`, `dropped`, `unindexed`, `warnings`, and `results` in the envelope.\n# A weak match on the `words` tier is expected. Offer --on-device (a one-time ~33 MB\n# download) to the user, and run it only after they agree:\n# npx hyperframes catalog --query \"reveal a headline one line at a time\" --on-device -y --json\n\n# 2a. If a result fits, install it\nnpx hyperframes add \n\n# 2b. If nothing fits, report the gap (the envelope's `report_gap` comes pre-filled),\n# then author the reveal by hand following /hyperframes-core\nnpx hyperframes feedback --search-miss \"reveal a headline one line at a time\" \\\n --wanted \"\" --tier \n\n# 3. Confirm where the headline sits on the timeline without reading every file\nnpx hyperframes timeline --json\n\n# 4. Fast feedback after the first HTML pass and after structural changes\nnpx hyperframes lint\n\n# 5. Final gate. It reruns lint itself, so don't run lint separately here.\nnpx hyperframes check --snapshots\n\n# 6. Inspect the reveal frames, plus each mounted scene's midpoint if\n# index.html uses data-composition-src\nnpx hyperframes snapshot --range : --frames 8\n\n# 7. Final Studio preview. Verify the URL returns HTTP 200, give the user the\n# #project/ URL, and keep the preview running during review.\nnpx hyperframes preview --background\n\n# 8. Close the history turn\nnpx hyperframes history end\n```\n\n**Then stop.** Ask the user whether they want revisions or a render. Passing checks does not count as approval.\n\n- **After approval:** start with `npx hyperframes render --quality looks --output out.mp4`, then verify the file with `test -s` and `ffprobe`.\n- **If `check` fails or the user says the result got worse:** use `npx hyperframes history undo --who claude` rather than editing the files back by hand.", "5e47cb7799d28fde1d39192e48c1c9f1c870fe817127384fdfb72b4e43013522": "Here's the sequence, from discovery through the final preview. It stops at the approval gate and does not render.\n\n```bash\n# 0. Start-of-turn bookkeeping\nnpx hyperframes usage --json\nnpx hyperframes history begin --who claude --label \"Add headline reveal\"\nnpx hyperframes history --since mine --who claude # build on any edits the person made\n\n# 1. Discovery: describe the effect, not the mechanism, and phrase it in English\nnpx hyperframes catalog --query \"reveal a headline one line at a time\" --json\n# Read `tier` (words vs on-device), `dropped`, `unindexed`, `warnings`.\n# A weak match on the `words` tier is expected. If nothing fits, offer the\n# ~33 MB on-device tier to the user (don't enable it silently), then:\n# npx hyperframes catalog --query \"reveal a headline one line at a time\" --on-device -y --json\n# If there's still no usable match, report the gap using the pre-filled `report_gap`:\n# npx hyperframes feedback --search-miss \"reveal a headline one line at a time\" \\\n# --wanted \"staggered line-by-line headline reveal\" --tier \n\n# 2. Install the chosen primitive\nnpx hyperframes add \n\n# 3. Author: wire it into the composition (per /hyperframes-core), checking placement\nnpx hyperframes timeline --json\n\n# 4. Fast feedback after the first HTML pass and after structural changes\nnpx hyperframes lint\n\n# 5. Final gate (reruns lint itself, so don't run lint again just before it)\nnpx hyperframes check --snapshots\n\n# 6. Visual spot-check of the reveal at full resolution\nnpx hyperframes snapshot --range : --frames 8\n# If index.html mounts data-composition-src, also take one midpoint per host slot:\n# npx hyperframes snapshot --at ,,\n\n# 7. Final Studio preview\nnpx hyperframes preview --background\n# Confirm the URL returns HTTP 200, then give the user the #project/ URL\n# and ask whether to revise or render. Keep the preview running during review.\n\n# 8. End the turn\nnpx hyperframes history end\n```\n\nNotes:\n- **The approval gate is real.** A passing `check` doesn't approve a render. `render --quality draft`/`looks`/`delivery` comes only after the user says yes.\n- **If `check` fails** or the user says the change made things worse, run `npx hyperframes history undo --who claude`. Don't revert by hand.\n- **Keep runs linked.** Use one `HYPERFRAMES_RUN_ID` across steps 4–7 so they count as one verification loop.\n- **Timing placeholders.** ``, ``/``, and the snapshot times depend on the catalog result and the timeline. Nothing has been searched yet, so they stay as placeholders.", "b38f9303c565461dfbe34805776fdf21bb1eb8f2fae77f263ef1aaf8de36e7c0": "Here's the sequence from discovery to the final preview. It stops before rendering because rendering hasn't been approved.\n\n```bash\n# 0. Optional: check remaining harness allowance at the start of the workflow\nnpx hyperframes usage --json\n\n# 1. Open a history turn and see what the person changed since your last turn\nnpx hyperframes history begin --who claude --label \"Add headline reveal\"\nnpx hyperframes history --since mine --who claude\n\n# 2. Discovery: describe the effect, not the mechanism (query in English)\nnpx hyperframes catalog --query \"reveal a headline one line at a time\" --json\n# Read `tier` (words vs on-device), `dropped`, `unindexed`, `warnings`.\n# If results are weak on `words`, offer the on-device tier (one-time ~33 MB download,\n# nothing sent). Only run this after the person agrees:\n# npx hyperframes catalog --query \"reveal a headline one line at a time\" --on-device -y --json\n\n# 3a. A match fits: install it (see /hyperframes-registry)\nnpx hyperframes add \n\n# 3b. Nothing fits: report the gap (prefilled as `report_gap` in the JSON envelope),\n# then author the reveal by hand per /hyperframes-core\nnpx hyperframes feedback --search-miss \"reveal a headline one line at a time\" \\\n --wanted \"\" --tier \n\n# 4. Fast feedback after wiring the reveal into the composition\nnpx hyperframes lint\n\n# 5. Confirm placement on the timeline without reading every HTML file\nnpx hyperframes timeline --json\n\n# 6. Final gate (reruns lint; don't run a separate lint first)\nnpx hyperframes check --snapshots\n\n# 7. Inspect the reveal at its actual times at full resolution\nnpx hyperframes snapshot --at ,,\n# If the headline lives in a sub-composition:\nnpx hyperframes snapshot --composition --frames 8\n\n# 8. Close the history turn\nnpx hyperframes history end\n\n# 9. Final Studio preview (only after check passes)\nnpx hyperframes preview --background\n# Verify the URL returns HTTP 200, hand over the #project/ URL,\n# and ask whether to revise or render. Keep the preview alive during review.\n```\n\n**Notes**\n- If `check` fails or the person says it got worse, run `npx hyperframes history undo --who claude` instead of hand-editing back.\n- If the reveal involves zoom or camera keyframes, read `/hyperframes-keyframes` before authoring it.\n- Stop here. A passing `check` is not approval. Run `render --quality draft` or `--quality looks` only after the person approves the preview.", "257c080a37212b6a9c11d580a016d9c2d7fab71f1c9e2f588b4a6bcd58098987": "Here's the sequence from discovery through preview, stopping before any render. Placeholders like `` and `` are yours to fill in.\n\n## 0. Session setup\n\n```bash\nexport HYPERFRAMES_RUN_ID=headline-reveal-01 # one ID for the whole verification loop\nnpx hyperframes usage --json # start-of-workflow read\nnpx hyperframes history begin --who claude --label \"Add headline reveal\"\nnpx hyperframes history --since mine --who claude # see what the person changed; build on it\n```\n\n## 1. Discovery: search the catalog before writing motion by hand\n\nDescribe the effect in English, not the mechanism:\n\n```bash\nnpx hyperframes catalog --query \"reveal a headline one line at a time\" --json\n```\n\nRead the envelope rather than assuming:\n- **`tier`** tells you how it was ranked. A weak result on `words` is expected; the same on `on-device` would be a bug.\n- **`warnings`** may carry an offer of the on-device tier. Don't enable it silently. Tell the person it's a one-time ~33 MB download, cached under `~/.hyperframes/`, with nothing sent. If they agree:\n ```bash\n npx hyperframes catalog --query \"reveal a headline one line at a time\" --on-device -y --json\n ```\n- **`dropped` / `unindexed`** above zero aren't fixed by rewording. Re-running with `--on-device` refetches the index when `unindexed > 0`.\n\n**If a result fits**, read `/hyperframes-registry` first, then install it:\n```bash\nnpx hyperframes add \n```\n\n**If nothing fits**, report the gap on whichever tier answered. Use the pre-filled `report_gap` line and add `--wanted`:\n```bash\nnpx hyperframes feedback --search-miss \"reveal a headline one line at a time\" \\\n --wanted \"\" --tier \n```\nThen author the reveal by hand per `/hyperframes-core`.\n\n## 2. Author and place\n\nWire the headline into the composition using `/hyperframes-core`. If it involves keyframe or camera motion, read `/hyperframes-keyframes` first. Confirm placement without reading every HTML file:\n\n```bash\nnpx hyperframes timeline --json\n```\n\n## 3. Fast feedback while editing\n\nRun this after the first HTML pass and after any structural change:\n```bash\nnpx hyperframes lint\n```\n\n## 4. Final gate\n\n`check` reruns lint itself, so don't run a separate lint right before it:\n```bash\nnpx hyperframes check --snapshots\n```\n\n## 5. Sub-composition smoke test (if `index.html` mounts `data-composition-src`)\n\n```bash\nnpx hyperframes snapshot --at ,, # a visible midpoint per host slot\nnpx hyperframes snapshot --range : --frames 8 # around the headline reveal\n```\nInspect the opening 30 s and any reported problem times at full resolution, and zoom into the text edges. Tiny unstyled text or a missing hero element counts as a blocking mount defect.\n\n## 6. Preview for review\n\n```bash\nnpx hyperframes preview --background\n```\n- Verify that the URL returns HTTP 200.\n- Hand the person the timeline project URL (`#project/`).\n- Ask whether to revise or render, and keep the preview running until review ends.\n\n## 7. Close the turn\n\n```bash\nnpx hyperframes usage --json # milestone read before any render decision\nnpx hyperframes history end\n```\n\nIf a check fails, or the person says the result got worse, undo instead of hand-editing back:\n```bash\nnpx hyperframes history undo --who claude\n```\n\n## Stop here\n\nThere's no `render` in this sequence because rendering hasn't been approved, and passing checks isn't approval. Once the person approves, the next step would be `npx hyperframes render --quality looks --output out.mp4`, followed by output verification with `test -s` and `ffprobe`.", "eb724f599f7fe5f2048a2bcb0b42e6d9e5c7c022f11744db9a9570279dd1250c": "# HyperFrames headline reveal: command sequence (discovery → validate → preview, no render)\n\nNo registry search has been run, so the block name below is a placeholder. I also couldn't check the CLI here, so some subcommand names are my best recollection. Step 0 confirms them before you rely on them.\n\n### 0. Confirm the CLI surface\n```bash\nnpx hyperframes --help\nnpx hyperframes add --help\n```\nCheck for the discovery subcommand (`search`, `list`, or similar) and for `lint` or `validate`. Adjust the steps below to match.\n\n### 1. Discovery: search the registry\n```bash\nnpx hyperframes search headline\n# or, if search isn't available:\nnpx hyperframes list\n```\nShortlist candidates such as text-reveal, headline, or kinetic-title blocks. Note the exact registry name of the one you pick.\n\n### 2. Inspect the chosen block (if the CLI supports it)\n```bash\nnpx hyperframes info \n```\nCheck its parameters (text, duration, easing), its dependencies, and which files it will write. This lets you confirm it won't overwrite existing project files.\n\n### 3. Add the block\n```bash\nnpx hyperframes add \n```\nThen review what changed before going further:\n```bash\ngit status\ngit diff\n```\n\n### 4. Wire it into the composition (manual edit, no command)\nPlace the block in the composition HTML. Set the headline text and the timing (start and duration on the timeline), and make sure it doesn't collide with existing tracks.\n\n### 5. Validate\n```bash\nnpx hyperframes lint\n```\nFix any reported issues, such as missing timing attributes, unknown elements, or asset paths. Re-run until it passes cleanly.\n\n### 6. Preview\n```bash\nnpx hyperframes preview\n```\nScrub through the reveal in the browser preview. Check the entrance timing, the easing, the text fit and wrapping at the target resolution, and the final hold frame.\n\n### Stop here\nDo **not** run `npx hyperframes render`. Rendering hasn't been approved, so it waits for an explicit go-ahead after you've reviewed the preview.", "9d6ac6c2c89d9014b38adb4c1198a8ed05ea36390c4eda53e047a695ce1d4390": "# Draft: HyperFrames Headline Reveal, from Discovery to Preview\n\nI haven't run anything, and no registry search has been done, so I don't know the real block name. The subcommand names below are my best understanding of the HyperFrames CLI. They aren't confirmed against your installed version. Anything in `` is a placeholder to fill from real output.\n\n## 0. Confirm the CLI surface first\n```bash\nnpx hyperframes --version\nnpx hyperframes --help\n```\nCheck that `add`, `lint`, and `preview` exist with these names. Also check how registry discovery is exposed (for example `catalog`, `search`, or `add --list`). Adjust the steps below to match.\n\n## 1. Discovery (registry search)\n```bash\nnpx hyperframes catalog # or the equivalent listing/search command from --help\n```\nLook for a headline or text-reveal block, such as a title reveal, kinetic headline, or text mask reveal. Write down:\n- the exact block ID → ``\n- any required props or slots, such as headline text, duration, or easing\n- any fonts or assets it depends on\n\nIf the catalog has no suitable block, stop here. The fallback is hand-authoring a GSAP-timed composition clip, which is a separate plan.\n\n## 2. Inspect before adding (optional but recommended)\n```bash\nnpx hyperframes add --dry-run # only if supported; otherwise skip\ngit status # baseline is clean per snapshot\n```\n\n## 3. Add the block\n```bash\nnpx hyperframes add \ngit status\ngit diff\n```\nReview which files were created or modified. Typically that means a block or component file plus its wiring into the composition HTML.\n\n## 4. Wire and configure\nThis is a manual edit, not a command. Place the headline clip in the target composition and set:\n- the headline text\n- the start time and duration (`data-start` / `data-duration` or equivalent)\n- the track or layer\n\n## 5. Validate\n```bash\nnpx hyperframes lint\n```\nFix any reported issues and re-run until it's clean. Things to check include timing overlaps, missing assets, and a timeline that isn't registered.\n\n## 6. Preview (no render)\n```bash\nnpx hyperframes preview\n```\nOpen the local preview URL it prints. Then check:\n- reveal timing and easing\n- text wrapping at the target resolution\n- font loading, so there's no fallback-font flash\n- the final hold frame\n\n## 7. Stop point\nDon't run `npx hyperframes render` until rendering is explicitly approved.\n\n## Open items to resolve before executing\n1. The real discovery command name and the chosen ``, from steps 0–1.\n2. Which composition file the headline belongs in.\n3. The headline copy, start time, and duration.", "2becab901efdc5e79eb4fe08b9661341c995b499177f314921c083cc80d1d6b9": "# Draft command sequence: headline reveal (no render)\n\nI don't have verified CLI output here, and no registry search has been run. Treat the subcommand names below as **assumptions to confirm with `--help`** before running anything. Placeholders are in ``.\n\n### 1. Confirm the CLI surface\n```bash\nnpx hyperframes --version\nnpx hyperframes --help # confirm the add/search, lint, and preview subcommand names\n```\n\n### 2. Check the environment\n```bash\nnpx hyperframes doctor # if available: checks Node, Chrome, and FFmpeg\n```\n\n### 3. Search the registry\n```bash\nnpx hyperframes catalog # or the search equivalent shown in --help\n# Filter for: headline, title, text reveal, kinetic type\n```\nPick one block and note its exact ID. **Stop here** if nothing suitable exists; don't guess an ID.\n\n### 4. Inspect before installing\n```bash\nnpx hyperframes add --help # check flags such as target path or dry run\ngit status # make sure the tree is clean so the add is easy to review or revert\n```\n\n### 5. Add the block\n```bash\nnpx hyperframes add \ngit diff --stat # review exactly which files were added or changed\n```\n\n### 6. Wire it into the composition\nThis is a manual edit, not a command. Reference the block in `.html`. Set the headline text, the start time, and the duration, and make sure the timing data attributes don't overlap other clips.\n\n### 7. Validate\n```bash\nnpx hyperframes lint # fix every error and re-run until clean\n```\n\n### 8. Preview\n```bash\nnpx hyperframes preview # local studio or browser preview; scrub the reveal and check timing and fonts\n```\n\n### 9. Stop: render is gated\n```bash\n# NOT RUN — needs explicit approval:\n# npx hyperframes render --output .mp4\n```\n\n### Open items before execution\n- Confirm the real subcommand names for search and add from `--help`.\n- Choose the block ID from actual registry results.\n- Get approval to render once the preview looks right.", "7eb929615054fd8c1e7e7fd7d934b80605e9c3a926071ecc57834108709a7c93": "# HyperFrames headline reveal: command sequence (draft, not executed)\n\nNothing below has been run. No registry search has been done, so the block name is a placeholder (``). I've marked subcommands I'm unsure of with **(verify)**. Check those against `--help` before relying on them.\n\n### 0. Confirm the CLI and project state\n```bash\nnpx hyperframes --version\nnpx hyperframes --help # confirms the real subcommand names\ngit status # start from a clean tree so the added files are easy to review\n```\n\n### 1. Discovery (registry search)\n```bash\nnpx hyperframes catalog # (verify) list available blocks/components\nnpx hyperframes catalog --search headline # (verify) or \"title\", \"text reveal\", \"kinetic type\"\n```\nPick a candidate based on the reveal style (mask wipe, per-word stagger, per-character fade), its duration, and its dependencies.\n\n### 2. Inspect before adding\n```bash\nnpx hyperframes info # (verify) props, duration, required assets/fonts\n```\n\n### 3. Add the block\n```bash\nnpx hyperframes add \ngit diff --stat # review exactly what was added or modified\n```\n\n### 4. Wire it into the composition (manual edit, no command)\n- Place the block in the main composition HTML.\n- Set the headline text, font, and colors.\n- Set the timing attributes (start and duration) so the reveal doesn't collide with other tracks.\n- Make sure any fonts or assets it references exist locally.\n\n### 5. Validate\n```bash\nnpx hyperframes lint # structural/timing checks on the composition\n```\nFix anything it reports, then re-run until it's clean.\n\n### 6. Preview\n```bash\nnpx hyperframes preview # local dev preview in the browser\n```\nThings to check by eye:\n- Reveal timing and easing\n- Text clipping or overflow at the target resolution\n- Font loading (no fallback-font flash)\n- Behaviour at the first and last frames\n\n### 7. Stop here: render is not approved\nFor when approval is given, **not to be run now**:\n```bash\nnpx hyperframes render # pending explicit approval\n```\n\n### Open items before anyone executes this\n1. Run the actual registry search and replace `` with a real name.\n2. Confirm the discovery and info subcommand names, since they're the least certain part of this sequence.\n3. Get explicit sign-off before step 7.", "7ee563e76ba5ed6e9d1dbc30affb8155b30bc83a24b945b6835eae047bed250b": "# Finding the file that owns the visible clip at main time 14\n\nUse `npx hyperframes timeline --json` and filter on absolute time. Don't add up offsets by reading `index.html` and each sub-composition by hand.\n\n## Why the timeline command fits\n\nThe local start of 2 s is measured inside the sub-composition, not on the main timeline. In the `--json` output, every nested row also carries:\n\n- **`absStart` / `absEnd`:** absolute main-timeline times, with the mount offset already applied.\n- **`file`:** the file that owns the row. For a nested clip, that is the sub-composition file, not `index.html`.\n\nIf the scene's own timeline begins at its mount point, the clip should show up near `absStart: 14` (12 mount + 2 local). Confirm that from the output rather than relying on the arithmetic.\n\n## Steps\n\n1. **List what is active at 14 s:**\n ```bash\n npx hyperframes timeline --json \\\n | jq '.. | objects | select(has(\"absStart\") and .absStart <= 14 and .absEnd > 14) | {file, absStart, absEnd}'\n ```\n Adjust the path to match the JSON shape you see. The rule to apply is `absStart <= 14 < absEnd`. Because the start is inclusive and the end is exclusive, a clip starting exactly at 14 counts, and one ending exactly at 14 does not.\n\n2. **Read the result:** you will usually see two kinds of rows.\n - The **host row** is the scene mount itself, spanning from 12 s and owned by `index.html`.\n - The **nested clip row** has `absStart` around 14 and is owned by the sub-composition file.\n\n The deepest nested row is the clip you're after, and its `file` is the owner. If several leaf clips overlap at 14, track or stacking order decides which one is on top.\n\n3. **Check it visually:** the timeline tells you what is scheduled, not what is actually painted, so capture the frame too:\n ```bash\n npx hyperframes snapshot --at 14\n ```\n If the frame is blank, unstyled, or missing the expected element, treat it as a mount defect in that sub-composition. `hyperframes-core/references/sub-compositions.md` covers the fixes.\n\n4. **If you mean an element you clicked in Studio** rather than a time, ask Studio directly:\n ```bash\n npx hyperframes preview --context --json --context-fields selection\n ```\n It returns the selection's `hfId` or selector along with its source file.", "69f7e2d166d4f97fef2e8cfca59f77aa66f9f183f38dcf5da93f7aea60e457fd": "Use `npx hyperframes timeline --json`, not the HTML files. Don't add the local and mount times yourself.\n\n## Why the timeline command\n\nThe nested scene's local time (2 s) is measured from the start of its own sub-composition. The mount (12 s) is on the main timeline. If you read `index.html` and the sub-composition file by hand, you have to combine those offsets yourself, and that is easy to get wrong. `timeline --json` does it for you. Each nested row carries:\n\n- **`absStart` / `absEnd`**: absolute main-timeline times, already offset by the mount.\n- **`file`**: the sub-composition file that owns the clip.\n\n## Steps\n\n1. **Dump the resolved timeline:**\n ```bash\n npx hyperframes timeline --json\n ```\n\n2. **Find rows that span main time 14.** Look for rows where `absStart <= 14` and `absEnd > 14`. Read `file` on those rows. Ignore the local start/end fields; they describe time inside the sub-composition. As a `jq` filter, it looks roughly like this (adjust the path to wherever the rows sit in the envelope):\n ```bash\n npx hyperframes timeline --json \\\n | jq '.. | objects | select(.absStart? != null and .absStart <= 14 and .absEnd > 14) | {file, absStart, absEnd}'\n ```\n\n3. **Mind the boundary.** If the 2 s local start belongs to a clip inside a scene mounted at 12 s, that clip's `absStart` should read 14. A clip starting exactly at 14 is right on the edge. Check whether the previous clip's `absEnd` is also 14, and whether anything else overlaps. If several rows match (stacked tracks, an overlay over a background), the one on top is what you actually see. Use the track ordering in the output to decide.\n\n4. **Confirm with pixels.** The timeline tells you what is scheduled, not what renders. Capture that exact time:\n ```bash\n npx hyperframes snapshot --at 14\n ```\n Check that the visible content matches the clip from the `file` you identified. If the frame is blank or unstyled, or the hero element is missing, that points to a mount defect. See `hyperframes-core/references/sub-compositions.md`.\n\n## Summary\n\n`timeline --json` → find the row with `absStart ≤ 14 < absEnd` → read its `file` → confirm with `snapshot --at 14`.", "8aac7733014537156ffe42278d8bfbb9e89a63b80a14820262d2a1a86082d208": "# Finding the file that owns the clip at main time 14\n\nUse `timeline --json`. It flattens the whole project, including nested sub-compositions, into rows on the main timeline. You don't have to read `index.html` or each `data-composition-src` file and add the offsets yourself.\n\n## 1. Dump the timeline\n\n```bash\nnpx hyperframes timeline --json\n```\n\nEach nested row includes:\n\n- **`absStart` / `absEnd`**: the clip's absolute time on the main timeline, with the mount offset already applied.\n- **`file`**: the sub-composition file that owns the row.\n- The local, per-sub-composition timing.\n\n## 2. Match on absolute time, not local time\n\nYour case shows why this matters. A local start of 2 s inside a scene mounted at main time 12 s puts that clip at about **14 s absolute**. If you filtered on local time, you would look for 2 s and miss it, or pick the wrong clip. Let the CLI resolve the offset and filter on `absStart`/`absEnd`:\n\n```bash\nnpx hyperframes timeline --json \\\n | jq '.. | objects | select(has(\"absStart\") and .absStart <= 14 and .absEnd > 14) | {file, absStart, absEnd}'\n```\n\nI haven't verified the exact JSON envelope shape. If `..` returns too much, change the selector to match the real top-level key. The fields to filter on are `absStart`, `absEnd` and `file`.\n\n## 3. Read the result\n\n- **One row** means its `file` owns the visible clip at 14 s.\n- **Several rows** mean overlapping clips, for example the scene's own row plus clips inside it. The most deeply nested row is usually the visible content. If they overlap at the same level, track or stacking order decides what's on top.\n- **A row starting exactly at 14** is a boundary case. Check whether it is already visible at that frame, which step 4 shows directly.\n\n## 4. Confirm it visually\n\nThe timeline tells you what is scheduled. A snapshot shows what actually renders:\n\n```bash\nnpx hyperframes snapshot --at 14\n```\n\nUse this one if you want several samples inside that scene, with the `data-composition-id` from the owning file:\n\n```bash\nnpx hyperframes snapshot --composition --frames 8\n```\n\nIf the frame at 14 s is blank, unstyled, or missing the expected element while the timeline says a clip should be there, treat it as a mount defect in that file.", "97b1357cdc62203c2200b607db8e2833c3e35d2a088087f802eea572cb672c48": "## The time mapping\n\nAssuming the nested scene plays at 1× speed with no trim or retime applied at the mount point:\n\n```\nlocal_time = local_start + (main_time − mount_time)\n = 2 + (14 − 12)\n = 4 s\n```\n\nSo main time **14 s** corresponds to **local time 4 s** inside the nested scene. Search for the visible clip at 4 s in the nested scene's own timeline, not at 14 s or 2 s.\n\nThe two common mistakes are:\n- Querying the nested scene at **14 s**, which ignores the mount offset.\n- Querying at **2 s**, which ignores the scene's local start.\n\n## Inspecting it with the CLI\n\nYou haven't said which tool this is, and I can't look up its commands, so I won't guess exact flags. The workflow usually looks like this:\n\n1. **Query the main timeline at 14 s.** Ask the CLI which item is active and topmost at that time. You should see the nested-scene instance mounted at 12 s rather than a leaf clip. Note its mount time, local start, and any speed or retime value it reports.\n2. **Confirm the offset.** Check that the reported mount time is 12 and the local start is 2. If the tool shows a playback rate other than 1, use `local = 2 + (14 − 12) × rate` instead.\n3. **Descend into the nested scene at local time 4 s.** List the clips active at 4 s and find the topmost visible one, ignoring clips that are hidden, muted, or fully transparent.\n4. **Read that clip's source.** The clip's media or source path is the file that owns what you see. If that clip is itself another nested scene, repeat steps 2–3 with its offsets.\n5. **Cross-check if possible.** Many tools have a \"resolve\" or \"trace\" mode that takes a main-timeline time and reports the whole chain down to the leaf file. If yours does, run it at 14 s and confirm it lands at local 4 s and the same file.\n\nIf you tell me the CLI's name or paste its `--help` output, I can give you the exact commands.", "a99459da93b9abfb071746258c607acd1256c40b1a85d794dbd8dfaf74a266f4": "# Finding the clip owner at main time 14s\n\n## 1. Convert main time to nested local time\n\nI'm assuming \"local start 2s\" means the nested scene begins playing from its own 2s mark when it is mounted.\n\n```\nlocal_time = (main_time − mount_time) + local_start\n = (14 − 12) + 2\n = 4 seconds\n```\n\nSo main time 14s corresponds to **4s inside the nested scene**. A common mistake is to look at local 2s, which ignores the start offset, or at local 14s, which ignores the mount.\n\n## 2. How to inspect it with the CLI\n\nYou didn't say which tool this is, and I can't check its help output. So I won't guess at command names or flags. The steps are the same for most timeline or scene CLIs:\n\n1. **Inspect the main timeline at 14s.** Confirm that the visible element there is the nested scene's mount, not a clip in the main scene layered above it. If a main-scene clip covers it, that clip's file is your answer.\n2. **Read the mount's details.** Check the mount time (12s), local start (2s), and any speed or time-remap setting. A speed other than 1× changes the formula: `local = (14 − 12) × speed + 2`.\n3. **Inspect the nested scene at local 4s.** List the clips active at that time, ordered by layer or z-order.\n4. **Choose the topmost visible clip.** Skip clips that are hidden, muted, fully transparent, or masked out.\n5. **Read that clip's source path.** This is the owning file. If the clip is itself another nested scene, repeat steps 1–4 one level deeper.\n\n## 3. Things to check\n\n- **Off-by-one conventions:** see whether clip ranges include or exclude their end time. A clip ending exactly at 4s may not count as visible.\n- **Frames vs. seconds:** if the CLI uses frames, convert 4s using the nested scene's frame rate, not the main scene's.\n- **Overrides:** some tools let the parent scene replace nested assets, so the file shown in the nested scene's definition may not be what renders.\n\nIf you share the CLI's name or paste its `--help` output, I can turn these steps into exact commands.", "f76143b6d6f07bb6eb0d5dba124df8c0c02ea66523ee8f47bd7d38c32b7b7af2": "# Mapping main time 14 into the nested scene\n\nAssuming the nested scene plays at normal speed (no time stretch or retime):\n\n```\nlocal_time = local_start + (main_time - mount_time)\n = 2 + (14 - 12)\n = 4 seconds\n```\n\nSo at main time 14 you need the clip that is visible at **local time 4** inside the nested scene, not at local time 14 or 2.\n\n# Inspecting it with the CLI\n\nYou haven't said which CLI this is, so I can't give you its exact command names. Below is the sequence to follow; the commands are **placeholders** for whatever your tool calls these operations.\n\n1. **Confirm the mount parameters in the main timeline.** Check the nested scene's mount offset (12s), its local start or in-point (2s), and any speed or retime factor. If there is a speed factor `s`, the formula becomes `2 + (14 - 12) * s`.\n ```\n inspect main --at 14 # which item is on top at 14s?\n ```\n This should show that the nested scene is the visible item at 14s. If something on a higher track covers it, that item owns the frame instead and you can stop here.\n\n2. **Descend into the nested scene at the mapped time.**\n ```\n inspect --at 4\n ```\n Use local time 4, not 14. If the tool can resolve nesting for you (some have a flag like `--resolve`, `--recursive`, or `--trace`), run ` inspect main --at 14 --resolve` and it will do the mapping itself. Its output should agree with the value 4.\n\n3. **Find the topmost visible clip at that time.** Among the clips active at local 4s, take the one on the highest enabled track that isn't muted, hidden, or fully transparent. Its source or media path is the file that owns the visible clip.\n\n4. **Repeat if there is further nesting.** If that clip is itself a nested scene, apply the same formula again using its own mount offset and local start.\n\nIf you tell me which CLI you're using, or paste its `--help` output, I can replace the placeholders with the real commands and flags.", "7bf24247c9a8e94b4a53cade9eace8c82a7af36aaaf878536b4d0a4e50e57648": "# Finding the clip owner at main time 14\n\n## 1. Convert main time to nested-scene time\n\nAssuming \"local start 2s\" means the nested scene starts playing from its own t=2 when mounted:\n\n```\nnested_local_time = local_start + (main_time − mount_time)\n = 2 + (14 − 12)\n = 4 s\n```\n\nSo you're looking for whatever is visible at **t = 4 s inside the nested scene**, not t = 14 or t = 2. Two easy mistakes to avoid:\n\n- **Using 14 directly in the nested scene.** That ignores the mount offset.\n- **Using 2 (14 − 12) and forgetting the local start.** That ignores the trim or start offset.\n\nIf your tool defines \"local start\" differently, the formula changes. For example, it might mean the scene's position in some other parent rather than an in-point. Check that before trusting the 4 s result.\n\n## 2. Inspecting it with the CLI\n\nYou haven't said which CLI this is, and I can't look it up here, so I can't give you exact command names. The general workflow most timeline or scene tools support is:\n\n1. **Query the main timeline at t=14.** Look for a command like `inspect`, `probe`, `at`, or `resolve` that takes a time. Confirm it reports the nested scene mount as the active item, with mount time 12 and local start 2.\n2. **Descend into the nested scene.** Either pass the nested scene file and query t=4, or use a \"resolve through nesting\" or \"--recursive\" style flag on the main query. That flag is preferable because it applies the offsets for you.\n3. **Identify the topmost visible clip.** If several clips overlap at local t=4, the visible one is usually determined by track or layer order (highest track or last-drawn wins). Also exclude clips that are hidden, muted, or fully transparent.\n4. **Read the source/file field** on that clip. That's the owning file. If that clip is itself another nested scene, repeat the conversion one level deeper.\n5. **Cross-check.** If the CLI can print the full resolution chain (main → nested → clip, with times at each level), verify it shows main 14 → nested 4.\n\nIf you tell me the CLI's name, or paste its `--help` output, I can map these steps to the actual commands and flags.", "6d47e900cb9159cf3bc30b2d0b61a86f3c35d9c0ae5dd9f721dc4c36ca163c2e": "The render finished on the **slow path**: screenshot capture with a software GPU on Linux. That makes it slower, but it does not mean the render failed. Software rendering can also hide GPU-specific pixel problems, so a finished encode tells you nothing yet about what is in the frames.\n\n## Next verification steps\n\n1. **Confirm the file is real.** Check that it is non-empty (`test -s out.mp4`). You already know it exists, but a zero-byte file also exists.\n\n2. **Check the container against the composition.** Run `ffprobe -v error -show_format -show_streams out.mp4` and check:\n - The duration matches the root `data-duration`.\n - The fps matches, if the brief set one.\n - A video stream is present, plus an audio stream if the composition has audio.\n - The resolution is what you expect.\n\n3. **Decode frames and look at them.** Extract frames at the same timestamps you reviewed in the Studio preview, and inspect them at full resolution:\n - **The opening 30 seconds.**\n - **Any times that `check` or the preview flagged as problems.**\n - **The midpoint of each mounted sub-composition**, if `index.html` uses `data-composition-src`. Look for mount defects: tiny unstyled content, canvas-sized icons, or a missing hero element.\n\n4. **Zoom into fine detail.** Crop close-ups of small text, thin geometry, and the edges of canvas or WebGL content. A contact sheet alone isn't enough; passing `check` and a clean encode do not vouch for what is drawn inside a canvas.\n\n5. **Compare against the preview.** Look for black or blank frames, flicker, wrong or frozen frames, and missing elements. Anything that differs from the approved preview is a render defect.\n\n6. **Look at shaders with the software GPU in mind.** If the project uses WebGL or shaders, software rendering may not show invalid pixels that a hardware GPU would produce, such as an unclamped `pow(1 - cosine, …)`. If the output has to be right on real GPUs, verify it on a hardware-GPU preview or render, following `/hyperframes-animation` → `adapters/three.md`.\n\n7. **Optionally, find out why it fell back.** For future renders, run `npx hyperframes doctor --json` and check its `ok` payload (the command always exits zero). It shows whether a GPU or browser setup issue forced screenshot mode instead of `beginframe`.\n\n8. **Send feedback after verifying.** Unless telemetry is off or the user opted out, send one `npx hyperframes feedback --rating … --comment …` report. Mention the screenshot/software-GPU path if it caused friction.\n - If you find a visual defect and rate it 7 or lower, include a full reproduction packet and the `COMPOSITION_STRUCTURE:` block.\n - Use relative paths only in the report.\n\nOnly after steps 1–5 pass can you say the output has been verified.", "af3de5e900d3727d088e5739b35c166159b4f129e446f4b40aa49e6ee22d1891": "The render summary shows **screenshot mode with a software GPU on Linux**. That combination is the slow capture path. It does not mean the render failed. However, a finished encode does not prove the pixels are correct, so check the output before calling it done.\n\n## Next verification steps\n\n1. **Confirm the file is real and non-empty.**\n ```bash\n test -s out.mp4\n ```\n\n2. **Check the container and streams against the composition.**\n ```bash\n ffprobe -v error -show_format -show_streams out.mp4\n ```\n - The format duration should match the root `data-duration` in `index.html`.\n - If the brief specified an fps, compare the video stream's `r_frame_rate` / `avg_frame_rate` to it.\n - Confirm the resolution is what you intended, and that an audio stream is present if the composition has audio.\n\n3. **Decode frames and look at them.** Use the same timestamps you reviewed in the Studio preview, so you are comparing like with like.\n ```bash\n mkdir -p /tmp/qc-frames\n ffmpeg -v error -ss -i out.mp4 -frames:v 1 /tmp/qc-frames/frame_.png\n ```\n - Cover the **opening 30 seconds** at full resolution.\n - Cover any **times where `check` reported problems**.\n - Cover the **midpoint of each sub-composition slot** if `index.html` mounts `data-composition-src`. Treat tiny unstyled content, oversized icons, or a missing hero element as a mount defect.\n - **Zoom into close-ups** of fine text, thin geometry, and canvas/WebGL edges. Don't judge from a contact sheet alone.\n - Look for black, blank, frozen, or flickering frames, and frames that don't match the timeline.\n\n4. **Treat shader/WebGL content as unverified until checked on real hardware.** Software rendering can hide GPU-specific invalid pixels, such as the `pow(1 - cosine, …)` NaN case. If the composition uses shaders, also verify preview and export on the affected GPU hardware.\n\n5. **Optionally, investigate the slow path for future renders.** Run `npx hyperframes doctor --json` and check the browser/GPU section to see why `beginframe` and a hardware GPU weren't used. This affects speed, not correctness, so it doesn't block delivery.\n\n6. **Clean up and report.**\n - Remove only the QC directory you created: `rm -r /tmp/qc-frames`.\n - Once the frames check out, send one feedback report, unless telemetry is off or you've opted out:\n ```bash\n npx hyperframes feedback --rating <0-10> --comment \"\"\n ```\n - If you find a visual defect and rate it ≤ 7, include the full reproduction packet and the `COMPOSITION_STRUCTURE:` block. Use relative paths only.\n\nUntil steps 2–4 pass, describe the render as \"encoded, not yet visually verified.\"", "d1128de015043fcb0bacd33e6e49500fa78c16a0880776d1f1a59b6ddc5bae5f": "# Next verification steps\n\nThe render finished, but nothing about the pixels is verified yet. A completed encode does not certify what is inside a canvas, and **`screenshot` mode with `software gpu` on Linux is the slow capture path**. Expect it to be slow. It is not a failure by itself, but it is a reason to look closely at GPU-dependent content.\n\n### 1. Confirm the file is real\n```bash\ntest -s out.mp4 && echo ok\n```\n\n### 2. Check the container against the composition\n```bash\nffprobe -v error -show_format -show_streams out.mp4\n```\n- Compare the **duration** to the root `data-duration` in `index.html`.\n- If the brief set an **fps**, compare it too (`r_frame_rate` / `avg_frame_rate`).\n- Confirm there is a video stream and, if the composition has audio, an audio stream.\n\n### 3. Decode frames at the same times you reviewed in preview\nWrite them to a temp directory you own, for example:\n```bash\nmkdir -p /tmp/qc-frames\nffmpeg -v error -ss -i out.mp4 -frames:v 1 /tmp/qc-frames/t.png\n```\nRepeat for each time you checked in Studio. Then inspect:\n- **The opening 30 seconds at full resolution**, not just a contact sheet.\n- **Any times `check` reported problems.**\n- **A midpoint of each sub-composition slot** (each `data-composition-src` scene). Look for tiny unstyled content, canvas-sized icons, or missing hero elements. Treat any of these as a mount defect.\n- **Close-ups of fine detail**: text edges, thin geometry, and WebGL/canvas/shader edges. With software GPU, shader output can differ from the hardware-GPU preview. Look for black frames, NaN speckles, banding, or blank canvases. If the project uses `pow(1 - cosine, …)`, confirm the cosine is clamped to `[0, 1]`.\n\n### 4. Compare against the approved preview\nThe frames should match what the user approved in Studio at the same timestamps. Any divergence is a render defect, not a preview defect.\n\n### 5. Close out\n- If everything matches, report the result plainly. Then send one feedback report (unless telemetry is off or the user opted out):\n ```bash\n npx hyperframes feedback --rating <0-10> --comment \"\"\n ```\n- If you find a visual defect, capture a reproduction packet before submitting. It needs:\n - a relative command\n - expected vs. actual behavior\n - the exact error with absolute paths stripped\n - the `COMPOSITION_STRUCTURE:` block for ratings ≤ 7\n- Remove only `/tmp/qc-frames` when done.\n- If the render's Framey line ends in `hyperframes open …`, offer to open the project in the desktop app.\n\n### Optional: if speed matters for later renders\nThe slow path usually means no hardware GPU or no `beginframe` support in the environment. Running `npx hyperframes doctor --json` and reading `references/doctor-browser.md` is the place to start. A `--docker` render is another option for reproducibility. Neither is needed to verify this output.", "64b0ba1ac294621106065d7fc6ab644dd6604a97443563af15cb1107f783881a": "The render finished, but nothing about the pixels has been verified yet. `screenshot` capture with `software gpu` on Linux is the slow fallback path. It explains a long render time but does not by itself mean the output is wrong. Verify in this order.\n\n## 1. Confirm the container is sane\n\n```bash\ntest -s out.mp4\nffprobe -v error -show_format -show_streams out.mp4\n```\n\n- The file should be non-empty and contain a video stream (and an audio stream if the composition has audio).\n- **Duration** should match the root `data-duration`.\n- **fps** should match the brief, if the brief set one.\n- **Resolution** should match the composition's width and height.\n\nA duration or fps mismatch is a defect regardless of how the frames look.\n\n## 2. Inspect decoded frames\n\nA successful encode does not certify what is inside a canvas, so decode actual frames from `out.mp4`:\n\n- Use the **same timestamps you reviewed in the Studio preview**, so you can compare them directly.\n- Cover the **opening 30 seconds** at full resolution.\n- Check any **times previously reported as problems** by `check` or by the user.\n- Check **one midpoint per sub-composition slot**, if `index.html` mounts `data-composition-src`.\n\nWrite these frames to a disposable temp directory, and remove only that directory afterwards.\n\n## 3. Look closely, not just at a contact sheet\n\nZoom into:\n\n- Fine geometry, text edges and small type\n- WebGL or canvas content, shader edges and gradients\n\nLook for:\n\n- Black, blank or frozen frames\n- Flicker between adjacent frames\n- Missing hero elements, or tiny unstyled content (a sign of a failed mount)\n- Wrong-frame timing, where an animation is offset from the preview\n\n## 4. Account for the software-GPU path\n\n- If the composition uses WebGL or shaders, software rendering can differ from hardware output and can hide hardware-specific invalid pixels. Compare the decoded frames against the preview on the GPU the audience will use.\n- If lint flagged `shader_unbounded_cosine_pow`, fix it as the hyperframes-animation skill's `adapters/three.md` describes, and re-verify on the affected GPU.\n- To learn why the render fell back to `screenshot` mode instead of `beginframe`, run `npx hyperframes doctor --json` and read its payload. It always exits 0, so don't gate on the exit code. This matters for render speed on later renders, not for whether this output is correct.\n\n## 5. Decide\n\n- **All checks pass:** report the render as verified, then send one feedback report with `npx hyperframes feedback --rating <0-10> --comment \"\"`. Mention the screenshot/software-GPU slow path if it caused friction.\n- **Any visual defect found:** don't call the output done. Capture a reproduction packet: the relative command, expected vs actual behaviour, the timestamps involved, and whether the output completed or fell back. Include a `COMPOSITION_STRUCTURE:` block in the feedback if the rating is 7 or lower. Then fix the composition and re-render.", "d1a0186d0a36132a58bf91be0a3690977a91193890928fa8f09ad298586720b7": "## Current status\n\nThe render completed and produced output, but that only shows the pipeline didn't crash. Nothing yet confirms the frames are correct. Software GPU rendering on Linux (llvmpipe, SwiftShader, or similar) commonly produces output files that are black, blank, partial, or missing effects. So treat the result as **unverified**.\n\n## Next verification steps\n\n1. **Check the output file.**\n - Confirm the file size is plausible and not near zero.\n - Confirm the format and container are what you expected.\n - For video, check the codec, resolution, frame rate, duration, and frame count against the render settings (e.g. with `ffprobe`).\n - For an image sequence, confirm the expected number of frames exists with no gaps in numbering.\n\n2. **Look at actual frames.**\n - Extract and view a sample: the first frame, the last frame, and a few in between.\n - Look for all-black or all-transparent frames, which are typical when a software GL context fails silently.\n - Look for missing textures, shaders, or effects, wrong colors or gamma, and the wrong viewport size or cropping.\n - In screenshot mode, check that each capture shows the fully loaded state, not a loading screen or a half-drawn page.\n\n3. **Detect blank or frozen frames automatically.**\n - Compute per-frame statistics such as mean and variance of pixel values. Near-zero variance means a blank frame.\n - Compare hashes of consecutive frames. Identical hashes across frames that should change mean frozen output.\n\n4. **Compare against a reference.**\n - If you have a known-good render, ideally from a hardware GPU or a previous baseline, diff it against the new one.\n - Use a tolerance-based image comparison (SSIM, PSNR, or a pixel-diff threshold), because software and hardware rasterizers differ slightly in anti-aliasing and precision.\n\n5. **Review the render logs.**\n - Check which GL/Vulkan renderer string was actually used.\n - Look for warnings about unsupported extensions, shader compile failures, or fallbacks such as WebGL being disabled or features being blocklisted.\n - Check for timeouts in screenshot capture.\n\n6. **Check timing and completeness.**\n - Confirm the render duration is plausible. A very fast render on a software GPU can mean frames were skipped.\n - Confirm any requested animation or time range was fully covered.\n\n## What to report\n\nReport the outcome in two parts:\n- What is confirmed: the output exists, and its metadata matches (or doesn't).\n- What was inspected: which frames, and what you found.\n\nUntil frames have been viewed or checked automatically, describe the render as \"completed, output unverified\" rather than \"successful.\"", "715977e04c314241a9be59ae56cf12b3c6c0b542c74e55e8f5b92752b5618eab": "# Next verification steps\n\nThe render completed, but nothing confirms the frames are correct yet. Screenshot mode with a software GPU (likely SwiftShader or llvmpipe) is where blank frames, missing effects and timing drift usually show up.\n\n## 1. Check the container and stream metadata\nConfirm the file matches what was requested:\n```\nffprobe -v error -show_entries stream=codec_name,width,height,r_frame_rate,nb_frames,duration -of default=nw=1 out.mp4\n```\n- Resolution, fps and duration should match the composition.\n- Frame count should equal duration × fps. Count exactly with `-count_frames` if `nb_frames` is missing.\n- If there's audio, check that its stream exists and its duration matches the video's.\n\n## 2. Look at actual frames\nExtract a sample and view them yourself:\n- Pull the first, last and middle frames, plus any scene transitions:\n ```\n ffmpeg -i out.mp4 -vf \"select='eq(n,0)+eq(n,N/2)+eq(n,N-1)'\" -vsync 0 f_%03d.png\n ```\n Replace N with the real frame count.\n- Or make a contact sheet: `-vf \"fps=1,scale=320:-1,tile=6x5\"`.\n\n## 3. Detect degenerate output automatically\n- Blank frames: `ffmpeg -i out.mp4 -vf blackdetect=d=0.05:pix_th=0.1 -f null -`. Also check for all-white frames, for example with `signalstats` YAVG near 255.\n- Stalled or duplicated frames, a common screenshot-mode failure: `-vf freezedetect=n=0.001:d=0.2`. Compare any frozen spans against intentionally static sections.\n\n## 4. Check what software GPUs often get wrong\nScrutinize frames containing:\n- WebGL, canvas or shaders: may be blank, use a fallback, or have precision artifacts.\n- CSS filters, blur, `backdrop-filter`, 3D transforms and blend modes.\n- Embedded video: confirm it shows the correct frame for each timestamp, not stuck or black.\n- Fonts: check for fallback substitution, since Linux containers often lack the intended fonts.\n- Images and remote assets: confirm they loaded rather than showing placeholders.\n\n## 5. Compare against a reference\nIf you have a known-good render (hardware GPU, another machine, or an earlier approved build), compare them:\n```\nffmpeg -i out.mp4 -i ref.mp4 -lavfi \"ssim;[0][1]psnr\" -f null -\n```\nLook for frame ranges where SSIM drops, and inspect those frames.\n\n## 6. Review the render logs\nSearch for:\n- GL or WebGL warnings, such as \"context lost\" or \"WebGL not supported\".\n- Asset load failures, timeouts, retries and console errors from the page.\n- Delay-render or timeout warnings. These mean a frame may have been captured before it finished.\n\n## 7. Check timing and sync\n- Spot-check that animation positions match the expected timestamps.\n- If there's audio, check lip-sync or beat alignment at the start, middle and end.\n\n## Acceptance\nTreat the render as verified only when:\n- Metadata matches.\n- There are no unexplained blank or frozen spans.\n- Sampled frames look correct, especially GPU-heavy and font-heavy scenes.\n- Logs are clean, or their warnings are understood.\n\nUntil then, report it as \"rendered, not yet visually verified.\" If GPU-dependent scenes look wrong, re-render those segments with hardware acceleration or a different GL backend and compare.", "e2c4ba1d5196b46f49e6f8c1396977658fa07e73215ea899b9fdde024df098d4": "# Next Verification Steps\n\nThe render **completed**, but it is **not yet verified**. A file exists, and nobody has checked its content. Screenshot mode with a software GPU (likely SwiftShader or llvmpipe) is a common source of silent failures: blank frames, missing effects, or wrong timing. So check the content before you trust the output.\n\n## 1. Confirm the container is sane\n- Check file size. A tiny file is a red flag.\n- Use `ffprobe` (or similar) to confirm the expected format, codec, resolution, frame rate, duration, and frame count.\n- Confirm the file decodes end to end without errors (e.g. `ffmpeg -v error -i out.mp4 -f null -`).\n\n## 2. Inspect actual frames\n- Extract a few sample frames (first, ~25%, middle, ~75%, last) and look at them.\n- Check that each frame shows the expected scene. Watch for blank, black, white, or partially drawn content.\n\n## 3. Check for software-GPU artifacts\n- Compare against a known-good reference, such as a hardware-GPU render or an approved frame.\n- Look for missing WebGL or shader effects, absent blur, shadows, or filters, no antialiasing, wrong colors or gamma, and fallback fonts.\n- Search the render logs for GPU fallback, WebGL context loss, or shader compile warnings.\n\n## 4. Check timing and motion\nScreenshot mode captures frame by frame, so timing problems are common.\n- Run `ffmpeg -vf freezedetect` to find stuck or duplicated frames.\n- Run `ffmpeg -vf blackdetect` to find black segments.\n- Confirm that animations progress smoothly and that total duration matches the composition.\n\n## 5. Quantitative comparison (if a reference exists)\n- Compute SSIM or PSNR per frame against the reference, and flag frames below a threshold.\n\n## 6. Audio (if applicable)\n- Confirm an audio stream exists, has the right duration, and stays in sync.\n\n## Reporting\nUntil steps 2–4 are done, describe the result as \"render completed, output unverified.\" Call it verified only after the frames have been inspected and match expectations.", "a33597602b3c495e884fbd41d7e504cfc8e5ed07347d06973da49f6f4fbd73d8": "The render **completed**, but it is **unverified**. An existing output file only shows that the pipeline exited. It doesn't show that the frames are correct. Screenshot mode with a software GPU on Linux (typically llvmpipe or SwiftShader) adds specific risks: blank or black frames, missing WebGL or shader effects, frozen animation, and fonts or assets that didn't load.\n\n## Next verification steps\n\n**1. Check container and stream integrity**\n- Confirm the file size is plausible, not 0 bytes or suspiciously small.\n- Use `ffprobe` to confirm the codec, resolution, fps, duration and frame count match the composition settings.\n- Confirm the file decodes end to end without errors (e.g. `ffmpeg -v error -i out.mp4 -f null -`).\n\n**2. Inspect actual frames**\n- Extract and view at least the first frame, the last frame and a few in the middle, especially around transitions or effect-heavy sections.\n- Check for correct layout, loaded fonts and images, and no placeholder or fallback styling.\n\n**3. Detect failure patterns automatically**\n- Black or blank frames: `blackdetect` filter.\n- Frozen or stuck animation: `freezedetect` filter. Screenshot mode can capture the same frame repeatedly if time isn't advancing.\n- Duplicate frames: `mpdecimate`, or hash the extracted frames.\n\n**4. Check software-GPU-specific issues**\n- Review the render logs for WebGL context creation failures, \"GPU process unavailable\" or fallback warnings, shader compile errors, and timeouts.\n- Verify that any WebGL, canvas, 3D or filter-heavy elements actually appear. These are the elements most likely to silently render empty under software rendering.\n- Look for precision or blending artifacts such as banding, wrong alpha, or missing blur or shadows.\n\n**5. Compare against a reference**\n- If a known-good render exists (for example from a hardware GPU or a prior approved build), compare sampled frames with SSIM or PSNR and flag significant deviations.\n\n**6. Check audio, if applicable**\n- Confirm an audio stream is present, its duration matches the video, and it is in sync at a couple of checkpoints.\n\n**7. Record the result**\n- Note which checks passed. Only call the render verified after you've inspected frames and found no blank, frozen or missing-effect frames. Until then, report it as \"render completed, output unverified.\"", "e1f5598184edcd6630e67f7f69acbb8277082e1ae150d0214c87576597c7c937": "# Next verification steps\n\nRight now the only supported claim is: **the render finished and an output file exists. Its content is unverified.** Screenshot mode plus a software GPU (likely SwiftShader or llvmpipe) can produce a file that looks successful but contains blank, frozen, or mis-rendered frames. Check in this order:\n\n## 1. Container and stream sanity\n- Run `ffprobe` (or equivalent) to confirm duration, frame count, fps, resolution, codec, and pixel format match what was requested.\n- A frame count or duration that is off usually means screenshot capture dropped or duplicated frames.\n- If audio is expected, confirm the audio stream exists and its duration matches the video.\n\n## 2. Look at actual frames\n- Extract a handful of stills: the first frame, the last frame, the midpoint, and frames at known animation keypoints or scene changes.\n- Inspect them visually. This is the step that has not happened yet, and nothing else substitutes for it.\n\n## 3. Automated whole-file checks\n- **Blank frames:** use `ffmpeg -vf blackdetect` (and a white or solid-color check) to catch frames that failed to paint.\n- **Frozen or duplicate frames:** use `freezedetect` or `mpdecimate`, or hash each frame. Screenshot mode can capture the same frame repeatedly if rendering lags the capture.\n- **Timing:** confirm that animations progress at the expected rate, meaning frame N reflects time N/fps and the motion isn't stalling and then jumping.\n\n## 4. Software-GPU-specific risks\nInspect the elements most likely to break without a hardware GPU:\n- WebGL, canvas, or 3D content\n- Shaders, CSS filters and blurs, `backdrop-filter`\n- Embedded `