slidesync 0.1.0__tar.gz → 0.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slidesync
-Version: 0.1.0
+Version: 0.3.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.1.0
+Version: 0.3.0
 
 ```bash
 uvx slidesync --help            # run without installing
@@ -63,6 +63,8 @@ Support path.)
 | `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) |
 
 `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
@@ -84,7 +86,27 @@ is a no-op. Diff per run: identical hash → skip; same key, new content → rep
 new key → create. Removed slides are **kept** unless `--prune`. **Only `s2g_`
 slides are ever touched** — hand-authored slides are invisible to the sync. A
 hidden `<!-- s2g {...} -->` marker in speaker notes carries the human id, image
-path, and template vars so `pull` can recover them.
+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.
 
 ## Markdown dialect
 
@@ -96,7 +118,11 @@ may have its own frontmatter (`id:`, `template:`, `layout:`).
   `**bold**` / `*italic*` / `` `code` `` / `[link](url)`. GFM tables.
   `![alt](path)` images (uploaded to Drive; `alt` becomes the accessibility
   description, round-tripped on pull). Blank lines preserved as spacing.
-  `<!-- notes -->` become speaker notes.
+  `<!-- notes -->` become speaker notes — and round-trip as **comments, in
+  place**: template slides carry their authored source in the marker, so `pull`
+  re-emits each comment where it was written instead of one merged trailing
+  blob. Speaker notes edited live in Slides come back as one extra trailing
+  comment.
 - **Internal links:** `[text](#slide-id)` becomes a native Slides link to the
   slide whose `id:` (or title slug) is `slide-id`.
 
@@ -105,6 +131,9 @@ may have its own frontmatter (`id:`, `template:`, `layout:`).
 Select per slide via `template:` — native styled boxes, no in-deck templates:
 `dark`/`title`, `appendix`, `question`/`label`, `topic`, `content`,
 `graph`/`full` (single full-bleed image), `prompt`/`code` (verbatim monospace).
+Title cards (`dark`/`title`/`appendix`) render body lines as a small dimmed
+**byline** beneath the headline (e.g. `Project · Presenter`) — they still have
+no linkable body region.
 Slides with no `template:` fall back to a generative path (section /
 title+body / table / image) that also brands the background + IBM Plex.
 
@@ -131,6 +160,11 @@ Releases publish to PyPI via Trusted Publishing (OIDC) on a `v*.*.*` tag — see
   — this is a content mapper, not a CSS renderer.
 - On `pull`, the slide model holds a single image, so a slide with multiple
   images keeps the first; image `contentUrl`s from foreign decks are ephemeral.
+- Verbatim-source markers are seeded at push time, so comment preservation
+  applies from the first push with v0.2+ (older slides re-render once: the
+  content hash is now over the authored source). Generative-path slides (no
+  `template:`) still merge comments into a single trailing comment on pull,
+  since their live Slides edits — not the marker — are the source of truth.
 
 ## License
 

{slidesync-0.1.0 → slidesync-0.3.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.1.0
+Version: 0.3.0
 
 ```bash
 uvx slidesync --help            # run without installing
@@ -45,6 +45,8 @@ Support path.)
 | `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) |
 
 `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
@@ -66,7 +68,27 @@ is a no-op. Diff per run: identical hash → skip; same key, new content → rep
 new key → create. Removed slides are **kept** unless `--prune`. **Only `s2g_`
 slides are ever touched** — hand-authored slides are invisible to the sync. A
 hidden `<!-- s2g {...} -->` marker in speaker notes carries the human id, image
-path, and template vars so `pull` can recover them.
+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.
 
 ## Markdown dialect
 
@@ -78,7 +100,11 @@ may have its own frontmatter (`id:`, `template:`, `layout:`).
   `**bold**` / `*italic*` / `` `code` `` / `[link](url)`. GFM tables.
   `![alt](path)` images (uploaded to Drive; `alt` becomes the accessibility
   description, round-tripped on pull). Blank lines preserved as spacing.
-  `<!-- notes -->` become speaker notes.
+  `<!-- notes -->` become speaker notes — and round-trip as **comments, in
+  place**: template slides carry their authored source in the marker, so `pull`
+  re-emits each comment where it was written instead of one merged trailing
+  blob. Speaker notes edited live in Slides come back as one extra trailing
+  comment.
 - **Internal links:** `[text](#slide-id)` becomes a native Slides link to the
   slide whose `id:` (or title slug) is `slide-id`.
 
@@ -87,6 +113,9 @@ may have its own frontmatter (`id:`, `template:`, `layout:`).
 Select per slide via `template:` — native styled boxes, no in-deck templates:
 `dark`/`title`, `appendix`, `question`/`label`, `topic`, `content`,
 `graph`/`full` (single full-bleed image), `prompt`/`code` (verbatim monospace).
+Title cards (`dark`/`title`/`appendix`) render body lines as a small dimmed
+**byline** beneath the headline (e.g. `Project · Presenter`) — they still have
+no linkable body region.
 Slides with no `template:` fall back to a generative path (section /
 title+body / table / image) that also brands the background + IBM Plex.
 
@@ -113,6 +142,11 @@ Releases publish to PyPI via Trusted Publishing (OIDC) on a `v*.*.*` tag — see
   — this is a content mapper, not a CSS renderer.
 - On `pull`, the slide model holds a single image, so a slide with multiple
   images keeps the first; image `contentUrl`s from foreign decks are ephemeral.
+- Verbatim-source markers are seeded at push time, so comment preservation
+  applies from the first push with v0.2+ (older slides re-render once: the
+  content hash is now over the authored source). Generative-path slides (no
+  `template:`) still merge comments into a single trailing comment on pull,
+  since their live Slides edits — not the marker — are the source of truth.
 
 ## License
 

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

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

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

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

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

@@ -21,7 +21,9 @@ Idempotent sync (upsert), never a blind append:
   create. Removed slides are kept by default (`--prune` to delete).
 - Only `s2g_`-prefixed slides are ever touched; hand-authored slides are
   invisible to the sync. A tiny `<!-- s2g {...} -->` marker in speaker notes
-  carries the human id + image path so `pull` can recover them.
+  carries the human id + image path — and, for template slides, the authored
+  body markdown (base64) — so `pull` recovers the source verbatim: comments
+  stay comments, in place, instead of collapsing into one speaker-notes blob.
 
 Usage:
     bin/slidesync.py push deck.slidev.md --deck <id> [--anchor <slideId>] [--prune]
@@ -33,6 +35,9 @@ Usage:
 from __future__ import annotations
 
 import argparse
+import base64
+import datetime
+import difflib
 import hashlib
 import html
 import json
@@ -81,6 +86,7 @@ INK = {"red": 0.011764706, "green": 0.02745098, "blue": 0.07058824}  # #03070F
 BODY_INK = {"red": 0.11764706, "green": 0.1254902, "blue": 0.14117648}  # #1E2024
 PAPER = {"red": 0.98039216, "green": 0.98039216, "blue": 0.98039216}  # #FAFAFA
 WHITE = {"red": 1.0, "green": 1.0, "blue": 1.0}                       # #FFFFFF
+MUTED = {"red": 0.62, "green": 0.65, "blue": 0.69}  # dimmed byline on dark cards
 LIGHT_BG, DARK_BG = PAPER, BODY_INK
 
 # ---------------------------------------------------------------------------
@@ -187,6 +193,7 @@ class Slide:
     vars: dict = field(default_factory=dict)  # extra frontmatter -> {{token}} values
     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)
     key_hash: str = ""
     content_hash: str = ""
     object_id: str = ""
@@ -282,6 +289,7 @@ def build_slides(chunks: list[tuple[dict, str]]) -> list[Slide]:
 
 
 def build_slide(meta: dict, body: str, index: int) -> Slide:
+    authored = body.strip("\n")
     custom, body = _extract_custom(body)
     verbatim = None
     if (meta.get("template") or "").lower() in ("prompt", "code"):
@@ -299,6 +307,8 @@ def build_slide(meta: dict, body: str, index: int) -> Slide:
     slide.vars = {k: v for k, v in meta.items() if k not in RESERVED_KEYS}
     slide.custom = custom
     slide.verbatim = verbatim
+    if custom is None:  # custom slides are pull-authoritative; their source goes stale
+        slide.src = authored
     return _finalize(slide)
 
 
@@ -467,6 +477,18 @@ def to_slidev(slide: Slide, include_id: bool = True) -> str:
     out = []
     if fm:
         out += ["---"] + [f"{k}: {v}" for k, v in fm.items()] + ["---"]
+    if slide.src is not None:
+        # Authored source is the canonical render: comments stay comments, in
+        # place. Speaker notes are emitted only when they no longer match the
+        # authored comments (i.e. someone edited the notes pane in Slides) —
+        # compared whitespace-normalised, since the notes shape flattens
+        # paragraphs when read back.
+        out.append(slide.src)
+        extra = slide.notes.strip()
+        if extra and " ".join(extra.split()) != \
+                " ".join(_extract_notes(slide.src).split()):
+            out.append(f"<!-- {extra} -->")
+        return "\n".join(out).strip() + "\n"
     if slide.custom is not None:
         out += ["```gslides", slide.custom, "```"]
         if slide.notes:
@@ -553,8 +575,17 @@ def _marker(slide: Slide) -> str:
             data["body"] = body_md
         if slide.vars:
             data["vars"] = slide.vars
+        if slide.src is not None:
+            # base64: MARKER_RE is delimiter-based, so a `}` + `-->` sequence
+            # in raw authored markdown would truncate the JSON mid-string;
+            # encoding also keeps the visible notes pane free of a giant blob.
+            data["src"] = base64.b64encode(slide.src.encode()).decode()
     elif slide.layout_name and slide.layout_name not in SECTION_LAYOUTS:
         data["tpl"] = slide.layout_name
+    # Last-push stamp: `sync` reports it alongside drift. The Slides/Drive APIs
+    # have no per-slide edit times (file-level modifiedTime only), so this is
+    # the only per-slide timestamp that exists.
+    data["at"] = datetime.datetime.now(datetime.UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
     return f"<!-- s2g {json.dumps(data, separators=(',', ':'))} -->"
 
 
@@ -664,9 +695,15 @@ def _styled_requests(slide: Slide, style: Style, image_url, image_px) -> list[di
         head_pt = _fit_headline_pt(headline_text, style.headline_pt,
                                    max_lines=style.head_lines)
         head_h = _est_lines(headline_text, head_pt) * head_pt * 1.25 / 72 + 0.1
-    # Title cards (no body, no image) vertically centre the kicker+headline.
+    # Title cards have no body region; body lines render as a small dimmed
+    # byline beneath the headline (e.g. "Project · Presenter" on a title slide).
+    byline = ""
+    if style.body_align is None and slide.paras:
+        byline = "\n".join(p.text for p in slide.paras if p.text)
+    by_h = (byline.count("\n") + 1) * 0.32 if byline else 0.0
+    # Title cards (no body, no image) vertically centre kicker+headline+byline.
     if (style.body_align is None or not slide.paras) and not slide.image:
-        block = (0.36 if kicker_text else 0) + head_h
+        block = (0.36 if kicker_text else 0) + head_h + (by_h + 0.1 if byline else 0)
         y = max(0.4, (5.63 - block) / 2)
     else:
         y = style.top
@@ -682,6 +719,11 @@ def _styled_requests(slide: Slide, style: Style, image_url, image_px) -> list[di
                           headline_text, head_pt, style.headline_rgb, True,
                           halign=head_align)
         y += head_h + 0.15
+    if byline:
+        rgb = MUTED if style.bg == DARK_BG else BODY_INK
+        reqs += _text_box(sid, sid + "_by", (0.34, y, 9.32, by_h),
+                          byline, 14, rgb, False)
+        y += by_h + 0.1
     if style.body_align and slide.paras:
         bid = sid + "_b"
         reqs.append({"createShape": {"objectId": bid, "shapeType": "TEXT_BOX",
@@ -1503,6 +1545,8 @@ def _slide_from_marker(marker: dict, notes: str) -> Slide:
     slide.kicker = marker.get("h2", "")
     slide.template_name = marker["template"]
     slide.vars = marker.get("vars", {})
+    if "src" in marker:
+        slide.src = base64.b64decode(marker["src"]).decode()
     return slide
 
 
@@ -1852,6 +1896,192 @@ def cmd_layouts(args):
         logger.info(f"{name:<24} {', '.join(phs) or '(no placeholders)'}")
 
 
+# ---------------------------------------------------------------------------
+# Comments + sync (drift detection)
+# ---------------------------------------------------------------------------
+
+
+def shape_comments(raw: list[dict]) -> list[dict]:
+    """Drive comment threads -> [{id, page, author, content, resolved, replies}].
+
+    `page` is the anchored slide objectId (None for file-level comments) —
+    note an objectId outlives its slide, so the anchor may point at a deleted
+    page after a re-render. Resolve-action replies with no text are dropped.
+    """
+    out = []
+    for c in raw:
+        try:
+            anchor = json.loads(c.get("anchor") or "{}")
+        except json.JSONDecodeError:
+            anchor = {}
+        pages = anchor.get("pages") or []
+        out.append({
+            "id": c.get("id", ""),
+            "page": pages[0] if pages else None,
+            "author": (c.get("author") or {}).get("displayName", ""),
+            "content": (c.get("content") or "").strip(),
+            "resolved": bool(c.get("resolved")),
+            "modified": c.get("modifiedTime", ""),
+            "replies": [
+                {"author": (r.get("author") or {}).get("displayName", ""),
+                 "content": (r.get("content") or "").strip()}
+                for r in c.get("replies", []) if (r.get("content") or "").strip()
+            ],
+        })
+    return out
+
+
+_COMMENT_FIELDS = ("nextPageToken,comments(id,content,author(displayName),"
+                   "anchor,resolved,modifiedTime,replies(content,author(displayName)))")
+
+
+def list_comments(drive, deck: str) -> list[dict]:
+    raw, token = [], None
+    while True:
+        resp = drive.comments().list(fileId=deck, pageSize=100, pageToken=token,
+                                     fields=_COMMENT_FIELDS).execute()
+        raw += resp.get("comments", [])
+        token = resp.get("nextPageToken")
+        if not token:
+            return raw
+
+
+def cmd_comments(args):
+    _, drive = get_services(args.account)
+    print(json.dumps(shape_comments(list_comments(drive, args.deck)), indent=2))
+
+
+def text_lines_md(src: str) -> list[str]:
+    """Markdown slide body -> normalised visible text lines (comments excluded)."""
+    fences = [m.group("text") for m in VERBATIM_RE.finditer(src)]
+    headings, paras, _img, _alt, table, _ = parse_body(VERBATIM_RE.sub("", src))
+    lines = [headings[k] for k in sorted(headings)]
+    lines += [p.text for p in paras]
+    if table:
+        lines += [" | ".join(row) for row in table]
+    for f in fences:
+        lines += f.splitlines()
+    return _norm_lines(lines)
+
+
+def text_lines_native(s: dict) -> list[str]:
+    """Native slide JSON -> normalised visible text lines (notes excluded)."""
+    boxes = []
+    for el in s.get("pageElements", []):
+        if el.get("shape", {}).get("text"):
+            paras = _paras_from_shape(el["shape"])
+            if paras:
+                boxes.append((_el_y(el), _el_x(el), paras))
+        elif el.get("table"):
+            rows = _table_from_native(el["table"])
+            boxes.append((_el_y(el), _el_x(el),
+                          [Para(" | ".join(r)) for r in rows]))
+    boxes.sort(key=lambda t: (t[0], t[1]))
+    return _norm_lines([p.text for _, _, paras in boxes for p in paras])
+
+
+def _norm_lines(lines: list[str]) -> list[str]:
+    # Sorted: box reading-order vs markdown order differ legitimately (e.g. a
+    # kicker renders above the headline but is written below it).
+    return sorted(" ".join(line.split()) for line in lines if line.strip())
+
+
+def classify_drift(base: list[str] | None, local: list[str],
+                   live: list[str]) -> str:
+    """Three-way status for one slide; base is the last-pushed source (marker)."""
+    if base is None:
+        return "clean" if local == live else "drift-no-base"
+    if local == base and live == base:
+        return "clean"
+    if local != base and live == base:
+        return "local-edit"
+    if local == base and live != base:
+        return "live-drift"
+    return "converged" if local == live else "conflict"
+
+
+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 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.
+    """
+    slides_api, drive = get_services(args.account)
+    source = load_slides(args.source)
+    deck = args.deck or deck_from_source(args.source)
+    if not deck:
+        sys.exit("no target deck: pass --deck or add `deck:` frontmatter")
+    pres = slides_api.presentations().get(presentationId=deck).execute()
+    live = {s["objectId"].split("_")[1]: s for s in pres.get("slides", [])
+            if MANAGED_RE.match(s["objectId"])}
+    by_page = {}
+    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
+    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
+            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) + " -->")
+        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)
+        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():
+        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)
+
+
 def _loop_hop(slides_api, drive, title, slides):
     """One md->slides hop: build a deck, push, pull back."""
     deck = new_deck(slides_api, title)
@@ -1928,6 +2158,17 @@ def main():
     p.add_argument("deck")
     p.set_defaults(func=cmd_layouts)
 
+    p = sub.add_parser("comments",
+                       help="list comment threads as JSON (page anchor, author, replies)")
+    p.add_argument("deck")
+    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)
+    p.add_argument("--deck")
+    p.set_defaults(func=cmd_sync)
+
     p = sub.add_parser("make-templates",
                        help="add branded tagged template slides to a deck")
     p.add_argument("deck")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slidesync
-Version: 0.1.0
+Version: 0.3.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.1.0
+Version: 0.3.0
 
 ```bash
 uvx slidesync --help            # run without installing
@@ -63,6 +63,8 @@ Support path.)
 | `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) |
 
 `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
@@ -84,7 +86,27 @@ is a no-op. Diff per run: identical hash → skip; same key, new content → rep
 new key → create. Removed slides are **kept** unless `--prune`. **Only `s2g_`
 slides are ever touched** — hand-authored slides are invisible to the sync. A
 hidden `<!-- s2g {...} -->` marker in speaker notes carries the human id, image
-path, and template vars so `pull` can recover them.
+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.
 
 ## Markdown dialect
 
@@ -96,7 +118,11 @@ may have its own frontmatter (`id:`, `template:`, `layout:`).
   `**bold**` / `*italic*` / `` `code` `` / `[link](url)`. GFM tables.
   `![alt](path)` images (uploaded to Drive; `alt` becomes the accessibility
   description, round-tripped on pull). Blank lines preserved as spacing.
-  `<!-- notes -->` become speaker notes.
+  `<!-- notes -->` become speaker notes — and round-trip as **comments, in
+  place**: template slides carry their authored source in the marker, so `pull`
+  re-emits each comment where it was written instead of one merged trailing
+  blob. Speaker notes edited live in Slides come back as one extra trailing
+  comment.
 - **Internal links:** `[text](#slide-id)` becomes a native Slides link to the
   slide whose `id:` (or title slug) is `slide-id`.
 
@@ -105,6 +131,9 @@ may have its own frontmatter (`id:`, `template:`, `layout:`).
 Select per slide via `template:` — native styled boxes, no in-deck templates:
 `dark`/`title`, `appendix`, `question`/`label`, `topic`, `content`,
 `graph`/`full` (single full-bleed image), `prompt`/`code` (verbatim monospace).
+Title cards (`dark`/`title`/`appendix`) render body lines as a small dimmed
+**byline** beneath the headline (e.g. `Project · Presenter`) — they still have
+no linkable body region.
 Slides with no `template:` fall back to a generative path (section /
 title+body / table / image) that also brands the background + IBM Plex.
 
@@ -131,6 +160,11 @@ Releases publish to PyPI via Trusted Publishing (OIDC) on a `v*.*.*` tag — see
   — this is a content mapper, not a CSS renderer.
 - On `pull`, the slide model holds a single image, so a slide with multiple
   images keeps the first; image `contentUrl`s from foreign decks are ephemeral.
+- Verbatim-source markers are seeded at push time, so comment preservation
+  applies from the first push with v0.2+ (older slides re-render once: the
+  content hash is now over the authored source). Generative-path slides (no
+  `template:`) still merge comments into a single trailing comment on pull,
+  since their live Slides edits — not the marker — are the source of truth.
 
 ## License
 

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

@@ -10,5 +10,7 @@ slidesync.egg-info/dependency_links.txt
 slidesync.egg-info/entry_points.txt
 slidesync.egg-info/requires.txt
 slidesync.egg-info/top_level.txt
+tests/test_comment_preservation.py
 tests/test_markdown.py
-tests/test_pull.py
+tests/test_pull.py
+tests/test_sync_drift.py

slidesync-0.3.0/tests/test_comment_preservation.py

@@ -0,0 +1,132 @@
+"""Comments round-trip as comments, in place — not one merged speaker-notes blob.
+
+The authored body of every non-custom slide is stored (base64) in the `s2g`
+marker; `pull` re-emits it verbatim, so comment positions, prompt fences, and
+formatting quirks all survive. Speaker notes edited live in Slides surface as
+one extra trailing comment instead of silently replacing the authored ones.
+"""
+
+from slidesync._sync import (
+    STYLES,
+    _marker,
+    _read_marker,
+    _slide_from_marker,
+    build_slides,
+    split_slides,
+    to_slidev,
+)
+
+DECK = """---
+theme: seriph
+---
+
+---
+template: topic
+id: thread-finding
+---
+
+# Compression hurts recall
+## FINDING
+
+<!-- framing: say this slowly -->
+
+- one solid point
+
+![self-titled figure](../figures/fig.png)
+
+<!-- data-source: scripts/fig.py -->
+
+---
+template: prompt
+id: appendix-prompt-monitor
+---
+
+## MONITOR PROMPT
+
+```text
+You are a monitor. Score 0-100 in <verdict></verdict>.
+```
+
+---
+template: dark
+id: weekly
+---
+
+# 2026/06/12
+## WEEKLY UPDATE
+
+Touchstone · Daniel Hails
+"""
+
+
+def _slide(key):
+    return next(s for s in build_slides(split_slides(DECK)) if s.key == key)
+
+
+def _roundtrip(slide, notes=None):
+    marker = _read_marker(_marker(slide))
+    return _slide_from_marker(marker, slide.notes if notes is None else notes)
+
+
+def test_marker_parses_despite_comment_terminators_in_src():
+    # The authored body contains comments (`-->`) and braces; base64 keeps the
+    # marker JSON immune to `}` + `-->` sequences that would truncate the
+    # delimiter-based MARKER_RE match mid-string.
+    slide = _slide("thread-finding")
+    slide.src += "\n<!-- edge: {brace} -->"
+    marker = _read_marker(_marker(slide))
+    assert marker.get("src"), "marker should carry the authored source"
+
+
+def test_comments_survive_in_place_not_merged():
+    md = to_slidev(_roundtrip(_slide("thread-finding")))
+    assert md.count("<!--") == 2, "each comment stays its own comment"
+    assert md.index("framing: say this slowly") < md.index("one solid point")
+    assert md.index("data-source: scripts/fig.py") > md.index("../figures/fig.png")
+
+
+def test_prompt_fence_survives_pull():
+    md = to_slidev(_roundtrip(_slide("appendix-prompt-monitor")))
+    assert "You are a monitor." in md  # previously lost: marker had no body
+
+
+def test_unchanged_notes_are_not_duplicated():
+    slide = _slide("thread-finding")
+    # The notes shape flattens paragraphs to spaces when read back.
+    flattened = " ".join(slide.notes.split())
+    md = to_slidev(_roundtrip(slide, notes=flattened))
+    assert md.count("<!--") == 2
+
+
+def test_live_notes_edit_appends_trailing_comment():
+    slide = _slide("thread-finding")
+    md = to_slidev(_roundtrip(slide, notes=slide.notes + "\nadded in slides"))
+    assert md.count("<!--") == 3
+    assert md.rstrip().endswith("-->") and "added in slides" in md
+
+
+def _rendered(slide):
+    slide.object_id = "s2g_aaaaaaaaaa_bbbbbbbbbb"
+    return _styled(slide)
+
+
+def _styled(slide):
+    from slidesync._sync import _styled_requests
+
+    return _styled_requests(slide, STYLES["dark"], None, None)
+
+
+def test_dark_template_renders_body_as_byline():
+    reqs = _rendered(_slide("weekly"))
+    boxes = [r["createShape"]["objectId"] for r in reqs if "createShape" in r]
+    assert "s2g_aaaaaaaaaa_bbbbbbbbbb_by" in boxes
+    texts = [r["insertText"]["text"] for r in reqs if "insertText" in r]
+    assert "Touchstone · Daniel Hails" in texts
+
+
+def test_dark_template_without_body_has_no_byline():
+    slide = _slide("weekly")
+    slide.paras = []
+    reqs = _rendered(slide)
+    boxes = [r["createShape"]["objectId"] for r in reqs if "createShape" in r]
+    assert not [b for b in boxes if b.endswith("_by")]

slidesync-0.3.0/tests/test_sync_drift.py

@@ -0,0 +1,67 @@
+"""Offline tests for drift detection: comment shaping, text-line extraction
+parity (markdown vs native), and the three-way classification."""
+
+from slidesync._sync import (
+    classify_drift,
+    shape_comments,
+    text_lines_md,
+    text_lines_native,
+)
+
+RAW_COMMENTS = [
+    {"id": "c1",
+     "anchor": '{"type":"page","uid":1,"pages":["s2g_aaaaaaaaaa_bbbbbbbbbb"]}',
+     "author": {"displayName": "Daniel Hails"},
+     "content": "This is obviously dodgy. To debug",
+     "modifiedTime": "2026-06-12T15:00:00Z",
+     "replies": [
+         {"author": {"displayName": "Ted"}, "content": "agree"},
+         {"author": {"displayName": "Daniel Hails"}, "content": ""},  # resolve action
+     ]},
+    {"id": "c2", "anchor": "not json", "author": {}, "content": "file-level",
+     "resolved": True},
+]
+
+
+def test_shape_comments_extracts_page_author_replies():
+    a, b = shape_comments(RAW_COMMENTS)
+    assert a["page"] == "s2g_aaaaaaaaaa_bbbbbbbbbb"
+    assert a["author"] == "Daniel Hails" and not a["resolved"]
+    assert a["replies"] == [{"author": "Ted", "content": "agree"}]
+    assert b["page"] is None and b["resolved"] is True
+
+
+def _native(texts):
+    """A native slide with one text box per entry, stacked top to bottom."""
+    els = []
+    for i, text in enumerate(texts):
+        els.append({"transform": {"translateY": i * 914400, "translateX": 0},
+                    "shape": {"text": {"textElements": [
+                        {"paragraphMarker": {}},
+                        {"textRun": {"content": text, "style": {}}}]}}})
+    return {"objectId": "s", "pageElements": els}
+
+
+def test_md_and_native_text_lines_agree_for_a_styled_slide():
+    md = "# 2026/06/15\n## RELIABLE MONITORS\n\nWeekly Update\n<!-- a note -->"
+    # live render stacks kicker above headline — order differs, content matches
+    native = _native(["RELIABLE MONITORS", "2026/06/15", "Weekly Update"])
+    assert text_lines_md(md) == text_lines_native(native)
+
+
+def test_md_text_lines_include_verbatim_fences_and_skip_comments():
+    md = "## PROMPT\n```text\nYou are a monitor.\n```\n<!-- hidden -->"
+    lines = text_lines_md(md)
+    assert "You are a monitor." in lines
+    assert not any("hidden" in line for line in lines)
+
+
+def test_classify_drift_three_way():
+    base, local, live = ["a"], ["a"], ["a"]
+    assert classify_drift(base, local, live) == "clean"
+    assert classify_drift(base, ["b"], live) == "local-edit"
+    assert classify_drift(base, local, ["b"]) == "live-drift"
+    assert classify_drift(base, ["b"], ["c"]) == "conflict"
+    assert classify_drift(base, ["b"], ["b"]) == "converged"
+    assert classify_drift(None, ["a"], ["a"]) == "clean"
+    assert classify_drift(None, ["a"], ["b"]) == "drift-no-base"