@civitai/blocks-react 0.63.2 → 0.65.0

package/dist/index.js

@@ -59,6 +59,8 @@ export { RequestTimeoutError } from './transport/transport.js';
 export { InvalidIdempotencyKeyError } from './transport/transport.js';
 export { useCollectionFollow, CollectionFollowError, COLLECTION_FOLLOW_ERROR_CODES, isCollectionFollowErrorCode, } from './hooks/useCollectionFollow.js';
 export { useCreatePostFromApp, CreatePostError, CREATE_POST_ERROR_CODES, isCreatePostErrorCode, } from './hooks/useCreatePostFromApp.js';
+export { usePrepareTrainingDataset, PrepareTrainingDatasetError, PREPARE_TRAINING_DATASET_ERROR_CODES, isPrepareTrainingDatasetErrorCode, } from './hooks/usePrepareTrainingDataset.js';
+export { useRunTraining, RunTrainingError, RUN_TRAINING_ERROR_CODES, isRunTrainingErrorCode, } from './hooks/useRunTraining.js';
 export { useCheckpointPicker } from './hooks/useCheckpointPicker.js';
 export { useResourcePicker } from './hooks/useResourcePicker.js';
 export { useImageUpload } from './hooks/useImageUpload.js';
@@ -76,6 +78,10 @@ export { useDomainMaturity } from './hooks/useDomainMaturity.js';
 export { SfwGate } from './hooks/SfwGate.js';
 export { useDirectLoad } from './hooks/useDirectLoad.js';
 export { hostToRunUrl, DIRECT_LOAD_TIMEOUT_MS } from './transport/directLoad.js';
+// A block CANNOT frame its own bundled content by URL. This is the `srcdoc`
+// fallback; prefer a single-document design. Why, measured, in one place:
+// `@civitai/app-sdk`'s `src/blocks/nestedDocument.ts` header.
+export { useNestedDocument } from './hooks/useNestedDocument.js';
 export { useAppStorage } from './hooks/useAppStorage.js';
 export { useSharedStorage } from './hooks/useSharedStorage.js';
 //# sourceMappingURL=index.js.map

package/dist/internal/liveHost.d.ts

@@ -46,8 +46,8 @@
  * --- BEGIN DERIVED ---
  * fetch chokepoints ..... 2
  * REST endpoints ........ GET /api/v1/blocks/me
- * tRPC procedures ....... 29 = blocks.* (14) + apps.shared.* (10) + apps.storage.* (5)
- * switch case labels .... 45, of which 7 REFUSE (enumerated under SCOPE below)
+ * tRPC procedures ....... 28 = blocks.* (13) + apps.shared.* (10) + apps.storage.* (5)
+ * switch case labels .... 47, of which 10 REFUSE (enumerated under SCOPE below)
  * --- END DERIVED ---
  *
  * PICKERS (Phase 1 of "make dev:live a faithful local host"): the live host
@@ -101,6 +101,17 @@
  *     host-chrome consent. Replies `collection-unavailable`.
  *   • CREATE_POST_FROM_APP — needs the server-resolved preview plus host-chrome
  *     confirm before a PUBLIC post is written. Replies with a refusal.
+ *   • PREPARE_TRAINING_DATASET — the server refuses every `kind: 'training'`
+ *     request from a dev token, so there is nothing to forward. Replies with a
+ *     refusal.
+ *   • RUN_TRAINING — the same dev-token refusal, plus the host-chrome consent
+ *     dialog a run is confirmed in, which this harness does not have. Replies
+ *     with a refusal.
+ *   • PUBLISH_GENERATION_OUTPUTS — publishing requires the viewer's signed-in
+ *     civitai.com session, which the local harness does not have; test
+ *     publishing against the mock host — `createMockHost` or `Harness` from
+ *     `@civitai/blocks-react/testing`, with the `publishImageIds` /
+ *     `publishError` options. Replies with a refusal.
  *   • GET_WILDCARD_PACK — needs the session-authed resolve plus the in-tab
  *     zip/yaml parse that lives in civitai, not this SDK. Replies `parse-failed`.
  *   • OPEN_IMAGE_UPLOAD — needs the host's native modal + session-authed byte
@@ -176,6 +187,11 @@ export interface LiveHostOptions {
      */
     onPickerReady?: (handle: PickerOverlayHandle) => void;
 }
+/**
+ * The reply both training bridges get in dev:live — see their handlers. One
+ * string so the two cannot drift.
+ */
+export declare const TRAINING_UNSUPPORTED_ERROR = "training is not supported in dev:live \u2014 use dev:mock";
 /**
  * Decoded payload of a block-token JWT (the claims `BlockTokenService.sign`
  * stamps — see civitai `block-token.service.ts`). Everything is optional/unknown

package/dist/internal/liveHost.js

@@ -46,8 +46,8 @@
  * --- BEGIN DERIVED ---
  * fetch chokepoints ..... 2
  * REST endpoints ........ GET /api/v1/blocks/me
- * tRPC procedures ....... 29 = blocks.* (14) + apps.shared.* (10) + apps.storage.* (5)
- * switch case labels .... 45, of which 7 REFUSE (enumerated under SCOPE below)
+ * tRPC procedures ....... 28 = blocks.* (13) + apps.shared.* (10) + apps.storage.* (5)
+ * switch case labels .... 47, of which 10 REFUSE (enumerated under SCOPE below)
  * --- END DERIVED ---
  *
  * PICKERS (Phase 1 of "make dev:live a faithful local host"): the live host
@@ -101,6 +101,17 @@
  *     host-chrome consent. Replies `collection-unavailable`.
  *   • CREATE_POST_FROM_APP — needs the server-resolved preview plus host-chrome
  *     confirm before a PUBLIC post is written. Replies with a refusal.
+ *   • PREPARE_TRAINING_DATASET — the server refuses every `kind: 'training'`
+ *     request from a dev token, so there is nothing to forward. Replies with a
+ *     refusal.
+ *   • RUN_TRAINING — the same dev-token refusal, plus the host-chrome consent
+ *     dialog a run is confirmed in, which this harness does not have. Replies
+ *     with a refusal.
+ *   • PUBLISH_GENERATION_OUTPUTS — publishing requires the viewer's signed-in
+ *     civitai.com session, which the local harness does not have; test
+ *     publishing against the mock host — `createMockHost` or `Harness` from
+ *     `@civitai/blocks-react/testing`, with the `publishImageIds` /
+ *     `publishError` options. Replies with a refusal.
  *   • GET_WILDCARD_PACK — needs the session-authed resolve plus the in-tab
  *     zip/yaml parse that lives in civitai, not this SDK. Replies `parse-failed`.
  *   • OPEN_IMAGE_UPLOAD — needs the host's native modal + session-authed byte
@@ -125,6 +136,15 @@ const DEFAULT_BACKEND_BASE_URL = 'https://civitai.com';
 const PAGE_SLOT_ID = 'app.page';
 /** The budgeted-spend scope the workflow procedures require. */
 const BUDGETED_SCOPE = 'ai:write:budgeted';
+/**
+ * The reply both training bridges get in dev:live — see their handlers. One
+ * string so the two cannot drift.
+ */
+export const TRAINING_UNSUPPORTED_ERROR = 'training is not supported in dev:live — use dev:mock';
+/** The once-per-session console line for a refused training bridge. */
+const trainingUnsupportedLog = (type) => `${type} is not supported in dev:live (the server refuses every training request from a ` +
+    'dev token, and a run needs the host-chrome consent dialog). Replying with a refusal. ' +
+    'Use dev:mock to exercise the training flow.';
 /**
  * Decode the middle (payload) segment of a JWT (base64url) WITHOUT verifying
  * the signature — client-side we only need the claims to build BLOCK_INIT; the
@@ -962,6 +982,44 @@ export function createLiveHost(options) {
                         });
                         return;
                     }
+                    case 'PREPARE_TRAINING_DATASET': {
+                        // UNSUPPORTED in live, and here the SERVER decides it, not this
+                        // harness: every `kind: 'training'` procedure refuses a dev token
+                        // ("training is not available from a development or review session"
+                        // — `assertTrainingRequestAllowed` in civitai/civitai), because there
+                        // is no host page whose chrome can show the viewer a price. A
+                        // training ESTIMATE is still forwarded (ESTIMATE_WORKFLOW above) and
+                        // comes back carrying that same server refusal.
+                        //
+                        // FREE TEXT on the message's own reply channel; no host code is
+                        // honest about "this harness cannot do it". Use dev:mock — its
+                        // `trainingDatasetError` / `trainingDatasetRejected` knobs cover the
+                        // refusal set.
+                        if (!isRoutableRequestId(requestId))
+                            return;
+                        logOnce('training-dataset', trainingUnsupportedLog('PREPARE_TRAINING_DATASET'));
+                        dispatchToBlock({
+                            type: 'TRAINING_DATASET_RESULT',
+                            payload: { requestId, error: TRAINING_UNSUPPORTED_ERROR },
+                        });
+                        return;
+                    }
+                    case 'RUN_TRAINING': {
+                        // UNSUPPORTED in live for the same server-side reason as
+                        // PREPARE_TRAINING_DATASET directly above — and doubly so: a run is
+                        // CHARGED and confirmed in host chrome this harness does not have, so
+                        // faking either half would let dev prove out a flow production does
+                        // not have. Use dev:mock — its `runTrainingError` knob covers
+                        // `declined`, `submission-unconfirmed` and the rest.
+                        if (!isRoutableRequestId(requestId))
+                            return;
+                        logOnce('training-run', trainingUnsupportedLog('RUN_TRAINING'));
+                        dispatchToBlock({
+                            type: 'TRAINING_RESULT',
+                            payload: { requestId, error: TRAINING_UNSUPPORTED_ERROR },
+                        });
+                        return;
+                    }
                     case 'GET_WILDCARD_PACK': {
                         // UNSUPPORTED in live v1 (honest-by-design, like OPEN_BUZZ_PURCHASE):
                         // the real host resolves the pack via a SESSION-authed proc and does
@@ -1025,29 +1083,37 @@ export function createLiveHost(options) {
                         return;
                     }
                     case 'PUBLISH_GENERATION_OUTPUTS': {
-                        // Publish selected outputs of one of the app's OWN workflows as bare,
-                        // real-scanned public Image rows via the token-bound
-                        // `blocks.publishGenerationOutputs` MUTATION (POST). The block sends
-                        // `workflowId` + optional `imageIndexes` (NEVER urls); the host
-                        // re-derives ownership, re-uploads + FULL-scans server-side. Returns a
-                        // plain `{ imageIds }`, unwrapped with `callTrpcData`. FREE-TEXT error
-                        // on failure. Unroutable without requestId.
+                        // UNSUPPORTED in live, for the same reason as CREATE_POST_FROM_APP
+                        // above: publishing requires the viewer's signed-in civitai.com
+                        // session, which the local harness does not have — it holds a dev
+                        // block token and has no civitai chrome to render the publish
+                        // confirm in. On civitai.com the real host resolves the workflow's
+                        // outputs, shows that confirm, and only then publishes bare,
+                        // real-scanned public Image rows.
+                        //
+                        // FREE TEXT, like the post refusal: none of the host's codes is
+                        // honest about "this harness cannot do it". `usePublishGenerationOutputs`
+                        // rejects with it as the message. Test publishing against the mock
+                        // host — `createMockHost` or `Harness` from
+                        // `@civitai/blocks-react/testing`, with the `publishImageIds` /
+                        // `publishError` options.
                         if (!isRoutableRequestId(requestId))
                             return;
-                        void callTrpcData('blocks.publishGenerationOutputs', {
-                            blockToken: rawToken,
-                            workflowId: typed.payload?.workflowId,
-                            ...(typed.payload?.imageIndexes !== undefined
-                                ? { imageIndexes: typed.payload.imageIndexes }
-                                : {}),
-                            ...(typed.payload?.title !== undefined ? { title: typed.payload.title } : {}),
-                        }, 'POST').then((r) => {
-                            dispatchToBlock({
-                                type: 'PUBLISH_RESULT',
-                                payload: r.data
-                                    ? { requestId, result: r.data }
-                                    : { requestId, error: r.error ?? 'publish unavailable' },
-                            });
+                        logOnce('publish-outputs', 'PUBLISH_GENERATION_OUTPUTS is not supported in dev:live (publishing requires the ' +
+                            "viewer's signed-in civitai.com session, which the local harness does not have). " +
+                            'Replying with a refusal. Test publishing against the mock host — createMockHost ' +
+                            'or Harness from @civitai/blocks-react/testing, with the publishImageIds / ' +
+                            'publishError options.');
+                        dispatchToBlock({
+                            type: 'PUBLISH_RESULT',
+                            payload: {
+                                requestId,
+                                error: 'publishing generation outputs is not supported in dev:live — publishing ' +
+                                    "requires the viewer's signed-in civitai.com session, which the local harness " +
+                                    'does not have; test publishing against the mock host — createMockHost or ' +
+                                    'Harness from @civitai/blocks-react/testing, with the publishImageIds / ' +
+                                    'publishError options',
+                            },
                         });
                         return;
                     }

package/dist/internal/mockHost.d.ts

@@ -37,7 +37,7 @@
  * called). Only the postMessage bridge round-trips are exercised. Never import
  * this from production code.
  */
-import { type BlockContext, type BlockResourceInfo, type BlockResourcePickerType, type BlockUploadedImageInfo, type BlockGenerationSourceImageInfo, type BuzzAccountType, type BlockBuzzTransaction, type BlockBuzzAccount, type BlockDailyCompensationResource, type BlockViewer, type BlockWildcardPack, type BlockWildcardPackErrorCode, type AppWorkflow, type BlockGatedImage, type BlockCollectionFollowErrorCode, type BlockCreatePostHostError, type BlockCreatePostResult, type ColorDomain, type SharedStorageValue, type Theme, type ViewerInfo, type WorkflowBody } from '@civitai/app-sdk/blocks';
+import { type BlockContext, type BlockResourceInfo, type BlockResourcePickerType, type BlockUploadedImageInfo, type BlockGenerationSourceImageInfo, type BuzzAccountType, type BlockBuzzTransaction, type BlockBuzzAccount, type BlockDailyCompensationResource, type BlockViewer, type BlockWildcardPack, type BlockWildcardPackErrorCode, type AppWorkflow, type BlockPublishedModel, type BlockGatedImage, type BlockCollectionFollowErrorCode, 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';
 /**
  * How submits behave. `'none'` = everything succeeds; `'all'` / `'insufficient'`
  * = every submit RESOLVES an insufficient-Buzz `failed` snapshot, priced
@@ -178,7 +178,75 @@ export interface MockGenerationScenario {
      * {@link image} when both are set.
      */
     images?: string[] | ((req: WorkflowBody) => string[]);
+    /**
+     * How many trained epochs a succeeded training run reports on
+     * {@link BlockWorkflowSnapshot.trainedEpochs} — epochs `1…n`, each tagged with
+     * the run's `$type`. Applies only to a PASS-THROUGH `{ kind: 'step', $type:
+     * 'training' }` / `'imageResourceTraining'` body (tagged with that `$type`) and
+     * to a `kind: 'training'` run started through `RUN_TRAINING` (tagged
+     * `'training'`, the step the host builds for it); every other body is
+     * unaffected.
+     *
+     * Default `0`: the field is omitted, as the host omits it for a run that
+     * produced no checkpoint. Opt in with `n > 0` to simulate a finished run —
+     * it is off by default because a real run on this arm is bounded by the
+     * spend rules below, so a default success would promise what the host may
+     * not deliver.
+     *
+     * The mock never fabricates a checkpoint url: the block contract does not
+     * include one, so nothing here does either. A training snapshot's `imageUrls` stand for
+     * the run's SAMPLE images only (the same {@link image}/{@link images} knobs
+     * apply).
+     *
+     * 🔴 The real host's spend and timeout rules for this arm (see
+     * `WorkflowBodyPassThroughStep.maxBuzz` in `@civitai/app-sdk/blocks`) are
+     * NOT simulated: the mock neither quotes nor times out, so a success here
+     * says nothing about whether your run is quoted, what it costs, or whether
+     * it finishes.
+     *
+     * Snapshot-only: the app-queue read (`QUERY_APP_WORKFLOWS`) replies with the
+     * canned {@link MockHostOptions.appWorkflows} rows verbatim — they carry no
+     * body, so the mock cannot tell a training row from any other. To exercise
+     * {@link AppWorkflow.trainedEpochs}, put it on the rows you pass there.
+     */
+    trainedEpochs?: number;
+    /**
+     * When set, a succeeded pass-through training snapshot also carries this as
+     * {@link BlockWorkflowSnapshot.publishedModel} — simulating a run the viewer
+     * has started (`published: false`) or finished (`published: true`) publishing
+     * through the model wizard. Default: unset (field omitted). For the app-queue
+     * read, put `publishedModel` (and `trainedEpochs`) on the rows you pass as
+     * `appWorkflows`.
+     */
+    trainingPublishedModel?: BlockPublishedModel;
 }
+/**
+ * The training bounds the mock enforces — COPIES of `@civitai/app-sdk/blocks`'s
+ * `BLOCK_TRAINING_DATASET_MAX_ITEMS`, `BLOCK_TRAINING_CAPTION_MAX_CHARS` and
+ * `BLOCK_TRAINING_MAX_BUZZ_PER_RUN`, 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`). The copy is held
+ * to the SDK's value by `test/trainingKindFlow.test.tsx`, which imports both.
+ */
+export declare const MOCK_TRAINING_BOUNDS: {
+    readonly datasetMaxItems: 50;
+    readonly captionMaxChars: 1000;
+    readonly maxBuzzPerRun: 5000;
+};
+/** The real server's refusal for a training request from a token without the spend scope. */
+export declare const MOCK_TRAINING_SCOPE_ERROR = "block lacks ai:write:budgeted scope";
+/** The real server's refusal for an unknown, expired or spent quote on `RUN_TRAINING`. */
+export declare const MOCK_TRAINING_QUOTE_GONE_ERROR = "training quote not found, expired or already used \u2014 estimate again";
+/** The real server's refusal for a training estimate naming a dataset it does not hold. */
+export declare const MOCK_TRAINING_DATASET_GONE_ERROR = "training dataset not found or expired";
+/**
+ * The real server's two refusals for a dataset with NOTHING admitted
+ * (`prepareBlockTrainingDataset`): every image failed eligibility, or every
+ * eligible image failed its import. The server THROWS rather than returning
+ * `count: 0`, so a successful reply always admits at least one image.
+ */
+export declare const MOCK_TRAINING_NONE_ELIGIBLE_ERROR = "none of the requested images can be used for training";
+export declare const MOCK_TRAINING_NONE_IMPORTED_ERROR = "none of the requested images could be prepared for training";
 /**
  * BUZZ scenario controls — simulate a balance so the insufficient-Buzz / top-up
  * UX is exercisable. The mock host treats `balance` as a spendable wallet:
@@ -587,6 +655,82 @@ export interface MockHostOptions {
      * exercised by `declined`, never by the timing or the content.
      */
     createPostError?: BlockCreatePostHostError | string;
+    /**
+     * Images `PREPARE_TRAINING_DATASET` leaves out, with their reasons — what
+     * `usePrepareTrainingDataset()` reports on `rejected`. Only entries whose
+     * `imageId` the request actually named are reported, and `count` is the rest,
+     * exactly as the server derives it. Absent → every image is admitted.
+     * Live-tunable via {@link MockHost.setScenario}.
+     *
+     * When this rejects EVERY named image the reply is an `error`, as on the real
+     * server — {@link MOCK_TRAINING_NONE_ELIGIBLE_ERROR}, or
+     * {@link MOCK_TRAINING_NONE_IMPORTED_ERROR} when every image that passed
+     * eligibility was rejected with an `import-*` reason. A success never has
+     * `count: 0`.
+     *
+     * KIND-FAITHFUL, like the rest of the training path: the mock holds the
+     * datasets it prepared, an estimate naming any other `datasetId` fails as the
+     * server's does, a quote is run at most once, and every training call needs
+     * `ai:write:budgeted` on the token ({@link MockHostOptions.consentGranted}) and
+     * a signed-in viewer. What it cannot model: image ownership and moderation (it
+     * has no images), the flag, and the page-only / dev-token refusals.
+     *
+     * ⚠️ The quote↔body check is NARROWER than the server's: the mock compares only
+     * `datasetId`, while the server hashes the whole body (minus `quoteId`) and
+     * refuses any change. A body edited between estimate and run passes here and
+     * fails in production.
+     */
+    trainingDatasetRejected?: Array<{
+        imageId: number;
+        reason: BlockTrainingRejectionReason;
+    }>;
+    /**
+     * Force `PREPARE_TRAINING_DATASET` to reply with an `error` — a
+     * {@link BlockPrepareTrainingDatasetHostError} for a host refusal, or any other
+     * string for the free-text server-message variant. Absent → it prepares.
+     * Live-tunable via {@link MockHost.setScenario}.
+     */
+    trainingDatasetError?: BlockPrepareTrainingDatasetHostError | string;
+    /**
+     * The Buzz total a `kind: 'training'` estimate quotes. Default `500`. Above
+     * `BLOCK_TRAINING_MAX_BUZZ_PER_RUN` (5,000) the estimate fails exactly as the
+     * server's does. The run's terminal snapshot reports this as its `cost`.
+     * Live-tunable via {@link MockHost.setScenario}.
+     */
+    trainingQuoteTotal?: number;
+    /**
+     * Force `RUN_TRAINING` to reply with an `error` instead of starting a run — a
+     * {@link BlockRunTrainingHostError} (`'declined'`: the viewer dismissed the
+     * dialog, no run; `'submission-unconfirmed'`: the run MAY exist) or any other
+     * string for a server message. Absent → the run starts.
+     *
+     * Whether the QUOTE survives follows the real flow: the host's own gate and
+     * dialog codes (`declined`, `review-mode`, `block is not ready`, `sign in to
+     * train`, `invalid training request`, `no block token`) settle before the
+     * server claims the quote, so it stays runnable; `submission-unconfirmed` and
+     * any server message settle after the claim, so it is used up — re-running it
+     * gets the quote-gone error. Live-tunable via {@link MockHost.setScenario};
+     * `undefined` clears it.
+     *
+     * 🔴 Same real gap as {@link createPostError}: the consent dialog is HOST
+     * chrome, so the mock settles immediately where the real host waits on a click.
+     */
+    runTrainingError?: BlockRunTrainingHostError | string;
+    /**
+     * Make `RUN_TRAINING` resolve the server's spend-cap or temporary-availability
+     * refusal instead of a run:
+     * a snapshot `{ workflowId: 'failed', status: 'failed', cost: { total: <quote> },
+     * error: <this string> }` — the shape the real training submit returns when
+     * the viewer's daily / private-run Buzz cap, the per-app consent budget, the
+     * app's spend or rate limit (or its "temporarily unavailable" deny), or a
+     * dev-session cap stops the run (refunded, no run). `useRunTraining()` rejects
+     * it with `.refused`. Pass the server's text, e.g. `'daily Buzz cap reached: …'`.
+     * 🔴 The quote is CONSUMED, as on the server (it is claimed before the cap
+     * checks): running the same `quoteId` again gets the quote-gone error — estimate
+     * again. Absent → the run starts. Live-tunable via {@link MockHost.setScenario};
+     * `setScenario({ runTrainingCapRefusal: undefined })` clears it.
+     */
+    runTrainingCapRefusal?: string;
     /**
      * Buzz pools a `SUBMIT_WORKFLOW` must REJECT when named in `body.accountType`
      * — simulates the real backend's content-rating clamp. The real host throws a
@@ -751,7 +895,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' | 'cannedImageUpload' | 'cannedGenerationSourceUpload' | 'cannedImageScan' | 'generation' | 'buzz' | 'storage' | 'shared' | 'buzzBalanceError' | 'viewerResult' | 'viewerError' | 'buzzTransactions' | 'buzzAccounts' | 'dailyCompensation' | 'buzzReadError' | 'wildcardPack' | 'wildcardPackError' | 'collectionFollowError' | 'createPostResult' | 'createPostError' | 'appWorkflows' | 'appWorkflowsError' | 'publishImageIds' | 'publishError' | 'gatedImages' | 'gatedImagesError' | 'disallowedAccountTypes'>;
+export type MockHostScenarioPatch = Pick<MockHostOptions, 'consentGrantable' | 'failMode' | 'cost' | 'pollsUntilDone' | 'cannedPicks' | 'cannedImageUpload' | 'cannedGenerationSourceUpload' | 'cannedImageScan' | 'generation' | 'buzz' | 'storage' | 'shared' | 'buzzBalanceError' | 'viewerResult' | 'viewerError' | 'buzzTransactions' | 'buzzAccounts' | 'dailyCompensation' | 'buzzReadError' | 'wildcardPack' | 'wildcardPackError' | 'collectionFollowError' | 'createPostResult' | 'createPostError' | 'trainingDatasetRejected' | 'trainingDatasetError' | 'trainingQuoteTotal' | 'runTrainingError' | 'runTrainingCapRefusal' | 'appWorkflows' | 'appWorkflowsError' | 'publishImageIds' | 'publishError' | 'gatedImages' | 'gatedImagesError' | 'disallowedAccountTypes'>;
 /** Runtime Buzz-balance handle exposed on {@link MockHost.buzz}. */
 export interface MockBuzzHandle {
     /** Current simulated balance, or `undefined` when balance isn't simulated. */