@agent-native/core 0.93.0 → 0.94.1

package/corpus/templates/design/app/lib/clipboard-content-lineage.ts

@@ -0,0 +1,64 @@
+export type ClipboardContentMutationOrigin =
+  | "user"
+  | "clipboard-paste"
+  | "clipboard-undo"
+  | "clipboard-redo";
+
+export interface ClipboardContentMutationPublication {
+  mutationId: number;
+  contentHash: string;
+  origin: ClipboardContentMutationOrigin;
+}
+
+export interface ClipboardContentLineage extends ClipboardContentMutationPublication {
+  content: string;
+}
+
+/**
+ * Allocate the next local mutation only when it starts from the currently
+ * authoritative document. This prevents a delayed query/Yjs replay from
+ * becoming the base of a later paste after undo has already advanced history.
+ */
+export function publishClipboardContentMutation(args: {
+  current: ClipboardContentLineage | undefined;
+  baseContentHash: string;
+  nextContent: string;
+  nextContentHash: string;
+  origin: ClipboardContentMutationOrigin;
+}): ClipboardContentLineage | null {
+  if (args.current && args.current.contentHash !== args.baseContentHash) {
+    return null;
+  }
+  return {
+    content: args.nextContent,
+    contentHash: args.nextContentHash,
+    mutationId: (args.current?.mutationId ?? 0) + 1,
+    origin: args.origin,
+  };
+}
+
+/**
+ * Passive save/query/collaboration echoes never create or advance authority.
+ * They can only confirm the exact current hash, or acknowledge an explicitly
+ * published mutation carrying the same/newer id and matching content hash.
+ */
+export function acknowledgeClipboardContentMutation(args: {
+  current: ClipboardContentLineage | undefined;
+  nextContent: string;
+  nextContentHash: string;
+  publication?: ClipboardContentMutationPublication;
+}): ClipboardContentLineage | undefined {
+  const { current, publication } = args;
+  if (
+    publication &&
+    publication.contentHash === args.nextContentHash &&
+    (!current || publication.mutationId >= current.mutationId)
+  ) {
+    return {
+      ...publication,
+      content: args.nextContent,
+    };
+  }
+  if (current?.contentHash === args.nextContentHash) return current;
+  return current;
+}

package/corpus/templates/design/app/lib/design-clipboard-managed-styles.ts

@@ -0,0 +1,247 @@
+import {
+  extractManagedBreakpointCss,
+  injectManagedBreakpointCss,
+  isSafeBreakpointCssProperty,
+  isSafeBreakpointCssValueForProperty,
+  parseBreakpointMediaCss,
+  serializeBreakpointMediaModel,
+  type BreakpointMediaModel,
+} from "@shared/breakpoint-media";
+import {
+  extractManagedInteractionStateCss,
+  extractManagedResponsiveInteractionStateCss,
+  injectManagedInteractionStateCss,
+  injectManagedResponsiveInteractionStateCss,
+  isInteractionState,
+  isSafeInteractionStateCssProperty,
+  isSafeInteractionStateCssValue,
+  parseInteractionStatesCss,
+  parseResponsiveInteractionStatesCss,
+  serializeInteractionStatesModelWithPreviews,
+  serializeResponsiveInteractionStatesModel,
+  type InteractionState,
+  type InteractionStatesModel,
+  type ResponsiveInteractionStatesModel,
+} from "@shared/interaction-states";
+
+export interface ClipboardBreakpointDeclaration {
+  maxWidthPx: number;
+  nodeId: string;
+  property: string;
+  value: string;
+}
+
+export interface ClipboardInteractionStateDeclaration {
+  maxWidthPx?: number;
+  nodeId: string;
+  state: InteractionState;
+  property: string;
+  value: string;
+}
+
+export interface DesignClipboardManagedStyleSnapshot {
+  version: 1;
+  breakpoints: ClipboardBreakpointDeclaration[];
+  interactionStates: ClipboardInteractionStateDeclaration[];
+}
+
+const MAX_DECLARATIONS = 10_000;
+const MAX_BOUND_PX = 10_000_000;
+
+function safeString(value: unknown, max: number): value is string {
+  return typeof value === "string" && value.length > 0 && value.length <= max;
+}
+
+function validBound(value: unknown): value is number {
+  return (
+    typeof value === "number" &&
+    Number.isInteger(value) &&
+    value > 0 &&
+    value <= MAX_BOUND_PX
+  );
+}
+
+export function isValidDesignClipboardManagedStyleSnapshot(
+  value: unknown,
+): value is DesignClipboardManagedStyleSnapshot {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const snapshot = value as Record<string, unknown>;
+  if (
+    snapshot.version !== 1 ||
+    !Array.isArray(snapshot.breakpoints) ||
+    !Array.isArray(snapshot.interactionStates) ||
+    snapshot.breakpoints.length + snapshot.interactionStates.length >
+      MAX_DECLARATIONS
+  ) {
+    return false;
+  }
+  const validCommon = (entry: Record<string, unknown>) =>
+    safeString(entry.nodeId, 1_024) &&
+    safeString(entry.property, 256) &&
+    safeString(entry.value, 16_384);
+  return (
+    snapshot.breakpoints.every((raw) => {
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) return false;
+      const entry = raw as Record<string, unknown>;
+      return (
+        validCommon(entry) &&
+        validBound(entry.maxWidthPx) &&
+        isSafeBreakpointCssProperty(entry.property as string) &&
+        isSafeBreakpointCssValueForProperty(
+          entry.property as string,
+          entry.value as string,
+        )
+      );
+    }) &&
+    snapshot.interactionStates.every((raw) => {
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) return false;
+      const entry = raw as Record<string, unknown>;
+      return (
+        validCommon(entry) &&
+        (entry.maxWidthPx === undefined || validBound(entry.maxWidthPx)) &&
+        typeof entry.state === "string" &&
+        isInteractionState(entry.state) &&
+        isSafeInteractionStateCssProperty(entry.property as string) &&
+        isSafeInteractionStateCssValue(entry.value as string)
+      );
+    })
+  );
+}
+
+function selectedSubtreeNodeIds(layerHtml: string): Set<string> {
+  const nodeIds = new Set<string>();
+  const attribute = /\bdata-agent-native-node-id\s*=\s*(["'])([^"']+)\1/gi;
+  for (const match of layerHtml.matchAll(attribute)) {
+    if (match[2]) nodeIds.add(match[2]);
+  }
+  return nodeIds;
+}
+
+/**
+ * Capture only managed declarations owned by the selected subtree. Responsive
+ * utility classes need no parallel payload: they already live on the cloned
+ * elements' `class` attributes and are copied with the subtree HTML.
+ */
+export function extractDesignClipboardManagedStyles(
+  sourceHtml: string,
+  layerHtml: string,
+): DesignClipboardManagedStyleSnapshot | undefined {
+  const nodeIds = selectedSubtreeNodeIds(layerHtml);
+  if (nodeIds.size === 0) return undefined;
+
+  const breakpoints: ClipboardBreakpointDeclaration[] = [];
+  const breakpointModel = parseBreakpointMediaCss(
+    extractManagedBreakpointCss(sourceHtml) ?? "",
+  );
+  for (const [bound, nodes] of Object.entries(breakpointModel)) {
+    for (const [nodeId, declarations] of Object.entries(nodes)) {
+      if (!nodeIds.has(nodeId)) continue;
+      for (const [property, value] of Object.entries(declarations)) {
+        breakpoints.push({
+          maxWidthPx: Number(bound),
+          nodeId,
+          property,
+          value,
+        });
+      }
+    }
+  }
+
+  const interactionStates: ClipboardInteractionStateDeclaration[] = [];
+  const appendStates = (model: InteractionStatesModel, maxWidthPx?: number) => {
+    for (const [nodeId, states] of Object.entries(model)) {
+      if (!nodeIds.has(nodeId)) continue;
+      for (const [state, declarations] of Object.entries(states)) {
+        if (!isInteractionState(state) || !declarations) continue;
+        for (const [property, value] of Object.entries(declarations)) {
+          interactionStates.push({
+            ...(maxWidthPx === undefined ? {} : { maxWidthPx }),
+            nodeId,
+            state,
+            property,
+            value,
+          });
+        }
+      }
+    }
+  };
+  appendStates(
+    parseInteractionStatesCss(
+      extractManagedInteractionStateCss(sourceHtml) ?? "",
+    ),
+  );
+  const responsiveStates = parseResponsiveInteractionStatesCss(
+    extractManagedResponsiveInteractionStateCss(sourceHtml) ?? "",
+  );
+  for (const [bound, model] of Object.entries(responsiveStates)) {
+    appendStates(model, Number(bound));
+  }
+
+  if (breakpoints.length === 0 && interactionStates.length === 0) {
+    return undefined;
+  }
+  return { version: 1, breakpoints, interactionStates };
+}
+
+/**
+ * Merge remapped declarations into the target document in the same content
+ * value as the cloned DOM insertion. Model serialization preserves the
+ * desktop-down cascade and makes repeated application with the same id map
+ * byte-idempotent rather than appending duplicate raw rules.
+ */
+export function applyDesignClipboardManagedStyles(
+  targetHtml: string,
+  snapshots: Array<DesignClipboardManagedStyleSnapshot | null | undefined>,
+  nodeIdMap: ReadonlyMap<string, string>,
+): string {
+  if (snapshots.length === 0 || nodeIdMap.size === 0) return targetHtml;
+
+  const breakpoints: BreakpointMediaModel = parseBreakpointMediaCss(
+    extractManagedBreakpointCss(targetHtml) ?? "",
+  );
+  const states: InteractionStatesModel = parseInteractionStatesCss(
+    extractManagedInteractionStateCss(targetHtml) ?? "",
+  );
+  const responsiveStates: ResponsiveInteractionStatesModel =
+    parseResponsiveInteractionStatesCss(
+      extractManagedResponsiveInteractionStateCss(targetHtml) ?? "",
+    );
+
+  for (const snapshot of snapshots) {
+    if (!isValidDesignClipboardManagedStyleSnapshot(snapshot)) continue;
+    for (const declaration of snapshot.breakpoints) {
+      const targetNodeId = nodeIdMap.get(declaration.nodeId);
+      if (!targetNodeId) continue;
+      const bound = String(declaration.maxWidthPx);
+      breakpoints[bound] ??= {};
+      breakpoints[bound][targetNodeId] ??= {};
+      breakpoints[bound][targetNodeId][declaration.property] =
+        declaration.value;
+    }
+    for (const declaration of snapshot.interactionStates) {
+      const targetNodeId = nodeIdMap.get(declaration.nodeId);
+      if (!targetNodeId) continue;
+      const targetModel =
+        declaration.maxWidthPx === undefined
+          ? states
+          : (responsiveStates[String(declaration.maxWidthPx)] ??= {});
+      targetModel[targetNodeId] ??= {};
+      targetModel[targetNodeId][declaration.state] ??= {};
+      targetModel[targetNodeId][declaration.state]![declaration.property] =
+        declaration.value;
+    }
+  }
+
+  let nextHtml = injectManagedBreakpointCss(
+    targetHtml,
+    serializeBreakpointMediaModel(breakpoints),
+  );
+  nextHtml = injectManagedInteractionStateCss(
+    nextHtml,
+    serializeInteractionStatesModelWithPreviews(states),
+  );
+  return injectManagedResponsiveInteractionStateCss(
+    nextHtml,
+    serializeResponsiveInteractionStatesModel(responsiveStates),
+  );
+}

package/corpus/templates/design/app/lib/design-clipboard.ts

@@ -24,6 +24,10 @@ export interface DesignClipboardEnvironment {
   clipboard?: ClipboardLike | null;
   ClipboardItem?: ClipboardItemConstructor | null;
   legacyCopy?: (representations: DesignClipboardRepresentations) => boolean;
+  preferLegacyCopy?: boolean;
+  /** Per-installation secret used to reject marker-shaped HTML authored by
+   * arbitrary external clipboard sources. `null` fails closed. */
+  trustToken?: string | null;
 }
 
 export interface DesignClipboardRepresentations {
@@ -75,9 +79,42 @@ function browserClipboardEnvironment(): DesignClipboardEnvironment {
               document.removeEventListener("copy", handleCopy, true);
             }
           },
+    // A navigation immediately after Cmd+C can cancel Chromium's pending
+    // async clipboard.write promise. The copy-event path completes before the
+    // key handler returns, matching Figma's durable copy-before-leave behavior.
+    preferLegacyCopy: true,
+    trustToken: getDesignClipboardTrustToken(),
   };
 }
 
+const DESIGN_CLIPBOARD_TRUST_TOKEN_KEY =
+  "agent-native.design.clipboard-trust-token.v1";
+
+/**
+ * A stable, origin-local capability for rich Design clipboard markers. Plain
+ * HTML copied from another page can imitate our public marker syntax; without
+ * this capability it could smuggle script/event-handler markup into a srcdoc
+ * preview that intentionally supports executable Alpine designs. localStorage
+ * makes the token available to independent Design files and browser tabs while
+ * keeping ordinary clipboard contents from forging it.
+ */
+export function getDesignClipboardTrustToken(): string | null {
+  if (typeof window === "undefined") return null;
+  try {
+    const existing = window.localStorage.getItem(
+      DESIGN_CLIPBOARD_TRUST_TOKEN_KEY,
+    );
+    if (existing) return existing;
+    const token = globalThis.crypto.randomUUID();
+    window.localStorage.setItem(DESIGN_CLIPBOARD_TRUST_TOKEN_KEY, token);
+    return token;
+  } catch {
+    // If durable origin storage is unavailable, rich external marker parsing
+    // is disabled. Same-editor copy/paste still works through in-memory refs.
+    return null;
+  }
+}
+
 function supportsClipboardType(
   ClipboardItemCtor: ClipboardItemConstructor,
   type: string,
@@ -101,6 +138,13 @@ export async function writeDesignClipboard(
   const ClipboardItemCtor = environment.ClipboardItem;
   let richWriteError: unknown;
 
+  if (
+    environment.preferLegacyCopy &&
+    environment.legacyCopy?.(representations)
+  ) {
+    return;
+  }
+
   if (
     clipboard?.write &&
     ClipboardItemCtor &&
@@ -135,6 +179,10 @@ export async function writeDesignClipboard(
 
 export function readDesignClipboardPayloadFromDataTransfer(
   clipboardData: Pick<DataTransfer, "getData"> | null | undefined,
+  environment: Pick<
+    DesignClipboardEnvironment,
+    "trustToken"
+  > = browserClipboardEnvironment(),
 ): ReadDesignClipboardPayload | null {
   if (!clipboardData) return null;
   const plainText = clipboardData.getData("text/plain") ?? "";
@@ -142,7 +190,10 @@ export function readDesignClipboardPayloadFromDataTransfer(
     clipboardData.getData("text/html") ?? "",
     plainText,
   ]) {
-    const payload = parseDesignClipboardMarker(markerText);
+    const payload = parseDesignClipboardMarker(
+      markerText,
+      environment.trustToken,
+    );
     if (payload) return { payload, markerText, plainText };
   }
   return null;
@@ -164,7 +215,10 @@ export async function readDesignClipboardPayloadFromSystem(
         for (const type of ["text/html", "text/plain"]) {
           if (!item.types.includes(type)) continue;
           const markerText = await (await item.getType(type)).text();
-          const payload = parseDesignClipboardMarker(markerText);
+          const payload = parseDesignClipboardMarker(
+            markerText,
+            environment.trustToken,
+          );
           if (payload) return { payload, markerText, plainText };
         }
       }
@@ -177,7 +231,10 @@ export async function readDesignClipboardPayloadFromSystem(
   if (!clipboard.readText) return null;
   try {
     const markerText = await clipboard.readText();
-    const payload = parseDesignClipboardMarker(markerText);
+    const payload = parseDesignClipboardMarker(
+      markerText,
+      environment.trustToken,
+    );
     return payload ? { payload, markerText, plainText: markerText } : null;
   } catch {
     return null;

package/corpus/templates/design/app/lib/design-import.ts

@@ -1,5 +1,10 @@
 import type { PortableStyleSnapshot } from "@/components/design/types";
 
+import {
+  isValidDesignClipboardManagedStyleSnapshot,
+  type DesignClipboardManagedStyleSnapshot,
+} from "./design-clipboard-managed-styles";
+
 export interface FigmaFidelityReport {
   exactCount: number;
   approximated: Array<{
@@ -202,6 +207,7 @@ export interface DesignClipboardLayerEntry {
   rootNodeId?: string;
   sourceFileId: string;
   portableStyleSnapshot?: PortableStyleSnapshot;
+  managedStyleSnapshot?: DesignClipboardManagedStyleSnapshot;
 }
 
 export interface DesignClipboardScreenEntry {
@@ -295,7 +301,9 @@ function validateDesignClipboardPayload(
       !clipboardString(entry.sourceFileId) ||
       (entry.rootNodeId !== undefined && !clipboardString(entry.rootNodeId)) ||
       (entry.portableStyleSnapshot !== undefined &&
-        !isPortableClipboardStyleSnapshot(entry.portableStyleSnapshot))
+        !isPortableClipboardStyleSnapshot(entry.portableStyleSnapshot)) ||
+      (entry.managedStyleSnapshot !== undefined &&
+        !isValidDesignClipboardManagedStyleSnapshot(entry.managedStyleSnapshot))
     ) {
       return null;
     }
@@ -371,8 +379,10 @@ function decodeClipboardMarkerData(
 export function serializeDesignClipboardPayload(
   visibleText: string,
   payload: DesignClipboardPayload,
+  trustToken?: string,
 ): string {
-  const marker = `<!--${CLIPBOARD_MARKER_PREFIX}${encodeClipboardMarkerData(payload)}-->`;
+  const trustedPrefix = trustToken ? `${trustToken}.` : "";
+  const marker = `<!--${CLIPBOARD_MARKER_PREFIX}${trustedPrefix}${encodeClipboardMarkerData(payload)}-->`;
   return `${visibleText}\n${marker}`;
 }
 
@@ -383,6 +393,7 @@ export function serializeDesignClipboardPayload(
  */
 export function parseDesignClipboardMarker(
   text: string | null | undefined,
+  expectedTrustToken?: string | null,
 ): DesignClipboardPayload | null {
   if (!text) return null;
   const markerIndex = text.lastIndexOf(`<!--${CLIPBOARD_MARKER_PREFIX}`);
@@ -390,5 +401,22 @@ export function parseDesignClipboardMarker(
   const start = markerIndex + 4 + CLIPBOARD_MARKER_PREFIX.length;
   const end = text.indexOf("-->", start);
   if (end === -1) return null;
-  return decodeClipboardMarkerData(text.slice(start, end));
+  const markerData = text.slice(start, end);
+  const separator = markerData.indexOf(".");
+  if (expectedTrustToken === null) return null;
+  if (expectedTrustToken !== undefined) {
+    if (
+      separator <= 0 ||
+      markerData.slice(0, separator) !== expectedTrustToken
+    ) {
+      return null;
+    }
+    return decodeClipboardMarkerData(markerData.slice(separator + 1));
+  }
+  // The low-level parser remains able to inspect legacy markers for migration
+  // and tests. Browser paste paths always provide the per-installation trust
+  // token and therefore reject unauthenticated clipboard HTML.
+  return decodeClipboardMarkerData(
+    separator > 0 ? markerData.slice(separator + 1) : markerData,
+  );
 }

package/corpus/templates/design/app/pages/design-editor/latest-write-queue.ts

@@ -0,0 +1,56 @@
+export interface LatestWriteQueue<T> {
+  enqueue(value: T): void;
+  hasPending(): boolean;
+  whenIdle(): Promise<void>;
+}
+
+/**
+ * Serializes a remote preference write while coalescing queued values to the
+ * newest local intent. A slow older request can therefore never finish after
+ * and overwrite a newer request, and a rejected write cannot strand the queue.
+ */
+export function createLatestWriteQueue<T>(
+  write: (value: T) => Promise<unknown>,
+  onError?: (error: unknown) => void,
+): LatestWriteQueue<T> {
+  let latest: T | undefined;
+  let drainPromise: Promise<void> | null = null;
+
+  const drain = async () => {
+    while (latest !== undefined) {
+      const value = latest;
+      latest = undefined;
+      try {
+        await write(value);
+      } catch (error) {
+        try {
+          onError?.(error);
+        } catch {
+          // Error reporting must never strand a newer queued write.
+        }
+      }
+    }
+  };
+
+  const startDrain = () => {
+    if (drainPromise) return;
+    drainPromise = drain().finally(() => {
+      drainPromise = null;
+      // Defensive handoff for a value enqueued at the drain boundary.
+      if (latest !== undefined) startDrain();
+    });
+  };
+
+  return {
+    enqueue(value) {
+      latest = value;
+      startDrain();
+    },
+    hasPending() {
+      return drainPromise !== null || latest !== undefined;
+    },
+    async whenIdle() {
+      while (drainPromise) await drainPromise;
+    },
+  };
+}

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/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-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.

package/corpus/templates/design/changelog/2026-07-10-interactive-designs-no-longer-appear-blank-in-the-canvas-whe.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Interactive designs no longer appear blank in the canvas when an update introduces new scripts.

package/corpus/templates/design/changelog/2026-07-10-long-overview-editing-sessions-lots-of-pan-zoom-screen-switc.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Long overview editing sessions (lots of pan, zoom, screen switching, and edits) no longer accumulate excess memory over time

package/corpus/templates/design/changelog/2026-07-10-rapid-breakpoint-and-edit-scope-changes-no-longer-jump-back-.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Rapid breakpoint and edit-scope changes no longer jump back to an earlier responsive selection.

package/corpus/templates/design/changelog/2026-07-10-responsive-breakpoint-previews-stay-visible-while-panning-ac.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Responsive breakpoint previews stay visible while panning across the Design overview.

package/corpus/templates/design/changelog/2026-07-10-rich-design-clipboard-markers-are-now-accepted-only-from-the.md

@@ -0,0 +1,6 @@
+---
+type: security
+date: 2026-07-10
+---
+
+Rich Design clipboard markers are now accepted only from the current browser installation.