@agent-native/core 0.157.8 → 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(
@@ -162,6 +166,10 @@ export default defineAction({
           (total, r) => total + r.imageSkippedCount,
           0,
         );
+        const tablesDegraded = presentation.slides.reduce(
+          (total, s) => total + (s.tablesDegraded ?? 0),
+          0,
+        );
         const sourceImport = buildSourceImportMetadata({
           format: "pptx",
           slides: pptxResults.map((result) => ({
@@ -172,6 +180,7 @@ export default defineAction({
             editableText: true,
           })),
           imagesSkipped,
+          tablesDegraded,
         });
         if (imagesSkipped > 0) {
           throw new Error(
@@ -193,6 +202,7 @@ export default defineAction({
           aspectRatio,
           sourceImport,
           pptxResults[0]?.sourceText,
+          presentation.theme,
         );
         return {
           format: "pptx",
@@ -202,6 +212,7 @@ export default defineAction({
           deckId,
           imported: true,
           ...(imagesSkipped > 0 ? { imagesSkipped } : {}),
+          ...(tablesDegraded > 0 ? { tablesDegraded } : {}),
         };
       }
 
@@ -527,9 +538,14 @@ async function importPdfPagesWithFidelity(args: {
     ),
   );
   const slides = imported.map((entry) => entry.slide);
+  const imagesSkipped = fidelityPages.reduce(
+    (total, page) => total + page.imagesSkipped,
+    0,
+  );
   const sourceImport = buildSourceImportMetadata({
     format: "pdf",
     slides: imported.map((entry) => entry.snapshot),
+    imagesSkipped,
   });
 
   const importedTitle = await appendDeckSlides(
@@ -550,6 +566,7 @@ async function importPdfPagesWithFidelity(args: {
     aspectRatio,
     deckId,
     imported: true,
+    ...(imagesSkipped > 0 ? { imagesSkipped } : {}),
   };
 }
 
@@ -688,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");
 
@@ -736,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;
@@ -100,6 +104,7 @@ export async function importPptxBufferToDeck(args: {
   imported: true;
   url: string;
   imagesSkipped?: number;
+  tablesDegraded?: number;
 }> {
   const {
     fileBuffer,
@@ -120,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
@@ -156,6 +170,7 @@ export async function importPptxBufferToDeck(args: {
           sourceText: parsedSlide.texts.map((text) => text.content).join("\n"),
           imageUrls: Object.values(uploadedImages.urls),
           imageSkippedCount: uploadedImages.imageSkippedCount,
+          tablesDegraded: parsedSlide.tablesDegraded ?? 0,
         };
       }),
     ),
@@ -165,6 +180,10 @@ export async function importPptxBufferToDeck(args: {
     (total, r) => total + r.imageSkippedCount,
     0,
   );
+  const tablesDegraded = results.reduce(
+    (total, r) => total + r.tablesDegraded,
+    0,
+  );
   if (imagesSkipped > 0) {
     throw new Error(
       `Source-faithful PPTX import could not preserve ${imagesSkipped} image(s). No deck was written. Retry with browser-renderable images or use a PDF export for page-faithful preservation.`,
@@ -180,61 +199,67 @@ export async function importPptxBufferToDeck(args: {
       editableText: true,
     })),
     imagesSkipped,
+    tablesDegraded,
   });
   const aspectRatio = nearestAspectRatio(
     presentation.slides[0]?.widthEmu,
     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));
-
-    if (!existing.length) {
-      throw new Error(`Deck ${deckId} not found`);
-    }
+    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`);
+      }
 
-    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 } : {}),
-    };
+      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
@@ -243,6 +268,7 @@ export async function importPptxBufferToDeck(args: {
     title: deckTitle,
     slides,
     ...(aspectRatio ? { aspectRatio } : {}),
+    ...(presentation.theme ? { theme: presentation.theme } : {}),
     sourceImport,
     createdAt: now,
     updatedAt: now,
@@ -269,6 +295,7 @@ export async function importPptxBufferToDeck(args: {
     imported: true,
     url: getDeckUrl(id),
     ...(imagesSkipped > 0 ? { imagesSkipped } : {}),
+    ...(tablesDegraded > 0 ? { tablesDegraded } : {}),
   };
 }
 

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);