@civitai/blocks-react 0.76.0 → 0.77.0

package/README.md

@@ -1463,43 +1463,55 @@ options drive both arms (including `declined`). **`dev:live` refuses this bridge
 it has no civitai chrome to render the server-resolved confirm in, and driving
 the write without it would let dev prove out a flow production does not have.
 
-### `usePrepareTrainingDataset()` and `useRunTraining()` — LoRA training
-
-Train a LoRA with the ai-toolkit engine on the **viewer's own images**, from
-inside a page app — the App Blocks `kind: 'training'` flow. Four steps, three
-hooks:
-
-1. **Dataset** — `usePrepareTrainingDataset().prepareDataset([{ imageId, caption }])`
-   (`PREPARE_TRAINING_DATASET`). Only the viewer's own scanned, unflagged images
-   within the page's maturity ceiling are admitted; the rest come back in
-   `rejected` with a reason (`unavailable`, `unsupported-media`, `not-eligible`,
-   `pending-scan`, `import-failed`, `import-unavailable`; `pending-scan` and
-   `import-unavailable` are retryable). You get an opaque `datasetId` and the
-   admitted `count`, always at least 1 — if **nothing** is admitted the call
-   rejects with the server's message instead. 1–50 images, captions up to 1,000 characters; captions are
-   moderated. No dialog, no charge.
+### `useImageUpload({ purpose: 'trainingData' })` and `useRunTraining()` — LoRA training
+
+Train a LoRA with the ai-toolkit engine on **images the viewer uploads**, from
+inside a page app — the App Blocks `kind: 'training'` flow, with the same upload
+path and `{ air, caption }` dataset shape as Civitai's own training form. Four
+steps, three hooks:
+
+1. **Upload** — `useImageUpload({ purpose: 'trainingData' }).open()`
+   (`OPEN_IMAGE_UPLOAD { purpose: 'trainingData' }`). Civitai opens an upload
+   modal in **its own chrome**; the viewer picks up to 50 PNG, JPEG or WebP
+   images, and each is uploaded as a private blob (not published). `open()`
+   resolves with every image that uploaded, `[{ url, air }]`, or `null` when
+   the viewer cancels. Pair each `air` with your caption — captions up to 8,192
+   characters, one blob at most once. The host answers only when its modal
+   closes, after every original has uploaded, so `open()` waits up to an hour,
+   not the ten minutes the other pickers use.
 2. **Quote** — `useBuzzWorkflow().estimate(body)` with a `WorkflowBodyTraining`
-   (`kind: 'training'`, no `quoteId`). The reply carries `trainingQuote:
-   { quoteId, total, imageCount, expiresAt }` — the orchestrator's own price for
-   exactly this run, stored server-side for 15 minutes.
+   (`kind: 'training'`, `items: [{ air, caption }]`, no `quoteId`). The reply
+   carries `trainingQuote: { quoteId, total, imageCount, expiresAt }` — the
+   orchestrator's own price for exactly this run, stored server-side for 15
+   minutes.
 3. **Run** — `useRunTraining().runTraining({ ...body, quoteId })` (`RUN_TRAINING`).
    **Civitai shows the viewer a consent dialog in its own chrome** — price, base
    model, length and dataset size, all read back from the server, never from
-   your body — and submits only on their click. Change nothing in the body
-   between the estimate and the run; the server checks it against the quoted one.
+   your body, with the host's own copies of the uploads as thumbnails — and
+   submits only on their click. Change nothing in the body between the estimate
+   and the run; the server checks it against the quoted one.
 4. **Follow** — `useBuzzWorkflow().watch(workflowId)`. Once the run's moderation
    status is approved, `trainedEpochs` lists the epochs whose checkpoint is
    ready; send the viewer to the publish wizard with one of them (see
    `trainedEpochs` on `BlockWorkflowSnapshot`).
 
+🔴 **Upload and run in the same page session.** The host remembers the blobs
+its own upload modal uploaded for this block, and **refuses a quote naming any
+other** with `training data not uploaded here` — before any dialog, so no run
+and no charge. A page reload forgets the uploads: ask the viewer to upload
+again, then estimate again.
+
 🔴 **Availability.** Behind the host flag **`app-blocks-training-kind`**, which
 ships **off** and is evaluated per viewer. **Page apps only** — the model slot
-answers both messages with an error. The manifest must declare
+answers `RUN_TRAINING` with an error. The manifest must declare
 **`ai:write:budgeted`** and the viewer must be signed in and have granted it.
 **Refused from `dev:live` and from review sessions** (the server refuses
 development and review tokens); build the flow against the mock host. Requires a
 civitai.com host carrying civitai/civitai#5434 (`kind: 'training'`,
-`RUN_TRAINING`) and civitai/civitai#5438 (`PREPARE_TRAINING_DATASET`).
+`RUN_TRAINING`) and civitai/civitai#6461 (uploaded blobs as the dataset). The
+server-prepared dataset this flow used before #6461 (`usePrepareTrainingDataset`,
+`PREPARE_TRAINING_DATASET`) is **removed**; a host carrying #6461 answers that
+message with the error `removed`.
 
 🔴 **Money.** There is no `maxBuzz` and no timeout knob — the price is the quote.
 A confirmed run may cost more than the token's per-call `buzzBudget` (the viewer
@@ -1516,32 +1528,26 @@ saying anything about money:
 | `err.declined` | the viewer dismissed the dialog — **no run was submitted** | revert, say nothing |
 | `err.unconfirmed` | `submission-unconfirmed`, or no reply within the 10-min bound (`err.timedOut`) — the run **may be running and charged** | 🔴 **never retry automatically**: check the viewer's trainings first (`useAppWorkflows()` lists this app's runs). Re-running the same body after the server did start it is a **second, separately charged run** |
 | `err.refused` (`code: 'refused'`) | the server refused the submit after the viewer confirmed — a **spend cap** (their daily or private-run Buzz cap, the per-app consent budget, the app's daily spend or rate limit, a dev-session cap) or a **temporary-availability** deny. Refunded: **no run, nothing charged**; the quote is used up | show `err.message` (the server's reason, e.g. `daily Buzz cap reached: …`); estimate again before any retry — buying Buzz does not lift these caps |
+| `err.trainingDataNotUploaded` (`code: 'training data not uploaded here'`) | the quote names an image this host did not upload for this block (typically after a reload) — refused before any dialog: **no run, nothing charged** | ask the viewer to upload the images again, then estimate and run the new quote |
 | `err.signInRequired` | no session | route into `useRequestSignIn()` |
 | `err.code` set otherwise | a host refusal (`review-mode` / `block is not ready` / `invalid training request` / `no block token`) | show or ignore per case |
-| `err.code === undefined`, no flag | a server refusal before any submit (expired or used quote, changed body, ineligible image) | estimate again, then retry |
+| `err.code === undefined`, no flag | a server refusal before any submit (expired or used quote, changed body) | estimate again, then retry |
 
-`prepareDataset` rejects with a `PrepareTrainingDatasetError` (`.code` for the
-host's refusals — `review-mode`, `block is not ready`, `sign in to train`,
-`invalid training dataset`, `no block token` — plus `.signInRequired` and
-`.timedOut`). Preparing charges nothing, so none of them cost Buzz. It prompts
-for `ai:write:budgeted` and retries once on a grant (see the table below);
-`runTraining` deliberately does not — it carries no idempotency key and has an
-outcome where a run may exist, so it never re-sends.
+`runTraining` never prompts for `ai:write:budgeted` or re-sends — it carries no
+idempotency key and has an outcome where a run may exist.
 
 ```tsx
-const { prepareDataset } = usePrepareTrainingDataset();
+const { open } = useImageUpload({ purpose: 'trainingData' });
 const { estimate, watch } = useBuzzWorkflow();
 const { runTraining } = useRunTraining();
 
-async function train(images: Array<{ id: number; caption: string }>) {
-  // Rejects (no `.code`) when NOTHING is admitted, e.g. "none of the requested
-  // images can be used for training"; a resolved dataset always has count >= 1.
-  const dataset = await prepareDataset(images.map((i) => ({ imageId: i.id, caption: i.caption })));
-  if (dataset.rejected.length > 0) showNotice(`${dataset.rejected.length} image(s) left out`);
+async function train(captionFor: (image: BlockTrainingDataImage) => string) {
+  const images = await open();
+  if (!images) return; // the viewer cancelled
 
   const body: WorkflowBodyTraining = {
     kind: 'training',
-    datasetId: dataset.datasetId,
+    items: images.map((image) => ({ air: image.air, caption: captionFor(image) })),
     engine: 'ai-toolkit',
     model: baseModelKey, // a key from Civitai's training catalog
     params: aiToolkitParams, // AiToolkitTrainingParams
@@ -1561,6 +1567,7 @@ async function train(images: Array<{ id: number; caption: string }>) {
     if (err.declined) return; // no run
     if (err.unconfirmed) return showCheckYourTrainings(); // may be running — never auto-retry
     if (err.refused) return showError(err.message); // a cap / availability refusal; no run, nothing charged
+    if (err.trainingDataNotUploaded) return showError('Upload the images again.'); // no run
     if (err.signInRequired) return requestSignIn();
     showError('Could not start training. Get a new price and try again.');
   }
@@ -1569,19 +1576,22 @@ async function train(images: Array<{ id: number; caption: string }>) {
 
 With the mock host — `createMockHost` or `Harness` from
 `@civitai/blocks-react/testing` — the training path is **kind-faithful**: it
-holds the datasets it prepared and the quotes it stored, refuses an unknown
-dataset, a dataset with nothing admitted, a quote above 5,000 and a quote run
-twice, and needs
-`ai:write:budgeted` on the token and a signed-in viewer. Its knobs are
-`trainingDatasetRejected`, `trainingDatasetError`, `trainingQuoteTotal`,
-`runTrainingError` (`'declined'`, `'submission-unconfirmed'`, or any server
-message), `runTrainingCapRefusal` (the server's resolved cap / availability refusal, which consumes the quote →
+remembers the blob keys its uploads handed out and refuses a run naming any
+other (`training data not uploaded here`, quote kept), refuses items outside the
+server's schema at the estimate, a quote above 5,000, a quote run twice and a
+body that differs from the quoted one, and needs `ai:write:budgeted` on the
+token and a signed-in viewer. Its knobs are `cannedTrainingDataUpload` (the
+images an upload returns; default three fresh ones per upload, `null` for a
+cancel), `trainingDataNotUploadedHere` (refuse every run as a host that forgot
+its uploads would), `trainingQuoteTotal`, `runTrainingError` (`'declined'`,
+`'submission-unconfirmed'`, or any server message), `runTrainingCapRefusal` (the
+server's resolved cap / availability refusal, which consumes the quote →
 `err.refused`) and `generation.trainedEpochs` for the finished run. It has no
-consent dialog, so `runTraining` settles at once where the real host waits on a
-click, and it checks a run's body against its quote by `datasetId` only — the
-server compares the whole body.
-**`dev:live` refuses both bridges**, because the server refuses every training
-request from a dev token.
+upload modal and no consent dialog, so `open()` and `runTraining` settle at once
+where the real host waits on the viewer; and it accepts any https blob url as an
+`air`, where the server accepts only Civitai-hosted ones — name items by `air`.
+**`dev:live` refuses the run** (the server refuses every training request from a
+dev token) and answers the upload as a cancel.
 
 ### `useRunConfirmedStep()` — one job above the per-call budget
 
@@ -2213,8 +2223,10 @@ answers a raw `multiple` + Checkpoint request with the host's error.
 
 Host-mediated image upload — the host opens its native upload modal and the
 iframe never handles the bytes. Resolves with a moderated image (or `null` on
-dismiss); pass `{ purpose: 'generationSource' }` for an unscanned img2img source
-or `{ asyncScan: true }` for the early-resolve + `scanStatus()` flow.
+dismiss); pass `{ purpose: 'generationSource' }` for an unscanned img2img source,
+`{ purpose: 'trainingData' }` for several private training images in one call
+(`[{ url, air }] | null` — see the LoRA training section), or
+`{ asyncScan: true }` for the early-resolve + `scanStatus()` flow.
 
 ```tsx
 const { open } = useImageUpload();
@@ -2253,7 +2265,7 @@ render), with no picker, so the app can then post it. Returns `{ upload }`.
   sniffed type, whatever `filename` says.
 - **The cap is 40 MiB.** The hook refuses a larger buffer before sending it,
   with the host's error `file exceeds the maximum upload size`. The host also
-  allows at most 3 uploads and 80 MiB per 60 seconds per page, and replies
+  allows at most 8 uploads and 80 MiB per 60 seconds per page, and replies
   `busy` past that.
 - **The upload is blocking.** The host replies once the image is scanned, so
   allow for a wait of up to a few minutes. An image above the SFW ceiling or
@@ -2863,7 +2875,6 @@ had just worked.
 |---|---|---|
 | `useBuzzWorkflow()` | `submit()` | `ai:write:budgeted` |
 | `useCreatePostFromApp()` | `createPost()` | `posts:write:self` |
-| `usePrepareTrainingDataset()` | `prepareDataset()` | `ai:write:budgeted` |
 | `useGoodPurchase()` | `purchase()` | `goods:purchase:self` |
 | `useTip()` | `tip()` | `social:tip:self` |
 

package/dist/hooks/useImageUpload.d.ts

@@ -1,11 +1,12 @@
-import type { BlockGenerationSourceImageInfo, BlockImageScanResult, BlockPendingImageInfo, BlockUploadedImageInfo, BlockUploadPurpose } from '@civitai/app-sdk/blocks';
+import type { BlockGenerationSourceImageInfo, BlockImageScanResult, BlockPendingImageInfo, BlockTrainingDataImage, BlockUploadedImageInfo, BlockUploadPurpose } from '@civitai/app-sdk/blocks';
+export type { BlockTrainingDataImage };
 /**
  * What {@link useImageUpload} returns for the DEFAULT (`purpose: 'display'`,
  * blocking-scan) call — `useImageUpload()` with no arguments.
  *
  * 🔴 THIS HOOK IS OVERLOADED, SO ITS RETURN TYPE IS A FAMILY, NOT A SINGLETON
  * (#380). Each overload names its own: {@link UseImageUploadGenerationSource},
- * {@link UseImageUploadAsyncScan}, and this one. A single union would be worse
+ * {@link UseImageUploadTrainingData}, {@link UseImageUploadAsyncScan}, and this one. A single union would be worse
  * than the anonymous literals it replaces — it would hand every caller a
  * `scanStatus` that only one overload actually provides.
  */
@@ -16,6 +17,14 @@ export interface UseImageUpload {
 export interface UseImageUploadGenerationSource {
     open: () => Promise<BlockGenerationSourceImageInfo | null>;
 }
+/** What {@link useImageUpload} returns for `{ purpose: 'trainingData' }`. */
+export interface UseImageUploadTrainingData {
+    /**
+     * Every image the viewer uploaded, in the host's order, or `null` when they
+     * cancelled. Each `air` is what a `BlockTrainingDatasetItem` names.
+     */
+    open: () => Promise<BlockTrainingDataImage[] | null>;
+}
 /** What {@link useImageUpload} returns for `{ asyncScan: true }`. */
 export interface UseImageUploadAsyncScan {
     /** Early-resolve handle (image persisted, NOT yet scanned) or `null` (dismissed). */
@@ -37,7 +46,7 @@ export interface UseImageUploadAsyncScan {
  * compatible; the async overload types it required.
  */
 export interface UseImageUploadImplementation {
-    open: () => Promise<BlockUploadedImageInfo | BlockGenerationSourceImageInfo | BlockPendingImageInfo | null>;
+    open: () => Promise<BlockUploadedImageInfo | BlockGenerationSourceImageInfo | BlockPendingImageInfo | BlockTrainingDataImage[] | null>;
     scanStatus?: (handle: BlockPendingImageInfo) => Promise<BlockImageScanResult>;
 }
 /** Options for {@link useImageUpload}. */
@@ -49,14 +58,18 @@ export interface UseImageUploadOptions {
      *  - `'generationSource'` — a PRIVATE img2img source; UNSCANNED, so the host
      *    returns ONLY the source shape {@link BlockGenerationSourceImageInfo}
      *    (`{ url, width, height }`).
+     *  - `'trainingData'` — PRIVATE training images for a `kind: 'training'` run
+     *    (page apps only): up to 50 picked in one host modal, returned together as
+     *    {@link BlockTrainingDataImage}`[]`.
      */
     purpose?: BlockUploadPurpose;
     /**
      * Opt in to the NON-BLOCKING `'display'` flow. When `true`, `open()` resolves
      * EARLY (on persist) with a {@link BlockPendingImageInfo} and the scan verdict
      * is delivered separately via `scanStatus()` (see the async overload). Only
-     * meaningful for `'display'`; ignored for `'generationSource'` (that path has
-     * no host-side scan). Absent/`false` keeps the legacy blocking behavior.
+     * meaningful for `'display'`; ignored for `'generationSource'` and
+     * `'trainingData'` (neither has a host-side scan). Absent/`false` keeps the
+     * legacy blocking behavior.
      */
     asyncScan?: boolean;
 }
@@ -82,9 +95,20 @@ export interface UseImageUploadOptions {
  *    {@link BlockGenerationSourceImageInfo} (`{ url, width, height }`, UNSCANNED —
  *    the orchestrator scans it at gen time), or `null` on dismiss. Feed it
  *    straight into a `WorkflowBody.sourceImage` for an img2img graph.
+ *  - `'trainingData'` → resolves with EVERY image the viewer uploaded,
+ *    {@link BlockTrainingDataImage}`[]` (`{ url, air }` each), or `null` on
+ *    cancel. Step 1 of a `kind: 'training'` run: pair each `air` with a caption
+ *    for `WorkflowBodyTraining.items`. The host remembers the keys it uploaded
+ *    for this block and refuses a run naming any other
+ *    (`training data not uploaded here`), so upload and run in the same page
+ *    session. A host that predates the purpose answers with one display image,
+ *    which this resolves as `null` — never as a list it did not upload.
  *
  * Human-interactive, so it uses the same generous {@link HUMAN_INTERACTION_TIMEOUT_MS}
- * as the pickers (the host still resolves earlier on upload/dismiss/close).
+ * as the pickers (the host still resolves earlier on upload/dismiss/close) — except
+ * `'trainingData'`, which waits up to {@link TRAINING_DATA_UPLOAD_TIMEOUT_MS} (one
+ * hour): the host replies only after uploading up to 50 originals, which can take
+ * longer than ten minutes.
  * Host-mediated, same trust model as `useResourcePicker` / `useBuzzWorkflow`.
  *
  * Backward-compatible: when `purpose` is omitted the hook sends NO `purpose`
@@ -117,10 +141,20 @@ export interface UseImageUploadOptions {
  * if (!src) return;
  * await submit({ kind: 'textToImage', modelId, modelVersionId,
  *   sourceImage: src, params: { prompt } });
+ *
+ * @example
+ * // trainingData (private training images, several in one reply)
+ * const { open } = useImageUpload({ purpose: 'trainingData' });
+ * const images = await open();            // [{ url, air }, …] | null
+ * if (!images) return;
+ * const items = images.map((img) => ({ air: img.air, caption: captionFor(img) }));
  */
 export declare function useImageUpload(options: {
     purpose: 'generationSource';
 }): UseImageUploadGenerationSource;
+export declare function useImageUpload(options: {
+    purpose: 'trainingData';
+}): UseImageUploadTrainingData;
 export declare function useImageUpload(options: {
     purpose?: 'display';
     asyncScan: true;

package/dist/hooks/useImageUpload.js

@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useRef } from 'react';
-import { HUMAN_INTERACTION_TIMEOUT_MS } from '../transport/requestTimeouts.js';
+import { HUMAN_INTERACTION_TIMEOUT_MS, TRAINING_DATA_UPLOAD_TIMEOUT_MS, } from '../transport/requestTimeouts.js';
 import { getTransport } from '../transport/singleton.js';
 import { sendTypedRequest, subscribeTyped } from '../transport/transport.js';
 import { useTransportConnection } from './useTransportConnection.js';
@@ -31,7 +31,7 @@ function isTerminalVerdict(v) {
 export function useImageUpload(options) {
     useTransportConnection();
     const purpose = options?.purpose;
-    const asyncScan = options?.asyncScan === true && purpose !== 'generationSource';
+    const asyncScan = options?.asyncScan === true && (purpose === undefined || purpose === 'display');
     // Per-instance scan tracking, keyed by imageId. Persists across renders; a
     // verdict is correlated back to its upload by imageId + the generated requestId.
     const scansRef = useRef(new Map());
@@ -129,6 +129,19 @@ export function useImageUpload(options) {
             // payload) → treat as dismissed rather than fabricate a handle.
             return null;
         }
+        if (purpose === 'trainingData') {
+            const { selected } = await sendTypedRequest(getTransport(), { type: 'OPEN_IMAGE_UPLOAD', payload: { purpose } }, 'IMAGE_UPLOAD_RESULT', 
+            // NOT the 10-minute human bound: the host answers only after uploading
+            // every original, which can outlast it — see TRAINING_DATA_UPLOAD_TIMEOUT_MS.
+            { timeoutMs: TRAINING_DATA_UPLOAD_TIMEOUT_MS });
+            // Only the multi-image shape is an answer to THIS purpose. A host that
+            // predates `trainingData` normalises it to `display` and replies with one
+            // moderated image — nothing a training item can name — so that, an empty
+            // list and a cancel all resolve `null` rather than a fabricated list.
+            if (!selected || !('images' in selected) || selected.images.length === 0)
+                return null;
+            return selected.images.map(({ url, air }) => ({ url, air }));
+        }
         // ---- Existing BLOCKING behavior (unchanged) ----
         // Omit `purpose` for the default/display mode so the wire stays
         // byte-compatible with an older host that predates the field.
@@ -136,7 +149,10 @@ export function useImageUpload(options) {
         const { selected } = await sendTypedRequest(getTransport(), { type: 'OPEN_IMAGE_UPLOAD', payload }, 'IMAGE_UPLOAD_RESULT', { timeoutMs: HUMAN_INTERACTION_TIMEOUT_MS });
         // Normalize the "dismissed" case to an explicit null so callers can
         // `if (!img) return;` without an `undefined` ambiguity.
-        return selected ?? null;
+        // A multi-image training reply is not an answer to a single-image purpose.
+        if (!selected || 'images' in selected)
+            return null;
+        return selected;
     }, [asyncScan, purpose]);
     const scanStatus = useCallback((handle) => {
         const entry = scansRef.current.get(handle.imageId);

package/dist/hooks/useRunTraining.d.ts

@@ -1,5 +1,5 @@
-import type { BlockRunTrainingHostError, BlockTrainingQuote, BlockWorkflowSnapshot, WorkflowBodyTraining } from '@civitai/app-sdk/blocks';
-export type { BlockRunTrainingHostError, BlockTrainingQuote, WorkflowBodyTraining };
+import type { BlockRunTrainingHostError, BlockTrainingDatasetItem, BlockTrainingQuote, BlockWorkflowSnapshot, WorkflowBodyTraining } from '@civitai/app-sdk/blocks';
+export type { BlockRunTrainingHostError, BlockTrainingDatasetItem, BlockTrainingQuote, WorkflowBodyTraining, };
 /**
  * A training body ready to RUN: {@link WorkflowBodyTraining} with the `quoteId`
  * its estimate returned. Required here so a body without one is a compile error
@@ -16,7 +16,7 @@ export type QuotedTrainingBody = WorkflowBodyTraining & {
  * a body that differs from the quoted one) arrive in the same field — see
  * {@link isRunTrainingErrorCode}.
  */
-export declare const RUN_TRAINING_ERROR_CODES: readonly ["review-mode", "block is not ready", "sign in to train", "invalid training request", "no block token", "declined", "submission-unconfirmed"];
+export declare const RUN_TRAINING_ERROR_CODES: readonly ["review-mode", "block is not ready", "sign in to train", "invalid training request", "no block token", "training data not uploaded here", "declined", "submission-unconfirmed"];
 /**
  * The `code` a {@link RunTrainingError} can carry: one of the host's closed
  * refusal codes, or `'refused'` — assigned by THIS SDK, never sent by the host,
@@ -49,9 +49,15 @@ export declare function isRunTrainingErrorCode(error: string): error is BlockRun
  *    `.snapshot` the refusal it arrived in. Retrying needs a new estimate and
  *    usually a later time; buying Buzz does not lift these caps.
  *  - `.signInRequired` — no session. Route into `useRequestSignIn()`.
+ *  - `.trainingDataNotUploaded` (`code: 'training data not uploaded here'`) —
+ *    the quote names an image THIS host did not upload for this block. The host
+ *    remembers only the blobs its own `useImageUpload({ purpose: 'trainingData' })`
+ *    uploaded, and forgets them on a page reload. Refused before any dialog:
+ *    NO RUN, nothing charged. Ask the viewer to upload the images again, then
+ *    estimate and run the new quote.
  *  - anything else — a refusal before any submit (an expired or used quote, a
- *    body that no longer matches its quote, an ineligible image). Estimate again
- *    before retrying; `.message` is the host's or server's text.
+ *    body that no longer matches its quote). Estimate again before retrying;
+ *    `.message` is the host's or server's text.
  */
 export declare class RunTrainingError extends Error {
     /**
@@ -78,6 +84,12 @@ export declare class RunTrainingError extends Error {
     readonly timedOut: boolean;
     /** There is no session (`sign in to train`, or a bare `UNAUTHORIZED`). */
     readonly signInRequired: boolean;
+    /**
+     * The quote names an image this host did not upload for this block
+     * (`training data not uploaded here`). No run, nothing charged: upload the
+     * images again, estimate again, and run that quote.
+     */
+    readonly trainingDataNotUploaded: boolean;
     constructor(error: string, opts?: {
         timedOut?: boolean;
         refusedSnapshot?: BlockWorkflowSnapshot;
@@ -112,15 +124,19 @@ export interface UseRunTraining {
  * viewer. Refused from `dev:live` and from review sessions — build the flow
  * against the mock host. See `WorkflowBodyTraining` in `@civitai/app-sdk`.
  *
- * The flow: `usePrepareTrainingDataset()` → `useBuzzWorkflow().estimate(body)`
- * (its `trainingQuote.quoteId`) → `runTraining({ ...body, quoteId })` →
- * `useBuzzWorkflow().watch(workflowId)`. Change nothing in the body between the
- * estimate and the run: the server checks it against the quoted one.
+ * The flow: `useImageUpload({ purpose: 'trainingData' }).open()` (the viewer
+ * uploads the images; you caption them into `items: [{ air, caption }]`) →
+ * `useBuzzWorkflow().estimate(body)` (its `trainingQuote.quoteId`) →
+ * `runTraining({ ...body, quoteId })` → `useBuzzWorkflow().watch(workflowId)`.
+ * Change nothing in the body between the estimate and the run: the server checks
+ * it against the quoted one. Upload and run in the same page session: the host
+ * refuses a quote naming an image it did not upload for this block.
  *
  * 🔴 THE CONSENT DIALOG IS CIVITAI'S, AND IT IS THE CHARGE. Every number on it is
  * read back from the server's stored quote — never from your body. A run may cost
  * more than the token's per-call budget (the viewer confirms the exact price), up
- * to `BLOCK_TRAINING_MAX_BUZZ_PER_RUN` (5,000 Buzz). Images are the viewer's own.
+ * to `BLOCK_TRAINING_MAX_BUZZ_PER_RUN` (5,000 Buzz). Images are the ones the
+ * viewer uploaded through the host.
  *
  * 🔴 NO AUTOMATIC CONSENT RETRY, unlike the other consent-gated hooks — on
  * purpose. `RUN_TRAINING` carries no idempotency key and has an outcome
@@ -132,8 +148,12 @@ export interface UseRunTraining {
  * the viewer clicks or dismisses its dialog.
  *
  * @example
+ * const { open } = useImageUpload({ purpose: 'trainingData' });
  * const { estimate, watch } = useBuzzWorkflow();
  * const { runTraining } = useRunTraining();
+ * const images = await open();
+ * if (!images) return;                              // cancelled
+ * const body = { ...settings, items: images.map((i) => ({ air: i.air, caption: captionFor(i) })) };
  * const quote = (await estimate(body)).trainingQuote!;
  * try {
  *   const started = await runTraining({ ...body, quoteId: quote.quoteId });
@@ -142,6 +162,7 @@ export interface UseRunTraining {
  *   if (!(e instanceof RunTrainingError)) throw e;
  *   if (e.declined) return;                          // no run — say nothing
  *   if (e.signInRequired) return requestSignIn();
+ *   if (e.trainingDataNotUploaded) return askToUploadAgain(); // no run — re-upload, re-estimate
  *   if (e.unconfirmed) return showCheckYourTrainings(); // may be running — never auto-retry
  *   if (e.refused) return showError(e.message); // a cap / availability refusal; no run, nothing charged
  *   showError('Could not start training. Get a new price and try again.');

package/dist/hooks/useRunTraining.js

@@ -17,9 +17,12 @@ export const RUN_TRAINING_ERROR_CODES = [
     'sign in to train',
     'invalid training request',
     'no block token',
+    'training data not uploaded here',
     'declined',
     'submission-unconfirmed',
 ];
+/** The host code for a quote naming an image this host did not upload — see {@link RunTrainingError.trainingDataNotUploaded}. */
+const NOT_UPLOADED_HERE = 'training data not uploaded here';
 const CODE_SET = new Set(RUN_TRAINING_ERROR_CODES);
 /**
  * The `workflowId` the host's training submit stamps on a snapshot that is NOT a
@@ -55,9 +58,15 @@ export function isRunTrainingErrorCode(error) {
  *    `.snapshot` the refusal it arrived in. Retrying needs a new estimate and
  *    usually a later time; buying Buzz does not lift these caps.
  *  - `.signInRequired` — no session. Route into `useRequestSignIn()`.
+ *  - `.trainingDataNotUploaded` (`code: 'training data not uploaded here'`) —
+ *    the quote names an image THIS host did not upload for this block. The host
+ *    remembers only the blobs its own `useImageUpload({ purpose: 'trainingData' })`
+ *    uploaded, and forgets them on a page reload. Refused before any dialog:
+ *    NO RUN, nothing charged. Ask the viewer to upload the images again, then
+ *    estimate and run the new quote.
  *  - anything else — a refusal before any submit (an expired or used quote, a
- *    body that no longer matches its quote, an ineligible image). Estimate again
- *    before retrying; `.message` is the host's or server's text.
+ *    body that no longer matches its quote). Estimate again before retrying;
+ *    `.message` is the host's or server's text.
  */
 export class RunTrainingError extends Error {
     /**
@@ -84,6 +93,12 @@ export class RunTrainingError extends Error {
     timedOut;
     /** There is no session (`sign in to train`, or a bare `UNAUTHORIZED`). */
     signInRequired;
+    /**
+     * The quote names an image this host did not upload for this block
+     * (`training data not uploaded here`). No run, nothing charged: upload the
+     * images again, estimate again, and run that quote.
+     */
+    trainingDataNotUploaded;
     constructor(error, opts) {
         super(error);
         this.name = 'RunTrainingError';
@@ -99,6 +114,7 @@ export class RunTrainingError extends Error {
         this.declined = error === 'declined';
         this.unconfirmed = this.timedOut || error === 'submission-unconfirmed';
         this.signInRequired = error === 'sign in to train' || error === 'UNAUTHORIZED';
+        this.trainingDataNotUploaded = error === NOT_UPLOADED_HERE;
     }
 }
 /**
@@ -110,15 +126,19 @@ export class RunTrainingError extends Error {
  * viewer. Refused from `dev:live` and from review sessions — build the flow
  * against the mock host. See `WorkflowBodyTraining` in `@civitai/app-sdk`.
  *
- * The flow: `usePrepareTrainingDataset()` → `useBuzzWorkflow().estimate(body)`
- * (its `trainingQuote.quoteId`) → `runTraining({ ...body, quoteId })` →
- * `useBuzzWorkflow().watch(workflowId)`. Change nothing in the body between the
- * estimate and the run: the server checks it against the quoted one.
+ * The flow: `useImageUpload({ purpose: 'trainingData' }).open()` (the viewer
+ * uploads the images; you caption them into `items: [{ air, caption }]`) →
+ * `useBuzzWorkflow().estimate(body)` (its `trainingQuote.quoteId`) →
+ * `runTraining({ ...body, quoteId })` → `useBuzzWorkflow().watch(workflowId)`.
+ * Change nothing in the body between the estimate and the run: the server checks
+ * it against the quoted one. Upload and run in the same page session: the host
+ * refuses a quote naming an image it did not upload for this block.
  *
  * 🔴 THE CONSENT DIALOG IS CIVITAI'S, AND IT IS THE CHARGE. Every number on it is
  * read back from the server's stored quote — never from your body. A run may cost
  * more than the token's per-call budget (the viewer confirms the exact price), up
- * to `BLOCK_TRAINING_MAX_BUZZ_PER_RUN` (5,000 Buzz). Images are the viewer's own.
+ * to `BLOCK_TRAINING_MAX_BUZZ_PER_RUN` (5,000 Buzz). Images are the ones the
+ * viewer uploaded through the host.
  *
  * 🔴 NO AUTOMATIC CONSENT RETRY, unlike the other consent-gated hooks — on
  * purpose. `RUN_TRAINING` carries no idempotency key and has an outcome
@@ -130,8 +150,12 @@ export class RunTrainingError extends Error {
  * the viewer clicks or dismisses its dialog.
  *
  * @example
+ * const { open } = useImageUpload({ purpose: 'trainingData' });
  * const { estimate, watch } = useBuzzWorkflow();
  * const { runTraining } = useRunTraining();
+ * const images = await open();
+ * if (!images) return;                              // cancelled
+ * const body = { ...settings, items: images.map((i) => ({ air: i.air, caption: captionFor(i) })) };
  * const quote = (await estimate(body)).trainingQuote!;
  * try {
  *   const started = await runTraining({ ...body, quoteId: quote.quoteId });
@@ -140,6 +164,7 @@ export class RunTrainingError extends Error {
  *   if (!(e instanceof RunTrainingError)) throw e;
  *   if (e.declined) return;                          // no run — say nothing
  *   if (e.signInRequired) return requestSignIn();
+ *   if (e.trainingDataNotUploaded) return askToUploadAgain(); // no run — re-upload, re-estimate
  *   if (e.unconfirmed) return showCheckYourTrainings(); // may be running — never auto-retry
  *   if (e.refused) return showError(e.message); // a cap / availability refusal; no run, nothing charged
  *   showError('Could not start training. Get a new price and try again.');

package/dist/hooks/useUploadImageBytes.d.ts

@@ -58,7 +58,7 @@ export interface UseUploadImageBytes {
  *   scope, so ask for it first with `useRequestConsent()`: the upload runs
  *   before any `useCreatePostFromApp()` call that would otherwise prompt.
  * - **Images only:** PNG, WebP or JPEG by magic bytes. The cap is 40 MiB, and
- *   the host also allows at most 3 uploads and 80 MiB per 60 s per page.
+ *   the host also allows at most 8 uploads and 80 MiB per 60 s per page.
  * - The buffer is COPIED across `postMessage`, never transferred, so the block
  *   can keep displaying it. Pass an `ArrayBuffer` (`await blob.arrayBuffer()`),
  *   not a `Blob` or a typed array, which the host refuses.

package/dist/hooks/useUploadImageBytes.js

@@ -25,7 +25,7 @@ export const UPLOAD_IMAGE_BYTES_NO_IMAGE_ERROR = 'the host returned no uploaded
  *   scope, so ask for it first with `useRequestConsent()`: the upload runs
  *   before any `useCreatePostFromApp()` call that would otherwise prompt.
  * - **Images only:** PNG, WebP or JPEG by magic bytes. The cap is 40 MiB, and
- *   the host also allows at most 3 uploads and 80 MiB per 60 s per page.
+ *   the host also allows at most 8 uploads and 80 MiB per 60 s per page.
  * - The buffer is COPIED across `postMessage`, never transferred, so the block
  *   can keep displaying it. Pass an `ArrayBuffer` (`await blob.arrayBuffer()`),
  *   not a `Blob` or a typed array, which the host refuses.

package/dist/index.d.ts

@@ -73,10 +73,8 @@ export { useReactions, ReactionError, REACTIONS, REACTION_ERROR_CODES, isReactio
 export type { UseReactions, UseReactionsOptions } from './hooks/useReactions.js';
 export { useCreatePostFromApp, CreatePostError, CREATE_POST_ERROR_CODES, isCreatePostErrorCode, } from './hooks/useCreatePostFromApp.js';
 export type { UseCreatePostFromApp, BlockPostSource, BlockCreatePostRequest, BlockCreatePostResult, BlockCreatePostHostError, } from './hooks/useCreatePostFromApp.js';
-export { usePrepareTrainingDataset, PrepareTrainingDatasetError, PREPARE_TRAINING_DATASET_ERROR_CODES, isPrepareTrainingDatasetErrorCode, } from './hooks/usePrepareTrainingDataset.js';
-export type { UsePrepareTrainingDataset, BlockPrepareTrainingDatasetHostError, BlockTrainingDatasetItem, BlockTrainingDatasetResult, BlockTrainingRejectionReason, } from './hooks/usePrepareTrainingDataset.js';
 export { useRunTraining, RunTrainingError, RUN_TRAINING_ERROR_CODES, isRunTrainingErrorCode, } from './hooks/useRunTraining.js';
-export type { UseRunTraining, QuotedTrainingBody, RunTrainingErrorCode, BlockRunTrainingHostError, BlockTrainingQuote, WorkflowBodyTraining, } from './hooks/useRunTraining.js';
+export type { UseRunTraining, QuotedTrainingBody, RunTrainingErrorCode, BlockRunTrainingHostError, BlockTrainingQuote, BlockTrainingDatasetItem, WorkflowBodyTraining, } from './hooks/useRunTraining.js';
 export { useRunConfirmedStep, RunConfirmedStepError, RUN_CONFIRMED_STEP_ERROR_CODES, isRunConfirmedStepErrorCode, isStepQuoteId, } from './hooks/useRunConfirmedStep.js';
 export type { UseRunConfirmedStep, QuotedStepBody, RunConfirmedStepErrorCode, BlockRunConfirmedStepHostError, BlockStepQuote, WorkflowBodyPassThroughStep, } from './hooks/useRunConfirmedStep.js';
 export type { BlockBuzzTransaction, BlockBuzzAccount, BlockDailyCompensationResource, BlockWildcardPack, BlockWildcardPackErrorCode, AppWorkflow, AppWorkflowImage, AppWorkflowsParams, BlockGatedImage, BlockCollectionFollowErrorCode, BlockCollectionFollowResult, BlockAppReaction, BlockStoredReaction, BlockReactionEntityType, BlockEntityReactionErrorCode, BlockReactionCounts, BlockEntityReactionState, BlockEntityReactionResult, BlockEntityReactionsResult, } from '@civitai/app-sdk/blocks';
@@ -85,7 +83,7 @@ export type { UseCheckpointPicker } from './hooks/useCheckpointPicker.js';
 export { useResourcePicker, RESOURCE_PICKER_MULTIPLE_MAX } from './hooks/useResourcePicker.js';
 export type { UseResourcePicker, ResourcePickerOpenOptions, ResourcePickerMultiple, } from './hooks/useResourcePicker.js';
 export { useImageUpload } from './hooks/useImageUpload.js';
-export type { UseImageUpload, UseImageUploadAsyncScan, UseImageUploadGenerationSource, UseImageUploadOptions, } from './hooks/useImageUpload.js';
+export type { UseImageUpload, UseImageUploadAsyncScan, UseImageUploadGenerationSource, UseImageUploadTrainingData, UseImageUploadOptions, BlockTrainingDataImage, } from './hooks/useImageUpload.js';
 export { useUploadImageBytes } from './hooks/useUploadImageBytes.js';
 export type { UploadImageBytesOptions, UseUploadImageBytes, } from './hooks/useUploadImageBytes.js';
 export { useMediaUpload } from './hooks/useMediaUpload.js';

package/dist/index.js

@@ -62,7 +62,6 @@ export { InvalidIdempotencyKeyError } from './transport/transport.js';
 export { useCollectionFollow, CollectionFollowError, COLLECTION_FOLLOW_ERROR_CODES, isCollectionFollowErrorCode, } from './hooks/useCollectionFollow.js';
 export { useReactions, ReactionError, REACTIONS, REACTION_ERROR_CODES, isReactionErrorCode, } from './hooks/useReactions.js';
 export { useCreatePostFromApp, CreatePostError, CREATE_POST_ERROR_CODES, isCreatePostErrorCode, } from './hooks/useCreatePostFromApp.js';
-export { usePrepareTrainingDataset, PrepareTrainingDatasetError, PREPARE_TRAINING_DATASET_ERROR_CODES, isPrepareTrainingDatasetErrorCode, } from './hooks/usePrepareTrainingDataset.js';
 export { useRunTraining, RunTrainingError, RUN_TRAINING_ERROR_CODES, isRunTrainingErrorCode, } from './hooks/useRunTraining.js';
 export { useRunConfirmedStep, RunConfirmedStepError, RUN_CONFIRMED_STEP_ERROR_CODES, isRunConfirmedStepErrorCode, isStepQuoteId, } from './hooks/useRunConfirmedStep.js';
 export { useCheckpointPicker } from './hooks/useCheckpointPicker.js';