@opsydyn/elysia-spectral 1.5.0 → 1.5.2

package/dist/{core-BLJeXQ15.mjs → runtime-PGHAFx-E.mjs}

@@ -1,446 +1,10 @@
-import spectralCore from "@stoplight/spectral-core";
-import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { pathToFileURL } from "node:url";
-import spectralFunctions from "@stoplight/spectral-functions";
-import spectralRulesets from "@stoplight/spectral-rulesets";
-import YAML from "yaml";
 import signale from "signale";
 import { styleText } from "node:util";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { brunoToOpenCollection, openApiToBruno } from "@usebruno/converters";
-//#region src/core/finding-guidance.ts
-const guidanceByCode = {
-	"elysia-operation-summary": "Add detail.summary to the Elysia route options so generated docs and clients have a short operation label.",
-	"elysia-operation-tags": "Add detail.tags with at least one stable tag, for example ['Users'] or ['Dev'].",
-	"operation-description": "Add detail.description with a short user-facing explanation of what the route does.",
-	"operation-tags": "Add a non-empty detail.tags array on the route so the OpenAPI operation is grouped consistently.",
-	"operation-operationId": "Add detail.operationId with a unique camelCase identifier so generated clients and SDKs have stable method names.",
-	"operation-success-response": "Add at least one 2xx response schema to the route, for example response: { 200: t.Object(...) }.",
-	"oas3-api-servers": "Add a servers array to the OpenAPI documentation config with at least one base URL.",
-	"info-contact": "Add an info.contact object to the OpenAPI documentation config with a name and url or email.",
-	"rfc9457-problem-details": "Add an \"application/problem+json\" content entry to the error response. See RFC 9457 for the Problem Details schema."
-};
-const getFindingRecommendation = (code, message) => {
-	const direct = guidanceByCode[code];
-	if (direct) return direct;
-	if (code === "oas3-schema" && message.includes("required property \"responses\"")) return "Add a response schema to the route, for example response: { 200: t.Object(...) } or response: { 200: t.Array(...) }.";
-	if (code.startsWith("operation-")) return "Add the missing operation metadata under detail on the Elysia route options.";
-};
-//#endregion
-//#region src/core/normalize-findings.ts
-const httpMethods = new Set([
-	"get",
-	"put",
-	"post",
-	"delete",
-	"options",
-	"head",
-	"patch",
-	"trace"
-]);
-const normalizeFindings = (diagnostics, spec) => {
-	const findings = diagnostics.map((diagnostic) => normalizeFinding(diagnostic, spec));
-	const summary = findings.reduce((current, finding) => {
-		current[finding.severity] += 1;
-		current.total += 1;
-		return current;
-	}, {
-		error: 0,
-		warn: 0,
-		info: 0,
-		hint: 0,
-		total: 0
-	});
-	return {
-		ok: summary.error === 0,
-		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-		source: "manual",
-		failOn: "error",
-		durationMs: null,
-		summary,
-		findings
-	};
-};
-const normalizeFinding = (diagnostic, spec) => {
-	const path = [...diagnostic.path];
-	const finding = {
-		code: String(diagnostic.code),
-		message: diagnostic.message,
-		severity: toLintSeverity(diagnostic.severity),
-		path,
-		documentPointer: toDocumentPointer(path)
-	};
-	const recommendation = getFindingRecommendation(String(diagnostic.code), diagnostic.message);
-	if (recommendation) finding.recommendation = recommendation;
-	if (diagnostic.source !== void 0) finding.source = diagnostic.source;
-	if (diagnostic.range) finding.range = {
-		start: diagnostic.range.start,
-		end: diagnostic.range.end
-	};
-	const operation = inferOperation(path, spec);
-	if (operation) finding.operation = operation;
-	return finding;
-};
-const toLintSeverity = (severity) => {
-	switch (severity) {
-		case 0: return "error";
-		case 1: return "warn";
-		case 2: return "info";
-		default: return "hint";
-	}
-};
-const toDocumentPointer = (path) => {
-	if (path.length === 0) return "";
-	return `/${path.map((segment) => String(segment).replace(/~/g, "~0").replace(/\//g, "~1")).join("/")}`;
-};
-const inferOperation = (path, spec) => {
-	if (path[0] !== "paths") return;
-	const routePath = typeof path[1] === "string" ? path[1] : void 0;
-	const method = typeof path[2] === "string" && httpMethods.has(path[2]) ? path[2] : void 0;
-	if (!routePath && !method) return;
-	const operationRecord = routePath && method ? getNestedValue(spec, [
-		"paths",
-		routePath,
-		method
-	]) : void 0;
-	const operation = {};
-	if (routePath !== void 0) operation.path = routePath;
-	if (method !== void 0) operation.method = method;
-	if (operationRecord && typeof operationRecord === "object" && "operationId" in operationRecord) operation.operationId = String(operationRecord.operationId);
-	return operation;
-};
-const getNestedValue = (value, path) => {
-	let current = value;
-	for (const segment of path) {
-		if (current === null || typeof current !== "object") return;
-		current = current[segment];
-	}
-	return current;
-};
-//#endregion
-//#region src/core/lint-openapi.ts
-const { Spectral } = spectralCore;
-const lintOpenApi = async (spec, ruleset) => {
-	const spectral = new Spectral();
-	spectral.setRuleset(ruleset);
-	return normalizeFindings(await spectral.run(spec, { ignoreUnknownFormat: false }), spec);
-};
-//#endregion
-//#region src/presets/recommended.ts
-const { schema: schema$3, truthy: truthy$3 } = spectralFunctions;
-const { oas: oas$3 } = spectralRulesets;
-const operationSelector$2 = "$.paths[*][get,put,post,delete,options,head,patch,trace]";
-/**
-* Baseline quality preset. Equivalent to the package default ruleset.
-*
-* - Extends spectral:oas/recommended
-* - elysia-operation-summary and elysia-operation-tags at warn
-* - oas3-api-servers and info-contact disabled (local-dev friendly)
-*/
-const recommended = {
-	extends: [[oas$3, "recommended"]],
-	rules: {
-		"oas3-api-servers": "off",
-		"info-contact": "off",
-		"elysia-operation-summary": {
-			description: "Operations should define a summary for generated docs and clients.",
-			severity: "warn",
-			given: operationSelector$2,
-			then: {
-				field: "summary",
-				function: truthy$3
-			}
-		},
-		"elysia-operation-tags": {
-			description: "Operations should declare at least one tag for grouping and downstream tooling.",
-			severity: "warn",
-			given: operationSelector$2,
-			then: {
-				field: "tags",
-				function: schema$3,
-				functionOptions: { schema: {
-					type: "array",
-					minItems: 1
-				} }
-			}
-		}
-	}
-};
-//#endregion
-//#region src/rulesets/default-ruleset.ts
-const defaultRuleset = recommended;
-//#endregion
-//#region src/core/load-ruleset.ts
-const { alphabetical, casing, defined, enumeration, falsy, length, or, pattern, schema: schema$2, truthy: truthy$2, undefined: undefinedFunction, unreferencedReusableObject, xor } = spectralFunctions;
-const { oas: oas$2 } = spectralRulesets;
-const functionMap = {
-	alphabetical,
-	casing,
-	defined,
-	enumeration,
-	falsy,
-	length,
-	or,
-	pattern,
-	schema: schema$2,
-	truthy: truthy$2,
-	undefined: undefinedFunction,
-	unreferencedReusableObject,
-	xor
-};
-const extendsMap = { "spectral:oas": oas$2 };
-const autodiscoverRulesetFilenames = [
-	"spectral.yaml",
-	"spectral.yml",
-	"spectral.ts",
-	"spectral.mts",
-	"spectral.cts",
-	"spectral.js",
-	"spectral.mjs",
-	"spectral.cjs",
-	"spectral.config.yaml",
-	"spectral.config.yml",
-	"spectral.config.ts",
-	"spectral.config.mts",
-	"spectral.config.cts",
-	"spectral.config.js",
-	"spectral.config.mjs",
-	"spectral.config.cjs"
-];
-var RulesetLoadError = class extends Error {
-	constructor(message, options) {
-		super(message);
-		this.name = "RulesetLoadError";
-		if (options?.cause !== void 0) this.cause = options.cause;
-	}
-};
-const loadRuleset = async (input, baseDirOrOptions = process.cwd()) => {
-	return (await loadResolvedRuleset(input, baseDirOrOptions)).ruleset;
-};
-const loadResolvedRuleset = async (input, baseDirOrOptions = process.cwd()) => {
-	const options = normalizeLoadResolvedRulesetOptions(baseDirOrOptions);
-	const context = {
-		baseDir: options.baseDir,
-		defaultRuleset: options.defaultRuleset,
-		mergeAutodiscoveredWithDefault: options.mergeAutodiscoveredWithDefault
-	};
-	for (const resolver of options.resolvers) {
-		const loaded = await resolver(input, context);
-		if (loaded) {
-			const normalized = { ruleset: normalizeRulesetDefinition(loaded.ruleset) };
-			if (loaded.source) normalized.source = loaded.source;
-			return normalized;
-		}
-	}
-	if (input === void 0) return { ruleset: options.defaultRuleset };
-	throw new RulesetLoadError("Ruleset input could not be resolved.");
-};
-const normalizeLoadResolvedRulesetOptions = (value) => {
-	if (typeof value === "string") return {
-		baseDir: value,
-		resolvers: defaultRulesetResolvers,
-		mergeAutodiscoveredWithDefault: true,
-		defaultRuleset
-	};
-	return {
-		baseDir: value.baseDir ?? process.cwd(),
-		resolvers: value.resolvers ?? defaultRulesetResolvers,
-		mergeAutodiscoveredWithDefault: value.mergeAutodiscoveredWithDefault ?? true,
-		defaultRuleset: value.defaultRuleset ?? defaultRuleset
-	};
-};
-const resolveAutodiscoveredRuleset = async (input, context) => {
-	if (input !== void 0) return;
-	const autodiscoveredPath = await findAutodiscoveredRulesetPath(context.baseDir);
-	if (!autodiscoveredPath) return;
-	const loaded = await loadResolvedPathRuleset(autodiscoveredPath, context);
-	if (!context.mergeAutodiscoveredWithDefault) return {
-		...loaded,
-		source: {
-			path: autodiscoveredPath,
-			autodiscovered: true,
-			mergedWithDefault: false
-		}
-	};
-	return {
-		ruleset: mergeRulesets(context.defaultRuleset, loaded.ruleset),
-		source: {
-			path: autodiscoveredPath,
-			autodiscovered: true,
-			mergedWithDefault: true
-		}
-	};
-};
-const resolvePathRuleset = async (input, context) => {
-	if (typeof input !== "string") return;
-	return await loadResolvedPathRuleset(input, context);
-};
-const resolveInlineRuleset = async (input) => {
-	if (input === void 0 || typeof input === "string") return;
-	return { ruleset: normalizeRulesetDefinition(input) };
-};
-const defaultRulesetResolvers = [
-	resolveAutodiscoveredRuleset,
-	resolvePathRuleset,
-	resolveInlineRuleset
-];
-const loadResolvedPathRuleset = async (inputPath, context) => {
-	const resolvedPath = path.resolve(context.baseDir, inputPath);
-	if (isYamlRulesetPath(resolvedPath)) return {
-		ruleset: await loadYamlRuleset(resolvedPath),
-		source: {
-			path: inputPath,
-			autodiscovered: false,
-			mergedWithDefault: false
-		}
-	};
-	if (!isModuleRulesetPath(resolvedPath)) throw new RulesetLoadError(`Unsupported ruleset path: ${inputPath}. Supported local rulesets are .yaml, .yml, .js, .mjs, .cjs, .ts, .mts, and .cts.`);
-	return {
-		ruleset: await loadModuleRuleset(resolvedPath),
-		source: {
-			path: inputPath,
-			autodiscovered: false,
-			mergedWithDefault: false
-		}
-	};
-};
-const findAutodiscoveredRulesetPath = async (baseDir) => {
-	for (const filename of autodiscoverRulesetFilenames) {
-		const candidatePath = path.resolve(baseDir, filename);
-		try {
-			await access(candidatePath);
-			return `./${filename}`;
-		} catch (error) {
-			if (error.code !== "ENOENT") throw error;
-		}
-	}
-};
-const loadYamlRuleset = async (resolvedPath) => {
-	let fileContents;
-	try {
-		fileContents = await readFile(resolvedPath, "utf8");
-	} catch (error) {
-		throw new RulesetLoadError(`Unable to read ruleset at ${resolvedPath}.`, { cause: error });
-	}
-	let parsed;
-	try {
-		parsed = YAML.parse(fileContents);
-	} catch (error) {
-		throw new RulesetLoadError(`Unable to parse YAML ruleset at ${resolvedPath}.`, { cause: error });
-	}
-	return normalizeRulesetDefinition(parsed);
-};
-const loadModuleRuleset = async (resolvedPath) => {
-	let imported;
-	try {
-		imported = await import(pathToFileURL(resolvedPath).href);
-	} catch (error) {
-		throw new RulesetLoadError(`Unable to import module ruleset at ${resolvedPath}.`, { cause: error });
-	}
-	const resolvedRuleset = resolveModuleRulesetValue(imported);
-	if (resolvedRuleset === void 0) throw new RulesetLoadError(`Module ruleset at ${resolvedPath} must export a ruleset as the default export or a named "ruleset" export.`);
-	return normalizeRulesetDefinition(resolvedRuleset, {
-		...functionMap,
-		...resolveModuleFunctions(imported)
-	});
-};
-const resolveModuleRulesetValue = (imported) => {
-	if (!isRecord$1(imported)) return;
-	if ("default" in imported) return imported.default;
-	if ("ruleset" in imported) return imported.ruleset;
-};
-const resolveModuleFunctions = (imported) => {
-	if (!isRecord$1(imported) || !("functions" in imported)) return {};
-	const { functions } = imported;
-	if (!isRecord$1(functions)) throw new RulesetLoadError("Module ruleset \"functions\" export must be an object map of function names to Spectral functions.");
-	const entries = Object.entries(functions).filter(([, value]) => typeof value === "function");
-	return Object.fromEntries(entries);
-};
-const isYamlRulesetPath = (value) => value.endsWith(".yaml") || value.endsWith(".yml");
-const isModuleRulesetPath = (value) => value.endsWith(".js") || value.endsWith(".mjs") || value.endsWith(".cjs") || value.endsWith(".ts") || value.endsWith(".mts") || value.endsWith(".cts");
-const normalizeRulesetDefinition = (input, availableFunctions = functionMap) => {
-	if (!isRecord$1(input)) throw new RulesetLoadError("Ruleset must be an object.");
-	const normalized = { ...input };
-	if ("extends" in normalized) normalized.extends = normalizeExtends(normalized.extends);
-	if ("rules" in normalized) normalized.rules = normalizeRules(normalized.rules, availableFunctions);
-	return normalized;
-};
-const mergeRuleEntry = (base, override) => {
-	if (!isRecord$1(override)) return override;
-	if ("given" in override || "then" in override) return override;
-	if (isRecord$1(base) && ("given" in base || "then" in base)) return {
-		...base,
-		...override
-	};
-	const keys = Object.keys(override);
-	if (keys.length === 1 && keys[0] === "severity") return override.severity;
-	return override;
-};
-const mergeRulesets = (baseRuleset, overrideRuleset) => {
-	const mergedBase = baseRuleset;
-	const mergedOverride = overrideRuleset;
-	const baseRules = isRecord$1(mergedBase.rules) ? mergedBase.rules : {};
-	const overrideRules = isRecord$1(mergedOverride.rules) ? mergedOverride.rules : {};
-	const mergedRules = { ...baseRules };
-	for (const [name, overrideRule] of Object.entries(overrideRules)) mergedRules[name] = mergeRuleEntry(baseRules[name], overrideRule);
-	const baseExtends = toExtendsArray(mergedBase.extends);
-	const overrideExtends = toExtendsArray(mergedOverride.extends);
-	const mergedExtends = [...baseExtends, ...overrideExtends];
-	const merged = {
-		...mergedBase,
-		...mergedOverride
-	};
-	delete merged.extends;
-	delete merged.rules;
-	if (mergedExtends.length > 0) merged.extends = mergedExtends;
-	if (Object.keys(mergedRules).length > 0) merged.rules = mergedRules;
-	return merged;
-};
-const toExtendsArray = (value) => {
-	if (value === void 0) return [];
-	return Array.isArray(value) ? [...value] : [value];
-};
-const normalizeExtends = (value) => {
-	if (typeof value === "string") return resolveExtendsEntry(value);
-	if (!Array.isArray(value)) return value;
-	return value.map((entry) => {
-		if (typeof entry === "string") return resolveExtendsEntry(entry);
-		if (Array.isArray(entry) && entry.length >= 1 && typeof entry[0] === "string") return [resolveExtendsEntry(entry[0]), entry[1]];
-		return entry;
-	});
-};
-const resolveExtendsEntry = (value) => {
-	const resolved = extendsMap[value];
-	if (!resolved) throw new RulesetLoadError(`Unsupported ruleset extend target: "${value}". Supported extend targets: spectral:oas.`);
-	return resolved;
-};
-const normalizeRules = (value, availableFunctions) => {
-	if (!isRecord$1(value)) return value;
-	const entries = Object.entries(value).map(([ruleName, ruleValue]) => [ruleName, normalizeRule(ruleValue, availableFunctions)]);
-	return Object.fromEntries(entries);
-};
-const normalizeRule = (value, availableFunctions) => {
-	if (!isRecord$1(value)) return value;
-	const normalized = { ...value };
-	if ("then" in normalized) normalized.then = normalizeThen(normalized.then, availableFunctions);
-	return normalized;
-};
-const normalizeThen = (value, availableFunctions) => {
-	if (Array.isArray(value)) return value.map((entry) => normalizeThenEntry(entry, availableFunctions));
-	return normalizeThenEntry(value, availableFunctions);
-};
-const normalizeThenEntry = (value, availableFunctions) => {
-	if (!isRecord$1(value)) return value;
-	const normalized = { ...value };
-	if (typeof normalized.function === "string") {
-		const resolved = availableFunctions[normalized.function];
-		if (!resolved) throw new RulesetLoadError(`Unsupported Spectral function: ${String(normalized.function)}.`);
-		normalized.function = resolved;
-	}
-	return normalized;
-};
-const isRecord$1 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-//#endregion
+import YAML from "yaml";
+import { pathToFileURL } from "node:url";
 //#region src/output/terminal-format.ts
 const severityStyles = {
 	error: [
@@ -847,6 +411,11 @@ const toSarifArtifactUri = (value) => {
 };
 //#endregion
 //#region src/output/sinks.ts
+const relativiseArtifactPath = (artifactPath) => {
+	const resolvedPath = path.resolve(process.cwd(), artifactPath);
+	const relativePath = path.relative(process.cwd(), resolvedPath);
+	return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+};
 const createOutputSinks = (options) => {
 	const reporter = resolveReporter(options.logger);
 	const sinks = [];
@@ -857,24 +426,17 @@ const createOutputSinks = (options) => {
 	if (configuredSpecSnapshotPath) sinks.push({
 		name: "spec snapshot",
 		kind: "artifact",
+		phase: "pre-finalize",
 		async write(_result, context) {
 			const writtenSpecSnapshotPath = await writeSpecSnapshot(configuredSpecSnapshotPath === true ? await resolveDefaultSpecSnapshotPath() : configuredSpecSnapshotPath, context.spec, options.output?.pretty !== false);
 			reporter.artifact(`OpenAPI lint wrote spec snapshot to ${writtenSpecSnapshotPath}.`);
 			return { specSnapshotPath: writtenSpecSnapshotPath };
 		}
 	});
-	if (configuredJsonReportPath) sinks.push({
-		name: "JSON report",
-		kind: "artifact",
-		async write(result) {
-			const writtenJsonReportPath = await writeJsonReport(configuredJsonReportPath, result, options.output?.pretty !== false);
-			reporter.artifact(`OpenAPI lint wrote JSON report to ${writtenJsonReportPath}.`);
-			return { jsonReportPath: writtenJsonReportPath };
-		}
-	});
 	if (configuredJunitReportPath) sinks.push({
 		name: "JUnit report",
 		kind: "artifact",
+		phase: "pre-finalize",
 		async write(result) {
 			const writtenJunitReportPath = await writeJunitReport(configuredJunitReportPath, result);
 			reporter.artifact(`OpenAPI lint wrote JUnit report to ${writtenJunitReportPath}.`);
@@ -885,6 +447,7 @@ const createOutputSinks = (options) => {
 	if (configuredBrunoCollectionPath) sinks.push({
 		name: "Bruno collection",
 		kind: "artifact",
+		phase: "pre-finalize",
 		async write(_result, context) {
 			const writtenPath = await writeBrunoCollection(configuredBrunoCollectionPath, context.spec);
 			reporter.artifact(`OpenAPI lint wrote Bruno collection to ${writtenPath}.`);
@@ -894,6 +457,7 @@ const createOutputSinks = (options) => {
 	if (configuredSarifReportPath) sinks.push({
 		name: "SARIF report",
 		kind: "artifact",
+		phase: "pre-finalize",
 		async write(result) {
 			const writtenSarifReportPath = await writeSarifReport(configuredSarifReportPath, result, options.output?.pretty !== false);
 			reporter.artifact(`OpenAPI lint wrote SARIF report to ${writtenSarifReportPath}.`);
@@ -903,11 +467,29 @@ const createOutputSinks = (options) => {
 	for (const sink of options.output?.sinks ?? []) sinks.push({
 		name: sink.name,
 		kind: "custom",
+		phase: "post-finalize",
 		write: async (result, context) => await Promise.resolve(sink.write(result, context))
 	});
+	if (configuredJsonReportPath) sinks.push({
+		name: "JSON report",
+		kind: "artifact",
+		phase: "post-finalize",
+		async write(result) {
+			const writtenJsonReportPath = await writeJsonReport(configuredJsonReportPath, {
+				...result,
+				artifacts: {
+					...result.artifacts ?? {},
+					jsonReportPath: relativiseArtifactPath(configuredJsonReportPath)
+				}
+			}, options.output?.pretty !== false);
+			reporter.artifact(`OpenAPI lint wrote JSON report to ${writtenJsonReportPath}.`);
+			return { jsonReportPath: writtenJsonReportPath };
+		}
+	});
 	if (options.output?.console !== false) sinks.push({
 		name: "console",
 		kind: "report",
+		phase: "post-finalize",
 		async write(result) {
 			reportToConsole(result, reporter);
 		}
@@ -915,133 +497,6 @@ const createOutputSinks = (options) => {
 	return sinks;
 };
 //#endregion
-//#region src/presets/server.ts
-const { schema: schema$1, truthy: truthy$1 } = spectralFunctions;
-const { oas: oas$1 } = spectralRulesets;
-const operationSelector$1 = "$.paths[*][get,put,post,delete,options,head,patch,trace]";
-/**
-* Production API quality preset. Suitable as a CI gate for teams shipping
-* public or internal APIs where contract quality matters.
-*
-* Tightens recommended:
-* - elysia-operation-summary and elysia-operation-tags escalated to error
-* - operation-description, operation-operationId, operation-success-response at warn
-* - oas3-api-servers at warn (servers should be declared in production specs)
-*/
-const server = {
-	extends: [[oas$1, "recommended"]],
-	rules: {
-		"oas3-api-servers": "warn",
-		"info-contact": "off",
-		"elysia-operation-summary": {
-			description: "Operations should define a summary for generated docs and clients.",
-			severity: "error",
-			given: operationSelector$1,
-			then: {
-				field: "summary",
-				function: truthy$1
-			}
-		},
-		"elysia-operation-tags": {
-			description: "Operations should declare at least one tag for grouping and downstream tooling.",
-			severity: "error",
-			given: operationSelector$1,
-			then: {
-				field: "tags",
-				function: schema$1,
-				functionOptions: { schema: {
-					type: "array",
-					minItems: 1
-				} }
-			}
-		},
-		"operation-description": "warn",
-		"operation-operationId": "warn",
-		"operation-success-response": "warn"
-	}
-};
-//#endregion
-//#region src/presets/strict.ts
-const { schema, truthy } = spectralFunctions;
-const { oas } = spectralRulesets;
-const operationSelector = "$.paths[*][get,put,post,delete,options,head,patch,trace]";
-const isRecord = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
-/**
-* Checks that all 4xx/5xx responses declare application/problem+json as
-* their content type, conforming to RFC 9457 Problem Details for HTTP APIs.
-*/
-const checkProblemDetails = (operation) => {
-	if (!isRecord(operation) || !isRecord(operation.responses)) return;
-	const results = [];
-	for (const [statusCode, response] of Object.entries(operation.responses)) {
-		const code = Number(statusCode);
-		if (!Number.isFinite(code) || code < 400) continue;
-		if (!isRecord(response)) continue;
-		const content = response.content;
-		if (!isRecord(content) || !("application/problem+json" in content)) results.push({
-			message: `${statusCode} error response should use "application/problem+json" content type (RFC 9457 Problem Details).`,
-			path: ["responses", statusCode]
-		});
-	}
-	return results.length > 0 ? results : void 0;
-};
-/**
-* Full API governance preset. Suitable for teams with formal API governance
-* requirements, public API programs, or downstream client generation pipelines.
-*
-* Tightens server:
-* - All elysia rules and operation metadata rules escalated to error
-* - info-contact at warn (API ownership should be declared)
-* - oas3-api-servers at error (server declaration is required)
-* - rfc9457-problem-details at warn (error responses should use Problem Details)
-*/
-const strict = {
-	extends: [[oas, "recommended"]],
-	rules: {
-		"oas3-api-servers": "error",
-		"info-contact": "warn",
-		"elysia-operation-summary": {
-			description: "Operations should define a summary for generated docs and clients.",
-			severity: "error",
-			given: operationSelector,
-			then: {
-				field: "summary",
-				function: truthy
-			}
-		},
-		"elysia-operation-tags": {
-			description: "Operations should declare at least one tag for grouping and downstream tooling.",
-			severity: "error",
-			given: operationSelector,
-			then: {
-				field: "tags",
-				function: schema,
-				functionOptions: { schema: {
-					type: "array",
-					minItems: 1
-				} }
-			}
-		},
-		"operation-description": "error",
-		"operation-operationId": "error",
-		"operation-success-response": "error",
-		"rfc9457-problem-details": {
-			description: "Error responses (4xx, 5xx) should use RFC 9457 Problem Details (application/problem+json).",
-			message: "{{error}}",
-			severity: "warn",
-			given: operationSelector,
-			then: { function: checkProblemDetails }
-		}
-	}
-};
-//#endregion
-//#region src/presets/index.ts
-const presets = {
-	recommended,
-	server,
-	strict
-};
-//#endregion
 //#region src/providers/spec-provider.ts
 var BaseSpecProvider = class {
 	constructor(app, options = {}) {
@@ -1078,11 +533,11 @@ var PublicSpecProvider = class extends BaseSpecProvider {
 			if (response.ok) return await parseSpecResponse(response, sourceLabel, this.specPath);
 			if (this.options?.baseUrl) return await this.fetchViaLoopback();
 			const body = await safeReadBody(response);
-			throw new PublicSpecProviderError([`Unable to load OpenAPI JSON from ${this.specPath} via ${sourceLabel}: received ${describeResponse(response)}${body ? ` with body ${body}.` : "."}`, `Fix: ensure @elysiajs/openapi is mounted and exposing "${this.specPath}", or update source.specPath to the correct OpenAPI JSON route.`].join(" "));
+			throw new PublicSpecProviderError([`Unable to load OpenAPI JSON from ${this.specPath} via ${sourceLabel}: received ${describeResponse(response)}${body ? ` with body ${body}.` : "."}`, `Fix: ensure an OpenAPI generator (for example @elysiajs/openapi) is installed and mounted so it exposes "${this.specPath}", or update source.specPath to the correct OpenAPI JSON route.`].join(" "));
 		} catch (error) {
 			if (this.options?.baseUrl) return await this.fetchViaLoopback(error);
 			if (error instanceof PublicSpecProviderError) throw error;
-			throw new PublicSpecProviderError([`Unable to resolve OpenAPI JSON from ${this.specPath} via ${sourceLabel}.`, "Fix: ensure the app can serve the configured OpenAPI JSON route, or set source.baseUrl if the document is only reachable over HTTP."].join(" "), { cause: error });
+			throw new PublicSpecProviderError([`Unable to resolve OpenAPI JSON from ${this.specPath} via ${sourceLabel}.`, "Fix: ensure the app mounts an OpenAPI generator (for example @elysiajs/openapi) or otherwise serves the configured OpenAPI JSON route, or set source.baseUrl if the document is only reachable over HTTP."].join(" "), { cause: error });
 		}
 	}
 	async fetchViaLoopback(cause) {
@@ -1192,7 +647,13 @@ const createOpenApiLintRuntime = (options = {}) => {
 				reporter.start("OpenAPI lint started.");
 				try {
 					const spec = await new PublicSpecProvider(app, options.source).getSpec();
-					const loadedRuleset = await loadResolvedRuleset(options.ruleset, { ...options.preset ? { defaultRuleset: presets[options.preset] } : {} });
+					const [{ lintOpenApi }, { loadResolvedRuleset }, presetsModule] = await Promise.all([
+						import("./lint-openapi-D76sC7S5.mjs").then((n) => n.n),
+						import("./load-ruleset-CiikrzWx.mjs").then((n) => n.i),
+						options.preset ? import("./presets-CCfU_diN.mjs").then((n) => n.n) : Promise.resolve(null)
+					]);
+					const defaultRuleset = options.preset ? presetsModule?.presets[options.preset] : void 0;
+					const loadedRuleset = await loadResolvedRuleset(options.ruleset, { ...defaultRuleset ? { defaultRuleset } : {} });
 					if (loadedRuleset.source?.autodiscovered) {
 						const base = options.preset ? `"${options.preset}" preset` : "package default ruleset";
 						reporter.ruleset(`OpenAPI lint autodiscovered ruleset ${loadedRuleset.source.path} and merged it with the ${base}.`);
@@ -1202,10 +663,12 @@ const createOpenApiLintRuntime = (options = {}) => {
 					result.source = source;
 					result.failOn = options.failOn ?? "error";
 					result.ok = !shouldFail(result, result.failOn);
-					await writeOutputSinks(result, spec, options, artifactWriteFailureMode);
-					runtime.latest = result;
+					const { preFinalizeSinks, postFinalizeSinks } = partitionOutputSinks(createOutputSinks(options));
+					await writeOutputSinks(preFinalizeSinks, result, spec, reporter, artifactWriteFailureMode);
 					finalizeRuntimeRun(runtime, startedAt);
 					result.durationMs = runtime.durationMs;
+					await writeOutputSinks(postFinalizeSinks, result, spec, reporter, artifactWriteFailureMode);
+					runtime.latest = result;
 					reporter.complete("OpenAPI lint completed.");
 					enforceThreshold(result, options.failOn ?? "error");
 					runtime.status = "passed";
@@ -1251,9 +714,7 @@ const handleArtifactWriteFailure = (artifact, error, mode, reporter) => {
 	if (mode === "error") throw wrappedError;
 	reporter.warn(wrappedError.message);
 };
-const writeOutputSinks = async (result, spec, options, artifactWriteFailureMode) => {
-	const reporter = resolveReporter(options.logger);
-	const sinks = createOutputSinks(options);
+const writeOutputSinks = async (sinks, result, spec, reporter, artifactWriteFailureMode) => {
 	for (const sink of sinks) try {
 		const artifacts = await sink.write(result, {
 			spec,
@@ -1268,6 +729,21 @@ const writeOutputSinks = async (result, spec, options, artifactWriteFailureMode)
 		throw error;
 	}
 };
+const partitionOutputSinks = (sinks) => {
+	const preFinalizeSinks = [];
+	const postFinalizeSinks = [];
+	for (const sink of sinks) {
+		if (sink.phase === "post-finalize") {
+			postFinalizeSinks.push(sink);
+			continue;
+		}
+		preFinalizeSinks.push(sink);
+	}
+	return {
+		preFinalizeSinks,
+		postFinalizeSinks
+	};
+};
 const relativiseArtifacts = (artifacts) => {
 	const cwd = process.cwd();
 	const result = {};
@@ -1287,4 +763,4 @@ const resolveStartupMode = (options = {}) => {
 	return options.enabled === false ? "off" : "enforce";
 };
 //#endregion
-export { enforceThreshold as a, strict as c, RulesetLoadError as d, defaultRulesetResolvers as f, lintOpenApi as g, recommended as h, OpenApiLintThresholdError as i, server as l, loadRuleset as m, createOpenApiLintRuntime as n, shouldFail as o, loadResolvedRuleset as p, resolveStartupMode as r, presets as s, OpenApiLintArtifactWriteError as t, resolveReporter as u };
+export { enforceThreshold as a, OpenApiLintThresholdError as i, createOpenApiLintRuntime as n, shouldFail as o, resolveStartupMode as r, resolveReporter as s, OpenApiLintArtifactWriteError as t };