@opsydyn/elysia-spectral 0.3.0 → 0.5.1

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [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)
+
+
+### Features
+
+* add source metadata to LintRunResult ([bdd5a81](https://github.com/opsydyn/elysia-spectral/commit/bdd5a817c00b5fdccf4e1d27c8dbf4c6d4c36d2c))
+
 ## [0.3.0](https://github.com/opsydyn/elysia-spectral/compare/v0.2.5...v0.3.0) (2026-04-14)
 
 

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
 
@@ -426,29 +429,177 @@ spectralPlugin({
 
 Use `'warn'` for local development and `'error'` when artifact generation is required.
 
-### Run the runtime in CI or tests
+### Run the runtime in CI
+
+Use `createOpenApiLintRuntime` to run a standalone lint check in CI without starting an HTTP server. Import your Elysia app instance directly — the runtime uses `app.handle()` in-process to retrieve the generated OpenAPI document. No port binding required.
+
+Create a script at `scripts/lint-openapi.ts`:
 
 ```ts
-import { Elysia } from 'elysia'
-import { openapi } from '@elysiajs/openapi'
+import { app } from '../src/app'
 import { createOpenApiLintRuntime } from '@opsydyn/elysia-spectral'
 
-const app = new Elysia().use(openapi())
-
 const runtime = createOpenApiLintRuntime({
-  ruleset: './spectral.yaml',
+  preset: 'strict',
   failOn: 'error',
   output: {
     console: true,
-    jsonReportPath: './artifacts/openapi-lint.json',
-    specSnapshotPath: true,
-    artifactWriteFailures: 'error'
+    sarifReportPath: './reports/openapi.sarif',
+    junitReportPath: './reports/openapi.junit.xml',
+    specSnapshotPath: './reports/openapi-snapshot.json',
+    artifactWriteFailures: 'error',
+  },
+})
+
+try {
+  await runtime.run(app)
+  process.exit(0)
+} catch {
+  process.exit(1)
+}
+```
+
+Run it as a CI step:
+
+```yaml
+- name: Lint OpenAPI spec
+  run: bun scripts/lint-openapi.ts
+```
+
+### Integrate SARIF with GitHub code scanning
+
+SARIF output maps lint findings to code locations and surfaces them as GitHub code scanning alerts on pull requests.
+
+```yaml
+- name: Lint OpenAPI spec
+  run: bun scripts/lint-openapi.ts
+
+- name: Upload SARIF to GitHub code scanning
+  uses: github/codeql-action/upload-sarif@v3
+  with:
+    sarif_file: reports/openapi.sarif
+  if: always()
+```
+
+`if: always()` ensures the SARIF upload runs even when the lint step fails, so findings are visible on failing PRs.
+
+### Report lint findings as JUnit test results
+
+JUnit output lets CI systems that consume test XML (Buildkite, CircleCI, GitLab, GitHub via third-party actions) show lint findings alongside test results.
+
+```yaml
+- name: Lint OpenAPI spec
+  run: bun scripts/lint-openapi.ts
+
+- name: Publish lint results
+  uses: dorny/test-reporter@v1
+  with:
+    name: OpenAPI Lint
+    path: reports/openapi.junit.xml
+    reporter: java-junit
+  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.
+
+1. Generate and commit the initial snapshot:
+
+```bash
+bun scripts/lint-openapi.ts
+git add reports/openapi-snapshot.json
+git commit -m "chore: add openapi snapshot"
+```
+
+1. In CI, regenerate the snapshot and check for drift:
+
+```yaml
+- name: Lint OpenAPI spec
+  run: bun scripts/lint-openapi.ts
+
+- name: Check for snapshot drift
+  run: git diff --exit-code reports/openapi-snapshot.json
+```
+
+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 with openapi-ts
+
+Use the committed OpenAPI snapshot as input to [`openapi-ts`](https://openapi-ts.dev) to keep a generated TypeScript client in sync with the API surface.
+
+1. Install `openapi-ts`:
+
+```bash
+bun add -d @hey-api/openapi-ts
+```
+
+2. Add a codegen script to `package.json`:
+
+```json
+{
+  "scripts": {
+    "generate:client": "openapi-ts --input ./reports/openapi-snapshot.json --output ./src/generated/client --client @hey-api/client-fetch"
+  }
+}
+```
+
+3. Chain it after the lint step in CI:
+
+```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. The drift check ensures the committed client always matches the current spec.
+
 ### Work on this repository locally
 
 From the monorepo root:
@@ -492,6 +643,7 @@ type OpenApiLintArtifacts = {
   junitReportPath?: string
   sarifReportPath?: string
   specSnapshotPath?: string
+  brunoCollectionPath?: string
 }
 
 type OpenApiLintSink = {
@@ -535,6 +687,8 @@ type SpectralPluginOptions = {
     junitReportPath?: string
     sarifReportPath?: string
     specSnapshotPath?: string | true
+    /** .yml/.yaml → OpenCollection YAML (Bruno v3+), .json → Bruno collection JSON */
+    brunoCollectionPath?: string
     pretty?: boolean
     artifactWriteFailures?: ArtifactWriteFailureMode
     sinks?: OpenApiLintSink[]
@@ -606,6 +760,7 @@ Example successful response:
   "result": {
     "ok": true,
     "generatedAt": "2026-04-06T12:00:00.000Z",
+    "source": "startup",
     "summary": {
       "error": 0,
       "warn": 0,
@@ -642,7 +797,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.
@@ -691,4 +846,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-YZElrxnl.mjs";
-export { LoadResolvedRulesetOptions, LoadedRuleset, OpenApiLintArtifactWriteError, OpenApiLintThresholdError, ResolvedRulesetCandidate, RulesetLoadError, RulesetResolver, RulesetResolverContext, RulesetResolverInput, createOpenApiLintRuntime, defaultRulesetResolvers, enforceThreshold, exceedsThreshold, isEnabled, lintOpenApi, loadResolvedRuleset, loadRuleset, normalizeFindings, resolveStartupMode, shouldFail };
+import { _ as lintOpenApi, a as createOpenApiLintRuntime, c as LoadedRuleset, d as RulesetResolver, f as RulesetResolverContext, g as loadRuleset, h as loadResolvedRuleset, i as OpenApiLintArtifactWriteError, l as ResolvedRulesetCandidate, m as defaultRulesetResolvers, n as enforceThreshold, o as resolveStartupMode, p as RulesetResolverInput, r as shouldFail, s as LoadResolvedRulesetOptions, t as OpenApiLintThresholdError, u as RulesetLoadError } from "../index-B4fxn0G6.mjs";
+export { LoadResolvedRulesetOptions, LoadedRuleset, OpenApiLintArtifactWriteError, OpenApiLintThresholdError, ResolvedRulesetCandidate, RulesetLoadError, RulesetResolver, RulesetResolverContext, RulesetResolverInput, createOpenApiLintRuntime, defaultRulesetResolvers, enforceThreshold, lintOpenApi, loadResolvedRuleset, loadRuleset, resolveStartupMode, 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-DBjV7-E8.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, r as resolveStartupMode, t as OpenApiLintArtifactWriteError } from "../core-DTKNy6TU.mjs";
+export { OpenApiLintArtifactWriteError, OpenApiLintThresholdError, RulesetLoadError, createOpenApiLintRuntime, defaultRulesetResolvers, enforceThreshold, lintOpenApi, loadResolvedRuleset, loadRuleset, resolveStartupMode, shouldFail };

package/dist/{core-DBjV7-E8.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.",
@@ -53,6 +54,7 @@ const normalizeFindings = (diagnostics, spec) => {
 	return {
 		ok: summary.error === 0,
 		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		source: "manual",
 		summary,
 		findings
 	};
@@ -407,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) => {
@@ -668,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) => {
@@ -866,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",
@@ -1155,7 +1178,7 @@ const createOpenApiLintRuntime = (options = {}) => {
 		lastSuccess: null,
 		lastFailure: null,
 		running: false,
-		async run(app) {
+		async run(app, source = "manual") {
 			if (inFlight) return await inFlight;
 			inFlight = (async () => {
 				const startedAt = /* @__PURE__ */ new Date();
@@ -1174,6 +1197,8 @@ const createOpenApiLintRuntime = (options = {}) => {
 					} else if (options.preset && !loadedRuleset.source?.path) reporter.ruleset(`OpenAPI lint using "${options.preset}" preset.`);
 					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.");
@@ -1243,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-YZElrxnl.d.mts → index-B4fxn0G6.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
@@ -7,6 +7,7 @@ type SeverityThreshold = 'error' | 'warn' | 'info' | 'hint' | 'never';
 type LintSeverity = 'error' | 'warn' | 'info' | 'hint';
 type StartupLintMode = 'enforce' | 'report' | 'off';
 type OpenApiLintRuntimeStatus = 'idle' | 'running' | 'passed' | 'failed';
+type LintRunSource = 'startup' | 'healthcheck' | 'manual';
 type ArtifactWriteFailureMode = 'warn' | 'error';
 type SpectralLogger = {
   info: (message: string) => void;
@@ -18,6 +19,7 @@ type OpenApiLintArtifacts = {
   junitReportPath?: string;
   sarifReportPath?: string;
   specSnapshotPath?: string;
+  brunoCollectionPath?: string;
 };
 type OpenApiLintSinkContext = {
   spec: Record<string, unknown>;
@@ -40,6 +42,7 @@ type SpectralPluginOptions = {
     junitReportPath?: string;
     sarifReportPath?: string;
     specSnapshotPath?: string | true;
+    brunoCollectionPath?: string;
     pretty?: boolean;
     artifactWriteFailures?: ArtifactWriteFailureMode;
     sinks?: OpenApiLintSink[];
@@ -81,6 +84,7 @@ type LintFinding = {
 type LintRunResult = {
   ok: boolean;
   generatedAt: string;
+  source: LintRunSource;
   summary: {
     error: number;
     warn: number;
@@ -91,9 +95,6 @@ type LintRunResult = {
   artifacts?: OpenApiLintArtifacts;
   findings: LintFinding[];
 };
-interface SpecProvider {
-  getSpec(): Promise<unknown>;
-}
 type OpenApiLintRuntimeFailure = {
   name: string;
   message: string;
@@ -108,7 +109,7 @@ type OpenApiLintRuntime = {
   lastSuccess: LintRunResult | null;
   lastFailure: OpenApiLintRuntimeFailure | null;
   running: boolean;
-  run: (app: AnyElysia) => Promise<LintRunResult>;
+  run: (app: AnyElysia, source?: LintRunSource) => Promise<LintRunResult>;
 };
 //#endregion
 //#region src/core/lint-openapi.d.ts
@@ -149,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 {
@@ -159,7 +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
@@ -168,8 +165,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 { OpenApiLintSinkContext as A, LintRunResult as C, OpenApiLintRuntimeFailure as D, OpenApiLintRuntime as E, SpectralPluginOptions as F, StartupLintMode as I, SeverityThreshold as M, SpecProvider as N, OpenApiLintRuntimeStatus as O, SpectralLogger as P, LintFinding as S, OpenApiLintArtifacts 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, PresetName as j, OpenApiLintSink 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, LintSeverity as w, ArtifactWriteFailureMode as x, loadRuleset as y };
+export { SeverityThreshold as A, OpenApiLintArtifacts as C, OpenApiLintSink as D, OpenApiLintRuntimeStatus as E, SpectralPluginOptions as M, StartupLintMode as N, OpenApiLintSinkContext as O, LintSeverity as S, OpenApiLintRuntimeFailure as T, lintOpenApi as _, createOpenApiLintRuntime as a, LintRunResult as b, LoadedRuleset as c, RulesetResolver as d, RulesetResolverContext as f, loadRuleset as g, loadResolvedRuleset as h, OpenApiLintArtifactWriteError as i, SpectralLogger as j, PresetName as k, ResolvedRulesetCandidate as l, defaultRulesetResolvers as m, enforceThreshold as n, resolveStartupMode as o, RulesetResolverInput as p, shouldFail as r, LoadResolvedRulesetOptions as s, OpenApiLintThresholdError as t, RulesetLoadError as u, ArtifactWriteFailureMode as v, OpenApiLintRuntime as w, LintRunSource as x, LintFinding as y };

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { A as OpenApiLintSinkContext, C as LintRunResult, D as OpenApiLintRuntimeFailure, E as OpenApiLintRuntime, F as SpectralPluginOptions, I as StartupLintMode, M as SeverityThreshold, N as SpecProvider, O as OpenApiLintRuntimeStatus, P as SpectralLogger, S as LintFinding, T as OpenApiLintArtifacts, _ 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 PresetName, k as OpenApiLintSink, 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 LintSeverity, x as ArtifactWriteFailureMode, y as loadRuleset } from "./index-YZElrxnl.mjs";
+import { A as SeverityThreshold, C as OpenApiLintArtifacts, D as OpenApiLintSink, E as OpenApiLintRuntimeStatus, M as SpectralPluginOptions, N as StartupLintMode, O as OpenApiLintSinkContext, S as LintSeverity, T as OpenApiLintRuntimeFailure, _ as lintOpenApi, a as createOpenApiLintRuntime, b as LintRunResult, c as LoadedRuleset, d as RulesetResolver, f as RulesetResolverContext, g as loadRuleset, h as loadResolvedRuleset, i as OpenApiLintArtifactWriteError, j as SpectralLogger, k as PresetName, l as ResolvedRulesetCandidate, m as defaultRulesetResolvers, n as enforceThreshold, o as resolveStartupMode, p as RulesetResolverInput, r as shouldFail, s as LoadResolvedRulesetOptions, t as OpenApiLintThresholdError, u as RulesetLoadError, v as ArtifactWriteFailureMode, w as OpenApiLintRuntime, x as LintRunSource, y as LintFinding } from "./index-B4fxn0G6.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, 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, resolveStartupMode, 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-DBjV7-E8.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 = {}) => {
@@ -11,7 +11,7 @@ const spectralPlugin = (options = {}) => {
 		const startupMode = resolveStartupMode(options);
 		if (startupMode === "off") return;
 		try {
-			await runtime.run(app);
+			await runtime.run(app, "startup");
 		} catch (error) {
 			if (startupMode === "report" && error instanceof OpenApiLintThresholdError) {
 				reporter.report(`OpenAPI lint exceeded the "${options.failOn ?? "error"}" threshold, but startup is continuing because startup.mode is "report".`);
@@ -37,7 +37,7 @@ const spectralPlugin = (options = {}) => {
 			}
 			try {
 				const usedCache = !fresh && (runtime.latest !== null || runtime.running);
-				const result = usedCache ? runtime.latest ?? await runtime.run(currentApp) : await runtime.run(currentApp);
+				const result = usedCache ? runtime.latest ?? await runtime.run(currentApp, "healthcheck") : await runtime.run(currentApp, "healthcheck");
 				if (result === null) {
 					set.status = 500;
 					return {
@@ -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, resolveStartupMode, server, shouldFail, spectralPlugin, strict };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@opsydyn/elysia-spectral",
-  "version": "0.3.0",
+  "version": "0.5.1",
   "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"
   },