@agent-native/core 0.163.4 → 0.164.3

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

@@ -0,0 +1,183 @@
+import type { CanvasFrameGeometryById } from "@shared/canvas-frames";
+import { getFrameGroupBounds } from "@shared/canvas-math";
+import type { CodeLayerNode } from "@shared/code-layer";
+import { buildCodeLayerProjection } from "@shared/code-layer";
+import type { RefObject } from "react";
+
+import { trace } from "@/components/design/design-trace";
+import { getInitialFrameGeometry } from "@/components/design/multi-screen/frame-geometry";
+import type { FrameGeometry } from "@/components/design/multi-screen/types";
+import type { ElementInfo } from "@/components/design/types";
+import type { DesignHotkeyAlignEdge } from "@/hooks/useDesignHotkeys";
+import type { OverviewScreen } from "@/pages/design-editor/derive/overview-screens";
+import {
+  cloneCanvasFrameGeometry,
+  getCanvasFrameGeometry,
+} from "@/pages/design-editor/design-data-geometry-utils";
+import type { AlignableRect } from "@/pages/design-editor/layout-operations";
+import { computeAlignedPositions } from "@/pages/design-editor/layout-operations";
+import { overviewSelectionTargetsElement } from "@/pages/design-editor/selection-state";
+import type { DesignFile } from "@/pages/design-editor/types";
+
+export interface AlignSelectionArgs {
+  activeFile: DesignFile;
+  boardFileId: string | undefined;
+  boardFrameGeometry: FrameGeometry | undefined;
+  canEditDesign: boolean;
+  commitNodePositions: (
+    baseContent: string,
+    positions: ReadonlyMap<string, { x: number; y: number }>,
+  ) => boolean;
+  designDataJsonRef: RefObject<Record<string, unknown>>;
+  files: DesignFile[];
+  getActiveFileSelectedNodeIds: (content: string) => string[];
+  getFreshActiveContent: () => string;
+  handleGeometryCommit: (
+    before: CanvasFrameGeometryById,
+    after: CanvasFrameGeometryById,
+    options?: { source?: "pointer" | "keyboard" },
+  ) => void;
+  overviewScreens: OverviewScreen[];
+  overviewSelectedScreenIds: string[];
+  rectFromCodeLayerNode: (node: CodeLayerNode) => AlignableRect;
+  selectedElement: ElementInfo | null;
+  selectedLayerIdsState: string[];
+  viewModeRef: RefObject<"single" | "overview">;
+}
+
+export function runAlignSelection(
+  {
+    activeFile,
+    boardFileId,
+    boardFrameGeometry,
+    canEditDesign,
+    commitNodePositions,
+    designDataJsonRef,
+    files,
+    getActiveFileSelectedNodeIds,
+    getFreshActiveContent,
+    handleGeometryCommit,
+    overviewScreens,
+    overviewSelectedScreenIds,
+    rectFromCodeLayerNode,
+    selectedElement,
+    selectedLayerIdsState,
+    viewModeRef,
+  }: AlignSelectionArgs,
+  edge: DesignHotkeyAlignEdge,
+) {
+  trace("structure", "align", { layers: selectedLayerIdsState.length });
+  if (!canEditDesign) return;
+
+  // Overview, 2+ selected SCREENS: align each screen's frame geometry to
+  // the selection's combined bounding box through the same
+  // handleGeometryCommit path drags/nudges use — one undo step for the
+  // whole align. A layer selection must fall through to the element path
+  // below instead, as Figma aligns whatever is selected.
+  if (
+    viewModeRef.current === "overview" &&
+    !overviewSelectionTargetsElement({
+      selectedElement,
+      selectedLayerIds: selectedLayerIdsState,
+      fileIds: files.map((file) => file.id),
+    })
+  ) {
+    if (overviewSelectedScreenIds.length < 2) return;
+    const before = getCanvasFrameGeometry(designDataJsonRef.current);
+    const screenRects: AlignableRect[] = [];
+    overviewSelectedScreenIds.forEach((screenId) => {
+      const screenIndex = overviewScreens.findIndex(
+        (screen) => screen.id === screenId,
+      );
+      const screen =
+        screenIndex >= 0 ? overviewScreens[screenIndex] : undefined;
+      const fallbackGeometry =
+        screenIndex >= 0
+          ? getInitialFrameGeometry(screenIndex, {
+              width: screen?.width ?? 1280,
+              height: screen?.height ?? 2560,
+            })
+          : boardFileId === screenId
+            ? boardFrameGeometry
+            : undefined;
+      if (!fallbackGeometry) return;
+      const geometry = { ...fallbackGeometry, ...before[screenId] };
+      screenRects.push({
+        id: screenId,
+        x: geometry.x,
+        y: geometry.y,
+        width: geometry.width,
+        height: geometry.height,
+      });
+    });
+    if (screenRects.length < 2) return;
+    const bounds = getFrameGroupBounds(screenRects);
+    if (!bounds) return;
+    const positions = computeAlignedPositions(
+      screenRects,
+      {
+        x: bounds.left,
+        y: bounds.top,
+        width: bounds.width,
+        height: bounds.height,
+      },
+      edge,
+    );
+    if (positions.size === 0) return;
+    const after = cloneCanvasFrameGeometry(before);
+    positions.forEach((position, screenId) => {
+      after[screenId] = { ...after[screenId]!, ...position };
+    });
+    handleGeometryCommit(before, after);
+    return;
+  }
+
+  // Single-screen mode: in-screen DOM-node layers.
+  if (!activeFile) return;
+  const baseContent = getFreshActiveContent();
+  const nodeIds = getActiveFileSelectedNodeIds(baseContent);
+  if (nodeIds.length === 0) return;
+  const projection = buildCodeLayerProjection(baseContent);
+  const nodesById = new Map(projection.nodes.map((node) => [node.id, node]));
+  const selectedNodes = nodeIds
+    .map((nodeId) => nodesById.get(nodeId))
+    .filter((node): node is CodeLayerNode => Boolean(node));
+  if (selectedNodes.length === 0) return;
+  const selectedRects = selectedNodes.map(rectFromCodeLayerNode);
+
+  if (selectedRects.length >= 2) {
+    // Multi-selection: align to the selection's own combined bbox.
+    const bounds = getFrameGroupBounds(selectedRects);
+    if (!bounds) return;
+    const positions = computeAlignedPositions(
+      selectedRects,
+      {
+        x: bounds.left,
+        y: bounds.top,
+        width: bounds.width,
+        height: bounds.height,
+      },
+      edge,
+    );
+    if (positions.size === 0) return;
+    commitNodePositions(baseContent, positions);
+    return;
+  }
+
+  // Single selection: align relative to the parent's content box. A
+  // single top-level screen (no code-layer parent) is a no-op, matching
+  // Figma (there's nothing to align a lone top-level frame against).
+  const soleNode = selectedNodes[0]!;
+  const parentId = soleNode.parentId;
+  if (!parentId) return;
+  const parentNode = nodesById.get(parentId);
+  if (!parentNode) return;
+  const parentRect = rectFromCodeLayerNode(parentNode);
+  const positions = computeAlignedPositions(
+    [selectedRects[0]!],
+    { x: 0, y: 0, width: parentRect.width, height: parentRect.height },
+    edge,
+  );
+  if (positions.size === 0) return;
+  commitNodePositions(baseContent, positions);
+}

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

@@ -0,0 +1,243 @@
+import type { CanvasFrameGeometryById } from "@shared/canvas-frames";
+import type { Dispatch, RefObject, SetStateAction } from "react";
+
+import type { InspectorTab } from "@/components/design/EditPanel";
+import { getScreenPreviewViewport } from "@/components/design/multi-screen/frame-geometry";
+import type { ElementInfo } from "@/components/design/types";
+import type { DesignEditorCommand } from "@/hooks/use-navigation-state";
+import type { OverviewScreen } from "@/pages/design-editor/derive/overview-screens";
+import {
+  clampZoom,
+  shouldDeferOverviewZoomCommand,
+} from "@/pages/design-editor/overview-camera";
+import {
+  DEFAULT_INTERACT_DEVICE_PRESET,
+  resolveInteractDeviceForScreen,
+} from "@/pages/design-editor/responsive-interact";
+import { findDesignFileByScreenTarget } from "@/pages/design-editor/screen-command-utils";
+import {
+  getDesignToolActivationState,
+  isSingleScreenAnnotationTool,
+  normalizeDesignLeftPanel,
+  normalizeDesignTool,
+} from "@/pages/design-editor/tool-state";
+import type {
+  DesignFile,
+  DesignLeftPanel,
+  DesignTool,
+  EditorMode,
+} from "@/pages/design-editor/types";
+import { FOCUSED_SCREEN_ZOOM } from "@/pages/design-editor/types";
+
+export interface ApplyDesignEditorCommandArgs {
+  canEditDesign: boolean;
+  canvasFrameGeometryById: CanvasFrameGeometryById;
+  files: DesignFile[];
+  id: string | undefined;
+  overviewScreens: OverviewScreen[];
+  setActiveFileId: Dispatch<SetStateAction<string | null>>;
+  setActiveInspectorTab: Dispatch<SetStateAction<InspectorTab>>;
+  setActiveLeftPanel: Dispatch<SetStateAction<DesignLeftPanel>>;
+  setActiveTool: Dispatch<SetStateAction<DesignTool>>;
+  setDrawMode: Dispatch<SetStateAction<boolean>>;
+  setInteractDeviceName: Dispatch<SetStateAction<string>>;
+  setInteractDeviceSize: Dispatch<
+    SetStateAction<{ width: number; height: number }>
+  >;
+  setMode: Dispatch<SetStateAction<EditorMode>>;
+  setPinMode: Dispatch<SetStateAction<boolean>>;
+  setScreenZoom: Dispatch<SetStateAction<number>>;
+  setSelectedElement: Dispatch<SetStateAction<ElementInfo | null>>;
+  setSelectedLayerIdsState: Dispatch<SetStateAction<string[]>>;
+  setViewMode: Dispatch<SetStateAction<"single" | "overview">>;
+  setZoomForView: (
+    targetView: "single" | "overview",
+    update: SetStateAction<number>,
+  ) => void;
+  viewModeRef: RefObject<"single" | "overview">;
+}
+
+export function runApplyDesignEditorCommand(
+  {
+    canEditDesign,
+    canvasFrameGeometryById,
+    files,
+    id,
+    overviewScreens,
+    setActiveFileId,
+    setActiveInspectorTab,
+    setActiveLeftPanel,
+    setActiveTool,
+    setDrawMode,
+    setInteractDeviceName,
+    setInteractDeviceSize,
+    setMode,
+    setPinMode,
+    setScreenZoom,
+    setSelectedElement,
+    setSelectedLayerIdsState,
+    setViewMode,
+    setZoomForView,
+    viewModeRef,
+  }: ApplyDesignEditorCommandArgs,
+  command: DesignEditorCommand | Record<string, unknown>,
+) {
+  if (!id || command.designId !== id) return true;
+  const commandRecord = command as Record<string, unknown>;
+  const editorView =
+    command.editorView === "overview" || command.editorView === "single"
+      ? command.editorView
+      : command.viewMode === "overview" || command.viewMode === "single"
+        ? command.viewMode
+        : undefined;
+  const target =
+    typeof command.fileId === "string"
+      ? command.fileId
+      : typeof command.screenId === "string"
+        ? command.screenId
+        : typeof command.filename === "string"
+          ? command.filename
+          : typeof command.screen === "string"
+            ? command.screen
+            : null;
+  const selectionId =
+    typeof command.selection === "string"
+      ? command.selection
+      : typeof commandRecord.nodeId === "string"
+        ? commandRecord.nodeId
+        : typeof commandRecord.layerId === "string"
+          ? commandRecord.layerId
+          : null;
+  const targetFile = findDesignFileByScreenTarget(files, target);
+  // A navigate command can name a screen the agent just created that the
+  // get-design query hasn't refetched yet. Treat any unresolved named target
+  // as not-yet-applied (return false) so the app-state key is preserved and
+  // re-applied on the next tick once the file loads — not just when there are
+  // zero files. Otherwise the navigate is silently consumed and dropped.
+  if (target && !targetFile) return false;
+
+  const inspectorTab =
+    command.inspectorTab === "design" ||
+    command.inspectorTab === "comments" ||
+    command.inspectorTab === "tweaks" ||
+    command.inspectorTab === "code"
+      ? command.inspectorTab
+      : command.inspector === "design" ||
+          command.inspector === "comments" ||
+          command.inspector === "tweaks" ||
+          command.inspector === "code"
+        ? command.inspector
+        : undefined;
+  if (inspectorTab) setActiveInspectorTab(inspectorTab);
+  const leftPanel =
+    normalizeDesignLeftPanel(command.leftPanel) ??
+    normalizeDesignLeftPanel(command.panel) ??
+    normalizeDesignLeftPanel(command.inspectorTab) ??
+    normalizeDesignLeftPanel(command.inspector);
+  if (leftPanel) setActiveLeftPanel(leftPanel);
+
+  const commandTool = normalizeDesignTool(command.tool);
+  const effectiveCommandTool =
+    editorView === "overview" &&
+    commandTool &&
+    isSingleScreenAnnotationTool(commandTool)
+      ? "move"
+      : commandTool;
+  const applyCommandTool = (fallback: DesignTool) => {
+    if (!canEditDesign) return;
+    const nextTool = effectiveCommandTool ?? fallback;
+    const activation = getDesignToolActivationState(nextTool);
+    setActiveTool(nextTool);
+    setMode(activation.mode);
+    setDrawMode(activation.drawMode);
+    setPinMode(activation.pinMode);
+  };
+
+  if (targetFile) {
+    setActiveFileId(targetFile.id);
+  }
+  if (selectionId) {
+    setSelectedLayerIdsState([selectionId]);
+  }
+
+  const commandZoom =
+    typeof command.zoom === "number" && Number.isFinite(command.zoom)
+      ? clampZoom(command.zoom)
+      : null;
+  const targetView = editorView ?? viewModeRef.current;
+  // Zoom-compounding fix — see shouldDeferOverviewZoomCommand's doc
+  // comment: converting a persisted overview zoom back to canvas units
+  // needs the REAL overviewZoomScale (known only once `files` loads), so
+  // defer (return "not yet applicable", same contract as the
+  // `target && !targetFile` bailout above) instead of committing the
+  // conversion against the transient pre-load fallback scale. The mount
+  // effect retries automatically once `files` populates and this
+  // callback's identity changes.
+  if (
+    shouldDeferOverviewZoomCommand({
+      hasZoomCommand: commandZoom !== null,
+      targetView,
+      filesLoaded: files.length > 0,
+    })
+  ) {
+    return false;
+  }
+  if (commandZoom !== null) {
+    setZoomForView(targetView, commandZoom);
+  }
+
+  if (editorView === "overview") {
+    viewModeRef.current = "overview";
+    if (!selectionId) setSelectedElement(null);
+    applyCommandTool("move");
+    setViewMode("overview");
+  } else if (editorView === "single") {
+    viewModeRef.current = "single";
+    if (!selectionId) setSelectedElement(null);
+    const targetScreen = targetFile
+      ? overviewScreens.find((screen) => screen.id === targetFile.id)
+      : undefined;
+    const targetMetadataSize = targetScreen
+      ? {
+          width: targetScreen.width ?? DEFAULT_INTERACT_DEVICE_PRESET.width,
+          height: targetScreen.height ?? DEFAULT_INTERACT_DEVICE_PRESET.height,
+        }
+      : undefined;
+    const targetViewport =
+      targetFile && targetMetadataSize
+        ? getScreenPreviewViewport(targetMetadataSize, {
+            width:
+              canvasFrameGeometryById[targetFile.id]?.width ??
+              targetMetadataSize.width,
+            height:
+              canvasFrameGeometryById[targetFile.id]?.height ??
+              targetMetadataSize.height,
+          })
+        : undefined;
+    const interactDevice = resolveInteractDeviceForScreen(
+      targetViewport
+        ? {
+            width: targetViewport.viewportWidth,
+            height: targetViewport.viewportHeight,
+          }
+        : undefined,
+    );
+    setInteractDeviceName(interactDevice.name);
+    setInteractDeviceSize({
+      width: interactDevice.width,
+      height: interactDevice.height,
+    });
+    setActiveTool("move");
+    setDrawMode(false);
+    setPinMode(false);
+    setMode("interact");
+    if (commandZoom === null) {
+      setScreenZoom(FOCUSED_SCREEN_ZOOM);
+    }
+    setViewMode("single");
+  } else if (effectiveCommandTool) {
+    applyCommandTool("move");
+  }
+
+  return true;
+}

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

@@ -0,0 +1,236 @@
+import { assertDesignHtmlEditIntegrity } from "@shared/html-integrity";
+import { sourceContentHash } from "@shared/source-workspace";
+import type { QueryClient } from "@tanstack/react-query";
+import type { RefObject } from "react";
+import { toast } from "sonner";
+import * as Y from "yjs";
+
+import {
+  isShaderWriteInFlight,
+  waitForShaderWriteToSettle,
+} from "@/components/design/inspector/GlslShaderPanel";
+import type { ClipboardContentMutationPublication } from "@/lib/clipboard-content-lineage";
+import { resolveScreenCollabSyncTarget } from "@/pages/design-editor/collab-sync";
+import { TAB_ID } from "@/pages/design-editor/editor-session";
+import type { FileContentSaveRequest } from "@/pages/design-editor/editor-state";
+import type { ContentHistoryEntry } from "@/pages/design-editor/history";
+import { designSaveErrorMessage } from "@/pages/design-editor/save-failure";
+import type { DesignFile } from "@/pages/design-editor/types";
+
+export interface ApplyFileContentUpdateArgs {
+  acknowledgeAuthoritativeClipboardMutation: (args: {
+    fileId: string;
+    nextContent: string;
+    publication?: ClipboardContentMutationPublication;
+  }) => void;
+  activeFile: DesignFile;
+  applyFileContentUpdate: (
+    fileId: string,
+    nextContent: string,
+    options?: {
+      refreshPreview?: boolean;
+      skipPreview?: boolean;
+      forcePreviewFullDocument?: boolean;
+      persist?: boolean;
+      recordHistory?: boolean;
+      updatedAt?: string;
+      clipboardMutation?: ClipboardContentMutationPublication;
+    },
+  ) => void;
+  applyLocalContentUpdate: (
+    nextContent: string,
+    options?: {
+      refreshPreview?: boolean;
+      skipPreview?: boolean;
+      forcePreviewFullDocument?: boolean;
+      immediateSave?: boolean;
+      persist?: boolean;
+      recordHistory?: boolean;
+      historyBeforeContent?: string;
+      updatedAt?: string;
+      clipboardMutation?: ClipboardContentMutationPublication;
+    },
+  ) => void;
+  canEditDesignRef: RefObject<boolean>;
+  cancelQueuedFileContentSave: (fileId: string) => void;
+  clearPendingLocalFileContent: (
+    fileId: string,
+    expectedContent?: string,
+  ) => void;
+  createFileContentSaveRequest: (
+    fileId: string,
+    content: string,
+    syncCollab: boolean,
+  ) => FileContentSaveRequest;
+  files: DesignFile[];
+  getScreenContent: (screenId: string) => string;
+  id: string | undefined;
+  lastAckedFileContentHashRef: RefObject<Record<string, string>>;
+  markPendingLocalFileContent: (
+    fileId: string,
+    content: string,
+    baseUpdatedAt?: string | null,
+  ) => void;
+  overviewIsSynced: boolean;
+  overviewPresenceFileId: string | null;
+  overviewYdoc: Y.Doc | null;
+  queryClient: QueryClient;
+  recordContentHistoryEntry: (entry: ContentHistoryEntry) => void;
+  saveFileContent: (pending: FileContentSaveRequest) => void;
+  suppressContentHistoryRef: RefObject<boolean>;
+  t: (key: string, options?: Record<string, unknown>) => string;
+}
+
+export function runApplyFileContentUpdate(
+  {
+    acknowledgeAuthoritativeClipboardMutation,
+    activeFile,
+    applyFileContentUpdate,
+    applyLocalContentUpdate,
+    canEditDesignRef,
+    cancelQueuedFileContentSave,
+    clearPendingLocalFileContent,
+    createFileContentSaveRequest,
+    files,
+    getScreenContent,
+    id,
+    lastAckedFileContentHashRef,
+    markPendingLocalFileContent,
+    overviewIsSynced,
+    overviewPresenceFileId,
+    overviewYdoc,
+    queryClient,
+    recordContentHistoryEntry,
+    saveFileContent,
+    suppressContentHistoryRef,
+    t,
+  }: ApplyFileContentUpdateArgs,
+  fileId: string,
+  nextContent: string,
+  options: {
+    refreshPreview?: boolean;
+    skipPreview?: boolean;
+    forcePreviewFullDocument?: boolean;
+    persist?: boolean;
+    recordHistory?: boolean;
+    updatedAt?: string;
+    clipboardMutation?: ClipboardContentMutationPublication;
+  } = {},
+) {
+  if (!canEditDesignRef.current) return;
+  if (fileId === activeFile?.id) {
+    applyLocalContentUpdate(nextContent, options);
+    return;
+  }
+  // Cross-pipeline write race guard — same hazard commitVisualStyles
+  // already defends against (see its withShaderWriteLock note): a shader
+  // apply/remove/knob-commit for this same file runs a separate
+  // read-source-file -> apply-source-edit round trip, and the overview
+  // writeLiveDoc rewrite below replays FULL content into the connected
+  // overviewYdoc. Racing the two corrupts the doc (server-side diff vs
+  // synchronous untracked full rewrite). Defer the whole update until the
+  // in-flight shader write settles; the common no-shader case stays fully
+  // synchronous.
+  if (isShaderWriteInFlight(fileId)) {
+    void waitForShaderWriteToSettle(fileId).then(() => {
+      applyFileContentUpdate(fileId, nextContent, options);
+    });
+    return;
+  }
+  const previousFile = files.find((file) => file.id === fileId);
+  const previousContent =
+    getScreenContent(fileId) ?? previousFile?.content ?? "";
+  try {
+    assertDesignHtmlEditIntegrity({
+      previousContent,
+      nextContent,
+      fileType: previousFile?.fileType ?? "html",
+    });
+  } catch (error) {
+    toast.error(designSaveErrorMessage(error) ?? t("common.genericError"), {
+      id: `design-source-integrity:${fileId}`,
+    });
+    return;
+  }
+  acknowledgeAuthoritativeClipboardMutation({
+    fileId,
+    nextContent,
+    publication: options.clipboardMutation,
+  });
+  const shouldRecordHistory =
+    options.recordHistory !== false && !options.updatedAt;
+  if (
+    !suppressContentHistoryRef.current &&
+    shouldRecordHistory &&
+    previousContent !== nextContent
+  ) {
+    recordContentHistoryEntry({
+      fileId,
+      before: previousContent,
+      after: nextContent,
+    });
+  }
+  if (options.updatedAt) {
+    clearPendingLocalFileContent(fileId);
+    // Server-persisted content (see the matching note in
+    // applyLocalContentUpdate) — refresh the acked-hash base for the
+    // guarded update-file saves.
+    lastAckedFileContentHashRef.current[fileId] =
+      sourceContentHash(nextContent);
+  } else {
+    markPendingLocalFileContent(fileId, nextContent, previousFile?.updatedAt);
+  }
+  queryClient.setQueryData(["action", "get-design", { id }], (old: any) => {
+    if (!old || typeof old !== "object" || !Array.isArray(old.files)) {
+      return old;
+    }
+    return {
+      ...old,
+      files: old.files.map((file: DesignFile) =>
+        file.id === fileId
+          ? {
+              ...file,
+              content: nextContent,
+              ...(options.updatedAt ? { updatedAt: options.updatedAt } : {}),
+            }
+          : file,
+      ),
+    };
+  });
+  // §gesture-persistence — mirror applyLocalContentUpdate's collab-doc
+  // write. This screen isn't the active file, but overview mode can still
+  // hold a LIVE connected Yjs doc for it via the presence-only
+  // `overviewYdoc` subscription (keyed on `overviewPresenceFileId`, the
+  // selected/worked screen in overview — see its declaration doc comment).
+  // Before this fix, per-screen gesture commits only ever wrote SQL and
+  // relied entirely on the server-side `syncCollab: true` -> applyText
+  // round-trip to keep that connected doc in step; any gap between the
+  // SQL write and the next collab poll/state fetch left the connected
+  // client holding pre-edit Yjs text, which a subsequent doc connect
+  // (Code panel open) could read back as the seed snapshot. Writing the
+  // ydoc directly here — the same untracked-full-rewrite pattern used
+  // throughout this file — closes that gap the same way the active-file
+  // path already does, and lets syncCollab be skipped for the
+  // server-side round-trip since the client push already covers it.
+  const { writeLiveDoc, syncCollab } = resolveScreenCollabSyncTarget({
+    fileId,
+    overviewPresenceFileId,
+    overviewDocConnected: !!(overviewYdoc && overviewIsSynced),
+  });
+  if (writeLiveDoc && overviewYdoc) {
+    const ytext = overviewYdoc.getText("content");
+    if (ytext.toString() !== nextContent) {
+      overviewYdoc.transact(() => {
+        ytext.delete(0, ytext.length);
+        ytext.insert(0, nextContent);
+      }, TAB_ID);
+    }
+  }
+  if (options.persist === false) {
+    cancelQueuedFileContentSave(fileId);
+  } else {
+    saveFileContent(
+      createFileContentSaveRequest(fileId, nextContent, syncCollab),
+    );
+  }
+}