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

package/README.md

@@ -183,6 +183,89 @@ const watcher = builds.watch(app.appId, submitted.runId, ({ run, events }) => {
 // watcher.stop();
 ```
 
+#### Media builds
+
+An image or video is a build too: pass a `deliverable`. Each design round serves
+candidates; a decision names the one it approves or revises. Publication lands a
+release on the app's media asset through the same landing policy as an app change,
+and a release can be edited, forked or rolled back.
+
+```typescript
+const image = await builds.submit(appId, {
+  operation: 'create',
+  prompt: 'A launch poster for a late-night jazz club',
+  deliverable: { kind: 'image', spec: { size: '1024x1536', candidates: 2 } },
+  idempotencyKey,
+});
+
+// While a round is under review (run.design.gate):
+await builds.decideGate(appId, image.runId, gateId, {
+  decision: 'request_changes',
+  feedback: { text: 'Add a full moon above the club' },
+  selectedArtifactId: 'c1',
+  region: { x: 200, y: 100, width: 600, height: 300 }, // only this rectangle changes
+  idempotencyKey: 'moon',
+});
+await builds.decideGate(appId, image.runId, gateId, { decision: 'approve', selectedArtifactId: 'c1', idempotencyKey: 'pick' });
+
+// After publication: the verified release, a signed download, an edit of that exact release.
+const { asset } = await builds.media(appId, image.runId);
+const { url } = await builds.mediaDownloadUrl(appId, image.runId, 'c1');
+await builds.submit(appId, {
+  operation: 'edit',
+  prompt: 'Make the lettering gold',
+  deliverable: { kind: 'image', assetId: asset.assetId, expectedReleaseId: asset.currentRelease!.releaseId },
+  idempotencyKey: 'gold',
+});
+```
+
+An application build can use released images of its app, pinned by digest:
+`mediaSlots` places each image byte for byte at `/media/<slot>.<ext>` in the app,
+so a later edit of the image never changes the app until an app edit pins the new
+release.
+
+```typescript
+await builds.submit(appId, {
+  operation: 'edit',
+  prompt: 'Use the launch poster as the hero image',
+  mediaSlots: [{ slot: 'hero-image', assetId: asset.assetId }],
+  idempotencyKey: 'hero',
+});
+```
+
+A multi-scene video names its scenes and captions; a `request_changes` with
+`sceneIds` regenerates only those scenes, an edit with `replaceScenes` replaces
+one scene and keeps every other clip byte for byte, and a captions-only edit
+makes no generation call.
+
+Every release stays retained, with its alternatives and scene clips, for edits,
+forks and rollback. A build that ends without a release is collected a week
+after it ends, and an app that retains 20 GiB of media builds is refused new
+ones with `media_storage_quota`.
+
+#### Agent tools for media builds
+
+`mediaAgentTools(appId)` returns the builds client as tool declarations for an
+agent: `media_create`, `media_edit`, `media_inspect`, `media_revise`,
+`media_select`, `media_export` and `media_propose`. Each has a name, a
+description and a JSON Schema `inputSchema` to offer a model, and an `execute`
+that returns `{ ok, data, next }` or `{ ok: false, code, message, retryable, next }`,
+where `next` names the operations that make sense from the run's state and `code`
+is Build's own reason when the API relays one (`base_moved`, `candidate_unknown`). A request
+the run cannot take (no open review, an unknown candidate, a region outside a PNG
+candidate) is refused with its reason before any call is made. No tool publishes:
+`media_propose` reports whether the chosen candidate awaits the owner's landing
+decision or is already released.
+
+```typescript
+import { mediaAgentTools } from '@bounded-sh/client';
+
+const tools = mediaAgentTools(appId);
+const declarations = tools.map(({ name, description, inputSchema }) => ({ name, description, input_schema: inputSchema }));
+// When the model calls a tool:
+const result = await tools.find((tool) => tool.name === call.name)!.execute(call.input);
+```
+
 ## Usage
 
 ### Get Current User

package/dist/auth/turnkey-auth.d.ts

@@ -2,7 +2,10 @@ import type { User } from '@bounded-sh/core';
 export interface TurnkeyEmailLoginHandle {
     /** The email the code was sent to (echo, for the widget's "code sent to ..." line). */
     email: string;
-    /** Scoped frames remain mounted for later signing. */
+    /**
+     * App-scoped wallets: the signer document the signing bridge mounts AFTER login. The login
+     * code itself is never typed there (BSA-2026-004); `run()` always drives the Bounded OTP frame.
+     */
     frameUrl?: string;
     signerOrigin?: string;
     /**

package/dist/builds/client.d.ts

@@ -1,4 +1,4 @@
-import type { BuildCancelResponse, BuildDelegatedReviewCapabilityResponse, BuildEventsResponse, BuildGateDecisionResponse, BuildGetResponse, BuildListResponse, BuildReviewAudience, BuildReviewCapabilityRefreshResponse, BuildsApiErrorDetails, BuildSubmitResponse, BuildTopupResponse } from './types';
+import type { BuildCancelResponse, BuildDelegatedReviewCapabilityResponse, BuildDesignFeedback, BuildEventsResponse, BuildGateDecisionResponse, BuildGetResponse, BuildImageDeliverable, BuildVideoDeliverable, BuildListResponse, BuildMediaDownloadUrlResponse, BuildMediaResponse, BuildMediaRollbackResponse, BuildReviewAudience, BuildReviewCapabilityRefreshResponse, BuildsApiErrorDetails, BuildSubmitResponse, BuildTopupResponse } from './types';
 type BuildIdempotencyOptions = {
     /** Caller-minted wire key (1-256 characters), passed through unchanged. */
     idempotencyKey: string;
@@ -41,6 +41,18 @@ export type BuildSubmitOptions = {
         diff: string;
         proposalId: string;
     };
+    /** Deliver an image instead of an application: generated, reviewed in design rounds, and released as an asset. */
+    deliverable?: BuildImageDeliverable | BuildVideoDeliverable;
+    /**
+     * An application build's pinned media: released images of this app written byte for byte to `media/<slot>.<ext>`
+     * (served at `/media/<slot>.<ext>`). `releaseId` pins a retained release; without it the asset's current release is
+     * pinned when the build is admitted, so a later edit of the image never changes this app.
+     */
+    mediaSlots?: Array<{
+        slot: string;
+        assetId: string;
+        releaseId?: string;
+    }>;
 } & BuildIdempotencyOptions;
 export interface BuildInputArtifact {
     artifactId: string;
@@ -62,8 +74,23 @@ export declare function uploadInput(appId: string, options: {
  * replace a caller-minted `idempotencyKey` and survives refresh replays.
  */
 export type BuildGateDecisionOptions = {
-    decision: 'approve' | 'reject';
+    /** `request_changes` answers a design review only, and needs a note or feedback that asks for a change. */
+    decision: 'approve' | 'reject' | 'request_changes';
     note?: string;
+    /** Structured answer to a design review, sent beside `note`. */
+    feedback?: BuildDesignFeedback;
+    /** An image build's chosen candidate (`c1`...): the one approved, or the one a `request_changes` revises. */
+    selectedArtifactId?: string;
+    /** A multi-scene video's `request_changes`: the scenes of that candidate to regenerate; every other scene is kept. */
+    sceneIds?: string[];
+    /** An image's `request_changes`: the rectangle of that PNG candidate to change, in whole pixels; every pixel outside it
+     *  is kept exactly. */
+    region?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
 } & BuildIdempotencyOptions;
 /**
  * Exact owner-rendered approval review capability plus one durable
@@ -104,11 +131,16 @@ export declare class BuildsApiError<TDetails = BuildsApiErrorDetails> extends Er
     readonly status: number;
     /**
      * Developer-api error details, preserved verbatim. For
-     * `project_limit_exceeded`, `usage`, `limit`, and `dimension` are all present
-     * (the exact shape is exported as `ProjectLimitExceededDetails`).
+     * `project_daily_limit_exceeded`, `usage`, `limit`, `dimension`, `windowMs`,
+     * and `resetsAtMs` are all present (the exact shape is exported as
+     * `ProjectDailyLimitExceededDetails`).
      */
     readonly details?: TDetails;
-    /** Parsed Retry-After delay, when a 429 response supplied one. */
+    /**
+     * Parsed Retry-After delay, when a 429 response supplied one. A
+     * `project_daily_limit_exceeded` refusal carries it whenever `resetsAtMs` is
+     * not null.
+     */
     readonly retryAfterMs?: number;
     constructor(init: BuildsApiErrorInit<TDetails>);
 }
@@ -126,6 +158,19 @@ export declare function refreshReviewCapability(appId: string, runId: string, ga
  * authority.
  */
 export declare function getReviewCapability(appId: string, runId: string, gateId: string, options: BuildDelegatedReviewCapabilityOptions): Promise<BuildDelegatedReviewCapabilityResponse>;
+/**
+ * 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.
+ */
 export declare function topup(appId: string, runId: string, options: BuildTopupOptions): Promise<BuildTopupResponse>;
+/** An image build's verified images and its asset's current release. */
+export declare function media(appId: string, runId: string): Promise<BuildMediaResponse>;
+/** A short-lived signed URL for one image of an image build (usable directly as an image source). */
+export declare function mediaDownloadUrl(appId: string, runId: string, artifactId: string): Promise<BuildMediaDownloadUrlResponse>;
+/** Roll back the release an image build published: its asset returns to the release it replaced. */
+export declare function rollbackMedia(appId: string, runId: string, options?: {
+    note?: string;
+}): Promise<BuildMediaRollbackResponse>;
 export declare function list(appId: string, limit?: number): Promise<BuildListResponse>;
 export {};

package/dist/builds/index.d.ts

@@ -1,4 +1,4 @@
-import { cancel, decideGate, events, get, getReviewCapability, list, refreshReviewCapability, submit, topup, uploadInput } from './client';
+import { cancel, decideGate, events, get, getReviewCapability, list, media, mediaDownloadUrl, refreshReviewCapability, rollbackMedia, submit, topup, uploadInput } from './client';
 import { watch } from './watch';
 /**
  * Registered first-party product surfaces only, with
@@ -17,8 +17,13 @@ export declare const builds: {
     uploadInput: typeof uploadInput;
     list: typeof list;
     watch: typeof watch;
+    media: typeof media;
+    mediaDownloadUrl: typeof mediaDownloadUrl;
+    rollbackMedia: typeof rollbackMedia;
 };
 export { BuildsApiError } from './client';
+export { mediaAgentTools } from './media-tools';
+export type { MediaAgentTool, MediaToolName, MediaToolResult, MediaToolsClient } from './media-tools';
 export type { BuildGateDecisionOptions, BuildDelegatedReviewCapabilityOptions, BuildReviewCapabilityRefreshOptions, BuildSubmitOptions, BuildTopupOptions, BuildInputArtifact, } from './client';
 export type { BuildRunWatchHandle, BuildRunWatchOptions, BuildRunWatchUpdate, } from './watch';
 export * from './types';

package/dist/builds/media-tools.d.ts

@@ -0,0 +1,37 @@
+import { decideGate as decideGateRequest, get as getRequest, media as mediaRequest, mediaDownloadUrl as mediaDownloadUrlRequest, submit as submitRequest } from './client';
+/**
+ * AGENT TOOLS FOR MEDIA BUILDS: the builds client as tool declarations an agent framework can offer a model (a name, a
+ * description and a JSON Schema for the input) with an executor for each.
+ *
+ * An agent creates, inspects, revises, compares and selects within the app's build policy, and exports what was made. It
+ * never publishes: a media release lands through the app's landing policy, so `media_propose` only reports where the
+ * candidate stands and who decides. Every result names the operations that make sense next, and a request the run cannot
+ * take is answered with a code and the reason instead of being attempted.
+ */
+export type MediaToolName = 'media_create' | 'media_edit' | 'media_inspect' | 'media_revise' | 'media_select' | 'media_export' | 'media_propose';
+export type MediaToolResult = {
+    ok: true;
+    data: Record<string, unknown>;
+    next: MediaToolName[];
+} | {
+    ok: false;
+    code: string;
+    message: string;
+    retryable: boolean;
+    next: MediaToolName[];
+};
+export interface MediaAgentTool {
+    name: MediaToolName;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    execute(input: unknown): Promise<MediaToolResult>;
+}
+/** The client calls the tools make; the SDK's own by default (tests and other transports substitute). */
+export interface MediaToolsClient {
+    submit: typeof submitRequest;
+    get: typeof getRequest;
+    decideGate: typeof decideGateRequest;
+    media: typeof mediaRequest;
+    mediaDownloadUrl: typeof mediaDownloadUrlRequest;
+}
+export declare function mediaAgentTools(appId: string, client?: MediaToolsClient): MediaAgentTool[];

package/dist/builds/types.d.ts

@@ -1,8 +1,8 @@
 export declare const NON_TERMINAL_STATES: readonly ["queued", "admitted", "executing", "preview_ready", "parked", "resuming", "promoting", "quarantined"];
 export declare const TERMINAL_STATES: readonly ["promoted", "failed", "canceled", "rejected", "expired", "rebase_required", "reported"];
 export declare const RUN_STATES: readonly ["queued", "admitted", "executing", "preview_ready", "parked", "resuming", "promoting", "quarantined", "promoted", "failed", "canceled", "rejected", "expired", "rebase_required", "reported"];
-export declare const PARK_REASONS: readonly ["gate", "funding"];
-export declare const FAILURE_REASONS: readonly ["admission_rejected", "dispatch_timeout", "auth_revoked", "owner_changed", "policy_changed", "quarantine_forced", "bind_failed", "internal_error"];
+export declare const PARK_REASONS: readonly ["gate", "funding", "preview", "design"];
+export declare const FAILURE_REASONS: readonly ["admission_rejected", "dispatch_timeout", "auth_revoked", "owner_changed", "policy_changed", "target_retired", "promotion_rejected", "quarantine_forced", "bind_failed", "internal_error"];
 export type NonTerminalState = (typeof NON_TERMINAL_STATES)[number];
 export type TerminalState = (typeof TERMINAL_STATES)[number];
 export type RunState = (typeof RUN_STATES)[number];
@@ -60,6 +60,253 @@ export type BuildDelegatedReviewCapabilityView = BuildDelegatedReviewCapabilityB
     state: 'decided';
     decision: 'approve' | 'reject';
 });
+/** One choice a single-choice design question offers. */
+export interface BuildRunDesignQuestionOption {
+    id: string;
+    label: string;
+    /** Short supporting detail for the choice. */
+    hint?: string;
+}
+/**
+ * A design assumption the owner can confirm or change. `single` offers 2-4
+ * options and `current` names the one the prototype already shows; `text`
+ * asks for a short free answer and carries no options.
+ */
+export interface BuildRunDesignQuestion {
+    /** Unique within its round. */
+    id: string;
+    /** Short topic, such as "Layout". */
+    label: string;
+    /** The question itself, one line. */
+    prompt: string;
+    kind: 'single' | 'text';
+    options?: BuildRunDesignQuestionOption[];
+    /** The option id the prototype already implements. */
+    current?: string;
+    /** The design surface this question is about, when it is about one. */
+    surfaceId?: string;
+}
+/** One design round the owner has seen. */
+export interface BuildRunDesignRound {
+    round: number;
+    prototypeUrl?: string;
+    shots: number;
+    /** Screenshots of the round's served prototype, one per viewport. */
+    renders?: Array<{
+        viewport: string;
+        url: string;
+    }>;
+    /** The questions that round asked. */
+    questions?: BuildRunDesignQuestion[];
+    /**
+     * How the round's design review was decided. Known decisions are approve,
+     * request_changes, cancel, reject, skip and retry; `summary` is the first
+     * line of the decision note.
+     */
+    decision?: {
+        decision: string;
+        summary?: string;
+        decidedAt: string;
+    };
+    /** The previous round's requested changes could not be applied, so this round shows that prototype again. */
+    revisionFailed?: boolean;
+    /** A media build's candidates for this round; a decision chooses one with `selectedArtifactId`. */
+    candidates?: BuildRunImageCandidate[];
+}
+/** One candidate a design round served (an image, or a `video/mp4` clip with its duration). */
+export interface BuildRunImageCandidate {
+    id: string;
+    /** Absent when the round was served without a web address (a local Bind); the candidate is still chosen by id. */
+    url?: string;
+    mimeType: string;
+    width: number;
+    height: number;
+    /** A clip's duration. */
+    durationMs?: number;
+    /** A multi-scene video's scenes in play order: a `request_changes` names the ones to regenerate (`sceneIds`). */
+    scenes?: Array<{
+        id: string;
+        durationMs: number;
+        url?: string;
+    }>;
+}
+/** What an image build delivers: its sizing, quality, output format and references. Everything is optional. */
+export interface BuildImageSpec {
+    size?: '1024x1024' | '1024x1536' | '1536x1024';
+    quality?: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+    format?: 'png' | 'webp' | 'jpeg';
+    background?: 'opaque' | 'transparent';
+    /** Candidates per review round, 1 to 4 (default 2). */
+    candidates?: number;
+    /** `default` is the quality image model; `fast` is its faster sibling. */
+    model?: 'default' | 'fast';
+    /** Image attachments of the same submission the model takes as references. */
+    references?: Array<{
+        attachmentId: string;
+        role: 'subject' | 'style' | 'composition';
+    }>;
+    /**
+     * Edit (or fork) of a released PNG only: the rectangle, in the released image's pixels, that may change. Every pixel
+     * outside it stays exactly the release's (verified before the edit is released). Requires PNG output.
+     */
+    region?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+/**
+ * An image deliverable. A create generates a new asset of the app; an edit revises the asset's current release, named
+ * by `assetId`, optionally asserting the release it expects (`expectedReleaseId`).
+ */
+export interface BuildImageDeliverable {
+    kind: 'image';
+    spec?: BuildImageSpec;
+    assetId?: string;
+    expectedReleaseId?: string;
+    /** Create only: start a new asset from any retained release of this app's assets (a fork of that revision). */
+    forkOf?: BuildMediaForkOf;
+}
+/** A retained release a create forks into a new asset. */
+export interface BuildMediaForkOf {
+    assetId: string;
+    releaseId: string;
+}
+/** What a video build delivers. Everything is optional; an edit keeps its released clip's duration and aspect. */
+export interface BuildVideoSpec {
+    /** Whole seconds, 4-30 (default 5). Not on an edit. */
+    durationSeconds?: number;
+    /** Default `720p`; an edit keeps its released clip's. */
+    resolution?: '480p' | '720p';
+    /** Default `16:9`. Not with a first frame, whose aspect the clip takes, and not on an edit. */
+    aspectRatio?: '16:9' | '4:3' | '1:1' | '3:4' | '9:16' | '21:9';
+    /** Generate sound. Default false; an edit keeps its released clip's. */
+    audio?: boolean;
+    /** Alternatives per round, 1-2 (default 1). */
+    candidates?: number;
+    model?: 'default';
+    /**
+     * Image inputs, at most 4: an image attachment of the same submission or a released image asset of this app, as the
+     * first frame, the last frame (with a first frame) or a reference. An edit takes references only.
+     */
+    images?: Array<({
+        attachmentId: string;
+    } | {
+        assetId: string;
+    }) & {
+        role: 'first_frame' | 'last_frame' | 'reference';
+    }>;
+    /** Create: a multi-scene video's scenes (1-6 of 4-15 s, 30 s in all), rendered into one video with its captions. */
+    scenes?: BuildVideoScene[];
+    /** Edit of a multi-scene release: the scenes to regenerate; every other scene keeps its released clip exactly. */
+    replaceScenes?: Array<Omit<BuildVideoScene, 'durationSeconds'> & {
+        durationSeconds?: number;
+    }>;
+    /** Captions burned into a multi-scene video (on an edit they replace the released ones; absent, they are kept). An
+     *  edit that only changes captions makes no generation call. */
+    captions?: BuildVideoCaption[];
+}
+/** One scene of a multi-scene video. */
+export interface BuildVideoScene {
+    /** `s1` to `s6`, unique; scenes play in order. */
+    id: string;
+    prompt: string;
+    durationSeconds: number;
+    /** Reference images for this scene. */
+    images?: Array<({
+        attachmentId: string;
+    } | {
+        assetId: string;
+    }) & {
+        role: 'reference';
+    }>;
+}
+/** A caption burned into a multi-scene video, in milliseconds of the finished video. */
+export interface BuildVideoCaption {
+    startMs: number;
+    endMs: number;
+    text: string;
+}
+/**
+ * A video deliverable. A create generates a new clip asset of the app; an edit revises the asset's current release, named
+ * by `assetId`, optionally asserting the release it expects (`expectedReleaseId`).
+ */
+export interface BuildVideoDeliverable {
+    kind: 'video';
+    spec?: BuildVideoSpec;
+    assetId?: string;
+    expectedReleaseId?: string;
+    /** Create only: start a new clip asset from any retained video release of this app (a fork of that revision). */
+    forkOf?: BuildMediaForkOf;
+}
+/** A media build's facts of one image or clip: a clip also carries its duration and whether it has sound. */
+export interface BuildMediaArtifact {
+    id: string;
+    sha256: string;
+    bytes: number;
+    mimeType: string;
+    width: number;
+    height: number;
+    durationMs?: number;
+    hasAudio?: boolean;
+}
+/** A media build's asset, the verified images of its approved round (or its chosen clip), and the release it published. */
+export interface BuildRunMediaView {
+    kind: 'image' | 'video';
+    assetId: string;
+    baseReleaseId?: string;
+    /** The retained release a fork started this asset from. */
+    forkOf?: BuildMediaForkOf;
+    selectedArtifactId?: string;
+    artifacts?: BuildMediaArtifact[];
+    /** A multi-scene video: each scene's verified clip and its captions. */
+    scenes?: BuildMediaScene[];
+    captions?: BuildVideoCaption[];
+    releaseId?: string;
+}
+/** A multi-scene video's scene as released. */
+export interface BuildMediaScene {
+    id: string;
+    sha256: string;
+    bytes: number;
+    durationMs: number;
+    prompt: string;
+}
+/** One published release of a media asset. */
+export interface BuildMediaRelease {
+    releaseId: string;
+    runId: string;
+    prevReleaseId: string | null;
+    artifact: BuildMediaArtifact;
+    scenes?: BuildMediaScene[];
+    captions?: BuildVideoCaption[];
+    releasedAtMs: number;
+}
+export interface BuildMediaResponse {
+    wire: 1;
+    runId: string;
+    media: BuildRunMediaView | null;
+    asset: {
+        assetId: string;
+        currentRelease: BuildMediaRelease | null;
+    };
+}
+export interface BuildMediaDownloadUrlResponse {
+    wire: 1;
+    runId: string;
+    artifactId: string;
+    /** A short-lived signed URL serving exactly this image. */
+    url: string;
+    expiresAtMs: number;
+}
+export interface BuildMediaRollbackResponse {
+    wire: 1;
+    runId: string;
+    replayed: boolean;
+    /** The asset's release after the rollback (null when a create's release was rolled back). */
+    currentReleaseId: string | null;
+}
 /** The owner's design view of a design-first run: the prototype, every round seen, and the open design decision while
  *  the build waits on it (absent once decided). */
 export interface BuildRunDesignView {
@@ -76,13 +323,13 @@ export interface BuildRunDesignView {
         id: string;
         title: string;
     }>;
+    /** One-line summary of the round on screen. */
+    summary?: string;
+    /** The on-screen round's questions. Show them only while `gate` is open. */
+    questions?: BuildRunDesignQuestion[];
     round?: number;
     maxRounds?: number;
-    rounds?: Array<{
-        round: number;
-        prototypeUrl?: string;
-        shots: number;
-    }>;
+    rounds?: BuildRunDesignRound[];
     gate?: {
         gateId: string;
         allowedDecisions: string[];
@@ -130,6 +377,20 @@ export interface BuildRunClientView {
     };
     /** Owner-only design view: what an owner needs to answer a design review. */
     design?: BuildRunDesignView;
+    /** Owner-only: an image build's asset, verified images, and published release. */
+    media?: BuildRunMediaView;
+    /** Owner-only: the released images an application build pinned, and where the app serves each. */
+    mediaSlots?: Array<{
+        slot: string;
+        assetId: string;
+        releaseId: string;
+        sha256: string;
+        bytes: number;
+        mimeType: string;
+        width: number;
+        height: number;
+        file: string;
+    }>;
     createdAtMs: number;
     updatedAtMs: number;
 }
@@ -157,23 +418,37 @@ export interface BuildRunListRow {
     };
 }
 /**
- * Extensible developer-api error details. Project-limit errors populate the
- * typed fields below; other error codes may add arbitrary fields.
+ * Extensible developer-api error details. Quota refusals populate the typed
+ * fields below; other error codes may add arbitrary fields.
  */
 export interface BuildsApiErrorDetails {
-    /** Current usage when `code === "project_limit_exceeded"`. */
+    /** Creations counted inside the window when `code === "project_daily_limit_exceeded"`. */
     usage?: number;
-    /** Allowed usage when `code === "project_limit_exceeded"`. */
+    /** Creations the window allows when `code === "project_daily_limit_exceeded"`. */
     limit?: number;
-    /** Limit axis (for example, `maxProjects`) when a quota gate rejects. */
+    /** Limit axis (for example, `maxProjectCreatesPerDay`) when a quota gate rejects. */
     dimension?: string;
+    /** Length of the rolling window in milliseconds when a windowed quota gate rejects. */
+    windowMs?: number;
+    /**
+     * When the oldest counted creation leaves the window and one unit of capacity
+     * returns; `null` when nothing will free up (a limit of 0).
+     */
+    resetsAtMs?: number | null;
     [key: string]: unknown;
 }
-/** Exact details supplied with a `project_limit_exceeded` error. */
-export interface ProjectLimitExceededDetails extends BuildsApiErrorDetails {
+/**
+ * Exact details supplied with a `project_daily_limit_exceeded` error (HTTP 429):
+ * a Free account has used its rolling 24-hour project-create allowance.
+ * The response also carries `Retry-After` when `resetsAtMs` is not null, which
+ * the SDK surfaces as `BuildsApiError.retryAfterMs`.
+ */
+export interface ProjectDailyLimitExceededDetails extends BuildsApiErrorDetails {
     usage: number;
     limit: number;
-    dimension: string;
+    dimension: 'maxProjectCreatesPerDay';
+    windowMs: number;
+    resetsAtMs: number | null;
 }
 export interface BuildsApiErrorEnvelope {
     error: {
@@ -207,9 +482,34 @@ export interface BuildGateDecisionResponse {
     runId: string;
     targetAppId: string;
     gateId: string;
-    decision: 'approve' | 'reject';
+    decision: 'approve' | 'reject' | 'request_changes';
     state: string;
 }
+/** One answer to a design question: `optionId` for a `single` question, `text` for a `text` question. */
+export interface BuildDesignAnswer {
+    questionId: string;
+    optionId?: string;
+    text?: string;
+}
+/**
+ * Structured design review feedback. The builder validates it: answers must
+ * name the open round's questions, and confirming only the options the
+ * prototype already shows is not a requested change.
+ */
+export interface BuildDesignFeedback {
+    text?: string;
+    answers?: BuildDesignAnswer[];
+    /** Notes on specific design surfaces, by surface id. */
+    surfaces?: Array<{
+        id: string;
+        note: string;
+    }>;
+    /** Reference links for the designer. */
+    attachments?: Array<{
+        url: string;
+        name?: string;
+    }>;
+}
 export interface BuildDelegatedReviewCapabilityResponse {
     wire: 1;
     capability: BuildDelegatedReviewCapabilityView;

package/dist/{email-auth-provider-BGTfU1_i.mjs → email-auth-provider-BJXeBUwp.mjs}

@@ -1,5 +1,5 @@
 import { getActiveSessionManager } from '@bounded-sh/core';
-import { s as setCurrentUser, h as hasTurnkeyWallet, a as signMessageWithTurnkey, b as signTransactionWithTurnkey, c as signTransactionV1WithTurnkey, d as signAndSubmitTransactionWithTurnkey, g as getPlatform } from './index-DmAXYXDi.mjs';
+import { s as setCurrentUser, h as hasTurnkeyWallet, a as signMessageWithTurnkey, b as signTransactionWithTurnkey, c as signTransactionV1WithTurnkey, d as signAndSubmitTransactionWithTurnkey, g as getPlatform } from './index-CaZx7sd8.mjs';
 import 'react';
 
 // Web uses localStorage (WebSessionManager); React Native uses the configured
@@ -93,4 +93,4 @@ class EmailAuthProvider {
 const emailProviderSingleton = new EmailAuthProvider();
 
 export { EmailAuthProvider, emailProviderSingleton };
-//# sourceMappingURL=email-auth-provider-BGTfU1_i.mjs.map
+//# sourceMappingURL=email-auth-provider-BJXeBUwp.mjs.map