@agent-native/core 0.182.1-nightly-20260917183518 → 0.182.1

package/corpus/templates/design/server/lib/import-design-files.ts

@@ -4,8 +4,8 @@ import {
   hasCollabState,
   seedFromText,
 } from "@agent-native/core/collab";
-import { assertAccess } from "@agent-native/core/sharing";
-import { eq } from "drizzle-orm";
+import { assertAccess, resolveAccess } from "@agent-native/core/sharing";
+import { and, eq } from "drizzle-orm";
 import { nanoid } from "nanoid";
 
 import {
@@ -25,6 +25,8 @@ export interface ImportedDesignFile {
   filename: string;
   fileType: "html" | "css" | "jsx" | "asset";
   content: string;
+  /** Stable retry marker for a browser import request. */
+  operationSource?: string;
   source?: Record<string, unknown>;
   preferredFrame?: {
     title?: string;
@@ -50,6 +52,53 @@ export interface SavedImportedDesignFile {
   source?: Record<string, unknown>;
 }
 
+export async function findImportedDesignFileByOperationSource(
+  designId: string,
+  operationSource: string,
+): Promise<{
+  file: SavedImportedDesignFile;
+  placed: boolean;
+} | null> {
+  const access = await resolveAccess("design", designId);
+  if (!access) return null;
+  const db = getDb();
+  const [file] = await db
+    .select()
+    .from(schema.designFiles)
+    .where(
+      and(
+        eq(schema.designFiles.designId, designId),
+        eq(schema.designFiles.contentOperationSource, operationSource),
+      ),
+    )
+    .limit(1);
+  if (!file) return null;
+
+  let metadata: Record<string, unknown> | undefined;
+  try {
+    const parsed = access.resource.data
+      ? JSON.parse(access.resource.data)
+      : null;
+    const screenMetadata = isRecord(parsed) ? parsed.screenMetadata : null;
+    const candidate = isRecord(screenMetadata)
+      ? screenMetadata[file.id]
+      : undefined;
+    metadata = isRecord(candidate) ? candidate : undefined;
+  } catch {
+    metadata = undefined;
+  }
+
+  return {
+    file: {
+      id: file.id,
+      filename: file.filename,
+      fileType: file.fileType,
+      source: metadata,
+    },
+    placed: metadata?.operationSource === operationSource,
+  };
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -58,6 +107,12 @@ function jsonValuesEqual(left: unknown, right: unknown): boolean {
   return JSON.stringify(left) === JSON.stringify(right);
 }
 
+function isOperationSourceUniqueViolation(error: unknown): boolean {
+  return (error instanceof Error ? error.message : String(error)).includes(
+    "design_files_design_operation_source_unique_idx",
+  );
+}
+
 function nextImportedFrameZ(currentCanvasFrames: unknown): number {
   const currentFrames = parseCanvasFrameGeometryById(currentCanvasFrames);
   const currentFrameEntries = Object.values(currentFrames);
@@ -75,6 +130,20 @@ function nextImportedFrameZ(currentCanvasFrames: unknown): number {
   return Math.max(currentFrameEntries.length, highestPersistedZ + 1);
 }
 
+function nextImportedFrameX(currentCanvasFrames: unknown): number {
+  const currentFrames = Object.values(
+    parseCanvasFrameGeometryById(currentCanvasFrames),
+  );
+  const right = currentFrames.reduce((maxRight, frame) => {
+    const x = frame.x ?? 0;
+    const width = frame.width ?? 0;
+    return Number.isFinite(x) && Number.isFinite(width)
+      ? Math.max(maxRight, x + width)
+      : maxRight;
+  }, 0);
+  return currentFrames.length > 0 ? right + FRAME_GAP : 0;
+}
+
 function stringFromState(value: unknown, key: string): string | undefined {
   return isRecord(value) && typeof value[key] === "string"
     ? (value[key] as string)
@@ -228,87 +297,131 @@ export async function saveImportedDesignFiles(
     isApplied: () => true,
   });
 
-  await db.transaction(async (tx) => {
-    const [design] = await tx
-      .select()
-      .from(schema.designs)
-      .where(eq(schema.designs.id, designId))
-      .limit(1);
-    if (!design) throw new Error(`Design ${designId} was not found.`);
+  try {
+    await db.transaction(async (tx) => {
+      const [design] = await tx
+        .select()
+        .from(schema.designs)
+        .where(eq(schema.designs.id, designId))
+        .limit(1);
+      if (!design) throw new Error(`Design ${designId} was not found.`);
 
-    const existingFiles = await tx
-      .select()
-      .from(schema.designFiles)
-      .where(eq(schema.designFiles.designId, designId));
-    const usedFilenames = new Set(existingFiles.map((file) => file.filename));
-    let nextFrameX = 0;
+      const existingFiles = await tx
+        .select()
+        .from(schema.designFiles)
+        .where(eq(schema.designFiles.designId, designId));
+      const usedFilenames = new Set(existingFiles.map((file) => file.filename));
 
-    for (let index = 0; index < input.files.length; index += 1) {
-      const file = input.files[index]!;
-      const filename = uniqueFilename(
-        ensureExtension(sanitizeImportedFilename(file.filename), file.fileType),
-        usedFilenames,
-      );
-      const fileId = nanoid();
-      // Exact native clones are immutable source evidence. Other imports are
-      // annotated before persistence so editor operations can address nodes.
-      const annotatedContent = input.preserveExactContent
-        ? file.content
-        : annotateScreenHtmlForPersist(file.content, file.fileType);
-      await tx.insert(schema.designFiles).values({
-        id: fileId,
-        designId,
-        filename,
-        fileType: file.fileType,
-        content: annotatedContent,
-        createdAt: now,
-        updatedAt: now,
-      });
-      seedRecords.push({ id: fileId, content: annotatedContent });
+      for (let index = 0; index < input.files.length; index += 1) {
+        const file = input.files[index]!;
+        const [existing] = file.operationSource
+          ? await tx
+              .select()
+              .from(schema.designFiles)
+              .where(
+                and(
+                  eq(schema.designFiles.designId, designId),
+                  eq(
+                    schema.designFiles.contentOperationSource,
+                    file.operationSource,
+                  ),
+                ),
+              )
+              .limit(1)
+          : [];
+        const filename =
+          existing?.filename ??
+          uniqueFilename(
+            ensureExtension(
+              sanitizeImportedFilename(file.filename),
+              file.fileType,
+            ),
+            usedFilenames,
+          );
+        const fileId = existing?.id ?? nanoid();
+        // Exact native clones are immutable source evidence. Other imports are
+        // annotated before persistence so editor operations can address nodes.
+        const annotatedContent = input.preserveExactContent
+          ? file.content
+          : annotateScreenHtmlForPersist(file.content, file.fileType);
+        if (!existing) {
+          await tx.insert(schema.designFiles).values({
+            id: fileId,
+            designId,
+            filename,
+            fileType: file.fileType,
+            content: annotatedContent,
+            contentOperationSource: file.operationSource ?? null,
+            createdAt: now,
+            updatedAt: now,
+          });
+          seedRecords.push({ id: fileId, content: annotatedContent });
+        } else {
+          seedRecords.push({ id: fileId, content: existing.content });
+        }
 
-      const width = positiveDimension(
-        file.preferredFrame?.width,
-        DEFAULT_FRAME_WIDTH,
-      );
-      const height = positiveDimension(
-        file.preferredFrame?.height,
-        DEFAULT_FRAME_HEIGHT,
-      );
-      placements.push({
-        fileId,
-        filename,
-        x: file.preferredFrame?.x ?? nextFrameX,
-        y: file.preferredFrame?.y ?? 0,
-        width,
-        height,
-        z: index,
-      });
-      nextFrameX += width + FRAME_GAP;
-      const source = {
-        sourceType: input.sourceType,
-        previewState: "static",
-        title: file.preferredFrame?.title ?? filename.replace(/\.[^.]+$/, ""),
-        width,
-        height,
-        ...file.source,
-      };
-      metadataByFileId.set(fileId, source);
-      savedFiles.push({
-        id: fileId,
-        filename,
-        fileType: file.fileType,
-        source,
-      });
+        const width = positiveDimension(
+          file.preferredFrame?.width,
+          DEFAULT_FRAME_WIDTH,
+        );
+        const height = positiveDimension(
+          file.preferredFrame?.height,
+          DEFAULT_FRAME_HEIGHT,
+        );
+        placements.push({
+          fileId,
+          filename,
+          ...(file.preferredFrame?.x !== undefined
+            ? { x: file.preferredFrame.x }
+            : {}),
+          y: file.preferredFrame?.y ?? 0,
+          width,
+          height,
+          z: index,
+        });
+        const source = {
+          sourceType: input.sourceType,
+          previewState: "static",
+          title: file.preferredFrame?.title ?? filename.replace(/\.[^.]+$/, ""),
+          width,
+          height,
+          ...file.source,
+        };
+        metadataByFileId.set(fileId, source);
+        savedFiles.push({
+          id: fileId,
+          filename,
+          fileType: file.fileType,
+          source,
+        });
+      }
+    });
+  } catch (error) {
+    if (
+      input.files.some((file) => file.operationSource) &&
+      isOperationSourceUniqueViolation(error)
+    ) {
+      return saveImportedDesignFiles(input);
     }
-  });
+    throw error;
+  }
 
   await mutateDesignData({
     designId,
     mutate: (current, { updatedAt }) => {
-      placementsForPersistence = placements.map((placement, index) => ({
-        ...placement,
-        z: nextImportedFrameZ(current.canvasFrames) + index,
-      }));
+      let nextFrameX = nextImportedFrameX(current.canvasFrames);
+      placementsForPersistence = placements.map((placement, index) => {
+        const x = placement.x ?? nextFrameX;
+        nextFrameX = Math.max(
+          nextFrameX,
+          x + (placement.width ?? 0) + FRAME_GAP,
+        );
+        return {
+          ...placement,
+          x,
+          z: nextImportedFrameZ(current.canvasFrames) + index,
+        };
+      });
       const previousMetadata = isRecord(current.screenMetadata)
         ? { ...current.screenMetadata }
         : {};

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

@@ -419,13 +419,10 @@ CREATE INDEX IF NOT EXISTS design_versions_design_created_idx ON design_versions
  * 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.
+ * Best-effort unique indexes guarding cross-request insert races. Two
+ * concurrent calls can each see "no existing design_files row" from their
+ * own snapshot. The filename index protects localhost placement; the
+ * operation-source index protects retryable browser imports.
  *
  * This intentionally does NOT live in `runDesignMigrations` above:
  * `CREATE UNIQUE INDEX` fails outright against any database that already
@@ -456,6 +453,18 @@ async function ensureDesignFilesUniqueIndex(): Promise<void> {
       err instanceof Error ? err.message : err,
     );
   }
+  try {
+    await getDbExec().execute(
+      `CREATE UNIQUE INDEX IF NOT EXISTS design_files_design_operation_source_unique_idx ON design_files (design_id, content_operation_source) WHERE content_operation_source LIKE 'fig-import:%'`,
+    );
+  } catch (err) {
+    console.warn(
+      "[db] design_files_design_operation_source_unique_idx not created — " +
+        "pre-existing duplicate operation sources may require cleanup before " +
+        "concurrent browser-import retries are fully serialized:",
+      err instanceof Error ? err.message : err,
+    );
+  }
 }
 
 export default async (nitroApp: any): Promise<void> => {

package/corpus/templates/design/shared/fig-to-frames.ts

@@ -26,6 +26,8 @@ const MAX_FIG_NODES = 75_000;
 const MAX_FIG_IMAGES = 1_024;
 const MAX_FIG_FRAMES = 200;
 const MAX_FRAME_HTML_BYTES = 4 * 1024 * 1024;
+/** The browser action transport accepts smaller per-frame payloads. */
+export const MAX_FIG_FRAME_HTML_BYTES = 2 * 1024 * 1024;
 const MAX_TOTAL_HTML_BYTES = 24 * 1024 * 1024;
 const MAX_EMBEDDED_IMAGE_BYTES = 64 * 1024 * 1024;
 const IMAGE_UPLOAD_CONCURRENCY = 4;
@@ -34,6 +36,8 @@ const MAX_DURABLE_IMAGE_URL_CHARS = 2_048;
 export interface FigFileImportResult {
   files: ImportedDesignFile[];
   warnings: string[];
+  cleanup?: () => Promise<number>;
+  finalize?: () => Promise<number>;
   stats: {
     sourceKind: "fig-upload";
     format: "kiwi" | "zip";
@@ -78,7 +82,11 @@ export type ImageUploader = (input: {
   ownerEmail: string;
   recordAsset?: boolean;
   stableUrl?: boolean;
-}) => Promise<{ url?: string; cleanup?: () => Promise<boolean> } | null>;
+}) => Promise<{
+  url?: string;
+  cleanup?: () => Promise<boolean>;
+  finalize?: () => Promise<boolean>;
+} | null>;
 
 /** Wraps a frame's HTML into a standalone document. */
 export type HtmlNormalizer = (content: string, sourceLabel: string) => string;
@@ -182,6 +190,7 @@ async function uploadEmbeddedImages(
   omitted: number;
   warnings: string[];
   cleanup: () => Promise<number>;
+  finalize: () => Promise<number>;
 }> {
   assertEmbeddedImageBudget(images);
 
@@ -201,6 +210,7 @@ async function uploadEmbeddedImages(
   let omitted = 0;
   let storageUnavailable = false;
   const uploadCleanups: Array<() => Promise<boolean>> = [];
+  const uploadFinalizers: Array<() => Promise<boolean>> = [];
 
   for (
     let offset = 0;
@@ -224,6 +234,7 @@ async function uploadEmbeddedImages(
             stableUrl: true,
           });
           if (uploaded?.cleanup) uploadCleanups.push(uploaded.cleanup);
+          if (uploaded?.finalize) uploadFinalizers.push(uploaded.finalize);
           if (!uploaded?.url) {
             storageUnavailable = true;
             omitted += 1;
@@ -243,12 +254,6 @@ async function uploadEmbeddedImages(
     );
   }
 
-  if (omitted > 0) {
-    const message = `${omitted} embedded image${omitted === 1 ? " was" : "s were"} omitted because file storage was unavailable or rejected the upload. No image bytes were stored in SQL.`;
-    const cleanupFailures = await cleanupUploadedImages(uploadCleanups);
-    throw new Error(withCleanupFailures(message, cleanupFailures));
-  }
-
   return {
     imageMap,
     imageSizes,
@@ -256,6 +261,7 @@ async function uploadEmbeddedImages(
     omitted,
     warnings: [],
     cleanup: () => cleanupUploadedImages(uploadCleanups),
+    finalize: () => finalizeUploadedImages(uploadFinalizers),
   };
 }
 
@@ -270,12 +276,23 @@ async function cleanupUploadedImages(
   ).length;
 }
 
+async function finalizeUploadedImages(
+  finalizers: Array<() => Promise<boolean>>,
+): Promise<number> {
+  const results = await Promise.allSettled(
+    finalizers.map((finalize) => finalize()),
+  );
+  return results.filter(
+    (result) => result.status === "rejected" || !result.value,
+  ).length;
+}
+
 function withCleanupFailures(message: string, failures: number): string {
   if (failures === 0) return message;
   return `${message} Storage cleanup failed for ${failures} uploaded image${failures === 1 ? "" : "s"}.`;
 }
 
-function assertEmbeddedImageBudget(images: DecodedFigImage[]): void {
+export function assertEmbeddedImageBudget(images: DecodedFigImage[]): void {
   if (images.length > MAX_FIG_IMAGES) {
     throw new Error(".fig document has too many embedded images (max 1,024).");
   }
@@ -297,9 +314,11 @@ export async function convertDecodedFigToEditableHtml(
     ownerEmail: string;
     uploader: ImageUploader;
     normalizeHtml: HtmlNormalizer;
+    maxFrameHtmlBytes?: number;
     selection?: ReadonlySet<string>;
   },
 ): Promise<FigFileImportResult> {
+  const maxFrameHtmlBytes = options.maxFrameHtmlBytes ?? MAX_FRAME_HTML_BYTES;
   assertSafeDecodedFigDocument(decoded.document);
   const nodeChanges = nodeChangesFromDocument(
     decoded.document,
@@ -325,29 +344,36 @@ export async function convertDecodedFigToEditableHtml(
     trackUnresolvedImageRefs: true,
     selection,
   });
-  validateRenderedFrames(preliminary);
+  validateRenderedFrames(preliminary, maxFrameHtmlBytes);
   const imagesToUpload = selection
     ? decoded.images.filter((image) =>
         preliminary.unresolvedImageRefs?.has(image.hash),
       )
     : decoded.images;
-  const images = await uploadEmbeddedImages(
-    imagesToUpload,
-    options.ownerEmail,
-    options.uploader,
-  );
+  let images: Awaited<ReturnType<typeof uploadEmbeddedImages>> | undefined;
   try {
+    const uploadedImages = await uploadEmbeddedImages(
+      imagesToUpload,
+      options.ownerEmail,
+      options.uploader,
+    );
+    images = uploadedImages;
+    if (uploadedImages.omitted > 0) {
+      throw new Error(
+        `${uploadedImages.omitted} embedded image${uploadedImages.omitted === 1 ? " was" : "s were"} omitted because file storage was unavailable or rejected the upload. No image bytes were stored in SQL.`,
+      );
+    }
     const rendered =
       imagesToUpload.length === 0
         ? preliminary
         : renderHtmlTemplates(decoded.document, {
-            imageMap: images.imageMap,
-            imageSizes: images.imageSizes,
+            imageMap: uploadedImages.imageMap,
+            imageSizes: uploadedImages.imageSizes,
             missingImageUrl: "about:blank",
             trackUnresolvedImageRefs: true,
             selection,
           });
-    validateRenderedFrames(rendered);
+    validateRenderedFrames(rendered, maxFrameHtmlBytes);
 
     let totalHtmlBytes = 0;
     const files = rendered.frames.map((frame) => {
@@ -356,9 +382,9 @@ export async function convertDecodedFigToEditableHtml(
         `experimental .fig upload ${options.originalName}`,
       );
       const htmlBytes = utf8ByteLength(content);
-      if (htmlBytes > MAX_FRAME_HTML_BYTES) {
+      if (htmlBytes > maxFrameHtmlBytes) {
         throw new Error(
-          `.fig frame "${frame.frameName}" is too complex (generated HTML exceeds 4 MB).`,
+          `.fig frame "${frame.frameName}" is too complex (generated HTML exceeds ${Math.round(maxFrameHtmlBytes / 1024 / 1024)} MB).`,
         );
       }
       totalHtmlBytes += htmlBytes;
@@ -390,7 +416,9 @@ export async function convertDecodedFigToEditableHtml(
 
     return {
       files,
-      warnings: images.warnings,
+      warnings: uploadedImages.warnings,
+      cleanup: uploadedImages.cleanup,
+      finalize: uploadedImages.finalize,
       stats: {
         sourceKind: "fig-upload",
         format: decoded.format,
@@ -399,14 +427,14 @@ export async function convertDecodedFigToEditableHtml(
         frameCount: rendered.frameCount,
         nodeCount: nodeChanges.length,
         imageCount: decoded.images.length,
-        uploadedImageCount: images.uploaded,
-        omittedImageCount: images.omitted,
+        uploadedImageCount: uploadedImages.uploaded,
+        omittedImageCount: uploadedImages.omitted,
         approximatedNodeCount: rendered.approximatedNodes.length,
         unresolvedImageRefCount: rendered.unresolvedImageRefs?.size ?? 0,
       },
     };
   } catch (error) {
-    const cleanupFailures = await images.cleanup();
+    const cleanupFailures = images ? await images.cleanup() : 0;
     if (cleanupFailures === 0) throw error;
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(withCleanupFailures(message, cleanupFailures));
@@ -415,6 +443,7 @@ export async function convertDecodedFigToEditableHtml(
 
 function validateRenderedFrames(
   rendered: ReturnType<typeof renderHtmlTemplates>,
+  maxFrameHtmlBytes = MAX_FRAME_HTML_BYTES,
 ): void {
   if (rendered.frames.length === 0) {
     throw new Error(
@@ -427,9 +456,9 @@ function validateRenderedFrames(
   let total = 0;
   for (const frame of rendered.frames) {
     const bytes = utf8ByteLength(frame.html);
-    if (bytes > MAX_FRAME_HTML_BYTES) {
+    if (bytes > maxFrameHtmlBytes) {
       throw new Error(
-        `.fig frame "${frame.frameName}" is too complex (generated HTML exceeds 4 MB).`,
+        `.fig frame "${frame.frameName}" is too complex (generated HTML exceeds ${Math.round(maxFrameHtmlBytes / 1024 / 1024)} MB).`,
       );
     }
     total += bytes;
@@ -447,6 +476,7 @@ export async function importFigFileToEditableHtml(options: {
   ownerEmail: string;
   uploader: ImageUploader;
   normalizeHtml: HtmlNormalizer;
+  maxFrameHtmlBytes?: number;
 }): Promise<FigFileImportResult> {
   const decoded = decodeFig(options.data);
   return convertDecodedFigToEditableHtml(decoded, options);

package/corpus/templates/factory/CHANGELOG.md

@@ -3,6 +3,12 @@
 All notable user-facing changes to Chat are documented here. Open it any
 time from the command menu (Cmd+K → "What's new").
 
+## 2026-09-15
+
+### Fixed
+
+- Factory automation prompts version on save, show skill alignment separately, and stop duplicating injected blocks.
+
 ## 2026-09-14
 
 ### Improved

package/corpus/templates/mail/CHANGELOG.md

@@ -3,6 +3,12 @@
 All notable user-facing changes to Agent-Native Mail are documented here. Open it any
 time from the command menu (Cmd+K → "What's new") or from Settings.
 
+## 2026-09-17
+
+### Fixed
+
+- Mail undo keeps newer thread actions intact
+
 ## 2026-09-16
 
 ### Fixed

package/corpus/templates/slides/CHANGELOG.md

@@ -7,8 +7,20 @@ time from the command menu (Cmd+K → "What's new").
 
 ### Fixed
 
+- Allow keyboard nudges to move multiple selected slide layers together
+- Dragging slide elements keeps selection handles aligned and snap guides on the visual edges
+- Duplicating slides saves successfully when speaker notes are missing
+- Editing slide text preserves its formatting, layout, line breaks, and rich clipboard styles
+- Keep layout wrappers selectable around text blocks in Slides
+- Moving a multi-selection keeps bordered slide cards together
+- Slide content edits reject regex patterns that could freeze the editor
+- Slides keeps chat turns in order and restores the current slide context when you navigate or select.
 - Content-only agent edits now preserve the slide's existing backgrounds and styling.
 
+### Changed
+
+- Imported decks now support adding, deleting, and reordering slides
+
 ## 2026-09-15
 
 ### Improved

package/corpus/templates/slides/app/components/editor/AssetLibraryPanel.tsx

@@ -187,7 +187,7 @@ export default function AssetLibraryPanel({
           </span>
           <input
             type="file"
-            accept="image/*"
+            accept="image/*,.svg"
             multiple
             onChange={handleUpload}
             className="hidden"

package/corpus/templates/slides/app/components/editor/ImageDropPromptPopover.tsx

@@ -127,8 +127,7 @@ export default function ImageDropPromptPopover({
       const form = new FormData();
       form.append("file", file);
       // Prefer the hosted provider chain. When none is configured the route
-      // returns 503 — fall back to an inline data URL so the agent still gets
-      // the image (chat already accepts `images` data URLs).
+      // returns 503 — fall back to an inline data URL for inline-safe images.
       const res = await fetch(`${appBasePath()}/api/assets/upload`, {
         method: "POST",
         body: form,