@agent-native/core 0.182.1 → 0.182.2-nightly-20260917210345

package/corpus/templates/design/actions/create-file.ts

@@ -8,6 +8,7 @@ import { z } from "zod";
 import { getDb, schema } from "../server/db/index.js";
 import { mutateDesignData } from "../server/lib/design-data-mutation.js";
 import { snapshotDesignBeforeAgentEdit } from "../server/lib/design-versions.js";
+import { withDesignSourceMutationTransaction } from "../server/source-workspace.js";
 import {
   mergeCanvasFramePlacements,
   nextFreeCanvasRowY,
@@ -55,26 +56,6 @@ export default defineAction({
     await assertAccess("design", designId, "editor");
     await snapshotDesignBeforeAgentEdit(designId, context);
 
-    const db = getDb();
-
-    // Guard against duplicate (designId, filename) — edit-design uses .limit(1)
-    // which is non-deterministic when multiple rows match the same key.
-    const [existing] = await db
-      .select({ id: schema.designFiles.id })
-      .from(schema.designFiles)
-      .where(
-        and(
-          eq(schema.designFiles.designId, designId),
-          eq(schema.designFiles.filename, filename),
-        ),
-      )
-      .limit(1);
-    if (existing) {
-      throw new Error(
-        `File "${filename}" already exists in design ${designId} — use edit-design to modify it`,
-      );
-    }
-
     const id = nanoid();
     const now = new Date().toISOString();
 
@@ -92,24 +73,45 @@ export default defineAction({
       filename,
     });
 
-    await db.insert(schema.designFiles).values({
-      id,
-      designId,
-      filename,
-      fileType: fileType ?? "html",
-      content: annotatedContent,
-      createdAt: now,
-      updatedAt: now,
+    await withDesignSourceMutationTransaction(designId, async (tx) => {
+      // Guard against duplicate (designId, filename) inside the same
+      // transaction as the insert; the unique index remains the final guard.
+      const [existing] = await tx
+        .select({ id: schema.designFiles.id })
+        .from(schema.designFiles)
+        .where(
+          and(
+            eq(schema.designFiles.designId, designId),
+            eq(schema.designFiles.filename, filename),
+          ),
+        )
+        .limit(1);
+      if (existing) {
+        throw new Error(
+          `File "${filename}" already exists in design ${designId} — use edit-design to modify it`,
+        );
+      }
+
+      await tx.insert(schema.designFiles).values({
+        id,
+        designId,
+        filename,
+        fileType: fileType ?? "html",
+        content: annotatedContent,
+        createdAt: now,
+        updatedAt: now,
+      });
+
+      await tx
+        .update(schema.designs)
+        .set({ updatedAt: now })
+        .where(eq(schema.designs.id, designId));
     });
 
     // Seed collab state for the new file
     await seedFromText(id, annotatedContent);
 
-    // Update the design's updatedAt timestamp
-    await db
-      .update(schema.designs)
-      .set({ updatedAt: now })
-      .where(eq(schema.designs.id, designId));
+    const db = getDb();
 
     const resolvedFileType = fileType ?? "html";
     const renderable =

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

@@ -3,7 +3,8 @@ 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 { schema } from "../server/db/index.js";
+import { withDesignSourceMutationTransaction } from "../server/source-workspace.js";
 
 export default defineAction({
   description:
@@ -14,40 +15,40 @@ export default defineAction({
   run: async ({ id }) => {
     await assertAccess("design", id, "admin");
 
-    const db = getDb();
+    await withDesignSourceMutationTransaction(id, async (tx) => {
+      await tx
+        .delete(schema.designShares)
+        .where(eq(schema.designShares.resourceId, id));
 
-    await db
-      .delete(schema.designShares)
-      .where(eq(schema.designShares.resourceId, id));
+      await tx
+        .delete(schema.componentIndex)
+        .where(eq(schema.componentIndex.designId, id));
 
-    await db
-      .delete(schema.componentIndex)
-      .where(eq(schema.componentIndex.designId, id));
+      await tx
+        .delete(schema.motionTimeline)
+        .where(eq(schema.motionTimeline.designId, id));
 
-    await db
-      .delete(schema.motionTimeline)
-      .where(eq(schema.motionTimeline.designId, id));
+      await tx
+        .delete(schema.designState)
+        .where(eq(schema.designState.designId, id));
 
-    await db
-      .delete(schema.designState)
-      .where(eq(schema.designState.designId, id));
+      await tx
+        .delete(schema.designReviewSnapshot)
+        .where(eq(schema.designReviewSnapshot.designId, id));
 
-    await db
-      .delete(schema.designReviewSnapshot)
-      .where(eq(schema.designReviewSnapshot.designId, id));
+      // Delete associated files first
+      await tx
+        .delete(schema.designFiles)
+        .where(eq(schema.designFiles.designId, id));
 
-    // Delete associated files first
-    await db
-      .delete(schema.designFiles)
-      .where(eq(schema.designFiles.designId, id));
+      // Delete associated versions
+      await tx
+        .delete(schema.designVersions)
+        .where(eq(schema.designVersions.designId, id));
 
-    // Delete associated versions
-    await db
-      .delete(schema.designVersions)
-      .where(eq(schema.designVersions.designId, id));
-
-    // Delete the design itself
-    await db.delete(schema.designs).where(eq(schema.designs.id, id));
+      // Delete the design itself
+      await tx.delete(schema.designs).where(eq(schema.designs.id, id));
+    });
 
     return { id, deleted: true };
   },

package/corpus/templates/design/actions/delete-file.ts

@@ -1,11 +1,19 @@
 import { defineAction } from "@agent-native/core/action";
 import { accessFilter, assertAccess } from "@agent-native/core/sharing";
-import { and, eq } from "drizzle-orm";
+import { and, eq, sql } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
-import { mutateDesignData } from "../server/lib/design-data-mutation.js";
-import { snapshotDesignBeforeAgentEdit } from "../server/lib/design-versions.js";
+import {
+  snapshotDesignBeforeAgentEditInVersionLock,
+  withDesignVersionLock,
+} from "../server/lib/design-versions.js";
+import {
+  affectedRowCount,
+  designSourceMutationLockKey,
+  lockDesignFilesTable,
+} from "../server/source-workspace.js";
+import { isOverviewScreenFile } from "../shared/design-files.js";
 import { countLockedLayers } from "../shared/locked-layers.js";
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -61,6 +69,27 @@ function pruneDeletedFileMetadata(
   };
 }
 
+function nextUpdatedAt(current: string | null, now: Date): string {
+  const currentMs = current ? Date.parse(current) : Number.NaN;
+  return new Date(
+    Math.max(now.getTime(), Number.isFinite(currentMs) ? currentMs + 1 : 0),
+  ).toISOString();
+}
+
+function parseDesignData(
+  designId: string,
+  serialized: string | null,
+): Record<string, unknown> {
+  if (serialized === null) return {};
+  try {
+    const parsed: unknown = JSON.parse(serialized);
+    if (isRecord(parsed)) return parsed;
+  } catch {
+    throw new Error(`Design "${designId}" has invalid data JSON.`);
+  }
+  throw new Error(`Design "${designId}" has invalid data JSON.`);
+}
+
 export default defineAction({
   description:
     "Delete a file from a design project. Idempotent: if the file is already gone, returns deleted=false so cleanup retries can continue. Validates ownership via the parent design's access when the file exists.",
@@ -73,8 +102,14 @@ export default defineAction({
       .describe(
         "Delete the screen even though it holds locked layers. Only set this when the user explicitly asked for that screen to go.",
       ),
+    historyCheckpointId: z
+      .string()
+      .optional()
+      .describe(
+        "Existing frontend editor checkpoint to reuse for one grouped screen deletion.",
+      ),
   }),
-  run: async ({ id, allowLockedLayers }, context) => {
+  run: async ({ id, allowLockedLayers, historyCheckpointId }, context) => {
     const db = getDb();
 
     // Look up the file to get its designId for access check
@@ -82,6 +117,8 @@ export default defineAction({
       .select({
         id: schema.designFiles.id,
         designId: schema.designFiles.designId,
+        filename: schema.designFiles.filename,
+        fileType: schema.designFiles.fileType,
         content: schema.designFiles.content,
       })
       .from(schema.designFiles)
@@ -100,7 +137,6 @@ export default defineAction({
     if (!file) return { id, deleted: false, alreadyMissing: true };
 
     await assertAccess("design", file.designId, "editor");
-    await snapshotDesignBeforeAgentEdit(file.designId, context);
     // Locks exist to stop an agent destroying template branding in passing.
     // A person deleting their own screen has already decided, and every
     // template-backed screen carries locked layers — without this opt-in they
@@ -111,25 +147,120 @@ export default defineAction({
       );
     }
 
-    const pruneMetadata = () =>
-      mutateDesignData({
-        designId: file.designId,
-        mutate: (current, { updatedAt }) => ({
-          ...pruneDeletedFileMetadata(current, id),
-          updatedAt,
-        }),
-        isApplied: (current) =>
-          JSON.stringify(pruneDeletedFileMetadata(current, id)) ===
-          JSON.stringify(current),
-      });
+    if (historyCheckpointId !== undefined) {
+      if (context?.caller !== "frontend") {
+        throw new Error(
+          "A reusable editor history checkpoint is only valid for frontend deletes.",
+        );
+      }
+      const [checkpoint] = await db
+        .select({
+          id: schema.designVersions.id,
+          designId: schema.designVersions.designId,
+        })
+        .from(schema.designVersions)
+        .where(
+          and(
+            eq(schema.designVersions.id, historyCheckpointId),
+            eq(schema.designVersions.designId, file.designId),
+          ),
+        )
+        .limit(1);
+      if (!checkpoint) {
+        throw new Error(
+          "The editor history checkpoint is no longer available.",
+        );
+      }
+    }
+
+    // Restore locks the same design and updates file rows before designs.data.
+    // Keep the checkpoint and mutation under the same table/version boundary so
+    // history cannot capture a state that interleaves with the delete.
+    const deleted = await withDesignVersionLock(file.designId, async () => {
+      return db.transaction(async (tx) => {
+        await tx.execute(
+          sql`SELECT pg_advisory_xact_lock(hashtextextended(${designSourceMutationLockKey(file.designId)}, 0::bigint))`,
+        );
+        await lockDesignFilesTable(tx);
+        const currentFiles = await tx
+          .select({
+            id: schema.designFiles.id,
+            filename: schema.designFiles.filename,
+            fileType: schema.designFiles.fileType,
+          })
+          .from(schema.designFiles)
+          .where(eq(schema.designFiles.designId, file.designId))
+          .for("update");
+        const currentFile = currentFiles.find(
+          (candidate) => candidate.id === id,
+        );
+        if (!currentFile) return false;
+        if (
+          isOverviewScreenFile(currentFile) &&
+          currentFiles.filter(isOverviewScreenFile).length <= 1
+        ) {
+          throw new Error(
+            "A design must keep at least one user screen. Delete another screen first.",
+          );
+        }
+        if (historyCheckpointId === undefined) {
+          await snapshotDesignBeforeAgentEditInVersionLock(
+            file.designId,
+            context,
+            tx,
+          );
+        }
 
-    // Prune before deletion so a retry never loses the parent design id, then
-    // prune once more after deletion to close the small window where another
-    // editor could have refreshed metadata for the still-existing file.
-    await pruneMetadata();
-    await db.delete(schema.designFiles).where(eq(schema.designFiles.id, id));
-    await pruneMetadata();
+        const deleteResult = await tx
+          .delete(schema.designFiles)
+          .where(
+            and(
+              eq(schema.designFiles.id, id),
+              eq(schema.designFiles.designId, file.designId),
+            ),
+          );
+        const affected = affectedRowCount(deleteResult);
+        if (affected === 0) return false;
+        if (affected === undefined)
+          throw new Error("Could not verify that the design file was deleted.");
+        if (affected !== 1)
+          throw new Error("Unexpected design file delete result.");
+
+        const [design] = await tx
+          .select({
+            data: schema.designs.data,
+            updatedAt: schema.designs.updatedAt,
+          })
+          .from(schema.designs)
+          .where(eq(schema.designs.id, file.designId))
+          .for("update");
+        if (!design) throw new Error(`Design "${file.designId}" not found.`);
+
+        const updatedAt = nextUpdatedAt(design.updatedAt, new Date());
+        const data = pruneDeletedFileMetadata(
+          parseDesignData(file.designId, design.data),
+          id,
+        );
+        data.updatedAt = updatedAt;
+        const designUpdateResult = await tx
+          .update(schema.designs)
+          .set({ data: JSON.stringify(data), updatedAt })
+          .where(eq(schema.designs.id, file.designId));
+        const designAffected = affectedRowCount(designUpdateResult);
+        if (designAffected === undefined) {
+          throw new Error(
+            "Could not verify that the design metadata was updated.",
+          );
+        }
+        if (designAffected !== 1) {
+          throw new Error("Unexpected design metadata update result.");
+        }
+        return true;
+      });
+    });
 
-    return { id, deleted: true };
+    return deleted
+      ? { id, deleted: true }
+      : { id, deleted: false, alreadyMissing: true };
   },
 });

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

@@ -34,6 +34,7 @@ import { snapshotDesignBeforeAgentEdit } from "../server/lib/design-versions.js"
 import {
   readLiveSourceFile,
   SourceWorkspaceEditConflictError,
+  withDesignSourceMutationTransaction,
   writeInlineSourceFile,
   type SourceWorkspaceFile,
 } from "../server/source-workspace.js";
@@ -910,10 +911,19 @@ const generateDesignAction = defineAction({
             // 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));
+              await withDesignSourceMutationTransaction(
+                existing.designId,
+                (tx) =>
+                  tx
+                    .update(schema.designFiles)
+                    .set({ fileType: nextFileType, updatedAt: now })
+                    .where(
+                      and(
+                        eq(schema.designFiles.id, existing.id),
+                        eq(schema.designFiles.designId, existing.designId),
+                      ),
+                    ),
+              );
             }
           } finally {
             agentLeaveDocument(existing.id);
@@ -956,18 +966,20 @@ const generateDesignAction = defineAction({
       } else {
         // Create new file
         const fileId = nanoid();
-        await db.insert(schema.designFiles).values({
-          id: fileId,
-          designId,
-          filename: file.filename,
-          fileType: file.fileType ?? "html",
-          content: file.content,
-          contentOperationSource: null,
-          contentOperationRevision: null,
-          contentOperationResultHash: null,
-          createdAt: now,
-          updatedAt: now,
-        });
+        await withDesignSourceMutationTransaction(designId, (tx) =>
+          tx.insert(schema.designFiles).values({
+            id: fileId,
+            designId,
+            filename: file.filename,
+            fileType: file.fileType ?? "html",
+            content: file.content,
+            contentOperationSource: null,
+            contentOperationRevision: null,
+            contentOperationResultHash: null,
+            createdAt: now,
+            updatedAt: now,
+          }),
+        );
 
         // Publish agent presence for the new file before seeding.
         agentEnterDocument(fileId);