@openpkg-ts/extract 0.12.0 → 0.13.0

package/dist/bin/tspec.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   extract
-} from "../shared/chunk-wddga8ye.js";
+} from "../shared/chunk-ksf9k654.js";
 
 // src/cli/spec.ts
 import * as fs from "node:fs";

package/dist/shared/{chunk-wddga8ye.js → chunk-ksf9k654.js}

@@ -203,17 +203,133 @@ class TypeRegistry {
     if (external) {
       kind = "external";
     }
-    const typeString = checker.typeToString(type);
     const source = decl ? buildExternalSource(decl) : undefined;
+    const schema = this.buildShallowSchema(type, checker);
+    let members;
+    if (decl && (ts.isClassDeclaration(decl) || ts.isInterfaceDeclaration(decl))) {
+      members = this.extractShallowMembers(decl, checker);
+    }
     return {
       id: name,
       name,
       kind,
-      type: typeString !== name ? typeString : undefined,
+      schema,
+      members: members?.length ? members : undefined,
       ...external ? { external: true } : {},
       ...source ? { source } : {}
     };
   }
+  buildShallowSchema(type, checker) {
+    if (type.isUnion()) {
+      const allEnumLiterals = type.types.every((t) => t.flags & (ts.TypeFlags.EnumLiteral | ts.TypeFlags.NumberLiteral));
+      if (allEnumLiterals) {
+        const values = type.types.map((t) => {
+          if (t.flags & ts.TypeFlags.NumberLiteral) {
+            return t.value;
+          }
+          return checker.typeToString(t);
+        }).filter((v) => v !== undefined);
+        if (values.every((v) => typeof v === "number")) {
+          return { type: "number", enum: values };
+        }
+        return { type: "string", enum: values };
+      }
+      return {
+        anyOf: type.types.map((t) => {
+          if (t.flags & ts.TypeFlags.EnumLiteral) {
+            const value = t.value;
+            if (typeof value === "number") {
+              return { type: "number", enum: [value] };
+            }
+            return { type: checker.typeToString(t) };
+          }
+          const sym = t.getSymbol() || t.aliasSymbol;
+          if (sym && sym.flags & ts.SymbolFlags.EnumMember) {
+            return { type: checker.typeToString(t) };
+          }
+          if (sym && !sym.getName().startsWith("__")) {
+            return { $ref: sym.getName() };
+          }
+          if (t.flags & ts.TypeFlags.StringLiteral) {
+            return { type: "string", enum: [t.value] };
+          }
+          if (t.flags & ts.TypeFlags.NumberLiteral) {
+            return { type: "number", enum: [t.value] };
+          }
+          return { type: checker.typeToString(t) };
+        })
+      };
+    }
+    if (type.isIntersection()) {
+      return {
+        allOf: type.types.map((t) => {
+          const sym = t.getSymbol() || t.aliasSymbol;
+          if (sym && !sym.getName().startsWith("__")) {
+            return { $ref: sym.getName() };
+          }
+          return { type: checker.typeToString(t) };
+        })
+      };
+    }
+    const props = type.getProperties();
+    if (props.length > 0) {
+      const properties = {};
+      const required = [];
+      for (const prop of props.slice(0, 30)) {
+        const propName = prop.getName();
+        if (propName.startsWith("_"))
+          continue;
+        const propType = checker.getTypeOfSymbol(prop);
+        const callSigs = propType.getCallSignatures();
+        if (callSigs.length > 0) {
+          properties[propName] = { type: "function" };
+        } else {
+          const propSym = propType.getSymbol() || propType.aliasSymbol;
+          const symName = propSym?.getName();
+          if (propSym && symName && !symName.startsWith("__") && symName !== propName) {
+            properties[propName] = { $ref: symName };
+          } else {
+            properties[propName] = { type: checker.typeToString(propType) };
+          }
+        }
+        if (!(prop.flags & ts.SymbolFlags.Optional)) {
+          required.push(propName);
+        }
+      }
+      return {
+        type: "object",
+        properties,
+        ...required.length ? { required } : {}
+      };
+    }
+    return { type: checker.typeToString(type) };
+  }
+  extractShallowMembers(decl, checker) {
+    const members = [];
+    for (const member of decl.members) {
+      if (ts.isPropertyDeclaration(member) || ts.isPropertySignature(member)) {
+        const name = member.name?.getText();
+        if (!name || name.startsWith("#") || name.startsWith("_"))
+          continue;
+        const type = checker.getTypeAtLocation(member);
+        const sym = type.getSymbol() || type.aliasSymbol;
+        members.push({
+          name,
+          kind: "property",
+          schema: sym && !sym.getName().startsWith("__") ? { $ref: sym.getName() } : { type: checker.typeToString(type) }
+        });
+      } else if (ts.isMethodDeclaration(member) || ts.isMethodSignature(member)) {
+        const name = member.name?.getText();
+        if (!name || name.startsWith("#") || name.startsWith("_"))
+          continue;
+        members.push({
+          name,
+          kind: "method"
+        });
+      }
+    }
+    return members;
+  }
   registerFromSymbol(symbol, checker) {
     const name = symbol.getName();
     if (this.has(name))
@@ -289,6 +405,29 @@ function getParamDescription(propertyName, jsdocTags, inferredAlias) {
   }
   return;
 }
+function extractTypeParameters(node, checker) {
+  if (!node.typeParameters || node.typeParameters.length === 0) {
+    return;
+  }
+  return node.typeParameters.map((tp) => {
+    const name = tp.name.text;
+    let constraint;
+    if (tp.constraint) {
+      const constraintType = checker.getTypeAtLocation(tp.constraint);
+      constraint = checker.typeToString(constraintType);
+    }
+    let defaultType;
+    if (tp.default) {
+      const defType = checker.getTypeAtLocation(tp.default);
+      defaultType = checker.typeToString(defType);
+    }
+    return {
+      name,
+      ...constraint ? { constraint } : {},
+      ...defaultType ? { default: defaultType } : {}
+    };
+  });
+}
 
 // src/compiler/program.ts
 import * as path2 from "node:path";
@@ -339,57 +478,6 @@ function createProgram({
   };
 }
 
-// src/serializers/classes.ts
-function serializeClass(node, ctx) {
-  const symbol = ctx.typeChecker.getSymbolAtLocation(node.name ?? node);
-  const name = symbol?.getName() ?? node.name?.getText();
-  if (!name)
-    return null;
-  const declSourceFile = node.getSourceFile();
-  const { description, tags, examples } = getJSDocComment(node);
-  const source = getSourceLocation(node, declSourceFile);
-  return {
-    id: name,
-    name,
-    kind: "class",
-    description,
-    tags,
-    source,
-    members: [],
-    ...examples.length > 0 ? { examples } : {}
-  };
-}
-
-// src/serializers/enums.ts
-function serializeEnum(node, ctx) {
-  const symbol = ctx.typeChecker.getSymbolAtLocation(node.name ?? node);
-  const name = symbol?.getName() ?? node.name?.getText();
-  if (!name)
-    return null;
-  const declSourceFile = node.getSourceFile();
-  const { description, tags, examples } = getJSDocComment(node);
-  const source = getSourceLocation(node, declSourceFile);
-  const members = node.members.map((member) => {
-    const memberSymbol = ctx.typeChecker.getSymbolAtLocation(member.name);
-    const memberName = memberSymbol?.getName() ?? member.name.getText();
-    return {
-      id: memberName,
-      name: memberName,
-      kind: "enum-member"
-    };
-  });
-  return {
-    id: name,
-    name,
-    kind: "enum",
-    description,
-    tags,
-    source,
-    members,
-    ...examples.length > 0 ? { examples } : {}
-  };
-}
-
 // src/types/schema-builder.ts
 import ts4 from "typescript";
 var PRIMITIVES2 = new Set([
@@ -574,15 +662,15 @@ function buildSchema(type, checker, ctx, _depth = 0) {
     const elementTypes = typeRef2.typeArguments ?? [];
     if (ctx) {
       return withDepth(ctx, () => ({
-        type: "tuple",
-        items: elementTypes.map((t) => buildSchema(t, checker, ctx)),
+        type: "array",
+        prefixedItems: elementTypes.map((t) => buildSchema(t, checker, ctx)),
         minItems: elementTypes.length,
         maxItems: elementTypes.length
       }));
     }
     return {
-      type: "tuple",
-      items: elementTypes.map((t) => buildSchema(t, checker, ctx)),
+      type: "array",
+      prefixedItems: elementTypes.map((t) => buildSchema(t, checker, ctx)),
       minItems: elementTypes.length,
       maxItems: elementTypes.length
     };
@@ -591,6 +679,9 @@ function buildSchema(type, checker, ctx, _depth = 0) {
   if (typeRef.target && typeRef.typeArguments && typeRef.typeArguments.length > 0) {
     const symbol2 = typeRef.target.getSymbol();
     const name = symbol2?.getName();
+    if (name && BUILTIN_TYPES.has(name)) {
+      return { $ref: name };
+    }
     if (name && (isBuiltinGeneric(name) || !isAnonymous(typeRef.target))) {
       if (ctx) {
         return withDepth(ctx, () => ({
@@ -801,7 +892,10 @@ function extractDefaultValue(initializer) {
 function registerReferencedTypes(type, ctx) {
   if (ctx.visitedTypes.has(type))
     return;
-  ctx.visitedTypes.add(type);
+  const isPrimitive = type.flags & (ts5.TypeFlags.String | ts5.TypeFlags.Number | ts5.TypeFlags.Boolean | ts5.TypeFlags.Void | ts5.TypeFlags.Undefined | ts5.TypeFlags.Null | ts5.TypeFlags.Any | ts5.TypeFlags.Unknown | ts5.TypeFlags.Never | ts5.TypeFlags.StringLiteral | ts5.TypeFlags.NumberLiteral | ts5.TypeFlags.BooleanLiteral);
+  if (!isPrimitive) {
+    ctx.visitedTypes.add(type);
+  }
   const { typeChecker: checker, typeRegistry, exportedIds } = ctx;
   typeRegistry.registerType(type, checker, exportedIds);
   const typeArgs = type.typeArguments;
@@ -822,6 +916,280 @@ function registerReferencedTypes(type, ctx) {
   }
 }
 
+// src/serializers/classes.ts
+import ts6 from "typescript";
+function serializeClass(node, ctx) {
+  const { typeChecker: checker } = ctx;
+  const symbol = checker.getSymbolAtLocation(node.name ?? node);
+  const name = symbol?.getName() ?? node.name?.getText();
+  if (!name)
+    return null;
+  const declSourceFile = node.getSourceFile();
+  const { description, tags, examples } = getJSDocComment(node);
+  const source = getSourceLocation(node, declSourceFile);
+  const typeParameters = extractTypeParameters(node, checker);
+  const members = [];
+  const signatures = [];
+  const methodsByName = new Map;
+  for (const member of node.members) {
+    const memberName = getMemberName(member);
+    if (memberName?.startsWith("#"))
+      continue;
+    if (ts6.isPropertyDeclaration(member)) {
+      const propMember = serializeProperty(member, ctx);
+      if (propMember)
+        members.push(propMember);
+    } else if (ts6.isMethodDeclaration(member)) {
+      const methodMember = serializeMethod(member, ctx);
+      if (methodMember && methodMember.name) {
+        if (!methodsByName.has(methodMember.name)) {
+          methodsByName.set(methodMember.name, methodMember);
+        } else {
+          const existing = methodsByName.get(methodMember.name);
+          if (!existing.description && methodMember.description) {
+            existing.description = methodMember.description;
+          }
+          if (!existing.tags && methodMember.tags) {
+            existing.tags = methodMember.tags;
+          }
+        }
+      }
+    } else if (ts6.isConstructorDeclaration(member)) {
+      const ctorSig = serializeConstructor(member, ctx);
+      if (ctorSig)
+        signatures.push(ctorSig);
+    } else if (ts6.isGetAccessorDeclaration(member) || ts6.isSetAccessorDeclaration(member)) {
+      const accessorMember = serializeAccessor(member, ctx);
+      if (accessorMember)
+        members.push(accessorMember);
+    }
+  }
+  members.push(...methodsByName.values());
+  const extendsClause = getExtendsClause(node, checker);
+  const implementsClause = getImplementsClause(node, checker);
+  return {
+    id: name,
+    name,
+    kind: "class",
+    description,
+    tags,
+    source,
+    typeParameters,
+    members: members.length > 0 ? members : undefined,
+    signatures: signatures.length > 0 ? signatures : undefined,
+    extends: extendsClause,
+    implements: implementsClause?.length ? implementsClause : undefined,
+    ...examples.length > 0 ? { examples } : {}
+  };
+}
+function getMemberName(member) {
+  if (ts6.isConstructorDeclaration(member))
+    return "constructor";
+  if (!member.name)
+    return;
+  if (ts6.isIdentifier(member.name))
+    return member.name.text;
+  if (ts6.isPrivateIdentifier(member.name))
+    return member.name.text;
+  return member.name.getText();
+}
+function getVisibility(member) {
+  const modifiers = ts6.getModifiers(member);
+  if (!modifiers)
+    return;
+  for (const mod of modifiers) {
+    if (mod.kind === ts6.SyntaxKind.PrivateKeyword)
+      return "private";
+    if (mod.kind === ts6.SyntaxKind.ProtectedKeyword)
+      return "protected";
+    if (mod.kind === ts6.SyntaxKind.PublicKeyword)
+      return "public";
+  }
+  return;
+}
+function isStatic(member) {
+  const modifiers = ts6.getModifiers(member);
+  return modifiers?.some((m) => m.kind === ts6.SyntaxKind.StaticKeyword) ?? false;
+}
+function isReadonly(member) {
+  const modifiers = ts6.getModifiers(member);
+  return modifiers?.some((m) => m.kind === ts6.SyntaxKind.ReadonlyKeyword) ?? false;
+}
+function serializeProperty(node, ctx) {
+  const { typeChecker: checker } = ctx;
+  const name = getMemberName(node);
+  if (!name)
+    return null;
+  const { description, tags } = getJSDocComment(node);
+  const visibility = getVisibility(node);
+  const type = checker.getTypeAtLocation(node);
+  const schema = buildSchema(type, checker, ctx);
+  registerReferencedTypes(type, ctx);
+  const flags = {};
+  if (isStatic(node))
+    flags.static = true;
+  if (isReadonly(node))
+    flags.readonly = true;
+  if (node.questionToken)
+    flags.optional = true;
+  return {
+    name,
+    kind: "property",
+    description,
+    tags: tags.length > 0 ? tags : undefined,
+    visibility,
+    schema,
+    flags: Object.keys(flags).length > 0 ? flags : undefined
+  };
+}
+function serializeMethod(node, ctx) {
+  const { typeChecker: checker } = ctx;
+  const name = getMemberName(node);
+  if (!name)
+    return null;
+  const { description, tags } = getJSDocComment(node);
+  const visibility = getVisibility(node);
+  const type = checker.getTypeAtLocation(node);
+  const callSignatures = type.getCallSignatures();
+  const signatures = callSignatures.map((sig) => {
+    const params = extractParameters(sig, ctx);
+    const returnType = checker.getReturnTypeOfSignature(sig);
+    registerReferencedTypes(returnType, ctx);
+    return {
+      parameters: params.length > 0 ? params : undefined,
+      returns: {
+        schema: buildSchema(returnType, checker, ctx)
+      }
+    };
+  });
+  const flags = {};
+  if (isStatic(node))
+    flags.static = true;
+  if (node.asteriskToken)
+    flags.generator = true;
+  const modifiers = ts6.getModifiers(node);
+  if (modifiers?.some((m) => m.kind === ts6.SyntaxKind.AsyncKeyword)) {
+    flags.async = true;
+  }
+  return {
+    name,
+    kind: "method",
+    description,
+    tags: tags.length > 0 ? tags : undefined,
+    visibility,
+    signatures: signatures.length > 0 ? signatures : undefined,
+    flags: Object.keys(flags).length > 0 ? flags : undefined
+  };
+}
+function serializeConstructor(node, ctx) {
+  const { typeChecker: checker } = ctx;
+  const { description } = getJSDocComment(node);
+  const sig = checker.getSignatureFromDeclaration(node);
+  if (!sig)
+    return null;
+  const params = extractParameters(sig, ctx);
+  return {
+    description,
+    parameters: params.length > 0 ? params : undefined
+  };
+}
+function serializeAccessor(node, ctx) {
+  const { typeChecker: checker } = ctx;
+  const name = getMemberName(node);
+  if (!name)
+    return null;
+  const { description, tags } = getJSDocComment(node);
+  const visibility = getVisibility(node);
+  const type = checker.getTypeAtLocation(node);
+  const schema = buildSchema(type, checker, ctx);
+  registerReferencedTypes(type, ctx);
+  const kind = ts6.isGetAccessorDeclaration(node) ? "getter" : "setter";
+  const flags = {};
+  if (isStatic(node))
+    flags.static = true;
+  return {
+    name,
+    kind,
+    description,
+    tags: tags.length > 0 ? tags : undefined,
+    visibility,
+    schema,
+    flags: Object.keys(flags).length > 0 ? flags : undefined
+  };
+}
+function getExtendsClause(node, checker) {
+  if (!node.heritageClauses)
+    return;
+  for (const clause of node.heritageClauses) {
+    if (clause.token === ts6.SyntaxKind.ExtendsKeyword) {
+      const expr = clause.types[0];
+      if (expr) {
+        const type = checker.getTypeAtLocation(expr);
+        const symbol = type.getSymbol();
+        return symbol?.getName() ?? expr.expression.getText();
+      }
+    }
+  }
+  return;
+}
+function getImplementsClause(node, checker) {
+  if (!node.heritageClauses)
+    return;
+  for (const clause of node.heritageClauses) {
+    if (clause.token === ts6.SyntaxKind.ImplementsKeyword) {
+      return clause.types.map((expr) => {
+        const type = checker.getTypeAtLocation(expr);
+        const symbol = type.getSymbol();
+        return symbol?.getName() ?? expr.expression.getText();
+      });
+    }
+  }
+  return;
+}
+
+// src/serializers/enums.ts
+function serializeEnum(node, ctx) {
+  const { typeChecker: checker } = ctx;
+  const symbol = checker.getSymbolAtLocation(node.name ?? node);
+  const name = symbol?.getName() ?? node.name?.getText();
+  if (!name)
+    return null;
+  const declSourceFile = node.getSourceFile();
+  const { description, tags, examples } = getJSDocComment(node);
+  const source = getSourceLocation(node, declSourceFile);
+  const members = node.members.map((member) => {
+    const memberSymbol = checker.getSymbolAtLocation(member.name);
+    const memberName = memberSymbol?.getName() ?? member.name.getText();
+    const constantValue = checker.getConstantValue(member);
+    let schema;
+    if (typeof constantValue === "string") {
+      schema = { type: "string", enum: [constantValue] };
+    } else if (typeof constantValue === "number") {
+      schema = { type: "number", enum: [constantValue] };
+    } else if (member.initializer) {
+      schema = { type: member.initializer.getText() };
+    }
+    const { description: memberDesc } = getJSDocComment(member);
+    return {
+      id: memberName,
+      name: memberName,
+      kind: "enum-member",
+      ...schema ? { schema } : {},
+      ...memberDesc ? { description: memberDesc } : {}
+    };
+  });
+  return {
+    id: name,
+    name,
+    kind: "enum",
+    description,
+    tags,
+    source,
+    members,
+    ...examples.length > 0 ? { examples } : {}
+  };
+}
+
 // src/serializers/functions.ts
 function serializeFunctionExport(node, ctx) {
   const symbol = ctx.typeChecker.getSymbolAtLocation(node.name ?? node);
@@ -831,6 +1199,7 @@ function serializeFunctionExport(node, ctx) {
   const declSourceFile = node.getSourceFile();
   const { description, tags, examples } = getJSDocComment(node);
   const source = getSourceLocation(node, declSourceFile);
+  const typeParameters = extractTypeParameters(node, ctx.typeChecker);
   const type = ctx.typeChecker.getTypeAtLocation(node);
   const callSignatures = type.getCallSignatures();
   const signatures = callSignatures.map((sig) => {
@@ -851,20 +1220,50 @@ function serializeFunctionExport(node, ctx) {
     description,
     tags,
     source,
+    typeParameters,
     signatures,
     ...examples.length > 0 ? { examples } : {}
   };
 }
 
 // src/serializers/interfaces.ts
+import ts7 from "typescript";
 function serializeInterface(node, ctx) {
-  const symbol = ctx.typeChecker.getSymbolAtLocation(node.name ?? node);
+  const { typeChecker: checker } = ctx;
+  const symbol = checker.getSymbolAtLocation(node.name ?? node);
   const name = symbol?.getName() ?? node.name?.getText();
   if (!name)
     return null;
   const declSourceFile = node.getSourceFile();
   const { description, tags, examples } = getJSDocComment(node);
   const source = getSourceLocation(node, declSourceFile);
+  const typeParameters = extractTypeParameters(node, checker);
+  const members = [];
+  const methodsByName = new Map;
+  for (const member of node.members) {
+    if (ts7.isPropertySignature(member)) {
+      const propMember = serializePropertySignature(member, ctx);
+      if (propMember)
+        members.push(propMember);
+    } else if (ts7.isMethodSignature(member)) {
+      const methodMember = serializeMethodSignature(member, ctx);
+      if (methodMember && methodMember.name) {
+        if (!methodsByName.has(methodMember.name)) {
+          methodsByName.set(methodMember.name, methodMember);
+        }
+      }
+    } else if (ts7.isCallSignatureDeclaration(member)) {
+      const callMember = serializeCallSignature(member, ctx);
+      if (callMember)
+        members.push(callMember);
+    } else if (ts7.isIndexSignatureDeclaration(member)) {
+      const indexMember = serializeIndexSignature(member, ctx);
+      if (indexMember)
+        members.push(indexMember);
+    }
+  }
+  members.push(...methodsByName.values());
+  const extendsClause = getInterfaceExtends(node, checker);
   return {
     id: name,
     name,
@@ -872,10 +1271,121 @@ function serializeInterface(node, ctx) {
     description,
     tags,
     source,
-    members: [],
+    typeParameters,
+    members: members.length > 0 ? members : undefined,
+    extends: extendsClause,
     ...examples.length > 0 ? { examples } : {}
   };
 }
+function serializePropertySignature(node, ctx) {
+  const { typeChecker: checker } = ctx;
+  const name = node.name.getText();
+  const { description, tags } = getJSDocComment(node);
+  const type = checker.getTypeAtLocation(node);
+  const schema = buildSchema(type, checker, ctx);
+  registerReferencedTypes(type, ctx);
+  const flags = {};
+  if (node.questionToken)
+    flags.optional = true;
+  if (node.modifiers?.some((m) => m.kind === ts7.SyntaxKind.ReadonlyKeyword)) {
+    flags.readonly = true;
+  }
+  return {
+    name,
+    kind: "property",
+    description,
+    tags: tags.length > 0 ? tags : undefined,
+    schema,
+    flags: Object.keys(flags).length > 0 ? flags : undefined
+  };
+}
+function serializeMethodSignature(node, ctx) {
+  const { typeChecker: checker } = ctx;
+  const name = node.name.getText();
+  const { description, tags } = getJSDocComment(node);
+  const type = checker.getTypeAtLocation(node);
+  const callSignatures = type.getCallSignatures();
+  const signatures = callSignatures.map((sig) => {
+    const params = extractParameters(sig, ctx);
+    const returnType = checker.getReturnTypeOfSignature(sig);
+    registerReferencedTypes(returnType, ctx);
+    return {
+      parameters: params.length > 0 ? params : undefined,
+      returns: {
+        schema: buildSchema(returnType, checker, ctx)
+      }
+    };
+  });
+  const flags = {};
+  if (node.questionToken)
+    flags.optional = true;
+  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
+  };
+}
+function serializeCallSignature(node, ctx) {
+  const { typeChecker: checker } = ctx;
+  const { description, tags } = getJSDocComment(node);
+  const sig = checker.getSignatureFromDeclaration(node);
+  if (!sig)
+    return null;
+  const params = extractParameters(sig, ctx);
+  const returnType = checker.getReturnTypeOfSignature(sig);
+  registerReferencedTypes(returnType, ctx);
+  return {
+    name: "()",
+    kind: "call-signature",
+    description,
+    tags: tags.length > 0 ? tags : undefined,
+    signatures: [
+      {
+        parameters: params.length > 0 ? params : undefined,
+        returns: {
+          schema: buildSchema(returnType, checker, ctx)
+        }
+      }
+    ]
+  };
+}
+function serializeIndexSignature(node, ctx) {
+  const { typeChecker: checker } = ctx;
+  const { description, tags } = getJSDocComment(node);
+  const valueType = node.type ? checker.getTypeAtLocation(node.type) : checker.getAnyType();
+  const valueSchema = buildSchema(valueType, checker, ctx);
+  registerReferencedTypes(valueType, ctx);
+  const keyParam = node.parameters[0];
+  const keyType = keyParam?.type ? checker.getTypeAtLocation(keyParam.type) : checker.getStringType();
+  const keyTypeName = checker.typeToString(keyType);
+  return {
+    name: `[${keyTypeName}]`,
+    kind: "index-signature",
+    description,
+    tags: tags.length > 0 ? tags : undefined,
+    schema: {
+      type: "object",
+      additionalProperties: valueSchema
+    }
+  };
+}
+function getInterfaceExtends(node, checker) {
+  if (!node.heritageClauses)
+    return;
+  for (const clause of node.heritageClauses) {
+    if (clause.token === ts7.SyntaxKind.ExtendsKeyword && clause.types.length > 0) {
+      const names = clause.types.map((expr) => {
+        const type = checker.getTypeAtLocation(expr);
+        return type.getSymbol()?.getName() ?? expr.expression.getText();
+      });
+      return names.length === 1 ? names[0] : names;
+    }
+  }
+  return;
+}
 
 // src/serializers/type-aliases.ts
 function serializeTypeAlias(node, ctx) {
@@ -886,7 +1396,9 @@ function serializeTypeAlias(node, ctx) {
   const declSourceFile = node.getSourceFile();
   const { description, tags, examples } = getJSDocComment(node);
   const source = getSourceLocation(node, declSourceFile);
+  const typeParameters = extractTypeParameters(node, ctx.typeChecker);
   const type = ctx.typeChecker.getTypeAtLocation(node);
+  const schema = buildSchema(type, ctx.typeChecker, ctx);
   registerReferencedTypes(type, ctx);
   return {
     id: name,
@@ -895,7 +1407,8 @@ function serializeTypeAlias(node, ctx) {
     description,
     tags,
     source,
-    schema: buildSchema(type, ctx.typeChecker, ctx),
+    typeParameters,
+    schema,
     ...examples.length > 0 ? { examples } : {}
   };
 }
@@ -910,6 +1423,7 @@ function serializeVariable(node, statement, ctx) {
   const { description, tags, examples } = getJSDocComment(statement);
   const source = getSourceLocation(node, declSourceFile);
   const type = ctx.typeChecker.getTypeAtLocation(node);
+  const schema = buildSchema(type, ctx.typeChecker, ctx);
   registerReferencedTypes(type, ctx);
   return {
     id: name,
@@ -918,7 +1432,7 @@ function serializeVariable(node, statement, ctx) {
     description,
     tags,
     source,
-    schema: buildSchema(type, ctx.typeChecker, ctx),
+    schema,
     ...examples.length > 0 ? { examples } : {}
   };
 }
@@ -927,7 +1441,7 @@ function serializeVariable(node, statement, ctx) {
 import * as fs2 from "node:fs";
 import * as path3 from "node:path";
 import { SCHEMA_VERSION } from "@openpkg-ts/spec";
-import ts6 from "typescript";
+import ts8 from "typescript";
 
 // src/serializers/context.ts
 function createContext(program, sourceFile, options = {}) {
@@ -1004,36 +1518,36 @@ async function extract(options) {
 }
 function resolveExportTarget(symbol, checker) {
   let targetSymbol = symbol;
-  if (symbol.flags & ts6.SymbolFlags.Alias) {
+  if (symbol.flags & ts8.SymbolFlags.Alias) {
     const aliasTarget = checker.getAliasedSymbol(symbol);
     if (aliasTarget && aliasTarget !== symbol) {
       targetSymbol = aliasTarget;
     }
   }
   const declarations = targetSymbol.declarations ?? [];
-  const declaration = targetSymbol.valueDeclaration || declarations.find((decl) => decl.kind !== ts6.SyntaxKind.ExportSpecifier) || declarations[0];
+  const declaration = targetSymbol.valueDeclaration || declarations.find((decl) => decl.kind !== ts8.SyntaxKind.ExportSpecifier) || declarations[0];
   return { declaration, targetSymbol };
 }
 function serializeDeclaration(declaration, exportSymbol, targetSymbol, exportName, ctx) {
   let result = null;
-  if (ts6.isFunctionDeclaration(declaration)) {
+  if (ts8.isFunctionDeclaration(declaration)) {
     result = serializeFunctionExport(declaration, ctx);
-  } else if (ts6.isClassDeclaration(declaration)) {
+  } else if (ts8.isClassDeclaration(declaration)) {
     result = serializeClass(declaration, ctx);
-  } else if (ts6.isInterfaceDeclaration(declaration)) {
+  } else if (ts8.isInterfaceDeclaration(declaration)) {
     result = serializeInterface(declaration, ctx);
-  } else if (ts6.isTypeAliasDeclaration(declaration)) {
+  } else if (ts8.isTypeAliasDeclaration(declaration)) {
     result = serializeTypeAlias(declaration, ctx);
-  } else if (ts6.isEnumDeclaration(declaration)) {
+  } else if (ts8.isEnumDeclaration(declaration)) {
     result = serializeEnum(declaration, ctx);
-  } else if (ts6.isVariableDeclaration(declaration)) {
+  } else if (ts8.isVariableDeclaration(declaration)) {
     const varStatement = declaration.parent?.parent;
-    if (varStatement && ts6.isVariableStatement(varStatement)) {
+    if (varStatement && ts8.isVariableStatement(varStatement)) {
       result = serializeVariable(declaration, varStatement, ctx);
     }
-  } else if (ts6.isNamespaceExport(declaration) || ts6.isModuleDeclaration(declaration)) {
+  } else if (ts8.isNamespaceExport(declaration) || ts8.isModuleDeclaration(declaration)) {
     result = serializeNamespaceExport(exportSymbol, exportName, ctx);
-  } else if (ts6.isSourceFile(declaration)) {
+  } else if (ts8.isSourceFile(declaration)) {
     result = serializeNamespaceExport(exportSymbol, exportName, ctx);
   }
   if (result) {
@@ -1057,11 +1571,11 @@ function getJSDocFromExportSymbol(symbol) {
   const examples = [];
   const decl = symbol.declarations?.[0];
   if (decl) {
-    const exportDecl = ts6.isNamespaceExport(decl) ? decl.parent : decl;
-    if (exportDecl && ts6.isExportDeclaration(exportDecl)) {
-      const jsDocs = ts6.getJSDocCommentsAndTags(exportDecl);
+    const exportDecl = ts8.isNamespaceExport(decl) ? decl.parent : decl;
+    if (exportDecl && ts8.isExportDeclaration(exportDecl)) {
+      const jsDocs = ts8.getJSDocCommentsAndTags(exportDecl);
       for (const doc of jsDocs) {
-        if (ts6.isJSDoc(doc) && doc.comment) {
+        if (ts8.isJSDoc(doc) && doc.comment) {
           const commentText = typeof doc.comment === "string" ? doc.comment : doc.comment.map((c) => ("text" in c) ? c.text : "").join("");
           if (commentText) {
             return {
@@ -1145,4 +1659,4 @@ async function getPackageMeta(entryFile, baseDir) {
   } catch {}
   return { name: path3.basename(searchDir) };
 }
-export { TypeRegistry, getJSDocComment, getSourceLocation, createProgram, serializeClass, serializeEnum, isPrimitiveName, isBuiltinGeneric, isAnonymous, buildSchema, extractParameters, registerReferencedTypes, serializeFunctionExport, serializeInterface, serializeTypeAlias, serializeVariable, extract };
+export { TypeRegistry, getJSDocComment, getSourceLocation, createProgram, isPrimitiveName, isBuiltinGeneric, isAnonymous, buildSchema, extractParameters, registerReferencedTypes, serializeClass, serializeEnum, serializeFunctionExport, serializeInterface, serializeTypeAlias, serializeVariable, extract };

package/dist/src/index.d.ts

@@ -13,6 +13,16 @@ declare class TypeRegistry {
 	*/
 	registerType(type: ts.Type, checker: ts.TypeChecker, exportedIds: Set<string>): string | undefined;
 	private buildSpecType;
+	/**
+	* Build a shallow schema for registry types (no deep recursion).
+	* Only captures top-level structure with $refs.
+	*/
+	private buildShallowSchema;
+	/**
+	* Extract shallow members for classes/interfaces.
+	* Only captures property names and simple type info.
+	*/
+	private extractShallowMembers;
 	registerFromSymbol(symbol: ts.Symbol, checker: ts.TypeChecker): SpecType | undefined;
 }
 import { SpecExample, SpecSource, SpecTag } from "@openpkg-ts/spec";

package/dist/src/index.js

@@ -16,7 +16,7 @@ import {
   serializeInterface,
   serializeTypeAlias,
   serializeVariable
-} from "../shared/chunk-wddga8ye.js";
+} from "../shared/chunk-ksf9k654.js";
 // src/schema/adapters/arktype.ts
 var arktypeAdapter = {
   name: "arktype",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpkg-ts/extract",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "TypeScript export extraction to OpenPkg spec",
   "keywords": [
     "openpkg",
@@ -42,6 +42,7 @@
   "dependencies": {
     "@openpkg-ts/spec": "^0.12.0",
     "commander": "^12.0.0",
+    "tree-sitter-wasms": "^0.1.13",
     "typescript": "^5.0.0"
   },
   "devDependencies": {