slidemind 0.3.13 → 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

@@ -276,6 +276,25 @@ export async function loadConnectorPreview(bundleDir) {
   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");