slidesync 0.3.0__tar.gz → 0.4.1__tar.gz

{slidesync-0.3.0/slidesync.egg-info → slidesync-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slidesync
-Version: 0.3.0
+Version: 0.4.1
 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.3.0
+Version: 0.4.1
 
 ```bash
 uvx slidesync --help            # run without installing
@@ -58,13 +58,13 @@ Support path.)
 
 | Command | Purpose |
 |---------|---------|
-| `slidesync push <file.slidev.md> [--deck ID] [--new "Title"] [--anchor SLIDE] [--prune] [--force]` | markdown → Slides |
+| `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]` | report drift vs the live deck — comments, live edits, conflicts (exit 1 on drift) |
+| `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) |
 
 `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
@@ -89,24 +89,32 @@ hidden `<!-- s2g {...} -->` marker in speaker notes carries the human id, image
 path, template vars — and, for template slides, the authored body markdown
 (base64) — so `pull` recovers the source verbatim.
 
-## Sync & drift (detection, not resolution)
-
-The marker's last-pushed source is a true per-slide **merge base**, so `sync`
-classifies each slide three-way without timestamps (the Slides API has no
-per-slide edit times — only file-level `modifiedTime`; the marker's `at` stamp
-records when *we* last pushed each slide):
-
-| status | meaning | action |
-|--------|---------|--------|
-| `clean` / `converged` | nothing changed, or both sides made the same change | — |
-| `local-edit` | markdown changed, deck untouched | `push` (normal) |
-| `live-drift` | slide edited in Google Slides | fold the printed diff into the markdown, or `push --force` to clobber |
-| `conflict` | both changed since last push | resolve the two printed diffs by hand/LLM, then `push` |
-
-Unresolved comment threads print as ready-to-paste `<!-- @Author: text -->`
-blocks on their slide (replies as extra `@Author:` lines) — paste them into the
-source, where they round-trip from then on. Threads anchor to slide objectIds,
-so a re-render orphans them: `sync` reports those too. Capture before you push.
+## Sync & drift
+
+`push` is guarded like a non-fast-forward git push: if a slide it would replace
+(or prune) was edited in Google Slides since the last push — and the local
+markdown doesn't already carry that edit — the push is **rejected** with no
+changes made (`--force` overwrites). Live edits on slides the push wouldn't
+touch are left alone.
+
+`sync` reconciles the two sides, applying whatever is safe. The marker's
+last-pushed source is a true per-slide **merge base**, so each slide classifies
+three-way without timestamps (the APIs expose no per-slide edit times — only
+file-level `modifiedTime`; the marker's `at` stamp records our last push):
+
+| status | meaning | sync does |
+|--------|---------|-----------|
+| `clean` / `converged` | nothing changed, or both sides made the same change | nothing |
+| `local-edit` | markdown changed, deck untouched | pushes it |
+| `live-drift` | slide edited in Google Slides | writes the live content back into the markdown (reconstructed from its styled boxes, formatting runs included), then pushes |
+| `conflict` | both changed since last push | prints both diffs vs the base for a human/LLM to resolve; skips the push; exits 1 |
+
+Unresolved comment threads are appended to their slide as
+`<!-- @Author: text -->` blocks (replies as extra `@Author:` lines), and threads
+orphaned by a re-render are re-anchored to their slide via the objectId's
+key-hash. Captured text round-trips from then on. Write-back caveat: a slide
+edited live is rewritten canonically, so its authored comments collapse into
+one trailing block (untouched slides keep comments in place).
 
 ## Markdown dialect
 

{slidesync-0.3.0 → slidesync-0.4.1}/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.3.0
+Version: 0.4.1
 
 ```bash
 uvx slidesync --help            # run without installing
@@ -40,13 +40,13 @@ Support path.)
 
 | Command | Purpose |
 |---------|---------|
-| `slidesync push <file.slidev.md> [--deck ID] [--new "Title"] [--anchor SLIDE] [--prune] [--force]` | markdown → Slides |
+| `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]` | report drift vs the live deck — comments, live edits, conflicts (exit 1 on drift) |
+| `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) |
 
 `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
@@ -71,24 +71,32 @@ hidden `<!-- s2g {...} -->` marker in speaker notes carries the human id, image
 path, template vars — and, for template slides, the authored body markdown
 (base64) — so `pull` recovers the source verbatim.
 
-## Sync & drift (detection, not resolution)
-
-The marker's last-pushed source is a true per-slide **merge base**, so `sync`
-classifies each slide three-way without timestamps (the Slides API has no
-per-slide edit times — only file-level `modifiedTime`; the marker's `at` stamp
-records when *we* last pushed each slide):
-
-| status | meaning | action |
-|--------|---------|--------|
-| `clean` / `converged` | nothing changed, or both sides made the same change | — |
-| `local-edit` | markdown changed, deck untouched | `push` (normal) |
-| `live-drift` | slide edited in Google Slides | fold the printed diff into the markdown, or `push --force` to clobber |
-| `conflict` | both changed since last push | resolve the two printed diffs by hand/LLM, then `push` |
-
-Unresolved comment threads print as ready-to-paste `<!-- @Author: text -->`
-blocks on their slide (replies as extra `@Author:` lines) — paste them into the
-source, where they round-trip from then on. Threads anchor to slide objectIds,
-so a re-render orphans them: `sync` reports those too. Capture before you push.
+## Sync & drift
+
+`push` is guarded like a non-fast-forward git push: if a slide it would replace
+(or prune) was edited in Google Slides since the last push — and the local
+markdown doesn't already carry that edit — the push is **rejected** with no
+changes made (`--force` overwrites). Live edits on slides the push wouldn't
+touch are left alone.
+
+`sync` reconciles the two sides, applying whatever is safe. The marker's
+last-pushed source is a true per-slide **merge base**, so each slide classifies
+three-way without timestamps (the APIs expose no per-slide edit times — only
+file-level `modifiedTime`; the marker's `at` stamp records our last push):
+
+| status | meaning | sync does |
+|--------|---------|-----------|
+| `clean` / `converged` | nothing changed, or both sides made the same change | nothing |
+| `local-edit` | markdown changed, deck untouched | pushes it |
+| `live-drift` | slide edited in Google Slides | writes the live content back into the markdown (reconstructed from its styled boxes, formatting runs included), then pushes |
+| `conflict` | both changed since last push | prints both diffs vs the base for a human/LLM to resolve; skips the push; exits 1 |
+
+Unresolved comment threads are appended to their slide as
+`<!-- @Author: text -->` blocks (replies as extra `@Author:` lines), and threads
+orphaned by a re-render are re-anchored to their slide via the objectId's
+key-hash. Captured text round-trips from then on. Write-back caveat: a slide
+edited live is rewritten canonically, so its authored comments collapse into
+one trailing block (untouched slides keep comments in place).
 
 ## Markdown dialect
 

{slidesync-0.3.0 → slidesync-0.4.1}/pyproject.toml

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

{slidesync-0.3.0 → slidesync-0.4.1}/slidesync/__init__.py

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

{slidesync-0.3.0 → slidesync-0.4.1}/slidesync/_sync.py

@@ -36,6 +36,7 @@ from __future__ import annotations
 
 import argparse
 import base64
+import copy
 import datetime
 import difflib
 import hashlib
@@ -1147,6 +1148,16 @@ def push(slides_api, drive, deck, source, anchor, prune, base_dir=Path("."),
     creates, deletes, skips, pruned = plan_sync(source, managed, prune, force)
     if not (creates or deletes or pruned):  # nothing changed — skip reorder/links/gets
         return {"create": 0, "skip": len(skips), "replace": 0, "prune": 0}
+    if not force:
+        # Non-fast-forward guard: replacing or pruning a slide that was edited
+        # in Google Slides since its last push would silently discard that edit.
+        risks = _clobber_risks(pres, managed, source, pruned)
+        if risks:
+            for key in risks:
+                logger.error(f"live edit would be lost: {key}")
+            sys.exit("push rejected: the deck changed in Google Slides since the "
+                     "last push (slides above). Run `slidesync sync` to reconcile, "
+                     "or `push --force` to overwrite.")
     layouts = _layout_map(slides_api, deck, pres)
     templates = _template_index(slides_api, deck, pres)
     reqs = [{"deleteObject": {"objectId": oid}} for oid in deletes + pruned]
@@ -2004,20 +2015,145 @@ 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)
+    marker = _read_marker(notes_raw)
+    base_src = base64.b64decode(marker["src"]).decode() if "src" in marker else None
+    notes = " ".join(MARKER_RE.sub("", notes_raw).split())
+    return text_lines_native(s), notes, base_src, marker
+
+
+def _clobber_risks(pres, managed, source, pruned) -> list[str]:
+    """Keys of slides whose live edits a push would silently discard.
+
+    A replace (or prune) deletes the live slide, which loses information only
+    when the live copy drifted from its merge base AND the local markdown does
+    not already contain the live content (as it does right after `sync`).
+    Legacy slides without a src marker can't be checked and are allowed.
+    """
+    live = {s["objectId"]: s for s in pres.get("slides", [])}
+    by_kh = {s.key_hash: s for s in source}
+    out = []
+    for kh, (oid, _ch) in managed.items():
+        sl = by_kh.get(kh)
+        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])
+        if base_src is None:
+            continue
+        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 == _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)
+    return out
+
+
+def _slide_from_live_boxes(s, marker: dict) -> Slide:
+    """Rebuild a template slide's content from its deterministically-named boxes
+    (`_k` kicker, `_h` headline, `_by` byline, `_b` body), formatting runs
+    included — so live text edits can be written back into the markdown."""
+    sid = s["objectId"]
+    shapes = {el.get("objectId", ""): el["shape"]
+              for el in s.get("pageElements", [])
+              if el.get("shape", {}).get("text")}
+
+    def paras(suffix: str) -> list[Para]:
+        shape = shapes.get(sid + suffix)
+        return _paras_from_shape(shape) if shape else []
+
+    slide = Slide(marker.get("id", sid), "content")
+    slide.template_name = marker.get("template")
+    slide.vars = marker.get("vars", {})
+    if (slide.template_name or "").lower() in ("prompt", "code"):
+        slide.title = _flatten(paras("_k")).strip()
+        slide.verbatim = "\n".join(p.text for p in paras("_b"))
+        return slide
+    headline = _flatten(paras("_h")).strip()
+    kicker = _flatten(paras("_k")).strip()
+    if headline:
+        slide.title, slide.kicker = headline, kicker
+    else:
+        slide.title = kicker  # content template: the kicker IS the title
+    slide.paras = paras("_b") or paras("_by")
+    if marker.get("img"):
+        slide.layout = "image"
+        slide.image, slide.image_alt = marker["img"], marker.get("alt", "")
+    return slide
+
+
+def _render_body(slide: Slide) -> str:
+    """Slide -> markdown body only (the slide's frontmatter stays as authored)."""
+    bare = copy.copy(slide)
+    bare.template_name, bare.layout_name, bare.vars = None, None, {}
+    return to_slidev(bare, include_id=False).strip()
+
+
+_SEP_RE = re.compile(r"(?m)^---[ \t]*$")
+
+
+def _slide_span(text: str, key: str) -> tuple[int, int] | None:
+    """(start, end) of the body of the slide whose frontmatter id is `key`."""
+    m = re.search(rf"(?m)^id:\s*{re.escape(key)}\s*$", text)
+    if not m:
+        return None  # slide has no id: frontmatter — can't anchor file surgery
+    closer = _SEP_RE.search(text, m.end())
+    if not closer:
+        return None
+    nxt = _SEP_RE.search(text, closer.end())
+    return closer.end(), nxt.start() if nxt else len(text)
+
+
+def _replace_slide_body(text: str, key: str, body: str) -> str:
+    span = _slide_span(text, key)
+    if span is None:
+        return text
+    return text[:span[0]] + "\n" + body.strip("\n") + "\n\n" + text[span[1]:]
+
+
+def _append_to_slide_body(text: str, key: str, block: str) -> str:
+    span = _slide_span(text, key)
+    if span is None:
+        return text
+    return text[:span[1]].rstrip("\n") + "\n" + block + "\n\n" + text[span[1]:]
+
+
 def cmd_sync(args):
-    """Report per-slide drift between a markdown deck and its live Slides copy.
-
-    Detection, not resolution: each slide is classified against the marker's
-    last-pushed source (the merge base). Additive changes (comments, notes-pane
-    edits) are printed as ready-to-paste `<!-- @Author: ... -->` blocks; text
-    conflicts are printed as unified diffs for a human/LLM to fold into the
-    markdown, after which a normal `push` (or `push --force` to clobber
-    live-only drift) makes the file authoritative again. Exits 1 if anything
-    drifted.
+    """Reconcile a markdown deck with its live Slides copy — applying what's safe.
+
+    Pull side: unresolved comment threads are appended to their slide as
+    `<!-- @Author: text -->` blocks (orphaned threads are re-anchored via the
+    objectId's key-hash), and live-drift slides — edited in Slides, untouched
+    locally — are written back into the markdown, reconstructed from their
+    styled boxes. Conflict slides (both sides changed) are never touched: their
+    diffs print for a human/LLM to resolve, and the push step is skipped.
+    Push side: when no conflicts remain, the (updated) file is pushed — safe,
+    because local now matches live wherever the deck had drifted. Exits 1 when
+    conflicts remain.
     """
     slides_api, drive = get_services(args.account)
-    source = load_slides(args.source)
-    deck = args.deck or deck_from_source(args.source)
+    path = args.source
+    source = load_slides(path)
+    deck = args.deck or deck_from_source(path)
     if not deck:
         sys.exit("no target deck: pass --deck or add `deck:` frontmatter")
     pres = slides_api.presentations().get(presentationId=deck).execute()
@@ -2027,59 +2163,83 @@ def cmd_sync(args):
     for c in shape_comments(list_comments(drive, deck)):
         if not c["resolved"] and c["page"]:
             by_page.setdefault(c["page"], []).append(c)
-    drifted = 0
+
+    state = {"text": path.read_text(), "dirty": False, "pushable": False}
+    key_by_kh = {sl.key_hash: sl.key for sl in source}
+
+    def capture(key: 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()):
+            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']}")
+        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:
         s = live.pop(sl.key_hash, None)
         if s is None:
-            logger.warning(f"[missing   ] {sl.key} — not in deck; push will create it")
-            drifted += 1
+            logger.info(f"[missing   ] {sl.key} — push will create it")
+            state["pushable"] = True
             continue
         for c in by_page.pop(s["objectId"], []):
-            drifted += 1
-            lines = [f"@{c['author']}: {c['content']}"]
-            lines += [f"@{r['author']}: {r['content']}" for r in c["replies"]]
-            logger.info(f"[comment   ] {sl.key} ({c['modified']}):\n"
-                        + "<!-- " + "\n".join(lines) + " -->")
+            capture(sl.key, c, s["objectId"])
         if sl.custom is not None:
-            continue  # pull-authoritative; drawings are captured, not diffed
-        notes_raw = _read_notes(s)
-        marker = _read_marker(notes_raw)
-        base_src = (base64.b64decode(marker["src"]).decode()
-                    if "src" in marker else None)
-        base = text_lines_md(base_src) if base_src is not None else None
-        local = text_lines_md(sl.src or "")
-        live_lines = text_lines_native(s)
+            continue  # pull-authoritative; drawings are captured by pull, not diffed
+        live_lines, live_notes, base_src, marker = _live_state(s)
+        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)
-        pushed_at = marker.get("at", "?")
         if status in ("clean", "converged"):
             continue
-        drifted += 1
         if status == "local-edit":
             logger.info(f"[local-edit] {sl.key} — push will update it")
-        elif status in ("live-drift", "drift-no-base"):
-            logger.warning(f"[live-drift] {sl.key} (pushed {pushed_at}) — edited in "
-                           f"Slides; fold into the markdown or `push --force` to clobber:\n"
-                           + _diff(base if base is not None else local, live_lines,
-                                   "last-pushed" if base is not None else "local", "live"))
-        else:  # conflict
-            logger.error(f"[conflict  ] {sl.key} (pushed {pushed_at}) — both sides "
-                         f"changed since last push:\n"
-                         + _diff(base, local, "last-pushed", "local") + "\n"
-                         + _diff(base, live_lines, "last-pushed", "live"))
-        live_notes = " ".join(MARKER_RE.sub("", notes_raw).split())
-        base_notes = " ".join(_extract_notes(base_src).split()) if base_src else ""
-        if base_src is not None and live_notes != base_notes:
-            logger.info(f"[notes     ] {sl.key} — notes pane edited live:\n{live_notes}")
-    for kh, s in live.items():
-        logger.warning(f"[unmanaged ] {s['objectId']} in deck has no local slide "
-                       "(--prune on push would delete it)")
-    for page, cs in by_page.items():
+            state["pushable"] = True
+            continue
+        rebuilt = (_slide_from_live_boxes(s, marker)
+                   if status in ("live-drift", "drift-no-base")
+                   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")
+                continue
+        conflicts.append(sl.key)
+        logger.error(f"[conflict  ] {sl.key} (pushed {marker.get('at', '?')}) — "
+                     f"resolve in the markdown, then push:\n"
+                     + _diff(base or [], text_lines_md(sl.src or ""),
+                             "last-pushed", "local") + "\n"
+                     + _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
         for c in cs:
-            logger.warning(f"[orphaned  ] comment by {c['author']} anchored to deleted "
-                           f"slide {page}: {c['content']!r}")
-    logger.log("WARNING" if drifted else "SUCCESS",
-               f"{drifted} drifted item(s)" if drifted else "deck matches source")
-    sys.exit(1 if drifted else 0)
+            capture(key, 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}")
+    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)
+        logger.success(f"{stats} -> "
+                       f"https://docs.google.com/presentation/d/{deck}/edit")
+    else:
+        logger.success("deck matches source — nothing to do")
 
 
 def _loop_hop(slides_api, drive, title, slides):

{slidesync-0.3.0 → slidesync-0.4.1/slidesync.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slidesync
-Version: 0.3.0
+Version: 0.4.1
 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.3.0
+Version: 0.4.1
 
 ```bash
 uvx slidesync --help            # run without installing
@@ -58,13 +58,13 @@ Support path.)
 
 | Command | Purpose |
 |---------|---------|
-| `slidesync push <file.slidev.md> [--deck ID] [--new "Title"] [--anchor SLIDE] [--prune] [--force]` | markdown → Slides |
+| `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]` | report drift vs the live deck — comments, live edits, conflicts (exit 1 on drift) |
+| `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) |
 
 `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
@@ -89,24 +89,32 @@ hidden `<!-- s2g {...} -->` marker in speaker notes carries the human id, image
 path, template vars — and, for template slides, the authored body markdown
 (base64) — so `pull` recovers the source verbatim.
 
-## Sync & drift (detection, not resolution)
-
-The marker's last-pushed source is a true per-slide **merge base**, so `sync`
-classifies each slide three-way without timestamps (the Slides API has no
-per-slide edit times — only file-level `modifiedTime`; the marker's `at` stamp
-records when *we* last pushed each slide):
-
-| status | meaning | action |
-|--------|---------|--------|
-| `clean` / `converged` | nothing changed, or both sides made the same change | — |
-| `local-edit` | markdown changed, deck untouched | `push` (normal) |
-| `live-drift` | slide edited in Google Slides | fold the printed diff into the markdown, or `push --force` to clobber |
-| `conflict` | both changed since last push | resolve the two printed diffs by hand/LLM, then `push` |
-
-Unresolved comment threads print as ready-to-paste `<!-- @Author: text -->`
-blocks on their slide (replies as extra `@Author:` lines) — paste them into the
-source, where they round-trip from then on. Threads anchor to slide objectIds,
-so a re-render orphans them: `sync` reports those too. Capture before you push.
+## Sync & drift
+
+`push` is guarded like a non-fast-forward git push: if a slide it would replace
+(or prune) was edited in Google Slides since the last push — and the local
+markdown doesn't already carry that edit — the push is **rejected** with no
+changes made (`--force` overwrites). Live edits on slides the push wouldn't
+touch are left alone.
+
+`sync` reconciles the two sides, applying whatever is safe. The marker's
+last-pushed source is a true per-slide **merge base**, so each slide classifies
+three-way without timestamps (the APIs expose no per-slide edit times — only
+file-level `modifiedTime`; the marker's `at` stamp records our last push):
+
+| status | meaning | sync does |
+|--------|---------|-----------|
+| `clean` / `converged` | nothing changed, or both sides made the same change | nothing |
+| `local-edit` | markdown changed, deck untouched | pushes it |
+| `live-drift` | slide edited in Google Slides | writes the live content back into the markdown (reconstructed from its styled boxes, formatting runs included), then pushes |
+| `conflict` | both changed since last push | prints both diffs vs the base for a human/LLM to resolve; skips the push; exits 1 |
+
+Unresolved comment threads are appended to their slide as
+`<!-- @Author: text -->` blocks (replies as extra `@Author:` lines), and threads
+orphaned by a re-render are re-anchored to their slide via the objectId's
+key-hash. Captured text round-trips from then on. Write-back caveat: a slide
+edited live is rewritten canonically, so its authored comments collapse into
+one trailing block (untouched slides keep comments in place).
 
 ## Markdown dialect
 

{slidesync-0.3.0 → slidesync-0.4.1}/slidesync.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ slidesync.egg-info/entry_points.txt
 slidesync.egg-info/requires.txt
 slidesync.egg-info/top_level.txt
 tests/test_comment_preservation.py
+tests/test_e2e_scenarios.py
 tests/test_markdown.py
 tests/test_pull.py
 tests/test_sync_drift.py

slidesync-0.4.1/tests/test_e2e_scenarios.py

@@ -0,0 +1,320 @@
+"""End-to-end scenarios for push/sync against an in-memory Slides+Drive fake.
+
+The fake interprets exactly the request types slidesync emits (createSlide,
+deleteObject, createShape, insertText, deleteText, updateSlidesPosition) and
+renders state back in the wire format `presentations.get` returns — so push,
+the non-fast-forward guard, and sync's pull-back/capture all run unmodified.
+"""
+
+import json
+import re
+from types import SimpleNamespace
+
+import pytest
+
+from slidesync import _sync
+from slidesync._sync import cmd_sync, load_slides, push
+
+DECK = "fakedeck"
+
+MD = """---
+theme: seriph
+---
+
+---
+template: topic
+id: thread-a
+---
+# Takeaway A
+## FINDING · DATA
+
+One solid point.
+
+<!-- presenter note A -->
+
+---
+---
+template: content
+id: overview
+---
+## OVERVIEW
+
+First result line.
+"""
+
+
+def _text_els(text):
+    els = []
+    for line in text.split("\n"):
+        els.append({"paragraphMarker": {}})
+        els.append({"textRun": {"content": line + "\n", "style": {}}})
+    return els if text else []
+
+
+class FakeStore:
+    """In-memory deck: ordered slides, each with text shapes + speaker notes."""
+
+    def __init__(self):
+        self.slides = []  # {"id", "shapes": {sid: {"y", "x", "text"}}, "notes"}
+
+    def _slide(self, oid):
+        return next(s for s in self.slides if s["id"] == oid)
+
+    def _owner_of_shape(self, sid):
+        for s in self.slides:
+            if sid in s["shapes"] or sid == s["id"] + "_n":
+                return s
+        raise KeyError(sid)
+
+    def apply(self, reqs):
+        for r in reqs:
+            if "createSlide" in r:
+                self.slides.append({"id": r["createSlide"]["objectId"],
+                                    "shapes": {}, "notes": ""})
+            elif "deleteObject" in r:
+                self.slides = [s for s in self.slides
+                               if s["id"] != r["deleteObject"]["objectId"]]
+            elif "createShape" in r:
+                ep = r["createShape"]["elementProperties"]
+                tr = ep.get("transform", {})
+                self._slide(ep["pageObjectId"])["shapes"][
+                    r["createShape"]["objectId"]] = {
+                        "y": tr.get("translateY", 0), "x": tr.get("translateX", 0),
+                        "text": ""}
+            elif "insertText" in r:
+                sid = r["insertText"]["objectId"]
+                s = self._owner_of_shape(sid)
+                if sid == s["id"] + "_n":
+                    s["notes"] += r["insertText"]["text"]
+                else:
+                    s["shapes"][sid]["text"] += r["insertText"]["text"]
+            elif "deleteText" in r:
+                sid = r["deleteText"]["objectId"]
+                s = self._owner_of_shape(sid)
+                if sid == s["id"] + "_n":
+                    s["notes"] = ""
+                else:
+                    s["shapes"][sid]["text"] = ""
+            elif "updateSlidesPosition" in r:
+                oid = r["updateSlidesPosition"]["slideObjectIds"][0]
+                moved = self._slide(oid)
+                rest = [s for s in self.slides if s["id"] != oid]
+                rest.insert(r["updateSlidesPosition"]["insertionIndex"], moved)
+                self.slides = rest
+            # styling-only requests are ignored
+        return {}
+
+    def render(self):
+        out = []
+        for s in self.slides:
+            els = [{"objectId": sid,
+                    "transform": {"translateY": sh["y"], "translateX": sh["x"]},
+                    "shape": {"text": {"textElements": _text_els(sh["text"])}}}
+                   for sid, sh in s["shapes"].items() if sh["text"]]
+            nid = s["id"] + "_n"
+            out.append({
+                "objectId": s["id"], "pageElements": els,
+                "slideProperties": {"notesPage": {
+                    "notesProperties": {"speakerNotesObjectId": nid},
+                    "pageElements": [{"objectId": nid, "shape": {
+                        "text": {"textElements": _text_els(s["notes"])}}}]}}})
+        return {"slides": out, "layouts": []}
+
+    # test helpers ---------------------------------------------------------
+    def oid_of(self, needle):
+        for s in self.slides:
+            if any(needle in sh["text"] for sh in s["shapes"].values()):
+                return s["id"]
+        raise AssertionError(f"no live slide contains {needle!r}")
+
+    def edit_text(self, old, new):
+        for s in self.slides:
+            for sh in s["shapes"].values():
+                if old in sh["text"]:
+                    sh["text"] = sh["text"].replace(old, new)
+                    return
+        raise AssertionError(f"no live shape contains {old!r}")
+
+    def all_text(self):
+        return " ".join(sh["text"] for s in self.slides
+                        for sh in s["shapes"].values())
+
+
+class _Req:
+    def __init__(self, fn):
+        self.execute = fn
+
+
+class FakeSlides:
+    def __init__(self, store):
+        self.store = store
+
+    def presentations(self):
+        return self
+
+    def get(self, presentationId, fields=None):
+        return _Req(lambda: self.store.render())
+
+    def batchUpdate(self, presentationId, body):
+        return _Req(lambda: self.store.apply(body["requests"]))
+
+
+class FakeDrive:
+    def __init__(self):
+        self.threads = []  # raw Drive comment dicts
+
+    def comments(self):
+        return self
+
+    def list(self, fileId, pageSize=None, pageToken=None, fields=None):
+        return _Req(lambda: {"comments": self.threads})
+
+    def add(self, page_oid, content, author="Daniel Hails"):
+        self.threads.append({
+            "id": f"c{len(self.threads)}",
+            "anchor": json.dumps({"type": "page", "pages": [page_oid]}),
+            "author": {"displayName": author},
+            "content": content, "replies": []})
+
+
+@pytest.fixture
+def env(tmp_path, monkeypatch):
+    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(MD)
+    push(slides_api, drive, DECK, load_slides(path), anchor=None, prune=False,
+         base_dir=tmp_path)
+    return SimpleNamespace(store=store, drive=drive, slides=slides_api, path=path)
+
+
+def _sync_cmd(env):
+    cmd_sync(SimpleNamespace(source=env.path, deck=DECK, account=None))
+
+
+def _push(env, force=False, prune=False):
+    return push(env.slides, env.drive, DECK, load_slides(env.path), anchor=None,
+                prune=prune, base_dir=env.path.parent, force=force)
+
+
+def _local_edit(env):
+    env.path.write_text(env.path.read_text().replace(
+        "One solid point.", "One solid point, sharpened."))
+
+
+def _live_edit(env):
+    env.store.edit_text("Takeaway A", "Takeaway A, live-edited")
+
+
+SCENARIOS = {
+    "clean": dict(setup=[], sync_conflicts=False,
+                  file_has=[], live_has=["Takeaway A"]),
+    "local-edit": dict(setup=[_local_edit], sync_conflicts=False,
+                       file_has=["sharpened"], live_has=["sharpened"]),
+    "live-drift": dict(setup=[_live_edit], sync_conflicts=False,
+                       file_has=["live-edited"], live_has=["live-edited"]),
+    "conflict": dict(setup=[_live_edit,
+                            lambda e: e.path.write_text(e.path.read_text().replace(
+                                "Takeaway A", "Takeaway A, locally-reworded"))],
+                     sync_conflicts=True,
+                     file_has=["locally-reworded"], live_has=["live-edited"]),
+}
+
+
+@pytest.mark.parametrize("name", SCENARIOS)
+def test_sync_scenarios(env, name):
+    sc = SCENARIOS[name]
+    for step in sc["setup"]:
+        step(env)
+    if sc["sync_conflicts"]:
+        with pytest.raises(SystemExit):
+            _sync_cmd(env)
+    else:
+        _sync_cmd(env)
+    text, live = env.path.read_text(), env.store.all_text()
+    for needle in sc["file_has"]:
+        assert needle in text, f"{name}: {needle!r} missing from markdown"
+    for needle in sc["live_has"]:
+        assert needle in live, f"{name}: {needle!r} missing from deck"
+    if not sc["sync_conflicts"]:  # reconciled: a follow-up sync is a no-op
+        before = env.path.read_text()
+        _sync_cmd(env)
+        assert env.path.read_text() == before
+
+
+def test_push_rejects_conflicting_replace_and_force_overrides(env):
+    _live_edit(env)
+    env.path.write_text(env.path.read_text().replace(
+        "Takeaway A", "Takeaway A, locally-reworded"))
+    with pytest.raises(SystemExit):
+        _push(env)
+    assert "live-edited" in env.store.all_text()  # guard left the deck intact
+    _push(env, force=True)
+    assert "locally-reworded" in env.store.all_text()
+    assert "live-edited" not in env.store.all_text()
+
+
+def test_push_rejects_pruning_a_live_edited_slide(env):
+    _live_edit(env)
+    env.path.write_text(re.sub(r"(?ms)^---\ntemplate: topic\n.*?(?=^---$\n---\n)",
+                               "", env.path.read_text(), count=1))
+    assert "thread-a" not in env.path.read_text()
+    with pytest.raises(SystemExit):
+        _push(env, prune=True)
+    _push(env, prune=True, force=True)
+    assert "Takeaway A" not in env.store.all_text()
+
+
+def test_push_ignores_live_drift_on_untouched_slides(env):
+    # No local change -> nothing is replaced -> nothing can be lost -> no guard.
+    _live_edit(env)
+    stats = _push(env)
+    assert stats["replace"] == 0
+    assert "live-edited" in env.store.all_text()
+
+
+def test_sync_captures_comment_onto_its_slide(env):
+    env.drive.add(env.store.oid_of("Takeaway A"), "This is obviously dodgy. To debug")
+    _sync_cmd(env)
+    text = env.path.read_text()
+    assert "<!-- @Daniel Hails: This is obviously dodgy. To debug -->" in text
+    assert text.index("Takeaway A") < text.index("obviously dodgy") < text.index("OVERVIEW")
+    _sync_cmd(env)  # idempotent: captured text is not duplicated
+    assert env.path.read_text().count("obviously dodgy") == 1
+
+
+def test_sync_recaptures_orphaned_comment_via_key_hash(env):
+    env.drive.add(env.store.oid_of("Takeaway A"), "anchored before the re-render")
+    _local_edit(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))
+    assert path.read_text() == before  # no write-back, no conflict, no churn