@1agh/maude 1.0.7 → 1.0.8

package/apps/studio/export-dialog.tsx

@@ -26,6 +26,11 @@ import {
   useState,
 } from 'react';
 
+import {
+  defaultScopeForFormat,
+  isScopeValidForFormat,
+  validScopesForFormat,
+} from './exporters/format-scopes.ts';
 import { useSelectionSetOptional } from './use-selection-set.tsx';
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -228,16 +233,6 @@ const SCOPE_META: Record<Scope, { label: string; description: string }> = {
   },
 };
 
-const VALID_SCOPES_PER_FORMAT: Record<Format, Scope[]> = {
-  png: ['selection', 'artboard', 'canvas-as-separate'],
-  pdf: ['selection', 'artboard', 'canvas-as-separate'],
-  svg: ['selection', 'artboard', 'canvas-as-separate'],
-  html: ['artboard', 'canvas-as-separate'],
-  pptx: ['canvas-as-separate'],
-  canva: ['canvas-as-separate'],
-  zip: ['project-raw'],
-};
-
 export interface ExportHistoryEntry {
   format: Format;
   scope: Scope;
@@ -435,7 +430,13 @@ export function ExportDialogProvider({ children }: { children: ReactNode }): Rea
     await loadHistory();
     const last = history[0];
     if (!last) return;
-    await submit(last.format, last.scope, last.options ?? {});
+    // ⌘⇧E replays a history entry verbatim. An entry whose (format, scope)
+    // pair is no longer legal — or never was — would otherwise be re-sent as
+    // an unrenderable job; fall back to that format's default scope.
+    const scope = isScopeValidForFormat(last.format, last.scope)
+      ? last.scope
+      : defaultScopeForFormat(last.format);
+    await submit(last.format, scope, last.options ?? {});
   }, [history, loadHistory, submit]);
 
   const ctxValue = useMemo<ExportDialogValue>(
@@ -528,16 +529,20 @@ const DialogShell = (() => {
 
     useEffect(() => {
       if (!openState) return;
+      const next = openState.format ?? format;
       if (openState.format) setFormat(openState.format);
-      if (openState.scope) setScope(openState.scope);
-    }, [openState]);
+      // DDR-231 Phase 2 T4 — a hint the incoming FORMAT can't render (a
+      // context menu's `project-raw`, a re-opened zip entry) must not be
+      // adopted: it resolves to a file-tree target the render service refuses.
+      if (openState.scope && isScopeValidForFormat(next, openState.scope)) {
+        setScope(openState.scope);
+      }
+    }, [openState, format]);
 
-    // Keep the scope valid against the chosen format.
+    // Keep the scope valid against the chosen format — one shared table,
+    // exporters/format-scopes.ts (DDR-231 Phase 2 T4).
     useEffect(() => {
-      const valid = VALID_SCOPES_PER_FORMAT[format];
-      if (!valid.includes(scope)) {
-        setScope(valid[0] ?? 'artboard');
-      }
+      if (!isScopeValidForFormat(format, scope)) setScope(defaultScopeForFormat(format));
     }, [format, scope]);
 
     if (!openState) {
@@ -575,7 +580,7 @@ const DialogShell = (() => {
               value={scope}
               onChange={(e) => setScope(e.target.value as Scope)}
             >
-              {VALID_SCOPES_PER_FORMAT[format].map((s) => (
+              {validScopesForFormat(format).map((s) => (
                 <option key={s} value={s}>
                   {SCOPE_META[s].label}
                 </option>

package/apps/studio/exporters/_runtime.ts

@@ -126,7 +126,37 @@ export async function spawnShim(args: string[], opts: SpawnShimOptions): Promise
   };
   opts.signal?.addEventListener('abort', onAbort);
 
-  const stderrPromise = new Response(proc.stderr).text();
+  // Stream the shim's stderr LIVE to this process's stderr (prefixed) as well
+  // as buffering it for the exit-code error path. Buffering-only (the old
+  // `new Response(proc.stderr).text()`) hid every diagnostic until the child
+  // EXITED — so a shim that hung (a headless video encode that never resolves)
+  // produced total silence, and even on success the per-stage logs never
+  // surfaced. Live teeing makes the render worker's log show what a shim is
+  // doing while it does it, which is the only window CI/production has into it.
+  const shimTag = path.basename(args[0]).replace(/\.mjs$/, '');
+  const stderrPromise = (async () => {
+    let acc = '';
+    try {
+      const reader = proc.stderr.pipeThrough(new TextDecoderStream()).getReader();
+      let buf = '';
+      for (;;) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        acc += value;
+        buf += value;
+        let nl = buf.indexOf('\n');
+        while (nl !== -1) {
+          process.stderr.write(`[${shimTag}] ${buf.slice(0, nl)}\n`);
+          buf = buf.slice(nl + 1);
+          nl = buf.indexOf('\n');
+        }
+      }
+      if (buf) process.stderr.write(`[${shimTag}] ${buf}\n`);
+    } catch {
+      /* stream closed mid-read — the buffered `acc` still feeds the error path */
+    }
+    return acc;
+  })();
   const stdoutLines: string[] = [];
   let buffer = '';
   const consumeLine = (line: string) => {

package/apps/studio/exporters/capture-chrome.ts

@@ -0,0 +1,111 @@
+// capture-chrome.ts — the ONE list of editor-chrome selectors an export must
+// never carry (DDR-231 Phase 2 T2).
+//
+// `_shell.html` has owned this list since the print-marks RCA, as the
+// `<style id="canvas-hide-chrome" media="not all">` block that `?hide-chrome=1`
+// flips to `media="all"`. That works for every host that NAVIGATES to the shell
+// — the desktop / render-worker playwright spine does exactly that.
+//
+// The browser lane does not navigate: it captures the LIVE canvas the member is
+// looking at, where the block is still `media="not all"` and every overlay is
+// visible by design. The first cloud export shipped the artboard's own
+// `.dc-artboard-label` header straight into the SVG because of it.
+//
+// So the list needs a second consumer, and a list with two consumers drifts —
+// this file is the shared source, and `test/canvas-hide-chrome.test.ts` is the
+// tripwire that fails the moment it and the `_shell.html` block disagree in
+// either direction. Add a new overlay in ONE place and the test tells you the
+// other.
+//
+// Pure data + a DOM helper — no Node imports (this file bundles for the
+// browser through capture-core).
+
+/**
+ * Every editor-affordance selector suppressed during a capture. Kept in the
+ * same order and grouping as the `_shell.html` block so a diff of the two
+ * reads side by side.
+ */
+export const CAPTURE_HIDDEN_SELECTORS: readonly string[] = [
+  // Minimap + zoom + tool palette (and its portaled popovers)
+  '.dc-mm',
+  '.dc-zoom-tb',
+  '.dc-tool-palette',
+  '.dc-tp-popover',
+  '.dc-tp-shape-popover',
+  '.dc-context-menu',
+  // Presence — avatars (top-right) + live cursors
+  '.dc-participants',
+  '.dc-cursor-overlay',
+  // Selection + manipulation chrome
+  '.dc-cv-halo',
+  '.dc-cv-group-bbox',
+  '.dc-cv-eq-spacing-layer',
+  '.dc-multi-artboard-tb',
+  '.dc-elem-ctx-tb',
+  '.dc-snap-guide',
+  '.dc-snap-pill',
+  // Annotations (FigJam-style draw layer)
+  '.dc-annot-svg',
+  '.dc-annot-ctx',
+  '.dc-annot-resize-handle',
+  // Comments — pins, threads, composer, @mention popup
+  '.cm-layer',
+  '.cm-pin',
+  '.cm-thread',
+  '.cm-composer',
+  '.cm-mention-popup',
+  // Inspector pin overlay injected into every served shell (inspect.ts)
+  '.dgn-pin',
+  '#dgn-pin-layer',
+  // HUDs + banners
+  '.dc-ai-banner',
+  '.dc-undo-hud',
+  // Activity overlay — live "agent works here" chrome (Phase 13 / DDR-029)
+  '.dc-activity-rim',
+  // HMR "holding last good" toast (Phase 13.1 / DDR-077)
+  '.dc-hmr-holding',
+  // Artboard title/label button (editor affordance, not design content)
+  '.dc-artboard-label',
+  // Print/bleed/trim/margin guide overlay (feature-2-print-artboards)
+  '.dc-artboard-guides',
+  // Generic opt-in hooks for any future floating overlay
+  '[data-dc-overlay]',
+  '[data-mdcc-annotations]',
+];
+
+/** The CSS rule body both hosts apply. */
+export function captureChromeCss(): string {
+  return `${CAPTURE_HIDDEN_SELECTORS.join(',')}{display:none !important}`;
+}
+
+const STYLE_ID = 'maude-capture-chrome';
+
+/**
+ * Hide editor chrome for the duration of a capture and return the undo.
+ *
+ * Idempotent and ref-counted: a multi-artboard capture calls this once per
+ * target through {@link import('./capture-core.ts').svgForElement}, and nesting
+ * (the shim host navigates with `?hide-chrome=1` AND runs this) must not leave
+ * a half-removed style behind. The live-canvas host MUST call the returned undo
+ * — the member is looking at this DOM.
+ */
+export function applyCaptureChrome(doc: Document): () => void {
+  const existing = doc.getElementById(STYLE_ID) as (HTMLStyleElement & { _refs?: number }) | null;
+  if (existing) {
+    existing._refs = (existing._refs ?? 1) + 1;
+    return () => releaseCaptureChrome(doc);
+  }
+  const style = doc.createElement('style') as HTMLStyleElement & { _refs?: number };
+  style.id = STYLE_ID;
+  style._refs = 1;
+  style.textContent = captureChromeCss();
+  (doc.head ?? doc.documentElement).appendChild(style);
+  return () => releaseCaptureChrome(doc);
+}
+
+function releaseCaptureChrome(doc: Document): void {
+  const style = doc.getElementById(STYLE_ID) as (HTMLStyleElement & { _refs?: number }) | null;
+  if (!style) return;
+  style._refs = (style._refs ?? 1) - 1;
+  if (style._refs <= 0) style.remove();
+}