@agent-native/core 0.88.0 → 0.90.2

package/corpus/templates/design/actions/edit-design.ts

@@ -1,9 +1,5 @@
 import { defineAction } from "@agent-native/core";
 import {
-  hasCollabState,
-  getText,
-  applyText,
-  seedFromText,
   agentEnterDocument,
   agentLeaveDocument,
   agentUpdateSelection,
@@ -13,6 +9,11 @@ import { and, eq } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
+import {
+  readLiveSourceFile,
+  writeInlineSourceFile,
+  type SourceWorkspaceFile,
+} from "../server/source-workspace.js";
 import {
   applyOneEdit,
   type ApplyEditsResult,
@@ -225,7 +226,6 @@ export default defineAction({
     await assertAccess("design", designId, "editor");
 
     const db = getDb();
-    const now = new Date().toISOString();
     const requestedFileId = fileId?.trim();
     const targetFilename = requestedFileId
       ? undefined
@@ -238,7 +238,9 @@ export default defineAction({
     const [file] = await db
       .select({
         id: schema.designFiles.id,
+        designId: schema.designFiles.designId,
         filename: schema.designFiles.filename,
+        fileType: schema.designFiles.fileType,
         content: schema.designFiles.content,
       })
       .from(schema.designFiles)
@@ -263,20 +265,26 @@ export default defineAction({
       );
     }
 
-    // Prefer live collab content so we edit in-flight changes, not a stale
-    // persisted copy (mirrors get-design-snapshot).
-    let base = file.content ?? "";
-    try {
-      if (await hasCollabState(file.id)) {
-        // When a collab session exists it is authoritative — use its text even
-        // if empty (a legitimately cleared file), rather than silently editing
-        // stale stored HTML.
-        const live = await getText(file.id, "content");
-        if (typeof live === "string") base = live;
-      }
-    } catch {
-      // Collab read is best-effort; fall back to stored content.
-    }
+    // Read the LIVE base (collab text when present, else the SQL row) right
+    // before transforming, and carry its versionHash through to the write
+    // below. writeInlineSourceFile re-reads the live text immediately before
+    // its own applyText/DB write and rejects if it no longer matches this
+    // hash — closing the race window where a concurrent editor/agent write
+    // lands between this read and the persist (the same stale-diff-base bug
+    // fixed for insert-design-native-asset.ts and insert-asset.ts: a diff
+    // computed from a stale base, char-diffed into a collab doc that has
+    // since moved on, corrupts or drops the other writer's change).
+    const workspaceFile: SourceWorkspaceFile = {
+      id: file.id,
+      designId: file.designId,
+      filename: file.filename ?? "",
+      fileType: file.fileType ?? "html",
+      content: file.content,
+      createdAt: null,
+      updatedAt: null,
+    };
+    const live = await readLiveSourceFile(workspaceFile);
+    const base = live.content;
 
     const resolvedMode =
       mode ??
@@ -296,8 +304,9 @@ export default defineAction({
       // rather than a fabricated `[data-edit-target=...]` selector that could
       // never resolve against the rendered iframe. Region attribution instead
       // rides on the `{ kind: "text", quote }` recentEdits descriptor that
-      // `applyText(..., "agent")` auto-publishes from the content diff below —
-      // clients render a lingering highlight over the changed text.
+      // `applyText(..., "agent")` auto-publishes from the content diff inside
+      // writeInlineSourceFile below — clients render a lingering highlight
+      // over the changed text.
       agentEnterDocument(file.id);
       agentUpdateSelection(file.id, {
         selection: null,
@@ -306,23 +315,12 @@ export default defineAction({
       });
 
       try {
-        await db
-          .update(schema.designFiles)
-          .set({ content: nextContent, updatedAt: now })
-          .where(eq(schema.designFiles.id, file.id));
-
-        // Push the full new content through the collab layer; it diffs internally
-        // so live editors get a minimal update.
-        if (await hasCollabState(file.id)) {
-          await applyText(file.id, nextContent, "content", "agent");
-        } else {
-          await seedFromText(file.id, nextContent);
-        }
-
-        await db
-          .update(schema.designs)
-          .set({ updatedAt: now })
-          .where(eq(schema.designs.id, designId));
+        await writeInlineSourceFile({
+          designId: file.designId,
+          file: workspaceFile,
+          content: nextContent,
+          expectedVersionHash: live.versionHash,
+        });
       } finally {
         agentLeaveDocument(file.id);
       }

package/corpus/templates/design/actions/generate-design-title.ts

@@ -0,0 +1,87 @@
+import { defineAction } from "@agent-native/core";
+import { completeText } from "@agent-native/core/server";
+import { assertAccess } from "@agent-native/core/sharing";
+import { eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import { sanitizeGeneratedDesignTitle } from "../shared/prompt-title.js";
+
+const TITLE_SYSTEM_PROMPT =
+  "Generate a very short title (2-5 words) for a design/prototype that " +
+  "starts from this brief. Title Case, no quotes, no trailing punctuation. " +
+  "Return only the title, nothing else.";
+
+export default defineAction({
+  description:
+    "Generate a concise, human-friendly title for a design from its " +
+    "generation prompt and save it. Internal plumbing used right after a " +
+    "design is created from the prompt box — not a step in the normal " +
+    "design-generation flow, so agents should not call this directly.",
+  // UI-only plumbing: callable via the frontend action surface, hidden from
+  // the agent/MCP/A2A tool lists so it doesn't spend a tool-call slot.
+  agentTool: false,
+  schema: z.object({
+    designId: z.string().describe("Design ID to update"),
+    prompt: z.string().describe("The user's original generation prompt"),
+    previousTitle: z
+      .string()
+      .optional()
+      .describe(
+        "The placeholder title written when the design was created. If the " +
+          "design's current title no longer matches this (the user renamed " +
+          "it in the meantime), the generated title is discarded.",
+      ),
+  }),
+  run: async ({ designId, prompt, previousTitle }) => {
+    await assertAccess("design", designId, "editor");
+
+    const cleanPrompt = prompt.replace(/\s+/g, " ").trim().slice(0, 2000);
+    if (!cleanPrompt) return { updated: false, reason: "empty-prompt" };
+
+    let generated: string | null = null;
+    try {
+      const result = await completeText({
+        systemPrompt: TITLE_SYSTEM_PROMPT,
+        input: cleanPrompt.slice(0, 500),
+        maxOutputTokens: 30,
+        temperature: 0.3,
+        timeoutMs: 15_000,
+      });
+      generated = sanitizeGeneratedDesignTitle(result.text);
+    } catch {
+      // Best-effort: the placeholder title (already saved at creation time)
+      // stays as-is on any model/engine failure.
+      return { updated: false, reason: "generation-failed" };
+    }
+
+    if (!generated) return { updated: false, reason: "empty-result" };
+
+    const db = getDb();
+    const now = new Date().toISOString();
+
+    // Read-then-write inside one transaction so we only overwrite the
+    // placeholder title — never a title the user already changed in the
+    // meantime (manual rename racing this background call).
+    const outcome = await db.transaction(async (tx) => {
+      const [current] = await tx
+        .select({ title: schema.designs.title })
+        .from(schema.designs)
+        .where(eq(schema.designs.id, designId));
+
+      if (!current) return { updated: false, reason: "not-found" as const };
+      if (previousTitle !== undefined && current.title !== previousTitle) {
+        return { updated: false, reason: "title-changed" as const };
+      }
+
+      await tx
+        .update(schema.designs)
+        .set({ title: generated, updatedAt: now })
+        .where(eq(schema.designs.id, designId));
+
+      return { updated: true as const, title: generated };
+    });
+
+    return outcome;
+  },
+});

package/corpus/templates/design/actions/generate-design.ts

@@ -4,8 +4,6 @@ import {
   writeAppState,
 } from "@agent-native/core/application-state";
 import {
-  hasCollabState,
-  applyText,
   seedFromText,
   agentEnterDocument,
   agentLeaveDocument,
@@ -18,6 +16,11 @@ import { nanoid } from "nanoid";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
+import {
+  readLiveSourceFile,
+  writeInlineSourceFile,
+  type SourceWorkspaceFile,
+} from "../server/source-workspace.js";
 import {
   mergeCanvasFramePlacements,
   type CanvasFramePlacement,
@@ -27,6 +30,7 @@ import {
   type DesignGenerationSession,
   updateGenerationSessionWithSavedFiles,
 } from "../shared/generation-session.js";
+import { annotateScreenHtmlForPersist } from "../shared/screen-annotation.js";
 
 /** Editor deep link so external agents can surface "Open design". */
 function designDeepLink(designId: string): string {
@@ -287,7 +291,16 @@ const generateDesignAction = defineAction({
 
     const existingByName = new Map(existingFiles.map((f) => [f.filename, f]));
 
-    for (const file of files) {
+    // Stamp missing data-agent-native-node-id attributes before persisting so
+    // every generated screen is born fully addressable by id-keyed editor
+    // operations (move/select/style), instead of depending on a client-side
+    // backfill the first time a human opens the screen.
+    const annotatedFiles = files.map((file) => ({
+      ...file,
+      content: annotateScreenHtmlForPersist(file.content, file.fileType),
+    }));
+
+    for (const file of annotatedFiles) {
       const existing = existingByName.get(file.filename);
       if (existing) {
         // Publish agent presence so live editors see "AI is generating" in place.
@@ -298,22 +311,44 @@ const generateDesignAction = defineAction({
         });
 
         try {
-          // Update existing file
-          await db
-            .update(schema.designFiles)
-            .set({
-              content: file.content,
-              fileType: file.fileType ?? "html",
-              updatedAt: now,
-            })
-            .where(eq(schema.designFiles.id, existing.id));
+          // `file.content` here is LLM-generated content produced upstream of
+          // this action call, so there can be a large async window (the full
+          // generation time) between whenever this file's content was last
+          // known and this write. Read the LIVE base (collab text when
+          // present, else the SQL row) right before persisting and carry its
+          // versionHash through to writeInlineSourceFile, which re-reads the
+          // live text immediately before its own applyText/DB write and
+          // rejects if it no longer matches — closing the race window where a
+          // concurrent editor/agent write lands mid-generation. See
+          // insert-design-native-asset.ts and insert-asset.ts for the
+          // identical pattern.
+          const workspaceFile: SourceWorkspaceFile = {
+            id: existing.id,
+            designId: existing.designId,
+            filename: existing.filename ?? "",
+            fileType: existing.fileType ?? "html",
+            content: existing.content,
+            createdAt: null,
+            updatedAt: null,
+          };
+          const live = await readLiveSourceFile(workspaceFile);
+
+          await writeInlineSourceFile({
+            designId: existing.designId,
+            file: workspaceFile,
+            content: file.content,
+            expectedVersionHash: live.versionHash,
+          });
 
-          // Push content through collab layer for live editors
-          const collabExists = await hasCollabState(existing.id);
-          if (collabExists) {
-            await applyText(existing.id, file.content, "content", "agent");
-          } else {
-            await seedFromText(existing.id, file.content);
+          // writeInlineSourceFile only persists content/updatedAt; keep
+          // fileType in sync separately when the caller changed it (e.g.
+          // html -> jsx), matching the original update behavior.
+          const nextFileType = file.fileType ?? "html";
+          if (nextFileType !== (existing.fileType ?? "html")) {
+            await db
+              .update(schema.designFiles)
+              .set({ fileType: nextFileType, updatedAt: now })
+              .where(eq(schema.designFiles.id, existing.id));
           }
         } finally {
           agentLeaveDocument(existing.id);

package/corpus/templates/design/actions/generate-screens.ts

@@ -6,13 +6,87 @@ import { nanoid } from "nanoid";
 import { z } from "zod";
 
 import "../server/db/index.js";
-import { assignRegions } from "../shared/canvas-math.js";
+import {
+  type AssignedCanvasRegion,
+  DEFAULT_ASSIGNED_REGION_GAP,
+  DEFAULT_ASSIGNED_REGION_MAX_COLUMNS,
+} from "../shared/canvas-math.js";
 import {
   designGenerationSessionKey,
   type DesignGenerationFrame,
   type DesignGenerationSession,
 } from "../shared/generation-session.js";
 
+// Mirrors the mobile/tablet/desktop viewport vocabulary already used by
+// present-design-variants.ts's inferVariantSize, so a screen's canvas region
+// matches its intended device instead of every screen defaulting to the same
+// fixed desktop-shaped region regardless of content (B5-10: AI-generated
+// desktop designs were being placed in mobile-width screens because neither
+// this schema nor assignRegions had any per-screen size signal).
+const DEVICE_REGION_SIZE: Record<
+  "mobile" | "tablet" | "desktop",
+  { width: number; height: number }
+> = {
+  mobile: { width: 390, height: 844 },
+  tablet: { width: 768, height: 1024 },
+  desktop: { width: 1440, height: 1024 },
+};
+
+function regionSizeForScreen(screen: {
+  deviceType?: "mobile" | "tablet" | "desktop";
+  width?: number;
+  height?: number;
+}): { width: number; height: number } {
+  const base = DEVICE_REGION_SIZE[screen.deviceType ?? "desktop"];
+  return {
+    width: screen.width && screen.width > 0 ? screen.width : base.width,
+    height: screen.height && screen.height > 0 ? screen.height : base.height,
+  };
+}
+
+/**
+ * Pack per-screen-sized regions into rows/columns, matching assignRegions'
+ * layout shape (row/column-major, one gap between cells) but sizing each
+ * region individually instead of assuming every region is the same fixed
+ * size. Row height is the tallest region in that row, mirroring how
+ * assignRegions would behave if every item in a row shared one size.
+ */
+function assignRegionsForSizes(
+  sizes: Array<{ width: number; height: number }>,
+  {
+    columns,
+    gap = DEFAULT_ASSIGNED_REGION_GAP,
+  }: { columns: number; gap?: number },
+): AssignedCanvasRegion[] {
+  const regions: AssignedCanvasRegion[] = [];
+  let rowY = 0;
+
+  for (let rowStart = 0; rowStart < sizes.length; rowStart += columns) {
+    const row = sizes.slice(rowStart, rowStart + columns);
+    let x = 0;
+    let rowHeight = 0;
+
+    row.forEach((size, offset) => {
+      const index = rowStart + offset;
+      regions.push({
+        index,
+        row: Math.floor(index / columns),
+        column: index % columns,
+        x,
+        y: rowY,
+        width: size.width,
+        height: size.height,
+      });
+      x += size.width + gap;
+      rowHeight = Math.max(rowHeight, size.height);
+    });
+
+    rowY += rowHeight + gap;
+  }
+
+  return regions;
+}
+
 const AGENT_NAMES = [
   "Atlas",
   "Nova",
@@ -52,6 +126,29 @@ const requestedScreenSchema = z
       .describe("Target filename for this screen, such as onboarding.html"),
     role: z.enum(["screen", "variant"]).optional().default("screen"),
     variantOf: z.string().trim().min(1).optional(),
+    deviceType: z
+      .enum(["mobile", "tablet", "desktop"])
+      .optional()
+      .describe(
+        "Intended viewport for this screen. Defaults to desktop-sized when " +
+          "omitted — pass 'mobile' for phone screens and 'tablet' for iPad-" +
+          "width screens so the canvas region matches the content instead of " +
+          "always sizing every screen as desktop.",
+      ),
+    width: z
+      .number()
+      .positive()
+      .optional()
+      .describe(
+        "Optional explicit canvas region width in px, overriding deviceType.",
+      ),
+    height: z
+      .number()
+      .positive()
+      .optional()
+      .describe(
+        "Optional explicit canvas region height in px, overriding deviceType.",
+      ),
   })
   .superRefine((screen, ctx) => {
     if (screen.role === "variant" && !screen.variantOf) {
@@ -71,6 +168,10 @@ export default defineAction({
     "assigns non-overlapping canvas regions and returns per-frame generation " +
     "instructions including canvasFrame placements. The session state is " +
     "agent-facing planning state consumed by generate-design and view-screen. " +
+    "Pass each screen's deviceType ('mobile', 'tablet', or 'desktop') so its " +
+    "canvas region matches the content — a desktop dashboard should not be " +
+    "boxed into a 390px mobile-width frame. Defaults to desktop when omitted; " +
+    "pass explicit width/height instead for a non-standard viewport. " +
     "After this action, fan out calls to generate-design for each returned " +
     "frame, passing the returned canvasFrame values to generate-design so " +
     "screens appear in the infinite overview canvas.",
@@ -150,9 +251,12 @@ export default defineAction({
       await assertAccess("design-system", designSystemId, "viewer");
     }
 
-    const regions = assignRegions(screens.length, {
-      origin: { x: 0, y: 0 },
-      columns: screens.length <= 3 ? screens.length : 3,
+    const regionSizes = screens.map(regionSizeForScreen);
+    const regions = assignRegionsForSizes(regionSizes, {
+      columns:
+        screens.length <= 3
+          ? screens.length
+          : DEFAULT_ASSIGNED_REGION_MAX_COLUMNS,
     });
 
     const seenFilenames = new Map<string, number>();

package/corpus/templates/design/actions/get-motion-timeline.ts

@@ -10,8 +10,17 @@ import {
   hashCss,
   parse,
   parseFirstAnimationDurationMs,
+  parsePlaybackMode,
+  parseTimelineSpanMs,
 } from "../shared/motion-compiler.js";
-import type { MotionTrack } from "../shared/motion-timeline.js";
+import type {
+  MotionPlaybackMode,
+  MotionTrack,
+} from "../shared/motion-timeline.js";
+import {
+  MOTION_DEFAULT_PLAYBACK_MODE,
+  readTimelinePlaybackMode,
+} from "../shared/motion-timeline.js";
 
 type TimelineSource = "stored" | "recovered-css" | "stored-css-drift";
 
@@ -22,6 +31,12 @@ interface TimelineResult {
   filePath: string | null;
   tracks: unknown;
   durationMs: number;
+  /**
+   * Timeline playback mode: from the tracks JSON stamp for stored rows,
+   * recovered from animation-iteration-count/direction for CSS-recovered
+   * timelines, "once" for timelines that predate the field.
+   */
+  playbackMode: MotionPlaybackMode;
   defaultEase: string;
   compiledHash: string | null;
   cssHash?: string | null;
@@ -47,6 +62,7 @@ async function readManagedCssForSource(args: {
   hash: string;
   tracks: MotionTrack[];
   durationMs: number | null;
+  playbackMode: MotionPlaybackMode | null;
 } | null> {
   if (!args.sourceRef) return null;
 
@@ -88,7 +104,10 @@ async function readManagedCssForSource(args: {
     css,
     hash: hashCss(css),
     tracks,
-    durationMs: parseFirstAnimationDurationMs(css),
+    // Timeline span (max delay + duration) is robust when tracks carry
+    // per-track offsets/durations; fall back to the first duration.
+    durationMs: parseTimelineSpanMs(css) ?? parseFirstAnimationDurationMs(css),
+    playbackMode: parsePlaybackMode(css),
   };
 }
 
@@ -96,10 +115,13 @@ export default defineAction({
   description:
     "Read one or all motion timelines for a design. " +
     "Returns timeline metadata (id, sourceRef, filePath, durationMs, " +
-    "defaultEase, compiledHash) and the full tracks array (each track has " +
-    "targetNodeId, property, and keyframes). If sourceRef points at a design " +
-    "file and the metadata is missing or stale, recovers editable tracks from " +
-    "the managed <style data-agent-native-motion> block. Read-only.",
+    "playbackMode [loop|once|ping-pong], defaultEase, compiledHash) and the " +
+    "full tracks array (each track has targetNodeId, property, keyframes " +
+    "with per-segment easing incl. spring(...)/linear(...), and optional " +
+    "delayMs/durationMs start-offset timing). If sourceRef points at a " +
+    "design file and the metadata is missing or stale, recovers editable " +
+    "tracks (incl. offsets and playback mode) from the managed " +
+    "<style data-agent-native-motion> block. Read-only.",
   readOnly: true,
   http: { method: "GET" },
   schema: z.object({
@@ -151,13 +173,17 @@ export default defineAction({
       .limit(timelineId ? 1 : 100);
 
     const timelines: TimelineResult[] = rows.map((row) => {
+      const parsedTracks = parseTrackJson(row.tracks);
       return {
         id: row.id,
         designId: row.designId,
         sourceRef: row.sourceRef ?? null,
         filePath: row.filePath ?? null,
-        tracks: parseTrackJson(row.tracks),
+        tracks: parsedTracks,
         durationMs: row.durationMs,
+        playbackMode:
+          readTimelinePlaybackMode(parsedTracks) ??
+          MOTION_DEFAULT_PLAYBACK_MODE,
         defaultEase: row.defaultEase,
         compiledHash: row.compiledHash ?? null,
         cssHash: null,
@@ -183,6 +209,7 @@ export default defineAction({
           // Recover the compiled animation-duration instead of inventing a
           // default the next save would silently persist.
           durationMs: managedCss.durationMs ?? 1000,
+          playbackMode: managedCss.playbackMode ?? MOTION_DEFAULT_PLAYBACK_MODE,
           defaultEase: "ease",
           compiledHash: managedCss.hash,
           cssHash: managedCss.hash,
@@ -197,6 +224,7 @@ export default defineAction({
           // In the drift case the CSS is the runtime truth — surface its
           // compiled duration alongside its recovered tracks.
           durationMs: managedCss.durationMs ?? first.durationMs,
+          playbackMode: managedCss.playbackMode ?? first.playbackMode,
           cssHash: managedCss.hash,
           source: "stored-css-drift",
         };

package/corpus/templates/design/actions/import-design-source.ts

@@ -2,14 +2,12 @@ import { defineAction } from "@agent-native/core";
 import { assertAccess } from "@agent-native/core/sharing";
 import { z } from "zod";
 
-import { parseFigmaClipboardHtml } from "../server/lib/figma-import/clipboard.js";
-import { importFigmaBuffer } from "../server/lib/figma-import/processor.js";
 import {
   normalizeImportedHtmlDocument,
   resolveImportDesignId,
   saveImportedDesignFiles,
-  type ImportedDesignFile,
 } from "../server/lib/import-design-files.js";
+import { parseVisibleClipboardHtml } from "../server/lib/visible-clipboard-html.js";
 
 const MAX_HTML_IMPORT_BYTES = 2 * 1024 * 1024;
 
@@ -25,7 +23,7 @@ function baseFilename(originalName: string | undefined, fallback: string) {
 
 export default defineAction({
   description:
-    "Import Figma clipboard HTML or standalone HTML into the current Design project as one or more editable screens.",
+    "Import visible clipboard HTML or standalone HTML into the current Design project as an editable screen.",
   schema: z.object({
     designId: z
       .string()
@@ -64,84 +62,36 @@ export default defineAction({
       };
     }
 
-    const parsed = parseFigmaClipboardHtml(content);
-    const warnings: string[] = [];
-    if (parsed.buffer && parsed.hasFigmaBuffer) {
-      try {
-        const imported = await importFigmaBuffer({
-          buffer: parsed.buffer,
-          filename: originalName ?? "figma-paste.fig",
-          sourceKind: "figma-paste",
-          selection: { nodeId: parsed.meta?.selectedNodeId },
-          meta: parsed.meta,
-        });
-        const files: ImportedDesignFile[] = imported.files.map((file) => ({
-          filename: file.filename,
-          fileType: "html",
-          content: file.content,
-          source: file.source,
-          preferredFrame: {
-            title:
-              typeof file.source?.frameName === "string"
-                ? file.source.frameName
-                : undefined,
-            width: file.width,
-            height: file.height,
-          },
-        }));
-        const saved = await saveImportedDesignFiles({
-          designId: resolvedDesignId,
-          sourceType: "figma-paste",
-          files,
-          warnings: [...warnings, ...imported.warnings],
-        });
-        return { ...saved, stats: imported.stats };
-      } catch (error) {
-        warnings.push(
-          error instanceof Error
-            ? `Figma binary payload could not be decoded: ${error.message}`
-            : "Figma binary payload could not be decoded.",
-        );
-      }
-    } else if (parsed.buffer) {
-      warnings.push(
-        "The clipboard included a Figma buffer, but it was not a supported fig-kiwi payload.",
-      );
-    }
-
+    const parsed = parseVisibleClipboardHtml(content);
     if (!parsed.fallbackHtml) {
       throw new Error(
-        "No importable Figma frame data or visible HTML was found in the clipboard.",
+        "No visible HTML was found in the clipboard. Copy a frame, then paste into the canvas.",
       );
     }
     const saved = await saveImportedDesignFiles({
       designId: resolvedDesignId,
-      sourceType: "figma-paste-fallback",
+      sourceType: "figma-paste-html",
       files: [
         {
           filename: baseFilename(originalName, "figma-paste"),
           fileType: "html",
           content: normalizeImportedHtmlDocument(
             parsed.fallbackHtml,
-            "Figma clipboard fallback HTML",
+            "visible clipboard HTML",
           ),
           source: {
-            sourceType: "figma-paste-fallback",
-            selectedNodeId: parsed.meta?.selectedNodeId,
-            fileKey: parsed.meta?.fileKey,
+            sourceType: "figma-paste-html",
           },
         },
       ],
-      warnings,
     });
     return {
       ...saved,
       stats: {
         sourceKind: "figma-paste",
-        format: "html-fallback",
+        format: "html",
         frameCount: saved.files.length,
         imageCount: 0,
-        selectedNodeId: parsed.meta?.selectedNodeId,
       },
     };
   },