@agent-native/core 0.157.9 → 0.157.10

package/corpus/templates/slides/actions/import-file.ts

@@ -14,7 +14,10 @@ import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
 import { notifyClients } from "../server/handlers/decks.js";
-import { uploadPptxSlideImages } from "../server/handlers/import/pptx-assets.js";
+import {
+  assertPptxImagesRenderable,
+  uploadPptxSlideImages,
+} from "../server/handlers/import/pptx-assets.js";
 import { upsertBuilderProxyDesignSystem } from "../server/lib/builder-design-system-proxy.js";
 import { setupPdfParse } from "../server/lib/pdf-parse-setup.js";
 import {
@@ -148,6 +151,7 @@ export default defineAction({
         await assertAccess("deck", deckId, "editor");
         const pptxOwnerEmail = getRequestUserEmail();
         if (!pptxOwnerEmail) throw new Error("no authenticated user");
+        assertPptxImagesRenderable(presentation.slides);
         const pptxThemeFont = presentation.theme?.fonts?.[0];
         const uploadLimit = pLimit(4);
         const pptxResults = await Promise.all(
@@ -198,6 +202,7 @@ export default defineAction({
           aspectRatio,
           sourceImport,
           pptxResults[0]?.sourceText,
+          presentation.theme,
         );
         return {
           format: "pptx",
@@ -700,6 +705,7 @@ async function appendDeckSlides(
   aspectRatio?: AspectRatio,
   sourceImport?: ReturnType<typeof buildSourceImportMetadata>,
   titleSource?: unknown,
+  theme?: import("../server/handlers/import/pptx-parser.js").ParsedPresentation["theme"],
 ): Promise<string> {
   await assertAccess("deck", deckId, "editor");
 
@@ -748,6 +754,15 @@ async function appendDeckSlides(
       title: nextTitle,
       slides: [...previousSlides, ...slides],
       ...(!hadExistingSlides && aspectRatio ? { aspectRatio } : {}),
+      // Same rule as aspectRatio above: an appended file's palette only
+      // becomes the deck's theme when the deck had no slides yet, so
+      // appending onto an existing deck can't silently restyle every slide
+      // already on it. Deliberately keyed on slides rather than on whether a
+      // theme already exists: export writes one deck-level theme (OOXML allows
+      // one per master), so with zero slides there is nothing to protect, and
+      // refusing a new theme there would strand a deck whose slides were
+      // deleted with the old file's palette, unfixable by re-importing.
+      ...(!hadExistingSlides && theme ? { theme } : {}),
       ...(nextSourceImport ? { sourceImport: nextSourceImport } : {}),
       updatedAt: writeNow,
     };

package/corpus/templates/slides/actions/import-pptx.ts

@@ -12,7 +12,10 @@ import { z } from "zod";
 import { getDb, schema } from "../server/db/index.js";
 import { notifyClients } from "../server/handlers/decks.js";
 import { convertToSlideHtml } from "../server/handlers/import/html-converter.js";
-import { uploadPptxSlideImages } from "../server/handlers/import/pptx-assets.js";
+import {
+  assertPptxImagesRenderable,
+  uploadPptxSlideImages,
+} from "../server/handlers/import/pptx-assets.js";
 import {
   parsePptx,
   type ParsedElement,
@@ -27,6 +30,7 @@ import {
 } from "../shared/aspect-ratios.js";
 import { getDeckUrl } from "./_app-url.js";
 import { readUserUploadedFile } from "./_uploaded-files.js";
+import { withDeckLock } from "./patch-deck.js";
 
 export interface ImportedImageFallback {
   slideIndex: number;
@@ -121,9 +125,18 @@ export async function importPptxBufferToDeck(args: {
   // Check edit access before uploading any embedded images — uploads are
   // a side effect with real storage cost, so an unauthorized caller must
   // be rejected before that side effect happens, not after.
+  const db = getDb();
   if (deckId) {
     await assertAccess("deck", deckId, "editor");
+    const [deck] = await db
+      .select()
+      .from(schema.decks)
+      .where(eq(schema.decks.id, deckId));
+    if (!deck) {
+      throw new Error(`Deck ${deckId} not found`);
+    }
   }
+  assertPptxImagesRenderable(presentation.slides);
 
   // Convert each parsed slide to its positioned scene graph, uploading every
   // browser-renderable image so the imported deck keeps the source layering
@@ -193,56 +206,60 @@ export async function importPptxBufferToDeck(args: {
     presentation.slides[0]?.heightEmu,
   );
 
-  const db = getDb();
   const now = new Date().toISOString();
 
   if (deckId) {
-    const existing = await db
-      .select()
-      .from(schema.decks)
-      .where(eq(schema.decks.id, deckId));
+    return withDeckLock(deckId, async () => {
+      // Image uploads happen before this lock because they are independent of
+      // the deck row. Re-read inside the lock so the replacement is based on
+      // the latest deck data rather than the preflight snapshot.
+      const [latestDeck] = await db
+        .select()
+        .from(schema.decks)
+        .where(eq(schema.decks.id, deckId));
+      if (!latestDeck) {
+        throw new Error(`Deck ${deckId} not found`);
+      }
 
-    if (!existing.length) {
-      throw new Error(`Deck ${deckId} not found`);
-    }
-
-    const previousData = safeParseDeckData(existing[0].data);
-    const data = {
-      ...previousData,
-      title: deckTitle,
-      slides,
-      ...(aspectRatio ? { aspectRatio } : {}),
-      sourceImport,
-      updatedAt: now,
-    };
-    await db
-      .update(schema.decks)
-      .set({
+      const previousData = safeParseDeckData(latestDeck.data);
+      const data = {
+        ...previousData,
         title: deckTitle,
-        data: JSON.stringify(data),
-        ...(designSystemId !== undefined
-          ? { designSystemId }
-          : { designSystemId: existing[0].designSystemId }),
+        slides,
+        ...(aspectRatio ? { aspectRatio } : {}),
+        ...(presentation.theme ? { theme: presentation.theme } : {}),
+        sourceImport,
         updatedAt: now,
-      })
-      .where(eq(schema.decks.id, deckId));
+      };
+      await db
+        .update(schema.decks)
+        .set({
+          title: deckTitle,
+          data: JSON.stringify(data),
+          ...(designSystemId !== undefined
+            ? { designSystemId }
+            : { designSystemId: latestDeck.designSystemId }),
+          updatedAt: now,
+        })
+        .where(eq(schema.decks.id, deckId));
 
-    notifyClients(deckId);
-    await writeAppState("refresh-signal", {
-      ts: now,
-      source,
-    });
+      notifyClients(deckId);
+      await writeAppState("refresh-signal", {
+        ts: now,
+        source,
+      });
 
-    return {
-      id: deckId,
-      title: deckTitle,
-      slideCount: slides.length,
-      theme: presentation.theme,
-      imported: true,
-      url: getDeckUrl(deckId),
-      ...(imagesSkipped > 0 ? { imagesSkipped } : {}),
-      ...(tablesDegraded > 0 ? { tablesDegraded } : {}),
-    };
+      return {
+        id: deckId,
+        title: deckTitle,
+        slideCount: slides.length,
+        theme: presentation.theme,
+        imported: true,
+        url: getDeckUrl(deckId),
+        ...(imagesSkipped > 0 ? { imagesSkipped } : {}),
+        ...(tablesDegraded > 0 ? { tablesDegraded } : {}),
+      };
+    });
   }
 
   // Create new deck
@@ -251,6 +268,7 @@ export async function importPptxBufferToDeck(args: {
     title: deckTitle,
     slides,
     ...(aspectRatio ? { aspectRatio } : {}),
+    ...(presentation.theme ? { theme: presentation.theme } : {}),
     sourceImport,
     createdAt: now,
     updatedAt: now,

package/corpus/templates/slides/app/components/deck/SlideRenderer.tsx

@@ -528,6 +528,11 @@ function useSlideAutofit(
 
     root.addEventListener("load", scheduleMeasure, true);
     document.fonts?.ready.then(scheduleMeasure).catch(() => {});
+    // An imported deck's webfonts are requested only once its HTML is on
+    // screen, so they can land after `fonts.ready` has already settled. That
+    // reflows text without touching the DOM the observers watch, leaving the
+    // fit transform measured against the fallback font.
+    document.fonts?.addEventListener("loadingdone", scheduleMeasure);
 
     // `rootMargin` measures a thumbnail just before it scrolls in, so the fit
     // transform is already applied by the time it is on screen.
@@ -554,6 +559,7 @@ function useSlideAutofit(
       mutationObserver.disconnect();
       visibilityObserver?.disconnect();
       root.removeEventListener("load", scheduleMeasure, true);
+      document.fonts?.removeEventListener("loadingdone", scheduleMeasure);
     };
   }, [canvasWidth, canvasHeight, fitKey, ref]);
 }
@@ -596,6 +602,186 @@ function AutoFitContent({
   );
 }
 
+/**
+ * Google Fonts families an imported deck may name. Split by what the `css2`
+ * endpoint accepts for each: the first list has a real 100..900 variable
+ * weight axis, the rest only serve discrete weights. Asking for an axis a
+ * family does not have is a 400 for the whole request, so both lists were
+ * checked against the live endpoint rather than guessed from the name.
+ */
+const VARIABLE_AXIS_GOOGLE_FONTS = [
+  "Archivo",
+  "Asap",
+  "Catamaran",
+  "Chivo",
+  "DM Sans",
+  "Epilogue",
+  "Exo 2",
+  "Geist",
+  "Heebo",
+  "Inter",
+  "Jost",
+  "League Spartan",
+  "Lexend",
+  "Libre Franklin",
+  "Montserrat",
+  "Noto Sans",
+  "Noto Serif",
+  "Onest",
+  "Outfit",
+  "Overpass",
+  "Public Sans",
+  "Raleway",
+  "Roboto",
+  "Roboto Condensed",
+  "Roboto Slab",
+  "Urbanist",
+  "Work Sans",
+];
+
+const STATIC_WEIGHT_GOOGLE_FONTS = [
+  "Abril Fatface",
+  "Anton",
+  "Arimo",
+  "Assistant",
+  "Barlow",
+  "Barlow Condensed",
+  "Bebas Neue",
+  "Bodoni Moda",
+  "Bricolage Grotesque",
+  "Cabin",
+  "Caveat",
+  "Cormorant Garamond",
+  "Cousine",
+  "Crimson Text",
+  "Dancing Script",
+  "David Libre",
+  "EB Garamond",
+  "Figtree",
+  "Fira Sans",
+  "Hind",
+  "Homemade Apple",
+  "IBM Plex Sans",
+  "Inconsolata",
+  "Instrument Sans",
+  "Josefin Sans",
+  "Kanit",
+  "Karla",
+  "Lato",
+  "Libre Baskerville",
+  "Lora",
+  "Manrope",
+  "Merriweather",
+  "Mulish",
+  "Nova Square",
+  "Nunito",
+  "Nunito Sans",
+  "Open Sans",
+  "Oswald",
+  "Oxygen",
+  "PT Sans",
+  "PT Serif",
+  "Pacifico",
+  "Playfair Display",
+  "Plus Jakarta Sans",
+  "Poppins",
+  "Prompt",
+  "Quicksand",
+  "Red Hat Display",
+  "Roboto Mono",
+  "Rubik",
+  "Schibsted Grotesk",
+  "Sora",
+  "Source Sans 3",
+  "Space Grotesk",
+  "Syne",
+  "Teko",
+  "Tinos",
+  "Titillium Web",
+  "Ubuntu",
+  "Yanone Kaffeesatz",
+];
+
+/** Families decks still name under a name Google Fonts does not serve. */
+const GOOGLE_FONT_ALIASES: Record<string, string> = {
+  "source sans pro": "source sans 3",
+  bodoni: "bodoni moda",
+};
+
+/**
+ * PPTX stores a weight as part of the typeface name — a Work Sans deck is full
+ * of runs set in `Work Sans Medium` — but a webfont family covers its whole
+ * weight range, so the suffixed name matches nothing and falls back to the
+ * generic sans that made every imported deck look unstyled.
+ */
+const FONT_WEIGHT_SUFFIX =
+  /\s+(?:thin|extra ?light|ultra ?light|light|book|regular|normal|medium|semi ?bold|demi ?bold|bold|extra ?bold|ultra ?bold|black|heavy|italic|oblique)$/i;
+
+const GOOGLE_FONTS = new Map<string, { family: string; href: string }>();
+for (const [families, axis] of [
+  [VARIABLE_AXIS_GOOGLE_FONTS, "ital,wght@0,100..900;1,100..900"],
+  [STATIC_WEIGHT_GOOGLE_FONTS, "ital,wght@0,400;0,700;1,400;1,700"],
+] as const) {
+  for (const family of families) {
+    GOOGLE_FONTS.set(family.toLowerCase(), {
+      family,
+      href: `https://fonts.googleapis.com/css2?family=${family.replace(/ /g, "+")}:${axis}&display=swap`,
+    });
+  }
+}
+
+/** The webfont that should render `name`, or undefined when none can. */
+export function resolveImportedFont(
+  name: string,
+): { family: string; href: string } | undefined {
+  const key = name
+    .replace(/["']/g, "")
+    .trim()
+    .replace(/\s+/g, " ")
+    .toLowerCase();
+  if (!key) return undefined;
+  const lookup = (candidate: string) =>
+    GOOGLE_FONTS.get(GOOGLE_FONT_ALIASES[candidate] ?? candidate);
+  return lookup(key) ?? lookup(key.replace(FONT_WEIGHT_SUFFIX, "").trim());
+}
+
+/**
+ * Point every quoted `font-family` in imported slide HTML at a family we can
+ * actually serve, and collect the stylesheets that serve them. Families we
+ * cannot serve are left exactly as authored so the browser can still match a
+ * locally installed copy.
+ */
+export function prepareImportedFonts(html: string): {
+  html: string;
+  hrefs: string[];
+} {
+  const hrefs = new Set<string>();
+  const rewritten = html.replace(
+    /(font-family:\s*)'([^']*)'/gi,
+    (match, prefix: string, name: string) => {
+      const font = resolveImportedFont(name);
+      if (!font) return match;
+      hrefs.add(font.href);
+      return `${prefix}'${font.family}'`;
+    },
+  );
+  return { html: rewritten, hrefs: [...hrefs] };
+}
+
+const injectedFontHrefs = new Set<string>();
+
+function loadImportedFonts(hrefs: string[]) {
+  if (typeof document === "undefined") return;
+  for (const href of hrefs) {
+    if (injectedFontHrefs.has(href)) continue;
+    injectedFontHrefs.add(href);
+    const link = document.createElement("link");
+    link.rel = "stylesheet";
+    link.href = href;
+    document.head.appendChild(link);
+  }
+}
+
 /** Renders blank slide HTML content and applies white filter to logo images */
 function BlankSlideContent({ content }: { content: string }) {
   const scopeId = `slide-${useId().replace(/[^a-zA-Z0-9_-]/g, "")}`;
@@ -607,36 +793,43 @@ function BlankSlideContent({ content }: { content: string }) {
   // literal each render therefore wipes any DOM mutations made on children. That
   // includes the per-block `contentEditable="true"` set by SlideEditor's
   // double-click-to-edit flow, which made inline text editing appear to do nothing.
-  const { mermaidBlocks, htmlWithPlaceholders, dangerousHtml } = useMemo(() => {
-    // Extract mermaid blocks BEFORE sanitization — see mermaid-blocks.ts for
-    // why (sanitizer HTML-escaping breaks the mermaid parser).
-    const { blocks, contentWithPlaceholders } = extractMermaidBlocks(content);
-
-    // Apply white filter to all logo images (brandfetch, logo.dev, etc.) for dark backgrounds
-    const processed = sanitizeSlideHtml(
-      contentWithPlaceholders.replace(
-        /(<img\s+(?=[^>]*src="[^"]*(?:brandfetch|logo\.dev)[^"]*")[^>]*)(\/?>)/gi,
-        (_match, before, close) => {
-          if (before.includes('style="')) {
-            return (
-              before.replace(
-                'style="',
-                'style="filter:brightness(0) invert(1);',
-              ) + close
-            );
-          }
-          return before + ' style="filter:brightness(0) invert(1);"' + close;
-        },
-      ),
-      { scopeSelector },
-    );
+  const { mermaidBlocks, htmlWithPlaceholders, dangerousHtml, fontHrefs } =
+    useMemo(() => {
+      // Extract mermaid blocks BEFORE sanitization — see mermaid-blocks.ts for
+      // why (sanitizer HTML-escaping breaks the mermaid parser).
+      const { blocks, contentWithPlaceholders } = extractMermaidBlocks(content);
+
+      // Apply white filter to all logo images (brandfetch, logo.dev, etc.) for dark backgrounds
+      const sanitized = sanitizeSlideHtml(
+        contentWithPlaceholders.replace(
+          /(<img\s+(?=[^>]*src="[^"]*(?:brandfetch|logo\.dev)[^"]*")[^>]*)(\/?>)/gi,
+          (_match, before, close) => {
+            if (before.includes('style="')) {
+              return (
+                before.replace(
+                  'style="',
+                  'style="filter:brightness(0) invert(1);',
+                ) + close
+              );
+            }
+            return before + ' style="filter:brightness(0) invert(1);"' + close;
+          },
+        ),
+        { scopeSelector },
+      );
+      const { html: processed, hrefs } = prepareImportedFonts(sanitized);
 
-    return {
-      mermaidBlocks: blocks,
-      htmlWithPlaceholders: processed,
-      dangerousHtml: { __html: processed },
-    };
-  }, [content]);
+      return {
+        mermaidBlocks: blocks,
+        htmlWithPlaceholders: processed,
+        dangerousHtml: { __html: processed },
+        fontHrefs: hrefs,
+      };
+    }, [content]);
+
+  useEffect(() => {
+    loadImportedFonts(fontHrefs);
+  }, [fontHrefs]);
 
   if (mermaidBlocks.length > 0) {
     return (

package/corpus/templates/slides/app/components/editor/ExportMenu.tsx

@@ -35,12 +35,52 @@ import {
   DropdownMenuSubContent,
   DropdownMenuSubTrigger,
 } from "@/components/ui/dropdown-menu";
+import { useDecks } from "@/context/DeckContext";
 import type { GoogleSlidesExportResult } from "@/lib/export-google-slides-client";
 
 /** Google Slides' File → Import dialog, primed to ask for a file. */
 const GOOGLE_SLIDES_IMPORT_URL =
   "https://docs.google.com/presentation/u/0/?usp=import";
 
+/**
+ * The importer stamps this on every slide it writes, and `parseSlideHtml` in
+ * actions/export-pptx.ts branches on the same marker: those slides carry the
+ * source file's own geometry, which the server emits as real `custGeom` vector
+ * shapes. dom-to-pptx has no custGeom at all and rasterizes them to PNGs.
+ */
+const IMPORTED_SLIDE_MARKER = 'data-imported-pptx="true"';
+
+/**
+ * Objects whose geometry only exists once a browser has laid the slide out:
+ * `freezeSlideElementForFreeform` and the text-box tool mint
+ * `data-slide-object-id` client-side, while every object the importer emits
+ * also carries `data-pptx-element-kind`. The server has no layout engine to
+ * measure the former, so it refuses those slides rather than reflowing them.
+ */
+const BROWSER_AUTHORED_OBJECT =
+  "[data-slide-object-id]:not([data-pptx-element-kind]), .fmd-freeform-object";
+
+/**
+ * Whether the vector-capable server exporter can render this deck losslessly.
+ * `get-deck` returns the import receipt alongside the deck body, so the client
+ * deck carries `sourceImport` at runtime even though the type predates it.
+ */
+export function canExportPptxFromServer(
+  deck:
+    | { sourceImport?: unknown; slides: { content?: string }[] }
+    | null
+    | undefined,
+): boolean {
+  if (!deck?.sourceImport || deck.slides.length === 0) return false;
+  return deck.slides.every((slide) => {
+    const html = slide.content ?? "";
+    if (!html.includes(IMPORTED_SLIDE_MARKER)) return false;
+    return !new DOMParser()
+      .parseFromString(html, "text/html")
+      .querySelector(BROWSER_AUTHORED_OBJECT);
+  });
+}
+
 interface ExportMenuProps {
   deckId: string;
   deckTitle: string;
@@ -76,6 +116,7 @@ export const ExportMenu = forwardRef<ExportMenuHandle, ExportMenuProps>(
     ref,
   ) {
     const t = useT();
+    const { getDeck, flushDeckSave } = useDecks();
     const [googleSlidesImportOpen, setGoogleSlidesImportOpen] = useState(false);
     const googleSlidesImportTarget = useRef<Window | null>(null);
     const triggerBlobDownload = (blob: Blob, filename: string) => {
@@ -108,8 +149,38 @@ export const ExportMenu = forwardRef<ExportMenuHandle, ExportMenuProps>(
       }
     };
 
+    const exportPptxFromServer = async () => {
+      // The server exports the persisted deck, so an unflushed edit would be
+      // missing from the file the user just asked for.
+      await flushDeckSave(deckId);
+      const res = await fetch(`${appBasePath()}/api/exports/pptx`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ deckId }),
+      });
+      if (!res.ok) {
+        throw new Error(
+          await readErrorMessage(res, t("editorExport.exportPptxError")),
+        );
+      }
+      triggerBlobDownload(
+        await res.blob(),
+        filenameFromDisposition(
+          res.headers.get("content-disposition"),
+          ".pptx",
+        ),
+      );
+    };
+
     const handleExportPptx = async () => {
       try {
+        // An imported deck's shapes survive only on the server path. Falling
+        // back to the browser exporter on failure would hand back rasterized
+        // silhouettes of the same deck without saying so.
+        if (canExportPptxFromServer(getDeck(deckId))) {
+          await exportPptxFromServer();
+          return;
+        }
         await onExportPptx();
       } catch (err) {
         console.error("Export failed:", err);

package/corpus/templates/slides/app/global.css

@@ -537,9 +537,21 @@ button[title="Open agent sidebar"] {
 }
 
 .fmd-autofit-scale {
+  transform-origin: top left;
+}
+
+/* Only apply the fit transform once autofit is actually shrinking content
+   (see SlideRenderer's `data-fmd-autofit-active`). Any non-"none" `transform`
+   value — even the identity transform this rule used to apply unconditionally
+   — creates a new containing block for `position: absolute` descendants
+   (CSS Transforms spec). Freeform slide objects are authored against the
+   full `.fmd-slide` box; an always-on transform here silently re-anchored
+   them to this layer's smaller, padding-inset box instead, shifting them
+   off-canvas. Scoping the transform to the active-fit state keeps the
+   common (no scaling needed) case free of a containing block at all. */
+.fmd-autofit-scale[data-fmd-autofit-active] {
   transform: translate(var(--fmd-fit-x, 0px), var(--fmd-fit-y, 0px))
     scale(var(--fmd-fit-scale, 1));
-  transform-origin: top left;
 }
 
 .fmd-slide > [data-fmd-autofit-content] {
@@ -1084,8 +1096,14 @@ button[title="Open agent sidebar"] {
   font-style: normal;
 }
 
+/* An imported PPTX `a:srcRect` crop is rendered by oversizing the `<img>` past
+   its `overflow: hidden` box (e.g. `width: 255%; left: -77%`), so both caps
+   have to be lifted, not just the vertical one — `max-width: 100%` alone
+   silently shrank the image back to its box while the negative `left` kept
+   scrolling, leaving the visible crop window off the picture entirely. */
 .slide-content .fmd-slide img {
   border-radius: 0;
+  max-width: none;
   max-height: none;
   margin: 0;
 }

package/corpus/templates/slides/app/lib/export-google-slides-client.ts

@@ -15,6 +15,40 @@ export type GoogleSlidesExportResult =
   /** The export action should send the user through Google OAuth first. */
   | { url: null; requiresConnection: true; reason: string };
 
+export interface DeckPptxFile {
+  blob: Blob;
+  filename: string;
+}
+
+/**
+ * Renders the deck through the vector-capable server exporter — the only path
+ * that emits the source file's shapes as real `custGeom` geometry. Its
+ * positioned-object guard is rethrown verbatim so the caller can show it
+ * instead of quietly handing Google the rasterized browser export.
+ */
+export async function fetchDeckPptxFromServer(
+  deckId: string,
+  fallbackError: string,
+): Promise<DeckPptxFile> {
+  const res = await fetch(`${appBasePath()}/api/exports/pptx`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ deckId }),
+  });
+  if (!res.ok) {
+    const payload = (await res.json().catch(() => null)) as {
+      error?: string;
+      message?: string;
+    } | null;
+    throw new Error(payload?.error || payload?.message || fallbackError);
+  }
+  const disposition = res.headers.get("content-disposition");
+  return {
+    blob: await res.blob(),
+    filename: disposition?.match(/filename="?([^"]+)"?/i)?.[1] ?? "deck.pptx",
+  };
+}
+
 function triggerBlobDownload(blob: Blob, filename: string) {
   const url = URL.createObjectURL(blob);
   const a = document.createElement("a");
@@ -37,12 +71,17 @@ export async function exportDeckToGoogleSlides(
   deckTitle: string,
   slides: GoogleSlidesExportSlide[],
   aspectRatio?: AspectRatio,
+  /**
+   * Overrides the browser exporter. Source-imported decks pass
+   * `fetchDeckPptxFromServer`: dom-to-pptx ships no custGeom support, so the
+   * browser build would upload PNG rasterizations of the very shapes Google
+   * Slides can otherwise keep editable.
+   */
+  buildPptx?: () => Promise<DeckPptxFile>,
 ): Promise<GoogleSlidesExportResult> {
-  const { blob, filename } = await buildDeckPptxBlob(
-    deckTitle,
-    slides,
-    aspectRatio,
-  );
+  const { blob, filename } = await (buildPptx
+    ? buildPptx()
+    : buildDeckPptxBlob(deckTitle, slides, aspectRatio));
 
   const form = new FormData();
   form.append("file", blob, filename);