@nodetool-ai/base-nodes 0.7.0-rc.23 → 0.8.2

package/dist/nodes/image.js

@@ -1,1395 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { BaseNode, prop } from "@nodetool-ai/node-sdk";
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import sharp from "sharp";
-function toBytes(data) {
-    if (!data)
-        return new Uint8Array();
-    if (data instanceof Uint8Array)
-        return data;
-    return Uint8Array.from(Buffer.from(data, "base64"));
-}
-function imageBytes(image) {
-    if (!image || typeof image !== "object")
-        return new Uint8Array();
-    return toBytes(image.data);
-}
-async function imageBytesAsync(image, context) {
-    if (!image || typeof image !== "object")
-        return new Uint8Array();
-    const ref = image;
-    if (ref.data)
-        return toBytes(ref.data);
-    if (typeof ref.uri === "string" && ref.uri) {
-        if (context?.storage) {
-            const stored = await context.storage.retrieve(ref.uri);
-            if (stored !== null)
-                return new Uint8Array(stored);
-        }
-        if (ref.uri.startsWith("file://")) {
-            return new Uint8Array(await fs.readFile(filePath(ref.uri)));
-        }
-        if (ref.uri.startsWith("http://") || ref.uri.startsWith("https://")) {
-            const response = await fetch(ref.uri);
-            return new Uint8Array(await response.arrayBuffer());
-        }
-    }
-    return new Uint8Array();
-}
-function filePath(uriOrPath) {
-    if (uriOrPath.startsWith("file://")) {
-        try {
-            return fileURLToPath(new URL(uriOrPath));
-        }
-        catch {
-            // Fallback for non-standard URIs like file://C:\path
-            return uriOrPath.slice("file://".length);
-        }
-    }
-    return uriOrPath;
-}
-function dateName(name) {
-    const now = new Date();
-    const pad = (v) => String(v).padStart(2, "0");
-    return name
-        .replaceAll("%Y", String(now.getFullYear()))
-        .replaceAll("%m", pad(now.getMonth() + 1))
-        .replaceAll("%d", pad(now.getDate()))
-        .replaceAll("%H", pad(now.getHours()))
-        .replaceAll("%M", pad(now.getMinutes()))
-        .replaceAll("%S", pad(now.getSeconds()));
-}
-function imageRef(data, extras = {}) {
-    return {
-        type: "image",
-        data: Buffer.from(data).toString("base64"),
-        ...extras
-    };
-}
-function inferImageMime(uri, bytes) {
-    const lower = (uri ?? "").toLowerCase();
-    if (lower.endsWith(".jpg") || lower.endsWith(".jpeg"))
-        return "image/jpeg";
-    if (lower.endsWith(".webp"))
-        return "image/webp";
-    if (lower.endsWith(".gif"))
-        return "image/gif";
-    if (lower.endsWith(".bmp"))
-        return "image/bmp";
-    if (bytes.length < 4)
-        return "image/unknown";
-    if (bytes[0] === 0xff && bytes[1] === 0xd8)
-        return "image/jpeg";
-    if (bytes[0] === 0x47 && bytes[1] === 0x49)
-        return "image/gif";
-    if (bytes[0] === 0x42 && bytes[1] === 0x4d)
-        return "image/bmp";
-    if (bytes[0] === 0x52 && bytes[1] === 0x49 && bytes[8] === 0x57)
-        return "image/webp";
-    if (bytes[0] === 0x89 &&
-        bytes[1] === 0x50 &&
-        bytes[2] === 0x4e &&
-        bytes[3] === 0x47) {
-        return "image/png";
-    }
-    return "image/unknown";
-}
-function getModelConfig(props) {
-    const model = (props.model ?? {});
-    return {
-        providerId: typeof model.provider === "string" ? model.provider : "",
-        modelId: typeof model.id === "string" ? model.id : ""
-    };
-}
-const IMAGE_ASPECT_RATIOS = {
-    "21:9": [21, 9],
-    "16:9": [16, 9],
-    "3:2": [3, 2],
-    "7:5": [7, 5],
-    "4:3": [4, 3],
-    "5:4": [5, 4],
-    "1:1": [1, 1],
-    "9:16": [9, 16],
-    "2:3": [2, 3],
-    "5:7": [5, 7],
-    "3:4": [3, 4],
-    "4:5": [4, 5]
-};
-const IMAGE_RESOLUTION_PX = {
-    "1K": 1024,
-    "2K": 2048,
-    "4K": 4096
-};
-function resolveImageSize(resolution, aspectRatio) {
-    const base = IMAGE_RESOLUTION_PX[resolution] ?? 1024;
-    const [aw, ah] = IMAGE_ASPECT_RATIOS[aspectRatio] ?? [1, 1];
-    if (aw >= ah) {
-        const height = base;
-        const width = Math.round((height * aw) / ah);
-        return { width, height };
-    }
-    const width = base;
-    const height = Math.round((width * ah) / aw);
-    return { width, height };
-}
-const IMAGE_ASPECT_RATIO_VALUES = Object.keys(IMAGE_ASPECT_RATIOS);
-const IMAGE_RESOLUTION_VALUES = Object.keys(IMAGE_RESOLUTION_PX);
-const IMAGE_EDIT_STRENGTH_VALUES = [0.25, 0.5, 0.65, 0.75, 0.85, 1.0];
-function hasProviderSupport(context, providerId, modelId) {
-    return (!!context &&
-        typeof context.runProviderPrediction === "function" &&
-        !!providerId &&
-        !!modelId);
-}
-async function metadataFor(bytes) {
-    try {
-        const md = await sharp(bytes).metadata();
-        return {
-            width: md.width ?? undefined,
-            height: md.height ?? undefined
-        };
-    }
-    catch {
-        return { width: undefined, height: undefined };
-    }
-}
-async function transformImage(image, operation, context) {
-    const bytes = await imageBytesAsync(image, context);
-    if (bytes.length === 0) {
-        return imageRef(bytes, {
-            uri: image.uri ?? "",
-            width: image.width ?? undefined,
-            height: image.height ?? undefined
-        });
-    }
-    try {
-        const outputBytes = await operation(sharp(bytes, { failOn: "none" }), bytes).toBuffer();
-        const meta = await metadataFor(outputBytes);
-        return imageRef(outputBytes, {
-            uri: image.uri ?? "",
-            mimeType: inferImageMime(image.uri, outputBytes),
-            width: meta.width,
-            height: meta.height
-        });
-    }
-    catch {
-        return imageRef(bytes, {
-            uri: image.uri ?? "",
-            width: image.width ?? undefined,
-            height: image.height ?? undefined
-        });
-    }
-}
-export class LoadImageFileNode extends BaseNode {
-    static nodeType = "nodetool.image.LoadImageFile";
-    static title = "Load Image File";
-    static description = "Read an image file from disk.\n    image, input, load, file";
-    static metadataOutputTypes = {
-        output: "image"
-    };
-    async process() {
-        const p = filePath(String(this.path ?? ""));
-        const data = new Uint8Array(await fs.readFile(p));
-        const meta = await metadataFor(data);
-        return {
-            output: imageRef(data, {
-                uri: `file://${p}`,
-                mimeType: inferImageMime(p, data),
-                width: meta.width,
-                height: meta.height
-            })
-        };
-    }
-}
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Path",
-        description: "Path to the image file to read"
-    })
-], LoadImageFileNode.prototype, "path", void 0);
-export class LoadImageFolderNode extends BaseNode {
-    static nodeType = "nodetool.image.LoadImageFolder";
-    static title = "Load Image Folder";
-    static description = "Load all images from a folder, optionally including subfolders.\n    image, load, folder, files";
-    static metadataOutputTypes = {
-        image: "image",
-        path: "str",
-        images: "list"
-    };
-    static isStreamingOutput = true;
-    async process() {
-        const collected = [];
-        for await (const item of this._loadImages()) {
-            collected.push(item.image);
-        }
-        return {
-            image: collected[0] ?? {},
-            name: "",
-            images: collected
-        };
-    }
-    async *_loadImages() {
-        const raw = this.folder;
-        const folder = typeof raw === "string" && raw.length > 0
-            ? raw.startsWith("file:")
-                ? filePath(raw)
-                : raw
-            : typeof raw === "object" && raw !== null && typeof raw.uri === "string" && raw.uri.length > 0
-                ? filePath(raw.uri)
-                : "";
-        if (!folder)
-            return;
-        const extensions = Array.isArray(this.extensions)
-            ? this.extensions.map((e) => String(e).toLowerCase())
-            : [".png", ".jpg", ".jpeg", ".bmp", ".gif", ".webp", ".tiff"];
-        const patternStr = String(this.pattern ?? "");
-        const patternRegex = patternStr
-            ? new RegExp("^" +
-                patternStr
-                    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
-                    .replace(/\*/g, ".*")
-                    .replace(/\?/g, ".") +
-                "$", "i")
-            : null;
-        const files = [];
-        const collect = async (dir) => {
-            let entries;
-            try {
-                entries = await fs.readdir(dir, { withFileTypes: true });
-            }
-            catch {
-                // directory does not exist or is not accessible
-                return;
-            }
-            for (const entry of entries) {
-                if (entry.isDirectory() && this.include_subdirectories) {
-                    await collect(path.join(dir, entry.name));
-                }
-                else if (entry.isFile()) {
-                    files.push({ fullPath: path.join(dir, entry.name), name: entry.name });
-                }
-            }
-        };
-        await collect(folder);
-        for (const file of files) {
-            const ext = path.extname(file.name).toLowerCase();
-            if (!extensions.includes(ext))
-                continue;
-            if (patternRegex && !patternRegex.test(file.name))
-                continue;
-            const data = new Uint8Array(await fs.readFile(file.fullPath));
-            const meta = await metadataFor(data);
-            yield {
-                image: imageRef(data, {
-                    uri: `file://${file.fullPath}`,
-                    mimeType: inferImageMime(file.fullPath, data),
-                    width: meta.width,
-                    height: meta.height
-                }),
-                name: file.name
-            };
-        }
-    }
-    async *genProcess() {
-        const collected = [];
-        for await (const item of this._loadImages()) {
-            collected.push(item.image);
-            yield item;
-        }
-        yield { images: collected };
-    }
-}
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Folder",
-        description: "Folder to scan for images"
-    })
-], LoadImageFolderNode.prototype, "folder", void 0);
-__decorate([
-    prop({
-        type: "bool",
-        default: false,
-        title: "Include Subdirectories",
-        description: "Include images in subfolders"
-    })
-], LoadImageFolderNode.prototype, "include_subdirectories", void 0);
-__decorate([
-    prop({
-        type: "list[str]",
-        default: [".png", ".jpg", ".jpeg", ".bmp", ".gif", ".webp", ".tiff"],
-        title: "Extensions",
-        description: "Image file extensions to include"
-    })
-], LoadImageFolderNode.prototype, "extensions", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Pattern",
-        description: "Pattern to match image files"
-    })
-], LoadImageFolderNode.prototype, "pattern", void 0);
-export class SaveImageFileImageNode extends BaseNode {
-    static nodeType = "nodetool.image.SaveImageFile";
-    static title = "Save Image File";
-    static description = "Write an image to disk.\n    image, output, save, file";
-    static metadataOutputTypes = {
-        output: "image"
-    };
-    async process() {
-        const folder = String(this.folder ?? ".");
-        const filename = dateName(String(this.filename ?? "image.png"));
-        let p = filePath(path.resolve(folder, filename));
-        await fs.mkdir(path.dirname(p), { recursive: true });
-        if (!this.overwrite) {
-            const ext = path.extname(p);
-            const base = p.slice(0, p.length - ext.length);
-            let counter = 1;
-            while (true) {
-                try {
-                    await fs.access(p);
-                    p = `${base}_${counter}${ext}`;
-                    counter++;
-                }
-                catch {
-                    break;
-                }
-            }
-        }
-        await fs.writeFile(p, imageBytes(this.image));
-        return { output: p };
-    }
-}
-__decorate([
-    prop({
-        type: "image",
-        default: {
-            type: "image",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Image",
-        description: "The image to save"
-    })
-], SaveImageFileImageNode.prototype, "image", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Folder",
-        description: "Folder where the file will be saved"
-    })
-], SaveImageFileImageNode.prototype, "folder", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Filename",
-        description: "\n        The name of the image file.\n        You can use time and date variables to create unique names:\n        %Y - Year\n        %m - Month\n        %d - Day\n        %H - Hour\n        %M - Minute\n        %S - Second\n        "
-    })
-], SaveImageFileImageNode.prototype, "filename", void 0);
-__decorate([
-    prop({
-        type: "bool",
-        default: false,
-        title: "Overwrite",
-        description: "Overwrite the file if it already exists, otherwise file will be renamed"
-    })
-], SaveImageFileImageNode.prototype, "overwrite", void 0);
-export class LoadImageAssetsNode extends BaseNode {
-    static nodeType = "nodetool.image.LoadImageAssets";
-    static title = "Load Image Assets";
-    static description = "Load images from an asset folder.\n    load, image, file, import";
-    static metadataOutputTypes = {
-        image: "image",
-        name: "str",
-        images: "list"
-    };
-    static isStreamingOutput = true;
-    async process() {
-        const loader = new LoadImageFolderNode();
-        loader.assign({ folder: this.folder ?? "." });
-        const result = await loader.process();
-        return result;
-    }
-    async *genProcess() {
-        const loader = new LoadImageFolderNode();
-        loader.assign({ folder: this.folder ?? "." });
-        for await (const item of loader.genProcess()) {
-            yield item;
-        }
-    }
-}
-__decorate([
-    prop({
-        type: "folder",
-        default: {
-            type: "folder",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Folder",
-        description: "The asset folder to load the images from."
-    })
-], LoadImageAssetsNode.prototype, "folder", void 0);
-export class SaveImageNode extends BaseNode {
-    static nodeType = "nodetool.image.SaveImage";
-    static title = "Save Image Asset";
-    static description = "Save an image to specified asset folder with customizable name format.\n    save, image, folder, naming";
-    static metadataOutputTypes = {
-        output: "image"
-    };
-    async process(context) {
-        const bytes = await imageBytesAsync(this.image, context);
-        if (bytes.length === 0)
-            throw new Error("The input image is not connected.");
-        const name = dateName(String(this.name ?? "image.png"));
-        const mime = inferImageMime(undefined, bytes);
-        const meta = await metadataFor(bytes);
-        // Create asset via context (persists to DB + storage)
-        if (context && typeof context.createAsset === "function") {
-            const folderRef = this.folder;
-            const parentId = folderRef?.asset_id ?? null;
-            const asset = (await context.createAsset({
-                name,
-                contentType: mime === "image/unknown" ? "image/png" : mime,
-                content: bytes,
-                parentId,
-                nodeId: this.__node_id || null
-            }));
-            const assetId = asset.id;
-            const ext = name.includes(".") ? name.slice(name.lastIndexOf(".")) : ".png";
-            return {
-                output: imageRef(bytes, {
-                    uri: `asset://${assetId}${ext}`,
-                    mimeType: mime,
-                    width: meta.width,
-                    height: meta.height
-                })
-            };
-        }
-        // Fallback: write to filesystem
-        const folder = typeof this.folder === "string" ? this.folder : ".";
-        const full = path.resolve(folder, name);
-        await fs.mkdir(path.dirname(full), { recursive: true });
-        await fs.writeFile(full, bytes);
-        return {
-            output: imageRef(bytes, {
-                uri: `file://${full}`,
-                mimeType: mime,
-                width: meta.width,
-                height: meta.height
-            })
-        };
-    }
-}
-__decorate([
-    prop({
-        type: "image",
-        default: {
-            type: "image",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Image",
-        description: "The image to save."
-    })
-], SaveImageNode.prototype, "image", void 0);
-__decorate([
-    prop({
-        type: "folder",
-        default: {
-            type: "folder",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Folder",
-        description: "The asset folder to save the image in."
-    })
-], SaveImageNode.prototype, "folder", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "%Y-%m-%d_%H-%M-%S.png",
-        title: "Name",
-        description: "\n        Name of the output file.\n        You can use time and date variables to create unique names:\n        %Y - Year\n        %m - Month\n        %d - Day\n        %H - Hour\n        %M - Minute\n        %S - Second\n        "
-    })
-], SaveImageNode.prototype, "name", void 0);
-export class GetMetadataNode extends BaseNode {
-    static nodeType = "nodetool.image.GetMetadata";
-    static title = "Get Metadata";
-    static description = "Get metadata about the input image.\n    metadata, properties, analysis, information";
-    static metadataOutputTypes = {
-        format: "str",
-        mode: "str",
-        width: "int",
-        height: "int",
-        channels: "int"
-    };
-    async process(context) {
-        const image = (this.image ?? {});
-        const bytes = await imageBytesAsync(image, context);
-        try {
-            const md = await sharp(bytes).metadata();
-            const formatMap = {
-                jpeg: "JPEG",
-                png: "PNG",
-                webp: "WEBP",
-                gif: "GIF",
-                tiff: "TIFF",
-                svg: "SVG",
-                heif: "HEIF",
-                avif: "AVIF",
-                raw: "RAW"
-            };
-            const channelsToMode = {
-                1: "L",
-                2: "LA",
-                3: "RGB",
-                4: "RGBA"
-            };
-            return {
-                format: formatMap[md.format ?? ""] ?? (md.format ?? "unknown").toUpperCase(),
-                mode: channelsToMode[md.channels ?? 3] ?? "RGB",
-                width: md.width ?? 0,
-                height: md.height ?? 0,
-                channels: md.channels ?? 0
-            };
-        }
-        catch {
-            return {
-                format: "unknown",
-                mode: "RGB",
-                width: image.width ?? 0,
-                height: image.height ?? 0,
-                channels: 0
-            };
-        }
-    }
-}
-__decorate([
-    prop({
-        type: "image",
-        default: {
-            type: "image",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Image",
-        description: "The input image."
-    })
-], GetMetadataNode.prototype, "image", void 0);
-export class BatchToListNode extends BaseNode {
-    static nodeType = "nodetool.image.BatchToList";
-    static title = "Batch To List";
-    static description = "Convert an image batch to a list of image references.\n    batch, list, images, processing";
-    static metadataOutputTypes = {
-        output: "list[image]"
-    };
-    async process() {
-        const batch = this.batch;
-        if (!batch) {
-            throw new Error("Batch input is empty.");
-        }
-        const batchObj = batch;
-        if (batchObj.data == null) {
-            throw new Error("Batch data is null.");
-        }
-        if (!Array.isArray(batchObj.data)) {
-            // Single image ref — wrap in list
-            return { output: [batch] };
-        }
-        // Unwrap batch data into individual ImageRefs
-        const output = batchObj.data.map((item) => {
-            if (item instanceof Uint8Array || typeof item === "string") {
-                return imageRef(toBytes(item));
-            }
-            return item;
-        });
-        return { output };
-    }
-}
-__decorate([
-    prop({
-        type: "image",
-        default: {
-            type: "image",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Batch",
-        description: "The batch of images to convert."
-    })
-], BatchToListNode.prototype, "batch", void 0);
-export class ImagesToListNode extends BaseNode {
-    static nodeType = "nodetool.image.ImagesToList";
-    static title = "Images To List";
-    static description = "Convert all dynamic properties to a list of image references.\n    list, images, processing";
-    static metadataOutputTypes = {
-        output: "list[image]"
-    };
-    static isDynamic = true;
-    async process() {
-        const out = [];
-        for (const [, value] of this.dynamicProps) {
-            if (value == null)
-                continue;
-            if (Array.isArray(value)) {
-                for (const item of value) {
-                    if (item != null)
-                        out.push(item);
-                }
-            }
-            else {
-                out.push(value);
-            }
-        }
-        return { output: out };
-    }
-}
-class TransformImageNode extends BaseNode {
-    transformMeta() {
-        const image = (this.image ?? {});
-        return {
-            width: Number(this.width ?? image.width ?? 0) || null,
-            height: Number(this.height ?? image.height ?? 0) || null
-        };
-    }
-}
-export class PasteNode extends TransformImageNode {
-    static nodeType = "nodetool.image.Paste";
-    static title = "Paste";
-    static description = "Paste one image onto another at specified coordinates.\n    paste, composite, positioning, overlay";
-    static metadataOutputTypes = {
-        output: "image"
-    };
-    async process(context) {
-        const image = (this.image ?? {});
-        const paste = (this.paste ?? {});
-        const left = Math.max(0, Number(this.left ?? 0));
-        const top = Math.max(0, Number(this.top ?? 0));
-        const baseBytes = await imageBytesAsync(image, context);
-        const overlayBytes = await imageBytesAsync(paste, context);
-        if (baseBytes.length === 0 || overlayBytes.length === 0) {
-            return {
-                output: imageRef(baseBytes, {
-                    uri: image.uri ?? "",
-                    ...this.transformMeta()
-                })
-            };
-        }
-        try {
-            const outputBytes = await sharp(baseBytes, { failOn: "none" })
-                .composite([{ input: Buffer.from(overlayBytes), left, top }])
-                .toBuffer();
-            const meta = await metadataFor(outputBytes);
-            return {
-                output: imageRef(outputBytes, {
-                    uri: image.uri ?? "",
-                    mimeType: inferImageMime(image.uri, outputBytes),
-                    width: meta.width,
-                    height: meta.height
-                })
-            };
-        }
-        catch {
-            return {
-                output: imageRef(baseBytes, {
-                    uri: image.uri ?? "",
-                    ...this.transformMeta()
-                })
-            };
-        }
-    }
-}
-__decorate([
-    prop({
-        type: "image",
-        default: {
-            type: "image",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Image",
-        description: "The image to paste into."
-    })
-], PasteNode.prototype, "image", void 0);
-__decorate([
-    prop({
-        type: "image",
-        default: {
-            type: "image",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Paste",
-        description: "The image to paste."
-    })
-], PasteNode.prototype, "paste", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 0,
-        title: "Left",
-        description: "The left coordinate.",
-        min: 0,
-        max: 4096
-    })
-], PasteNode.prototype, "left", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 0,
-        title: "Top",
-        description: "The top coordinate.",
-        min: 0,
-        max: 4096
-    })
-], PasteNode.prototype, "top", void 0);
-export class ScaleNode extends TransformImageNode {
-    static nodeType = "nodetool.image.Scale";
-    static title = "Scale";
-    static description = "Enlarge or shrink an image by a scale factor.\n    image, resize, scale";
-    static metadataOutputTypes = {
-        output: "image"
-    };
-    async process(context) {
-        const image = (this.image ?? {});
-        const requestedScale = Number(this.scale ?? 0);
-        const targetWidth = 0;
-        const targetHeight = 0;
-        const scale = requestedScale > 0
-            ? requestedScale
-            : targetWidth > 0 && (image.width ?? 0) > 0
-                ? targetWidth / Number(image.width)
-                : targetHeight > 0 && (image.height ?? 0) > 0
-                    ? targetHeight / Number(image.height)
-                    : 1;
-        const output = (await transformImage(image, (instance) => {
-            const fallbackWidth = image.width ?? 1;
-            const fallbackHeight = image.height ?? 1;
-            return instance.resize({
-                width: Math.max(1, Math.round(fallbackWidth * scale)),
-                height: Math.max(1, Math.round(fallbackHeight * scale))
-            });
-        }, context));
-        const fallbackWidth = targetWidth > 0
-            ? targetWidth
-            : image.width != null
-                ? Math.max(1, Math.round(Number(image.width) * scale))
-                : null;
-        const fallbackHeight = targetHeight > 0
-            ? targetHeight
-            : image.height != null
-                ? Math.max(1, Math.round(Number(image.height) * scale))
-                : null;
-        return {
-            output: {
-                ...output,
-                width: fallbackWidth ?? output.width,
-                height: fallbackHeight ?? output.height
-            }
-        };
-    }
-}
-__decorate([
-    prop({
-        type: "image",
-        default: {
-            type: "image",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Image",
-        description: "The image to scale."
-    })
-], ScaleNode.prototype, "image", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 1,
-        title: "Scale",
-        description: "The scale factor.",
-        min: 0,
-        max: 10
-    })
-], ScaleNode.prototype, "scale", void 0);
-export class ResizeNode extends TransformImageNode {
-    static nodeType = "nodetool.image.Resize";
-    static title = "Resize";
-    static description = "Change image dimensions to specified width and height.\n    image, resize";
-    static metadataOutputTypes = {
-        output: "image"
-    };
-    async process(context) {
-        const image = (this.image ?? {});
-        const width = Number(this.width ?? image.width ?? 0) || null;
-        const height = Number(this.height ?? image.height ?? 0) || null;
-        const output = (await transformImage(image, (instance) => instance.resize(width ?? undefined, height ?? undefined), context));
-        return {
-            output: {
-                ...output,
-                width: output.width ?? width,
-                height: output.height ?? height
-            }
-        };
-    }
-}
-__decorate([
-    prop({
-        type: "image",
-        default: {
-            type: "image",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Image",
-        description: "The image to resize."
-    })
-], ResizeNode.prototype, "image", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 512,
-        title: "Width",
-        description: "The target width.",
-        min: 0,
-        max: 4096
-    })
-], ResizeNode.prototype, "width", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 512,
-        title: "Height",
-        description: "The target height.",
-        min: 0,
-        max: 4096
-    })
-], ResizeNode.prototype, "height", void 0);
-export class CropNode extends TransformImageNode {
-    static nodeType = "nodetool.image.Crop";
-    static title = "Crop";
-    static description = "Crop an image to specified coordinates.\n    image, crop";
-    static metadataOutputTypes = {
-        output: "image"
-    };
-    async process(context) {
-        const image = (this.image ?? {});
-        const left = Math.max(0, Number(this.left ?? 0));
-        const top = Math.max(0, Number(this.top ?? 0));
-        const right = Number(this.right ?? image.width ?? 0);
-        const bottom = Number(this.bottom ?? image.height ?? 0);
-        const width = Math.max(1, right - left);
-        const height = Math.max(1, bottom - top);
-        const output = (await transformImage(image, (instance) => instance.extract({ left, top, width, height }), context));
-        return {
-            output: {
-                ...output,
-                width: output.width ?? width,
-                height: output.height ?? height
-            }
-        };
-    }
-}
-__decorate([
-    prop({
-        type: "image",
-        default: {
-            type: "image",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Image",
-        description: "The image to crop."
-    })
-], CropNode.prototype, "image", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 0,
-        title: "Left",
-        description: "The left coordinate.",
-        min: 0,
-        max: 4096
-    })
-], CropNode.prototype, "left", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 0,
-        title: "Top",
-        description: "The top coordinate.",
-        min: 0,
-        max: 4096
-    })
-], CropNode.prototype, "top", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 512,
-        title: "Right",
-        description: "The right coordinate.",
-        min: 0,
-        max: 4096
-    })
-], CropNode.prototype, "right", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 512,
-        title: "Bottom",
-        description: "The bottom coordinate.",
-        min: 0,
-        max: 4096
-    })
-], CropNode.prototype, "bottom", void 0);
-export class FitNode extends TransformImageNode {
-    static nodeType = "nodetool.image.Fit";
-    static title = "Fit";
-    static description = "Resize an image to fit within specified dimensions while preserving aspect ratio.\n    image, resize, fit";
-    static metadataOutputTypes = {
-        output: "image"
-    };
-    async process(context) {
-        const image = (this.image ?? {});
-        const width = Math.max(1, Number(this.width ?? image.width ?? 512));
-        const height = Math.max(1, Number(this.height ?? image.height ?? 512));
-        const output = (await transformImage(image, (instance) => instance.resize(width, height, { fit: "cover", position: "centre" }), context));
-        return {
-            output: {
-                ...output,
-                width: output.width ?? width,
-                height: output.height ?? height
-            }
-        };
-    }
-}
-__decorate([
-    prop({
-        type: "image",
-        default: {
-            type: "image",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Image",
-        description: "The image to fit."
-    })
-], FitNode.prototype, "image", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 512,
-        title: "Width",
-        description: "Width to fit to.",
-        min: 1,
-        max: 4096
-    })
-], FitNode.prototype, "width", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 512,
-        title: "Height",
-        description: "Height to fit to.",
-        min: 1,
-        max: 4096
-    })
-], FitNode.prototype, "height", void 0);
-export class TextToImageNode extends BaseNode {
-    static nodeType = "nodetool.image.TextToImage";
-    static title = "Text To Image";
-    static description = "Generate images from text prompts using any supported image provider. Automatically routes to the appropriate backend (HuggingFace, FAL, MLX).\n    image, generation, AI, text-to-image, t2i";
-    static metadataOutputTypes = {
-        output: "image"
-    };
-    static basicFields = [
-        "model",
-        "prompt",
-        "aspect_ratio",
-        "resolution"
-    ];
-    static exposeAsTool = true;
-    static autoSaveAsset = true;
-    async process(context) {
-        const prompt = String(this.prompt ?? "");
-        const aspectRatio = String(this.aspect_ratio ?? "1:1");
-        const resolution = String(this.resolution ?? "1K");
-        const { width, height } = resolveImageSize(resolution, aspectRatio);
-        const { providerId, modelId } = getModelConfig(this.serialize());
-        if (!hasProviderSupport(context, providerId, modelId)) {
-            throw new Error("No provider available for text-to-image generation.");
-        }
-        const output = (await context.runProviderPrediction({
-            provider: providerId,
-            capability: "text_to_image",
-            model: modelId,
-            params: {
-                prompt,
-                width,
-                height,
-                aspect_ratio: aspectRatio,
-                resolution,
-                negative_prompt: this.negative_prompt
-            }
-        }));
-        const meta = await metadataFor(output);
-        return {
-            output: imageRef(output, {
-                mimeType: inferImageMime(undefined, output),
-                width: meta.width ?? width,
-                height: meta.height ?? height
-            })
-        };
-    }
-}
-__decorate([
-    prop({
-        type: "image_model",
-        default: {
-            type: "image_model",
-            provider: "huggingface_fal_ai",
-            id: "fal-ai/flux/schnell",
-            name: "FLUX.1 Schnell",
-            path: null,
-            supported_tasks: []
-        },
-        title: "Model",
-        description: "The image generation model to use"
-    })
-], TextToImageNode.prototype, "model", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "A cat holding a sign that says hello world",
-        title: "Prompt",
-        description: "Text prompt describing the desired image"
-    })
-], TextToImageNode.prototype, "prompt", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Negative Prompt",
-        description: "Text prompt describing what to avoid in the image"
-    })
-], TextToImageNode.prototype, "negative_prompt", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "1:1",
-        title: "Aspect Ratio",
-        description: "Aspect ratio of the generated image",
-        values: IMAGE_ASPECT_RATIO_VALUES,
-        json_schema_extra: { type: "media_aspect_ratio_image" }
-    })
-], TextToImageNode.prototype, "aspect_ratio", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "1K",
-        title: "Resolution",
-        description: "Output resolution (short edge in pixels)",
-        values: IMAGE_RESOLUTION_VALUES,
-        json_schema_extra: { type: "media_resolution_image" }
-    })
-], TextToImageNode.prototype, "resolution", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 0,
-        title: "Timeout Seconds",
-        description: "Timeout in seconds for API calls (0 = use provider default)",
-        min: 0,
-        max: 3600
-    })
-], TextToImageNode.prototype, "timeout_seconds", void 0);
-export class ImageToImageNode extends BaseNode {
-    static nodeType = "nodetool.image.ImageToImage";
-    static title = "Image To Image";
-    static description = "Transform images using text prompts with any supported image provider. Automatically routes to the appropriate backend (HuggingFace, FAL, MLX).\n    image, transformation, AI, image-to-image, i2i";
-    static metadataOutputTypes = {
-        output: "image"
-    };
-    static basicFields = [
-        "model",
-        "image",
-        "prompt",
-        "strength",
-        "aspect_ratio",
-        "resolution"
-    ];
-    static autoSaveAsset = true;
-    static exposeAsTool = true;
-    async process(context) {
-        const image = (this.image ?? {});
-        const bytes = await imageBytesAsync(image, context);
-        if (bytes.length === 0) {
-            throw new Error("The input image is empty.");
-        }
-        const aspectRatio = String(this.aspect_ratio ?? "1:1");
-        const resolution = String(this.resolution ?? "1K");
-        const { width, height } = resolveImageSize(resolution, aspectRatio);
-        const { providerId, modelId } = getModelConfig(this.serialize());
-        if (!hasProviderSupport(context, providerId, modelId)) {
-            throw new Error("No provider available for image-to-image generation.");
-        }
-        const output = (await context.runProviderPrediction({
-            provider: providerId,
-            capability: "image_to_image",
-            model: modelId,
-            params: {
-                image: bytes,
-                prompt: String(this.prompt ?? ""),
-                negative_prompt: this.negative_prompt,
-                target_width: width,
-                target_height: height,
-                aspect_ratio: aspectRatio,
-                resolution,
-                strength: this.strength,
-                scheduler: this.scheduler
-            }
-        }));
-        const meta = await metadataFor(output);
-        return {
-            output: imageRef(output, {
-                uri: image.uri ?? "",
-                mimeType: inferImageMime(image.uri, output),
-                width: meta.width,
-                height: meta.height
-            })
-        };
-    }
-}
-__decorate([
-    prop({
-        type: "image_model",
-        default: {
-            type: "image_model",
-            provider: "huggingface_fal_ai",
-            id: "fal-ai/flux/dev",
-            name: "FLUX.1 Dev",
-            path: null,
-            supported_tasks: []
-        },
-        title: "Model",
-        description: "The image generation model to use"
-    })
-], ImageToImageNode.prototype, "model", void 0);
-__decorate([
-    prop({
-        type: "image",
-        default: {
-            type: "image",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Image",
-        description: "Input image to transform"
-    })
-], ImageToImageNode.prototype, "image", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "A photorealistic version of the input image",
-        title: "Prompt",
-        description: "Text prompt describing the desired transformation"
-    })
-], ImageToImageNode.prototype, "prompt", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Negative Prompt",
-        description: "Text prompt describing what to avoid"
-    })
-], ImageToImageNode.prototype, "negative_prompt", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 0.65,
-        title: "Strength",
-        description: "How much to transform the input image (subtle = minor edit, strong = major edit)",
-        values: IMAGE_EDIT_STRENGTH_VALUES,
-        json_schema_extra: { type: "media_strength" }
-    })
-], ImageToImageNode.prototype, "strength", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "1:1",
-        title: "Aspect Ratio",
-        description: "Aspect ratio of the output image",
-        values: IMAGE_ASPECT_RATIO_VALUES,
-        json_schema_extra: { type: "media_aspect_ratio_image" }
-    })
-], ImageToImageNode.prototype, "aspect_ratio", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "1K",
-        title: "Resolution",
-        description: "Output resolution (short edge in pixels)",
-        values: IMAGE_RESOLUTION_VALUES,
-        json_schema_extra: { type: "media_resolution_image" }
-    })
-], ImageToImageNode.prototype, "resolution", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Scheduler",
-        description: "Scheduler to use (provider-specific)"
-    })
-], ImageToImageNode.prototype, "scheduler", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 0,
-        title: "Timeout Seconds",
-        description: "Timeout in seconds for API calls (0 = use provider default)",
-        min: 0,
-        max: 3600
-    })
-], ImageToImageNode.prototype, "timeout_seconds", void 0);
-export class RotateNode extends TransformImageNode {
-    static nodeType = "nodetool.image.Rotate";
-    static title = "Rotate";
-    static description = "Rotate an image by a specified angle in degrees.\n    image, rotate, angle, transform, orientation";
-    static metadataOutputTypes = {
-        output: "image"
-    };
-    async process(context) {
-        const image = (this.image ?? {});
-        const angle = Number(this.angle ?? 0);
-        if (angle === 0) {
-            const bytes = await imageBytesAsync(image, context);
-            return {
-                output: imageRef(bytes, {
-                    uri: image.uri ?? "",
-                    width: image.width ?? undefined,
-                    height: image.height ?? undefined
-                })
-            };
-        }
-        return transformImage(image, (instance) => instance.rotate(angle, { background: { r: 0, g: 0, b: 0, alpha: 0 } }), context);
-    }
-}
-__decorate([
-    prop({
-        type: "image",
-        default: {
-            type: "image",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Image",
-        description: "The image to rotate."
-    })
-], RotateNode.prototype, "image", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 0,
-        title: "Angle",
-        description: "Rotation angle in degrees (clockwise).",
-        min: -360,
-        max: 360
-    })
-], RotateNode.prototype, "angle", void 0);
-export class FlipNode extends TransformImageNode {
-    static nodeType = "nodetool.image.Flip";
-    static title = "Flip";
-    static description = "Flip an image horizontally or vertically.\n    image, flip, mirror, horizontal, vertical, transform";
-    static metadataOutputTypes = {
-        output: "image"
-    };
-    async process(context) {
-        const image = (this.image ?? {});
-        const direction = String(this.direction ?? "horizontal");
-        return transformImage(image, (instance) => direction === "vertical" ? instance.flip() : instance.flop(), context);
-    }
-}
-__decorate([
-    prop({
-        type: "image",
-        default: {
-            type: "image",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Image",
-        description: "The image to flip."
-    })
-], FlipNode.prototype, "image", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "horizontal",
-        title: "Direction",
-        description: "Flip direction.",
-        values: ["horizontal", "vertical"]
-    })
-], FlipNode.prototype, "direction", void 0);
-export const IMAGE_NODES = [
-    LoadImageFileNode,
-    LoadImageFolderNode,
-    SaveImageFileImageNode,
-    LoadImageAssetsNode,
-    SaveImageNode,
-    GetMetadataNode,
-    BatchToListNode,
-    ImagesToListNode,
-    PasteNode,
-    ScaleNode,
-    ResizeNode,
-    CropNode,
-    FitNode,
-    RotateNode,
-    FlipNode,
-    TextToImageNode,
-    ImageToImageNode
-];
-//# sourceMappingURL=image.js.map