@agent-native/core 0.122.1 → 0.122.3

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

@@ -18,6 +18,7 @@ import { z } from "zod";
 import { getDb, schema } from "../server/db/index.js";
 import {
   readLiveSourceFile,
+  SourceWorkspaceEditConflictError,
   writeInlineSourceFile,
   type SourceWorkspaceFile,
 } from "../server/source-workspace.js";
@@ -303,36 +304,28 @@ export default defineAction({
       );
     }
 
-    // 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 ??
       (replacementContent !== undefined ? "replace-file" : "search-replace");
-    const { content: nextContent, applied } =
-      resolvedMode === "replace-file"
-        ? { content: replacementContent ?? "", applied: 0 }
-        : applySearchReplaceEdits(base, edits ?? []);
-    const changed = nextContent !== base;
 
+    // A concurrent human/agent write can land between reading the live file
+    // and persisting this edit (writeInlineSourceFile throws
+    // SourceWorkspaceEditConflictError when that happens — see its own
+    // comment for the CAS/collab details). search-replace edits are anchored
+    // to specific text rather than a stale full snapshot, so on conflict we
+    // can just re-read the fresh content and reapply the SAME edits against
+    // it instead of forcing the agent to make a separate get-design-snapshot
+    // round trip and guess again. replace-file sends a full document computed
+    // from a point-in-time snapshot — retrying that blind could silently
+    // clobber whatever the concurrent writer did, so it still fails closed on
+    // the first conflict.
+    const MAX_EDIT_CONFLICT_RETRIES = 2;
+
+    let live: Awaited<ReturnType<typeof readLiveSourceFile>>;
+    let base = "";
+    let nextContent = "";
+    let applied = 0;
+    let changed = false;
     let creativeContext:
       | {
           contextMode: "off" | "auto" | "pinned";
@@ -352,7 +345,43 @@ export default defineAction({
         }
       | undefined;
 
-    if (changed) {
+    for (let attempt = 0; ; attempt += 1) {
+      // Refetch the SQL content on retries — readLiveSourceFile only falls
+      // back to this when no collab doc exists yet, so a conflict caused by
+      // a plain SQL writer (no live collab session) needs a fresh row here
+      // or every retry would recompute the exact same stale versionHash.
+      const currentContent =
+        attempt === 0
+          ? file.content
+          : (
+              await db
+                .select({ content: schema.designFiles.content })
+                .from(schema.designFiles)
+                .where(eq(schema.designFiles.id, file.id))
+                .limit(1)
+            )[0]?.content;
+
+      const workspaceFile: SourceWorkspaceFile = {
+        id: file.id,
+        designId: file.designId,
+        filename: file.filename ?? "",
+        fileType: file.fileType ?? "html",
+        content: currentContent,
+        createdAt: null,
+        updatedAt: null,
+      };
+      live = await readLiveSourceFile(workspaceFile);
+      base = live.content;
+
+      ({ content: nextContent, applied } =
+        resolvedMode === "replace-file"
+          ? { content: replacementContent ?? "", applied: 0 }
+          : applySearchReplaceEdits(base, edits ?? []));
+      changed = nextContent !== base;
+      creativeContext = undefined;
+
+      if (!changed) break;
+
       const previous =
         contextModeOverride === "off"
           ? null
@@ -439,6 +468,15 @@ export default defineAction({
           content: nextContent,
           expectedVersionHash: live.versionHash,
         });
+      } catch (error) {
+        if (
+          error instanceof SourceWorkspaceEditConflictError &&
+          resolvedMode === "search-replace" &&
+          attempt < MAX_EDIT_CONFLICT_RETRIES
+        ) {
+          continue;
+        }
+        throw error;
       } finally {
         agentLeaveDocument(file.id);
       }
@@ -448,6 +486,7 @@ export default defineAction({
         artifactId: designId,
         ...creativeContext,
       });
+      break;
     }
 
     return {

package/corpus/templates/design/changelog/2026-07-25-design-edits-retry-concurrent-changes.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-25
+---
+
+Design edits now retry safely when another collaborator changes the file.

package/corpus/templates/design/server/source-workspace.ts

@@ -331,7 +331,11 @@ export async function writeInlineSourceFile(args: {
       args.expectedVersionHash &&
       args.expectedVersionHash !== current.versionHash
     ) {
-      throw new Error(
+      // Typed so callers can catch-and-retry the same way they already do for
+      // the other two conflict sites below (see apply-shader-fill.ts /
+      // apply-component-prop-edit.ts / edit-design.ts) instead of only
+      // matching on message text.
+      throw new SourceWorkspaceEditConflictError(
         "Source file changed since it was read. Re-read the file and retry.",
       );
     }

package/corpus/templates/forms/.agents/skills/form-responses/SKILL.md

@@ -48,14 +48,16 @@ status, visibility, and an "Open editor" action.
 
 ## Exporting Responses
 
-Use `export-responses` to export to CSV or JSON:
+Use `export-responses` to export to CSV or JSON. The export is uploaded to
+configured file storage (never written to local disk — serverless hosts have
+a read-only filesystem) and the action returns the resulting file URL:
 
 ```bash
 # CSV export (default)
-pnpm action export-responses --form <form-id> --output data/export.csv
+pnpm action export-responses --form <form-id>
 
 # JSON export
-pnpm action export-responses --form <form-id> --output data/export.json --format json
+pnpm action export-responses --form <form-id> --format json
 ```
 
 The CSV includes headers derived from field labels. Array values (multiselect) are joined with semicolons.
@@ -113,7 +115,7 @@ To analyze responses, the workflow is:
 | ---------------------- | ---------------------------------------------------------------------------- |
 | "@Form setup?"         | `preview-form --formId <id>` and answer from the returned fields/settings    |
 | "How many responses?"  | `response-insights --formId <id>` and report `summary.responses`             |
-| "Export to CSV"        | `export-responses --form <id> --output data/export.csv`                      |
+| "Export to CSV"        | `export-responses --form <id>`                                               |
 | "Submissions by day"   | `response-insights --formId <id> --days 30`                                  |
 | "Summarize feedback"   | `response-insights`, then `list-responses` if more detail is needed          |
 | "Average rating"       | `list-responses`, compute from rating fields and state the sampled row count |

package/corpus/templates/forms/actions/create-form.ts

@@ -9,7 +9,10 @@ import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
 import { assertIntegrationUrlsAllowed } from "../server/lib/integrations.js";
-import { assertValidFields } from "../server/lib/validate-fields.js";
+import {
+  assertValidFields,
+  normalizeFieldIds,
+} from "../server/lib/validate-fields.js";
 import type { FormField, FormSettings } from "../shared/types.js";
 import { assertPublishableForm } from "./lib/assert-publishable-form.js";
 
@@ -88,6 +91,7 @@ export default defineAction({
         fields = args.fields as unknown as FormField[];
       }
     }
+    fields = normalizeFieldIds(fields) as FormField[];
     assertValidFields(fields);
 
     const defaultSettings: FormSettings = {

package/corpus/templates/forms/actions/export-responses.ts

@@ -1,6 +1,6 @@
-import fs from "fs";
-
 import { defineAction } from "@agent-native/core";
+import { uploadFile } from "@agent-native/core/file-upload";
+import { getRequestUserEmail } from "@agent-native/core/server/request-context";
 import { assertAccess } from "@agent-native/core/sharing";
 import { eq, desc } from "drizzle-orm";
 import { z } from "zod";
@@ -12,7 +12,6 @@ export default defineAction({
   description: "Export form responses to CSV or JSON file.",
   schema: z.object({
     form: z.string().describe("Form ID (required)"),
-    output: z.string().optional().describe("Output file path"),
     format: z.enum(["csv", "json"]).optional().describe("Export format"),
   }),
   http: false,
@@ -28,10 +27,10 @@ export default defineAction({
       .orderBy(desc(schema.responses.submittedAt));
 
     const fields = JSON.parse(form.fields);
-    const fmt =
-      args.format || (args.output?.endsWith(".json") ? "json" : "csv");
-    const outputPath =
-      args.output || `data/export-${formId}.${fmt === "json" ? "json" : "csv"}`;
+    const fmt = args.format || "csv";
+    const filename = `export-${formId}.${fmt === "json" ? "json" : "csv"}`;
+    const ownerEmail = getRequestUserEmail() ?? undefined;
+    let fileBody: string;
 
     if (fmt === "json") {
       const data = responses.map((r) => ({
@@ -42,7 +41,7 @@ export default defineAction({
         clientSurface: r.clientSurface ?? null,
         ...JSON.parse(r.data),
       }));
-      fs.writeFileSync(outputPath, JSON.stringify(data, null, 2));
+      fileBody = JSON.stringify(data, null, 2);
     } else {
       const headers = [
         "ID",
@@ -74,17 +73,29 @@ export default defineAction({
       // with a single quote so spreadsheets treat it as literal text.
       const neutralize = (cell: string) =>
         /^[=+\-@\t\r]/.test(cell) ? `'${cell}` : cell;
-      const csv = [headers, ...rows]
+      fileBody = [headers, ...rows]
         .map((row) =>
           row
             .map((cell: string) => `"${neutralize(cell).replace(/"/g, '""')}"`)
             .join(","),
         )
         .join("\n");
+    }
+
+    const uploaded = await uploadFile({
+      data: Buffer.from(fileBody, "utf8"),
+      mimeType: fmt === "json" ? "application/json" : "text/csv",
+      filename,
+      ownerEmail,
+    }).catch(() => null);
 
-      fs.writeFileSync(outputPath, csv);
+    if (!uploaded) {
+      throw new Error(
+        "Export was generated but not saved because file storage is not configured. " +
+          "Connect or reconnect Builder.io in Settings → File uploads, or register a custom provider.",
+      );
     }
 
-    return `Exported ${responses.length} responses to ${outputPath}`;
+    return `Exported ${responses.length} responses to ${uploaded.url}`;
   },
 });

package/corpus/templates/forms/actions/update-form.ts

@@ -6,7 +6,10 @@ import { z } from "zod";
 import { getDb, schema } from "../server/db/index.js";
 import { assertIntegrationUrlsAllowed } from "../server/lib/integrations.js";
 import { invalidatePublicFormCache } from "../server/lib/public-form-ssr.js";
-import { assertValidFields } from "../server/lib/validate-fields.js";
+import {
+  assertValidFields,
+  normalizeFieldIds,
+} from "../server/lib/validate-fields.js";
 import type { FormField, FormSettings } from "../shared/types.js";
 import { assertPublishableForm } from "./lib/assert-publishable-form.js";
 
@@ -81,6 +84,7 @@ export default defineAction({
       } else {
         parsedFields = args.fields;
       }
+      parsedFields = normalizeFieldIds(parsedFields);
       assertValidFields(parsedFields);
       updates.fields = JSON.stringify(parsedFields);
     }

package/corpus/templates/forms/changelog/2026-07-25-fields-can-be-created-without-ids.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-25
+---
+
+Forms can create and update fields without manually supplied IDs.

package/corpus/templates/forms/changelog/2026-07-25-response-exports-use-file-storage.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-25
+---
+
+Response exports now save to file storage and return a downloadable URL.

package/corpus/templates/forms/server/lib/validate-fields.ts

@@ -6,6 +6,49 @@
 export const FIELD_ID_PATTERN = /^[A-Za-z0-9_-]+$/;
 const CONDITIONAL_OPERATORS = new Set(["equals", "not_equals", "contains"]);
 
+/**
+ * Generates a safe id for a whole-array field replacement (create-form,
+ * update-form) when the model omits one — the #1 create-form failure in
+ * the 2026-07-25 reliability sweep ("field #1 has an invalid id undefined").
+ * Never used by patch-form-fields: there a missing id on an upsert op is
+ * ambiguous (new field vs. a forgotten reference to an existing one), so it
+ * must keep failing loud rather than risk silently creating a duplicate.
+ * Ids are slugified from `label` through the same FIELD_ID_PATTERN charset
+ * `assertValidFields` enforces, so a generated id can never fail that check.
+ */
+export function normalizeFieldIds(fields: unknown): unknown {
+  if (!Array.isArray(fields)) return fields;
+  const usedIds = new Set(
+    fields
+      .map((f) =>
+        f && typeof f === "object" ? (f as Record<string, unknown>).id : null,
+      )
+      .filter(
+        (id): id is string =>
+          typeof id === "string" && FIELD_ID_PATTERN.test(id),
+      ),
+  );
+  return fields.map((field) => {
+    if (field == null || typeof field !== "object") return field;
+    const f = field as Record<string, unknown>;
+    if (typeof f.id === "string" && FIELD_ID_PATTERN.test(f.id)) return field;
+    const label = typeof f.label === "string" ? f.label : "";
+    const base =
+      label
+        .toLowerCase()
+        .replace(/[^a-z0-9_-]+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .slice(0, 40) || "field";
+    let candidate = base;
+    let suffix = 1;
+    while (usedIds.has(candidate)) {
+      candidate = `${base}_${++suffix}`;
+    }
+    usedIds.add(candidate);
+    return { ...f, id: candidate };
+  });
+}
+
 export function assertValidFields(fields: unknown): void {
   if (!Array.isArray(fields)) {
     throw new Error("fields must be an array");

package/corpus/templates/slides/actions/extract-pdf.ts

@@ -2,6 +2,8 @@ import fs from "fs";
 
 import { parseArgs } from "@agent-native/core";
 
+import { setupPdfParse } from "../server/lib/pdf-parse-setup.js";
+
 export default async function (args: string[]) {
   const { path: pdfPath } = parseArgs(args);
   if (!pdfPath) {
@@ -10,12 +12,10 @@ export default async function (args: string[]) {
   }
 
   const buf = fs.readFileSync(pdfPath);
-  const { CanvasFactory, getData } = await import("pdf-parse/worker");
-  const { PDFParse } = await import("pdf-parse");
-  PDFParse.setWorker(getData());
+  const { PDFParse, canvasFactory } = await setupPdfParse();
   const pdf = new PDFParse({
     data: new Uint8Array(buf),
-    CanvasFactory,
+    CanvasFactory: canvasFactory,
   });
   const result = await pdf.getText().finally(() => pdf.destroy());
   const pages = result.pages || [];

package/corpus/templates/slides/actions/import-file.ts

@@ -14,6 +14,7 @@ import { z } from "zod";
 import { getDb, schema } from "../server/db/index.js";
 import { notifyClients } from "../server/handlers/decks.js";
 import { upsertBuilderProxyDesignSystem } from "../server/lib/builder-design-system-proxy.js";
+import { setupPdfParse } from "../server/lib/pdf-parse-setup.js";
 import { readUserUploadedFile } from "./_uploaded-files.js";
 
 const DEFAULT_MAX_SOURCE_CHARS = 60_000;
@@ -211,14 +212,12 @@ export default defineAction({
     }
 
     if (detectedFormat === "pdf") {
-      const { CanvasFactory, getData } = await import("pdf-parse/worker");
-      const { PDFParse } = await import("pdf-parse");
-      PDFParse.setWorker(getData());
+      const { PDFParse, canvasFactory } = await setupPdfParse();
       const { convertSectionsToSlides } =
         await import("../server/handlers/import/html-converter.js");
       const pdf = new PDFParse({
         data: new Uint8Array(fileBuffer),
-        CanvasFactory,
+        CanvasFactory: canvasFactory,
       });
       const result = await pdf.getText().finally(() => pdf.destroy());
       const pages = normalizePdfPages(result);

package/corpus/templates/slides/changelog/2026-07-25-gemini-image-models-updated.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-25
+---
+
+AI image generation uses the current Gemini image models.

package/corpus/templates/slides/changelog/2026-07-25-pdf-imports-tolerate-missing-canvas.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-25
+---
+
+PDF imports keep extracting text when native canvas bindings are unavailable.

package/corpus/templates/slides/server/handlers/image-providers/gemini.ts

@@ -74,9 +74,12 @@ export class GeminiProvider implements ImageProvider {
       imageConfig.aspectRatio = config.aspectRatio;
     }
 
+    // Google retired the "-preview" aliases (shut down 2026-06-25); the GA
+    // model ids dropped the suffix. Sending the old preview ids 404s every
+    // call before falling through to gemini-2.5-flash-image.
     const geminiModels = [
-      "gemini-3.1-flash-image-preview",
-      "gemini-3-pro-image-preview",
+      "gemini-3.1-flash-image",
+      "gemini-3-pro-image",
       "gemini-2.5-flash-image",
     ];
     let lastError: Error | null = null;

package/corpus/templates/slides/server/lib/pdf-parse-setup.ts

@@ -0,0 +1,150 @@
+/**
+ * Prod incident (2026-07-25 reliability sweep): `import-file`'s PDF path
+ * crashed with "DOMMatrix is not defined" 21 times in 14 days. `pdf-parse`'s
+ * `/worker` submodule unconditionally imports `@napi-rs/canvas` (a native
+ * N-API binary) as a side effect of the import itself — just to read its
+ * bundled worker-script blob (`getData()`) — and assigns its `DOMMatrix`
+ * export onto `globalThis` for pdfjs-dist's text-transform math to use. That
+ * native binary is fragile in serverless Lambda-style environments (missing
+ * platform binding, wrong glibc/musl target) and can silently fail to
+ * populate `globalThis.DOMMatrix` without the surrounding import itself
+ * throwing, so the crash only surfaces later, deep inside `getText()`.
+ *
+ * `getText()` never renders to a canvas — `CanvasFactory` is documented
+ * optional on `LoadParameters` and is only consumed by `getImage()`/
+ * `getScreenshot()`. So for pure text extraction we don't need the canvas
+ * import to succeed; we only need SOME `DOMMatrix` implementation to exist
+ * for pdfjs-dist's 2D transform math. This installs a minimal, spec-correct
+ * 2D-affine `DOMMatrix` polyfill (PDF content-stream matrices are always the
+ * 2D 6-value form, never 3D) as a fallback, then attempts the real
+ * `@napi-rs/canvas`-backed setup for the CanvasFactory/worker-script wiring,
+ * catching failure instead of letting it crash the whole import.
+ */
+
+interface Minimal2DMatrix {
+  a: number;
+  b: number;
+  c: number;
+  d: number;
+  e: number;
+  f: number;
+  is2D: boolean;
+  isIdentity: boolean;
+  multiply(other: Minimal2DMatrix): Minimal2DMatrix;
+  translate(tx?: number, ty?: number): Minimal2DMatrix;
+  scale(sx?: number, sy?: number): Minimal2DMatrix;
+  inverse(): Minimal2DMatrix;
+  toString(): string;
+}
+
+function installDomMatrixPolyfillIfMissing(): void {
+  if (
+    typeof (globalThis as { DOMMatrix?: unknown }).DOMMatrix !== "undefined"
+  ) {
+    return;
+  }
+
+  class PolyfillDOMMatrix implements Minimal2DMatrix {
+    a = 1;
+    b = 0;
+    c = 0;
+    d = 1;
+    e = 0;
+    f = 0;
+
+    constructor(init?: number[] | string) {
+      if (Array.isArray(init) && init.length >= 6) {
+        [this.a, this.b, this.c, this.d, this.e, this.f] = init;
+      }
+    }
+
+    get is2D(): boolean {
+      return true;
+    }
+
+    get isIdentity(): boolean {
+      return (
+        this.a === 1 &&
+        this.b === 0 &&
+        this.c === 0 &&
+        this.d === 1 &&
+        this.e === 0 &&
+        this.f === 0
+      );
+    }
+
+    multiply(other: Minimal2DMatrix): PolyfillDOMMatrix {
+      return new PolyfillDOMMatrix([
+        this.a * other.a + this.c * other.b,
+        this.b * other.a + this.d * other.b,
+        this.a * other.c + this.c * other.d,
+        this.b * other.c + this.d * other.d,
+        this.a * other.e + this.c * other.f + this.e,
+        this.b * other.e + this.d * other.f + this.f,
+      ]);
+    }
+
+    translate(tx = 0, ty = 0): PolyfillDOMMatrix {
+      return this.multiply(new PolyfillDOMMatrix([1, 0, 0, 1, tx, ty]));
+    }
+
+    scale(sx = 1, sy = sx): PolyfillDOMMatrix {
+      return this.multiply(new PolyfillDOMMatrix([sx, 0, 0, sy, 0, 0]));
+    }
+
+    inverse(): PolyfillDOMMatrix {
+      const det = this.a * this.d - this.b * this.c;
+      if (det === 0) return new PolyfillDOMMatrix();
+      const invDet = 1 / det;
+      return new PolyfillDOMMatrix([
+        this.d * invDet,
+        -this.b * invDet,
+        -this.c * invDet,
+        this.a * invDet,
+        (this.c * this.f - this.d * this.e) * invDet,
+        (this.b * this.e - this.a * this.f) * invDet,
+      ]);
+    }
+
+    toString(): string {
+      return `matrix(${this.a}, ${this.b}, ${this.c}, ${this.d}, ${this.e}, ${this.f})`;
+    }
+  }
+
+  (globalThis as { DOMMatrix?: unknown }).DOMMatrix = PolyfillDOMMatrix;
+}
+
+/** Result of `setupPdfParse` — pass `canvasFactory` to `new PDFParse(...)` when present. */
+export interface PdfParseSetup {
+  PDFParse: typeof import("pdf-parse").PDFParse;
+  canvasFactory: object | undefined;
+}
+
+/**
+ * Sets up `pdf-parse` for text extraction, tolerating a broken native-canvas
+ * dependency. Always installs the DOMMatrix polyfill FIRST (cheap, no
+ * native deps, spec-correct for the 2D case pdfjs-dist actually uses) so
+ * `getText()` can never hit "DOMMatrix is not defined" regardless of
+ * whether the canvas worker setup below succeeds.
+ */
+export async function setupPdfParse(): Promise<PdfParseSetup> {
+  installDomMatrixPolyfillIfMissing();
+
+  const { PDFParse } = await import("pdf-parse");
+  let canvasFactory: object | undefined;
+  try {
+    const { CanvasFactory, getData } = await import("pdf-parse/worker");
+    PDFParse.setWorker(getData());
+    canvasFactory = CanvasFactory;
+  } catch (err) {
+    // Native @napi-rs/canvas binding unavailable in this runtime — fine for
+    // text-only extraction. Leave the worker script unconfigured (a
+    // documented no-op read, see PDFParse.setWorker) and CanvasFactory
+    // undefined; pdfjs-dist runs in-process without a separate worker.
+    console.warn(
+      "[import-file] pdf-parse canvas worker setup failed, continuing without it (text-only extraction is unaffected):",
+      err instanceof Error ? err.message : String(err),
+    );
+  }
+  return { PDFParse, canvasFactory };
+}