@agent-native/core 0.137.8 → 0.139.0

package/dist/scripts/docs/source-search.js

@@ -1,12 +1,14 @@
 /**
  * Core script: source-search
  *
- * Search and read the packaged Agent Native first-party template corpus.
- * The corpus is generated into @agent-native/core/corpus during package build.
+ * Search and read version-matched framework source.
+ * First-party templates are generated into @agent-native/core/corpus during
+ * package build; Core and Toolkit source are read from their installed roots.
  *
  * Usage:
  *   pnpm action source-search --query "defineAction"
  *   pnpm action source-search --path templates/chat/actions/hello.ts
+ *   pnpm action source-search --path core/src/action.ts
  *   pnpm action source-search --path templates/plan/AGENTS.md
  *   pnpm action source-search --list
  */
@@ -57,6 +59,40 @@ function getCorpusRoot() {
     //   dist/scripts/docs/source-search.js -> corpus/
     return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../../corpus");
 }
+function getPackageRoot() {
+    return path.dirname(getCorpusRoot());
+}
+function getToolkitSourceRoot() {
+    const candidates = [
+        path.resolve(getPackageRoot(), "../toolkit/src"),
+        path.resolve(process.cwd(), "node_modules/@agent-native/toolkit/src"),
+    ];
+    return candidates.find((candidate) => fs.existsSync(candidate)) ?? null;
+}
+function getSourceRoots() {
+    const corpusRoot = getCorpusRoot();
+    const roots = [
+        {
+            prefix: "templates",
+            directory: path.join(corpusRoot, "templates"),
+            visibilityRoot: corpusRoot,
+        },
+    ];
+    // A monorepo checkout has the authored Core source. Published packages do
+    // not carry the whole source tree, so use their readable dist output.
+    const coreSourceRoot = path.join(getPackageRoot(), "src");
+    roots.push(fs.existsSync(path.join(coreSourceRoot, "server"))
+        ? { prefix: "core/src", directory: coreSourceRoot }
+        : { prefix: "core/dist", directory: path.join(getPackageRoot(), "dist") });
+    const toolkitSourceRoot = getToolkitSourceRoot();
+    if (toolkitSourceRoot) {
+        roots.push({
+            prefix: "toolkit/src",
+            directory: toolkitSourceRoot,
+        });
+    }
+    return roots;
+}
 /**
  * The corpus is a sibling of the package root, so a bundled serverless deploy
  * never carries it. Callers register this tool conditionally: advertising a
@@ -125,29 +161,52 @@ function isRuntimeVisibleCorpusPath(corpusRoot, absolutePath) {
         return true;
     }
 }
-function listFiles(dir, base = dir, corpusRoot = getCorpusRoot()) {
+function listFiles(dir, base = dir, visibilityRoot) {
     if (!fs.existsSync(dir))
         return [];
     const files = [];
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return files;
+    }
+    for (const entry of entries) {
         const abs = path.join(dir, entry.name);
-        if (!isRuntimeVisibleCorpusPath(corpusRoot, abs))
+        if (visibilityRoot && !isRuntimeVisibleCorpusPath(visibilityRoot, abs)) {
             continue;
+        }
         if (entry.isDirectory()) {
-            files.push(...listFiles(abs, base, corpusRoot));
+            files.push(...listFiles(abs, base, visibilityRoot));
         }
         else if (entry.isFile() && isProbablyTextFile(abs)) {
-            const stat = fs.statSync(abs);
+            let stat;
+            try {
+                stat = fs.statSync(abs);
+            }
+            catch {
+                continue;
+            }
             if (stat.size <= MAX_FILE_BYTES) {
                 files.push({
                     absolutePath: abs,
                     relativePath: path.relative(base, abs).split(path.sep).join("/"),
+                    visibilityRoot,
                 });
             }
         }
     }
     return files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
 }
+export function listSourceFiles() {
+    return getSourceRoots()
+        .flatMap((root) => listFiles(root.directory, root.directory, root.visibilityRoot).map((file) => ({
+        ...file,
+        relativePath: `${root.prefix}/${file.relativePath}`,
+    })))
+        .sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
 function lineSnippet(line, terms) {
     const trimmed = line.trim();
     if (trimmed.length <= 220)
@@ -162,7 +221,6 @@ function lineSnippet(line, terms) {
     return `${start > 0 ? "..." : ""}${trimmed.slice(start, end)}${end < trimmed.length ? "..." : ""}`;
 }
 function searchCorpus(query) {
-    const corpusRoot = getCorpusRoot();
     const terms = query
         .toLowerCase()
         .split(/\s+/)
@@ -171,7 +229,9 @@ function searchCorpus(query) {
     if (terms.length === 0)
         return [];
     const results = [];
-    for (const file of listFiles(corpusRoot)) {
+    for (const file of listSourceFiles()) {
+        if (/\.(?:spec|test)\.[cm]?[jt]sx?$/.test(file.relativePath))
+            continue;
         let raw = "";
         try {
             raw = fs.readFileSync(file.absolutePath, "utf-8");
@@ -204,26 +264,37 @@ function searchCorpus(query) {
     }
     return results.sort((a, b) => b.score - a.score || a.file.localeCompare(b.file));
 }
-function readCorpusPath(relative) {
+function readSourcePath(relative) {
     if (!isValidPath(relative)) {
-        return `Invalid corpus path: ${relative}`;
+        return `Invalid source path: ${relative}`;
     }
-    const corpusRoot = getCorpusRoot();
-    const target = path.resolve(corpusRoot, relative);
-    if (!target.startsWith(corpusRoot + path.sep) && target !== corpusRoot) {
-        return `Invalid corpus path: ${relative}`;
+    const sourceRoot = getSourceRoots().find((root) => relative === root.prefix || relative.startsWith(`${root.prefix}/`));
+    if (!sourceRoot)
+        return `Source path not found: ${relative}`;
+    const rootRelativePath = relative
+        .slice(sourceRoot.prefix.length)
+        .replace(/^\//, "");
+    const target = path.resolve(sourceRoot.directory, rootRelativePath);
+    if (!target.startsWith(sourceRoot.directory + path.sep) &&
+        target !== sourceRoot.directory) {
+        return `Invalid source path: ${relative}`;
     }
     if (!fs.existsSync(target)) {
-        return `Corpus path not found: ${relative}`;
+        return `Source path not found: ${relative}`;
     }
-    if (!isRuntimeVisibleCorpusPath(corpusRoot, target)) {
-        return `Corpus path is not available to runtime source-search: ${relative}`;
+    if (sourceRoot.visibilityRoot &&
+        !isRuntimeVisibleCorpusPath(sourceRoot.visibilityRoot, target)) {
+        return `Source path is not available to runtime source-search: ${relative}`;
     }
     const stat = fs.statSync(target);
     if (stat.isDirectory()) {
         const entries = fs
             .readdirSync(target, { withFileTypes: true })
-            .filter((entry) => isRuntimeVisibleCorpusPath(corpusRoot, path.join(target, entry.name)))
+            .filter((entry) => {
+            if (!sourceRoot.visibilityRoot)
+                return true;
+            return isRuntimeVisibleCorpusPath(sourceRoot.visibilityRoot, path.join(target, entry.name));
+        })
             .map((entry) => `${entry.isDirectory() ? "dir " : "file"} ${entry.name}`)
             .sort();
         const shown = entries.slice(0, 200);
@@ -239,33 +310,30 @@ function readCorpusPath(relative) {
             .join("\n");
     }
     if (!stat.isFile())
-        return `Unsupported corpus path: ${relative}`;
+        return `Unsupported source path: ${relative}`;
     if (!isProbablyTextFile(target))
-        return `Not a text corpus file: ${relative}`;
+        return `Not a text source file: ${relative}`;
     if (stat.size > MAX_FILE_BYTES) {
-        return `Corpus file is too large to read through source-search: ${relative}`;
+        return `Source file is too large to read through source-search: ${relative}`;
     }
     const raw = fs.readFileSync(target, "utf-8");
     if (raw.length <= MAX_READ_CHARS)
         return raw;
     return `${raw.slice(0, MAX_READ_CHARS)}\n\n... truncated at ${MAX_READ_CHARS} characters. Use a narrower path or direct rg for more context.`;
 }
-function listCorpus() {
-    const corpusRoot = getCorpusRoot();
-    const sections = ["templates"];
-    return sections.map((section) => {
-        const sectionRoot = path.join(corpusRoot, section);
-        const files = listFiles(sectionRoot);
-        const children = fs.existsSync(sectionRoot)
+function listSourceRoots() {
+    return getSourceRoots().map((root) => {
+        const files = listFiles(root.directory, root.directory, root.visibilityRoot);
+        const children = fs.existsSync(root.directory)
             ? fs
-                .readdirSync(sectionRoot, { withFileTypes: true })
+                .readdirSync(root.directory, { withFileTypes: true })
                 .filter((entry) => entry.isDirectory())
                 .map((entry) => entry.name)
                 .sort()
             : [];
         return {
-            section,
-            path: section,
+            section: root.prefix,
+            path: root.prefix,
             files: files.length,
             directories: children,
         };
@@ -273,27 +341,26 @@ function listCorpus() {
 }
 export default async function sourceSearchScript(args) {
     const parsed = parseArgs(args);
-    const corpusRoot = getCorpusRoot();
     if (parsed.help === "true") {
         console.log(`Usage: pnpm action source-search [options]
 
 Options:
-  --query <text>    Search source corpus by keyword
-  --path <path>     Read a corpus file or list a corpus directory
-  --list            List corpus sections
+  --query <text>    Search readable framework source by keyword
+  --path <path>     Read a source file or list a source directory
+  --list            List source roots
   --help            Show this help message`);
         return;
     }
-    if (!fs.existsSync(corpusRoot)) {
-        console.log(`Source corpus not found at ${corpusRoot}. Build or reinstall @agent-native/core so node_modules/@agent-native/core/corpus exists.`);
+    if (!hasSourceCorpus()) {
+        console.log("Version-matched source is not available. Build or reinstall @agent-native/core so its source corpus and readable package sources are present.");
         return;
     }
     if (parsed.list === "true") {
-        console.log(JSON.stringify(listCorpus(), null, 2));
+        console.log(JSON.stringify(listSourceRoots(), null, 2));
         return;
     }
     if (parsed.path) {
-        console.log(readCorpusPath(parsed.path));
+        console.log(readSourcePath(parsed.path));
         return;
     }
     if (parsed.query) {
@@ -310,7 +377,7 @@ Options:
             }
             console.log("");
         }
-        console.log("Use --path <file> to read a specific corpus file.");
+        console.log("Use --path <file> to read a specific source file.");
         return;
     }
     console.log("Provide --query, --path, or --list. Use --help for details.");

package/dist/search-utils/index.d.ts

@@ -1,7 +1,18 @@
 export type SearchMatchMode = "allTerms" | "anyTerm" | "phrase" | "regex";
+export type TextSearchMode = "substring" | "glob" | "sql-like" | "regex";
+export interface TextMatcher {
+    matches(value: string): boolean;
+    error?: string;
+}
 export declare function escapeLikeTerm(value: string): string;
 export declare function normalizeSearchTerms(query: string): string[];
 export declare function matchesSearchMode(value: string, query: string, mode: SearchMatchMode): boolean;
+/**
+ * Build a bounded, case-insensitive matcher for agent-facing text search.
+ * Regexes are deliberately constrained because these matchers may scan a
+ * packaged source corpus during a single agent turn.
+ */
+export declare function createTextMatcher(pattern: string, mode?: TextSearchMode): TextMatcher;
 export declare function buildSearchSnippet(value: string, terms: string[], maxLength?: number): string;
 export declare function scoreSearchText(fields: {
     title?: string | null;

package/dist/search-utils/index.js

@@ -1,4 +1,5 @@
 import safeRegex from "safe-regex2";
+const MAX_TEXT_SEARCH_PATTERN_LENGTH = 240;
 const STOPWORDS = new Set([
     "about",
     "and",
@@ -57,6 +58,77 @@ export function matchesSearchMode(value, query, mode) {
         ? tokens.every((term) => normalizedValue.includes(term))
         : tokens.some((term) => normalizedValue.includes(term));
 }
+/**
+ * Build a bounded, case-insensitive matcher for agent-facing text search.
+ * Regexes are deliberately constrained because these matchers may scan a
+ * packaged source corpus during a single agent turn.
+ */
+export function createTextMatcher(pattern, mode = "substring") {
+    if (!pattern) {
+        return { matches: () => false, error: "Search pattern cannot be empty." };
+    }
+    if (pattern.length > MAX_TEXT_SEARCH_PATTERN_LENGTH) {
+        return {
+            matches: () => false,
+            error: `Search pattern is limited to ${MAX_TEXT_SEARCH_PATTERN_LENGTH} characters.`,
+        };
+    }
+    if (mode === "substring") {
+        const normalized = pattern.toLowerCase();
+        return {
+            matches: (value) => value.toLowerCase().includes(normalized),
+        };
+    }
+    const regexSource = mode === "regex" ? pattern : wildcardPatternToRegex(pattern, mode);
+    try {
+        const matcher = new RegExp(regexSource, "isu");
+        if (mode === "regex" && !safeRegex(pattern)) {
+            return {
+                matches: () => false,
+                error: "Regex pattern is too complex for a bounded source search.",
+            };
+        }
+        return { matches: (value) => matcher.test(value) };
+    }
+    catch {
+        return {
+            matches: () => false,
+            error: `Invalid ${mode} search pattern.`,
+        };
+    }
+}
+function wildcardPatternToRegex(pattern, mode) {
+    let source = "";
+    let escaped = false;
+    for (const character of pattern) {
+        if (escaped) {
+            source += escapeRegexCharacter(character);
+            escaped = false;
+            continue;
+        }
+        if (character === "\\") {
+            escaped = true;
+            continue;
+        }
+        const isMany = mode === "glob" ? character === "*" : character === "%";
+        const isOne = mode === "glob" ? character === "?" : character === "_";
+        if (isMany) {
+            source += "[\\s\\S]*";
+        }
+        else if (isOne) {
+            source += "[\\s\\S]";
+        }
+        else {
+            source += escapeRegexCharacter(character);
+        }
+    }
+    if (escaped)
+        source += "\\\\";
+    return source;
+}
+function escapeRegexCharacter(value) {
+    return value.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+}
 export function buildSearchSnippet(value, terms, maxLength = 260) {
     const text = normalizeText(value);
     if (text.length <= maxLength)

package/dist/server/action-change.d.ts

@@ -26,4 +26,10 @@ export interface NotifyActionChangeOptions {
 }
 export declare function writeActionChangeMarker(options: NotifyActionChangeOptions): Promise<void>;
 export declare function notifyActionChange(options: NotifyActionChangeOptions): Promise<void>;
+/**
+ * Publish the fast in-memory invalidation without holding a user-visible run
+ * on the durable marker write. The marker remains scheduled for other
+ * processes and its failure is logged instead of becoming an invisible gap.
+ */
+export declare function notifyActionChangeInBackground(options: NotifyActionChangeOptions): void;
 //# sourceMappingURL=action-change.d.ts.map

package/dist/server/action-change.js

@@ -40,6 +40,23 @@ function actionChangeTarget(options) {
         requestSource: options.requestSource,
     };
 }
+function recordActionChange(options) {
+    const target = actionChangeTarget(options);
+    recordChange({
+        source: "action",
+        type: "change",
+        key: target.actionName,
+        ...(target.owner ? { owner: target.owner } : {}),
+        ...(target.orgId ? { orgId: target.orgId } : {}),
+        ...(target.requestSource ? { requestSource: target.requestSource } : {}),
+    });
+    return {
+        actionName: options.actionName,
+        ...(target.owner ? { owner: target.owner } : {}),
+        ...(target.orgId ? { orgId: target.orgId } : {}),
+        ...(target.requestSource ? { requestSource: target.requestSource } : {}),
+    };
+}
 export async function writeActionChangeMarker(options) {
     const target = actionChangeTarget(options);
     const sessionId = actionChangeMarkerSession(target);
@@ -51,20 +68,17 @@ export async function writeActionChangeMarker(options) {
     }, { requestSource: options.requestSource ?? "agent" });
 }
 export async function notifyActionChange(options) {
-    const target = actionChangeTarget(options);
-    recordChange({
-        source: "action",
-        type: "change",
-        key: options.actionName,
-        ...(target.owner ? { owner: target.owner } : {}),
-        ...(target.orgId ? { orgId: target.orgId } : {}),
-        ...(options.requestSource ? { requestSource: options.requestSource } : {}),
-    });
-    await writeActionChangeMarker({
-        actionName: options.actionName,
-        ...(target.owner ? { owner: target.owner } : {}),
-        ...(target.orgId ? { orgId: target.orgId } : {}),
-        ...(options.requestSource ? { requestSource: options.requestSource } : {}),
+    await writeActionChangeMarker(recordActionChange(options));
+}
+/**
+ * Publish the fast in-memory invalidation without holding a user-visible run
+ * on the durable marker write. The marker remains scheduled for other
+ * processes and its failure is logged instead of becoming an invisible gap.
+ */
+export function notifyActionChangeInBackground(options) {
+    const normalizedOptions = recordActionChange(options);
+    void writeActionChangeMarker(normalizedOptions).catch((error) => {
+        console.warn("[action-change] durable marker write failed:", error instanceof Error ? error.message : String(error));
     });
 }
 //# sourceMappingURL=action-change.js.map

package/dist/server/action-discovery.js

@@ -517,6 +517,28 @@ export async function mergeCoreSharingActions(registry) {
             () => import("../sharing/actions/create-agent-resource-link.js"),
         ],
         ["upload-image", () => import("../file-upload/actions/upload-image.js")],
+        // Transactional email catalog — mounted everywhere so Dispatch can ask any
+        // app what it sends without that app opting in.
+        [
+            "list-transactional-emails",
+            () => import("../email-catalog/actions/list-transactional-emails.js"),
+        ],
+        [
+            "render-transactional-email-preview",
+            () => import("../email-catalog/actions/render-transactional-email-preview.js"),
+        ],
+        [
+            "list-email-log",
+            () => import("../email-catalog/actions/list-email-log.js"),
+        ],
+        [
+            "list-email-activity",
+            () => import("../email-catalog/actions/list-email-activity.js"),
+        ],
+        [
+            "list-email-engagement",
+            () => import("../email-catalog/actions/list-email-engagement.js"),
+        ],
         [
             "get-feature-flags",
             () => import("../feature-flags/actions/get-feature-flags.js"),
@@ -596,6 +618,15 @@ export async function mergeCoreSharingActions(registry) {
             "update-user-profile",
             () => import("../user-profile/actions/update-user-profile.js"),
         ],
+        [
+            "get-auth-methods",
+            () => import("../user-profile/actions/get-auth-methods.js"),
+        ],
+        ["set-password", () => import("../user-profile/actions/set-password.js")],
+        [
+            "change-password",
+            () => import("../user-profile/actions/change-password.js"),
+        ],
         [
             "change-appearance",
             () => import("../appearance/actions/change-appearance.js"),

package/dist/server/action-routes.js

@@ -422,6 +422,7 @@ export function mountActionRoutes(nitroApp, actions, options) {
                         userEmail,
                         orgId: orgId ?? null,
                         caller,
+                        requestHeaders: event.headers,
                         actionName: name,
                         ...(resolvedCaller?.delegationJti
                             ? {

package/dist/server/agent-chat/browser-team-tools.js

@@ -228,7 +228,7 @@ export function createBuilderBrowserTool(deps) {
         },
         "activate-browser": {
             tool: {
-                description: "Activate browser automation tools. Call this when you need to interact with a real browser — e.g. to extract design tokens from a rendered page, take screenshots, read computed styles from JS-heavy sites, or test a live URL. After activation, chrome-devtools MCP tools (navigate, click, evaluate_script, take_screenshot, etc.) become available on your next action. Requires Builder.io connection.",
+                description: "Activate browser automation tools. Call this when you need to interact with a real browser — e.g. to extract design tokens from a rendered page, take screenshots, read computed styles from JS-heavy sites, or test a live URL. After activation, chrome-devtools MCP tools (navigate, click, evaluate_script, take_screenshot, etc.) become available on your next action. Requires a Builder.io connection (free tier available).",
                 parameters: {
                     type: "object",
                     properties: {

package/dist/server/agent-chat/script-entries.js

@@ -3,7 +3,7 @@ import { dbExecToolParameters } from "../../scripts/db/tool-schemas.js";
 import { captureCliOutput } from "../cli-capture.js";
 import { getAmbientUserEmail, getRequestOrgId, getRequestRunContext, getRequestUserEmail, } from "../request-context.js";
 // ---------------------------------------------------------------------------
-// CLI-script-backed action entries: db-*, docs-search/source-search,
+// CLI-script-backed action entries: db-*, framework-search/docs-search/source-search,
 // resources/save-memory/delete-memory, chat-history, manage-agent-engine,
 // manage-agent-loop-settings, and call-agent. Each wraps a core CLI script
 // (that writes to console.log) as an ActionEntry via `wrapCliScript`.
@@ -174,6 +174,47 @@ export async function createDbScriptEntries(mode = "read", options = {}) {
  */
 export async function createDocsScriptEntries() {
     const entries = {};
+    try {
+        const mod = await import("../../scripts/docs/framework-search.js");
+        entries["framework-search"] = wrapCliScript({
+            description: "Search the version-matched Agent Native docs and readable Core, Toolkit, and first-party template source in one bounded read-only call. Use this first when a docs answer may require implementation evidence.",
+            parameters: {
+                type: "object",
+                properties: {
+                    pattern: {
+                        type: "string",
+                        description: "Text pattern to search across docs and source. Use normal text by default, or use glob (* and ?) / SQL-like (% and _) / regex mode for broader or more precise matching.",
+                    },
+                    scope: {
+                        type: "string",
+                        description: "Search corpus: all, docs, or source (default: all).",
+                        enum: ["all", "docs", "source"],
+                    },
+                    mode: {
+                        type: "string",
+                        description: "Match mode: substring, glob, sql-like, or safe regex (default: substring).",
+                        enum: ["substring", "glob", "sql-like", "regex"],
+                    },
+                    path: {
+                        type: "string",
+                        description: "Optional glob path filter such as templates/*/actions/*.ts or core/src/server/*.",
+                    },
+                    limit: {
+                        type: "string",
+                        description: "Maximum matching files to return, from 1 to 50.",
+                    },
+                    list: {
+                        type: "string",
+                        description: 'Set to "true" to list searchable docs and source roots.',
+                        enum: ["true"],
+                    },
+                },
+            },
+        }, mod.default, { readOnly: true });
+    }
+    catch (error) {
+        console.warn("[agent-chat] framework-search unavailable; keeping the older lookup tools:", error instanceof Error ? error.message : String(error));
+    }
     try {
         const mod = await import("../../scripts/docs/search.js");
         entries["docs-search"] = wrapCliScript({
@@ -207,7 +248,7 @@ export async function createDocsScriptEntries() {
             return entries;
         }
         entries["source-search"] = wrapCliScript({
-            description: "Search and read the packaged Agent Native first-party template corpus under node_modules/@agent-native/core/corpus. Use --list for sections, --query to search template source, and --path to read a file.",
+            description: "Search and read readable version-matched Core, Toolkit, and first-party template source. Use framework-search for one combined docs/source search with glob, SQL-like, or regex matching; use --list, --query, or --path for focused source lookup.",
             parameters: {
                 type: "object",
                 properties: {

package/dist/server/auth-login-mode.d.ts

@@ -0,0 +1,8 @@
+import { type EmailReadiness } from "./email.js";
+export type AuthLoginMode = "magic-link" | "password";
+/** Magic link is the frictionless default only when outbound email is ready. */
+export declare function resolveAuthLoginMode(emailReady: boolean): AuthLoginMode;
+export declare function resolveAuthLoginModeFromReadiness(emailReadiness: EmailReadiness): AuthLoginMode;
+/** Resolve the browser mode from the same scoped email transport used to send. */
+export declare function getAuthLoginMode(): Promise<AuthLoginMode>;
+//# sourceMappingURL=auth-login-mode.d.ts.map

package/dist/server/auth-login-mode.js

@@ -0,0 +1,17 @@
+import { getEmailReadiness } from "./email.js";
+/** Magic link is the frictionless default only when outbound email is ready. */
+export function resolveAuthLoginMode(emailReady) {
+    const optOut = process.env.AUTH_MAGIC_LINK?.trim().toLowerCase();
+    if (optOut === "0" || optOut === "false" || optOut === "off") {
+        return "password";
+    }
+    return emailReady ? "magic-link" : "password";
+}
+export function resolveAuthLoginModeFromReadiness(emailReadiness) {
+    return resolveAuthLoginMode(emailReadiness.status === "ready");
+}
+/** Resolve the browser mode from the same scoped email transport used to send. */
+export async function getAuthLoginMode() {
+    return resolveAuthLoginModeFromReadiness(await getEmailReadiness());
+}
+//# sourceMappingURL=auth-login-mode.js.map