@bounded-sh/client 0.0.100-performance.1 → 0.0.101

package/dist/{index-DmAXYXDi.mjs → index-CaZx7sd8.mjs}

@@ -35,13 +35,6 @@ function walletOperationGuard() {
             throw new Error('wallet_session_changed');
     };
 }
-function walletLoginGuard(signal) {
-    const generation = ++loginGeneration;
-    return () => {
-        if ((signal === null || signal === void 0 ? void 0 : signal.aborted) || generation !== loginGeneration)
-            throw new Error('wallet_login_cancelled');
-    };
-}
 // This realm owns one active SDK session and one retained signer frame.
 let activeWalletState;
 function setWalletSessionState(key, state) { activeWalletState = { key, state }; }
@@ -4522,11 +4515,6 @@ function ensureFonts() {
     link.setAttribute("data-bounded-fonts", "1");
     document.head.append(pre1, pre2, link);
 }
-/** Tag the already mounted login document without moving or navigating it. */
-function bindWarmSignerFrame(frame, context) {
-    if ((modal === null || modal === void 0 ? void 0 : modal.iframe) === frame)
-        modal.iframeContext = context;
-}
 
 // turnkey-wallet-widget.ts - runs one Turnkey signer exchange inside the shared
 // in-app WIDGET (bounded-widget-modal.ts). The Bounded-owned signer page is loaded
@@ -5885,14 +5873,13 @@ function completeLoginInPopup(openerOrigin) {
 // identical to exchangeCode's tail so the realtime worker cannot tell them apart.
 async function establishInlineSession(data, beforeCommit, beforeStore) {
     const base = await issuerBase();
-    beforeCommit === null || beforeCommit === void 0 ? void 0 : beforeCommit();
     const idToken = tokenField(data, 'id_token', 'idToken');
     if (!idToken)
         throw new Error('No id_token in the inline session response');
     const accessToken = tokenField(data, 'access_token', 'accessToken') || idToken;
     const refreshToken = boundedRefreshTokenField(data);
     const user = userFromIdToken(idToken);
-    const rollback = await sessionManager().storeSession(String(user.address || ''), accessToken, idToken, refreshToken, base, () => { beforeCommit === null || beforeCommit === void 0 ? void 0 : beforeCommit(); beforeStore === null || beforeStore === void 0 ? void 0 : beforeStore(); });
+    const rollback = await sessionManager().storeSession(String(user.address || ''), accessToken, idToken, refreshToken, base, () => { });
     // Adopt the OIDC provider on EVERY session surface - including core's signing
     // pointer (getConfig().authProvider), which this path used to skip, leaving
     // onchain writes routed through a previous (e.g. logged-out wallet) provider.
@@ -6321,7 +6308,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-BGTfU1_i.mjs')).EmailAuthProvider();
+            currentAuthProvider = new (await import('./email-auth-provider-BJXeBUwp.mjs')).EmailAuthProvider();
             break;
         case "phantom": {
             // First-class Solana WALLET LOGIN (the poof/TaroBase-style "connect
@@ -6363,7 +6350,7 @@ async function getAuthProvider(config) {
             // (bounded-login-widget.ts), so registration never counts as
             // evidence the user has a wallet.
             await ensureSolanaMobileWalletRegistered(config, configuredNetwork);
-            const { InjectedWalletProvider } = await import('./injected-wallet-provider-CLLhLBAJ.mjs');
+            const { InjectedWalletProvider } = await import('./injected-wallet-provider-DR8xVudg.mjs');
             currentAuthProvider = new InjectedWalletProvider(resolveInjectedWalletConfig(config), rpcUrl, configuredNetwork);
             break;
         }
@@ -6376,7 +6363,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-BPZMEE8I.mjs');
+            const { InjectedEvmWalletProvider } = await import('./injected-evm-wallet-provider-B3Mtkdnu.mjs');
             currentAuthProvider = new InjectedEvmWalletProvider(evmWalletConfig);
             break;
         }
@@ -6401,7 +6388,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-DVxlea-z.mjs')).GuestAuthProvider();
+            currentAuthProvider = new (await import('./guest-auth-provider-CUo6sgop.mjs')).GuestAuthProvider();
             break;
     }
     if (!currentAuthProvider) {
@@ -6463,7 +6450,7 @@ async function signInAnonymously() {
     // 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-DVxlea-z.mjs')).GuestAuthProvider();
+    const provider = new (await import('./guest-auth-provider-CUo6sgop.mjs')).GuestAuthProvider();
     setAuthLoading(true); // reflect "signing in…" while the guest keypair session is minted
     // adoptSessionProvider awaits only getConfig() (already resolved here) and then
     // runs every write - provider/method/config/marker/user - in one synchronous
@@ -6634,7 +6621,7 @@ function ensureSharedWalletLoginReady() {
     if (!sharedWalletReady) {
         sharedWalletReady = (async () => {
             await getConfig();
-            await import('./injected-wallet-provider-CLLhLBAJ.mjs');
+            await import('./injected-wallet-provider-DR8xVudg.mjs');
         })().catch((error) => {
             sharedWalletReady = null;
             throw error;
@@ -6737,7 +6724,7 @@ async function loginWithWallet(options) {
         await ensureSharedWalletLoginReady();
     else
         await ensureWalletLoginReady();
-    const { InjectedWalletProvider } = await import('./injected-wallet-provider-CLLhLBAJ.mjs');
+    const { InjectedWalletProvider } = await import('./injected-wallet-provider-DR8xVudg.mjs');
     // Keep the RAW wallet provider: the offchain wrapper forwards only a fixed
     // set of methods, so cleanup below must speak to the provider that actually
     // holds the config rather than to whatever is wrapping it.
@@ -7743,12 +7730,14 @@ async function startTurnkeyEmailLogin(email) {
         : undefined;
     return {
         email: trimmed, frameUrl, signerOrigin,
-        run(iframe, signal) {
+        run(iframe, _signal) {
             if (!ceremonyId) {
                 return Promise.reject(new Error('This app is not configured for in-frame wallet login. Please try again.'));
             }
             const run = { iframe, base, signerOrigin, appId, email: trimmed, otpId, otpEncryptionTargetBundle, ceremonyId };
-            return frameUrl ? runScopedOtpFrame(run, frameUrl, signal) : runOtpFrame(run);
+            // BSA-2026-004: the login code is typed only in /wallet/turnkey/otp-frame.
+            // The scoped signer URL is for post-login signing, not OTP entry.
+            return runOtpFrame(run);
         },
     };
 }
@@ -7853,104 +7842,6 @@ function runOtpFrame(run) {
         run.iframe.src = url;
     });
 }
-// The scoped document owns both OTP and signing. Adopt only its sanitized app
-// session, acknowledge with a narrow grant, then wait for wallet readiness.
-function runScopedOtpFrame(run, frameUrl, signal) {
-    const assertCurrent = walletLoginGuard(signal);
-    const beforeStore = getActiveSessionManager().captureSessionEstablishment();
-    return new Promise((resolve, reject) => {
-        let settled = false, adopting = false, started = false;
-        let user = null;
-        let adoptedToken = '';
-        let context = null;
-        const post = (data) => { var _a; return (_a = run.iframe.contentWindow) === null || _a === void 0 ? void 0 : _a.postMessage(data, run.signerOrigin); };
-        const cleanup = () => {
-            settled = true;
-            clearTimeout(timer);
-            window.removeEventListener('message', onMessage);
-            signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', abort);
-        };
-        const fail = (error) => { cleanup(); reject(error instanceof Error ? error : new Error(String(error))); };
-        const abort = () => { post({ type: 'bounded:otp:cancel' }); fail(new Error('wallet_login_cancelled')); };
-        const finish = (ready, reason, expiresAt) => {
-            if (!user || !context || getActiveSessionManager().getIdToken() !== adoptedToken) {
-                fail(new Error('wallet_session_changed'));
-                return;
-            }
-            setWalletSessionState(context.key, ready && Number.isFinite(expiresAt) && expiresAt > Date.now()
-                ? { status: 'ready', expiresAt: expiresAt } : { status: 'verification-required', reason });
-            cleanup();
-            resolve(user);
-        };
-        const onMessage = async (event) => {
-            if (settled || event.origin !== run.signerOrigin || event.source !== run.iframe.contentWindow)
-                return;
-            const d = event.data;
-            if (!d || typeof d !== 'object')
-                return;
-            if (d.type === 'bounded:otp:ready' && !started) {
-                started = true;
-                post({ type: 'bounded:otp:start', email: run.email, ceremonyId: run.ceremonyId,
-                    otpId: run.otpId, otpEncryptionTargetBundle: run.otpEncryptionTargetBundle });
-            }
-            if (d.type === 'bounded:otp:wallet-ready' && user) {
-                finish(d.ok === true, typeof d.error === 'string' ? d.error : 'wallet_session_unavailable', d.expiresAt);
-            }
-            if (d.type !== 'bounded:otp:result' || adopting)
-                return;
-            if (d.ok !== true || !d.session || typeof d.session.idToken !== 'string') {
-                fail(new Error(String(d.error || 'wallet_login_failed')));
-                return;
-            }
-            adopting = true;
-            try {
-                assertCurrent();
-                const token = d.session.idToken;
-                const claims = JSON.parse(getPlatform().atob(token.split('.')[1].replace(/-/g, '+').replace(/_/g, '/')));
-                context = walletContextFromClaims(claims, run.base, run.appId, window.location.origin);
-                if (context.scope !== 'app')
-                    throw new Error('wallet_scope_mismatch');
-                user = await establishInlineSession(d.session, () => { assertCurrent(); if (settled)
-                    throw new Error('wallet_login_cancelled'); }, beforeStore);
-                adoptedToken = token;
-                bindWarmSignerFrame(run.iframe, context.key);
-                if (settled || (signal === null || signal === void 0 ? void 0 : signal.aborted) || getActiveSessionManager().getIdToken() !== token)
-                    throw new Error('wallet_session_changed');
-                setWalletSessionState(context.key, { status: 'verification-required', reason: 'wallet_session_pending' });
-                const authorization = await requestTurnkeyActionAuthorization({
-                    baseUrl: run.base, idToken: token, action: 'createWallet', fetchImpl: (u, i) => fetch(u, i),
-                });
-                if (settled || getActiveSessionManager().getIdToken() !== token)
-                    throw new Error('wallet_session_changed');
-                post({ type: 'bounded:otp:authorization', authorization });
-            }
-            catch (error) {
-                if (user && adoptedToken) {
-                    post({ type: 'bounded:otp:authorization', authorization: '' });
-                    finish(false, 'wallet_session_unavailable');
-                }
-                else
-                    fail(error);
-            }
-        };
-        const timer = setTimeout(() => {
-            if (user)
-                finish(false, 'wallet_session_timeout');
-            else
-                fail(new Error('The sign-in code entry timed out. Please try again.'));
-        }, 180000);
-        window.addEventListener('message', onMessage);
-        signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', abort, { once: true });
-        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
-            abort();
-            return;
-        }
-        if (run.iframe.src !== frameUrl)
-            run.iframe.src = frameUrl;
-        // Readiness can predate listener installation when reusing a mounted frame.
-        post({ type: 'bounded:otp:hello' });
-    });
-}
 
 // bounded-login-widget.ts - the UNIFIED Bounded login surface: one in-app card
 // (Shadow-DOM modal from bounded-widget-modal.ts, Bounded look + motion) that folds
@@ -8490,24 +8381,10 @@ async function prepareAndOpen(opts, pending) {
                                 settleAttempt(attempt);
                                 return;
                             }
-                            if (!handle.frameUrl || !handle.signerOrigin) {
-                                if (settleAttempt(attempt))
-                                    swap(renderOtpFrame(handle));
-                                return;
-                            }
-                            const controller = new AbortController();
-                            abortScopedLogin = () => controller.abort();
-                            // Mount once in the shared modal. Moving a live iframe would discard
-                            // the trusted document holding the private in-memory session key.
-                            detachIframe(m);
-                            const frame = ensureIframe(m, handle.frameUrl, handle.signerOrigin, `login:${attempt}`);
-                            setPanelHeight(m, 380);
-                            const completion = handle.run(frame, controller.signal);
-                            m.chain = completion.then(() => undefined, () => undefined);
-                            const user = await completion;
-                            abortScopedLogin = null;
-                            settleAttempt(attempt);
-                            succeed(user);
+                            // BSA-2026-004: collect the code in the Bounded OTP frame, never in
+                            // this tenant DOM and never in the unframeable signer document.
+                            if (settleAttempt(attempt))
+                                swap(renderOtpFrame(handle));
                         })
                             .catch((err) => {
                             if (!settleAttempt(attempt))
@@ -9363,9 +9240,26 @@ async function getReviewCapability(appId, runId, gateId, options) {
         body: { expectedPreviewUrl: options.expectedPreviewUrl },
     });
 }
+/**
+ * Add funds to a run parked for funding. Accounts billed through payer shards refuse it with
+ * `topup_unavailable_payer_shard` (in `details.upstreamCode`): a parked run there holds no money, so the payer adds
+ * credits and submits the build again.
+ */
 async function topup(appId, runId, options) {
     return requestDevApi(`${appPath(appId)}/${encodeURIComponent(runId)}/topup`, { method: 'POST', body: options });
 }
+/** An image build's verified images and its asset's current release. */
+async function media(appId, runId) {
+    return requestDevApi(`${appPath(appId)}/${encodeURIComponent(runId)}/media`);
+}
+/** A short-lived signed URL for one image of an image build (usable directly as an image source). */
+async function mediaDownloadUrl(appId, runId, artifactId) {
+    return requestDevApi(`${appPath(appId)}/${encodeURIComponent(runId)}/media-download-url`, { method: 'POST', body: { artifactId } });
+}
+/** Roll back the release an image build published: its asset returns to the release it replaced. */
+async function rollbackMedia(appId, runId, options = {}) {
+    return requestDevApi(`${appPath(appId)}/${encodeURIComponent(runId)}/media-rollback`, { method: 'POST', body: options.note ? { note: options.note } : {} });
+}
 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}`);
@@ -9397,13 +9291,15 @@ const RUN_STATES = [
     ...NON_TERMINAL_STATES,
     ...TERMINAL_STATES,
 ];
-const PARK_REASONS = ['gate', 'funding'];
+const PARK_REASONS = ['gate', 'funding', 'preview', 'design'];
 const FAILURE_REASONS = [
     'admission_rejected',
     'dispatch_timeout',
     'auth_revoked',
     'owner_changed',
     'policy_changed',
+    'target_retired',
+    'promotion_rejected',
     'quarantine_forced',
     'bind_failed',
     'internal_error',
@@ -9661,6 +9557,345 @@ function useBuildRun(appId, runId, options) {
     return { run, events, loading, error };
 }
 
+const TERMINAL = new Set(['promoted', 'failed', 'canceled', 'rejected', 'expired', 'rebase_required', 'reported']);
+const KEY = { type: 'string', minLength: 1, maxLength: 256, description: 'A key unique to this intent; retrying with the same key never repeats the action.' };
+const RUN_ID = { type: 'string', minLength: 1, maxLength: 128, description: 'The build run id media_create or media_edit returned.' };
+const REGION = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['x', 'y', 'width', 'height'],
+    properties: {
+        x: { type: 'integer', minimum: 0 },
+        y: { type: 'integer', minimum: 0 },
+        width: { type: 'integer', minimum: 1 },
+        height: { type: 'integer', minimum: 1 },
+    },
+    description: 'A rectangle in whole pixels of the image; nothing outside it changes.',
+};
+const SPEC = { type: 'object', description: 'The deliverable spec (image: size, quality, format, background, candidates, model, references, region; video: durationSeconds, resolution, aspectRatio, audio, images, scenes, replaceScenes, captions). See the builds docs.' };
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const text = (value, max) => typeof value === 'string' && value.trim().length > 0 && value.length <= max ? value : undefined;
+const refuse = (code, message, next = ['media_inspect'], retryable = false) => ({ ok: false, code, message, retryable, next });
+function region(value) {
+    if (!isRecord(value))
+        return undefined;
+    const { x, y, width, height } = value;
+    return [x, y, width, height].every(Number.isSafeInteger) && x >= 0 && y >= 0
+        && width >= 1 && height >= 1
+        ? { x: x, y: y, width: width, height: height }
+        : undefined;
+}
+/** A thrown API error, as the tool result the model reads. The developer API answers with a coarse public code and
+ *  relays Build's own reason (base_moved, candidate_unknown, media_storage_quota, ...) as details.upstreamCode. */
+function failure(error) {
+    var _a;
+    const apiError = error;
+    const upstream = (_a = apiError === null || apiError === void 0 ? void 0 : apiError.details) === null || _a === void 0 ? void 0 : _a.upstreamCode;
+    return refuse(typeof upstream === 'string' && /^[a-z][a-z0-9_]{0,79}$/.test(upstream) && upstream !== 'unknown_upstream_error'
+        ? upstream
+        : typeof (apiError === null || apiError === void 0 ? void 0 : apiError.code) === 'string' ? apiError.code : 'request_failed', typeof (apiError === null || apiError === void 0 ? void 0 : apiError.message) === 'string' ? apiError.message : 'The request failed.', ['media_inspect'], (apiError === null || apiError === void 0 ? void 0 : apiError.retryable) === true);
+}
+/** What a run lets an agent do next. */
+function nextFor(run) {
+    var _a;
+    if ((_a = run.design) === null || _a === void 0 ? void 0 : _a.gate)
+        return ['media_select', 'media_revise', 'media_export'];
+    if (run.state === 'promoted')
+        return ['media_export', 'media_edit', 'media_create'];
+    if (run.state === 'parked' && run.parkReason === 'gate')
+        return ['media_propose', 'media_export'];
+    if (TERMINAL.has(run.state))
+        return ['media_create'];
+    return ['media_inspect'];
+}
+function candidateView(candidate) {
+    return Object.assign(Object.assign(Object.assign(Object.assign({ id: candidate.id }, (candidate.url ? { url: candidate.url } : {})), { mimeType: candidate.mimeType, width: candidate.width, height: candidate.height }), (candidate.durationMs !== undefined ? { durationMs: candidate.durationMs } : {})), (candidate.scenes ? { scenes: candidate.scenes } : {}));
+}
+function mediaAgentTools(appId, client = {
+    submit: submit,
+    get: get,
+    decideGate: decideGate,
+    media: media,
+    mediaDownloadUrl: mediaDownloadUrl,
+}) {
+    const run = async (runId) => (await client.get(appId, runId)).run;
+    const submit = async (options) => {
+        try {
+            const submitted = await client.submit(appId, options);
+            return { ok: true, data: { runId: submitted.runId, status: submitted.status }, next: ['media_inspect'] };
+        }
+        catch (error) {
+            return failure(error);
+        }
+    };
+    /** The open design review of a run, or the refusal that explains why there is none. */
+    const openReview = async (input) => {
+        var _a;
+        const runId = text(input.runId, 128);
+        if (!runId)
+            return refuse('input_invalid', 'runId is required.');
+        let current;
+        try {
+            current = await run(runId);
+        }
+        catch (error) {
+            return failure(error);
+        }
+        const gate = (_a = current.design) === null || _a === void 0 ? void 0 : _a.gate;
+        if (!gate) {
+            return refuse('no_open_review', `Run ${runId} is ${current.state}${current.parkReason ? ` (${current.parkReason})` : ''}; no design round is waiting for a decision.`, nextFor(current));
+        }
+        return { run: current, gateId: gate.gateId };
+    };
+    const candidateOf = (current, id) => { var _a, _b, _c, _d; return (_d = (_c = (_b = (_a = current.design) === null || _a === void 0 ? void 0 : _a.rounds) === null || _b === void 0 ? void 0 : _b.find((round) => { var _a; return round.round === ((_a = current.design) === null || _a === void 0 ? void 0 : _a.round); })) === null || _c === void 0 ? void 0 : _c.candidates) === null || _d === void 0 ? void 0 : _d.find((candidate) => candidate.id === id); };
+    return [
+        {
+            name: 'media_create',
+            description: 'Start an image or video build for this app. Pass forkOf to start a new asset from a retained release. Returns the run id; the first round of candidates follows (read it with media_inspect).',
+            inputSchema: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['kind', 'prompt', 'idempotencyKey'],
+                properties: {
+                    kind: { type: 'string', enum: ['image', 'video'] },
+                    prompt: { type: 'string', minLength: 1, maxLength: 4000, description: 'What to make.' },
+                    spec: SPEC,
+                    forkOf: {
+                        type: 'object',
+                        additionalProperties: false,
+                        required: ['assetId', 'releaseId'],
+                        properties: { assetId: { type: 'string' }, releaseId: { type: 'string' } },
+                        description: 'A retained release of this app to start from.',
+                    },
+                    idempotencyKey: KEY,
+                },
+            },
+            async execute(raw) {
+                const input = isRecord(raw) ? raw : {};
+                const prompt = text(input.prompt, 4000);
+                const key = text(input.idempotencyKey, 256);
+                if ((input.kind !== 'image' && input.kind !== 'video') || !prompt || !key) {
+                    return refuse('input_invalid', 'kind (image or video), prompt and idempotencyKey are required.', []);
+                }
+                return submit({
+                    operation: 'create',
+                    prompt,
+                    deliverable: Object.assign(Object.assign({ kind: input.kind }, (isRecord(input.spec) ? { spec: input.spec } : {})), (isRecord(input.forkOf) ? { forkOf: input.forkOf } : {})),
+                    idempotencyKey: key,
+                });
+            },
+        },
+        {
+            name: 'media_edit',
+            description: 'Edit a released image or video. Name the asset and the release you edit (a newer release refuses the edit as base_moved). An image spec may carry region to change only a rectangle; a video spec may carry replaceScenes or captions, and a captions-only edit makes no generation call.',
+            inputSchema: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['kind', 'assetId', 'expectedReleaseId', 'prompt', 'idempotencyKey'],
+                properties: {
+                    kind: { type: 'string', enum: ['image', 'video'] },
+                    assetId: { type: 'string' },
+                    expectedReleaseId: { type: 'string' },
+                    prompt: { type: 'string', minLength: 1, maxLength: 4000, description: 'The change to make.' },
+                    spec: SPEC,
+                    idempotencyKey: KEY,
+                },
+            },
+            async execute(raw) {
+                const input = isRecord(raw) ? raw : {};
+                const prompt = text(input.prompt, 4000);
+                const key = text(input.idempotencyKey, 256);
+                const assetId = text(input.assetId, 128);
+                const expectedReleaseId = text(input.expectedReleaseId, 128);
+                if ((input.kind !== 'image' && input.kind !== 'video') || !prompt || !key || !assetId || !expectedReleaseId) {
+                    return refuse('input_invalid', 'kind, assetId, expectedReleaseId, prompt and idempotencyKey are required.', []);
+                }
+                return submit({
+                    operation: 'edit',
+                    prompt,
+                    deliverable: Object.assign({ kind: input.kind, assetId,
+                        expectedReleaseId }, (isRecord(input.spec) ? { spec: input.spec } : {})),
+                    idempotencyKey: key,
+                });
+            },
+        },
+        {
+            name: 'media_inspect',
+            description: 'Read a media build: its state, the candidates of the round under review (with their scenes), the decision it waits on, and its release once published.',
+            inputSchema: { type: 'object', additionalProperties: false, required: ['runId'], properties: { runId: RUN_ID } },
+            async execute(raw) {
+                var _a, _b, _c, _d, _e;
+                const runId = text(isRecord(raw) ? raw.runId : undefined, 128);
+                if (!runId)
+                    return refuse('input_invalid', 'runId is required.', []);
+                try {
+                    const current = await run(runId);
+                    const round = (_b = (_a = current.design) === null || _a === void 0 ? void 0 : _a.rounds) === null || _b === void 0 ? void 0 : _b.find((entry) => { var _a; return entry.round === ((_a = current.design) === null || _a === void 0 ? void 0 : _a.round); });
+                    const media = current.state === 'promoted' || current.media ? await client.media(appId, runId) : undefined;
+                    return {
+                        ok: true,
+                        data: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ runId, state: current.state }, (current.parkReason ? { parkReason: current.parkReason } : {})), (current.failureReason ? { failureReason: current.failureReason } : {})), (current.failureDetail ? { failureDetail: current.failureDetail } : {})), (round
+                            ? Object.assign({ round: round.round, maxRounds: (_c = current.design) === null || _c === void 0 ? void 0 : _c.maxRounds, candidates: ((_d = round.candidates) !== null && _d !== void 0 ? _d : []).map(candidateView) }, (round.revisionFailed ? { revisionFailed: true } : {})) : {})), (((_e = current.design) === null || _e === void 0 ? void 0 : _e.gate) ? { review: { gateId: current.design.gate.gateId, allowedDecisions: current.design.gate.allowedDecisions } } : {})), (current.state === 'parked' && current.parkReason === 'funding'
+                            ? { waitingFor: 'funding: the payer adds funds and, where top-up is unavailable (topup_unavailable_payer_shard), submits the build again; an agent cannot' }
+                            : {})), (media ? { media: media.media, asset: media.asset } : {})),
+                        next: nextFor(current),
+                    };
+                }
+                catch (error) {
+                    return failure(error);
+                }
+            },
+        },
+        {
+            name: 'media_revise',
+            description: 'Ask for another round of the design under review. Name the candidate to revise; for an image, region limits the change to a rectangle of that candidate (PNG only); for a multi-scene video, sceneIds regenerates only those scenes and keeps every other scene byte for byte.',
+            inputSchema: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['runId', 'feedback', 'idempotencyKey'],
+                properties: {
+                    runId: RUN_ID,
+                    feedback: { type: 'string', minLength: 1, maxLength: 4000, description: 'What to change.' },
+                    candidateId: { type: 'string', description: 'The candidate to revise; without it the whole round is redone from the feedback.' },
+                    sceneIds: { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 6 },
+                    region: REGION,
+                    idempotencyKey: KEY,
+                },
+            },
+            async execute(raw) {
+                var _a, _b;
+                const input = isRecord(raw) ? raw : {};
+                const feedback = text(input.feedback, 4000);
+                const key = text(input.idempotencyKey, 256);
+                if (!feedback || !key)
+                    return refuse('input_invalid', 'runId, feedback and idempotencyKey are required.', []);
+                const review = await openReview(input);
+                if ('ok' in review)
+                    return review;
+                if (!((_b = (_a = review.run.design) === null || _a === void 0 ? void 0 : _a.gate) === null || _b === void 0 ? void 0 : _b.allowedDecisions.includes('request_changes'))) {
+                    return refuse('decision_not_allowed', 'This round takes no revision (it may be the last one): select a candidate instead.', ['media_select']);
+                }
+                const candidate = input.candidateId === undefined ? undefined : candidateOf(review.run, input.candidateId);
+                if (input.candidateId !== undefined && !candidate) {
+                    return refuse('candidate_unknown', `No candidate ${String(input.candidateId)} in the round under review.`, ['media_inspect']);
+                }
+                const sceneIds = Array.isArray(input.sceneIds) ? input.sceneIds.filter((id) => typeof id === 'string') : undefined;
+                if (sceneIds && (!(candidate === null || candidate === void 0 ? void 0 : candidate.scenes) || !sceneIds.every((id) => candidate.scenes.some((scene) => scene.id === id)))) {
+                    return refuse('scenes_unknown', 'sceneIds must name scenes of the multi-scene candidate being revised (candidateId).', ['media_inspect']);
+                }
+                const area = input.region === undefined ? undefined : region(input.region);
+                if (input.region !== undefined
+                    && (!area || (candidate === null || candidate === void 0 ? void 0 : candidate.mimeType) !== 'image/png' || area.x + area.width > candidate.width || area.y + area.height > candidate.height)) {
+                    return refuse('region_invalid', 'region must lie inside the PNG candidate being revised (candidateId).', ['media_inspect']);
+                }
+                try {
+                    const decided = await client.decideGate(appId, review.run.runId, review.gateId, Object.assign(Object.assign(Object.assign(Object.assign({ decision: 'request_changes', feedback: { text: feedback } }, (candidate ? { selectedArtifactId: candidate.id } : {})), (sceneIds ? { sceneIds } : {})), (area ? { region: area } : {})), { idempotencyKey: key }));
+                    return { ok: true, data: { runId: review.run.runId, state: decided.state }, next: ['media_inspect'] };
+                }
+                catch (error) {
+                    return failure(error);
+                }
+            },
+        },
+        {
+            name: 'media_select',
+            description: 'Choose a candidate of the round under review. The chosen candidate is what the build releases, through the app\'s landing policy.',
+            inputSchema: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['runId', 'candidateId', 'idempotencyKey'],
+                properties: { runId: RUN_ID, candidateId: { type: 'string' }, idempotencyKey: KEY },
+            },
+            async execute(raw) {
+                const input = isRecord(raw) ? raw : {};
+                const key = text(input.idempotencyKey, 256);
+                if (!key)
+                    return refuse('input_invalid', 'runId, candidateId and idempotencyKey are required.', []);
+                const review = await openReview(input);
+                if ('ok' in review)
+                    return review;
+                const candidate = candidateOf(review.run, input.candidateId);
+                if (!candidate)
+                    return refuse('candidate_unknown', `No candidate ${String(input.candidateId)} in the round under review.`, ['media_inspect']);
+                try {
+                    const decided = await client.decideGate(appId, review.run.runId, review.gateId, {
+                        decision: 'approve',
+                        selectedArtifactId: candidate.id,
+                        idempotencyKey: key,
+                    });
+                    return { ok: true, data: { runId: review.run.runId, state: decided.state, selectedArtifactId: candidate.id }, next: ['media_propose', 'media_inspect'] };
+                }
+                catch (error) {
+                    return failure(error);
+                }
+            },
+        },
+        {
+            name: 'media_export',
+            description: 'A short-lived signed URL for one verified image or video of a build (a published release, or a candidate the build deposited), with its digest.',
+            inputSchema: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['runId', 'artifactId'],
+                properties: { runId: RUN_ID, artifactId: { type: 'string' } },
+            },
+            async execute(raw) {
+                var _a, _b;
+                const input = isRecord(raw) ? raw : {};
+                const runId = text(input.runId, 128);
+                const artifactId = text(input.artifactId, 64);
+                if (!runId || !artifactId)
+                    return refuse('input_invalid', 'runId and artifactId are required.', []);
+                try {
+                    const view = await client.media(appId, runId);
+                    const artifact = (_b = (_a = view.media) === null || _a === void 0 ? void 0 : _a.artifacts) === null || _b === void 0 ? void 0 : _b.find((entry) => entry.id === artifactId);
+                    if (!artifact) {
+                        return refuse('artifact_unavailable', `Run ${runId} has no verified artifact ${artifactId} yet; a candidate under review is exported from its round's url (media_inspect).`, ['media_inspect']);
+                    }
+                    const signed = await client.mediaDownloadUrl(appId, runId, artifactId);
+                    return {
+                        ok: true,
+                        data: { runId, artifactId, url: signed.url, expiresAtMs: signed.expiresAtMs, sha256: artifact.sha256, mimeType: artifact.mimeType, bytes: artifact.bytes },
+                        next: ['media_inspect'],
+                    };
+                }
+                catch (error) {
+                    return failure(error);
+                }
+            },
+        },
+        {
+            name: 'media_propose',
+            description: 'Put a build\'s chosen candidate forward for publication and report where it stands. Publishing is decided by the app\'s landing policy (the owner approves the release, or the policy lands it); this tool never approves it.',
+            inputSchema: { type: 'object', additionalProperties: false, required: ['runId'], properties: { runId: RUN_ID } },
+            async execute(raw) {
+                var _a;
+                const runId = text(isRecord(raw) ? raw.runId : undefined, 128);
+                if (!runId)
+                    return refuse('input_invalid', 'runId is required.', []);
+                try {
+                    const current = await run(runId);
+                    if (current.state === 'promoted') {
+                        const view = await client.media(appId, runId);
+                        return { ok: true, data: { runId, state: 'published', release: view.asset.currentRelease }, next: nextFor(current) };
+                    }
+                    if (current.state === 'parked' && current.parkReason === 'gate') {
+                        const gate = current.gates.find((entry) => !entry.decided);
+                        return { ok: true, data: Object.assign(Object.assign({ runId, state: 'awaiting_publication' }, (gate ? { gateId: gate.gateId } : {})), { decidedBy: 'the app owner, under the landing policy' }), next: ['media_inspect'] };
+                    }
+                    if ((_a = current.design) === null || _a === void 0 ? void 0 : _a.gate) {
+                        return refuse('not_selected', 'Choose a candidate first (media_select); only a chosen candidate can be published.', ['media_select', 'media_revise']);
+                    }
+                    return refuse('not_proposable', `Run ${runId} is ${current.state}${current.parkReason ? ` (${current.parkReason})` : ''}; it has no candidate waiting for publication.`, nextFor(current));
+                }
+                catch (error) {
+                    return failure(error);
+                }
+            },
+        },
+    ];
+}
+
 /**
  * Registered first-party product surfaces only, with
  * one exact Drafted exception for delegated review/decision routes. Other
@@ -9678,6 +9913,9 @@ const builds = {
     uploadInput,
     list: list$1,
     watch,
+    media,
+    mediaDownloadUrl,
+    rollbackMedia,
 };
 
 async function create(options = {}) {
@@ -10482,5 +10720,312 @@ function defaultInjectedEvmProvider() {
     return null;
 }
 
-export { onrampStatus as $, getAuthProvider as A, signInAnonymously as B, loginWithPrivy as C, loginWithWallet as D, ensureWalletLoginReady as E, ensureSharedWalletLoginReady as F, preloadWalletLogin as G, loginWithRedirect as H, completeLoginFromRedirect as I, loginWithPopup as J, completeLoginInPopup as K, openBoundedWidget as L, ensureSignedIn as M, useAuth as N, useQuery as O, useBuildRun as P, apps as Q, signSolanaMessageViaTurnkey as R, getOrCreateTurnkeyWallet as S, openTurnkeyKeyExport as T, getTurnkeyWalletSessionState as U, getTurnkeyWalletRecoveryUrl as V, WalletConfigError as W, startTurnkeyEmailLogin as X, getIdToken as Y, onramp as Z, onrampQuote as _, signMessageWithTurnkey as a, setPlatform as a0, OffchainAuthProvider as a1, PrivyExpoProvider as a2, requestEip6963Providers as a3, builds as a4, BuildsApiError as a5, NON_TERMINAL_STATES as a6, TERMINAL_STATES as a7, RUN_STATES as a8, PARK_REASONS as a9, FAILURE_REASONS as aa, BUILD_REVIEW_CAPABILITY_SCHEMA as ab, BUILD_REVIEW_CAPABILITY_REFRESH_SCHEMA as ac, BUILD_DELEGATED_REVIEW_CAPABILITY_SCHEMA as ad, signTransactionWithTurnkey as b, signTransactionV1WithTurnkey as c, signAndSubmitTransactionWithTurnkey as d, bs58 as e, defaultInjectedProvider as f, getPlatform as g, hasTurnkeyWallet as h, firstStandardWalletProvider as i, setAuthLoading as j, bufferExports as k, setStoredAuthMethod as l, confirmAndCheckTransaction as m, normalizeSolanaRpcUrl as n, defaultInjectedEvmProvider as o, init as p, getCurrentUser as q, resolveSolanaRpcUrl as r, setCurrentUser as s, transactionHasSignature as t, onAuthStateChanged as u, onAuthLoadingChanged as v, getAuthLoading as w, waitForAuthReady as x, login as y, logout as z };
-//# sourceMappingURL=index-DmAXYXDi.mjs.map
+/** Admission comes from an app-authenticated function invoking the Cloudflare
+ * broadcast connector. No application membership is managed by this helper. */
+async function connectBroadcast(ticket, options) {
+    var _a, _b, _c, _d;
+    const url = new URL(ticket.url);
+    if (url.username || url.password || url.search || url.hash || (url.protocol !== "https:" && !(url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))))
+        throw new Error("Invalid broadcast URL");
+    if (!/^[a-f0-9]{64}$/.test(ticket.token) || ticket.transport !== "webrtc-broadcast" || !Number.isFinite(ticket.expiresAt) || ticket.expiresAt <= Date.now()
+        || !Number.isInteger(ticket.maxSeconds) || ticket.maxSeconds < 15 || ticket.maxSeconds > 300
+        || !["publisher", "listener"].includes(ticket.role) || ((_a = options.signal) === null || _a === void 0 ? void 0 : _a.aborted))
+        throw new Error("Invalid or expired broadcast ticket");
+    const publisher = ticket.role === "publisher";
+    const tracks = publisher ? [(_b = options.microphone) === null || _b === void 0 ? void 0 : _b.getAudioTracks()[0], (_c = options.assistant) === null || _c === void 0 ? void 0 : _c.getAudioTracks()[0]] : [];
+    if (publisher && tracks.some(track => !track || track.readyState !== "live"))
+        throw new Error("Microphone and assistant audio tracks are required");
+    if (!publisher && !options.audio)
+        throw new Error("Two playback elements are required");
+    const peer = new RTCPeerConnection({ iceServers: [{ urls: "stun:stun.cloudflare.com:3478" }] });
+    let stopped = false, stopPromise;
+    let resolveClosed;
+    const closed = new Promise(resolve => { resolveClosed = resolve; });
+    let disconnectTimer;
+    const request = async (method, body) => {
+        const response = await fetch(ticket.url, Object.assign(Object.assign({ method, headers: { Authorization: `Bearer ${ticket.token}`, "Content-Type": "application/json" } }, (body === undefined ? {} : { body: JSON.stringify(body) })), { signal: AbortSignal.timeout(15000), redirect: "error", cache: "no-store" }));
+        if (!response.ok)
+            throw new Error(`Broadcast request failed (${response.status})`);
+        return response.json();
+    };
+    const connection = {
+        closed,
+        status: () => request("GET"),
+        close() {
+            var _a, _b;
+            if (stopPromise)
+                return stopPromise;
+            stopped = true;
+            clearTimeout(deadline);
+            clearTimeout(disconnectTimer);
+            peer.close();
+            (_a = options.signal) === null || _a === void 0 ? void 0 : _a.removeEventListener("abort", abort);
+            tracks.forEach(t => t === null || t === void 0 ? void 0 : t.removeEventListener("ended", abort));
+            (_b = options.audio) === null || _b === void 0 ? void 0 : _b.forEach(audio => { audio.pause(); audio.srcObject = null; });
+            resolveClosed();
+            // These tracks also belong to the primary voice connection. Closing the
+            // broadcast must not stop the microphone or assistant's direct playback.
+            stopPromise = (async () => {
+                for (let attempt = 0; attempt < 3; attempt++) {
+                    try {
+                        await request("DELETE");
+                        return;
+                    }
+                    catch (error) {
+                        if (attempt === 2)
+                            throw error;
+                        await new Promise(resolve => setTimeout(resolve, 250 * (attempt + 1)));
+                    }
+                }
+            })();
+            return stopPromise;
+        },
+    };
+    const abort = () => { void connection.close().catch(() => { }); };
+    const deadline = setTimeout(abort, ticket.maxSeconds * 1000);
+    (_d = options.signal) === null || _d === void 0 ? void 0 : _d.addEventListener("abort", abort, { once: true });
+    tracks.forEach(track => track === null || track === void 0 ? void 0 : track.addEventListener("ended", abort, { once: true }));
+    let audioMids = [];
+    peer.addEventListener("track", event => {
+        var _a;
+        const audio = (_a = options.audio) === null || _a === void 0 ? void 0 : _a[audioMids.indexOf(event.transceiver.mid || "")];
+        if (!audio) {
+            abort();
+            return;
+        }
+        audio.srcObject = new MediaStream([event.track]);
+        void audio.play().catch(abort);
+    });
+    peer.addEventListener("connectionstatechange", () => {
+        clearTimeout(disconnectTimer);
+        if (peer.connectionState === "failed")
+            abort();
+        else if (peer.connectionState === "disconnected")
+            disconnectTimer = setTimeout(abort, 5000);
+    });
+    try {
+        let result;
+        if (publisher) {
+            for (const track of tracks)
+                peer.addTransceiver(track, { direction: "sendonly", sendEncodings: [{ maxBitrate: 32000 }] });
+            await peer.setLocalDescription(await peer.createOffer());
+            result = await request("POST", { sdp: peer.localDescription.sdp });
+            if (stopped)
+                throw new Error("Broadcast cancelled");
+            await peer.setRemoteDescription(result.sessionDescription);
+        }
+        else {
+            result = await request("POST", {});
+            if (stopped)
+                throw new Error("Broadcast cancelled");
+            audioMids = ["microphone", "assistant"].map(name => { var _a, _b; return ((_b = (_a = result.tracks) === null || _a === void 0 ? void 0 : _a.find(track => track.trackName === name)) === null || _b === void 0 ? void 0 : _b.mid) || ""; });
+            if (audioMids.some(mid => !mid) || new Set(audioMids).size !== 2)
+                throw new Error("Invalid broadcast audio tracks");
+            await peer.setRemoteDescription(result.sessionDescription);
+            await peer.setLocalDescription(await peer.createAnswer());
+            await request("PUT", { sdp: peer.localDescription.sdp });
+        }
+        await new Promise((resolve, reject) => {
+            var _a;
+            const timer = setTimeout(() => done(new Error("Broadcast connection timed out")), 15000);
+            const check = () => {
+                if (stopped || ["failed", "closed"].includes(peer.connectionState))
+                    done(new Error("Broadcast connection ended"));
+                else if (peer.connectionState === "connected")
+                    done();
+            };
+            const done = (error) => { var _a; clearTimeout(timer); peer.removeEventListener("connectionstatechange", check); (_a = options.signal) === null || _a === void 0 ? void 0 : _a.removeEventListener("abort", check); error ? reject(error) : resolve(); };
+            peer.addEventListener("connectionstatechange", check);
+            (_a = options.signal) === null || _a === void 0 ? void 0 : _a.addEventListener("abort", check, { once: true });
+            check();
+        });
+        if (stopped)
+            throw new Error("Broadcast cancelled");
+        return connection;
+    }
+    catch (error) {
+        await connection.close().catch(() => { });
+        throw error;
+    }
+}
+
+/** Attach browser media directly to the connector's provider. Bounded observes
+ * usage independently; data-channel messages never count as billing receipts. */
+async function connectServiceSession(ticket, options) {
+    var _a, _b, _c;
+    const url = new URL(ticket.url);
+    if (url.username || url.password || url.search || url.hash || (url.protocol !== "https:" && !(url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))))
+        throw new Error("Invalid service session URL");
+    if (!/^[a-f0-9]{64}$/.test(ticket.token) || ticket.transport !== "webrtc-session" || !Number.isFinite(ticket.expiresAt) || ticket.expiresAt <= Date.now())
+        throw new Error("Invalid or expired service session ticket");
+    if ((_a = options.signal) === null || _a === void 0 ? void 0 : _a.aborted)
+        throw new Error("Service session aborted");
+    const peer = new RTCPeerConnection();
+    const audioStream = new MediaStream();
+    const channel = peer.createDataChannel("oai-events");
+    let ready = false, finished = false, closing = false;
+    let resolveClosed, rejectClosed;
+    let resolveReady, rejectReady;
+    let pollTimer;
+    const closed = new Promise((resolve, reject) => { resolveClosed = resolve; rejectClosed = reject; });
+    void closed.catch(() => { });
+    const connected = new Promise((resolve, reject) => { resolveReady = resolve; rejectReady = reject; });
+    void connected.catch(() => { });
+    const request = async (method, body) => {
+        const response = await fetch(ticket.url, Object.assign(Object.assign({ method, headers: Object.assign({ Authorization: `Bearer ${ticket.token}` }, (body === undefined ? {} : { "Content-Type": "application/json" })) }, (body === undefined ? {} : { body: JSON.stringify(body) })), { signal: AbortSignal.timeout(15000), cache: "no-store", redirect: "error" }));
+        if (!response.ok)
+            throw new Error(`Service session request failed (${response.status})`);
+        return response.json();
+    };
+    const cleanup = () => {
+        var _a;
+        clearTimeout(startTimer);
+        clearTimeout(pollTimer);
+        (_a = options.signal) === null || _a === void 0 ? void 0 : _a.removeEventListener("abort", abort);
+        options.stream.getTracks().forEach(track => track.stop());
+        options.audio.pause();
+        options.audio.srcObject = null;
+        channel.close();
+        peer.close();
+    };
+    const fail = (error) => {
+        if (finished)
+            return;
+        finished = true;
+        rejectReady(error);
+        rejectClosed(error);
+        cleanup();
+    };
+    const poll = async (until) => {
+        if (finished)
+            return;
+        try {
+            const state = await request("GET");
+            if (state.state === "closed" && state.finalUsage === true && Number.isFinite(state.seconds) && state.seconds >= 0 && Number.isSafeInteger(state.chargedMicroUsd) && state.chargedMicroUsd >= 0) {
+                finished = true;
+                resolveClosed({ seconds: state.seconds, chargedMicroUsd: state.chargedMicroUsd, finalUsage: true });
+                if (!ready)
+                    rejectReady(new Error("Service session ended before startup"));
+                cleanup();
+                return;
+            }
+            if (["waiting", "creating", "active"].includes(state.state))
+                await request("DELETE");
+            if (state.state === "attention") {
+                fail(new Error("Service session requires reconciliation"));
+                return;
+            }
+        }
+        catch ( /* bounded retries; never invent a receipt after a network failure */_a) { /* bounded retries; never invent a receipt after a network failure */ }
+        if (Date.now() >= until) {
+            fail(new Error("Service session finalization unconfirmed; check session status"));
+            return;
+        }
+        pollTimer = setTimeout(() => { void poll(until); }, 500);
+    };
+    const session = {
+        audioStream,
+        closed,
+        send(event) {
+            if (!ready || closing || finished || channel.readyState !== "open")
+                throw new Error("Service session is not accepting messages");
+            const json = JSON.stringify(event);
+            if (new TextEncoder().encode(json).byteLength > 65536 || channel.bufferedAmount > 256000)
+                throw new Error("Service session backpressure limit");
+            channel.send(json);
+        },
+        close() {
+            if (!closing && !finished) {
+                closing = true;
+                options.stream.getTracks().forEach(track => track.stop());
+                options.audio.pause();
+                options.audio.srcObject = null;
+                // Keep WebRTC alive while the server collects final usage. HTTP close
+                // also works when the provider data channel is already gone.
+                void request("DELETE").catch(() => { }).then(() => poll(Date.now() + 45000));
+            }
+            return closed;
+        },
+    };
+    const abort = () => { void session.close(); };
+    const startTimer = setTimeout(() => { void request("DELETE").catch(() => { }); fail(new Error("Service session startup timed out")); }, 30000);
+    (_b = options.signal) === null || _b === void 0 ? void 0 : _b.addEventListener("abort", abort, { once: true });
+    peer.addEventListener("track", ({ track }) => { if (closing || finished)
+        return; audioStream.addTrack(track); options.audio.srcObject = audioStream; void options.audio.play().catch(() => { void session.close(); fail(new Error("Audio playback was blocked")); }); });
+    channel.addEventListener("message", ({ data }) => {
+        var _a;
+        if (finished || closing)
+            return;
+        let event;
+        try {
+            event = JSON.parse(String(data));
+        }
+        catch (_b) {
+            return;
+        }
+        if ((event === null || event === void 0 ? void 0 : event.type) === "session.started" && !ready) {
+            ready = true;
+            clearTimeout(startTimer);
+            resolveReady();
+        }
+        if ((event === null || event === void 0 ? void 0 : event.type) === "session.closed")
+            void session.close();
+        try {
+            (_a = options.onEvent) === null || _a === void 0 ? void 0 : _a.call(options, event);
+        }
+        catch ( /* UI callback failure cannot own cleanup */_c) { /* UI callback failure cannot own cleanup */ }
+    });
+    peer.addEventListener("connectionstatechange", () => { if (["failed", "closed"].includes(peer.connectionState) && !finished)
+        void session.close(); });
+    channel.addEventListener("close", () => { if (!finished)
+        void session.close(); });
+    try {
+        for (const track of options.stream.getAudioTracks())
+            peer.addTrack(track, options.stream);
+        if (!options.stream.getAudioTracks().length)
+            throw new Error("An audio track is required");
+        await peer.setLocalDescription(await peer.createOffer());
+        if (peer.iceGatheringState !== "complete")
+            await new Promise((resolve, reject) => {
+                var _a;
+                const timer = setTimeout(() => done(new Error("Service session ICE gathering timed out")), 10000);
+                const done = (error) => {
+                    var _a;
+                    clearTimeout(timer);
+                    peer.removeEventListener("icegatheringstatechange", check);
+                    peer.removeEventListener("connectionstatechange", check);
+                    (_a = options.signal) === null || _a === void 0 ? void 0 : _a.removeEventListener("abort", check);
+                    error ? reject(error) : resolve();
+                };
+                const check = () => {
+                    var _a;
+                    if (closing || finished || ((_a = options.signal) === null || _a === void 0 ? void 0 : _a.aborted) || peer.connectionState === "closed")
+                        done(new Error("Service session aborted during ICE gathering"));
+                    else if (peer.iceGatheringState === "complete")
+                        done();
+                };
+                peer.addEventListener("icegatheringstatechange", check);
+                peer.addEventListener("connectionstatechange", check);
+                (_a = options.signal) === null || _a === void 0 ? void 0 : _a.addEventListener("abort", check, { once: true });
+                check();
+            });
+        if (closing || finished)
+            throw new Error("Service session aborted before admission");
+        if (!((_c = peer.localDescription) === null || _c === void 0 ? void 0 : _c.sdp.includes("\r\na=candidate:")))
+            throw new Error("Service session has no usable ICE candidates");
+        const answer = await request("POST", { sdp: peer.localDescription.sdp });
+        if (closing || finished)
+            throw new Error("Service session aborted during admission");
+        await peer.setRemoteDescription({ type: "answer", sdp: answer.sdp });
+        await connected;
+        return session;
+    }
+    catch (error) {
+        void request("DELETE").catch(() => { });
+        fail(error instanceof Error ? error : new Error("Service session startup failed"));
+        throw error;
+    }
+}
+
+export { onrampStatus as $, getAuthProvider as A, signInAnonymously as B, loginWithPrivy as C, loginWithWallet as D, ensureWalletLoginReady as E, ensureSharedWalletLoginReady as F, preloadWalletLogin as G, loginWithRedirect as H, completeLoginFromRedirect as I, loginWithPopup as J, completeLoginInPopup as K, openBoundedWidget as L, ensureSignedIn as M, useAuth as N, useQuery as O, useBuildRun as P, apps as Q, signSolanaMessageViaTurnkey as R, getOrCreateTurnkeyWallet as S, openTurnkeyKeyExport as T, getTurnkeyWalletSessionState as U, getTurnkeyWalletRecoveryUrl as V, WalletConfigError as W, startTurnkeyEmailLogin as X, getIdToken as Y, onramp as Z, onrampQuote as _, signMessageWithTurnkey as a, setPlatform as a0, OffchainAuthProvider as a1, PrivyExpoProvider as a2, requestEip6963Providers as a3, connectBroadcast as a4, connectServiceSession as a5, builds as a6, BuildsApiError as a7, mediaAgentTools as a8, NON_TERMINAL_STATES as a9, TERMINAL_STATES as aa, RUN_STATES as ab, PARK_REASONS as ac, FAILURE_REASONS as ad, BUILD_REVIEW_CAPABILITY_SCHEMA as ae, BUILD_REVIEW_CAPABILITY_REFRESH_SCHEMA as af, BUILD_DELEGATED_REVIEW_CAPABILITY_SCHEMA as ag, signTransactionWithTurnkey as b, signTransactionV1WithTurnkey as c, signAndSubmitTransactionWithTurnkey as d, bs58 as e, defaultInjectedProvider as f, getPlatform as g, hasTurnkeyWallet as h, firstStandardWalletProvider as i, setAuthLoading as j, bufferExports as k, setStoredAuthMethod as l, confirmAndCheckTransaction as m, normalizeSolanaRpcUrl as n, defaultInjectedEvmProvider as o, init as p, getCurrentUser as q, resolveSolanaRpcUrl as r, setCurrentUser as s, transactionHasSignature as t, onAuthStateChanged as u, onAuthLoadingChanged as v, getAuthLoading as w, waitForAuthReady as x, login as y, logout as z };
+//# sourceMappingURL=index-CaZx7sd8.mjs.map