@amritk/mjst 0.6.0 → 0.7.1

package/README.md

@@ -109,7 +109,8 @@ npx mjst --config ./mjst.config.json
 | 🚫 | `strict` | `--strict` | `boolean` | — | `false` | 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. |
 | 🔒 | `readonly` | `--readonly` | `boolean` | — | `false` | Emit every property, array, and record in the generated type definitions as readonly, producing deeply immutable types. Affects type definitions only; the generated parsers still build and return plain objects. |
 | 🧰 | `helpers` | `--helpers <mode>` | `string` | — | — | Controls how generated parsers reference their runtime helpers. 'package' emits imports from @amritk/helpers (requires it to be installed in the consumer project). 'embedded' ships the helper source under outDir/_helpers/ so the output is self-contained. When omitted, the CLI auto-detects: it picks 'package' if @amritk/helpers resolves from outDir, otherwise 'embedded'. |
-| ⚙️ | `config` | `--config <path>` | `string` | — | — | Path to a JSON config file. Keys match the option names in this schema (schema, schemaDir, outDir, outFile, typesOnly, build, logWarnings, strict, readonly, helpers). CLI flags take precedence over config file values. |
+| 🏷️ | `typeSuffix` | `--type-suffix <suffix>` | `string` | — | `""` | 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. |
+| ⚙️ | `config` | `--config <path>` | `string` | — | — | Path to a JSON config file. Keys match the option names in this schema (schema, schemaDir, outDir, outFile, typesOnly, build, logWarnings, strict, readonly, helpers, typeSuffix). CLI flags take precedence over config file values. |
 <!-- config-table-end -->
 
 ---

package/dist/cli-config.d.ts

@@ -67,4 +67,10 @@ export type CliConfig = {
      * 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;
 };

package/dist/cli.js

@@ -2,7 +2,7 @@
 
 // src/cli.ts
 import { execFile } from "node:child_process";
-import { mkdir, readdir, readFile as readFile3, unlink, writeFile } from "node:fs/promises";
+import { mkdir, readdir, readFile as readFile4, unlink, writeFile } from "node:fs/promises";
 import { basename, dirname as dirname2, join as join8, relative, resolve as resolve3, sep } from "node:path";
 import { promisify } from "node:util";
 
@@ -89888,15 +89888,15 @@ var refToFilename2 = (ref) => {
   }
   return filename;
 };
-var kebabToPascal = (kebab) => {
+var kebabToPascal = (kebab, suffix) => {
   const words = kebab.split("-");
   let pascalCase = "";
   for (const word of words) {
     pascalCase += word.charAt(0).toUpperCase() + word.slice(1);
   }
-  return pascalCase + "Object";
+  return pascalCase + suffix;
 };
-var refToName = (ref) => kebabToPascal(refToFilename2(ref));
+var refToName = (ref, suffix = "") => kebabToPascal(refToFilename2(ref), suffix);
 var resolveDynamicRefs = (schema, dynamicRefMap) => {
   if (typeof schema !== "object" || schema === null) {
     return schema;
@@ -90180,15 +90180,15 @@ var refToFilename4 = (ref) => {
   }
   return filename;
 };
-var kebabToPascal2 = (kebab) => {
+var kebabToPascal2 = (kebab, suffix) => {
   const words = kebab.split("-");
   let pascalCase = "";
   for (const word of words) {
     pascalCase += word.charAt(0).toUpperCase() + word.slice(1);
   }
-  return pascalCase + "Object";
+  return pascalCase + suffix;
 };
-var refToName2 = (ref) => kebabToPascal2(refToFilename4(ref));
+var refToName2 = (ref, suffix = "") => kebabToPascal2(refToFilename4(ref), suffix);
 var JS_IDENTIFIER = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
 var safeKey = (key) => {
   if (JS_IDENTIFIER.test(key)) {
@@ -90306,13 +90306,13 @@ var getUnbrandedType = (schema, options = {}) => {
     if (!schema.$ref.startsWith("#")) {
       return "unknown";
     }
-    return refToName2(schema.$ref);
+    return refToName2(schema.$ref, options.typeSuffix);
   }
   if (schema.$dynamicRef) {
     if (schema.$dynamicRef === "#meta") {
-      return "Schema";
+      return `Schema${options.typeSuffix ?? ""}`;
     }
-    return refToName2(schema.$dynamicRef);
+    return refToName2(schema.$dynamicRef, options.typeSuffix);
   }
   if (schema.const !== undefined) {
     return JSON.stringify(schema.const);
@@ -90359,7 +90359,7 @@ var getUnbrandedType = (schema, options = {}) => {
   if (conditionalResult) {
     const baseType = getTypeScriptType(conditionalResult.schema, options);
     if (conditionalResult.thenRef) {
-      return `(${baseType}) & ${refToName2(conditionalResult.thenRef)}`;
+      return `(${baseType}) & ${refToName2(conditionalResult.thenRef, options.typeSuffix)}`;
     }
     return baseType;
   }
@@ -90440,6 +90440,31 @@ var getUnbrandedType = (schema, options = {}) => {
     case "object":
       if (schema.properties) {
         const readonlyPrefix = options.readonly ? "readonly " : "";
+        const hasDescriptions = Object.values(schema.properties).some((p) => isSchemaObject2(p) && (typeof p.description === "string" || typeof p.$comment === "string"));
+        if (hasDescriptions) {
+          let properties2 = "";
+          let first22 = true;
+          for (const key in schema.properties) {
+            const propSchema = schema.properties[key];
+            const isRequired = schema.required?.includes(key) ?? false;
+            const optional3 = isRequired ? "" : "?";
+            const propType = getTypeScriptType(propSchema, options);
+            const inlineDescription = isSchemaObject2(propSchema) && typeof propSchema.description === "string" ? propSchema.description : isSchemaObject2(propSchema) && typeof propSchema.$comment === "string" ? propSchema.$comment : undefined;
+            if (!first22)
+              properties2 += `
+`;
+            first22 = false;
+            if (inlineDescription) {
+              properties2 += "  /** " + inlineDescription + ` */
+  ` + readonlyPrefix + safeKey(key) + optional3 + ": " + propType + ";";
+            } else {
+              properties2 += "  " + readonlyPrefix + safeKey(key) + optional3 + ": " + propType + ";";
+            }
+          }
+          return `{
+` + properties2 + `
+}`;
+        }
         let properties = "";
         let first5 = true;
         for (const key in schema.properties) {
@@ -90481,8 +90506,9 @@ var generateTypeDefinition = (schema, typeName, options = {}) => {
   if (!isObjectLikeSchema(schema)) {
     const tsType = getTypeScriptType(schema, options);
     let result = "";
-    if (isSchemaObject2(schema) && schema.$comment && typeof schema.$comment === "string") {
-      result += buildJsDocBlock(typeName, schema.$comment);
+    const topLevelComment = isSchemaObject2(schema) && typeof schema.description === "string" && schema.description || isSchemaObject2(schema) && typeof schema.$comment === "string" && schema.$comment || undefined;
+    if (topLevelComment) {
+      result += buildJsDocBlock(typeName, topLevelComment);
     }
     result += `export type ${typeName} = ${tsType};`;
     return result;
@@ -90493,9 +90519,10 @@ var generateTypeDefinition = (schema, typeName, options = {}) => {
     const conditionalThenRef = conditionalResult?.thenRef ?? null;
     let jsDocTitle;
     let jsDocDescription;
-    if (isSchemaObject2(schema) && schema.$comment && typeof schema.$comment === "string") {
+    const topLevelComment = isSchemaObject2(schema) && typeof schema.description === "string" && schema.description || isSchemaObject2(schema) && typeof schema.$comment === "string" && schema.$comment || undefined;
+    if (topLevelComment) {
       jsDocTitle = typeName;
-      jsDocDescription = schema.$comment;
+      jsDocDescription = topLevelComment;
     }
     const hasProperties2 = normalizedSchema.properties && Object.keys(normalizedSchema.properties).length > 0;
     const hasAdditionalProperties2 = normalizedSchema.additionalProperties && typeof normalizedSchema.additionalProperties === "object";
@@ -90552,12 +90579,12 @@ var generateTypeDefinition = (schema, typeName, options = {}) => {
     if (isSchemaObject2(schema) && Array.isArray(schema.allOf)) {
       for (const entry of schema.allOf) {
         if (isSchemaObject2(entry) && entry.$ref) {
-          allOfIntersections.push(refToName2(entry.$ref));
+          allOfIntersections.push(refToName2(entry.$ref, options.typeSuffix));
         }
       }
     }
     if (isSchemaObject2(schema) && typeof schema.$ref === "string" && schema.$ref.startsWith("#")) {
-      allOfIntersections.push(refToName2(schema.$ref));
+      allOfIntersections.push(refToName2(schema.$ref, options.typeSuffix));
     }
     let result = "";
     if (jsDocTitle && jsDocDescription) {
@@ -90567,7 +90594,7 @@ var generateTypeDefinition = (schema, typeName, options = {}) => {
 ` + properties + `
 }`;
     if (conditionalThenRef) {
-      typeBody += " & " + refToName2(conditionalThenRef);
+      typeBody += " & " + refToName2(conditionalThenRef, options.typeSuffix);
     }
     for (const intersectionType of allOfIntersections) {
       typeBody += " & " + intersectionType;
@@ -90702,6 +90729,7 @@ var collectImports = (schema, options) => {
   const typesOnly = options?.typesOnly === true;
   const selfFilename = options?.selfRef ? refToFilename(options.selfRef) : undefined;
   const rootSchema = options?.rootSchema;
+  const typeSuffix = options?.typeSuffix;
   const refs = new Set;
   const collectRefsFromValue = (value10) => {
     if (typeof value10 !== "object" || value10 === null) {
@@ -90829,7 +90857,7 @@ var collectImports = (schema, options) => {
       if (!resolveRef2(ref, rootSchema))
         continue;
     }
-    const typeName = refToName(ref);
+    const typeName = refToName(ref, typeSuffix);
     const filename = refToFilename(ref);
     if (selfFilename !== undefined && filename === selfFilename) {
       continue;
@@ -91495,33 +91523,33 @@ var isPropertyRequired = (key, schema) => {
   }
   return schema.required.includes(key);
 };
-var generateRequiredRefCall = (key, ref) => {
+var generateRequiredRefCall = (key, ref, suffix) => {
   const acc = safeAccessor("input", key);
-  const parserName = generateParserName(refToName(ref));
+  const parserName = generateParserName(refToName(ref, suffix));
   return `${parserName}(${acc})`;
 };
-var generateOptionalRefCall = (key, ref) => {
+var generateOptionalRefCall = (key, ref, suffix) => {
   const acc = safeAccessor("input", key);
-  const parserName = generateParserName(refToName(ref));
+  const parserName = generateParserName(refToName(ref, suffix));
   return `...(${acc} && { ${safeKey2(key)}: ${parserName}(${acc}) })`;
 };
-var generateRequiredArrayRefCall = (key, ref) => {
-  const parserName = generateParserName(refToName(ref));
+var generateRequiredArrayRefCall = (key, ref, suffix) => {
+  const parserName = generateParserName(refToName(ref, suffix));
   return `validateArray(${safeAccessor("input", key)}, ${parserName})`;
 };
-var generateOptionalArrayRefCall = (key, ref) => {
-  const parserName = generateParserName(refToName(ref));
+var generateOptionalArrayRefCall = (key, ref, suffix) => {
+  const parserName = generateParserName(refToName(ref, suffix));
   const acc = safeAccessor("input", key);
   return `...(${acc} && { ${safeKey2(key)}: validateArray(${acc}, ${parserName}) })`;
 };
-var generateRequiredRecordRefCall = (key, ref) => {
+var generateRequiredRecordRefCall = (key, ref, suffix) => {
   const acc = safeAccessor("input", key);
-  const parserName = generateParserName(refToName(ref));
+  const parserName = generateParserName(refToName(ref, suffix));
   return `validateRecord(${acc}, ${parserName})`;
 };
-var generateOptionalRecordRefCall = (key, ref) => {
+var generateOptionalRecordRefCall = (key, ref, suffix) => {
   const acc = safeAccessor("input", key);
-  const parserName = generateParserName(refToName(ref));
+  const parserName = generateParserName(refToName(ref, suffix));
   return `...(${acc} && { ${safeKey2(key)}: validateRecord(${acc}, ${parserName}) })`;
 };
 var generateOptionalInlineProperty = (key, valueExpression) => {
@@ -91566,20 +91594,20 @@ var shouldUseRecordRefImport = (propSchema, useRefImports) => {
   const additionalProps = propSchema.additionalProperties;
   return isSchemaObject3(additionalProps) && hasRef(additionalProps);
 };
-var generatePropertyValue = (key, propSchema, isRequired, useRefImports) => {
+var generatePropertyValue = (key, propSchema, isRequired, useRefImports, suffix) => {
   if (shouldUseRefImport(propSchema, useRefImports)) {
     const ref = propSchema.$ref;
-    return isRequired ? generateRequiredRefCall(key, ref) : generateOptionalRefCall(key, ref);
+    return isRequired ? generateRequiredRefCall(key, ref, suffix) : generateOptionalRefCall(key, ref, suffix);
   }
   if (shouldUseArrayRefImport(propSchema, useRefImports)) {
     const items = propSchema.items;
     const ref = items.$ref;
-    return isRequired ? generateRequiredArrayRefCall(key, ref) : generateOptionalArrayRefCall(key, ref);
+    return isRequired ? generateRequiredArrayRefCall(key, ref, suffix) : generateOptionalArrayRefCall(key, ref, suffix);
   }
   if (shouldUseRecordRefImport(propSchema, useRefImports)) {
     const additionalProps = propSchema.additionalProperties;
     const ref = additionalProps.$ref;
-    return isRequired ? generateRequiredRecordRefCall(key, ref) : generateOptionalRecordRefCall(key, ref);
+    return isRequired ? generateRequiredRecordRefCall(key, ref, suffix) : generateOptionalRecordRefCall(key, ref, suffix);
   }
   if (!isSchemaObject3(propSchema)) {
     return isRequired ? "undefined" : generateOptionalInlineProperty(key, "undefined");
@@ -91588,23 +91616,23 @@ var generatePropertyValue = (key, propSchema, isRequired, useRefImports) => {
   const valueExpression = generateValidationExpression(key, propSchema, defaultValue, isRequired);
   return isRequired ? valueExpression : generateOptionalInlineProperty(key, valueExpression);
 };
-var generatePropertyEntries = (schema, useRefImports) => {
+var generatePropertyEntries = (schema, useRefImports, suffix) => {
   if (!hasProperties(schema)) {
     return [];
   }
   const entries8 = [];
   for (const [key, propSchema] of Object.entries(schema.properties)) {
     const isRequired = isPropertyRequired(key, schema);
-    const value10 = generatePropertyValue(key, propSchema, isRequired, useRefImports);
+    const value10 = generatePropertyValue(key, propSchema, isRequired, useRefImports, suffix);
     const isOptional = value10.startsWith("...");
     entries8.push({ key, value: value10, isOptional });
   }
   return entries8;
 };
-var generateFallbackValue = (_, propSchema, useRefImports) => {
+var generateFallbackValue = (_, propSchema, useRefImports, suffix) => {
   if (useRefImports && hasRef(propSchema)) {
     const ref = propSchema.$ref;
-    const parserName = generateParserName(refToName(ref));
+    const parserName = generateParserName(refToName(ref, suffix));
     return `${parserName}(undefined)`;
   }
   if (useRefImports && isSchemaObject3(propSchema) && propSchema.type === "array" && hasItems(propSchema) && hasRef(propSchema.items)) {
@@ -91647,7 +91675,7 @@ var generateFallbackValue = (_, propSchema, useRefImports) => {
       return "undefined";
   }
 };
-var generateFallbackObject = (schema, useRefImports, typeName) => {
+var generateFallbackObject = (schema, useRefImports, typeName, suffix) => {
   if (!hasProperties(schema)) {
     return `{} as ${typeName}`;
   }
@@ -91658,7 +91686,7 @@ var generateFallbackObject = (schema, useRefImports, typeName) => {
   for (const [key, propSchema] of Object.entries(schema.properties)) {
     const isRequired = isPropertyRequired(key, schema);
     if (isRequired) {
-      const fallbackValue = generateFallbackValue(key, propSchema, useRefImports);
+      const fallbackValue = generateFallbackValue(key, propSchema, useRefImports, suffix);
       if (fallbackValue === "undefined") {
         return `{} as ${typeName}`;
       }
@@ -91726,11 +91754,11 @@ var toVarName = (key) => {
   return `_${safe}`;
 };
 var shapeValidatorName = (typeName) => `validate${typeName}Shape`;
-var generatePropertyTypeCheck = (varName, schema, useRefImports) => {
+var generatePropertyTypeCheck = (varName, schema, useRefImports, suffix) => {
   if (!isSchemaObject3(schema))
     return null;
   if (useRefImports && hasRef(schema)) {
-    const refName = refToName(schema.$ref);
+    const refName = refToName(schema.$ref, suffix);
     return `${shapeValidatorName(refName)}(${varName})`;
   }
   if (hasEnum(schema) || hasOneOf(schema) || hasAnyOf(schema) || hasAllOf(schema) || hasRef(schema) || "not" in schema) {
@@ -91739,7 +91767,7 @@ var generatePropertyTypeCheck = (varName, schema, useRefImports) => {
   if (!hasType(schema))
     return null;
   if (useRefImports && schema.type === "array" && hasItems(schema) && isSchemaObject3(schema.items) && hasRef(schema.items)) {
-    const refName = refToName(schema.items.$ref);
+    const refName = refToName(schema.items.$ref, suffix);
     return `Array.isArray(${varName}) && ${varName}.every(${shapeValidatorName(refName)})`;
   }
   const checks = [];
@@ -91800,7 +91828,7 @@ var generatePropertyTypeCheck = (varName, schema, useRefImports) => {
 var shouldCacheVariable = (propSchema, _canFastPath, _useRefImports) => {
   return isSchemaObject3(propSchema);
 };
-var generateObjectParser = (schema, typeName, useRefImports, logWarnings, strict2) => {
+var generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnings, strict2) => {
   const functionName = generateParserName(typeName);
   if (!hasProperties(schema)) {
     if (strict2) {
@@ -91811,7 +91839,7 @@ var generateObjectParser = (schema, typeName, useRefImports, logWarnings, strict
     }
     return `export const ${functionName} = (input: unknown): ${typeName} => isObject(input) ? input as ${typeName} : {} as ${typeName};`;
   }
-  const fallbackObject = generateFallbackObject(schema, useRefImports, typeName);
+  const fallbackObject = generateFallbackObject(schema, useRefImports, typeName, suffix);
   const properties = Object.entries(schema.properties);
   const lines = [];
   lines.push(`export const ${functionName} = (input: unknown): ${typeName} => {`);
@@ -91834,7 +91862,7 @@ var generateObjectParser = (schema, typeName, useRefImports, logWarnings, strict
       if (shouldUseRecordRefImport(propSchema, useRefImports)) {
         canFastPath = false;
       } else {
-        const check7 = generatePropertyTypeCheck(varName, propSchema, useRefImports);
+        const check7 = generatePropertyTypeCheck(varName, propSchema, useRefImports, suffix);
         if (check7 === null) {
           canFastPath = false;
         } else {
@@ -91873,7 +91901,7 @@ var generateObjectParser = (schema, typeName, useRefImports, logWarnings, strict
   if (useRefImports && isSchemaObject3(schema) && hasAllOf(schema)) {
     for (const entry of schema.allOf) {
       if (isSchemaObject3(entry) && hasRef(entry)) {
-        const parserName = generateParserName(refToName(entry.$ref));
+        const parserName = generateParserName(refToName(entry.$ref, suffix));
         objectLines.push(`    ...(${parserName}(input) as Record<string, unknown>),`);
       }
     }
@@ -91883,7 +91911,7 @@ var generateObjectParser = (schema, typeName, useRefImports, logWarnings, strict
     const accessor = shouldCache ? varName : safeAccessor("input", key);
     if (shouldUseRefImport(propSchema, useRefImports)) {
       const ref = propSchema.$ref;
-      const parserName = generateParserName(refToName(ref));
+      const parserName = generateParserName(refToName(ref, suffix));
       if (isRequired) {
         objectLines.push(`    ${safeKey2(key)}: ${parserName}(${accessor}),`);
       } else {
@@ -91894,7 +91922,7 @@ var generateObjectParser = (schema, typeName, useRefImports, logWarnings, strict
     if (shouldUseArrayRefImport(propSchema, useRefImports)) {
       const items = propSchema.items;
       const ref = items.$ref;
-      const parserName = generateParserName(refToName(ref));
+      const parserName = generateParserName(refToName(ref, suffix));
       if (isRequired) {
         objectLines.push(`    ${safeKey2(key)}: validateArray(${accessor}, ${parserName}),`);
       } else {
@@ -91905,7 +91933,7 @@ var generateObjectParser = (schema, typeName, useRefImports, logWarnings, strict
     if (shouldUseRecordRefImport(propSchema, useRefImports)) {
       const additionalProps = propSchema.additionalProperties;
       const ref = additionalProps.$ref;
-      const parserName = generateParserName(refToName(ref));
+      const parserName = generateParserName(refToName(ref, suffix));
       if (isRequired) {
         objectLines.push(`    ${safeKey2(key)}: validateRecord(${accessor}, ${parserName}),`);
       } else {
@@ -91944,9 +91972,9 @@ var generateObjectParser = (schema, typeName, useRefImports, logWarnings, strict
   }
   return result;
 };
-var generateCombinedObjectParser = (schema, typeName, useRefImports, logWarnings, strict2) => {
+var generateCombinedObjectParser = (schema, typeName, useRefImports, suffix, logWarnings, strict2) => {
   const functionName = generateParserName(typeName);
-  const entries8 = generatePropertyEntries(schema, useRefImports);
+  const entries8 = generatePropertyEntries(schema, useRefImports, suffix);
   const propertyLines = entries8.map((entry) => {
     if (entry.isOptional) {
       return `    ${entry.value},`;
@@ -91954,17 +91982,17 @@ var generateCombinedObjectParser = (schema, typeName, useRefImports, logWarnings
     return `    ${safeKey2(entry.key)}: ${entry.value},`;
   });
   if (!isSchemaObject3(schema) || !("patternProperties" in schema)) {
-    return generateObjectParser(schema, typeName, useRefImports, logWarnings, strict2);
+    return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict2);
   }
   const patternProps = schema.patternProperties;
   const patterns = Object.entries(patternProps);
   const refPattern = patterns.find(([, ps]) => isSchemaObject3(ps) && hasRef(ps));
   if (!refPattern || !useRefImports) {
-    return generateObjectParser(schema, typeName, useRefImports, logWarnings, strict2);
+    return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict2);
   }
   const [pattern2, patternSchema] = refPattern;
   const ref = patternSchema.$ref;
-  const parserName = generateParserName(refToName(ref));
+  const parserName = generateParserName(refToName(ref, suffix));
   const assignmentCode = `(result as Record<string, unknown>)[key] = ${parserName}(value);`;
   const escapedPattern = escapeRegexPattern2(pattern2);
   const inputSpread = "    ...input,";
@@ -91992,7 +92020,7 @@ ${objectProperties}
   return result;
 };`;
 };
-var generateAdditionalPropertiesParser = (schema, typeName, useRefImports, strict2) => {
+var generateAdditionalPropertiesParser = (schema, typeName, useRefImports, suffix, strict2) => {
   const functionName = generateParserName(typeName);
   const additionalProps = schema.additionalProperties;
   if (!additionalProps) {
@@ -92000,7 +92028,7 @@ var generateAdditionalPropertiesParser = (schema, typeName, useRefImports, stric
   }
   if (useRefImports && isSchemaObject3(additionalProps) && hasRef(additionalProps)) {
     const ref = additionalProps.$ref;
-    const parserName = generateParserName(refToName(ref));
+    const parserName = generateParserName(refToName(ref, suffix));
     if (strict2) {
       return `export const ${functionName} = (input: unknown): ${typeName} => {
   if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);
@@ -92050,7 +92078,7 @@ var generateInlineValueParser = (schema) => {
 var escapeRegexPattern2 = (pattern2) => {
   return pattern2.replace(/\\/g, "\\\\").replace(/\//g, "\\/");
 };
-var generatePatternPropertiesParser = (schema, typeName, useRefImports, strict2) => {
+var generatePatternPropertiesParser = (schema, typeName, useRefImports, suffix, strict2) => {
   const functionName = generateParserName(typeName);
   if (!("patternProperties" in schema) || typeof schema.patternProperties !== "object") {
     return generateEmptyObjectParser(typeName, strict2);
@@ -92064,7 +92092,7 @@ var generatePatternPropertiesParser = (schema, typeName, useRefImports, strict2)
   let patternAssignment = "(result as Record<string, unknown>)[key] = value;";
   if (useRefImports && isSchemaObject3(patternSchema) && hasRef(patternSchema)) {
     const ref = patternSchema.$ref;
-    const parserName = generateParserName(refToName(ref));
+    const parserName = generateParserName(refToName(ref, suffix));
     patternAssignment = `(result as Record<string, unknown>)[key] = ${parserName}(value);`;
   } else if (patternSchema === false) {
     patternAssignment = "";
@@ -92087,7 +92115,7 @@ ${notObjectBranch}
   return result;
 };`;
 };
-var generateConditionalParser = (schema, typeName) => {
+var generateConditionalParser = (schema, typeName, suffix) => {
   const functionName = generateParserName(typeName);
   const ifSchema = schema.if;
   const thenSchema = schema.then;
@@ -92097,7 +92125,7 @@ var generateConditionalParser = (schema, typeName) => {
   if (!thenHasRef || !elseHasRef) {
     const mergedSchema = getConditionalObjectSchema2(schema);
     if (mergedSchema) {
-      return generateObjectParser(mergedSchema, typeName, false);
+      return generateObjectParser(mergedSchema, typeName, false, suffix);
     }
     return generateEmptyObjectParser(typeName);
   }
@@ -92105,15 +92133,15 @@ var generateConditionalParser = (schema, typeName) => {
   if (!isRefCondition) {
     const mergedSchema = getConditionalObjectSchema2(schema);
     if (mergedSchema) {
-      return generateObjectParser(mergedSchema, typeName, false);
+      return generateObjectParser(mergedSchema, typeName, false, suffix);
     }
     return generateEmptyObjectParser(typeName);
   }
   const thenRef = thenSchema.$ref;
   const elseRef = elseSchema.$ref;
-  const thenParserName = generateParserName(refToName(thenRef));
-  const elseParserName = generateParserName(refToName(elseRef));
-  const thenTypeName = refToName(thenRef);
+  const thenParserName = generateParserName(refToName(thenRef, suffix));
+  const elseParserName = generateParserName(refToName(elseRef, suffix));
+  const thenTypeName = refToName(thenRef, suffix);
   return `export const ${functionName} = (input: unknown): ${typeName} | ${thenTypeName} =>
   hasRef(input) ? ${thenParserName}(input) : ${elseParserName}(input)
       `;
@@ -92186,7 +92214,8 @@ var selectParserStrategy = (schema, typeName, options) => {
   const useRefImports = options?.useRefImports ?? false;
   const logWarnings = options?.logWarnings ?? false;
   const strict2 = options?.strict ?? false;
-  if (typeName === "SchemaObject") {
+  const suffix = options?.typeSuffix ?? "";
+  if (typeName === `Schema${suffix}`) {
     return generateSchemaObjectParser(typeName);
   }
   const isObjectLikeSchema2 = isObjectSchema2(schema) || isSchemaObject3(schema) && (("patternProperties" in schema) || ("additionalProperties" in schema));
@@ -92194,30 +92223,30 @@ var selectParserStrategy = (schema, typeName, options) => {
     return generateNonObjectParser(typeName, schema, strict2);
   }
   if (hasProperties(schema) && isSchemaObject3(schema) && "patternProperties" in schema) {
-    return generateCombinedObjectParser(schema, typeName, useRefImports, logWarnings, strict2);
+    return generateCombinedObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict2);
   }
   if (hasProperties(schema)) {
-    return generateObjectParser(schema, typeName, useRefImports, logWarnings, strict2);
+    return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict2);
   }
   if (isSchemaObject3(schema) && "if" in schema && "then" in schema && "else" in schema) {
-    return generateConditionalParser(schema, typeName);
+    return generateConditionalParser(schema, typeName, suffix);
   }
   const conditionalObjectSchema = getConditionalObjectSchema2(schema);
   if (conditionalObjectSchema) {
-    return generateObjectParser(conditionalObjectSchema, typeName, useRefImports, logWarnings, strict2);
+    return generateObjectParser(conditionalObjectSchema, typeName, useRefImports, suffix, logWarnings, strict2);
   }
   if (!isObjectLikeSchema2) {
     return generateNonObjectParser(typeName, schema, strict2);
   }
   if ("patternProperties" in schema) {
-    return generatePatternPropertiesParser(schema, typeName, useRefImports, strict2);
+    return generatePatternPropertiesParser(schema, typeName, useRefImports, suffix, strict2);
   }
   if ("additionalProperties" in schema && !hasProperties(schema)) {
     const additionalProps = schema.additionalProperties;
     if (additionalProps === true || additionalProps === false) {
       return generateEmptyObjectParser(typeName, strict2);
     }
-    return generateAdditionalPropertiesParser(schema, typeName, useRefImports, strict2);
+    return generateAdditionalPropertiesParser(schema, typeName, useRefImports, suffix, strict2);
   }
   if ("type" in schema && schema.type === "object" && !hasProperties(schema)) {
     return generateEmptyObjectParser(typeName, strict2);
@@ -92227,7 +92256,7 @@ var selectParserStrategy = (schema, typeName, options) => {
 var generateParserFunction = (schema, typeName, options) => {
   return selectParserStrategy(schema, typeName, options);
 };
-var generateShapeValidator = (schema, typeName, useRefImports) => {
+var generateShapeValidator = (schema, typeName, useRefImports, suffix = "") => {
   const fnName = shapeValidatorName(typeName);
   const stub = `export const ${fnName} = (_input: unknown): boolean => false;`;
   if (!isSchemaObject3(schema))
@@ -92245,7 +92274,7 @@ var generateShapeValidator = (schema, typeName, useRefImports) => {
     }
     const accessor = safeAccessor("input", key);
     const isRequired = isPropertyRequired(key, schema);
-    const check7 = generatePropertyTypeCheck(accessor, propSchema, useRefImports);
+    const check7 = generatePropertyTypeCheck(accessor, propSchema, useRefImports, suffix);
     if (check7 === null) {
       return stub;
     }
@@ -92273,9 +92302,10 @@ var generateFile = (schema, typeName, options) => {
   const selfRef = options?.selfRef;
   const rootSchema = options?.rootSchema;
   const helpersMode = options?.helpersMode ?? "package";
-  const typeDefinition = generateTypeDefinition(schema, typeName, { readonly: options?.readonly ?? false });
+  const typeSuffix = options?.typeSuffix ?? "";
+  const typeDefinition = generateTypeDefinition(schema, typeName, { readonly: options?.readonly ?? false, typeSuffix });
   if (typesOnly) {
-    const imports2 = collectImports(schema, { typesOnly: true, selfRef, rootSchema });
+    const imports2 = collectImports(schema, { typesOnly: true, selfRef, rootSchema, typeSuffix });
     let result2 = "";
     if (imports2.length > 0) {
       result2 += imports2[0];
@@ -92291,15 +92321,16 @@ var generateFile = (schema, typeName, options) => {
   }
   const parserFunction = generateParserFunction(schema, typeName, {
     useRefImports: true,
+    typeSuffix,
     ...options?.logWarnings !== undefined ? { logWarnings: options.logWarnings } : {},
     ...options?.strict !== undefined ? { strict: options.strict } : {}
   });
-  const shapeValidator = generateShapeValidator(schema, typeName, true);
+  const shapeValidator = generateShapeValidator(schema, typeName, true, typeSuffix);
   const combinedFunctions = `${shapeValidator}
 
 ${parserFunction}`;
   const helpers = collectHelpers(combinedFunctions, helpersMode, options?.helpersImportPrefix);
-  const imports = [...collectImports(schema, { selfRef, rootSchema }), ...helpers.imports];
+  const imports = [...collectImports(schema, { selfRef, rootSchema, typeSuffix }), ...helpers.imports];
   let result = "";
   if (imports.length > 0) {
     result += imports[0];
@@ -92340,7 +92371,7 @@ var extractDynamicAnchorDefs = (schema) => {
   }
   return refs;
 };
-var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWarnings, strict2, helpersMode = "package", helpersImportPrefix = "./", readonly2 = false) => {
+var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWarnings, strict2, helpersMode = "package", helpersImportPrefix = "./", readonly2 = false, typeSuffix = "") => {
   rootSchema = upgradeDraft07Schema(rootSchema);
   const files = [];
   const processedRefs = new Set;
@@ -92356,6 +92387,7 @@ var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWar
     helpersMode,
     helpersImportPrefix,
     readonly: readonly2,
+    typeSuffix,
     ...logWarnings !== undefined ? { logWarnings } : {},
     ...strict2 !== undefined ? { strict: strict2 } : {}
   });
@@ -92382,7 +92414,7 @@ var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWar
       console.warn(`Warning: Could not resolve ref: ${ref}`);
       continue;
     }
-    const typeName = refToName(ref);
+    const typeName = refToName(ref, typeSuffix);
     const filename = refToFilename(ref);
     const processedSchema = resolveDynamicRefs(resolvedSchema, dynamicRefMap);
     const extendedSchema = extensions ? applySchemaExtensions(processedSchema, filename, extensions) : processedSchema;
@@ -92393,6 +92425,7 @@ var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWar
       helpersMode,
       helpersImportPrefix,
       readonly: readonly2,
+      typeSuffix,
       ...logWarnings !== undefined ? { logWarnings } : {},
       ...strict2 !== undefined ? { strict: strict2 } : {}
     });
@@ -92581,7 +92614,8 @@ var VALUE_KEYS = new Set([
   "outFile",
   "input",
   "export",
-  "helpers"
+  "helpers",
+  "typeSuffix"
 ]);
 var toCamelCase = (key) => key.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
 var parseHelpersValue = (value10) => {
@@ -92607,6 +92641,9 @@ var assignValue = (config3, key, value10) => {
     case "export":
       config3.export = value10;
       return true;
+    case "typeSuffix":
+      config3.typeSuffix = value10;
+      return true;
     case "input": {
       const parsed = parseInputValue(value10);
       if (parsed)
@@ -92678,8 +92715,17 @@ var parseCliArgs = (args2) => {
   return config3;
 };
 
+// src/read-version.ts
+import { readFile as readFile3 } from "node:fs/promises";
+var readVersion = async () => {
+  const pkgUrl = new URL("../package.json", import.meta.url);
+  const pkg = JSON.parse(await readFile3(pkgUrl, "utf-8"));
+  return pkg.version ?? "0.0.0";
+};
+
 // src/cli.ts
 var execFileAsync = promisify(execFile);
+var isVersionRequest = (args2) => args2[0] === "version" || args2.includes("--version") || args2.includes("-v");
 var extractConfigPath = (args2) => {
   for (let i = 0;i < args2.length; i++) {
     const arg = args2[i];
@@ -92695,7 +92741,7 @@ var extractConfigPath = (args2) => {
 var loadSchema = async (config3, schemaPath) => {
   const inputFormat = config3.input ?? "json";
   if (inputFormat === "json") {
-    return JSON.parse(await readFile3(schemaPath, "utf-8"));
+    return JSON.parse(await readFile4(schemaPath, "utf-8"));
   }
   console.log(`Input format: ${inputFormat}`);
   const source = await loadSchemaModule(schemaPath, config3.export);
@@ -92755,7 +92801,7 @@ var runSingle = async (config3, schemaPath, outputDir) => {
   console.log(`Helpers mode: ${helpersMode}${config3.helpers ? " (explicit)" : " (auto-detected)"}`);
   const rootTypeName = deriveRootTypeName(schema);
   console.log(`Root type: ${rootTypeName}`);
-  const files = await buildSchema(schema, rootTypeName, undefined, config3.typesOnly, config3.logWarnings, config3.strict, helpersMode, undefined, config3.readonly);
+  const files = await buildSchema(schema, rootTypeName, undefined, config3.typesOnly, config3.logWarnings, config3.strict, helpersMode, undefined, config3.readonly, config3.typeSuffix);
   for (const file2 of files) {
     await writeGeneratedFile(outputDir, file2.filename, file2.content);
     console.log(`Generated: ${file2.filename}`);
@@ -92773,7 +92819,7 @@ var runSingleFile = async (config3, schemaPath, outFilePath) => {
   await mkdir(outputDir, { recursive: true });
   const rootTypeName = deriveRootTypeName(schema);
   console.log(`Root type: ${rootTypeName}`);
-  const files = await buildSchema(schema, rootTypeName, undefined, config3.typesOnly, config3.logWarnings, config3.strict, config3.helpers ?? "package", undefined, config3.readonly);
+  const files = await buildSchema(schema, rootTypeName, undefined, config3.typesOnly, config3.logWarnings, config3.strict, config3.helpers ?? "package", undefined, config3.readonly, config3.typeSuffix);
   await writeFile(outFilePath, combineGeneratedFiles(files), "utf-8");
   console.log(`Generated: ${relative(process.cwd(), outFilePath)}`);
   if (config3.build) {
@@ -92808,7 +92854,7 @@ var runRecursive = async (config3, schemaDir, outputDir) => {
     const rootTypeName = deriveRootTypeName(schema);
     console.log(`
 ${relPath} → ${relNoExt}/ (root type: ${rootTypeName})`);
-    const files = await buildSchema(schema, rootTypeName, undefined, config3.typesOnly, config3.logWarnings, config3.strict, helpersMode, helpersImportPrefix, config3.readonly);
+    const files = await buildSchema(schema, rootTypeName, undefined, config3.typesOnly, config3.logWarnings, config3.strict, helpersMode, helpersImportPrefix, config3.readonly, config3.typeSuffix);
     for (const file2 of files) {
       if (file2.filename.startsWith("_helpers/")) {
         sharedHelpers.set(file2.filename, file2.content);
@@ -92834,6 +92880,10 @@ Total files generated: ${writtenTsFiles.length}`);
 };
 var run10 = async () => {
   const args2 = process.argv.slice(2);
+  if (isVersionRequest(args2)) {
+    console.log(await readVersion());
+    return;
+  }
   const configPath = extractConfigPath(args2);
   const fileConfig = configPath ? await loadConfig(configPath) : {};
   const cliConfig = parseCliArgs(args2);

package/dist/read-version.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reads the CLI's own version from its `package.json`.
+ *
+ * Resolved relative to this module so it works whether the code runs from
+ * `src/` (dev) or the bundled `dist/cli.js` (published) — `package.json`
+ * sits one directory above both.
+ */
+export declare const readVersion: () => Promise<string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/mjst",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "type": "module",
   "license": "MIT",
@@ -42,10 +42,10 @@
     "generate-readme": "bun run ./scripts/generate-readme.ts"
   },
   "dependencies": {
-    "@amritk/adapters": "0.2.2",
-    "@amritk/generate-parsers": "0.5.0",
+    "@amritk/adapters": "0.2.4",
+    "@amritk/generate-parsers": "0.6.1",
     "@amritk/generate-markdown": "0.2.1",
-    "@amritk/helpers": "0.5.0"
+    "@amritk/helpers": "0.6.1"
   },
   "devDependencies": {
     "json-schema-typed": "^8.0.1"

package/src/cli-config.ts

@@ -68,4 +68,10 @@ export type CliConfig = {
    * 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
 }

package/src/cli.ts

@@ -16,6 +16,11 @@ 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.
@@ -142,6 +147,7 @@ const runSingle = async (config: Partial<CliConfig>, schemaPath: string, outputD
     helpersMode,
     undefined,
     config.readonly,
+    config.typeSuffix,
   )
 
   for (const file of files) {
@@ -183,6 +189,7 @@ const runSingleFile = async (config: Partial<CliConfig>, schemaPath: string, out
     config.helpers ?? 'package',
     undefined,
     config.readonly,
+    config.typeSuffix,
   )
 
   await writeFile(outFilePath, combineGeneratedFiles(files), 'utf-8')
@@ -247,6 +254,7 @@ const runRecursive = async (config: Partial<CliConfig>, schemaDir: string, outpu
       helpersMode,
       helpersImportPrefix,
       config.readonly,
+      config.typeSuffix,
     )
 
     for (const file of files) {
@@ -279,6 +287,11 @@ 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

package/src/parse-cli-args.ts

@@ -18,6 +18,7 @@ type MutableConfig = {
   strict?: boolean
   readonly?: boolean
   helpers?: 'package' | 'embedded'
+  typeSuffix?: string
 }
 
 // Boolean flags toggle on by presence and accept `--flag=false` to opt out.
@@ -31,6 +32,7 @@ const VALUE_KEYS = new Set<keyof MutableConfig>([
   'input',
   'export',
   'helpers',
+  'typeSuffix',
 ])
 
 /** Normalizes a CLI flag name to its camelCase config key so both `--out-dir` and `--outDir` map to `outDir`. */
@@ -62,6 +64,9 @@ const assignValue = (config: MutableConfig, key: string, value: string): boolean
     case 'export':
       config.export = value
       return true
+    case 'typeSuffix':
+      config.typeSuffix = value
+      return true
     case 'input': {
       const parsed = parseInputValue(value)
       if (parsed) config.input = parsed

package/src/read-version.test.ts

@@ -0,0 +1,18 @@
+import { readFile } from 'node:fs/promises'
+import { describe, expect, it } from 'vitest'
+
+import { readVersion } from './read-version'
+
+describe('read-version', () => {
+  it('returns the version declared in the package.json', async () => {
+    const pkg = JSON.parse(await readFile(new URL('../package.json', import.meta.url), 'utf-8')) as {
+      version: string
+    }
+
+    expect(await readVersion()).toBe(pkg.version)
+  })
+
+  it('returns a semver-shaped string', async () => {
+    expect(await readVersion()).toMatch(/^\d+\.\d+\.\d+/)
+  })
+})

package/src/read-version.ts

@@ -0,0 +1,14 @@
+import { readFile } from 'node:fs/promises'
+
+/**
+ * Reads the CLI's own version from its `package.json`.
+ *
+ * Resolved relative to this module so it works whether the code runs from
+ * `src/` (dev) or the bundled `dist/cli.js` (published) — `package.json`
+ * sits one directory above both.
+ */
+export const readVersion = async (): Promise<string> => {
+  const pkgUrl = new URL('../package.json', import.meta.url)
+  const pkg = JSON.parse(await readFile(pkgUrl, 'utf-8')) as { version?: string }
+  return pkg.version ?? '0.0.0'
+}