@agent-native/core 0.92.12 → 0.94.0

package/corpus/templates/design/app/pages/design-editor/pending-edits.ts

@@ -1,3 +1,4 @@
+import { removeBreakpointMediaDeclaration } from "@shared/breakpoint-media";
 import {
   applyVisualEdit,
   type ApplyVisualEditResult,
@@ -5,9 +6,11 @@ import {
 import {
   duplicateStatePreviewRules,
   type InteractionState,
+  upsertResponsiveStateStyles,
   upsertStateStyles,
 } from "@shared/interaction-states";
 import {
+  normalizeCssPropertyName,
   planBreakpointStyleWrite,
   utilityStem,
 } from "@shared/responsive-classes";
@@ -36,6 +39,18 @@ export interface PendingVisualStyleEdit {
   tagName?: string | null;
   classes: string[];
   styles: Record<string, string>;
+  /**
+   * Element pseudo-class being authored. Omitted for ordinary/base styles.
+   * Localhost screens cannot persist the editor's managed HTML block because
+   * their DesignFile content is the route URL, so interaction-state edits use
+   * the same guarded coding-agent handoff as other live visual edits while the
+   * iframe bridge keeps a temporary state-scoped preview.
+   */
+  interactionState?: InteractionState;
+  /** Base computed values used only to restore inspector fields after the
+   * first pending state override is undone. Runtime preview cleanup still
+   * uses `originalStyles` (empty values remove the temporary CSSOM rule). */
+  baseStyles?: Record<string, string>;
   /**
    * Inline style values to replay when the user discards the live preview.
    * Missing authored inline values are stored as "" so the bridge removes the
@@ -53,6 +68,7 @@ export interface PendingVisualStyleEdit {
   breakpoint?: {
     activeWidthPx: number;
     upperBoundPx: number | null;
+    editScope?: "cascade-smaller" | "only";
   };
 }
 
@@ -133,6 +149,13 @@ export interface PendingLiveStructureEdit {
   anchorSourceId?: string | null;
   anchorSourceAnchor?: ReactSourceAnchor;
   placement: "before" | "after" | "inside";
+  /** Runtime layout semantics captured at drop time. These are required for
+   * the coding agent to distinguish a flow/auto-layout insertion from an
+   * absolute child whose visual offset must be rebased into its new parent. */
+  dropMode?: "flow-insert" | "absolute-container";
+  forceFlowPositionOverride?: boolean;
+  sourceRect?: { x: number; y: number; width: number; height: number };
+  anchorRect?: { x: number; y: number; width: number; height: number };
   requestId?: string;
   updatedAt: number;
 }
@@ -297,10 +320,28 @@ export type PendingLiveNonStyleUndoEntry =
   | PendingLiveTextUndoEntry
   | PendingLiveStructureUndoEntry;
 
+export function pendingLiveStructureEditsMatch(
+  left: PendingLiveStructureEdit,
+  right: PendingLiveStructureEdit,
+): boolean {
+  return (
+    left.screenId === right.screenId &&
+    left.selector === right.selector &&
+    (left.sourceId ?? "") === (right.sourceId ?? "") &&
+    left.anchorSelector === right.anchorSelector &&
+    (left.anchorSourceId ?? "") === (right.anchorSourceId ?? "") &&
+    left.placement === right.placement &&
+    left.dropMode === right.dropMode &&
+    Boolean(left.forceFlowPositionOverride) ===
+      Boolean(right.forceFlowPositionOverride)
+  );
+}
+
 function pendingVisualStyleEditKey(edit: PendingVisualStyleEdit): string {
   return [
     edit.screenId,
     edit.sourceId?.trim() || edit.selector.trim() || "unknown",
+    edit.interactionState ?? "default",
   ].join("::");
 }
 
@@ -322,6 +363,7 @@ export function mergePendingVisualStyleEdit(
         ...nextEdit.originalStyles,
         ...edit.originalStyles,
       },
+      baseStyles: edit.baseStyles ?? nextEdit.baseStyles,
     };
   });
   return merged ? next : [...edits, nextEdit];
@@ -392,6 +434,7 @@ export function buildPendingVisualStyleRevertPatches(
   selector: string;
   sourceId?: string | null;
   styles: Record<string, string>;
+  interactionState?: InteractionState;
 }> {
   return edits
     .map((edit) => ({
@@ -399,6 +442,9 @@ export function buildPendingVisualStyleRevertPatches(
       selector: edit.selector,
       sourceId: edit.sourceId,
       styles: edit.originalStyles,
+      ...(edit.interactionState
+        ? { interactionState: edit.interactionState }
+        : {}),
     }))
     .filter((patch) => Object.keys(patch.styles).length > 0);
 }
@@ -442,6 +488,9 @@ export function formatPendingVisualStylePrompt(args: {
     tagName: edit.tagName ?? null,
     classes: edit.classes,
     styles: edit.styles,
+    ...(edit.interactionState
+      ? { interactionState: edit.interactionState }
+      : {}),
     ...(edit.breakpoint ? { breakpoint: edit.breakpoint } : {}),
   }));
   const hasBreakpointScopedEdits = args.edits.some(
@@ -488,7 +537,14 @@ export function formatPendingVisualStylePrompt(args: {
       subjectAnchor && targetAnchor
         ? buildReactSemanticHandoff({
             operation: edit.placement === "inside" ? "reparent" : "move",
-            desiredChange: `Move the selected runtime element ${edit.placement} the target runtime element.`,
+            desiredChange: [
+              `Move the selected runtime element ${edit.placement} the target runtime element.`,
+              edit.dropMode === "flow-insert"
+                ? `The drop is a flow/auto-layout insertion${edit.forceFlowPositionOverride ? "; remove authored absolute positioning so the moved element participates in the target container's layout" : "; preserve normal flow participation"}.`
+                : edit.dropMode === "absolute-container"
+                  ? "The target is an absolute-positioning container; preserve absolute positioning and rebase the moved element's visual offset from sourceRect into the target anchorRect coordinate space."
+                  : "Preserve the runtime layout behavior observed in the preview.",
+            ].join(" "),
             sourceAnchors: [subjectAnchor, targetAnchor],
             runtimeRelationship: {
               kind: edit.placement,
@@ -521,6 +577,12 @@ export function formatPendingVisualStylePrompt(args: {
       anchorSourceId: edit.anchorSourceId ?? null,
       anchorSourceAnchor: redactReactSourceAnchor(edit.anchorSourceAnchor),
       placement: edit.placement,
+      ...(edit.dropMode ? { dropMode: edit.dropMode } : {}),
+      ...(edit.forceFlowPositionOverride
+        ? { forceFlowPositionOverride: true }
+        : {}),
+      ...(edit.sourceRect ? { sourceRect: edit.sourceRect } : {}),
+      ...(edit.anchorRect ? { anchorRect: edit.anchorRect } : {}),
       ...(semanticHandoff.ok
         ? { semanticHandoff: semanticHandoff.handoff }
         : { semanticHandoffFailure: semanticHandoff.rejection }),
@@ -542,7 +604,10 @@ export function formatPendingVisualStylePrompt(args: {
       ? "At least one React anchor is repeated at runtime or resolves to a shared component definition. Inspect map/conditional/component call sites and confirm whether the change should affect one instance or every instance before writing source."
       : "",
     hasBreakpointScopedEdits
-      ? "Edits that carry a `breakpoint` field were made while a narrower breakpoint frame was active: apply them as width-scoped overrides (apply-visual-edit with `activeFrameWidthPx` set to breakpoint.activeWidthPx), NOT as base writes — base values must keep rendering at wider viewports."
+      ? "Edits that carry a `breakpoint` field were made while a narrower breakpoint frame was active: apply them as width-scoped overrides (apply-visual-edit with `activeFrameWidthPx` set to breakpoint.activeWidthPx), NOT as base writes — base values must keep rendering at wider viewports. When breakpoint.editScope is `only`, confine the override to breakpoint.activeWidthPx through breakpoint.upperBoundPx; otherwise use the normal desktop-down cascade."
+      : "",
+    args.edits.some((edit) => edit.interactionState)
+      ? "Edits that carry an `interactionState` field are pseudo-class overrides, not base styles. Apply each property only to that exact state (`hover`, `focus`, `focus-visible`, `active`, or `disabled`) while preserving the element's default styling and its other states."
       : "",
     "",
     "Pending style edits:",
@@ -646,11 +711,55 @@ export function applyScopedVisualStyleEdit(args: {
   property: string;
   value: string;
   upperBoundPx: number | null;
+  /** Inclusive lower bound for an exact-range edit. Omit for the normal
+   * desktop-down “this breakpoint and smaller” cascade. */
+  lowerBoundPx?: number | null;
 }): ApplyVisualEditResult {
-  const { content, target, property, value, upperBoundPx } = args;
+  const { content, target, property, value, upperBoundPx, lowerBoundPx } = args;
+  const normalizedProperty = normalizeCssPropertyName(property);
+  if (
+    lowerBoundPx != null &&
+    upperBoundPx != null &&
+    "nodeId" in target &&
+    Number.isFinite(lowerBoundPx) &&
+    lowerBoundPx > 0 &&
+    upperBoundPx >= lowerBoundPx
+  ) {
+    const maxPatch = applyVisualEdit(content, {
+      kind: "breakpoint-style",
+      target,
+      maxWidthPx: upperBoundPx,
+      property: normalizedProperty,
+      value,
+      operation: "set",
+    });
+    if (maxPatch.result.status !== "applied") return maxPatch;
+    const withoutCascade = removeBreakpointMediaDeclaration(maxPatch.content, {
+      nodeId: target.nodeId,
+      maxWidthPx: upperBoundPx,
+      property: normalizedProperty,
+    });
+    return {
+      ...maxPatch,
+      content: setExactBreakpointDeclaration(withoutCascade, {
+        nodeId: target.nodeId,
+        property: normalizedProperty,
+        value,
+        minWidthPx: Math.round(lowerBoundPx),
+        maxWidthPx: Math.round(upperBoundPx),
+      }),
+    };
+  }
+  const cleanedContent =
+    "nodeId" in target
+      ? removeExactBreakpointDeclarations(content, {
+          nodeId: target.nodeId,
+          property: normalizedProperty,
+        })
+      : content;
   const plan = planBreakpointStyleWrite({ property, value, upperBoundPx });
   if (plan.mode === "class") {
-    const rcPatch = applyVisualEdit(content, {
+    const rcPatch = applyVisualEdit(cleanedContent, {
       kind: "responsive-class",
       target,
       // `prefix` is ignored when maxWidthPx is set (desktop-down scope).
@@ -668,7 +777,7 @@ export function applyScopedVisualStyleEdit(args: {
     upperBoundPx !== null &&
     upperBoundPx !== undefined
   ) {
-    return applyVisualEdit(content, {
+    return applyVisualEdit(cleanedContent, {
       kind: "breakpoint-style",
       target,
       maxWidthPx: upperBoundPx,
@@ -677,7 +786,84 @@ export function applyScopedVisualStyleEdit(args: {
       operation: "set",
     });
   }
-  return applyVisualEdit(content, { kind: "style", target, property, value });
+  return applyVisualEdit(cleanedContent, {
+    kind: "style",
+    target,
+    property,
+    value,
+  });
+}
+
+const EXACT_BREAKPOINT_ATTR = "data-agent-native-breakpoint-range";
+
+function exactBreakpointMarker(
+  nodeId: string,
+  property: string,
+  bounds?: { minWidthPx: number; maxWidthPx: number },
+): string {
+  const base = `${encodeURIComponent(nodeId)}::${encodeURIComponent(property)}`;
+  return bounds ? `${base}::${bounds.minWidthPx}-${bounds.maxWidthPx}` : base;
+}
+
+function escapeCssAttribute(value: string): string {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function removeExactBreakpointDeclarations(
+  content: string,
+  args: {
+    nodeId: string;
+    property: string;
+    minWidthPx?: number;
+    maxWidthPx?: number;
+  },
+): string {
+  const marker = exactBreakpointMarker(
+    args.nodeId,
+    args.property,
+    args.minWidthPx != null && args.maxWidthPx != null
+      ? { minWidthPx: args.minWidthPx, maxWidthPx: args.maxWidthPx }
+      : undefined,
+  );
+  const markerPattern =
+    args.minWidthPx != null && args.maxWidthPx != null
+      ? escapeRegExp(marker)
+      : `${escapeRegExp(marker)}::[^\"]+`;
+  const styleRe = new RegExp(
+    `<style\\b[^>]*\\b${EXACT_BREAKPOINT_ATTR}="${markerPattern}"[^>]*>.*?<\\/style>\\n?`,
+    "gis",
+  );
+  return content.replace(styleRe, "");
+}
+
+function setExactBreakpointDeclaration(
+  content: string,
+  args: {
+    nodeId: string;
+    property: string;
+    value: string;
+    minWidthPx: number;
+    maxWidthPx: number;
+  },
+): string {
+  const cleaned = removeExactBreakpointDeclarations(content, args);
+  const marker = exactBreakpointMarker(args.nodeId, args.property, args);
+  const selectorId = escapeCssAttribute(args.nodeId);
+  const block = `<style ${EXACT_BREAKPOINT_ATTR}="${marker}">
+@media (min-width: ${args.minWidthPx}px) and (max-width: ${args.maxWidthPx}px) {
+  [data-agent-native-node-id="${selectorId}"][data-agent-native-node-id="${selectorId}"] {
+    ${args.property}: ${args.value.trim()};
+  }
+}
+</style>`;
+  const headClose = cleaned.lastIndexOf("</head>");
+  return headClose >= 0
+    ? `${cleaned.slice(0, headClose)}${block}\n${cleaned.slice(headClose)}`
+    : `${block}\n${cleaned}`;
 }
 
 /**
@@ -728,7 +914,17 @@ export function applyInteractionStateStyleCommit(
   nodeId: string,
   state: InteractionState,
   styles: Record<string, string>,
+  maxWidthPx?: number | null,
 ): string {
+  if (maxWidthPx != null) {
+    return upsertResponsiveStateStyles(
+      content,
+      nodeId,
+      state,
+      maxWidthPx,
+      styles,
+    );
+  }
   const withStateStyles = upsertStateStyles(content, nodeId, state, styles);
   return duplicateStatePreviewRules(withStateStyles);
 }

package/corpus/templates/design/app/pages/design-editor/pending-structure-verification.ts

@@ -0,0 +1,92 @@
+import { buildCodeLayerProjection } from "@shared/code-layer";
+
+import { resolveCodeLayerNodeFromBridge } from "./code-layer-state";
+import type { PendingLiveStructureEdit } from "./pending-edits";
+
+export type RuntimeStructureVerificationFailure =
+  | "missing-subject"
+  | "missing-anchor"
+  | "wrong-parent"
+  | "wrong-order"
+  | "wrong-drop-mode";
+
+export interface RuntimeStructureVerificationResult {
+  ok: boolean;
+  failure?: RuntimeStructureVerificationFailure;
+}
+
+/**
+ * Proves that a post-source-write runtime snapshot reconstructed the exact
+ * optimistic relationship. This deliberately checks hierarchy/order and the
+ * flow-vs-absolute contract; matching selectors alone is not confirmation.
+ */
+export function verifyPendingStructureRuntime(
+  snapshotHtml: string,
+  edit: PendingLiveStructureEdit,
+): RuntimeStructureVerificationResult {
+  const projection = buildCodeLayerProjection(snapshotHtml);
+  const subject = resolveCodeLayerNodeFromBridge(
+    projection,
+    edit.selector,
+    edit.sourceId ?? undefined,
+  );
+  if (!subject) return { ok: false, failure: "missing-subject" };
+  const anchor = resolveCodeLayerNodeFromBridge(
+    projection,
+    edit.anchorSelector,
+    edit.anchorSourceId ?? undefined,
+  );
+  if (!anchor) return { ok: false, failure: "missing-anchor" };
+
+  if (edit.placement === "inside") {
+    if (subject.parentId !== anchor.id) {
+      return { ok: false, failure: "wrong-parent" };
+    }
+  } else {
+    if (subject.parentId !== anchor.parentId) {
+      return { ok: false, failure: "wrong-parent" };
+    }
+    const siblings = anchor.parentId
+      ? (projection.nodes.find((node) => node.id === anchor.parentId)
+          ?.children ?? [])
+      : projection.nodes
+          .filter((node) => !node.parentId)
+          .map((node) => node.id);
+    const subjectIndex = siblings.indexOf(subject.id);
+    const anchorIndex = siblings.indexOf(anchor.id);
+    const expectedDelta = edit.placement === "before" ? -1 : 1;
+    if (
+      subjectIndex < 0 ||
+      anchorIndex < 0 ||
+      subjectIndex - anchorIndex !== expectedDelta
+    ) {
+      return { ok: false, failure: "wrong-order" };
+    }
+  }
+
+  const position = subject.style.position?.trim().toLowerCase() ?? "static";
+  if (edit.dropMode === "absolute-container" && position !== "absolute") {
+    return { ok: false, failure: "wrong-drop-mode" };
+  }
+  if (
+    edit.dropMode === "flow-insert" &&
+    (position === "absolute" || position === "fixed")
+  ) {
+    return { ok: false, failure: "wrong-drop-mode" };
+  }
+
+  return { ok: true };
+}
+
+export function verifyPendingStructuresRuntime(
+  snapshots: Record<string, { html: string } | undefined>,
+  edits: readonly PendingLiveStructureEdit[],
+): RuntimeStructureVerificationResult {
+  for (const edit of edits) {
+    const snapshot = snapshots[edit.screenId];
+    if (!snapshot) return { ok: false, failure: "missing-subject" };
+    const result = verifyPendingStructureRuntime(snapshot.html, edit);
+    if (!result.ok) return result;
+  }
+  return { ok: true };
+}

package/corpus/templates/design/app/pages/design-editor/performance-buffer-guard.ts

@@ -0,0 +1,80 @@
+import { useEffect } from "react";
+
+/**
+ * Long-running dev-mode sessions in the multi-screen overview (pan / zoom /
+ * select / undo cycles across many screens) trigger a very high render rate.
+ * In development builds, React and Radix UI primitives record a
+ * `performance.mark` / `performance.measure` entry for large numbers of
+ * component renders (visible as "Popper", "TooltipProvider", "Primitive.div",
+ * etc. in `performance.getEntriesByType("measure")`). The browser's User
+ * Timing buffer has no default cap, so these entries — and the strings/
+ * objects the Performance panel keeps for them — accumulate for the entire
+ * page lifetime. Over a long soak this dominates JS heap growth (verified via
+ * heap-snapshot diffing: hundreds of thousands of retained `PerformanceMeasure`
+ * native objects). Clearing the buffer once it crosses a bound keeps a long
+ * session's heap flat without disabling the underlying instrumentation (a
+ * fresh profiling window still fills up normally after each sweep).
+ */
+export const PERFORMANCE_BUFFER_CHECK_INTERVAL_MS = 15_000;
+export const PERFORMANCE_BUFFER_ENTRY_LIMIT = 3_000;
+
+export interface PerformanceBufferLike {
+  getEntriesByType(type: "mark" | "measure"): { length: number };
+  clearMarks?(): void;
+  clearMeasures?(): void;
+}
+
+/** Pure decision function so the threshold logic is unit-testable without a
+ * real Performance object. */
+export function shouldClearPerformanceBuffer(
+  markCount: number,
+  measureCount: number,
+  limit: number = PERFORMANCE_BUFFER_ENTRY_LIMIT,
+): boolean {
+  return markCount + measureCount > limit;
+}
+
+/** Sweeps `performance` marks/measures once if they exceed the bound. Safe to
+ * call even when the Performance User Timing APIs are unavailable. */
+export function sweepPerformanceBufferIfNeeded(
+  perf: PerformanceBufferLike,
+  limit: number = PERFORMANCE_BUFFER_ENTRY_LIMIT,
+): boolean {
+  if (
+    typeof perf.getEntriesByType !== "function" ||
+    typeof perf.clearMarks !== "function" ||
+    typeof perf.clearMeasures !== "function"
+  ) {
+    return false;
+  }
+  const markCount = perf.getEntriesByType("mark").length;
+  const measureCount = perf.getEntriesByType("measure").length;
+  if (!shouldClearPerformanceBuffer(markCount, measureCount, limit)) {
+    return false;
+  }
+  perf.clearMarks();
+  perf.clearMeasures();
+  return true;
+}
+
+/** Periodically bounds the browser's User Timing buffer for the lifetime of
+ * the mounted editor. No-op on the server and in browsers without the
+ * Performance User Timing APIs. */
+export function usePerformanceBufferGuard(
+  intervalMs: number = PERFORMANCE_BUFFER_CHECK_INTERVAL_MS,
+  limit: number = PERFORMANCE_BUFFER_ENTRY_LIMIT,
+): void {
+  useEffect(() => {
+    if (
+      !import.meta.env.DEV ||
+      typeof window === "undefined" ||
+      typeof performance === "undefined"
+    ) {
+      return;
+    }
+    const id = window.setInterval(() => {
+      sweepPerformanceBufferIfNeeded(performance, limit);
+    }, intervalMs);
+    return () => window.clearInterval(id);
+  }, [intervalMs, limit]);
+}

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

@@ -0,0 +1,58 @@
+import { isDesignHtmlIntegrityError } from "@shared/html-integrity";
+
+export type DesignSaveFailureKind =
+  | "offline"
+  | "intentional-abort"
+  | "conflict"
+  | "invalid-html"
+  | "other";
+
+function errorField(error: unknown, field: string): unknown {
+  return error && typeof error === "object"
+    ? (error as Record<string, unknown>)[field]
+    : undefined;
+}
+
+export function designSaveErrorMessage(error: unknown): string | null {
+  const message = errorField(error, "message");
+  if (typeof message !== "string" || !message.trim()) return null;
+  return message.replace(/^DESIGN_HTML_INTEGRITY:\s*/, "");
+}
+
+/**
+ * Only true transport failures deserve the “save when reconnected” warning.
+ * HMR/editor reload aborts, optimistic conflicts, IndexedDB/outbox failures,
+ * and HTML-integrity rejections are not connectivity failures.
+ */
+export function classifyDesignSaveFailure(
+  error: unknown,
+  navigatorOnline: boolean,
+): DesignSaveFailureKind {
+  if (isDesignHtmlIntegrityError(error)) return "invalid-html";
+  const name = errorField(error, "name");
+  if (name === "AbortError") return "intentional-abort";
+
+  const status = errorField(error, "status");
+  const message = designSaveErrorMessage(error)?.toLowerCase() ?? "";
+  if (
+    status === 409 ||
+    message.includes("changed since it was read") ||
+    message.includes("re-read the file") ||
+    message.includes("source file changed")
+  ) {
+    return "conflict";
+  }
+
+  if (!navigatorOnline) return "offline";
+  if (
+    (name === "TypeError" || status === 0) &&
+    (message.includes("failed to fetch") ||
+      message.includes("networkerror") ||
+      message.includes("network request failed") ||
+      message.includes("load failed"))
+  ) {
+    return "offline";
+  }
+
+  return "other";
+}

package/corpus/templates/design/app/routes/templates.tsx

@@ -1,9 +1,7 @@
-import { redirect } from "react-router";
+export { default } from "../pages/Templates";
 
-export function loader() {
-  return redirect("/", 302);
-}
+import { messagesByLocale } from "@/i18n-data";
 
-export default function TemplatesRedirect() {
-  return null;
+export function meta() {
+  return [{ title: messagesByLocale["en-US"].routeTitles.designTemplates }];
 }

package/corpus/templates/design/changelog/2026-07-10-app-workspaces-now-use-clean-borderless-main-surfaces-throug.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-10
+---
+
+App workspaces now use clean, borderless main surfaces throughout.

package/corpus/templates/design/changelog/2026-07-10-ask-chat-what-s-in-a-figma-file-or-frame-structure-screensho.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-07-10
+---
+
+Ask chat what's in a Figma file or frame (structure, screenshot, components) without importing it

package/corpus/templates/design/changelog/2026-07-10-canvas-edits-now-reject-malformed-html-before-it-can-corrupt.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Canvas edits now reject malformed HTML before it can corrupt a screen, and reconnect warnings only appear for real connection failures.

package/corpus/templates/design/changelog/2026-07-10-complex-designs-now-export-as-valid-secure-svgs-and-crisp-ra.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Complex designs now export as valid, secure SVGs and crisp raster/PDF files, and undo can restore the design from before an agent redesign.

package/corpus/templates/design/changelog/2026-07-10-complex-figma-masks-arcs-rich-text-transformed-images-and-ad.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Complex Figma masks, arcs, rich text, transformed images, and advanced strokes now preserve their appearance with explicit fallbacks instead of importing incorrectly.

package/corpus/templates/design/changelog/2026-07-10-concurrent-agent-and-artboard-edits-no-longer-show-misleadin.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Concurrent agent and artboard edits no longer show misleading HTML error popups when an unsafe merge is rejected.

package/corpus/templates/design/changelog/2026-07-10-copied-layers-paste-across-designs-and-browser-tabs.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Copied layers and screens now paste faithfully after switching designs or browser tabs.

package/corpus/templates/design/changelog/2026-07-10-copy-and-download-editable-figma-svg.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-07-10
+---
+
+Designs can now be copied or downloaded as editable Figma-ready SVG using the live rendered screen.

package/corpus/templates/design/changelog/2026-07-10-copying-design-text-now-pastes-readable-text-into-other-apps.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Copying design text now pastes readable text into other apps instead of internal HTML.

package/corpus/templates/design/changelog/2026-07-10-deleted-screens-can-be-restored-with-undo-and-removed-again-.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Deleted screens can be restored with Undo and removed again with Redo

package/corpus/templates/design/changelog/2026-07-10-design-changes-now-save-before-switching-apps-and-retry-when.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Design changes now save before switching apps and retry when you return

package/corpus/templates/design/changelog/2026-07-10-design-stays-usable-on-phones-by-keeping-editor-panels-and-f.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Design stays usable on phones by keeping editor panels and floating tools from covering chat and other controls

package/corpus/templates/design/changelog/2026-07-10-designs-with-html-examples-inside-alpine-attributes-or-comme.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Designs with HTML examples inside Alpine attributes or comments can now be edited without false integrity errors.