@agent-native/core 0.182.1 → 0.182.2-nightly-20260917225811

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 9518
+- template files: 9529

package/corpus/templates/clips/app/root.tsx

@@ -212,6 +212,16 @@ function ClipsExtensionAuthBridge() {
     const targetExtensionId = extensionId;
 
     let cancelled = false;
+    let removeBridgeListener: (() => void) | null = null;
+
+    const completeExtensionSignIn = () => {
+      if (cancelled) return;
+      const cleaned = new URL(window.location.href);
+      cleaned.searchParams.delete("clipsExtensionAuth");
+      cleaned.searchParams.delete("clipsExtensionId");
+      window.history.replaceState(window.history.state, "", cleaned);
+      setShowAuthSuccess(true);
+    };
 
     async function sendSessionToExtension() {
       const runtime = (
@@ -219,7 +229,6 @@ function ClipsExtensionAuthBridge() {
           chrome?: { runtime?: ExternalChromeRuntime };
         }
       ).chrome?.runtime;
-      if (!runtime?.sendMessage) return;
 
       const response = await fetch(appPath("/_agent-native/auth/session"), {
         credentials: "include",
@@ -233,21 +242,60 @@ function ClipsExtensionAuthBridge() {
         return;
       }
 
+      const message = {
+        source: "clips-auth-bridge",
+        kind: "session",
+        token: session.token,
+        email: session.email,
+        clipsBaseUrl: window.location.origin,
+      } as const;
+      const sendViaPageBridge = () => {
+        const onMessage = (event: MessageEvent) => {
+          if (
+            event.source !== window ||
+            event.origin !== window.location.origin
+          ) {
+            return;
+          }
+          const data = event.data as
+            | { source?: unknown; kind?: unknown; ok?: unknown }
+            | undefined;
+          if (
+            data?.source !== "clips-auth-bridge" ||
+            data.kind !== "session-result"
+          ) {
+            return;
+          }
+          removeBridgeListener?.();
+          removeBridgeListener = null;
+          if (data.ok === true) completeExtensionSignIn();
+        };
+        removeBridgeListener = () =>
+          window.removeEventListener("message", onMessage);
+        window.addEventListener("message", onMessage);
+        window.postMessage(message, window.location.origin);
+      };
+
+      if (!runtime?.sendMessage) {
+        sendViaPageBridge();
+        return;
+      }
+
       runtime.sendMessage(
         targetExtensionId,
         {
           type: "CLIPS_AUTH_SESSION",
-          token: session.token,
-          email: session.email,
-          clipsBaseUrl: window.location.origin,
+          token: message.token,
+          email: message.email,
+          clipsBaseUrl: message.clipsBaseUrl,
         },
         (extensionResponse) => {
-          if (cancelled || runtime.lastError || !extensionResponse?.ok) return;
-          const cleaned = new URL(window.location.href);
-          cleaned.searchParams.delete("clipsExtensionAuth");
-          cleaned.searchParams.delete("clipsExtensionId");
-          window.history.replaceState(window.history.state, "", cleaned);
-          setShowAuthSuccess(true);
+          if (cancelled) return;
+          if (!runtime.lastError && extensionResponse?.ok) {
+            completeExtensionSignIn();
+            return;
+          }
+          sendViaPageBridge();
         },
       );
     }
@@ -255,6 +303,7 @@ function ClipsExtensionAuthBridge() {
     void sendSessionToExtension();
     return () => {
       cancelled = true;
+      removeBridgeListener?.();
     };
   }, [location.search]);
 

package/corpus/templates/clips/changelog/2026-09-17-desktop-popover-closes-when-clicking-away.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-09-17
+---
+
+The desktop popover now closes when you click away from it.

package/corpus/templates/clips/changelog/2026-09-17-self-hosted-extension-sign-in.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-09-17
+---
+
+Self-hosted Clips extensions now finish sign-in reliably.

package/corpus/templates/clips/chrome-extension/src/background.ts

@@ -77,6 +77,13 @@ type PopupStartMessage = {
   settings?: Partial<ExtensionSettings>;
 };
 
+type AuthSessionMessage = {
+  type: "CLIPS_AUTH_SESSION";
+  token?: string;
+  email?: string;
+  clipsBaseUrl?: string;
+};
+
 type ExternalMessage =
   | {
       type: "CLIPS_CAPTURE_START";
@@ -93,12 +100,7 @@ type ExternalMessage =
       type: "CLIPS_CAPTURE_CANCEL";
       sessionId?: string;
     }
-  | {
-      type: "CLIPS_AUTH_SESSION";
-      token?: string;
-      email?: string;
-      clipsBaseUrl?: string;
-    };
+  | AuthSessionMessage;
 
 type ChromeTab = {
   id?: number;
@@ -2237,6 +2239,35 @@ async function handlePopupSignIn(message: {
   return { ok: true };
 }
 
+async function handleAuthSession(
+  message: AuthSessionMessage,
+  senderUrl?: string,
+) {
+  const settings = await readSettings();
+  const clipsBaseUrl = normalizeBaseUrl(
+    message.clipsBaseUrl ?? settings.clipsBaseUrl,
+  );
+  const senderOrigin = originOf(senderUrl);
+  if (
+    !senderOrigin ||
+    senderOrigin !== originOf(clipsBaseUrl) ||
+    senderOrigin !== originOf(settings.clipsBaseUrl)
+  ) {
+    return { ok: false, error: "Auth message came from the wrong origin." };
+  }
+  if (typeof message.token !== "string" || !message.token.trim()) {
+    return { ok: false, error: "Missing auth token." };
+  }
+  await storageSet({ ...settings, clipsBaseUrl });
+  await saveAuthSession({
+    token: message.token,
+    email: typeof message.email === "string" ? message.email : undefined,
+    clipsBaseUrl,
+    savedAt: nowIso(),
+  });
+  return { ok: true };
+}
+
 function summarize(snapshot: {
   endedAt: string;
   consoleLogs: ConsoleLog[];
@@ -2734,25 +2765,7 @@ async function handleExternalMessage(
   }
 
   if (message.type === "CLIPS_AUTH_SESSION") {
-    const settings = await readSettings();
-    const clipsBaseUrl = normalizeBaseUrl(
-      message.clipsBaseUrl ?? settings.clipsBaseUrl,
-    );
-    const senderOrigin = originOf(sender?.url);
-    if (!senderOrigin || senderOrigin !== originOf(clipsBaseUrl)) {
-      return { ok: false, error: "Auth message came from the wrong origin." };
-    }
-    if (typeof message.token !== "string" || !message.token.trim()) {
-      return { ok: false, error: "Missing auth token." };
-    }
-    await storageSet({ ...settings, clipsBaseUrl });
-    await saveAuthSession({
-      token: message.token,
-      email: typeof message.email === "string" ? message.email : undefined,
-      clipsBaseUrl,
-      savedAt: nowIso(),
-    });
-    return { ok: true };
+    return handleAuthSession(message, sender?.url);
   }
 
   if (message.type === "CLIPS_CAPTURE_START") {
@@ -2858,6 +2871,13 @@ async function dispatchRuntimeMessage(
 ): Promise<unknown> {
   const type = (message as { type?: unknown }).type;
 
+  if (type === "CLIPS_AUTH_SESSION") {
+    return handleAuthSession(
+      message as AuthSessionMessage,
+      sender?.tab?.url ?? sender?.url,
+    );
+  }
+
   if (type === "CLIPS_DIAGNOSTIC_INTERACTION") {
     const tabId = sender?.tab?.id;
     const sessionId =

package/corpus/templates/clips/chrome-extension/src/content-script.ts

@@ -141,6 +141,49 @@
     }
     sendDiagnosticNavigation(data.url);
   });
+
+  window.addEventListener("message", (event) => {
+    if (event.source !== window || event.origin !== window.location.origin) {
+      return;
+    }
+    const data = event.data as
+      | {
+          source?: unknown;
+          kind?: unknown;
+          token?: unknown;
+          email?: unknown;
+          clipsBaseUrl?: unknown;
+        }
+      | undefined;
+    if (
+      data?.source !== "clips-auth-bridge" ||
+      data.kind !== "session" ||
+      typeof data.token !== "string" ||
+      typeof data.clipsBaseUrl !== "string"
+    ) {
+      return;
+    }
+    chrome.runtime.sendMessage(
+      {
+        type: "CLIPS_AUTH_SESSION",
+        token: data.token,
+        ...(typeof data.email === "string" ? { email: data.email } : {}),
+        clipsBaseUrl: data.clipsBaseUrl,
+      },
+      (response?: { ok?: boolean; error?: string }) => {
+        void chrome.runtime.lastError;
+        window.postMessage(
+          {
+            source: "clips-auth-bridge",
+            kind: "session-result",
+            ok: response?.ok === true,
+            ...(response?.error ? { error: response.error } : {}),
+          },
+          window.location.origin,
+        );
+      },
+    );
+  });
   window.postMessage(
     { source: "clips-diagnostic-history", kind: "request-token" },
     "*",

package/corpus/templates/clips/desktop/src-tauri/src/lib.rs

@@ -43,6 +43,8 @@ mod util;
 mod whisper_model;
 mod whisper_speech;
 
+use std::time::Duration;
+
 use tauri::{Emitter, Manager};
 
 use clips::{position_popover, toggle_popover};
@@ -62,6 +64,12 @@ use util::{
 // should replace with their real icon.
 pub(crate) const TRAY_PNG: &[u8] = include_bytes!("../icons/tray.png");
 
+const POPOVER_BLUR_GUARD: Duration = Duration::from_millis(1500);
+
+fn popover_blur_delay(elapsed: Duration) -> Option<Duration> {
+    (elapsed < POPOVER_BLUR_GUARD).then(|| POPOVER_BLUR_GUARD - elapsed)
+}
+
 fn present_popover(app: &tauri::AppHandle) {
     if let Some(window) = app.get_webview_window("popover") {
         set_capture_excluded(&window);
@@ -480,7 +488,7 @@ pub fn run() {
             }
 
             // Hide the popover on blur so it feels like a real menu-bar popover.
-            // The 250ms guard is the important bit — during the tray-click
+            // The 1.5s guard is the important bit — during the tray-click
             // itself macOS briefly steals focus from the popover, which would
             // fire Focused(false) and hide the window we literally just showed.
             if let Some(window) = app.get_webview_window("popover") {
@@ -511,11 +519,37 @@ pub fn run() {
                         let shown_at = app_handle
                             .try_state::<PopoverShownAt>()
                             .and_then(|s| s.0.lock().ok().and_then(|g| *g));
-                        let elapsed_ms = shown_at
-                            .map(|t| t.elapsed().as_millis())
-                            .unwrap_or(u128::MAX);
-                        dlog!("[clips-tray] popover blur, elapsed_ms={}", elapsed_ms);
-                        if elapsed_ms >= 1500 {
+                        let elapsed = shown_at.map(|t| t.elapsed()).unwrap_or(Duration::MAX);
+                        dlog!(
+                            "[clips-tray] popover blur, elapsed_ms={}",
+                            elapsed.as_millis()
+                        );
+                        if let Some(delay) = popover_blur_delay(elapsed) {
+                            let Some(shown_at) = shown_at else {
+                                return;
+                            };
+                            let delayed_handle = handle.clone();
+                            let delayed_app_handle = app_handle.clone();
+                            tauri::async_runtime::spawn(async move {
+                                tokio::time::sleep(delay).await;
+                                let still_current = delayed_app_handle
+                                    .try_state::<PopoverShownAt>()
+                                    .and_then(|state| {
+                                        state.0.lock().ok().map(|guard| *guard == Some(shown_at))
+                                    })
+                                    .unwrap_or(false);
+                                if !still_current
+                                    || is_recording_active(&delayed_app_handle)
+                                    || !config::auto_hide_popover_enabled(&delayed_app_handle)
+                                    || delayed_handle.is_focused().unwrap_or(true)
+                                {
+                                    return;
+                                }
+                                let _ = delayed_handle.hide();
+                                clips::close_bubble_if_idle(&delayed_app_handle);
+                                let _ = delayed_app_handle.emit("clips:popover-visible", false);
+                            });
+                        } else {
                             let _ = handle.hide();
                             clips::close_bubble_if_idle(&app_handle);
                             let _ = app_handle.emit("clips:popover-visible", false);
@@ -623,3 +657,18 @@ pub fn run() {
             }
         });
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{popover_blur_delay, POPOVER_BLUR_GUARD};
+    use std::time::Duration;
+
+    #[test]
+    fn retries_blur_until_guard_expires() {
+        assert_eq!(
+            popover_blur_delay(Duration::from_millis(400)),
+            Some(Duration::from_millis(1100))
+        );
+        assert_eq!(popover_blur_delay(POPOVER_BLUR_GUARD), None);
+    }
+}

package/corpus/templates/design/.generated/bridge/editor-chrome.generated.ts

@@ -1447,19 +1447,24 @@ export const editorChromeBridgeScript: string = `"use strict";
       "__reactInternalFiber$"
     ];
     function reactFiberOf(el) {
-      var keys = Object.keys(el);
+      var keys = Object.getOwnPropertyNames(el);
+      var fallback = null;
       for (var i = 0; i < keys.length; i += 1) {
         for (var j = 0; j < REACT_FIBER_KEY_PREFIXES.length; j += 1) {
           if (keys[i].indexOf(REACT_FIBER_KEY_PREFIXES[j]) === 0) {
-            return el[keys[i]];
+            var fiber = el[keys[i]];
+            if (!fallback) fallback = fiber;
+            if (fiber && fiber._debugSource) return fiber;
           }
         }
       }
-      return null;
+      return fallback;
     }
     function reactDebugProvenance(el) {
       var cached = reactDebugProvenanceCache?.get(el);
-      if (cached !== void 0) return cached;
+      if (cached !== void 0 && (cached.method === "debug-source" || cached.method === "debug-stack-remapped")) {
+        return cached;
+      }
       var leafFiber = reactFiberOf(el);
       if (!leafFiber) return { unavailableReason: "not-framework" };
       var elementLocation = fiberDebugLocation(leafFiber);
@@ -1935,10 +1940,8 @@ export const editorChromeBridgeScript: string = `"use strict";
           cloneNode.setAttribute("data-an-runtime-layer-remove", "true");
           continue;
         }
-        cloneNode.setAttribute(
-          "data-agent-native-node-id",
-          ensureRuntimeLayerNodeId(sourceNode)
-        );
+        var runtimeNodeId = ensureRuntimeLayerNodeId(sourceNode);
+        cloneNode.setAttribute("data-agent-native-node-id", runtimeNodeId);
         inlineSnapshotComputedStyle(sourceNode, cloneNode);
         var provenance = elementDebugProvenance(sourceNode);
         if (provenance.sourceFile) {
@@ -1959,6 +1962,25 @@ export const editorChromeBridgeScript: string = `"use strict";
           if (provenance.component) {
             cloneNode.setAttribute("data-component-name", provenance.component);
           }
+          var runtimeComponent = runtimeComponentIdentityForElement(
+            sourceNode,
+            provenance,
+            runtimeNodeId
+          );
+          if (runtimeComponent) {
+            cloneNode.setAttribute(
+              "data-agent-native-runtime-component-id",
+              runtimeComponent.componentId
+            );
+            cloneNode.setAttribute(
+              "data-agent-native-runtime-instance-id",
+              runtimeComponent.instanceId
+            );
+            cloneNode.setAttribute(
+              "data-agent-native-runtime-component-capability",
+              runtimeComponent.writeCapability
+            );
+          }
           if (provenance.ownerSourceFile) {
             cloneNode.setAttribute(
               "data-source-owner-file",
@@ -2505,6 +2527,57 @@ export const editorChromeBridgeScript: string = `"use strict";
       if (!elementLooksLikeComponent(el) || !el || !el.getAttribute) return "";
       return layerNameForElement(el);
     }
+    function runtimeComponentPropsForElement(el) {
+      var props = [];
+      if (!el.attributes) return props;
+      for (var index = 0; index < el.attributes.length; index += 1) {
+        var attribute = el.attributes[index];
+        if (!attribute || attribute.name.indexOf("data-agent-native-prop-") !== 0)
+          continue;
+        var rawName = attribute.name.slice("data-agent-native-prop-".length);
+        if (!rawName) continue;
+        props.push({
+          name: rawName.replace(/-([a-z])/g, function(_match, letter) {
+            return String(letter).toUpperCase();
+          }),
+          value: attribute.value
+        });
+      }
+      return props;
+    }
+    function runtimeComponentIdentityForElement(el, provenance, instanceId) {
+      var name = provenance.component && provenance.component.trim();
+      var definitionSourceFile = provenance.sourceFile && provenance.sourceFile.trim();
+      var invocationSourceFile = provenance.ownerSourceFile && provenance.ownerSourceFile.trim();
+      var invocationLine = provenance.ownerLine;
+      var invocationColumn = provenance.ownerColumn;
+      var invocationMethod = provenance.ownerMethod;
+      if (!name || !definitionSourceFile || !provenance.framework || provenance.framework === "html" || !instanceId) {
+        return void 0;
+      }
+      var boundary = [
+        provenance.framework,
+        definitionSourceFile,
+        provenance.line || "",
+        provenance.column || "",
+        name
+      ].join("|");
+      var writable = provenance.framework === "react" && invocationSourceFile !== void 0 && invocationMethod !== void 0 && invocationMethod !== "debug-stack" && Number.isFinite(invocationLine) && Number.isFinite(invocationColumn);
+      return {
+        componentId: "runtime-component-" + runtimeLayerHash(boundary),
+        instanceId,
+        name,
+        framework: provenance.framework,
+        sourceFile: invocationSourceFile,
+        line: invocationLine,
+        column: invocationColumn,
+        method: invocationMethod,
+        ownerKey: provenance.ownerKey,
+        props: runtimeComponentPropsForElement(el),
+        writeCapability: writable ? "authored-jsx-literal" : "unsupported",
+        reason: writable ? void 0 : "The runtime did not expose a verified authored component invocation location."
+      };
+    }
     function isAutoLayoutDisplay(display) {
       return display === "flex" || display === "inline-flex" || display === "grid" || display === "inline-grid";
     }
@@ -3320,6 +3393,7 @@ export const editorChromeBridgeScript: string = `"use strict";
         alignItems: parentStyles.alignItems,
         justifyContent: parentStyles.justifyContent,
         gap: parentStyles.gap,
+        gridAutoFlow: parentStyles.gridAutoFlow,
         gridTemplateColumns: parentStyles.gridTemplateColumns,
         gridTemplateRows: parentStyles.gridTemplateRows,
         position: parentStyles.position
@@ -3356,10 +3430,17 @@ export const editorChromeBridgeScript: string = `"use strict";
         });
       }
       var provenance = elementDebugProvenance(el);
+      var runtimeComponent = runtimeComponentIdentityForElement(
+        el,
+        provenance,
+        sourceId || runtimeSourceId || pendingNodeId || getSelector(el)
+      );
       var portableStyleSnapshot = collectPortableStyleSnapshot(el);
       return {
         tagName: el.tagName.toLowerCase(),
         componentName: componentName || void 0,
+        componentAnnotation: explicitComponentNameForElement(el) || void 0,
+        runtimeComponent,
         id: el.id || void 0,
         sourceId,
         runtimeSelector: runtimeSelector || void 0,
@@ -11336,8 +11417,8 @@ export const editorChromeBridgeScript: string = `"use strict";
       var gestureState = memberStates[groupEls.indexOf(gestureEl)] || memberStates[0];
       var originLeft = gestureState.originLeft;
       var originTop = gestureState.originTop;
-      var startX = e.clientX;
-      var startY = e.clientY;
+      var startX = pointerStartParam ? pointerStartParam.clientX : e.clientX;
+      var startY = pointerStartParam ? pointerStartParam.clientY : e.clientY;
       var dragEl = gestureEl;
       var gestureViewport = bridgeGestureViewport();
       var DRAG_THRESHOLD = 3;
@@ -11366,11 +11447,13 @@ export const editorChromeBridgeScript: string = `"use strict";
       bridgeMoveController.pointerDown({
         kind: "move",
         objectIds: [getSelector(gestureEl)],
-        // \`e\` is deliberately the event that actually began the legacy move
-        // lifecycle, not \`pointerStartParam\`: anchoring the controller at the
-        // pointerdown moves the element the extra threshold-crossing distance,
-        // which breaks the cross-screen drop's target resolution.
-        pointer: bridgeGesturePointer(e),
+        // Shield drags begin here after their threshold-crossing event. For an
+        // alt-drag, the clone must include the movement from the original press;
+        // plain shield drags keep their existing threshold-relative baseline so
+        // cross-screen target resolution is unchanged.
+        pointer: bridgeGesturePointer(
+          duplicatedForDrag && pointerStartParam ? { ...e, ...pointerStartParam } : e
+        ),
         viewport: gestureViewport,
         canvas: { width: gestureViewport.width, height: gestureViewport.height }
       });
@@ -11394,7 +11477,7 @@ export const editorChromeBridgeScript: string = `"use strict";
       var dragElOffsetScaleX = ancestorScale(dragEl, "x");
       var dragElOffsetScaleY = ancestorScale(dragEl, "y");
       if (!isGroupDrag) {
-        postCrossScreenDrag("start", dragEl, e, {
+        postCrossScreenDrag("start", dragEl, pointerStartParam || e, {
           duplicate: duplicatedForDrag
         });
       }
@@ -11474,7 +11557,7 @@ export const editorChromeBridgeScript: string = `"use strict";
           currentAutoLayoutTarget = null;
           hideInsertionGuide();
         } else {
-          currentAutoLayoutTarget = !duplicatedForDrag && !bridgeSpaceKeyPressed ? autoLayoutInsertionTargetForPoint(
+          currentAutoLayoutTarget = !bridgeSpaceKeyPressed ? autoLayoutInsertionTargetForPoint(
             dragEl,
             ev.clientX,
             ev.clientY,
@@ -11574,6 +11657,8 @@ export const editorChromeBridgeScript: string = `"use strict";
             positionOverlay(selectionOverlay, selectedEl);
             postElementSelect(selectedEl);
             postCrossScreenDrag("cancel");
+          } else if (!isGroupDrag) {
+            postCrossScreenDrag("cancel");
           }
           return;
         }
@@ -11601,7 +11686,7 @@ export const editorChromeBridgeScript: string = `"use strict";
           }
           return;
         }
-        if (ev && !duplicatedForDrag && !outsideOnDrop && !bridgeSpaceKeyPressed) {
+        if (ev && !outsideOnDrop && !bridgeSpaceKeyPressed) {
           var finalAutoLayoutTarget = autoLayoutInsertionTargetForPoint(
             dragEl,
             ev.clientX,
@@ -11631,7 +11716,7 @@ export const editorChromeBridgeScript: string = `"use strict";
           postVisualDuplicateChange(
             originalSelectedEl,
             dragEl,
-            null,
+            currentAutoLayoutTarget,
             duplicatedSourceNodeIdMap
           );
           postCrossScreenDrag("cancel");
@@ -14968,6 +15053,9 @@ export const editorChromeBridgeScript: string = `"use strict";
           "aria-label",
           "class",
           "data-agent-native-component",
+          "data-agent-native-runtime-component-capability",
+          "data-agent-native-runtime-component-id",
+          "data-agent-native-runtime-instance-id",
           "data-agent-native-layer-name",
           "data-layer-name",
           "layer-name",

package/corpus/templates/design/.generated/bridge/hit-test.generated.ts

@@ -326,6 +326,7 @@ export const hitTestBridgeScript: string = `"use strict";
     }
     function getOrMintPendingNodeId(el) {
       if (!el || !el.getAttribute || !el.setAttribute) return "";
+      if (el === document.body || el === document.documentElement) return "";
       if (isTemplateCloneElement(el)) return "";
       var existing = el.getAttribute("data-an-pending-node-id");
       if (existing) return existing;