@amritk/mjst 0.21.1 → 0.23.0

package/AI.md

@@ -8,7 +8,7 @@ reference is [README.md](./README.md); config options are in
 
 > Pre-alpha: generated output and flags change without notice pre-1.0. This
 > package ships **only a `mjst` binary** — there are no JS exports. For the
-> programmatic API import `@amritk/generate-parsers` etc. instead.
+> programmatic API import `@amritk/validation` etc. instead.
 
 ## The four commands
 
@@ -57,11 +57,19 @@ mjst markdown ./config.schema.json --table --readme ./README.md
    `--discriminator <prop>` when the document tags frames with something other
    than `type`; a channel carrying `x-mjst: { discriminator }` keeps its own.
 
+## Picking what gets emitted
+
+Every run emits the type. `--types-only` stops there. A bare run adds a parser;
+`--validators` adds `isX`/`validateX` beside it; `--validators-only` emits those
+*without* a parser, which is the shape to reach for when the generated code only
+ever judges input it did not produce. `--check`, `--coerce` and `--repair` each
+add one more entry point to the validator half and work under either flag.
+
 ## Common flags
 
 `--schema` / `--schema-dir`, `--out-dir` / `--out-file`, `--input`,
-`--validators`, `--examples`, `--message-contracts`, `--discriminator`,
-`--types-only`, `--build`, `--strict`, `--strip-unknown`,
+`--validators` / `--validators-only`, `--examples`, `--message-contracts`,
+`--discriminator`, `--types-only`, `--build`, `--strict`, `--strip-unknown`,
 `--unknown-keys count-keys|count-enumerable`, `--readonly`,
 `--import-ext ts|js`, `--config <path>`, `--resolve-remote` /
 `--allowed-hosts` (SSRF-guarded remote `$ref`s).

package/README.md

@@ -95,19 +95,35 @@ JSON-Pointer error paths — and an `isX(input)` boolean type guard:
 npx mjst --schema ./schema.json --out-dir ./generated --validators
 ```
 
-The validators carry the same schema-derived filenames as the parsers, so they land in a
-`validators/` subdirectory to avoid colliding:
+Both halves land in one directory, over a single declaration of each type. The type and the
+validators share the file named after the schema; the parser moves next to them under a
+`.parse` suffix and imports the type from there:
 
 ```
 generated/
-  schema.ts, index.ts            ← parsers + types
-  validators/
-    schema.ts, index.ts          ← validateX / isX
-    validation-result.ts         ← ValidationResult / ValidationError contract
+  schema.ts                      ← export type X, plus isX / validateX
+  schema.parse.ts                ← parseX, importing the type from ./schema
+  validation-result.ts           ← ValidationResult / ValidationError contract
+  index.ts                       ← a barrel over all of it
 ```
 
-This works with `--schema-dir` too (the `validators/` tree mirrors the parser layout) and with
-`--build`. It cannot be combined with `--types-only` or `--out-file`, which emit no runtime code.
+So there is exactly one `export type X` in the output, and the guard, the validator and the
+parser are all talking about it.
+
+This works with `--schema-dir` and `--input asyncapi` too — each schema's own subdirectory
+carries both halves — and with `--build`. It cannot be combined with `--types-only` or
+`--out-file`, which emit no runtime code.
+
+Ask for no validators and there is nothing to collide with, so the parser keeps `schema.ts` and
+its own type, and no `validation-result.ts` is emitted at all.
+
+Three flags shape the validators, and each needs `--validators` alongside it:
+
+- `--check` adds `checkX`, the same `ValidationResult` as `validateX` but stopped at the first
+  violation, so it costs one error object rather than however many the document earns.
+- `--coerce` adds `coerceX`, which moves scalars toward the declared type and then validates.
+- `--repair` adds `repairX`, which coerces, validates, and then repairs each rejected position
+  to a value the schema supplies.
 
 ### Running the generated output
 
@@ -305,6 +321,10 @@ npx mjst markdown ./config.schema.json --table --readme ./README.md
 | `--layout` | Default layout for nested properties: `headings` (default), `table`, or `none`. |
 | `--sort` | Property order: `schema` (default) or `alphabetical`. |
 | `--heading-level` | Heading level of the page title, 1-6 (default: `1`). |
+| `--type-column` | When a property table renders its **Type** column: `auto` (default — only when a row fills it with something a reader could act on), `always`, or `never`. |
+| `--default-column` | When a property table renders its **Default** column: `auto` (default), `always`, or `never`. |
+| `--required-style` | How a property table says which properties are required: `marker` (default — `_required_` beside the name) or `column` (a **Required** column). |
+| `--required-first` | List the required properties at the top of every table, the rest under them. |
 | `--table` | Render the HTML config table instead of the prose pages. |
 | `--readme` | Markdown file the table is spliced into (default: `README.md`). Requires `--table`. |
 
@@ -389,7 +409,52 @@ Under `--table` only the content between `<!-- config-table-start -->
 <td align="center"><code>false</code></td>
 </tr>
 <tr>
-<td colspan="4">Also emit validation functions alongside the parsers. For every generated type X the CLI writes a validateX (returning a rich ValidationResult with JSON-Pointer error paths) and an isX boolean type guard. The files land in a validators/ subdirectory of the output so they never collide with the parser files, which share the same schema-derived names. Works with both schema and schemaDir. Incompatible with typesOnly and outFile, which produce no runtime code.</td>
+<td colspan="4">Also emit validation functions alongside the parsers. For every generated type X the CLI writes a validateX (returning a rich ValidationResult with JSON-Pointer error paths) and an isX boolean type guard. They share one directory and one declaration of X with the parser: the type and the validators land in x.ts, and the parser moves to x.parse.ts beside them, importing the type from there. Works with both schema and schemaDir. Incompatible with typesOnly and outFile, which produce no runtime code.</td>
+</tr>
+<tr>
+<td>🛡️ <code>validatorsOnly</code></td>
+<td><code>--validators-only</code></td>
+<td><code>boolean</code></td>
+<td align="center"><code>false</code></td>
+</tr>
+<tr>
+<td colspan="4">Emit the validator half and no parser: the type, isX, validateX, and whichever of checkX, coerceX and repairX were asked for. Implies validators, so it does not need it as well. This is the mirror of typesOnly at the other end of the ladder — one run with nothing that rewrites a document, the other with nothing that executes at all — and it is what to reach for when the generated code only ever judges input it did not produce. Without it every run carries a parser. Incompatible with typesOnly and outFile.</td>
+</tr>
+<tr>
+<td>🔎 <code>check</code></td>
+<td><code>--check</code></td>
+<td><code>boolean</code></td>
+<td align="center"><code>false</code></td>
+</tr>
+<tr>
+<td colspan="4">Also emit a checkX alongside each validateX. It is the same ValidationResult, carrying the one error that stopped it: where validateX walks the whole document to collect every violation, checkX gives up at the first and costs a single error object. Reach for it when a failure has to be reported but only the first thing wrong matters — a service refusing to boot on a bad config does not need the other nine. When nothing has to be reported at all, isX is cheaper still, since it builds no error object. validateX and isX are unchanged either way. Requires validators.</td>
+</tr>
+<tr>
+<td>🧪 <code>coerce</code></td>
+<td><code>--coerce</code></td>
+<td><code>boolean</code></td>
+<td align="center"><code>false</code></td>
+</tr>
+<tr>
+<td colspan="4">Also emit a coerceX alongside each validateX. It moves scalars toward the type the schema declares and then runs the very same validateX over the result, so a config value written the YAML way reads the same whether it came from a config file or an extension. The input is never modified and nothing is substituted: a value that cannot be coerced into a valid one reaches the validator untouched, so the error names what the caller actually wrote, with the keyword and params that rejected it. The table is Ajv's coerceTypes minus the cells where Ajv guesses — no whitespace-to-zero, no hex or Infinity strings, and nothing coerced to or from null — so every value this coerces, Ajv coerces to the same value, and the rest become errors rather than silent repairs. At a union it coerces only when exactly one of the offered types can take the value, and leaves a value that is already one of them alone, so the answer does not depend on the order the union was written in. Requires validators.</td>
+</tr>
+<tr>
+<td>🔧 <code>repair</code></td>
+<td><code>--repair</code></td>
+<td><code>boolean</code></td>
+<td align="center"><code>false</code></td>
+</tr>
+<tr>
+<td colspan="4">Also emit a repairX alongside each validateX. It coerces, runs the very same validateX, and then repairs each position the validator rejected to a value the schema itself supplies — a default, a const, the first enum member, or a fallback built to satisfy that position's own bounds — re-validating until the document is accepted or nothing further can be repaired. The repairs it reports are the validator's own errors, the ones a repair was found for, so a caller logs the same path, keyword and params it would have been rejected with and the two can never drift apart. A document needing nothing comes back valid with an empty repairs list; one fully repaired comes back valid with a non-empty one, leaving the caller to decide whether that is acceptable; one that could not be fully repaired comes back invalid carrying both the repairs applied and the errors still outstanding. The input is never modified and everything the repair did not touch is shared. Implies coerce, so a value merely written in the wrong type is right before the validator sees it and never counts as a repair. Requires validators.</td>
+</tr>
+<tr>
+<td>🌿 <code>branchErrors</code></td>
+<td><code>--branch-errors</code></td>
+<td><code>boolean</code></td>
+<td align="center"><code>false</code></td>
+</tr>
+<tr>
+<td colspan="4">Explain a failing anyOf/oneOf with the errors of the branch it meant, instead of the bare "must match a schema in anyOf" that names no field and no reason. The branch that rejected the value's kind is dropped first, so a string-or-object union is left with the one branch that was talking about this value; where several remain, a discriminator breaks the tie; where none stands out, nothing extra is reported. Off by default and off costs nothing — the generated code is exactly what it would be without the option. On, each branch keeps what it complained about: a push per failing branch and one lazily-created array per combinator that had one. Requires validators.</td>
 </tr>
 <tr>
 <td>🎲 <code>examples</code></td>
@@ -686,7 +751,7 @@ usage error. Run `mjst markdown --help` for details.
 <td align="center"><code>false</code></td>
 </tr>
 <tr>
-<td colspan="4">Also emit validation functions alongside the parsers. For every generated type X the CLI writes a validateX (returning a rich ValidationResult with JSON-Pointer error paths) and an isX boolean type guard. The files land in a validators/ subdirectory of the output so they never collide with the parser files, which share the same schema-derived names. Works with both schema and schemaDir. Incompatible with typesOnly and outFile, which produce no runtime code.</td>
+<td colspan="4">Also emit validation functions alongside the parsers. For every generated type X the CLI writes a validateX (returning a rich ValidationResult with JSON-Pointer error paths) and an isX boolean type guard. They share one directory and one declaration of X with the parser: the type and the validators land in x.ts, and the parser moves to x.parse.ts beside them, importing the type from there. Works with both schema and schemaDir. Incompatible with typesOnly and outFile, which produce no runtime code.</td>
 </tr>
 <tr>
 <td>🎲 <code>examples</code></td>

package/dist/cli-config.d.ts

@@ -41,16 +41,106 @@ export type CliConfig = {
      * Useful when you only need the type shapes and do not need runtime validation.
      */
     readonly typesOnly?: boolean;
+    /**
+     * When true, emit the validator half and no parser: the type, `isX`,
+     * `validateX`, and whichever of `checkX`/`coerceX`/`repairX` were asked for.
+     *
+     * Implies `validators`, and is the mirror of `typesOnly` at the other end of
+     * the ladder — one run with nothing that rewrites a document, the other with
+     * nothing that executes at all. Without it every run carries a parser, so the
+     * library's own default (a type and its validators, nothing that builds a
+     * value) had no spelling here.
+     */
+    readonly validatorsOnly?: boolean;
     /**
      * When true, also emit validation functions alongside the parsers. For every
      * generated type `X` the CLI writes a `validateX` (returning a rich
      * `ValidationResult` with JSON-Pointer error paths) and an `isX` boolean type
-     * guard. The files land in a `validators/` subdirectory of the output so they
-     * never collide with the parser files, which share the same schema-derived
-     * names. Works with both `schema` and `schemaDir`. Incompatible with
-     * `typesOnly` and `outFile`, which produce no runtime code.
+     * guard.
+     *
+     * They share one directory and one declaration of `X` with the parser: the
+     * type and the validators land in `x.ts`, and the parser moves to `x.parse.ts`
+     * beside them, importing the type from there. Both halves are then talking
+     * about the same type, which two side-by-side trees could only promise.
+     *
+     * Works with both `schema` and `schemaDir`. Incompatible with `typesOnly` and
+     * `outFile`, which produce no runtime code.
      */
     readonly validators?: boolean;
+    /**
+     * When true, generated validators also get a `checkX`: the same
+     * `ValidationResult` `validateX` returns, carrying the one error that stopped
+     * it. It gives up at the first violation instead of walking on to collect the
+     * rest, so it costs a single error object where `validateX` costs however many
+     * the document earns.
+     *
+     * Reach for it when a failure has to be reported but only the first thing
+     * wrong matters — a service refusing to boot on a bad config does not need the
+     * other nine. When nothing has to be reported at all, `isX` is cheaper still:
+     * it builds no error object.
+     *
+     * Requires `validators`. `validateX` and `isX` are unchanged either way.
+     */
+    readonly check?: boolean;
+    /**
+     * When true, generated validators also get a `coerceX`: it moves scalars
+     * toward what the schema asks for and then runs the very same `validateX` over
+     * the result, so a config value written the YAML way reads the same however it
+     * arrived.
+     *
+     * The input is never modified, and nothing is ever substituted: where a value
+     * cannot be coerced into a valid one it is handed to the validator untouched,
+     * so the error names what the caller actually wrote, with the keyword and
+     * params that rejected it. That is the difference from a coercing *parser*,
+     * which repairs toward a default and leaves nothing to report.
+     *
+     * The table is Ajv's `coerceTypes` minus the cells where Ajv guesses — no
+     * whitespace-to-zero, no `0x`/`Infinity` strings, and nothing coerced to or
+     * from `null`. Every value this coerces, Ajv coerces to the same value, so
+     * moving off Ajv never changes a value; it turns some of Ajv's silent repairs
+     * into errors instead. At a union it coerces only when exactly one of the
+     * offered types can take the value, and leaves a value that is already one of
+     * them alone — so the answer does not depend on the order the union is
+     * written in, which under Ajv it does.
+     *
+     * Requires `validators`. `validateX` and `isX` are unchanged either way.
+     */
+    readonly coerce?: boolean;
+    /**
+     * When true, generated validators also get a `repairX`: it coerces, validates,
+     * and then repairs each position the validator rejected to a value the schema
+     * itself supplies — a `default`, a `const`, the first `enum` member, or a
+     * fallback built to satisfy the position's own bounds. The result carries the
+     * repaired value together with `repairs`, which *are* the errors `validateX`
+     * produced for the positions that were repaired, so a caller logs the same
+     * path, keyword and params it would have been rejected with.
+     *
+     * A document needing no repair comes back valid with an empty `repairs`; one
+     * fully repaired comes back valid with a non-empty one, leaving the caller to
+     * decide whether that is acceptable; one that could not be fully repaired
+     * comes back invalid carrying both the repairs applied and the errors still
+     * outstanding.
+     *
+     * Implies `coerce` — repairing runs after coercion, so a value merely written
+     * in the wrong type is right before the validator sees it and never counts as
+     * a repair. Requires `validators`.
+     */
+    readonly repair?: boolean;
+    /**
+     * When true, a failing `anyOf` / `oneOf` in a generated validator also reports
+     * the errors of the branch it meant, instead of the bare "must match a schema
+     * in anyOf" that names no field and no reason.
+     *
+     * Off by default, and off costs nothing — the generated code is exactly what
+     * it would be without the option. On, each branch keeps what it complained
+     * about, which is a push per *failing* branch and one lazily-created array per
+     * combinator that had one. A valid instance fails no branch and allocates
+     * nothing, but the branches are still handed a collector, so measure before
+     * turning it on in a hot path.
+     *
+     * Requires `validators`.
+     */
+    readonly branchErrors?: boolean;
     /**
      * When true, also emit test-data files for every schema: a `fast-check`
      * arbitrary (`FooArbitrary`) that produces schema-valid values and a concrete

package/dist/cli.js

@@ -4,8 +4,6 @@ import { readdir, unlink, writeFile } from "node:fs/promises";
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import { promisify } from "node:util";
 import { extractAsyncApi, listMessageSchemas } from "@amritk/asyncapi";
-import { buildSchema } from "@amritk/generate-parsers";
-import { buildValidatorSchema } from "@amritk/generate-validators";
 import { deriveRootTypeName } from "@amritk/helpers/derive-root-type-name";
 const execFileAsync = promisify(execFile);
 import { combineGeneratedFiles } from "./combine-files.js";
@@ -14,6 +12,7 @@ import { detectHelpersMode } from "./detect-helpers-mode.js";
 import { emitExamples } from "./emit-examples.js";
 import { CONTRACTS_DIR, CONTRACTS_PEER, emitMessageContracts } from "./emit-message-contracts.js";
 import { ensureOutputDir } from "./ensure-output-dir.js";
+import { generateFiles } from "./generate-files.js";
 import { HELP_TEXT } from "./help-text.js";
 import { isDependencyDeclared } from "./is-dependency-declared.js";
 import { loadAsyncApiDocument } from "./load-asyncapi-document.js";
@@ -22,7 +21,6 @@ import { loadSchema } from "./load-schema.js";
 import { parseCliArgs } from "./parse-cli-args.js";
 import { parseMetaRequest } from "./parse-meta-request.js";
 import { readVersion } from "./read-version.js";
-import { resolveImportExt } from "./resolve-import-ext.js";
 const ROOT_TYPE_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 const DISCRIMINATOR_PATTERN = /^[A-Za-z_$][\w$-]*$/;
 const schemaBaseName = (schemaPath) => basename(schemaPath).replace(/\.[^.]+$/, "");
@@ -138,24 +136,13 @@ const findJsonSchemas = async (dir) => {
   }
   return results;
 };
-const runValidators = async (config, schema, rootTypeName, writer, validatorsSubDir) => {
-  const files = await buildValidatorSchema(schema, rootTypeName, config.typeSuffix, void 0, config.unknownKeys, config.formats);
-  const staged = [];
-  for (const file of files) {
-    const content = config.banner ? resolveBanner(config.banner) + file.content : file.content;
-    const relFilename = join(validatorsSubDir, file.filename);
-    await writer.stage(relFilename, content);
-    staged.push(relFilename);
-  }
-  return staged;
-};
 const runSingle = async (config, schemaPath, outputDir) => {
   const schema = await loadSchema(config, schemaPath);
   await ensureOutputDir(outputDir);
   const helpersMode = resolveHelpersMode(config, outputDir);
   const rootTypeName = config.rootType ?? deriveRootTypeName(schema, schemaBaseName(schemaPath));
   console.log(`Root type: ${rootTypeName}`);
-  const files = await buildSchema(schema, rootTypeName, void 0, config.typesOnly, config.logWarnings, config.strict, helpersMode, void 0, config.readonly, config.stripUnknown, config.typeSuffix, resolveImportExt(config), config.caseInsensitive, void 0, config.unknownKeys);
+  const files = await generateFiles(config, schema, rootTypeName, { mode: helpersMode });
   const writer = await createOutputWriter(outputDir);
   const written = await commitOrDiscard(writer, async () => {
     for (const file of files) {
@@ -163,8 +150,6 @@ const runSingle = async (config, schemaPath, outputDir) => {
       const content = config.banner && !isHelper ? resolveBanner(config.banner) + file.content : file.content;
       await writer.stage(file.filename, content);
     }
-    if (config.validators)
-      await runValidators(config, schema, rootTypeName, writer, "validators");
   });
   for (const filename of written)
     console.log(`Generated: ${filename}`);
@@ -184,7 +169,9 @@ const runSingleFile = async (config, schemaPath, outFilePath) => {
   await ensureOutputDir(outputDir);
   const rootTypeName = config.rootType ?? deriveRootTypeName(schema, schemaBaseName(schemaPath));
   console.log(`Root type: ${rootTypeName}`);
-  const files = await buildSchema(schema, rootTypeName, void 0, config.typesOnly, config.logWarnings, config.strict, config.helpers ?? "package", void 0, config.readonly, config.stripUnknown, config.typeSuffix, resolveImportExt(config), config.caseInsensitive, void 0, config.unknownKeys);
+  const files = await generateFiles(config, schema, rootTypeName, {
+    mode: config.helpers ?? "package"
+  });
   const combined = combineGeneratedFiles(files);
   const writer = await createOutputWriter(outputDir);
   const written = await commitOrDiscard(writer, async () => {
@@ -226,7 +213,10 @@ const runRecursive = async (config, schemaDir, outputDir) => {
       const rootTypeName = deriveRootTypeName(schema, schemaBaseName(schemaFile));
       console.log(`
 ${relPath} \u2192 ${relNoExt}/ (root type: ${rootTypeName})`);
-      const files = await buildSchema(schema, rootTypeName, void 0, config.typesOnly, config.logWarnings, config.strict, helpersMode, helpersImportPrefix, config.readonly, config.stripUnknown, config.typeSuffix, resolveImportExt(config), config.caseInsensitive, void 0, config.unknownKeys);
+      const files = await generateFiles(config, schema, rootTypeName, {
+        mode: helpersMode,
+        importPrefix: helpersImportPrefix
+      });
       for (const file of files) {
         if (file.filename.startsWith("_helpers/")) {
           sharedHelpers.set(file.filename, file.content);
@@ -235,9 +225,6 @@ ${relPath} \u2192 ${relNoExt}/ (root type: ${rootTypeName})`);
         const content = config.banner ? resolveBanner(config.banner) + file.content : file.content;
         await writer.stage(join(relNoExt, file.filename), content);
       }
-      if (config.validators) {
-        await runValidators(config, schema, rootTypeName, writer, join("validators", relNoExt));
-      }
       if (config.examples)
         exampleTasks.push({ schema, rootTypeName, subDir: relNoExt });
     }
@@ -291,7 +278,10 @@ const runAsyncApi = async (config, documentPath, outputDir) => {
       const helpersImportPrefix = "../".repeat(depth);
       console.log(`
 ${subDir}/ (root type: ${rootTypeName})`);
-      const files = await buildSchema(schema, rootTypeName, void 0, config.typesOnly, config.logWarnings, config.strict, helpersMode, helpersImportPrefix, config.readonly, config.stripUnknown, config.typeSuffix, resolveImportExt(config), config.caseInsensitive);
+      const files = await generateFiles(config, schema, rootTypeName, {
+        mode: helpersMode,
+        importPrefix: helpersImportPrefix
+      });
       for (const file of files) {
         if (file.filename.startsWith("_helpers/")) {
           sharedHelpers.set(file.filename, file.content);
@@ -300,9 +290,6 @@ ${subDir}/ (root type: ${rootTypeName})`);
         const content = config.banner ? resolveBanner(config.banner) + file.content : file.content;
         await writer.stage(join(subDir, file.filename), content);
       }
-      if (config.validators) {
-        await runValidators(config, schema, rootTypeName, writer, join("validators", subDir));
-      }
       if (config.examples)
         exampleTasks.push({ schema, rootTypeName, subDir });
     }
@@ -390,13 +377,27 @@ const run = async () => {
   const fileConfig = configPath ? await loadConfig(configPath) : {};
   const cliConfig = parseCliArgs(args);
   const config = { ...fileConfig, ...cliConfig };
+  const wantsValidators = config.validators === true || config.validatorsOnly === true;
+  if (config.coerce && !wantsValidators) {
+    console.error("Error: --coerce shapes the generated validators, so it needs --validators too.");
+    process.exit(1);
+  }
+  if (config.repair && !wantsValidators) {
+    console.error("Error: --repair shapes the generated validators, so it needs --validators too.");
+    process.exit(1);
+  }
+  if (config.check && !wantsValidators) {
+    console.error("Error: --check shapes the generated validators, so it needs --validators too.");
+    process.exit(1);
+  }
+  if (config.branchErrors && !wantsValidators) {
+    console.error("Error: --branch-errors shapes the generated validators, so it needs --validators too.");
+    process.exit(1);
+  }
   if (config.outDir && config.outFile) {
     console.error("Error: provide only one of --out-dir or --out-file, not both.");
     process.exit(1);
   }
-  if (config.force) {
-    console.warn("Warning: --force is deprecated and does nothing; generated files always replace what is at their path.");
-  }
   if (config.rootType !== void 0 && !ROOT_TYPE_PATTERN.test(config.rootType)) {
     console.error(`Error: invalid --root-type "${config.rootType}". Expected a TypeScript identifier (letters, digits, _ or $, not starting with a digit).`);
     process.exit(1);
@@ -413,10 +414,18 @@ const run = async () => {
     console.error("Error: --validators cannot be combined with --types-only, which emits no runtime code.");
     process.exit(1);
   }
+  if (config.validatorsOnly && config.typesOnly) {
+    console.error("Error: --validators-only cannot be combined with --types-only. Pick the one end you want: types alone, or types and validators.");
+    process.exit(1);
+  }
   if (config.validators && config.outFile) {
     console.error("Error: --validators cannot be combined with --out-file. Use --out-dir to emit validator files.");
     process.exit(1);
   }
+  if (config.validatorsOnly && config.outFile) {
+    console.error("Error: --validators-only cannot be combined with --out-file. Use --out-dir to emit validator files.");
+    process.exit(1);
+  }
   if (config.input === "asyncapi") {
     if (config.schemaDir) {
       console.error("Error: --input asyncapi reads a single document via --schema; it cannot be combined with --schema-dir.");

package/dist/combine-files.d.ts

@@ -1,4 +1,4 @@
-import type { GeneratedFile } from '@amritk/generate-parsers';
+import type { GeneratedFile } from '@amritk/validation';
 /**
  * Merges the per-schema {@link GeneratedFile}s into a single self-contained
  * TypeScript module. Each generated file imports its sibling definitions via

package/dist/generate-files.d.ts

@@ -0,0 +1,24 @@
+import { type GeneratedFile } from '@amritk/validation';
+import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
+import type { CliConfig } from './cli-config.js';
+/** Where one schema's generated files reach their runtime helpers from. */
+export type HelpersPlacement = {
+    /** The published package, or helper sources emitted into the output tree. */
+    readonly mode: 'package' | 'embedded';
+    /**
+     * Relative path from this schema's output subdirectory back to the shared
+     * `_helpers/` at the output root. The recursive flows nest a schema's files a
+     * directory or more down, so `./` is only right at the top.
+     */
+    readonly importPrefix?: string;
+};
+/**
+ * Generates one schema's files, translating the CLI's flags into the single
+ * options object `@amritk/validation` takes.
+ *
+ * All four generation flows come through here so none of them can quietly hold a
+ * different opinion about what a flag means — which is exactly what happened
+ * while the CLI drove the two generators directly and positionally: the AsyncAPI
+ * flow passed `--unknown-keys` to the validators and forgot it for the parsers.
+ */
+export declare const generateFiles: (config: Partial<CliConfig>, schema: JSONSchema, rootTypeName: string, helpers: HelpersPlacement) => Promise<GeneratedFile[]>;

package/dist/generate-files.js

@@ -0,0 +1,24 @@
+import { generate } from "@amritk/validation";
+import { resolveImportExt } from "./resolve-import-ext.js";
+import { resolveModes } from "./resolve-modes.js";
+const generateFiles = async (config, schema, rootTypeName, helpers) => generate(schema, rootTypeName, {
+  modes: resolveModes(config),
+  typeSuffix: config.typeSuffix ?? "",
+  branchErrors: config.branchErrors === true,
+  stripUnknown: config.stripUnknown === true,
+  readonly: config.readonly === true,
+  caseInsensitive: config.caseInsensitive === true,
+  helpersMode: helpers.mode,
+  helpersImportPrefix: helpers.importPrefix ?? "./",
+  importExt: resolveImportExt(config),
+  logWarnings: config.logWarnings === true,
+  // Spread rather than passed as `undefined`: under
+  // `exactOptionalPropertyTypes` an absent option and one set to `undefined`
+  // are different things, and only the first falls back to the generator's own
+  // default.
+  ...config.unknownKeys !== void 0 ? { unknownKeys: config.unknownKeys } : {},
+  ...config.formats !== void 0 ? { formats: config.formats } : {}
+});
+export {
+  generateFiles
+};

package/dist/help-text.d.ts

@@ -4,4 +4,4 @@
  * documents these flags (config.schema.json) is not shipped in the published
  * package; the help-text test cross-checks that every flag is listed.
  */
-export declare const HELP_TEXT = "mjst \u2014 generate TypeScript parsers and type definitions from JSON Schemas\n\nUsage:\n  mjst --schema <path> --out-dir <dir> [options]\n  mjst --schema-dir <dir> --out-dir <dir> [options]\n  mjst --schema <path> --out-file <file> --types-only [options]\n\nSubcommands (each with its own flags and --help):\n  mjst lint <files>                       Lint JSON/YAML documents against a ruleset\n  mjst compile-api <module> --out <file>  Compile @amritk/api route contracts into a fetch-handler module\n  mjst markdown <schema> --out-dir <dir>  Generate markdown documentation from a JSON Schema\n\nInput:\n  --schema <path>       Schema to process: a JSON Schema file, or a module when --input is set\n  --schema-dir <dir>    Directory of JSON Schemas, processed recursively (instead of --schema)\n  --input <format>      Schema source format: json (default), typebox, zod, valibot, effect, avro,\n                        or asyncapi (an AsyncAPI 2.x/3.0 document, JSON or YAML)\n  --export <name>       Which export of the schema module to use when --input names a module format\n\nOutput:\n  --out-dir <dir>       Output directory for the generated files\n  --out-file <file>     Single-file output instead of a directory (requires --types-only)\n  --types-only          Generate type definitions only, without parser functions\n  --validators          Also emit validateX/isX validators into a validators/ subdir\n  --examples            Also emit fast-check arbitraries + example values under examples/\n  --message-contracts   Also emit @amritk/api channel contracts under contracts/ (--input asyncapi only)\n  --discriminator <p>   Property naming which message a frame is, for --message-contracts (default: type)\n  --build               Compile the generated files to .js/.d.ts (implies --import-ext js)\n  --force               Deprecated; ignored (generated files always overwrite)\n  --import-ext <ext>    Extension on generated relative imports: ts (default) or js\n  --helpers <mode>      Runtime helpers: package or embedded (default: auto-detect from package.json)\n  --root-type <name>    Root type name for a single --schema run (default: schema title or filename)\n  --type-suffix <s>     Suffix appended to every $ref-derived type name\n  --banner [text]       Prepend a header comment to every generated file\n  --readonly            Emit deeply readonly type definitions\n\nValidation:\n  --strict              Throw on type/shape mismatches instead of coercing to defaults\n  --strip-unknown       Silently drop undeclared input keys at every nesting level\n  --case-insensitive    Normalize mis-cased enum/const strings to their exact casing\n  --log-warnings        console.warn on input keys not declared in the schema\n  --unknown-keys <s>    How closed objects are proven free of undeclared keys:\n                        count-keys (default, fastest on Bun) or count-enumerable (fastest on Node)\n  --formats <f>         String formats the generated validators enforce: \"all\", or a\n                        comma-separated list (e.g. uuid,date-time,email). Off by default,\n                        which leaves \"format\" an annotation as JSON Schema reads it.\n\nReference resolution:\n  --resolve-remote      Fetch http(s) $refs while resolving cross-file/remote refs (off by default)\n  --allowed-hosts <h>   Restrict remote $ref fetches to these hosts (comma-separated; implies --resolve-remote)\n  --allow-private-hosts Permit remote $refs to private/loopback hosts (SSRF guard, off by default)\n  --allowed-roots <d>   Extra directories a local $ref may resolve into, on top of the schema's own\n                        (comma-separated; relative to the current directory)\n\nMisc:\n  --config <path>       JSON config file with the same keys; CLI flags take precedence\n  --version, -v         Print the CLI version\n  --help, -h            Print this help\n\nDocs: https://github.com/amritk/mjst/tree/main/packages/cli#readme\n";
+export declare const HELP_TEXT = "mjst \u2014 generate TypeScript types, validators and parsers from JSON Schemas\n\nUsage:\n  mjst --schema <path> --out-dir <dir> [options]\n  mjst --schema-dir <dir> --out-dir <dir> [options]\n  mjst --schema <path> --out-file <file> --types-only [options]\n\nSubcommands (each with its own flags and --help):\n  mjst lint <files>                       Lint JSON/YAML documents against a ruleset\n  mjst compile-api <module> --out <file>  Compile @amritk/api route contracts into a fetch-handler module\n  mjst markdown <schema> --out-dir <dir>  Generate markdown documentation from a JSON Schema\n\nInput:\n  --schema <path>       Schema to process: a JSON Schema file, or a module when --input is set\n  --schema-dir <dir>    Directory of JSON Schemas, processed recursively (instead of --schema)\n  --input <format>      Schema source format: json (default), typebox, zod, valibot, effect, avro,\n                        or asyncapi (an AsyncAPI 2.x/3.0 document, JSON or YAML)\n  --export <name>       Which export of the schema module to use when --input names a module format\n\nOutput:\n  --out-dir <dir>       Output directory for the generated files\n  --out-file <file>     Single-file output instead of a directory (requires --types-only)\n  --types-only          Generate type definitions only, without parser functions\n  --validators          Also emit validateX/isX validators beside the parsers, over one\n                        shared declaration of each generated type\n  --validators-only     Emit the validator half and no parser: the type, isX, validateX and\n                        whichever of checkX/coerceX/repairX were asked for (implies\n                        --validators; the mirror of --types-only)\n  --check               Also emit checkX, the same result as validateX but stopped at the\n                        first violation (requires --validators)\n  --coerce              Also emit coerceX, which coerces scalars the way Ajv's coerceTypes\n                        does and then validates (requires --validators)\n  --repair              Also emit repairX, which coerces, validates, then repairs each\n                        rejected position to a schema-supplied value and reports the\n                        errors it repaired (implies --coerce; requires --validators)\n  --branch-errors       Explain a failing anyOf/oneOf with the errors of the branch it\n                        meant (requires --validators; costs a little on unions)\n  --examples            Also emit fast-check arbitraries + example values under examples/\n  --message-contracts   Also emit @amritk/api channel contracts under contracts/ (--input asyncapi only)\n  --discriminator <p>   Property naming which message a frame is, for --message-contracts (default: type)\n  --build               Compile the generated files to .js/.d.ts (implies --import-ext js)\n  --force               Deprecated; ignored (generated files always overwrite)\n  --import-ext <ext>    Extension on generated relative imports: ts (default) or js\n  --helpers <mode>      Runtime helpers: package or embedded (default: auto-detect from package.json)\n  --root-type <name>    Root type name for a single --schema run (default: schema title or filename)\n  --type-suffix <s>     Suffix appended to every $ref-derived type name\n  --banner [text]       Prepend a header comment to every generated file\n  --readonly            Emit deeply readonly type definitions\n\nValidation:\n  --strict              Throw on type/shape mismatches instead of coercing to defaults\n  --strip-unknown       Silently drop undeclared input keys at every nesting level\n  --case-insensitive    Normalize mis-cased enum/const strings to their exact casing\n  --log-warnings        console.warn on input keys not declared in the schema\n  --unknown-keys <s>    How closed objects are proven free of undeclared keys:\n                        count-keys (default, fastest on Bun) or count-enumerable (fastest on Node)\n  --formats <f>         String formats the generated validators enforce: \"all\", or a\n                        comma-separated list (e.g. uuid,date-time,email). Off by default,\n                        which leaves \"format\" an annotation as JSON Schema reads it.\n\nReference resolution:\n  --resolve-remote      Fetch http(s) $refs while resolving cross-file/remote refs (off by default)\n  --allowed-hosts <h>   Restrict remote $ref fetches to these hosts (comma-separated; implies --resolve-remote)\n  --allow-private-hosts Permit remote $refs to private/loopback hosts (SSRF guard, off by default)\n  --allowed-roots <d>   Extra directories a local $ref may resolve into, on top of the schema's own\n                        (comma-separated; relative to the current directory)\n\nMisc:\n  --config <path>       JSON config file with the same keys; CLI flags take precedence\n  --version, -v         Print the CLI version\n  --help, -h            Print this help\n\nDocs: https://github.com/amritk/mjst/tree/main/packages/cli#readme\n";

package/dist/help-text.js

@@ -1,4 +1,4 @@
-const HELP_TEXT = `mjst \u2014 generate TypeScript parsers and type definitions from JSON Schemas
+const HELP_TEXT = `mjst \u2014 generate TypeScript types, validators and parsers from JSON Schemas
 
 Usage:
   mjst --schema <path> --out-dir <dir> [options]
@@ -21,7 +21,20 @@ Output:
   --out-dir <dir>       Output directory for the generated files
   --out-file <file>     Single-file output instead of a directory (requires --types-only)
   --types-only          Generate type definitions only, without parser functions
-  --validators          Also emit validateX/isX validators into a validators/ subdir
+  --validators          Also emit validateX/isX validators beside the parsers, over one
+                        shared declaration of each generated type
+  --validators-only     Emit the validator half and no parser: the type, isX, validateX and
+                        whichever of checkX/coerceX/repairX were asked for (implies
+                        --validators; the mirror of --types-only)
+  --check               Also emit checkX, the same result as validateX but stopped at the
+                        first violation (requires --validators)
+  --coerce              Also emit coerceX, which coerces scalars the way Ajv's coerceTypes
+                        does and then validates (requires --validators)
+  --repair              Also emit repairX, which coerces, validates, then repairs each
+                        rejected position to a schema-supplied value and reports the
+                        errors it repaired (implies --coerce; requires --validators)
+  --branch-errors       Explain a failing anyOf/oneOf with the errors of the branch it
+                        meant (requires --validators; costs a little on unions)
   --examples            Also emit fast-check arbitraries + example values under examples/
   --message-contracts   Also emit @amritk/api channel contracts under contracts/ (--input asyncapi only)
   --discriminator <p>   Property naming which message a frame is, for --message-contracts (default: type)

package/dist/load-config.js

@@ -30,10 +30,13 @@ const loadConfig = async (configPath) => {
     ...typeof obj["export"] === "string" && { export: obj["export"] },
     ...typeof obj["validators"] === "boolean" && { validators: obj["validators"] },
     ...typeof obj["typesOnly"] === "boolean" && { typesOnly: obj["typesOnly"] },
+    ...typeof obj["validatorsOnly"] === "boolean" && { validatorsOnly: obj["validatorsOnly"] },
     ...typeof obj["examples"] === "boolean" && { examples: obj["examples"] },
     ...typeof obj["messageContracts"] === "boolean" && { messageContracts: obj["messageContracts"] },
     ...typeof obj["discriminator"] === "string" && { discriminator: obj["discriminator"] },
     ...typeof obj["build"] === "boolean" && { build: obj["build"] },
+    ...typeof obj["coerce"] === "boolean" && { coerce: obj["coerce"] },
+    ...typeof obj["branchErrors"] === "boolean" && { branchErrors: obj["branchErrors"] },
     ...typeof obj["force"] === "boolean" && { force: obj["force"] },
     ...typeof obj["logWarnings"] === "boolean" && { logWarnings: obj["logWarnings"] },
     ...typeof obj["strict"] === "boolean" && { strict: obj["strict"] },

package/dist/markdown/help-text.d.ts

@@ -3,4 +3,4 @@
  * HELP_TEXT: the flag list is small and stable, and the test cross-checks that
  * every flag is listed.
  */
-export declare const MARKDOWN_HELP_TEXT = "mjst markdown \u2014 generate markdown documentation from a JSON Schema\n\nUsage:\n  mjst markdown <schema> --out-dir <dir> [options]\n  mjst markdown <schema> --table --readme <file>\n\nTwo shapes come out of the same schema. By default it writes the prose\nreference \u2014 a heading, a type, the description and an example per property,\nacross as many pages as the schema's x-doc keyword declares. With --table it\nrenders one HTML table instead and splices it into an existing markdown file\nbetween <!-- config-table-start --> and <!-- config-table-end -->, leaving the\nrest of that file alone.\n\nProse reference options:\n  --out-dir <dir>      Directory the pages are written to (default: the current directory)\n  --file <path>        Output path of the index page (default: the schema's x-doc.file, then index.md)\n  --title <text>       Page title (default: the schema's title)\n  --language <lang>    Fence language for derived examples and literals (default: json)\n  --layout <mode>      Default layout for nested properties: headings (default), table, or none\n  --sort <order>       Property order: schema (default) or alphabetical\n  --heading-level <n>  Heading level of the page title, 1-6 (default: 1)\n\nTable options:\n  --table              Render the HTML config table instead of the prose pages\n  --readme <path>      Markdown file the table is spliced into (default: README.md)\n\nMisc:\n  --help, -h           Print this help\n\nDocs: https://github.com/amritk/mjst/tree/main/packages/cli#readme\n";
+export declare const MARKDOWN_HELP_TEXT = "mjst markdown \u2014 generate markdown documentation from a JSON Schema\n\nUsage:\n  mjst markdown <schema> --out-dir <dir> [options]\n  mjst markdown <schema> --table --readme <file>\n\nTwo shapes come out of the same schema. By default it writes the prose\nreference \u2014 a heading, a type, the description and an example per property,\nacross as many pages as the schema's x-doc keyword declares. With --table it\nrenders one HTML table instead and splices it into an existing markdown file\nbetween <!-- config-table-start --> and <!-- config-table-end -->, leaving the\nrest of that file alone.\n\nProse reference options:\n  --out-dir <dir>      Directory the pages are written to (default: the current directory)\n  --file <path>        Output path of the index page (default: the schema's x-doc.file, then index.md)\n  --title <text>       Page title (default: the schema's title)\n  --language <lang>    Fence language for derived examples and literals (default: json)\n  --layout <mode>      Default layout for nested properties: headings (default), table, or none\n  --sort <order>       Property order: schema (default) or alphabetical\n  --heading-level <n>  Heading level of the page title, 1-6 (default: 1)\n\nProperty table options (the root x-doc.table, for every table on every page):\n  --type-column <when>     Render the Type column: auto (default), always, or never\n  --default-column <when>  Render the Default column: auto (default), always, or never\n  --required-style <how>   Say which properties are required: marker (default, beside\n                           the name) or column (a Required column)\n  --required-first         List the required properties at the top of every table\n\nTable options:\n  --table              Render the HTML config table instead of the prose pages\n  --readme <path>      Markdown file the table is spliced into (default: README.md)\n\nMisc:\n  --help, -h           Print this help\n\nDocs: https://github.com/amritk/mjst/tree/main/packages/cli#readme\n";

package/dist/markdown/help-text.js

@@ -20,6 +20,13 @@ Prose reference options:
   --sort <order>       Property order: schema (default) or alphabetical
   --heading-level <n>  Heading level of the page title, 1-6 (default: 1)
 
+Property table options (the root x-doc.table, for every table on every page):
+  --type-column <when>     Render the Type column: auto (default), always, or never
+  --default-column <when>  Render the Default column: auto (default), always, or never
+  --required-style <how>   Say which properties are required: marker (default, beside
+                           the name) or column (a Required column)
+  --required-first         List the required properties at the top of every table
+
 Table options:
   --table              Render the HTML config table instead of the prose pages
   --readme <path>      Markdown file the table is spliced into (default: README.md)

package/dist/markdown/parse-markdown-args.d.ts

@@ -1,4 +1,4 @@
-import type { DocLayout, DocSort } from '@amritk/generate-markdown';
+import type { DocLayout, DocSort, DocTableColumn, DocTableRequired } from '@amritk/generate-markdown';
 /** The flags and positional the `markdown` subcommand understands. */
 export type MarkdownArgs = {
     /** Path to the JSON Schema to document (the sole positional). */
@@ -17,6 +17,14 @@ export type MarkdownArgs = {
     sort?: DocSort;
     /** Heading level of the page title (`--heading-level`). */
     headingLevel?: number;
+    /** When property tables render their Type column (`--type-column`). */
+    typeColumn?: DocTableColumn;
+    /** When property tables render their Default column (`--default-column`). */
+    defaultColumn?: DocTableColumn;
+    /** How property tables say which properties are required (`--required-style`). */
+    requiredStyle?: DocTableRequired;
+    /** True when `--required-first` was passed: required properties head every table. */
+    requiredFirst?: boolean;
     /** True when `--table` was passed: render the HTML table instead of the pages. */
     table?: boolean;
     /** Markdown file the table is spliced into (`--readme`). */

package/dist/markdown/parse-markdown-args.js

@@ -1,7 +1,21 @@
-const VALUE_KEYS = /* @__PURE__ */ new Set(["outDir", "file", "title", "language", "layout", "sort", "headingLevel", "readme"]);
-const BOOLEAN_KEYS = /* @__PURE__ */ new Set(["table"]);
+const VALUE_KEYS = /* @__PURE__ */ new Set([
+  "outDir",
+  "file",
+  "title",
+  "language",
+  "layout",
+  "sort",
+  "headingLevel",
+  "typeColumn",
+  "defaultColumn",
+  "requiredStyle",
+  "readme"
+]);
+const BOOLEAN_KEYS = /* @__PURE__ */ new Set(["table", "requiredFirst"]);
 const LAYOUTS = ["headings", "table", "none"];
 const SORTS = ["schema", "alphabetical"];
+const TABLE_COLUMNS = ["auto", "always", "never"];
+const REQUIRED_STYLES = ["marker", "column"];
 const toCamelCase = (key) => key.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
 const parseChoice = (flag, value, choices) => {
   const match = choices.find((choice) => choice === value);
@@ -40,6 +54,15 @@ const assignValue = (args, key, value) => {
     case "headingLevel":
       args.headingLevel = parseHeadingLevel(value);
       return;
+    case "typeColumn":
+      args.typeColumn = parseChoice("type-column", value, TABLE_COLUMNS);
+      return;
+    case "defaultColumn":
+      args.defaultColumn = parseChoice("default-column", value, TABLE_COLUMNS);
+      return;
+    case "requiredStyle":
+      args.requiredStyle = parseChoice("required-style", value, REQUIRED_STYLES);
+      return;
     case "readme":
       args.readme = value;
       return;
@@ -78,7 +101,10 @@ const parseMarkdownArgs = (argv) => {
     const flagName = arg.slice(2);
     const key = toCamelCase(flagName);
     if (BOOLEAN_KEYS.has(key)) {
-      args.table = true;
+      if (key === "requiredFirst")
+        args.requiredFirst = true;
+      else
+        args.table = true;
       continue;
     }
     if (!VALUE_KEYS.has(key))

package/dist/markdown/run.js

@@ -6,7 +6,19 @@ const usageError = (message) => ({ code: 2, stdout: "", stderr: `Error: ${messag
 ` });
 const failure = (message) => ({ code: 1, stdout: "", stderr: `Error: ${message}
 ` });
-const PAGE_FLAGS = ["outDir", "file", "title", "language", "layout", "sort", "headingLevel"];
+const PAGE_FLAGS = [
+  "outDir",
+  "file",
+  "title",
+  "language",
+  "layout",
+  "sort",
+  "headingLevel",
+  "typeColumn",
+  "defaultColumn",
+  "requiredStyle",
+  "requiredFirst"
+];
 const run = async (argv) => {
   let args;
   try {
@@ -51,7 +63,15 @@ const run = async (argv) => {
     language: args.language,
     layout: args.layout,
     sort: args.sort,
-    headingLevel: args.headingLevel
+    headingLevel: args.headingLevel,
+    // Always passed: every member is optional, so the schema's own
+    // `x-doc.table` still decides whatever the flags left alone.
+    table: {
+      type: args.typeColumn,
+      default: args.defaultColumn,
+      required: args.requiredStyle,
+      requiredFirst: args.requiredFirst
+    }
   };
   let files;
   try {

package/dist/parse-cli-args.js

@@ -4,6 +4,11 @@ const LIST_KEYS = /* @__PURE__ */ new Set(["allowedHosts", "allowedRoots"]);
 const BOOLEAN_KEYS = /* @__PURE__ */ new Set([
   "typesOnly",
   "validators",
+  "validatorsOnly",
+  "check",
+  "coerce",
+  "repair",
+  "branchErrors",
   "examples",
   "messageContracts",
   "build",
@@ -124,9 +129,24 @@ const assignBoolean = (config, key, value) => {
     case "typesOnly":
       config.typesOnly = value;
       return true;
+    case "validatorsOnly":
+      config.validatorsOnly = value;
+      return true;
     case "validators":
       config.validators = value;
       return true;
+    case "check":
+      config.check = value;
+      return true;
+    case "coerce":
+      config.coerce = value;
+      return true;
+    case "repair":
+      config.repair = value;
+      return true;
+    case "branchErrors":
+      config.branchErrors = value;
+      return true;
     case "examples":
       config.examples = value;
       return true;

package/dist/resolve-modes.d.ts

@@ -0,0 +1,19 @@
+import type { Mode } from '@amritk/validation';
+import type { CliConfig } from './cli-config.js';
+/**
+ * Turns the flags a run was given into the list of entry points `generate()`
+ * should emit.
+ *
+ * The CLI predates the mode list: its flags grew one at a time, each one meaning
+ * "also emit this function", so the mapping is additive rather than a choice.
+ * Keeping it in one place means the four generation flows cannot drift on what
+ * `--strict --validators --repair` is supposed to produce.
+ *
+ * `--types-only` is the one run with nothing to execute, so it stops at `types`
+ * — asking for a parser there would emit runtime code the flag exists to avoid.
+ * `--validators-only` is its mirror at the other end: everything that judges a
+ * document, and nothing that builds one. Between them, every run carries a
+ * parser, because emitting one is what the CLI does when you do not tell it
+ * otherwise.
+ */
+export declare const resolveModes: (config: Partial<CliConfig>) => Mode[];

package/dist/resolve-modes.js

@@ -0,0 +1,21 @@
+const resolveModes = (config) => {
+  if (config.typesOnly === true)
+    return ["types"];
+  const modes = ["types"];
+  if (config.validators === true || config.validatorsOnly === true) {
+    modes.push("guard", "validate");
+    if (config.check === true)
+      modes.push("check");
+    if (config.coerce === true)
+      modes.push("coerce");
+    if (config.repair === true)
+      modes.push("repair");
+  }
+  if (config.validatorsOnly !== true) {
+    modes.push(config.strict === true ? "parseStrict" : "parse");
+  }
+  return modes;
+};
+export {
+  resolveModes
+};

package/dist/validate-config.js

@@ -8,7 +8,12 @@ const CONFIG_KEYS = {
   outDir: { type: "string" },
   outFile: { type: "string" },
   typesOnly: { type: "boolean" },
+  validatorsOnly: { type: "boolean" },
   validators: { type: "boolean" },
+  check: { type: "boolean" },
+  coerce: { type: "boolean" },
+  repair: { type: "boolean" },
+  branchErrors: { type: "boolean" },
   examples: { type: "boolean" },
   messageContracts: { type: "boolean" },
   discriminator: { type: "string" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/mjst",
-  "version": "0.21.1",
+  "version": "0.23.0",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "type": "module",
   "engines": {
@@ -49,15 +49,14 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@amritk/adapters": "^0.6.3",
-    "@amritk/api": "^0.16.4",
-    "@amritk/asyncapi": "^0.3.1",
-    "@amritk/generate-examples": "^0.8.5",
-    "@amritk/generate-markdown": "^0.8.0",
-    "@amritk/generate-parsers": "^0.24.0",
-    "@amritk/generate-validators": "^0.18.0",
-    "@amritk/helpers": "^0.22.0",
-    "@amritk/lint": "^0.6.0",
+    "@amritk/adapters": "^0.6.5",
+    "@amritk/api": "^0.16.5",
+    "@amritk/asyncapi": "^0.3.3",
+    "@amritk/generate-examples": "^0.8.7",
+    "@amritk/generate-markdown": "^0.9.0",
+    "@amritk/helpers": "^0.23.1",
+    "@amritk/lint": "^0.6.1",
+    "@amritk/validation": "^0.3.0",
     "@amritk/resolve-refs": "^0.7.1",
     "@amritk/yaml": "^0.7.2",
     "fast-glob": "^3.3.2",