@fungi.computer/darkroom 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,607 @@
+import * as z from "zod";
+import { reportCatchFailure } from "./failure.js";
+import { getMediaModel, MediaSettingsError, mediaVideoModelIdSchema, mediaVideoResolutionSchema, mediaVideoAspectRatioSchema, mediaVideoReferenceRoleSchema, } from "./model-catalog.js";
+export { mediaFailureStageSchema } from "./execution-error.js";
+export { getMediaModel, listMediaModels, mediaModelInputSchema, mediaModelSchema, mediaRequestedImageFormatSchema, mediaModels, mediaModelTierSchema, MediaSettingsError, mediaVideoModelIdSchema, mediaVideoResolutionSchema, mediaVideoAspectRatioSchema, mediaVideoReferenceRoleSchema, mediaVideoFormatSchema, mediaVideoSchema, } from "./model-catalog.js";
+/** The long-edge bounds a viewer may ask for when fitting an image to look at. */
+export const MIN_VIEW_DIMENSION = 256;
+/** Maximum long-edge size accepted by an image viewer, in pixels. */
+export const MAX_VIEW_DIMENSION = 512;
+/** Decode a viewer long-edge size within the supported pixel bounds. */
+export const viewDimensionSchema = z.lazy(() => z.number().int().min(MIN_VIEW_DIMENSION).max(MAX_VIEW_DIMENSION));
+/** Maximum reference files in one generation request. */
+export const MAX_REFERENCE_COUNT = 4;
+/** Maximum reference width and height sent to inference, in pixels. */
+export const MAX_REFERENCE_DIMENSION = 512;
+/** Maximum decoded bytes per reference image. */
+export const MAX_REFERENCE_BYTES = 8 * 1024 * 1024;
+/** Maximum retained still-image output bytes. */
+export const MAX_OUTPUT_BYTES = 32 * 1024 * 1024;
+const requiredString = (value, name) => {
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+        throw new MediaSettingsError(`${name} must not be blank`);
+    return trimmed;
+};
+const boundedInteger = (value, name, minimum, maximum) => {
+    if (!Number.isSafeInteger(value) || value < minimum || value > maximum)
+        throw new MediaSettingsError(`${name} must be an integer from ${String(minimum)} through ${String(maximum)}`);
+    return value;
+};
+const normalizeReference = (value) => {
+    const reference = {
+        computerId: requiredString(value.computerId, "reference computerId"),
+        path: requiredString(value.path, "reference path"),
+    };
+    if (value.role === undefined)
+        return reference;
+    return { ...reference, role: value.role };
+};
+/** Structural wire grammar for one Media generation request. */
+export const mediaGenerationSettingsSchema = z
+    .object({
+    /** Provider catalog model identifier. */
+    model: z.string().min(1).max(256),
+    /** Generation prompt. */
+    prompt: z.string().min(1).max(2_048),
+    /** Requested image width or nominal video selector, not decoded MP4 dimensions. */
+    width: z.number().int().min(1).max(5_040),
+    /** Requested image height or nominal video selector, not decoded MP4 dimensions. */
+    height: z.number().int().min(1).max(5_040),
+    /** Model-specific inference step count. */
+    steps: z.number().int().optional(),
+    /** Requested video length in whole seconds. */
+    durationSeconds: z.number().int().optional(),
+    /** Video resolution; must match the nominal width/height selector. */
+    resolution: mediaVideoResolutionSchema.optional(),
+    /** Video aspect; must match the nominal width/height selector. */
+    aspectRatio: mediaVideoAspectRatioSchema.optional(),
+    /** Video audio selection. */
+    generateAudio: z.boolean().optional(),
+    /** Host-authorized reference images. */
+    references: z
+        .array(z
+        .object({
+        /** Host-admitted destination or reference identity. */
+        computerId: z.string().min(1).max(256),
+        /** Fixed destination or reference file path. */
+        path: z.string().min(1).max(4_096),
+        /** Video-only reference role. */
+        role: mediaVideoReferenceRoleSchema.optional(),
+    })
+        .strict())
+        .max(MAX_REFERENCE_COUNT)
+        .optional(),
+})
+    .strict();
+/** App selections contain paths; the host supplies the admitted Computer. */
+export const mediaGenerationSelectionSchema = mediaGenerationSettingsSchema.extend({
+    /** Host-authorized reference images. */
+    references: z
+        .array(z
+        .object({
+        /** Fixed destination or reference file path. */
+        path: z.string().min(1).max(4_096),
+        /** Video-only reference role. */
+        role: mediaVideoReferenceRoleSchema.optional(),
+    })
+        .strict())
+        .max(MAX_REFERENCE_COUNT)
+        .optional(),
+});
+/** Validate caller settings and apply retained model defaults. */
+export const validateMediaGenerationSettings = (raw) => {
+    const parsed = mediaGenerationSettingsSchema.safeParse(raw);
+    if (!parsed.success)
+        throw new MediaSettingsError("generation settings are invalid");
+    return normalizeGenerationSettings(parsed.data, normalizeReference);
+};
+/** Validate path-only selections without inventing a Computer identity. */
+export const validateMediaGenerationSelection = (raw) => {
+    const parsed = mediaGenerationSelectionSchema.safeParse(raw);
+    if (!parsed.success)
+        throw new MediaSettingsError("generation settings are invalid");
+    return normalizeGenerationSettings(parsed.data, (reference) => {
+        const selection = {
+            path: requiredString(reference.path, "reference path"),
+        };
+        if (reference.role === undefined)
+            return selection;
+        return { ...selection, role: reference.role };
+    });
+};
+function normalizeGenerationSettings(input, normalize) {
+    const modelId = requiredString(input.model, "model");
+    const model = getMediaModel(modelId);
+    if (model === undefined)
+        throw new MediaSettingsError(`unknown Media model "${modelId}"`);
+    const prompt = requiredString(input.prompt, "prompt");
+    const maximumDimension = model.video === null ? 4_096 : 5_040;
+    const width = boundedInteger(input.width, "width", 1, maximumDimension);
+    const height = boundedInteger(input.height, "height", 1, maximumDimension);
+    if (model.input.dimensions === "own" &&
+        (width < 256 ||
+            height < 256 ||
+            width > (model.input.maxDimension ?? 4_096) ||
+            height > (model.input.maxDimension ?? 4_096)))
+        throw new MediaSettingsError(`${model.id} accepts dimensions from 256 through ${String(model.input.maxDimension)}`);
+    if (model.sizes !== null &&
+        !model.sizes.includes(`${String(width)}x${String(height)}`))
+        throw new MediaSettingsError(`${model.id} accepts only these sizes: ${model.sizes.join(", ")}`);
+    let durationSeconds;
+    if (model.video === null) {
+        if (input.resolution !== undefined ||
+            input.aspectRatio !== undefined ||
+            input.generateAudio !== undefined ||
+            input.references?.some((reference) => reference.role !== undefined))
+            throw new MediaSettingsError(`${model.id} does not take video settings or frame roles`);
+        if (input.durationSeconds !== undefined)
+            throw new MediaSettingsError(`${model.id} does not take a duration`);
+    }
+    else {
+        durationSeconds = boundedInteger(input.durationSeconds ?? model.video.defaultSeconds, "durationSeconds", model.video.minSeconds, model.video.maxSeconds);
+        if (!model.video.durations.includes(durationSeconds))
+            throw new MediaSettingsError(`${model.id} accepts durationSeconds ${model.video.durations.join(", ")}`);
+        if (prompt.length > model.video.maxPromptLength)
+            throw new MediaSettingsError(`${model.id} prompt exceeds ${String(model.video.maxPromptLength)} characters`);
+    }
+    let steps;
+    if (input.steps !== undefined && model.input.steps === "fixed")
+        throw new MediaSettingsError(`${model.id} uses fixed steps and cannot be adjusted`);
+    if (input.steps !== undefined) {
+        steps = boundedInteger(input.steps, "steps", 1, Number.MAX_SAFE_INTEGER);
+        if (model.input.maxSteps !== null && steps > model.input.maxSteps)
+            throw new MediaSettingsError(`${model.id} accepts at most ${String(model.input.maxSteps)} steps`);
+    }
+    else if (model.input.steps !== "fixed" &&
+        model.input.defaultSteps !== null) {
+        steps = model.input.defaultSteps;
+    }
+    let references;
+    if (input.references !== undefined) {
+        if (input.references.length > model.input.maxReferences)
+            throw new MediaSettingsError(`${model.id} accepts at most ${String(model.input.maxReferences)} reference images`);
+        references = input.references.map(normalize);
+    }
+    const normalized = {
+        model: model.id,
+        prompt,
+        width,
+        height,
+    };
+    if (steps !== undefined)
+        normalized.steps = steps;
+    if (durationSeconds !== undefined)
+        normalized.durationSeconds = durationSeconds;
+    if (model.video !== null) {
+        const video = model.video;
+        const format = video.formats.find((candidate) => candidate.width === width && candidate.height === height);
+        if (format === undefined)
+            throw new MediaSettingsError("unsupported video size");
+        if ((input.resolution !== undefined &&
+            input.resolution !== format.resolution) ||
+            (input.aspectRatio !== undefined &&
+                input.aspectRatio !== format.aspectRatio))
+            throw new MediaSettingsError("video selectors must match nominal width and height");
+        normalized.resolution = format.resolution;
+        normalized.aspectRatio = format.aspectRatio;
+        const generateAudio = input.generateAudio ?? video.defaultGenerateAudio;
+        if (generateAudio !== null)
+            normalized.generateAudio = generateAudio;
+        if (references !== undefined) {
+            references = references.map((reference) => ({
+                ...reference,
+                role: reference.role ?? mediaVideoReferenceRoleSchema.enum.first,
+            }));
+            const roles = references.map((reference) => reference.role);
+            if (roles.some((role) => role === undefined || !video.referenceRoles.includes(role)))
+                throw new MediaSettingsError(`${model.id} does not accept this frame/reference role`);
+            const first = roles.filter((role) => role === "first-frame").length;
+            const last = roles.filter((role) => role === "last-frame").length;
+            const referenceCount = roles.filter((role) => role === "reference").length;
+            if (first > 1 ||
+                last > 1 ||
+                (last > 0 && first !== 1) ||
+                (referenceCount > 0 && first + last > 0))
+                throw new MediaSettingsError("video frame and reference modes cannot mix; last frame requires one first frame");
+            if (referenceCount > video.maxReferenceImages ||
+                (referenceCount > 0 &&
+                    !video.referenceResolutions.includes(format.resolution)))
+                throw new MediaSettingsError(`${model.id} does not accept reference-image mode at this resolution/count`);
+        }
+    }
+    if (references !== undefined)
+        normalized.references = Object.freeze(references);
+    return Object.freeze(normalized);
+}
+/** Path-only video reference; the host supplies authority and reads its bytes. */
+export const mediaVideoReferenceSchema = z.lazy(() => z.strictObject({
+    /** Selected image path, trimmed and nonblank after validation. */
+    path: z.string().min(1).max(4_096),
+    /** Explicit first frame, last frame, or reference-image role. */
+    role: mediaVideoReferenceRoleSchema,
+}));
+/** Neutral video selection; model-specific combinations are checked by validateMediaVideoSelection. */
+export const mediaVideoSelectionSchema = z.lazy(() => z.strictObject({
+    /** Verified catalog model identifier. */
+    model: mediaVideoModelIdSchema,
+    /** Trimmed prompt; Seedance allows 2,000 characters, Veo uses the retained host cap of 2,048. */
+    prompt: z.string().min(1).max(2_048),
+    /** Model-specific resolution, default 720p. */
+    resolution: mediaVideoResolutionSchema.optional(),
+    /** Model-specific aspect, default 16:9. */
+    aspectRatio: mediaVideoAspectRatioSchema.optional(),
+    /** Whole seconds; Seedance 4–12, Veo exactly 4/6/8, MiniMax H3 Max 5–15. */
+    durationSeconds: z.number().int().min(4).max(15).optional(),
+    /** Veo defaults true; Seedance omits the provider option when unset;
+     * MiniMax H3 Max has no audio field and refuses an explicit choice. */
+    generateAudio: z.boolean().optional(),
+    /** Up to four references, with provider-specific roles and mode limits. */
+    references: z
+        .array(mediaVideoReferenceSchema)
+        .max(MAX_REFERENCE_COUNT)
+        .optional(),
+}));
+/** Validate supported model/size/duration/reference combinations before authority or billing admission. */
+export function validateMediaVideoSelection(raw) {
+    const parsed = mediaVideoSelectionSchema.safeParse(raw);
+    if (!parsed.success)
+        throw new MediaSettingsError("video selection is invalid");
+    const input = parsed.data;
+    const model = getMediaModel(input.model);
+    if (model?.video == null)
+        throw new MediaSettingsError("unknown video model");
+    const resolution = input.resolution ?? model.video.defaultResolution;
+    const aspectRatio = input.aspectRatio ?? model.video.defaultAspectRatio;
+    const format = model.video.formats.find((candidate) => candidate.resolution === resolution &&
+        candidate.aspectRatio === aspectRatio);
+    if (format === undefined)
+        throw new MediaSettingsError(`${model.id} does not accept this resolution/aspect`);
+    const normalized = validateMediaGenerationSelection({
+        ...input,
+        width: format.width,
+        height: format.height,
+    });
+    const selection = {
+        ...format,
+        model: input.model,
+        prompt: normalized.prompt,
+        durationSeconds: normalized.durationSeconds ?? model.video.defaultSeconds,
+    };
+    if (normalized.generateAudio !== undefined)
+        selection.generateAudio = normalized.generateAudio;
+    if (normalized.references !== undefined)
+        selection.references = Object.freeze(normalized.references.map((reference) => Object.freeze(mediaVideoReferenceSchema.parse(reference))));
+    return Object.freeze(selection);
+}
+const imageFormats = new Set(["png", "jpeg", "gif", "webp"]);
+/** Resolve only provider-accepted references through the caller's reader. */
+export const resolveMediaReferences = async (settings, reader) => {
+    const model = getMediaModel(settings.model);
+    if (model === undefined)
+        throw new MediaSettingsError("unknown Media model");
+    const references = settings.references ?? [];
+    if (references.length > model.input.maxReferences)
+        throw new MediaSettingsError(`${model.id} accepts at most ${String(model.input.maxReferences)} reference images`);
+    const resolved = [];
+    for (const reference of references) {
+        const image = await reader.read(reference);
+        if (!imageFormats.has(image.format) ||
+            !Number.isSafeInteger(image.width) ||
+            !Number.isSafeInteger(image.height) ||
+            image.width < 1 ||
+            image.height < 1 ||
+            image.width > MAX_REFERENCE_DIMENSION ||
+            image.height > MAX_REFERENCE_DIMENSION ||
+            !(image.bytes instanceof Uint8Array) ||
+            image.bytes.byteLength === 0 ||
+            image.bytes.byteLength > MAX_REFERENCE_BYTES)
+            throw new MediaSettingsError(`reference ${reference.computerId}:${reference.path} exceeds the bounded image contract`);
+        resolved.push(Object.freeze({ ...image }));
+    }
+    return Object.freeze(resolved);
+};
+const mimeForFormat = (format) => `image/${format}`;
+/** Build the exact JSON or multipart payload required by a retained model. */
+export const buildProviderInput = (settings, references = []) => {
+    const model = getMediaModel(settings.model);
+    if (model === undefined)
+        throw new MediaSettingsError("unknown Media model");
+    if (model.sizes !== null)
+        throw new MediaSettingsError(`${model.id} runs through the AI Gateway`);
+    if (references.length > model.input.maxReferences)
+        throw new MediaSettingsError(`${model.id} accepts at most ${String(model.input.maxReferences)} reference images`);
+    if (model.input.referenceField === null && references.length > 0)
+        throw new MediaSettingsError(`${model.id} does not accept references`);
+    if (model.input.transport === "json") {
+        const body = {
+            prompt: settings.prompt,
+        };
+        if (model.input.dimensions === "own") {
+            body.width = settings.width;
+            body.height = settings.height;
+        }
+        if (settings.steps !== undefined && model.input.steps === "steps")
+            body.steps = settings.steps;
+        if (settings.steps !== undefined && model.input.steps === "num_steps")
+            body.num_steps = settings.steps;
+        return Object.freeze({
+            transport: "json",
+            body: Object.freeze(body),
+        });
+    }
+    const body = new FormData();
+    body.append("prompt", settings.prompt);
+    if (model.input.dimensions === "own") {
+        body.append("width", String(settings.width));
+        body.append("height", String(settings.height));
+    }
+    if (settings.steps !== undefined && model.input.steps === "steps")
+        body.append("steps", String(settings.steps));
+    references.forEach((reference, index) => {
+        body.append(`${model.input.referenceField ?? "input_image_"}${String(index)}`, new Blob([new Uint8Array(reference.bytes).buffer], {
+            type: mimeForFormat(reference.format),
+        }), reference.filename ?? `reference-${String(index)}`);
+    });
+    return Object.freeze({
+        transport: "multipart",
+        body,
+    });
+};
+const providerEntrySchema = z.lazy(() => z
+    .object({
+    /** Base64-encoded image data. */
+    base64: z.string().optional(),
+    /** Encoded inline image data. */
+    data: z.string().optional(),
+    /** HTTP provider output URL. */
+    url: z
+        .url()
+        .refine((value) => /^https?:\/\//iu.test(value), "provider image URLs must use HTTP(S)")
+        .optional(),
+})
+    .strict());
+const providerEnvelopeSchema = z.lazy(() => z.union([
+    z.object({
+        /** Encoded provider image. */
+        image: z.string().min(1),
+    }),
+    z.object({
+        /** Provider image entries. */
+        image: z.array(providerEntrySchema),
+    }),
+    z.object({
+        /** Provider output image entries. */
+        images: z.array(providerEntrySchema),
+    }),
+]));
+/** Decode the Workers AI binding's raw output at the provider boundary. */
+export const mediaProviderWireSchema = z.lazy(() => z.union([
+    providerEnvelopeSchema,
+    z.instanceof(Uint8Array),
+    z.instanceof(Response),
+    z.custom((value) => value instanceof ReadableStream),
+]));
+/** Parse the provider wire envelope before normalization. */
+export const parseMediaProviderOutput = (value) => {
+    if (value instanceof Uint8Array)
+        return {
+            kind: "bytes",
+            bytes: value,
+        };
+    if (value instanceof Response)
+        return {
+            kind: "response",
+            response: value,
+        };
+    if (value instanceof ReadableStream)
+        return {
+            kind: "response",
+            response: new Response(value),
+        };
+    const parsed = providerEnvelopeSchema.parse(value);
+    if ("image" in parsed)
+        return Array.isArray(parsed.image)
+            ? {
+                kind: "entries",
+                entries: parsed.image,
+            }
+            : {
+                kind: "encoded",
+                encoded: parsed.image,
+            };
+    return {
+        kind: "entries",
+        entries: parsed.images,
+    };
+};
+const sniffImageFormat = (bytes) => {
+    if (bytes.length >= 8 &&
+        bytes[0] === 0x89 &&
+        bytes[1] === 0x50 &&
+        bytes[2] === 0x4e &&
+        bytes[3] === 0x47 &&
+        bytes[4] === 0x0d &&
+        bytes[5] === 0x0a &&
+        bytes[6] === 0x1a &&
+        bytes[7] === 0x0a)
+        return "png";
+    if (bytes.length >= 3 &&
+        bytes[0] === 0xff &&
+        bytes[1] === 0xd8 &&
+        bytes[2] === 0xff)
+        return "jpeg";
+    if (bytes.length >= 6 &&
+        bytes[0] === 0x47 &&
+        bytes[1] === 0x49 &&
+        bytes[2] === 0x46 &&
+        bytes[3] === 0x38 &&
+        (bytes[4] === 0x37 || bytes[4] === 0x39) &&
+        bytes[5] === 0x61)
+        return "gif";
+    if (bytes.length >= 12 &&
+        bytes[0] === 0x52 &&
+        bytes[1] === 0x49 &&
+        bytes[2] === 0x46 &&
+        bytes[3] === 0x46 &&
+        bytes[8] === 0x57 &&
+        bytes[9] === 0x45 &&
+        bytes[10] === 0x42 &&
+        bytes[11] === 0x50)
+        return "webp";
+    return undefined;
+};
+const decodeEncoded = (value, maximumBytes) => {
+    const comma = value.startsWith("data:") ? value.indexOf(",") : -1;
+    const payload = comma >= 0 ? value.slice(comma + 1) : value;
+    if (payload.length > Math.ceil((maximumBytes * 4) / 3) + 4)
+        return undefined;
+    const encoded = z.base64().safeParse(payload);
+    if (!encoded.success)
+        return undefined;
+    const binary = atob(encoded.data);
+    if (binary.length === 0 || binary.length > maximumBytes)
+        return undefined;
+    return Uint8Array.from(binary, (character) => character.charCodeAt(0));
+};
+const encodedExceedsBound = (value, maximumBytes) => {
+    const comma = value.startsWith("data:") ? value.indexOf(",") : -1;
+    const payload = comma >= 0 ? value.slice(comma + 1) : value;
+    return payload.length > Math.ceil((maximumBytes * 4) / 3) + 4;
+};
+const declaredDataUrlFormat = (value) => {
+    if (!value.startsWith("data:"))
+        return undefined;
+    const comma = value.indexOf(",");
+    if (comma < 0)
+        return undefined;
+    const mime = value.slice(5, comma).split(";", 1)[0]?.toLowerCase();
+    if (mime === "image/jpeg")
+        return "jpeg";
+    if (mime === "image/png")
+        return "png";
+    if (mime === "image/gif")
+        return "gif";
+    if (mime === "image/webp")
+        return "webp";
+    return undefined;
+};
+/** Read a successful provider response within an explicit byte bound, closing its reader. */
+export const readResponseBytes = async (response, maximumBytes) => {
+    if (!response.ok)
+        throw new Error(`provider response status ${String(response.status)}`);
+    const claimedLength = response.headers.get("content-length");
+    if (claimedLength !== null) {
+        const length = Number(claimedLength);
+        if (!Number.isSafeInteger(length) || length < 0 || length > maximumBytes)
+            throw new Error("provider response exceeds the byte bound");
+    }
+    if (response.body === null)
+        throw new Error("provider response had no body");
+    const reader = new ReadableStreamDefaultReader(response.body);
+    const chunks = [];
+    let total = 0;
+    try {
+        let item = await reader.read();
+        while (!item.done) {
+            total += item.value.byteLength;
+            if (total > maximumBytes)
+                throw new Error("provider response exceeds the byte bound");
+            chunks.push(item.value);
+            item = await reader.read();
+        }
+    }
+    finally {
+        // Closing a rejected stream must not hide its original read/bound failure.
+        await reader.cancel().catch((cause) => {
+            reportCatchFailure("provider-response-reader-cancel", cause);
+        });
+        reader.releaseLock();
+    }
+    const bytes = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return bytes;
+};
+const tryNormalizeBytes = (bytes, maximumBytes, declaredFormat) => {
+    if (bytes.byteLength === 0 || bytes.byteLength > maximumBytes)
+        return undefined;
+    const format = sniffImageFormat(bytes);
+    if (format === undefined)
+        return undefined;
+    return { bytes, format: declaredFormat ?? format };
+};
+const normalizeBytes = (bytes, maximumBytes, declaredFormat) => {
+    const output = tryNormalizeBytes(bytes, maximumBytes, declaredFormat);
+    if (output === undefined)
+        throw new Error("provider image has an unsupported format or size");
+    return output;
+};
+/** Normalize all retained provider envelopes into bounded image bytes. */
+export const normalizeMediaProviderOutput = async (value, options = {}) => {
+    const maximumBytes = options.maxBytes ?? MAX_OUTPUT_BYTES;
+    if (!Number.isSafeInteger(maximumBytes) || maximumBytes < 1)
+        throw new Error("maxBytes must be a positive safe integer");
+    const parsed = parseMediaProviderOutput(value);
+    if (parsed.kind === "bytes")
+        return normalizeBytes(parsed.bytes, maximumBytes);
+    if (parsed.kind === "response")
+        return normalizeBytes(await readResponseBytes(parsed.response, maximumBytes), maximumBytes);
+    if (parsed.kind === "encoded") {
+        if (encodedExceedsBound(parsed.encoded, maximumBytes))
+            throw new Error("provider image exceeds the byte bound");
+        const bytes = decodeEncoded(parsed.encoded, maximumBytes);
+        if (bytes === undefined)
+            throw new Error("provider image encoding is invalid");
+        return normalizeBytes(bytes, maximumBytes, declaredDataUrlFormat(parsed.encoded));
+    }
+    for (const entry of parsed.entries) {
+        for (const encoded of [entry.base64, entry.data]) {
+            if (encoded === undefined)
+                continue;
+            const bytes = decodeEncoded(encoded, maximumBytes);
+            if (bytes !== undefined) {
+                const normalized = tryNormalizeBytes(bytes, maximumBytes, declaredDataUrlFormat(encoded));
+                if (normalized !== undefined)
+                    return normalized;
+            }
+        }
+        if (entry.url !== undefined) {
+            const fetchUrl = options.fetchUrl ?? ((url) => fetch(url));
+            try {
+                const response = await fetchUrl(entry.url);
+                return normalizeBytes(await readResponseBytes(response, maximumBytes), maximumBytes);
+            }
+            catch (cause) {
+                reportCatchFailure("provider-entry-fetch", cause);
+                /* Try the next provider entry. */
+            }
+        }
+    }
+    throw new Error("provider returned no valid image bytes");
+};
+export { estimateImageMilliunits, estimateImageNeurons, } from "./cost-estimate.js";
+export { neuronsToMilliunits, USD_PER_1K_NEURONS } from "./neurons.js";
+/** Provider video cost from the sole catalog, in milliunits (1 cent = 1,000). Video-input references are unsupported. */
+export function estimateVideoMilliunits(settings) {
+    const checked = validateMediaGenerationSelection({
+        ...settings,
+        references: settings.references?.map((reference) => ({
+            path: reference.path,
+            role: reference.role,
+        })),
+    });
+    const model = getMediaModel(checked.model);
+    if (model?.video == null || checked.durationSeconds === undefined)
+        throw new MediaSettingsError("video cost requires a verified video model");
+    const price = model.video.prices.find((candidate) => candidate.resolution === checked.resolution);
+    if (price === undefined)
+        throw new MediaSettingsError("video price unavailable for this resolution");
+    const rate = checked.generateAudio === true
+        ? price.audioMilliunitsPerSecond
+        : price.silentMilliunitsPerSecond;
+    return rate * checked.durationSeconds;
+}