@reclaimprotocol/client 0.1.29 → 0.1.31

package/lib/launch/environment.d.ts

@@ -0,0 +1,224 @@
+/**
+ * Injectable environment port for browser globals.
+ *
+ * The reference JS SDK's `device.ts` reads `navigator`/`window` at *import*
+ * time, which breaks under SSR and makes device detection untestable
+ * without stubbing real globals — forbidden by `packages/client/AGENTS.md`,
+ * and this package has no DOM test library. Every function under
+ * `src/launch/` takes a `LaunchEnvironment` instead of touching a global
+ * directly, and `defaultEnvironment()` — the only place real globals are
+ * read — is called lazily by `ReclaimFlow.from()`, never at module scope.
+ *
+ * The port only exposes the narrow surface launch code needs, typed with
+ * our own interfaces rather than lib "dom" types. This file deliberately
+ * does NOT `/// <reference lib="dom" />` (unlike `packages/app/src/client/*`,
+ * which can): `packages/client`'s `tsconfig.json` compiles this whole
+ * package as one program, including Node-oriented files like
+ * `verify-tee.ts` that type `crypto.subtle` against `node:crypto`'s
+ * `webcrypto.SubtleCrypto`. Pulling in the "dom" lib anywhere merges its
+ * *global* `SubtleCrypto` (and `Response`/`Headers`/etc.) declarations into
+ * the same program, and the DOM lib's `SubtleCrypto` has since grown
+ * post-quantum KEM methods Node's typings don't — breaking that unrelated
+ * file. Instead, the `declare global` block below adds ambient `window`/
+ * `document`/`navigator` typed narrowly and exactly to what this port
+ * needs, so real browser globals type-check with no cast and no leakage of
+ * anything else "dom" would bring in.
+ */
+/** A `MessageEvent`-shaped value, narrowed to what the extension handshake
+ *  and popup-blocking checks read. */
+export interface LaunchMessageEvent {
+    data: unknown;
+    origin?: string;
+}
+export interface LaunchUserAgentData {
+    mobile?: boolean;
+    platform?: string;
+}
+export interface LaunchClipboard {
+    writeText(text: string): Promise<void>;
+}
+export interface LaunchNavigator {
+    userAgent: string;
+    maxTouchPoints?: number;
+    /** Chromium's low-entropy User-Agent Client Hints. Absent on every
+     *  WebKit browser (all of iOS) and on Firefox — an augmenting signal
+     *  only, never the sole basis for a decision. */
+    userAgentData?: LaunchUserAgentData;
+    clipboard?: LaunchClipboard;
+}
+export interface LaunchMediaQueryResult {
+    matches: boolean;
+}
+export interface LaunchCss {
+    supports?(property: string, value: string): boolean;
+}
+/** Only the inline-style properties `src/launch/` actually sets (the QR
+ *  modal's chrome, and the hidden iframes used to probe mobile deep links).
+ *  Every name here matches a real `CSSStyleDeclaration` property 1:1, so a
+ *  real element's `.style` satisfies this without a cast. */
+export interface LaunchStyleDeclaration {
+    width?: string;
+    height?: string;
+    border?: string;
+    display?: string;
+    position?: string;
+    inset?: string;
+    alignItems?: string;
+    justifyContent?: string;
+    background?: string;
+    zIndex?: string;
+    color?: string;
+    borderRadius?: string;
+    padding?: string;
+    maxWidth?: string;
+    textAlign?: string;
+    fontFamily?: string;
+    fontSize?: string;
+    fontWeight?: string;
+    margin?: string;
+    marginBottom?: string;
+    marginLeft?: string;
+    marginTop?: string;
+    cursor?: string;
+    top?: string;
+    right?: string;
+    boxShadow?: string;
+    boxSizing?: string;
+    lineHeight?: string;
+    overflow?: string;
+    transition?: string;
+    textDecoration?: string;
+    backgroundColor?: string;
+    gap?: string;
+}
+/** Only the one field the QR modal's backdrop handler reads, to tell a click
+ *  on the backdrop from one that bubbled out of the card. */
+export interface LaunchMouseEvent {
+    readonly target?: unknown;
+}
+/**
+ * Minimal surface of an element this package creates and mutates (an
+ * embedded iframe, a QR container, or the QR modal's own chrome). `src` is
+ * optional — only the iframes need it, plain containers/buttons don't have
+ * it at all — so a real `HTMLElement` (not just `HTMLIFrameElement`)
+ * satisfies this without a cast.
+ */
+export interface LaunchElement {
+    src?: string;
+    innerHTML: string;
+    readonly style: LaunchStyleDeclaration;
+    setAttribute(name: string, value: string): void;
+    appendChild(el: LaunchElement): void;
+    addEventListener(type: 'click', listener: (event?: LaunchMouseEvent) => void): void;
+    removeEventListener(type: 'click', listener: (event?: LaunchMouseEvent) => void): void;
+    remove(): void;
+}
+/** A container `launch()` embeds an iframe into — `options.target`. A real
+ *  `HTMLElement` satisfies this. */
+export interface LaunchContainer {
+    appendChild(el: LaunchElement): void;
+}
+/** A window/tab this package opened or was handed pre-opened. A real
+ *  `Window` returned by `window.open()` does not have `navigate()`, so
+ *  `defaultEnvironment()` wraps it — see below. */
+export interface LaunchWindowHandle {
+    readonly location: {
+        href: string;
+    };
+    readonly closed?: boolean;
+    navigate(url: string): void;
+    close(): void;
+}
+export interface LaunchDocumentBody {
+    appendChild(el: LaunchElement): void;
+}
+/** Only the one field the QR modal's Escape handler reads. */
+export interface LaunchKeyboardEvent {
+    readonly key: string;
+}
+export interface LaunchDocument {
+    readonly hidden?: boolean;
+    createElement(tagName: string): LaunchElement;
+    querySelector(selector: string): unknown;
+    /** Null only in the (practically unreachable, for code that only runs
+     *  after DOM APIs already exist) case that the document has no body yet. */
+    readonly body: LaunchDocumentBody | null;
+    addEventListener(type: 'visibilitychange', listener: () => void, options?: {
+        once?: boolean;
+    }): void;
+    /** `keydown` is here only so the QR modal can close on Escape. */
+    addEventListener(type: 'keydown', listener: (event: LaunchKeyboardEvent) => void): void;
+    removeEventListener(type: 'visibilitychange', listener: () => void): void;
+    removeEventListener(type: 'keydown', listener: (event: LaunchKeyboardEvent) => void): void;
+}
+export interface LaunchWindow {
+    innerWidth?: number;
+    innerHeight?: number;
+    devicePixelRatio?: number;
+    screen?: {
+        width?: number;
+        height?: number;
+    };
+    /** Presence (any value, including `undefined`) signals touch-event
+     *  support — mirrors the reference SDK's `'ontouchstart' in window`. */
+    ontouchstart?: unknown;
+    DeviceMotionEvent?: {
+        requestPermission?(): Promise<string>;
+    };
+    DeviceOrientationEvent?: unknown;
+    orientation?: unknown;
+    CSS?: LaunchCss;
+    matchMedia?(query: string): LaunchMediaQueryResult | null | undefined;
+    addEventListener(type: 'message', listener: (event: LaunchMessageEvent) => void): void;
+    removeEventListener(type: 'message', listener: (event: LaunchMessageEvent) => void): void;
+    postMessage(message: unknown, targetOrigin: string): void;
+}
+export interface LaunchEnvironment {
+    window?: LaunchWindow;
+    document?: LaunchDocument;
+    navigator?: LaunchNavigator;
+    /** Opens a URL in a new tab/window (`window.open`). Returns `null` when
+     *  blocked or unavailable — the same contract as the real DOM method. */
+    open(url?: string, target?: string, features?: string): LaunchWindowHandle | null;
+    /** Navigates the current tab (`window.location.href = url`) — used for
+     *  the mobile deep-link/App-Clip/store redirects, which happen in the
+     *  claimant's own tab, not a popup. */
+    navigate(url: string): void;
+    /** Real `setTimeout`/`clearTimeout` by default. Injectable so tests can
+     *  fake the 500ms about:blank recovery check, the extension probe
+     *  timeout, and the mobile store-fallback delays without waiting on
+     *  real wall-clock timers or stubbing the global timer functions. */
+    setTimeout(handler: () => void, delayMs: number): unknown;
+    clearTimeout(handle: unknown): void;
+}
+/**
+ * The real global `window`'s shape, exactly as far as this file's own
+ * `open()`/`navigate()` need — a superset of `LaunchWindow` (which is what
+ * the rest of `src/launch/` sees through `LaunchEnvironment.window`) by
+ * `location`/`open`. See the file header for why this is declared here
+ * rather than obtained via `/// <reference lib="dom" />`.
+ */
+interface GlobalWindow extends LaunchWindow {
+    location: {
+        href: string;
+    };
+    open(url?: string, target?: string, features?: string): GlobalWindowHandle | null;
+}
+interface GlobalWindowHandle {
+    location: {
+        href: string;
+    };
+    closed: boolean;
+    close(): void;
+}
+declare global {
+    var window: GlobalWindow | undefined;
+    var document: LaunchDocument | undefined;
+}
+/**
+ * The real browser globals, wrapped to satisfy `LaunchEnvironment`. Reads
+ * `window`/`document`/`navigator` only when called — never at module scope
+ * — so importing `src/launch/` has no effect under SSR.
+ */
+export declare function defaultEnvironment(): LaunchEnvironment;
+export {};

package/lib/launch/environment.js

@@ -0,0 +1,98 @@
+/**
+ * Injectable environment port for browser globals.
+ *
+ * The reference JS SDK's `device.ts` reads `navigator`/`window` at *import*
+ * time, which breaks under SSR and makes device detection untestable
+ * without stubbing real globals — forbidden by `packages/client/AGENTS.md`,
+ * and this package has no DOM test library. Every function under
+ * `src/launch/` takes a `LaunchEnvironment` instead of touching a global
+ * directly, and `defaultEnvironment()` — the only place real globals are
+ * read — is called lazily by `ReclaimFlow.from()`, never at module scope.
+ *
+ * The port only exposes the narrow surface launch code needs, typed with
+ * our own interfaces rather than lib "dom" types. This file deliberately
+ * does NOT `/// <reference lib="dom" />` (unlike `packages/app/src/client/*`,
+ * which can): `packages/client`'s `tsconfig.json` compiles this whole
+ * package as one program, including Node-oriented files like
+ * `verify-tee.ts` that type `crypto.subtle` against `node:crypto`'s
+ * `webcrypto.SubtleCrypto`. Pulling in the "dom" lib anywhere merges its
+ * *global* `SubtleCrypto` (and `Response`/`Headers`/etc.) declarations into
+ * the same program, and the DOM lib's `SubtleCrypto` has since grown
+ * post-quantum KEM methods Node's typings don't — breaking that unrelated
+ * file. Instead, the `declare global` block below adds ambient `window`/
+ * `document`/`navigator` typed narrowly and exactly to what this port
+ * needs, so real browser globals type-check with no cast and no leakage of
+ * anything else "dom" would bring in.
+ */
+/**
+ * Reads the browser-only extras (`userAgentData`, `maxTouchPoints`,
+ * `clipboard`) off the real `navigator` global through a loosely-typed bag
+ * rather than widening `@types/node`'s fixed ambient `Navigator` type (see
+ * the `declare global` comment above) or asserting `nav` itself to
+ * `any`/`unknown`. A real browser's `navigator` has all of these; Node's
+ * ambient type just doesn't say so.
+ */
+function wrapNavigator(nav) {
+    const extras = nav;
+    return {
+        get userAgent() {
+            return nav.userAgent;
+        },
+        get maxTouchPoints() {
+            return extras.maxTouchPoints;
+        },
+        get userAgentData() {
+            return extras.userAgentData;
+        },
+        get clipboard() {
+            return extras.clipboard;
+        },
+    };
+}
+/**
+ * The real browser globals, wrapped to satisfy `LaunchEnvironment`. Reads
+ * `window`/`document`/`navigator` only when called — never at module scope
+ * — so importing `src/launch/` has no effect under SSR.
+ */
+export function defaultEnvironment() {
+    const win = typeof window === 'undefined' ? undefined : window;
+    return {
+        window: win,
+        document: typeof document === 'undefined' ? undefined : document,
+        navigator: typeof navigator === 'undefined'
+            ? undefined
+            : wrapNavigator(navigator),
+        open(url, target, features) {
+            const handle = win?.open(url, target, features);
+            if (!handle) {
+                return null;
+            }
+            return {
+                get location() {
+                    return handle.location;
+                },
+                get closed() {
+                    return handle.closed;
+                },
+                navigate(u) {
+                    handle.location.href = u;
+                },
+                close() {
+                    handle.close();
+                },
+            };
+        },
+        navigate(url) {
+            if (win) {
+                win.location.href = url;
+            }
+        },
+        setTimeout(handler, delayMs) {
+            return setTimeout(handler, delayMs);
+        },
+        clearTimeout(handle) {
+            // `handle` is always something this same `setTimeout` returned.
+            clearTimeout(handle);
+        },
+    };
+}

package/lib/launch/errors.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Distinguishable rejection for an extension-bound session this device can't
+ * run — no extension present, or opened on a phone (the extension has no
+ * mobile mechanism at all). `launch()` rejects with this rather than
+ * silently falling back to another mechanism: the session names one client,
+ * and switching would misattribute it (see the launch-API plan's "Launch
+ * mechanisms" section).
+ *
+ * A plain `Error` subclass, not a `@hapi/boom` error:
+ * `packages/client/AGENTS.md` requires browser-safe modules to avoid
+ * `node:assert` and the Boom runtime, and `src/launch/` is loaded directly
+ * into a browser bundle.
+ */
+export type ReclaimFlowUnavailableReason = 'mobile-device' | 'extension-disabled' | 'extension-not-found';
+export declare class ReclaimFlowUnavailableError extends Error {
+    readonly name = "ReclaimFlowUnavailableError";
+    readonly reason: ReclaimFlowUnavailableReason;
+    constructor(reason: ReclaimFlowUnavailableReason);
+}
+export declare function isReclaimFlowUnavailableError(error: unknown): error is ReclaimFlowUnavailableError;

package/lib/launch/errors.js

@@ -0,0 +1,25 @@
+export class ReclaimFlowUnavailableError extends Error {
+    constructor(reason) {
+        super(reasonMessage(reason));
+        this.name = 'ReclaimFlowUnavailableError';
+        this.reason = reason;
+    }
+}
+export function isReclaimFlowUnavailableError(error) {
+    return error instanceof ReclaimFlowUnavailableError;
+}
+function reasonMessage(reason) {
+    switch (reason) {
+        case 'mobile-device':
+            return 'This session is bound to the Reclaim browser extension, '
+                + 'which has no mobile mechanism. Open it on a desktop browser '
+                + 'instead.';
+        case 'extension-disabled':
+            return 'This session is bound to the Reclaim browser extension, '
+                + 'but options.useBrowserExtension is false.';
+        case 'extension-not-found':
+            return 'This session is bound to the Reclaim browser extension, '
+                + 'which was not found on this device. Offer the install link '
+                + 'instead.';
+    }
+}

package/lib/launch/extension.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The `reclaim-browser-extension` target's mechanism: no navigation, just a
+ * `window.postMessage` handshake with the content script the extension
+ * injects into every page. Speaks the protocol directly rather than
+ * depending on `@reclaimprotocol/browser-extension-sdk` (a second SDK for a
+ * ping and a handoff).
+ *
+ * Action constants match `reclaim-browser-extension-sdk/src/utils/constants/
+ * interfaces.js`'s `RECLAIM_SDK_ACTIONS`. The extension now supplies its own
+ * Verification Client id (`reclaim-browser-extension-sdk` commit b2f35fa —
+ * "the extension is always the `reclaim-browser-extension` client, so it
+ * supplies its own id rather than trusting the page for one"), so the
+ * `RECLAIM_START_VERIFICATION` payload below deliberately does NOT carry
+ * one: a page handing the extension a different client's id would leave a
+ * session recorded against a codebase that never ran it.
+ */
+import type { LaunchEnvironment } from './environment.ts';
+export declare const RECLAIM_EXTENSION_CHECK = "RECLAIM_EXTENSION_CHECK";
+export declare const RECLAIM_EXTENSION_RESPONSE = "RECLAIM_EXTENSION_RESPONSE";
+export declare const RECLAIM_START_VERIFICATION = "RECLAIM_START_VERIFICATION";
+export declare const RECLAIM_CANCEL_VERIFICATION = "RECLAIM_CANCEL_VERIFICATION";
+export interface ExtensionHandoff {
+    sessionId: string;
+    diag: boolean;
+    extensionID?: string;
+}
+/** Probes for the extension with a short-lived `postMessage` round trip.
+ *  Resolves `false` on timeout, on no `window`, or if nothing answers —
+ *  never rejects. */
+export declare function probeExtension(env: LaunchEnvironment, options?: {
+    extensionID?: string;
+    extensionTimeout?: number;
+}): Promise<boolean>;
+/** Hands the session off to the extension. No navigation, no return value —
+ *  the extension runs the verification and the consumer's backend receives
+ *  the callback (see the launch-API plan's "The page cannot poll" risk). */
+export declare function sendExtensionStartVerification(env: LaunchEnvironment, handoff: ExtensionHandoff): void;
+/** Tears down the extension's in-progress verification UI. This is what
+ *  `FlowHandle.close()` does for the extension-handoff mechanism — there's
+ *  no tab or iframe to close instead. Does not cancel the Builder session
+ *  itself (see `FlowHandle.close()`'s contract in ./flow.ts). */
+export declare function sendExtensionCancelVerification(env: LaunchEnvironment, handoff: Pick<ExtensionHandoff, 'sessionId' | 'extensionID'>): void;

package/lib/launch/extension.js

@@ -0,0 +1,72 @@
+export const RECLAIM_EXTENSION_CHECK = 'RECLAIM_EXTENSION_CHECK';
+export const RECLAIM_EXTENSION_RESPONSE = 'RECLAIM_EXTENSION_RESPONSE';
+export const RECLAIM_START_VERIFICATION = 'RECLAIM_START_VERIFICATION';
+export const RECLAIM_CANCEL_VERIFICATION = 'RECLAIM_CANCEL_VERIFICATION';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+/** Probes for the extension with a short-lived `postMessage` round trip.
+ *  Resolves `false` on timeout, on no `window`, or if nothing answers —
+ *  never rejects. */
+export function probeExtension(env, options = {}) {
+    const win = env.window;
+    if (!win) {
+        return Promise.resolve(false);
+    }
+    const extensionTimeout = options.extensionTimeout ?? 200;
+    const messageId = `reclaim-check-${Math.random().toString(36).slice(2)}`;
+    return new Promise(resolve => {
+        // An arrow (not a hoisted `function`) so TypeScript's control-flow
+        // analysis keeps treating `win` as defined inside this closure — a
+        // nested function *declaration* can in principle be invoked before the
+        // enclosing `if(!win) return` runs, so TS won't narrow through one.
+        const onMessage = (event) => {
+            const data = event.data;
+            if (isRecord(data)
+                && data.action === RECLAIM_EXTENSION_RESPONSE
+                && data.messageId === messageId) {
+                env.clearTimeout(timeoutHandle);
+                win.removeEventListener('message', onMessage);
+                resolve(!!data.installed);
+            }
+        };
+        const timeoutHandle = env.setTimeout(() => {
+            win.removeEventListener('message', onMessage);
+            resolve(false);
+        }, extensionTimeout);
+        win.addEventListener('message', onMessage);
+        win.postMessage({
+            action: RECLAIM_EXTENSION_CHECK,
+            extensionID: options.extensionID,
+            messageId,
+        }, '*');
+    });
+}
+/** Hands the session off to the extension. No navigation, no return value —
+ *  the extension runs the verification and the consumer's backend receives
+ *  the callback (see the launch-API plan's "The page cannot poll" risk). */
+export function sendExtensionStartVerification(env, handoff) {
+    env.window?.postMessage({
+        action: RECLAIM_START_VERIFICATION,
+        messageId: handoff.sessionId,
+        extensionID: handoff.extensionID,
+        data: {
+            builder: {
+                apiVersion: '2',
+                sessionId: handoff.sessionId,
+                ...(handoff.diag ? { diagnosticMode: true } : {}),
+            },
+        },
+    }, '*');
+}
+/** Tears down the extension's in-progress verification UI. This is what
+ *  `FlowHandle.close()` does for the extension-handoff mechanism — there's
+ *  no tab or iframe to close instead. Does not cancel the Builder session
+ *  itself (see `FlowHandle.close()`'s contract in ./flow.ts). */
+export function sendExtensionCancelVerification(env, handoff) {
+    env.window?.postMessage({
+        action: RECLAIM_CANCEL_VERIFICATION,
+        messageId: handoff.sessionId,
+        extensionID: handoff.extensionID,
+    }, '*');
+}

package/lib/launch/flow.d.ts

@@ -0,0 +1,82 @@
+/**
+ * `ReclaimFlow` — the public entry point. One constructor
+ * (`ReclaimFlow.from`), per the launch-API plan: no
+ * `fromSession`/`fromVerificationUrl`/`fromDescriptor` family.
+ *
+ * `resolveTarget()`/`launch()` decide the mechanism from the URL's client
+ * (see ./target.ts) and the device (see ./device.ts); `launch()` runs it
+ * (./portal.ts, ./mobile.ts, ./extension.ts, ./modal.ts) and hands back a
+ * `FlowHandle` that tears down whatever UI it created.
+ */
+import type { VerificationSession } from '../types/openapi.ts';
+import type { DetectionConfidence, DeviceKind } from './device.ts';
+import type { LaunchElement, LaunchWindowHandle } from './environment.ts';
+import type { ReclaimFlowUnavailableReason } from './errors.ts';
+import type { FlowOptions } from './options.ts';
+import { resolveAndroidAppDownloadUrl, resolveAndroidDeepLinkPackage } from './options.ts';
+import type { VerificationTarget } from './target.ts';
+export type { FlowOptions } from './options.ts';
+export type { VerificationTarget } from './target.ts';
+export type { DetectionConfidence, DeviceKind } from './device.ts';
+export { ReclaimFlowUnavailableError, isReclaimFlowUnavailableError, } from './errors.ts';
+export type { ReclaimFlowUnavailableReason } from './errors.ts';
+/** A `verificationUrl` string, or any object carrying one — a full
+ *  `VerificationSession` satisfies it. */
+export type FlowInput = string | VerificationSession | {
+    verificationUrl: string;
+};
+export type LaunchMechanism = 'new-tab' | 'iframe' | 'extension-handoff' | 'qr-modal' | 'ios-app-clip' | 'ios-deep-link' | 'android-deep-link' | 'unavailable';
+/** Which client and mechanism a flow resolves to on this device. Read-only —
+ *  `resolveTarget()` changes nothing (see the plan's "Targets" section). */
+export interface ResolvedTarget {
+    /** The client the URL names, or `undefined` for an unrecognised path
+     *  (degrades to `mechanism: 'new-tab'`). */
+    client: VerificationTarget | undefined;
+    device: DeviceKind;
+    /** Exposed so a caller can render a chooser instead of trusting a
+     *  borderline device-detection guess — see ./device.ts. */
+    confidence: DetectionConfidence;
+    mechanism: LaunchMechanism;
+    /** `false` only for an extension-bound session this device can't run
+     *  (see `reason`); `launch()` rejects rather than substituting another
+     *  mechanism. */
+    available: boolean;
+    reason?: ReclaimFlowUnavailableReason;
+}
+export interface FlowHandle {
+    /** Tears down the UI this launch created (tab/iframe/modal, or the
+     *  extension's in-progress verification). Does not cancel the session —
+     *  the Builder session outcome still arrives at the consumer's backend
+     *  callback. */
+    close(): void;
+    readonly target: ResolvedTarget;
+    readonly iframe?: LaunchElement;
+    readonly tab?: LaunchWindowHandle | null;
+}
+export declare class ReclaimFlow {
+    #private;
+    private constructor();
+    /** The only constructor — no `fromSession`/`fromVerificationUrl`/
+     *  `fromDescriptor` family. */
+    static from(input: FlowInput, options?: FlowOptions): ReclaimFlow;
+    /** The `session`/object this flow was built from, or `undefined` when
+     *  `from()` was given a bare `verificationUrl` string. */
+    get session(): VerificationSession | {
+        verificationUrl: string;
+    } | undefined;
+    /** Merges `options` for later `getUrl()`/`resolveTarget()`/`launch()`
+     *  calls. Chainable. */
+    setOptions(options: FlowOptions): this;
+    /** Resolves the target and returns the claimant URL, without navigating. */
+    getUrl(): Promise<string>;
+    /** Which client and mechanism this flow will use on this device. A read:
+     *  reports the mechanism and changes nothing (the one exception is a
+     *  short-lived `postMessage` probe for an extension-bound session, which
+     *  navigates nothing and shows no UI). */
+    resolveTarget(): Promise<ResolvedTarget>;
+    /** Opens it. Rejects with `ReclaimFlowUnavailableError` for an
+     *  extension-bound session this device can't run, rather than silently
+     *  falling back to another mechanism. */
+    launch(): Promise<FlowHandle>;
+}
+export { resolveAndroidAppDownloadUrl, resolveAndroidDeepLinkPackage };