@penpair/core 0.3.6 → 0.4.0

package/dist/design-releases/validation.js

@@ -0,0 +1,384 @@
+import { observationHash } from "../journal.js";
+import { validateArtifactReview } from "../maps/review.js";
+import { mapObject, mapText, mapId, mapHash, mapPath } from "../maps/validation.js";
+export function releaseReference(raw) {
+    const value = mapObject(raw, "Release artifact reference", [
+        "path",
+        "sha256",
+    ]);
+    return {
+        path: mapPath(value.path, "Release artifact path"),
+        sha256: mapHash(value.sha256, "Release artifact hash"),
+    };
+}
+function screen(raw, planned = true) {
+    const value = mapObject(raw, "Release screen", [
+        "id",
+        "label",
+        "pageId",
+        "frameId",
+        "inspection",
+        "render",
+        "dependencies",
+        ...(planned
+            ? []
+            : [
+                "contentHash",
+            ]),
+    ]);
+    return {
+        id: mapId(value.id, "Screen ID"),
+        label: mapText(value.label, "Screen label", 2000),
+        pageId: mapId(value.pageId, "Source page ID"),
+        frameId: mapId(value.frameId, "Source frame ID"),
+        inspection: releaseReference(value.inspection),
+        ...(value.render === undefined
+            ? {}
+            : {
+                render: releaseReference(value.render),
+            }),
+        ...(value.dependencies === undefined
+            ? {}
+            : {
+                dependencies: releaseReference(value.dependencies),
+            }),
+    };
+}
+function contract(raw, planned = true) {
+    const value = mapObject(raw, "Release contract", [
+        "path",
+        "sha256",
+        "review",
+        ...(planned
+            ? []
+            : [
+                "kind",
+                "id",
+            ]),
+    ]);
+    return {
+        ...releaseReference({
+            path: value.path,
+            sha256: value.sha256,
+        }),
+        ...(value.review === undefined
+            ? {}
+            : {
+                review: validateArtifactReview(value.review),
+            }),
+    };
+}
+function releaseHeader(value) {
+    const productVersion = mapText(value.productVersion, "Product SemVer", 100);
+    if (!/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.test(productVersion)) {
+        throw new Error("Explicit product SemVer is required independently of the Penpair version");
+    }
+    return {
+        id: mapId(value.id, "Release ID"),
+        title: mapText(value.title, "Release title", 2000),
+        productVersion,
+        fileId: mapId(value.fileId, "Pinned file ID"),
+    };
+}
+function boundedList(value, label, maximum) {
+    if (!Array.isArray(value) || !value.length || value.length > maximum) {
+        throw new Error(`${label} must contain 1–${maximum} entries`);
+    }
+    return value;
+}
+function unique(values, label) {
+    if (new Set(values).size !== values.length) {
+        throw new Error(`Duplicate ${label}`);
+    }
+}
+export function validateReleasePlan(raw) {
+    const value = mapObject(raw, "Design release plan", [
+        "schemaVersion",
+        "kind",
+        "id",
+        "title",
+        "productVersion",
+        "fileId",
+        "screens",
+        "contracts",
+    ]);
+    if (value.schemaVersion !== 1 || value.kind !== "design-release-plan") {
+        throw new Error("Unsupported design release plan schema");
+    }
+    const screens = boundedList(value.screens, "Release screens", 100).map((entry) => screen(entry));
+    const contracts = boundedList(value.contracts, "Release contracts", 100).map((entry) => contract(entry));
+    unique(screens.map((entry) => entry.id), "screen IDs");
+    unique(screens.map((entry) => entry.frameId), "source frame IDs");
+    unique(contracts.map((entry) => entry.path), "contract paths");
+    return {
+        schemaVersion: 1,
+        kind: "design-release-plan",
+        ...releaseHeader(value),
+        screens,
+        contracts,
+    };
+}
+function receipt(raw) {
+    const value = mapObject(raw, "Release receipt", [
+        "sourceId",
+        "targetFrameId",
+        "sourceFrameId",
+        "targetPageId",
+        "nodeMap",
+        "sourceContentHash",
+        "targetContentHash",
+        "sourceInspection",
+        "targetInspection",
+        "originalRender",
+        "targetRender",
+        "decodedPixelsHash",
+        "width",
+        "height",
+    ]);
+    const nodeMap = mapObject(value.nodeMap, "Node map", Object.keys(value.nodeMap && typeof value.nodeMap === "object" ? value.nodeMap : {}));
+    if (!Object.keys(nodeMap).length || Object.keys(nodeMap).length > 20000) {
+        throw new Error("Release node map is empty or unbounded");
+    }
+    const mapped = Object.fromEntries(Object.entries(nodeMap).map(([from, to]) => [
+        mapId(from, "Source node ID"),
+        mapId(to, "Target node ID"),
+    ]));
+    unique(Object.values(mapped), "target descendant IDs");
+    if (!Number.isInteger(value.width) ||
+        Number(value.width) < 1 ||
+        !Number.isInteger(value.height) ||
+        Number(value.height) < 1) {
+        throw new Error("Receipt requires exact image dimensions");
+    }
+    return {
+        sourceId: mapId(value.sourceId, "Receipt source ID"),
+        targetFrameId: mapId(value.targetFrameId, "Receipt target frame ID"),
+        sourceFrameId: mapId(value.sourceFrameId, "Receipt source frame ID"),
+        targetPageId: mapId(value.targetPageId, "Receipt target page ID"),
+        nodeMap: mapped,
+        sourceContentHash: mapHash(value.sourceContentHash, "Source content hash"),
+        targetContentHash: mapHash(value.targetContentHash, "Target content hash"),
+        sourceInspection: releaseReference(value.sourceInspection),
+        targetInspection: releaseReference(value.targetInspection),
+        originalRender: releaseReference(value.originalRender),
+        targetRender: releaseReference(value.targetRender),
+        decodedPixelsHash: mapHash(value.decodedPixelsHash, "Decoded pixels hash"),
+        width: Number(value.width),
+        height: Number(value.height),
+    };
+}
+export function validateDesignRelease(raw) {
+    const value = mapObject(raw, "Design release", [
+        "schemaVersion",
+        "kind",
+        "id",
+        "title",
+        "productVersion",
+        "fileId",
+        "status",
+        "sources",
+        "contracts",
+        "target",
+        "receipts",
+        "maps",
+        "overview",
+        "fidelity",
+        "reviews",
+        "implementation",
+        "createdAt",
+        "finalized",
+    ]);
+    if (value.schemaVersion !== 1 ||
+        value.kind !== "design-release" ||
+        ![
+            "planned",
+            "awaiting-copy",
+            "verified",
+            "final",
+        ].includes(String(value.status))) {
+        throw new Error("Unsupported design release schema or state");
+    }
+    const sources = boundedList(value.sources, "Release sources", 100).map((entry) => {
+        const source = screen(entry, false);
+        return {
+            ...source,
+            contentHash: mapHash(entry.contentHash, "Pinned source content hash"),
+        };
+    });
+    const contracts = boundedList(value.contracts, "Release contracts", 100).map((entry) => {
+        const item = entry;
+        if (item.kind !== "journey-map" && item.kind !== "integration-map") {
+            throw new Error("Release contract kind unsupported");
+        }
+        return {
+            ...contract(item, false),
+            kind: item.kind,
+            id: mapId(item.id, "Release contract ID"),
+        };
+    });
+    const target = mapObject(value.target, "Release target", [
+        "name",
+        "ownerKey",
+        "pageId",
+        "overviewFrameId",
+    ]);
+    const implementation = mapObject(value.implementation, "Independent implementation status", [
+        "status",
+        "evidence",
+    ]);
+    if (![
+        "not-assessed",
+        "in-progress",
+        "verified",
+    ].includes(String(implementation.status)) ||
+        !Array.isArray(implementation.evidence) ||
+        implementation.evidence.length > 1000) {
+        throw new Error("Invalid implementation evidence status");
+    }
+    if (!Array.isArray(value.maps) || value.maps.length > 100) {
+        throw new Error("Invalid release map evidence list");
+    }
+    if (!Array.isArray(value.receipts) ||
+        value.receipts.length > 100 ||
+        !Array.isArray(value.reviews) ||
+        value.reviews.length > 100) {
+        throw new Error("Invalid release receipt/review list");
+    }
+    const result = {
+        schemaVersion: 1,
+        kind: "design-release",
+        ...releaseHeader(value),
+        status: value.status,
+        sources,
+        contracts,
+        target: {
+            name: mapText(target.name, "Release page name", 200),
+            ownerKey: mapHash(target.ownerKey, "Release ownership key"),
+            ...(target.pageId === undefined
+                ? {}
+                : {
+                    pageId: mapId(target.pageId, "Release page ID"),
+                }),
+            ...(target.overviewFrameId === undefined
+                ? {}
+                : {
+                    overviewFrameId: mapId(target.overviewFrameId, "Overview frame ID"),
+                }),
+        },
+        maps: value.maps.map((raw) => {
+            const item = mapObject(raw, "Release map evidence", [
+                "kind",
+                "id",
+                "boardId",
+                "contractHash",
+                "projection",
+                "render",
+            ]);
+            if (item.kind !== "journey-map" && item.kind !== "integration-map") {
+                throw new Error("Unsupported release map kind");
+            }
+            return {
+                kind: item.kind,
+                id: mapId(item.id, "Map ID"),
+                boardId: mapId(item.boardId, "Map board ID"),
+                contractHash: mapHash(item.contractHash, "Map contract hash"),
+                projection: releaseReference(item.projection),
+                render: releaseReference(item.render),
+            };
+        }),
+        receipts: value.receipts.map(receipt),
+        reviews: value.reviews.map(validateArtifactReview),
+        implementation: {
+            status: implementation.status,
+            evidence: implementation.evidence.map(releaseReference),
+        },
+        createdAt: mapText(value.createdAt, "Release creation time", 100),
+    };
+    if (result.target.name !== `release/${result.productVersion}` ||
+        result.target.ownerKey !==
+            observationHash({
+                id: result.id,
+                fileId: result.fileId,
+                productVersion: result.productVersion,
+            })) {
+        throw new Error("Release target name or ownership key changed");
+    }
+    unique(sources.map((entry) => entry.id), "source screen IDs");
+    unique(sources.map((entry) => entry.frameId), "source frame IDs");
+    unique(result.receipts.map((entry) => entry.sourceId), "receipt sources");
+    unique(result.receipts.map((entry) => entry.targetFrameId), "receipt targets");
+    for (const item of result.receipts) {
+        const source = sources.find((entry) => entry.id === item.sourceId);
+        if (!source ||
+            source.frameId !== item.sourceFrameId ||
+            item.targetPageId !== result.target.pageId ||
+            sources.some((entry) => entry.frameId === item.targetFrameId) ||
+            item.nodeMap[item.sourceFrameId] !== item.targetFrameId) {
+            throw new Error("Receipt does not bind the pinned source to an independent release target");
+        }
+    }
+    unique(result.maps.map((item) => `${item.kind}:${item.id}`), "release map identities");
+    if (value.overview !== undefined) {
+        const overview = mapObject(value.overview, "Overview evidence", [
+            "contentHash",
+            "render",
+            "decodedPixelsHash",
+        ]);
+        result.overview = {
+            contentHash: mapHash(overview.contentHash, "Overview content hash"),
+            render: releaseReference(overview.render),
+            decodedPixelsHash: mapHash(overview.decodedPixelsHash, "Overview decoded pixels hash"),
+        };
+    }
+    if (value.fidelity !== undefined) {
+        const evidence = mapObject(value.fidelity, "Release fidelity", [
+            "schemaVersion",
+            "kind",
+            "verifiedAt",
+            "receiptsHash",
+            "exactDecodedPixels",
+            "nativeStructure",
+        ]);
+        if (evidence.schemaVersion !== 1 ||
+            evidence.kind !== "design-release-fidelity" ||
+            evidence.exactDecodedPixels !== true ||
+            evidence.nativeStructure !== true ||
+            mapHash(evidence.receiptsHash, "Receipts hash") !== observationHash(result.receipts) ||
+            result.receipts.length !== sources.length) {
+            throw new Error("Fidelity evidence does not bind all screen receipts");
+        }
+        result.fidelity = {
+            schemaVersion: 1,
+            kind: "design-release-fidelity",
+            verifiedAt: mapText(evidence.verifiedAt, "Verification time", 100),
+            receiptsHash: String(evidence.receiptsHash),
+            exactDecodedPixels: true,
+            nativeStructure: true,
+        };
+    }
+    if ((result.status === "verified" || result.status === "final") && !result.fidelity) {
+        throw new Error("Verified releases require complete fidelity evidence");
+    }
+    if (value.finalized !== undefined) {
+        const final = mapObject(value.finalized, "Final release pointer", [
+            "bundle",
+            "markerHash",
+            "reviewHash",
+        ]);
+        result.finalized = {
+            bundle: releaseReference(final.bundle),
+            markerHash: mapHash(final.markerHash, "Final marker hash"),
+            reviewHash: mapHash(final.reviewHash, "Final review hash"),
+        };
+    }
+    if ((result.status === "final") !== Boolean(result.finalized)) {
+        throw new Error("Final release status requires a finalized immutable bundle pointer");
+    }
+    return result;
+}
+/** Owner review scopes immutable design evidence; implementation acceptance is independent. */
+export function hashDesignRelease(raw) {
+    const release = validateDesignRelease(raw);
+    const { status: _status, reviews: _reviews, createdAt: _createdAt, finalized: _finalized, implementation: _implementation, ...candidate } = release;
+    return observationHash(candidate);
+}

package/dist/design-releases/verify.d.ts

@@ -0,0 +1,3 @@
+import type { PenpotToolClient } from "../client.js";
+import type { DesignRelease, ReceiptInput, ReleaseOptions } from "./types.js";
+export declare function verifyRelease(client: PenpotToolClient, root: string, raw: DesignRelease, inputs: ReceiptInput[], options?: ReleaseOptions): Promise<DesignRelease>;

package/dist/design-releases/verify.js

@@ -0,0 +1,148 @@
+import { exportShapePng } from "../export.js";
+import { observationHash } from "../journal.js";
+import { withPageSession, selectPage } from "../page-session.js";
+import { readArtifact, saveArtifact } from "./artifact-paths.js";
+import { compareNativeCopy, decodedPixels, deriveNodeMap, inspectionContentHash, } from "./fidelity.js";
+import { assertSourceUnchanged, captureReleaseScreen, observeRelease, releaseClient, } from "./live.js";
+import { assertReleaseContracts } from "./store.js";
+import { validateDesignRelease } from "./validation.js";
+export async function verifyRelease(client, root, raw, inputs, options = {}) {
+    const release = validateDesignRelease(raw);
+    if (release.status === "final") {
+        throw new Error("Finalized releases cannot replace fidelity evidence");
+    }
+    if (!release.target.pageId ||
+        !release.target.overviewFrameId ||
+        !release.overview ||
+        release.maps.length !== release.contracts.length) {
+        throw new Error("Release page, overview and native maps must be assembled first");
+    }
+    if (!Array.isArray(inputs) ||
+        inputs.length !== release.sources.length ||
+        new Set(inputs.map((item) => item.sourceId)).size !== inputs.length ||
+        new Set(inputs.map((item) => item.targetFrameId)).size !== inputs.length) {
+        throw new Error("Explicit complete source-to-target receipts are required; duplicate receipts conflict");
+    }
+    if (inputs.some((item) => !release.sources.some((source) => source.id === item.sourceId) ||
+        release.sources.some((source) => source.frameId === item.targetFrameId))) {
+        throw new Error("Receipt uses an unknown source or an original source as target");
+    }
+    await assertReleaseContracts(root, release.contracts, false, undefined, release.fileId);
+    client = releaseClient(client, release);
+    return withPageSession(client, async () => {
+        const owned = await observeRelease(client, release);
+        if (owned.marker?.status !== "draft") {
+            throw new Error("Release is not an owned mutable draft");
+        }
+        const observations = [];
+        const fullMap = {};
+        for (const source of release.sources) {
+            const input = inputs.find((item) => item.sourceId === source.id);
+            if (!source.render) {
+                throw new Error("Pinned source render is required before native fidelity verification");
+            }
+            const original = await assertSourceUnchanged(client, root, release, source);
+            const copied = await captureReleaseScreen(client, release.fileId, release.target.pageId, input.targetFrameId);
+            const mapping = deriveNodeMap(original, copied);
+            for (const [from, to] of Object.entries(mapping)) {
+                if (Object.hasOwn(fullMap, from) || Object.values(fullMap).includes(to)) {
+                    throw new Error("Duplicate or overlapping source/target descendants conflict");
+                }
+                fullMap[from] = to;
+            }
+            observations.push({
+                source,
+                input,
+                original,
+                copied,
+            });
+        }
+        const receipts = [];
+        for (const { source, input, original, copied } of observations) {
+            const content = compareNativeCopy(original, copied, fullMap);
+            const frozen = await decodedPixels(await readArtifact(root, source.render, 64 * 1024 * 1024));
+            await selectPage(client, {
+                id: source.pageId,
+            });
+            const sourceImage = await exportShapePng(client, source.frameId, {
+                ...options.exportOptions,
+                stable: true,
+            });
+            await selectPage(client, {
+                id: release.target.pageId,
+            });
+            const targetImage = await exportShapePng(client, input.targetFrameId, {
+                ...options.exportOptions,
+                stable: true,
+            });
+            if (!sourceImage.stable ||
+                !targetImage.stable ||
+                sourceImage.capture.fileId !== release.fileId ||
+                sourceImage.capture.pageId !== source.pageId ||
+                targetImage.capture.fileId !== release.fileId ||
+                targetImage.capture.pageId !== release.target.pageId) {
+                throw new Error("Stable source and target render provenance is required");
+            }
+            const environment = (image) => ({
+                scale: image.capture.scale,
+                api: image.capture.penpotApiVersion,
+                render: image.capture.renderEnvironment,
+                themes: image.capture.activeThemeIds,
+                activeThemes: image.capture.activeThemes,
+            });
+            if (observationHash(environment(sourceImage)) !== observationHash(environment(targetImage))) {
+                throw new Error("Source and target render environments or themes differ");
+            }
+            const before = await decodedPixels(sourceImage.png);
+            const after = await decodedPixels(targetImage.png);
+            if (before.width !== after.width ||
+                before.height !== after.height ||
+                before.width !== frozen.width ||
+                before.height !== frozen.height ||
+                before.hash !== after.hash ||
+                before.hash !== frozen.hash) {
+                throw new Error("Native copy or pinned source changed exact decoded pixels or image dimensions");
+            }
+            const sourceAfter = await assertSourceUnchanged(client, root, release, source);
+            const targetAfter = await captureReleaseScreen(client, release.fileId, release.target.pageId, input.targetFrameId);
+            compareNativeCopy(sourceAfter, targetAfter, fullMap);
+            if (observationHash(deriveNodeMap(sourceAfter, targetAfter)) !==
+                observationHash(deriveNodeMap(original, copied))) {
+                throw new Error("Native descendant identities changed during fidelity capture");
+            }
+            if (inspectionContentHash(sourceAfter) !== source.contentHash) {
+                throw new Error("Source changed during fidelity capture");
+            }
+            const prefix = `design/releases/${release.productVersion}/evidence/screens/${source.id}`;
+            receipts.push({
+                ...input,
+                sourceFrameId: source.frameId,
+                targetPageId: release.target.pageId,
+                nodeMap: deriveNodeMap(original, copied),
+                sourceContentHash: content.sourceHash,
+                targetContentHash: content.targetHash,
+                sourceInspection: await saveArtifact(root, `${prefix}-source-${observationHash(sourceAfter)}.json`, `${JSON.stringify(sourceAfter, null, 2)}\n`, options.redact),
+                targetInspection: await saveArtifact(root, `${prefix}-target-${observationHash(targetAfter)}.json`, `${JSON.stringify(targetAfter, null, 2)}\n`, options.redact),
+                originalRender: await saveArtifact(root, `${prefix}-source-${before.hash}.png`, sourceImage.png, options.redact),
+                targetRender: await saveArtifact(root, `${prefix}-target-${after.hash}.png`, targetImage.png, options.redact),
+                decodedPixelsHash: before.hash,
+                width: before.width,
+                height: before.height,
+            });
+        }
+        return validateDesignRelease({
+            ...release,
+            status: "verified",
+            receipts,
+            fidelity: {
+                schemaVersion: 1,
+                kind: "design-release-fidelity",
+                verifiedAt: new Date().toISOString(),
+                receiptsHash: observationHash(receipts),
+                exactDecodedPixels: true,
+                nativeStructure: true,
+            },
+            reviews: [],
+        });
+    });
+}

package/dist/image-codec.d.ts

@@ -0,0 +1,3 @@
+import { type BaselineImageFormat } from "./image-evidence.js";
+/** Keep PNG byte identity, or deterministically encode the same pixels as lossless WebP. */
+export declare function encodeBaselineImage(png: Buffer, format: BaselineImageFormat): Promise<Buffer>;

package/dist/image-codec.js

@@ -0,0 +1,78 @@
+import { inspectImageEvidence } from "./image-evidence.js";
+const maximumDecodedPixels = 64_000_000;
+function assertStaticPng(bytes) {
+    let offset = 8;
+    while (offset < bytes.length) {
+        if (offset + 12 > bytes.length) {
+            throw new Error("Truncated PNG cannot be encoded as lossless WebP");
+        }
+        const length = bytes.readUInt32BE(offset);
+        const end = offset + length + 12;
+        const chunk = bytes.subarray(offset + 4, offset + 8).toString("latin1");
+        if (end > bytes.length) {
+            throw new Error("Truncated PNG cannot be encoded as lossless WebP");
+        }
+        if (chunk === "acTL" || chunk === "fcTL" || chunk === "fdAT") {
+            throw new Error("Lossless WebP encoding requires a static 8-bit PNG");
+        }
+        offset = end;
+    }
+}
+/** Keep PNG byte identity, or deterministically encode the same pixels as lossless WebP. */
+export async function encodeBaselineImage(png, format) {
+    const source = inspectImageEvidence(png);
+    if (source.format !== "png" || (format !== "png" && format !== "webp")) {
+        throw new Error("Baseline encoding requires PNG input and png or webp output");
+    }
+    if (source.width * source.height > maximumDecodedPixels) {
+        throw new Error("Baseline image exceeds the 64-megapixel decode budget");
+    }
+    if (format === "png") {
+        return Buffer.from(png);
+    }
+    assertStaticPng(png);
+    const { default: sharp } = await import("sharp");
+    const decoder = sharp(png, {
+        failOn: "error",
+        limitInputPixels: maximumDecodedPixels,
+    });
+    const metadata = await decoder.metadata();
+    if (metadata.depth !== "uchar" || (metadata.pages ?? 1) !== 1 || metadata.bitsPerSample === 16) {
+        throw new Error("Lossless WebP encoding requires a static 8-bit PNG");
+    }
+    const encoded = await decoder
+        .keepIccProfile()
+        .webp({
+        lossless: true,
+        exact: true,
+        effort: 6,
+    })
+        .toBuffer();
+    const output = inspectImageEvidence(encoded);
+    if (output.format !== "webp" ||
+        output.width !== source.width ||
+        output.height !== source.height) {
+        throw new Error("Lossless WebP encoding changed image dimensions");
+    }
+    const verified = sharp(encoded, {
+        failOn: "error",
+        limitInputPixels: maximumDecodedPixels,
+    });
+    const encodedMetadata = await verified.metadata();
+    if (Boolean(metadata.icc) !== Boolean(encodedMetadata.icc) ||
+        (metadata.icc && !metadata.icc.equals(encodedMetadata.icc))) {
+        throw new Error("Lossless WebP encoding changed the ICC profile");
+    }
+    const before = await sharp(png, {
+        failOn: "error",
+        limitInputPixels: maximumDecodedPixels,
+    })
+        .ensureAlpha()
+        .raw()
+        .toBuffer();
+    const after = await verified.ensureAlpha().raw().toBuffer();
+    if (!before.equals(after)) {
+        throw new Error("Lossless WebP encoding changed RGBA pixels");
+    }
+    return encoded;
+}

package/dist/image-evidence.d.ts

@@ -0,0 +1,15 @@
+export type BaselineImageFormat = "png" | "webp";
+export declare const maximumImageBytes: number;
+interface ImageSize {
+    width: number;
+    height: number;
+}
+export interface ImageMetadata extends ImageSize {
+    format: BaselineImageFormat;
+}
+/** Header/container assurance only; this does not decode compressed pixels. */
+export declare function inspectImageEvidence(bytes: Buffer): ImageMetadata;
+export declare function readImageEvidence(root: string, file: string): Promise<{
+    bytes: Buffer;
+} & ImageMetadata>;
+export {};