@openpkg-ts/sdk 0.35.1 → 0.37.0

package/dist/index.js

@@ -29,7 +29,7 @@ import {
   toPagefindRecords,
   toSearchIndex,
   toSearchIndexJSON
-} from "./shared/chunk-4fgxg5jj.js";
+} from "./shared/chunk-hnajr1tb.js";
 
 // src/primitives/diff.ts
 import {
@@ -1746,7 +1746,9 @@ function parseExamplesFromTags(tags) {
 function stripParamSeparator(text) {
   if (!text)
     return;
-  const stripped = text.replace(/^-\s*/, "").trim();
+  let stripped = text.replace(/^-\s*/, "").trim();
+  const parts = stripped.split(/\n\s*\n/);
+  stripped = parts[0].trim();
   return stripped || undefined;
 }
 function stripTypeParamSeparator(text) {
@@ -1951,6 +1953,21 @@ function isSymbolDeprecated(symbol) {
       }
       return { deprecated: true, reason };
     }
+    if (ts2.isExportSpecifier(declaration)) {
+      const exportDecl = declaration.parent?.parent;
+      if (exportDecl && ts2.isExportDeclaration(exportDecl)) {
+        const parentTag = ts2.getJSDocDeprecatedTag(exportDecl);
+        if (parentTag) {
+          let reason;
+          if (typeof parentTag.comment === "string") {
+            reason = parentTag.comment;
+          } else if (Array.isArray(parentTag.comment)) {
+            reason = parentTag.comment.map((c) => typeof c === "string" ? c : c.text).join("");
+          }
+          return { deprecated: true, reason };
+        }
+      }
+    }
   }
   return { deprecated: false };
 }
@@ -2011,6 +2028,8 @@ function getExportKind(declaration, type) {
     return "enum";
   if (ts2.isModuleDeclaration(declaration) || ts2.isNamespaceExport(declaration))
     return "namespace";
+  if (ts2.isVariableDeclaration(declaration) && type.getConstructSignatures().length > 0)
+    return "class";
   if (ts2.isVariableDeclaration(declaration) && type.getCallSignatures().length > 0)
     return "function";
   return "variable";
@@ -2155,6 +2174,63 @@ var ARRAY_PROTOTYPE_METHODS = new Set([
   "toString",
   "toLocaleString"
 ]);
+var STRING_PROTOTYPE_METHODS = new Set([
+  "charAt",
+  "charCodeAt",
+  "codePointAt",
+  "concat",
+  "endsWith",
+  "includes",
+  "indexOf",
+  "lastIndexOf",
+  "localeCompare",
+  "match",
+  "matchAll",
+  "normalize",
+  "padEnd",
+  "padStart",
+  "repeat",
+  "replace",
+  "replaceAll",
+  "search",
+  "slice",
+  "split",
+  "startsWith",
+  "substring",
+  "toLocaleLowerCase",
+  "toLocaleUpperCase",
+  "toLowerCase",
+  "toUpperCase",
+  "trim",
+  "trimEnd",
+  "trimStart",
+  "at",
+  "bold",
+  "fixed",
+  "italics",
+  "link",
+  "small",
+  "strike",
+  "sub",
+  "sup",
+  "anchor",
+  "big",
+  "blink",
+  "fontcolor",
+  "fontsize",
+  "substr",
+  "toString",
+  "valueOf",
+  "length"
+]);
+var NUMBER_PROTOTYPE_METHODS = new Set([
+  "toFixed",
+  "toExponential",
+  "toPrecision",
+  "toString",
+  "valueOf",
+  "toLocaleString"
+]);
 function isPrimitiveName(name) {
   return PRIMITIVES.has(name);
 }
@@ -2227,40 +2303,13 @@ function buildSchema(type, checker, ctx) {
   const schema = buildSchemaInternal(type, checker, ctx);
   return ensureNonEmptySchema(schema, type, checker);
 }
-function buildSchemaInternal(type, checker, ctx) {
-  if (isAtMaxDepth(ctx)) {
-    return { type: checker.typeToString(type) };
-  }
-  if (ctx?.visitedTypes.has(type)) {
-    const callSignatures = type.getCallSignatures();
-    if (callSignatures.length > 0) {
-      return buildFunctionSchema(callSignatures, checker, ctx);
-    }
-    const symbol2 = type.getSymbol() || type.aliasSymbol;
-    if (symbol2 && !isAnonymous(type)) {
-      const name = symbol2.getName();
-      const schema = { $ref: `#/types/${name}` };
-      const typeRef2 = type;
-      if (typeRef2.target) {
-        const typeArgs2 = checker.getTypeArguments(typeRef2);
-        if (typeArgs2 && typeArgs2.length > 0) {
-          ctx.visitedTypes.delete(type);
-          schema.typeArguments = typeArgs2.map((t) => buildSchema(t, checker, ctx));
-          ctx.visitedTypes.add(type);
-        }
-      }
-      return schema;
-    }
-    if (type.flags & ts3.TypeFlags.Object) {
-      const properties = type.getProperties();
-      if (properties.length > 0) {
-        return buildObjectSchema(properties, checker, ctx, type);
-      }
+function buildMaxDepthSchema(type, checker) {
+  const symbol = type.getSymbol() || type.aliasSymbol;
+  if (symbol && !isAnonymous(type)) {
+    const name = symbol.getName();
+    if (!name.startsWith("__") && !isPrimitiveName(name)) {
+      return { $ref: `#/types/${name}` };
     }
-    return { type: checker.typeToString(type) };
-  }
-  if (ctx && type.flags & ts3.TypeFlags.Object) {
-    ctx.visitedTypes.add(type);
   }
   if (type.flags & ts3.TypeFlags.String)
     return { type: "string" };
@@ -2274,223 +2323,281 @@ function buildSchemaInternal(type, checker, ctx) {
     return { type: "null" };
   if (type.flags & ts3.TypeFlags.Void)
     return { type: "void" };
-  if (type.flags & ts3.TypeFlags.Any)
-    return { type: "any" };
-  if (type.flags & ts3.TypeFlags.Unknown)
-    return { type: "unknown" };
-  if (type.flags & ts3.TypeFlags.Never)
-    return { type: "never" };
-  if (type.flags & ts3.TypeFlags.BigInt)
-    return { type: "bigint" };
-  if (type.flags & ts3.TypeFlags.ESSymbol)
-    return { type: "symbol" };
-  if (type.isThisType?.()) {
-    const constraint = type.getConstraint?.();
-    const symbol2 = constraint?.getSymbol() ?? type.getSymbol();
-    if (symbol2 && !isAnonymous(type)) {
-      return {
-        $ref: `#/types/${symbol2.getName()}`,
-        "x-ts-type": "this"
-      };
-    }
-  }
-  if (type.flags & ts3.TypeFlags.StringLiteral) {
-    const literal = type.value;
-    return { type: "string", enum: [literal] };
+  if (type.isUnion()) {
+    const schemas = type.types.map((t) => buildMaxDepthSchema(t, checker));
+    return { anyOf: schemas };
   }
-  if (type.flags & ts3.TypeFlags.NumberLiteral) {
-    const literal = type.value;
-    return { type: "number", enum: [literal] };
+  if (type.isIntersection()) {
+    const schemas = type.types.map((t) => buildMaxDepthSchema(t, checker));
+    return { allOf: schemas };
   }
-  if (type.flags & ts3.TypeFlags.BooleanLiteral) {
-    const typeString2 = checker.typeToString(type);
-    return { type: "boolean", enum: [typeString2 === "true"] };
+  return { type: checker.typeToString(type) };
+}
+function buildSchemaInternal(type, checker, ctx) {
+  if (isAtMaxDepth(ctx)) {
+    return buildMaxDepthSchema(type, checker);
   }
-  if (type.isUnion()) {
-    const types = type.types;
-    const allStringLiterals = types.every((t) => t.flags & ts3.TypeFlags.StringLiteral);
-    if (allStringLiterals) {
-      const enumValues = types.map((t) => t.value);
-      return { type: "string", enum: enumValues };
-    }
-    const allNumberLiterals = types.every((t) => t.flags & ts3.TypeFlags.NumberLiteral);
-    if (allNumberLiterals) {
-      const enumValues = types.map((t) => t.value);
-      return { type: "number", enum: enumValues };
-    }
-    if (ctx) {
-      return withDepth(ctx, () => ({
-        anyOf: types.map((t) => buildSchema(t, checker, ctx))
-      }));
+  if (ctx?.visitedTypes.has(type)) {
+    const callSignatures = type.getCallSignatures();
+    if (callSignatures.length > 0) {
+      return buildFunctionSchema(callSignatures, checker, ctx);
     }
-    return { anyOf: types.map((t) => buildSchema(t, checker, ctx)) };
+    const symbol = type.getSymbol() || type.aliasSymbol;
+    if (symbol && !isAnonymous(type)) {
+      return { $ref: `#/types/${symbol.getName()}` };
+    }
+    return { type: checker.typeToString(type) };
   }
-  const isIntersectionType = type.isIntersection() || !!(type.flags & ts3.TypeFlags.Intersection);
-  if (isIntersectionType && "types" in type) {
-    const intersectionType = type;
-    const filteredTypes = intersectionType.types.filter((t) => !(t.flags & ts3.TypeFlags.Never));
-    if (filteredTypes.length === 0) {
+  const addedToVisited = !!(ctx && type.flags & ts3.TypeFlags.Object);
+  if (addedToVisited) {
+    ctx.visitedTypes.add(type);
+  }
+  try {
+    if (type.flags & ts3.TypeFlags.String)
+      return { type: "string" };
+    if (type.flags & ts3.TypeFlags.Number)
+      return { type: "number" };
+    if (type.flags & ts3.TypeFlags.Boolean)
+      return { type: "boolean" };
+    if (type.flags & ts3.TypeFlags.Undefined)
+      return { type: "undefined" };
+    if (type.flags & ts3.TypeFlags.Null)
+      return { type: "null" };
+    if (type.flags & ts3.TypeFlags.Void)
+      return { type: "void" };
+    if (type.flags & ts3.TypeFlags.Any)
+      return { type: "any" };
+    if (type.flags & ts3.TypeFlags.Unknown)
+      return { type: "unknown" };
+    if (type.flags & ts3.TypeFlags.Never)
       return { type: "never" };
+    if (type.flags & ts3.TypeFlags.BigInt)
+      return { type: "bigint" };
+    if (type.flags & ts3.TypeFlags.ESSymbol)
+      return { type: "symbol" };
+    if (type.isThisType === true) {
+      const constraint = type.getConstraint?.();
+      const symbol2 = constraint?.getSymbol() ?? type.getSymbol();
+      if (symbol2 && !isAnonymous(type)) {
+        return {
+          $ref: `#/types/${symbol2.getName()}`,
+          "x-ts-type": "this"
+        };
+      }
     }
-    if (filteredTypes.length === 1) {
-      return buildSchema(filteredTypes[0], checker, ctx);
-    }
-    if (ctx) {
-      return withDepth(ctx, () => ({
-        allOf: filteredTypes.map((t) => buildSchema(t, checker, ctx))
-      }));
+    if (type.flags & ts3.TypeFlags.StringLiteral) {
+      const literal = type.value;
+      return { type: "string", enum: [literal] };
+    }
+    if (type.flags & ts3.TypeFlags.NumberLiteral) {
+      const literal = type.value;
+      return { type: "number", enum: [literal] };
+    }
+    if (type.flags & ts3.TypeFlags.BooleanLiteral) {
+      const typeString2 = checker.typeToString(type);
+      return { type: "boolean", enum: [typeString2 === "true"] };
+    }
+    if (type.aliasSymbol && !type.aliasTypeArguments?.length) {
+      const aliasName = type.aliasSymbol.getName();
+      if (!aliasName.startsWith("__") && !isPrimitiveName(aliasName)) {
+        const packageOrigin = getTypeOrigin(type, checker);
+        const schema = { $ref: `#/types/${aliasName}` };
+        if (packageOrigin) {
+          setSchemaExtension(schema, "x-ts-package", packageOrigin);
+        }
+        return schema;
+      }
     }
-    return { allOf: filteredTypes.map((t) => buildSchema(t, checker, ctx)) };
-  }
-  const typeString = checker.typeToString(type);
-  if (typeString === "never[]" || typeString === "[]") {
-    return { type: "array", prefixedItems: [], minItems: 0, maxItems: 0 };
-  }
-  const symbol = type.getSymbol() || type.aliasSymbol;
-  if (symbol?.getName() === "Array" && isBuiltinSymbol(symbol)) {
-    const typeRef2 = type;
-    const typeArgs2 = typeRef2.target ? checker.getTypeArguments(typeRef2) : undefined;
-    const elementType = typeArgs2?.[0];
-    if (elementType) {
-      return { type: "array", items: buildSchema(elementType, checker, ctx) };
-    }
-    return { type: "array", items: { "x-ts-type": "unknown" } };
-  }
-  if (checker.isArrayType(type)) {
-    const arrayTypeRef = type;
-    const arrayTypeArgs = checker.getTypeArguments(arrayTypeRef);
-    const elementType = arrayTypeArgs?.[0];
-    if (elementType) {
+    if (type.isUnion()) {
+      const types = type.types;
+      const allStringLiterals = types.every((t) => t.flags & ts3.TypeFlags.StringLiteral);
+      if (allStringLiterals) {
+        const enumValues = types.map((t) => t.value);
+        return { type: "string", enum: enumValues };
+      }
+      const allNumberLiterals = types.every((t) => t.flags & ts3.TypeFlags.NumberLiteral);
+      if (allNumberLiterals) {
+        const enumValues = types.map((t) => t.value);
+        return { type: "number", enum: enumValues };
+      }
       if (ctx) {
         return withDepth(ctx, () => ({
-          type: "array",
-          items: buildSchema(elementType, checker, ctx)
+          anyOf: types.map((t) => buildSchema(t, checker, ctx))
         }));
       }
-      return { type: "array", items: buildSchema(elementType, checker, ctx) };
+      return { anyOf: types.map((t) => buildSchema(t, checker, ctx)) };
+    }
+    const isIntersectionType = type.isIntersection() || !!(type.flags & ts3.TypeFlags.Intersection);
+    if (isIntersectionType && "types" in type) {
+      const intersectionType = type;
+      const filteredTypes = intersectionType.types.filter((t) => !(t.flags & ts3.TypeFlags.Never));
+      if (filteredTypes.length === 0) {
+        return { type: "never" };
+      }
+      if (filteredTypes.length === 1) {
+        return buildSchema(filteredTypes[0], checker, ctx);
+      }
+      if (ctx) {
+        return withDepth(ctx, () => ({
+          allOf: filteredTypes.map((t) => buildSchema(t, checker, ctx))
+        }));
+      }
+      return { allOf: filteredTypes.map((t) => buildSchema(t, checker, ctx)) };
     }
-    return { type: "array" };
-  }
-  if (checker.isTupleType(type)) {
-    const tupleTypeRef = type;
-    const elementTypes = checker.getTypeArguments(tupleTypeRef) ?? [];
-    if (ctx) {
-      return withDepth(ctx, () => {
-        const prevInTupleElement = ctx.inTupleElement;
-        ctx.inTupleElement = true;
-        try {
-          return {
+    const typeString = checker.typeToString(type);
+    if (typeString === "never[]" || typeString === "[]") {
+      return { type: "array", prefixedItems: [], minItems: 0, maxItems: 0 };
+    }
+    const symbol = type.getSymbol() || type.aliasSymbol;
+    if (symbol?.getName() === "Array" && isBuiltinSymbol(symbol)) {
+      const typeRef2 = type;
+      const typeArgs2 = typeRef2.target ? checker.getTypeArguments(typeRef2) : undefined;
+      const elementType = typeArgs2?.[0];
+      if (elementType) {
+        return { type: "array", items: buildSchema(elementType, checker, ctx) };
+      }
+      return { type: "array", items: { "x-ts-type": "unknown" } };
+    }
+    if (checker.isArrayType(type)) {
+      const arrayTypeRef = type;
+      const arrayTypeArgs = checker.getTypeArguments(arrayTypeRef);
+      const elementType = arrayTypeArgs?.[0];
+      if (elementType) {
+        if (ctx) {
+          return withDepth(ctx, () => ({
             type: "array",
-            prefixedItems: elementTypes.map((t) => buildSchema(t, checker, ctx)),
-            minItems: elementTypes.length,
-            maxItems: elementTypes.length
-          };
-        } finally {
-          ctx.inTupleElement = prevInTupleElement;
+            items: buildSchema(elementType, checker, ctx)
+          }));
         }
-      });
-    }
-    return {
-      type: "array",
-      prefixedItems: elementTypes.map((t) => buildSchema(t, checker, ctx)),
-      minItems: elementTypes.length,
-      maxItems: elementTypes.length
-    };
-  }
-  const typeRef = type;
-  const typeArgs = typeRef.target ? checker.getTypeArguments(typeRef) : undefined;
-  if (typeRef.target && typeArgs && typeArgs.length > 0) {
-    const symbol2 = typeRef.target.getSymbol();
-    const name = symbol2?.getName();
-    if (name && BUILTIN_TYPES.has(name)) {
-      return { $ref: `#/types/${name}` };
+        return { type: "array", items: buildSchema(elementType, checker, ctx) };
+      }
+      return { type: "array" };
     }
-    if (name && (isBuiltinGeneric(name) || !isAnonymous(typeRef.target))) {
-      const packageOrigin = getTypeOrigin(typeRef.target, checker);
+    if (checker.isTupleType(type)) {
+      const tupleTypeRef = type;
+      const elementTypes = checker.getTypeArguments(tupleTypeRef) ?? [];
       if (ctx) {
         return withDepth(ctx, () => {
-          const schema2 = {
-            $ref: `#/types/${name}`,
-            typeArguments: typeArgs.map((t) => buildSchema(t, checker, ctx))
-          };
-          if (packageOrigin) {
-            setSchemaExtension(schema2, "x-ts-package", packageOrigin);
+          const prevInTupleElement = ctx.inTupleElement;
+          ctx.inTupleElement = true;
+          try {
+            return {
+              type: "array",
+              prefixedItems: elementTypes.map((t) => buildSchema(t, checker, ctx)),
+              minItems: elementTypes.length,
+              maxItems: elementTypes.length
+            };
+          } finally {
+            ctx.inTupleElement = prevInTupleElement;
           }
-          return schema2;
         });
       }
-      const schema = {
-        $ref: `#/types/${name}`,
-        typeArguments: typeArgs.map((t) => buildSchema(t, checker, ctx))
+      return {
+        type: "array",
+        prefixedItems: elementTypes.map((t) => buildSchema(t, checker, ctx)),
+        minItems: elementTypes.length,
+        maxItems: elementTypes.length
       };
-      if (packageOrigin) {
-        setSchemaExtension(schema, "x-ts-package", packageOrigin);
-      }
-      return schema;
-    }
-  }
-  const aliasTypeArgs = type.aliasTypeArguments;
-  const aliasSymbol = type.aliasSymbol;
-  if (aliasSymbol && aliasTypeArgs && aliasTypeArgs.length > 0) {
-    const name = aliasSymbol.getName();
-    if (BUILTIN_TYPES.has(name)) {
-      return { $ref: `#/types/${name}` };
     }
-    if (isBuiltinGeneric(name) || !name.startsWith("__")) {
-      const packageOrigin = getTypeOrigin(type, checker);
-      if (ctx) {
-        return withDepth(ctx, () => {
-          const schema2 = {
-            $ref: `#/types/${name}`,
-            typeArguments: aliasTypeArgs.map((t) => buildSchema(t, checker, ctx))
-          };
-          if (packageOrigin) {
-            setSchemaExtension(schema2, "x-ts-package", packageOrigin);
-          }
-          return schema2;
-        });
+    const typeRef = type;
+    const typeArgs = typeRef.target ? checker.getTypeArguments(typeRef) : undefined;
+    if (typeRef.target && typeArgs && typeArgs.length > 0) {
+      const symbol2 = typeRef.target.getSymbol();
+      const name = symbol2?.getName();
+      if (name && BUILTIN_TYPES.has(name)) {
+        return { $ref: `#/types/${name}` };
       }
-      const schema = {
-        $ref: `#/types/${name}`,
-        typeArguments: aliasTypeArgs.map((t) => buildSchema(t, checker, ctx))
-      };
-      if (packageOrigin) {
-        setSchemaExtension(schema, "x-ts-package", packageOrigin);
+      if (name && (isBuiltinGeneric(name) || !isAnonymous(typeRef.target))) {
+        const packageOrigin = getTypeOrigin(typeRef.target, checker);
+        if (ctx) {
+          return withDepth(ctx, () => {
+            const schema2 = {
+              $ref: `#/types/${name}`,
+              typeArguments: typeArgs.map((t) => buildSchema(t, checker, ctx))
+            };
+            if (packageOrigin) {
+              setSchemaExtension(schema2, "x-ts-package", packageOrigin);
+            }
+            return schema2;
+          });
+        }
+        const schema = {
+          $ref: `#/types/${name}`,
+          typeArguments: typeArgs.map((t) => buildSchema(t, checker, ctx))
+        };
+        if (packageOrigin) {
+          setSchemaExtension(schema, "x-ts-package", packageOrigin);
+        }
+        return schema;
       }
-      return schema;
     }
-  }
-  if (type.flags & ts3.TypeFlags.Object) {
-    const callSignatures = type.getCallSignatures();
-    if (callSignatures.length > 0) {
-      return buildFunctionSchema(callSignatures, checker, ctx);
+    const aliasTypeArgs = type.aliasTypeArguments;
+    const aliasSymbol = type.aliasSymbol;
+    if (aliasSymbol && aliasTypeArgs && aliasTypeArgs.length > 0) {
+      const name = aliasSymbol.getName();
+      if (BUILTIN_TYPES.has(name)) {
+        return { $ref: `#/types/${name}` };
+      }
+      if (isBuiltinGeneric(name) || !name.startsWith("__")) {
+        const packageOrigin = getTypeOrigin(type, checker);
+        if (ctx) {
+          return withDepth(ctx, () => {
+            const schema2 = {
+              $ref: `#/types/${name}`,
+              typeArguments: aliasTypeArgs.map((t) => buildSchema(t, checker, ctx))
+            };
+            if (packageOrigin) {
+              setSchemaExtension(schema2, "x-ts-package", packageOrigin);
+            }
+            return schema2;
+          });
+        }
+        const schema = {
+          $ref: `#/types/${name}`,
+          typeArguments: aliasTypeArgs.map((t) => buildSchema(t, checker, ctx))
+        };
+        if (packageOrigin) {
+          setSchemaExtension(schema, "x-ts-package", packageOrigin);
+        }
+        return schema;
+      }
     }
-  }
-  if (symbol && !isAnonymous(type)) {
-    const name = symbol.getName();
-    if (isPrimitiveName(name)) {
-      return { type: name };
+    if (type.flags & ts3.TypeFlags.Object) {
+      const callSignatures = type.getCallSignatures();
+      if (callSignatures.length > 0) {
+        return buildFunctionSchema(callSignatures, checker, ctx);
+      }
     }
-    if (BUILTIN_TYPES.has(name)) {
-      return { $ref: `#/types/${name}` };
+    if (symbol && !isAnonymous(type)) {
+      const name = symbol.getName();
+      if (isPrimitiveName(name)) {
+        return { type: name };
+      }
+      if (BUILTIN_TYPES.has(name)) {
+        return { $ref: `#/types/${name}` };
+      }
+      if (!name.startsWith("__")) {
+        const packageOrigin = getTypeOrigin(type, checker);
+        const schema = { $ref: `#/types/${name}` };
+        if (packageOrigin) {
+          setSchemaExtension(schema, "x-ts-package", packageOrigin);
+        }
+        return schema;
+      }
     }
-    if (!name.startsWith("__")) {
-      const packageOrigin = getTypeOrigin(type, checker);
-      const schema = { $ref: `#/types/${name}` };
-      if (packageOrigin) {
-        setSchemaExtension(schema, "x-ts-package", packageOrigin);
+    if (type.flags & ts3.TypeFlags.Object) {
+      const objectType = type;
+      const properties = type.getProperties();
+      if (properties.length > 0 || objectType.objectFlags & ts3.ObjectFlags.Anonymous) {
+        return buildObjectSchema(properties, checker, ctx, type);
       }
-      return schema;
     }
-  }
-  if (type.flags & ts3.TypeFlags.Object) {
-    const objectType = type;
-    const properties = type.getProperties();
-    if (properties.length > 0 || objectType.objectFlags & ts3.ObjectFlags.Anonymous) {
-      return buildObjectSchema(properties, checker, ctx, type);
+    return { type: checker.typeToString(type) };
+  } finally {
+    if (addedToVisited) {
+      ctx.visitedTypes.delete(type);
     }
   }
-  return { type: checker.typeToString(type) };
 }
 function buildFunctionSchema(callSignatures, checker, ctx) {
   const buildSignatures = () => {
@@ -2523,6 +2630,7 @@ function buildFunctionSchema(callSignatures, checker, ctx) {
   return { type: "function", signatures: buildSignatures() };
 }
 function buildObjectSchema(properties, checker, ctx, originalType) {
+  const isArrayLikeType = originalType ? checker.isArrayType(originalType) || checker.isTupleType(originalType) || originalType.symbol?.getName() === "Array" && isBuiltinSymbol(originalType.symbol) : false;
   const buildProps = () => {
     const props = {};
     const required = [];
@@ -2530,7 +2638,7 @@ function buildObjectSchema(properties, checker, ctx, originalType) {
       const propName = prop.getName();
       if (propName.startsWith("_"))
         continue;
-      if (ARRAY_PROTOTYPE_METHODS.has(propName)) {
+      if (isArrayLikeType && ARRAY_PROTOTYPE_METHODS.has(propName)) {
         continue;
       }
       const propType = checker.getTypeOfSymbol(prop);
@@ -2801,11 +2909,11 @@ function extractDefaultValue(initializer) {
 function registerReferencedTypes(type, ctx, depth = 0) {
   if (depth > ctx.maxTypeDepth)
     return;
-  if (ctx.visitedTypes.has(type))
+  if (ctx.registeredTypes.has(type))
     return;
   const isPrimitive = type.flags & (ts4.TypeFlags.String | ts4.TypeFlags.Number | ts4.TypeFlags.Boolean | ts4.TypeFlags.Void | ts4.TypeFlags.Undefined | ts4.TypeFlags.Null | ts4.TypeFlags.Any | ts4.TypeFlags.Unknown | ts4.TypeFlags.Never | ts4.TypeFlags.StringLiteral | ts4.TypeFlags.NumberLiteral | ts4.TypeFlags.BooleanLiteral);
   if (!isPrimitive) {
-    ctx.visitedTypes.add(type);
+    ctx.registeredTypes.add(type);
   }
   const { typeChecker: checker, typeRegistry } = ctx;
   typeRegistry.registerType(type, ctx);
@@ -2912,8 +3020,6 @@ function isGenericTypeParameter(name) {
     return true;
   if (/^T[A-Z]/.test(name))
     return true;
-  if (["Key", "Value", "Item", "Element"].includes(name))
-    return true;
   return false;
 }
 function isExternalType(decl) {
@@ -2939,7 +3045,7 @@ class TypeRegistry {
     return Array.from(this.types.values());
   }
   registerType(type, ctx) {
-    const symbol = type.getSymbol() || type.aliasSymbol;
+    const symbol = type.aliasSymbol || type.getSymbol();
     if (!symbol)
       return;
     const name = symbol.getName();
@@ -2994,7 +3100,7 @@ class TypeRegistry {
     }
     let schema = buildSchema(type, checker, ctx);
     if (this.isSelfRef(schema, name)) {
-      schema = this.buildObjectSchemaFromType(type, checker, ctx);
+      schema = this.resolveSelRefSchema(type, checker, ctx);
     }
     return {
       id: name,
@@ -3010,7 +3116,56 @@ class TypeRegistry {
     const obj = schema;
     return obj.$ref === `#/types/${typeName}`;
   }
-  buildObjectSchemaFromType(type, checker, ctx) {
+  resolveSelRefSchema(type, checker, ctx) {
+    if (type.isUnion()) {
+      const types = type.types;
+      const allStringLiterals = types.every((t) => t.flags & ts5.TypeFlags.StringLiteral);
+      if (allStringLiterals) {
+        return {
+          type: "string",
+          enum: types.map((t) => t.value)
+        };
+      }
+      const allNumberLiterals = types.every((t) => t.flags & ts5.TypeFlags.NumberLiteral);
+      if (allNumberLiterals) {
+        return {
+          type: "number",
+          enum: types.map((t) => t.value)
+        };
+      }
+      return {
+        anyOf: types.map((t) => buildSchema(t, checker, ctx))
+      };
+    }
+    const symbol = type.getSymbol() ?? type.aliasSymbol;
+    if (symbol) {
+      const decl = symbol.declarations?.find(ts5.isEnumDeclaration);
+      if (decl) {
+        const members = [];
+        for (const member of decl.members) {
+          const memberSymbol = checker.getSymbolAtLocation(member.name);
+          if (memberSymbol) {
+            const constantValue = checker.getConstantValue(member);
+            if (constantValue !== undefined) {
+              members.push({
+                name: memberSymbol.getName(),
+                value: constantValue
+              });
+            }
+          }
+        }
+        if (members.length > 0) {
+          return {
+            type: typeof members[0].value === "string" ? "string" : "number",
+            enum: members.map((m) => m.value),
+            "x-enum-members": members
+          };
+        }
+      }
+    }
+    return this.buildObjectSchemaFromProperties(type, checker, ctx);
+  }
+  buildObjectSchemaFromProperties(type, checker, ctx) {
     const properties = type.getProperties();
     if (properties.length === 0) {
       return { type: checker.typeToString(type) };
@@ -3022,11 +3177,18 @@ class TypeRegistry {
       const typeName = type.getSymbol()?.getName() ?? "anonymous";
       ctx.onTruncation(typeName, properties.length, limit);
     }
+    const isArrayLike = checker.isArrayType(type) || checker.isTupleType(type) || type.symbol?.getName() === "Array" && type.symbol?.getDeclarations()?.[0]?.getSourceFile()?.fileName?.includes("/typescript/lib/lib.");
+    const isStringLike = type.flags & ts5.TypeFlags.StringLike;
+    const isNumberLike = type.flags & ts5.TypeFlags.NumberLike;
     for (const prop of properties.slice(0, limit)) {
       const propName = prop.getName();
       if (propName.startsWith("_"))
         continue;
-      if (ARRAY_PROTOTYPE_METHODS.has(propName))
+      if (isArrayLike && ARRAY_PROTOTYPE_METHODS.has(propName))
+        continue;
+      if (isStringLike && STRING_PROTOTYPE_METHODS.has(propName))
+        continue;
+      if (isNumberLike && NUMBER_PROTOTYPE_METHODS.has(propName))
         continue;
       const propType = checker.getTypeOfSymbol(prop);
       this.registerType(propType, ctx);
@@ -3049,15 +3211,16 @@ function createContext(program, sourceFile, options = {}) {
     typeChecker: program.getTypeChecker(),
     program,
     sourceFile,
-    maxTypeDepth: options.maxTypeDepth ?? 4,
+    maxTypeDepth: options.maxTypeDepth ?? 5,
     maxExternalTypeDepth: options.maxExternalTypeDepth ?? 2,
     currentDepth: 0,
     resolveExternalTypes: options.resolveExternalTypes ?? true,
     typeRegistry: new TypeRegistry,
     exportedIds: new Set,
     visitedTypes: new Set,
+    registeredTypes: new Set,
     includePrivate: options.includePrivate ?? false,
-    maxProperties: options.maxProperties ?? 20,
+    maxProperties: options.maxProperties ?? 100,
     onTruncation: options.onTruncation
   };
 }
@@ -3354,6 +3517,8 @@ function serializeProperty(node, ctx) {
     flags.readonly = true;
   if (node.questionToken)
     flags.optional = true;
+  const symbol = checker.getSymbolAtLocation(node.name ?? node);
+  const { deprecated, reason: deprecationReason } = isSymbolDeprecated(symbol);
   return {
     name,
     kind: "property",
@@ -3361,7 +3526,8 @@ function serializeProperty(node, ctx) {
     tags: tags.length > 0 ? tags : undefined,
     visibility,
     schema,
-    flags: Object.keys(flags).length > 0 ? flags : undefined
+    flags: Object.keys(flags).length > 0 ? flags : undefined,
+    ...deprecated ? { deprecated: true, deprecationReason } : {}
   };
 }
 function serializeMethod(node, ctx) {
@@ -3389,6 +3555,8 @@ function serializeMethod(node, ctx) {
   if (modifiers?.some((m) => m.kind === ts7.SyntaxKind.AbstractKeyword)) {
     flags.abstract = true;
   }
+  const symbol = checker.getSymbolAtLocation(node.name ?? node);
+  const { deprecated, reason: deprecationReason } = isSymbolDeprecated(symbol);
   return {
     name,
     kind: "method",
@@ -3396,7 +3564,8 @@ function serializeMethod(node, ctx) {
     tags: tags.length > 0 ? tags : undefined,
     visibility,
     signatures: signatures.length > 0 ? signatures : undefined,
-    flags: Object.keys(flags).length > 0 ? flags : undefined
+    flags: Object.keys(flags).length > 0 ? flags : undefined,
+    ...deprecated ? { deprecated: true, deprecationReason } : {}
   };
 }
 function serializeConstructor(node, ctx) {
@@ -3582,6 +3751,14 @@ function serializeFunctionExport(node, ctx, nameOverride) {
       ...callSignatures.length > 1 ? { overloadIndex: index } : {}
     };
   });
+  const flags = {};
+  const modifiers = ts8.getModifiers(node);
+  if (modifiers?.some((m) => m.kind === ts8.SyntaxKind.AsyncKeyword)) {
+    flags.async = true;
+  }
+  if (node.asteriskToken) {
+    flags.generator = true;
+  }
   return {
     id: name,
     name,
@@ -3591,6 +3768,7 @@ function serializeFunctionExport(node, ctx, nameOverride) {
     source,
     typeParameters,
     signatures,
+    ...Object.keys(flags).length > 0 ? { flags } : {},
     ...deprecated ? { deprecated: true, deprecationReason } : {},
     ...examples.length > 0 ? { examples } : {}
   };
@@ -3698,13 +3876,16 @@ function serializePropertySignature(node, ctx) {
   if (node.modifiers?.some((m) => m.kind === ts9.SyntaxKind.ReadonlyKeyword)) {
     flags.readonly = true;
   }
+  const symbol = checker.getSymbolAtLocation(node.name);
+  const { deprecated, reason: deprecationReason } = isSymbolDeprecated(symbol);
   return {
     name,
     kind: "property",
     description,
     tags: tags.length > 0 ? tags : undefined,
     schema,
-    flags: Object.keys(flags).length > 0 ? flags : undefined
+    flags: Object.keys(flags).length > 0 ? flags : undefined,
+    ...deprecated ? { deprecated: true, deprecationReason } : {}
   };
 }
 function serializeMethodSignature(node, ctx) {
@@ -3717,13 +3898,16 @@ function serializeMethodSignature(node, ctx) {
   const flags = {};
   if (node.questionToken)
     flags.optional = true;
+  const symbol = checker.getSymbolAtLocation(node.name);
+  const { deprecated, reason: deprecationReason } = isSymbolDeprecated(symbol);
   return {
     name,
     kind: "method",
     description,
     tags: tags.length > 0 ? tags : undefined,
     signatures: signatures.length > 0 ? signatures : undefined,
-    flags: Object.keys(flags).length > 0 ? flags : undefined
+    flags: Object.keys(flags).length > 0 ? flags : undefined,
+    ...deprecated ? { deprecated: true, deprecationReason } : {}
   };
 }
 function serializeCallSignature(node, ctx) {
@@ -4463,12 +4647,12 @@ async function getExport(options) {
   const result = createProgram({ entryFile, baseDir, content });
   const { program, sourceFile } = result;
   if (!sourceFile) {
-    return { export: null, types: [], errors: [`Could not load source file: ${entryFile}`] };
+    return { export: null, types: [], errors: [`Entry file not found: ${entryFile}. Specify with: drift get src/index.ts <name>`] };
   }
   const checker = program.getTypeChecker();
   const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
   if (!moduleSymbol) {
-    return { export: null, types: [], errors: ["Could not get module symbol"] };
+    return { export: null, types: [], errors: [`No exports found in ${entryFile}. Is this the right entry point?`] };
   }
   const exportedSymbols = checker.getExportsOfModule(moduleSymbol);
   const targetSymbol = exportedSymbols.find((s) => s.getName() === exportName);
@@ -4482,12 +4666,39 @@ async function getExport(options) {
   const ctx = createContext(program, sourceFile, { maxTypeDepth });
   ctx.exportedIds = exportedIds;
   try {
+    const originalDecls = targetSymbol.declarations ?? [];
+    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" }));
+      return { export: normalizeExport(spec2, { dialect: "draft-2020-12" }), types: types2, errors };
+    }
     const { declaration, resolvedSymbol, isTypeOnly } = resolveExportTarget(targetSymbol, checker);
     if (!declaration) {
+      const externalPackage = detectExternalPackage(targetSymbol, checker);
+      if (externalPackage) {
+        const stub = {
+          id: exportName,
+          name: exportName,
+          kind: "external",
+          source: { package: externalPackage }
+        };
+        return { export: stub, types: [], errors };
+      }
       return { export: null, types: [], errors: [`No declaration found for '${exportName}'`] };
     }
     let spec = serializeDeclaration(declaration, targetSymbol, resolvedSymbol, exportName, ctx, isTypeOnly);
     if (!spec) {
+      const externalPackage = detectExternalPackage(targetSymbol, checker);
+      if (externalPackage) {
+        const stub = {
+          id: exportName,
+          name: exportName,
+          kind: "external",
+          source: { package: externalPackage }
+        };
+        return { export: stub, types: [], errors };
+      }
       return { export: null, types: [], errors: [`Could not serialize '${exportName}'`] };
     }
     spec = normalizeExport(spec, { dialect: "draft-2020-12" });
@@ -4537,17 +4748,27 @@ function serializeDeclaration(declaration, _exportSymbol, _targetSymbol, exportN
   } else if (ts11.isVariableDeclaration(declaration)) {
     const varStatement = declaration.parent?.parent;
     if (varStatement && ts11.isVariableStatement(varStatement)) {
-      if (declaration.initializer && ts11.isArrowFunction(declaration.initializer)) {
+      if (declaration.initializer && (ts11.isArrowFunction(declaration.initializer) || ts11.isFunctionExpression(declaration.initializer))) {
         const varName = ts11.isIdentifier(declaration.name) ? declaration.name.text : declaration.name.getText();
         result = serializeFunctionExport(declaration.initializer, ctx, varName);
       } else {
-        result = serializeVariable(declaration, varStatement, ctx);
+        const checker = ctx.program.getTypeChecker();
+        const varType = checker.getTypeAtLocation(declaration);
+        if (varType.getCallSignatures().length > 0) {
+          result = serializeVariable(declaration, varStatement, ctx);
+          if (result)
+            result = { ...result, kind: "function" };
+        } else {
+          result = serializeVariable(declaration, varStatement, ctx);
+        }
       }
     }
+  } else if (ts11.isNamespaceExport(declaration) || ts11.isModuleDeclaration(declaration) || ts11.isNamespaceImport(declaration) || ts11.isSourceFile(declaration)) {
+    result = serializeNamespaceForGet(_exportSymbol, exportName, ctx);
   }
   if (result) {
     if (result.name !== exportName) {
-      result = { ...result, id: exportName, name: result.name };
+      result = { ...result, id: exportName, name: exportName };
     }
     if (isTypeOnly) {
       result = { ...result, flags: { ...result.flags ?? {}, typeOnly: true } };
@@ -4555,6 +4776,65 @@ function serializeDeclaration(declaration, _exportSymbol, _targetSymbol, exportN
   }
   return result;
 }
+function serializeNamespaceForGet(symbol, exportName, ctx) {
+  const checker = ctx.program.getTypeChecker();
+  let targetSymbol = symbol;
+  if (symbol.flags & ts11.SymbolFlags.Alias) {
+    const aliased = checker.getAliasedSymbol(symbol);
+    if (aliased && aliased !== symbol) {
+      targetSymbol = aliased;
+    }
+  }
+  const members = [];
+  try {
+    const nsExports = checker.getExportsOfModule(targetSymbol);
+    for (const memberSymbol of nsExports) {
+      const memberName = memberSymbol.getName();
+      const memberDecls = memberSymbol.declarations ?? [];
+      const memberDecl = memberSymbol.valueDeclaration || memberDecls[0];
+      if (memberDecl) {
+        const type = checker.getTypeAtLocation(memberDecl);
+        const kind = getExportKind(memberDecl, type);
+        members.push({ name: memberName, kind });
+      }
+    }
+  } catch {}
+  return {
+    id: exportName,
+    name: exportName,
+    kind: "namespace",
+    tags: [],
+    ...members.length > 0 ? { members } : {}
+  };
+}
+function detectExternalPackage(symbol, checker) {
+  let targetSymbol = symbol;
+  if (symbol.flags & ts11.SymbolFlags.Alias) {
+    const aliased = checker.getAliasedSymbol(symbol);
+    if (aliased && aliased !== symbol) {
+      targetSymbol = aliased;
+    }
+  }
+  const allDecls = [...targetSymbol.declarations ?? [], ...symbol.declarations ?? []];
+  for (const decl of allDecls) {
+    const sf = decl.getSourceFile();
+    if (sf?.fileName.includes("node_modules")) {
+      const match = sf.fileName.match(/node_modules\/(@[^/]+\/[^/]+|[^/]+)/);
+      if (match)
+        return match[1];
+    }
+    if (ts11.isExportSpecifier(decl)) {
+      const exportDecl = decl.parent?.parent;
+      if (exportDecl && ts11.isExportDeclaration(exportDecl) && exportDecl.moduleSpecifier) {
+        const moduleText = exportDecl.moduleSpecifier.text;
+        if (!moduleText.startsWith(".") && !moduleText.startsWith("/")) {
+          return moduleText;
+        }
+      }
+    }
+  }
+  return;
+}
 // src/primitives/list.ts
 import * as path4 from "node:path";
 import ts12 from "typescript";
@@ -4565,12 +4845,12 @@ async function listExports(options) {
   const result = createProgram({ entryFile, baseDir, content });
   const { program, sourceFile } = result;
   if (!sourceFile) {
-    return { exports: [], errors: [`Could not load source file: ${entryFile}`] };
+    return { exports: [], errors: [`Entry file not found: ${entryFile}. Specify with: drift list src/index.ts`] };
   }
   const checker = program.getTypeChecker();
   const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
   if (!moduleSymbol) {
-    return { exports: [], errors: ["Could not get module symbol"] };
+    return { exports: [], errors: [`No exports found in ${entryFile}. Is this the right entry point?`] };
   }
   const exportedSymbols = checker.getExportsOfModule(moduleSymbol);
   for (const symbol of exportedSymbols) {
@@ -4598,8 +4878,15 @@ function extractExportItem(symbol, checker, entryFile, entrySourceFile) {
   }
   const declarations = targetSymbol.declarations ?? [];
   const declaration = targetSymbol.valueDeclaration || declarations.find((d) => d.kind !== ts12.SyntaxKind.ExportSpecifier) || declarations[0];
-  if (!declaration)
-    return null;
+  if (!declaration) {
+    return {
+      name,
+      kind: "external",
+      file: "<external>",
+      line: 0,
+      reexport: true
+    };
+  }
   if (ts12.isSourceFile(declaration)) {
     return {
       name,
@@ -5769,7 +6056,7 @@ async function extract(options) {
     if (!sourceFile) {
       return {
         spec: createEmptySpec(entryFile, includeSchema, isDtsSource),
-        diagnostics: [{ message: `Could not load source file: ${entryFile}`, severity: "error" }]
+        diagnostics: [{ message: `Entry file not found: ${entryFile}. Specify with: drift list src/index.ts`, severity: "error" }]
       };
     }
     const typeChecker = program.getTypeChecker();
@@ -5777,7 +6064,7 @@ async function extract(options) {
     if (!moduleSymbol) {
       return {
         spec: createEmptySpec(entryFile, includeSchema, isDtsSource),
-        diagnostics: [{ message: "Could not get module symbol", severity: "warning" }]
+        diagnostics: [{ message: `No exports found in ${entryFile}. Is this the right entry point?`, severity: "warning" }]
       };
     }
     const exportedSymbols = typeChecker.getExportsOfModule(moduleSymbol);
@@ -5896,6 +6183,41 @@ async function extract(options) {
     }
     const verification = buildVerificationSummary(exportedSymbols.length, exports.length, exportTracker);
     const meta = await getPackageMeta(entryFile, baseDir);
+    {
+      const symFlags = ts16.SymbolFlags.Type | ts16.SymbolFlags.Interface | ts16.SymbolFlags.Class;
+      const maxPasses = 5;
+      for (let pass = 0;pass < maxPasses; pass++) {
+        const allRefs = new Map;
+        for (const exp of exports) {
+          collectAllRefsWithContext(exp, allRefs, {
+            exportName: exp.id || exp.name,
+            location: "property",
+            path: []
+          });
+        }
+        for (const t of ctx.typeRegistry.getAll()) {
+          collectAllRefsWithContext(t, allRefs, {
+            exportName: t.id,
+            location: "property",
+            path: []
+          });
+        }
+        let added = 0;
+        for (const [typeName] of allRefs) {
+          if (ctx.typeRegistry.has(typeName))
+            continue;
+          if (BUILTIN_TYPES2.has(typeName))
+            continue;
+          const tsType = findTypeInProgram(typeName, typeChecker, program, sourceFile, symFlags);
+          if (tsType) {
+            ctx.typeRegistry.registerType(tsType, ctx);
+            added++;
+          }
+        }
+        if (added === 0)
+          break;
+      }
+    }
     const types = ctx.typeRegistry.getAll();
     const projectBaseDir = baseDir ?? path8.dirname(entryFile);
     const definedTypes = new Set(types.map((t) => t.id));
@@ -6022,11 +6344,17 @@ function serializeDeclaration2(declaration, exportSymbol, exportName, ctx, isTyp
   } else if (ts16.isVariableDeclaration(declaration)) {
     const varStatement = declaration.parent?.parent;
     if (varStatement && ts16.isVariableStatement(varStatement)) {
-      if (declaration.initializer && ts16.isArrowFunction(declaration.initializer)) {
+      if (declaration.initializer && (ts16.isArrowFunction(declaration.initializer) || ts16.isFunctionExpression(declaration.initializer))) {
         const varName = ts16.isIdentifier(declaration.name) ? declaration.name.text : declaration.name.getText();
         result = serializeFunctionExport(declaration.initializer, ctx, varName);
       } else {
         result = serializeVariable(declaration, varStatement, ctx);
+        if (result?.kind === "variable") {
+          const type = ctx.typeChecker.getTypeAtLocation(declaration);
+          if (type.getConstructSignatures().length > 0) {
+            result = { ...result, kind: "class" };
+          }
+        }
       }
     }
   } else if (ts16.isNamespaceExport(declaration) || ts16.isModuleDeclaration(declaration) || ts16.isNamespaceImport(declaration) || ts16.isSourceFile(declaration)) {
@@ -6051,6 +6379,12 @@ function serializeDeclaration2(declaration, exportSymbol, exportName, ctx, isTyp
         flags: { ...result.flags ?? {}, typeOnly: true }
       };
     }
+    if (!result.deprecated) {
+      const { deprecated, reason: deprecationReason } = isSymbolDeprecated(exportSymbol);
+      if (deprecated) {
+        result = { ...result, deprecated: true, deprecationReason };
+      }
+    }
   }
   return result;
 }
@@ -6098,7 +6432,7 @@ function serializeNamespaceMember(symbol, memberName, ctx) {
     return null;
   const type = checker.getTypeAtLocation(declaration);
   const callSignatures = type.getCallSignatures();
-  const deprecated = isSymbolDeprecated(targetSymbol);
+  const { deprecated } = isSymbolDeprecated(targetSymbol);
   let kind = "variable";
   if (ts16.isFunctionDeclaration(declaration) || ts16.isFunctionExpression(declaration)) {
     kind = "function";
@@ -6219,20 +6553,42 @@ function createEmptySpec(entryFile, includeSchema, isDtsSource) {
     }
   };
 }
+function findTypeInProgram(name, checker, program, sourceFile, symFlags) {
+  const localSym = checker.resolveName(name, sourceFile, symFlags, false);
+  if (localSym)
+    return checker.getDeclaredTypeOfSymbol(localSym);
+  const entryDir = path8.dirname(sourceFile.fileName);
+  for (const sf of program.getSourceFiles()) {
+    const fn = sf.fileName;
+    if (fn.includes("/typescript/lib/lib.") || fn.includes("\\typescript\\lib\\lib."))
+      continue;
+    if (fn.includes("/@types/node/") || fn.includes("\\@types\\node\\"))
+      continue;
+    if (fn.startsWith(entryDir))
+      continue;
+    const sym = checker.resolveName(name, sf, symFlags, false);
+    if (sym)
+      return checker.getDeclaredTypeOfSymbol(sym);
+  }
+  return;
+}
 async function getPackageMeta(entryFile, baseDir) {
-  const searchDir = baseDir ?? path8.dirname(entryFile);
-  const pkgPath = path8.join(searchDir, "package.json");
-  try {
-    if (fs7.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
-      return {
-        name: pkg.name ?? path8.basename(searchDir),
-        version: pkg.version,
-        description: pkg.description
-      };
-    }
-  } catch {}
-  return { name: path8.basename(searchDir) };
+  let dir = baseDir ?? path8.dirname(entryFile);
+  while (dir !== path8.dirname(dir)) {
+    const pkgPath = path8.join(dir, "package.json");
+    try {
+      if (fs7.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
+        return {
+          name: pkg.name ?? path8.basename(dir),
+          version: pkg.version,
+          description: pkg.description
+        };
+      }
+    } catch {}
+    dir = path8.dirname(dir);
+  }
+  return { name: path8.basename(baseDir ?? path8.dirname(entryFile)) };
 }
 
 // src/primitives/spec.ts
@@ -6355,8 +6711,10 @@ export {
   arktypeAdapter,
   analyzeSpec,
   TypeRegistry,
+  STRING_PROTOTYPE_METHODS,
   QueryBuilder,
   PRIMITIVES,
+  NUMBER_PROTOTYPE_METHODS,
   CacheManager,
   CONFIG_FILENAME,
   BUILTIN_TYPE_SCHEMAS,