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

package/dist/{index.native-CllNqdoy.js → index.native-PGrxu7RO.js}

@@ -6065,7 +6065,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-Cpj8hIFu.js'); })).EmailAuthProvider();
+            currentAuthProvider = new (await Promise.resolve().then(function () { return require('./email-auth-provider-DCZ93FYg.js'); })).EmailAuthProvider();
             break;
         case "phantom": {
             // First-class Solana WALLET LOGIN (the poof/TaroBase-style "connect
@@ -6107,7 +6107,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-Bi_mB_q3.js'); });
+            const { InjectedWalletProvider } = await Promise.resolve().then(function () { return require('./injected-wallet-provider-29eTkM-A.js'); });
             currentAuthProvider = new InjectedWalletProvider(resolveInjectedWalletConfig(config), rpcUrl, configuredNetwork);
             break;
         }
@@ -6120,7 +6120,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-BXM8TfS3.js'); });
+            const { InjectedEvmWalletProvider } = await Promise.resolve().then(function () { return require('./injected-evm-wallet-provider-BNu6Z-iN.js'); });
             currentAuthProvider = new InjectedEvmWalletProvider(evmWalletConfig);
             break;
         }
@@ -6145,7 +6145,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-0PjGFGDm.js'); })).GuestAuthProvider();
+            currentAuthProvider = new (await Promise.resolve().then(function () { return require('./guest-auth-provider--Sqlucfr.js'); })).GuestAuthProvider();
             break;
     }
     if (!currentAuthProvider) {
@@ -6207,7 +6207,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-0PjGFGDm.js'); })).GuestAuthProvider();
+    const provider = new (await Promise.resolve().then(function () { return require('./guest-auth-provider--Sqlucfr.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
@@ -6378,7 +6378,7 @@ function ensureSharedWalletLoginReady() {
     if (!sharedWalletReady) {
         sharedWalletReady = (async () => {
             await core.getConfig();
-            await Promise.resolve().then(function () { return require('./injected-wallet-provider-Bi_mB_q3.js'); });
+            await Promise.resolve().then(function () { return require('./injected-wallet-provider-29eTkM-A.js'); });
         })().catch((error) => {
             sharedWalletReady = null;
             throw error;
@@ -7311,9 +7311,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}`);
@@ -7345,13 +7362,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',
@@ -7609,6 +7628,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
@@ -7626,6 +7984,9 @@ const builds = {
     uploadInput,
     list: list$1,
     watch,
+    media,
+    mediaDownloadUrl,
+    rollbackMedia,
 };
 
 async function create(options = {}) {
@@ -8377,6 +8738,7 @@ exports.loginWithPopup = loginWithPopup;
 exports.loginWithPrivy = loginWithPrivy;
 exports.loginWithRedirect = loginWithRedirect;
 exports.logout = logout;
+exports.mediaAgentTools = mediaAgentTools;
 exports.normalizeSolanaRpcUrl = normalizeSolanaRpcUrl;
 exports.onAuthLoadingChanged = onAuthLoadingChanged;
 exports.onAuthStateChanged = onAuthStateChanged;
@@ -8400,4 +8762,4 @@ exports.useAuth = useAuth;
 exports.useBuildRun = useBuildRun;
 exports.useQuery = useQuery;
 exports.waitForAuthReady = waitForAuthReady;
-//# sourceMappingURL=index.native-CllNqdoy.js.map
+//# sourceMappingURL=index.native-PGrxu7RO.js.map