@civitai/blocks-react 0.66.0 → 0.67.0

package/README.md

@@ -687,7 +687,8 @@ publish another.
 
 🔴 **No arm of `sources` takes a URL.** Name a workflow from this app's own
 subqueue plus indexes into its outputs, or `Image` ids from a previous
-`usePublishGenerationOutputs()` publish. The server re-verifies both — ownership,
+`usePublishGenerationOutputs()` publish or `useUploadImageBytes()` upload. The
+server re-verifies both — ownership,
 this app's provenance marker, and that the image is not already in a post.
 
 ⚠️ **Posting a published image removes it from this app's own grid.** The
@@ -1208,6 +1209,113 @@ if (img) {
 }
 ```
 
+### `useUploadImageBytes()`
+
+Upload an image the block **produced in the tab** (a healed PNG, an edited
+render), with no picker, so the app can then post it. Returns `{ upload }`.
+`upload(bytes, { filename? })` resolves with the same moderated image a picked
+`useImageUpload()` upload returns (`imageId`, `nsfwLevel`, `contentRating`,
+`url`). That `imageId` is postable by this app through
+`useCreatePostFromApp()` as a `{ kind: 'published', imageIds }` source.
+
+- 🔴 **Page apps only.** A slot (model) block's host has no handler for it. The
+  host answers an unhandled request at once with its generic refusal, so on a
+  slot `upload` rejects immediately with `unsupported on this host` rather than
+  waiting out the 10-minute timeout.
+- 🔴 **Requires `posts:write:self`.** The server refuses the upload without
+  it, and this hook does not prompt. Ask for the scope first with
+  `useRequestConsent()` and upload only once `useBlockToken().scopes` holds it
+  (the example below), because the upload runs before the `createPost()` call
+  that would otherwise prompt.
+- **Images only:** PNG, WebP or JPEG by magic bytes. Anything else is refused
+  with `file type is not allowed`. The host names the stored file from the
+  sniffed type, whatever `filename` says.
+- **The cap is 40 MiB.** The hook refuses a larger buffer before sending it,
+  with the host's error `file exceeds the maximum upload size`. The host also
+  allows at most 3 uploads and 80 MiB per 60 seconds per page, and replies
+  `busy` past that.
+- **The upload is blocking.** The host replies once the image is scanned, so
+  allow for a wait of up to a few minutes. An image above the SFW ceiling or
+  flagged by the scan is refused with the scan's message.
+- Pass an `ArrayBuffer` (`await blob.arrayBuffer()`). A `Blob`, a
+  `Uint8Array` or an empty buffer is refused with
+  `invalid image-upload request`. The buffer is copied, not transferred.
+
+`upload` **rejects** with the host's error string on every refusal: the ones
+above, `no block token`, or a server message passed through verbatim (the
+missing scope, the posting flag, page-only, a rate limit, the scan). It
+rejects with `the host returned no uploaded image` if the reply carries
+neither an image nor an error. If no reply arrives within 10 minutes it
+rejects with a `RequestTimeoutError`; the host may still have stored the
+image, so retrying after a timeout can create a duplicate.
+
+🔴 **A host that predates this variant ignores `bytes` and opens its upload
+picker instead**, so the call settles on whatever the viewer picks. The hook
+needs civitai/civitai#5639 merged and deployed to civitai.com. That PR is still
+changing, so no intermediate head of it is enough. Do not ship a block that
+relies on `useUploadImageBytes()` before then.
+
+```tsx
+import {
+  CreatePostError,
+  useBlockToken,
+  useCreatePostFromApp,
+  useRequestConsent,
+  useUploadImageBytes,
+} from '@civitai/blocks-react';
+
+function PostHealedButton({ healed }: { healed: Blob }) {
+  const { scopes } = useBlockToken();
+  const { requestConsent } = useRequestConsent();
+  const { upload } = useUploadImageBytes();
+  const { createPost } = useCreatePostFromApp();
+  const canPost = scopes.includes('posts:write:self');
+
+  async function onClick() {
+    if (!canPost) {
+      // Fire-and-forget: this opens the host's consent dialog and returns
+      // nothing. On a grant the host pushes a new token, `scopes` updates and
+      // the button re-renders as "Post". Never upload before that: the server
+      // refuses the upload without the scope.
+      requestConsent({ scopes: ['posts:write:self'] });
+      return;
+    }
+    try {
+      // 1. Bytes made in the tab, uploaded and scanned by the host.
+      const image = await upload(await healed.arrayBuffer(), { filename: 'healed.png' });
+      // 2. Posted through the existing bridge, with its own confirm.
+      const post = await createPost({
+        sources: [{ kind: 'published', imageIds: [image.imageId] }],
+        title: 'Fixed with Metadata Healer',
+      });
+      showToast(`Posted! ${post.url}`);
+    } catch (err) {
+      if (err instanceof CreatePostError && err.declined) return; // the viewer said no
+      showToast((err as Error).message); // e.g. 'busy', 'file type is not allowed'
+    }
+  }
+
+  return <button onClick={onClick}>{canPost ? 'Post' : 'Allow posting'}</button>;
+}
+```
+
+Under `createMockHost` / `Harness` the host's checks run in the host's order:
+the cap, then the window, then the type. `uploadImageBytesResult` sets the
+image an accepted upload returns, `uploadImageBytesError` forces a refusal
+(for example `block lacks posts:write:self scope`), and `onUploadImageBytes`
+reports what was accepted. The mock's `CREATE_POST_FROM_APP` checks a
+`published` source with the server's rule and refusal strings, but not its
+data. Production accepts the viewer's own images that this app stamped and that
+are not in a post yet, including ones from earlier sessions. The mock has no
+earlier sessions, so it accepts only ids it issued as postable in this session
+(an accepted bytes upload, or a `PUBLISH_GENERATION_OUTPUTS` reply) plus the
+ids you seed with `createMockHost({ postableImageIds: [...] })`, each in one
+post only. Any other id, a picked `useImageUpload()` id (production leaves it
+unstamped) or an already-posted id is refused with
+`an image is not available to post`. The mock does not model the page-only
+rule, the scope check, the real scan, or an older host's picker. `dev:live` has
+no bytes path: `upload` rejects with `the host returned no uploaded image`.
+
 ### `useSaveImage()`
 
 Ask the host to download a file to the viewer's device. **A block cannot

package/dist/hooks/useCreatePostFromApp.d.ts

@@ -113,7 +113,8 @@ export interface UseCreatePostFromApp {
  *
  * 🔴 NO ARM OF `sources` TAKES A URL. Name a workflow from this app's own
  * subqueue plus indexes into its outputs, or `Image` ids from a previous
- * `usePublishGenerationOutputs()` publish. The server re-verifies both.
+ * `usePublishGenerationOutputs()` publish or `useUploadImageBytes()` upload.
+ * The server re-verifies both.
  *
  * ⚠️ POSTING A PUBLISHED IMAGE REMOVES IT FROM THIS APP'S OWN GRID. The
  * app-scoped read behind `useGatedImages()` is conjoined with `postId IS NULL`,

package/dist/hooks/useCreatePostFromApp.js

@@ -121,7 +121,8 @@ export class CreatePostError extends Error {
  *
  * 🔴 NO ARM OF `sources` TAKES A URL. Name a workflow from this app's own
  * subqueue plus indexes into its outputs, or `Image` ids from a previous
- * `usePublishGenerationOutputs()` publish. The server re-verifies both.
+ * `usePublishGenerationOutputs()` publish or `useUploadImageBytes()` upload.
+ * The server re-verifies both.
  *
  * ⚠️ POSTING A PUBLISHED IMAGE REMOVES IT FROM THIS APP'S OWN GRID. The
  * app-scoped read behind `useGatedImages()` is conjoined with `postId IS NULL`,

package/dist/hooks/useUploadImageBytes.d.ts

@@ -0,0 +1,84 @@
+import type { BlockUploadedImageInfo } from '@civitai/app-sdk/blocks';
+/**
+ * The SDK's own rejection when a reply carries neither an image nor an
+ * `error`. A host that predates the `bytes` variant opens its picker instead,
+ * and a dismissed picker replies this way; so does any reply whose `selected`
+ * is not the moderated `display` shape.
+ */
+export declare const UPLOAD_IMAGE_BYTES_NO_IMAGE_ERROR = "the host returned no uploaded image";
+/** Options for {@link UseUploadImageBytes.upload}. */
+export interface UploadImageBytesOptions {
+    /**
+     * Advisory name for the stored image. The host sanitises it with the same
+     * rules as a `useSaveImage()` bytes name, forces the extension from the
+     * sniffed type, and caps it at 255 characters.
+     */
+    filename?: string;
+}
+/** What {@link useUploadImageBytes} returns. */
+export interface UseUploadImageBytes {
+    /**
+     * Upload an image the block produced in the tab, with no picker, and resolve
+     * with the moderated image: the same {@link BlockUploadedImageInfo} a picked
+     * `useImageUpload()` upload returns. Its `imageId` is postable by THIS app
+     * through `useCreatePostFromApp()` as `{ kind: 'published', imageIds }`.
+     *
+     * REJECTS with the host's error string on every refusal or failure:
+     * `invalid image-upload request` (not a non-empty `ArrayBuffer`),
+     * `file exceeds the maximum upload size`, `file type is not allowed`,
+     * `busy` (the host's rolling window is full; retry later), `no block token`,
+     * or a server message passed through verbatim (a missing `posts:write:self`
+     * scope, the posting flag, page-only, a rate limit, a scan refusal or
+     * timeout), or `unsupported on this host` on a slot (model) host, which has
+     * no handler and answers at once with its generic refusal. Rejects with
+     * `the host returned no uploaded image` when a reply carries neither an image
+     * nor an error.
+     *
+     * 🔴 With NO reply inside the 10-minute bound it rejects with a
+     * `RequestTimeoutError` instead, and the work may have completed: the host
+     * may have stored and scanned the image. Retrying after a timeout can create
+     * a duplicate image.
+     *
+     * 🔴 One call is refused BEFORE sending, with the host's own string: a buffer
+     * over the 40 MiB cap rejects with `file exceeds the maximum upload size`,
+     * so it is never copied across `postMessage` just to be refused.
+     */
+    upload: (bytes: ArrayBuffer, options?: UploadImageBytesOptions) => Promise<BlockUploadedImageInfo>;
+}
+/**
+ * Upload an image the block PRODUCED IN THE VIEWER'S TAB (a healed PNG, an
+ * edited render) through the host's `OPEN_IMAGE_UPLOAD { bytes }` bridge, so
+ * the app can then post it. No picker opens; the host runs the same store
+ * upload → persist → scan pipeline as a picked `display` upload and replies
+ * only once the scan settles.
+ *
+ * - 🔴 **Page apps only** (a slot host rejects at once with
+ *   `unsupported on this host`), and the token needs **`posts:write:self`**
+ *   (the server refuses the persist without it). This hook does not prompt for the
+ *   scope, so ask for it first with `useRequestConsent()`: the upload runs
+ *   before any `useCreatePostFromApp()` call that would otherwise prompt.
+ * - **Images only:** PNG, WebP or JPEG by magic bytes. The cap is 40 MiB, and
+ *   the host also allows at most 3 uploads and 80 MiB per 60 s per page.
+ * - The buffer is COPIED across `postMessage`, never transferred, so the block
+ *   can keep displaying it. Pass an `ArrayBuffer` (`await blob.arrayBuffer()`),
+ *   not a `Blob` or a typed array, which the host refuses.
+ * - 🔴 **A host that predates the variant ignores `bytes` and opens its picker.**
+ *   Then the promise settles on whatever the viewer picks, or rejects with
+ *   `the host returned no uploaded image` on a dismiss. It needs
+ *   civitai/civitai#5639 merged and deployed to civitai.com; that PR is still
+ *   changing, so no intermediate head of it is enough. Do not ship a block
+ *   relying on this before then.
+ *
+ * Under `createMockHost` / `Harness` the host's admission rules are modelled
+ * (see `MockHostOptions.uploadImageBytesResult`). `dev:live` has no bytes
+ * path: it replies dismissed, so `upload` rejects with
+ * `the host returned no uploaded image`.
+ *
+ * @example
+ * const { upload } = useUploadImageBytes();
+ * const { createPost } = useCreatePostFromApp();
+ * const image = await upload(await healed.arrayBuffer(), { filename: 'healed.png' });
+ * await createPost({ sources: [{ kind: 'published', imageIds: [image.imageId] }] });
+ */
+export declare function useUploadImageBytes(): UseUploadImageBytes;
+//# sourceMappingURL=useUploadImageBytes.d.ts.map

package/dist/hooks/useUploadImageBytes.js

@@ -0,0 +1,77 @@
+import { useCallback } from 'react';
+import { throwOnReplyError } from '../internal/replyError.js';
+import { UPLOAD_BYTES_MAX_BYTES, UPLOAD_BYTES_TOO_LARGE_ERROR } from '../internal/uploadBytes.js';
+import { HUMAN_INTERACTION_TIMEOUT_MS } from '../transport/requestTimeouts.js';
+import { getTransport } from '../transport/singleton.js';
+import { sendTypedRequest } from '../transport/transport.js';
+/**
+ * The SDK's own rejection when a reply carries neither an image nor an
+ * `error`. A host that predates the `bytes` variant opens its picker instead,
+ * and a dismissed picker replies this way; so does any reply whose `selected`
+ * is not the moderated `display` shape.
+ */
+export const UPLOAD_IMAGE_BYTES_NO_IMAGE_ERROR = 'the host returned no uploaded image';
+/**
+ * Upload an image the block PRODUCED IN THE VIEWER'S TAB (a healed PNG, an
+ * edited render) through the host's `OPEN_IMAGE_UPLOAD { bytes }` bridge, so
+ * the app can then post it. No picker opens; the host runs the same store
+ * upload → persist → scan pipeline as a picked `display` upload and replies
+ * only once the scan settles.
+ *
+ * - 🔴 **Page apps only** (a slot host rejects at once with
+ *   `unsupported on this host`), and the token needs **`posts:write:self`**
+ *   (the server refuses the persist without it). This hook does not prompt for the
+ *   scope, so ask for it first with `useRequestConsent()`: the upload runs
+ *   before any `useCreatePostFromApp()` call that would otherwise prompt.
+ * - **Images only:** PNG, WebP or JPEG by magic bytes. The cap is 40 MiB, and
+ *   the host also allows at most 3 uploads and 80 MiB per 60 s per page.
+ * - The buffer is COPIED across `postMessage`, never transferred, so the block
+ *   can keep displaying it. Pass an `ArrayBuffer` (`await blob.arrayBuffer()`),
+ *   not a `Blob` or a typed array, which the host refuses.
+ * - 🔴 **A host that predates the variant ignores `bytes` and opens its picker.**
+ *   Then the promise settles on whatever the viewer picks, or rejects with
+ *   `the host returned no uploaded image` on a dismiss. It needs
+ *   civitai/civitai#5639 merged and deployed to civitai.com; that PR is still
+ *   changing, so no intermediate head of it is enough. Do not ship a block
+ *   relying on this before then.
+ *
+ * Under `createMockHost` / `Harness` the host's admission rules are modelled
+ * (see `MockHostOptions.uploadImageBytesResult`). `dev:live` has no bytes
+ * path: it replies dismissed, so `upload` rejects with
+ * `the host returned no uploaded image`.
+ *
+ * @example
+ * const { upload } = useUploadImageBytes();
+ * const { createPost } = useCreatePostFromApp();
+ * const image = await upload(await healed.arrayBuffer(), { filename: 'healed.png' });
+ * await createPost({ sources: [{ kind: 'published', imageIds: [image.imageId] }] });
+ */
+export function useUploadImageBytes() {
+    const upload = useCallback(async (bytes, options) => {
+        // The ONLY client-side refusal, mirroring `useSaveImage`'s cap pre-check:
+        // everything else is forwarded and judged by the host.
+        if (bytes instanceof ArrayBuffer && bytes.byteLength > UPLOAD_BYTES_MAX_BYTES) {
+            throw new Error(UPLOAD_BYTES_TOO_LARGE_ERROR);
+        }
+        const reply = await sendTypedRequest(getTransport(), {
+            type: 'OPEN_IMAGE_UPLOAD',
+            payload: {
+                bytes,
+                ...(options?.filename !== undefined ? { filename: options.filename } : {}),
+            },
+        }, 'IMAGE_UPLOAD_RESULT', 
+        // `OPEN_IMAGE_UPLOAD` is bucketed `'human'` (transport/requestTimeouts.ts),
+        // and this variant needs the long bound too: the host replies only after
+        // the store upload, the persist and a scan poll of up to three minutes,
+        // and a host that predates `bytes` opens a picker a person must close.
+        { timeoutMs: HUMAN_INTERACTION_TIMEOUT_MS });
+        // No `ok` on this reply, so the presence-based helper (internal/replyError.ts).
+        throwOnReplyError(reply, 'image upload failed');
+        const selected = reply.selected;
+        if (selected && !('status' in selected) && 'imageId' in selected)
+            return selected;
+        throw new Error(UPLOAD_IMAGE_BYTES_NO_IMAGE_ERROR);
+    }, []);
+    return { upload };
+}
+//# sourceMappingURL=useUploadImageBytes.js.map

package/dist/index.d.ts

@@ -78,6 +78,8 @@ export { useResourcePicker } from './hooks/useResourcePicker.js';
 export type { UseResourcePicker } from './hooks/useResourcePicker.js';
 export { useImageUpload } from './hooks/useImageUpload.js';
 export type { UseImageUpload, UseImageUploadAsyncScan, UseImageUploadGenerationSource, UseImageUploadOptions, } from './hooks/useImageUpload.js';
+export { useUploadImageBytes } from './hooks/useUploadImageBytes.js';
+export type { UploadImageBytesOptions, UseUploadImageBytes, } from './hooks/useUploadImageBytes.js';
 export { useGenerationResources } from './hooks/useGenerationResources.js';
 export type { UseGenerationResources } from './hooks/useGenerationResources.js';
 export { GENERATION_RESOURCES_API_BASE, MAX_GENERATION_RESOURCE_IDS, buildGenerationResourcesUrl, responseToResources, } from './api/generationResources.js';

package/dist/index.js

@@ -64,6 +64,7 @@ export { useRunTraining, RunTrainingError, RUN_TRAINING_ERROR_CODES, isRunTraini
 export { useCheckpointPicker } from './hooks/useCheckpointPicker.js';
 export { useResourcePicker } from './hooks/useResourcePicker.js';
 export { useImageUpload } from './hooks/useImageUpload.js';
+export { useUploadImageBytes } from './hooks/useUploadImageBytes.js';
 export { useGenerationResources } from './hooks/useGenerationResources.js';
 export { GENERATION_RESOURCES_API_BASE, MAX_GENERATION_RESOURCE_IDS, buildGenerationResourcesUrl, responseToResources, } from './api/generationResources.js';
 export { useCivitaiNavigate } from './hooks/useCivitaiNavigate.js';

package/dist/internal/liveHost.js

@@ -1174,9 +1174,21 @@ export function createLiveHost(options) {
                         // the hook resolves to `null`) and log an actionable message. Honest-
                         // by-design — never fabricate a moderated image id. Mirrors the
                         // OPEN_BUZZ_PURCHASE "no headless contract" pattern.
-                        logOnce('open-image-upload', 'OPEN_IMAGE_UPLOAD received but live dev mode cannot serve the native upload ' +
-                            'modal — resolving the upload as dismissed (null). Test the image-upload flow ' +
-                            'against the real site, or use createMockHost({ cannedImageUpload }) in dev:mock.');
+                        //
+                        // The `bytes` variant (`useUploadImageBytes()`) gets the same reply,
+                        // but that hook has no "dismissed" outcome: it REJECTS with its
+                        // no-image error. So it gets its own message, naming its mock option.
+                        if (typed.payload != null && 'bytes' in typed.payload) {
+                            logOnce('open-image-upload-bytes', 'OPEN_IMAGE_UPLOAD { bytes } received but live dev mode has no bytes upload path — ' +
+                                'useUploadImageBytes().upload() REJECTS with "the host returned no uploaded image". ' +
+                                'Test the bytes upload against the real site, or use ' +
+                                'createMockHost({ uploadImageBytesResult }) in dev:mock.');
+                        }
+                        else {
+                            logOnce('open-image-upload', 'OPEN_IMAGE_UPLOAD received but live dev mode cannot serve the native upload ' +
+                                'modal — resolving the upload as dismissed (null). Test the image-upload flow ' +
+                                'against the real site, or use createMockHost({ cannedImageUpload }) in dev:mock.');
+                        }
                         dispatchToBlock({
                             type: 'IMAGE_UPLOAD_RESULT',
                             payload: { requestId: requestId ?? '' },

package/dist/internal/mockHost.d.ts

@@ -619,8 +619,9 @@ export interface MockHostOptions {
     /**
      * The bare (post-less) scanned `Image` row ids returned from
      * `PUBLISH_GENERATION_OUTPUTS` (what `usePublishGenerationOutputs().publish()`
-     * resolves with). Absent → {@link DEFAULT_PUBLISH_IMAGE_IDS}. Live-tunable via
-     * {@link MockHost.setScenario}.
+     * resolves with). Absent → {@link DEFAULT_PUBLISH_IMAGE_IDS}. Each reply makes
+     * these ids postable once in a `CREATE_POST_FROM_APP` `published` source (see
+     * {@link createPostResult}). Live-tunable via {@link MockHost.setScenario}.
      */
     publishImageIds?: number[];
     /**
@@ -681,6 +682,21 @@ export interface MockHostOptions {
      * `useCreatePostFromApp().createPost()` resolves with). Absent →
      * {@link DEFAULT_CREATE_POST_RESULT}. Ignored when {@link createPostError} is
      * set. Live-tunable via {@link MockHost.setScenario}.
+     *
+     * A `{ kind: 'published', imageIds }` source is checked as the server's
+     * `resolveAppPublishedImages` checks it (civitai/civitai#5639). Production
+     * accepts the viewer's own images that this app stamped and that are not in a
+     * post yet, from this session or an earlier one. The mock has no earlier
+     * sessions, so it accepts ONLY ids issued as postable on this mock instance
+     * (an accepted `OPEN_IMAGE_UPLOAD { bytes }` reply,
+     * {@link uploadImageBytesResult}, or a `PUBLISH_GENERATION_OUTPUTS` reply,
+     * {@link publishImageIds}) plus the ids seeded with {@link postableImageIds}.
+     * Any other id, a picked `useImageUpload()` id (production leaves it
+     * unstamped) or an id a previous post already adopted is refused with
+     * `an image is not available to post`, and a source with no positive integer
+     * id with `no valid image ids in a published source`. A refused post adopts
+     * nothing. `workflow` sources are not checked. The mock does not model the
+     * scan wait, the viewer's ceiling or the server's input schema.
      */
     createPostResult?: BlockCreatePostResult;
     /**
@@ -816,6 +832,64 @@ export interface MockHostOptions {
         mimeType: string;
         filename: string;
     }) => void;
+    /**
+     * The moderated image an ACCEPTED `OPEN_IMAGE_UPLOAD { bytes }` replies with
+     * (what `useUploadImageBytes().upload()` resolves with). Absent →
+     * {@link DEFAULT_IMAGE_BYTES_UPLOAD}, whose `imageId` differs from
+     * {@link DEFAULT_IMAGE_UPLOAD}'s so a block that confuses a picked upload
+     * with an uploaded one is visible. Each accepted upload makes its `imageId`
+     * postable ONCE in a `CREATE_POST_FROM_APP` `{ kind: 'published', imageIds }`
+     * source on this same mock instance, as the real host allows for the app that
+     * uploaded it; see {@link createPostResult} for what the mock refuses.
+     * Live-tunable via {@link MockHost.setScenario}.
+     *
+     * The `bytes` variant runs the host's admission rules
+     * (civitai/civitai#5639, `imageUploadBytes.ts`) in the host's order: not a
+     * non-empty `ArrayBuffer`, or `purpose: 'generationSource'` →
+     * `invalid image-upload request`; over 40 MiB →
+     * `file exceeds the maximum upload size` (checked FIRST); a full rolling
+     * window (3 uploads or 80 MiB per 60 s, per install) → `busy`; not PNG /
+     * WebP / JPEG by magic bytes → `file type is not allowed`; then
+     * {@link uploadImageBytesError}, standing in for the server persist and the
+     * scan. 🔴 What the mock cannot model: that the variant is PAGE-ONLY, the
+     * `posts:write:self` scope check (force `block lacks posts:write:self scope`
+     * with {@link uploadImageBytesError}), the real scan, the no-reply for a
+     * `requestId` reused while in flight (the mock replies at once), and that a
+     * host OLDER than the variant opens its picker instead.
+     */
+    uploadImageBytesResult?: BlockUploadedImageInfo;
+    /**
+     * Force an `OPEN_IMAGE_UPLOAD { bytes }` that passed the admission rules
+     * above to reply with this `error`: a server refusal the real host forwards
+     * (`block lacks posts:write:self scope`,
+     * `Rate limit exceeded, please retry shortly.`, a scan refusal, …), or
+     * `busy` / `no block token`. The upload still counts against the window, as
+     * on the host. Absent → it succeeds. Live-tunable via
+     * {@link MockHost.setScenario}; `undefined` clears it.
+     */
+    uploadImageBytesError?: string;
+    /**
+     * Called with each `bytes` upload the mock ACCEPTS: the sniffed `mimeType`
+     * (`image/png`, `image/webp` or `image/jpeg`), the `filename` as the host
+     * stores it (the `useSaveImage()` bytes cleaning, the sniffed extension, at
+     * most 255 characters), and a copy of the `bytes`.
+     */
+    onUploadImageBytes?: (file: {
+        bytes: ArrayBuffer;
+        mimeType: string;
+        filename: string;
+    }) => void;
+    /**
+     * Image ids the mock treats as already issued and postable when the host is
+     * created, as production treats an image this app stamped for the viewer in
+     * an EARLIER session that is not in a post yet. Each seeded id may be posted
+     * ONCE in a `CREATE_POST_FROM_APP` `{ kind: 'published', imageIds }` source;
+     * see {@link createPostResult} for what the mock refuses. Use it for a test
+     * that posts an image the block uploaded before the test started, instead of
+     * driving an upload or `PUBLISH_GENERATION_OUTPUTS` first. Absent → none.
+     * Read once at creation; not live-tunable.
+     */
+    postableImageIds?: number[];
     /**
      * 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
@@ -980,7 +1054,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' | 'trainingDatasetRejected' | 'trainingDatasetError' | 'trainingQuoteTotal' | 'runTrainingError' | 'runTrainingCapRefusal' | 'appWorkflows' | 'appWorkflowsError' | 'publishImageIds' | 'publishError' | 'gatedImages' | 'gatedImagesError' | 'disallowedAccountTypes' | 'saveImageError'>;
+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' | 'saveImageError' | 'uploadImageBytesResult' | 'uploadImageBytesError'>;
 /** Runtime Buzz-balance handle exposed on {@link MockHost.buzz}. */
 export interface MockBuzzHandle {
     /** Current simulated balance, or `undefined` when balance isn't simulated. */

package/dist/internal/mockHost.js

@@ -42,6 +42,7 @@ import { consentUnavailablePayload, isKnownBlockScope, resolveUngrantableConsent
 import { requiredStorageScope, storageResultType, storageScopeDeniedMessage, storageScopeDeniedPayload, } from './mockHostScopes.js';
 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 { RUN_TRAINING_ERROR_CODES } from '../hooks/useRunTraining.js';
 import { hostContextWithTheme } from '../transport/transport.js';
 import { isRoutableRequestId } from '../transport/requestId.js';
@@ -248,6 +249,17 @@ const DEFAULT_IMAGE_UPLOAD = {
  * — no imageId/nsfwLevel). `null` simulates a user-dismissed modal. The url is a
  * Civitai-hosted image so a dev can feed it straight into a `sourceImage` body.
  */
+/**
+ * The moderated image the mock host returns from an accepted
+ * `OPEN_IMAGE_UPLOAD { bytes }` when {@link MockHostOptions.uploadImageBytesResult}
+ * is omitted. Its `imageId` deliberately differs from {@link DEFAULT_IMAGE_UPLOAD}'s.
+ */
+const DEFAULT_IMAGE_BYTES_UPLOAD = {
+    imageId: 12345701,
+    nsfwLevel: 1,
+    contentRating: 'pg',
+    url: 'https://image.civitai.com/mock/original=true/dev-bytes-upload.png',
+};
 const DEFAULT_GENERATION_SOURCE_UPLOAD = {
     url: 'https://image.civitai.com/mock/original=true/dev-generation-source.jpeg',
     width: 1024,
@@ -831,6 +843,19 @@ export function createMockHost(options = {}) {
     let runTrainingError = options.runTrainingError;
     // SAVE_IMAGE: a forced-refusal knob (see `saveImageError`).
     let saveImageError = options.saveImageError;
+    // OPEN_IMAGE_UPLOAD { bytes }: the canned result, a forced-refusal knob, and
+    // the host's rolling window (per install, like the host's per mount).
+    let uploadImageBytesResult = options.uploadImageBytesResult ?? DEFAULT_IMAGE_BYTES_UPLOAD;
+    let uploadImageBytesError = options.uploadImageBytesError;
+    let uploadBytesWindow = [];
+    // 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
+    // earlier session's stamped, unposted images), and only until a post adopts
+    // them. Mirrors the host's `resolveAppPublishedImages` (civitai/civitai#5639):
+    // this app's provenance stamp and `postId IS NULL`. A picked `useImageUpload()`
+    // image is never added: production leaves it unstamped, so it is not postable.
+    const postableImageIds = new Set(options.postableImageIds ?? []);
     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
@@ -1840,6 +1865,32 @@ export function createMockHost(options = {}) {
                             });
                             return;
                         }
+                        // `published` sources: the server's `resolveAppPublishedImages`
+                        // refusals, verbatim. Ids are de-duplicated and non-positive /
+                        // non-integer ones dropped first; none left → `no valid image ids
+                        // in a published source`. Then ONE message for "unknown", "not this
+                        // app's" (a picked upload is unstamped) and "already in a post", so
+                        // the reply is no existence oracle. Refused, never skipped.
+                        const adopted = [];
+                        for (const source of sources) {
+                            if (source?.kind !== 'published')
+                                continue;
+                            const raw = Array.isArray(source.imageIds) ? source.imageIds : [];
+                            const ids = [...new Set(raw)].filter((n) => typeof n === 'number' && Number.isInteger(n) && n > 0);
+                            const refusal = ids.length === 0
+                                ? 'no valid image ids in a published source'
+                                : ids.some((id) => !postableImageIds.has(id))
+                                    ? 'an image is not available to post'
+                                    : undefined;
+                            if (refusal !== undefined) {
+                                dispatchToBlock({ type: 'CREATE_POST_RESULT', payload: { requestId, error: refusal } });
+                                return;
+                            }
+                            adopted.push(...ids);
+                        }
+                        // Posted: the adopted images now have a `postId`, so never again.
+                        for (const id of adopted)
+                            postableImageIds.delete(id);
                         dispatchToBlock({
                             type: 'CREATE_POST_RESULT',
                             payload: { requestId, result: { ...createPostResult } },
@@ -1962,6 +2013,8 @@ export function createMockHost(options = {}) {
                             });
                             return;
                         }
+                        for (const id of publishImageIds)
+                            postableImageIds.add(id);
                         dispatchToBlock({
                             type: 'PUBLISH_RESULT',
                             payload: { requestId, result: { imageIds: [...publishImageIds] } },
@@ -2025,6 +2078,31 @@ export function createMockHost(options = {}) {
                         //   • 'generationSource' → the UNSCANNED source { url, width, height }
                         //   • 'display' (default / absent) → the MODERATED image
                         // `null` → dismissed (no `selected`), so the hook resolves to null.
+                        // The `bytes` variant (civitai/civitai#5639): no picker, the host's
+                        // admission rules in the host's order (./uploadBytes.ts), then the
+                        // forced refusal standing in for the server persist + scan.
+                        const bytesReq = resolveUploadBytesRequest(typed.payload ?? {});
+                        if (bytesReq.kind !== 'none') {
+                            if (!isRoutableRequestId(requestId))
+                                return;
+                            const reply = (p) => dispatchToBlock({ type: 'IMAGE_UPLOAD_RESULT', payload: { requestId, ...p } });
+                            if (bytesReq.kind === 'invalid')
+                                return reply({ error: UPLOAD_BYTES_INVALID_ERROR });
+                            const admitted = admitUploadBytes(bytesReq, uploadBytesWindow, Date.now());
+                            uploadBytesWindow = admitted.recent;
+                            if (!admitted.result.ok)
+                                return reply({ error: admitted.result.error });
+                            if (uploadImageBytesError !== undefined)
+                                return reply({ error: uploadImageBytesError });
+                            // A COPY, as production's structured-clone `postMessage` delivers it.
+                            options.onUploadImageBytes?.({
+                                bytes: bytesReq.bytes.slice(0),
+                                mimeType: admitted.result.type,
+                                filename: admitted.result.filename,
+                            });
+                            postableImageIds.add(uploadImageBytesResult.imageId);
+                            return reply({ selected: { ...uploadImageBytesResult } });
+                        }
                         const isGenerationSource = typed.payload?.purpose === 'generationSource';
                         // NON-BLOCKING display path (asyncScan:true): early-resolve with a
                         // PENDING handle, then stream the canned scan verdict on a later tick.
@@ -2694,6 +2772,11 @@ export function createMockHost(options = {}) {
             runTrainingError = patch.runTrainingError;
         if ('saveImageError' in patch)
             saveImageError = patch.saveImageError;
+        if (patch.uploadImageBytesResult !== undefined) {
+            uploadImageBytesResult = patch.uploadImageBytesResult;
+        }
+        if ('uploadImageBytesError' in patch)
+            uploadImageBytesError = patch.uploadImageBytesError;
         if ('runTrainingCapRefusal' in patch)
             runTrainingCapRefusal = patch.runTrainingCapRefusal;
         if (patch.appWorkflows !== undefined) {

package/dist/internal/saveBytes.d.ts

@@ -47,6 +47,15 @@ export declare function saveImageRequestKind(p: {
 export type SaveBytesType = 'image/png' | 'image/webp' | 'image/jpeg' | 'application/json' | 'text/plain';
 /** The extension the host forces for each classified type. */
 export declare const SAVE_BYTES_EXTENSION: Record<SaveBytesType, string>;
+/** The three image types the host recognises by magic bytes. */
+export type SniffedImageType = 'image/png' | 'image/webp' | 'image/jpeg';
+/**
+ * PNG / WebP / JPEG by magic bytes — the host's shared sniffer
+ * (`sniffSaveBytesImage`: the full 8-byte PNG signature, no GIF). Both `bytes`
+ * bridges use it: `SAVE_IMAGE` before its text fallback, and
+ * `OPEN_IMAGE_UPLOAD`, which accepts images only.
+ */
+export declare function sniffImageBytes(view: Uint8Array): SniffedImageType | null;
 /**
  * Classify a `bytes` payload by CONTENT — the host's `classifySaveBytes`.
  * `filename` is the only hint and must already be CLEANED

package/dist/internal/saveBytes.js

@@ -73,6 +73,21 @@ const PNG = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
 const JPEG = [0xff, 0xd8, 0xff];
 const RIFF = [0x52, 0x49, 0x46, 0x46]; // "RIFF"
 const WEBP = [0x57, 0x45, 0x42, 0x50]; // "WEBP" at offset 8
+/**
+ * PNG / WebP / JPEG by magic bytes — the host's shared sniffer
+ * (`sniffSaveBytesImage`: the full 8-byte PNG signature, no GIF). Both `bytes`
+ * bridges use it: `SAVE_IMAGE` before its text fallback, and
+ * `OPEN_IMAGE_UPLOAD`, which accepts images only.
+ */
+export function sniffImageBytes(view) {
+    if (startsWith(view, PNG))
+        return 'image/png';
+    if (startsWith(view, RIFF) && startsWith(view, WEBP, 8))
+        return 'image/webp';
+    if (startsWith(view, JPEG))
+        return 'image/jpeg';
+    return null;
+}
 /**
  * Classify a `bytes` payload by CONTENT — the host's `classifySaveBytes`.
  * `filename` is the only hint and must already be CLEANED
@@ -83,12 +98,9 @@ const WEBP = [0x57, 0x45, 0x42, 0x50]; // "WEBP" at offset 8
  */
 export function classifySaveBytes(bytes, filename = '') {
     const view = new Uint8Array(bytes);
-    if (startsWith(view, PNG))
-        return 'image/png';
-    if (startsWith(view, RIFF) && startsWith(view, WEBP, 8))
-        return 'image/webp';
-    if (startsWith(view, JPEG))
-        return 'image/jpeg';
+    const image = sniffImageBytes(view);
+    if (image)
+        return image;
     if (view.includes(0))
         return null;
     let text;

package/dist/internal/uploadBytes.d.ts

@@ -0,0 +1,89 @@
+/**
+ * The `bytes` variant of `OPEN_IMAGE_UPLOAD`: the strings both sides of the
+ * bridge agree on, and the mock host's copy of the host's admission rules.
+ *
+ * The contract is civitai/civitai#5639 (`imageUploadBytes.ts` in the host). The
+ * host owns the real rules. This copy exists so `createMockHost` (and so
+ * `dev:harness` and every block test) accepts and refuses the same buffers
+ * production does. Keep it exactly as narrow as the contract: a mock that
+ * accepts a GIF teaches a block that GIFs upload.
+ */
+import { type SniffedImageType } from './saveBytes.js';
+/**
+ * The cap on one `bytes` upload: 40 MiB of raw bytes (`ArrayBuffer.byteLength`).
+ *
+ * 🔴 The host spells its OWN copy of this number (civitai/civitai
+ * `BLOCK_IMAGE_MAX_BYTES`, the image pipeline's server cap), and the two MUST
+ * match. Nothing in this repository can read the host's value, so a drift is
+ * invisible here until a block hits the host's refusal on a buffer this hook let
+ * through, or the hook refuses one the host would have accepted. Kept local to
+ * this package (not exported from `@civitai/app-sdk`) so the hook needs no newer
+ * app-sdk peer.
+ */
+export declare const UPLOAD_BYTES_MAX_BYTES: number;
+/** The host's rolling window: at most this many admitted uploads… */
+export declare const UPLOAD_BYTES_MAX_PER_WINDOW = 3;
+/** …and this many admitted bytes… */
+export declare const UPLOAD_BYTES_MAX_BYTES_PER_WINDOW: number;
+/** …per this many milliseconds, per mounted page host. */
+export declare const UPLOAD_BYTES_WINDOW_MS = 60000;
+/** Not a non-empty `ArrayBuffer`, or `purpose: 'generationSource'` with `bytes`. */
+export declare const UPLOAD_BYTES_INVALID_ERROR = "invalid image-upload request";
+/** Over {@link UPLOAD_BYTES_MAX_BYTES}. Also the hook's own pre-send refusal. */
+export declare const UPLOAD_BYTES_TOO_LARGE_ERROR = "file exceeds the maximum upload size";
+/** Not PNG / WebP / JPEG by magic bytes. */
+export declare const UPLOAD_BYTES_TYPE_NOT_ALLOWED_ERROR = "file type is not allowed";
+/** The host's rolling window is full. Retryable. */
+export declare const UPLOAD_BYTES_BUSY_ERROR = "busy";
+/** The host holds no block token. */
+export declare const UPLOAD_BYTES_NO_TOKEN_ERROR = "no block token";
+/** One admitted upload in the window: when, and how many bytes. */
+export type UploadBytesWindowEntry = {
+    at: number;
+    size: number;
+};
+/**
+ * Which `OPEN_IMAGE_UPLOAD` variant a raw payload is, by the host's predicate
+ * (`resolveImageUploadBytes`). `none`: no `bytes` (null or absent), so the
+ * picker paths run unchanged. `invalid`: `bytes` is not an `ArrayBuffer` (a
+ * typed-array view is refused, not unwrapped), is empty, or comes with
+ * `purpose: 'generationSource'`.
+ */
+export declare function resolveUploadBytesRequest(raw: {
+    bytes?: unknown;
+    purpose?: unknown;
+    filename?: unknown;
+}): {
+    kind: 'none';
+} | {
+    kind: 'invalid';
+} | {
+    kind: 'bytes';
+    bytes: ArrayBuffer;
+    filename?: string;
+};
+/**
+ * The host's admission decision (`processUploadBytes`), in its order:
+ *   1. the per-file cap, FIRST, so an over-cap file is always too large and
+ *      never `busy` (a retry could never succeed);
+ *   2. the window, NOT recording, so a full window refuses `busy` before any
+ *      sniffing;
+ *   3. PNG / WebP / JPEG by magic bytes;
+ *   4. record the upload in the window. Only an upload that will run counts.
+ * Returns the pruned window to store back.
+ */
+export declare function admitUploadBytes(req: {
+    bytes: ArrayBuffer;
+    filename?: string;
+}, recent: readonly UploadBytesWindowEntry[], now: number): {
+    result: {
+        ok: true;
+        type: SniffedImageType;
+        filename: string;
+    } | {
+        ok: false;
+        error: string;
+    };
+    recent: UploadBytesWindowEntry[];
+};
+//# sourceMappingURL=uploadBytes.d.ts.map

package/dist/internal/uploadBytes.js

@@ -0,0 +1,102 @@
+/**
+ * The `bytes` variant of `OPEN_IMAGE_UPLOAD`: the strings both sides of the
+ * bridge agree on, and the mock host's copy of the host's admission rules.
+ *
+ * The contract is civitai/civitai#5639 (`imageUploadBytes.ts` in the host). The
+ * host owns the real rules. This copy exists so `createMockHost` (and so
+ * `dev:harness` and every block test) accepts and refuses the same buffers
+ * production does. Keep it exactly as narrow as the contract: a mock that
+ * accepts a GIF teaches a block that GIFs upload.
+ */
+import { forceSaveBytesExtension, sanitizeSaveBytesFilename, sniffImageBytes, } from './saveBytes.js';
+/**
+ * The cap on one `bytes` upload: 40 MiB of raw bytes (`ArrayBuffer.byteLength`).
+ *
+ * 🔴 The host spells its OWN copy of this number (civitai/civitai
+ * `BLOCK_IMAGE_MAX_BYTES`, the image pipeline's server cap), and the two MUST
+ * match. Nothing in this repository can read the host's value, so a drift is
+ * invisible here until a block hits the host's refusal on a buffer this hook let
+ * through, or the hook refuses one the host would have accepted. Kept local to
+ * this package (not exported from `@civitai/app-sdk`) so the hook needs no newer
+ * app-sdk peer.
+ */
+export const UPLOAD_BYTES_MAX_BYTES = 40 * 1024 * 1024;
+/** The host's rolling window: at most this many admitted uploads… */
+export const UPLOAD_BYTES_MAX_PER_WINDOW = 3;
+/** …and this many admitted bytes… */
+export const UPLOAD_BYTES_MAX_BYTES_PER_WINDOW = 2 * UPLOAD_BYTES_MAX_BYTES;
+/** …per this many milliseconds, per mounted page host. */
+export const UPLOAD_BYTES_WINDOW_MS = 60_000;
+/** Not a non-empty `ArrayBuffer`, or `purpose: 'generationSource'` with `bytes`. */
+export const UPLOAD_BYTES_INVALID_ERROR = 'invalid image-upload request';
+/** Over {@link UPLOAD_BYTES_MAX_BYTES}. Also the hook's own pre-send refusal. */
+export const UPLOAD_BYTES_TOO_LARGE_ERROR = 'file exceeds the maximum upload size';
+/** Not PNG / WebP / JPEG by magic bytes. */
+export const UPLOAD_BYTES_TYPE_NOT_ALLOWED_ERROR = 'file type is not allowed';
+/** The host's rolling window is full. Retryable. */
+export const UPLOAD_BYTES_BUSY_ERROR = 'busy';
+/** The host holds no block token. */
+export const UPLOAD_BYTES_NO_TOKEN_ERROR = 'no block token';
+/** `Image.name`'s bound in the host's persist input. */
+const UPLOAD_BYTES_MAX_FILENAME_LENGTH = 255;
+/**
+ * Which `OPEN_IMAGE_UPLOAD` variant a raw payload is, by the host's predicate
+ * (`resolveImageUploadBytes`). `none`: no `bytes` (null or absent), so the
+ * picker paths run unchanged. `invalid`: `bytes` is not an `ArrayBuffer` (a
+ * typed-array view is refused, not unwrapped), is empty, or comes with
+ * `purpose: 'generationSource'`.
+ */
+export function resolveUploadBytesRequest(raw) {
+    if (raw.bytes == null)
+        return { kind: 'none' };
+    if (!(raw.bytes instanceof ArrayBuffer) || raw.bytes.byteLength === 0)
+        return { kind: 'invalid' };
+    if (raw.purpose === 'generationSource')
+        return { kind: 'invalid' };
+    return {
+        kind: 'bytes',
+        bytes: raw.bytes,
+        filename: typeof raw.filename === 'string' ? raw.filename : undefined,
+    };
+}
+function windowHasRoom(live, size) {
+    const total = live.reduce((sum, e) => sum + e.size, 0);
+    return live.length < UPLOAD_BYTES_MAX_PER_WINDOW && total + size <= UPLOAD_BYTES_MAX_BYTES_PER_WINDOW;
+}
+/** The host's stored name: the save-bytes cleaning, the sniffed extension, then 255 characters. */
+function uploadBytesFilename(raw, type) {
+    const name = forceSaveBytesExtension(sanitizeSaveBytesFilename(raw), type);
+    if (name.length <= UPLOAD_BYTES_MAX_FILENAME_LENGTH)
+        return name;
+    const ext = name.slice(name.lastIndexOf('.'));
+    return name.slice(0, UPLOAD_BYTES_MAX_FILENAME_LENGTH - ext.length) + ext;
+}
+/**
+ * The host's admission decision (`processUploadBytes`), in its order:
+ *   1. the per-file cap, FIRST, so an over-cap file is always too large and
+ *      never `busy` (a retry could never succeed);
+ *   2. the window, NOT recording, so a full window refuses `busy` before any
+ *      sniffing;
+ *   3. PNG / WebP / JPEG by magic bytes;
+ *   4. record the upload in the window. Only an upload that will run counts.
+ * Returns the pruned window to store back.
+ */
+export function admitUploadBytes(req, recent, now) {
+    const size = req.bytes.byteLength;
+    const live = recent.filter((e) => now - e.at < UPLOAD_BYTES_WINDOW_MS);
+    if (size > UPLOAD_BYTES_MAX_BYTES) {
+        return { result: { ok: false, error: UPLOAD_BYTES_TOO_LARGE_ERROR }, recent: live };
+    }
+    if (!windowHasRoom(live, size)) {
+        return { result: { ok: false, error: UPLOAD_BYTES_BUSY_ERROR }, recent: live };
+    }
+    const type = sniffImageBytes(new Uint8Array(req.bytes));
+    if (!type) {
+        return { result: { ok: false, error: UPLOAD_BYTES_TYPE_NOT_ALLOWED_ERROR }, recent: live };
+    }
+    return {
+        result: { ok: true, type, filename: uploadBytesFilename(req.filename, type) },
+        recent: [...live, { at: now, size }],
+    };
+}
+//# sourceMappingURL=uploadBytes.js.map

package/dist/transport/validate.d.ts

@@ -248,6 +248,7 @@ export declare function isValidImageUploadResult(p: unknown): p is {
         imageId: number;
         url: string;
     };
+    error?: string;
 };
 /**
  * Host→block `IMAGE_SCAN_RESOLVED` — the async scan verdict for a pending

package/dist/transport/validate.js

@@ -657,6 +657,13 @@ export function isValidImageUploadResult(p) {
         return false;
     if (!isWireRequestIdShape(p.requestId))
         return false;
+    // `error` (civitai/civitai#5639): a refused or failed `OPEN_IMAGE_UPLOAD
+    // { bytes }`. Free text (host strings plus forwarded server messages), so
+    // only its TYPE is checked. 🔴 Accepting it is load-bearing: a validator that
+    // dropped `{ requestId, error }` would leave `useUploadImageBytes()` waiting
+    // out its whole timeout on a refusal the host already sent.
+    if (p.error !== undefined && typeof p.error !== 'string')
+        return false;
     // `selected` absent → cancelled upload (valid). When present, it must match
     // one of the purpose-keyed shapes (moderated / generationSource / pending).
     if (p.selected !== undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@civitai/blocks-react",
-  "version": "0.66.0",
+  "version": "0.67.0",
   "description": "React hooks and iframe transport for Civitai Apps. Pairs with @civitai/app-sdk/blocks.",
   "license": "MIT",
   "type": "module",
@@ -58,7 +58,7 @@
     "typescript": "^5.9.2",
     "vite": "^8.0.14",
     "vitest": "^4.1.11",
-    "@civitai/app-sdk": "^0.61.0"
+    "@civitai/app-sdk": "^0.62.0"
   },
   "publishConfig": {
     "access": "public"