@agent-native/core 0.201.1 → 0.202.0-nightly-20261006033736

package/dist/automation/index.d.ts

@@ -139,8 +139,8 @@ export declare function createAutomationCallbackHandler(runtime: AutomationRunti
     duplicate?: undefined;
     eventId?: undefined;
 } | {
+    error?: undefined;
     accepted: boolean;
     duplicate: boolean;
     eventId: string;
-    error?: undefined;
 }>;

package/dist/client/analytics/index.d.ts

@@ -1,2 +1,2 @@
-export { AGENT_NATIVE_EXCEPTION_EVENT_NAME, addErrorBreadcrumb, captureAttribution, captureClientException, captureError, captureException, captureMessage, clearAnalyticsSessionId, configureTracking, getAnalyticsAnonymousId, getAnalyticsSessionId, getFirstTouchAttribution, getSessionReplayContext, getSessionReplayUrl, isErrorCaptureInstalled, maybeStartSessionReplay, setAnalyticsSessionId, setSentryUser, setTrackingContentCaptureEnabled, setTrackingIdentity, startSessionReplay, stopSessionReplay, trackAgentChatLifecycle, trackAnonymousEvent, trackEvent, trackLifecycleEvent, trackSessionStatus, type AgentChatLifecycleEvent, type CaptureExceptionContext, type CapturedExceptionEvent, type ClientCaptureContext, type ConfigureTrackingOptions, type ErrorCaptureConfigOptions, type ExceptionBreadcrumb, type ExceptionLevel, type FirstTouchAttribution, type SessionReplayContext, type SessionReplayLinkOptions, type SessionReplayOptions, type SessionReplayStartResult, type SessionReplayUrlMatcher, type TrackingIdentityUser, } from "../analytics.js";
+export { AGENT_NATIVE_EXCEPTION_EVENT_NAME, addErrorBreadcrumb, captureAttribution, captureClientException, captureError, captureException, captureMessage, clearAnalyticsSessionId, configureTracking, getAnalyticsAnonymousId, getAnalyticsSessionId, getFirstTouchAttribution, getLastTouchAttribution, getSessionReplayContext, getSessionReplayUrl, isErrorCaptureInstalled, maybeStartSessionReplay, setAnalyticsSessionId, setSentryUser, setTrackingContentCaptureEnabled, setTrackingIdentity, startSessionReplay, stopSessionReplay, trackAgentChatLifecycle, trackAnonymousEvent, trackEvent, trackLifecycleEvent, trackSessionStatus, type AgentChatLifecycleEvent, type CaptureExceptionContext, type CapturedExceptionEvent, type ClientCaptureContext, type ConfigureTrackingOptions, type ErrorCaptureConfigOptions, type ExceptionBreadcrumb, type ExceptionLevel, type FirstTouchAttribution, type LastTouchAttribution, type SessionReplayContext, type SessionReplayLinkOptions, type SessionReplayOptions, type SessionReplayStartResult, type SessionReplayUrlMatcher, type TrackingIdentityUser, } from "../analytics.js";
 export { track } from "../track.js";

package/dist/client/analytics/index.js

@@ -1,2 +1,2 @@
-export { AGENT_NATIVE_EXCEPTION_EVENT_NAME, addErrorBreadcrumb, captureAttribution, captureClientException, captureError, captureException, captureMessage, clearAnalyticsSessionId, configureTracking, getAnalyticsAnonymousId, getAnalyticsSessionId, getFirstTouchAttribution, getSessionReplayContext, getSessionReplayUrl, isErrorCaptureInstalled, maybeStartSessionReplay, setAnalyticsSessionId, setSentryUser, setTrackingContentCaptureEnabled, setTrackingIdentity, startSessionReplay, stopSessionReplay, trackAgentChatLifecycle, trackAnonymousEvent, trackEvent, trackLifecycleEvent, trackSessionStatus, } from "../analytics.js";
+export { AGENT_NATIVE_EXCEPTION_EVENT_NAME, addErrorBreadcrumb, captureAttribution, captureClientException, captureError, captureException, captureMessage, clearAnalyticsSessionId, configureTracking, getAnalyticsAnonymousId, getAnalyticsSessionId, getFirstTouchAttribution, getLastTouchAttribution, getSessionReplayContext, getSessionReplayUrl, isErrorCaptureInstalled, maybeStartSessionReplay, setAnalyticsSessionId, setSentryUser, setTrackingContentCaptureEnabled, setTrackingIdentity, startSessionReplay, stopSessionReplay, trackAgentChatLifecycle, trackAnonymousEvent, trackEvent, trackLifecycleEvent, trackSessionStatus, } from "../analytics.js";
 export { track } from "../track.js";

package/dist/client/analytics.d.ts

@@ -86,14 +86,34 @@ export interface FirstTouchAttribution {
     landed_at?: string;
     capture_truncated?: string;
 }
+/** The latest visit that had a source; see `captureLastTouchAttribution`. */
+export interface LastTouchAttribution {
+    ref?: string;
+    via?: string;
+    utm_source?: string;
+    utm_medium?: string;
+    utm_campaign?: string;
+    utm_content?: string;
+    utm_term?: string;
+    gclid?: string;
+    msclkid?: string;
+    vector_source?: string;
+    landing_referrer?: string;
+    site_referrer?: string;
+    site_landing_path?: string;
+    landing_path?: string;
+    touched_at?: string;
+    capture_truncated?: string;
+}
 export declare function getAnalyticsIdentityKey(): string | undefined;
 export declare function getAnalyticsAnonymousId(): string | undefined;
 export declare function getAnalyticsSessionId(): string | undefined;
 export declare function getFirstTouchAttribution(): FirstTouchAttribution | null;
+export declare function getLastTouchAttribution(): LastTouchAttribution | null;
 /**
- * Store the visitor's first touch now instead of in `configureTracking()`,
- * for a page that reads it before tracking starts. It runs once per page
- * load, so tracking's own capture is then a no-op.
+ * Store the visitor's first and last touch now instead of in
+ * `configureTracking()`, for a page that reads them before tracking starts.
+ * It runs once per page load, so tracking's own capture is then a no-op.
  */
 export declare function captureAttribution(): void;
 export declare function setSentryUser(user: TrackingIdentityUser | null, orgId?: string | null): void;

package/dist/client/analytics.js

@@ -1,6 +1,7 @@
 import { recordTrackingEvent } from "../observability/tracing.js";
 import { AGENT_NATIVE_LIFECYCLE_EVENTS, canonicalTrackingEvent, legacyLifecycleEvent, normalizeTrackingDimension, withCanonicalTrackingProperties, } from "../shared/analytics-events.js";
 import { ANALYTICS_CLIENT_PLATFORM_PROPERTY, } from "../shared/analytics-platform.js";
+import { hasAttributionSource } from "../shared/attribution-source.js";
 import { resolveLaneEndpoint } from "../shared/environment-lanes.js";
 import { classifyErrorNoise, } from "../shared/error-noise.js";
 import { llmConnectionTrackingProperties, } from "../shared/llm-connection.js";
@@ -101,6 +102,72 @@ const FIRST_TOUCH_COOKIE_FIELD_PRIORITY = [
     "site_landing_path",
     "landed_at",
 ];
+const LAST_TOUCH_STORAGE_KEY = "an_last_touch";
+const LAST_TOUCH_COOKIE_NAME = "an_lt";
+// Small enough that both cookies still fit the signup handoff header.
+const LAST_TOUCH_MAX_COOKIE_BYTES = 700;
+// What a sourced visit keeps as last touch, besides its path and time.
+const LAST_TOUCH_SOURCE_FIELDS = [
+    "ref",
+    "via",
+    "utm_source",
+    "utm_medium",
+    "utm_campaign",
+    "utm_content",
+    "utm_term",
+    "gclid",
+    "msclkid",
+    "vector_source",
+    "landing_referrer",
+    "site_referrer",
+];
+// Which fields the cookie keeps first when they don't all fit.
+const LAST_TOUCH_COOKIE_FIELD_PRIORITY = [
+    "ref",
+    "gclid",
+    "msclkid",
+    "vector_source",
+    "utm_source",
+    "utm_medium",
+    "utm_campaign",
+    "via",
+    "utm_content",
+    "utm_term",
+    "landing_referrer",
+    "site_referrer",
+    "landing_path",
+    "touched_at",
+    "site_landing_path",
+];
+// The marketing site forwards its own last touch under these names when it
+// differs from the first touch it forwards as plain campaign params.
+const FORWARDED_LAST_TOUCH_FIELDS = {
+    last_ref: "ref",
+    last_via: "via",
+    last_utm_source: "utm_source",
+    last_utm_medium: "utm_medium",
+    last_utm_campaign: "utm_campaign",
+    last_utm_content: "utm_content",
+    last_utm_term: "utm_term",
+    last_gclid: "gclid",
+    last_msclkid: "msclkid",
+    last_vector_source: "vector_source",
+    last_referrer: "site_referrer",
+    last_landing_path: "site_landing_path",
+};
+// When the site's latest sourced visit happened, so an older site visit can't
+// replace a newer one the app already has.
+const FORWARDED_LAST_TOUCH_AT_PARAM = "last_at";
+const FIRST_TOUCH_COOKIE = {
+    name: FIRST_TOUCH_COOKIE_NAME,
+    maxBytes: FIRST_TOUCH_MAX_COOKIE_BYTES,
+    priority: FIRST_TOUCH_COOKIE_FIELD_PRIORITY,
+};
+const LAST_TOUCH_COOKIE = {
+    name: LAST_TOUCH_COOKIE_NAME,
+    maxBytes: LAST_TOUCH_MAX_COOKIE_BYTES,
+    priority: LAST_TOUCH_COOKIE_FIELD_PRIORITY,
+};
 let _firstTouchCaptured = false;
 function safeStorageGet(key) {
     try {
@@ -390,7 +457,7 @@ function buildFirstTouchAttribution() {
     attribution.landed_at = new Date().toISOString();
     return attribution;
 }
-function readFirstTouchCookie() {
+function readAttributionCookie(cookieName) {
     if (typeof document === "undefined")
         return null;
     try {
@@ -400,7 +467,7 @@ function readFirstTouchCookie() {
             if (eq === -1)
                 continue;
             const name = part.slice(0, eq).trim();
-            if (name === FIRST_TOUCH_COOKIE_NAME) {
+            if (name === cookieName) {
                 return part.slice(eq + 1).trim();
             }
         }
@@ -410,15 +477,16 @@ function readFirstTouchCookie() {
     }
     return null;
 }
-function firstTouchCookieAssignment(encodedValue) {
-    return (`${FIRST_TOUCH_COOKIE_NAME}=${encodedValue}; path=/; ` +
+function attributionCookieAssignment(cookieName, encodedValue) {
+    return (`${cookieName}=${encodedValue}; path=/; ` +
         `max-age=${FIRST_TOUCH_COOKIE_MAX_AGE_SECONDS}; SameSite=Lax`);
 }
-function fitFirstTouchCookieValue(value) {
+function fitAttributionCookieValue(value, spec) {
     const source = JSON.parse(value);
     const compact = {};
     let truncated = false;
-    for (const field of FIRST_TOUCH_COOKIE_FIELD_PRIORITY) {
+    const fits = (encoded) => attributionCookieAssignment(spec.name, encoded).length <= spec.maxBytes;
+    for (const field of spec.priority) {
         const rawValue = source[field];
         if (typeof rawValue !== "string" || !rawValue)
             continue;
@@ -426,9 +494,8 @@ function fitFirstTouchCookieValue(value) {
             ...compact,
             [field]: rawValue.slice(0, FIRST_TOUCH_MAX_FIELD_LENGTH),
         };
-        const encoded = encodeURIComponent(JSON.stringify(candidate));
-        if (firstTouchCookieAssignment(encoded).length <= FIRST_TOUCH_MAX_COOKIE_BYTES) {
-            Object.assign(compact, { [field]: candidate[field] });
+        if (fits(encodeURIComponent(JSON.stringify(candidate)))) {
+            compact[field] = candidate[field];
         }
         else {
             truncated = true;
@@ -437,38 +504,63 @@ function fitFirstTouchCookieValue(value) {
     if (truncated) {
         compact.capture_truncated = "1";
         // Keep the auth handoff under its 4 KB header limit after re-encoding.
-        for (const field of [...FIRST_TOUCH_COOKIE_FIELD_PRIORITY].reverse()) {
+        for (const field of [...spec.priority].reverse()) {
             const encoded = encodeURIComponent(JSON.stringify(compact));
-            if (firstTouchCookieAssignment(encoded).length <=
-                FIRST_TOUCH_MAX_COOKIE_BYTES) {
+            if (fits(encoded))
                 return encoded;
-            }
             delete compact[field];
         }
     }
     const encoded = encodeURIComponent(JSON.stringify(compact));
-    if (firstTouchCookieAssignment(encoded).length > FIRST_TOUCH_MAX_COOKIE_BYTES) {
-        throw new Error("First-touch attribution exceeded the cookie budget");
+    if (!fits(encoded)) {
+        throw new Error(`Attribution exceeded the ${spec.name} cookie budget`);
     }
     return encoded;
 }
-function writeFirstTouchCookie(value) {
+function writeAttributionCookie(value, spec) {
     if (typeof document === "undefined")
         return;
-    const encodedValue = fitFirstTouchCookieValue(value);
+    const encodedValue = fitAttributionCookieValue(value, spec);
     try {
-        document.cookie = firstTouchCookieAssignment(encodedValue);
+        document.cookie = attributionCookieAssignment(spec.name, encodedValue);
     }
     catch {
         // best-effort
     }
 }
+function storeAttribution(storageKey, spec, attribution) {
+    const json = JSON.stringify(attribution);
+    safeStorageSet(storageKey, json);
+    writeAttributionCookie(json, spec);
+}
+/**
+ * Restore a cookie that expired or was cleared from its stored value, so the
+ * signup boundary still sees it.
+ */
+function backfillAttributionCookie(storageKey, spec) {
+    if (readAttributionCookie(spec.name))
+        return;
+    const stored = safeStorageGet(storageKey);
+    if (!stored)
+        return;
+    try {
+        writeAttributionCookie(stored, spec);
+    }
+    catch {
+        // coercion-ok: localStorage still holds the value; only this page's
+        // signup handoff goes without it.
+    }
+}
 /**
- * Capture the visitor's first-touch referral attribution exactly once. Reads
- * the current URL query params + landing info and, IF no attribution is
- * already stored (first-write-wins), persists it to both `localStorage`
- * (`an_attribution`) and the first-party `an_ft` cookie. Fully defensive and
- * SSR-safe — any failure is swallowed so it can never break app boot.
+ * Capture the visitor's referral attribution once per page load, into both
+ * `localStorage` and a first-party cookie the signup boundary reads. Fully
+ * defensive and SSR-safe — any failure is swallowed so it can never break app
+ * boot.
+ *
+ * First touch (`an_attribution` / `an_ft`) is first-write-wins, except over a
+ * visit that had no source: the first visit that says where this person came
+ * from replaces it. Without that, an untagged first visit would hide every
+ * tagged visit after it.
  */
 function captureFirstTouchAttribution() {
     if (_firstTouchCaptured)
@@ -477,35 +569,80 @@ function captureFirstTouchAttribution() {
     if (typeof window === "undefined")
         return;
     try {
-        const existing = safeStorageGet(FIRST_TOUCH_STORAGE_KEY);
-        if (existing) {
-            // Already captured in a prior visit. Backfill the cookie if it expired
-            // or was cleared so the signup boundary still sees first-touch data, but
-            // never overwrite the stored value itself (first-write-wins).
-            if (!readFirstTouchCookie()) {
-                try {
-                    writeFirstTouchCookie(existing);
-                }
-                catch {
-                    // ignore
-                }
-            }
-            return;
+        const current = buildFirstTouchAttribution();
+        const existing = getFirstTouchAttribution();
+        if (existing &&
+            (hasAttributionSource(existing) || !hasAttributionSource(current))) {
+            backfillAttributionCookie(FIRST_TOUCH_STORAGE_KEY, FIRST_TOUCH_COOKIE);
+        }
+        else {
+            storeAttribution(FIRST_TOUCH_STORAGE_KEY, FIRST_TOUCH_COOKIE, current);
         }
-        const attribution = buildFirstTouchAttribution();
-        const json = JSON.stringify(attribution);
-        safeStorageSet(FIRST_TOUCH_STORAGE_KEY, json);
-        writeFirstTouchCookie(json);
+        captureLastTouchAttribution(current);
     }
     catch {
         // Attribution is best-effort telemetry; never let it break boot.
     }
 }
-export function getFirstTouchAttribution() {
+/**
+ * Last touch (`an_last_touch` / `an_lt`) is the latest visit that had a
+ * source. When the marketing site forwards its own last touch, that visit is
+ * the one to keep, not the site's first touch riding on the same link. A site
+ * visit keeps the time it happened, and loses to a newer visit the app has
+ * already recorded.
+ */
+function captureLastTouchAttribution(current) {
+    const forwarded = readForwardedLastTouch();
+    const source = forwarded ?? (hasAttributionSource(current) ? current : null);
+    const forwardedAt = readForwardedLastTouchAt();
+    const existing = getLastTouchAttribution();
+    const existingAt = Date.parse(existing?.touched_at ?? "");
+    if (!source ||
+        (forwardedAt &&
+            hasAttributionSource(existing) &&
+            existingAt > Date.parse(forwardedAt))) {
+        backfillAttributionCookie(LAST_TOUCH_STORAGE_KEY, LAST_TOUCH_COOKIE);
+        return;
+    }
+    const lastTouch = {};
+    for (const field of LAST_TOUCH_SOURCE_FIELDS) {
+        const value = source[field];
+        if (value)
+            lastTouch[field] = value;
+    }
+    // As for first touch, `landing_path` is where the visitor entered this app
+    // and `site_landing_path` the marketing-site page the touch landed on.
+    if (current.landing_path)
+        lastTouch.landing_path = current.landing_path;
+    if (source.site_landing_path) {
+        lastTouch.site_landing_path = source.site_landing_path;
+    }
+    lastTouch.touched_at = forwardedAt ?? current.landed_at;
+    storeAttribution(LAST_TOUCH_STORAGE_KEY, LAST_TOUCH_COOKIE, lastTouch);
+}
+function readForwardedLastTouchAt() {
+    const raw = new URLSearchParams(window.location.search).get(FORWARDED_LAST_TOUCH_AT_PARAM);
+    const time = Date.parse(raw ?? "");
+    // A visit can't be in the future; a bad clock or value means "now".
+    if (!Number.isFinite(time) || time > Date.now())
+        return undefined;
+    return new Date(time).toISOString();
+}
+function readForwardedLastTouch() {
+    const params = new URLSearchParams(window.location.search);
+    const forwarded = {};
+    for (const [param, field] of Object.entries(FORWARDED_LAST_TOUCH_FIELDS)) {
+        const value = truncateFirstTouchField(params.get(param));
+        if (value)
+            forwarded[field] = value;
+    }
+    return hasAttributionSource(forwarded) ? forwarded : null;
+}
+function readStoredAttribution(storageKey) {
     if (typeof window === "undefined")
         return null;
     try {
-        const raw = safeStorageGet(FIRST_TOUCH_STORAGE_KEY);
+        const raw = safeStorageGet(storageKey);
         if (!raw)
             return null;
         const parsed = JSON.parse(raw);
@@ -518,10 +655,16 @@ export function getFirstTouchAttribution() {
         return null;
     }
 }
+export function getFirstTouchAttribution() {
+    return readStoredAttribution(FIRST_TOUCH_STORAGE_KEY);
+}
+export function getLastTouchAttribution() {
+    return readStoredAttribution(LAST_TOUCH_STORAGE_KEY);
+}
 /**
- * Store the visitor's first touch now instead of in `configureTracking()`,
- * for a page that reads it before tracking starts. It runs once per page
- * load, so tracking's own capture is then a no-op.
+ * Store the visitor's first and last touch now instead of in
+ * `configureTracking()`, for a page that reads them before tracking starts.
+ * It runs once per page load, so tracking's own capture is then a no-op.
  */
 export function captureAttribution() {
     if (isSyntheticBrowserTraffic())

package/dist/client/client-status-requests.d.ts

@@ -4,6 +4,7 @@ export type ClientStatusResult<T> = {
 } | {
     state: "unavailable";
     status?: number;
+    stale?: boolean;
 };
 declare global {
     interface Window {
@@ -26,7 +27,9 @@ export declare function invalidateClientStatusRequest(path: string): void;
  */
 export declare function expireClientStatusResult(path: string): void;
 export declare function invalidateClientStatusRequests(): void;
-export declare function fetchAgentEngineStatus<T = unknown>(): Promise<ClientStatusResult<T>>;
+export declare function fetchAgentEngineStatus<T = unknown>(options?: {
+    fresh?: boolean;
+}): Promise<ClientStatusResult<T>>;
 export declare function fetchEnvironmentStatus<T = unknown>(): Promise<ClientStatusResult<T>>;
 export declare function fetchBuilderStatus<T = unknown>(): Promise<ClientStatusResult<T>>;
 export declare function fetchFileUploadStatus<T = unknown>(): Promise<ClientStatusResult<T>>;

package/dist/client/client-status-requests.js

@@ -14,6 +14,8 @@ const REQUEST_TIMEOUT_MS = 15_000;
 const SESSION_STATUS_PATH = "/_agent-native/auth/session";
 const cache = new Map();
 const requests = new Map();
+const supersededRequests = new WeakSet();
+const freshRequests = new WeakSet();
 const requestControllers = new Map();
 const requestGenerations = new Map();
 let invalidationListenersInstalled = false;
@@ -54,19 +56,28 @@ function installInvalidationListeners() {
         });
     }
 }
-async function fetchClientStatus(path) {
+async function fetchClientStatus(path, options) {
     if (agentNativeApiDisabledReason())
         return { state: "unavailable" };
     installInvalidationListeners();
     const url = agentNativePath(path);
     const cached = cache.get(url);
-    if (cached && cached.expiresAt > Date.now()) {
+    if (!options?.fresh && cached && cached.expiresAt > Date.now()) {
         return cached.result;
     }
     cache.delete(url);
     const pending = requests.get(url);
-    if (pending)
+    if (pending && options?.fresh && freshRequests.has(pending)) {
         return pending;
+    }
+    if (pending && !options?.fresh) {
+        return pending;
+    }
+    if (options?.fresh) {
+        if (pending)
+            supersededRequests.add(pending);
+        requestGenerations.set(url, (requestGenerations.get(url) ?? 0) + 1);
+    }
     const sessionRead = path === SESSION_STATUS_PATH;
     const currentGeneration = () => sessionRead ? sessionGeneration : statusGeneration;
     const requestGeneration = currentGeneration();
@@ -104,6 +115,9 @@ async function fetchClientStatus(path) {
             .catch(() => ({ state: "unavailable" }));
     const request = Promise.race([transport, timeout])
         .then((result) => {
+        if (supersededRequests.has(request)) {
+            return fetchClientStatus(path);
+        }
         if (currentGeneration() === requestGeneration &&
             (requestGenerations.get(url) ?? 0) === requestUrlGeneration &&
             result.state === "available") {
@@ -127,6 +141,8 @@ async function fetchClientStatus(path) {
         }
     });
     requests.set(url, request);
+    if (options?.fresh)
+        freshRequests.add(request);
     if (controller)
         requestControllers.set(url, controller);
     return request;
@@ -162,8 +178,8 @@ export function invalidateClientStatusRequests() {
     requestControllers.clear();
     requests.clear();
 }
-export function fetchAgentEngineStatus() {
-    return fetchClientStatus("/_agent-native/agent-engine/status");
+export function fetchAgentEngineStatus(options) {
+    return fetchClientStatus("/_agent-native/agent-engine/status", options);
 }
 export function fetchEnvironmentStatus() {
     return fetchClientStatus("/_agent-native/env-status");

package/dist/client/embed-auth.d.ts

@@ -4,4 +4,10 @@ export declare function isEmbedMcpChatBridgeActive(): boolean;
 export declare function getEmbedAuthToken(): string | null;
 export declare function isEmbedAuthActive(): boolean;
 export declare function _resetEmbedAuthForTests(): void;
+/**
+ * Forgets every replayed refusal. Call it when access is known to have
+ * changed, such as a link's status turning `allowed`: a refusal recorded
+ * before then would otherwise fail the next read for up to a minute.
+ */
+export declare function forgetAuthFailures(): void;
 export declare function ensureEmbedAuthFetchInterceptor(): void;

package/dist/client/embed-auth.js

@@ -349,6 +349,11 @@ function isAuthFailureStatus(status) {
     return status === 401 || status === 403;
 }
 function shouldGuardAuthFailure(method, url) {
+    // Only an embed replays refusals, so a missing or expired embed token can't
+    // set off a retry storm. Elsewhere a refusal can lift mid-session, as when
+    // someone shares the page, and a replayed one would hide that for a minute.
+    if (!isEmbedAuthActive())
+        return false;
     if (!GUARDED_METHODS.has(method))
         return false;
     if (url.pathname === EMBED_START_PATH)
@@ -415,6 +420,14 @@ async function recordAuthFailure(key, response) {
 function clearAuthFailure(key) {
     authFailureCache.delete(key);
 }
+/**
+ * Forgets every replayed refusal. Call it when access is known to have
+ * changed, such as a link's status turning `allowed`: a refusal recorded
+ * before then would otherwise fail the next read for up to a minute.
+ */
+export function forgetAuthFailures() {
+    authFailureCache.clear();
+}
 function withEmbedAuthHeaders(input, init, token, win) {
     const method = requestMethod(input, init);
     const url = inputUrl(input, win);

package/dist/client/session-replay.js

@@ -1114,8 +1114,9 @@ async function awaitReplayUpload(request, timeout) {
 async function sendReplayUpload(options, body, callbacks = {}) {
     if (isCrossOriginReplayEndpoint(options.endpoint)) {
         const canUseKeepalive = canUseReplayKeepalive(body);
-        if (canUseKeepalive)
-            callbacks.beforeKeepaliveUpload?.();
+        if (callbacks.beforeUpload?.(canUseKeepalive) === "defer") {
+            return "deferred";
+        }
         const timeout = startReplayUploadTimeout();
         await awaitReplayUploadRequest(timeout, () => fetch(options.endpoint, {
             method: "POST",
@@ -1124,12 +1125,12 @@ async function sendReplayUpload(options, body, callbacks = {}) {
             headers: { "Content-Type": "text/plain;charset=UTF-8" },
             signal: timeout.signal,
         }));
-        return;
+        return "sent";
     }
     const upload = await buildReplayUploadBody(body);
     const canUseKeepalive = canUseReplayKeepalive(upload.body);
-    if (canUseKeepalive)
-        callbacks.beforeKeepaliveUpload?.();
+    if (callbacks.beforeUpload?.(canUseKeepalive) === "defer")
+        return "deferred";
     const timeout = startReplayUploadTimeout();
     await awaitReplayUploadRequest(timeout, () => fetch(options.endpoint, {
         method: "POST",
@@ -1141,6 +1142,7 @@ async function sendReplayUpload(options, body, callbacks = {}) {
         },
         signal: timeout.signal,
     }));
+    return "sent";
 }
 function isFinalFlushReason(reason) {
     return [
@@ -1157,6 +1159,16 @@ function isFinalFlushReason(reason) {
 function isTerminalReplayFlushReason(reason) {
     return reason === "pagehide" || reason === "beforeunload";
 }
+/**
+ * A navigation fires `visibilitychange` before or after `pagehide`, depending
+ * on the browser, and a mobile page may get only `visibilitychange`. A page in
+ * the back/forward cache can be evicted without running again.
+ */
+function isPageLeaveReplayFlushReason(reason) {
+    return (isTerminalReplayFlushReason(reason) ||
+        reason === "pagehide-persisted" ||
+        reason === "visibility-hidden");
+}
 function flushReasonPriority(reason) {
     if (reason === "pagehide" ||
         reason === "pagehide-persisted" ||
@@ -1176,12 +1188,6 @@ function mergePendingFlushReason(current, requested) {
         ? requested
         : current;
 }
-function shouldReserveSequenceBeforeKeepalive(reason) {
-    return (reason === "pagehide" ||
-        reason === "pagehide-persisted" ||
-        reason === "beforeunload" ||
-        reason === "visibility-hidden");
-}
 function hasFullSnapshot(events) {
     return events.some((event) => event.type === RRWEB_FULL_SNAPSHOT_EVENT_TYPE);
 }
@@ -1449,19 +1455,39 @@ export async function flushSessionReplay(reason = "manual") {
     let pausedForQuota = false;
     let quotaRetryAfterSeconds = null;
     try {
-        await sendReplayUpload(state.options, payload.body, {
-            beforeKeepaliveUpload: shouldReserveSequenceBeforeKeepalive(reason)
-                ? () => {
-                    advanceReplaySequence(state, payload);
-                    reservedSequence = true;
+        // An upload can be stored after a navigation has destroyed this page and
+        // its response handler: a keepalive one because the browser finishes
+        // sending it, and a larger one when the server already has its body.
+        // Persist the next index first, or the next page resends this chunk number
+        // with different content and the server rejects it (HTTP 409). A flush as
+        // the page hides or leaves never starts an upload too large for keepalive:
+        // a navigation usually cancels it, so a reserved number would leave a gap,
+        // and an unreserved one that still arrives would be reused. Its events stay
+        // queued for the next flush of a page that survives. A same-origin body is
+        // compressed before this check, so a hide or leave event can arrive in
+        // between; it is queued as the pending reason.
+        const outcome = await sendReplayUpload(state.options, payload.body, {
+            beforeUpload: (keepalive) => {
+                const pendingReason = state.pendingFlushReason;
+                if (!keepalive &&
+                    (isPageLeaveReplayFlushReason(reason) ||
+                        (pendingReason !== null &&
+                            isPageLeaveReplayFlushReason(pendingReason)))) {
+                    return "defer";
                 }
-                : undefined,
+                advanceReplaySequence(state, payload);
+                reservedSequence = true;
+                return "send";
+            },
         });
-        if (!reservedSequence)
-            advanceReplaySequence(state, payload);
-        state.automaticConflictRestartAttempted = false;
-        state.transientClientErrorFailures = 0;
-        uploaded = true;
+        if (outcome === "deferred") {
+            restoreReplayEvents(state, events);
+        }
+        else {
+            state.automaticConflictRestartAttempted = false;
+            state.transientClientErrorFailures = 0;
+            uploaded = true;
+        }
     }
     catch (error) {
         if (error instanceof ReplayUploadInFlightTimeoutError) {

package/dist/client/sharing/index.d.ts

@@ -1,4 +1,6 @@
 export { SHARE_LINK_REF_PARAM, SHARE_LINK_VIA_PARAM, withShareLinkAttribution, } from "./share-link-attribution.js";
+export { useAccessRequestDecisions, useAccessRequestReview, useResourceAccessRequests, type AccessRequestDecisionFailure, type AccessRequestDecisions, type AccessRequestReview, type AccessRequestReviewController, type AccessRequestRole, type ResourceAccessRequestsController, } from "./useAccessRequestReview.js";
+export { useResourceAccessGate, type ResourceAccessGateController, type ResourceAccessGateOptions, type ResourceAccessGateRequest, type ResourceAccessRequestFailure, type ResourceAccessGateRole, type ResourceAccessGateState, type ResourceAccessGateStatus, } from "./useResourceAccessGate.js";
 export { useShareButtonController, type ShareButtonController, type ShareButtonControllerOptions, type ShareButtonOrgMember, type ShareButtonOrgMemberSearch, type ShareButtonRole, type ShareButtonShare, type ShareButtonSharesResponse, type ShareButtonVisibility, } from "./useShareButtonController.js";
 export { useShareDialogController, type ResourceShare, type ResourceSharesResponse, type ShareDialogController, type ShareDialogControllerOptions, type ShareDialogPerson, type ShareDialogTab, type ShareOption, type ShareRole, type ShareVisibility, } from "./useShareDialogController.js";
 export { createShareQueryKey, createShareQueryParams, extractShareErrorMessage, fetchOrgMemberPage, mergeOrgMembers, normalizeOrgMembers, optimisticallyUpdateShareCache, rollbackShareCache, useShareMutationGuard, useShareMutations, useShareOrgMemberSearch, useShareQuery, type OrgMemberPage, type ShareOrgMember, type ShareOrgMemberSearchResult, type ShareQueryKey, type ShareQueryParams, } from "./share-controller-helpers.js";

package/dist/client/sharing/index.js

@@ -1,4 +1,6 @@
 export { SHARE_LINK_REF_PARAM, SHARE_LINK_VIA_PARAM, withShareLinkAttribution, } from "./share-link-attribution.js";
+export { useAccessRequestDecisions, useAccessRequestReview, useResourceAccessRequests, } from "./useAccessRequestReview.js";
+export { useResourceAccessGate, } from "./useResourceAccessGate.js";
 export { useShareButtonController, } from "./useShareButtonController.js";
 export { useShareDialogController, } from "./useShareDialogController.js";
 export { createShareQueryKey, createShareQueryParams, extractShareErrorMessage, fetchOrgMemberPage, mergeOrgMembers, normalizeOrgMembers, optimisticallyUpdateShareCache, rollbackShareCache, useShareMutationGuard, useShareMutations, useShareOrgMemberSearch, useShareQuery, } from "./share-controller-helpers.js";