@agent-native/core 0.92.10 → 0.92.11

package/corpus/templates/design/actions/add-localhost-screens.ts

@@ -25,6 +25,7 @@ import {
   type CanvasFrameGeometry,
   type CanvasFramePlacement,
 } from "../shared/canvas-frames.js";
+import { isUniqueConstraintViolation } from "../shared/db-conflict.js";
 import {
   makeLocalhostRouteId,
   titleFromRoutePath,
@@ -488,6 +489,18 @@ export default defineAction({
       height: number;
     }> = [];
     const placementIntents: PlacementIntent[] = [];
+    // Duplicate-route guard: `existingFiles`/`existingByFilename`/the
+    // route-candidate lookups below are all snapshotted ONCE above the loop
+    // and never refreshed as new files are inserted mid-loop, so two entries
+    // in the SAME `requestedRoutes` call that resolve to the same route
+    // (repeated `paths`, or a `routeId` and a `path` naming the same route)
+    // each independently see "no existing match" and each insert a fresh
+    // `design_files` row — two overlapping screens for one route. Track
+    // routeIds already processed THIS call (keyed with width/height so an
+    // intentional multi-viewport request for the same route still creates
+    // its distinct variants) and skip later duplicates outright.
+    const seenRouteRequestKeys = new Set<string>();
+    let placementIndex = 0;
 
     for (let index = 0; index < requestedRoutes.length; index += 1) {
       const input = requestedRoutes[index]!;
@@ -505,6 +518,9 @@ export default defineAction({
       );
       const routeId =
         input.routeId ?? manifestRoute?.id ?? makeLocalhostRouteId(path);
+      const routeRequestKey = `${routeId}::${input.width ?? ""}x${input.height ?? ""}`;
+      if (seenRouteRequestKeys.has(routeRequestKey)) continue;
+      seenRouteRequestKeys.add(routeRequestKey);
       const title =
         input.title ?? manifestRoute?.title ?? titleFromRoutePath(path);
       const sourceFile = input.sourceFile ?? manifestRoute?.sourceFile;
@@ -619,7 +635,9 @@ export default defineAction({
       const filename =
         existing?.filename ??
         uniqueFilename(path, usedFilenames, preferredFilename);
-      const fileId = existing?.id ?? nanoid();
+      // Reassigned below if a concurrent request wins the insert race for
+      // this exact (designId, filename) pair — see the `else` branch.
+      let fileId = existing?.id ?? nanoid();
       const existingScreenMetadata = existing
         ? metadataForFile(
             existing.id,
@@ -656,16 +674,50 @@ export default defineAction({
           await seedFromText(existing.id, url);
         }
       } else {
-        await db.insert(schema.designFiles).values({
-          id: fileId,
-          designId,
-          filename,
-          fileType: "html",
-          content: url,
-          createdAt: now,
-          updatedAt: now,
-        });
-        await seedFromText(fileId, url);
+        try {
+          await db.insert(schema.designFiles).values({
+            id: fileId,
+            designId,
+            filename,
+            fileType: "html",
+            content: url,
+            createdAt: now,
+            updatedAt: now,
+          });
+          await seedFromText(fileId, url);
+        } catch (err) {
+          if (!isUniqueConstraintViolation(err)) throw err;
+          // Cross-request race: this snapshot's `existingFiles` query ran
+          // before a concurrent add-localhost-screens call (for the same
+          // route) committed its own insert, so both requests independently
+          // computed the same deterministic filename and both tried to
+          // create it. The `design_files_design_filename_unique_idx` unique
+          // index (see server/plugins/db.ts) turns the loser's insert into
+          // this error instead of a silent duplicate screen. Recover by
+          // adopting whichever row actually won the race and updating its
+          // content, the same way the `existing` branch above does.
+          const [winner] = await db
+            .select()
+            .from(schema.designFiles)
+            .where(
+              and(
+                eq(schema.designFiles.designId, designId),
+                eq(schema.designFiles.filename, filename),
+              ),
+            )
+            .limit(1);
+          if (!winner) throw err;
+          fileId = winner.id;
+          await db
+            .update(schema.designFiles)
+            .set({ content: url, fileType: "html", updatedAt: now })
+            .where(eq(schema.designFiles.id, winner.id));
+          if (await hasCollabState(winner.id)) {
+            await applyText(winner.id, url, "content", "agent");
+          } else {
+            await seedFromText(winner.id, url);
+          }
+        }
       }
 
       savedScreens.push({
@@ -688,12 +740,13 @@ export default defineAction({
         x:
           input.x ??
           existingFrame?.x ??
-          layoutStartX + index * (width + layoutGap),
+          layoutStartX + placementIndex * (width + layoutGap),
         y: input.y ?? existingFrame?.y ?? layoutStartY,
         width,
         height,
-        z: input.z ?? existingFrame?.z ?? index,
+        z: input.z ?? existingFrame?.z ?? placementIndex,
       };
+      placementIndex += 1;
       placementIntents.push({
         fileId,
         filename,

package/corpus/templates/design/actions/apply-component-prop-edit.ts

@@ -12,11 +12,12 @@
  *                    HTML attribute on the component root.
  * - `classReplace` — replaces one Tailwind class with another on the root node.
  *
- * **Tier B (real-app, localhost / fusion):**  prop writes require the
- * `applyEdit` source capability.  Localhost sources have it (design bridge +
- * user write consent); fusion sources gain it after bridge hardening.  For
- * sources without it the action returns a `ctaRequired: true` response and
- * does not modify any source.
+ * **Real-app sources (localhost / fusion):** deliberately fail closed. This
+ * action's patcher operates on SQL-backed HTML design files; it must never be
+ * reused for compiled JSX/TSX source. Real-app prop persistence needs a
+ * dedicated consented, version-guarded bridge transform. Until that exists,
+ * callers may preview but this action returns `ctaRequired: true` without
+ * reading or modifying a design file.
  *
  * See DESIGN-STUDIO-PLAN.md §6.1, §7 (preview/apply contract), §11 phase 2.
  */
@@ -38,10 +39,11 @@ import { z } from "zod";
 import { getDb, schema } from "../server/db/index.js";
 import "../server/db/index.js"; // ensure registerShareableResource runs
 import {
+  prepareInlineSourceEdit,
+  SourceWorkspaceEditConflictError,
   writeInlineSourceFile,
   type SourceWorkspaceFile,
 } from "../server/source-workspace.js";
-import { resolveSourceCapabilities } from "../shared/capability-resolver.js";
 import {
   applyVisualEdit,
   buildCodeLayerProjection,
@@ -56,9 +58,7 @@ import {
   componentNameFor,
   componentNodeIdMatches,
 } from "../shared/component-model.js";
-import { hasCapability } from "../shared/design-source-capabilities.js";
 import { designSourceTypeFromData } from "../shared/source-mode.js";
-import { sourceContentHash } from "../shared/source-workspace.js";
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -174,8 +174,8 @@ export default defineAction({
     "For inline/Alpine designs, edits the data-agent-native-prop-* attributes, " +
     "x-data expression, or class list of the component root via the deterministic " +
     "HTML-patch path (same seam as apply-visual-edit). " +
-    "For real-app sources, the applyEdit capability must be available; if not, " +
-    "returns ctaRequired=true without modifying any file.",
+    "For real-app sources, returns ctaRequired=true without modifying any file; " +
+    "compiled source requires a dedicated consented bridge transform.",
   schema: z.object({
     designId: z.string().describe("Design project ID"),
     nodeId: z
@@ -234,19 +234,21 @@ export default defineAction({
       .optional(),
   }),
   run: async ({ designId, nodeId, fileId, edit, source }) => {
-    const db = getDb();
-
     // ── Access check ────────────────────────────────────────────────────────
     const access = await resolveAccess("design", designId);
     if (!access) throw new Error("Design not found");
 
-    // ── Source type + capability gate ────────────────────────────────────────
+    // ── Source type gate ────────────────────────────────────────────────────
     const rawData = (access.resource as { data?: unknown }).data;
     const sourceType = designSourceTypeFromData(rawData);
-    const caps = resolveSourceCapabilities(sourceType);
 
-    // Real-app sources gate on `applyEdit` (bridge write hardening).
-    if (sourceType !== "inline" && !hasCapability(caps, "applyEdit")) {
+    // Fail closed for every real-app tier even if its generic capability map
+    // advertises applyEdit. This action only knows how to patch SQL-backed HTML;
+    // allowing localhost through here could report success for the mirror while
+    // leaving the real JSX/TSX file untouched. A future compiled-source action
+    // must perform consent, canonical path resolution, AST anchoring, and an
+    // expected-version bridge write as one dedicated transaction.
+    if (sourceType !== "inline") {
       return {
         designId,
         nodeId,
@@ -254,13 +256,14 @@ export default defineAction({
         persisted: false,
         ctaRequired: true,
         ctaMessage:
-          "Prop write-back to real app sources requires the bridge applyEdit " +
-          "capability, which lands with bridge write hardening. " +
+          "Prop write-back to real app sources requires a dedicated consented, " +
+          "version-guarded compiled-source transform. " +
           "Use preview-component-prop-edit to preview without persisting.",
       };
     }
 
     await assertAccess("design", designId, "editor");
+    const db = getDb();
 
     // ── Fetch file ───────────────────────────────────────────────────────────
     const conditions = [
@@ -289,12 +292,24 @@ export default defineAction({
 
     if (!file) throw new Error("Design HTML file not found.");
 
-    if (
-      source?.currentContent &&
-      source.revision &&
-      file.updatedAt &&
-      source.revision !== file.updatedAt
-    ) {
+    const workspaceFile: SourceWorkspaceFile = {
+      id: file.id,
+      designId: file.designId,
+      filename: file.filename,
+      fileType: "html",
+      content: file.content,
+      createdAt: null,
+      updatedAt: file.updatedAt,
+    };
+    let prepared: Awaited<ReturnType<typeof prepareInlineSourceEdit>>;
+    try {
+      prepared = await prepareInlineSourceEdit({
+        file: workspaceFile,
+        currentContent: source?.currentContent,
+        revision: source?.revision,
+      });
+    } catch (error) {
+      if (!(error instanceof SourceWorkspaceEditConflictError)) throw error;
       return {
         designId,
         nodeId,
@@ -307,18 +322,12 @@ export default defineAction({
       };
     }
 
-    // Prefer explicit editor content after the caller's revision check, and use
-    // the saved SQL content as the fallback. Collab/Yjs reads can be stale
-    // across local dev worker processes and make prop controls lag behind.
-    const html =
-      typeof source?.currentContent === "string"
-        ? source.currentContent
-        : (file.content ?? "");
-    // Capture the hash of this EXACT base — the same string the transform
-    // below reads from — so persistEdit can pass it through as
-    // expectedVersionHash. A re-read at persist time would hash whatever is
-    // live "then" instead of proving this base is still current.
-    const baseVersionHash = sourceContentHash(html);
+    // The transform runs against the caller's working copy (when supplied),
+    // while the persist CAS uses the live hash that working copy is allowed to
+    // replace. Keeping those identities separate preserves rapid unsaved prop
+    // edits without weakening concurrent-writer rejection.
+    const html = prepared.content;
+    const baseVersionHash = prepared.expectedVersionHash;
 
     // ── Resolve node ─────────────────────────────────────────────────────────
     const codeLayerSource: CodeLayerSource = {

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

@@ -32,7 +32,7 @@ import { z } from "zod";
 import { getDb, schema } from "../server/db/index.js";
 import "../server/db/index.js"; // ensure registerShareableResource runs
 import {
-  readLiveSourceFile,
+  prepareInlineSourceEdit,
   writeInlineSourceFile,
   type SourceWorkspaceFile,
 } from "../server/source-workspace.js";
@@ -51,7 +51,6 @@ import {
   readTimelinePlaybackMode,
   withTimelinePlaybackMode,
 } from "../shared/motion-timeline.js";
-import { sourceContentHash } from "../shared/source-workspace.js";
 
 // ─── DoS-guard caps ──────────────────────────────────────────────────────────
 //
@@ -343,7 +342,15 @@ export default defineAction({
       .describe(
         "Current open editor HTML for the target file. When supplied, the " +
           "managed motion CSS is patched into this content instead of the " +
-          "last SQL snapshot so in-flight local edits are preserved.",
+          "last SQL snapshot so in-flight local edits are preserved. " +
+          "revision must also be supplied.",
+      ),
+    revision: z
+      .string()
+      .optional()
+      .describe(
+        "design_files.updatedAt value the currentContent is based on. " +
+          "Required when currentContent is supplied.",
       ),
   }),
   run: async ({
@@ -357,6 +364,7 @@ export default defineAction({
     defaultEase,
     includeContent,
     currentContent: currentContentInput,
+    revision,
   }) => {
     const access = await assertAccess("design", designId, "editor");
 
@@ -378,6 +386,7 @@ export default defineAction({
         filename: schema.designFiles.filename,
         fileType: schema.designFiles.fileType,
         content: schema.designFiles.content,
+        updatedAt: schema.designFiles.updatedAt,
       })
       .from(schema.designFiles)
       .innerJoin(
@@ -398,40 +407,25 @@ export default defineAction({
     const fileId = file.id;
     const resolvedSourceRef = sourceRef ?? fileId;
 
-    // The EDITABLE base for compiling/injecting CSS: prefer the caller's
-    // in-flight editor snapshot when supplied (currentContentInput), else the
-    // LIVE collab-authoritative content for this file (not the raw SQL row —
-    // a live editor's Y.Text may be ahead of the last SQL snapshot). Either
-    // way, `baseVersionHash` is computed from the EXACT string chosen as the
-    // base, at this same point in time, so it faithfully represents "what
-    // this transform's base was" for the persist's optimistic-concurrency
-    // check below — never a fresh re-hash of already-transformed content
-    // (that would trivially match itself and prove nothing raced).
-    let currentContent: string;
-    let baseVersionHash: string;
-    if (currentContentInput !== undefined) {
-      // Caller supplied their own editor snapshot as the patch base. It may
-      // already be stale relative to the live doc — that's fine.
-      // writeInlineSourceFile's own guard (via readLiveSourceFile at write
-      // time) correctly rejects the write if this base no longer matches
-      // live state, exactly as designed for every other caller-supplied-base
-      // action (see apply-component-prop-edit.ts / apply-shader-fill.ts).
-      currentContent = currentContentInput;
-      baseVersionHash = sourceContentHash(currentContent);
-    } else {
-      const workspaceFileForRead: SourceWorkspaceFile = {
+    // Keep the transform working copy separate from the live version it may
+    // replace. A caller snapshot can legitimately contain unsaved local edits
+    // beyond the matching SQL revision; the write CAS must guard the observed
+    // live base, not incorrectly hash those unsaved edits as if already live.
+    const prepared = await prepareInlineSourceEdit({
+      file: {
         id: file.id,
         designId: file.designId,
         filename: file.filename,
         fileType: file.fileType,
         content: file.content,
         createdAt: null,
-        updatedAt: null,
-      };
-      const live = await readLiveSourceFile(workspaceFileForRead);
-      currentContent = live.content;
-      baseVersionHash = live.versionHash;
-    }
+        updatedAt: file.updatedAt,
+      },
+      currentContent: currentContentInput,
+      revision,
+    });
+    const currentContent = prepared.content;
+    const baseVersionHash = prepared.expectedVersionHash;
 
     // ── 2. Compile tracks → CSS ─────────────────────────────────────────────
     const inputTracks = tracks as MotionTrack[];

package/corpus/templates/design/actions/apply-shader-fill.ts

@@ -38,7 +38,8 @@ import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
 import {
-  readLiveSourceFile,
+  prepareInlineSourceEdit,
+  SourceWorkspaceEditConflictError,
   writeInlineSourceFile,
   type SourceWorkspaceFile,
 } from "../server/source-workspace.js";
@@ -58,7 +59,6 @@ import {
   type ShaderPresetName,
   validateDescriptor,
 } from "../shared/shader-presets.js";
-import { sourceContentHash } from "../shared/source-workspace.js";
 
 // ─── Schema ──────────────────────────────────────────────────────────────────
 
@@ -163,14 +163,10 @@ interface ResolvedDesignFile {
  * editor access. Mirrors `resolveEditableDesignFile` in apply-visual-edit.ts so
  * the shader-fill write goes through the exact same ownership gate.
  *
- * The editable base is collab-aware: `readLiveSourceFile` returns the live
- * Y.Text content when a collab doc exists for this file, else the SQL row —
- * never only the raw SQL snapshot. When the caller supplies
- * `source.currentContent`, that in-flight editor snapshot is preferred as the
- * base instead (same precedence as apply-motion-edit.ts / apply-component-
- * prop-edit.ts), and its versionHash is computed directly from that exact
- * string via `sourceContentHash` — not from a fresh live re-read, which would
- * prove nothing about whether this specific base is still current.
+ * `prepareInlineSourceEdit` keeps the caller's working copy (the transform
+ * base) separate from the live hash it is allowed to replace (the write CAS).
+ * This preserves unsaved local edits based on the matching SQL revision while
+ * still rejecting a third, concurrently-edited live value.
  */
 async function resolveEditableDesignFile(source: {
   designId?: string;
@@ -241,36 +237,27 @@ async function resolveEditableDesignFile(source: {
       "source.revision is required when source.currentContent is provided.",
     );
   }
-  // Legitimate pre-check, distinct from the CAS write-guard below: reject
-  // early when the caller's own revision stamp doesn't match the file's SQL
-  // updatedAt, before any transform work happens.
-  if (
-    source.currentContent !== undefined &&
-    source.revision &&
-    file.updatedAt &&
-    source.revision !== file.updatedAt
-  ) {
-    throw new ShaderFillRevisionConflictError();
-  }
-
-  let content: string;
-  let versionHash: string;
-  if (source.currentContent !== undefined) {
-    content = source.currentContent;
-    versionHash = sourceContentHash(content);
-  } else {
-    const workspaceFile: SourceWorkspaceFile = {
-      id: file.id,
-      designId: file.designId,
-      filename: file.filename,
-      fileType: file.fileType,
-      content: file.content,
-      createdAt: null,
-      updatedAt: file.updatedAt,
-    };
-    const live = await readLiveSourceFile(workspaceFile);
-    content = live.content;
-    versionHash = live.versionHash;
+  const workspaceFile: SourceWorkspaceFile = {
+    id: file.id,
+    designId: file.designId,
+    filename: file.filename,
+    fileType: file.fileType,
+    content: file.content,
+    createdAt: null,
+    updatedAt: file.updatedAt,
+  };
+  let prepared: Awaited<ReturnType<typeof prepareInlineSourceEdit>>;
+  try {
+    prepared = await prepareInlineSourceEdit({
+      file: workspaceFile,
+      currentContent: source.currentContent,
+      revision: source.revision,
+    });
+  } catch (error) {
+    if (error instanceof SourceWorkspaceEditConflictError) {
+      throw new ShaderFillRevisionConflictError();
+    }
+    throw error;
   }
 
   return {
@@ -278,8 +265,8 @@ async function resolveEditableDesignFile(source: {
     designId: file.designId,
     filename: file.filename,
     fileType: file.fileType,
-    content,
-    versionHash,
+    content: prepared.content,
+    versionHash: prepared.expectedVersionHash,
     codeLayerSource: {
       kind: "design-file",
       designId: file.designId,