@tikoci/centrs 0.1.3 → 0.1.6

package/src/api.ts

@@ -21,21 +21,26 @@ import type {
 	CommonSettingsMeta,
 	SettingSource as CoreSettingSource,
 	EnvelopeValidationMeta,
+	EnvelopeValidationStage,
 	Tip,
+	ValidationTrace,
 	Warning,
 } from "./core/envelope.ts";
 import { buildTip } from "./core/envelope.ts";
 import {
-	extractCompletionNames,
-	inspectChildren,
+	inspectArgumentNames,
 	inspectChildrenOrEmpty,
-	inspectCompletions,
-	isArgumentNode,
 	isCommandNode,
 	pathTokens,
 } from "./core/inspect.ts";
+import { toYaml } from "./core/yaml.ts";
 import { CentrsError, serializeCentrsError } from "./errors.ts";
 import { promptForWriteConfirmation } from "./execute.ts";
+import {
+	assertOfflineSyntax,
+	isOfflineGateRejection,
+	OFFLINE_GATE_SOURCE,
+} from "./offline-gate.ts";
 import {
 	type ApiVerb,
 	createProtocolAdapter,
@@ -45,11 +50,13 @@ import {
 	type RouterOsProtocol,
 } from "./protocols/index.ts";
 import {
+	assertNoQuickchrOverrideConflict,
 	type CdbResolution,
 	isIpTransport,
 	loadEnvFileDefaults,
 	parseDuration,
 	parseResolvePolicy,
+	quickchrConnection,
 	type ResolvedAuth,
 	type ResolvedSetting,
 	type ResolvedTarget,
@@ -57,11 +64,11 @@ import {
 	resolveBooleanSetting,
 	resolveCdb,
 	resolveMacTarget,
+	resolveQuickchrTarget,
 	resolveStringSetting,
 	resolveTarget,
 	toCoreSource,
 } from "./resolver/index.ts";
-import { toYaml } from "./retrieve.ts";
 
 export const apiOutputFormats = ["json", "yaml", "text"] as const;
 export type ApiOutputFormat = (typeof apiOutputFormats)[number];
@@ -72,6 +79,12 @@ export type ApiMethod = (typeof apiMethods)[number];
 
 export interface ApiRequest {
 	targetInput?: string;
+	/**
+	 * quickchr machine name (`--quickchr <name>`): resolve host/port/auth from
+	 * the live VM descriptor instead of CDB/env (`docs/CONSTITUTION.md` →
+	 * Resolution providers). Conflicts with host/port/username/password.
+	 */
+	quickchr?: string;
 	/** REST-style endpoint path, leniently normalized (`ip/address`, `/rest/ip/address`, `"ip address"`, `ip/address/*1`, `ip/address/listen`). */
 	endpoint: string;
 	/** HTTP method (`-X`), default `GET`, case-insensitive. */
@@ -88,7 +101,11 @@ export interface ApiRequest {
 	rawQuery?: readonly string[];
 	/** `--proplist` / `--attribute` property projection. */
 	proplist?: readonly string[];
-	/** `--raw`: bare RouterOS body passthrough; implies `--validate=false`. */
+	/**
+	 * `--raw`: bare RouterOS body passthrough. DEFAULTS `--validate` to false; an
+	 * explicit `validate` still wins, and its failures render through the `--raw`
+	 * error contract (#154).
+	 */
 	raw?: boolean;
 	/** `--listen`: native-api-only open-ended follow (later phase; rejected here). */
 	listen?: boolean;
@@ -115,6 +132,23 @@ export interface ApiRequest {
 	confirm?: (prompt: string) => Promise<boolean>;
 }
 
+/**
+ * The `--raw` / `--validate` precedence for a summary built BEFORE (or instead
+ * of) full resolution — a usage error, or a fan-out member that never reached
+ * `resolveApiRequest`.
+ *
+ * Ambient sources are deliberately out of reach here: this runs where the CDB
+ * and config tiers have not been loaded, so it reports the two layers it CAN
+ * see. That is why it is a shared helper rather than an inlined expression —
+ * both call sites used to spell `request.raw ? false : …`, which contradicted
+ * the resolved request by reporting `validate: false` for an explicit
+ * `--raw --validate=true` (#154).
+ */
+function summarizedValidate(request: ApiRequest): boolean {
+	if (request.validate !== undefined) return request.validate;
+	return !(request.raw ?? false);
+}
+
 export interface NormalizedApiEndpoint {
 	/** Canonical slash path with the leading `/rest` and any trailing id/`listen` removed. */
 	path: string;
@@ -238,19 +272,25 @@ export async function apiEnvelope(
 	env: Record<string, string | undefined> = Bun.env,
 ): Promise<ApiEnvelope> {
 	let resolved: ResolvedApiRequest | undefined;
+	// The gate finishes inside `runResolvedApi`, but the error envelope is built
+	// out here after the throw has unwound past it. Without the trace, a
+	// `transport/*` or `routeros/*` fault on the request — both stages already
+	// settled — reported `/console/inspect` as the validator that failed.
+	const trace: ValidationTrace = {};
 	try {
 		resolved = await resolveApiRequest(request, env);
 		await assertApiWriteConfirmed(request, resolved);
-		return await runResolvedApi(resolved);
+		return await runResolvedApi(resolved, trace);
 	} catch (error) {
 		return resolved
-			? buildApiErrorEnvelopeFromResolved(resolved, error)
+			? buildApiErrorEnvelopeFromResolved(resolved, error, trace)
 			: buildApiErrorEnvelope(request, error, env);
 	}
 }
 
 export async function runResolvedApi(
 	resolved: ResolvedApiRequest,
+	trace: ValidationTrace = {},
 ): Promise<ApiSuccessEnvelope> {
 	assertListenCapability(resolved);
 	const backend = createProtocolAdapter({
@@ -270,18 +310,15 @@ export async function runResolvedApi(
 	let tips: Tip[] = [];
 	try {
 		if (resolved.validate.value) {
-			const result = await validateApiRequest(resolved, backend);
+			const result = await validateApiRequest(resolved, backend, trace);
 			validation = result.validation;
 			tips = result.tips;
 		} else {
-			validation = {
-				enabled: false,
-				source: "disabled",
-				result: "skipped",
-				syntax: false,
-				semantic: false,
-			};
+			validation = disabledApiValidationMeta(resolved);
 		}
+		// Recorded BEFORE the request, so a transport drop or RouterOS fault below
+		// reports the gate that actually settled rather than a guess.
+		trace.validation = validation;
 
 		const result = await backend.apiRequest(buildProtocolApiRequest(resolved));
 		return {
@@ -542,32 +579,63 @@ export async function resolveApiRequest(
 	const query = buildApiQuery(request);
 	const proplist = buildApiProplist(request);
 
-	const cdbResolution =
-		override?.cdbResolution ??
-		(await resolveCdb(
-			{
-				targetInput: request.targetInput,
-				cdbFile: request.cdbFile,
-				cdbPassword: request.cdbPassword,
-			},
-			env,
-			config,
-		));
-	const via = resolveApiProtocol(request, env, listen, cdbResolution, config);
-	const format = resolveApiFormat(request, env, config);
-	// `--raw` forces validation off (constitution: --raw waiver); otherwise the
-	// inspect gate is on by default.
-	const validate: ResolvedSetting<boolean> = raw
-		? { value: false, source: { kind: "cli", key: "--raw" } }
-		: resolveBooleanSetting(
-				request.validate,
+	// A quickchr target is a named-live-provider: host/port/auth come from the
+	// live descriptor, bypassing CDB, `__default__`, and MAC resolution.
+	let quickchrResolution: Awaited<
+		ReturnType<typeof resolveQuickchrTarget>
+	> | null = null;
+	if (request.quickchr !== undefined) {
+		assertNoQuickchrOverrideConflict(request, request.quickchr);
+		quickchrResolution = await resolveQuickchrTarget(request.quickchr);
+	}
+	const cdbResolution = quickchrResolution
+		? undefined
+		: (override?.cdbResolution ??
+			(await resolveCdb(
+				{
+					targetInput: request.targetInput,
+					cdbFile: request.cdbFile,
+					cdbPassword: request.cdbPassword,
+				},
 				env,
-				"CENTRS_VALIDATE",
-				true,
-				"validate",
-				cdbResolution?.overrides.validate,
 				config,
-			);
+			)));
+	const via = resolveApiProtocol(request, env, listen, cdbResolution, config);
+	const format = resolveApiFormat(request, env, config);
+	// `--raw` is a PRECEDENCE LAYER, not an override (#154). It ranks below an
+	// explicit `--validate` and above every ambient source, so:
+	//
+	//   --validate=true|false   explicit CLI flag   ← wins
+	//   --raw                   → validate=false
+	//   CENTRS_VALIDATE / CDB comment-kv / config
+	//   default                 → validate=true
+	//
+	// It used to short-circuit the whole ladder, which silently discarded an
+	// explicit `--validate=true` — and env, CDB and config with it. `--raw
+	// --validate=true` is the intended way to debug `api` when centrs itself is
+	// suspect: the gate runs and a failure renders through `rawErrorPayload` as
+	// `{code,message}` on stderr with a nonzero exit, which is the `--raw` error
+	// contract for any other preflight failure. `--raw` still outranks the
+	// ambient sources rather than merely lowering the default, so it behaves the
+	// same on every machine regardless of a `CENTRS_VALIDATE` in the environment.
+	//
+	// The `--raw` arm must SHORT-CIRCUIT, not merely win a comparison: resolving
+	// the ambient layer first would parse `CENTRS_VALIDATE` even when `--raw`
+	// decides the value, so a malformed ambient value threw `settings/invalid-
+	// boolean` out of a call `--raw` had already settled — the same
+	// machine-dependence this layer exists to remove.
+	const validate: ResolvedSetting<boolean> =
+		raw && request.validate === undefined
+			? { value: false, source: { kind: "cli", key: "--raw" } }
+			: resolveBooleanSetting(
+					request.validate,
+					env,
+					"CENTRS_VALIDATE",
+					true,
+					"validate",
+					cdbResolution?.overrides.validate,
+					config,
+				);
 	const timeoutMs = resolveApiTimeout(
 		request.timeout,
 		env,
@@ -575,48 +643,70 @@ export async function resolveApiRequest(
 		cdbResolution?.overrides.timeoutMs,
 		config,
 	);
-	const macResolution = isIpTransport(via.value)
-		? await resolveMacTarget({
-				host: request.host,
-				targetInput: request.targetInput,
-				cdbTarget: cdbResolution?.target,
+	const macResolution =
+		quickchrResolution === null && isIpTransport(via.value)
+			? await resolveMacTarget({
+					host: request.host,
+					targetInput: request.targetInput,
+					cdbTarget: cdbResolution?.target,
+					env,
+					config,
+					policy: parseResolvePolicy(
+						request.resolve ??
+							env["CENTRS_RESOLVE"] ??
+							config["CENTRS_RESOLVE"],
+					),
+					// api has no Layer-2 transport (rest-api/native-api only), so MAC
+					// remediation matches retrieve's (no mac-telnet suggestion).
+					operation: "retrieve",
+				})
+			: undefined;
+	const connection = quickchrResolution
+		? quickchrConnection(quickchrResolution, via.value)
+		: null;
+	const target = connection
+		? connection.target
+		: resolveTarget(
+				{
+					targetInput: request.targetInput,
+					host: request.host,
+					port: request.port,
+					macResolution,
+				},
 				env,
+				via.value,
+				cdbResolution,
 				config,
-				policy: parseResolvePolicy(
-					request.resolve ?? env["CENTRS_RESOLVE"] ?? config["CENTRS_RESOLVE"],
-				),
-				// api has no Layer-2 transport (rest-api/native-api only), so MAC
-				// remediation matches retrieve's (no mac-telnet suggestion).
-				operation: "retrieve",
-			})
-		: undefined;
-	const target = resolveTarget(
-		{
-			targetInput: request.targetInput,
-			host: request.host,
-			port: request.port,
-			macResolution,
-		},
-		env,
-		via.value,
-		cdbResolution,
-		config,
-	);
-	const auth = resolveAuth(
-		{ username: request.username, password: request.password },
-		env,
-		cdbResolution,
-		config,
-	);
-	const insecure = resolveBooleanSetting(
-		request.insecure,
-		env,
-		"CENTRS_INSECURE",
-		false,
-		"insecure",
-		cdbResolution?.overrides.insecure,
-		config,
-	);
+			);
+	const auth = connection
+		? connection.auth
+		: resolveAuth(
+				{ username: request.username, password: request.password },
+				env,
+				cdbResolution,
+				config,
+			);
+	// A quickchr TLS endpoint is trusted by provenance (self-signed VM cert) —
+	// `insecure` is forced with provider provenance and the provider-trust
+	// warning rides the envelope (see QuickchrConnection.insecure).
+	const insecure =
+		connection?.insecure === true
+			? {
+					value: true,
+					source: {
+						kind: "provider" as const,
+						key: `quickchr:${request.quickchr}`,
+					},
+				}
+			: resolveBooleanSetting(
+					request.insecure,
+					env,
+					"CENTRS_INSECURE",
+					false,
+					"insecure",
+					cdbResolution?.overrides.insecure,
+					config,
+				);
 
 	return {
 		endpoint: request.endpoint,
@@ -644,7 +734,9 @@ export async function resolveApiRequest(
 		insecure,
 		yes: request.yes ?? false,
 		verbose: request.verbose ?? false,
-		warnings: cdbResolution?.warnings ?? [],
+		warnings: connection
+			? [...connection.warnings]
+			: (cdbResolution?.warnings ?? []),
 	};
 }
 
@@ -863,6 +955,9 @@ export function buildProtocolApiRequest(
 	return request;
 }
 
+/** The api device-stage validator: structured input is inspected, never `:parse`d. */
+const API_DEVICE_STAGE_SOURCE = "/console/inspect request=child";
+
 interface ApiValidationResult {
 	validation: EnvelopeValidationMeta;
 	tips: Tip[];
@@ -870,22 +965,58 @@ interface ApiValidationResult {
 
 /**
  * The structured-input gate. Because the input is a path (not a CLI string) the
- * validator is `/console/inspect`, never `:put [:parse]`. Path existence via
- * `request=child`; add/set attribute validity via `request=child`+`completion`. A
+ * validator is `/console/inspect`, never `:put [:parse]`. Path existence and
+ * add/set attribute validity both come from `request=child` — command-level
+ * `request=completion` is unsafe on RouterOS 7.12.2 (`core/inspect.ts`). A
  * `/execute` script is a CLI string → `semantic: not-applicable`.
  */
 async function validateApiRequest(
 	resolved: ResolvedApiRequest,
 	backend: ProtocolAdapter,
+	trace: ValidationTrace = {},
 ): Promise<ApiValidationResult> {
 	if (resolved.scriptMode) {
+		// `/execute` carries a CLI string, so `/console/inspect` has nothing to
+		// inspect — which until GH#354 meant the script was sent with NO gate at
+		// all (`syntax: false`, `semantic: "not-applicable"`, `result: "passed"`).
+		// The offline analyzer is the whole gate here: a syntax fault is now a
+		// byte span and no round trip, where before it reached the device.
+		const script = scriptOf(resolved);
+		const offline = script
+			? assertOfflineSyntax(script, {
+					surface: "api /execute",
+					via: resolved.via.value,
+				})
+			: undefined;
+		trace.offlineVerdict = offline?.verdict;
+		const offlineReason =
+			offline === undefined
+				? "no `script` field to analyze"
+				: offline.verdict === "warn"
+					? "analyzer abstained on part of the input"
+					: undefined;
 		return {
 			validation: {
 				enabled: true,
-				source: "/console/inspect (script, not-applicable)",
+				source: offline === undefined ? "not-applicable" : OFFLINE_GATE_SOURCE,
 				result: "passed",
-				syntax: false,
+				syntax: offline !== undefined,
 				semantic: "not-applicable",
+				stages: [
+					{
+						stage: "offline",
+						source: OFFLINE_GATE_SOURCE,
+						result: offline === undefined ? "skipped" : "passed",
+						...(offlineReason ? { reason: offlineReason } : {}),
+					},
+					{
+						stage: "device",
+						source: "/console/inspect request=child",
+						result: "skipped",
+						reason:
+							"`/execute` is a CLI string, not a menu path; RouterOS re-validates it on the run",
+					},
+				],
 			},
 			tips: [],
 		};
@@ -927,7 +1058,7 @@ async function validateApiRequest(
 		// Only reject when inspect actually surfaced the command's arguments; if it
 		// returns none, skip rather than false-reject a valid command.
 		if (isCommand && Object.keys(resolved.body).length > 0) {
-			const available = await inspectApiAttributes(backend, tokens);
+			const available = await inspectArgumentNames(backend, tokens);
 			if (available.length > 0) {
 				const requested = Object.keys(resolved.body);
 				const missing = requested.filter(
@@ -942,10 +1073,10 @@ async function validateApiRequest(
 						context: {
 							path: resolved.path,
 							verb: resolved.verb,
-							attribute: missing[0],
+							parameter: missing[0],
 							requestedAttributes: requested,
 							availableAttributes: available,
-							validationSource: "/console/inspect request=child+completion",
+							validationSource: "/console/inspect request=child",
 						},
 					});
 				}
@@ -970,7 +1101,7 @@ async function validateApiRequest(
 	}
 
 	if (resolved.verb === "add" || resolved.verb === "set") {
-		const available = await inspectApiAttributes(backend, [
+		const available = await inspectArgumentNames(backend, [
 			...tokens,
 			resolved.verb,
 		]);
@@ -987,17 +1118,17 @@ async function validateApiRequest(
 				context: {
 					path: resolved.path,
 					verb: resolved.verb,
-					attribute: missing[0],
+					parameter: missing[0],
 					requestedAttributes: requested,
 					availableAttributes: available,
-					validationSource: "/console/inspect request=child+completion",
+					validationSource: "/console/inspect request=child",
 				},
 			});
 		}
 		return {
 			validation: {
 				enabled: true,
-				source: "/console/inspect request=child+completion",
+				source: "/console/inspect request=child",
 				result: "passed",
 				syntax: false,
 				semantic: true,
@@ -1019,6 +1150,21 @@ async function validateApiRequest(
 	};
 }
 
+/**
+ * The `/execute` script body, when there is one to analyze.
+ *
+ * A missing or blank `script` is not this gate's error to raise:
+ * {@link buildProtocolApiRequest} already rejects it with an actionable
+ * `input/invalid-command` naming the three ways to pass one. Reporting a syntax
+ * fault for an absent field would be the wrong diagnosis.
+ */
+function scriptOf(resolved: ResolvedApiRequest): string | undefined {
+	const script = resolved.body["script"];
+	return typeof script === "string" && script.trim().length > 0
+		? script
+		: undefined;
+}
+
 function unknownPathError(resolved: ResolvedApiRequest): CentrsError {
 	return new CentrsError({
 		code: "validation/unknown-path",
@@ -1033,23 +1179,6 @@ function unknownPathError(resolved: ResolvedApiRequest): CentrsError {
 	});
 }
 
-async function inspectApiAttributes(
-	backend: ProtocolAdapter,
-	commandTokens: readonly string[],
-): Promise<string[]> {
-	const children = await inspectChildren(backend, commandTokens);
-	const childAttributes = children
-		.filter(isArgumentNode)
-		.map((child) => child.name)
-		.filter(
-			(name): name is string => typeof name === "string" && name.length > 0,
-		);
-	const completionRows = await inspectCompletions(backend, commandTokens);
-	return [
-		...new Set([...childAttributes, ...extractCompletionNames(completionRows)]),
-	].sort();
-}
-
 async function assertApiWriteConfirmed(
 	request: ApiRequest,
 	resolved: ResolvedApiRequest,
@@ -1256,7 +1385,7 @@ export function buildApiErrorEnvelope(
 						: false,
 					listen: request.listen ?? false,
 					yes: request.yes ?? false,
-					validate: request.raw ? false : (request.validate ?? true),
+					validate: summarizedValidate(request),
 					raw: request.raw ?? false,
 					format: resolveErrorFormat(request, env),
 				},
@@ -1272,6 +1401,7 @@ export function buildApiErrorEnvelope(
 export function buildApiErrorEnvelopeFromResolved(
 	resolved: ResolvedApiRequest,
 	error: unknown,
+	trace?: ValidationTrace,
 ): ApiErrorEnvelope {
 	const centrsError = asApiError(error);
 	return {
@@ -1279,17 +1409,117 @@ export function buildApiErrorEnvelopeFromResolved(
 		error: serializeCentrsError(centrsError),
 		warnings: [...resolved.warnings],
 		tips: [],
-		meta: metaFromResolved(resolved, {
-			enabled: resolved.validate.value,
-			source: resolved.validate.value ? "/console/inspect" : "disabled",
-			result: resolved.validate.value ? "failed" : "skipped",
+		meta: metaFromResolved(
+			resolved,
+			trace?.validation ??
+				failedApiValidationMeta(resolved, centrsError, trace),
+		),
+	};
+}
+
+/**
+ * `meta.validation` for an api error envelope. A stage-1 rejection opened no
+ * connection, so the meta must not report `/console/inspect` as the validator
+ * that failed (GH#354).
+ */
+function failedApiValidationMeta(
+	resolved: ResolvedApiRequest,
+	error: CentrsError,
+	trace?: ValidationTrace,
+): EnvelopeValidationMeta {
+	if (!resolved.validate.value) {
+		return disabledApiValidationMeta(resolved);
+	}
+	if (isOfflineGateRejection(error)) {
+		return {
+			enabled: true,
+			source: OFFLINE_GATE_SOURCE,
+			result: "failed",
 			syntax: false,
-			semantic: resolved.validate.value
-				? resolved.scriptMode
-					? "not-applicable"
-					: false
-				: false,
-		}),
+			semantic: "not-applicable",
+			stages: [
+				{ stage: "offline", source: OFFLINE_GATE_SOURCE, result: "failed" },
+				{
+					stage: "device",
+					source: API_DEVICE_STAGE_SOURCE,
+					result: "skipped",
+					reason: "offline analysis rejected the script; no connection opened",
+				},
+			],
+		};
+	}
+	// `stages` is only asserted when a `validation/*` error identifies the device
+	// stage as the rejecter. Everything downstream — a RouterOS fault on the
+	// request, a transport drop — passed the gate and is served by
+	// `trace.validation` before this function is ever reached.
+	const deviceRejected = error.code.startsWith("validation/");
+	return {
+		enabled: true,
+		source: "/console/inspect",
+		result: "failed",
+		syntax: false,
+		semantic: resolved.scriptMode ? "not-applicable" : false,
+		...(deviceRejected
+			? { stages: [offlineApiStage(resolved, trace), deviceStageFailed()] }
+			: {}),
+	};
+}
+
+/**
+ * The offline-stage entry for an api gate that reached the device stage.
+ *
+ * Script mode is the only api shape stage 1 analyzes; a structured path request
+ * is a path plus a body, not a CLI string, so its offline stage is `skipped`
+ * with the reason spelled out rather than silently reported as passed.
+ */
+function offlineApiStage(
+	resolved: ResolvedApiRequest,
+	trace?: ValidationTrace,
+): EnvelopeValidationStage {
+	if (!resolved.scriptMode) {
+		return {
+			stage: "offline",
+			source: OFFLINE_GATE_SOURCE,
+			result: "skipped",
+			reason: "structured path request, not a CLI string (GH#354)",
+		};
+	}
+	return {
+		stage: "offline",
+		source: OFFLINE_GATE_SOURCE,
+		result: "passed",
+		...(trace?.offlineVerdict === "warn"
+			? { reason: "analyzer abstained on part of the input" }
+			: {}),
+	};
+}
+
+function deviceStageFailed(): EnvelopeValidationStage {
+	return {
+		stage: "device",
+		source: API_DEVICE_STAGE_SOURCE,
+		result: "failed",
+	};
+}
+
+/**
+ * `--validate=false` (including a bare `--raw`). Both stages are listed as
+ * `skipped` rather than omitted, so a consumer reading `stages` never has to
+ * special-case the disabled shape; `enabled: false` already carries the why.
+ */
+function disabledApiValidationMeta(
+	resolved: ResolvedApiRequest,
+): EnvelopeValidationMeta {
+	return {
+		enabled: false,
+		source: "disabled",
+		result: "skipped",
+		syntax: false,
+		semantic: resolved.scriptMode ? "not-applicable" : false,
+		stages: [
+			{ stage: "offline", source: OFFLINE_GATE_SOURCE, result: "skipped" },
+			{ stage: "device", source: API_DEVICE_STAGE_SOURCE, result: "skipped" },
+		],
 	};
 }
 
@@ -1482,7 +1712,7 @@ export function apiRequestSummaryFromRequest(
 		write: parsed ? isApiMutating(parsed, normalized.path) : false,
 		listen,
 		yes: request.yes ?? false,
-		validate: request.raw ? false : (request.validate ?? true),
+		validate: summarizedValidate(request),
 		raw: request.raw ?? false,
 		format: resolveErrorFormat(request, env),
 		query: buildApiQuery(request),