@agent-native/core 0.202.0-nightly-20261006153106 → 0.202.0

package/dist/client/web-vitals.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Core Web Vitals per page view, measured with the browser's own
+ * PerformanceObserver. A page view is one visible stretch of one route: it
+ * ends when the route changes through `pushState`/`popstate` or the page is
+ * hidden, and a page that becomes visible again starts a new one. TTFB and
+ * LCP belong to the document load only; INP and CLS are measured within each
+ * page view. A metric the browser cannot measure is left out, never zero, and
+ * a page view the manifest has no route for carries no route. No report
+ * carries the page's path, which can hold slugs and emails; `pageview` has it.
+ */
+export type WebVitalsNavigationType = "load" | "client" | "resume";
+export interface PageViewVitals {
+    route?: string;
+    navigationType: WebVitalsNavigationType;
+    ttfbMs?: number;
+    lcpMs?: number;
+    inpMs?: number;
+    cls?: number;
+}
+export interface WebVitalsLocation {
+    route: string | null;
+    pathname: string;
+}
+interface LayoutShiftLike {
+    startTime: number;
+    value: number;
+    hadRecentInput: boolean;
+}
+interface InteractionLike {
+    interactionId?: number;
+    duration: number;
+}
+export interface WebVitalsTrackerOptions {
+    /** Read when a page view ends: whether layout shifts are being observed. */
+    measuresLayoutShift: () => boolean;
+    report: (vitals: PageViewVitals) => void;
+    interactionCount?: () => number | undefined;
+}
+/**
+ * The page-view state machine, separate from the observers that feed it so
+ * the metric rules can be exercised without a browser.
+ */
+export declare function createWebVitalsTracker(options: WebVitalsTrackerOptions): {
+    startLoad(location: WebVitalsLocation, ttfbMs: number | undefined): void;
+    /**
+     * `replace` keeps the page view and moves it to the new route, since
+     * redirects and URL canonicalization replace the entry the person landed
+     * on. Any other change of path is a new page view.
+     */
+    navigate(location: WebVitalsLocation, kind: "push" | "replace"): void;
+    hidden(): void;
+    /** Drops the current page view without reporting it. */
+    discard(): void;
+    visible(location: WebVitalsLocation): void;
+    largestContentfulPaint(startTimeMs: number): void;
+    finalizeLargestContentfulPaint(): void;
+    layoutShift(entry: LayoutShiftLike): void;
+    interaction(entry: InteractionLike): void;
+};
+export type WebVitalsTracker = ReturnType<typeof createWebVitalsTracker>;
+export interface WebVitalsController {
+    navigate(kind: "push" | "replace"): void;
+}
+/**
+ * Starts measuring the current document. Returns null where the browser has
+ * no PerformanceObserver, so no page view is reported as measured.
+ */
+export declare function installWebVitals(locate: () => WebVitalsLocation, report: (vitals: PageViewVitals) => void): WebVitalsController | null;
+export {};

package/dist/client/web-vitals.js

@@ -0,0 +1,288 @@
+/**
+ * Core Web Vitals per page view, measured with the browser's own
+ * PerformanceObserver. A page view is one visible stretch of one route: it
+ * ends when the route changes through `pushState`/`popstate` or the page is
+ * hidden, and a page that becomes visible again starts a new one. TTFB and
+ * LCP belong to the document load only; INP and CLS are measured within each
+ * page view. A metric the browser cannot measure is left out, never zero, and
+ * a page view the manifest has no route for carries no route. No report
+ * carries the page's path, which can hold slugs and emails; `pageview` has it.
+ */
+const CLS_WINDOW_GAP_MS = 1_000;
+const CLS_WINDOW_MAX_MS = 5_000;
+const LONGEST_INTERACTIONS_KEPT = 10;
+const INTERACTIONS_PER_INP_STEP = 50;
+function roundMs(value) {
+    return Math.round(value);
+}
+/**
+ * The page-view state machine, separate from the observers that feed it so
+ * the metric rules can be exercised without a browser.
+ */
+export function createWebVitalsTracker(options) {
+    let current = null;
+    function begin(location, navigationType) {
+        current = {
+            location,
+            navigationType,
+            lcpFinal: navigationType !== "load",
+            cls: 0,
+            windowValue: 0,
+            windowStart: 0,
+            windowLast: 0,
+            shifted: false,
+            longestInteractions: [],
+            interactionIds: new Set(),
+            interactionCountAtStart: options.interactionCount?.(),
+        };
+    }
+    function inp(view) {
+        const longest = view.longestInteractions;
+        if (!longest.length)
+            return undefined;
+        const browserCount = view.interactionCountAtStart === undefined
+            ? undefined
+            : (options.interactionCount?.() ?? 0) - view.interactionCountAtStart;
+        const count = Math.max(browserCount ?? 0, view.interactionIds.size);
+        // The 98th percentile: skip one of the longest per 50 interactions.
+        const index = Math.min(longest.length - 1, Math.floor(count / INTERACTIONS_PER_INP_STEP));
+        return roundMs(longest[index].duration);
+    }
+    function end() {
+        const view = current;
+        current = null;
+        if (!view)
+            return;
+        // Switching back to a tab and away again measured nothing a person
+        // experienced; reporting its CLS of 0 would only dilute the percentiles.
+        if (view.navigationType === "resume" &&
+            !view.shifted &&
+            !view.interactionIds.size) {
+            return;
+        }
+        const vitals = { navigationType: view.navigationType };
+        if (view.location.route)
+            vitals.route = view.location.route;
+        if (view.ttfbMs !== undefined)
+            vitals.ttfbMs = view.ttfbMs;
+        if (view.lcpMs !== undefined)
+            vitals.lcpMs = view.lcpMs;
+        const inpMs = inp(view);
+        if (inpMs !== undefined)
+            vitals.inpMs = inpMs;
+        if (options.measuresLayoutShift()) {
+            vitals.cls = Math.round(view.cls * 10_000) / 10_000;
+        }
+        if (vitals.ttfbMs === undefined &&
+            vitals.lcpMs === undefined &&
+            vitals.inpMs === undefined &&
+            vitals.cls === undefined) {
+            return;
+        }
+        options.report(vitals);
+    }
+    return {
+        startLoad(location, ttfbMs) {
+            begin(location, "load");
+            if (current && ttfbMs !== undefined)
+                current.ttfbMs = roundMs(ttfbMs);
+        },
+        /**
+         * `replace` keeps the page view and moves it to the new route, since
+         * redirects and URL canonicalization replace the entry the person landed
+         * on. Any other change of path is a new page view.
+         */
+        navigate(location, kind) {
+            if (!current)
+                return;
+            if (current.location.pathname === location.pathname)
+                return;
+            if (kind === "replace") {
+                current.location = location;
+                return;
+            }
+            end();
+            begin(location, "client");
+        },
+        hidden() {
+            end();
+        },
+        /** Drops the current page view without reporting it. */
+        discard() {
+            current = null;
+        },
+        visible(location) {
+            if (!current)
+                begin(location, "resume");
+        },
+        largestContentfulPaint(startTimeMs) {
+            if (!current || current.lcpFinal)
+                return;
+            current.lcpMs = roundMs(Math.max(0, startTimeMs));
+        },
+        finalizeLargestContentfulPaint() {
+            if (current)
+                current.lcpFinal = true;
+        },
+        layoutShift(entry) {
+            const view = current;
+            if (!view || entry.hadRecentInput)
+                return;
+            if (view.windowValue > 0 &&
+                entry.startTime - view.windowLast < CLS_WINDOW_GAP_MS &&
+                entry.startTime - view.windowStart < CLS_WINDOW_MAX_MS) {
+                view.windowValue += entry.value;
+            }
+            else {
+                view.windowValue = entry.value;
+                view.windowStart = entry.startTime;
+            }
+            view.windowLast = entry.startTime;
+            view.cls = Math.max(view.cls, view.windowValue);
+            view.shifted = true;
+        },
+        interaction(entry) {
+            const view = current;
+            const id = entry.interactionId;
+            if (!view || !id)
+                return;
+            view.interactionIds.add(id);
+            const longest = view.longestInteractions;
+            const existing = longest.find((item) => item.id === id);
+            if (existing) {
+                existing.duration = Math.max(existing.duration, entry.duration);
+            }
+            else if (longest.length < LONGEST_INTERACTIONS_KEPT ||
+                entry.duration > longest[longest.length - 1].duration) {
+                longest.push({ id, duration: entry.duration });
+            }
+            else {
+                return;
+            }
+            longest.sort((a, b) => b.duration - a.duration);
+            longest.length = Math.min(longest.length, LONGEST_INTERACTIONS_KEPT);
+        },
+    };
+}
+function supportedEntryTypes() {
+    return typeof PerformanceObserver !== "undefined"
+        ? (PerformanceObserver.supportedEntryTypes ?? [])
+        : [];
+}
+function activationStart() {
+    const navigation = performance.getEntriesByType("navigation")[0];
+    return navigation?.activationStart ?? 0;
+}
+function timeToFirstByte() {
+    const navigation = performance.getEntriesByType("navigation")[0];
+    if (!navigation || navigation.responseStart <= 0)
+        return undefined;
+    if (navigation.responseStart > performance.now())
+        return undefined;
+    return Math.max(0, navigation.responseStart - activationStart());
+}
+/**
+ * Starts measuring the current document. Returns null where the browser has
+ * no PerformanceObserver, so no page view is reported as measured.
+ */
+export function installWebVitals(locate, report) {
+    if (typeof window === "undefined" || typeof document === "undefined") {
+        return null;
+    }
+    const types = supportedEntryTypes();
+    if (!types.length)
+        return null;
+    const performanceWithCount = performance;
+    let measuresLayoutShift = false;
+    const tracker = createWebVitalsTracker({
+        measuresLayoutShift: () => measuresLayoutShift,
+        report,
+        interactionCount: () => performanceWithCount.interactionCount,
+    });
+    const prerendering = document
+        .prerendering;
+    let firstHiddenAt = document.visibilityState === "hidden" && !prerendering ? 0 : Infinity;
+    const observers = new Map();
+    /** False when the browser cannot observe `type`, so its metric stays absent. */
+    const observe = (type, handle, init = {}) => {
+        if (!types.includes(type))
+            return false;
+        try {
+            const observer = new PerformanceObserver((list) => handle(list.getEntries()));
+            observer.observe({ type, buffered: true, ...init });
+            observers.set(observer, handle);
+            return true;
+        }
+        catch {
+            // coercion-ok: false tells the caller the type is unobserved.
+            return false;
+        }
+    };
+    const flush = () => {
+        for (const [observer, handle] of observers) {
+            const records = observer.takeRecords();
+            if (records.length)
+                handle(records);
+        }
+    };
+    tracker.startLoad(locate(), timeToFirstByte());
+    // A page loaded in a background tab: nobody saw its load, so it is not a
+    // page view, and what happens once someone switches to it is a resume like
+    // any other. Ending it instead would report its TTFB as a load.
+    if (firstHiddenAt === 0)
+        tracker.discard();
+    const handleLcp = (entries) => {
+        const start = activationStart();
+        for (const entry of entries) {
+            if (entry.startTime < firstHiddenAt) {
+                tracker.largestContentfulPaint(entry.startTime - start);
+            }
+        }
+    };
+    const handleShifts = (entries) => {
+        for (const entry of entries) {
+            tracker.layoutShift(entry);
+        }
+    };
+    const handleInteractions = (entries) => {
+        for (const entry of entries) {
+            tracker.interaction(entry);
+        }
+    };
+    observe("largest-contentful-paint", handleLcp);
+    measuresLayoutShift = observe("layout-shift", handleShifts);
+    observe("event", handleInteractions, { durationThreshold: 16 });
+    observe("first-input", handleInteractions);
+    const finalizeLcp = () => {
+        flush();
+        tracker.finalizeLargestContentfulPaint();
+    };
+    for (const type of ["keydown", "click"]) {
+        window.addEventListener(type, finalizeLcp, { capture: true, once: true });
+    }
+    const pageHidden = () => {
+        flush();
+        tracker.finalizeLargestContentfulPaint();
+        tracker.hidden();
+    };
+    document.addEventListener("visibilitychange", (event) => {
+        if (document.visibilityState === "hidden") {
+            firstHiddenAt = Math.min(firstHiddenAt, event.timeStamp);
+            pageHidden();
+        }
+        else {
+            tracker.visible(locate());
+        }
+    }, { capture: true });
+    window.addEventListener("pagehide", pageHidden, { capture: true });
+    window.addEventListener("pageshow", (event) => {
+        if (event.persisted)
+            tracker.visible(locate());
+    }, { capture: true });
+    return {
+        navigate(kind) {
+            flush();
+            tracker.navigate(locate(), kind);
+        },
+    };
+}

package/dist/collab/routes.d.ts

@@ -8,8 +8,8 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
     state: string;
 }>>;
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/file-upload/actions/upload-image.d.ts

@@ -42,8 +42,8 @@ declare const _default: import("../../action.js").ActionDefinition<{
     url: string;
     id: string;
     provider: string;
-    configured?: undefined;
     error?: undefined;
+    configured?: undefined;
 } | {
     url?: undefined;
     id?: undefined;

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

@@ -49,6 +49,8 @@ export interface MCPConfig {
         connectorCatalog: string[];
         instructions?: string;
         widgets?: boolean;
+        widgetDomain?: string;
+        widgetDiagnostic?: "tiny-html" | "no-frame-domains";
         keyToolNames?: readonly string[];
         toolDescriptions?: Record<string, string>;
         toolParameterDescriptions?: Record<string, Record<string, string>>;