@agent-native/core 0.92.9 → 0.92.11

package/corpus/templates/design/app/components/design/bridge/embedded-wheel.bridge.ts

@@ -24,6 +24,8 @@
  * Protocol (parent → iframe):
  *
  *   { type: 'embedded-canvas-pan-mode', leftButtonEnabled }
+ *   { type: 'embedded-canvas-gesture-mode', wheelEnabled,
+ *     spaceKeyForwardingEnabled }
  *   { type: 'embedded-canvas-pan-cancel' }
  *
  * Rules:
@@ -244,6 +246,11 @@ declare var __EMBEDDED_SPACE_KEY_FORWARDING_ENABLED__: boolean;
     }
     if (e.data.type === "embedded-canvas-pan-mode") {
       leftButtonEnabled = !!e.data.leftButtonEnabled;
+      return;
+    }
+    if (e.data.type === "embedded-canvas-gesture-mode") {
+      wheelEnabled = !!e.data.wheelEnabled;
+      spaceKeyForwardingEnabled = !!e.data.spaceKeyForwardingEnabled;
     }
   }
 

package/corpus/templates/design/app/components/design/bridge/hit-test.bridge.ts

@@ -251,7 +251,12 @@
       el.getAttribute("data-agent-native-primitive") ||
       ""
     ).toLowerCase();
-    if (primitive !== "rectangle" && primitive !== "rect") return false;
+    if (
+      primitive !== "rectangle" &&
+      primitive !== "rect" &&
+      primitive !== "frame"
+    )
+      return false;
     var cs = window.getComputedStyle(el);
     return cs.position === "absolute" || cs.position === "fixed";
   }

package/corpus/templates/design/app/components/design/bridge/motion-preview.bridge.ts

@@ -66,6 +66,26 @@
   var touchedProps: Record<string, string[]> = {};
   // Map of nodeId -> property -> original inline style value.
   var originalInlineValues: Record<string, Record<string, string>> = {};
+  // Map of nodeId -> resolved element, so applyPreview's per-track lookup
+  // during scrub/playback (driven by the parent's own rAF loop — one
+  // "motion-preview" message per frame) does one attribute-selector
+  // querySelector per node ONCE instead of once per track on every single
+  // frame. Invalidated (falls through to a fresh querySelector) whenever the
+  // cached element is no longer in the document — e.g. a host-applied edit
+  // replaced the node — so a stale reference never silently no-ops a track.
+  // Reset alongside the other per-load state in clearPreview so a reload
+  // after the previewed screen's DOM changes always re-resolves.
+  var elementCache: Record<string, HTMLElement | null> = {};
+
+  function resolveTrackElement(nodeId: string): HTMLElement | null {
+    var cached = elementCache[nodeId];
+    if (cached && document.contains(cached)) return cached;
+    var el = document.querySelector(
+      '[data-agent-native-node-id="' + nodeId + '"]',
+    ) as HTMLElement | null;
+    elementCache[nodeId] = el;
+    return el;
+  }
 
   function camelizeProp(prop: string): string {
     return String(prop).replace(/-([a-z])/g, function (_m: string, c: string) {
@@ -673,9 +693,7 @@
   function applyPreview(t: number): void {
     for (var i = 0; i < loadedTracks.length; i++) {
       var track = loadedTracks[i];
-      var el = document.querySelector(
-        '[data-agent-native-node-id="' + track.targetNodeId + '"]',
-      ) as HTMLElement | null;
+      var el = resolveTrackElement(track.targetNodeId);
       if (!el) continue;
       var value = interpolate(track.keyframes, trackLocalT(track, t));
       if (value === "") continue;
@@ -700,9 +718,7 @@
   function clearPreview(): void {
     var nodeIds = Object.keys(touchedProps);
     for (var i = 0; i < nodeIds.length; i++) {
-      var el = document.querySelector(
-        '[data-agent-native-node-id="' + nodeIds[i] + '"]',
-      ) as HTMLElement | null;
+      var el = resolveTrackElement(nodeIds[i]);
       if (!el) continue;
       var props = touchedProps[nodeIds[i]];
       for (var j = 0; j < props.length; j++) {
@@ -718,6 +734,7 @@
     loadedTracks = [];
     loadedDefaultEase = "ease";
     loadedTimelineDurationMs = null;
+    elementCache = {};
   }
 
   // Last previewed playhead position, so reloading the track list (which

package/corpus/templates/design/app/components/design/bridge/sample.bridge.ts

@@ -10,6 +10,13 @@
  */
 (function () {
   window.addEventListener("message", function (e: MessageEvent) {
+    // Every other *.bridge.ts listener validates the sender before trusting
+    // the payload (see editor-chrome.bridge.ts, hit-test.bridge.ts, etc. —
+    // all check `e.source !== window.parent`); this one didn't, even though
+    // it's just a compile-pipeline smoke-test fixture with no real iframe
+    // wiring today. Match the house rule so it stays a safe template to
+    // copy from if this file is ever pointed at a live surface.
+    if (e.source !== window.parent) return;
     if (!e.data || e.data.type !== "agent-native:sample-ping") return;
     var correlationId: string = e.data.correlationId ?? "";
     try {

package/corpus/templates/design/app/components/design/code-workbench/CodeWorkbench.tsx

@@ -350,9 +350,14 @@ function CodeWorkbenchInner({
       const onUp = () => {
         target.removeEventListener("pointermove", onMove);
         target.removeEventListener("pointerup", onUp);
+        target.removeEventListener("pointercancel", onUp);
       };
       target.addEventListener("pointermove", onMove);
       target.addEventListener("pointerup", onUp);
+      // A cancelled pointer (e.g. a dialog stealing capture mid-drag) would
+      // otherwise never fire pointerup, leaking these listeners onto the
+      // resize handle until the next drag piles more on top of them.
+      target.addEventListener("pointercancel", onUp);
     },
     [api],
   );

package/corpus/templates/design/app/components/design/code-workbench/editor/MonacoHost.tsx

@@ -9,6 +9,7 @@ import {
 } from "../../code-workbench-theme";
 import {
   dispatchKeybinding,
+  runCommand,
   type WorkbenchCommand,
   type WorkbenchCommandContext,
 } from "../commands";
@@ -93,11 +94,22 @@ export function MonacoHost({
     // Safety net: Monaco's own Cmd+S binding (if any) is not guaranteed, and
     // the root's capture-phase keydown handler already dispatches workbench
     // commands before Monaco sees them — this addCommand is a belt-and-
-    // braces fallback for save specifically.
+    // braces fallback for save specifically. It goes through the same
+    // `workbench.save` command (via runCommand) as every other invocation
+    // path, not a bare `api.save()` call, so a failed save (stale version,
+    // missing local write consent, network error) still surfaces a toast /
+    // consent-retry here instead of failing silently.
     editor.addCommand(
       monacoModule.KeyMod.CtrlCmd | monacoModule.KeyCode.KeyS,
       () => {
-        void commandContextRef.current.api.save();
+        const saveCommand = commandsRef.current.find(
+          (command) => command.id === "workbench.save",
+        );
+        if (saveCommand) {
+          void runCommand(saveCommand, commandContextRef.current);
+        } else {
+          void commandContextRef.current.api.save();
+        }
       },
     );
 

package/corpus/templates/design/app/components/design/code-workbench/explorer/FileTree.tsx

@@ -93,6 +93,16 @@ export function FileTree({
     text: "",
     at: 0,
   });
+  // When Enter/Escape ends a rename or new-file input via setRenamingPath /
+  // setPendingNewFile, React unmounts the focused input as part of that same
+  // update. Removing a focused DOM node makes the browser fire a native blur
+  // on it, which our onBlur handler would otherwise treat as an independent
+  // commit — double-submitting on Enter (rename/create called twice) and
+  // silently committing the draft on Escape instead of discarding it. These
+  // refs let the key handler mark "I already resolved this input" so the
+  // resulting blur is a no-op.
+  const renameHandledRef = useRef(false);
+  const newFileHandledRef = useRef(false);
 
   const rows = flattenVisibleTree(nodes, expandedPaths);
 
@@ -121,6 +131,7 @@ export function FileTree({
   );
 
   const startRename = useCallback((node: TreeNode) => {
+    renameHandledRef.current = false;
     setRenamingPath(node.path);
     setRenameDraft(baseName(node.path));
   }, []);
@@ -293,6 +304,7 @@ export function FileTree({
               label="New File" /* i18n-ignore */
               icon={IconPlus}
               onClick={() => {
+                newFileHandledRef.current = false;
                 setPendingNewFile({ parentPath: "" });
                 setNewFileDraft("");
               }}
@@ -390,14 +402,25 @@ export function FileTree({
                       value={renameDraft}
                       onClick={(event) => event.stopPropagation()}
                       onChange={(event) => setRenameDraft(event.target.value)}
-                      onBlur={() => commitRename(row.node)}
+                      onBlur={() => {
+                        // Enter/Escape already resolved this input; the blur
+                        // firing right after is just the DOM node unmounting,
+                        // not a real "user clicked away" commit request.
+                        if (renameHandledRef.current) {
+                          renameHandledRef.current = false;
+                          return;
+                        }
+                        void commitRename(row.node);
+                      }}
                       onKeyDown={(event) => {
                         event.stopPropagation();
                         if (event.key === "Enter") {
                           event.preventDefault();
+                          renameHandledRef.current = true;
                           void commitRename(row.node);
                         } else if (event.key === "Escape") {
                           event.preventDefault();
+                          renameHandledRef.current = true;
                           setRenamingPath(null);
                         }
                       }}
@@ -418,6 +441,7 @@ export function FileTree({
                   <ContextMenuItem
                     className="text-[12px]"
                     onSelect={() => {
+                      newFileHandledRef.current = false;
                       toggleFolder(row.path, true);
                       setPendingNewFile({ parentPath: row.path });
                       setNewFileDraft("");
@@ -481,14 +505,25 @@ export function FileTree({
               value={newFileDraft}
               placeholder="filename.ext" /* i18n-ignore */
               onChange={(event) => setNewFileDraft(event.target.value)}
-              onBlur={() => commitNewFile()}
+              onBlur={() => {
+                // Enter/Escape already resolved this input; the blur firing
+                // right after is just the DOM node unmounting, not a real
+                // "user clicked away" commit request.
+                if (newFileHandledRef.current) {
+                  newFileHandledRef.current = false;
+                  return;
+                }
+                void commitNewFile();
+              }}
               onKeyDown={(event) => {
                 event.stopPropagation();
                 if (event.key === "Enter") {
                   event.preventDefault();
+                  newFileHandledRef.current = true;
                   void commitNewFile();
                 } else if (event.key === "Escape") {
                   event.preventDefault();
+                  newFileHandledRef.current = true;
                   setPendingNewFile(null);
                   setNewFileDraft("");
                 }

package/corpus/templates/design/app/components/design/code-workbench/format/format-on-open-guard.ts

@@ -0,0 +1,25 @@
+/**
+ * Pure guard extracted from format-on-open.ts so it stays unit-testable
+ * without pulling in `../store` / `../model-registry` (and transitively
+ * `monaco-editor`, which requires a full browser environment and can't load
+ * under vitest's default node/jsdom setup) — same split used by
+ * status-bar-lang.ts for StatusBar.tsx.
+ */
+
+/**
+ * Decide whether a completed background format result is still safe to
+ * apply. `snapshotContent` is the buffer content that was actually sent to
+ * Prettier; formatting runs asynchronously (dynamic plugin imports + async
+ * format), so by the time the result comes back the user may have already
+ * started editing the live model. Applying the formatted text in that case
+ * would silently discard their in-progress edits, so we bail unless the
+ * model's current value still matches the snapshot that was formatted.
+ */
+export function shouldApplyFormatResult(
+  currentModelValue: string,
+  snapshotContent: string,
+  formatted: string,
+): boolean {
+  if (formatted === snapshotContent) return false;
+  return currentModelValue === snapshotContent;
+}

package/corpus/templates/design/app/components/design/code-workbench/format/format-on-open.ts

@@ -3,8 +3,11 @@ import { useEffect } from "react";
 import { modelRegistry } from "../model-registry";
 import { useWorkbench, type BufferLoadedEvent } from "../store";
 import { providerKindFromKey } from "../workspace/types";
+import { shouldApplyFormatResult } from "./format-on-open-guard";
 import { formatWithPrettier, isFormattablePath } from "./prettier-format";
 
+export { shouldApplyFormatResult } from "./format-on-open-guard";
+
 /**
  * Auto-format-on-first-open policy: the design's SQL-backed (inline) files
  * are machine-generated, so the first time a formattable inline buffer is
@@ -42,10 +45,25 @@ export function useFormatOnFirstOpen({ enabled }: { enabled: boolean }): void {
       void (async () => {
         const result = await formatWithPrettier(event.read.content, event.path);
         if ("error" in result) return;
-        if (result.formatted === event.read.content) return;
 
         const entry = modelRegistry.get(event.uri);
         if (!entry || entry.model.isDisposed()) return;
+        // Formatting is async (dynamic plugin imports + Prettier itself), so
+        // the user may have started typing in the buffer while we were
+        // awaiting the result. Applying `result.formatted` — derived from the
+        // pre-format snapshot — over the model unconditionally would silently
+        // clobber those in-progress edits. Bail out if the live model no
+        // longer matches the snapshot that was formatted; a later save or
+        // manual format can pick it up.
+        if (
+          !shouldApplyFormatResult(
+            entry.model.getValue(),
+            event.read.content,
+            result.formatted,
+          )
+        ) {
+          return;
+        }
         // Push the formatted text without touching savedAltVersionId, so the
         // buffer becomes dirty (matches the "formatted but unsaved" state a
         // real edit would produce) — then save silently.

package/corpus/templates/design/app/components/design/code-workbench/model-registry.ts

@@ -31,6 +31,16 @@ function monacoUriFor(uri: string): monaco.Uri {
 
 class WorkbenchModelRegistry {
   private entries = new Map<string, WorkbenchModelEntry>();
+  /**
+   * Uris currently inside an `applyExternalContent`/`reloadContent` call.
+   * Monaco fires `onDidChangeContent` synchronously from inside
+   * `pushEditOperations`, before this class can update `savedAltVersionId` to
+   * the post-edit version — so a dirty-tracking subscriber reading
+   * `isDirty()` from that callback would see a stale "dirty" result for an
+   * edit nobody typed. Callers (store.tsx's dirty-tracking subscription) use
+   * `isApplyingExternalContent` to skip acting on that spurious notification.
+   */
+  private externalContentUris = new Set<string>();
 
   get(uri: string): WorkbenchModelEntry | undefined {
     return this.entries.get(uri);
@@ -75,6 +85,15 @@ class WorkbenchModelRegistry {
     return entry.model.getAlternativeVersionId() !== entry.savedAltVersionId;
   }
 
+  /**
+   * True while `uri`'s content is being replaced by `applyExternalContent`.
+   * Dirty-tracking subscribers must ignore `onDidChangeContent` notifications
+   * that fire while this is true — see the field comment above.
+   */
+  isApplyingExternalContent(uri: string): boolean {
+    return this.externalContentUris.has(uri);
+  }
+
   /**
    * Replace buffer content from an external change (agent edit, canvas edit)
    * while preserving the undo stack.
@@ -87,14 +106,33 @@ class WorkbenchModelRegistry {
       entry.savedAltVersionId = model.getAlternativeVersionId();
       return;
     }
-    model.pushEditOperations(
-      null,
-      [{ range: model.getFullModelRange(), text: content }],
-      () => null,
-    );
+    this.externalContentUris.add(uri);
+    try {
+      model.pushEditOperations(
+        null,
+        [{ range: model.getFullModelRange(), text: content }],
+        () => null,
+      );
+    } finally {
+      this.externalContentUris.delete(uri);
+    }
     entry.savedAltVersionId = model.getAlternativeVersionId();
   }
 
+  /**
+   * Force an already-open buffer to match freshly read content + language,
+   * discarding any local edits. Used only for explicit user-initiated reload
+   * (e.g. the "File changed elsewhere — reload latest" conflict action) —
+   * the caller has already decided to discard unsaved edits, so unlike
+   * `applyExternalContent`'s callers this does not gate on dirty state.
+   */
+  reloadContent(uri: string, content: string, language: string) {
+    const entry = this.entries.get(uri);
+    if (!entry || entry.model.isDisposed()) return;
+    monaco.editor.setModelLanguage(entry.model, language);
+    this.applyExternalContent(uri, content);
+  }
+
   /** Mark the buffer clean as of the given alternative version id. */
   markSaved(uri: string, altVersionId: number) {
     const entry = this.entries.get(uri);

package/corpus/templates/design/app/components/design/code-workbench/search/SearchView.tsx

@@ -79,6 +79,21 @@ export function SearchView({ searchSeed }: SearchViewProps) {
   const [replaceAllFailures, setReplaceAllFailures] = useState(0);
   const debounceRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const abortRef = useRef<AbortController | null>(null);
+  // `providers` is recreated with a new array/object identity on every
+  // unrelated design poll tick (it flows through the design's SWR-polled
+  // `files` query, which has no structural-sharing guard), even when the
+  // actual set of workspace sources hasn't changed. Depending on `providers`
+  // directly would re-run the search effect on every poll tick, silently
+  // resetting `dismissed` (bringing back results the user just dismissed)
+  // and `replaceAllFailures`. Keep the latest providers in a ref for the
+  // debounced search to read, and key the effect off a stable signature of
+  // provider identities instead so it only re-runs when the source set
+  // actually changes.
+  const providersRef = useRef(providers);
+  providersRef.current = providers;
+  const providersSignature = providers
+    .map((provider) => provider.key)
+    .join(",");
 
   useEffect(() => {
     if (searchSeed.token === 0) return;
@@ -102,7 +117,7 @@ export function SearchView({ searchSeed }: SearchViewProps) {
       setDismissed({ files: new Set(), matches: new Set() });
       setReplaceAllFailures(0);
       searchWorkspace({
-        providers,
+        providers: providersRef.current,
         query,
         matchCase,
         wholeWord,
@@ -121,7 +136,17 @@ export function SearchView({ searchSeed }: SearchViewProps) {
       if (debounceRef.current) clearTimeout(debounceRef.current);
     };
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [query, matchCase, wholeWord, regex, providers]);
+  }, [query, matchCase, wholeWord, regex, providersSignature]);
+
+  // Safety net: abort any in-flight search when the view unmounts (it
+  // normally stays mounted-but-hidden per SideBar, but can genuinely unmount
+  // when the workbench itself closes) so a late `setResults` never fires
+  // against a torn-down component.
+  useEffect(() => {
+    return () => {
+      abortRef.current?.abort();
+    };
+  }, []);
 
   const visibleFiles = useMemo<FileSearchResult[]>(() => {
     if (!results) return [];

package/corpus/templates/design/app/components/design/code-workbench/search/search-engine.ts

@@ -268,7 +268,16 @@ export function replaceMatchesInText(
     count += 1;
     if (options.regex) {
       // Support $1, $2, ... backreferences the way String.replace does.
-      const groups = matchArgs.slice(1, -2);
+      // The callback args are (match, ...captureGroups, offset, string[,
+      // namedGroups]) — `namedGroups` is only appended when the pattern has
+      // named capture groups, so it must be dropped before slicing off the
+      // trailing offset/string pair, or a `$N` beyond the real group count
+      // would silently resolve to the match offset instead of "".
+      let rest = matchArgs.slice(1);
+      if (typeof rest[rest.length - 1] === "object") {
+        rest = rest.slice(0, -1);
+      }
+      const groups = rest.slice(0, -2);
       return replacement.replace(/\$(\d+)/g, (_all, index) => {
         const groupIndex = Number(index) - 1;
         return typeof groups[groupIndex] === "string" ? groups[groupIndex] : "";

package/corpus/templates/design/app/components/design/code-workbench/store.tsx

@@ -341,6 +341,12 @@ export function WorkbenchProvider({
     if (dirtySubscribedModelsRef.current.has(entry.model)) return;
     dirtySubscribedModelsRef.current.add(entry.model);
     entry.model.onDidChangeContent(() => {
+      // Programmatic content replacement (agent edit, external reload) fires
+      // this synchronously before the model registry updates its saved
+      // version marker; treating that as a real edit would incorrectly mark
+      // the buffer dirty (and pin a preview tab) for a change the user never
+      // made. See modelRegistry.isApplyingExternalContent.
+      if (modelRegistry.isApplyingExternalContent(uri)) return;
       apiRef.current?.markDirty(uri, modelRegistry.isDirty(uri));
     });
   }, []);
@@ -369,7 +375,18 @@ export function WorkbenchProvider({
       try {
         const read = await provider.readFile(path);
         const language = read.language ?? languageForPath(path);
-        modelRegistry.ensureModel(uri, read.content, language);
+        // loadBuffer is also used by reloadBuffer to force an already-open
+        // buffer back to the latest server content (e.g. the "File changed
+        // elsewhere — reload latest" conflict action). `ensureModel` is
+        // intentionally a no-op on content when a model already exists (so
+        // the initial-open path here never clobbers a buffer someone is
+        // mid-edit on) — reloadContent is the explicit, caller-opted-in
+        // discard-local-edits path for that case.
+        if (modelRegistry.has(uri)) {
+          modelRegistry.reloadContent(uri, read.content, language);
+        } else {
+          modelRegistry.ensureModel(uri, read.content, language);
+        }
         subscribeDirtyTracking(uri);
         rememberVersionHash(uri, read.versionHash);
         const firstLoad = !loadedOnceRef.current.has(uri);
@@ -382,7 +399,7 @@ export function WorkbenchProvider({
             dirty: modelRegistry.isDirty(uri),
             conflict: false,
             saving: false,
-            readonly: read.readonly ?? false,
+            readonly: read.readonly ?? existingMeta?.readonly ?? false,
             language,
             fileId: read.fileId,
             savedVersionHash: read.versionHash,