@agent-native/core 0.146.1 → 0.146.3

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 7903
+- template files: 7904

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/editor/EditorToolbar.tsx

@@ -96,7 +96,10 @@ interface EditorToolbarProps {
   onShowHistory: () => void;
   historyButtonRef: React.RefObject<HTMLButtonElement | null>;
   currentSlide?: Slide;
-  onUpdateSlide?: (updates: Partial<Omit<Slide, "id">>) => void;
+  onUpdateSlide?: (
+    updates: Partial<Omit<Slide, "id">>,
+    slideIdOverride?: string,
+  ) => void;
   /** Active users on the current slide (from collab awareness) */
   activeUsers?: CollabUser[];
   /** Whether the agent has a durable presence entry on this slide */
@@ -352,7 +355,7 @@ export default function EditorToolbar({
   // That row rides on SlideEditor, which only mounts for a real slide, so an
   // empty deck must keep this fallback or it has no way to add one.
   const contextToolbarVisible = canEdit && Boolean(currentSlide);
-  const { undo, redo, canUndo, canRedo } = useDecks();
+  const { undo, redo, canUndo, canRedo, getDeck } = useDecks();
   const fileInputRef = useRef<HTMLInputElement>(null);
   const [importing, setImporting] = useState(false);
   const { setTheme, resolvedTheme } = useTheme();
@@ -553,7 +556,7 @@ export default function EditorToolbar({
           >
             <div className="py-1.5">
               {/* Layout section */}
-              <div className="px-3 py-1.5 text-[10px] font-medium text-muted-foreground/70 uppercase tracking-wider">
+              <div className="px-3 py-1.5 text-[10px] font-medium text-muted-foreground uppercase tracking-wider">
                 {t("editorToolbar.layout")}
               </div>
               {slideLayoutOptions.map((opt) => (
@@ -573,7 +576,7 @@ export default function EditorToolbar({
 
               {/* Background section */}
               <div className="mx-2 my-1.5 border-t border-border" />
-              <div className="px-3 py-1.5 text-[10px] font-medium text-muted-foreground/70 uppercase tracking-wider">
+              <div className="px-3 py-1.5 text-[10px] font-medium text-muted-foreground uppercase tracking-wider">
                 {t("editorToolbar.background")}
               </div>
               <div className="px-3 pb-2">
@@ -619,7 +622,7 @@ export default function EditorToolbar({
 
               {/* Image & Assets section */}
               <div className="mx-2 my-1.5 border-t border-border" />
-              <div className="px-3 py-1.5 text-[10px] font-medium text-muted-foreground/70 uppercase tracking-wider">
+              <div className="px-3 py-1.5 text-[10px] font-medium text-muted-foreground uppercase tracking-wider">
                 {t("editorToolbar.media")}
               </div>
               <button
@@ -647,27 +650,46 @@ export default function EditorToolbar({
 
               {/* Diagrams section */}
               <div className="mx-2 my-1.5 border-t border-border" />
-              <div className="px-3 py-1.5 text-[10px] font-medium text-muted-foreground/70 uppercase tracking-wider">
+              <div className="px-3 py-1.5 text-[10px] font-medium text-muted-foreground uppercase tracking-wider">
                 {t("editorToolbar.diagrams")}
               </div>
               <button
-                onClick={() => {
+                onClick={async () => {
                   if (!onUpdateSlide || !currentSlide) return;
-                  const mermaidTemplate = `<div class="fmd-slide" style="display:flex;flex-direction:column;align-items:center;justify-content:center;height:100%;padding:60px 80px;font-family:'Poppins',sans-serif;">
-<div class="mermaid">
-graph TD
+                  // Pin the slide this insert targets before the async
+                  // import/parse below, so navigating to another slide in the
+                  // meantime can't redirect where the diagram lands.
+                  const targetSlideId = currentSlide.id;
+                  const defaultMermaidDefinition = `graph TD
     A[Start] --> B{Decision}
     B -->|Yes| C[Action A]
     B -->|No| D[Action B]
     C --> E[End]
-    D --> E
-</div>
-</div>`;
-                  onUpdateSlide({
-                    content: mermaidTemplate,
-                    layout: "blank",
-                  });
-                  setLayoutOpen(false);
+    D --> E`;
+                  try {
+                    const { convertMermaidToExcalidraw } =
+                      await import("./MermaidToExcalidrawPanel");
+                    const data = await convertMermaidToExcalidraw(
+                      defaultMermaidDefinition,
+                    );
+                    // The target slide may have been deleted while the import/
+                    // parse above was in flight — patch-deck rejects the whole
+                    // batch for a missing slide id, so re-check with the live
+                    // deck (not the stale `currentSlide` this closure captured)
+                    // and drop the result instead of enqueueing a dead op.
+                    const stillExists = getDeck(deckId)?.slides.some(
+                      (s) => s.id === targetSlideId,
+                    );
+                    if (!stillExists) return;
+                    onUpdateSlide({ excalidrawData: data }, targetSlideId);
+                    setLayoutOpen(false);
+                  } catch (err) {
+                    console.error("Insert Mermaid diagram failed:", err);
+                    toast.error(t("editorToolbar.insertMermaidFailed"), {
+                      description:
+                        err instanceof Error ? err.message : undefined,
+                    });
+                  }
                 }}
                 className="flex items-center gap-2 w-full px-3 py-1.5 text-xs text-muted-foreground hover:text-foreground hover:bg-accent/50 transition-colors"
               >
@@ -696,6 +718,8 @@ graph TD
                   <button
                     onClick={async () => {
                       if (!onUpdateSlide || !currentSlide) return;
+                      // Same pinning as the insert handler above.
+                      const targetSlideId = currentSlide.id;
                       try {
                         const match = currentSlide.content.match(
                           /<div\s+class="mermaid"[^>]*>([\s\S]*?)<\/div>/i,
@@ -706,13 +730,22 @@ graph TD
                         const data = await convertMermaidToExcalidraw(
                           match[1].trim(),
                         );
-                        onUpdateSlide({ excalidrawData: data });
+                        // Same stale-target guard as the insert handler above.
+                        const stillExists = getDeck(deckId)?.slides.some(
+                          (s) => s.id === targetSlideId,
+                        );
+                        if (!stillExists) return;
+                        onUpdateSlide({ excalidrawData: data }, targetSlideId);
                         setLayoutOpen(false);
-                      } catch (err: any) {
+                      } catch (err) {
                         console.error("Mermaid to Excalidraw failed:", err);
+                        toast.error(t("editorToolbar.convertMermaidFailed"), {
+                          description:
+                            err instanceof Error ? err.message : undefined,
+                        });
                       }
                     }}
-                    className="flex items-center gap-2 w-full px-3 py-1.5 text-xs text-[hsl(var(--accent-cyan))]/80 hover:text-[hsl(var(--accent-cyan))] hover:bg-accent/50 transition-colors"
+                    className="flex items-center gap-2 w-full px-3 py-1.5 text-xs text-[hsl(var(--accent-cyan))] hover:bg-accent/50 transition-colors"
                   >
                     <IconTransform className="w-3 h-3" />
                     {t("editorToolbar.convertMermaidToExcalidraw")}
@@ -734,7 +767,7 @@ graph TD
 
               {/* Transitions section */}
               <div className="mx-2 my-1.5 border-t border-border" />
-              <div className="px-3 py-1.5 text-[10px] font-medium text-muted-foreground/70 uppercase tracking-wider">
+              <div className="px-3 py-1.5 text-[10px] font-medium text-muted-foreground uppercase tracking-wider">
                 {t("editorToolbar.transition")}
               </div>
               <div className="px-3 pb-2.5 grid grid-cols-4 gap-1">
@@ -767,7 +800,7 @@ graph TD
               {onSetAspectRatio && (
                 <>
                   <div className="mx-2 my-1.5 border-t border-border" />
-                  <div className="px-3 py-1.5 text-[10px] font-medium text-muted-foreground/70 uppercase tracking-wider">
+                  <div className="px-3 py-1.5 text-[10px] font-medium text-muted-foreground uppercase tracking-wider">
                     {t("editorToolbar.aspectRatio")}
                   </div>
                   <div className="px-3 pb-2.5 grid grid-cols-4 gap-1">

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

@@ -4409,6 +4409,7 @@ export default function SlideEditor({
 
       <DrawOverlay
         visible={!!drawMode}
+        scopeKey={slideId || slide.id}
         onClose={() => onExitDrawMode?.()}
         onSend={(annotations, instruction, canvasSize) => {
           const summary = annotations

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

@@ -31,7 +31,10 @@ export function SlideOverflowWarning({
     <div
       role="status"
       aria-live="polite"
-      className="absolute -top-12 left-0 z-20 flex items-center gap-2 rounded-md border border-foreground/40 px-2 py-1 text-xs text-foreground"
+      // w-max/nowrap: the containing block is the zoomed slide canvas, so at
+      // low zoom the banner would otherwise wrap to a height taller than its
+      // own -top-12 offset and spill down over the slide.
+      className="absolute -top-12 left-0 z-20 flex w-max items-center gap-2 whitespace-nowrap rounded-md border border-foreground/40 px-2 py-1 text-xs text-foreground"
       onPointerDown={(event) => event.stopPropagation()}
       onClick={(event) => event.stopPropagation()}
     >

package/corpus/templates/slides/app/context/DeckContext.tsx

@@ -143,6 +143,27 @@ export type DeckPersistenceResult =
   | { persisted: false; reason: "request-failed"; error: unknown }
   | { persisted: false; reason: "not-found" };
 
+/**
+ * Ask the server whether a deck row exists, keeping "absent" and "could not
+ * check" distinct — a rejected write is not by itself proof the row is missing.
+ */
+async function probeDeckPersisted(id: string): Promise<DeckPersistenceResult> {
+  try {
+    const result = await callAction<unknown>(
+      "get-deck",
+      { id },
+      {
+        method: "GET",
+      },
+    );
+    return normalizeActionDeck(result)
+      ? { persisted: true }
+      : { persisted: false, reason: "not-found" };
+  } catch (error) {
+    return { persisted: false, reason: "request-failed", error };
+  }
+}
+
 export function describeDeckPersistenceFailure(
   result: DeckPersistenceResult,
   fallback: string,
@@ -178,6 +199,7 @@ interface DeckContextType {
     sourceDeckId: string,
     newId: string,
     title?: string,
+    onFailure?: () => void,
   ) => Deck | null;
   deleteDeck: (id: string) => void;
   updateDeck: (
@@ -851,18 +873,52 @@ async function fetchDeckListLightFromAPI(): Promise<{ id: string }[] | null> {
   }
 }
 
+const DECK_FETCH_RETRY_ATTEMPTS = 3;
+const DECK_FETCH_RETRY_DELAY_MS = 400;
+
+// `get-deck` returns a real 404/403 only when the deck is genuinely gone or
+// the caller genuinely lacks access (see actions/get-deck.ts). A network blip
+// or 5xx is transient and must not be coerced into the same "not found" null
+// the caller uses to show the owner-facing "deck unavailable" pane — that
+// flashed a wrong message on brief server hiccups even though the deck still
+// existed.
+function isConfirmedDeckAbsence(err: unknown): boolean {
+  const status = (err as { status?: unknown } | null)?.status;
+  return status === 404 || status === 403;
+}
+
+// A timeout already made the caller wait the full action timeout window once
+// (see DEFAULT_ACTION_TIMEOUT_MS in use-action.ts); retrying would multiply
+// that wait instead of surfacing the failure — same reasoning as
+// `isActionTimeout` in the shared action-query retry policy.
+function isDeckFetchTimeout(err: unknown): boolean {
+  return (err as { timedOut?: unknown } | null)?.timedOut === true;
+}
+
 async function fetchDeckFromAPI(id: string): Promise<Deck | null> {
-  try {
-    const result = await callAction<unknown>(
-      "get-deck",
-      { id },
-      { method: "GET" },
-    );
-    return normalizeActionDeck(result);
-  } catch (err) {
-    console.error(`Failed to fetch deck ${id}:`, err);
-    return null;
+  for (let attempt = 1; attempt <= DECK_FETCH_RETRY_ATTEMPTS; attempt++) {
+    try {
+      const result = await callAction<unknown>(
+        "get-deck",
+        { id },
+        { method: "GET" },
+      );
+      return normalizeActionDeck(result);
+    } catch (err) {
+      if (
+        isConfirmedDeckAbsence(err) ||
+        isDeckFetchTimeout(err) ||
+        attempt === DECK_FETCH_RETRY_ATTEMPTS
+      ) {
+        console.error(`Failed to fetch deck ${id}:`, err);
+        return null;
+      }
+      await new Promise((resolve) =>
+        setTimeout(resolve, attempt * DECK_FETCH_RETRY_DELAY_MS),
+      );
+    }
   }
+  return null;
 }
 
 export function deckIdFromPathname(pathname: string): string | null {
@@ -1776,24 +1832,18 @@ export function DeckProvider({ children }: { children: ReactNode }) {
         }
       }
 
-      try {
-        const result = await callAction<unknown>(
-          "get-deck",
-          { id },
-          { method: "GET" },
-        );
-        return normalizeActionDeck(result)
-          ? { persisted: true }
-          : { persisted: false, reason: "not-found" };
-      } catch (error) {
-        return { persisted: false, reason: "request-failed", error };
-      }
+      return probeDeckPersisted(id);
     },
     [],
   );
 
   const duplicateDeck = useCallback(
-    (sourceDeckId: string, newId: string, title?: string): Deck | null => {
+    (
+      sourceDeckId: string,
+      newId: string,
+      title?: string,
+      onFailure?: () => void,
+    ): Deck | null => {
       if (pendingDuplicateSourceIdsRef.current.has(sourceDeckId)) return null;
       const source = decks.find((d) => d.id === sourceDeckId);
       if (!source) return null;
@@ -1843,10 +1893,26 @@ export function DeckProvider({ children }: { children: ReactNode }) {
       ).then(() => undefined);
       pendingCreatePromisesRef.current.set(newId, duplicatePromise);
       duplicatePromise
-        .catch((err) => {
+        .catch(async (err) => {
+          // A rejected request is not proof the row is missing: a timeout or
+          // dropped response can land after the server committed the insert.
+          // Discarding the copy then would delete work that actually exists
+          // and tell the user it failed, so confirm against the server first.
+          const probe = await probeDeckPersisted(newId);
+          if (probe.persisted) {
+            console.warn(
+              `Duplicate request for ${newId} failed but the deck persisted:`,
+              err,
+            );
+            return;
+          }
           console.error("Duplicate failed:", err);
-          // Roll back: drop the optimistic deck from local state.
+          // Roll back: drop the optimistic deck from local state. The caller
+          // (via onFailure) is responsible for navigating away if the user is
+          // still sitting on this now-gone deck's route — otherwise they're
+          // stranded on a "Deck unavailable" screen with no way back.
           setDecks((prev) => prev.filter((d) => d.id !== newId));
+          onFailure?.();
         })
         .finally(() => {
           pendingCreateIdsRef.current.delete(newId);