@openpkg-ts/sdk 0.54.11 → 0.55.1

package/dist/index.js

@@ -18,6 +18,11 @@ import {
   groupByVisibility,
   isMethod,
   isProperty,
+  isRequiredOnlyAnyOf,
+  normalizeExport,
+  normalizeMembers,
+  normalizeSchema,
+  normalizeType,
   query,
   resolveTypeRef,
   sortByName,
@@ -25,7 +30,7 @@ import {
   toPagefindRecords,
   toSearchIndex,
   toSearchIndexJSON
-} from "./shared/chunk-7287tqkx.js";
+} from "./shared/chunk-jfjmy1r0.js";
 
 // src/primitives/diff.ts
 import {
@@ -2111,17 +2116,41 @@ function getSourceLocation(node, sourceFile) {
     line: line + 1
   };
 }
+function bindingPatternKind(decl) {
+  if (!decl)
+    return;
+  if (ts2.isObjectBindingPattern(decl.name))
+    return "object";
+  if (ts2.isArrayBindingPattern(decl.name))
+    return "array";
+  return;
+}
+function destructuredParamName(kind, taken, jsdocName) {
+  if (jsdocName && !taken.has(jsdocName))
+    return jsdocName;
+  const base = kind === "object" ? "options" : "args";
+  if (!taken.has(base))
+    return base;
+  let i = 2;
+  while (taken.has(`${base}${i}`))
+    i++;
+  return `${base}${i}`;
+}
+function jsdocParamTagName(tag) {
+  if (tag.tagName.text !== "param")
+    return "";
+  const paramTag = tag;
+  try {
+    return paramTag.name?.getText() ?? "";
+  } catch {
+    return paramTag.name?.text ?? "";
+  }
+}
 function getParamDescription(propertyName, jsdocTags, inferredAlias) {
   for (const tag of jsdocTags) {
     if (tag.tagName.text !== "param")
       continue;
-    const paramTag = tag;
-    let tagParamName = "";
-    try {
-      tagParamName = paramTag.name?.getText() ?? "";
-    } catch {
-      tagParamName = paramTag.name?.text ?? "";
-    }
+    const tagParamName = jsdocParamTagName(tag);
     const isMatch = tagParamName === propertyName || inferredAlias && tagParamName === `${inferredAlias}.${propertyName}` || tagParamName.endsWith(`.${propertyName}`);
     if (isMatch) {
       const comment = typeof tag.comment === "string" ? tag.comment : ts2.getTextOfJSDocComment(tag.comment);
@@ -2873,6 +2902,23 @@ function declaredTypeNode(decl) {
   const withType = decl;
   return withType?.type;
 }
+function propertyTypeNode(prop) {
+  const decls = prop.getDeclarations() ?? [];
+  if (decls.length <= 1)
+    return declaredTypeNode(prop.valueDeclaration ?? decls[0]);
+  const nodes = decls.map(declaredTypeNode).filter((n) => n !== undefined);
+  const informative = nodes.filter((n) => n.kind !== ts5.SyntaxKind.NeverKeyword && n.kind !== ts5.SyntaxKind.UndefinedKeyword);
+  const [first, ...rest] = informative.length > 0 ? informative : nodes;
+  if (!first)
+    return;
+  try {
+    const text = (n) => n.getText().replace(/\s+/g, " ");
+    const firstText = text(first);
+    return rest.every((n) => text(n) === firstText) ? first : undefined;
+  } catch {
+    return;
+  }
+}
 function typeNodeOfSignature(sig) {
   const decl = sig.getDeclaration();
   if (!decl || !ts5.isFunctionLike(decl))
@@ -3014,7 +3060,7 @@ function decoratePropertySchema(schema, prop, propType, checker) {
   let result = obj;
   if (!derivable && !("x-ts-type" in obj)) {
     result = { ...result, "x-ts-type": text };
-    const declared = writtenTypeText(declaredTypeNode(decl));
+    const declared = writtenTypeText(propertyTypeNode(prop));
     if (declared && declared !== text && !PRIMITIVES.has(declared) && !("x-ts-declared" in obj)) {
       result = { ...result, "x-ts-declared": declared };
     }
@@ -3893,6 +3939,7 @@ function buildSchemaInternal(type, checker, ctx, typeNode) {
 function buildFunctionSchema(callSignatures, checker, ctx) {
   const buildSignatures = () => {
     const signatures = callSignatures.map((sig) => {
+      const taken = new Set(sig.getParameters().filter((p) => !bindingPatternKind(p.valueDeclaration)).map((p) => p.getName()));
       const params = sig.getParameters().flatMap((param) => {
         const decl = param.valueDeclaration;
         if (!decl)
@@ -3900,11 +3947,18 @@ function buildFunctionSchema(callSignatures, checker, ctx) {
         const paramType = checker.getTypeOfSymbolAtLocation(param, decl);
         const isOptional = !!decl?.questionToken || !!decl?.initializer;
         const effectiveType = isOptional ? stripUndefinedFromType(paramType, checker) : paramType;
+        const pattern = bindingPatternKind(decl);
+        let name = param.getName();
+        if (pattern) {
+          name = destructuredParamName(pattern, taken);
+          taken.add(name);
+        }
         return {
-          name: param.getName(),
+          name,
           schema: buildSchema(effectiveType, checker, ctx, decl.type),
           required: !isOptional && !decl.dotDotDotToken,
-          ...decl.dotDotDotToken ? { rest: true } : {}
+          ...decl.dotDotDotToken ? { rest: true } : {},
+          ...pattern ? { "x-ts-destructured": true } : {}
         };
       });
       const returnType = checker.getReturnTypeOfSignature(sig);
@@ -3945,8 +3999,7 @@ function buildObjectSchema(properties, checker, ctx, originalType) {
       const isOptionalProp = !!(prop.flags & ts5.SymbolFlags.Optional);
       const rawPropType = checker.getTypeOfSymbol(prop);
       const propType = isOptionalProp ? stripUndefinedFromType(rawPropType, checker) : rawPropType;
-      const decl = prop.valueDeclaration ?? prop.getDeclarations()?.[0];
-      let propSchema = buildSchema(propType, checker, ctx, declaredTypeNode(decl));
+      let propSchema = buildSchema(propType, checker, ctx, propertyTypeNode(prop));
       const docComment = prop.getDocumentationComment(checker);
       if (docComment.length > 0) {
         const description = docComment.map((c) => c.text).join(`
@@ -4505,121 +4558,206 @@ function extractParameters(signature, ctx) {
   const result = [];
   const signatureDecl = signature.getDeclaration();
   const jsdocTags = signatureDecl ? ts7.getJSDocTags(signatureDecl) : [];
+  const names = destructuredNames(signature.getParameters(), jsdocTags, checker);
   for (const param of signature.getParameters()) {
     const decl = param.valueDeclaration;
     if (!decl)
       continue;
     const defer = typeNodeDefersExpansion(decl.type, checker, ctx.program);
     const type = defer ? undefined : checker.getTypeOfSymbolAtLocation(param, decl);
-    if (decl && ts7.isObjectBindingPattern(decl.name)) {
-      const expandedParams = expandBindingPattern(decl, type ?? checker.getTypeOfSymbolAtLocation(param, decl), jsdocTags, ctx);
-      result.push(...expandedParams);
-    } else {
-      const isOptional = !!decl?.questionToken || !!decl?.initializer;
-      const isRest = !!decl.dotDotDotToken;
-      const paramName = param.getName();
-      const description = getParamDescription(paramName, jsdocTags);
-      const schema = defer ? buildSchemaFromTypeNode(decl.type, checker, ctx) : buildSchema(isOptional ? stripUndefinedFromType(type, checker) : type, checker, ctx, decl.type);
-      if (!defer && type) {
-        registerReferencedTypes(isOptional ? stripUndefinedFromType(type, checker) : type, ctx);
-      }
-      const paramResult = {
-        name: paramName,
-        schema,
-        required: !isOptional && !isRest,
-        ...isRest ? { rest: true } : {}
-      };
-      if (description) {
-        paramResult.description = description;
-        const inlineTags = parseInlineTags(description);
-        if (inlineTags)
-          paramResult.inlineTags = inlineTags;
-      }
-      if (decl.initializer) {
-        applyDefault(paramResult, decl.initializer);
-      }
-      result.push(paramResult);
-    }
-  }
-  return result;
-}
-function expandBindingPattern(paramDecl, paramType, jsdocTags, ctx) {
-  const { typeChecker: checker } = ctx;
-  const result = [];
-  const bindingPattern = paramDecl.name;
-  const allProperties = getEffectiveProperties(paramType, checker);
-  const inferredAlias = inferParamAlias(jsdocTags);
-  for (const element of bindingPattern.elements) {
-    if (!ts7.isBindingElement(element))
-      continue;
-    const propertyName = element.propertyName ? ts7.isIdentifier(element.propertyName) ? element.propertyName.text : element.propertyName.getText() : ts7.isIdentifier(element.name) ? element.name.text : element.name.getText();
-    const propSymbol = allProperties.get(propertyName);
-    if (!propSymbol)
-      continue;
-    const isOptional = !!(propSymbol.flags & ts7.SymbolFlags.Optional) || element.initializer !== undefined;
-    const propType = checker.getTypeOfSymbol(propSymbol);
-    const effectiveType = isOptional ? stripUndefinedFromType(propType, checker) : propType;
-    registerReferencedTypes(effectiveType, ctx);
-    const description = getParamDescription(propertyName, jsdocTags, inferredAlias);
-    const param = {
-      name: propertyName,
-      schema: buildSchema(effectiveType, checker, ctx, declaredTypeNode(propSymbol.valueDeclaration)),
-      required: !isOptional
+    const isOptional = !!decl.questionToken || !!decl.initializer;
+    const isRest = !!decl.dotDotDotToken;
+    const pattern = bindingPatternKind(decl);
+    const paramName = pattern ? names.get(param) ?? param.getName() : param.getName();
+    const description = getParamDescription(paramName, jsdocTags);
+    let schema = defer ? buildSchemaFromTypeNode(decl.type, checker, ctx) : buildSchema(isOptional ? stripUndefinedFromType(type, checker) : type, checker, ctx, decl.type);
+    if (!defer && type) {
+      registerReferencedTypes(isOptional ? stripUndefinedFromType(type, checker) : type, ctx);
+    }
+    if (pattern === "object") {
+      schema = resolvedObjectSchema(schema, param, decl, isOptional, ctx);
+    }
+    const paramResult = {
+      name: paramName,
+      schema,
+      required: !isOptional && !isRest,
+      ...isRest ? { rest: true } : {},
+      ...pattern ? { "x-ts-destructured": true } : {}
     };
     if (description) {
-      param.description = description;
+      paramResult.description = description;
       const inlineTags = parseInlineTags(description);
       if (inlineTags)
-        param.inlineTags = inlineTags;
+        paramResult.inlineTags = inlineTags;
     }
-    if (element.initializer) {
-      applyDefault(param, element.initializer);
+    if (decl.initializer) {
+      applyDefault(paramResult, decl.initializer);
     }
-    result.push(param);
+    if (pattern === "object") {
+      annotateBindingElements(decl.name, paramResult, jsdocTags);
+    }
+    result.push(paramResult);
   }
   return result;
 }
-function getEffectiveProperties(type, _checker) {
-  const properties = new Map;
-  if (type.isIntersection()) {
-    for (const subType of type.types) {
-      for (const prop of subType.getProperties()) {
-        properties.set(prop.getName(), prop);
-      }
+function destructuredNames(params, jsdocTags, checker) {
+  const names = new Map;
+  const taken = new Set;
+  const patterns = [];
+  for (const param of params) {
+    const decl = param.valueDeclaration;
+    const kind = bindingPatternKind(decl);
+    if (!kind || !decl) {
+      taken.add(param.getName());
+      continue;
     }
-  } else {
-    for (const prop of type.getProperties()) {
-      properties.set(prop.getName(), prop);
+    patterns.push({ symbol: param, decl, kind });
+  }
+  if (patterns.length === 0)
+    return names;
+  const tagNames = jsdocTags.map(jsdocParamTagName).filter((n) => n && !n.startsWith("__"));
+  if (tagNames.length === 0) {
+    for (const { symbol, kind } of patterns) {
+      const name = destructuredParamName(kind, taken);
+      taken.add(name);
+      names.set(symbol, name);
     }
+    return names;
   }
-  return properties;
-}
-function inferParamAlias(jsdocTags) {
-  const prefixes = [];
-  for (const tag of jsdocTags) {
-    if (tag.tagName.text !== "param")
+  const keys = new Set;
+  for (const { symbol, decl } of patterns) {
+    for (const element of decl.name.elements) {
+      const key = bindingElementKey(element);
+      if (key)
+        keys.add(key);
+    }
+    const type = checker.getTypeOfSymbolAtLocation(symbol, decl);
+    for (const prop of resolvedProperties(type, checker))
+      keys.add(prop.getName());
+  }
+  const candidates = [];
+  for (const tagName of tagNames) {
+    const [head, ...rest] = tagName.split(".");
+    if (taken.has(head))
       continue;
-    const tagText = typeof tag.comment === "string" ? tag.comment : ts7.getTextOfJSDocComment(tag.comment) ?? "";
-    const paramTag = tag;
-    const paramName = paramTag.name?.getText() ?? "";
-    if (paramName.includes(".")) {
-      const prefix = paramName.split(".")[0];
-      if (prefix && !prefix.startsWith("__")) {
-        prefixes.push(prefix);
-      }
-    } else if (tagText.includes(".")) {
-      const match = tagText.match(/^(\w+)\./);
-      if (match && !match[1].startsWith("__")) {
-        prefixes.push(match[1]);
+    if (rest.length === 0 && keys.has(head))
+      continue;
+    if (!candidates.includes(head))
+      candidates.push(head);
+  }
+  patterns.forEach(({ symbol, kind }, i) => {
+    const name = destructuredParamName(kind, taken, candidates[i]);
+    taken.add(name);
+    names.set(symbol, name);
+  });
+  return names;
+}
+function bindingElementKey(element) {
+  if (!ts7.isBindingElement(element) || element.dotDotDotToken)
+    return;
+  const key = element.propertyName ?? element.name;
+  if (ts7.isIdentifier(key))
+    return key.text;
+  if (ts7.isStringLiteral(key) || ts7.isNumericLiteral(key))
+    return key.text;
+  return;
+}
+function resolvedProperties(type, checker) {
+  const seen = new Map;
+  for (const arm of objectArms(type, checker)) {
+    for (const prop of armProperties(arm, checker)) {
+      const name = prop.getName();
+      const current = seen.get(name);
+      if (!current || isAbsentMarker(current, checker) && !isAbsentMarker(prop, checker)) {
+        seen.set(name, prop);
       }
     }
   }
-  if (prefixes.length === 0)
+  return [...seen.values()];
+}
+function isAbsentMarker(prop, checker) {
+  const type = stripUndefinedFromType(checker.getTypeOfSymbol(prop), checker);
+  return !!(type.flags & (ts7.TypeFlags.Never | ts7.TypeFlags.Undefined));
+}
+function armRequiredNames(arm, checker) {
+  return new Set(armProperties(arm, checker).filter((p) => !(p.flags & ts7.SymbolFlags.Optional)).map((p) => p.getName()));
+}
+var PRIMITIVE_LIKE = ts7.TypeFlags.StringLike | ts7.TypeFlags.NumberLike | ts7.TypeFlags.BigIntLike | ts7.TypeFlags.BooleanLike | ts7.TypeFlags.ESSymbolLike | ts7.TypeFlags.Void | ts7.TypeFlags.Undefined | ts7.TypeFlags.Null;
+function objectArms(type, checker) {
+  const arms = type.isUnion() ? type.types : [type];
+  return arms.filter((arm) => !(arm.flags & PRIMITIVE_LIKE) && armProperties(arm, checker).length > 0);
+}
+function armProperties(arm, checker) {
+  const own = checker.getPropertiesOfType(arm);
+  return own.length > 0 ? own : checker.getPropertiesOfType(checker.getApparentType(arm));
+}
+function resolvedObjectSchema(schema, param, decl, isOptional, ctx) {
+  if (typeof schema !== "object" || schema === null || Array.isArray(schema))
+    return schema;
+  const current = schema;
+  if (current.properties || current.$ref)
+    return schema;
+  const { typeChecker: checker } = ctx;
+  const raw = checker.getTypeOfSymbolAtLocation(param, decl);
+  const type = isOptional ? stripUndefinedFromType(raw, checker) : raw;
+  const arms = objectArms(type, checker);
+  if (arms.length === 0)
+    return schema;
+  const props = resolvedProperties(type, checker);
+  const resolved = buildObjectSchema(props, checker, ctx, type);
+  if (arms.length > 1) {
+    const perArm = arms.map((arm) => armRequiredNames(arm, checker));
+    const requiredInAll = new Set(props.map((p) => p.getName()).filter((name) => perArm.every((set) => set.has(name))));
+    const required = props.map((p) => p.getName()).filter((n) => requiredInAll.has(n));
+    if (required.length)
+      resolved.required = required;
+    else
+      delete resolved.required;
+    const emitted = new Set(Object.keys(resolved.properties));
+    const anyOf = perArmRequired(perArm, requiredInAll, emitted);
+    if (anyOf)
+      resolved.anyOf = anyOf;
+  }
+  resolved["x-ts-type"] = renderTypeText(type, checker, decl);
+  return resolved;
+}
+function perArmRequired(perArm, shared, emitted) {
+  const distinct = new Map;
+  for (const set of perArm) {
+    const extra = [...set].filter((name) => emitted.has(name) && !shared.has(name));
+    if (extra.length === 0)
+      return;
+    distinct.set(extra.join("\x00"), extra);
+  }
+  if (distinct.size < 2)
+    return;
+  return [...distinct.values()].map((required) => ({ required }));
+}
+function annotateBindingElements(pattern, param, jsdocTags) {
+  const schema = param.schema;
+  const properties = schema?.properties;
+  if (!properties)
     return;
-  const counts = new Map;
-  for (const p of prefixes)
-    counts.set(p, (counts.get(p) ?? 0) + 1);
-  return Array.from(counts.entries()).sort((a, b) => b[1] - a[1])[0]?.[0];
+  for (const element of pattern.elements) {
+    const propertyName = bindingElementKey(element);
+    if (!propertyName)
+      continue;
+    const prop = properties[propertyName];
+    if (!prop || typeof prop !== "object" || Array.isArray(prop))
+      continue;
+    const propSchema = prop;
+    const description = getParamDescription(propertyName, jsdocTags, param.name);
+    if (description && propSchema.description === undefined) {
+      propSchema.description = description;
+    }
+    if (element.initializer) {
+      const extracted = extractLiteralDefault(element.initializer);
+      if (extracted.literal)
+        propSchema.default = extracted.value;
+      else
+        propSchema["x-ts-default"] = extracted.text;
+    }
+  }
 }
 function extractLiteralDefault(initializer) {
   if (ts7.isStringLiteral(initializer)) {
@@ -5361,14 +5499,23 @@ function schemaFromTypeNode(node, ctx) {
 }
 function parametersFromAst(decl, ctx) {
   const jsdocTags = ts11.getJSDocTags(decl);
+  const taken = new Set(decl.parameters.flatMap((p) => ts11.isIdentifier(p.name) ? [p.name.text] : []));
   return decl.parameters.map((p) => {
-    const name = ts11.isIdentifier(p.name) ? p.name.text : p.name.getText();
+    const pattern = bindingPatternKind(p);
+    let name;
+    if (pattern) {
+      name = destructuredParamName(pattern, taken);
+      taken.add(name);
+    } else {
+      name = ts11.isIdentifier(p.name) ? p.name.text : p.name.getText();
+    }
     const isOptional = !!p.questionToken || !!p.initializer;
     const param = {
       name,
       schema: schemaFromTypeNode(p.type, ctx),
       required: !isOptional && !p.dotDotDotToken,
-      ...p.dotDotDotToken ? { rest: true } : {}
+      ...p.dotDotDotToken ? { rest: true } : {},
+      ...pattern ? { "x-ts-destructured": true } : {}
     };
     const description = getParamDescription(name, jsdocTags);
     if (description)
@@ -6063,543 +6210,6 @@ function serializeValue(name, node, symbol, jsdocNode, type, typeNode, ctx) {
   };
 }
 
-// src/types/schema-normalizer.ts
-import { JSON_SCHEMA_DRAFT } from "@openpkg-ts/spec";
-var TS_PRIMITIVE_NORMALIZATIONS = {
-  void: () => ({ type: "null", "x-ts-type": "void" }),
-  never: () => ({ not: {} }),
-  any: () => ({ "x-ts-type": "any" }),
-  unknown: () => ({ "x-ts-type": "unknown" }),
-  undefined: () => ({ type: "null", "x-ts-type": "undefined" }),
-  bigint: () => ({ type: "integer", "x-ts-type": "bigint" }),
-  symbol: () => ({ type: "string", "x-ts-type": "symbol" })
-};
-function normalizeSchema(schema, options = {}) {
-  const { includeSchemaField = false } = options;
-  const normalized = normalizeSchemaInternal(schema, options);
-  if (includeSchemaField && typeof normalized === "object") {
-    return {
-      $schema: JSON_SCHEMA_DRAFT,
-      ...normalized
-    };
-  }
-  return normalized;
-}
-function normalizeSchemaInternal(schema, options) {
-  const result = normalizeSchemaDispatch(schema, options);
-  if (schema && typeof schema === "object" && !Array.isArray(schema)) {
-    const s = schema;
-    if (s.deprecated === true && result.deprecated === undefined) {
-      result.deprecated = true;
-    }
-    if (s.readOnly === true && result.readOnly === undefined) {
-      result.readOnly = true;
-    }
-    for (const key of Object.keys(s)) {
-      if (key.startsWith("x-") && s[key] !== undefined && result[key] === undefined) {
-        result[key] = s[key];
-      }
-    }
-    if (Array.isArray(s.typeArguments) && s.typeArguments.length > 0 && result["x-ts-type-arguments"] === undefined) {
-      result["x-ts-type-arguments"] = s.typeArguments.map((arg) => normalizeSchemaInternal(arg, options));
-    }
-  }
-  return result;
-}
-function normalizeSchemaDispatch(schema, options) {
-  if (typeof schema === "string") {
-    return normalizeStringType(schema);
-  }
-  if (schema == null) {
-    return {};
-  }
-  if (typeof schema !== "object") {
-    return {};
-  }
-  if ("anyOf" in schema && Array.isArray(schema.anyOf)) {
-    return normalizeCombinator("anyOf", schema.anyOf, schema, options);
-  }
-  if ("allOf" in schema && Array.isArray(schema.allOf)) {
-    return normalizeCombinator("allOf", schema.allOf, schema, options);
-  }
-  if ("oneOf" in schema && Array.isArray(schema.oneOf)) {
-    return normalizeCombinator("oneOf", schema.oneOf, schema, options);
-  }
-  if ("$ref" in schema && typeof schema.$ref === "string") {
-    return normalizeRef(schema, options);
-  }
-  if ("type" in schema && typeof schema.type === "string") {
-    return normalizeTypedSchema(schema, options);
-  }
-  return normalizeGenericObject(schema, options);
-}
-function normalizeStringType(type) {
-  const specialNormalization = TS_PRIMITIVE_NORMALIZATIONS[type];
-  if (specialNormalization) {
-    return specialNormalization();
-  }
-  if (["string", "number", "boolean", "integer", "null", "object", "array"].includes(type)) {
-    return { type };
-  }
-  return { "x-ts-type": type };
-}
-function normalizeTypedSchema(schema, options) {
-  const { type } = schema;
-  const specialNormalization = TS_PRIMITIVE_NORMALIZATIONS[type];
-  if (specialNormalization) {
-    const normalized = specialNormalization();
-    return mergeSchemaFields(normalized, schema, ["type"]);
-  }
-  if (type === "function") {
-    return normalizeFunctionType(schema, options);
-  }
-  if (type === "tuple") {
-    return normalizeTupleType(schema, options);
-  }
-  if (type === "array") {
-    return normalizeArrayType(schema, options);
-  }
-  if (type === "object") {
-    return normalizeObjectType(schema, options);
-  }
-  if (["string", "number", "boolean", "integer", "null"].includes(type)) {
-    return normalizeStandardType(schema, options);
-  }
-  const result = { "x-ts-type": type };
-  return mergeSchemaFields(result, schema, ["type"]);
-}
-function normalizeFunctionType(schema, options) {
-  const result = {
-    "x-ts-function": true
-  };
-  if ("signatures" in schema && Array.isArray(schema.signatures)) {
-    result["x-ts-signatures"] = schema.signatures.map((sig) => normalizeSignature(sig, options));
-  }
-  if ("description" in schema && schema.description) {
-    result.description = schema.description;
-  }
-  return result;
-}
-function normalizeSignature(signature, options) {
-  const result = {};
-  if (signature.parameters) {
-    result.parameters = signature.parameters.map((param) => ({
-      name: param.name,
-      schema: normalizeSchemaInternal(param.schema, options),
-      ...param.required !== undefined ? { required: param.required } : {},
-      ...param.description ? { description: param.description } : {},
-      ...param.default !== undefined ? { default: param.default } : {},
-      ...param.rest ? { rest: param.rest } : {}
-    }));
-  }
-  if (signature.returns) {
-    result.returns = {
-      schema: normalizeSchemaInternal(signature.returns.schema, options),
-      ...signature.returns.description ? { description: signature.returns.description } : {}
-    };
-  }
-  if (signature.description) {
-    result.description = signature.description;
-  }
-  if (signature.typeParameters) {
-    result.typeParameters = signature.typeParameters;
-  }
-  return result;
-}
-function normalizeTupleType(schema, options) {
-  const result = { type: "array" };
-  const prefix = Array.isArray(schema.prefixItems) ? schema.prefixItems : Array.isArray(schema.prefixedItems) ? schema.prefixedItems : undefined;
-  if (prefix) {
-    result.prefixItems = prefix.map((item) => normalizeSchemaInternal(item, options));
-  } else if ("items" in schema && Array.isArray(schema.items)) {
-    result.prefixItems = schema.items.map((item) => normalizeSchemaInternal(item, options));
-    result.minItems = schema.items.length;
-    result.maxItems = schema.items.length;
-  }
-  if ("minItems" in schema && typeof schema.minItems === "number") {
-    result.minItems = schema.minItems;
-  }
-  if ("maxItems" in schema && typeof schema.maxItems === "number") {
-    result.maxItems = schema.maxItems;
-  }
-  if ("description" in schema && schema.description) {
-    result.description = schema.description;
-  }
-  return result;
-}
-function normalizeArrayType(schema, options) {
-  const result = { type: "array" };
-  if ("items" in schema && schema.items && !Array.isArray(schema.items)) {
-    result.items = normalizeSchemaInternal(schema.items, options);
-  }
-  const arrayPrefix = Array.isArray(schema.prefixItems) ? schema.prefixItems : Array.isArray(schema.prefixedItems) ? schema.prefixedItems : undefined;
-  if (arrayPrefix) {
-    result.prefixItems = arrayPrefix.map((item) => normalizeSchemaInternal(item, options));
-  }
-  if ("minItems" in schema && typeof schema.minItems === "number") {
-    result.minItems = schema.minItems;
-  }
-  if ("maxItems" in schema && typeof schema.maxItems === "number") {
-    result.maxItems = schema.maxItems;
-  }
-  if (schema.uniqueItems === true) {
-    result.uniqueItems = true;
-  }
-  if (schema.contains && typeof schema.contains === "object") {
-    result.contains = normalizeSchemaInternal(schema.contains, options);
-  }
-  for (const keyword of ["title", "default"]) {
-    if (keyword in schema && schema[keyword] !== undefined) {
-      result[keyword] = schema[keyword];
-    }
-  }
-  if ("description" in schema && schema.description) {
-    result.description = schema.description;
-  }
-  return result;
-}
-function normalizeObjectType(schema, options) {
-  const result = { type: "object" };
-  if ("properties" in schema && schema.properties) {
-    const properties = schema.properties;
-    result.properties = Object.fromEntries(Object.entries(properties).map(([key, value]) => [
-      key,
-      normalizeSchemaInternal(value, options)
-    ]));
-  }
-  if ("required" in schema && Array.isArray(schema.required)) {
-    result.required = schema.required;
-  }
-  if ("additionalProperties" in schema) {
-    if (typeof schema.additionalProperties === "boolean") {
-      result.additionalProperties = schema.additionalProperties;
-    } else if (schema.additionalProperties) {
-      result.additionalProperties = normalizeSchemaInternal(schema.additionalProperties, options);
-    }
-  }
-  for (const keyword of ["patternProperties", "$defs"]) {
-    const value = schema[keyword];
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-      result[keyword] = Object.fromEntries(Object.entries(value).map(([key, nested]) => [
-        key,
-        normalizeSchemaInternal(nested, options)
-      ]));
-    }
-  }
-  if (schema.propertyNames && typeof schema.propertyNames === "object") {
-    result.propertyNames = normalizeSchemaInternal(schema.propertyNames, options);
-  }
-  for (const keyword of ["title", "default", "examples", "minProperties", "maxProperties"]) {
-    if (keyword in schema && schema[keyword] !== undefined) {
-      result[keyword] = schema[keyword];
-    }
-  }
-  if ("description" in schema && schema.description) {
-    result.description = schema.description;
-  }
-  return result;
-}
-function normalizeStandardType(schema, options) {
-  const result = { type: schema.type };
-  const validationKeywords = [
-    "enum",
-    "const",
-    "format",
-    "pattern",
-    "minimum",
-    "maximum",
-    "exclusiveMinimum",
-    "exclusiveMaximum",
-    "multipleOf",
-    "minLength",
-    "maxLength",
-    "description",
-    "default",
-    "examples",
-    "title"
-  ];
-  for (const keyword of validationKeywords) {
-    if (keyword in schema && schema[keyword] !== undefined) {
-      result[keyword] = schema[keyword];
-    }
-  }
-  for (const key of Object.keys(schema)) {
-    if (key.startsWith("x-") && schema[key] !== undefined) {
-      const value = schema[key];
-      if (isSchemaLike(value)) {
-        result[key] = normalizeSchemaInternal(value, options);
-      } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-        result[key] = normalizeGenericObject(value, options);
-      } else {
-        result[key] = value;
-      }
-    }
-  }
-  return result;
-}
-function normalizeRef(schema, options) {
-  const result = { $ref: schema.$ref };
-  if (schema.typeArguments && schema.typeArguments.length > 0) {
-    result["x-ts-type-arguments"] = schema.typeArguments.map((arg) => normalizeSchemaInternal(arg, options));
-  }
-  for (const key of Object.keys(schema)) {
-    if (key.startsWith("x-ts-") && schema[key] !== undefined) {
-      result[key] = schema[key];
-    }
-  }
-  return result;
-}
-function normalizeCombinator(keyword, schemas, originalSchema, options) {
-  let branches = schemas.map((s) => normalizeSchemaInternal(s, options));
-  if (keyword !== "allOf") {
-    const seen = new Set;
-    branches = branches.filter((b) => {
-      const key = JSON.stringify(b);
-      if (seen.has(key))
-        return false;
-      seen.add(key);
-      return true;
-    });
-    if (branches.length === 1) {
-      const single = { ...branches[0] };
-      if ("description" in originalSchema && originalSchema.description && !single.description) {
-        single.description = originalSchema.description;
-      }
-      return single;
-    }
-  }
-  const result = { [keyword]: branches };
-  if ((keyword === "anyOf" || keyword === "oneOf") && "discriminator" in originalSchema && originalSchema.discriminator) {
-    result.discriminator = originalSchema.discriminator;
-  }
-  if ("description" in originalSchema && originalSchema.description) {
-    result.description = originalSchema.description;
-  }
-  return result;
-}
-function normalizeGenericObject(schema, options) {
-  const result = {};
-  for (const [key, value] of Object.entries(schema)) {
-    if (value == null)
-      continue;
-    if (isSchemaLike(value)) {
-      result[key] = normalizeSchemaInternal(value, options);
-    } else if (Array.isArray(value)) {
-      result[key] = value.map((item) => isSchemaLike(item) ? normalizeSchemaInternal(item, options) : item);
-    } else if (typeof value === "object") {
-      result[key] = normalizeGenericObject(value, options);
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-function isSchemaLike(value) {
-  if (typeof value !== "object" || value == null)
-    return false;
-  if (typeof value === "string")
-    return true;
-  const obj = value;
-  return "type" in obj || "$ref" in obj || "anyOf" in obj || "allOf" in obj || "oneOf" in obj || "properties" in obj || "items" in obj || "prefixItems" in obj || "prefixedItems" in obj;
-}
-function mergeSchemaFields(target, source, excludeKeys) {
-  if (typeof source !== "object" || source == null) {
-    return target;
-  }
-  const excludeSet = new Set(excludeKeys);
-  const result = { ...target };
-  for (const [key, value] of Object.entries(source)) {
-    if (!excludeSet.has(key) && value !== undefined) {
-      if (!(key in result)) {
-        result[key] = value;
-      }
-    }
-  }
-  return result;
-}
-function isVendorSchemaExport(exp) {
-  return !!exp.tags?.some((t) => t.name === "schema-source" && t.text === "standard-json-schema");
-}
-function normalizeExport(exp, options = {}) {
-  const result = { ...exp };
-  const vendorSchema = isVendorSchemaExport(exp);
-  if (exp.schema && !vendorSchema) {
-    result.schema = normalizeSchema(exp.schema, options);
-  }
-  if (exp.signatures) {
-    result.signatures = exp.signatures.map((sig) => normalizeSignatureSpec(sig, options));
-  }
-  if (exp.members) {
-    result.members = exp.members.map((member) => normalizeMember(member, options));
-  }
-  if (!vendorSchema && shouldGenerateMembersSchema(exp.kind) && exp.members && exp.members.length > 0) {
-    result.schema = withOpenArms(normalizeMembers(exp.members, options), result.schema);
-  }
-  return result;
-}
-function withOpenArms(membersSchema, provided) {
-  const arms = provided?.allOf;
-  return Array.isArray(arms) ? { allOf: [membersSchema, ...arms] } : membersSchema;
-}
-function normalizeType(type, options = {}) {
-  const result = { ...type };
-  if (type.schema) {
-    result.schema = normalizeSchema(type.schema, options);
-  }
-  if (type.members) {
-    result.members = type.members.map((member) => normalizeMember(member, options));
-  }
-  if (shouldGenerateMembersSchema(type.kind) && type.members && type.members.length > 0) {
-    result.schema = withOpenArms(normalizeMembers(type.members, options), result.schema);
-  }
-  return result;
-}
-function shouldGenerateMembersSchema(kind) {
-  return kind === "interface" || kind === "class";
-}
-function normalizeSignatureSpec(signature, options) {
-  const result = { ...signature };
-  if (signature.parameters) {
-    result.parameters = signature.parameters.map((param) => ({
-      ...param,
-      schema: normalizeSchema(param.schema, options)
-    }));
-  }
-  if (signature.returns) {
-    result.returns = {
-      ...signature.returns,
-      schema: normalizeSchema(signature.returns.schema, options)
-    };
-  }
-  return result;
-}
-function normalizeMember(member, options) {
-  const result = { ...member };
-  if (member.schema) {
-    result.schema = normalizeSchema(member.schema, options);
-  }
-  if (member.signatures) {
-    result.signatures = member.signatures.map((sig) => normalizeSignatureSpec(sig, options));
-  }
-  return result;
-}
-function normalizeMembers(members, options = {}) {
-  const properties = {};
-  const required = [];
-  let additionalProperties;
-  let numberIndexSchema;
-  for (const member of members) {
-    const { name, kind } = member;
-    if (kind === "index" || kind === "index-signature") {
-      if (name === "[number]") {
-        numberIndexSchema = normalizeMemberToSchema(member, options);
-      } else {
-        additionalProperties = normalizeMemberToSchema(member, options);
-      }
-      continue;
-    }
-    if (!name)
-      continue;
-    const memberSchema = normalizeMemberToSchema(member, options);
-    properties[name] = memberSchema;
-    if (!isOptionalMember(member)) {
-      required.push(name);
-    }
-  }
-  const result = {
-    type: "object",
-    properties
-  };
-  if (required.length > 0) {
-    result.required = required;
-  }
-  if (additionalProperties !== undefined) {
-    result.additionalProperties = additionalProperties;
-  }
-  if (numberIndexSchema !== undefined) {
-    result.patternProperties = { "^\\d+$": numberIndexSchema };
-    result["x-ts-index-key"] = "number";
-  }
-  return result;
-}
-function memberDocExtras(member) {
-  const extras = {};
-  if (member.description) {
-    extras.description = member.description;
-  }
-  if (member.flags?.readonly === true) {
-    extras.readOnly = true;
-  }
-  if (member.deprecated) {
-    extras.deprecated = true;
-    const reason = member.deprecationReason ?? member.tags?.find((t) => t.name === "deprecated")?.text;
-    if (reason?.trim()) {
-      extras["x-deprecated-reason"] = reason;
-    }
-  }
-  return extras;
-}
-function normalizeMemberToSchema(member, options) {
-  const { kind, schema, signatures } = member;
-  if (kind === "method" || kind === "call-signature") {
-    return normalizeMethodMember(member, options);
-  }
-  if (kind === "getter") {
-    const baseSchema2 = schema ? normalizeSchemaInternal(schema, options) : {};
-    return {
-      ...baseSchema2,
-      "x-ts-accessor": "getter",
-      ...memberDocExtras(member)
-    };
-  }
-  if (kind === "setter") {
-    const baseSchema2 = schema ? normalizeSchemaInternal(schema, options) : {};
-    return {
-      ...baseSchema2,
-      "x-ts-accessor": "setter",
-      ...memberDocExtras(member)
-    };
-  }
-  if (kind === "index" || kind === "index-signature") {
-    if (schema && typeof schema === "object" && "additionalProperties" in schema) {
-      return normalizeSchemaInternal(schema.additionalProperties, options);
-    }
-    return schema ? normalizeSchemaInternal(schema, options) : {};
-  }
-  if (signatures && signatures.length > 0) {
-    return normalizeMethodMember(member, options);
-  }
-  const baseSchema = schema ? normalizeSchemaInternal(schema, options) : {};
-  const extras = memberDocExtras(member);
-  return Object.keys(extras).length > 0 ? { ...baseSchema, ...extras } : baseSchema;
-}
-function normalizeMethodMember(member, options) {
-  const result = {
-    "x-ts-function": true
-  };
-  if (member.flags?.methodSyntax === true) {
-    result["x-ts-method"] = true;
-  }
-  const memberTypeText = member.schema && typeof member.schema === "object" ? member.schema["x-ts-type"] : undefined;
-  if (typeof memberTypeText === "string") {
-    result["x-ts-type"] = memberTypeText;
-  }
-  if (member.signatures && member.signatures.length > 0) {
-    result["x-ts-signatures"] = member.signatures.map((sig) => normalizeSignature(sig, options));
-  }
-  Object.assign(result, memberDocExtras(member));
-  return result;
-}
-function isOptionalMember(member) {
-  if (member.flags?.optional === true) {
-    return true;
-  }
-  if (member.name?.endsWith("?")) {
-    return true;
-  }
-  return false;
-}
-
 // src/primitives/get.ts
 async function getExport(options) {
   const { entryFile, exportName, baseDir, content, maxTypeDepth } = options;
@@ -8966,7 +8576,7 @@ import {
   validateSpec as validateSpec2
 } from "@openpkg-ts/spec";
 // src/schema/json-schema.ts
-import { JSON_SCHEMA_DRAFT as JSON_SCHEMA_DRAFT2 } from "@openpkg-ts/spec";
+import { JSON_SCHEMA_DRAFT } from "@openpkg-ts/spec";
 
 // src/schema/ref-walker.ts
 var INTERNAL_REF_PREFIX = "#/types/";
@@ -9102,7 +8712,7 @@ function exportToJsonSchema(subject, spec, options = {}) {
   if (Object.keys(defs).length > 0)
     doc.$defs = defs;
   if (includeSchemaField)
-    return { $schema: JSON_SCHEMA_DRAFT2, ...doc };
+    return { $schema: JSON_SCHEMA_DRAFT, ...doc };
   return doc;
 }
 function toJsonSchema(spec, options = {}) {
@@ -9139,7 +8749,7 @@ function toJsonSchema(spec, options = {}) {
   }
   const doc = { $defs: defs };
   if (includeSchemaField)
-    return { $schema: JSON_SCHEMA_DRAFT2, ...doc };
+    return { $schema: JSON_SCHEMA_DRAFT, ...doc };
   return doc;
 }
 
@@ -9514,6 +9124,7 @@ export {
   isSymbolDeprecated,
   isStandardJSONSchema,
   isSchemaType,
+  isRequiredOnlyAnyOf,
   isRemoteInput,
   isReadonlyPropertySymbol,
   isPureRefSchema,