osury 1.0.1 → 1.2.0

package/dist/osury.mjs

@@ -0,0 +1,4041 @@
+#!/usr/bin/env node
+
+// node_modules/@rescript/runtime/lib/es6/Primitive_option.js
+function some(x) {
+  if (x === void 0) {
+    return {
+      BS_PRIVATE_NESTED_SOME_NONE: 0
+    };
+  } else if (x !== null && x.BS_PRIVATE_NESTED_SOME_NONE !== void 0) {
+    return {
+      BS_PRIVATE_NESTED_SOME_NONE: x.BS_PRIVATE_NESTED_SOME_NONE + 1 | 0
+    };
+  } else {
+    return x;
+  }
+}
+function valFromOption(x) {
+  if (x === null || x.BS_PRIVATE_NESTED_SOME_NONE === void 0) {
+    return x;
+  }
+  let depth = x.BS_PRIVATE_NESTED_SOME_NONE;
+  if (depth === 0) {
+    return;
+  } else {
+    return {
+      BS_PRIVATE_NESTED_SOME_NONE: depth - 1 | 0
+    };
+  }
+}
+
+// src/Errors.mjs
+function makeLocation(pathOpt, lineOpt, columnOpt, param) {
+  let path2 = pathOpt !== void 0 ? pathOpt : [];
+  let line = lineOpt !== void 0 ? valFromOption(lineOpt) : void 0;
+  let column = columnOpt !== void 0 ? valFromOption(columnOpt) : void 0;
+  return {
+    path: path2,
+    line,
+    column
+  };
+}
+function makeError(kind, pathOpt, hintOpt, param) {
+  let path2 = pathOpt !== void 0 ? pathOpt : [];
+  let hint = hintOpt !== void 0 ? valFromOption(hintOpt) : void 0;
+  return {
+    kind,
+    location: makeLocation(path2, void 0, void 0, void 0),
+    hint
+  };
+}
+function unknownType(value, pathOpt, hintOpt, param) {
+  let path2 = pathOpt !== void 0 ? pathOpt : [];
+  let hint = hintOpt !== void 0 ? valFromOption(hintOpt) : void 0;
+  return makeError({
+    TAG: "UnknownType",
+    _0: value
+  }, path2, some(hint), void 0);
+}
+function missingField(field, pathOpt, hintOpt, param) {
+  let path2 = pathOpt !== void 0 ? pathOpt : [];
+  let hint = hintOpt !== void 0 ? valFromOption(hintOpt) : void 0;
+  return makeError({
+    TAG: "MissingRequiredField",
+    _0: field
+  }, path2, some(hint), void 0);
+}
+
+// node_modules/@rescript/core/src/Core__Array.mjs
+function reduce(arr, init, f) {
+  return arr.reduce(f, init);
+}
+function filterMap(a, f) {
+  let l = a.length;
+  let r = new Array(l);
+  let j = 0;
+  for (let i = 0; i < l; ++i) {
+    let v = a[i];
+    let v$1 = f(v);
+    if (v$1 !== void 0) {
+      r[j] = valFromOption(v$1);
+      j = j + 1 | 0;
+    }
+  }
+  r.length = j;
+  return r;
+}
+function findMap(arr, f) {
+  let _i = 0;
+  while (true) {
+    let i = _i;
+    if (i === arr.length) {
+      return;
+    }
+    let r = f(arr[i]);
+    if (r !== void 0) {
+      return r;
+    }
+    _i = i + 1 | 0;
+    continue;
+  }
+  ;
+}
+
+// node_modules/@rescript/core/src/Core__Option.mjs
+function mapOr(opt, $$default, f) {
+  if (opt !== void 0) {
+    return f(valFromOption(opt));
+  } else {
+    return $$default;
+  }
+}
+function getOr(opt, $$default) {
+  if (opt !== void 0) {
+    return valFromOption(opt);
+  } else {
+    return $$default;
+  }
+}
+function isSome(x) {
+  return x !== void 0;
+}
+function isNone(x) {
+  return x === void 0;
+}
+
+// src/Schema.mjs
+function isNullType(json) {
+  if (typeof json !== "object" || json === null || Array.isArray(json)) {
+    return false;
+  }
+  let match = json["type"];
+  return match === "null";
+}
+function hasDefault(json) {
+  if (typeof json === "object" && json !== null && !Array.isArray(json)) {
+    return isSome(json["default"]);
+  } else {
+    return false;
+  }
+}
+function extractRefName(refPath) {
+  let parts = refPath.split("/");
+  return getOr(parts[parts.length - 1 | 0], refPath);
+}
+function parseEnumValues(arr) {
+  let values = filterMap(arr, (item) => {
+    if (typeof item === "string") {
+      return item;
+    }
+  });
+  if (values.length === arr.length) {
+    return values;
+  }
+}
+function extractTagFromProperty(dict, propertyName) {
+  let match = dict[propertyName];
+  if (match === void 0) {
+    return;
+  }
+  if (typeof match !== "object" || match === null || Array.isArray(match)) {
+    return;
+  }
+  let match$1 = match["const"];
+  if (typeof match$1 === "string") {
+    return match$1;
+  }
+}
+function extractDiscriminatorPropertyName(dict) {
+  let match = dict["discriminator"];
+  if (match === void 0) {
+    return;
+  }
+  if (typeof match !== "object" || match === null || Array.isArray(match)) {
+    return;
+  }
+  let match$1 = match["propertyName"];
+  if (typeof match$1 === "string") {
+    return match$1;
+  }
+}
+function parseSchema(json) {
+  if (typeof json === "object" && json !== null && !Array.isArray(json)) {
+    return parseObject(json);
+  }
+  return {
+    TAG: "Error",
+    _0: [makeError({
+      TAG: "InvalidJson",
+      _0: "expected object"
+    }, void 0, void 0, void 0)]
+  };
+}
+function parsePrimitiveType(dict) {
+  let match = dict["type"];
+  if (match !== void 0) {
+    if (Array.isArray(match)) {
+      let typeStrings = filterMap(match, (t) => {
+        if (typeof t === "string") {
+          return t;
+        }
+      });
+      let hasNull = typeStrings.includes("null");
+      let nonNullTypes = typeStrings.filter((t) => t !== "null");
+      if (!hasNull) {
+        return {
+          TAG: "Error",
+          _0: [makeError({
+            TAG: "UnsupportedFeature",
+            _0: "type array without null"
+          }, void 0, void 0, void 0)]
+        };
+      }
+      if (nonNullTypes.length !== 1) {
+        return {
+          TAG: "Error",
+          _0: [makeError({
+            TAG: "InvalidJson",
+            _0: "type array must have exactly one non-null type"
+          }, void 0, void 0, void 0)]
+        };
+      }
+      let nonNullType = nonNullTypes[0];
+      let newDict = Object.fromEntries(Object.entries(dict).map((param) => {
+        let k = param[0];
+        if (k === "type") {
+          return [
+            k,
+            nonNullType
+          ];
+        } else {
+          return [
+            k,
+            param[1]
+          ];
+        }
+      }));
+      let inner = parsePrimitiveType(newDict);
+      if (inner.TAG === "Ok") {
+        return {
+          TAG: "Ok",
+          _0: {
+            _tag: "Nullable",
+            _0: inner._0
+          }
+        };
+      } else {
+        return {
+          TAG: "Error",
+          _0: inner._0
+        };
+      }
+    }
+    switch (typeof match) {
+      case "string":
+        switch (match) {
+          case "array":
+            return parseArrayType(dict);
+          case "boolean":
+            return {
+              TAG: "Ok",
+              _0: "Boolean"
+            };
+          case "integer":
+            return {
+              TAG: "Ok",
+              _0: "Integer"
+            };
+          case "null":
+            return {
+              TAG: "Ok",
+              _0: "Null"
+            };
+          case "number":
+            return {
+              TAG: "Ok",
+              _0: "Number"
+            };
+          case "object":
+            return parseObjectType(dict);
+          case "string":
+            let match$1 = dict["const"];
+            let exit = 0;
+            if (match$1 !== void 0) {
+              if (typeof match$1 === "string") {
+                return {
+                  TAG: "Ok",
+                  _0: {
+                    _tag: "Enum",
+                    _0: [match$1]
+                  }
+                };
+              }
+              exit = 2;
+            } else {
+              exit = 2;
+            }
+            if (exit === 2) {
+              let match$2 = dict["enum"];
+              if (match$2 === void 0) {
+                return {
+                  TAG: "Ok",
+                  _0: "String"
+                };
+              }
+              let exit$1 = 0;
+              if (Array.isArray(match$2)) {
+                let values = parseEnumValues(match$2);
+                if (values !== void 0) {
+                  return {
+                    TAG: "Ok",
+                    _0: {
+                      _tag: "Enum",
+                      _0: values
+                    }
+                  };
+                } else {
+                  return {
+                    TAG: "Error",
+                    _0: [makeError({
+                      TAG: "InvalidJson",
+                      _0: "enum values must be strings"
+                    }, void 0, void 0, void 0)]
+                  };
+                }
+              }
+              exit$1 = 3;
+              if (exit$1 === 3) {
+                return {
+                  TAG: "Error",
+                  _0: [makeError({
+                    TAG: "InvalidJson",
+                    _0: "enum must be an array"
+                  }, void 0, void 0, void 0)]
+                };
+              }
+            }
+            break;
+          default:
+            return {
+              TAG: "Error",
+              _0: [unknownType(match, void 0, void 0, void 0)]
+            };
+        }
+        break;
+    }
+    return {
+      TAG: "Error",
+      _0: [makeError({
+        TAG: "InvalidJson",
+        _0: "type must be a string or array"
+      }, void 0, void 0, void 0)]
+    };
+  }
+  let match$3 = dict["properties"];
+  if (match$3 !== void 0) {
+    return parseObjectType(dict);
+  } else {
+    return {
+      TAG: "Ok",
+      _0: "Unknown"
+    };
+  }
+}
+function parseArrayType(dict) {
+  let itemSchema = dict["items"];
+  if (itemSchema === void 0) {
+    return {
+      TAG: "Error",
+      _0: [missingField("items", void 0, "array type requires items schema", void 0)]
+    };
+  }
+  let itemType = parseSchema(itemSchema);
+  if (itemType.TAG === "Ok") {
+    return {
+      TAG: "Ok",
+      _0: {
+        _tag: "Array",
+        _0: itemType._0
+      }
+    };
+  } else {
+    return {
+      TAG: "Error",
+      _0: itemType._0
+    };
+  }
+}
+function parseAnyOf(items) {
+  let hasNull = items.some(isNullType);
+  let nonNullItems = items.filter((item) => !isNullType(item));
+  if (hasNull && nonNullItems.length === 1) {
+    let match = nonNullItems[0];
+    if (match === void 0) {
+      return {
+        TAG: "Error",
+        _0: [makeError({
+          TAG: "InvalidJson",
+          _0: "anyOf with only null types"
+        }, void 0, void 0, void 0)]
+      };
+    }
+    if (typeof match === "object" && match !== null && !Array.isArray(match)) {
+      let innerType = parseObject(match);
+      if (innerType.TAG === "Ok") {
+        return {
+          TAG: "Ok",
+          _0: {
+            _tag: "Nullable",
+            _0: innerType._0
+          }
+        };
+      } else {
+        return {
+          TAG: "Error",
+          _0: innerType._0
+        };
+      }
+    }
+    return {
+      TAG: "Error",
+      _0: [makeError({
+        TAG: "InvalidJson",
+        _0: "anyOf item must be object"
+      }, void 0, void 0, void 0)]
+    };
+  }
+  if (!hasNull && nonNullItems.length >= 2) {
+    let results = nonNullItems.map(parseSchema);
+    let errors = filterMap(results, (r) => {
+      if (r.TAG === "Ok") {
+        return;
+      } else {
+        return r._0;
+      }
+    }).flat();
+    if (errors.length > 0) {
+      return {
+        TAG: "Error",
+        _0: errors
+      };
+    }
+    let types = filterMap(results, (r) => {
+      if (r.TAG === "Ok") {
+        return r._0;
+      }
+    });
+    return {
+      TAG: "Ok",
+      _0: {
+        _tag: "Union",
+        _0: types
+      }
+    };
+  }
+  if (!(hasNull && nonNullItems.length >= 2)) {
+    return {
+      TAG: "Error",
+      _0: [makeError({
+        TAG: "InvalidJson",
+        _0: "anyOf must have at least 2 items"
+      }, void 0, void 0, void 0)]
+    };
+  }
+  let results$1 = nonNullItems.map(parseSchema);
+  let errors$1 = filterMap(results$1, (r) => {
+    if (r.TAG === "Ok") {
+      return;
+    } else {
+      return r._0;
+    }
+  }).flat();
+  if (errors$1.length > 0) {
+    return {
+      TAG: "Error",
+      _0: errors$1
+    };
+  }
+  let types$1 = filterMap(results$1, (r) => {
+    if (r.TAG === "Ok") {
+      return r._0;
+    }
+  });
+  return {
+    TAG: "Ok",
+    _0: {
+      _tag: "Nullable",
+      _0: {
+        _tag: "Union",
+        _0: types$1
+      }
+    }
+  };
+}
+function parseObjectType(dict) {
+  let valueSchema = dict["additionalProperties"];
+  let exit = 0;
+  if (valueSchema !== void 0) {
+    switch (typeof valueSchema) {
+      case "boolean":
+        if (valueSchema) {
+          return {
+            TAG: "Ok",
+            _0: {
+              _tag: "Dict",
+              _0: "String"
+            }
+          };
+        }
+        exit = 1;
+        break;
+      case "object":
+        let valueType = parseSchema(valueSchema);
+        if (valueType.TAG === "Ok") {
+          return {
+            TAG: "Ok",
+            _0: {
+              _tag: "Dict",
+              _0: valueType._0
+            }
+          };
+        } else {
+          return {
+            TAG: "Error",
+            _0: valueType._0
+          };
+        }
+      default:
+        exit = 1;
+    }
+  } else {
+    exit = 1;
+  }
+  if (exit === 1) {
+    let match = dict["required"];
+    let requiredFields = match !== void 0 ? Array.isArray(match) ? filterMap(match, (item) => {
+      if (typeof item === "string") {
+        return item;
+      }
+    }) : [] : [];
+    let match$1 = dict["properties"];
+    if (match$1 === void 0) {
+      return {
+        TAG: "Ok",
+        _0: {
+          _tag: "Object",
+          _0: []
+        }
+      };
+    }
+    let exit$1 = 0;
+    if (typeof match$1 === "object" && match$1 !== null && !Array.isArray(match$1)) {
+      let entries = Object.entries(match$1).filter((param) => param[0] !== "_tag");
+      let results = entries.map((param) => {
+        let propSchema = param[1];
+        let name = param[0];
+        let propType = parseSchema(propSchema);
+        if (propType.TAG === "Ok") {
+          return {
+            TAG: "Ok",
+            _0: {
+              name,
+              type: propType._0,
+              required: requiredFields.includes(name) || hasDefault(propSchema)
+            }
+          };
+        } else {
+          return {
+            TAG: "Error",
+            _0: propType._0
+          };
+        }
+      });
+      let errors = filterMap(results, (r) => {
+        if (r.TAG === "Ok") {
+          return;
+        } else {
+          return r._0;
+        }
+      }).flat();
+      if (errors.length > 0) {
+        return {
+          TAG: "Error",
+          _0: errors
+        };
+      }
+      let fields = filterMap(results, (r) => {
+        if (r.TAG === "Ok") {
+          return r._0;
+        }
+      });
+      return {
+        TAG: "Ok",
+        _0: {
+          _tag: "Object",
+          _0: fields
+        }
+      };
+    }
+    exit$1 = 2;
+    if (exit$1 === 2) {
+      return {
+        TAG: "Error",
+        _0: [makeError({
+          TAG: "InvalidJson",
+          _0: "properties must be an object"
+        }, void 0, void 0, void 0)]
+      };
+    }
+  }
+}
+function parseAllOf(items) {
+  let results = items.map(parseSchema);
+  let errors = filterMap(results, (r) => {
+    if (r.TAG === "Ok") {
+      return;
+    } else {
+      return r._0;
+    }
+  }).flat();
+  if (errors.length > 0) {
+    return {
+      TAG: "Error",
+      _0: errors
+    };
+  }
+  let allFields = filterMap(results, (r) => {
+    if (r.TAG !== "Ok") {
+      return;
+    }
+    let fields = r._0;
+    if (typeof fields !== "object" || fields._tag !== "Object") {
+      return;
+    } else {
+      return fields._0;
+    }
+  }).flat();
+  return {
+    TAG: "Ok",
+    _0: {
+      _tag: "Object",
+      _0: allFields
+    }
+  };
+}
+function parseOneOf(items, discriminatorPropertyNameOpt) {
+  let discriminatorPropertyName = discriminatorPropertyNameOpt !== void 0 ? valFromOption(discriminatorPropertyNameOpt) : void 0;
+  let propName = getOr(discriminatorPropertyName, "_tag");
+  let caseResults = items.map((item) => {
+    if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+      let match = item["$ref"];
+      let exit = 0;
+      if (match !== void 0) {
+        if (typeof match === "string") {
+          let name = extractRefName(match);
+          return {
+            TAG: "Ok",
+            _0: {
+              _tag: name,
+              payload: {
+                _tag: "Ref",
+                _0: name
+              }
+            }
+          };
+        }
+        exit = 2;
+      } else {
+        exit = 2;
+      }
+      if (exit === 2) {
+        let match$1 = item["properties"];
+        let exit$1 = 0;
+        if (match$1 !== void 0) {
+          if (typeof match$1 === "object" && match$1 !== null && !Array.isArray(match$1)) {
+            let tag = extractTagFromProperty(match$1, propName);
+            if (tag === void 0) {
+              return {
+                TAG: "Error",
+                _0: [makeError({
+                  TAG: "MissingRequiredField",
+                  _0: propName + " with const"
+                }, void 0, void 0, void 0)]
+              };
+            }
+            let match$2 = item["required"];
+            let requiredFields = match$2 !== void 0 ? Array.isArray(match$2) ? filterMap(match$2, (i) => {
+              if (typeof i === "string") {
+                return i;
+              }
+            }) : [] : [];
+            let entries = Object.entries(match$1).filter((param) => param[0] !== propName);
+            let fieldResults = entries.map((param) => {
+              let name = param[0];
+              let propType = parseSchema(param[1]);
+              if (propType.TAG === "Ok") {
+                return {
+                  TAG: "Ok",
+                  _0: {
+                    name,
+                    type: propType._0,
+                    required: requiredFields.includes(name)
+                  }
+                };
+              } else {
+                return {
+                  TAG: "Error",
+                  _0: propType._0
+                };
+              }
+            });
+            let errors2 = filterMap(fieldResults, (r) => {
+              if (r.TAG === "Ok") {
+                return;
+              } else {
+                return r._0;
+              }
+            }).flat();
+            if (errors2.length > 0) {
+              return {
+                TAG: "Error",
+                _0: errors2
+              };
+            }
+            let fields = filterMap(fieldResults, (r) => {
+              if (r.TAG === "Ok") {
+                return r._0;
+              }
+            });
+            return {
+              TAG: "Ok",
+              _0: {
+                _tag: tag,
+                payload: {
+                  _tag: "Object",
+                  _0: fields
+                }
+              }
+            };
+          }
+          exit$1 = 3;
+        } else {
+          exit$1 = 3;
+        }
+        if (exit$1 === 3) {
+          return {
+            TAG: "Error",
+            _0: [makeError({
+              TAG: "InvalidJson",
+              _0: "oneOf item must have properties"
+            }, void 0, void 0, void 0)]
+          };
+        }
+      }
+    }
+    return {
+      TAG: "Error",
+      _0: [makeError({
+        TAG: "InvalidJson",
+        _0: "oneOf item must be object"
+      }, void 0, void 0, void 0)]
+    };
+  });
+  let errors = filterMap(caseResults, (r) => {
+    if (r.TAG === "Ok") {
+      return;
+    } else {
+      return r._0;
+    }
+  }).flat();
+  if (errors.length > 0) {
+    return {
+      TAG: "Error",
+      _0: errors
+    };
+  }
+  let cases = filterMap(caseResults, (r) => {
+    if (r.TAG === "Ok") {
+      return r._0;
+    }
+  });
+  return {
+    TAG: "Ok",
+    _0: {
+      _tag: "PolyVariant",
+      _0: cases
+    }
+  };
+}
+function applyNullable(dict, result) {
+  let match = dict["nullable"];
+  if (match === void 0) {
+    return result;
+  }
+  if (typeof match !== "boolean") {
+    return result;
+  }
+  if (!match) {
+    return result;
+  }
+  if (result.TAG !== "Ok") {
+    return result;
+  }
+  let t = result._0;
+  if (typeof t !== "object" || t._tag !== "Nullable") {
+    return {
+      TAG: "Ok",
+      _0: {
+        _tag: "Nullable",
+        _0: t
+      }
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: t
+    };
+  }
+}
+function parseObject(dict) {
+  let match = dict["$ref"];
+  if (match !== void 0) {
+    if (typeof match === "string") {
+      return applyNullable(dict, {
+        TAG: "Ok",
+        _0: {
+          _tag: "Ref",
+          _0: extractRefName(match)
+        }
+      });
+    }
+    return {
+      TAG: "Error",
+      _0: [makeError({
+        TAG: "InvalidJson",
+        _0: "$ref must be a string"
+      }, void 0, void 0, void 0)]
+    };
+  }
+  let match$1 = dict["oneOf"];
+  if (match$1 !== void 0) {
+    if (Array.isArray(match$1)) {
+      let hasNull = match$1.some(isNullType);
+      let nonNullItems = match$1.filter((item) => !isNullType(item));
+      if (hasNull && nonNullItems.length === 1) {
+        let match$2 = nonNullItems[0];
+        if (match$2 === void 0) {
+          return {
+            TAG: "Error",
+            _0: [makeError({
+              TAG: "InvalidJson",
+              _0: "oneOf with only null types"
+            }, void 0, void 0, void 0)]
+          };
+        }
+        let exit = 0;
+        if (typeof match$2 === "object" && match$2 !== null && !Array.isArray(match$2)) {
+          let innerType = parseObject(match$2);
+          if (innerType.TAG === "Ok") {
+            return {
+              TAG: "Ok",
+              _0: {
+                _tag: "Nullable",
+                _0: innerType._0
+              }
+            };
+          } else {
+            return {
+              TAG: "Error",
+              _0: innerType._0
+            };
+          }
+        }
+        exit = 2;
+        if (exit === 2) {
+          return {
+            TAG: "Error",
+            _0: [makeError({
+              TAG: "InvalidJson",
+              _0: "oneOf item must be object"
+            }, void 0, void 0, void 0)]
+          };
+        }
+      } else {
+        if (hasNull && nonNullItems.length >= 2) {
+          let discriminatorPropName = extractDiscriminatorPropertyName(dict);
+          let inner = parseOneOf(nonNullItems, some(discriminatorPropName));
+          if (inner.TAG === "Ok") {
+            return {
+              TAG: "Ok",
+              _0: {
+                _tag: "Nullable",
+                _0: inner._0
+              }
+            };
+          } else {
+            return {
+              TAG: "Error",
+              _0: inner._0
+            };
+          }
+        }
+        let discriminatorPropName$1 = extractDiscriminatorPropertyName(dict);
+        return parseOneOf(match$1, some(discriminatorPropName$1));
+      }
+    }
+    return {
+      TAG: "Error",
+      _0: [makeError({
+        TAG: "InvalidJson",
+        _0: "oneOf must be an array"
+      }, void 0, void 0, void 0)]
+    };
+  }
+  let match$3 = dict["allOf"];
+  if (match$3 !== void 0) {
+    if (Array.isArray(match$3)) {
+      return parseAllOf(match$3);
+    }
+    return {
+      TAG: "Error",
+      _0: [makeError({
+        TAG: "InvalidJson",
+        _0: "allOf must be an array"
+      }, void 0, void 0, void 0)]
+    };
+  }
+  let match$4 = dict["anyOf"];
+  if (match$4 === void 0) {
+    return applyNullable(dict, parsePrimitiveType(dict));
+  }
+  if (Array.isArray(match$4)) {
+    return parseAnyOf(match$4);
+  }
+  return {
+    TAG: "Error",
+    _0: [makeError({
+      TAG: "InvalidJson",
+      _0: "anyOf must be an array"
+    }, void 0, void 0, void 0)]
+  };
+}
+var parse = parseSchema;
+
+// src/OpenAPIParser.mjs
+function pathToName(path2) {
+  return path2.split("/").filter((s) => {
+    if (s !== "") {
+      return !s.startsWith("{");
+    } else {
+      return false;
+    }
+  }).map((segment) => segment.split("-").map((part) => {
+    let first = part.charAt(0).toUpperCase();
+    let rest = part.slice(1);
+    return first + rest;
+  }).join("")).join("");
+}
+function ucFirst(s) {
+  let first = s.charAt(0).toUpperCase();
+  let rest = s.slice(1);
+  return first + rest;
+}
+function parsePathResponses(pathsJson) {
+  if (typeof pathsJson !== "object" || pathsJson === null || Array.isArray(pathsJson)) {
+    return {
+      TAG: "Ok",
+      _0: []
+    };
+  }
+  let results = Object.entries(pathsJson).flatMap((param) => {
+    let methodsJson = param[1];
+    let path2 = param[0];
+    if (typeof methodsJson === "object" && methodsJson !== null && !Array.isArray(methodsJson)) {
+      return filterMap(Object.entries(methodsJson), (param2) => {
+        let opJson = param2[1];
+        let method = param2[0];
+        let httpMethods = [
+          "get",
+          "post",
+          "put",
+          "patch",
+          "delete"
+        ];
+        if (!httpMethods.includes(method)) {
+          return;
+        }
+        if (typeof opJson !== "object" || opJson === null || Array.isArray(opJson)) {
+          return;
+        }
+        let match = opJson["responses"];
+        if (match === void 0) {
+          return;
+        }
+        if (typeof match !== "object" || match === null || Array.isArray(match)) {
+          return;
+        }
+        let r = match["200"];
+        let responseJson = r !== void 0 ? r : match["201"];
+        if (responseJson === void 0) {
+          return;
+        }
+        if (typeof responseJson !== "object" || responseJson === null || Array.isArray(responseJson)) {
+          return;
+        }
+        let match$1 = responseJson["content"];
+        if (match$1 === void 0) {
+          return;
+        }
+        if (typeof match$1 !== "object" || match$1 === null || Array.isArray(match$1)) {
+          return;
+        }
+        let match$2 = match$1["application/json"];
+        if (match$2 === void 0) {
+          return;
+        }
+        if (typeof match$2 !== "object" || match$2 === null || Array.isArray(match$2)) {
+          return;
+        }
+        let schemaJson = match$2["schema"];
+        if (schemaJson === void 0) {
+          return;
+        }
+        let name = ucFirst(method) + pathToName(path2) + "Response";
+        let schemaType = parse(schemaJson);
+        if (schemaType.TAG === "Ok") {
+          return {
+            TAG: "Ok",
+            _0: {
+              name,
+              schema: schemaType._0,
+              discriminatorTag: void 0,
+              discriminatorPropertyName: void 0,
+              fieldDiscriminators: void 0
+            }
+          };
+        } else {
+          return {
+            TAG: "Error",
+            _0: schemaType._0
+          };
+        }
+      });
+    } else {
+      return [];
+    }
+  });
+  let errors = filterMap(results, (r) => {
+    if (r.TAG === "Ok") {
+      return;
+    } else {
+      return r._0;
+    }
+  }).flat();
+  if (errors.length > 0) {
+    return {
+      TAG: "Error",
+      _0: errors
+    };
+  }
+  let schemas = filterMap(results, (r) => {
+    if (r.TAG === "Ok") {
+      return r._0;
+    }
+  });
+  return {
+    TAG: "Ok",
+    _0: schemas
+  };
+}
+function extractDiscriminatorFromPair(items, discDict) {
+  let match = discDict["propertyName"];
+  if (match === void 0) {
+    return;
+  }
+  if (typeof match !== "string") {
+    return;
+  }
+  let memberNames = filterMap(items, (item) => {
+    if (typeof item !== "object" || item === null || Array.isArray(item)) {
+      return;
+    }
+    let match2 = item["$ref"];
+    if (match2 === void 0) {
+      return;
+    }
+    if (typeof match2 !== "string") {
+      return;
+    }
+    let parts = match2.split("/");
+    return parts[parts.length - 1 | 0];
+  });
+  if (memberNames.length < 2) {
+    return;
+  }
+  let lcNames = memberNames.map((n) => {
+    let first = n.charAt(0).toLowerCase();
+    let rest = n.slice(1);
+    return first + rest;
+  });
+  let firstName = getOr(lcNames[0], "unknown");
+  let restNames = lcNames.slice(1);
+  let unionName = firstName + restNames.map((n) => "Or" + ucFirst(n)).join("");
+  return [
+    unionName,
+    match
+  ];
+}
+function extractFieldDiscriminators(schemaJson) {
+  let result = {};
+  if (typeof schemaJson === "object" && schemaJson !== null && !Array.isArray(schemaJson)) {
+    let match = schemaJson["properties"];
+    if (typeof match === "object" && match !== null && !Array.isArray(match)) {
+      Object.entries(match).forEach((param) => {
+        let propJson = param[1];
+        if (typeof propJson !== "object" || propJson === null || Array.isArray(propJson)) {
+          return;
+        }
+        let match2 = propJson["anyOf"];
+        let directItems;
+        let exit = 0;
+        if (Array.isArray(match2)) {
+          directItems = match2;
+        } else {
+          exit = 1;
+        }
+        if (exit === 1) {
+          let match$1 = propJson["oneOf"];
+          directItems = Array.isArray(match$1) ? match$1 : void 0;
+        }
+        let match$2 = propJson["discriminator"];
+        let exit$1 = 0;
+        if (directItems !== void 0 && match$2 !== void 0) {
+          if (typeof match$2 === "object" && match$2 !== null && !Array.isArray(match$2)) {
+            let match$3 = extractDiscriminatorFromPair(directItems, match$2);
+            if (match$3 !== void 0) {
+              result[match$3[0]] = match$3[1];
+              return;
+            } else {
+              return;
+            }
+          }
+          exit$1 = 1;
+        } else {
+          exit$1 = 1;
+        }
+        if (exit$1 === 1) {
+          let match$4 = propJson["items"];
+          if (match$4 === void 0) {
+            return;
+          }
+          if (typeof match$4 !== "object" || match$4 === null || Array.isArray(match$4)) {
+            return;
+          }
+          let match$5 = match$4["anyOf"];
+          let nestedItems;
+          let exit$2 = 0;
+          if (Array.isArray(match$5)) {
+            nestedItems = match$5;
+          } else {
+            exit$2 = 2;
+          }
+          if (exit$2 === 2) {
+            let match$6 = match$4["oneOf"];
+            nestedItems = Array.isArray(match$6) ? match$6 : void 0;
+          }
+          let match$7 = match$4["discriminator"];
+          if (nestedItems === void 0) {
+            return;
+          }
+          if (match$7 === void 0) {
+            return;
+          }
+          if (typeof match$7 !== "object" || match$7 === null || Array.isArray(match$7)) {
+            return;
+          }
+          let match$8 = extractDiscriminatorFromPair(nestedItems, match$7);
+          if (match$8 !== void 0) {
+            result[match$8[0]] = match$8[1];
+            return;
+          } else {
+            return;
+          }
+        }
+      });
+    }
+  }
+  return result;
+}
+function extractDiscriminatorPropertyName2(schemaJson) {
+  if (typeof schemaJson !== "object" || schemaJson === null || Array.isArray(schemaJson)) {
+    return;
+  }
+  let match = schemaJson["discriminator"];
+  if (match === void 0) {
+    return;
+  }
+  if (typeof match !== "object" || match === null || Array.isArray(match)) {
+    return;
+  }
+  let match$1 = match["propertyName"];
+  if (typeof match$1 === "string") {
+    return match$1;
+  }
+}
+function extractDiscriminatorTag(schemaJson) {
+  if (typeof schemaJson !== "object" || schemaJson === null || Array.isArray(schemaJson)) {
+    return;
+  }
+  let match = schemaJson["properties"];
+  if (match === void 0) {
+    return;
+  }
+  if (typeof match !== "object" || match === null || Array.isArray(match)) {
+    return;
+  }
+  let match$1 = match["_tag"];
+  if (match$1 === void 0) {
+    return;
+  }
+  if (typeof match$1 !== "object" || match$1 === null || Array.isArray(match$1)) {
+    return;
+  }
+  let match$2 = match$1["const"];
+  if (typeof match$2 === "string") {
+    return match$2;
+  }
+}
+function parseComponentSchemas(componentsJson) {
+  if (typeof componentsJson === "object" && componentsJson !== null && !Array.isArray(componentsJson)) {
+    let match = componentsJson["schemas"];
+    if (match === void 0) {
+      return {
+        TAG: "Ok",
+        _0: []
+      };
+    }
+    let exit = 0;
+    if (typeof match === "object" && match !== null && !Array.isArray(match)) {
+      let entries = Object.entries(match);
+      let results = entries.map((param) => {
+        let schemaJson = param[1];
+        let discriminatorTag = extractDiscriminatorTag(schemaJson);
+        let discriminatorPropertyName = extractDiscriminatorPropertyName2(schemaJson);
+        let fieldDiscs = extractFieldDiscriminators(schemaJson);
+        let fieldDiscriminators = Object.entries(fieldDiscs).length > 0 ? fieldDiscs : void 0;
+        let schemaType = parse(schemaJson);
+        if (schemaType.TAG === "Ok") {
+          return {
+            TAG: "Ok",
+            _0: {
+              name: param[0],
+              schema: schemaType._0,
+              discriminatorTag,
+              discriminatorPropertyName,
+              fieldDiscriminators
+            }
+          };
+        } else {
+          return {
+            TAG: "Error",
+            _0: schemaType._0
+          };
+        }
+      });
+      let errors = filterMap(results, (r) => {
+        if (r.TAG === "Ok") {
+          return;
+        } else {
+          return r._0;
+        }
+      }).flat();
+      if (errors.length > 0) {
+        return {
+          TAG: "Error",
+          _0: errors
+        };
+      }
+      let schemas = filterMap(results, (r) => {
+        if (r.TAG === "Ok") {
+          return r._0;
+        }
+      });
+      return {
+        TAG: "Ok",
+        _0: schemas
+      };
+    }
+    exit = 2;
+    if (exit === 2) {
+      return {
+        TAG: "Error",
+        _0: [makeError({
+          TAG: "InvalidJson",
+          _0: "schemas must be an object"
+        }, void 0, void 0, void 0)]
+      };
+    }
+  }
+  return {
+    TAG: "Error",
+    _0: [makeError({
+      TAG: "InvalidJson",
+      _0: "components must be an object"
+    }, void 0, void 0, void 0)]
+  };
+}
+function buildParamsObjectJson(params) {
+  let properties = {};
+  let required = [];
+  params.forEach((param) => {
+    if (typeof param !== "object" || param === null || Array.isArray(param)) {
+      return;
+    }
+    let match = param["in"];
+    let location = typeof match === "string" ? match : void 0;
+    let isQueryOrPath;
+    if (location !== void 0) {
+      switch (location) {
+        case "path":
+        case "query":
+          isQueryOrPath = true;
+          break;
+        default:
+          isQueryOrPath = false;
+      }
+    } else {
+      isQueryOrPath = false;
+    }
+    if (!isQueryOrPath) {
+      return;
+    }
+    let match$1 = param["name"];
+    let match$2 = param["schema"];
+    if (match$1 === void 0) {
+      return;
+    }
+    if (typeof match$1 !== "string") {
+      return;
+    }
+    if (match$2 === void 0) {
+      return;
+    }
+    let cleanSchema;
+    cleanSchema = typeof match$2 === "object" && match$2 !== null && !Array.isArray(match$2) ? Object.fromEntries(Object.entries(match$2).filter((param2) => param2[0] !== "default")) : match$2;
+    properties[match$1] = cleanSchema;
+    let match$3 = param["required"];
+    let isRequired = match$3 === true;
+    let pathRequired = location === "path";
+    if (isRequired || pathRequired) {
+      required.push(match$1);
+      return;
+    }
+  });
+  if (Object.entries(properties).length === 0) {
+    return;
+  }
+  let obj = {};
+  obj["type"] = "object";
+  obj["properties"] = properties;
+  obj["required"] = required;
+  return obj;
+}
+function parsePathParameters(pathsJson) {
+  if (typeof pathsJson !== "object" || pathsJson === null || Array.isArray(pathsJson)) {
+    return {
+      TAG: "Ok",
+      _0: []
+    };
+  }
+  let results = Object.entries(pathsJson).flatMap((param) => {
+    let methodsJson = param[1];
+    let path2 = param[0];
+    if (typeof methodsJson === "object" && methodsJson !== null && !Array.isArray(methodsJson)) {
+      return filterMap(Object.entries(methodsJson), (param2) => {
+        let opJson = param2[1];
+        let method = param2[0];
+        let httpMethods = [
+          "get",
+          "post",
+          "put",
+          "patch",
+          "delete"
+        ];
+        if (!httpMethods.includes(method)) {
+          return;
+        }
+        if (typeof opJson !== "object" || opJson === null || Array.isArray(opJson)) {
+          return;
+        }
+        let match = opJson["parameters"];
+        if (match === void 0) {
+          return;
+        }
+        if (!Array.isArray(match)) {
+          return;
+        }
+        let objJson = buildParamsObjectJson(match);
+        if (objJson === void 0) {
+          return;
+        }
+        let name = ucFirst(method) + pathToName(path2) + "Params";
+        let schemaType = parse(objJson);
+        if (schemaType.TAG === "Ok") {
+          return {
+            TAG: "Ok",
+            _0: {
+              name,
+              schema: schemaType._0,
+              discriminatorTag: void 0,
+              discriminatorPropertyName: void 0,
+              fieldDiscriminators: void 0
+            }
+          };
+        } else {
+          return {
+            TAG: "Error",
+            _0: schemaType._0
+          };
+        }
+      });
+    } else {
+      return [];
+    }
+  });
+  let errors = filterMap(results, (r) => {
+    if (r.TAG === "Ok") {
+      return;
+    } else {
+      return r._0;
+    }
+  }).flat();
+  if (errors.length > 0) {
+    return {
+      TAG: "Error",
+      _0: errors
+    };
+  }
+  let schemas = filterMap(results, (r) => {
+    if (r.TAG === "Ok") {
+      return r._0;
+    }
+  });
+  return {
+    TAG: "Ok",
+    _0: schemas
+  };
+}
+function extractAllDiscriminatorMappings(json) {
+  let result = {};
+  let walk = (j) => {
+    if (Array.isArray(j)) {
+      j.forEach(walk);
+      return;
+    }
+    switch (typeof j) {
+      case "object":
+        let match = j["oneOf"];
+        let match$1 = j["discriminator"];
+        if (Array.isArray(match) && typeof match$1 === "object" && match$1 !== null && !Array.isArray(match$1)) {
+          let match$2 = match$1["mapping"];
+          if (typeof match$2 === "object" && match$2 !== null && !Array.isArray(match$2)) {
+            Object.entries(match$2).forEach((param) => {
+              let refValue = param[1];
+              if (typeof refValue !== "string") {
+                return;
+              }
+              let parts = refValue.split("/");
+              let schemaName = parts[parts.length - 1 | 0];
+              if (schemaName !== void 0) {
+                result[schemaName] = param[0];
+                return;
+              }
+            });
+          }
+        }
+        Object.entries(j).forEach((param) => walk(param[1]));
+        return;
+      default:
+        return;
+    }
+  };
+  walk(json);
+  return result;
+}
+function rewriteVariantTagsInType(schema, tagByRef) {
+  if (typeof schema !== "object") {
+    return schema;
+  }
+  switch (schema._tag) {
+    case "Optional":
+      return {
+        _tag: "Optional",
+        _0: rewriteVariantTagsInType(schema._0, tagByRef)
+      };
+    case "Nullable":
+      return {
+        _tag: "Nullable",
+        _0: rewriteVariantTagsInType(schema._0, tagByRef)
+      };
+    case "Object":
+      return {
+        _tag: "Object",
+        _0: schema._0.map((f) => ({
+          name: f.name,
+          type: rewriteVariantTagsInType(f.type, tagByRef),
+          required: f.required
+        }))
+      };
+    case "Array":
+      return {
+        _tag: "Array",
+        _0: rewriteVariantTagsInType(schema._0, tagByRef)
+      };
+    case "PolyVariant":
+      let newCases = schema._0.map((c2) => {
+        let refName = c2.payload;
+        if (typeof refName !== "object") {
+          return {
+            _tag: c2._tag,
+            payload: rewriteVariantTagsInType(refName, tagByRef)
+          };
+        }
+        if (refName._tag !== "Ref") {
+          return {
+            _tag: c2._tag,
+            payload: rewriteVariantTagsInType(refName, tagByRef)
+          };
+        }
+        let actualTag = tagByRef[refName._0];
+        if (actualTag !== void 0 && actualTag !== c2._tag) {
+          return {
+            _tag: actualTag,
+            payload: c2.payload
+          };
+        } else {
+          return c2;
+        }
+      });
+      return {
+        _tag: "PolyVariant",
+        _0: newCases
+      };
+    case "Dict":
+      return {
+        _tag: "Dict",
+        _0: rewriteVariantTagsInType(schema._0, tagByRef)
+      };
+    case "Union":
+      return {
+        _tag: "Union",
+        _0: schema._0.map((t) => rewriteVariantTagsInType(t, tagByRef))
+      };
+    default:
+      return schema;
+  }
+}
+function resolveRefTagsInPolyVariants(schemas, mappingByRef) {
+  let tagByRef = {};
+  schemas.forEach((s) => {
+    let tag = s.discriminatorTag;
+    if (tag !== void 0) {
+      tagByRef[s.name] = tag;
+      return;
+    }
+  });
+  Object.entries(mappingByRef).forEach((param) => {
+    tagByRef[param[0]] = param[1];
+  });
+  return schemas.map((s) => ({
+    name: s.name,
+    schema: rewriteVariantTagsInType(s.schema, tagByRef),
+    discriminatorTag: s.discriminatorTag,
+    discriminatorPropertyName: s.discriminatorPropertyName,
+    fieldDiscriminators: s.fieldDiscriminators
+  }));
+}
+function parseDocument(json) {
+  if (typeof json === "object" && json !== null && !Array.isArray(json)) {
+    let componentsJson = json["components"];
+    let componentSchemas = componentsJson !== void 0 ? parseComponentSchemas(componentsJson) : {
+      TAG: "Ok",
+      _0: []
+    };
+    let pathsJson = json["paths"];
+    let pathSchemas = pathsJson !== void 0 ? parsePathResponses(pathsJson) : {
+      TAG: "Ok",
+      _0: []
+    };
+    let pathsJson$1 = json["paths"];
+    let paramSchemas = pathsJson$1 !== void 0 ? parsePathParameters(pathsJson$1) : {
+      TAG: "Ok",
+      _0: []
+    };
+    let mappingByRef = extractAllDiscriminatorMappings(json);
+    let exit = 0;
+    if (componentSchemas.TAG === "Ok" && pathSchemas.TAG === "Ok") {
+      if (paramSchemas.TAG === "Ok") {
+        return {
+          TAG: "Ok",
+          _0: resolveRefTagsInPolyVariants(componentSchemas._0.concat(pathSchemas._0).concat(paramSchemas._0), mappingByRef)
+        };
+      }
+      exit = 2;
+    } else {
+      exit = 2;
+    }
+    if (exit === 2) {
+      let errs = filterMap([
+        componentSchemas,
+        pathSchemas,
+        paramSchemas
+      ], (r) => {
+        if (r.TAG === "Ok") {
+          return;
+        } else {
+          return r._0;
+        }
+      }).flat();
+      return {
+        TAG: "Error",
+        _0: errs
+      };
+    }
+  }
+  return {
+    TAG: "Error",
+    _0: [makeError({
+      TAG: "InvalidJson",
+      _0: "document must be an object"
+    }, void 0, void 0, void 0)]
+  };
+}
+
+// src/CodegenHelpers.mjs
+var reservedKeywords = [
+  "type",
+  "let",
+  "rec",
+  "and",
+  "as",
+  "open",
+  "include",
+  "module",
+  "sig",
+  "struct",
+  "exception",
+  "external",
+  "if",
+  "else",
+  "switch",
+  "while",
+  "for",
+  "try",
+  "catch",
+  "when",
+  "true",
+  "false",
+  "assert",
+  "lazy",
+  "constraint",
+  "functor",
+  "class",
+  "method",
+  "object",
+  "private",
+  "public",
+  "virtual",
+  "mutable",
+  "new",
+  "inherit",
+  "initializer",
+  "val",
+  "with",
+  "match",
+  "of",
+  "fun",
+  "function",
+  "in",
+  "do",
+  "done",
+  "begin",
+  "end",
+  "then",
+  "to",
+  "downto",
+  "or",
+  "land",
+  "lor",
+  "lxor",
+  "lsl",
+  "lsr",
+  "asr",
+  "mod",
+  "await",
+  "async"
+];
+function isReservedKeyword(name) {
+  return reservedKeywords.includes(name);
+}
+function lcFirst(s) {
+  if (s.length === 0) {
+    return s;
+  }
+  let first = s.charAt(0).toLowerCase();
+  let rest = s.slice(1);
+  return first + rest;
+}
+function ucFirst2(s) {
+  if (s.length === 0) {
+    return s;
+  }
+  let first = s.charAt(0).toUpperCase();
+  let rest = s.slice(1);
+  return first + rest;
+}
+function isOptionalType(schema) {
+  if (typeof schema !== "object") {
+    return false;
+  }
+  switch (schema._tag) {
+    case "Optional":
+    case "Nullable":
+      return true;
+    default:
+      return false;
+  }
+}
+function isNullableType(schema) {
+  if (typeof schema !== "object") {
+    return false;
+  } else {
+    return schema._tag === "Nullable";
+  }
+}
+function getTagForType(t) {
+  if (typeof t !== "object") {
+    switch (t) {
+      case "String":
+        return "String";
+      case "Number":
+        return "Float";
+      case "Integer":
+        return "Int";
+      case "Boolean":
+        return "Bool";
+      case "Null":
+        return "Null";
+      case "Unknown":
+        return "Unknown";
+    }
+  } else {
+    switch (t._tag) {
+      case "Optional":
+        return `Option` + getTagForType(t._0);
+      case "Nullable":
+        return `Null` + getTagForType(t._0);
+      case "Object":
+        return "Object";
+      case "Array":
+        return `Array` + getTagForType(t._0);
+      case "Ref":
+        return ucFirst2(t._0);
+      case "Enum":
+        return "Enum";
+      case "PolyVariant":
+        return "Variant";
+      case "Dict":
+        return "Dict";
+      case "Union":
+        return "Union";
+    }
+  }
+}
+function hasUnion(_schema) {
+  while (true) {
+    let schema = _schema;
+    if (typeof schema !== "object") {
+      return false;
+    }
+    switch (schema._tag) {
+      case "Object":
+        return schema._0.some((f) => hasUnion(f.type));
+      case "PolyVariant":
+        return schema._0.some((c2) => hasUnion(c2.payload));
+      case "Optional":
+      case "Nullable":
+      case "Array":
+      case "Dict":
+        _schema = schema._0;
+        continue;
+      case "Union":
+        return true;
+      default:
+        return false;
+    }
+  }
+  ;
+}
+function isPrimitiveOnlyUnion(types) {
+  let allPrimitive = types.every((t) => {
+    if (typeof t === "object") {
+      return false;
+    }
+    switch (t) {
+      case "String":
+      case "Number":
+      case "Integer":
+      case "Boolean":
+        return true;
+      default:
+        return false;
+    }
+  });
+  if (!allPrimitive) {
+    return false;
+  }
+  let hasFloat = types.some((t) => t === "Number");
+  let hasInt = types.some((t) => t === "Integer");
+  return !(hasFloat && hasInt);
+}
+
+// node_modules/@rescript/runtime/lib/es6/Primitive_bool.js
+function compare(x, y) {
+  if (x) {
+    if (y) {
+      return 0;
+    } else {
+      return 1;
+    }
+  } else if (y) {
+    return -1;
+  } else {
+    return 0;
+  }
+}
+
+// node_modules/@rescript/runtime/lib/es6/Primitive_float.js
+function compare2(x, y) {
+  if (x === y) {
+    return 0;
+  } else if (x < y) {
+    return -1;
+  } else if (x > y || x === x) {
+    return 1;
+  } else if (y === y) {
+    return -1;
+  } else {
+    return 0;
+  }
+}
+
+// node_modules/@rescript/runtime/lib/es6/Primitive_string.js
+function compare3(s1, s2) {
+  if (s1 === s2) {
+    return 0;
+  } else if (s1 < s2) {
+    return -1;
+  } else {
+    return 1;
+  }
+}
+
+// node_modules/@rescript/runtime/lib/es6/Primitive_object.js
+var for_in = (function(o, foo) {
+  for (var x in o) {
+    foo(x);
+  }
+});
+function compare4(a, b) {
+  if (a === b) {
+    return 0;
+  }
+  let a_type = typeof a;
+  let b_type = typeof b;
+  switch (a_type) {
+    case "bigint":
+      if (b_type === "bigint") {
+        return compare2(a, b);
+      }
+      break;
+    case "boolean":
+      if (b_type === "boolean") {
+        return compare(a, b);
+      }
+      break;
+    case "function":
+      if (b_type === "function") {
+        throw {
+          RE_EXN_ID: "Invalid_argument",
+          _1: "compare: functional value",
+          Error: new Error()
+        };
+      }
+      break;
+    case "number":
+      if (b_type === "number") {
+        return compare2(a, b);
+      }
+      break;
+    case "string":
+      if (b_type === "string") {
+        return compare3(a, b);
+      } else {
+        return 1;
+      }
+    case "undefined":
+      return -1;
+  }
+  switch (b_type) {
+    case "string":
+      return -1;
+    case "undefined":
+      return 1;
+    default:
+      if (a_type === "boolean") {
+        return 1;
+      }
+      if (b_type === "boolean") {
+        return -1;
+      }
+      if (a_type === "function") {
+        return 1;
+      }
+      if (b_type === "function") {
+        return -1;
+      }
+      if (a_type === "number") {
+        if (b === null || b.BS_PRIVATE_NESTED_SOME_NONE !== void 0) {
+          return 1;
+        } else {
+          return -1;
+        }
+      }
+      if (b_type === "number") {
+        if (a === null || a.BS_PRIVATE_NESTED_SOME_NONE !== void 0) {
+          return -1;
+        } else {
+          return 1;
+        }
+      }
+      if (a === null) {
+        if (b.BS_PRIVATE_NESTED_SOME_NONE !== void 0) {
+          return 1;
+        } else {
+          return -1;
+        }
+      }
+      if (b === null) {
+        if (a.BS_PRIVATE_NESTED_SOME_NONE !== void 0) {
+          return -1;
+        } else {
+          return 1;
+        }
+      }
+      if (a.BS_PRIVATE_NESTED_SOME_NONE !== void 0) {
+        if (b.BS_PRIVATE_NESTED_SOME_NONE !== void 0) {
+          return aux_obj_compare(a, b);
+        } else {
+          return -1;
+        }
+      }
+      let tag_a = a.TAG;
+      let tag_b = b.TAG;
+      if (tag_a !== tag_b) {
+        if (tag_a < tag_b) {
+          return -1;
+        } else {
+          return 1;
+        }
+      }
+      let len_a = a.length | 0;
+      let len_b = b.length | 0;
+      if (len_a === len_b) {
+        if (Array.isArray(a)) {
+          let _i = 0;
+          while (true) {
+            let i = _i;
+            if (i === len_a) {
+              return 0;
+            }
+            let res = compare4(a[i], b[i]);
+            if (res !== 0) {
+              return res;
+            }
+            _i = i + 1 | 0;
+            continue;
+          }
+          ;
+        } else if (a instanceof Date && b instanceof Date) {
+          return a - b;
+        } else {
+          return aux_obj_compare(a, b);
+        }
+      } else if (len_a < len_b) {
+        let _i$1 = 0;
+        while (true) {
+          let i$1 = _i$1;
+          if (i$1 === len_a) {
+            return -1;
+          }
+          let res$1 = compare4(a[i$1], b[i$1]);
+          if (res$1 !== 0) {
+            return res$1;
+          }
+          _i$1 = i$1 + 1 | 0;
+          continue;
+        }
+        ;
+      } else {
+        let _i$2 = 0;
+        while (true) {
+          let i$2 = _i$2;
+          if (i$2 === len_b) {
+            return 1;
+          }
+          let res$2 = compare4(a[i$2], b[i$2]);
+          if (res$2 !== 0) {
+            return res$2;
+          }
+          _i$2 = i$2 + 1 | 0;
+          continue;
+        }
+        ;
+      }
+  }
+}
+function aux_obj_compare(a, b) {
+  let min_key_lhs = {
+    contents: void 0
+  };
+  let min_key_rhs = {
+    contents: void 0
+  };
+  let do_key = (param, key) => {
+    let min_key = param[2];
+    let b2 = param[1];
+    if (!(!Object.prototype.hasOwnProperty.call(b2, key) || compare4(param[0][key], b2[key]) > 0)) {
+      return;
+    }
+    let mk = min_key.contents;
+    if (mk !== void 0 && key >= mk) {
+      return;
+    } else {
+      min_key.contents = key;
+      return;
+    }
+  };
+  let do_key_a = (key) => do_key([
+    a,
+    b,
+    min_key_rhs
+  ], key);
+  let do_key_b = (key) => do_key([
+    b,
+    a,
+    min_key_lhs
+  ], key);
+  for_in(a, do_key_a);
+  for_in(b, do_key_b);
+  let match = min_key_lhs.contents;
+  let match$1 = min_key_rhs.contents;
+  if (match !== void 0) {
+    if (match$1 !== void 0) {
+      return compare3(match, match$1);
+    } else {
+      return -1;
+    }
+  } else if (match$1 !== void 0) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+function greaterthan(a, b) {
+  if ((typeof a === "number" || typeof a === "bigint") && (typeof b === "number" || typeof b === "bigint")) {
+    return a > b;
+  } else {
+    return compare4(a, b) > 0;
+  }
+}
+function lessthan(a, b) {
+  if ((typeof a === "number" || typeof a === "bigint") && (typeof b === "number" || typeof b === "bigint")) {
+    return a < b;
+  } else {
+    return compare4(a, b) < 0;
+  }
+}
+
+// src/CodegenTransforms.mjs
+function collectEnumsFromType(parentType, fieldPath, _schema) {
+  while (true) {
+    let schema = _schema;
+    if (typeof schema !== "object") {
+      return [];
+    }
+    switch (schema._tag) {
+      case "Object":
+        return schema._0.flatMap((f) => collectEnumsFromType(parentType, fieldPath.concat([f.name]), f.type));
+      case "Enum":
+        if (fieldPath.length > 0) {
+          return [{
+            parentType,
+            fieldPath,
+            values: schema._0
+          }];
+        } else {
+          return [];
+        }
+      case "PolyVariant":
+        return schema._0.flatMap((c2) => collectEnumsFromType(parentType, fieldPath, c2.payload));
+      case "Optional":
+      case "Nullable":
+      case "Array":
+      case "Dict":
+        break;
+      case "Union":
+        return schema._0.flatMap((t) => collectEnumsFromType(parentType, fieldPath, t));
+      default:
+        return [];
+    }
+    _schema = schema._0;
+    continue;
+  }
+  ;
+}
+function collectInlineEnums(schemas) {
+  return schemas.flatMap((s) => {
+    let match = s.schema;
+    if (typeof match !== "object") {
+      return collectEnumsFromType(s.name, [], s.schema);
+    } else if (match._tag === "Enum") {
+      return [];
+    } else {
+      return collectEnumsFromType(s.name, [], s.schema);
+    }
+  });
+}
+function camelize(s) {
+  let parts = s.replace(/-/g, "_").split("_").filter((p) => p !== "");
+  let first = parts[0];
+  if (first === void 0) {
+    return s;
+  }
+  let rest = parts.slice(1);
+  return lcFirst(first) + rest.map(ucFirst2).join("");
+}
+function occurrenceKey(occ) {
+  return occ.parentType + "::" + occ.fieldPath.join("/");
+}
+function valuesCanonicalKey(values) {
+  let cmp = (a, b) => {
+    if (lessthan(a, b)) {
+      return -1;
+    } else if (greaterthan(a, b)) {
+      return 1;
+    } else {
+      return 0;
+    }
+  };
+  return values.toSorted(cmp).join("");
+}
+function leafFieldName(occ) {
+  let s = occ.fieldPath[occ.fieldPath.length - 1 | 0];
+  if (s !== void 0) {
+    return s;
+  } else {
+    return "unknown";
+  }
+}
+function replaceEnumsInType(parentType, fieldPath, names, schema) {
+  if (typeof schema !== "object") {
+    return schema;
+  }
+  switch (schema._tag) {
+    case "Optional":
+      return {
+        _tag: "Optional",
+        _0: replaceEnumsInType(parentType, fieldPath, names, schema._0)
+      };
+    case "Nullable":
+      return {
+        _tag: "Nullable",
+        _0: replaceEnumsInType(parentType, fieldPath, names, schema._0)
+      };
+    case "Object":
+      return {
+        _tag: "Object",
+        _0: schema._0.map((f) => {
+          let newType = replaceEnumsInType(parentType, fieldPath.concat([f.name]), names, f.type);
+          return {
+            name: f.name,
+            type: newType,
+            required: f.required
+          };
+        })
+      };
+    case "Array":
+      return {
+        _tag: "Array",
+        _0: replaceEnumsInType(parentType, fieldPath, names, schema._0)
+      };
+    case "Enum":
+      if (fieldPath.length <= 0) {
+        return schema;
+      }
+      let key = parentType + "::" + fieldPath.join("/");
+      let name = names[key];
+      if (name !== void 0) {
+        return {
+          _tag: "Ref",
+          _0: ucFirst2(name)
+        };
+      } else {
+        return schema;
+      }
+    case "PolyVariant":
+      return {
+        _tag: "PolyVariant",
+        _0: schema._0.map((c2) => {
+          let payload = replaceEnumsInType(parentType, fieldPath, names, c2.payload);
+          return {
+            _tag: c2._tag,
+            payload
+          };
+        })
+      };
+    case "Dict":
+      return {
+        _tag: "Dict",
+        _0: replaceEnumsInType(parentType, fieldPath, names, schema._0)
+      };
+    case "Union":
+      return {
+        _tag: "Union",
+        _0: schema._0.map((t) => replaceEnumsInType(parentType, fieldPath, names, t))
+      };
+    default:
+      return schema;
+  }
+}
+function replaceInlineEnums(schemas, names) {
+  return schemas.map((s) => {
+    let match = s.schema;
+    let newSchema;
+    let exit = 0;
+    if (typeof match !== "object" || match._tag !== "Enum") {
+      exit = 1;
+    } else {
+      newSchema = s.schema;
+    }
+    if (exit === 1) {
+      newSchema = replaceEnumsInType(s.name, [], names, s.schema);
+    }
+    return {
+      name: s.name,
+      schema: newSchema,
+      discriminatorTag: s.discriminatorTag,
+      discriminatorPropertyName: s.discriminatorPropertyName,
+      fieldDiscriminators: s.fieldDiscriminators
+    };
+  });
+}
+function buildExtractedEnumSchemas(occurrences, names) {
+  let seen = {};
+  let result = [];
+  occurrences.forEach((occ) => {
+    let key = occurrenceKey(occ);
+    let name = names[key];
+    if (name === void 0) {
+      return;
+    }
+    let typeName = ucFirst2(name);
+    if (isNone(seen[typeName])) {
+      seen[typeName] = true;
+      result.push({
+        name: typeName,
+        schema: {
+          _tag: "Enum",
+          _0: occ.values
+        },
+        discriminatorTag: void 0,
+        discriminatorPropertyName: void 0,
+        fieldDiscriminators: void 0
+      });
+      return;
+    }
+  });
+  return result;
+}
+function resolveEnumNames(occurrences, topLevelNames) {
+  let topLevelSet = {};
+  topLevelNames.forEach((n) => {
+    topLevelSet[lcFirst(n)] = true;
+  });
+  let buckets = {};
+  occurrences.forEach((occ) => {
+    let leaf = leafFieldName(occ);
+    let vKey = valuesCanonicalKey(occ.values);
+    let set = buckets[leaf];
+    if (set !== void 0) {
+      set[vKey] = true;
+      return;
+    }
+    let set$1 = {};
+    set$1[vKey] = true;
+    buckets[leaf] = set$1;
+  });
+  let result = {};
+  occurrences.forEach((occ) => {
+    let leaf = leafFieldName(occ);
+    let camelized = camelize(leaf);
+    let distinctSets = mapOr(buckets[leaf], 1, (set) => Object.keys(set).length);
+    let collidesTopLevel = isSome(topLevelSet[camelized]);
+    let baseName = distinctSets > 1 || collidesTopLevel ? lcFirst(occ.parentType) + ucFirst2(camelized) : camelized;
+    let name = isReservedKeyword(baseName) ? baseName + "_" : baseName;
+    result[occurrenceKey(occ)] = name;
+  });
+  return result;
+}
+function isRefPlusDictUnion(types) {
+  if (types.length !== 2) {
+    return;
+  }
+  let hasDict = types.some((t) => {
+    if (typeof t !== "object") {
+      return false;
+    }
+    if (t._tag !== "Dict") {
+      return false;
+    }
+    let tmp = t._0;
+    if (typeof tmp !== "object") {
+      return tmp === "String";
+    } else {
+      return false;
+    }
+  });
+  let refName = findMap(types, (t) => {
+    if (typeof t !== "object" || t._tag !== "Ref") {
+      return;
+    } else {
+      return t._0;
+    }
+  });
+  if (hasDict) {
+    return refName;
+  }
+}
+function isPrimitivePlusDictUnion(types) {
+  if (types.length !== 2) {
+    return;
+  }
+  let hasDict = types.some((t) => {
+    if (typeof t !== "object") {
+      return false;
+    }
+    if (t._tag !== "Dict") {
+      return false;
+    }
+    let tmp = t._0;
+    if (typeof tmp !== "object") {
+      return tmp === "String";
+    } else {
+      return false;
+    }
+  });
+  let primitiveName = findMap(types, (t) => {
+    if (typeof t === "object") {
+      return;
+    }
+    switch (t) {
+      case "String":
+        return "string";
+      case "Number":
+        return "float";
+      case "Integer":
+        return "int";
+      case "Boolean":
+        return "bool";
+      default:
+        return;
+    }
+  });
+  if (hasDict) {
+    return primitiveName;
+  }
+}
+function getUnionName(types) {
+  let names = types.map((t) => {
+    if (typeof t !== "object") {
+      switch (t) {
+        case "String":
+          return "string";
+        case "Number":
+          return "float";
+        case "Integer":
+          return "int";
+        case "Boolean":
+          return "bool";
+        case "Null":
+          return "null";
+        default:
+          return "unknown";
+      }
+    } else {
+      switch (t._tag) {
+        case "Array":
+          return "array";
+        case "Ref":
+          return lcFirst(t._0);
+        case "Dict":
+          return "dict";
+        default:
+          return "unknown";
+      }
+    }
+  });
+  if (names.length === 0) {
+    return "emptyUnion";
+  }
+  let first = getOr(names[0], "unknown");
+  let rest = names.slice(1);
+  return first + rest.map((n) => "Or" + ucFirst2(n)).join("");
+}
+function getPolyVariantName(cases) {
+  return getUnionName(cases.map((c2) => c2.payload));
+}
+function extractUnionsFromType(_schema) {
+  while (true) {
+    let schema = _schema;
+    if (typeof schema !== "object") {
+      return [];
+    }
+    switch (schema._tag) {
+      case "Object":
+        return schema._0.flatMap((field) => extractUnionsFromType(field.type));
+      case "PolyVariant":
+        let name = getPolyVariantName(schema._0);
+        return [{
+          name,
+          schema
+        }];
+      case "Optional":
+      case "Nullable":
+      case "Array":
+      case "Dict":
+        _schema = schema._0;
+        continue;
+      case "Union":
+        let types = schema._0;
+        let match = isRefPlusDictUnion(types);
+        if (match !== void 0) {
+          return [];
+        }
+        let name$1 = getUnionName(types);
+        return [{
+          name: name$1,
+          schema
+        }];
+      default:
+        return [];
+    }
+  }
+  ;
+}
+function extractUnions(_parentName, schema) {
+  if (typeof schema !== "object") {
+    return [];
+  } else if (schema._tag === "Object") {
+    return schema._0.flatMap((field) => extractUnionsFromType(field.type));
+  } else {
+    return [];
+  }
+}
+function replaceUnionInType(schema) {
+  if (typeof schema !== "object") {
+    return schema;
+  }
+  switch (schema._tag) {
+    case "Optional":
+      return {
+        _tag: "Optional",
+        _0: replaceUnionInType(schema._0)
+      };
+    case "Nullable":
+      return {
+        _tag: "Nullable",
+        _0: replaceUnionInType(schema._0)
+      };
+    case "Object":
+      let newFields = schema._0.map((field) => {
+        let newType = replaceUnionInType(field.type);
+        return {
+          name: field.name,
+          type: newType,
+          required: field.required
+        };
+      });
+      return {
+        _tag: "Object",
+        _0: newFields
+      };
+    case "Array":
+      return {
+        _tag: "Array",
+        _0: replaceUnionInType(schema._0)
+      };
+    case "PolyVariant":
+      return {
+        _tag: "Ref",
+        _0: getPolyVariantName(schema._0)
+      };
+    case "Dict":
+      return {
+        _tag: "Dict",
+        _0: replaceUnionInType(schema._0)
+      };
+    case "Union":
+      let types = schema._0;
+      let refName = isRefPlusDictUnion(types);
+      if (refName !== void 0) {
+        return {
+          _tag: "Ref",
+          _0: refName
+        };
+      } else {
+        return {
+          _tag: "Ref",
+          _0: getUnionName(types)
+        };
+      }
+    default:
+      return schema;
+  }
+}
+function replaceUnions(_parentName, schema) {
+  if (typeof schema !== "object") {
+    return schema;
+  }
+  if (schema._tag !== "Object") {
+    return schema;
+  }
+  let newFields = schema._0.map((field) => {
+    let newType = replaceUnionInType(field.type);
+    return {
+      name: field.name,
+      type: newType,
+      required: field.required
+    };
+  });
+  return {
+    _tag: "Object",
+    _0: newFields
+  };
+}
+function getDependencies(_schema) {
+  while (true) {
+    let schema = _schema;
+    if (typeof schema !== "object") {
+      return [];
+    }
+    switch (schema._tag) {
+      case "Object":
+        return schema._0.flatMap((f) => getDependencies(f.type));
+      case "Ref":
+        return [schema._0];
+      case "Enum":
+        return [];
+      case "PolyVariant":
+        return schema._0.flatMap((c2) => getDependencies(c2.payload));
+      case "Optional":
+      case "Nullable":
+      case "Array":
+      case "Dict":
+        _schema = schema._0;
+        continue;
+      case "Union":
+        return schema._0.flatMap(getDependencies);
+    }
+  }
+  ;
+}
+function topologicalSort(schemas) {
+  let schemaMap = {};
+  schemas.forEach((s) => {
+    schemaMap[s.name] = s;
+  });
+  let deps = {};
+  schemas.forEach((s) => {
+    let refNames = getDependencies(s.schema);
+    let validRefs = refNames.filter((name) => isSome(schemaMap[name]));
+    deps[s.name] = validRefs;
+  });
+  let outDegree = {};
+  schemas.forEach((s) => {
+    let myDeps = getOr(deps[s.name], []);
+    outDegree[s.name] = myDeps.length;
+  });
+  let reverseDeps = {};
+  schemas.forEach((s) => {
+    reverseDeps[s.name] = [];
+  });
+  Object.entries(deps).forEach((param) => {
+    let name = param[0];
+    param[1].forEach((refName) => {
+      let arr = reverseDeps[refName];
+      if (arr !== void 0) {
+        arr.push(name);
+        return;
+      }
+    });
+  });
+  let queue = schemas.filter((s) => getOr(outDegree[s.name], 0) === 0).map((s) => s.name);
+  let result = [];
+  let visited = {};
+  let process2 = () => {
+    while (true) {
+      let name = queue.shift();
+      if (name === void 0) {
+        return;
+      }
+      if (isNone(visited[name])) {
+        visited[name] = true;
+        let schema = schemaMap[name];
+        if (schema !== void 0) {
+          result.push(schema);
+        }
+        let dependents = reverseDeps[name];
+        if (dependents !== void 0) {
+          dependents.forEach((depName) => {
+            let current = getOr(outDegree[depName], 0);
+            outDegree[depName] = current - 1 | 0;
+            if ((current - 1 | 0) === 0) {
+              queue.push(depName);
+              return;
+            }
+          });
+        }
+      }
+      continue;
+    }
+    ;
+  };
+  process2();
+  schemas.forEach((s) => {
+    if (isNone(visited[s.name])) {
+      result.push(s);
+      return;
+    }
+  });
+  return result;
+}
+function buildSkipSchemaSet(schemas) {
+  let skipSet = {};
+  schemas.forEach((s) => {
+    let types = s.schema;
+    let hasInlineProblem;
+    if (typeof types !== "object") {
+      hasInlineProblem = hasUnion(s.schema);
+    } else {
+      switch (types._tag) {
+        case "PolyVariant":
+          hasInlineProblem = types._0.some((c2) => hasUnion(c2.payload));
+          break;
+        case "Union":
+          hasInlineProblem = types._0.some(hasUnion);
+          break;
+        default:
+          hasInlineProblem = hasUnion(s.schema);
+      }
+    }
+    if (hasInlineProblem) {
+      skipSet[s.name] = true;
+      return;
+    }
+  });
+  let changed = {
+    contents: true
+  };
+  while (changed.contents) {
+    changed.contents = false;
+    schemas.forEach((s) => {
+      if (!isNone(skipSet[s.name])) {
+        return;
+      }
+      let refs = getDependencies(s.schema);
+      let refsSkipSchema = refs.some((refName) => isSome(skipSet[refName]));
+      if (refsSkipSchema) {
+        skipSet[s.name] = true;
+        changed.contents = true;
+        return;
+      }
+    });
+  }
+  ;
+  return skipSet;
+}
+function collectUnionWarnings(schemas) {
+  let seen = {};
+  let warnings = [];
+  let findUnions = (_schema) => {
+    while (true) {
+      let schema = _schema;
+      if (typeof schema !== "object") {
+        return [];
+      }
+      switch (schema._tag) {
+        case "Object":
+          return schema._0.flatMap((f) => findUnions(f.type));
+        case "Optional":
+        case "Nullable":
+        case "Array":
+        case "Dict":
+          _schema = schema._0;
+          continue;
+        case "Union":
+          return [schema._0];
+        default:
+          return [];
+      }
+    }
+    ;
+  };
+  schemas.forEach((s) => {
+    let unions = findUnions(s.schema);
+    unions.forEach((types) => {
+      let unionName = getUnionName(types);
+      if (!isNone(seen[unionName])) {
+        return;
+      }
+      seen[unionName] = true;
+      let refName = isRefPlusDictUnion(types);
+      if (refName !== void 0) {
+        warnings.push(`\u26A0 ` + unionName + `: anyOf without discriminator, simplified to ` + lcFirst(refName));
+        return;
+      }
+      let primName = isPrimitivePlusDictUnion(types);
+      if (primName !== void 0) {
+        warnings.push(`\u26A0 ` + unionName + `: anyOf [` + primName + `, Dict] without discriminator, @tag("_tag") may not work at runtime`);
+        return;
+      }
+    });
+  });
+  return warnings;
+}
+function validateUnionDiscriminators(schemas) {
+  let seen = {};
+  let errors = [];
+  let schemasDict = {};
+  schemas.forEach((s) => {
+    schemasDict[s.name] = s.schema;
+  });
+  let tagsDict = {};
+  schemas.forEach((s) => {
+    let tag = s.discriminatorTag;
+    if (tag !== void 0) {
+      tagsDict[s.name] = tag;
+      return;
+    }
+  });
+  let fieldDiscsDict = {};
+  schemas.forEach((s) => {
+    let dict = s.fieldDiscriminators;
+    if (dict !== void 0) {
+      Object.entries(dict).forEach((param) => {
+        fieldDiscsDict[param[0]] = param[1];
+      });
+      return;
+    }
+  });
+  let findUnions = (_schema) => {
+    while (true) {
+      let schema = _schema;
+      if (typeof schema !== "object") {
+        return [];
+      }
+      switch (schema._tag) {
+        case "Object":
+          return schema._0.flatMap((f) => findUnions(f.type));
+        case "Optional":
+        case "Nullable":
+        case "Array":
+        case "Dict":
+          _schema = schema._0;
+          continue;
+        case "Union":
+          return [schema._0];
+        default:
+          return [];
+      }
+    }
+    ;
+  };
+  schemas.forEach((s) => {
+    let unions = findUnions(s.schema);
+    unions.forEach((types) => {
+      let unionName = getUnionName(types);
+      if (!isNone(seen[unionName])) {
+        return;
+      }
+      seen[unionName] = true;
+      if (isPrimitiveOnlyUnion(types)) {
+        return;
+      }
+      let match = isRefPlusDictUnion(types);
+      if (match !== void 0) {
+        return;
+      }
+      let match$1 = isPrimitivePlusDictUnion(types);
+      if (match$1 !== void 0) {
+        return;
+      }
+      if (!isNone(fieldDiscsDict[unionName])) {
+        return;
+      }
+      let allRefsHaveTags = types.every((t) => {
+        if (typeof t !== "object" || t._tag !== "Ref") {
+          return true;
+        } else {
+          return isSome(tagsDict[t._0]);
+        }
+      });
+      if (!allRefsHaveTags) {
+        errors.push(makeError({
+          TAG: "MissingDiscriminator",
+          _0: unionName
+        }, void 0, 'Add discriminator: { propertyName: "type" } to the anyOf/oneOf schema, or use the _tag convention with const values', void 0));
+        return;
+      }
+    });
+  });
+  return errors;
+}
+
+// src/IRGen.mjs
+function convertType(schema) {
+  if (typeof schema !== "object") {
+    switch (schema) {
+      case "String":
+        return {
+          TAG: "Primitive",
+          _0: "PString"
+        };
+      case "Number":
+        return {
+          TAG: "Primitive",
+          _0: "PFloat"
+        };
+      case "Integer":
+        return {
+          TAG: "Primitive",
+          _0: "PInt"
+        };
+      case "Boolean":
+        return {
+          TAG: "Primitive",
+          _0: "PBool"
+        };
+      case "Null":
+        return {
+          TAG: "Primitive",
+          _0: "PUnit"
+        };
+      case "Unknown":
+        return "JSON";
+    }
+  } else {
+    switch (schema._tag) {
+      case "Optional":
+        return {
+          TAG: "Option",
+          _0: convertType(schema._0)
+        };
+      case "Nullable":
+        return {
+          TAG: "Nullable",
+          _0: convertType(schema._0)
+        };
+      case "Object":
+        let fields = schema._0;
+        if (fields.length === 0) {
+          return "JSON";
+        } else {
+          return {
+            TAG: "InlineRecord",
+            _0: fields.map(convertField)
+          };
+        }
+      case "Array":
+        return {
+          TAG: "Array",
+          _0: convertType(schema._0)
+        };
+      case "Ref":
+        return {
+          TAG: "Named",
+          _0: lcFirst(schema._0)
+        };
+      case "Enum":
+        return {
+          TAG: "Enum",
+          _0: schema._0
+        };
+      case "PolyVariant":
+        return {
+          TAG: "InlineVariant",
+          _0: schema._0.map((c2) => {
+            let payload = convertType(c2.payload);
+            return {
+              tag: c2._tag,
+              payload
+            };
+          })
+        };
+      case "Dict":
+        return {
+          TAG: "Dict",
+          _0: convertType(schema._0)
+        };
+      case "Union":
+        return {
+          TAG: "InlineVariant",
+          _0: schema._0.map((t) => {
+            let tag = getTagForType(t);
+            let payload = convertType(t);
+            return {
+              tag,
+              payload
+            };
+          })
+        };
+    }
+  }
+}
+function convertField(field) {
+  let baseType = convertType(field.type);
+  let wrappedType = field.required || isOptionalType(field.type) ? baseType : {
+    TAG: "Option",
+    _0: baseType
+  };
+  let annotations = [];
+  if (isNullableType(field.type)) {
+    annotations.push("SNull");
+  }
+  if (isReservedKeyword(field.name)) {
+    annotations.push({
+      TAG: "As",
+      _0: field.name
+    });
+  }
+  let fieldName = isReservedKeyword(field.name) ? field.name + "_" : field.name;
+  return {
+    name: fieldName,
+    annotations,
+    type_: wrappedType
+  };
+}
+function convertToIrTypeDef(namedSchema, schemasDict, tagsDict, skipSchemaSet) {
+  let typeName = lcFirst(namedSchema.name);
+  let tagName = getOr(namedSchema.discriminatorPropertyName, "_tag");
+  let shouldSkipSchema = isSome(skipSchemaSet[namedSchema.name]);
+  let cases = namedSchema.schema;
+  if (typeof cases === "object") {
+    switch (cases._tag) {
+      case "PolyVariant":
+        let irCases = cases._0.map((c2) => {
+          let refName = c2.payload;
+          let payload;
+          if (typeof refName !== "object" || refName._tag !== "Ref") {
+            payload = convertType(refName);
+          } else {
+            let refName$1 = refName._0;
+            let other = schemasDict[refName$1];
+            if (other !== void 0) {
+              if (typeof other !== "object" || other._tag !== "Object") {
+                payload = convertType(other);
+              } else {
+                let filtered = other._0.filter((f) => f.name !== tagName);
+                payload = {
+                  TAG: "InlineRecord",
+                  _0: filtered.map(convertField)
+                };
+              }
+            } else {
+              payload = {
+                TAG: "Named",
+                _0: lcFirst(refName$1)
+              };
+            }
+          }
+          return {
+            tag: ucFirst2(c2._tag),
+            payload
+          };
+        });
+        let baseAnnotations = [
+          "GenType",
+          {
+            TAG: "Tag",
+            _0: tagName
+          }
+        ];
+        let annotations = shouldSkipSchema ? baseAnnotations : baseAnnotations.concat(["Schema"]);
+        return {
+          name: typeName,
+          annotations,
+          kind: {
+            TAG: "VariantDef",
+            _0: irCases
+          }
+        };
+      case "Union":
+        let types = cases._0;
+        if (isPrimitiveOnlyUnion(types)) {
+          let irCases$1 = types.map((t) => {
+            let tag = getTagForType(t);
+            let payload = convertType(t);
+            return {
+              tag,
+              payload
+            };
+          });
+          let baseAnnotations$1 = [
+            "GenType",
+            {
+              TAG: "Tag",
+              _0: tagName
+            },
+            "Unboxed"
+          ];
+          let annotations$1 = shouldSkipSchema ? baseAnnotations$1 : baseAnnotations$1.concat(["Schema"]);
+          return {
+            name: typeName,
+            annotations: annotations$1,
+            kind: {
+              TAG: "VariantDef",
+              _0: irCases$1
+            }
+          };
+        }
+        let irCases$2 = types.map((t) => {
+          if (typeof t === "object" && t._tag === "Ref") {
+            let name = t._0;
+            let tagValue = tagsDict[name];
+            let tag = tagValue !== void 0 ? ucFirst2(tagValue) : ucFirst2(name);
+            let other = schemasDict[name];
+            let payload;
+            if (other !== void 0) {
+              if (typeof other !== "object" || other._tag !== "Object") {
+                payload = convertType(other);
+              } else {
+                let filtered = other._0.filter((f) => f.name !== tagName);
+                payload = {
+                  TAG: "InlineRecord",
+                  _0: filtered.map(convertField)
+                };
+              }
+            } else {
+              payload = {
+                TAG: "Named",
+                _0: lcFirst(name)
+              };
+            }
+            return {
+              tag,
+              payload
+            };
+          }
+          let tag$1 = getTagForType(t);
+          let payload$1 = convertType(t);
+          return {
+            tag: tag$1,
+            payload: payload$1
+          };
+        });
+        let baseAnnotations$2 = [
+          "GenType",
+          {
+            TAG: "Tag",
+            _0: tagName
+          }
+        ];
+        let annotations$2 = shouldSkipSchema ? baseAnnotations$2 : baseAnnotations$2.concat(["Schema"]);
+        return {
+          name: typeName,
+          annotations: annotations$2,
+          kind: {
+            TAG: "VariantDef",
+            _0: irCases$2
+          }
+        };
+    }
+  }
+  let fields = namedSchema.schema;
+  let kind;
+  if (typeof fields !== "object" || fields._tag !== "Object") {
+    kind = {
+      TAG: "AliasDef",
+      _0: convertType(namedSchema.schema)
+    };
+  } else {
+    let fields$1 = fields._0;
+    kind = fields$1.length > 0 ? {
+      TAG: "RecordDef",
+      _0: fields$1.map(convertField)
+    } : {
+      TAG: "AliasDef",
+      _0: convertType(namedSchema.schema)
+    };
+  }
+  let annotations$3 = shouldSkipSchema ? ["GenType"] : [
+    "GenType",
+    "Schema"
+  ];
+  return {
+    name: typeName,
+    annotations: annotations$3,
+    kind
+  };
+}
+function generate(schemas) {
+  let validationErrors = validateUnionDiscriminators(schemas);
+  if (validationErrors.length > 0) {
+    return {
+      TAG: "Error",
+      _0: validationErrors
+    };
+  }
+  let warnings = collectUnionWarnings(schemas);
+  let enumOccurrences = collectInlineEnums(schemas);
+  let topLevelNames = schemas.map((s) => s.name);
+  let enumNames = resolveEnumNames(enumOccurrences, topLevelNames);
+  let enumSchemas = buildExtractedEnumSchemas(enumOccurrences, enumNames);
+  let schemasAfterEnumPromotion = replaceInlineEnums(schemas, enumNames);
+  let schemas$1 = enumSchemas.concat(schemasAfterEnumPromotion);
+  let extractedUnions = schemas$1.flatMap((s) => extractUnions(s.name, s.schema).map((extracted) => {
+    let dict = s.fieldDiscriminators;
+    let discriminatorPropertyName = dict !== void 0 ? dict[extracted.name] : void 0;
+    return {
+      name: extracted.name,
+      schema: extracted.schema,
+      discriminatorTag: void 0,
+      discriminatorPropertyName,
+      fieldDiscriminators: void 0
+    };
+  }));
+  let seen = {};
+  let uniqueUnions = extractedUnions.filter((u) => {
+    if (isSome(seen[u.name])) {
+      return false;
+    } else {
+      seen[u.name] = true;
+      return true;
+    }
+  });
+  let modifiedSchemas = schemas$1.map((s) => ({
+    name: s.name,
+    schema: replaceUnions(s.name, s.schema),
+    discriminatorTag: s.discriminatorTag,
+    discriminatorPropertyName: s.discriminatorPropertyName,
+    fieldDiscriminators: s.fieldDiscriminators
+  }));
+  let allSchemas = uniqueUnions.concat(modifiedSchemas);
+  let schemasDict = {};
+  let tagsDict = {};
+  allSchemas.forEach((s) => {
+    schemasDict[s.name] = s.schema;
+    let tag = s.discriminatorTag;
+    if (tag !== void 0) {
+      tagsDict[s.name] = tag;
+      return;
+    }
+  });
+  let skipSchemaSet = buildSkipSchemaSet(allSchemas);
+  let sorted = topologicalSort(allSchemas);
+  let irTypes = sorted.map((s) => convertToIrTypeDef(s, schemasDict, tagsDict, skipSchemaSet));
+  return {
+    TAG: "Ok",
+    _0: {
+      preamble: "module S = Sury",
+      types: irTypes,
+      warnings
+    }
+  };
+}
+
+// src/CodegenShims.mjs
+function generateDictShim() {
+  return `// Generated by osury - Dict type shim for @genType
+export type t<T> = { [key: string]: T };
+`;
+}
+function generateNullableShim() {
+  return `/**
+ * Type shim for ReScript Nullable.t
+ *
+ * This file is generated by osury (not by ReScript/genType).
+ * It maps ReScript's option<T> to TypeScript's T | null for JSON nullable fields.
+ *
+ * ReScript side: Nullable.t<T> = option<T> (works with sury's S.null schema)
+ * TypeScript side: t<T> = T | null (correct JSON null representation)
+ */
+export type t<T> = T | null;
+`;
+}
+function generateJsonShim() {
+  return `// Generated by osury - JSON type shim for @genType
+export type t = unknown;
+`;
+}
+function generateNullableModule() {
+  return `// Generated by osury - Nullable type for JSON null values
+// This is option<T> internally but maps to T | null in TypeScript via shim
+@genType.import(("./Nullable.shim.ts", "t"))
+type t<'a> = option<'a>
+`;
+}
+
+// src/BackendReScript.mjs
+function quoteTag(tag) {
+  let needsQuoting = tag === "" || tag.split("").some((c2) => {
+    let code = c2.charCodeAt(0);
+    return !(code >= 97 && code <= 122 || code >= 65 && code <= 90 || code >= 48 && code <= 57 || code === 95);
+  });
+  if (needsQuoting) {
+    return `"` + tag + `"`;
+  } else {
+    return tag;
+  }
+}
+function printPrimitive(p) {
+  switch (p) {
+    case "PString":
+      return "string";
+    case "PFloat":
+      return "float";
+    case "PInt":
+      return "int";
+    case "PBool":
+      return "bool";
+    case "PUnit":
+      return "unit";
+  }
+}
+function printType(t) {
+  if (typeof t !== "object") {
+    return "@s.matches(S.json) JSON.t";
+  }
+  switch (t.TAG) {
+    case "Primitive":
+      return printPrimitive(t._0);
+    case "Option":
+      return `option<` + printType(t._0) + `>`;
+    case "Nullable":
+      return `Nullable.t<` + printType(t._0) + `>`;
+    case "Array":
+      return `array<` + printType(t._0) + `>`;
+    case "Dict":
+      return `Dict.t<` + printType(t._0) + `>`;
+    case "Named":
+      return t._0;
+    case "Enum":
+      let variants = t._0.map((v) => `#` + quoteTag(v)).join(" | ");
+      return `[` + variants + `]`;
+    case "InlineRecord":
+      return printRecord(t._0);
+    case "InlineVariant":
+      return printVariantCases(t._0);
+  }
+}
+function printField(field) {
+  let typeStr = printType(field.type_);
+  let fieldType = reduce(field.annotations, typeStr, (acc, ann) => {
+    if (typeof ann !== "object" && ann === "SNull") {
+      return `@s.null ` + acc;
+    } else {
+      return acc;
+    }
+  });
+  let asAttr = getOr(findMap(field.annotations, (ann) => {
+    if (typeof ann !== "object" || ann.TAG !== "As") {
+      return;
+    } else {
+      return `@as("` + ann._0 + `") `;
+    }
+  }), "");
+  return asAttr + field.name + `: ` + fieldType;
+}
+function printRecord(fields) {
+  if (fields.length === 0) {
+    return "{}";
+  }
+  let fieldStrs = fields.map(printField);
+  return `{
+  ` + fieldStrs.join(",\n  ") + `
+}`;
+}
+function printVariantCase(c2) {
+  let payloadStr = printType(c2.payload);
+  return c2.tag + `(` + payloadStr + `)`;
+}
+function printVariantCases(cases) {
+  let caseStrs = cases.map(printVariantCase);
+  return `[` + caseStrs.map((c2) => `#` + quoteTag(c2)).join(" | ") + `]`;
+}
+function printAnnotation(ann) {
+  if (typeof ann === "object") {
+    if (ann.TAG === "Tag") {
+      return `@tag("` + ann._0 + `")`;
+    } else {
+      return;
+    }
+  }
+  switch (ann) {
+    case "GenType":
+      return "@genType";
+    case "Schema":
+      return "@schema";
+    case "Unboxed":
+      return "@unboxed";
+    case "SNull":
+      return;
+  }
+}
+function printAnnotations(annotations) {
+  return filterMap(annotations, printAnnotation).join("\n");
+}
+function printTypeDef(typeDef) {
+  let annotations = printAnnotations(typeDef.annotations);
+  let fields = typeDef.kind;
+  let body;
+  switch (fields.TAG) {
+    case "RecordDef":
+      body = printRecord(fields._0);
+      break;
+    case "VariantDef":
+      body = fields._0.map(printVariantCase).join(" | ");
+      break;
+    case "AliasDef":
+      body = printType(fields._0);
+      break;
+  }
+  return annotations + `
+type ` + typeDef.name + ` = ` + body;
+}
+function print(module_) {
+  let typeDefs = module_.types.map(printTypeDef).join("\n\n");
+  return module_.preamble + "\n\n" + typeDefs;
+}
+
+// src/Codegen.mjs
+function generateModuleWithDiagnostics(schemas) {
+  let irModule = generate(schemas);
+  if (irModule.TAG !== "Ok") {
+    return {
+      TAG: "Error",
+      _0: irModule._0
+    };
+  }
+  let irModule$1 = irModule._0;
+  let code = print(irModule$1);
+  return {
+    TAG: "Ok",
+    _0: {
+      code,
+      warnings: irModule$1.warnings
+    }
+  };
+}
+var generateDictShim2 = generateDictShim;
+var generateJsonShim2 = generateJsonShim;
+var generateNullableShim2 = generateNullableShim;
+var generateNullableModule2 = generateNullableModule;
+
+// src/DomainConfig.mjs
+function parseFieldConfig(name, json) {
+  if (typeof json === "object" && json !== null && !Array.isArray(json)) {
+    let match = json["type"];
+    let exit = 0;
+    if (match !== void 0) {
+      if (typeof match === "string") {
+        let match$1 = json["mapper"];
+        let mapper = typeof match$1 === "string" ? match$1 : void 0;
+        let match$2 = json["source"];
+        let source = typeof match$2 === "string" ? match$2 : void 0;
+        return {
+          TAG: "Ok",
+          _0: [
+            name,
+            {
+              type_: match,
+              mapper,
+              source
+            }
+          ]
+        };
+      }
+      exit = 2;
+    } else {
+      exit = 2;
+    }
+    if (exit === 2) {
+      return {
+        TAG: "Error",
+        _0: [makeError({
+          TAG: "MissingRequiredField",
+          _0: "type"
+        }, [
+          "fields",
+          name
+        ], some(`Field "` + name + `" must have a "type" property`), void 0)]
+      };
+    }
+  }
+  return {
+    TAG: "Error",
+    _0: [makeError({
+      TAG: "InvalidJson",
+      _0: `field "` + name + `" must be an object`
+    }, [
+      "fields",
+      name
+    ], void 0, void 0)]
+  };
+}
+function parseModuleConfig(name, json) {
+  if (typeof json === "object" && json !== null && !Array.isArray(json)) {
+    let match = json["source"];
+    let exit = 0;
+    if (typeof match === "string") {
+      let match$1 = json["output"];
+      let output = typeof match$1 === "string" ? match$1 : void 0;
+      let match$2 = json["fields"];
+      let exit$1 = 0;
+      if (match$2 !== void 0) {
+        if (typeof match$2 === "object" && match$2 !== null && !Array.isArray(match$2)) {
+          let entries = Object.entries(match$2);
+          let results = entries.map((param) => parseFieldConfig(param[0], param[1]));
+          let errors = filterMap(results, (r) => {
+            if (r.TAG === "Ok") {
+              return;
+            } else {
+              return r._0;
+            }
+          }).flat();
+          if (errors.length > 0) {
+            return {
+              TAG: "Error",
+              _0: errors
+            };
+          }
+          let fields = filterMap(results, (r) => {
+            if (r.TAG === "Ok") {
+              return r._0;
+            }
+          });
+          return {
+            TAG: "Ok",
+            _0: [
+              name,
+              {
+                source: match,
+                output,
+                fields
+              }
+            ]
+          };
+        }
+        exit$1 = 3;
+      } else {
+        exit$1 = 3;
+      }
+      if (exit$1 === 3) {
+        return {
+          TAG: "Error",
+          _0: [makeError({
+            TAG: "MissingRequiredField",
+            _0: "fields"
+          }, [
+            "modules",
+            name
+          ], some(`Module "` + name + `" must have a "fields" object`), void 0)]
+        };
+      }
+    } else {
+      exit = 2;
+    }
+    if (exit === 2) {
+      return {
+        TAG: "Error",
+        _0: [makeError({
+          TAG: "MissingRequiredField",
+          _0: "source"
+        }, [
+          "modules",
+          name
+        ], some(`Module "` + name + `" must have a "source" property referencing the API type`), void 0)]
+      };
+    }
+  }
+  return {
+    TAG: "Error",
+    _0: [makeError({
+      TAG: "InvalidJson",
+      _0: `module "` + name + `" must be an object`
+    }, [
+      "modules",
+      name
+    ], void 0, void 0)]
+  };
+}
+function parse2(json) {
+  if (typeof json === "object" && json !== null && !Array.isArray(json)) {
+    let match = json["modules"];
+    let exit = 0;
+    if (match !== void 0) {
+      if (typeof match === "object" && match !== null && !Array.isArray(match)) {
+        let entries = Object.entries(match);
+        let results = entries.map((param) => parseModuleConfig(param[0], param[1]));
+        let errors = filterMap(results, (r) => {
+          if (r.TAG === "Ok") {
+            return;
+          } else {
+            return r._0;
+          }
+        }).flat();
+        if (errors.length > 0) {
+          return {
+            TAG: "Error",
+            _0: errors
+          };
+        }
+        let modules = filterMap(results, (r) => {
+          if (r.TAG === "Ok") {
+            return r._0;
+          }
+        });
+        return {
+          TAG: "Ok",
+          _0: {
+            modules
+          }
+        };
+      }
+      exit = 2;
+    } else {
+      exit = 2;
+    }
+    if (exit === 2) {
+      return {
+        TAG: "Error",
+        _0: [makeError({
+          TAG: "MissingRequiredField",
+          _0: "modules"
+        }, [], `Config must have a "modules" object`, void 0)]
+      };
+    }
+  }
+  return {
+    TAG: "Error",
+    _0: [makeError({
+      TAG: "InvalidJson",
+      _0: "config must be an object"
+    }, void 0, void 0, void 0)]
+  };
+}
+
+// src/DomainGen.mjs
+function generateField(param) {
+  let fieldConfig = param[1];
+  let name = param[0];
+  let mapper = fieldConfig.mapper;
+  let mapping;
+  if (mapper !== void 0) {
+    mapping = {
+      TAG: "Mapper",
+      _0: mapper
+    };
+  } else {
+    let s = fieldConfig.source;
+    let sourceName = s !== void 0 ? s : name;
+    mapping = {
+      TAG: "Passthrough",
+      _0: sourceName
+    };
+  }
+  return {
+    name,
+    typeAnnotation: fieldConfig.type_,
+    mapping
+  };
+}
+function generateModule(param, apiModule) {
+  let moduleConfig = param[1];
+  let name = param[0];
+  let o = moduleConfig.output;
+  let output = o !== void 0 ? o : name + ".gen.res";
+  let sourceType = apiModule + "." + moduleConfig.source;
+  let fields = moduleConfig.fields.map(generateField);
+  return {
+    name,
+    sourceType,
+    output,
+    fields
+  };
+}
+function generate2(config, apiModule) {
+  return config.modules.map((entry) => generateModule(entry, apiModule));
+}
+
+// src/DomainBackend.mjs
+function printField2(field) {
+  return `  ` + field.name + `: ` + field.typeAnnotation + `,`;
+}
+function printType2(module_) {
+  let fields = module_.fields.map(printField2).join("\n");
+  return `type t = {
+` + fields + `
+}`;
+}
+function printMakeField(field) {
+  let fn = field.mapping;
+  if (fn.TAG === "Mapper") {
+    return `  ` + field.name + `: ` + fn._0 + `(raw),`;
+  } else {
+    return `  ` + field.name + `: raw.` + fn._0 + `,`;
+  }
+}
+function printMake(module_) {
+  let fields = module_.fields.map(printMakeField).join("\n");
+  return `let make = (raw: ` + module_.sourceType + `): t => {
+` + fields + `
+}`;
+}
+function printModule(module_) {
+  let header2 = `// ` + module_.output + ` (generated by osury \u2014 do not edit)`;
+  let typeBlock = printType2(module_);
+  let makeBlock = printMake(module_);
+  return header2 + "\n\n" + typeBlock + "\n\n" + makeBlock + "\n";
+}
+
+// bin/osury.mjs
+import fs from "fs";
+import path from "path";
+import { createRequire } from "module";
+import { performance } from "perf_hooks";
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+var VERSION = pkg.version;
+var noColor = process.env.NO_COLOR != null || process.argv.includes("--no-color") || !process.stderr.isTTY;
+var fmt = (code, text) => noColor ? text : `\x1B[${code}m${text}\x1B[0m`;
+var c = {
+  bold: (t) => fmt("1", t),
+  dim: (t) => fmt("2", t),
+  italic: (t) => fmt("3", t),
+  red: (t) => fmt("31", t),
+  green: (t) => fmt("32", t),
+  yellow: (t) => fmt("33", t),
+  blue: (t) => fmt("34", t),
+  magenta: (t) => fmt("35", t),
+  cyan: (t) => fmt("36", t),
+  white: (t) => fmt("37", t),
+  gray: (t) => fmt("90", t),
+  boldRed: (t) => fmt("1;31", t),
+  boldGreen: (t) => fmt("1;32", t),
+  boldYellow: (t) => fmt("1;33", t),
+  boldCyan: (t) => fmt("1;36", t)
+};
+var sym = {
+  success: c.green("\u2713"),
+  error: c.red("\u2717"),
+  warning: c.yellow("\u26A0"),
+  arrow: c.dim("\u2192"),
+  bullet: c.dim("\xB7"),
+  bar: c.dim("\u2502")
+};
+var log = (...args) => console.log(...args);
+var err = (...args) => console.error(...args);
+var blank = () => log();
+function header() {
+  blank();
+  log(`  ${c.bold("osury")} ${c.dim(`v${VERSION}`)}`);
+  log(`  ${c.dim("OpenAPI 3.x \u2192 ReScript + Sury")}`);
+  blank();
+}
+function elapsed(startMs) {
+  const ms = performance.now() - startMs;
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  return `${(ms / 1e3).toFixed(2)}s`;
+}
+function printHelp() {
+  header();
+  log(`  ${c.bold("Usage")}`);
+  log(`    ${c.cyan("$")} osury ${c.cyan("<input.json>")} ${c.dim("[output.res]")}`);
+  log(`    ${c.cyan("$")} osury generate ${c.cyan("<input.json>")} -o ${c.cyan("<output.res>")}`);
+  log(`    ${c.cyan("$")} osury domain ${c.dim("[options]")}`);
+  blank();
+  log(`  ${c.bold("Options")}`);
+  log(`    ${c.cyan("-o")}, ${c.cyan("--output")}    Output file path ${c.dim("(default: ./Generated.res)")}`);
+  log(`    ${c.cyan("-h")}, ${c.cyan("--help")}      Show this help`);
+  log(`    ${c.cyan("-v")}, ${c.cyan("--version")}   Show version`);
+  log(`    ${c.cyan("--no-color")}    Disable colored output`);
+  blank();
+  log(`  ${c.bold("Domain options")}`);
+  log(`    ${c.cyan("--config")}      Config file path ${c.dim("(default: domain.config.json)")}`);
+  log(`    ${c.cyan("--api-module")}  API module name ${c.dim("(default: Api)")}`);
+  log(`    ${c.cyan("-o")}            Output directory ${c.dim("(default: src/domains/)")}`);
+  blank();
+  log(`  ${c.bold("Examples")}`);
+  log(`    ${c.cyan("$")} osury openapi.json`);
+  log(`    ${c.cyan("$")} osury openapi.json src/API.res`);
+  log(`    ${c.cyan("$")} osury generate schema.json -o src/Schema.res`);
+  log(`    ${c.cyan("$")} osury domain --config domain.config.json --api-module Api`);
+  blank();
+}
+function parseArgs(args) {
+  const options = { input: null, output: "./Generated.res" };
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg === "-h" || arg === "--help") {
+      printHelp();
+      process.exit(0);
+    } else if (arg === "-v" || arg === "--version") {
+      log(`osury v${VERSION}`);
+      process.exit(0);
+    } else if (arg === "--no-color") {
+    } else if (arg === "-o" || arg === "--output") {
+      i++;
+      if (i >= args.length) {
+        header();
+        err(`  ${sym.error} ${c.boldRed("Missing value for --output")}`);
+        blank();
+        err(`  Expected: osury input.json ${c.cyan("-o <path>")}`);
+        blank();
+        process.exit(1);
+      }
+      options.output = args[i];
+    } else if (arg === "generate") {
+    } else if (!options.input) {
+      options.input = arg;
+    } else if (options.output === "./Generated.res") {
+      options.output = arg;
+    }
+    i++;
+  }
+  return options;
+}
+function levenshtein(a, b) {
+  const m = a.length, n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++)
+    for (let j = 1; j <= n; j++)
+      dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+  return dp[m][n];
+}
+function findSimilarFiles(target) {
+  const dir = path.dirname(target);
+  const resolvedDir = dir === "." ? process.cwd() : dir;
+  const base = path.basename(target).toLowerCase();
+  try {
+    const files = fs.readdirSync(resolvedDir);
+    return files.filter((f) => {
+      const fl = f.toLowerCase();
+      if (!fl.endsWith(".json") && !fl.endsWith(".yaml") && !fl.endsWith(".yml"))
+        return false;
+      return levenshtein(base, fl) <= Math.ceil(base.length * 0.4);
+    }).sort((a, b) => levenshtein(a.toLowerCase(), base) - levenshtein(b.toLowerCase(), base)).slice(0, 3);
+  } catch {
+    return [];
+  }
+}
+function formatErrorKind(kind) {
+  if (!kind || !kind.TAG) return "Unknown error";
+  switch (kind.TAG) {
+    case "UnknownType":
+      return `Unknown type ${c.bold(`"${kind._0}"`)}`;
+    case "MissingRequiredField":
+      return `Missing required field ${c.bold(`"${kind._0}"`)}`;
+    case "InvalidRef":
+      return `Invalid reference ${c.bold(`"${kind._0}"`)}`;
+    case "UnsupportedFeature":
+      return `Unsupported feature ${c.bold(`"${kind._0}"`)}`;
+    case "InvalidFormat":
+      return `Invalid format ${c.bold(`"${kind._0}"`)}`;
+    case "CircularReference":
+      return `Circular reference ${c.bold(`"${kind._0}"`)}`;
+    case "AmbiguousUnion":
+      return `Ambiguous union (anyOf/oneOf cannot be distinguished)`;
+    case "MissingDiscriminator":
+      return `Missing discriminator for union ${c.bold(`"${kind._0}"`)}`;
+    case "InvalidJson":
+      return `Invalid JSON: ${kind._0}`;
+    default:
+      return kind.TAG + (kind._0 ? `: ${kind._0}` : "");
+  }
+}
+function formatParseError(error, index) {
+  const pathStr = error.location?.path?.length > 0 ? c.cyan("#/" + error.location.path.join("/")) : c.cyan("#");
+  const lines = [];
+  lines.push(`  ${c.dim(`${index + 1}.`)} ${pathStr}`);
+  lines.push(`     ${formatErrorKind(error.kind)}`);
+  if (error.hint) {
+    lines.push(`     ${c.dim("Hint:")} ${c.italic(error.hint)}`);
+  }
+  return lines.join("\n");
+}
+function formatWarning(warning) {
+  const cleaned = warning.replace(/^⚠\s*/, "");
+  return `  ${sym.warning} ${c.yellow(cleaned)}`;
+}
+function generate3(inputPath, outputPath) {
+  const start = performance.now();
+  header();
+  if (!fs.existsSync(inputPath)) {
+    err(`  ${sym.error} ${c.boldRed("File not found:")} ${c.cyan(inputPath)}`);
+    const similar = findSimilarFiles(inputPath);
+    if (similar.length > 0) {
+      blank();
+      err(`  ${c.dim("Did you mean?")}`);
+      similar.forEach((f) => {
+        err(`    ${sym.bullet} ${c.cyan(f)}`);
+      });
+    }
+    blank();
+    process.exit(1);
+  }
+  let doc;
+  try {
+    const raw = fs.readFileSync(inputPath, "utf8");
+    doc = JSON.parse(raw);
+  } catch (e) {
+    err(`  ${sym.error} ${c.boldRed("Invalid JSON")} in ${c.cyan(inputPath)}`);
+    blank();
+    if (e instanceof SyntaxError) {
+      const msg = e.message.replace(/^Unexpected/, "Unexpected");
+      err(`     ${c.red(msg)}`);
+    } else {
+      err(`     ${c.red(e.message)}`);
+    }
+    blank();
+    err(`  ${c.dim("Tip:")} Validate your JSON at ${c.cyan("https://jsonlint.com")}`);
+    blank();
+    process.exit(1);
+  }
+  const result = parseDocument(doc);
+  if (result.TAG !== "Ok") {
+    const errors = result._0;
+    const count = errors.length;
+    err(
+      `  ${sym.error} ${c.boldRed(`${count} parse error${count !== 1 ? "s" : ""}`)} in ${c.cyan(inputPath)}`
+    );
+    blank();
+    errors.forEach((error, i) => {
+      err(formatParseError(error, i));
+      if (i < errors.length - 1) blank();
+    });
+    blank();
+    process.exit(1);
+  }
+  const schemas = result._0;
+  const schemaCount = schemas.length;
+  log(`  ${sym.success} Parsed ${c.bold(String(schemaCount))} schema${schemaCount !== 1 ? "s" : ""} from ${c.cyan(inputPath)}`);
+  const genResult = generateModuleWithDiagnostics(schemas);
+  if (genResult.TAG !== "Ok") {
+    const errors = genResult._0;
+    const count = errors.length;
+    err(
+      `  ${sym.error} ${c.boldRed(`${count} codegen error${count !== 1 ? "s" : ""}`)} in ${c.cyan(inputPath)}`
+    );
+    blank();
+    errors.forEach((error, i) => {
+      err(formatParseError(error, i));
+      if (i < errors.length - 1) blank();
+    });
+    blank();
+    process.exit(1);
+  }
+  const { code, warnings } = genResult._0;
+  if (warnings.length > 0) {
+    blank();
+    warnings.forEach((w) => {
+      log(formatWarning(w));
+    });
+  }
+  const outputDir = path.dirname(outputPath);
+  if (outputDir && outputDir !== "." && !fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+  const typeCount = (code.match(/^type\s/gm) || []).length;
+  fs.writeFileSync(outputPath, code);
+  const dictShimPath = path.join(outputDir || ".", "Dict.gen.ts");
+  fs.writeFileSync(dictShimPath, generateDictShim2());
+  const jsonShimPath = path.join(outputDir || ".", "JSON.gen.ts");
+  fs.writeFileSync(jsonShimPath, generateJsonShim2());
+  const nullableResPath = path.join(outputDir || ".", "Nullable.res");
+  fs.writeFileSync(nullableResPath, generateNullableModule2());
+  const nullableShimPath = path.join(outputDir || ".", "Nullable.shim.ts");
+  fs.writeFileSync(nullableShimPath, generateNullableShim2());
+  blank();
+  log(`  ${sym.success} Generated ${c.bold(String(typeCount))} type${typeCount !== 1 ? "s" : ""}`);
+  blank();
+  log(`  ${c.dim("Files written:")}`);
+  log(`    ${sym.bullet} ${c.cyan(outputPath)} ${c.dim("(main module)")}`);
+  log(`    ${sym.bullet} ${c.cyan(dictShimPath)} ${c.dim("(TS shim)")}`);
+  log(`    ${sym.bullet} ${c.cyan(jsonShimPath)} ${c.dim("(TS shim)")}`);
+  log(`    ${sym.bullet} ${c.cyan(nullableResPath)} ${c.dim("(ReScript module)")}`);
+  log(`    ${sym.bullet} ${c.cyan(nullableShimPath)} ${c.dim("(TS shim)")}`);
+  blank();
+  log(`  ${c.dim(`Done in ${elapsed(start)}`)}`);
+  blank();
+}
+function parseDomainArgs(args) {
+  const options = {
+    config: "domain.config.json",
+    apiModule: "Api",
+    outputDir: "src/domains/"
+  };
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg === "-h" || arg === "--help") {
+      printHelp();
+      process.exit(0);
+    } else if (arg === "--config") {
+      i++;
+      if (i >= args.length) {
+        header();
+        err(`  ${sym.error} ${c.boldRed("Missing value for --config")}`);
+        blank();
+        process.exit(1);
+      }
+      options.config = args[i];
+    } else if (arg === "--api-module") {
+      i++;
+      if (i >= args.length) {
+        header();
+        err(`  ${sym.error} ${c.boldRed("Missing value for --api-module")}`);
+        blank();
+        process.exit(1);
+      }
+      options.apiModule = args[i];
+    } else if (arg === "-o" || arg === "--output") {
+      i++;
+      if (i >= args.length) {
+        header();
+        err(`  ${sym.error} ${c.boldRed("Missing value for --output")}`);
+        blank();
+        process.exit(1);
+      }
+      options.outputDir = args[i];
+    } else if (arg === "--no-color") {
+    }
+    i++;
+  }
+  return options;
+}
+function generateDomain(options) {
+  const start = performance.now();
+  header();
+  log(`  ${c.dim("Mode:")} domain module generation`);
+  blank();
+  if (!fs.existsSync(options.config)) {
+    err(`  ${sym.error} ${c.boldRed("Config not found:")} ${c.cyan(options.config)}`);
+    blank();
+    process.exit(1);
+  }
+  let configJson;
+  try {
+    const raw = fs.readFileSync(options.config, "utf8");
+    configJson = JSON.parse(raw);
+  } catch (e) {
+    err(`  ${sym.error} ${c.boldRed("Invalid JSON")} in ${c.cyan(options.config)}`);
+    blank();
+    if (e instanceof SyntaxError) {
+      err(`     ${c.red(e.message)}`);
+    } else {
+      err(`     ${c.red(e.message)}`);
+    }
+    blank();
+    process.exit(1);
+  }
+  const parseResult = parse2(configJson);
+  if (parseResult.TAG !== "Ok") {
+    const errors = parseResult._0;
+    const count = errors.length;
+    err(
+      `  ${sym.error} ${c.boldRed(`${count} config error${count !== 1 ? "s" : ""}`)} in ${c.cyan(options.config)}`
+    );
+    blank();
+    errors.forEach((error, i) => {
+      err(formatParseError(error, i));
+      if (i < errors.length - 1) blank();
+    });
+    blank();
+    process.exit(1);
+  }
+  const config = parseResult._0;
+  const moduleCount = config.modules.length;
+  log(`  ${sym.success} Parsed ${c.bold(String(moduleCount))} domain module${moduleCount !== 1 ? "s" : ""} from ${c.cyan(options.config)}`);
+  const modules = generate2(config, options.apiModule);
+  if (!fs.existsSync(options.outputDir)) {
+    fs.mkdirSync(options.outputDir, { recursive: true });
+  }
+  const writtenFiles = [];
+  modules.forEach((mod) => {
+    const code = printModule(mod);
+    const outputPath = path.join(options.outputDir, mod.output);
+    fs.writeFileSync(outputPath, code);
+    writtenFiles.push(outputPath);
+  });
+  blank();
+  log(`  ${sym.success} Generated ${c.bold(String(writtenFiles.length))} domain module${writtenFiles.length !== 1 ? "s" : ""}`);
+  blank();
+  log(`  ${c.dim("Files written:")}`);
+  writtenFiles.forEach((f) => {
+    log(`    ${sym.bullet} ${c.cyan(f)}`);
+  });
+  blank();
+  log(`  ${c.dim(`Done in ${elapsed(start)}`)}`);
+  blank();
+}
+var rawArgs = process.argv.slice(2);
+if (rawArgs[0] === "domain") {
+  const domainOptions = parseDomainArgs(rawArgs.slice(1));
+  generateDomain(domainOptions);
+} else {
+  const options = parseArgs(rawArgs);
+  if (!options.input) {
+    header();
+    err(`  ${sym.error} ${c.boldRed("No input file specified")}`);
+    blank();
+    err(`  ${c.dim("Usage:")} osury ${c.cyan("<input.json>")} ${c.dim("[output.res]")}`);
+    err(`  ${c.dim("Help:")}  osury ${c.cyan("--help")}`);
+    blank();
+    process.exit(1);
+  }
+  generate3(options.input, options.output);
+}