@tikoci/centrs 0.1.4 → 0.1.7

package/src/index.ts

@@ -1,5 +1,3 @@
-export const centrsVersion = "0.1.0";
-
 export {
 	type ApiEnvelope,
 	type ApiErrorEnvelope,
@@ -81,6 +79,7 @@ export {
 	type EnvelopeMeta,
 	type EnvelopeTargetMeta,
 	type EnvelopeValidationMeta,
+	type EnvelopeValidationStage,
 	type FanoutData,
 	type FanoutSummary,
 	normalizeWarnings,
@@ -110,6 +109,7 @@ export {
 	type InspectChildItem,
 	type InspectCompletionItem,
 	type InspectRequestKind,
+	inspectArgumentNames,
 	inspectChildren,
 	inspectChildrenOrEmpty,
 	inspectCompletions,
@@ -136,6 +136,7 @@ export {
 	versionFactFromComment,
 	versionInRange,
 } from "./core/preflight.ts";
+export { centrsVersion } from "./core/version.ts";
 export {
 	encodeMndpPacket,
 	MNDP_BROADCAST_ADDRESS,
@@ -202,6 +203,7 @@ export {
 	type DevicesCommand,
 	type DevicesEnvelope,
 	type DevicesGroupSummary,
+	type DevicesInitData,
 	type DevicesListItem,
 	type DevicesMutationData,
 	type DevicesMutationEnvelope,
@@ -214,6 +216,7 @@ export {
 	defaultCdbPath,
 	devicesOutputFormats,
 	editInteractiveOnlyError,
+	initCdb,
 	type LoadCdbOptions,
 	type LoadedCdb,
 	listDevices,
@@ -305,13 +308,20 @@ export {
 // relative to the statement it was handed; the `Token` is that rebased into
 // document space by `explainCommand`. A consumer reading `explainCommand`'s
 // result wants the latter.
+//
+// `lexExplainArgumentTokens` is the skip-tolerant reading (#316) and is
+// exported for the same reason `lexExplainValueAnchors` is: a consumer building
+// its own token-level rule needs the reading a rule wants, not the one a
+// renderer wants. Its `undecided` tokens carry no `value` and never become one.
 export {
 	type Argument as ExplainArgument,
 	type ArgumentKind as ExplainArgumentKind,
 	type ArgumentReading as ExplainArgumentReading,
 	type ArgumentsRead as ExplainArgumentsRead,
 	type ArgumentsUnread as ExplainArgumentsUnread,
+	type ArgumentTokenReading as ExplainArgumentTokenReading,
 	lexArguments as lexExplainArguments,
+	lexArgumentTokens as lexExplainArgumentTokens,
 	lexValueAnchors as lexExplainValueAnchors,
 	type ValueAnchor as ExplainValueAnchor,
 	type ValueAnchorKind as ExplainValueAnchorKind,
@@ -478,6 +488,14 @@ export {
 	explainOutputFormats,
 	renderExplainEnvelope,
 } from "./explain.ts";
+export {
+	assertOfflineSyntax,
+	isOfflineGateRejection,
+	OFFLINE_GATE_SOURCE,
+	type OfflineGateFinding,
+	type OfflineGateResult,
+	type ValidationStageName,
+} from "./offline-gate.ts";
 export {
 	type ApiVerb,
 	createProtocolAdapter,
@@ -672,6 +690,7 @@ export {
 	transferFanout,
 } from "./transfer-fanout.ts";
 
+import { centrsVersion } from "./core/version.ts";
 import { plannedProtocols, type RouterOsProtocol } from "./protocols/index.ts";
 
 export const plannedSurfaces = ["api", "cli", "tui", "mcp", "proxy"] as const;

package/src/mcp/server.ts

@@ -10,6 +10,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { centrsVersion } from "../core/version.ts";
 import { type CentrsMcpConfig, resolveMcpConfig } from "./config.ts";
 import {
 	buildDevicesResource,
@@ -79,7 +80,7 @@ export function createCentrsMcpServer(
 	config: CentrsMcpConfig = resolveMcpConfig(),
 ): McpServer {
 	const server = new McpServer(
-		{ name: "centrs-mcp", version: "0.1.0" },
+		{ name: "centrs-mcp", version: centrsVersion },
 		{ instructions: SERVER_INSTRUCTIONS },
 	);
 

package/src/mcp/tools.ts

@@ -352,7 +352,7 @@ export const executeInputShape = {
 		.boolean()
 		.optional()
 		.describe(
-			"Required true for write-shaped commands (add/set/remove). Reads ignore it.",
+			"Required true for write-shaped commands, including selector/positional and non-CRUD mutations. Reads ignore it.",
 		),
 	via: z.string().optional().describe("Override transport."),
 	timeout: z

package/src/offline-gate.ts

@@ -0,0 +1,148 @@
+/**
+ * Stage 1 of the validation gate: the offline analyzer in front of the device
+ * preflight (GH#354).
+ *
+ * centrs used to run two validators that did not know about each other — the
+ * device preflight (`:put [:parse …]` plus `/console/inspect request=child`)
+ * that `execute` / `api` / `validate` share, and offline `explain`, which is
+ * byte-accurate and corpus-gated but took no part in validation at all. This
+ * module is the seam that joins them: every CLI-shaped input is analyzed here
+ * first, with no connection, and only then handed to the device stage.
+ *
+ * Three things that buys, in the order they matter:
+ *
+ * 1. A syntax fault is rejected with a **byte span** and **no round trip** — the
+ *    protocol adapter is never even constructed.
+ * 2. The device stage narrows to the semantic half it is actually needed for
+ *    (`:parse` is name-level only; `/console/inspect` owns the attribute set).
+ * 3. Where the device probe is unsafe or unavailable — the 7.12.2 class of
+ *    problem in GH#343 — the gate degrades to a real gate instead of to nothing.
+ *
+ * **A clean offline pass is necessary, never sufficient.** `explain` publishes
+ * `runtimeAcceptance: "not-proven"` for a reason: `/console/inspect` accepts
+ * forms the runtime rejects, and the analyzer has no per-menu schema (decision 3
+ * — no offline schema snapshot). The device stage is not optional and this
+ * module never reports success on its behalf. `verdict: "warn"` is an
+ * ABSTENTION, not a rejection, and passes through for the same reason.
+ *
+ * `--validate=false` disables BOTH stages — one flag, one meaning. That was
+ * settled with the `--raw` precedence layer on GH#154 and is why callers gate
+ * this on the same resolved `validate` setting as the device stage; the escape
+ * hatch has to cover a stage-1 defect too (GH#355 is a live example of the
+ * analyzer being wrong in the other direction).
+ *
+ * The offending byte range rides `context.span`, never {@link CentrsError}'s
+ * `position`. `RouterOsErrorPosition` is documented as RouterOS's own
+ * authoritative 1-based byte column, "carried verbatim; never re-derived"
+ * (`errors.ts`) — synthesizing one from offline analysis would make a
+ * centrs-derived offset indistinguishable from a device-reported one.
+ */
+
+import { CentrsError } from "./errors.ts";
+import { type ExplainDiagnostic, explainCommand } from "./explain.ts";
+
+/** Validator identity for `meta.validation` and error context. */
+export const OFFLINE_GATE_SOURCE = "offline explain (canonicalizer)";
+
+/** Which stage of the two-stage gate produced a verdict. */
+export type ValidationStageName = "offline" | "device";
+
+/** One rejected span, flattened out of {@link ExplainDiagnostic} for the error context. */
+export interface OfflineGateFinding {
+	/** The `explain/<analyzer>/<slug>` diagnostic code. */
+	code: string;
+	message: string;
+	/** Byte offsets into the analyzed input, end-exclusive. */
+	start: number;
+	end: number;
+}
+
+/** Outcome of a stage-1 run that did not reject. */
+export interface OfflineGateResult {
+	/**
+	 * `pass` — the analyzer read the whole input. `warn` — it ABSTAINED on part
+	 * of it (an unresolved menu, say). Both proceed to the device stage; only
+	 * `fail` throws.
+	 */
+	verdict: "pass" | "warn";
+	/** Warning-severity diagnostics, kept so a caller can surface the abstention. */
+	warnings: readonly OfflineGateFinding[];
+}
+
+function findingOf(diagnostic: ExplainDiagnostic): OfflineGateFinding {
+	return {
+		code: diagnostic.code,
+		message: diagnostic.message,
+		start: diagnostic.span.start,
+		end: diagnostic.span.end,
+	};
+}
+
+/**
+ * Run the offline stage over a RouterOS CLI string.
+ *
+ * Throws `validation/syntax` when the analyzer rejects the input; returns the
+ * verdict otherwise. Never opens a connection and never throws for any other
+ * reason — `explainCommand` itself is documented as total.
+ *
+ * `surface` names the caller in the error context (`execute`, `api /execute`) so
+ * a reader can tell which command's gate spoke; `via` is the resolved protocol
+ * when the caller has one, purely for context.
+ */
+export function assertOfflineSyntax(
+	command: string,
+	options: { surface: string; via?: string },
+): OfflineGateResult {
+	const analysis = explainCommand(command);
+	const errors = analysis.diagnostics.filter(
+		(diagnostic) => diagnostic.severity === "error",
+	);
+	const warnings = analysis.diagnostics
+		.filter((diagnostic) => diagnostic.severity === "warning")
+		.map(findingOf);
+
+	if (analysis.verdict !== "fail") {
+		return { verdict: analysis.verdict === "warn" ? "warn" : "pass", warnings };
+	}
+
+	// A `fail` verdict always carries at least one error diagnostic, but read it
+	// defensively: an empty list would otherwise produce an error that says
+	// nothing about what was wrong, which is worse than a generic summary.
+	const findings = errors.map(findingOf);
+	const first = findings[0];
+	throw new CentrsError({
+		code: "validation/syntax",
+		summary: first
+			? `RouterOS syntax rejected by offline analysis: ${first.message}`
+			: "RouterOS syntax rejected by offline analysis.",
+		remediation:
+			"Run `centrs explain '<command>'` to see the offending bytes in context, " +
+			"fix the syntax, then retry. `--validate=false` bypasses both validation " +
+			"stages if you are deliberately probing a RouterOS edge centrs reads wrong.",
+		context: {
+			command,
+			validationStage: "offline" satisfies ValidationStageName,
+			validationSource: OFFLINE_GATE_SOURCE,
+			surface: options.surface,
+			...(options.via ? { via: options.via } : {}),
+			...(first ? { span: { start: first.start, end: first.end } } : {}),
+			diagnostics: findings,
+		},
+		causeData: first?.code ?? "offline analysis rejected the input",
+	});
+}
+
+/**
+ * True when `error` is the rejection {@link assertOfflineSyntax} throws.
+ *
+ * Callers use this to build honest envelope metadata: on a stage-1 rejection the
+ * device stage did not run, and no connection was opened, so the meta must not
+ * claim `:parse` or `/console/inspect` failed.
+ */
+export function isOfflineGateRejection(error: unknown): boolean {
+	return (
+		error instanceof CentrsError &&
+		error.code === "validation/syntax" &&
+		(error.context?.["validationStage"] as string | undefined) === "offline"
+	);
+}

package/src/protocols/adapter.ts

@@ -152,6 +152,14 @@ export interface ProtocolListenOptions {
 	 * after the follow is established, instead of a blind timer.
 	 */
 	onListening?: () => void;
+	/**
+	 * How long to wait for RouterOS to acknowledge `/cancel` after `signal`
+	 * aborts before ending the listen locally. Native API defaults to the
+	 * adapter's `timeoutMs`, the same bound as any other reply wait.
+	 */
+	cancelGraceMs?: number;
+	/** Fired when that wait expires without the router's acknowledgement. */
+	onCancelUnacknowledged?: () => void;
 }
 
 /**
@@ -733,7 +741,10 @@ class NativeApiAdapter implements ProtocolAdapter {
 			command.proplist = request.proplist;
 		}
 		const session = await this.connect();
-		for await (const reply of session.listen(command, options)) {
+		for await (const reply of session.listen(command, {
+			...options,
+			cancelGraceMs: options.cancelGraceMs ?? this.config.timeoutMs,
+		})) {
 			// Each `!re` becomes a rest-style record (string values; `.dead` preserved).
 			yield { ...reply.attributes };
 		}

package/src/protocols/mac-telnet-console.ts

@@ -627,14 +627,16 @@ export function parseScriptFor(cli: string): string {
  *      with RouterOS's position suffix. All 425 corpus rows of this shape are
  *      the entire return; none appear embedded. Requiring both line-start and
  *      the `(line N column M)` suffix is what separates a real verdict from
- *      echoed body text.
+ *      echoed body text. The pinned 7.23.5/7.24.2/7.25beta3 captures add no
+ *      new heads beyond `syntax error`, `expected …` and `missing …`
+ *      (`missing closing brace`, `missing value for where`; GH#375).
  */
 const WRAPPED_BAD_PARAMETER = /\(evl\s+bad parameter\s+(\S+)/i;
 const WRAPPED_BAD_COMMAND = /\(<%%\s*bad command name\b/i;
 const BARE_BAD_PARAMETER =
 	/^[ \t]*bad parameter\s+(\S+)[^\n]*\(line \d+ column \d+\)/im;
 const BARE_SYNTAX =
-	/^[ \t]*(?:syntax error|bad command name|expected [a-z]+(?: [a-z]+)*)[^\n]*\(line \d+ column \d+\)/im;
+	/^[ \t]*(?:syntax error|bad command name|(?:expected|missing) [a-z]+(?: [a-z]+)*)[^\n]*\(line \d+ column \d+\)/im;
 
 /**
  * Classify the printed value of `:put [:parse "<cli>"]`. Grounded on CHR 7.23.3
@@ -646,8 +648,8 @@ const BARE_SYNTAX =
  * RouterOS emits them (see the grammar note above): wrapped as
  * `(evl bad parameter <name> (line N column M) /path)` /
  * `(<%% bad command name <name> (line N column M) a;b;c)`, or bare and
- * line-initial as `expected … (line N column M)` / `syntax error (line N column
- * M)`. A single `:parse` covers both the syntax and the unknown-attribute
+ * line-initial as `expected … (line N column M)` / `missing … (line N column
+ * M)` / `syntax error (line N column M)`. A single `:parse` covers both the syntax and the unknown-attribute
  * (name-level) gate on every transport — REST and native API expose the same text
  * in the `ret` value (HTTP 200 / `as-string`), the console transports print it.
  *

package/src/protocols/native-api.ts

@@ -635,10 +635,21 @@ export class NativeApiSession {
 	 *   trap/`!done` are not awaited) and the generator returns.
 	 * A non-`interrupted` trap (e.g. a bad path) or `!fatal`/transport closure
 	 * throws. CHR-grounded (7.23.1): see `commands/api/AGENTS.md`.
+	 *
+	 * After an abort, `cancelGraceMs` bounds the wait for that acknowledgement: a
+	 * peer that never answers `/cancel` would otherwise hold the generator open
+	 * forever (#385). On expiry the generator ends without the router's
+	 * `!done` and `onCancelUnacknowledged` fires, so the caller can close the
+	 * session and report that the stop was local, not acknowledged.
 	 */
 	async *listen(
 		command: NativeApiCommand,
-		options: { signal?: AbortSignal; onListening?: () => void } = {},
+		options: {
+			signal?: AbortSignal;
+			onListening?: () => void;
+			cancelGraceMs?: number;
+			onCancelUnacknowledged?: () => void;
+		} = {},
 	): AsyncGenerator<ApiReply, void, void> {
 		if (this.closed) {
 			throw (
@@ -702,10 +713,24 @@ export class NativeApiSession {
 		// can act on a real barrier rather than a blind timer.
 		options.onListening?.();
 
-		const onAbort = (): void => this.cancel(tag);
+		let graceTimer: ReturnType<typeof setTimeout> | undefined;
+		const onAbort = (): void => {
+			this.cancel(tag);
+			if (options.cancelGraceMs === undefined) return;
+			graceTimer = setTimeout(() => {
+				if (ended) return;
+				// Stop routing this tag and drop anything queued: a peer that ignores
+				// `/cancel` but keeps sending frames must not keep the loop draining.
+				this.subscriptions.delete(tag);
+				queue.length = 0;
+				ended = true;
+				options.onCancelUnacknowledged?.();
+				signalWake();
+			}, options.cancelGraceMs);
+		};
 		if (options.signal) {
 			if (options.signal.aborted) {
-				this.cancel(tag);
+				onAbort();
 			} else {
 				options.signal.addEventListener("abort", onAbort, { once: true });
 			}
@@ -738,6 +763,7 @@ export class NativeApiSession {
 				throw this.trapToError(command.command, trap);
 			}
 		} finally {
+			clearTimeout(graceTimer);
 			options.signal?.removeEventListener("abort", onAbort);
 			this.subscriptions.delete(tag);
 			// Consumer broke out early (e.g. --count reached): tell the router to stop.

package/src/resolver/target.ts

@@ -428,20 +428,40 @@ export function resolveAuth(
 }
 
 export function parseHostCandidate(value: string): URL {
-	if (/^https?:\/\//i.test(value)) {
-		const url = new URL(value);
-		if (url.pathname !== "/" && url.pathname !== "") {
-			throw new CentrsError({
-				code: "input/invalid-target",
-				summary: `Target URL must not include a path. Received: ${value}`,
-				remediation:
-					"Pass only the RouterOS host or base URL, then provide the RouterOS menu path as the second positional argument.",
-			});
-		}
-		return url;
+	const hasScheme = /^https?:\/\//i.test(value);
+	let url: URL;
+	try {
+		url = new URL(hasScheme ? value : `http://${value}`);
+	} catch (cause) {
+		throw invalidTargetError(value, cause);
 	}
+	if (hasScheme && url.pathname !== "/" && url.pathname !== "") {
+		throw new CentrsError({
+			code: "input/invalid-target",
+			summary: `Target URL must not include a path. Received: ${value}`,
+			remediation:
+				"Pass only the RouterOS host or base URL, then provide the RouterOS menu path as the second positional argument.",
+		});
+	}
+	return url;
+}
 
-	return new URL(`http://${value}`);
+/**
+ * A `<router>` that is not a CDB handle and does not parse as a host (#381).
+ * `quickchr:NAME` is the likely guess for a quickchr VM, so it names the flag.
+ */
+function invalidTargetError(value: string, cause: unknown): CentrsError {
+	const quickchrGuess = /^quickchr:(.+)$/i.exec(value)?.[1];
+	return new CentrsError({
+		code: "input/invalid-target",
+		summary: `Target is not a known device or a valid host: ${value}`,
+		remediation:
+			quickchrGuess !== undefined
+				? `Select a quickchr VM with the flag: \`--quickchr ${quickchrGuess}\` (there is no \`quickchr:\` target prefix).`
+				: "Pass a CDB target or identity (see `centrs devices list`), an IP or hostname with optional `:port`, or an `http(s)://host[:port]` base URL.",
+		context: { target: value },
+		cause,
+	});
 }
 
 function readPort(parsedUrl: URL, scheme: "http" | "https"): number {

package/src/retrieve-fanout.ts

@@ -46,6 +46,7 @@ import {
 	runFanout,
 	summarizeFanout,
 } from "./core/fanout.ts";
+import { toYaml } from "./core/yaml.ts";
 import { CentrsError, serializeCentrsError } from "./errors.ts";
 import { plannedProtocols, type RouterOsProtocol } from "./protocols/index.ts";
 import {
@@ -71,7 +72,6 @@ import {
 	resolveRetrieveGlobalContext,
 	resolveRetrieveRequest,
 	runResolvedRetrieve,
-	toYaml,
 	validateRetrieveRequestShape,
 } from "./retrieve.ts";
 

package/src/retrieve.ts

@@ -8,6 +8,7 @@ import type {
 } from "./core/envelope.ts";
 import {
 	extractCompletionNames,
+	inspectArgumentNames,
 	inspectChildren,
 	inspectChildrenOrEmpty,
 	inspectCompletions,
@@ -15,6 +16,7 @@ import {
 	isCommandNode,
 	pathTokens,
 } from "./core/inspect.ts";
+import { toYaml } from "./core/yaml.ts";
 import { CentrsError, serializeCentrsError } from "./errors.ts";
 import {
 	createProtocolAdapter,
@@ -123,6 +125,7 @@ export type RetrieveErrorEnvelope = CentrsErrorEnvelope<RetrieveOperationMeta>;
 
 interface RetrieveInspection {
 	command: "get" | "print";
+	singleton: boolean;
 }
 
 export interface ResolvedRetrieveRequest {
@@ -239,7 +242,7 @@ export async function runResolvedRetrieve(
 			}
 		}
 
-		const data = await executeRetrieve(resolved, backend);
+		const data = await executeRetrieve(resolved, backend, inspection);
 		const envelope = buildSuccessEnvelope(
 			resolved,
 			{
@@ -998,9 +1001,18 @@ async function inspectRetrievePath(
 		});
 	}
 
-	const singleton = isKnownSingletonPath(resolved.path);
+	// A singleton's `get` takes only `value-name`; a list menu's also takes
+	// `number` (CHR 7.23.7: /tool/romon, /ip/dns, /system/identity vs
+	// /ip/address). A hardcoded path list missed every other singleton and
+	// validated its properties against `print`'s flags (issue #377).
+	const singleton =
+		supportsGet &&
+		!(await inspectArgumentNames(backend, [...tokens, "get"])).includes(
+			"number",
+		);
 	return {
-		command: singleton && supportsGet ? "get" : "print",
+		command: singleton ? "get" : "print",
+		singleton,
 	};
 }
 
@@ -1039,8 +1051,9 @@ async function inspectAttributes(
 async function executeRetrieve(
 	resolved: ResolvedRetrieveRequest,
 	backend: ProtocolAdapter,
+	inspection: RetrieveInspection | undefined,
 ): Promise<unknown> {
-	if (isKnownSingletonPath(resolved.path)) {
+	if (inspection?.singleton ?? isKnownSingletonPath(resolved.path)) {
 		const data = await backend.getSingleton(resolved.path);
 		if (resolved.attributes.length > 0) {
 			return projectSingletonAttributes(data, resolved.attributes);
@@ -1054,6 +1067,7 @@ async function executeRetrieve(
 	});
 }
 
+/** Fallback for `--validate=false`, which skips the inspect that detects singletons. */
 function isKnownSingletonPath(path: string): boolean {
 	return ["/system/resource", "/system/identity"].includes(
 		path.replace(/\/$/, ""),
@@ -1192,62 +1206,3 @@ function exhaustiveOutputFormat(value: never): never {
 function isPlainObject(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-
-export function toYaml(value: unknown, indent = 0): string {
-	const prefix = " ".repeat(indent);
-	if (value === null || value === undefined) {
-		return "null";
-	}
-	if (typeof value === "string") {
-		return yamlScalar(value);
-	}
-	if (typeof value === "number" || typeof value === "boolean") {
-		return String(value);
-	}
-	if (Array.isArray(value)) {
-		if (value.length === 0) {
-			return `${prefix}[]`;
-		}
-		return value
-			.map((item) => {
-				if (isScalar(item)) {
-					return `${prefix}- ${toYaml(item, indent + 2)}`;
-				}
-				return `${prefix}-\n${toYaml(item, indent + 2)}`;
-			})
-			.join("\n");
-	}
-	if (isPlainObject(value)) {
-		const entries = Object.entries(value).filter(
-			([, entryValue]) => entryValue !== undefined,
-		);
-		if (entries.length === 0) {
-			return `${prefix}{}`;
-		}
-		return entries
-			.map(([key, entryValue]) => {
-				if (isScalar(entryValue)) {
-					return `${prefix}${key}: ${toYaml(entryValue, indent + 2)}`;
-				}
-				return `${prefix}${key}:\n${toYaml(entryValue, indent + 2)}`;
-			})
-			.join("\n");
-	}
-	return yamlScalar(JSON.stringify(value));
-}
-
-function isScalar(value: unknown): value is boolean | number | string | null {
-	return (
-		value === null ||
-		typeof value === "string" ||
-		typeof value === "number" ||
-		typeof value === "boolean"
-	);
-}
-
-function yamlScalar(value: string): string {
-	if (value.length === 0) {
-		return '""';
-	}
-	return JSON.stringify(value);
-}

package/src/settings.ts

@@ -24,6 +24,7 @@ import type {
 	Warning,
 } from "./core/envelope.ts";
 import { buildTip } from "./core/envelope.ts";
+import { toYaml } from "./core/yaml.ts";
 import { loadCdb, resolveDevicesSettings } from "./devices.ts";
 import { CentrsError, serializeCentrsError } from "./errors.ts";
 import { plannedProtocols, type RouterOsProtocol } from "./protocols/index.ts";
@@ -37,7 +38,7 @@ import {
 	readSettingsFileRaw,
 	resolveOptionalIntegerSetting,
 } from "./resolver/index.ts";
-import { retrieveOutputFormats, toYaml } from "./retrieve.ts";
+import { retrieveOutputFormats } from "./retrieve.ts";
 
 // ── Envelope shape ───────────────────────────────────────────────────────────
 

package/src/transfer-fanout.ts

@@ -38,6 +38,7 @@ import {
 	runFanout,
 	summarizeFanout,
 } from "./core/fanout.ts";
+import { toYaml } from "./core/yaml.ts";
 import { CentrsError, serializeCentrsError } from "./errors.ts";
 import { promptForWriteConfirmation } from "./execute.ts";
 import { plannedProtocols, type RouterOsProtocol } from "./protocols/index.ts";
@@ -50,7 +51,6 @@ import {
 	type SelectionResolveInput,
 	type TargetSelection,
 } from "./resolver/index.ts";
-import { toYaml } from "./retrieve.ts";
 import {
 	buildTransferErrorEnvelope,
 	isTransferWriteVerb,

package/src/transfer.ts

@@ -29,6 +29,7 @@ import type {
 	EnvelopeValidationMeta,
 	Warning,
 } from "./core/envelope.ts";
+import { toYaml } from "./core/yaml.ts";
 import { CentrsError, serializeCentrsError } from "./errors.ts";
 import {
 	createProtocolAdapter,
@@ -54,7 +55,6 @@ import {
 	resolveTarget,
 	toCoreSource,
 } from "./resolver/index.ts";
-import { toYaml } from "./retrieve.ts";
 
 export const transferOutputFormats = ["text", "json", "yaml"] as const;
 export type TransferOutputFormat = (typeof transferOutputFormats)[number];