slidemind 0.3.12 → 0.3.14

package/src/bridge/bundle.mjs

@@ -50,6 +50,7 @@ import {
   getDesignBundle,
   getDesignBundleForBrand,
   getDesignBundleForBrandAnyBackend,
+  listBrands,
 } from "./client.mjs";
 import { updateCliInstruction } from "../install-channel.mjs";
 
@@ -655,6 +656,74 @@ export function readDeckBundleRef(deckDir) {
 // Resolve the materialized bundle directory a deck should read its design files
 // from (via the deck's .bundle-ref.json). Returns null when no bundle has been
 // materialized for the deck's CD yet.
+// Re-sync a bound deck's design bundle to the design as it stands right now.
+//
+// `ready` materializes at session start, but a corporate design can change
+// while a session runs, and every local step afterwards (HTML build, lint,
+// capture, the draft checks, and the etag the server render is validated
+// against) reads this cached copy. So the deck commands call this first: the
+// sync is etag-gated and incremental, so an unchanged design downloads nothing.
+//
+// Returns { result, changed } — `changed` is true when the design's etag moved,
+// in which case the deck's ref is rewritten to the new one. Returns null when
+// the deck is unbound or the backend cannot be reached: a stale-but-present
+// bundle is what keeps the host-free steps host-free.
+export async function refreshDeckBundle(deckDir) {
+  if (!deckDir) return null;
+  const ref = readDeckBundleRef(deckDir);
+  if (!ref?.presFP) return null; // unbound — `ready <deck>` binds it
+  // A refresh must never make a host-free step wait like a render does: a dead
+  // backend has to fall back to the cached bundle in seconds, not the 35s
+  // default plus retries. A negative delay list filters to empty, which also
+  // turns the transient retry off — the next command retries anyway.
+  const prev = {
+    SLIDEMIND_BRIDGE_TIMEOUT_MS: process.env.SLIDEMIND_BRIDGE_TIMEOUT_MS,
+    SLIDEMIND_BRIDGE_RETRY_DELAYS_MS: process.env.SLIDEMIND_BRIDGE_RETRY_DELAYS_MS,
+  };
+  process.env.SLIDEMIND_BRIDGE_TIMEOUT_MS ??=
+    process.env.SLIDEMIND_BUNDLE_REFRESH_TIMEOUT_MS || "6000";
+  process.env.SLIDEMIND_BRIDGE_RETRY_DELAYS_MS ??= "-1";
+  try {
+    const result = await materializeBundle(null, { brandId: ref.presFP });
+    if (!result) return null;
+    const changed = Boolean(result.etag) && result.etag !== ref.etag;
+    if (changed) {
+      writeDeckBundleRef(deckDir, { presFP: result.presFP, etag: result.etag });
+    }
+    return { result, changed };
+  } catch {
+    return null; // offline / unconnected / design withdrawn — keep the cache
+  } finally {
+    for (const [k, v] of Object.entries(prev)) {
+      if (v === undefined) delete process.env[k];
+      else process.env[k] = v;
+    }
+  }
+}
+
+// The design an UNBOUND deck can be rendered/previewed against WITHOUT a
+// PowerPoint window — the same ladder `ready` walks once no window is in play:
+// the deck's own binding → the one design cached on this machine → the one
+// design the connected backends list. Returns the presFP, or null when nothing
+// answers unambiguously (0 or several of either; no brand route) — the caller
+// then falls back to the window registry, which is the only remaining source
+// of a design (an open presentation's active corporate design) and the one
+// place that legitimately needs the pane.
+export async function resolveWindowlessBrand(deckDir) {
+  const bound = readDeckBundleRef(deckDir)?.presFP;
+  if (bound) return bound;
+  const cached = listCachedBundles();
+  if (cached.length === 1) return cached[0].presFP;
+  if (cached.length > 1) return null;
+  let brands = [];
+  try {
+    brands = await listBrands();
+  } catch {
+    brands = [];
+  }
+  return brands.length === 1 ? brands[0].presFP : null;
+}
+
 export function resolveBundleDirForDeck(deckDir) {
   const ref = readDeckBundleRef(deckDir);
   if (!ref?.presFP) return null;

package/src/bridge/capture.mjs

@@ -145,8 +145,9 @@ export function buildCaptureInput(deckDir, bundleDir) {
 }
 
 // Launch a headless Chrome, run `fn`, then tear it down — mirrors the add-in's
-// withBrowser (waits for the process to fully exit before cleanup).
-async function withBrowser(fn) {
+// withBrowser (waits for the process to fully exit before cleanup). Exported
+// for the draft-check grid overlay, which reuses the same pinned Chrome.
+export async function withBrowser(fn) {
   // Test hook: run the engine with no real browser. Only safe with a fake
   // engine that ignores its `browser` argument — never set in production.
   if (process.env.SLIDEMIND_CAPTURE_BROWSERLESS === "1") {
@@ -162,11 +163,25 @@ async function withBrowser(fn) {
   // the bundle-shipped fonts are identical at the same pinned version, so text
   // measurement parity with the add-in's renderer is preserved.
   // SLIDEMIND_CAPTURE_FULL_CHROME=1 forces the full binary for A/B debugging.
-  const browser = await puppeteer.launch({
-    headless: process.env.SLIDEMIND_CAPTURE_FULL_CHROME === "1" ? true : "shell",
-    protocolTimeout: 600_000,
-    args: LAUNCH_ARGS,
-  });
+  const launch = (args) =>
+    puppeteer.launch({
+      headless: process.env.SLIDEMIND_CAPTURE_FULL_CHROME === "1" ? true : "shell",
+      protocolTimeout: 600_000,
+      args,
+    });
+  let browser;
+  try {
+    browser = await launch(LAUNCH_ARGS);
+  } catch (err) {
+    // Codex's workspace-write seatbelt denies the mach-port rendezvous the
+    // browser process uses to hand off to its renderer ("bootstrap_check_in
+    // … Permission denied"), so a multi-process launch dies before the first
+    // page. Single-process keeps the renderer in-process — no rendezvous —
+    // and paints identically (same Blink/Skia, same fonts). Retried only on a
+    // launch failure, so every other environment keeps the stock launch.
+    if (!/Failed to launch the browser process/i.test(String(err?.message ?? err))) throw err;
+    browser = await launch([...LAUNCH_ARGS, "--single-process", "--no-zygote"]);
+  }
   try {
     return await fn(browser);
   } finally {
@@ -199,7 +214,7 @@ async function withBrowser(fn) {
  * Throws if the engine is missing/corrupt or the local browser can't launch —
  * the caller decides whether to fall back to the server render path.
  */
-export async function captureDeckLocally({ deckDir, bundleDir, onProgress }) {
+export async function captureDeckLocally({ deckDir, bundleDir, onProgress, only = null }) {
   const enginePath = path.join(bundleDir, "capture-engine.mjs");
   if (!fs.existsSync(enginePath)) {
     throw new Error(`no capture engine in bundle ${bundleDir}`);
@@ -218,6 +233,15 @@ export async function captureDeckLocally({ deckDir, bundleDir, onProgress }) {
   }
 
   const input = buildCaptureInput(deckDir, bundleDir);
+  // `only`: capture a subset of the authored slides (a per-slide builder
+  // re-checking its own file) — the engine renders each slide on its own, so
+  // dropping the others from the input is exact, not an approximation.
+  if (Array.isArray(only) && only.length > 0) {
+    const keep = new Set(only);
+    for (const name of Object.keys(input.slides)) {
+      if (!keep.has(name)) delete input.slides[name];
+    }
+  }
   return withBrowser((browser) => engine.captureDeck(browser, input, { onProgress }));
 }
 
@@ -232,6 +256,45 @@ export async function captureDeckLocally({ deckDir, bundleDir, onProgress }) {
  * never a silent degradation: such a bundle's lint engine (same deployment)
  * rejects `<Chart>` as an unknown component before a page is ever built.
  */
+/**
+ * The exporter's connector geometry (`connector-derive`) as a browser script
+ * exported from the same artifact (`connectorPreview: { globalName, source }`).
+ * The HTML preview's connector overlay calls it on the measured DOM rects, so
+ * the preview draws the route and arrowhead the .pptx will have. The CLI ships
+ * no connector geometry of its own. null when the bundle has no engine or the
+ * engine predates the export (the overlay then draws nothing and says so).
+ */
+export async function loadConnectorPreview(bundleDir) {
+  if (!bundleDir || !bundleHasCaptureEngine(bundleDir)) return null;
+  const enginePath = path.join(bundleDir, "capture-engine.mjs");
+  const version = readBundleMeta(bundleDir).captureEngineVersion ?? "0";
+  const engine = await import(
+    `${pathToFileURL(enginePath).href}?v=${encodeURIComponent(version)}`
+  );
+  const preview = engine.connectorPreview;
+  if (!preview || typeof preview.source !== "string") return null;
+  return { globalName: String(preview.globalName || "SlidemindConnectorDerive"), source: preview.source };
+}
+
+/**
+ * The measured draft checks (`draftChecks: { fill, typeScale, typeScaleTokens,
+ * overlap }`) exported from the same artifact — the rules the add-in's own
+ * see_draft runs. view-draft calls them on its local capture so both harnesses
+ * teach one contract. The CLI ships no draft-check rule of its own; null when
+ * the bundle has no engine or the engine predates the export.
+ */
+export async function loadDraftChecks(bundleDir) {
+  if (!bundleDir || !bundleHasCaptureEngine(bundleDir)) return null;
+  const enginePath = path.join(bundleDir, "capture-engine.mjs");
+  const version = readBundleMeta(bundleDir).captureEngineVersion ?? "0";
+  const engine = await import(
+    `${pathToFileURL(enginePath).href}?v=${encodeURIComponent(version)}`
+  );
+  const checks = engine.draftChecks;
+  if (!checks || typeof checks.fill !== "function") return null;
+  return checks;
+}
+
 export async function loadChartPreview(bundleDir) {
   if (!bundleDir || !bundleHasCaptureEngine(bundleDir)) return null;
   const enginePath = path.join(bundleDir, "capture-engine.mjs");