blokctl 1.3.0 → 1.4.0

package/dist/commands/create/project.js

@@ -1,6 +1,7 @@
 import child_process from "node:child_process";
 import os from "node:os";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import util from "node:util";
 import * as p from "@clack/prompts";
 import figlet from "figlet";
@@ -22,7 +23,8 @@ const exec = util.promisify(child_process.exec);
 const HOME_DIR = `${os.homedir()}/.blok`;
 const GITHUB_REPO_LOCAL = `${HOME_DIR}/blok`;
 const GITHUB_REPO_REMOTE = "https://github.com/well-prado/blok.git";
-const GITHUB_REPO_RELEASE_TAG = "v1.3.0";
+const GITHUB_REPO_RELEASE_TAG = "v1.4.0";
+const BUNDLED_SCAFFOLD_REPO = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../scaffold-repo");
 const RUNTIME_HELLO_EXAMPLES = {
     go: "runtime-go-hello.ts",
     rust: "runtime-rust-hello.ts",
@@ -279,14 +281,19 @@ export async function createProject(opts, version, currentPath = false, localRep
         const dirPath = !currentPath ? path.join(process.cwd(), projectName) : process.cwd();
         if (!skipPrompts)
             s.message("Gathering project files");
-        const repoSource = localRepoPath ? path.resolve(localRepoPath) : GITHUB_REPO_LOCAL;
+        let repoSource;
         if (localRepoPath) {
+            repoSource = path.resolve(localRepoPath);
             if (!fsExtra.existsSync(repoSource)) {
                 throw new Error(`Local repo path not found: ${repoSource}`);
             }
             console.log(color.dim(`  Using local repo: ${repoSource}`));
         }
+        else if (fsExtra.existsSync(BUNDLED_SCAFFOLD_REPO)) {
+            repoSource = BUNDLED_SCAFFOLD_REPO;
+        }
         else {
+            repoSource = GITHUB_REPO_LOCAL;
             const githubLocalExists = fsExtra.existsSync(GITHUB_REPO_LOCAL);
             if (githubLocalExists) {
                 fsExtra.removeSync(GITHUB_REPO_LOCAL);
@@ -419,7 +426,10 @@ export async function createProject(opts, version, currentPath = false, localRep
                         fsExtra.copySync(`${triggerSrcDir}/AppRoutes.ts`, `${triggerDestDir}/AppRoutes.ts`);
                     }
                     if (fsExtra.existsSync(`${triggerSrcDir}/workflows`)) {
-                        fsExtra.copySync(`${triggerSrcDir}/workflows`, `${dirPath}/src/workflows/${triggerKind}`);
+                        const devFixtures = /\/(countries-helper|countries-cats-helper|empty)\.ts$|\/workflows\/eval(\/|$)/;
+                        fsExtra.copySync(`${triggerSrcDir}/workflows`, `${dirPath}/src/workflows/${triggerKind}`, {
+                            filter: (src) => !devFixtures.test(src),
+                        });
                     }
                 }
             }
@@ -554,7 +564,7 @@ export async function createProject(opts, version, currentPath = false, localRep
             "@blokjs/trigger-worker": "triggers/worker",
             "@blokjs/core": "core/core",
         };
-        const BLOKJS_DEP_RANGE = "^1.3.0";
+        const BLOKJS_DEP_RANGE = "^1.4.0";
         for (const depGroup of ["dependencies", "devDependencies", "peerDependencies"]) {
             const deps = packageJsonContent[depGroup];
             if (!deps)
@@ -877,6 +887,7 @@ export async function createProject(opts, version, currentPath = false, localRep
             s.stop(error.message);
         if (skipPrompts)
             console.log(error.message);
+        process.exitCode = 1;
     }
 }
 export function generateSharedNodesFile(_triggers, _repoSource) {

package/dist/commands/create/utils/Examples.d.ts

@@ -13,7 +13,7 @@ declare const package_dev_dependencies: {
     "@types/pg": string;
 };
 declare const python3_file = "from pydantic import BaseModel\n\nfrom blok import node\nfrom blok.types.context import Context\n\n\nclass Input(BaseModel):\n    \"\"\"Validated inputs for the {{NODE_NAME}} node.\"\"\"\n\n    name: str = \"world\"\n\n\nclass Output(BaseModel):\n    message: str\n\n\n@node(\"{{NODE_NAME}}\", \"Describe what {{NODE_NAME}} does\")\ndef run(ctx: Context, input: Input) -> Output:\n    # `input` is already validated against Input; the return is validated\n    # against Output and serialized for you.\n    return Output(message=f\"Hello, {input.name}!\")\n";
-declare const examples_url = "\nExamples:\n1- Open \"workflow-docs.json\" in your browser at http://localhost:4000/workflow-docs\n2- Open \"db-manager.json\" in your browser at http://localhost:4000/db-manager\n3- Open \"dashboard-gen.json\" in your browser at http://localhost:4000/dashboard-gen\n4- Open \"countries.json\" in your browser at http://localhost:4000/countries\n5- Open \"chat.json\" in your browser at http://localhost:4000/chat (set OPENROUTER_API_KEY first)\n6- Open \"chat-memory.json\" in your browser at http://localhost:4000/chat-memory (needs OPENROUTER_API_KEY + Redis at REDIS_URL)\n7- Webhook router: POST /webhooks/{stripe,github,linear} with signed bodies \u2014 set the matching *_WEBHOOK_SECRET env vars (needs --triggers webhook)\n8- LLM agent w/ tool calls: open http://localhost:4000/agent \u2014 model picks between get_weather and calculate tools (needs OPENROUTER_API_KEY + Redis)\n9- Worker fan-out: POST /fanout/jobs with body '{items:[...], tenantId?:\"...\"}' to enqueue N worker jobs (needs --triggers worker; BLOK_WORKER_ADAPTER=in-memory works single-process)\n10- Trigger references (NOT http): workflows/json/{cron-heartbeat,pubsub-on-order}.json demonstrate the cron and pubsub triggers; src/workflows/websocket/events/echo-demo.ts demonstrates websocket \u2014 read AGENTS.md \"Choosing a trigger\" to pick the right one by intent instead of defaulting to HTTP.\n\nFor more documentation, visit src/nodes/examples/README.md. The first three examples require a PostgreSQL database to function.\n";
+declare const examples_url = "\nExamples:\n1- Open \"workflow-docs.json\" in your browser at http://localhost:4000/workflow-docs\n2- Open \"db-manager.json\" in your browser at http://localhost:4000/db-manager\n3- Open \"dashboard-gen.json\" in your browser at http://localhost:4000/dashboard-gen\n4- Open \"countries.json\" in your browser at http://localhost:4000/countries\n5- Open \"chat.json\" in your browser at http://localhost:4000/chat (set OPENROUTER_API_KEY first)\n6- Open \"chat-memory.json\" in your browser at http://localhost:4000/chat-memory (needs OPENROUTER_API_KEY + Redis at REDIS_URL)\n7- Webhook router: POST /webhooks/{stripe,github,linear} with signed bodies \u2014 set the matching *_WEBHOOK_SECRET env vars (needs --triggers webhook)\n8- LLM agent w/ tool calls: open http://localhost:4000/agent \u2014 model picks between get_weather and calculate tools (needs OPENROUTER_API_KEY + Redis)\n9- Worker fan-out: POST /fanout/jobs with body '{items:[...], tenantId?:\"...\"}' to enqueue N worker jobs (needs --triggers worker; BLOK_WORKER_ADAPTER=in-memory works single-process)\n10- Trigger references (NOT http): workflows/json/{cron-heartbeat,pubsub-on-order}.json demonstrate the cron and pubsub triggers; src/workflows/websocket/events/echo-demo.ts demonstrates websocket \u2014 read AGENTS.md \"Choosing a trigger\" to pick the right one by intent instead of defaulting to HTTP.\n\nFor more documentation, visit src/nodes/examples/README.md.\n";
 declare const workflow_template = "import { http, node, step, workflow } from \"@blokjs/core\";\n\n/**\n * {{WORKFLOW_NAME}}\n *\n * Add steps with step(\"id\", node, inputs). Read a step's output downstream via\n * the handle it returns (const user = step(...); ... user.name). Control flow:\n * branch / forEach / switchOn / tryCatch \u2014 all from @blokjs/core.\n */\nexport default workflow(\n\t\"{{WORKFLOW_NAME}}\",\n\t{ version: \"1.0.0\", trigger: http.get(\"{{WORKFLOW_PATH}}\") },\n\t(req) => {\n\t\t// Echo the request body back. @blokjs/respond writes the HTTP response,\n\t\t// so mark it ephemeral (no state slot needed).\n\t\tstep(\"echo\", node(\"@blokjs/respond\"), { body: req.body }, { ephemeral: true });\n\t},\n);\n";
 declare const supervisord_nodejs = "\n[supervisord]\nnodaemon=true\n\n[program:nodejs_app]\ncommand=npm start\ndirectory=/app\nautostart=true\nautorestart=true\nstderr_logfile=/var/log/nodejs.err.log\nstdout_logfile=/var/log/nodejs.out.log\n";
 declare const supervisord_python = "\n[program:python_app]\ncommand=python3 /app/.blok/runtimes/python3/server.py\ndirectory=/app\nautostart=true\nautorestart=true\nstderr_logfile=/var/log/python.err.log\nstdout_logfile=/var/log/python.out.log\n";

package/dist/commands/create/utils/Examples.js

@@ -77,7 +77,7 @@ Examples:
 9- Worker fan-out: POST /fanout/jobs with body '{items:[...], tenantId?:"..."}' to enqueue N worker jobs (needs --triggers worker; BLOK_WORKER_ADAPTER=in-memory works single-process)
 10- Trigger references (NOT http): workflows/json/{cron-heartbeat,pubsub-on-order}.json demonstrate the cron and pubsub triggers; src/workflows/websocket/events/echo-demo.ts demonstrates websocket — read AGENTS.md "Choosing a trigger" to pick the right one by intent instead of defaulting to HTTP.
 
-For more documentation, visit src/nodes/examples/README.md. The first three examples require a PostgreSQL database to function.
+For more documentation, visit src/nodes/examples/README.md.
 `;
 const workflow_template = `import { http, node, step, workflow } from "@blokjs/core";
 

package/dist/commands/runtime/shared.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import * as p from "@clack/prompts";
 import color from "picocolors";
 import simpleGit from "simple-git";
@@ -62,6 +63,9 @@ export async function resolveSdkSource(projectRoot, localOverride, onProgress) {
         }
         return resolved;
     }
+    const bundled = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../scaffold-repo");
+    if (fs.existsSync(path.join(bundled, "sdks")))
+        return bundled;
     const tag = readFrameworkTag(projectRoot);
     if (!tag) {
         throw new RuntimeCommandError("Couldn't determine the project's Blok version from package.json. Pass --local <path-to-blok-repo> to point at a matching SDK source.");

package/dist/scaffold-repo/examples/ts-workflows/mcp-greeter.ts

@@ -0,0 +1,59 @@
+import { workflow } from "@blokjs/helper";
+import { z } from "zod";
+
+/**
+ * MCP example — exposes this workflow to MCP clients (Cursor, Claude, …) as a
+ * tool named "greet".
+ *
+ * Ships only when the project is scaffolded with the `mcp` trigger. On
+ * `blokctl dev` an MCP server mounts on the HTTP port at `/mcp`
+ * (SSE: GET /mcp/sse + POST /mcp/messages, and Streamable-HTTP: POST /mcp).
+ * Clients see a `greet` tool whose JSON inputSchema is derived from the
+ * top-level `input` Zod schema below. `tools/call` arguments arrive on
+ * `ctx.request.body`, and the MCP result is the final step's `ctx.response.data`.
+ *
+ * This is a `runtime.*`-free, in-process example: a single `@blokjs/expr` step
+ * builds the greeting object, so no external SDK container is required.
+ */
+export default workflow({
+	name: "mcp-greeter",
+	version: "1.0.0",
+	description: "MCP tool that greets a person by name.",
+
+	// Becomes the MCP tool's JSON-Schema inputSchema (via zod-to-json-schema).
+	input: z.object({
+		name: z.string().min(1).describe("Name of the person to greet"),
+		excited: z.boolean().default(false).describe("End the greeting with '!' instead of '.'"),
+	}),
+
+	output: z.object({
+		greeting: z.string(),
+	}),
+
+	trigger: {
+		mcp: {
+			path: "/mcp",
+			serverName: "blok-examples",
+			serverVersion: "1.0.0",
+			transports: ["sse", "streamable-http"],
+			tool: {
+				name: "greet",
+				description: "Greet a person by name. Pass { name, excited? }.",
+			},
+		},
+	},
+
+	steps: [
+		{
+			// `@blokjs/expr` evaluates the plain-JS expression against the live
+			// ctx and returns its result as this step's data — which is what the
+			// MCP trigger sends back as the tool result (ctx.response.data).
+			id: "greet",
+			use: "@blokjs/expr",
+			inputs: {
+				expression:
+					'({ greeting: "Hello, " + (ctx.request.body.name || "there") + (ctx.request.body.excited ? "!" : ".") })',
+			},
+		},
+	],
+});

package/dist/scaffold-repo/examples/ts-workflows/runtime-csharp-hello.ts

@@ -0,0 +1,36 @@
+import { workflow } from "@blokjs/helper";
+
+/**
+ * Cross-runtime example — runs the C# sidecar's built-in `hello-world` node.
+ *
+ * Ships only when the project is scaffolded with the C# runtime
+ * (`blokctl create … --runtimes csharp`, or `blokctl runtime add csharp` later).
+ * On `blokctl dev` the C# SDK container starts and registers `hello-world`;
+ * this HTTP workflow dispatches to it over gRPC.
+ *
+ * Two data paths in one call — this is the point of the example:
+ *   - `name`   comes from the request BODY (the node reads `ctx.request.body.name`)
+ *   - `prefix` comes from the step `inputs` (step inputs become the node's config)
+ *
+ *   POST /runtimes/csharp/hello   { "name": "Ada" }
+ *   → { "message": "Hello from the C# runtime, Ada!", "timestamp": "…", "language": "csharp" }
+ *
+ * The single step is the terminal step, so the HTTP trigger emits its output
+ * as the JSON response — no `@blokjs/respond` needed.
+ */
+export default workflow({
+	name: "runtime-csharp-hello",
+	version: "1.0.0",
+	description: "Calls the C# runtime's hello-world node over gRPC.",
+	trigger: { http: { method: "POST", path: "/runtimes/csharp/hello" } },
+	steps: [
+		{
+			id: "greet",
+			use: "hello-world",
+			type: "runtime.csharp",
+			// Step inputs become the node's config. The hello-world node reads
+			// `prefix` from there; `name` flows in separately from the request body.
+			inputs: { prefix: "Hello from the C# runtime" },
+		},
+	],
+});

package/dist/scaffold-repo/examples/ts-workflows/runtime-go-hello.ts

@@ -0,0 +1,36 @@
+import { workflow } from "@blokjs/helper";
+
+/**
+ * Cross-runtime example — runs the Go sidecar's built-in `hello-world` node.
+ *
+ * Ships only when the project is scaffolded with the Go runtime
+ * (`blokctl create … --runtimes go`, or add it later via
+ * `blokctl runtime add go`). On `blokctl dev` the Go SDK container starts and
+ * registers `hello-world`; this HTTP workflow dispatches to it over gRPC.
+ *
+ * Two data paths in one call — this is the point of the example:
+ *   - `name`   comes from the request BODY (the node reads `ctx.request.body.name`)
+ *   - `prefix` comes from the step `inputs` (step inputs become the node's config)
+ *
+ *   POST /runtimes/go/hello   { "name": "Ada" }
+ *   → { "message": "Hello from the Go runtime, Ada!", "timestamp": "…", "language": "go" }
+ *
+ * The single step is the terminal step, so the HTTP trigger emits its output
+ * as the JSON response — no `@blokjs/respond` needed.
+ */
+export default workflow({
+	name: "runtime-go-hello",
+	version: "1.0.0",
+	description: "Calls the Go runtime's hello-world node over gRPC.",
+	trigger: { http: { method: "POST", path: "/runtimes/go/hello" } },
+	steps: [
+		{
+			id: "greet",
+			use: "hello-world",
+			type: "runtime.go",
+			// Step inputs become the node's config. The hello-world node reads
+			// `prefix` from there; `name` flows in separately from the request body.
+			inputs: { prefix: "Hello from the Go runtime" },
+		},
+	],
+});

package/dist/scaffold-repo/examples/ts-workflows/runtime-java-hello.ts

@@ -0,0 +1,36 @@
+import { workflow } from "@blokjs/helper";
+
+/**
+ * Cross-runtime example — runs the Java sidecar's built-in `hello-world` node.
+ *
+ * Ships only when the project is scaffolded with the Java runtime
+ * (`blokctl create … --runtimes java`, or `blokctl runtime add java` later).
+ * On `blokctl dev` the Java SDK container starts and registers `hello-world`;
+ * this HTTP workflow dispatches to it over gRPC.
+ *
+ * Two data paths in one call — this is the point of the example:
+ *   - `name`   comes from the request BODY (the node reads `ctx.request.body.name`)
+ *   - `prefix` comes from the step `inputs` (step inputs become the node's config)
+ *
+ *   POST /runtimes/java/hello   { "name": "Ada" }
+ *   → { "message": "Hello from the Java runtime, Ada!", "timestamp": "…", "language": "java" }
+ *
+ * The single step is the terminal step, so the HTTP trigger emits its output
+ * as the JSON response — no `@blokjs/respond` needed.
+ */
+export default workflow({
+	name: "runtime-java-hello",
+	version: "1.0.0",
+	description: "Calls the Java runtime's hello-world node over gRPC.",
+	trigger: { http: { method: "POST", path: "/runtimes/java/hello" } },
+	steps: [
+		{
+			id: "greet",
+			use: "hello-world",
+			type: "runtime.java",
+			// Step inputs become the node's config. The hello-world node reads
+			// `prefix` from there; `name` flows in separately from the request body.
+			inputs: { prefix: "Hello from the Java runtime" },
+		},
+	],
+});

package/dist/scaffold-repo/examples/ts-workflows/runtime-php-hello.ts

@@ -0,0 +1,36 @@
+import { workflow } from "@blokjs/helper";
+
+/**
+ * Cross-runtime example — runs the PHP sidecar's built-in `hello-world` node.
+ *
+ * Ships only when the project is scaffolded with the PHP runtime
+ * (`blokctl create … --runtimes php`, or `blokctl runtime add php` later).
+ * On `blokctl dev` the PHP SDK container starts and registers `hello-world`;
+ * this HTTP workflow dispatches to it over gRPC.
+ *
+ * Two data paths in one call — this is the point of the example:
+ *   - `name`   comes from the request BODY (the node reads `ctx.request.body.name`)
+ *   - `prefix` comes from the step `inputs` (step inputs become the node's config)
+ *
+ *   POST /runtimes/php/hello   { "name": "Ada" }
+ *   → { "message": "Hello from the PHP runtime, Ada!", "timestamp": "…", "language": "php" }
+ *
+ * The single step is the terminal step, so the HTTP trigger emits its output
+ * as the JSON response — no `@blokjs/respond` needed.
+ */
+export default workflow({
+	name: "runtime-php-hello",
+	version: "1.0.0",
+	description: "Calls the PHP runtime's hello-world node over gRPC.",
+	trigger: { http: { method: "POST", path: "/runtimes/php/hello" } },
+	steps: [
+		{
+			id: "greet",
+			use: "hello-world",
+			type: "runtime.php",
+			// Step inputs become the node's config. The hello-world node reads
+			// `prefix` from there; `name` flows in separately from the request body.
+			inputs: { prefix: "Hello from the PHP runtime" },
+		},
+	],
+});

package/dist/scaffold-repo/examples/ts-workflows/runtime-python3-hello.ts

@@ -0,0 +1,36 @@
+import { workflow } from "@blokjs/helper";
+
+/**
+ * Cross-runtime example — runs the Python3 sidecar's built-in `hello-world` node.
+ *
+ * Ships only when the project is scaffolded with the Python3 runtime
+ * (`blokctl create … --runtimes python3`, or `blokctl runtime add python3` later).
+ * On `blokctl dev` the Python3 SDK container starts and registers `hello-world`;
+ * this HTTP workflow dispatches to it over gRPC.
+ *
+ * Two data paths in one call — this is the point of the example:
+ *   - `name`   comes from the request BODY (the node reads `ctx.request.body.name`)
+ *   - `prefix` comes from the step `inputs` (step inputs become the node's config)
+ *
+ *   POST /runtimes/python3/hello   { "name": "Ada" }
+ *   → { "message": "Hello from the Python3 runtime, Ada!", "timestamp": "…", "language": "python3" }
+ *
+ * The single step is the terminal step, so the HTTP trigger emits its output
+ * as the JSON response — no `@blokjs/respond` needed.
+ */
+export default workflow({
+	name: "runtime-python3-hello",
+	version: "1.0.0",
+	description: "Calls the Python3 runtime's hello-world node over gRPC.",
+	trigger: { http: { method: "POST", path: "/runtimes/python3/hello" } },
+	steps: [
+		{
+			id: "greet",
+			use: "hello-world",
+			type: "runtime.python3",
+			// Step inputs become the node's config. The hello-world node reads
+			// `prefix` from there; `name` flows in separately from the request body.
+			inputs: { prefix: "Hello from the Python3 runtime" },
+		},
+	],
+});

package/dist/scaffold-repo/examples/ts-workflows/runtime-ruby-hello.ts

@@ -0,0 +1,36 @@
+import { workflow } from "@blokjs/helper";
+
+/**
+ * Cross-runtime example — runs the Ruby sidecar's built-in `hello-world` node.
+ *
+ * Ships only when the project is scaffolded with the Ruby runtime
+ * (`blokctl create … --runtimes ruby`, or `blokctl runtime add ruby` later).
+ * On `blokctl dev` the Ruby SDK container starts and registers `hello-world`;
+ * this HTTP workflow dispatches to it over gRPC.
+ *
+ * Two data paths in one call — this is the point of the example:
+ *   - `name`   comes from the request BODY (the node reads `ctx.request.body.name`)
+ *   - `prefix` comes from the step `inputs` (step inputs become the node's config)
+ *
+ *   POST /runtimes/ruby/hello   { "name": "Ada" }
+ *   → { "message": "Hello from the Ruby runtime, Ada!", "timestamp": "…", "language": "ruby" }
+ *
+ * The single step is the terminal step, so the HTTP trigger emits its output
+ * as the JSON response — no `@blokjs/respond` needed.
+ */
+export default workflow({
+	name: "runtime-ruby-hello",
+	version: "1.0.0",
+	description: "Calls the Ruby runtime's hello-world node over gRPC.",
+	trigger: { http: { method: "POST", path: "/runtimes/ruby/hello" } },
+	steps: [
+		{
+			id: "greet",
+			use: "hello-world",
+			type: "runtime.ruby",
+			// Step inputs become the node's config. The hello-world node reads
+			// `prefix` from there; `name` flows in separately from the request body.
+			inputs: { prefix: "Hello from the Ruby runtime" },
+		},
+	],
+});

package/dist/scaffold-repo/examples/ts-workflows/runtime-rust-hello.ts

@@ -0,0 +1,36 @@
+import { workflow } from "@blokjs/helper";
+
+/**
+ * Cross-runtime example — runs the Rust sidecar's built-in `hello-world` node.
+ *
+ * Ships only when the project is scaffolded with the Rust runtime
+ * (`blokctl create … --runtimes rust`, or `blokctl runtime add rust` later).
+ * On `blokctl dev` the Rust SDK container starts and registers `hello-world`;
+ * this HTTP workflow dispatches to it over gRPC.
+ *
+ * Two data paths in one call — this is the point of the example:
+ *   - `name`   comes from the request BODY (the node reads `ctx.request.body.name`)
+ *   - `prefix` comes from the step `inputs` (step inputs become the node's config)
+ *
+ *   POST /runtimes/rust/hello   { "name": "Ada" }
+ *   → { "message": "Hello from the Rust runtime, Ada!", "timestamp": "…", "language": "rust" }
+ *
+ * The single step is the terminal step, so the HTTP trigger emits its output
+ * as the JSON response — no `@blokjs/respond` needed.
+ */
+export default workflow({
+	name: "runtime-rust-hello",
+	version: "1.0.0",
+	description: "Calls the Rust runtime's hello-world node over gRPC.",
+	trigger: { http: { method: "POST", path: "/runtimes/rust/hello" } },
+	steps: [
+		{
+			id: "greet",
+			use: "hello-world",
+			type: "runtime.rust",
+			// Step inputs become the node's config. The hello-world node reads
+			// `prefix` from there; `name` flows in separately from the request body.
+			inputs: { prefix: "Hello from the Rust runtime" },
+		},
+	],
+});