@agent-native/core 0.207.1 → 0.207.2-nightly-20261013011333

package/dist/client/motion-text.js

@@ -0,0 +1,551 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Children, cloneElement, isValidElement, useCallback, useEffect, useRef, useState, } from "react";
+import "./motion-text.css";
+import { isMotionEaseVariableReference, isValidMotionEase, resolveMotionEaseForWebAnimations, } from "../shared/motion-easing.js";
+const MOTION_TEXT_UNITS = new Set([
+    "character",
+    "word",
+    "line",
+    "paragraph",
+]);
+const MOTION_TEXT_PROPERTIES = new Set([
+    "opacity",
+    "translate",
+    "scale",
+    "rotate",
+    "filter",
+]);
+const MOTION_TEXT_PLAYBACK_MODES = new Set([
+    "loop",
+    "once",
+    "ping-pong",
+]);
+const PARAGRAPH_TAGS = new Set([
+    "blockquote",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "li",
+    "p",
+]);
+const INLINE_TEXT_TAGS = new Set([
+    "a",
+    "abbr",
+    "b",
+    "bdi",
+    "bdo",
+    "cite",
+    "code",
+    "data",
+    "del",
+    "dfn",
+    "em",
+    "i",
+    "ins",
+    "kbd",
+    "mark",
+    "q",
+    "s",
+    "samp",
+    "small",
+    "span",
+    "strong",
+    "sub",
+    "sup",
+    "time",
+    "u",
+    "var",
+]);
+const MAX_TEXT_UNITS = 512;
+const PREVIEW_MESSAGE_TYPES = new Set([
+    "motion-preview",
+    "motion-preview-clear",
+]);
+/**
+ * Applies static text property animations to a single intrinsic JSX host element.
+ * Importing this entry includes the package stylesheet; the same asset is
+ * available as `@agent-native/core/client/motion-text.css` for CSS-only setups.
+ */
+export function AgentNativeMotionText({ animation, animations: animationList, playbackMode = "once", children, }) {
+    if (animation && animationList) {
+        throw new Error("AgentNativeMotionText accepts animation or animations, not both.");
+    }
+    const animations = animationList ?? (animation ? [animation] : []);
+    validateAnimations(animations);
+    const primaryAnimation = animations[0];
+    validatePlaybackMode(playbackMode);
+    const child = Children.only(children);
+    if (!isValidElement(child) || typeof child.type !== "string") {
+        throw new Error("AgentNativeMotionText requires exactly one intrinsic host JSX child.");
+    }
+    const host = child;
+    if (host.props["data-agent-native-node-id"] !== primaryAnimation.targetNodeId) {
+        throw new Error("AgentNativeMotionText animation.targetNodeId must match the child’s static data-agent-native-node-id.");
+    }
+    const [motionAllowed, setMotionAllowed] = useState(false);
+    const hostRef = useRef(null);
+    const childRef = host.props.ref;
+    const setHostRef = useCallback((element) => {
+        hostRef.current = element;
+        if (typeof childRef === "function") {
+            if (!element) {
+                childRef(null);
+                return;
+            }
+            const cleanup = childRef(element);
+            return () => {
+                hostRef.current = null;
+                if (typeof cleanup === "function")
+                    cleanup();
+                else
+                    childRef(null);
+            };
+        }
+        assignRef(childRef, element);
+        if (element) {
+            return () => {
+                hostRef.current = null;
+                assignRef(childRef, null);
+            };
+        }
+    }, [childRef]);
+    useEffect(() => {
+        if (typeof window.matchMedia !== "function") {
+            setMotionAllowed(true);
+            return;
+        }
+        const preference = window.matchMedia("(prefers-reduced-motion: reduce)");
+        const updatePreference = () => setMotionAllowed(!preference.matches);
+        updatePreference();
+        preference.addEventListener?.("change", updatePreference);
+        return () => preference.removeEventListener?.("change", updatePreference);
+    }, []);
+    useEffect(() => {
+        if (!motionAllowed)
+            return;
+        const hostElement = hostRef.current;
+        if (!hostElement)
+            return;
+        const elements = resolveMotionUnits(hostElement, primaryAnimation);
+        if (elements.length === 0) {
+            throw new Error("AgentNativeMotionText found no animatable text units.");
+        }
+        const groupCount = elements.reduce((count, entry) => Math.max(count, entry.index + 1), 0);
+        if (groupCount > MAX_TEXT_UNITS) {
+            throw new Error(`AgentNativeMotionText supports at most ${MAX_TEXT_UNITS} animated units.`);
+        }
+        if ((groupCount - 1) * primaryAnimation.staggerMs > 120_000) {
+            throw new Error("AgentNativeMotionText stagger exceeds the 120000ms runtime limit.");
+        }
+        const previewAnimations = [];
+        try {
+            for (const track of animations) {
+                for (const entry of elements) {
+                    if (typeof entry.element.animate !== "function") {
+                        throw new Error("AgentNativeMotionText requires the Web Animations API.");
+                    }
+                    const delayIndex = track.direction === "reverse"
+                        ? groupCount - 1 - entry.index
+                        : entry.index;
+                    const easingStyle = track.keyframes.some((keyframe) => isMotionEaseVariableReference(keyframe.ease ?? ""))
+                        ? window.getComputedStyle(entry.element)
+                        : null;
+                    const keyframes = track.keyframes.map((keyframe) => ({
+                        offset: keyframe.t,
+                        easing: resolveMotionEaseForWebAnimations(keyframe.ease ?? "ease", (name) => easingStyle?.getPropertyValue(name) ?? ""),
+                        [track.property]: keyframe.value,
+                    }));
+                    const delay = (track.delayMs ?? 0) + delayIndex * track.staggerMs;
+                    const runningAnimation = entry.element.animate(keyframes, {
+                        duration: track.durationMs,
+                        delay,
+                        iterations: playbackMode === "once" ? 1 : Infinity,
+                        direction: playbackMode === "ping-pong" ? "alternate" : "normal",
+                        fill: "both",
+                    });
+                    previewAnimations.push({
+                        animation: runningAnimation,
+                        delay,
+                        durationMs: track.durationMs,
+                    });
+                }
+            }
+        }
+        catch (error) {
+            for (const entry of previewAnimations) {
+                entry.animation.cancel();
+            }
+            throw error;
+        }
+        let isPreviewing = false;
+        const handlePreviewMessage = (event) => {
+            if (event.source !== window.parent ||
+                !isMotionPreviewMessage(event.data)) {
+                return;
+            }
+            if (event.data.type === "motion-preview-clear") {
+                if (!isPreviewing)
+                    return;
+                isPreviewing = false;
+                for (const entry of previewAnimations) {
+                    entry.animation.currentTime = 0;
+                    entry.animation.play();
+                }
+                return;
+            }
+            const t = Number(event.data.t);
+            const timelineDuration = Number(event.data.durationMs);
+            if (!Number.isFinite(t) || !Number.isFinite(timelineDuration))
+                return;
+            if (timelineDuration <= 0)
+                return;
+            if (!isPreviewing) {
+                isPreviewing = true;
+                for (const entry of previewAnimations)
+                    entry.animation.pause();
+            }
+            const timelineTime = Math.max(0, Math.min(1, t)) * timelineDuration;
+            for (const entry of previewAnimations) {
+                const elapsed = Math.max(0, timelineTime - entry.delay);
+                entry.animation.currentTime =
+                    playbackMode === "once"
+                        ? Math.min(entry.durationMs, elapsed)
+                        : elapsed;
+            }
+        };
+        window.addEventListener("message", handlePreviewMessage);
+        return () => {
+            window.removeEventListener("message", handlePreviewMessage);
+            for (const entry of previewAnimations) {
+                entry.animation.cancel();
+            }
+        };
+    }, [animations, motionAllowed, playbackMode, primaryAnimation]);
+    const nextUnitIndex = { current: 0 };
+    const outputChildren = motionAllowed
+        ? primaryAnimation.unit === "paragraph"
+            ? renderParagraphs(host.props.children, nextUnitIndex)
+            : renderTextNodes(host.props.children, primaryAnimation, nextUnitIndex)
+        : host.props.children;
+    return cloneElement(host, { ref: setHostRef, children: outputChildren });
+}
+function validatePlaybackMode(mode) {
+    if (!MOTION_TEXT_PLAYBACK_MODES.has(mode)) {
+        throw new Error("AgentNativeMotionText playbackMode is unsupported.");
+    }
+}
+function validateAnimations(animations) {
+    if (!Array.isArray(animations) || animations.length === 0) {
+        throw new Error("AgentNativeMotionText requires at least one animation.");
+    }
+    const first = animations[0];
+    const properties = new Set();
+    for (const animation of animations) {
+        validateAnimation(animation);
+        if (animation.targetNodeId !== first.targetNodeId ||
+            animation.unit !== first.unit ||
+            animation.direction !== first.direction ||
+            animation.staggerMs !== first.staggerMs) {
+            throw new Error("AgentNativeMotionText animations for one target must share target, unit, direction, and stagger.");
+        }
+        if (properties.has(animation.property)) {
+            throw new Error(`AgentNativeMotionText property "${animation.property}" is duplicated.`);
+        }
+        properties.add(animation.property);
+    }
+}
+function validateAnimation(animation) {
+    if (!animation || typeof animation !== "object") {
+        throw new Error("AgentNativeMotionText animation must be a static object.");
+    }
+    if (typeof animation.targetNodeId !== "string" ||
+        !/^[A-Za-z0-9_-]+$/.test(animation.targetNodeId)) {
+        throw new Error("AgentNativeMotionText targetNodeId is invalid.");
+    }
+    if (!MOTION_TEXT_UNITS.has(animation.unit)) {
+        throw new Error("AgentNativeMotionText unit is unsupported.");
+    }
+    if (animation.direction !== "forward" && animation.direction !== "reverse") {
+        throw new Error("AgentNativeMotionText direction is unsupported.");
+    }
+    if (!MOTION_TEXT_PROPERTIES.has(animation.property)) {
+        throw new Error("AgentNativeMotionText property is unsupported.");
+    }
+    if (!Number.isFinite(animation.staggerMs) ||
+        animation.staggerMs < 0 ||
+        animation.staggerMs > 5000) {
+        throw new Error("AgentNativeMotionText staggerMs is invalid.");
+    }
+    if (animation.delayMs !== undefined &&
+        (!Number.isFinite(animation.delayMs) ||
+            animation.delayMs < 0 ||
+            animation.delayMs > 120_000)) {
+        throw new Error("AgentNativeMotionText delayMs is invalid.");
+    }
+    if (!Number.isFinite(animation.durationMs) ||
+        animation.durationMs <= 0 ||
+        animation.durationMs > 120_000) {
+        throw new Error("AgentNativeMotionText durationMs is invalid.");
+    }
+    if (!Array.isArray(animation.keyframes) ||
+        animation.keyframes.length < 2 ||
+        animation.keyframes.length > 128) {
+        throw new Error("AgentNativeMotionText keyframes are invalid.");
+    }
+    let previousT = -1;
+    for (const keyframe of animation.keyframes) {
+        if (!Number.isFinite(keyframe.t) ||
+            keyframe.t < 0 ||
+            keyframe.t > 1 ||
+            keyframe.t <= previousT ||
+            typeof keyframe.value !== "string" ||
+            keyframe.value.trim().length === 0 ||
+            (keyframe.ease !== undefined &&
+                (typeof keyframe.ease !== "string" ||
+                    !isValidMotionEase(keyframe.ease)))) {
+            throw new Error("AgentNativeMotionText keyframes are invalid.");
+        }
+        previousT = keyframe.t;
+    }
+    if (animation.keyframes[0]?.t !== 0 ||
+        animation.keyframes[animation.keyframes.length - 1]?.t !== 1) {
+        throw new Error("AgentNativeMotionText keyframes must span [0, 1].");
+    }
+}
+function assignRef(ref, value) {
+    if (typeof ref === "function")
+        ref(value);
+    else if (ref)
+        ref.current = value;
+}
+function textTokens(text, unit) {
+    if (unit === "character") {
+        const Segmenter = Intl.Segmenter;
+        const parts = Segmenter
+            ? Array.from(new Segmenter(undefined, { granularity: "grapheme" }).segment(text), (part) => part.segment)
+            : Array.from(text);
+        return parts.map((part) => ({
+            text: part,
+            animated: !/^\s+$/u.test(part),
+        }));
+    }
+    const Segmenter = Intl.Segmenter;
+    const chunks = Segmenter
+        ? Array.from(new Segmenter(undefined, { granularity: "word" }).segment(text), (part) => ({
+            text: part.segment,
+            word: part.isWordLike,
+        }))
+        : (text.match(/\s+|[^\s]+/gu) ?? []).map((part) => ({
+            text: part,
+            word: !/^\s+$/u.test(part),
+        }));
+    const tokens = [];
+    for (let index = 0; index < chunks.length; index += 1) {
+        const chunk = chunks[index];
+        if (/^\s+$/u.test(chunk.text)) {
+            tokens.push({ text: chunk.text, animated: false });
+        }
+        else if (chunk.word) {
+            tokens.push({ text: chunk.text, animated: true });
+        }
+        else if (tokens.length && tokens[tokens.length - 1].animated) {
+            tokens[tokens.length - 1].text += chunk.text;
+        }
+        else {
+            const nextWord = chunks
+                .slice(index + 1)
+                .findIndex((candidate) => candidate.word);
+            if (nextWord >= 0) {
+                let punctuation = chunk.text;
+                while (index + 1 < chunks.length &&
+                    !chunks[index + 1].word &&
+                    !/^\s+$/u.test(chunks[index + 1].text)) {
+                    punctuation += chunks[++index].text;
+                }
+                tokens.push({ text: punctuation, animated: true });
+            }
+            else {
+                tokens.push({ text: chunk.text, animated: false });
+            }
+        }
+    }
+    return tokens;
+}
+function renderTextNodes(node, animation, nextUnitIndex) {
+    const textLeaves = [];
+    collectTextLeaves(node, textLeaves, { current: 0 });
+    const text = textLeaves.map((leaf) => leaf.text).join("");
+    const unit = animation.unit === "character" ? "character" : "word";
+    const tokenValues = textTokens(text, unit);
+    const tokens = [];
+    let tokenOffset = 0;
+    for (const token of tokenValues) {
+        const start = tokenOffset;
+        const end = start + token.text.length;
+        tokenOffset = end;
+        tokens.push({ ...token, start, end, index: -1 });
+    }
+    for (const token of tokens) {
+        if (token.animated)
+            token.index = nextUnitIndex.current++;
+    }
+    if (nextUnitIndex.current > MAX_TEXT_UNITS) {
+        throw new Error(`AgentNativeMotionText supports at most ${MAX_TEXT_UNITS} animated units.`);
+    }
+    return mapTextLeaves(node, 0, textLeaves, tokens);
+}
+function collectTextLeaves(node, leaves, offset) {
+    if (typeof node === "string" || typeof node === "number") {
+        const text = String(node);
+        const start = offset.current;
+        leaves.push({ text, start, end: start + text.length });
+        offset.current += text.length;
+        return;
+    }
+    if (Array.isArray(node)) {
+        for (const child of node)
+            collectTextLeaves(child, leaves, offset);
+        return;
+    }
+    if (isValidElement(node)) {
+        if (typeof node.type !== "string" || !INLINE_TEXT_TAGS.has(node.type)) {
+            throw new Error("Character, word, and line Motion text supports only static inline host elements.");
+        }
+        collectTextLeaves(asMotionTextNode(node).props.children, leaves, offset);
+    }
+}
+function mapTextLeaves(node, leafIndex, leaves, tokens) {
+    if (typeof node === "string" || typeof node === "number") {
+        const leaf = leaves[leafIndex];
+        return renderTextLeaf(leaf, tokens);
+    }
+    if (Array.isArray(node)) {
+        let nextLeafIndex = leafIndex;
+        const mapped = node.map((child) => {
+            const mappedChild = mapTextLeaves(child, nextLeafIndex, leaves, tokens);
+            nextLeafIndex += countTextLeaves(child);
+            return mappedChild;
+        });
+        return mapped;
+    }
+    if (isValidElement(node)) {
+        if (typeof node.type !== "string")
+            return node;
+        const element = asMotionTextNode(node);
+        const children = element.props.children;
+        const mappedChildren = mapTextLeaves(children, leafIndex, leaves, tokens);
+        return cloneElement(element, { children: mappedChildren });
+    }
+    return node;
+}
+function renderTextLeaf(leaf, tokens) {
+    if (!leaf)
+        return null;
+    const parts = [];
+    for (const token of tokens) {
+        const start = Math.max(leaf.start, token.start);
+        const end = Math.min(leaf.end, token.end);
+        if (start >= end)
+            continue;
+        const text = leaf.text.slice(start - leaf.start, end - leaf.start);
+        if (!token.animated) {
+            parts.push(text);
+            continue;
+        }
+        parts.push(_jsx("span", { className: "agent-native-motion-text-unit", "data-agent-native-motion-text-unit": token.index, children: text }, `${token.index}-${start}`));
+    }
+    return parts;
+}
+function countTextLeaves(node) {
+    if (typeof node === "string" || typeof node === "number")
+        return 1;
+    if (Array.isArray(node))
+        return node.reduce((sum, child) => sum + countTextLeaves(child), 0);
+    if (isValidElement(node)) {
+        return countTextLeaves(asMotionTextNode(node).props.children);
+    }
+    return 0;
+}
+function renderParagraphs(node, nextUnitIndex) {
+    if (isValidElement(node) && typeof node.type === "string") {
+        const element = asMotionTextNode(node);
+        if (PARAGRAPH_TAGS.has(node.type)) {
+            const index = nextUnitIndex.current++;
+            return cloneElement(element, {
+                "data-agent-native-motion-text-unit": index,
+            });
+        }
+        if (Array.isArray(element.props.children)) {
+            let foundElement = false;
+            const children = element.props.children.map((child) => {
+                if (isValidElement(child) &&
+                    typeof child.type === "string" &&
+                    PARAGRAPH_TAGS.has(child.type)) {
+                    foundElement = true;
+                    return renderParagraphs(child, nextUnitIndex);
+                }
+                return child;
+            });
+            if (foundElement)
+                return cloneElement(element, { children });
+        }
+        if (isValidElement(element.props.children) &&
+            typeof element.props.children.type === "string" &&
+            PARAGRAPH_TAGS.has(element.props.children.type)) {
+            return cloneElement(element, {
+                children: renderParagraphs(element.props.children, nextUnitIndex),
+            });
+        }
+        if (typeof element.props.children === "string" &&
+            element.props.children.length > 0) {
+            const index = nextUnitIndex.current++;
+            return cloneElement(element, {
+                "data-agent-native-motion-text-unit": index,
+            });
+        }
+    }
+    return node;
+}
+function asMotionTextNode(node) {
+    return node;
+}
+function resolveMotionUnits(host, animation) {
+    if (animation.unit === "paragraph") {
+        const hostTag = host.tagName.toLowerCase();
+        if (PARAGRAPH_TAGS.has(hostTag))
+            return [{ element: host, index: 0 }];
+        const children = Array.from(host.children);
+        if (children.length &&
+            children.every((child) => PARAGRAPH_TAGS.has(child.tagName.toLowerCase()))) {
+            return children.map((element, index) => ({ element, index }));
+        }
+        return [{ element: host, index: 0 }];
+    }
+    const units = Array.from(host.querySelectorAll("[data-agent-native-motion-text-unit]"));
+    if (animation.unit === "line") {
+        const lineTops = [];
+        return units.map((element) => {
+            const top = element.getBoundingClientRect().top;
+            let index = lineTops.findIndex((existing) => Math.abs(existing - top) < 0.5);
+            if (index < 0) {
+                index = lineTops.length;
+                lineTops.push(top);
+            }
+            return { element, index };
+        });
+    }
+    return units.map((element) => ({
+        element,
+        index: Number(element.getAttribute("data-agent-native-motion-text-unit")),
+    }));
+}
+function isMotionPreviewMessage(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const message = value;
+    return (typeof message.type === "string" &&
+        PREVIEW_MESSAGE_TYPES.has(message.type));
+}

package/dist/client/org/hooks.d.ts

@@ -88,7 +88,9 @@ export declare function useSetOrgVisualIdentity(): import("@tanstack/react-query
 } | null, {
     previous: OrgInfo | undefined;
 }>;
-export declare function useSwitchOrg(): import("@tanstack/react-query").UseMutationResult<any, Error, string | null, unknown>;
+export declare function useSwitchOrg(options?: {
+    onPersisted?: (orgId: string | null) => void;
+}): import("@tanstack/react-query").UseMutationResult<any, Error, string | null, unknown>;
 export declare function useDeleteOrg(): import("@tanstack/react-query").UseMutationResult<any, Error, string, unknown>;
 export declare function useJoinByDomain(): import("@tanstack/react-query").UseMutationResult<any, Error, string, unknown>;
 export declare function useSetOrgDomain(): import("@tanstack/react-query").UseMutationResult<any, Error, string | null, unknown>;

package/dist/client/org/hooks.js

@@ -230,14 +230,20 @@ export function useSetOrgVisualIdentity() {
         },
     });
 }
-export function useSwitchOrg() {
+export function useSwitchOrg(options = {}) {
     const qc = useQueryClient();
     return useMutation({
         mutationFn: (orgId) => apiFetch(`${orgBasePath()}/switch`, {
             method: "PUT",
             body: JSON.stringify({ orgId }),
         }),
-        onSuccess: async () => {
+        onSuccess: async (_data, orgId) => {
+            try {
+                options.onPersisted?.(orgId);
+            }
+            catch {
+                console.error("The organization persistence callback failed.");
+            }
             // The persisted-results scope follows the session's org; re-read it before
             // refetching, or this org's results are saved under the old one. Loaded here,
             // not at import: use-session pulls in frame.ts, which touches window on load.

package/dist/client/route-chunk-recovery.d.ts

@@ -20,6 +20,8 @@ export declare function createRouteChunkRecoveryState(): RouteChunkRecoveryState
 export declare function isRouteModuleReloadMessage(value: unknown): boolean;
 export declare function isDynamicImportFailureMessage(value: unknown): boolean;
 export declare function rememberIntendedNavigation(state: RouteChunkRecoveryState, href: string, now?: number): void;
+/** Preserve router-driven targets whose route module fails before history commits. */
+export declare function rememberRouteChunkRecoveryNavigation(href: string, win?: Window | undefined): void;
 export declare function getFreshIntendedNavigation(state: RouteChunkRecoveryState, currentHref: string, now?: number): string | null;
 export declare function intendedHrefFromClick(win: Window, event: MouseEvent): string | null;
 /** The recorded exhaustion for this page session, if recovery ever gave up. */

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

@@ -2,6 +2,7 @@ import { CHUNK_RECOVERY_CACHE_BUSTER_PARAM, CHUNK_RECOVERY_ORIGINAL_HASH_PARAM,
 const INSTALL_KEY = "__agentNativeRouteChunkRecoveryInstalled";
 const INTENDED_NAV_MAX_AGE_MS = 15_000;
 const STALE_CHUNK_EXHAUSTED_KEY = "__agentNativeStaleChunkRecoveryExhausted";
+const recoveryStates = new WeakMap();
 /**
  * Fired on `window` the first time a stale chunk could not be recovered by a
  * reload. The shared noise rules drop the raw dynamic-import failure because
@@ -35,6 +36,15 @@ export function rememberIntendedNavigation(state, href, now = Date.now()) {
     state.intendedHref = href;
     state.intendedAt = now;
 }
+/** Preserve router-driven targets whose route module fails before history commits. */
+export function rememberRouteChunkRecoveryNavigation(href, win = typeof window === "undefined" ? undefined : window) {
+    if (!win)
+        return;
+    const state = recoveryStates.get(win);
+    const sameOrigin = sameOriginHref(win, href);
+    if (state && sameOrigin)
+        rememberIntendedNavigation(state, sameOrigin);
+}
 export function getFreshIntendedNavigation(state, currentHref, now = Date.now()) {
     if (!state.intendedHref)
         return null;
@@ -374,6 +384,7 @@ export function installRouteChunkRecovery(win = typeof window === "undefined" ?
     installedTarget[INSTALL_KEY] = true;
     clearChunkRecoveryCacheBuster(win);
     const state = createRouteChunkRecoveryState();
+    recoveryStates.set(win, state);
     win.document.addEventListener("click", (event) => {
         const href = intendedHrefFromClick(win, event);
         if (href)

package/dist/client/use-action.d.ts

@@ -1,4 +1,4 @@
-import type { Query, UseQueryOptions, UseMutationOptions } from "@tanstack/react-query";
+import type { Query, QueryClient, UseQueryOptions, UseMutationOptions } from "@tanstack/react-query";
 /** @internal exported for tests */
 export declare function defaultActionQueryRetry(failureCount: number, error: unknown): boolean;
 /** @internal alias kept for existing specs. */
@@ -105,10 +105,18 @@ export declare function guardActionQueryRefetchInterval<TData = unknown>(refetch
 export declare function resolveActionQueryRetry(retry: unknown, failureCount: number, error: unknown): boolean;
 /** @internal exported for tests */
 export declare function resetActionCircuitTripEventsForTests(): void;
+export declare function registerActionQueryCacheRevoker(client: QueryClient, revoke: () => void, bindingToken?: object): void;
+/** @internal set only by the scoped action-query cache binder. */
+export declare function setActionQueryCacheBindingToken(token: object | undefined): void;
+export declare function setAccessDeniedActionQueryBinding(query: Query, token: object | undefined): void;
+export declare function getAccessDeniedActionQueryBinding(query: Query): object | undefined;
+export declare function clearAccessDeniedActionQueryBinding(query: Query): void;
 /** @internal read by the persisted query cache. */
 export declare function isBrowserPersistableActionQuery(query: Query): boolean;
+/** @internal a response is persistable only in the binding active at fetch start. */
+export declare function isBrowserPersistableActionQueryForBinding(query: Query, token: object): boolean;
 /** @internal used only after a persisted action result is accepted and hydrated. */
-export declare function markRestoredBrowserPersistableActionQuery(query: Query): void;
+export declare function markRestoredBrowserPersistableActionQuery(query: Query, token?: object): void;
 export declare function revokeBrowserPersistableActionQuery(query: Query): void;
 export declare function useActionQuery<TResult = undefined, TName extends ActionName = ActionName>(actionName: TName, params?: ActionParams<TName>, options?: Omit<UseQueryOptions<TResult extends undefined ? ActionResult<TName> : TResult>, "queryKey" | "queryFn"> & {
     queryKeyScope?: readonly unknown[];