@amritk/mjst 0.7.6 → 0.7.7

package/README.md

@@ -204,7 +204,7 @@ npx mjst --config ./mjst.config.json
 <td align="center"><code>false</code></td>
 </tr>
 <tr>
-<td colspan="5">Generate parsers that throw on type/shape mismatches (wrong type, missing required property, enum/pattern/min/max violations) instead of coercing invalid input to default values. Unknown extra keys are still allowed.</td>
+<td colspan="5">Generate parsers that throw on type/shape mismatches (wrong type, missing required property, enum/pattern/min/max violations) instead of coercing invalid input to default values. When a schema sets additionalProperties: false, undeclared keys throw too; otherwise they are still allowed.</td>
 </tr>
 <tr>
 <td>🔒 <code>readonly</code></td>

package/dist/cli-config.d.ts

@@ -81,4 +81,3 @@ export type CliConfig = {
      */
     readonly banner?: boolean | string;
 };
-//# sourceMappingURL=cli-config.d.ts.map

package/dist/cli.d.ts

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
 export {};
-//# sourceMappingURL=cli.d.ts.map

package/dist/combine-files.d.ts

@@ -11,4 +11,3 @@ import type { GeneratedFile } from '@amritk/generate-parsers';
  * type-only relative imports (no runtime helpers).
  */
 export declare const combineGeneratedFiles: (files: readonly GeneratedFile[]) => string;
-//# sourceMappingURL=combine-files.d.ts.map

package/dist/detect-helpers-mode.d.ts

@@ -8,4 +8,3 @@
  * for the output to be self-contained.
  */
 export declare const detectHelpersMode: (outputDir: string) => 'package' | 'embedded';
-//# sourceMappingURL=detect-helpers-mode.d.ts.map

package/dist/load-config.d.ts

@@ -4,4 +4,3 @@ import type { CliConfig } from './cli-config.js';
  * The config file should have the same keys as the CLI flags (schema, outDir).
  */
 export declare const loadConfig: (configPath: string) => Promise<Partial<CliConfig>>;
-//# sourceMappingURL=load-config.d.ts.map

package/dist/load-schema-module.d.ts

@@ -14,4 +14,3 @@
  * for a `.ts` path so the cause is not a cryptic module-resolution error.
  */
 export declare const loadSchemaModule: (modulePath: string, exportName?: string) => Promise<unknown>;
-//# sourceMappingURL=load-schema-module.d.ts.map

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

@@ -7,4 +7,3 @@ import type { CliConfig } from './cli-config.js';
  * provided are returned so they can be layered on top of config file values.
  */
 export declare const parseCliArgs: (args: readonly string[]) => Partial<CliConfig>;
-//# sourceMappingURL=parse-cli-args.d.ts.map

package/dist/read-version.d.ts

@@ -6,4 +6,3 @@
  * sits one directory above both.
  */
 export declare const readVersion: () => Promise<string>;
-//# sourceMappingURL=read-version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/mjst",
-  "version": "0.7.6",
+  "version": "0.7.7",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "type": "module",
   "license": "MIT",
@@ -27,8 +27,7 @@
     "mjst": "./dist/cli.js"
   },
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "publishConfig": {
     "access": "public"
@@ -42,10 +41,10 @@
     "generate-readme": "bun run ./scripts/generate-readme.ts"
   },
   "dependencies": {
-    "@amritk/adapters": "0.2.8",
-    "@amritk/generate-parsers": "0.7.2",
+    "@amritk/adapters": "0.2.9",
+    "@amritk/generate-parsers": "0.8.0",
     "@amritk/generate-markdown": "0.2.4",
-    "@amritk/helpers": "0.8.0"
+    "@amritk/helpers": "0.9.0"
   },
   "devDependencies": {
     "json-schema-typed": "^8.0.1"

package/dist/cli-config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli-config.d.ts","sourceRoot":"","sources":["../src/cli-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAA;AAElE;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB,iGAAiG;IACjG,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IACxB;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;IAC3B;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,YAAY,CAAA;IAC7B;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IACxB,0FAA0F;IAC1F,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IACxB;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;IACzB;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAA;IAC5B;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;IACxB;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAA;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;IACzB;;;;;;;;OAQG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,GAAG,UAAU,CAAA;IACzC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;IAC5B;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;CACnC,CAAA"}

package/dist/cli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/combine-files.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"combine-files.d.ts","sourceRoot":"","sources":["../src/combine-files.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAO7D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,UAAW,SAAS,aAAa,EAAE,KAAG,MAwBvE,CAAA"}

package/dist/detect-helpers-mode.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"detect-helpers-mode.d.ts","sourceRoot":"","sources":["../src/detect-helpers-mode.ts"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,cAAe,MAAM,KAAG,SAAS,GAAG,UAQjE,CAAA"}

package/dist/load-config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"load-config.d.ts","sourceRoot":"","sources":["../src/load-config.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAO7C;;;GAGG;AACH,eAAO,MAAM,UAAU,eAAsB,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,CAwB/E,CAAA"}

package/dist/load-schema-module.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"load-schema-module.d.ts","sourceRoot":"","sources":["../src/load-schema-module.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,eAAsB,MAAM,eAAe,MAAM,KAAG,OAAO,CAAC,OAAO,CAkC/F,CAAA"}

package/dist/parse-cli-args.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse-cli-args.d.ts","sourceRoot":"","sources":["../src/parse-cli-args.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAgH7C;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,SAAU,SAAS,MAAM,EAAE,KAAG,OAAO,CAAC,SAAS,CA0DvE,CAAA"}

package/dist/read-version.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"read-version.d.ts","sourceRoot":"","sources":["../src/read-version.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,QAAa,OAAO,CAAC,MAAM,CAIlD,CAAA"}

package/src/cli-config.ts

@@ -1,84 +0,0 @@
-import type { SourceFormat } from '@amritk/adapters/source-format'
-
-/**
- * Configuration for the CLI tool.
- * These properties map 1:1 with CLI flags and config file keys.
- */
-export type CliConfig = {
-  /** Path to the schema to process — a JSON Schema file, or a JS/TS module when `input` is set. */
-  readonly schema?: string
-  /**
-   * Path to a directory of JSON Schema files. When set, the CLI walks the directory
-   * recursively, generates parsers for every `*.json` schema it finds, and mirrors the
-   * directory layout under `outDir`. A single shared `_helpers/` directory is emitted at
-   * the root of `outDir` (in embedded mode) and every nested parser imports from it.
-   * Mutually exclusive with `schema`; when both are present `schemaDir` wins.
-   */
-  readonly schemaDir?: string
-  /**
-   * The source format of the schema. Defaults to `'json'` (a plain JSON Schema file).
-   * Any other format loads `schema` as a module and converts it via the matching adapter.
-   */
-  readonly input?: SourceFormat
-  /**
-   * Which export of the schema module to use when `input` is not `'json'`.
-   * Defaults to the default export, or the sole named export when there is exactly one.
-   */
-  readonly export?: string
-  /** Output directory for generated TypeScript files. Mutually exclusive with `outFile`. */
-  readonly outDir?: string
-  /**
-   * Output everything to a single TypeScript file instead of a directory of files.
-   * Mutually exclusive with `outDir`. Currently supported only with `typesOnly`.
-   */
-  readonly outFile?: string
-  /**
-   * When true, only generate TypeScript type definitions without parser functions.
-   * Useful when you only need the type shapes and do not need runtime validation.
-   */
-  readonly typesOnly?: boolean
-  /**
-   * When true, compile the generated TypeScript files to .js and .d.ts output.
-   * The .ts source files are removed after compilation.
-   */
-  readonly build?: boolean
-  /**
-   * When true, the generated parsers emit a console.warn for every input key
-   * that is not declared in the schema's properties.
-   */
-  readonly logWarnings?: boolean
-  /**
-   * When true, the generated parsers throw on type/shape mismatches
-   * (wrong type, missing required property, enum/pattern/min/max violations)
-   * instead of coercing invalid input to default values.
-   */
-  readonly strict?: boolean
-  /**
-   * Controls how generated parsers reference their runtime helpers.
-   * - `'package'`: emit `import ... from '@amritk/helpers/...'`.
-   * - `'embedded'`: ship the helper source under `outDir/_helpers/` and emit
-   *   relative imports so the output directory is self-contained.
-   *
-   * When omitted, the CLI auto-detects: it picks `'package'` if `@amritk/helpers`
-   * resolves from outDir, otherwise falls back to `'embedded'`.
-   */
-  readonly helpers?: 'package' | 'embedded'
-  /**
-   * When true, every property, array, and record in the generated type
-   * definitions is emitted as `readonly`, producing deeply immutable types.
-   */
-  readonly readonly?: boolean
-  /**
-   * Suffix appended to every generated type name derived from a `$ref`
-   * (e.g. `'Object'` turns `Contact` into `ContactObject`). Defaults to `''`
-   * (no suffix). The root type name is used verbatim and is unaffected.
-   */
-  readonly typeSuffix?: string
-  /**
-   * Prepends a comment header to every generated file (excluding `_helpers/`).
-   * - `true` — use the default message: "This file was auto-generated by @amritk/mjst…"
-   * - A string — use that text as the message body (wrapped in a JSDoc block).
-   * - `false` / omitted — no header.
-   */
-  readonly banner?: boolean | string
-}

package/src/cli.ts

@@ -1,371 +0,0 @@
-#!/usr/bin/env node
-import { execFile } from 'node:child_process'
-import { mkdir, readdir, readFile, unlink, writeFile } from 'node:fs/promises'
-import { basename, dirname, join, relative, resolve, sep } from 'node:path'
-import { promisify } from 'node:util'
-import { getAdapter } from '@amritk/adapters/get-adapter'
-import { buildSchema } from '@amritk/generate-parsers'
-import { deriveRootTypeName } from '@amritk/helpers/derive-root-type-name'
-import type { JSONSchema } from 'json-schema-typed/draft-2020-12'
-
-const execFileAsync = promisify(execFile)
-
-import type { CliConfig } from './cli-config'
-import { combineGeneratedFiles } from './combine-files'
-import { detectHelpersMode } from './detect-helpers-mode'
-import { loadConfig } from './load-config'
-import { loadSchemaModule } from './load-schema-module'
-import { parseCliArgs } from './parse-cli-args'
-import { readVersion } from './read-version'
-
-/** True when the args request the CLI version (`version`, `--version`, or `-v`). */
-const isVersionRequest = (args: readonly string[]): boolean =>
-  args[0] === 'version' || args.includes('--version') || args.includes('-v')
-
-/**
- * Extracts the --config flag value from process args before full parsing.
- * We need this early so we can load the config file first, then overlay CLI flags.
- */
-const extractConfigPath = (args: readonly string[]): string | undefined => {
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i]
-
-    if (arg === '--config' && args[i + 1] && !args[i + 1]?.startsWith('--')) {
-      return args[i + 1]
-    }
-
-    if (arg?.startsWith('--config=')) {
-      return arg.slice('--config='.length)
-    }
-  }
-
-  return undefined
-}
-
-/** Reads a JSON Schema off disk, or loads a module and converts it via its adapter. */
-const loadSchema = async (config: Partial<CliConfig>, schemaPath: string): Promise<unknown> => {
-  const inputFormat = config.input ?? 'json'
-
-  if (inputFormat === 'json') {
-    return JSON.parse(await readFile(schemaPath, 'utf-8'))
-  }
-
-  console.log(`Input format: ${inputFormat}`)
-  const source = await loadSchemaModule(schemaPath, config.export)
-  return getAdapter(inputFormat).toJSONSchema(source)
-}
-
-const DEFAULT_BANNER_TEXT =
-  'This file was auto-generated by @amritk/mjst.\n * Do not edit it manually — your changes will be overwritten on the next generation.'
-
-const resolveBanner = (banner: boolean | string | undefined): string => {
-  if (!banner) return ''
-  const text = banner === true ? DEFAULT_BANNER_TEXT : banner
-  return `/**\n * ${text}\n */\n\n`
-}
-
-/** Writes a generated file, creating any parent directories the filename implies. */
-const writeGeneratedFile = async (baseDir: string, filename: string, content: string): Promise<void> => {
-  const filePath = join(baseDir, filename)
-  await mkdir(dirname(filePath), { recursive: true })
-  await writeFile(filePath, content, 'utf-8')
-}
-
-/**
- * Compiles the generated `.ts` files to `.js`/`.d.ts` with a temporary tsconfig,
- * then removes the intermediate sources. `tsFiles` are paths relative to `outputDir`.
- */
-const buildOutput = async (outputDir: string, tsFiles: readonly string[], typesOnly?: boolean): Promise<void> => {
-  // Write a minimal tsconfig so tsc can compile the generated files without
-  // inheriting settings like allowImportingTsExtensions that block emission.
-  // In 'package' mode tsc finds @amritk/helpers via the consumer's node_modules.
-  // In 'embedded' mode the helpers live under ./_helpers and need no resolution.
-  const tsconfigContent = JSON.stringify(
-    {
-      compilerOptions: {
-        target: 'ESNext',
-        module: 'ESNext',
-        moduleResolution: 'bundler',
-        declaration: true,
-        emitDeclarationOnly: typesOnly,
-        skipLibCheck: true,
-      },
-      include: tsFiles.map((file) => `./${file}`),
-    },
-    null,
-    2,
-  )
-
-  const tsconfigPath = join(outputDir, '.tsconfig-mjst-build.json')
-  await writeFile(tsconfigPath, tsconfigContent, 'utf-8')
-
-  try {
-    await execFileAsync('npx', ['tsc', '--project', tsconfigPath])
-  } catch (error) {
-    // tsc reports the actual errors on stdout; surface them so the user sees
-    // *what* failed instead of a bare "compilation failed".
-    const details = error as { stdout?: string; stderr?: string }
-    const output = [details.stdout, details.stderr].filter(Boolean).join('\n').trim()
-    throw new Error(
-      `TypeScript compilation failed. Check the generated files for errors.${output ? `\n\n${output}` : ''}`,
-    )
-  } finally {
-    await unlink(tsconfigPath)
-  }
-
-  // Remove the intermediate .ts files now that .js and .d.ts have been produced
-  for (const file of tsFiles) {
-    await unlink(join(outputDir, file))
-    console.log(`Built: ${file.replace(/\.ts$/, '.js')}`)
-    console.log(`Built: ${file.replace(/\.ts$/, '.d.ts')}`)
-  }
-
-  console.log(`\nTotal files built: ${tsFiles.length * 2}`)
-}
-
-/** Recursively collects every `*.json` file under `dir`, returning absolute paths. */
-const findJsonSchemas = async (dir: string): Promise<string[]> => {
-  const entries = await readdir(dir, { withFileTypes: true })
-  const results: string[] = []
-
-  for (const entry of entries) {
-    const full = join(dir, entry.name)
-    if (entry.isDirectory()) {
-      results.push(...(await findJsonSchemas(full)))
-    } else if (entry.isFile() && entry.name.endsWith('.json')) {
-      results.push(full)
-    }
-  }
-
-  return results
-}
-
-/** Generates parsers for a single schema (the original one-schema-in, one-outDir-out flow). */
-const runSingle = async (config: Partial<CliConfig>, schemaPath: string, outputDir: string): Promise<void> => {
-  const schema = await loadSchema(config, schemaPath)
-
-  await mkdir(outputDir, { recursive: true })
-
-  const helpersMode = config.helpers ?? detectHelpersMode(outputDir)
-  console.log(`Helpers mode: ${helpersMode}${config.helpers ? ' (explicit)' : ' (auto-detected)'}`)
-
-  const rootTypeName = deriveRootTypeName(schema)
-  console.log(`Root type: ${rootTypeName}`)
-
-  const files = await buildSchema(
-    schema as JSONSchema,
-    rootTypeName,
-    undefined,
-    config.typesOnly,
-    config.logWarnings,
-    config.strict,
-    helpersMode,
-    undefined,
-    config.readonly,
-    config.typeSuffix,
-  )
-
-  for (const file of files) {
-    const isHelper = file.filename.startsWith('_helpers/')
-    const content = config.banner && !isHelper ? resolveBanner(config.banner) + file.content : file.content
-    await writeGeneratedFile(outputDir, file.filename, content)
-    console.log(`Generated: ${file.filename}`)
-  }
-
-  if (config.build) {
-    await buildOutput(
-      outputDir,
-      files.map((f) => f.filename),
-      config.typesOnly,
-    )
-  } else {
-    console.log(`\nTotal files generated: ${files.length}`)
-  }
-}
-
-/**
- * Generates a single self-contained file from one schema, concatenating every
- * generated definition (and dropping the cross-file imports that are no longer
- * needed) into `outFilePath`. Currently used for types-only output.
- */
-const runSingleFile = async (config: Partial<CliConfig>, schemaPath: string, outFilePath: string): Promise<void> => {
-  const schema = await loadSchema(config, schemaPath)
-  const outputDir = dirname(outFilePath)
-  await mkdir(outputDir, { recursive: true })
-
-  const rootTypeName = deriveRootTypeName(schema)
-  console.log(`Root type: ${rootTypeName}`)
-
-  const files = await buildSchema(
-    schema as JSONSchema,
-    rootTypeName,
-    undefined,
-    config.typesOnly,
-    config.logWarnings,
-    config.strict,
-    config.helpers ?? 'package',
-    undefined,
-    config.readonly,
-    config.typeSuffix,
-  )
-
-  const combined = combineGeneratedFiles(files)
-  await writeFile(outFilePath, config.banner ? resolveBanner(config.banner) + combined : combined, 'utf-8')
-  console.log(`Generated: ${relative(process.cwd(), outFilePath)}`)
-
-  if (config.build) {
-    await buildOutput(outputDir, [basename(outFilePath)], config.typesOnly)
-  } else {
-    console.log(`\nTotal files generated: 1`)
-  }
-}
-
-/**
- * Generates parsers for every JSON Schema under `schemaDir`, mirroring the directory
- * layout into `outDir`. Each schema's output lands in its own subdirectory (so files
- * from different schemas never collide) and the runtime helpers are emitted once into a
- * shared `outDir/_helpers/` that every nested parser imports from.
- */
-const runRecursive = async (config: Partial<CliConfig>, schemaDir: string, outputDir: string): Promise<void> => {
-  if (config.input && config.input !== 'json') {
-    console.error("Error: --schemaDir only supports JSON Schema files; remove --input or set it to 'json'.")
-    process.exit(1)
-  }
-
-  const schemaFiles = await findJsonSchemas(schemaDir)
-
-  if (schemaFiles.length === 0) {
-    console.error(`Error: no .json schema files found under ${schemaDir}.`)
-    process.exit(1)
-  }
-
-  await mkdir(outputDir, { recursive: true })
-
-  const helpersMode = config.helpers ?? detectHelpersMode(outputDir)
-  console.log(`Helpers mode: ${helpersMode}${config.helpers ? ' (explicit)' : ' (auto-detected)'}`)
-
-  // Helper sources are identical across schemas, so collect them by filename and
-  // write the deduplicated set once at the output root.
-  const sharedHelpers = new Map<string, string>()
-  const writtenTsFiles: string[] = []
-
-  for (const schemaFile of schemaFiles) {
-    const relPath = relative(schemaDir, schemaFile)
-    const relNoExt = relPath.slice(0, -'.json'.length)
-    const schemaSubDir = join(outputDir, relNoExt)
-    // Depth of the schema's output subdirectory, used to build the relative import
-    // path back to the shared `_helpers/` at the output root (../, ../../, ...).
-    const depth = relNoExt.split(sep).filter(Boolean).length
-    const helpersImportPrefix = '../'.repeat(depth)
-
-    const schema = await loadSchema(config, schemaFile)
-    const rootTypeName = deriveRootTypeName(schema)
-    console.log(`\n${relPath} → ${relNoExt}/ (root type: ${rootTypeName})`)
-
-    const files = await buildSchema(
-      schema as JSONSchema,
-      rootTypeName,
-      undefined,
-      config.typesOnly,
-      config.logWarnings,
-      config.strict,
-      helpersMode,
-      helpersImportPrefix,
-      config.readonly,
-      config.typeSuffix,
-    )
-
-    for (const file of files) {
-      if (file.filename.startsWith('_helpers/')) {
-        sharedHelpers.set(file.filename, file.content)
-        continue
-      }
-
-      const content = config.banner ? resolveBanner(config.banner) + file.content : file.content
-      await writeGeneratedFile(schemaSubDir, file.filename, content)
-      const relativeFilename = join(relNoExt, file.filename)
-      writtenTsFiles.push(relativeFilename)
-      console.log(`Generated: ${relativeFilename}`)
-    }
-  }
-
-  for (const [filename, content] of sharedHelpers) {
-    await writeGeneratedFile(outputDir, filename, content)
-    writtenTsFiles.push(filename)
-    console.log(`Generated: ${filename}`)
-  }
-
-  if (config.build) {
-    await buildOutput(outputDir, writtenTsFiles, config.typesOnly)
-  } else {
-    console.log(`\nTotal files generated: ${writtenTsFiles.length}`)
-  }
-}
-
-const run = async (): Promise<void> => {
-  // Skip the first two args (node executable and script path)
-  const args = process.argv.slice(2)
-
-  if (isVersionRequest(args)) {
-    console.log(await readVersion())
-    return
-  }
-
-  const configPath = extractConfigPath(args)
-
-  // Start with config file values if provided, then overlay CLI flags on top
-  const fileConfig = configPath ? await loadConfig(configPath) : {}
-  const cliConfig = parseCliArgs(args)
-  const config = { ...fileConfig, ...cliConfig }
-
-  if (config.outDir && config.outFile) {
-    console.error('Error: provide only one of --out-dir or --out-file, not both.')
-    process.exit(1)
-  }
-
-  // Single-file output is the alternative to a directory of files.
-  if (config.outFile) {
-    if (!config.typesOnly) {
-      console.error('Error: --out-file currently supports only --types-only output. Add --types-only or use --out-dir.')
-      process.exit(1)
-    }
-
-    if (config.schemaDir) {
-      console.error('Error: --out-file cannot be combined with --schema-dir; use --out-dir for recursive output.')
-      process.exit(1)
-    }
-
-    if (!config.schema) {
-      console.error('Error: --schema is required. Provide a path to a JSON Schema.')
-      process.exit(1)
-    }
-
-    await runSingleFile(config, resolve(config.schema), resolve(config.outFile))
-    return
-  }
-
-  if (!config.outDir) {
-    console.error('Error: --out-dir or --out-file is required. Provide an output destination for generated files.')
-    process.exit(1)
-  }
-
-  const outputDir = resolve(config.outDir)
-
-  // schemaDir activates recursive mode and takes precedence over a single schema.
-  if (config.schemaDir) {
-    await runRecursive(config, resolve(config.schemaDir), outputDir)
-    return
-  }
-
-  if (!config.schema) {
-    console.error('Error: --schema (or --schemaDir) is required. Provide a path to a JSON Schema.')
-    process.exit(1)
-  }
-
-  await runSingle(config, resolve(config.schema), outputDir)
-}
-
-run().catch((error: unknown) => {
-  console.error(error instanceof Error ? error.message : error)
-  process.exit(1)
-})

package/src/combine-files.test.ts

@@ -1,49 +0,0 @@
-import type { GeneratedFile } from '@amritk/generate-parsers'
-import { describe, expect, it } from 'vitest'
-
-import { combineGeneratedFiles } from './combine-files'
-
-describe('combineGeneratedFiles', () => {
-  it('drops relative imports and the index barrel, inlining every definition', () => {
-    const files: GeneratedFile[] = [
-      {
-        filename: 'document.ts',
-        content: "import type { Person } from './person';\n\nexport type Document = {\n  owner?: Person;\n};",
-      },
-      {
-        filename: 'person.ts',
-        content: 'export type Person = {\n  name: string;\n};',
-      },
-      {
-        filename: 'index.ts',
-        content: "export type { Document } from './document';\nexport type { Person } from './person';\n",
-      },
-    ]
-
-    const result = combineGeneratedFiles(files)
-
-    expect(result).not.toContain('import')
-    expect(result).not.toContain('./document')
-    expect(result).toContain('export type Document =')
-    expect(result).toContain('export type Person =')
-  })
-
-  it('hoists and deduplicates external (non-relative) imports', () => {
-    const files: GeneratedFile[] = [
-      {
-        filename: 'a.ts',
-        content: "import { isObject } from '@amritk/helpers/is-object';\n\nexport const a = isObject;",
-      },
-      {
-        filename: 'b.ts',
-        content: "import { isObject } from '@amritk/helpers/is-object';\n\nexport const b = isObject;",
-      },
-    ]
-
-    const result = combineGeneratedFiles(files)
-    const importCount = result.split('\n').filter((line) => line.startsWith('import')).length
-
-    expect(importCount).toBe(1)
-    expect(result).toContain("import { isObject } from '@amritk/helpers/is-object';")
-  })
-})

package/src/combine-files.ts

@@ -1,43 +0,0 @@
-import type { GeneratedFile } from '@amritk/generate-parsers'
-
-// Require whitespace after `import` so a property literally named `import` (e.g.
-// `import?: string`) is not mistaken for an import statement.
-const IMPORT_RE = /^import\s/
-const RELATIVE_IMPORT_RE = /\bfrom\s+['"]\.\.?\//
-
-/**
- * Merges the per-schema {@link GeneratedFile}s into a single self-contained
- * TypeScript module. Each generated file imports its sibling definitions via
- * relative paths; since everything now lives in one file those imports are
- * dropped, while any external (package) imports are hoisted to the top and
- * deduplicated. The `index.ts` barrel is skipped because it only re-exports the
- * declarations that are already inlined here.
- *
- * Intended for types-only output, where files contain only type definitions and
- * type-only relative imports (no runtime helpers).
- */
-export const combineGeneratedFiles = (files: readonly GeneratedFile[]): string => {
-  const externalImports = new Set<string>()
-  const bodies: string[] = []
-
-  for (const file of files) {
-    if (file.filename === 'index.ts') continue
-
-    const bodyLines: string[] = []
-    for (const line of file.content.split('\n')) {
-      if (IMPORT_RE.test(line.trimStart())) {
-        // Relative imports point at sibling files that are now inlined — drop them.
-        if (RELATIVE_IMPORT_RE.test(line)) continue
-        externalImports.add(line.trim())
-        continue
-      }
-      bodyLines.push(line)
-    }
-
-    const body = bodyLines.join('\n').trim()
-    if (body) bodies.push(body)
-  }
-
-  const importBlock = [...externalImports].sort().join('\n')
-  return [importBlock, bodies.join('\n\n')].filter(Boolean).join('\n\n') + '\n'
-}