php artisan voodflow:make-node MyNode       # 1. Scaffold
php artisan voodflow:build-node MyNode      # 2. Compile JSX → JS bundle

php artisan voodflow:make-node {name}

  trigger      — Starts a workflow (scheduled, event-driven, webhook)
  action       — Performs an operation (send, create, call)
  transform    — Reshapes or maps data
  flow         — Controls execution branching (if, switch, loop)
  data         — Reads or writes to a data store
  utility      — Developer tools (debug, code, inspect)
  ai           — AI/ML integrations
  notification — Sends alerts or messages
  integration  — Third-party API connectors

  FREE — Public node (default)
  PRO  — Paid node (requires licensing)

packages/voodflow/voodflow/src/Nodes/Custom/{NodeClass}/
├── {NodeClass}.php
├── components/
│   └── {NodeClass}.jsx
└── manifest.json

<?php

namespace Voodflow\Voodflow\Nodes\UppercaseNode;

use Voodflow\Voodflow\Contracts\NodeInterface;
use Voodflow\Voodflow\Execution\ExecutionContext;
use Voodflow\Voodflow\Execution\ExecutionResult;

class UppercaseNode implements NodeInterface
{
    public static function type(): string
    {
        return 'uppercase_node';
    }

    public static function defaultConfig(): array
    {
        return [
            'label' => 'Uppercase',
            'description' => '',
            'source_path' => 'text',
            'target_key' => 'uppercased',
        ];
    }

    public function execute(ExecutionContext $context): ExecutionResult
    {
        $sourcePath = $context->getConfig('source_path', 'text');
        $targetKey = $context->getConfig('target_key', 'uppercased');

        $value = data_get($context->input, $sourcePath);
        $value = is_string($value) ? $value : (string) $value;

        $resolved = $context->resolveTemplate($value);

        return ExecutionResult::success(array_merge($context->input, [
            $targetKey => mb_strtoupper($resolved),
        ]));
    }

    public function validate(array $config): array
    {
        $errors = [];

        if (empty($config['source_path'])) {
            $errors['source_path'] = 'Source path is required';
        }

        return $errors;
    }

    public static function definition(): array
    {
        return [
            ['key' => 'source_path', 'type' => 'text', 'label' => 'Source Path', 'required' => true],
            ['key' => 'target_key', 'type' => 'text', 'label' => 'Target Key', 'required' => true],
        ];
    }

    public static function supportsRetry(): bool
    {
        return true;
    }
}

// Pass data to the default output
ExecutionResult::success(array $data): ExecutionResult

// Terminate branch with error (interceptable by Catch node)
ExecutionResult::failure(string $message, string $code = 'ERROR'): ExecutionResult

// Route to a named output handle (flow nodes)
ExecutionResult::success($data)->toOutput('true')
ExecutionResult::success($data)->toOutput('false')

import {
    BaseNodeContainer,
    NodeHeader,
    NodeConfigReadOnlyNotice,
    NodeNonExecutableNotice,
    CollapsedView,
    NodeConfigFields,
    FieldLabel,
    TextInput,
    SelectInput,
    StandardHandle,
    NODE_CONFIG_DEBOUNCE_MS,
    useStandardNodeBehavior,
    useNodeAccessUi,
} from "../../../../resources/js/components/nodes";

const [channel, setChannel] = useState(data.channel || "");

<div className="px-4 pb-4 border-t border-slate-100 dark:border-slate-800 pt-4 space-y-4">
    <div className="space-y-1">
        <FieldLabel>Slack Channel</FieldLabel>
        <TextInput
            value={channel}
            onChange={(e) => setChannel(e.target.value)}
            placeholder="#general"
            color={nodeColor}
        />
    </div>
</div>

component.call("updateNodeConfig", { nodeId: id, label, description, channel });
// and in setNodes: data: { ...node.data, label, description, channel }
// add `channel, data.channel` to the dependency array

php artisan voodflow:build-node ChatNode

{
    "name": "chat-node",
    "display_name": "Chat",
    "version": "1.0.0",
    "author": "Acme Corp",
    "author_url": "https://acme.example.com",
    "description": "Post messages to chat channels",
    "category": "integration",
    "tier": "CORE",

    "display": {
        "iconType": "heroicon",
        "icon": "heroicon-o-chat-bubble-left-right",
        "color": "indigo",
        "logo": null
    },

    "php": {
        "class": "ChatNode",
        "namespace": "Voodflow\\Voodflow\\Nodes\\ChatNode"
    },

    "javascript": {
        "component": "VoodflowNode_ChatNode",
        "bundle": "dist/chat-node.js"
    },

    "voodflow": {
        "min_version": "1.0.0"
    },

    "license": {
        "type": "MIT"
    }
}

$builder
    ->addSelectField('audience', 'Audience', ['email' => 'Email', 'slack' => 'Slack'], required: true)
    ->addTextField('email', 'Email address', description: 'Used when Audience is Email')
    ->withVisibleWhen('audience', 'email');

# Edit your PHP or JSX, then:
php artisan voodflow:build-node MyNode
# → Refresh browser

// Good
public static function type(): string { return 'acme_chat_node'; }

// Bad — may conflict
public static function type(): string { return 'chat'; }

# 1. Scaffold
php artisan voodflow:make-node UppercaseNode
# Type: transform | Tier: CORE | Author: Your Name

public function execute(ExecutionContext $context): ExecutionResult
{
    $sourcePath = $context->getConfig('source_path', 'text');
    $targetKey = $context->getConfig('target_key', 'uppercased');

    $value = data_get($context->input, $sourcePath);
    $value = is_string($value) ? $value : (string) $value;

    $resolved = $context->resolveTemplate($value);

    return ExecutionResult::success(array_merge($context->input, [
        $targetKey => mb_strtoupper($resolved),
    ]));
}

# 2. Build
php artisan voodflow:build-node UppercaseNode

# 3. Test in canvas: connect after Dummy Data, set source_path = "text"
# 4. Inspect output with a Data Viewer node