@agent-native/core 0.176.1 → 0.176.2-nightly-20260831185956

package/dist/server/origin-allowlist.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Exact public origins configured for this deployment.
+ *
+ * OAuth redirect construction and Better Auth's browser-origin checks must use
+ * the same set so an intentional host alias is accepted by both subsystems.
+ */
+export declare const EXPLICIT_PUBLIC_ORIGIN_ENV_KEYS: readonly ["WORKSPACE_OAUTH_ORIGIN", "VITE_WORKSPACE_OAUTH_ORIGIN", "APP_URL", "VITE_APP_URL", "BETTER_AUTH_URL", "VITE_BETTER_AUTH_URL", "URL", "DEPLOY_URL"];
+export declare const WORKSPACE_GATEWAY_ORIGIN_ENV_KEYS: readonly ["WORKSPACE_GATEWAY_URL", "VITE_WORKSPACE_GATEWAY_URL"];
+export declare function normalizeOrigin(raw: string | undefined): string | undefined;
+export declare function isLoopbackHost(host: string | undefined): boolean;
+export declare function isLoopbackOrigin(origin: string | undefined): boolean;
+export declare function firstOriginFromEnv(keys: readonly string[], options: {
+    allowLoopback: boolean;
+}): string | undefined;
+export declare function getConfiguredOriginAllowlist(): Set<string>;

package/dist/server/origin-allowlist.js

@@ -0,0 +1,93 @@
+/**
+ * Exact public origins configured for this deployment.
+ *
+ * OAuth redirect construction and Better Auth's browser-origin checks must use
+ * the same set so an intentional host alias is accepted by both subsystems.
+ */
+export const EXPLICIT_PUBLIC_ORIGIN_ENV_KEYS = [
+    "WORKSPACE_OAUTH_ORIGIN",
+    "VITE_WORKSPACE_OAUTH_ORIGIN",
+    "APP_URL",
+    "VITE_APP_URL",
+    "BETTER_AUTH_URL",
+    "VITE_BETTER_AUTH_URL",
+    "URL",
+    "DEPLOY_URL",
+];
+export const WORKSPACE_GATEWAY_ORIGIN_ENV_KEYS = [
+    "WORKSPACE_GATEWAY_URL",
+    "VITE_WORKSPACE_GATEWAY_URL",
+];
+const BETTER_AUTH_TRUSTED_ORIGINS_ENV_KEY = "BETTER_AUTH_TRUSTED_ORIGINS";
+export function normalizeOrigin(raw) {
+    const value = raw?.trim();
+    if (!value || value.includes("*"))
+        return undefined;
+    try {
+        const u = new URL(value);
+        if (u.protocol !== "http:" && u.protocol !== "https:")
+            return undefined;
+        if (u.username || u.password)
+            return undefined;
+        return `${u.protocol}//${u.host}`;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function isLoopbackHost(host) {
+    if (!host)
+        return false;
+    try {
+        const parsed = new URL(`http://${host}`);
+        return (parsed.hostname === "localhost" ||
+            parsed.hostname === "127.0.0.1" ||
+            parsed.hostname === "::1" ||
+            parsed.hostname === "[::1]");
+    }
+    catch {
+        return false;
+    }
+}
+export function isLoopbackOrigin(origin) {
+    if (!origin)
+        return false;
+    try {
+        return isLoopbackHost(new URL(origin).host);
+    }
+    catch {
+        return false;
+    }
+}
+function addNormalizedOrigin(out, raw, options) {
+    const origin = normalizeOrigin(raw);
+    if (!origin)
+        return;
+    if (!options.allowLoopback && isLoopbackOrigin(origin))
+        return;
+    out.add(origin);
+}
+export function firstOriginFromEnv(keys, options) {
+    for (const key of keys) {
+        const origin = normalizeOrigin(process.env[key]);
+        if (!origin)
+            continue;
+        if (!options.allowLoopback && isLoopbackOrigin(origin))
+            continue;
+        return origin;
+    }
+    return undefined;
+}
+export function getConfiguredOriginAllowlist() {
+    const out = new Set();
+    for (const key of EXPLICIT_PUBLIC_ORIGIN_ENV_KEYS) {
+        addNormalizedOrigin(out, process.env[key], { allowLoopback: true });
+    }
+    for (const origin of (process.env[BETTER_AUTH_TRUSTED_ORIGINS_ENV_KEY] ?? "").split(",")) {
+        addNormalizedOrigin(out, origin, { allowLoopback: true });
+    }
+    for (const key of WORKSPACE_GATEWAY_ORIGIN_ENV_KEYS) {
+        addNormalizedOrigin(out, process.env[key], { allowLoopback: false });
+    }
+    return out;
+}

package/dist/server/realtime-token.d.ts

@@ -26,8 +26,8 @@ export declare function createRealtimeTokenHandler(): import("h3").EventHandlerW
     expiresAt?: undefined;
     ttlSeconds?: undefined;
 } | {
+    error?: undefined;
     token: string;
     expiresAt: string;
     ttlSeconds: number;
-    error?: undefined;
 }>>;

package/dist/server/release-migrations.js

@@ -3,7 +3,9 @@ import { AGENT_HARNESS_SESSION_MIGRATIONS, AGENT_HARNESS_SESSION_MIGRATIONS_TABL
 import { OBSERVATIONAL_MEMORY_MIGRATIONS } from "../agent/observational-memory/migrations.js";
 import { AGENT_RUN_MIGRATIONS, AGENT_RUN_MIGRATIONS_TABLE, } from "../agent/run-migrations.js";
 import { AGENT_TOOL_APPROVAL_MIGRATIONS, AGENT_TOOL_APPROVAL_MIGRATIONS_TABLE, } from "../agent/tool-approval-migrations.js";
+import { getAppConfig } from "../app-config/index.js";
 import { CHAT_THREAD_SCHEMA_MIGRATIONS, CHAT_THREAD_SCHEMA_MIGRATIONS_TABLE, } from "../chat-threads/schema-migrations.js";
+import { getDatabaseUrl, isLocalDatabase } from "../db/client.js";
 import { runMigrations } from "../db/migrations.js";
 import { REMOTE_DEVICE_MIGRATIONS, REMOTE_DEVICE_MIGRATIONS_TABLE, } from "../integrations/remote-device-migrations.js";
 import { runAutomationRunMigrations } from "../jobs/run-history.js";
@@ -15,6 +17,51 @@ import { WORKSPACE_CONNECTIONS_MIGRATIONS, WORKSPACE_CONNECTIONS_MIGRATIONS_TABL
 import { runBetterAuthMigrations } from "./better-auth-migrations.js";
 import { IDENTITY_SSO_MIGRATIONS } from "./identity-sso-migrations.js";
 import { runFrameworkSchemaEnsures } from "./release-schema.js";
+/**
+ * A release deploy whose `DATABASE_URL` resolves to a local SQLite file
+ * migrated nothing: the file dies with the build container while the deployed
+ * functions keep talking to the real database. Every later signal still reports
+ * success — `Applied migration ...` lines, a zero exit, a published deploy — so
+ * this has to fail here or it fails silently forever. CRM shipped this way and
+ * served 500s on every write because its `jwks`/`user` tables were never
+ * created on the database its functions actually use.
+ *
+ * Scoped to `CONTEXT=production` on purpose. The beta lane deliberately builds
+ * with `AGENT_NATIVE_RUN_RELEASE_MIGRATIONS=1` under a branch-deploy context
+ * against masked site secrets, and its databases are migrated by their
+ * production twin — so keying off that flag would fail every beta deploy while
+ * never guarding the production one this exists for.
+ */
+function assertReleaseMigrationTargetsRemoteDatabase() {
+    if (getAppConfig().migration.deployContext !== "production")
+        return;
+    const url = getDatabaseUrl();
+    // `isLocalDatabase()` alone is not enough. Netlify hands the CLI a MASKED
+    // secret ("****************uire") outside its own build infra, and that is
+    // neither empty nor a `file:` URL — so it reads as "not local" while being
+    // unconnectable, and the driver falls back to a local SQLite file anyway.
+    // Factory published green off exactly that, having applied 93 migrations to
+    // a file that died with the build container. Require a real scheme too.
+    if (!isLocalDatabase() && url.includes("://"))
+        return;
+    throw new Error(`Release migrations resolved to an unusable database (${describeReleaseMigrationUrl(url)}). ` +
+        "In a production deploy the schema must be applied to the same remote " +
+        "database the deployed functions use; migrating a local or unconnectable " +
+        "URL succeeds silently and publishes a site whose database never received " +
+        "the schema. Supply the site's real DATABASE_URL to the deploy step. Note " +
+        "NETLIFY_DATABASE_URL and NETLIFY_DATABASE_URL_UNPOOLED take precedence " +
+        "over DATABASE_URL in the deploy build command, so a masked value in " +
+        "either of those overrides a correct DATABASE_URL.");
+}
+/** Describes the URL shape without ever echoing a credential into build logs. */
+function describeReleaseMigrationUrl(url) {
+    if (!url)
+        return "unset";
+    if (url.startsWith("file:"))
+        return "local file";
+    const scheme = url.includes("://") ? url.split("://")[0] : undefined;
+    return scheme ? `${scheme} url` : "no scheme — likely a masked secret";
+}
 /**
  * Apply framework-owned schema in one explicit release step.
  *
@@ -23,6 +70,7 @@ import { runFrameworkSchemaEnsures } from "./release-schema.js";
  * private schema from being silently coupled to every framework deployment.
  */
 export async function runFrameworkReleaseMigrations(nitroApp) {
+    assertReleaseMigrationTargetsRemoteDatabase();
     // First: the versioned migration lists below only cover the tables that have
     // one. Most framework tables are defined by their store's `ensureTable()`,
     // which production serverless can never run — see `./release-schema.ts`.

package/dist/server/request-context.d.ts

@@ -94,6 +94,8 @@ export interface RequestRunContext {
     }>;
 }
 export interface RequestContext {
+    /** True for synthetic browser checks whose telemetry must not be recorded. */
+    isSyntheticTraffic?: boolean;
     userEmail?: string;
     userName?: string;
     orgId?: string;

package/dist/server/request-context.js

@@ -111,10 +111,15 @@ export function addRequestContextObserver(observer) {
  * isolation-scoped backends (Sentry, OpenTelemetry, etc.).
  */
 export function runWithRequestContext(ctx, fn) {
-    if (ctx.run?.allowedActionNames !== undefined) {
+    const inheritedSyntheticTraffic = als.getStore()?.isSyntheticTraffic;
+    const context = ctx.isSyntheticTraffic === undefined &&
+        inheritedSyntheticTraffic !== undefined
+        ? { ...ctx, isSyntheticTraffic: inheritedSyntheticTraffic }
+        : ctx;
+    if (context.run?.allowedActionNames !== undefined) {
         assertRequestActionSurfaceIsolation();
     }
-    return als.run(ctx, () => {
+    return als.run(context, () => {
         if (observers.length > 0) {
             for (const obs of observers) {
                 try {

package/dist/server/self-dispatch.js

@@ -1,6 +1,7 @@
 import { getAppConfig } from "../app-config/index.js";
 import { isLocalDatabase } from "../db/client.js";
 import { signInternalToken } from "../integrations/internal-token.js";
+import { SYNTHETIC_TRAFFIC_BETA_E2E, SYNTHETIC_TRAFFIC_HEADER, } from "../shared/test-traffic.js";
 /**
  * Shared self-dispatch helper for the framework's serverless background-work
  * pattern: enqueue a unit of work to SQL, then fire a fresh HTTP POST back to
@@ -24,6 +25,7 @@ import { signInternalToken } from "../integrations/internal-token.js";
  * implementation.
  */
 import { getConfiguredAppBasePath, withConfiguredAppBasePath, } from "./app-base-path.js";
+import { getRequestContext } from "./request-context.js";
 /**
  * On serverless, returning from the dispatching handler before the outbound
  * TCP handshake starts can freeze the function with the dispatch request stuck
@@ -130,6 +132,9 @@ export async function fireInternalDispatch(options) {
     const headers = {
         "Content-Type": "application/json",
     };
+    if (getRequestContext()?.isSyntheticTraffic === true) {
+        headers[SYNTHETIC_TRAFFIC_HEADER] = SYNTHETIC_TRAFFIC_BETA_E2E;
+    }
     try {
         headers["Authorization"] = `Bearer ${signInternalToken(options.taskId)}`;
     }

package/dist/server/sentry.js

@@ -19,6 +19,7 @@
 import * as Sentry from "@sentry/node";
 import { resolveDeployEnvironment, resolveServerRelease, } from "./deploy-environment.js";
 import { errorSignalFromSentryEvent, shouldReportErrorSignal, } from "./error-noise-filter.js";
+import { getRequestContext } from "./request-context.js";
 import { resolveServerSentryDsn } from "./sentry-config.js";
 let _initStarted = false;
 let _initSucceeded = false;
@@ -202,6 +203,8 @@ export function setSentryRequestContext(ctx) {
  * this just records the error for observability.
  */
 export function captureAuthError(error, context) {
+    if (getRequestContext()?.isSyntheticTraffic)
+        return undefined;
     if (!_initSucceeded)
         return undefined;
     try {
@@ -227,6 +230,8 @@ export function captureAuthError(error, context) {
  * succeeded, otherwise `undefined`.
  */
 export function captureRouteError(error, context = {}) {
+    if (getRequestContext()?.isSyntheticTraffic)
+        return undefined;
     if (!_initSucceeded)
         return undefined;
     try {

package/dist/server/ssr-handler.js

@@ -20,9 +20,11 @@ import { createRequestHandler } from "react-router";
 import { isMcpPublicPath } from "../mcp/route-paths.js";
 import { DEFAULT_SPECULATION_RULES_PATH, resolveSsrCacheHeaders, resolveSsrCacheKeyHeaders, SSR_QUERY_CACHE_KEY_HEADER, } from "../shared/cache-control.js";
 import { AGENT_NATIVE_SOCIAL_IMAGE_ALT, AGENT_NATIVE_SOCIAL_IMAGE_HEIGHT, AGENT_NATIVE_SOCIAL_IMAGE_PATH, AGENT_NATIVE_SOCIAL_IMAGE_TYPE, AGENT_NATIVE_SOCIAL_IMAGE_WIDTH, withAgentNativeSocialImageCacheBuster, } from "../shared/social-meta.js";
+import { getSsrAuthRedirectScript } from "../shared/ssr-auth-redirect.js";
 import { getAppBasePathFromViteEnv, stripAppBasePath as canonicalStripAppBasePath, } from "./app-base-path.js";
 import { getAppOriginClientConfigScript } from "./app-origin-config.js";
 import { captureError } from "./capture-error.js";
+import { frameworkSessionHintCookieName, resolveAuthCookieNamespace, } from "./cookie-namespace.js";
 import { getPostHogClientConfigScript } from "./posthog-config.js";
 import { runWithRequestContext } from "./request-context.js";
 import { getRealtimeClientConfigScript, getSentryClientConfigScript, } from "./sentry-config.js";
@@ -336,6 +338,9 @@ async function rewriteMountedResponse(response, basePath, pathname, requestUrl)
         getPostHogClientConfigScript(),
         getRealtimeClientConfigScript(),
         getAppOriginClientConfigScript(),
+        pathname === "/"
+            ? getSsrAuthRedirectScript(frameworkSessionHintCookieName(resolveAuthCookieNamespace().frameworkCookieName))
+            : null,
     ]
         .filter(Boolean)
         .join("") || null;

package/dist/server/workspace-provider-oauth.d.ts

@@ -5,6 +5,7 @@ export type GenericWorkspaceOAuthProvider = "figma" | "gmail" | "google_calendar
 export type WorkspaceProviderOAuthScope = "user" | "organization" | "app";
 export declare function isWorkspaceProviderOAuthScope(value: unknown): value is WorkspaceProviderOAuthScope;
 export declare function isGoogleWorkspaceOAuthProvider(provider: string): boolean;
+export declare function shouldUseRootGoogleOAuthCallback(provider: GenericWorkspaceOAuthProvider): boolean;
 export declare function hasWorkspaceProviderOAuthCredentials(provider: GenericWorkspaceOAuthProvider): Promise<boolean>;
 export interface WorkspaceProviderOAuthFlow {
     provider: GenericWorkspaceOAuthProvider;
@@ -64,6 +65,14 @@ type WorkspaceProviderIdentity = {
     scopes?: string[];
     config?: Record<string, unknown>;
 };
+export declare function workspaceProviderOAuthFlowInvalidReason(input: {
+    flow: WorkspaceProviderOAuthFlow;
+    state: OAuthStatePayload;
+    provider: GenericWorkspaceOAuthProvider;
+    sessionEmail: string;
+    sessionOrgId?: string;
+    now?: number;
+}): string | undefined;
 export declare function isWorkspaceProviderOAuthFlowValid(input: {
     flow: WorkspaceProviderOAuthFlow;
     state: OAuthStatePayload;

package/dist/server/workspace-provider-oauth.js

@@ -11,7 +11,6 @@ import { getSession, redirectWithStagedCookies, safeReturnPath, } from "./auth.j
 import { resolveSecret } from "./credential-provider.js";
 import { decodeOAuthState, encodeOAuthState, getAppUrl, oauthErrorPage, resolveOAuthRedirectUri, } from "./google-oauth.js";
 import { runWithRequestContext } from "./request-context.js";
-import { isWorkspaceOAuthCallbackRelayEnabled } from "./workspace-oauth.js";
 const SUPPORTED_PROVIDERS = new Set([
     "figma",
     "gmail",
@@ -44,10 +43,35 @@ export function isGoogleWorkspaceOAuthProvider(provider) {
         provider === "google_sheets" ||
         provider === "google_slides");
 }
+export function shouldUseRootGoogleOAuthCallback(provider) {
+    return isGoogleWorkspaceOAuthProvider(provider);
+}
 export async function hasWorkspaceProviderOAuthCredentials(provider) {
     const [clientId, clientSecret] = await resolveProviderClientCredentials(provider);
     return Boolean(clientId && clientSecret);
 }
+function isWorkspaceProviderOAuthFlow(value) {
+    const flow = record(value);
+    return Boolean(flow &&
+        typeof flow.provider === "string" &&
+        SUPPORTED_PROVIDERS.has(flow.provider) &&
+        typeof flow.flowId === "string" &&
+        flow.flowId.length > 0 &&
+        typeof flow.verifier === "string" &&
+        flow.verifier.length > 0 &&
+        typeof flow.redirectUri === "string" &&
+        flow.redirectUri.length > 0 &&
+        typeof flow.owner === "string" &&
+        flow.owner.length > 0 &&
+        (flow.orgId === undefined || typeof flow.orgId === "string") &&
+        typeof flow.appId === "string" &&
+        flow.appId.length > 0 &&
+        isWorkspaceProviderOAuthScope(flow.scope) &&
+        (flow.salesforceLoginUrl === undefined ||
+            typeof flow.salesforceLoginUrl === "string") &&
+        typeof flow.expiresAt === "number" &&
+        Number.isFinite(flow.expiresAt));
+}
 export function workspaceProviderOAuthPath(provider, phase) {
     return `/_agent-native/connections/oauth/${provider}/${phase}`;
 }
@@ -105,11 +129,10 @@ export async function handleWorkspaceProviderOAuthStart(event, providerId) {
     if (providerId === "salesforce" && !salesforceLoginUrl) {
         return oauthFlowFailure(event, 400, "Salesforce environment must be production or sandbox.");
     }
-    const useRootGoogleCallback = isWorkspaceOAuthCallbackRelayEnabled() &&
-        isGoogleWorkspaceOAuthProvider(providerId);
+    const useRootGoogleCallback = shouldUseRootGoogleOAuthCallback(providerId);
     const redirectUri = resolveOAuthRedirectUri(event, useRootGoogleCallback
         ? "/_agent-native/google/callback"
-        : workspaceProviderOAuthPath(providerId, "callback"));
+        : workspaceProviderOAuthPath(providerId, "callback"), { allowRootCallback: useRootGoogleCallback });
     if (!redirectUri) {
         return oauthFlowFailure(event, 400, "Invalid OAuth redirect URI.");
     }
@@ -193,10 +216,11 @@ export async function handleWorkspaceProviderOAuthCallback(event, providerId) {
     const session = await getSession(event).catch(() => null);
     if (!session?.email)
         return unauthorized(event);
-    const flow = readStoredFlow(event, providerId);
-    if (!flow || !isWorkspaceProviderOAuthScope(flow.scope)) {
-        return oauthFlowFailure(event, 400, "OAuth state is invalid or expired.");
+    const storedFlow = readStoredFlow(event, providerId);
+    if (!storedFlow.flow) {
+        return oauthFlowFailure(event, 400, `OAuth flow cookie ${storedFlow.reason}.`);
     }
+    const flow = storedFlow.flow;
     const orgContext = await requireWorkspaceProviderOAuthAccess(event, flow.appId, flow.scope);
     if (!orgContext) {
         return oauthFlowFailure(event, 403, WORKSPACE_OAUTH_ADMIN_ERROR);
@@ -217,15 +241,15 @@ export async function handleWorkspaceProviderOAuthCallback(event, providerId) {
     }
     deleteCookie(event, flowCookieName(providerId), { path: "/" });
     const state = decodeOAuthState(stateParam, "");
-    if (!flow ||
-        !isWorkspaceProviderOAuthFlowValid({
-            flow,
-            state,
-            provider: providerId,
-            sessionEmail: session.email,
-            sessionOrgId: orgId,
-        })) {
-        return oauthFlowFailure(event, 400, "OAuth state is invalid or expired.");
+    const stateError = workspaceProviderOAuthFlowInvalidReason({
+        flow,
+        state,
+        provider: providerId,
+        sessionEmail: session.email,
+        sessionOrgId: orgId,
+    });
+    if (stateError) {
+        return oauthFlowFailure(event, 400, `OAuth state rejected: ${stateError}. Start the connection again.`);
     }
     const provider = requiredProvider(providerId);
     return runWithRequestContext({ userEmail: session.email, orgId }, async () => {
@@ -662,27 +686,68 @@ function requiredProvider(providerId) {
 function readStoredFlow(event, provider) {
     const encrypted = getCookie(event, flowCookieName(provider));
     if (!encrypted)
-        return null;
+        return { flow: null, reason: "is missing" };
+    let decrypted;
     try {
-        return JSON.parse(decryptSecretValue(encrypted));
+        decrypted = decryptSecretValue(encrypted);
     }
     catch {
-        return null;
+        return { flow: null, reason: "could not be decrypted" };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(decrypted);
+    }
+    catch {
+        return { flow: null, reason: "is malformed" };
+    }
+    const parsedRecord = record(parsed);
+    if (parsedRecord && !isWorkspaceProviderOAuthScope(parsedRecord.scope)) {
+        return { flow: null, reason: "has an invalid scope" };
+    }
+    return isWorkspaceProviderOAuthFlow(parsed)
+        ? { flow: parsed, reason: "is valid" }
+        : { flow: null, reason: "is malformed" };
+}
+export function workspaceProviderOAuthFlowInvalidReason(input) {
+    if (!Number.isFinite(input.flow.expiresAt)) {
+        return "flow expiry is invalid";
+    }
+    if (input.flow.expiresAt < (input.now ?? Date.now()))
+        return "flow expired";
+    if (input.flow.provider !== input.provider)
+        return "provider mismatch";
+    if (!input.state.flowId) {
+        return "state is missing, malformed, or has an invalid signature";
+    }
+    if (input.state.flowId !== input.flow.flowId) {
+        return "state does not match the OAuth flow";
+    }
+    if (input.state.redirectUri !== input.flow.redirectUri) {
+        return "redirect URI mismatch";
+    }
+    if (input.state.owner !== input.flow.owner)
+        return "state owner mismatch";
+    if (input.state.scope !== input.flow.scope)
+        return "state scope mismatch";
+    if (input.state.provider !== undefined &&
+        input.state.provider !== input.provider) {
+        return "state provider mismatch";
+    }
+    if (input.sessionEmail !== input.flow.owner)
+        return "session owner mismatch";
+    if (input.state.orgId !== input.flow.orgId) {
+        return "state organization mismatch";
+    }
+    if (input.sessionOrgId !== input.flow.orgId) {
+        return "session organization mismatch";
     }
+    if (input.state.app !== input.flow.appId)
+        return "state app mismatch";
+    return undefined;
 }
 export function isWorkspaceProviderOAuthFlowValid(input) {
-    return (input.flow.expiresAt >= (input.now ?? Date.now()) &&
-        input.flow.provider === input.provider &&
-        input.state.flowId === input.flow.flowId &&
-        input.state.redirectUri === input.flow.redirectUri &&
-        input.state.owner === input.flow.owner &&
-        input.state.scope === input.flow.scope &&
-        (input.state.provider === undefined ||
-            input.state.provider === input.provider) &&
-        input.sessionEmail === input.flow.owner &&
-        input.state.orgId === input.flow.orgId &&
-        input.sessionOrgId === input.flow.orgId &&
-        input.state.app === input.flow.appId);
+    return workspaceProviderOAuthFlowInvalidReason(input) === undefined;
 }
 export function canConnectWorkspaceProviderOAuth(orgId, role) {
     return Boolean(orgId) && (role === "owner" || role === "admin");

package/dist/shared/index.d.ts

@@ -17,6 +17,8 @@ export { DISPATCH_WORKSPACE_ROOT_REDIRECTS, RESERVED_WORKSPACE_APP_IDS, assertVa
 export { DEFAULT_WORKSPACE_APP_AUDIENCE, WORKSPACE_APP_AUDIENCES, normalizeWorkspaceAppAudience, normalizeWorkspaceAppPathList, workspaceAppAudienceFromEnv, workspaceAppAudienceFromPackageJson, workspaceAppRouteAccessFromEnv, workspaceAppRouteAccessFromPackageJson, type WorkspaceAppRouteAccess, type WorkspaceAppRouteAccessFromConfig, type WorkspaceAppAudience, } from "./workspace-app-audience.js";
 export { AGENT_NATIVE_OPEN_PATH, AGENT_SIDEBAR_QUERY_PARAM, AGENT_SIDEBAR_QUERY_VALUE_CLOSED, AGENT_SIDEBAR_QUERY_VALUE_OPEN, isAgentNativeOpenDeepLink, withCollapsedAgentSidebarParam, } from "./agent-sidebar-url.js";
 export { buildChatFirstAppCreationPrompt, titleFromChatFirstAppPrompt, type ChatFirstAppCreationPromptInput, type ChatFirstAppCreationResource, type ChatFirstAppCreationVaultAccessMode, } from "./chat-first-app-creation.js";
+export { isQaTestEmail } from "./qa-test-email.js";
+export { SYNTHETIC_TRAFFIC_BETA_E2E, SYNTHETIC_TRAFFIC_HEADER, isSyntheticTrafficValue, } from "./test-traffic.js";
 export { NATIVE_AUTH_COPY, resolveNativeAuthCopy, type NativeAuthCopy, } from "./auth-copy.js";
 export { createPollEngine, type PollEngineOptions, type PollEngineHandle, } from "./poll-engine.js";
 export { AGENT_NATIVE_DEFAULT_SOCIAL_IMAGE, AGENT_NATIVE_SOCIAL_IMAGE_CACHE_BUSTER, AGENT_NATIVE_SOCIAL_IMAGE_ALT, AGENT_NATIVE_SOCIAL_IMAGE_HEIGHT, AGENT_NATIVE_SOCIAL_IMAGE_PATH, AGENT_NATIVE_SOCIAL_IMAGE_TYPE, AGENT_NATIVE_SOCIAL_IMAGE_WIDTH, defaultSocialImageMeta, withAgentNativeSocialImageCacheBuster, withDefaultSocialImage, type SocialMetaDescriptor, } from "./social-meta.js";

package/dist/shared/index.js

@@ -17,6 +17,8 @@ export { DISPATCH_WORKSPACE_ROOT_REDIRECTS, RESERVED_WORKSPACE_APP_IDS, assertVa
 export { DEFAULT_WORKSPACE_APP_AUDIENCE, WORKSPACE_APP_AUDIENCES, normalizeWorkspaceAppAudience, normalizeWorkspaceAppPathList, workspaceAppAudienceFromEnv, workspaceAppAudienceFromPackageJson, workspaceAppRouteAccessFromEnv, workspaceAppRouteAccessFromPackageJson, } from "./workspace-app-audience.js";
 export { AGENT_NATIVE_OPEN_PATH, AGENT_SIDEBAR_QUERY_PARAM, AGENT_SIDEBAR_QUERY_VALUE_CLOSED, AGENT_SIDEBAR_QUERY_VALUE_OPEN, isAgentNativeOpenDeepLink, withCollapsedAgentSidebarParam, } from "./agent-sidebar-url.js";
 export { buildChatFirstAppCreationPrompt, titleFromChatFirstAppPrompt, } from "./chat-first-app-creation.js";
+export { isQaTestEmail } from "./qa-test-email.js";
+export { SYNTHETIC_TRAFFIC_BETA_E2E, SYNTHETIC_TRAFFIC_HEADER, isSyntheticTrafficValue, } from "./test-traffic.js";
 export { NATIVE_AUTH_COPY, resolveNativeAuthCopy, } from "./auth-copy.js";
 export { createPollEngine, } from "./poll-engine.js";
 export { AGENT_NATIVE_DEFAULT_SOCIAL_IMAGE, AGENT_NATIVE_SOCIAL_IMAGE_CACHE_BUSTER, AGENT_NATIVE_SOCIAL_IMAGE_ALT, AGENT_NATIVE_SOCIAL_IMAGE_HEIGHT, AGENT_NATIVE_SOCIAL_IMAGE_PATH, AGENT_NATIVE_SOCIAL_IMAGE_TYPE, AGENT_NATIVE_SOCIAL_IMAGE_WIDTH, defaultSocialImageMeta, withAgentNativeSocialImageCacheBuster, withDefaultSocialImage, } from "./social-meta.js";

package/dist/shared/loading-labels.d.ts

@@ -0,0 +1 @@
+export declare const LOADING_LABELS: readonly ["Churning", "Accomplishing", "Actioning", "Actualizing", "Architecting", "Baking", "Befuddling", "Booping", "Brewing", "Calculating", "Canoodling", "Cerebrating", "Clauding", "Cogitating", "Combobulating", "Concocting", "Considering", "Cooking", "Crafting", "Creating", "Crystallizing", "Deciphering", "Discombobulating", "Doodling", "Finagling", "Flibbertigibbeting", "Generating", "Gesticulating", "Hatching", "Hullaballooing", "Ideating", "Lollygagging", "Manifesting", "Meandering", "Mulling", "Noodling", "Percolating", "Pondering", "Pontificating", "Puzzling", "Razzmatazzing", "Recombobulating", "Ruminating", "Sautéing", "Schlepping", "Spelunking", "Tinkering", "Tomfoolering", "Topsy-turvying", "Vibing", "Wibbling", "Wrangling", "Zigzagging"];

package/dist/shared/loading-labels.js

@@ -0,0 +1,55 @@
+export const LOADING_LABELS = [
+    "Churning",
+    "Accomplishing",
+    "Actioning",
+    "Actualizing",
+    "Architecting",
+    "Baking",
+    "Befuddling",
+    "Booping",
+    "Brewing",
+    "Calculating",
+    "Canoodling",
+    "Cerebrating",
+    "Clauding",
+    "Cogitating",
+    "Combobulating",
+    "Concocting",
+    "Considering",
+    "Cooking",
+    "Crafting",
+    "Creating",
+    "Crystallizing",
+    "Deciphering",
+    "Discombobulating",
+    "Doodling",
+    "Finagling",
+    "Flibbertigibbeting",
+    "Generating",
+    "Gesticulating",
+    "Hatching",
+    "Hullaballooing",
+    "Ideating",
+    "Lollygagging",
+    "Manifesting",
+    "Meandering",
+    "Mulling",
+    "Noodling",
+    "Percolating",
+    "Pondering",
+    "Pontificating",
+    "Puzzling",
+    "Razzmatazzing",
+    "Recombobulating",
+    "Ruminating",
+    "Sautéing",
+    "Schlepping",
+    "Spelunking",
+    "Tinkering",
+    "Tomfoolering",
+    "Topsy-turvying",
+    "Vibing",
+    "Wibbling",
+    "Wrangling",
+    "Zigzagging",
+];

package/dist/shared/qa-test-email.d.ts

@@ -0,0 +1 @@
+export declare function isQaTestEmail(value: unknown): boolean;

package/dist/shared/qa-test-email.js

@@ -0,0 +1,42 @@
+/**
+ * Identities that automated checks create, so tracking can drop their events
+ * before they reach a provider.
+ *
+ * Every pattern here must be impossible for a real signup to match. The
+ * reserved domains and TLDs come from RFC 2606 / RFC 6761 and are permanently
+ * undeliverable, so matching them cannot suppress a real user. Do not add a
+ * pattern that merely looks synthetic — `test@`, `demo@` and `qa@` are real
+ * addresses people sign up with.
+ *
+ * Widened after a fleet audit found 17 synthetic signups reaching production
+ * analytics: the original pattern only matched plus-addressed
+ * `+qa-test-bot-…@`, so `an-e2e-probe-…@e2e.agent-native.test`,
+ * `e2e-…@example.com` and bare `qa-test-bot-…@` all slipped through.
+ */
+const QA_TEST_EMAIL_PATTERNS = [
+    // Plus-addressed bot identities on an otherwise real mailbox.
+    /\+qa-test-bot-[^@\s]+@/i,
+    // Bare bot identities — the local part starts with the marker.
+    /^qa-test-bot-[^@\s]*@/i,
+    /^an-e2e-probe-[^@\s]*@/i,
+    // RFC 2606 / RFC 6761 reserved TLDs. Never resolvable, never a real user.
+    //
+    // `.test` and `.example` are deliberately NOT here. They are undeliverable
+    // in the world, but inside this repo they are how a fixture spells a REAL
+    // user: 545 `.test` and 13 `.example` addresses across packages/core stand
+    // in for people, and suppressing them silently drops the tracking those
+    // tests assert. Four spec files caught it; the rest would have kept passing
+    // while measuring nothing.
+    /@[^@\s]*\.(?:invalid|localhost)$/i,
+    // Only on a reserved domain: this repo uses bare example.com addresses as
+    // fixtures for REAL users, so the domain alone must never suppress.
+    /^e2e-[^@\s]*@example\.(?:com|net|org)$/i,
+];
+export function isQaTestEmail(value) {
+    if (typeof value !== "string")
+        return false;
+    const candidate = value.trim();
+    if (!candidate)
+        return false;
+    return QA_TEST_EMAIL_PATTERNS.some((pattern) => pattern.test(candidate));
+}

package/dist/shared/route-warmup-config.js

@@ -7,11 +7,11 @@ const AGENT_NATIVE_ROUTE_WARMUP_STRATEGIES = new Set([
 ]);
 export const DEFAULT_AGENT_NATIVE_ROUTE_WARMUP_SELECTOR = 'a[data-an-prefetch="render"][href]';
 export const DEFAULT_AGENT_NATIVE_ROUTE_WARMUP_CONFIG = {
-    strategy: "intent",
+    strategy: "viewport",
     data: true,
     modules: true,
     selector: DEFAULT_AGENT_NATIVE_ROUTE_WARMUP_SELECTOR,
-    maxConcurrent: 4,
+    maxConcurrent: 8,
 };
 export function isAgentNativeRouteWarmupStrategy(value) {
     return (typeof value === "string" &&

package/dist/shared/sign-in-journey.js

@@ -183,7 +183,7 @@ function createSignInJourneyRuntime(basePath) {
         return normalizeAppPath(decoded);
     }
     function homeHref() {
-        return base || "/";
+        return base + "/home";
     }
     function signInJourney(input) {
         var here = normalizeAppPath(input.at);