@styx-api/core 0.2.0 → 0.4.0

package/dist/index.mjs

@@ -8,20 +8,20 @@ function findDeepName$1(node) {
 		if (name) return name;
 	}
 }
-function isObject$2(x) {
+function isObject$3(x) {
 	return typeof x === "object" && x !== null && !Array.isArray(x);
 }
-function isString$2(x) {
+function isString$3(x) {
 	return typeof x === "string";
 }
-function isNumber$1(x) {
+function isNumber$2(x) {
 	return typeof x === "number";
 }
-function isArray$2(x) {
+function isArray$3(x) {
 	return Array.isArray(x);
 }
 function isArgparseMarker(x) {
-	return isObject$2(x) && isString$2(x.__argparse__);
+	return isObject$3(x) && isString$3(x.__argparse__);
 }
 function isSuppressed(x) {
 	return isArgparseMarker(x) && x.__argparse__ === "SUPPRESS";
@@ -55,7 +55,7 @@ var ArgdumpParser = class {
 			this.error(e instanceof SyntaxError ? e.message : "Invalid JSON");
 			return null;
 		}
-		if (!isObject$2(parsed)) {
+		if (!isObject$3(parsed)) {
 			this.error("JSON source is not an object");
 			return null;
 		}
@@ -63,11 +63,11 @@ var ArgdumpParser = class {
 	}
 	buildAppMeta(descriptor) {
 		const prog = descriptor.prog;
-		if (!isString$2(prog)) return void 0;
+		if (!isString$3(prog)) return void 0;
 		let id = prog || void 0;
 		if (!id) {
 			const desc = descriptor.description;
-			if (isString$2(desc)) {
+			if (isString$3(desc)) {
 				const match = desc.match(/^(\S+)/);
 				if (match) id = match[1].replace(/[:;,]+$/, "") || void 0;
 			}
@@ -77,8 +77,8 @@ var ArgdumpParser = class {
 		const epilog = descriptor.epilog;
 		let versionStr;
 		const actions = descriptor.actions;
-		if (isArray$2(actions)) {
-			for (const action of actions) if (isObject$2(action) && action.action_type === "version" && isString$2(action.version)) {
+		if (isArray$3(actions)) {
+			for (const action of actions) if (isObject$3(action) && action.action_type === "version" && isString$3(action.version)) {
 				versionStr = action.version.replace(/%%?\(prog\)s\s*/g, "").trim();
 				if (!versionStr) versionStr = void 0;
 				break;
@@ -87,9 +87,9 @@ var ArgdumpParser = class {
 		return {
 			id,
 			...versionStr && { version: versionStr },
-			...(isString$2(description) || isString$2(epilog)) && { doc: {
-				...isString$2(description) && { description },
-				...isString$2(epilog) && { comment: epilog }
+			...(isString$3(description) || isString$3(epilog)) && { doc: {
+				...isString$3(description) && { description },
+				...isString$3(epilog) && { comment: epilog }
 			} }
 		};
 	}
@@ -97,9 +97,9 @@ var ArgdumpParser = class {
 		const typeInfo = action.type_info;
 		const fileTypeInfo = action.file_type_info;
 		const choices = action.choices;
-		if (isArray$2(choices) && choices.length > 0) {
+		if (isArray$3(choices) && choices.length > 0) {
 			const alts = [];
-			for (const choice of choices) if (isString$2(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) }
 			});
@@ -110,13 +110,13 @@ var ArgdumpParser = class {
 				attrs: { alts }
 			};
 		}
-		if (isObject$2(fileTypeInfo)) return {
+		if (isObject$3(fileTypeInfo)) return {
 			kind: "path",
 			attrs: {}
 		};
-		if (isObject$2(typeInfo)) {
+		if (isObject$3(typeInfo)) {
 			const name = typeInfo.name;
-			if (!isString$2(name)) return this.inferFromSamples(action) ?? {
+			if (!isString$3(name)) return this.inferFromSamples(action) ?? {
 				kind: "str",
 				attrs: {}
 			};
@@ -165,7 +165,7 @@ var ArgdumpParser = class {
 		};
 	}
 	resolveByModule(mod) {
-		if (!isString$2(mod)) return null;
+		if (!isString$3(mod)) return null;
 		if (mod === "pathlib" || mod === "os.path" || mod.includes("path")) return {
 			kind: "path",
 			attrs: {}
@@ -180,7 +180,7 @@ var ArgdumpParser = class {
 	inferFromSamples(action) {
 		const samples = [];
 		const def = action.default;
-		if (isArray$2(def)) samples.push(...def);
+		if (isArray$3(def)) samples.push(...def);
 		else samples.push(def);
 		samples.push(action.const);
 		let sawNumber = false;
@@ -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",
@@ -249,10 +249,10 @@ var ArgdumpParser = class {
 		const dest = action.dest;
 		const help = action.help;
 		const defaultVal = action.default;
-		const name = this.preferredName(action) ?? (isString$2(dest) ? dest : void 0);
+		const name = this.preferredName(action) ?? (isString$3(dest) ? dest : void 0);
 		const hasName = name !== void 0;
-		const hasHelp = isString$2(help) && !isSuppressed(help);
-		const hasDefault = (isString$2(defaultVal) || isNumber$1(defaultVal) || typeof defaultVal === "boolean") && !isSuppressed(defaultVal);
+		const hasHelp = isString$3(help) && !isSuppressed(help);
+		const hasDefault = (isString$3(defaultVal) || isNumber$2(defaultVal) || typeof defaultVal === "boolean") && !isSuppressed(defaultVal);
 		if (!hasName && !hasHelp && !hasDefault) return void 0;
 		return {
 			...hasName && { name },
@@ -262,20 +262,20 @@ var ArgdumpParser = class {
 	}
 	getOptionFlag(action) {
 		const optionStrings = action.option_strings;
-		if (!isArray$2(optionStrings) || optionStrings.length === 0) return null;
-		for (const opt of optionStrings) if (isString$2(opt) && opt.startsWith("--")) return opt;
+		if (!isArray$3(optionStrings) || optionStrings.length === 0) return null;
+		for (const opt of optionStrings) if (isString$3(opt) && opt.startsWith("--")) return opt;
 		const first = optionStrings[0];
-		return isString$2(first) ? first : null;
+		return isString$3(first) ? first : null;
 	}
 	/** Prefer the first --long flag (without leading dashes) over dest. */
 	preferredName(action) {
 		const optionStrings = action.option_strings;
-		if (!isArray$2(optionStrings)) return void 0;
-		for (const opt of optionStrings) if (isString$2(opt) && opt.startsWith("--") && opt.length > 2) return opt.slice(2);
+		if (!isArray$3(optionStrings)) return void 0;
+		for (const opt of optionStrings) if (isString$3(opt) && opt.startsWith("--") && opt.length > 2) return opt.slice(2);
 	}
 	isPositional(action) {
 		const optionStrings = action.option_strings;
-		return !isArray$2(optionStrings) || optionStrings.length === 0;
+		return !isArray$3(optionStrings) || optionStrings.length === 0;
 	}
 	buildAction(action) {
 		const actionType = action.action_type ?? "store";
@@ -293,7 +293,7 @@ var ArgdumpParser = class {
 			case "help":
 			case "version": return null;
 			case "unknown":
-				this.warn(`Unknown action type for '${action.dest}'` + (isString$2(action.custom_action_class) ? ` (custom class: ${action.custom_action_class})` : "") + ", treating as store");
+				this.warn(`Unknown action type for '${action.dest}'` + (isString$3(action.custom_action_class) ? ` (custom class: ${action.custom_action_class})` : "") + ", treating as store");
 				return this.buildStore(action);
 			default:
 				this.warn(`Unrecognized action_type '${actionType}' for '${action.dest}', skipping`);
@@ -405,20 +405,20 @@ var ArgdumpParser = class {
 	}
 	buildBooleanOptional(action) {
 		const optionStrings = action.option_strings;
-		if (!isArray$2(optionStrings) || optionStrings.length === 0) {
+		if (!isArray$3(optionStrings) || optionStrings.length === 0) {
 			this.error(`boolean_optional action '${action.dest}' has no option strings`);
 			return null;
 		}
 		let posFlag = null;
 		let negFlag = null;
 		for (const opt of optionStrings) {
-			if (!isString$2(opt)) continue;
+			if (!isString$3(opt)) continue;
 			if (opt.startsWith("--no-")) negFlag = opt;
 			else if (opt.startsWith("--")) posFlag = opt;
 		}
 		if (!posFlag) {
-			posFlag = isString$2(optionStrings[0]) ? optionStrings[0] : null;
-			negFlag = isString$2(optionStrings[1]) ? optionStrings[1] : null;
+			posFlag = isString$3(optionStrings[0]) ? optionStrings[0] : null;
+			negFlag = isString$3(optionStrings[1]) ? optionStrings[1] : null;
 		}
 		if (!posFlag) {
 			this.error(`boolean_optional action '${action.dest}' has no valid option strings`);
@@ -545,14 +545,14 @@ var ArgdumpParser = class {
 	}
 	buildSubparsers(action) {
 		const subparsers = action.subparsers;
-		if (!isObject$2(subparsers)) {
+		if (!isObject$3(subparsers)) {
 			this.error(`parsers action '${action.dest}' has no subparsers`);
 			return null;
 		}
-		const aliases = isObject$2(action.subparsers_aliases) ? action.subparsers_aliases : {};
+		const aliases = isObject$3(action.subparsers_aliases) ? action.subparsers_aliases : {};
 		const alts = [];
 		for (const [name, parserInfo] of Object.entries(subparsers)) {
-			if (!isObject$2(parserInfo)) {
+			if (!isObject$3(parserInfo)) {
 				this.warn(`Skipping non-object subparser '${name}'`);
 				continue;
 			}
@@ -566,8 +566,8 @@ var ArgdumpParser = class {
 				}, ...subExpr.attrs.nodes] }
 			};
 			const subAliases = aliases[name];
-			const aliasDoc = isArray$2(subAliases) && subAliases.length > 0 ? ` (aliases: ${subAliases.filter(isString$2).join(", ")})` : "";
-			const description = isString$2(parserInfo.description) ? parserInfo.description : void 0;
+			const aliasDoc = isArray$3(subAliases) && subAliases.length > 0 ? ` (aliases: ${subAliases.filter(isString$3).join(", ")})` : "";
+			const description = isString$3(parserInfo.description) ? parserInfo.description : void 0;
 			const docStr = description ? description + aliasDoc : aliasDoc ? aliasDoc.slice(1) : void 0;
 			seq.meta = {
 				name,
@@ -600,11 +600,11 @@ var ArgdumpParser = class {
 	applyMutualExclusion(actionsByDest, groups, nodes, nodesByDest) {
 		const excluded = /* @__PURE__ */ new Set();
 		for (const group of groups) {
-			if (!isObject$2(group)) continue;
+			if (!isObject$3(group)) continue;
 			const groupActions = group.actions;
-			if (!isArray$2(groupActions)) continue;
+			if (!isArray$3(groupActions)) continue;
 			const memberDests = [];
-			for (const dest of groupActions) if (isString$2(dest) && nodesByDest.has(dest)) memberDests.push(dest);
+			for (const dest of groupActions) if (isString$3(dest) && nodesByDest.has(dest)) memberDests.push(dest);
 			if (memberDests.length < 2) continue;
 			const altMembers = [];
 			for (const dest of memberDests) {
@@ -634,7 +634,7 @@ var ArgdumpParser = class {
 				kind: "optional",
 				attrs: { node: alt }
 			};
-			const groupName = (isString$2(group.title) ? group.title : void 0) ?? (memberDests.length === 2 ? `${memberDests[0]}_or_${memberDests[1]}` : `${memberDests[0]}_choice`);
+			const groupName = (isString$3(group.title) ? group.title : void 0) ?? (memberDests.length === 2 ? `${memberDests[0]}_or_${memberDests[1]}` : `${memberDests[0]}_choice`);
 			groupNode.meta = {
 				...groupNode.meta,
 				name: groupName
@@ -651,7 +651,7 @@ var ArgdumpParser = class {
 	}
 	parseParserInfo(descriptor) {
 		const actions = descriptor.actions;
-		if (!isArray$2(actions)) return {
+		if (!isArray$3(actions)) return {
 			kind: "sequence",
 			attrs: { nodes: [] }
 		};
@@ -660,11 +660,11 @@ var ArgdumpParser = class {
 		const actionsByDest = /* @__PURE__ */ new Map();
 		const nodesByDest = /* @__PURE__ */ new Map();
 		for (const rawAction of actions) {
-			if (!isObject$2(rawAction)) continue;
+			if (!isObject$3(rawAction)) continue;
 			const node = this.buildAction(rawAction);
 			if (!node) continue;
 			const dest = rawAction.dest;
-			if (isString$2(dest)) {
+			if (isString$3(dest)) {
 				actionsByDest.set(dest, rawAction);
 				nodesByDest.set(dest, node);
 			}
@@ -673,7 +673,7 @@ var ArgdumpParser = class {
 		}
 		let allNodes = [...positionals, ...optionals];
 		const mutexGroups = descriptor.mutually_exclusive_groups;
-		if (isArray$2(mutexGroups) && mutexGroups.length > 0) allNodes = this.applyMutualExclusion(actionsByDest, mutexGroups, allNodes, nodesByDest);
+		if (isArray$3(mutexGroups) && mutexGroups.length > 0) allNodes = this.applyMutualExclusion(actionsByDest, mutexGroups, allNodes, nodesByDest);
 		return {
 			kind: "sequence",
 			attrs: { nodes: allNodes }
@@ -715,7 +715,7 @@ var ArgdumpParser = class {
 			};
 		}
 		const prog = descriptor.prog;
-		if (isString$2(prog) && prog) expr.attrs.nodes.unshift({
+		if (isString$3(prog) && prog) expr.attrs.nodes.unshift({
 			kind: "literal",
 			attrs: { str: prog }
 		});
@@ -847,16 +847,16 @@ function boutiquesSplitCommand(command) {
 
 //#endregion
 //#region src/frontend/boutiques/parser.ts
-function isObject$1(x) {
+function isObject$2(x) {
 	return typeof x === "object" && x !== null && !Array.isArray(x);
 }
-function isString$1(x) {
+function isString$2(x) {
 	return typeof x === "string";
 }
-function isNumber(x) {
+function isNumber$1(x) {
 	return typeof x === "number";
 }
-function isArray$1(x) {
+function isArray$2(x) {
 	return Array.isArray(x);
 }
 var InputTypePrimitive = /* @__PURE__ */ function(InputTypePrimitive) {
@@ -898,7 +898,7 @@ var BoutiquesParser = class {
 			this.error(e instanceof SyntaxError ? e.message : "Invalid JSON");
 			return null;
 		}
-		if (!isObject$1(parsed)) {
+		if (!isObject$2(parsed)) {
 			this.error("JSON source is not an object");
 			return null;
 		}
@@ -910,9 +910,9 @@ var BoutiquesParser = class {
 			this.error(`type is missing for input: '${btInput.id}'`);
 			return null;
 		}
-		if (isObject$1(btType)) return InputTypePrimitive.SubCommand;
-		if (isArray$1(btType)) return InputTypePrimitive.SubCommandUnion;
-		const typeName = isString$1(btType) ? btType : String(btType);
+		if (isObject$2(btType)) return InputTypePrimitive.SubCommand;
+		if (isArray$2(btType)) return InputTypePrimitive.SubCommandUnion;
+		const typeName = isString$2(btType) ? btType : String(btType);
 		switch (typeName) {
 			case "String": return InputTypePrimitive.String;
 			case "File": return InputTypePrimitive.File;
@@ -951,43 +951,43 @@ var BoutiquesParser = class {
 		const title = btInput.name;
 		const description = btInput.description;
 		const defaultValue = btInput["default-value"];
-		const hasDefault = isString$1(defaultValue) || isNumber(defaultValue) || typeof defaultValue === "boolean";
-		if (!isString$1(name) && !isString$1(title) && !isString$1(description) && !hasDefault) return;
+		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$1(name) && { name },
-			...(isString$1(title) || isString$1(description)) && { doc: {
-				...isString$1(title) && { title },
-				...isString$1(description) && { description }
+			...isString$2(name) && { name },
+			...(isString$2(title) || isString$2(description)) && { doc: {
+				...isString$2(title) && { title },
+				...isString$2(description) && { description }
 			} },
 			...hasDefault && { defaultValue }
 		};
 	}
 	buildStreamMeta(bt) {
 		const id = bt.id;
-		if (!isString$1(id)) return void 0;
+		if (!isString$2(id)) return void 0;
 		const name = bt.name;
 		const description = bt.description;
 		return {
 			name: id,
-			...(isString$1(name) || isString$1(description)) && { doc: {
-				...isString$1(name) && { title: name },
-				...isString$1(description) && { description }
+			...(isString$2(name) || isString$2(description)) && { doc: {
+				...isString$2(name) && { title: name },
+				...isString$2(description) && { description }
 			} }
 		};
 	}
 	buildOutput(out, lookup, idOptional) {
 		const id = out.id;
-		if (!isString$1(id)) {
+		if (!isString$2(id)) {
 			this.error("output-files entry missing id");
 			return null;
 		}
 		const template = out["path-template"];
-		if (!isString$1(template)) {
+		if (!isString$2(template)) {
 			this.error(`output-files entry '${id}' missing path-template`);
 			return null;
 		}
 		const stripRaw = out["path-template-stripped-extensions"];
-		const stripExtensions = isArray$1(stripRaw) && stripRaw.every(isString$1) && stripRaw.length > 0 ? stripRaw : void 0;
+		const stripExtensions = isArray$2(stripRaw) && stripRaw.every(isString$2) && stripRaw.length > 0 ? stripRaw : void 0;
 		const tokens = destructTemplate(template, lookup).map((part) => {
 			if (typeof part === "string") return {
 				kind: "literal",
@@ -1006,9 +1006,9 @@ var BoutiquesParser = class {
 			name: id,
 			tokens
 		};
-		if (isString$1(title) || isString$1(description)) output.doc = {
-			...isString$1(title) && { title },
-			...isString$1(description) && { description }
+		if (isString$2(title) || isString$2(description)) output.doc = {
+			...isString$2(title) && { title },
+			...isString$2(description) && { description }
 		};
 		return { output };
 	}
@@ -1019,18 +1019,18 @@ var BoutiquesParser = class {
 	*/
 	attachOutputs(rootSeq, bt) {
 		const outputFiles = bt["output-files"];
-		if (!isArray$1(outputFiles)) return;
+		if (!isArray$2(outputFiles)) return;
 		const lookup = {};
 		const idOptional = /* @__PURE__ */ new Set();
 		const inputs = bt["inputs"];
-		if (isArray$1(inputs)) {
-			for (const input of inputs) if (isObject$1(input) && isString$1(input["value-key"]) && isString$1(input.id)) {
+		if (isArray$2(inputs)) {
+			for (const input of inputs) if (isObject$2(input) && isString$2(input["value-key"]) && isString$2(input.id)) {
 				lookup[input["value-key"]] = nodeRef(input.id);
 				if (input.optional === true) idOptional.add(input.id);
 			}
 		}
 		for (const out of outputFiles) {
-			if (!isObject$1(out)) {
+			if (!isObject$2(out)) {
 				this.warn("Skipping non-object output-files entry");
 				continue;
 			}
@@ -1042,7 +1042,7 @@ var BoutiquesParser = class {
 	}
 	buildAppMeta(bt) {
 		const id = bt.id ?? bt.name;
-		if (!isString$1(id)) return void 0;
+		if (!isString$2(id)) return void 0;
 		const name = bt.name;
 		const description = bt.description;
 		const version = bt["tool-version"];
@@ -1052,30 +1052,30 @@ var BoutiquesParser = class {
 		const stdout = bt["stdout-output"];
 		const stderr = bt["stderr-output"];
 		const doc = {
-			...isString$1(name) && { title: name },
-			...isString$1(description) && { description },
-			...isString$1(author) && { authors: [author] },
-			...isString$1(url) && { urls: [url] }
+			...isString$2(name) && { title: name },
+			...isString$2(description) && { description },
+			...isString$2(author) && { authors: [author] },
+			...isString$2(url) && { urls: [url] }
 		};
 		return {
 			id,
-			...isString$1(version) && { version },
+			...isString$2(version) && { version },
 			...Object.keys(doc).length > 0 && { doc },
-			...isObject$1(container) && isString$1(container.image) && { container: {
+			...isObject$2(container) && isString$2(container.image) && { container: {
 				image: container.image,
-				...isString$1(container.type) && { type: container.type }
+				...isString$2(container.type) && { type: container.type }
 			} },
-			...isObject$1(stdout) && { stdout: this.buildStreamMeta(stdout) },
-			...isObject$1(stderr) && { stderr: this.buildStreamMeta(stderr) }
+			...isObject$2(stdout) && { stdout: this.buildStreamMeta(stdout) },
+			...isObject$2(stderr) && { stderr: this.buildStreamMeta(stderr) }
 		};
 	}
 	buildEnumAlternative(choices, meta) {
 		const alts = [];
-		for (const choice of choices) if (isString$1(choice)) alts.push({
+		for (const choice of choices) if (isString$2(choice)) alts.push({
 			kind: "literal",
 			attrs: { str: choice }
 		});
-		else if (isNumber(choice)) alts.push({
+		else if (isNumber$1(choice)) alts.push({
 			kind: "literal",
 			attrs: { str: String(choice) }
 		});
@@ -1092,7 +1092,7 @@ var BoutiquesParser = class {
 		const meta = this.buildNodeMeta(btInput);
 		if (inputType.isEnum) {
 			const choices = btInput["value-choices"];
-			if (!isArray$1(choices)) {
+			if (!isArray$2(choices)) {
 				this.error(`Invalid value-choices for '${btInput.id}'`);
 				return null;
 			}
@@ -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;
 			}
@@ -1146,7 +1146,7 @@ var BoutiquesParser = class {
 			}
 			case InputTypePrimitive.Flag: {
 				const flag = btInput["command-line-flag"];
-				if (!isString$1(flag)) {
+				if (!isString$2(flag)) {
 					this.error(`Flag input '${btInput.id}' missing command-line-flag`);
 					return null;
 				}
@@ -1164,7 +1164,7 @@ var BoutiquesParser = class {
 			}
 			case InputTypePrimitive.SubCommand: {
 				const nested = btInput.type;
-				if (!isObject$1(nested)) {
+				if (!isObject$2(nested)) {
 					this.error(`Invalid subcommand type for '${btInput.id}'`);
 					return null;
 				}
@@ -1174,14 +1174,14 @@ var BoutiquesParser = class {
 			}
 			case InputTypePrimitive.SubCommandUnion: {
 				const alts = btInput.type;
-				if (!isArray$1(alts)) {
+				if (!isArray$2(alts)) {
 					this.error(`Invalid subcommand union type for '${btInput.id}'`);
 					return null;
 				}
 				const parsedAlts = [];
 				const usedTags = /* @__PURE__ */ new Set();
 				for (const alt of alts) {
-					if (!isObject$1(alt)) {
+					if (!isObject$2(alt)) {
 						this.warn("Skipping non-object subcommand alternative");
 						continue;
 					}
@@ -1233,15 +1233,15 @@ var BoutiquesParser = class {
 			kind: "repeat",
 			attrs: {
 				node,
-				...isString$1(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"] }
+				...isString$2(btInput["list-separator"]) && { join: btInput["list-separator"] },
+				...isNumber$1(btInput["min-list-entries"]) && { countMin: btInput["min-list-entries"] },
+				...isNumber$1(btInput["max-list-entries"]) && { countMax: btInput["max-list-entries"] }
 			}
 		};
 	}
 	wrapWithFlag(node, btInput) {
 		const flag = btInput["command-line-flag"];
-		if (!isString$1(flag)) return node;
+		if (!isString$2(flag)) return node;
 		return {
 			kind: "sequence",
 			attrs: { nodes: [{
@@ -1288,11 +1288,11 @@ var BoutiquesParser = class {
 	parseDescriptor(bt) {
 		const inputs = bt["inputs"];
 		const inputsLookup = /* @__PURE__ */ new Map();
-		if (isArray$1(inputs)) {
-			for (const input of inputs) if (isObject$1(input) && isString$1(input["value-key"])) inputsLookup.set(input["value-key"], input);
+		if (isArray$2(inputs)) {
+			for (const input of inputs) if (isObject$2(input) && isString$2(input["value-key"])) inputsLookup.set(input["value-key"], input);
 		}
 		const commandLine = bt["command-line"];
-		const segments = isString$1(commandLine) ? this.parseCommandLineTemplate(commandLine, inputsLookup) : [];
+		const segments = isString$2(commandLine) ? this.parseCommandLineTemplate(commandLine, inputsLookup) : [];
 		const rootSeq = {
 			kind: "sequence",
 			attrs: { nodes: [] }
@@ -1305,7 +1305,7 @@ var BoutiquesParser = class {
 					join: ""
 				}
 			};
-			for (const elem of segment) if (isObject$1(elem)) {
+			for (const elem of segment) if (isObject$2(elem)) {
 				const inputType = this.getInputType(elem);
 				if (inputType === null) continue;
 				let node = this.buildTerminal(elem, inputType);
@@ -1477,6 +1477,419 @@ function camelCase(s) {
 	return pascal.charAt(0).toLowerCase() + pascal.slice(1);
 }
 
+//#endregion
+//#region src/frontend/mrtrix/parser.ts
+function isObject$1(x) {
+	return typeof x === "object" && x !== null && !Array.isArray(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);
+}
+/** Coerce a possibly-missing list field to an array. */
+function asArray$1(x) {
+	return isArray$1(x) ? x : [];
+}
+/** Input file types: each maps to a plain path terminal. */
+const INPUT_TYPES = new Set([
+	"file in",
+	"image in",
+	"directory in",
+	"tracks in"
+]);
+/** Output file types: each maps to a `str` (the user-supplied filename) + an `Output`. */
+const OUTPUT_TYPES = new Set([
+	"file out",
+	"image out",
+	"directory out",
+	"tracks out"
+]);
+/** A fresh empty root sequence for error returns (IR passes mutate in place,
+* so callers must not share a single instance). */
+function emptyExpr$1() {
+	return {
+		kind: "sequence",
+		attrs: { nodes: [] }
+	};
+}
+/**
+* Parser for MRtrix3 C++ command definitions (`mrtrix.json`), as dumped by the
+* `__print_usage_json__` hook (see niwrap `extraction/mrtrix/`).
+*
+* The format is flat: positional `arguments`, plus `option_groups[].options`
+* where each option is a single-dash switch (`-id`) carrying 0..N positional
+* `arguments`. There are no unions, conditionals, or nested options. We lower
+* it onto the same `Expr` shapes the Boutiques/Workbench parsers emit:
+*
+*   <command> <positionals...> [-option ...] ...
+*
+*   - argument (input type)  -> typed terminal
+*   - argument (`* out`)     -> str terminal + an Output entry referencing it
+*   - option, 0 args         -> opt(lit(-switch))                  (bool flag)
+*   - 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`, 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.
+*/
+var MrtrixParser = class {
+	name = "mrtrix";
+	extensions = ["json"];
+	errors = [];
+	warnings = [];
+	usedNames = /* @__PURE__ */ new Set();
+	reset() {
+		this.errors = [];
+		this.warnings = [];
+		this.usedNames = /* @__PURE__ */ new Set();
+	}
+	/** Reserve a unique sibling name, suffixing `_2`, `_3`, ... on collision. */
+	uniqueName(base) {
+		if (!this.usedNames.has(base)) {
+			this.usedNames.add(base);
+			return base;
+		}
+		let n = 2;
+		while (this.usedNames.has(`${base}_${n}`)) n++;
+		const name = `${base}_${n}`;
+		this.usedNames.add(name);
+		this.warn(`Duplicate id '${base}'; renamed a sibling binding to '${name}'`);
+		return name;
+	}
+	error(message, location) {
+		this.errors.push({
+			message,
+			location
+		});
+	}
+	warn(message, location) {
+		this.warnings.push({
+			message,
+			location
+		});
+	}
+	parseJSON(source) {
+		let parsed;
+		try {
+			parsed = JSON.parse(source);
+		} catch (e) {
+			this.error(e instanceof SyntaxError ? e.message : "Invalid JSON");
+			return null;
+		}
+		if (!isObject$1(parsed)) {
+			this.error("JSON source is not an object");
+			return null;
+		}
+		return parsed;
+	}
+	docFrom(description) {
+		return isString$1(description) && description.length > 0 ? { description } : void 0;
+	}
+	buildAppMeta(cmd) {
+		const name = cmd.name;
+		if (!isString$1(name) || name.length === 0) {
+			this.error("MRtrix descriptor missing required 'name' string");
+			return;
+		}
+		const synopsis = cmd.synopsis;
+		const paragraphs = asArray$1(cmd.description).filter(isString$1).join("\n\n");
+		const author = cmd.author;
+		const references = asArray$1(cmd.references).filter(isString$1);
+		const version = cmd.version;
+		const doc = {
+			...isString$1(synopsis) && synopsis.length > 0 && { title: synopsis },
+			...paragraphs.length > 0 && { description: paragraphs },
+			...isString$1(author) && author.length > 0 && { authors: [author] },
+			...references.length > 0 && { literature: references },
+			urls: [`https://mrtrix.readthedocs.io/en/latest/reference/commands/${name}.html`]
+		};
+		return {
+			id: name,
+			...isString$1(version) && version.length > 0 && { version },
+			doc
+		};
+	}
+	/**
+	* 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`.
+	*/
+	buildArgTerminal(arg, meta) {
+		const argType = arg.type;
+		if (!isString$1(argType)) {
+			this.error(`MRtrix argument '${String(arg.id)}' missing 'type'`);
+			return null;
+		}
+		const name = meta.name;
+		switch (argType) {
+			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 "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;
+				return { node };
+			}
+			case "float seq": {
+				const node = repJoin(",", float());
+				node.meta = meta;
+				return { node };
+			}
+			case "various": {
+				const stringArm = seq(str({ name: "obj" }));
+				stringArm.meta = {
+					name: "VariousString",
+					variantTag: "VariousString"
+				};
+				const fileArm = seq(path({ name: "obj" }));
+				fileArm.meta = {
+					name: "VariousFile",
+					variantTag: "VariousFile"
+				};
+				const node = alt(stringArm, fileArm);
+				node.meta = meta;
+				return { node };
+			}
+			default:
+				if (INPUT_TYPES.has(argType)) return { node: path(meta) };
+				if (OUTPUT_TYPES.has(argType)) return {
+					node: str(meta),
+					output: {
+						name,
+						...meta.doc && { doc: meta.doc },
+						tokens: [{
+							kind: "ref",
+							target: nodeRef(name)
+						}],
+						mediaTypes: [`mrtrix/${argType}`]
+					}
+				};
+				this.error(`Unknown MRtrix type '${argType}' for '${name}'`);
+				return null;
+		}
+	}
+	/**
+	* A positional argument: typed terminal, wrapped for cardinality. Output-type
+	* positionals push their `Output` onto the root's `outputs` collector.
+	*/
+	buildPositional(arg, rootOutputs) {
+		if (!isObject$1(arg)) {
+			this.warn("Skipping non-object argument");
+			return null;
+		}
+		const id = arg.id;
+		if (!isString$1(id)) {
+			this.error("MRtrix argument missing 'id'");
+			return null;
+		}
+		const meta = {
+			name: this.uniqueName(snakeCase(id)),
+			...this.docMeta(arg.description)
+		};
+		const built = this.buildArgTerminal(arg, meta);
+		if (!built) return null;
+		if (built.output) rootOutputs.push(built.output);
+		return this.applyCardinality(built.node, arg, built.output !== void 0);
+	}
+	/** Wrap a terminal for `allow_multiple` (repeat) and `optional` (optional). */
+	applyCardinality(node, arg, isOutput) {
+		let result = node;
+		if (arg.allow_multiple === true && !isOutput && result.kind !== "repeat") result = rep(result);
+		else if (arg.allow_multiple === true && isOutput) this.warn(`Output argument '${String(arg.id)}' is allow_multiple; treating as single`);
+		if (arg.optional === true) result = opt(result);
+		return result;
+	}
+	docMeta(description) {
+		const doc = this.docFrom(description);
+		return doc ? { doc } : {};
+	}
+	/**
+	* An option `-{id}` with 0..N arguments. Returns the node plus any outputs
+	* that must live on the ROOT (collapsing single-value options); sub-struct
+	* options carry their own outputs on the struct sequence's meta.
+	*/
+	buildOption(option) {
+		if (!isObject$1(option)) {
+			this.warn("Skipping non-object option");
+			return null;
+		}
+		const id = option.id;
+		if (!isString$1(id)) {
+			this.error("MRtrix option missing 'id'");
+			return null;
+		}
+		const flag = `-${id}`;
+		const name = this.uniqueName(snakeCase(id));
+		const optDoc = this.docFrom(option.description);
+		const args = asArray$1(option.arguments);
+		const required = option.optional === false;
+		if (args.length === 0) {
+			if (option.allow_multiple === true) return {
+				node: rep(lit(flag), {
+					name,
+					...optDoc && { doc: optDoc }
+				}),
+				rootOutputs: []
+			};
+			const meta = {
+				name,
+				...optDoc && { doc: optDoc },
+				defaultValue: false
+			};
+			return {
+				node: opt(lit(flag), meta),
+				rootOutputs: []
+			};
+		}
+		if (args.length === 1 && option.allow_multiple !== true) {
+			const arg = args[0];
+			if (!isObject$1(arg)) {
+				this.error(`MRtrix option '${id}' has a non-object argument`);
+				return null;
+			}
+			const meta = {
+				name,
+				...optDoc && { doc: optDoc }
+			};
+			const built = this.buildArgTerminal(arg, meta);
+			if (!built) return null;
+			const valueNode = this.applyCardinality(built.node, arg, built.output !== void 0);
+			const flagSeq = seq(lit(flag), valueNode);
+			return {
+				node: required ? flagSeq : opt(flagSeq),
+				rootOutputs: built.output ? [built.output] : []
+			};
+		}
+		const inner = [lit(flag)];
+		const structOutputs = [];
+		for (const rawArg of args) {
+			if (!isObject$1(rawArg)) {
+				this.warn(`Skipping non-object argument of option '${id}'`);
+				continue;
+			}
+			const argId = rawArg.id;
+			if (!isString$1(argId)) {
+				this.error(`MRtrix option '${id}' has an argument missing 'id'`);
+				continue;
+			}
+			const argDoc = this.docFrom(rawArg.description) ?? optDoc;
+			const meta = {
+				name: snakeCase(argId),
+				...argDoc && { doc: argDoc }
+			};
+			const built = this.buildArgTerminal(rawArg, meta);
+			if (!built) continue;
+			const valueNode = this.applyCardinality(built.node, rawArg, built.output !== void 0);
+			inner.push(valueNode);
+			if (built.output) structOutputs.push(built.output);
+		}
+		const structSeq = seq(...inner);
+		structSeq.meta = {
+			name,
+			...structOutputs.length > 0 && { outputs: structOutputs }
+		};
+		const wrapperMeta = optDoc ? { doc: optDoc } : void 0;
+		let node;
+		if (option.allow_multiple === true) node = rep(structSeq, wrapperMeta);
+		else if (required) {
+			if (optDoc) structSeq.meta = {
+				...structSeq.meta,
+				doc: optDoc
+			};
+			node = structSeq;
+		} else node = opt(structSeq, wrapperMeta);
+		return {
+			node,
+			rootOutputs: []
+		};
+	}
+	parse(source, _filename) {
+		this.reset();
+		const cmd = this.parseJSON(source);
+		if (!cmd) return {
+			expr: emptyExpr$1(),
+			errors: this.errors,
+			warnings: this.warnings
+		};
+		const meta = this.buildAppMeta(cmd);
+		if (!meta || !isString$1(cmd.name)) return {
+			expr: emptyExpr$1(),
+			errors: this.errors,
+			warnings: this.warnings
+		};
+		const nodes = [lit(cmd.name)];
+		const rootOutputs = [];
+		for (const arg of asArray$1(cmd.arguments)) {
+			const node = this.buildPositional(arg, rootOutputs);
+			if (node) nodes.push(node);
+		}
+		for (const group of asArray$1(cmd.option_groups)) {
+			if (!isObject$1(group)) continue;
+			for (const option of asArray$1(group.options)) {
+				const built = this.buildOption(option);
+				if (!built) continue;
+				nodes.push(built.node);
+				rootOutputs.push(...built.rootOutputs);
+			}
+		}
+		const rootSeq = seq(...nodes);
+		rootSeq.meta = {
+			name: meta.id,
+			...rootOutputs.length > 0 && { outputs: rootOutputs }
+		};
+		return {
+			meta,
+			expr: rootSeq,
+			errors: this.errors,
+			warnings: this.warnings
+		};
+	}
+};
+
 //#endregion
 //#region src/frontend/workbench/parser.ts
 function isObject(x) {
@@ -1808,6 +2221,7 @@ function detectFormat(source) {
 	const obj = parsed;
 	if (typeof obj.$schema === "string" && obj.$schema.includes("argdump")) return "argdump";
 	if (typeof obj.command === "string" && typeof obj.short_description === "string") return "workbench";
+	if (typeof obj.synopsis === "string" && Array.isArray(obj.option_groups) && Array.isArray(obj.arguments)) return "mrtrix";
 	if ("command-line" in obj || Array.isArray(obj.inputs) && "name" in obj) return "boutiques";
 	if (Array.isArray(obj.actions) && "prog" in obj) return "argdump";
 	return null;
@@ -7869,7 +8283,7 @@ function compile(source, filenameOrOptions) {
 		errors: [{ message: "Could not detect input format. Specify format explicitly." }],
 		warnings: []
 	};
-	return (format === "argdump" ? new ArgdumpParser() : format === "workbench" ? new WorkbenchParser() : new BoutiquesParser()).parse(source, options.filename);
+	return (format === "argdump" ? new ArgdumpParser() : format === "workbench" ? new WorkbenchParser() : format === "mrtrix" ? new MrtrixParser() : new BoutiquesParser()).parse(source, options.filename);
 }
 
 //#endregion