@amritk/generate-validators 0.4.2 → 0.5.1

package/dist/index.js

@@ -1,1468 +1 @@
-// ../helpers/dist/build-dynamic-ref-map.js
-var isSchemaObject = (schema) => {
-  return typeof schema === "object" && schema !== null && typeof schema !== "boolean";
-};
-var buildDynamicRefMap = (rootSchema) => {
-  const map = {};
-  if (!isSchemaObject(rootSchema) || !("$defs" in rootSchema)) {
-    return map;
-  }
-  const defs = rootSchema.$defs;
-  for (const [key, value] of Object.entries(defs)) {
-    if (typeof value === "object" && value !== null && "$dynamicAnchor" in value && typeof value["$dynamicAnchor"] === "string") {
-      const anchor = value["$dynamicAnchor"];
-      map[`#${anchor}`] = `#/$defs/${key}`;
-    }
-  }
-  return map;
-};
-
-// ../helpers/dist/extract-refs.js
-var isResolvableRef = (ref) => {
-  if (ref === "#")
-    return false;
-  if (ref.startsWith("#"))
-    return true;
-  if (ref.startsWith("http://") || ref.startsWith("https://"))
-    return true;
-  return false;
-};
-var extractRefs = (schema) => {
-  const refs = new Set;
-  const traverse = (obj) => {
-    if (typeof obj !== "object" || obj === null) {
-      return;
-    }
-    if (Array.isArray(obj)) {
-      for (const item of obj) {
-        traverse(item);
-      }
-      return;
-    }
-    const record = obj;
-    if ("$ref" in record && typeof record["$ref"] === "string" && isResolvableRef(record["$ref"])) {
-      refs.add(record["$ref"]);
-    }
-    for (const key in record) {
-      traverse(record[key]);
-    }
-  };
-  traverse(schema);
-  return refs;
-};
-
-// ../helpers/dist/ref-to-filename.js
-var toKebabCase = (value) => value.replace(/OAuth/g, "Oauth").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/([a-z\d])([A-Z])/g, "$1-$2").toLowerCase();
-var uriRefToFilename = (uri) => {
-  const hashIndex = uri.indexOf("#");
-  const baseUri = hashIndex === -1 ? uri : uri.slice(0, hashIndex);
-  const fragment = hashIndex === -1 ? "" : uri.slice(hashIndex + 1);
-  const withoutProtocol = baseUri.replace(/^https?:\/\/[^/]+\//, "");
-  const withoutExt = withoutProtocol.replace(/\.json$/, "");
-  const rawSegments = withoutExt.split("/");
-  const SKIP_KEYS = new Set(["definitions", "$defs"]);
-  const segments = [];
-  for (let i = 0;i < rawSegments.length; i++) {
-    const s = rawSegments[i];
-    if (SKIP_KEYS.has(s))
-      continue;
-    const prevRaw = rawSegments[i - 1];
-    if (/^\d+\.\d+/.test(s) && prevRaw !== undefined && SKIP_KEYS.has(prevRaw))
-      continue;
-    segments.push(s);
-  }
-  const baseName = segments.map((s) => toKebabCase(s).replace(/\./g, "-")).join("-");
-  if (!fragment)
-    return baseName;
-  const fragSegments = fragment.split("/").filter((s) => s && !SKIP_KEYS.has(s) && s !== "properties");
-  const fragLast = fragSegments[fragSegments.length - 1];
-  if (!fragLast)
-    return baseName;
-  return `${baseName}-${toKebabCase(fragLast)}`;
-};
-var refToFilename = (ref) => {
-  if (ref.startsWith("http://") || ref.startsWith("https://")) {
-    return uriRefToFilename(ref);
-  }
-  const segments = ref.split("/");
-  let filename = segments[segments.length - 1];
-  if (/[A-Z]/.test(filename)) {
-    filename = toKebabCase(filename);
-  }
-  return filename;
-};
-
-// ../helpers/dist/ref-to-name.js
-var toKebabCase2 = (value) => value.replace(/OAuth/g, "Oauth").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/([a-z\d])([A-Z])/g, "$1-$2").toLowerCase();
-var uriRefToFilename2 = (uri) => {
-  const hashIndex = uri.indexOf("#");
-  const baseUri = hashIndex === -1 ? uri : uri.slice(0, hashIndex);
-  const fragment = hashIndex === -1 ? "" : uri.slice(hashIndex + 1);
-  const withoutProtocol = baseUri.replace(/^https?:\/\/[^/]+\//, "");
-  const withoutExt = withoutProtocol.replace(/\.json$/, "");
-  const rawSegments = withoutExt.split("/");
-  const SKIP_KEYS = new Set(["definitions", "$defs"]);
-  const segments = [];
-  for (let i = 0;i < rawSegments.length; i++) {
-    const s = rawSegments[i];
-    if (SKIP_KEYS.has(s))
-      continue;
-    const prevRaw = rawSegments[i - 1];
-    if (/^\d+\.\d+/.test(s) && prevRaw !== undefined && SKIP_KEYS.has(prevRaw))
-      continue;
-    segments.push(s);
-  }
-  const baseName = segments.map((s) => toKebabCase2(s).replace(/\./g, "-")).join("-");
-  if (!fragment)
-    return baseName;
-  const fragSegments = fragment.split("/").filter((s) => s && !SKIP_KEYS.has(s) && s !== "properties");
-  const fragLast = fragSegments[fragSegments.length - 1];
-  if (!fragLast)
-    return baseName;
-  return `${baseName}-${toKebabCase2(fragLast)}`;
-};
-var refToFilename2 = (ref) => {
-  if (ref.startsWith("http://") || ref.startsWith("https://")) {
-    return uriRefToFilename2(ref);
-  }
-  const segments = ref.split("/");
-  let filename = segments[segments.length - 1];
-  if (/[A-Z]/.test(filename)) {
-    filename = toKebabCase2(filename);
-  }
-  return filename;
-};
-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 + suffix;
-};
-var refToName = (ref, suffix = "") => kebabToPascal(refToFilename2(ref), suffix);
-
-// ../helpers/dist/resolve-dynamic-refs.js
-var resolveDynamicRefs = (schema, dynamicRefMap) => {
-  if (typeof schema !== "object" || schema === null) {
-    return schema;
-  }
-  if (Object.keys(dynamicRefMap).length === 0) {
-    return schema;
-  }
-  const clone = JSON.parse(JSON.stringify(schema));
-  const walk = (obj) => {
-    if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
-      return;
-    }
-    const record = obj;
-    if ("$dynamicRef" in record && typeof record["$dynamicRef"] === "string") {
-      const resolved = dynamicRefMap[record["$dynamicRef"]];
-      if (resolved) {
-        record["$ref"] = resolved;
-        delete record["$dynamicRef"];
-      }
-    }
-    for (const key in record) {
-      walk(record[key]);
-    }
-  };
-  walk(clone);
-  return clone;
-};
-
-// ../helpers/dist/resolve-ref.js
-var navigatePointer = (pointer, schema) => {
-  const parts = pointer.split("/").filter(Boolean);
-  let current = schema;
-  for (const part of parts) {
-    const decodedPart = part.replace(/~1/g, "/").replace(/~0/g, "~");
-    if (current && typeof current === "object" && decodedPart in current) {
-      const next = current[decodedPart];
-      if (typeof next === "object" && next !== null) {
-        current = next;
-      } else {
-        return;
-      }
-    } else {
-      return;
-    }
-  }
-  return current;
-};
-var resolveRef = (ref, rootSchema) => {
-  if (ref.startsWith("#")) {
-    return navigatePointer(ref.slice(1), rootSchema);
-  }
-  const hashIndex = ref.indexOf("#");
-  const baseUri = hashIndex === -1 ? ref : ref.slice(0, hashIndex);
-  const rawFragment = hashIndex === -1 ? "" : ref.slice(hashIndex + 1);
-  const fragment = rawFragment === "" || rawFragment === "/" ? "" : rawFragment;
-  const defs = rootSchema["$defs"];
-  if (typeof defs !== "object" || defs === null)
-    return;
-  const defsRecord = defs;
-  const base = defsRecord[baseUri];
-  if (typeof base !== "object" || base === null)
-    return;
-  if (!fragment)
-    return base;
-  const normalizedFragment = fragment.replace(/^\/definitions\//, "/$defs/");
-  return navigatePointer(normalizedFragment, base);
-};
-
-// ../helpers/dist/upgrade-draft07-schema.js
-var toKebabCase3 = (value) => value.replace(/OAuth/g, "Oauth").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/([a-z\d])([A-Z])/g, "$1-$2").toLowerCase();
-var uriRefToFilename3 = (uri) => {
-  const hashIndex = uri.indexOf("#");
-  const baseUri = hashIndex === -1 ? uri : uri.slice(0, hashIndex);
-  const fragment = hashIndex === -1 ? "" : uri.slice(hashIndex + 1);
-  const withoutProtocol = baseUri.replace(/^https?:\/\/[^/]+\//, "");
-  const withoutExt = withoutProtocol.replace(/\.json$/, "");
-  const rawSegments = withoutExt.split("/");
-  const SKIP_KEYS = new Set(["definitions", "$defs"]);
-  const segments = [];
-  for (let i = 0;i < rawSegments.length; i++) {
-    const s = rawSegments[i];
-    if (SKIP_KEYS.has(s))
-      continue;
-    const prevRaw = rawSegments[i - 1];
-    if (/^\d+\.\d+/.test(s) && prevRaw !== undefined && SKIP_KEYS.has(prevRaw))
-      continue;
-    segments.push(s);
-  }
-  const baseName = segments.map((s) => toKebabCase3(s).replace(/\./g, "-")).join("-");
-  if (!fragment)
-    return baseName;
-  const fragSegments = fragment.split("/").filter((s) => s && !SKIP_KEYS.has(s) && s !== "properties");
-  const fragLast = fragSegments[fragSegments.length - 1];
-  if (!fragLast)
-    return baseName;
-  return `${baseName}-${toKebabCase3(fragLast)}`;
-};
-var refToFilename3 = (ref) => {
-  if (ref.startsWith("http://") || ref.startsWith("https://")) {
-    return uriRefToFilename3(ref);
-  }
-  const segments = ref.split("/");
-  let filename = segments[segments.length - 1];
-  if (/[A-Z]/.test(filename)) {
-    filename = toKebabCase3(filename);
-  }
-  return filename;
-};
-var isDraft07Schema = (schema) => typeof schema["$schema"] === "string" && schema["$schema"].includes("draft-07");
-var rewriteRefs = (obj, refMap, selfRef) => {
-  if (typeof obj !== "object" || obj === null)
-    return obj;
-  if (Array.isArray(obj))
-    return obj.map((item) => rewriteRefs(item, refMap, selfRef));
-  const record = obj;
-  const result = {};
-  for (const [key, value] of Object.entries(record)) {
-    if (key === "$ref" && typeof value === "string") {
-      if (refMap.has(value)) {
-        result[key] = refMap.get(value);
-      } else if (value === "#" && selfRef) {
-        result[key] = selfRef;
-      } else {
-        result[key] = value;
-      }
-    } else {
-      result[key] = rewriteRefs(value, refMap, selfRef);
-    }
-  }
-  return result;
-};
-var hoistNestedDefs = (defs) => {
-  const hoisted = {};
-  for (const [parentName, parentSchema] of Object.entries(defs)) {
-    if (typeof parentSchema !== "object" || parentSchema === null) {
-      hoisted[parentName] = parentSchema;
-      continue;
-    }
-    const parentObj = parentSchema;
-    const nestedDefs = parentObj["$defs"];
-    if (!nestedDefs || typeof nestedDefs !== "object") {
-      hoisted[parentName] = parentSchema;
-      continue;
-    }
-    const parentPrefix = parentName.startsWith("http://") || parentName.startsWith("https://") ? refToFilename3(parentName) : parentName;
-    const localToHoisted = new Map;
-    for (const localName of Object.keys(nestedDefs)) {
-      const hoistedName = `${parentPrefix}-${toKebabCase3(localName)}`;
-      localToHoisted.set(`#/$defs/${localName}`, `#/$defs/${hoistedName}`);
-    }
-    const selfRef = `#/$defs/${parentPrefix}`;
-    const rewrittenParent = rewriteRefs(parentObj, localToHoisted, selfRef);
-    hoisted[parentName] = rewrittenParent;
-    for (const [localName, localSchema] of Object.entries(nestedDefs)) {
-      const hoistedName = `${parentPrefix}-${toKebabCase3(localName)}`;
-      hoisted[hoistedName] = rewriteRefs(localSchema, localToHoisted, selfRef);
-    }
-  }
-  return hoisted;
-};
-var upgradeDraft07Schema = (schema) => {
-  if (!isDraft07Schema(schema))
-    return schema;
-  const { definitions, $schema: _, ...rest } = schema;
-  const rawDefs = definitions ?? {};
-  const renamedDefs = {};
-  for (const [key, value] of Object.entries(rawDefs)) {
-    renamedDefs[key] = renameNestedDefs(value);
-  }
-  const hoistedDefs = hoistNestedDefs(renamedDefs);
-  for (const key of Object.keys(hoistedDefs)) {
-    if (key.startsWith("http://") || key.startsWith("https://")) {
-      const shortName = refToFilename3(key);
-      if (shortName && !(shortName in hoistedDefs)) {
-        hoistedDefs[shortName] = hoistedDefs[key];
-      }
-    }
-  }
-  return {
-    ...rest,
-    $defs: hoistedDefs
-  };
-};
-var renameNestedDefs = (obj) => {
-  if (typeof obj !== "object" || obj === null)
-    return obj;
-  if (Array.isArray(obj))
-    return obj.map(renameNestedDefs);
-  const record = obj;
-  const result = {};
-  for (const [key, value] of Object.entries(record)) {
-    if (key === "$ref" && typeof value === "string" && value.startsWith("#/definitions/")) {
-      result[key] = value.replace("#/definitions/", "#/$defs/");
-    } else {
-      const outKey = key === "definitions" ? "$defs" : key;
-      result[outKey] = renameNestedDefs(value);
-    }
-  }
-  return result;
-};
-
-// ../helpers/dist/generate-type-definition.js
-var isSchemaObject2 = (schema) => {
-  return typeof schema === "object" && schema !== null && typeof schema !== "boolean";
-};
-var isObjectSchema = (schema) => {
-  return isSchemaObject2(schema) && (("type" in schema) && schema.type === "object" || ("properties" in schema));
-};
-var MJST_EXTENSION_KEY = "x-mjst";
-var IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-var SUPPORTED_PRIMITIVES = new Set(["bigint"]);
-var SAFE_BRAND = /^[\w$ -]+$/;
-var readExtensionString = (schema, field) => {
-  if (!isSchemaObject2(schema))
-    return;
-  const extension = schema[MJST_EXTENSION_KEY];
-  if (typeof extension !== "object" || extension === null)
-    return;
-  const value = extension[field];
-  return typeof value === "string" ? value : undefined;
-};
-var getMjstInstanceOf = (schema) => {
-  const instanceOf = readExtensionString(schema, "instanceOf");
-  return instanceOf !== undefined && IDENTIFIER.test(instanceOf) ? instanceOf : undefined;
-};
-var getMjstPrimitive = (schema) => {
-  const primitive = readExtensionString(schema, "primitive");
-  return primitive !== undefined && SUPPORTED_PRIMITIVES.has(primitive) ? primitive : undefined;
-};
-var getMjstBrand = (schema) => {
-  const brand = readExtensionString(schema, "brand");
-  return brand !== undefined && SAFE_BRAND.test(brand) ? brand : undefined;
-};
-var toKebabCase4 = (value) => value.replace(/OAuth/g, "Oauth").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/([a-z\d])([A-Z])/g, "$1-$2").toLowerCase();
-var uriRefToFilename4 = (uri) => {
-  const hashIndex = uri.indexOf("#");
-  const baseUri = hashIndex === -1 ? uri : uri.slice(0, hashIndex);
-  const fragment = hashIndex === -1 ? "" : uri.slice(hashIndex + 1);
-  const withoutProtocol = baseUri.replace(/^https?:\/\/[^/]+\//, "");
-  const withoutExt = withoutProtocol.replace(/\.json$/, "");
-  const rawSegments = withoutExt.split("/");
-  const SKIP_KEYS = new Set(["definitions", "$defs"]);
-  const segments = [];
-  for (let i = 0;i < rawSegments.length; i++) {
-    const s = rawSegments[i];
-    if (SKIP_KEYS.has(s))
-      continue;
-    const prevRaw = rawSegments[i - 1];
-    if (/^\d+\.\d+/.test(s) && prevRaw !== undefined && SKIP_KEYS.has(prevRaw))
-      continue;
-    segments.push(s);
-  }
-  const baseName = segments.map((s) => toKebabCase4(s).replace(/\./g, "-")).join("-");
-  if (!fragment)
-    return baseName;
-  const fragSegments = fragment.split("/").filter((s) => s && !SKIP_KEYS.has(s) && s !== "properties");
-  const fragLast = fragSegments[fragSegments.length - 1];
-  if (!fragLast)
-    return baseName;
-  return `${baseName}-${toKebabCase4(fragLast)}`;
-};
-var refToFilename4 = (ref) => {
-  if (ref.startsWith("http://") || ref.startsWith("https://")) {
-    return uriRefToFilename4(ref);
-  }
-  const segments = ref.split("/");
-  let filename = segments[segments.length - 1];
-  if (/[A-Z]/.test(filename)) {
-    filename = toKebabCase4(filename);
-  }
-  return filename;
-};
-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 + suffix;
-};
-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)) {
-    return key;
-  }
-  return `'${key}'`;
-};
-var getConditionalObjectSchema = (schema) => {
-  if (!isSchemaObject2(schema)) {
-    return null;
-  }
-  if (!("if" in schema) || !("then" in schema)) {
-    return null;
-  }
-  const ifSchema = schema.if;
-  const thenSchema = schema.then;
-  if (!isSchemaObject2(ifSchema) || !isSchemaObject2(thenSchema)) {
-    return null;
-  }
-  const ifProperties = ifSchema.properties;
-  const thenProperties = thenSchema.properties;
-  const hasIfProperties = ifProperties && typeof ifProperties === "object";
-  const hasThenProperties = thenProperties && typeof thenProperties === "object";
-  if (!hasIfProperties && !hasThenProperties) {
-    return null;
-  }
-  const properties = {
-    ...hasIfProperties ? ifProperties : {},
-    ...hasThenProperties ? thenProperties : {}
-  };
-  const required = new Set;
-  if (Array.isArray(ifSchema.required)) {
-    for (const key of ifSchema.required) {
-      required.add(key);
-    }
-  }
-  if (hasIfProperties) {
-    for (const key in ifProperties) {
-      required.add(key);
-    }
-  }
-  if (Array.isArray(thenSchema.required)) {
-    for (const key of thenSchema.required) {
-      required.add(key);
-    }
-  }
-  if (hasThenProperties) {
-    for (const key in thenProperties) {
-      required.add(key);
-    }
-  }
-  const thenRef = typeof thenSchema.$ref === "string" ? thenSchema.$ref : null;
-  return {
-    schema: {
-      type: "object",
-      properties,
-      ...required.size > 0 ? { required: Array.from(required) } : {}
-    },
-    thenRef
-  };
-};
-var isObjectLikeSchema = (schema) => {
-  if (!isSchemaObject2(schema)) {
-    return false;
-  }
-  if (isObjectSchema(schema)) {
-    return true;
-  }
-  return "patternProperties" in schema || "additionalProperties" in schema || "if" in schema && "then" in schema;
-};
-var getBooleanSubSchemaType = (schema) => {
-  return schema ? "unknown" : "never";
-};
-var buildJsDocBlock = (title, description, commentUrl) => {
-  let block = `/**
-`;
-  block += `* ${title}
-`;
-  block += `*
-`;
-  block += `* ${description}
-`;
-  if (commentUrl?.startsWith("http")) {
-    block += `* 
-`;
-    block += `* @see {@link ${commentUrl}}
-`;
-  }
-  block += `*/
-`;
-  return block;
-};
-var getTypeScriptType = (schema, options = {}) => {
-  const base = getUnbrandedType(schema, options);
-  const brand = getMjstBrand(schema);
-  return brand ? `(${base} & { readonly __brand: '${brand}' })` : base;
-};
-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);
-  }
-  if (typeof schema !== "object" || schema === null) {
-    return "unknown";
-  }
-  const instanceOf = getMjstInstanceOf(schema);
-  if (instanceOf) {
-    return instanceOf;
-  }
-  const primitive = getMjstPrimitive(schema);
-  if (primitive) {
-    return primitive;
-  }
-  if (schema.$ref) {
-    if (!schema.$ref.startsWith("#")) {
-      return "unknown";
-    }
-    return refToName2(schema.$ref, options.typeSuffix);
-  }
-  if (schema.$dynamicRef) {
-    if (schema.$dynamicRef === "#meta") {
-      return `Schema${options.typeSuffix ?? ""}`;
-    }
-    return refToName2(schema.$dynamicRef, options.typeSuffix);
-  }
-  if (schema.const !== undefined) {
-    return JSON.stringify(schema.const);
-  }
-  if (schema.enum && schema.enum.length > 0) {
-    if (schema.enum.length === 1) {
-      return JSON.stringify(schema.enum[0]);
-    }
-    let enumUnion = JSON.stringify(schema.enum[0]);
-    for (let i = 1;i < schema.enum.length; i++) {
-      enumUnion += " | " + JSON.stringify(schema.enum[i]);
-    }
-    return enumUnion;
-  }
-  if (schema.enum && schema.enum.length > 1) {
-    let multiEnumUnion = JSON.stringify(schema.enum[0]);
-    for (let i = 1;i < schema.enum.length; i++) {
-      multiEnumUnion += " | " + JSON.stringify(schema.enum[i]);
-    }
-    return multiEnumUnion;
-  }
-  if (schema.oneOf && Array.isArray(schema.oneOf) && schema.oneOf.length > 0) {
-    let oneOfUnion = getTypeScriptType(schema.oneOf[0], options);
-    for (let i = 1;i < schema.oneOf.length; 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], options);
-    for (let i = 1;i < schema.anyOf.length; 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], options);
-    for (let i = 1;i < schema.allOf.length; i++) {
-      intersectionTypes += " & " + getTypeScriptType(schema.allOf[i], options);
-    }
-    return intersectionTypes;
-  }
-  const conditionalResult = getConditionalObjectSchema(schema);
-  if (conditionalResult) {
-    const baseType = getTypeScriptType(conditionalResult.schema, options);
-    if (conditionalResult.thenRef) {
-      return `(${baseType}) & ${refToName2(conditionalResult.thenRef, options.typeSuffix)}`;
-    }
-    return baseType;
-  }
-  if (!schema.type) {
-    if (schema.additionalProperties !== undefined) {
-      if (typeof schema.additionalProperties === "boolean") {
-        return recordType("string", getBooleanSubSchemaType(schema.additionalProperties), options);
-      }
-      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 [pattern, value] = firstEntry;
-        if (value !== undefined) {
-          const valueType = typeof value === "boolean" ? getBooleanSubSchemaType(value) : getTypeScriptType(value, options);
-          if (pattern === "^x-") {
-            return recordType("`x-${string}`", valueType, options);
-          }
-          return recordType("string", valueType, options);
-        }
-      }
-    }
-    if (schema.default !== undefined) {
-      if (typeof schema.default === "string") {
-        return "string";
-      }
-      if (typeof schema.default === "number") {
-        return "number";
-      }
-      if (typeof schema.default === "boolean") {
-        return "boolean";
-      }
-    }
-    return "unknown";
-  }
-  if (Array.isArray(schema.type)) {
-    const mapType = (t) => {
-      switch (t) {
-        case "string":
-          return "string";
-        case "number":
-        case "integer":
-          return "number";
-        case "boolean":
-          return "boolean";
-        case "null":
-          return "null";
-        case "array":
-          return "unknown[]";
-        case "object":
-          return "Record<string, unknown>";
-        default:
-          return "unknown";
-      }
-    };
-    let typeUnion = mapType(schema.type[0]);
-    for (let i = 1;i < schema.type.length; i++) {
-      typeUnion += " | " + mapType(schema.type[i]);
-    }
-    return typeUnion;
-  }
-  switch (schema.type) {
-    case "string":
-      return "string";
-    case "number":
-    case "integer":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "array":
-      if (schema.items) {
-        const itemType = getTypeScriptType(schema.items, options);
-        const wrappedItemType = itemType.includes(" | ") ? `(${itemType})` : itemType;
-        return options.readonly ? `readonly ${wrappedItemType}[]` : `${wrappedItemType}[]`;
-      }
-      return options.readonly ? "readonly unknown[]" : "unknown[]";
-    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 first2 = true;
-          for (const key in schema.properties) {
-            const propSchema = schema.properties[key];
-            const isRequired = schema.required?.includes(key) ?? false;
-            const optional = 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 (!first2)
-              properties2 += `
-`;
-            first2 = false;
-            if (inlineDescription) {
-              properties2 += "  /** " + inlineDescription + ` */
-  ` + readonlyPrefix + safeKey(key) + optional + ": " + propType + ";";
-            } else {
-              properties2 += "  " + readonlyPrefix + safeKey(key) + optional + ": " + propType + ";";
-            }
-          }
-          return `{
-` + properties2 + `
-}`;
-        }
-        let properties = "";
-        let first = true;
-        for (const key in schema.properties) {
-          const propSchema = schema.properties[key];
-          const isRequired = schema.required?.includes(key) ?? false;
-          const optional = isRequired ? "" : "?";
-          const propType = getTypeScriptType(propSchema, options);
-          if (!first)
-            properties += "; ";
-          properties += readonlyPrefix + safeKey(key) + optional + ": " + propType;
-          first = false;
-        }
-        return "{ " + properties + " }";
-      }
-      if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
-        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 [pattern, patternVal] = firstEntry;
-          if (patternVal) {
-            const valueType = getTypeScriptType(patternVal, options);
-            if (pattern === "^x-") {
-              return recordType("`x-${string}`", valueType, options);
-            }
-            return recordType("string", valueType, options);
-          }
-        }
-      }
-      return "object";
-    default:
-      return "unknown";
-  }
-};
-var generateTypeDefinition = (schema, typeName, options = {}) => {
-  const readonlyPrefix = options.readonly ? "readonly " : "";
-  if (!isObjectLikeSchema(schema)) {
-    const tsType = getTypeScriptType(schema, options);
-    let result = "";
-    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;
-  }
-  if (isObjectLikeSchema(schema)) {
-    const conditionalResult = getConditionalObjectSchema(schema);
-    const normalizedSchema = conditionalResult?.schema ?? schema;
-    const conditionalThenRef = conditionalResult?.thenRef ?? null;
-    let jsDocTitle;
-    let jsDocDescription;
-    const topLevelComment = isSchemaObject2(schema) && typeof schema.description === "string" && schema.description || isSchemaObject2(schema) && typeof schema.$comment === "string" && schema.$comment || undefined;
-    if (topLevelComment) {
-      jsDocTitle = typeName;
-      jsDocDescription = topLevelComment;
-    }
-    const hasProperties2 = normalizedSchema.properties && Object.keys(normalizedSchema.properties).length > 0;
-    const hasAdditionalProperties2 = normalizedSchema.additionalProperties && typeof normalizedSchema.additionalProperties === "object";
-    const hasPatternProperties = normalizedSchema.patternProperties && typeof normalizedSchema.patternProperties === "object" && Object.keys(normalizedSchema.patternProperties).length > 0;
-    if (!hasProperties2 && hasPatternProperties && normalizedSchema.patternProperties) {
-      const firstEntry = Object.entries(normalizedSchema.patternProperties)[0];
-      const firstPattern = firstEntry?.[0];
-      const firstPatternProperty = firstEntry?.[1];
-      if (firstPatternProperty === undefined) {
-        return `export type ${typeName} = Record<string, unknown>;`;
-      }
-      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} = ${recordType(keyType, patternPropType, options)};`;
-      return result2;
-    }
-    if (!hasProperties2 && hasAdditionalProperties2 && normalizedSchema.additionalProperties) {
-      const additionalPropType = getTypeScriptType(normalizedSchema.additionalProperties, options);
-      let result2 = "";
-      if (jsDocTitle && jsDocDescription) {
-        result2 += buildJsDocBlock(jsDocTitle, jsDocDescription);
-      }
-      result2 += `export type ${typeName} = {
-  ${readonlyPrefix}[key: string]: ${additionalPropType};
-};`;
-      return result2;
-    }
-    const schemaProps = normalizedSchema.properties ?? {};
-    let properties = "";
-    let isFirstProp = true;
-    for (const key in schemaProps) {
-      const propSchema = schemaProps[key];
-      const isRequired = normalizedSchema.required?.includes(key) ?? false;
-      const optional = isRequired ? "" : "?";
-      const propType = getTypeScriptType(propSchema, options);
-      const quotedKey = readonlyPrefix + safeKey(key);
-      if (!isFirstProp)
-        properties += `
-`;
-      isFirstProp = false;
-      const inlineDescription = isSchemaObject2(propSchema) && typeof propSchema.description === "string" ? propSchema.description : isSchemaObject2(propSchema) && typeof propSchema.$comment === "string" ? propSchema.$comment : undefined;
-      if (inlineDescription) {
-        properties += "  /** " + inlineDescription + ` */
-  ` + quotedKey + optional + ": " + propType + ";";
-      } else {
-        properties += "  " + quotedKey + optional + ": " + propType + ";";
-      }
-    }
-    const allOfIntersections = [];
-    if (isSchemaObject2(schema) && Array.isArray(schema.allOf)) {
-      for (const entry of schema.allOf) {
-        if (isSchemaObject2(entry) && entry.$ref) {
-          allOfIntersections.push(refToName2(entry.$ref, options.typeSuffix));
-        }
-      }
-    }
-    if (isSchemaObject2(schema) && typeof schema.$ref === "string" && schema.$ref.startsWith("#")) {
-      allOfIntersections.push(refToName2(schema.$ref, options.typeSuffix));
-    }
-    let result = "";
-    if (jsDocTitle && jsDocDescription) {
-      result += buildJsDocBlock(jsDocTitle, jsDocDescription);
-    }
-    let typeBody = `{
-` + properties + `
-}`;
-    if (conditionalThenRef) {
-      typeBody += " & " + refToName2(conditionalThenRef, options.typeSuffix);
-    }
-    for (const intersectionType of allOfIntersections) {
-      typeBody += " & " + intersectionType;
-    }
-    result += "export type " + typeName + " = " + typeBody + ";";
-    return result;
-  }
-  return "export type " + typeName + " = unknown;";
-};
-
-// ../helpers/dist/schema-guards.js
-var hasRef = (value) => {
-  return typeof value === "object" && value !== null && !Array.isArray(value) && "$ref" in value && typeof value.$ref === "string";
-};
-var isSchemaObject3 = (schema) => {
-  return typeof schema === "object" && schema !== null && typeof schema !== "boolean";
-};
-var hasType = (schema) => {
-  return isSchemaObject3(schema) && "type" in schema && typeof schema.type === "string";
-};
-var isObjectSchema2 = (schema) => {
-  return isSchemaObject3(schema) && (("type" in schema) && schema.type === "object" || ("properties" in schema));
-};
-var hasProperties = (schema) => {
-  return isSchemaObject3(schema) && "properties" in schema && typeof schema.properties === "object" && schema.properties !== null;
-};
-var hasEnum = (schema) => {
-  return isSchemaObject3(schema) && "enum" in schema && Array.isArray(schema.enum);
-};
-var hasPattern = (schema) => {
-  return isSchemaObject3(schema) && "pattern" in schema && typeof schema.pattern === "string";
-};
-var hasOneOf = (schema) => {
-  return isSchemaObject3(schema) && "oneOf" in schema && Array.isArray(schema.oneOf);
-};
-var hasAnyOf = (schema) => {
-  return isSchemaObject3(schema) && "anyOf" in schema && Array.isArray(schema.anyOf);
-};
-var hasAllOf = (schema) => {
-  return isSchemaObject3(schema) && "allOf" in schema && Array.isArray(schema.allOf);
-};
-var hasRequired = (schema) => {
-  return isSchemaObject3(schema) && "required" in schema && Array.isArray(schema.required);
-};
-var hasItems = (schema) => {
-  return isSchemaObject3(schema) && "items" in schema && typeof schema.items === "object" && schema.items !== null && typeof schema.items !== "boolean";
-};
-var hasAdditionalProperties = (schema) => {
-  return isSchemaObject3(schema) && "additionalProperties" in schema;
-};
-var hasMinLength = (schema) => {
-  return isSchemaObject3(schema) && "minLength" in schema && typeof schema.minLength === "number";
-};
-var hasMaxLength = (schema) => {
-  return isSchemaObject3(schema) && "maxLength" in schema && typeof schema.maxLength === "number";
-};
-var hasMinimum = (schema) => {
-  return isSchemaObject3(schema) && "minimum" in schema && typeof schema.minimum === "number";
-};
-var hasMaximum = (schema) => {
-  return isSchemaObject3(schema) && "maximum" in schema && typeof schema.maximum === "number";
-};
-var hasExclusiveMinimum = (schema) => {
-  return isSchemaObject3(schema) && "exclusiveMinimum" in schema && typeof schema.exclusiveMinimum === "number";
-};
-var hasExclusiveMaximum = (schema) => {
-  return isSchemaObject3(schema) && "exclusiveMaximum" in schema && typeof schema.exclusiveMaximum === "number";
-};
-var hasMultipleOf = (schema) => {
-  return isSchemaObject3(schema) && "multipleOf" in schema && typeof schema.multipleOf === "number";
-};
-
-// src/generators/collect-validator-imports.ts
-var buildImport = (ref, suffix) => {
-  const filename = refToFilename(ref);
-  const typeName = refToName(ref, suffix);
-  const validatorName = `validate${typeName}`;
-  return `import { type ${typeName}, ${validatorName} } from './${filename}'`;
-};
-var canonicalFilename = (ref) => {
-  const base = ref.endsWith("-or-reference") ? ref.replace("-or-reference", "") : ref;
-  return refToFilename(base);
-};
-var collectDirectRefs = (schema) => {
-  if (typeof schema === "boolean" || schema === null)
-    return [];
-  const refs = [];
-  if (hasRef(schema)) {
-    refs.push(schema.$ref);
-    return refs;
-  }
-  const propSchemas = "properties" in schema && typeof schema.properties === "object" && schema.properties !== null ? Object.values(schema.properties) : [];
-  for (const prop of propSchemas) {
-    if (hasRef(prop))
-      refs.push(prop.$ref);
-    if (hasItems(prop) && hasRef(prop.items))
-      refs.push(prop.items.$ref);
-    if (hasAdditionalProperties(prop) && hasRef(prop.additionalProperties)) {
-      refs.push(prop.additionalProperties.$ref);
-    }
-  }
-  if (hasItems(schema) && hasRef(schema.items)) {
-    refs.push(schema.items.$ref);
-  }
-  if (hasAdditionalProperties(schema) && hasRef(schema.additionalProperties)) {
-    refs.push(schema.additionalProperties.$ref);
-  }
-  for (const branch of [
-    ...hasOneOf(schema) ? schema.oneOf : [],
-    ...hasAnyOf(schema) ? schema.anyOf : [],
-    ...hasAllOf(schema) ? schema.allOf : []
-  ]) {
-    if (hasRef(branch))
-      refs.push(branch.$ref);
-  }
-  return refs;
-};
-var collectValidatorImports = (schema, options) => {
-  const selfFilename = options?.selfRef ? refToFilename(options.selfRef) : null;
-  const rootSchema = options?.rootSchema;
-  const typeSuffix = options?.typeSuffix ?? "";
-  const refs = collectDirectRefs(schema);
-  const seen = new Set;
-  const imports = [];
-  for (const ref of refs) {
-    const filename = canonicalFilename(ref);
-    if (seen.has(filename))
-      continue;
-    if (selfFilename && filename === selfFilename)
-      continue;
-    if (rootSchema) {
-      const resolved = resolveRef(ref, rootSchema);
-      if (!resolved)
-        continue;
-    }
-    seen.add(filename);
-    const importRef = ref.endsWith("-or-reference") ? ref.replace("-or-reference", "") : ref;
-    imports.push(buildImport(importRef, typeSuffix));
-  }
-  return imports;
-};
-
-// ../helpers/dist/mjst-extension.js
-var isSchemaObject4 = (schema) => {
-  return typeof schema === "object" && schema !== null && typeof schema !== "boolean";
-};
-var MJST_EXTENSION_KEY2 = "x-mjst";
-var IDENTIFIER2 = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-var SUPPORTED_PRIMITIVES2 = new Set(["bigint"]);
-var readExtensionString2 = (schema, field) => {
-  if (!isSchemaObject4(schema))
-    return;
-  const extension = schema[MJST_EXTENSION_KEY2];
-  if (typeof extension !== "object" || extension === null)
-    return;
-  const value = extension[field];
-  return typeof value === "string" ? value : undefined;
-};
-var getMjstInstanceOf2 = (schema) => {
-  const instanceOf = readExtensionString2(schema, "instanceOf");
-  return instanceOf !== undefined && IDENTIFIER2.test(instanceOf) ? instanceOf : undefined;
-};
-var getMjstPrimitive2 = (schema) => {
-  const primitive = readExtensionString2(schema, "primitive");
-  return primitive !== undefined && SUPPORTED_PRIMITIVES2.has(primitive) ? primitive : undefined;
-};
-
-// src/generators/generate-validator-function.ts
-var validatorName = (typeName) => `validate${typeName}`;
-var typeofString = (type) => {
-  if (type === "integer")
-    return "number";
-  return type;
-};
-var wrongTypeCondition = (accessor, type) => {
-  switch (type) {
-    case "string":
-      return `typeof ${accessor} !== 'string'`;
-    case "number":
-    case "integer":
-      return `typeof ${accessor} !== 'number'`;
-    case "boolean":
-      return `typeof ${accessor} !== 'boolean'`;
-    case "array":
-      return `!Array.isArray(${accessor})`;
-    case "object":
-      return `typeof ${accessor} !== 'object' || ${accessor} === null || Array.isArray(${accessor})`;
-    default:
-      return "";
-  }
-};
-var generatePropertyChecks = (key, propSchema, isRequired, suffix) => {
-  if (!isSchemaObject3(propSchema))
-    return [];
-  const raw = `obj[${JSON.stringify(key)}]`;
-  const path = `\`\${_path}/${key}\``;
-  const lines = [];
-  if (hasRef(propSchema)) {
-    const ref = propSchema.$ref;
-    const vName = validatorName(refToName(ref, suffix));
-    if (isRequired) {
-      lines.push(`  if (!(${JSON.stringify(key)} in obj)) {`);
-      lines.push(`    errors.push({ message: "must have required property '${key}'", path: _path })`);
-      lines.push(`  } else {`);
-      lines.push(`    const _r = ${vName}(${raw}, ${path})`);
-      lines.push(`    if (_r !== true) errors.push(..._r.errors)`);
-      lines.push(`  }`);
-    } else {
-      lines.push(`  if (${raw} !== undefined) {`);
-      lines.push(`    const _r = ${vName}(${raw}, ${path})`);
-      lines.push(`    if (_r !== true) errors.push(..._r.errors)`);
-      lines.push(`  }`);
-    }
-    return lines;
-  }
-  const instanceOf = getMjstInstanceOf2(propSchema);
-  if (instanceOf) {
-    if (isRequired) {
-      lines.push(`  if (!(${JSON.stringify(key)} in obj)) {`);
-      lines.push(`    errors.push({ message: "must have required property '${key}'", path: _path })`);
-      lines.push(`  } else if (!(${raw} instanceof ${instanceOf})) {`);
-      lines.push(`    errors.push({ message: 'must be ${instanceOf}', path: ${path} })`);
-      lines.push(`  }`);
-    } else {
-      lines.push(`  if (${raw} !== undefined && !(${raw} instanceof ${instanceOf})) {`);
-      lines.push(`    errors.push({ message: 'must be ${instanceOf}', path: ${path} })`);
-      lines.push(`  }`);
-    }
-    return lines;
-  }
-  const primitive = getMjstPrimitive2(propSchema);
-  if (primitive) {
-    if (isRequired) {
-      lines.push(`  if (!(${JSON.stringify(key)} in obj)) {`);
-      lines.push(`    errors.push({ message: "must have required property '${key}'", path: _path })`);
-      lines.push(`  } else if (typeof ${raw} !== "${primitive}") {`);
-      lines.push(`    errors.push({ message: 'must be ${primitive}', path: ${path} })`);
-      lines.push(`  }`);
-    } else {
-      lines.push(`  if (${raw} !== undefined && typeof ${raw} !== "${primitive}") {`);
-      lines.push(`    errors.push({ message: 'must be ${primitive}', path: ${path} })`);
-      lines.push(`  }`);
-    }
-    return lines;
-  }
-  if (hasEnum(propSchema)) {
-    const allowed = JSON.stringify(propSchema.enum);
-    const label = propSchema.enum.map((v) => JSON.stringify(v)).join(", ");
-    if (isRequired) {
-      lines.push(`  if (!(${JSON.stringify(key)} in obj)) {`);
-      lines.push(`    errors.push({ message: "must have required property '${key}'", path: _path })`);
-      lines.push(`  } else if (!(${allowed} as unknown[]).includes(${raw})) {`);
-      lines.push(`    errors.push({ message: \`must be one of: ${label}\`, path: ${path} })`);
-      lines.push(`  }`);
-    } else {
-      lines.push(`  if (${raw} !== undefined && !(${allowed} as unknown[]).includes(${raw})) {`);
-      lines.push(`    errors.push({ message: \`must be one of: ${label}\`, path: ${path} })`);
-      lines.push(`  }`);
-    }
-    return lines;
-  }
-  if (hasType(propSchema)) {
-    const t = propSchema.type;
-    const wrongType = wrongTypeCondition(raw, t);
-    const typLabel = typeofString(t);
-    if (isRequired) {
-      lines.push(`  if (!(${JSON.stringify(key)} in obj)) {`);
-      lines.push(`    errors.push({ message: "must have required property '${key}'", path: _path })`);
-      if (wrongType) {
-        lines.push(`  } else if (${wrongType}) {`);
-        lines.push(`    errors.push({ message: 'must be ${typLabel}', path: ${path} })`);
-      }
-      lines.push(`  }`);
-    } else if (wrongType) {
-      lines.push(`  if (${raw} !== undefined && (${wrongType})) {`);
-      lines.push(`    errors.push({ message: 'must be ${typLabel}', path: ${path} })`);
-      lines.push(`  }`);
-    }
-    if (t === "string") {
-      if (hasPattern(propSchema)) {
-        lines.push(`  if (typeof ${raw} === 'string' && !/${propSchema.pattern}/.test(${raw})) {`);
-        lines.push(`    errors.push({ message: 'must match pattern ${propSchema.pattern}', path: ${path} })`);
-        lines.push(`  }`);
-      }
-      if (hasMinLength(propSchema)) {
-        lines.push(`  if (typeof ${raw} === 'string' && ${raw}.length < ${propSchema.minLength}) {`);
-        lines.push(`    errors.push({ message: 'must have at least ${propSchema.minLength} characters', path: ${path} })`);
-        lines.push(`  }`);
-      }
-      if (hasMaxLength(propSchema)) {
-        lines.push(`  if (typeof ${raw} === 'string' && ${raw}.length > ${propSchema.maxLength}) {`);
-        lines.push(`    errors.push({ message: 'must have at most ${propSchema.maxLength} characters', path: ${path} })`);
-        lines.push(`  }`);
-      }
-    }
-    if (t === "number" || t === "integer") {
-      if (hasMinimum(propSchema)) {
-        lines.push(`  if (typeof ${raw} === 'number' && ${raw} < ${propSchema.minimum}) {`);
-        lines.push(`    errors.push({ message: 'must be >= ${propSchema.minimum}', path: ${path} })`);
-        lines.push(`  }`);
-      }
-      if (hasMaximum(propSchema)) {
-        lines.push(`  if (typeof ${raw} === 'number' && ${raw} > ${propSchema.maximum}) {`);
-        lines.push(`    errors.push({ message: 'must be <= ${propSchema.maximum}', path: ${path} })`);
-        lines.push(`  }`);
-      }
-      if (hasExclusiveMinimum(propSchema)) {
-        lines.push(`  if (typeof ${raw} === 'number' && ${raw} <= ${propSchema.exclusiveMinimum}) {`);
-        lines.push(`    errors.push({ message: 'must be > ${propSchema.exclusiveMinimum}', path: ${path} })`);
-        lines.push(`  }`);
-      }
-      if (hasExclusiveMaximum(propSchema)) {
-        lines.push(`  if (typeof ${raw} === 'number' && ${raw} >= ${propSchema.exclusiveMaximum}) {`);
-        lines.push(`    errors.push({ message: 'must be < ${propSchema.exclusiveMaximum}', path: ${path} })`);
-        lines.push(`  }`);
-      }
-      if (hasMultipleOf(propSchema)) {
-        lines.push(`  if (typeof ${raw} === 'number' && ${raw} % ${propSchema.multipleOf} !== 0) {`);
-        lines.push(`    errors.push({ message: 'must be a multiple of ${propSchema.multipleOf}', path: ${path} })`);
-        lines.push(`  }`);
-      }
-    }
-    if (t === "array" && hasItems(propSchema)) {
-      const itemSchema = propSchema.items;
-      if (hasRef(itemSchema)) {
-        const vName = validatorName(refToName(itemSchema.$ref, suffix));
-        lines.push(`  if (Array.isArray(${raw})) {`);
-        lines.push(`    for (let _i = 0; _i < ${raw}.length; _i++) {`);
-        lines.push(`      const _ir = ${vName}(${raw}[_i], \`${path.slice(1, -1)}/${key}/\${_i}\`)`);
-        lines.push(`      if (_ir !== true) errors.push(..._ir.errors)`);
-        lines.push(`    }`);
-        lines.push(`  }`);
-      } else if (hasType(itemSchema)) {
-        const itemType = itemSchema.type;
-        const itemWrong = wrongTypeCondition("_item", itemType);
-        const itemLabel = typeofString(itemType);
-        if (itemWrong) {
-          lines.push(`  if (Array.isArray(${raw})) {`);
-          lines.push(`    for (let _i = 0; _i < ${raw}.length; _i++) {`);
-          lines.push(`      const _item = ${raw}[_i]`);
-          lines.push(`      if (${itemWrong}) errors.push({ message: 'items must be ${itemLabel}', path: \`${path.slice(1, -1)}/${key}/\${_i}\` })`);
-          lines.push(`    }`);
-          lines.push(`  }`);
-        }
-      }
-    }
-  }
-  return lines;
-};
-var generateObjectValidator = (schema, typeName, suffix) => {
-  const vName = validatorName(typeName);
-  const required = new Set(hasRequired(schema) ? schema.required : []);
-  const properties = hasProperties(schema) ? schema.properties : {};
-  const propertyLines = [];
-  for (const [key, propSchema] of Object.entries(properties)) {
-    const checks = generatePropertyChecks(key, propSchema, required.has(key), suffix);
-    if (checks.length > 0) {
-      propertyLines.push(...checks);
-    }
-  }
-  if (hasAdditionalProperties(schema) && isSchemaObject3(schema.additionalProperties) && hasRef(schema.additionalProperties)) {
-    const vRefName = validatorName(refToName(schema.additionalProperties.$ref, suffix));
-    propertyLines.push(`  for (const _key of Object.keys(obj)) {`);
-    propertyLines.push(`    if (${JSON.stringify(Object.keys(properties))}.includes(_key)) continue`);
-    propertyLines.push(`    const _r = ${vRefName}(obj[_key as keyof typeof obj], \`\${_path}/\${_key}\`)`);
-    propertyLines.push(`    if (_r !== true) errors.push(..._r.errors)`);
-    propertyLines.push(`  }`);
-  }
-  const body = propertyLines.length > 0 ? `
-` + propertyLines.join(`
-`) + `
-` : "";
-  return [
-    `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
-    `  if (typeof input !== 'object' || input === null || Array.isArray(input)) {`,
-    `    return { valid: false, errors: [{ message: 'must be object', path: _path }] }`,
-    `  }`,
-    ``,
-    `  const errors: ValidationError[] = []`,
-    `  const obj = input as Record<string, unknown>`,
-    body,
-    `  return errors.length > 0 ? { valid: false, errors } : true`,
-    `}`
-  ].join(`
-`);
-};
-var generateScalarValidator = (schema, typeName, suffix) => {
-  const vName = validatorName(typeName);
-  if (!isSchemaObject3(schema)) {
-    return [`export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`, `  return true`, `}`].join(`
-`);
-  }
-  if (hasRef(schema)) {
-    const delegateName = validatorName(refToName(schema.$ref, suffix));
-    return [
-      `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
-      `  return ${delegateName}(input, _path)`,
-      `}`
-    ].join(`
-`);
-  }
-  const instanceOf = getMjstInstanceOf2(schema);
-  if (instanceOf) {
-    return [
-      `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
-      `  if (!(input instanceof ${instanceOf})) {`,
-      `    return { valid: false, errors: [{ message: 'must be ${instanceOf}', path: _path }] }`,
-      `  }`,
-      `  return true`,
-      `}`
-    ].join(`
-`);
-  }
-  const primitive = getMjstPrimitive2(schema);
-  if (primitive) {
-    return [
-      `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
-      `  if (typeof input !== "${primitive}") {`,
-      `    return { valid: false, errors: [{ message: 'must be ${primitive}', path: _path }] }`,
-      `  }`,
-      `  return true`,
-      `}`
-    ].join(`
-`);
-  }
-  if (hasEnum(schema)) {
-    const allowed = JSON.stringify(schema.enum);
-    const label = schema.enum.map((v) => JSON.stringify(v)).join(", ");
-    return [
-      `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
-      `  if (!(${allowed} as unknown[]).includes(input)) {`,
-      `    return { valid: false, errors: [{ message: \`must be one of: ${label}\`, path: _path }] }`,
-      `  }`,
-      `  return true`,
-      `}`
-    ].join(`
-`);
-  }
-  if (hasOneOf(schema)) {
-    const branches = schema.oneOf.map((branch, i) => {
-      if (!hasRef(branch))
-        return null;
-      const bName = validatorName(refToName(branch.$ref, suffix));
-      return `  const _r${i} = ${bName}(input, _path)
-  if (_r${i} === true) return true`;
-    }).filter(Boolean).join(`
-`);
-    return [
-      `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
-      branches,
-      `  return { valid: false, errors: [{ message: 'must match one of the expected schemas', path: _path }] }`,
-      `}`
-    ].join(`
-`);
-  }
-  if (hasType(schema)) {
-    const t = schema.type;
-    const wrongType = wrongTypeCondition("input", t);
-    const typLabel = typeofString(t);
-    const constraintLines = [];
-    if (t === "string") {
-      if (hasPattern(schema)) {
-        constraintLines.push(`  if (typeof input === 'string' && !/${schema.pattern}/.test(input)) {`);
-        constraintLines.push(`    errors.push({ message: 'must match pattern ${schema.pattern}', path: _path })`);
-        constraintLines.push(`  }`);
-      }
-      if (hasMinLength(schema)) {
-        constraintLines.push(`  if (typeof input === 'string' && input.length < ${schema.minLength}) {`);
-        constraintLines.push(`    errors.push({ message: 'must have at least ${schema.minLength} characters', path: _path })`);
-        constraintLines.push(`  }`);
-      }
-      if (hasMaxLength(schema)) {
-        constraintLines.push(`  if (typeof input === 'string' && input.length > ${schema.maxLength}) {`);
-        constraintLines.push(`    errors.push({ message: 'must have at most ${schema.maxLength} characters', path: _path })`);
-        constraintLines.push(`  }`);
-      }
-    }
-    if (!wrongType) {
-      return [
-        `export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`,
-        `  return true`,
-        `}`
-      ].join(`
-`);
-    }
-    if (constraintLines.length === 0) {
-      return [
-        `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
-        `  if (${wrongType}) {`,
-        `    return { valid: false, errors: [{ message: 'must be ${typLabel}', path: _path }] }`,
-        `  }`,
-        `  return true`,
-        `}`
-      ].join(`
-`);
-    }
-    return [
-      `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
-      `  if (${wrongType}) {`,
-      `    return { valid: false, errors: [{ message: 'must be ${typLabel}', path: _path }] }`,
-      `  }`,
-      `  const errors: ValidationError[] = []`,
-      constraintLines.join(`
-`),
-      `  return errors.length > 0 ? { valid: false, errors } : true`,
-      `}`
-    ].join(`
-`);
-  }
-  return [`export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`, `  return true`, `}`].join(`
-`);
-};
-var generateValidatorFunction = (schema, typeName, suffix = "") => {
-  if (isObjectSchema2(schema)) {
-    return generateObjectValidator(schema, typeName, suffix);
-  }
-  return generateScalarValidator(schema, typeName, suffix);
-};
-
-// src/generators/generate-files.ts
-var generateValidatorFile = (schema, typeName, options) => {
-  const typeSuffix = options?.typeSuffix ?? "";
-  const refImports = collectValidatorImports(schema, {
-    selfRef: options?.selfRef,
-    rootSchema: options?.rootSchema,
-    typeSuffix
-  });
-  const typeDefinition = generateTypeDefinition(schema, typeName, { typeSuffix });
-  const validatorFunction = generateValidatorFunction(schema, typeName, typeSuffix);
-  let result = `import type { ValidationResult, ValidationError } from './validation-result'
-`;
-  for (const imp of refImports) {
-    result += imp + `
-`;
-  }
-  if (refImports.length > 0) {
-    result += `
-`;
-  } else {
-    result += `
-`;
-  }
-  result += typeDefinition + `
-
-` + validatorFunction;
-  return result;
-};
-
-// src/generators/build-schema.ts
-var VALIDATION_RESULT_CONTENT = `/**
- * A single validation error with a human-readable message and a JSON Pointer
- * path indicating where in the document the error occurred.
- */
-export type ValidationError = {
-  message: string
-  path: string
-}
-
-/**
- * The result of a generated validator function.
- * Returns \`true\` when the input is valid, or an object with \`valid: false\`
- * and a list of errors when it is not.
- */
-export type ValidationResult = true | { valid: false; errors: ValidationError[] }
-`;
-var buildValidatorSchema = async (rootSchema, rootTypeName, typeSuffix = "") => {
-  rootSchema = upgradeDraft07Schema(rootSchema);
-  const files = [];
-  const processedRefs = new Set;
-  const processedFilenames = new Set;
-  const refsToProcess = [];
-  const dynamicRefMap = buildDynamicRefMap(rootSchema);
-  const processedRootSchema = resolveDynamicRefs(rootSchema, dynamicRefMap);
-  const rootContent = generateValidatorFile(processedRootSchema, rootTypeName, {
-    rootSchema,
-    typeSuffix
-  });
-  const rootFilename = rootTypeName.toLowerCase();
-  if (rootFilename !== "validation-result") {
-    processedFilenames.add(rootFilename);
-    files.push({ filename: `${rootFilename}.ts`, content: rootContent });
-  }
-  const rootRefs = extractRefs(rootSchema);
-  refsToProcess.push(...rootRefs);
-  while (refsToProcess.length > 0) {
-    const ref = refsToProcess.shift();
-    if (!ref || processedRefs.has(ref))
-      continue;
-    processedRefs.add(ref);
-    const resolvedSchema = resolveRef(ref, rootSchema);
-    if (!resolvedSchema) {
-      console.warn(`Warning: Could not resolve ref: ${ref}`);
-      continue;
-    }
-    const typeName = refToName(ref, typeSuffix);
-    const filename = refToFilename(ref);
-    const processedSchema = resolveDynamicRefs(resolvedSchema, dynamicRefMap);
-    const content = generateValidatorFile(processedSchema, typeName, {
-      selfRef: ref,
-      rootSchema,
-      typeSuffix
-    });
-    if (filename !== "validation-result" && !processedFilenames.has(filename)) {
-      processedFilenames.add(filename);
-      files.push({ filename: `${filename}.ts`, content });
-    }
-    for (const nestedRef of extractRefs(resolvedSchema)) {
-      if (!processedRefs.has(nestedRef))
-        refsToProcess.push(nestedRef);
-    }
-  }
-  files.push({ filename: "validation-result.ts", content: VALIDATION_RESULT_CONTENT });
-  const TYPE_EXPORT_RE = /^export type (\w+)/gm;
-  const CONST_EXPORT_RE = /^export const (\w+)/gm;
-  const sortedFiles = [...files].sort((a, b) => a.filename.localeCompare(b.filename));
-  let indexContent = "";
-  for (const file of sortedFiles) {
-    const moduleName = file.filename.replace(/\.ts$/, "");
-    const typeNames = [];
-    const constNames = [];
-    for (const match of file.content.matchAll(TYPE_EXPORT_RE))
-      typeNames.push(match[1]);
-    for (const match of file.content.matchAll(CONST_EXPORT_RE))
-      constNames.push(match[1]);
-    if (typeNames.length === 0 && constNames.length === 0)
-      continue;
-    const typeExports = typeNames.map((n) => `type ${n}`);
-    indexContent += `export { ${[...typeExports, ...constNames].join(", ")} } from './${moduleName}';
-`;
-  }
-  files.push({ filename: "index.ts", content: indexContent });
-  return files;
-};
-export {
-  buildValidatorSchema
-};
+export { buildValidatorSchema } from './generators/build-schema.js';