@agent-native/core 0.146.0 → 0.146.2

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

@@ -2,7 +2,6 @@ import path from "path";
 
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
-import { uploadFile } from "@agent-native/core/file-upload";
 import { startBuilderDesignSystemIndex } from "@agent-native/core/server";
 import {
   getRequestOrgId,
@@ -273,21 +272,16 @@ export default defineAction({
       const { PDFParse, canvasFactory } = await setupPdfParse();
       const title = titleFromPath(filename);
 
-      // Designed slide PDFs (photo backgrounds, gradients, custom
-      // typography) bake their visuals into vector/image page content with
-      // no reliable text/shape structure to reconstruct, so importing into a
-      // deck rasterizes each page instead of flattening it to generic bullet
-      // text. Do not silently fall back to text reconstruction when the
-      // renderer is unavailable: that is how a visually complete source deck
-      // turns into a misleading, content-lossy import.
+      // Reconstruct each page's real layout — positioned text blocks at
+      // their actual sizes plus every embedded image at its actual
+      // placement — instead of flattening the page to one guessed
+      // background photo and a canned text template. Image placement needs
+      // the optional canvas renderer; text positioning does not, so this
+      // still beats the old bullet-text fallback even when canvasFactory is
+      // unavailable in this runtime.
       if (importIntoDeck) {
-        if (!canvasFactory) {
-          throw new Error(
-            "Source-faithful PDF import is unavailable in this runtime because the page renderer is not configured. Retry after connecting file storage or use a PDF export with a supported Slides deployment.",
-          );
-        }
         if (!deckId) throw new Error("deckId is required to import into deck");
-        return importPdfPagesAsFullBleedSlides({
+        return importPdfPagesWithFidelity({
           fileBuffer,
           title,
           deckId,
@@ -351,60 +345,61 @@ function nearestAspectRatio(width: number, height: number): AspectRatio {
   return best;
 }
 
-async function importPdfPagesAsFullBleedSlides(args: {
+async function importPdfPagesWithFidelity(args: {
   fileBuffer: Buffer;
   title: string;
   deckId: string;
   PDFParse: Awaited<ReturnType<typeof setupPdfParse>>["PDFParse"];
-  canvasFactory: object;
+  canvasFactory: object | undefined;
 }) {
   const { fileBuffer, title, deckId, PDFParse, canvasFactory } = args;
-  const { buildFullPageImageSlideHtml } =
+  const { convertToSlideHtml, convertSectionsToSlides } =
     await import("../server/handlers/import/html-converter.js");
+  const { parsePdfFidelity } =
+    await import("../server/handlers/import/pdf-fidelity-parser.js");
 
   const pdf = new PDFParse({
     data: new Uint8Array(fileBuffer),
     CanvasFactory: canvasFactory,
   });
   let pages: { num: number; text: string }[];
-  let screenshotsByPage: Map<
-    number,
-    { data: Uint8Array; width: number; height: number }
-  >;
+  let fidelityPages: Awaited<ReturnType<typeof parsePdfFidelity>>;
   try {
-    let textPages: { num: number; text: string }[] = [];
-    try {
-      textPages = normalizePdfPages(await pdf.getText());
-    } catch (error) {
-      console.warn(
-        "[import-file] PDF text extraction failed; preserving rendered pages and leaving notes empty:",
-        error,
-      );
-    }
-    // Rasterize the complete page so positioned text, vector shapes, logos,
-    // photos, and the source page proportions survive the import together.
-    const screenshotResult = await pdf.getScreenshot({
-      desiredWidth: 1600,
-      imageBuffer: true,
-      imageDataUrl: false,
-    });
-    screenshotsByPage = new Map();
-    for (const page of screenshotResult.pages) {
-      screenshotsByPage.set(page.pageNumber, {
-        data: page.data,
-        width: page.width,
-        height: page.height,
-      });
-    }
-    if (screenshotsByPage.size === 0) {
-      throw new Error("The PDF renderer returned no pages.");
-    }
-    pages = screenshotResult.pages.map((page) => ({
-      num: page.pageNumber,
-      text:
-        textPages.find((textPage) => textPage.num === page.pageNumber)?.text ??
-        "",
-    }));
+    pages = normalizePdfPages(await pdf.getText());
+    // Image placement needs the optional canvas renderer to decode pixel
+    // data; skip it (text still gets real positions/sizes) when the native
+    // canvas binding isn't available in this runtime.
+    const imageResult = canvasFactory
+      ? await pdf
+          .getImage({
+            imageBuffer: true,
+            imageDataUrl: false,
+            imageThreshold: 0,
+          })
+          .catch((err) => {
+            console.warn(
+              "[import-file] PDF image extraction failed, importing text-only fidelity:",
+              err instanceof Error ? err.message : String(err),
+            );
+            return undefined;
+          })
+      : undefined;
+
+    // `pdf-parse` memoizes the loaded pdfjs document behind `load()` (a
+    // TS-only `private` method — a real, callable runtime property).
+    // Reaching into it reuses the exact document `getText`/`getImage` above
+    // already parsed instead of parsing the file a second time.
+    const doc = await (
+      pdf as unknown as {
+        load(): Promise<
+          import("pdfjs-dist/legacy/build/pdf.mjs").PDFDocumentProxy
+        >;
+      }
+    ).load();
+    // coercion-ok: undefined here means either canvasFactory was absent or
+    // getImage() already failed and logged a warning above — text-only
+    // fidelity is the intended degrade, not a swallowed failure.
+    fidelityPages = await parsePdfFidelity(doc, imageResult?.pages ?? []);
   } finally {
     await pdf.destroy();
   }
@@ -413,60 +408,110 @@ async function importPdfPagesAsFullBleedSlides(args: {
     throw new Error("The PDF renderer returned no importable pages.");
   }
 
+  // A page with neither extracted text nor a fidelity element is only ever
+  // produced when nothing on it could be recovered (e.g. a scanned/image
+  // page and canvas rendering was unavailable or failed) — if that's true of
+  // every page, importing anyway would silently create a deck of blank
+  // placeholder slides and report success, matching the earlier
+  // text-extraction path's "needs OCR" failure keeps that lossy import from
+  // going unnoticed.
+  const hasRecoverableContent = pages.some((page) => {
+    const fidelity = fidelityPages.find((p) => p.pageNumber === page.num);
+    return page.text.trim().length > 0 || (fidelity?.elements.length ?? 0) > 0;
+  });
+  if (!hasRecoverableContent) {
+    throw new Error(
+      "No importable text or images found in this PDF. Scanned PDFs need OCR first.",
+    );
+  }
+
   // Source decks (e.g. Instagram carousel exports) are commonly portrait or
   // square, not the deck editor's 16:9 default — match the canvas to the
-  // first rendered page's own proportions instead of stretching/cropping it.
-  const firstScreenshot = pages
-    .map((page) => screenshotsByPage.get(page.num))
-    .find((image): image is NonNullable<typeof image> => Boolean(image));
-  const aspectRatio = firstScreenshot
-    ? nearestAspectRatio(firstScreenshot.width, firstScreenshot.height)
+  // PDF's own real page proportions instead of stretching/cropping it.
+  const firstSizedPage = fidelityPages.find((p) => p.widthEmu > 0);
+  const aspectRatio = firstSizedPage
+    ? nearestAspectRatio(firstSizedPage.widthEmu, firstSizedPage.heightEmu)
     : undefined;
 
   const ownerEmail = getRequestUserEmail();
+  if (!ownerEmail) throw new Error("no authenticated user");
+
+  // Bounded the same way as the PPTX upload path below — an unbounded
+  // `Promise.all` here would fire one image-upload batch per page at once,
+  // and a large deck can be dozens of pages.
+  const uploadLimit = pLimit(4);
   const imported = await Promise.all(
-    pages.map(async (page) => {
-      const screenshot = screenshotsByPage.get(page.num);
+    pages.map((page, index) =>
+      uploadLimit(async () => {
+        const fidelity = fidelityPages.find((p) => p.pageNumber === page.num);
+
+        if (!fidelity || fidelity.elements.length === 0) {
+          // Fidelity parsing failed or found nothing placeable on this page
+          // (e.g. a fully blank page) — fall back to plain extracted text
+          // instead of producing a silently blank slide.
+          const firstLine = page.text.split(/\r?\n/)[0]?.trim();
+          const [content] = convertSectionsToSlides([
+            { heading: firstLine || `Page ${page.num}`, content: page.text },
+          ]);
+          const id = newSlideId();
+          return {
+            slide: {
+              id,
+              content: content ?? '<div class="fmd-slide"></div>',
+              layout: "content",
+              notes: page.text,
+            },
+            snapshot: {
+              id,
+              text: page.text,
+              notes: page.text,
+              imageUrls: [],
+              editableText: true,
+            } satisfies SourceImportSlideSnapshot,
+          };
+        }
 
-      if (!screenshot) {
-        throw new Error(
-          `The PDF renderer did not return page ${page.num}; refusing a partial source import.`,
+        const slideForUpload = {
+          texts: [],
+          images: [],
+          elements: fidelity.elements,
+        };
+        const uploaded = await uploadPptxSlideImages({
+          slide: slideForUpload,
+          slideIndex: index,
+          ownerEmail,
+        });
+        const content = convertToSlideHtml(
+          {
+            texts: [],
+            images: [],
+            elements: fidelity.elements,
+            widthEmu: fidelity.widthEmu,
+            heightEmu: fidelity.heightEmu,
+            // A page with no detected full-page fill is plain paper.
+            backgroundColor: fidelity.backgroundColor ?? "#ffffff", // guard:allow-raw-color - fallback plain-paper background, not a design-system token
+          },
+          uploaded.urls,
         );
-      }
 
-      const uploadResult = await uploadFile({
-        data: Buffer.from(screenshot.data),
-        filename: `slide-import-${Date.now()}-p${page.num}.png`,
-        mimeType: "image/png",
-        ownerEmail: ownerEmail ?? undefined,
-        recordAsset: false,
-      });
-      if (!uploadResult?.url) {
-        throw new Error(
-          "File storage is not configured. Connect Builder.io (free tier available) or another upload provider before importing PDF slides.",
-        );
-      }
-      const id = newSlideId();
-      return {
-        slide: {
-          id,
-          content: buildFullPageImageSlideHtml(
-            uploadResult.url,
-            screenshot.width,
-            screenshot.height,
-          ),
-          layout: "full-image",
-          notes: page.text,
-        },
-        snapshot: {
-          id,
-          text: page.text,
-          notes: page.text,
-          imageUrls: [uploadResult.url],
-          editableText: false,
-        } satisfies SourceImportSlideSnapshot,
-      };
-    }),
+        const id = newSlideId();
+        return {
+          slide: {
+            id,
+            content,
+            layout: "content",
+            notes: page.text,
+          },
+          snapshot: {
+            id,
+            text: page.text,
+            notes: page.text,
+            imageUrls: Object.values(uploaded.urls),
+            editableText: true,
+          } satisfies SourceImportSlideSnapshot,
+        };
+      }),
+    ),
   );
   const slides = imported.map((entry) => entry.slide);
   const sourceImport = buildSourceImportMetadata({

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

@@ -59,6 +59,7 @@ export default function DeckCard({
   const [contextOpen, setContextOpen] = useState(false);
   const inputRef = useRef<HTMLInputElement>(null);
   const pendingRenameRef = useRef(false);
+  const pendingDeleteRef = useRef(false);
   const pendingWorkspaceDefaultRef = useRef(false);
 
   useEffect(() => {
@@ -227,6 +228,11 @@ export default function DeckCard({
                 pendingWorkspaceDefaultRef.current = false;
                 onSetWorkspaceDefault?.(deck.id, !isWorkspaceDefault);
               }
+              if (pendingDeleteRef.current) {
+                e.preventDefault();
+                pendingDeleteRef.current = false;
+                setTimeout(() => onDelete(deck.id), 0);
+              }
             }}
           >
             <DropdownMenuItem
@@ -268,8 +274,10 @@ export default function DeckCard({
             )}
             <DropdownMenuSeparator />
             <DropdownMenuItem
-              onSelect={() => {
-                onDelete(deck.id);
+              onSelect={(event) => {
+                event.preventDefault();
+                pendingDeleteRef.current = true;
+                setMenuOpen(false);
               }}
               className="text-red-400 focus:text-red-400"
             >

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

@@ -80,7 +80,7 @@ export function buildImageGenerationContext({
   }
 
   contextParts.push(
-    '\nGenerate 3 variations. Show each as an inline rendered image preview using markdown image syntax (![Variation 1](url)), not a plain text link — the chat renders "![]()" as an actual image but "[]()" as a bare link. Let the user pick their favorite, then insert the chosen generated image into the slide content in the right place.',
+    '\nGenerate 3 preview-only variations. Show each as an inline rendered image preview using markdown image syntax (![Variation 1](url)), not a plain text link — the chat renders "![]()" as an actual image but "[]()" as a bare link. After the user chooses one, place that preview URL with update-slide and then get-deck to verify the persisted slide HTML contains it before claiming success. For a direct one-image request instead, call `generate-image-api` with insertIntoSlide: true plus deckId and slideId; claim it was added only if the action returns inserted: true.',
   );
 
   return contextParts.join("\n");

package/corpus/templates/slides/changelog/2026-08-07-deleting-a-deck-no-longer-freezes-the-slides-browser.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-07
+---
+
+Deleting a deck no longer freezes the Slides browser

package/corpus/templates/slides/changelog/2026-08-07-slides-verify-generated-images-are-persisted-on-the-target-s.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-07
+---
+
+Slides verify generated images are persisted on the target slide

package/corpus/templates/slides/package.json

@@ -53,6 +53,7 @@
     "nanoid": "^5.1.9",
     "p-limit": "^7.3.0",
     "pdf-parse": "^2.4.5",
+    "pdfjs-dist": "5.4.296",
     "pptxgenjs": "4.0.1",
     "react-markdown": "^10.1.0",
     "rehype-raw": "^7.0.0",

package/corpus/templates/slides/server/handlers/import/html-converter.ts

@@ -334,9 +334,18 @@ function formatFidelityRun(
     `font-style:${run.italic ? "italic" : "normal"}`,
     `text-decoration:${run.underline ? "underline" : "none"}`,
   ].join(";");
+  const href = run.href && isSafeLinkHref(run.href) ? run.href : undefined;
+  if (href) {
+    return `<a href="${esc(href)}" target="_blank" rel="noopener noreferrer" style="${styles};">${esc(run.content)}</a>`;
+  }
   return `<span style="${styles};">${esc(run.content)}</span>`;
 }
 
+/** A source PDF/PPTX link annotation is untrusted input — only render schemes a browser treats as navigation, never `javascript:`/`data:`/etc. */
+function isSafeLinkHref(href: string): boolean {
+  return /^(https?:|mailto:)/i.test(href);
+}
+
 function fontWeightForFamily(
   fontFamily: string | undefined,
   fallback: number,