@civitai/blocks-react 0.74.1 → 0.76.0

package/dist/internal/mockHost.js

@@ -42,12 +42,15 @@ 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';
 import { RUN_TRAINING_ERROR_CODES } from '../hooks/useRunTraining.js';
+import { createMockReactions, REACTION_SCOPE, } from './mockHostReactions.js';
 import { hostContextWithTheme } from '../transport/transport.js';
 import { isRoutableRequestId } from '../transport/requestId.js';
 /**
@@ -1092,6 +1095,16 @@ export function createMockHost(options = {}) {
     // survived review. There is no READ op on this bridge for such a map to feed,
     // so the honest shape is not to offer one.
     let collectionFollowError = options.collectionFollowError;
+    // App reactions: per-image state + a forced-error knob, owned by
+    // `./mockHostReactions.ts`. The scope test is PRESENCE in the manifest's
+    // declared scopes, the same set the storage gate reads.
+    const reactionScopeDeclared = (options.declaredScopes ?? []).includes(REACTION_SCOPE);
+    const reactions = createMockReactions({
+        seed: options.reactionStates,
+        error: options.reactionError ?? undefined,
+        signedIn: () => viewer !== null,
+        hasScope: () => reactionScopeDeclared,
+    });
     // App Blocks → Post bridge: the canned post + a forced-refusal knob.
     let createPostResult = options.createPostResult ?? DEFAULT_CREATE_POST_RESULT;
     let createPostError = options.createPostError;
@@ -1108,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
@@ -1635,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 };
                     }
@@ -1857,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;
                     }
@@ -1930,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`.
@@ -1983,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
@@ -2582,6 +2632,27 @@ export function createMockHost(options = {}) {
                         });
                         return;
                     }
+                    case 'SET_ENTITY_REACTION': {
+                        // App reactions. Every path with a routable requestId replies exactly
+                        // once; the decision order is the real host's (see
+                        // `./mockHostReactions.ts`).
+                        if (!isRoutableRequestId(requestId))
+                            return;
+                        dispatchToBlock({
+                            type: 'ENTITY_REACTION_RESULT',
+                            payload: { requestId, ...reactions.set(typed.payload) },
+                        });
+                        return;
+                    }
+                    case 'GET_ENTITY_REACTIONS': {
+                        if (!isRoutableRequestId(requestId))
+                            return;
+                        dispatchToBlock({
+                            type: 'ENTITY_REACTIONS_RESULT',
+                            payload: { requestId, ...reactions.get(typed.payload) },
+                        });
+                        return;
+                    }
                     case 'CREATE_POST_FROM_APP': {
                         // Publish a REAL Post on the viewer's profile from the app's own
                         // outputs. Drop a request with no requestId (unroutable) — same as
@@ -2994,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).
@@ -3754,6 +3849,9 @@ export function createMockHost(options = {}) {
             wildcardPackError = patch.wildcardPackError;
         if (patch.collectionFollowError !== undefined)
             collectionFollowError = patch.collectionFollowError;
+        if (patch.reactionStates !== undefined || patch.reactionError !== undefined) {
+            reactions.configure({ seed: patch.reactionStates, error: patch.reactionError });
+        }
         if (patch.createPostResult !== undefined)
             createPostResult = patch.createPostResult;
         if (patch.createPostError !== undefined)
@@ -3776,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/mockHostReactions.d.ts

@@ -0,0 +1,62 @@
+/**
+ * mockHostReactions.ts — the dev host's half of `SET_ENTITY_REACTION` /
+ * `GET_ENTITY_REACTIONS` (app reactions, civitai/civitai#6144).
+ *
+ * It mirrors the REAL host's decision order, from civitai's `reactionGate.ts`
+ * and `blocks.setReactionFromApp` / `blocks.getReactionsForApp`:
+ *
+ *   1. no usable `requestId` → dropped (nothing to reply to);
+ *   1b. a forced `review-mode` / `not-ready` (`reactionError`) → that code,
+ *      since the host's preflight checks both before anything else;
+ *   2. no viewer → `sign-in-required` (identity before payload);
+ *   3. malformed payload, or a reaction apps may not set (`Dislike`) →
+ *      `invalid-request`;
+ *   4. `social:react:self` not among the manifest's declared scopes →
+ *      `needs-consent`;
+ *   5. the forced-error knob, when set;
+ *   6. a write without a ticket → `entity-unavailable`; a read answers only
+ *      ticketed ids and lists the rest in `unavailable`.
+ *
+ * 🔴 WHAT THIS CANNOT CHECK: whether a ticket is GENUINE. A real ticket is an
+ * HMAC the server signs with a secret no block holds, so this mock accepts any
+ * well-formed one (1 to 256 characters). A block that invents tickets passes
+ * here and fails in production with `entity-unavailable`; the tickets a block
+ * passes should be the `reactTicket` fields its images arrived with.
+ *
+ * The mock never produces `review-mode` or `not-ready` on its own; force them
+ * with `reactionError`, and they are answered at step 1b, as the host would.
+ */
+import type { BlockEntityReactionResult, BlockEntityReactionsResult, BlockReactionCounts, BlockStoredReaction } from '@civitai/app-sdk/blocks';
+/** The scope both messages need. */
+export declare const REACTION_SCOPE = "social:react:self";
+/** A seeded image for the mock. Every field is optional; absent counts are 0. */
+export interface MockReactionSeed {
+    counts?: Partial<BlockReactionCounts>;
+    viewerReactions?: BlockStoredReaction[];
+    /** Report this image's counts as unknown, as the real metric store sometimes does. */
+    statsUnknown?: boolean;
+}
+/** The reply payload, minus `requestId`. */
+export type MockReactionReply<T> = {
+    result: T;
+} | {
+    error: string;
+};
+export interface MockReactions {
+    set(payload: unknown): MockReactionReply<BlockEntityReactionResult>;
+    get(payload: unknown): MockReactionReply<BlockEntityReactionsResult>;
+    /** Replace the seed and the forced error, as `setScenario` does. */
+    configure(patch: {
+        seed?: Record<number, MockReactionSeed>;
+        error?: string | null;
+    }): void;
+}
+export declare function createMockReactions(opts: {
+    seed?: Record<number, MockReactionSeed>;
+    error?: string;
+    /** Is a viewer signed in? Read on every call. */
+    signedIn: () => boolean;
+    /** Does the manifest declare the scope? Read on every call. */
+    hasScope: () => boolean;
+}): MockReactions;
+//# sourceMappingURL=mockHostReactions.d.ts.map

package/dist/internal/mockHostReactions.js

@@ -0,0 +1,166 @@
+/**
+ * mockHostReactions.ts — the dev host's half of `SET_ENTITY_REACTION` /
+ * `GET_ENTITY_REACTIONS` (app reactions, civitai/civitai#6144).
+ *
+ * It mirrors the REAL host's decision order, from civitai's `reactionGate.ts`
+ * and `blocks.setReactionFromApp` / `blocks.getReactionsForApp`:
+ *
+ *   1. no usable `requestId` → dropped (nothing to reply to);
+ *   1b. a forced `review-mode` / `not-ready` (`reactionError`) → that code,
+ *      since the host's preflight checks both before anything else;
+ *   2. no viewer → `sign-in-required` (identity before payload);
+ *   3. malformed payload, or a reaction apps may not set (`Dislike`) →
+ *      `invalid-request`;
+ *   4. `social:react:self` not among the manifest's declared scopes →
+ *      `needs-consent`;
+ *   5. the forced-error knob, when set;
+ *   6. a write without a ticket → `entity-unavailable`; a read answers only
+ *      ticketed ids and lists the rest in `unavailable`.
+ *
+ * 🔴 WHAT THIS CANNOT CHECK: whether a ticket is GENUINE. A real ticket is an
+ * HMAC the server signs with a secret no block holds, so this mock accepts any
+ * well-formed one (1 to 256 characters). A block that invents tickets passes
+ * here and fails in production with `entity-unavailable`; the tickets a block
+ * passes should be the `reactTicket` fields its images arrived with.
+ *
+ * The mock never produces `review-mode` or `not-ready` on its own; force them
+ * with `reactionError`, and they are answered at step 1b, as the host would.
+ */
+import { REACTIONS } from '../hooks/useReactions.js';
+/** The scope both messages need. */
+export const REACTION_SCOPE = 'social:react:self';
+const MAX_IDS = 100;
+const MAX_TICKET = 256;
+const isPositiveInt = (v) => typeof v === 'number' && Number.isInteger(v) && v > 0;
+const isTicket = (v) => typeof v === 'string' && v.length > 0 && v.length <= MAX_TICKET;
+const isAppReaction = (v) => typeof v === 'string' && REACTIONS.includes(v);
+function zeroCounts() {
+    return { Like: 0, Heart: 0, Laugh: 0, Cry: 0 };
+}
+export function createMockReactions(opts) {
+    const states = new Map();
+    let forcedError = opts.error;
+    const seedWith = (seed) => {
+        states.clear();
+        for (const [key, value] of Object.entries(seed ?? {})) {
+            states.set(Number(key), {
+                counts: { ...zeroCounts(), ...(value.counts ?? {}) },
+                viewerReactions: [...(value.viewerReactions ?? [])],
+                statsUnknown: value.statsUnknown === true,
+            });
+        }
+    };
+    seedWith(opts.seed);
+    const stateOf = (id) => states.get(id) ?? { counts: zeroCounts(), viewerReactions: [], statsUnknown: false };
+    /** Steps 2 to 5; `null` when the request may proceed. */
+    const refuse = (validPayload) => {
+        // The host's own preflight refusals come before everything else
+        // (`reactionGate.ts`: review mode, then the handshake, then the viewer), so
+        // a forced one is answered first. Every other forced code stands for a
+        // SERVER answer, which only a request past the host's gate can get.
+        if (forcedError === 'review-mode' || forcedError === 'not-ready')
+            return forcedError;
+        if (!opts.signedIn())
+            return 'sign-in-required';
+        if (!validPayload)
+            return 'invalid-request';
+        if (!opts.hasScope())
+            return 'needs-consent';
+        if (forcedError !== undefined)
+            return forcedError;
+        return null;
+    };
+    return {
+        set(payload) {
+            const p = (payload ?? {});
+            const valid = p.entityType === 'image' &&
+                isPositiveInt(p.entityId) &&
+                isAppReaction(p.reaction) &&
+                typeof p.reacted === 'boolean' &&
+                (p.ticket === undefined || isTicket(p.ticket));
+            const refusal = refuse(valid);
+            if (refusal !== null)
+                return { error: refusal };
+            if (!isTicket(p.ticket))
+                return { error: 'entity-unavailable' };
+            const id = p.entityId;
+            const reaction = p.reaction;
+            const reacted = p.reacted;
+            const before = stateOf(id);
+            const holds = before.viewerReactions.includes(reaction);
+            const changed = holds !== reacted;
+            const after = changed
+                ? {
+                    counts: {
+                        ...before.counts,
+                        [reaction]: Math.max(0, before.counts[reaction] + (reacted ? 1 : -1)),
+                    },
+                    viewerReactions: reacted
+                        ? [...before.viewerReactions, reaction]
+                        : before.viewerReactions.filter((r) => r !== reaction),
+                    statsUnknown: before.statsUnknown,
+                }
+                : before;
+            states.set(id, after);
+            return {
+                result: {
+                    entityType: 'image',
+                    entityId: id,
+                    reaction,
+                    reacted,
+                    changed,
+                    counts: { ...after.counts },
+                    viewerReactions: [...after.viewerReactions],
+                    statsUnknown: after.statsUnknown,
+                },
+            };
+        },
+        get(payload) {
+            const p = (payload ?? {});
+            const ids = p.ids;
+            const ticketsOk = p.tickets === undefined ||
+                (typeof p.tickets === 'object' && p.tickets !== null && !Array.isArray(p.tickets));
+            const valid = p.entityType === 'image' &&
+                Array.isArray(ids) &&
+                ids.length > 0 &&
+                ids.length <= MAX_IDS &&
+                ids.every(isPositiveInt) &&
+                ticketsOk;
+            if (valid && p.tickets !== undefined) {
+                // The real gate refuses a malformed ticket for a REQUESTED id, and
+                // ignores the tickets for ids it was not asked about.
+                const wanted = new Set(ids.map(String));
+                for (const [key, value] of Object.entries(p.tickets)) {
+                    if (wanted.has(key) && !isTicket(value))
+                        return { error: refuse(false) ?? 'invalid-request' };
+                }
+            }
+            const refusal = refuse(valid);
+            if (refusal !== null)
+                return { error: refusal };
+            const tickets = (p.tickets ?? {});
+            const byId = {};
+            const unavailable = [];
+            for (const id of new Set(ids)) {
+                if (!isTicket(tickets[String(id)])) {
+                    unavailable.push(id);
+                    continue;
+                }
+                const s = stateOf(id);
+                byId[String(id)] = {
+                    counts: { ...s.counts },
+                    viewerReactions: [...s.viewerReactions],
+                    statsUnknown: s.statsUnknown,
+                };
+            }
+            return { result: { entityType: 'image', byId, unavailable } };
+        },
+        configure(patch) {
+            if (patch.seed !== undefined)
+                seedWith(patch.seed);
+            if (patch.error !== undefined)
+                forcedError = patch.error ?? undefined;
+        },
+    };
+}
+//# sourceMappingURL=mockHostReactions.js.map

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

package/dist/internal/mockWorkflowGraph.d.ts

@@ -27,7 +27,10 @@ export declare const MOCK_WORKFLOW_BOUNDS: {
     readonly maxInputDepth: 32;
     /** How deep a `repeat` template may nest another `repeat`. */
     readonly maxRepeatNesting: 4;
-    /** Serialized bytes of every step `input` plus `arguments`, summed. */
+    /**
+     * Serialized bytes of every step `input` plus `arguments`, summed. The host's
+     * `WORKFLOW_INPUT_BYTES_MAX`, which is its pass-through cap by definition.
+     */
     readonly maxInputBytes: 262144;
     /** Characters of a step `$type`, and of a step `name` on the wire. */
     readonly maxTypeChars: 64;
@@ -95,6 +98,22 @@ export declare function mockUnpricedWorkflowRefusal(body: {
  * not already refuse it. Estimate only — the submit of the same body proceeds.
  */
 export declare function mockUnquotedWorkflowEstimateRefusal(failure: MockWorkflowQuoteFailure): MockWorkflowRefusal;
+type WellFormedWorkflowBody = {
+    steps: Array<{
+        name?: string;
+        $type: string;
+        input: Record<string, unknown>;
+        suppressOutput?: boolean;
+    }>;
+    arguments?: Record<string, unknown>;
+};
+/**
+ * The host's wire schema, mirrored: exact keys, types and sizes — everything
+ * but the summed byte cap. Exported so the step-input gate
+ * (`mockHostStepInput.ts`) runs its rules only on a body the schema's shape
+ * accepts, as zod runs a refinement only after the shape parses.
+ */
+export declare function isWellFormedWorkflowShape(body: unknown): body is WellFormedWorkflowBody;
 /**
  * The refusal for a `kind: 'workflow'` body, or `null` for one the mock will
  * price and run. In the host's order:
@@ -114,4 +133,5 @@ export declare function mockUnquotedWorkflowEstimateRefusal(failure: MockWorkflo
  *     `workflow_step_denied`.
  */
 export declare function mockWorkflowBodyRefusal(body: unknown): MockWorkflowRefusal | null;
+export {};
 //# sourceMappingURL=mockWorkflowGraph.d.ts.map