@agent-native/core 0.80.9 → 0.80.11

package/corpus/templates/design/app/pages/DesignEditor.tsx

@@ -38,20 +38,31 @@ import {
   type CanvasFrameGeometry,
   type CanvasFrameGeometryById,
 } from "@shared/canvas-frames";
+import { resolveSourceCapabilities } from "@shared/capability-resolver";
 import {
   applyVisualEdit,
   buildCodeLayerProjection,
   buildCodeLayerTree,
   ensureCodeLayerNodeIdsInHtml,
+  moveNodeBetweenDocuments,
   removeCodeLayerNodeFromHtml,
   type CodeLayerNode,
+  type CodeLayerProjection,
   type CodeLayerTreeNode,
 } from "@shared/code-layer";
+import { componentNameFor, isComponentInstance } from "@shared/component-model";
+import type { A11yFinding } from "@shared/design-review";
+import {
+  DESIGN_CAPABILITY_NAMES,
+  hasCapability,
+} from "@shared/design-source-capabilities";
 import { shouldUseLiveFileContent } from "@shared/html-content";
 import {
   resolveTweaksToCssVars,
   type TweakSelections,
 } from "@shared/resolve-tweaks";
+import { utilityStem, widthToPrefix } from "@shared/responsive-classes";
+import { normalizeDesignSourceType } from "@shared/source-mode";
 import {
   IconArrowLeft,
   IconArrowUpRight,
@@ -94,6 +105,9 @@ import {
   IconFileExport,
   IconPlayerPlay,
   IconDeviceFloppy,
+  IconRocket,
+  IconExternalLink,
+  IconCircleCheck,
   IconTerminal2,
 } from "@tabler/icons-react";
 import { useQueryClient } from "@tanstack/react-query";
@@ -113,6 +127,7 @@ import { useParams, useNavigate, Link, useLocation } from "react-router";
 import { toast } from "sonner";
 import * as Y from "yjs";
 
+import { canvasPrimitiveVisual } from "@/components/design/canvas-primitive-style";
 import {
   CanvasContextMenu,
   type CanvasContextMenuHandle,
@@ -121,10 +136,15 @@ import {
   DesignCanvas,
   type IframeContextMenuPayload,
   type IframeHotkeyPayload,
+  type MotionTrackWire,
 } from "@/components/design/DesignCanvas";
 import { DesignEditorSkeleton } from "@/components/design/DesignEditorSkeleton";
 import type { DesignExtensionSlotContext } from "@/components/design/DesignExtensionsPanel";
-import { EditPanel, type InspectorTab } from "@/components/design/EditPanel";
+import {
+  EditPanel,
+  type InspectCodeData,
+  type InspectorTab,
+} from "@/components/design/EditPanel";
 import type { ExportSettingsValue } from "@/components/design/inspector";
 import {
   LayersPanel,
@@ -132,12 +152,18 @@ import {
   type LayersPanelMoveIntent,
   type LayersPanelNode,
 } from "@/components/design/LayersPanel";
+import { LocalSourceEditBanner } from "@/components/design/LocalSourceEditBanner";
+import {
+  MotionDock,
+  type MotionDockTrack,
+} from "@/components/design/MotionDock";
 import {
   MultiScreenCanvas,
   OVERVIEW_FRAME_WIDTH,
   type CanvasPrimitiveInsert,
 } from "@/components/design/MultiScreenCanvas";
 import { QuestionFlow } from "@/components/design/QuestionFlow";
+import type { ReviewPanelProps } from "@/components/design/ReviewPanel";
 import type { ElementInfo, DeviceFrameType } from "@/components/design/types";
 import {
   DEVICE_FRAME_VIEWPORTS,
@@ -148,6 +174,14 @@ import type { UploadedFile } from "@/components/editor/PromptDialog";
 import { Avatar, AvatarFallback, AvatarImage } from "@/components/ui/avatar";
 import { Button } from "@/components/ui/button";
 import { Checkbox } from "@/components/ui/checkbox";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
 import {
   DropdownMenu,
   DropdownMenuContent,
@@ -263,6 +297,32 @@ export function getSelectedScreenIdsForEditorState(args: {
   return activeFileId ? [activeFileId] : [];
 }
 
+function fileIdFromLayerSelectionId(
+  layerId: string,
+  fileIds: Set<string>,
+): string | null {
+  const normalized = layerId.startsWith("code:")
+    ? layerId.slice("code:".length)
+    : layerId;
+  return fileIds.has(normalized) ? normalized : null;
+}
+
+export function getOverviewScreenIdsFromLayerSelection(args: {
+  fileIds: string[];
+  layerIds: string[];
+}) {
+  const fileIds = new Set(args.fileIds);
+  const seen = new Set<string>();
+  const selectedScreenIds: string[] = [];
+  args.layerIds.forEach((layerId) => {
+    const fileId = fileIdFromLayerSelectionId(layerId, fileIds);
+    if (!fileId || seen.has(fileId)) return;
+    seen.add(fileId);
+    selectedScreenIds.push(fileId);
+  });
+  return selectedScreenIds;
+}
+
 export function getOverviewEnterTarget(args: {
   activeFileId: string | null | undefined;
   overviewSelectedScreenIds: string[];
@@ -334,6 +394,71 @@ export function getDesignEditorShareUrl(
   return new URL(pathname, origin).toString();
 }
 
+export function getLocalhostRouteSourceFile(args: {
+  sourceFile?: string;
+  source?: string;
+}): string | undefined {
+  if (args.sourceFile?.trim()) return args.sourceFile;
+  const raw = args.source;
+  if (!raw) return undefined;
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    if (
+      parsed &&
+      typeof parsed === "object" &&
+      "file" in parsed &&
+      typeof (parsed as Record<string, unknown>).file === "string"
+    ) {
+      return (parsed as Record<string, string>).file;
+    }
+  } catch {
+    if (raw.length > 0) return raw;
+  }
+  return undefined;
+}
+
+export function getLayerMoveSourceContent(args: {
+  sourceFileId: string;
+  activeFileId?: string | null;
+  activeContent: string;
+  sourceFileContent?: string;
+  sourceContentMap: ReadonlyMap<string, string>;
+}) {
+  return (
+    args.sourceContentMap.get(args.sourceFileId) ??
+    (args.sourceFileId === args.activeFileId
+      ? args.activeContent
+      : args.sourceFileContent) ??
+    ""
+  );
+}
+
+export function getFreshActiveFileContent(args: {
+  activeContent: string;
+  latestContent?: string | null;
+  lastLocalContent?: string | null;
+}) {
+  return args.latestContent ?? args.lastLocalContent ?? args.activeContent;
+}
+
+export function getFreshScreenContent(args: {
+  screenId: string;
+  activeFileId?: string | null;
+  freshActiveContent: string;
+  fileContentById: ReadonlyMap<string, string>;
+}) {
+  return args.screenId === args.activeFileId
+    ? args.freshActiveContent
+    : (args.fileContentById.get(args.screenId) ?? "");
+}
+
+export function getLayerMoveIterationOrder<T>(
+  orderedIds: readonly T[],
+  placement: "before" | "after" | "inside",
+): T[] {
+  return placement === "after" ? [...orderedIds].reverse() : [...orderedIds];
+}
+
 function resolveZoomUpdate(update: SetStateAction<number>, current: number) {
   return typeof update === "function" ? update(current) : update;
 }
@@ -367,6 +492,27 @@ export function shouldEscapeToOverview(args: {
   );
 }
 
+/**
+ * Build the set of all node ids (both projection ids and data-agent-native-node-id
+ * attribute values) that exist in the given projection. Used by handleGroupSelection
+ * and handleUngroupSelection to filter selectedLayerIdsState to the active file's
+ * nodes before passing them to wrapNodes / unwrap, preventing cross-file stale ids
+ * from causing spurious "conflict" errors.
+ *
+ * Exported for unit testing.
+ */
+export function buildActiveFileNodeIdSet(
+  projection: CodeLayerProjection,
+): Set<string> {
+  const ids = new Set<string>();
+  for (const n of projection.nodes) {
+    ids.add(n.id);
+    const attrId = n.dataAttributes["data-agent-native-node-id"];
+    if (attrId) ids.add(attrId);
+  }
+  return ids;
+}
+
 let html2CanvasColorContext: CanvasRenderingContext2D | null | undefined;
 
 interface FileContentSaveRequest {
@@ -603,6 +749,12 @@ interface GeometryHistoryEntry {
   after: CanvasFrameGeometryById;
 }
 
+interface ContentHistoryEntry {
+  fileId: string;
+  before: string;
+  after: string;
+}
+
 type PatchProofStatus =
   | "runtime"
   | "queued"
@@ -812,6 +964,113 @@ function applyInlineStylesToHtml(
   }
 }
 
+const CSS_PROPERTY_UTILITY_STEMS: Record<string, string[]> = {
+  color: ["text-color"],
+  "background-color": ["background-color"],
+  background: ["background-color", "background-image"],
+  "font-size": ["font-size"],
+  "font-weight": ["font-weight"],
+  "font-family": ["font-family"],
+  "text-align": ["text-align"],
+  display: ["display"],
+  position: ["position"],
+  width: ["w"],
+  height: ["h"],
+  opacity: ["opacity"],
+  "border-radius": ["rounded"],
+  padding: ["p"],
+  "padding-left": ["px", "pl"],
+  "padding-right": ["px", "pr"],
+  "padding-top": ["py", "pt"],
+  "padding-bottom": ["py", "pb"],
+  margin: ["m"],
+  "margin-left": ["mx", "ml"],
+  "margin-right": ["mx", "mr"],
+  "margin-top": ["my", "mt"],
+  "margin-bottom": ["my", "mb"],
+  gap: ["gap"],
+  "column-gap": ["gap-x"],
+  "row-gap": ["gap-y"],
+};
+
+const DEFAULT_STATES_PANEL_BREAKPOINTS = [
+  { id: "bp-mobile", label: "Mobile", widthPx: 390 },
+  { id: "bp-tablet", label: "Tablet", widthPx: 768 },
+  { id: "bp-desktop", label: "Desktop", widthPx: 1280 },
+] as const;
+
+function normalizeCssPropertyName(property: string): string {
+  return property.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+}
+
+function looksLikeTailwindUtility(value: string): boolean {
+  const trimmed = value.trim();
+  if (!trimmed || /\s/.test(trimmed)) return false;
+  if (/[;{}]/.test(trimmed) || /\/\*/.test(trimmed)) return false;
+  if (/^(?:#|rgb\(|rgba\(|hsl\(|hsla\(|var\(|calc\()/i.test(trimmed)) {
+    return false;
+  }
+  if (trimmed.includes(":")) return false;
+  return /^[!-]?[a-z0-9][a-z0-9[\]()./%_-]*$/i.test(trimmed);
+}
+
+function responsiveUtilityMatchesStyleProperty(
+  property: string,
+  value: string,
+): boolean {
+  if (!looksLikeTailwindUtility(value)) return false;
+  const normalizedProperty = normalizeCssPropertyName(property);
+  const stem = utilityStem(value.trim());
+  const allowed = CSS_PROPERTY_UTILITY_STEMS[normalizedProperty];
+  return allowed ? allowed.includes(stem) : stem === normalizedProperty;
+}
+
+interface DesignStatePreviewRow {
+  captureData?: Record<string, unknown> | null;
+  fixtureData?: Record<string, unknown> | null;
+}
+
+const STATE_PREVIEW_HTML_KEYS = [
+  "domHtml",
+  "domSnapshot",
+  "documentHtml",
+  "html",
+  "content",
+  "markup",
+] as const;
+
+function looksLikePreviewHtml(value: string): boolean {
+  return /<!doctype|<html\b|<body\b|<[a-zA-Z][\s>]/i.test(value);
+}
+
+function findStatePreviewHtml(value: unknown, depth = 0): string | null {
+  if (typeof value === "string") {
+    return looksLikePreviewHtml(value) ? value : null;
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value) || depth > 2)
+    return null;
+  const record = value as Record<string, unknown>;
+  for (const key of STATE_PREVIEW_HTML_KEYS) {
+    const hit = findStatePreviewHtml(record[key], depth + 1);
+    if (hit) return hit;
+  }
+  for (const entry of Object.values(record)) {
+    const hit = findStatePreviewHtml(entry, depth + 1);
+    if (hit) return hit;
+  }
+  return null;
+}
+
+function designStatePreviewHtml(
+  row: DesignStatePreviewRow | undefined,
+): string | null {
+  if (!row) return null;
+  return (
+    findStatePreviewHtml(row.captureData) ??
+    findStatePreviewHtml(row.fixtureData)
+  );
+}
+
 function escapeHtmlAttributeValue(value: string): string {
   return value
     .replace(/&/g, "&amp;")
@@ -820,6 +1079,44 @@ function escapeHtmlAttributeValue(value: string): string {
     .replace(/>/g, "&gt;");
 }
 
+const ABS_POSITION_PROPS = [
+  "position",
+  "left",
+  "top",
+  "right",
+  "bottom",
+] as const;
+
+/**
+ * Remove absolute-positioning style properties from the element identified by
+ * `data-agent-native-node-id` so that it becomes a flow child after being
+ * reparented into a container. Returns the updated HTML, or the original HTML
+ * if the node cannot be found or parsing is unavailable.
+ *
+ * Uses DOMParser + CSSStyleDeclaration.removeProperty() rather than
+ * applyVisualEdit({kind:"style",value:""}) because the substrate rejects
+ * empty-string values in isSafeStyleValue, making that approach a silent no-op.
+ */
+function removeAbsolutePositioningFromNodeInHtml(
+  content: string,
+  nodeAttrId: string,
+): string {
+  if (typeof window === "undefined") return content;
+  try {
+    const doc = new DOMParser().parseFromString(content, "text/html");
+    const element = doc.querySelector(
+      `[data-agent-native-node-id="${CSS.escape(nodeAttrId)}"]`,
+    ) as HTMLElement | null;
+    if (!element) return content;
+    for (const prop of ABS_POSITION_PROPS) {
+      element.style.removeProperty(prop);
+    }
+    return `<!DOCTYPE html>\n${doc.documentElement.outerHTML}`;
+  } catch {
+    return content;
+  }
+}
+
 function escapeHtmlText(value: string): string {
   return value
     .replace(/&/g, "&amp;")
@@ -1147,12 +1444,20 @@ function appendCanvasPrimitiveToHtml(
       element.style.transform = `rotate(${geometry.rotation}deg)`;
     }
 
+    // Use the shared canvas-primitive-style module so committed output is
+    // pixel-identical to the draft preview (fixes B5 color jump, B6 ellipse
+    // radius jump).  User-supplied fill/stroke/strokeWidth override the
+    // canonical defaults so hand-chosen colours are preserved.
+    const canonical = canvasPrimitiveVisual(
+      primitive.kind === "rectangle" ? "rect" : primitive.kind,
+    );
     if (primitive.kind === "frame") {
-      element.style.background = primitive.fill ?? "rgba(255, 255, 255, 0.04)";
-      element.style.border = `${primitive.strokeWidth ?? 1}px solid ${
-        primitive.stroke ?? "rgba(148, 163, 184, 0.35)"
-      }`;
-      element.style.borderRadius = "2px";
+      element.style.background = primitive.fill ?? canonical.background;
+      element.style.border =
+        primitive.stroke !== undefined || primitive.strokeWidth !== undefined
+          ? `${primitive.strokeWidth ?? 1}px dashed ${primitive.stroke ?? canonical.border.split(" ").slice(2).join(" ")}`
+          : canonical.border;
+      element.style.borderRadius = canonical.borderRadius;
       element.style.overflow = "hidden";
     } else if (primitive.kind === "text") {
       element.textContent = primitive.text ?? "Text";
@@ -1164,18 +1469,23 @@ function appendCanvasPrimitiveToHtml(
       element.style.fontSize = "16px";
       element.style.lineHeight = "1.2";
       element.style.whiteSpace = "pre-wrap";
+      element.style.border = canonical.border;
+      element.style.borderRadius = canonical.borderRadius;
     } else if (primitive.kind === "ellipse") {
-      element.style.background = primitive.fill ?? "rgba(37, 99, 235, 0.16)";
-      element.style.border = `${primitive.strokeWidth ?? 1}px solid ${
-        primitive.stroke ?? "rgb(37, 99, 235)"
-      }`;
-      element.style.borderRadius = "50%";
+      element.style.background = primitive.fill ?? canonical.background;
+      element.style.border =
+        primitive.stroke !== undefined || primitive.strokeWidth !== undefined
+          ? `${primitive.strokeWidth ?? 1}px solid ${primitive.stroke ?? canonical.border.split(" ").slice(2).join(" ")}`
+          : canonical.border;
+      element.style.borderRadius = canonical.borderRadius; // "50%"
     } else {
-      element.style.background = primitive.fill ?? "rgba(37, 99, 235, 0.16)";
-      element.style.border = `${primitive.strokeWidth ?? 1}px solid ${
-        primitive.stroke ?? "rgb(37, 99, 235)"
-      }`;
-      element.style.borderRadius = "2px";
+      // rect / rectangle / frame fallthrough
+      element.style.background = primitive.fill ?? canonical.background;
+      element.style.border =
+        primitive.stroke !== undefined || primitive.strokeWidth !== undefined
+          ? `${primitive.strokeWidth ?? 1}px solid ${primitive.stroke ?? canonical.border.split(" ").slice(2).join(" ")}`
+          : canonical.border;
+      element.style.borderRadius = canonical.borderRadius;
     }
 
     doc.body.appendChild(element);
@@ -1918,6 +2228,78 @@ function collectCodeLayerAncestors(
   return [];
 }
 
+export function sortCodeLayerIdsByTreeOrder(
+  ids: readonly string[],
+  tree: readonly CodeLayerTreeNode[],
+): string[] {
+  const treeOrder = new Map<string, number>();
+  let index = 0;
+  const visit = (nodes: readonly CodeLayerTreeNode[]) => {
+    for (const node of nodes) {
+      treeOrder.set(node.id, index);
+      index += 1;
+      visit(node.children);
+    }
+  };
+  visit(tree);
+
+  const originalOrder = new Map(
+    ids.map((id, originalIndex) => [id, originalIndex]),
+  );
+  return [...ids].sort((a, b) => {
+    const aOrder = treeOrder.get(a);
+    const bOrder = treeOrder.get(b);
+    if (aOrder === undefined && bOrder === undefined) {
+      return (originalOrder.get(a) ?? 0) - (originalOrder.get(b) ?? 0);
+    }
+    if (aOrder === undefined) return 1;
+    if (bOrder === undefined) return -1;
+    return aOrder - bOrder;
+  });
+}
+
+function findCodeLayerNodeInProjection(
+  projection: CodeLayerProjection,
+  previousNode: CodeLayerNode,
+): CodeLayerNode | null {
+  const stableSourceIds = [
+    previousNode.dataAttributes["data-agent-native-node-id"],
+    previousNode.dataAttributes["data-code-layer-id"],
+    previousNode.dataAttributes["data-layer-id"],
+    previousNode.dataAttributes["data-builder-id"],
+    previousNode.dataAttributes["data-loc"],
+    typeof previousNode.attributes.id === "string"
+      ? previousNode.attributes.id
+      : undefined,
+  ].filter((id): id is string => Boolean(id));
+
+  for (const sourceId of stableSourceIds) {
+    const stableMatch = projection.nodes.find(
+      (node) =>
+        node.dataAttributes["data-agent-native-node-id"] === sourceId ||
+        node.dataAttributes["data-code-layer-id"] === sourceId ||
+        node.dataAttributes["data-layer-id"] === sourceId ||
+        node.dataAttributes["data-builder-id"] === sourceId ||
+        node.dataAttributes["data-loc"] === sourceId ||
+        node.attributes.id === sourceId,
+    );
+    if (stableMatch) return stableMatch;
+  }
+
+  const exactMatch = projection.nodes.find(
+    (node) => node.id === previousNode.id,
+  );
+  if (exactMatch) return exactMatch;
+
+  const fallbackMatches = projection.nodes.filter(
+    (node) =>
+      node.tag === previousNode.tag &&
+      node.layerName === previousNode.layerName &&
+      (node.textSnippet ?? "") === (previousNode.textSnippet ?? ""),
+  );
+  return fallbackMatches.length === 1 ? (fallbackMatches[0] ?? null) : null;
+}
+
 function AgentNativeMenuMark({ className }: { className?: string }) {
   return (
     <svg
@@ -2599,6 +2981,11 @@ function buildAuthoritativeTweakSelections(
         ? persistedSelections[tweak.id]
         : tweak.defaultValue;
   }
+  for (const [key, value] of Object.entries(persistedSelections)) {
+    if (/^--[-_a-zA-Z0-9]+$/.test(key)) {
+      selections[key] = value;
+    }
+  }
   return selections;
 }
 
@@ -2815,6 +3202,9 @@ export default function DesignEditor() {
   const [hiddenLayerIds, setHiddenLayerIds] = useState<Set<string>>(
     () => new Set(),
   );
+  const layerStateOverridesRef = useRef<
+    Map<string, { hidden?: boolean; locked?: boolean }>
+  >(new Map());
   const [overviewSelectAllRequest, setOverviewSelectAllRequest] = useState(0);
   const [overviewClearSelectionRequest, setOverviewClearSelectionRequest] =
     useState(0);
@@ -2828,6 +3218,34 @@ export default function DesignEditor() {
   const spaceHandPreviousToolRef = useRef<DesignTool | null>(null);
   const hasSelectedElement = Boolean(selectedElement);
 
+  // ── Motion dock state (§6.3) ────────────────────────────────────────────────
+  // The MotionDock is mounted below the canvas and shown when motionDockOpen.
+  // Tracks and durationMs are local state; "Write to CSS" calls applyMotionEdit.
+  const [motionDockOpen, setMotionDockOpen] = useState(false);
+  const [motionTracks, setMotionTracks] = useState<MotionDockTrack[]>([]);
+  const [motionDurationMs, setMotionDurationMs] = useState(1000);
+  const [shaderFillPreview, setShaderFillPreview] = useState<{
+    selector?: string;
+    nodeId?: string;
+    css: string;
+  } | null>(null);
+
+  // ── Breakpoint preview state (§6.4) ─────────────────────────────────────────
+  // Active breakpoint width for the current design (pixels). Controls which
+  // side-by-side frame is focused. undefined = no frame selected (overview mode).
+  const [activeBreakpointWidthState, setActiveBreakpointWidthState] = useState<
+    number | undefined
+  >(undefined);
+
+  // ── Design state selection (§6.4 / §8) ───────────────────────────────────────
+  // null = Default (live) view; a string id = one of the design_state rows.
+  const [selectedStateId, setSelectedStateId] = useState<string | null>(null);
+  const [reviewFileId, setReviewFileId] = useState<string | null>(null);
+  const [reviewFindings, setReviewFindings] = useState<A11yFinding[]>([]);
+  const [reviewAuditLoading, setReviewAuditLoading] = useState(false);
+  const [reviewAuditedAt, setReviewAuditedAt] = useState<string | null>(null);
+  const [reviewAuditError, setReviewAuditError] = useState<string | null>(null);
+
   useEffect(() => {
     if (!isBuilderDesignEmbed) return;
     // Announce ready to Builder. The trusted origin is not yet known at this
@@ -2955,6 +3373,9 @@ export default function DesignEditor() {
   const [canUndo, setCanUndo] = useState(false);
   const [canRedo, setCanRedo] = useState(false);
   const undoManagerRef = useRef<Y.UndoManager | null>(null);
+  const contentUndoStackRef = useRef<ContentHistoryEntry[]>([]);
+  const contentRedoStackRef = useRef<ContentHistoryEntry[]>([]);
+  const suppressContentHistoryRef = useRef(false);
   const geometryUndoStackRef = useRef<GeometryHistoryEntry[]>([]);
   const geometryRedoStackRef = useRef<GeometryHistoryEntry[]>([]);
   const historyOrderRef = useRef<Array<"content" | "geometry">>([]);
@@ -2963,17 +3384,30 @@ export default function DesignEditor() {
     const undoManager = undoManagerRef.current;
     setCanUndo(
       Boolean(undoManager?.canUndo()) ||
+        contentUndoStackRef.current.length > 0 ||
         geometryUndoStackRef.current.length > 0,
     );
     setCanRedo(
       Boolean(undoManager?.canRedo()) ||
+        contentRedoStackRef.current.length > 0 ||
         geometryRedoStackRef.current.length > 0,
     );
   }, []);
+  const clearLocalUndoRedoStacks = useCallback(() => {
+    contentUndoStackRef.current = [];
+    contentRedoStackRef.current = [];
+    geometryUndoStackRef.current = [];
+    geometryRedoStackRef.current = [];
+    historyOrderRef.current = [];
+    redoOrderRef.current = [];
+  }, []);
   const persistedSelectionStateRef = useRef<string | null>(null);
   const designSelectionOwnerIdRef = useRef(`${TAB_ID}:${generateTabId()}`);
   const frameGeometrySaveTimerRef = useRef<number | null>(null);
   const [tweakSaveActive, setTweakSaveActive] = useState(false);
+  // Dismissible localhost-source banner (reset per session).
+  const [localSourceBannerDismissed, setLocalSourceBannerDismissed] =
+    useState(false);
   // Shared visual-editor annotate overlays. drawMode owns the send toolbar,
   // while pinMode temporarily routes canvas clicks to comment pins that queue
   // into the same agent submission.
@@ -3292,6 +3726,58 @@ export default function DesignEditor() {
     designAccessRole === "owner" || designAccessRole === "admin";
   const canEditDesign = canShareDesign || designAccessRole === "editor";
   const canEditDesignRef = useRef(canEditDesign);
+  const pendingLocalFileContentsRef = useRef<
+    Map<
+      string,
+      { content: string; startedAt: number; baseUpdatedAt?: string | null }
+    >
+  >(new Map());
+  const [
+    pendingLocalFileContentsRevision,
+    setPendingLocalFileContentsRevision,
+  ] = useState(0);
+
+  const markPendingLocalFileContent = useCallback(
+    (fileId: string, content: string, baseUpdatedAt?: string | null) => {
+      const current = pendingLocalFileContentsRef.current.get(fileId);
+      if (current?.content === content) {
+        if (
+          baseUpdatedAt !== undefined &&
+          current.baseUpdatedAt === undefined
+        ) {
+          pendingLocalFileContentsRef.current.set(fileId, {
+            ...current,
+            baseUpdatedAt,
+          });
+          setPendingLocalFileContentsRevision((revision) => revision + 1);
+        }
+        return;
+      }
+      pendingLocalFileContentsRef.current.set(fileId, {
+        content,
+        startedAt: Date.now(),
+        baseUpdatedAt,
+      });
+      setPendingLocalFileContentsRevision((revision) => revision + 1);
+    },
+    [],
+  );
+
+  const clearPendingLocalFileContent = useCallback(
+    (fileId: string, expectedContent?: string) => {
+      const current = pendingLocalFileContentsRef.current.get(fileId);
+      if (!current) return;
+      if (
+        expectedContent !== undefined &&
+        current.content !== expectedContent
+      ) {
+        return;
+      }
+      pendingLocalFileContentsRef.current.delete(fileId);
+      setPendingLocalFileContentsRevision((revision) => revision + 1);
+    },
+    [],
+  );
 
   useEffect(() => {
     canEditDesignRef.current = canEditDesign;
@@ -3332,6 +3818,45 @@ export default function DesignEditor() {
   const duplicateDesignMutation = useActionMutation("duplicate-design");
   const exportHtmlMutation = useActionMutation("export-html");
   const exportZipMutation = useActionMutation("export-zip");
+  const applyMotionEditMutation = useActionMutation("apply-motion-edit");
+  // §6.4 breakpoint mutations — wired to MultiScreenCanvas + affordance
+  const addBreakpointMutation = useActionMutation("add-breakpoint");
+  const setActiveBreakpointMutation = useActionMutation(
+    "set-active-breakpoint",
+  );
+
+  // §6.1 — promote a selection into a reusable component instance.
+  const createComponentMutation = useActionMutation("create-component");
+  // §6.1 — jump to a component instance's source (selects the root + navigates).
+  const openComponentSourceMutation = useActionMutation(
+    "open-component-source",
+  );
+
+  // §6.6 — "Make it real" migration flow (migrate-inline-design-to-app).
+  // The mutation stays unconditional; the dialog gates on isSignedIn.
+  const migrateMutation = useActionMutation("migrate-inline-design-to-app");
+
+  // Dialog open/close state for the "Make this a real app" flow.
+  const [makeRealDialogOpen, setMakeRealDialogOpen] = useState(false);
+
+  // Result payload returned by migrate-inline-design-to-app on success.
+  // `null` = not yet migrated; populated once the Builder agent accepts the job.
+  const [migrationResult, setMigrationResult] = useState<{
+    branchName?: string;
+    url?: string;
+    versionId?: string;
+    seedFileCount?: number;
+    status?: string;
+    projectId?: string;
+    cta?: {
+      kind: string;
+      label: string;
+      description: string;
+      connectUrl?: string;
+      primaryAction: string;
+    };
+  } | null>(null);
+
   const [shareExportFormat, setShareExportFormat] =
     useState<ShareExportFormat>("html");
   const [codingHandoffResult, setCodingHandoffResult] =
@@ -3356,6 +3881,7 @@ export default function DesignEditor() {
   const saveFileContent = useCallback(
     (pending: FileContentSaveRequest) => {
       if (!canEditDesignRef.current) return;
+      markPendingLocalFileContent(pending.id, pending.content);
       latestFileSaveForUnloadRef.current[pending.id] = pending;
       const previous =
         fileSaveChainsRef.current[pending.id] ?? Promise.resolve();
@@ -3374,6 +3900,7 @@ export default function DesignEditor() {
                 : prev,
             );
           } catch (error) {
+            clearPendingLocalFileContent(pending.id, pending.content);
             setPatchProof((prev) =>
               prev && prev.fileId === pending.id && prev.status === "queued"
                 ? {
@@ -3395,7 +3922,12 @@ export default function DesignEditor() {
         }
       });
     },
-    [t, updateFileMutation],
+    [
+      clearPendingLocalFileContent,
+      markPendingLocalFileContent,
+      t,
+      updateFileMutation,
+    ],
   );
 
   const queueFileContentSave = useCallback(
@@ -3410,6 +3942,7 @@ export default function DesignEditor() {
         content,
         syncCollab: options.syncCollab ?? true,
       };
+      markPendingLocalFileContent(fileId, content);
       latestFileSaveForUnloadRef.current[fileId] = pending;
       if (options.immediate) {
         const timer = fileSaveTimersRef.current[fileId];
@@ -3434,7 +3967,7 @@ export default function DesignEditor() {
         saveFileContent(pending);
       }, 400);
     },
-    [saveFileContent],
+    [markPendingLocalFileContent, saveFileContent],
   );
 
   useEffect(() => {
@@ -3679,7 +4212,38 @@ export default function DesignEditor() {
     updateDesignMutation,
   ]);
 
-  const files = design?.files ?? [];
+  const serverFiles = design?.files ?? [];
+  useEffect(() => {
+    if (pendingLocalFileContentsRef.current.size === 0) return;
+    let changed = false;
+    for (const file of serverFiles) {
+      const pending = pendingLocalFileContentsRef.current.get(file.id);
+      if (pending && (file.content ?? "") === pending.content) {
+        if (
+          pending.baseUpdatedAt !== undefined &&
+          file.updatedAt === pending.baseUpdatedAt
+        ) {
+          continue;
+        }
+        pendingLocalFileContentsRef.current.delete(file.id);
+        changed = true;
+      }
+    }
+    if (changed) {
+      setPendingLocalFileContentsRevision((revision) => revision + 1);
+    }
+  }, [serverFiles]);
+  const pendingLocalFileContentsSnapshot = useMemo(
+    () => new Map(pendingLocalFileContentsRef.current),
+    [pendingLocalFileContentsRevision],
+  );
+  const files = useMemo(() => {
+    if (pendingLocalFileContentsSnapshot.size === 0) return serverFiles;
+    return serverFiles.map((file) => {
+      const pending = pendingLocalFileContentsSnapshot.get(file.id);
+      return pending ? { ...file, content: pending.content } : file;
+    });
+  }, [pendingLocalFileContentsSnapshot, serverFiles]);
   const designDataJson = useMemo(
     () => parseDesignDataJson(design?.data),
     [design?.data],
@@ -3699,6 +4263,38 @@ export default function DesignEditor() {
       designDataJson,
       "screenMetadata",
     );
+    // §6.4 — breakpoint set stored in designs.data.breakpointSet as a
+    // BreakpointSet { id, breakpoints: BreakpointDefinition[] }.
+    // Each BreakpointDefinition has { id, label, widthPx, prefix }.
+    const breakpointSet = (() => {
+      try {
+        const raw = (designDataJson as Record<string, unknown>)?.breakpointSet;
+        if (
+          raw &&
+          typeof raw === "object" &&
+          !Array.isArray(raw) &&
+          Array.isArray((raw as Record<string, unknown>).breakpoints)
+        ) {
+          return raw as {
+            id: string;
+            breakpoints: Array<{
+              id: string;
+              widthPx: number;
+              label?: string;
+              prefix?: string;
+            }>;
+          };
+        }
+      } catch {
+        // ignore
+      }
+      return undefined;
+    })();
+    const bpWidths =
+      breakpointSet && breakpointSet.breakpoints.length > 0
+        ? breakpointSet.breakpoints.map((bp) => bp.widthPx)
+        : undefined;
+
     return files.map((file) => {
       const metadata = getDesignDataRecord(metadataByFileId, file.id);
       const stringValue = (key: string) =>
@@ -3716,6 +4312,7 @@ export default function DesignEditor() {
         updatedAt: file.updatedAt,
         sourceType: stringValue("sourceType"),
         source: stringValue("source"),
+        sourceFile: stringValue("sourceFile"),
         lod: stringValue("lod"),
         previewState: stringValue("previewState"),
         status: stringValue("status"),
@@ -3724,9 +4321,19 @@ export default function DesignEditor() {
         height: numberValue("height"),
         url: stringValue("url"),
         previewUrl: stringValue("previewUrl"),
+        // Breakpoint preview widths (§6.4). When non-empty, MultiScreenCanvas
+        // renders one iframe per width to the right of the primary frame.
+        breakpointWidths: bpWidths,
+        // Active breakpoint width tracked in component state; shared across all
+        // screens (a design has one active breakpoint set at a time in v1).
+        activeBreakpointWidth: bpWidths?.includes(
+          activeBreakpointWidthState ?? -1,
+        )
+          ? activeBreakpointWidthState
+          : undefined,
       };
     });
-  }, [designDataJson, files]);
+  }, [designDataJson, files, activeBreakpointWidthState]);
   const queueFrameGeometrySave = useCallback(
     (geometryById: CanvasFrameGeometryById) => {
       if (!id || !canEditDesignRef.current) return;
@@ -3838,6 +4445,61 @@ export default function DesignEditor() {
     [syncUndoRedoState, writeFrameGeometrySnapshot],
   );
 
+  // §6.6 — "Make this a real app" handler.
+  // Opens the dialog; actual migration fires when the user confirms.
+  const handleOpenMakeReal = useCallback(() => {
+    setMigrationResult(null);
+    setMakeRealDialogOpen(true);
+  }, []);
+
+  // Fires when the user clicks "Start migration" in the dialog.
+  // Calls migrate-inline-design-to-app, then on success flips sourceType to
+  // "fusion" in the design data blob so gated panels light up.
+  const handleConfirmMakeReal = useCallback(async () => {
+    if (!id) return;
+    try {
+      const result = await migrateMutation.mutateAsync({ designId: id } as any);
+      const r = result as any;
+      setMigrationResult({
+        branchName: r?.branchName,
+        url: r?.url,
+        versionId: r?.versionId,
+        seedFileCount: r?.seedFileCount,
+        status: r?.status,
+        projectId: r?.projectId,
+        cta: r?.cta,
+      });
+
+      // When the Builder agent accepted the job (status = "processing"),
+      // flip the design data to sourceType "fusion" so capability-gated
+      // panels (branches, deploy) light up on refresh.
+      if (r?.status === "processing" && r?.url) {
+        const nextData = {
+          ...designDataJsonRef.current,
+          sourceType: "fusion",
+          fusionBranchName: r.branchName,
+          fusionUrl: r.url,
+          fusionProjectId: r.projectId,
+        };
+        updateDesignMutation.mutate(
+          { id, data: JSON.stringify(nextData) } as any,
+          {
+            onSuccess: () => {
+              queryClient.invalidateQueries({
+                queryKey: ["action", "get-design"],
+              });
+            },
+          },
+        );
+      } else if (r?.status === "not-configured") {
+        // Builder not connected — leave dialog open to show the CTA.
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Migration failed";
+      toast.error(message);
+    }
+  }, [id, migrateMutation, updateDesignMutation, queryClient]);
+
   generationOutputReadyRef.current = files.length > 0;
 
   useEffect(() => {
@@ -3947,11 +4609,21 @@ export default function DesignEditor() {
   }, [files, activeFileId]);
 
   const activeFile = files.find((f) => f.id === activeFileId) ?? files[0];
+  useEffect(() => {
+    if (!reviewFileId || reviewFileId === activeFile?.id) return;
+    setReviewFileId(null);
+    setReviewFindings([]);
+    setReviewAuditedAt(null);
+    setReviewAuditError(null);
+    setReviewAuditLoading(false);
+  }, [activeFile?.id, reviewFileId]);
+
   const initialGenerationReadOnly = shouldLockInspectorForInitialGeneration({
     fileCount: files.length,
     generating,
     pendingGenerationActive,
   });
+
   const selectedScreenIds = useMemo(
     () =>
       getSelectedScreenIdsForEditorState({
@@ -4340,6 +5012,7 @@ export default function DesignEditor() {
   // The last content this client itself wrote into the Y.Doc (inline-style
   // edits) — so the reconcile/observe doesn't treat our own echo as external.
   const lastLocalContentRef = useRef<string | null>(null);
+  const latestActiveContentRef = useRef<string | null>(null);
   // Freshest known DB `updatedAt` for the active file, kept in a ref so the
   // Yjs observe handler can advance the reconcile watermark without re-subscribing.
   const documentFileUpdatedAtRef = useRef<string | null>(null);
@@ -4383,7 +5056,10 @@ export default function DesignEditor() {
       setCollabContentFileId(null);
       lastAppliedFileUpdatedAtRef.current = null;
       lastLocalContentRef.current = null;
+      latestActiveContentRef.current = null;
+      clearLocalUndoRedoStacks();
       clearStaleAgentCollabRecovery();
+      syncUndoRedoState();
       return;
     }
     if (activeFileId !== prevActiveFileIdRef.current) {
@@ -4392,9 +5068,18 @@ export default function DesignEditor() {
       setCollabContentFileId(null);
       lastAppliedFileUpdatedAtRef.current = null;
       lastLocalContentRef.current = null;
+      latestActiveContentRef.current = null;
+      clearLocalUndoRedoStacks();
       clearStaleAgentCollabRecovery();
+      syncUndoRedoState();
     }
-  }, [activeFileId, clearStaleAgentCollabRecovery, viewMode]);
+  }, [
+    activeFileId,
+    clearLocalUndoRedoStacks,
+    clearStaleAgentCollabRecovery,
+    syncUndoRedoState,
+    viewMode,
+  ]);
 
   useEffect(() => {
     return clearStaleAgentCollabRecovery;
@@ -4406,6 +5091,20 @@ export default function DesignEditor() {
     const fileId = activeFileId;
     const ytext = ydoc.getText("content");
     const text = ytext.toString();
+    const pendingLocalContent =
+      pendingLocalFileContentsRef.current.get(fileId)?.content;
+    if (pendingLocalContent && text !== pendingLocalContent) {
+      setCollabContent(pendingLocalContent);
+      setCollabContentFileId(fileId);
+      lastLocalContentRef.current = pendingLocalContent;
+      latestActiveContentRef.current = pendingLocalContent;
+      setContentRenderRevision((revision) => revision + 1);
+      ydoc.transact(() => {
+        ytext.delete(0, ytext.length);
+        ytext.insert(0, pendingLocalContent);
+      }, TAB_ID);
+      return;
+    }
     if (text.length > 0) {
       const storedContent = activeFile?.content ?? "";
       if (
@@ -4418,6 +5117,7 @@ export default function DesignEditor() {
         setCollabContent(storedContent);
         setCollabContentFileId(fileId);
         lastLocalContentRef.current = storedContent;
+        latestActiveContentRef.current = storedContent;
         setContentRenderRevision((revision) => revision + 1);
         ydoc.transact(() => {
           ytext.delete(0, ytext.length);
@@ -4430,9 +5130,17 @@ export default function DesignEditor() {
       // confirms or applies the current DB content.
       setCollabContent(text);
       setCollabContentFileId(fileId);
+      latestActiveContentRef.current = text;
       setContentRenderRevision((revision) => revision + 1);
     }
-  }, [ydoc, isSynced, activeFileId, activeFile?.content, activeFile?.fileType]);
+  }, [
+    ydoc,
+    isSynced,
+    activeFileId,
+    activeFile?.content,
+    activeFile?.fileType,
+    pendingLocalFileContentsRevision,
+  ]);
 
   // Keep the freshest DB `updatedAt` in a ref the observe handler can read.
   useEffect(() => {
@@ -4453,14 +5161,29 @@ export default function DesignEditor() {
     const ytext = ydoc.getText("content");
     const handler = (_event: unknown, transaction?: { origin?: unknown }) => {
       const next = ytext.toString();
-      setCollabContent(next);
-      setCollabContentFileId(fileId);
       // UndoManager fires with itself as the origin; treat those as local too
       // so the reconcile watermark and stale-selection fix are consistent.
       const isLocalEdit =
         transaction?.origin === TAB_ID ||
         transaction?.origin === LOCAL_EDIT_ORIGIN ||
         transaction?.origin === undoManagerRef.current;
+      const pendingLocalContent =
+        pendingLocalFileContentsRef.current.get(fileId)?.content;
+      if (pendingLocalContent && next !== pendingLocalContent && !isLocalEdit) {
+        setCollabContent(pendingLocalContent);
+        setCollabContentFileId(fileId);
+        lastLocalContentRef.current = pendingLocalContent;
+        latestActiveContentRef.current = pendingLocalContent;
+        setContentRenderRevision((revision) => revision + 1);
+        ydoc.transact(() => {
+          ytext.delete(0, ytext.length);
+          ytext.insert(0, pendingLocalContent);
+        }, TAB_ID);
+        return;
+      }
+      setCollabContent(next);
+      setCollabContentFileId(fileId);
+      latestActiveContentRef.current = next;
       if (isLocalEdit) {
         lastLocalContentRef.current = next;
       } else {
@@ -4565,6 +5288,7 @@ export default function DesignEditor() {
       setCollabContent(dbContent);
       setCollabContentFileId(activeFile.id);
       lastLocalContentRef.current = dbContent;
+      latestActiveContentRef.current = dbContent;
       if (dbUpdatedAt) lastAppliedFileUpdatedAtRef.current = dbUpdatedAt;
       setContentRenderRevision((revision) => revision + 1);
 
@@ -4618,6 +5342,7 @@ export default function DesignEditor() {
             setCollabContent(expectedContent);
             setCollabContentFileId(expectedFileId);
             lastLocalContentRef.current = expectedContent;
+            latestActiveContentRef.current = expectedContent;
             lastAppliedFileUpdatedAtRef.current = expectedUpdatedAt;
             setContentRenderRevision((revision) => revision + 1);
 
@@ -4643,6 +5368,7 @@ export default function DesignEditor() {
     setCollabContent(dbContent);
     setCollabContentFileId(activeFile.id);
     lastLocalContentRef.current = dbContent;
+    latestActiveContentRef.current = dbContent;
     if (dbUpdatedAt) lastAppliedFileUpdatedAtRef.current = dbUpdatedAt;
     setContentRenderRevision((revision) => revision + 1);
 
@@ -4688,6 +5414,72 @@ export default function DesignEditor() {
   const canvasContextMenuRef = useRef<CanvasContextMenuHandle | null>(null);
   const canvasContainerRef = useRef<HTMLDivElement>(null);
 
+  // Live handle to the active DesignCanvas preview iframe. DesignCanvas owns the
+  // <iframe> internally (tagged data-design-preview-iframe) and does not forward
+  // its ref, so we resolve the element lazily from the DOM at read time. The
+  // MotionDock reads `.current` only when scrubbing, so this always returns the
+  // currently-mounted iframe even after content swaps recreate the element.
+  const canvasIframeRef = useMemo<React.RefObject<HTMLIFrameElement | null>>(
+    () => ({
+      get current() {
+        return document.querySelector<HTMLIFrameElement>(
+          "iframe[data-design-preview-iframe]",
+        );
+      },
+    }),
+    [],
+  );
+
+  const handleRunDesignAudit = useCallback(async () => {
+    if (!id || !activeFile?.id) return;
+    const auditFileId = activeFile.id;
+    setReviewFileId(auditFileId);
+    setReviewAuditLoading(true);
+    setReviewAuditError(null);
+    try {
+      const result = await callAction<{
+        findings: A11yFinding[];
+        auditedAt: string;
+      }>("run-design-audit", {
+        designId: id,
+        fileId: auditFileId,
+      } as any);
+      setReviewFileId(auditFileId);
+      setReviewFindings(Array.isArray(result.findings) ? result.findings : []);
+      setReviewAuditedAt(result.auditedAt ?? new Date().toISOString());
+    } catch (error) {
+      const message =
+        error instanceof Error
+          ? error.message
+          : t("designEditor.toasts.auditRunFailed");
+      setReviewAuditError(message);
+      toast.error(message);
+    } finally {
+      setReviewAuditLoading(false);
+    }
+  }, [activeFile?.id, id, t]);
+
+  const handleReviewFindingClick = useCallback(
+    (finding: A11yFinding) => {
+      const selector =
+        finding.selector ??
+        (finding.nodeId
+          ? `[data-agent-native-node-id="${finding.nodeId.replace(/"/g, '\\"')}"]`
+          : null);
+      if (!selector) return;
+      canvasIframeRef.current?.contentWindow?.postMessage(
+        {
+          type: "select-element",
+          selector,
+          nodeId: finding.nodeId ?? undefined,
+        },
+        "*",
+      );
+      if (finding.nodeId) setSelectedLayerIdsState([finding.nodeId]);
+    },
+    [canvasIframeRef],
+  );
+
   // Broadcast pointer position (normalized to canvas container) and
   // selected element selector so peers can see where the user is working.
   const handleCanvasPointerMove = useCallback(
@@ -4801,26 +5593,45 @@ export default function DesignEditor() {
   // Resolve the content to render: prefer collab content only after the
   // per-file reconcile state has reset for the current active file. Otherwise a
   // file switch can render one frame with the previous file's Yjs text.
+  // Always resolve to a string — a non-string source (e.g. a collab value that
+  // is not yet a plain string, or a not-yet-loaded file) must never reach the
+  // many `content.trim()` / projection callers below, which would crash render.
   const activeCollabFileReady =
     viewMode === "single" && activeFileId === prevActiveFileIdRef.current;
-  const activeContent =
-    activeCollabFileReady &&
+  const pendingActiveFileContent = activeFile?.id
+    ? pendingLocalFileContentsSnapshot.get(activeFile.id)?.content
+    : undefined;
+  const activeContentSource =
+    pendingActiveFileContent ??
+    (activeCollabFileReady &&
     collabContentFileId === activeFile?.id &&
     collabContent !== null
       ? collabContent
-      : (activeFile?.content ?? "");
+      : (activeFile?.content ?? ""));
+  const activeContent =
+    typeof activeContentSource === "string" ? activeContentSource : "";
+  useLayoutEffect(() => {
+    latestActiveContentRef.current = activeContent;
+  }, [activeContent]);
   const fileContentById = useMemo(() => {
     const map = new Map<string, string>();
     for (const file of files) {
-      map.set(file.id, file.content ?? "");
+      map.set(file.id, typeof file.content === "string" ? file.content : "");
     }
     return map;
   }, [files]);
   const getScreenContent = useCallback(
     (screenId: string) =>
-      screenId === activeFile?.id
-        ? activeContent
-        : (fileContentById.get(screenId) ?? ""),
+      getFreshScreenContent({
+        screenId,
+        activeFileId: activeFile?.id,
+        freshActiveContent: getFreshActiveFileContent({
+          activeContent,
+          latestContent: latestActiveContentRef.current,
+          lastLocalContent: lastLocalContentRef.current,
+        }),
+        fileContentById,
+      }),
     [activeContent, activeFile?.id, fileContentById],
   );
   const pageStyles = useMemo(
@@ -4846,24 +5657,227 @@ export default function DesignEditor() {
     return selectedElement?.selector ? [selectedElement.selector] : [];
   }, [selectedCodeLayerNode, selectedElement?.selector]);
   const selectedCanvasSelector = selectedCanvasSelectorCandidates[0] ?? null;
-  const hoveredCodeLayerNode = useMemo(() => {
-    if (!hoveredElement) return null;
-    if (isScreenRootElementInfo(hoveredElement)) return null;
-    return resolveCodeLayerNodeFromElementInfo(
-      activeCodeLayerProjection,
-      hoveredElement,
-    );
-  }, [activeCodeLayerProjection, hoveredElement]);
-  const hoveredCanvasSelectorCandidates = useMemo(() => {
-    if (isScreenRootElementInfo(hoveredElement)) return [];
-    if (hoveredCodeLayerNode) {
-      return codeLayerSelectorAliases(hoveredCodeLayerNode);
-    }
-    return hoveredElement?.selector ? [hoveredElement.selector] : [];
-  }, [hoveredCodeLayerNode, hoveredElement]);
-  const hoveredCanvasSelector = hoveredCanvasSelectorCandidates[0] ?? null;
-  const hoveredElementIsScreenRoot = isScreenRootElementInfo(hoveredElement);
-  const hoveredScreenRootId = hoveredElementIsScreenRoot
+
+  const handleDesignStateSelect = useCallback(
+    (stateId: string | null, row?: DesignStatePreviewRow) => {
+      setSelectedStateId(stateId);
+      const win = canvasIframeRef.current?.contentWindow;
+      if (!win) return;
+
+      if (stateId === null) {
+        win.postMessage(
+          {
+            type: "replace-document-content",
+            content: activeContent,
+            forceFullDocument: true,
+          },
+          "*",
+        );
+        return;
+      }
+
+      const html = designStatePreviewHtml(row);
+      if (!html) return;
+      win.postMessage(
+        {
+          type: "replace-document-content",
+          content: html,
+          forceFullDocument: true,
+        },
+        "*",
+      );
+    },
+    [activeContent, canvasIframeRef],
+  );
+
+  // ── Inspector header quick actions (Create component / Inspect code) ───────
+  // Resolve the design-level source type + capability map so the inspector can
+  // gate the real-app affordances (jump-to-source, prop write-back).
+  const designSourceType = useMemo(
+    () =>
+      normalizeDesignSourceType(designDataJson.sourceType as unknown) ??
+      "inline",
+    [designDataJson.sourceType],
+  );
+  const sourceCapabilities = useMemo(() => {
+    const caps = resolveSourceCapabilities(designSourceType);
+    return DESIGN_CAPABILITY_NAMES.filter((name) => hasCapability(caps, name));
+  }, [designSourceType]);
+
+  // Builder-hosted preview URL for fusion-source designs, written into the
+  // design data blob by the "Make it real" migration. Threaded into DesignCanvas
+  // so the fusion preview renders (and so the bridge trust check can validate
+  // the frame's origin against it).
+  const designFusionUrl = useMemo(() => {
+    const raw = (designDataJson as { fusionUrl?: unknown }).fusionUrl;
+    return typeof raw === "string" && raw ? raw : undefined;
+  }, [designDataJson]);
+
+  // §6.1 — open a component instance's source. open-component-source selects the
+  // component root in the editor and emits a navigate app-state; for real-app
+  // (localhost / fusion) sources it also resolves the external file location.
+  const handleComponentSourceJump = useCallback(
+    ({ nodeId }: { nodeId: string; componentName: string }) => {
+      if (!id || !nodeId) return;
+      openComponentSourceMutation.mutate(
+        { designId: id, nodeId, fileId: activeFileId ?? undefined } as any,
+        {
+          onError: () => {
+            toast.error(
+              "Could not open component source" /* i18n-ignore edge-case jump failure */,
+            );
+          },
+        },
+      );
+    },
+    [id, activeFileId, openComponentSourceMutation],
+  );
+
+  // The selected node id, when it already is a recognised component instance —
+  // unlocks the contextual Component section at the top of the Design tab.
+  const selectedComponentNodeId = useMemo(() => {
+    if (!selectedCodeLayerNode) return undefined;
+    return isComponentInstance(selectedCodeLayerNode)
+      ? bridgeSourceIdForCodeLayerNode(selectedCodeLayerNode)
+      : undefined;
+  }, [selectedCodeLayerNode]);
+
+  useEffect(() => {
+    setShaderFillPreview(null);
+  }, [activeFile?.id, selectedElement?.selector, selectedElement?.sourceId]);
+
+  // A friendly default name for the create-component dialog, derived from the
+  // selected element's layer name / tag.
+  const defaultComponentName = useMemo(() => {
+    if (selectedCodeLayerNode?.layerName)
+      return selectedCodeLayerNode.layerName;
+    if (selectedElement?.tagName) {
+      const tag = selectedElement.tagName;
+      return tag.charAt(0).toUpperCase() + tag.slice(1);
+    }
+    return "Component";
+  }, [selectedCodeLayerNode?.layerName, selectedElement?.tagName]);
+
+  // Outer HTML of the selection — backs the inline/Alpine "Inspect code" view.
+  const selectedElementOuterHtml = useMemo(() => {
+    if (!selectedElement?.selector) return null;
+    return (
+      selectedElement.htmlContent ??
+      getElementOuterHtml(activeContent, selectedElement.selector)
+    );
+  }, [activeContent, selectedElement?.selector, selectedElement?.htmlContent]);
+
+  // §6.3 — the motion-dock target: the selected element's literal
+  // `data-agent-native-node-id` (the value the motion compiler + preview bridge
+  // match on, NOT the hashed projection id) plus a friendly label. Single-screen
+  // mode auto-stamps every selectable node with this attribute (see the
+  // ensureCodeLayerNodeIdsInHtml effect), so a selection reliably resolves to a
+  // stable node id here. `null` when nothing animatable is selected — the dock
+  // then disables its "Add track" affordance.
+  const motionSelectedTarget = useMemo<{
+    nodeId: string;
+    label: string;
+  } | null>(() => {
+    if (!selectedCodeLayerNode) return null;
+    const nodeId =
+      selectedCodeLayerNode.dataAttributes["data-agent-native-node-id"]?.trim();
+    if (!nodeId) return null;
+    const label =
+      selectedCodeLayerNode.layerName ||
+      selectedElement?.tagName ||
+      "Selected element";
+    return { nodeId, label };
+  }, [selectedCodeLayerNode, selectedElement?.tagName]);
+
+  // Serialisable subset of the dock's tracks for the DesignCanvas motion-preview
+  // bridge. Strips the UI-only `label` field. Only populated while the dock is
+  // open so a closed dock never leaves preview overrides on the canvas; an empty
+  // array makes DesignCanvas send `motion-preview-clear`. Scrubbing previews
+  // these tracks live in the iframe — it never writes (that is "Write to CSS").
+  const motionTracksWire = useMemo<MotionTrackWire[]>(() => {
+    if (!motionDockOpen || motionTracks.length === 0) return [];
+    return motionTracks.map(({ label: _label, ...track }) => track);
+  }, [motionDockOpen, motionTracks]);
+
+  const inspectCodeData = useMemo<InspectCodeData | undefined>(() => {
+    if (!selectedElement) return undefined;
+    // Inline/Alpine: the design HTML is the source — show the element's HTML.
+    // Real-app source resolution (vscode:// deep link) requires the
+    // resolveNodeToFile bridge op, which is wired through open-component-source
+    // when an external file path is available; until that round-trip is hooked
+    // up here the popover shows the projected HTML for all source types.
+    return { html: selectedElementOuterHtml, sourceLocation: null };
+  }, [selectedElement, selectedElementOuterHtml]);
+
+  const handleCreateComponent = useCallback(
+    (name: string) => {
+      if (!id || !selectedElement) return;
+      const nodeId = selectedElementLayerId ?? undefined;
+      const selector = selectedCanvasSelector ?? selectedElement.selector;
+      createComponentMutation.mutate(
+        { designId: id, nodeId, selector, name } as any,
+        {
+          onSuccess: () => {
+            queryClient.invalidateQueries({
+              queryKey: ["action", "get-design"],
+            });
+            toast.success(t("designEditor.toasts.componentCreated"));
+          },
+          onError: () => {
+            toast.error(t("designEditor.toasts.componentCreateFailed"));
+          },
+        },
+      );
+
+      // Follow-up: ask the Design agent to extract props and replace repeated
+      // instances with this component. The deterministic annotate above is the
+      // core; this is an enhancement that runs in the agent chat.
+      sendToAgentChat({
+        message: `Extract props for the "${name}" component and replace repeated instances on this design with it.`,
+        context: [
+          `Design id: "${id}".`,
+          selectedElement.selector
+            ? `Component root selector: ${selectedElement.selector}.`
+            : "",
+          nodeId ? `Component root node id: ${nodeId}.` : "",
+          `The element was just annotated with data-agent-native-component="${name}".`,
+          "Call view-screen first, then use get-code-layer-projection to find repeated instances, and apply-visual-edit / apply-component-prop-edit to converge them on this component with data-agent-native-prop-* props.",
+        ]
+          .filter(Boolean)
+          .join("\n"),
+        submit: true,
+        openSidebar: true,
+      });
+    },
+    [
+      id,
+      selectedElement,
+      selectedElementLayerId,
+      selectedCanvasSelector,
+      createComponentMutation,
+      queryClient,
+      t,
+    ],
+  );
+
+  const hoveredCodeLayerNode = useMemo(() => {
+    if (!hoveredElement) return null;
+    if (isScreenRootElementInfo(hoveredElement)) return null;
+    return resolveCodeLayerNodeFromElementInfo(
+      activeCodeLayerProjection,
+      hoveredElement,
+    );
+  }, [activeCodeLayerProjection, hoveredElement]);
+  const hoveredCanvasSelectorCandidates = useMemo(() => {
+    if (isScreenRootElementInfo(hoveredElement)) return [];
+    if (hoveredCodeLayerNode) {
+      return codeLayerSelectorAliases(hoveredCodeLayerNode);
+    }
+    return hoveredElement?.selector ? [hoveredElement.selector] : [];
+  }, [hoveredCodeLayerNode, hoveredElement]);
+  const hoveredCanvasSelector = hoveredCanvasSelectorCandidates[0] ?? null;
+  const hoveredElementIsScreenRoot = isScreenRootElementInfo(hoveredElement);
+  const hoveredScreenRootId = hoveredElementIsScreenRoot
     ? hoveredElementScreenId
     : null;
   const hoveredChildScreenId = hoveredElementIsScreenRoot
@@ -4923,9 +5937,44 @@ export default function DesignEditor() {
       } = {},
     ) => {
       if (!activeFile || !canEditDesignRef.current) return;
+      const previousContent =
+        collabContentFileIdRef.current === activeFile.id &&
+        typeof collabContentRef.current === "string"
+          ? collabContentRef.current
+          : (activeFile.content ?? "");
+      const yjsHistoryAvailable = Boolean(
+        ydoc && isSynced && undoManagerRef.current,
+      );
+      if (
+        !suppressContentHistoryRef.current &&
+        !yjsHistoryAvailable &&
+        previousContent !== nextContent
+      ) {
+        contentUndoStackRef.current = [
+          ...contentUndoStackRef.current.slice(-(MAX_DESIGN_UNDO_STACK - 1)),
+          {
+            fileId: activeFile.id,
+            before: previousContent,
+            after: nextContent,
+          },
+        ];
+        contentRedoStackRef.current = [];
+        historyOrderRef.current = [
+          ...historyOrderRef.current.slice(-(MAX_DESIGN_UNDO_STACK - 1)),
+          "content",
+        ];
+        redoOrderRef.current = [];
+        syncUndoRedoState();
+      }
+      markPendingLocalFileContent(
+        activeFile.id,
+        nextContent,
+        activeFile.updatedAt,
+      );
       setCollabContent(nextContent);
       setCollabContentFileId(activeFile.id);
       lastLocalContentRef.current = nextContent;
+      latestActiveContentRef.current = nextContent;
       if (id) {
         queryClient.setQueryData(
           ["action", "get-design", { id }],
@@ -4976,9 +6025,11 @@ export default function DesignEditor() {
       activeFile,
       id,
       isSynced,
+      markPendingLocalFileContent,
       queryClient,
       queueFileContentSave,
       replacePreviewContent,
+      syncUndoRedoState,
       ydoc,
     ],
   );
@@ -4994,6 +6045,8 @@ export default function DesignEditor() {
         applyLocalContentUpdate(nextContent, options);
         return;
       }
+      const previousFile = files.find((file) => file.id === fileId);
+      markPendingLocalFileContent(fileId, nextContent, previousFile?.updatedAt);
       queryClient.setQueryData(["action", "get-design", { id }], (old: any) => {
         if (!old || typeof old !== "object" || !Array.isArray(old.files)) {
           return old;
@@ -5011,9 +6064,79 @@ export default function DesignEditor() {
         syncCollab: true,
       });
     },
-    [activeFile?.id, applyLocalContentUpdate, id, queryClient, saveFileContent],
+    [
+      activeFile?.id,
+      applyLocalContentUpdate,
+      files,
+      id,
+      markPendingLocalFileContent,
+      queryClient,
+      saveFileContent,
+    ],
+  );
+
+  const handleComponentPropApplied = useCallback(
+    (fileId: string, nextContent: string) => {
+      applyFileContentUpdate(fileId, nextContent, {
+        refreshPreview: fileId === activeFile?.id,
+      });
+    },
+    [activeFile?.id, applyFileContentUpdate],
+  );
+
+  const handleReviewFixApplied = useCallback(
+    (
+      _finding: A11yFinding,
+      result?: { fileId?: string; patchedContent?: string },
+    ) => {
+      setReviewFindings((prev) =>
+        prev.filter((finding) => finding.id !== _finding.id),
+      );
+      if (
+        typeof result?.fileId === "string" &&
+        typeof result.patchedContent === "string"
+      ) {
+        applyFileContentUpdate(result.fileId, result.patchedContent, {
+          refreshPreview: result.fileId === activeFile?.id,
+        });
+      }
+      void handleRunDesignAudit();
+    },
+    [activeFile?.id, applyFileContentUpdate, handleRunDesignAudit],
   );
 
+  const resolvedReviewPanelProps = useMemo<
+    Omit<ReviewPanelProps, "className"> | undefined
+  >(() => {
+    if (!id || !activeFile) return undefined;
+    const reviewMatchesActiveFile = reviewFileId === activeFile.id;
+    return {
+      findings: reviewMatchesActiveFile ? reviewFindings : [],
+      auditLoading: reviewMatchesActiveFile ? reviewAuditLoading : false,
+      auditedAt: reviewMatchesActiveFile ? reviewAuditedAt : null,
+      auditError: reviewMatchesActiveFile ? reviewAuditError : null,
+      onRunAudit: handleRunDesignAudit,
+      onFindingClick: handleReviewFindingClick,
+      fixSource: {
+        designId: id,
+        fileId: activeFile.id,
+        filename: activeFile.filename,
+      },
+      onFixApplied: handleReviewFixApplied,
+    };
+  }, [
+    activeFile,
+    handleReviewFindingClick,
+    handleReviewFixApplied,
+    handleRunDesignAudit,
+    id,
+    reviewAuditError,
+    reviewAuditLoading,
+    reviewAuditedAt,
+    reviewFileId,
+    reviewFindings,
+  ]);
+
   const handleCreatePrimitive = useCallback(
     (screenId: string, primitive: CanvasPrimitiveInsert) => {
       if (!canEditDesign) return false;
@@ -5085,8 +6208,12 @@ export default function DesignEditor() {
 
   const handlePrimitiveCreated = useCallback(
     (screenId: string, nodeId: string) => {
+      // B2/B4 fix: stay in overview mode after drawing a primitive.  The user
+      // drew a shape on the board — they should remain on the board with the
+      // new primitive selected, matching Figma behaviour.  We activate the
+      // target screen (so the layers panel shows its content) and select the
+      // new node, but do NOT switch to single/full view.
       pendingOverviewScreenSelectionRef.current = null;
-      viewModeRef.current = "single";
       setActiveFileId(screenId);
       setSelectedElement(null);
       setHoveredElement(null);
@@ -5094,7 +6221,7 @@ export default function DesignEditor() {
       setOverviewSelectedScreenIds([]);
       setActiveTool("move");
       setMode("edit");
-      setViewMode("single");
+      // viewMode stays at "overview" — no setViewMode("single") call here.
     },
     [],
   );
@@ -5329,6 +6456,58 @@ export default function DesignEditor() {
       mode,
       activeTool,
       inspectorTab: activeInspectorTab,
+      // §8 DesignNavigationState additions — dock + breakpoint context
+      dock: { kind: "motion" as const, open: motionDockOpen },
+      motion: {
+        previewing: false,
+        playheadMs: 0,
+        timelineId: undefined as string | undefined,
+        selectedTrackId: undefined as string | undefined,
+        selectedKeyframeId: undefined as string | undefined,
+      },
+      // §8 breakpoint fields — "auto" = no specific breakpoint focused.
+      breakpoint: (activeBreakpointWidthState != null
+        ? activeBreakpointWidthState < 500
+          ? "mobile"
+          : activeBreakpointWidthState < 1024
+            ? "tablet"
+            : "desktop"
+        : "auto") as "auto" | "mobile" | "tablet" | "desktop",
+      activeBreakpointId: (() => {
+        if (activeBreakpointWidthState == null) return undefined;
+        try {
+          const raw = (designDataJson as Record<string, unknown>)
+            ?.breakpointSet;
+          if (
+            raw &&
+            typeof raw === "object" &&
+            Array.isArray((raw as Record<string, unknown>).breakpoints)
+          ) {
+            const bps = (
+              raw as { breakpoints: Array<{ id: string; widthPx: number }> }
+            ).breakpoints;
+            return bps.find((b) => b.widthPx === activeBreakpointWidthState)
+              ?.id;
+          }
+        } catch {
+          // ignore
+        }
+        return undefined;
+      })(),
+      breakpointSetId: (() => {
+        try {
+          const raw = (designDataJson as Record<string, unknown>)
+            ?.breakpointSet;
+          if (raw && typeof raw === "object") {
+            return (raw as Record<string, unknown>).id as string | undefined;
+          }
+        } catch {
+          // ignore
+        }
+        return undefined;
+      })(),
+      // §8 — active design state (null = Default / live view)
+      selectedStateId,
     };
     (window as any).__designSelection = selection;
     const persistedSelection = {
@@ -5344,6 +6523,12 @@ export default function DesignEditor() {
       mode: selection.mode,
       activeTool: selection.activeTool,
       inspectorTab: selection.inspectorTab,
+      dock: selection.dock,
+      motion: selection.motion,
+      breakpoint: selection.breakpoint,
+      activeBreakpointId: selection.activeBreakpointId,
+      breakpointSetId: selection.breakpointSetId,
+      selectedStateId: selection.selectedStateId,
       ownerId: designSelectionOwnerIdRef.current,
     };
     const persistedKey = JSON.stringify(persistedSelection);
@@ -5381,6 +6566,10 @@ export default function DesignEditor() {
     overviewSelectedScreenIds,
     viewMode,
     zoom,
+    motionDockOpen,
+    activeBreakpointWidthState,
+    designDataJson,
+    selectedStateId,
   ]);
 
   useEffect(() => {
@@ -5440,6 +6629,15 @@ export default function DesignEditor() {
       mode,
       activeTool,
       tweakValues: tweakSelections,
+      onShaderFillPreview: (_descriptor, css) => {
+        setShaderFillPreview({
+          selector: selectedElement?.selector ?? undefined,
+          nodeId:
+            selectedElement?.sourceId ?? selectedCodeLayerNode?.id ?? undefined,
+          css,
+        });
+      },
+      onShaderFillPreviewClear: () => setShaderFillPreview(null),
     }),
     [
       activeFile?.filename,
@@ -5452,6 +6650,7 @@ export default function DesignEditor() {
       mode,
       overviewSelectedScreenIds,
       selectedElement,
+      selectedCodeLayerNode?.id,
       selectedScreenIds,
       tweakSelections,
       viewMode,
@@ -5676,7 +6875,10 @@ export default function DesignEditor() {
       // advance lastLocalContentRef.current to resolvedNextContent below, the
       // next synchronous call reads the previous call's result and the patches
       // compose. Falls back to activeContent when the ref is unset (file switch).
-      const baseContent = lastLocalContentRef.current ?? activeContent;
+      const baseContent =
+        latestActiveContentRef.current ??
+        lastLocalContentRef.current ??
+        activeContent;
       const [firstProperty, firstValue] = entries[0];
       const projection = buildCodeLayerProjection(baseContent);
       const targetInfo = options.elementInfo ?? selectedElement;
@@ -5743,20 +6945,71 @@ export default function DesignEditor() {
       });
       const sendStyleChange = (window as any).__designCanvasSendStyle;
       if (!options.runtimeApplied && typeof sendStyleChange === "function") {
+        const selectorCandidates = targetNode
+          ? codeLayerSelectorAliases(targetNode)
+          : selector
+            ? [selector]
+            : [];
+        const nodeId = targetNode
+          ? bridgeSourceIdForCodeLayerNode(targetNode)
+          : targetInfo?.sourceId;
         entries.forEach(([property, value]) => {
-          sendStyleChange(selector, property, value);
+          sendStyleChange(selector, property, value, {
+            selectorCandidates,
+            nodeId,
+          });
         });
       }
 
       const nextContent = applyInlineStylesToHtml(baseContent, selector, {
         ...Object.fromEntries(entries),
       });
+      // §6.4 — Breakpoint-scoped class editing. Reuses the `projection` and
+      // `targetNode` resolved above for the patch-proof block (same baseContent).
+      // When an active non-base breakpoint frame is set, attempt to route class
+      // edits through `kind: "responsive-class"` so the write targets only that
+      // breakpoint prefix (e.g. "md:text-lg" instead of "text-lg").  This fires
+      // when the element has a `responsive-class` EditCapability, which signals
+      // that its values come from Tailwind class tokens and can carry a prefix.
+      // Falls back to `kind: "style"` (inline attribute) for any entry that
+      // fails the responsive path (e.g. raw CSS values with no Tailwind utility).
+      const activeBreakpointPrefix =
+        activeBreakpointWidthState != null
+          ? widthToPrefix(activeBreakpointWidthState)
+          : null;
+      // `responsive-class` is a code-layer EditCapability kind not yet reflected
+      // in the ElementInfo type union (types.ts); cast to string for the check.
+      const hasResponsiveCapability =
+        activeBreakpointPrefix != null &&
+        activeBreakpointPrefix !== "base" &&
+        selectedElement?.editCapabilities?.some(
+          (cap) => (cap.kind as string) === "responsive-class",
+        );
       const stylePatch = entries.reduce<{
         content: string;
         failed: string | null;
       }>(
         (current, [property, value]) => {
           if (current.failed) return current;
+          // Try responsive-class path first when appropriate.
+          if (hasResponsiveCapability && activeBreakpointPrefix) {
+            const utility = value.trim();
+            if (responsiveUtilityMatchesStyleProperty(property, utility)) {
+              const rcPatch = applyVisualEdit(current.content, {
+                kind: "responsive-class",
+                target: targetNode ? { nodeId: targetNode.id } : { selector },
+                prefix: activeBreakpointPrefix,
+                operation: "replace",
+                utility,
+                stem: utilityStem(utility),
+              });
+              if (rcPatch.result.status === "applied") {
+                return { content: rcPatch.content, failed: null };
+              }
+            }
+            // Responsive-class path didn't apply (e.g. value is a raw CSS value,
+            // not a Tailwind utility); fall through to the inline-style path.
+          }
           const patch = applyVisualEdit(current.content, {
             kind: "style",
             target: targetNode ? { nodeId: targetNode.id } : { selector },
@@ -5826,6 +7079,7 @@ export default function DesignEditor() {
       // Mark as our own write so the get-design reconcile + Yjs observe don't
       // treat the echo as an external edit and fight the live value.
       lastLocalContentRef.current = resolvedNextContent;
+      latestActiveContentRef.current = resolvedNextContent;
       // Write the edit into the shared Y.Doc so other open clients see it live
       // through Yjs (not only via the slower update-file → applyText round-trip).
       // Use LOCAL_EDIT_ORIGIN so the UndoManager captures this transaction.
@@ -5865,6 +7119,7 @@ export default function DesignEditor() {
     [
       activeContent,
       activeFile,
+      activeBreakpointWidthState,
       canEditDesign,
       queueFileContentSave,
       selectedElement,
@@ -5884,7 +7139,10 @@ export default function DesignEditor() {
       ) {
         const sendStyleChange = (window as any).__designCanvasSendStyle;
         if (typeof sendStyleChange === "function") {
-          sendStyleChange(selector, property, value);
+          sendStyleChange(selector, property, value, {
+            selectorCandidates: selectedCanvasSelectorCandidates,
+            nodeId: selectedElement?.sourceId,
+          });
           return;
         }
       }
@@ -5893,6 +7151,8 @@ export default function DesignEditor() {
     [
       commitVisualStyles,
       selectedElement?.selector,
+      selectedElement?.sourceId,
+      selectedCanvasSelectorCandidates,
       textEditingState.active,
       textEditingState.hasRange,
       textEditingState.selector,
@@ -5911,6 +7171,16 @@ export default function DesignEditor() {
     [commitVisualStyles, selectedElement?.selector],
   );
 
+  const getFreshActiveContent = useCallback(
+    () =>
+      getFreshActiveFileContent({
+        activeContent,
+        latestContent: latestActiveContentRef.current,
+        lastLocalContent: lastLocalContentRef.current,
+      }),
+    [activeContent],
+  );
+
   const handleVisualStyleChange = useCallback(
     (
       selector: string,
@@ -5939,7 +7209,8 @@ export default function DesignEditor() {
     ) => {
       if (!canEditDesign) return false;
       if (!activeFile) return false;
-      const projection = buildCodeLayerProjection(activeContent);
+      const baseContent = getFreshActiveContent();
+      const projection = buildCodeLayerProjection(baseContent);
       const resolveBridgeNode = (targetSelector: string, sourceId?: string) =>
         resolveCodeLayerNodeFromBridge(projection, targetSelector, sourceId);
       const targetInfo = elementInfo
@@ -5956,7 +7227,7 @@ export default function DesignEditor() {
         anchorSelector,
         details?.anchorSourceId,
       );
-      const patch = applyVisualEdit(activeContent, {
+      const patch = applyVisualEdit(baseContent, {
         kind: "moveNode",
         target: targetNode ? { nodeId: targetNode.id } : { selector },
         anchor: anchorNode
@@ -6004,7 +7275,13 @@ export default function DesignEditor() {
       }
       return true;
     },
-    [activeContent, activeFile, applyLocalContentUpdate, canEditDesign, t],
+    [
+      activeFile,
+      applyLocalContentUpdate,
+      canEditDesign,
+      getFreshActiveContent,
+      t,
+    ],
   );
 
   const handleVisualDuplicateChange = useCallback(
@@ -6021,7 +7298,8 @@ export default function DesignEditor() {
     ) => {
       if (!canEditDesign) return false;
       if (!activeFile) return false;
-      const projection = buildCodeLayerProjection(activeContent);
+      const baseContent = getFreshActiveContent();
+      const projection = buildCodeLayerProjection(baseContent);
       const targetInfo = elementInfo
         ? {
             ...elementInfo,
@@ -6041,7 +7319,7 @@ export default function DesignEditor() {
         details?.anchorSelector,
         details?.anchorSourceId,
       );
-      const nextContent = insertClonedHtmlLayer(activeContent, cloneHtml, {
+      const nextContent = insertClonedHtmlLayer(baseContent, cloneHtml, {
         targetSelectors: targetNode
           ? codeLayerSelectorAliases(targetNode)
           : [selector],
@@ -6075,7 +7353,13 @@ export default function DesignEditor() {
       }
       return true;
     },
-    [activeContent, activeFile, applyLocalContentUpdate, canEditDesign, t],
+    [
+      activeFile,
+      applyLocalContentUpdate,
+      canEditDesign,
+      getFreshActiveContent,
+      t,
+    ],
   );
 
   const handleTextContentChange = useCallback(
@@ -6087,7 +7371,8 @@ export default function DesignEditor() {
     ) => {
       if (!canEditDesign) return;
       if (!activeFile) return;
-      const projection = buildCodeLayerProjection(activeContent);
+      const baseContent = getFreshActiveContent();
+      const projection = buildCodeLayerProjection(baseContent);
       const targetInfo = elementInfo ? { ...elementInfo, selector } : null;
       const targetNode = targetInfo
         ? resolveCodeLayerNodeFromElementInfo(projection, targetInfo)
@@ -6095,10 +7380,10 @@ export default function DesignEditor() {
       const isEmpty = value.trim().length === 0;
       const removedContent =
         isEmpty && targetNode
-          ? removeCodeLayerNodeFromHtml(activeContent, targetNode)
+          ? removeCodeLayerNodeFromHtml(baseContent, targetNode)
           : null;
       const patch = !removedContent
-        ? applyVisualEdit(activeContent, {
+        ? applyVisualEdit(baseContent, {
             kind: "textContent",
             target: targetNode ? { nodeId: targetNode.id } : { selector },
             value,
@@ -6108,12 +7393,7 @@ export default function DesignEditor() {
       const nextContent =
         removedContent ??
         (patch?.result.status === "applied" ? patch.content : null) ??
-        updateElementContentInHtml(
-          activeContent,
-          selector,
-          value,
-          details?.html,
-        );
+        updateElementContentInHtml(baseContent, selector, value, details?.html);
       if (!nextContent) {
         toast.error(
           codeLayerPatchMessage(
@@ -6162,7 +7442,13 @@ export default function DesignEditor() {
           : previous;
       });
     },
-    [activeContent, activeFile, applyLocalContentUpdate, canEditDesign, t],
+    [
+      activeFile,
+      applyLocalContentUpdate,
+      canEditDesign,
+      getFreshActiveContent,
+      t,
+    ],
   );
 
   const handleScreenVisualStyleChange = useCallback(
@@ -6483,22 +7769,71 @@ export default function DesignEditor() {
 
   const handleCopySelection = useCallback(async () => {
     if (!selectedElement?.selector) return;
-    const html = getElementOuterHtml(activeContent, selectedElement.selector);
+    const html = getElementOuterHtml(
+      getFreshActiveContent(),
+      selectedElement.selector,
+    );
     if (!html) return;
     copiedLayerHtmlRef.current = html;
     pasteCascadeRef.current = 0;
     setHasCanvasClipboard(true);
     try {
       await navigator.clipboard.writeText(html);
-      toast.success(t("designEditor.toasts.copied"));
     } catch {
       toast.error(t("designEditor.toasts.clipboardBlocked"));
     }
-  }, [activeContent, selectedElement, t]);
+  }, [getFreshActiveContent, selectedElement, t]);
 
   const handlePasteSelection = useCallback(
     (position?: { x: number; y: number }) => {
       if (!activeFile || !canEditDesign || !copiedLayerHtmlRef.current) return;
+      const baseContent = getFreshActiveContent();
+
+      // B7 fix: when an element is selected and no explicit canvas position was
+      // given, insert the clone as an in-flow sibling right AFTER the selected
+      // element.  Strip any position/left/top from the clone so it participates
+      // in normal document flow instead of being an absolutely-positioned body
+      // child.  Fall back to the old position-based clone when nothing is
+      // selected or a "Paste here" position is provided.
+      if (!position && selectedElement?.selector) {
+        const selector = selectedCanvasSelector ?? selectedElement.selector;
+        // Strip position properties from the pasted clone so it becomes an
+        // in-flow sibling (not absolute).
+        const strippedHtml = (() => {
+          try {
+            const parser = new DOMParser();
+            const tmp = parser.parseFromString(
+              `<template>${copiedLayerHtmlRef.current!}</template>`,
+              "text/html",
+            );
+            const root =
+              tmp.querySelector("template")?.content.firstElementChild ??
+              tmp.body.firstElementChild;
+            if (root && root instanceof HTMLElement) {
+              root.style.position = "";
+              root.style.left = "";
+              root.style.top = "";
+              root.style.right = "";
+              root.style.bottom = "";
+            }
+            return root?.outerHTML ?? copiedLayerHtmlRef.current!;
+          } catch {
+            return copiedLayerHtmlRef.current!;
+          }
+        })();
+
+        const nextContent = insertClonedHtmlLayer(baseContent, strippedHtml, {
+          targetSelectors: [selector],
+          placement: "after",
+        });
+        if (nextContent) {
+          pasteCascadeRef.current += 1;
+          applyLocalContentUpdate(nextContent);
+          return;
+        }
+        // Fall through to position-based clone if insert failed.
+      }
+
       // Explicit positions (e.g. "Paste here" at the cursor) are honored as-is.
       // Keyboard pastes land near the source layer and cascade so repeats don't
       // stack exactly.
@@ -6512,53 +7847,86 @@ export default function DesignEditor() {
             : { x: 120 + offset, y: 120 + offset };
         })();
       const nextContent = cloneHtmlLayerAtPosition(
-        activeContent,
+        baseContent,
         copiedLayerHtmlRef.current,
         targetPosition,
       );
       if (!nextContent) return;
       if (!position) pasteCascadeRef.current += 1;
       applyLocalContentUpdate(nextContent);
-      toast.success(t("designEditor.toasts.pasted"), { duration: 3000 });
     },
-    [activeContent, activeFile, applyLocalContentUpdate, canEditDesign, t],
+    [
+      activeFile,
+      applyLocalContentUpdate,
+      canEditDesign,
+      getFreshActiveContent,
+      selectedCanvasSelector,
+      selectedElement,
+    ],
   );
 
   const handlePasteOverSelection = useCallback(() => {
     if (!activeFile || !copiedLayerHtmlRef.current) return;
+    const baseContent = getFreshActiveContent();
     if (selectedElement?.boundingRect) {
       const { x, y } = selectedElement.boundingRect;
       const nextContent = cloneHtmlLayerAtPosition(
-        activeContent,
+        baseContent,
         copiedLayerHtmlRef.current,
         { x, y },
       );
       if (!nextContent) return;
       applyLocalContentUpdate(nextContent);
-      toast.success(t("designEditor.toasts.pasted"));
     } else {
       handlePasteSelection();
     }
   }, [
-    activeContent,
     activeFile,
     applyLocalContentUpdate,
+    getFreshActiveContent,
     handlePasteSelection,
     selectedElement,
-    t,
   ]);
 
   const handleDuplicateSelection = useCallback(() => {
     if (!canEditDesign) return;
     if (selectedElement?.selector) {
-      const html = getElementOuterHtml(activeContent, selectedElement.selector);
-      const rect = selectedElement.boundingRect;
-      const nextContent = html
-        ? cloneHtmlLayerAtPosition(activeContent, html, {
-            x: rect.x + 16,
-            y: rect.y + 16,
-          })
-        : null;
+      const baseContent = getFreshActiveContent();
+      const html = getElementOuterHtml(baseContent, selectedElement.selector);
+      if (!html) {
+        toast.error(t("designEditor.toasts.duplicateElementFailed"));
+        return;
+      }
+      // B7 fix: duplicate inserts the clone as an in-flow sibling right AFTER
+      // the original — not as an absolutely-positioned body child.  Strip
+      // position/left/top so it joins normal document flow.
+      const selector = selectedCanvasSelector ?? selectedElement.selector;
+      const strippedHtml = (() => {
+        try {
+          const parser = new DOMParser();
+          const tmp = parser.parseFromString(
+            `<template>${html}</template>`,
+            "text/html",
+          );
+          const root =
+            tmp.querySelector("template")?.content.firstElementChild ??
+            tmp.body.firstElementChild;
+          if (root && root instanceof HTMLElement) {
+            root.style.position = "";
+            root.style.left = "";
+            root.style.top = "";
+            root.style.right = "";
+            root.style.bottom = "";
+          }
+          return root?.outerHTML ?? html;
+        } catch {
+          return html;
+        }
+      })();
+      const nextContent = insertClonedHtmlLayer(baseContent, strippedHtml, {
+        targetSelectors: [selector],
+        placement: "after",
+      });
       if (nextContent) {
         applyLocalContentUpdate(nextContent);
       } else {
@@ -6568,16 +7936,19 @@ export default function DesignEditor() {
     }
     if (activeFile) handleDuplicateScreen(activeFile.id);
   }, [
-    activeContent,
     activeFile,
     applyLocalContentUpdate,
     canEditDesign,
+    getFreshActiveContent,
     handleDuplicateScreen,
+    selectedCanvasSelector,
     selectedElement,
+    t,
   ]);
 
   const handleDeleteSelection = useCallback(() => {
     if (!canEditDesign) return;
+    const baseContent = getFreshActiveContent();
     // Multi-select delete: when several DOM/code layers are selected in the
     // panel, remove all of them — not just the single focused element. Compose
     // the removals against the running content (re-projecting each pass) so
@@ -6589,7 +7960,7 @@ export default function DesignEditor() {
         !files.some((file) => file.id === layerId),
     );
     if (candidateIds.length > 1) {
-      let content = activeContent;
+      let content = baseContent;
       const removedSelectors: string[] = [];
       for (const layerId of candidateIds) {
         const projection = buildCodeLayerProjection(content);
@@ -6603,7 +7974,7 @@ export default function DesignEditor() {
         if (selector) removedSelectors.push(selector);
         content = next;
       }
-      if (content !== activeContent) {
+      if (content !== baseContent) {
         removedSelectors.forEach((selector) => deleteRuntimeElement(selector));
         applyLocalContentUpdate(content, { refreshPreview: false });
         setSelectedElement(null);
@@ -6614,48 +7985,452 @@ export default function DesignEditor() {
     }
 
     if (!selectedElement?.selector) return;
-    const projection = buildCodeLayerProjection(activeContent);
+    const projection = buildCodeLayerProjection(baseContent);
     const targetNode = resolveCodeLayerNodeFromElementInfo(
       projection,
       selectedElement,
     );
     const nextContent =
       (targetNode
-        ? removeCodeLayerNodeFromHtml(activeContent, targetNode)
-        : null) ??
-      removeElementFromHtml(activeContent, selectedElement.selector);
+        ? removeCodeLayerNodeFromHtml(baseContent, targetNode)
+        : null) ?? removeElementFromHtml(baseContent, selectedElement.selector);
     if (!nextContent) return;
     deleteRuntimeElement(selectedElement.selector);
     applyLocalContentUpdate(nextContent, { refreshPreview: false });
     setSelectedElement(null);
     setSelectedLayerIdsState([]);
   }, [
-    activeContent,
     applyLocalContentUpdate,
     canEditDesign,
     deleteRuntimeElement,
     files,
+    getFreshActiveContent,
     selectedElement,
     selectedLayerIdsState,
   ]);
 
-  const handleCutSelection = useCallback(async () => {
-    if (!selectedElement?.selector) return;
-    // Copy first (populates the internal clipboard ref even if the async
-    // navigator.clipboard write is blocked — handleCopySelection swallows that
-    // error) then remove the element so a subsequent paste can re-insert it.
-    await handleCopySelection();
-    handleDeleteSelection();
-  }, [handleCopySelection, handleDeleteSelection, selectedElement]);
-
-  const handleDeleteOverviewSelection = useCallback(
-    (selectedIds: string[]) => {
-      if (!canEditDesign) return false;
-      if (!selectedIds.length || files.length <= 1) return false;
+  // Wrap the current multi-layer selection into a new group container.
+  const handleGroupSelection = useCallback(() => {
+    if (!canEditDesign || !activeFile) return;
+    const baseContent = getFreshActiveContent();
+    // Collect the DOM-node layer ids that belong to the active screen.
+    // Build a set of ids present in the active content so stale ids from
+    // other files (which can persist in selectedLayerIdsState after a
+    // cross-screen layers-panel selection) are excluded before wrapNodes
+    // runs against activeContent. Without this filter, cross-file ids
+    // cause wrapNodes to return "conflict" even for a valid same-file
+    // selection.
+    const fileIds = new Set(files.map((f) => f.id));
+    const activeNodeIdSet = buildActiveFileNodeIdSet(
+      buildCodeLayerProjection(baseContent),
+    );
+    const nodeIds = selectedLayerIdsState.filter(
+      (id) =>
+        !id.startsWith("__") && !fileIds.has(id) && activeNodeIdSet.has(id),
+    );
+    if (nodeIds.length < 2) return;
+    const patch = applyVisualEdit(baseContent, {
+      kind: "wrapNodes",
+      targetIds: nodeIds,
+      autoLayout: false,
+    });
+    if (patch.result.status !== "applied") {
+      toast.error(
+        codeLayerPatchMessage(
+          patch.result.message,
+          t("designEditor.toasts.layerMoveFailed"),
+        ),
+        { duration: 4000 },
+      );
+      return;
+    }
+    applyLocalContentUpdate(patch.content, { skipPreview: true });
+    // Select the new wrapper node if the substrate reported its id.
+    const wrapperId = patch.result.wrapperNodeId;
+    if (wrapperId) {
+      // Find the projection node whose data-agent-native-node-id matches.
+      const wrapperNode = patch.projection.nodes.find(
+        (n) => n.dataAttributes["data-agent-native-node-id"] === wrapperId,
+      );
+      if (wrapperNode) {
+        setSelectedLayerIdsState([wrapperNode.id]);
+        setSelectedElement(elementInfoFromCodeLayerNode(wrapperNode));
+      }
+    }
+  }, [
+    activeFile,
+    applyLocalContentUpdate,
+    canEditDesign,
+    files,
+    getFreshActiveContent,
+    selectedLayerIdsState,
+    t,
+  ]);
 
-      const selectedIdSet = new Set(selectedIds);
-      const selectedFiles = files.filter((file) => selectedIdSet.has(file.id));
-      if (!selectedFiles.length) return false;
+  // Unwrap the currently selected single-container layer.
+  const handleUngroupSelection = useCallback(() => {
+    if (!canEditDesign || !activeFile) return;
+    const baseContent = getFreshActiveContent();
+    // Filter to active-file nodes only (mirrors handleGroupSelection fix).
+    // A stale id from another file must not be passed to unwrap or it will
+    // fail with "conflict" even though the actual selection is valid.
+    const fileIds = new Set(files.map((f) => f.id));
+    const activeNodeIdSet = buildActiveFileNodeIdSet(
+      buildCodeLayerProjection(baseContent),
+    );
+    const nodeIds = selectedLayerIdsState.filter(
+      (id) =>
+        !id.startsWith("__") && !fileIds.has(id) && activeNodeIdSet.has(id),
+    );
+    const targetId = nodeIds[0];
+    if (!targetId) return;
+    const patch = applyVisualEdit(baseContent, {
+      kind: "unwrap",
+      targetId,
+    });
+    if (patch.result.status !== "applied") {
+      toast.error(
+        codeLayerPatchMessage(
+          patch.result.message,
+          t("designEditor.toasts.layerMoveFailed"),
+        ),
+        { duration: 4000 },
+      );
+      return;
+    }
+    applyLocalContentUpdate(patch.content, { skipPreview: true });
+    setSelectedElement(null);
+    setSelectedLayerIdsState([]);
+  }, [
+    activeFile,
+    applyLocalContentUpdate,
+    canEditDesign,
+    files,
+    getFreshActiveContent,
+    selectedLayerIdsState,
+    t,
+  ]);
+
+  /**
+   * Convert the selected container to full auto-layout. Applies the
+   * { kind: "autoLayout", enabled: true } substrate intent which sets
+   * display:flex on the target AND strips position:absolute/left/top/right/bottom
+   * from its direct children so they become flow children.
+   */
+  const handleAutoLayoutConvert = useCallback(
+    (
+      targetNodeId: string,
+      opts?: { direction?: "row" | "column"; gap?: string },
+    ) => {
+      if (!canEditDesign || !activeFile) return;
+      const baseContent = getFreshActiveContent();
+      const patch = applyVisualEdit(baseContent, {
+        kind: "autoLayout",
+        targetId: targetNodeId,
+        enabled: true,
+        direction: opts?.direction ?? "row",
+        gap: opts?.gap ?? "8px",
+      });
+      if (patch.result.status !== "applied") {
+        toast.error(
+          codeLayerPatchMessage(
+            patch.result.message,
+            t("designEditor.toasts.layerMoveFailed"),
+          ),
+          { duration: 4000 },
+        );
+        return;
+      }
+      applyLocalContentUpdate(patch.content, { skipPreview: true });
+      // Re-select the container so the inspector refreshes its layout state.
+      const containerNode = patch.projection.nodes.find(
+        (n) =>
+          n.dataAttributes["data-agent-native-node-id"] === targetNodeId ||
+          n.id === targetNodeId,
+      );
+      if (containerNode) {
+        setSelectedLayerIdsState([containerNode.id]);
+        setSelectedElement(elementInfoFromCodeLayerNode(containerNode));
+      }
+    },
+    [
+      activeFile,
+      applyLocalContentUpdate,
+      canEditDesign,
+      getFreshActiveContent,
+      t,
+    ],
+  );
+
+  /**
+   * Handle a primitive being drag-dropped onto another primitive in the
+   * MultiScreenCanvas overview (CONTRACT: onPrimitiveReparent prop).
+   *
+   * Same-screen: applies a moveNode intent then strips the moved node's
+   * absolute positioning so it becomes a flow child of the container.
+   * Cross-screen: uses moveNodeBetweenDocuments and persists both files.
+   */
+  const handleOverviewPrimitiveReparent = useCallback(
+    ({
+      sourceNodeId,
+      sourceScreenId,
+      targetNodeId,
+      targetScreenId,
+    }: {
+      sourceNodeId: string;
+      sourceScreenId: string;
+      targetNodeId: string;
+      targetScreenId: string;
+      placement: "inside";
+    }) => {
+      if (!canEditDesign) return;
+
+      if (sourceScreenId === targetScreenId) {
+        // --- Same-screen reparent ---
+        const baseContent = getScreenContent(sourceScreenId);
+        if (!baseContent) return;
+
+        // 1. Move the node inside the target container.
+        const movePatch = applyVisualEdit(baseContent, {
+          kind: "moveNode",
+          target: { nodeId: sourceNodeId },
+          anchor: { nodeId: targetNodeId },
+          placement: "inside",
+        });
+        if (movePatch.result.status !== "applied") {
+          toast.error(
+            codeLayerPatchMessage(
+              movePatch.result.message,
+              t("designEditor.toasts.layerMoveFailed"),
+            ),
+            { duration: 4000 },
+          );
+          return;
+        }
+
+        // 2. Strip absolute positioning from the moved node so it flows naturally.
+        // Use removeAbsolutePositioningFromNodeInHtml (DOM-based) because the
+        // applyVisualEdit substrate rejects empty-string values in isSafeStyleValue,
+        // making applyVisualEdit({kind:"style",value:""}) a silent no-op.
+        const movedNodeAttrId =
+          movePatch.projection.nodes.find(
+            (n) =>
+              n.dataAttributes["data-agent-native-node-id"] === sourceNodeId ||
+              n.id === sourceNodeId,
+          )?.dataAttributes["data-agent-native-node-id"] ?? sourceNodeId;
+        const strippedContent = removeAbsolutePositioningFromNodeInHtml(
+          movePatch.content,
+          movedNodeAttrId,
+        );
+
+        applyFileContentUpdate(sourceScreenId, strippedContent, {
+          skipPreview: true,
+        });
+
+        // Re-select the moved node.
+        const nextProjection = buildCodeLayerProjection(strippedContent);
+        const movedNodeAfter = nextProjection.nodes.find(
+          (n) =>
+            n.dataAttributes["data-agent-native-node-id"] === sourceNodeId ||
+            n.id === sourceNodeId,
+        );
+        if (movedNodeAfter) {
+          setSelectedLayerIdsState([movedNodeAfter.id]);
+          setSelectedElement(elementInfoFromCodeLayerNode(movedNodeAfter));
+        }
+        return;
+      }
+
+      // --- Cross-screen reparent ---
+      const sourceContent = getScreenContent(sourceScreenId);
+      const destContent = getScreenContent(targetScreenId);
+      if (!sourceContent || !destContent) return;
+
+      // Resolve data-agent-native-node-id attributes for moveNodeBetweenDocuments.
+      const sourceProjection = buildCodeLayerProjection(sourceContent);
+      const destProjection = buildCodeLayerProjection(destContent);
+      const sourceNode = sourceProjection.nodes.find(
+        (n) =>
+          n.dataAttributes["data-agent-native-node-id"] === sourceNodeId ||
+          n.id === sourceNodeId,
+      );
+      const anchorNode = destProjection.nodes.find(
+        (n) =>
+          n.dataAttributes["data-agent-native-node-id"] === targetNodeId ||
+          n.id === targetNodeId,
+      );
+      const nodeAttrId =
+        sourceNode?.dataAttributes["data-agent-native-node-id"] ?? sourceNodeId;
+      const anchorAttrId =
+        anchorNode?.dataAttributes["data-agent-native-node-id"] ?? targetNodeId;
+
+      const result = moveNodeBetweenDocuments(sourceContent, destContent, {
+        nodeId: nodeAttrId,
+        anchorNodeId: anchorAttrId,
+        placement: "inside",
+      });
+      if (result.status !== "applied") {
+        toast.error(
+          codeLayerPatchMessage(
+            result.message,
+            t("designEditor.toasts.layerMoveFailed"),
+          ),
+          { duration: 4000 },
+        );
+        return;
+      }
+
+      // Strip absolute positioning from the moved node in the destination.
+      // Use removeAbsolutePositioningFromNodeInHtml (DOM-based) because
+      // applyVisualEdit({kind:"style",value:""}) is a silent no-op (the
+      // substrate rejects empty-string values in isSafeStyleValue). Use
+      // result.movedNodeId (the final id in destHtml, which may differ from
+      // nodeAttrId when a collision triggered an id re-stamp) so the strip and
+      // re-selection always find the correct element.
+      const destNodeAttrId = result.movedNodeId ?? nodeAttrId;
+      const strippedDest = removeAbsolutePositioningFromNodeInHtml(
+        result.destHtml,
+        destNodeAttrId,
+      );
+
+      applyFileContentUpdate(sourceScreenId, result.sourceHtml, {
+        refreshPreview: true,
+      });
+      applyFileContentUpdate(targetScreenId, strippedDest, {
+        refreshPreview: true,
+      });
+
+      // Re-select the moved node in the destination.
+      const finalProjection = buildCodeLayerProjection(strippedDest);
+      const movedNodeFinal = finalProjection.nodes.find(
+        (n) => n.dataAttributes["data-agent-native-node-id"] === destNodeAttrId,
+      );
+      if (movedNodeFinal) {
+        setSelectedLayerIdsState([movedNodeFinal.id]);
+        setSelectedElement(elementInfoFromCodeLayerNode(movedNodeFinal));
+      }
+    },
+    [applyFileContentUpdate, canEditDesign, getScreenContent, t],
+  );
+
+  /**
+   * Cross-screen element drag-drop handler (CONTRACT: onCrossScreenElementDrop
+   * prop on MultiScreenCanvas).
+   *
+   * The bridge in the source screen's iframe posts phase:"end" with the
+   * selector / sourceNodeId of the dragged element.  MultiScreenCanvas maps
+   * the board point to a target screen and calls this handler.  We resolve
+   * both screens' content, identify the node by its data-agent-native-node-id
+   * (falling back to a projection lookup by selector when only the selector is
+   * available), call moveNodeBetweenDocuments to move it into the target
+   * screen's <body>, persist both files, switch the active screen to the
+   * target, and select the moved node — keeping viewMode "overview" throughout.
+   */
+  const handleCrossScreenElementDrop = useCallback(
+    ({
+      sourceSelector,
+      sourceNodeId,
+      sourceScreenId,
+      targetScreenId,
+    }: {
+      sourceSelector: string;
+      sourceNodeId?: string;
+      sourceScreenId: string;
+      targetScreenId: string;
+    }) => {
+      if (!canEditDesign) return;
+      if (sourceScreenId === targetScreenId) return;
+
+      const sourceContent = getScreenContent(sourceScreenId);
+      const destContent = getScreenContent(targetScreenId);
+      if (!sourceContent || !destContent) return;
+
+      // Resolve the data-agent-native-node-id that moveNodeBetweenDocuments
+      // uses as a stable key.  Prefer the bridge-supplied sourceNodeId when it
+      // looks like a node-attr id; otherwise look up via selector projection.
+      const sourceProjection = buildCodeLayerProjection(sourceContent);
+      const resolvedSourceNode = sourceNodeId
+        ? (sourceProjection.nodes.find(
+            (n) =>
+              n.dataAttributes["data-agent-native-node-id"] === sourceNodeId ||
+              n.id === sourceNodeId,
+          ) ??
+          resolveCodeLayerNodeFromBridge(
+            sourceProjection,
+            sourceSelector,
+            sourceNodeId,
+          ))
+        : resolveCodeLayerNodeFromBridge(sourceProjection, sourceSelector);
+      const nodeAttrId =
+        resolvedSourceNode?.dataAttributes["data-agent-native-node-id"] ??
+        sourceNodeId ??
+        sourceSelector;
+
+      const result = moveNodeBetweenDocuments(sourceContent, destContent, {
+        nodeId: nodeAttrId,
+        placement: "inside",
+      });
+      if (result.status !== "applied") {
+        toast.error(
+          codeLayerPatchMessage(
+            result.message,
+            t("designEditor.toasts.layerMoveFailed"),
+          ),
+          { duration: 4000 },
+        );
+        return;
+      }
+
+      // Strip absolute positioning from the moved node in the destination so
+      // it flows naturally as a body child (mirrors handleOverviewPrimitiveReparent).
+      // Use result.movedNodeId (the final id in destHtml, which may differ from
+      // nodeAttrId when a collision triggered an id re-stamp) so the strip and
+      // re-selection always find the correct element.
+      const destNodeAttrId = result.movedNodeId ?? nodeAttrId;
+      const strippedDest = removeAbsolutePositioningFromNodeInHtml(
+        result.destHtml,
+        destNodeAttrId,
+      );
+
+      applyFileContentUpdate(sourceScreenId, result.sourceHtml, {
+        refreshPreview: true,
+      });
+      applyFileContentUpdate(targetScreenId, strippedDest, {
+        refreshPreview: true,
+      });
+
+      // Switch active screen to the target and select the moved node; viewMode
+      // stays "overview" (no setViewMode call).
+      setActiveFileId(targetScreenId);
+      const finalProjection = buildCodeLayerProjection(strippedDest);
+      const movedNodeFinal = finalProjection.nodes.find(
+        (n) => n.dataAttributes["data-agent-native-node-id"] === destNodeAttrId,
+      );
+      if (movedNodeFinal) {
+        setSelectedLayerIdsState([movedNodeFinal.id]);
+        setSelectedElement(elementInfoFromCodeLayerNode(movedNodeFinal));
+      }
+    },
+    [applyFileContentUpdate, canEditDesign, getScreenContent, t],
+  );
+
+  const handleCutSelection = useCallback(async () => {
+    if (!selectedElement?.selector) return;
+    // Copy first (populates the internal clipboard ref even if the async
+    // navigator.clipboard write is blocked — handleCopySelection swallows that
+    // error) then remove the element so a subsequent paste can re-insert it.
+    await handleCopySelection();
+    handleDeleteSelection();
+  }, [handleCopySelection, handleDeleteSelection, selectedElement]);
+
+  const handleDeleteOverviewSelection = useCallback(
+    (selectedIds: string[]) => {
+      if (!canEditDesign) return false;
+      if (!selectedIds.length || files.length <= 1) return false;
+
+      const selectedIdSet = new Set(selectedIds);
+      const selectedFiles = files.filter((file) => selectedIdSet.has(file.id));
+      if (!selectedFiles.length) return false;
 
       const maxDeleteCount =
         selectedFiles.length >= files.length
@@ -6737,8 +8512,7 @@ export default function DesignEditor() {
       textAlign: selectedElement.computedStyles.textAlign,
     };
     setHasPropsClipboard(true);
-    toast.success(t("designEditor.toasts.propsCopied"));
-  }, [selectedElement, t]);
+  }, [selectedElement]);
 
   const handlePasteProps = useCallback(() => {
     if (!canEditDesign) return;
@@ -6749,8 +8523,7 @@ export default function DesignEditor() {
       ),
     );
     commitVisualStyles(selectedElement.selector, styles);
-    toast.success(t("designEditor.toasts.propsPasted"));
-  }, [canEditDesign, commitVisualStyles, selectedElement, t]);
+  }, [canEditDesign, commitVisualStyles, selectedElement]);
 
   const changeSelectedZIndex = useCallback(
     (mode: "forward" | "front" | "backward" | "back") => {
@@ -6810,31 +8583,67 @@ export default function DesignEditor() {
     if (!canEditDesign) return;
     const um = undoManagerRef.current;
     const undoContent = () => {
-      if (!um || !um.canUndo()) return false;
-      um.undo();
-      if (ydoc && activeFile) {
-        const next = ydoc.getText("content").toString();
-        lastLocalContentRef.current = next;
-        queueFileContentSave(activeFile.id, next, {
-          syncCollab: !(ydoc && isSynced),
-        });
-        if (!replacePreviewContent(next)) {
-          setContentRenderRevision((revision) => revision + 1);
+      if (um?.canUndo()) {
+        um.undo();
+        if (ydoc && activeFile) {
+          const next = ydoc.getText("content").toString();
+          markPendingLocalFileContent(
+            activeFile.id,
+            next,
+            activeFile.updatedAt,
+          );
+          lastLocalContentRef.current = next;
+          queueFileContentSave(activeFile.id, next, {
+            syncCollab: !(ydoc && isSynced),
+          });
+          if (!replacePreviewContent(next)) {
+            setContentRenderRevision((revision) => revision + 1);
+          }
+          // Clear stale selection if the undo removed the selected element.
+          setSelectedElement((prev) => {
+            if (!prev) return prev;
+            return elementInfoExistsInContent(next, prev) ? prev : null;
+          });
+          setHoveredElement((prev) => {
+            if (!prev) return prev;
+            return elementInfoExistsInContent(next, prev) ? prev : null;
+          });
         }
-        // Clear stale selection if the undo removed the selected element.
-        setSelectedElement((prev) => {
-          if (!prev) return prev;
-          return elementInfoExistsInContent(next, prev) ? prev : null;
-        });
-        setHoveredElement((prev) => {
-          if (!prev) return prev;
-          return elementInfoExistsInContent(next, prev) ? prev : null;
-        });
+        redoOrderRef.current = [
+          ...redoOrderRef.current.slice(-(MAX_DESIGN_UNDO_STACK - 1)),
+          "content",
+        ];
+        return true;
       }
+
+      if (!activeFile) return false;
+      const entry = contentUndoStackRef.current.pop();
+      if (!entry || entry.fileId !== activeFile.id) return false;
+      contentRedoStackRef.current = [
+        ...contentRedoStackRef.current.slice(-(MAX_DESIGN_UNDO_STACK - 1)),
+        entry,
+      ];
       redoOrderRef.current = [
         ...redoOrderRef.current.slice(-(MAX_DESIGN_UNDO_STACK - 1)),
         "content",
       ];
+      suppressContentHistoryRef.current = true;
+      try {
+        applyLocalContentUpdate(entry.before, {
+          refreshPreview: false,
+          immediateSave: true,
+        });
+      } finally {
+        suppressContentHistoryRef.current = false;
+      }
+      setSelectedElement((prev) => {
+        if (!prev) return prev;
+        return elementInfoExistsInContent(entry.before, prev) ? prev : null;
+      });
+      setHoveredElement((prev) => {
+        if (!prev) return prev;
+        return elementInfoExistsInContent(entry.before, prev) ? prev : null;
+      });
       return true;
     };
     const undoGeometry = () => {
@@ -6870,8 +8679,10 @@ export default function DesignEditor() {
   }, [
     ydoc,
     activeFile,
+    applyLocalContentUpdate,
     canEditDesign,
     isSynced,
+    markPendingLocalFileContent,
     queueFileContentSave,
     replacePreviewContent,
     syncUndoRedoState,
@@ -6882,31 +8693,67 @@ export default function DesignEditor() {
     if (!canEditDesign) return;
     const um = undoManagerRef.current;
     const redoContent = () => {
-      if (!um || !um.canRedo()) return false;
-      um.redo();
-      if (ydoc && activeFile) {
-        const next = ydoc.getText("content").toString();
-        lastLocalContentRef.current = next;
-        queueFileContentSave(activeFile.id, next, {
-          syncCollab: !(ydoc && isSynced),
-        });
-        if (!replacePreviewContent(next)) {
-          setContentRenderRevision((revision) => revision + 1);
+      if (um?.canRedo()) {
+        um.redo();
+        if (ydoc && activeFile) {
+          const next = ydoc.getText("content").toString();
+          markPendingLocalFileContent(
+            activeFile.id,
+            next,
+            activeFile.updatedAt,
+          );
+          lastLocalContentRef.current = next;
+          queueFileContentSave(activeFile.id, next, {
+            syncCollab: !(ydoc && isSynced),
+          });
+          if (!replacePreviewContent(next)) {
+            setContentRenderRevision((revision) => revision + 1);
+          }
+          // Clear stale selection if the redo removed the selected element.
+          setSelectedElement((prev) => {
+            if (!prev) return prev;
+            return elementInfoExistsInContent(next, prev) ? prev : null;
+          });
+          setHoveredElement((prev) => {
+            if (!prev) return prev;
+            return elementInfoExistsInContent(next, prev) ? prev : null;
+          });
         }
-        // Clear stale selection if the redo removed the selected element.
-        setSelectedElement((prev) => {
-          if (!prev) return prev;
-          return elementInfoExistsInContent(next, prev) ? prev : null;
-        });
-        setHoveredElement((prev) => {
-          if (!prev) return prev;
-          return elementInfoExistsInContent(next, prev) ? prev : null;
-        });
+        historyOrderRef.current = [
+          ...historyOrderRef.current.slice(-(MAX_DESIGN_UNDO_STACK - 1)),
+          "content",
+        ];
+        return true;
       }
+
+      if (!activeFile) return false;
+      const entry = contentRedoStackRef.current.pop();
+      if (!entry || entry.fileId !== activeFile.id) return false;
+      contentUndoStackRef.current = [
+        ...contentUndoStackRef.current.slice(-(MAX_DESIGN_UNDO_STACK - 1)),
+        entry,
+      ];
       historyOrderRef.current = [
         ...historyOrderRef.current.slice(-(MAX_DESIGN_UNDO_STACK - 1)),
         "content",
       ];
+      suppressContentHistoryRef.current = true;
+      try {
+        applyLocalContentUpdate(entry.after, {
+          refreshPreview: false,
+          immediateSave: true,
+        });
+      } finally {
+        suppressContentHistoryRef.current = false;
+      }
+      setSelectedElement((prev) => {
+        if (!prev) return prev;
+        return elementInfoExistsInContent(entry.after, prev) ? prev : null;
+      });
+      setHoveredElement((prev) => {
+        if (!prev) return prev;
+        return elementInfoExistsInContent(entry.after, prev) ? prev : null;
+      });
       return true;
     };
     const redoGeometry = () => {
@@ -6942,8 +8789,10 @@ export default function DesignEditor() {
   }, [
     ydoc,
     activeFile,
+    applyLocalContentUpdate,
     canEditDesign,
     isSynced,
+    markPendingLocalFileContent,
     queueFileContentSave,
     replacePreviewContent,
     syncUndoRedoState,
@@ -7382,6 +9231,8 @@ export default function DesignEditor() {
       setTitleDraft(design?.title ?? "");
       setTitleEditing(true);
     },
+    onGroup: canEditDesign ? handleGroupSelection : undefined,
+    onUngroup: canEditDesign ? handleUngroupSelection : undefined,
     onSelectAll: handleSelectAllFrames,
     onUndo: canEditDesign ? handleUndo : undefined,
     onRedo: canEditDesign ? handleRedo : undefined,
@@ -8234,14 +10085,29 @@ ${serializedHtml}
         )
         .map((node) => node.id),
     );
+    const allLayerIds = new Set([
+      ...fileIds,
+      ...allCodeLayerNodes.map((node) => node.id),
+    ]);
     const reconcile = (
       current: Set<string>,
       sourceIds: Set<string>,
+      kind: "hidden" | "locked",
     ): Set<string> => {
       const next = new Set(sourceIds);
       current.forEach((id) => {
         if (fileIds.has(id)) next.add(id);
       });
+      layerStateOverridesRef.current.forEach((override, id) => {
+        if (!allLayerIds.has(id)) {
+          layerStateOverridesRef.current.delete(id);
+          return;
+        }
+        const value = override[kind];
+        if (value === undefined) return;
+        if (value) next.add(id);
+        else next.delete(id);
+      });
       if (
         next.size === current.size &&
         Array.from(next).every((id) => current.has(id))
@@ -8251,8 +10117,12 @@ ${serializedHtml}
       return next;
     };
 
-    setLockedLayerIds((current) => reconcile(current, lockedFromSource));
-    setHiddenLayerIds((current) => reconcile(current, hiddenFromSource));
+    setLockedLayerIds((current) =>
+      reconcile(current, lockedFromSource, "locked"),
+    );
+    setHiddenLayerIds((current) =>
+      reconcile(current, hiddenFromSource, "hidden"),
+    );
   }, [codeLayerModelsByFile, files]);
   const lockedLayerSelectors = useMemo(() => {
     const selectors = Array.from(lockedLayerIds)
@@ -8458,6 +10328,59 @@ ${serializedHtml}
     );
   }, [activeContent, activeFile?.id, builderPreviewUrl, overviewScreens]);
 
+  // §6.4 / §8 — Breakpoints list for the StatesPanel, derived from
+  // designs.data.breakpointSet. Returns a stable empty array when none are set.
+  const statesPanelBreakpoints = useMemo<
+    Array<{ id: string; label: string; widthPx: number }>
+  >(() => {
+    try {
+      const raw = (designDataJson as Record<string, unknown>)?.breakpointSet;
+      if (
+        raw &&
+        typeof raw === "object" &&
+        !Array.isArray(raw) &&
+        Array.isArray((raw as Record<string, unknown>).breakpoints)
+      ) {
+        const bps = (
+          raw as {
+            breakpoints: Array<{
+              id: string;
+              widthPx: number;
+              label?: string;
+            }>;
+          }
+        ).breakpoints;
+        return bps.map((bp) => ({
+          id: bp.id,
+          widthPx: bp.widthPx,
+          label:
+            bp.label ??
+            (bp.widthPx >= 1024
+              ? "Desktop"
+              : bp.widthPx >= 600
+                ? "Tablet"
+                : "Mobile"),
+        }));
+      }
+    } catch {
+      // ignore
+    }
+    return [];
+  }, [designDataJson]);
+
+  // Active breakpoint id for the StatesPanel — "auto" when no frame is focused.
+  const statesPanelActiveBreakpointId = useMemo<string>(() => {
+    if (activeBreakpointWidthState == null) return "auto";
+    const match = statesPanelBreakpoints.find(
+      (bp) => bp.widthPx === activeBreakpointWidthState,
+    );
+    if (match) return match.id;
+    const defaultMatch = DEFAULT_STATES_PANEL_BREAKPOINTS.find(
+      (bp) => bp.widthPx === activeBreakpointWidthState,
+    );
+    return defaultMatch?.id ?? "auto";
+  }, [activeBreakpointWidthState, statesPanelBreakpoints]);
+
   const handleOpenDesignPreview = useCallback(() => {
     if (activeScreenPreviewUrl) {
       window.open(activeScreenPreviewUrl, "_blank", "noopener,noreferrer");
@@ -8479,6 +10402,16 @@ ${serializedHtml}
     selectedElementLayerId ??
     activeFile?.id ??
     "";
+  const selectedElementFullViewScreenId =
+    viewMode === "overview" && selectedElement
+      ? selectedElementLayerId
+        ? (codeLayerOwnerByNodeId.get(selectedElementLayerId)?.fileId ??
+          activeFileId)
+        : activeFileId
+      : null;
+  const fullViewScreenIds = selectedElementFullViewScreenId
+    ? [selectedElementFullViewScreenId]
+    : [];
   const activeLayerLocked = Boolean(
     activeLayerId && effectiveCodeLayerState.lockedIds.has(activeLayerId),
   );
@@ -8486,6 +10419,35 @@ ${serializedHtml}
     activeLayerId && effectiveCodeLayerState.hiddenIds.has(activeLayerId),
   );
 
+  // Detect if the active screen is a localhost/local source so we can show a banner.
+  const activeScreenIsLocalSource =
+    viewMode === "single" &&
+    Boolean(activeFile) &&
+    activeOverviewScreen?.sourceType === "localhost";
+  const activeScreenRouteSourceFile = activeScreenIsLocalSource
+    ? getLocalhostRouteSourceFile({
+        sourceFile: activeOverviewScreen?.sourceFile,
+        source: activeOverviewScreen?.source,
+      })
+    : undefined;
+
+  // canGroup: 2+ DOM-node layers selected in the active screen (not file rows).
+  const fileIdSet = new Set(files.map((f) => f.id));
+  const selectedDomLayerIds = selectedLayerIds.filter(
+    (id) => !id.startsWith("__") && !fileIdSet.has(id),
+  );
+  const canGroup =
+    canEditDesign &&
+    viewMode === "single" &&
+    Boolean(activeFile) &&
+    selectedDomLayerIds.length >= 2;
+  // canUngroup: exactly one DOM-node layer selected.
+  const canUngroup =
+    canEditDesign &&
+    viewMode === "single" &&
+    Boolean(activeFile) &&
+    selectedDomLayerIds.length === 1;
+
   const canMoveLayer = useCallback(
     (intent: LayersPanelMoveIntent) => {
       const targetOwner = codeLayerOwnerByNodeId.get(intent.targetId);
@@ -8498,17 +10460,24 @@ ${serializedHtml}
       }
       return intent.draggedIds.some((draggedId) => {
         const draggedOwner = codeLayerOwnerByNodeId.get(draggedId);
-        return (
-          draggedId !== intent.targetId &&
-          !!draggedOwner &&
-          draggedOwner.fileId === targetOwner.fileId &&
-          !collectCodeLayerAncestors(
+        if (
+          draggedId === intent.targetId ||
+          !draggedOwner ||
+          effectiveCodeLayerState.lockedIds.has(draggedId) ||
+          effectiveCodeLayerState.hiddenIds.has(draggedId)
+        ) {
+          return false;
+        }
+        // Same-file move: also exclude ancestor drags (would orphan the node).
+        if (draggedOwner.fileId === targetOwner.fileId) {
+          return !collectCodeLayerAncestors(
             targetOwner.tree,
             intent.targetId,
-          ).includes(draggedId) &&
-          !effectiveCodeLayerState.lockedIds.has(draggedId) &&
-          !effectiveCodeLayerState.hiddenIds.has(draggedId)
-        );
+          ).includes(draggedId);
+        }
+        // Cross-file move: allowed as long as neither side is locked/hidden
+        // (already checked above). File-row ids are excluded by the owner check.
+        return true;
       });
     },
     [codeLayerOwnerByNodeId, effectiveCodeLayerState],
@@ -8526,26 +10495,62 @@ ${serializedHtml}
       ) {
         return;
       }
-      const sourceFile = files.find((file) => file.id === targetOwner.fileId);
-      const sourceContent =
+      const freshActiveContent = getFreshActiveContent();
+      const destFile = files.find((file) => file.id === targetOwner.fileId);
+      const destContent =
         targetOwner.fileId === activeFile?.id
-          ? activeContent
-          : (sourceFile?.content ?? "");
-      if (!sourceContent) return;
-      let nextContent = sourceContent;
-      let moved = false;
+          ? freshActiveContent
+          : (destFile?.content ?? "");
+      if (!destContent) return;
+
+      // Group dragged ids by source file so we can handle same-file and
+      // cross-file moves independently.
+      const sameFileDragIds: string[] = [];
+      const crossFileDrags: Array<{ draggedId: string; sourceFileId: string }> =
+        [];
+      const movedNodeSnapshots = new Map<string, CodeLayerNode>();
       for (const draggedId of intent.draggedIds) {
         const draggedOwner = codeLayerOwnerByNodeId.get(draggedId);
         if (
           draggedId === intent.targetId ||
           !draggedOwner ||
-          draggedOwner.fileId !== targetOwner.fileId ||
           effectiveCodeLayerState.lockedIds.has(draggedId) ||
           effectiveCodeLayerState.hiddenIds.has(draggedId)
         ) {
           continue;
         }
-        const patch = applyVisualEdit(nextContent, {
+        movedNodeSnapshots.set(draggedId, draggedOwner.node);
+        if (draggedOwner.fileId === targetOwner.fileId) {
+          sameFileDragIds.push(draggedId);
+        } else {
+          crossFileDrags.push({
+            draggedId,
+            sourceFileId: draggedOwner.fileId,
+          });
+        }
+      }
+
+      const targetTreeForMove =
+        targetOwner.fileId === activeFile?.id
+          ? buildCodeLayerTree(buildCodeLayerProjection(freshActiveContent))
+          : targetOwner.tree;
+      const orderedSameFileDragIds = sortCodeLayerIdsByTreeOrder(
+        sameFileDragIds,
+        targetTreeForMove,
+      );
+      const movedIdOrder = [
+        ...orderedSameFileDragIds,
+        ...crossFileDrags.map((drag) => drag.draggedId),
+      ];
+
+      // --- Same-file moves (existing path) ---
+      let nextDestContent = destContent;
+      let moved = false;
+      for (const draggedId of getLayerMoveIterationOrder(
+        orderedSameFileDragIds,
+        intent.placement,
+      )) {
+        const patch = applyVisualEdit(nextDestContent, {
           kind: "moveNode",
           target: { nodeId: draggedId },
           anchor: { nodeId: intent.targetId },
@@ -8561,23 +10566,119 @@ ${serializedHtml}
           );
           continue;
         }
-        nextContent = patch.content;
+        nextDestContent = patch.content;
         moved = true;
       }
-      if (!moved || nextContent === sourceContent) return;
-      applyFileContentUpdate(targetOwner.fileId, nextContent, {
-        refreshPreview: true,
-      });
+
+      // --- Cross-file moves: use moveNodeBetweenDocuments ---
+      // Group by source file so multiple nodes from the same source are
+      // applied sequentially against the running source content.
+      const sourceContentMap = new Map<string, string>();
+      for (const { draggedId, sourceFileId } of crossFileDrags) {
+        const srcFile = files.find((f) => f.id === sourceFileId);
+        if (!srcFile) continue;
+        const currentSourceContent = getLayerMoveSourceContent({
+          sourceFileId,
+          activeFileId: activeFile?.id,
+          activeContent: freshActiveContent,
+          sourceFileContent: srcFile.content,
+          sourceContentMap,
+        });
+
+        // The dragged node's data-agent-native-node-id is the node id tracked
+        // by code-layer. Look up the actual attribute value from the owner.
+        const draggedOwner = codeLayerOwnerByNodeId.get(draggedId);
+        const nodeAttrId =
+          draggedOwner?.node.dataAttributes["data-agent-native-node-id"] ??
+          draggedId;
+        const anchorAttrId =
+          codeLayerOwnerByNodeId.get(intent.targetId)?.node.dataAttributes[
+            "data-agent-native-node-id"
+          ] ?? intent.targetId;
+
+        const result = moveNodeBetweenDocuments(
+          currentSourceContent,
+          nextDestContent,
+          {
+            nodeId: nodeAttrId,
+            anchorNodeId: anchorAttrId,
+            placement: intent.placement,
+          },
+        );
+        if (result.status !== "applied") {
+          toast.error(
+            codeLayerPatchMessage(
+              result.message,
+              t("designEditor.toasts.layerMoveFailed"),
+            ),
+            { duration: 4000 },
+          );
+          continue;
+        }
+        sourceContentMap.set(sourceFileId, result.sourceHtml);
+        nextDestContent = result.destHtml;
+        moved = true;
+      }
+
+      if (!moved) return;
+
+      const finalDestProjection =
+        nextDestContent !== destContent
+          ? buildCodeLayerProjection(nextDestContent)
+          : null;
+      const finalDestTree = finalDestProjection
+        ? buildCodeLayerTree(finalDestProjection)
+        : [];
+      const movedNodesAfterMove = movedIdOrder
+        .map((draggedId) => movedNodeSnapshots.get(draggedId))
+        .map((node) =>
+          node && finalDestProjection
+            ? findCodeLayerNodeInProjection(finalDestProjection, node)
+            : null,
+        )
+        .filter((node): node is CodeLayerNode => Boolean(node));
+
+      if (movedNodesAfterMove.length > 0) {
+        setSelectedLayerIdsState(movedNodesAfterMove.map((node) => node.id));
+        const lastMovedNode =
+          movedNodesAfterMove[movedNodesAfterMove.length - 1];
+        if (lastMovedNode && targetOwner.fileId === activeFile?.id) {
+          setSelectedElement(elementInfoFromCodeLayerNode(lastMovedNode));
+        }
+        const movedAncestorIds = movedNodesAfterMove.flatMap((node) =>
+          collectCodeLayerAncestors(finalDestTree, node.id),
+        );
+        setExpandedLayerIds((current) => {
+          const next = new Set(current);
+          next.add(targetOwner.fileId);
+          movedAncestorIds.forEach((ancestorId) => next.add(ancestorId));
+          return next.size === current.length ? current : Array.from(next);
+        });
+      }
+
+      // Persist source files that changed.
+      for (const [sourceFileId, newSourceContent] of sourceContentMap) {
+        applyFileContentUpdate(sourceFileId, newSourceContent, {
+          refreshPreview: false,
+        });
+      }
+
+      // Persist dest file (which may also be the active file).
+      if (nextDestContent !== destContent) {
+        applyFileContentUpdate(targetOwner.fileId, nextDestContent, {
+          refreshPreview: false,
+        });
+      }
     },
     [
-      activeContent,
       activeFile?.id,
       applyFileContentUpdate,
       canEditDesign,
       canMoveLayer,
       codeLayerOwnerByNodeId,
-      files,
       effectiveCodeLayerState,
+      files,
+      getFreshActiveContent,
       t,
     ],
   );
@@ -8616,6 +10717,21 @@ ${serializedHtml}
           ? currentLayerIds.filter((layerId) => layerId !== intent.id)
           : [...currentLayerIds, intent.id];
         setSelectedLayerIdsState(additiveLayerIds);
+        if (viewModeRef.current === "overview") {
+          const fileIds = files.map((file) => file.id);
+          const selectedScreenIds = getOverviewScreenIdsFromLayerSelection({
+            fileIds,
+            layerIds: additiveLayerIds,
+          });
+          const toggledScreen =
+            getOverviewScreenIdsFromLayerSelection({
+              fileIds,
+              layerIds: [intent.id],
+            }).length > 0;
+          if (toggledScreen || selectedScreenIds.length > 0) {
+            setOverviewSelectedScreenIds(selectedScreenIds);
+          }
+        }
         setSelectedElement(null);
         focusDesignInspectorForSelection();
         setActiveTool("move");
@@ -8712,7 +10828,7 @@ ${serializedHtml}
       const sourceFile = files.find((file) => file.id === owner.fileId);
       const sourceContent =
         owner.fileId === activeFile?.id
-          ? activeContent
+          ? getFreshActiveContent()
           : (sourceFile?.content ?? "");
       if (!sourceContent) return;
       const nextContent = setCodeLayerAttributeInHtml(
@@ -8728,12 +10844,12 @@ ${serializedHtml}
       setSelectedLayerIdsState([layerId]);
     },
     [
-      activeContent,
       activeFile?.id,
       applyFileContentUpdate,
       canEditDesign,
       codeLayerOwnerByNodeId,
       files,
+      getFreshActiveContent,
       queryClient,
       t,
       updateFileMutation,
@@ -8743,6 +10859,10 @@ ${serializedHtml}
   const handleToggleLayerLocked = useCallback(
     (layerId: string, locked: boolean) => {
       if (!canEditDesign) return;
+      layerStateOverridesRef.current.set(layerId, {
+        ...layerStateOverridesRef.current.get(layerId),
+        locked,
+      });
       const applyLockedState = () => {
         setLockedLayerIds((current) => {
           const next = new Set(current);
@@ -8757,38 +10877,47 @@ ${serializedHtml}
       }
       const owner = codeLayerOwnerByNodeId.get(layerId);
       const node = owner?.node;
-      if (!owner || !node) return;
+      if (!owner || !node) {
+        applyLockedState();
+        return;
+      }
       const sourceFile = files.find((file) => file.id === owner.fileId);
       const sourceContent =
         owner.fileId === activeFile?.id
-          ? activeContent
+          ? getFreshActiveContent()
           : (sourceFile?.content ?? "");
-      if (!sourceContent) return;
-      const nextContent = setCodeLayerAttributeInHtml(
-        sourceContent,
-        node,
-        "data-agent-native-locked",
-        locked ? "true" : null,
-      );
-      if (!nextContent || nextContent === sourceContent) return;
-      applyFileContentUpdate(owner.fileId, nextContent, {
-        refreshPreview: false,
-      });
+      if (sourceContent) {
+        const nextContent = setCodeLayerAttributeInHtml(
+          sourceContent,
+          node,
+          "data-agent-native-locked",
+          locked ? "true" : null,
+        );
+        if (nextContent && nextContent !== sourceContent) {
+          applyFileContentUpdate(owner.fileId, nextContent, {
+            refreshPreview: false,
+          });
+        }
+      }
       applyLockedState();
     },
     [
-      activeContent,
       activeFile?.id,
       applyFileContentUpdate,
       canEditDesign,
       codeLayerOwnerByNodeId,
       files,
+      getFreshActiveContent,
     ],
   );
 
   const handleToggleLayerHidden = useCallback(
     (layerId: string, hidden: boolean) => {
       if (!canEditDesign) return;
+      layerStateOverridesRef.current.set(layerId, {
+        ...layerStateOverridesRef.current.get(layerId),
+        hidden,
+      });
       const applyHiddenState = () => {
         setHiddenLayerIds((current) => {
           const next = new Set(current);
@@ -8803,32 +10932,37 @@ ${serializedHtml}
       }
       const owner = codeLayerOwnerByNodeId.get(layerId);
       const node = owner?.node;
-      if (!owner || !node) return;
+      if (!owner || !node) {
+        applyHiddenState();
+        return;
+      }
       const sourceFile = files.find((file) => file.id === owner.fileId);
       const sourceContent =
         owner.fileId === activeFile?.id
-          ? activeContent
+          ? getFreshActiveContent()
           : (sourceFile?.content ?? "");
-      if (!sourceContent) return;
-      const nextContent = setCodeLayerAttributeInHtml(
-        sourceContent,
-        node,
-        "data-agent-native-hidden",
-        hidden ? "true" : null,
-      );
-      if (!nextContent || nextContent === sourceContent) return;
-      applyFileContentUpdate(owner.fileId, nextContent, {
-        refreshPreview: false,
-      });
+      if (sourceContent) {
+        const nextContent = setCodeLayerAttributeInHtml(
+          sourceContent,
+          node,
+          "data-agent-native-hidden",
+          hidden ? "true" : null,
+        );
+        if (nextContent && nextContent !== sourceContent) {
+          applyFileContentUpdate(owner.fileId, nextContent, {
+            refreshPreview: false,
+          });
+        }
+      }
       applyHiddenState();
     },
     [
-      activeContent,
       activeFile?.id,
       applyFileContentUpdate,
       canEditDesign,
       codeLayerOwnerByNodeId,
       files,
+      getFreshActiveContent,
     ],
   );
 
@@ -9096,6 +11230,19 @@ ${serializedHtml}
             ? t("designEditor.stopPinningComments")
             : t("designEditor.pinComment")}
         </DropdownMenuItem>
+        {isSignedIn && (
+          <>
+            <DropdownMenuSeparator />
+            <DropdownMenuItem
+              onClick={() => {
+                handleOpenMakeReal();
+              }}
+            >
+              <IconRocket className="mr-2 h-4 w-4" />
+              {"Make this a real app" /* i18n-ignore */}
+            </DropdownMenuItem>
+          </>
+        )}
       </DropdownMenuContent>
     </DropdownMenu>
   );
@@ -9254,6 +11401,28 @@ ${serializedHtml}
             <TooltipContent>{t("designEditor.designPreview")}</TooltipContent>
           </Tooltip>
 
+          {/* §6.6 — "Make this a real app" shortcut button (signed-in only).
+              Surfaces the migration CTA without requiring the project menu. */}
+          {isSignedIn && (
+            <Tooltip>
+              <TooltipTrigger asChild>
+                <Button
+                  variant="ghost"
+                  size="icon"
+                  className="size-8 cursor-pointer rounded-md text-muted-foreground hover:bg-accent hover:text-foreground"
+                  onClick={handleOpenMakeReal}
+                  disabled={migrateMutation.isPending}
+                  aria-label={"Make this a real app" /* i18n-ignore */}
+                >
+                  <IconRocket className="size-4" />
+                </Button>
+              </TooltipTrigger>
+              <TooltipContent>
+                {"Make this a real app" /* i18n-ignore */}
+              </TooltipContent>
+            </Tooltip>
+          )}
+
           {isSignedIn ? (
             <ShareButton
               resourceType="design"
@@ -9447,6 +11616,19 @@ ${serializedHtml}
                   ? t("designEditor.stopPinningComments")
                   : t("designEditor.pinComment")}
               </DropdownMenuItem>
+              {isSignedIn && (
+                <>
+                  <DropdownMenuSeparator />
+                  <DropdownMenuItem
+                    onClick={() => {
+                      handleOpenMakeReal();
+                    }}
+                  >
+                    <IconRocket className="mr-2 h-4 w-4" />
+                    {"Make this a real app" /* i18n-ignore */}
+                  </DropdownMenuItem>
+                </>
+              )}
             </DropdownMenuContent>
           </DropdownMenu>
           {titleEditing && canEditDesign ? (
@@ -9786,7 +11968,9 @@ ${serializedHtml}
               canEditDesign && hasPropsClipboard && Boolean(selectedElement)
             }
             canCopyAsCode={Boolean(selectedElement?.selector)}
-            hiddenActions={["group", "ungroup", "rename"]}
+            canGroup={canGroup}
+            canUngroup={canUngroup}
+            hiddenActions={["rename"]}
             getCanvasPoint={getContextCanvasPoint}
             onPasteHere={(details) =>
               handlePasteSelection(
@@ -9818,310 +12002,393 @@ ${serializedHtml}
                 handleToggleLayerHidden(activeLayerId, !activeLayerHidden);
               }
             }}
+            onGroup={canGroup ? handleGroupSelection : undefined}
+            onUngroup={canUngroup ? handleUngroupSelection : undefined}
             onCopyProps={handleCopyProps}
             onPasteProps={handlePasteProps}
             onCopyAsCode={handleCopySelection}
           >
             {activeFile ? (
-              <div
-                ref={canvasContainerRef}
-                className="relative mx-1 h-full min-w-0 flex-1 overflow-hidden rounded-xl bg-[var(--design-editor-canvas-bg)]"
-                onPointerMove={handleCanvasPointerMove}
-              >
-                {/* Transparent shield that blocks pointer events reaching the
+              <div className="flex min-w-0 flex-1 flex-col overflow-hidden">
+                {/* Banner for screens connected to a local dev server: edits
+                    route through the agent rather than being applied inline. */}
+                {activeScreenIsLocalSource &&
+                  !localSourceBannerDismissed &&
+                  id && (
+                    <LocalSourceEditBanner
+                      designId={id}
+                      fileId={activeFile.id}
+                      routeSourceFile={activeScreenRouteSourceFile}
+                      onDismiss={() => setLocalSourceBannerDismissed(true)}
+                    />
+                  )}
+                <div
+                  ref={canvasContainerRef}
+                  className="relative mx-1 min-w-0 flex-1 overflow-hidden rounded-xl bg-[var(--design-editor-canvas-bg)]"
+                  onPointerMove={handleCanvasPointerMove}
+                >
+                  {/* Transparent shield that blocks pointer events reaching the
                     iframe when a portaled Radix popover (e.g. color picker) is
                     open. The iframe has its own event context so it receives
                     pointer events even when visually covered by the popover. */}
-                {inspectorPopoverOpen && (
-                  <div
-                    aria-hidden="true"
-                    style={{
-                      position: "absolute",
-                      inset: 0,
-                      zIndex: 10,
-                      pointerEvents: "auto",
-                    }}
-                  />
-                )}
-                {viewMode === "overview" ? (
-                  <MultiScreenCanvas
-                    screens={overviewScreens}
-                    zoom={overviewCanvasZoom}
-                    onZoomChange={setOverviewCanvasZoom}
-                    activeId={activeFileId}
-                    selectedScreenIds={overviewSelectedScreenIds}
-                    activeScreenHasHoveredChild={
-                      Boolean(hoveredElement) &&
-                      !hoveredElementIsScreenRoot &&
-                      hoveredElementScreenId === activeFileId
-                    }
-                    hoveredChildScreenId={hoveredChildScreenId}
-                    directlyHoveredScreenId={hoveredScreenRootId}
-                    previewDeviceFrame={deviceFrame}
-                    activeTool={activeTool}
-                    onActiveToolChange={(tool) =>
-                      setActiveTool(tool === "rectangle" ? "rect" : tool)
-                    }
-                    selectAllRequest={overviewSelectAllRequest}
-                    clearSelectionRequest={overviewClearSelectionRequest}
-                    onScreenSelectionChange={
-                      handleOverviewScreenSelectionChange
-                    }
-                    geometryById={canvasFrameGeometryById}
-                    onGeometryChange={queueFrameGeometrySave}
-                    onGeometryCommit={handleGeometryCommit}
-                    onCreatePrimitive={handleCreatePrimitive}
-                    onPrimitiveCreated={handlePrimitiveCreated}
-                    onCreateScreenFrame={handleCreateScreenFrame}
-                    onDeleteSelection={handleDeleteOverviewSelection}
-                    onSelectionChange={setOverviewSelectedScreenIds}
-                    onPick={(id) => {
-                      pendingOverviewScreenSelectionRef.current = null;
-                      setSelectedElement(null);
-                      setHoveredElement(null);
-                      setSelectedLayerIdsState([id]);
-                      setActiveFileId(id);
-                      setActiveTool("move");
-                      setMode("edit");
-                    }}
-                    onEdit={enterSingleScreen}
-                    onDuplicate={handleDuplicateScreen}
-                    renderScreenContent={(screen, metadata, geometry) => {
-                      const screenIsActive = screen.id === activeFile?.id;
-                      const screenContent = getScreenContent(screen.id);
-                      const screenContentKey = [
-                        screen.id,
-                        screen.updatedAt ?? "",
-                        getContentSignature(screenContent),
-                        screenIsActive ? contentRenderRevision : 0,
-                      ].join(":");
-
-                      return (
-                        <DesignCanvas
-                          content={screenContent}
-                          contentKey={screenContentKey}
-                          zoom={100}
-                          deviceFrame="none"
-                          embeddedFrame={{
-                            viewportWidth: Math.max(
-                              1,
-                              Math.round(geometry.width),
-                            ),
-                            viewportHeight: Math.max(
-                              1,
-                              Math.round(geometry.height),
-                            ),
-                            displayWidth: Math.max(
-                              1,
-                              Math.round(geometry.width),
-                            ),
-                            displayHeight: Math.max(
-                              1,
-                              Math.round(geometry.height),
-                            ),
-                            fluid: true,
-                          }}
-                          editorChromeScaleX={overviewCanvasZoom / 100}
-                          editorChromeScaleY={overviewCanvasZoom / 100}
-                          editMode={mode === "edit"}
-                          interactMode={false}
-                          readOnly={!canEditDesign}
-                          scaleMode={screenIsActive && activeTool === "scale"}
-                          clearSelectionRequest={overviewClearSelectionRequest}
-                          registerRuntimeBridge={screenIsActive}
-                          selectedSelector={
-                            screenIsActive ? selectedCanvasSelector : null
-                          }
-                          selectedSelectorCandidates={
-                            screenIsActive
-                              ? selectedCanvasSelectorCandidates
-                              : []
-                          }
-                          hoveredSelector={
-                            hoveredElementScreenId === screen.id
-                              ? hoveredCanvasSelector
-                              : null
-                          }
-                          hoveredSelectorCandidates={
-                            hoveredElementScreenId === screen.id
-                              ? hoveredCanvasSelectorCandidates
-                              : []
-                          }
-                          lockedSelectors={getLayerSelectorsForFile(
-                            screen.id,
-                            lockedLayerIds,
-                          )}
-                          hiddenSelectors={getLayerSelectorsForFile(
-                            screen.id,
-                            hiddenLayerIds,
-                          )}
-                          onElementSelect={(info) =>
-                            handleScreenElementSelect(screen.id, info)
-                          }
-                          onElementHover={(info) =>
-                            handleScreenElementHover(screen.id, info)
-                          }
-                          onClearSelection={() =>
-                            handleScreenElementClear(screen.id)
+                  {inspectorPopoverOpen && (
+                    <div
+                      aria-hidden="true"
+                      style={{
+                        position: "absolute",
+                        inset: 0,
+                        zIndex: 10,
+                        pointerEvents: "auto",
+                      }}
+                    />
+                  )}
+                  {viewMode === "overview" ? (
+                    <MultiScreenCanvas
+                      screens={overviewScreens}
+                      zoom={overviewCanvasZoom}
+                      onZoomChange={setOverviewCanvasZoom}
+                      activeId={activeFileId}
+                      selectedScreenIds={overviewSelectedScreenIds}
+                      fullViewScreenIds={fullViewScreenIds}
+                      activeScreenHasHoveredChild={
+                        Boolean(hoveredElement) &&
+                        !hoveredElementIsScreenRoot &&
+                        hoveredElementScreenId === activeFileId
+                      }
+                      hoveredChildScreenId={hoveredChildScreenId}
+                      directlyHoveredScreenId={hoveredScreenRootId}
+                      previewDeviceFrame={deviceFrame}
+                      activeTool={activeTool}
+                      onActiveToolChange={(tool) =>
+                        setActiveTool(tool === "rectangle" ? "rect" : tool)
+                      }
+                      selectAllRequest={overviewSelectAllRequest}
+                      clearSelectionRequest={overviewClearSelectionRequest}
+                      onScreenSelectionChange={
+                        handleOverviewScreenSelectionChange
+                      }
+                      geometryById={canvasFrameGeometryById}
+                      onGeometryChange={queueFrameGeometrySave}
+                      onGeometryCommit={handleGeometryCommit}
+                      onCreatePrimitive={handleCreatePrimitive}
+                      onPrimitiveCreated={handlePrimitiveCreated}
+                      onPrimitiveReparent={handleOverviewPrimitiveReparent}
+                      onCrossScreenElementDrop={handleCrossScreenElementDrop}
+                      onCreateScreenFrame={handleCreateScreenFrame}
+                      onDeleteSelection={handleDeleteOverviewSelection}
+                      onSelectionChange={setOverviewSelectedScreenIds}
+                      onPick={(id) => {
+                        pendingOverviewScreenSelectionRef.current = null;
+                        setSelectedElement(null);
+                        setHoveredElement(null);
+                        setSelectedLayerIdsState([id]);
+                        setActiveFileId(id);
+                        setActiveTool("move");
+                        setMode("edit");
+                      }}
+                      onEdit={enterSingleScreen}
+                      onDuplicate={handleDuplicateScreen}
+                      onAddBreakpoint={(screenId, widthPx) => {
+                        if (!id) return;
+                        const breakpointLabel =
+                          widthPx <= 480
+                            ? "Mobile"
+                            : widthPx <= 1024
+                              ? "Tablet"
+                              : "Desktop";
+                        void addBreakpointMutation.mutateAsync({
+                          designId: id,
+                          label: breakpointLabel,
+                          widthPx,
+                        });
+                      }}
+                      onActiveBreakpointChange={(_screenId, widthPx) => {
+                        setActiveBreakpointWidthState(widthPx);
+                        if (!id) return;
+                        const bpSet = (() => {
+                          try {
+                            const raw = (
+                              designDataJson as Record<string, unknown>
+                            )?.breakpointSet;
+                            if (
+                              raw &&
+                              typeof raw === "object" &&
+                              Array.isArray(
+                                (raw as Record<string, unknown>).breakpoints,
+                              )
+                            ) {
+                              return raw as {
+                                breakpoints: Array<{
+                                  id: string;
+                                  widthPx: number;
+                                }>;
+                              };
+                            }
+                          } catch {
+                            // Ignore malformed design data; the mutation below
+                            // can still clear back to auto.
                           }
-                          onIframeHotkey={handleIframeHotkey}
-                          onIframeContextMenu={handleIframeContextMenu}
-                          onVisualStyleChange={(selector, styles, info) =>
-                            handleScreenVisualStyleChange(
+                          return null;
+                        })();
+                        const bp = bpSet?.breakpoints.find(
+                          (b) => b.widthPx === widthPx,
+                        );
+                        void setActiveBreakpointMutation.mutateAsync({
+                          designId: id,
+                          breakpointId:
+                            widthPx !== undefined && bp ? bp.id : "auto",
+                        });
+                      }}
+                      renderScreenContent={(screen, metadata, geometry) => {
+                        const screenIsActive = screen.id === activeFile?.id;
+                        const screenContent = getScreenContent(screen.id);
+                        const screenContentKey = screenIsActive
+                          ? [screen.id, contentRenderRevision].join(":")
+                          : [
                               screen.id,
-                              selector,
-                              styles,
-                              info,
-                            )
-                          }
-                          onVisualStructureChange={(
-                            selector,
-                            anchorSelector,
-                            placement,
-                            info,
-                            details,
-                          ) =>
-                            handleScreenVisualStructureChange(
+                              screen.updatedAt ?? "",
+                              getContentSignature(screenContent),
+                              0,
+                            ].join(":");
+
+                        return (
+                          <DesignCanvas
+                            content={screenContent}
+                            contentKey={screenContentKey}
+                            zoom={100}
+                            deviceFrame="none"
+                            sourceType={designSourceType}
+                            fusionUrl={designFusionUrl}
+                            onComponentSourceJump={handleComponentSourceJump}
+                            embeddedFrame={{
+                              viewportWidth: Math.max(
+                                1,
+                                Math.round(geometry.width),
+                              ),
+                              viewportHeight: Math.max(
+                                1,
+                                Math.round(geometry.height),
+                              ),
+                              displayWidth: Math.max(
+                                1,
+                                Math.round(geometry.width),
+                              ),
+                              displayHeight: Math.max(
+                                1,
+                                Math.round(geometry.height),
+                              ),
+                              fluid: true,
+                            }}
+                            editorChromeScaleX={overviewCanvasZoom / 100}
+                            editorChromeScaleY={overviewCanvasZoom / 100}
+                            editMode={mode === "edit"}
+                            interactMode={false}
+                            readOnly={!canEditDesign}
+                            scaleMode={screenIsActive && activeTool === "scale"}
+                            clearSelectionRequest={
+                              overviewClearSelectionRequest
+                            }
+                            registerRuntimeBridge={screenIsActive}
+                            selectedSelector={
+                              screenIsActive ? selectedCanvasSelector : null
+                            }
+                            selectedSelectorCandidates={
+                              screenIsActive
+                                ? selectedCanvasSelectorCandidates
+                                : []
+                            }
+                            hoveredSelector={
+                              hoveredElementScreenId === screen.id
+                                ? hoveredCanvasSelector
+                                : null
+                            }
+                            hoveredSelectorCandidates={
+                              hoveredElementScreenId === screen.id
+                                ? hoveredCanvasSelectorCandidates
+                                : []
+                            }
+                            lockedSelectors={getLayerSelectorsForFile(
                               screen.id,
+                              lockedLayerIds,
+                            )}
+                            hiddenSelectors={getLayerSelectorsForFile(
+                              screen.id,
+                              hiddenLayerIds,
+                            )}
+                            onElementSelect={(info) =>
+                              handleScreenElementSelect(screen.id, info)
+                            }
+                            onElementHover={(info) =>
+                              handleScreenElementHover(screen.id, info)
+                            }
+                            onClearSelection={() =>
+                              handleScreenElementClear(screen.id)
+                            }
+                            onIframeHotkey={handleIframeHotkey}
+                            onIframeContextMenu={handleIframeContextMenu}
+                            onVisualStyleChange={(selector, styles, info) =>
+                              handleScreenVisualStyleChange(
+                                screen.id,
+                                selector,
+                                styles,
+                                info,
+                              )
+                            }
+                            onVisualStructureChange={(
                               selector,
                               anchorSelector,
                               placement,
                               info,
                               details,
-                            )
-                          }
-                          onVisualDuplicateChange={(
-                            selector,
-                            cloneHtml,
-                            info,
-                            details,
-                          ) =>
-                            handleScreenVisualDuplicateChange(
-                              screen.id,
+                            ) =>
+                              handleScreenVisualStructureChange(
+                                screen.id,
+                                selector,
+                                anchorSelector,
+                                placement,
+                                info,
+                                details,
+                              )
+                            }
+                            onVisualDuplicateChange={(
                               selector,
                               cloneHtml,
                               info,
                               details,
-                            )
-                          }
-                          onTextContentChange={(
-                            selector,
-                            value,
-                            info,
-                            details,
-                          ) =>
-                            handleScreenTextContentChange(
-                              screen.id,
+                            ) =>
+                              handleScreenVisualDuplicateChange(
+                                screen.id,
+                                selector,
+                                cloneHtml,
+                                info,
+                                details,
+                              )
+                            }
+                            onTextContentChange={(
                               selector,
                               value,
                               info,
                               details,
-                            )
-                          }
-                          onTextEditingStateChange={setTextEditingState}
-                          onElementDblClickText={(info) =>
-                            handleScreenElementDblClickText(screen.id, info)
-                          }
-                          tweakValues={cssVarValues}
-                          drawMode={false}
-                          pinMode={false}
-                          designId={id}
-                          designTitle={design?.title}
-                          commentContextId={`${id}:${screen.id}`}
-                          commentContextLabel={`${design?.title ?? t("navigation.brand")} / ${prettyScreenName(screen.filename)}`}
-                        />
-                      );
-                    }}
-                  />
-                ) : (
-                  <>
-                    <DesignCanvas
-                      content={activeContent}
-                      contentKey={`${activeFile.id}:${contentRenderRevision}`}
-                      zoom={zoom}
-                      onZoomChange={setZoom}
-                      deviceFrame={deviceFrame}
-                      editMode={mode === "edit"}
-                      interactMode={mode === "interact"}
-                      readOnly={!canEditDesign}
-                      scaleMode={activeTool === "scale"}
-                      clearSelectionRequest={overviewClearSelectionRequest}
-                      selectedSelector={selectedCanvasSelector}
-                      selectedSelectorCandidates={
-                        selectedCanvasSelectorCandidates
-                      }
-                      hoveredSelector={hoveredCanvasSelector}
-                      hoveredSelectorCandidates={
-                        hoveredCanvasSelectorCandidates
-                      }
-                      lockedSelectors={lockedLayerSelectors}
-                      hiddenSelectors={hiddenLayerSelectors}
-                      onElementSelect={handleElementSelect}
-                      onElementHover={handleElementHover}
-                      onClearSelection={() => {
-                        setSelectedElement(null);
-                        setHoveredElement(null);
-                        setHoveredElementScreenId(null);
-                        setSelectedLayerIdsState([]);
-                      }}
-                      onIframeHotkey={handleIframeHotkey}
-                      onIframeContextMenu={handleIframeContextMenu}
-                      onVisualStyleChange={handleVisualStyleChange}
-                      onVisualStructureChange={handleVisualStructureChange}
-                      onVisualDuplicateChange={handleVisualDuplicateChange}
-                      onTextContentChange={handleTextContentChange}
-                      onTextEditingStateChange={setTextEditingState}
-                      onElementDblClickText={handleElementDblClickText}
-                      tweakValues={cssVarValues}
-                      drawMode={drawMode}
-                      onExitDrawMode={() => {
-                        setDrawMode(false);
-                        setPinMode(false);
-                        setActiveTool("move");
-                        setMode("edit");
-                      }}
-                      pinMode={pinMode}
-                      onExitPinMode={() => {
-                        setPinMode(false);
-                        if (mode === "annotate") {
-                          setActiveTool("draw");
-                        }
-                      }}
-                      designId={id}
-                      designTitle={design?.title}
-                      commentContextId={`${id}:${activeFile.id}`}
-                      commentContextLabel={`${design?.title ?? t("navigation.brand")} / ${prettyScreenName(activeFile.filename)}`}
-                      onPrototypeNavigate={(screen) => {
-                        if (!screen) return;
-                        const norm = (s: string) =>
-                          s
-                            .replace(/^\.?\//, "")
-                            .replace(/\.html?$/i, "")
-                            .toLowerCase();
-                        const target = norm(screen);
-                        if (!target) return;
-                        // Exact (normalized) filename match only — a substring match
-                        // could send "board" to "dashboard.html".
-                        const match = files.find(
-                          (f) => norm(f.filename) === target,
+                            ) =>
+                              handleScreenTextContentChange(
+                                screen.id,
+                                selector,
+                                value,
+                                info,
+                                details,
+                              )
+                            }
+                            onTextEditingStateChange={setTextEditingState}
+                            onElementDblClickText={(info) =>
+                              handleScreenElementDblClickText(screen.id, info)
+                            }
+                            tweakValues={cssVarValues}
+                            drawMode={false}
+                            pinMode={false}
+                            designId={id}
+                            designTitle={design?.title}
+                            commentContextId={`${id}:${screen.id}`}
+                            commentContextLabel={`${design?.title ?? t("navigation.brand")} / ${prettyScreenName(screen.filename)}`}
+                          />
                         );
-                        if (match) {
-                          viewModeRef.current = "single";
-                          setScreenZoom(FOCUSED_SCREEN_ZOOM);
-                          setViewMode("single");
-                          setActiveFileId(match.id);
-                        }
                       }}
                     />
-                    {/* Presence: live cursor overlay for remote participants */}
-                    {others.length > 0 && (
-                      <LiveCursorOverlay
-                        others={others}
-                        containerRef={canvasContainerRef}
+                  ) : (
+                    <>
+                      <DesignCanvas
+                        content={activeContent}
+                        contentKey={`${activeFile.id}:${contentRenderRevision}`}
+                        zoom={zoom}
+                        onZoomChange={setZoom}
+                        deviceFrame={deviceFrame}
+                        sourceType={designSourceType}
+                        fusionUrl={designFusionUrl}
+                        previewWidthPx={activeBreakpointWidthState}
+                        shaderFillPreview={shaderFillPreview}
+                        onComponentSourceJump={handleComponentSourceJump}
+                        motionTracks={motionTracksWire}
+                        editMode={mode === "edit"}
+                        interactMode={mode === "interact"}
+                        readOnly={!canEditDesign}
+                        scaleMode={activeTool === "scale"}
+                        clearSelectionRequest={overviewClearSelectionRequest}
+                        selectedSelector={selectedCanvasSelector}
+                        selectedSelectorCandidates={
+                          selectedCanvasSelectorCandidates
+                        }
+                        hoveredSelector={hoveredCanvasSelector}
+                        hoveredSelectorCandidates={
+                          hoveredCanvasSelectorCandidates
+                        }
+                        lockedSelectors={lockedLayerSelectors}
+                        hiddenSelectors={hiddenLayerSelectors}
+                        onElementSelect={handleElementSelect}
+                        onElementHover={handleElementHover}
+                        onClearSelection={() => {
+                          setSelectedElement(null);
+                          setHoveredElement(null);
+                          setHoveredElementScreenId(null);
+                          setSelectedLayerIdsState([]);
+                        }}
+                        onIframeHotkey={handleIframeHotkey}
+                        onIframeContextMenu={handleIframeContextMenu}
+                        onVisualStyleChange={handleVisualStyleChange}
+                        onVisualStructureChange={handleVisualStructureChange}
+                        onVisualDuplicateChange={handleVisualDuplicateChange}
+                        onTextContentChange={handleTextContentChange}
+                        onTextEditingStateChange={setTextEditingState}
+                        onElementDblClickText={handleElementDblClickText}
+                        tweakValues={cssVarValues}
+                        drawMode={drawMode}
+                        onExitDrawMode={() => {
+                          setDrawMode(false);
+                          setPinMode(false);
+                          setActiveTool("move");
+                          setMode("edit");
+                        }}
+                        pinMode={pinMode}
+                        onExitPinMode={() => {
+                          setPinMode(false);
+                          if (mode === "annotate") {
+                            setActiveTool("draw");
+                          }
+                        }}
+                        designId={id}
+                        designTitle={design?.title}
+                        commentContextId={`${id}:${activeFile.id}`}
+                        commentContextLabel={`${design?.title ?? t("navigation.brand")} / ${prettyScreenName(activeFile.filename)}`}
+                        onPrototypeNavigate={(screen) => {
+                          if (!screen) return;
+                          const norm = (s: string) =>
+                            s
+                              .replace(/^\.?\//, "")
+                              .replace(/\.html?$/i, "")
+                              .toLowerCase();
+                          const target = norm(screen);
+                          if (!target) return;
+                          // Exact (normalized) filename match only — a substring match
+                          // could send "board" to "dashboard.html".
+                          const match = files.find(
+                            (f) => norm(f.filename) === target,
+                          );
+                          if (match) {
+                            viewModeRef.current = "single";
+                            setScreenZoom(FOCUSED_SCREEN_ZOOM);
+                            setViewMode("single");
+                            setActiveFileId(match.id);
+                          }
+                        }}
                       />
-                    )}
-                  </>
-                )}
+                      {/* Presence: live cursor overlay for remote participants */}
+                      {others.length > 0 && (
+                        <LiveCursorOverlay
+                          others={others}
+                          containerRef={canvasContainerRef}
+                        />
+                      )}
+                    </>
+                  )}
+                </div>
               </div>
             ) : (
               <div className="flex flex-1 items-center justify-center">
@@ -10140,7 +12407,7 @@ ${serializedHtml}
                       </p>
                       {retryablePrompt ? (
                         <p className="mx-auto mb-4 max-w-sm text-xs italic text-muted-foreground/70">
-                          "{retryablePrompt.prompt}"
+                          {`"${retryablePrompt.prompt}"`}
                         </p>
                       ) : null}
                       <div className="flex items-center justify-center gap-2">
@@ -10206,6 +12473,51 @@ ${serializedHtml}
                   tweakValues={tweakSelections}
                   extensionContext={designExtensionContext}
                   readOnly={initialGenerationReadOnly}
+                  onComponentPropApplied={handleComponentPropApplied}
+                  onTokensApplied={(resolvedCssVars) => {
+                    if (!canEditDesign || !id) return;
+                    setTweakSelections((prev) => ({
+                      ...prev,
+                      ...resolvedCssVars,
+                    }));
+                    queryClient.setQueryData(
+                      ["action", "get-design", { id }],
+                      (old: any) => {
+                        if (!old || typeof old !== "object") return old;
+                        let currentData: Record<string, unknown> = {};
+                        if (typeof old.data === "string" && old.data) {
+                          try {
+                            const parsed = JSON.parse(old.data);
+                            if (
+                              parsed &&
+                              typeof parsed === "object" &&
+                              !Array.isArray(parsed)
+                            ) {
+                              currentData = parsed;
+                            }
+                          } catch {
+                            currentData = {};
+                          }
+                        }
+                        const currentSelections =
+                          currentData.tweakSelections &&
+                          typeof currentData.tweakSelections === "object" &&
+                          !Array.isArray(currentData.tweakSelections)
+                            ? currentData.tweakSelections
+                            : {};
+                        return {
+                          ...old,
+                          data: JSON.stringify({
+                            ...currentData,
+                            tweakSelections: {
+                              ...currentSelections,
+                              ...resolvedCssVars,
+                            },
+                          }),
+                        };
+                      },
+                    );
+                  }}
                   onTweakChange={(tweakId, value) =>
                     setTweakSelections((prev) => {
                       if (!canEditDesign) return prev;
@@ -10217,8 +12529,67 @@ ${serializedHtml}
                   onRequestTweaks={handleRequestTweaks}
                   onStyleChange={handleStyleChange}
                   onStylesChange={handleStylesChange}
+                  onAutoLayoutConvert={handleAutoLayoutConvert}
                   onExport={handleInspectorExport}
                   exporting={pngExporting || svgExporting}
+                  designId={id}
+                  fileId={activeFile?.id}
+                  filename={activeFile?.filename}
+                  componentNodeId={selectedComponentNodeId}
+                  sourceCapabilities={sourceCapabilities}
+                  onCreateComponent={
+                    id && selectedElement ? handleCreateComponent : undefined
+                  }
+                  defaultComponentName={defaultComponentName}
+                  inspectCode={inspectCodeData}
+                  statesPanelProps={
+                    id
+                      ? {
+                          // §6.4 / §8 — active state and breakpoint wired into
+                          // the StatesPanel so selection is agent-visible.
+                          activeStateId: selectedStateId,
+                          activeBreakpointId: statesPanelActiveBreakpointId,
+                          breakpoints: statesPanelBreakpoints,
+                          onStateSelect: handleDesignStateSelect,
+                          onBreakpointSelect: (breakpointId) => {
+                            // "auto" = clear the active breakpoint (overview).
+                            if (breakpointId === "auto") {
+                              setActiveBreakpointWidthState(undefined);
+                              if (id) {
+                                void setActiveBreakpointMutation.mutateAsync({
+                                  designId: id,
+                                  breakpointId: "auto",
+                                });
+                              }
+                              return;
+                            }
+                            const bp =
+                              statesPanelBreakpoints.find(
+                                (b) => b.id === breakpointId,
+                              ) ??
+                              DEFAULT_STATES_PANEL_BREAKPOINTS.find(
+                                (b) => b.id === breakpointId,
+                              );
+                            if (!bp) return;
+                            setActiveBreakpointWidthState(bp.widthPx);
+                            if (id) {
+                              void setActiveBreakpointMutation.mutateAsync({
+                                designId: id,
+                                breakpointId,
+                              });
+                            }
+                          },
+                          onAddBreakpoint: () => {
+                            // Delegate to the MultiScreenCanvas affordance by
+                            // navigating to overview where the "+" button lives.
+                            if (viewMode !== "overview") {
+                              setViewMode("overview");
+                            }
+                          },
+                        }
+                      : undefined
+                  }
+                  reviewPanelProps={resolvedReviewPanelProps}
                 />
               </div>
             ) : (
@@ -10228,6 +12599,55 @@ ${serializedHtml}
         ) : null}
       </div>
 
+      {/* Motion dock (§6.3) — collapsible bottom dock; visible when activeFile
+          is open and the user has opened it. Canvas remains visible above.
+          Preview-only scrubbing fires a motion-preview postMessage to the
+          canvas iframe (via canvasIframeRef); "Write to CSS" fires
+          apply-motion-edit. */}
+      {!embedded && activeFile ? (
+        <MotionDock
+          tracks={motionTracks}
+          durationMs={motionDurationMs}
+          open={motionDockOpen}
+          onOpenChange={setMotionDockOpen}
+          onTracksChange={setMotionTracks}
+          onDurationChange={setMotionDurationMs}
+          canvasIframeRef={canvasIframeRef}
+          selectedTarget={motionSelectedTarget}
+          onApply={(tracks, durationMs) => {
+            if (!id) return;
+            applyMotionEditMutation.mutate(
+              {
+                designId: id,
+                fileId: activeFile.id,
+                tracks: tracks.map(({ label: _label, ...t }) => t),
+                durationMs,
+                includeContent: true,
+              },
+              {
+                onSuccess: (result) => {
+                  const response = result as {
+                    fileId?: unknown;
+                    patchedContent?: unknown;
+                  };
+                  if (
+                    typeof response.fileId === "string" &&
+                    typeof response.patchedContent === "string"
+                  ) {
+                    applyFileContentUpdate(
+                      response.fileId,
+                      response.patchedContent,
+                      { refreshPreview: response.fileId === activeFile.id },
+                    );
+                  }
+                },
+              },
+            );
+          }}
+          applying={applyMotionEditMutation.isPending}
+        />
+      ) : null}
+
       <PromptPopover
         open={showPrompt}
         onOpenChange={handlePromptOpenChange}
@@ -10313,6 +12733,183 @@ ${serializedHtml}
         loading={generating || pendingGenerationActive}
         anchorRef={tweakPromptAnchorRef}
       />
+
+      {/* §6.6 — "Make this a real app" dialog.
+          Three states:
+          1. Idle — confirm prompt with description of what will happen.
+          2. Migrating — spinner while the Builder cloud agent accepts the job.
+          3. Success — branchName + url; sourceType already flipped to fusion.
+          4. Not-configured — CTA to connect Builder.io.
+      */}
+      <Dialog
+        open={makeRealDialogOpen}
+        onOpenChange={(open) => {
+          if (!migrateMutation.isPending) setMakeRealDialogOpen(open);
+        }}
+      >
+        <DialogContent className="sm:max-w-md">
+          {/* Not-configured: Builder not connected or no project ID */}
+          {migrationResult?.status === "not-configured" &&
+          migrationResult.cta ? (
+            <>
+              <DialogHeader>
+                <DialogTitle className="flex items-center gap-2">
+                  <IconRocket className="size-5 text-muted-foreground" />
+                  {migrationResult.cta.label}
+                </DialogTitle>
+                <DialogDescription>
+                  {migrationResult.cta.description}
+                </DialogDescription>
+              </DialogHeader>
+              <DialogFooter className="flex-col gap-2 sm:flex-row">
+                <Button
+                  variant="outline"
+                  onClick={() => setMakeRealDialogOpen(false)}
+                  className="cursor-pointer"
+                >
+                  Cancel
+                </Button>
+                {migrationResult.cta.connectUrl ? (
+                  <Button asChild className="cursor-pointer">
+                    <a
+                      href={migrationResult.cta.connectUrl}
+                      target="_blank"
+                      rel="noopener noreferrer"
+                    >
+                      {migrationResult.cta.primaryAction}
+                      <IconExternalLink className="ml-1.5 size-3.5" />
+                    </a>
+                  </Button>
+                ) : null}
+              </DialogFooter>
+            </>
+          ) : migrationResult?.status === "processing" ? (
+            /* Success: Builder accepted the migration job */
+            <>
+              <DialogHeader>
+                <DialogTitle className="flex items-center gap-2">
+                  <IconCircleCheck className="size-5 text-green-500" />
+                  {"Migration started" /* i18n-ignore */}
+                </DialogTitle>
+                <DialogDescription>
+                  {
+                    "Builder is generating a React app branch from your design. The original inline design is preserved and recoverable." /* i18n-ignore */
+                  }
+                </DialogDescription>
+              </DialogHeader>
+              <div className="space-y-3 py-2">
+                {migrationResult.branchName && (
+                  <div className="rounded-md border border-border bg-muted/40 px-3 py-2 text-sm">
+                    <span className="text-muted-foreground">
+                      {"Branch: " /* i18n-ignore */}
+                    </span>
+                    <span className="font-mono font-medium">
+                      {migrationResult.branchName}
+                    </span>
+                  </div>
+                )}
+                {migrationResult.url && (
+                  <a
+                    href={migrationResult.url}
+                    target="_blank"
+                    rel="noopener noreferrer"
+                    className="flex items-center gap-1.5 text-sm text-[var(--design-editor-accent-color)] hover:underline"
+                  >
+                    {"Open in Builder" /* i18n-ignore */}
+                    <IconExternalLink className="size-3.5" />
+                  </a>
+                )}
+                {migrationResult.seedFileCount !== undefined && (
+                  <p className="text-xs text-muted-foreground">
+                    {
+                      `${migrationResult.seedFileCount} design file${migrationResult.seedFileCount === 1 ? "" : "s"} included in migration seed.` /* i18n-ignore */
+                    }
+                  </p>
+                )}
+              </div>
+              <DialogFooter>
+                <Button
+                  onClick={() => setMakeRealDialogOpen(false)}
+                  className="cursor-pointer"
+                >
+                  {"Done" /* i18n-ignore */}
+                </Button>
+              </DialogFooter>
+            </>
+          ) : (
+            /* Idle or migrating */
+            <>
+              <DialogHeader>
+                <DialogTitle className="flex items-center gap-2">
+                  <IconRocket className="size-5" />
+                  {"Make this a real app" /* i18n-ignore */}
+                </DialogTitle>
+                <DialogDescription>
+                  {
+                    "Connect Builder.io to convert this design into a React + Tailwind app with real components, props, branches, and deploys. Your current inline design is preserved as a snapshot you can restore at any time." /* i18n-ignore */
+                  }
+                </DialogDescription>
+              </DialogHeader>
+              <div className="space-y-2 py-1 text-sm text-muted-foreground">
+                <p>{"What happens:" /* i18n-ignore */}</p>
+                <ul className="list-disc pl-4 space-y-1">
+                  <li>
+                    {
+                      "Your design HTML and tokens are sent to the Builder cloud agent" /* i18n-ignore */
+                    }
+                  </li>
+                  <li>
+                    {
+                      "A React + Tailwind branch is generated in Builder" /* i18n-ignore */
+                    }
+                  </li>
+                  <li>
+                    {
+                      "The editor switches to fusion source mode — gated panels light up" /* i18n-ignore */
+                    }
+                  </li>
+                  <li>
+                    {
+                      "The original inline design is saved as a restorable snapshot" /* i18n-ignore */
+                    }
+                  </li>
+                </ul>
+                <p className="pt-1 text-xs">
+                  {
+                    "Requires Builder.io to be connected with a branch project configured." /* i18n-ignore */
+                  }
+                </p>
+              </div>
+              <DialogFooter className="flex-col gap-2 sm:flex-row">
+                <Button
+                  variant="outline"
+                  onClick={() => setMakeRealDialogOpen(false)}
+                  disabled={migrateMutation.isPending}
+                  className="cursor-pointer"
+                >
+                  Cancel
+                </Button>
+                <Button
+                  onClick={() => void handleConfirmMakeReal()}
+                  disabled={migrateMutation.isPending}
+                  className="cursor-pointer"
+                >
+                  {
+                    migrateMutation.isPending ? (
+                      <>
+                        <Spinner className="mr-2 size-3.5" />
+                        {"Starting migration…" /* i18n-ignore */}
+                      </>
+                    ) : (
+                      "Start migration"
+                    ) /* i18n-ignore */
+                  }
+                </Button>
+              </DialogFooter>
+            </>
+          )}
+        </DialogContent>
+      </Dialog>
     </div>
   );
 }