slidemind 0.3.20 → 0.4.0

package/src/builders/line-relations.mjs

@@ -0,0 +1,230 @@
+// How a line relates to the painted shapes it meets — one relation, read by
+// the transcriber that orders a free line among the shapes (placement.mjs) and
+// by the draft check that judges the render (the add-in's
+// connector-occlusion.ts). Two readings of it disagreed: the transcriber took
+// as ground only a panel holding ALL of the line and put it under everything
+// else it crossed, the check takes the panel under most of it — a divider
+// 13px past its card's edge was written under that card and the check named
+// it hidden (x114 QBR 6).
+//
+//   - Ground: the painted shape under most of a free line's length. The line
+//     lies on it and paints after it (a divider on its card, an axis on its
+//     panel). A line glued at both ends relates its nodes; only a shape holding
+//     all of it is its ground.
+//   - Station: an opaque node the line threads near its centre (a timeline's
+//     stop, the disc on a divider). It sits on the line and paints after it.
+//     A bead (≤16px) reads as a dot on its line whichever paints first.
+//
+// A shape is `{ rect, outline, content, alpha, lines }`: `outline` is
+// `{ ellipse, poly }` when anything paints it (null otherwise), `content` a
+// picture, icon or chart (its pixels are unknown), `alpha` how opaque its
+// paint is, `lines` its text lines. Points and rects are px in one frame.
+//
+// Shared by both clients; mirrored by scripts/sync-transcription-runtime.mjs —
+// no imports here.
+
+export const STATION_MAX_PX = 16;
+export const STATION_CENTRE_FRAC = 0.75;
+export const NODE_CENTRE_FRAC = 0.4;
+export const OPAQUE = 0.99;
+
+// ---- Points and segments against rects, ellipses and clip polygons ----------
+
+export function pointInsideRect(point, rect) {
+  return point.x >= rect.x && point.x <= rect.x + rect.w && point.y >= rect.y && point.y <= rect.y + rect.h;
+}
+
+export function pointInsideShape(point, rect, ellipse, grow) {
+  const r = { x: rect.x - grow, y: rect.y - grow, w: rect.w + grow * 2, h: rect.h + grow * 2 };
+  if (r.w <= 0 || r.h <= 0) return false;
+  if (!ellipse) return pointInsideRect(point, r);
+  const nx = (point.x - (r.x + r.w / 2)) / (r.w / 2);
+  const ny = (point.y - (r.y + r.h / 2)) / (r.h / 2);
+  return nx * nx + ny * ny <= 1;
+}
+
+/** The point sits ON the shape's outline (within `band` px either side), not deep inside it. */
+export function pointOnOutline(point, rect, ellipse, band) {
+  return pointInsideShape(point, rect, ellipse, band) && !pointInsideShape(point, rect, ellipse, -band);
+}
+
+export function rectContainsRect(outer, inner, eps = 0.5) {
+  return inner.x >= outer.x - eps && inner.y >= outer.y - eps && inner.x + inner.w <= outer.x + outer.w + eps && inner.y + inner.h <= outer.y + outer.h + eps;
+}
+
+export function insidePolygon(p, poly) {
+  let inside = false;
+  for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+    const a = poly[i];
+    const b = poly[j];
+    if (a.y > p.y !== b.y > p.y && p.x < ((b.x - a.x) * (p.y - a.y)) / (b.y - a.y) + a.x) inside = !inside;
+  }
+  return inside;
+}
+
+function orientation(a, b, c) {
+  const value = (b.y - a.y) * (c.x - b.x) - (b.x - a.x) * (c.y - b.y);
+  if (Math.abs(value) < 0.0001) return 0;
+  return value > 0 ? 1 : 2;
+}
+
+function onSegment(a, b, c) {
+  return b.x <= Math.max(a.x, c.x) + 0.0001 && b.x + 0.0001 >= Math.min(a.x, c.x) && b.y <= Math.max(a.y, c.y) + 0.0001 && b.y + 0.0001 >= Math.min(a.y, c.y);
+}
+
+function segmentsIntersect(a, b, c, d) {
+  const o1 = orientation(a, b, c);
+  const o2 = orientation(a, b, d);
+  const o3 = orientation(c, d, a);
+  const o4 = orientation(c, d, b);
+  if (o1 !== o2 && o3 !== o4) return true;
+  if (o1 === 0 && onSegment(a, c, b)) return true;
+  if (o2 === 0 && onSegment(a, d, b)) return true;
+  if (o3 === 0 && onSegment(c, a, d)) return true;
+  if (o4 === 0 && onSegment(c, b, d)) return true;
+  return false;
+}
+
+export function segmentHitsRect(a, b, rect) {
+  if (pointInsideRect(a, rect) || pointInsideRect(b, rect)) return true;
+  const tl = { x: rect.x, y: rect.y };
+  const tr = { x: rect.x + rect.w, y: rect.y };
+  const br = { x: rect.x + rect.w, y: rect.y + rect.h };
+  const bl = { x: rect.x, y: rect.y + rect.h };
+  return segmentsIntersect(a, b, tl, tr) || segmentsIntersect(a, b, tr, br) || segmentsIntersect(a, b, br, bl) || segmentsIntersect(a, b, bl, tl);
+}
+
+export function segmentHitsEllipse(a, b, rect) {
+  const rx = rect.w / 2;
+  const ry = rect.h / 2;
+  const cx = rect.x + rx;
+  const cy = rect.y + ry;
+  const ax = (a.x - cx) / rx;
+  const ay = (a.y - cy) / ry;
+  const dx = (b.x - cx) / rx - ax;
+  const dy = (b.y - cy) / ry - ay;
+  const len2 = dx * dx + dy * dy;
+  const t = len2 ? Math.max(0, Math.min(1, -(ax * dx + ay * dy) / len2)) : 0;
+  const px = ax + t * dx;
+  const py = ay + t * dy;
+  return px * px + py * py < 1;
+}
+
+export function segmentHitsPolygon(a, b, poly) {
+  if (insidePolygon(a, poly) || insidePolygon(b, poly)) return true;
+  return poly.some((p, i) => segmentsIntersect(a, b, p, poly[(i + 1) % poly.length]));
+}
+
+// ---- A route against one painted shape --------------------------------------
+
+/** Points along the route, every few px, each weighted by the length it stands for. */
+export function routeSamples(points) {
+  const out = [];
+  for (let i = 1; i < points.length; i++) {
+    const a = points[i - 1];
+    const b = points[i];
+    const len = Math.hypot(b.x - a.x, b.y - a.y);
+    const n = Math.max(1, Math.ceil(len / 4));
+    for (let k = 0; k < n; k++) {
+      const t = (k + 0.5) / n;
+      out.push({ p: { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t }, w: len / n });
+    }
+  }
+  return out;
+}
+
+export function insideOutline(p, shape) {
+  if (!shape.outline) return false;
+  return shape.outline.poly ? insidePolygon(p, shape.outline.poly) : pointInsideShape(p, shape.rect, shape.outline.ellipse, 0);
+}
+
+/** The share of a route's length that lies inside a shape's painted outline. */
+export function routeShare(points, shape, samples = routeSamples(points)) {
+  const total = samples.reduce((sum, s) => sum + s.w, 0);
+  if (!total) return 0;
+  return samples.reduce((sum, s) => sum + (insideOutline(s.p, shape) ? s.w : 0), 0) / total;
+}
+
+/**
+ * The line's ground: the painted shape under most of a free line, or — a line
+ * glued at both ends (`related`) — one holding all of it.
+ */
+export function isGround(shape, points, related = false, samples = undefined) {
+  if (!shape.outline) return false;
+  if (related) return points.every((p) => pointInsideRect(p, { x: shape.rect.x - 0.5, y: shape.rect.y - 0.5, w: shape.rect.w + 1, h: shape.rect.h + 1 }));
+  return routeShare(points, shape, samples) > 0.5;
+}
+
+/** The route's nearest approach to `point`: the distance, and the route's direction there. */
+export function nearestOnRoute(point, points) {
+  let best = { d: Number.POSITIVE_INFINITY, ux: 1, uy: 0 };
+  for (let i = 0; i < points.length - 1; i++) {
+    const a = points[i];
+    const b = points[i + 1];
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    const len2 = dx * dx + dy * dy;
+    const t = len2 ? Math.max(0, Math.min(1, ((point.x - a.x) * dx + (point.y - a.y) * dy) / len2)) : 0;
+    const d = Math.hypot(a.x + t * dx - point.x, a.y + t * dy - point.y);
+    if (d < best.d) best = len2 ? { d, ux: dx / Math.sqrt(len2), uy: dy / Math.sqrt(len2) } : { ...best, d };
+  }
+  return best;
+}
+
+export const isBead = (shape) => Math.max(shape.rect.w, shape.rect.h) <= STATION_MAX_PX;
+
+/** The route enters the shape's painted outline. */
+function meets(points, shape) {
+  const { rect, outline } = shape;
+  for (let i = 0; i < points.length - 1; i++) {
+    if (outline.poly) {
+      if (segmentHitsPolygon(points[i], points[i + 1], outline.poly)) return true;
+    } else if (rect.w > 0 && rect.h > 0) {
+      if (outline.ellipse ? segmentHitsEllipse(points[i], points[i + 1], rect) : segmentHitsRect(points[i], points[i + 1], rect)) return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * A station: a bead, or an opaque node — only an opaque node covers the line
+ * and whatever it holds; through a wash the line still strikes its text. It is
+ * threaded near its centre: within NODE_CENTRE_FRAC of its half-extent across
+ * the route (a bead: STATION_CENTRE_FRAC).
+ */
+export function isStation(shape, points) {
+  const { rect } = shape;
+  if (!shape.outline || shape.content || (isBead(shape) && shape.lines.length)) return false;
+  if (!isBead(shape) && shape.alpha < OPAQUE) return false;
+  const { d, ux, uy } = nearestOnRoute({ x: rect.x + rect.w / 2, y: rect.y + rect.h / 2 }, points);
+  // The node's half-extent across the route: a disc's radius, half a bar's
+  // length where a line crosses it.
+  const across = shape.outline.ellipse ? Math.hypot((uy * rect.w) / 2, (ux * rect.h) / 2) : (Math.abs(uy) * rect.w) / 2 + (Math.abs(ux) * rect.h) / 2;
+  if (d > across * (isBead(shape) ? STATION_CENTRE_FRAC : NODE_CENTRE_FRAC)) return false;
+  return meets(points, shape);
+}
+
+/**
+ * The smallest painted shape whose outline a free end touches (a ring arc
+ * meeting its disc, a rule ending at a card's edge): the line is attached to
+ * it in all but name. An end deep inside a panel touches nothing.
+ */
+export function touchedShape(point, shapes, band) {
+  let node = null;
+  for (const o of shapes) {
+    if (!o.outline || !pointOnOutline(point, o.rect, o.outline.ellipse, band)) continue;
+    if (!node || o.rect.w * o.rect.h < node.rect.w * node.rect.h) node = o;
+  }
+  return node;
+}
+
+/**
+ * The stations a line passes through: stations that hold none of its ends
+ * (`ends`: rects — a zero rect at a free point, a node's rect) and are not its
+ * ground.
+ */
+export function stationsOf(points, shapes, ends, related = false) {
+  if (related) return [];
+  const samples = routeSamples(points);
+  return shapes.filter((o) => isStation(o, points) && !ends.some((e) => rectContainsRect(o.rect, e)) && !isGround(o, points, false, samples));
+}

package/src/builders/lint-fix.mjs

@@ -16,9 +16,22 @@
 // Everything else the lint engine flags (raw colors, token choices, spacing
 // scales) is a judgment call and deliberately NOT auto-fixed.
 
+import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 
+import { CONVERSIONS_DIR, conversionProvenance } from "../lib/conversions.mjs";
+import { statePath } from "../lib/deck-paths.mjs";
+import { selectSlideFiles } from "../lib/slide-selection.mjs";
+
+// "This source says it is converted", as two markers only the converter writes:
+// the dialect pragma `slidemind adopt` stamps at the top of the file, and the
+// dialect's own attributes/host in the body. Identical to the pair
+// `validateSettleTarget` refuses on (src/builders/settle.mjs DIALECT_RE /
+// NATIVE_RE) on purpose — one definition of the dialect across the CLI.
+const DIALECT_RE = /^\s*\/\/\s*SLIDEMIND_DIALECT:\s*converted\b/m;
+const NATIVE_RE = /\bdata-sm-(?:native-object|source-id)\b|<ConvertedHost/;
+
 // Declaration blocks inside a <style> string or a style attribute: convert
 // `letter-spacing: Nem` when the SAME block carries `font-size: Mpx`.
 const DECL_BLOCK = /\{[^{}]*\}/g;
@@ -61,28 +74,123 @@ export function fixSlideSource(src) {
 }
 
 /**
- * Fix every slides/*.jsx in a deck, writing only changed files.
- * Returns { files: <changed file count>, fixes: <total fix count> }.
+ * Slides this whole-file rewrite may NOT touch, by file name → why. Preview is
+ * a look-at-it step: a slide whose source someone has taken over keeps its
+ * exact bytes, or an edit safeguard anywhere else is undone by the next
+ * `view-draft`. Three owners are knowable from what the deck already records:
+ *
+ *   - CONVERTED (`slidemind adopt`, conversions/<stem>.json): its raw values
+ *     ARE the original .pptx's. Rewriting one is a silent edit of an imported
+ *     slide the user never asked for.
+ *   - UNREADABLE record: the file is there and will not parse, so whether the
+ *     slide is converted is UNANSWERED. That is the strongest reason to keep
+ *     hands off it, not the weakest — which is why this asks
+ *     `conversionProvenance` per slide instead of `loadConversions`: a map
+ *     cannot say "something was here and I could not read it", so a corrupt
+ *     record reaches that map's callers as plain absence, i.e. as permission.
+ *   - MARKED converted by its own source, with no record found. The record and
+ *     the marker are two INDEPENDENT signals and either one refuses, matching
+ *     the add-in's `slideNormalizationPolicy`. The asymmetry is deliberate:
+ *     there the threat is a worker DELETING the marker to launder an import,
+ *     so the persisted record is the backstop; here it is the reverse, a record
+ *     deleted, lost or never written on a slide whose source still says what it
+ *     is. Two signals, either sufficient, covers both directions — and without
+ *     this one the same slide is protected in one client and rewritten in the
+ *     other.
+ *   - EDITED since `transcribe` stamped it (state/transcribed.json): the bytes
+ *     no longer match the hash the machine wrote, so a person or an agent owns
+ *     the file — the same rule `transcribe --force` already refuses on.
+ *
+ * A slide with NO stamp is not "edited": nothing ever recorded a machine
+ * baseline for it, so there is nothing it can differ from. Ordinary authored
+ * decks keep the autofix exactly as before.
+ */
+function unrewritableSlides(deckDir, slideFiles) {
+  const why = new Map();
+  for (const name of slideFiles) {
+    const record = conversionProvenance(deckDir, name);
+    if (record === undefined) {
+      why.set(
+        name,
+        `its ${CONVERSIONS_DIR}/${name.replace(/\.jsx$/, "")}.json could not be read, so whether ` +
+          "this slide is converted is unknown — an unreadable record is not permission to rewrite it",
+      );
+      continue;
+    }
+    if (record) {
+      why.set(name, "converted from .pptx — its raw values are the original slide's");
+      continue;
+    }
+    // No record. The source itself is the second, independent signal.
+    let src;
+    try {
+      src = fs.readFileSync(path.join(deckDir, "slides", name), "utf8");
+    } catch {
+      continue;
+    }
+    if (DIALECT_RE.test(src) || NATIVE_RE.test(src)) {
+      why.set(
+        name,
+        "its source is marked converted, though no conversion record was found — " +
+          `the record ${CONVERSIONS_DIR}/${name.replace(/\.jsx$/, "")}.json is missing, which is worth ` +
+          "repairing on its own (re-run 'slidemind adopt' for this deck)",
+      );
+    }
+  }
+  let stamps = {};
+  try {
+    stamps = JSON.parse(fs.readFileSync(statePath(deckDir, "transcribed.json"), "utf8"));
+  } catch {
+    stamps = {};
+  }
+  for (const [name, hash] of Object.entries(stamps)) {
+    if (why.has(name)) continue;
+    let src;
+    try {
+      src = fs.readFileSync(path.join(deckDir, "slides", name), "utf8");
+    } catch {
+      continue;
+    }
+    if (crypto.createHash("sha256").update(src).digest("hex") !== hash) {
+      why.set(name, "edited since it was transcribed — the edit stands");
+    }
+  }
+  return why;
+}
+
+/**
+ * Fix every slides/*.jsx in a deck, writing only changed files — except the
+ * ones `unrewritableSlides` withholds, which keep their bytes.
+ * Returns { files, fixes, withheld: [{ file, reason, fixes }] }.
  */
-export function fixDeckSlides(deckDir) {
+export function fixDeckSlides(deckDir, { only = null } = {}) {
   const slidesDir = path.join(deckDir, "slides");
   let files = 0;
   let fixes = 0;
+  const withheld = [];
   let entries = [];
   try {
     entries = fs.readdirSync(slidesDir).filter((f) => f.endsWith(".jsx"));
   } catch {
-    return { files, fixes };
+    return { files, fixes, withheld };
   }
+  entries = selectSlideFiles(entries, only);
+  const unrewritable = unrewritableSlides(deckDir, entries);
   for (const f of entries) {
     const p = path.join(slidesDir, f);
     const src = fs.readFileSync(p, "utf8");
     const res = fixSlideSource(src);
-    if (res.fixes.length) {
-      fs.writeFileSync(p, res.src);
-      files += 1;
-      fixes += res.fixes.length;
+    if (!res.fixes.length) continue;
+    const reason = unrewritable.get(f);
+    if (reason) {
+      // Reported, never applied: the lint still prints every finding on this
+      // file, so the fix is offered rather than performed.
+      withheld.push({ file: f, reason, fixes: res.fixes });
+      continue;
     }
+    fs.writeFileSync(p, res.src);
+    files += 1;
+    fixes += res.fixes.length;
   }
-  return { files, fixes };
+  return { files, fixes, withheld };
 }

package/src/builders/lint.mjs

@@ -16,6 +16,7 @@ import path from "node:path";
 import { pathToFileURL } from "node:url";
 
 import { resolveBundleDirForDeck } from "../bridge/bundle.mjs";
+import { deckSlug } from "../lib/deck-paths.mjs";
 
 // Resolve the cached engine for a deck and explain every miss actionably.
 // Returns { enginePath, version, primitives }.
@@ -23,8 +24,8 @@ function resolveEngine(deckDir) {
   const bundleDir = resolveBundleDirForDeck(deckDir);
   if (!bundleDir) {
     throw new Error(
-      `No materialized design bundle for deck ${path.basename(deckDir)}.\n` +
-        `  Run 'slidemind download-bundle ${path.basename(deckDir)}' first.`,
+      `No materialized design bundle for deck ${deckSlug(deckDir)}.\n` +
+        `  Run 'slidemind download-bundle ${deckSlug(deckDir)}' first.`,
     );
   }
   const enginePath = path.join(bundleDir, "lint-engine.mjs");
@@ -42,14 +43,14 @@ function resolveEngine(deckDir) {
       throw new Error(
         `The paired slidemind add-in does not serve a lint engine yet.\n` +
           `  Update/redeploy the add-in backend, then re-run ` +
-          `'slidemind download-bundle ${path.basename(deckDir)}'.`,
+          `'slidemind download-bundle ${deckSlug(deckDir)}'.`,
       );
     }
     // Cache written before the engine existed (meta lacks the key), or the
     // file went missing — refetch repairs both.
     throw new Error(
       `This bundle cache predates the lint engine.\n` +
-        `  Run 'slidemind download-bundle ${path.basename(deckDir)}'.`,
+        `  Run 'slidemind download-bundle ${deckSlug(deckDir)}'.`,
     );
   }
 
@@ -84,7 +85,7 @@ export async function lintSlidesOrThrow({ deckDir, slideFiles, layoutSources })
   if (typeof engine.lintSlidesInMemory !== "function") {
     throw new Error(
       `Cached lint engine is corrupt (no lintSlidesInMemory export).\n` +
-        `  Run 'slidemind download-bundle ${path.basename(deckDir)}'.`,
+        `  Run 'slidemind download-bundle ${deckSlug(deckDir)}'.`,
     );
   }
 
@@ -124,25 +125,29 @@ const DYNAMIC_ID_RE =
 export function collapseLintLines(lines) {
   const out = [];
   const seen = new Set();
-  const dynamic = new Map(); // file → { indent, refs: [] }
+  const arrows = new Map();
   for (const line of lines) {
     if (seen.has(line)) continue;
     seen.add(line);
-    const m = DYNAMIC_ID_RE.exec(line);
-    if (m) {
-      const entry = dynamic.get(m[2]) ?? { file: m[2], indent: m[1], refs: [] };
-      entry.refs.push(m[3].replace(/^data-(?:from|to)=/, ""));
-      if (!dynamic.has(m[2])) {
-        dynamic.set(m[2], entry);
-        out.push(entry); // placeholder keeps the file's position in the listing
-      }
-      continue;
+    // Template-id refs resolve at render time; the engine from 2026-09-19 on
+    // no longer emits this line, and an older engine's copy is dropped here —
+    // the render-time endpoint check is what catches a real miss.
+    if (DYNAMIC_ID_RE.test(line)) continue;
+    // One "SVG path arrow" advice per file, naming its lines: repeated per
+    // arrow it fired 162 times in one x66 run, mostly on arcs no route draws,
+    // and buried the lines that mattered.
+    const arrow = PATH_ARROW_RE.exec(line);
+    if (arrow) {
+      const [, file, at] = arrow;
+      const prior = arrows.get(file);
+      if (prior) { prior.lines.push(at); continue; }
+      arrows.set(file, { index: out.length, lines: [at], text: line.slice(arrow[0].length) });
     }
     out.push(line);
   }
-  return out.map((item) =>
-    typeof item === "string"
-      ? item
-      : `${item.indent}[lint:note] ${item.file} — ${item.refs.length} connector ref${item.refs.length === 1 ? "" : "s"} (${[...new Set(item.refs)].slice(0, 4).join(", ")}${item.refs.length > 4 ? ", …" : ""}) use ids the slide builds with a template — they resolve at render time; check that each connector lands on its node in the draft render.`,
-  );
+  for (const [file, { index, lines: at, text }] of arrows) {
+    if (at.length > 1) out[index] = `  [lint:warn] ${file}:${at.join(",")} — (${at.length}×) ${text.trim()}`;
+  }
+  return out;
 }
+const PATH_ARROW_RE = /^\s*\[lint:warn\] ([^:\s]+\.jsx):(\d+) — (?=SVG path arrow)/;

package/src/builders/list-jsx.mjs

@@ -0,0 +1,88 @@
+// The native list the transcriber writes. An item (`marker` on a paragraph,
+// concept-lists.mjs) is never a glyph typed into a run or a mark parked beside
+// a line: it is an `<li>` of an `<L>`, so the export writes a PowerPoint bullet
+// (`<a:buChar>` / `<a:buAutoNum>`) with a hanging indent. The glyph is the
+// design's: `.slide ul/ol` and `.slide li::marker` in the bundle's CSS carry
+// the brand bullet (layouts-css-codegen.ts); L sets none of its own. A check
+// list keeps its tick (`bullet="✓"`), a don't list its cross, a numbered list
+// counts (`ordered`). The marker's paint is the reader's when it named one
+// (`markerVar`: the concept's accent dots stay accent), else the brand's.
+// The items' words sit where the reader measured them and the marker hangs
+// outside, left of them (`padding-left: 0`, `list-style-position: outside`),
+// as the painting had it. Placed by `x`/`y` it stands alone; without them it
+// flows inside a block's `<T>` after the paragraphs above it, at its own
+// `indent` off the block's left edge (its words' offset, the marker hanging in
+// it), aligned by its own `align`, and the export merges title and items into
+// ONE text frame (oox/adapter/text-merge.ts).
+// Pure; mirrored into the add-in by scripts/sync-transcription-runtime.mjs.
+
+export const LIST_HELPER = `  const L = ({ id, x, y, w, px, indent, align, role = "body", tone = "dark", colorVar, bullet, ordered, markerVar, stack, block, children }) => {
+    const style = { ...(x != null ? { position: "absolute", left: x, top: y, width: w } : {}), ...(indent ? { marginLeft: indent } : {}), ...(align ? { textAlign: align } : {}), margin: 0, paddingLeft: 0, boxSizing: "border-box",
+      listStylePosition: "outside", ...(ordered ? { listStyleType: "decimal" } : bullet ? { listStyleType: \`"\${bullet} "\` } : {}),
+      ...(markerVar ? { "--sm-marker": markerVar } : {}), ...ROLE[role], color: colorVar ?? TONE[tone], ...(px ? { fontSize: HALF_PT(px) } : {}), lineHeight: "var(--lh-tight)" };
+    return (<>{markerVar ? <style>{".sm-list[data-marker] > li::marker { color: var(--sm-marker); }"}</style> : null}
+      {ordered ? <ol id={id} className="sm-list" data-marker={markerVar} data-sm-stack={stack} data-sm-block={block} style={style}>{children}</ol> : <ul id={id} className="sm-list" data-marker={markerVar} data-sm-stack={stack} data-sm-block={block} style={style}>{children}</ul>}</>);
+  };
+`;
+
+/** The `L` attributes a marker kind adds: a check or don't list's glyph, a numbered list's count. */
+export const markerAttrs = (marker) => (marker === "check" ? ['bullet="✓"'] : marker === "cross" ? ['bullet="✗"'] : marker === "number" ? ["ordered"] : []);
+
+/**
+ * The JSX children of a text block: one `<P>` per plain paragraph, a run of
+ * items with one marker as one `<L>` of `<li>`s. `para(p)` writes a plain
+ * paragraph, `attrs(p)` the role, paint, indent and marker attributes of the
+ * paragraph that opens a list, `item(p, head)` an item's text (painted like
+ * `head` unless its own paint differs). `single` is set when the block is
+ * exactly one list.
+ */
+export function blockChildren(paragraphs, { para, item, attrs }) {
+  const out = [];
+  let lists = 0;
+  for (let i = 0; i < paragraphs.length; ) {
+    const head = paragraphs[i];
+    if (!head.marker) {
+      out.push(para(head));
+      i += 1;
+      continue;
+    }
+    let j = i;
+    while (j < paragraphs.length && paragraphs[j].marker === head.marker) j += 1;
+    const items = paragraphs.slice(i, j).map((p) => `<li>${item(p, head)}</li>`).join("");
+    out.push(`<L ${[...attrs(head), ...markerAttrs(head.marker)].join(" ")}>${items}</L>`);
+    lists += 1;
+    i = j;
+  }
+  return { children: out.join(""), single: lists === 1 && out.length === 1 };
+}
+
+// A styled run inside a paragraph: the accent figure in "under 21 days", the
+// bold term in a sentence (text-blocks.mjs `runs`). It takes its role's rung
+// and paint from the kit, never a size of its own, so one sentence stays ONE
+// text frame whose runs the export writes with their own size, weight and
+// colour (dom-serialiser text runs → `<a:r>`).
+export const RUN_HELPER = `  const R = ({ role, bold, tone, colorVar, children }) => (
+    <span style={{ ...(role ? ROLE[role] : {}), ...(colorVar || tone ? { color: colorVar ?? TONE[tone] } : {}), ...(bold ? { fontWeight: "var(--fw-bold)" } : {}) }}>{children}</span>
+  );
+`;
+
+/**
+ * `body` (escaped JSX text) with each run wrapped in `<R …>`, in order: a run
+ * is found after the one before it, never inside a tag. `attrs(run)` names its
+ * role and paint, `escape` escapes its words like the body's.
+ */
+export function wrapRuns(body, runs, attrs, escape) {
+  let out = body;
+  let at = 0;
+  for (const run of runs ?? []) {
+    const needle = escape(String(run.text ?? "").trim());
+    if (!needle) continue;
+    let i = out.indexOf(needle, at);
+    while (i >= 0 && out.lastIndexOf("<", i) > out.lastIndexOf(">", i)) i = out.indexOf(needle, i + 1);
+    if (i < 0) continue;
+    const tag = `<R${attrs(run).map((a) => ` ${a}`).join("")}>${needle}</R>`;
+    out = out.slice(0, i) + tag + out.slice(i + needle.length);
+    at = i + tag.length;
+  }
+  return out;
+}