@civitai/blocks-react 0.75.0 → 0.76.0

package/dist/internal/mediaUploadBytes.js

@@ -0,0 +1,268 @@
+/**
+ * `OPEN_MEDIA_UPLOAD`: the strings and limits both sides of the bridge agree
+ * on, the content sniffers, and the mock host's copy of the host's admission
+ * rules for BYTES mode.
+ *
+ * The host owns the real rules. This copy exists so `createMockHost` (and so
+ * `dev:harness` and every block test) accepts and refuses the same buffers
+ * production does, and so `useMediaUpload` can refuse locally what the host
+ * would refuse anyway. Keep it exactly as narrow as the contract: a mock that
+ * accepts a GIF as an image teaches a block that GIFs upload.
+ *
+ * 🔴 The host spells its OWN copy of every constant and string here, and the
+ * two MUST match. Nothing in this repository can read the host's values, so a
+ * drift is invisible here until a block hits a refusal the SDK did not
+ * predict. Kept local to this package (not exported from `@civitai/app-sdk`).
+ *
+ * WHAT THIS CANNOT MODEL: the host decodes the media before it uploads.
+ * Its decode-time refusals (`could not read this video file`,
+ * `could not read this audio file`, `this file has no video track`, an image
+ * too small to resize to at least 64 px, and upload failures) need a real
+ * decoder and network, so the mock never produces them.
+ */
+import { sniffImageBytes } from './saveBytes.js';
+/** The cap on one VIDEO or AUDIO upload: 64 MiB of raw bytes (the consumer-blob upload cap). */
+export const MEDIA_UPLOAD_MAX_BYTES = 64 * 1024 * 1024;
+/**
+ * The cap on one IMAGE upload: 24 MiB. Lower than {@link MEDIA_UPLOAD_MAX_BYTES}
+ * because the host decodes an image in full before it resizes it.
+ */
+export const MEDIA_UPLOAD_IMAGE_MAX_BYTES = 24 * 1024 * 1024;
+/** The bytes-mode rolling window: per this many milliseconds, per mounted page host… */
+export const MEDIA_UPLOAD_WINDOW_MS = 60_000;
+/** …at most this many admitted bytes uploads… */
+export const MEDIA_UPLOAD_MAX_PER_WINDOW = 8;
+/** …and this many admitted bytes. */
+export const MEDIA_UPLOAD_MAX_BYTES_PER_WINDOW = 2 * MEDIA_UPLOAD_MAX_BYTES;
+/** `bytes` is not a non-empty `ArrayBuffer`, or `mimeType` is present but not a string. */
+export const MEDIA_UPLOAD_INVALID_ERROR = 'invalid media-upload request';
+export const MEDIA_UPLOAD_KIND_ERROR = "kind must be 'image', 'video' or 'audio'";
+export const MEDIA_UPLOAD_PURPOSE_ERROR = "purpose must be 'generationSource'";
+/** Over {@link MEDIA_UPLOAD_MAX_BYTES} (video, audio). */
+export const MEDIA_UPLOAD_TOO_LARGE_ERROR = 'file exceeds the 64 MB upload limit';
+/** Over {@link MEDIA_UPLOAD_IMAGE_MAX_BYTES} (image). */
+export const MEDIA_UPLOAD_IMAGE_TOO_LARGE_ERROR = 'file exceeds the 24 MB image upload limit';
+/** Bytes mode only: the host holds no block token. Checked before the cap and the window. */
+export const MEDIA_UPLOAD_NO_TOKEN_ERROR = 'no block token';
+/** The sniffed content is not one of the requested kind's types. */
+export const MEDIA_UPLOAD_TYPE_ERROR = {
+    image: 'images must be PNG, JPEG or WebP',
+    video: 'videos must be MP4 or WebM',
+    audio: 'audio must be MP3, WAV or WebM',
+};
+export const MEDIA_UPLOAD_MIME_MISMATCH_ERROR = "mimeType does not match the file's content";
+/** The bytes-mode window is full. Retryable. */
+export const MEDIA_UPLOAD_BUSY_ERROR = 'busy';
+/** The kinds the bridge knows. */
+export const MEDIA_UPLOAD_KINDS = ['image', 'video', 'audio'];
+export function isMediaKind(v) {
+    return typeof v === 'string' && MEDIA_UPLOAD_KINDS.includes(v);
+}
+/** The per-file cap for a kind, and the refusal past it. */
+export function mediaUploadCap(kind) {
+    return kind === 'image'
+        ? { maxBytes: MEDIA_UPLOAD_IMAGE_MAX_BYTES, error: MEDIA_UPLOAD_IMAGE_TOO_LARGE_ERROR }
+        : { maxBytes: MEDIA_UPLOAD_MAX_BYTES, error: MEDIA_UPLOAD_TOO_LARGE_ERROR };
+}
+function asciiAt(u8, text, offset = 0) {
+    if (u8.length < offset + text.length)
+        return false;
+    for (let i = 0; i < text.length; i++) {
+        if (u8[offset + i] !== text.charCodeAt(i))
+            return false;
+    }
+    return true;
+}
+/** WebM: the EBML magic, and the DocType `webm` within the first 64 bytes (generic Matroska is refused). */
+function isWebm(u8) {
+    if (!(u8[0] === 0x1a && u8[1] === 0x45 && u8[2] === 0xdf && u8[3] === 0xa3))
+        return false;
+    const head = u8.subarray(0, 64);
+    for (let i = 0; i + 4 <= head.length; i++) {
+        if (asciiAt(head, 'webm', i))
+            return true;
+    }
+    return false;
+}
+/** MP4: `ftyp` at offset 4 of a buffer at least 12 bytes long. */
+function isMp4(u8) {
+    return u8.length >= 12 && asciiAt(u8, 'ftyp', 4);
+}
+/** MP3: an ID3 tag, or an MPEG audio frame sync with a valid version and layer. */
+function isMp3(u8) {
+    if (asciiAt(u8, 'ID3'))
+        return true;
+    if (u8.length < 2)
+        return false;
+    const b0 = u8[0];
+    const b1 = u8[1];
+    return b0 === 0xff && (b1 & 0xe0) === 0xe0 && ((b1 >> 1) & 0x03) !== 0 && ((b1 >> 3) & 0x03) !== 1;
+}
+/** WAV: `RIFF` at 0 and `WAVE` at 8. */
+function isWav(u8) {
+    return asciiAt(u8, 'RIFF') && asciiAt(u8, 'WAVE', 8);
+}
+/**
+ * The content type of `bytes` WITHIN the requested kind, by magic bytes, or
+ * `null` when the content is none of that kind's types (a PNG sent as `audio`
+ * is `null`: a type refusal). WebM is `video/webm` under `video` and
+ * `audio/webm` under `audio`.
+ */
+export function sniffMediaBytes(kind, u8) {
+    switch (kind) {
+        case 'image':
+            return sniffImageBytes(u8);
+        case 'video':
+            if (isMp4(u8))
+                return 'video/mp4';
+            if (isWebm(u8))
+                return 'video/webm';
+            return null;
+        case 'audio':
+            if (isMp3(u8))
+                return 'audio/mpeg';
+            if (isWav(u8))
+                return 'audio/wav';
+            if (isWebm(u8))
+                return 'audio/webm';
+            return null;
+    }
+}
+/** A declared MIME type as the host compares it: lowercased, `;params` cut, `audio/x-wav` read as `audio/wav`. */
+export function normaliseMediaMimeType(mimeType) {
+    const base = mimeType.split(';')[0].trim().toLowerCase();
+    return base === 'audio/x-wav' ? 'audio/wav' : base;
+}
+function windowHasRoom(live, size) {
+    const total = live.reduce((sum, e) => sum + e.size, 0);
+    return live.length < MEDIA_UPLOAD_MAX_PER_WINDOW && total + size <= MEDIA_UPLOAD_MAX_BYTES_PER_WINDOW;
+}
+/**
+ * The host's decision for one `OPEN_MEDIA_UPLOAD`, in the host's order, from
+ * step 4 of the contract on (the caller has already dropped an unroutable
+ * `requestId`; review mode and readiness do not exist in the mock):
+ *   1. `kind` not known → kind error; `purpose` not `'generationSource'` →
+ *      purpose error;
+ *   2. no `bytes` (absent or `null`) → PICKER mode (not windowed: a human
+ *      picks);
+ *   3. `bytes` not a non-empty `ArrayBuffer`, or a non-string `mimeType` →
+ *      invalid;
+ *   4. no block token (`opts.noToken`) → `no block token`, before the cap
+ *      and the window;
+ *   5. over the kind's cap ({@link mediaUploadCap}: 24 MiB for an image,
+ *      64 MiB for video and audio) → too large, before the window, so an
+ *      over-cap file is never `busy` (a retry could never succeed);
+ *   6. the window, NOT recording, so a full window refuses `busy` before any
+ *      sniffing;
+ *   7. the sniffed content in the kind's set → else the kind's type error;
+ *   8. a present `mimeType` (normalised) equal to the sniffed type → else
+ *      mismatch;
+ *   9. record the upload in the window. Only an upload that will run counts.
+ * Returns the pruned window to store back.
+ */
+export function admitMediaUpload(raw, recent, now, opts = {}) {
+    const live = recent.filter((e) => now - e.at < MEDIA_UPLOAD_WINDOW_MS);
+    const refuse = (error) => ({ result: { ok: false, error }, recent: live });
+    if (!isMediaKind(raw.kind))
+        return refuse(MEDIA_UPLOAD_KIND_ERROR);
+    const kind = raw.kind;
+    if (raw.purpose !== 'generationSource')
+        return refuse(MEDIA_UPLOAD_PURPOSE_ERROR);
+    // `null` reads as absent, as `OPEN_IMAGE_UPLOAD`'s `bytes` does.
+    if (raw.bytes == null)
+        return { result: { ok: true, mode: 'picker', kind }, recent: live };
+    const bytes = raw.bytes;
+    if (!(bytes instanceof ArrayBuffer) || bytes.byteLength === 0)
+        return refuse(MEDIA_UPLOAD_INVALID_ERROR);
+    if (raw.mimeType !== undefined && typeof raw.mimeType !== 'string') {
+        return refuse(MEDIA_UPLOAD_INVALID_ERROR);
+    }
+    const size = bytes.byteLength;
+    if (opts.noToken)
+        return refuse(MEDIA_UPLOAD_NO_TOKEN_ERROR);
+    const cap = mediaUploadCap(kind);
+    if (size > cap.maxBytes)
+        return refuse(cap.error);
+    if (!windowHasRoom(live, size))
+        return refuse(MEDIA_UPLOAD_BUSY_ERROR);
+    const sniffed = sniffMediaBytes(kind, new Uint8Array(bytes));
+    if (!sniffed)
+        return refuse(MEDIA_UPLOAD_TYPE_ERROR[kind]);
+    if (typeof raw.mimeType === 'string' && normaliseMediaMimeType(raw.mimeType) !== sniffed) {
+        return refuse(MEDIA_UPLOAD_MIME_MISMATCH_ERROR);
+    }
+    return {
+        result: { ok: true, mode: 'bytes', kind, bytes, mimeType: sniffed },
+        recent: [...live, { at: now, size }],
+    };
+}
+/**
+ * What the mock host answers when no canned upload is configured for a kind.
+ * Every field differs between kinds, so a block that mixes two up shows it.
+ * The URLs are deliberately unresolvable: the mock uploads nothing.
+ */
+export const DEFAULT_MOCK_MEDIA_UPLOADS = {
+    image: {
+        url: 'https://media.mock.invalid/generation-input/dev-image.jpeg',
+        kind: 'image',
+        mimeType: 'image/jpeg',
+        sizeBytes: 182_311,
+        width: 1024,
+        height: 768,
+    },
+    video: {
+        url: 'https://media.mock.invalid/generation-input/dev-video.mp4',
+        kind: 'video',
+        mimeType: 'video/mp4',
+        sizeBytes: 4_812_330,
+        width: 1280,
+        height: 720,
+        durationMs: 5_000,
+    },
+    audio: {
+        url: 'https://media.mock.invalid/generation-input/dev-audio.mp3',
+        kind: 'audio',
+        mimeType: 'audio/mpeg',
+        sizeBytes: 961_204,
+        durationMs: 30_000,
+    },
+};
+/**
+ * The mock host's whole answer to one routable `OPEN_MEDIA_UPLOAD`, on a page
+ * surface: {@link admitMediaUpload}, then
+ *  - picker mode: the canned upload for the kind, or a bare reply (dismissed)
+ *    when that kind is canned `null`;
+ *  - bytes mode: the canned upload for the kind (the default when it is
+ *    `null`: there is no viewer to dismiss), carrying what the host would
+ *    report for THESE bytes: the sniffed `mimeType` and the buffer's size for
+ *    video and audio; `image/jpeg` and the canned size for an image, which the
+ *    host re-encodes;
+ *  - `forcedError`, when set, replaces a success: the stand-in for the
+ *    decode and upload failures the mock cannot produce. A bytes upload it
+ *    fails has still been admitted, so it still counts against the window, as
+ *    on the host. ONE value is placed where the host checks it instead:
+ *    `no block token` refuses a bytes upload right after the buffer check,
+ *    before the cap and the window, and is not counted.
+ */
+export function mockMediaUploadReply(args) {
+    const admitted = admitMediaUpload(args.payload, args.recent, args.now, {
+        noToken: args.forcedError === MEDIA_UPLOAD_NO_TOKEN_ERROR,
+    });
+    const { result, recent } = admitted;
+    if (!result.ok)
+        return { reply: { error: result.error }, recent };
+    if (args.forcedError !== undefined)
+        return { reply: { error: args.forcedError }, recent };
+    // A kind left out of `canned` answers the default; one set to `null` dismisses.
+    const configured = args.canned[result.kind];
+    const canned = configured === undefined ? DEFAULT_MOCK_MEDIA_UPLOADS[result.kind] : configured;
+    if (result.mode === 'picker') {
+        return { reply: canned ? { selected: { ...canned, kind: result.kind } } : {}, recent };
+    }
+    const base = canned ?? DEFAULT_MOCK_MEDIA_UPLOADS[result.kind];
+    const selected = result.kind === 'image'
+        ? { ...base, kind: 'image', mimeType: 'image/jpeg' }
+        : { ...base, kind: result.kind, mimeType: result.mimeType, sizeBytes: result.bytes.byteLength };
+    return { reply: { selected }, recent };
+}
+//# sourceMappingURL=mediaUploadBytes.js.map

package/dist/internal/mockHost.d.ts

@@ -38,6 +38,7 @@
  * 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 MockMediaUploads } from './mediaUploadBytes.js';
 import { type MockWorkflowQuoteFailure } from './mockWorkflowGraph.js';
 import { type MockReactionSeed } from './mockHostReactions.js';
 /**
@@ -1220,6 +1221,37 @@ export interface MockHostOptions {
         mimeType: string;
         filename: string;
     }) => void;
+    /**
+     * What `OPEN_MEDIA_UPLOAD` (`useMediaUpload()`) answers, per kind. A kind
+     * left out answers a built-in default for that kind; `null` makes the viewer
+     * close that kind's picker (`open()` resolves `null`). A bytes `upload()`
+     * answers the kind's entry (or the default) with the sniffed `mimeType` and
+     * the buffer's `sizeBytes` for video and audio, and `image/jpeg` for an
+     * image, as the host re-encodes it.
+     *
+     * The host's checks run in the host's order (`./mediaUploadBytes.ts`): kind,
+     * purpose, then for bytes an invalid buffer, the cap (24 MB for an image,
+     * 64 MB for video and audio), the bytes-mode
+     * window (8 uploads or 128 MB per 60 s, per install) → `busy`, the content
+     * sniff per kind, and a declared `mimeType` that disagrees. A model-slot
+     * `context` answers `unsupported on this host`. 🔴 The mock cannot decode
+     * media, so the host's decode-time refusals (an unreadable file, a video with
+     * no video track, an image too small to resize) never happen here: force one
+     * with {@link mediaUploadError}. Live-tunable via {@link MockHost.setScenario}.
+     */
+    cannedMediaUploads?: MockMediaUploads;
+    /**
+     * Force an `OPEN_MEDIA_UPLOAD` that passed the checks above to reply with
+     * this `error`: a host-only refusal such as `this file has no video track`,
+     * `media upload failed — please try again`, or
+     * `this video was refused by the upload service`. A bytes upload it fails
+     * still counts against the window, as on the host. `no block token` is the
+     * exception: like the host, the mock refuses a bytes upload with it right
+     * after the buffer check, before the cap and the window, and does not count
+     * it. Absent → it succeeds.
+     * Live-tunable via {@link MockHost.setScenario}; `undefined` clears it.
+     */
+    mediaUploadError?: string;
     /**
      * Image ids the mock treats as already issued and postable when the host is
      * created, as production treats an image this app stamped for the viewer in
@@ -1398,7 +1430,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'>;
+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'>;
 /** 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

@@ -42,8 +42,10 @@ import { consentUnavailablePayload, isKnownBlockScope, resolveUngrantableConsent
 import { PAGE_CHECKPOINT_PERSIST_ERROR, emulatesPageHost } from './hostSurface.js';
 import { requiredStorageScope, storageResultType, storageScopeDeniedMessage, storageScopeDeniedPayload, } from './mockHostScopes.js';
 import { governsIdempotencyKey, idempotencyKeyDeniedMessage, idempotencyKeyRefusal, } from './mockHostIdempotency.js';
+import { stepInputRefusal } from './mockHostStepInput.js';
 import { SAVE_IMAGE_INVALID_REQUEST_ERROR, prepareSaveBytes, saveImageRequestKind, } from './saveBytes.js';
 import { UPLOAD_BYTES_INVALID_ERROR, admitUploadBytes, resolveUploadBytesRequest, } from './uploadBytes.js';
+import { mockMediaUploadReply, } from './mediaUploadBytes.js';
 import { mockUnpricedWorkflowRefusal, mockUnquotedWorkflowEstimateRefusal, mockWorkflowBodyRefusal, mockWorkflowStepGenerations, mockWorkflowStepName, } from './mockWorkflowGraph.js';
 import { BATCH_ESTIMATE_CELL_TIMEOUT_ERROR } from '../hooks/useBatchEstimate.js';
 import { RUN_CONFIRMED_STEP_ERROR_CODES, STEP_QUOTE_ID_PATTERN, } from '../hooks/useRunConfirmedStep.js';
@@ -1119,6 +1121,11 @@ export function createMockHost(options = {}) {
     let uploadImageBytesResult = options.uploadImageBytesResult ?? DEFAULT_IMAGE_BYTES_UPLOAD;
     let uploadImageBytesError = options.uploadImageBytesError;
     let uploadBytesWindow = [];
+    // OPEN_MEDIA_UPLOAD: canned per-kind answers, a forced refusal, and the
+    // bytes-mode window (per install, like the host's per mount).
+    let cannedMediaUploads = options.cannedMediaUploads ?? {};
+    let mediaUploadError = options.mediaUploadError;
+    let mediaUploadWindow = [];
     // The ids a `CREATE_POST_FROM_APP` `{ kind: 'published' }` source may name:
     // ONLY ids this mock itself issued as postable (an accepted bytes upload, or a
     // PUBLISH_GENERATION_OUTPUTS reply) plus the seeded `postableImageIds` (an
@@ -1646,6 +1653,15 @@ export function createMockHost(options = {}) {
                     // The batch path refuses the WHOLE call before it reaches this function
                     // (see ESTIMATE_WORKFLOW_BATCH), so this branch is the single-estimate
                     // one in practice.
+                    //
+                    // 🔴 THE STEP-INPUT GATE comes first of the server's checks — see
+                    // ./mockHostStepInput.ts. Its rules are zod refinements of the body,
+                    // so they refuse at the procedure's `.input()`, before the handler's
+                    // scope check. The host catches that into `failureSnapshot(err)`.
+                    const inputRefusal = stepInputRefusal(body, opts.issuePathPrefix);
+                    if (inputRefusal !== null) {
+                        return { workflowId: 'failed', status: 'failed', error: inputRefusal };
+                    }
                     if (!consentGranted) {
                         return { workflowId: 'failed', status: 'failed', error: MOCK_SPEND_SCOPE_ERROR };
                     }
@@ -1868,7 +1884,10 @@ export function createMockHost(options = {}) {
                         const body = typed.payload?.body ?? {};
                         dispatchToBlock({
                             type: 'ESTIMATE_RESULT',
-                            payload: { requestId, snapshot: estimateSnapshotFor(body, { storeQuotes: true }) },
+                            payload: {
+                                requestId,
+                                snapshot: estimateSnapshotFor(body, { storeQuotes: true, issuePathPrefix: ['body'] }),
+                            },
                         });
                         return;
                     }
@@ -1941,7 +1960,10 @@ export function createMockHost(options = {}) {
                                     error: MOCK_TRAINING_IN_BATCH_ERROR,
                                 };
                             }
-                            return estimateSnapshotFor(cell ?? {}, { storeQuotes: false });
+                            return estimateSnapshotFor(cell ?? {}, {
+                                storeQuotes: false,
+                                issuePathPrefix: [],
+                            });
                         });
                         // The server's aggregate rule: the cells that priced, i.e. not
                         // `'failed'` and carrying a numeric `cost.total`.
@@ -1994,6 +2016,23 @@ export function createMockHost(options = {}) {
                             });
                             return;
                         }
+                        // 🔴 THE STEP-INPUT GATE (./mockHostStepInput.ts): inline media in a
+                        // pass-through step input, then its byte cap. zod refinements of the
+                        // body, so the server refuses at `.input()` — ahead of the spend-scope
+                        // gate below, which is the handler's first act. Nothing is debited.
+                        {
+                            const inputRefusal = stepInputRefusal(body, ['body']);
+                            if (inputRefusal !== null) {
+                                dispatchToBlock({
+                                    type: 'WORKFLOW_SUBMITTED',
+                                    payload: {
+                                        requestId,
+                                        snapshot: { workflowId: 'failed', status: 'failed', error: inputRefusal },
+                                    },
+                                });
+                                return;
+                            }
+                        }
                         // 🔴 THE SPEND-SCOPE GATE. civitai's `submitWorkflow` throws
                         // `FORBIDDEN` with this message as its first act after
                         // authenticating the token — before the budget, the training
@@ -3026,6 +3065,30 @@ export function createMockHost(options = {}) {
                         });
                         return;
                     }
+                    case 'OPEN_MEDIA_UPLOAD': {
+                        // Generation-input media upload. The rules live in
+                        // ./mediaUploadBytes.ts, in the host's order; there is no picker
+                        // UI, so picker mode answers at once from `cannedMediaUploads`.
+                        if (!isRoutableRequestId(requestId))
+                            return;
+                        if (!emulatesPageHost(options.context)) {
+                            dispatchToBlock({
+                                type: 'MEDIA_UPLOAD_RESULT',
+                                payload: { requestId, error: 'unsupported on this host' },
+                            });
+                            return;
+                        }
+                        const answer = mockMediaUploadReply({
+                            payload: typed.payload ?? {},
+                            canned: cannedMediaUploads,
+                            forcedError: mediaUploadError,
+                            recent: mediaUploadWindow,
+                            now: Date.now(),
+                        });
+                        mediaUploadWindow = answer.recent;
+                        dispatchToBlock({ type: 'MEDIA_UPLOAD_RESULT', payload: { requestId, ...answer.reply } });
+                        return;
+                    }
                     case 'OPEN_IMAGE_UPLOAD': {
                         // Host-chrome image upload: return the canned result keyed by the
                         // requested `purpose` (mirrors the real host's IMAGE_UPLOAD_RESULT).
@@ -3811,6 +3874,10 @@ export function createMockHost(options = {}) {
         }
         if ('uploadImageBytesError' in patch)
             uploadImageBytesError = patch.uploadImageBytesError;
+        if ('cannedMediaUploads' in patch)
+            cannedMediaUploads = patch.cannedMediaUploads ?? {};
+        if ('mediaUploadError' in patch)
+            mediaUploadError = patch.mediaUploadError;
         if ('runTrainingCapRefusal' in patch)
             runTrainingCapRefusal = patch.runTrainingCapRefusal;
         if ('runConfirmedStepError' in patch)

package/dist/internal/mockHostStepInput.d.ts

@@ -0,0 +1,62 @@
+/**
+ * The mock host's STEP-INPUT GATE: the inline-media rule and the byte cap the
+ * real host applies to a pass-through step body, on the estimate, each
+ * batch-estimate cell and the submit.
+ *
+ * WHAT THE REAL HOST SENDS BACK. Both rules are zod refinements of the body
+ * schema (civitai/civitai `src/server/schema/blocks/workflow.schema.ts`), so a
+ * refusal is a tRPC `BAD_REQUEST` thrown at the procedure's `.input()` — before
+ * the handler, and so before the spend-scope check, the budget and any debit.
+ * tRPC uses the `ZodError`'s message as the error message, which is the issue
+ * list as pretty-printed JSON, and the page host catches the rejected mutation
+ * into `failureSnapshot(err)` (`src/components/AppBlocks/failureSnapshot.ts`):
+ *
+ *     { workflowId: 'failed', status: 'failed', error: '[\n  {\n    "code": "custom", … }\n]' }
+ *
+ * with NO `cost`, so `estimate()` rejects with `WorkflowEstimateError` code
+ * `'failed'` and `submit()` with `WorkflowSubmitError` code `'exception'`. A
+ * batch cell is parsed against the same schema inside the procedure and gets
+ * the same snapshot, its issue path relative to the cell rather than `body`.
+ *
+ * MIRRORS the server's `refuseInlineMedia` superRefine and the byte-cap refine
+ * after it, over the same fields (the step `input`; or each workflow step
+ * `input` and then `arguments`, which a step can `$ref`):
+ *  - one value budget SHARED by every field of the body; a spent budget refuses
+ *    the whole body with the arm's own message;
+ *  - the inline-media issue path is the field prefix plus the offending path,
+ *    and the message names the same path WITHOUT the procedure's `body` segment;
+ *  - the search counts the JSON length of the strings it passes, and once that
+ *    is over the byte cap it reads no further string — so a photo AFTER a string
+ *    that already crossed the cap gets the BYTE-CAP refusal, while the string
+ *    that crosses it is still searched (an oversized photo gets the media one);
+ *  - an inline-media or budget issue is added with `continue: false`, so the
+ *    byte cap never also reports — the error is always ONE issue.
+ * The issue shape (`code`, `path`, `message`, in that order, `continue`
+ * stripped) and the byte-cap message were measured against zod 4 with the
+ * server's schema shape.
+ */
+/** The server's byte-cap message for a pass-through step `input` (issue path `input`). */
+export declare const MOCK_STEP_INPUT_BYTES_ERROR = "step input exceeds the 262144-byte limit";
+/** The server's summed byte-cap message for a `kind: 'workflow'` body (issue path `steps`). */
+export declare const MOCK_WORKFLOW_INPUT_BYTES_ERROR = "workflow step inputs and arguments exceed the 262144-byte limit";
+/** The server's value-budget refusal on the `kind: 'step'` arm (issue path `input`). */
+export declare const MOCK_STEP_INPUT_TOO_MANY_VALUES_ERROR = "step input holds more than 262144 values";
+/** The server's value-budget refusal on the `kind: 'workflow'` arm (issue path `steps`). */
+export declare const MOCK_WORKFLOW_INPUT_TOO_MANY_VALUES_ERROR = "step inputs and arguments hold more than 262144 values in total";
+/** `ZodError.message` for a single custom issue — what tRPC hands the host as `err.message`. */
+export declare function zodIssueMessage(path: ReadonlyArray<string | number>, message: string): string;
+/**
+ * The refusal text for `body`'s step input(s), or `null` to proceed.
+ * `issuePathPrefix` is `['body']` for an estimate or submit (the field of the
+ * procedure input) and `[]` for a batch cell (parsed on its own).
+ *
+ *  - A pass-through `kind: 'step'` body (no `step` id): its `input`.
+ *  - A `kind: 'workflow'` body: each step's `input`, then `arguments`; its byte
+ *    cap is their SUM.
+ *
+ * Any other body, a step whose `input` is not an object, or a workflow whose
+ * wire shape is wrong, is left to the checks that already handle it — zod
+ * refuses the shape before these refinements run.
+ */
+export declare function stepInputRefusal(body: unknown, issuePathPrefix: ReadonlyArray<string | number>): string | null;
+//# sourceMappingURL=mockHostStepInput.d.ts.map

package/dist/internal/mockHostStepInput.js

@@ -0,0 +1,120 @@
+/**
+ * The mock host's STEP-INPUT GATE: the inline-media rule and the byte cap the
+ * real host applies to a pass-through step body, on the estimate, each
+ * batch-estimate cell and the submit.
+ *
+ * WHAT THE REAL HOST SENDS BACK. Both rules are zod refinements of the body
+ * schema (civitai/civitai `src/server/schema/blocks/workflow.schema.ts`), so a
+ * refusal is a tRPC `BAD_REQUEST` thrown at the procedure's `.input()` — before
+ * the handler, and so before the spend-scope check, the budget and any debit.
+ * tRPC uses the `ZodError`'s message as the error message, which is the issue
+ * list as pretty-printed JSON, and the page host catches the rejected mutation
+ * into `failureSnapshot(err)` (`src/components/AppBlocks/failureSnapshot.ts`):
+ *
+ *     { workflowId: 'failed', status: 'failed', error: '[\n  {\n    "code": "custom", … }\n]' }
+ *
+ * with NO `cost`, so `estimate()` rejects with `WorkflowEstimateError` code
+ * `'failed'` and `submit()` with `WorkflowSubmitError` code `'exception'`. A
+ * batch cell is parsed against the same schema inside the procedure and gets
+ * the same snapshot, its issue path relative to the cell rather than `body`.
+ *
+ * MIRRORS the server's `refuseInlineMedia` superRefine and the byte-cap refine
+ * after it, over the same fields (the step `input`; or each workflow step
+ * `input` and then `arguments`, which a step can `$ref`):
+ *  - one value budget SHARED by every field of the body; a spent budget refuses
+ *    the whole body with the arm's own message;
+ *  - the inline-media issue path is the field prefix plus the offending path,
+ *    and the message names the same path WITHOUT the procedure's `body` segment;
+ *  - the search counts the JSON length of the strings it passes, and once that
+ *    is over the byte cap it reads no further string — so a photo AFTER a string
+ *    that already crossed the cap gets the BYTE-CAP refusal, while the string
+ *    that crosses it is still searched (an oversized photo gets the media one);
+ *  - an inline-media or budget issue is added with `continue: false`, so the
+ *    byte cap never also reports — the error is always ONE issue.
+ * The issue shape (`code`, `path`, `message`, in that order, `continue`
+ * stripped) and the byte-cap message were measured against zod 4 with the
+ * server's schema shape.
+ */
+import { isWellFormedWorkflowShape } from './mockWorkflowGraph.js';
+import { INLINE_MEDIA_MAX_VISITS, INLINE_MEDIA_OVER_BYTE_LIMIT, INLINE_MEDIA_TOO_MANY_VALUES, PASS_THROUGH_INPUT_BYTES_MAX, findInlineMediaPath, inlineMediaMessage, } from './stepInputLimits.js';
+/** The server's byte-cap message for a pass-through step `input` (issue path `input`). */
+export const MOCK_STEP_INPUT_BYTES_ERROR = `step input exceeds the ${PASS_THROUGH_INPUT_BYTES_MAX}-byte limit`;
+/** The server's summed byte-cap message for a `kind: 'workflow'` body (issue path `steps`). */
+export const MOCK_WORKFLOW_INPUT_BYTES_ERROR = `workflow step inputs and arguments exceed the ${PASS_THROUGH_INPUT_BYTES_MAX}-byte limit`;
+/** The server's value-budget refusal on the `kind: 'step'` arm (issue path `input`). */
+export const MOCK_STEP_INPUT_TOO_MANY_VALUES_ERROR = `step input holds more than ${INLINE_MEDIA_MAX_VISITS} values`;
+/** The server's value-budget refusal on the `kind: 'workflow'` arm (issue path `steps`). */
+export const MOCK_WORKFLOW_INPUT_TOO_MANY_VALUES_ERROR = `step inputs and arguments hold more than ${INLINE_MEDIA_MAX_VISITS} values in total`;
+/** `ZodError.message` for a single custom issue — what tRPC hands the host as `err.message`. */
+export function zodIssueMessage(path, message) {
+    return JSON.stringify([{ code: 'custom', path, message }], null, 2);
+}
+const isPlainObject = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+/** The server's `refuseInlineMedia`: the first hit across `fields`, sharing one budget. */
+function inlineMediaIssue(fields, overflow) {
+    const budget = { visits: 0 };
+    for (const [prefix, value] of fields) {
+        const hit = findInlineMediaPath(value, budget, PASS_THROUGH_INPUT_BYTES_MAX);
+        if (!hit || hit === INLINE_MEDIA_OVER_BYTE_LIMIT)
+            continue;
+        if (hit === INLINE_MEDIA_TOO_MANY_VALUES)
+            return overflow;
+        const path = [...prefix, ...hit];
+        return { path, message: inlineMediaMessage(path) };
+    }
+    return null;
+}
+/**
+ * The summed `JSON.stringify(value).length` of `fields` (a value it writes
+ * nothing for, like an absent `arguments`, counts 0) — the verdict the server's
+ * `jsonLengthWithin` gives. `null` when JSON cannot serialize one (a `BigInt`,
+ * a cycle): a structured-clone payload can carry either, and such an input is
+ * left to the checks that already model it, not reported as a size.
+ */
+function serializedLength(fields) {
+    try {
+        return fields.reduce((sum, [, value]) => sum + (JSON.stringify(value)?.length ?? 0), 0);
+    }
+    catch {
+        return null;
+    }
+}
+/** Inline media / value budget first; the byte cap only when that found nothing. */
+function fieldsIssue(fields, overflow, overCap) {
+    const media = inlineMediaIssue(fields, overflow);
+    if (media !== null)
+        return media;
+    const size = serializedLength(fields);
+    return size !== null && size > PASS_THROUGH_INPUT_BYTES_MAX ? overCap : null;
+}
+/**
+ * The refusal text for `body`'s step input(s), or `null` to proceed.
+ * `issuePathPrefix` is `['body']` for an estimate or submit (the field of the
+ * procedure input) and `[]` for a batch cell (parsed on its own).
+ *
+ *  - A pass-through `kind: 'step'` body (no `step` id): its `input`.
+ *  - A `kind: 'workflow'` body: each step's `input`, then `arguments`; its byte
+ *    cap is their SUM.
+ *
+ * Any other body, a step whose `input` is not an object, or a workflow whose
+ * wire shape is wrong, is left to the checks that already handle it — zod
+ * refuses the shape before these refinements run.
+ */
+export function stepInputRefusal(body, issuePathPrefix) {
+    if (!isPlainObject(body))
+        return null;
+    let issue = null;
+    if (body.kind === 'step' && body.step === undefined) {
+        if (!isPlainObject(body.input))
+            return null;
+        issue = fieldsIssue([[['input'], body.input]], { path: ['input'], message: MOCK_STEP_INPUT_TOO_MANY_VALUES_ERROR }, { path: ['input'], message: MOCK_STEP_INPUT_BYTES_ERROR });
+    }
+    else if (body.kind === 'workflow' && isWellFormedWorkflowShape(body)) {
+        issue = fieldsIssue([
+            ...body.steps.map((step, i) => [['steps', i, 'input'], step.input]),
+            [['arguments'], body.arguments],
+        ], { path: ['steps'], message: MOCK_WORKFLOW_INPUT_TOO_MANY_VALUES_ERROR }, { path: ['steps'], message: MOCK_WORKFLOW_INPUT_BYTES_ERROR });
+    }
+    return issue === null ? null : zodIssueMessage([...issuePathPrefix, ...issue.path], issue.message);
+}
+//# sourceMappingURL=mockHostStepInput.js.map