@civitai/blocks-react 0.76.1 → 0.77.0

package/dist/internal/liveHost.js

@@ -47,7 +47,7 @@
  * fetch chokepoints ..... 2
  * REST endpoints ........ GET /api/v1/blocks/me
  * tRPC procedures ....... 29 = blocks.* (14) + apps.shared.* (10) + apps.storage.* (5)
- * switch case labels .... 53, of which 15 REFUSE (enumerated under SCOPE below)
+ * switch case labels .... 52, of which 14 REFUSE (enumerated under SCOPE below)
  * --- END DERIVED ---
  *
  * PICKERS (Phase 1 of "make dev:live a faithful local host"): the live host
@@ -113,12 +113,9 @@
  *     `entity-unavailable`.
  *   • CREATE_POST_FROM_APP — needs the server-resolved preview plus host-chrome
  *     confirm before a PUBLIC post is written. Replies with a refusal.
- *   • PREPARE_TRAINING_DATASET — the server refuses every `kind: 'training'`
- *     request from a dev token, so there is nothing to forward. Replies with a
- *     refusal.
- *   • RUN_TRAINING — the same dev-token refusal, plus the host-chrome consent
- *     dialog a run is confirmed in, which this harness does not have. Replies
- *     with a refusal.
+ *   • RUN_TRAINING — the server refuses every `kind: 'training'` request from a
+ *     dev token, and a run is confirmed in a host-chrome consent dialog this
+ *     harness does not have. Replies with a refusal.
  *   • RUN_CONFIRMED_STEP — the server refuses a confirmed step from a dev token
  *     and the estimate never returns a `stepQuote` for one, and the price is
  *     confirmed in host chrome this harness does not have. Replies with a
@@ -174,8 +171,7 @@ const DEFAULT_BACKEND_BASE_URL = 'https://civitai.com';
 /** The budgeted-spend scope the workflow procedures require. */
 const BUDGETED_SCOPE = 'ai:write:budgeted';
 /**
- * The reply both training bridges get in dev:live — see their handlers. One
- * string so the two cannot drift.
+ * The reply `RUN_TRAINING` gets in dev:live — see its handler.
  */
 export const TRAINING_UNSUPPORTED_ERROR = 'training is not supported in dev:live — use dev:mock';
 /** The once-per-session console line for a refused training bridge. */
@@ -1139,35 +1135,25 @@ export function createLiveHost(options) {
                         });
                         return;
                     }
-                    case 'PREPARE_TRAINING_DATASET': {
+                    case 'RUN_TRAINING': {
                         // UNSUPPORTED in live, and here the SERVER decides it, not this
                         // harness: every `kind: 'training'` procedure refuses a dev token
                         // ("training is not available from a development or review session"
                         // — `assertTrainingRequestAllowed` in civitai/civitai), because there
                         // is no host page whose chrome can show the viewer a price. A
                         // training ESTIMATE is still forwarded (ESTIMATE_WORKFLOW above) and
-                        // comes back carrying that same server refusal.
+                        // comes back carrying that same server refusal. A run is also
+                        // CHARGED and confirmed in host chrome this harness does not have, so
+                        // faking either half would let dev prove out a flow production does
+                        // not have. The upload half (`OPEN_IMAGE_UPLOAD { purpose:
+                        // 'trainingData' }`) is answered as a dismissal (`null`), like every
+                        // other upload mode — see OPEN_IMAGE_UPLOAD below.
                         //
                         // FREE TEXT on the message's own reply channel; no host code is
                         // honest about "this harness cannot do it". Use dev:mock — its
-                        // `trainingDatasetError` / `trainingDatasetRejected` knobs cover the
-                        // refusal set.
-                        if (!isRoutableRequestId(requestId))
-                            return;
-                        logOnce('training-dataset', trainingUnsupportedLog('PREPARE_TRAINING_DATASET'));
-                        dispatchToBlock({
-                            type: 'TRAINING_DATASET_RESULT',
-                            payload: { requestId, error: TRAINING_UNSUPPORTED_ERROR },
-                        });
-                        return;
-                    }
-                    case 'RUN_TRAINING': {
-                        // UNSUPPORTED in live for the same server-side reason as
-                        // PREPARE_TRAINING_DATASET directly above — and doubly so: a run is
-                        // CHARGED and confirmed in host chrome this harness does not have, so
-                        // faking either half would let dev prove out a flow production does
-                        // not have. Use dev:mock — its `runTrainingError` knob covers
-                        // `declined`, `submission-unconfirmed` and the rest.
+                        // `cannedTrainingDataUpload`, `trainingDataNotUploadedHere` and
+                        // `runTrainingError` knobs cover the upload, the not-uploaded-here
+                        // refusal, `declined`, `submission-unconfirmed` and the rest.
                         if (!isRoutableRequestId(requestId))
                             return;
                         logOnce('training-run', trainingUnsupportedLog('RUN_TRAINING'));
@@ -1391,6 +1377,12 @@ export function createLiveHost(options) {
                                 'Test the bytes upload against the real site, or use ' +
                                 'createMockHost({ uploadImageBytesResult }) in dev:mock.');
                         }
+                        else if (typed.payload?.purpose === 'trainingData') {
+                            logOnce('open-image-upload-training-data', "OPEN_IMAGE_UPLOAD { purpose: 'trainingData' } received but live dev mode " +
+                                'cannot serve the training-data upload modal — resolving the upload as cancelled (null). ' +
+                                'Test the training flow against the real site, or use ' +
+                                'createMockHost({ cannedTrainingDataUpload }) in dev:mock.');
+                        }
                         else {
                             logOnce('open-image-upload', 'OPEN_IMAGE_UPLOAD received but live dev mode cannot serve the native upload ' +
                                 'modal — resolving the upload as dismissed (null). Test the image-upload flow ' +

package/dist/internal/mockHost.d.ts

@@ -37,7 +37,7 @@
  * called). Only the postMessage bridge round-trips are exercised. Never import
  * this from production code.
  */
-import { type BlockContext, type BlockResourceInfo, type BlockResourcePickerType, type BlockUploadedImageInfo, type BlockGenerationSourceImageInfo, type BuzzAccountType, type BlockBuzzTransaction, type BlockBuzzAccount, type BlockDailyCompensationResource, type BlockViewer, type BlockWildcardPack, type BlockWildcardPackErrorCode, type AppWorkflow, type BlockModel3dOutput, type BlockPublishedModel, type BlockRunConfirmedStepHostError, type BlockGatedImage, type BlockPickedImageInfo, type BlockCollectionFollowErrorCode, type BlockEntityReactionErrorCode, type BlockCreatePostHostError, type BlockCreatePostResult, type BlockPrepareTrainingDatasetHostError, type BlockRunTrainingHostError, type BlockTrainingRejectionReason, type ColorDomain, type SharedStorageValue, type Theme, type ViewerInfo, type WorkflowBody } from '@civitai/app-sdk/blocks';
+import { type BlockContext, type BlockResourceInfo, type BlockResourcePickerType, type BlockUploadedImageInfo, type BlockGenerationSourceImageInfo, type BuzzAccountType, type BlockBuzzTransaction, type BlockBuzzAccount, type BlockDailyCompensationResource, type BlockViewer, type BlockWildcardPack, type BlockWildcardPackErrorCode, type AppWorkflow, type BlockModel3dOutput, type BlockPublishedModel, type BlockRunConfirmedStepHostError, type BlockGatedImage, type BlockPickedImageInfo, type BlockCollectionFollowErrorCode, type BlockEntityReactionErrorCode, type BlockCreatePostHostError, type BlockCreatePostResult, type BlockRunTrainingHostError, type BlockTrainingDataImage, type ColorDomain, type SharedStorageValue, type Theme, type ViewerInfo, type WorkflowBody } from '@civitai/app-sdk/blocks';
 import { type MockMediaUploads } from './mediaUploadBytes.js';
 import { type MockWorkflowQuoteFailure } from './mockWorkflowGraph.js';
 import { type MockReactionSeed } from './mockHostReactions.js';
@@ -412,7 +412,7 @@ export interface MockGenerationScenario {
  */
 export declare const MOCK_TRAINING_BOUNDS: {
     readonly datasetMaxItems: 50;
-    readonly captionMaxChars: 1000;
+    readonly captionMaxChars: 8192;
     readonly maxBuzzPerRun: 5000;
 };
 /**
@@ -425,16 +425,15 @@ export declare const MOCK_TRAINING_BOUNDS: {
 export declare const MOCK_SPEND_SCOPE_ERROR = "block lacks ai:write:budgeted scope";
 /** The real server's refusal for an unknown, expired or spent quote on `RUN_TRAINING`. */
 export declare const MOCK_TRAINING_QUOTE_GONE_ERROR = "training quote not found, expired or already used \u2014 estimate again";
-/** The real server's refusal for a training estimate naming a dataset it does not hold. */
-export declare const MOCK_TRAINING_DATASET_GONE_ERROR = "training dataset not found or expired";
 /**
- * The real server's two refusals for a dataset with NOTHING admitted
- * (`prepareBlockTrainingDataset`): every image failed eligibility, or every
- * eligible image failed its import. The server THROWS rather than returning
- * `count: 0`, so a successful reply always admits at least one image.
+ * The estimate's refusals for `items` outside the server's schema. The first two
+ * are the server's own custom messages (`blockTrainingDatasetItemsSchema`); the
+ * third stands for every other zod issue (count, caption length, missing or extra
+ * keys), whose real text is zod's formatting and not a contract.
  */
-export declare const MOCK_TRAINING_NONE_ELIGIBLE_ERROR = "none of the requested images can be used for training";
-export declare const MOCK_TRAINING_NONE_IMPORTED_ERROR = "none of the requested images could be prepared for training";
+export declare const MOCK_TRAINING_AIR_ERROR = "air must be a consumer blob key or its Civitai-hosted blob url";
+export declare const MOCK_TRAINING_DUPLICATE_ERROR = "a training dataset names each image once";
+export declare const MOCK_TRAINING_ITEMS_ERROR = "training items must be 1 to 50 { air, caption } entries with captions of at most 8192 characters";
 /**
  * The per-job ceiling of a confirmed step — a COPY of `@civitai/app-sdk/blocks`'s
  * `BLOCK_CONFIRMED_STEP_MAX_BUZZ_PER_JOB`, not value-imported for the reason
@@ -1014,41 +1013,34 @@ export interface MockHostOptions {
      */
     createPostError?: BlockCreatePostHostError | string;
     /**
-     * Images `PREPARE_TRAINING_DATASET` leaves out, with their reasons — what
-     * `usePrepareTrainingDataset()` reports on `rejected`. Only entries whose
-     * `imageId` the request actually named are reported, and `count` is the rest,
-     * exactly as the server derives it. Absent → every image is admitted.
+     * The images an `OPEN_IMAGE_UPLOAD { purpose: 'trainingData' }` returns — what
+     * `useImageUpload({ purpose: 'trainingData' }).open()` resolves with. Absent →
+     * {@link DEFAULT_TRAINING_DATA_UPLOAD_COUNT} images with FRESH keys on every
+     * upload, so two uploads never collide. `null` (or `[]`) → the viewer cancelled.
      * Live-tunable via {@link MockHost.setScenario}.
      *
-     * When this rejects EVERY named image the reply is an `error`, as on the real
-     * server — {@link MOCK_TRAINING_NONE_ELIGIBLE_ERROR}, or
-     * {@link MOCK_TRAINING_NONE_IMPORTED_ERROR} when every image that passed
-     * eligibility was rejected with an `import-*` reason. A success never has
-     * `count: 0`.
-     *
-     * KIND-FAITHFUL, like the rest of the training path: the mock holds the
-     * datasets it prepared, an estimate naming any other `datasetId` fails as the
-     * server's does, a quote is run at most once, and every training call needs
-     * `ai:write:budgeted` on the token ({@link MockHostOptions.consentGranted}) and
-     * a signed-in viewer. What it cannot model: image ownership and moderation (it
-     * has no images), the flag, and the page-only / dev-token refusals.
-     *
-     * ⚠️ The quote↔body check is NARROWER than the server's: the mock compares only
-     * `datasetId`, while the server hashes the whole body (minus `quoteId`) and
-     * refuses any change. A body edited between estimate and run passes here and
-     * fails in production.
-     */
-    trainingDatasetRejected?: Array<{
-        imageId: number;
-        reason: BlockTrainingRejectionReason;
-    }>;
-    /**
-     * Force `PREPARE_TRAINING_DATASET` to reply with an `error` — a
-     * {@link BlockPrepareTrainingDatasetHostError} for a host refusal, or any other
-     * string for the free-text server-message variant. Absent → it prepares.
-     * Live-tunable via {@link MockHost.setScenario}.
+     * The mock REMEMBERS every key it hands out, per install, as the real host
+     * does per block instance: `RUN_TRAINING` refuses a quote naming any other key
+     * with `training data not uploaded here`, before any other check, and keeps the
+     * quote. Keys compare case-insensitively; an item may name its blob by the
+     * `url` too.
+     *
+     * KIND-FAITHFUL, like the rest of the training path: the estimate refuses items
+     * outside the server's schema, a quote is run at most once and is checked
+     * against the whole body it was quoted for (minus `quoteId`), and every
+     * training call needs `ai:write:budgeted` on the token
+     * ({@link MockHostOptions.consentGranted}) and a signed-in viewer. What it
+     * cannot model: blob storage, the Civitai-hosted-url rule on `air`, the flag,
+     * and the page-only / dev-token refusals.
+     */
+    cannedTrainingDataUpload?: BlockTrainingDataImage[] | null;
+    /**
+     * Make `RUN_TRAINING` refuse EVERY quote with `training data not uploaded
+     * here`, as the real host does after a page reload forgot the uploads. Settles
+     * before the server claims the quote, so the quote survives. Live-tunable via
+     * {@link MockHost.setScenario}; `undefined` clears it.
      */
-    trainingDatasetError?: BlockPrepareTrainingDatasetHostError | string;
+    trainingDataNotUploadedHere?: boolean;
     /**
      * The Buzz total a `kind: 'training'` estimate quotes. Default `500`. Above
      * `BLOCK_TRAINING_MAX_BUZZ_PER_RUN` (5,000) the estimate fails exactly as the
@@ -1064,7 +1056,8 @@ export interface MockHostOptions {
      *
      * Whether the QUOTE survives follows the real flow: the host's own gate and
      * dialog codes (`declined`, `review-mode`, `block is not ready`, `sign in to
-     * train`, `invalid training request`, `no block token`) settle before the
+     * train`, `invalid training request`, `no block token`, `training data not
+     * uploaded here`) settle before the
      * server claims the quote, so it stays runnable; `submission-unconfirmed` and
      * any server message settle after the claim, so it is used up — re-running it
      * gets the quote-gone error. Live-tunable via {@link MockHost.setScenario};
@@ -1431,7 +1424,7 @@ export interface MockHostOptions {
  * {@link MockHost.setTheme}, which pushes a real `THEME_CHANGE` — the mock of
  * the viewer toggling dark mode with the block already mounted.)
  */
-export type MockHostScenarioPatch = Pick<MockHostOptions, 'consentGrantable' | 'failMode' | 'cost' | 'pollsUntilDone' | 'cannedPicks' | 'cannedMultiPicks' | 'cannedImagePicks' | 'cannedImageUpload' | 'cannedGenerationSourceUpload' | 'cannedImageScan' | 'generation' | 'buzz' | 'storage' | 'shared' | 'buzzBalanceError' | 'viewerResult' | 'viewerError' | 'buzzTransactions' | 'buzzAccounts' | 'dailyCompensation' | 'buzzReadError' | 'wildcardPack' | 'wildcardPackError' | 'collectionFollowError' | 'reactionStates' | 'reactionError' | 'createPostResult' | 'createPostError' | 'trainingDatasetRejected' | 'trainingDatasetError' | 'trainingQuoteTotal' | 'runTrainingError' | 'runTrainingCapRefusal' | 'runConfirmedStepError' | 'runConfirmedStepCapRefusal' | 'appWorkflows' | 'appWorkflowsError' | 'publishImageIds' | 'publishError' | 'gatedImages' | 'gatedImagesError' | 'disallowedAccountTypes' | 'saveImageError' | 'uploadImageBytesResult' | 'uploadImageBytesError' | 'cannedMediaUploads' | 'mediaUploadError'>;
+export type MockHostScenarioPatch = Pick<MockHostOptions, 'consentGrantable' | 'failMode' | 'cost' | 'pollsUntilDone' | 'cannedPicks' | 'cannedMultiPicks' | 'cannedImagePicks' | 'cannedImageUpload' | 'cannedGenerationSourceUpload' | 'cannedImageScan' | 'generation' | 'buzz' | 'storage' | 'shared' | 'buzzBalanceError' | 'viewerResult' | 'viewerError' | 'buzzTransactions' | 'buzzAccounts' | 'dailyCompensation' | 'buzzReadError' | 'wildcardPack' | 'wildcardPackError' | 'collectionFollowError' | 'reactionStates' | 'reactionError' | 'createPostResult' | 'createPostError' | 'cannedTrainingDataUpload' | 'trainingDataNotUploadedHere' | 'trainingQuoteTotal' | 'runTrainingError' | 'runTrainingCapRefusal' | 'runConfirmedStepError' | 'runConfirmedStepCapRefusal' | 'appWorkflows' | 'appWorkflowsError' | 'publishImageIds' | 'publishError' | 'gatedImages' | 'gatedImagesError' | 'disallowedAccountTypes' | 'saveImageError' | 'uploadImageBytesResult' | 'uploadImageBytesError' | 'cannedMediaUploads' | 'mediaUploadError'>;
 /** Runtime Buzz-balance handle exposed on {@link MockHost.buzz}. */
 export interface MockBuzzHandle {
     /** Current simulated balance, or `undefined` when balance isn't simulated. */

package/dist/internal/mockHost.js

@@ -154,33 +154,81 @@ const trainingStepType = (body) => body.kind === 'training' ? 'training' : passT
  */
 export const MOCK_TRAINING_BOUNDS = {
     datasetMaxItems: 50,
-    captionMaxChars: 1000,
+    captionMaxChars: 8192,
     maxBuzzPerRun: 5000,
 };
+/** A consumer-blob key: the host's `BLOB_KEY_REGEX` (civitai/civitai#6461). */
+const MOCK_BLOB_KEY = /^[A-Za-z0-9]{1,64}(\.[A-Za-z0-9]{1,8})?$/;
+/** The path a blob url names its key under. */
+const MOCK_BLOB_PATH_PREFIX = '/v2/consumer/blobs/';
+/** The host's cap on an item's `air` string (`SOURCE_IMAGE_URL_MAX`). */
+const MOCK_AIR_MAX_CHARS = 2048;
 /**
- * The host's `PREPARE_TRAINING_DATASET` item check, mirrored: the server's
- * `blockTrainingDatasetItemsSchema` — 1…50 items, each EXACTLY `{ imageId:
- * positive integer, caption: string ≤ 1000 }`. The real host runs this BEFORE any
- * server call and refuses with `invalid training dataset`, so the mock does too.
+ * The blob key an item's `air` names, or `null` — the host's
+ * `trainingBlobKeyFromAir`: the bare key, or an https url whose path is exactly
+ * `/v2/consumer/blobs/<key>` (its query dropped).
+ *
+ * ⚠️ NARROWER THAN THE HOST: the real check also requires the url to be on a
+ * Civitai-hosted origin; the mock accepts any https host so a harness can use
+ * placeholder urls. Name an item by its `air` (the bare key) and the two agree.
  */
-function isValidTrainingDatasetItems(items) {
+const mockBlobKeyFromAir = (air) => {
+    if (MOCK_BLOB_KEY.test(air))
+        return air;
+    let url;
+    try {
+        url = new URL(air);
+    }
+    catch {
+        return null;
+    }
+    if (url.protocol !== 'https:' || !url.pathname.startsWith(MOCK_BLOB_PATH_PREFIX))
+        return null;
+    const key = url.pathname.slice(MOCK_BLOB_PATH_PREFIX.length);
+    return MOCK_BLOB_KEY.test(key) ? key : null;
+};
+/** The host's key identity (`trainingBlobKeyIdentity`): keys are case-insensitive. */
+const blobKeyIdentity = (key) => key.toLowerCase();
+/**
+ * The server's `kind: 'training'` item schema (`blockTrainingDatasetItemsSchema`,
+ * civitai/civitai#6461), mirrored for the ESTIMATE: 1…50 items, each EXACTLY
+ * `{ air, caption }` with a caption up to 8,192 characters, every `air` a blob key
+ * or blob url, and no blob named twice. Returns the items with each `air`
+ * canonicalised to its bare key — what the server quotes and hashes — or the
+ * refusal message.
+ */
+function resolveTrainingItems(items) {
     if (!Array.isArray(items))
-        return false;
-    if (items.length < 1 || items.length > MOCK_TRAINING_BOUNDS.datasetMaxItems)
-        return false;
-    return items.every((it) => {
+        return { refusal: MOCK_TRAINING_ITEMS_ERROR };
+    if (items.length < 1 || items.length > MOCK_TRAINING_BOUNDS.datasetMaxItems) {
+        return { refusal: MOCK_TRAINING_ITEMS_ERROR };
+    }
+    const shaped = items.every((it) => {
         if (typeof it !== 'object' || it === null || Array.isArray(it))
             return false;
         const keys = Object.keys(it);
-        if (keys.length !== 2 || !keys.includes('imageId') || !keys.includes('caption'))
+        if (keys.length !== 2 || !keys.includes('air') || !keys.includes('caption'))
             return false;
-        const { imageId, caption } = it;
-        return (typeof imageId === 'number' &&
-            Number.isInteger(imageId) &&
-            imageId > 0 &&
+        const { air, caption } = it;
+        return (typeof air === 'string' &&
+            air.length <= MOCK_AIR_MAX_CHARS &&
             typeof caption === 'string' &&
             caption.length <= MOCK_TRAINING_BOUNDS.captionMaxChars);
     });
+    if (!shaped)
+        return { refusal: MOCK_TRAINING_ITEMS_ERROR };
+    const out = [];
+    const seen = new Set();
+    for (const it of items) {
+        const key = mockBlobKeyFromAir(it.air);
+        if (key === null)
+            return { refusal: MOCK_TRAINING_AIR_ERROR };
+        if (seen.has(blobKeyIdentity(key)))
+            return { refusal: MOCK_TRAINING_DUPLICATE_ERROR };
+        seen.add(blobKeyIdentity(key));
+        out.push({ air: key, caption: it.caption });
+    }
+    return { items: out };
 }
 /**
  * The real server's refusal for ANY money call from a token without the spend
@@ -192,16 +240,19 @@ function isValidTrainingDatasetItems(items) {
 export const MOCK_SPEND_SCOPE_ERROR = 'block lacks ai:write:budgeted scope';
 /** The real server's refusal for an unknown, expired or spent quote on `RUN_TRAINING`. */
 export const MOCK_TRAINING_QUOTE_GONE_ERROR = 'training quote not found, expired or already used — estimate again';
-/** The real server's refusal for a training estimate naming a dataset it does not hold. */
-export const MOCK_TRAINING_DATASET_GONE_ERROR = 'training dataset not found or expired';
 /**
- * The real server's two refusals for a dataset with NOTHING admitted
- * (`prepareBlockTrainingDataset`): every image failed eligibility, or every
- * eligible image failed its import. The server THROWS rather than returning
- * `count: 0`, so a successful reply always admits at least one image.
+ * The estimate's refusals for `items` outside the server's schema. The first two
+ * are the server's own custom messages (`blockTrainingDatasetItemsSchema`); the
+ * third stands for every other zod issue (count, caption length, missing or extra
+ * keys), whose real text is zod's formatting and not a contract.
  */
-export const MOCK_TRAINING_NONE_ELIGIBLE_ERROR = 'none of the requested images can be used for training';
-export const MOCK_TRAINING_NONE_IMPORTED_ERROR = 'none of the requested images could be prepared for training';
+export const MOCK_TRAINING_AIR_ERROR = 'air must be a consumer blob key or its Civitai-hosted blob url';
+export const MOCK_TRAINING_DUPLICATE_ERROR = 'a training dataset names each image once';
+export const MOCK_TRAINING_ITEMS_ERROR = 'training items must be 1 to 50 { air, caption } entries with captions of at most 8192 characters';
+/** The host code for a quote naming an image the host did not upload for the block. */
+const MOCK_TRAINING_NOT_UPLOADED_HERE = 'training data not uploaded here';
+/** How many images a default `trainingData` upload returns. */
+const DEFAULT_TRAINING_DATA_UPLOAD_COUNT = 3;
 /**
  * The forced `RUN_TRAINING` errors that settle BEFORE the server claims (and so
  * consumes) the quote: the host's own gate and dialog codes. Derived from the
@@ -496,6 +547,8 @@ const DEFAULT_IMAGE_BYTES_UPLOAD = {
     contentRating: 'pg',
     url: 'https://image.civitai.com/mock/original=true/dev-bytes-upload.png',
 };
+/** Where the default `trainingData` upload's placeholder blob urls point. */
+const DEFAULT_TRAINING_DATA_URL_BASE = 'https://blobs.mock.invalid/v2/consumer/blobs/';
 const DEFAULT_GENERATION_SOURCE_UPLOAD = {
     url: 'https://image.civitai.com/mock/original=true/dev-generation-source.jpeg',
     width: 1024,
@@ -1108,10 +1161,11 @@ export function createMockHost(options = {}) {
     // App Blocks → Post bridge: the canned post + a forced-refusal knob.
     let createPostResult = options.createPostResult ?? DEFAULT_CREATE_POST_RESULT;
     let createPostError = options.createPostError;
-    // App Blocks training bridges: canned dataset rejections, quote total, and
-    // forced-refusal knobs. The datasets/quotes themselves live per install.
-    let trainingDatasetRejected = options.trainingDatasetRejected ?? [];
-    let trainingDatasetError = options.trainingDatasetError;
+    // App Blocks training: the canned upload, the "host forgot its uploads" knob,
+    // the quote total, and forced-refusal knobs. The uploaded keys and the quotes
+    // themselves live per install.
+    let cannedTrainingDataUpload = options.cannedTrainingDataUpload;
+    let trainingDataNotUploadedHere = options.trainingDataNotUploadedHere === true;
     let trainingQuoteTotal = options.trainingQuoteTotal ?? DEFAULT_TRAINING_QUOTE_TOTAL;
     let runTrainingError = options.runTrainingError;
     // SAVE_IMAGE: a forced-refusal knob (see `saveImageError`).
@@ -1368,10 +1422,29 @@ export function createMockHost(options = {}) {
         // restored after a reload). `canceled` is set by `CANCEL_WORKFLOW`, so later
         // polls keep answering `canceled` instead of resuming the countdown.
         const workflows = new Map();
-        // Training: datasets this install prepared (id → admitted count) and the
-        // quotes its estimates stored (id → what a run is checked against).
-        const trainingDatasets = new Map();
+        // Training: the blob keys this install's uploads handed out (by identity —
+        // the host's per-block-instance memory), and the quotes its estimates stored
+        // (id → what a run is checked against).
+        const trainingUploads = new Set();
+        let trainingUploadSerial = 0;
         const trainingQuotes = new Map();
+        /**
+         * What a training quote is bound to: the body without `quoteId`, its items
+         * canonicalised (the server quotes the bare key). `null` when the body is not
+         * plain JSON or its items do not resolve — then no run can match it.
+         */
+        const trainingFingerprint = (raw) => {
+            const resolved = resolveTrainingItems(raw.items);
+            if ('refusal' in resolved)
+                return null;
+            const { quoteId: _quoteId, ...rest } = raw;
+            try {
+                return canonicalStepJson({ ...rest, items: resolved.items }, 'body');
+            }
+            catch {
+                return null;
+            }
+        };
         // Confirmed steps: the quotes this install's estimates stored (id → what a
         // run is checked against). Same serial as the training handles, so every
         // handle this install mints is distinct.
@@ -1667,9 +1740,10 @@ export function createMockHost(options = {}) {
                     }
                     // TRAINING ESTIMATE — KIND-FAITHFUL, the one exception to the
                     // kind-agnostic rule above, because the real arm is not a priced
-                    // pass-through: it names a dataset the server must hold, refuses a
-                    // price above the per-run ceiling, and STORES a quote the run is later
-                    // checked against. (The spend scope is checked above, for every kind.)
+                    // pass-through: it checks the dataset items against the server's
+                    // schema, refuses a price above the per-run ceiling, and STORES a quote
+                    // the run is later checked against. (Uploads are NOT checked here —
+                    // the server's estimate does not; the host checks them at the run.) (The spend scope is checked above, for every kind.)
                     // Each refusal is the server's message in the host's `failureSnapshot`
                     // shape.
                     if (body.kind === 'training') {
@@ -1678,9 +1752,10 @@ export function createMockHost(options = {}) {
                             status: 'failed',
                             error,
                         });
-                        const imageCount = trainingDatasets.get(body.datasetId);
-                        if (imageCount === undefined)
-                            return refuse(MOCK_TRAINING_DATASET_GONE_ERROR);
+                        const resolved = resolveTrainingItems(body.items);
+                        if ('refusal' in resolved)
+                            return refuse(resolved.refusal);
+                        const imageCount = resolved.items.length;
                         const total = trainingQuoteTotal;
                         if (total > MOCK_TRAINING_BOUNDS.maxBuzzPerRun) {
                             return refuse(`this training run costs ${total} Buzz, above the per-run limit of ${MOCK_TRAINING_BOUNDS.maxBuzzPerRun} for apps`);
@@ -1688,7 +1763,8 @@ export function createMockHost(options = {}) {
                         const quoteId = trainingHandle('tq_');
                         const expiresAtMs = Date.now() + TRAINING_QUOTE_TTL_MS;
                         trainingQuotes.set(quoteId, {
-                            datasetId: body.datasetId,
+                            fingerprint: trainingFingerprint(body),
+                            itemKeys: resolved.items.map((it) => it.air),
                             total,
                             expiresAtMs,
                             spent: false,
@@ -2712,46 +2788,6 @@ export function createMockHost(options = {}) {
                         });
                         return;
                     }
-                    case 'PREPARE_TRAINING_DATASET': {
-                        // The host's gate order (`prepareTrainingDatasetGate.ts`): no
-                        // requestId → drop; signed-out → `sign in to train`; items outside
-                        // the server's schema → `invalid training dataset`, before any call.
-                        // Then the server: the spend scope, then the dataset.
-                        if (!isRoutableRequestId(requestId))
-                            return;
-                        const reply = (payload) => dispatchToBlock({ type: 'TRAINING_DATASET_RESULT', payload: { requestId, ...payload } });
-                        if (viewer === null)
-                            return reply({ error: 'sign in to train' });
-                        const items = typed.payload?.items;
-                        if (!isValidTrainingDatasetItems(items)) {
-                            return reply({ error: 'invalid training dataset' });
-                        }
-                        if (!consentGranted)
-                            return reply({ error: MOCK_SPEND_SCOPE_ERROR });
-                        if (trainingDatasetError !== undefined)
-                            return reply({ error: trainingDatasetError });
-                        const named = new Set(items.map((it) => it.imageId));
-                        const rejected = trainingDatasetRejected
-                            .filter((r) => named.has(r.imageId))
-                            .map(({ imageId, reason }) => ({ imageId, reason }));
-                        const rejectedIds = new Set(rejected.map((r) => r.imageId));
-                        const count = [...named].filter((id) => !rejectedIds.has(id)).length;
-                        if (count === 0) {
-                            // The server THROWS here, eligibility before import: an `import-*`
-                            // rejection means that image PASSED eligibility, so the server
-                            // reached the import and refuses there.
-                            const anyImported = rejected.some((r) => r.reason.startsWith('import-'));
-                            return reply({
-                                error: anyImported
-                                    ? MOCK_TRAINING_NONE_IMPORTED_ERROR
-                                    : MOCK_TRAINING_NONE_ELIGIBLE_ERROR,
-                            });
-                        }
-                        const datasetId = trainingHandle('tds_');
-                        trainingDatasets.set(datasetId, count);
-                        const result = { datasetId, count, rejected };
-                        return reply({ result });
-                    }
                     case 'RUN_TRAINING': {
                         // The host's gate (`runTrainingGate.ts`): no requestId → drop;
                         // signed-out → `sign in to train`; not a `kind:'training'` body with
@@ -2775,6 +2811,13 @@ export function createMockHost(options = {}) {
                         if (!quote || quote.spent || Date.now() >= quote.expiresAtMs) {
                             return reply({ error: MOCK_TRAINING_QUOTE_GONE_ERROR });
                         }
+                        // The host reads the quote back and refuses, with no dialog, one
+                        // naming any blob it did not upload for this block — before the
+                        // server claims it, so the quote survives.
+                        if (trainingDataNotUploadedHere ||
+                            quote.itemKeys.some((key) => !trainingUploads.has(blobKeyIdentity(key)))) {
+                            return reply({ error: MOCK_TRAINING_NOT_UPLOADED_HERE });
+                        }
                         // Which outcomes consume the quote, modelled on the real flow: the
                         // host's gate and consent dialog come first (quote kept); the
                         // server's submit then claims the quote with a GETDEL
@@ -2788,7 +2831,8 @@ export function createMockHost(options = {}) {
                             return reply({ error: runTrainingError });
                         }
                         quote.spent = true;
-                        if (b.datasetId !== quote.datasetId) {
+                        const runFingerprint = trainingFingerprint(b);
+                        if (runFingerprint === null || runFingerprint !== quote.fingerprint) {
                             return reply({
                                 error: 'the training body differs from the one that was quoted — estimate again',
                             });
@@ -3120,6 +3164,36 @@ export function createMockHost(options = {}) {
                             postableImageIds.add(uploadImageBytesResult.imageId);
                             return reply({ selected: { ...uploadImageBytesResult } });
                         }
+                        // TRAINING DATA (civitai/civitai#6461): several private images in ONE
+                        // reply, `{ images: [{ url, air }] }`. Every key handed out is
+                        // remembered for RUN_TRAINING's not-uploaded-here check.
+                        if (typed.payload?.purpose === 'trainingData') {
+                            let images;
+                            if (cannedTrainingDataUpload === undefined) {
+                                images = Array.from({ length: DEFAULT_TRAINING_DATA_UPLOAD_COUNT }, () => {
+                                    trainingUploadSerial += 1;
+                                    const air = `mockblob${trainingUploadSerial.toString(16).padStart(8, '0')}.png`;
+                                    return { url: `${DEFAULT_TRAINING_DATA_URL_BASE}${air}`, air };
+                                });
+                            }
+                            else {
+                                images = cannedTrainingDataUpload;
+                            }
+                            if (!images || images.length === 0) {
+                                dispatchToBlock({ type: 'IMAGE_UPLOAD_RESULT', payload: { requestId } });
+                                return;
+                            }
+                            for (const img of images) {
+                                const key = mockBlobKeyFromAir(img.air);
+                                if (key !== null)
+                                    trainingUploads.add(blobKeyIdentity(key));
+                            }
+                            dispatchToBlock({
+                                type: 'IMAGE_UPLOAD_RESULT',
+                                payload: { requestId, selected: { images: images.map(({ url, air }) => ({ url, air })) } },
+                            });
+                            return;
+                        }
                         const isGenerationSource = typed.payload?.purpose === 'generationSource';
                         // NON-BLOCKING display path (asyncScan:true): early-resolve with a
                         // PENDING handle, then stream the canned scan verdict on a later tick.
@@ -3856,13 +3930,15 @@ export function createMockHost(options = {}) {
             createPostResult = patch.createPostResult;
         if (patch.createPostError !== undefined)
             createPostError = patch.createPostError;
-        if (patch.trainingDatasetRejected !== undefined) {
-            trainingDatasetRejected = patch.trainingDatasetRejected;
-        }
-        // The training error knobs clear on an explicit `undefined` (key PRESENT in
+        // `null` is meaningful (a cancel) and `undefined` restores the default, so
+        // check for the KEY's presence.
+        if ('cannedTrainingDataUpload' in patch)
+            cannedTrainingDataUpload = patch.cannedTrainingDataUpload;
+        // The training refusal knobs clear on an explicit `undefined` (key PRESENT in
         // the patch), so a harness can turn a refusal off without re-installing.
-        if ('trainingDatasetError' in patch)
-            trainingDatasetError = patch.trainingDatasetError;
+        if ('trainingDataNotUploadedHere' in patch) {
+            trainingDataNotUploadedHere = patch.trainingDataNotUploadedHere === true;
+        }
         if (patch.trainingQuoteTotal !== undefined)
             trainingQuoteTotal = patch.trainingQuoteTotal;
         if ('runTrainingError' in patch)

package/dist/transport/requestTimeouts.d.ts

@@ -28,6 +28,23 @@ export declare const DEFAULT_REQUEST_TIMEOUT_MS = 30000;
  * no deep hook paths, so the rename touches no reachable API.
  */
 export declare const HUMAN_INTERACTION_TIMEOUT_MS: number;
+/**
+ * The bound for `OPEN_IMAGE_UPLOAD { purpose: 'trainingData' }` (civitai/civitai#6461),
+ * which is longer than {@link HUMAN_INTERACTION_TIMEOUT_MS} on purpose.
+ *
+ * The host replies ONCE, when its modal closes — after the viewer picked up to 50
+ * images AND the host uploaded every original. That second half is network work
+ * the viewer does not control, so ten minutes from `open()` can expire while the
+ * host is still uploading. The block would then reject, drop the late reply, and
+ * never learn the keys the host now remembers for `RUN_TRAINING`. The host always
+ * answers on close (images, or a bare cancel), so the bound only has to end a wait
+ * on a host that will never answer; an hour does that without cutting off a slow
+ * upload.
+ *
+ * Still in the `'human'` bucket of {@link REQUEST_TIMEOUT_CLASS}: it is at least
+ * the human bound, which is what that bucket guarantees.
+ */
+export declare const TRAINING_DATA_UPLOAD_TIMEOUT_MS: number;
 /**
  * The bound for a `'protocol'` request whose SERVER WORK is itself slow — the
  * host forwards it to the orchestrator and replies only once that answers. No
@@ -36,14 +53,9 @@ export declare const HUMAN_INTERACTION_TIMEOUT_MS: number;
  *
  * Callers: the workflow trio in `hooks/useBuzzWorkflow.ts` (a submit is a whatif
  * preflight plus the real submit plus a prompt audit), and
- * `PREPARE_TRAINING_DATASET` in `hooks/usePrepareTrainingDataset.ts`, whose
- * server moderates the captions and imports up to 50 images into the
- * orchestrator, the import alone under a 60s budget
- * (`BLOCK_TRAINING_IMPORT_BUDGET_MS` in civitai/civitai's
- * `block-training-dataset.service.ts`) — so the 30s default would reject a
- * healthy prepare mid-import.
+ * `ESTIMATE_WORKFLOW_BATCH` in `hooks/useBatchEstimate.ts`.
  *
- * Was a module-local constant in `useBuzzWorkflow.ts`; moved here so the second
+ * Was a module-local constant in `useBuzzWorkflow.ts`; moved here so every
  * caller shares the number instead of re-typing it.
  */
 export declare const WORKFLOW_REQUEST_TIMEOUT_MS = 120000;