@agent-native/core 0.92.10 → 0.92.11

package/corpus/templates/design/server/lib/figma-paste-fallback.ts

@@ -0,0 +1,64 @@
+/**
+ * Shared "legacy" Figma paste fallback: saves the visible clipboard HTML
+ * (markers stripped by `parseVisibleClipboardHtml`) as a new Design screen.
+ *
+ * Extracted from `import-design-source.ts`'s `figma-paste-html` branch so the
+ * REST-first clipboard import path (`import-figma-clipboard.ts`) can fall back
+ * to the exact same behavior when node resolution can't confidently match the
+ * pasted content to specific Figma nodes, instead of re-implementing it.
+ */
+
+import {
+  normalizeImportedHtmlDocument,
+  resolveImportDesignId,
+  saveImportedDesignFiles,
+} from "./import-design-files.js";
+import { parseVisibleClipboardHtml } from "./visible-clipboard-html.js";
+
+export interface SaveFigmaPasteHtmlFallbackInput {
+  designId?: string;
+  clipboardHtml: string;
+  originalName?: string;
+}
+
+function baseFilename(originalName: string | undefined, fallback: string) {
+  return (originalName?.trim() || fallback).replace(/\.[^.]+$/, "") + ".html";
+}
+
+export async function saveFigmaPasteHtmlFallback(
+  input: SaveFigmaPasteHtmlFallbackInput,
+) {
+  const parsed = parseVisibleClipboardHtml(input.clipboardHtml);
+  if (!parsed.fallbackHtml) {
+    throw new Error(
+      "No visible HTML was found in the clipboard. Copy a frame, then paste into the canvas.",
+    );
+  }
+  const designId = await resolveImportDesignId(input.designId);
+  const saved = await saveImportedDesignFiles({
+    designId,
+    sourceType: "figma-paste-html",
+    files: [
+      {
+        filename: baseFilename(input.originalName, "figma-paste"),
+        fileType: "html",
+        content: normalizeImportedHtmlDocument(
+          parsed.fallbackHtml,
+          "visible clipboard HTML",
+        ),
+        source: {
+          sourceType: "figma-paste-html",
+        },
+      },
+    ],
+  });
+  return {
+    ...saved,
+    stats: {
+      sourceKind: "figma-paste",
+      format: "html",
+      frameCount: saved.files.length,
+      imageCount: 0,
+    },
+  };
+}

package/corpus/templates/design/server/lib/playwright-runtime.ts

@@ -0,0 +1,78 @@
+/**
+ * playwright-runtime.ts — shared headless-Chromium bootstrap used by every
+ * server-side action that needs a real rendered DOM (as opposed to static
+ * HTML/CSS analysis): `take-design-screenshot.ts`'s visual diagnostics pass
+ * and `design-to-figma-svg.ts`'s scene extractor for the Figma SVG export.
+ *
+ * Extracted out of `take-design-screenshot.ts` (which originally owned this
+ * logic) so `server/lib/*` modules can share it without an inverted
+ * lib -> action dependency. `take-design-screenshot.ts` re-exports these same
+ * names for backward compatibility with its existing spec/imports.
+ */
+
+export type PlaywrightModule = {
+  chromium: import("@playwright/test").BrowserType;
+};
+
+/**
+ * Dynamic import of a real Chromium-capable Playwright package.  Tries the
+ * bare `"playwright"` package first (present when `@agent-native/core`'s
+ * optional dependency resolved), then falls back to `@playwright/test` (a
+ * direct devDependency of this template, used by its own e2e suite, which
+ * re-exports the same chromium/Browser API). Loaded via a non-literal
+ * specifier so bundlers don't try to statically resolve/include it — it's
+ * optional and can be entirely absent (e.g. in a hosted deploy).
+ */
+export async function importPlaywright(): Promise<PlaywrightModule> {
+  try {
+    const specifier = "playwright";
+    return (await import(
+      /* @vite-ignore */ specifier
+    )) as unknown as PlaywrightModule;
+  } catch {
+    return (await import("@playwright/test")) as unknown as PlaywrightModule;
+  }
+}
+
+const SYSTEM_CHROME_EXECUTABLES = [
+  "/usr/bin/google-chrome-stable",
+  "/usr/bin/google-chrome",
+  "/usr/bin/chromium-browser",
+  "/usr/bin/chromium",
+];
+
+/** Pure classifier for "no Chromium binary available" errors. */
+export function isMissingBrowserError(err: unknown): boolean {
+  const message = err instanceof Error ? err.message : String(err);
+  return /Executable doesn't exist|playwright install|browser.*not found|chromium.*not found/i.test(
+    message,
+  );
+}
+
+/** Launches Chromium, falling back to a system Chrome/Chromium binary when
+ *  Playwright's bundled browser isn't installed (hosted/serverless deploys). */
+export async function launchChromium(
+  chromium: import("@playwright/test").BrowserType,
+): Promise<import("@playwright/test").Browser> {
+  const launchOptions = { args: ["--no-sandbox"] };
+  try {
+    return await chromium.launch(launchOptions);
+  } catch (err) {
+    if (!isMissingBrowserError(err)) throw err;
+    const { existsSync } = await import("node:fs");
+    for (const executablePath of SYSTEM_CHROME_EXECUTABLES) {
+      if (!existsSync(executablePath)) continue;
+      try {
+        return await chromium.launch({ ...launchOptions, executablePath });
+      } catch {
+        // Try the next candidate; the original error is rethrown below.
+      }
+    }
+    throw err;
+  }
+}
+
+// NOTE: no shared `chromiumUnavailableReason` here on purpose — each caller's
+// message should name ITS OWN fallback (e.g. `take-design-screenshot.ts`
+// points at `run-design-audit`; the Figma SVG export points at `export-svg`),
+// so that stays a small, action-local export next to each call site.

package/corpus/templates/design/server/plugins/db.ts

@@ -356,8 +356,49 @@ ALTER TABLE design_files ADD COLUMN IF NOT EXISTS content_operation_result_hash
  * drops, renames, or retypes anything — and any failure here is logged and
  * swallowed so it can never fail boot.
  */
+/**
+ * Best-effort unique index guarding against the add-localhost-screens
+ * cross-request race: two concurrent calls placing the same localhost route
+ * each see "no existing design_files row" from their own snapshot and both
+ * insert a fresh row using the same deterministic filename for that route
+ * (see actions/add-localhost-screens.ts). A unique index on
+ * (design_id, filename) makes the losing insert fail instead of silently
+ * creating an overlapping duplicate screen.
+ *
+ * This intentionally does NOT live in `runDesignMigrations` above:
+ * `CREATE UNIQUE INDEX` fails outright against any database that already
+ * contains a duplicate (design_id, filename) pair — e.g. from this exact race
+ * having already fired before this fix shipped — and `runMigrations` has no
+ * way to tolerate that failure class (only lock-timeout / duplicate-column /
+ * permission errors are swallowed there). A failed migration entry blocks
+ * every later entry in the list forever: it crashes the process outright in
+ * local dev, and on serverless it silently stops applying anything past it on
+ * every cold start. So this runs as its own best-effort step instead: created
+ * when possible, safely skipped (with a warning) when legacy duplicates block
+ * it. `add-localhost-screens.ts`'s insert path tolerates either outcome — it
+ * catches a real unique-violation from this index and falls back to updating
+ * the row that won the race, and is a no-op/no-crash path when the index
+ * isn't present yet.
+ */
+async function ensureDesignFilesUniqueIndex(): Promise<void> {
+  try {
+    await getDbExec().execute(
+      `CREATE UNIQUE INDEX IF NOT EXISTS design_files_design_filename_unique_idx ON design_files (design_id, filename)`,
+    );
+  } catch (err) {
+    console.warn(
+      "[db] design_files_design_filename_unique_idx not created — likely " +
+        "pre-existing duplicate (design_id, filename) rows from the " +
+        "add-localhost-screens race predating this fix. New concurrent " +
+        "inserts remain best-effort until the duplicates are cleaned up:",
+      err instanceof Error ? err.message : err,
+    );
+  }
+}
+
 export default async (nitroApp: any): Promise<void> => {
   await runDesignMigrations(nitroApp);
+  await ensureDesignFilesUniqueIndex();
   try {
     const summary = await ensureAdditiveColumns({
       db: getDbExec(),

package/corpus/templates/design/server/source-workspace.ts

@@ -211,6 +211,70 @@ export async function readLiveSourceFile(file: SourceWorkspaceFile): Promise<{
   };
 }
 
+/**
+ * A caller-supplied editor snapshot has two distinct identities:
+ *
+ * - `content` is the working copy the mutation must transform (it may contain
+ *   unsaved local edits), while
+ * - `expectedVersionHash` is the live source version that working copy is
+ *   allowed to replace.
+ *
+ * Hashing `currentContent` for both roles creates a false conflict whenever a
+ * local working copy is legitimately ahead of the persisted/live base. This
+ * helper accepts that working copy only when its SQL revision still matches
+ * and the live document is either the persisted base it was derived from or
+ * the working copy itself (for callers that already published it to Yjs).
+ * Any third live value is a genuine concurrent edit and fails closed. The
+ * returned live hash must be passed to `writeInlineSourceFile`, whose
+ * read-check-write lock closes the race after this preparation step.
+ */
+export class SourceWorkspaceEditConflictError extends Error {
+  constructor(
+    message = "Source file changed since the editor snapshot was prepared.",
+  ) {
+    super(message);
+    this.name = "SourceWorkspaceEditConflictError";
+  }
+}
+
+export async function prepareInlineSourceEdit(args: {
+  file: SourceWorkspaceFile;
+  currentContent?: string;
+  revision?: string;
+}): Promise<{ content: string; expectedVersionHash: string }> {
+  const live = await readLiveSourceFile(args.file);
+
+  if (args.currentContent === undefined) {
+    return {
+      content: live.content,
+      expectedVersionHash: live.versionHash,
+    };
+  }
+
+  if (!args.revision) {
+    throw new SourceWorkspaceEditConflictError(
+      "A source revision is required with current editor content.",
+    );
+  }
+  if (!args.file.updatedAt || args.revision !== args.file.updatedAt) {
+    throw new SourceWorkspaceEditConflictError();
+  }
+
+  const persistedVersionHash = sourceContentHash(args.file.content ?? "");
+  const workingVersionHash = sourceContentHash(args.currentContent);
+  if (
+    live.versionHash !== persistedVersionHash &&
+    live.versionHash !== workingVersionHash
+  ) {
+    throw new SourceWorkspaceEditConflictError();
+  }
+
+  return {
+    content: args.currentContent,
+    expectedVersionHash: live.versionHash,
+  };
+}
+
 export async function writeInlineSourceFile(args: {
   designId: string;
   file: SourceWorkspaceFile;

package/corpus/templates/design/shared/board-file.ts

@@ -680,8 +680,19 @@ export function stripBoardSurfaceOffsetFromCoord(value: number): number {
  * coordinate space. This is the pure seam used by
  * `handleOverviewPrimitiveReparent` (DesignEditor.tsx).
  *
- * Both inputs are normalized with `stripBoardSurfaceOffsetFromCoord` first:
- * a source that was persisted in board-iframe viewport coordinates
+ * The flat subtraction below is only correct when both `source` and `target`
+ * are already expressed in the SAME coordinate space — historically that
+ * meant "both are direct children of the screen root", because callers used
+ * to read a node's own inline left/top verbatim (parent-relative, not
+ * root-relative). DesignEditor.tsx's `getAbsolutePositioningForNodeInHtml`
+ * now resolves both inputs with an ancestor walk
+ * (`authoredElementPosition`) up to the screen root before calling this, so
+ * the subtraction is valid regardless of how deeply either node is nested —
+ * dropping a node into a container that's itself nested inside another frame
+ * no longer produces a garbage delta.
+ *
+ * Both inputs are also normalized with `stripBoardSurfaceOffsetFromCoord`
+ * first: a source that was persisted in board-iframe viewport coordinates
  * (boardCoord + 65536 — see BOARD_SURFACE_CONTENT_OFFSET_PX) is rebased to
  * board space before subtracting the target's origin, so the child's new
  * left/top always comes out parent-relative regardless of which upstream

package/corpus/templates/design/shared/canvas-math.ts

@@ -1228,51 +1228,34 @@ function projectionsOverlap(
  * For `origin.rotation` falsy this is identical to calling
  * `resizeFrameFromDelta` directly.
  */
-export function resizeRotatedFrameFromDelta(
+/**
+ * Shared re-anchor step used by both resizeRotatedFrameFromDelta and its
+ * snap-aware counterpart below: given the frame's ORIGIN geometry (still
+ * carrying its rotation) and a candidate RESIZED-LOCAL geometry (unrotated,
+ * already grown/shrunk along the frame's own local axes — optionally
+ * adjusted by a snap pass in between), translates the resized-local geometry
+ * so the same handle-opposite anchor point (or the frame's own center, for
+ * an alt/option "resize from center" drag) stays fixed in WORLD space once
+ * rotation is re-applied. See resizeRotatedFrameFromDelta's original inline
+ * comment (kept there) for why alt-resize anchors on the center instead of
+ * the opposite corner/edge.
+ */
+function reanchorRotatedResizeToWorld(
   origin: FrameGeometry,
   handle: ResizeHandle,
-  worldDx: number,
-  worldDy: number,
-  options: ResizeFrameOptions = {},
+  degrees: number,
+  resizedLocal: FrameGeometry,
+  options: Pick<ResizeFrameOptions, "resizeFromCenter">,
 ): FrameGeometry {
-  const degrees = origin.rotation ?? 0;
-  if (!degrees) {
-    return resizeFrameFromDelta(origin, handle, worldDx, worldDy, options);
-  }
-
   const originCenter = {
     x: origin.x + origin.width / 2,
     y: origin.y + origin.height / 2,
   };
-  // Alt/option resize (`resizeFromCenter`) already grows the frame
-  // symmetrically about its own center in LOCAL space (resizeFrameFromDelta
-  // below keeps the center fixed on both axes for that mode). To keep that
-  // center fixed in WORLD space too — matching Figma, where alt-resizing a
-  // rotated frame grows around its visual center rather than pivoting off an
-  // opposite corner — the re-anchor step below must use the center as its
-  // fixed point instead of the handle's opposite corner/edge. Using the
-  // center as the anchor is a no-op for the rotation (a point rotates around
-  // itself unchanged), so it stays put in world space by construction.
-  // Non-center (default) resizes keep anchoring on the opposite corner/edge
-  // so that world-fixed-anchor behavior is unchanged.
   const anchorLocalBefore = options.resizeFromCenter
     ? originCenter
     : getResizeAnchorPoint(origin, handle);
   const anchorWorld = rotatePoint(anchorLocalBefore, originCenter, degrees);
 
-  // Map the world-space pointer delta into the frame's own unrotated axes so
-  // dragging "outward along the handle" behaves the same regardless of how
-  // the frame is rotated.
-  const localDelta = rotateVector({ x: worldDx, y: worldDy }, -degrees);
-
-  const resizedLocal = resizeFrameFromDelta(
-    { ...origin, rotation: undefined },
-    handle,
-    localDelta.x,
-    localDelta.y,
-    options,
-  );
-
   const centerAfterLocal = {
     x: resizedLocal.x + resizedLocal.width / 2,
     y: resizedLocal.y + resizedLocal.height / 2,
@@ -1298,6 +1281,221 @@ export function resizeRotatedFrameFromDelta(
   };
 }
 
+export function resizeRotatedFrameFromDelta(
+  origin: FrameGeometry,
+  handle: ResizeHandle,
+  worldDx: number,
+  worldDy: number,
+  options: ResizeFrameOptions = {},
+): FrameGeometry {
+  const degrees = origin.rotation ?? 0;
+  if (!degrees) {
+    return resizeFrameFromDelta(origin, handle, worldDx, worldDy, options);
+  }
+
+  // Map the world-space pointer delta into the frame's own unrotated axes so
+  // dragging "outward along the handle" behaves the same regardless of how
+  // the frame is rotated.
+  const localDelta = rotateVector({ x: worldDx, y: worldDy }, -degrees);
+
+  const resizedLocal = resizeFrameFromDelta(
+    { ...origin, rotation: undefined },
+    handle,
+    localDelta.x,
+    localDelta.y,
+    options,
+  );
+
+  return reanchorRotatedResizeToWorld(
+    origin,
+    handle,
+    degrees,
+    resizedLocal,
+    options,
+  );
+}
+
+/** Resize handles in clockwise screen order (y grows downward), so rotating a
+ *  handle by one 90° quadrant clockwise is a +2 step through this ring. */
+const RESIZE_HANDLES_CLOCKWISE: readonly ResizeHandle[] = [
+  "n",
+  "ne",
+  "e",
+  "se",
+  "s",
+  "sw",
+  "w",
+  "nw",
+];
+
+/** Maps a local resize handle to the world-space direction it points after
+ *  rotating the frame clockwise by `quadrants` 90° steps (CSS-positive
+ *  rotation is clockwise on screen): at 90°, the local east handle points
+ *  due south in world space, so "e" → "s". */
+function rotateHandleByQuadrants(
+  handle: ResizeHandle,
+  quadrants: number,
+): ResizeHandle {
+  const index = RESIZE_HANDLES_CLOCKWISE.indexOf(handle);
+  return RESIZE_HANDLES_CLOCKWISE[(index + 2 * ((quadrants % 4) + 4)) % 8]!;
+}
+
+/**
+ * Beyond this many degrees away from the nearest axis-aligned orientation
+ * (0/90/180/270), resize snapping is skipped for rotated frames: the frame's
+ * true edges diverge too far from any axis-aligned box for edge/center
+ * alignment against siblings to mean anything, and a wrong-axis guide is
+ * worse than none.
+ */
+const ROTATED_RESIZE_SNAP_MAX_OFF_AXIS_DEGREES = 30;
+
+/**
+ * Rotation-aware counterpart to resizeRotatedFrameFromDelta that also snaps
+ * to nearby stationary siblings, matching computeResizeSnap's contract for
+ * the unrotated group-resize path (CV-style: same threshold/guide shape).
+ *
+ * How rotated snapping works (see WORK ITEM 2 in the canvas bug pass this was
+ * added for, reworked in the pre-ship review): the unsnapped rotated resize
+ * is computed first, then its actual world-space AABB is snapped against
+ * stationary siblings' world bounds with the exact same computeResizeSnap
+ * machinery a non-rotated resize uses — with the resize handle mapped into
+ * its world orientation by the frame's nearest 90° quadrant (at ~90° the
+ * local east edge faces due south in world space, so "e" snaps the AABB's
+ * bottom edge; at ~180° it faces west; etc.). Any snap offset is then fed
+ * back into the rotated resize as extra world pointer travel, so anchoring
+ * stays exact. This is edge-exact at 0/90/180/270 (the AABB edges ARE the
+ * frame's edges there) and approximate in between (pointer travel maps to
+ * AABB-edge movement with a cos² factor); once the rotation is more than
+ * ROTATED_RESIZE_SNAP_MAX_OFF_AXIS_DEGREES from every axis-aligned
+ * orientation, snapping is skipped entirely (no guides) rather than snapping
+ * an axis that no longer matches what the user sees.
+ */
+export function resizeRotatedFrameFromDeltaWithSnap(
+  origin: FrameGeometry,
+  handle: ResizeHandle,
+  worldDx: number,
+  worldDy: number,
+  stationary: FrameEntry[],
+  snapOptions: ResizeSnapOptions,
+  options: ResizeFrameOptions = {},
+): { frame: FrameGeometry; guides: AlignmentGuide[] } {
+  const degrees = origin.rotation ?? 0;
+  if (!degrees) {
+    const resizedLocal = resizeFrameFromDelta(
+      origin,
+      handle,
+      worldDx,
+      worldDy,
+      options,
+    );
+    return computeResizeSnap(resizedLocal, stationary, handle, snapOptions);
+  }
+
+  const localDelta = rotateVector({ x: worldDx, y: worldDy }, -degrees);
+
+  const resizedLocal = resizeFrameFromDelta(
+    { ...origin, rotation: undefined },
+    handle,
+    localDelta.x,
+    localDelta.y,
+    options,
+  );
+
+  // Snapping is skipped outright for a rotated frame whenever the caller's
+  // aspect-preserve flag is set (shift-held or the K scale tool):
+  // independently snapping x and y against the local-bounds approximation
+  // above would distort the locked ratio the aspect-preserving resize above
+  // just computed, and computeAspectPreservingResizeSnap's own single-locked-
+  // ratio reasoning only holds against the frame's true (rotated) shape, not
+  // this approximation. No snap beats a wrong one here.
+  if (snapOptions.preserveAspectRatio || snapOptions.bypass) {
+    return {
+      frame: reanchorRotatedResizeToWorld(
+        origin,
+        handle,
+        degrees,
+        resizedLocal,
+        options,
+      ),
+      guides: [],
+    };
+  }
+
+  const unsnapped = reanchorRotatedResizeToWorld(
+    origin,
+    handle,
+    degrees,
+    resizedLocal,
+    options,
+  );
+
+  // Map the resize handle into its world orientation by the nearest 90°
+  // quadrant (see the doc comment above). Far off-axis, skip snapping
+  // outright — a wrong-axis snap/guide is worse than none.
+  const normalizedDegrees = ((degrees % 360) + 360) % 360;
+  const nearestQuadrant = Math.round(normalizedDegrees / 90) % 4;
+  const offAxisDegrees = Math.abs(
+    normalizedDegrees - Math.round(normalizedDegrees / 90) * 90,
+  );
+  if (offAxisDegrees > ROTATED_RESIZE_SNAP_MAX_OFF_AXIS_DEGREES) {
+    return { frame: unsnapped, guides: [] };
+  }
+
+  const worldHandle = rotateHandleByQuadrants(handle, nearestQuadrant);
+  const aabb = getRotatedFrameAABB(unsnapped);
+  const worldBox: FrameGeometry = {
+    x: aabb.left,
+    y: aabb.top,
+    width: aabb.width,
+    height: aabb.height,
+  };
+  // Min sizes are per-axis, so they swap with the axes at 90/270.
+  const worldSnapOptions =
+    nearestQuadrant % 2 === 1
+      ? {
+          ...snapOptions,
+          minWidth: snapOptions.minHeight,
+          minHeight: snapOptions.minWidth,
+        }
+      : snapOptions;
+
+  const snap = computeResizeSnap(
+    worldBox,
+    stationary,
+    worldHandle,
+    worldSnapOptions,
+  );
+  if (snap.guides.length === 0) {
+    return { frame: unsnapped, guides: [] };
+  }
+
+  // The snap moved the dragged world edge(s) of the AABB; express that
+  // movement as extra world pointer travel and recompute the rotated resize,
+  // so the anchor-fixing translation stays exact instead of being applied to
+  // an already-snapped box.
+  const snapDx = handleAffectsEast(worldHandle)
+    ? snap.frame.x + snap.frame.width - (worldBox.x + worldBox.width)
+    : handleAffectsWest(worldHandle)
+      ? snap.frame.x - worldBox.x
+      : 0;
+  const snapDy = handleAffectsSouth(worldHandle)
+    ? snap.frame.y + snap.frame.height - (worldBox.y + worldBox.height)
+    : handleAffectsNorth(worldHandle)
+      ? snap.frame.y - worldBox.y
+      : 0;
+
+  return {
+    frame: resizeRotatedFrameFromDelta(
+      origin,
+      handle,
+      worldDx + snapDx,
+      worldDy + snapDy,
+      options,
+    ),
+    guides: snap.guides,
+  };
+}
+
 /** The local (unrotated) point that a given resize handle keeps fixed: the
  *  edge/corner opposite the handle, or the center of an axis the handle
  *  doesn't affect at all (e.g. "n" leaves the horizontal axis untouched). */