@amritk/mjst 0.12.2 → 0.13.0

package/dist/lint/resolver.js

@@ -1,126 +1,93 @@
-import { readFileSync } from 'node:fs';
-import { resolve as resolvePath } from 'node:path';
-import { createDocument, DiagnosticSeverity, resolveSourceOriginFromMap, } from '@amritk/lint';
-import { resolveRefs, resolveRefsFromFile } from '@amritk/resolve-refs';
-import { parse as parseYaml } from '@amritk/yaml';
-import { hasExternalRefs } from '../has-external-refs.js';
+import { readFileSync } from "node:fs";
+import { resolve as resolvePath } from "node:path";
+import { createDocument, DiagnosticSeverity, resolveSourceOriginFromMap } from "@amritk/lint";
+import { resolveRefs, resolveRefsFromFile } from "@amritk/resolve-refs";
+import { parse as parseYaml } from "@amritk/yaml";
+import { hasExternalRefs } from "../has-external-refs.js";
 const isRemote = (location) => /^https?:\/\//i.test(location);
-/**
- * Parses a referenced document by extension: YAML for `.yaml`/`.yml`, JSON for
- * `.json`, and for anything else (extensionless, remote) tries JSON first, then
- * YAML. YAML is a JSON superset, so this accepts every document the linter does.
- */
 const parseDoc = (content, location) => {
-    if (/\.ya?ml$/i.test(location))
-        return parseYaml(content);
-    if (/\.json$/i.test(location))
-        return JSON.parse(content);
-    try {
-        return JSON.parse(content);
-    }
-    catch {
-        return parseYaml(content);
-    }
+  if (/\.ya?ml$/i.test(location))
+    return parseYaml(content);
+  if (/\.json$/i.test(location))
+    return JSON.parse(content);
+  try {
+    return JSON.parse(content);
+  } catch {
+    return parseYaml(content);
+  }
 };
-/** Whether the file at `absolute` reads back byte-for-byte as `input` (the document we linted). */
 const readsBackAs = (absolute, input) => {
-    try {
-        return readFileSync(absolute, 'utf8') === input;
-    }
-    catch {
-        return false;
-    }
+  try {
+    return readFileSync(absolute, "utf8") === input;
+  } catch {
+    return false;
+  }
 };
-/**
- * Builds the {@link ISourceSet} the runner uses to map a finding on a resolved
- * (dereferenced) node back to the file it came from. Origins from the resolver
- * attribute each inlined node to its source document + path; `get` lazily parses
- * each source file (with a position map) so findings on cross-file nodes report
- * that file's own `line:column`. The root document is already parsed by the
- * linter, so it is reused directly. Remote documents are not re-fetched here, so
- * a finding inlined from a URL falls back to the root document's position.
- */
 const buildSourceSet = (rootDocument, resolved, origins, rootLocation) => {
-    const documents = new Map([[rootLocation, rootDocument]]);
-    const originMap = origins ?? new Map();
-    const load = (location) => {
-        if (documents.has(location))
-            return documents.get(location);
-        let document;
-        if (location !== '' && !isRemote(location)) {
-            try {
-                document = createDocument(readFileSync(location, 'utf8'), { source: location });
-            }
-            catch {
-                document = undefined;
-            }
-        }
-        documents.set(location, document);
-        return document;
-    };
-    return {
-        get: load,
-        origin: (path) => resolveSourceOriginFromMap(resolved, originMap, rootLocation, path),
-    };
+  const documents = /* @__PURE__ */ new Map([[rootLocation, rootDocument]]);
+  const originMap = origins ?? /* @__PURE__ */ new Map();
+  const load = (location) => {
+    if (documents.has(location))
+      return documents.get(location);
+    let document;
+    if (location !== "" && !isRemote(location)) {
+      try {
+        document = createDocument(readFileSync(location, "utf8"), { source: location });
+      } catch {
+        document = void 0;
+      }
+    }
+    documents.set(location, document);
+    return document;
+  };
+  return {
+    get: load,
+    origin: (path) => resolveSourceOriginFromMap(resolved, originMap, rootLocation, path)
+  };
 };
-/** A zero-width range at the document start, for resolve errors with no recoverable position. */
 const DOCUMENT_START = { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } };
-/**
- * Maps resolver failures ({@link ResolveError}) into lint findings so an
- * unresolvable `$ref` — a typo'd pointer, a missing file, a refused/failed
- * remote fetch — surfaces as a diagnostic instead of being silently dropped. An
- * error carrying a JSON path is anchored to that node's position in the root
- * document (best effort, `closest`); otherwise the finding is document-level.
- */
 const toFindings = (errors, root) => errors.map((error) => {
-    const location = error.path.length > 0 ? root.getLocationForJsonPath(error.path, true) : undefined;
-    const finding = {
-        code: 'unresolved-ref',
-        message: error.message,
-        path: error.path,
-        severity: DiagnosticSeverity.Error,
-        range: location?.range ?? DOCUMENT_START,
-    };
-    if (root.source !== undefined)
-        finding.source = root.source;
-    return finding;
+  const location = error.path.length > 0 ? root.getLocationForJsonPath(error.path, true) : void 0;
+  const finding = {
+    code: "unresolved-ref",
+    message: error.message,
+    path: error.path,
+    severity: DiagnosticSeverity.Error,
+    range: location?.range ?? DOCUMENT_START
+  };
+  if (root.source !== void 0)
+    finding.source = root.source;
+  return finding;
 });
-/**
- * Builds a {@link LintResolver} backed by `@amritk/resolve-refs`, dereferencing
- * `$ref`, `$dynamicRef`/`$dynamicAnchor`, and `$recursiveRef`/`$recursiveAnchor`
- * so rules with `resolved: true` (the ruleset default) see through references.
- *
- * Internal-only documents resolve in memory. A document with cross-file/remote
- * refs is resolved from disk **only when its source file reads back exactly as
- * the linted input** — so a piped document (`--stdin-filepath`) never resolves
- * against a different on-disk file — with remote fetching gated by `options`.
- */
-export const createLintResolver = (options = {}) => {
-    const fromFileOptions = {
-        remote: options.remote ?? false,
-        ...(options.allowedHosts ? { allowedHosts: options.allowedHosts } : {}),
-        ...(options.allowPrivateHosts ? { allowPrivateHosts: options.allowPrivateHosts } : {}),
-        parse: parseDoc,
-        trackOrigins: true,
-    };
-    return async (document, { input }) => {
-        const { source } = document;
-        if (source && hasExternalRefs(document.data)) {
-            const absolute = resolvePath(source);
-            if (readsBackAs(absolute, input)) {
-                const { resolved, origins, errors } = await resolveRefsFromFile(absolute, fromFileOptions);
-                return {
-                    resolved,
-                    sources: buildSourceSet(document, resolved, origins, absolute),
-                    ...(errors.length > 0 ? { diagnostics: toFindings(errors, document) } : {}),
-                };
-            }
-        }
-        const { resolved, origins, errors } = resolveRefs(document.data, { trackOrigins: true });
+const createLintResolver = (options = {}) => {
+  const fromFileOptions = {
+    remote: options.remote ?? false,
+    ...options.allowedHosts ? { allowedHosts: options.allowedHosts } : {},
+    ...options.allowPrivateHosts ? { allowPrivateHosts: options.allowPrivateHosts } : {},
+    parse: parseDoc,
+    trackOrigins: true
+  };
+  return async (document, { input }) => {
+    const { source } = document;
+    if (source && hasExternalRefs(document.data)) {
+      const absolute = resolvePath(source);
+      if (readsBackAs(absolute, input)) {
+        const { resolved: resolved2, origins: origins2, errors: errors2 } = await resolveRefsFromFile(absolute, fromFileOptions);
         return {
-            resolved,
-            sources: buildSourceSet(document, resolved, origins, ''),
-            ...(errors.length > 0 ? { diagnostics: toFindings(errors, document) } : {}),
+          resolved: resolved2,
+          sources: buildSourceSet(document, resolved2, origins2, absolute),
+          ...errors2.length > 0 ? { diagnostics: toFindings(errors2, document) } : {}
         };
+      }
+    }
+    const { resolved, origins, errors } = resolveRefs(document.data, { trackOrigins: true });
+    return {
+      resolved,
+      sources: buildSourceSet(document, resolved, origins, ""),
+      ...errors.length > 0 ? { diagnostics: toFindings(errors, document) } : {}
     };
+  };
+};
+export {
+  createLintResolver
 };

package/dist/lint/ruleset-loader.js

@@ -1,31 +1,33 @@
-import { existsSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import { dirname, isAbsolute, join, resolve } from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { parseWithPointers } from '@amritk/lint';
-const RULESET_FILENAMES = ['.lint.yaml', '.lint.yml', '.lint.json', '.lint.js', '.lint.mjs'];
-/** Loads a ruleset definition from a YAML, JSON, or JS/MJS file. */
-export const loadRuleset = async (path) => {
-    const absolute = isAbsolute(path) ? path : resolve(process.cwd(), path);
-    if (/\.(c|m)?js$/.test(absolute)) {
-        const module = await import(pathToFileURL(absolute).href);
-        return (module.default ?? module);
-    }
-    const content = await readFile(absolute, 'utf8');
-    return parseWithPointers(content).data;
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { parseWithPointers } from "@amritk/lint";
+const RULESET_FILENAMES = [".lint.yaml", ".lint.yml", ".lint.json", ".lint.js", ".lint.mjs"];
+const loadRuleset = async (path) => {
+  const absolute = isAbsolute(path) ? path : resolve(process.cwd(), path);
+  if (/\.(c|m)?js$/.test(absolute)) {
+    const module = await import(pathToFileURL(absolute).href);
+    return module.default ?? module;
+  }
+  const content = await readFile(absolute, "utf8");
+  return parseWithPointers(content).data;
 };
-/** Walks up from a directory looking for a `.lint.*` ruleset file. */
-export const discoverRuleset = (startDir) => {
-    let dir = resolve(startDir);
-    while (true) {
-        for (const name of RULESET_FILENAMES) {
-            const candidate = join(dir, name);
-            if (existsSync(candidate))
-                return candidate;
-        }
-        const parent = dirname(dir);
-        if (parent === dir)
-            return undefined;
-        dir = parent;
+const discoverRuleset = (startDir) => {
+  let dir = resolve(startDir);
+  while (true) {
+    for (const name of RULESET_FILENAMES) {
+      const candidate = join(dir, name);
+      if (existsSync(candidate))
+        return candidate;
     }
+    const parent = dirname(dir);
+    if (parent === dir)
+      return void 0;
+    dir = parent;
+  }
+};
+export {
+  discoverRuleset,
+  loadRuleset
 };

package/dist/lint/run.js

@@ -1,208 +1,167 @@
-import { readFile } from 'node:fs/promises';
-import { dirname, isAbsolute, resolve } from 'node:path';
-import { DiagnosticSeverity, lintDocument, validateRuleset, } from '@amritk/lint';
-import fg from 'fast-glob';
-import yargs from 'yargs';
-import { createLintResolver } from './resolver.js';
-import { discoverRuleset, loadRuleset } from './ruleset-loader.js';
+import { readFile } from "node:fs/promises";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { DiagnosticSeverity, lintDocument, validateRuleset } from "@amritk/lint";
+import fg from "fast-glob";
+import yargs from "yargs";
+import { createLintResolver } from "./resolver.js";
+import { discoverRuleset, loadRuleset } from "./ruleset-loader.js";
 const SEVERITY_BY_NAME = {
-    error: DiagnosticSeverity.Error,
-    warn: DiagnosticSeverity.Warning,
-    info: DiagnosticSeverity.Information,
-    hint: DiagnosticSeverity.Hint,
+  error: DiagnosticSeverity.Error,
+  warn: DiagnosticSeverity.Warning,
+  info: DiagnosticSeverity.Information,
+  hint: DiagnosticSeverity.Hint
 };
-const SEVERITY_LABEL = ['error', 'warning', 'info', 'hint'];
-/**
- * Renders findings as a compact, dependency-free report — one `file:line:col`
- * line per finding (1-based, editor-clickable), then a count summary. Structured
- * output (JSON, SARIF, …) is a consumer concern: use the `@amritk/lint` library's
- * `lintDocument`, which returns `IDiagnostic[]`.
- */
+const SEVERITY_LABEL = ["error", "warning", "info", "hint"];
 const formatReport = (findings) => {
-    if (findings.length === 0)
-        return 'No problems found\n';
-    const lines = findings.map((d) => {
-        const loc = `${d.source ?? '<stdin>'}:${d.range.start.line + 1}:${d.range.start.character + 1}`;
-        return `${loc}  ${SEVERITY_LABEL[d.severity] ?? 'error'}  ${d.code}  ${d.message}`;
-    });
-    const errors = findings.filter((d) => d.severity === DiagnosticSeverity.Error).length;
-    const warnings = findings.filter((d) => d.severity === DiagnosticSeverity.Warning).length;
-    lines.push('', `✖ ${findings.length} problem(s) (${errors} error(s), ${warnings} warning(s))`);
-    return `${lines.join('\n')}\n`;
+  if (findings.length === 0)
+    return "No problems found\n";
+  const lines = findings.map((d) => {
+    const loc = `${d.source ?? "<stdin>"}:${d.range.start.line + 1}:${d.range.start.character + 1}`;
+    return `${loc}  ${SEVERITY_LABEL[d.severity] ?? "error"}  ${d.code}  ${d.message}`;
+  });
+  const errors = findings.filter((d) => d.severity === DiagnosticSeverity.Error).length;
+  const warnings = findings.filter((d) => d.severity === DiagnosticSeverity.Warning).length;
+  lines.push("", `\u2716 ${findings.length} problem(s) (${errors} error(s), ${warnings} warning(s))`);
+  return `${lines.join("\n")}
+`;
 };
 const readStdin = async () => {
-    const chunks = [];
-    for await (const chunk of process.stdin)
-        chunks.push(chunk);
-    return Buffer.concat(chunks).toString('utf8');
+  const chunks = [];
+  for await (const chunk of process.stdin)
+    chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
 };
 const filterBySeverity = (results, failSeverity) => results.filter((result) => result.severity <= failSeverity);
-/**
- * Maps `items` through `worker` with at most `limit` running at once, preserving
- * input order in the result. Lets the CLI lint a directory of documents
- * concurrently instead of strictly one at a time, without unbounded parallelism.
- */
 const mapWithConcurrency = async (items, limit, worker) => {
-    const results = new Array(items.length);
-    let next = 0;
-    const runners = new Array(Math.max(1, Math.min(limit, items.length))).fill(0).map(async () => {
-        while (true) {
-            const index = next++;
-            if (index >= items.length)
-                return;
-            results[index] = await worker(items[index]);
-        }
-    });
-    await Promise.all(runners);
-    return results;
+  const results = new Array(items.length);
+  let next = 0;
+  const runners = new Array(Math.max(1, Math.min(limit, items.length))).fill(0).map(async () => {
+    while (true) {
+      const index = next++;
+      if (index >= items.length)
+        return;
+      results[index] = await worker(items[index]);
+    }
+  });
+  await Promise.all(runners);
+  return results;
 };
-/**
- * Runs the linter over `argv`, returning the exit code and the text it would
- * print (rather than writing to the process streams) so it can be driven
- * in-process by tests. `stdin` supplies the piped document when there are no file
- * targets; when omitted it is read from `process.stdin`.
- */
-export const run = async (argv, options = {}) => {
-    const out = [];
-    const err = [];
-    const parsed = (await yargs(argv)
-        .scriptName('lint')
-        .parserConfiguration({ 'greedy-arrays': false })
-        .usage('$0 [documents..]', 'Lint JSON/YAML documents against a ruleset')
-        .positional('documents', { describe: 'Documents or globs to lint', type: 'string', array: true })
-        .option('ruleset', { alias: 'r', type: 'string', describe: 'Path to a ruleset file' })
-        .option('encoding', { type: 'string', default: 'utf8', describe: 'Input encoding' })
-        .option('fail-severity', { alias: 'F', type: 'string', default: 'error', choices: Object.keys(SEVERITY_BY_NAME) })
-        .option('display-only-failures', { alias: 'D', type: 'boolean', default: false })
-        .option('verbose', { type: 'boolean', default: false })
-        .option('quiet', { alias: 'q', type: 'boolean', default: false })
-        .option('stdin-filepath', {
-        type: 'string',
-        describe: 'Path to associate with stdin input (labels findings and enables ruleset discovery)',
-    })
-        .option('concurrency', {
-        type: 'number',
-        default: 8,
-        describe: 'Maximum number of documents to lint in parallel',
-    })
-        .option('resolve', {
-        type: 'boolean',
-        default: true,
-        describe: 'Dereference $ref / $dynamicRef / $recursiveRef before linting (use --no-resolve to disable)',
-    })
-        .option('resolve-remote', {
-        type: 'boolean',
-        default: false,
-        describe: 'Allow fetching http(s) $refs while resolving (off by default; a lint run stays offline)',
-    })
-        .option('allowed-hosts', {
-        type: 'string',
-        array: true,
-        describe: 'Restrict remote $ref fetches to these hosts (implies --resolve-remote)',
-    })
-        .option('allow-private-hosts', {
-        type: 'boolean',
-        default: false,
-        describe: 'Permit remote $refs to private/loopback hosts (SSRF guard, off by default)',
-    })
-        .help()
-        .alias('help', 'h')
-        .parse());
-    const failSeverity = SEVERITY_BY_NAME[parsed.failSeverity] ?? DiagnosticSeverity.Error;
-    // A non-empty --allowed-hosts is an explicit opt-in to remote fetching.
-    const allowRemote = parsed.resolveRemote || (parsed.allowedHosts?.length ?? 0) > 0;
-    const resolver = parsed.resolve
-        ? createLintResolver({
-            remote: allowRemote,
-            ...(parsed.allowedHosts ? { allowedHosts: parsed.allowedHosts } : {}),
-            allowPrivateHosts: parsed.allowPrivateHosts,
-        })
-        : undefined;
-    const reportRulesetProblems = (definition, label) => {
-        if (parsed.quiet)
-            return;
-        for (const problem of validateRuleset(definition)) {
-            const at = problem.path.length > 0 ? ` (at ${problem.path.join('.')})` : '';
-            err.push(`warning: ruleset ${label}: ${problem.message}${at}\n`);
-        }
-    };
-    const discoverAndLoad = async (dir) => {
-        const discovered = discoverRuleset(dir);
-        if (!discovered)
-            return undefined;
-        const definition = await loadRuleset(discovered);
-        reportRulesetProblems(definition, discovered);
-        return { definition, basePath: dirname(discovered) };
-    };
-    let rulesetDefinition;
-    let rulesetBasePath;
-    if (parsed.ruleset) {
-        rulesetDefinition = await loadRuleset(parsed.ruleset);
-        rulesetBasePath = dirname(isAbsolute(parsed.ruleset) ? parsed.ruleset : resolve(process.cwd(), parsed.ruleset));
-        reportRulesetProblems(rulesetDefinition, parsed.ruleset);
+const run = async (argv, options = {}) => {
+  const out = [];
+  const err = [];
+  const parsed = await yargs(argv).scriptName("lint").parserConfiguration({ "greedy-arrays": false }).usage("$0 [documents..]", "Lint JSON/YAML documents against a ruleset").positional("documents", { describe: "Documents or globs to lint", type: "string", array: true }).option("ruleset", { alias: "r", type: "string", describe: "Path to a ruleset file" }).option("encoding", { type: "string", default: "utf8", describe: "Input encoding" }).option("fail-severity", { alias: "F", type: "string", default: "error", choices: Object.keys(SEVERITY_BY_NAME) }).option("display-only-failures", { alias: "D", type: "boolean", default: false }).option("verbose", { type: "boolean", default: false }).option("quiet", { alias: "q", type: "boolean", default: false }).option("stdin-filepath", {
+    type: "string",
+    describe: "Path to associate with stdin input (labels findings and enables ruleset discovery)"
+  }).option("concurrency", {
+    type: "number",
+    default: 8,
+    describe: "Maximum number of documents to lint in parallel"
+  }).option("resolve", {
+    type: "boolean",
+    default: true,
+    describe: "Dereference $ref / $dynamicRef / $recursiveRef before linting (use --no-resolve to disable)"
+  }).option("resolve-remote", {
+    type: "boolean",
+    default: false,
+    describe: "Allow fetching http(s) $refs while resolving (off by default; a lint run stays offline)"
+  }).option("allowed-hosts", {
+    type: "string",
+    array: true,
+    describe: "Restrict remote $ref fetches to these hosts (implies --resolve-remote)"
+  }).option("allow-private-hosts", {
+    type: "boolean",
+    default: false,
+    describe: "Permit remote $refs to private/loopback hosts (SSRF guard, off by default)"
+  }).help().alias("help", "h").parse();
+  const failSeverity = SEVERITY_BY_NAME[parsed.failSeverity] ?? DiagnosticSeverity.Error;
+  const allowRemote = parsed.resolveRemote || (parsed.allowedHosts?.length ?? 0) > 0;
+  const resolver = parsed.resolve ? createLintResolver({
+    remote: allowRemote,
+    ...parsed.allowedHosts ? { allowedHosts: parsed.allowedHosts } : {},
+    allowPrivateHosts: parsed.allowPrivateHosts
+  }) : void 0;
+  const reportRulesetProblems = (definition, label) => {
+    if (parsed.quiet)
+      return;
+    for (const problem of validateRuleset(definition)) {
+      const at = problem.path.length > 0 ? ` (at ${problem.path.join(".")})` : "";
+      err.push(`warning: ruleset ${label}: ${problem.message}${at}
+`);
     }
-    const targets = await fg(parsed.documents ?? [], { dot: true, onlyFiles: true });
-    const allResults = [];
-    if (targets.length === 0) {
-        if (options.stdin === undefined && process.stdin.isTTY) {
-            return { code: 2, stdout: '', stderr: 'No documents provided.\n' };
-        }
-        const content = options.stdin ?? (await readStdin());
-        // With --stdin-filepath, label findings with that path and discover a
-        // `.lint.*` ruleset by walking up from its directory.
-        const stdinPath = parsed.stdinFilepath;
-        let definition = rulesetDefinition;
-        let basePath = rulesetBasePath;
-        if (!definition && !parsed.ruleset && stdinPath) {
-            const discovered = await discoverAndLoad(dirname(stdinPath));
-            if (discovered)
-                ({ definition, basePath } = discovered);
-        }
-        const opts = {
-            ...(definition ? { ruleset: definition } : {}),
-            ...(basePath !== undefined ? { rulesetBasePath: basePath } : {}),
-            ...(resolver && definition ? { resolve: resolver } : {}),
-            source: stdinPath ?? '<stdin>',
-        };
-        allResults.push(...(await lintDocument(content, opts)));
+  };
+  const discoverAndLoad = async (dir) => {
+    const discovered = discoverRuleset(dir);
+    if (!discovered)
+      return void 0;
+    const definition = await loadRuleset(discovered);
+    reportRulesetProblems(definition, discovered);
+    return { definition, basePath: dirname(discovered) };
+  };
+  let rulesetDefinition;
+  let rulesetBasePath;
+  if (parsed.ruleset) {
+    rulesetDefinition = await loadRuleset(parsed.ruleset);
+    rulesetBasePath = dirname(isAbsolute(parsed.ruleset) ? parsed.ruleset : resolve(process.cwd(), parsed.ruleset));
+    reportRulesetProblems(rulesetDefinition, parsed.ruleset);
+  }
+  const targets = await fg(parsed.documents ?? [], { dot: true, onlyFiles: true });
+  const allResults = [];
+  if (targets.length === 0) {
+    if (options.stdin === void 0 && process.stdin.isTTY) {
+      return { code: 2, stdout: "", stderr: "No documents provided.\n" };
     }
-    else {
-        // Cache discovered/loaded rulesets by directory so a directory of documents
-        // that share a `.lint.*` file parses it once, not once per file.
-        const rulesetCache = new Map();
-        const perFile = await mapWithConcurrency(targets, parsed.concurrency, async (file) => {
-            const content = await readFile(file, parsed.encoding);
-            let definition = rulesetDefinition;
-            let basePath = rulesetBasePath;
-            if (!definition && !parsed.ruleset) {
-                const dir = dirname(file);
-                let discovered = rulesetCache.get(dir);
-                if (!rulesetCache.has(dir)) {
-                    discovered = await discoverAndLoad(dir);
-                    rulesetCache.set(dir, discovered);
-                }
-                if (discovered)
-                    ({ definition, basePath } = discovered);
-            }
-            const opts = definition
-                ? {
-                    ruleset: definition,
-                    ...(basePath !== undefined ? { rulesetBasePath: basePath } : {}),
-                    ...(resolver ? { resolve: resolver } : {}),
-                    source: file,
-                }
-                : { source: file };
-            return lintDocument(content, opts);
-        });
-        for (const remaining of perFile)
-            allResults.push(...remaining);
+    const content = options.stdin ?? await readStdin();
+    const stdinPath = parsed.stdinFilepath;
+    let definition = rulesetDefinition;
+    let basePath = rulesetBasePath;
+    if (!definition && !parsed.ruleset && stdinPath) {
+      const discovered = await discoverAndLoad(dirname(stdinPath));
+      if (discovered)
+        ({ definition, basePath } = discovered);
     }
-    const displayed = parsed.displayOnlyFailures ? filterBySeverity(allResults, failSeverity) : allResults;
-    if (!parsed.quiet)
-        out.push(formatReport(displayed));
-    return {
-        code: filterBySeverity(allResults, failSeverity).length > 0 ? 1 : 0,
-        stdout: out.join(''),
-        stderr: err.join(''),
+    const opts = {
+      ...definition ? { ruleset: definition } : {},
+      ...basePath !== void 0 ? { rulesetBasePath: basePath } : {},
+      ...resolver && definition ? { resolve: resolver } : {},
+      source: stdinPath ?? "<stdin>"
     };
+    allResults.push(...await lintDocument(content, opts));
+  } else {
+    const rulesetCache = /* @__PURE__ */ new Map();
+    const perFile = await mapWithConcurrency(targets, parsed.concurrency, async (file) => {
+      const content = await readFile(file, parsed.encoding);
+      let definition = rulesetDefinition;
+      let basePath = rulesetBasePath;
+      if (!definition && !parsed.ruleset) {
+        const dir = dirname(file);
+        let discovered = rulesetCache.get(dir);
+        if (!rulesetCache.has(dir)) {
+          discovered = await discoverAndLoad(dir);
+          rulesetCache.set(dir, discovered);
+        }
+        if (discovered)
+          ({ definition, basePath } = discovered);
+      }
+      const opts = definition ? {
+        ruleset: definition,
+        ...basePath !== void 0 ? { rulesetBasePath: basePath } : {},
+        ...resolver ? { resolve: resolver } : {},
+        source: file
+      } : { source: file };
+      return lintDocument(content, opts);
+    });
+    for (const remaining of perFile)
+      allResults.push(...remaining);
+  }
+  const displayed = parsed.displayOnlyFailures ? filterBySeverity(allResults, failSeverity) : allResults;
+  if (!parsed.quiet)
+    out.push(formatReport(displayed));
+  return {
+    code: filterBySeverity(allResults, failSeverity).length > 0 ? 1 : 0,
+    stdout: out.join(""),
+    stderr: err.join("")
+  };
+};
+export {
+  run
 };