@civitai/blocks-react 0.76.1 → 0.78.0

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.
+ */
+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 isValidTrainingDatasetItems(items) {
+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,
@@ -699,6 +752,38 @@ const DEFAULT_WILDCARD_PACK = {
     truncatedLists: [],
     maturity: { browsingLevel: SFW_LEVELS, sfwOnly: true },
 };
+/**
+ * Default file reported on `GET_RESOURCE_FILE`: one plain `.json` workflow in the
+ * ComfyUI UI format (a `nodes` array), so a block renders a graph out of the box.
+ */
+const DEFAULT_RESOURCE_FILE = {
+    meta: {
+        modelId: 618700,
+        modelVersionId: 691700,
+        fileId: 591700,
+        fileName: 'sample-workflow.json',
+        modelName: 'Sample Workflow',
+        versionName: 'v1.0',
+        creatorUsername: 'creator',
+    },
+    entries: [
+        {
+            path: 'sample-workflow.json',
+            format: 'ui',
+            graph: {
+                last_node_id: 2,
+                last_link_id: 1,
+                nodes: [
+                    { id: 1, type: 'CheckpointLoaderSimple', inputs: [], outputs: [{ name: 'MODEL', links: [1] }] },
+                    { id: 2, type: 'KSampler', inputs: [{ name: 'model', link: 1 }], outputs: [] },
+                ],
+                links: [[1, 1, 0, 2, 0, 'MODEL']],
+                version: 0.4,
+            },
+        },
+    ],
+    truncated: false,
+};
 /**
  * Default app generator SUBQUEUE page reported on `QUERY_APP_WORKFLOWS`. A small
  * mixed-status list (a done gen with two images, one still processing) so a block
@@ -1083,6 +1168,9 @@ export function createMockHost(options = {}) {
     // Wildcard-pack bridge data + forced discriminated-error knob.
     let wildcardPack = options.wildcardPack ?? DEFAULT_WILDCARD_PACK;
     let wildcardPackError = options.wildcardPackError;
+    // Resource-file bridge data + forced closed-set error knob.
+    let resourceFile = options.resourceFile ?? DEFAULT_RESOURCE_FILE;
+    let resourceFileError = options.resourceFileError;
     // Collection-follow bridge.
     //
     // 🔴 THERE IS DELIBERATELY NO FOLLOW-STATE MAP HERE, and an earlier version's
@@ -1108,10 +1196,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 +1457,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 +1775,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 +1787,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 +1798,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,
@@ -2540,6 +2651,25 @@ export function createMockHost(options = {}) {
                         });
                         return;
                     }
+                    case 'GET_RESOURCE_FILE': {
+                        // Token-INDEPENDENT read, like GET_WILDCARD_PACK. A forced error
+                        // replies with the closed-set code (never free text), as the real
+                        // host does. The canned file is returned for any version / file id.
+                        if (!isRoutableRequestId(requestId))
+                            return;
+                        if (resourceFileError !== undefined) {
+                            dispatchToBlock({
+                                type: 'RESOURCE_FILE_RESULT',
+                                payload: { requestId, error: resourceFileError },
+                            });
+                            return;
+                        }
+                        dispatchToBlock({
+                            type: 'RESOURCE_FILE_RESULT',
+                            payload: { requestId, file: resourceFile },
+                        });
+                        return;
+                    }
                     case 'QUERY_APP_WORKFLOWS': {
                         // App generator SUBQUEUE read. Drop a request with no requestId
                         // (unroutable). A forced error replies with the FREE-TEXT error
@@ -2712,46 +2842,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 +2865,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 +2885,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 +3218,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.
@@ -3847,6 +3975,11 @@ export function createMockHost(options = {}) {
             wildcardPack = patch.wildcardPack;
         if (patch.wildcardPackError !== undefined)
             wildcardPackError = patch.wildcardPackError;
+        if (patch.resourceFile !== undefined)
+            resourceFile = patch.resourceFile;
+        // Key PRESENCE, not value: `{ resourceFileError: undefined }` clears it.
+        if ('resourceFileError' in patch)
+            resourceFileError = patch.resourceFileError;
         if (patch.collectionFollowError !== undefined)
             collectionFollowError = patch.collectionFollowError;
         if (patch.reactionStates !== undefined || patch.reactionError !== undefined) {
@@ -3856,13 +3989,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,17 +53,25 @@ 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;
+/**
+ * The bound for `GET_RESOURCE_FILE` (`hooks/useResourceFile.ts`), a `'protocol'`
+ * request whose HOST work is slow: a session-authed resolve, a fetch of the
+ * signed URL (up to 32 MB), then an unzip and parse of up to 16 MB in the
+ * viewer's tab. The host bounds all three with ONE 110 s deadline
+ * (civitai/civitai#6818 `RESOURCE_FILE_DEADLINE_MS`), after which it replies
+ * `parse-failed`. At {@link DEFAULT_REQUEST_TIMEOUT_MS} a large file on a slow
+ * connection would time out on the block while the host was still working, and
+ * the host's valid reply would be dropped as unroutable. 120 s leaves the host's
+ * 110 s deadline room to answer first. Same number as
+ * {@link WORKFLOW_REQUEST_TIMEOUT_MS}.
+ */
+export declare const RESOURCE_FILE_REQUEST_TIMEOUT_MS = 120000;
 /** Which bound a block→parent message is answered under. */
 export type RequestTimeoutClass = 
 /** Reply waits on a PERSON — must pass {@link HUMAN_INTERACTION_TIMEOUT_MS}. */

package/dist/transport/requestTimeouts.js

@@ -27,6 +27,23 @@ export const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
  * no deep hook paths, so the rename touches no reachable API.
  */
 export const HUMAN_INTERACTION_TIMEOUT_MS = 10 * 60_000;
+/**
+ * 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 const TRAINING_DATA_UPLOAD_TIMEOUT_MS = 60 * 60_000;
 /**
  * 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
@@ -35,17 +52,25 @@ export const HUMAN_INTERACTION_TIMEOUT_MS = 10 * 60_000;
  *
  * 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 const WORKFLOW_REQUEST_TIMEOUT_MS = 120_000;
+/**
+ * The bound for `GET_RESOURCE_FILE` (`hooks/useResourceFile.ts`), a `'protocol'`
+ * request whose HOST work is slow: a session-authed resolve, a fetch of the
+ * signed URL (up to 32 MB), then an unzip and parse of up to 16 MB in the
+ * viewer's tab. The host bounds all three with ONE 110 s deadline
+ * (civitai/civitai#6818 `RESOURCE_FILE_DEADLINE_MS`), after which it replies
+ * `parse-failed`. At {@link DEFAULT_REQUEST_TIMEOUT_MS} a large file on a slow
+ * connection would time out on the block while the host was still working, and
+ * the host's valid reply would be dropped as unroutable. 120 s leaves the host's
+ * 110 s deadline room to answer first. Same number as
+ * {@link WORKFLOW_REQUEST_TIMEOUT_MS}.
+ */
+export const RESOURCE_FILE_REQUEST_TIMEOUT_MS = 120_000;
 /**
  * 🔴 THE TOTALITY GATE — every block→parent message type, bucketed.
  *
@@ -130,11 +155,6 @@ const REQUEST_TIMEOUT_CLASS = {
     APP_STORAGE_SET: 'protocol',
     CANCEL_APP_WORKFLOW: 'protocol',
     CANCEL_WORKFLOW: 'protocol',
-    // No dialog — preparing a dataset charges nothing and the host replies when
-    // the server does. Server-bound, so `'protocol'`; but sent under
-    // `WORKFLOW_REQUEST_TIMEOUT_MS`, not the 30s default, because the server's
-    // image import alone may take 60s. Same reasoning as the workflow trio below.
-    PREPARE_TRAINING_DATASET: 'protocol',
     // The workflow trio is server-bound, not person-bound. It carries its OWN
     // longer bound (`WORKFLOW_REQUEST_TIMEOUT_MS` in `hooks/useBuzzWorkflow.ts`)
     // for orchestrator latency — a different reason for a different number.
@@ -151,6 +171,10 @@ const REQUEST_TIMEOUT_CLASS = {
     GET_IMAGES_BY_IDS: 'protocol',
     GET_VIEWER: 'protocol',
     GET_WILDCARD_PACK: 'protocol',
+    // No person in the loop, so `'protocol'` — but sent under its own longer
+    // `RESOURCE_FILE_REQUEST_TIMEOUT_MS`: the host's resolve + fetch + unzip run
+    // under a 110 s deadline, which the 30 s default would cut short.
+    GET_RESOURCE_FILE: 'protocol',
     QUERY_APP_WORKFLOWS: 'protocol',
     REQUEST_TOKEN: 'protocol',
     // The host fetches the blob and triggers the browser's own download; it replies

package/dist/transport/validate.d.ts

@@ -245,7 +245,8 @@ export declare function isValidViewerResult(p: unknown): p is {
  *     value, `url` non-empty).
  *   • `'generationSource'` → the source `{ url, width, height }` (positive finite
  *     dimensions, non-empty url; no imageId/nsfwLevel).
- * The guard accepts EITHER shape (the result carries no purpose discriminator).
+ *   • `'trainingData'` → `{ images: [{ url, air }] }` (non-empty strings).
+ * The guard accepts ANY of the shapes (the result carries no purpose discriminator).
  * Kept in lockstep with the host's `IMAGE_UPLOAD_RESULT` (civitai/civitai
  * `PageBlockHost.tsx` / `BlockImageUploadModal.tsx` /
  * `BlockGenerationSourceUploadModal.tsx`).
@@ -265,6 +266,11 @@ export declare function isValidImageUploadResult(p: unknown): p is {
         status: 'pending';
         imageId: number;
         url: string;
+    } | {
+        images: Array<{
+            url: string;
+            air: string;
+        }>;
     };
     error?: string;
 };
@@ -341,6 +347,17 @@ export declare function isValidDailyCompensationResult(p: unknown): boolean;
  * reply, mirroring the host's enum contract.
  */
 export declare function isValidWildcardPackResult(p: unknown): boolean;
+/**
+ * Reply to a block-initiated `GET_RESOURCE_FILE`. Same contract shape as
+ * {@link isValidWildcardPackResult}: EITHER a `file` OR an `error` that is one of
+ * {@link RESOURCE_FILE_ERROR_CODES}; a free-text or unknown `error`, or a reply
+ * with neither, is malformed and dropped. The `file` is checked field by field —
+ * `meta` ids positive integers, names strings, `creatorUsername` a string or
+ * `null`, `truncated` a boolean, and EVERY entry an object with a string `path`,
+ * a known `format` and a `graph` key. `graph` itself is the host's parsed JSON
+ * and may be any JSON value.
+ */
+export declare function isValidResourceFileResult(p: unknown): boolean;
 /**
  * Reply to a block-initiated `QUERY_APP_WORKFLOWS`. A well-formed reply carries
  * EITHER a `result` ({ workflows: AppWorkflow[], cursor: string | null }) OR a
@@ -442,22 +459,6 @@ export declare function isValidEntityReactionsResult(p: unknown): boolean;
  * so a drop at least times out visibly.
  */
 export declare function isValidCreatePostResult(p: unknown): boolean;
-/**
- * Reply to `PREPARE_TRAINING_DATASET`. A well-formed reply carries EITHER a
- * `result` (`{ datasetId: non-empty string, count: integer ≥ 0, rejected: [{
- * imageId: number, reason: string }] }`) OR an `error`; one with neither is
- * malformed and dropped.
- *
- * 🔴 `error` IS SHAPE-CHECKED ONLY — the same decision as
- * {@link isValidCreatePostResult}: the host's closed codes share the field with
- * any server message it forwards, and a membership check would drop those
- * replies before correlation, leaving the request to its timer.
- *
- * `rejected[].reason` is checked as a STRING, not against today's six members —
- * the host adding a reason must not make every prepare reply that carries it a
- * dropped one (the forward-compatibility rule in {@link isValidWorkflowSnapshot}).
- */
-export declare function isValidTrainingDatasetResult(p: unknown): boolean;
 /**
  * Reply to `RUN_TRAINING`. A well-formed reply carries EITHER a `snapshot` (a
  * valid {@link isValidWorkflowSnapshot} — the block polls its `workflowId`) OR an