@opsydyn/elysia-spectral 0.4.0 → 0.5.2

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [0.5.2](https://github.com/opsydyn/elysia-spectral/compare/v0.5.1...v0.5.2) (2026-04-15)
+
+
+### Bug Fixes
+
+* replace export * with named exports in core/index.ts for stable public API ([d0ef1c9](https://github.com/opsydyn/elysia-spectral/commit/d0ef1c95618ecd5a83e8224f2ba831b226a7ab38))
+
+## [0.5.1](https://github.com/opsydyn/elysia-spectral/compare/v0.5.0...v0.5.1) (2026-04-15)
+
+
+### Bug Fixes
+
+* tighten public API surface and align LintRunResult.ok with threshold ([8ca3331](https://github.com/opsydyn/elysia-spectral/commit/8ca3331db59e5753d454e759730e3ecd931d2087))
+
+## [0.5.0](https://github.com/opsydyn/elysia-spectral/compare/v0.4.0...v0.5.0) (2026-04-15)
+
+
+### Features
+
+* add Bruno collection output via output.brunoCollectionPath ([45abcd6](https://github.com/opsydyn/elysia-spectral/commit/45abcd6225bd94098d5974a27ef2c7642614c77f))
+
 ## [0.4.0](https://github.com/opsydyn/elysia-spectral/compare/v0.3.0...v0.4.0) (2026-04-15)
 
 

package/README.md

@@ -49,6 +49,8 @@ Current package scope:
 
 - startup linting
 - threshold-based failure
+- first-party governance presets: `recommended`, `server`, `strict`
+- RFC 9457 Problem Details enforcement (strict preset)
 - repo-level and local rulesets
 - YAML, JS, TS, and in-memory rulesets
 - resolver pipeline for advanced ruleset loading
@@ -57,6 +59,7 @@ Current package scope:
 - JUnit report output
 - SARIF report output
 - OpenAPI snapshot output
+- Bruno collection output (OpenCollection YAML or JSON)
 - reusable runtime for CI and tests
 - opt-in healthcheck endpoint for cached and fresh runs
 
@@ -497,6 +500,47 @@ JUnit output lets CI systems that consume test XML (Buildkite, CircleCI, GitLab,
   if: always()
 ```
 
+### Generate a Bruno collection
+
+Export the generated OpenAPI spec as a Bruno collection. Bruno is an open-source API client — generated collections let your team test API endpoints without manual import steps.
+
+The output format is determined by the file extension:
+
+- `.yml` / `.yaml` — OpenCollection YAML (recommended, Bruno v3.0.0+)
+- `.json` — Bruno collection JSON (compatible with all Bruno versions)
+
+```ts
+// OpenCollection YAML — recommended
+spectralPlugin({
+  output: {
+    brunoCollectionPath: './bruno/collection.yml'
+  }
+})
+
+// Bruno JSON — for older Bruno versions
+spectralPlugin({
+  output: {
+    brunoCollectionPath: './bruno/collection.json'
+  }
+})
+```
+
+The collection is written after each lint run — at startup, on healthcheck, or in CI. Commit it alongside the spec snapshot so it stays in sync with the API surface.
+
+To regenerate in CI as part of your lint script:
+
+```ts
+const runtime = createOpenApiLintRuntime({
+  preset: 'strict',
+  output: {
+    specSnapshotPath: './reports/openapi-snapshot.json',
+    brunoCollectionPath: './bruno/collection.yml',
+  },
+})
+
+await runtime.run(app)
+```
+
 ### Track OpenAPI snapshot drift
 
 Commit the generated OpenAPI snapshot and use `git diff --exit-code` to detect when the API surface changes unexpectedly in a PR.
@@ -521,6 +565,43 @@ git commit -m "chore: add openapi snapshot"
 
 If the snapshot has changed, the CI step fails and the diff is visible in the logs. Deliberate API changes are acknowledged by updating the committed snapshot — accidental ones are caught before they ship.
 
+### Generate a typed client
+
+**If your consumer is a TypeScript project that can import from your Elysia app, use [Eden Treaty](https://elysiajs.com/eden/treaty/overview) instead.** It derives types directly from the app instance with no codegen, no snapshot, and no drift.
+
+```ts
+import { treaty } from '@elysiajs/eden'
+import type { App } from '../server'
+
+const client = treaty<App>('localhost:3000')
+// fully typed — zero codegen
+```
+
+For vendor-agnostic consumers — cross-repo TypeScript, non-TypeScript clients, or a published SDK — use the committed OpenAPI snapshot as input to [`openapi-ts`](https://openapi-ts.dev):
+
+```json
+{
+  "scripts": {
+    "generate:client": "openapi-ts --input ./reports/openapi-snapshot.json --output ./src/generated/client --client @hey-api/client-fetch"
+  }
+}
+```
+
+Chain it after the lint step in CI and guard against drift:
+
+```yaml
+- name: Lint OpenAPI spec
+  run: bun scripts/lint-openapi.ts
+
+- name: Generate typed client
+  run: bun run generate:client
+
+- name: Check for client drift
+  run: git diff --exit-code src/generated/client/
+```
+
+The lint gate runs first — if the spec is invalid the codegen step never runs.
+
 ### Work on this repository locally
 
 From the monorepo root:
@@ -551,63 +632,38 @@ That example uses `startup.mode: 'report'`, so the app still boots while the pac
 ### Package API
 
 ```ts
-type PresetName = 'recommended' | 'server' | 'strict'
+// ── Vocabulary types ──────────────────────────────────────────────────────────
 
+type PresetName = 'recommended' | 'server' | 'strict'
+type LintSeverity = 'error' | 'warn' | 'info' | 'hint'
 type SeverityThreshold = 'error' | 'warn' | 'info' | 'hint' | 'never'
-
 type StartupLintMode = 'enforce' | 'report' | 'off'
-
+type LintRunSource = 'startup' | 'healthcheck' | 'manual'
 type ArtifactWriteFailureMode = 'warn' | 'error'
+type OpenApiLintRuntimeStatus = 'idle' | 'running' | 'passed' | 'failed'
 
-type OpenApiLintArtifacts = {
-  jsonReportPath?: string
-  junitReportPath?: string
-  sarifReportPath?: string
-  specSnapshotPath?: string
-}
-
-type OpenApiLintSink = {
-  name: string
-  write: (
-    result: LintRunResult,
-    context: {
-      spec: Record<string, unknown>
-      logger: SpectralLogger
-    }
-  ) => undefined | Partial<OpenApiLintArtifacts> | Promise<undefined | Partial<OpenApiLintArtifacts>>
-}
-
-type RulesetResolver = (
-  input: string | RulesetDefinition | Record<string, unknown> | undefined,
-  context: {
-    baseDir: string
-    defaultRuleset: RulesetDefinition
-    mergeAutodiscoveredWithDefault: boolean
-  }
-) => Promise<LoadedRuleset | undefined>
-
-type LoadResolvedRulesetOptions = {
-  baseDir?: string
-  resolvers?: RulesetResolver[]
-  mergeAutodiscoveredWithDefault?: boolean
-  /** Override the base ruleset used for autodiscovery merging and the fallback when no ruleset is configured. */
-  defaultRuleset?: RulesetDefinition
-}
+// ── Plugin options ────────────────────────────────────────────────────────────
 
 type SpectralPluginOptions = {
   /** First-party governance preset. Sets the base ruleset and autodiscovery merge target. */
   preset?: PresetName
   /** Custom ruleset path, object, or inline definition. Merged on top of preset when both are set. */
   ruleset?: string | RulesetDefinition | Record<string, unknown>
+  /** Severity level at which the lint run is considered failed. Defaults to 'error'. */
   failOn?: SeverityThreshold
   healthcheck?: false | { path?: string }
   output?: {
+    /** Print findings to the console. Default: true. */
     console?: boolean
     jsonReportPath?: string
     junitReportPath?: string
     sarifReportPath?: string
+    /** true derives the path from the consuming app's package name. */
     specSnapshotPath?: string | true
+    /** .yml/.yaml → OpenCollection YAML (Bruno v3+), .json → Bruno collection JSON */
+    brunoCollectionPath?: string
     pretty?: boolean
+    /** Whether artifact write failures throw or warn. Default: 'warn'. */
     artifactWriteFailures?: ArtifactWriteFailureMode
     sinks?: OpenApiLintSink[]
   }
@@ -615,16 +671,160 @@ type SpectralPluginOptions = {
     specPath?: string
     baseUrl?: string
   }
-  enabled?: boolean | ((env: Record<string, string | undefined>) => boolean)
+  /**
+   * Controls startup lint behaviour.
+   * startup.mode takes precedence over the legacy enabled option.
+   *   'enforce' — lint runs at startup and throws on threshold failure (default)
+   *   'report'  — lint runs at startup, prints findings, but never blocks boot
+   *   'off'     — startup lint is skipped entirely
+   */
   startup?: {
     mode?: StartupLintMode
   }
-  logger?: {
-    info: (message: string) => void
-    warn: (message: string) => void
-    error: (message: string) => void
+  /**
+   * Legacy enable flag. Prefer startup.mode for new code.
+   * false or () => false is equivalent to startup.mode: 'off'.
+   * The function form receives process.env for environment-based toggling.
+   */
+  enabled?: boolean | ((env: Record<string, string | undefined>) => boolean)
+  logger?: SpectralLogger
+}
+
+// ── Result types ──────────────────────────────────────────────────────────────
+
+type LintFinding = {
+  code: string
+  message: string
+  severity: LintSeverity
+  path: Array<string | number>
+  documentPointer?: string
+  recommendation?: string
+  source?: string
+  range?: {
+    start?: { line: number; character: number }
+    end?: { line: number; character: number }
+  }
+  operation?: {
+    method?: string
+    path?: string
+    operationId?: string
   }
 }
+
+type LintRunResult = {
+  /** True when no findings meet or exceed the configured failOn threshold. */
+  ok: boolean
+  generatedAt: string
+  /** Where the lint run was triggered from. */
+  source: LintRunSource
+  summary: {
+    error: number
+    warn: number
+    info: number
+    hint: number
+    total: number
+  }
+  artifacts?: OpenApiLintArtifacts
+  findings: LintFinding[]
+}
+
+type OpenApiLintArtifacts = {
+  jsonReportPath?: string
+  junitReportPath?: string
+  sarifReportPath?: string
+  specSnapshotPath?: string
+  brunoCollectionPath?: string
+}
+
+type OpenApiLintRuntimeFailure = {
+  name: string
+  message: string
+  generatedAt: string
+}
+
+// ── Runtime ───────────────────────────────────────────────────────────────────
+
+type OpenApiLintRuntime = {
+  status: OpenApiLintRuntimeStatus
+  startedAt: string | null
+  completedAt: string | null
+  durationMs: number | null
+  latest: LintRunResult | null
+  lastSuccess: LintRunResult | null
+  lastFailure: OpenApiLintRuntimeFailure | null
+  running: boolean
+  run: (app: AnyElysia, source?: LintRunSource) => Promise<LintRunResult>
+}
+
+function createOpenApiLintRuntime(options?: SpectralPluginOptions): OpenApiLintRuntime
+
+// ── Extension points (advanced) ───────────────────────────────────────────────
+
+type SpectralLogger = {
+  info: (message: string) => void
+  warn: (message: string) => void
+  error: (message: string) => void
+}
+
+type OpenApiLintSinkContext = {
+  spec: Record<string, unknown>
+  logger: SpectralLogger
+}
+
+type OpenApiLintSink = {
+  name: string
+  write: (
+    result: LintRunResult,
+    context: OpenApiLintSinkContext,
+  ) => undefined | Partial<OpenApiLintArtifacts> | Promise<undefined | Partial<OpenApiLintArtifacts>>
+}
+
+type RulesetResolver = (
+  input: string | RulesetDefinition | Record<string, unknown> | undefined,
+  context: RulesetResolverContext,
+) => Promise<ResolvedRulesetCandidate | undefined>
+
+type RulesetResolverContext = {
+  baseDir: string
+  defaultRuleset: RulesetDefinition
+  mergeAutodiscoveredWithDefault: boolean
+}
+
+type ResolvedRulesetCandidate = {
+  ruleset: unknown
+  source?: LoadedRuleset['source']
+}
+
+type LoadedRuleset = {
+  ruleset: RulesetDefinition
+  source?: {
+    path: string
+    autodiscovered: boolean
+    mergedWithDefault: boolean
+  }
+}
+
+type LoadResolvedRulesetOptions = {
+  baseDir?: string
+  resolvers?: RulesetResolver[]
+  mergeAutodiscoveredWithDefault?: boolean
+  /** Override the base ruleset used for autodiscovery merging and the fallback when no ruleset is configured. */
+  defaultRuleset?: RulesetDefinition
+}
+
+// ── Error classes ─────────────────────────────────────────────────────────────
+
+class OpenApiLintThresholdError extends Error {
+  readonly threshold: SeverityThreshold
+  readonly result: LintRunResult
+}
+
+class OpenApiLintArtifactWriteError extends Error {
+  readonly artifact: string
+  readonly cause: unknown
+}
+
+class RulesetLoadError extends Error {}
 ```
 
 ### Presets
@@ -715,7 +915,7 @@ Example successful response:
 
 The current output model has two layers:
 
-- convenience options such as `jsonReportPath`, `junitReportPath`, `specSnapshotPath`, and `sarifReportPath`
+- convenience options such as `jsonReportPath`, `junitReportPath`, `specSnapshotPath`, `sarifReportPath`, and `brunoCollectionPath`
 - sink abstractions under `output.sinks`
 
 The convenience options compile down to built-in sinks so the current API stays simple while the internal output model becomes extensible.
@@ -764,4 +964,4 @@ Production-grade linting needs more than a pass/fail boolean. The runtime tracks
 
 ### Project status
 
-This package currently implements the narrowed v0.1 scope from [project.md](../../project.md) and the ongoing hardening work tracked in [roadmap.md](../../roadmap.md).
+The package is actively developed toward a stable `v1`. Milestones 0.2 through 0.6 are complete. Ongoing work is tracked in [roadmap.md](../../roadmap.md).

package/dist/core/index.d.mts

@@ -1,2 +1,2 @@
-import { _ as defaultRulesetResolvers, a as OpenApiLintArtifactWriteError, b as lintOpenApi, c as resolveStartupMode, d as LoadedRuleset, f as ResolvedRulesetCandidate, g as RulesetResolverInput, h as RulesetResolverContext, i as shouldFail, l as normalizeFindings, m as RulesetResolver, n as enforceThreshold, o as createOpenApiLintRuntime, p as RulesetLoadError, r as exceedsThreshold, s as isEnabled, t as OpenApiLintThresholdError, u as LoadResolvedRulesetOptions, v as loadResolvedRuleset, y as loadRuleset } from "../index-CMyl_MsI.mjs";
-export { LoadResolvedRulesetOptions, LoadedRuleset, OpenApiLintArtifactWriteError, OpenApiLintThresholdError, ResolvedRulesetCandidate, RulesetLoadError, RulesetResolver, RulesetResolverContext, RulesetResolverInput, createOpenApiLintRuntime, defaultRulesetResolvers, enforceThreshold, exceedsThreshold, isEnabled, lintOpenApi, loadResolvedRuleset, loadRuleset, normalizeFindings, resolveStartupMode, shouldFail };
+import { a as createOpenApiLintRuntime, c as ResolvedRulesetCandidate, d as RulesetResolverContext, f as RulesetResolverInput, g as lintOpenApi, h as loadRuleset, i as OpenApiLintArtifactWriteError, l as RulesetLoadError, m as loadResolvedRuleset, n as enforceThreshold, o as LoadResolvedRulesetOptions, p as defaultRulesetResolvers, r as shouldFail, s as LoadedRuleset, t as OpenApiLintThresholdError, u as RulesetResolver } from "../index-11HnbLDN.mjs";
+export { LoadResolvedRulesetOptions, LoadedRuleset, OpenApiLintArtifactWriteError, OpenApiLintThresholdError, ResolvedRulesetCandidate, RulesetLoadError, RulesetResolver, RulesetResolverContext, RulesetResolverInput, createOpenApiLintRuntime, defaultRulesetResolvers, enforceThreshold, lintOpenApi, loadResolvedRuleset, loadRuleset, shouldFail };

package/dist/core/index.mjs

@@ -1,2 +1,2 @@
-import { a as OpenApiLintThresholdError, c as shouldFail, g as loadRuleset, h as loadResolvedRuleset, i as resolveStartupMode, m as defaultRulesetResolvers, n as createOpenApiLintRuntime, o as enforceThreshold, p as RulesetLoadError, r as isEnabled, s as exceedsThreshold, t as OpenApiLintArtifactWriteError, v as lintOpenApi, y as normalizeFindings } from "../core-D_ro1XEW.mjs";
-export { OpenApiLintArtifactWriteError, OpenApiLintThresholdError, RulesetLoadError, createOpenApiLintRuntime, defaultRulesetResolvers, enforceThreshold, exceedsThreshold, isEnabled, lintOpenApi, loadResolvedRuleset, loadRuleset, normalizeFindings, resolveStartupMode, shouldFail };
+import { a as enforceThreshold, d as RulesetLoadError, f as defaultRulesetResolvers, g as lintOpenApi, i as OpenApiLintThresholdError, m as loadRuleset, n as createOpenApiLintRuntime, o as shouldFail, p as loadResolvedRuleset, t as OpenApiLintArtifactWriteError } from "../core-DTKNy6TU.mjs";
+export { OpenApiLintArtifactWriteError, OpenApiLintThresholdError, RulesetLoadError, createOpenApiLintRuntime, defaultRulesetResolvers, enforceThreshold, lintOpenApi, loadResolvedRuleset, loadRuleset, shouldFail };

package/dist/{core-D_ro1XEW.mjs → core-DTKNy6TU.mjs}

@@ -7,6 +7,7 @@ import spectralRulesets from "@stoplight/spectral-rulesets";
 import YAML from "yaml";
 import signale from "signale";
 import { styleText } from "node:util";
+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.",
@@ -408,7 +409,7 @@ const normalizeExtends = (value) => {
 };
 const resolveExtendsEntry = (value) => {
 	const resolved = extendsMap[value];
-	if (!resolved) throw new RulesetLoadError(`Unsupported ruleset extend target: ${value}. v0.1 supports spectral:oas.`);
+	if (!resolved) throw new RulesetLoadError(`Unsupported ruleset extend target: "${value}". Supported extend targets: spectral:oas.`);
 	return resolved;
 };
 const normalizeRules = (value, availableFunctions) => {
@@ -669,6 +670,17 @@ const buildSpecReference = (finding, specSnapshotPath) => {
 	return `${specSnapshotPath}#${finding.documentPointer}`;
 };
 //#endregion
+//#region src/output/bruno-reporter.ts
+const isYamlPath = (filePath) => filePath.endsWith(".yml") || filePath.endsWith(".yaml");
+const writeBrunoCollection = async (outputPath, spec) => {
+	const resolvedPath = path.resolve(process.cwd(), outputPath);
+	const collection = openApiToBruno(spec);
+	const content = isYamlPath(outputPath) ? YAML.stringify(brunoToOpenCollection(collection)) : JSON.stringify(collection, null, 2);
+	await mkdir(path.dirname(resolvedPath), { recursive: true });
+	await writeFile(resolvedPath, content, "utf8");
+	return resolvedPath;
+};
+//#endregion
 //#region src/output/json-reporter.ts
 const DEFAULT_SPEC_SNAPSHOT_FILENAME = "open-api.json";
 const writeJsonArtifact = async (artifactPath, payload, pretty = true) => {
@@ -867,6 +879,16 @@ const createOutputSinks = (options) => {
 			return { junitReportPath: writtenJunitReportPath };
 		}
 	});
+	const configuredBrunoCollectionPath = options.output?.brunoCollectionPath;
+	if (configuredBrunoCollectionPath) sinks.push({
+		name: "Bruno collection",
+		kind: "artifact",
+		async write(_result, context) {
+			const writtenPath = await writeBrunoCollection(configuredBrunoCollectionPath, context.spec);
+			reporter.artifact(`OpenAPI lint wrote Bruno collection to ${writtenPath}.`);
+			return { brunoCollectionPath: writtenPath };
+		}
+	});
 	if (configuredSarifReportPath) sinks.push({
 		name: "SARIF report",
 		kind: "artifact",
@@ -1176,6 +1198,7 @@ const createOpenApiLintRuntime = (options = {}) => {
 					else if (loadedRuleset.source?.path) reporter.ruleset(`OpenAPI lint loaded ruleset ${loadedRuleset.source.path}.`);
 					const result = await lintOpenApi(spec, loadedRuleset.ruleset);
 					result.source = source;
+					result.ok = !shouldFail(result, options.failOn ?? "error");
 					await writeOutputSinks(result, spec, options, artifactWriteFailureMode);
 					runtime.latest = result;
 					reporter.complete("OpenAPI lint completed.");
@@ -1245,13 +1268,10 @@ const mergeArtifacts = (current, next) => ({
 	...current,
 	...next
 });
-const isEnabled = (options = {}) => {
-	return resolveStartupMode(options) !== "off";
-};
 const resolveStartupMode = (options = {}) => {
 	if (options.startup?.mode) return options.startup.mode;
 	if (typeof options.enabled === "function") return options.enabled(process.env) ? "enforce" : "off";
 	return options.enabled === false ? "off" : "enforce";
 };
 //#endregion
-export { recommended as _, OpenApiLintThresholdError as a, shouldFail as c, server as d, resolveReporter as f, loadRuleset as g, loadResolvedRuleset as h, resolveStartupMode as i, presets as l, defaultRulesetResolvers as m, createOpenApiLintRuntime as n, enforceThreshold as o, RulesetLoadError as p, isEnabled as r, exceedsThreshold as s, OpenApiLintArtifactWriteError as t, strict as u, lintOpenApi as v, normalizeFindings as y };
+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 };

package/dist/{index-CMyl_MsI.d.mts → index-11HnbLDN.d.mts}

@@ -1,4 +1,4 @@
-import { ISpectralDiagnostic, RulesetDefinition } from "@stoplight/spectral-core";
+import { RulesetDefinition } from "@stoplight/spectral-core";
 import { AnyElysia } from "elysia";
 
 //#region src/types.d.ts
@@ -19,6 +19,7 @@ type OpenApiLintArtifacts = {
   junitReportPath?: string;
   sarifReportPath?: string;
   specSnapshotPath?: string;
+  brunoCollectionPath?: string;
 };
 type OpenApiLintSinkContext = {
   spec: Record<string, unknown>;
@@ -41,6 +42,7 @@ type SpectralPluginOptions = {
     junitReportPath?: string;
     sarifReportPath?: string;
     specSnapshotPath?: string | true;
+    brunoCollectionPath?: string;
     pretty?: boolean;
     artifactWriteFailures?: ArtifactWriteFailureMode;
     sinks?: OpenApiLintSink[];
@@ -93,9 +95,6 @@ type LintRunResult = {
   artifacts?: OpenApiLintArtifacts;
   findings: LintFinding[];
 };
-interface SpecProvider {
-  getSpec(): Promise<unknown>;
-}
 type OpenApiLintRuntimeFailure = {
   name: string;
   message: string;
@@ -151,9 +150,6 @@ declare const loadRuleset: (input?: RulesetResolverInput, baseDirOrOptions?: str
 declare const loadResolvedRuleset: (input?: RulesetResolverInput, baseDirOrOptions?: string | LoadResolvedRulesetOptions) => Promise<LoadedRuleset>;
 declare const defaultRulesetResolvers: RulesetResolver[];
 //#endregion
-//#region src/core/normalize-findings.d.ts
-declare const normalizeFindings: (diagnostics: ISpectralDiagnostic[], spec: unknown) => LintRunResult;
-//#endregion
 //#region src/core/runtime.d.ts
 declare const createOpenApiLintRuntime: (options?: SpectralPluginOptions) => OpenApiLintRuntime;
 declare class OpenApiLintArtifactWriteError extends Error {
@@ -161,8 +157,6 @@ declare class OpenApiLintArtifactWriteError extends Error {
   readonly cause: unknown;
   constructor(artifact: string, cause: unknown);
 }
-declare const isEnabled: (options?: SpectralPluginOptions) => boolean;
-declare const resolveStartupMode: (options?: SpectralPluginOptions) => StartupLintMode;
 //#endregion
 //#region src/core/thresholds.d.ts
 declare class OpenApiLintThresholdError extends Error {
@@ -170,8 +164,7 @@ declare class OpenApiLintThresholdError extends Error {
   readonly result: LintRunResult;
   constructor(threshold: SeverityThreshold, result: LintRunResult);
 }
-declare const exceedsThreshold: (severity: LintSeverity, threshold: SeverityThreshold) => boolean;
 declare const shouldFail: (result: LintRunResult, threshold: SeverityThreshold) => boolean;
 declare const enforceThreshold: (result: LintRunResult, threshold: SeverityThreshold) => void;
 //#endregion
-export { OpenApiLintSink as A, LintRunResult as C, OpenApiLintRuntime as D, OpenApiLintArtifacts as E, SpectralLogger as F, SpectralPluginOptions as I, StartupLintMode as L, PresetName as M, SeverityThreshold as N, OpenApiLintRuntimeFailure as O, SpecProvider as P, LintFinding as S, LintSeverity as T, defaultRulesetResolvers as _, OpenApiLintArtifactWriteError as a, lintOpenApi as b, resolveStartupMode as c, LoadedRuleset as d, ResolvedRulesetCandidate as f, RulesetResolverInput as g, RulesetResolverContext as h, shouldFail as i, OpenApiLintSinkContext as j, OpenApiLintRuntimeStatus as k, normalizeFindings as l, RulesetResolver as m, enforceThreshold as n, createOpenApiLintRuntime as o, RulesetLoadError as p, exceedsThreshold as r, isEnabled as s, OpenApiLintThresholdError as t, LoadResolvedRulesetOptions as u, loadResolvedRuleset as v, LintRunSource as w, ArtifactWriteFailureMode as x, loadRuleset as y };
+export { SpectralLogger as A, OpenApiLintRuntime as C, OpenApiLintSinkContext as D, OpenApiLintSink as E, StartupLintMode as M, PresetName as O, OpenApiLintArtifacts as S, OpenApiLintRuntimeStatus as T, ArtifactWriteFailureMode as _, createOpenApiLintRuntime as a, LintRunSource as b, ResolvedRulesetCandidate as c, RulesetResolverContext as d, RulesetResolverInput as f, lintOpenApi as g, loadRuleset as h, OpenApiLintArtifactWriteError as i, SpectralPluginOptions as j, SeverityThreshold as k, RulesetLoadError as l, loadResolvedRuleset as m, enforceThreshold as n, LoadResolvedRulesetOptions as o, defaultRulesetResolvers as p, shouldFail as r, LoadedRuleset as s, OpenApiLintThresholdError as t, RulesetResolver as u, LintFinding as v, OpenApiLintRuntimeFailure as w, LintSeverity as x, LintRunResult as y };

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { A as OpenApiLintSink, C as LintRunResult, D as OpenApiLintRuntime, E as OpenApiLintArtifacts, F as SpectralLogger, I as SpectralPluginOptions, L as StartupLintMode, M as PresetName, N as SeverityThreshold, O as OpenApiLintRuntimeFailure, P as SpecProvider, S as LintFinding, T as LintSeverity, _ as defaultRulesetResolvers, a as OpenApiLintArtifactWriteError, b as lintOpenApi, c as resolveStartupMode, d as LoadedRuleset, f as ResolvedRulesetCandidate, g as RulesetResolverInput, h as RulesetResolverContext, i as shouldFail, j as OpenApiLintSinkContext, k as OpenApiLintRuntimeStatus, l as normalizeFindings, m as RulesetResolver, n as enforceThreshold, o as createOpenApiLintRuntime, p as RulesetLoadError, r as exceedsThreshold, s as isEnabled, t as OpenApiLintThresholdError, u as LoadResolvedRulesetOptions, v as loadResolvedRuleset, w as LintRunSource, x as ArtifactWriteFailureMode, y as loadRuleset } from "./index-CMyl_MsI.mjs";
+import { A as SpectralLogger, C as OpenApiLintRuntime, D as OpenApiLintSinkContext, E as OpenApiLintSink, M as StartupLintMode, O as PresetName, S as OpenApiLintArtifacts, T as OpenApiLintRuntimeStatus, _ as ArtifactWriteFailureMode, a as createOpenApiLintRuntime, b as LintRunSource, c as ResolvedRulesetCandidate, d as RulesetResolverContext, f as RulesetResolverInput, g as lintOpenApi, h as loadRuleset, i as OpenApiLintArtifactWriteError, j as SpectralPluginOptions, k as SeverityThreshold, l as RulesetLoadError, m as loadResolvedRuleset, n as enforceThreshold, o as LoadResolvedRulesetOptions, p as defaultRulesetResolvers, r as shouldFail, s as LoadedRuleset, t as OpenApiLintThresholdError, u as RulesetResolver, v as LintFinding, w as OpenApiLintRuntimeFailure, x as LintSeverity, y as LintRunResult } from "./index-11HnbLDN.mjs";
 import { RulesetDefinition } from "@stoplight/spectral-core";
 import { Elysia } from "elysia";
 
@@ -72,4 +72,4 @@ declare const strict: RulesetDefinition;
 //#region src/presets/index.d.ts
 declare const presets: Record<PresetName, RulesetDefinition>;
 //#endregion
-export { ArtifactWriteFailureMode, LintFinding, LintRunResult, LintRunSource, LintSeverity, LoadResolvedRulesetOptions, LoadedRuleset, OpenApiLintArtifactWriteError, OpenApiLintArtifacts, OpenApiLintRuntime, OpenApiLintRuntimeFailure, OpenApiLintRuntimeStatus, OpenApiLintSink, OpenApiLintSinkContext, OpenApiLintThresholdError, PresetName, ResolvedRulesetCandidate, RulesetLoadError, RulesetResolver, RulesetResolverContext, RulesetResolverInput, SeverityThreshold, SpecProvider, SpectralLogger, SpectralPluginOptions, StartupLintMode, createOpenApiLintRuntime, defaultRulesetResolvers, enforceThreshold, exceedsThreshold, isEnabled, lintOpenApi, loadResolvedRuleset, loadRuleset, normalizeFindings, presets, recommended, resolveStartupMode, server, shouldFail, spectralPlugin, strict };
+export { ArtifactWriteFailureMode, LintFinding, LintRunResult, LintRunSource, LintSeverity, LoadResolvedRulesetOptions, LoadedRuleset, OpenApiLintArtifactWriteError, OpenApiLintArtifacts, OpenApiLintRuntime, OpenApiLintRuntimeFailure, OpenApiLintRuntimeStatus, OpenApiLintSink, OpenApiLintSinkContext, OpenApiLintThresholdError, PresetName, ResolvedRulesetCandidate, RulesetLoadError, RulesetResolver, RulesetResolverContext, RulesetResolverInput, SeverityThreshold, SpectralLogger, SpectralPluginOptions, StartupLintMode, createOpenApiLintRuntime, defaultRulesetResolvers, enforceThreshold, lintOpenApi, loadResolvedRuleset, loadRuleset, presets, recommended, server, shouldFail, spectralPlugin, strict };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { _ as recommended, a as OpenApiLintThresholdError, c as shouldFail, d as server, f as resolveReporter, g as loadRuleset, h as loadResolvedRuleset, i as resolveStartupMode, l as presets, m as defaultRulesetResolvers, n as createOpenApiLintRuntime, o as enforceThreshold, p as RulesetLoadError, r as isEnabled, s as exceedsThreshold, t as OpenApiLintArtifactWriteError, u as strict, v as lintOpenApi, y as normalizeFindings } from "./core-D_ro1XEW.mjs";
+import { a as enforceThreshold, c as strict, d as RulesetLoadError, f as defaultRulesetResolvers, g as lintOpenApi, h as recommended, i as OpenApiLintThresholdError, l as server, m as loadRuleset, n as createOpenApiLintRuntime, o as shouldFail, p as loadResolvedRuleset, r as resolveStartupMode, s as presets, t as OpenApiLintArtifactWriteError, u as resolveReporter } from "./core-DTKNy6TU.mjs";
 import { Elysia } from "elysia";
 //#region src/plugin.ts
 const spectralPlugin = (options = {}) => {
@@ -82,4 +82,4 @@ const spectralPlugin = (options = {}) => {
 	return plugin;
 };
 //#endregion
-export { OpenApiLintArtifactWriteError, OpenApiLintThresholdError, RulesetLoadError, createOpenApiLintRuntime, defaultRulesetResolvers, enforceThreshold, exceedsThreshold, isEnabled, lintOpenApi, loadResolvedRuleset, loadRuleset, normalizeFindings, presets, recommended, resolveStartupMode, server, shouldFail, spectralPlugin, strict };
+export { OpenApiLintArtifactWriteError, OpenApiLintThresholdError, RulesetLoadError, createOpenApiLintRuntime, defaultRulesetResolvers, enforceThreshold, lintOpenApi, loadResolvedRuleset, loadRuleset, presets, recommended, server, shouldFail, spectralPlugin, strict };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@opsydyn/elysia-spectral",
-  "version": "0.4.0",
+  "version": "0.5.2",
   "description": "Thin Elysia plugin that lints generated OpenAPI documents with Spectral.",
-  "packageManager": "bun@1.2.9",
+  "packageManager": "bun@1.3.11",
   "publishConfig": {
     "access": "public"
   },
@@ -71,6 +71,8 @@
     "@stoplight/spectral-functions": "^1.10.2",
     "@stoplight/spectral-parsers": "^1.0.4",
     "@stoplight/spectral-rulesets": "^1.22.1",
+    "@usebruno/converters": "^0.18.1",
+    "@usebruno/lang": "^0.35.0",
     "signale": "^1.4.0",
     "yaml": "^2.8.1"
   },