@agent-native/core 0.127.1 → 0.127.3

package/corpus/README.md

@@ -30,4 +30,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 - core files: 1739
 - toolkit files: 160
-- template files: 6815
+- template files: 6816

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @agent-native/core
 
+## 0.127.3
+
+### Patch Changes
+
+- 750e90e: Add a `materialize --out <dir>` subcommand to `agent-native template` that writes the post-processed standalone template tree (e.g. `--template chat`, with the template's own identity, `_gitignore`→`.gitignore`, resolved deps, standalone `netlify.toml`) to a directory — no existing app required. This is the monorepo half of the vendor-branch starter mirror: the public monorepo materializes `templates/chat` and pushes it to the private starter's `template` branch, which the starter merges into `main` with git. Reuses the existing `materializeTemplate` engine.
+
+## 0.127.2
+
+### Patch Changes
+
+- c6ca76a: Fix the Builder Design Systems API base URL fallback incorrectly including an `agent-native/` prefix. The real route is registered as `/design-systems/v1/...` with no `agent-native/` prefix, so requests using the fallback base URL (when `BUILDER_DESIGN_SYSTEMS_BASE_URL` is unset) were hitting the wrong path.
+
 ## 0.127.1
 
 ### Patch Changes

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.127.1",
+  "version": "0.127.3",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {

package/corpus/core/src/cli/template-sync.ts

@@ -476,6 +476,18 @@ export async function runTemplate(
   }
 
   const rest = args.slice(1);
+
+  // `materialize` produces a fresh post-processed template tree at --out; it has
+  // no existing app to resolve, so it runs before target resolution.
+  if (command === "materialize") {
+    try {
+      return await materializeCommand(rest, io);
+    } catch (err) {
+      io.err(err instanceof Error ? err.message : String(err));
+      return 1;
+    }
+  }
+
   const appArg = positionalArgs(rest)[0];
   const flags = {
     to: flagValue(rest, "--to"),
@@ -540,6 +552,87 @@ async function runForTarget(
   }
 }
 
+/**
+ * Write the post-processed template tree to a directory — the pristine,
+ * template-derived output `create` would produce (no install/git/skills).
+ * `--to` defaults to the local template (walked up from the package); pass a ref
+ * to fetch from GitHub instead.
+ */
+async function materializeCommand(
+  rest: string[],
+  io: TemplateIO,
+): Promise<number> {
+  const outDir = flagValue(rest, "--out");
+  const template = flagValue(rest, "--template");
+  const name = flagValue(rest, "--name");
+  const ref = flagValue(rest, "--to") ?? null;
+  if (!outDir) {
+    io.err("template materialize requires --out <dir>.");
+    return 1;
+  }
+  if (!template) {
+    io.err("template materialize requires --template <name>.");
+    return 1;
+  }
+  // Stage into a unique sibling dir, then swap it in crash-safely: move the old
+  // tree aside, move the staged tree in, and restore the old one if that fails.
+  // Directory replacement isn't atomic on POSIX (you can't rename onto a non-empty
+  // dir), so the old tree is only ever moved — never deleted before the new one is
+  // in place — and a crash between the two renames leaves it recoverable under
+  // `backup`. Unique same-filesystem siblings keep each rename atomic and
+  // collision-free.
+  const parent = path.dirname(path.resolve(outDir));
+  fs.mkdirSync(parent, { recursive: true });
+  const tmp = fs.mkdtempSync(path.join(parent, ".template-materialize-"));
+  // `backup` is a unique dir too, so a concurrent process can't occupy the path;
+  // renaming a directory onto an existing *empty* dir is a valid replace on POSIX,
+  // so the `hadOld` rename below still lands cleanly on it.
+  const backup = fs.mkdtempSync(
+    path.join(parent, ".template-materialize-backup-"),
+  );
+  let backupHoldsOriginal = false;
+  try {
+    const result = await materializeTemplate({
+      appName: name ?? template,
+      template,
+      ref,
+      shape: "standalone",
+      destDir: tmp,
+    });
+    const hadOld = fs.existsSync(outDir);
+    if (hadOld) {
+      fs.renameSync(outDir, backup);
+      backupHoldsOriginal = true;
+    }
+    try {
+      fs.renameSync(tmp, outDir);
+      backupHoldsOriginal = false;
+    } catch (err) {
+      if (hadOld) {
+        fs.renameSync(backup, outDir);
+        backupHoldsOriginal = false;
+      }
+      throw err;
+    }
+    io.out(
+      `Materialized "${template}" (${result.source}@${result.ref}) to ${outDir}.`,
+    );
+    return 0;
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+    // If restoring from `backup` above itself threw, `backupHoldsOriginal` is still
+    // true and `backup` is the only remaining copy of the pre-existing output —
+    // leave it on disk instead of deleting the last copy of the user's data.
+    if (!backupHoldsOriginal) {
+      fs.rmSync(backup, { recursive: true, force: true });
+    } else {
+      io.err(
+        `Failed to restore ${outDir}; the previous contents were preserved at ${backup}.`,
+      );
+    }
+  }
+}
+
 function templateName(target: AppTarget, flags: TemplateFlags): string {
   const name = flags.template ?? target.provenance.template;
   if (!name) {
@@ -995,6 +1088,9 @@ function templateUsage(): string {
     "  baseline [app]          Record a baseline for an app scaffolded before",
     "                          provenance existed [--ref <ref>] [--template <name>]",
     "  accept [app]            Advance the baseline after resolving conflicts",
+    "  materialize --template <name> --out <dir>",
+    "                          Write the post-processed template tree to a dir",
+    "                          (no app needed) [--name <appName>] [--to <ref>]",
     "",
     "With no [app], operates on the current app, or on every app in a workspace",
     "when run from the workspace root. --to defaults to the ref matching the",

package/corpus/core/src/server/builder-design-systems.ts

@@ -140,7 +140,7 @@ function trimTrailingSlash(value: string): string {
 export function getBuilderDesignSystemsBaseUrl(): string {
   return (
     process.env.BUILDER_DESIGN_SYSTEMS_BASE_URL ||
-    `${trimTrailingSlash(getBuilderProxyOrigin())}/agent-native/design-systems/v1`
+    `${trimTrailingSlash(getBuilderProxyOrigin())}/design-systems/v1`
   );
 }
 

package/corpus/core/src/templates/chat/_gitignore

@@ -9,8 +9,10 @@ npm-debug.log*
 pnpm-debug.log*
 
 node_modules
+build/
 dist
 dist-ssr
+.output/
 *.local
 
 # Editor directories and files

package/corpus/templates/chat/_gitignore

@@ -9,8 +9,10 @@ npm-debug.log*
 pnpm-debug.log*
 
 node_modules
+build/
 dist
 dist-ssr
+.output/
 *.local
 
 # Editor directories and files

package/corpus/templates/design/.agents/skills/design-generation/SKILL.md

@@ -377,6 +377,29 @@ view only when the user asked to focus one specific screen.
 
 ## HTML Structure Requirements
 
+### The save gate rejects malformed markup
+
+Every path that persists model-authored HTML — `generate-design`, `create-file`,
+`present-design-variants`, `edit-design`, `update-file`, canvas edits — runs an
+integrity check, and a **new** file is held to it strictly. Import paths
+(Figma, localhost, templates, duplication) deliberately do not fail closed:
+that markup comes from a real app or an existing design, and rejecting it would
+block bringing work in rather than prevent a bad generation.
+Rejections name the file, line, column, and offending source line — fix exactly
+what it points at instead of re-sending the payload differently. Blocked: an
+attribute quote that is never closed; an unclosed element or a closing tag with
+no opener; content ending mid-tag (a payload cut off in transit); a
+`<style>`/`<script>` missing its opener or closer; duplicated editor-managed
+style blocks; more than one `<html>`/`<body>`.
+
+This exists because the HTML parser never throws — it recovers silently and
+renders a page, just not the one you wrote. An unterminated quote in `<head>`
+swallows every following tag into that attribute, so the Tailwind runtime stops
+applying and the screen renders unstyled with no console error to show it.
+
+Saves may also return non-blocking `warnings` (e.g. utility classes with no
+reachable Tailwind runtime). Fix those before reporting the design as ready.
+
 ### Mandatory Elements
 
 Every `index.html` must include:

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

@@ -6,6 +6,10 @@ import { nanoid } from "nanoid";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
+import {
+  assertDesignHtmlCreateIntegrity,
+  describeDesignHtmlIntegrityIssue,
+} from "../shared/html-integrity.js";
 import { annotateScreenHtmlForPersist } from "../shared/screen-annotation.js";
 
 export default defineAction({
@@ -63,6 +67,14 @@ export default defineAction({
     // the first time someone opens it.
     const annotatedContent = annotateScreenHtmlForPersist(content, fileType);
 
+    // Reject malformed HTML before the row exists — creation went through raw
+    // inserts, so it was the one write path with no integrity gate.
+    const advisory = assertDesignHtmlCreateIntegrity({
+      content: annotatedContent,
+      fileType: fileType ?? "html",
+      filename,
+    });
+
     await db.insert(schema.designFiles).values({
       id,
       designId,
@@ -94,6 +106,9 @@ export default defineAction({
       fileType: resolvedFileType,
       renderable,
       urlPath: renderable ? `/design/${designId}` : null,
+      ...(advisory.length > 0
+        ? { warnings: advisory.map(describeDesignHtmlIntegrityIssue) }
+        : {}),
     };
   },
 });

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

@@ -45,6 +45,11 @@ import {
   type DesignGenerationSession,
   updateGenerationSessionWithSavedFiles,
 } from "../shared/generation-session.js";
+import {
+  assertDesignHtmlCreateIntegrity,
+  describeDesignHtmlIntegrityIssue,
+  inspectDesignHtmlDocumentIntegrity,
+} from "../shared/html-integrity.js";
 import { assertLockedLayersPreserved } from "../shared/locked-layers.js";
 import { widthToPrefix } from "../shared/responsive-classes.js";
 import { annotateScreenHtmlForPersist } from "../shared/screen-annotation.js";
@@ -769,6 +774,38 @@ const generateDesignAction = defineAction({
       content: annotateScreenHtmlForPersist(file.content, file.fileType),
     }));
 
+    // Gate every NEW file up front so a rejected file cannot orphan the ones
+    // written before it. Existing files take the edit transition inside
+    // writeInlineSourceFile, which still allows repairing a malformed screen.
+    const integrityWarnings: Array<{ filename: string; message: string }> = [];
+    for (const file of annotatedFiles) {
+      if ((file.fileType ?? "html") !== "html") continue;
+      const existing = existingByName.get(file.filename);
+      // A row changing type into HTML is new HTML, not an edit: the edit
+      // transition validates against the row's CURRENT type, so a css→html
+      // candidate would skip the HTML checks and still be stored as HTML below.
+      const becomesHtml =
+        existing !== undefined && (existing.fileType ?? "html") !== "html";
+      // Blocking applies to new files and type transitions. An existing HTML row
+      // takes the lenient edit transition instead, so a legacy-malformed screen
+      // stays repairable — but its advisories are still reported, or the same
+      // content would warn as a new file and save silently as a regeneration.
+      const advisory =
+        !existing || becomesHtml
+          ? assertDesignHtmlCreateIntegrity({
+              content: file.content,
+              fileType: "html",
+              filename: file.filename,
+            })
+          : (inspectDesignHtmlDocumentIntegrity(file.content).advisory ?? []);
+      for (const entry of advisory) {
+        integrityWarnings.push({
+          filename: file.filename,
+          message: describeDesignHtmlIntegrityIssue(entry),
+        });
+      }
+    }
+
     for (const file of annotatedFiles) {
       const existing = existingByName.get(file.filename);
       if (existing) {
@@ -1198,6 +1235,9 @@ const generateDesignAction = defineAction({
       savedFiles,
       placedFrames,
       fileCount: savedFiles.length,
+      // Non-blocking: a well-formed screen with no Tailwind runtime renders
+      // unstyled, which reads as a layout bug rather than a missing runtime.
+      ...(integrityWarnings.length > 0 ? { warnings: integrityWarnings } : {}),
       ...creativeContextProvenance,
     };
   },

package/corpus/templates/design/actions/present-design-variants.ts

@@ -19,6 +19,7 @@ import {
   type CanvasFramePlacement,
 } from "../shared/canvas-frames.js";
 import { isUniqueConstraintViolation } from "../shared/db-conflict.js";
+import { assertDesignHtmlWellFormed } from "../shared/html-integrity.js";
 import { widthToPrefix } from "../shared/responsive-classes.js";
 import { annotateScreenHtmlForPersist } from "../shared/screen-annotation.js";
 
@@ -826,6 +827,21 @@ export default defineAction({
   run: async ({ designId, prompt, variants, deleteSupersededSetIds }) => {
     await assertAccess("design", designId, "editor");
 
+    // Before any mutation. These are model-authored screens created by raw
+    // insert, so they need the same well-formedness gate as generate-design —
+    // though not its document-shape rules, since a variant may be a sketch with
+    // `<html>`/`<body>` implied. Ordering is the load-bearing part: the
+    // supersession and deletion below are irreversible, so throwing after them
+    // would destroy existing variant sets and create nothing to replace them.
+    for (const variant of variants) {
+      const candidate = variant.content?.trim();
+      if (!candidate) continue;
+      assertDesignHtmlWellFormed({
+        content: annotateScreenHtmlForPersist(candidate, "html"),
+        filename: `variant-${slugify(variant.label.trim(), "option")}.html`,
+      });
+    }
+
     // Non-destructive bookkeeping: flag earlier still-complete variant sets
     // as superseded. Files are NEVER deleted automatically — a user's pick
     // exists only as a chat instruction until the agent's delete-file turn

package/corpus/templates/design/app/pages/design-editor/save-failure.ts

@@ -1,4 +1,7 @@
-import { isDesignHtmlIntegrityError } from "@shared/html-integrity";
+import {
+  DESIGN_HTML_INTEGRITY_SUMMARY,
+  isDesignHtmlIntegrityError,
+} from "@shared/html-integrity";
 
 export type DesignSaveFailureKind =
   | "offline"
@@ -14,6 +17,9 @@ function errorField(error: unknown, field: string): unknown {
 }
 
 export function designSaveErrorMessage(error: unknown): string | null {
+  // Integrity errors carry located, agent-facing guidance in `message`. Toasts
+  // get the summary instead; the two audiences need different text.
+  if (isDesignHtmlIntegrityError(error)) return DESIGN_HTML_INTEGRITY_SUMMARY;
   const message = errorField(error, "message");
   if (typeof message !== "string" || !message.trim()) return null;
   return message.replace(/^DESIGN_HTML_INTEGRITY:\s*/, "");

package/corpus/templates/design/changelog/2026-07-28-generated-designs-with-malformed-html-are-now-rejected-at-sa.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-28
+---
+
+Generated designs with malformed HTML are now rejected at save with the exact line and character to fix, instead of persisting and rendering broken.

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

@@ -361,6 +361,7 @@ export async function writeInlineSourceFile(args: {
       previousContent: current.content,
       nextContent: args.content,
       fileType: currentFile.fileType ?? args.file.fileType ?? "html",
+      filename: currentFile.filename ?? args.file.filename,
     });
 
     if (await hasCollabState(args.file.id)) {