@bounded-sh/client 0.0.100-performance.0 → 0.0.100

package/dist/{index-DUVRmF9-.js → index-Pyb2SLgv.js}

@@ -56,13 +56,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 }; }
@@ -4543,11 +4536,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
@@ -5906,14 +5894,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.
@@ -6342,7 +6329,7 @@ async function getAuthProvider(config) {
             // manager as legacy email sessions. Human login should be started
             // with loginWithRedirect(); this provider is kept as the restore and
             // logout surface for those sessions.
-            currentAuthProvider = new (await Promise.resolve().then(function () { return require('./email-auth-provider-C6SFJd9L.js'); })).EmailAuthProvider();
+            currentAuthProvider = new (await Promise.resolve().then(function () { return require('./email-auth-provider-Cr3I4Po5.js'); })).EmailAuthProvider();
             break;
         case "phantom": {
             // First-class Solana WALLET LOGIN (the poof/TaroBase-style "connect
@@ -6384,7 +6371,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 Promise.resolve().then(function () { return require('./injected-wallet-provider-B3LLEpfp.js'); });
+            const { InjectedWalletProvider } = await Promise.resolve().then(function () { return require('./injected-wallet-provider-Cv9RELO6.js'); });
             currentAuthProvider = new InjectedWalletProvider(resolveInjectedWalletConfig(config), rpcUrl, configuredNetwork);
             break;
         }
@@ -6397,7 +6384,7 @@ async function getAuthProvider(config) {
             // Selecting authMethod:'evm-wallet' IS the opt-in — pass evmWalletConfig
             // to point at a specific wallet or set chainId/domain.
             const evmWalletConfig = ((_a = config.evmWalletConfig) !== null && _a !== void 0 ? _a : {});
-            const { InjectedEvmWalletProvider } = await Promise.resolve().then(function () { return require('./injected-evm-wallet-provider-Dq3FDV1M.js'); });
+            const { InjectedEvmWalletProvider } = await Promise.resolve().then(function () { return require('./injected-evm-wallet-provider-U0XJu5HM.js'); });
             currentAuthProvider = new InjectedEvmWalletProvider(evmWalletConfig);
             break;
         }
@@ -6422,7 +6409,7 @@ async function getAuthProvider(config) {
             break;
         case "guest":
             // Anonymous auth: a device-local ed25519 keypair signs the challenge.
-            currentAuthProvider = new (await Promise.resolve().then(function () { return require('./guest-auth-provider-pC-AheTZ.js'); })).GuestAuthProvider();
+            currentAuthProvider = new (await Promise.resolve().then(function () { return require('./guest-auth-provider-CPj-w7_R.js'); })).GuestAuthProvider();
             break;
     }
     if (!currentAuthProvider) {
@@ -6484,7 +6471,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 Promise.resolve().then(function () { return require('./guest-auth-provider-pC-AheTZ.js'); })).GuestAuthProvider();
+    const provider = new (await Promise.resolve().then(function () { return require('./guest-auth-provider-CPj-w7_R.js'); })).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
@@ -6655,7 +6642,7 @@ function ensureSharedWalletLoginReady() {
     if (!sharedWalletReady) {
         sharedWalletReady = (async () => {
             await core.getConfig();
-            await Promise.resolve().then(function () { return require('./injected-wallet-provider-B3LLEpfp.js'); });
+            await Promise.resolve().then(function () { return require('./injected-wallet-provider-Cv9RELO6.js'); });
         })().catch((error) => {
             sharedWalletReady = null;
             throw error;
@@ -6758,7 +6745,7 @@ async function loginWithWallet(options) {
         await ensureSharedWalletLoginReady();
     else
         await ensureWalletLoginReady();
-    const { InjectedWalletProvider } = await Promise.resolve().then(function () { return require('./injected-wallet-provider-B3LLEpfp.js'); });
+    const { InjectedWalletProvider } = await Promise.resolve().then(function () { return require('./injected-wallet-provider-Cv9RELO6.js'); });
     // 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.
@@ -7764,12 +7751,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);
         },
     };
 }
@@ -7874,104 +7863,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 = core.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 || core.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) || core.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 || core.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
@@ -8511,24 +8402,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))
@@ -9384,9 +9261,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}`);
@@ -9418,13 +9312,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',
@@ -9682,6 +9578,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
@@ -9699,6 +9934,9 @@ const builds = {
     uploadInput,
     list: list$1,
     watch,
+    media,
+    mediaDownloadUrl,
+    rollbackMedia,
 };
 
 async function create(options = {}) {
@@ -10503,6 +10741,313 @@ function defaultInjectedEvmProvider() {
     return null;
 }
 
+/** 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;
+    }
+}
+
 exports.BUILD_DELEGATED_REVIEW_CAPABILITY_SCHEMA = BUILD_DELEGATED_REVIEW_CAPABILITY_SCHEMA;
 exports.BUILD_REVIEW_CAPABILITY_REFRESH_SCHEMA = BUILD_REVIEW_CAPABILITY_REFRESH_SCHEMA;
 exports.BUILD_REVIEW_CAPABILITY_SCHEMA = BUILD_REVIEW_CAPABILITY_SCHEMA;
@@ -10522,6 +11067,8 @@ exports.builds = builds;
 exports.completeLoginFromRedirect = completeLoginFromRedirect;
 exports.completeLoginInPopup = completeLoginInPopup;
 exports.confirmAndCheckTransaction = confirmAndCheckTransaction;
+exports.connectBroadcast = connectBroadcast;
+exports.connectServiceSession = connectServiceSession;
 exports.defaultInjectedEvmProvider = defaultInjectedEvmProvider;
 exports.defaultInjectedProvider = defaultInjectedProvider;
 exports.ensureSharedWalletLoginReady = ensureSharedWalletLoginReady;
@@ -10544,6 +11091,7 @@ exports.loginWithPrivy = loginWithPrivy;
 exports.loginWithRedirect = loginWithRedirect;
 exports.loginWithWallet = loginWithWallet;
 exports.logout = logout;
+exports.mediaAgentTools = mediaAgentTools;
 exports.normalizeSolanaRpcUrl = normalizeSolanaRpcUrl;
 exports.onAuthLoadingChanged = onAuthLoadingChanged;
 exports.onAuthStateChanged = onAuthStateChanged;
@@ -10571,4 +11119,4 @@ exports.useAuth = useAuth;
 exports.useBuildRun = useBuildRun;
 exports.useQuery = useQuery;
 exports.waitForAuthReady = waitForAuthReady;
-//# sourceMappingURL=index-DUVRmF9-.js.map
+//# sourceMappingURL=index-Pyb2SLgv.js.map