@agent-native/core 0.84.30 → 0.84.34

package/corpus/README.md

@@ -28,4 +28,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 ## Generated Counts
 
 - core files: 2043
-- template files: 4973
+- template files: 4994

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @agent-native/core
 
+## 0.84.34
+
+### Patch Changes
+
+- 56f3d91: Fix hosted Google Analytics / Tag Manager injection by baking the measurement id into Nitro server bundles and merging the required GA/GTM script, connect, and image hosts into existing stricter document CSPs.
+
+## 0.84.33
+
+### Patch Changes
+
+- 8cc9620: Keep Nitro/Vite dev servers responsive when native file watchers hit EMFILE or ENOSPC by falling back to polling instead of replacing failed watches with no-ops.
+
+## 0.84.32
+
+### Patch Changes
+
+- da8ac0a: Keep tail-resume reconnect content display-only, recover zero-byte action-prep stalls, and polish Design screen tool labels.
+
+## 0.84.31
+
+### Patch Changes
+
+- 3190dea: Inline rrweb stylesheet snapshots by default so Analytics session replay captures can play back styled pages without live CSS fetches.
+
 ## 0.84.30
 
 ### Patch Changes

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.84.30",
+  "version": "0.84.34",
   "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/client/session-replay.ts

@@ -19,6 +19,7 @@ interface RrwebRecordOptions {
   emit: (event: ReplayEvent) => void;
   checkoutEveryNth?: number;
   checkoutEveryNms?: number;
+  inlineStylesheet?: boolean;
   blockClass?: string | RegExp;
   blockSelector?: string;
   ignoreClass?: string | RegExp;
@@ -82,6 +83,7 @@ export interface SessionReplayOptions {
   maxBatchBytes?: number;
   checkoutEveryNth?: number;
   checkoutEveryNms?: number;
+  inlineStylesheet?: boolean;
   blockSelector?: string;
   ignoreSelector?: string;
   maskTextClass?: string | RegExp;
@@ -135,6 +137,7 @@ interface NormalizedSessionReplayOptions {
   maxBatchBytes: number;
   checkoutEveryNth?: number;
   checkoutEveryNms?: number;
+  inlineStylesheet: boolean;
   blockSelector: string;
   ignoreSelector: string;
   maskTextClass: string | RegExp;
@@ -509,6 +512,7 @@ function normalizeOptions(
     ),
     checkoutEveryNth: options.checkoutEveryNth,
     checkoutEveryNms: options.checkoutEveryNms,
+    inlineStylesheet: options.inlineStylesheet ?? true,
     blockSelector: options.blockSelector || DEFAULT_BLOCK_SELECTOR,
     ignoreSelector: options.ignoreSelector || DEFAULT_IGNORE_SELECTOR,
     maskTextClass: options.maskTextClass || DEFAULT_MASK_TEXT_CLASS,
@@ -1010,6 +1014,7 @@ async function startSessionReplayRecorder(
       sampling: normalized.eventSampling,
       checkoutEveryNth: normalized.checkoutEveryNth,
       checkoutEveryNms: normalized.checkoutEveryNms,
+      inlineStylesheet: normalized.inlineStylesheet,
       blockSelector: normalized.blockSelector,
       ignoreSelector: normalized.ignoreSelector,
       maskTextClass: normalized.maskTextClass,

package/corpus/core/src/client/use-action.ts

@@ -60,7 +60,11 @@ function defaultActionQueryRetry(
  * it maps action names to their parameter and return types, enabling
  * end-to-end type safety for `useActionQuery` and `useActionMutation`.
  */
-export interface ActionRegistry {}
+declare global {
+  interface AgentNativeActionRegistry {}
+}
+
+export interface ActionRegistry extends AgentNativeActionRegistry {}
 
 /** Resolves to the union of registered action names, or `string` if no registry exists. */
 type ActionName = keyof ActionRegistry extends never

package/corpus/core/src/server/ssr-handler.ts

@@ -402,6 +402,15 @@ function appendToExistingCspDirective(
   existing.tokens = appendCspTokens(existing.tokens, additions);
 }
 
+function ensureCspDirective(
+  directives: CspDirective[],
+  name: string,
+  tokens: readonly string[],
+): void {
+  if (findCspDirective(directives, name)) return;
+  directives.push({ name, tokens: [...tokens] });
+}
+
 function hasStrictNonceScriptPolicy(tokens: readonly string[]): boolean {
   return tokens.some(
     (token) => token === "'strict-dynamic'" || token.startsWith("'nonce-"),
@@ -480,6 +489,9 @@ function augmentExistingEnforcedCspForFrameworkScripts(
     }
   }
 
+  ensureCspDirective(directives, "object-src", ["'none'"]);
+  ensureCspDirective(directives, "base-uri", ["'self'"]);
+
   return serializeCsp(directives);
 }
 

package/corpus/core/src/vite/action-types-plugin.ts

@@ -280,12 +280,16 @@ type ActionEntry<T> = T extends { default: { run: (...args: infer A) => infer R
     }
   : { result: any; params: Record<string, any> };
 
-declare module "@agent-native/core/client" {
-  interface ActionRegistry {
+declare global {
+  interface AgentNativeActionRegistry {
 ${typeEntries.join("\n")}
   }
 }
 
+declare module "@agent-native/core/client" {
+  interface ActionRegistry extends AgentNativeActionRegistry {}
+}
+
 export {};
 `;
 

package/corpus/core/src/vite/client.ts

@@ -1,3 +1,4 @@
+import { EventEmitter } from "events";
 import fs from "fs";
 import type { IncomingMessage, ServerResponse } from "http";
 import { createRequire, syncBuiltinESMExports } from "module";
@@ -36,6 +37,137 @@ const require = createRequire(import.meta.url);
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 let nitroFsWatchGuardInstalled = false;
 
+type FsWatchArgs = [fs.PathLike, ...any[]];
+
+function isFileWatchLimitError(
+  error: NodeJS.ErrnoException | undefined,
+): boolean {
+  return error?.code === "EMFILE" || error?.code === "ENOSPC";
+}
+
+function watchPollingIntervalMs(): number {
+  const raw = Number(process.env.CHOKIDAR_INTERVAL ?? 1000);
+  return Number.isFinite(raw) && raw > 0 ? raw : 1000;
+}
+
+function fsWatchListener(args: FsWatchArgs): fs.WatchListener<string> | null {
+  const maybeOptionsOrListener = args[1];
+  const maybeListener = args[2];
+  if (typeof maybeOptionsOrListener === "function")
+    return maybeOptionsOrListener as fs.WatchListener<string>;
+  if (typeof maybeListener === "function")
+    return maybeListener as fs.WatchListener<string>;
+  return null;
+}
+
+function fsWatchPersistent(args: FsWatchArgs): boolean {
+  const options = args[1];
+  if (!options || typeof options === "function") return true;
+  if (typeof options === "string" || Buffer.isBuffer(options)) return true;
+  return options.persistent !== false;
+}
+
+function directEntrySnapshot(
+  target: string,
+): Map<string, { mtimeMs: number; size: number; directory: boolean }> {
+  const snapshot = new Map<
+    string,
+    { mtimeMs: number; size: number; directory: boolean }
+  >();
+  const stat = fs.statSync(target);
+  if (!stat.isDirectory()) {
+    snapshot.set(path.basename(target), {
+      mtimeMs: stat.mtimeMs,
+      size: stat.size,
+      directory: false,
+    });
+    return snapshot;
+  }
+  for (const entry of fs.readdirSync(target, { withFileTypes: true })) {
+    const entryPath = path.join(target, entry.name);
+    try {
+      const entryStat = fs.statSync(entryPath);
+      snapshot.set(entry.name, {
+        mtimeMs: entryStat.mtimeMs,
+        size: entryStat.size,
+        directory: entryStat.isDirectory(),
+      });
+    } catch {
+      // The entry may have disappeared between readdir and stat.
+    }
+  }
+  return snapshot;
+}
+
+function createPollingFsWatcher(args: FsWatchArgs): fs.FSWatcher {
+  const target = String(args[0]);
+  const listener = fsWatchListener(args);
+  const emitter = new EventEmitter() as fs.FSWatcher;
+  let closed = false;
+  let previous = directEntrySnapshot(target);
+
+  if (listener) emitter.on("change", listener);
+
+  const emitChange = (eventName: "change" | "rename", filename: string) => {
+    emitter.emit("change", eventName, filename);
+  };
+
+  const timer = setInterval(() => {
+    if (closed) return;
+    let next: typeof previous;
+    try {
+      next = directEntrySnapshot(target);
+    } catch (error) {
+      emitter.emit("error", error);
+      return;
+    }
+
+    for (const [filename, current] of next) {
+      const old = previous.get(filename);
+      if (!old) {
+        emitChange("rename", filename);
+        continue;
+      }
+      if (
+        old.mtimeMs !== current.mtimeMs ||
+        old.size !== current.size ||
+        old.directory !== current.directory
+      ) {
+        emitChange("change", filename);
+      }
+    }
+    for (const filename of previous.keys()) {
+      if (!next.has(filename)) emitChange("rename", filename);
+    }
+    previous = next;
+  }, watchPollingIntervalMs());
+
+  if (!fsWatchPersistent(args)) timer.unref();
+
+  emitter.close = () => {
+    if (closed) return;
+    closed = true;
+    clearInterval(timer);
+    emitter.removeAllListeners();
+  };
+  emitter.ref = () => {
+    timer.ref();
+    return emitter;
+  };
+  emitter.unref = () => {
+    timer.unref();
+    return emitter;
+  };
+
+  return emitter;
+}
+
+function warnNitroFsWatchFallback(target: unknown, err: NodeJS.ErrnoException) {
+  console.warn(
+    `[agent-native] Falling back to polling Nitro fs.watch for ${String(target)}: ${err.message}`,
+  );
+}
+
 function installNitroFsWatchGuard(): void {
   if (nitroFsWatchGuardInstalled) return;
   nitroFsWatchGuardInstalled = true;
@@ -49,29 +181,32 @@ function installNitroFsWatchGuard(): void {
       watcher = originalWatch(...args);
     } catch (error) {
       const err = error as NodeJS.ErrnoException;
-      if (err.code !== "EMFILE" && err.code !== "ENOSPC") throw error;
-      console.warn(
-        `[agent-native] Disabled Nitro fs.watch for ${String(args[0])}: ${err.message}`,
-      );
-      return {
-        close() {},
-        on() {
-          return this as fs.FSWatcher;
-        },
-      } as unknown as fs.FSWatcher;
+      if (!isFileWatchLimitError(err)) throw error;
+      warnNitroFsWatchFallback(args[0], err);
+      return createPollingFsWatcher(args as FsWatchArgs);
     }
 
     const originalEmit = watcher.emit.bind(watcher);
+    const originalClose = watcher.close.bind(watcher);
+    let pollingFallback: fs.FSWatcher | undefined;
+
+    watcher.close = (() => {
+      pollingFallback?.close();
+      return originalClose();
+    }) as fs.FSWatcher["close"];
+
     watcher.emit = ((eventName: string | symbol, ...eventArgs: any[]) => {
       const err = eventArgs[0] as NodeJS.ErrnoException | undefined;
-      if (
-        eventName === "error" &&
-        (err?.code === "EMFILE" || err?.code === "ENOSPC")
-      ) {
-        console.warn(
-          `[agent-native] Disabled Nitro fs.watch for ${String(args[0])}: ${err.message}`,
-        );
+      if (eventName === "error" && isFileWatchLimitError(err) && err) {
+        warnNitroFsWatchFallback(args[0], err);
         watcher.close();
+        pollingFallback = createPollingFsWatcher(args as FsWatchArgs);
+        pollingFallback.on("change", (changeEvent, filename) => {
+          originalEmit("change", changeEvent, filename);
+        });
+        pollingFallback.on("error", (pollingError) => {
+          originalEmit("error", pollingError);
+        });
         return false;
       }
       return originalEmit(eventName, ...eventArgs);

package/corpus/templates/analytics/app/pages/sessions/SessionDetailPage.tsx

@@ -1243,7 +1243,14 @@ function sanitizeCssText(value: string): string {
   if (!containsStylesheetNetworkLoad(value)) return value;
   return value
     .replace(/@import\s+(?:url\s*\()?[^;{}]+;?/gi, "")
-    .replace(/\burl\s*\((?:\\.|[^\\)])*\)/gi, "none");
+    .replace(/\burl\s*\(\s*((?:\\.|[^\\)])*)\)/gi, sanitizeCssUrlToken);
+}
+
+function sanitizeCssUrlToken(match: string, rawValue: string): string {
+  const urlValue = rawValue.trim();
+  const unquoted = urlValue.replace(/^(['"])(.*)\1$/, "$2").trim();
+  if (/^(?:data:|blob:|#)/i.test(unquoted)) return match;
+  return "none";
 }
 
 function sanitizeAttributes(attributes: AnyRecord): AnyRecord {
@@ -1258,6 +1265,11 @@ function sanitizeAttributes(attributes: AnyRecord): AnyRecord {
       if (style.trim()) next[key] = style;
       continue;
     }
+    if (normalized === "_csstext") {
+      const cssText = sanitizeCssText(String(value));
+      if (cssText.trim()) next[key] = cssText;
+      continue;
+    }
     next[key] = value;
   }
   return next;

package/corpus/templates/analytics/changelog/2026-07-01-session-replays-keep-inlined-css-without-live-resource-loa.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-01
+---
+
+Session replay playback keeps rrweb's inlined stylesheet snapshots while stripping live resource loads, reducing blank replay frames for captured pages with external CSS.

package/corpus/templates/design/AGENTS.md

@@ -191,6 +191,24 @@ patterns live in `.agents/skills/`.
   mode can list and resolve local routes now, but file reads/writes remain a
   bridge contract until explicit permission controls are hardened.
 
+## Code Workspace
+
+- The editor left rail has a wide `code` workspace panel. Open it with
+  `navigate --view editor --designId <id> --leftPanel code` and optionally pass
+  `fileId`, `filename`, or `screen` to focus a file.
+- Use `list-source-files` to inspect the source workspace. For the MVP the
+  backend is `virtual-inline` over SQL-backed `design_files`, exposed as
+  `designfs://<designId>/`.
+- Use `read-source-file` for file contents and preserve its `versionHash` before
+  writing. Do not return full file content from `view-screen`; it reports only
+  active code file metadata and dirty state.
+- Use `preview-source-edit` to show a diff without saving, then
+  `apply-source-edit` with the prior `versionHash` to save either a full replace
+  or exact replace. These actions update the same inline file state as the UI.
+- Use `resolve-selection-source` when the user has a canvas element selected and
+  you need the best matching inline file location/snippet. Localhost/container
+  source reads and writes remain future backend work.
+
 ## Localhost Source Actions
 
 - `connect-localhost`: registers or refreshes a localhost source connection

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

@@ -0,0 +1,87 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+
+import {
+  findSourceWorkspaceFile,
+  readLiveSourceFile,
+  resolveSourceWorkspace,
+  writeInlineSourceFile,
+} from "../server/source-workspace.js";
+import {
+  applySourceEdit,
+  previewSourceDiff,
+} from "../shared/source-workspace.js";
+
+const sourceEditSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("full-replace"),
+    content: z.string().describe("Complete replacement file content"),
+  }),
+  z.object({
+    kind: z.literal("exact-replace"),
+    search: z.string().min(1).describe("Unique exact text to replace"),
+    replace: z.string().describe("Replacement text"),
+  }),
+]);
+
+export default defineAction({
+  description:
+    "Apply a source-file edit through the shared Design source surface. In the " +
+    "MVP this writes inline design_files only and rejects stale version hashes.",
+  schema: z
+    .object({
+      designId: z.string().describe("Design project ID"),
+      path: z
+        .string()
+        .optional()
+        .describe("Source path/filename, such as index.html"),
+      fileId: z.string().optional().describe("Design file ID"),
+      edit: sourceEditSchema,
+      expectedVersionHash: z
+        .string()
+        .optional()
+        .describe("Hash returned by read-source-file or preview-source-edit"),
+    })
+    .refine((args) => args.path || args.fileId, {
+      message: "Provide either path or fileId.",
+      path: ["path"],
+    }),
+  run: async ({ designId, path, fileId, edit, expectedVersionHash }) => {
+    const workspace = await resolveSourceWorkspace(designId, {
+      includeContent: true,
+    });
+    if (workspace.sourceType !== "inline") {
+      throw new Error("Only inline Design files are editable in this MVP.");
+    }
+    const file = findSourceWorkspaceFile(workspace.files, { fileId, path });
+    const live = await readLiveSourceFile(file);
+    if (
+      expectedVersionHash !== undefined &&
+      expectedVersionHash !== live.versionHash
+    ) {
+      throw new Error(
+        "Source file changed since it was read. Re-read the file and retry.",
+      );
+    }
+
+    const next = applySourceEdit(live.content, edit);
+    const write = await writeInlineSourceFile({
+      designId,
+      file,
+      content: next.content,
+      expectedVersionHash: expectedVersionHash ?? live.versionHash,
+    });
+
+    return {
+      designId,
+      path: file.filename,
+      fileId: file.id,
+      backendKind: "virtual-inline",
+      changed: write.changed,
+      editsApplied: next.editsApplied,
+      versionHash: write.versionHash,
+      updatedAt: write.updatedAt,
+      diff: previewSourceDiff(live.content, next.content),
+    };
+  },
+});

package/corpus/templates/design/actions/import-design-source.ts

@@ -0,0 +1,158 @@
+import { defineAction } from "@agent-native/core";
+import { assertAccess } from "@agent-native/core/sharing";
+import { z } from "zod";
+
+import { parseFigmaClipboardHtml } from "../server/lib/figma-import/clipboard.js";
+import { importFigmaBuffer } from "../server/lib/figma-import/processor.js";
+import {
+  normalizeImportedHtmlDocument,
+  resolveImportDesignId,
+  saveImportedDesignFiles,
+  type ImportedDesignFile,
+} from "../server/lib/import-design-files.js";
+
+const MAX_HTML_IMPORT_BYTES = 2 * 1024 * 1024;
+
+function ensureHtmlSize(content: string) {
+  if (Buffer.byteLength(content, "utf8") > MAX_HTML_IMPORT_BYTES) {
+    throw new Error("HTML import content is too large (max 2 MB).");
+  }
+}
+
+function baseFilename(originalName: string | undefined, fallback: string) {
+  return (originalName?.trim() || fallback).replace(/\.[^.]+$/, "") + ".html";
+}
+
+export default defineAction({
+  description:
+    "Import Figma clipboard HTML or standalone HTML into the current Design project as one or more editable screens.",
+  schema: z.object({
+    designId: z
+      .string()
+      .optional()
+      .describe("Design id. Defaults to the active editor navigation state."),
+    sourceType: z.enum(["figma-paste-html", "html-string"]),
+    content: z
+      .string()
+      .max(
+        MAX_HTML_IMPORT_BYTES,
+        "HTML import content is too large (max 2 MB).",
+      ),
+    originalName: z.string().optional(),
+  }),
+  run: async ({ designId, sourceType, content, originalName }) => {
+    ensureHtmlSize(content);
+    const resolvedDesignId = await resolveImportDesignId(designId);
+    await assertAccess("design", resolvedDesignId, "editor");
+
+    if (sourceType === "html-string") {
+      const saved = await saveImportedDesignFiles({
+        designId: resolvedDesignId,
+        sourceType: "html-import",
+        files: [
+          {
+            filename: baseFilename(originalName, "imported-html"),
+            fileType: "html",
+            content: normalizeImportedHtmlDocument(content, "HTML source"),
+            source: { sourceType: "html-string", originalName },
+          },
+        ],
+      });
+      return {
+        ...saved,
+        stats: { sourceKind: "html-string", frameCount: saved.files.length },
+      };
+    }
+
+    const parsed = parseFigmaClipboardHtml(content);
+    const warnings: string[] = [];
+    if (parsed.buffer && parsed.hasFigmaBuffer) {
+      try {
+        const imported = await importFigmaBuffer({
+          buffer: parsed.buffer,
+          filename: originalName ?? "figma-paste.fig",
+          sourceKind: "figma-paste",
+          selection: { nodeId: parsed.meta?.selectedNodeId },
+          meta: parsed.meta,
+        });
+        const files: ImportedDesignFile[] = imported.files.map((file) => ({
+          filename: file.filename,
+          fileType: "html",
+          content: file.content,
+          source: file.source,
+          preferredFrame: {
+            title:
+              typeof file.source?.frameName === "string"
+                ? file.source.frameName
+                : undefined,
+            width: file.width,
+            height: file.height,
+          },
+        }));
+        const saved = await saveImportedDesignFiles({
+          designId: resolvedDesignId,
+          sourceType: "figma-paste",
+          files,
+          warnings: [...warnings, ...imported.warnings],
+        });
+        return { ...saved, stats: imported.stats };
+      } catch (error) {
+        warnings.push(
+          error instanceof Error
+            ? `Figma binary payload could not be decoded: ${error.message}`
+            : "Figma binary payload could not be decoded.",
+        );
+      }
+    } else if (parsed.buffer) {
+      warnings.push(
+        "The clipboard included a Figma buffer, but it was not a supported fig-kiwi payload.",
+      );
+    }
+
+    if (!parsed.fallbackHtml) {
+      throw new Error(
+        "No importable Figma frame data or visible HTML was found in the clipboard.",
+      );
+    }
+    const saved = await saveImportedDesignFiles({
+      designId: resolvedDesignId,
+      sourceType: "figma-paste-fallback",
+      files: [
+        {
+          filename: baseFilename(originalName, "figma-paste"),
+          fileType: "html",
+          content: normalizeImportedHtmlDocument(
+            parsed.fallbackHtml,
+            "Figma clipboard fallback HTML",
+          ),
+          source: {
+            sourceType: "figma-paste-fallback",
+            selectedNodeId: parsed.meta?.selectedNodeId,
+            fileKey: parsed.meta?.fileKey,
+          },
+        },
+      ],
+      warnings,
+    });
+    return {
+      ...saved,
+      stats: {
+        sourceKind: "figma-paste",
+        format: "html-fallback",
+        frameCount: saved.files.length,
+        imageCount: 0,
+        selectedNodeId: parsed.meta?.selectedNodeId,
+      },
+    };
+  },
+  link: ({ result }) => {
+    if (!result || typeof result !== "object") return null;
+    const designId = (result as { designId?: string }).designId;
+    if (!designId) return null;
+    return {
+      url: `/design/${designId}`,
+      label: "Open overview",
+      view: "editor",
+    };
+  },
+});