glideshow 0.1.2__py3-none-any.whl

glideshow/history.py

@@ -0,0 +1,210 @@
+"""Version history in git: saves are committed (debounced) with a message naming what changed, pushed to origin when
+there is one (the backup), listed for File → Version history."""
+
+import os, shutil, re, sys, threading
+from pathlib import Path
+
+# History: when the deck lives in a git repo, saves are committed (deck.html + assets/), at most one commit per
+# GLIDESHOW_GIT_DELAY seconds of quiet (30 by default), with a message naming the first changed slide and its new words.
+GIT = {"on": True, "push": True, "delay": float(os.environ.get("GLIDESHOW_GIT_DELAY") or 30), "timer": None, "lock": __import__("threading").Lock()}
+
+
+def git(deck: Path, *args):
+    import subprocess
+    return subprocess.run(["git", "-C", str(deck), *args], capture_output=True, text=True)
+
+
+def commit_message(old: str, new: str) -> str:
+    if not old:
+        m = re.search(r"<title>(.*?)</title>", new, re.S)
+        return f"deck: {(m.group(1).strip() if m else '') or 'first save'}"[:72]
+    split = lambda h: [x.split(">", 1)[-1] for x in re.split(r"<section\b", h.split('class="slides"', 1)[-1])[1:]]   # each slide's inside
+    words = lambda h: re.sub(r"\s+", " ", re.sub(r"<[^>]+>", " ", re.sub(r"<(svg|script|style)\b.*?</\1>", " ", h, flags=re.S))).split()
+    a, b = split(old), split(new)
+    # which slides changed, came or went, matched by content (a slide inserted early doesn't make every later one "changed")
+    import difflib
+    changed, added, removed, first, gone_at = [], [], 0, None, None
+    for tag, i1, i2, j1, j2 in difflib.SequenceMatcher(a=a, b=b, autojunk=False).get_opcodes():
+        if tag == "equal": continue
+        pairs = min(i2 - i1, j2 - j1) if tag == "replace" else 0
+        for k in range(pairs):
+            changed.append(j1 + k); first = first if first is not None else (i1 + k, j1 + k)
+        added += range(j1 + pairs, j2); removed += (i2 - i1) - pairs
+        if (i2 - i1) > pairs and gone_at is None: gone_at = i1 + pairs
+        if first is None and j2 > j1 + pairs: first = (None, j1 + pairs)
+    if first is None: return f"slide {gone_at + 1} removed" + (f" (and {removed - 1} more)" if removed > 1 else "") if removed else "deck: edit"
+    before, after = words(a[first[0]]) if first[0] is not None else [], words(b[first[1]])
+    fresh = " ".join(([w for w in after if w not in before] or after)[:6]) or "edit"
+    if len(changed) == 1 and not added and not removed: return f"slide {changed[0] + 1}: {fresh}"[:72]
+    nums = lambda xs: ", ".join(str(x + 1) for x in xs[:4]) + (" …" if len(xs) > 4 else "")
+    parts = ([f"slide{'s' if len(changed) > 1 else ''} {nums(changed)}"] if changed else []) + ([f"new slide{'s' if len(added) > 1 else ''} {nums(added)}"] if added else []) \
+        + ([f"{removed} removed"] if removed else [])
+    return f"{' + '.join(parts)}: {fresh}"[:72]
+
+
+def commit_outside(deck: Path, saved: str):
+    """deck.html was changed outside the editor. The editor's last save, if still waiting for its commit, is committed first
+    (from memory, as it was), so each side's change is its own version; the outside edit is committed once the file has
+    been quiet for GLIDESHOW_OUTSIDE_DELAY seconds (3), so an agent's run of writes makes one version, not dozens."""
+    if GIT["timer"] and GIT["timer"].is_alive():
+        GIT["timer"].cancel(); GIT["timer"] = None
+        commit_text(deck, saved)
+    if GIT.get("outside"): GIT["outside"].cancel()
+    GIT["outside"] = threading.Timer(float(os.environ.get("GLIDESHOW_OUTSIDE_DELAY") or 3), commit_now, [deck, "outside the editor: "]); GIT["outside"].daemon = True; GIT["outside"].start()
+
+
+def commit_text(deck: Path, html: str):
+    """Commit this text as deck.html without touching the file on disk (git's index, not the working tree)."""
+    import subprocess
+    with GIT["lock"]:
+        if git(deck, "rev-parse", "--is-inside-work-tree").stdout.strip() != "true": return
+        top = Path(git(deck, "rev-parse", "--show-toplevel").stdout.strip())
+        rel = (deck / "deck.html").resolve().relative_to(top.resolve()).as_posix()
+        sha = subprocess.run(["git", "-C", str(deck), "hash-object", "-w", "--stdin"], input=html, capture_output=True, text=True).stdout.strip()
+        if not sha: return
+        git(top, "update-index", "--add", "--cacheinfo", f"100644,{sha},{rel}")
+        git(top, "commit", "-q", "-m", commit_message(git(deck, "show", f"HEAD:{rel}").stdout, html))
+
+
+def commit_now(deck: Path, label: str = ""):
+    with GIT["lock"]:
+        if git(deck, "rev-parse", "--is-inside-work-tree").stdout.strip() != "true":
+            return
+        top = Path(git(deck, "rev-parse", "--show-toplevel").stdout.strip())
+        rel = (deck / "deck.html").resolve().relative_to(top.resolve()).as_posix()
+        old = git(deck, "show", f"HEAD:{rel}").stdout
+        paths = ["deck.html"] + (["assets"] if any(f.is_file() for f in (deck / "assets").rglob("*")) else []) + (["comments.json"] if (deck / "comments.json").exists() else [])   # git refuses an empty pathspec
+        git(deck, "add", "--", *paths)
+        made = git(deck, "commit", "-q", "-m", (label + commit_message(old, (deck / "deck.html").read_text()))[:72], "--", *paths).returncode == 0
+    if made: sync(deck)   # backup: the commit goes to origin too
+
+
+
+def commit_library(home: Path, message: str):
+    """A library change (a deck moved, a folder made or removed): commit everything under $GLIDESHOW_HOME, then push."""
+    if not GIT["on"] or git(home, "rev-parse", "--is-inside-work-tree").stdout.strip() != "true":
+        return
+    with GIT["lock"]:
+        git(home, "add", "-A", "--", ".")
+        made = git(home, "commit", "-q", "-m", message[:72]).returncode == 0
+    if made: sync(home)
+
+
+def commit_outside_library(home: Path, skip: Path | None = None) -> bool:
+    """What changed in the library outside the editor (an agent editing a deck that isn't open, a new deck folder, a
+    file deleted by hand): one commit, so syncing, which waits for a clean tree, never stalls on it. Files over 50 MB
+    are left out (GitHub refuses them, which would stall the push instead). `skip` is the open deck's deck.html: its
+    outside edits are commit_outside's, named by slide, even when this runs in the second before that one notices."""
+    if not GIT["on"] or git(home, "rev-parse", "--is-inside-work-tree").stdout.strip() != "true": return False
+    with GIT["lock"]:
+        paths = [line[3:].split(" -> ")[-1].strip('"') for line in git(home, "status", "--porcelain").stdout.splitlines()]
+        big = [p for p in paths if (home / p).is_file() and (home / p).stat().st_size > 50_000_000]
+        paths = [p for p in paths if p not in big and Path(p).name not in (".DS_Store", "Thumbs.db")]   # Finder's / Explorer's litter
+        try: mine = skip.resolve().relative_to(home.resolve()).as_posix() if skip else None
+        except ValueError: mine = None
+        paths = [p for p in paths if p != mine]
+        if big: print(f"git: not committing files over 50 MB: {', '.join(big[:3])}")
+        if not paths: return False
+        deck_of = lambda p: next((q.as_posix() for q in [Path(p), *Path(p).parents] if q != Path(".") and (home / q / "deck.html").is_file()), Path(p).parts[0])
+        names = sorted({deck_of(p) for p in paths})
+        git(home, "add", "-A", "--", *paths)
+        made = git(home, "commit", "-q", "-m", ("outside the editor: " + ", ".join(names[:3]) + (" …" if len(names) > 3 else ""))[:72]).returncode == 0
+    return made
+
+
+def prune_emptied(repo: Path, before: str):
+    """Folders that commits brought in from elsewhere emptied (a deck removed online): git takes away the files but leaves
+    the folders, with any empty ones inside (a deck's assets/), and Home would show them as empty folders. Only folders
+    the pulled commits removed files from, and only once nothing is left in them but empty folders."""
+    gone = git(repo, "diff", "--name-only", "--diff-filter=D", before, "HEAD").stdout.split("\n")
+    for d in sorted({(repo / f).parent for f in gone if f}, key=lambda p: -len(p.parts)):
+        while d != repo and repo in d.parents and d.is_dir() and not any(f.is_file() or f.is_symlink() for f in d.rglob("*")):
+            shutil.rmtree(d, ignore_errors=True); d = d.parent
+
+
+# A deck.html both sides changed merges slide by slide and box by box (glideshow/merge.py, the rules of the editor and of
+# glideshow.org), not line by line: unrelated edits sit on nearby lines of a deck, and a line merge where this Mac wins
+# could drop a web edit. In a rebase the Mac's commit being replayed is git's "theirs" (%B), so the driver is told it is
+# mine. A deck it can't read as slides is left to git's line merge.
+DECK_MERGE = ("-c", "merge.glideshow-deck.name=Glideshow deck merge", "-c", f'merge.glideshow-deck.driver="{sys.executable}" "{Path(__file__).with_name("merge.py")}" %O %A %B theirs')   # (by its path: it needs nothing else)
+
+
+def deck_merge_attributes(repo: Path):
+    """deck.html files use the deck merge (in .git/info/attributes: nothing for the library to commit)."""
+    p = Path(repo) / git(repo, "rev-parse", "--git-path", "info/attributes").stdout.strip()
+    line = "deck.html merge=glideshow-deck"
+    if not p.exists() or line not in p.read_text().splitlines():
+        p.parent.mkdir(parents=True, exist_ok=True)
+        with p.open("a") as f: f.write(line + "\n")
+
+
+def sync(repo: Path) -> str:
+    """Trade commits with origin: bring in what was committed elsewhere (the online editor, docs/self-hosting.md) under the
+    local commits, then push those. Only with nothing uncommitted (a save waiting for its commit, or a hand edit), so a
+    pull never writes into a file being worked on; the next try comes after the commit. Returns what happened."""
+    if not GIT["push"] or git(repo, "remote", "get-url", "origin").returncode: return "no origin"
+    with GIT["lock"]:
+        if git(repo, "status", "--porcelain", "--untracked-files=no").stdout.strip(): return "uncommitted changes"
+        deck_merge_attributes(repo)
+        branch = git(repo, "rev-parse", "--abbrev-ref", "HEAD").stdout.strip()
+        if git(repo, "fetch", "-q", "origin", branch).returncode: return "offline"
+        behind, ahead = (int(n) for n in git(repo, "rev-list", "--left-right", "--count", "FETCH_HEAD...HEAD").stdout.split() or (0, 0))
+        before = git(repo, "rev-parse", "HEAD").stdout.strip()
+        if behind:
+            if git(repo, *DECK_MERGE, "rebase", "-q", "FETCH_HEAD").returncode:
+                # The same lines changed in both places: this Mac's version wins where they overlap (the other one stays in
+                # the history), so the two never stay apart, which would stop the backup.
+                git(repo, "rebase", "--abort")
+                if git(repo, *DECK_MERGE, "rebase", "-q", "-X", "theirs", "FETCH_HEAD").returncode:
+                    git(repo, "rebase", "--abort"); print("git: couldn't bring in commits from origin; local commits kept"); return "conflict"
+                print("git: an edit made elsewhere overlapped this Mac's; this Mac's version was kept (the other is in the history)")
+            prune_emptied(repo, before)
+        if ahead:
+            r = git(repo, "push", "-q", "origin", f"HEAD:{branch}")
+            if r.returncode: print(f"git push failed (kept locally): {r.stderr.strip()[:200]}"); return "push failed"
+        return f"in {behind}, out {ahead}"
+
+
+def schedule_commit(deck: Path):
+
+    if not GIT["on"]:
+        return
+    if GIT["timer"]: GIT["timer"].cancel()
+    GIT["timer"] = threading.Timer(GIT["delay"], commit_now, [deck]); GIT["timer"].daemon = True; GIT["timer"].start()
+
+
+def history(deck: Path, slide=None, limit=100) -> list:
+    if git(deck, "rev-parse", "--is-inside-work-tree").stdout.strip() != "true":
+        return []
+    out = []
+    for line in git(deck, "log", f"-{limit}", "--format=%H%x09%ct%x09%an%x09%s", "--", "deck.html").stdout.splitlines():
+        h, t, who, msg = line.split("\t", 3)
+        out.append({"rev": h, "time": int(t), "author": who, "message": msg})
+    names = {}   # named versions: annotated tags under refs/tags/slides/
+    for line in git(deck, "for-each-ref", "refs/tags/slides", "--format=%(*objectname)%09%(contents:subject)").stdout.splitlines():
+        rev, _, name = line.partition("\t")
+        if rev: names[rev] = name
+    for c in out: c["name"] = names.get(c["rev"], "")
+    web, pushed = github_url(deck), set(git(deck, "rev-list", "-n", "1000", "@{upstream}").stdout.split())
+    for c in out: c["url"] = f"{web}/commit/{c['rev']}" if web and c["rev"] in pushed else ""   # only commits already on GitHub
+    if slide:   # keep the commits where slide N's <section> differs from the commit before it
+        sec = lambda h: (re.split(r"<section\b", h.split('class="slides"', 1)[-1])[1:] + [""] * slide)[slide - 1]
+        texts = [git(deck, "show", f"{c['rev']}:./deck.html").stdout for c in out] + [""]
+        out = [c for i, c in enumerate(out) if sec(texts[i]) != sec(texts[i + 1])]
+    return out
+
+
+def github_url(deck: Path) -> str:
+    """https://github.com/OWNER/REPO for the repo's origin when it is on GitHub (ssh or https remote), else ''."""
+    m = re.match(r"(?:git@github\.com:|https://github\.com/)([\w.-]+/[\w.-]+?)(?:\.git)?/?$", git(deck, "remote", "get-url", "origin").stdout.strip())
+    return f"https://github.com/{m.group(1)}" if m else ""
+
+
+def init_repo(deck: Path):
+
+    if git(deck, "rev-parse", "--is-inside-work-tree").stdout.strip() == "true":
+        return print(f"{deck} is already in a git repo")
+    git(deck, "init", "-q")
+    (deck / ".gitignore").write_text(".DS_Store\n*.tmp\n")
+    git(deck, "add", "-A"); git(deck, "commit", "-q", "-m", "deck: start")
+    print(f"{deck} is now a git repo; saves are committed")

glideshow/merge.py

@@ -0,0 +1,210 @@
+"""Three-way merges of deck files, by slide and by box: editor/lib/merge.js in Python, rule for rule (smoke checks that
+the two agree), for the Mac's side of a library online: history.sync pulls glideshow.org's commits under the Mac's own
+with this as git's merge of deck.html, where a line merge would mix unrelated edits that sit on nearby lines.
+
+    python glideshow/merge.py BASE OURS THEIRS [MINE]   # git's merge driver (%O %A %B): the result is written to OURS
+
+MINE names which of OURS / THEIRS keeps a box (or slide) both changed: 'theirs' in a rebase, where THEIRS is this Mac's
+commit being replayed on top of what came in. A file that can't be read as slides gets git's line merge, MINE winning
+where lines overlap."""
+import re, sys
+
+_ID = re.compile(r'\sid="[^"]*"')
+norm = lambda h: _ID.sub("", h)
+same_html = lambda a, b: a == b or norm(a) == norm(b)
+_SID = re.compile(r'^<section\b[^>]*\sdata-sid="([^"]+)"')
+sid_of = lambda h: (m.group(1) if (m := _SID.match(h)) else "")
+
+
+def merge_lists(base, mine, theirs, key, both=lambda b, m, t: m, val=lambda x: x):
+    """Keyed lists, three ways (merge.js mergeLists): (list, clash, order)."""
+    same = lambda a, b: a is not None and b is not None and same_html(val(a), val(b))
+    B, M, T = ({key(h): h for h in l} for l in (base, mine, theirs))
+    out, clash = {}, []
+    for i in dict.fromkeys([*M, *T, *B]):
+        b, m, t = B.get(i), M.get(i), T.get(i)
+        if m is not None and t is not None:
+            if same(m, b): out[i] = t
+            elif same(t, b) or same(t, m): out[i] = m
+            else: out[i] = both(b, m, t); clash.append(i)
+        elif m is not None:
+            if b is None or not same(m, b): out[i] = m
+        elif t is not None:
+            if b is None or not same(t, b): out[i] = t
+    ids = lambda l: [key(h) for h in l]
+    moved = [i for i in ids(mine) if i in B] != [i for i in ids(base) if i in M]
+    lead, other = (mine, theirs) if moved else (theirs, mine)
+    order = [i for i in ids(lead) if i in out]
+    oids = ids(other)
+    for n, i in enumerate(oids):
+        if i not in out or i in order: continue
+        prev = next((x for x in reversed(oids[:n]) if x in order), None)
+        order.insert(order.index(prev) + 1 if prev is not None else 0, i)
+    order += [i for i in out if i not in order]
+    return [out[i] for i in order], [i for i in clash if i in order], order
+
+
+VOID = {"area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"}
+TOKEN = re.compile(r"""<!--[\s\S]*?-->|<(script|style|textarea|title|xmp|noscript|template)\b(?:[^>"']|"[^"]*"|'[^']*')*>[\s\S]*?</\1\s*>|<(/?)([a-zA-Z][\w:-]*)\b(?:[^>"']|"[^"]*"|'[^']*')*?(/?)>""")
+OPEN = re.compile(r"""^\s*<([a-zA-Z][\w-]*)\b(?:[^>"']|"[^"]*"|'[^']*')*>""")
+CLOSE = re.compile(r"</\s*([a-zA-Z][\w-]*)\s*>\s*$")
+
+
+def parts(html):
+    """An element's opening tag, top-level children (each whole) and closing tag; None when the tags don't pair up."""
+    o, c = OPEN.match(html), CLOSE.search(html)
+    if not o or not c or c.group(1).lower() != o.group(1).lower(): return None
+    body, kids = html[len(o.group(0)):len(html) - len(c.group(0))], []
+    depth, start, last = 0, -1, 0
+    def text(a, z):
+        t = body[a:z].strip()
+        if t: kids.append(t)
+    for m in TOKEN.finditer(body):
+        at, end = m.start(), m.end()
+        whole = m.group(0).startswith("<!--") or m.group(1) or (not m.group(2) and (m.group(4) or m.group(3).lower() in VOID))
+        if depth == 0: text(last, at)
+        if whole:
+            if depth == 0: kids.append(m.group(0)); last = end
+            continue
+        if m.group(2):
+            depth -= 1
+            if depth < 0: return None
+            if depth == 0: kids.append(body[start:end]); last = end
+        else:
+            if depth == 0: start = at
+            depth += 1
+    if depth: return None
+    text(last, len(body))
+    return {"open": o.group(0).strip(), "kids": kids, "close": c.group(0).strip()}
+
+
+_KID_ID = re.compile(r"""^<[a-zA-Z][\w-]*\b(?:[^>"']|"[^"]*"|'[^']*')*?\sid="([^"]+)\"""")
+_KID_TAG = re.compile(r"""^<([a-zA-Z][\w-]*)\b(?:[^>"']|"[^"]*"|'[^']*')*?(?:\sclass="([^"]*)")?""")
+
+
+def keyed(kids):
+    seen, out = {}, []
+    for h in kids:
+        if m := _KID_ID.match(h): out.append(("id:" + m.group(1), h)); continue
+        t = _KID_TAG.match(h)
+        k = (t.group(1).lower() + "." + (t.group(2) or "")) if t and t.group(1) else "#text"
+        n = seen.get(k, 0); seen[k] = n + 1; out.append((f"{k}#{n}", h))
+    return out
+
+
+def merge_boxes(b, m, t, note=None):
+    """One slide both sides changed, box by box (merge.js mergeBoxes). note['lost']: something of theirs gave way."""
+    note = note if note is not None else {}
+    note["lost"] = True
+    B, M, T = (parts(b) if b is not None else None), parts(m), parts(t)
+    if not B or not M or not T or re.search(r"<section\b", "".join(B["kids"] + M["kids"] + T["kids"]), re.I): return m
+    bk = keyed(B["kids"]); base = dict(bk)
+    def match(side):
+        out = keyed(side["kids"]); have = {k for k, _ in out}; free = [x for x in bk if x[0] not in have]; unmatched = 0; res = []
+        for k, h in out:
+            if k in base: res.append((k, h)); continue
+            i = next((j for j, (_, bh) in enumerate(free) if norm(bh) == norm(h)), -1)
+            if i >= 0: res.append((free.pop(i)[0], h)); continue
+            unmatched += 1; res.append((k, h))
+        got = {k for k, _ in res}
+        return res, len(bk) > 1 and sum(k not in got for k, _ in bk) > len(bk) / 2 and unmatched > 0
+    mm, ms = match(M); tt, ts = match(T)
+    if ms or ts: return m
+    lst, clash, _ = merge_lists(bk, mm, tt, lambda x: x[0], val=lambda x: x[1])
+    same = lambda a, b: same_html(a, b)
+    open_ = T["open"] if same(M["open"], B["open"]) else M["open"]
+    note["lost"] = bool(clash) or (not same(M["open"], B["open"]) and not same(T["open"], B["open"]) and not same(M["open"], T["open"]))
+    return f"{open_}\n" + "\n".join("  " + h for _, h in lst) + f"\n{M['close']}"
+
+
+_SLIDE = re.compile(r"""<!--[\s\S]*?-->|<(script|style|textarea|title|xmp|noscript|template)\b[\s\S]*?</\1\s*>|<section\b(?:[^>"']|"[^"]*"|'[^']*')*>|</section\s*>""", re.I)
+
+
+def split_deck(html):
+    slides, depth, start, first, end = [], 0, -1, -1, -1
+    for m in _SLIDE.finditer(html):
+        if m.group(1) or m.group(0).startswith("<!--"): continue
+        if m.group(0)[1] == "/":
+            depth -= 1
+            if depth < 0: return None
+            if not depth: slides.append(html[start:m.end()]); end = m.end()
+        else:
+            if not depth:
+                start = m.start()
+                if first < 0: first = start
+            depth += 1
+    if depth or first < 0: return None
+    return {"head": html[:first], "slides": slides, "tail": html[end:]}
+
+
+def _hash(t):   # merge.js hashStr (FNV-1a, 32-bit, base 36)
+    h = 2166136261
+    for ch in t:
+        h = ((h ^ ord(ch)) * 16777619) & 0xFFFFFFFF
+    out, digits = "", "0123456789abcdefghijklmnopqrstuvwxyz"
+    while True:
+        h, r = divmod(h, 36); out = digits[r] + out
+        if not h: return out
+
+
+_INNER_SID = re.compile(r'<section\b[^>]*\sdata-sid="([^"]+)"')
+def _print(h): return re.sub(r"\s+", " ", re.sub(r">\s+<", "><", re.sub(r'\sdata-sid="[^"]*"', "", norm(h)))).strip()
+def _own_key(h):
+    if s := sid_of(h): return s
+    m = _INNER_SID.search(h); return "stack:" + m.group(1) if m else ""
+
+
+def slide_keys(lists):
+    """merge.js slideKeys: ids, or content (matched to an id only when unambiguous)."""
+    owners, loose = {}, [dict() for _ in lists]
+    for i, l in enumerate(lists):
+        for h in l:
+            k, f = _own_key(h), _print(h)
+            if k: owners.setdefault(f, set()).add(k)
+            else: loose[i][f] = loose[i].get(f, 0) + 1
+    sure = lambda f: next(iter(owners[f])) if len(owners.get(f, ())) == 1 and all(m.get(f, 0) <= 1 for m in loose) else ""
+    out = []
+    for l in lists:
+        seen, row = {}, []
+        for h in l:
+            if k := _own_key(h): row.append((k, h)); continue
+            f = _print(h)
+            if s := sure(f): row.append((s, h)); continue
+            n = seen.get(f, 0); seen[f] = n + 1; row.append((f"c:{_hash(f)}:{n}", h))
+        out.append(row)
+    return out
+
+
+def merge_decks(base, mine, theirs):
+    """Whole deck files (merge.js mergeDecks): {'html', 'both'}, or None when one can't be read as slides."""
+    B, M, T = split_deck(base) if base else None, split_deck(mine), split_deck(theirs)
+    if not M or not T or (base and not B): return None
+    kb, km, kt = slide_keys([B["slides"] if B else [], M["slides"], T["slides"]])
+    lost = []
+    def both(b, m, t):
+        n = {"lost": True}
+        h = merge_boxes(b[1] if b else None, m[1], t[1], n) if sid_of(m[1]) else m[1]
+        if n["lost"]: lost.append(m[0])
+        return (m[0], h)
+    lst, _, order = merge_lists(kb, km, kt, lambda x: x[0], both, lambda x: x[1])
+    third = lambda b, m, t: t if (b is not None and same_html(m, b)) else m
+    html = third(B["head"] if B else None, M["head"], T["head"]) + "\n\n".join(h for _, h in lst) + third(B["tail"] if B else None, M["tail"], T["tail"])
+    return {"html": html, "both": [order.index(i) + 1 for i in lost if i in order]}
+
+
+def main(argv):
+    base, ours, theirs = argv[1:4]
+    mine = argv[4] if len(argv) > 4 else "ours"
+    read = lambda p: open(p, encoding="utf-8").read()
+    o, a, b = read(base), read(ours), read(theirs)
+    r = merge_decks(o, b, a) if mine == "theirs" else merge_decks(o, a, b)
+    if r is None:   # not slides: git's line merge, mine winning where lines overlap (as history.sync did before)
+        import subprocess
+        return 1 if subprocess.run(["git", "merge-file", "-q", "--theirs" if mine == "theirs" else "--ours", ours, base, theirs]).returncode < 0 else 0
+    with open(ours, "w", encoding="utf-8") as f: f.write(r["html"])
+    if r["both"]: print(f"glideshow: deck merged; slide{'s' if len(r['both']) > 1 else ''} {', '.join(map(str, r['both']))} changed on both sides, this Mac's version kept", file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))

glideshow/osutil.py

@@ -0,0 +1,44 @@
+"""What differs by operating system: the Trash, showing a file in the file manager, and where fonts are installed."""
+
+import datetime, os, shutil, subprocess, sys, time
+from pathlib import Path
+from urllib.parse import quote
+
+
+def trash(p: Path) -> Path:
+    """Move a deck folder to the Trash (macOS), the freedesktop trash (Linux) or, elsewhere, $GLIDESHOW_HOME/.trash.
+    GLIDESHOW_TRASH overrides (tests use a temp dir)."""
+    stamp = f"{p.name}-{int(time.time())}"
+    if os.environ.get("GLIDESHOW_TRASH"):
+        d = Path(os.environ["GLIDESHOW_TRASH"])
+    elif sys.platform == "darwin":
+        d = Path.home() / ".Trash"
+    elif sys.platform.startswith("linux"):
+        base = Path(os.environ.get("XDG_DATA_HOME") or Path.home() / ".local" / "share") / "Trash"
+        (base / "info").mkdir(parents=True, exist_ok=True); (base / "files").mkdir(parents=True, exist_ok=True)
+        (base / "info" / f"{stamp}.trashinfo").write_text(
+            f"[Trash Info]\nPath={quote(str(p.resolve()))}\nDeletionDate={datetime.datetime.now().strftime('%Y-%m-%dT%H:%M:%S')}\n")
+        d = base / "files"
+    else:
+        d = p.parent / ".trash"
+    d.mkdir(parents=True, exist_ok=True)
+    dst = d / stamp
+    shutil.move(str(p), dst)
+    return dst
+
+
+def reveal(p: Path) -> None:
+    """Show the file in Finder / Explorer / the default file manager."""
+    if sys.platform == "darwin": subprocess.run(["open", "-R", str(p)], check=False)
+    elif sys.platform == "win32": subprocess.run(["explorer", "/select,", str(p)], check=False)
+    else: subprocess.run(["xdg-open", str(p.parent)], check=False)
+
+
+def font_dirs() -> list:
+    """Folders holding fonts installed on this computer, for the font menu's "Your fonts"."""
+    home = Path.home()
+    if sys.platform == "darwin":
+        return [home / "Library" / "Fonts", Path("/Library/Fonts")]
+    if sys.platform == "win32":
+        return [Path(os.environ.get("WINDIR", "C:/Windows")) / "Fonts", Path(os.environ.get("LOCALAPPDATA", home)) / "Microsoft" / "Windows" / "Fonts"]
+    return [home / ".local" / "share" / "fonts", home / ".fonts", Path("/usr/share/fonts"), Path("/usr/local/share/fonts")]