@bounded-sh/client 0.0.48 → 0.0.51

package/dist/{index.native-BZCc0gO-.js → index-BsrZb496.js}

@@ -4247,6 +4247,41 @@ function setStoredAuthMethod(method) {
         // storage might not be available
     }
 }
+function getStoredIdToken() {
+    try {
+        return core.getActiveSessionManager().getIdToken();
+    }
+    catch (_a) {
+        return null;
+    }
+}
+function idTokenIsGuest(idToken, expectedAddress) {
+    var _a;
+    try {
+        if (!idToken)
+            return false;
+        let b64 = (_a = idToken.split('.')[1]) === null || _a === void 0 ? void 0 : _a.replace(/-/g, '+').replace(/_/g, '/');
+        if (!b64)
+            return false;
+        const pad = b64.length % 4;
+        if (pad === 2)
+            b64 += '==';
+        else if (pad === 3)
+            b64 += '=';
+        const claims = JSON.parse(getPlatform().atob(b64));
+        if ((claims === null || claims === void 0 ? void 0 : claims.is_anonymous) !== true)
+            return false;
+        if (expectedAddress && (claims === null || claims === void 0 ? void 0 : claims['custom:walletAddress']) !== expectedAddress)
+            return false;
+        return true;
+    }
+    catch (_b) {
+        return false;
+    }
+}
+function storedSessionIsGuest() {
+    return idTokenIsGuest(getStoredIdToken());
+}
 /**
  * Pick the provider used for an ordinary `init({ appId })` restore.
  *
@@ -4257,7 +4292,16 @@ function setStoredAuthMethod(method) {
 function authMethodForInit(config) {
     if (config.authMethod != null)
         return config.authMethod;
-    return getStoredAuthMethod() === 'guest' ? 'guest' : 'email';
+    if (getStoredAuthMethod() !== 'guest')
+        return 'email';
+    if (storedSessionIsGuest())
+        return 'guest';
+    // A marker is only a restore hint; the bearer is authoritative. Repair a
+    // stale marker (for example, a crash/failed switch while a human session was
+    // still active) instead of relabelling that human bearer as a guest.
+    const hasSession = !!getStoredIdToken();
+    setStoredAuthMethod(hasSession ? 'email' : null);
+    return 'email';
 }
 function objectIdentityKey(value) {
     if (!value || (typeof value !== 'object' && typeof value !== 'function'))
@@ -4422,7 +4466,7 @@ async function getAuthProvider(config) {
             // manager as legacy email sessions. Human login should be started
             // with loginWithRedirect(); this provider is kept as the restore and
             // logout surface for those sessions.
-            currentAuthProvider = new (await Promise.resolve().then(function () { return require('./email-auth-provider-CmunfauO.js'); })).EmailAuthProvider();
+            currentAuthProvider = new (await Promise.resolve().then(function () { return require('./email-auth-provider-Bm6vmoy3.js'); })).EmailAuthProvider();
             break;
         case "wallet":
         case "phantom": {
@@ -4441,7 +4485,7 @@ async function getAuthProvider(config) {
             if (!isWalletLoginEnabled(config)) {
                 throw walletLoginNotEnabledError(authMethod);
             }
-            const { InjectedWalletProvider } = await Promise.resolve().then(function () { return require('./injected-wallet-provider-BBZym7YQ.js'); });
+            const { InjectedWalletProvider } = await Promise.resolve().then(function () { return require('./injected-wallet-provider-DpJvuK73.js'); });
             currentAuthProvider = new InjectedWalletProvider(resolveInjectedWalletConfig(config), rpcUrl, configuredNetwork);
             break;
         }
@@ -4454,7 +4498,7 @@ async function getAuthProvider(config) {
             // Selecting authMethod:'evm-wallet' IS the opt-in — pass evmWalletConfig
             // to point at a specific wallet or set chainId/domain.
             const evmWalletConfig = ((_a = config.evmWalletConfig) !== null && _a !== void 0 ? _a : {});
-            const { InjectedEvmWalletProvider } = await Promise.resolve().then(function () { return require('./injected-evm-wallet-provider-T-EF9C3W.js'); });
+            const { InjectedEvmWalletProvider } = await Promise.resolve().then(function () { return require('./injected-evm-wallet-provider-CEWIg-_U.js'); });
             currentAuthProvider = new InjectedEvmWalletProvider(evmWalletConfig);
             break;
         }
@@ -4482,7 +4526,7 @@ async function getAuthProvider(config) {
             break;
         case "guest":
             // Anonymous auth: a device-local ed25519 keypair signs the challenge.
-            currentAuthProvider = new (await Promise.resolve().then(function () { return require('./guest-auth-provider-B68XT2lU.js'); })).GuestAuthProvider();
+            currentAuthProvider = new (await Promise.resolve().then(function () { return require('./guest-auth-provider-CHqB_uN0.js'); })).GuestAuthProvider();
             break;
     }
     if (!currentAuthProvider) {
@@ -4519,19 +4563,108 @@ function assertBrowserAuthEnv(method) {
  * ownership-as-data pattern. `init()` must have run first. Browser/RN only.
  */
 async function signInAnonymously() {
+    var _a;
     assertBrowserAuthEnv('signInAnonymously');
-    const provider = new (await Promise.resolve().then(function () { return require('./guest-auth-provider-B68XT2lU.js'); })).GuestAuthProvider();
-    currentAuthProvider = provider;
-    currentAuthMethod = 'guest';
-    currentAuthProviderConfigKey = 'direct:guest';
+    // Resolve configuration before taking the transaction snapshot. Although
+    // getConfig is normally already resolved after init(), it is asynchronous;
+    // another login that finishes during that await must be part of the prior
+    // state we preserve, not accidentally split across old/new snapshots.
     const coreConfig = await core.getConfig();
-    coreConfig.authProvider = provider;
-    coreConfig.authMethod = 'guest';
-    setAuthProviderInstance(provider);
-    setStoredAuthMethod('guest');
+    const previousAuthProvider = currentAuthProvider;
+    const previousAuthMethod = currentAuthMethod;
+    const previousProviderConfigKey = currentAuthProviderConfigKey;
+    const previousStoredAuthMethod = getStoredAuthMethod();
+    const previousGlobalProvider = getAuthProviderInstance();
+    const previousUser = getCurrentUser();
+    const previousCoreProvider = coreConfig.authProvider;
+    const previousCoreAuthMethod = coreConfig.authMethod;
+    const previousIdToken = getStoredIdToken();
+    // Lazy-load the guest provider so its ed25519/web3 dependencies stay out of
+    // the main bundle for data-only apps. Specifier is a static string literal
+    // so bundle-splitting can see it.
+    const provider = new (await Promise.resolve().then(function () { return require('./guest-auth-provider-CHqB_uN0.js'); })).GuestAuthProvider();
     setAuthLoading(true); // reflect "signing in…" while the guest keypair session is minted
+    const commit = (user) => {
+        // No await/interleaving inside this block: provider/method/config/marker
+        // become guest before the user notification fires, so listeners and
+        // concurrent imperative calls can never observe a mixed identity.
+        currentAuthProvider = provider;
+        currentAuthMethod = 'guest';
+        currentAuthProviderConfigKey = 'direct:guest';
+        coreConfig.authProvider = provider;
+        coreConfig.authMethod = 'guest';
+        setAuthProviderInstance(provider);
+        setStoredAuthMethod('guest');
+        setCurrentUser(user);
+    };
     try {
-        return await provider.login();
+        // Mint/store first while every shared provider surface remains on the
+        // previous identity. The provider also withholds setCurrentUser here.
+        const user = await provider.loginForProviderSwitch();
+        if (!user)
+            return null;
+        // A human login may have completed after the guest request persisted but
+        // before its promise resumed here. Re-check the live bearer immediately
+        // before commit so a late guest result cannot overwrite that newer user.
+        if (!user.address || !idTokenIsGuest(getStoredIdToken(), user.address)) {
+            throw new Error('Anonymous sign-in was superseded by another session.');
+        }
+        commit(user);
+        return user;
+    }
+    catch (error) {
+        const currentIdToken = getStoredIdToken();
+        if (currentIdToken !== previousIdToken && idTokenIsGuest(currentIdToken)) {
+            // Defensive applied-yet-error reconciliation: if storage contains a
+            // valid guest bearer/key despite the thrown write, commit that truth
+            // instead of restoring a human UI over a guest token.
+            let recovered = null;
+            try {
+                recovered = await provider.restoreSessionForProviderSwitch();
+            }
+            catch (_b) {
+                try {
+                    core.getActiveSessionManager().clearSession();
+                }
+                catch ( /* fail closed below */_c) { /* fail closed below */ }
+            }
+            if (recovered) {
+                commit(recovered);
+                return recovered;
+            }
+            // restoreSessionForProviderSwitch fails closed and clears a split
+            // bearer. Do not resurrect a user object that no longer has its token.
+            setCurrentUser(null);
+        }
+        else if (currentIdToken === previousIdToken) {
+            // The staged attempt never changed the bearer; every shared provider
+            // surface stayed untouched, so restore the exact prior user/marker.
+            currentAuthProvider = previousAuthProvider;
+            currentAuthMethod = previousAuthMethod;
+            currentAuthProviderConfigKey = previousProviderConfigKey;
+            coreConfig.authProvider = previousCoreProvider;
+            coreConfig.authMethod = previousCoreAuthMethod;
+            setAuthProviderInstance(previousGlobalProvider);
+            setStoredAuthMethod(previousStoredAuthMethod);
+            if (getCurrentUser() !== previousUser)
+                setCurrentUser(previousUser);
+        }
+        else {
+            // A different non-guest token won while this staged guest mint was in
+            // flight (another tab/popup/login). The guest attempt never mutated
+            // shared provider state, so preserve that winner exactly. Align only
+            // this module's private registry to the provider the winner installed;
+            // never overwrite its core/global provider, marker, or user snapshot.
+            const concurrentProvider = (_a = getAuthProviderInstance()) !== null && _a !== void 0 ? _a : coreConfig.authProvider;
+            if (concurrentProvider)
+                currentAuthProvider = concurrentProvider;
+            const concurrentStoredMethod = getStoredAuthMethod();
+            currentAuthMethod = concurrentStoredMethod && concurrentStoredMethod !== 'guest'
+                ? concurrentStoredMethod
+                : (previousAuthMethod && previousAuthMethod !== 'guest' ? previousAuthMethod : 'email');
+            currentAuthProviderConfigKey = previousProviderConfigKey;
+        }
+        throw error;
     }
     finally {
         setAuthLoading(false);
@@ -4625,8 +4758,45 @@ async function login$1(options) {
 function getCurrentAuthMethod() {
     return currentAuthMethod;
 }
-async function logout$1() {
-    var _a;
+// The hosted issuer keeps its OWN browser session (the Better Auth cookie on
+// auth.bounded.sh) — clearing the app-local session alone leaves it alive, so
+// the next loginWithRedirect() silently re-signs the user in as the SAME
+// account: "sign out" that never lets you re-choose. The issuer ships
+// GET /logout for exactly this — it expires the session cookies and bounces
+// back — but it only redirects to https origins it trusts. Mirror that
+// allowlist here: on a trusted origin we end the issuer session with a
+// top-level bounce; anywhere else (custom domains, http dev) we keep the
+// local-only logout instead of stranding the user on the issuer origin.
+function issuerLogoutBounceUrl(issuerBase) {
+    if (typeof window === 'undefined' || typeof document === 'undefined')
+        return null; // RN/Node: no shared cookie jar to clear this way
+    try {
+        if (window.top !== window.self)
+            return null; // framed: SameSite=Lax cookies don't ride iframe navigations
+    }
+    catch (_a) {
+        return null;
+    }
+    try {
+        const here = new URL(window.location.href);
+        const host = here.hostname;
+        const isLocalhost = host === 'localhost' || host === '127.0.0.1' || host.endsWith('.localhost');
+        const trusted = here.protocol === 'https:' &&
+            (host === 'bounded.sh' ||
+                host.endsWith('.bounded.sh') ||
+                host.endsWith('.bounded.page') ||
+                host.endsWith('.oapps.fun') ||
+                isLocalhost);
+        if (!trusted)
+            return null;
+        const base = issuerBase.replace(/\/$/, '');
+        return `${base}/logout?redirect_uri=${encodeURIComponent(here.href)}`;
+    }
+    catch (_b) {
+        return null;
+    }
+}
+async function logout$1(options) {
     // Re-initialize the provider if it was cleared by a prior logout — the exact mirror
     // of login()'s self-heal above. A hosted popup/redirect login (loginWithPopup /
     // completeLoginFromRedirect) establishes a session WITHOUT touching the provider
@@ -4649,13 +4819,28 @@ async function logout$1() {
     // mistake a local-only logout for server revocation.
     const sm = core.getActiveSessionManager();
     const refreshToken = sm.getRefreshToken();
+    const sessionIssuer = sm.getIssuer();
     if (refreshToken)
-        await core.revokeSession(refreshToken, (_a = sm.getIssuer()) !== null && _a !== void 0 ? _a : undefined);
+        await core.revokeSession(refreshToken, sessionIssuer !== null && sessionIssuer !== void 0 ? sessionIssuer : undefined);
+    // Hosted sessions ('email' covers the whole hosted surface: email OTP +
+    // social + the OIDC redirect/popup flows) are the ones with an issuer
+    // cookie; wallet and guest sessions have nothing hosted to end.
+    const wasHosted = (currentAuthMethod !== null && currentAuthMethod !== void 0 ? currentAuthMethod : getStoredAuthMethod()) === 'email';
     await currentAuthProvider.logout();
     setStoredAuthMethod(null);
     currentAuthProvider = null;
     currentAuthMethod = null;
     currentAuthProviderConfigKey = null;
+    if (wasHosted && !(options === null || options === void 0 ? void 0 : options.keepIssuerSession)) {
+        const issuerBase = sessionIssuer
+            || (await core.getConfig()).humanAuthApiUrl
+            || 'https://auth.bounded.sh';
+        const bounce = issuerLogoutBounceUrl(issuerBase);
+        // Local state is already cleared, so even if the navigation is stopped
+        // (tab close, extension) the app-side logout has fully happened.
+        if (bounce)
+            window.location.href = bounce;
+    }
 }
 
 /**
@@ -4785,11 +4970,11 @@ async function login(options) {
     setCurrentUser(loggedInUser);
     return currentUser;
 }
-async function logout() {
+async function logout(options) {
     if (!authProviderInstance) {
         throw new Error('SDK not initialized. Please call init() first.');
     }
-    await logout$1();
+    await logout$1(options);
     setCurrentUser(null);
 }
 var hasRunFirstTime = false;
@@ -4828,21 +5013,25 @@ function setCurrentUser(user) {
 function getCurrentUser() {
     return currentUser;
 }
+/** @internal Snapshot/restore surface for transactional auth-provider switches. */
+function getAuthProviderInstance() {
+    return authProviderInstance;
+}
 function setAuthProviderInstance(provider) {
     authProviderInstance = provider;
 }
 
-var _a;
+var _a$2;
 // Whether we're in a server-side rendering context (no hooks allowed).
 // React Native has no `window` but DOES support hooks.
 // We detect Node SSR specifically via process.versions.node to avoid
 // false positives from Node 21+ which defines `navigator` globally.
-const isSSR = typeof window === 'undefined'
+const isSSR$2 = typeof window === 'undefined'
     && typeof process !== 'undefined'
-    && !!((_a = process.versions) === null || _a === void 0 ? void 0 : _a.node);
+    && !!((_a$2 = process.versions) === null || _a$2 === void 0 ? void 0 : _a$2.node);
 function useAuth() {
     // Provide a fallback so server render doesn't break
-    if (isSSR) {
+    if (isSSR$2) {
         return {
             login: async (_options) => undefined,
             logout: async () => undefined,
@@ -4904,6 +5093,613 @@ function useAuth() {
     };
 }
 
+var _a$1;
+// SSR guard (mirrors useAuth): no hooks/subscriptions during Node server render.
+// React Native has no `window` but DOES support hooks, so detect Node SSR
+// specifically via process.versions.node.
+const isSSR$1 = typeof window === 'undefined'
+    && typeof process !== 'undefined'
+    && !!((_a$1 = process.versions) === null || _a$1 === void 0 ? void 0 : _a$1.node);
+function useQuery(path, options) {
+    if (isSSR$1) {
+        return { data: undefined, loading: true, error: null };
+    }
+    const [data, setData] = React__namespace.useState(undefined);
+    const [loading, setLoading] = React__namespace.useState(true);
+    const [error, setError] = React__namespace.useState(null);
+    // Re-subscribe only when the query actually changes (not on every render).
+    const optionsKey = options ? JSON.stringify(options) : '';
+    React__namespace.useEffect(() => {
+        if (!path) {
+            setData(undefined);
+            setLoading(false);
+            setError(null);
+            return;
+        }
+        let active = true;
+        let unsubscribe;
+        setLoading(true);
+        setError(null);
+        core.subscribe(path, Object.assign(Object.assign({}, options), { onData: (d) => {
+                if (!active)
+                    return;
+                // A reconnect can legitimately surface a transport error before the
+                // socket re-authenticates and sends a new authorized snapshot. That
+                // fresh snapshot is the recovery boundary: keep the error visible
+                // until data arrives, then clear it so React does not remain stuck on
+                // a failure page after realtime has recovered.
+                setError(null);
+                setData(d);
+                setLoading(false);
+            }, onError: (e) => {
+                if (!active)
+                    return;
+                setError(e instanceof Error ? e : new Error(String(e)));
+                setLoading(false);
+            } }))
+            .then((unsub) => {
+            if (active)
+                unsubscribe = unsub;
+            else
+                void unsub(); // unmounted before subscribe resolved
+        })
+            .catch((e) => {
+            if (!active)
+                return;
+            setError(e instanceof Error ? e : new Error(String(e)));
+            setLoading(false);
+        });
+        return () => {
+            active = false;
+            void (unsubscribe === null || unsubscribe === void 0 ? void 0 : unsubscribe());
+        };
+        // optionsKey captures the option object's contents; path is the other input.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [path, optionsKey]);
+    return { data, loading, error };
+}
+
+// Wrapper for getIdToken - passes isServer=false for client-side usage
+async function getIdToken() {
+    return core.getIdToken(false);
+}
+
+var __rest = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+/** A structured non-2xx response from the developer API. */
+class BuildsApiError extends Error {
+    constructor(init) {
+        super(init.message);
+        this.name = 'BuildsApiError';
+        this.code = init.code;
+        this.retryable = init.retryable;
+        this.status = init.status;
+        this.details = init.details;
+        this.retryAfterMs = init.retryAfterMs;
+    }
+}
+const memoryIdempotencyKeys = new Map();
+const IDEMPOTENCY_STORAGE_PREFIX = 'bounded:build:idempotency:';
+function retryAfterMs(response) {
+    var _a, _b;
+    const value = (_b = (_a = response.headers) === null || _a === void 0 ? void 0 : _a.get) === null || _b === void 0 ? void 0 : _b.call(_a, 'Retry-After');
+    if (!value)
+        return undefined;
+    const seconds = Number(value);
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return Math.ceil(seconds * 1000);
+    const at = Date.parse(value);
+    if (!Number.isFinite(at))
+        return undefined;
+    return Math.max(0, at - Date.now());
+}
+async function responseBody(response) {
+    const text = await response.text();
+    if (!text)
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch (_a) {
+        return { raw: text };
+    }
+}
+function apiError(response, body) {
+    const envelope = body;
+    const nested = (envelope === null || envelope === void 0 ? void 0 : envelope.error) && typeof envelope.error === 'object'
+        ? envelope.error
+        : undefined;
+    const hasNestedDetails = !!nested && Object.prototype.hasOwnProperty.call(nested, 'details');
+    const hasTopLevelDetails = !!body
+        && typeof body === 'object'
+        && Object.prototype.hasOwnProperty.call(body, 'details');
+    const legacyCode = typeof (body === null || body === void 0 ? void 0 : body.error) === 'string' ? body.error : undefined;
+    const code = typeof (nested === null || nested === void 0 ? void 0 : nested.code) === 'string'
+        ? nested.code
+        : legacyCode !== null && legacyCode !== void 0 ? legacyCode : `http_${response.status}`;
+    const message = typeof (nested === null || nested === void 0 ? void 0 : nested.message) === 'string'
+        ? nested.message
+        : typeof (body === null || body === void 0 ? void 0 : body.message) === 'string'
+            ? body.message
+            : `Developer API request failed with HTTP ${response.status}`;
+    const retryable = typeof (nested === null || nested === void 0 ? void 0 : nested.retryable) === 'boolean'
+        ? nested.retryable
+        : response.status === 429 || response.status >= 500;
+    return new BuildsApiError(Object.assign(Object.assign({ code,
+        message,
+        retryable, status: response.status }, (hasNestedDetails
+        ? { details: nested === null || nested === void 0 ? void 0 : nested.details }
+        : hasTopLevelDetails
+            ? { details: body.details }
+            : {})), (response.status === 429 ? { retryAfterMs: retryAfterMs(response) } : {})));
+}
+/** @internal Shared authenticated developer-api transport for builds and apps. */
+async function requestDevApi(path, request = {}) {
+    var _a, _b;
+    const config = await core.getConfig();
+    const base = (_a = config.devApiUrl) === null || _a === void 0 ? void 0 : _a.replace(/\/$/, '');
+    if (!base) {
+        throw new Error('Bounded developer API is not configured. Pass devApiUrl or a Bounded network to init().');
+    }
+    // Reuse the exact accessor exposed publicly as getIdToken().
+    const token = await getIdToken();
+    if (!token) {
+        throw new BuildsApiError({
+            code: 'auth_required',
+            message: 'Sign in before calling the Bounded developer API.',
+            retryable: false,
+            status: 401,
+        });
+    }
+    const hasBody = request.body !== undefined;
+    const response = await fetch(`${base}${path}`, Object.assign({ method: (_b = request.method) !== null && _b !== void 0 ? _b : 'GET', headers: Object.assign({ Authorization: `Bearer ${token}` }, (hasBody ? { 'Content-Type': 'application/json' } : {})) }, (hasBody ? { body: JSON.stringify(request.body) } : {})));
+    const body = await responseBody(response);
+    if (!response.ok)
+        throw apiError(response, body);
+    return body;
+}
+function intentStorageKey(intentKey) {
+    return `${IDEMPOTENCY_STORAGE_PREFIX}${intentKey}`;
+}
+function isValidIdempotencyKey(value) {
+    return typeof value === 'string' && value.length > 0 && value.length <= 256;
+}
+function readPersistedIdempotencyKey(intentKey) {
+    var _a;
+    const storageKey = intentStorageKey(intentKey);
+    try {
+        const stored = (_a = globalThis.sessionStorage) === null || _a === void 0 ? void 0 : _a.getItem(storageKey);
+        if (isValidIdempotencyKey(stored))
+            return stored;
+    }
+    catch (_b) {
+        // Storage can be disabled by browser privacy policy; use module memory.
+    }
+    const inMemory = memoryIdempotencyKeys.get(storageKey);
+    return isValidIdempotencyKey(inMemory) ? inMemory : undefined;
+}
+function persistIdempotencyKey(intentKey, idempotencyKey) {
+    var _a;
+    const storageKey = intentStorageKey(intentKey);
+    memoryIdempotencyKeys.set(storageKey, idempotencyKey);
+    try {
+        (_a = globalThis.sessionStorage) === null || _a === void 0 ? void 0 : _a.setItem(storageKey, idempotencyKey);
+    }
+    catch (_b) {
+        // The in-memory write above is the React Native / disabled-storage fallback.
+    }
+}
+function randomHex(bytes) {
+    const cryptoObject = globalThis.crypto;
+    if (cryptoObject === null || cryptoObject === void 0 ? void 0 : cryptoObject.getRandomValues) {
+        const values = new Uint8Array(bytes);
+        cryptoObject.getRandomValues(values);
+        return Array.from(values, (value) => value.toString(16).padStart(2, '0')).join('');
+    }
+    let value = '';
+    for (let index = 0; index < bytes; index += 1) {
+        value += Math.floor(Math.random() * 256).toString(16).padStart(2, '0');
+    }
+    return value;
+}
+function mintIdempotencyKey() {
+    const cryptoObject = globalThis.crypto;
+    if (typeof (cryptoObject === null || cryptoObject === void 0 ? void 0 : cryptoObject.randomUUID) === 'function') {
+        return `build_${cryptoObject.randomUUID()}`;
+    }
+    return `build_${Date.now().toString(36)}_${randomHex(16)}`;
+}
+function actionIdempotencyKey(options, action) {
+    const supplied = options.idempotencyKey;
+    if (supplied !== undefined) {
+        if (!isValidIdempotencyKey(supplied)) {
+            throw new TypeError('idempotencyKey must be between 1 and 256 characters.');
+        }
+        if (options.intentKey)
+            persistIdempotencyKey(options.intentKey, supplied);
+        return supplied;
+    }
+    if (!options.intentKey) {
+        throw new TypeError(`intentKey is required when ${action} auto-mints an idempotency key.`);
+    }
+    const existing = readPersistedIdempotencyKey(options.intentKey);
+    if (existing)
+        return existing;
+    const minted = mintIdempotencyKey();
+    // This is deliberately synchronous and happens before requestDevApi can fetch.
+    persistIdempotencyKey(options.intentKey, minted);
+    return minted;
+}
+function appPath(appId) {
+    return `/app/${encodeURIComponent(appId)}/builds`;
+}
+async function submit(appId, options) {
+    const idempotencyKey = actionIdempotencyKey(options, 'submit()');
+    const { intentKey: _intentKey, idempotencyKey: _suppliedKey } = options, submission = __rest(options, ["intentKey", "idempotencyKey"]);
+    return requestDevApi(appPath(appId), {
+        method: 'POST',
+        body: Object.assign(Object.assign({}, submission), { idempotencyKey }),
+    });
+}
+async function get(appId, runId) {
+    return requestDevApi(`${appPath(appId)}/${encodeURIComponent(runId)}`);
+}
+async function events(appId, runId, after = 0) {
+    const cursor = Number.isFinite(after) ? Math.max(0, Math.floor(after)) : 0;
+    return requestDevApi(`${appPath(appId)}/${encodeURIComponent(runId)}/events?after=${cursor}`);
+}
+async function cancel(appId, runId) {
+    return requestDevApi(`${appPath(appId)}/${encodeURIComponent(runId)}/cancel`, { method: 'POST' });
+}
+async function decideGate(appId, runId, gateId, options) {
+    const idempotencyKey = actionIdempotencyKey(options, 'decideGate()');
+    const { intentKey: _intentKey, idempotencyKey: _suppliedKey } = options, decision = __rest(options, ["intentKey", "idempotencyKey"]);
+    return requestDevApi(`${appPath(appId)}/${encodeURIComponent(runId)}/gates/${encodeURIComponent(gateId)}/decision`, { method: 'POST', body: Object.assign(Object.assign({}, decision), { idempotencyKey }) });
+}
+async function topup(appId, runId, options) {
+    return requestDevApi(`${appPath(appId)}/${encodeURIComponent(runId)}/topup`, { method: 'POST', body: options });
+}
+async function list$1(appId, limit = 20) {
+    const requestedLimit = Number.isFinite(limit) ? Math.max(1, Math.floor(limit)) : 20;
+    return requestDevApi(`${appPath(appId)}?limit=${requestedLimit}`);
+}
+
+// Source of truth for these strings:
+// packages/cdk/cloudflare/bounded-build/src/types.ts. Keep them string-pinned;
+// wire:1 remains additive and callers must tolerate unknown response strings.
+const NON_TERMINAL_STATES = [
+    'queued',
+    'admitted',
+    'executing',
+    'preview_ready',
+    'parked',
+    'resuming',
+    'promoting',
+    'quarantined',
+];
+const TERMINAL_STATES = [
+    'promoted',
+    'failed',
+    'canceled',
+    'rejected',
+    'expired',
+    'rebase_required',
+    'reported',
+];
+const RUN_STATES = [
+    ...NON_TERMINAL_STATES,
+    ...TERMINAL_STATES,
+];
+const PARK_REASONS = ['gate', 'funding'];
+const FAILURE_REASONS = [
+    'admission_rejected',
+    'dispatch_timeout',
+    'auth_revoked',
+    'owner_changed',
+    'policy_changed',
+    'quarantine_forced',
+    'bind_failed',
+    'internal_error',
+];
+
+const NORMAL_POLL_MS = 2000;
+const PARKED_POLL_MS = 5000;
+const LONG_RUNNING_POLL_MS = 10000;
+const TWO_MINUTES_MS = 2 * 60000;
+const TEN_MINUTES_MS = 10 * 60000;
+const terminalStates = new Set(TERMINAL_STATES);
+function pollCadence(state, elapsedMs) {
+    if (elapsedMs >= TEN_MINUTES_MS)
+        return LONG_RUNNING_POLL_MS;
+    if ((state === null || state === void 0 ? void 0 : state.startsWith('parked')) || elapsedMs >= TWO_MINUTES_MS)
+        return PARKED_POLL_MS;
+    return NORMAL_POLL_MS;
+}
+function retryCadence(error, state, elapsedMs) {
+    const cadence = pollCadence(state, elapsedMs);
+    if (error instanceof BuildsApiError && error.status === 429 && error.retryAfterMs !== undefined) {
+        return Math.max(cadence, error.retryAfterMs);
+    }
+    return cadence;
+}
+function hasRetryAfter(error) {
+    return error instanceof BuildsApiError
+        && error.status === 429
+        && error.retryAfterMs !== undefined;
+}
+// A permanent API refusal (expired session, revoked access, unknown run) will
+// never heal by re-polling; the loop must stop and surface it instead of
+// retrying forever. 429 stays retryable regardless of the server envelope.
+function isPermanentError(error) {
+    return error instanceof BuildsApiError
+        && error.status !== 429
+        && error.retryable === false;
+}
+function newEvents(rows, lastSeq, seen) {
+    const cursorBeforePoll = lastSeq;
+    const fresh = [];
+    let nextCursor = lastSeq;
+    for (const event of rows) {
+        if (!Number.isFinite(event === null || event === void 0 ? void 0 : event.seq))
+            continue;
+        nextCursor = Math.max(nextCursor, event.seq);
+        if (event.seq <= cursorBeforePoll || seen.has(event.seq))
+            continue;
+        seen.add(event.seq);
+        fresh.push(event);
+    }
+    return { events: fresh, lastSeq: nextCursor };
+}
+/**
+ * Poll a build view and its event cursor until stopped or the run reaches a
+ * known terminal state. Unknown state strings remain untouched and nonterminal.
+ */
+function watch(appId, runId, onUpdate, options = {}) {
+    const startedAt = Date.now();
+    const seenSeqs = new Set();
+    let lastSeq = Number.isFinite(options.after)
+        ? Math.max(0, Math.floor(options.after))
+        : 0;
+    let timer;
+    let active = true;
+    let lastState;
+    const stop = () => {
+        active = false;
+        if (timer !== undefined) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+    };
+    const schedule = (delayMs) => {
+        if (!active)
+            return;
+        timer = setTimeout(() => {
+            timer = undefined;
+            void poll();
+        }, delayMs);
+    };
+    const reportError = (error) => {
+        var _a;
+        try {
+            (_a = options.onError) === null || _a === void 0 ? void 0 : _a.call(options, error);
+        }
+        catch (_b) {
+            // A consumer error callback must not break the transport loop.
+        }
+    };
+    const publish = (run, events) => {
+        try {
+            onUpdate({ run, events });
+        }
+        catch (_a) {
+            // Polling is transport state; consumer render errors must not strand it.
+        }
+    };
+    const poll = async () => {
+        if (!active)
+            return;
+        let run;
+        try {
+            const view = await get(appId, runId);
+            if (!active)
+                return;
+            run = view.run;
+            lastState = run.state;
+        }
+        catch (error) {
+            if (!active)
+                return;
+            reportError(error);
+            if (isPermanentError(error)) {
+                stop();
+                return;
+            }
+            schedule(retryCadence(error, lastState, Date.now() - startedAt));
+            return;
+        }
+        try {
+            const response = await events(appId, runId, lastSeq);
+            if (!active)
+                return;
+            const deduped = newEvents(Array.isArray(response.events) ? response.events : [], lastSeq, seenSeqs);
+            lastSeq = deduped.lastSeq;
+            publish(run, deduped.events);
+        }
+        catch (error) {
+            if (!active)
+                return;
+            // The view still advances UI state even when event replay is rate-limited.
+            publish(run, []);
+            reportError(error);
+            if (terminalStates.has(run.state)) {
+                // The run itself is done, but a rate-limited final event replay still
+                // owes the caller its unseen seq rows. Honor Retry-After, retry the
+                // piggyback once the limiter permits it, then stop after a successful
+                // replay. Other terminal replay failures stop normally.
+                if (hasRetryAfter(error)) {
+                    schedule(retryCadence(error, run.state, Date.now() - startedAt));
+                    return;
+                }
+                stop();
+                return;
+            }
+            if (isPermanentError(error)) {
+                stop();
+                return;
+            }
+            schedule(retryCadence(error, run.state, Date.now() - startedAt));
+            return;
+        }
+        if (!active)
+            return;
+        if (terminalStates.has(run.state)) {
+            // Drain the remaining event pages before stopping: a resumed terminal
+            // watch may owe the caller more rows than one page returns. Each page
+            // advances the cursor, so the loop terminates; the cap is a backstop.
+            for (let page = 0; page < 50 && active; page += 1) {
+                let drained;
+                try {
+                    const response = await events(appId, runId, lastSeq);
+                    if (!active)
+                        return;
+                    drained = newEvents(Array.isArray(response.events) ? response.events : [], lastSeq, seenSeqs);
+                }
+                catch (error) {
+                    reportError(error);
+                    break;
+                }
+                if (drained.events.length === 0)
+                    break;
+                lastSeq = drained.lastSeq;
+                publish(run, drained.events);
+            }
+            stop();
+            return;
+        }
+        schedule(pollCadence(run.state, Date.now() - startedAt));
+    };
+    void poll();
+    return { stop };
+}
+
+var _a;
+// SSR guard (mirrors useAuth): no hooks/subscriptions during Node server render.
+// React Native has no `window` but DOES support hooks, so detect Node SSR
+// specifically via process.versions.node.
+const isSSR = typeof window === 'undefined'
+    && typeof process !== 'undefined'
+    && !!((_a = process.versions) === null || _a === void 0 ? void 0 : _a.node);
+function useBuildRun(appId, runId, options) {
+    if (isSSR) {
+        return { run: null, events: [], loading: true, error: null };
+    }
+    const [run, setRun] = React__namespace.useState(null);
+    const [events, setEvents] = React__namespace.useState([]);
+    const [loading, setLoading] = React__namespace.useState(true);
+    const [error, setError] = React__namespace.useState(null);
+    const optionsKey = options ? JSON.stringify(options) : '';
+    React__namespace.useEffect(() => {
+        setRun(null);
+        setEvents([]);
+        setError(null);
+        if (!appId || !runId) {
+            setLoading(false);
+            return;
+        }
+        let active = true;
+        setLoading(true);
+        const handle = watch(appId, runId, ({ run: nextRun, events: nextEvents }) => {
+            if (!active)
+                return;
+            setRun(nextRun);
+            if (nextEvents.length > 0) {
+                setEvents((current) => {
+                    const seen = new Set(current.map((event) => event.seq));
+                    return [...current, ...nextEvents.filter((event) => !seen.has(event.seq))];
+                });
+            }
+            setError(null);
+            setLoading(false);
+        }, Object.assign(Object.assign({}, options), { onError: (value) => {
+                if (!active)
+                    return;
+                setError(value instanceof Error ? value : new Error(String(value)));
+                setLoading(false);
+            } }));
+        return () => {
+            active = false;
+            handle.stop();
+        };
+        // optionsKey captures the option object's contents; ids are the other inputs.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [appId, runId, optionsKey]);
+    return { run, events, loading, error };
+}
+
+/**
+ * Platform first-party surfaces only (bounded.sh, oapps.fun, localhost) —
+ * dev-api CORS blocks calls from generated-app origins. Server-side callers unaffected.
+ */
+const builds = {
+    submit,
+    get,
+    events,
+    cancel,
+    decideGate,
+    topup,
+    list: list$1,
+    watch,
+};
+
+async function create(options = {}) {
+    const body = Object.assign(Object.assign(Object.assign(Object.assign({}, (options.name !== undefined ? { name: options.name } : {})), (options.prompt !== undefined ? { prompt: options.prompt } : {})), (options.clientToken !== undefined ? { clientToken: options.clientToken } : {})), (options.intent !== undefined ? { intent: options.intent } : {}));
+    const app = await requestDevApi('/apps/new', {
+        method: 'POST',
+        body,
+    });
+    return Object.assign(Object.assign({ appId: app.appId }, (typeof app.slug === 'string' && app.slug ? { slug: app.slug } : {})), { url: app.url, 
+        // Fail closed against an older server response that omitted this field.
+        policySeeded: app.policySeeded === true });
+}
+async function list() {
+    // This legacy-compatible action shape is also used by oapps.fun listMyApps.
+    const response = await requestDevApi('/', {
+        method: 'POST',
+        body: { action: 'listApps' },
+    });
+    const rows = Array.isArray(response.apps) ? response.apps : [];
+    return rows
+        .map((value) => {
+        var _a, _b, _c, _d;
+        const row = value && typeof value === 'object'
+            ? value
+            : {};
+        const appId = String((_c = (_b = (_a = row._id) !== null && _a !== void 0 ? _a : row.id) !== null && _b !== void 0 ? _b : row.appId) !== null && _c !== void 0 ? _c : '');
+        if (!/^[a-f0-9]{24}$/i.test(appId))
+            return null;
+        const name = String((_d = row.name) !== null && _d !== void 0 ? _d : '').trim() || '(unnamed app)';
+        const slug = typeof row.slug === 'string' && row.slug ? row.slug : undefined;
+        const url = typeof row.url === 'string' && row.url.trim() ? row.url.trim() : undefined;
+        return Object.assign(Object.assign({ appId,
+            name }, (slug ? { slug } : {})), (url ? { url } : {}));
+    })
+        .filter((app) => app !== null);
+}
+/**
+ * Platform first-party surfaces only (bounded.sh, oapps.fun, localhost) —
+ * dev-api CORS blocks calls from generated-app origins. Server-side callers unaffected.
+ */
+const apps = { create, list };
+
 async function deserializeTransaction(tx) {
     // Literal specifier so bundlers can code-split the lazy chunk.
     const { Transaction, VersionedTransaction } = await import('@solana/web3.js');
@@ -4916,11 +5712,6 @@ async function deserializeTransaction(tx) {
     }
 }
 
-// Wrapper for getIdToken - passes isServer=false for client-side usage
-async function getIdToken() {
-    return core.getIdToken(false);
-}
-
 /**
  * Extracts a human-readable error message from Solana transaction logs.
  */
@@ -5316,15 +6107,110 @@ class PrivyExpoProvider {
     }
 }
 
+/**
+ * Default provider discovery: Phantom-first, then any Wallet-Standard
+ * `window.solana`. Kept tiny + synchronous (no heavy imports) so it works inside
+ * a user gesture and can be eagerly exported from the SDK entry.
+ */
+function defaultInjectedProvider() {
+    var _a;
+    if (typeof window === 'undefined')
+        return null;
+    const w = window;
+    const phantom = (_a = w === null || w === void 0 ? void 0 : w.phantom) === null || _a === void 0 ? void 0 : _a.solana;
+    if (phantom && typeof phantom.signMessage === 'function')
+        return phantom;
+    const generic = w === null || w === void 0 ? void 0 : w.solana;
+    if (generic && typeof generic.signMessage === 'function')
+        return generic;
+    return null;
+}
+
+// injected-evm-wallet-types.ts — tiny, dependency-free surface for the EVM
+// WALLET LOGIN path (BYO wallet via SIWE). The EVM twin of
+// injected-wallet-types.ts: kept separate from injected-evm-wallet-provider.ts
+// so the SDK entry can eagerly export the type surface + the provider-discovery
+// helper WITHOUT dragging the provider class into the default bundle. The
+// provider is lazy-loaded by getAuthProvider() when an app opts into
+// authMethod:'evm-wallet'.
+//
+// It rides the standard EIP-1193 injected provider a browser wallet exposes
+// (MetaMask / Rabby / Coinbase Wallet / any window.ethereum), discovered via
+// EIP-6963 (multi-wallet, collision-free) with a window.ethereum fallback. It
+// needs NO viem/ethers and NO React — EIP-1193 request() + hex strings suffice.
+// EIP-6963 is announcement-based: wallets add an `eip6963:requestProvider`
+// listener and synchronously dispatch `eip6963:announceProvider` in response. We
+// keep a persistent collector so announcements (including late ones) are
+// captured, and re-request on demand.
+const announcedProviders = [];
+let announceListenerAttached = false;
+function attachAnnounceListener() {
+    if (announceListenerAttached || typeof window === 'undefined')
+        return;
+    announceListenerAttached = true;
+    window.addEventListener('eip6963:announceProvider', (event) => {
+        const detail = event === null || event === void 0 ? void 0 : event.detail;
+        if (detail &&
+            detail.provider &&
+            typeof detail.provider.request === 'function' &&
+            !announcedProviders.some((d) => { var _a, _b; return ((_a = d.info) === null || _a === void 0 ? void 0 : _a.uuid) === ((_b = detail.info) === null || _b === void 0 ? void 0 : _b.uuid); })) {
+            announcedProviders.push(detail);
+        }
+    });
+}
+/**
+ * Request + collect EIP-6963 providers. Dispatches `eip6963:requestProvider`
+ * (synchronous — already-loaded wallets announce in the same tick) and returns
+ * every wallet announced so far. Kept synchronous so it works inside a user
+ * gesture and can be eagerly exported from the SDK entry.
+ */
+function requestEip6963Providers() {
+    if (typeof window === 'undefined')
+        return [];
+    attachAnnounceListener();
+    try {
+        window.dispatchEvent(new Event('eip6963:requestProvider'));
+    }
+    catch (_a) {
+        /* older browsers without Event constructor — fall through to window.ethereum */
+    }
+    return announcedProviders.slice();
+}
+/**
+ * Default EVM provider discovery: EIP-6963 first (multi-wallet, collision-free),
+ * then legacy `window.ethereum`. Returns null when no injected wallet is present.
+ */
+function defaultInjectedEvmProvider() {
+    if (typeof window === 'undefined')
+        return null;
+    const details = requestEip6963Providers();
+    if (details.length > 0)
+        return details[0].provider;
+    const eth = window.ethereum;
+    if (eth && typeof eth.request === 'function')
+        return eth;
+    return null;
+}
+
+exports.BuildsApiError = BuildsApiError;
 exports.EMBEDDED_WALLET_UNSUPPORTED = EMBEDDED_WALLET_UNSUPPORTED;
+exports.FAILURE_REASONS = FAILURE_REASONS;
+exports.NON_TERMINAL_STATES = NON_TERMINAL_STATES;
 exports.OffchainAuthProvider = OffchainAuthProvider;
+exports.PARK_REASONS = PARK_REASONS;
 exports.PrivyExpoProvider = PrivyExpoProvider;
+exports.RUN_STATES = RUN_STATES;
 exports.SURFNET_RPC_URL = SURFNET_RPC_URL;
+exports.TERMINAL_STATES = TERMINAL_STATES;
+exports.apps = apps;
 exports.bs58 = bs58;
 exports.bufferExports = bufferExports;
+exports.builds = builds;
 exports.completeLoginFromRedirect = completeLoginFromRedirect;
 exports.completeLoginInPopup = completeLoginInPopup;
 exports.confirmAndCheckTransaction = confirmAndCheckTransaction;
+exports.defaultInjectedEvmProvider = defaultInjectedEvmProvider;
+exports.defaultInjectedProvider = defaultInjectedProvider;
 exports.deserializeTransaction = deserializeTransaction;
 exports.embeddedRunEvmTransaction = embeddedRunEvmTransaction;
 exports.embeddedSignAndSubmit = embeddedSignAndSubmit;
@@ -5344,10 +6230,13 @@ exports.logout = logout;
 exports.normalizeSolanaRpcUrl = normalizeSolanaRpcUrl;
 exports.onAuthLoadingChanged = onAuthLoadingChanged;
 exports.onAuthStateChanged = onAuthStateChanged;
+exports.requestEip6963Providers = requestEip6963Providers;
 exports.resolveSolanaRpcUrl = resolveSolanaRpcUrl;
 exports.setAuthLoading = setAuthLoading;
 exports.setCurrentUser = setCurrentUser;
 exports.setPlatform = setPlatform;
 exports.signInAnonymously = signInAnonymously;
 exports.useAuth = useAuth;
-//# sourceMappingURL=index.native-BZCc0gO-.js.map
+exports.useBuildRun = useBuildRun;
+exports.useQuery = useQuery;
+//# sourceMappingURL=index-BsrZb496.js.map