@agent-native/core 0.95.1 → 0.97.0

package/corpus/templates/design/shared/local-jsx-visual-edit.ts

@@ -0,0 +1,388 @@
+import { previewSourceDiff } from "./source-workspace.js";
+
+export interface LocalJsxSourceAnchor {
+  line: number;
+  column: number;
+  runtimeMultiplicity?: number;
+  scope?:
+    | "single-instance"
+    | "repeated-render"
+    | "shared-component-definition"
+    | "unknown";
+}
+
+export type LocalJsxLeafIntent =
+  | {
+      kind: "textContent";
+      value: string;
+    }
+  | {
+      kind: "class";
+      operation: "add" | "remove" | "replace" | "set";
+      className?: string;
+      classNames?: string[];
+      from?: string;
+      to?: string;
+    }
+  | { kind: "style"; property: string; value: string };
+
+export interface LocalJsxVisualEditResult {
+  content: string;
+  result: {
+    status: "applied" | "conflict" | "needsAgent" | "unsupported";
+    changed: boolean;
+    message: string;
+  };
+  proposedDiff?: ReturnType<typeof previewSourceDiff>;
+}
+
+interface OpeningTag {
+  start: number;
+  end: number;
+  name: string;
+  selfClosing: boolean;
+}
+
+function offsetAt(
+  content: string,
+  line: number,
+  column: number,
+): number | null {
+  if (
+    !Number.isInteger(line) ||
+    !Number.isInteger(column) ||
+    line < 1 ||
+    column < 1
+  )
+    return null;
+  let offset = 0;
+  for (let currentLine = 1; currentLine < line; currentLine += 1) {
+    const newline = content.indexOf("\n", offset);
+    if (newline === -1) return null;
+    offset = newline + 1;
+  }
+  const result = offset + column - 1;
+  return result <= content.length ? result : null;
+}
+
+function positionAt(
+  content: string,
+  offset: number,
+): { line: number; column: number } {
+  let line = 1;
+  let lineStart = 0;
+  for (let index = 0; index < offset; index += 1) {
+    if (content.charCodeAt(index) === 10) {
+      line += 1;
+      lineStart = index + 1;
+    }
+  }
+  return { line, column: offset - lineStart + 1 };
+}
+
+function scanOpeningTags(content: string): OpeningTag[] {
+  const tags: OpeningTag[] = [];
+  for (let start = 0; start < content.length; start += 1) {
+    if (content[start] === "/" && content[start + 1] === "/") {
+      const newline = content.indexOf("\n", start + 2);
+      start = newline === -1 ? content.length : newline;
+      continue;
+    }
+    if (content[start] === "/" && content[start + 1] === "*") {
+      const close = content.indexOf("*/", start + 2);
+      start = close === -1 ? content.length : close + 1;
+      continue;
+    }
+    if (
+      content[start] === '"' ||
+      content[start] === "'" ||
+      content[start] === "`"
+    ) {
+      const quote = content[start];
+      for (start += 1; start < content.length; start += 1) {
+        if (content[start] === quote && content[start - 1] !== "\\") break;
+      }
+      continue;
+    }
+    if (content[start] !== "<" || /[!/?]/.test(content[start + 1] ?? ""))
+      continue;
+    const nameMatch = /^[A-Za-z][A-Za-z0-9_.:-]*/.exec(
+      content.slice(start + 1),
+    );
+    if (!nameMatch) continue;
+    let quote = "";
+    let braces = 0;
+    for (
+      let index = start + 1 + nameMatch[0].length;
+      index < content.length;
+      index += 1
+    ) {
+      const char = content[index] ?? "";
+      if (quote) {
+        if (char === quote && content[index - 1] !== "\\") quote = "";
+        continue;
+      }
+      if (char === '"' || char === "'") {
+        quote = char;
+        continue;
+      }
+      if (char === "{") braces += 1;
+      else if (char === "}") braces -= 1;
+      else if (char === ">" && braces === 0) {
+        const before = content.slice(start, index).trimEnd();
+        tags.push({
+          start,
+          end: index + 1,
+          name: nameMatch[0],
+          selfClosing: before.endsWith("/"),
+        });
+        start = index;
+        break;
+      }
+      if (braces < 0) break;
+    }
+  }
+  return tags;
+}
+
+function fail(
+  content: string,
+  status: LocalJsxVisualEditResult["result"]["status"],
+  message: string,
+): LocalJsxVisualEditResult {
+  return { content, result: { status, changed: false, message } };
+}
+
+function replaceRange(
+  content: string,
+  start: number,
+  end: number,
+  replacement: string,
+  message: string,
+): LocalJsxVisualEditResult {
+  const next = `${content.slice(0, start)}${replacement}${content.slice(end)}`;
+  return {
+    content: next,
+    result: { status: "applied", changed: next !== content, message },
+    proposedDiff: previewSourceDiff(content, next),
+  };
+}
+
+function jsxText(value: string): string {
+  return value
+    .split("&")
+    .join("&amp;")
+    .split("<")
+    .join("&lt;")
+    .split(">")
+    .join("&gt;")
+    .split("{")
+    .join("&#123;")
+    .split("}")
+    .join("&#125;");
+}
+
+function camelProperty(property: string): string | null {
+  const value = property
+    .trim()
+    .replace(/-([a-z])/g, (_, char: string) => char.toUpperCase());
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value) ? value : null;
+}
+
+export function planLocalJsxVisualEdit(args: {
+  content: string;
+  anchor: LocalJsxSourceAnchor;
+  intent: LocalJsxLeafIntent;
+}): LocalJsxVisualEditResult {
+  const { content, anchor, intent } = args;
+  if (
+    (anchor.runtimeMultiplicity ?? 1) !== 1 ||
+    anchor.scope === "repeated-render" ||
+    anchor.scope === "shared-component-definition"
+  ) {
+    return fail(
+      content,
+      "needsAgent",
+      "The source anchor renders more than one instance or belongs to a shared component; inspect its call sites before editing.",
+    );
+  }
+  const anchorOffset = offsetAt(content, anchor.line, anchor.column);
+  if (anchorOffset === null) {
+    return fail(
+      content,
+      "conflict",
+      "The source anchor is outside the current file.",
+    );
+  }
+  const candidates = scanOpeningTags(content).filter((tag) => {
+    const position = positionAt(content, tag.start);
+    return (
+      position.line === anchor.line &&
+      Math.abs(position.column - anchor.column) <= 1
+    );
+  });
+  if (candidates.length !== 1) {
+    return fail(
+      content,
+      "conflict",
+      candidates.length === 0
+        ? "No JSX element starts at the supplied source anchor. Re-resolve the live selection."
+        : "The supplied source anchor is ambiguous.",
+    );
+  }
+  const tag = candidates[0]!;
+  const opening = content.slice(tag.start, tag.end);
+  if (/\{\s*\.\.\./.test(opening)) {
+    return fail(
+      content,
+      "needsAgent",
+      "JSX spread attributes require semantic source inspection.",
+    );
+  }
+
+  if (intent.kind === "textContent") {
+    if (tag.selfClosing)
+      return fail(
+        content,
+        "unsupported",
+        "A self-closing JSX element has no leaf text to edit.",
+      );
+    const close = `</${tag.name}>`;
+    const closeStart = content.indexOf(close, tag.end);
+    if (closeStart === -1)
+      return fail(
+        content,
+        "conflict",
+        "The JSX closing tag could not be resolved.",
+      );
+    const inner = content.slice(tag.end, closeStart);
+    if (/[<>{}]/.test(inner)) {
+      return fail(
+        content,
+        "needsAgent",
+        "Only leaf JSX text without child elements or expressions can be edited deterministically.",
+      );
+    }
+    return replaceRange(
+      content,
+      tag.end,
+      closeStart,
+      jsxText(intent.value),
+      "Leaf JSX text updated.",
+    );
+  }
+
+  if (intent.kind === "class") {
+    const attr = /\s(className|class)\s*=\s*(["'])(.*?)\2/s.exec(opening);
+    if (!attr && /\s(?:className|class)\s*=/.test(opening)) {
+      return fail(
+        content,
+        "needsAgent",
+        "Dynamic JSX class expressions require semantic source inspection.",
+      );
+    }
+    let classes = attr?.[3]?.split(/\s+/).filter(Boolean) ?? [];
+    const requested =
+      intent.classNames ?? (intent.className ? [intent.className] : []);
+    const replacementTokens = [
+      ...requested,
+      ...(intent.from ? [intent.from] : []),
+      ...(intent.to ? [intent.to] : []),
+    ];
+    if (
+      replacementTokens.some((token) => !token || /[\s"'`<>{}=]/.test(token))
+    ) {
+      return fail(
+        content,
+        "unsupported",
+        "Class tokens must be plain non-whitespace tokens without JSX delimiters.",
+      );
+    }
+    if (intent.operation === "set") classes = requested;
+    else if (intent.operation === "add") classes = [...classes, ...requested];
+    else if (intent.operation === "remove")
+      classes = classes.filter((item) => !requested.includes(item));
+    else {
+      if (!intent.from || !intent.to || !classes.includes(intent.from))
+        return fail(
+          content,
+          "conflict",
+          "The class replacement guard does not match the current literal class list.",
+        );
+      classes = classes.map((item) =>
+        item === intent.from ? intent.to! : item,
+      );
+    }
+    classes = [...new Set(classes)];
+    const replacement = classes.join(" ");
+    let nextOpening: string;
+    if (attr) {
+      const valueStart = attr.index! + attr[0].indexOf(attr[3]!);
+      nextOpening = `${opening.slice(0, valueStart)}${replacement}${opening.slice(valueStart + attr[3]!.length)}`;
+    } else if (intent.operation === "add" || intent.operation === "set") {
+      const insertAt = opening.lastIndexOf(tag.selfClosing ? "/>" : ">");
+      nextOpening = `${opening.slice(0, insertAt)} className="${replacement.split('"').join("&quot;")}"${opening.slice(insertAt)}`;
+    } else {
+      return fail(
+        content,
+        "conflict",
+        "The anchored JSX element has no literal className/class attribute.",
+      );
+    }
+    return replaceRange(
+      content,
+      tag.start,
+      tag.end,
+      nextOpening,
+      "Literal JSX classes updated.",
+    );
+  }
+
+  const property = camelProperty(intent.property);
+  if (!property)
+    return fail(
+      content,
+      "unsupported",
+      "The CSS property cannot be represented as a JSX style key.",
+    );
+  const styleAttr = /\sstyle\s*=\s*\{\{([\s\S]*?)\}\}/.exec(opening);
+  let nextOpening: string;
+  if (!styleAttr) {
+    if (/\sstyle\s*=/.test(opening))
+      return fail(
+        content,
+        "needsAgent",
+        "Dynamic JSX style expressions require semantic source inspection.",
+      );
+    const insertAt = opening.lastIndexOf(tag.selfClosing ? "/>" : ">");
+    const value = JSON.stringify(intent.value);
+    nextOpening = `${opening.slice(0, insertAt)} style={{ ${property}: ${value} }}${opening.slice(insertAt)}`;
+  } else {
+    const body = styleAttr[1]!;
+    const literalStyleObject =
+      /^\s*(?:[A-Za-z_$][A-Za-z0-9_$]*\s*:\s*(?:"[^"\n]*"|'[^'\n]*'|-?\d+(?:\.\d+)?)(?:\s*,\s*[A-Za-z_$][A-Za-z0-9_$]*\s*:\s*(?:"[^"\n]*"|'[^'\n]*'|-?\d+(?:\.\d+)?)\s*,?)*|)\s*$/;
+    if (!literalStyleObject.test(body))
+      return fail(
+        content,
+        "needsAgent",
+        "Only flat literal JSX style objects can be edited deterministically.",
+      );
+    const propertyPattern = new RegExp(
+      `(^|[,\\s])(${property})\\s*:\\s*((?:["'][^"'\\n]*["'])|-?\\d+(?:\\.\\d+)?)`,
+      "s",
+    );
+    const match = propertyPattern.exec(body);
+    const nextBody = match
+      ? `${body.slice(0, match.index + match[1]!.length)}${property}: ${JSON.stringify(intent.value)}${body.slice(match.index + match[0].length)}`
+      : `${body.trimEnd()}${body.trim() ? ", " : ""}${property}: ${JSON.stringify(intent.value)}${body.endsWith(" ") ? " " : ""}`;
+    const bodyStart = styleAttr.index! + styleAttr[0].indexOf(body);
+    nextOpening = `${opening.slice(0, bodyStart)}${nextBody}${opening.slice(bodyStart + body.length)}`;
+  }
+  return replaceRange(
+    content,
+    tag.start,
+    tag.end,
+    nextOpening,
+    "Literal JSX style updated.",
+  );
+}

package/corpus/templates/dispatch/package.json

@@ -20,7 +20,7 @@
     "@radix-ui/react-tooltip": "^1.2.7",
     "@tabler/icons-react": "catalog:",
     "@tanstack/react-query": "^5.99.2",
-    "h3": "^2.0.1-rc.20",
+    "h3": "catalog:",
     "isbot": "^5",
     "next-themes": "^0.4.6",
     "sonner": "^2.0.7",
@@ -40,7 +40,6 @@
     "react-router": "^8.1.0",
     "tailwindcss": "catalog:",
     "tsx": "^4.20.3",
-    "typescript": "catalog:",
     "typescript-7": "catalog:",
     "vite": "catalog:",
     "vitest": "catalog:"

package/corpus/templates/forms/actions/patch-form-fields.ts

@@ -6,6 +6,12 @@
  * concurrent edits to DIFFERENT fields both survive instead of the later
  * client overwriting the earlier one with its stale full-array snapshot.
  *
+ * The read-modify-write runs under a per-form in-process lock (same pattern
+ * as `patch-deck` in the slides template) so two concurrent callers (e.g. the
+ * form-builder autosave and an agent edit) are serialized instead of racing
+ * on the same row — without the lock, the second writer's read would miss
+ * the first writer's not-yet-committed update and silently clobber it.
+ *
  * The UI form builder uses this action for all incremental edits.
  * The legacy `update-form --fields <json>` path remains available for agents
  * and bulk imports that want to replace the whole fields array at once.
@@ -21,6 +27,36 @@ import { assertValidFields } from "../server/lib/validate-fields.js";
 import type { FormField } from "../shared/types.js";
 import { assertPublishableForm } from "./lib/assert-publishable-form.js";
 
+// ---------------------------------------------------------------------------
+// Per-form write lock — mirrors `withDeckLock` in
+// templates/slides/actions/patch-deck.ts so concurrent client and agent
+// writes to the same form's fields are serialised in-process.
+// ---------------------------------------------------------------------------
+const LOCK_KEY = "__formsFieldPatchLocks" as const;
+type GlobalWithLocks = typeof globalThis & {
+  [LOCK_KEY]?: Map<string, Promise<unknown>>;
+};
+const globalRef = globalThis as GlobalWithLocks;
+if (!globalRef[LOCK_KEY]) {
+  globalRef[LOCK_KEY] = new Map<string, Promise<unknown>>();
+}
+const formLocks: Map<string, Promise<unknown>> = globalRef[LOCK_KEY]!;
+
+export function withFormLock<T>(
+  formId: string,
+  fn: () => Promise<T>,
+): Promise<T> {
+  const prev = formLocks.get(formId) ?? Promise.resolve();
+  const next = prev.then(fn, fn);
+  formLocks.set(formId, next);
+  next
+    .finally(() => {
+      if (formLocks.get(formId) === next) formLocks.delete(formId);
+    })
+    .catch(() => {});
+  return next;
+}
+
 const fieldOpSchema = z.union([
   z.object({
     op: z.literal("upsert"),
@@ -50,58 +86,60 @@ export default defineAction({
   run: async (args) => {
     await assertAccess("form", args.id, "editor");
 
-    const db = getDb();
-    const [existing] = await db
-      .select()
-      .from(schema.forms)
-      .where(eq(schema.forms.id, args.id))
-      .limit(1);
+    return withFormLock(args.id, async () => {
+      const db = getDb();
+      const [existing] = await db
+        .select()
+        .from(schema.forms)
+        .where(eq(schema.forms.id, args.id))
+        .limit(1);
 
-    if (!existing) {
-      throw new Error(`Form ${args.id} not found`);
-    }
+      if (!existing) {
+        throw new Error(`Form ${args.id} not found`);
+      }
 
-    let ops: Array<{ op: string; [k: string]: unknown }>;
-    if (typeof args.ops === "string") {
-      try {
-        ops = JSON.parse(args.ops);
-      } catch {
-        throw new Error("--ops must be valid JSON");
+      let ops: Array<{ op: string; [k: string]: unknown }>;
+      if (typeof args.ops === "string") {
+        try {
+          ops = JSON.parse(args.ops);
+        } catch {
+          throw new Error("--ops must be valid JSON");
+        }
+      } else {
+        ops = args.ops as Array<{ op: string; [k: string]: unknown }>;
       }
-    } else {
-      ops = args.ops as Array<{ op: string; [k: string]: unknown }>;
-    }
 
-    if (!Array.isArray(ops)) {
-      throw new Error("ops must be an array");
-    }
+      if (!Array.isArray(ops)) {
+        throw new Error("ops must be an array");
+      }
 
-    // Parse current fields from the DB row.
-    let currentFields: FormField[] = [];
-    try {
-      currentFields = JSON.parse(existing.fields) as FormField[];
-    } catch {
-      currentFields = [];
-    }
+      // Parse current fields from the DB row.
+      let currentFields: FormField[] = [];
+      try {
+        currentFields = JSON.parse(existing.fields) as FormField[];
+      } catch {
+        currentFields = [];
+      }
 
-    // Apply ops server-side so concurrent edits on different fields both land.
-    const nextFields = applyFieldOps(
-      currentFields,
-      ops as Parameters<typeof applyFieldOps>[1],
-    );
+      // Apply ops server-side so concurrent edits on different fields both land.
+      const nextFields = applyFieldOps(
+        currentFields,
+        ops as Parameters<typeof applyFieldOps>[1],
+      );
 
-    // Validate the result before persisting.
-    assertValidFields(nextFields);
-    if (existing.status === "published") {
-      assertPublishableForm(nextFields);
-    }
+      // Validate the result before persisting.
+      assertValidFields(nextFields);
+      if (existing.status === "published") {
+        assertPublishableForm(nextFields);
+      }
 
-    const now = new Date().toISOString();
-    await db
-      .update(schema.forms)
-      .set({ fields: JSON.stringify(nextFields), updatedAt: now })
-      .where(eq(schema.forms.id, args.id));
+      const now = new Date().toISOString();
+      await db
+        .update(schema.forms)
+        .set({ fields: JSON.stringify(nextFields), updatedAt: now })
+        .where(eq(schema.forms.id, args.id));
 
-    return { id: args.id, fields: nextFields, updatedAt: now };
+      return { id: args.id, fields: nextFields, updatedAt: now };
+    });
   },
 });

package/corpus/templates/forms/changelog/2026-07-10-simultaneous-edits-to-different-form-fields-no-longer-overwr.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Simultaneous edits to different form fields no longer overwrite each other

package/corpus/templates/forms/package.json

@@ -39,7 +39,7 @@
     "cmdk": "^1.1.1",
     "drizzle-orm": "^0.45.2",
     "embla-carousel-react": "^8.6.0",
-    "h3": "^2.0.1-rc.20",
+    "h3": "catalog:",
     "input-otp": "^1.4.2",
     "isbot": "^5",
     "nanoid": "^5.1.9",
@@ -87,7 +87,6 @@
     "sonner": "^2.0.7",
     "tailwind-merge": "^3.5.0",
     "tailwindcss": "catalog:",
-    "typescript": "catalog:",
     "typescript-7": "catalog:",
     "vite": "catalog:",
     "vitest": "catalog:"

package/corpus/templates/macros/package.json

@@ -24,7 +24,7 @@
     "@supabase/supabase-js": "^2.101.1",
     "@tabler/icons-react": "catalog:",
     "drizzle-orm": "^0.45.2",
-    "h3": "^2.0.1-rc.20",
+    "h3": "catalog:",
     "isbot": "^5",
     "recharts": "^3.8.1",
     "zod": "^4.4.3"
@@ -86,7 +86,6 @@
     "tailwind-merge": "^3.5.0",
     "tailwindcss": "catalog:",
     "tsx": "^4.20.3",
-    "typescript": "catalog:",
     "typescript-7": "catalog:",
     "vaul": "^1.1.2",
     "vite": "catalog:",

package/corpus/templates/mail/app/components/email/EmailThread.tsx

@@ -3042,6 +3042,7 @@ function HtmlEmailBody({
       } catch {}
     });
 
+    let handleRsvpClick: ((e: MouseEvent) => void) | null = null;
     if (calEventId && rsvpLinks.length > 0) {
       const eventId = calEventId;
       rsvpLinks.forEach((a) => {
@@ -3083,7 +3084,7 @@ function HtmlEmailBody({
       });
 
       // Handle RSVP clicks inline
-      const handleRsvpClick = async (e: MouseEvent) => {
+      handleRsvpClick = async (e: MouseEvent) => {
         const anchor = (e.target as Element)?.closest?.(
           'a[href*="calendar.google.com/calendar/event"]',
         ) as HTMLElement | null;
@@ -3189,6 +3190,7 @@ function HtmlEmailBody({
 
     return () => {
       doc.removeEventListener("click", handleLinkClick);
+      if (handleRsvpClick) doc.removeEventListener("click", handleRsvpClick);
       doc.removeEventListener("keydown", forwardKey);
       clearTimeout(timer);
       clearTimeout(timer2);

package/corpus/templates/mail/changelog/2026-07-10-fixed-calendar-rsvp-buttons-in-emails-firing-duplicate-respo.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Fixed calendar RSVP buttons in emails firing duplicate responses after theme changes

package/corpus/templates/mail/package.json

@@ -25,7 +25,7 @@
     "chrono-node": "^2.7.6",
     "drizzle-orm": "^0.45.2",
     "embla-carousel-react": "^8.6.0",
-    "h3": "^2.0.1-rc.20",
+    "h3": "catalog:",
     "input-otp": "^1.4.2",
     "isbot": "^5",
     "jose": "^6.2.2",
@@ -102,7 +102,6 @@
     "tailwindcss": "catalog:",
     "tiptap-markdown": "^0.9.0",
     "tsx": "^4.20.3",
-    "typescript": "catalog:",
     "typescript-7": "catalog:",
     "vaul": "^1.1.2",
     "vite": "catalog:",