argsbarg 6.0.1 → 6.0.2

package/src/cli-tool/program.ts

@@ -5,6 +5,7 @@ Argsbarg developer tools — bootstrap consumer CLIs via `create`.
 import pkg from "../../package.json" with { type: "json" };
 import { CliOptionKind, type CliProgram } from "../index.ts";
 import { runCreate } from "./run-create.ts";
+import { runSchemagenCli } from "./run-schemagen.ts";
 
 export const program = {
   key: "argsbarg",
@@ -92,5 +93,39 @@ export const program = {
         process.exit(code);
       },
     },
+    {
+      key: "schemagen",
+      description: "Generate JSON Schema artifacts from src/**/schema.ts into colocated __generated__/ directories.",
+      options: [
+        {
+          name: "root",
+          description: "Project root (default: current working directory).",
+          kind: CliOptionKind.String,
+        },
+        {
+          name: "src-dir",
+          description: "Source directory relative to --root (default: src).",
+          kind: CliOptionKind.String,
+        },
+        {
+          name: "tsconfig",
+          description: "Path to tsconfig relative to --root (default: tsconfig.json).",
+          kind: CliOptionKind.String,
+        },
+      ],
+      handler: (ctx) => {
+        try {
+          runSchemagenCli({
+            root: ctx.stringOpt("root"),
+            srcDir: ctx.stringOpt("src-dir"),
+            tsconfig: ctx.stringOpt("tsconfig"),
+          });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          process.stderr.write(`${message}\n`);
+          process.exit(1);
+        }
+      },
+    },
   ],
 } satisfies CliProgram;

package/src/cli-tool/run-schemagen.ts

@@ -0,0 +1,23 @@
+/** Run argsbarg schemagen in the current working directory (or `--root`). */
+
+import { resolve } from "node:path";
+import { runSchemagen } from "./schemagen/run.ts";
+
+export interface RunSchemagenCliOptions {
+  root?: string;
+  srcDir?: string;
+  tsconfig?: string;
+}
+
+/** Exit 0 on success; throws on failure. */
+export function runSchemagenCli(options: RunSchemagenCliOptions = {}): void {
+  const projectRoot = resolve(options.root ?? process.cwd());
+  const counts = runSchemagen({
+    projectRoot,
+    srcDir: options.srcDir,
+    tsconfig: options.tsconfig,
+  });
+  console.log(
+    `config roots: ${counts.configRoots}, input roots: ${counts.inputRoots}, output roots: ${counts.outputRoots}`,
+  );
+}

package/src/cli-tool/schemagen/cleanup.ts

@@ -0,0 +1,60 @@
+/*
+Remove stale __generated__/ directories and files after schemagen runs.
+*/
+
+import { existsSync, readdirSync, rmSync, statSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import type { SchemaRoot } from "./discover-schema-roots.ts";
+import { GENERATED_DIR, SCHEMA_FILE, schemaJsonBasename } from "./names.ts";
+
+function listGeneratedDirs(srcDir: string, projectRoot: string, out: string[]): void {
+  for (const ent of readdirSync(srcDir)) {
+    const full = join(srcDir, ent);
+    const st = statSync(full);
+    if (!st.isDirectory()) {
+      continue;
+    }
+    if (ent === GENERATED_DIR) {
+      out.push(relative(projectRoot, full));
+      continue;
+    }
+    listGeneratedDirs(full, projectRoot, out);
+  }
+}
+
+/** Drop orphan `__generated__/` trees and JSON files for removed schema kinds. */
+export function cleanStaleGenerated(
+  projectRoot: string,
+  srcDir: string,
+  activeBySchemaFile: Map<string, SchemaRoot[]>,
+): void {
+  const srcPath = join(projectRoot, srcDir);
+  if (!existsSync(srcPath)) {
+    return;
+  }
+
+  const generatedDirs: string[] = [];
+  listGeneratedDirs(srcPath, projectRoot, generatedDirs);
+
+  for (const relGeneratedDir of generatedDirs) {
+    const generatedDir = join(projectRoot, relGeneratedDir);
+    const relSchemaPath = relative(projectRoot, join(dirname(generatedDir), SCHEMA_FILE));
+    const roots = existsSync(join(projectRoot, relSchemaPath)) ? (activeBySchemaFile.get(relSchemaPath) ?? []) : [];
+
+    if (roots.length === 0) {
+      rmSync(generatedDir, { recursive: true, force: true });
+      console.log(`removed ${relGeneratedDir}`);
+      continue;
+    }
+
+    const keep = new Set(["index.ts", ...roots.map((root) => schemaJsonBasename(root.kind))]);
+    for (const ent of readdirSync(generatedDir)) {
+      if (keep.has(ent)) {
+        continue;
+      }
+      const stalePath = join(generatedDir, ent);
+      rmSync(stalePath, { recursive: true, force: true });
+      console.log(`removed ${relative(projectRoot, stalePath)}`);
+    }
+  }
+}

package/{examples/full-example/scripts → src/cli-tool}/schemagen/discover-schema-roots.ts

@@ -1,18 +1,10 @@
 /*
-Discovers schema roots in schema-types.ts files via configType / inputType / outputType exports.
-Copy per consumer repo — see docs/output-schema.md and docs/config-schema.md.
+Discovers schema roots in schema.ts files via configType / inputType / outputType exports.
 */
 
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import { join, relative } from "node:path";
-import {
-  configSchemaExportName,
-  inputSchemaExportName,
-  outfileForConfigType,
-  outfileForInputType,
-  outfileForOutputType,
-  outputSchemaExportName,
-} from "./naming.ts";
+import { SCHEMA_FILE } from "./names.ts";
 
 export type SchemaRootKind = "config" | "input" | "output";
 
@@ -21,14 +13,10 @@ export type SchemaRole = "configType" | "inputType" | "outputType";
 export interface SchemaRoot {
   kind: SchemaRootKind;
   typeName: string;
-  /** Path relative to project root (e.g. src/config/schema-types.ts). */
+  /** Path relative to project root (e.g. src/config/schema.ts). */
   path: string;
-  outfile: string;
-  exportName: string;
 }
 
-const SCHEMA_TYPES_FILE = "schema-types.ts";
-
 const ROLE_EXPORT_RE = /export\s+type\s+(configType|inputType|outputType)\s*=\s*(\w+)/g;
 
 const ROLE_TO_KIND: Record<SchemaRole, SchemaRootKind> = {
@@ -37,15 +25,15 @@ const ROLE_TO_KIND: Record<SchemaRole, SchemaRootKind> = {
   outputType: "output",
 };
 
-function listSchemaTypesFiles(srcDir: string, baseDir: string, out: string[]): void {
+function listSchemaFiles(srcDir: string, baseDir: string, out: string[]): void {
   for (const ent of readdirSync(srcDir)) {
     const full = join(srcDir, ent);
     const st = statSync(full);
     if (st.isDirectory()) {
-      listSchemaTypesFiles(full, baseDir, out);
+      listSchemaFiles(full, baseDir, out);
       continue;
     }
-    if (ent === SCHEMA_TYPES_FILE) {
+    if (ent === SCHEMA_FILE) {
       out.push(relative(baseDir, full));
     }
   }
@@ -62,35 +50,6 @@ function isTypeDefinedInFile(text: string, typeName: string): boolean {
   return false;
 }
 
-function rootForRole(role: SchemaRole, typeName: string, path: string): SchemaRoot {
-  const kind = ROLE_TO_KIND[role];
-  if (kind === "config") {
-    return {
-      kind,
-      typeName,
-      path,
-      outfile: outfileForConfigType(typeName),
-      exportName: configSchemaExportName(typeName),
-    };
-  }
-  if (kind === "input") {
-    return {
-      kind,
-      typeName,
-      path,
-      outfile: outfileForInputType(typeName),
-      exportName: inputSchemaExportName(typeName),
-    };
-  }
-  return {
-    kind,
-    typeName,
-    path,
-    outfile: outfileForOutputType(typeName),
-    exportName: outputSchemaExportName(typeName),
-  };
-}
-
 function discoverFromFile(path: string, text: string): SchemaRoot[] {
   const rolesSeen = new Set<SchemaRole>();
   const roots: SchemaRoot[] = [];
@@ -108,17 +67,17 @@ function discoverFromFile(path: string, text: string): SchemaRoot[] {
     if (!isTypeDefinedInFile(text, typeName)) {
       continue;
     }
-    roots.push(rootForRole(role, typeName, path));
+    roots.push({ kind: ROLE_TO_KIND[role], typeName, path });
   }
 
   return roots;
 }
 
-/** Find all schema roots under `src/` in files named schema-types.ts. */
-export function discoverSchemaRoots(projectRoot: string): SchemaRoot[] {
-  const srcDir = join(projectRoot, "src");
+/** Find all schema roots under `srcDir` in files named `schema.ts`. */
+export function discoverSchemaRoots(projectRoot: string, srcDir = "src"): SchemaRoot[] {
+  const srcPath = join(projectRoot, srcDir);
   const files: string[] = [];
-  listSchemaTypesFiles(srcDir, projectRoot, files);
+  listSchemaFiles(srcPath, projectRoot, files);
 
   const roots: SchemaRoot[] = [];
   const typeOwners = new Map<string, string>();
@@ -128,9 +87,7 @@ export function discoverSchemaRoots(projectRoot: string): SchemaRoot[] {
     for (const root of discoverFromFile(relPath, text)) {
       const prev = typeOwners.get(root.typeName);
       if (prev) {
-        throw new Error(
-          `${relPath}: duplicate schema root type ${root.typeName} (already declared in ${prev})`,
-        );
+        throw new Error(`${relPath}: duplicate schema root type ${root.typeName} (already declared in ${prev})`);
       }
       typeOwners.set(root.typeName, relPath);
       roots.push(root);
@@ -139,9 +96,7 @@ export function discoverSchemaRoots(projectRoot: string): SchemaRoot[] {
 
   const configRoots = roots.filter((r) => r.kind === "config");
   if (configRoots.length > 1) {
-    throw new Error(
-      `multiple config schema roots: ${configRoots.map((r) => `${r.typeName} (${r.path})`).join(", ")}`,
-    );
+    throw new Error(`multiple config schema roots: ${configRoots.map((r) => `${r.typeName} (${r.path})`).join(", ")}`);
   }
 
   return roots;

package/src/cli-tool/schemagen/index.ts

@@ -0,0 +1,3 @@
+export { discoverSchemaRoots, type SchemaRoot, type SchemaRootKind } from "./discover-schema-roots.ts";
+export { GENERATED_DIR, SCHEMA_FILE, schemaExportName, schemaJsonBasename } from "./names.ts";
+export { type RunSchemagenOptions, type RunSchemagenResult, runSchemagen } from "./run.ts";

package/src/cli-tool/schemagen/names.ts

@@ -0,0 +1,22 @@
+import type { SchemaRootKind } from "./discover-schema-roots.ts";
+
+/** Directory name for generated schema artifacts (next to `schema.ts`). */
+export const GENERATED_DIR = "__generated__";
+
+/** TypeScript schema root filename under `src/`. */
+export const SCHEMA_FILE = "schema.ts";
+
+/** JSON basename for a schema root kind (`outputSchema.json`, etc.). */
+export function schemaJsonBasename(kind: SchemaRootKind): string {
+  return `${kind}Schema.json`;
+}
+
+/** Export const name wired on leaves or `program.appConfig`. */
+export function schemaExportName(kind: SchemaRootKind): string {
+  return `${kind}Schema`;
+}
+
+/** Safe import binding for a schema JSON basename. */
+export function schemaJsonImportVar(kind: SchemaRootKind): string {
+  return `${kind}SchemaJson`;
+}

package/src/cli-tool/schemagen/run.ts

@@ -0,0 +1,108 @@
+/*
+Generate JSON Schema artifacts under __generated__/ and write index.ts re-exports.
+*/
+
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { createGenerator } from "ts-json-schema-generator";
+import { cleanStaleGenerated } from "./cleanup.ts";
+import { discoverSchemaRoots, type SchemaRoot, type SchemaRootKind } from "./discover-schema-roots.ts";
+import { GENERATED_DIR, schemaExportName, schemaJsonBasename, schemaJsonImportVar } from "./names.ts";
+
+const KIND_ORDER: SchemaRootKind[] = ["config", "input", "output"];
+
+export interface RunSchemagenOptions {
+  /** Project root (default: `process.cwd()`). */
+  projectRoot?: string;
+  /** Source tree directory relative to project root (default: `src`). */
+  srcDir?: string;
+  /** Path to tsconfig relative to project root (default: `tsconfig.json`). */
+  tsconfig?: string;
+}
+
+export interface RunSchemagenResult {
+  configRoots: number;
+  inputRoots: number;
+  outputRoots: number;
+}
+
+function resolveTsconfig(projectRoot: string, tsconfig: string): string {
+  const path = join(projectRoot, tsconfig);
+  try {
+    return path;
+  } catch {
+    throw new Error(`tsconfig not found: ${path}`);
+  }
+}
+
+function generateJson(projectRoot: string, tsconfigPath: string, root: SchemaRoot): Record<string, unknown> {
+  const generator = createGenerator({
+    path: join(projectRoot, root.path),
+    type: root.typeName,
+    tsconfig: tsconfigPath,
+    topRef: false,
+    skipTypeCheck: false,
+    jsDoc: "extended",
+    additionalProperties: root.kind === "config" ? false : undefined,
+  });
+  const schema = generator.createSchema(root.typeName) as Record<string, unknown>;
+  if (root.kind === "config") {
+    schema.additionalProperties = false;
+  }
+  return schema;
+}
+
+function writeGeneratedIndex(generatedDir: string, roots: SchemaRoot[]): void {
+  const sorted = [...roots].sort((left, right) => KIND_ORDER.indexOf(left.kind) - KIND_ORDER.indexOf(right.kind));
+  const lines = ["// Auto-generated by argsbarg schemagen — do not edit by hand.", ""];
+  for (const root of sorted) {
+    lines.push(`import ${schemaJsonImportVar(root.kind)} from "./${schemaJsonBasename(root.kind)}";`);
+  }
+  if (sorted.length > 0) {
+    lines.push("");
+  }
+  for (const root of sorted) {
+    lines.push(
+      `export const ${schemaExportName(root.kind)} = ${schemaJsonImportVar(root.kind)} as Record<string, unknown>;`,
+    );
+    lines.push("");
+  }
+  writeFileSync(join(generatedDir, "index.ts"), `${lines.join("\n")}`);
+}
+
+/** Generate colocated `__generated__` JSON schemas and `index.ts` barrels. */
+export function runSchemagen(options: RunSchemagenOptions = {}): RunSchemagenResult {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const srcDir = options.srcDir ?? "src";
+  const tsconfigPath = resolveTsconfig(projectRoot, options.tsconfig ?? "tsconfig.json");
+
+  const roots = discoverSchemaRoots(projectRoot, srcDir);
+  const bySchemaFile = new Map<string, SchemaRoot[]>();
+
+  for (const root of roots) {
+    const schema = generateJson(projectRoot, tsconfigPath, root);
+    const generatedDir = join(dirname(join(projectRoot, root.path)), GENERATED_DIR);
+    mkdirSync(generatedDir, { recursive: true });
+    const jsonPath = join(generatedDir, schemaJsonBasename(root.kind));
+    writeFileSync(jsonPath, `${JSON.stringify(schema, null, 2)}\n`);
+    console.log(`wrote ${relative(projectRoot, jsonPath)} (${root.typeName})`);
+
+    const list = bySchemaFile.get(root.path) ?? [];
+    list.push(root);
+    bySchemaFile.set(root.path, list);
+  }
+
+  for (const [relPath, fileRoots] of bySchemaFile) {
+    const generatedDir = join(dirname(join(projectRoot, relPath)), GENERATED_DIR);
+    writeGeneratedIndex(generatedDir, fileRoots);
+    console.log(`wrote ${relative(projectRoot, join(generatedDir, "index.ts"))}`);
+  }
+
+  cleanStaleGenerated(projectRoot, srcDir, bySchemaFile);
+
+  return {
+    configRoots: roots.filter((r) => r.kind === "config").length,
+    inputRoots: roots.filter((r) => r.kind === "input").length,
+    outputRoots: roots.filter((r) => r.kind === "output").length,
+  };
+}

package/src/cli-tool/schemagen/schemagen.test.ts

@@ -0,0 +1,125 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { discoverSchemaRoots } from "./discover-schema-roots.ts";
+import { schemaExportName, schemaJsonBasename } from "./names.ts";
+import { runSchemagen } from "./run.ts";
+
+const exampleRoot = join(import.meta.dir, "../../../examples/full-example");
+
+const tempRoots: string[] = [];
+
+afterEach(() => {
+  for (const root of tempRoots.splice(0)) {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+function makeTempProject(): string {
+  const root = mkdtempSync(join(tmpdir(), "argsbarg-schemagen-"));
+  tempRoots.push(root);
+  writeFileSync(
+    join(root, "tsconfig.json"),
+    JSON.stringify(
+      {
+        compilerOptions: {
+          strict: true,
+          target: "ESNext",
+          module: "ESNext",
+          moduleResolution: "bundler",
+          resolveJsonModule: true,
+        },
+        include: ["src/**/*"],
+      },
+      null,
+      2,
+    ),
+  );
+  return root;
+}
+
+function writeSchema(root: string, relDir: string, body: string): void {
+  const dir = join(root, "src", relDir);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "schema.ts"), body);
+}
+
+describe("schemagen", () => {
+  test("discovers AppConfig and StatusJsonOutput in full-example", () => {
+    const roots = discoverSchemaRoots(exampleRoot);
+    expect(roots.map((r) => `${r.kind}:${r.typeName}`).sort()).toEqual(["config:AppConfig", "output:StatusJsonOutput"]);
+  });
+
+  test("maps schema kinds to __generated__ filenames and export names", () => {
+    expect(schemaJsonBasename("output")).toBe("outputSchema.json");
+    expect(schemaJsonBasename("config")).toBe("configSchema.json");
+    expect(schemaExportName("output")).toBe("outputSchema");
+  });
+
+  test("runSchemagen writes __generated__ artifacts in full-example", () => {
+    const counts = runSchemagen({ projectRoot: exampleRoot });
+    expect(counts).toEqual({ configRoots: 1, inputRoots: 0, outputRoots: 1 });
+  });
+
+  test("removes stale JSON files when a schema kind is dropped", () => {
+    const root = makeTempProject();
+    writeSchema(
+      root,
+      "commands/demo",
+      `/** Tool input. */
+export interface DemoInput { id: string; }
+/** Tool output. */
+export interface DemoOutput { ok: boolean; }
+export type inputType = DemoInput;
+export type outputType = DemoOutput;
+`,
+    );
+
+    runSchemagen({ projectRoot: root });
+    const generatedDir = join(root, "src/commands/demo/__generated__");
+    expect(existsSync(join(generatedDir, "inputSchema.json"))).toBe(true);
+    expect(existsSync(join(generatedDir, "outputSchema.json"))).toBe(true);
+
+    writeSchema(
+      root,
+      "commands/demo",
+      `/** Tool output. */
+export interface DemoOutput { ok: boolean; }
+export type outputType = DemoOutput;
+`,
+    );
+
+    runSchemagen({ projectRoot: root });
+    expect(existsSync(join(generatedDir, "inputSchema.json"))).toBe(false);
+    expect(existsSync(join(generatedDir, "outputSchema.json"))).toBe(true);
+    expect(existsSync(join(generatedDir, "index.ts"))).toBe(true);
+  });
+
+  test("removes orphan __generated__ when schema.ts is gone", () => {
+    const root = makeTempProject();
+    const generatedDir = join(root, "src/orphan/__generated__");
+    mkdirSync(generatedDir, { recursive: true });
+    writeFileSync(join(generatedDir, "outputSchema.json"), "{}\n");
+    writeFileSync(join(generatedDir, "index.ts"), "export const outputSchema = {};\n");
+
+    runSchemagen({ projectRoot: root });
+    expect(existsSync(generatedDir)).toBe(false);
+  });
+
+  test("removes __generated__ when schema.ts has no discoverable roots", () => {
+    const root = makeTempProject();
+    writeSchema(
+      root,
+      "commands/empty",
+      `export type outputType = never;
+`,
+    );
+    const generatedDir = join(root, "src/commands/empty/__generated__");
+    mkdirSync(generatedDir, { recursive: true });
+    writeFileSync(join(generatedDir, "outputSchema.json"), "{}\n");
+
+    runSchemagen({ projectRoot: root });
+    expect(existsSync(generatedDir)).toBe(false);
+  });
+});

package/examples/full-example/schemas/configSchemas.ts

@@ -1,6 +0,0 @@
-// Auto-generated by scripts/schemagen.ts — do not edit by hand.
-
-import app_config from "./generated/app-config.json";
-
-/** JSON Schema for program.appConfig.jsonSchema from `AppConfig`. */
-export const APP_CONFIG_JSON_SCHEMA = app_config as Record<string, unknown>;

package/examples/full-example/schemas/outputSchemas.ts

@@ -1,6 +0,0 @@
-// Auto-generated by scripts/schemagen.ts — do not edit by hand.
-
-import status from "./generated/status.json";
-
-/** JSON Schema for leaf outputSchema from `StatusJsonOutput`. */
-export const STATUS_JSON_OUTPUT_SCHEMA = status as Record<string, unknown>;

package/examples/full-example/scripts/schemagen/discover-schema-roots.test.ts

@@ -1,25 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { join } from "node:path";
-import { discoverSchemaRoots } from "./discover-schema-roots.ts";
-
-const projectRoot = join(import.meta.dir, "../..");
-
-describe("discover-schema-roots", () => {
-  test("finds AppConfig and StatusJsonOutput in schema-types.ts files", () => {
-    const roots = discoverSchemaRoots(projectRoot);
-    const config = roots.find((r) => r.kind === "config");
-    const output = roots.find((r) => r.kind === "output");
-    expect(config).toMatchObject({
-      typeName: "AppConfig",
-      path: "src/config/schema-types.ts",
-      outfile: "app-config.json",
-      exportName: "APP_CONFIG_JSON_SCHEMA",
-    });
-    expect(output).toMatchObject({
-      typeName: "StatusJsonOutput",
-      path: "src/commands/status/schema-types.ts",
-      outfile: "status.json",
-      exportName: "STATUS_JSON_OUTPUT_SCHEMA",
-    });
-  });
-});

package/examples/full-example/scripts/schemagen/naming.ts

@@ -1,99 +0,0 @@
-/*
-Maps discovered schema root type names to generated filenames and bridge export constants.
-Matches conventions in docs/output-schema.md and docs/config-schema.md.
-*/
-
-/** kebab-case from PascalCase segments. */
-export function camelToKebab(name: string): string {
-  return name
-    .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
-    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2")
-    .toLowerCase();
-}
-
-/** SCREAMING_SNAKE from PascalCase. */
-export function camelToScreamingSnake(name: string): string {
-  return camelToKebab(name).replace(/-/g, "_").toUpperCase();
-}
-
-/** Generated JSON filename for a tool-input schema root. */
-export function outfileForInputType(typeName: string): string {
-  if (typeName.endsWith("ToolInput")) {
-    return `${camelToKebab(typeName.slice(0, -"ToolInput".length))}-tool-input.json`;
-  }
-  return `${camelToKebab(typeName)}-tool-input.json`;
-}
-
-/** Bridge export constant for a tool-input schema root. */
-export function inputSchemaExportName(typeName: string): string {
-  if (typeName.endsWith("ToolInput")) {
-    const base = typeName.slice(0, -"ToolInput".length);
-    return `${camelToScreamingSnake(base)}_TOOL_INPUT_SCHEMA`;
-  }
-  return `${camelToScreamingSnake(typeName)}_TOOL_INPUT_SCHEMA`;
-}
-
-/** Generated JSON filename for an output-schema root type. */
-export function outfileForOutputType(typeName: string): string {
-  if (typeName.endsWith("JsonOutput")) {
-    return `${camelToKebab(typeName.slice(0, -"JsonOutput".length))}.json`;
-  }
-  if (typeName.endsWith("OpResult")) {
-    return `${camelToKebab(typeName.slice(0, -"OpResult".length))}-op-result.json`;
-  }
-  if (typeName.endsWith("Output")) {
-    return `${camelToKebab(typeName.slice(0, -"Output".length))}.json`;
-  }
-  if (typeName.endsWith("Result")) {
-    return `${camelToKebab(typeName.slice(0, -"Result".length))}.json`;
-  }
-  return `${camelToKebab(typeName)}.json`;
-}
-
-/** Bridge export constant for an output-schema root. */
-export function outputSchemaExportName(typeName: string): string {
-  if (typeName.endsWith("JsonOutput")) {
-    const base = typeName.slice(0, -"JsonOutput".length);
-    return `${camelToScreamingSnake(base)}_JSON_OUTPUT_SCHEMA`;
-  }
-  if (typeName.endsWith("OpResult")) {
-    const base = typeName.slice(0, -"OpResult".length);
-    return `${camelToScreamingSnake(base)}_OP_RESULT_OUTPUT_SCHEMA`;
-  }
-  if (typeName.endsWith("Output")) {
-    const base = typeName.slice(0, -"Output".length);
-    return `${camelToScreamingSnake(base)}_OUTPUT_SCHEMA`;
-  }
-  if (typeName.endsWith("Result")) {
-    const base = typeName.slice(0, -"Result".length);
-    return `${camelToScreamingSnake(base)}_RESULT_OUTPUT_SCHEMA`;
-  }
-  return `${camelToScreamingSnake(typeName)}_OUTPUT_SCHEMA`;
-}
-
-/** Generated JSON filename for a config-schema root (typically AppConfig → app-config.json). */
-export function outfileForConfigType(typeName: string): string {
-  if (typeName.endsWith("Config")) {
-    return `${camelToKebab(typeName.slice(0, -"Config".length))}-config.json`;
-  }
-  return `${camelToKebab(typeName)}-config.json`;
-}
-
-/** Bridge export constant for a config-schema root (AppConfig → APP_CONFIG_JSON_SCHEMA). */
-export function configSchemaExportName(typeName: string): string {
-  if (typeName.endsWith("Config")) {
-    const base = typeName.slice(0, -"Config".length);
-    return `${camelToScreamingSnake(base)}_CONFIG_JSON_SCHEMA`;
-  }
-  return `${camelToScreamingSnake(typeName)}_CONFIG_JSON_SCHEMA`;
-}
-
-/** Import path basename for a generated JSON file (no extension). */
-export function jsonImportBasename(outfile: string): string {
-  return outfile.replace(/\.json$/, "");
-}
-
-/** Safe import binding for a generated JSON file (no extension, hyphens → underscores). */
-export function jsonImportVar(outfile: string): string {
-  return jsonImportBasename(outfile).replace(/-/g, "_");
-}