@nodetool-ai/atlascloud-nodes 0.8.1

package/dist/atlascloud-factory.js

@@ -0,0 +1,730 @@
+/**
+ * Dynamic AtlasCloud node-class factory.
+ *
+ * Generates node classes from `atlascloud-manifest.json` at runtime, mirroring
+ * the topaz-nodes and kie-nodes factories. Each manifest entry declares a
+ * model id, modality, output type, and the input fields exposed in the node
+ * UI. The generated class extends `BaseNode`, so `BaseNode._injectSecrets`
+ * resolves `ATLASCLOUD_API_KEY` from `context.getSecret(...)` and surfaces it
+ * as `this._secrets.ATLASCLOUD_API_KEY` inside `process()`.
+ */
+import { applyContentCardBody, BaseNode, classifyFields, classNameToTitle, defaultForPropType, propertyOf, registerDeclaredProperty } from "@nodetool-ai/node-sdk";
+import { fetchExternalMedia, loadMediaRefBytes, mapPromptAssetsToInputs } from "@nodetool-ai/runtime";
+import { atlasAwaitResult, atlasDownload, atlasUploadMedia, atlasSubmit, getApiKey, pickOutputUrl } from "./atlascloud-base.js";
+/** True for a single-asset field type. */
+function isAssetFieldType(type) {
+    return type === "image" || type === "video" || type === "audio";
+}
+/** The asset kind a `list[...]` field wraps, or null for any other field. */
+function listAssetKind(type) {
+    if (type === "list[image]")
+        return "image";
+    if (type === "list[video]")
+        return "video";
+    if (type === "list[audio]")
+        return "audio";
+    return null;
+}
+/**
+ * In-flight raw-RGBA images (protocol `RAW_RGBA_MIME`) carry straight-alpha
+ * pixels in `data`, not an encoded file. `loadMediaRefBytes` PNG-encodes them,
+ * so the outgoing data URI must say `image/png` rather than the ref's mime.
+ */
+const RAW_RGBA_MIME = "image/x-raw-rgba";
+/** Narrow a node property value to a string. */
+function isStringValue(value) {
+    return typeof value === "string";
+}
+/** Narrow a node property value to an image or video reference. */
+function isVisualReference(value) {
+    if (typeof value !== "object" ||
+        value === null ||
+        Array.isArray(value) ||
+        value instanceof Uint8Array) {
+        return false;
+    }
+    return value.type === "image" || value.type === "video";
+}
+/** Narrow a node property value to a number. */
+function isNumberValue(value) {
+    return typeof value === "number";
+}
+/** Narrow a node property value to a boolean. */
+function isBooleanValue(value) {
+    return typeof value === "boolean";
+}
+/** Narrow a node property value to a media ref object (not a list or bytes). */
+function isAssetRef(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        !(value instanceof Uint8Array));
+}
+/** True when a ref's `data` slot holds a non-empty inline payload string. */
+function isInlineText(data) {
+    return typeof data === "string" && data.length > 0;
+}
+function looksLikePublicUrl(s) {
+    return s !== undefined && isSafeHttpUrl(s);
+}
+/**
+ * Validate an http(s) URL for outbound fetching from the workflow runtime.
+ *
+ * Returns false for any host that points back at the runtime host or its
+ * private network — defense against SSRF via user-controllable asset URIs.
+ * Workflow inputs (ImageRef.uri etc.) can be set by anyone who can submit a
+ * graph; without this check, the worker would happily proxy requests to
+ *   - localhost / loopback (any service bound to 127.0.0.1)
+ *   - RFC1918 private space (10.*, 172.16-31.*, 192.168.*)
+ *   - 169.254.169.254 (AWS / GCP / Azure instance metadata)
+ *   - IPv6 loopback / link-local / unique-local equivalents
+ *
+ * Note: this is hostname-string-based, not a resolved-IP check, so it can be
+ * bypassed by a public DNS name that resolves to a private IP (DNS rebinding).
+ * That's a known limitation — fixing it properly requires resolving DNS in
+ * the same socket dance as the eventual fetch(). The string check is what
+ * the canonical fal/replicate/topaz providers use today, hardened here against
+ * the inet_aton-style numeric encodings (decimal/hex/octal, short-form) and
+ * IPv4-mapped IPv6 that the OS resolver still accepts but a naive dotted-quad
+ * regex misses.
+ */
+function isSafeHttpUrl(uri) {
+    let u;
+    try {
+        u = new URL(uri);
+    }
+    catch {
+        return false;
+    }
+    if (u.protocol !== "http:" && u.protocol !== "https:")
+        return false;
+    return !isPrivateOrLocalHost(u.hostname);
+}
+/** Parse a single inet_aton component: decimal, 0x-hex, or 0-prefixed octal. */
+function parseIpComponent(part) {
+    if (/^0x[0-9a-f]+$/i.test(part))
+        return parseInt(part.slice(2), 16);
+    if (/^0[0-7]+$/.test(part))
+        return parseInt(part, 8);
+    if (/^[0-9]+$/.test(part))
+        return parseInt(part, 10);
+    return null;
+}
+/**
+ * Parse `host` as IPv4 using inet_aton semantics, which `getaddrinfo` (and thus
+ * `fetch`) honors: `a.b.c.d`, the short forms `a.b.c` / `a.b` / `a`, and each
+ * component in decimal, hex (`0x7f`), or octal (`0177`). Returns the four
+ * octets, or null when the host isn't a numeric IPv4 in any of these forms.
+ */
+function ipv4ToOctets(host) {
+    const parts = host.split(".");
+    if (parts.length === 0 || parts.length > 4)
+        return null;
+    const nums = [];
+    for (const part of parts) {
+        const n = parseIpComponent(part);
+        if (n === null || n < 0)
+            return null;
+        nums.push(n);
+    }
+    // Every component but the last must fit in one octet; the final component
+    // absorbs all remaining low-order octets (e.g. "127.1" → 127.0.0.1).
+    const n = nums.length;
+    for (let i = 0; i < n - 1; i++) {
+        if (nums[i] > 0xff)
+            return null;
+    }
+    const tailOctets = 4 - (n - 1);
+    const tail = nums[n - 1];
+    if (tail < 0 || tail > 0xffffffff || tail >= 2 ** (tailOctets * 8))
+        return null;
+    let value = tail;
+    for (let i = 0; i < n - 1; i++) {
+        value += nums[i] * 256 ** (3 - i);
+    }
+    return [
+        (value >>> 24) & 0xff,
+        (value >>> 16) & 0xff,
+        (value >>> 8) & 0xff,
+        value & 0xff
+    ];
+}
+/** Extract the embedded IPv4 from an IPv4-mapped / -compatible IPv6 address. */
+function mappedIpv4ToOctets(host) {
+    // Dotted tail: ::ffff:127.0.0.1 or the deprecated compat form ::127.0.0.1
+    const dotted = /^::(?:ffff:)?(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/i.exec(host);
+    if (dotted)
+        return ipv4ToOctets(dotted[1]);
+    // Hex tail: ::ffff:7f00:1
+    const hex = /^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i.exec(host);
+    if (hex) {
+        const hi = parseInt(hex[1], 16);
+        const lo = parseInt(hex[2], 16);
+        return [(hi >> 8) & 0xff, hi & 0xff, (lo >> 8) & 0xff, lo & 0xff];
+    }
+    return null;
+}
+function isPrivateV4(octets) {
+    const [o1, o2] = octets;
+    if (o1 === 0)
+        return true; // 0.0.0.0/8 — "this network"
+    if (o1 === 10)
+        return true; // RFC1918
+    if (o1 === 127)
+        return true; // loopback
+    if (o1 === 169 && o2 === 254)
+        return true; // link-local incl. cloud metadata
+    if (o1 === 172 && o2 >= 16 && o2 <= 31)
+        return true; // RFC1918
+    if (o1 === 192 && o2 === 168)
+        return true; // RFC1918
+    if (o1 === 100 && o2 >= 64 && o2 <= 127)
+        return true; // CGNAT
+    return false;
+}
+function isPrivateOrLocalHost(hostname) {
+    // URL.hostname returns IPv6 wrapped in brackets ("[::1]") on Node — strip
+    // before pattern matching so the v6 cases below work on the bare form.
+    let h = hostname.toLowerCase();
+    if (h.startsWith("[") && h.endsWith("]"))
+        h = h.slice(1, -1);
+    if (h === "" || h === "localhost" || h.endsWith(".localhost"))
+        return true;
+    // IPv4 in any inet_aton-accepted spelling, or embedded in a mapped IPv6.
+    const octets = ipv4ToOctets(h) ?? mappedIpv4ToOctets(h);
+    if (octets)
+        return isPrivateV4(octets);
+    // Pure IPv6 — URL.hostname returns bracket-stripped form ("::1", "fe80::1").
+    if (h === "::1" || h === "::")
+        return true;
+    if (h.startsWith("fe80:") || h.startsWith("fe80::"))
+        return true; // link-local
+    // ULA range fc00::/7 — first nibble is f, second is c or d
+    if (/^f[cd][0-9a-f]{2}:/i.test(h))
+        return true;
+    return false;
+}
+function bytesToDataUri(bytes, mime) {
+    return `data:${mime};base64,${Buffer.from(bytes).toString("base64")}`;
+}
+function guessMime(ref, fallback) {
+    if (ref?.mime_type)
+        return ref.mime_type;
+    if (ref?.mimeType)
+        return ref.mimeType;
+    if (ref?.metadata?.mime_type)
+        return ref.metadata.mime_type;
+    const uri = ref?.uri ?? "";
+    if (/\.jpe?g(?:[?#]|$)/i.test(uri))
+        return "image/jpeg";
+    if (/\.png(?:[?#]|$)/i.test(uri))
+        return "image/png";
+    if (/\.webp(?:[?#]|$)/i.test(uri))
+        return "image/webp";
+    if (/\.mp4(?:[?#]|$)/i.test(uri))
+        return "video/mp4";
+    if (/\.mov(?:[?#]|$)/i.test(uri))
+        return "video/quicktime";
+    if (/\.wav(?:[?#]|$)/i.test(uri))
+        return "audio/wav";
+    if (/\.mp3(?:[?#]|$)/i.test(uri))
+        return "audio/mpeg";
+    return fallback;
+}
+function defaultMimeFor(fieldType) {
+    if (fieldType === "video")
+        return "video/mp4";
+    if (fieldType === "audio")
+        return "audio/wav";
+    return "image/png";
+}
+/** Mime for bytes we resolved ourselves, with the raw-RGBA case mapped to PNG. */
+function resolvedMime(ref, fieldType) {
+    const mime = guessMime(ref, defaultMimeFor(fieldType));
+    return mime === RAW_RGBA_MIME ? "image/png" : mime;
+}
+/** True for a raw-RGBA in-flight image: pixels in `data`, no encoded file. */
+function isRawRgba(ref) {
+    return ((ref.mime_type ?? ref.mimeType) === RAW_RGBA_MIME &&
+        ref.data instanceof Uint8Array);
+}
+/**
+ * True when a ref carries no source at all: every slot blank. The UI sends a
+ * fully-shaped ref for an asset input the user left empty
+ * (`{ type: "image", uri: "", asset_id: null, data: null }`), which is an
+ * absent optional input — not something to fail the node over.
+ */
+function isEmptyAssetRef(ref) {
+    if ((ref.uri ?? "").trim() !== "")
+        return false;
+    if (isInlineText(ref.data))
+        return false;
+    if (ref.data instanceof Uint8Array && ref.data.byteLength > 0)
+        return false;
+    return ref.asset_id == null || ref.asset_id === "";
+}
+function isHttpUri(uri) {
+    return uri !== undefined && /^https?:\/\//i.test(uri);
+}
+/**
+ * Resolve a NodeTool asset ref (ImageRef/VideoRef/AudioRef) to something the
+ * AtlasCloud API accepts: either a public HTTPS URL or a `data:<mime>;base64,...`
+ * URI. Returns null when the ref is empty/undefined.
+ */
+export async function resolveAssetForAtlas(ref, context, fieldType) {
+    if (!ref)
+        return null;
+    // Bare string the user pasted in: a public URL, or a data: URI which is
+    // already the exact shape the API wants.
+    if (isStringValue(ref)) {
+        if (ref.startsWith("data:"))
+            return ref;
+        return looksLikePublicUrl(ref) ? ref : null;
+    }
+    if (!isAssetRef(ref))
+        return null;
+    const r = ref;
+    // An asset input left empty is an absent optional input, not a broken one.
+    if (isEmptyAssetRef(r))
+        return null;
+    const rawUri = r.uri;
+    if (rawUri !== undefined) {
+        if (looksLikePublicUrl(rawUri))
+            return rawUri;
+        if (rawUri.startsWith("data:"))
+            return rawUri;
+    }
+    // Inline bytes, except raw-RGBA pixels — those are not an encoded image and
+    // must go through the canonical resolver's PNG encoder below.
+    if (!isRawRgba(r)) {
+        if (isInlineText(r.data)) {
+            return r.data.startsWith("data:")
+                ? r.data
+                : `data:${resolvedMime(r, fieldType)};base64,${r.data}`;
+        }
+        if (r.data instanceof Uint8Array && r.data.byteLength > 0) {
+            return bytesToDataUri(r.data, resolvedMime(r, fieldType));
+        }
+    }
+    // Internal references the canonical resolver understands but a raw
+    // storage.retrieve / guarded fetch can't uniformly turn into bytes:
+    //   - asset://<id>, package://<pkg>/<path>, memory://<key> reference schemes
+    //   - the self-hosted `/api/storage/<key>` path, reduced to its bare <key>
+    //   - a ref that carries only an `asset_id` (its `uri` is empty or an
+    //     internal path) — the common shape for library-picked and generated
+    //     media wired into a downstream node
+    // The SSRF safety lives HERE, in restricting what we hand resolveAssetBytes:
+    // it will happily download an arbitrary http(s) URL if given one, so we only
+    // ever pass it these trusted internal refs (or an asset:// derived from
+    // asset_id). Arbitrary http(s) URIs stay on the isSafeHttpUrl-guarded fetch
+    // path below and are never routed through it.
+    //
+    const uri = rawUri;
+    const trimmedAssetId = r.asset_id?.trim() ?? "";
+    const assetId = trimmedAssetId !== "" ? trimmedAssetId : null;
+    // Map an internal-ref URI to the argument resolveAssetBytes expects, or null
+    // when it isn't one. asset:// / package:// / memory:// are passed verbatim
+    // (resolveAssetBytes recognizes each scheme); the `/api/storage/<key>` HTTP
+    // path is reduced to its bare `<key>`, since resolveAssetBytes keys off the
+    // storage key / asset id, not the route — handing it the full path makes it
+    // treat the whole string as an id and build a broken nested URL that 404s.
+    const internalRefCandidate = (u) => {
+        if (u.startsWith("asset://") ||
+            u.startsWith("package://") ||
+            u.startsWith("memory://")) {
+            return u;
+        }
+        // Strip any `?query`/`#hash` (thumb URLs carry e.g. `?thumb=1`) so the bare
+        // storage key is handed over. resolveAssetBytes strips these too, but doing
+        // it here keeps the passed key exact and the intent explicit.
+        const apiStorage = /^\/?api\/storage\/(.+)$/.exec(u);
+        return apiStorage ? apiStorage[1].split(/[?#]/)[0] || null : null;
+    };
+    if (context?.resolveAssetBytes) {
+        const candidate = (uri !== undefined ? internalRefCandidate(uri) : null) ??
+            (assetId ? `asset://${assetId}` : null);
+        if (candidate) {
+            const { bytes } = await context.resolveAssetBytes(candidate);
+            if (bytes && bytes.byteLength > 0) {
+                return bytesToDataUri(new Uint8Array(bytes), guessMime(r, defaultMimeFor(fieldType)));
+            }
+        }
+    }
+    if (r.uri && context?.storage) {
+        try {
+            const bytes = await context.storage.retrieve(r.uri);
+            if (bytes && bytes.byteLength > 0) {
+                return bytesToDataUri(new Uint8Array(bytes), guessMime(r, defaultMimeFor(fieldType)));
+            }
+        }
+        catch {
+            /* fall through to direct fetch */
+        }
+    }
+    // Canonical resolver fallback — it understands ref shapes the bespoke
+    // branches above miss: `file://` URIs and absolute local paths, raw-RGBA
+    // in-flight images (PNG-encoded on the way out), and `asset_id` →
+    // `/api/storage/<id>.<ext>` storage candidates.
+    //
+    // Skipped for http(s) URIs: a safe one already passed through at the top, so
+    // anything still here is a private/loopback/metadata host, and
+    // loadMediaRefBytes downloads http(s) unguarded. Routing those through it
+    // would hand back the SSRF hole isSafeHttpUrl exists to close.
+    if (!isHttpUri(r.uri)) {
+        const bytes = await loadMediaRefBytes(r, context);
+        if (bytes && bytes.byteLength > 0) {
+            return bytesToDataUri(bytes, resolvedMime(r, fieldType));
+        }
+    }
+    // Direct fetch fallback. Use the same private-host guard as the
+    // pass-through path so a workflow can't trick the worker into proxying
+    // requests to internal services / cloud metadata endpoints.
+    if (r.uri && isSafeHttpUrl(r.uri)) {
+        // The predicate judged the initial URL; the protected fetch judges every
+        // redirect hop and applies the media-ref egress policy.
+        const res = await fetchExternalMedia(r.uri);
+        if (res.ok) {
+            const bytes = new Uint8Array(await res.arrayBuffer());
+            return bytesToDataUri(bytes, guessMime(r, defaultMimeFor(fieldType)));
+        }
+    }
+    throw new Error(`Cannot resolve ${fieldType} asset for AtlasCloud — no usable uri or inline data`);
+}
+async function uploadVideoInput(apiKey, resolved) {
+    if (!resolved.startsWith("data:"))
+        return resolved;
+    const match = /^data:([^;,]+);base64,(.+)$/s.exec(resolved);
+    if (!match) {
+        throw new Error("AtlasCloud video input must be a public URL or Base64 data URI");
+    }
+    const mimeType = match[1];
+    const encoded = match[2];
+    if (!mimeType || !encoded) {
+        throw new Error("AtlasCloud video input data URI is empty");
+    }
+    return atlasUploadMedia(apiKey, new Uint8Array(Buffer.from(encoded, "base64")), mimeType, "input-video");
+}
+/**
+ * Coerce a UI-serialized value back to the type AtlasCloud's worker expects.
+ * NodeTool serializes numeric dropdowns as strings; AtlasCloud rejects `"5"`
+ * when it wants `5`. Coerce here so the user doesn't see opaque worker errors.
+ *
+ * Callers must filter out null/undefined before invoking — the factory does
+ * this in its field loop, so there's no defensive guard here.
+ */
+function coerceScalar(v, type) {
+    switch (type) {
+        case "int": {
+            if (isNumberValue(v))
+                return Math.trunc(v);
+            const n = parseInt(String(v), 10);
+            return Number.isNaN(n) ? null : n;
+        }
+        case "float": {
+            if (isNumberValue(v))
+                return v;
+            const f = parseFloat(String(v));
+            return Number.isNaN(f) ? null : f;
+        }
+        case "bool": {
+            if (isBooleanValue(v))
+                return v;
+            if (isStringValue(v))
+                return v.toLowerCase() === "true";
+            return Boolean(v);
+        }
+        default:
+            return v;
+    }
+}
+function computeFieldClassification(fields) {
+    return classifyFields(fields.map((f) => ({ name: f.name, propType: f.type })));
+}
+/** Whether an asset ref already points at a source (so a mention shouldn't fill it). */
+function refHasSource(value) {
+    if (!isAssetRef(value))
+        return false;
+    const r = value;
+    if ((r.uri ?? "").trim() !== "")
+        return true;
+    if (isInlineText(r.data))
+        return true;
+    if (r.data instanceof Uint8Array && r.data.byteLength > 0)
+        return true;
+    return r.asset_id != null && r.asset_id !== "";
+}
+/**
+ * Route `asset://` media mentioned inline in a node's text inputs onto its
+ * empty image/audio/video inputs (and strip the mentions from the text). Shared
+ * with FAL / KIE / Replicate / image-to-image via `mapPromptAssetsToInputs` —
+ * lets a Seedance reference-to-video node pull its reference image, audio track
+ * and video clip straight from the prompt's @-mentions.
+ */
+async function promptAssetOverrides(instance, spec, context) {
+    const textFields = [];
+    const assetFields = [];
+    for (const field of spec.fields) {
+        const value = propertyOf(instance, field.name);
+        if (isAssetFieldType(field.type)) {
+            assetFields.push({
+                name: field.name,
+                kind: field.type,
+                list: false,
+                hasSource: refHasSource(value)
+            });
+            continue;
+        }
+        const listKind = listAssetKind(field.type);
+        if (listKind) {
+            assetFields.push({
+                name: field.name,
+                kind: listKind,
+                list: true,
+                hasSource: Array.isArray(value) && value.some(refHasSource)
+            });
+            continue;
+        }
+        if (field.type === "str") {
+            textFields.push({ name: field.name, value: String(value ?? "") });
+        }
+    }
+    const overrides = await mapPromptAssetsToInputs(textFields, assetFields, context);
+    // SAFETY: mapPromptAssetsToInputs only writes back what it read off this
+    // node's own inputs — rewritten prompt strings and media refs — so every
+    // value is a node property value, the shapes `NodeValue` names.
+    return overrides;
+}
+/**
+ * Append resolved asset URLs to a request array of `{ url, type }` objects,
+ * creating it on first use. Order follows manifest field order, so a model
+ * that reads its references positionally sees images before videos before
+ * audio.
+ */
+function appendWrapped(input, key, urls, kind) {
+    const existing = input[key];
+    const bucket = Array.isArray(existing) ? existing : [];
+    for (const url of urls) {
+        bucket.push({ url, type: kind });
+    }
+    input[key] = bucket;
+}
+export function createAtlasNodeClass(spec) {
+    const nodeType = `atlascloud.${spec.moduleName}.${spec.className}`;
+    const title = spec.title || classNameToTitle(spec.className);
+    const specRef = spec;
+    const AtlasNodeClass = class extends BaseNode {
+        async process(context) {
+            const apiKey = getApiKey(this._secrets);
+            const input = {};
+            const overrides = await promptAssetOverrides(this, specRef, context);
+            const readValue = (name) => name in overrides ? overrides[name] : propertyOf(this, name);
+            for (const f of specRef.fields) {
+                const v = readValue(f.name);
+                if (isAssetFieldType(f.type)) {
+                    const inner = f.type;
+                    const resolved = v == null ? null : await resolveAssetForAtlas(v, context, inner);
+                    if (resolved !== null) {
+                        const inputUrl = inner === "video"
+                            ? await uploadVideoInput(apiKey, resolved)
+                            : resolved;
+                        if (f.wrapInto) {
+                            appendWrapped(input, f.wrapInto, [inputUrl], inner);
+                        }
+                        else {
+                            input[f.name] = f.array ? [inputUrl] : inputUrl;
+                        }
+                    }
+                    else if (f.required) {
+                        throw new Error(`${specRef.title}: the ${inner} input "${f.title ?? f.name}" is empty — connect or upload a${inner === "image" ? "n" : ""} ${inner}`);
+                    }
+                    continue;
+                }
+                if (v === undefined || v === null)
+                    continue;
+                const listKind = listAssetKind(f.type);
+                if (listKind) {
+                    const inner = listKind;
+                    if (!Array.isArray(v))
+                        continue;
+                    const resolved = [];
+                    for (const item of v) {
+                        const r = await resolveAssetForAtlas(item, context, inner);
+                        if (r !== null) {
+                            resolved.push(inner === "video" ? await uploadVideoInput(apiKey, r) : r);
+                        }
+                    }
+                    if (f.maxItems !== undefined && resolved.length > f.maxItems) {
+                        throw new Error(`${specRef.title}: "${f.title ?? f.name}" accepts at most ${f.maxItems} items`);
+                    }
+                    if (resolved.length > 0) {
+                        if (f.wrapInto) {
+                            appendWrapped(input, f.wrapInto, resolved, inner);
+                        }
+                        else {
+                            input[f.name] = resolved;
+                        }
+                    }
+                    continue;
+                }
+                if (v === "")
+                    continue;
+                if (f.type === "enum" &&
+                    f.values?.length &&
+                    !f.values.some((allowed) => allowed === v)) {
+                    // A model switch can leave a stale enum value in a persisted app.
+                    // Use the declared model default when it is valid instead of sending
+                    // a parameter that the selected AtlasCloud model cannot accept.
+                    if (f.default !== undefined &&
+                        f.default !== null &&
+                        f.values.some((allowed) => allowed === f.default)) {
+                        // SAFETY: The preceding membership check proves the manifest default is an allowed NodeValue.
+                        input[f.name] = f.default;
+                    }
+                    continue;
+                }
+                input[f.name] = coerceScalar(v, f.type);
+            }
+            const requiredGroups = new Set(specRef.fields
+                .filter((field) => field.requiredGroup && field.wrapInto)
+                .map((field) => field.wrapInto));
+            for (const group of requiredGroups) {
+                const values = input[group];
+                const hasVisualReference = Array.isArray(values) && values.some(isVisualReference);
+                if (!hasVisualReference) {
+                    throw new Error(`${specRef.title}: connect at least one reference image or video`);
+                }
+            }
+            if (input.background === "transparent" &&
+                input.output_format === "jpeg") {
+                throw new Error(`${specRef.title}: transparent backgrounds require PNG or WebP output`);
+            }
+            if (specRef.modelId.startsWith("pixverse/") &&
+                Array.isArray(input.images)) {
+                input.images = input.images.map((image) => ({ image }));
+            }
+            else if (specRef.modelId.startsWith("vidu/") &&
+                Array.isArray(input.subjects)) {
+                const images = input.subjects;
+                if (images.length > 7) {
+                    throw new Error(`${specRef.title}: "subjects" accepts at most 7 images`);
+                }
+                input.subjects = Array.from({ length: Math.ceil(images.length / 3) }, (_, index) => ({
+                    id: String(index + 1),
+                    images: images.slice(index * 3, index * 3 + 3)
+                }));
+            }
+            const predictionId = await atlasSubmit(apiKey, specRef.modality, specRef.modelId, input);
+            const result = await atlasAwaitResult(apiKey, predictionId, {
+                pollInterval: specRef.pollInterval ?? 3000,
+                maxAttempts: specRef.maxAttempts ?? 600
+            });
+            const url = pickOutputUrl(result);
+            // Retries 429/5xx — the job is already generated and billed by now, so a
+            // transient CDN blip must not throw the paid-for result away.
+            const bytes = await atlasDownload(url);
+            // Preferred path: hand bytes to NodeTool storage so the result becomes a
+            // proper local asset. Falls back to base64 embed if storage is missing
+            // or rejects the write — that mirrors the autoSaveAsset contract used
+            // by topaz-nodes.
+            const isVideo = specRef.outputType === "video";
+            const imageFormat = input.output_format === "jpeg" || input.output_format === "webp"
+                ? input.output_format
+                : "png";
+            const ext = isVideo
+                ? "mp4"
+                : imageFormat === "jpeg"
+                    ? "jpg"
+                    : imageFormat;
+            const mime = isVideo ? "video/mp4" : `image/${imageFormat}`;
+            const filename = `atlascloud-${specRef.outputType}-${Date.now()}.${ext}`;
+            const storage = context?.storage;
+            if (storage?.store) {
+                try {
+                    const storageUri = await storage.store(filename, bytes, mime);
+                    return { output: { type: specRef.outputType, uri: storageUri } };
+                }
+                catch {
+                    /* fall through to base64 embed */
+                }
+            }
+            return {
+                output: {
+                    type: specRef.outputType,
+                    uri: "",
+                    data: Buffer.from(bytes).toString("base64")
+                }
+            };
+        }
+    };
+    Object.defineProperty(AtlasNodeClass, "name", {
+        value: spec.className,
+        configurable: true
+    });
+    Object.defineProperty(AtlasNodeClass, "nodeType", {
+        value: nodeType,
+        configurable: true
+    });
+    Object.defineProperty(AtlasNodeClass, "title", {
+        value: title,
+        configurable: true
+    });
+    Object.defineProperty(AtlasNodeClass, "description", {
+        value: spec.description,
+        configurable: true
+    });
+    Object.defineProperty(AtlasNodeClass, "requiredSettings", {
+        value: ["ATLASCLOUD_API_KEY"],
+        configurable: true
+    });
+    Object.defineProperty(AtlasNodeClass, "autoSaveAsset", {
+        value: true,
+        configurable: true
+    });
+    Object.defineProperty(AtlasNodeClass, "metadataOutputTypes", {
+        value: { output: spec.outputType },
+        configurable: true
+    });
+    // Every AtlasCloud model generates an image or a video — preview it in the
+    // node body.
+    applyContentCardBody(AtlasNodeClass);
+    const { inlineFields, inputFields } = computeFieldClassification(spec.fields);
+    Object.defineProperty(AtlasNodeClass, "inlineFields", {
+        value: inlineFields,
+        configurable: true
+    });
+    Object.defineProperty(AtlasNodeClass, "inputFields", {
+        value: inputFields,
+        configurable: true
+    });
+    for (const field of spec.fields) {
+        // Preserve null defaults verbatim — the AtlasCloud manifests use `null`
+        // to mean "field is optional with no preselected value" (e.g. aspect_ratio
+        // on Nano Banana models). Coercing those to a type-default empty string
+        // can fail enum-values validation, since "" isn't in the values list.
+        const propDefault = field.default === null
+            ? null
+            : (field.default ?? defaultForPropType(field.type));
+        const propOptions = {
+            type: field.type,
+            default: propDefault
+        };
+        if (field.title)
+            propOptions.title = field.title;
+        if (field.description)
+            propOptions.description = field.description;
+        if (field.values?.length)
+            propOptions.values = field.values;
+        if (field.min !== undefined)
+            propOptions.min = field.min;
+        if (field.max !== undefined)
+            propOptions.max = field.max;
+        if (field.required)
+            propOptions.required = true;
+        registerDeclaredProperty(AtlasNodeClass, field.name, propOptions);
+    }
+    return AtlasNodeClass;
+}
+export function loadAtlasNodesFromManifest(manifest) {
+    return manifest.map(createAtlasNodeClass);
+}
+//# sourceMappingURL=atlascloud-factory.js.map