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

package/corpus/templates/design/server/lib/design-snapshot.ts

@@ -43,6 +43,13 @@ export interface DesignSnapshot {
   resolvedCssVars: Record<string, string>;
 }
 
+export interface BuildDesignSnapshotOptions {
+  /** Read the persisted SQL rows even when a live collaboration document exists. */
+  preferStoredFileContent?: boolean;
+}
+
+type SnapshotDatabase = Pick<ReturnType<typeof getDb>, "select">;
+
 function parseDesignData(data?: string | null): Record<string, unknown> {
   if (!data) return {};
   try {
@@ -62,8 +69,10 @@ function parseDesignData(data?: string | null): Record<string, unknown> {
 export async function buildDesignSnapshot(
   designId: string,
   designData?: string | null,
+  options: BuildDesignSnapshotOptions = {},
+  database?: SnapshotDatabase,
 ): Promise<DesignSnapshot> {
-  const db = getDb();
+  const db = database ?? getDb();
 
   const rows = await db
     .select()
@@ -76,23 +85,26 @@ export async function buildDesignSnapshot(
     let source: "collab" | "stored" = "stored";
     // Prefer live collab text when an editing session exists for this file so
     // an external agent sees in-flight edits, not the last persisted snapshot.
-    try {
-      if (await hasCollabState(f.id)) {
-        const live = await getText(f.id, "content");
-        if (
-          typeof live === "string" &&
-          shouldUseLiveFileContent({
-            liveContent: live,
-            storedContent: f.content,
-            fileType: f.fileType,
-          })
-        ) {
-          content = live;
-          source = "collab";
+    if (!options.preferStoredFileContent) {
+      try {
+        if (await hasCollabState(f.id)) {
+          const live = await getText(f.id, "content");
+          if (
+            typeof live === "string" &&
+            shouldUseLiveFileContent({
+              liveContent: live,
+              storedContent: f.content,
+              fileType: f.fileType,
+            })
+          ) {
+            content = live;
+            source = "collab";
+          }
         }
+      } catch {
+        // coercion-ok: live collaboration is optional; stored content remains explicitly tagged.
+        // Collab read is best-effort; fall back to stored content.
       }
-    } catch {
-      // Collab read is best-effort; fall back to stored content.
     }
     files.push({
       id: f.id,

package/corpus/templates/design/server/lib/design-versions.ts

@@ -16,8 +16,8 @@ import {
   type PrivateBlobHandle,
 } from "@agent-native/core/private-blob";
 import { getRequestUserEmail } from "@agent-native/core/server/request-context";
-import { assertAccess } from "@agent-native/core/sharing";
-import { and, asc, desc, eq, isNull } from "drizzle-orm";
+import { accessFilter, assertAccess } from "@agent-native/core/sharing";
+import { and, asc, desc, eq, isNull, sql } from "drizzle-orm";
 import { nanoid } from "nanoid";
 
 import {
@@ -25,7 +25,12 @@ import {
   type ComponentDeletionGeometry,
 } from "../../shared/component-archive.js";
 import { getDb, schema } from "../db/index.js";
-import { withSourceFileWriteLock } from "../source-workspace.js";
+import {
+  affectedRowCount,
+  designSourceMutationLockKey,
+  lockDesignFilesTable,
+  withSourceFileWriteLock,
+} from "../source-workspace.js";
 import { buildDesignSnapshot } from "./design-snapshot.js";
 
 const CHAT_VERSION_LOOKBACK = 100;
@@ -36,6 +41,7 @@ export interface DesignVersionChatContext {
   runId?: string;
   turnId?: string;
   actionName?: string;
+  surface?: "editor";
 }
 
 export interface DesignVersionFile {
@@ -66,7 +72,7 @@ export interface DesignVersionListEntry {
   designId: string;
   label: string | null;
   createdAt: string | null;
-  source: "chat" | "legacy";
+  source: "chat" | "editor" | "legacy";
   fileCount: number;
   chatContext: DesignVersionChatContext | null;
   editable: boolean;
@@ -136,6 +142,7 @@ function parseChatContext(
       context[key] = candidate;
     }
   }
+  if (value.surface === "editor") context.surface = "editor";
   return Object.keys(context).length > 0 ? context : undefined;
 }
 
@@ -337,9 +344,9 @@ export async function readDesignVersionSnapshot(
 }
 
 function chatContextKey(
-  context: DesignVersionChatContext | undefined,
+  context: DesignVersionChatContext | null | undefined,
 ): string | null {
-  if (!context) return null;
+  if (!context || context.surface === "editor") return null;
   const scope = context.threadId ?? "";
   const turn = context.turnId ?? context.runId ?? "";
   return turn ? `${scope}:${turn}` : null;
@@ -358,6 +365,18 @@ function actionChatContext(
   };
 }
 
+function editorActionContext(
+  context: ActionRunContext,
+): DesignVersionChatContext | null {
+  if (context.caller !== "frontend" && context.caller !== "webmcp") {
+    return null;
+  }
+  return {
+    surface: "editor",
+    ...(context.actionName ? { actionName: context.actionName } : {}),
+  };
+}
+
 function versionTime(value: string | null): number {
   if (!value) return 0;
   const timestamp = Date.parse(value);
@@ -372,18 +391,6 @@ function nextUpdatedAt(current: string | null, now: Date): string {
   return new Date(nextMs).toISOString();
 }
 
-function affectedRowCount(result: unknown): number | undefined {
-  if (!result || typeof result !== "object") return undefined;
-  const candidate = result as {
-    rowsAffected?: unknown;
-    rowCount?: unknown;
-    changes?: unknown;
-  };
-  const value =
-    candidate.rowsAffected ?? candidate.rowCount ?? candidate.changes;
-  return typeof value === "number" ? value : undefined;
-}
-
 function designFileRevisionWhere(file: {
   id: string;
   designId: string;
@@ -448,10 +455,13 @@ async function assertNoUnpersistedCollaborativeEdits(
   designId: string,
   storedFiles: ReadonlyArray<{ id: string; content: string }>,
   designData?: string | null,
+  database?: DesignDatabase,
 ): Promise<void> {
   let liveSnapshot;
   try {
-    liveSnapshot = await buildDesignSnapshot(designId, designData);
+    liveSnapshot = database
+      ? await buildDesignSnapshot(designId, designData, {}, database)
+      : await buildDesignSnapshot(designId, designData);
   } catch {
     throw new DesignVersionRestoreConflictError(
       "Design history cannot verify live editing state right now. Refresh and try again.",
@@ -483,6 +493,7 @@ async function withDesignFileLocks<T>(
 }
 
 type DesignAccess = Awaited<ReturnType<typeof assertAccess>>;
+type DesignDatabase = Pick<ReturnType<typeof getDb>, "select" | "insert">;
 
 const designVersionLocks = new Map<string, Promise<unknown>>();
 
@@ -492,10 +503,12 @@ async function captureDesignVersion(
     label: string;
     chatContext?: DesignVersionChatContext;
     deletionGeometry?: ComponentDeletionGeometry;
+    preferStoredFileContent?: boolean;
   },
   access: DesignAccess,
+  database?: DesignDatabase,
 ): Promise<{ id: string; createdAt: string; label: string }> {
-  const design = access.resource as {
+  let design = access.resource as {
     data?: unknown;
     title?: unknown;
     description?: unknown;
@@ -503,8 +516,29 @@ async function captureDesignVersion(
     designSystemId?: unknown;
     ownerEmail?: unknown;
   };
+  if (database) {
+    const [currentDesign] = await database
+      .select()
+      .from(schema.designs)
+      .where(
+        and(
+          eq(schema.designs.id, designId),
+          accessFilter(schema.designs, schema.designShares),
+        ),
+      )
+      .limit(1);
+    if (!currentDesign) {
+      throw new Error(`Design "${designId}" not found.`);
+    }
+    design = { ...design, ...currentDesign };
+  }
   const designData = parseDesignData(designId, design.data);
-  const liveSnapshot = await buildDesignSnapshot(designId, designData);
+  const snapshotOptions = options.preferStoredFileContent
+    ? { preferStoredFileContent: true }
+    : undefined;
+  const liveSnapshot = database
+    ? await buildDesignSnapshot(designId, designData, snapshotOptions, database)
+    : await buildDesignSnapshot(designId, designData, snapshotOptions);
   const designTitle = typeof design.title === "string" ? design.title : "";
   const designDescription =
     typeof design.description === "string" || design.description === null
@@ -536,7 +570,7 @@ async function captureDesignVersion(
     resolvedCssVars: liveSnapshot.resolvedCssVars,
     deletionGeometry: options.deletionGeometry,
   };
-  const db = getDb();
+  const db = database ?? getDb();
   const [latest] = await db
     .select({
       id: schema.designVersions.id,
@@ -745,69 +779,103 @@ export async function createDesignVersionSnapshot(
  * retries and multi-action turns converge on the earliest checkpoint instead
  * of filling history with one copy per tool call.
  */
-export async function snapshotDesignBeforeAgentEdit(
+async function snapshotDesignBeforeAgentEditInLock(
   designId: string,
-  context?: ActionRunContext,
+  context: ActionRunContext,
+  database?: DesignDatabase,
 ): Promise<{ id: string; createdAt: string; label: string } | null> {
-  if (!context) return null;
   const chatContext = actionChatContext(context);
-  if (!chatContext) return null;
-
-  return withDesignVersionLock(designId, async () => {
-    const access = await assertAccess("design", designId, "editor");
-    const key = chatContextKey(chatContext);
-    if (!key) return null;
-
-    const rows = await getDb()
-      .select({
-        id: schema.designVersions.id,
-        createdAt: schema.designVersions.createdAt,
-        label: schema.designVersions.label,
-        chatContext: schema.designVersions.chatContext,
-      })
-      .from(schema.designVersions)
-      .where(eq(schema.designVersions.designId, designId))
-      .orderBy(
-        asc(isNull(schema.designVersions.createdAt)),
-        desc(schema.designVersions.createdAt),
-        desc(schema.designVersions.id),
-      )
-      .limit(CHAT_VERSION_LOOKBACK);
-
-    let existing: { id: string; createdAt: string; label: string } | undefined;
-    for (const row of rows) {
-      let rowChatContext: DesignVersionChatContext | undefined;
-      try {
-        rowChatContext = parseStoredChatContext(row.chatContext);
-      } catch {
-        continue;
-      }
-      if (chatContextKey(rowChatContext) !== key) continue;
-      const candidate = {
-        id: row.id,
-        createdAt: row.createdAt ?? new Date().toISOString(),
-        label: row.label ?? "Before chat edit",
-      };
-      if (
-        !existing ||
-        versionTime(candidate.createdAt) < versionTime(existing.createdAt)
-      ) {
-        existing = candidate;
-      }
-    }
-    if (existing) return existing;
+  const editorContext = editorActionContext(context);
+  if (!chatContext && !editorContext) return null;
 
+  const access = await assertAccess("design", designId, "editor");
+  if (editorContext) {
     return captureDesignVersion(
       designId,
       {
         label: context.actionName
-          ? `Before chat edit: ${context.actionName}`
-          : "Before chat edit",
-        chatContext,
+          ? `Before editor edit: ${context.actionName}`
+          : "Before editor edit",
+        chatContext: editorContext,
       },
       access,
+      database,
     );
-  });
+  }
+  if (!chatContext) return null;
+  const key = chatContextKey(chatContext);
+  if (!key) return null;
+
+  const rows = await (database ?? getDb())
+    .select({
+      id: schema.designVersions.id,
+      createdAt: schema.designVersions.createdAt,
+      label: schema.designVersions.label,
+      chatContext: schema.designVersions.chatContext,
+    })
+    .from(schema.designVersions)
+    .where(eq(schema.designVersions.designId, designId))
+    .orderBy(
+      asc(isNull(schema.designVersions.createdAt)),
+      desc(schema.designVersions.createdAt),
+      desc(schema.designVersions.id),
+    )
+    .limit(CHAT_VERSION_LOOKBACK);
+
+  let existing: { id: string; createdAt: string; label: string } | undefined;
+  for (const row of rows) {
+    let rowChatContext: DesignVersionChatContext | undefined;
+    try {
+      rowChatContext = parseStoredChatContext(row.chatContext);
+    } catch {
+      continue;
+    }
+    if (chatContextKey(rowChatContext) !== key) continue;
+    const candidate = {
+      id: row.id,
+      createdAt: row.createdAt ?? new Date().toISOString(),
+      label: row.label ?? "Before chat edit",
+    };
+    if (
+      !existing ||
+      versionTime(candidate.createdAt) < versionTime(existing.createdAt)
+    ) {
+      existing = candidate;
+    }
+  }
+  if (existing) return existing;
+
+  return captureDesignVersion(
+    designId,
+    {
+      label: context.actionName
+        ? `Before chat edit: ${context.actionName}`
+        : "Before chat edit",
+      chatContext,
+    },
+    access,
+    database,
+  );
+}
+
+export async function snapshotDesignBeforeAgentEdit(
+  designId: string,
+  context?: ActionRunContext,
+): Promise<{ id: string; createdAt: string; label: string } | null> {
+  if (!context) return null;
+  return withDesignVersionLock(designId, () =>
+    snapshotDesignBeforeAgentEditInLock(designId, context),
+  );
+}
+
+/** Call only while the caller owns withDesignVersionLock(designId, ...). */
+export async function snapshotDesignBeforeAgentEditInVersionLock(
+  designId: string,
+  context?: ActionRunContext,
+  database?: DesignDatabase,
+): Promise<{ id: string; createdAt: string; label: string } | null> {
+  if (!context) return null;
+  return snapshotDesignBeforeAgentEditInLock(designId, context, database);
 }
 
 export async function listDesignVersions(
@@ -853,7 +921,12 @@ export async function listDesignVersions(
       designId,
       label: row.label,
       createdAt: row.createdAt,
-      source: chatContext ? "chat" : "legacy",
+      source:
+        chatContext?.surface === "editor"
+          ? "editor"
+          : chatContext
+            ? "chat"
+            : "legacy",
       fileCount: row.fileCount ?? 0,
       chatContext: chatContext ?? null,
       editable: Boolean(chatContext),
@@ -899,7 +972,7 @@ export async function restoreDesignVersion(args: {
   collaborationReconcilePending: string[];
 }> {
   return withDesignVersionLock(args.designId, async () => {
-    await assertAccess("design", args.designId, "editor");
+    const access = await assertAccess("design", args.designId, "editor");
     const db = getDb();
     const [version] = await db
       .select({
@@ -950,49 +1023,54 @@ export async function restoreDesignVersion(args: {
         ...target.files.flatMap((file) => (file.id ? [file.id] : [])),
       ],
       async () => {
-        const lockedFiles = await db
-          .select()
-          .from(schema.designFiles)
-          .where(eq(schema.designFiles.designId, args.designId));
-        await assertNoForeignCollaborators(
-          [
-            ...lockedFiles.map((file) => file.id),
-            ...target.files.flatMap((file) => (file.id ? [file.id] : [])),
-          ],
-          currentEmail,
-        );
-
-        const lockedAccess = await assertAccess(
-          "design",
-          args.designId,
-          "editor",
-        );
-        const currentDesign = lockedAccess.resource as {
-          data?: unknown;
-          updatedAt?: string | null;
-        };
-        await assertNoUnpersistedCollaborativeEdits(
-          args.designId,
-          lockedFiles,
-          typeof currentDesign.data === "string"
-            ? currentDesign.data
-            : undefined,
-        );
-        const before = await captureDesignVersion(
-          args.designId,
-          { label: "Before restore" },
-          lockedAccess,
-        );
-        const now = new Date();
-        const updatedAt = nextUpdatedAt(currentDesign.updatedAt ?? null, now);
-        const currentById = new Map(lockedFiles.map((file) => [file.id, file]));
-        const currentByFilename = new Map(
-          lockedFiles.map((file) => [file.filename, file]),
-        );
-        const claimedIds = new Set<string>();
-        const restoreFiles: RestoreFile[] = [];
-
-        await db.transaction(async (tx) => {
+        return db.transaction(async (tx) => {
+          await tx.execute(
+            sql`SELECT pg_advisory_xact_lock(hashtextextended(${designSourceMutationLockKey(args.designId)}, 0::bigint))`,
+          );
+          await lockDesignFilesTable(tx);
+          const lockedFiles = await tx
+            .select()
+            .from(schema.designFiles)
+            .where(eq(schema.designFiles.designId, args.designId));
+          await assertNoForeignCollaborators(
+            [
+              ...lockedFiles.map((file) => file.id),
+              ...target.files.flatMap((file) => (file.id ? [file.id] : [])),
+            ],
+            currentEmail,
+          );
+
+          const [currentDesign] = await tx
+            .select()
+            .from(schema.designs)
+            .where(eq(schema.designs.id, args.designId))
+            .limit(1);
+          if (!currentDesign) {
+            throw new Error(`Design "${args.designId}" not found.`);
+          }
+          await assertNoUnpersistedCollaborativeEdits(
+            args.designId,
+            lockedFiles,
+            currentDesign.data,
+            tx,
+          );
+          const before = await captureDesignVersion(
+            args.designId,
+            { label: "Before restore" },
+            access,
+            tx,
+          );
+          const now = new Date();
+          const updatedAt = nextUpdatedAt(currentDesign.updatedAt ?? null, now);
+          const currentById = new Map(
+            lockedFiles.map((file) => [file.id, file]),
+          );
+          const currentByFilename = new Map(
+            lockedFiles.map((file) => [file.filename, file]),
+          );
+          const claimedIds = new Set<string>();
+          const restoreFiles: RestoreFile[] = [];
+
           for (const targetFile of target.files) {
             const byId = targetFile.id
               ? currentById.get(targetFile.id)
@@ -1152,18 +1230,18 @@ export async function restoreDesignVersion(args: {
               "Design changed while history was being restored. Refresh and try again.",
             );
           }
-        });
 
-        return {
-          beforeRestoreVersionId: before.id,
-          restore: {
-            updatedAt,
-            files: restoreFiles,
-            deletedFileIds: lockedFiles
-              .filter((file) => !claimedIds.has(file.id))
-              .map((file) => file.id),
-          },
-        };
+          return {
+            beforeRestoreVersionId: before.id,
+            restore: {
+              updatedAt,
+              files: restoreFiles,
+              deletedFileIds: lockedFiles
+                .filter((file) => !claimedIds.has(file.id))
+                .map((file) => file.id),
+            },
+          };
+        });
       },
     );
 

package/corpus/templates/design/server/lib/fusion-screens.ts

@@ -21,7 +21,7 @@ import {
   applyText,
   seedFromText,
 } from "@agent-native/core/collab";
-import { eq } from "drizzle-orm";
+import { and, eq } from "drizzle-orm";
 import { nanoid } from "nanoid";
 
 import {
@@ -30,6 +30,7 @@ import {
   type CanvasFramePlacement,
 } from "../../shared/canvas-frames.js";
 import { getDb, schema } from "../db/index.js";
+import { withDesignSourceMutationTransaction } from "../source-workspace.js";
 import { mutateDesignData } from "./design-data-mutation.js";
 
 const PATH_BASE_PLACEHOLDER = "http://fusion-screen-base.invalid";
@@ -149,31 +150,56 @@ export async function upsertFusionScreens(args: {
       ? `${screenUrl.pathname}${screenUrl.search}`
       : screenUrl.toString();
     const preferredFilename = `fusion-${slugForPath(path)}.html`;
-    const existing = existingByFilename.get(preferredFilename);
+    let existing = existingByFilename.get(preferredFilename);
     const filename = existing?.filename ?? uniqueFilename(path, usedFilenames);
-    const fileId = existing?.id ?? nanoid();
+    let fileId = existing?.id ?? nanoid();
     const title = titleFromPath(path);
 
     if (existing) {
-      await db
-        .update(schema.designFiles)
-        .set({ content: url, fileType: "html", updatedAt: now })
-        .where(eq(schema.designFiles.id, existing.id));
-      if (await hasCollabState(existing.id)) {
-        await applyText(existing.id, url, "content", "agent");
+      const updated = await withDesignSourceMutationTransaction(
+        designId,
+        async (tx) => {
+          const [current] = await tx
+            .select({ id: schema.designFiles.id })
+            .from(schema.designFiles)
+            .where(
+              and(
+                eq(schema.designFiles.id, existing!.id),
+                eq(schema.designFiles.designId, designId),
+              ),
+            )
+            .limit(1);
+          if (!current) return false;
+          await tx
+            .update(schema.designFiles)
+            .set({ content: url, fileType: "html", updatedAt: now })
+            .where(eq(schema.designFiles.id, existing!.id));
+          return true;
+        },
+      );
+      if (updated) {
+        if (await hasCollabState(existing.id)) {
+          await applyText(existing.id, url, "content", "agent");
+        } else {
+          await seedFromText(existing.id, url);
+        }
       } else {
-        await seedFromText(existing.id, url);
+        existing = undefined;
+        fileId = nanoid();
       }
-    } else {
-      await db.insert(schema.designFiles).values({
-        id: fileId,
-        designId,
-        filename,
-        fileType: "html",
-        content: url,
-        createdAt: now,
-        updatedAt: now,
-      });
+    }
+    if (!existing) {
+      await withDesignSourceMutationTransaction(designId, (tx) =>
+        tx.insert(schema.designFiles).values({
+          id: fileId,
+          designId,
+          filename,
+          fileType: "html",
+          content: url,
+          createdAt: now,
+          updatedAt: now,
+        }),
+      );
       await seedFromText(fileId, url);
     }
 

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

@@ -5,7 +5,7 @@ import {
   seedFromText,
 } from "@agent-native/core/collab";
 import { assertAccess, resolveAccess } from "@agent-native/core/sharing";
-import { and, eq } from "drizzle-orm";
+import { and, eq, sql } from "drizzle-orm";
 import { nanoid } from "nanoid";
 
 import {
@@ -15,6 +15,7 @@ import {
 } from "../../shared/canvas-frames.js";
 import { annotateScreenHtmlForPersist } from "../../shared/screen-annotation.js";
 import { getDb, schema } from "../db/index.js";
+import { designSourceMutationLockKey } from "../source-workspace.js";
 import { mutateDesignData } from "./design-data-mutation.js";
 
 const DEFAULT_FRAME_WIDTH = 1440;
@@ -299,6 +300,9 @@ export async function saveImportedDesignFiles(
 
   try {
     await db.transaction(async (tx) => {
+      await tx.execute(
+        sql`SELECT pg_advisory_xact_lock(hashtextextended(${designSourceMutationLockKey(designId)}, 0::bigint))`,
+      );
       const [design] = await tx
         .select()
         .from(schema.designs)