@skyold/model-protocol 0.1.0-beta.0

package/dist/media-images.js

@@ -0,0 +1,721 @@
+import { createHash } from 'node:crypto';
+export const OPENAI_IMAGES_PROTOCOL = 'openai-images/v1';
+export const VOLC_IMAGES_PROTOCOL = 'volc-images/v1';
+export const MAX_IMAGE_REVISED_PROMPT_UTF8_BYTES_V1 = 32 * 1024;
+const MAX_OUTPUT_ITEMS = 10;
+const MAX_OUTPUT_ITEM_BYTES = 25 * 1024 * 1024;
+const MAX_OUTPUT_ITEM_BASE64_CHARS = 4 * Math.ceil(MAX_OUTPUT_ITEM_BYTES / 3);
+const MAX_INLINE_TOTAL_BYTES = 100 * 1024 * 1024;
+const BASE64_VERIFY_CHUNK_CHARS = 64 * 1024;
+const IMAGE_MAGIC_BYTES = 12;
+const IMAGE_MIME_TYPES = new Set(['image/png', 'image/jpeg', 'image/webp']);
+const SHA256 = /^[a-f0-9]{64}$/;
+const UTF8_ENCODER = new TextEncoder();
+export function parseImageGenerationCapabilityV1(value) {
+    if (!isRecord(value) ||
+        !hasExactKeys(value, [
+            'schemaVersion',
+            'supportedPolicies',
+            'responseFormats',
+            'outputFormats',
+            'requestMapping',
+            'qualities',
+            'minCount',
+            'maxCount',
+            'allowedSizes',
+            'maxPromptUtf8Bytes',
+            'certifiedModelRevision',
+        ], ['allowedBackgrounds'])) {
+        return null;
+    }
+    const sizes = value['allowedSizes'];
+    const responseFormats = value['responseFormats'];
+    const outputFormats = value['outputFormats'];
+    const requestMapping = parseRequestMapping(value['requestMapping'], responseFormats, outputFormats);
+    const allowedBackgrounds = value['allowedBackgrounds'];
+    if (value['schemaVersion'] !== 1 ||
+        !uniqueArray(value['supportedPolicies'], (item) => item === 'transparent' || item === 'managed') ||
+        !uniqueArray(responseFormats, (item) => item === 'url' || item === 'b64_json') ||
+        !uniqueArray(outputFormats, (item) => item === 'png' || item === 'jpeg' || item === 'webp') ||
+        !uniqueArray(value['qualities'], (item) => item === 'auto' || item === 'low' || item === 'medium' || item === 'high') ||
+        (allowedBackgrounds !== undefined &&
+            !uniqueArray(allowedBackgrounds, (item) => item === 'auto' || item === 'opaque' || item === 'transparent')) ||
+        !positiveInteger(value['minCount']) ||
+        !positiveInteger(value['maxCount']) ||
+        value['minCount'] > value['maxCount'] ||
+        value['maxCount'] > MAX_OUTPUT_ITEMS ||
+        !Array.isArray(sizes) ||
+        sizes.length === 0 ||
+        !sizes.every(isSize) ||
+        new Set(sizes.map((size) => `${size.width}x${size.height}`)).size !== sizes.length ||
+        !positiveInteger(value['maxPromptUtf8Bytes']) ||
+        value['maxPromptUtf8Bytes'] > 32 * 1024 ||
+        !nonEmptyString(value['certifiedModelRevision']) ||
+        requestMapping === null) {
+        return null;
+    }
+    const parsedAllowedBackgrounds = allowedBackgrounds === undefined
+        ? undefined
+        : allowedBackgrounds;
+    return {
+        schemaVersion: 1,
+        supportedPolicies: [
+            ...value['supportedPolicies'],
+        ],
+        responseFormats: [...responseFormats],
+        outputFormats: [...outputFormats],
+        requestMapping,
+        ...(parsedAllowedBackgrounds === undefined
+            ? {}
+            : {
+                allowedBackgrounds: [...parsedAllowedBackgrounds],
+            }),
+        qualities: [...value['qualities']],
+        minCount: value['minCount'],
+        maxCount: value['maxCount'],
+        allowedSizes: sizes.map((size) => ({ width: size.width, height: size.height })),
+        maxPromptUtf8Bytes: value['maxPromptUtf8Bytes'],
+        certifiedModelRevision: value['certifiedModelRevision'],
+    };
+}
+export function parseImageTaskCapabilityDeclarationV1(value) {
+    if (!isRecord(value) ||
+        !hasExactKeys(value, [
+            'schemaVersion',
+            'taskKind',
+            'protocolFamily',
+            'inputModalities',
+            'outputModalities',
+            'executionModes',
+            'supportsCallback',
+            'supportsCancel',
+            'imageGenerationCapability',
+        ]) ||
+        value['schemaVersion'] !== 1 ||
+        value['taskKind'] !== 'image_generation' ||
+        (value['protocolFamily'] !== OPENAI_IMAGES_PROTOCOL &&
+            value['protocolFamily'] !== VOLC_IMAGES_PROTOCOL) ||
+        !exactSingleton(value['inputModalities'], 'text') ||
+        !exactSingleton(value['outputModalities'], 'image') ||
+        !exactSingleton(value['executionModes'], 'sync') ||
+        value['supportsCallback'] !== false ||
+        value['supportsCancel'] !== false) {
+        return null;
+    }
+    const imageGenerationCapability = parseImageGenerationCapabilityV1(value['imageGenerationCapability']);
+    if (imageGenerationCapability === null)
+        return null;
+    return {
+        schemaVersion: 1,
+        taskKind: 'image_generation',
+        protocolFamily: value['protocolFamily'],
+        inputModalities: ['text'],
+        outputModalities: ['image'],
+        executionModes: ['sync'],
+        supportsCallback: false,
+        supportsCancel: false,
+        imageGenerationCapability,
+    };
+}
+export function parseImageTaskCapabilityDeclarationV2(value) {
+    if (!isRecord(value) ||
+        !hasExactKeys(value, [
+            'schemaVersion',
+            'taskKind',
+            'protocolFamily',
+            'operations',
+            'inputModalities',
+            'outputModalities',
+            'executionModes',
+            'supportsCallback',
+            'supportsCancel',
+            'imageGenerationCapability',
+        ], ['imageEditingCapability', 'imageUsageReportingCapability']) ||
+        value['schemaVersion'] !== 2 ||
+        value['taskKind'] !== 'image_generation' ||
+        (value['protocolFamily'] !== OPENAI_IMAGES_PROTOCOL &&
+            value['protocolFamily'] !== VOLC_IMAGES_PROTOCOL) ||
+        !uniqueArray(value['operations'], (item) => item === 'generate' || item === 'edit') ||
+        !uniqueArray(value['inputModalities'], (item) => item === 'text' || item === 'image') ||
+        !value['inputModalities'].includes('text') ||
+        !exactSingleton(value['outputModalities'], 'image') ||
+        !exactSingleton(value['executionModes'], 'sync') ||
+        value['supportsCallback'] !== false ||
+        value['supportsCancel'] !== false) {
+        return null;
+    }
+    const operations = value['operations'];
+    const inputModalities = value['inputModalities'];
+    const supportsEdit = operations.includes('edit');
+    if (supportsEdit !== inputModalities.includes('image'))
+        return null;
+    const imageGenerationCapability = parseImageGenerationCapabilityV1(value['imageGenerationCapability']);
+    if (imageGenerationCapability === null)
+        return null;
+    const imageEditingCapability = value['imageEditingCapability'] === undefined
+        ? undefined
+        : parseImageEditingCapabilityV2(value['imageEditingCapability']);
+    if (supportsEdit !== (imageEditingCapability !== undefined) ||
+        (value['imageEditingCapability'] !== undefined && imageEditingCapability === undefined)) {
+        return null;
+    }
+    const imageUsageReportingCapability = value['imageUsageReportingCapability'] === undefined
+        ? undefined
+        : parseImageUsageReportingCapabilityV1(value['imageUsageReportingCapability']);
+    if (value['imageUsageReportingCapability'] !== undefined &&
+        imageUsageReportingCapability === undefined) {
+        return null;
+    }
+    return {
+        schemaVersion: 2,
+        taskKind: 'image_generation',
+        protocolFamily: value['protocolFamily'],
+        operations: [...operations],
+        inputModalities: [...inputModalities],
+        outputModalities: ['image'],
+        executionModes: ['sync'],
+        supportsCallback: false,
+        supportsCancel: false,
+        imageGenerationCapability,
+        ...(imageEditingCapability === undefined ? {} : { imageEditingCapability }),
+        ...(imageUsageReportingCapability === undefined ? {} : { imageUsageReportingCapability }),
+    };
+}
+function parseImageUsageReportingCapabilityV1(value) {
+    if (!isRecord(value) ||
+        !hasExactKeys(value, ['schemaVersion', 'guaranteedUnits']) ||
+        value['schemaVersion'] !== 1 ||
+        !uniqueArray(value['guaranteedUnits'], (item) => item === 'inputTokens' || item === 'outputTokens' || item === 'totalTokens')) {
+        return undefined;
+    }
+    return {
+        schemaVersion: 1,
+        guaranteedUnits: [
+            ...value['guaranteedUnits'],
+        ],
+    };
+}
+export function canonicalizeImageTaskCapabilityDeclarationsV1(value) {
+    if (!Array.isArray(value))
+        return [];
+    const parsed = [];
+    const keys = new Set();
+    for (const item of value) {
+        const declaration = parseImageTaskCapabilityDeclarationV1(item);
+        if (declaration === null)
+            return [];
+        const key = `${declaration.taskKind}:${declaration.protocolFamily}`;
+        if (keys.has(key))
+            return [];
+        keys.add(key);
+        parsed.push(declaration);
+    }
+    return parsed;
+}
+export function canonicalizeImageTaskCapabilityDeclarations(value) {
+    if (!Array.isArray(value))
+        return [];
+    const parsed = [];
+    const keys = new Set();
+    for (const item of value) {
+        const declaration = isRecord(item) && item['schemaVersion'] === 1
+            ? parseImageTaskCapabilityDeclarationV1(item)
+            : parseImageTaskCapabilityDeclarationV2(item);
+        if (declaration === null)
+            return [];
+        const key = `${declaration.taskKind}:${declaration.protocolFamily}`;
+        if (keys.has(key))
+            return [];
+        keys.add(key);
+        parsed.push(declaration);
+    }
+    return parsed;
+}
+export function decodeOpenAiImagesProtocolSnapshotV1(value) {
+    if (!isRecord(value) ||
+        !hasExactKeys(value, ['protocolFamily', 'created', 'items'], ['background', 'outputFormat', 'quality', 'size', 'usage']) ||
+        value['protocolFamily'] !== OPENAI_IMAGES_PROTOCOL ||
+        !positiveOrZeroInteger(value['created']) ||
+        !Array.isArray(value['items']) ||
+        value['items'].length > MAX_OUTPUT_ITEMS) {
+        rejectOpenAiImagesSnapshot();
+    }
+    const items = value['items'].map((item) => {
+        if (!isRecord(item) ||
+            !hasExactKeys(item, [], ['revisedPrompt']) ||
+            (item['revisedPrompt'] !== undefined &&
+                (typeof item['revisedPrompt'] !== 'string' ||
+                    UTF8_ENCODER.encode(item['revisedPrompt']).byteLength >
+                        MAX_IMAGE_REVISED_PROMPT_UTF8_BYTES_V1))) {
+            rejectOpenAiImagesSnapshot();
+        }
+        return item['revisedPrompt'] === undefined ? {} : { revisedPrompt: item['revisedPrompt'] };
+    });
+    const background = value['background'];
+    const outputFormat = value['outputFormat'];
+    const quality = value['quality'];
+    const size = value['size'];
+    if ((background !== undefined && background !== 'transparent' && background !== 'opaque') ||
+        (outputFormat !== undefined &&
+            outputFormat !== 'png' &&
+            outputFormat !== 'jpeg' &&
+            outputFormat !== 'webp') ||
+        (quality !== undefined && quality !== 'low' && quality !== 'medium' && quality !== 'high') ||
+        (size !== undefined && !imagePixelSize(size))) {
+        rejectOpenAiImagesSnapshot();
+    }
+    const usage = value['usage'] === undefined ? undefined : decodeOpenAiImagesUsageSnapshot(value['usage']);
+    return {
+        protocolFamily: OPENAI_IMAGES_PROTOCOL,
+        created: value['created'],
+        items,
+        ...(background === undefined ? {} : { background }),
+        ...(outputFormat === undefined ? {} : { outputFormat }),
+        ...(quality === undefined ? {} : { quality }),
+        ...(size === undefined ? {} : { size }),
+        ...(usage === undefined ? {} : { usage }),
+    };
+}
+export function decodeVolcImagesProtocolSnapshotV1(value) {
+    if (!isRecord(value) ||
+        !hasExactKeys(value, ['protocolFamily', 'model', 'created', 'items', 'usage']) ||
+        value['protocolFamily'] !== VOLC_IMAGES_PROTOCOL ||
+        !nonEmptyString(value['model']) ||
+        value['model'].length > 256 ||
+        !positiveOrZeroInteger(value['created']) ||
+        !Array.isArray(value['items']) ||
+        value['items'].length === 0 ||
+        value['items'].length > MAX_OUTPUT_ITEMS) {
+        rejectVolcImagesSnapshot();
+    }
+    const items = value['items'].map((item) => {
+        if (!isRecord(item) || !hasExactKeys(item, ['size']) || !imagePixelSize(item['size'])) {
+            rejectVolcImagesSnapshot();
+        }
+        return { size: item['size'] };
+    });
+    const usage = decodeVolcImagesUsageSnapshot(value['usage']);
+    if (usage.generatedImages !== items.length || usage.totalTokens < usage.outputTokens) {
+        rejectVolcImagesSnapshot();
+    }
+    return {
+        protocolFamily: VOLC_IMAGES_PROTOCOL,
+        model: value['model'],
+        created: value['created'],
+        items,
+        usage,
+    };
+}
+export function decodeImageGenerationProtocolSnapshotV1(value) {
+    if (!isRecord(value))
+        rejectImageGenerationSnapshot();
+    if (value['protocolFamily'] === OPENAI_IMAGES_PROTOCOL) {
+        return decodeOpenAiImagesProtocolSnapshotV1(value);
+    }
+    if (value['protocolFamily'] === VOLC_IMAGES_PROTOCOL) {
+        return decodeVolcImagesProtocolSnapshotV1(value);
+    }
+    return rejectImageGenerationSnapshot();
+}
+function parseRequestMapping(value, responseFormats, outputFormats) {
+    if (!isRecord(value) ||
+        !hasExactKeys(value, ['responseFormat', 'outputFormat', 'providerOptions']) ||
+        !Array.isArray(responseFormats) ||
+        !Array.isArray(outputFormats)) {
+        return null;
+    }
+    const responseFormat = parseFormatMapping(value['responseFormat'], responseFormats, (item) => item === 'url' || item === 'b64_json');
+    const outputFormat = parseFormatMapping(value['outputFormat'], outputFormats, (item) => item === 'png' || item === 'jpeg' || item === 'webp');
+    const providerOptions = value['providerOptions'];
+    if (responseFormat === null ||
+        outputFormat === null ||
+        !isRecord(providerOptions) ||
+        !hasExactKeys(providerOptions, ['openaiImages', 'volcImages']) ||
+        !closedUniqueArray(providerOptions['openaiImages'], (item) => item === 'background' || item === 'moderation' || item === 'outputCompression') ||
+        !closedUniqueArray(providerOptions['volcImages'], (item) => item === 'watermark')) {
+        return null;
+    }
+    return {
+        responseFormat,
+        outputFormat,
+        providerOptions: {
+            openaiImages: [
+                ...providerOptions['openaiImages'],
+            ],
+            volcImages: [
+                ...providerOptions['volcImages'],
+            ],
+        },
+    };
+}
+function parseFormatMapping(value, supported, isFormat) {
+    if (!isRecord(value) || typeof value['mode'] !== 'string')
+        return null;
+    if (value['mode'] === 'parameter' &&
+        hasExactKeys(value, ['mode', 'defaultValue']) &&
+        isFormat(value['defaultValue']) &&
+        supported.includes(value['defaultValue'])) {
+        return { mode: 'parameter', defaultValue: value['defaultValue'] };
+    }
+    if (value['mode'] === 'fixed' &&
+        hasExactKeys(value, ['mode', 'value']) &&
+        isFormat(value['value']) &&
+        supported.length === 1 &&
+        supported[0] === value['value']) {
+        return { mode: 'fixed', value: value['value'] };
+    }
+    return null;
+}
+function decodeOpenAiImagesUsageSnapshot(value) {
+    if (!isRecord(value) ||
+        !hasExactKeys(value, ['inputTokens', 'inputTokenDetails', 'outputTokens', 'totalTokens'], ['outputTokenDetails']) ||
+        !positiveOrZeroInteger(value['inputTokens']) ||
+        !positiveOrZeroInteger(value['outputTokens']) ||
+        !positiveOrZeroInteger(value['totalTokens'])) {
+        rejectOpenAiImagesSnapshot();
+    }
+    const inputTokenDetails = decodeImageTokenDetails(value['inputTokenDetails']);
+    const outputTokenDetails = value['outputTokenDetails'] === undefined
+        ? undefined
+        : decodeImageTokenDetails(value['outputTokenDetails']);
+    if (safeIntegerSum(inputTokenDetails.imageTokens, inputTokenDetails.textTokens) !==
+        value['inputTokens'] ||
+        (outputTokenDetails !== undefined &&
+            safeIntegerSum(outputTokenDetails.imageTokens, outputTokenDetails.textTokens) !==
+                value['outputTokens']) ||
+        safeIntegerSum(value['inputTokens'], value['outputTokens']) !== value['totalTokens']) {
+        rejectOpenAiImagesSnapshot();
+    }
+    return {
+        inputTokens: value['inputTokens'],
+        inputTokenDetails,
+        outputTokens: value['outputTokens'],
+        totalTokens: value['totalTokens'],
+        ...(outputTokenDetails === undefined ? {} : { outputTokenDetails }),
+    };
+}
+function decodeImageTokenDetails(value) {
+    if (!isRecord(value) ||
+        !hasExactKeys(value, ['imageTokens', 'textTokens']) ||
+        !positiveOrZeroInteger(value['imageTokens']) ||
+        !positiveOrZeroInteger(value['textTokens'])) {
+        rejectOpenAiImagesSnapshot();
+    }
+    return { imageTokens: value['imageTokens'], textTokens: value['textTokens'] };
+}
+function rejectOpenAiImagesSnapshot() {
+    throw new Error('INVALID_OPENAI_IMAGES_PROTOCOL_SNAPSHOT');
+}
+function decodeVolcImagesUsageSnapshot(value) {
+    if (!isRecord(value) ||
+        !hasExactKeys(value, ['generatedImages', 'outputTokens', 'totalTokens']) ||
+        !positiveOrZeroInteger(value['generatedImages']) ||
+        !positiveOrZeroInteger(value['outputTokens']) ||
+        !positiveOrZeroInteger(value['totalTokens'])) {
+        rejectVolcImagesSnapshot();
+    }
+    return {
+        generatedImages: value['generatedImages'],
+        outputTokens: value['outputTokens'],
+        totalTokens: value['totalTokens'],
+    };
+}
+function imagePixelSize(value) {
+    if (typeof value !== 'string')
+        return false;
+    const match = /^([1-9]\d{1,3})x([1-9]\d{1,3})$/.exec(value);
+    if (match === null)
+        return false;
+    const width = Number(match[1]);
+    const height = Number(match[2]);
+    return width >= 64 && width <= 8192 && height >= 64 && height <= 8192;
+}
+function safeIntegerSum(left, right) {
+    const sum = left + right;
+    return Number.isSafeInteger(sum) ? sum : null;
+}
+function rejectVolcImagesSnapshot() {
+    throw new Error('INVALID_VOLC_IMAGES_PROTOCOL_SNAPSHOT');
+}
+function rejectImageGenerationSnapshot() {
+    throw new Error('INVALID_IMAGE_GENERATION_PROTOCOL_SNAPSHOT');
+}
+export function decodeMediaTaskResultV2(value) {
+    if (!isRecord(value) ||
+        !hasExactKeys(value, ['type', 'items']) ||
+        value['type'] !== 'media' ||
+        !Array.isArray(value['items']) ||
+        value['items'].length > MAX_OUTPUT_ITEMS) {
+        rejectMediaResult();
+    }
+    const declaredInlineTotal = value['items'].reduce((total, item) => {
+        if (!isRecord(item) || item['kind'] !== 'inline' || !positiveOrZeroInteger(item['sizeBytes'])) {
+            return total;
+        }
+        return total + item['sizeBytes'];
+    }, 0);
+    if (declaredInlineTotal > MAX_INLINE_TOTAL_BYTES)
+        rejectMediaResult();
+    let inlineBytes = 0;
+    return {
+        type: 'media',
+        items: value['items'].map((item) => {
+            const output = decodeMediaTaskOutput(item);
+            if (output.kind === 'inline') {
+                inlineBytes += output.sizeBytes;
+                if (inlineBytes > MAX_INLINE_TOTAL_BYTES)
+                    rejectMediaResult();
+            }
+            return output;
+        }),
+    };
+}
+export function summarizeMediaTaskOutput(output) {
+    if (output.kind === 'reference')
+        return output;
+    const { base64: _base64, ...summary } = output;
+    return summary;
+}
+function inspectInlineImageBase64V1(value, reject) {
+    if (typeof value !== 'string' ||
+        value.length > MAX_OUTPUT_ITEM_BASE64_CHARS ||
+        !isCanonicalBase64(value)) {
+        reject();
+    }
+    const sizeBytes = decodedBase64Length(value);
+    if (sizeBytes > MAX_OUTPUT_ITEM_BYTES)
+        reject();
+    return { base64: value, sizeBytes };
+}
+export function materializeInlineImageBase64ValueV1(value, expectedFormat) {
+    const inspected = inspectInlineImageBase64V1(value, rejectInlineImageBase64);
+    const { detected, sha256 } = verifyInlineImageBase64(inspected, rejectInlineImageBase64);
+    if (detected?.format !== expectedFormat)
+        rejectInlineImageBase64();
+    return {
+        kind: 'inline',
+        mimeType: detected.mimeType,
+        base64: inspected.base64,
+        sizeBytes: inspected.sizeBytes,
+        sha256,
+    };
+}
+function decodeMediaTaskOutput(value) {
+    if (!isRecord(value) || typeof value['kind'] !== 'string')
+        rejectMediaResult();
+    if (value['kind'] === 'reference') {
+        if (!hasExactKeys(value, ['kind', 'reference']))
+            rejectMediaResult();
+        return { kind: 'reference', reference: decodeReference(value['reference']) };
+    }
+    if (value['kind'] !== 'inline' ||
+        !hasExactKeys(value, ['kind', 'mimeType', 'base64', 'sizeBytes', 'sha256']))
+        rejectMediaResult();
+    const { mimeType, base64, sizeBytes, sha256 } = value;
+    if (typeof base64 !== 'string' || base64.length > MAX_OUTPUT_ITEM_BASE64_CHARS)
+        rejectMediaResult();
+    if (typeof mimeType !== 'string' ||
+        !IMAGE_MIME_TYPES.has(mimeType) ||
+        !positiveOrZeroInteger(sizeBytes) ||
+        sizeBytes > MAX_OUTPUT_ITEM_BYTES ||
+        typeof sha256 !== 'string' ||
+        !SHA256.test(sha256))
+        rejectMediaResult();
+    const inspected = inspectInlineImageBase64V1(base64, rejectMediaResult);
+    if (inspected.sizeBytes !== sizeBytes)
+        rejectMediaResult();
+    const verified = verifyInlineImageBase64(inspected, rejectMediaResult);
+    if (verified.sha256 !== sha256 || verified.detected?.mimeType !== mimeType)
+        rejectMediaResult();
+    return {
+        kind: 'inline',
+        mimeType,
+        base64,
+        sizeBytes,
+        sha256,
+    };
+}
+function verifyInlineImageBase64(inspected, reject) {
+    const hash = createHash('sha256');
+    const magic = new Uint8Array(Math.min(IMAGE_MAGIC_BYTES, inspected.sizeBytes));
+    let magicOffset = 0;
+    let decodedBytes = 0;
+    for (let offset = 0; offset < inspected.base64.length; offset += BASE64_VERIFY_CHUNK_CHARS) {
+        const chunk = Buffer.from(inspected.base64.slice(offset, offset + BASE64_VERIFY_CHUNK_CHARS), 'base64');
+        decodedBytes += chunk.byteLength;
+        if (decodedBytes > inspected.sizeBytes)
+            reject();
+        hash.update(chunk);
+        if (magicOffset < magic.byteLength) {
+            const copied = Math.min(chunk.byteLength, magic.byteLength - magicOffset);
+            magic.set(chunk.subarray(0, copied), magicOffset);
+            magicOffset += copied;
+        }
+    }
+    if (decodedBytes !== inspected.sizeBytes)
+        reject();
+    return { detected: detectImageFormat(magic), sha256: hash.digest('hex') };
+}
+function decodeReference(value) {
+    if (!isRecord(value) || typeof value['kind'] !== 'string')
+        rejectMediaResult();
+    if (value['kind'] === 'url' &&
+        hasExactKeys(value, ['kind', 'url', 'mimeType'], ['sizeBytes', 'expiresAt']) &&
+        nonEmptyString(value['url']) &&
+        imageMimeType(value['mimeType']) &&
+        (value['sizeBytes'] === undefined ||
+            (positiveOrZeroInteger(value['sizeBytes']) && value['sizeBytes'] <= MAX_OUTPUT_ITEM_BYTES)) &&
+        (value['expiresAt'] === undefined || nonEmptyString(value['expiresAt']))) {
+        return value;
+    }
+    if (value['kind'] === 'object' &&
+        hasExactKeys(value, ['kind', 'objectKey', 'mimeType', 'sizeBytes', 'sha256', 'expiresAt']) &&
+        nonEmptyString(value['objectKey']) &&
+        imageMimeType(value['mimeType']) &&
+        positiveOrZeroInteger(value['sizeBytes']) &&
+        value['sizeBytes'] <= MAX_OUTPUT_ITEM_BYTES &&
+        typeof value['sha256'] === 'string' &&
+        SHA256.test(value['sha256']) &&
+        nonEmptyString(value['expiresAt'])) {
+        return value;
+    }
+    return rejectMediaResult();
+}
+function decodedBase64Length(value) {
+    const padding = value.endsWith('==') ? 2 : value.endsWith('=') ? 1 : 0;
+    return (value.length / 4) * 3 - padding;
+}
+function isCanonicalBase64(value) {
+    if (value.length % 4 !== 0)
+        return false;
+    const padding = value.endsWith('==') ? 2 : value.endsWith('=') ? 1 : 0;
+    for (let index = 0; index < value.length - padding; index += 1) {
+        const code = value.charCodeAt(index);
+        if (!((code >= 65 && code <= 90) ||
+            (code >= 97 && code <= 122) ||
+            (code >= 48 && code <= 57) ||
+            code === 43 ||
+            code === 47)) {
+            return false;
+        }
+    }
+    for (let index = value.length - padding; index < value.length; index += 1) {
+        if (value[index] !== '=')
+            return false;
+    }
+    if (padding > 0) {
+        const tail = base64Sextet(value.charCodeAt(value.length - padding - 1));
+        if (tail < 0 || (padding === 2 ? (tail & 0b1111) !== 0 : (tail & 0b11) !== 0)) {
+            return false;
+        }
+    }
+    return true;
+}
+function base64Sextet(code) {
+    if (code >= 65 && code <= 90)
+        return code - 65;
+    if (code >= 97 && code <= 122)
+        return code - 97 + 26;
+    if (code >= 48 && code <= 57)
+        return code - 48 + 52;
+    if (code === 43)
+        return 62;
+    if (code === 47)
+        return 63;
+    return -1;
+}
+function parseImageEditingCapabilityV2(value) {
+    if (!isRecord(value) ||
+        !hasExactKeys(value, ['maxInputImages', 'supportsMask', 'inputMimeTypes']) ||
+        !positiveInteger(value['maxInputImages']) ||
+        value['maxInputImages'] > MAX_OUTPUT_ITEMS ||
+        typeof value['supportsMask'] !== 'boolean' ||
+        !uniqueArray(value['inputMimeTypes'], imageMimeType)) {
+        return undefined;
+    }
+    return {
+        maxInputImages: value['maxInputImages'],
+        supportsMask: value['supportsMask'],
+        inputMimeTypes: [...value['inputMimeTypes']],
+    };
+}
+function isSize(value) {
+    return (isRecord(value) &&
+        hasExactKeys(value, ['width', 'height']) &&
+        positiveInteger(value['width']) &&
+        positiveInteger(value['height']) &&
+        value['width'] >= 256 &&
+        value['width'] <= 4096 &&
+        value['height'] >= 256 &&
+        value['height'] <= 4096);
+}
+function uniqueArray(value, predicate) {
+    return (Array.isArray(value) &&
+        value.length > 0 &&
+        value.every(predicate) &&
+        new Set(value).size === value.length);
+}
+function closedUniqueArray(value, predicate) {
+    return Array.isArray(value) && value.every(predicate) && new Set(value).size === value.length;
+}
+function hasExactKeys(value, required, optional = []) {
+    const allowed = new Set([...required, ...optional]);
+    return (Object.keys(value).every((key) => allowed.has(key)) &&
+        required.every((key) => Object.prototype.hasOwnProperty.call(value, key)));
+}
+function isRecord(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null));
+}
+function exactSingleton(value, expected) {
+    return Array.isArray(value) && value.length === 1 && value[0] === expected;
+}
+function positiveInteger(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value > 0;
+}
+function positiveOrZeroInteger(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+}
+function nonEmptyString(value) {
+    return typeof value === 'string' && Boolean(value.trim());
+}
+function imageMimeType(value) {
+    return typeof value === 'string' && IMAGE_MIME_TYPES.has(value);
+}
+function detectImageFormat(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 { format: 'png', mimeType: 'image/png' };
+    }
+    if (bytes.length >= 3 && bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff) {
+        return { format: 'jpeg', mimeType: 'image/jpeg' };
+    }
+    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 { format: 'webp', mimeType: 'image/webp' };
+    }
+    return null;
+}
+function rejectInlineImageBase64() {
+    throw new Error('INVALID_INLINE_IMAGE_BASE64');
+}
+function rejectMediaResult() {
+    throw new Error('INVALID_MEDIA_TASK_RESULT');
+}
+//# sourceMappingURL=media-images.js.map