padrone 1.7.1 → 1.8.1

package/dist/index.mjs

@@ -1,7 +1,7 @@
-import { _ as resolveStdin, c as getCommandRuntime, d as repathCommandTree, f as resolveAllCommands, g as createTerminalReplSession, h as suggestSimilar, i as commandSymbol, l as lazyResolver, n as buildReplCompleter, o as findCommandByName, p as resolveCommand, u as mergeCommands, v as resolveStdinAlways, y as REPL_SIGINT } from "./commands-B_gufyR9.mjs";
-import { a as getJsonSchema, c as parsePositionalConfig, i as extractSchemaMetadata, l as preprocessArgs, n as coerceArgs, o as isArrayField, r as detectUnknownArgs, s as isAsyncStreamField, t as applyValues } from "./args-Cnq0nwSM.mjs";
+import { _ as resolveStdin, c as getCommandRuntime, d as repathCommandTree, f as resolveAllCommands, g as createTerminalReplSession, h as suggestSimilar, i as commandSymbol, l as lazyResolver, n as buildReplCompleter, o as findCommandByName, p as resolveCommand, u as mergeCommands, v as resolveStdinAlways, y as REPL_SIGINT } from "./commands-DLR0rFgq.mjs";
+import { a as getJsonSchema, c as parsePositionalConfig, i as extractSchemaMetadata, l as preprocessArgs, n as coerceArgs, o as isArrayField, r as detectUnknownArgs, s as isAsyncStreamField, t as applyValues } from "./args-DrCXxXeP.mjs";
 import { i as createStdinStream, r as concatBytes, t as asyncStream } from "./stream-DC4H8YTx.mjs";
-import { a as escapeHtml, i as getVersion, o as resolveOutputFormat, r as getRootCommand, s as colorThemes, t as generateHelp } from "./help-BtxLgrF_.mjs";
+import { a as escapeHtml, i as getVersion, o as resolveOutputFormat, r as getRootCommand, s as colorThemes, t as generateHelp } from "./help-B-ZMYyn-.mjs";
 import { a as SignalError, i as RoutingError, n as ConfigError, o as ValidationError, r as PadroneError, s as signalExitCode, t as ActionError } from "./errors-DA4KzK1M.mjs";
 //#region src/core/results.ts
 /**
@@ -239,7 +239,14 @@ function runInterceptorChain(phase, interceptors, ctx, core) {
 	for (let i = phaseInterceptors.length - 1; i >= 0; i--) {
 		const handler = phaseInterceptors[i][phase];
 		const prevNext = next;
-		next = (currentCtx) => handler(currentCtx, (overrides) => prevNext(overrides ? Object.assign({}, currentCtx, overrides) : currentCtx));
+		next = (currentCtx) => handler(currentCtx, (overrides) => {
+			if (!overrides) return prevNext(currentCtx);
+			if (overrides.context != null && typeof overrides.context === "object") overrides = {
+				...overrides,
+				context: Object.assign({}, currentCtx.context, overrides.context)
+			};
+			return prevNext(Object.assign({}, currentCtx, overrides));
+		});
 	}
 	return next(ctx);
 }
@@ -325,6 +332,70 @@ function wrapWithLifecycle(interceptors, command, input, pipeline, wrapErrorResu
 	if (result instanceof Promise) return result.then(handleSuccess, runError);
 	return handleSuccess(result);
 }
+/**
+* Wraps a command-level pipeline (validate + execute) with error → shutdown lifecycle hooks.
+* Unlike `wrapWithLifecycle`, this has no `start` phase and uses the resolved command context.
+* Only interceptors exclusive to the command chain (not in root) should be passed here.
+*/
+function wrapWithCommandLifecycle(interceptors, command, input, pipeline, wrapErrorResult, signal, context, runtime, program, caller, pipelineState) {
+	const hasError = interceptors.some((p) => p.error);
+	const hasShutdown = interceptors.some((p) => p.shutdown);
+	if (!hasError && !hasShutdown) return pipeline();
+	const runShutdown = (error, result) => {
+		if (!hasShutdown) return;
+		return runInterceptorChain("shutdown", interceptors, {
+			command,
+			input,
+			error,
+			result,
+			signal,
+			context,
+			runtime,
+			program,
+			caller,
+			...pipelineState
+		}, () => {});
+	};
+	const runError = (error) => {
+		if (!hasError) {
+			const s = runShutdown(error);
+			if (s instanceof Promise) return s.then(() => {
+				throw error;
+			});
+			throw error;
+		}
+		return thenMaybe(runInterceptorChain("error", interceptors, {
+			command,
+			input,
+			error,
+			signal,
+			context,
+			runtime,
+			program,
+			caller,
+			...pipelineState
+		}, () => ({ error })), (er) => {
+			if (er.error !== void 0) return thenMaybe(runShutdown(er.error), () => {
+				throw er.error;
+			});
+			const wrapped = wrapErrorResult ? wrapErrorResult(er.result) : er.result;
+			return thenMaybe(runShutdown(void 0, wrapped), () => wrapped);
+		});
+	};
+	const handleSuccess = (result) => {
+		const s = runShutdown(void 0, result);
+		if (s instanceof Promise) return s.then(() => result);
+		return result;
+	};
+	let result;
+	try {
+		result = pipeline();
+	} catch (e) {
+		return runError(e);
+	}
+	if (result instanceof Promise) return result.then(handleSuccess, runError);
+	return handleSuccess(result);
+}
 //#endregion
 //#region src/output/primitives.ts
 function stringifyCell(value) {
@@ -640,10 +711,7 @@ function createAutoOutputInterceptor(outputConfig) {
 			if (collected instanceof Promise) return collected.then((v) => ({ result: v }));
 			return { result: collected };
 		};
-		const executedOrPromise = next({ context: {
-			...ctx.context,
-			output: indicator
-		} });
+		const executedOrPromise = next({ context: { output: indicator } });
 		if (executedOrPromise instanceof Promise) return executedOrPromise.then(handleResult);
 		return handleResult(executedOrPromise);
 	} }));
@@ -934,9 +1002,11 @@ function parseCommand(input, rootCommand, findCommandByName) {
 		unmatchedTerms
 	};
 	const argsMeta = curCommand.meta?.fields;
-	const { flags, aliases } = curCommand.argsSchema ? extractSchemaMetadata(curCommand.argsSchema, argsMeta, curCommand.meta?.autoAlias) : {
+	const { flags, aliases, negatives, customNegation } = curCommand.argsSchema ? extractSchemaMetadata(curCommand.argsSchema, argsMeta, curCommand.meta?.autoAlias) : {
 		flags: {},
-		aliases: {}
+		aliases: {},
+		negatives: {},
+		customNegation: /* @__PURE__ */ new Set()
 	};
 	const arrayArguments = /* @__PURE__ */ new Set();
 	if (curCommand.argsSchema) try {
@@ -951,9 +1021,16 @@ function parseCommand(input, rootCommand, findCommandByName) {
 		let key;
 		if (arg.type === "alias" && arg.key.length === 1 && flags[arg.key[0]]) key = [flags[arg.key[0]]];
 		else if (arg.type === "named" && arg.key.length === 1 && aliases[arg.key[0]]) key = [aliases[arg.key[0]]];
-		else key = arg.key;
+		else if (arg.type === "named" && arg.key.length === 1 && negatives[arg.key[0]]) {
+			setNestedValue(rawArgs, [negatives[arg.key[0]]], false);
+			continue;
+		} else key = arg.key;
 		const rootKey = key[0];
 		if (arg.type === "named" && arg.negated) {
+			if (customNegation.has(rootKey)) {
+				setNestedValue(rawArgs, [`no-${key.join(".")}`], false);
+				continue;
+			}
 			setNestedValue(rawArgs, key, false);
 			continue;
 		}
@@ -990,12 +1067,21 @@ function buildCommandArgs(command, rawArgs, positionalArgs) {
 		flags: {},
 		aliases: {}
 	});
+	let issues;
 	const positionalConfig = command.meta?.positional ? parsePositionalConfig(command.meta.positional) : [];
 	if (positionalConfig.length > 0) {
 		let argIndex = 0;
 		for (let i = 0; i < positionalConfig.length; i++) {
 			const { name, variadic } = positionalConfig[i];
 			if (argIndex >= positionalArgs.length) break;
+			if (name in preprocessedArgs) {
+				issues ??= [];
+				issues.push({
+					path: [name],
+					message: `Ambiguous argument "${name}": provided both positionally and as a named option`
+				});
+				continue;
+			}
 			if (variadic) {
 				const nonVariadicAfter = positionalConfig.slice(i + 1).filter((p) => !p.variadic).length;
 				const variadicEnd = positionalArgs.length - nonVariadicAfter;
@@ -1011,7 +1097,10 @@ function buildCommandArgs(command, rawArgs, positionalArgs) {
 		}
 	}
 	if (command.argsSchema) preprocessedArgs = coerceArgs(preprocessedArgs, command.argsSchema);
-	return preprocessedArgs;
+	return {
+		args: preprocessedArgs,
+		issues
+	};
 }
 /**
 * Detects unknown options in args that aren't defined in the schema.
@@ -1024,8 +1113,8 @@ function checkUnknownArgs(command, preprocessedArgs) {
 		return unknowns;
 	}
 	const argsMeta = command.meta?.fields;
-	const { flags, aliases } = extractSchemaMetadata(command.argsSchema, argsMeta, command.meta?.autoAlias);
-	return detectUnknownArgs(preprocessedArgs, command.argsSchema, flags, aliases);
+	const { flags, aliases, negatives } = extractSchemaMetadata(command.argsSchema, argsMeta, command.meta?.autoAlias);
+	return detectUnknownArgs(preprocessedArgs, command.argsSchema, flags, aliases, negatives);
 }
 /**
 * Validates preprocessed arguments against the command's schema.
@@ -1071,7 +1160,12 @@ function formatIssueMessages(issues) {
 * External data sources (stdin, env, config) are not resolved here — use eval() for that.
 */
 function coreValidateForParse(command, rawArgs, positionalArgs) {
-	return thenMaybe(validateCommandArgs(command, buildCommandArgs(command, rawArgs, positionalArgs)), (v) => v);
+	const { args: preprocessedArgs, issues } = buildCommandArgs(command, rawArgs, positionalArgs);
+	if (issues) return {
+		args: void 0,
+		argsResult: { issues }
+	};
+	return thenMaybe(validateCommandArgs(command, preprocessedArgs), (v) => v);
 }
 //#endregion
 //#region src/extension/utils.ts
@@ -1429,7 +1523,11 @@ const interactiveInterceptor = defineInterceptor({
 	const interactivitySuppressed = runtime.interactive === "unsupported" || effectiveInteractive === false || stdinIsPiped && effectiveInteractive !== true;
 	const forceInteractive = !interactivitySuppressed && effectiveInteractive === true;
 	if (!(!interactivitySuppressed && runtime.prompt && hasInteractiveConfig(command.meta))) return next();
-	const preprocessedArgs = buildCommandArgs(command, ctx.rawArgs, ctx.positionalArgs);
+	const { args: preprocessedArgs, issues: positionalIssues } = buildCommandArgs(command, ctx.rawArgs, ctx.positionalArgs);
+	if (positionalIssues) return {
+		args: void 0,
+		argsResult: { issues: positionalIssues }
+	};
 	const unknowns = checkUnknownArgs(command, preprocessedArgs);
 	if (unknowns.length > 0) return {
 		args: void 0,
@@ -1966,6 +2064,7 @@ function execCommand(resolvedInput, ctx, evalOptions, errorMode = "soft", caller
 	const initialContext = evalOptions?.context;
 	const factoryCache = /* @__PURE__ */ new Map();
 	const rootInterceptors = resolveRegisteredInterceptors(rootCommand.interceptors ?? [], factoryCache);
+	const rootInterceptorSet = new Set(rootInterceptors);
 	const runPipeline = (signal, pipelineContext) => {
 		const parseCtx = {
 			input: resolvedInput,
@@ -1983,51 +2082,74 @@ function execCommand(resolvedInput, ctx, evalOptions, errorMode = "soft", caller
 			pipelineState.rawArgs = parsed.rawArgs;
 			pipelineState.positionalArgs = parsed.positionalArgs;
 			const commandInterceptors = resolveRegisteredInterceptors(collectInterceptorsFn(command), factoryCache);
+			const commandOnlyInterceptors = commandInterceptors.filter((i) => !rootInterceptorSet.has(i));
 			const context = resolveContext(command, pipelineContext);
-			const validateCtx = {
+			const routedOrPromise = runInterceptorChain("route", commandInterceptors, {
 				...parseCtx,
 				command,
 				rawArgs: parsed.rawArgs,
 				positionalArgs: parsed.positionalArgs,
-				context,
-				evalInteractive: evalOptions?.interactive
-			};
-			const coreValidate = (validateCtx) => {
-				const preprocessedArgs = buildCommandArgs(validateCtx.command, validateCtx.rawArgs, validateCtx.positionalArgs);
-				return thenMaybe(validateCommandArgs(validateCtx.command, preprocessedArgs), (v) => v);
-			};
-			const validatedOrPromise = runInterceptorChain("validate", commandInterceptors, validateCtx, coreValidate);
-			const continueAfterValidate = (v) => {
-				pipelineState.args = v.args;
-				if (v.argsResult?.issues) return handleValidationIssues(v.argsResult, command, errorMode);
-				const executeCtx = {
-					...validateCtx,
-					args: v.args
-				};
-				const coreExecute = (executeCtx) => {
-					const handler = command.action ?? noop;
-					const actionCtx = {
-						runtime: executeCtx.runtime,
-						command: executeCtx.command,
-						program: ctx.builder,
-						signal: executeCtx.signal,
-						context: executeCtx.context,
-						caller
+				context
+			}, () => {});
+			const continueAfterRoute = () => {
+				const runValidateAndExecute = () => {
+					const validateCtx = {
+						...parseCtx,
+						command,
+						rawArgs: parsed.rawArgs,
+						positionalArgs: parsed.positionalArgs,
+						context,
+						evalInteractive: evalOptions?.interactive
 					};
-					return { result: handler(executeCtx.args, actionCtx) };
+					const coreValidate = (validateCtx) => {
+						const { args: preprocessedArgs, issues } = buildCommandArgs(validateCtx.command, validateCtx.rawArgs, validateCtx.positionalArgs);
+						if (issues) return {
+							args: void 0,
+							argsResult: { issues }
+						};
+						return thenMaybe(validateCommandArgs(validateCtx.command, preprocessedArgs), (v) => v);
+					};
+					const validatedOrPromise = runInterceptorChain("validate", commandInterceptors, validateCtx, coreValidate);
+					const continueAfterValidate = (v) => {
+						pipelineState.args = v.args;
+						if (v.argsResult?.issues) return handleValidationIssues(v.argsResult, command, errorMode);
+						const executeCtx = {
+							...validateCtx,
+							args: v.args
+						};
+						const coreExecute = (executeCtx) => {
+							const handler = command.action ?? noop;
+							const actionCtx = {
+								runtime: executeCtx.runtime,
+								command: executeCtx.command,
+								program: ctx.builder,
+								signal: executeCtx.signal,
+								context: executeCtx.context,
+								caller
+							};
+							return { result: handler(executeCtx.args, actionCtx) };
+						};
+						return thenMaybe(runInterceptorChain("execute", commandInterceptors, executeCtx, coreExecute), (e) => {
+							const finalize = (result) => withDrain({
+								command,
+								args: v.args,
+								argsResult: v.argsResult,
+								result
+							});
+							if (e.result instanceof Promise) return e.result.then(finalize);
+							return finalize(e.result);
+						});
+					};
+					return thenMaybe(warnIfUnexpectedAsync(validatedOrPromise, command), continueAfterValidate);
 				};
-				return thenMaybe(runInterceptorChain("execute", commandInterceptors, executeCtx, coreExecute), (e) => {
-					const finalize = (result) => withDrain({
-						command,
-						args: v.args,
-						argsResult: v.argsResult,
-						result
-					});
-					if (e.result instanceof Promise) return e.result.then(finalize);
-					return finalize(e.result);
-				});
+				return wrapWithCommandLifecycle(commandOnlyInterceptors, command, resolvedInput, runValidateAndExecute, (result) => withDrain({
+					command,
+					args: void 0,
+					argsResult: void 0,
+					result
+				}), signal, context, runtime, ctx.builder, caller, pipelineState);
 			};
-			return thenMaybe(warnIfUnexpectedAsync(validatedOrPromise, command), continueAfterValidate);
+			return thenMaybe(routedOrPromise, continueAfterRoute);
 		};
 		return thenMaybe(parsedOrPromise, continueAfterParse);
 	};
@@ -2260,6 +2382,11 @@ function createProgramMethods(ctx, evalCommand) {
 		if (commandObj.path) parts.push(commandObj.path);
 		const positionalConfig = commandObj.meta?.positional ? parsePositionalConfig(commandObj.meta.positional) : [];
 		const positionalNames = new Set(positionalConfig.map((p) => p.name));
+		const negativeKeyword = {};
+		if (commandObj.argsSchema) {
+			const { negatives } = extractSchemaMetadata(commandObj.argsSchema, commandObj.meta?.fields, commandObj.meta?.autoAlias);
+			for (const [keyword, argName] of Object.entries(negatives)) if (!(argName in negativeKeyword)) negativeKeyword[argName] = keyword;
+		}
 		if (args && typeof args === "object") {
 			for (const { name, variadic } of positionalConfig) {
 				const value = args[name];
@@ -2278,6 +2405,7 @@ function createProgramMethods(ctx, evalCommand) {
 			const stringifyValue = (key, value) => {
 				if (value === void 0) return;
 				if (typeof value === "boolean") if (value) parts.push(`--${key}`);
+				else if (negativeKeyword[key]) parts.push(`--${negativeKeyword[key]}`);
 				else parts.push(`--no-${key}`);
 				else if (Array.isArray(value)) for (const v of value) {
 					const vStr = String(v);
@@ -2457,17 +2585,17 @@ function createProgramMethods(ctx, evalCommand) {
 	};
 	const completion = async (shell) => {
 		resolveAllCommands(rootCommand);
-		const { generateCompletionOutput } = await import("./completion-BEuflbDO.mjs");
+		const { generateCompletionOutput } = await import("./completion-UnBKfGuk.mjs");
 		return generateCompletionOutput(rootCommand, shell);
 	};
 	const mcp = async (prefs) => {
 		resolveAllCommands(rootCommand);
-		const { startMcpServer } = await import("./mcp-6-Jw4Bpq.mjs");
+		const { startMcpServer } = await import("./mcp-D6PdtjIs.mjs");
 		return startMcpServer(ctx.builder, rootCommand, evalCommand, prefs);
 	};
 	const serve = async (prefs) => {
 		resolveAllCommands(rootCommand);
-		const { startServeServer } = await import("./serve-YVTPzBCl.mjs");
+		const { startServeServer } = await import("./serve-PaCLsNoD.mjs");
 		return startServeServer(ctx.builder, rootCommand, evalCommand, prefs);
 	};
 	return {
@@ -2688,33 +2816,13 @@ function createPadroneBuilder(inputCommand) {
 	execCtx.builder = builder;
 	return builder;
 }
-/**
-* Identity helper that contextually types a command builder callback while preserving its full return type.
-* Use this when defining commands in separate files — the parent program retains exact type information
-* about the subcommand's args, result, and nested commands.
-*
-* @example
-* ```ts
-* // my-command.ts
-* export const myCommand = defineCommand((c) =>
-*   c.arguments(z.object({ name: z.string() }))
-*    .action((args) => console.log(args.name))
-* );
-*
-* // cli.ts
-* createPadrone('test').command('my-command', myCommand)
-* ```
-*
-* @example With context
-* ```ts
-* export const myCommand = defineCommand<{ db: Database }>((c) =>
-*   c.arguments(z.object({ id: z.string() }))
-*    .action((args, ctx) => ctx.context.db.find(args.id))
-* );
-* ```
-*/
 function defineCommand(fn) {
-	return fn;
+	if (fn) return fn;
+	const builder = {
+		requires: () => builder,
+		define: (f) => f
+	};
+	return builder;
 }
 //#endregion
 //#region src/extension/completion.ts
@@ -2736,7 +2844,7 @@ function padroneCompletion() {
 	}), { positional: ["shell"] }).async().action(async (args, ctx) => {
 		const rootCommand = getRootCommand(ctx.command);
 		resolveAllCommands(rootCommand);
-		const { detectShell, generateCompletionOutput, setupCompletions } = await import("./completion-BEuflbDO.mjs");
+		const { detectShell, generateCompletionOutput, setupCompletions } = await import("./completion-UnBKfGuk.mjs");
 		const shell = args.shell;
 		if (args.setup) {
 			const resolvedShell = shell ?? await detectShell();
@@ -3310,11 +3418,7 @@ function loggerInterceptor(rawConfig) {
 					prefix: rawConfig?.prefix ?? "",
 					timestamps: rawConfig?.timestamps ?? ctxCfg?.timestamps ?? false
 				};
-				const logger = createLogger(ctx.runtime, resolved.level, resolved, ctx.context?.tracing);
-				return next({ context: {
-					...ctx.context,
-					logger
-				} });
+				return next({ context: { logger: createLogger(ctx.runtime, resolved.level, resolved, ctx.context?.tracing) } });
 			}
 		};
 	});
@@ -3414,7 +3518,7 @@ function padroneMcp(defaults) {
 	}), { positional: ["transport"] }).async().action(async (args, ctx) => {
 		const rootCommand = getRootCommand(ctx.command);
 		resolveAllCommands(rootCommand);
-		const { startMcpServer } = await import("./mcp-6-Jw4Bpq.mjs");
+		const { startMcpServer } = await import("./mcp-D6PdtjIs.mjs");
 		const transport = args.transport === "stdio" || args.transport === "http" ? args.transport : void 0;
 		const port = args.port ? parseInt(args.port, 10) : void 0;
 		const prefs = {
@@ -3674,6 +3778,7 @@ function createTerminalProgress(message, options) {
 		barFrame++;
 		render();
 	}, tickInterval) : void 0;
+	if (timer && typeof timer === "object" && "unref" in timer) timer.unref();
 	render();
 	const clear = () => {
 		if (stopped) return;
@@ -3858,9 +3963,30 @@ function progressInterceptor(config) {
 					ctx.runtime.output = originalOutput;
 					ctx.runtime.error = originalError;
 				};
-				return next();
+				const onValidationFailure = (error) => {
+					if (indicator) {
+						cleanup(indicator, msgs.success, msgs.error, error, void 0, true);
+						teardown();
+					}
+				};
+				const checkResult = (result) => {
+					if (result.argsResult?.issues) onValidationFailure(/* @__PURE__ */ new Error("Validation failed"));
+					return result;
+				};
+				let result;
+				try {
+					result = next();
+				} catch (err) {
+					onValidationFailure(err);
+					throw err;
+				}
+				if (result instanceof Promise) return result.then(checkResult, (err) => {
+					onValidationFailure(err);
+					throw err;
+				});
+				return checkResult(result);
 			},
-			execute(ctx, next) {
+			execute(_ctx, next) {
 				if (indicator && msgs.validation) indicator.update(msgs.progress);
 				const effectiveIndicator = indicator ?? noopIndicator;
 				const onSuccess = (value) => {
@@ -3876,10 +4002,7 @@ function progressInterceptor(config) {
 				};
 				let result;
 				try {
-					result = next({ context: {
-						...ctx.context,
-						progress: effectiveIndicator
-					} });
+					result = next({ context: { progress: effectiveIndicator } });
 				} catch (err) {
 					onError(err);
 				}
@@ -3897,6 +4020,12 @@ function progressInterceptor(config) {
 				}, (err) => onError(err)) };
 				onSuccess(result.result);
 				return result;
+			},
+			shutdown(ctx) {
+				if (indicator) {
+					cleanup(indicator, msgs.success, msgs.error, ctx.error, ctx.result, !!ctx.error);
+					teardown();
+				}
 			}
 		};
 	}).provides();
@@ -3951,7 +4080,7 @@ function padroneServe(defaults) {
 	})).async().action(async (args, ctx) => {
 		const rootCommand = getRootCommand(ctx.command);
 		resolveAllCommands(rootCommand);
-		const { startServeServer } = await import("./serve-YVTPzBCl.mjs");
+		const { startServeServer } = await import("./serve-PaCLsNoD.mjs");
 		const port = args.port ? parseInt(args.port, 10) : void 0;
 		const prefs = {
 			...defaults,
@@ -4046,7 +4175,7 @@ function tracingInterceptor(config) {
 			},
 			execute(ctx, next) {
 				rootSpan = tracer.startSpan(`cli ${ctx.command.name}`);
-				const padroneTracer = {
+				return next({ context: { tracing: {
 					tracer,
 					rootSpan,
 					span(name, fn) {
@@ -4071,11 +4200,7 @@ function tracingInterceptor(config) {
 							throw err;
 						}
 					}
-				};
-				return next({ context: {
-					...ctx.context,
-					tracing: padroneTracer
-				} });
+				} } });
 			},
 			error(ctx, next) {
 				rootSpan?.recordException(ctx.error);