@tikoci/centrs 0.1.3 → 0.1.6

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,
@@ -118,6 +118,25 @@ export {
 	isCommandNode,
 	pathTokens,
 } from "./core/inspect.ts";
+export {
+	assertCapability,
+	type CapabilityRequirement,
+	checkCapability,
+	compareRouterOsVersion,
+	type DeviceVersion,
+	type DeviceVersionSource,
+	type PreflightState,
+	type PreflightVerdict,
+	parseRouterOsVersion,
+	probeDeviceVersion,
+	type RouterOsVersionParts,
+	type RouterOsVersionRange,
+	renderSupportedRanges,
+	routerOsVersionAtLeast,
+	versionFactFromComment,
+	versionInRange,
+} from "./core/preflight.ts";
+export { centrsVersion } from "./core/version.ts";
 export {
 	encodeMndpPacket,
 	MNDP_BROADCAST_ADDRESS,
@@ -276,6 +295,205 @@ export {
 	executeFanout,
 	renderExecuteFanoutEnvelope,
 } from "./execute-fanout.ts";
+// The lexer's own names are module-scoped and read naturally there; at the
+// package root they need the `Explain` prefix every other explain export
+// carries — a bare `Argument` says nothing about which of centrs's surfaces it
+// belongs to. Aliasing at the re-export is the existing pattern here (see
+// `occurrences as explainOccurrences` below).
+//
+// `ExplainArgument` and `ExplainArgumentToken` are the same SHAPE in two
+// coordinate spaces: this one is what `lexArguments` returns, with spans
+// 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,
+	type ValueAnchorReading as ExplainValueAnchorReading,
+} from "./explain/args.ts";
+export {
+	DIRECTIVE_BODY,
+	HEAD_SCOPED_ARG_NAMES,
+	isScopeBrace,
+	matchBrace,
+	SCOPE_ARG_NAMES,
+	type ScopeBlock,
+	scopeBlocks,
+	scopeBodies,
+	scopeNameAt,
+} from "./explain/blocks.ts";
+export {
+	analyzeCoordinates,
+	byteSpanToRange,
+	byteToPosition,
+	type CharRun,
+	type CoordinateAnalysis,
+	coordinateDefects,
+	type Position,
+	positionToByte,
+	type Range,
+	runAtByte,
+	SUB,
+} from "./explain/coordinates.ts";
+export {
+	type Defect,
+	type DefectCode,
+	defectAt,
+	hasStructuralDefect,
+	isPositionalFact,
+	mergeDefects,
+	rebaseDefects,
+} from "./explain/defects.ts";
+export {
+	type DocumentAnalysis,
+	type Resolution,
+	resolveDocument,
+	resolveStatements,
+	type Span,
+	type StatementAnalysis,
+	type StatementResolution,
+} from "./explain/pathresolve.ts";
+export {
+	maskComments,
+	type QuotedStringScan,
+	type Segment,
+	type SegmentResult,
+	scanQuotedString,
+	segmentStatements,
+} from "./explain/segment.ts";
+export {
+	HIGHLIGHT_CLASS,
+	resolveSymbols,
+	type SymbolAnalysis,
+	type SymbolClass,
+	type SymbolOccurrence,
+	type SymbolRole,
+} from "./explain/symbols.ts";
+export type {
+	ExplainApiCandidateTransport,
+	ExplainExecuteTransport,
+	ExplainRestMethod,
+	ExplainRestRequest,
+	ExplainTransport,
+	ExplainTransportClassification,
+	ExplainUnknownTransport,
+} from "./explain/transport.ts";
+export {
+	VALUE_SHAPES,
+	type ValueContext as ExplainValueContext,
+	type ValueShape as ExplainValueShape,
+	type ValueShapeOptions as ExplainValueShapeOptions,
+	valueShapeHints as explainValueShapeHints,
+} from "./explain/values.ts";
+export {
+	type DocumentVerbSplit,
+	describeStatement,
+	isDirective,
+	type RunToken,
+	resolveVerb,
+	resolveVerbs,
+	runTokens,
+	type Sep,
+	type Split,
+	SUBMENU_DIRECTIVES,
+	splitRun,
+	VERBS,
+	type VerbAnalysis,
+	type VerbResolution,
+	type VerbSplit,
+	type VerbSplitCommandReading,
+	type VerbSplitMenuReading,
+	type VerbSplitRefusal,
+} from "./explain/verbsplit.ts";
+export {
+	classifyVerb,
+	containsWrite,
+	type Occurrence,
+	type OccurrenceClass,
+	// `occurrences` is too generic for the library root; the module-local name
+	// stays short because inside `write.ts` there is only one kind.
+	occurrences as explainOccurrences,
+	READ_VERBS,
+	ROOT_CMDS,
+	ROOT_DYNAMIC,
+	ROOT_WRITE,
+	WRITE_VERBS,
+	type WriteAnalysis,
+	type WriteVerdict,
+} from "./explain/write.ts";
+export {
+	buildExplainErrorEnvelope,
+	buildExplainFacetTip,
+	type ExplainArguments,
+	type ExplainArgumentToken,
+	type ExplainBlock,
+	type ExplainCanonical,
+	type ExplainCommandOptions,
+	type ExplainCommandReading,
+	type ExplainData,
+	type ExplainDiagnostic,
+	type ExplainEnvelope,
+	type ExplainEnvelopeOptions,
+	type ExplainErrorEnvelope,
+	type ExplainEvidence,
+	type ExplainFailOn,
+	type ExplainInput,
+	type ExplainMenuReading,
+	type ExplainOperationMeta,
+	type ExplainOutputFormat,
+	type ExplainPositionMapEntry,
+	type ExplainReading,
+	type ExplainRefusal,
+	type ExplainResolution,
+	type ExplainSeverity,
+	type ExplainSpan,
+	type ExplainSpanClass,
+	type ExplainSpanRange,
+	type ExplainStatement,
+	type ExplainStatementFacts,
+	type ExplainStructure,
+	type ExplainSubcommand,
+	type ExplainSubcommandFacts,
+	type ExplainSymbolClass,
+	type ExplainSymbolOccurrence,
+	type ExplainSymbols,
+	type ExplainToken,
+	type ExplainTokenClass,
+	type ExplainValueFacts,
+	type ExplainValueOccurrence,
+	type ExplainValueShapeFact,
+	type ExplainValues,
+	type ExplainValueTypeFact,
+	type ExplainVerdict,
+	explainCommand,
+	explainEnvelope,
+	explainExitCode,
+	explainFailOnLevels,
+	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,
@@ -304,9 +522,6 @@ export {
 	type CdbGroupTarget,
 	type CdbResolution,
 	type CdbResolveInput,
-	type CdbSelectionExpansion,
-	type CdbSelectionMember,
-	type CdbSelectionResolveInput,
 	type CommentKvGeoKey,
 	type CommentKvKey,
 	type CommentKvLayer,
@@ -323,7 +538,7 @@ export {
 	defaultPortForScheme,
 	deviceLocation,
 	expandCdbGroup,
-	expandCdbSelection,
+	expandSelection,
 	isDefaultRecordTarget,
 	type NearPredicate,
 	type ParsedGpsTuple,
@@ -351,6 +566,9 @@ export {
 	resolveOptionalIntegerSetting,
 	resolveStringSetting,
 	resolveTarget,
+	type SelectionExpansion,
+	type SelectionMember,
+	type SelectionResolveInput,
 	type SelectionWhereClause,
 	type TargetResolveInput,
 	type TargetSelection,
@@ -470,6 +688,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/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/mac-telnet-console.ts

@@ -39,10 +39,11 @@
  *     scraped for: `(evl …)` = ok, `syntax error (line …)` = malformed, and
  *     `bad parameter <name> (line …)` = unknown attribute. A single console
  *     `:parse` therefore covers both the syntax and the unknown-attribute
- *     (semantic) gate — no `/console/inspect` table parsing needed.
+ *     (name-level) gate — no `/console/inspect` table parsing needed.
  */
 
 import { parseRouterOsPosition } from "../core/routeros-errors.ts";
+import { routerOsStringLiteral } from "../core/routeros-string.ts";
 import { CentrsError } from "../errors.ts";
 import {
 	type MacAddress,
@@ -323,8 +324,11 @@ export class MacTelnetConsole {
 	 * Validate a command without running it, using a single console `:parse`.
 	 * Throws `validation/syntax` for malformed CLI and
 	 * `validation/unknown-attribute` for a rejected parameter; returns the parsed
-	 * form on success. One gate covers both because the console's `:parse`
-	 * reports `bad parameter <name>` as well as `syntax error`.
+	 * form on success. One gate covers both because the console prints the
+	 * `:parse` return value, which carries `bad parameter <name>` as well as the
+	 * `(<%%` / `(line N column M)` syntax diagnostics — see
+	 * {@link classifyParseResult} for the full grammar and why the matcher is
+	 * anchored to the diagnostic shape rather than to bare words.
 	 */
 	async parseGate(cli: string): Promise<string> {
 		const { output } = await this.run(parseScriptFor(cli));
@@ -604,17 +608,61 @@ export function parseScriptFor(cli: string): string {
 	return `:put [:parse ${routerOsStringLiteral(cli)}]`;
 }
 
+/*
+ * The `:parse` diagnostic grammar, anchored to where RouterOS actually emits
+ * each shape. Anchoring is load-bearing, not cosmetic: an *accepted* return
+ * echoes the script body, so `:put "bad parameter x"` comes back as
+ * `(evl /putmessage=bad parameter x)`. An unanchored search reads that echoed
+ * content as a verdict and refuses to run a valid command (GH#230).
+ *
+ * Two shapes, both corpus-verified against lsp-routeros-ts
+ * `parseil_results.il_text` (2736 rows, RouterOS 7.20.8/7.22.1/7.23rc1):
+ *
+ *   1. WRAPPED — the diagnostic sits inside the returned value, marked by the
+ *      `(evl ` / `(<%%` wrapper. It can appear mid-return, because a
+ *      multi-statement script reports the offending statement in place. Every
+ *      corpus `bad parameter` (8/8) follows `(evl `, and every `bad command
+ *      name` (135/135) follows `(<%%`.
+ *   2. BARE — the diagnostic *is* the whole return, printed on its own line
+ *      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.
+ */
+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;
+
 /**
- * Classify the output of a console `:put [:parse "<cli>"]`. A single console
- * `:parse` reports both forms (grounded on CHR 7.23.1): `bad parameter <name>`
- * for an unknown attribute and `syntax error` / `bad command name` for malformed
- * CLI. Throws the matching `validation/*` error; returns on a clean parse.
+ * Classify the printed value of `:put [:parse "<cli>"]`. Grounded on CHR 7.23.3
+ * (see GH#230): `:parse` *never* throws — it returns a value whose text carries
+ * the verdict. For a bare menu path the accepted form is `(evl /canonical/path)`
+ * (abbreviations expanded); for script-shaped input the accepted return echoes
+ * the statement body and may contain arbitrary text — including text that looks
+ * like a diagnostic. Rejections are therefore matched only in the positions
+ * 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
+ * (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.
+ *
+ * Throws the matching `validation/*` error; returns on a clean parse.
  */
-export function classifyParseResult(output: string, cli: string): void {
-	// The console `:parse` rejection carries RouterOS's authoritative byte offset
+export function classifyParseResult(
+	output: string,
+	cli: string,
+	via: string = "mac-telnet",
+): void {
+	// The `:parse` rejection carries RouterOS's authoritative byte offset
 	// (`… (line N column M)`); surface it as the structured `error.position`.
 	const position = parseRouterOsPosition(output);
-	const unknown = output.match(/bad parameter\s+(\S+)/i);
+	const unknown =
+		output.match(WRAPPED_BAD_PARAMETER) ?? output.match(BARE_BAD_PARAMETER);
 	if (unknown) {
 		throw new CentrsError({
 			code: "validation/unknown-attribute",
@@ -624,13 +672,13 @@ export function classifyParseResult(output: string, cli: string): void {
 			context: {
 				command: cli,
 				parameter: cleanToken(unknown[1] ?? ""),
-				validationSource: ":put [:parse ...] over mac-telnet",
+				validationSource: `:put [:parse ...] over ${via}`,
 				detail: output,
 			},
 			...(position ? { position } : {}),
 		});
 	}
-	if (/syntax error|bad command name|expected\b/i.test(output)) {
+	if (WRAPPED_BAD_COMMAND.test(output) || BARE_SYNTAX.test(output)) {
 		throw new CentrsError({
 			code: "validation/syntax",
 			summary: "RouterOS rejected the command syntax while parsing it.",
@@ -638,7 +686,7 @@ export function classifyParseResult(output: string, cli: string): void {
 				"Fix the RouterOS CLI syntax (quotes, brackets, attribute form), then retry.",
 			context: {
 				command: cli,
-				validationSource: ":put [:parse ...] over mac-telnet",
+				validationSource: `:put [:parse ...] over ${via}`,
 				detail: output,
 			},
 			...(position ? { position } : {}),
@@ -646,10 +694,6 @@ export function classifyParseResult(output: string, cli: string): void {
 	}
 }
 
-function routerOsStringLiteral(value: string): string {
-	return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
-}
-
 function cleanToken(token: string): string {
 	return token.replace(/^["'`]+|["'`.,;:)]+$/g, "");
 }

package/src/resolver/facts.ts

@@ -1,6 +1,6 @@
 /**
  * Device-class fact extraction + selector matching, shared by the fan-out
- * resolver ({@link ../resolver/selection.ts | expandCdbSelection}) and
+ * resolver ({@link ../resolver/selection.ts | expandSelection}) and
  * `devices list` (`src/devices.ts`) so **both surfaces match `--where` /
  * `--near` / `--bbox` against identical semantics**.
  *

package/src/resolver/index.ts

@@ -88,14 +88,33 @@ export {
 	unresolvedMacError,
 } from "./mac.ts";
 export {
-	type CdbSelectionExpansion,
-	type CdbSelectionMember,
-	type CdbSelectionResolveInput,
-	expandCdbSelection,
+	assertNoQuickchrOverrideConflict,
+	type QuickchrConnection,
+	type QuickchrResolution,
+	quickchrConnection,
+	resolveQuickchrTarget,
+	SUPPORTED_DESCRIPTOR_VERSION,
+} from "./quickchr-provider.ts";
+export {
+	expandSelection,
 	isDefaultRecordTarget,
+	type SelectionExpansion,
+	type SelectionMember,
+	type SelectionResolveInput,
 	type SelectionWhereClause,
 	type TargetSelection,
 } from "./selection.ts";
+export {
+	type AnyServiceEndpoint,
+	isEndpointAvailable,
+	type ServiceEndpoint,
+	type ServiceEndpointAuth,
+	type ServiceEndpointMap,
+	type ServiceEndpointSource,
+	type SshEndpointAuth,
+	type SshServiceEndpoint,
+	type UnavailableEndpoint,
+} from "./service-endpoint.ts";
 export {
 	type CommentKvLayer,
 	parseBoolean,