ugcinc 4.0.2 → 4.1.0

package/dist/automations/nodes/deduplicate.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'deduplicate',
+    label: 'Mass Repost',
+    description: 'Make videos unique for safe reposting',
+    type: 'generator',
+    category: 'Generation',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        deduplication: 'level3',
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: () => ({
+        inputs: [
+            {
+                id: 'video',
+                type: 'video',
+                isArray: false,
+                required: true,
+            },
+        ],
+        outputs: [
+            {
+                id: 'output',
+                type: 'video',
+                isArray: false,
+                required: true,
+            },
+        ],
+    }),
+});
+exports.default = definition;

package/dist/automations/nodes/destructure.d.ts

@@ -0,0 +1,25 @@
+type IndexExpression = {
+    type: 'single';
+    index: number;
+} | {
+    type: 'range';
+    start: number;
+    end: number;
+} | {
+    type: 'list';
+    indexes: number[];
+};
+interface DestructureSelection {
+    portId: string;
+    indexExpr: IndexExpression;
+    isVariable?: boolean;
+    propertyPath?: string;
+}
+declare const definition: import("./types").NodeDefinition<"generator", {
+    selections: DestructureSelection[];
+    outputMode: "per-input";
+    selectionMode: null;
+}>;
+export default definition;
+export type { DestructureSelection, IndexExpression };
+export type DestructureConfig = typeof definition.defaults;

package/dist/automations/nodes/destructure.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'destructure',
+    label: 'Destructure',
+    description: 'Extract specific elements from an array by index or range',
+    type: 'generator',
+    category: 'Control Flow',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        selections: [],
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config, getConnectedOutput }) => {
+        const selections = config?.selections ?? [];
+        // Input accepts any array type
+        const inputTypes = ['image', 'video', 'audio', 'text', 'object'];
+        const inputs = [
+            {
+                id: 'array',
+                type: inputTypes,
+                isArray: true,
+                required: true,
+            },
+        ];
+        const outputs = [];
+        // Determine base type from connected input
+        let baseType = 'object';
+        if (getConnectedOutput) {
+            const connectedOutput = getConnectedOutput('array');
+            if (connectedOutput?.type && connectedOutput.isArray) {
+                const connType = connectedOutput.type;
+                if (!Array.isArray(connType)) {
+                    baseType = connType;
+                }
+            }
+        }
+        for (const selection of selections) {
+            // If variable, add input port for index expression
+            if (selection.isVariable) {
+                inputs.push({
+                    id: `idx-${selection.portId}`,
+                    type: 'text',
+                    isArray: false,
+                    required: true,
+                });
+            }
+            // Output type depends on index expression:
+            // - 'single' -> single item (isArray: false)
+            // - 'range' or 'list' -> array of items (isArray: true)
+            const outputIsArray = selection.indexExpr.type !== 'single';
+            outputs.push({
+                id: selection.portId,
+                type: baseType,
+                isArray: outputIsArray,
+                required: true,
+            });
+        }
+        return { inputs, outputs };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/for-each.d.ts

@@ -0,0 +1,23 @@
+import type { BasePortType } from '../types';
+interface ForEachOutputProperty {
+    portId: string;
+    propertyPath: string;
+    type: BasePortType;
+    isArray: boolean;
+}
+interface ForEachInputPort {
+    id: string;
+    type: BasePortType;
+    isArray: boolean;
+}
+declare const definition: import("./types").NodeDefinition<"generator", {
+    outputProperties: ForEachOutputProperty[];
+    inputPorts: ForEachInputPort[];
+    exposeItem: boolean;
+    exposeIndex: boolean;
+    outputMode: "per-input";
+    selectionMode: null;
+}>;
+export default definition;
+export type { ForEachOutputProperty, ForEachInputPort };
+export type ForEachConfig = typeof definition.defaults;

package/dist/automations/nodes/for-each.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'for-each',
+    label: 'For Each',
+    description: 'Iterate over an array, executing downstream nodes for each item',
+    type: 'generator',
+    category: 'Control Flow',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        outputProperties: [],
+        inputPorts: [],
+        exposeItem: false,
+        exposeIndex: false,
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config, getConnectedOutput }) => {
+        const outputProperties = config?.outputProperties ?? [];
+        const inputPorts = config?.inputPorts ?? [];
+        const exposeItem = config?.exposeItem ?? false;
+        const exposeIndex = config?.exposeIndex ?? false;
+        // Inputs: array + passthrough inputs
+        const inputs = [
+            { id: 'array', type: 'object', isArray: false, required: true },
+        ];
+        for (const port of inputPorts) {
+            inputs.push({
+                id: port.id,
+                type: port.type,
+                isArray: port.isArray,
+                required: false,
+            });
+        }
+        // Outputs
+        const outputs = [];
+        // Determine item type from connected array input
+        let itemType = 'object';
+        if (getConnectedOutput) {
+            const connectedOutput = getConnectedOutput('array');
+            if (connectedOutput?.objectSchema) {
+                // Has objectSchema - it's an object array, use object type
+                itemType = 'object';
+            }
+            else if (connectedOutput?.type && connectedOutput.isArray) {
+                // Connected to an array type - extract the base type
+                const connType = connectedOutput.type;
+                if (!Array.isArray(connType)) {
+                    itemType = connType;
+                }
+            }
+        }
+        // Add item output if exposed
+        if (exposeItem) {
+            outputs.push({ id: 'item', type: itemType, isArray: false, required: true });
+        }
+        // Add index output if exposed
+        if (exposeIndex) {
+            outputs.push({ id: 'index', type: 'number', isArray: false, required: true });
+        }
+        // Add configured property outputs
+        for (const prop of outputProperties) {
+            outputs.push({
+                id: prop.portId,
+                type: prop.type,
+                isArray: prop.isArray,
+                required: true,
+            });
+        }
+        // Add passthrough outputs (same value for all iterations)
+        for (const port of inputPorts) {
+            outputs.push({
+                id: port.id,
+                type: port.type,
+                isArray: port.isArray,
+                required: true,
+            });
+        }
+        return { inputs, outputs };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/generate-image.d.ts

@@ -0,0 +1,16 @@
+type ImageGenerationTextModel = 'fal-ai/gemini-3-pro-image-preview' | 'fal-ai/nano-banana-pro' | 'fal-ai/nano-banana' | 'fal-ai/gpt-image-1/text-to-image';
+type ImageGenerationEditModel = 'fal-ai/gemini-3-pro-image-preview/edit' | 'fal-ai/nano-banana-pro/edit' | 'fal-ai/nano-banana/edit' | 'fal-ai/gpt-image-1/edit-image';
+type ImageGenerationModel = ImageGenerationTextModel | ImageGenerationEditModel;
+declare function isEditModel(model: ImageGenerationModel): model is ImageGenerationEditModel;
+declare const definition: import("./types").NodeDefinition<"generator", {
+    model: ImageGenerationModel;
+    aspectRatio: string;
+    numImages: number;
+    apiKey: string | undefined;
+    outputMode: "per-input";
+    selectionMode: null;
+}>;
+export default definition;
+export { isEditModel };
+export type { ImageGenerationTextModel, ImageGenerationEditModel, ImageGenerationModel };
+export type GenerateImageConfig = typeof definition.defaults;

package/dist/automations/nodes/generate-image.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEditModel = isEditModel;
+const types_1 = require("./types");
+function isEditModel(model) {
+    return model.includes('/edit') || model.includes('/edit-image');
+}
+const definition = (0, types_1.defineNode)({
+    nodeId: 'generate-image',
+    label: 'Generate Image',
+    description: 'Generate images with AI',
+    type: 'generator',
+    category: 'AI Generation',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        model: 'fal-ai/nano-banana',
+        aspectRatio: '1:1',
+        numImages: 1,
+        apiKey: undefined,
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const model = (config?.model ?? 'fal-ai/nano-banana');
+        const inputs = [
+            { id: 'prompt', type: 'text', isArray: false, required: true },
+        ];
+        if (isEditModel(model)) {
+            inputs.push({ id: 'image', type: 'image', isArray: false, required: true });
+        }
+        return {
+            inputs,
+            outputs: [
+                {
+                    id: 'output',
+                    type: 'image',
+                    isArray: false,
+                    required: true,
+                },
+            ],
+        };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/generate-video.d.ts

@@ -0,0 +1,16 @@
+type VideoGenerationTextToVideoModel = 'fal-ai/veo3.1' | 'fal-ai/veo3' | 'fal-ai/veo3/fast' | 'fal-ai/kling-video/v2.6/pro/text-to-video' | 'fal-ai/kling-video/v2.5/pro/text-to-video' | 'fal-ai/luma-dream-machine/ray-2' | 'fal-ai/luma-dream-machine/ray-2-flash' | 'fal-ai/minimax/hailuo-2.3/pro/text-to-video' | 'wan/v2.6/text-to-video' | 'fal-ai/sora-2/text-to-video';
+type VideoGenerationImageToVideoModel = 'fal-ai/veo3.1/image-to-video' | 'fal-ai/veo3/image-to-video' | 'fal-ai/kling-video/v2.6/pro/image-to-video' | 'fal-ai/kling-video/v2.5/pro/image-to-video' | 'fal-ai/luma-dream-machine/ray-2/image-to-video' | 'fal-ai/luma-dream-machine/ray-2-flash/image-to-video' | 'fal-ai/minimax/hailuo-2.3/pro/image-to-video' | 'wan/v2.6/image-to-video' | 'fal-ai/sora-2/image-to-video/pro';
+type VideoGenerationModel = VideoGenerationTextToVideoModel | VideoGenerationImageToVideoModel;
+declare function isImageToVideoModel(model: VideoGenerationModel): model is VideoGenerationImageToVideoModel;
+declare const definition: import("./types").NodeDefinition<"generator", {
+    model: VideoGenerationModel;
+    aspectRatio: string;
+    duration: number;
+    apiKey: string | undefined;
+    outputMode: "per-input";
+    selectionMode: null;
+}>;
+export default definition;
+export { isImageToVideoModel };
+export type { VideoGenerationTextToVideoModel, VideoGenerationImageToVideoModel, VideoGenerationModel };
+export type GenerateVideoConfig = typeof definition.defaults;

package/dist/automations/nodes/generate-video.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isImageToVideoModel = isImageToVideoModel;
+const types_1 = require("./types");
+function isImageToVideoModel(model) {
+    return model.includes('/image-to-video');
+}
+const definition = (0, types_1.defineNode)({
+    nodeId: 'generate-video',
+    label: 'Generate Video',
+    description: 'Generate videos with AI',
+    type: 'generator',
+    category: 'AI Generation',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        model: 'fal-ai/kling-video/v2.6/pro/text-to-video',
+        aspectRatio: '16:9',
+        duration: 5,
+        apiKey: undefined,
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const model = (config?.model ?? 'fal-ai/kling-video/v2.6/pro/text-to-video');
+        const inputs = [
+            { id: 'prompt', type: 'text', isArray: false, required: true },
+        ];
+        if (isImageToVideoModel(model)) {
+            inputs.push({ id: 'image', type: 'image', isArray: false, required: true });
+        }
+        return {
+            inputs,
+            outputs: [
+                {
+                    id: 'output',
+                    type: 'video',
+                    isArray: false,
+                    required: true,
+                },
+            ],
+        };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/if.d.ts

@@ -0,0 +1,22 @@
+import type { BasePortType } from '../types';
+declare const IfLogicOperators: readonly ["and", "or", "xor", "nor"];
+type IfLogicOperator = typeof IfLogicOperators[number];
+interface IfBooleanInput {
+    id: string;
+}
+interface IfPassthroughInput {
+    id: string;
+    type: BasePortType;
+    isArray: boolean;
+}
+declare const definition: import("./types").NodeDefinition<"generator", {
+    logicOperator: IfLogicOperator;
+    booleanInputs: IfBooleanInput[];
+    passthroughInputs: IfPassthroughInput[];
+    outputMode: "per-input";
+    selectionMode: null;
+}>;
+export default definition;
+export { IfLogicOperators };
+export type { IfLogicOperator, IfBooleanInput, IfPassthroughInput };
+export type IfConfig = typeof definition.defaults;

package/dist/automations/nodes/if.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IfLogicOperators = void 0;
+const types_1 = require("./types");
+const IfLogicOperators = ['and', 'or', 'xor', 'nor'];
+exports.IfLogicOperators = IfLogicOperators;
+const definition = (0, types_1.defineNode)({
+    nodeId: 'if',
+    label: 'If',
+    description: 'Conditional branching based on boolean logic',
+    type: 'generator',
+    category: 'Control Flow',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        logicOperator: 'and',
+        booleanInputs: [{ id: 'condition-1' }],
+        passthroughInputs: [{
+                id: 'value',
+                type: 'image',
+                isArray: false,
+            }],
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const booleanInputs = config?.booleanInputs ?? [];
+        const passthroughInputs = config?.passthroughInputs ?? [];
+        const inputs = [];
+        const outputs = [];
+        // Boolean condition inputs
+        for (const boolInput of booleanInputs) {
+            inputs.push({ id: boolInput.id, type: 'boolean', isArray: false, required: true });
+        }
+        // Passthrough inputs and true/false outputs
+        for (const passthrough of passthroughInputs) {
+            inputs.push({ id: passthrough.id, type: passthrough.type, isArray: passthrough.isArray, required: true });
+            outputs.push({ id: `true-${passthrough.id}`, type: passthrough.type, isArray: passthrough.isArray, required: true });
+            outputs.push({ id: `false-${passthrough.id}`, type: passthrough.type, isArray: passthrough.isArray, required: true });
+        }
+        return { inputs, outputs };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/image-composer.d.ts

@@ -0,0 +1,33 @@
+import type { NodeOutputValues } from '../types';
+import type { ImageEditorNodeConfig } from '../../render/types';
+declare const definition: import("./types").NodeDefinition<"generator", {
+    imageEditor: {
+        width: number;
+        height: number;
+        aspectRatio: string;
+        dimensionPreset: string;
+        backgroundType: string;
+        elements: never[];
+    };
+    outputMode: "per-input";
+    selectionMode: null;
+}>;
+export default definition;
+export type ImageComposerConfig = typeof definition.defaults;
+/**
+ * Input to the image-composer node executor
+ */
+export interface ImageEditorNodeInput extends Record<string, unknown> {
+    type: 'image-composer';
+    config: ImageEditorNodeConfig;
+    imageUrls: Record<string, string>;
+    textValues: Record<string, string>;
+}
+/**
+ * Output from the image-composer node executor
+ */
+export interface ImageEditorNodeOutput extends Record<string, unknown>, NodeOutputValues {
+    width?: number;
+    height?: number;
+    aspectRatio?: string;
+}

package/dist/automations/nodes/image-composer.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'image-composer',
+    label: 'Image Composer',
+    description: 'Create templated images',
+    type: 'generator',
+    category: 'Generation',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        imageEditor: {
+            width: 1080,
+            height: 1920,
+            aspectRatio: '9:16',
+            dimensionPreset: '9:16',
+            backgroundType: 'image',
+            elements: [],
+        },
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const editorConfig = config?.imageEditor;
+        const inputs = [];
+        if (editorConfig) {
+            // Add background input if backgroundType is not 'color'
+            if (editorConfig.backgroundType !== 'color') {
+                inputs.push({
+                    id: 'background',
+                    type: 'image',
+                    isArray: false,
+                    required: true,
+                });
+            }
+            // Add inputs for each element with inputId or textInputId
+            editorConfig.elements.forEach(elem => {
+                if (elem.type === 'image' && elem.inputId) {
+                    inputs.push({
+                        id: elem.inputId,
+                        type: 'image',
+                        isArray: false,
+                        required: true,
+                    });
+                }
+                else if (elem.type === 'text' && elem.textInputId) {
+                    inputs.push({
+                        id: elem.textInputId,
+                        type: 'text',
+                        isArray: false,
+                        required: true,
+                    });
+                }
+            });
+            // Build enum options from element IDs for crop boundary inputs
+            const elementEnumOptions = editorConfig.elements.map(elem => ({
+                label: elem.id,
+                value: elem.id,
+            }));
+            // Add crop boundary inputs as enum type (not required)
+            const addedCropInputs = new Set();
+            const cropConfig = editorConfig.dynamicCrop;
+            [
+                cropConfig?.vertical?.startBoundary?.inputRef,
+                cropConfig?.vertical?.endBoundary?.inputRef,
+                cropConfig?.horizontal?.startBoundary?.inputRef,
+                cropConfig?.horizontal?.endBoundary?.inputRef,
+            ].forEach(inputRef => {
+                if (inputRef && !addedCropInputs.has(inputRef)) {
+                    addedCropInputs.add(inputRef);
+                    inputs.push({
+                        id: inputRef,
+                        type: 'enum',
+                        isArray: false,
+                        required: false,
+                        enumOptions: elementEnumOptions,
+                    });
+                }
+            });
+        }
+        return {
+            inputs,
+            outputs: [
+                {
+                    id: 'output',
+                    type: 'image',
+                    isArray: false,
+                    required: true,
+                },
+            ],
+        };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/index.d.ts

@@ -0,0 +1,20 @@
+import type { UserCreatableNodeType } from '../types';
+import type { NodeDefinition } from './types';
+type AnyNodeDefinition = NodeDefinition<any, any>;
+/**
+ * Registry of all user-creatable node definitions.
+ * This is the single source of truth for node types.
+ *
+ * Note: Internal executor types like 'for-each-value' are not included here
+ * as they are created dynamically during execution, not by users.
+ */
+export declare const nodeDefinitions: Record<UserCreatableNodeType, AnyNodeDefinition>;
+/**
+ * Get all node definitions as an array
+ */
+export declare function getAllNodeDefinitions(): AnyNodeDefinition[];
+/**
+ * Get a node definition by its nodeId
+ */
+export declare function getNodeDefinition(nodeId: UserCreatableNodeType): AnyNodeDefinition | undefined;
+export {};

package/dist/automations/nodes/index.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeDefinitions = void 0;
+exports.getAllNodeDefinitions = getAllNodeDefinitions;
+exports.getNodeDefinition = getNodeDefinition;
+// Import all node definitions
+const account_1 = __importDefault(require("./account"));
+const auto_caption_1 = __importDefault(require("./auto-caption"));
+const auto_post_1 = __importDefault(require("./auto-post"));
+const branch_1 = __importDefault(require("./branch"));
+const collect_1 = __importDefault(require("./collect"));
+const compose_workflow_1 = __importDefault(require("./compose-workflow"));
+const create_dm_1 = __importDefault(require("./create-dm"));
+const custom_model_1 = __importDefault(require("./custom-model"));
+const deduplicate_1 = __importDefault(require("./deduplicate"));
+const destructure_1 = __importDefault(require("./destructure"));
+const for_each_1 = __importDefault(require("./for-each"));
+const generate_image_1 = __importDefault(require("./generate-image"));
+const generate_video_1 = __importDefault(require("./generate-video"));
+const if_1 = __importDefault(require("./if"));
+const image_composer_1 = __importDefault(require("./image-composer"));
+const llm_1 = __importDefault(require("./llm"));
+const manual_trigger_1 = __importDefault(require("./manual-trigger"));
+const media_1 = __importDefault(require("./media"));
+const not_1 = __importDefault(require("./not"));
+const output_1 = __importDefault(require("./output"));
+const random_1 = __importDefault(require("./random"));
+const random_route_1 = __importDefault(require("./random-route"));
+const recurrence_1 = __importDefault(require("./recurrence"));
+const save_to_media_1 = __importDefault(require("./save-to-media"));
+const screenshot_animation_1 = __importDefault(require("./screenshot-animation"));
+const social_audio_1 = __importDefault(require("./social-audio"));
+const text_1 = __importDefault(require("./text"));
+const transcript_1 = __importDefault(require("./transcript"));
+const video_composer_1 = __importDefault(require("./video-composer"));
+const video_import_1 = __importDefault(require("./video-import"));
+/**
+ * Registry of all user-creatable node definitions.
+ * This is the single source of truth for node types.
+ *
+ * Note: Internal executor types like 'for-each-value' are not included here
+ * as they are created dynamically during execution, not by users.
+ */
+exports.nodeDefinitions = {
+    'account': account_1.default,
+    'auto-caption': auto_caption_1.default,
+    'auto-post': auto_post_1.default,
+    'branch': branch_1.default,
+    'collect': collect_1.default,
+    'compose-workflow': compose_workflow_1.default,
+    'create-dm': create_dm_1.default,
+    'custom-model': custom_model_1.default,
+    'deduplicate': deduplicate_1.default,
+    'destructure': destructure_1.default,
+    'for-each': for_each_1.default,
+    'generate-image': generate_image_1.default,
+    'generate-video': generate_video_1.default,
+    'if': if_1.default,
+    'image-composer': image_composer_1.default,
+    'llm': llm_1.default,
+    'manual-trigger': manual_trigger_1.default,
+    'media': media_1.default,
+    'not': not_1.default,
+    'passthrough': output_1.default,
+    'random': random_1.default,
+    'random-route': random_route_1.default,
+    'recurrence': recurrence_1.default,
+    'save-to-media': save_to_media_1.default,
+    'screenshot-animation': screenshot_animation_1.default,
+    'social-audio': social_audio_1.default,
+    'text': text_1.default,
+    'transcript': transcript_1.default,
+    'video-composer': video_composer_1.default,
+    'video-import': video_import_1.default,
+};
+// =============================================================================
+// Getters
+// =============================================================================
+/**
+ * Get all node definitions as an array
+ */
+function getAllNodeDefinitions() {
+    return Object.values(exports.nodeDefinitions);
+}
+/**
+ * Get a node definition by its nodeId
+ */
+function getNodeDefinition(nodeId) {
+    return exports.nodeDefinitions[nodeId];
+}