@agent-native/core 0.80.4 → 0.80.5

package/corpus/templates/content/shared/builder-mdx.ts

@@ -20,6 +20,7 @@ export const BUILDER_DOCS_MODELS = [
   "docs-content",
   "blog-article",
   "agent-native-blog-article-test",
+  "symbol",
 ] as const;
 
 export type BuilderDocsModel = (typeof BUILDER_DOCS_MODELS)[number] | string;
@@ -175,6 +176,7 @@ export function builderRawRootForEntry(model: string, entryId: string) {
 function modelDirectory(model: string) {
   if (model === "docs-content") return "docs";
   if (model === "blog-article") return "blog";
+  if (model === "symbol") return "symbols";
   return safePathPart(model);
 }
 
@@ -194,6 +196,23 @@ export function builderMdxPathForEntry(entry: BuilderContentEntry) {
   )}/${slug}${BUILDER_DOCS_MDX_EXTENSION}`;
 }
 
+function builderSymbolMdxPathForEntry(entry: BuilderContentEntry) {
+  const data = entry.data ?? {};
+  const title = builderEntryTitle(entry);
+  const handle = stringFromRecord(data, [
+    "handle",
+    "slug",
+    "urlPath",
+    "url",
+    "path",
+  ]);
+  const slug = slugify(handle?.replace(/^\/+|\/+$/g, "") || title, entry.id);
+  return `${BUILDER_DOCS_CONTENT_ROOT}/symbols/${safePathPart(
+    entry.model,
+    "symbol",
+  )}/${slug}${BUILDER_DOCS_MDX_EXTENSION}`;
+}
+
 function stringFromRecord(
   record: Record<string, unknown>,
   keys: string[],
@@ -357,6 +376,50 @@ function childBlocks(block: unknown): unknown[] {
   return Array.isArray(block.children) ? block.children : [];
 }
 
+function symbolContentEntry(
+  symbol: Record<string, unknown>,
+): BuilderContentEntry | null {
+  const content = isRecord(symbol.content) ? symbol.content : null;
+  if (!content) return null;
+  const rawModel = stringFromRecord(symbol, ["model"]);
+  const rawEntry = stringFromRecord(symbol, ["entry"]);
+  const id = stringFromRecord(content, ["id", "entry", "uid"]) ?? rawEntry;
+  if (!id) return null;
+
+  const model =
+    stringFromRecord(content, ["model", "modelName", "queryModel"]) ??
+    rawModel ??
+    "symbol";
+  const data = isRecord(content.data)
+    ? (JSON.parse(JSON.stringify(content.data)) as Record<string, unknown>)
+    : {};
+  if (!Array.isArray(data.blocks) && Array.isArray(content.blocks)) {
+    data.blocks = content.blocks;
+  }
+  if (!data.blocks) return null;
+
+  return {
+    ...content,
+    id,
+    model,
+    name:
+      stringFromRecord(content, ["name"]) ??
+      stringFromRecord(data, ["title", "pageTitle", "name"]) ??
+      id,
+    published:
+      typeof content.published === "string" ? content.published : undefined,
+    lastUpdated:
+      typeof content.lastUpdated === "string" ||
+      typeof content.lastUpdated === "number"
+        ? content.lastUpdated
+        : typeof content.updatedDate === "string" ||
+            typeof content.updatedDate === "number"
+          ? content.updatedDate
+          : undefined,
+    data,
+  };
+}
+
 function blockSummary(block: unknown) {
   const name = componentName(block);
   const options = componentOptions(block);
@@ -382,6 +445,7 @@ interface BlocksToMdxContext {
   rawRoot: string;
   files: Record<string, string>;
   warnings: string[];
+  emitReferencedEntry: (entry: BuilderContentEntry) => Promise<string>;
 }
 
 async function builderBlocksToMdxBody(
@@ -493,10 +557,19 @@ async function builderBlockToMdx(
 
   if (name === "Symbol") {
     const symbol = isRecord(options.symbol) ? options.symbol : {};
+    const contentEntry = symbolContentEntry(symbol);
+    const source = contentEntry
+      ? await ctx.emitReferencedEntry(contentEntry)
+      : undefined;
     const data: BuilderSymbolData = {
       ...raw,
       entry: typeof symbol.entry === "string" ? symbol.entry : undefined,
       model: typeof symbol.model === "string" ? symbol.model : undefined,
+      source,
+      dynamic:
+        boolFromRecord(symbol, "dynamic") ??
+        boolFromRecord(symbol, "isDynamic") ??
+        boolFromRecord(options, "dynamicSymbol"),
       data: isRecord(symbol.data) ? symbol.data : undefined,
     };
     return serializeRegistryBlockToMdx("builder-symbol", {
@@ -525,12 +598,76 @@ async function builderBlockToMdx(
 export async function builderEntryToMdxBundle(
   entry: BuilderContentEntry,
 ): Promise<BuilderMdxBundle> {
+  const files: Record<string, string> = {};
+  const warnings: string[] = [];
+  const emitted = new Set<string>();
+  const mdx = await emitBuilderEntryToMdxFile({
+    entry,
+    files,
+    warnings,
+    emitted,
+    symbolPath: false,
+  });
+  return { mdx, files, blocks: builderEntryBlocks(entry) };
+}
+
+async function emitBuilderEntryToMdxFile({
+  entry,
+  files,
+  warnings,
+  emitted,
+  symbolPath,
+}: {
+  entry: BuilderContentEntry;
+  files: Record<string, string>;
+  warnings: string[];
+  emitted: Set<string>;
+  symbolPath: boolean;
+}): Promise<BuilderMdxFile> {
+  const path = symbolPath
+    ? builderSymbolMdxPathForEntry(entry)
+    : builderMdxPathForEntry(entry);
+  const key = `${entry.model}:${entry.id}:${path}`;
+  if (emitted.has(key)) {
+    return {
+      path,
+      documentId: builderDocumentId(entry.model, entry.id),
+      title: builderEntryTitle(entry),
+      metadata: {
+        model: entry.model,
+        entryId: entry.id,
+        lastUpdated: normalizeRemoteUpdatedAt(entry),
+        published: entry.published,
+        sourceHash: builderSourceHash(entry),
+        blocksHash: builderBlocksHash(builderEntryBlocks(entry)),
+        rawRoot: builderRawRootForEntry(entry.model, entry.id),
+        path,
+      },
+      frontmatter: {},
+      body: "",
+      source: files[path] ?? "",
+    };
+  }
+  emitted.add(key);
+
   const blocks = builderEntryBlocks(entry);
   const rawRoot = builderRawRootForEntry(entry.model, entry.id);
-  const files: Record<string, string> = {};
-  const ctx: BlocksToMdxContext = { rawRoot, files, warnings: [] };
+  const ctx: BlocksToMdxContext = {
+    rawRoot,
+    files,
+    warnings,
+    emitReferencedEntry: async (referencedEntry) => {
+      const nested = await emitBuilderEntryToMdxFile({
+        entry: referencedEntry,
+        files,
+        warnings,
+        emitted,
+        symbolPath: true,
+      });
+      return nested.path;
+    },
+  };
   const body = await builderBlocksToMdxBody(blocks, ctx);
-  const path = builderMdxPathForEntry(entry);
   const blocksHash = builderBlocksHash(blocks);
   const sourceHash = builderSourceHash(entry);
   const frontmatter = frontmatterForEntry({
@@ -552,7 +689,7 @@ export async function builderEntryToMdxBundle(
     source,
   };
   files[path] = source;
-  return { mdx, files, blocks };
+  return mdx;
 }
 
 function parseFrontmatterValue(value: string): unknown {

package/corpus/templates/content/shared/nfm.ts

@@ -673,6 +673,7 @@ function serializeBlock(node: PMNode, indent: number): string[] {
       return serializeBlockAtom(node, ind);
     case "registryBlock":
       return serializeRegistryBlock(node, ind);
+    case "contentReference":
     case "localMdxComponent":
       return serializeRawSourceBlock(node, ind);
     default: {
@@ -1199,6 +1200,19 @@ function parseSingleBlock(
     return { nodes: [withIndentAttr(node)], end: childRes.end };
   }
 
+  // Content reference (Notion-style reusable MDX transclusion). The source
+  // owns the reference; the editor resolves and previews it from local files.
+  const contentReferenceTag = matchContentReferenceOpen(dedent);
+  if (contentReferenceTag) {
+    return parseContentReference(
+      lines,
+      start,
+      indent,
+      rel,
+      contentReferenceTag,
+    );
+  }
+
   // Registry block (PascalCase MDX element: <Endpoint .../>, <Checklist .../>,
   // <DataModel …>…</DataModel>, …). These are the dev-doc / OpenAPI library
   // blocks shared with plan, encoded inline. They are recognized by the content
@@ -1288,6 +1302,12 @@ function matchRegistryBlockOpen(dedent: string): string | null {
   return registryBlockSpecByTag(tag) ? tag : null;
 }
 
+function matchContentReferenceOpen(dedent: string): string | null {
+  return /^<ContentReference(?:[\s/>]|$)/.test(dedent)
+    ? "ContentReference"
+    : null;
+}
+
 function matchLocalMdxComponentOpen(dedent: string): string | null {
   const m = dedent.match(/^<([A-Z][\w-]*)(?:[\s/>]|$)/);
   if (!m) return null;
@@ -1424,6 +1444,48 @@ function parseRegistryBlock(
   return { nodes: [withIndentAttr(node)], end };
 }
 
+function parseContentReference(
+  lines: string[],
+  start: number,
+  indent: number,
+  rel: number,
+  _tag: string,
+): ParseResult {
+  const withIndentAttr = (node: PMNode): PMNode => {
+    if (rel > 0) node.attrs = { ...(node.attrs || {}), indent: rel };
+    return node;
+  };
+  const dedented = lines.map((l) => stripTabs(l, indent));
+
+  let openEndLine = start;
+  {
+    let joined = "";
+    for (let i = start; i < lines.length; i++) {
+      joined += (i === start ? "" : "\n") + dedented[i];
+      const res = scanOpenTagEnd(joined);
+      if (res) {
+        openEndLine = i;
+        break;
+      }
+      openEndLine = i;
+    }
+  }
+
+  const rawLines = dedented.slice(start, openEndLine + 1);
+  const raw = rawLines.join("\n");
+  const props = parseAttrs(raw);
+  const node: PMNode = {
+    type: "contentReference",
+    attrs: {
+      sourcePath:
+        props.sourcePath ?? props.path ?? props.source ?? props.href ?? "",
+      title: props.title ?? null,
+      __raw: raw,
+    },
+  };
+  return { nodes: [withIndentAttr(node)], end: openEndLine + 1 };
+}
+
 function parseLocalMdxComponent(
   lines: string[],
   start: number,

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

@@ -178,19 +178,18 @@ Extracts CSS tokens from a project's generated HTML, or clones an existing desig
 ### Source: Figma file
 
 ```bash
-pnpm action import-figma --figmaUrl "https://figma.com/design/<key>/..." \
-  --description "<extracted tokens / styles summary>"
+pnpm action index-design-system-with-builder \
+  --projectName "Acme Figma system" \
+  --codeFiles '[{"filename":"figma-summary.md","content":"<extracted tokens / styles summary>"}]'
 ```
 
-**Prefer the connected Figma MCP** when available (tools like
-`get_variable_defs`, `get_design_context`, `get_metadata`, `get_screenshot`).
-Call those on the file/selection FIRST to pull real variables (tokens), color
-and text styles, and a screenshot — this sidesteps REST/Enterprise limits and
-returns a token map directly. Then pass that summary to `import-figma` and build
-the system with `create-design-system`. Convert Figma colors (0-1 RGBA) to hex,
-effects to CSS box-shadow, and text styles to font tokens; snap spacing to a
-4/8px scale. If no Figma MCP is connected, ask the user to paste the token
-values or describe the file.
+Builder is the required extraction/indexing path for Figma-backed design
+systems. If a connected Figma MCP is available (tools like `get_variable_defs`,
+`get_design_context`, `get_metadata`, `get_screenshot`), call those on the
+file/selection first to pull real variables, color/text styles, and screenshot
+notes, then pass that summary to `index-design-system-with-builder` as an
+uploaded text context file. Do not build a local design system from the Figma
+summary unless the user explicitly asks for a manual local fallback.
 
 **When the user uploads a raw `.fig` file**, send it to Builder design-system
 indexing through the setup page upload route. Do not parse `.fig` files locally

package/corpus/templates/design/AGENTS.md

@@ -101,6 +101,11 @@ patterns live in `.agents/skills/`.
   progress. External MCP hosts should use `present-design-variants` so the same
   picker opens inline instead of writing `application_state` directly.
 - Use framework sharing actions for design and design-system visibility/grants.
+- `/visual-edit` is a public entry route and public `/design/:id` links may
+  render read-only public designs without a session. Do not open anonymous write
+  actions: save, share, generation, localhost connection, and screen persistence
+  should send signed-out visitors through `/_agent-native/sign-in?return=...`,
+  then save or copy the design into the authenticated account before sharing.
 - When the user asks to download/export, use export actions or point to the
   editor download menu.
 - Design source modes are `inline`, `localhost`, and `fusion`. Inline is the

package/corpus/templates/design/_gitignore

@@ -37,3 +37,10 @@ data/.sessions.json
 learnings.md
 
 .vercel/
+
+# Playwright E2E
+/test-results/
+/playwright-report/
+/e2e/.auth/
+data/e2e.db
+data/e2e.db-*

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

@@ -32,18 +32,28 @@ function parseJsonString(value: unknown): unknown {
 
 const sourceSchema = z.preprocess(
   parseJsonString,
-  z.object({
-    kind: z
-      .enum(["design-file", "inline-html", "local-file", "remote-url"])
-      .default("design-file"),
-    designId: z.string().optional(),
-    fileId: z.string().optional(),
-    filename: z.string().optional().default("index.html"),
-    path: z.string().optional(),
-    url: z.string().optional(),
-    revision: z.string().optional(),
-    html: z.string().optional(),
-  }),
+  z
+    .object({
+      kind: z
+        .enum(["design-file", "inline-html", "local-file", "remote-url"])
+        .default("design-file"),
+      designId: z.string().optional(),
+      fileId: z.string().optional(),
+      filename: z.string().optional().default("index.html"),
+      path: z.string().optional(),
+      url: z.string().optional(),
+      revision: z.string().optional(),
+      html: z.string().optional(),
+    })
+    .superRefine((source, ctx) => {
+      if (source.kind === "design-file" && !source.designId && !source.fileId) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["designId"],
+          message: "designId or fileId is required for design-file sources",
+        });
+      }
+    }),
 );
 
 const targetSchema = z.object({

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

@@ -3,7 +3,7 @@ import {
   getRequestUserEmail,
   getRequestOrgId,
 } from "@agent-native/core/server/request-context";
-import { eq } from "drizzle-orm";
+import { and, eq, isNull } from "drizzle-orm";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 
@@ -66,12 +66,23 @@ export default defineAction({
     if (!ownerEmail) throw new Error("no authenticated user");
     const orgId = getRequestOrgId();
 
-    // Check only this user's owned systems. Shared systems should not prevent
-    // the first system a user creates from becoming their default.
+    // Check only this user's owned systems within the same org. Shared systems
+    // should not prevent the first system a user creates from becoming their
+    // default, and systems in other orgs must not suppress the default in this org.
     const existing = await db
       .select({ id: schema.designSystems.id })
       .from(schema.designSystems)
-      .where(eq(schema.designSystems.ownerEmail, ownerEmail))
+      .where(
+        orgId
+          ? and(
+              eq(schema.designSystems.ownerEmail, ownerEmail),
+              eq(schema.designSystems.orgId, orgId),
+            )
+          : and(
+              eq(schema.designSystems.ownerEmail, ownerEmail),
+              isNull(schema.designSystems.orgId),
+            ),
+      )
       .limit(1);
 
     const isDefault = existing.length === 0;

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

@@ -1,7 +1,7 @@
 import { defineAction } from "@agent-native/core";
 import { seedFromText } from "@agent-native/core/collab";
 import { assertAccess } from "@agent-native/core/sharing";
-import { eq } from "drizzle-orm";
+import { and, eq } from "drizzle-orm";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 
@@ -34,6 +34,25 @@ export default defineAction({
     await assertAccess("design", designId, "editor");
 
     const db = getDb();
+
+    // Guard against duplicate (designId, filename) — edit-design uses .limit(1)
+    // which is non-deterministic when multiple rows match the same key.
+    const [existing] = await db
+      .select({ id: schema.designFiles.id })
+      .from(schema.designFiles)
+      .where(
+        and(
+          eq(schema.designFiles.designId, designId),
+          eq(schema.designFiles.filename, filename),
+        ),
+      )
+      .limit(1);
+    if (existing) {
+      throw new Error(
+        `File "${filename}" already exists in design ${designId} — use edit-design to modify it`,
+      );
+    }
+
     const id = nanoid();
     const now = new Date().toISOString();
 

package/corpus/templates/design/actions/delete-design-system.ts

@@ -7,12 +7,12 @@ import { getDb, schema } from "../server/db/index.js";
 
 export default defineAction({
   description:
-    "Delete a design system. Requires admin access. Designs linked to it are unlinked.",
+    "Delete a design system. Requires owner access. Designs linked to it are unlinked.",
   schema: z.object({
     id: z.string().min(1).describe("Design system ID to delete"),
   }),
   run: async ({ id }) => {
-    await assertAccess("design-system", id, "admin");
+    await assertAccess("design-system", id, "owner");
 
     const db = getDb();
 

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

@@ -31,14 +31,45 @@ export default defineAction({
     const now = new Date().toISOString();
     const newTitle = title || `Copy of ${source.title}`;
 
-    // Copy the design
+    // Fetch source files first so we can remap canvasFrames before inserting
+    const files = await db
+      .select()
+      .from(schema.designFiles)
+      .where(eq(schema.designFiles.designId, id));
+
+    // Build old-to-new file ID mapping upfront
+    const idMap = new Map<string, string>(
+      files.map((file) => [file.id, nanoid()]),
+    );
+
+    // Remap canvasFrames keys in source.data from old IDs to new IDs
+    let newData = source.data;
+    try {
+      const parsed =
+        typeof source.data === "string" ? JSON.parse(source.data) : source.data;
+      if (parsed && typeof parsed === "object" && parsed.canvasFrames) {
+        const remapped: Record<string, unknown> = {};
+        for (const [oldId, geometry] of Object.entries(parsed.canvasFrames)) {
+          const newFileId = idMap.get(oldId);
+          remapped[newFileId ?? oldId] = geometry;
+        }
+        newData =
+          typeof source.data === "string"
+            ? JSON.stringify({ ...parsed, canvasFrames: remapped })
+            : { ...parsed, canvasFrames: remapped };
+      }
+    } catch {
+      // If data is unparseable, fall back to copying verbatim
+    }
+
+    // Copy the design with remapped canvasFrames
     await db.insert(schema.designs).values({
       id: newId,
       title: newTitle,
       description: source.description,
       projectType: source.projectType,
       designSystemId: source.designSystemId ?? null,
-      data: source.data,
+      data: newData,
       ownerEmail: (() => {
         const e = getRequestUserEmail();
         if (!e) throw new Error("no authenticated user");
@@ -49,15 +80,10 @@ export default defineAction({
       updatedAt: now,
     });
 
-    // Copy all associated files with new IDs
-    const files = await db
-      .select()
-      .from(schema.designFiles)
-      .where(eq(schema.designFiles.designId, id));
-
+    // Copy all associated files using the pre-generated IDs
     for (const file of files) {
       await db.insert(schema.designFiles).values({
-        id: nanoid(),
+        id: idMap.get(file.id)!,
         designId: newId,
         filename: file.filename,
         fileType: file.fileType,