@amritk/mjst 0.5.1 → 0.7.0

package/dist/cli.js

@@ -2,8 +2,8 @@
 
 // src/cli.ts
 import { execFile } from "node:child_process";
-import { mkdir, readFile as readFile3, unlink, writeFile } from "node:fs/promises";
-import { dirname as dirname2, join as join8, resolve as resolve3 } from "node:path";
+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";
 
 // ../adapters/dist/get-adapter.js
@@ -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)) {
@@ -90281,12 +90281,13 @@ var buildJsDocBlock = (title, description, commentUrl) => {
 `;
   return block;
 };
-var getTypeScriptType = (schema) => {
-  const base = getUnbrandedType(schema);
+var getTypeScriptType = (schema, options = {}) => {
+  const base = getUnbrandedType(schema, options);
   const brand2 = getMjstBrand(schema);
   return brand2 ? `(${base} & { readonly __brand: '${brand2}' })` : base;
 };
-var getUnbrandedType = (schema) => {
+var recordType = (keyType, valueType, options) => options.readonly ? `Readonly<Record<${keyType}, ${valueType}>>` : `Record<${keyType}, ${valueType}>`;
+var getUnbrandedType = (schema, options = {}) => {
   if (typeof schema === "boolean") {
     return getBooleanSubSchemaType(schema);
   }
@@ -90305,13 +90306,13 @@ var getUnbrandedType = (schema) => {
     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);
@@ -90334,51 +90335,51 @@ var getUnbrandedType = (schema) => {
     return multiEnumUnion;
   }
   if (schema.oneOf && Array.isArray(schema.oneOf) && schema.oneOf.length > 0) {
-    let oneOfUnion = getTypeScriptType(schema.oneOf[0]);
+    let oneOfUnion = getTypeScriptType(schema.oneOf[0], options);
     for (let i = 1;i < schema.oneOf.length; i++) {
-      oneOfUnion += " | " + getTypeScriptType(schema.oneOf[i]);
+      oneOfUnion += " | " + getTypeScriptType(schema.oneOf[i], options);
     }
     return oneOfUnion;
   }
   if (schema.anyOf && Array.isArray(schema.anyOf) && schema.anyOf.length > 0) {
-    let anyOfUnion = getTypeScriptType(schema.anyOf[0]);
+    let anyOfUnion = getTypeScriptType(schema.anyOf[0], options);
     for (let i = 1;i < schema.anyOf.length; i++) {
-      anyOfUnion += " | " + getTypeScriptType(schema.anyOf[i]);
+      anyOfUnion += " | " + getTypeScriptType(schema.anyOf[i], options);
     }
     return anyOfUnion;
   }
   if (schema.allOf && Array.isArray(schema.allOf) && schema.allOf.length > 0) {
-    let intersectionTypes = getTypeScriptType(schema.allOf[0]);
+    let intersectionTypes = getTypeScriptType(schema.allOf[0], options);
     for (let i = 1;i < schema.allOf.length; i++) {
-      intersectionTypes += " & " + getTypeScriptType(schema.allOf[i]);
+      intersectionTypes += " & " + getTypeScriptType(schema.allOf[i], options);
     }
     return intersectionTypes;
   }
   const conditionalResult = getConditionalObjectSchema(schema);
   if (conditionalResult) {
-    const baseType = getTypeScriptType(conditionalResult.schema);
+    const baseType = getTypeScriptType(conditionalResult.schema, options);
     if (conditionalResult.thenRef) {
-      return `(${baseType}) & ${refToName2(conditionalResult.thenRef)}`;
+      return `(${baseType}) & ${refToName2(conditionalResult.thenRef, options.typeSuffix)}`;
     }
     return baseType;
   }
   if (!schema.type) {
     if (schema.additionalProperties !== undefined) {
       if (typeof schema.additionalProperties === "boolean") {
-        return `Record<string, ${getBooleanSubSchemaType(schema.additionalProperties)}>`;
+        return recordType("string", getBooleanSubSchemaType(schema.additionalProperties), options);
       }
-      return `Record<string, ${getTypeScriptType(schema.additionalProperties)}>`;
+      return recordType("string", getTypeScriptType(schema.additionalProperties, options), options);
     }
     if (schema.patternProperties && typeof schema.patternProperties === "object") {
       const firstEntry = Object.entries(schema.patternProperties)[0];
       if (firstEntry) {
         const [pattern2, value10] = firstEntry;
         if (value10 !== undefined) {
-          const valueType = typeof value10 === "boolean" ? getBooleanSubSchemaType(value10) : getTypeScriptType(value10);
+          const valueType = typeof value10 === "boolean" ? getBooleanSubSchemaType(value10) : getTypeScriptType(value10, options);
           if (pattern2 === "^x-") {
-            return `Record<\`x-\${string}\`, ${valueType}>`;
+            return recordType("`x-${string}`", valueType, options);
           }
-          return `Record<string, ${valueType}>`;
+          return recordType("string", valueType, options);
         }
       }
     }
@@ -90431,41 +90432,42 @@ var getUnbrandedType = (schema) => {
       return "boolean";
     case "array":
       if (schema.items) {
-        const itemType = getTypeScriptType(schema.items);
+        const itemType = getTypeScriptType(schema.items, options);
         const wrappedItemType = itemType.includes(" | ") ? `(${itemType})` : itemType;
-        return `${wrappedItemType}[]`;
+        return options.readonly ? `readonly ${wrappedItemType}[]` : `${wrappedItemType}[]`;
       }
-      return "unknown[]";
+      return options.readonly ? "readonly unknown[]" : "unknown[]";
     case "object":
       if (schema.properties) {
+        const readonlyPrefix = options.readonly ? "readonly " : "";
         let properties = "";
         let first5 = 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);
+          const propType = getTypeScriptType(propSchema, options);
           if (!first5)
             properties += "; ";
-          properties += safeKey(key) + optional3 + ": " + propType;
+          properties += readonlyPrefix + safeKey(key) + optional3 + ": " + propType;
           first5 = false;
         }
         return "{ " + properties + " }";
       }
       if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
-        const additionalPropType = getTypeScriptType(schema.additionalProperties);
-        return `Record<string, ${additionalPropType}>`;
+        const additionalPropType = getTypeScriptType(schema.additionalProperties, options);
+        return recordType("string", additionalPropType, options);
       }
       if (schema.patternProperties && typeof schema.patternProperties === "object") {
         const firstEntry = Object.entries(schema.patternProperties)[0];
         if (firstEntry) {
           const [pattern2, patternVal] = firstEntry;
           if (patternVal) {
-            const valueType = getTypeScriptType(patternVal);
+            const valueType = getTypeScriptType(patternVal, options);
             if (pattern2 === "^x-") {
-              return `Record<\`x-\${string}\`, ${valueType}>`;
+              return recordType("`x-${string}`", valueType, options);
             }
-            return `Record<string, ${valueType}>`;
+            return recordType("string", valueType, options);
           }
         }
       }
@@ -90474,9 +90476,10 @@ var getUnbrandedType = (schema) => {
       return "unknown";
   }
 };
-var generateTypeDefinition = (schema, typeName) => {
+var generateTypeDefinition = (schema, typeName, options = {}) => {
+  const readonlyPrefix = options.readonly ? "readonly " : "";
   if (!isObjectLikeSchema(schema)) {
-    const tsType = getTypeScriptType(schema);
+    const tsType = getTypeScriptType(schema, options);
     let result = "";
     if (isSchemaObject2(schema) && schema.$comment && typeof schema.$comment === "string") {
       result += buildJsDocBlock(typeName, schema.$comment);
@@ -90504,23 +90507,23 @@ var generateTypeDefinition = (schema, typeName) => {
       if (firstPatternProperty === undefined) {
         return `export type ${typeName} = Record<string, unknown>;`;
       }
-      const patternPropType = typeof firstPatternProperty === "boolean" ? getBooleanSubSchemaType(firstPatternProperty) : getTypeScriptType(firstPatternProperty);
+      const patternPropType = typeof firstPatternProperty === "boolean" ? getBooleanSubSchemaType(firstPatternProperty) : getTypeScriptType(firstPatternProperty, options);
       const keyType = firstPattern === "^x-" ? "`x-${string}`" : "string";
       let result2 = "";
       if (jsDocTitle && jsDocDescription) {
         result2 += buildJsDocBlock(jsDocTitle, jsDocDescription);
       }
-      result2 += `export type ${typeName} = Record<${keyType}, ${patternPropType}>;`;
+      result2 += `export type ${typeName} = ${recordType(keyType, patternPropType, options)};`;
       return result2;
     }
     if (!hasProperties2 && hasAdditionalProperties2 && normalizedSchema.additionalProperties) {
-      const additionalPropType = getTypeScriptType(normalizedSchema.additionalProperties);
+      const additionalPropType = getTypeScriptType(normalizedSchema.additionalProperties, options);
       let result2 = "";
       if (jsDocTitle && jsDocDescription) {
         result2 += buildJsDocBlock(jsDocTitle, jsDocDescription);
       }
       result2 += `export type ${typeName} = {
-  [key: string]: ${additionalPropType};
+  ${readonlyPrefix}[key: string]: ${additionalPropType};
 };`;
       return result2;
     }
@@ -90531,8 +90534,8 @@ var generateTypeDefinition = (schema, typeName) => {
       const propSchema = schemaProps[key];
       const isRequired = normalizedSchema.required?.includes(key) ?? false;
       const optional3 = isRequired ? "" : "?";
-      const propType = getTypeScriptType(propSchema);
-      const quotedKey = safeKey(key);
+      const propType = getTypeScriptType(propSchema, options);
+      const quotedKey = readonlyPrefix + safeKey(key);
       if (!isFirstProp)
         properties += `
 `;
@@ -90549,12 +90552,12 @@ var generateTypeDefinition = (schema, typeName) => {
     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) {
@@ -90564,7 +90567,7 @@ var generateTypeDefinition = (schema, typeName) => {
 ` + properties + `
 }`;
     if (conditionalThenRef) {
-      typeBody += " & " + refToName2(conditionalThenRef);
+      typeBody += " & " + refToName2(conditionalThenRef, options.typeSuffix);
     }
     for (const intersectionType of allOfIntersections) {
       typeBody += " & " + intersectionType;
@@ -90580,31 +90583,32 @@ var PACKAGE_IMPORTS = {
   "validate-record": "import { validateRecord } from '@amritk/helpers/validate-record';",
   "has-ref": "import { hasRef } from '@amritk/helpers/schema-guards';"
 };
-var EMBEDDED_IMPORTS = {
-  "is-object": "import { isObject } from './_helpers/is-object';",
-  "validate-array": "import { validateArray } from './_helpers/validate-array';",
-  "validate-record": "import { validateRecord } from './_helpers/validate-record';",
-  "has-ref": "import { hasRef } from './_helpers/has-ref';"
+var EMBEDDED_NAMED_EXPORTS = {
+  "is-object": "isObject",
+  "validate-array": "validateArray",
+  "validate-record": "validateRecord",
+  "has-ref": "hasRef"
 };
-var collectHelpers = (parserFunction, mode) => {
+var embeddedImport = (helper, prefix) => `import { ${EMBEDDED_NAMED_EXPORTS[helper]} } from '${prefix}_helpers/${helper}';`;
+var collectHelpers = (parserFunction, mode, helpersImportPrefix = "./") => {
   const imports = [];
   const used = new Set;
-  const table3 = mode === "embedded" ? EMBEDDED_IMPORTS : PACKAGE_IMPORTS;
+  const importFor = (helper) => mode === "embedded" ? embeddedImport(helper, helpersImportPrefix) : PACKAGE_IMPORTS[helper];
   if (parserFunction.includes("validateArray")) {
-    imports.push(table3["validate-array"]);
+    imports.push(importFor("validate-array"));
     used.add("validate-array");
   }
   if (parserFunction.includes("validateRecord")) {
-    imports.push(table3["validate-record"]);
+    imports.push(importFor("validate-record"));
     used.add("validate-record");
     used.add("is-object");
   }
   if (parserFunction.includes("isObject")) {
-    imports.push(table3["is-object"]);
+    imports.push(importFor("is-object"));
     used.add("is-object");
   }
   if (parserFunction.includes("hasRef(")) {
-    imports.push(table3["has-ref"]);
+    imports.push(importFor("has-ref"));
     used.add("has-ref");
   }
   return { imports, used };
@@ -90698,6 +90702,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) {
@@ -90825,7 +90830,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;
@@ -91491,33 +91496,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) => {
@@ -91562,20 +91567,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");
@@ -91584,23 +91589,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)) {
@@ -91643,7 +91648,7 @@ var generateFallbackValue = (_, propSchema, useRefImports) => {
       return "undefined";
   }
 };
-var generateFallbackObject = (schema, useRefImports, typeName) => {
+var generateFallbackObject = (schema, useRefImports, typeName, suffix) => {
   if (!hasProperties(schema)) {
     return `{} as ${typeName}`;
   }
@@ -91654,7 +91659,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}`;
       }
@@ -91722,11 +91727,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) {
@@ -91735,7 +91740,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 = [];
@@ -91796,7 +91801,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) {
@@ -91807,7 +91812,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} => {`);
@@ -91830,7 +91835,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 {
@@ -91869,7 +91874,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>),`);
       }
     }
@@ -91879,7 +91884,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 {
@@ -91890,7 +91895,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 {
@@ -91901,7 +91906,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 {
@@ -91940,9 +91945,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},`;
@@ -91950,17 +91955,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,";
@@ -91988,7 +91993,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) {
@@ -91996,7 +92001,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}\`);
@@ -92046,7 +92051,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);
@@ -92060,7 +92065,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 = "";
@@ -92083,7 +92088,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;
@@ -92093,7 +92098,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);
   }
@@ -92101,15 +92106,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)
       `;
@@ -92182,7 +92187,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));
@@ -92190,30 +92196,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);
@@ -92223,7 +92229,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))
@@ -92241,7 +92247,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;
     }
@@ -92269,9 +92275,10 @@ var generateFile = (schema, typeName, options) => {
   const selfRef = options?.selfRef;
   const rootSchema = options?.rootSchema;
   const helpersMode = options?.helpersMode ?? "package";
-  const typeDefinition = generateTypeDefinition(schema, typeName);
+  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];
@@ -92287,15 +92294,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);
-  const imports = [...collectImports(schema, { selfRef, rootSchema }), ...helpers.imports];
+  const helpers = collectHelpers(combinedFunctions, helpersMode, options?.helpersImportPrefix);
+  const imports = [...collectImports(schema, { selfRef, rootSchema, typeSuffix }), ...helpers.imports];
   let result = "";
   if (imports.length > 0) {
     result += imports[0];
@@ -92336,7 +92344,7 @@ var extractDynamicAnchorDefs = (schema) => {
   }
   return refs;
 };
-var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWarnings, strict2, helpersMode = "package") => {
+var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWarnings, strict2, helpersMode = "package", helpersImportPrefix = "./", readonly2 = false, typeSuffix = "") => {
   rootSchema = upgradeDraft07Schema(rootSchema);
   const files = [];
   const processedRefs = new Set;
@@ -92350,6 +92358,9 @@ var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWar
     typesOnly: typesOnly ?? false,
     rootSchema,
     helpersMode,
+    helpersImportPrefix,
+    readonly: readonly2,
+    typeSuffix,
     ...logWarnings !== undefined ? { logWarnings } : {},
     ...strict2 !== undefined ? { strict: strict2 } : {}
   });
@@ -92376,7 +92387,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;
@@ -92385,6 +92396,9 @@ var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWar
       selfRef: ref,
       rootSchema,
       helpersMode,
+      helpersImportPrefix,
+      readonly: readonly2,
+      typeSuffix,
       ...logWarnings !== undefined ? { logWarnings } : {},
       ...strict2 !== undefined ? { strict: strict2 } : {}
     });
@@ -92458,6 +92472,41 @@ var deriveRootTypeName = (schema) => {
   return name || "Document";
 };
 
+// src/combine-files.ts
+var IMPORT_RE = /^import\s/;
+var RELATIVE_IMPORT_RE = /\bfrom\s+['"]\.\.?\//;
+var combineGeneratedFiles = (files) => {
+  const externalImports = new Set;
+  const bodies = [];
+  for (const file2 of files) {
+    if (file2.filename === "index.ts")
+      continue;
+    const bodyLines = [];
+    for (const line of file2.content.split(`
+`)) {
+      if (IMPORT_RE.test(line.trimStart())) {
+        if (RELATIVE_IMPORT_RE.test(line))
+          continue;
+        externalImports.add(line.trim());
+        continue;
+      }
+      bodyLines.push(line);
+    }
+    const body = bodyLines.join(`
+`).trim();
+    if (body)
+      bodies.push(body);
+  }
+  const importBlock = [...externalImports].sort().join(`
+`);
+  return [importBlock, bodies.join(`
+
+`)].filter(Boolean).join(`
+
+`) + `
+`;
+};
+
 // src/detect-helpers-mode.ts
 import { createRequire as createRequire2 } from "node:module";
 import { resolve } from "node:path";
@@ -92486,13 +92535,16 @@ var loadConfig = async (configPath) => {
   const obj = parsed;
   return {
     ...typeof obj["schema"] === "string" && { schema: obj["schema"] },
+    ...typeof obj["schemaDir"] === "string" && { schemaDir: obj["schemaDir"] },
     ...typeof obj["outDir"] === "string" && { outDir: obj["outDir"] },
+    ...typeof obj["outFile"] === "string" && { outFile: obj["outFile"] },
     ...isSourceFormat(obj["input"]) && { input: obj["input"] },
     ...typeof obj["export"] === "string" && { export: obj["export"] },
     ...typeof obj["typesOnly"] === "boolean" && { typesOnly: obj["typesOnly"] },
     ...typeof obj["build"] === "boolean" && { build: obj["build"] },
     ...typeof obj["logWarnings"] === "boolean" && { logWarnings: obj["logWarnings"] },
-    ...typeof obj["strict"] === "boolean" && { strict: obj["strict"] }
+    ...typeof obj["strict"] === "boolean" && { strict: obj["strict"] },
+    ...typeof obj["readonly"] === "boolean" && { readonly: obj["readonly"] }
   };
 };
 
@@ -92527,99 +92579,126 @@ ${String(error54)}`);
 
 // src/parse-cli-args.ts
 var SOURCE_FORMATS2 = ["json", "typebox", "zod", "valibot", "effect"];
+var BOOLEAN_KEYS = new Set(["typesOnly", "build", "logWarnings", "strict", "readonly"]);
+var VALUE_KEYS = new Set([
+  "schema",
+  "schemaDir",
+  "outDir",
+  "outFile",
+  "input",
+  "export",
+  "helpers",
+  "typeSuffix"
+]);
+var toCamelCase = (key) => key.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+var parseHelpersValue = (value10) => {
+  if (value10 === "package" || value10 === "embedded")
+    return value10;
+  return;
+};
+var parseInputValue = (value10) => SOURCE_FORMATS2.includes(value10) ? value10 : undefined;
+var assignValue = (config3, key, value10) => {
+  switch (key) {
+    case "schema":
+      config3.schema = value10;
+      return true;
+    case "schemaDir":
+      config3.schemaDir = value10;
+      return true;
+    case "outDir":
+      config3.outDir = value10;
+      return true;
+    case "outFile":
+      config3.outFile = value10;
+      return true;
+    case "export":
+      config3.export = value10;
+      return true;
+    case "typeSuffix":
+      config3.typeSuffix = value10;
+      return true;
+    case "input": {
+      const parsed = parseInputValue(value10);
+      if (parsed)
+        config3.input = parsed;
+      return true;
+    }
+    case "helpers": {
+      const parsed = parseHelpersValue(value10);
+      if (parsed)
+        config3.helpers = parsed;
+      return true;
+    }
+    default:
+      return false;
+  }
+};
+var assignBoolean = (config3, key, value10) => {
+  switch (key) {
+    case "typesOnly":
+      config3.typesOnly = value10;
+      return true;
+    case "build":
+      config3.build = value10;
+      return true;
+    case "logWarnings":
+      config3.logWarnings = value10;
+      return true;
+    case "strict":
+      config3.strict = value10;
+      return true;
+    case "readonly":
+      config3.readonly = value10;
+      return true;
+    default:
+      return false;
+  }
+};
 var parseCliArgs = (args2) => {
   const config3 = {};
-  const parseHelpersValue = (value10) => {
-    if (value10 === "package" || value10 === "embedded")
-      return value10;
-    return;
-  };
-  const parseInputValue = (value10) => SOURCE_FORMATS2.includes(value10) ? value10 : undefined;
   for (let i = 0;i < args2.length; i++) {
     const arg = args2[i];
-    if (!arg) {
+    if (!arg || !arg.startsWith("--")) {
       continue;
     }
-    if (arg.startsWith("--") && arg.includes("=")) {
-      const equalsIndex = arg.indexOf("=");
-      const key = arg.slice(2, equalsIndex);
+    const equalsIndex = arg.indexOf("=");
+    if (equalsIndex !== -1) {
+      const key2 = toCamelCase(arg.slice(2, equalsIndex));
       const value10 = arg.slice(equalsIndex + 1);
-      if (key === "schema") {
-        config3.schema = value10;
-      } else if (key === "outDir") {
-        config3.outDir = value10;
-      } else if (key === "input") {
-        const parsed = parseInputValue(value10);
-        if (parsed)
-          config3.input = parsed;
-      } else if (key === "export") {
-        config3.export = value10;
-      } else if (key === "types-only") {
-        config3.typesOnly = value10 !== "false";
-      } else if (key === "build") {
-        config3.build = value10 !== "false";
-      } else if (key === "log-warnings") {
-        config3.logWarnings = value10 !== "false";
-      } else if (key === "strict") {
-        config3.strict = value10 !== "false";
-      } else if (key === "helpers") {
-        const parsed = parseHelpersValue(value10);
-        if (parsed)
-          config3.helpers = parsed;
+      if (BOOLEAN_KEYS.has(key2)) {
+        assignBoolean(config3, key2, value10 !== "false");
+      } else {
+        assignValue(config3, key2, value10);
       }
       continue;
     }
-    if (arg === "--schema") {
-      const value10 = args2[i + 1];
-      if (value10 && !value10.startsWith("--")) {
-        config3.schema = value10;
-        i++;
-      }
-    } else if (arg === "--outDir") {
-      const value10 = args2[i + 1];
-      if (value10 && !value10.startsWith("--")) {
-        config3.outDir = value10;
-        i++;
-      }
-    } else if (arg === "--input") {
-      const value10 = args2[i + 1];
-      if (value10 && !value10.startsWith("--")) {
-        const parsed = parseInputValue(value10);
-        if (parsed) {
-          config3.input = parsed;
-          i++;
-        }
-      }
-    } else if (arg === "--export") {
+    const key = toCamelCase(arg.slice(2));
+    if (BOOLEAN_KEYS.has(key)) {
+      assignBoolean(config3, key, true);
+      continue;
+    }
+    if (VALUE_KEYS.has(key)) {
       const value10 = args2[i + 1];
       if (value10 && !value10.startsWith("--")) {
-        config3.export = value10;
+        assignValue(config3, key, value10);
         i++;
       }
-    } else if (arg === "--types-only") {
-      config3.typesOnly = true;
-    } else if (arg === "--build") {
-      config3.build = true;
-    } else if (arg === "--log-warnings") {
-      config3.logWarnings = true;
-    } else if (arg === "--strict") {
-      config3.strict = true;
-    } else if (arg === "--helpers") {
-      const value10 = args2[i + 1];
-      if (value10 && !value10.startsWith("--")) {
-        const parsed = parseHelpersValue(value10);
-        if (parsed) {
-          config3.helpers = parsed;
-          i++;
-        }
-      }
     }
   }
   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];
@@ -92632,77 +92711,190 @@ var extractConfigPath = (args2) => {
   }
   return;
 };
-var run10 = async () => {
-  const args2 = process.argv.slice(2);
-  const configPath = extractConfigPath(args2);
-  const fileConfig = configPath ? await loadConfig(configPath) : {};
-  const cliConfig = parseCliArgs(args2);
-  const config3 = { ...fileConfig, ...cliConfig };
-  if (!config3.schema) {
-    console.error("Error: --schema is required. Provide a path to a JSON Schema file.");
-    process.exit(1);
-  }
-  if (!config3.outDir) {
-    console.error("Error: --outDir is required. Provide an output directory for generated files.");
-    process.exit(1);
-  }
-  const schemaPath = resolve3(config3.schema);
+var loadSchema = async (config3, schemaPath) => {
   const inputFormat = config3.input ?? "json";
-  let schema;
   if (inputFormat === "json") {
-    schema = JSON.parse(await readFile3(schemaPath, "utf-8"));
-  } else {
-    console.log(`Input format: ${inputFormat}`);
-    const source = await loadSchemaModule(schemaPath, config3.export);
-    schema = await getAdapter(inputFormat).toJSONSchema(source);
+    return JSON.parse(await readFile4(schemaPath, "utf-8"));
+  }
+  console.log(`Input format: ${inputFormat}`);
+  const source = await loadSchemaModule(schemaPath, config3.export);
+  return getAdapter(inputFormat).toJSONSchema(source);
+};
+var writeGeneratedFile = async (baseDir, filename, content) => {
+  const filePath = join8(baseDir, filename);
+  await mkdir(dirname2(filePath), { recursive: true });
+  await writeFile(filePath, content, "utf-8");
+};
+var buildOutput = async (outputDir, tsFiles, typesOnly) => {
+  const tsconfigContent = JSON.stringify({
+    compilerOptions: {
+      target: "ESNext",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      declaration: true,
+      emitDeclarationOnly: typesOnly,
+      skipLibCheck: true
+    },
+    include: tsFiles.map((file2) => `./${file2}`)
+  }, null, 2);
+  const tsconfigPath = join8(outputDir, ".tsconfig-mjst-build.json");
+  await writeFile(tsconfigPath, tsconfigContent, "utf-8");
+  try {
+    await execFileAsync("npx", ["tsc", "--project", tsconfigPath]);
+  } catch {
+    throw new Error("TypeScript compilation failed. Check the generated files for errors.");
+  } finally {
+    await unlink(tsconfigPath);
   }
-  const outputDir = resolve3(config3.outDir);
+  for (const file2 of tsFiles) {
+    await unlink(join8(outputDir, file2));
+    console.log(`Built: ${file2.replace(/\.ts$/, ".js")}`);
+    console.log(`Built: ${file2.replace(/\.ts$/, ".d.ts")}`);
+  }
+  console.log(`
+Total files built: ${tsFiles.length * 2}`);
+};
+var findJsonSchemas = async (dir3) => {
+  const entries8 = await readdir(dir3, { withFileTypes: true });
+  const results = [];
+  for (const entry of entries8) {
+    const full = join8(dir3, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...await findJsonSchemas(full));
+    } else if (entry.isFile() && entry.name.endsWith(".json")) {
+      results.push(full);
+    }
+  }
+  return results;
+};
+var runSingle = async (config3, schemaPath, outputDir) => {
+  const schema = await loadSchema(config3, schemaPath);
   await mkdir(outputDir, { recursive: true });
   const helpersMode = config3.helpers ?? detectHelpersMode(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);
+  const files = await buildSchema(schema, rootTypeName, undefined, config3.typesOnly, config3.logWarnings, config3.strict, helpersMode, undefined, config3.readonly, config3.typeSuffix);
   for (const file2 of files) {
-    const filePath = join8(outputDir, file2.filename);
-    await mkdir(dirname2(filePath), { recursive: true });
-    await writeFile(filePath, file2.content, "utf-8");
+    await writeGeneratedFile(outputDir, file2.filename, file2.content);
     console.log(`Generated: ${file2.filename}`);
   }
   if (config3.build) {
-    const tsconfigContent = JSON.stringify({
-      compilerOptions: {
-        target: "ESNext",
-        module: "ESNext",
-        moduleResolution: "bundler",
-        declaration: true,
-        emitDeclarationOnly: config3.typesOnly,
-        skipLibCheck: true
-      },
-      include: ["./**/*.ts"]
-    }, null, 2);
-    const tsconfigPath = join8(outputDir, ".tsconfig-mjst-build.json");
-    await writeFile(tsconfigPath, tsconfigContent, "utf-8");
-    try {
-      await execFileAsync("npx", ["tsc", "--project", tsconfigPath]);
-    } catch {
-      throw new Error("TypeScript compilation failed. Check the generated files for errors.");
-    } finally {
-      await unlink(tsconfigPath);
-    }
+    await buildOutput(outputDir, files.map((f) => f.filename), config3.typesOnly);
+  } else {
+    console.log(`
+Total files generated: ${files.length}`);
+  }
+};
+var runSingleFile = async (config3, schemaPath, outFilePath) => {
+  const schema = await loadSchema(config3, schemaPath);
+  const outputDir = dirname2(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, config3.typeSuffix);
+  await writeFile(outFilePath, combineGeneratedFiles(files), "utf-8");
+  console.log(`Generated: ${relative(process.cwd(), outFilePath)}`);
+  if (config3.build) {
+    await buildOutput(outputDir, [basename(outFilePath)], config3.typesOnly);
+  } else {
+    console.log(`
+Total files generated: 1`);
+  }
+};
+var runRecursive = async (config3, schemaDir, outputDir) => {
+  if (config3.input && config3.input !== "json") {
+    console.error("Error: --schemaDir only supports JSON Schema files; remove --input or set it to 'json'.");
+    process.exit(1);
+  }
+  const schemaFiles = await findJsonSchemas(schemaDir);
+  if (schemaFiles.length === 0) {
+    console.error(`Error: no .json schema files found under ${schemaDir}.`);
+    process.exit(1);
+  }
+  await mkdir(outputDir, { recursive: true });
+  const helpersMode = config3.helpers ?? detectHelpersMode(outputDir);
+  console.log(`Helpers mode: ${helpersMode}${config3.helpers ? " (explicit)" : " (auto-detected)"}`);
+  const sharedHelpers = new Map;
+  const writtenTsFiles = [];
+  for (const schemaFile of schemaFiles) {
+    const relPath = relative(schemaDir, schemaFile);
+    const relNoExt = relPath.slice(0, -".json".length);
+    const schemaSubDir = join8(outputDir, relNoExt);
+    const depth = relNoExt.split(sep).filter(Boolean).length;
+    const helpersImportPrefix = "../".repeat(depth);
+    const schema = await loadSchema(config3, schemaFile);
+    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, config3.typeSuffix);
     for (const file2 of files) {
-      await unlink(join8(outputDir, file2.filename));
-      const jsFilename = file2.filename.replace(/\.ts$/, ".js");
-      const dtsFilename = file2.filename.replace(/\.ts$/, ".d.ts");
-      console.log(`Built: ${jsFilename}`);
-      console.log(`Built: ${dtsFilename}`);
+      if (file2.filename.startsWith("_helpers/")) {
+        sharedHelpers.set(file2.filename, file2.content);
+        continue;
+      }
+      await writeGeneratedFile(schemaSubDir, file2.filename, file2.content);
+      const relativeFilename = join8(relNoExt, file2.filename);
+      writtenTsFiles.push(relativeFilename);
+      console.log(`Generated: ${relativeFilename}`);
     }
-    console.log(`
-Total files built: ${files.length * 2}`);
+  }
+  for (const [filename, content] of sharedHelpers) {
+    await writeGeneratedFile(outputDir, filename, content);
+    writtenTsFiles.push(filename);
+    console.log(`Generated: ${filename}`);
+  }
+  if (config3.build) {
+    await buildOutput(outputDir, writtenTsFiles, config3.typesOnly);
   } else {
     console.log(`
-Total files generated: ${files.length}`);
+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);
+  const config3 = { ...fileConfig, ...cliConfig };
+  if (config3.outDir && config3.outFile) {
+    console.error("Error: provide only one of --out-dir or --out-file, not both.");
+    process.exit(1);
+  }
+  if (config3.outFile) {
+    if (!config3.typesOnly) {
+      console.error("Error: --out-file currently supports only --types-only output. Add --types-only or use --out-dir.");
+      process.exit(1);
+    }
+    if (config3.schemaDir) {
+      console.error("Error: --out-file cannot be combined with --schema-dir; use --out-dir for recursive output.");
+      process.exit(1);
+    }
+    if (!config3.schema) {
+      console.error("Error: --schema is required. Provide a path to a JSON Schema.");
+      process.exit(1);
+    }
+    await runSingleFile(config3, resolve3(config3.schema), resolve3(config3.outFile));
+    return;
+  }
+  if (!config3.outDir) {
+    console.error("Error: --out-dir or --out-file is required. Provide an output destination for generated files.");
+    process.exit(1);
+  }
+  const outputDir = resolve3(config3.outDir);
+  if (config3.schemaDir) {
+    await runRecursive(config3, resolve3(config3.schemaDir), outputDir);
+    return;
+  }
+  if (!config3.schema) {
+    console.error("Error: --schema (or --schemaDir) is required. Provide a path to a JSON Schema.");
+    process.exit(1);
   }
+  await runSingle(config3, resolve3(config3.schema), outputDir);
 };
 run10().catch((error54) => {
   console.error(error54 instanceof Error ? error54.message : error54);