fix(annotator): execute review-canvas JS via Blocks head and add edit autosave

The canvas <script> was injected with gr.HTML, which Gradio mounts via
innerHTML — browsers never execute scripts inserted that way, so the
Review & Edit canvas was dead in every browser. Serve it through
gr.Blocks(head=...) instead.

Autosave checkpoints every annotated page to data/working_set/autosave/
on each mutating action (canonical label JSON, per-box status preserved
for exact resume; pages with unreviewed machine boxes stay
audit_status=machine). Disabled automatically off-repo (HF Space).

app.py

@@ -1,6 +1,8 @@
 import base64
 import hashlib
 import json
+import os
+import re
 import tempfile
 import uuid
 import zipfile
@@ -404,6 +406,33 @@ def detect_page_api(pdf_file, page_number=1, dpi=DETECTION_DPI, conf=0.25):
 # ---------------------------------------------------------------------------
 _LABEL_DISPLAY_DPI = 100  # the Review tab canvas coordinate space
 
+# Autosave: when running from the repo checkout (not the HF Space), every
+# annotation change is checkpointed to disk so a browser refresh/crash loses
+# nothing. Files go to a staging dir, NOT the canonical labels dir — the
+# canonical ground truth is only ever written via merge_labels.py.
+_REPO_WORKING_SET = Path(__file__).resolve().parents[2] / "data" / "working_set"
+
+
+def _resolve_autosave_dir():
+    env = os.environ.get("FACADE_AUTOSAVE_DIR")
+    if env:
+        p = Path(env)
+        p.mkdir(parents=True, exist_ok=True)
+        return p
+    if _REPO_WORKING_SET.is_dir():
+        p = _REPO_WORKING_SET / "autosave"
+        p.mkdir(parents=True, exist_ok=True)
+        return p
+    return None  # HF Space / standalone — autosave off
+
+
+_AUTOSAVE_DIR = _resolve_autosave_dir()
+
+
+def _slugify_doc(stem):
+    # must match scripts/annotation/common.py::doc_slug
+    return re.sub(r"[^A-Za-z0-9._-]+", "_", stem).strip("_")[:60]
+
 
 def _source_tag(ann, model_version):
     src = ann.get("source", "unknown")
@@ -414,45 +443,74 @@ def _source_tag(ann, model_version):
     return src
 
 
-def on_rv_export_labels(rv_pdf, rv_annotations):
-    """Export every page with annotations as canonical label JSONs (zipped).
+def _page_label_data(rv_pdf, page, anns, audit_status):
+    """Build one page's canonical label dict from canvas annotations.
 
     Coordinates are converted from the 100-DPI canvas space to PDF points so
-    labels are DPI-independent and merge with other sources downstream.
+    labels are DPI-independent and merge with other sources downstream. The
+    per-box "status" key is an extra field for exact import round-trips.
     """
+    mv = get_model_version()
+    boxes, rejected = [], []
+    for ann in anns:
+        entry = {
+            "id": ann.get("uid") or str(uuid.uuid4()),
+            "x1_pt": round(px_to_pt(ann["x1"], _LABEL_DISPLAY_DPI), 3),
+            "y1_pt": round(px_to_pt(ann["y1"], _LABEL_DISPLAY_DPI), 3),
+            "x2_pt": round(px_to_pt(ann["x2"], _LABEL_DISPLAY_DPI), 3),
+            "y2_pt": round(px_to_pt(ann["y2"], _LABEL_DISPLAY_DPI), 3),
+            "source": _source_tag(ann, mv),
+            "conf": round(float(ann.get("conf", 1.0)), 4),
+            "status": ann.get("status", "pending"),
+            "history": ann.get("history", []),
+        }
+        (rejected if ann.get("status") == "rejected" else boxes).append(entry)
+    return {
+        "doc": _slugify_doc(Path(rv_pdf).stem),
+        "pdf": Path(rv_pdf).name,
+        "page": int(page),
+        "page_type": "",
+        "audit_status": audit_status,
+        "audited_at": datetime.now(UTC).isoformat(),
+        "boxes": boxes,
+        "rejected_boxes": rejected,
+    }
+
+
+def _autosave(rv_pdf, rv_annotations):
+    """Checkpoint every annotated page to the autosave dir. Never raises —
+    a failed checkpoint must not break the edit that triggered it."""
+    if _AUTOSAVE_DIR is None or rv_pdf is None:
+        return
+    try:
+        out_dir = _AUTOSAVE_DIR / _slugify_doc(Path(rv_pdf).stem)
+        out_dir.mkdir(parents=True, exist_ok=True)
+        for page, anns in (rv_annotations or {}).items():
+            if not anns:
+                continue
+            # A page still holding unreviewed machine boxes is not an audit
+            unreviewed = any(
+                a.get("status", "pending") == "pending" and not str(a.get("source", "")).startswith("human")
+                for a in anns
+            )
+            data = _page_label_data(rv_pdf, page, anns, "machine" if unreviewed else "audited")
+            (out_dir / f"p{int(page):03d}.json").write_text(json.dumps(data, indent=2), encoding="utf-8")
+    except Exception as exc:
+        print(f"[autosave] checkpoint failed: {exc}")
+
+
+def on_rv_export_labels(rv_pdf, rv_annotations):
+    """Export every page with annotations as canonical label JSONs (zipped)."""
     if rv_pdf is None:
         return None, "No PDF loaded."
     pages = {p: anns for p, anns in (rv_annotations or {}).items() if anns}
     if not pages:
         return None, "No annotations to export."
     stem = Path(rv_pdf).stem
-    mv = get_model_version()
     tmp_dir = Path(tempfile.mkdtemp(prefix="labels_"))
     written = []
     for page, anns in sorted(pages.items()):
-        boxes, rejected = [], []
-        for ann in anns:
-            entry = {
-                "id": ann.get("uid") or str(uuid.uuid4()),
-                "x1_pt": round(px_to_pt(ann["x1"], _LABEL_DISPLAY_DPI), 3),
-                "y1_pt": round(px_to_pt(ann["y1"], _LABEL_DISPLAY_DPI), 3),
-                "x2_pt": round(px_to_pt(ann["x2"], _LABEL_DISPLAY_DPI), 3),
-                "y2_pt": round(px_to_pt(ann["y2"], _LABEL_DISPLAY_DPI), 3),
-                "source": _source_tag(ann, mv),
-                "conf": round(float(ann.get("conf", 1.0)), 4),
-                "history": ann.get("history", []),
-            }
-            (rejected if ann.get("status") == "rejected" else boxes).append(entry)
-        data = {
-            "doc": stem,
-            "pdf": Path(rv_pdf).name,
-            "page": int(page),
-            "page_type": "",
-            "audit_status": "audited",
-            "audited_at": datetime.now(UTC).isoformat(),
-            "boxes": boxes,
-            "rejected_boxes": rejected,
-        }
+        data = _page_label_data(rv_pdf, page, anns, "audited")
         out = tmp_dir / f"p{int(page):03d}.json"
         out.write_text(json.dumps(data, indent=2), encoding="utf-8")
         written.append(out)
@@ -498,13 +556,15 @@ def on_rv_import_labels(label_files, rv_pdf, rv_page, rv_annotations):
                         "x2": pt_to_px(box["x2_pt"], _LABEL_DISPLAY_DPI),
                         "y2": pt_to_px(box["y2_pt"], _LABEL_DISPLAY_DPI),
                         "conf": float(box.get("conf", 1.0)),
-                        "status": status,
+                        # autosave files carry per-box status for exact resume
+                        "status": "rejected" if status == "rejected" else box.get("status", status),
                         "source": box.get("source", "unknown"),
                         "history": box.get("history", []),
                     }
                 )
         rv_annotations[page] = anns
         loaded_pages.append(page)
+    _autosave(rv_pdf, rv_annotations)
     current = rv_annotations.get(rv_page, [])
     img_rgb = _render_pdf_page(rv_pdf, rv_page, dpi=100) if rv_pdf is not None and rv_page in loaded_pages else None
     return (
@@ -663,6 +723,9 @@ def on_canvas_events(events_json, rv_pdf, rv_page, rv_annotations, rv_ledger):
             )
     rv_ledger = _append_events(rv_ledger, events)
 
+    if action in ("created", "moved", "resized", "deleted"):
+        _autosave(rv_pdf, rv_annotations)
+
     canvas_json = _build_canvas_json(None, new_anns, selected=selected)
     return canvas_json, rv_annotations, rv_ledger, _build_review_df(new_anns), selected
 
@@ -699,6 +762,7 @@ def on_rv_detect(rv_pdf, rv_page, rv_annotations, rv_conf):
     ]
     rv_annotations = dict(rv_annotations)
     rv_annotations[rv_page] = annotations
+    _autosave(rv_pdf, rv_annotations)
     engine = "YOLO" if using_yolo else "OpenCV"
     return (
         _build_canvas_json(img_rgb, annotations),
@@ -752,6 +816,7 @@ def on_rv_detect_all(rv_pdf, rv_page, rv_total, rv_annotations, rv_conf):
         return _build_canvas_json(None, []), _build_review_df([]), rv_annotations, f"Error: {exc}"
     img_rgb = _render_pdf_page(rv_pdf, rv_page, dpi=100)
     anns = all_anns.get(rv_page, [])
+    _autosave(rv_pdf, all_anns)
     engine = "YOLO" if using_yolo else "OpenCV"
     return (
         _build_canvas_json(img_rgb, anns),
@@ -791,6 +856,7 @@ def on_rv_update_box(rv_pdf, rv_page, rv_annotations, ledger, selected_idx, x1,
     rv_annotations[rv_page] = new_anns
     event = _make_event(rv_page, old, "modified", before=before, after=_make_box(new_anns[idx]))
     ledger = _append_events(ledger, [event])
+    _autosave(rv_pdf, rv_annotations)
     img_rgb = _render_pdf_page(rv_pdf, rv_page, dpi=100)
     return (
         _build_canvas_json(img_rgb, new_anns, selected=idx),
@@ -814,6 +880,7 @@ def on_rv_approve_all(rv_pdf, rv_page, rv_annotations, ledger):
         if a.get("status") != "approved"
     ]
     ledger = _append_events(ledger, events)
+    _autosave(rv_pdf, rv_annotations)
     return (
         _build_canvas_json(None, new_anns),
         _build_review_df(new_anns),
@@ -836,6 +903,7 @@ def on_rv_reject_all(rv_pdf, rv_page, rv_annotations, ledger):
         if a.get("status") != "rejected"
     ]
     ledger = _append_events(ledger, events)
+    _autosave(rv_pdf, rv_annotations)
     return (
         _build_canvas_json(None, new_anns),
         _build_review_df(new_anns),
@@ -859,6 +927,7 @@ def on_rv_approve_selected(rv_pdf, rv_page, rv_annotations, ledger, selected_idx
     rv_annotations[rv_page] = new_anns
     event = _make_event(rv_page, old, "accepted", before=_make_box(old), after=_make_box(new_anns[idx]))
     ledger = _append_events(ledger, [event])
+    _autosave(rv_pdf, rv_annotations)
     return (
         _build_canvas_json(None, new_anns, selected=idx),
         _build_review_df(new_anns),
@@ -883,6 +952,7 @@ def on_rv_delete_selected(rv_pdf, rv_page, rv_annotations, ledger, selected_idx)
     rv_annotations[rv_page] = new_anns
     event = _make_event(rv_page, removed, "rejected", before=_make_box(removed), after=None)
     ledger = _append_events(ledger, [event])
+    _autosave(rv_pdf, rv_annotations)
     new_sel = min(idx, len(new_anns) - 1) if new_anns else -1
     return (
         _build_canvas_json(None, new_anns, selected=new_sel),
@@ -911,6 +981,7 @@ def on_rv_copy_selected(rv_pdf, rv_page, rv_annotations, ledger, selected_idx):
     new_sel = len(new_anns) - 1
     event = _make_event(rv_page, new_ann, "created", before=None, after=_make_box(new_ann))
     ledger = _append_events(ledger, [event])
+    _autosave(rv_pdf, rv_annotations)
     return (
         _build_canvas_json(None, new_anns, selected=new_sel),
         _build_review_df(new_anns),
@@ -1250,7 +1321,9 @@ _CANVAS_JS = """
 </script>
 """
 
-with gr.Blocks(title="Takeoff AI Annotator") as demo:
+# _CANVAS_JS must go through head= — gr.HTML inserts via innerHTML, which never
+# executes <script> tags, so the canvas engine would silently not run.
+with gr.Blocks(title="Takeoff AI Annotator", head=_CANVAS_JS) as demo:
     gr.Markdown(f"# Takeoff AI Annotator  \n_Model: `{_model_version}`_")
 
     shapes_state = gr.State([])
@@ -1380,6 +1453,12 @@ with gr.Blocks(title="Takeoff AI Annotator") as demo:
             gr.Markdown(
                 "`A` approve &nbsp; `C` copy &nbsp; `Del` delete &nbsp; "
                 "`← →` pages &nbsp; — draw box by dragging on empty canvas"
+                + (
+                    f"  \n💾 **Autosave on** — every change is checkpointed to `{_AUTOSAVE_DIR}`; "
+                    "a refresh/crash loses nothing (re-import from there to resume)."
+                    if _AUTOSAVE_DIR
+                    else ""
+                )
             )
 
             # ── Wire events ─────────────────────────────────────────────────
@@ -1581,7 +1660,5 @@ with gr.Blocks(title="Takeoff AI Annotator") as demo:
         api_name="detect_page",
     )
 
-    gr.HTML(_CANVAS_JS)
-
 if __name__ == "__main__":
     demo.launch()