@styx-api/core 0.3.0 → 0.5.0

package/dist/index.mjs

@@ -14,7 +14,7 @@ function isObject$3(x) {
 function isString$3(x) {
 	return typeof x === "string";
 }
-function isNumber$1(x) {
+function isNumber$2(x) {
 	return typeof x === "number";
 }
 function isArray$3(x) {
@@ -99,7 +99,7 @@ var ArgdumpParser = class {
 		const choices = action.choices;
 		if (isArray$3(choices) && choices.length > 0) {
 			const alts = [];
-			for (const choice of choices) if (isString$3(choice) || isNumber$1(choice)) alts.push({
+			for (const choice of choices) if (isString$3(choice) || isNumber$2(choice)) alts.push({
 				kind: "literal",
 				attrs: { str: String(choice) }
 			});
@@ -232,7 +232,7 @@ var ArgdumpParser = class {
 				countMin: 1
 			}
 		};
-		if (isNumber$1(nargs) && Number.isInteger(nargs) && nargs >= 0) {
+		if (isNumber$2(nargs) && Number.isInteger(nargs) && nargs >= 0) {
 			if (nargs === 1) return node;
 			return {
 				kind: "repeat",
@@ -252,7 +252,7 @@ var ArgdumpParser = class {
 		const name = this.preferredName(action) ?? (isString$3(dest) ? dest : void 0);
 		const hasName = name !== void 0;
 		const hasHelp = isString$3(help) && !isSuppressed(help);
-		const hasDefault = (isString$3(defaultVal) || isNumber$1(defaultVal) || typeof defaultVal === "boolean") && !isSuppressed(defaultVal);
+		const hasDefault = (isString$3(defaultVal) || isNumber$2(defaultVal) || typeof defaultVal === "boolean") && !isSuppressed(defaultVal);
 		if (!hasName && !hasHelp && !hasDefault) return void 0;
 		return {
 			...hasName && { name },
@@ -853,7 +853,7 @@ function isObject$2(x) {
 function isString$2(x) {
 	return typeof x === "string";
 }
-function isNumber(x) {
+function isNumber$1(x) {
 	return typeof x === "number";
 }
 function isArray$2(x) {
@@ -951,7 +951,7 @@ var BoutiquesParser = class {
 		const title = btInput.name;
 		const description = btInput.description;
 		const defaultValue = btInput["default-value"];
-		const hasDefault = isString$2(defaultValue) || isNumber(defaultValue) || typeof defaultValue === "boolean";
+		const hasDefault = isString$2(defaultValue) || isNumber$1(defaultValue) || typeof defaultValue === "boolean";
 		if (!isString$2(name) && !isString$2(title) && !isString$2(description) && !hasDefault) return;
 		return {
 			...isString$2(name) && { name },
@@ -1075,7 +1075,7 @@ var BoutiquesParser = class {
 			kind: "literal",
 			attrs: { str: choice }
 		});
-		else if (isNumber(choice)) alts.push({
+		else if (isNumber$1(choice)) alts.push({
 			kind: "literal",
 			attrs: { str: String(choice) }
 		});
@@ -1112,11 +1112,11 @@ var BoutiquesParser = class {
 					kind: "int",
 					attrs: {}
 				};
-				if (isNumber(btInput.minimum)) {
+				if (isNumber$1(btInput.minimum)) {
 					node.attrs.minValue = Math.floor(btInput.minimum);
 					if (btInput["exclusive-minimum"] === true) node.attrs.minValue += 1;
 				}
-				if (isNumber(btInput.maximum)) {
+				if (isNumber$1(btInput.maximum)) {
 					node.attrs.maxValue = Math.floor(btInput.maximum);
 					if (btInput["exclusive-maximum"] === true) node.attrs.maxValue -= 1;
 				}
@@ -1128,8 +1128,8 @@ var BoutiquesParser = class {
 					kind: "float",
 					attrs: {}
 				};
-				if (isNumber(btInput.minimum)) node.attrs.minValue = btInput.minimum;
-				if (isNumber(btInput.maximum)) node.attrs.maxValue = btInput.maximum;
+				if (isNumber$1(btInput.minimum)) node.attrs.minValue = btInput.minimum;
+				if (isNumber$1(btInput.maximum)) node.attrs.maxValue = btInput.maximum;
 				if (meta) node.meta = meta;
 				return node;
 			}
@@ -1234,8 +1234,8 @@ var BoutiquesParser = class {
 			attrs: {
 				node,
 				...isString$2(btInput["list-separator"]) && { join: btInput["list-separator"] },
-				...isNumber(btInput["min-list-entries"]) && { countMin: btInput["min-list-entries"] },
-				...isNumber(btInput["max-list-entries"]) && { countMax: btInput["max-list-entries"] }
+				...isNumber$1(btInput["min-list-entries"]) && { countMin: btInput["min-list-entries"] },
+				...isNumber$1(btInput["max-list-entries"]) && { countMax: btInput["max-list-entries"] }
 			}
 		};
 	}
@@ -1485,6 +1485,9 @@ function isObject$1(x) {
 function isString$1(x) {
 	return typeof x === "string";
 }
+function isNumber(x) {
+	return typeof x === "number" && Number.isFinite(x);
+}
 function isArray$1(x) {
 	return Array.isArray(x);
 }
@@ -1531,9 +1534,10 @@ function emptyExpr$1() {
 *   - option, 1 arg          -> opt(seq(lit(-switch), value))      (flat optional)
 *   - option, >1 arg / multi -> opt|rep(seq(lit(-switch), ...))    (sub-struct)
 *
-* Type mapping mirrors the v1 `mrt2bt.js` converter's `set_type`. The dump does
-* not carry choice values, so a `choice` argument degrades to a plain string
-* (as it did in v1). Per-command quirks v1 hand-coded that the flat dump cannot
+* Type mapping mirrors the v1 `mrt2bt.js` converter's `set_type`, plus `choice`
+* values: when the dump carries `choices` it lowers to an enum (an alternative
+* of literals), else a plain string (older dumps that omit the values - as v1
+* always did). Per-command quirks v1 hand-coded that the flat dump cannot
 * express (e.g. dwi2fod/mtnormalise paired in/out args) are intentionally NOT
 * special-cased here - they are patched on the niwrap side post-dump, keeping
 * this frontend format-general.
@@ -1616,6 +1620,19 @@ var MrtrixParser = class {
 		};
 	}
 	/**
+	* Integer/float bounds, when the dump carries them. The C++ hook serializes
+	* `Argument::limits.{i,f}.{min,max}` as `min`/`max`, omitting the unbounded
+	* sentinels - so a present value is a real, tool-enforced bound.
+	*/
+	numericBounds(arg) {
+		const lo = arg.min;
+		const hi = arg.max;
+		return {
+			...isNumber(lo) && { minValue: lo },
+			...isNumber(hi) && { maxValue: hi }
+		};
+	}
+	/**
 	* Lower one MRtrix argument to its terminal node (carrying name + doc) and,
 	* for output types, an accompanying `Output`.
 	*/
@@ -1627,11 +1644,31 @@ var MrtrixParser = class {
 		}
 		const name = meta.name;
 		switch (argType) {
-			case "integer": return { node: int(meta) };
-			case "float": return { node: float(meta) };
+			case "integer": {
+				const node = int(meta);
+				Object.assign(node.attrs, this.numericBounds(arg));
+				return { node };
+			}
+			case "float": {
+				const node = float(meta);
+				Object.assign(node.attrs, this.numericBounds(arg));
+				return { node };
+			}
 			case "text":
-			case "choice":
-			case "undefined": return { node: str(meta) };
+			case "undefined":
+			case "boolean": return { node: str(meta) };
+			case "choice": {
+				const choices = arg.choices;
+				if (isArray$1(choices)) {
+					const alts = choices.filter(isString$1).map((c) => lit(c));
+					if (alts.length > 0) {
+						const node = alt(...alts);
+						node.meta = meta;
+						return { node };
+					}
+				}
+				return { node: str(meta) };
+			}
 			case "int seq": {
 				const node = repJoin(",", int());
 				node.meta = meta;
@@ -3350,196 +3387,6 @@ function resolveTypeName(namedTypes) {
 	};
 }
 
-//#endregion
-//#region src/backend/styxdefs-compat.ts
-/**
-* Runtime version floors baked into generated dependency metadata.
-*
-* styx2-generated code calls `mutable_copy` / `mutableCopy` (introduced in the
-* styxdefs 0.7.0 / styxdefs-js 0.2.0 release), so emitted packages genuinely
-* require that runtime floor. This is the single source of truth: bump here and
-* both the Python and TypeScript backends pick it up.
-*/
-const STYXDEFS_COMPAT = {
-	python: ">=0.7.0,<0.8.0",
-	npm: "^0.2.0"
-};
-/**
-* Extra Python runtime packages the root distribution pulls in (container +
-* graph runners). Left unpinned - styxdefs's floor constrains them transitively
-* via their own inter-package pins.
-*/
-const PYTHON_RUNNER_DEPS = [
-	"styxdocker",
-	"styxsingularity",
-	"styxgraph"
-];
-
-//#endregion
-//#region src/backend/python/packaging.ts
-const REQUIRES_PYTHON = ">=3.10";
-const BUILD_SYSTEM = `[build-system]
-requires = ["setuptools>=61"]
-build-backend = "setuptools.build_meta"`;
-/** Escape a value for embedding in a TOML basic string. */
-function tomlStr(s) {
-	return s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/[\r\n]+/g, " ").replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "").trim();
-}
-/** Suite directory / importable package name; matches the CLI's `pkgDir` fallback. */
-function pkgDir(pkg) {
-	return pkg.name ?? "package";
-}
-/** Distribution (PyPI) name for a package: `<project>_<package>`, or just `<package>`. */
-function pyDistName(proj, pkg) {
-	const name = pkgDir(pkg);
-	return proj.name ? `${proj.name}_${name}` : name;
-}
-const SUMMARY_MAX_LEN = 512;
-/**
-* Clamp a description to a <=512-char one-line summary. Prefer cutting at the
-* last complete sentence that fits (clean, no dangling fragment); if there is no
-* sentence boundary early enough, cut at a word boundary and mark the elision.
-*/
-function clampSummary(s) {
-	if (s.length <= SUMMARY_MAX_LEN) return s;
-	const window = s.slice(0, SUMMARY_MAX_LEN);
-	const lastSentence = window.lastIndexOf(". ");
-	if (lastSentence >= 0) return s.slice(0, lastSentence + 1);
-	const ellipsis = "...";
-	const body = window.slice(0, SUMMARY_MAX_LEN - 3);
-	const lastSpace = body.lastIndexOf(" ");
-	return (lastSpace > 0 ? body.slice(0, lastSpace) : body).replace(/[.,;:\s]+$/, "") + ellipsis;
-}
-function description$1(doc, fallbackName) {
-	return clampSummary(doc?.description ?? `Styx generated wrappers for ${doc?.title ?? fallbackName ?? "tools"}.`);
-}
-function authorsField(doc) {
-	return `[${(doc?.authors?.length ? doc.authors : ["unknown"]).map((a) => `{ name = "${tomlStr(a)}" }`).join(", ")}]`;
-}
-function licenseField(proj) {
-	return `{ text = "${tomlStr(proj.license?.description ?? "unknown")}" }`;
-}
-/**
-* Per-suite `pyproject.toml`. The flat layout (`python/<pkg>/bet.py`) makes the
-* directory itself the importable package, so setuptools' `package-dir` maps the
-* import name (`<pkg>`) onto the distribution's root directory. The styxdefs
-* floor is the only runtime dependency.
-*
-* Precondition: `pkg.name` must be a valid Python identifier - the flat layout's
-* relative imports (`from .bet import *`) already require this, and the CLI uses
-* it verbatim as the directory name, so this stays consistent with that.
-*/
-function generateSubPyproject(proj, pkg) {
-	const importName = pkgDir(pkg);
-	const cb = new CodeBuilder("  ");
-	cb.line("[project]");
-	cb.line(`name = "${tomlStr(pyDistName(proj, pkg))}"`);
-	cb.line(`version = "${tomlStr(proj.version ?? "0.0.0")}"`);
-	cb.line(`description = "${tomlStr(description$1(pkg.doc, pkg.name))}"`);
-	cb.line(`readme = "README.md"`);
-	cb.line(`license = ${licenseField(proj)}`);
-	cb.line(`authors = ${authorsField(pkg.doc ?? proj.doc)}`);
-	cb.line(`requires-python = "${REQUIRES_PYTHON}"`);
-	cb.line("dependencies = [");
-	cb.line(`  "styxdefs${STYXDEFS_COMPAT.python}",`);
-	cb.line("]");
-	cb.blank();
-	cb.line("[tool.setuptools]");
-	cb.line(`packages = ["${importName}"]`);
-	cb.line(`package-dir = { "${importName}" = "." }`);
-	cb.blank();
-	cb.line("[tool.setuptools.package-data]");
-	cb.line(`"${importName}" = ["py.typed"]`);
-	cb.blank();
-	cb.line(BUILD_SYSTEM);
-	return cb.toString() + "\n";
-}
-/**
-* Root `pyproject.toml`: a metapackage depending on each per-suite distribution
-* plus the container/graph runner packages. `packages = []` keeps setuptools
-* from sweeping the sibling suite directories into this distribution.
-*/
-function generateRootPyproject(proj, distNames) {
-	const cb = new CodeBuilder("  ");
-	cb.line("[project]");
-	cb.line(`name = "${tomlStr(proj.name ?? "project")}"`);
-	cb.line(`version = "${tomlStr(proj.version ?? "0.0.0")}"`);
-	cb.line(`description = "${tomlStr(description$1(proj.doc, proj.name))}"`);
-	cb.line(`readme = "README.md"`);
-	cb.line(`license = ${licenseField(proj)}`);
-	cb.line(`authors = ${authorsField(proj.doc)}`);
-	cb.line(`requires-python = "${REQUIRES_PYTHON}"`);
-	cb.line("dependencies = [");
-	for (const dep of PYTHON_RUNNER_DEPS) cb.line(`  "${dep}",`);
-	for (const dist of distNames) cb.line(`  "${tomlStr(dist)}",`);
-	cb.line("]");
-	cb.blank();
-	cb.line("[tool.setuptools]");
-	cb.line("packages = []");
-	cb.blank();
-	cb.line(BUILD_SYSTEM);
-	return cb.toString() + "\n";
-}
-/** Per-suite README crediting the upstream tool authors. */
-function generateSubReadme(proj, pkg) {
-	const projectTitle = proj.doc?.title ?? proj.name ?? "Styx";
-	const packageTitle = pkg.doc?.title ?? pkg.name ?? "package";
-	const url = pkg.doc?.urls?.[0];
-	const titleMd = url ? `[${packageTitle}](${url})` : packageTitle;
-	const credits = pkg.doc?.authors?.length ? pkg.doc.authors.join(", ") : pkg.doc?.urls?.join(", ") ?? "unknown";
-	return `# ${projectTitle} wrappers for ${titleMd}${pkg.doc?.description ? `\n\n${pkg.doc.description}` : ""}\n\n${packageTitle} is made by ${credits}.\n\nThis package contains wrappers only and has no affiliation with the original authors.\n`;
-}
-/** Root README listing the bundled per-suite distributions. */
-function generateRootReadme(proj, distNames) {
-	return `# ${proj.doc?.title ?? proj.name ?? "Styx"}\n${proj.doc?.description ? `\n${proj.doc.description}\n` : ""}\nAuto-generated Styx wrappers. This project bundles the following packages:\n\n${distNames.map((d) => `- ${d}`).join("\n")}\n`;
-}
-/** Local-install manifest: each suite directory first, then the root metapackage. */
-function generateRequirementsTxt(pkgDirs) {
-	return [...pkgDirs.map((d) => `./${d}`), "./"].join("\n") + "\n";
-}
-
-//#endregion
-//#region src/backend/sig-entries.ts
-/**
-* Build per-field signature entries for the kwarg wrapper and params factory.
-* Skips `@type` (the factory injects it as a constant). Required-no-default
-* entries are placed before defaulted ones so the resulting signature is
-* syntactically valid in both Python and TS.
-*
-* `registerLocal` is called once per field with the wire key; it must return
-* a scrubbed, unique host identifier (typically by combining a language-aware
-* scrub function with `Scope.add()`). The caller's scope should already have
-* the function's other locals (`params`, `runner`, ...) reserved so this
-* registration cannot collide with them.
-*/
-function buildSigEntries(rootType, fieldInfo, registerLocal, opts) {
-	const entries = [];
-	for (const [fieldName, fieldType] of Object.entries(rootType.fields)) {
-		if (fieldType.kind === "literal") continue;
-		const fi = fieldInfo.get(fieldName);
-		const isOptional = fieldType.kind === "optional";
-		const inner = isOptional ? fieldType.inner : fieldType;
-		let sigType = opts.renderType(inner);
-		if (isOptional) sigType += opts.nullableSuffix;
-		let sigDefault;
-		const hasExplicitDefault = fi?.defaultValue !== void 0;
-		if (hasExplicitDefault) sigDefault = opts.renderDefault(fi.defaultValue);
-		else if (isOptional) sigDefault = opts.nullableDefault;
-		entries.push({
-			name: registerLocal(fieldName),
-			wireKey: fieldName,
-			sigType,
-			sigDefault,
-			isOptional,
-			hasExplicitDefault,
-			doc: fi?.doc
-		});
-	}
-	const required = entries.filter((e) => e.sigDefault === void 0);
-	const defaulted = entries.filter((e) => e.sigDefault !== void 0);
-	return [...required, ...defaulted];
-}
-
 //#endregion
 //#region src/backend/union-variants.ts
 /**
@@ -4359,65 +4206,455 @@ function emitKwargWrapper$1(ctx, entries, funcName, paramsFnName, executeFnName,
 }
 
 //#endregion
-//#region src/backend/validate-walk.ts
+//#region src/backend/nipype/emit.ts
+function call(ctor, args) {
+	return `${ctor}(${args.join(", ")})`;
+}
 /**
-* Enumerate a struct type's fields in declaration order, each paired with the
-* IR node its binding resolved from. `searchRoot` is the IR subtree known to
-* contain the struct (the root expr for the top-level struct, or a field /
-* union-arm node for nested ones).
+* Render a numeric literal, forcing a float form (e.g. `0.0`) for a float field.
+* `traits.Range` infers its numeric type from the bound literals, so integer
+* bounds on a float field (e.g. `low=0, high=1`) would build an *integer* range
+* that rejects `0.5`. Emitting `0.0`/`1.0` keeps it a float range.
 */
-function structFields(ctx, structType, searchRoot) {
-	const nodeByName = /* @__PURE__ */ new Map();
-	if (searchRoot) {
-		const structNode = findStructNode(searchRoot, ctx, structType);
-		if (structNode) for (const child of structNode.attrs.nodes) {
-			const match = resolveFieldBinding(child, ctx, structType);
-			if (match) nodeByName.set(match.binding.name, match.binding.node);
+function renderNum(value, asFloat) {
+	if (asFloat && typeof value === "number" && Number.isInteger(value)) return `${value}.0`;
+	return renderPyLiteral(value);
+}
+/** Human-readable `desc=` text: doc + degrade/media-type notes. */
+function descText(p) {
+	const parts = [];
+	if (p.doc) parts.push(p.doc);
+	if (p.kind === "struct" || p.kind === "union") parts.push("(nested configuration; pass a dict)");
+	if (p.mediaTypes && p.mediaTypes.length > 0) parts.push(`(media types: ${p.mediaTypes.join(", ")})`);
+	return parts.length > 0 ? parts.join(" ") : void 0;
+}
+/** Map a list element descriptor to a (bare) nipype inner trait. */
+function renderItemTrait(item) {
+	if (!item) return "traits.Any()";
+	switch (item.kind) {
+		case "path": return "File(exists=True)";
+		case "int":
+		case "count": return "traits.Int()";
+		case "float": return "traits.Float()";
+		case "str": return "traits.Str()";
+		case "bool": return "traits.Bool()";
+		case "enum": return call("traits.Enum", (item.choices ?? []).map((c) => renderPyLiteral(c)));
+		default: return "traits.Any()";
+	}
+}
+/** Map a parameter to its nipype input trait expression, carrying rich constraints. */
+function renderInputTrait(p) {
+	const tail = [];
+	if (p.mandatory) tail.push("mandatory=True");
+	const desc = descText(p);
+	if (desc) tail.push(`desc=${pyStr(desc)}`);
+	const hasDef = p.hasDefault && p.default !== void 0;
+	const def = p.default;
+	switch (p.kind) {
+		case "path": return call("File", ["exists=True", ...tail]);
+		case "bool": return call("traits.Bool", [...hasDef ? [renderPyLiteral(def), "usedefault=True"] : [], ...tail]);
+		case "count": return call("traits.Int", [...hasDef ? [renderPyLiteral(def), "usedefault=True"] : [], ...tail]);
+		case "int":
+		case "float": {
+			const asFloat = p.kind === "float";
+			if (p.range) {
+				const a = [];
+				if (hasDef) a.push(`value=${renderNum(def, asFloat)}`);
+				if (p.range.min !== void 0) a.push(`low=${renderNum(p.range.min, asFloat)}`);
+				if (p.range.max !== void 0) a.push(`high=${renderNum(p.range.max, asFloat)}`);
+				if (hasDef) a.push("usedefault=True");
+				return call("traits.Range", [...a, ...tail]);
+			}
+			return call(p.kind === "int" ? "traits.Int" : "traits.Float", [...hasDef ? [renderNum(def, asFloat), "usedefault=True"] : [], ...tail]);
+		}
+		case "str": return call("traits.Str", [...hasDef ? [renderPyLiteral(def), "usedefault=True"] : [], ...tail]);
+		case "enum": {
+			const choices = p.choices ?? [];
+			return call("traits.Enum", [
+				...(hasDef ? [def, ...choices.filter((c) => c !== def)] : choices).map((c) => renderPyLiteral(c)),
+				...hasDef ? ["usedefault=True"] : [],
+				...tail
+			]);
+		}
+		case "list": {
+			const inner = renderItemTrait(p.itemType);
+			const bounds = [];
+			if (p.listBounds?.min !== void 0) bounds.push(`minlen=${p.listBounds.min}`);
+			if (p.listBounds?.max !== void 0) bounds.push(`maxlen=${p.listBounds.max}`);
+			return call("traits.List", [
+				inner,
+				...bounds,
+				...tail
+			]);
 		}
+		case "struct":
+		case "union": return call("traits.Any", tail);
 	}
-	const fieldInfo = collectFieldInfo(ctx, structType);
-	return Object.entries(structType.fields).map(([name, type]) => ({
-		name,
-		type,
-		node: nodeByName.get(name),
-		hasDefault: fieldInfo.get(name)?.defaultValue !== void 0
-	}));
 }
 /**
-* Depth-first search for the first node satisfying `pred`, descending through
-* the transparent structural wrappers the solver may bury a binding under
-* (sequence/optional/repeat/alternative).
+* Map an output field to its nipype output trait expression. `isRoot` is the
+* synthetic output directory, typed as a `Directory` rather than a `File`.
 */
-function findNode(node, pred) {
-	if (!node) return void 0;
-	if (pred(node)) return node;
-	switch (node.kind) {
-		case "sequence":
-			for (const child of node.attrs.nodes) {
-				const r = findNode(child, pred);
-				if (r) return r;
-			}
-			return;
-		case "optional": return findNode(node.attrs.node, pred);
-		case "repeat": return findNode(node.attrs.node, pred);
-		case "alternative":
-			for (const alt of node.attrs.alts) {
-				const r = findNode(alt, pred);
-				if (r) return r;
-			}
-			return;
-		default: return;
-	}
-}
-/** Locate the int/float node carrying a scalar field's numeric range. */
-function findRangeNode(node) {
-	return findNode(node, (n) => n.kind === "int" || n.kind === "float");
-}
-/** Locate the repeat node carrying a list field's length bounds and item. */
-function findRepeatNode(node) {
-	return findNode(node, (n) => n.kind === "repeat");
+function renderOutputTrait(f, isRoot) {
+	const tail = f.doc ? [`desc=${pyStr(f.doc)}`] : [];
+	if (f.shape.kind === "list") return call("traits.List", ["File()", ...tail]);
+	if (isRoot) return call("Directory", tail);
+	return call("File", tail);
 }
-/** Locate the alternative node backing a union field, to map arms to variants. */
+/**
+* Emit the nipype interface module for one tool: a typed InputSpec/OutputSpec and
+* a BaseInterface that delegates execution to the co-emitted styx Python wrapper.
+*/
+function emitNipypeInterface(ctx, spec, names) {
+	const cb = new CodeBuilder("    ");
+	cb.comment("This file was auto generated by Styx.", "# ");
+	cb.comment("Do not edit this file directly.", "# ");
+	cb.blank();
+	cb.line("from nipype.interfaces.base import (");
+	cb.indent(() => {
+		cb.line("BaseInterface,");
+		cb.line("BaseInterfaceInputSpec,");
+		cb.line("Directory,");
+		cb.line("File,");
+		cb.line("TraitedSpec,");
+		cb.line("isdefined,");
+		cb.line("traits,");
+	});
+	cb.line(")");
+	cb.blank();
+	cb.line(`from .${names.styxStem} import ${spec.delegation.wrapperFn}, ${spec.delegation.outputsClass}`);
+	cb.blank();
+	cb.blank();
+	cb.line(`class ${names.inputSpec}(BaseInterfaceInputSpec):`);
+	cb.indent(() => {
+		if (!spec.rootIsStruct || spec.params.length === 0) {
+			cb.line("pass");
+			return;
+		}
+		for (const p of spec.params) cb.line(`${p.hostName} = ${renderInputTrait(p)}`);
+	});
+	cb.blank();
+	cb.blank();
+	cb.line(`class ${names.outputSpec}(TraitedSpec):`);
+	cb.indent(() => {
+		if (spec.outputs.length === 0 && spec.streams.length === 0) {
+			cb.line("pass");
+			return;
+		}
+		spec.outputs.forEach((f, i) => cb.line(`${f.id} = ${renderOutputTrait(f, i === 0)}`));
+		for (const s of spec.streams) {
+			const tail = s.doc ? `, desc=${pyStr(s.doc)}` : "";
+			cb.line(`${s.id} = traits.List(traits.Str()${tail})`);
+		}
+	});
+	cb.blank();
+	cb.blank();
+	cb.line(`class ${names.cls}(BaseInterface):`);
+	cb.indent(() => {
+		emitDocstring(cb, [ctx.app?.doc?.title, ctx.app?.doc?.description].filter(Boolean).join("\n\n") || void 0);
+		cb.line(`input_spec = ${names.inputSpec}`);
+		cb.line(`output_spec = ${names.outputSpec}`);
+		cb.blank();
+		cb.line("def _run_interface(self, runtime):");
+		cb.indent(() => {
+			if (!spec.rootIsStruct) {
+				cb.line("raise NotImplementedError(");
+				cb.indent(() => cb.line(pyStr("styx nipype backend: tools with a non-struct root are not supported.")));
+				cb.line(")");
+				return;
+			}
+			cb.line("kwargs = {}");
+			for (const p of spec.params) if (p.mandatory) cb.line(`kwargs[${pyStr(p.hostName)}] = self.inputs.${p.hostName}`);
+			else {
+				cb.line(`if isdefined(self.inputs.${p.hostName}):`);
+				cb.indent(() => cb.line(`kwargs[${pyStr(p.hostName)}] = self.inputs.${p.hostName}`));
+			}
+			cb.line(`self._result: ${spec.delegation.outputsClass} = ${spec.delegation.wrapperFn}(**kwargs)`);
+			cb.line("return runtime");
+		});
+		cb.blank();
+		cb.line("def _list_outputs(self):");
+		cb.indent(() => {
+			if (!spec.rootIsStruct) {
+				cb.line("return self._outputs().get()");
+				return;
+			}
+			cb.line("result = self._result");
+			cb.line("outputs = self._outputs().get()");
+			for (const f of spec.outputs) if (f.shape.kind === "single" && f.shape.optional) {
+				cb.line(`if result.${f.id} is not None:`);
+				cb.indent(() => cb.line(`outputs[${pyStr(f.id)}] = result.${f.id}`));
+			} else cb.line(`outputs[${pyStr(f.id)}] = result.${f.id}`);
+			for (const s of spec.streams) cb.line(`outputs[${pyStr(s.id)}] = result.${s.id}`);
+			cb.line("return outputs");
+		});
+	});
+	return cb.toString();
+}
+
+//#endregion
+//#region src/backend/styxdefs-compat.ts
+/**
+* Runtime version floors baked into generated dependency metadata.
+*
+* styx2-generated code calls `mutable_copy` / `mutableCopy` (introduced in the
+* styxdefs 0.7.0 / styxdefs-js 0.2.0 release), so emitted packages genuinely
+* require that runtime floor. This is the single source of truth: bump here and
+* both the Python and TypeScript backends pick it up.
+*/
+const STYXDEFS_COMPAT = {
+	python: ">=0.7.0,<0.8.0",
+	npm: "^0.2.0"
+};
+/**
+* Extra Python runtime packages the root metapackage pulls in. `styxkit[all]`
+* provides the cross-backend runner-selection helpers (`use_docker`, `use_auto`,
+* ...) that the metapackage's `__init__` re-exports, and transitively installs
+* every container/graph runner backend. Left unpinned - styxkit's own styxdefs
+* floor constrains the stack.
+*/
+const PYTHON_RUNNER_DEPS = ["styxkit[all]"];
+
+//#endregion
+//#region src/backend/python/packaging.ts
+const REQUIRES_PYTHON = ">=3.10";
+const BUILD_SYSTEM = `[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"`;
+/** Escape a value for embedding in a TOML basic string. */
+function tomlStr(s) {
+	return s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/[\r\n]+/g, " ").replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "").trim();
+}
+/** Suite directory / importable package name; matches the CLI's `pkgDir` fallback. */
+function pkgDir(pkg) {
+	return pkg.name ?? "package";
+}
+/** Distribution (PyPI) name for a package: `<project>_<package>`, or just `<package>`. */
+function pyDistName(proj, pkg) {
+	const name = pkgDir(pkg);
+	return proj.name ? `${proj.name}_${name}` : name;
+}
+const SUMMARY_MAX_LEN = 512;
+/**
+* Clamp a description to a <=512-char one-line summary. Prefer cutting at the
+* last complete sentence that fits (clean, no dangling fragment); if there is no
+* sentence boundary early enough, cut at a word boundary and mark the elision.
+*/
+function clampSummary(s) {
+	if (s.length <= SUMMARY_MAX_LEN) return s;
+	const window = s.slice(0, SUMMARY_MAX_LEN);
+	const lastSentence = window.lastIndexOf(". ");
+	if (lastSentence >= 0) return s.slice(0, lastSentence + 1);
+	const ellipsis = "...";
+	const body = window.slice(0, SUMMARY_MAX_LEN - 3);
+	const lastSpace = body.lastIndexOf(" ");
+	return (lastSpace > 0 ? body.slice(0, lastSpace) : body).replace(/[.,;:\s]+$/, "") + ellipsis;
+}
+function description$1(doc, fallbackName) {
+	return clampSummary(doc?.description ?? `Styx generated wrappers for ${doc?.title ?? fallbackName ?? "tools"}.`);
+}
+function authorsField(doc) {
+	return `[${(doc?.authors?.length ? doc.authors : ["unknown"]).map((a) => `{ name = "${tomlStr(a)}" }`).join(", ")}]`;
+}
+function licenseField(proj) {
+	return `{ text = "${tomlStr(proj.license?.description ?? "unknown")}" }`;
+}
+/**
+* Per-suite `pyproject.toml`. The flat layout (`python/<pkg>/bet.py`) makes the
+* directory itself the importable package, so setuptools' `package-dir` maps the
+* import name (`<pkg>`) onto the distribution's root directory. The styxdefs
+* floor is the only runtime dependency.
+*
+* Precondition: `pkg.name` must be a valid Python identifier - the flat layout's
+* relative imports (`from .bet import *`) already require this, and the CLI uses
+* it verbatim as the directory name, so this stays consistent with that.
+*/
+function generateSubPyproject(proj, pkg) {
+	const importName = pkgDir(pkg);
+	const cb = new CodeBuilder("  ");
+	cb.line("[project]");
+	cb.line(`name = "${tomlStr(pyDistName(proj, pkg))}"`);
+	cb.line(`version = "${tomlStr(proj.version ?? "0.0.0")}"`);
+	cb.line(`description = "${tomlStr(description$1(pkg.doc, pkg.name))}"`);
+	cb.line(`readme = "README.md"`);
+	cb.line(`license = ${licenseField(proj)}`);
+	cb.line(`authors = ${authorsField(pkg.doc ?? proj.doc)}`);
+	cb.line(`requires-python = "${REQUIRES_PYTHON}"`);
+	cb.line("dependencies = [");
+	cb.line(`  "styxdefs${STYXDEFS_COMPAT.python}",`);
+	cb.line("]");
+	cb.blank();
+	cb.line("[tool.setuptools]");
+	cb.line(`packages = ["${importName}"]`);
+	cb.line(`package-dir = { "${importName}" = "." }`);
+	cb.blank();
+	cb.line("[tool.setuptools.package-data]");
+	cb.line(`"${importName}" = ["py.typed"]`);
+	cb.blank();
+	cb.line(BUILD_SYSTEM);
+	return cb.toString() + "\n";
+}
+/**
+* The metapackage's `__init__.py`. A thin re-export of styxkit so the runner
+* configuration helpers (`use_docker`, `use_local`, `set_global_runner`, ...)
+* are reachable as `<project>.<name>` - the v1 ergonomic that the v2 split into
+* per-suite distributions otherwise dropped. The logic lives in styxkit (pulled
+* in via `styxkit[all]`), so this stays a wildcard re-export and never re-emits
+* the runner-config code itself.
+*/
+function generateRootInitPy() {
+	return "# This file was auto generated by Styx.\n# Do not edit this file directly.\n\n# Re-export styxkit's runner-configuration helpers (use_docker, use_local,\n# use_auto, set_global_runner, get_global_runner, ...) so they are available\n# directly on this package, e.g. `import niwrap; niwrap.use_docker()`.\nfrom styxkit import *  # noqa: F401,F403\n";
+}
+/**
+* Root `pyproject.toml`: a metapackage depending on `styxkit[all]` (the runner
+* stack it re-exports) plus each per-suite distribution. `packages` lists only
+* the metapackage's own module so setuptools ships the styxkit re-export without
+* sweeping the sibling suite directories into this distribution.
+*/
+function generateRootPyproject(proj, distNames, moduleName) {
+	const cb = new CodeBuilder("  ");
+	cb.line("[project]");
+	cb.line(`name = "${tomlStr(proj.name ?? "project")}"`);
+	cb.line(`version = "${tomlStr(proj.version ?? "0.0.0")}"`);
+	cb.line(`description = "${tomlStr(description$1(proj.doc, proj.name))}"`);
+	cb.line(`readme = "README.md"`);
+	cb.line(`license = ${licenseField(proj)}`);
+	cb.line(`authors = ${authorsField(proj.doc)}`);
+	cb.line(`requires-python = "${REQUIRES_PYTHON}"`);
+	cb.line("dependencies = [");
+	for (const dep of PYTHON_RUNNER_DEPS) cb.line(`  "${dep}",`);
+	for (const dist of distNames) cb.line(`  "${tomlStr(dist)}",`);
+	cb.line("]");
+	cb.blank();
+	cb.line("[tool.setuptools]");
+	cb.line(`packages = ["${moduleName}"]`);
+	cb.blank();
+	cb.line("[tool.setuptools.package-data]");
+	cb.line(`"${moduleName}" = ["py.typed"]`);
+	cb.blank();
+	cb.line(BUILD_SYSTEM);
+	return cb.toString() + "\n";
+}
+/** Per-suite README crediting the upstream tool authors. */
+function generateSubReadme(proj, pkg) {
+	const projectTitle = proj.doc?.title ?? proj.name ?? "Styx";
+	const packageTitle = pkg.doc?.title ?? pkg.name ?? "package";
+	const url = pkg.doc?.urls?.[0];
+	const titleMd = url ? `[${packageTitle}](${url})` : packageTitle;
+	const credits = pkg.doc?.authors?.length ? pkg.doc.authors.join(", ") : pkg.doc?.urls?.join(", ") ?? "unknown";
+	return `# ${projectTitle} wrappers for ${titleMd}${pkg.doc?.description ? `\n\n${pkg.doc.description}` : ""}\n\n${packageTitle} is made by ${credits}.\n\nThis package contains wrappers only and has no affiliation with the original authors.\n`;
+}
+/** Root README listing the bundled per-suite distributions. */
+function generateRootReadme(proj, distNames) {
+	return `# ${proj.doc?.title ?? proj.name ?? "Styx"}\n${proj.doc?.description ? `\n${proj.doc.description}\n` : ""}\nAuto-generated Styx wrappers. This project bundles the following packages:\n\n${distNames.map((d) => `- ${d}`).join("\n")}\n`;
+}
+/** Local-install manifest: each suite directory first, then the root metapackage. */
+function generateRequirementsTxt(pkgDirs) {
+	return [...pkgDirs.map((d) => `./${d}`), "./"].join("\n") + "\n";
+}
+
+//#endregion
+//#region src/backend/sig-entries.ts
+/**
+* Build per-field signature entries for the kwarg wrapper and params factory.
+* Skips `@type` (the factory injects it as a constant). Required-no-default
+* entries are placed before defaulted ones so the resulting signature is
+* syntactically valid in both Python and TS.
+*
+* `registerLocal` is called once per field with the wire key; it must return
+* a scrubbed, unique host identifier (typically by combining a language-aware
+* scrub function with `Scope.add()`). The caller's scope should already have
+* the function's other locals (`params`, `runner`, ...) reserved so this
+* registration cannot collide with them.
+*/
+function buildSigEntries(rootType, fieldInfo, registerLocal, opts) {
+	const entries = [];
+	for (const [fieldName, fieldType] of Object.entries(rootType.fields)) {
+		if (fieldType.kind === "literal") continue;
+		const fi = fieldInfo.get(fieldName);
+		const isOptional = fieldType.kind === "optional";
+		const inner = isOptional ? fieldType.inner : fieldType;
+		let sigType = opts.renderType(inner);
+		if (isOptional) sigType += opts.nullableSuffix;
+		let sigDefault;
+		const hasExplicitDefault = fi?.defaultValue !== void 0;
+		if (hasExplicitDefault) sigDefault = opts.renderDefault(fi.defaultValue);
+		else if (isOptional) sigDefault = opts.nullableDefault;
+		entries.push({
+			name: registerLocal(fieldName),
+			wireKey: fieldName,
+			sigType,
+			sigDefault,
+			isOptional,
+			hasExplicitDefault,
+			doc: fi?.doc
+		});
+	}
+	const required = entries.filter((e) => e.sigDefault === void 0);
+	const defaulted = entries.filter((e) => e.sigDefault !== void 0);
+	return [...required, ...defaulted];
+}
+
+//#endregion
+//#region src/backend/validate-walk.ts
+/**
+* Enumerate a struct type's fields in declaration order, each paired with the
+* IR node its binding resolved from. `searchRoot` is the IR subtree known to
+* contain the struct (the root expr for the top-level struct, or a field /
+* union-arm node for nested ones).
+*/
+function structFields(ctx, structType, searchRoot) {
+	const nodeByName = /* @__PURE__ */ new Map();
+	if (searchRoot) {
+		const structNode = findStructNode(searchRoot, ctx, structType);
+		if (structNode) for (const child of structNode.attrs.nodes) {
+			const match = resolveFieldBinding(child, ctx, structType);
+			if (match) nodeByName.set(match.binding.name, match.binding.node);
+		}
+	}
+	const fieldInfo = collectFieldInfo(ctx, structType);
+	return Object.entries(structType.fields).map(([name, type]) => ({
+		name,
+		type,
+		node: nodeByName.get(name),
+		hasDefault: fieldInfo.get(name)?.defaultValue !== void 0
+	}));
+}
+/**
+* Depth-first search for the first node satisfying `pred`, descending through
+* the transparent structural wrappers the solver may bury a binding under
+* (sequence/optional/repeat/alternative).
+*/
+function findNode(node, pred) {
+	if (!node) return void 0;
+	if (pred(node)) return node;
+	switch (node.kind) {
+		case "sequence":
+			for (const child of node.attrs.nodes) {
+				const r = findNode(child, pred);
+				if (r) return r;
+			}
+			return;
+		case "optional": return findNode(node.attrs.node, pred);
+		case "repeat": return findNode(node.attrs.node, pred);
+		case "alternative":
+			for (const alt of node.attrs.alts) {
+				const r = findNode(alt, pred);
+				if (r) return r;
+			}
+			return;
+		default: return;
+	}
+}
+/** Locate the int/float node carrying a scalar field's numeric range. */
+function findRangeNode(node) {
+	return findNode(node, (n) => n.kind === "int" || n.kind === "float");
+}
+/** Locate the repeat node carrying a list field's length bounds and item. */
+function findRepeatNode(node) {
+	return findNode(node, (n) => n.kind === "repeat");
+}
+/** Locate the alternative node backing a union field, to map arms to variants. */
 function findAlternativeNode(node) {
 	return findNode(node, (n) => n.kind === "alternative");
 }
@@ -5119,7 +5356,7 @@ function computePublicNames$1(appId) {
 * (the `reg` registrations and the `sigScope` child), so passing the same scope
 * the emitter continues with keeps later local registrations consistent.
 */
-function buildEmitModel$1(ctx, scope = new Scope(PY_RESERVED)) {
+function buildEmitModel(ctx, scope = new Scope(PY_RESERVED)) {
 	const appId = ctx.app?.id;
 	const pkg = ctx.package?.name;
 	const publicNames = computePublicNames$1(appId);
@@ -5162,7 +5399,7 @@ function buildEmitModel$1(ctx, scope = new Scope(PY_RESERVED)) {
 function generatePython(ctx, packageScope) {
 	const cb = new CodeBuilder("    ");
 	const scope = packageScope ?? new Scope(PY_RESERVED);
-	const { names, rootType, rootIsStruct, namedTypes, typeDecls, rootTypeTag, paramsType, sigEntries } = buildEmitModel$1(ctx, scope);
+	const { names, rootType, rootIsStruct, namedTypes, typeDecls, rootTypeTag, paramsType, sigEntries } = buildEmitModel(ctx, scope);
 	cb.comment("This file was auto generated by Styx.", "# ");
 	cb.comment("Do not edit this file directly.", "# ");
 	cb.blank();
@@ -5309,6 +5546,7 @@ var PythonBackend = class {
 		const files = /* @__PURE__ */ new Map();
 		const distNames = [];
 		const pkgDirs = [];
+		const warnings = [];
 		for (const p of packages) {
 			const pkg = p.meta ?? {};
 			const dir = pkg.name ?? "package";
@@ -5317,13 +5555,21 @@ var PythonBackend = class {
 			files.set(`${dir}/pyproject.toml`, generateSubPyproject(proj, pkg));
 			files.set(`${dir}/README.md`, generateSubReadme(proj, pkg));
 		}
-		files.set("pyproject.toml", generateRootPyproject(proj, distNames));
+		let rootMod = pyScrubIdent(proj.name && proj.name.trim() ? proj.name : "project", PY_RESERVED);
+		if (pkgDirs.includes(rootMod)) {
+			const collided = rootMod;
+			while (pkgDirs.includes(rootMod)) rootMod += "_";
+			warnings.push({ message: `metapackage module "${collided}" collides with a suite directory; emitting as "${rootMod}" instead` });
+		}
+		files.set(`${rootMod}/__init__.py`, generateRootInitPy());
+		files.set(`${rootMod}/py.typed`, "");
+		files.set("pyproject.toml", generateRootPyproject(proj, distNames, rootMod));
 		files.set("README.md", generateRootReadme(proj, distNames));
 		files.set("requirements.txt", generateRequirementsTxt(pkgDirs));
 		return {
 			files,
 			errors: [],
-			warnings: []
+			warnings
 		};
 	}
 };
@@ -5469,7 +5715,7 @@ const pyDialect = {
 * @param opts - Import and package-root options.
 */
 function renderPythonCall(ctx, config, opts = {}) {
-	const model = buildEmitModel$1(ctx);
+	const model = buildEmitModel(ctx);
 	const pkg = ctx.package?.name;
 	const callee = pkg ? `${pkg}.${model.names.wrapper}` : model.names.wrapper;
 	const call = model.rootIsStruct && model.rootType.kind === "struct" ? renderKwargCall(callee, model.sigEntries, model.rootType, config) : `${callee}(${renderValue(config, model.rootType, "", pyDialect)})`;
@@ -5492,6 +5738,495 @@ function renderKwargCall(callee, sigEntries, rootType, config) {
 	return `${callee}(\n${lines.join("\n")}\n)`;
 }
 
+//#endregion
+//#region src/backend/typed-spec.ts
+/** Project a tool's solved tree into the flat typed spec for delegation backends. */
+function buildTypedSpec(ctx) {
+	const model = buildEmitModel(ctx);
+	const delegation = {
+		moduleName: appModuleName$1(ctx.app),
+		wrapperFn: model.names.wrapper,
+		outputsClass: model.names.outputs
+	};
+	const outputs = collectOutputFields(ctx, pyId);
+	const streams = streamFields(ctx, pyId);
+	if (!model.rootIsStruct || model.rootType.kind !== "struct") return {
+		rootIsStruct: false,
+		params: [],
+		outputs,
+		streams,
+		delegation
+	};
+	const rootType = model.rootType;
+	const fieldByName = new Map(structFields(ctx, rootType, ctx.expr).map((f) => [f.name, f]));
+	const fieldInfo = collectFieldInfo(ctx, rootType);
+	return {
+		rootIsStruct: true,
+		params: model.sigEntries.map((e) => {
+			const fe = fieldByName.get(e.wireKey);
+			const fi = fieldInfo.get(e.wireKey);
+			return describeParam(e, fe?.type, fe?.node, fi?.defaultValue, fi?.doc);
+		}),
+		outputs,
+		streams,
+		delegation
+	};
+}
+function describeParam(e, type, node, defaultValue, fallbackDoc) {
+	const optional = e.isOptional;
+	const hasDefault = e.hasExplicitDefault;
+	const base = {
+		hostName: e.name,
+		wireKey: e.wireKey,
+		optional,
+		hasDefault,
+		mandatory: !optional && !hasDefault,
+		default: defaultValue,
+		doc: e.doc ?? fallbackDoc
+	};
+	const inner = type && type.kind === "optional" ? type.inner : type;
+	const choices = inner ? literalChoices(inner, node) : void 0;
+	if (choices) return {
+		...base,
+		kind: "enum",
+		choices
+	};
+	switch (inner?.kind) {
+		case "scalar":
+			if (inner.scalar === "path") return {
+				...base,
+				kind: "path",
+				scalarKind: "path",
+				mediaTypes: pathMediaTypes(node)
+			};
+			if (inner.scalar === "int" || inner.scalar === "float") return {
+				...base,
+				kind: inner.scalar,
+				scalarKind: inner.scalar,
+				range: numericRange(node)
+			};
+			return {
+				...base,
+				kind: "str",
+				scalarKind: "str"
+			};
+		case "bool": return {
+			...base,
+			kind: "bool"
+		};
+		case "count": return {
+			...base,
+			kind: "count"
+		};
+		case "list": return {
+			...base,
+			kind: "list",
+			listBounds: listBounds(node),
+			itemType: describeItem(inner.item, node)
+		};
+		case "struct": return {
+			...base,
+			kind: "struct"
+		};
+		case "union": return {
+			...base,
+			kind: "union"
+		};
+		default: return {
+			...base,
+			kind: "str"
+		};
+	}
+}
+function describeItem(item, node) {
+	const inner = item.kind === "optional" ? item.inner : item;
+	const choices = literalChoices(inner, node);
+	if (choices) return {
+		kind: "enum",
+		choices
+	};
+	switch (inner.kind) {
+		case "scalar":
+			if (inner.scalar === "path") return {
+				kind: "path",
+				scalarKind: "path",
+				mediaTypes: pathMediaTypes(node)
+			};
+			return {
+				kind: inner.scalar,
+				scalarKind: inner.scalar
+			};
+		case "bool": return { kind: "bool" };
+		case "count": return { kind: "count" };
+		case "struct": return { kind: "struct" };
+		case "union": return { kind: "union" };
+		default: return { kind: "str" };
+	}
+}
+/** Allowed values when `inner` is a literal or a union of literals (else undefined). */
+function literalChoices(inner, node) {
+	if (inner.kind === "literal") return [inner.value];
+	if (inner.kind === "union" && inner.variants.length > 0 && inner.variants.every((v) => v.type.kind === "literal")) return inner.variants.map((v) => v.type.value);
+	const altNode = node ? findNode(node, (n) => n.kind === "alternative") : void 0;
+	if (altNode && altNode.kind === "alternative") {
+		const alts = altNode.attrs.alts;
+		if (alts.length > 0 && alts.every((a) => a.kind === "literal")) return alts.map((a) => a.attrs.str);
+	}
+}
+function numericRange(node) {
+	const r = findRangeNode(node);
+	if (!r) return void 0;
+	const { minValue, maxValue } = r.attrs;
+	if (minValue === void 0 && maxValue === void 0) return void 0;
+	return {
+		min: minValue,
+		max: maxValue
+	};
+}
+function listBounds(node) {
+	const r = findRepeatNode(node);
+	if (!r) return void 0;
+	const { countMin, countMax } = r.attrs;
+	if (countMin === void 0 && countMax === void 0) return void 0;
+	return {
+		min: countMin,
+		max: countMax
+	};
+}
+function pathMediaTypes(node) {
+	const p = node ? findNode(node, (n) => n.kind === "path") : void 0;
+	if (p && p.kind === "path") {
+		const mt = p.attrs.mediaTypes;
+		if (mt && mt.length > 0) return mt;
+	}
+}
+
+//#endregion
+//#region src/backend/nipype/nipype.ts
+/** Derive the per-tool nipype module/class names. */
+function nipypeNames(ctx) {
+	const mod = appModuleName$1(ctx.app);
+	const rawId = ctx.app?.id ?? "tool";
+	const cls = pascalCase(/^[0-9]/.test(rawId) ? "v_" + rawId : rawId);
+	return {
+		styxStem: `_${mod}`,
+		ifaceStem: mod,
+		cls,
+		inputSpec: `${cls}InputSpec`,
+		outputSpec: `${cls}OutputSpec`
+	};
+}
+/** Generate the nipype interface module source for one tool. */
+function generateNipype(ctx) {
+	return emitNipypeInterface(ctx, buildTypedSpec(ctx), nipypeNames(ctx));
+}
+/**
+* Emits nipype `Interface` definitions whose typed InputSpec/OutputSpec carry
+* rich constraints (numeric ranges, list bounds, enum choices, file types) and
+* which delegate execution to the styx Python wrapper (Option B): no command-line
+* arg-building or output-path resolution is re-implemented here.
+*
+* Per tool, two co-located files are emitted so the output is a self-contained,
+* importable Python package: `_<tool>.py` (the styx Python module) and
+* `<tool>.py` (the interface, importing the wrapper via a relative import).
+*/
+var NipypeBackend = class {
+	name = "nipype";
+	target = "nipype";
+	emitApp(ctx, _scope) {
+		const names = nipypeNames(ctx);
+		const spec = buildTypedSpec(ctx);
+		const warnings = [];
+		if (!spec.rootIsStruct) warnings.push({ message: `nipype: '${ctx.app?.id ?? "?"}' has a non-struct root; emitted interface has no typed inputs and raises on run.` });
+		const styxCode = generatePython(ctx);
+		const ifaceCode = emitNipypeInterface(ctx, spec, names);
+		return {
+			meta: ctx.app,
+			files: new Map([[`${names.styxStem}.py`, styxCode], [`${names.ifaceStem}.py`, ifaceCode]]),
+			errors: [],
+			warnings
+		};
+	}
+};
+
+//#endregion
+//#region src/backend/pydra/emit.ts
+/** A scalar enum's Python type: int when every choice is numeric, else str. */
+function enumScalar(choices) {
+	return (choices ?? []).every((c) => typeof c === "number") ? "int" : "str";
+}
+/** True when a parameter is a file path (a path scalar or a list of paths). */
+function isPathParam(p) {
+	return p.kind === "path" || p.kind === "list" && p.itemType?.kind === "path";
+}
+function itemTypeStr(item, imp) {
+	if (!item) {
+		imp.typing = true;
+		return "ty.Any";
+	}
+	switch (item.kind) {
+		case "path":
+			imp.file = true;
+			return "File";
+		case "int":
+		case "count": return "int";
+		case "float": return "float";
+		case "str": return "str";
+		case "bool": return "bool";
+		case "enum": return enumScalar(item.choices);
+		default:
+			imp.typing = true;
+			return "ty.Any";
+	}
+}
+/** Base (non-optional) Python type expression for a parameter. */
+function baseType(p, imp) {
+	switch (p.kind) {
+		case "path":
+			imp.file = true;
+			return "File";
+		case "int":
+		case "count": return "int";
+		case "float": return "float";
+		case "str": return "str";
+		case "bool": return "bool";
+		case "enum": return enumScalar(p.choices);
+		case "list": return `list[${itemTypeStr(p.itemType, imp)}]`;
+		case "struct":
+		case "union":
+			imp.typing = true;
+			return "ty.Any";
+	}
+}
+/** Full input type, wrapping in `ty.Optional[...]` for an omittable-no-default field. */
+function inputType(p, imp) {
+	const base = baseType(p, imp);
+	if (p.optional && !p.hasDefault) {
+		imp.typing = true;
+		return `ty.Optional[${base}]`;
+	}
+	return base;
+}
+/** An attrs validator enforcing numeric range / list-length bounds, or undefined. */
+function validatorExpr(p, imp) {
+	const checks = [];
+	if (p.range) {
+		if (p.range.min !== void 0) checks.push(`attrs.validators.ge(${renderPyLiteral(p.range.min)})`);
+		if (p.range.max !== void 0) checks.push(`attrs.validators.le(${renderPyLiteral(p.range.max)})`);
+	}
+	if (p.listBounds) {
+		if (p.listBounds.min !== void 0) checks.push(`attrs.validators.min_len(${p.listBounds.min})`);
+		if (p.listBounds.max !== void 0) checks.push(`attrs.validators.max_len(${p.listBounds.max})`);
+	}
+	if (checks.length === 0) return void 0;
+	imp.attrs = true;
+	return `_styx_optional(${checks.length === 1 ? checks[0] : `attrs.validators.and_(${checks.join(", ")})`})`;
+}
+/** Help text: doc + degrade / media-type notes. */
+function helpText(p) {
+	const parts = [];
+	if (p.doc) parts.push(p.doc);
+	if (p.kind === "struct" || p.kind === "union") parts.push("(nested configuration; pass a dict)");
+	if (p.mediaTypes && p.mediaTypes.length > 0) parts.push(`(media types: ${p.mediaTypes.join(", ")})`);
+	return parts.length > 0 ? parts.join(" ") : void 0;
+}
+/** Render a `python.arg(...)` field for one parameter. */
+function renderInputArg(p, imp) {
+	const args = [`type=${inputType(p, imp)}`];
+	if (p.mandatory) {} else if (p.optional && !p.hasDefault) args.push("default=None");
+	else args.push(`default=${renderPyLiteral(p.default)}`);
+	if (p.kind === "enum") args.push(`allowed_values=[${(p.choices ?? []).map((c) => renderPyLiteral(c)).join(", ")}]`);
+	const v = validatorExpr(p, imp);
+	if (v) args.push(`validator=${v}`);
+	const h = helpText(p);
+	if (h) args.push(`help=${pyStr(h)}`);
+	return `python.arg(${args.join(", ")})`;
+}
+/** Python type for an output field. `isRoot` is the synthetic output directory. */
+function outputType(f, isRoot, imp) {
+	if (f.shape.kind === "list") {
+		imp.file = true;
+		return "list[File]";
+	}
+	if (isRoot) {
+		imp.directory = true;
+		return "Directory";
+	}
+	imp.file = true;
+	if (f.shape.optional) {
+		imp.typing = true;
+		return "ty.Optional[File]";
+	}
+	return "File";
+}
+function renderOutputArg(f, isRoot, imp) {
+	const args = [`type=${outputType(f, isRoot, imp)}`];
+	if (f.doc) args.push(`help=${pyStr(f.doc)}`);
+	return `python.out(${args.join(", ")})`;
+}
+/**
+* Emit the pydra task module for one tool: a `@python.define` task whose typed
+* inputs/outputs carry rich constraints and whose body delegates execution to the
+* co-emitted styx Python wrapper (Option B). Targets the post-rewrite
+* `pydra.compose` API (pydra >= 1.0a, Python >= 3.11).
+*/
+function emitPydraTask(ctx, spec, names) {
+	const imp = {
+		typing: false,
+		attrs: false,
+		file: false,
+		directory: false
+	};
+	const inputEntries = spec.params.map((p) => ({
+		key: p.hostName,
+		expr: renderInputArg(p, imp)
+	}));
+	const outputEntries = spec.outputs.map((f, i) => ({
+		key: f.id,
+		expr: renderOutputArg(f, i === 0, imp)
+	}));
+	for (const s of spec.streams) outputEntries.push({
+		key: s.id,
+		expr: `python.out(type=list[str]${s.doc ? `, help=${pyStr(s.doc)}` : ""})`
+	});
+	const needsPath = spec.params.some(isPathParam);
+	const cb = new CodeBuilder("    ");
+	cb.comment("This file was auto generated by Styx.", "# ");
+	cb.comment("Do not edit this file directly.", "# ");
+	cb.comment("Targets the pydra.compose API (pydra >= 1.0a, Python >= 3.11).", "# ");
+	cb.blank();
+	if (needsPath) cb.line("import os");
+	if (imp.typing) cb.line("import typing as ty");
+	if (imp.attrs) cb.line("import attrs.validators");
+	cb.line("from pydra.compose import python");
+	const ff = [];
+	if (imp.directory) ff.push("Directory");
+	if (imp.file) ff.push("File");
+	if (ff.length > 0) cb.line(`from fileformats.generic import ${ff.join(", ")}`);
+	cb.blank();
+	cb.line(`from .${names.styxStem} import ${spec.delegation.wrapperFn}`);
+	cb.blank();
+	cb.blank();
+	if (imp.attrs) {
+		cb.line("def _styx_optional(validator):");
+		cb.indent(() => {
+			cb.line("\"\"\"Apply an attrs validator only to a set (non-NOTHING), non-None value.\"\"\"");
+			cb.line("def _check(instance, attribute, value):");
+			cb.indent(() => {
+				cb.line("if value is attrs.NOTHING or value is None:");
+				cb.indent(() => cb.line("return"));
+				cb.line("validator(instance, attribute, value)");
+			});
+			cb.line("return _check");
+		});
+		cb.blank();
+		cb.blank();
+	}
+	if (needsPath) {
+		cb.line("def _styx_path(value):");
+		cb.indent(() => {
+			cb.line("\"\"\"Convert fileformats / Path inputs into a styxdefs-accepted path.\"\"\"");
+			cb.line("if value is None:");
+			cb.indent(() => cb.line("return None"));
+			cb.line("if isinstance(value, (list, tuple)):");
+			cb.indent(() => cb.line("return [os.fspath(v) for v in value]"));
+			cb.line("return os.fspath(value)");
+		});
+		cb.blank();
+		cb.blank();
+	}
+	cb.line("@python.define(");
+	cb.indent(() => {
+		if (inputEntries.length === 0) cb.line("inputs={},");
+		else {
+			cb.line("inputs={");
+			cb.indent(() => {
+				for (const e of inputEntries) cb.line(`${pyStr(e.key)}: ${e.expr},`);
+			});
+			cb.line("},");
+		}
+		cb.line("outputs={");
+		cb.indent(() => {
+			for (const e of outputEntries) cb.line(`${pyStr(e.key)}: ${e.expr},`);
+		});
+		cb.line("},");
+	});
+	cb.line(")");
+	const paramList = spec.params.map((p) => p.hostName);
+	cb.line(`def ${names.cls}(${paramList.join(", ")}):`);
+	cb.indent(() => {
+		emitDocstring(cb, [ctx.app?.doc?.title, ctx.app?.doc?.description].filter(Boolean).join("\n\n") || void 0);
+		if (!spec.rootIsStruct) {
+			cb.line("raise NotImplementedError(");
+			cb.indent(() => cb.line(pyStr("styx pydra backend: tools with a non-struct root are not supported.")));
+			cb.line(")");
+			return;
+		}
+		if (spec.params.length === 0) cb.line(`result = ${spec.delegation.wrapperFn}()`);
+		else {
+			cb.line(`result = ${spec.delegation.wrapperFn}(`);
+			cb.indent(() => {
+				for (const p of spec.params) {
+					const expr = isPathParam(p) ? `_styx_path(${p.hostName})` : p.hostName;
+					cb.line(`${p.hostName}=${expr},`);
+				}
+			});
+			cb.line(")");
+		}
+		const returns = [...spec.outputs.map((f) => `result.${f.id}`), ...spec.streams.map((s) => `result.${s.id}`)];
+		if (returns.length === 1) cb.line(`return ${returns[0]}`);
+		else cb.line(`return ${returns.join(", ")}`);
+	});
+	return cb.toString();
+}
+
+//#endregion
+//#region src/backend/pydra/pydra.ts
+/** Derive the per-tool pydra module/class names. */
+function pydraNames(ctx) {
+	const mod = appModuleName$1(ctx.app);
+	const rawId = ctx.app?.id ?? "tool";
+	const safeId = /^[0-9]/.test(rawId) ? "v_" + rawId : rawId;
+	return {
+		styxStem: `_${mod}`,
+		ifaceStem: mod,
+		cls: pascalCase(safeId)
+	};
+}
+/** Generate the pydra task module source for one tool. */
+function generatePydra(ctx) {
+	return emitPydraTask(ctx, buildTypedSpec(ctx), pydraNames(ctx));
+}
+/**
+* Emits pydra tasks (`@python.define`, the post-rewrite pydra.compose API) whose
+* typed inputs/outputs carry rich constraints (numeric ranges and list bounds via
+* attrs validators, enum choices, file types, defaults) and which delegate
+* execution to the styx Python wrapper (Option B): no command-line arg-building
+* or output-path resolution is re-implemented here.
+*
+* Per tool, two co-located files are emitted so the output is a self-contained,
+* importable Python package: `_<tool>.py` (the styx Python module) and
+* `<tool>.py` (the task, importing the wrapper via a relative import).
+*/
+var PydraBackend = class {
+	name = "pydra";
+	target = "pydra";
+	emitApp(ctx, _scope) {
+		const names = pydraNames(ctx);
+		const spec = buildTypedSpec(ctx);
+		const warnings = [];
+		if (!spec.rootIsStruct) warnings.push({ message: `pydra: '${ctx.app?.id ?? "?"}' has a non-struct root; emitted task has no typed inputs and raises on run.` });
+		const styxCode = generatePython(ctx);
+		const taskCode = emitPydraTask(ctx, spec, names);
+		return {
+			meta: ctx.app,
+			files: new Map([[`${names.styxStem}.py`, styxCode], [`${names.ifaceStem}.py`, taskCode]]),
+			errors: [],
+			warnings
+		};
+	}
+};
+
 //#endregion
 //#region src/backend/schema/jsonschema.ts
 var SchemaBuilder = class {
@@ -5537,7 +6272,7 @@ var SchemaBuilder = class {
 			case "literal": return { const: type.value };
 			case "optional": return this.fromType(type.inner, node?.kind === "optional" ? node.attrs.node : void 0);
 			case "list": {
-				const repeat = node?.kind === "repeat" ? node : void 0;
+				const repeat = findRepeatNode(node);
 				const schema = {
 					type: "array",
 					items: this.fromType(type.item, repeat?.attrs.node)
@@ -5547,7 +6282,7 @@ var SchemaBuilder = class {
 				return schema;
 			}
 			case "struct": return this.structSchema(type, node);
-			case "union": return this.unionSchema(type);
+			case "union": return this.unionSchema(type, node);
 		}
 	}
 	findTerminal(node) {
@@ -5608,9 +6343,20 @@ var SchemaBuilder = class {
 		if (required.length > 0) schema.required = required;
 		return schema;
 	}
-	unionSchema(type) {
+	unionSchema(type, node) {
 		if (type.variants.every((v) => v.type.kind === "literal")) return { enum: type.variants.map((v) => v.type.kind === "literal" ? v.type.value : "") };
-		return { oneOf: type.variants.map((v) => this.fromType(v.type)) };
+		const altNode = findAlternativeNode(node);
+		return { oneOf: type.variants.map((v, i) => {
+			const schema = this.fromType(v.type, altNode?.attrs.alts[i]);
+			if (v.type.kind === "struct" && "@type" in v.type.fields && schema.properties && !("@type" in schema.properties)) {
+				schema.properties = {
+					"@type": this.fromType(v.type.fields["@type"]),
+					...schema.properties
+				};
+				schema.required = ["@type", ...schema.required ?? []];
+			}
+			return schema;
+		}) };
 	}
 };
 function generateSchema(ctx) {
@@ -6862,7 +7608,7 @@ function computePublicNames(appId) {
 * (the `reg` registrations and the `sigScope` child), so passing the same scope
 * the emitter continues with keeps later local registrations consistent.
 */
-function buildEmitModel(ctx, scope = new Scope(TS_RESERVED)) {
+function buildEmitModel$1(ctx, scope = new Scope(TS_RESERVED)) {
 	const appId = ctx.app?.id;
 	const pkg = ctx.package?.name ?? "unknown";
 	const publicNames = computePublicNames(appId);
@@ -6905,7 +7651,7 @@ function buildEmitModel(ctx, scope = new Scope(TS_RESERVED)) {
 function generateTypeScript(ctx, packageScope) {
 	const cb = new CodeBuilder("  ");
 	const scope = packageScope ?? new Scope(TS_RESERVED);
-	const { appId, pkg, names, rootType, rootIsStruct, namedTypes, typeDecls, rootTypeTag, paramsType, sigEntries } = buildEmitModel(ctx, scope);
+	const { appId, pkg, names, rootType, rootIsStruct, namedTypes, typeDecls, rootTypeTag, paramsType, sigEntries } = buildEmitModel$1(ctx, scope);
 	cb.comment("This file was auto generated by Styx.");
 	cb.comment("Do not edit this file directly.");
 	cb.blank();
@@ -7088,7 +7834,7 @@ const tsDialect = {
 * @param opts - Import and package-root options.
 */
 function renderTypeScriptCall(ctx, config, opts = {}) {
-	const model = buildEmitModel(ctx);
+	const model = buildEmitModel$1(ctx);
 	const pkg = ctx.package?.name;
 	const fnName = model.rootIsStruct ? model.names.execute : model.names.wrapper;
 	const call = `${pkg ? `${pkg}.${fnName}` : fnName}(${model.rootIsStruct && model.rootType.kind === "struct" ? renderStructLiteral(config, model.rootType, "", tsDialect, model.rootTypeTag) : renderValue(config, model.rootType, "", tsDialect)})`;
@@ -8250,5 +8996,5 @@ function compile(source, filenameOrOptions) {
 }
 
 //#endregion
-export { BoutiquesBackend, CodeBuilder, JsonSchemaBackend, PYTHON_RUNNER_DEPS, PassStatus, PythonBackend, STYXDEFS_COMPAT, Scope, TypeScriptBackend, alt, appEntrypoint, atomKey, buildSigEntries, camelCase, canonicalize, collectFieldInfo, collectNamedTypes, compactTokens, compile, compose, createContext, createPipeline, createRegistry, defaultNamingStrategy, defaultPipeline, detectFormat, effectiveOutputName, findDoc, findStructNode, fixpoint, flatten, float, format, formatSolveResult, generateBoutiques, generateOutputsSchema, generatePython, generateSchema, generateTypeScript, int, isGated, isIterated, isStructural, isTerminal, lit, nodeRef, opt, outputGate, pascalCase, path, planOutput, planScope, removeEmpty, renderPythonCall, renderStructLiteral, renderTypeScriptCall, renderValue, rep, repJoin, resolveFieldBinding, resolveOutputs, resolveTypeName, screamingSnakeCase, seq, seqJoin, simplify, snakeCase, solve, str, structKey, typeKey, unionKey };
+export { BoutiquesBackend, CodeBuilder, JsonSchemaBackend, NipypeBackend, PYTHON_RUNNER_DEPS, PassStatus, PydraBackend, PythonBackend, STYXDEFS_COMPAT, Scope, TypeScriptBackend, alt, appEntrypoint, atomKey, buildEmitModel, buildSigEntries, buildTypedSpec, camelCase, canonicalize, collectFieldInfo, collectNamedTypes, compactTokens, compile, compose, createContext, createPipeline, createRegistry, defaultNamingStrategy, defaultPipeline, detectFormat, effectiveOutputName, findDoc, findStructNode, fixpoint, flatten, float, format, formatSolveResult, generateBoutiques, generateNipype, generateOutputsSchema, generatePydra, generatePython, generateSchema, generateTypeScript, int, isGated, isIterated, isStructural, isTerminal, lit, nipypeNames, nodeRef, opt, outputGate, pascalCase, path, planOutput, planScope, pydraNames, removeEmpty, renderPythonCall, renderStructLiteral, renderTypeScriptCall, renderValue, rep, repJoin, resolveFieldBinding, resolveOutputs, resolveTypeName, screamingSnakeCase, seq, seqJoin, simplify, snakeCase, solve, str, structKey, typeKey, unionKey };
 //# sourceMappingURL=index.mjs.map