@nodetool-ai/base-nodes 0.7.0-rc.11

package/dist/nodes/image.js

@@ -0,0 +1,1395 @@
+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