slidemind 0.3.5 → 0.3.13

package/src/bridge/engine-download.mjs

@@ -14,7 +14,7 @@ import {
   imageSizeFromBuffer,
   svgSizeFromMarkup,
 } from "./image-dimensions.mjs";
-import { describeRecolor } from "./recolor.mjs";
+import { applyLocalRecolor, describeRecolor } from "./recolor.mjs";
 
 // Every image format an engine accepts, plus the alias spellings seen in the
 // wild. Mirrors the add-in's `searchImage` set (lib/image-formats.ts there);
@@ -151,12 +151,18 @@ function describeRecolorWithRefusal(markup, mimeType, iconColor, refusedColor) {
     refusedColor ? null : (iconColor ?? null),
   );
   if (!refusedColor) return described;
+  // With the local bake in place (applyLocalRecolor), a surviving refusal
+  // means the glyph itself declined the colour — say why instead of sending
+  // the agent on a pane hunt.
+  const why =
+    described.mode === "multicolor"
+      ? "it is a multi-tone glyph and a single colour would flatten it — left as designed."
+      : described.mode === "raster"
+        ? "raster images carry their own colours."
+        : "the glyph's paint structure could not be rewritten safely.";
   return {
     ...described,
-    note:
-      `Saved in its ORIGINAL colours — recolouring to ${refusedColor} runs in the slidemind add-in. ` +
-      "Re-run this download with --to <presId> (a PowerPoint window with the slidemind pane open) " +
-      "to bake the colour in.",
+    note: `Saved in its ORIGINAL colours — recolouring to ${refusedColor} was not applied: ${why}`,
   };
 }
 
@@ -218,16 +224,29 @@ async function streamOneResult({
     if (res?.svgMarkup) {
       // SVG arrives inline, not as a stream.
       fs.rmSync(tempPath, { force: true });
+      // Window-free tint fallback: the pane-side refusal is about WHERE the
+      // rewrite runs, not whether it's possible — for currentColor/mono SVGs
+      // the bake is a deterministic local string transform. Measured impact:
+      // one sim batch carried 235 "saved in ORIGINAL colours" notes, every
+      // one an off-brand icon on the rendered slide.
+      let markup = res.svgMarkup;
+      if (recolorRefused) {
+        const local = applyLocalRecolor(markup, recolorRefused);
+        if (local.applied) {
+          markup = local.markup;
+          recolorRefused = null;
+        }
+      }
       const filename = `engine-${searchId}-${selection}.svg`;
       const target = path.join(assetsDir, filename);
-      fs.writeFileSync(target, res.svgMarkup, "utf8");
+      fs.writeFileSync(target, markup, "utf8");
       return {
         selection,
         path: target,
         reference: `./assets/${filename}`,
         mimeType: res.mimeType ?? "image/svg+xml",
         recolor: describeRecolorWithRefusal(
-          res.svgMarkup,
+          markup,
           res.mimeType,
           iconColor,
           recolorRefused,

package/src/bridge/recolor.mjs

@@ -110,3 +110,49 @@ export function describeRecolor(svgMarkup, mimeType, appliedColor = null) {
     note,
   };
 }
+
+// Bake a colour into an SVG LOCALLY — the fallback for the window-free path,
+// where the add-in refuses the tint (`recolor_needs_host`) because its
+// DOM-based classifier lives pane-side. For the two recolourable modes the
+// rewrite is a deterministic string transform this module can do itself:
+//   currentColor — replace every `currentColor` paint with the hex;
+//   mono         — replace every concrete fill/stroke paint with the hex.
+// Multicolor and raster are refused (flattening a multi-tone glyph or touching
+// raster bytes is never right). Returns { markup, applied }.
+export function applyLocalRecolor(svgMarkup, hex) {
+  if (typeof svgMarkup !== "string" || !hex || !isSvg(null, svgMarkup)) {
+    return { markup: svgMarkup, applied: false };
+  }
+  if (hasCurrentColor(svgMarkup)) {
+    return {
+      markup: svgMarkup.replace(
+        /((?:fill|stroke)\s*[:=]\s*["']?\s*)currentColor/gi,
+        `$1${hex}`,
+      ),
+      applied: true,
+    };
+  }
+  const paints = distinctPaints(svgMarkup);
+  if (paints.size >= 2 || paints.size === 0) {
+    // Multicolor: never flatten. Zero declared paints: the glyph renders in
+    // the SVG default (black) via inheritance — inject a root fill instead of
+    // rewriting nothing.
+    if (paints.size === 0) {
+      return {
+        markup: svgMarkup.replace(/<svg\b/i, `<svg fill="${hex}"`),
+        applied: true,
+      };
+    }
+    return { markup: svgMarkup, applied: false };
+  }
+  const markup = svgMarkup.replace(
+    /((?:fill|stroke)\s*[:=]\s*["']?\s*)(#[0-9a-fA-F]{3,8}|rgba?\([^)]*\)|hsla?\([^)]*\)|[a-zA-Z]+)/g,
+    (m, prefix, value) => {
+      const v = value.trim().toLowerCase();
+      if (v === "none" || v === "transparent") return m;
+      if (!/^#|^rgb|^hsl/.test(v) && !NAMED_COLORS.has(v)) return m;
+      return `${prefix}${hex}`;
+    },
+  );
+  return { markup, applied: true };
+}

package/src/bridge/setup-claim.mjs

@@ -114,7 +114,13 @@ export async function redeemSetupClaim({ backendURL, secret, cliVersion }) {
   }
 
   if (result.status === 200 && result.json?.sessionToken) {
-    return String(result.json.sessionToken);
+    // `oid` (the user's directory id) arrives from add-ins that report it; an
+    // older add-in leaves it null, which the session store treats as "unknown
+    // person" — i.e. never inherit the previous Microsoft 365 sign-in.
+    return {
+      sessionToken: String(result.json.sessionToken),
+      oid: typeof result.json.oid === "string" && result.json.oid ? result.json.oid : null,
+    };
   }
   // Discriminate on the error CODE, not the status. A deployment that predates
   // one-command setup has no such route, so the request falls through to that

package/src/builders/build.mjs

@@ -29,9 +29,12 @@
 
 import { spawn } from "node:child_process";
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
+import { resolveBundleDirForDeck } from "../bridge/bundle.mjs";
+import { loadChartPreview, loadConnectorPreview } from "../bridge/capture.mjs";
 import { FAVICON_LINK } from "./gate-server.mjs";
 import { lintSlidesOrThrow } from "./lint.mjs";
 import { resolveSkillForDeck } from "./resolve-skill.mjs";
@@ -145,6 +148,98 @@ function copyDesignSystem(deckDir, skill) {
   fs.writeFileSync(path.join(deckDir, "layouts.css"), cssChunks.join("\n\n"));
 }
 
+// First concrete (non-generic) family of a CSS var's font stack, or null.
+function firstConcreteFamily(cssText, varName) {
+  const match = cssText.match(new RegExp(`--${varName}\\s*:\\s*([^;]+);`));
+  if (!match) return null;
+  const generics = new Set([
+    "sans-serif",
+    "serif",
+    "monospace",
+    "system-ui",
+    "ui-sans-serif",
+    "ui-serif",
+    "ui-monospace",
+    "cursive",
+    "fantasy",
+  ]);
+  for (const part of match[1].split(",")) {
+    const family = part.trim().replace(/^['"]|['"]$/g, "");
+    if (family && !generics.has(family.toLowerCase())) return family;
+  }
+  return null;
+}
+
+// Copy the materialized bundle's brand fonts next to the preview and emit the
+// same @font-face block the server's capture page uses: one rule per FACE
+// under its canonical family plus the CSS-token alias (--font-sans/--font-mono),
+// with real weight/style descriptors so bold/italic render (and later measure)
+// with the real face instead of a synthesized one. Without this the preview
+// showed system fallbacks while capture/export used the brand face.
+function brandFontFaces(deckDir, skill) {
+  const bundleDir = skill.bundleDir;
+  if (!bundleDir || !fs.existsSync(bundleDir)) return "";
+  let meta = {};
+  try {
+    meta = JSON.parse(
+      fs.readFileSync(path.join(bundleDir, "bundle.json"), "utf8"),
+    );
+  } catch {
+    return "";
+  }
+  const fonts = Array.isArray(meta.fonts) ? meta.fonts : [];
+  if (fonts.length === 0) return "";
+
+  let css = "";
+  try {
+    css = fs.readFileSync(path.join(deckDir, "corporate-design.css"), "utf8");
+  } catch {
+    /* alias resolution degrades to canonical families only */
+  }
+  const aliasByRole = {
+    primary: firstConcreteFamily(css, "font-sans"),
+    mono: firstConcreteFamily(css, "font-mono"),
+  };
+
+  const outFonts = path.join(deckDir, "fonts");
+  const rules = [];
+  for (const font of fonts) {
+    if (!font?.family || !font?.filename) continue;
+    const filename = path.basename(font.filename);
+    const src = path.join(bundleDir, "fonts", filename);
+    if (!fs.existsSync(src)) continue;
+    fs.mkdirSync(outFonts, { recursive: true });
+    fs.copyFileSync(src, path.join(outFonts, filename));
+
+    const weight =
+      font.variable &&
+      typeof font.variable.minWeight === "number" &&
+      typeof font.variable.maxWeight === "number"
+        ? `${font.variable.minWeight} ${font.variable.maxWeight}`
+        : String(
+            typeof font.weight === "number" &&
+              font.weight >= 100 &&
+              font.weight <= 900
+              ? font.weight
+              : 400,
+          );
+    const style = font.style === "italic" ? "italic" : "normal";
+    const format = filename.toLowerCase().endsWith(".otf")
+      ? "opentype"
+      : "truetype";
+    const rule = (family) =>
+      `@font-face { font-family: ${JSON.stringify(family)}; ` +
+      `src: url(${JSON.stringify(`./fonts/${filename}`)}) format("${format}"); ` +
+      `font-weight: ${weight}; font-style: ${style}; font-display: block; }`;
+    rules.push(rule(font.family));
+    const alias = aliasByRole[font.role];
+    if (alias && alias.toLowerCase() !== font.family.toLowerCase()) {
+      rules.push(rule(alias));
+    }
+  }
+  return rules.join("\n");
+}
+
 function loadOverrides(deckDir) {
   const file = path.join(deckDir, "overrides.json");
   if (!fs.existsSync(file)) return { version: 1, slides: {} };
@@ -228,6 +323,12 @@ const HTML_TEMPLATE = `<!doctype html>
       --sw-tech-blue-80: #3333FF;
       --sw-magenta: #E6007E;
     }
+    /* A data-connector div is a directive, not a painted box (the render
+       derives the line between its two referenced nodes). Same rule the
+       bundle's corporate-design.css carries; repeated here so a preview
+       against an older bundle lays out like the render will. */
+    [data-connector] { position: absolute; width: 0; height: 0; padding: 0; margin: 0; border-color: transparent; pointer-events: none; }
+    [data-sm-connector-overlay] { position: absolute; left: 0; top: 0; width: 1280px; height: 720px; overflow: visible; pointer-events: none; z-index: 2147483000; }
   </style>
   <style>
     /* Substitute Arial with Arimo (a metric clone) so wrap behaviour
@@ -258,6 +359,10 @@ const HTML_TEMPLATE = `<!doctype html>
       font-style: italic;
     }
   </style>
+  <style id="brand-font-faces">__BRAND_FONT_FACES__</style>
+  <!-- Chart palette for the <Chart> stand-in (from the bundle's capture engine;
+       empty when the bundle carries no chart runtime). -->
+  <style id="chart-theme-tokens">__CHART_THEME_TOKENS__</style>
   <style>
     html, body { margin: 0; padding: 0; height: 100%; background: #0a0a0a; overflow: hidden; }
     :root {
@@ -470,6 +575,15 @@ __SLIDES__
   <script crossorigin src="https://unpkg.com/react@18/umd/react.production.min.js"></script>
   <script crossorigin src="https://unpkg.com/react-dom@18/umd/react-dom.production.min.js"></script>
   <script src="https://unpkg.com/@babel/standalone/babel.min.js"></script>
+  <!-- The <Chart> stand-in runtime: the add-in's own vendored scripts, inlined
+       from the bundle's capture engine (this CLI ships no chart source). They
+       install window.SlidemindChart, which the bootstrap below binds as Chart
+       before any slide is evaluated. -->
+__CHART_PREVIEW_SCRIPTS__
+  <!-- The exporter's connector geometry (connector-derive), inlined from the
+       bundle's capture engine: the overlay below derives every data-connector
+       route and arrowhead exactly as the .pptx export does. -->
+__CONNECTOR_PREVIEW_SCRIPT__
   <script>window.__SLIDE_EDITOR_OVERRIDES__ = __OVERRIDES__;</script>
   <script>window.SVG_ASSETS = __SVG_ASSETS__;</script>
   <script>
@@ -500,8 +614,11 @@ __RUNTIME_APPLIER__
                 var nameNode = node.name;
                 // Intrinsic elements only: a lowercase JSXIdentifier. Skip
                 // components (<SlideCover>), member/namespaced names, fragments.
+                // <Chart> is the one component that opts in (as in the add-in's
+                // instrument-source-loc): it forwards the attribute onto its
+                // root div, so a review pin on a chart resolves to its tag.
                 if (!nameNode || nameNode.type !== "JSXIdentifier") return;
-                if (!/^[a-z]/.test(nameNode.name)) return;
+                if (!/^[a-z]/.test(nameNode.name) && nameNode.name !== "Chart") return;
                 for (var i = 0; i < node.attributes.length; i++) {
                   var a = node.attributes[i];
                   if (a.type === "JSXAttribute" && a.name &&
@@ -649,6 +766,14 @@ __RUNTIME_APPLIER__
         }
       });
 
+      // The Chart binding slide jsx is compiled against — installed by the
+      // bundle's chart-preview scripts above; without them a chart renders
+      // nothing, exactly as the add-in's page behaves.
+      var Chart = window.SlidemindChart
+        ? window.SlidemindChart.createComponent(React)
+        : function () { return null; };
+      var slideScope = Object.assign({ Chart: Chart }, LAYOUTS);
+
       var slides = [];
       document.querySelectorAll('script[data-kind="slide"]').forEach(function (s) {
         var idx = parseInt(s.dataset.index, 10);
@@ -657,7 +782,7 @@ __RUNTIME_APPLIER__
           var Component = evalJsx(
             s.textContent,
             "slides/" + name + ".jsx",
-            LAYOUTS
+            slideScope
           );
           slides[idx] = { name: name, Component: Component };
         } catch (err) {
@@ -680,6 +805,130 @@ __RUNTIME_APPLIER__
 
       smInlineSvgAssets();
 
+      // Connector overlay — the preview's stand-in for the native connectors
+      // the render derives from every data-connector directive (the capture
+      // engine injects an equivalent SVG before its screenshot). Straight,
+      // elbow and arc routes, side pins, arrowheads, dash and colour follow
+      // the same rules as the exporter's connector-derive; the exporter's
+      // measured output at view-draft / in the .pptx stays the truth.
+      function smDrawConnectors(container) {
+        if (!container) return;
+        var old = container.querySelector(":scope > svg[data-sm-connector-overlay]");
+        if (old) old.remove();
+        var dirs = container.querySelectorAll("[data-connector]");
+        if (!dirs.length) return;
+        var derive = window.SlidemindConnectorDerive;
+        if (!derive || typeof derive.resolveConnector !== "function") {
+          console.warn("connector overlay skipped: the bundle's capture engine exports no connector geometry (re-fetch the bundle)");
+          return;
+        }
+        var cRect = container.getBoundingClientRect();
+        var scale = cRect.width / 1280 || 1;
+        var NS = "http://www.w3.org/2000/svg";
+        var svg = document.createElementNS(NS, "svg");
+        svg.setAttribute("data-sm-connector-overlay", "1");
+        svg.setAttribute("viewBox", "0 0 1280 720");
+        var defs = document.createElementNS(NS, "defs");
+        svg.appendChild(defs);
+        var rectOf = function (el) {
+          var r = el.getBoundingClientRect();
+          return { x: (r.left - cRect.left) / scale, y: (r.top - cRect.top) / scale, w: r.width / scale, h: r.height / scale };
+        };
+        var resolveRef = function (ref) {
+          if (!ref) return null;
+          try { return container.querySelector(ref.charAt(0) === "#" ? ref : "#" + ref); } catch (e) { return null; }
+        };
+        var sideOrNull = function (raw) {
+          var s = (raw || "").toLowerCase();
+          return (s === "top" || s === "bottom" || s === "left" || s === "right") ? s : null;
+        };
+        // Computed CSS colour ("rgb(a)(...)") → { hex, alpha } as the serialiser reports it.
+        var colorOf = function (css) {
+          var m = /rgba?\(([^)]+)\)/.exec(css || "");
+          if (!m) return { hex: "000000", alpha: 1 };
+          var p = m[1].split(",").map(function (v) { return parseFloat(v); });
+          var hex = p.slice(0, 3).map(function (v) {
+            var h = Math.max(0, Math.min(255, Math.round(v))).toString(16);
+            return h.length < 2 ? "0" + h : h;
+          }).join("").toUpperCase();
+          return { hex: hex, alpha: p.length > 3 && isFinite(p[3]) ? p[3] : 1 };
+        };
+        dirs.forEach(function (el, idx) {
+          var fromEl = resolveRef(el.getAttribute("data-from"));
+          var toEl = resolveRef(el.getAttribute("data-to"));
+          var route = (el.getAttribute("data-route") || "straight").toLowerCase();
+          var centerEl = route === "arc" ? resolveRef(el.getAttribute("data-center")) : null;
+          var arrowRaw = (el.getAttribute("data-arrow") || "none").toLowerCase();
+          var cs = getComputedStyle(el);
+          var stroke = colorOf(cs.color);
+          // The same payload the serialiser hands the exporter; resolveConnector
+          // derives endpoints, route, bends, arc, and arrowhead size from it.
+          var r = derive.resolveConnector({
+            from: el.getAttribute("data-from") || "",
+            to: el.getAttribute("data-to") || "",
+            arrow: (arrowRaw === "start" || arrowRaw === "end" || arrowRaw === "both") ? arrowRaw : "none",
+            route: route,
+            fromSide: sideOrNull(el.getAttribute("data-from-side")),
+            toSide: sideOrNull(el.getAttribute("data-to-side")),
+            center: el.getAttribute("data-center") || null,
+            fromRect: fromEl ? rectOf(fromEl) : null,
+            toRect: toEl ? rectOf(toEl) : null,
+            centerRect: centerEl ? rectOf(centerEl) : null,
+            strokeHex: stroke.hex,
+            strokeAlpha: stroke.alpha,
+            strokeWidthPx: parseFloat(cs.borderTopWidth) || 0,
+            dashed: /dashed|dotted/.test(cs.borderTopStyle || ""),
+            missing: [],
+          });
+          if (!r) return;
+          var color = "#" + r.strokeHex;
+          var d;
+          if (r.arc) {
+            var large = Math.abs(r.arc.sweepDeg) > 180 ? 1 : 0;
+            var sweep = r.arc.sweepDeg > 0 ? 1 : 0;
+            d = "M" + r.start.x + " " + r.start.y + " A" + r.arc.r + " " + r.arc.r + " 0 " + large + " " + sweep + " " + r.end.x + " " + r.end.y;
+          } else {
+            d = r.points.map(function (p, i) { return (i ? "L" : "M") + p.x + " " + p.y; }).join(" ");
+          }
+          var path = document.createElementNS(NS, "path");
+          path.setAttribute("d", d);
+          path.setAttribute("fill", "none");
+          path.setAttribute("stroke", color);
+          path.setAttribute("stroke-opacity", String(r.strokeAlpha));
+          path.setAttribute("stroke-width", String(r.strokeWidthPx));
+          if (r.dashed) {
+            var dash = Math.max(4, r.strokeWidthPx * 3);
+            path.setAttribute("stroke-dasharray", dash + " " + dash);
+          }
+          if (r.arrowStart || r.arrowEnd) {
+            // Marker sized to the head PowerPoint renders (r.arrowheadPx).
+            var markerId = "sm-conn-arrow-" + idx;
+            var marker = document.createElementNS(NS, "marker");
+            marker.setAttribute("id", markerId);
+            marker.setAttribute("viewBox", "0 0 10 10");
+            marker.setAttribute("refX", "9");
+            marker.setAttribute("refY", "5");
+            marker.setAttribute("markerWidth", String(r.arrowheadPx));
+            marker.setAttribute("markerHeight", String(r.arrowheadPx));
+            marker.setAttribute("orient", "auto-start-reverse");
+            marker.setAttribute("markerUnits", "userSpaceOnUse");
+            var tri = document.createElementNS(NS, "path");
+            tri.setAttribute("d", "M0,0 L10,5 L0,10 z");
+            tri.setAttribute("fill", color);
+            tri.setAttribute("fill-opacity", String(r.strokeAlpha));
+            marker.appendChild(tri);
+            defs.appendChild(marker);
+            if (r.arrowStart) path.setAttribute("marker-start", "url(#" + markerId + ")");
+            if (r.arrowEnd) path.setAttribute("marker-end", "url(#" + markerId + ")");
+          }
+          svg.appendChild(path);
+        });
+        if (svg.childNodes.length > 1) container.appendChild(svg);
+      }
+      function smScheduleConnectors(container) {
+        requestAnimationFrame(function () { requestAnimationFrame(function () { smDrawConnectors(container); }); });
+      }
+
       if (printMode) {
         document.body.classList.add("deck--print");
         var printDeck = document.createElement("div");
@@ -699,6 +948,7 @@ __RUNTIME_APPLIER__
           ReactDOM.createRoot(page).render(
             React.createElement(slide.Component, { assetsPath: "./assets" })
           );
+          smScheduleConnectors(page);
         });
         return;
       }
@@ -788,6 +1038,7 @@ __RUNTIME_APPLIER__
         root.render(
           React.createElement(slide.Component, { assetsPath: "./assets" })
         );
+        smScheduleConnectors(stage);
         updateThumbs();
       }
 
@@ -898,6 +1149,12 @@ export async function buildDeck(deckDir, opts = {}) {
   );
   await lintSlidesOrThrow({ deckDir, slideFiles, layoutSources });
 
+  // The <Chart> stand-in runtime rides in the same bundle cache (see
+  // loadChartPreview) — resolved after lint, which already proved the bundle
+  // is materialized.
+  const chartPreview = await loadChartPreview(resolveBundleDirForDeck(deckDir));
+  const connectorPreview = await loadConnectorPreview(resolveBundleDirForDeck(deckDir));
+
   copyDesignSystem(deckDir, skill);
 
   const layoutsBlock = layoutFiles.map(inlineLayout).join("\n");
@@ -908,11 +1165,25 @@ export async function buildDeck(deckDir, opts = {}) {
   const svgAssets = collectSvgAssets(deckDir);
 
   const html = HTML_TEMPLATE.replace("__TITLE__", path.basename(deckDir))
+    .replace("__BRAND_FONT_FACES__", brandFontFaces(deckDir, skill))
     .replace("__LAYOUTS__", layoutsBlock)
     .replace("__SLIDES__", slidesBlock)
     .replace("__OVERRIDES__", safeInlineJson(loadOverrides(deckDir)))
     .replace("__SVG_ASSETS__", safeInlineJson(svgAssets))
-    .replace("__RUNTIME_APPLIER__", safeInline(fs.readFileSync(RUNTIME_APPLIER, "utf8")));
+    .replace("__RUNTIME_APPLIER__", safeInline(fs.readFileSync(RUNTIME_APPLIER, "utf8")))
+    // Function replacers: script sources may contain `$&`-style patterns that a
+    // string replacement would expand.
+    .replace("__CHART_THEME_TOKENS__", () => (chartPreview ? chartPreview.tokensCss : ""))
+    .replace("__CHART_PREVIEW_SCRIPTS__", () =>
+      chartPreview
+        ? chartPreview.scripts
+            .map((script) => `  <script>\n${safeInline(script.source)}\n  </script>`)
+            .join("\n")
+        : "",
+    )
+    .replace("__CONNECTOR_PREVIEW_SCRIPT__", () =>
+      connectorPreview ? `  <script>\n${safeInline(connectorPreview.source)}\n  </script>` : "",
+    );
 
   const out = path.join(deckDir, "presentation.html");
   fs.writeFileSync(out, html);
@@ -965,6 +1236,35 @@ const OPENER_EXIT_GRACE_MS = 2000;
 // user to open manually unless `quiet` — callers with their own messaging (the
 // review/plan gates) pass quiet:true and speak for themselves.
 export function openInBrowser(target, { quiet = false } = {}) {
+  // Machine-level browser kill-switch for headless simulation batches
+  // (scripts/codex-sim.mjs writes it for the batch, removes it after): every
+  // env/PATH/cwd channel for reaching a sim session proved lossy at least
+  // once, so the LAST line of defense is a HOME-scoped marker no shell can
+  // strip. Stale-guarded to 6h so a crashed batch can't silently disable the
+  // browser for real use forever.
+  // Two locations: the config dir, and THIS MODULE'S OWN DIRECTORY — session
+  // shells have shown unreliable HOME/XDG resolution, but a session that runs
+  // this code by definition resolves __dirname correctly.
+  for (const kill of [
+    path.join(
+      process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"),
+      "slidemind",
+      "suppress-browser",
+    ),
+    path.join(__dirname, ".sim-suppress-browser"),
+  ]) {
+    try {
+      const age = Date.now() - fs.statSync(kill).mtimeMs;
+      if (age < 6 * 60 * 60 * 1000) {
+        if (!quiet) {
+          process.stderr.write(`browser suppressed (simulation) — open ${target} manually\n`);
+        }
+        return Promise.resolve(false);
+      }
+    } catch {
+      // marker absent — keep checking / open normally
+    }
+  }
   const chain = openerChain(target);
   return new Promise((resolve) => {
     const tryAt = (i) => {
@@ -1012,10 +1312,15 @@ function parseArgs(argv) {
       args.deck = argv[++i];
     } else if (a === "--open") {
       args.open = true;
+    } else if (a === "--fix") {
+      args.fix = true;
     } else if (a === "-h" || a === "--help") {
       process.stdout.write(
-        "Usage: slidemind build <deck> [--open]\n" +
-          "       node src/builders/build.mjs --deck <deck> [--open]\n",
+        "Usage: slidemind build <deck> [--open] [--fix]\n" +
+          "       node src/builders/build.mjs --deck <deck> [--open] [--fix]\n" +
+          "  --fix  apply the deterministic lint autofixes to slides/*.jsx before building\n" +
+          "         (pin inline-svg px size from its viewBox; letter-spacing em→px where the\n" +
+          "         block's px font-size makes the conversion exact)\n",
       );
       process.exit(0);
     } else {
@@ -1033,6 +1338,15 @@ function parseArgs(argv) {
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   const deckDir = path.resolve(args.deck);
+  if (args.fix) {
+    const { fixDeckSlides } = await import("./lint-fix.mjs");
+    const fixed = fixDeckSlides(deckDir);
+    if (fixed.fixes) {
+      process.stdout.write(
+        `Autofixed ${fixed.fixes} lint issue(s) in ${fixed.files} slide file(s) — re-read any file before patching it.\n`,
+      );
+    }
+  }
   const { out, slideCount } = await buildDeck(deckDir);
   const rel = path.relative(process.cwd(), out) || out;
   process.stdout.write(`Built ${rel}  (${slideCount} slides)\n`);