@agent-native/core 0.92.10 → 0.92.12

package/corpus/templates/design/app/pages/design-editor/screen-auto-layout.ts

@@ -0,0 +1,169 @@
+import {
+  applyVisualEdit,
+  buildCodeLayerProjection,
+  type CodeLayerNode,
+  type CodeLayerProjection,
+} from "@shared/code-layer";
+
+import {
+  inferAutoLayoutFromChildren,
+  type AlignableRect,
+} from "./layout-operations";
+
+export type EnableInlineScreenAutoLayoutResult =
+  | {
+      status: "applied" | "unchanged";
+      content: string;
+      targetNodeId: string;
+      direction: "row" | "column";
+      gap: number;
+      padding: number;
+    }
+  | {
+      status: "unsupported" | "failed";
+      content: string;
+      message?: string;
+    };
+
+function nodeById(projection: CodeLayerProjection): Map<string, CodeLayerNode> {
+  return new Map(projection.nodes.map((node) => [node.id, node]));
+}
+
+/**
+ * A screen frame owns the authored document body. Fragment-only design files
+ * have no editable body in source, so a single visual root is the only safe
+ * equivalent. Multiple fragment roots would require inventing a wrapper and
+ * changing source structure, which is deliberately left to a semantic edit.
+ */
+export function resolveInlineScreenAutoLayoutRoot(
+  projection: CodeLayerProjection,
+): CodeLayerNode | null {
+  const body = projection.nodes.find((node) => node.tag === "body");
+  if (body) return body;
+
+  const nodes = nodeById(projection);
+  const roots = projection.rootNodeIds
+    .map((id) => nodes.get(id))
+    .filter((node): node is CodeLayerNode =>
+      Boolean(node && node.tag !== "html" && node.tag !== "head"),
+    );
+  return roots.length === 1 ? roots[0]! : null;
+}
+
+function finiteStyleNumber(value: string | undefined, fallback = 0): number {
+  const parsed = Number.parseFloat(value ?? "");
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function rectForNode(
+  node: CodeLayerNode,
+  fallback: { width?: number; height?: number } = {},
+): AlignableRect {
+  return {
+    id: node.id,
+    x: finiteStyleNumber(node.style.left),
+    y: finiteStyleNumber(node.style.top),
+    width: finiteStyleNumber(node.style.width, fallback.width ?? 0),
+    height: finiteStyleNumber(node.style.height, fallback.height ?? 0),
+  };
+}
+
+/** Deterministically enable auto layout on an inline HTML/Alpine screen root. */
+export function enableInlineScreenAutoLayout(args: {
+  content: string;
+  width?: number;
+  height?: number;
+}): EnableInlineScreenAutoLayoutResult {
+  const projection = buildCodeLayerProjection(args.content);
+  const target = resolveInlineScreenAutoLayoutRoot(projection);
+  if (!target) {
+    return { status: "unsupported", content: args.content };
+  }
+
+  const nodes = nodeById(projection);
+  const targetRect = rectForNode(target, {
+    width: args.width,
+    height: args.height,
+  });
+  const childRects = target.children
+    .map((childId) => nodes.get(childId))
+    .filter((node): node is CodeLayerNode => Boolean(node))
+    .map((node) => rectForNode(node));
+  const inferred = inferAutoLayoutFromChildren(targetRect, childRects);
+  const autoLayoutPatch = applyVisualEdit(args.content, {
+    kind: "autoLayout",
+    targetId: target.id,
+    enabled: true,
+    direction: inferred.direction,
+    gap: `${inferred.gap}px`,
+  });
+  if (autoLayoutPatch.result.status !== "applied") {
+    return {
+      status: "failed",
+      content: args.content,
+      message: autoLayoutPatch.result.message,
+    };
+  }
+
+  let content = autoLayoutPatch.content;
+  if (inferred.padding > 0) {
+    const paddingPatch = applyVisualEdit(content, {
+      kind: "style",
+      target: { nodeId: target.id },
+      property: "padding",
+      value: `${inferred.padding}px`,
+    });
+    if (paddingPatch.result.status === "applied") {
+      content = paddingPatch.content;
+    }
+  }
+
+  return {
+    status: content === args.content ? "unchanged" : "applied",
+    content,
+    targetNodeId: target.id,
+    ...inferred,
+  };
+}
+
+function hasExactReactProvenance(node: CodeLayerNode): boolean {
+  const sourceFile = node.dataAttributes["data-source-file"]?.trim();
+  const line = Number(node.dataAttributes["data-source-line"]);
+  const column = Number(node.dataAttributes["data-source-column"]);
+  return Boolean(
+    sourceFile &&
+    Number.isSafeInteger(line) &&
+    line > 0 &&
+    Number.isSafeInteger(column) &&
+    column > 0,
+  );
+}
+
+/**
+ * Resolve the shallowest compiler-provenanced React roots beneath the live
+ * screen body. Unsourced mount nodes such as `#root` are traversed, while
+ * later body branches (for example portals) are ignored once the primary app
+ * branch yields editable roots.
+ */
+export function getRuntimeScreenAutoLayoutSubjectIds(
+  projection: CodeLayerProjection,
+): string[] {
+  const nodes = nodeById(projection);
+  const collect = (nodeId: string, ancestors: Set<string>): string[] => {
+    if (ancestors.has(nodeId)) return [];
+    const node = nodes.get(nodeId);
+    if (!node) return [];
+    if (hasExactReactProvenance(node)) return [node.id];
+    const nextAncestors = new Set(ancestors);
+    nextAncestors.add(nodeId);
+    return node.children.flatMap((childId) => collect(childId, nextAncestors));
+  };
+
+  const body = projection.nodes.find((node) => node.tag === "body");
+  const branchIds = body?.children ?? projection.rootNodeIds;
+  for (const branchId of branchIds) {
+    const subjects = collect(branchId, new Set());
+    if (subjects.length > 0) return Array.from(new Set(subjects));
+  }
+  return [];
+}

package/corpus/templates/design/app/pages/design-editor/selection-state.ts

@@ -46,6 +46,33 @@ export function getOverviewScreenRuntimeReplacementKey({
   return [screenId, updatedAt ?? "", getContentSignature(content)].join(":");
 }
 
+/** Keep inline overview iframe identity stable across active-screen switches
+ * and content/history updates. Inline overview screens have the bridge-backed
+ * full-document replacement channel, so content changes belong in
+ * `runtimeReplacementKey`, never in the iframe's srcdoc identity key. Other
+ * source types retain the legacy remount fallback because they may not expose
+ * an in-place document replacement bridge. */
+export function getOverviewScreenContentKey({
+  screenId,
+  screenIsActive,
+  contentRenderRevision,
+  updatedAt,
+  content,
+  useRuntimeReplacement,
+}: {
+  screenId: string;
+  screenIsActive: boolean;
+  contentRenderRevision: number;
+  updatedAt?: string | null;
+  content: string;
+  useRuntimeReplacement: boolean;
+}): string {
+  if (useRuntimeReplacement) return `${screenId}:inline-overview`;
+  return screenIsActive
+    ? [screenId, contentRenderRevision].join(":")
+    : [screenId, updatedAt ?? "", getContentSignature(content), 0].join(":");
+}
+
 export function shouldUseOverviewRuntimeReplacement({
   sourceType,
   externalSnapshotHtml,
@@ -84,6 +111,38 @@ export function sameStringIds(a: string[], b: string[]) {
   return a.length === b.length && a.every((value, index) => value === b[index]);
 }
 
+/**
+ * Undo/redo inspector-panel resync — decides whether a pending live edit
+ * being reverted/replayed (by handleUndo's pendingStyleUndo/
+ * pendingNonStyleUndo branches, or handleRedo's pendingTextRedo/
+ * pendingLiveRedo branches) targets the SAME element as the current
+ * `selectedElement`. Undo/redo aren't guaranteed to be undoing the
+ * currently-selected element (the user may have re-selected something else
+ * since the edit was made), so the panel should only be patched with the
+ * revert/redo payload when this returns true — otherwise a background
+ * undo would incorrectly clobber whatever the user has selected right now.
+ * Matches by sourceId when BOTH sides carry one (the stable, authoritative
+ * identity across re-renders) — a sourceId mismatch there means a different
+ * element even if their selectors coincidentally collide (e.g. repeated
+ * list items sharing one CSS selector). Falls back to the CSS selector only
+ * when a sourceId comparison isn't possible on at least one side.
+ *
+ * Exported for unit testing.
+ */
+export function pendingEditTargetsSelectedElement(args: {
+  editSourceId?: string | null;
+  editSelector: string;
+  selectedSourceId?: string | null;
+  selectedSelector?: string | null;
+}): boolean {
+  if (args.editSourceId && args.selectedSourceId) {
+    return args.selectedSourceId === args.editSourceId;
+  }
+  return Boolean(
+    args.selectedSelector && args.selectedSelector === args.editSelector,
+  );
+}
+
 export function isScreenRootElementInfo(info: ElementInfo | null | undefined) {
   const tagName = info?.tagName?.toUpperCase();
   return tagName === "BODY" || tagName === "HTML";
@@ -104,13 +163,29 @@ export function shouldIgnoreOverviewLayerCreationEcho(args: {
   pendingScreenId: string | null | undefined;
   screenId: string;
   info?: ElementInfo | null;
+  resolvedLayerId?: string | null;
   event: "select" | "clear";
 }) {
   if (!args.pendingLayerId) return false;
   if (args.pendingScreenId && args.pendingScreenId !== args.screenId) {
     return false;
   }
-  return args.event === "clear" || isScreenRootElementInfo(args.info);
+  if (args.event === "clear" || isScreenRootElementInfo(args.info)) {
+    return true;
+  }
+  // Layers-panel selection is applied optimistically in the host, then the
+  // selected selector is mirrored into the overview iframe. The bridge echoes
+  // that exact layer back as an ordinary element-select a frame later. Without
+  // recognizing the matching id here, a Cmd/Ctrl toggle or Shift range briefly
+  // renders the correct multi-selection and is then collapsed to the echoed
+  // primary layer. Only ignore the exact pending layer; a real canvas click on
+  // any other element must still replace the panel selection immediately.
+  const echoedLayerId =
+    args.info?.sourceId ?? args.info?.id ?? args.info?.pendingNodeId;
+  return (
+    args.resolvedLayerId === args.pendingLayerId ||
+    echoedLayerId === args.pendingLayerId
+  );
 }
 
 export function getSelectedScreenIdsForEditorState(args: {
@@ -291,6 +366,99 @@ export function shouldEscapeToOverview(args: {
   );
 }
 
+/**
+ * A node's `parentId` in the FLAT code-layer ownership map
+ * (`codeLayerOwnerByNodeId` / `codeLayerOwnerByNodeIdRef` in DesignEditor.tsx)
+ * still points at `<html>`/`<body>` even though the VISUAL layers tree
+ * collapses those document-shell nodes away (see shared/code-layer.ts's
+ * `isCollapsibleDocumentShellNode` / `compactCodeLayerTreeNodes`) — the flat
+ * map is built straight from `projection.nodes`, which is never filtered.
+ * Mirrors `isCollapsibleDocumentShellNode`'s own check (tag is html/body AND
+ * the layer name came from the tag itself, i.e. nothing more specific named
+ * it) against the flat `CodeLayerNode`'s own fields directly, since the flat
+ * node already carries `tag`/`layerNameSource` without needing a separate
+ * lookup map.
+ *
+ * Both the Escape pop-one-level walk (`resolveEscapePopSelectionAction`) and
+ * the shared Shift+Enter / "\\" select-parent walk (`handleSelectParentLayer`
+ * in DesignEditor.tsx) must treat a parent that resolves to a document-shell
+ * node as NO parent at all — otherwise popping from a top-level layer selects
+ * the raw `<body>`/`<html>` DOM nodes instead of stopping at the screen/frame
+ * level (or fully deselecting), which produces a permanently broken 0x0
+ * inspector with no way back to a deselected state.
+ *
+ * Exported for unit testing.
+ */
+export function isDocumentShellCodeLayerNode(node: {
+  tag: string;
+  layerNameSource: string;
+}): boolean {
+  return (
+    (node.tag === "html" || node.tag === "body") &&
+    node.layerNameSource === "tag"
+  );
+}
+
+/**
+ * True only when `parentNode` exists AND is not a document-shell node — see
+ * `isDocumentShellCodeLayerNode`. Callers walking the flat code-layer
+ * ownership map (Escape pop-one-level, Shift+Enter select-parent) must use
+ * this instead of a bare `Boolean(parentNode)` truthiness check, or a
+ * top-level layer's collapsed `<body>`/`<html>` ancestor gets treated as a
+ * selectable parent layer.
+ *
+ * Exported for unit testing.
+ */
+export function hasSelectableCodeLayerParent(args: {
+  parentNode: { tag: string; layerNameSource: string } | null | undefined;
+}): boolean {
+  return (
+    args.parentNode != null && !isDocumentShellCodeLayerNode(args.parentNode)
+  );
+}
+
+export type EscapePopSelectionAction =
+  | { kind: "pop-to-parent-layer" }
+  | { kind: "pop-to-screen-frame" }
+  | { kind: "deselect" };
+
+/**
+ * Figma parity — Escape on a plain canvas selection pops one level at a
+ * time (child layer -> parent layer -> containing screen/frame -> fully
+ * deselected) instead of deselecting everything on the first press.
+ *
+ * - A selected layer that has a code-layer parent (`hasLayerParent`) pops to
+ *   that parent, reusing the same ancestor-walk `handleSelectParentLayer`
+ *   (Shift+Enter / "\\") already uses via `codeLayerOwnerByNodeIdRef`.
+ * - A selected TOP-level layer (no code-layer parent) in overview mode pops
+ *   to selecting its containing screen/frame — the same selection kind
+ *   (`overviewSelectedScreenIds`) clicking a frame directly in overview
+ *   already produces.
+ * - Anything else — nothing selected, or a top-level layer in single-screen
+ *   mode where there's no separate "frame" to pop to (the screen already
+ *   fills the view, so top-level already reads as "the frame boundary") —
+ *   falls straight through to a full deselect, matching the previous
+ *   unconditional Escape behavior.
+ *
+ * Callers must have already handled every higher-priority Escape consumer
+ * (an in-progress marquee/drag, an active breakpoint edit target,
+ * `shouldEscapeToOverview`'s zoom-out-to-overview case) before calling this
+ * — it only decides the remaining plain-canvas-selection case.
+ *
+ * Exported for unit testing.
+ */
+export function resolveEscapePopSelectionAction(args: {
+  hasSelectedLayer: boolean;
+  hasLayerParent: boolean;
+  viewMode: "single" | "overview";
+}): EscapePopSelectionAction {
+  if (args.hasSelectedLayer) {
+    if (args.hasLayerParent) return { kind: "pop-to-parent-layer" };
+    if (args.viewMode === "overview") return { kind: "pop-to-screen-frame" };
+  }
+  return { kind: "deselect" };
+}
+
 /**
  * B5-1: an empty-canvas click (a marquee/hit-test that resolved to zero
  * elements) must deselect ANY current selection kind — a selected
@@ -315,6 +483,38 @@ export function shouldClearBridgeSelectionOnEmptyMarquee(args: {
   return args.resolvedCount === 0 && !args.additive;
 }
 
+/**
+ * PICK-RACE: MultiScreenCanvas's `onPick` prop is `(id: string) => void` — no
+ * modifier/event info — even though a shift-click there already toggled a
+ * full multi-id array internally (handleFrameClick's own `selectedIds`
+ * state) before calling `onPick` with just the resulting PRIMARY id. That
+ * full array only reaches DesignEditor a render later, via the
+ * `onScreenSelectionChange` effect (MultiScreenCanvas reports its
+ * `selectedIds` from a `useEffect` that commits after this synchronous
+ * `onPick` call already ran).
+ *
+ * Forcing `selectedLayerIdsState` down to `[pickedId]` in
+ * `handleOverviewScreenPick` is wrong for BOTH shift-click cases: adding a
+ * screen would drop every other already-selected screen, and removing one
+ * would replace the whole array with just the new primary — there is no way
+ * to reconstruct the correct multi-id array from a single id. So: while
+ * Shift is held, this returns the CURRENT selection unchanged instead of a
+ * wrong singleton, and lets `overviewSelectedScreenIds` (which the
+ * `selectedLayerIds` derivation already prefers whenever non-empty) be the
+ * sole source of truth once that effect settles. When Shift isn't held this
+ * is a plain single-screen pick, matching the previous unconditional
+ * behavior.
+ *
+ * Exported for unit testing.
+ */
+export function computeOverviewScreenPickSelectionIds(args: {
+  pickedId: string;
+  shiftKeyHeld: boolean;
+  currentSelectedLayerIds: string[];
+}): string[] {
+  return args.shiftKeyHeld ? args.currentSelectedLayerIds : [args.pickedId];
+}
+
 /**
  * Build the set of all node ids (both projection ids and data-agent-native-node-id
  * attribute values) that exist in the given projection. Used by handleGroupSelection

package/corpus/templates/design/changelog/2026-07-09-added-underline-strikethrough-and-text-case-uppercase-lowerc.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-07-09
+---
+
+Typography properties now include underline, strikethrough, and text case controls.

package/corpus/templates/design/changelog/2026-07-09-annotate-now-draws-across-the-all-screens-canvas-without-swi.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-09
+---
+
+Annotate now draws across the All Screens canvas without switching views or reloading screen previews.

package/corpus/templates/design/changelog/2026-07-09-auto-layout-children-can-now-be-dragged-into-freeform-screen.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-09
+---
+
+Auto-layout children can now be dragged into freeform screens, other layouts, and absolute frames without jumping or losing their position.

package/corpus/templates/design/changelog/2026-07-09-board-shapes-now-stay-visible-and-nest-correctly-across-the-.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-09
+---
+
+Board shapes now stay visible and nest correctly across the All screens canvas without iframe flashes.

package/corpus/templates/design/changelog/2026-07-09-component-source-navigation-now-opens-reliably-from-the-insp.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-09
+---
+
+Component source navigation now opens reliably from the inspector and component interactions.

package/corpus/templates/design/changelog/2026-07-09-cross-screen-local-react-layer-moves-now-hand-off-exact-sour.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-09
+---
+
+Cross-screen local React layer moves now hand off exact source anchors safely instead of silently refusing the drop.

package/corpus/templates/design/changelog/2026-07-09-cross-screen-moves-undo-and-redo-now-keep-both-screens-stabl.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-09
+---
+
+Cross-screen moves, undo, and redo now keep both screens stable without preview flashes or lost selection

package/corpus/templates/design/changelog/2026-07-09-detach-a-component-instance-into-plain-editable-eleme.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-07-09
+---
+
+Component instances can now be detached (⌥⌘B) into plain, independently-editable elements.

package/corpus/templates/design/changelog/2026-07-09-dragging-layers-into-auto-layout-now-respects-ignore-auto-la.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-09
+---
+
+Dragging layers into auto layout now respects Ignore auto layout and stays visually stable during reparenting

package/corpus/templates/design/changelog/2026-07-09-drawing-annotations-sent-to-the-agent-now-include-a-rendered.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-09
+---
+
+Drawing annotations sent to the agent now include a rendered screenshot with the drawing composited on top, not just coordinates

package/corpus/templates/design/changelog/2026-07-09-editor-sidebars-now-use-figma-matched-default-widths-for-a-r.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-09
+---
+
+Editor sidebars now use Figma-matched default widths for a roomier, more familiar canvas.

package/corpus/templates/design/changelog/2026-07-09-empty-frames-and-rectangles-now-expose-full-auto-layout-cont.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-09
+---
+
+Empty frames and rectangles now expose full Auto layout controls, and promoted containers show the correct Layers icon.

package/corpus/templates/design/changelog/2026-07-09-export-any-design-screen-as-a-real-vector-svg-for-figma-with.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-07-09
+---
+
+Export any design screen as a real vector SVG for Figma, with copy-to-clipboard and drag-import support

package/corpus/templates/design/changelog/2026-07-09-grid-auto-layout-now-uses-true-responsive-rows-and-columns-w.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-09
+---
+
+Grid auto layout now uses true responsive rows and columns with track sizing, independent gaps, and fluid canvas reordering.

package/corpus/templates/design/changelog/2026-07-09-hidden-and-locked-screens-now-behave-consistently-between-la.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-09
+---
+
+Hidden and locked screens now behave consistently between Layers and the overview canvas.

package/corpus/templates/design/changelog/2026-07-09-image-fills-now-preserve-valid-urls-and-layered-fit-settings.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-09
+---
+
+Image fills now preserve valid URLs and layered fit settings across page and layer edits.

package/corpus/templates/design/changelog/2026-07-09-import-figma-frames-as-pixel-accurate-design-screens-via-a-s.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-07-09
+---
+
+Import Figma frames as pixel-accurate Design screens via a shared file/branch link

package/corpus/templates/design/changelog/2026-07-09-inspect-code-now-hides-internal-styling-metadata-and-wraps-l.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-09
+---
+
+Inspect Code now hides internal styling metadata and wraps long attribute lists for easier reading.

package/corpus/templates/design/changelog/2026-07-09-inspector-blur-and-shadow-effects-now-preserve-other-effects.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-09
+---
+
+Inspector effects preserve sibling filters and fractional values, linking padding no longer overwrites asymmetric sides, and mixed layout or constraint selections now display honestly.

package/corpus/templates/design/changelog/2026-07-09-jump-to-a-components-other-instances-from-the-inspecto.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-07-09
+---
+
+The Component inspector panel and canvas context menu can now jump to a component's earliest instance ("Go to main component").

package/corpus/templates/design/changelog/2026-07-09-keyboard-shortcuts-are-now-discoverable-in-a-figma-style-bot.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-07-09
+---
+
+Keyboard shortcuts are now discoverable in a Figma-style bottom panel from the app menu or Ctrl+Shift+?.

package/corpus/templates/design/changelog/2026-07-09-layer-selection-now-keeps-cmd-or-ctrl-toggles-and-shift-rang.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-09
+---
+
+Layer selection now keeps Cmd or Ctrl toggles and Shift ranges intact in All screens view

package/corpus/templates/design/changelog/2026-07-09-layers-dropped-into-auto-layout-now-participate-correctly-in.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-09
+---
+
+Layers dropped into Auto layout now participate correctly in ordering, spacing, and alignment.

package/corpus/templates/design/changelog/2026-07-09-local-live-edit-screens-now-enter-and-leave-full-view-withou.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-09
+---
+
+Local live-edit screens now enter and leave Full view without blank, URL-only, or duplicate-loading flashes.

package/corpus/templates/design/changelog/2026-07-09-local-preview-urls-now-live-in-the-inspector-instead-of-taki.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-09
+---
+
+Local preview URLs now live in the inspector instead of taking space above the canvas

package/corpus/templates/design/changelog/2026-07-09-local-react-layers-can-now-be-hidden-and-locked-from-layers-.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-09
+---
+
+Local React layers can now be hidden and locked from Layers with source-backed persistence.

package/corpus/templates/design/changelog/2026-07-09-local-react-layers-now-keep-exact-source-provenance-and-supp.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-09
+---
+
+Local React layers now keep exact source provenance and support safe same-screen reorder, reparent, group, ungroup, and Auto layout editing through the coding agent.

package/corpus/templates/design/changelog/2026-07-09-local-react-visual-editing-now-loads-reliably-and-shows-live.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-09
+---
+
+Local React visual editing now loads reliably and shows live component layers with exact development source locations.

package/corpus/templates/design/changelog/2026-07-09-paste-from-figma-cmd-v-now-imports-exact-editable-nodes-when.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-09
+---
+
+Paste from Figma (Cmd+V) now imports exact, editable nodes when possible, with a clear fallback and hint when it can't

package/corpus/templates/design/changelog/2026-07-09-pressing-escape-after-selecting-a-screen-now-reveals-page-pr.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-09
+---
+
+Pressing Escape after selecting a screen now reveals Page properties instead of immediately reselecting the active screen.

package/corpus/templates/design/changelog/2026-07-09-right-click-overlapping-or-nested-objects-to-choose-the-exac.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-07-09
+---
+
+Right-click overlapping or nested objects to choose the exact visible unlocked layer from a Figma-style Select layer submenu

package/corpus/templates/design/changelog/2026-07-09-scale-edge-stretch-and-center-constraints-now-preserve-layer.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-09
+---
+
+Scale, edge, stretch, and center constraints now preserve layer geometry when nested or auto-layout frames resize