slidesync 0.4.0__tar.gz → 0.5.0__tar.gz

{slidesync-0.4.0/slidesync.egg-info → slidesync-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slidesync
-Version: 0.4.0
+Version: 0.5.0
 Summary: Bidirectional sync between a Slidev markdown deck and Google Slides as native, editable objects
 Author-email: Daniel Hails <slidesync@hails.info>
 License: MIT
@@ -22,7 +22,7 @@ Bidirectional sync between a [Slidev](https://sli.dev) markdown deck and **Googl
 Slides** — as native, editable objects (title/body/bullets/tables/positioned
 images, brand-styled text boxes), not pasted screenshots.
 
-Version: 0.4.0
+Version: 0.5.0
 
 ```bash
 uvx slidesync --help            # run without installing
@@ -58,17 +58,25 @@ Support path.)
 
 | Command | Purpose |
 |---------|---------|
-| `slidesync push <file.slidev.md> [--deck ID] [--new "Title"] [--anchor SLIDE] [--prune] [--force]` | markdown → Slides (rejected if it would discard live edits; `--force` overrides) |
+| `slidesync push <file.slidev.md>... [--deck ID] [--new "Title"] [--anchor SLIDE] [--prune] [--force]` | markdown → Slides (rejected if it would discard live edits; `--force` overrides) |
 | `slidesync pull <deckId> --out <file.md> [--all]` | Slides → markdown (`--all` includes non-managed slides) |
 | `slidesync roundtrip [--keep]` | self-test: push a sample, pull, assert identical |
 | `slidesync layouts <deckId>` | list a deck's theme layouts + placeholders |
 | `slidesync make-templates <deckId>` | inject branded `{{token}}` template slides |
 | `slidesync comments <deckId>` | list comment threads as JSON (page anchor, author, content, replies) |
-| `slidesync sync <file.slidev.md> [--deck ID]` | reconcile with the live deck: pull comments + live edits into the markdown, push local changes; conflicts stop it (exit 1) |
+| `slidesync sync <file.slidev.md>... [--deck ID] [--prune]` | reconcile with the live deck: pull comments + live edits into the markdown, push local changes; conflicts stop it (exit 1) |
 
 `push` resolves the target deck from (in order) `--deck`, `--new`, or a top-level
-`deck:` frontmatter key. Relative image paths resolve against the markdown file's
-directory.
+`deck:` frontmatter key. Relative image paths resolve against each slide's own
+source file.
+
+**Multi-file decks**: `push`/`sync` accept several files (e.g.
+`slidesync sync $(ls -r meetings/*.slidev.md)` — one file per meeting, newest
+first). Deck order follows the argument order; slide ids namespace as
+`<file-stem>-<id>` (`2026-06-15-overview`) so files can reuse ids; intra-file
+`[text](#id)` links rewrite to the namespaced target, while fully-qualified
+cross-file targets pass through. `sync` routes comment capture and live-edit
+write-backs into the right source file under its local id.
 
 ```bash
 slidesync push deck.slidev.md            # targets `deck:` frontmatter

{slidesync-0.4.0 → slidesync-0.5.0}/README.md

@@ -4,7 +4,7 @@ Bidirectional sync between a [Slidev](https://sli.dev) markdown deck and **Googl
 Slides** — as native, editable objects (title/body/bullets/tables/positioned
 images, brand-styled text boxes), not pasted screenshots.
 
-Version: 0.4.0
+Version: 0.5.0
 
 ```bash
 uvx slidesync --help            # run without installing
@@ -40,17 +40,25 @@ Support path.)
 
 | Command | Purpose |
 |---------|---------|
-| `slidesync push <file.slidev.md> [--deck ID] [--new "Title"] [--anchor SLIDE] [--prune] [--force]` | markdown → Slides (rejected if it would discard live edits; `--force` overrides) |
+| `slidesync push <file.slidev.md>... [--deck ID] [--new "Title"] [--anchor SLIDE] [--prune] [--force]` | markdown → Slides (rejected if it would discard live edits; `--force` overrides) |
 | `slidesync pull <deckId> --out <file.md> [--all]` | Slides → markdown (`--all` includes non-managed slides) |
 | `slidesync roundtrip [--keep]` | self-test: push a sample, pull, assert identical |
 | `slidesync layouts <deckId>` | list a deck's theme layouts + placeholders |
 | `slidesync make-templates <deckId>` | inject branded `{{token}}` template slides |
 | `slidesync comments <deckId>` | list comment threads as JSON (page anchor, author, content, replies) |
-| `slidesync sync <file.slidev.md> [--deck ID]` | reconcile with the live deck: pull comments + live edits into the markdown, push local changes; conflicts stop it (exit 1) |
+| `slidesync sync <file.slidev.md>... [--deck ID] [--prune]` | reconcile with the live deck: pull comments + live edits into the markdown, push local changes; conflicts stop it (exit 1) |
 
 `push` resolves the target deck from (in order) `--deck`, `--new`, or a top-level
-`deck:` frontmatter key. Relative image paths resolve against the markdown file's
-directory.
+`deck:` frontmatter key. Relative image paths resolve against each slide's own
+source file.
+
+**Multi-file decks**: `push`/`sync` accept several files (e.g.
+`slidesync sync $(ls -r meetings/*.slidev.md)` — one file per meeting, newest
+first). Deck order follows the argument order; slide ids namespace as
+`<file-stem>-<id>` (`2026-06-15-overview`) so files can reuse ids; intra-file
+`[text](#id)` links rewrite to the namespaced target, while fully-qualified
+cross-file targets pass through. `sync` routes comment capture and live-edit
+write-backs into the right source file under its local id.
 
 ```bash
 slidesync push deck.slidev.md            # targets `deck:` frontmatter

{slidesync-0.4.0 → slidesync-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "slidesync"
-version = "0.4.0"
+version = "0.5.0"
 authors = [
     { name = "Daniel Hails", email = "slidesync@hails.info" },
 ]
@@ -32,7 +32,7 @@ include = ["slidesync*"]
 dev = ["pytest>=8"]
 
 [tool.bumpver]
-current_version = "0.4.0"
+current_version = "0.5.0"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 commit = true

{slidesync-0.4.0 → slidesync-0.5.0}/slidesync/__init__.py

@@ -30,7 +30,7 @@ from slidesync._sync import (
     write_slidev,
 )
 
-__version__ = "0.4.0"
+__version__ = "0.5.0"
 
 __all__ = [
     "Para",

{slidesync-0.4.0 → slidesync-0.5.0}/slidesync/_sync.py

@@ -195,6 +195,8 @@ class Slide:
     custom: str | None = None  # ```gslides``` literal Slides API requests (JSON)
     verbatim: str | None = None  # ``` ``` fenced body for prompt/code slides
     src: str | None = None  # body markdown as authored (comments in place)
+    src_path: Path | None = None  # source file this slide was loaded from
+    src_key: str = ""  # id as written in that file (un-namespaced)
     key_hash: str = ""
     content_hash: str = ""
     object_id: str = ""
@@ -254,6 +256,55 @@ def load_slides(path: Path) -> list[Slide]:
     return build_slides(split_slides(path.read_text()))
 
 
+LOCAL_LINK_RE = re.compile(
+    r"""(?x)
+    \]\(\#              # close of [text], open of (#...
+    (?P<target>[\w-]+)  # the slide id being linked to
+    \)                  # close paren
+    """
+)
+
+
+def load_deck(paths: list[Path]) -> list[Slide]:
+    """Load one or many source files into a single slide list.
+
+    With several files (e.g. `slidesync sync meetings/*.slidev.md`, one file per
+    meeting), deck order follows the argument order and every slide id is
+    namespaced with its file's stem (`2026-06-15-overview`) so files can reuse
+    ids without colliding. Intra-file `[text](#id)` links are rewritten to the
+    namespaced target; already-qualified cross-file links pass through. Each
+    slide remembers its origin (`src_path`/`src_key`) so `sync` writes captures
+    and live edits back into the right file. Duplicate keys are an error.
+    """
+    if len(paths) == 1:
+        slides = load_slides(paths[0])
+        for s in slides:
+            s.src_path, s.src_key = paths[0], s.key
+    else:
+        slides = []
+        for path in paths:
+            prefix = path.name.split(".")[0]
+            chunks = split_slides(path.read_text())
+            local = {m.get("id") or f"slide{i}" for i, (m, _b) in enumerate(chunks)}
+
+            def relink(m, prefix=prefix, local=local):
+                t = m.group("target")
+                return f"](#{prefix}-{t})" if t in local else m.group(0)
+
+            for i, (meta, body) in enumerate(chunks):
+                src_key = meta.get("id") or f"slide{i}"
+                meta = {**meta, "id": f"{prefix}-{src_key}"}
+                slide = build_slide(meta, LOCAL_LINK_RE.sub(relink, body), i)
+                slide.src_path, slide.src_key = path, src_key
+                slides.append(slide)
+    seen, dupes = set(), set()
+    for s in slides:
+        (dupes if s.key in seen else seen).add(s.key)
+    if dupes:
+        sys.exit(f"duplicate slide ids across sources: {sorted(dupes)}")
+    return slides
+
+
 def split_slides(text: str) -> list[tuple[dict, str]]:
     post = frontmatter.loads(text)
     chunks = re.split(r"(?m)^---[ \t]*$", post.content)
@@ -1227,7 +1278,9 @@ def _resolve_image(drive, slide: Slide, base_dir=Path(".")):
         return None, None
     p = Path(slide.image)
     if not p.is_absolute():
-        p = base_dir / p
+        # Relative to the slide's own source file (multi-file decks), else the
+        # caller's base directory.
+        p = (slide.src_path.parent if slide.src_path else base_dir) / p
     if not p.exists():
         logger.warning(f"image not found, graphic skipped: {p}")
         return None, None
@@ -1865,18 +1918,33 @@ def deck_from_source(path: Path) -> str | None:
     return m.group("id") if m else str(val)
 
 
+def _source_paths(args) -> list[Path]:
+    paths = args.source if isinstance(args.source, list) else [args.source]
+    return [Path(p) for p in paths]
+
+
+def _deck_of(args, paths: list[Path]) -> str | None:
+    if args.deck:
+        return args.deck
+    for p in paths:
+        if d := deck_from_source(p):
+            return d
+    return None
+
+
 def cmd_push(args):
-    source = load_slides(args.source)
-    logger.info(f"parsed {len(source)} slides from {args.source}")
+    paths = _source_paths(args)
+    source = load_deck(paths)
+    logger.info(f"parsed {len(source)} slides from {len(paths)} file(s)")
     slides_api, drive = get_services(args.account)
-    deck = args.deck or deck_from_source(args.source)
+    deck = _deck_of(args, paths)
     if args.new:
         deck = new_deck(slides_api, args.new)
         logger.info(f"created https://docs.google.com/presentation/d/{deck}/edit")
     if not deck:
         sys.exit("no target deck: pass --deck/--new or add `deck:` frontmatter")
     stats = push(slides_api, drive, deck, source, args.anchor, args.prune,
-                 base_dir=args.source.parent, force=args.force)
+                 base_dir=paths[0].parent, force=args.force)
     logger.success(f"{stats} -> https://docs.google.com/presentation/d/{deck}/edit")
 
 
@@ -2015,6 +2083,20 @@ def _diff(a: list[str], b: list[str], a_name: str, b_name: str) -> str:
     return "\n".join(difflib.unified_diff(a, b, a_name, b_name, lineterm=""))
 
 
+def _content_lines(src: str | None, template: str | None) -> list[str] | None:
+    """Markdown text lines as they would actually RENDER for this template.
+
+    graph/full slides are text-free (only the image renders), so markdown body
+    text on them can never reach the deck — comparing it against the live slide
+    would report drift forever.
+    """
+    if src is None:
+        return None
+    if (template or "").lower() in ("graph", "full"):
+        return []
+    return text_lines_md(src)
+
+
 def _live_state(s) -> tuple[list[str], str, str | None, dict]:
     """(text lines, normalised notes, base source, marker) of a live slide."""
     notes_raw = _read_notes(s)
@@ -2040,13 +2122,14 @@ def _clobber_risks(pres, managed, source, pruned) -> list[str]:
         replacing = sl is not None and sl.custom is None and sl.object_id != oid
         if not (replacing or oid in pruned) or live.get(oid) is None:
             continue
-        live_lines, live_notes, base_src, _marker_ = _live_state(live[oid])
+        live_lines, live_notes, base_src, marker = _live_state(live[oid])
         if base_src is None:
             continue
-        if (live_lines == text_lines_md(base_src)
+        if (live_lines == _content_lines(base_src, marker.get("template"))
                 and live_notes == " ".join(_extract_notes(base_src).split())):
             continue  # deck untouched since last push
-        if (sl is not None and live_lines == text_lines_md(sl.src or "")
+        if (sl is not None
+                and live_lines == _content_lines(sl.src or "", sl.template_name)
                 and live_notes == " ".join((sl.notes or "").split())):
             continue  # local already carries the live edit
         out.append(sl.key if sl is not None else oid)
@@ -2136,9 +2219,9 @@ def cmd_sync(args):
     conflicts remain.
     """
     slides_api, drive = get_services(args.account)
-    path = args.source
-    source = load_slides(path)
-    deck = args.deck or deck_from_source(path)
+    paths = _source_paths(args)
+    source = load_deck(paths)
+    deck = _deck_of(args, paths)
     if not deck:
         sys.exit("no target deck: pass --deck or add `deck:` frontmatter")
     pres = slides_api.presentations().get(presentationId=deck).execute()
@@ -2149,37 +2232,56 @@ def cmd_sync(args):
         if not c["resolved"] and c["page"]:
             by_page.setdefault(c["page"], []).append(c)
 
-    state = {"text": path.read_text(), "dirty": False, "pushable": False}
-    key_by_kh = {sl.key_hash: sl.key for sl in source}
+    texts = {p: p.read_text() for p in paths}
+    state = {"dirty": set(), "pushable": False}
+    origin_by_kh = {sl.key_hash: (sl.src_path, sl.src_key) for sl in source}
 
-    def capture(key: str | None, c: dict, page: str) -> None:
+    def capture(origin: tuple[Path, str] | None, c: dict, page: str) -> None:
         lines = [f"@{c['author']}: {c['content']}"]
         lines += [f"@{r['author']}: {r['content']}" for r in c["replies"]]
         block = "<!-- " + "\n".join(lines) + " -->"
-        if " ".join(c["content"].split()) in " ".join(state["text"].split()):
+        path, key = origin if origin else (None, None)
+        if path and " ".join(c["content"].split()) in " ".join(texts[path].split()):
             return  # already captured
-        new = _append_to_slide_body(state["text"], key, block) if key else state["text"]
-        if new != state["text"]:
-            state.update(text=new, dirty=True, pushable=True)
-            logger.info(f"[comment   ] {key} — captured thread by {c['author']}")
+        new = _append_to_slide_body(texts[path], key, block) if path else None
+        if new is not None and new != texts[path]:
+            texts[path] = new
+            state["dirty"].add(path)
+            state["pushable"] = True
+            logger.info(f"[comment   ] {key} — captured thread by {c['author']} "
+                        f"-> {path.name}")
         else:
             logger.warning(f"[comment   ] thread by {c['author']} on {key or page} "
                            f"couldn't be placed; paste manually:\n{block}")
 
     conflicts = []
     for sl in source:
+        origin = (sl.src_path, sl.src_key)
         s = live.pop(sl.key_hash, None)
         if s is None:
             logger.info(f"[missing   ] {sl.key} — push will create it")
             state["pushable"] = True
             continue
         for c in by_page.pop(s["objectId"], []):
-            capture(sl.key, c, s["objectId"])
+            capture(origin, c, s["objectId"])
         if sl.custom is not None:
-            continue  # pull-authoritative; drawings are captured by pull, not diffed
+            # Pull-authoritative: refresh the ```gslides``` block from the live
+            # drawing so hand-drawn edits land back in the source file.
+            marker = _read_marker(_read_notes(s))
+            live_json = (_custom_slide_from_native(s, marker, "").custom
+                         if "id" in marker else None)
+            if live_json and live_json.strip() != (sl.custom or "").strip():
+                new = texts[sl.src_path].replace(sl.custom, live_json, 1)
+                if new != texts[sl.src_path]:
+                    texts[sl.src_path] = new
+                    state["dirty"].add(sl.src_path)
+                    logger.info(f"[drawing   ] {sl.key} — captured live drawing "
+                                f"-> {sl.src_path.name}")
+            continue
         live_lines, live_notes, base_src, marker = _live_state(s)
-        base = text_lines_md(base_src) if base_src is not None else None
-        status = classify_drift(base, text_lines_md(sl.src or ""), live_lines)
+        base = _content_lines(base_src, marker.get("template"))
+        local = _content_lines(sl.src or "", sl.template_name) or []
+        status = classify_drift(base, local, live_lines)
         if status in ("clean", "converged"):
             continue
         if status == "local-edit":
@@ -2191,10 +2293,14 @@ def cmd_sync(args):
                    and marker.get("template") else None)
         if rebuilt and (rebuilt.title or rebuilt.paras or rebuilt.verbatim):
             rebuilt.notes = " ".join(MARKER_RE.sub("", _read_notes(s)).split())
-            new = _replace_slide_body(state["text"], sl.key, _render_body(rebuilt))
-            if new != state["text"]:
-                state.update(text=new, dirty=True, pushable=True)
-                logger.info(f"[pulled    ] {sl.key} — live edit written back")
+            new = _replace_slide_body(texts[sl.src_path], sl.src_key,
+                                      _render_body(rebuilt))
+            if new != texts[sl.src_path]:
+                texts[sl.src_path] = new
+                state["dirty"].add(sl.src_path)
+                state["pushable"] = True
+                logger.info(f"[pulled    ] {sl.key} — live edit written back "
+                            f"-> {sl.src_path.name}")
                 continue
         conflicts.append(sl.key)
         logger.error(f"[conflict  ] {sl.key} (pushed {marker.get('at', '?')}) — "
@@ -2204,22 +2310,22 @@ def cmd_sync(args):
                      + _diff(base or [], live_lines, "last-pushed", "live"))
     for page, cs in by_page.items():  # threads on re-rendered (deleted) pages
         m = re.match(r"s2g_(?P<kh>[0-9a-f]{10})_", page)
-        key = key_by_kh.get(m.group("kh")) if m else None
+        origin = origin_by_kh.get(m.group("kh")) if m else None
         for c in cs:
-            capture(key, c, page)
+            capture(origin, c, page)
     for _kh, s in live.items():
         logger.warning(f"[unmanaged ] {s['objectId']} has no local slide "
                        "(push --prune would delete it)")
 
-    if state["dirty"]:
-        path.write_text(state["text"])
-        logger.success(f"updated {path}")
+    for p in sorted(state["dirty"]):
+        p.write_text(texts[p])
+        logger.success(f"updated {p}")
     if conflicts:
         sys.exit(f"sync stopped: {len(conflicts)} conflict(s) above — resolve in "
                  "the markdown, then `slidesync push` (its guard protects the rest).")
     if state["pushable"]:
-        stats = push(slides_api, drive, deck, load_slides(path), anchor=None,
-                     prune=False, base_dir=path.parent)
+        stats = push(slides_api, drive, deck, load_deck(paths), anchor=None,
+                     prune=args.prune, base_dir=paths[0].parent)
         logger.success(f"{stats} -> "
                        f"https://docs.google.com/presentation/d/{deck}/edit")
     else:
@@ -2279,7 +2385,9 @@ def main():
     sub = ap.add_subparsers(dest="cmd", required=True)
 
     p = sub.add_parser("push")
-    p.add_argument("source", type=Path)
+    p.add_argument("source", type=Path, nargs="+",
+                   help="one or more .slidev.md files; several files merge into "
+                        "one deck with ids namespaced by file stem")
     p.add_argument("--deck")
     p.add_argument("--new")
     p.add_argument("--anchor")
@@ -2308,9 +2416,12 @@ def main():
     p.set_defaults(func=cmd_comments)
 
     p = sub.add_parser("sync",
-                       help="report drift vs the live deck (comments, live edits, conflicts)")
-    p.add_argument("source", type=Path)
+                       help="reconcile with the live deck (comments, live edits, conflicts)")
+    p.add_argument("source", type=Path, nargs="+",
+                   help="one or more .slidev.md files (ids namespaced by stem when several)")
     p.add_argument("--deck")
+    p.add_argument("--prune", action="store_true",
+                   help="the final push deletes managed slides missing from the sources")
     p.set_defaults(func=cmd_sync)
 
     p = sub.add_parser("make-templates",

{slidesync-0.4.0 → slidesync-0.5.0/slidesync.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slidesync
-Version: 0.4.0
+Version: 0.5.0
 Summary: Bidirectional sync between a Slidev markdown deck and Google Slides as native, editable objects
 Author-email: Daniel Hails <slidesync@hails.info>
 License: MIT
@@ -22,7 +22,7 @@ Bidirectional sync between a [Slidev](https://sli.dev) markdown deck and **Googl
 Slides** — as native, editable objects (title/body/bullets/tables/positioned
 images, brand-styled text boxes), not pasted screenshots.
 
-Version: 0.4.0
+Version: 0.5.0
 
 ```bash
 uvx slidesync --help            # run without installing
@@ -58,17 +58,25 @@ Support path.)
 
 | Command | Purpose |
 |---------|---------|
-| `slidesync push <file.slidev.md> [--deck ID] [--new "Title"] [--anchor SLIDE] [--prune] [--force]` | markdown → Slides (rejected if it would discard live edits; `--force` overrides) |
+| `slidesync push <file.slidev.md>... [--deck ID] [--new "Title"] [--anchor SLIDE] [--prune] [--force]` | markdown → Slides (rejected if it would discard live edits; `--force` overrides) |
 | `slidesync pull <deckId> --out <file.md> [--all]` | Slides → markdown (`--all` includes non-managed slides) |
 | `slidesync roundtrip [--keep]` | self-test: push a sample, pull, assert identical |
 | `slidesync layouts <deckId>` | list a deck's theme layouts + placeholders |
 | `slidesync make-templates <deckId>` | inject branded `{{token}}` template slides |
 | `slidesync comments <deckId>` | list comment threads as JSON (page anchor, author, content, replies) |
-| `slidesync sync <file.slidev.md> [--deck ID]` | reconcile with the live deck: pull comments + live edits into the markdown, push local changes; conflicts stop it (exit 1) |
+| `slidesync sync <file.slidev.md>... [--deck ID] [--prune]` | reconcile with the live deck: pull comments + live edits into the markdown, push local changes; conflicts stop it (exit 1) |
 
 `push` resolves the target deck from (in order) `--deck`, `--new`, or a top-level
-`deck:` frontmatter key. Relative image paths resolve against the markdown file's
-directory.
+`deck:` frontmatter key. Relative image paths resolve against each slide's own
+source file.
+
+**Multi-file decks**: `push`/`sync` accept several files (e.g.
+`slidesync sync $(ls -r meetings/*.slidev.md)` — one file per meeting, newest
+first). Deck order follows the argument order; slide ids namespace as
+`<file-stem>-<id>` (`2026-06-15-overview`) so files can reuse ids; intra-file
+`[text](#id)` links rewrite to the namespaced target, while fully-qualified
+cross-file targets pass through. `sync` routes comment capture and live-edit
+write-backs into the right source file under its local id.
 
 ```bash
 slidesync push deck.slidev.md            # targets `deck:` frontmatter

{slidesync-0.4.0 → slidesync-0.5.0}/tests/test_e2e_scenarios.py

@@ -13,7 +13,7 @@ from types import SimpleNamespace
 import pytest
 
 from slidesync import _sync
-from slidesync._sync import cmd_sync, load_slides, push
+from slidesync._sync import cmd_sync, load_deck, load_slides, push
 
 DECK = "fakedeck"
 
@@ -190,7 +190,7 @@ def env(tmp_path, monkeypatch):
 
 
 def _sync_cmd(env):
-    cmd_sync(SimpleNamespace(source=env.path, deck=DECK, account=None))
+    cmd_sync(SimpleNamespace(source=env.path, deck=DECK, account=None, prune=False))
 
 
 def _push(env, force=False, prune=False):
@@ -290,3 +290,132 @@ def test_sync_recaptures_orphaned_comment_via_key_hash(env):
     _push(env)  # re-render replaces the slide; the thread's page id now dangles
     _sync_cmd(env)
     assert "<!-- @Daniel Hails: anchored before the re-render -->" in env.path.read_text()
+
+
+GRAPH_MD = MD + """
+---
+template: graph
+id: fig-placeholder
+---
+![[Bracketed placeholder alt that defeats IMAGE_RE]](../figures/missing.png)
+
+<!-- caption comment -->
+"""
+
+
+def test_graph_slides_with_unrenderable_text_stay_clean(tmp_path, monkeypatch):
+    # A graph/full slide is text-free: body text in the markdown (e.g. an image
+    # line whose bracketed alt breaks IMAGE_RE) can never render, so it must
+    # not register as drift. Regression: the live probe flagged placeholder
+    # graph slides as live-drift forever.
+    store, drive = FakeStore(), FakeDrive()
+    slides_api = FakeSlides(store)
+    monkeypatch.setattr(_sync, "get_services", lambda account: (slides_api, drive))
+    path = tmp_path / "deck.slidev.md"
+    path.write_text(GRAPH_MD)
+    push(slides_api, drive, DECK, load_slides(path), anchor=None, prune=False,
+         base_dir=tmp_path)
+    before = path.read_text()
+    cmd_sync(SimpleNamespace(source=path, deck=DECK, account=None, prune=False))
+    assert path.read_text() == before  # no write-back, no conflict, no churn
+
+
+WEEK_A = """---
+theme: seriph
+---
+
+---
+template: topic
+id: thread-x
+---
+# Newer week takeaway
+## FINDING
+
+Newer point one.
+
+[appendix link](#thread-y)
+[cross week](#2026-06-01-thread-x)
+
+---
+---
+template: topic
+id: thread-y
+---
+# Newer week appendix
+## BACKUP
+
+Appendix detail.
+"""
+
+WEEK_B = """---
+theme: seriph
+---
+
+---
+template: topic
+id: thread-x
+---
+# Older week takeaway
+## FINDING
+
+Older point one.
+"""
+
+
+@pytest.fixture
+def multi(tmp_path, monkeypatch):
+    store, drive = FakeStore(), FakeDrive()
+    slides_api = FakeSlides(store)
+    monkeypatch.setattr(_sync, "get_services", lambda account: (slides_api, drive))
+    a = tmp_path / "2026-06-08.slidev.md"
+    b = tmp_path / "2026-06-01.slidev.md"
+    a.write_text(WEEK_A)
+    b.write_text(WEEK_B)
+    push(slides_api, drive, DECK, load_deck([a, b]), anchor=None, prune=False,
+         base_dir=tmp_path)
+    return SimpleNamespace(store=store, drive=drive, slides=slides_api, a=a, b=b)
+
+
+def _multi_sync(env):
+    cmd_sync(SimpleNamespace(source=[env.a, env.b], deck=DECK, account=None,
+                             prune=False))
+
+
+def test_multi_file_namespaces_ids_and_intra_file_links(multi):
+    slides = load_deck([multi.a, multi.b])
+    assert [s.key for s in slides] == ["2026-06-08-thread-x", "2026-06-08-thread-y",
+                                       "2026-06-01-thread-x"]
+    newer = slides[0]
+    links = [r.link for p in newer.paras for r in p.runs if r.style == "link"]
+    assert "#2026-06-08-thread-y" in links     # intra-file: namespaced
+    assert "#2026-06-01-thread-x" in links     # cross-file: already qualified
+    assert (newer.src_path, newer.src_key) == (multi.a, "thread-x")
+
+
+def test_multi_file_comment_capture_routes_to_origin_file(multi):
+    multi.drive.add(multi.store.oid_of("Older point one"), "comment on the old week")
+    _multi_sync(multi)
+    assert "<!-- @Daniel Hails: comment on the old week -->" in multi.b.read_text()
+    assert "comment on the old week" not in multi.a.read_text()
+
+
+def test_multi_file_live_drift_writes_back_to_origin_file(multi):
+    multi.store.edit_text("Older point one", "Older point one, live-edited")
+    _multi_sync(multi)
+    assert "live-edited" in multi.b.read_text()
+    assert "live-edited" not in multi.a.read_text()
+    # the source file keeps its LOCAL id, not the namespaced one
+    assert "id: thread-x" in multi.b.read_text()
+    assert "id: 2026-06-01-thread-x" not in multi.b.read_text()
+
+
+def test_duplicate_keys_across_files_are_rejected(tmp_path):
+    a = tmp_path / "same.slidev.md"
+    b = tmp_path / "same2.slidev.md"
+    a.write_text(WEEK_B)
+    b.write_text(WEEK_B.replace("same", "same"))
+    # same stem prefix collision: copy a file so namespaced keys collide
+    c = tmp_path / "same.copy.slidev.md"  # stem "same" again (split on first dot)
+    c.write_text(WEEK_B)
+    with pytest.raises(SystemExit):
+        load_deck([a, c])