@amritk/mjst 0.12.3 → 0.13.1

package/README.md

@@ -21,7 +21,7 @@
 
 Options can be supplied via CLI flags or a JSON config file. **CLI flags always take precedence over config file values.**
 
-It also carries a `lint` subcommand — `mjst lint <files>` — a format-agnostic JSON/YAML style-guide linter powered by [`@amritk/lint`](../lint). See [Linting](#linting).
+It also carries a `lint` subcommand — `mjst lint <files>` — a format-agnostic JSON/YAML style-guide linter powered by [`@amritk/lint`](../lint) (see [Linting](#linting)), and a `compile-api` subcommand — `mjst compile-api <routes-module> --out <file>` — that compiles [`@amritk/api`](../api) route contracts into a production fetch-handler module (see [Compiling an API](#compiling-an-api)).
 
 ---
 
@@ -219,6 +219,33 @@ The exit code is `0` when no finding reaches `--fail-severity`, `1` when one doe
 
 ---
 
+## Compiling an API
+
+`mjst compile-api` compiles [`@amritk/api`](../api) route contracts into a fused fetch-handler module — the production counterpart to `createApi`, with inlined guards, schema-derived serializers, and a precomputed OpenAPI document. It wraps the library's `compileToModule` so you do not have to hand-write a build script. Like `lint`, it has its own flags (and its own `--help`), independent of the generation flags above.
+
+```bash
+# Compile every route contract exported by the routes module
+npx mjst compile-api src/routes.ts --out dist/handler.js
+
+# Wire in the exports-by-name options (context factory, mounts, OpenAPI info, ...)
+npx mjst compile-api src/routes.ts --out dist/handler.js --options compile-options.json
+```
+
+Every export of the routes module that looks like a route contract (`method`, `path`, `responses`) is compiled; the generated module imports those contracts back through `--routes-import` (default: the relative path from the out file to the routes module). The routes module is imported at build time, so it must be loadable by the runtime running mjst — run via `bunx` for TypeScript sources, or under Node install a loader such as `tsx` (`node --import tsx`).
+
+| Flag | Description |
+| --- | --- |
+| `<routes-module>` | Module exporting the route contracts (positional). |
+| `--out` | Output file for the generated module (required; parent directories are created). |
+| `--routes-import` | Import specifier the generated module uses for the routes module. Defaults to the relative path from the out file. |
+| `--options` | JSON file spread into the `compileToModule` options — `contextExport`, `mounts`, `info`, `servers`, `security`, `securitySchemes`, and friends. Flags take precedence. |
+| `--open-api-path` | Serve the precomputed OpenAPI JSON at this path (default `/openapi.json`). |
+| `--max-body-bytes` | Reject request bodies larger than this many bytes with a 413 (default `1048576`; `Infinity` disables the cap). |
+
+The exit code is `0` on success, `1` when compilation fails (unloadable module, no contracts found, invalid options JSON), and `2` on a usage error. Run `mjst compile-api --help` for details.
+
+---
+
 ## Configuration reference
 
 <!-- config-table-start -->

package/dist/cli.js

@@ -244,6 +244,15 @@ const run = async () => {
       process.stderr.write(result.stderr);
     process.exit(result.code);
   }
+  if (args[0] === "compile-api") {
+    const { run: compileApiRun } = await import("./compile-api/run.js");
+    const result = await compileApiRun(args.slice(1));
+    if (result.stdout)
+      process.stdout.write(result.stdout);
+    if (result.stderr)
+      process.stderr.write(result.stderr);
+    process.exit(result.code);
+  }
   if (isVersionRequest(args)) {
     console.log(await readVersion());
     return;

package/dist/compile-api/collect-route-contracts.d.ts

@@ -0,0 +1,9 @@
+import type { AnyRouteContract } from '@amritk/api';
+/**
+ * Picks the route contracts out of a loaded routes module, keyed by export
+ * name — exactly the record `compileToModule` expects, since the generated
+ * module imports each contract back by that name. Non-contract exports
+ * (context factories, error formatters, hooks) are left alone; they are wired
+ * in by name through the compile options instead.
+ */
+export declare const collectRouteContracts: (moduleExports: Record<string, unknown>) => Record<string, AnyRouteContract>;

package/dist/compile-api/collect-route-contracts.js

@@ -0,0 +1,15 @@
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isRouteContract = (value) => isRecord(value) && typeof value["method"] === "string" && typeof value["path"] === "string" && isRecord(value["responses"]);
+const collectRouteContracts = (moduleExports) => {
+  const routes = {};
+  for (const [name, value] of Object.entries(moduleExports)) {
+    if (name === "default")
+      continue;
+    if (isRouteContract(value))
+      routes[name] = value;
+  }
+  return routes;
+};
+export {
+  collectRouteContracts
+};

package/dist/compile-api/default-routes-import.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The default `routesImport` specifier: the relative path from the out file's
+ * directory to the routes module. The module's real on-disk extension is kept
+ * — same convention as the generator's default `--import-ext ts` (see
+ * resolve-import-ext.ts): literal paths load under Bun, Node's type
+ * stripping, and bundlers alike, whereas an extensionless specifier only
+ * resolves through a bundler.
+ */
+export declare const defaultRoutesImport: (outFile: string, routesModulePath: string) => string;

package/dist/compile-api/default-routes-import.js

@@ -0,0 +1,8 @@
+import { dirname, relative, sep } from "node:path";
+const defaultRoutesImport = (outFile, routesModulePath) => {
+  const specifier = relative(dirname(outFile), routesModulePath).split(sep).join("/");
+  return specifier.startsWith(".") ? specifier : `./${specifier}`;
+};
+export {
+  defaultRoutesImport
+};

package/dist/compile-api/help-text.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Usage text for `mjst compile-api --help`. Hand-written like the top-level
+ * HELP_TEXT: the flag list is small and stable, and the test cross-checks that
+ * every flag is listed.
+ */
+export declare const COMPILE_API_HELP_TEXT = "mjst compile-api \u2014 compile @amritk/api route contracts into a fused fetch-handler module\n\nUsage:\n  mjst compile-api <routes-module> --out <file> [options]\n\nThe routes module is imported at build time and every export that looks like a\nroute contract (method, path, responses) becomes a compiled route. The module\nmust be loadable by the runtime that runs mjst \u2014 run via bunx for TypeScript\nsources, or under Node install a loader such as tsx (node --import tsx).\n\nOptions:\n  --out <file>            Output file for the generated module (required; parent dirs are created)\n  --routes-import <spec>  Import specifier the generated module uses to import the routes\n                          (default: the relative path from the out file to the routes module)\n  --options <json-file>   JSON file spread into the compileToModule options for everything\n                          not expressible as a flag: contextExport, mounts, info, servers,\n                          security, securitySchemes, errorsExport, onErrorExport, ...\n                          Flags take precedence over the file.\n  --open-api-path <path>  Serve the precomputed OpenAPI JSON at this path (default: /openapi.json)\n  --max-body-bytes <n>    Reject larger request bodies with a 413 (default: 1048576; Infinity disables)\n  --help, -h              Print this help\n\nDocs: https://github.com/amritk/mjst/tree/main/packages/cli#readme\n";

package/dist/compile-api/help-text.js

@@ -0,0 +1,27 @@
+const COMPILE_API_HELP_TEXT = `mjst compile-api \u2014 compile @amritk/api route contracts into a fused fetch-handler module
+
+Usage:
+  mjst compile-api <routes-module> --out <file> [options]
+
+The routes module is imported at build time and every export that looks like a
+route contract (method, path, responses) becomes a compiled route. The module
+must be loadable by the runtime that runs mjst \u2014 run via bunx for TypeScript
+sources, or under Node install a loader such as tsx (node --import tsx).
+
+Options:
+  --out <file>            Output file for the generated module (required; parent dirs are created)
+  --routes-import <spec>  Import specifier the generated module uses to import the routes
+                          (default: the relative path from the out file to the routes module)
+  --options <json-file>   JSON file spread into the compileToModule options for everything
+                          not expressible as a flag: contextExport, mounts, info, servers,
+                          security, securitySchemes, errorsExport, onErrorExport, ...
+                          Flags take precedence over the file.
+  --open-api-path <path>  Serve the precomputed OpenAPI JSON at this path (default: /openapi.json)
+  --max-body-bytes <n>    Reject larger request bodies with a 413 (default: 1048576; Infinity disables)
+  --help, -h              Print this help
+
+Docs: https://github.com/amritk/mjst/tree/main/packages/cli#readme
+`;
+export {
+  COMPILE_API_HELP_TEXT
+};

package/dist/compile-api/load-routes-module.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Imports the user's routes module and returns the full export record —
+ * compile-api needs every export (each one is a route-contract candidate), so
+ * it cannot reuse loadSchemaModule, which selects a single export. The import
+ * mechanics and the friendly `.ts` hint mirror load-schema-module.ts: a `.ts`
+ * module only loads under a TypeScript-capable runtime.
+ */
+export declare const loadRoutesModule: (modulePath: string) => Promise<Record<string, unknown>>;

package/dist/compile-api/load-routes-module.js

@@ -0,0 +1,13 @@
+import { pathToFileURL } from "node:url";
+const loadRoutesModule = async (modulePath) => {
+  try {
+    return await import(pathToFileURL(modulePath).href);
+  } catch (error) {
+    const hint = modulePath.endsWith(".ts") ? " Importing a .ts routes module 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 routes module at ${modulePath}.${hint}
+${String(error)}`);
+  }
+};
+export {
+  loadRoutesModule
+};

package/dist/compile-api/parse-compile-api-args.d.ts

@@ -0,0 +1,25 @@
+/** The flags and positional the `compile-api` subcommand understands. */
+export type CompileApiArgs = {
+    /** Path to the module exporting the route contracts (the sole positional). */
+    routesModule?: string;
+    /** Output file for the generated module (`--out`). */
+    out?: string;
+    /** Import specifier override for the routes module (`--routes-import`). */
+    routesImport?: string;
+    /** Path to a JSON file spread into the compile options (`--options`). */
+    optionsFile?: string;
+    /** OpenAPI document path override (`--open-api-path`). */
+    openApiPath?: string;
+    /** Request body size cap override (`--max-body-bytes`). */
+    maxBodyBytes?: number;
+    /** True when `--help`/`-h` was passed. */
+    help?: boolean;
+};
+/**
+ * Parses the `compile-api` argv into a typed args object. Mirrors the main
+ * CLI parser's conventions: kebab-case and camelCase flag spellings, both
+ * `--flag value` and `--flag=value`, and a loud error on unknown flags so a
+ * typo cannot silently drop an option. Throws on usage errors; the caller
+ * turns that into the exit-code-2 path.
+ */
+export declare const parseCompileApiArgs: (argv: readonly string[]) => CompileApiArgs;

package/dist/compile-api/parse-compile-api-args.js

@@ -0,0 +1,73 @@
+const VALUE_KEYS = /* @__PURE__ */ new Set(["out", "routesImport", "options", "openApiPath", "maxBodyBytes"]);
+const toCamelCase = (key) => key.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+const parseMaxBodyBytes = (value) => {
+  if (value.toLowerCase() === "infinity")
+    return Number.POSITIVE_INFINITY;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    throw new Error(`Invalid --max-body-bytes value "${value}". Expected a non-negative number or Infinity.`);
+  }
+  return parsed;
+};
+const assignValue = (args, key, value) => {
+  switch (key) {
+    case "out":
+      args.out = value;
+      return;
+    case "routesImport":
+      args.routesImport = value;
+      return;
+    case "options":
+      args.optionsFile = value;
+      return;
+    case "openApiPath":
+      args.openApiPath = value;
+      return;
+    case "maxBodyBytes":
+      args.maxBodyBytes = parseMaxBodyBytes(value);
+      return;
+    default:
+      throw new Error(`Unknown flag "--${key}".`);
+  }
+};
+const parseCompileApiArgs = (argv) => {
+  const args = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === void 0)
+      continue;
+    if (arg === "--help" || arg === "-h") {
+      args.help = true;
+      continue;
+    }
+    if (!arg.startsWith("--")) {
+      if (args.routesModule !== void 0) {
+        throw new Error(`Unexpected argument "${arg}". compile-api takes a single routes module path.`);
+      }
+      args.routesModule = arg;
+      continue;
+    }
+    const equalsIndex = arg.indexOf("=");
+    if (equalsIndex !== -1) {
+      const key2 = toCamelCase(arg.slice(2, equalsIndex));
+      if (!VALUE_KEYS.has(key2))
+        throw new Error(`Unknown flag "--${arg.slice(2, equalsIndex)}".`);
+      assignValue(args, key2, arg.slice(equalsIndex + 1));
+      continue;
+    }
+    const flagName = arg.slice(2);
+    const key = toCamelCase(flagName);
+    if (!VALUE_KEYS.has(key))
+      throw new Error(`Unknown flag "--${flagName}".`);
+    const value = argv[i + 1];
+    if (value === void 0 || value.startsWith("--")) {
+      throw new Error(`Flag "--${flagName}" expects a value.`);
+    }
+    assignValue(args, key, value);
+    i++;
+  }
+  return args;
+};
+export {
+  parseCompileApiArgs
+};

package/dist/compile-api/read-compile-options.d.ts

@@ -0,0 +1,9 @@
+import type { CompileModuleOptions } from '@amritk/api';
+/**
+ * Reads the `--options` JSON file: everything `compileToModule` accepts that
+ * has no dedicated flag (contextExport, mounts, info, servers, security,
+ * securitySchemes, hook exports, ...) rides in here and is spread into the
+ * compile options. Throws with the file path on unreadable or invalid input
+ * so the CLI can report exactly which file to fix.
+ */
+export declare const readCompileOptions: (optionsPath: string) => Promise<Partial<CompileModuleOptions>>;

package/dist/compile-api/read-compile-options.js

@@ -0,0 +1,24 @@
+import { readFile } from "node:fs/promises";
+const readCompileOptions = async (optionsPath) => {
+  let raw;
+  try {
+    raw = await readFile(optionsPath, "utf-8");
+  } catch (error) {
+    throw new Error(`Failed to read --options file at ${optionsPath}.
+${String(error)}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`Invalid JSON in --options file at ${optionsPath}.
+${String(error)}`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`Invalid --options file at ${optionsPath}: expected a JSON object of compileToModule options.`);
+  }
+  return parsed;
+};
+export {
+  readCompileOptions
+};

package/dist/compile-api/run.d.ts

@@ -0,0 +1,9 @@
+import type { RunResult } from '../lint/run.js';
+/**
+ * Runs `mjst compile-api` over `argv`: loads the routes module, collects its
+ * route-contract exports, compiles them with `compileToModule`, and writes
+ * the emitted module to `--out`. Returns the exit code and the text it would
+ * print (rather than writing to the process streams) so tests can drive it
+ * in-process — the same shape as the lint subcommand's `run`.
+ */
+export declare const run: (argv: string[]) => Promise<RunResult>;

package/dist/compile-api/run.js

@@ -0,0 +1,75 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, relative, resolve } from "node:path";
+import { compileToModule } from "@amritk/api";
+import { collectRouteContracts } from "./collect-route-contracts.js";
+import { defaultRoutesImport } from "./default-routes-import.js";
+import { COMPILE_API_HELP_TEXT } from "./help-text.js";
+import { loadRoutesModule } from "./load-routes-module.js";
+import { parseCompileApiArgs } from "./parse-compile-api-args.js";
+import { readCompileOptions } from "./read-compile-options.js";
+const usageError = (message) => ({ code: 2, stdout: "", stderr: `Error: ${message}
+` });
+const failure = (message) => ({ code: 1, stdout: "", stderr: `Error: ${message}
+` });
+const run = async (argv) => {
+  let args;
+  try {
+    args = parseCompileApiArgs(argv);
+  } catch (error) {
+    return usageError(error instanceof Error ? error.message : String(error));
+  }
+  if (args.help || argv.length === 0) {
+    return { code: 0, stdout: COMPILE_API_HELP_TEXT, stderr: "" };
+  }
+  if (args.routesModule === void 0) {
+    return usageError("A routes module path is required. Usage: mjst compile-api <routes-module> --out <file>");
+  }
+  if (args.out === void 0) {
+    return usageError("--out is required. Provide an output file for the generated module.");
+  }
+  const modulePath = resolve(args.routesModule);
+  let moduleExports;
+  try {
+    moduleExports = await loadRoutesModule(modulePath);
+  } catch (error) {
+    return failure(error instanceof Error ? error.message : String(error));
+  }
+  const routes = collectRouteContracts(moduleExports);
+  const routeNames = Object.keys(routes);
+  if (routeNames.length === 0) {
+    return failure(`No route contracts found in ${modulePath}. A route contract is a named export declaring method, path, and responses.`);
+  }
+  let fileOptions = {};
+  if (args.optionsFile !== void 0) {
+    try {
+      fileOptions = await readCompileOptions(resolve(args.optionsFile));
+    } catch (error) {
+      return failure(error instanceof Error ? error.message : String(error));
+    }
+  }
+  const outFile = resolve(args.out);
+  const routesImport = args.routesImport ?? defaultRoutesImport(outFile, modulePath);
+  let source;
+  try {
+    source = compileToModule({
+      ...fileOptions,
+      ...args.openApiPath !== void 0 ? { openApiPath: args.openApiPath } : {},
+      ...args.maxBodyBytes !== void 0 ? { maxBodyBytes: args.maxBodyBytes } : {},
+      routesImport,
+      routes
+    });
+  } catch (error) {
+    return failure(error instanceof Error ? error.message : String(error));
+  }
+  await mkdir(dirname(outFile), { recursive: true });
+  await writeFile(outFile, source, "utf-8");
+  const stdout = [
+    `Compiled ${routeNames.length} route(s): ${routeNames.join(", ")}`,
+    `Generated: ${relative(process.cwd(), outFile)}`,
+    ""
+  ].join("\n");
+  return { code: 0, stdout, stderr: "" };
+};
+export {
+  run
+};

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\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\n  --export <name>       Which export of the schema module to use when --input is not json\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  --build               Compile the generated files to .js/.d.ts (implies --import-ext js)\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\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\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 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\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\n  --export <name>       Which export of the schema module to use when --input is not json\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  --build               Compile the generated files to .js/.d.ts (implies --import-ext js)\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\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\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

@@ -5,6 +5,10 @@ Usage:
   mjst --schema-dir <dir> --out-dir <dir> [options]
   mjst --schema <path> --out-file <file> --types-only [options]
 
+Subcommands (each with its own flags and --help):
+  mjst lint <files>                       Lint JSON/YAML documents against a ruleset
+  mjst compile-api <module> --out <file>  Compile @amritk/api route contracts into a fetch-handler module
+
 Input:
   --schema <path>       Schema to process: a JSON Schema file, or a module when --input is set
   --schema-dir <dir>    Directory of JSON Schemas, processed recursively (instead of --schema)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/mjst",
-  "version": "0.12.3",
+  "version": "0.13.1",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "type": "module",
   "license": "MIT",
@@ -42,6 +42,7 @@
   },
   "dependencies": {
     "@amritk/adapters": "0.3.3",
+    "@amritk/api": "0.6.0",
     "@amritk/generate-examples": "0.5.3",
     "@amritk/generate-parsers": "0.17.0",
     "@amritk/generate-validators": "0.11.9",