@amritk/mjst 0.12.2 → 0.12.3

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
 };

package/dist/load-config.js

@@ -1,46 +1,45 @@
-import { readFile } from 'node:fs/promises';
-import { resolve } from 'node:path';
-const SOURCE_FORMATS = ['json', 'typebox', 'zod', 'valibot', 'effect'];
-const isSourceFormat = (value) => typeof value === 'string' && SOURCE_FORMATS.includes(value);
-const isHelpersMode = (value) => value === 'package' || value === 'embedded';
-const isImportExt = (value) => value === 'js' || value === 'ts';
-const isStringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === 'string');
-/**
- * Loads a JSON config file and returns the relevant CLI config properties.
- * The config file should have the same keys as the CLI flags (schema, outDir).
- */
-export const loadConfig = async (configPath) => {
-    const absolutePath = resolve(configPath);
-    const raw = await readFile(absolutePath, 'utf-8');
-    const parsed = JSON.parse(raw);
-    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
-        throw new Error(`Config file must be a JSON object: ${configPath}`);
-    }
-    const obj = parsed;
-    return {
-        ...(typeof obj['schema'] === 'string' && { schema: obj['schema'] }),
-        ...(typeof obj['schemaDir'] === 'string' && { schemaDir: obj['schemaDir'] }),
-        ...(typeof obj['outDir'] === 'string' && { outDir: obj['outDir'] }),
-        ...(typeof obj['outFile'] === 'string' && { outFile: obj['outFile'] }),
-        ...(isSourceFormat(obj['input']) && { input: obj['input'] }),
-        ...(typeof obj['export'] === 'string' && { export: obj['export'] }),
-        ...(typeof obj['validators'] === 'boolean' && { validators: obj['validators'] }),
-        ...(typeof obj['typesOnly'] === 'boolean' && { typesOnly: obj['typesOnly'] }),
-        ...(typeof obj['examples'] === 'boolean' && { examples: obj['examples'] }),
-        ...(typeof obj['build'] === 'boolean' && { build: obj['build'] }),
-        ...(typeof obj['logWarnings'] === 'boolean' && { logWarnings: obj['logWarnings'] }),
-        ...(typeof obj['strict'] === 'boolean' && { strict: obj['strict'] }),
-        ...(typeof obj['stripUnknown'] === 'boolean' && { stripUnknown: obj['stripUnknown'] }),
-        ...(typeof obj['caseInsensitive'] === 'boolean' && { caseInsensitive: obj['caseInsensitive'] }),
-        ...(typeof obj['readonly'] === 'boolean' && { readonly: obj['readonly'] }),
-        ...(isHelpersMode(obj['helpers']) && { helpers: obj['helpers'] }),
-        ...(isImportExt(obj['importExt']) && { importExt: obj['importExt'] }),
-        ...(typeof obj['rootType'] === 'string' && { rootType: obj['rootType'] }),
-        ...(typeof obj['typeSuffix'] === 'string' && { typeSuffix: obj['typeSuffix'] }),
-        // `banner` is a boolean toggle or a custom header string, mirroring the CLI flag.
-        ...((typeof obj['banner'] === 'boolean' || typeof obj['banner'] === 'string') && { banner: obj['banner'] }),
-        ...(typeof obj['resolveRemote'] === 'boolean' && { resolveRemote: obj['resolveRemote'] }),
-        ...(isStringArray(obj['allowedHosts']) && { allowedHosts: obj['allowedHosts'] }),
-        ...(typeof obj['allowPrivateHosts'] === 'boolean' && { allowPrivateHosts: obj['allowPrivateHosts'] }),
-    };
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+const SOURCE_FORMATS = ["json", "typebox", "zod", "valibot", "effect"];
+const isSourceFormat = (value) => typeof value === "string" && SOURCE_FORMATS.includes(value);
+const isHelpersMode = (value) => value === "package" || value === "embedded";
+const isImportExt = (value) => value === "js" || value === "ts";
+const isStringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
+const loadConfig = async (configPath) => {
+  const absolutePath = resolve(configPath);
+  const raw = await readFile(absolutePath, "utf-8");
+  const parsed = JSON.parse(raw);
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`Config file must be a JSON object: ${configPath}`);
+  }
+  const obj = parsed;
+  return {
+    ...typeof obj["schema"] === "string" && { schema: obj["schema"] },
+    ...typeof obj["schemaDir"] === "string" && { schemaDir: obj["schemaDir"] },
+    ...typeof obj["outDir"] === "string" && { outDir: obj["outDir"] },
+    ...typeof obj["outFile"] === "string" && { outFile: obj["outFile"] },
+    ...isSourceFormat(obj["input"]) && { input: obj["input"] },
+    ...typeof obj["export"] === "string" && { export: obj["export"] },
+    ...typeof obj["validators"] === "boolean" && { validators: obj["validators"] },
+    ...typeof obj["typesOnly"] === "boolean" && { typesOnly: obj["typesOnly"] },
+    ...typeof obj["examples"] === "boolean" && { examples: obj["examples"] },
+    ...typeof obj["build"] === "boolean" && { build: obj["build"] },
+    ...typeof obj["logWarnings"] === "boolean" && { logWarnings: obj["logWarnings"] },
+    ...typeof obj["strict"] === "boolean" && { strict: obj["strict"] },
+    ...typeof obj["stripUnknown"] === "boolean" && { stripUnknown: obj["stripUnknown"] },
+    ...typeof obj["caseInsensitive"] === "boolean" && { caseInsensitive: obj["caseInsensitive"] },
+    ...typeof obj["readonly"] === "boolean" && { readonly: obj["readonly"] },
+    ...isHelpersMode(obj["helpers"]) && { helpers: obj["helpers"] },
+    ...isImportExt(obj["importExt"]) && { importExt: obj["importExt"] },
+    ...typeof obj["rootType"] === "string" && { rootType: obj["rootType"] },
+    ...typeof obj["typeSuffix"] === "string" && { typeSuffix: obj["typeSuffix"] },
+    // `banner` is a boolean toggle or a custom header string, mirroring the CLI flag.
+    ...(typeof obj["banner"] === "boolean" || typeof obj["banner"] === "string") && { banner: obj["banner"] },
+    ...typeof obj["resolveRemote"] === "boolean" && { resolveRemote: obj["resolveRemote"] },
+    ...isStringArray(obj["allowedHosts"]) && { allowedHosts: obj["allowedHosts"] },
+    ...typeof obj["allowPrivateHosts"] === "boolean" && { allowPrivateHosts: obj["allowPrivateHosts"] }
+  };
+};
+export {
+  loadConfig
 };

package/dist/load-schema-module.js

@@ -1,45 +1,30 @@
-import { pathToFileURL } from 'node:url';
-/**
- * Loads a schema authored as a JS/TS module and returns the exported schema value.
- *
- * Export selection, in order of preference:
- * 1. The export named by `exportName`, when provided (`--export <name>`).
- * 2. The module's default export.
- * 3. The sole named export, when there is exactly one.
- *
- * Anything else is ambiguous and throws, so the user can disambiguate explicitly
- * rather than have mjst guess wrong.
- *
- * Importing a `.ts` module requires a TypeScript-capable runtime (Bun, or Node
- * with a loader such as `tsx`). We surface a friendly hint when the import fails
- * for a `.ts` path so the cause is not a cryptic module-resolution error.
- */
-export const loadSchemaModule = async (modulePath, exportName) => {
-    let mod;
-    try {
-        mod = (await import(pathToFileURL(modulePath).href));
+import { pathToFileURL } from "node:url";
+const loadSchemaModule = async (modulePath, exportName) => {
+  let mod;
+  try {
+    mod = await import(pathToFileURL(modulePath).href);
+  } catch (error) {
+    const hint = modulePath.endsWith(".ts") ? " Importing a .ts schema requires a TypeScript-capable runtime \u2014 run mjst via `bunx`, or install `tsx` and run Node with `--import tsx`." : "";
+    throw new Error(`Failed to load schema module at ${modulePath}.${hint}
+${String(error)}`);
+  }
+  if (exportName) {
+    if (!(exportName in mod)) {
+      throw new Error(`Schema module ${modulePath} has no export named '${exportName}'.`);
     }
-    catch (error) {
-        const hint = modulePath.endsWith('.ts')
-            ? ' Importing a .ts schema requires a TypeScript-capable runtime — run mjst via `bunx`, or install `tsx` and run Node with `--import tsx`.'
-            : '';
-        throw new Error(`Failed to load schema module at ${modulePath}.${hint}\n${String(error)}`);
-    }
-    if (exportName) {
-        if (!(exportName in mod)) {
-            throw new Error(`Schema module ${modulePath} has no export named '${exportName}'.`);
-        }
-        return mod[exportName];
-    }
-    if ('default' in mod && mod['default'] !== undefined) {
-        return mod['default'];
-    }
-    const namedKeys = Object.keys(mod).filter((key) => key !== 'default');
-    if (namedKeys.length === 1) {
-        const key = namedKeys[0];
-        if (key)
-            return mod[key];
-    }
-    throw new Error(`Schema module ${modulePath} exports ${namedKeys.length} values (${namedKeys.join(', ') || 'none'}). ` +
-        `Specify which one to use with --export <name>.`);
+    return mod[exportName];
+  }
+  if ("default" in mod && mod["default"] !== void 0) {
+    return mod["default"];
+  }
+  const namedKeys = Object.keys(mod).filter((key) => key !== "default");
+  if (namedKeys.length === 1) {
+    const key = namedKeys[0];
+    if (key)
+      return mod[key];
+  }
+  throw new Error(`Schema module ${modulePath} exports ${namedKeys.length} values (${namedKeys.join(", ") || "none"}). Specify which one to use with --export <name>.`);
+};
+export {
+  loadSchemaModule
 };

package/dist/load-schema.js

@@ -1,52 +1,36 @@
-import { readFile } from 'node:fs/promises';
-import { getAdapter } from '@amritk/adapters/get-adapter';
-import { resolveRefsFromFile } from '@amritk/resolve-refs';
-import { hasExternalRefs } from './has-external-refs.js';
-import { loadSchemaModule } from './load-schema-module.js';
-/**
- * Builds the `@amritk/resolve-refs` options from the CLI config, mirroring the
- * safety posture of `mjst lint`: remote (`http(s)`) `$ref`s are refused unless
- * opted into, a non-empty `allowedHosts` implies remote fetching, and private/
- * loopback hosts stay blocked as an SSRF guard unless explicitly permitted.
- */
+import { readFile } from "node:fs/promises";
+import { getAdapter } from "@amritk/adapters/get-adapter";
+import { resolveRefsFromFile } from "@amritk/resolve-refs";
+import { hasExternalRefs } from "./has-external-refs.js";
+import { loadSchemaModule } from "./load-schema-module.js";
 const buildResolveOptions = (config) => {
-    // A non-empty allow-list is itself an opt-in to remote fetching.
-    const remote = (config.resolveRemote ?? false) || (config.allowedHosts?.length ?? 0) > 0;
-    return {
-        remote,
-        ...(config.allowedHosts ? { allowedHosts: [...config.allowedHosts] } : {}),
-        ...(config.allowPrivateHosts ? { allowPrivateHosts: config.allowPrivateHosts } : {}),
-    };
+  const remote = (config.resolveRemote ?? false) || (config.allowedHosts?.length ?? 0) > 0;
+  return {
+    remote,
+    ...config.allowedHosts ? { allowedHosts: [...config.allowedHosts] } : {},
+    ...config.allowPrivateHosts ? { allowPrivateHosts: config.allowPrivateHosts } : {}
+  };
 };
-/** Renders resolver failures into a single CLI error message. */
 const formatResolveErrors = (schemaPath, errors) => {
-    const details = errors.map((error) => `  - ${error.message}`).join('\n');
-    return `Failed to resolve $refs in ${schemaPath}:\n${details}`;
+  const details = errors.map((error) => `  - ${error.message}`).join("\n");
+  return `Failed to resolve $refs in ${schemaPath}:
+${details}`;
 };
-/**
- * Reads a JSON Schema off disk, or loads a module and converts it via its adapter.
- *
- * For JSON input, a schema whose only references are same-document `#/...`
- * pointers is parsed as-is — the generator resolves those internal `$ref`s
- * itself into named type files, so inlining them here would collapse that
- * structure. When a cross-file or remote `$ref` is present (which the generator
- * cannot follow on its own), the schema is dereferenced with
- * `@amritk/resolve-refs`, inlining every external target into a single document.
- * Any resolve failures are surfaced as a CLI error rather than silently yielding
- * a half-resolved schema.
- */
-export const loadSchema = async (config, schemaPath) => {
-    const inputFormat = config.input ?? 'json';
-    if (inputFormat === 'json') {
-        const data = JSON.parse(await readFile(schemaPath, 'utf-8'));
-        if (!hasExternalRefs(data))
-            return data;
-        const { resolved, errors } = await resolveRefsFromFile(schemaPath, buildResolveOptions(config));
-        if (errors.length > 0)
-            throw new Error(formatResolveErrors(schemaPath, errors));
-        return resolved;
-    }
-    console.log(`Input format: ${inputFormat}`);
-    const source = await loadSchemaModule(schemaPath, config.export);
-    return getAdapter(inputFormat).toJSONSchema(source);
+const loadSchema = async (config, schemaPath) => {
+  const inputFormat = config.input ?? "json";
+  if (inputFormat === "json") {
+    const data = JSON.parse(await readFile(schemaPath, "utf-8"));
+    if (!hasExternalRefs(data))
+      return data;
+    const { resolved, errors } = await resolveRefsFromFile(schemaPath, buildResolveOptions(config));
+    if (errors.length > 0)
+      throw new Error(formatResolveErrors(schemaPath, errors));
+    return resolved;
+  }
+  console.log(`Input format: ${inputFormat}`);
+  const source = await loadSchemaModule(schemaPath, config.export);
+  return getAdapter(inputFormat).toJSONSchema(source);
+};
+export {
+  loadSchema
 };