ffmpeg-skill 3.6.1 → 3.6.3

package/scripts/_common/runner.py

@@ -332,7 +332,7 @@ class Context:
     __slots__ = ("dry_run", "json", "json_brief", "progress", "fast", "duration_hint", "commands", "timeout", "overwrite", "written", "preexisting", "plan", "plan_written", "plan_inputs", "codec", "alpha_line",
                  "hw", "hw_source", "hw_notes", "hw_swaps", "hw_fallback", "hw_env_ignored", "hw_stages", "hw_auto",
                  "notes", "warnings", "fallbacks", "skipped", "audit_log", "stage_verification", "first_input", "audio_inputs", "video_inputs",
-                 "source_timecode", "smpte_hint", "delivered")
+                 "source_timecode", "smpte_hint", "delivered", "expected_timecode")
 
     def __init__(self) -> None:
         self.reset()
@@ -343,6 +343,7 @@ class Context:
         self.first_input = None   # (path, audio track count) of the first input probed: emit() reports tracks the output left out
         self.video_inputs = set()  # real paths of the inputs probed that have a picture: with two or more, which one the output shows is the tool's choice (sync --trim-second, a join)
         self.source_timecode = None  # (start timecode, duration) of the first input probed that carries one (time_arg's SMPTE hint)
+        self.expected_timecode = None  # the start timecode a tool that moved the picture's start wrote (timeline.output_timecode_args; "" for none): source_carry compares it
         self.smpte_hint = None    # what die() says when an hh:mm:ss:ff flag read past the end looks like a source timecode (#411)
         self.delivered: List[str] = []  # deliverables written before a later step (export --normalize, render's chapters/check): a stop then keeps them (#415)
         self.audio_inputs = set()  # real paths of the inputs probed that have sound: with two or more, whose tracks an output should keep is the tool's choice (grid --audio-from, a mix)
@@ -481,6 +482,14 @@ def apply_common(args: "argparse.Namespace") -> None:
     STATE.progress = bool(getattr(args, "progress", False))
     STATE.fast = bool(getattr(args, "fast", False))
     STATE.overwrite = bool(getattr(args, "overwrite", False))
+    if STATE.plan and os.environ.get("FFMPEG_SKILL_READ_ONLY", "") not in ("", "0"):
+        # mcp/server.py runs the tools it annotates readOnlyHint (probe, check, cropdetect) with
+        # this set: a plan is the one file they could write, so it is refused here, after argparse,
+        # whatever spelling of --plan a raw argv used. Refused before the exit hook can write it.
+        plan_path, STATE.plan = STATE.plan, None
+        refuse("input", "read_only_plan_refused",
+               f"--plan {plan_path!r}: this tool runs read-only here (FFMPEG_SKILL_READ_ONLY) and writes no file; "
+               "run it from the command line to write a plan", plan=plan_path)
     if STATE.plan:
         # the plan is a file this run writes itself: the side-file guards apply (#408), so it
         # never replaces an input, the output or an existing file without --overwrite
@@ -1229,7 +1238,13 @@ def refuse_existing_outputs(paths: Sequence[str]) -> None:
         if output not in existing:
             existing.append(output)
             facts.append({"path": output, "resolved": real, "size": size, "mtime_ns": mtime_ns})
+    # a file batch.py delivered on an earlier --watch pass, still exactly as it left it, is that
+    # run's own: replaced without --overwrite, per path (anything else existing is still refused)
+    if existing and not STATE.overwrite:
+        keep = [i for i, p in enumerate(existing) if not owned_replaceable(p)]
+        existing, facts = [existing[i] for i in keep], [facts[i] for i in keep]
     if not existing or STATE.overwrite:
+        report_owned_targets(paths)
         return
     hint = "pass --overwrite, or choose another -o path"
     if len(existing) == 1:
@@ -1248,6 +1263,111 @@ def _remember_output(cmd: Sequence[str]) -> None:
         STATE.written.add(os.path.realpath(output))
     except OSError:
         pass
+    report_committed(output)
+
+
+# set only by batch.py for the steps it runs: the path of a JSON file {"replaceable": {real path:
+# owned_identity()}, "report": directory}. "replaceable" is every file that batch process
+# delivered (a --watch loop's earlier passes) as it left it; a step replaces one of those without
+# --overwrite while it is still that file, and nothing else. Each process that passes the output
+# check writes <report>/<pid>.json: {"targets": the paths it was allowed to write, "committed":
+# {real path: owned_identity()} taken when each of them was written (report_committed), so batch
+# learns the side files (an .srt beside the video) it delivered as they were when written, not as
+# they are when the item ends -- an edit made while a later step ran is not adopted.
+OWNED_ENV = "_FFMPEG_SKILL_OWNED"
+_OWNED_CACHE: Dict[str, Dict[str, Any]] = {}
+_OWNED_TARGETS: Dict[str, List[str]] = {}
+_OWNED_COMMITTED: Dict[str, Dict[str, Dict[str, int]]] = {}
+
+
+def owned_identity(path: str) -> "Optional[Dict[str, int]]":
+    """{size, mtime_ns, ino, dev} of a regular file: what tells the file batch.py delivered from
+    one put at the same path since (a replacement with the same size and mtime is a new inode).
+    None when the path is not a regular file."""
+    try:
+        st = os.stat(path)
+    except OSError:
+        return None
+    if not os.path.isfile(path):
+        return None
+    return {"size": st.st_size, "mtime_ns": st.st_mtime_ns, "ino": st.st_ino, "dev": st.st_dev}
+
+
+def _owned_config(config: Optional[str] = None) -> Dict[str, Any]:
+    config = config if config is not None else os.environ.get(OWNED_ENV, "")
+    if not config:
+        return {}
+    if config not in _OWNED_CACHE:
+        try:
+            with open(config, encoding="utf-8") as fh:
+                doc = json.load(fh)
+        except (OSError, ValueError):
+            doc = {}
+        _OWNED_CACHE[config] = doc if isinstance(doc, dict) else {}
+    return _OWNED_CACHE[config]
+
+
+def owned_replaceable(path: str, config: Optional[str] = None) -> bool:
+    """Whether `path` is a file the batch.py process running this step delivered, still with the
+    identity it had then (checked now, at the output check, not when the step was planned)."""
+    replaceable = _owned_config(config).get("replaceable")
+    if not isinstance(replaceable, dict):
+        return False
+    try:
+        real = os.path.realpath(path)
+    except OSError:
+        return False
+    expected = replaceable.get(real)
+    return isinstance(expected, dict) and owned_identity(real) == expected
+
+
+def report_owned_targets(paths: Sequence[Optional[str]], config: Optional[str] = None) -> None:
+    """Under batch.py: record paths this process passed the output check for, in the report
+    directory its config names. Nothing outside batch.py; a report that cannot be written only
+    means the next pass refuses that file as someone else's."""
+    config = config if config is not None else os.environ.get(OWNED_ENV, "")
+    report = _owned_config(config).get("report")
+    if not isinstance(report, str) or not report:
+        return
+    targets = _OWNED_TARGETS.setdefault(config, [])
+    for p in paths:
+        if p:
+            try:
+                real = os.path.realpath(p)
+            except OSError:
+                continue
+            if real not in targets:
+                targets.append(real)
+    _write_owned_report(config, report)
+
+
+def _write_owned_report(config: str, report: str) -> None:
+    doc = {"targets": _OWNED_TARGETS.get(config, []), "committed": _OWNED_COMMITTED.get(config, {})}
+    try:
+        with open(os.path.join(report, f"{os.getpid()}.json"), "w", encoding="utf-8") as fh:
+            json.dump(doc, fh)
+    except OSError:
+        pass
+
+
+def report_committed(path: Optional[str], config: Optional[str] = None) -> None:
+    """Under batch.py: record the identity `path` has right now, just after this process wrote it,
+    if it passed this process's output check. What batch later lets a step replace is that file
+    as it was written; one edited afterwards no longer matches and is refused."""
+    config = config if config is not None else os.environ.get(OWNED_ENV, "")
+    report = _owned_config(config).get("report")
+    if not path or not isinstance(report, str) or not report:
+        return
+    try:
+        real = os.path.realpath(path)
+    except OSError:
+        return
+    if real not in _OWNED_TARGETS.get(config, []):
+        return
+    ident = owned_identity(real)
+    if ident:
+        _OWNED_COMMITTED.setdefault(config, {})[real] = ident
+        _write_owned_report(config, report)
 
 
 def remember_written(*paths: Optional[str]) -> None:
@@ -1260,6 +1380,7 @@ def remember_written(*paths: Optional[str]) -> None:
                 STATE.written.add(os.path.realpath(path))
             except OSError:
                 pass
+            report_committed(path)
 
 
 def _timed_out(cmd: Sequence[str], seconds: float) -> "None":
@@ -1649,13 +1770,14 @@ def child_limit(per_call: Optional[float] = None) -> Optional[float]:
     return (limit * 4 + 60) if limit else None
 
 
-def run_tool(argv: Sequence[str], *, per_call: Optional[float] = None) -> subprocess.CompletedProcess:
+def run_tool(argv: Sequence[str], *, per_call: Optional[float] = None,
+             env: Optional[Dict[str, str]] = None) -> subprocess.CompletedProcess:
     """Run a sibling script (`argv[0]` is the script path) under child_limit(). On overrun the
     child is killed and a CompletedProcess is returned whose stdout is this skill's own failure
     document (kind timeout, exit 124), so callers that parse the child's --json see a timeout
-    exactly as they would from the child itself."""
+    exactly as they would from the child itself. `env` replaces the inherited environment."""
     limit = child_limit(per_call)
-    child = subprocess.Popen([sys.executable] + list(argv), stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, encoding="utf-8", errors="replace")
+    child = subprocess.Popen([sys.executable] + list(argv), stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, encoding="utf-8", errors="replace", env=env)
     _watch(child, [])  # a sibling script removes its own partial output; there is none of ours to clean
     try:
         out, err = child.communicate(timeout=limit)
@@ -1674,6 +1796,20 @@ def run_tool(argv: Sequence[str], *, per_call: Optional[float] = None) -> subpro
         return subprocess.CompletedProcess(list(argv), 124, json.dumps(doc), partial + f"\nerror: {msg}\n")
 
 
+def option_args(flag: str, value: Any) -> List[str]:
+    """One option and its value for a sibling tool's argparse, as [flag, value] -- or as the single
+    token `flag=value` when the value starts with '-'. argparse reads a separate token that starts
+    with '-' (and is not a negative number) as the next option, so overlay text "-50%" was refused
+    as "expected one argument" and a value like "--plan=x" became an option of its own. The joined
+    form is read as the value whatever it holds. `flag` must be a long option: `-o=x` is not."""
+    text = str(value)
+    if text.startswith("-"):
+        if not flag.startswith("--"):
+            raise ValueError(f"option_args: {flag!r} is not a long option")
+        return [f"{flag}={text}"]
+    return [flag, text]
+
+
 def child_args() -> List[str]:
     """The shared flags a tool that runs sibling scripts (render.py, batch.py) forwards to them,
     so one `--timeout`/`--overwrite`/`--fast`/`--dry-run` on the outer command governs every
@@ -1749,7 +1885,7 @@ def subtitle_container_holds(codec: str, out_ext: str) -> bool:
     return True
 
 
-def run_keeping_subtitles(cmd: List[str], output: str) -> bool:
+def run_keeping_subtitles(cmd: List[str], output: str, relabel_timecode: bool = False) -> bool:
     """Run an ffmpeg command that already maps its video/audio, trying first to also
     stream-copy any subtitle/data streams the source has (`-map 0:s?`/`0:d?` are no-ops when
     there are none). A source whose subtitle codec cannot be copied into the target container
@@ -1761,8 +1897,13 @@ def run_keeping_subtitles(cmd: List[str], output: str) -> bool:
     The retry is recorded with the first attempt's error (`diagnostics.fallbacks`,
     `non_av_streams_dropped`): the caller's `dropped_non_av_streams` says that streams went, the
     record says why, which is the only way to tell a container that cannot hold them from a first
-    attempt that failed for another reason and happened to succeed the second time."""
-    first = run(cmd + ["-map", "0:s?", "-map", "0:d?", "-c:s", "copy", "-c:d", "copy", output], check=False)
+    attempt that failed for another reason and happened to succeed the second time.
+
+    `relabel_timecode`: the command writes its own start timecode (timeline.output_timecode_args),
+    so a source's tmcd data track is not copied -- its label, at the source's rate, would win over
+    the new one; the MOV/MP4 muxer builds the track again from the label."""
+    skip_tmcd = ["-map", "-0:d:m:timecode"] if relabel_timecode else []
+    first = run(cmd + ["-map", "0:s?", "-map", "0:d?"] + skip_tmcd + ["-c:s", "copy", "-c:d", "copy", output], check=False)
     if first.returncode == 0:
         return False
     if classify_ffmpeg_failure(first.stderr or "") or not _has_non_av_streams(cmd):

package/scripts/_common/timeline.py

@@ -153,6 +153,45 @@ def _tc_label(frames: int, rate: Fraction, drop: bool) -> str:
     return _tc(frames, nominal)[:-3] + ";" + _tc(frames, nominal)[-2:]
 
 
+def output_timecode_args(meta: Dict[str, Any], first_frame: Optional[float], rate: Optional[float] = None) -> List[str]:
+    """The arguments that give an output the start timecode of the source frame it starts on:
+    `first_frame` seconds after the source picture's first frame (negative: a head the tool
+    added), or None to write no start timecode at all (a join, whose later frames no single start
+    label describes). A tool that moves the start of the picture used to write the source's own
+    start timecode unchanged: FFmpeg copies the video stream's `timecode` tag, and the MOV/MP4
+    muxer rebuilds a tmcd track from it, so a cut from 1 s was stamped 01:00:00:00 for frame 30.
+    Both the stream and the container tag are set (Matroska keeps a stale stream tag otherwise;
+    MXF reads the container's). Nothing for a source without a start timecode. The label also
+    goes on STATE.expected_timecode, which source_carry compares the written file with: an
+    MXF, which always writes one, reads 00:00:00:00 when none is wanted and is listed as dropped.
+    `rate` is the frame rate the output is delivered at when the tool changes it (fit --fps, a
+    VFR source conformed to a constant rate), None for the source's own: the source's label is
+    read at the source's rate and the output's is counted at the output's, so 01:00:00:12 at 25
+    fps (0.48 s past the hour) is 01:00:00:24 at 50."""
+    from _common.runner import STATE
+    tc = (meta or {}).get("timecode") or {}
+    fps = ((meta or {}).get("video") or {}).get("fps")
+    if not tc.get("value") or not fps:
+        return []
+    label = ""
+    if first_frame is not None:
+        src_rate = exact_rate(float(fps))
+        out_rate = exact_rate(float(rate)) if rate else src_rate
+        drop = _drop_frame(tc.get("drop_frame"), out_rate)
+        nominal = round(float(out_rate))
+        if nominal >= 1:
+            day = (nominal * 600 - (nominal // 15) * 9) * 144 if drop else nominal * 86400
+            # the source label and the offset to the first frame, both in output frames, rounded
+            # once: 00:00:00:02 at 25 fps plus 0.08 s is 4.8 frames at 30, so frame 5, not 2 + 2
+            pos = (Fraction(start_tc_frames(tc, src_rate)) / src_rate
+                   + Fraction(first_frame).limit_denominator(1000000)) * out_rate
+            label = _tc_label(round(pos) % day, out_rate, drop)
+        # below 1 fps no frame count can name a frame: the label is removed, as when the first
+        # frame is unknown, rather than divide by a zero-length day
+    STATE.expected_timecode = label
+    return ["-metadata:s:v:0", f"timecode={label}", "-metadata", f"timecode={label}"]
+
+
 def build(proj: Dict[str, Any], probes: Dict[str, Dict[str, Any]], rel) -> Dict[str, Any]:
     """The editor-neutral timeline: every time in frames at `rate`.
 

package/scripts/_common/wrap.py

@@ -29,7 +29,11 @@ ADVANCE_EM = {"ja": 1.0, "zh": 1.0, "ko": 1.0, "th": 1.0, "hi": 0.7, "ar": 0.6,
 # a word. A Thai run is therefore one atom, broken only at the spaces (or the manual `|`) the
 # writer put there; an over-long run stays long on its own line, the rule long Latin words
 # already follow.
-NO_SPACE_SCRIPTS = ("ja", "zh", "ko")
+# Korean is NOT here: it is written with spaces between words (eojeol), so a Hangul run is a word
+# like a Latin one -- broken at its spaces, and cut inside only by _slice_atom's escape hatch.
+# Per-character atoms broke `시작|합니다` and, once a pass moved the break, joined the halves
+# with no space (`늦지마세요`) while the result said text_unchanged.
+NO_SPACE_SCRIPTS = ("ja", "zh")
 NO_BOUNDARY_SCRIPTS = ("th",)   # per-character breaking would chop words: keep the run whole
 
 
@@ -304,9 +308,11 @@ def _join(left: str, atom: str, spaced: bool) -> str:
 
 
 def _break_spaced(first: str, second: str) -> bool:
-    """Did a space stand at the break between these two wrapped lines? Only spaced scripts put one
-    there -- a CJK/Thai break sits between two characters that were written with nothing between
-    them, and re-joining them with a space would insert a character the cue never had."""
+    """A guess at whether a space stood at the break between these two wrapped lines, from the
+    scripts on each side. The wrapper's own passes do not use it: the greedy fill records the real
+    answer per break (`gaps`) and every pass carries it along, because a script cannot tell -- a
+    Japanese cue written with spaces (`はい そうです`) lost one whenever a pass moved a break that
+    stood at a space. Kept as the fallback for a caller that has only the two strings."""
     if not first or not second:
         return False
     return char_script(first[-1]) not in NO_SPACE_SCRIPTS and char_script(second[0]) not in NO_SPACE_SCRIPTS \
@@ -477,7 +483,18 @@ def best_break(atoms: "Sequence[Tuple[str, bool]]", max_em: float,
     return None if best is None else best[1]
 
 
-def _fix_orphans(lines: "List[str]", max_em: float) -> "List[str]":
+def _gaps(lines: "List[str]", gaps: "Optional[List[bool]]") -> "List[bool]":
+    """The per-break space flags a pass reads and updates: the caller's list (updated in place, so
+    the next pass sees the moved breaks), or the _break_spaced() guess when the caller has none."""
+    if gaps is None:
+        return [_break_spaced(a, b) for a, b in zip(lines, lines[1:])]
+    if len(gaps) != max(len(lines) - 1, 0):
+        raise ValueError("gaps must hold one flag per break")
+    return gaps
+
+
+def _fix_orphans(lines: "List[str]", max_em: float,
+                 gaps: "Optional[List[bool]]" = None) -> "List[str]":
     """No last line that is a single stranded atom.
 
     Greedy wrapping leaves one character alone whenever the line before it filled exactly: eval 14
@@ -486,6 +503,7 @@ def _fix_orphans(lines: "List[str]", max_em: float) -> "List[str]":
     onto it -- but only while the result still fits and the line above does not become an orphan
     itself, so a two-word cue is never made worse."""
     lines = list(lines)
+    gaps = _gaps(lines, gaps)
     for _ in range(len(lines)):
         if len(lines) < 2:
             break
@@ -499,14 +517,16 @@ def _fix_orphans(lines: "List[str]", max_em: float) -> "List[str]":
         new_prev = ""
         for atom, sp in prev[:-1]:
             new_prev = _join(new_prev, atom, sp)
-        new_last = _join(moved, tail[0][0], _break_spaced(lines[-2], lines[-1]))
+        new_last = _join(moved, tail[0][0], gaps[-1])
         if text_width_em(new_last) > max_em or text_width_em(new_prev) < ORPHAN_MIN_EM:
             break
         lines[-2], lines[-1] = new_prev, new_last
+        gaps[-1] = spaced
     return lines
 
 
-def _fix_weak_lines(lines: "List[str]", max_em: float) -> "List[str]":
+def _fix_weak_lines(lines: "List[str]", max_em: float,
+                    gaps: "Optional[List[bool]]" = None) -> "List[str]":
     """R2, generalised: _fix_orphans run at *every* boundary, against _is_weak_line.
 
     1.15 only ever looked at the last line, so a stranded digit or kana in the middle of a
@@ -514,6 +534,7 @@ def _fix_weak_lines(lines: "List[str]", max_em: float) -> "List[str]":
     of the line above moves down onto it -- with 1.15's two guards intact (the result must still
     fit, and the line above must not itself become weak), so the line count never changes."""
     lines = list(lines)
+    gaps = _gaps(lines, gaps)
     for i in range(len(lines) - 1, 0, -1):
         for _ in range(len(lines)):
             if not _is_weak_line(lines[i]):
@@ -521,19 +542,21 @@ def _fix_weak_lines(lines: "List[str]", max_em: float) -> "List[str]":
             prev = _atoms(lines[i - 1])
             if len(prev) < 2:
                 break
-            moved, _spaced = prev[-1]
+            moved, spaced = prev[-1]
             new_prev = ""
             for atom, sp in prev[:-1]:
                 new_prev = _join(new_prev, atom, sp)
-            new_last = _join(moved, lines[i], _break_spaced(lines[i - 1], lines[i]))
+            new_last = _join(moved, lines[i], gaps[i - 1])
             if text_width_em(new_last) > max_em or _is_weak_line(new_prev) \
                     or text_width_em(new_prev) < ORPHAN_MIN_EM:
                 break
             lines[i - 1], lines[i] = new_prev, new_last
+            gaps[i - 1] = spaced
     return lines
 
 
-def _rebalance(lines: "List[str]", max_em: float) -> "List[str]":
+def _rebalance(lines: "List[str]", max_em: float,
+               gaps: "Optional[List[bool]]" = None) -> "List[str]":
     """Move each break to the one that minimises the widest line of the pair, without changing the
     line count.
 
@@ -544,11 +567,12 @@ def _rebalance(lines: "List[str]", max_em: float) -> "List[str]":
     if len(lines) < 2:
         return lines
     out = list(lines)
+    gaps = _gaps(out, gaps)
     for i in range(len(out) - 1):
         first, second = out[i], out[i + 1]
         tail_atoms = _atoms(second)
         if tail_atoms:
-            tail_atoms[0] = (tail_atoms[0][0], _break_spaced(first, second))
+            tail_atoms[0] = (tail_atoms[0][0], gaps[i])
         atoms = _atoms(first) + tail_atoms
         if not atoms or any(char_script(ch) in NO_SPACE_SCRIPTS for ch in first + second):
             continue
@@ -568,13 +592,15 @@ def _rebalance(lines: "List[str]", max_em: float) -> "List[str]":
                 continue
             key = (max(wa, wb), abs(wa - wb))
             if best is None or key < best[0]:
-                best = (key, a, b)
+                best = (key, a, b, atoms[cut][1])
         if best is not None:
             out[i], out[i + 1] = best[1], best[2]
+            gaps[i] = best[3]
     return out
 
 
-def _rebalance_phrase(lines: "List[str]", max_em: float, lang: "Optional[str]") -> "Tuple[List[str], int]":
+def _rebalance_phrase(lines: "List[str]", max_em: float, lang: "Optional[str]",
+                      gaps: "Optional[List[bool]]" = None) -> "Tuple[List[str], int]":
     """_rebalance with R1-R4 deciding, for every script rather than spaced ones only.
 
     Returns the new lines and how many breaks a phrase rule moved away from the position 1.15's
@@ -582,12 +608,13 @@ def _rebalance_phrase(lines: "List[str]", max_em: float, lang: "Optional[str]")
     if len(lines) < 2:
         return list(lines), 0
     out = list(lines)
+    gaps = _gaps(out, gaps)
     moved = 0
     for i in range(len(out) - 1):
         first, second = out[i], out[i + 1]
         tail_atoms = _atoms(second)
         if tail_atoms:
-            tail_atoms[0] = (tail_atoms[0][0], _break_spaced(first, second))
+            tail_atoms[0] = (tail_atoms[0][0], gaps[i])
         atoms = _split_hyphens(_atoms(first) + tail_atoms)
         if len(atoms) < 2:
             continue
@@ -602,11 +629,13 @@ def _rebalance_phrase(lines: "List[str]", max_em: float, lang: "Optional[str]")
         if (a, b) != (first, second):
             moved += 1
         out[i], out[i + 1] = a, b
+        gaps[i] = atoms[cut][1]
     return out, moved
 
 
 def _greedy_chunks(raw: str, max_em: float, *, slice_overlong: bool = False,
-                   sliced: "Optional[List[int]]" = None) -> "List[str]":
+                   sliced: "Optional[List[int]]" = None,
+                   gaps: "Optional[List[bool]]" = None) -> "List[str]":
     """The greedy fill on its own: the line count every mode must keep.
 
     `slice_overlong` (off by default -- only caption.py's final burn-in pass turns it on, never
@@ -615,47 +644,65 @@ def _greedy_chunks(raw: str, max_em: float, *, slice_overlong: bool = False,
     katakana run that already fits is completely untouched -- is hard-sliced by _slice_atom()
     instead of kept whole. `sliced`, when given, gets one entry (the number of extra lines that
     one atom produced) per atom actually sliced, which is how the caller counts
-    `broken_inside_word` without re-deriving it from the output lines."""
+    `broken_inside_word` without re-deriving it from the output lines.
+
+    `gaps`, when given, is filled with one flag per break: did a space stand there in `raw`? The
+    passes in _balance() carry it, so a break they move keeps (or drops) exactly that space."""
     current = ""
+    current_gap = False   # did a space stand before `current`'s first atom
     chunk: "List[str]" = []
-    for atom, spaced in _atoms(raw):
-        if slice_overlong and not current and text_width_em(atom) > max_em:
+    breaks: "List[bool]" = []
+
+    def emit(line: str, gap_before: bool) -> None:
+        if chunk:
+            breaks.append(gap_before)
+        chunk.append(line)
+
+    def start_line(atom: str, spaced: bool) -> "Tuple[str, bool]":
+        """The new current line opening with `atom`, sliced first when it is too wide alone."""
+        if slice_overlong and text_width_em(atom) > max_em:
             pieces = _slice_atom(atom, max_em)
             if sliced is not None and len(pieces) > 1:
                 sliced.append(len(pieces) - 1)
-            chunk.extend(pieces[:-1])
-            current = pieces[-1]
+            if len(pieces) > 1:
+                emit(pieces[0], spaced)
+                for piece in pieces[1:-1]:
+                    emit(piece, False)
+                return pieces[-1], False
+        return atom, spaced
+
+    for atom, spaced in _atoms(raw):
+        if not current:
+            current, current_gap = start_line(atom, spaced)
             continue
         candidate = _join(current, atom, spaced)
-        if current and text_width_em(candidate) > max_em:
-            chunk.append(current)
-            if slice_overlong and text_width_em(atom) > max_em:
-                pieces = _slice_atom(atom, max_em)
-                if sliced is not None and len(pieces) > 1:
-                    sliced.append(len(pieces) - 1)
-                chunk.extend(pieces[:-1])
-                current = pieces[-1]
-            else:
-                current = atom
+        if text_width_em(candidate) > max_em:
+            emit(current, current_gap)
+            current, current_gap = start_line(atom, spaced)
         else:
             current = candidate
     if current:
-        chunk.append(current)
+        emit(current, current_gap)
+    if gaps is not None:
+        gaps[:] = breaks
     return chunk
 
 
-def _balance(chunk: "List[str]", max_em: float, mode: str, lang: "Optional[str]") -> "List[str]":
+def _balance(chunk: "List[str]", max_em: float, mode: str, lang: "Optional[str]",
+             gaps: "Optional[List[bool]]" = None) -> "List[str]":
     """The post-passes for one greedy chunk, in the mode's own order. Never changes the count:
     a pass that would is discarded, exactly as 1.15 did."""
     if len(chunk) < 2:
         return chunk
+    gaps = list(gaps) if gaps is not None else None
     if mode == "measured":
-        fixed = _fix_orphans(chunk, max_em)
-        rebalanced = _rebalance(fixed, max_em)
+        fixed = _fix_orphans(chunk, max_em, gaps)
+        rebalanced = _rebalance(fixed, max_em, list(gaps) if gaps is not None else None)
     else:
-        fixed = _fix_weak_lines(_fix_orphans(chunk, max_em), max_em)
-        rebalanced, _moved = _rebalance_phrase(fixed, max_em, lang)
-        rebalanced = _fix_weak_lines(rebalanced, max_em)
+        fixed = _fix_weak_lines(_fix_orphans(chunk, max_em, gaps), max_em, gaps)
+        later = list(gaps) if gaps is not None else None
+        rebalanced, _moved = _rebalance_phrase(fixed, max_em, lang, later)
+        rebalanced = _fix_weak_lines(rebalanced, max_em, later)
     if len(rebalanced) == len(chunk):
         return rebalanced
     return fixed if len(fixed) == len(chunk) else chunk
@@ -681,8 +728,9 @@ def wrap_text(text: str, max_em: float, *, balance: bool = True, mode: str = "ph
     for raw in text.split("\n"):
         if not raw.strip():
             continue
-        chunk = _greedy_chunks(raw, max_em, slice_overlong=slice_overlong, sliced=sliced)
-        lines.extend(_balance(chunk, max_em, mode, lang) if balance else chunk)
+        gaps: "List[bool]" = []
+        chunk = _greedy_chunks(raw, max_em, slice_overlong=slice_overlong, sliced=sliced, gaps=gaps)
+        lines.extend(_balance(chunk, max_em, mode, lang, gaps) if balance else chunk)
     return lines or [text]
 def wrap_variants(text: str, max_em: float, *, mode: str = "phrase",
                   lang: "Optional[str]" = None, slice_overlong: bool = False,
@@ -701,10 +749,12 @@ def wrap_variants(text: str, max_em: float, *, mode: str = "phrase",
     for raw in text.split("\n"):
         if not raw.strip():
             continue
-        chunk = _greedy_chunks(raw, max_em, slice_overlong=slice_overlong, sliced=sliced)
+        gaps: "List[bool]" = []
+        chunk = _greedy_chunks(raw, max_em, slice_overlong=slice_overlong, sliced=sliced, gaps=gaps)
         greedy.extend(chunk)
-        wrapped.extend(_balance(list(chunk), max_em, mode, lang))
-        measured.extend(chunk if mode == "measured" else _balance(list(chunk), max_em, "measured", None))
+        wrapped.extend(_balance(list(chunk), max_em, mode, lang, gaps))
+        measured.extend(chunk if mode == "measured"
+                        else _balance(list(chunk), max_em, "measured", None, gaps))
     if not greedy:
         greedy = [text]
     return (wrapped or [text], greedy, measured or [text])