@openpkg-ts/sdk 0.46.0 → 0.47.0

package/dist/index.js

@@ -1848,9 +1848,13 @@ import ts4 from "typescript";
 
 // src/types/schema-builder.ts
 import ts3 from "typescript";
+
+// src/schema/builtins.ts
 var BUILTIN_TYPE_SCHEMAS = {
+  Array: { type: "array" },
+  ReadonlyArray: { type: "array" },
   Date: { type: "string", format: "date-time" },
-  RegExp: { type: "object", description: "RegExp" },
+  RegExp: { type: "object" },
   Error: { type: "object" },
   Promise: { type: "object" },
   Map: { type: "object" },
@@ -1860,6 +1864,7 @@ var BUILTIN_TYPE_SCHEMAS = {
   Function: { type: "object" },
   ArrayBuffer: { type: "string", format: "binary" },
   ArrayBufferLike: { type: "string", format: "binary" },
+  SharedArrayBuffer: { type: "string", format: "binary" },
   DataView: { type: "string", format: "binary" },
   Uint8Array: { type: "string", format: "byte" },
   Uint16Array: { type: "string", format: "byte" },
@@ -1872,6 +1877,32 @@ var BUILTIN_TYPE_SCHEMAS = {
   BigInt64Array: { type: "string", format: "byte" },
   BigUint64Array: { type: "string", format: "byte" }
 };
+
+// src/types/schema-builder.ts
+function escapeRegex(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildTemplatePattern(type) {
+  const slotPattern = (slot) => {
+    if (slot.flags & ts3.TypeFlags.NumberLike)
+      return "-?\\d+(?:\\.\\d+)?";
+    if (slot.flags & ts3.TypeFlags.BigIntLike)
+      return "-?\\d+";
+    if (slot.flags & ts3.TypeFlags.BooleanLike)
+      return "(?:true|false)";
+    return ".*";
+  };
+  let pattern = `^${escapeRegex(type.texts[0] ?? "")}`;
+  type.types.forEach((slot, i) => {
+    pattern += slotPattern(slot) + escapeRegex(type.texts[i + 1] ?? "");
+  });
+  return `${pattern}$`;
+}
+function builtinSchema(name) {
+  const schema = { ...BUILTIN_TYPE_SCHEMAS[name] ?? { type: "object" } };
+  setSchemaExtension(schema, "x-ts-type", name);
+  return schema;
+}
 function setSchemaExtension(schema, key, value) {
   schema[key] = value;
 }
@@ -2169,9 +2200,15 @@ function buildSchema(type, checker, ctx) {
   return ensureNonEmptySchema(schema, type, checker);
 }
 function buildMaxDepthSchema(type, checker) {
+  if (type.flags & ts3.TypeFlags.TypeParameter && type.isThisType !== true) {
+    return { "x-ts-type": checker.typeToString(type) };
+  }
   const symbol = type.getSymbol() || type.aliasSymbol;
   if (symbol && !isAnonymous(type)) {
     const name = symbol.getName();
+    if (BUILTIN_TYPES.has(name) || isBuiltinGeneric(name)) {
+      return builtinSchema(name);
+    }
     if (!name.startsWith("__") && !isPrimitiveName(name)) {
       return { $ref: `#/types/${name}` };
     }
@@ -2188,6 +2225,13 @@ function buildMaxDepthSchema(type, checker) {
     return { type: "null" };
   if (type.flags & ts3.TypeFlags.Void)
     return { type: "void" };
+  if (type.flags & ts3.TypeFlags.TemplateLiteral) {
+    return {
+      type: "string",
+      pattern: buildTemplatePattern(type),
+      "x-ts-type": renderTypeText(type, checker)
+    };
+  }
   if (type.isUnion()) {
     const schemas = type.types.map((t) => buildMaxDepthSchema(t, checker));
     return { anyOf: schemas };
@@ -2209,7 +2253,11 @@ function buildSchemaInternal(type, checker, ctx) {
     }
     const symbol = type.getSymbol() || type.aliasSymbol;
     if (symbol && !isAnonymous(type)) {
-      return { $ref: `#/types/${symbol.getName()}` };
+      const name = symbol.getName();
+      if (BUILTIN_TYPES.has(name) || isBuiltinGeneric(name)) {
+        return builtinSchema(name);
+      }
+      return { $ref: `#/types/${name}` };
     }
     return { type: checker.typeToString(type) };
   }
@@ -2250,6 +2298,9 @@ function buildSchemaInternal(type, checker, ctx) {
         };
       }
     }
+    if (type.flags & ts3.TypeFlags.TypeParameter) {
+      return { "x-ts-type": checker.typeToString(type) };
+    }
     if (type.flags & ts3.TypeFlags.StringLiteral) {
       const literal = type.value;
       return { type: "string", enum: [literal] };
@@ -2273,6 +2324,16 @@ function buildSchemaInternal(type, checker, ctx) {
         return schema;
       }
     }
+    if (type.flags & ts3.TypeFlags.TemplateLiteral) {
+      return {
+        type: "string",
+        pattern: buildTemplatePattern(type),
+        "x-ts-type": renderTypeText(type, checker)
+      };
+    }
+    if (type.flags & ts3.TypeFlags.StringMapping) {
+      return { type: "string", "x-ts-type": renderTypeText(type, checker) };
+    }
     if (type.isUnion()) {
       const types = type.types;
       const allStringLiterals = types.every((t) => t.flags & ts3.TypeFlags.StringLiteral);
@@ -2285,12 +2346,23 @@ function buildSchemaInternal(type, checker, ctx) {
         const enumValues = types.map((t) => t.value);
         return { type: "number", enum: enumValues };
       }
+      const allBooleanLiterals = types.every((t) => t.flags & ts3.TypeFlags.BooleanLiteral);
+      if (allBooleanLiterals) {
+        return { type: "boolean" };
+      }
+      const isBoolLiteral = (t) => !!(t.flags & ts3.TypeFlags.BooleanLiteral);
+      let members = types;
+      if (types.filter(isBoolLiteral).length === 2) {
+        const firstBool = types.findIndex(isBoolLiteral);
+        members = types.filter((t, i) => !isBoolLiteral(t) || i === firstBool);
+      }
+      const buildBranch = (t) => isBoolLiteral(t) ? { type: "boolean" } : buildSchema(t, checker, ctx);
       if (ctx) {
         return withDepth(ctx, () => ({
-          anyOf: types.map((t) => buildSchema(t, checker, ctx))
+          anyOf: members.map(buildBranch)
         }));
       }
-      return { anyOf: types.map((t) => buildSchema(t, checker, ctx)) };
+      return { anyOf: members.map(buildBranch) };
     }
     const isIntersectionType = type.isIntersection() || !!(type.flags & ts3.TypeFlags.Intersection);
     if (isIntersectionType && "types" in type) {
@@ -2311,7 +2383,7 @@ function buildSchemaInternal(type, checker, ctx) {
     }
     const typeString = checker.typeToString(type);
     if (typeString === "never[]" || typeString === "[]") {
-      return { type: "array", prefixedItems: [], minItems: 0, maxItems: 0 };
+      return { type: "array", prefixItems: [], minItems: 0, maxItems: 0 };
     }
     const symbol = type.getSymbol() || type.aliasSymbol;
     if (symbol?.getName() === "Array" && isBuiltinSymbol(symbol)) {
@@ -2348,7 +2420,7 @@ function buildSchemaInternal(type, checker, ctx) {
           try {
             return {
               type: "array",
-              prefixedItems: elementTypes.map((t) => buildSchema(t, checker, ctx)),
+              prefixItems: elementTypes.map((t) => buildSchema(t, checker, ctx)),
               minItems: elementTypes.length,
               maxItems: elementTypes.length
             };
@@ -2359,7 +2431,7 @@ function buildSchemaInternal(type, checker, ctx) {
       }
       return {
         type: "array",
-        prefixedItems: elementTypes.map((t) => buildSchema(t, checker, ctx)),
+        prefixItems: elementTypes.map((t) => buildSchema(t, checker, ctx)),
         minItems: elementTypes.length,
         maxItems: elementTypes.length
       };
@@ -2370,9 +2442,16 @@ function buildSchemaInternal(type, checker, ctx) {
       const symbol2 = typeRef.target.getSymbol();
       const name = symbol2?.getName();
       if (name && BUILTIN_TYPES.has(name)) {
-        return { $ref: `#/types/${name}` };
+        return builtinSchema(name);
       }
-      if (name && (isBuiltinGeneric(name) || !isAnonymous(typeRef.target))) {
+      if (name && isBuiltinGeneric(name)) {
+        const build = () => ({
+          ...builtinSchema(name),
+          typeArguments: typeArgs.map((t) => buildSchema(t, checker, ctx))
+        });
+        return ctx ? withDepth(ctx, build) : build();
+      }
+      if (name && !isAnonymous(typeRef.target)) {
         const packageOrigin = getTypeOrigin(typeRef.target, checker);
         if (ctx) {
           return withDepth(ctx, () => {
@@ -2401,7 +2480,7 @@ function buildSchemaInternal(type, checker, ctx) {
     if (aliasSymbol && aliasTypeArgs && aliasTypeArgs.length > 0) {
       const name = aliasSymbol.getName();
       if (BUILTIN_TYPES.has(name)) {
-        return { $ref: `#/types/${name}` };
+        return builtinSchema(name);
       }
       if (RESOLVED_UTILITY_TYPES.has(name) && type.flags & ts3.TypeFlags.Object) {
         const props = type.getProperties();
@@ -2410,7 +2489,14 @@ function buildSchemaInternal(type, checker, ctx) {
           return buildObjectSchema(props, checker, ctx, type);
         }
       }
-      if (isBuiltinGeneric(name) || !name.startsWith("__")) {
+      if (isBuiltinGeneric(name)) {
+        const build = () => ({
+          ...builtinSchema(name),
+          typeArguments: aliasTypeArgs.map((t) => buildSchema(t, checker, ctx))
+        });
+        return ctx ? withDepth(ctx, build) : build();
+      }
+      if (!name.startsWith("__")) {
         const packageOrigin = getTypeOrigin(type, checker);
         if (ctx) {
           return withDepth(ctx, () => {
@@ -2446,7 +2532,10 @@ function buildSchemaInternal(type, checker, ctx) {
         return { type: name };
       }
       if (BUILTIN_TYPES.has(name)) {
-        return { $ref: `#/types/${name}` };
+        return builtinSchema(name);
+      }
+      if (isBuiltinGeneric(name) && isBuiltinSymbol(symbol)) {
+        return builtinSchema(name);
       }
       if (!name.startsWith("__")) {
         const packageOrigin = getTypeOrigin(type, checker);
@@ -2460,7 +2549,7 @@ function buildSchemaInternal(type, checker, ctx) {
     if (type.flags & ts3.TypeFlags.Object) {
       const objectType = type;
       const properties = type.getProperties();
-      if (properties.length > 0 || objectType.objectFlags & ts3.ObjectFlags.Anonymous) {
+      if (properties.length > 0 || objectType.objectFlags & ts3.ObjectFlags.Anonymous || checker.getIndexInfosOfType(type).length > 0) {
         return buildObjectSchema(properties, checker, ctx, type);
       }
     }
@@ -2480,9 +2569,10 @@ function buildFunctionSchema(callSignatures, checker, ctx) {
           return [];
         const paramType = checker.getTypeOfSymbolAtLocation(param, decl);
         const isOptional = !!decl?.questionToken || !!decl?.initializer;
+        const effectiveType = isOptional ? stripUndefinedFromType(paramType, checker) : paramType;
         return {
           name: param.getName(),
-          schema: buildSchema(paramType, checker, ctx),
+          schema: buildSchema(effectiveType, checker, ctx),
           required: !isOptional
         };
       });
@@ -2503,6 +2593,8 @@ function buildFunctionSchema(callSignatures, checker, ctx) {
 }
 function buildObjectSchema(properties, checker, ctx, originalType) {
   const isArrayLikeType = originalType ? checker.isArrayType(originalType) || checker.isTupleType(originalType) || originalType.symbol?.getName() === "Array" && isBuiltinSymbol(originalType.symbol) : false;
+  const isStringLikeType = !!(originalType && originalType.flags & ts3.TypeFlags.StringLike);
+  const isNumberLikeType = !!(originalType && originalType.flags & ts3.TypeFlags.NumberLike);
   const buildProps = () => {
     const props = {};
     const required = [];
@@ -2513,7 +2605,15 @@ function buildObjectSchema(properties, checker, ctx, originalType) {
       if (isArrayLikeType && ARRAY_PROTOTYPE_METHODS.has(propName)) {
         continue;
       }
-      const propType = checker.getTypeOfSymbol(prop);
+      if (isStringLikeType && STRING_PROTOTYPE_METHODS.has(propName)) {
+        continue;
+      }
+      if (isNumberLikeType && NUMBER_PROTOTYPE_METHODS.has(propName)) {
+        continue;
+      }
+      const isOptionalProp = !!(prop.flags & ts3.SymbolFlags.Optional);
+      const rawPropType = checker.getTypeOfSymbol(prop);
+      const propType = isOptionalProp ? stripUndefinedFromType(rawPropType, checker) : rawPropType;
       let propSchema = buildSchema(propType, checker, ctx);
       const docComment = prop.getDocumentationComment(checker);
       if (docComment.length > 0) {
@@ -2538,11 +2638,19 @@ function buildObjectSchema(properties, checker, ctx, originalType) {
       properties: props,
       ...required.length > 0 ? { required } : {}
     };
-    const stringIndex = originalType ? checker.getIndexInfosOfType(originalType).find((i) => i.keyType.flags & ts3.TypeFlags.String) : undefined;
+    const indexInfos = originalType ? checker.getIndexInfosOfType(originalType) : [];
+    const stringIndex = indexInfos.find((i) => i.keyType.flags & ts3.TypeFlags.String);
     if (stringIndex) {
       schema.additionalProperties = buildSchema(stringIndex.type, checker, ctx);
     }
-    if (Object.keys(props).length === 0 && originalType && !stringIndex) {
+    const numberIndex = indexInfos.find((i) => i.keyType.flags & ts3.TypeFlags.Number);
+    if (numberIndex) {
+      schema.patternProperties = {
+        "^\\d+$": buildSchema(numberIndex.type, checker, ctx)
+      };
+      setSchemaExtension(schema, "x-ts-index-key", "number");
+    }
+    if (Object.keys(props).length === 0 && originalType && !stringIndex && !numberIndex) {
       setSchemaExtension(schema, "x-ts-type", checker.typeToString(originalType));
     }
     return schema;
@@ -2701,6 +2809,9 @@ function extractParameters(signature, ctx) {
       if (description) {
         paramResult.description = description;
       }
+      if (decl.initializer) {
+        applyDefault(paramResult, decl.initializer);
+      }
       result.push(paramResult);
     }
   }
@@ -2733,7 +2844,7 @@ function expandBindingPattern(paramDecl, paramType, jsdocTags, ctx) {
       param.description = description;
     }
     if (element.initializer) {
-      param.default = extractDefaultValue(element.initializer);
+      applyDefault(param, element.initializer);
     }
     result.push(param);
   }
@@ -2781,23 +2892,37 @@ function inferParamAlias(jsdocTags) {
     counts.set(p, (counts.get(p) ?? 0) + 1);
   return Array.from(counts.entries()).sort((a, b) => b[1] - a[1])[0]?.[0];
 }
-function extractDefaultValue(initializer) {
+function extractLiteralDefault(initializer) {
   if (ts4.isStringLiteral(initializer)) {
-    return initializer.text;
+    return { literal: true, value: initializer.text };
   }
   if (ts4.isNumericLiteral(initializer)) {
-    return Number(initializer.text);
+    return { literal: true, value: Number(initializer.text) };
+  }
+  if (ts4.isPrefixUnaryExpression(initializer) && initializer.operator === ts4.SyntaxKind.MinusToken && ts4.isNumericLiteral(initializer.operand)) {
+    return { literal: true, value: -Number(initializer.operand.text) };
   }
   if (initializer.kind === ts4.SyntaxKind.TrueKeyword) {
-    return true;
+    return { literal: true, value: true };
   }
   if (initializer.kind === ts4.SyntaxKind.FalseKeyword) {
-    return false;
+    return { literal: true, value: false };
   }
   if (initializer.kind === ts4.SyntaxKind.NullKeyword) {
-    return null;
+    return { literal: true, value: null };
+  }
+  return { literal: false, text: initializer.getText() };
+}
+function applyDefault(param, initializer) {
+  const extracted = extractLiteralDefault(initializer);
+  if (extracted.literal) {
+    param.default = extracted.value;
+    if (param.schema && typeof param.schema === "object" && !Array.isArray(param.schema)) {
+      param.schema.default = extracted.value;
+    }
+  } else if (param.schema && typeof param.schema === "object" && !Array.isArray(param.schema)) {
+    param.schema["x-ts-default"] = extracted.text;
   }
-  return initializer.getText();
 }
 function registerReferencedTypes(type, ctx, depth = 0) {
   if (depth > ctx.maxTypeDepth)
@@ -2826,6 +2951,10 @@ function registerReferencedTypes(type, ctx, depth = 0) {
       registerReferencedTypes(t, ctx, depth + 1);
     }
   }
+  const typeSymbol = type.aliasSymbol ?? type.getSymbol();
+  if (typeSymbol && ctx.shouldExpandExternal && !typeSymbol.getName().startsWith("__") && !ctx.shouldExpandExternal(typeSymbol)) {
+    return;
+  }
   if (type.flags & ts4.TypeFlags.Object) {
     const props = type.getProperties();
     const limit = ctx.maxProperties;
@@ -2960,6 +3089,16 @@ class TypeRegistry {
       return;
     if (this.has(name))
       return name;
+    if (ctx.shouldExpandExternal && !ctx.shouldExpandExternal(symbol)) {
+      this.add({
+        id: name,
+        name,
+        kind: "external",
+        external: true,
+        schema: { "x-ts-type": renderTypeText(type, ctx.typeChecker) }
+      });
+      return name;
+    }
     if (this.processing.has(name))
       return name;
     this.processing.add(name);
@@ -3062,7 +3201,7 @@ class TypeRegistry {
       const elementTypes = checker.getTypeArguments(type) ?? [];
       return {
         type: "array",
-        prefixedItems: elementTypes.map((t) => buildSchema(t, checker, ctx)),
+        prefixItems: elementTypes.map((t) => buildSchema(t, checker, ctx)),
         minItems: elementTypes.length,
         maxItems: elementTypes.length
       };
@@ -3071,6 +3210,9 @@ class TypeRegistry {
       const elementType = checker.getTypeArguments(type)?.[0];
       return elementType ? { type: "array", items: buildSchema(elementType, checker, ctx) } : { type: "array" };
     }
+    if (type.flags & ts5.TypeFlags.Conditional) {
+      return { "x-ts-type": renderTypeText(type, checker) };
+    }
     return this.buildObjectSchemaFromProperties(type, checker, ctx);
   }
   buildEnumSchema(symbol, checker) {
@@ -3100,8 +3242,10 @@ class TypeRegistry {
   }
   buildObjectSchemaFromProperties(type, checker, ctx) {
     const properties = type.getProperties();
-    const stringIndex = checker.getIndexInfosOfType(type).find((i) => i.keyType.flags & ts5.TypeFlags.String);
-    if (properties.length === 0 && !stringIndex) {
+    const indexInfos = checker.getIndexInfosOfType(type);
+    const stringIndex = indexInfos.find((i) => i.keyType.flags & ts5.TypeFlags.String);
+    const numberIndex = indexInfos.find((i) => i.keyType.flags & ts5.TypeFlags.Number);
+    if (properties.length === 0 && !stringIndex && !numberIndex) {
       return { type: checker.typeToString(type) };
     }
     const props = {};
@@ -3128,7 +3272,8 @@ class TypeRegistry {
     }
     for (const prop of included.slice(0, limit)) {
       const propName = prop.getName();
-      const propType = checker.getTypeOfSymbol(prop);
+      const rawPropType = checker.getTypeOfSymbol(prop);
+      const propType = prop.flags & ts5.SymbolFlags.Optional ? stripUndefinedFromType(rawPropType, checker) : rawPropType;
       this.registerType(propType, ctx);
       let propSchema = buildSchema(propType, checker, ctx);
       const docComment = prop.getDocumentationComment(checker);
@@ -3153,7 +3298,11 @@ class TypeRegistry {
       type: "object",
       properties: props,
       ...required.length > 0 ? { required } : {},
-      ...stringIndex ? { additionalProperties: buildSchema(stringIndex.type, checker, ctx) } : {}
+      ...stringIndex ? { additionalProperties: buildSchema(stringIndex.type, checker, ctx) } : {},
+      ...numberIndex ? {
+        patternProperties: { "^\\d+$": buildSchema(numberIndex.type, checker, ctx) },
+        "x-ts-index-key": "number"
+      } : {}
     };
   }
 }
@@ -3174,7 +3323,8 @@ function createContext(program, sourceFile, options = {}) {
     registeredTypes: new Set,
     includePrivate: options.includePrivate ?? false,
     maxProperties: options.maxProperties ?? 500,
-    onTruncation: options.onTruncation
+    onTruncation: options.onTruncation,
+    shouldExpandExternal: options.shouldExpandExternal
   };
 }
 function getInheritedMembers(classType, ownMemberNames, ctx, isStatic = false) {
@@ -3463,7 +3613,8 @@ function serializeProperty(node, ctx) {
   if (!ctx.includePrivate && (visibility === "private" || visibility === "protected")) {
     return null;
   }
-  const type = checker.getTypeAtLocation(node);
+  const rawType = checker.getTypeAtLocation(node);
+  const type = node.questionToken ? stripUndefinedFromType(rawType, checker) : rawType;
   registerReferencedTypes(type, ctx);
   let schema = buildSchema(type, checker, ctx);
   const flags = {};
@@ -3857,7 +4008,8 @@ function serializePropertySignature(node, ctx) {
   const { typeChecker: checker } = ctx;
   const name = node.name.getText();
   const { description, tags } = getJSDocComment(node);
-  const type = checker.getTypeAtLocation(node);
+  const rawType = checker.getTypeAtLocation(node);
+  const type = node.questionToken ? stripUndefinedFromType(rawType, checker) : rawType;
   let schema = buildSchema(type, checker, ctx);
   registerReferencedTypes(type, ctx);
   const flags = {};
@@ -3998,7 +4150,7 @@ function serializeTypeAlias(node, ctx) {
     }
   } else if (isInlineFunctionAlias(node.type) && type.getCallSignatures().length > 0) {
     schema = buildFunctionSchema(type.getCallSignatures(), ctx.typeChecker, ctx);
-  } else if ((ts10.isMappedTypeNode(node.type) || ts10.isConditionalTypeNode(node.type)) && type.getProperties().length > 0 && type.getCallSignatures().length === 0) {
+  } else if ((ts10.isMappedTypeNode(node.type) || ts10.isConditionalTypeNode(node.type)) && type.getProperties().length > 0 && type.getCallSignatures().length === 0 && !(type.flags & ts10.TypeFlags.Conditional) && !(type.flags & (ts10.TypeFlags.StringLike | ts10.TypeFlags.NumberLike))) {
     schema = buildObjectSchema(type.getProperties(), ctx.typeChecker, ctx, type);
     members = serializeResolvedMembers(type, node, ctx);
   } else {
@@ -4330,10 +4482,7 @@ function serializeVariable(node, statement, ctx) {
 }
 
 // src/types/schema-normalizer.ts
-var SCHEMA_DIALECT_URLS = {
-  "draft-2020-12": "https://json-schema.org/draft/2020-12/schema",
-  "draft-07": "http://json-schema.org/draft-07/schema#"
-};
+import { JSON_SCHEMA_DRAFT } from "@openpkg-ts/spec";
 var TS_PRIMITIVE_NORMALIZATIONS = {
   void: () => ({ type: "null", "x-ts-type": "void" }),
   never: () => ({ not: {} }),
@@ -4344,11 +4493,11 @@ var TS_PRIMITIVE_NORMALIZATIONS = {
   symbol: () => ({ type: "string", "x-ts-type": "symbol" })
 };
 function normalizeSchema(schema, options = {}) {
-  const { includeSchemaField = false, dialect = "draft-2020-12" } = options;
+  const { includeSchemaField = false } = options;
   const normalized = normalizeSchemaInternal(schema, options);
   if (includeSchemaField && typeof normalized === "object") {
     return {
-      $schema: SCHEMA_DIALECT_URLS[dialect],
+      $schema: JSON_SCHEMA_DRAFT,
       ...normalized
     };
   }
@@ -4369,6 +4518,9 @@ function normalizeSchemaInternal(schema, options) {
         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;
 }
@@ -4474,14 +4626,14 @@ function normalizeSignature(signature, options) {
 }
 function normalizeTupleType(schema, options) {
   const result = { type: "array" };
-  if ("items" in schema && Array.isArray(schema.items)) {
-    result.prefixedItems = schema.items.map((item) => normalizeSchemaInternal(item, options));
+  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 ("prefixedItems" in schema && Array.isArray(schema.prefixedItems)) {
-    result.prefixedItems = schema.prefixedItems.map((item) => normalizeSchemaInternal(item, options));
-  }
   if ("minItems" in schema && typeof schema.minItems === "number") {
     result.minItems = schema.minItems;
   }
@@ -4498,8 +4650,9 @@ function normalizeArrayType(schema, options) {
   if ("items" in schema && schema.items && !Array.isArray(schema.items)) {
     result.items = normalizeSchemaInternal(schema.items, options);
   }
-  if ("prefixedItems" in schema && Array.isArray(schema.prefixedItems)) {
-    result.prefixedItems = schema.prefixedItems.map((item) => normalizeSchemaInternal(item, 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;
@@ -4507,6 +4660,17 @@ function normalizeArrayType(schema, options) {
   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;
   }
@@ -4531,6 +4695,23 @@ function normalizeObjectType(schema, options) {
       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;
   }
@@ -4637,7 +4818,7 @@ function isSchemaLike(value) {
   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 || "prefixedItems" in obj;
+  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) {
@@ -4654,9 +4835,13 @@ function mergeSchemaFields(target, source, excludeKeys) {
   }
   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 };
-  if (exp.schema) {
+  const vendorSchema = isVendorSchemaExport(exp);
+  if (exp.schema && !vendorSchema) {
     result.schema = normalizeSchema(exp.schema, options);
   }
   if (exp.signatures) {
@@ -4665,7 +4850,7 @@ function normalizeExport(exp, options = {}) {
   if (exp.members) {
     result.members = exp.members.map((member) => normalizeMember(member, options));
   }
-  if (shouldGenerateMembersSchema(exp.kind) && exp.members && exp.members.length > 0) {
+  if (!vendorSchema && shouldGenerateMembersSchema(exp.kind) && exp.members && exp.members.length > 0) {
     result.schema = normalizeMembers(exp.members, options);
   }
   return result;
@@ -4716,10 +4901,15 @@ 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") {
-      additionalProperties = normalizeMemberToSchema(member, options);
+      if (name === "[number]") {
+        numberIndexSchema = normalizeMemberToSchema(member, options);
+      } else {
+        additionalProperties = normalizeMemberToSchema(member, options);
+      }
       continue;
     }
     if (!name)
@@ -4740,6 +4930,10 @@ function normalizeMembers(members, options = {}) {
   if (additionalProperties !== undefined) {
     result.additionalProperties = additionalProperties;
   }
+  if (numberIndexSchema !== undefined) {
+    result.patternProperties = { "^\\d+$": numberIndexSchema };
+    result["x-ts-index-key"] = "number";
+  }
   return result;
 }
 function memberDocExtras(member) {
@@ -4858,9 +5052,9 @@ async function getExport(options) {
     const isNamespaceExportDecl = originalDecls.some((d) => ts11.isNamespaceExport(d) || ts11.isNamespaceImport(d));
     if (isNamespaceExportDecl) {
       const spec2 = serializeNamespaceForGet(targetSymbol, exportName, ctx);
-      const types2 = ctx.typeRegistry.getAll().map((t) => normalizeType(t, { dialect: "draft-2020-12" }));
+      const types2 = ctx.typeRegistry.getAll().map((t) => normalizeType(t));
       return {
-        export: normalizeExport(spec2, { dialect: "draft-2020-12" }),
+        export: normalizeExport(spec2),
         types: types2,
         errors
       };
@@ -4893,8 +5087,8 @@ async function getExport(options) {
       }
       return { export: null, types: [], errors: [`Could not serialize '${exportName}'`] };
     }
-    spec = normalizeExport(spec, { dialect: "draft-2020-12" });
-    const types = ctx.typeRegistry.getAll().map((t) => normalizeType(t, { dialect: "draft-2020-12" }));
+    spec = normalizeExport(spec);
+    const types = ctx.typeRegistry.getAll().map((t) => normalizeType(t));
     return { export: spec, types, errors };
   } catch (err) {
     errors.push(`Failed to serialize '${exportName}': ${err instanceof Error ? err.message : String(err)}`);
@@ -6022,12 +6216,7 @@ var NODE_MODULES_PKG = /node_modules\/(@[^/]+\/[^/]+|[^/]+)/;
 function isLibFile(fileName) {
   return fileName.includes("/typescript/lib/lib.") || fileName.includes("\\typescript\\lib\\lib.");
 }
-function expandReachableTypes(exportedSymbols, ctx, opts) {
-  if (opts.followExternal === false)
-    return;
-  const checker = ctx.typeChecker;
-  const visited = new Set;
-  const MAX_DEPTH = 30;
+function createExternalExpansionPredicate(opts) {
   const packageAllowed = (pkg) => {
     if (pkg === "typescript")
       return false;
@@ -6037,6 +6226,25 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
       return true;
     return opts.workspacePackages.has(pkg);
   };
+  return (symbol) => {
+    const decl = symbol.declarations?.[0];
+    if (!decl)
+      return false;
+    const fileName = decl.getSourceFile().fileName;
+    if (isLibFile(fileName))
+      return false;
+    const match = fileName.match(NODE_MODULES_PKG);
+    if (match)
+      return packageAllowed(match[1]);
+    return true;
+  };
+}
+function expandReachableTypes(exportedSymbols, ctx, opts) {
+  if (opts.followExternal === false)
+    return;
+  const checker = ctx.typeChecker;
+  const visited = new Set;
+  const MAX_DEPTH = 30;
   const entryPackageDir = findPackageDir(opts.entryFile);
   const packageLabel = (fileName) => {
     const match = fileName.match(NODE_MODULES_PKG);
@@ -6051,18 +6259,7 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
     }
     return (pkg ?? "local").replace(/^@/, "").replace(/\//g, "-");
   };
-  const symbolAllowed = (symbol) => {
-    const decl = symbol.declarations?.[0];
-    if (!decl)
-      return false;
-    const fileName = decl.getSourceFile().fileName;
-    if (isLibFile(fileName))
-      return false;
-    const match = fileName.match(NODE_MODULES_PKG);
-    if (match)
-      return packageAllowed(match[1]);
-    return true;
-  };
+  const symbolAllowed = createExternalExpansionPredicate(opts);
   const visit = (type, depth) => {
     if (!type || depth > MAX_DEPTH || visited.has(type))
       return;
@@ -6574,7 +6771,11 @@ async function extract(options) {
       resolveExternalTypes,
       includePrivate,
       maxProperties,
-      onTruncation
+      onTruncation,
+      shouldExpandExternal: createExternalExpansionPredicate({
+        followExternal: options.followExternal,
+        workspacePackages: result.workspacePackages ?? new Map
+      })
     });
     ctx.exportedIds = exportedIds;
     const filteredSymbols = exportedSymbols.filter((s) => shouldIncludeExport(s.getName(), only, ignore));
@@ -6744,7 +6945,7 @@ async function extract(options) {
     if (options.schemaExtraction === "hybrid") {
       const projectBaseDir2 = baseDir || path9.dirname(entryFile);
       const runtimeResult = await extractStandardSchemasFromProject(entryFile, projectBaseDir2, {
-        target: options.schemaTarget || "draft-2020-12",
+        target: "draft-2020-12",
         timeout: 15000
       });
       if (runtimeResult.schemas.size > 0) {
@@ -6775,8 +6976,8 @@ async function extract(options) {
         });
       }
     }
-    const normalizedExports = exports.map((exp) => normalizeExport(exp, { dialect: "draft-2020-12" }));
-    const normalizedTypes = types.map((t) => normalizeType(t, { dialect: "draft-2020-12" }));
+    const normalizedExports = exports.map((exp) => normalizeExport(exp));
+    const normalizedTypes = types.map((t) => normalizeType(t));
     const spec = {
       ...includeSchema ? { $schema: SCHEMA_URL } : {},
       openpkg: SCHEMA_VERSION,
@@ -7083,6 +7284,485 @@ async function getPackageMeta(entryFile, baseDir) {
 
 // src/primitives/spec.ts
 var extractSpec = extract;
+// src/primitives/validate.ts
+import {
+  assertSpec,
+  getAvailableVersions,
+  getValidationErrors,
+  LATEST_VERSION,
+  validateSpec as validateSpec2
+} from "@openpkg-ts/spec";
+// src/schema/json-schema.ts
+import { JSON_SCHEMA_DRAFT as JSON_SCHEMA_DRAFT2 } from "@openpkg-ts/spec";
+
+// src/schema/ref-walker.ts
+var INTERNAL_REF_PREFIX = "#/types/";
+function isTsExtensionKey(key) {
+  return (key.startsWith("x-ts-") || key === "x-enum-members") && key !== "x-deprecated-reason";
+}
+function stripTsExtensions(schema) {
+  const walk = (value) => {
+    if (Array.isArray(value))
+      return value.map(walk);
+    if (value && typeof value === "object") {
+      const out = {};
+      for (const [key, nested] of Object.entries(value)) {
+        if (isTsExtensionKey(key))
+          continue;
+        out[key] = walk(nested);
+      }
+      return out;
+    }
+    return value;
+  };
+  return walk(schema);
+}
+function escapePointerToken(name) {
+  return name.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function bundleRefs(root, spec, options = {}) {
+  const { keepExtensions = false, typeParameterNames = [], onUnresolved = "permissive" } = options;
+  const typeParams = new Set(typeParameterNames);
+  const warnings = [];
+  const defs = {};
+  const defKeyByName = new Map;
+  const lookupType = (name) => {
+    const types = spec.types ?? [];
+    return types.find((t) => t.id === name) ?? types.find((t) => t.name === name);
+  };
+  const assignDefKey = (name) => {
+    const existing = defKeyByName.get(name);
+    if (existing)
+      return existing;
+    let key = escapePointerToken(name);
+    if (Object.hasOwn(defs, key) || Object.values(defKeyByName).includes(key)) {
+      let n = 2;
+      while (Object.hasOwn(defs, `${key}_${n}`) || Object.values(defKeyByName).includes(`${key}_${n}`)) {
+        n++;
+      }
+      warnings.push(`def key collision for "${name}" — using "${key}_${n}"`);
+      key = `${key}_${n}`;
+    }
+    defKeyByName.set(name, key);
+    return key;
+  };
+  const bodyOfType = (type) => {
+    if (type.schema)
+      return normalizeSchema(type.schema);
+    if (type.members && type.members.length > 0)
+      return normalizeMembers(type.members);
+    return {};
+  };
+  const rewrite = (node) => {
+    if (Array.isArray(node))
+      return node.map(rewrite);
+    if (!node || typeof node !== "object")
+      return node;
+    const obj = node;
+    const ref = obj.$ref;
+    if (typeof ref === "string" && ref.startsWith(INTERNAL_REF_PREFIX)) {
+      const name = ref.slice(INTERNAL_REF_PREFIX.length);
+      const siblings = {};
+      for (const [key2, value] of Object.entries(obj)) {
+        if (key2 === "$ref")
+          continue;
+        siblings[key2] = rewrite(value);
+      }
+      if (typeParams.has(name)) {
+        warnings.push(`type parameter "${name}" is not an addressable schema`);
+        return keepExtensions ? { ...siblings, "x-ts-type": name } : {};
+      }
+      const builtin = BUILTIN_TYPE_SCHEMAS[name];
+      if (builtin) {
+        return { ...builtin, ...keepExtensions ? siblings : {} };
+      }
+      const type = lookupType(name);
+      if (!type) {
+        warnings.push(`unresolved ref "${ref}"`);
+        if (onUnresolved === "error") {
+          throw new Error(`bundleRefs: cannot resolve ${ref}`);
+        }
+        return keepExtensions ? { ...siblings, "x-ts-type": name } : {};
+      }
+      const key = assignDefKey(name);
+      if (!Object.hasOwn(defs, key)) {
+        defs[key] = {};
+        defs[key] = rewrite(bodyOfType(type));
+      }
+      const refNode = { $ref: `#/$defs/${key}` };
+      return { ...siblings, ...refNode };
+    }
+    const out = {};
+    for (const [key, value] of Object.entries(obj)) {
+      out[key] = rewrite(value);
+    }
+    return out;
+  };
+  let schema = rewrite(normalizeSchema(root));
+  if (!keepExtensions) {
+    schema = stripTsExtensions(schema);
+    for (const key of Object.keys(defs)) {
+      defs[key] = stripTsExtensions(defs[key]);
+    }
+  }
+  return { schema, defs, warnings };
+}
+
+// src/schema/json-schema.ts
+function typeParamNames(subject) {
+  return (subject.typeParameters ?? []).map((p) => p.name);
+}
+function subjectSchema(subject) {
+  if (subject.schema)
+    return normalizeSchema(subject.schema);
+  if (subject.members && subject.members.length > 0)
+    return normalizeMembers(subject.members);
+  return {};
+}
+function exportToJsonSchema(subject, spec, options = {}) {
+  const { keepExtensions = false, includeSchemaField = true } = options;
+  const { schema, defs } = bundleRefs(subjectSchema(subject), spec, {
+    keepExtensions,
+    typeParameterNames: typeParamNames(subject)
+  });
+  const doc = { ...schema };
+  if (Object.keys(defs).length > 0)
+    doc.$defs = defs;
+  if (includeSchemaField)
+    return { $schema: JSON_SCHEMA_DRAFT2, ...doc };
+  return doc;
+}
+function toJsonSchema(spec, options = {}) {
+  const { root, keepExtensions = false, includeSchemaField = true } = options;
+  if (root) {
+    const subject = spec.exports.find((e) => e.name === root) ?? (spec.types ?? []).find((t) => t.name === root);
+    if (!subject) {
+      throw new Error(`toJsonSchema: no export or type named "${root}"`);
+    }
+    return exportToJsonSchema(subject, spec, { keepExtensions, includeSchemaField });
+  }
+  const defs = {};
+  const mergeInto = (name, bundled) => {
+    for (const [key, value] of Object.entries(bundled.defs)) {
+      if (!Object.hasOwn(defs, key))
+        defs[key] = value;
+    }
+    if (!Object.hasOwn(defs, name))
+      defs[name] = bundled.schema;
+  };
+  for (const type of spec.types ?? []) {
+    mergeInto(type.name, bundleRefs(subjectSchema(type), spec, {
+      keepExtensions,
+      typeParameterNames: typeParamNames(type)
+    }));
+  }
+  for (const exp of spec.exports) {
+    if (!exp.schema && !(exp.members && exp.members.length > 0))
+      continue;
+    mergeInto(exp.name, bundleRefs(subjectSchema(exp), spec, {
+      keepExtensions,
+      typeParameterNames: typeParamNames(exp)
+    }));
+  }
+  const doc = { $defs: defs };
+  if (includeSchemaField)
+    return { $schema: JSON_SCHEMA_DRAFT2, ...doc };
+  return doc;
+}
+
+// src/schema/as-standard-schema.ts
+var DRAFT_07_URL = "http://json-schema.org/draft-07/schema#";
+function rewriteDefsPointers(value) {
+  if (Array.isArray(value))
+    return value.map(rewriteDefsPointers);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [key, nested] of Object.entries(value)) {
+      if (key === "$ref" && typeof nested === "string") {
+        out.$ref = nested.replace("#/$defs/", "#/definitions/");
+      } else {
+        out[key] = rewriteDefsPointers(nested);
+      }
+    }
+    return out;
+  }
+  return value;
+}
+function downlevelToDraft07(doc) {
+  const convert = (value) => {
+    if (Array.isArray(value))
+      return value.map(convert);
+    if (value && typeof value === "object") {
+      const obj = value;
+      const out = {};
+      for (const [key, nested] of Object.entries(obj)) {
+        if (key === "$defs") {
+          out.definitions = convert(nested);
+        } else if (key === "prefixItems" && Array.isArray(nested)) {
+          out.items = convert(nested);
+        } else {
+          out[key] = convert(nested);
+        }
+      }
+      return out;
+    }
+    return value;
+  };
+  const converted = rewriteDefsPointers(convert(doc));
+  converted.$schema = DRAFT_07_URL;
+  return converted;
+}
+function downlevelToOpenApi30(doc) {
+  const convert = (value) => {
+    if (Array.isArray(value))
+      return value.map(convert);
+    if (!value || typeof value !== "object")
+      return value;
+    const obj = value;
+    const out = {};
+    if (Array.isArray(obj.anyOf)) {
+      const branches = obj.anyOf;
+      const nulls = branches.filter((b) => b && b.type === "null");
+      const rest = branches.filter((b) => !(b && b.type === "null"));
+      if (nulls.length > 0 && rest.length === 1) {
+        Object.assign(out, convert(rest[0]));
+        out.nullable = true;
+        for (const [key, nested] of Object.entries(obj)) {
+          if (key !== "anyOf")
+            out[key] = convert(nested);
+        }
+        return out;
+      }
+    }
+    for (const [key, nested] of Object.entries(obj)) {
+      if (key === "$schema")
+        continue;
+      if (key === "$defs") {
+        out.definitions = convert(nested);
+      } else if (key === "const") {
+        out.enum = [nested];
+      } else {
+        out[key] = convert(nested);
+      }
+    }
+    return out;
+  };
+  return rewriteDefsPointers(convert(doc));
+}
+function asStandardSchema(subject, spec, options = {}) {
+  const resolved = typeof subject === "string" ? spec.exports.find((e) => e.name === subject) ?? (spec.types ?? []).find((t) => t.name === subject) : subject;
+  if (!resolved) {
+    throw new Error(`asStandardSchema: no export or type named "${subject}"`);
+  }
+  const cache = new Map;
+  const build = (opts) => {
+    const target = opts.target;
+    const cached = cache.get(target);
+    if (cached)
+      return cached;
+    const base = exportToJsonSchema(resolved, spec, {
+      keepExtensions: options.keepExtensions,
+      includeSchemaField: true
+    });
+    let result;
+    switch (target) {
+      case "draft-2020-12":
+        result = base;
+        break;
+      case "draft-07":
+        result = downlevelToDraft07(base);
+        break;
+      case "openapi-3.0":
+        result = downlevelToOpenApi30(base);
+        break;
+      default:
+        throw new Error(`asStandardSchema: unsupported target "${target}". Supported: draft-2020-12, draft-07, openapi-3.0`);
+    }
+    cache.set(target, result);
+    return result;
+  };
+  return {
+    "~standard": {
+      version: 1,
+      vendor: "openpkg",
+      jsonSchema: {
+        input: build,
+        output: build
+      }
+    }
+  };
+}
+// src/schema/tool-schema.ts
+var OPENAI_ALLOWED_KEYWORDS = new Set([
+  "type",
+  "properties",
+  "required",
+  "additionalProperties",
+  "items",
+  "prefixItems",
+  "anyOf",
+  "enum",
+  "const",
+  "description",
+  "title",
+  "$ref",
+  "$defs",
+  "format"
+]);
+function isObject(v) {
+  return !!v && typeof v === "object" && !Array.isArray(v);
+}
+function isObjectNode(node) {
+  return node.type === "object" || "properties" in node;
+}
+function isFunctionOnly(schema) {
+  if (!isObject(schema))
+    return false;
+  if (!("x-ts-function" in schema))
+    return false;
+  const keys = Object.keys(schema).filter((k) => !k.startsWith("x-ts-"));
+  return keys.length === 0;
+}
+function openAiStrict(node, warnings) {
+  if (Array.isArray(node))
+    return node.map((n) => openAiStrict(n, warnings));
+  if (!isObject(node))
+    return node;
+  const src = { ...node };
+  if ("oneOf" in src && !("anyOf" in src)) {
+    src.anyOf = src.oneOf;
+    delete src.oneOf;
+  }
+  if (Array.isArray(src.allOf)) {
+    const branches = src.allOf;
+    warnings.push("openai-strict: allOf is unsupported — using first branch");
+    delete src.allOf;
+    if (isObject(branches[0]))
+      Object.assign(src, branches[0]);
+  }
+  const out = {};
+  for (const [key, value] of Object.entries(src)) {
+    if (key.startsWith("x-"))
+      continue;
+    if (key === "properties" && isObject(value)) {
+      const props = {};
+      const kept = [];
+      for (const [propName, propSchema] of Object.entries(value)) {
+        if (isFunctionOnly(propSchema)) {
+          warnings.push(`openai-strict: pruned function-typed property "${propName}"`);
+          continue;
+        }
+        props[propName] = openAiStrict(propSchema, warnings);
+        kept.push(propName);
+      }
+      out.properties = props;
+      out.required = kept;
+      continue;
+    }
+    if (key === "required")
+      continue;
+    if (key === "$defs" && isObject(value)) {
+      out.$defs = Object.fromEntries(Object.entries(value).map(([k, v]) => [k, openAiStrict(v, warnings)]));
+      continue;
+    }
+    if (!OPENAI_ALLOWED_KEYWORDS.has(key) && key !== "anyOf" && !key.startsWith("$")) {
+      warnings.push(`openai-strict: dropped unsupported keyword "${key}"`);
+      continue;
+    }
+    out[key] = openAiStrict(value, warnings);
+  }
+  if (isObjectNode(out)) {
+    out.type = "object";
+    if (!("properties" in out))
+      out.properties = {};
+    if (!("required" in out))
+      out.required = Object.keys(out.properties);
+    if (out.additionalProperties !== undefined && out.additionalProperties !== false) {
+      warnings.push("openai-strict: open-ended additionalProperties dropped (record types unsupported)");
+    }
+    out.additionalProperties = false;
+  }
+  return out;
+}
+function anthropic(node, warnings) {
+  if (Array.isArray(node))
+    return node.map((n) => anthropic(n, warnings));
+  if (!isObject(node))
+    return node;
+  const out = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (key.startsWith("x-ts-") || key === "x-enum-members")
+      continue;
+    if (key === "properties" && isObject(value)) {
+      const props = {};
+      const dropped = new Set;
+      for (const [propName, propSchema] of Object.entries(value)) {
+        if (isFunctionOnly(propSchema)) {
+          warnings.push(`anthropic: pruned function-typed property "${propName}"`);
+          dropped.add(propName);
+          continue;
+        }
+        props[propName] = anthropic(propSchema, warnings);
+      }
+      out.properties = props;
+      if (Array.isArray(node.required)) {
+        out.required = node.required.filter((r) => !dropped.has(r));
+      }
+      continue;
+    }
+    if (key === "required")
+      continue;
+    out[key] = anthropic(value, warnings);
+  }
+  return out;
+}
+function toToolSchema(exp, spec, options) {
+  if (exp.kind !== "function" || !exp.signatures || exp.signatures.length === 0) {
+    throw new TypeError(`toToolSchema: export "${exp.name}" is not a function with signatures (kind: ${exp.kind})`);
+  }
+  const sig = exp.signatures[options.signatureIndex ?? 0] ?? exp.signatures[0];
+  const warnings = [];
+  const properties = {};
+  const required = [];
+  for (const param of sig.parameters ?? []) {
+    let paramSchema = normalizeSchema(param.schema);
+    if (param.rest) {
+      paramSchema = { type: "array", items: paramSchema };
+    }
+    if (param.description && !paramSchema.description) {
+      paramSchema.description = param.description;
+    }
+    properties[param.name] = paramSchema;
+    if (param.required !== false)
+      required.push(param.name);
+  }
+  const wrapper = {
+    type: "object",
+    properties,
+    ...required.length > 0 ? { required } : {}
+  };
+  const typeParameterNames = [
+    ...(exp.typeParameters ?? []).map((p) => p.name),
+    ...(sig.typeParameters ?? []).map((p) => p.name)
+  ];
+  const bundled = bundleRefs(wrapper, spec, { keepExtensions: true, typeParameterNames });
+  warnings.push(...bundled.warnings);
+  let parameters = { ...bundled.schema };
+  if (Object.keys(bundled.defs).length > 0)
+    parameters.$defs = bundled.defs;
+  if (options.provider === "openai-strict") {
+    parameters = openAiStrict(parameters, warnings);
+  } else {
+    parameters = stripTsExtensions(anthropic(parameters, warnings));
+  }
+  const description = exp.description ?? sig.description;
+  return {
+    name: exp.name,
+    ...description ? { description } : {},
+    parameters,
+    warnings
+  };
+}
 // src/types/utils.ts
 import ts18 from "typescript";
 function isExported(node) {
@@ -7102,13 +7782,16 @@ export {
   zodAdapter,
   withDescription,
   withDeprecated,
+  validateSpec2 as validateSpec,
   valibotAdapter,
   typeboxAdapter,
+  toToolSchema,
   toSearchIndexJSON,
   toSearchIndex,
   toPagefindRecords,
   toNavigation,
   toMarkdown,
+  toJsonSchema,
   toJSONString,
   toJSON,
   toHTML,
@@ -7116,6 +7799,7 @@ export {
   toDocusaurusSidebarJS,
   toAlgoliaRecords,
   stripUndefinedFromType,
+  stripTsExtensions,
   sortByName,
   shouldEmitAliasTypeText,
   serializeVariable,
@@ -7159,6 +7843,7 @@ export {
   isAnonymous,
   hasDeprecatedTag,
   groupByVisibility,
+  getValidationErrors,
   getTypeOrigin,
   getSourceLocation,
   getProperties,
@@ -7171,6 +7856,7 @@ export {
   getExportKind,
   getExport,
   getDeprecationMessage,
+  getAvailableVersions,
   toMarkdown as generateDocs,
   formatTypeParameters,
   formatSchema,
@@ -7192,6 +7878,7 @@ export {
   extractParameters,
   extract,
   exportToMarkdown,
+  exportToJsonSchema,
   ensureNonEmptySchema,
   diffSpec2 as diffSpecs,
   diffSpec,
@@ -7202,10 +7889,13 @@ export {
   createDocs,
   categorizeBreakingChanges,
   calculateNextVersion,
+  bundleRefs,
   buildSignatureString,
   buildSchema,
   buildObjectSchema,
   buildFunctionSchema,
+  assertSpec,
+  asStandardSchema,
   arktypeAdapter,
   analyzeSpec,
   TypeRegistry,
@@ -7213,6 +7903,7 @@ export {
   QueryBuilder,
   PRIMITIVES,
   NUMBER_PROTOTYPE_METHODS,
+  LATEST_VERSION,
   CacheManager,
   CONFIG_FILENAME,
   BUILTIN_TYPE_SCHEMAS,