@agent-native/core 0.182.1 → 0.182.2-nightly-20260917225811

package/corpus/templates/design/app/pages/design-editor/commands/duplicate-selection.ts

@@ -5,7 +5,10 @@ import { toast } from "sonner";
 import * as Y from "yjs";
 
 import { trace } from "@/components/design/design-trace";
-import type { ElementInfo } from "@/components/design/types";
+import type {
+  ElementInfo,
+  RuntimeStructureInsertRequest,
+} from "@/components/design/types";
 import type { ClipboardContentMutationPublication } from "@/lib/clipboard-content-lineage";
 import {
   extractLayerPosition,
@@ -13,6 +16,7 @@ import {
   insertClonedHtmlLayer,
   insertClonedHtmlLayers,
   planLinkedComponentStructureClone,
+  prepareClonedHtmlLayersForLiveInsert,
   type ComponentCloneBatchContext,
   type LinkedComponentStructureClonePlan,
 } from "@/pages/design-editor/clone-and-pen-edit";
@@ -28,6 +32,7 @@ import {
   mapAcceptedSelectionNode,
   projectAcceptedSource,
 } from "@/pages/design-editor/commands/selection-publication";
+import { isStandaloneHttpUrl } from "@/pages/design-editor/editor-state";
 import type { GeometryHistorySelection } from "@/pages/design-editor/history";
 import type { DesignFile } from "@/pages/design-editor/types";
 
@@ -147,10 +152,16 @@ export interface DuplicateSelectionArgs {
     nodeIdMap: Map<string, string>,
     targetFileId: string,
   ) => void;
+  runtimeStructureInsertRevisionRef?: RefObject<number>;
   selectionBefore?: GeometryHistorySelection;
   selectedCanvasSelector: string;
   selectedElement: ElementInfo | null;
   selectedLayerIdsState: string[];
+  setRuntimeStructureInsertRequest?: Dispatch<
+    SetStateAction<
+      (RuntimeStructureInsertRequest & { screenId: string }) | null
+    >
+  >;
   setOverviewSelectedScreenIds: Dispatch<SetStateAction<string[]>>;
   setSelectedElement: Dispatch<SetStateAction<ElementInfo | null>>;
   setSelectedLayerIdsState: Dispatch<SetStateAction<string[]>>;
@@ -174,10 +185,12 @@ export function runDuplicateSelection({
   lastDuplicateTransformRef,
   overviewSelectedScreenIds,
   remapMotionTracksForClone,
+  runtimeStructureInsertRevisionRef,
   selectionBefore,
   selectedCanvasSelector,
   selectedElement,
   selectedLayerIdsState,
+  setRuntimeStructureInsertRequest,
   setOverviewSelectedScreenIds,
   setSelectedElement,
   setSelectedLayerIdsState,
@@ -263,6 +276,68 @@ export function runDuplicateSelection({
         : null;
     const nextDuplicateRootNodeIds: string[] = [];
 
+    // A localhost screen stores its route URL, while the selected layer only
+    // exists in the running iframe. Reusing the design-file clone path here
+    // would ask the URL string for an HTML projection and silently turn Cmd+D
+    // into a no-op. Prepare the runtime snapshots for the same one-shot bridge
+    // insert lifecycle used by paste so the clone gets a fresh identity and
+    // participates in pending-edit undo/redo.
+    if (
+      activeFile &&
+      isStandaloneHttpUrl(activeFile.content ?? "") &&
+      snapshots.every((snapshot) => snapshot.sourceFileId === activeFile.id)
+    ) {
+      const sourcePositions = snapshots.map((snapshot) =>
+        extractLayerPosition(snapshot.html),
+      );
+      const prepared = prepareClonedHtmlLayersForLiveInsert(
+        activeFile.content ?? "",
+        snapshots.map((snapshot) => snapshot.html),
+        {
+          stripRootPosition: true,
+          positions: sourcePositions.map((position) =>
+            position
+              ? {
+                  x: position.x + (repeatTransform?.dx ?? 0),
+                  y: position.y + (repeatTransform?.dy ?? 0),
+                  space: "layout" as const,
+                }
+              : undefined,
+          ),
+        },
+      );
+      if (
+        prepared &&
+        runtimeStructureInsertRevisionRef &&
+        setRuntimeStructureInsertRequest
+      ) {
+        const anchorSelector =
+          selectedElement?.runtimeSelector ??
+          selectedCanvasSelector ??
+          selectedElement?.selector;
+        const anchorSourceId =
+          selectedElement?.runtimeSourceId ?? selectedElement?.sourceId;
+        const hasAnchor = Boolean(anchorSelector);
+        runtimeStructureInsertRevisionRef.current += 1;
+        setRuntimeStructureInsertRequest({
+          requestId: runtimeStructureInsertRevisionRef.current,
+          screenId: activeFile.id,
+          html: prepared.htmlFragments[0]!,
+          additionalHtml: prepared.htmlFragments.slice(1),
+          anchor: hasAnchor
+            ? { selector: anchorSelector!, sourceId: anchorSourceId }
+            : { selector: "body" },
+          placement: hasAnchor ? "after" : "inside",
+        });
+        lastDuplicateTransformRef.current = {
+          rootNodeIds: [...prepared.rootNodeIds].sort(),
+          dx: repeatTransform?.dx ?? 0,
+          dy: repeatTransform?.dy ?? 0,
+        };
+        return;
+      }
+    }
+
     const sortedSnapshotsByFile = new Map(
       files.map((file) => [
         file.id,

package/corpus/templates/design/app/pages/design-editor/commands/redo.ts

@@ -29,6 +29,8 @@ import type { LiveScreenSnapshot } from "@/pages/design-editor/command-types";
 import type { ApplyFileContentUpdateResult } from "@/pages/design-editor/commands/apply-file-content-update";
 import type { ApplyLocalContentUpdateResult } from "@/pages/design-editor/commands/apply-local-content-update";
 import { prepareContentHistoryReplay } from "@/pages/design-editor/commands/prepare-content-history-replay";
+import type { DesignDataOperation } from "@/pages/design-editor/data-operations";
+import { applyDesignDataOperations } from "@/pages/design-editor/data-operations";
 import type { OverviewScreen } from "@/pages/design-editor/derive/overview-screens";
 import {
   getCanvasFrameGeometry,
@@ -153,8 +155,17 @@ export interface RedoArgs {
   fileDeletionRedoStackRef: RefObject<FileDeletionHistoryEntry[]>;
   fileDeletionUndoStackRef: RefObject<FileDeletionHistoryEntry[]>;
   fileHistoryMutationPendingRef: RefObject<boolean>;
+  clearPendingHistory?: () => void;
   files: DesignFile[];
-  focusCreatedScreen: (screenId: string, geometry: FrameGeometry) => void;
+  filesRef?: RefObject<DesignFile[]>;
+  focusCreatedScreen: (
+    screenId: string,
+    geometry: FrameGeometry,
+    options?: {
+      preserveCamera?: boolean;
+      suppressLineupRecenter?: boolean;
+    },
+  ) => void;
   geometryRedoStackRef: RefObject<GeometryHistoryEntry[]>;
   geometryUndoStackRef: RefObject<GeometryHistoryEntry[]>;
   getFreshActiveContent: () => string;
@@ -299,6 +310,9 @@ export interface RedoArgs {
     html: string,
     options?: { recordHistory?: boolean },
   ) => boolean;
+  updateDesignAsync: ReturnType<
+    typeof useActionMutation<undefined, undefined, "update-design">
+  >["mutateAsync"];
   viewModeRef: RefObject<"single" | "overview">;
   writeFrameGeometrySnapshot: (
     geometryById: CanvasFrameGeometryById,
@@ -335,7 +349,9 @@ export function runRedo({
   fileDeletionRedoStackRef,
   fileDeletionUndoStackRef,
   fileHistoryMutationPendingRef,
+  clearPendingHistory,
   files,
+  filesRef,
   focusCreatedScreen,
   geometryRedoStackRef,
   geometryUndoStackRef,
@@ -391,6 +407,7 @@ export function runRedo({
   t,
   undoManagerRef,
   updateLiveScreenSnapshotContent,
+  updateDesignAsync,
   viewModeRef,
   writeFrameGeometrySnapshot,
   ydoc,
@@ -399,8 +416,9 @@ export function runRedo({
     selection: GeometryHistorySelection | undefined,
     replaySources: Record<string, string> = {},
   ) => {
+    const currentFiles = filesRef?.current ?? files;
     const actualSources = Object.fromEntries(
-      files.map((file) => [
+      currentFiles.map((file) => [
         file.id,
         replaySources[file.id] ?? getScreenContent(file.id),
       ]),
@@ -1144,9 +1162,8 @@ export function runRedo({
   // U12: redo a screen create/duplicate by recreating the file with the
   // same filename/content/fileType and restoring its recorded geometry.
   // This is async (createFileMutation), unlike every other redo path here,
-  // so it optimistically reports success immediately (mirrors
-  // handleAddScreen's own optimistic cache write) and surfaces a toast on
-  // failure instead of rolling the redo stacks back.
+  // so the history stacks move optimistically while the mutation runs and
+  // restore the redo entry if creation or its metadata commit fails.
   const redoFileCreation = () => {
     if (!canUseOverviewHistory) return false;
     const entry = fileCreationRedoStackRef.current.pop();
@@ -1162,6 +1179,77 @@ export function runRedo({
     ];
     fileHistoryMutationPendingRef.current = true;
     syncUndoRedoState();
+    const restoreFailedRedo = (error: unknown) => {
+      if (
+        fileCreationUndoStackRef.current[
+          fileCreationUndoStackRef.current.length - 1
+        ] === entry
+      ) {
+        fileCreationUndoStackRef.current =
+          fileCreationUndoStackRef.current.slice(0, -1);
+      }
+      historyOrderRef.current = removeRecentUndoRedoOrderKinds(
+        historyOrderRef.current,
+        "file-created",
+        1,
+      );
+      fileCreationRedoStackRef.current = [
+        ...fileCreationRedoStackRef.current.slice(-(MAX_DESIGN_UNDO_STACK - 1)),
+        entry,
+      ];
+      redoOrderRef.current = [
+        ...redoOrderRef.current.slice(-(MAX_DESIGN_UNDO_STACK - 1)),
+        "file-created",
+      ];
+      clearPendingHistory?.();
+      fileHistoryMutationPendingRef.current = false;
+      syncUndoRedoState();
+      toast.error(
+        error instanceof Error
+          ? error.message
+          : t("designEditor.toasts.screenDuplicateError"),
+      );
+    };
+    const reconcileFailedRedo = async (
+      error: unknown,
+      nextId?: string,
+      result?: Record<string, unknown>,
+    ) => {
+      if (nextId) {
+        try {
+          await performDeleteFiles(
+            [
+              {
+                id: nextId,
+                filename: entry.filename,
+                fileType: entry.fileType,
+                content: entry.content,
+                createdAt:
+                  typeof result?.createdAt === "string" ? result.createdAt : "",
+                updatedAt:
+                  typeof result?.updatedAt === "string" ? result.updatedAt : "",
+              },
+            ],
+            {
+              preserveHistory: true,
+              skipFileCreationRedoPrune: true,
+            },
+          );
+        } catch (cleanupError) {
+          trace("history", "redo-file-cleanup-failed", {
+            id,
+            error:
+              cleanupError instanceof Error
+                ? cleanupError.message
+                : String(cleanupError),
+          });
+        }
+        await queryClient.invalidateQueries({
+          queryKey: ["action", "get-design"],
+        });
+      }
+      restoreFailedRedo(error);
+    };
     createFileMutation.mutate(
       {
         designId: id,
@@ -1170,7 +1258,7 @@ export function runRedo({
         fileType: entry.fileType,
       } as any,
       {
-        onSuccess: (result: any) => {
+        onSuccess: async (result: any) => {
           const nextId = typeof result?.id === "string" ? result.id : null;
           if (nextId) {
             const geometry = {
@@ -1180,6 +1268,58 @@ export function runRedo({
               }),
               ...entry.geometry,
             };
+            const dataOperations: DesignDataOperation[] = [
+              {
+                op: "set",
+                path: ["canvasFrames", nextId],
+                value: geometry,
+              },
+              ...(entry.screenMetadata
+                ? [
+                    {
+                      op: "set" as const,
+                      path: ["screenMetadata", nextId] as [string, ...string[]],
+                      value: entry.screenMetadata,
+                    },
+                  ]
+                : []),
+              ...(entry.localhostScreen
+                ? [
+                    {
+                      op: "set" as const,
+                      path: ["localhostScreens", nextId] as [
+                        string,
+                        ...string[],
+                      ],
+                      value: entry.localhostScreen,
+                    },
+                  ]
+                : []),
+            ];
+            if (dataOperations.length > 0) {
+              const nextData = applyDesignDataOperations(
+                designDataJsonRef.current,
+                dataOperations,
+              );
+              designDataJsonRef.current = nextData;
+              queryClient.setQueryData(
+                ["action", "get-design", { id }],
+                (old: any) => {
+                  if (!old || typeof old !== "object") return old;
+                  return { ...old, data: JSON.stringify(nextData) };
+                },
+              );
+              try {
+                await updateDesignAsync({ id, dataOperations } as any);
+              } catch (error) {
+                trace("history", "redo-file-data-failed", {
+                  id,
+                  error: error instanceof Error ? error.message : String(error),
+                });
+                await reconcileFailedRedo(error, nextId, result);
+                return;
+              }
+            }
             optimisticallyInsertCreatedFile({
               fileId: nextId,
               filename: entry.filename,
@@ -1187,52 +1327,19 @@ export function runRedo({
               content: entry.content,
               result,
             });
-            writeFrameGeometrySnapshot({
-              ...getCanvasFrameGeometry(designDataJsonRef.current),
-              [nextId]: geometry,
+            focusCreatedScreen(nextId, geometry, {
+              preserveCamera: entry.preserveCamera,
+              suppressLineupRecenter: entry.preserveCamera,
             });
-            focusCreatedScreen(nextId, geometry);
           }
           fileHistoryMutationPendingRef.current = false;
           syncUndoRedoState();
-          void queryClient.invalidateQueries({
+          await queryClient.invalidateQueries({
             queryKey: ["action", "get-design"],
           });
         },
         onError: (error: unknown) => {
-          // The optimistic history move happened before the request. Put the
-          // entry back exactly where it came from so a failed redo remains
-          // retryable and does not leave a phantom undo operation behind.
-          if (
-            fileCreationUndoStackRef.current[
-              fileCreationUndoStackRef.current.length - 1
-            ] === entry
-          ) {
-            fileCreationUndoStackRef.current =
-              fileCreationUndoStackRef.current.slice(0, -1);
-          }
-          historyOrderRef.current = removeRecentUndoRedoOrderKinds(
-            historyOrderRef.current,
-            "file-created",
-            1,
-          );
-          fileCreationRedoStackRef.current = [
-            ...fileCreationRedoStackRef.current.slice(
-              -(MAX_DESIGN_UNDO_STACK - 1),
-            ),
-            entry,
-          ];
-          redoOrderRef.current = [
-            ...redoOrderRef.current.slice(-(MAX_DESIGN_UNDO_STACK - 1)),
-            "file-created",
-          ];
-          fileHistoryMutationPendingRef.current = false;
-          syncUndoRedoState();
-          toast.error(
-            error instanceof Error
-              ? error.message
-              : t("designEditor.toasts.screenDuplicateError"),
-          );
+          restoreFailedRedo(error);
         },
       },
     );
@@ -1280,6 +1387,7 @@ export function runRedo({
             ...redoOrderRef.current.slice(-(MAX_DESIGN_UNDO_STACK - 1)),
             "file-deleted",
           ];
+          clearPendingHistory?.();
         }
         fileHistoryMutationPendingRef.current = false;
         syncUndoRedoState();

package/corpus/templates/design/app/pages/design-editor/commands/save-file-content.ts

@@ -1,4 +1,5 @@
 import { useActionMutation } from "@agent-native/core/client/hooks";
+import { sourceContentHash } from "@shared/source-workspace";
 import type { QueryClient } from "@tanstack/react-query";
 import type { Dispatch, RefObject, SetStateAction } from "react";
 import { toast } from "sonner";
@@ -7,7 +8,11 @@ import type { DesignSaveOutboxEntry } from "@/lib/design-save-outbox";
 import { updateFileResultPersistedContent } from "@/lib/design-save-outbox";
 import type { PatchProofState } from "@/pages/design-editor/command-types";
 import type { FileContentSaveRequest } from "@/pages/design-editor/editor-state";
-import { shouldClearLatestUnloadSave } from "@/pages/design-editor/editor-state";
+import {
+  advanceLatestUnloadSaveBase,
+  prepareFileContentSaveKeepalive,
+  shouldClearLatestUnloadSave,
+} from "@/pages/design-editor/editor-state";
 import {
   classifyDesignSaveFailure,
   designSaveErrorMessage,
@@ -21,6 +26,7 @@ export interface SaveFileContentArgs {
   createFileSaveOutboxEntry: (
     pending: FileContentSaveRequest,
   ) => DesignSaveOutboxEntry | null;
+  designId?: string;
   fileSaveChainsRef: RefObject<Record<string, Promise<void>>>;
   journalOutboxEntry: (entry: DesignSaveOutboxEntry) => Promise<boolean>;
   latestFileSaveForUnloadRef: RefObject<Record<string, FileContentSaveRequest>>;
@@ -43,11 +49,86 @@ export interface SaveFileContentArgs {
   warnChangesWillRetry: () => void;
 }
 
+type FileContentSaveKeepaliveAttempt =
+  | { accepted: true; completion: Promise<unknown> }
+  | { accepted: false; completion: null };
+
+export interface SaveFileContentKeepaliveArgs {
+  acknowledgeOutboxEntry: (entry: DesignSaveOutboxEntry) => Promise<void>;
+  createFileSaveOutboxEntry: (
+    pending: FileContentSaveRequest,
+  ) => DesignSaveOutboxEntry | null;
+  journalOutboxEntry: (entry: DesignSaveOutboxEntry) => Promise<boolean>;
+  latestFileSaveForUnloadRef: RefObject<Record<string, FileContentSaveRequest>>;
+  sendKeepalive: (
+    payload: Record<string, unknown>,
+  ) => FileContentSaveKeepaliveAttempt;
+}
+
+export function runFileContentSaveKeepalive(
+  {
+    acknowledgeOutboxEntry,
+    createFileSaveOutboxEntry,
+    journalOutboxEntry,
+    latestFileSaveForUnloadRef,
+    sendKeepalive,
+  }: SaveFileContentKeepaliveArgs,
+  pending: FileContentSaveRequest,
+) {
+  // Keep the folded oldest-base entry durable while the direct request uses
+  // this edit's own base. If the predecessor never lands, replay must start
+  // from the oldest known version rather than the successor's base.
+  const durableEntry = createFileSaveOutboxEntry(pending);
+  const keepaliveEntry = createFileSaveOutboxEntry(
+    prepareFileContentSaveKeepalive(pending),
+  );
+  if (!durableEntry || !keepaliveEntry) return;
+  const journalPromise = journalOutboxEntry(durableEntry);
+  const attempt = sendKeepalive(keepaliveEntry.payload);
+  if (!attempt.accepted) {
+    void journalPromise.catch(() => {});
+    return;
+  }
+  void attempt.completion
+    .then(async (result: unknown) => {
+      await journalPromise;
+      const persistedContentMatches = updateFileResultPersistedContent(
+        result,
+        pending.content,
+      );
+      if (!persistedContentMatches) return;
+      const resultInfo = result as { versionHash?: string } | undefined;
+      const latest = latestFileSaveForUnloadRef.current[pending.id];
+      if (shouldClearLatestUnloadSave(latest, pending)) {
+        await acknowledgeOutboxEntry(durableEntry);
+        delete latestFileSaveForUnloadRef.current[pending.id];
+        return;
+      }
+      if (
+        advanceLatestUnloadSaveBase(
+          latest,
+          pending,
+          resultInfo?.versionHash ?? sourceContentHash(pending.content),
+        )
+      ) {
+        const advancedOutboxEntry = latest
+          ? createFileSaveOutboxEntry(latest)
+          : null;
+        if (advancedOutboxEntry) {
+          await journalOutboxEntry(advancedOutboxEntry);
+        }
+      }
+      await acknowledgeOutboxEntry(durableEntry);
+    })
+    .catch(() => {});
+}
+
 export function runSaveFileContent(
   {
     acknowledgeOutboxEntry,
     canEditDesignRef,
     createFileSaveOutboxEntry,
+    designId,
     fileSaveChainsRef,
     journalOutboxEntry,
     latestFileSaveForUnloadRef,
@@ -120,8 +201,54 @@ export function runSaveFileContent(
           pending.content,
           t("common.genericError"),
         );
+        const latest = latestFileSaveForUnloadRef.current[pending.id];
+        if (
+          persistedContentMatches &&
+          advanceLatestUnloadSaveBase(
+            latest,
+            pending,
+            resultInfo?.versionHash ?? sourceContentHash(pending.content),
+          )
+        ) {
+          const advancedOutboxEntry = latest
+            ? createFileSaveOutboxEntry(latest)
+            : null;
+          if (advancedOutboxEntry)
+            await journalOutboxEntry(advancedOutboxEntry);
+        }
+        if (
+          persistedContentMatches &&
+          pending.identityMigrationSourceContent !== undefined &&
+          latestFileSaveForUnloadRef.current[pending.id] === pending
+        ) {
+          // Identity repair has landed. Retire its raw-base marker so the next
+          // user edit publishes against the canonical bytes it already sees.
+          markPendingLocalFileContent(pending.id, pending.content);
+        }
         if (persistedContentMatches && outboxEntry) {
           await acknowledgeOutboxEntry(outboxEntry);
+        }
+        if (persistedContentMatches && designId) {
+          queryClient.setQueryData(
+            ["action", "get-design", { id: designId }],
+            (old: any) => {
+              if (
+                !old ||
+                typeof old !== "object" ||
+                !Array.isArray(old.files)
+              ) {
+                return old;
+              }
+              return {
+                ...old,
+                files: old.files.map((file: { id?: unknown }) =>
+                  file.id === pending.id
+                    ? { ...file, content: pending.content }
+                    : file,
+                ),
+              };
+            },
+          );
         } else if (!persistedContentMatches) {
           // A stale/no-op save result is a source conflict, not a lost
           // connection. Drop the rejected overlay before refetch — leaving
@@ -143,7 +270,6 @@ export function runSaveFileContent(
           shouldClearLatestUnloadSave(
             latestFileSaveForUnloadRef.current[pending.id],
             pending,
-            !persistedContentMatches,
           )
         ) {
           delete latestFileSaveForUnloadRef.current[pending.id];
@@ -180,6 +306,9 @@ export function runSaveFileContent(
         if (failureKind === "conflict") {
           // Roll back our optimistic bytes before the refetch can race ahead.
           rollbackPendingLocalFileContent(pending.id, pending.content);
+          if (latestFileSaveForUnloadRef.current[pending.id] === pending) {
+            delete latestFileSaveForUnloadRef.current[pending.id];
+          }
         }
         void queryClient.invalidateQueries({
           queryKey: ["action", "get-design"],

package/corpus/templates/design/app/pages/design-editor/commands/screen-visual-duplicate-change.ts

@@ -33,6 +33,7 @@ export interface ScreenVisualDuplicateChangeArgs {
       forcePreviewFullDocument?: boolean;
       persist?: boolean;
       recordHistory?: boolean;
+      historyBeforeContent?: string;
       updatedAt?: string;
       clipboardMutation?: ClipboardContentMutationPublication;
     },
@@ -193,6 +194,9 @@ export function runScreenVisualDuplicateChange(
     });
     return false;
   }
-  applyFileContentUpdate(screenId, nextContent, { skipPreview: true });
+  applyFileContentUpdate(screenId, nextContent, {
+    skipPreview: true,
+    historyBeforeContent: baseContent,
+  });
   return true;
 }

package/corpus/templates/design/app/pages/design-editor/commands/undo.ts

@@ -410,6 +410,13 @@ export interface UndoArgs {
   createFileMutation: ReturnType<
     typeof useActionMutation<undefined, undefined, "create-file">
   >;
+  optimisticallyInsertCreatedFile?: (args: {
+    fileId: string;
+    filename: string;
+    fileType: DesignFile["fileType"];
+    content: string;
+    result?: Record<string, unknown> | null;
+  }) => void;
   deleteFileMutation: ReturnType<
     typeof useActionMutation<undefined, undefined, "delete-file">
   >;
@@ -419,7 +426,9 @@ export interface UndoArgs {
   fileDeletionRedoStackRef: RefObject<FileDeletionHistoryEntry[]>;
   fileDeletionUndoStackRef: RefObject<FileDeletionHistoryEntry[]>;
   fileHistoryMutationPendingRef: RefObject<boolean>;
+  clearPendingHistory?: () => void;
   files: DesignFile[];
+  filesRef?: RefObject<DesignFile[]>;
   geometryRedoStackRef: RefObject<GeometryHistoryEntry[]>;
   geometryUndoStackRef: RefObject<GeometryHistoryEntry[]>;
   getFreshActiveContent: () => string;
@@ -547,6 +556,7 @@ export function runUndo({
   contentUndoSelectionStackRef,
   contentUndoStackRef,
   createFileMutation,
+  optimisticallyInsertCreatedFile,
   deleteFileMutation,
   designDataJsonRef,
   fileCreationRedoStackRef,
@@ -554,7 +564,9 @@ export function runUndo({
   fileDeletionRedoStackRef,
   fileDeletionUndoStackRef,
   fileHistoryMutationPendingRef,
+  clearPendingHistory,
   files,
+  filesRef,
   geometryRedoStackRef,
   geometryUndoStackRef,
   getFreshActiveContent,
@@ -609,8 +621,9 @@ export function runUndo({
     selection: GeometryHistorySelection | undefined,
     replaySources: Record<string, string> = {},
   ) => {
+    const currentFiles = filesRef?.current ?? files;
     const actualSources = Object.fromEntries(
-      files.map((file) => [
+      currentFiles.map((file) => [
         file.id,
         replaySources[file.id] ?? getScreenContent(file.id),
       ]),
@@ -1478,6 +1491,17 @@ export function runUndo({
           ...file,
           content: preparedFiles[index]?.content ?? file.content,
         }));
+        entry.files.forEach((file, index) => {
+          const recreatedFile = recreatedEntry.files[index];
+          const prepared = preparedFiles[index];
+          if (!recreatedFile || !prepared) return;
+          optimisticallyInsertCreatedFile?.({
+            fileId: recreatedFile.id,
+            filename: file.filename,
+            fileType: file.fileType,
+            content: prepared.content,
+          });
+        });
         const metadataRestore = restoreMetadataAndGeometry(
           restoreEntry,
           recreatedEntry,
@@ -1548,6 +1572,7 @@ export function runUndo({
           setSelectedLayerIdsState(recreatedEntry.files.map((file) => file.id));
         }
       } catch (error) {
+        clearPendingHistory?.();
         const cleanupResults = await Promise.allSettled(
           recreatedIds.map((fileId) =>
             deleteFileMutation.mutateAsync({