@civitai/blocks-react 0.69.1 → 0.71.0

package/dist/internal/mockHost.js

@@ -43,6 +43,7 @@ import { requiredStorageScope, storageResultType, storageScopeDeniedMessage, sto
 import { governsIdempotencyKey, idempotencyKeyDeniedMessage, idempotencyKeyRefusal, } from './mockHostIdempotency.js';
 import { SAVE_IMAGE_INVALID_REQUEST_ERROR, prepareSaveBytes, saveImageRequestKind, } from './saveBytes.js';
 import { UPLOAD_BYTES_INVALID_ERROR, admitUploadBytes, resolveUploadBytesRequest, } from './uploadBytes.js';
+import { mockUnpricedWorkflowRefusal, mockWorkflowBodyRefusal, mockWorkflowStepGenerations, mockWorkflowStepName, } from './mockWorkflowGraph.js';
 import { BATCH_ESTIMATE_CELL_TIMEOUT_ERROR } from '../hooks/useBatchEstimate.js';
 import { RUN_TRAINING_ERROR_CODES } from '../hooks/useRunTraining.js';
 import { hostContextWithTheme } from '../transport/transport.js';
@@ -87,6 +88,9 @@ const preferredAccountType = (body) => {
         // is `.strict()` with no `accountType`.
         case 'training':
             return undefined;
+        // Nor does a multi-step body: the kind has no `accountType` field.
+        case 'workflow':
+            return undefined;
         default: {
             // Exhaustiveness check: a new `WorkflowBody` member makes this assignment
             // fail to compile, right here, rather than defaulting somewhere.
@@ -173,8 +177,14 @@ function isValidTrainingDatasetItems(items) {
             caption.length <= MOCK_TRAINING_BOUNDS.captionMaxChars);
     });
 }
-/** The real server's refusal for a training request from a token without the spend scope. */
-export const MOCK_TRAINING_SCOPE_ERROR = 'block lacks ai:write:budgeted scope';
+/**
+ * The real server's refusal for ANY money call from a token without the spend
+ * scope: civitai's `estimateWorkflow`, `estimateWorkflowBatch`, `submitWorkflow`
+ * and the training procedures all throw `FORBIDDEN` with exactly this message
+ * BEFORE any pricing, rate-limit or budget work. ONE constant for every mock
+ * path that refuses on `consentGranted === false`, so the copies cannot drift.
+ */
+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. */
@@ -984,10 +994,35 @@ export function createMockHost(options = {}) {
         viewerVoted: row.voters.has(mockUserId),
     });
     // Resolve a per-gen cost from the scenario (or legacy `cost`).
+    // A `kind: 'workflow'` body is the SUM of its steps — see `workflowStepCosts`.
     const costFor = (body) => {
+        if (body.kind === 'workflow')
+            return workflowStepCosts(body).reduce((sum, c) => sum + c, 0);
         const spec = gen.costPerGen ?? legacyCost;
         return typeof spec === 'function' ? spec(body) : (spec ?? legacyCost);
     };
+    /**
+     * `costPerGen`, called once per step of a `kind: 'workflow'` body and
+     * multiplied by that step's generations — 1, or a `repeat`'s iteration count —
+     * because the orchestrator's quote prices every child of a bounded repeat.
+     */
+    const workflowStepCosts = (body) => {
+        // Unpriced: reserved at the ceiling, one per-generation budget per step.
+        if (gen.workflowUnpriced === true)
+            return body.steps.map(() => buzzBudget);
+        const spec = gen.costPerGen ?? legacyCost;
+        return (Array.isArray(body.steps) ? body.steps : []).map((step, index) => {
+            const each = typeof spec === 'function'
+                ? spec(body, {
+                    index,
+                    name: mockWorkflowStepName(step, index),
+                    $type: step.$type,
+                    input: step.input,
+                })
+                : spec;
+            return each * mockWorkflowStepGenerations(step.$type, step.input, body.arguments);
+        });
+    };
     // `null` = this quote is not itemised (a fee-less kind, or `authorFee: false`).
     const authorFeeFor = (body) => {
         if (gen.authorFee === false)
@@ -995,9 +1030,16 @@ export function createMockHost(options = {}) {
         // A REGISTERED step is keyed on the VALUE of `step`, as the host keys it —
         // never `'step' in body`: `{ kind: 'step', step: undefined, ... }` is a legal
         // pass-through body, and a pass-through quote prices no fee.
-        const quotesFee = body.kind === 'textToImage' || (body.kind === 'step' && typeof body.step === 'string');
+        // A `workflow` body quotes ONE fee for the whole workflow: this function is
+        // called once per body and never per step.
+        const quotesFee = body.kind === 'textToImage' ||
+            body.kind === 'workflow' ||
+            (body.kind === 'step' && typeof body.step === 'string');
         if (!quotesFee)
             return null;
+        // An unpriced workflow has no quoted base, so no fee is priced on it.
+        if (body.kind === 'workflow' && gen.workflowUnpriced === true)
+            return 0;
         const spec = gen.authorFee ?? 0;
         return typeof spec === 'function' ? spec(body) : spec;
     };
@@ -1143,10 +1185,88 @@ export function createMockHost(options = {}) {
                 ...(gen.trainingPublishedModel ? { publishedModel: { ...gen.trainingPublishedModel } } : {}),
             };
         };
+        /**
+         * The `steps` (and the top-level `imageUrls` they add up to) of a
+         * `kind: 'workflow'` run, given each step's status. A step reports images
+         * only once it has `'succeeded'` and only if it did not set
+         * `suppressOutput`; the top-level list is the union of those, in step order.
+         */
+        const workflowStepsView = (workflowId, body, statusOf, failedError) => {
+            const lastVisible = body.steps.reduce((last, s, i) => (s.suppressOutput === true ? last : i), -1);
+            const steps = body.steps.map((step, index) => {
+                const status = statusOf(index);
+                const name = mockWorkflowStepName(step, index);
+                const visible = status === 'succeeded' && step.suppressOutput !== true;
+                return {
+                    name,
+                    $type: step.$type,
+                    status,
+                    ...(visible
+                        ? {
+                            imageUrls: index === lastVisible
+                                ? imagesFor(workflowId, body)
+                                : [
+                                    `https://placehold.co/512x512/1971c2/ffffff/png?text=MOCK%0A${encodeURIComponent(name)}`,
+                                ],
+                        }
+                        : {}),
+                    ...(status === 'failed' && failedError !== undefined ? { error: failedError } : {}),
+                };
+            });
+            const imageUrls = steps.flatMap((s) => s.imageUrls ?? []);
+            return { steps, ...(imageUrls.length > 0 ? { imageUrls } : {}) };
+        };
+        /** A RUNNING `kind: 'workflow'` run after `polls` polls: steps finish in order. */
+        const workflowProgressView = (workflowId, body, polls) => {
+            const total = body.steps.length;
+            const failing = failingWorkflowStep(body);
+            const done = Math.min(Math.floor((total * polls) / Math.max(1, pollsUntilDone)), total - 1, failing === -1 ? total - 1 : failing);
+            return workflowStepsView(workflowId, body, (i) => i < done ? 'succeeded' : i === done ? 'processing' : 'pending');
+        };
+        /** Index of the step `generation.failWorkflowStep` names, or `-1`. */
+        const failingWorkflowStep = (body) => {
+            const target = gen.failWorkflowStep;
+            if (target === undefined)
+                return -1;
+            return body.steps.findIndex((s, i) => mockWorkflowStepName(s, i) === target);
+        };
+        /**
+         * The terminal snapshot of a `kind: 'workflow'` run whose step
+         * `generation.failWorkflowStep` names failed, or `null` when none does.
+         * Earlier steps stay `'succeeded'` and CHARGED, so `cost.total` is their sum
+         * and their visible images are still there.
+         */
+        const workflowPartialFailure = (workflowId) => {
+            const wf = workflows.get(workflowId);
+            const body = wf?.body;
+            if (!wf || body?.kind !== 'workflow')
+                return null;
+            const failing = failingWorkflowStep(body);
+            if (failing === -1)
+                return null;
+            const error = `mock: step "${mockWorkflowStepName(body.steps[failing], failing)}" failed`;
+            const charged = (wf.stepCosts ?? []).slice(0, failing).reduce((sum, c) => sum + c, 0);
+            return {
+                workflowId,
+                status: 'failed',
+                cost: { total: charged },
+                error,
+                ...workflowStepsView(workflowId, body, (i) => (i < failing ? 'succeeded' : i === failing ? 'failed' : 'canceled'), error),
+            };
+        };
         const succeededSnapshot = (workflowId) => {
             const wf = workflows.get(workflowId);
             const cost = wf?.cost ?? legacyCost;
             const body = wf?.body ?? {};
+            if (body.kind === 'workflow') {
+                return {
+                    workflowId,
+                    status: 'succeeded',
+                    cost: { total: cost },
+                    ...workflowStepsView(workflowId, body, () => 'succeeded'),
+                    spentAccountType: primaryFunder(buzzBalance),
+                };
+            }
             return {
                 ...trainingFields(body),
                 workflowId,
@@ -1262,20 +1382,39 @@ export function createMockHost(options = {}) {
                         // two to diagnose from the block side.
                         return { workflowId: 'wf_estimate', status: 'pending' };
                     }
+                    // 🔴 THE SPEND-SCOPE GATE — EVERY body kind, not just training.
+                    // civitai's `estimateWorkflow` throws `FORBIDDEN` with exactly this
+                    // message as its FIRST act after authenticating the token, before any
+                    // pricing, and the page host catches the throw into
+                    // `failureSnapshot(err)` — the `'failed'` sentinel id, no `cost`. That
+                    // is the signal a block answers with `requestConsent(...)` and a retry.
+                    // Until #608 only the training arm checked it, so the refusal → consent
+                    // → retry loop was unreachable for every other estimate in `pnpm dev`.
+                    //
+                    // Sits AFTER the `failEstimate` knobs on purpose: an explicitly forced
+                    // failure is what the author asked to see, and `estimate()` is not
+                    // consent-retried, so a scope refusal ahead of it would hide the knob
+                    // behind a message the author never asked for.
+                    //
+                    // 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.
+                    if (!consentGranted) {
+                        return { workflowId: 'failed', status: 'failed', error: MOCK_SPEND_SCOPE_ERROR };
+                    }
                     // TRAINING ESTIMATE — KIND-FAITHFUL, the one exception to the
                     // kind-agnostic rule above, because the real arm is not a priced
-                    // pass-through: it needs the spend scope, 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. Each refusal is the
-                    // server's message in the host's `failureSnapshot` shape.
+                    // 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.)
+                    // Each refusal is the server's message in the host's `failureSnapshot`
+                    // shape.
                     if (body.kind === 'training') {
                         const refuse = (error) => ({
                             workflowId: 'failed',
                             status: 'failed',
                             error,
                         });
-                        if (!consentGranted)
-                            return refuse(MOCK_TRAINING_SCOPE_ERROR);
                         const imageCount = trainingDatasets.get(body.datasetId);
                         if (imageCount === undefined)
                             return refuse(MOCK_TRAINING_DATASET_GONE_ERROR);
@@ -1303,6 +1442,16 @@ export function createMockHost(options = {}) {
                             },
                         };
                     }
+                    // MULTI-STEP — the second kind-faithful arm: the host refuses a body
+                    // it will not run BEFORE pricing it, with an `errorCode`, in the
+                    // `failureSnapshot` shape (no `cost`). A body that passes is priced
+                    // below like any other: `quotedCost` sums the steps and adds ONE fee.
+                    if (body.kind === 'workflow') {
+                        const refusal = mockWorkflowBodyRefusal(body) ??
+                            (gen.workflowUnpriced === true ? mockUnpricedWorkflowRefusal(body) : null);
+                        if (refusal !== null)
+                            return { workflowId: 'failed', status: 'failed', ...refusal };
+                    }
                     return {
                         workflowId: 'wf_estimate',
                         status: 'pending',
@@ -1458,6 +1607,21 @@ export function createMockHost(options = {}) {
                             });
                             return;
                         }
+                        // 🔴 THE SPEND-SCOPE GATE, WHOLE-CALL. civitai's
+                        // `estimateWorkflowBatch` throws `FORBIDDEN` before pricing a single
+                        // cell, and the host (`estimateBatchGate.ts`) catches the throw into
+                        // `{ requestId, error: err.message }` — NOT a per-cell failure, and
+                        // no `snapshots`/`aggregate`. The SDK surfaces it as
+                        // `BatchEstimateError` code `'failed'` with this text on `hostError`.
+                        // After the request-shape checks above, because those are the host's
+                        // own gate and run before the server is consulted.
+                        if (!consentGranted) {
+                            dispatchToBlock({
+                                type: 'ESTIMATE_BATCH_RESULT',
+                                payload: { requestId, error: MOCK_SPEND_SCOPE_ERROR },
+                            });
+                            return;
+                        }
                         const snapshots = bodies.map((cell, index) => {
                             // The host's snapshot for a cell its call budget ran out on.
                             if (gen.batchEstimateTimedOutCells?.includes(index)) {
@@ -1510,13 +1674,14 @@ export function createMockHost(options = {}) {
                         // the largest-wallet stamp. No recipe-registry validation.
                         submitCount += 1;
                         const body = typed.payload?.body ?? {};
-                        // A `kind: 'training'` body is never started by SUBMIT_WORKFLOW: the
-                        // server charges a training run only against a quote a signed-in
-                        // session confirmed, which only RUN_TRAINING's dialog records. The
-                        // server's own refusal, in the host's `failureSnapshot` shape.
-                        // (`useBuzzWorkflow().submit()` refuses before sending; this covers a
-                        // raw transport send.)
-                        if (body.kind === 'training') {
+                        // CAUGHT-SERVER-EXCEPTION simulation (`generation.failSubmitException`).
+                        // Reproduces the host's `failureSnapshot(err)` byte-for-byte: the
+                        // 'failed' sentinel id and NO `cost`, which is what separates an
+                        // errored submit from a priced budget rejection
+                        // (civitai/civitai-app-starters#251). Checked FIRST — a forced
+                        // host-side throw pre-empts every server-side decision below,
+                        // including the spend-scope gate.
+                        if (gen.failSubmitException === true) {
                             dispatchToBlock({
                                 type: 'WORKFLOW_SUBMITTED',
                                 payload: {
@@ -1524,22 +1689,39 @@ export function createMockHost(options = {}) {
                                     snapshot: {
                                         workflowId: 'failed',
                                         status: 'failed',
-                                        error: 'this training run has not been confirmed by the viewer in this session',
+                                        error: gen.failSubmitExceptionMessage ?? 'mock: submit failed',
                                     },
                                 },
                             });
                             return;
                         }
-                        const cost = costFor(body);
-                        // What the viewer pays: the generation plus the app fee.
-                        const charged = cost + (authorFeeFor(body) ?? 0);
-                        // CAUGHT-SERVER-EXCEPTION simulation (`generation.failSubmitException`).
-                        // Reproduces the host's `failureSnapshot(err)` byte-for-byte: the
-                        // 'failed' sentinel id and NO `cost`, which is what separates an
-                        // errored submit from a priced budget rejection
-                        // (civitai/civitai-app-starters#251). Checked FIRST — a host-side
-                        // throw pre-empts every server-side decision below.
-                        if (gen.failSubmitException === true) {
+                        // 🔴 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
+                        // confirmation, the currency resolution and any debit — and the page
+                        // host's SUBMIT_WORKFLOW handler catches the rejected mutation into
+                        // `failureSnapshot(err)`: the `'failed'` sentinel, NO `cost`. So
+                        // `submit()` rejects as `'exception'`, and `withConsentRetry` (the
+                        // token lacks `ai:write:budgeted`) prompts, this mock grants and
+                        // pushes TOKEN_REFRESH, and the SAME-KEY retry lands below. Nothing
+                        // is debited and no workflow is recorded on this arm.
+                        if (!consentGranted) {
+                            dispatchToBlock({
+                                type: 'WORKFLOW_SUBMITTED',
+                                payload: {
+                                    requestId,
+                                    snapshot: { workflowId: 'failed', status: 'failed', error: MOCK_SPEND_SCOPE_ERROR },
+                                },
+                            });
+                            return;
+                        }
+                        // A `kind: 'training'` body is never started by SUBMIT_WORKFLOW: the
+                        // server charges a training run only against a quote a signed-in
+                        // session confirmed, which only RUN_TRAINING's dialog records. The
+                        // server's own refusal, in the host's `failureSnapshot` shape.
+                        // (`useBuzzWorkflow().submit()` refuses before sending; this covers a
+                        // raw transport send.)
+                        if (body.kind === 'training') {
                             dispatchToBlock({
                                 type: 'WORKFLOW_SUBMITTED',
                                 payload: {
@@ -1547,12 +1729,32 @@ export function createMockHost(options = {}) {
                                     snapshot: {
                                         workflowId: 'failed',
                                         status: 'failed',
-                                        error: gen.failSubmitExceptionMessage ?? 'mock: submit failed',
+                                        error: 'this training run has not been confirmed by the viewer in this session',
                                     },
                                 },
                             });
                             return;
                         }
+                        // A `kind: 'workflow'` body the host will not run is refused here,
+                        // before any cap, balance or debit — the same refusal, with the same
+                        // `errorCode`, the estimate gives. No `cost`, so `submit()` rejects.
+                        if (body.kind === 'workflow') {
+                            const refusal = mockWorkflowBodyRefusal(body) ??
+                                (gen.workflowUnpriced === true ? mockUnpricedWorkflowRefusal(body) : null);
+                            if (refusal !== null) {
+                                dispatchToBlock({
+                                    type: 'WORKFLOW_SUBMITTED',
+                                    payload: {
+                                        requestId,
+                                        snapshot: { workflowId: 'failed', status: 'failed', ...refusal },
+                                    },
+                                });
+                                return;
+                            }
+                        }
+                        const cost = costFor(body);
+                        // What the viewer pays: the generation plus the app fee.
+                        const charged = cost + (authorFeeFor(body) ?? 0);
                         // Disallowed-account path (content-rating clamp): the real backend
                         // rejects a picked pool outside the app's maturity policy at the
                         // currency-resolution boundary — BEFORE any Buzz spend — so this is
@@ -1697,7 +1899,12 @@ export function createMockHost(options = {}) {
                         if (balanceSimulated)
                             buzz.balance = buzz.balance - charged;
                         const workflowId = `wf_${submitCount}_${Date.now()}`;
-                        workflows.set(workflowId, { polls: 0, cost, body });
+                        workflows.set(workflowId, {
+                            polls: 0,
+                            cost,
+                            body,
+                            ...(body.kind === 'workflow' ? { stepCosts: workflowStepCosts(body) } : {}),
+                        });
                         dispatchToBlock({
                             type: 'WORKFLOW_SUBMITTED',
                             payload: { requestId, snapshot: { workflowId, status: 'pending' } },
@@ -1723,6 +1930,16 @@ export function createMockHost(options = {}) {
                         }
                         const polls = wf.polls + 1;
                         wf.polls = polls;
+                        // A `kind: 'workflow'` run with a step told to fail ends `failed`
+                        // with its earlier steps intact (`generation.failWorkflowStep`).
+                        const partialFailure = polls >= pollsUntilDone ? workflowPartialFailure(workflowId) : null;
+                        if (partialFailure !== null) {
+                            dispatchToBlock({
+                                type: 'WORKFLOW_STATUS',
+                                payload: { requestId, snapshot: partialFailure },
+                            });
+                            return;
+                        }
                         const outcome = polls >= pollsUntilDone ? (gen.workflowOutcome?.(workflowId, wf.body) ?? 'succeeded') : null;
                         if (outcome === 'failed' || outcome === 'expired') {
                             dispatchToBlock({
@@ -1753,7 +1970,17 @@ export function createMockHost(options = {}) {
                         else {
                             dispatchToBlock({
                                 type: 'WORKFLOW_STATUS',
-                                payload: { requestId, snapshot: { workflowId, status: 'processing' } },
+                                payload: {
+                                    requestId,
+                                    snapshot: {
+                                        workflowId,
+                                        status: 'processing',
+                                        // A multi-step run reports how far its steps have got.
+                                        ...(wf.body?.kind === 'workflow'
+                                            ? workflowProgressView(workflowId, wf.body, polls)
+                                            : {}),
+                                    },
+                                },
                             });
                         }
                         return;
@@ -1774,6 +2001,14 @@ export function createMockHost(options = {}) {
                         if (wf && !wf.canceled && wf.polls >= pollsUntilDone) {
                             // Already finished: like the real host, report the real terminal
                             // status rather than pretending the cancel took.
+                            const partialFailure = workflowPartialFailure(workflowId);
+                            if (partialFailure !== null) {
+                                dispatchToBlock({
+                                    type: 'WORKFLOW_CANCELED',
+                                    payload: { requestId, snapshot: partialFailure },
+                                });
+                                return;
+                            }
                             const outcome = gen.workflowOutcome?.(workflowId, wf.body) ?? 'succeeded';
                             dispatchToBlock({
                                 type: 'WORKFLOW_CANCELED',
@@ -2111,7 +2346,7 @@ export function createMockHost(options = {}) {
                             return reply({ error: 'invalid training dataset' });
                         }
                         if (!consentGranted)
-                            return reply({ error: MOCK_TRAINING_SCOPE_ERROR });
+                            return reply({ error: MOCK_SPEND_SCOPE_ERROR });
                         if (trainingDatasetError !== undefined)
                             return reply({ error: trainingDatasetError });
                         const named = new Set(items.map((it) => it.imageId));
@@ -2154,7 +2389,7 @@ export function createMockHost(options = {}) {
                             return reply({ error: 'invalid training request' });
                         }
                         if (!consentGranted)
-                            return reply({ error: MOCK_TRAINING_SCOPE_ERROR });
+                            return reply({ error: MOCK_SPEND_SCOPE_ERROR });
                         const quote = trainingQuotes.get(b.quoteId);
                         if (!quote || quote.spent || Date.now() >= quote.expiresAtMs) {
                             return reply({ error: MOCK_TRAINING_QUOTE_GONE_ERROR });

package/dist/internal/mockWorkflowGraph.d.ts

@@ -0,0 +1,104 @@
+/**
+ * The mock host's checks on a multi-step `kind: 'workflow'` body: its shape,
+ * its step cap, its step names and reference graph, and the step-type denylist.
+ *
+ * A MIRROR of the host's rules, kept in its own pure module so the estimate, the
+ * batch estimate and the submit all refuse the same bodies, in the same order,
+ * with the same `errorCode`.
+ *
+ * 🔴 AN APPROXIMATION, NOT THE HOST. It checks WHERE a reference points, never
+ * whether its `path` exists, and it prices nothing. A body this accepts can
+ * still be refused by the real host or by the orchestrator.
+ */
+/**
+ * The bounds the mock enforces. `maxSteps` is a COPY of
+ * `@civitai/app-sdk/blocks`'s `BLOCK_WORKFLOW_MAX_STEPS`, deliberately not
+ * value-imported: a value import of a symbol the newest PUBLISHED app-sdk lacks
+ * raises this package's peer floor
+ * (`tests/guards/blocks-react-peer-floor.test.mjs`). It is held to the SDK's
+ * value by `test/mockHostWorkflowKind.test.tsx`, which imports both.
+ */
+export declare const MOCK_WORKFLOW_BOUNDS: {
+    /** Steps in one body. */
+    readonly maxSteps: 8;
+    /** Reference objects across every step input of one body. */
+    readonly maxRefs: 64;
+    /** Nesting depth of one step `input`. */
+    readonly maxInputDepth: 32;
+    /** How deep a `repeat` template may nest another `repeat`. */
+    readonly maxRepeatNesting: 4;
+    /** Serialized bytes of every step `input` plus `arguments`, summed. */
+    readonly maxInputBytes: 262144;
+    /** Characters of a step `$type`, and of a step `name` on the wire. */
+    readonly maxTypeChars: 64;
+    /**
+     * Iterations of one top-level `repeat` step, nested repeats MULTIPLIED. A
+     * COPY of `@civitai/app-sdk/blocks`'s `BLOCK_WORKFLOW_REPEAT_MAX_ITERATIONS`,
+     * held to it by the same test as `maxSteps`.
+     */
+    readonly maxRepeatIterations: 16;
+};
+/**
+ * Orchestrator `$type`s a `kind: 'workflow'` step may not name: the host's
+ * platform-internal list (scanners, moderation classifiers, hashing and model
+ * ingestion, the catalog's platform internals, web scrape/search and the
+ * retired `textToImage` step type) plus `promptModeration`. Matched
+ * case-insensitively, as the host matches. Anything else is accepted,
+ * including a `$type` this list has never heard of.
+ */
+export declare const MOCK_WORKFLOW_DENIED_STEP_TYPES: readonly string[];
+/** A refused body: the reply's `error` and, where one is defined, its `errorCode`. */
+export interface MockWorkflowRefusal {
+    error: string;
+    errorCode?: 'workflow_step_denied' | 'workflow_ref_invalid' | 'workflow_too_many_steps' | 'workflow_repeat_unbounded' | 'training-quote-unavailable';
+}
+/** What a step is called in a reference and on the snapshot: its `name`, or `'$<index>'`. */
+export declare const mockWorkflowStepName: (step: {
+    name?: unknown;
+}, index: number) => string;
+/** The refusal for a `repeat` whose shape or nesting the mock cannot follow. */
+export declare const MOCK_REPEAT_SHAPE_ERROR: string;
+/** The refusal for a `merge` whose sources the mock cannot read. */
+export declare const MOCK_MERGE_SHAPE_ERROR = "a merge step needs a \"fields\" object whose entries each carry a string \"$ref\" and a \"reduce\"";
+/**
+ * How many generations a step runs: 1, or a `repeat`'s iteration count with
+ * nested repeats multiplied (never less than 1). Only meaningful for a body
+ * {@link mockWorkflowBodyRefusal} accepted.
+ */
+export declare function mockWorkflowStepGenerations(stepType: string, input: unknown, args: unknown): number;
+/** The host's refusal text for an unquoted training step (`UNQUOTED_TRAINING_ERROR`). */
+export declare const MOCK_UNQUOTED_TRAINING_ERROR = "Training needs a price quote and none could be obtained; try again.";
+/**
+ * The refusal for a body {@link mockWorkflowBodyRefusal} ACCEPTED when the host
+ * could get NO price quote for it, or `null` when it would proceed (reserved at
+ * the ceiling). In the host's order: a training step anywhere (its own
+ * `training-quote-*` refusal — the mock reports `'training-quote-unavailable'`,
+ * the code for "no usable answer"), then a `repeat` anywhere
+ * (`workflow_repeat_unbounded`, naming the first such step).
+ */
+export declare function mockUnpricedWorkflowRefusal(body: {
+    steps: ReadonlyArray<{
+        $type: string;
+        input: unknown;
+    }>;
+}): MockWorkflowRefusal | null;
+/**
+ * The refusal for a `kind: 'workflow'` body, or `null` for one the mock will
+ * price and run. In the host's order:
+ *
+ *  1. the wire shape — no `errorCode`, the host's schema rejection;
+ *  2. the step cap — `workflow_too_many_steps`;
+ *  3. step by step: the name rules and a `repeat`'s exact shape and nesting
+ *     (`workflow_ref_invalid`); the repeat bound — only over an array in
+ *     `arguments`, at most 16 iterations with nested repeats multiplied
+ *     (`workflow_repeat_unbounded`); then the reference graph
+ *     (`workflow_ref_invalid`). A name is `[a-z][a-z0-9_-]{0,31}` (or the
+ *     step's own `$<index>`), unique, and not `block-step`; every source — a
+ *     reference, a `repeat`'s `for`, a `merge` field — names `$arguments` or an
+ *     EARLIER step, and a `merge` field never names a repeat variable;
+ *  4. a repeat `as` name that is also a step name — `workflow_ref_invalid`;
+ *  5. the step-type denylist on every step and on the step a `repeat` runs —
+ *     `workflow_step_denied`.
+ */
+export declare function mockWorkflowBodyRefusal(body: unknown): MockWorkflowRefusal | null;
+//# sourceMappingURL=mockWorkflowGraph.d.ts.map