@agent-native/core 0.227.0-nightly-20261110032437 → 0.227.0

package/dist/client/chat/run-outcome.d.ts

@@ -15,6 +15,54 @@ import { type AutoContinueRefusalCode } from "../../agent/auto-continue.js";
  */
 export declare const RUN_OUTCOMES: readonly ["running", "succeeded", "stopped", "interrupted", "failed", "unverified"];
 export type RunOutcome = (typeof RUN_OUTCOMES)[number];
+export type ActiveRunPhase = {
+    readonly type: "streaming";
+} | {
+    readonly type: "holdingInterruption";
+    readonly error: AgentError;
+} | {
+    readonly type: "followingSuccessor";
+} | {
+    readonly type: "awaitingContinuation";
+    readonly streamClosed: boolean;
+};
+export type RunPhase = ActiveRunPhase | {
+    readonly type: "cancelling";
+    readonly previous: ActiveRunPhase;
+} | {
+    readonly type: "terminal";
+} | {
+    readonly type: "disposed";
+};
+export type RunPhaseEvent = {
+    readonly type: "streamEnded";
+} | {
+    readonly type: "streamFailed";
+} | {
+    readonly type: "interrupted";
+    readonly error: AgentError;
+} | {
+    readonly type: "followSuccessor";
+} | {
+    readonly type: "streamOpened";
+} | {
+    readonly type: "continuationResumed";
+} | {
+    readonly type: "awaitContinuation";
+    readonly streamClosed: boolean;
+} | {
+    readonly type: "terminal";
+} | {
+    readonly type: "cancelStarted";
+} | {
+    readonly type: "cancelSucceeded";
+} | {
+    readonly type: "cancelFailed";
+} | {
+    readonly type: "dispose";
+};
+/** Late stream and authority results cannot revive a terminal or disposed run. */
+export declare function transition(phase: RunPhase, event: RunPhaseEvent): RunPhase;
 /**
  * Codes that described "the agent stopped / is stuck" one incident at a time.
  * They survive only as telemetry detail; the user sees their outcome. A new

package/dist/client/chat/run-outcome.js

@@ -24,6 +24,56 @@ export const RUN_OUTCOMES = [
     "failed",
     "unverified",
 ];
+/** Late stream and authority results cannot revive a terminal or disposed run. */
+export function transition(phase, event) {
+    if (event.type === "dispose")
+        return { type: "disposed" };
+    if (phase.type === "disposed")
+        return phase;
+    if (phase.type === "terminal")
+        return phase;
+    if (phase.type === "cancelling") {
+        if (event.type === "cancelFailed")
+            return phase.previous;
+        if (event.type === "cancelSucceeded")
+            return { type: "terminal" };
+        return phase;
+    }
+    switch (event.type) {
+        case "streamEnded":
+        case "streamFailed":
+            return phase.type === "streaming"
+                ? { type: "followingSuccessor" }
+                : phase;
+        case "interrupted":
+            return phase.type === "streaming"
+                ? { type: "holdingInterruption", error: event.error }
+                : phase;
+        case "followSuccessor":
+            return phase.type === "holdingInterruption"
+                ? { type: "followingSuccessor" }
+                : phase;
+        case "streamOpened":
+            return phase.type === "followingSuccessor"
+                ? { type: "streaming" }
+                : phase;
+        case "continuationResumed":
+            return phase.type === "awaitingContinuation"
+                ? { type: "streaming" }
+                : phase;
+        case "awaitContinuation":
+            return phase.type === "streaming"
+                ? { type: "awaitingContinuation", streamClosed: event.streamClosed }
+                : phase;
+        case "terminal":
+            return { type: "terminal" };
+        case "cancelStarted":
+            return { type: "cancelling", previous: phase };
+        case "cancelSucceeded":
+        case "cancelFailed":
+            return phase;
+    }
+}
 /**
  * Codes that described "the agent stopped / is stuck" one incident at a time.
  * They survive only as telemetry detail; the user sees their outcome. A new

package/dist/collab/routes.d.ts

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

package/dist/collab/struct-routes.d.ts

@@ -13,9 +13,9 @@ export declare const postCollabPatch: import("h3").EventHandlerWithFetch<import(
     ok: boolean;
 }>>;
 export declare const getCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    data?: undefined;
     error: string;
     docId?: undefined;
+    data?: undefined;
 } | {
     error?: undefined;
     docId: string;

package/dist/deploy/build.d.ts

@@ -186,6 +186,7 @@ export declare function cloudflareExternalBundleEntry(resolvedMod: string, neede
  */
 export declare function patchCloudflareModuleServerOutput(serverDir: string): void;
 export declare function bundleYjsRuntimeForServerlessOutput(serverDir: string, projectCwd: string): string[];
+export declare function prepareVercelFunctionOutputs(outputDir: string, projectCwd: string): void;
 export declare function shouldBundleYjsRuntimeForPreset(targetPreset: string): boolean;
 export declare function nitroServerCodeSplittingGroupsForPreset(targetPreset: string): {
     test: RegExp;

package/dist/deploy/build.js

@@ -3864,6 +3864,32 @@ export function bundleYjsRuntimeForServerlessOutput(serverDir, projectCwd) {
     });
     return bareImports;
 }
+export function prepareVercelFunctionOutputs(outputDir, projectCwd) {
+    const functionsDir = path.join(outputDir, "functions");
+    if (!fs.existsSync(functionsDir))
+        return;
+    const visit = (dir) => {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const entryPath = path.join(dir, entry.name);
+            if (entry.name.endsWith(".func")) {
+                if (entry.isSymbolicLink()) {
+                    const target = fs.realpathSync(entryPath);
+                    const relative = path.relative(fs.realpathSync(functionsDir), target);
+                    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+                        throw new Error(`[deploy] Vercel function link leaves output: ${entryPath}`);
+                    }
+                    fs.unlinkSync(entryPath);
+                    fs.cpSync(target, entryPath, { recursive: true });
+                }
+                bundleYjsRuntimeForServerlessOutput(entryPath, projectCwd);
+            }
+            else if (entry.isDirectory()) {
+                visit(entryPath);
+            }
+        }
+    };
+    visit(functionsDir);
+}
 export function shouldBundleYjsRuntimeForPreset(targetPreset) {
     return (targetPreset === "netlify" ||
         targetPreset === "vercel" ||
@@ -5050,7 +5076,10 @@ export default bundle;
         sanitizeServerlessFunctionPackageManifest(nitro.options.output.serverDir);
         pruneServerlessFunctionDeadWeight(nitro.options.output.serverDir);
     }
-    if (shouldBundleYjsRuntimeForPreset(preset)) {
+    if (preset === "vercel") {
+        prepareVercelFunctionOutputs(nitro.options.output.dir, cwd);
+    }
+    else if (shouldBundleYjsRuntimeForPreset(preset)) {
         bundleYjsRuntimeForServerlessOutput(nitro.options.output.serverDir, cwd);
     }
     if (isCloudflareModulePreset(preset)) {

package/dist/framework-package-versions.json

@@ -1,17 +1,17 @@
 {
-  "@agent-native/agentkit": "0.227.0-nightly-20261110032437",
+  "@agent-native/agentkit": "0.227.0",
   "@agent-native/code-agents-ui": "0.1.75",
-  "@agent-native/core": "0.227.0-nightly-20261110032437",
-  "@agent-native/core-corpus": "0.227.0-nightly-20261110032437",
-  "@agent-native/creative-context": "0.8.68",
-  "@agent-native/dispatch": "0.42.4-nightly-20261110032437",
+  "@agent-native/core": "0.227.0",
+  "@agent-native/core-corpus": "0.227.0",
+  "@agent-native/creative-context": "0.8.69",
+  "@agent-native/dispatch": "0.42.4",
   "@agent-native/embedding": "0.2.0",
   "@agent-native/migrate": "0.0.7",
-  "@agent-native/otel": "0.1.35",
-  "@agent-native/pinpoint": "0.1.111",
-  "@agent-native/recap-cli": "0.5.99",
-  "@agent-native/scheduling": "0.2.56-nightly-20261110032437",
+  "@agent-native/otel": "0.1.36",
+  "@agent-native/pinpoint": "0.1.112",
+  "@agent-native/recap-cli": "0.5.100",
+  "@agent-native/scheduling": "0.2.56",
   "@agent-native/shared-app-config": "0.1.2",
-  "@agent-native/skills": "0.4.4-nightly-20261110032437",
-  "@agent-native/toolkit": "0.227.0-nightly-20261110032437"
+  "@agent-native/skills": "0.4.4",
+  "@agent-native/toolkit": "0.227.0"
 }

package/dist/jobs/run-now.js

@@ -4,7 +4,7 @@ import { canQueueAutomationRunNow, } from "../automations/service.js";
 import { isLocalDatabase } from "../db/client.js";
 import { organizationResourceOwner, resourceGetByPath, } from "../resources/store.js";
 import { fireInternalDispatch } from "../server/self-dispatch.js";
-import { parseJobResource } from "./frontmatter.js";
+import { isRecoveredFactoryJob, jobBelongsToApp, parseJobResource, } from "./frontmatter.js";
 import { automationRunOwnership } from "./run-history-ownership.js";
 import { listUnclaimedAutomationRuns, startAutomationRun, } from "./run-history.js";
 async function dispatchAutomationRun(historyId, requestHeaders) {
@@ -113,6 +113,14 @@ export async function authorizeAutomationRunNow(input) {
         });
     }
     if (!(await canQueueAutomationRunNow(input, access.resource, access.scope, input.additionalJobAppIds))) {
+        const { meta } = parseJobResource(access.resource.content);
+        if (!jobBelongsToApp(meta, input.appId, input.additionalJobAppIds) &&
+            !isRecoveredFactoryJob(meta, access.resource.path, input.appId, access.resource.owner)) {
+            const ownerAppId = meta.appId?.trim();
+            throw Object.assign(new Error(ownerAppId
+                ? `This automation belongs to the "${ownerAppId}" app. Run it from that app.`
+                : "This automation has no app owner and cannot be run."), { statusCode: 403 });
+        }
         throw Object.assign(new Error("Collaborate access is required to run this automation."), { statusCode: 403 });
     }
     return access;

package/dist/notifications/routes.d.ts

@@ -1,12 +1,12 @@
 export declare function createNotificationsHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<"" | import("./types.js").Notification[] | {
-    error?: undefined;
     count: number;
     updated?: undefined;
+    error?: undefined;
     ok?: undefined;
 } | {
-    error?: undefined;
     count?: undefined;
     updated: number;
+    error?: undefined;
     ok?: undefined;
 } | {
     count?: undefined;
@@ -14,8 +14,8 @@ export declare function createNotificationsHandler(): import("h3").EventHandlerW
     error: string;
     ok?: undefined;
 } | {
-    error?: undefined;
     count?: undefined;
     updated?: undefined;
+    error?: undefined;
     ok: boolean;
 }>>;

package/dist/org/index.d.ts

@@ -180,9 +180,9 @@ export declare const getMyOrgHandler: import("h3").EventHandlerWithFetch<import(
     soloDeploymentAdmin: boolean | undefined;
 }>>;
 export declare const createOrgHandler: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    id?: undefined;
     name?: undefined;
     success: boolean;
+    id?: undefined;
     role?: undefined;
 } | {
     success?: undefined;

package/dist/org/migrations.d.ts

@@ -1,7 +1,7 @@
 export declare const ORG_MIGRATIONS: ({
-    name?: undefined;
     version: number;
     sql: string;
+    name?: undefined;
 } | {
     version: number;
     name: string;

package/dist/provider-api/actions/provider-api.d.ts

@@ -316,8 +316,8 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         notes?: string | undefined;
         scope?: "org" | "user" | undefined;
     }, {
-        provider?: undefined;
         id?: undefined;
+        provider?: undefined;
         message?: undefined;
         providers: {
             id: string;

package/dist/resources/handlers.d.ts

@@ -49,7 +49,6 @@ export declare function handleUploadResource(event: any): Promise<import("./stor
     error: string;
     storageSetupRequired?: undefined;
 } | {
-    error?: undefined;
     id: string;
     path: string;
     owner: string;
@@ -64,6 +63,7 @@ export declare function handleUploadResource(event: any): Promise<import("./stor
     runId: string | null;
     expiresAt: number | null;
     metadata: string | null;
+    error?: undefined;
     url: string;
     provider: string;
     storageSetupRequired?: undefined;

package/dist/scripts/agent-engines/list-agent-engines.js

@@ -1,6 +1,6 @@
 import { getAgentAppModelDefaultForCurrentRequest } from "../../agent/app-model-defaults.js";
 import { CHATGPT_SUBSCRIPTION_ENGINE_NAME } from "../../agent/chatgpt-subscription-contract.js";
-import { readDefaultAgentEngineSettingDetailed, resolveDefaultAgentEngineAuthority, } from "../../agent/default-agent-engine.js";
+import { isDefaultAgentEngineScopeResolved, readDefaultAgentEngineSettingDetailed, resolveDefaultAgentEngineAuthority, } from "../../agent/default-agent-engine.js";
 import { listChatGPTSubscriptionModels } from "../../agent/engine/chatgpt-subscription-engine.js";
 import { listAgentEngines, registerBuiltinEngines, detectEngineFromEnv, detectEngineFromUserSecrets, getAgentEngineEntry, isAgentEnginePackageInstalled, isStoredEngineUsableForRequest, normalizeModelForEngine, resolveEngineAcceptsCustomModels, resolveEnginePreservesCustomModels, } from "../../agent/engine/index.js";
 import { applyProviderModelSelection, providerForEngineName, resolveEffectiveProviderModelSelection, } from "../../agent/provider-model-selection.js";
@@ -101,10 +101,14 @@ export async function run(args = {}) {
         }
         return pending;
     };
-    const [defaultSetting, defaultAuthority] = await Promise.all([
-        readDefaultAgentEngineSettingDetailed(),
-        resolveDefaultAgentEngineAuthority(),
-    ]);
+    // An unresolved scope cannot say which default applies. Listing engines
+    // must still work, so the read is skipped and reported as "unresolved"
+    // instead of "none", which would claim no default is saved.
+    const defaultAuthority = await resolveDefaultAgentEngineAuthority();
+    const scopeUnresolved = !isDefaultAgentEngineScopeResolved();
+    const defaultSetting = scopeUnresolved
+        ? { value: null, source: "unresolved" }
+        : await readDefaultAgentEngineSettingDetailed();
     const current = defaultSetting.value
         ? defaultSetting.value
         : null;

package/dist/server/auth.d.ts

@@ -9,7 +9,7 @@ import type { GoogleAuthMode } from "./google-auth-mode.js";
 import { type OnboardingHtmlOptions } from "./onboarding-html.js";
 import { isSessionResolutionUnavailable } from "./session-resolution-unavailable.js";
 export declare function getSessionMaxAge(): number;
-export declare function recordBuilderSignupBinding(event: H3Event, attemptId: unknown, method: "password" | "magic-link" | "google", email: string): Promise<void>;
+export declare function recordBuilderSignupBinding(event: H3Event, attemptId: unknown, method: "password" | "magic-link" | "google", email: string, verifiedSession?: AuthSession): Promise<void>;
 export interface AuthSession {
     email: string;
     userId?: string;
@@ -94,6 +94,8 @@ export interface AuthOptions {
      * fallback markup, which the auth client script replaces in the browser.
      */
     renderSignInPage?: (props: AuthPageProps) => string | undefined;
+    /** Trusted HTML appended to the sign-in document head. */
+    authHeadHtml?: string;
     renderResetPasswordPage?: (props: ResetPasswordPageProps) => string | undefined;
     rootAuth?: boolean;
     googleOnly?: boolean;

package/dist/server/auth.js

@@ -12,7 +12,7 @@ import { FIRST_RUN_ONBOARDING_COOKIE, FIRST_RUN_ONBOARDING_MAX_AGE, } from "../s
 import { FIRST_TOUCH_SERVER_PATH } from "../shared/first-touch-persistence.js";
 import { isGoogleProfileImageUrl } from "../shared/google-profile-image.js";
 import { corsAllowHeadersFor, EMBED_TRANSPLANT_HEADER, isExplicitCorsAllowedOrigin, isMcpEmbedCorsOrigin, MCP_EMBED_CORS_ALLOW_HEADERS, shouldAllowMcpEmbedCredentials, } from "../shared/mcp-embed-headers.js";
-import { bindBuilderSignupAttempt, builderSignupAssignmentCookieName, } from "./builder-signup-experiment.js";
+import { bindBuilderSignupAttempt, startBuilderSignupForVerifiedSession, builderSignupAssignmentCookieName, } from "./builder-signup-experiment.js";
 import { createConsentHandler, createConsentRegionHandler, requestAllowsConsentCategory, } from "./consent-route.js";
 import { readDevActionDiscoveryFile } from "./dev-action-discovery.js";
 import { devLoopbackAuthHint } from "./dev-origin-hint.js";
@@ -155,12 +155,24 @@ function requestWithSignupAttribution(request, signupAttribution) {
 function headersWithSignupAttribution(headers, cookieHeader) {
     return addSignupAttributionHeader(headers, signupAttributionContextFromCookieHeader(cookieHeader));
 }
-export async function recordBuilderSignupBinding(event, attemptId, method, email) {
+export async function recordBuilderSignupBinding(event, attemptId, method, email, verifiedSession) {
     if (typeof attemptId !== "string" &&
         !getCookie(event, builderSignupAssignmentCookieName()))
         return;
     try {
-        await bindBuilderSignupAttempt(event, attemptId, method, email);
+        const bound = await bindBuilderSignupAttempt(event, attemptId, method, email);
+        if (bound &&
+            verifiedSession?.emailVerified === true &&
+            verifiedSession.token &&
+            verifiedSession.email.trim().toLowerCase() === email.trim().toLowerCase()) {
+            // The callback just issued this session; its cookie is in the response,
+            // not the incoming request. Org/credential checks must see that identity.
+            const signupSession = { ...verifiedSession, userId: bound.userId };
+            event.context.__anSessionCache = Promise.resolve(signupSession);
+            delete event.context.__anOrgContextCache;
+            markRequestIdentityAuthenticatedAtMs(event, verifiedSession.email, Date.now(), verifiedSession.token);
+            await startBuilderSignupForVerifiedSession(event, signupSession);
+        }
     }
     catch (error) {
         captureAuthError(error, { route: "signup", email });
@@ -1862,6 +1874,7 @@ function getOnboardingHtmlOptions(options, event, rawPath, authMode) {
         signupLegalNotice: options.signupLegalNotice,
         googleAuthMode: options.googleAuthMode,
         renderSignInPage: options.renderSignInPage,
+        authHeadHtml: options.authHeadHtml,
         requestHost: event ? getRequestHost(event) : undefined,
         requestPath: rawPath,
         requestOrigin: event ? getOrigin(event) : undefined,
@@ -4420,15 +4433,16 @@ async function mountBetterAuthRoutes(app, options) {
                         console.warn("[auth] failed to store Google profile image:", error);
                     });
                 }
+                const signupUserId = isNewGoogleUser
+                    ? await getBetterAuthUserIdForEmail(email)
+                    : undefined;
                 const { sessionToken } = await createOAuthSession(event, email, {
                     hasProductionSession: false,
                     desktop,
                     mobile,
                     trackSignup: {
                         authProvider: "google",
-                        canonicalAuthUserId: isNewGoogleUser
-                            ? await getBetterAuthUserIdForEmail(email)
-                            : undefined,
+                        ...(signupUserId ? { canonicalAuthUserId: signupUserId } : {}),
                         name: typeof user.name === "string" ? user.name : undefined,
                         attribution: signupAttribution,
                         signupAnonymousId,
@@ -4437,8 +4451,14 @@ async function mountBetterAuthRoutes(app, options) {
                         isNewUser: isNewGoogleUser,
                     },
                 });
-                if (isNewGoogleUser)
-                    await recordBuilderSignupBinding(event, builderSignupAttemptId, "google", email);
+                if (isNewGoogleUser) {
+                    await recordBuilderSignupBinding(event, builderSignupAttemptId, "google", email, {
+                        email,
+                        ...(sessionToken ? { token: sessionToken } : {}),
+                        ...(typeof user.name === "string" ? { name: user.name } : {}),
+                        emailVerified: true,
+                    });
+                }
                 logGoogleOAuthDebug(event, "callback-session-created", {
                     flowId,
                     desktop,
@@ -5418,7 +5438,7 @@ async function mountBetterAuthRoutes(app, options) {
             : query.return;
         const signupSession = await getSession(event);
         if (signupSession?.emailVerified)
-            await recordBuilderSignupBinding(event, query.builder_signup_attempt, "magic-link", signupSession.email);
+            await recordBuilderSignupBinding(event, query.builder_signup_attempt, "magic-link", signupSession.email, signupSession);
         setFirstRunOnboardingCookie(event);
         return queryEchoSafeRedirect(event, redirectWithStagedCookies(event, safeReturnPath(rawReturn), 302));
     }));

package/dist/server/builder-signup-experiment.d.ts

@@ -31,13 +31,18 @@ export declare function builderSignupAssignmentCookieName(): string;
 export declare function encodeBuilderSignupAssignment(assignment: Assignment): string;
 export declare function decodeBuilderSignupAssignment(value: string | undefined): Assignment | null;
 export declare function isBuilderSignupExperimentEnabled(): boolean;
-export declare function bindBuilderSignupAttempt(event: H3Event, attemptId: unknown, method: "password" | "magic-link" | "google", email: string): Promise<boolean>;
+export declare function bindBuilderSignupAttempt(event: H3Event, attemptId: unknown, method: "password" | "magic-link" | "google", email: string): Promise<{
+    userId: string;
+} | false>;
 export declare function getBuilderSignupConnectError(userId: string | undefined): Promise<{
     code: "account_exists";
     message: string;
     at: number;
 } | undefined>;
-export declare function createBuilderSignupExperimentHandler(dependencies: {
+export declare function setBuilderSignupVerifiedStarter(starter: (event: H3Event, session: AuthSession) => Promise<unknown>): void;
+/** Called only after the auth provider issued this verified signup's session. */
+export declare function startBuilderSignupForVerifiedSession(event: H3Event, session: AuthSession): Promise<void>;
+export declare function createBuilderSignupExperiment(dependencies: {
     getSession: (event: H3Event) => Promise<AuthSession | null>;
     sameOrigin: (event: H3Event) => boolean;
     activate: (event: H3Event, session: AuthSession, owner: {
@@ -53,44 +58,86 @@ export declare function createBuilderSignupExperimentHandler(dependencies: {
         attempt: string;
         startedAt: number;
     }) => Promise<boolean>;
-}): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    status: "connected" | "fallback";
-    code?: string | undefined;
-} | {
-    status: "unavailable";
-    code: string;
-} | {
-    status: "disabled";
-    code?: undefined;
-} | {
-    id: string;
-    variant: "automatic" | "control";
-    issuedAt: number;
-    acceptedAt?: number | undefined;
-    attemptId?: string | undefined;
-    method?: "google" | "magic-link" | "password" | undefined;
-    email?: string | undefined;
-    policy: "builder-signup-2026-11-06";
-    status: "assigned";
-    experimentId: string;
-    code?: undefined;
-} | {
-    status: "disabled";
-    code: string;
-} | {
-    code?: undefined;
-    status: "pending";
-} | {
-    code?: undefined;
-    status: "eligible";
-} | {
-    code?: undefined;
-    status: "not_required";
-} | {
-    code?: undefined;
-    status: "accepted";
-} | {
-    status: "pending";
-    code: string;
-}>>;
+}): {
+    handler: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
+        status: "connected" | "fallback";
+        code?: string | undefined;
+    } | {
+        status: "unavailable";
+        code: string;
+    } | {
+        status: "disabled";
+        code?: undefined;
+    } | {
+        id: string;
+        variant: "automatic" | "control";
+        issuedAt: number;
+        acceptedAt?: number | undefined;
+        attemptId?: string | undefined;
+        method?: "google" | "magic-link" | "password" | undefined;
+        email?: string | undefined;
+        policy: "builder-signup-2026-11-06";
+        status: "assigned";
+        experimentId: string;
+        code?: undefined;
+    } | {
+        status: "disabled";
+        code: string;
+    } | {
+        code?: undefined;
+        status: "pending";
+    } | {
+        code?: undefined;
+        status: "eligible";
+    } | {
+        code?: undefined;
+        status: "not_required";
+    } | {
+        code?: undefined;
+        status: "accepted";
+    } | {
+        status: "pending";
+        code: string;
+    }>>;
+    startVerifiedSignup: (event: H3Event, session: AuthSession) => Promise<{
+        status: "connected" | "fallback";
+        code?: string | undefined;
+    } | {
+        status: "unavailable";
+        code: string;
+    } | {
+        status: "disabled";
+        code?: undefined;
+    } | {
+        id: string;
+        variant: "automatic" | "control";
+        issuedAt: number;
+        acceptedAt?: number | undefined;
+        attemptId?: string | undefined;
+        method?: "google" | "magic-link" | "password" | undefined;
+        email?: string | undefined;
+        policy: "builder-signup-2026-11-06";
+        status: "assigned";
+        experimentId: string;
+        code?: undefined;
+    } | {
+        status: "disabled";
+        code: string;
+    } | {
+        code?: undefined;
+        status: "pending";
+    } | {
+        code?: undefined;
+        status: "eligible";
+    } | {
+        code?: undefined;
+        status: "not_required";
+    } | {
+        code?: undefined;
+        status: "accepted";
+    } | {
+        status: "pending";
+        code: string;
+    }>;
+};
 export {};