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

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

@@ -37,6 +37,7 @@ export interface ApplyFileContentUpdateArgs {
       refreshPreview?: boolean;
       skipPreview?: boolean;
       forcePreviewFullDocument?: boolean;
+      immediateSave?: boolean;
       persist?: boolean;
       recordHistory?: boolean;
       historyBeforeContent?: string;
@@ -126,6 +127,7 @@ export function runApplyFileContentUpdate(
     refreshPreview?: boolean;
     skipPreview?: boolean;
     forcePreviewFullDocument?: boolean;
+    immediateSave?: boolean;
     persist?: boolean;
     recordHistory?: boolean;
     historyBeforeContent?: string;

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

@@ -109,6 +109,8 @@ export interface DeleteFilesArgs {
   fileCreationUndoStackRef: RefObject<FileCreationHistoryEntry[]>;
   fileDeletionUndoStackRef: RefObject<FileDeletionHistoryEntry[]>;
   fileHistoryMutationPendingRef: RefObject<boolean>;
+  captureHistoryCheckpoint?: () => Promise<string>;
+  clearPendingHistory?: () => void;
   files: DesignFile[];
   geometryRedoStackRef: RefObject<GeometryHistoryEntry[]>;
   geometryUndoStackRef: RefObject<GeometryHistoryEntry[]>;
@@ -132,7 +134,7 @@ export interface DeleteFilesArgs {
   ) => void;
 }
 
-export function runDeleteFiles(
+export async function runDeleteFiles(
   {
     activeFile,
     canvasFrameGeometryById,
@@ -149,6 +151,8 @@ export function runDeleteFiles(
     fileCreationUndoStackRef,
     fileDeletionUndoStackRef,
     fileHistoryMutationPendingRef,
+    captureHistoryCheckpoint,
+    clearPendingHistory,
     files,
     geometryRedoStackRef,
     geometryUndoStackRef,
@@ -186,8 +190,11 @@ export function runDeleteFiles(
       failedFiles: DesignFile[],
     ) => void;
   },
-) {
+): Promise<void> {
   if (!filesToDelete.length) return;
+  if (options?.recordDeletionHistory && fileHistoryMutationPendingRef.current) {
+    throw new Error(t("common.genericError"));
+  }
   const deleteIds = new Set(filesToDelete.map((file) => file.id));
   const nextActiveFile = files.find((file) => !deleteIds.has(file.id));
   const nextGeometry = cloneCanvasFrameGeometry(canvasFrameGeometryById);
@@ -201,10 +208,24 @@ export function runDeleteFiles(
           })),
         }
       : null;
+  let historyCheckpointId: string | undefined;
   if (deletionHistoryEntry) {
-    clearRedoStacks();
     fileHistoryMutationPendingRef.current = true;
     syncUndoRedoState();
+    if (captureHistoryCheckpoint) {
+      try {
+        historyCheckpointId = await captureHistoryCheckpoint();
+      } catch (error) {
+        fileHistoryMutationPendingRef.current = false;
+        clearPendingHistory?.();
+        syncUndoRedoState();
+        toast.error(
+          error instanceof Error ? error.message : t("common.genericError"),
+        );
+        return;
+      }
+    }
+    clearRedoStacks();
   }
   filesToDelete.forEach((file) => {
     delete nextGeometry[file.id];
@@ -371,61 +392,62 @@ export function runDeleteFiles(
   setSelectedElement(null);
   setSelectedLayerIdsState([]);
 
-  void Promise.allSettled(
+  const results = await Promise.allSettled(
     filesToDelete.map((file) =>
       deleteFileMutation.mutateAsync({
         id: file.id,
         allowLockedLayers: true,
+        ...(historyCheckpointId ? { historyCheckpointId } : {}),
       } as any),
     ),
-  ).then((results) => {
-    const deletedFiles = filesToDelete.filter((_, index) => {
-      const result = results[index];
-      return (
-        result?.status === "fulfilled" &&
-        (result.value as { deleted?: boolean } | undefined)?.deleted !== false
-      );
-    });
-    const deletedIds = new Set(deletedFiles.map((file) => file.id));
-    const failedFiles = filesToDelete.filter(
-      (file) => !deletedIds.has(file.id),
+  );
+  const deletedFiles = filesToDelete.filter((_, index) => {
+    const result = results[index];
+    return (
+      result?.status === "fulfilled" &&
+      (result.value as { deleted?: boolean } | undefined)?.deleted !== false
     );
+  });
+  const deletedIds = new Set(deletedFiles.map((file) => file.id));
+  const failedFiles = filesToDelete.filter((file) => !deletedIds.has(file.id));
 
-    if (deletionHistoryEntry && deletedFiles.length > 0) {
-      fileDeletionUndoStackRef.current = [
-        ...fileDeletionUndoStackRef.current.slice(-(MAX_DESIGN_UNDO_STACK - 1)),
-        filterFileDeletionHistoryEntry(deletionHistoryEntry, deletedIds),
-      ];
-      historyOrderRef.current = [
-        ...historyOrderRef.current.slice(-(MAX_DESIGN_UNDO_STACK - 1)),
-        "file-deleted",
-      ];
-    }
+  if (deletionHistoryEntry && deletedFiles.length > 0) {
+    fileDeletionUndoStackRef.current = [
+      ...fileDeletionUndoStackRef.current.slice(-(MAX_DESIGN_UNDO_STACK - 1)),
+      filterFileDeletionHistoryEntry(deletionHistoryEntry, deletedIds),
+    ];
+    historyOrderRef.current = [
+      ...historyOrderRef.current.slice(-(MAX_DESIGN_UNDO_STACK - 1)),
+      "file-deleted",
+    ];
+  }
 
-    const rejected = results.find(
-      (result): result is PromiseRejectedResult => result.status === "rejected",
-    );
-    if (failedFiles.length > 0) {
-      void queryClient.invalidateQueries({
-        queryKey: ["action", "get-design"],
-      });
-      if (rejected) {
-        toast.error(
-          rejected.reason instanceof Error
-            ? rejected.reason.message
-            : t("common.genericError"),
-        );
-      }
+  const rejected = results.find(
+    (result): result is PromiseRejectedResult => result.status === "rejected",
+  );
+  if (failedFiles.length > 0) {
+    void queryClient.invalidateQueries({
+      queryKey: ["action", "get-design"],
+    });
+    if (rejected) {
+      toast.error(
+        rejected.reason instanceof Error
+          ? rejected.reason.message
+          : t("common.genericError"),
+      );
     }
+    // A partial/failed batch is not a safe boundary for a queued undo/redo.
+    // The surviving user intent must be reissued explicitly after refresh.
+    if (deletionHistoryEntry) clearPendingHistory?.();
+  }
 
-    if (deletionHistoryEntry) {
-      fileHistoryMutationPendingRef.current = false;
-      for (const fileId of deletedIds)
-        latestClipboardMutationContentRef.current.delete(fileId);
-    }
-    options?.onMutationSettled?.(deletedFiles, failedFiles);
-    syncUndoRedoState();
-  });
+  if (deletionHistoryEntry) {
+    fileHistoryMutationPendingRef.current = false;
+    for (const fileId of deletedIds)
+      latestClipboardMutationContentRef.current.delete(fileId);
+  }
+  options?.onMutationSettled?.(deletedFiles, failedFiles);
+  syncUndoRedoState();
 
   // File-backed screen deletion is not a geometry-only edit. The screen rows
   // are hard-deleted, so suppress MultiScreenCanvas' local frame-history

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

@@ -153,7 +153,9 @@ export interface RedoArgs {
   fileDeletionRedoStackRef: RefObject<FileDeletionHistoryEntry[]>;
   fileDeletionUndoStackRef: RefObject<FileDeletionHistoryEntry[]>;
   fileHistoryMutationPendingRef: RefObject<boolean>;
+  clearPendingHistory?: () => void;
   files: DesignFile[];
+  filesRef?: RefObject<DesignFile[]>;
   focusCreatedScreen: (screenId: string, geometry: FrameGeometry) => void;
   geometryRedoStackRef: RefObject<GeometryHistoryEntry[]>;
   geometryUndoStackRef: RefObject<GeometryHistoryEntry[]>;
@@ -335,7 +337,9 @@ export function runRedo({
   fileDeletionRedoStackRef,
   fileDeletionUndoStackRef,
   fileHistoryMutationPendingRef,
+  clearPendingHistory,
   files,
+  filesRef,
   focusCreatedScreen,
   geometryRedoStackRef,
   geometryUndoStackRef,
@@ -399,8 +403,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),
       ]),
@@ -1226,6 +1231,7 @@ export function runRedo({
             ...redoOrderRef.current.slice(-(MAX_DESIGN_UNDO_STACK - 1)),
             "file-created",
           ];
+          clearPendingHistory?.();
           fileHistoryMutationPendingRef.current = false;
           syncUndoRedoState();
           toast.error(
@@ -1280,6 +1286,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,
@@ -43,6 +48,80 @@ 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,
@@ -120,6 +199,30 @@ 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);
         } else if (!persistedContentMatches) {
@@ -143,7 +246,6 @@ export function runSaveFileContent(
           shouldClearLatestUnloadSave(
             latestFileSaveForUnloadRef.current[pending.id],
             pending,
-            !persistedContentMatches,
           )
         ) {
           delete latestFileSaveForUnloadRef.current[pending.id];
@@ -180,6 +282,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/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({

package/corpus/templates/design/app/pages/design-editor/editor-state.ts

@@ -599,6 +599,12 @@ export function restorePendingFileContent<
 
 export interface FileContentSaveRequest {
   identityMigrationSourceContent?: string;
+  /**
+   * CAS base for the durable latest-content replay. Normal saves keep their
+   * per-edit base so the serialized chain remains strict; the outbox needs the
+   * oldest unacknowledged base so a pagehide can replay the full snapshot.
+   */
+  unloadExpectedVersionHash?: string;
   id: string;
   content: string;
   syncCollab: boolean;
@@ -610,6 +616,19 @@ export interface FileContentSaveRequest {
   expectedVersionHash: string;
 }
 
+/**
+ * A pagehide request must retain its own CAS base. The durable outbox may fold
+ * later edits onto the oldest base, but a direct keepalive can race that
+ * predecessor and must remain replayable in operation order.
+ */
+export function prepareFileContentSaveKeepalive(
+  pending: FileContentSaveRequest,
+): FileContentSaveRequest {
+  return pending.unloadExpectedVersionHash === undefined
+    ? pending
+    : { ...pending, unloadExpectedVersionHash: undefined };
+}
+
 export function coalescePendingFileContentSave(
   next: FileContentSaveRequest,
   pending: FileContentSaveRequest | undefined,
@@ -637,10 +656,8 @@ type FileContentSaveRequestsById = Readonly<
 export function shouldClearLatestUnloadSave(
   latest: FileContentSaveRequest | undefined,
   completed: FileContentSaveRequest,
-  skippedStaleMirror = false,
 ): boolean {
   return Boolean(
-    !skippedStaleMirror &&
     latest &&
     latest.id === completed.id &&
     latest.content === completed.content &&
@@ -650,6 +667,50 @@ export function shouldClearLatestUnloadSave(
   );
 }
 
+/**
+ * A completed predecessor advances a newer unload replay from its old CAS
+ * base. Mutate the request in place so debounce slots and save chains keep the
+ * same request object, then let the caller re-journal its updated payload.
+ */
+export function advanceLatestUnloadSaveBase(
+  latest: FileContentSaveRequest | undefined,
+  completed: FileContentSaveRequest,
+  persistedVersionHash: string,
+): boolean {
+  const completedBase =
+    completed.unloadExpectedVersionHash ?? completed.expectedVersionHash;
+  const latestBase =
+    latest?.unloadExpectedVersionHash ?? latest?.expectedVersionHash;
+  if (
+    !latest ||
+    latest === completed ||
+    latest.id !== completed.id ||
+    latest.operationSource !== completed.operationSource ||
+    latest.operationRevision <= completed.operationRevision ||
+    latestBase !== completedBase
+  ) {
+    return false;
+  }
+  latest.unloadExpectedVersionHash = persistedVersionHash;
+  return true;
+}
+
+export function shouldClearLatestUnloadSaveForOutboxEntry(
+  latest: FileContentSaveRequest | undefined,
+  entry: {
+    resourceId: string;
+    operationSource: string;
+    operationRevision: number;
+  },
+): boolean {
+  return Boolean(
+    latest &&
+    latest.id === entry.resourceId &&
+    latest.operationSource === entry.operationSource &&
+    latest.operationRevision === entry.operationRevision,
+  );
+}
+
 /**
  * Flushes debounce slots through the ordinary serialized mutation path during
  * React cleanup (route/design changes). Real document unload is handled by the

package/corpus/templates/design/app/pages/design-editor/nudge-intent.ts

@@ -421,6 +421,19 @@ function isRenderedBlockDisplay(display: string | null | undefined): boolean {
   return display === "block" || display === "list-item";
 }
 
+function hasRenderedGridPlacement(
+  computedStyles: Record<string, string> | undefined,
+): boolean {
+  return [computedStyles?.gridColumn, computedStyles?.gridRow].some((value) => {
+    const normalized = value?.trim().replace(/\s+/g, " ").toLowerCase();
+    if (!normalized) return false;
+    return normalized.split("/").some((line) => {
+      const trimmed = line.trim();
+      return trimmed !== "auto" && !/^span(?:\s|$)/.test(trimmed);
+    });
+  });
+}
+
 export interface ResolveElementNudgeIntentArgs {
   content: string;
   source?: CodeLayerSource;
@@ -477,14 +490,45 @@ export function resolveElementNudgeIntent(
   // round-trip has happened yet and `parentDisplay` is simply absent. An
   // element that really is inline or a flex child is handled above — the parser
   // sees those, and a rendered value always wins over this default.
-  const rendered = args.selectedElement.parentDisplay;
-  // A rendered grid needs its column count to map an arrow onto the next visual
-  // cell, and `display: grid` alone does not carry it. Guessing "flex row" walks
-  // DOM order instead, which is a different element in any multi-column grid.
-  if (
+  const rendered =
+    args.selectedElement.parentDisplay ??
+    args.selectedElement.parentLayout?.display;
+  // A rendered grid needs its track count to map an arrow onto the next visual
+  // cell, and `display: grid` alone does not carry it. Reuse the computed track
+  // templates already reported by the bridge instead of guessing a flex row.
+  const renderedGrid =
     parsedContainer.kind === "none" &&
     !escapesFlow(position) &&
     (rendered === "grid" || rendered === "inline-grid")
+      ? describeFlowContainer({
+          style: {
+            display: rendered,
+            ...(args.selectedElement.parentLayout?.gridTemplateColumns
+              ? {
+                  "grid-template-columns":
+                    args.selectedElement.parentLayout.gridTemplateColumns,
+                }
+              : {}),
+            ...(args.selectedElement.parentLayout?.gridTemplateRows
+              ? {
+                  "grid-template-rows":
+                    args.selectedElement.parentLayout.gridTemplateRows,
+                }
+              : {}),
+            ...(args.selectedElement.parentLayout?.gridAutoFlow
+              ? {
+                  "grid-auto-flow":
+                    args.selectedElement.parentLayout.gridAutoFlow,
+                }
+              : {}),
+          },
+        })
+      : NO_FLOW_CONTAINER;
+  if (
+    parsedContainer.kind === "none" &&
+    !escapesFlow(position) &&
+    (rendered === "grid" || rendered === "inline-grid") &&
+    (renderedGrid.kind !== "grid" || renderedGrid.lineLength === null)
   ) {
     return { kind: "none" };
   }
@@ -496,29 +540,31 @@ export function resolveElementNudgeIntent(
   if (
     parsedContainer.kind === "none" &&
     !escapesFlow(position) &&
-    isRenderedFlowDisplay(rendered) &&
+    (rendered === "flex" || rendered === "inline-flex") &&
     !renderedFlexDirection
   ) {
     return { kind: "none" };
   }
   const container: FlowContainerInfo =
     parsedContainer.kind === "none" && !escapesFlow(position)
-      ? isRenderedFlowDisplay(rendered)
-        ? {
-            ...NO_FLOW_CONTAINER,
-            kind: "flex",
-            axis: renderedFlexDirection?.startsWith("column")
-              ? "vertical"
-              : "horizontal",
-            reversed: renderedFlexDirection?.endsWith("-reverse") ?? false,
-          }
-        : // `parent` null means the node is a projection root: it has no flow to
-          // reorder within, and the bridge reports `parentDisplay: undefined`
-          // for it exactly as it does for a not-yet-measured selection.
-          isRenderedBlockDisplay(rendered) ||
-            (rendered === undefined && parent !== null)
-          ? BLOCK_FLOW_CONTAINER
-          : parsedContainer
+      ? renderedGrid.kind === "grid"
+        ? renderedGrid
+        : isRenderedFlowDisplay(rendered)
+          ? {
+              ...NO_FLOW_CONTAINER,
+              kind: "flex",
+              axis: renderedFlexDirection?.startsWith("column")
+                ? "vertical"
+                : "horizontal",
+              reversed: renderedFlexDirection?.endsWith("-reverse") ?? false,
+            }
+          : // `parent` null means the node is a projection root: it has no flow to
+            // reorder within, and the bridge reports `parentDisplay: undefined`
+            // for it exactly as it does for a not-yet-measured selection.
+            isRenderedBlockDisplay(rendered) ||
+              (rendered === undefined && parent !== null)
+            ? BLOCK_FLOW_CONTAINER
+            : parsedContainer
       : parsedContainer;
   // Flex/grid paint children by `order` and explicit grid placement, not DOM
   // position, so moving the node would write a source change that produces no
@@ -552,6 +598,12 @@ export function resolveElementNudgeIntent(
   ) {
     return { kind: "none" };
   }
+  if (
+    container.kind === "grid" &&
+    hasRenderedGridPlacement(args.selectedElement.computedStyles)
+  ) {
+    return { kind: "none" };
+  }
 
   const intent = resolveNudgeIntent({
     direction: args.direction,