@agent-native/core 0.201.1-nightly-20261005213104 → 0.201.1

package/dist/client/route-chunk-recovery.js

@@ -1,7 +1,6 @@
+import { CHUNK_RECOVERY_CACHE_BUSTER_PARAM, CHUNK_RECOVERY_QUERY_PARAM, CHUNK_RECOVERY_QUERY_VALUE, ROUTE_WARMUP_PRELOAD_ATTRIBUTE, STALE_CHUNK_RELOAD_AT_KEY, STALE_CHUNK_RELOAD_COOLDOWN_MS, } from "../shared/route-chunk-recovery-bootstrap.js";
 const INSTALL_KEY = "__agentNativeRouteChunkRecoveryInstalled";
 const INTENDED_NAV_MAX_AGE_MS = 15_000;
-const STALE_CHUNK_RELOAD_AT_KEY = "__agentNativeStaleChunkReloadAt";
-const STALE_CHUNK_RELOAD_COOLDOWN_MS = 10_000;
 const STALE_CHUNK_EXHAUSTED_KEY = "__agentNativeStaleChunkRecoveryExhausted";
 /**
  * Fired on `window` the first time a stale chunk could not be recovered by a
@@ -91,6 +90,50 @@ function hardNavigate(win, href) {
         win.location.href = href;
     }
 }
+function withChunkRecoveryCacheBuster(win, href, now = Date.now()) {
+    const url = new URL(href, win.location.href);
+    url.searchParams.set(CHUNK_RECOVERY_QUERY_PARAM, CHUNK_RECOVERY_QUERY_VALUE);
+    url.searchParams.set(CHUNK_RECOVERY_CACHE_BUSTER_PARAM, `${now.toString(36)}-${Math.random().toString(36).slice(2)}`);
+    return url.href;
+}
+function readRecoveryAttemptAt(win) {
+    const url = new URL(win.location.href);
+    if (url.searchParams.get(CHUNK_RECOVERY_QUERY_PARAM) !==
+        CHUNK_RECOVERY_QUERY_VALUE) {
+        return 0;
+    }
+    const timestamp = url.searchParams.get(CHUNK_RECOVERY_CACHE_BUSTER_PARAM)?.split("-", 1)[0] ??
+        "";
+    if (!/^[0-9a-z]+$/i.test(timestamp))
+        return 0;
+    const parsed = Number.parseInt(timestamp, 36);
+    return Number.isSafeInteger(parsed) && parsed <= Date.now() ? parsed : 0;
+}
+function clearChunkRecoveryCacheBuster(win) {
+    const url = new URL(win.location.href);
+    if (url.searchParams.get(CHUNK_RECOVERY_QUERY_PARAM) !==
+        CHUNK_RECOVERY_QUERY_VALUE) {
+        return;
+    }
+    // Keep the fixed marker as a cooldown when session storage is unavailable.
+    const recoveryStartedAt = readRecoveryAttemptAt(win);
+    if (markStaleChunkReload(win, recoveryStartedAt || Date.now()) !== true) {
+        return;
+    }
+    url.searchParams.delete(CHUNK_RECOVERY_QUERY_PARAM);
+    url.searchParams.delete(CHUNK_RECOVERY_CACHE_BUSTER_PARAM);
+    win.history.replaceState(win.history.state, "", `${url.pathname}${url.search}${url.hash}`);
+}
+function isModuleAssetLoadFailure(event) {
+    const target = event.target;
+    const tagName = target?.tagName?.toUpperCase();
+    if (tagName === "LINK" && target) {
+        if (target.hasAttribute?.(ROUTE_WARMUP_PRELOAD_ATTRIBUTE))
+            return false;
+        return /(?:^|\s)modulepreload(?:\s|$)/i.test(target.getAttribute?.("rel") ?? target.rel ?? "");
+    }
+    return tagName === "SCRIPT" && target?.type?.toLowerCase() === "module";
+}
 function isAgentNativeDesktop(win) {
     return /AgentNativeDesktop/i.test(win.navigator?.userAgent || "");
 }
@@ -121,22 +164,33 @@ function isViteOptimizerFailureMessage(message) {
         message.includes("/@fs/"));
 }
 function readStaleChunkReloadAt(win) {
+    const mem = win[STALE_CHUNK_RELOAD_AT_KEY];
+    const fallback = Math.max(typeof mem === "number" && Number.isFinite(mem) ? mem : 0, readRecoveryAttemptAt(win));
     try {
         const raw = win.sessionStorage?.getItem(STALE_CHUNK_RELOAD_AT_KEY);
         const parsed = raw == null ? NaN : Number(raw);
         if (Number.isFinite(parsed))
-            return parsed;
+            return Math.max(fallback, parsed);
     }
-    catch { }
-    const mem = win[STALE_CHUNK_RELOAD_AT_KEY];
-    return typeof mem === "number" ? mem : 0;
+    catch {
+        return fallback;
+    }
+    return fallback;
 }
 function markStaleChunkReload(win, now) {
-    win[STALE_CHUNK_RELOAD_AT_KEY] = now;
+    const winState = win;
+    winState[STALE_CHUNK_RELOAD_AT_KEY] = now;
     try {
-        win.sessionStorage?.setItem(STALE_CHUNK_RELOAD_AT_KEY, String(now));
+        const storage = win
+            .sessionStorage;
+        if (!storage)
+            return "unavailable";
+        storage.setItem(STALE_CHUNK_RELOAD_AT_KEY, String(now));
+        return true;
+    }
+    catch {
+        return "unavailable";
     }
-    catch { }
 }
 /** The recorded exhaustion for this page session, if recovery ever gave up. */
 export function readStaleChunkRecoveryExhausted(win = typeof window === "undefined" ? undefined : window) {
@@ -172,7 +226,9 @@ export function reloadForStaleChunk(win = typeof window === "undefined" ? undefi
         return false;
     }
     markStaleChunkReload(win, now);
-    hardNavigate(win, win.location.href);
+    hardNavigate(win, hasViteDevRecovery(win) === true
+        ? win.location.href
+        : withChunkRecoveryCacheBuster(win, win.location.href, now));
     return true;
 }
 export function recoverFromStaleChunkError(error, win = typeof window === "undefined" ? undefined : window) {
@@ -202,7 +258,9 @@ function recoverToIntendedNavigation(win, state) {
         win.history.replaceState(win.history.state, "", recoveryTarget);
     }
     catch { }
-    hardNavigate(win, recoveryTarget);
+    hardNavigate(win, hasViteDevRecovery(win) === true
+        ? recoveryTarget
+        : withChunkRecoveryCacheBuster(win, recoveryTarget));
     return true;
 }
 function recoverFromDynamicImportFailure(win, state, message) {
@@ -275,12 +333,18 @@ export function installRouteChunkRecovery(win = typeof window === "undefined" ?
     if (installedTarget[INSTALL_KEY])
         return;
     installedTarget[INSTALL_KEY] = true;
+    clearChunkRecoveryCacheBuster(win);
     const state = createRouteChunkRecoveryState();
     win.document.addEventListener("click", (event) => {
         const href = intendedHrefFromClick(win, event);
         if (href)
             rememberIntendedNavigation(state, href);
     }, true);
+    win.document.addEventListener("error", (event) => {
+        if (isModuleAssetLoadFailure(event) && hasViteDevRecovery(win) !== true) {
+            reloadForStaleChunk(win);
+        }
+    }, true);
     patchHistoryMethod(win, state, "pushState");
     patchHistoryMethod(win, state, "replaceState");
     patchReload(win, state);

package/dist/client/route-warmup.d.ts

@@ -40,6 +40,7 @@ declare function getManifestRouteTree(manifest: ReactRouterManifest): WarmupRout
 export declare function isClientRouteUrl(url: URL): boolean;
 declare function hasWarmableRouteAssets(): boolean;
 declare function routeAssetUrlsForHref(href: string): string[];
+declare function warmRouteAssetsForHref(href: string): void;
 declare function renderWarmupLinksForSelector(selector: string): HTMLAnchorElement[];
 declare function resetRouteWarmupCachesForTests(): void;
 export declare function AgentNativeRouteWarmup({ config, }: AgentNativeRouteWarmupProps): null;
@@ -54,5 +55,6 @@ export declare const __routeWarmupInternalsForTests: {
     renderWarmupLinksForSelector: typeof renderWarmupLinksForSelector;
     routeAssetUrlsForHref: typeof routeAssetUrlsForHref;
     resetRouteWarmupCachesForTests: typeof resetRouteWarmupCachesForTests;
+    warmRouteAssetsForHref: typeof warmRouteAssetsForHref;
 };
 export {};

package/dist/client/route-warmup.js

@@ -1,5 +1,6 @@
 import { useEffect } from "react";
 import { matchRoutes } from "react-router";
+import { ROUTE_WARMUP_PRELOAD_ATTRIBUTE } from "../shared/route-chunk-recovery-bootstrap.js";
 import { mergeAgentNativeRouteWarmupConfig, } from "../shared/route-warmup-config.js";
 import { isServerRoutePath } from "./api-path.js";
 const PREFETCH_ATTR = "data-an-prefetch";
@@ -300,6 +301,7 @@ function warmRouteAssetsForHref(href) {
         const link = document.createElement("link");
         link.rel = "modulepreload";
         link.href = assetUrl;
+        link.setAttribute(ROUTE_WARMUP_PRELOAD_ATTRIBUTE, "true");
         document.head.appendChild(link);
     }
 }
@@ -556,4 +558,5 @@ export const __routeWarmupInternalsForTests = {
     renderWarmupLinksForSelector,
     routeAssetUrlsForHref,
     resetRouteWarmupCachesForTests,
+    warmRouteAssetsForHref,
 };

package/dist/client/vite-dev-recovery-script.js

@@ -1,4 +1,5 @@
 import { EMBED_MODE_QUERY_PARAM, EMBED_TOKEN_QUERY_PARAM, } from "../shared/embed-auth.js";
+import { ROUTE_WARMUP_PRELOAD_ATTRIBUTE } from "../shared/route-chunk-recovery-bootstrap.js";
 export function getViteDevRecoveryScript() {
     const embedModeParam = JSON.stringify(EMBED_MODE_QUERY_PARAM);
     const embedTokenParam = JSON.stringify(EMBED_TOKEN_QUERY_PARAM);
@@ -15,6 +16,8 @@ export function getViteDevRecoveryScript() {
   window[INSTALL_KEY] = true;
 
   var RELOAD_KEY = "__an_optimize_reload";
+  var RELOAD_HISTORY_PARAM = "__an_vite_dev_recovery";
+  var routeWarmupAttribute = ${JSON.stringify(ROUTE_WARMUP_PRELOAD_ATTRIBUTE)};
   var MAX_RELOADS = 3;
   var MIN_RELOAD_INTERVAL_MS = 2000;
   var RESET_AFTER_MS = 8000;
@@ -26,24 +29,70 @@ export function getViteDevRecoveryScript() {
   // in a short window, stop and show a manual-refresh message instead of
   // looping forever.
   function readReloadHistory() {
+    var cutoff = Date.now() - 30000;
+    var history = [];
     try {
       var raw = sessionStorage.getItem(RELOAD_KEY);
-      if (!raw) return [];
-      var arr = JSON.parse(raw);
-      var cutoff = Date.now() - 30000;
-      return Array.isArray(arr) ? arr.filter(function(t) { return t > cutoff; }) : [];
-    } catch (e) { return []; }
+      var arr = raw ? JSON.parse(raw) : [];
+      if (Array.isArray(arr)) {
+        history = arr.filter(function(t) {
+          return typeof t === "number" && Number.isFinite(t) && t > cutoff;
+        });
+      }
+    } catch (e) {
+      // coercion-ok: blocked or corrupt storage falls back to the URL history marker.
+    }
+    var params = new URLSearchParams(window.location.search || "");
+    var encoded = params.get(RELOAD_HISTORY_PARAM);
+    if (encoded) {
+      encoded.split(".").forEach(function(value) {
+        var timestamp = Number.parseInt(value, 36);
+        if (Number.isSafeInteger(timestamp) && timestamp > cutoff) {
+          history.push(timestamp);
+        }
+      });
+    }
+    return history.filter(function(timestamp, index, values) {
+      return values.indexOf(timestamp) === index;
+    }).sort(function(a, b) { return a - b; });
   }
-  function recordReload() {
+  function writeReloadHistory(history) {
+    var savedInSession = false;
     try {
-      var history = readReloadHistory();
-      history.push(Date.now());
       sessionStorage.setItem(RELOAD_KEY, JSON.stringify(history));
-    } catch (e) {}
+      savedInSession = true;
+    } catch (e) {
+      // coercion-ok: blocked storage falls back to the URL history marker.
+    }
+    try {
+      var url = new URL(window.location.href);
+      if (history.length) {
+        url.searchParams.set(RELOAD_HISTORY_PARAM, history.map(function(timestamp) {
+          return timestamp.toString(36);
+        }).join("."));
+      } else {
+        url.searchParams.delete(RELOAD_HISTORY_PARAM);
+      }
+      window.history.replaceState(
+        window.history.state,
+        "",
+        url.pathname + url.search + url.hash,
+      );
+      return true;
+    } catch (error) {
+      console.warn("[agent-native] Could not persist Vite recovery history.", error);
+      return savedInSession;
+    }
+  }
+  function recordReload() {
+    var history = readReloadHistory();
+    history.push(Date.now());
+    return writeReloadHistory(history);
   }
   // Reset the counter after a stable period (page didn't fail again).
   setTimeout(function() {
     try { sessionStorage.removeItem(RELOAD_KEY); } catch (e) {}
+    writeReloadHistory([]);
   }, RESET_AFTER_MS);
 
   function showOverlay(title, subtitle) {
@@ -85,7 +134,13 @@ export function getViteDevRecoveryScript() {
       return;
     }
     console.log("[agent-native] Vite re-bundled deps (" + reason + "), reloading\\u2026");
-    recordReload();
+    if (!recordReload()) {
+      showOverlay(
+        "Dev server out of sync",
+        "Auto-reload could not track attempts. Refresh the page manually.",
+      );
+      return;
+    }
     // First reload is silent. One refresh almost always fixes it and the
     // overlay flash is more disruptive than the reload itself. Only show
     // the overlay starting on the second attempt, when something is clearly
@@ -144,18 +199,31 @@ export function getViteDevRecoveryScript() {
 
   function looksLikeViteDep(url) {
     if (!url) return false;
-    // Only treat same-origin URLs as Vite deps. Do not reload the page
-    // because some third-party CDN script 404'd.
+    // Generic resource errors are ambiguous for app route modules; only Vite's
+    // transformed module URLs are safe evidence of an optimizer failure.
     try {
       var u = new URL(url, window.location.href);
       if (u.origin !== window.location.origin) return false;
     } catch (e) { return false; }
     return url.indexOf("/node_modules/.vite/deps/") !== -1
         || url.indexOf("/@fs/") !== -1
-        || url.indexOf("/@id/") !== -1
-        || url.indexOf("?v=") !== -1
-        || url.indexOf("?import") !== -1
-        || /\\.(m?js|ts|tsx|jsx)(\\?|$)/.test(url);
+        || url.indexOf("/@id/") !== -1;
+  }
+
+  function looksLikeLocalViteModule(url, target) {
+    if (!url || !target) return false;
+    var hostname = window.location.hostname;
+    var localDevHost = hostname === "localhost"
+        || hostname.endsWith(".localhost")
+        || /^127(?:\\.\\d{1,3}){3}$/.test(hostname)
+        || hostname === "::1"
+        || hostname === "[::1]";
+    if (!localDevHost) return false;
+    if (url.indexOf(window.location.origin + "/") !== 0) return false;
+    if (target.tagName === "SCRIPT") return String(target.type || "").toLowerCase() === "module";
+    return target.tagName === "LINK"
+        && !(target.hasAttribute && target.hasAttribute(routeWarmupAttribute))
+        && /(?:^|\\s)modulepreload(?:\\s|$)/i.test(target.rel || "");
   }
 
   // 1) <script type="module"> / <link> 504. These fire on the element, not
@@ -172,7 +240,7 @@ export function getViteDevRecoveryScript() {
     var tag = t.tagName;
     if (tag !== "SCRIPT" && tag !== "LINK") return;
     var url = t.src || t.href || "";
-    if (looksLikeViteDep(url)) {
+    if (looksLikeViteDep(url) || looksLikeLocalViteModule(url, t)) {
       var name = url.split("/").pop();
       scheduleReload("script 504: " + name);
     }

package/dist/collab/awareness.d.ts

@@ -38,19 +38,19 @@ export declare const postAwareness: import("h3").EventHandlerWithFetch<import("h
     error: string;
     states?: undefined;
 } | {
+    error?: undefined;
     states: {
         clientId: number;
         state: string;
     }[];
-    error?: undefined;
 }>>;
 export declare const getActiveUsers: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
     users?: undefined;
 } | {
+    error?: undefined;
     users: {
         clientId: number;
         lastSeen: number;
     }[];
-    error?: undefined;
 }>>;

package/dist/collab/struct-routes.d.ts

@@ -1,6 +1,6 @@
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/deploy/build.js

@@ -1613,7 +1613,9 @@ function applyDefaultSsrCacheHeader(headers, status, pathname) {
     headers.set(name, value);
   }
   const netlifyVary = varyByQuery
-    ? SSR_CACHE_KEY_HEADERS["netlify-vary"] ? "query" : undefined
+    ? SSR_CACHE_KEY_HEADERS["netlify-vary"]
+      ? "query"
+      : undefined
     : SSR_CACHE_KEY_HEADERS["netlify-vary"];
   if (netlifyVary) headers.set("netlify-vary", netlifyVary);
   else headers.delete("netlify-vary");

package/dist/feature-flags/a2a-action-route.js

@@ -34,9 +34,8 @@ export function createFeatureFlagA2AActionRouteAuth(actionName) {
             if (!claims || !claims.scope.includes(FLAG_ACTION_SCOPES[actionName])) {
                 throw new Error("Invalid feature flag delegation");
             }
-            const { resolveOrgByDomain } = await import("../org/context.js");
-            const localOrg = await resolveOrgByDomain(claims.orgDomain);
-            if (!localOrg && !isFeatureFlagAdminEmail(claims.email)) {
+            const orgId = claims.orgId?.trim() || null;
+            if (!orgId && !isFeatureFlagAdminEmail(claims.email)) {
                 throw new Error("Invalid feature flag delegation");
             }
             if (actionName === "set-feature-flag" &&
@@ -45,7 +44,7 @@ export function createFeatureFlagA2AActionRouteAuth(actionName) {
             }
             return {
                 owner: claims.email,
-                orgId: localOrg?.orgId ?? null,
+                orgId,
                 anonymous: false,
                 delegationJti: claims.jti,
                 delegationIssuer: claims.issuer,

package/dist/jobs/actions/manage-recurring-job.d.ts

@@ -11,9 +11,9 @@ declare const _default: import("../../action.js").ActionDefinition<{
     enabled?: undefined;
     nextRun?: undefined;
 } | {
-    deleted?: undefined;
     name: string;
     enabled: boolean;
     nextRun: string;
+    deleted?: undefined;
 }>;
 export default _default;

package/dist/mcp/build-server.d.ts

@@ -103,6 +103,10 @@ export declare function conciseToolResultText(name: string, result: unknown, opt
 export declare function createMCPServerForRequest(config: MCPConfig, identity: MCPCallerIdentity | undefined, requestMeta?: MCPRequestMeta): Promise<import("@modelcontextprotocol/server").Server>;
 export declare function getAccessTokens(): string[];
 export declare function getBearerToken(authHeader: string | undefined): string | undefined;
+export declare class McpIdentityVerificationUnavailableError extends Error {
+    readonly cause: unknown;
+    constructor(cause: unknown);
+}
 export type VerifyAuthResult = {
     authed: boolean;
     identity?: MCPCallerIdentity;