@agent-native/core 0.141.7 → 0.144.1

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

@@ -1,4 +1,9 @@
-import type { ParsedSlide, ParsedTextRun } from "./pptx-parser.js";
+import type {
+  ParsedElement,
+  ParsedParagraph,
+  ParsedSlide,
+  ParsedTextRun,
+} from "./pptx-parser.js";
 
 /** Escape HTML special characters. */
 function esc(text: string): string {
@@ -47,6 +52,24 @@ export function buildFullBleedImageSlideHtml(
 </div>`;
 }
 
+/** Render a rasterized source page without changing its layout or text. */
+export function buildFullPageImageSlideHtml(
+  imageUrl: string,
+  sourceWidth?: number,
+  sourceHeight?: number,
+): string {
+  const sourceDimensions =
+    Number.isFinite(sourceWidth) &&
+    Number.isFinite(sourceHeight) &&
+    sourceWidth! > 0 &&
+    sourceHeight! > 0
+      ? ` data-source-width="${sourceWidth}" data-source-height="${sourceHeight}"`
+      : "";
+  return `<div class="fmd-slide fmd-imported-pdf" data-imported-pdf="true"${sourceDimensions} style="position: relative; width: 100%; height: 100%; overflow: hidden; background: hsl(var(--background));">
+    <img src="${esc(imageUrl)}" alt="" style="position: absolute; inset: 0; width: 100%; height: 100%; object-fit: contain;" />
+</div>`;
+}
+
 /** Wrap text in formatting tags based on run properties. */
 function formatRun(run: ParsedTextRun): string {
   let text = esc(run.content);
@@ -63,7 +86,11 @@ const DEFAULT_IMPORT_FONT = "'Poppins', sans-serif";
 function cssFontFamily(themeFont: string | undefined): string {
   if (!themeFont) return DEFAULT_IMPORT_FONT;
   const safeName = themeFont.replace(/["']/g, "").trim();
-  return safeName ? `'${safeName}', sans-serif` : DEFAULT_IMPORT_FONT;
+  if (!safeName) return DEFAULT_IMPORT_FONT;
+  if (safeName.toLowerCase().startsWith("poppins")) {
+    return "'Poppins', sans-serif";
+  }
+  return `'${safeName}', sans-serif`;
 }
 
 /**
@@ -107,9 +134,13 @@ function groupIntoParagraphs(texts: ParsedTextRun[]): ParsedTextRun[][] {
  */
 export function convertToSlideHtml(
   slide: ParsedSlide,
-  imageUrl?: string,
+  imageUrls?: string | Record<string, string>,
   themeFont?: string,
 ): string {
+  if (slide.elements?.length) {
+    return buildFidelitySlide(slide, imageUrls, themeFont);
+  }
+
   const paragraphs = groupIntoParagraphs(slide.texts);
   const fontFamily = cssFontFamily(themeFont);
 
@@ -117,7 +148,12 @@ export function convertToSlideHtml(
   // has no room to show it, which is how imports used to silently drop
   // photos from otherwise short/title-shaped slides.
   if (slide.images.length > 0) {
-    return buildImageSlide(paragraphs, slide, imageUrl, fontFamily);
+    return buildImageSlide(
+      paragraphs,
+      slide,
+      typeof imageUrls === "string" ? imageUrls : undefined,
+      fontFamily,
+    );
   }
 
   if (slide.layoutHint === "title" || paragraphs.length <= 2) {
@@ -127,6 +163,194 @@ export function convertToSlideHtml(
   return buildContentSlide(paragraphs, slide, fontFamily);
 }
 
+const DEFAULT_SLIDE_WIDTH_EMU = 9144000;
+const DEFAULT_SLIDE_HEIGHT_EMU = 5143500;
+const CSS_PX_PER_POINT = 96 / 72;
+const DEFAULT_PPTX_BACKGROUND = "#000000"; // guard:allow-raw-color - preserve PPTX black when no background is declared
+const DEFAULT_PPTX_FOREGROUND = "#ffffff"; // guard:allow-raw-color - preserve PPTX white when no run color is declared
+
+function buildFidelitySlide(
+  slide: ParsedSlide,
+  imageUrls: string | Record<string, string> | undefined,
+  themeFont: string | undefined,
+): string {
+  const widthEmu = slide.widthEmu || DEFAULT_SLIDE_WIDTH_EMU;
+  const heightEmu = slide.heightEmu || DEFAULT_SLIDE_HEIGHT_EMU;
+  const background = slide.backgroundColor ?? DEFAULT_PPTX_BACKGROUND;
+  const gridStyle = slide.backgroundGrid
+    ? `background-image:linear-gradient(to right, ${esc(slide.backgroundGrid.color)} 0 ${Math.max(0.5, toSlidePxX(slide.backgroundGrid.lineWidthEmu, widthEmu))}px, transparent ${Math.max(0.5, toSlidePxX(slide.backgroundGrid.lineWidthEmu, widthEmu))}px),linear-gradient(to bottom, ${esc(slide.backgroundGrid.color)} 0 ${Math.max(0.5, toSlidePxY(slide.backgroundGrid.lineWidthEmu, heightEmu))}px, transparent ${Math.max(0.5, toSlidePxY(slide.backgroundGrid.lineWidthEmu, heightEmu))}px);background-size:${toSlidePxX(slide.backgroundGrid.stepXEmu, widthEmu)}px ${toSlidePxY(slide.backgroundGrid.stepYEmu, heightEmu)}px;background-position:${toSlidePxX(slide.backgroundGrid.offsetXEmu, widthEmu)}px ${toSlidePxY(slide.backgroundGrid.offsetYEmu, heightEmu)}px;background-repeat:repeat;`
+    : "";
+  const elements = slide.elements ?? [];
+  const html = elements
+    .map((element, index) =>
+      buildFidelityElement(
+        element,
+        index,
+        widthEmu,
+        heightEmu,
+        imageUrls,
+        themeFont,
+      ),
+    )
+    .join("\n");
+
+  return `<div class="fmd-slide fmd-imported-pptx" data-imported-pptx="true" data-slide-width-emu="${widthEmu}" data-slide-height-emu="${heightEmu}" style="position: relative; width: 100%; height: 100%; overflow: hidden; background: ${esc(background)};${gridStyle} font-family: ${cssFontFamily(themeFont)};">${html}
+</div>`;
+}
+
+function buildFidelityElement(
+  element: ParsedElement,
+  index: number,
+  widthEmu: number,
+  heightEmu: number,
+  imageUrls: string | Record<string, string> | undefined,
+  themeFont: string | undefined,
+): string {
+  const position = `position: absolute; left: ${toSlidePxX(element.x, widthEmu)}px; top: ${toSlidePxY(element.y, heightEmu)}px; width: ${toSlidePxX(element.width, widthEmu)}px; height: ${toSlidePxY(element.height, heightEmu)}px; z-index: ${index}; box-sizing: border-box;`;
+  const rotation = element.rotation
+    ? ` transform: rotate(${element.rotation}deg); transform-origin: center center;`
+    : "";
+  const objectId = ` data-slide-object-id="${esc(element.id)}"`;
+
+  if (element.kind === "image") {
+    const url = imageUrlForElement(element, imageUrls);
+    const imageStyle = imageRenderStyle(element);
+    return `<div class="fmd-pptx-image" data-pptx-element-kind="image" data-pptx-image-name="${esc(element.image?.name ?? "image")}"${objectId} style="${position}${rotation} overflow: hidden;">${url ? `<img src="${esc(url)}" alt="" style="${imageStyle}" />` : `<div class="fmd-img-placeholder" style="width:100%;height:100%;">Imported image: ${esc(element.image?.name ?? "image")}</div>`}</div>`;
+  }
+
+  const decoration = shapeDecoration(element, widthEmu);
+  if (element.kind === "shape") {
+    return `<div class="fmd-pptx-shape" data-pptx-element-kind="shape"${objectId} style="${position}${rotation}${decoration}"></div>`;
+  }
+
+  const textStyle = textBoxStyle(element, widthEmu, heightEmu, themeFont);
+  const defaultFontWeight = element.placeholderType === "title" ? 700 : 400;
+  const paragraphs = (element.paragraphs ?? [])
+    .map((paragraph, paragraphIndex) =>
+      buildFidelityParagraph(
+        paragraph,
+        paragraphIndex,
+        widthEmu,
+        themeFont,
+        defaultFontWeight,
+      ),
+    )
+    .join("\n");
+  return `<div class="fmd-pptx-text" data-pptx-element-kind="text"${objectId} style="${position}${rotation}${decoration}${textStyle}">${paragraphs}</div>`;
+}
+
+function toSlidePxX(valueEmu: number, slideWidthEmu: number): number {
+  return Math.round((valueEmu / slideWidthEmu) * 960 * 1000) / 1000;
+}
+
+function toSlidePxY(valueEmu: number, slideHeightEmu: number): number {
+  return Math.round((valueEmu / slideHeightEmu) * 540 * 1000) / 1000;
+}
+
+function imageUrlForElement(
+  element: ParsedElement,
+  imageUrls: string | Record<string, string> | undefined,
+): string | undefined {
+  if (typeof imageUrls === "string") return imageUrls;
+  return imageUrls?.[element.id];
+}
+
+function imageRenderStyle(element: ParsedElement): string {
+  const crop = element.image?.crop;
+  if (!crop) return "display:block;width:100%;height:100%;object-fit:fill;";
+  const visibleWidth = Math.max(0.001, 1 - crop.left - crop.right);
+  const visibleHeight = Math.max(0.001, 1 - crop.top - crop.bottom);
+  return `display:block;position:absolute;left:${(-crop.left / visibleWidth) * 100}%;top:${(-crop.top / visibleHeight) * 100}%;width:${(1 / visibleWidth) * 100}%;height:${(1 / visibleHeight) * 100}%;object-fit:fill;`;
+}
+
+function shapeDecoration(element: ParsedElement, widthEmu: number): string {
+  const fill = element.fill ? `background: ${esc(element.fill)};` : "";
+  const line = element.lineColor
+    ? `border: ${Math.max(1, toSlidePxX(element.lineWidth ?? 12700, widthEmu))}px solid ${esc(element.lineColor)};`
+    : "";
+  const radius = element.shapeType === "roundRect" ? "border-radius: 6px;" : "";
+  return `${fill}${line}${radius}`;
+}
+
+function textBoxStyle(
+  element: ParsedElement,
+  widthEmu: number,
+  heightEmu: number,
+  themeFont: string | undefined,
+): string {
+  const padding = element.padding;
+  const left = padding ? toSlidePxX(padding.left, widthEmu) : 0;
+  const right = padding ? toSlidePxX(padding.right, widthEmu) : 0;
+  const top = padding ? toSlidePxY(padding.top, heightEmu) : 0;
+  const bottom = padding ? toSlidePxY(padding.bottom, heightEmu) : 0;
+  const align = element.paragraphs?.[0]?.alignment ?? "left";
+  const vertical =
+    element.verticalAlign === "middle"
+      ? "justify-content:center;"
+      : element.verticalAlign === "bottom"
+        ? "justify-content:flex-end;"
+        : "justify-content:flex-start;";
+  return `display:flex;flex-direction:column;${vertical}padding:${top}px ${right}px ${bottom}px ${left}px;font-family:${cssFontFamily(themeFont)};text-align:${align};overflow:visible;`;
+}
+
+function buildFidelityParagraph(
+  paragraph: ParsedParagraph,
+  paragraphIndex: number,
+  widthEmu: number,
+  themeFont: string | undefined,
+  defaultFontWeight: number,
+): string {
+  const firstRun = paragraph.runs[0];
+  const fontSize = (firstRun?.fontSize ?? 18) * CSS_PX_PER_POINT;
+  const lineHeight = paragraph.lineSpacing ?? 1.2;
+  const bullet = paragraph.bulletChar
+    ? `<span aria-hidden="true" style="display:inline-block;width:${fontSize * 0.75}px;min-width:${fontSize * 0.75}px;margin-right:${fontSize * 0.65}px;color:${esc(paragraph.bulletColor ?? firstRun?.color ?? DEFAULT_PPTX_FOREGROUND)};font-family:${cssFontFamily(paragraph.bulletFontFamily ?? themeFont)};font-size:${(paragraph.bulletSize ?? firstRun?.fontSize ?? 18) * CSS_PX_PER_POINT}px;">${esc(paragraph.bulletChar)}</span>`
+    : "";
+  const marginLeft = paragraph.marginLeftEmu
+    ? toSlidePxX(paragraph.marginLeftEmu, widthEmu)
+    : 0;
+  const indent = paragraph.indentEmu
+    ? toSlidePxX(paragraph.indentEmu, widthEmu)
+    : 0;
+  const spacingBefore = paragraph.spaceBeforePt ?? 0;
+  const spacingAfter = paragraph.spaceAfterPt ?? 0;
+  const bulletMargin = paragraph.bulletChar ? `margin-left:${indent}px;` : "";
+  const text = paragraph.runs
+    .map((run) => formatFidelityRun(run, themeFont, defaultFontWeight))
+    .join("");
+  return `<p data-pptx-paragraph="${paragraphIndex}" style="display:block;flex:0 0 auto;text-align:${paragraph.alignment ?? "left"};white-space:pre-wrap;margin:${spacingBefore * CSS_PX_PER_POINT}px 0 ${spacingAfter * CSS_PX_PER_POINT}px;line-height:${lineHeight};font-size:${fontSize}px;min-height:${fontSize * lineHeight}px;padding-left:${marginLeft}px;text-indent:${paragraph.bulletChar ? 0 : indent}px;">${bullet.replace("display:inline-block;", `display:inline-block;${bulletMargin}`)}${text}</p>`;
+}
+
+function formatFidelityRun(
+  run: ParsedTextRun,
+  themeFont: string | undefined,
+  defaultFontWeight = 400,
+): string {
+  const styles = [
+    `font-size:${(run.fontSize ?? 18) * CSS_PX_PER_POINT}px`,
+    `font-family:${cssFontFamily(run.fontFamily ?? themeFont)}`,
+    `color:${esc(run.color ?? DEFAULT_PPTX_FOREGROUND)}`,
+    `font-weight:${run.bold ? 700 : fontWeightForFamily(run.fontFamily, defaultFontWeight)}`,
+    `font-style:${run.italic ? "italic" : "normal"}`,
+    `text-decoration:${run.underline ? "underline" : "none"}`,
+  ].join(";");
+  return `<span style="${styles};">${esc(run.content)}</span>`;
+}
+
+function fontWeightForFamily(
+  fontFamily: string | undefined,
+  fallback: number,
+): number {
+  const normalized = fontFamily?.toLowerCase() ?? "";
+  if (!normalized) return fallback;
+  if (/(?:semi|demi)bold|semibold/.test(normalized)) return 600;
+  if (/extra[- ]?bold|heavy/.test(normalized)) return 800;
+  if (/bold/.test(normalized)) return 700;
+  if (/medium/.test(normalized)) return 500;
+  if (/light|thin/.test(normalized)) return 300;
+  return 400;
+}
+
 function buildTitleSlide(
   paragraphs: ParsedTextRun[][],
   slide: ParsedSlide,
@@ -166,7 +390,7 @@ function buildContentSlide(
       })
       .join("\n");
 
-    bulletsHtml = `\n    <div style="display: flex; flex-direction: column; gap: 20px;">
+    bulletsHtml = `\n    <div class="fmd-animation-container" style="display: flex; flex-direction: column; gap: 20px;">
 ${bulletItems}
     </div>`;
   }
@@ -232,15 +456,20 @@ function buildOverlayImageSlide(
   const headingHtml = headingPara.map(formatRun).join(" ") || "Slide";
 
   const captionParas = paragraphs.slice(1);
-  const captionHtml = captionParas
-    .map((para) => para.map(formatRun).join(" "))
-    .join(" ");
+  const captionHtml = captionParas.length
+    ? `<div class="fmd-animation-container" style="display: flex; flex-direction: column; gap: 8px;">${captionParas
+        .map(
+          (para) =>
+            `<p style="font-size: 18px; color: rgba(255,255,255,0.75); /* guard:allow-raw-color - standalone imported slide HTML uses fixed contrast colors */ line-height: 1.5; margin: 0;">${para.map(formatRun).join(" ")}</p>`,
+        )
+        .join("\n")}</div>`
+    : "";
 
   return `<div class="fmd-slide" style="position: relative; width: 100%; height: 100%; overflow: hidden;">
     <img src="${esc(imageUrl)}" alt="" style="position: absolute; inset: 0; width: 100%; height: 100%; object-fit: cover;" />
     <div style="position: absolute; inset: 0; background: linear-gradient(to top, rgba(0,0,0,0.85) 0%, rgba(0,0,0,0.35) 55%, rgba(0,0,0,0) 80%);"></div>
     <div style="position: absolute; left: 0; right: 0; bottom: 0; padding: 56px 70px; font-family: ${fontFamily};">
-      <h2 style="font-size: 40px; font-weight: 900; color: #fff; line-height: 1.15; letter-spacing: -1px; margin: 0 0 ${captionHtml ? "12px" : "0"} 0;">${headingHtml}</h2>${captionHtml ? `\n      <p style="font-size: 18px; color: rgba(255,255,255,0.75); line-height: 1.5; margin: 0;">${captionHtml}</p>` : ""}
+      <h2 style="font-size: 40px; font-weight: 900; color: #fff; /* guard:allow-raw-color - standalone imported slide HTML uses fixed contrast colors */ line-height: 1.15; letter-spacing: -1px; margin: 0 0 ${captionHtml ? "12px" : "0"} 0;">${headingHtml}</h2>${captionHtml ? `\n      ${captionHtml}` : ""}
     </div>
 </div>`;
 }
@@ -256,9 +485,14 @@ function buildStackedImageSlide(
   const headingText = headingPara.map(formatRun).join(" ") || "Slide";
 
   const captionParas = paragraphs.slice(1);
-  const captionText = captionParas
-    .map((para) => para.map(formatRun).join(" "))
-    .join(" ");
+  const captionText = captionParas.length
+    ? `<div class="fmd-animation-container" style="display: flex; flex-direction: column; gap: 8px;">${captionParas
+        .map(
+          (para) =>
+            `<p style="font-size: 16px; color: rgba(255,255,255,0.7); /* guard:allow-raw-color - standalone imported slide HTML uses fixed contrast colors */ line-height: 1.5; margin: 0;">${para.map(formatRun).join(" ")}</p>`,
+        )
+        .join("\n")}</div>`
+    : "";
 
   const imageName = slide.images[0]?.name ?? "image";
   // Size the box to the image's own placed aspect ratio instead of a fixed
@@ -278,7 +512,7 @@ function buildStackedImageSlide(
 
   return `<div class="fmd-slide" style="padding: 64px 90px; display: flex; flex-direction: column; justify-content: flex-start; font-family: ${fontFamily};">
     ${imageHtml}
-    <h2 style="font-size: 32px; font-weight: 900; color: #fff; line-height: 1.2; letter-spacing: -0.5px; margin: 0 0 12px 0;">${headingText}</h2>${captionText ? `\n    <p style="font-size: 16px; color: rgba(255,255,255,0.7); line-height: 1.5; margin: 0;">${captionText}</p>` : ""}
+    <h2 style="font-size: 32px; font-weight: 900; color: #fff; /* guard:allow-raw-color - standalone imported slide HTML uses fixed contrast colors */ line-height: 1.2; letter-spacing: -0.5px; margin: 0 0 12px 0;">${headingText}</h2>${captionText ? `\n    ${captionText}` : ""}
 </div>`;
 }
 

package/corpus/templates/slides/server/handlers/import/pptx-assets.ts

@@ -0,0 +1,67 @@
+import { uploadFile } from "@agent-native/core/file-upload";
+
+import { storeLocalImportedAsset } from "../../lib/import-asset-storage.js";
+import type { ParsedElement, ParsedSlide } from "./pptx-parser.js";
+
+const BROWSER_RENDERABLE_IMAGE_MIME_TYPES = new Set([
+  "image/png",
+  "image/jpeg",
+  "image/gif",
+  "image/webp",
+  "image/svg+xml",
+  "image/bmp",
+]);
+
+export async function uploadPptxSlideImages(args: {
+  slide: ParsedSlide;
+  slideIndex: number;
+  ownerEmail: string;
+}): Promise<{ urls: Record<string, string>; imageSkippedCount: number }> {
+  const imageElements = (args.slide.elements ?? []).filter(
+    (
+      element,
+    ): element is ParsedElement & {
+      kind: "image";
+      image: NonNullable<ParsedElement["image"]>;
+    } => element.kind === "image" && Boolean(element.image),
+  );
+  const urls: Record<string, string> = {};
+
+  for (const [imageIndex, element] of imageElements.entries()) {
+    const image = element.image;
+    if (!BROWSER_RENDERABLE_IMAGE_MIME_TYPES.has(image.mimeType)) continue;
+    const filename = `pptx-import-${Date.now()}-s${args.slideIndex}-i${imageIndex}-${image.name}`;
+    let url: string | undefined;
+    try {
+      const result = await uploadFile({
+        data: Buffer.from(image.data),
+        filename,
+        mimeType: image.mimeType,
+        ownerEmail: args.ownerEmail,
+        recordAsset: false,
+      });
+      url = result?.url;
+    } catch {
+      url = undefined;
+    }
+
+    if (!url) {
+      url =
+        (await storeLocalImportedAsset({
+          email: args.ownerEmail,
+          filename,
+          mimeType: image.mimeType,
+          data: image.data,
+        })) ?? undefined;
+    }
+    if (url) urls[element.id] = url;
+  }
+
+  return {
+    urls,
+    imageSkippedCount: Math.max(
+      0,
+      imageElements.length - Object.keys(urls).length,
+    ),
+  };
+}

package/corpus/templates/slides/server/handlers/import/pptx-parser.ts

@@ -1,5 +1,7 @@
 export {
   parsePptxPresentation as parsePptx,
+  type ParsedPptxElement as ParsedElement,
+  type ParsedPptxParagraph as ParsedParagraph,
   type ParsedPptxImage as ParsedImage,
   type ParsedPptxPresentation as ParsedPresentation,
   type ParsedPptxSlide as ParsedSlide,

package/corpus/templates/slides/server/handlers/uploads.ts

@@ -9,9 +9,11 @@ import {
 import { nanoid } from "nanoid";
 
 import {
+  MAX_FIG_REFERENCE_FILE_BYTES,
+  MAX_REFERENCE_FILE_BYTES,
   SLIDES_REFERENCE_FILE_ERROR_LABEL,
   isSlidesReferenceFileExtension,
-} from "../../shared/upload-types";
+} from "../../shared/upload-types.js";
 import { tenantUploadDir } from "../lib/tenant-files.js";
 import {
   isHostedSlidesRuntime,
@@ -23,8 +25,10 @@ import {
   withSlidesRequestContext,
 } from "./request-auth-context.js";
 
-export const MAX_REFERENCE_FILE_BYTES = 50 * 1024 * 1024;
-export const MAX_FIG_REFERENCE_FILE_BYTES = 200 * 1024 * 1024;
+export {
+  MAX_FIG_REFERENCE_FILE_BYTES,
+  MAX_REFERENCE_FILE_BYTES,
+} from "../../shared/upload-types.js";
 const FIG_LOCAL_COPY_SIGNATURE = new Uint8Array([
   0x66, 0x69, 0x67, 0x2d, 0x6b, 0x69, 0x77, 0x69,
 ]);

package/corpus/templates/slides/server/lib/chat-attachments.ts

@@ -2,10 +2,13 @@ import path from "path";
 
 import type { AgentChatAttachment } from "@agent-native/core/server";
 
-import { isSlidesReferenceFileExtension } from "../../shared/upload-types.js";
+import {
+  isSlidesReferenceFileExtension,
+  MAX_REFERENCE_FILE_BYTES,
+} from "../../shared/upload-types.js";
 import { saveUploadedReferenceFile } from "../handlers/uploads.js";
 
-const MAX_CHAT_UPLOAD_BYTES = 50 * 1024 * 1024;
+const MAX_CHAT_UPLOAD_BYTES = MAX_REFERENCE_FILE_BYTES;
 const MAX_INLINE_IMAGE_BYTES = 10 * 1024 * 1024;
 
 function decodeDataUrl(data: string | undefined): {
@@ -116,8 +119,8 @@ export async function prepareSlidesChatAttachments(args: {
           "",
           "File handling rules:",
           "- If the request refers to the current or visible deck, call `view-screen` first to confirm the active deckId, then pass that deckId to import or slide-edit actions.",
-          '- PPTX files: call `import-pptx --filePath "<path>" --deckId <deckId>` when updating the visible deck, or omit deckId only when the user explicitly wants a new deck.',
-          '- PDF and DOCX files: call `import-file --filePath "<path>" --format auto --deckId <deckId>` and use the returned extracted text as source material before creating slides. The returned text is capped for reliability; re-run with maxChars only if more context is needed. If the user wants a direct replacement import, pass `--importIntoDeck true` as well.',
+          '- PPTX files: when the user wants the visible deck improved, call `import-pptx --filePath "<path>" --deckId <deckId>` first, then edit those imported slide IDs in place with update-slide. Do not rebuild the source deck with add-slide.',
+          '- PDF and DOCX files: call `import-file --filePath "<path>" --format auto --deckId <deckId>` and use the returned extracted text as source material before creating editable slides. For a visual PDF that the user wants preserved, beautified, or restyled from its original layout, pass `--importIntoDeck true` so each page is imported source-faithfully first; keep the full-page image and style around it, with source text persisted in slide notes for inspection.',
           '- Figma `.fig` files: call `import-file --filePath "<path>" --format fig` to start Builder design-system indexing. Do not create a local design system directly from the upload.',
           "- For deck-generation requests, start mutating promptly: create or update the first slide as soon as source material is extracted, then continue slide-by-slide with add-slide/update-slide.",
           '- Image files with an embeddable URL can be inserted directly into slide HTML as `<img src="...">` or used as visual references.',

package/corpus/templates/slides/server/lib/emails.ts

@@ -5,7 +5,10 @@
  * and preview them without the app having sent anything yet.
  */
 
-import { defineTransactionalEmail } from "@agent-native/core/email-catalog";
+import {
+  defineTransactionalEmail,
+  getTransactionalEmail,
+} from "@agent-native/core/email-catalog";
 
 import { renderDeckCommentEmail } from "./comment-notifications.js";
 
@@ -14,7 +17,9 @@ export const SLIDES_DECK_COMMENT_EMAIL_ID = "slides.deck-comment";
 let registered = false;
 
 export function registerSlidesEmails(): void {
-  if (registered) return;
+  // Nitro can re-evaluate this module during dev HMR while the core registry
+  // remains alive. Treat the existing Slides-owned entry as already registered.
+  if (registered || getTransactionalEmail(SLIDES_DECK_COMMENT_EMAIL_ID)) return;
   registered = true;
 
   defineTransactionalEmail({

package/corpus/templates/slides/server/lib/google-docs-error.ts

@@ -0,0 +1,50 @@
+export function formatGoogleOAuthError(error: unknown): string {
+  const rawMessage =
+    error instanceof Error ? error.message : String(error || "Unknown error");
+  const message = rawMessage.replace(/\s+/g, " ").trim();
+  const normalized = message.toLowerCase();
+
+  if (
+    normalized.includes("insufficient permission") ||
+    normalized.includes("insufficient_scope")
+  ) {
+    return "Google Docs access was denied. Connect again and approve the requested Google Drive file permission.";
+  }
+  if (
+    normalized.includes("redirect_uri_mismatch") ||
+    normalized.includes("redirect uri")
+  ) {
+    return "Google rejected the redirect URI. Add the current Slides callback URL to the Google OAuth client and try again.";
+  }
+  if (
+    normalized.includes("access_denied") ||
+    normalized.includes("user denied") ||
+    normalized === "denied"
+  ) {
+    return "Google access was canceled or denied. Connect Google again and approve access.";
+  }
+  if (
+    normalized.includes("invalid_grant") ||
+    normalized.includes("connection expired") ||
+    normalized.includes("token has been expired")
+  ) {
+    return "The Google connection expired. Connect Google again.";
+  }
+  if (
+    normalized.includes("invalid_client") ||
+    normalized.includes("unauthorized_client")
+  ) {
+    return "Google rejected the OAuth client configuration. Check the Slides Google OAuth credentials and authorized redirect URI.";
+  }
+  if (
+    normalized.includes("unverified") ||
+    normalized.includes("not verified") ||
+    normalized.includes("test user") ||
+    normalized.includes("sensitive app") ||
+    normalized.includes("access blocked")
+  ) {
+    return "Google blocked this app because its OAuth consent screen is unverified or this account is not an allowed test user.";
+  }
+
+  return message.slice(0, 240) || "Google OAuth failed. Try connecting again.";
+}

package/corpus/templates/slides/server/lib/google-docs-oauth.ts

@@ -17,6 +17,7 @@ const USERINFO_URL = "https://www.googleapis.com/oauth2/v2/userinfo";
 export const GOOGLE_DOCS_PROVIDER = "google-docs";
 export const GOOGLE_DOCS_SCOPES = [
   "https://www.googleapis.com/auth/drive.file",
+  "https://www.googleapis.com/auth/presentations.readonly",
   "https://www.googleapis.com/auth/userinfo.email",
   "https://www.googleapis.com/auth/userinfo.profile",
 ];

package/corpus/templates/slides/server/lib/import-asset-storage.ts

@@ -0,0 +1,127 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+import {
+  decryptSecretValue,
+  encryptSecretValue,
+} from "@agent-native/core/secrets/crypto";
+import { getConfiguredAppBasePath } from "@agent-native/core/server";
+
+import { isHostedSlidesRuntime, tenantFileKey } from "./tenant-files.js";
+
+const IMPORT_ASSET_PREFIX = "slides-import-asset:v1:";
+
+export interface LocalImportedAssetDescriptor {
+  kind: "slides-import-asset";
+  version: 1;
+  ownerKey: string;
+  id: string;
+  filename: string;
+  mimeType: string;
+}
+
+export function isLocalImportAssetFallbackAvailable(): boolean {
+  return !isHostedSlidesRuntime() && process.env.NODE_ENV !== "production";
+}
+
+export async function storeLocalImportedAsset(args: {
+  email: string;
+  filename: string;
+  mimeType: string;
+  data: Uint8Array;
+}): Promise<string | null> {
+  if (!isLocalImportAssetFallbackAvailable()) return null;
+
+  const id = randomUUID();
+  const safeFilename = path
+    .basename(args.filename)
+    .replace(/[^a-zA-Z0-9_.-]/g, "-");
+  const directory = path.join(
+    process.cwd(),
+    "data",
+    "import-assets",
+    tenantFileKey(args.email),
+  );
+  await mkdir(directory, { recursive: true });
+  await writeFile(path.join(directory, `${id}-${safeFilename}`), args.data);
+
+  const descriptor: LocalImportedAssetDescriptor = {
+    kind: "slides-import-asset",
+    version: 1,
+    ownerKey: tenantFileKey(args.email),
+    id,
+    filename: safeFilename,
+    mimeType: args.mimeType,
+  };
+  const token = `${IMPORT_ASSET_PREFIX}${encryptSecretValue(
+    JSON.stringify(descriptor),
+  )}`;
+  return `${getConfiguredAppBasePath()}/api/import-assets/${encodeURIComponent(token)}`;
+}
+
+export function decodeLocalImportedAssetToken(
+  token: string,
+): LocalImportedAssetDescriptor {
+  if (!token.startsWith(IMPORT_ASSET_PREFIX)) {
+    throw new Error("Invalid imported asset token");
+  }
+  const descriptor = JSON.parse(
+    decryptSecretValue(token.slice(IMPORT_ASSET_PREFIX.length)),
+  ) as LocalImportedAssetDescriptor;
+  if (
+    descriptor?.kind !== "slides-import-asset" ||
+    descriptor.version !== 1 ||
+    typeof descriptor.ownerKey !== "string" ||
+    !/^[a-f0-9]{24}$/.test(descriptor.ownerKey) ||
+    typeof descriptor.id !== "string" ||
+    !/^[0-9a-f-]{36}$/.test(descriptor.id) ||
+    typeof descriptor.filename !== "string" ||
+    descriptor.filename !== path.basename(descriptor.filename) ||
+    typeof descriptor.mimeType !== "string"
+  ) {
+    throw new Error("Invalid imported asset descriptor");
+  }
+  return descriptor;
+}
+
+/** Read a local development import asset after rechecking its owner scope. */
+export async function readLocalImportedAsset(args: {
+  token: string;
+  email: string;
+}): Promise<{ data: Uint8Array; mimeType: string } | null> {
+  if (!isLocalImportAssetFallbackAvailable()) return null;
+
+  let descriptor: LocalImportedAssetDescriptor;
+  try {
+    descriptor = decodeLocalImportedAssetToken(decodeURIComponent(args.token));
+  } catch {
+    // coercion-ok: malformed tokens represent an absent local asset, not a successful read.
+    return null;
+  }
+  if (descriptor.ownerKey !== tenantFileKey(args.email)) return null;
+
+  const directory = path.resolve(
+    process.cwd(),
+    "data",
+    "import-assets",
+    descriptor.ownerKey,
+  );
+  const filepath = path.resolve(
+    directory,
+    `${descriptor.id}-${descriptor.filename}`,
+  );
+  if (!filepath.startsWith(directory + path.sep)) return null;
+
+  try {
+    return {
+      data: await readFile(filepath),
+      mimeType: descriptor.mimeType,
+    };
+  } catch {
+    // coercion-ok: a missing local asset is an absent export image and is skipped by the caller.
+    return null;
+  }
+}
+
+export { IMPORT_ASSET_PREFIX };