@civitai/blocks-react 0.63.2 → 0.65.0

package/dist/internal/mockHost.js

@@ -41,6 +41,7 @@ import { APP_STORAGE_ERROR_REQUEST_FAILED, APP_STORAGE_ERROR_USER_QUOTA_EXCEEDED
 import { consentUnavailablePayload, isKnownBlockScope, resolveUngrantableConsentNotice, } from './consent.js';
 import { requiredStorageScope, storageResultType, storageScopeDeniedMessage, storageScopeDeniedPayload, } from './mockHostScopes.js';
 import { governsIdempotencyKey, idempotencyKeyDeniedMessage, idempotencyKeyRefusal, } from './mockHostIdempotency.js';
+import { RUN_TRAINING_ERROR_CODES } from '../hooks/useRunTraining.js';
 import { hostContextWithTheme } from '../transport/transport.js';
 import { isRoutableRequestId } from '../transport/requestId.js';
 /**
@@ -79,6 +80,10 @@ const preferredAccountType = (body) => {
             return body.mode === 'inline' ? undefined : body.params.accountType;
         case 'step':
             return undefined;
+        // A training body names no pool either: the host's `blockTrainingBodySchema`
+        // is `.strict()` with no `accountType`.
+        case 'training':
+            return undefined;
         default: {
             // Exhaustiveness check: a new `WorkflowBody` member makes this assignment
             // fail to compile, right here, rather than defaulting somewhere.
@@ -112,6 +117,86 @@ const BUDGETED_SCOPE = 'ai:write:budgeted';
 const DEFAULT_STORAGE_QUOTA_BYTES = APP_STORAGE_MAX_BYTES;
 const DEFAULT_STORAGE_VALUE_CAP_BYTES = APP_STORAGE_MAX_VALUE_BYTES;
 const DEFAULT_STORAGE_LIMIT_ROWS = APP_STORAGE_MAX_ROWS;
+/**
+ * The pass-through training `$type` a body names, if any. Exact match — the
+ * orchestrator's `$type` discriminator is case-sensitive. Only the pass-through
+ * arm carries a `$type`, so no separate `kind` narrow is needed.
+ */
+const passThroughTrainingType = (body) => {
+    const t = body.$type;
+    return t === 'training' || t === 'imageResourceTraining' ? t : undefined;
+};
+/**
+ * The orchestrator `$type` a body's run trains with, if it trains at all: the
+ * pass-through training `$type`s above, and `'training'` for a
+ * `kind: 'training'` body — the host builds an ai-toolkit `training` step for it.
+ */
+const trainingStepType = (body) => body.kind === 'training' ? 'training' : passThroughTrainingType(body);
+/**
+ * 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 const MOCK_TRAINING_BOUNDS = {
+    datasetMaxItems: 50,
+    captionMaxChars: 1000,
+    maxBuzzPerRun: 5000,
+};
+/**
+ * The host's `PREPARE_TRAINING_DATASET` item check, mirrored: the server's
+ * `blockTrainingDatasetItemsSchema` — 1…50 items, each EXACTLY `{ imageId:
+ * positive integer, caption: string ≤ 1000 }`. The real host runs this BEFORE any
+ * server call and refuses with `invalid training dataset`, so the mock does too.
+ */
+function isValidTrainingDatasetItems(items) {
+    if (!Array.isArray(items))
+        return false;
+    if (items.length < 1 || items.length > MOCK_TRAINING_BOUNDS.datasetMaxItems)
+        return false;
+    return items.every((it) => {
+        if (typeof it !== 'object' || it === null || Array.isArray(it))
+            return false;
+        const keys = Object.keys(it);
+        if (keys.length !== 2 || !keys.includes('imageId') || !keys.includes('caption'))
+            return false;
+        const { imageId, caption } = it;
+        return (typeof imageId === 'number' &&
+            Number.isInteger(imageId) &&
+            imageId > 0 &&
+            typeof caption === 'string' &&
+            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 an unknown, expired or spent quote on `RUN_TRAINING`. */
+export const MOCK_TRAINING_QUOTE_GONE_ERROR = 'training quote not found, expired or already used — estimate again';
+/** The real server's refusal for a training estimate naming a dataset it does not hold. */
+export const MOCK_TRAINING_DATASET_GONE_ERROR = 'training dataset not found or expired';
+/**
+ * The real server's two refusals for a dataset with NOTHING admitted
+ * (`prepareBlockTrainingDataset`): every image failed eligibility, or every
+ * eligible image failed its import. The server THROWS rather than returning
+ * `count: 0`, so a successful reply always admits at least one image.
+ */
+export const MOCK_TRAINING_NONE_ELIGIBLE_ERROR = 'none of the requested images can be used for training';
+export const MOCK_TRAINING_NONE_IMPORTED_ERROR = 'none of the requested images could be prepared for training';
+/**
+ * The forced `RUN_TRAINING` errors that settle BEFORE the server claims (and so
+ * consumes) the quote: the host's own gate and dialog codes. Derived from the
+ * host-code list — every code except `submission-unconfirmed`, which the host
+ * emits only after a submit was sent. Any other forced error (a server message
+ * such as "Not enough Buzz for this training run.") stands for a refusal the
+ * server made AFTER its claim, so it consumes the quote.
+ */
+const PRE_CLAIM_RUN_TRAINING_ERRORS = new Set(RUN_TRAINING_ERROR_CODES.filter((c) => c !== 'submission-unconfirmed'));
+/** Default quote total for a `kind: 'training'` estimate when {@link MockHostOptions.trainingQuoteTotal} is unset. */
+const DEFAULT_TRAINING_QUOTE_TOTAL = 500;
+/** The real quote lifetime (`BLOCK_TRAINING_QUOTE_TTL_SECONDS`, 15 min). */
+const TRAINING_QUOTE_TTL_MS = 15 * 60_000;
 // The canned picks carry the WIDENED BlockResourceInfo projection (PR-C) — the
 // public recommended settings a real host now returns — so dev:mock mirrors prod
 // (a picked resource seeds a weight slider + trigger words). Defaults match the
@@ -722,6 +807,13 @@ export function createMockHost(options = {}) {
     // App Blocks → Post bridge: the canned post + a forced-refusal knob.
     let createPostResult = options.createPostResult ?? DEFAULT_CREATE_POST_RESULT;
     let createPostError = options.createPostError;
+    // App Blocks training bridges: canned dataset rejections, quote total, and
+    // forced-refusal knobs. The datasets/quotes themselves live per install.
+    let trainingDatasetRejected = options.trainingDatasetRejected ?? [];
+    let trainingDatasetError = options.trainingDatasetError;
+    let trainingQuoteTotal = options.trainingQuoteTotal ?? DEFAULT_TRAINING_QUOTE_TOTAL;
+    let runTrainingError = options.runTrainingError;
+    let runTrainingCapRefusal = options.runTrainingCapRefusal;
     // App-subqueue bridge data + forced free-text-error knob. `appWorkflows` is
     // MUTABLE — CANCEL_APP_WORKFLOW marks the matching row canceled in place so a
     // follow-up QUERY reflects it.
@@ -873,6 +965,16 @@ export function createMockHost(options = {}) {
         let submitCount = 0;
         // body + cost remembered per workflow so the succeeded snapshot can echo them.
         const workflows = new Map();
+        // Training: datasets this install prepared (id → admitted count) and the
+        // quotes its estimates stored (id → what a run is checked against).
+        const trainingDatasets = new Map();
+        const trainingQuotes = new Map();
+        let trainingSerial = 0;
+        /** `<prefix>` + 32 hex characters — the real handles' shape. */
+        const trainingHandle = (prefix) => {
+            trainingSerial += 1;
+            return `${prefix}${trainingSerial.toString(16).padStart(32, '0')}`;
+        };
         const timers = new Set();
         const dispatchToBlock = (data) => {
             win.dispatchEvent(new MessageEvent('message', { data, origin: parentOrigin }));
@@ -894,11 +996,36 @@ export function createMockHost(options = {}) {
                 ...(consentGranted ? { buzzBudget } : {}),
             };
         };
+        /**
+         * The training-only fields of a succeeded snapshot — see
+         * {@link MockGenerationScenario.trainedEpochs}. KIND-FAITHFUL, unlike the
+         * rest of the money path: only a pass-through `training` /
+         * `imageResourceTraining` body gets them, because only such a step produces
+         * a checkpoint. Empty for every other body, so their snapshots are unchanged.
+         */
+        const trainingFields = (body) => {
+            const $type = trainingStepType(body);
+            if (!$type)
+                return {};
+            const count = Math.max(0, Math.floor(gen.trainedEpochs ?? 0));
+            return {
+                ...(count > 0
+                    ? {
+                        trainedEpochs: Array.from({ length: count }, (_, i) => ({
+                            $type,
+                            epochNumber: i + 1,
+                        })),
+                    }
+                    : {}),
+                ...(gen.trainingPublishedModel ? { publishedModel: { ...gen.trainingPublishedModel } } : {}),
+            };
+        };
         const succeededSnapshot = (workflowId) => {
             const wf = workflows.get(workflowId);
             const cost = wf?.cost ?? legacyCost;
             const body = wf?.body ?? {};
             return {
+                ...trainingFields(body),
                 workflowId,
                 status: 'succeeded',
                 cost: { total: cost },
@@ -1125,6 +1252,53 @@ export function createMockHost(options = {}) {
                             });
                             return;
                         }
+                        // 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.
+                        if (body.kind === 'training') {
+                            const refuse = (error) => dispatchToBlock({
+                                type: 'ESTIMATE_RESULT',
+                                payload: { requestId, snapshot: { 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);
+                            const total = trainingQuoteTotal;
+                            if (total > MOCK_TRAINING_BOUNDS.maxBuzzPerRun) {
+                                return refuse(`this training run costs ${total} Buzz, above the per-run limit of ${MOCK_TRAINING_BOUNDS.maxBuzzPerRun} for apps`);
+                            }
+                            const quoteId = trainingHandle('tq_');
+                            const expiresAtMs = Date.now() + TRAINING_QUOTE_TTL_MS;
+                            trainingQuotes.set(quoteId, {
+                                datasetId: body.datasetId,
+                                total,
+                                expiresAtMs,
+                                spent: false,
+                            });
+                            dispatchToBlock({
+                                type: 'ESTIMATE_RESULT',
+                                payload: {
+                                    requestId,
+                                    snapshot: {
+                                        workflowId: 'wf_estimate',
+                                        status: 'pending',
+                                        cost: { total },
+                                        trainingQuote: {
+                                            quoteId,
+                                            total,
+                                            imageCount,
+                                            expiresAt: new Date(expiresAtMs).toISOString(),
+                                        },
+                                    },
+                                },
+                            });
+                            return;
+                        }
                         dispatchToBlock({
                             type: 'ESTIMATE_RESULT',
                             payload: {
@@ -1148,6 +1322,26 @@ 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') {
+                            dispatchToBlock({
+                                type: 'WORKFLOW_SUBMITTED',
+                                payload: {
+                                    requestId,
+                                    snapshot: {
+                                        workflowId: 'failed',
+                                        status: 'failed',
+                                        error: 'this training run has not been confirmed by the viewer in this session',
+                                    },
+                                },
+                            });
+                            return;
+                        }
                         const cost = costFor(body);
                         // CAUGHT-SERVER-EXCEPTION simulation (`generation.failSubmitException`).
                         // Reproduces the host's `failureSnapshot(err)` byte-for-byte: the
@@ -1599,6 +1793,108 @@ export function createMockHost(options = {}) {
                         });
                         return;
                     }
+                    case 'PREPARE_TRAINING_DATASET': {
+                        // The host's gate order (`prepareTrainingDatasetGate.ts`): no
+                        // requestId → drop; signed-out → `sign in to train`; items outside
+                        // the server's schema → `invalid training dataset`, before any call.
+                        // Then the server: the spend scope, then the dataset.
+                        if (!isRoutableRequestId(requestId))
+                            return;
+                        const reply = (payload) => dispatchToBlock({ type: 'TRAINING_DATASET_RESULT', payload: { requestId, ...payload } });
+                        if (viewer === null)
+                            return reply({ error: 'sign in to train' });
+                        const items = typed.payload?.items;
+                        if (!isValidTrainingDatasetItems(items)) {
+                            return reply({ error: 'invalid training dataset' });
+                        }
+                        if (!consentGranted)
+                            return reply({ error: MOCK_TRAINING_SCOPE_ERROR });
+                        if (trainingDatasetError !== undefined)
+                            return reply({ error: trainingDatasetError });
+                        const named = new Set(items.map((it) => it.imageId));
+                        const rejected = trainingDatasetRejected
+                            .filter((r) => named.has(r.imageId))
+                            .map(({ imageId, reason }) => ({ imageId, reason }));
+                        const rejectedIds = new Set(rejected.map((r) => r.imageId));
+                        const count = [...named].filter((id) => !rejectedIds.has(id)).length;
+                        if (count === 0) {
+                            // The server THROWS here, eligibility before import: an `import-*`
+                            // rejection means that image PASSED eligibility, so the server
+                            // reached the import and refuses there.
+                            const anyImported = rejected.some((r) => r.reason.startsWith('import-'));
+                            return reply({
+                                error: anyImported
+                                    ? MOCK_TRAINING_NONE_IMPORTED_ERROR
+                                    : MOCK_TRAINING_NONE_ELIGIBLE_ERROR,
+                            });
+                        }
+                        const datasetId = trainingHandle('tds_');
+                        trainingDatasets.set(datasetId, count);
+                        const result = { datasetId, count, rejected };
+                        return reply({ result });
+                    }
+                    case 'RUN_TRAINING': {
+                        // The host's gate (`runTrainingGate.ts`): no requestId → drop;
+                        // signed-out → `sign in to train`; not a `kind:'training'` body with
+                        // a `quoteId` → `invalid training request`. Then the server: the
+                        // spend scope, then the quote (unknown, expired or already spent).
+                        if (!isRoutableRequestId(requestId))
+                            return;
+                        const reply = (payload) => dispatchToBlock({ type: 'TRAINING_RESULT', payload: { requestId, ...payload } });
+                        if (viewer === null)
+                            return reply({ error: 'sign in to train' });
+                        const raw = typed.payload?.body;
+                        const b = raw && typeof raw === 'object' && !Array.isArray(raw)
+                            ? raw
+                            : null;
+                        if (!b || b.kind !== 'training' || typeof b.quoteId !== 'string' || !b.quoteId) {
+                            return reply({ error: 'invalid training request' });
+                        }
+                        if (!consentGranted)
+                            return reply({ error: MOCK_TRAINING_SCOPE_ERROR });
+                        const quote = trainingQuotes.get(b.quoteId);
+                        if (!quote || quote.spent || Date.now() >= quote.expiresAtMs) {
+                            return reply({ error: MOCK_TRAINING_QUOTE_GONE_ERROR });
+                        }
+                        // Which outcomes consume the quote, modelled on the real flow: the
+                        // host's gate and consent dialog come first (quote kept); the
+                        // server's submit then claims the quote with a GETDEL
+                        // (`claimTrainingQuote`) BEFORE any of its own checks, so every
+                        // server outcome — a refusal, a body mismatch, a cap refusal,
+                        // `submission-unconfirmed`, a run — consumes it. The mock's check
+                        // ORDER below is its own; only the spent/kept split is the server's.
+                        if (runTrainingError !== undefined) {
+                            if (!PRE_CLAIM_RUN_TRAINING_ERRORS.has(runTrainingError))
+                                quote.spent = true;
+                            return reply({ error: runTrainingError });
+                        }
+                        quote.spent = true;
+                        if (b.datasetId !== quote.datasetId) {
+                            return reply({
+                                error: 'the training body differs from the one that was quoted — estimate again',
+                            });
+                        }
+                        // The server's cap / availability refusals RESOLVE (refunded, no run
+                        // started) — after the quote was consumed above.
+                        if (runTrainingCapRefusal !== undefined) {
+                            return reply({
+                                snapshot: {
+                                    workflowId: 'failed',
+                                    status: 'failed',
+                                    cost: { total: quote.total },
+                                    error: runTrainingCapRefusal,
+                                },
+                            });
+                        }
+                        submitCount += 1;
+                        const workflowId = `wf_${submitCount}_${Date.now()}`;
+                        workflows.set(workflowId, {
+                            polls: 0,
+                            cost: quote.total,
+                            body: raw,
+                        });
+                        return reply({ snapshot: { workflowId, status: 'pending' } });
+                    }
                     case 'PUBLISH_GENERATION_OUTPUTS': {
                         // Publish selected outputs of one of the app's OWN workflows as bare,
                         // real-scanned public Image rows. Drop a request with no requestId
@@ -2313,6 +2609,19 @@ export function createMockHost(options = {}) {
             createPostResult = patch.createPostResult;
         if (patch.createPostError !== undefined)
             createPostError = patch.createPostError;
+        if (patch.trainingDatasetRejected !== undefined) {
+            trainingDatasetRejected = patch.trainingDatasetRejected;
+        }
+        // The training error knobs clear on an explicit `undefined` (key PRESENT in
+        // the patch), so a harness can turn a refusal off without re-installing.
+        if ('trainingDatasetError' in patch)
+            trainingDatasetError = patch.trainingDatasetError;
+        if (patch.trainingQuoteTotal !== undefined)
+            trainingQuoteTotal = patch.trainingQuoteTotal;
+        if ('runTrainingError' in patch)
+            runTrainingError = patch.runTrainingError;
+        if ('runTrainingCapRefusal' in patch)
+            runTrainingCapRefusal = patch.runTrainingCapRefusal;
         if (patch.appWorkflows !== undefined) {
             appWorkflows = {
                 workflows: patch.appWorkflows.workflows,

package/dist/transport/requestTimeouts.d.ts

@@ -28,6 +28,25 @@ export declare const DEFAULT_REQUEST_TIMEOUT_MS = 30000;
  * no deep hook paths, so the rename touches no reachable API.
  */
 export declare const HUMAN_INTERACTION_TIMEOUT_MS: number;
+/**
+ * The bound for a `'protocol'` request whose SERVER WORK is itself slow — the
+ * host forwards it to the orchestrator and replies only once that answers. No
+ * person is in the loop, so it stays in the `'protocol'` bucket below; it just
+ * needs more than {@link DEFAULT_REQUEST_TIMEOUT_MS}.
+ *
+ * Callers: the workflow trio in `hooks/useBuzzWorkflow.ts` (a submit is a whatif
+ * preflight plus the real submit plus a prompt audit), and
+ * `PREPARE_TRAINING_DATASET` in `hooks/usePrepareTrainingDataset.ts`, whose
+ * server moderates the captions and imports up to 50 images into the
+ * orchestrator, the import alone under a 60s budget
+ * (`BLOCK_TRAINING_IMPORT_BUDGET_MS` in civitai/civitai's
+ * `block-training-dataset.service.ts`) — so the 30s default would reject a
+ * healthy prepare mid-import.
+ *
+ * Was a module-local constant in `useBuzzWorkflow.ts`; moved here so the second
+ * caller shares the number instead of re-typing it.
+ */
+export declare const WORKFLOW_REQUEST_TIMEOUT_MS = 120000;
 /** Which bound a block→parent message is answered under. */
 export type RequestTimeoutClass = 
 /** Reply waits on a PERSON — must pass {@link HUMAN_INTERACTION_TIMEOUT_MS}. */

package/dist/transport/requestTimeouts.js

@@ -27,6 +27,25 @@ export const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
  * no deep hook paths, so the rename touches no reachable API.
  */
 export const HUMAN_INTERACTION_TIMEOUT_MS = 10 * 60_000;
+/**
+ * The bound for a `'protocol'` request whose SERVER WORK is itself slow — the
+ * host forwards it to the orchestrator and replies only once that answers. No
+ * person is in the loop, so it stays in the `'protocol'` bucket below; it just
+ * needs more than {@link DEFAULT_REQUEST_TIMEOUT_MS}.
+ *
+ * Callers: the workflow trio in `hooks/useBuzzWorkflow.ts` (a submit is a whatif
+ * preflight plus the real submit plus a prompt audit), and
+ * `PREPARE_TRAINING_DATASET` in `hooks/usePrepareTrainingDataset.ts`, whose
+ * server moderates the captions and imports up to 50 images into the
+ * orchestrator, the import alone under a 60s budget
+ * (`BLOCK_TRAINING_IMPORT_BUDGET_MS` in civitai/civitai's
+ * `block-training-dataset.service.ts`) — so the 30s default would reject a
+ * healthy prepare mid-import.
+ *
+ * Was a module-local constant in `useBuzzWorkflow.ts`; moved here so the second
+ * caller shares the number instead of re-typing it.
+ */
+export const WORKFLOW_REQUEST_TIMEOUT_MS = 120_000;
 /**
  * 🔴 THE TOTALITY GATE — every block→parent message type, bucketed.
  *
@@ -69,6 +88,12 @@ const REQUEST_TIMEOUT_CLASS = {
     // failure, with nothing to reconcile the two. Unlike the publish bridge there
     // is no "outputs were lost" framing available here: the post exists.
     CREATE_POST_FROM_APP: 'human',
+    // 🔴 `'human'`: the host opens a training CONSENT dialog (price, base model,
+    // length, dataset size) and replies only on the viewer's click or dismiss. At
+    // the 30s default the request would reject with the dialog still open, and a
+    // viewer who then clicked Train would start a CHARGED run the block had
+    // already reported as failed.
+    RUN_TRAINING: 'human',
     // ── Fire-and-forget: no requestId, so no pending promise to time out ────
     BLOCK_ERROR: 'no-reply',
     BLOCK_HELLO: 'no-reply',
@@ -97,6 +122,11 @@ const REQUEST_TIMEOUT_CLASS = {
     APP_STORAGE_SET: 'protocol',
     CANCEL_APP_WORKFLOW: 'protocol',
     CANCEL_WORKFLOW: 'protocol',
+    // No dialog — preparing a dataset charges nothing and the host replies when
+    // the server does. Server-bound, so `'protocol'`; but sent under
+    // `WORKFLOW_REQUEST_TIMEOUT_MS`, not the 30s default, because the server's
+    // image import alone may take 60s. Same reasoning as the workflow trio below.
+    PREPARE_TRAINING_DATASET: 'protocol',
     // The workflow trio is server-bound, not person-bound. It carries its OWN
     // longer bound (`WORKFLOW_REQUEST_TIMEOUT_MS` in `hooks/useBuzzWorkflow.ts`)
     // for orchestrator latency — a different reason for a different number.

package/dist/transport/validate.d.ts

@@ -399,6 +399,33 @@ export declare function isValidCollectionFollowResult(p: unknown): boolean;
  * so a drop at least times out visibly.
  */
 export declare function isValidCreatePostResult(p: unknown): boolean;
+/**
+ * Reply to `PREPARE_TRAINING_DATASET`. A well-formed reply carries EITHER a
+ * `result` (`{ datasetId: non-empty string, count: integer ≥ 0, rejected: [{
+ * imageId: number, reason: string }] }`) OR an `error`; one with neither is
+ * malformed and dropped.
+ *
+ * 🔴 `error` IS SHAPE-CHECKED ONLY — the same decision as
+ * {@link isValidCreatePostResult}: the host's closed codes share the field with
+ * any server message it forwards, and a membership check would drop those
+ * replies before correlation, leaving the request to its timer.
+ *
+ * `rejected[].reason` is checked as a STRING, not against today's six members —
+ * the host adding a reason must not make every prepare reply that carries it a
+ * dropped one (the forward-compatibility rule in {@link isValidWorkflowSnapshot}).
+ */
+export declare function isValidTrainingDatasetResult(p: unknown): boolean;
+/**
+ * Reply to `RUN_TRAINING`. A well-formed reply carries EITHER a `snapshot` (a
+ * valid {@link isValidWorkflowSnapshot} — the block polls its `workflowId`) OR an
+ * `error`; one with neither is malformed and dropped.
+ *
+ * 🔴 `error` IS SHAPE-CHECKED ONLY, and here a membership check would cost the
+ * most: this request carries the TEN-MINUTE consent bound, and the host forwards
+ * server refusals (an expired quote, a changed body, an ineligible image) in this
+ * field. A dropped refusal would leave a Train button spinning for ten minutes.
+ */
+export declare function isValidTrainingResult(p: unknown): boolean;
 /**
  * Reply to `APP_STORAGE_GET`. `value` is arbitrary JSON (incl. `null` for an
  * unset key / anon viewer), so there is nothing to type-check on it — the guard