ffmpeg-skill 3.8.17 → 3.8.18

package/docs/contract.md

@@ -26,7 +26,7 @@ The contract is derived from the code that runs, not maintained beside it:
 | Field | Meaning | Changes when |
 |---|---|---|
 | `contract_version` | shape of this document (`2.0`) | a key is renamed, removed or changes meaning |
-| `skill.version` | the npm / package.json version (`3.8.17`) | any release |
+| `skill.version` | the npm / package.json version (`3.8.18`) | any release |
 
 A release that adds a tool or a flag keeps `contract_version`; a breaking change to the
 ToolSpec shape bumps it. Consumers pin on `contract_version` and read `skill.version`
@@ -154,7 +154,7 @@ JSON would have been rewritten for that. The flat keys, typed per tool in `outpu
   "deprecated": [],
   "removed": [{"what": "...", "since": "1.10.0", "replacement": "...", "removed_in": "2.0.0", "where": "cli | json | mcp | behaviour"},
               {"what": "running on FFmpeg 5.x (the requirements.ffmpeg floor)", "since": "2.14.0", "replacement": "FFmpeg 6.1 or later; ...", "removed_in": "3.0.0", "where": "behaviour"}],
-  "skill": {"id": "ffmpeg-skill", "version": "3.8.17", "execution_mode": "local", "kind": "execution",
+  "skill": {"id": "ffmpeg-skill", "version": "3.8.18", "execution_mode": "local", "kind": "execution",
             "entrypoints": {"cli": "...", "mcp": "...", "contract": "...", "doctor": "..."},
             "not_provided": ["AI reasoning", "decisions", "production plans", "project IR", "approvals", "network access", "transcription engine"]},
   "requirements": {"python": ">=3.10 (standard library only)", "ffmpeg": ">=6.1", "ffprobe": ">=6.1"},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ffmpeg-skill",
-  "version": "3.8.17",
+  "version": "3.8.18",
   "mcpName": "io.github.kajisho5/ffmpeg-skill",
   "description": "Agent Skill that gives coding agents (Claude Code, Cursor, Codex) a local video editor: 42 FFmpeg tools with a machine-readable contract, contract-derived MCP server, FFmpeg capability detection, probe-first / verify-last workflow. Cut, join, silence removal, fit, captions and karaoke, overlays, motion graphics, HDR to SDR, LUTs, audio clean-up and typed dynamics, sync with drift correction, multicam, loudness, delivery checks, project rendering, batch. No API keys, no cloud, no dependencies.",
   "keywords": [

package/references/scripts.md

@@ -656,6 +656,7 @@ ends -- a cutaway, not a splice, so the output is exactly as long as A. One
 `--insert`/`--at` pair per cutaway (`--duration`, `--end`, `--from` are per
 cutaway too, or given once for all; defaults 4 s and 0); windows may not
 overlap or run past A's end, and B must have enough material from `--from`.
+A still picture as B is shown for the whole window.
 `--audio a` (default) keeps A's audio untouched and stream-copied; `b` replaces
 it inside each window with B's; `mix` plays both. The output's length is
 verified against A's.
@@ -717,7 +718,8 @@ bottom-right corner; `--label none` skips it. No audio unless `--audio-from`
 picks one input's track by index -- mixing every clip's audio together is
 rarely useful for a comparison grid, so this tool never does that silently.
 Runs only as long as the shortest clip by default; `--pad` instead holds
-each shorter clip's last frame (with silence) out to the longest.
+each shorter clip's last frame (with silence) out to the longest. A still
+picture fills its cell for the grid's length; a grid of stills only is refused.
 
 ### silence.py — remove dead air / jump cuts
 ```
@@ -1192,7 +1194,8 @@ hand-built step:
 and `check.py --platform podcast`. `--template all` renders `tiktok, reels, shorts, youtube, x,
 linkedin, facebook` (not the audio template, not the `youtube-shorts` alias) into
 `<stem>_<platform>.mp4`, runs each platform's check and writes `<stem>_pack.md` with one row per
-destination; `report.py --pack <stem>_pack.md` renders that table as a single HTML page. A pack
+destination; `report.py --pack <stem>_pack.md` renders that table (and refuses a file whose first
+table has other columns) as a single HTML page. A pack
 whose destinations did not all pass exits non-zero with the per-destination rows in `pack`.
 
 `audiogram` (1.16) is the one-call form of the podcast-to-video job: an `audiogram` stage runs
@@ -1607,7 +1610,9 @@ like column; `--margin PX` sets all four edges and wins over `--platform`.
 read by `caption.py` and, for `font` and `colour`, by `graphics.py`; it wins
 over the older top-level `caption` block where both set the same key, and that
 block still carries the burn-in-only defaults (`animate`, `karaoke`, `bold`,
-`outline`). `"lang"` is the script hint `--lang` would give. When a
+`outline`). `"lang"` is the script hint `--lang` would give. A key no tool
+reads is refused, naming it (`loudness`, read by none, gets a note), and a
+`font_file` that is not a font is refused where text is drawn with it. When a
 user mentions brand guidelines, colours, "our font" or a logo, ask for or
 write a brand.json once and reuse it across every output.
 

package/scripts/_common/decision.py

@@ -16,7 +16,7 @@ from typing import Any, Dict, List, Optional, Sequence, Tuple
 from _common.color import (as_limited, bt709_label_filter, bt709_matrix_args, bt709_matrix_filter, bt709_tag_args, drawn_stream_format,
                            is_neutral_color, limited_range_filter, rgb_island, rgb_to_bt709_filter, _sdr_bt709)
 from _common.alpha import rgb_to_bt709_line
-from _common.emit import die, input_length, record_fallback, refuse, warn
+from _common.emit import die, input_length, note, record_fallback, refuse, warn
 from _common.runner import read_json
 from _common.runner import CODECS, STATE, ffmpeg_encoders, ffmpeg_list_error, ffmpeg_version, hw_platform_reason
 
@@ -1295,6 +1295,46 @@ BRAND_DEFAULTS: Dict[str, Any] = {
 }
 
 
+# Every key a tool reads from a brand file, per block (#510). `styles.caption` is merged over the
+# top-level `caption` block (brand_caption_style()), so the two take the same keys. `colors.accent`
+# is a palette entry BRAND_DEFAULTS and examples/brand.json carry; `loudness` is read by no tool
+# (A107) and is kept out of the refusal, since the example shipped it until 3.8.8: it gets a note.
+BRAND_KEYS: Dict[str, frozenset] = {
+    "": frozenset({"font", "font_file", "colors", "logo", "logo_position", "logo_scale", "logo_opacity",
+                   "safe_margin", "caption", "styles", "lang", "emoji_assets", "loudness"}),
+    "colors": frozenset({"primary", "text", "outline", "background", "accent", "upcoming"}),
+    "caption": frozenset({"size", "position", "animate", "karaoke", "bold", "outline", "box", "color", "colour",
+                          "font", "emoji_assets"}),
+    "styles": frozenset({"caption"}),
+}
+BRAND_KEYS["styles.caption"] = BRAND_KEYS["caption"]
+
+
+def check_brand_keys(data: Dict[str, Any], path: str) -> None:
+    """Refuse a brand file key no tool reads, as render.py refuses a project's (check_keys()): a
+    misspelt `"safe_margn"` or `"colours"` was dropped without a word and the defaults drawn."""
+    import difflib
+    import json
+    blocks = [("", data)]
+    for name in ("colors", "caption", "styles"):
+        if isinstance(data.get(name), dict):
+            blocks.append((name, data[name]))
+    if isinstance(data.get("styles"), dict) and isinstance(data["styles"].get("caption"), dict):
+        blocks.append(("styles.caption", data["styles"]["caption"]))
+    for block, obj in blocks:
+        for key in obj:
+            if key in BRAND_KEYS[block]:
+                continue
+            where = f"{block}.{key}" if block else str(key)
+            near = difflib.get_close_matches(str(key), sorted(BRAND_KEYS[block]), n=1)
+            # quoted as JSON: the key is the caller's text, and a quote or a line break in it stays one line
+            die(f"brand file {path}: unknown key {json.dumps(where)}" + (f' (did you mean "{near[0]}"?)' if near else ""),
+                kind="input", hint=f"the keys read{' in ' + block if block else ''}: " + ", ".join(sorted(BRAND_KEYS[block])))
+    if "loudness" in data:
+        note(f'brand file {path}: "loudness" is read by no tool and was ignored (a target is loudness.py -I, '
+             'export.py\'s preset, or a render project\'s "loudness")')
+
+
 def load_brand(path: Optional[str]) -> Dict[str, Any]:
     """Load brand.json (fonts, colours, logo, safe margins, caption defaults); missing keys fall back to defaults."""
     import copy
@@ -1322,6 +1362,7 @@ def load_brand(path: Optional[str]) -> Dict[str, Any]:
             die(f'brand file {path}: "{key}" must be an object {{...}}, got {type(value).__name__}', kind="input")
         if key in ("logo", "font_file", "font") and not isinstance(value, str):
             die(f'brand file {path}: "{key}" must be a string, got {type(value).__name__}', kind="input")
+    check_brand_keys(data, path)
     base = Path(path).resolve().parent
     for k, v in data.items():
         if v is None and isinstance(brand.get(k), dict):

package/scripts/_common/fonts.py

@@ -278,6 +278,37 @@ _SCRIPT_RANGES = (
 )
 
 
+# The first bytes of the font files FreeType opens (drawtext and libass both load through it):
+# TrueType, OpenType/CFF, Apple 'true'/'typ1', a collection, WOFF/WOFF2, PostScript Type 1 (PFA
+# text, PFB segment marker), BDF and PCF bitmap fonts.
+_FONT_MAGIC = (b"\x00\x01\x00\x00", b"OTTO", b"true", b"typ1", b"ttcf", b"wOFF", b"wOF2",
+               b"%!PS-AdobeFont", b"%!FontType1", b"\x80\x01", b"STARTFONT", b"\x01fcp")
+
+
+def require_font_file(path: str, label: str = "--font-file") -> str:
+    """Refuse a font file that is not there or is not a font, before anything is drawn with it
+    (#510). drawtext that cannot load its `fontfile=` asks fontconfig for a default face instead
+    and exits 0, and libass given the file's directory finds no face in it and does the same, so a
+    text file named `brand.ttf` drew DejaVu Sans with `font_used.substituted: false`. Read by the
+    first bytes, not the extension; a gzipped PCF (`.pcf.gz`) and a Mac `.dfont` (no signature)
+    pass by name."""
+    shown_path = str(path)
+    if not os.path.isfile(shown_path):
+        die(f"{label} {shown_path}: no such file", kind="input")
+    try:
+        with open(shown_path, "rb") as fh:
+            head = fh.read(16)
+    except OSError as exc:
+        die(f"{label} {shown_path} cannot be read: {exc.strerror or exc}", kind="input")
+    lower = shown_path.lower()
+    if head.startswith(_FONT_MAGIC) or lower.endswith(".dfont") or (lower.endswith(".pcf.gz") and head.startswith(b"\x1f\x8b")):
+        return shown_path
+    die(f"{label} {shown_path} is not a font file (it starts with {head[:8]!r}, which no TrueType, OpenType, "
+        "WOFF, Type 1, BDF or PCF font does): drawing with it would fall back to another face without a word",
+        kind="input", hint="name a .ttf, .otf or .ttc file (fc-list lists the installed ones), or --font FAMILY")
+    return shown_path
+
+
 def font_family_of_file(path: str) -> "Optional[str]":
     """The family name of a font FILE -- what libass wants, given a --font-file. `fc-scan` reads
     the file directly; without fontconfig the file stem is the honest best guess."""

package/scripts/_common/probe.py

@@ -905,6 +905,20 @@ def refuse_not_a_still(path: str, meta: Dict[str, Any], flag: str, instead: str)
         + (f" ({length:.3f}s)" if length else "") + f", and {flag} is read as one picture", kind="input", hint=instead)
 
 
+def is_still_input(meta: Dict[str, Any]) -> bool:
+    """A probe document of one picture read by an image demuxer (_is_still()'s rule, on the
+    document): a still given where a clip is taken. Read with a plain `-i` it is one frame, so a
+    tool that shows it for a while opens it with still_loop_args() (#510)."""
+    fmt = str((meta or {}).get("format") or "")
+    return not (meta or {}).get("dry_run") and (fmt == "image2" or fmt.endswith("_pipe"))
+
+
+def still_loop_args(path: str, seconds: float) -> List[str]:
+    """The input options that show a still picture for `seconds`: `-loop 1` repeats its one frame
+    (the image demuxers' option) and `-t` ends the repeat, so the input is bounded."""
+    return ["-loop", "1", *still_input_args(path), "-t", f"{max(seconds, 0.001):.3f}"]
+
+
 def analyze_levels(path: str, seconds: float = 20.0) -> Dict[str, Any]:
     """Sample luma/saturation statistics (signalstats) and guess whether the picture is Log-encoded.
 

package/scripts/broll.py

@@ -26,7 +26,7 @@ from _common.decision import (av_trim, conform_output_t, conform_to_length, fram
                               grid_at_or_after, silence_filter, stream_starts, window_expr, windowed_overlay_x)
 from _common import STATE, add_common, aac_args, apply_common, cfr_args, cfr_at_input, as_limited, default_output, die, draws_chroma, drawn_chain, emit, ffmpeg_base, info, time_arg, label_chain, matrix_chain, overlay_format, range_chain, probe, run, validate_color, video_args, X264_PRESETS, fmt_secs
 from _common.emit import note, record_fallback
-from _common.probe import display_size, square_pixels, square_pixels_note
+from _common.probe import display_size, is_still_input, square_pixels, square_pixels_note, still_loop_args
 from _common.emit import input_length
 
 
@@ -109,7 +109,9 @@ def main() -> int:
             die(f"cutaway {i + 1}: --at {at:g}s is past the end of the A-roll ({dur_a:.3f}s)")
         if dur_a and at + length > dur_a + 0.01:
             die(f"cutaway {i + 1}: {at:g}s + {length:g}s runs past the end of the A-roll ({dur_a:.3f}s)")
-        dur_b = input_length(meta_b)
+        # a still has no material to run out of: it is looped for the window. image2 gives some (a
+        # TGA) a duration of one frame, which this refused as "only -0.460s from 0.5s" (review of #532)
+        dur_b = None if is_still_input(meta_b) else input_length(meta_b)
         if dur_b and start_b + length > dur_b + 0.01 and not STATE.dry_run:
             die(f"cutaway {i + 1}: {path} has only {dur_b - start_b:.3f}s from {start_b:g}s, {length:g}s asked for")
         # the cutaway in whole frames: `first` is B's first frame at or after --from, `on` the
@@ -139,6 +141,15 @@ def main() -> int:
     output = args.output or default_output(args.input, "broll")
     cmd = ffmpeg_base() + ["-i", args.input]
     for c in cutaways:
+        # a still B-roll is one frame to a plain -i: it showed for one frame of the cutaway and A
+        # came back under it (#510). Looped, it lasts the window it is trimmed to. The bound is past
+        # the trim's end, which runs from B's first frame at or after --from on the loop's own
+        # grid for the window's whole frames: --from + --duration cut that frame off a short window
+        # (--from 0.041 --duration 0.033 needs the frame at 0.08, review of #532). A frame of B
+        # past it costs nothing: the trim drops it.
+        if is_still_input(c["meta"]):
+            frame_b = 1 / c["rate"] if c["rate"] else 0.04
+            cmd += still_loop_args(c["path"], max(c["from"], c["first"]) + max(c["length"], c["span"] or 0) + 2 * frame_b)
         cmd += ["-i", c["path"]]
 
     # Picture: each B window is trimmed, normalised to A's frame and fps, shifted to start at its

package/scripts/caption.py

@@ -56,7 +56,7 @@ from _common.asr import ENGINE_CHOICES
 from _common.emit import warn
 from _common.probe import display_size, square_pixels, square_pixels_note
 from _common.runner import carried_stream_maps, refuse_output_is_input, same_file, subtitle_codec_for, subtitle_container_holds
-from _common.fonts import font_choice, record_font_choice
+from _common.fonts import font_choice, record_font_choice, require_font_file
 from _common import (ASR_INSTALL_HINT, die_no_engine, parse_srt, transcribe, whisper_word_timings,
                      write_srt)
 from _common.asr import srt_blocks
@@ -1327,6 +1327,11 @@ def main() -> int:
     if args.brand and bcap.get("karaoke") and not args.karaoke:
         args.karaoke = True
     if args.brand and brand.get("font_file") and not args.fonts_dir:
+        # the brand's face is found in its directory by libass, so a file there that is no font
+        # left libass to another face without a word (#510); a soft track (--mode mux) draws nothing,
+        # and nor does a run with no input video, which only writes the SRT (review of #532)
+        if args.mode != "mux" and args.input:
+            require_font_file(brand["font_file"], "the --brand file's font_file")
         args.fonts_dir = str(Path(brand["font_file"]).parent)
     if not (args.srt or args.ass or args.text or args.transcribe):
         die("give one of --srt, --ass, --text or --transcribe")

package/scripts/graphics.py

@@ -47,7 +47,7 @@ from _common import (guard_sidecar, require_filter, aac_args, add_common, brand_
 from _common.emit import note, warn
 from _common.alpha import (add_alpha_args, audio_line, check_alpha_args, decoder_args_for, default_ext, finish_chain,
                            report as alpha_report, source_alpha, source_format, tag_args, video_line)
-from _common.fonts import font_choice, record_font_choice
+from _common.fonts import font_choice, record_font_choice, require_font_file
 from _common.probe import display_size, square_pixels, square_pixels_note
 from _ass_overlay import text_overlay_ass, EMOJI_SENTINEL
 from _common import drawtext_fontfile  # noqa: E402
@@ -175,6 +175,9 @@ def main(force_route: Optional[str] = None) -> int:
     if args.brand and style.get("color") and not args.text_color:
         text_c = color_hex(style["color"])
     args.lang = args.lang or (brand.get("lang") if args.brand else None)
+    # checked where text is drawn with it: the progress template draws a bar only (review of #532)
+    if args.template != "progress" and (args.font_file or brand.get("font_file")):
+        require_font_file(args.font_file or brand["font_file"], "--font-file" if args.font_file else "the --brand file's font_file")
     # a font that covers the text before drawtext renders boxes instead of glyphs (1.12)
     _script, script_file, _family = script_font_for_text(
         " ".join(t for t in (args.name, args.title, args.subtitle, args.text, args.top, args.bottom) if t),

package/scripts/grid.py

@@ -32,7 +32,7 @@ from _common import drawtext_fontfile  # noqa: E402
 from _common import ffmpeg_filters, filter_missing_hint  # noqa: E402
 from _common.emit import note, record_fallback  # noqa: E402
 from _common.fonts import script_font_for_text  # noqa: E402
-from _common.probe import square_pixels  # noqa: E402
+from _common.probe import is_still_input, square_pixels, still_loop_args  # noqa: E402
 from _common.wrap import text_width_em  # noqa: E402
 from _common.emit import input_length  # noqa: E402
 from _common.decision import conform_output_t, conform_to_length  # noqa: E402
@@ -116,8 +116,15 @@ def main() -> int:
     if args.audio_from is not None and not metas[args.audio_from].get("audio"):
         die(f"--audio-from {args.audio_from}: {args.inputs[args.audio_from]} has no audio stream")
 
-    durations = [input_length(m) for m in metas]
+    # a still picture has no length of its own: it lasts as long as the grid (#510). Counted as a
+    # clip of 0 s, it made the grid 0 s long, and the run ended in a traceback on the empty file.
+    stills = [is_still_input(m) for m in metas]
+    if all(stills):
+        die("every cell is a still picture, so the grid has no length to take from a clip", kind="input",
+            hint="give at least one video cell, or make a clip of a still first (insert.py STILL --duration T)")
+    durations = [input_length(m) for m, still in zip(metas, stills) if not still]
     target_duration = max(durations) if args.pad else min(durations)
+    durations = [target_duration if still else input_length(m) for m, still in zip(metas, stills)]
 
     # each label is drawn with a font that covers its own script, as every other text-drawing tool
     # picks one (through 3.1.3 a Japanese or Thai filename came out as tofu, #411); `font_used` is
@@ -139,11 +146,13 @@ def main() -> int:
     if args.label == "auto" and cut:
         note(f"{len(cut)} cell label(s) wider than the {args.cell_width} px cell at --font-size "
              f"{args.font_size} were shortened from the end with an ellipsis")
-    output = args.output or default_output(args.inputs[0], "grid")
+    # named after the first cell; a still there would give its own extension (white_grid.png), and
+    # the image muxer cannot write the grid's frames to one file name (review of #532)
+    output = args.output or default_output(args.inputs[0], "grid", "mp4" if stills[0] else None)
 
     cmd = ffmpeg_base()
-    for p in args.inputs:
-        cmd += ["-i", p]
+    for p, still in zip(args.inputs, stills):
+        cmd += (still_loop_args(p, target_duration) if still else []) + ["-i", p]
 
     # each cell converted by its own tags to the BT.709 the grid is tagged with (a BT.601 or an RGB
     # input): without it 5.1/6.1 relabelled them, and 7.1+ converted cells to one another's matrix.

package/scripts/overlay.py

@@ -46,7 +46,7 @@ from _common.probe import display_size, refuse_not_a_still, square_pixels, squar
 from _common.drawtext import shaping_refusal
 from _common.wrap import wrap_text
 from _common import text_width_em
-from _common.fonts import font_choice, record_font_choice
+from _common.fonts import font_choice, record_font_choice, require_font_file
 from _common import drawtext_fontfile  # noqa: E402
 
 # Per-edge margins: a platform's UI does not cover the same fraction of every edge (TikTok's
@@ -361,6 +361,7 @@ def main() -> int:
     # at --font-size), so a project that asked for 200 px text completed with the 42 px default.
     if args.text and not (args.image or args.video) and (args.scale is not None or args.scale_percent is not None):
         die("--scale and --scale-percent size an image, logo or video layer; text size is --font-size", kind="input")
+    font_file_from = "--font-file"  # what the refusal of a font file that is not one names
     if args.brand:
         if args.margin == ap.get_default("margin"):
             args.margin = int(brand.get("safe_margin", args.margin))
@@ -368,6 +369,7 @@ def main() -> int:
             args.font = brand.get("font", args.font)
         if not args.font_file and brand.get("font_file"):
             args.font_file = brand["font_file"]
+            font_file_from = "the --brand file's font_file"
     if args.text:
         # 1.15: drawtext never reorders or re-clusters (no harfbuzz), so Devanagari matras and
         # Thai/Lao mark stacking come out wrong on EVERY build. A wrong frame is not a delivery:
@@ -393,6 +395,8 @@ def main() -> int:
                      "a font without the glyph draws an empty box (monochrome at best with one). --emoji none "
                      "leaves them out; caption.py/graphics.py composite colour PNGs with --emoji-assets",
                      "emoji_monochrome")
+    if args.text and args.font_file:
+        require_font_file(args.font_file, font_file_from)
     script_file = script_family = None
     if args.text and not args.font_file:
         # 1.12: non-Latin overlay text picks a font by script, so a title in Japanese, Korean,
@@ -533,6 +537,11 @@ def main() -> int:
         # a --start/--end window is in the layer's position, which is evaluated on the main
         # picture's frames; overlay's enable is evaluated on the layer's frames too
         ov = f"overlay={windowed_overlay_x(x, enable) if enable else x}:{y}" + (overlay_format(meta) or ":format=auto")
+        if not meta.get("duration"):
+            # nothing to bound by -t: the overlay ends with the main picture. -shortest alone never
+            # ended a still main (one picture, no duration): overlay kept repeating it under the
+            # looped layer and the run went on until its timeout (#510)
+            ov += ":shortest=1"
         # -loop 1 turns the still into a timed stream so fade/enable expressions see real timestamps
         cmd = ffmpeg_base() + ["-i", args.input, "-loop", "1", *still_input_args(args.image), "-i", args.image]
         # the RGBA still is converted to the BT.709 the output is tagged with (overlay's own

package/scripts/report.py

@@ -14,6 +14,7 @@ import base64
 import html
 import json
 import os
+import re
 import sys
 import tempfile
 from pathlib import Path
@@ -145,6 +146,10 @@ def md_cells(line: str) -> List[str]:
     return cells
 
 
+# the columns of render.py's render_pack() table, in its order
+PACK_HEADER = ["platform", "file", "size", "duration", "check"]
+
+
 def pack_report(args) -> int:
     """render.py --template all writes <stem>_pack.md: one row per destination. This renders the
     same rows as HTML, so a pack can be handed over the way a single delivery report is -- no
@@ -152,19 +157,37 @@ def pack_report(args) -> int:
     text = read_text_or_die(args.pack, "--pack")
     rows: List[List[str]] = []
     header: List[str] = []
+    delimiter: Optional[List[str]] = None
     for line in text.split("\n"):
         line = line.strip()
         if not line.startswith("|"):
+            if header:
+                break  # the table ended: a later table in the file is not the pack's
             continue
         cells = md_cells(line)
-        if all(set(c) <= set("-: ") for c in cells):
-            continue
         if not header:
             header = cells
+        elif delimiter is None:
+            delimiter = cells  # the line under the header, whatever it is: checked below
         else:
+            # every later line is a row, a separator-like one too: `| | |` after a row was skipped
+            # as a delimiter and never counted (review of #532)
             rows.append(cells)
+    # the table render.py --template all writes, and only that one: any Markdown table was taken
+    # and handed over as a pack report with `verified: true` (#510)
+    if header and header != PACK_HEADER:
+        die(f"{args.pack}: its table's columns are {' | '.join(header)}, not the pack table's "
+            f"({' | '.join(PACK_HEADER)}) that render.py --template all writes", kind="input")
+    # a header with a row under it and no delimiter line is no Markdown table (review of #532)
+    if header and delimiter is not None and not (
+            len(delimiter) == len(PACK_HEADER) and all(re.fullmatch(r":?-+:?", c) for c in delimiter)):
+        die(f"{args.pack}: the line under the pack table's header is not its delimiter row "
+            f"(|---|---|---|---|---|), so it is no Markdown table", kind="input")
+    bad = next((i for i, r in enumerate(rows) if len(r) != len(PACK_HEADER)), None)
+    if bad is not None:
+        die(f"{args.pack}: row {bad + 1} of the pack table has {len(rows[bad])} cells, not {len(PACK_HEADER)}", kind="input")
     if not rows:
-        die(f"{args.pack}: no pack table found (expected the Markdown table render.py --template all writes)")
+        die(f"{args.pack}: no pack table found (expected the Markdown table render.py --template all writes)", kind="input")
     title = args.title or f"Social pack — {Path(args.pack).stem.replace('_pack', '')}"
     output = args.output or str(Path(args.pack).with_suffix(".html"))
     guard_sidecar(output, args.pack)