@bounded-sh/client 0.0.48 → 0.0.50

package/dist/{index.native-CytJPNQV.mjs → index-BYy1tSkr.mjs}

@@ -1,4 +1,4 @@
-import { assertCanonicalBoundedRuntimeWriteCalldata, getActiveSessionManager, getConfig, WebSessionManager, ReactNativeSessionManager, revokeSession, init as init$1, reconnectWithNewAuth, deriveUserIdentityFromIdToken, getIdToken as getIdToken$1, convertRemainingAccounts, buildSetDocumentsTransaction, genAuthNonce, genSolanaMessage, createSessionWithSignature } from '@bounded-sh/core';
+import { assertCanonicalBoundedRuntimeWriteCalldata, getActiveSessionManager, getConfig, WebSessionManager, ReactNativeSessionManager, revokeSession, init as init$1, reconnectWithNewAuth, deriveUserIdentityFromIdToken, subscribe, getIdToken as getIdToken$1, convertRemainingAccounts, buildSetDocumentsTransaction, genAuthNonce, genSolanaMessage, createSessionWithSignature } from '@bounded-sh/core';
 import * as React from 'react';
 
 /**
@@ -4226,6 +4226,41 @@ function setStoredAuthMethod(method) {
         // storage might not be available
     }
 }
+function getStoredIdToken() {
+    try {
+        return 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.
  *
@@ -4236,7 +4271,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'))
@@ -4401,7 +4445,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 import('./email-auth-provider-GRj8IOg2.mjs')).EmailAuthProvider();
+            currentAuthProvider = new (await import('./email-auth-provider-DIZAETBC.mjs')).EmailAuthProvider();
             break;
         case "wallet":
         case "phantom": {
@@ -4420,7 +4464,7 @@ async function getAuthProvider(config) {
             if (!isWalletLoginEnabled(config)) {
                 throw walletLoginNotEnabledError(authMethod);
             }
-            const { InjectedWalletProvider } = await import('./injected-wallet-provider-DCwygA3j.mjs');
+            const { InjectedWalletProvider } = await import('./injected-wallet-provider-BfzoheDy.mjs');
             currentAuthProvider = new InjectedWalletProvider(resolveInjectedWalletConfig(config), rpcUrl, configuredNetwork);
             break;
         }
@@ -4433,7 +4477,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 import('./injected-evm-wallet-provider-BOMLGGHM.mjs');
+            const { InjectedEvmWalletProvider } = await import('./injected-evm-wallet-provider-sBCSkksr.mjs');
             currentAuthProvider = new InjectedEvmWalletProvider(evmWalletConfig);
             break;
         }
@@ -4461,7 +4505,7 @@ async function getAuthProvider(config) {
             break;
         case "guest":
             // Anonymous auth: a device-local ed25519 keypair signs the challenge.
-            currentAuthProvider = new (await import('./guest-auth-provider-C4BuTNIa.mjs')).GuestAuthProvider();
+            currentAuthProvider = new (await import('./guest-auth-provider-BR0_YL8z.mjs')).GuestAuthProvider();
             break;
     }
     if (!currentAuthProvider) {
@@ -4498,19 +4542,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 import('./guest-auth-provider-C4BuTNIa.mjs')).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 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 import('./guest-auth-provider-BR0_YL8z.mjs')).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 {
+                    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);
@@ -4807,21 +4940,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,
@@ -4883,6 +5020,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.useState(undefined);
+    const [loading, setLoading] = React.useState(true);
+    const [error, setError] = React.useState(null);
+    // Re-subscribe only when the query actually changes (not on every render).
+    const optionsKey = options ? JSON.stringify(options) : '';
+    React.useEffect(() => {
+        if (!path) {
+            setData(undefined);
+            setLoading(false);
+            setError(null);
+            return;
+        }
+        let active = true;
+        let unsubscribe;
+        setLoading(true);
+        setError(null);
+        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 getIdToken$1(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 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.useState(null);
+    const [events, setEvents] = React.useState([]);
+    const [loading, setLoading] = React.useState(true);
+    const [error, setError] = React.useState(null);
+    const optionsKey = options ? JSON.stringify(options) : '';
+    React.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');
@@ -4895,11 +5639,6 @@ async function deserializeTransaction(tx) {
     }
 }
 
-// Wrapper for getIdToken - passes isServer=false for client-side usage
-async function getIdToken() {
-    return getIdToken$1(false);
-}
-
 /**
  * Extracts a human-readable error message from Solana transaction logs.
  */
@@ -5295,5 +6034,90 @@ class PrivyExpoProvider {
     }
 }
 
-export { useAuth as A, deserializeTransaction as B, getIdToken as C, setPlatform as D, EMBEDDED_WALLET_UNSUPPORTED as E, OffchainAuthProvider as O, PrivyExpoProvider as P, SURFNET_RPC_URL as S, hasEmbeddedEvmWallet as a, embeddedSignAndSubmit as b, setAuthLoading as c, bufferExports as d, embeddedRunEvmTransaction as e, bs58 as f, getPlatform as g, hasEmbeddedWallet as h, confirmAndCheckTransaction as i, init as j, getCurrentUser as k, onAuthLoadingChanged as l, getAuthLoading as m, normalizeSolanaRpcUrl as n, onAuthStateChanged as o, login as p, logout as q, resolveSolanaRpcUrl as r, setCurrentUser as s, getAuthProvider as t, signInAnonymously as u, loginWithPrivy as v, loginWithRedirect as w, completeLoginFromRedirect as x, loginWithPopup as y, completeLoginInPopup as z };
-//# sourceMappingURL=index.native-CytJPNQV.mjs.map
+/**
+ * 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;
+}
+
+export { loginWithPopup as A, completeLoginInPopup as B, useAuth as C, useQuery as D, EMBEDDED_WALLET_UNSUPPORTED as E, useBuildRun as F, apps as G, deserializeTransaction as H, getIdToken as I, setPlatform as J, requestEip6963Providers as K, builds as L, BuildsApiError as M, NON_TERMINAL_STATES as N, OffchainAuthProvider as O, PrivyExpoProvider as P, PARK_REASONS as Q, RUN_STATES as R, SURFNET_RPC_URL as S, TERMINAL_STATES as T, FAILURE_REASONS as U, hasEmbeddedEvmWallet as a, embeddedSignAndSubmit as b, setAuthLoading as c, defaultInjectedProvider as d, embeddedRunEvmTransaction as e, bufferExports as f, getPlatform as g, hasEmbeddedWallet as h, bs58 as i, confirmAndCheckTransaction as j, defaultInjectedEvmProvider as k, init as l, getCurrentUser as m, normalizeSolanaRpcUrl as n, onAuthStateChanged as o, onAuthLoadingChanged as p, getAuthLoading as q, resolveSolanaRpcUrl as r, setCurrentUser as s, login as t, logout as u, getAuthProvider as v, signInAnonymously as w, loginWithPrivy as x, loginWithRedirect as y, completeLoginFromRedirect as z };
+//# sourceMappingURL=index-BYy1tSkr.mjs.map