@tikoci/centrs 0.1.2 → 0.1.3

package/src/execute-fanout.ts

@@ -0,0 +1,438 @@
+/**
+ * Multi-target fan-out for `execute`.
+ *
+ * A target selection (`--group` / `--where` / `--all` / `--default` / multiple
+ * positionals before `--`) expands to N members and runs the SAME RouterOS
+ * command on each through the single-target execute tail (`resolveExecuteRequest`
+ * → `runResolvedExecute`), collecting per-target inner `ExecuteEnvelope`s into the
+ * locked `FanoutData` shape (`src/core/envelope.ts`).
+ *
+ * Boundaries (see `commands/execute/README.md`, `docs/CONSTITUTION.md`), shared
+ * with `api-fanout.ts` / `retrieve-fanout.ts`:
+ *   - The CDB is loaded ONCE (`expandCdbSelection`); a cdb member is resolved with
+ *     its pre-resolved record, so `resolveCdb`'s `__default__` synthetic fallback
+ *     never collides ad-hoc literals.
+ *   - A `--default` / `__default__` member is guarded from being dialed as the
+ *     literal hostname `"__default__"` — it fails that one target deterministically
+ *     with `target/unresolved`.
+ *   - A **write-shaped** command (add/set/remove) is confirmed ONCE up front
+ *     (`--yes`), never per target; without `--yes` the error names the blast radius
+ *     (how many routers). Write-ness is target-independent (`canonicalizeExecuteCommand`).
+ */
+
+import type {
+	CentrsErrorEnvelope,
+	CentrsSuccessEnvelope,
+	CommonSettingsMeta,
+	FanoutData,
+	FanoutSummary,
+} from "./core/envelope.ts";
+import {
+	buildFanoutEnvelope,
+	buildFanoutResolveFailure,
+	commonVia,
+	defaultFanoutSleep,
+	resolveFanoutConcurrency,
+	runFanout,
+	summarizeFanout,
+} from "./core/fanout.ts";
+import { CentrsError, serializeCentrsError } from "./errors.ts";
+import {
+	buildExecuteErrorEnvelopeFromResolved,
+	type ExecuteEnvelope,
+	type ExecuteOperationMeta,
+	type ExecuteRequest,
+	type ExecuteRequestSummary,
+	type ExecuteSuccessEnvelope,
+	promptForWriteConfirmation,
+	type ResolvedExecuteRequest,
+	resolveExecuteGlobalContext,
+	resolveExecuteRequest,
+	runResolvedExecute,
+} from "./execute.ts";
+import { plannedProtocols, type RouterOsProtocol } from "./protocols/index.ts";
+import {
+	type CdbSelectionExpansion,
+	type CdbSelectionMember,
+	type CdbSelectionResolveInput,
+	expandCdbSelection,
+	isDefaultRecordTarget,
+	loadEnvFileDefaults,
+	type TargetSelection,
+} from "./resolver/index.ts";
+import { toYaml } from "./retrieve.ts";
+
+/** Compact description of the selector that produced the fan-out. */
+export interface ExecuteSelectionSummary {
+	groups: readonly string[];
+	where: readonly string[];
+	all: boolean;
+	default: boolean;
+	positionals: readonly string[];
+}
+
+export interface ExecuteFanoutOperationMeta {
+	kind: "fanout";
+	concurrency: number;
+	summary: FanoutSummary;
+	request: ExecuteRequestSummary;
+	selection: ExecuteSelectionSummary;
+}
+
+export type ExecuteFanoutData = FanoutData<unknown, ExecuteOperationMeta>;
+export type ExecuteFanoutEnvelope = CentrsSuccessEnvelope<
+	ExecuteFanoutData,
+	ExecuteFanoutOperationMeta
+>;
+export type ExecuteFanoutErrorEnvelope =
+	CentrsErrorEnvelope<ExecuteFanoutOperationMeta>;
+
+/** Test/override seams; production callers pass nothing. */
+export interface ExecuteFanoutInternals {
+	expand?: (
+		selection: TargetSelection,
+		input: CdbSelectionResolveInput,
+		env: Record<string, string | undefined>,
+		config?: Record<string, string | undefined>,
+	) => Promise<CdbSelectionExpansion>;
+	execute?: (
+		resolved: ResolvedExecuteRequest,
+	) => Promise<ExecuteSuccessEnvelope>;
+	sleep?: (ms: number) => Promise<void>;
+}
+
+export interface ExecuteFanoutOptions {
+	concurrency?: number;
+	/** CLI: true (literal positionals allowed). MCP: false (CDB is the allowlist). */
+	allowAdhoc?: boolean;
+}
+
+function summarizeSelection(
+	selection: TargetSelection,
+): ExecuteSelectionSummary {
+	return {
+		groups: selection.groups,
+		where: selection.where.map((clause) => `${clause.key}=${clause.value}`),
+		all: selection.all,
+		default: selection.default,
+		positionals: selection.positionals,
+	};
+}
+
+/** Representative transport for the concurrency default (pinned > native member > global). */
+function fanoutVia(
+	request: ExecuteRequest,
+	env: Record<string, string | undefined>,
+	globalVia: RouterOsProtocol,
+	expansion: CdbSelectionExpansion,
+): RouterOsProtocol {
+	// Deliberately CLI/env only, not `config` — see the identical note in
+	// `retrieve-fanout.ts`'s `resolveFanoutConcurrencyProtocol`.
+	if (request.via !== undefined || env["CENTRS_VIA"] !== undefined) {
+		return globalVia;
+	}
+	const anyNative = expansion.targets.some(
+		(member) =>
+			member.kind === "cdb" &&
+			member.resolution.overrides.via?.value === "native-api",
+	);
+	return anyNative ? "native-api" : globalVia;
+}
+
+function memberTargetMeta(member: CdbSelectionMember): {
+	input?: string;
+	identity?: string;
+	recordIndex?: number;
+} {
+	if (member.kind === "cdb") {
+		return {
+			input: member.resolution.identity,
+			identity: member.resolution.identity,
+			recordIndex: member.recordIndex,
+		};
+	}
+	return { input: member.input };
+}
+
+/**
+ * Ad-hoc literal targets have no CDB record. `resolveExecuteRequest` may borrow the
+ * `__default__` record's index when filling fallback creds, so the inner envelope
+ * would carry that borrowed `recordIndex` — making distinct literals collide on one
+ * index. Drop it for literal members and stamp the caller's `input` so the target
+ * stays identifiable in renderers (mirrors `api-fanout.ts`).
+ */
+function relabelAdhocMember(
+	envelope: ExecuteEnvelope,
+	member: CdbSelectionMember,
+): ExecuteEnvelope {
+	if (member.kind !== "literal") {
+		return envelope;
+	}
+	const { recordIndex: _borrowed, ...target } = envelope.meta.target;
+	return {
+		...envelope,
+		meta: { ...envelope.meta, target: { ...target, input: member.input } },
+	};
+}
+
+/**
+ * Run an `execute` fan-out. Returns a success envelope when the orchestration
+ * completes (even if every target failed); throws only for pre-flight failures
+ * (invalid command shape, CDB decrypt, unconfirmed write) the caller renders as
+ * an outer error via {@link buildExecuteFanoutErrorEnvelope}.
+ */
+export async function executeFanout(
+	request: ExecuteRequest,
+	selection: TargetSelection,
+	env: Record<string, string | undefined> = Bun.env,
+	internals: ExecuteFanoutInternals = {},
+	options: ExecuteFanoutOptions = {},
+): Promise<ExecuteFanoutEnvelope> {
+	// Validate + canonicalize the command ONCE, before selection expansion: a bad
+	// command shape is an outer error regardless of how many targets resolve, and
+	// write-ness is target-independent.
+	const config = await loadEnvFileDefaults(env);
+	const global = resolveExecuteGlobalContext(request, env, config);
+	const selectionSummary = summarizeSelection(selection);
+
+	const expand = internals.expand ?? expandCdbSelection;
+	const expansion = await expand(
+		selection,
+		{
+			cdbFile: request.cdbFile,
+			cdbPassword: request.cdbPassword,
+			allowAdhoc: options.allowAdhoc ?? true,
+		},
+		env,
+		config,
+	);
+
+	const via = fanoutVia(request, env, global.via, expansion);
+	const concurrency = resolveFanoutConcurrency(options.concurrency, via);
+
+	if (expansion.empty) {
+		return executeFanoutEnvelope({
+			selection: selectionSummary,
+			concurrency,
+			summary: { total: 0, ok: 0, failed: 0 },
+			requestSummary: global.summary,
+			settings: global.settings,
+			via: null,
+			warnings: expansion.warnings,
+			targets: [],
+		});
+	}
+
+	// Write-shaped fan-out: confirm ONCE up front, naming the blast radius.
+	await assertFanoutWriteConfirmed(request, global.summary, expansion);
+
+	const execute = internals.execute ?? runResolvedExecute;
+	const sleep = internals.sleep ?? defaultFanoutSleep;
+
+	const targets = await runFanout<
+		CdbSelectionMember,
+		ResolvedExecuteRequest,
+		ExecuteEnvelope
+	>({
+		members: expansion.targets,
+		concurrency,
+		resolve: (member) => {
+			if (member.kind === "cdb") {
+				if (isDefaultRecordTarget(member.resolution.target)) {
+					throw new CentrsError({
+						code: "target/unresolved",
+						summary:
+							"The `__default__` record is a credential fallback, not a connectable router.",
+						remediation:
+							"Select real devices with `--group` / `--where` / `--all` or a positional; `--default` cannot be a RouterOS target.",
+						context: { target: member.resolution.target },
+					});
+				}
+				return resolveExecuteRequest(
+					{ ...request, targetInput: member.resolution.target },
+					env,
+					{ cdbResolution: member.resolution, config },
+				);
+			}
+			return resolveExecuteRequest(
+				{ ...request, targetInput: member.input },
+				env,
+				{ config },
+			);
+		},
+		onResolveError: (member, error) =>
+			buildFanoutResolveFailure<ExecuteOperationMeta>({
+				error,
+				target: memberTargetMeta(member),
+				warnings: member.kind === "cdb" ? [...member.resolution.warnings] : [],
+				summary: "Failed to resolve a fanout target.",
+			}),
+		execute: async (resolved, member) =>
+			relabelAdhocMember(await execute(resolved), member),
+		onExecuteError: (resolved, member, error) =>
+			relabelAdhocMember(
+				buildExecuteErrorEnvelopeFromResolved(resolved, error),
+				member,
+			),
+		sleep,
+	});
+
+	return executeFanoutEnvelope({
+		selection: selectionSummary,
+		concurrency,
+		summary: summarizeFanout(targets),
+		requestSummary: global.summary,
+		settings: global.settings,
+		via: commonVia(targets),
+		warnings: expansion.warnings,
+		targets,
+	});
+}
+
+async function assertFanoutWriteConfirmed(
+	request: ExecuteRequest,
+	summary: ExecuteRequestSummary,
+	expansion: CdbSelectionExpansion,
+): Promise<void> {
+	if (!summary.write || request.yes) {
+		return;
+	}
+	const count = expansion.targets.length;
+	const prompt = `Run write-shaped \`${summary.command}\` across ${count} router(s)? Type yes to continue: `;
+	if (request.stdinIsTty ?? process.stdin.isTTY) {
+		const confirmed = await (request.confirm ?? promptForWriteConfirmation)(
+			prompt,
+		);
+		if (confirmed) {
+			return;
+		}
+	}
+	throw new CentrsError({
+		code: "usage/confirmation-required",
+		summary: `A write-shaped \`${summary.command}\` would run across ${count} router(s) and needs explicit confirmation.`,
+		remediation:
+			"Pass `--yes` to fan the write out to every selected router, or answer `yes` at the TTY prompt after reviewing the blast radius.",
+		context: { command: summary.command, routers: count },
+	});
+}
+
+interface ExecuteFanoutEnvelopeInput {
+	selection: ExecuteSelectionSummary;
+	concurrency: number;
+	summary: FanoutSummary;
+	requestSummary: ExecuteRequestSummary;
+	settings: CommonSettingsMeta;
+	via: RouterOsProtocol | null;
+	warnings: CdbSelectionExpansion["warnings"];
+	targets: readonly ExecuteEnvelope[];
+}
+
+function executeFanoutEnvelope(
+	input: ExecuteFanoutEnvelopeInput,
+): ExecuteFanoutEnvelope {
+	return buildFanoutEnvelope<
+		unknown,
+		ExecuteOperationMeta,
+		ExecuteFanoutOperationMeta
+	>({
+		summary: input.summary,
+		targets: input.targets,
+		warnings: input.warnings,
+		settings: input.settings,
+		via: input.via,
+		operation: {
+			kind: "fanout",
+			concurrency: input.concurrency,
+			summary: input.summary,
+			request: input.requestSummary,
+			selection: input.selection,
+		},
+	});
+}
+
+/** Outer error envelope for a fan-out that failed before per-target results. */
+export function buildExecuteFanoutErrorEnvelope(
+	request: ExecuteRequest,
+	error: unknown,
+): ExecuteFanoutErrorEnvelope {
+	const centrsError =
+		error instanceof CentrsError
+			? error
+			: new CentrsError({
+					code: "internal/unhandled",
+					summary: "execute fan-out failed with an unexpected error.",
+					remediation:
+						"Re-run with `--format json` to capture the structured error details.",
+					cause: error,
+				});
+	const requestedVia = plannedProtocols.includes(
+		request.via as RouterOsProtocol,
+	)
+		? (request.via as RouterOsProtocol)
+		: null;
+	return {
+		ok: false,
+		error: serializeCentrsError(centrsError),
+		warnings: [],
+		tips: [],
+		meta: {
+			target: {},
+			via: requestedVia,
+			settings: {},
+		},
+	};
+}
+
+/**
+ * Render an execute fan-out envelope. `json`/`yaml` serialize the whole envelope;
+ * `text` renders a summary line plus one line per target in record-index order.
+ */
+export function renderExecuteFanoutEnvelope(
+	envelope: ExecuteFanoutEnvelope | ExecuteFanoutErrorEnvelope,
+	format: "json" | "yaml" | "text",
+	options: { verbose?: boolean } = {},
+): string {
+	if (format === "json") {
+		return JSON.stringify(envelope, null, 2);
+	}
+	if (format === "yaml") {
+		return toYaml(envelope);
+	}
+	if (!envelope.ok) {
+		const lines = [`[${envelope.error.code}] ${envelope.error.summary}`];
+		if (envelope.error.remediation) {
+			lines.push(`Fix: ${envelope.error.remediation}`);
+		}
+		return lines.join("\n");
+	}
+	const operation = envelope.meta.operation;
+	const { total, ok, failed } = envelope.data.summary;
+	const lines: string[] = [
+		`execute ${operation?.request.command ?? "?"}: ${ok}/${total} ok, ${failed} failed (concurrency ${operation?.concurrency ?? "?"})`,
+	];
+	for (const target of envelope.data.targets) {
+		const meta = target.meta;
+		const label =
+			meta.target.identity ??
+			meta.target.host ??
+			meta.target.input ??
+			"(unknown)";
+		const index = meta.target.recordIndex ?? "-";
+		if (target.ok) {
+			lines.push(
+				`  [${index}] ok    ${label} (${target.meta.operation?.objectCount ?? 0} object(s))`,
+			);
+		} else {
+			lines.push(
+				`  [${index}] FAIL  ${label} [${target.error.code}] ${target.error.summary}`,
+			);
+			if (options.verbose && target.error.remediation) {
+				lines.push(`        Fix: ${target.error.remediation}`);
+			}
+		}
+	}
+	for (const warning of envelope.warnings) {
+		lines.push(`warning [${warning.code}]: ${warning.message}`);
+	}
+	return lines.join("\n");
+}

package/src/execute.ts

@@ -35,6 +35,7 @@ import {
 	effectiveHostCandidate,
 	isIpTransport,
 	isMacAddress,
+	loadEnvFileDefaults,
 	parseDuration,
 	parseResolvePolicy,
 	type ResolvedAuth,
@@ -277,19 +278,29 @@ export async function runResolvedExecute(
 export async function resolveExecuteRequest(
 	request: ExecuteRequest,
 	env: Record<string, string | undefined>,
+	options: {
+		cdbResolution?: CdbResolution;
+		config?: Record<string, string | undefined>;
+	} = {},
 ): Promise<ResolvedExecuteRequest> {
 	validateExecuteRequestShape(request);
 	const canonical = canonicalizeExecuteCommand(request.command);
-	const cdbResolution = await resolveCdb(
-		{
-			targetInput: request.targetInput,
-			cdbFile: request.cdbFile,
-			cdbPassword: request.cdbPassword,
-		},
-		env,
-	);
-	const via = resolveExecuteProtocol(request, env, cdbResolution);
-	const format = resolveFormat(request, env);
+	const config = options.config ?? (await loadEnvFileDefaults(env));
+	// Fan-out passes the pre-resolved CDB record for a member (the CDB is loaded
+	// once in `expandCdbSelection`); single-target resolves it here.
+	const cdbResolution =
+		options.cdbResolution ??
+		(await resolveCdb(
+			{
+				targetInput: request.targetInput,
+				cdbFile: request.cdbFile,
+				cdbPassword: request.cdbPassword,
+			},
+			env,
+			config,
+		));
+	const via = resolveExecuteProtocol(request, env, cdbResolution, config);
+	const format = resolveFormat(request, env, config);
 	const validate = resolveBooleanSetting(
 		request.validate,
 		env,
@@ -297,18 +308,22 @@ export async function resolveExecuteRequest(
 		true,
 		"validate",
 		cdbResolution?.overrides.validate,
+		config,
 	);
 	const timeoutMs = resolveTimeoutSetting(
 		request.timeout,
 		env,
 		via.value,
 		cdbResolution?.overrides.timeoutMs,
+		config,
 	);
 	const maxResultsBytes = resolveOptionalIntegerSetting(
 		request.maxResultsBytes,
 		env,
 		"CENTRS_MAX_RESULTS",
 		"max-results",
+		undefined,
+		config,
 	);
 	const macResolution = isIpTransport(via.value)
 		? await resolveMacTarget({
@@ -316,7 +331,10 @@ export async function resolveExecuteRequest(
 				targetInput: request.targetInput,
 				cdbTarget: cdbResolution?.target,
 				env,
-				policy: parseResolvePolicy(request.resolve ?? env["CENTRS_RESOLVE"]),
+				config,
+				policy: parseResolvePolicy(
+					request.resolve ?? env["CENTRS_RESOLVE"] ?? config["CENTRS_RESOLVE"],
+				),
 				operation: "execute",
 			})
 		: undefined;
@@ -330,6 +348,7 @@ export async function resolveExecuteRequest(
 		env,
 		via.value,
 		cdbResolution,
+		config,
 	);
 	const auth = resolveAuth(
 		{
@@ -339,6 +358,7 @@ export async function resolveExecuteRequest(
 		},
 		env,
 		cdbResolution,
+		config,
 	);
 	const insecure = resolveBooleanSetting(
 		request.insecure,
@@ -347,6 +367,7 @@ export async function resolveExecuteRequest(
 		false,
 		"insecure",
 		cdbResolution?.overrides.insecure,
+		config,
 	);
 
 	return {
@@ -366,6 +387,79 @@ export async function resolveExecuteRequest(
 	};
 }
 
+export interface ExecuteGlobalContext {
+	via: RouterOsProtocol;
+	write: boolean;
+	summary: ExecuteRequestSummary;
+	settings: CommonSettingsMeta;
+}
+
+/**
+ * Resolve the target-independent settings (protocol, format, validate, timeout,
+ * max-results) for a fan-out's outer `meta.operation.request` summary and its
+ * transport-aware concurrency default. No CDB record is consulted; the global
+ * `--via` (default `native-api`) decides the summary and concurrency base. Also
+ * canonicalizes the command once so write-ness is known before any target runs.
+ */
+export function resolveExecuteGlobalContext(
+	request: ExecuteRequest,
+	env: Record<string, string | undefined>,
+	config: Record<string, string | undefined> = {},
+): ExecuteGlobalContext {
+	validateExecuteRequestShape(request);
+	const canonical = canonicalizeExecuteCommand(request.command);
+	const via = resolveExecuteProtocol(request, env, undefined, config);
+	const format = resolveFormat(request, env, config);
+	const validate = resolveBooleanSetting(
+		request.validate,
+		env,
+		"CENTRS_VALIDATE",
+		true,
+		"validate",
+		undefined,
+		config,
+	);
+	const timeoutMs = resolveTimeoutSetting(
+		request.timeout,
+		env,
+		via.value,
+		undefined,
+		config,
+	);
+	const maxResultsBytes = resolveOptionalIntegerSetting(
+		request.maxResultsBytes,
+		env,
+		"CENTRS_MAX_RESULTS",
+		"max-results",
+		undefined,
+		config,
+	);
+	return {
+		via: via.value,
+		write: isWriteShaped(canonical),
+		summary: {
+			command: request.command,
+			canonical,
+			write: isWriteShaped(canonical),
+			yes: request.yes ?? false,
+			validate: validate.value,
+			verbose: request.verbose ?? false,
+			timeoutMs: timeoutMs.value,
+			format: format.value,
+			maxResultsBytes: maxResultsBytes?.value,
+		},
+		settings: {
+			via: toCoreSource(via.source),
+			timeoutMs: toCoreSource(timeoutMs.source),
+			format: toCoreSource(format.source),
+			validate: toCoreSource(validate.source),
+			maxResultsBytes: maxResultsBytes
+				? toCoreSource(maxResultsBytes.source)
+				: undefined,
+		},
+	};
+}
+
 export function buildExecuteErrorEnvelope(
 	request: ExecuteRequest,
 	error: unknown,
@@ -756,16 +850,6 @@ async function runCommand(
 		return backend.execute({ path: "", command: "", script: resolved.command });
 	}
 	if (resolved.canonical.mode === "script") {
-		if (resolved.via.value === "native-api") {
-			throw new CentrsError({
-				code: "transport/unsupported-operation",
-				summary:
-					"The native API execute path requires a slash-prefixed RouterOS command.",
-				remediation:
-					"Use a path-shaped command such as `/system/identity/set name=x`, or pin `--via rest-api` for `/rest/execute` script mode.",
-				context: { via: resolved.via.value, command: resolved.command },
-			});
-		}
 		return backend.execute({ path: "", command: "", script: resolved.command });
 	}
 	return backend.execute({
@@ -821,8 +905,9 @@ function resolveExecuteProtocol(
 	request: ExecuteRequest,
 	env: Record<string, string | undefined>,
 	cdb?: CdbResolution,
+	config: Record<string, string | undefined> = {},
 ): ResolvedSetting<RouterOsProtocol> {
-	const defaultVia = isUnresolvedMacTarget(request, env, cdb)
+	const defaultVia = isUnresolvedMacTarget(request, env, cdb, config)
 		? "mac-telnet"
 		: "native-api";
 	const via = resolveStringSetting(
@@ -833,6 +918,7 @@ function resolveExecuteProtocol(
 		"via",
 		undefined,
 		cdb?.overrides.via,
+		config,
 	);
 	if (!via) {
 		throw new CentrsError({
@@ -877,8 +963,13 @@ function isUnresolvedMacTarget(
 	request: ExecuteRequest,
 	env: Record<string, string | undefined>,
 	cdb?: CdbResolution,
+	config: Record<string, string | undefined> = {},
 ): boolean {
-	if (request.via !== undefined || env["CENTRS_VIA"] !== undefined) {
+	if (
+		request.via !== undefined ||
+		env["CENTRS_VIA"] !== undefined ||
+		config["CENTRS_VIA"] !== undefined
+	) {
 		return false;
 	}
 	// Decide the default transport from the *effective* target (host >
@@ -890,6 +981,7 @@ function isUnresolvedMacTarget(
 		targetInput: request.targetInput,
 		cdbTarget: cdb?.target,
 		env,
+		config,
 	});
 	return candidate ? isMacAddress(candidate) : false;
 }
@@ -897,6 +989,7 @@ function isUnresolvedMacTarget(
 function resolveFormat(
 	request: ExecuteRequest,
 	env: Record<string, string | undefined>,
+	config: Record<string, string | undefined> = {},
 ): ResolvedSetting<ExecuteOutputFormat> {
 	return resolveStringSetting(
 		request.format,
@@ -905,6 +998,8 @@ function resolveFormat(
 		"text",
 		"format",
 		parseOutputFormat,
+		undefined,
+		config,
 	) as ResolvedSetting<ExecuteOutputFormat>;
 }
 
@@ -930,6 +1025,7 @@ function resolveTimeoutSetting(
 	env: Record<string, string | undefined>,
 	via: RouterOsProtocol,
 	commentKv?: ResolvedSetting<number>,
+	config: Record<string, string | undefined> = {},
 ): ResolvedSetting<number> {
 	const resolved = resolveStringSetting(
 		timeout === undefined ? undefined : String(timeout),
@@ -950,6 +1046,7 @@ function resolveTimeoutSetting(
 			return parsed;
 		},
 		commentKv,
+		config,
 	);
 	if (!resolved) {
 		throw new Error("timeout resolution produced no value");