@agent-native/core 0.214.0 → 0.217.0

package/dist/client/consent.js

@@ -0,0 +1,413 @@
+import { CONSENT_COOKIE_LIFETIME_SECONDS, CONSENT_COOKIE_NAME, CONSENT_PATH, CONSENT_REGION_PATH, consentCookieDomain, isConsentRegionTimeZone, parseConsent, serializeConsent, } from "../shared/consent.js";
+import { agentNativePath } from "./api-path.js";
+import { agentNativeApiDisabledReason } from "./api-surface.js";
+/** Strictly necessary for the banner: which region this session is in. */
+const REGION_STORAGE_KEY = "an_consent_region";
+/**
+ * Scripts that run before this module loads, like the Google tags the server
+ * injects into the page, queue `[category, run]` here.
+ */
+const SCRIPT_QUEUE_KEY = "__AN_CONSENT_QUEUE__";
+/** The Google data layers the server's Consent Mode default script set up. */
+const GOOGLE_CONSENT_LAYERS_KEY = "__AN_CONSENT_LAYERS__";
+// One state per page, however many copies of this module a bundle carries.
+const STATE_KEY = Symbol.for("agent-native.client.consent");
+function state() {
+    const holder = globalThis;
+    return (holder[STATE_KEY] ??= {
+        region: null,
+        regionPromise: null,
+        waiters: [],
+        listeners: new Set(),
+        settingsOpen: false,
+        pageChoice: null,
+    });
+}
+function readCookie(name) {
+    if (typeof document === "undefined")
+        return null;
+    try {
+        for (const part of document.cookie ? document.cookie.split(";") : []) {
+            const eq = part.indexOf("=");
+            if (eq !== -1 && part.slice(0, eq).trim() === name) {
+                return part.slice(eq + 1).trim();
+            }
+        }
+    }
+    catch {
+        // coercion-ok: a sandboxed iframe can't read cookies, so it holds no
+        // choice and the visitor is asked.
+    }
+    return null;
+}
+/** The visitor's stored choice, or `null` before they've made one. */
+export function getConsentChoice() {
+    return (parseConsent(readCookie(CONSENT_COOKIE_NAME)) ?? state().pageChoice ?? null);
+}
+function cookieDomain() {
+    const host = typeof window === "undefined" ? "" : window.location.hostname;
+    const domain = consentCookieDomain(host);
+    return domain ? `; domain=${domain}` : "";
+}
+function writeChoiceCookie(choice) {
+    try {
+        document.cookie =
+            `${CONSENT_COOKIE_NAME}=${serializeConsent(choice)}; path=/; ` +
+                `max-age=${CONSENT_COOKIE_LIFETIME_SECONDS}; SameSite=Lax${cookieDomain()}`;
+    }
+    catch {
+        // coercion-ok: a sandboxed iframe can't store the choice; it still
+        // applies to this page.
+    }
+}
+let serverChoiceWrites = Promise.resolve();
+let latestChoice = null;
+/**
+ * Safari keeps a cookie page JavaScript wrote for seven days at most, so the
+ * server writes the choice again for its full year. Writes go one at a time
+ * and only the newest is sent. A response for an older choice still sets that
+ * choice's cookie, so the newest is written back over it at once.
+ */
+function storeChoiceOnServer(choice) {
+    latestChoice = choice;
+    if (agentNativeApiDisabledReason() || typeof fetch !== "function")
+        return;
+    serverChoiceWrites = serverChoiceWrites.then(async () => {
+        if (latestChoice !== choice)
+            return;
+        await fetch(agentNativePath(CONSENT_PATH), {
+            method: "POST",
+            credentials: "same-origin",
+            keepalive: true,
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ choice: serializeConsent(choice) }),
+        }).catch(() => {
+            // coercion-ok: the browser's own copy still holds the choice, for
+            // seven days in Safari; the visitor is asked again after that.
+        });
+        if (latestChoice && latestChoice !== choice) {
+            writeChoiceCookie(latestChoice);
+        }
+    });
+}
+function readCachedRegion() {
+    try {
+        const value = window.sessionStorage.getItem(REGION_STORAGE_KEY);
+        return value === "consent" || value === "none" ? value : null;
+    }
+    catch {
+        // coercion-ok: without session storage the region is asked again.
+        return null;
+    }
+}
+function cacheRegion(region) {
+    try {
+        window.sessionStorage.setItem(REGION_STORAGE_KEY, region);
+    }
+    catch {
+        // coercion-ok: without session storage the region is asked again.
+    }
+}
+function timeZoneRegion() {
+    try {
+        const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        return isConsentRegionTimeZone(timeZone) ? "consent" : "none";
+    }
+    catch {
+        // An unreadable zone could be anywhere, so it gets the banner.
+        return "consent";
+    }
+}
+async function fetchRegion() {
+    if (agentNativeApiDisabledReason() || typeof fetch !== "function") {
+        return timeZoneRegion();
+    }
+    try {
+        const response = await fetch(agentNativePath(CONSENT_REGION_PATH), {
+            credentials: "same-origin",
+        });
+        const body = response.ok
+            ? (await response.json())
+            : {};
+        if (body.region === "consent" || body.region === "none") {
+            return body.region;
+        }
+    }
+    catch {
+        // coercion-ok: with no answer from the server, the time zone decides.
+    }
+    return timeZoneRegion();
+}
+/**
+ * Whether this visitor gets the banner: the server's answer from the
+ * request's country, else the browser's time zone. Asked once a session.
+ */
+export function resolveConsentRegion() {
+    const current = state();
+    if (current.region)
+        return Promise.resolve(current.region);
+    const cached = typeof window === "undefined" ? null : readCachedRegion();
+    if (cached) {
+        current.region = cached;
+        // Another app or tab may have stored a reject since this page's waiters
+        // last looked; let them clear what they kept.
+        settle();
+        notify();
+        return Promise.resolve(cached);
+    }
+    return (current.regionPromise ??= fetchRegion().then((region) => {
+        current.region = region;
+        cacheRegion(region);
+        settle();
+        notify();
+        return region;
+    }));
+}
+/** The best answer available now, without waiting for the server. */
+function regionGuess() {
+    const current = state();
+    return current.region ?? readCachedRegion() ?? timeZoneRegion();
+}
+function allows(category, region) {
+    const choice = getConsentChoice();
+    if (choice)
+        return choice[category];
+    return region === "none";
+}
+/**
+ * Whether `category` is allowed right now, on the time zone's guess until the
+ * server answers. Pair it with `whenConsentAllows` and a `revoke` that undoes
+ * whatever this let through.
+ */
+export function consentAllowsNow(category) {
+    if (typeof window === "undefined")
+        return false;
+    if (!state().region)
+        void resolveConsentRegion();
+    return allows(category, regionGuess());
+}
+/**
+ * Whether `category` is allowed, from the visitor's choice or the server's
+ * region; `null` until one of them is known, where `consentAllowsNow` would
+ * guess from the time zone. For what `revoke` can't undo once it's sent.
+ */
+export function consentDecision(category) {
+    if (typeof window === "undefined")
+        return false;
+    const choice = getConsentChoice();
+    if (choice)
+        return choice[category];
+    const region = state().region ?? readCachedRegion();
+    if (region)
+        return region === "none";
+    void resolveConsentRegion();
+    return null;
+}
+/**
+ * Google's tags can't be unloaded, but they follow Consent Mode: a reject
+ * stops what's already on the page from storing or sending identifiers.
+ */
+function updateGoogleConsent(region) {
+    const holder = window;
+    const layers = holder[GOOGLE_CONSENT_LAYERS_KEY];
+    if (!Array.isArray(layers))
+        return;
+    const grant = (category) => allows(category, region) ? "granted" : "denied";
+    const update = {
+        analytics_storage: grant("performance"),
+        ad_storage: grant("targeting"),
+        ad_user_data: grant("targeting"),
+        ad_personalization: grant("targeting"),
+    };
+    for (const name of layers) {
+        if (typeof name !== "string")
+            continue;
+        const layer = (holder[name] ??= []);
+        // gtag reads an `arguments` object from the data layer, never an array.
+        (function gtag(..._args) {
+            layer.push(arguments);
+        })("consent", "update", update);
+    }
+}
+function settle() {
+    const region = state().region;
+    if (region || getConsentChoice())
+        updateGoogleConsent(region);
+    for (const waiter of state().waiters) {
+        const allowed = allows(waiter.category, region);
+        if (allowed && !waiter.ran) {
+            waiter.ran = true;
+            isolate(waiter.run);
+        }
+        else if (!allowed && (region || getConsentChoice())) {
+            // Also clears what an earlier page stored before the banner existed.
+            waiter.ran = false;
+            if (waiter.revoke)
+                isolate(waiter.revoke);
+        }
+    }
+    // A choice stored here or in another tab decides before the region does.
+    if (region || getConsentChoice())
+        releaseHeldForDecision?.(true);
+}
+/**
+ * One callback throwing must not skip the waiters after it, or a later revoke
+ * would never clear what a rejected category stored. Rethrow it on its own task
+ * so it still surfaces.
+ */
+function isolate(callback) {
+    try {
+        callback();
+    }
+    catch (error) {
+        setTimeout(() => {
+            throw error;
+        });
+    }
+}
+function notify() {
+    for (const listener of state().listeners)
+        listener();
+}
+/**
+ * Run `run` once `category` is allowed: at once outside the consent region,
+ * and inside it when the visitor accepts. A later "reject" calls `revoke`.
+ */
+export function whenConsentAllows(category, run, options = {}) {
+    if (typeof window === "undefined")
+        return;
+    const waiter = { category, run, revoke: options.revoke, ran: false };
+    state().waiters.push(waiter);
+    const region = state().region ??
+        readCachedRegion() ??
+        (options.optimistic ? regionGuess() : null);
+    if (allows(category, region)) {
+        waiter.ran = true;
+        isolate(run);
+    }
+    else if (state().region || getConsentChoice()) {
+        // A reject decided before this caller asked still clears what it stored.
+        if (options.revoke)
+            isolate(options.revoke);
+    }
+    if (!state().region)
+        void resolveConsentRegion();
+}
+let heldForDecision = null;
+let releaseHeldForDecision = null;
+/**
+ * Run `send` once the visitor's choice or the server's region is known, so
+ * the time zone's guess never sends what consent covers. `decided` is false
+ * when the page closes first; send then without what consent covers.
+ */
+export function whenConsentDecided(send) {
+    if (consentDecision("performance") !== null) {
+        send(true);
+        return;
+    }
+    if (!heldForDecision) {
+        const held = [];
+        heldForDecision = held;
+        const release = (decided) => {
+            if (heldForDecision !== held)
+                return;
+            heldForDecision = null;
+            releaseHeldForDecision = null;
+            window.removeEventListener("pagehide", onPageHide);
+            for (const run of held)
+                run(decided);
+        };
+        const onPageHide = () => release(false);
+        releaseHeldForDecision = release;
+        window.addEventListener("pagehide", onPageHide);
+        void resolveConsentRegion().then(() => release(true));
+    }
+    heldForDecision.push(send);
+}
+const CONSENT_CHANNEL_NAME = "agent-native-consent";
+let seenChoice = null;
+let consentChannel = null;
+/**
+ * Apply a choice another tab or app stored: at once in other tabs of this
+ * app, and on the next focus for another app on the site.
+ */
+function recheckStoredChoice() {
+    const raw = readCookie(CONSENT_COOKIE_NAME);
+    if (raw === seenChoice)
+        return;
+    seenChoice = raw;
+    state().settingsOpen = false;
+    settle();
+    notify();
+}
+function watchOtherTabs() {
+    if (typeof window === "undefined" || typeof document === "undefined")
+        return;
+    seenChoice = readCookie(CONSENT_COOKIE_NAME);
+    window.addEventListener?.("focus", recheckStoredChoice);
+    document.addEventListener?.("visibilitychange", recheckStoredChoice);
+    if (typeof BroadcastChannel !== "function")
+        return;
+    try {
+        consentChannel = new BroadcastChannel(CONSENT_CHANNEL_NAME);
+        consentChannel.onmessage = recheckStoredChoice;
+    }
+    catch {
+        // coercion-ok: without the channel, other tabs recheck on focus.
+    }
+}
+/** Store the visitor's choice for every app on this site, and apply it. */
+export function setConsentChoice(choice) {
+    if (typeof document === "undefined")
+        return;
+    writeChoiceCookie(choice);
+    storeChoiceOnServer(choice);
+    seenChoice = readCookie(CONSENT_COOKIE_NAME);
+    // Only a browser that won't keep the cookie falls back to this page's
+    // copy; a cookie the visitor clears later means they're asked again.
+    state().pageChoice = seenChoice === null ? choice : null;
+    try {
+        consentChannel?.postMessage("changed");
+    }
+    catch {
+        // coercion-ok: other tabs still recheck on focus.
+    }
+    state().settingsOpen = false;
+    if (!state().region)
+        state().region = "consent";
+    settle();
+    notify();
+}
+/** Reopen the banner so the visitor can change their choice. */
+export function openConsentSettings() {
+    state().settingsOpen = true;
+    notify();
+}
+/** Whether the banner should show now, for the banner component. */
+export function shouldShowConsentBanner() {
+    const current = state();
+    if (current.settingsOpen)
+        return true;
+    return current.region === "consent" && !getConsentChoice();
+}
+export function subscribeConsent(listener) {
+    state().listeners.add(listener);
+    return () => state().listeners.delete(listener);
+}
+/** Run the scripts the page queued before this module loaded. */
+function drainScriptQueue() {
+    if (typeof window === "undefined")
+        return;
+    const holder = window;
+    const queued = holder[SCRIPT_QUEUE_KEY];
+    const push = (...entries) => {
+        for (const [category, run] of entries)
+            whenConsentAllows(category, run);
+        return 0;
+    };
+    holder[SCRIPT_QUEUE_KEY] = { push };
+    if (Array.isArray(queued))
+        push(...queued);
+}
+drainScriptQueue();
+watchOtherTabs();

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

@@ -1,4 +1,5 @@
 export { useOnboarding, type UseOnboardingResult } from "./use-onboarding.js";
+export { useOnboardingChecklist, type UseOnboardingChecklistResult, } from "./use-onboarding-checklist.js";
 export { isFirstRunOnboardingEnabled } from "./first-run-enabled.js";
 export { dispatchFirstRunOnboardingStatus, fetchFirstRunOnboardingStatus, FIRST_RUN_ONBOARDING_STATUS_RESOLVED_EVENT, } from "./first-run-status.js";
 export { useOnboardingPreviewMode, useOnboardingPreviewStep, ONBOARDING_PREVIEW_STORAGE_KEY, ONBOARDING_PREVIEW_QUERY_PARAM, ONBOARDING_PREVIEW_QUERY_VALUE, ONBOARDING_PREVIEW_STEP_QUERY_PARAM, ONBOARDING_PREVIEW_STEPS, getOnboardingPreviewStep, isOnboardingPreviewQuery, } from "./use-preview-mode.js";

package/dist/client/onboarding/index.js

@@ -1,4 +1,5 @@
 export { useOnboarding } from "./use-onboarding.js";
+export { useOnboardingChecklist, } from "./use-onboarding-checklist.js";
 export { isFirstRunOnboardingEnabled } from "./first-run-enabled.js";
 export { dispatchFirstRunOnboardingStatus, fetchFirstRunOnboardingStatus, FIRST_RUN_ONBOARDING_STATUS_RESOLVED_EVENT, } from "./first-run-status.js";
 export { useOnboardingPreviewMode, useOnboardingPreviewStep, ONBOARDING_PREVIEW_STORAGE_KEY, ONBOARDING_PREVIEW_QUERY_PARAM, ONBOARDING_PREVIEW_QUERY_VALUE, ONBOARDING_PREVIEW_STEP_QUERY_PARAM, ONBOARDING_PREVIEW_STEPS, getOnboardingPreviewStep, isOnboardingPreviewQuery, } from "./use-preview-mode.js";

package/dist/client/onboarding/use-onboarding-checklist.d.ts

@@ -0,0 +1,23 @@
+import type { OnboardingStepStatus } from "../../onboarding/types.js";
+export interface UseOnboardingChecklistResult {
+    steps: OnboardingStepStatus[];
+    completeCount: number;
+    totalCount: number;
+    dismissed: boolean;
+    collapsed: boolean;
+    /** `loading` only before the first answer; a refresh keeps the last one. */
+    status: "loading" | "ready" | "error";
+    error: Error | null;
+    refresh: () => Promise<unknown>;
+    dismiss: () => Promise<void>;
+    reopen: () => Promise<void>;
+    setCollapsed: (collapsed: boolean) => Promise<void>;
+}
+/**
+ * Reads one named onboarding checklist (steps registered with
+ * `registerOnboardingStep({ checklist })`). Rows are re-read whenever a local
+ * action or an agent tool finishes, so a step checks itself off after the work
+ * that completes it. Dismissal is stored by the onboarding plugin and the
+ * collapsed state in application state, so both follow the user across devices.
+ */
+export declare function useOnboardingChecklist(checklist: string): UseOnboardingChecklistResult;

package/dist/client/onboarding/use-onboarding-checklist.js

@@ -0,0 +1,115 @@
+import { useMutation, useQuery, useQueryClient, } from "@tanstack/react-query";
+import { useCallback } from "react";
+import { agentNativePath } from "../api-path.js";
+import { readClientAppState, writeClientAppState, } from "../application-state.js";
+import { useChangeVersions } from "../use-change-version.js";
+const CHECKLIST_TIMEOUT_MS = 10_000;
+function summaryKey(checklist) {
+    return ["onboarding-checklist", checklist];
+}
+function collapsedKey(checklist) {
+    return ["onboarding-checklist-collapsed", checklist];
+}
+function collapsedStateKey(checklist) {
+    return `onboarding:collapsed:${checklist}`;
+}
+function checklistUrl(path, checklist) {
+    return agentNativePath(`/_agent-native/onboarding/${path}?checklist=${encodeURIComponent(checklist)}`);
+}
+async function fetchChecklist(checklist, signal) {
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    signal.addEventListener("abort", abort);
+    const timer = setTimeout(abort, CHECKLIST_TIMEOUT_MS);
+    try {
+        const response = await fetch(checklistUrl("summary", checklist), {
+            signal: controller.signal,
+        });
+        if (!response.ok)
+            throw new Error(`checklist: ${response.status}`);
+        const body = (await response.json());
+        return { steps: body.steps, dismissed: !!body.dismissed };
+    }
+    finally {
+        clearTimeout(timer);
+        signal.removeEventListener("abort", abort);
+    }
+}
+async function postChecklist(path, checklist) {
+    const response = await fetch(checklistUrl(path, checklist), {
+        method: "POST",
+    });
+    if (!response.ok)
+        throw new Error(`checklist ${path}: ${response.status}`);
+}
+function patchSummary(queryClient, checklist, patch) {
+    const snapshot = queryClient.getQueriesData({
+        queryKey: summaryKey(checklist),
+    });
+    queryClient.setQueriesData({ queryKey: summaryKey(checklist) }, (current) => (current ? { ...current, ...patch } : current));
+    return snapshot;
+}
+/**
+ * Reads one named onboarding checklist (steps registered with
+ * `registerOnboardingStep({ checklist })`). Rows are re-read whenever a local
+ * action or an agent tool finishes, so a step checks itself off after the work
+ * that completes it. Dismissal is stored by the onboarding plugin and the
+ * collapsed state in application state, so both follow the user across devices.
+ */
+export function useOnboardingChecklist(checklist) {
+    const queryClient = useQueryClient();
+    const changeVersion = useChangeVersions(["action"]);
+    const summary = useQuery({
+        queryKey: [...summaryKey(checklist), changeVersion],
+        queryFn: ({ signal }) => fetchChecklist(checklist, signal),
+        placeholderData: (previous) => previous,
+    });
+    const collapsedQuery = useQuery({
+        queryKey: collapsedKey(checklist),
+        queryFn: async () => {
+            const value = await readClientAppState(collapsedStateKey(checklist));
+            return value?.collapsed === true;
+        },
+        staleTime: Infinity,
+    });
+    const dismissMutation = useMutation({
+        mutationFn: (dismissed) => postChecklist(dismissed ? "dismiss" : "reopen", checklist),
+        onMutate: (dismissed) => ({
+            previous: patchSummary(queryClient, checklist, { dismissed }),
+        }),
+        onError: (_error, _dismissed, context) => {
+            for (const [key, data] of context?.previous ?? []) {
+                queryClient.setQueryData(key, data);
+            }
+        },
+        onSettled: () => queryClient.invalidateQueries({ queryKey: summaryKey(checklist) }),
+    });
+    const collapseMutation = useMutation({
+        mutationFn: (collapsed) => writeClientAppState(collapsedStateKey(checklist), { collapsed }),
+        onMutate: (collapsed) => {
+            const previous = queryClient.getQueryData(collapsedKey(checklist));
+            queryClient.setQueryData(collapsedKey(checklist), collapsed);
+            return { previous };
+        },
+        onError: (_error, _collapsed, context) => {
+            queryClient.setQueryData(collapsedKey(checklist), context?.previous);
+        },
+    });
+    const dismiss = useCallback(() => dismissMutation.mutateAsync(true), [dismissMutation]);
+    const reopen = useCallback(() => dismissMutation.mutateAsync(false), [dismissMutation]);
+    const setCollapsed = useCallback((collapsed) => collapseMutation.mutateAsync(collapsed).then(() => undefined), [collapseMutation]);
+    const steps = summary.data?.steps ?? [];
+    return {
+        steps,
+        completeCount: steps.filter((step) => step.complete).length,
+        totalCount: steps.length,
+        dismissed: summary.data?.dismissed ?? false,
+        collapsed: collapsedQuery.data ?? false,
+        status: summary.data ? "ready" : summary.isError ? "error" : "loading",
+        error: summary.error,
+        refresh: () => queryClient.invalidateQueries({ queryKey: summaryKey(checklist) }),
+        dismiss,
+        reopen,
+        setCollapsed,
+    };
+}

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

@@ -269,6 +269,8 @@ export declare function useResourceSuggestions(params: ListResourceSuggestionsPa
 export declare function useCreateResourceSuggestion(): import("@tanstack/react-query").UseMutationResult<ResourceSuggestion, Error, CreateResourceSuggestionInput, unknown>;
 export declare function useCreateResourceSuggestionProposal(): import("@tanstack/react-query").UseMutationResult<ResourceSuggestionProposalResult, Error, CreateResourceSuggestionProposalInput, unknown>;
 export declare function useDecideResourceSuggestionProposal(): import("@tanstack/react-query").UseMutationResult<ResourceSuggestionProposalResult, Error, DecideResourceSuggestionProposalInput, unknown>;
+/** Shows every listed proposal member as decided until the server answers. */
+export declare function proposalDecisionOverlay(input: DecideResourceSuggestionProposalInput, queryClient: QueryClient): ReviewOptimisticMutation;
 export declare function useDecideResourceSuggestion(): import("@tanstack/react-query").UseMutationResult<{
     suggestion: ResourceSuggestion;
     decision: unknown;

package/dist/client/review/use-review.js

@@ -547,7 +547,34 @@ export function useCreateResourceSuggestionProposal() {
     return useActionMutation("create-resource-suggestion-proposal");
 }
 export function useDecideResourceSuggestionProposal() {
-    return useActionMutation("decide-resource-suggestion-proposal");
+    return useOptimisticReviewMutation("decide-resource-suggestion-proposal", proposalDecisionOverlay);
+}
+/** Shows every listed proposal member as decided until the server answers. */
+export function proposalDecisionOverlay(input, queryClient) {
+    const [first] = input.members;
+    const resource = first && resourceForSuggestion(queryClient, first.id);
+    if (!resource)
+        return noSuggestionOverlay();
+    const memberIds = new Set(input.members.map((member) => member.id));
+    return {
+        action: "list-resource-suggestions",
+        resource,
+        transform: (data, params) => updateSuggestions(data, (suggestions) => suggestions.flatMap((suggestion) => {
+            if (!memberIds.has(suggestion.id))
+                return [suggestion];
+            const next = { ...suggestion, status: input.decision };
+            return matchesSuggestionQuery(params, next) ? [next] : [];
+        })),
+        onSuccess: (result) => (data, params) => {
+            const decided = new Map(result.suggestions.map((suggestion) => [suggestion.id, suggestion]));
+            return updateSuggestions(data, (suggestions) => suggestions.flatMap((suggestion) => {
+                const next = decided.get(suggestion.id);
+                if (!next)
+                    return [suggestion];
+                return matchesSuggestionQuery(params, next) ? [next] : [];
+            }));
+        },
+    };
 }
 export function useDecideResourceSuggestion() {
     return useOptimisticReviewMutation("decide-resource-suggestion", (input, queryClient) => {

package/dist/client/session-replay.d.ts

@@ -64,7 +64,7 @@ export interface SessionReplayOptions {
 }
 export interface SessionReplayStartResult {
     started: boolean;
-    reason?: "disabled" | "not-browser" | "missing-public-key" | "missing-session-id" | "missing-user-id" | "sampled-out" | "url-blocked" | "already-active" | "import-failed" | "record-failed";
+    reason?: "disabled" | "not-browser" | "missing-public-key" | "missing-session-id" | "missing-user-id" | "sampled-out" | "url-blocked" | "already-active" | "import-failed" | "record-failed" | "consent-required";
     replayId?: string;
     sessionId?: string;
     sampled?: boolean;