Code node runtime

Code nodes run in an immutable BlitFlow Sandbox. Choose runtime: "node" or runtime: "python"; the runtime decides the source contract and installed packages. This page is the authoritative list of what each environment contains — packages from your own application are not available inside a Sandbox.

Runtime matrix

Node v1, Node v2, and Python v1 are independent immutable snapshots. Their exact patch versions and package inventories are captured when each snapshot is built. A workflow retains its selected version; changing the authoring default does not rewrite existing definitions.

Entry points

Node.js

BlitFlow saves Node source as an .mjs module and invokes its default export:

export default async function (inputs, context) {
  return { result: inputs.value };
}

The one-argument form remains valid. Node source must be executable JavaScript ESM: TypeScript syntax, CommonJS require(), and module.exports are not transpiled or supported.

Python

BlitFlow saves Python source as source.py and invokes main:

def main(inputs, context):
    return {"result": inputs["value"]}

main(inputs) and main(inputs, context) are both valid. main may be synchronous or async. The result must be a plain dict with string keys and strict JSON values. NaN, infinity, bytes, sets, non-string keys, cycles, and custom objects are rejected — including NumPy and pandas scalars and arrays: return float(x), int(x) or .tolist(). An exception raised inside main is a code failure; BlitFlow does not reinterpret it as an argument-count error.

For both languages, inputs is keyed by declared ports, required outputs must exist, optional outputs may be omitted, and extra outputs fail the step. stdout and stderr are bounded diagnostics and never outputs.

Node.js imports

The Node.js 24 standard library is installed. Import built-ins through node: specifiers so generated code cannot confuse them with third-party packages.

import { createHash } from "node:crypto";
import { readFile, writeFile } from "node:fs/promises";

Node v1 includes one external package:

Node v2 requires Node.js >=24.12.0 <25 and includes this exact public catalog:

sharp is not available in Node v1. New Node definitions use v2; explicitly pin version 1 only when preserving its smaller legacy environment. axios and @blitflow/sdk are not available inside either Sandbox environment. Other packages from your application are not installed. Network modules may exist in the standard library, but outbound connections are denied. Do not run npm, npx, yarn, pnpm, or bun install.

Python imports

Python v1 includes the following exact public catalog. Use the import name in the second column, not necessarily the distribution name. Transitive packages are locked for the snapshot but are not a stable authoring surface.

• PyTorch is not installed.
• TensorFlow is not installed.
• Transformers is not installed.
• Diffusers is not installed.

Choose a catalog/provider node for workloads that require those model runtimes.

Python runs with user site packages disabled, bytecode writes disabled, a headless Matplotlib backend, and bounded native-library thread counts. Do not run pip, uv, conda, poetry, or another installer from user code.

Filesystem and Artifacts

Every attempt receives a fresh filesystem. FILE, IMAGE, AUDIO, and VIDEO inputs are read-only local descriptors in both languages:

type CodeArtifactInput = {
  path: string;
  mimeType: string;
  sizeBytes: number;
};

Use the language-specific context path for outputs:

// Node
export default async function ({ text }, { outputDir }) {
  const path = outputDir + "/report.txt";
  await (await import("node:fs/promises")).writeFile(path, text);
  return { report: { path, mimeType: "text/plain" } };
}

# Python
from pathlib import Path

def main(inputs, context):
    path = Path(context.output_dir) / "report.txt"
    path.write_text(inputs["text"], encoding="utf-8")
    return {"report": {"path": str(path), "mimeType": "text/plain"}}

Only declared FILE, IMAGE, AUDIO, and VIDEO outputs are collected and persisted. Never hard-code internal Sandbox paths.

The returned mimeType is checked against the detected bytes. Typed media ports accept closed allowlists; FILE takes any passive MIME:

SVG, HTML, XML, JavaScript, and other active content are rejected on every port. See Code nodes for size limits and chaining examples.

Sandbox restrictions

These restrictions apply identically to Node and Python:

The process supervisor also enforces these per-attempt limits:

Timeouts, missing imports, syntax errors, exceptions, and invalid results fail the step. Public errors do not contain stdout, stderr, internal paths, private Artifact URLs, or provider details.