dsh-comfyui 0.3.0-beta.2 → 0.3.0-beta.4

package/lib/comfyui.d.ts

@@ -101,11 +101,31 @@ export declare class ComfyUIClient {
     private endpoint;
     private request;
     /** Upload a file (multipart body forwarded verbatim) into ComfyUI's input directory. */
+    /** Forward a multipart/form-data upload body verbatim (the browser's own
+     * form, field "image", as ComfyUI's /upload/image expects it). */
     uploadFile(body: Uint8Array, contentType: string): Promise<{
         name?: string;
         subfolder?: string;
         type?: string;
     }>;
+    /**
+     * Put one file into ComfyUI's input directory (images, video, audio alike).
+     *
+     * /upload/image only accepts multipart/form-data: posting the bytes as a
+     * raw body with their own content-type answers HTTP 400, which is why
+     * picking a generated file into the load area used to fail instead of
+     * copying it. The form is built here so callers can pass plain bytes.
+     * `overwrite` keeps a repeated pick from piling up "name (1).png" copies.
+     */
+    uploadMedia(bytes: Uint8Array, filename: string, contentType: string, opts?: {
+        overwrite?: boolean;
+        subfolder?: string;
+        timeoutMs?: number;
+    }): Promise<{
+        name?: string;
+        subfolder?: string;
+        type?: string;
+    }>;
     /** Queue one API-format workflow and return its prompt id. */
     queuePrompt(workflow: unknown, options?: {
         promptId?: string;
@@ -182,12 +202,24 @@ export declare class ComfyUIClient {
 export declare function hasMedia(entry: ComfyUIHistoryEntry): boolean;
 /** Compose a readable failure message from history status messages. */
 export declare function historyErrorMessage(promptId: string, entry: ComfyUIHistoryEntry): string;
+/**
+ * Build the same-origin proxy URL for one media file.
+ *
+ * The file is addressed by its own name/subfolder/type rather than by
+ * prompt+node+index: the latter has to be resolved through ComfyUI's
+ * /history, which lives in memory and is dropped on server restart or a
+ * "clear history" click — after which every stored asset URL 404s even though
+ * the file is still sitting in the output directory. Addressing the file
+ * directly keeps old assets viewable for as long as the file exists.
+ */
+export declare function mediaProxyUrl(ref: ComfyUIMediaRef, proxyBase?: string): string;
 /**
  * Collect media items from a completed history entry, in node/output order,
  * capped by maxItems. The URL is the same-origin proxy route when a web
- * server is present, otherwise a ComfyUI /view URL (for headless hosts).
+ * server is present, otherwise the bare filename (for headless hosts).
  */
 export declare function collectMedia(opts: {
+    /** The run these outputs belong to; kept for call-site clarity and logging. */
     promptId: string;
     entry: ComfyUIHistoryEntry;
     maxItems: number;

package/lib/comfyui.js

@@ -104,6 +104,8 @@ export class ComfyUIClient {
         }
     }
     /** Upload a file (multipart body forwarded verbatim) into ComfyUI's input directory. */
+    /** Forward a multipart/form-data upload body verbatim (the browser's own
+     * form, field "image", as ComfyUI's /upload/image expects it). */
     async uploadFile(body, contentType) {
         const data = await this.request('/upload/image', {
             method: 'POST',
@@ -112,6 +114,25 @@ export class ComfyUIClient {
         });
         return data ?? {};
     }
+    /**
+     * Put one file into ComfyUI's input directory (images, video, audio alike).
+     *
+     * /upload/image only accepts multipart/form-data: posting the bytes as a
+     * raw body with their own content-type answers HTTP 400, which is why
+     * picking a generated file into the load area used to fail instead of
+     * copying it. The form is built here so callers can pass plain bytes.
+     * `overwrite` keeps a repeated pick from piling up "name (1).png" copies.
+     */
+    async uploadMedia(bytes, filename, contentType, opts = {}) {
+        const form = new FormData();
+        form.append('image', new Blob([bytes], { type: contentType !== '' ? contentType : 'application/octet-stream' }), filename);
+        form.append('overwrite', opts.overwrite === false ? 'false' : 'true');
+        if (opts.subfolder !== undefined && opts.subfolder !== '')
+            form.append('subfolder', opts.subfolder);
+        // Video files are large; the connect timeout is far too tight for them.
+        const data = await this.request('/upload/image', { method: 'POST', body: form }, opts.timeoutMs ?? Math.max(this.connectTimeoutMs, 120_000));
+        return data ?? {};
+    }
     /** Queue one API-format workflow and return its prompt id. */
     async queuePrompt(workflow, options = {}) {
         const payload = { prompt: workflow, client_id: CLIENT_ID };
@@ -353,13 +374,27 @@ export function historyErrorMessage(promptId, entry) {
     }
     return `ComfyUI execution failed (prompt ${promptId}): ${details.join('; ') || 'unknown error'}`;
 }
+/**
+ * Build the same-origin proxy URL for one media file.
+ *
+ * The file is addressed by its own name/subfolder/type rather than by
+ * prompt+node+index: the latter has to be resolved through ComfyUI's
+ * /history, which lives in memory and is dropped on server restart or a
+ * "clear history" click — after which every stored asset URL 404s even though
+ * the file is still sitting in the output directory. Addressing the file
+ * directly keeps old assets viewable for as long as the file exists.
+ */
+export function mediaProxyUrl(ref, proxyBase) {
+    const query = new URLSearchParams({ file: ref.filename, subfolder: ref.subfolder ?? '', type: ref.type ?? 'output' });
+    return `${proxyBase ?? ''}/comfyui/media?${query.toString()}`;
+}
 /**
  * Collect media items from a completed history entry, in node/output order,
  * capped by maxItems. The URL is the same-origin proxy route when a web
- * server is present, otherwise a ComfyUI /view URL (for headless hosts).
+ * server is present, otherwise the bare filename (for headless hosts).
  */
 export function collectMedia(opts) {
-    const { promptId, entry, maxItems, proxyBase } = opts;
+    const { entry, maxItems, proxyBase } = opts;
     const items = [];
     const AUDIO_EXT = /\.(mp3|wav|ogg|flac|m4a|aac|opus)$/i;
     const VIDEO_EXT = /\.(mp4|webm|mov|mkv|avi)$/i;
@@ -377,13 +412,12 @@ export function collectMedia(opts) {
                 // Some nodes emit audio/video filenames through the image/video
                 // arrays; classify them by extension so the card renders a player.
                 const itemKind = AUDIO_EXT.test(ref.filename) ? 'audio' : VIDEO_EXT.test(ref.filename) ? 'video' : kind;
-                const query = new URLSearchParams({ prompt: promptId, node, index: String(index) });
                 items.push({
                     ...ref,
                     node,
                     index,
                     kind: itemKind,
-                    url: proxyBase !== undefined ? `${proxyBase}/comfyui/media?${query.toString()}` : ref.filename,
+                    url: proxyBase !== undefined ? mediaProxyUrl(ref, proxyBase) : ref.filename,
                 });
             }
         }

package/lib/config.d.ts

@@ -25,6 +25,11 @@ export declare const Config: z<Schemastery.ObjectS<{
     maxAssets: z<number, number>;
     /** External base URL for generated media (e.g. http://192.168.1.5:3080). Empty = auto-detect the browser's request host, then http://127.0.0.1:<webServerPort>. */
     mediaHost: z<string, string>;
+    /** ComfyUI's output directory on this machine, used to delete asset files
+     * from the panel. Empty = infer it from the file paths ComfyUI reports;
+     * deletion falls back to removing the index record when neither works
+     * (e.g. a ComfyUI running on another host). */
+    outputDir: z<string, string>;
 }>, Schemastery.ObjectT<{
     /** ComfyUI HTTP server base URL. */
     baseUrl: z<string, string>;
@@ -46,6 +51,11 @@ export declare const Config: z<Schemastery.ObjectS<{
     maxAssets: z<number, number>;
     /** External base URL for generated media (e.g. http://192.168.1.5:3080). Empty = auto-detect the browser's request host, then http://127.0.0.1:<webServerPort>. */
     mediaHost: z<string, string>;
+    /** ComfyUI's output directory on this machine, used to delete asset files
+     * from the panel. Empty = infer it from the file paths ComfyUI reports;
+     * deletion falls back to removing the index record when neither works
+     * (e.g. a ComfyUI running on another host). */
+    outputDir: z<string, string>;
 }>>;
 export type Config = {
     /** ComfyUI HTTP server base URL. */
@@ -68,4 +78,6 @@ export type Config = {
     maxAssets: number;
     /** External base URL for generated media; empty auto-detects the request host. */
     mediaHost: string;
+    /** ComfyUI's output directory on this machine; empty infers it from reported file paths. */
+    outputDir: string;
 };

package/lib/config.js

@@ -25,4 +25,9 @@ export const Config = z.object({
     maxAssets: z.number().min(1).max(10_000).default(200),
     /** External base URL for generated media (e.g. http://192.168.1.5:3080). Empty = auto-detect the browser's request host, then http://127.0.0.1:<webServerPort>. */
     mediaHost: z.string().default(''),
+    /** ComfyUI's output directory on this machine, used to delete asset files
+     * from the panel. Empty = infer it from the file paths ComfyUI reports;
+     * deletion falls back to removing the index record when neither works
+     * (e.g. a ComfyUI running on another host). */
+    outputDir: z.string().default(''),
 });

package/lib/index.js

@@ -77,6 +77,7 @@ export async function apply(ctx, entryConfig) {
         dataDir: entryConfig.dataDir !== undefined && entryConfig.dataDir !== '' ? entryConfig.dataDir : defaultDataDir(),
         maxAssets: entryConfig.maxAssets ?? 200,
         mediaHost: entryConfig.mediaHost ?? '',
+        outputDir: entryConfig.outputDir ?? '',
     };
     const store = new ComfyUIStore(resolved.dataDir, resolved.maxAssets);
     await store.init();
@@ -146,8 +147,9 @@ export async function apply(ctx, entryConfig) {
             let prompt = workflow;
             if (meta.parameters !== undefined && meta.parameters.length > 0) {
                 const objectInfo = await objectInfoCached(client);
-                const current = await store.loadCurrentImage();
-                prompt = applyWorkflowParameters(prompt, meta.parameters, meta.values ?? {}, objectInfo, await store.loadMediaSizes(), current?.name);
+                const slots = await store.loadSlots();
+                const loaded = slots.filter((slot) => slot !== null);
+                prompt = applyWorkflowParameters(prompt, meta.parameters, meta.values ?? {}, objectInfo, await store.loadMediaSizes(), loaded);
             }
             const extraData = {};
             if (meta.workflowId !== undefined && meta.workflowId !== null && meta.workflowName !== null) {
@@ -169,9 +171,10 @@ export async function apply(ctx, entryConfig) {
         saveMediaSize: (name, size) => store.saveMediaSize(name, size),
         lookupMediaHash: (hash) => store.lookupMediaHash(hash),
         saveMediaHash: (hash, name) => store.saveMediaHash(hash, name),
-        loadCurrentImage: () => store.loadCurrentImage(),
-        saveCurrentImage: (image) => store.saveCurrentImage(image),
+        loadSlots: () => store.loadSlots(),
+        saveSlots: (slots) => store.saveSlots(slots),
         listAssets: () => store.listAssets(),
+        deleteAsset: (promptId) => store.deleteAsset(promptId),
         sweep: async () => {
             const client = runtime.createClient(await resolveApiKey(ctx, resolved.apiKeyEnv));
             return tracker.sweep({ client, store, maxItems: resolved.maxMediaItems, proxyBase: runtime.proxyBase() });

package/lib/params.d.ts

@@ -16,6 +16,17 @@ export interface WorkflowParameter {
     description?: string;
     /** Number parameters (seeds): randomize on every run when true. */
     random?: boolean;
+    /** Number parameters: the numeric type object_info declares for the input.
+     * 'int' is rounded on apply; 'float' takes decimals. Absent means the
+     * declaration was unavailable (no object_info, unregistered node, ambiguous
+     * union type) — decimals are then accepted as-is, since a float value is
+     * the safe superset. */
+    numberKind?: 'int' | 'float';
+    /** Declared numeric bounds and step from object_info (editor hints only —
+     * values are not clamped, ComfyUI validates them at queue time). */
+    min?: number;
+    max?: number;
+    step?: number;
     /** Allowed values when the node input is a dropdown (object_info combo). */
     options?: Array<string | number>;
     /** Loader-node inputs (LoadImage/LoadVideo/LoadAudio): the value is a
@@ -38,6 +49,20 @@ export type { Workflow };
  * list and whose key name is loader-shaped. Returns the upload kind.
  */
 export declare function uploadKindOf(objectInfo: Record<string, unknown> | undefined, classType: string, inputKey: string): 'image' | 'video' | 'audio' | undefined;
+/** The numeric type and bounds object_info declares for an input, if any.
+ *
+ * ComfyUI writes `["INT", {default,min,max,...}]` / `["FLOAT", {..., step,
+ * round}]`, and a few nodes use decorated or union type names (`"INT:seed"`,
+ * `"INT,FLOAT"`). A union that admits FLOAT is reported as float, because a
+ * float value is accepted wherever an int one is but not the reverse.
+ * Everything else returns undefined: the caller then treats the parameter as
+ * an unconstrained number (decimals allowed, no rounding). */
+export declare function numberSpecOf(objectInfo: Record<string, unknown> | undefined, classType: string, inputKey: string): {
+    kind: 'int' | 'float';
+    min?: number;
+    max?: number;
+    step?: number;
+} | undefined;
 /** The object_info input spec for one input name of a node class, if declared. */
 export declare function inputOptions(objectInfo: Record<string, unknown> | undefined, classType: string, inputKey: string): Array<string | number> | undefined;
 /** Full child info (key, options, default) for one selected DynamicCombo parent value. */
@@ -60,4 +85,7 @@ export declare function analyzeWorkflowParameters(workflow: Workflow, objectInfo
 export declare function applyWorkflowParameters(workflow: Workflow, parameters: WorkflowParameter[], values: Record<string, unknown>, objectInfo?: Record<string, unknown>, imageSizes?: Record<string, {
     width: number;
     height: number;
-}>, defaultImage?: string): Workflow;
+}>, loadArea?: Array<{
+    name: string;
+    kind: 'image' | 'video' | 'audio';
+}>): Workflow;

package/lib/params.js

@@ -24,6 +24,28 @@ const TEXT_KEYS = new Set(['text', 'value', 'prompt']);
 function isPrimitive(value) {
     return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
 }
+/** Read a boolean parameter's value, accepting the string and 0/1 spellings.
+ *
+ * A boolean default authored before the panel had a checkbox was stored as a
+ * string ("true"), and an agent may pass "false" or 0 just as readily. Writing
+ * any of those into a BOOLEAN node input would make ComfyUI reject the prompt
+ * (and "false" would read as truthy), so they are normalized here; anything
+ * that is not a recognized spelling returns undefined and the input keeps its
+ * authored value. */
+function coerceBoolean(value) {
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number')
+        return value === 1 ? true : value === 0 ? false : undefined;
+    if (typeof value !== 'string')
+        return undefined;
+    const text = value.trim().toLowerCase();
+    if (text === 'true' || text === '1' || text === 'yes' || text === 'on')
+        return true;
+    if (text === 'false' || text === '0' || text === 'no' || text === 'off')
+        return false;
+    return undefined;
+}
 /** Parse a media-state JSON array (MiniMaxH3 loader media_state); undefined when not one. */
 function parseMediaState(raw) {
     try {
@@ -80,6 +102,45 @@ function displayName(workflow, nodeId, inputKey) {
         return inputKey === 'value' ? '文本' : '提示词';
     return `${node.class_type} · ${inputKey}`;
 }
+/** The raw object_info spec tuple for one input of a node class. */
+function inputSpec(objectInfo, classType, inputKey) {
+    if (objectInfo === undefined)
+        return undefined;
+    const def = objectInfo[classType];
+    const spec = def?.input?.required?.[inputKey] ?? def?.input?.optional?.[inputKey];
+    return Array.isArray(spec) ? spec : undefined;
+}
+/** The numeric type and bounds object_info declares for an input, if any.
+ *
+ * ComfyUI writes `["INT", {default,min,max,...}]` / `["FLOAT", {..., step,
+ * round}]`, and a few nodes use decorated or union type names (`"INT:seed"`,
+ * `"INT,FLOAT"`). A union that admits FLOAT is reported as float, because a
+ * float value is accepted wherever an int one is but not the reverse.
+ * Everything else returns undefined: the caller then treats the parameter as
+ * an unconstrained number (decimals allowed, no rounding). */
+export function numberSpecOf(objectInfo, classType, inputKey) {
+    const spec = inputSpec(objectInfo, classType, inputKey);
+    if (spec === undefined)
+        return undefined;
+    const typeName = spec[0];
+    if (typeof typeName !== 'string')
+        return undefined;
+    // "INT:seed" → INT; "INT,FLOAT" → the union members.
+    const names = typeName.split(',').map((name) => name.split(':')[0]?.trim().toUpperCase() ?? '');
+    const hasFloat = names.includes('FLOAT');
+    const hasInt = names.includes('INT');
+    if (!hasFloat && !hasInt)
+        return undefined;
+    const meta = spec[1];
+    const flags = meta !== null && typeof meta === 'object' ? meta : {};
+    const numberOf = (value) => typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+    return {
+        kind: hasFloat ? 'float' : 'int',
+        min: numberOf(flags.min),
+        max: numberOf(flags.max),
+        step: numberOf(flags.step),
+    };
+}
 /** The object_info input spec for one input name of a node class, if declared. */
 export function inputOptions(objectInfo, classType, inputKey) {
     if (objectInfo === undefined)
@@ -249,6 +310,11 @@ export function analyzeWorkflowParameters(workflow, objectInfo) {
         const options = input.options ?? (input.classType !== undefined
             ? inputOptions(objectInfo, input.classType, input.inputKey)
             : undefined);
+        // Number inputs carry their declared INT/FLOAT type so the panel editor
+        // and the run path know whether decimals are allowed.
+        const numberSpec = input.type === 'number' && input.classType !== undefined
+            ? numberSpecOf(objectInfo, input.classType, input.inputKey)
+            : undefined;
         params.push({
             id: randomUUID(),
             name: uniqueName(input.name),
@@ -258,6 +324,10 @@ export function analyzeWorkflowParameters(workflow, objectInfo) {
             inputKey: input.inputKey,
             default: input.value,
             random: input.random,
+            numberKind: numberSpec?.kind,
+            min: numberSpec?.min,
+            max: numberSpec?.max,
+            step: numberSpec?.step,
             options,
             upload: input.upload,
             subfolder: input.subfolder,
@@ -365,16 +435,39 @@ export function analyzeWorkflowParameters(workflow, objectInfo) {
  * workflow. Unknown parameters are ignored; omitted ones fall back to the
  * parameter default. The input workflow is not mutated.
  */
-export function applyWorkflowParameters(workflow, parameters, values, objectInfo, imageSizes, defaultImage) {
+export function applyWorkflowParameters(workflow, parameters, values, objectInfo, imageSizes, loadArea) {
     const copy = structuredClone(workflow);
     let effectiveValues = values;
-    // The load-area selection is the default source image: when an image upload
-    // parameter is left unset, use it instead of the workflow's stored default.
-    if (defaultImage !== undefined && typeof defaultImage === 'string' && defaultImage !== '') {
-        const imageParam = parameters.find((param) => param.upload === 'image');
-        if (imageParam !== undefined && !Object.prototype.hasOwnProperty.call(effectiveValues, imageParam.name)) {
-            effectiveValues = { ...effectiveValues, [imageParam.name]: defaultImage };
+    // The load area supplies the default source media: each loader parameter
+    // left unset takes the next load-area slot of its own kind, in slot order
+    // (slot 1 → first image parameter, slot 2 → second, and so on). A workflow
+    // with a single image parameter therefore behaves exactly as it did when
+    // the load area held one file, and an explicit value always wins.
+    if (loadArea !== undefined && loadArea.length > 0) {
+        const queues = { image: [], video: [], audio: [] };
+        for (const slot of loadArea) {
+            if (typeof slot?.name === 'string' && slot.name !== '')
+                queues[slot.kind].push(slot.name);
+        }
+        const filled = { ...effectiveValues };
+        let used = false;
+        for (const param of parameters) {
+            const kind = param.upload;
+            if (kind !== 'image' && kind !== 'video' && kind !== 'audio')
+                continue;
+            if (Object.prototype.hasOwnProperty.call(effectiveValues, param.name))
+                continue;
+            // An audio parameter may also take a video slot: ComfyUI's LoadAudio
+            // accepts a video container and pulls its audio track, and the load
+            // area classifies an .mp4 as video.
+            const next = queues[kind].shift() ?? (kind === 'audio' ? queues.video.shift() : undefined);
+            if (next === undefined)
+                continue;
+            filled[param.name] = next;
+            used = true;
         }
+        if (used)
+            effectiveValues = filled;
     }
     // Auto-match the output size to the source image: when the effective source
     // image (explicit or load-area default) has a recorded pixel size but
@@ -421,8 +514,9 @@ export function applyWorkflowParameters(workflow, parameters, values, objectInfo
         const node = copy[param.nodeId];
         if (node === undefined)
             continue;
+        const explicit = Object.prototype.hasOwnProperty.call(effectiveValues, param.name);
         let value;
-        if (Object.prototype.hasOwnProperty.call(effectiveValues, param.name)) {
+        if (explicit) {
             value = effectiveValues[param.name];
         }
         else if (param.random === true && param.type === 'number') {
@@ -431,6 +525,31 @@ export function applyWorkflowParameters(workflow, parameters, values, objectInfo
         else {
             value = param.default;
         }
+        // A loader parameter with an empty default and nothing to fill it (no
+        // explicit value, no load-area slot of its kind) leaves the workflow's
+        // authored file name alone. Writing the empty default instead would clear
+        // the node's file input and the run would fail on a missing image.
+        // 'media' slots are exempt: there an empty value *means* "remove this
+        // reference slot", and they are merged back separately below.
+        if (!explicit && param.upload !== undefined && param.upload !== 'media' && value === '')
+            continue;
+        // A parameter exposed on a *linked* input (its authored value is a
+        // [nodeId, slot] reference, not a widget value) carries an empty default,
+        // because a link cannot be represented as one. Writing that default would
+        // sever the link on every run, so an omitted value leaves the link alone —
+        // only an explicit value replaces it.
+        if (!explicit && param.default === '' && !isPrimitive(node.inputs[param.inputKey]) && node.inputs[param.inputKey] !== undefined)
+            continue;
+        // INT inputs reject decimals at queue time; round rather than fail on a
+        // value like 20.5. The stored kind wins, but a workflow saved before the
+        // kind was recorded still gets it resolved from object_info here, so old
+        // libraries behave the same as freshly analyzed ones. An input whose type
+        // stays unknown is left exactly as the caller passed it.
+        if (param.type === 'number' && typeof value === 'number' && !Number.isInteger(value)) {
+            const kind = param.numberKind ?? numberSpecOf(objectInfo, node.class_type, param.inputKey)?.kind;
+            if (kind === 'int')
+                value = Math.round(value);
+        }
         const isComboChild = comboChildKeys.has(`${param.nodeId}:${param.inputKey}`);
         // Upload parameters accept any server-side filename (uploaded files, or
         // ComfyUI's "[output]"-annotated paths); options are only a reference list.
@@ -441,8 +560,12 @@ export function applyWorkflowParameters(workflow, parameters, values, objectInfo
             continue;
         if (param.type === 'number' && typeof value !== 'number')
             continue;
-        if (param.type === 'boolean' && typeof value !== 'boolean')
-            continue;
+        if (param.type === 'boolean' && typeof value !== 'boolean') {
+            const coerced = coerceBoolean(value);
+            if (coerced === undefined)
+                continue;
+            value = coerced;
+        }
         if (param.upload === 'media')
             continue; // merged back into the JSON array below
         node.inputs[param.inputKey] = value;

package/lib/proxy.js

@@ -63,11 +63,24 @@ export function mountComfyUIProxy(ctx, runtime) {
                     nodeOutput?.videos,
                     nodeOutput?.gifs,
                 ];
-                const ref = collections
+                let ref = collections
                     .flatMap((items) => items ?? [])[index];
                 if (ref === undefined) {
-                    sendJson(response, 404, { error: `no media item ${node}[${index}] for prompt ${prompt} (history may be evicted)` });
-                    return;
+                    // ComfyUI's /history is in-memory: a server restart or a "clear
+                    // history" click drops the entry and this lookup fails even though
+                    // the file is still on disk. The plugin's own asset index keeps the
+                    // file reference for every run it submitted, so fall back to it —
+                    // this is what keeps older chat cards (whose URLs were minted before
+                    // the proxy addressed files directly) from going blank.
+                    const archived = await runtime.listAssets();
+                    const item = archived
+                        .find((asset) => asset.promptId === prompt)
+                        ?.media.find((entry) => entry.node === node && entry.index === index);
+                    if (item === undefined) {
+                        sendJson(response, 404, { error: `no media item ${node}[${index}] for prompt ${prompt} (history evicted and not in the asset index)` });
+                        return;
+                    }
+                    ref = { filename: item.filename, subfolder: item.subfolder, type: item.type };
                 }
                 const { bytes, contentType } = await client.fetchView(ref);
                 response.writeHead(200, {