@openpkg-ts/sdk 0.35.1 → 0.36.0

package/dist/browser.d.ts

@@ -400,8 +400,12 @@ import { OpenPkg as OpenPkg8, SpecExport as SpecExport4, SpecMember as SpecMembe
 interface FormatSchemaOptions {
 	/** Include package attribution for external types */
 	includePackage?: boolean;
-	/** Collapse unions with more than N members (default: no collapse) */
+	/** Collapse unions with more than N members (default: 5) */
 	collapseUnionThreshold?: number;
+	/** Max recursion depth before returning "..." (default: 3) */
+	maxDepth?: number;
+	/** @internal current recursion depth */
+	_depth?: number;
 }
 /**
 * Format a schema to a human-readable type string.
@@ -675,4 +679,47 @@ declare class QueryBuilder {
 * Create a query builder for the given spec
 */
 declare function query(spec: OpenPkg9): QueryBuilder;
-export { toSearchIndexJSON, toSearchIndex2 as toSearchIndex, toPagefindRecords2 as toPagefindRecords, toAlgoliaRecords2 as toAlgoliaRecords, sortByName, resolveTypeRef, query, isProperty, isMethod, hasDeprecatedTag, groupByVisibility, getProperties, getMethods, getMemberBadges, getDeprecationMessage, formatTypeParameters, formatSchema, formatReturnType, formatParameters, formatMappedType, formatConditionalType, formatBadges, findMissingParamDocs, buildSignatureString, analyzeSpec, SpecMappedType, SpecDiagnostics, SpecConditionalType, SearchRecord, SearchOptions, SearchIndex, QueryBuilder, PagefindRecord, LoadOptions, FormatSchemaOptions, DocsInstance, DiagnosticItem, AlgoliaRecord };
+import { OpenPkg as OpenPkg10, SpecExample, SpecExport as SpecExport6, SpecSchema as SpecSchema2, SpecSignatureParameter } from "@openpkg-ts/spec";
+interface CodeExample {
+	/** Unique identifier */
+	id: string;
+	/** Display label for chip */
+	label: string;
+	/** Code content */
+	code: string;
+	/** Language for highlighting (e.g. 'ts', 'bash') */
+	language?: string;
+}
+interface Language {
+	/** Language identifier (e.g. "typescript", "python") */
+	id: string;
+	/** Display label (e.g. "TypeScript", "Python") */
+	label: string;
+}
+interface APIParameterSchema {
+	/** Type name */
+	type?: string;
+	/** Formatted type string */
+	typeString?: string;
+	/** Description */
+	description?: string;
+	/** Nested properties for object types */
+	properties?: Record<string, APIParameterSchema>;
+	/** Required property names */
+	required?: string[];
+}
+declare function getLangForHighlight(lang: string): string;
+declare function getLanguageLabel(lang: string): string;
+declare function specSchemaToAPISchema(schema: SpecSchema2 | undefined): APIParameterSchema | undefined;
+declare function specParamToAPIParam(param: SpecSignatureParameter): {
+	name: string;
+	type: string;
+	required: boolean;
+	description?: string;
+	children?: APIParameterSchema;
+};
+/** Convert spec examples to CodeExample[] (Shape B: id/label/code/language) */
+declare function specExamplesToCodeExamples(examples: (string | SpecExample)[] | undefined, defaultLang?: string): CodeExample[];
+declare function getLanguagesFromExamples(examples: (string | SpecExample)[] | undefined): Language[];
+declare function buildImportStatement(exp: SpecExport6, spec: OpenPkg10): string;
+export { toSearchIndexJSON, toSearchIndex2 as toSearchIndex, toPagefindRecords2 as toPagefindRecords, toAlgoliaRecords2 as toAlgoliaRecords, specSchemaToAPISchema, specParamToAPIParam, specExamplesToCodeExamples, sortByName, resolveTypeRef, query, isProperty, isMethod, hasDeprecatedTag, groupByVisibility, getProperties, getMethods, getMemberBadges, getLanguagesFromExamples, getLanguageLabel, getLangForHighlight, getDeprecationMessage, formatTypeParameters, formatSchema, formatReturnType, formatParameters, formatMappedType, formatConditionalType, formatBadges, findMissingParamDocs, buildSignatureString, buildImportStatement, analyzeSpec, SpecMappedType, SpecDiagnostics, SpecConditionalType, SearchRecord, SearchOptions, SearchIndex, QueryBuilder, PagefindRecord, LoadOptions, Language, FormatSchemaOptions, DocsInstance, DiagnosticItem, CodeExample, AlgoliaRecord, APIParameterSchema };

package/dist/browser.js

@@ -25,12 +25,121 @@ import {
   toPagefindRecords,
   toSearchIndex,
   toSearchIndexJSON
-} from "./shared/chunk-4fgxg5jj.js";
+} from "./shared/chunk-hnajr1tb.js";
+// src/core/spec-converters.ts
+function getLangForHighlight(lang) {
+  const langMap = {
+    typescript: "ts",
+    javascript: "js",
+    ts: "ts",
+    js: "js",
+    tsx: "tsx",
+    jsx: "jsx",
+    bash: "bash",
+    shell: "bash",
+    json: "json",
+    python: "python",
+    go: "go",
+    rust: "rust"
+  };
+  return langMap[lang.toLowerCase()] || lang;
+}
+function getLanguageLabel(lang) {
+  const labels = {
+    typescript: "TypeScript",
+    javascript: "JavaScript",
+    ts: "TypeScript",
+    js: "JavaScript",
+    bash: "Bash",
+    json: "JSON",
+    python: "Python",
+    go: "Go",
+    rust: "Rust"
+  };
+  return labels[lang.toLowerCase()] || lang;
+}
+function specSchemaToAPISchema(schema) {
+  if (!schema || typeof schema !== "object")
+    return;
+  const s = schema;
+  const result = {};
+  result.type = formatSchema(schema);
+  result.typeString = result.type;
+  if (typeof s.description === "string") {
+    result.description = s.description;
+  }
+  if (s.type === "object" && s.properties && typeof s.properties === "object") {
+    result.properties = {};
+    for (const [key, value] of Object.entries(s.properties)) {
+      const nested = specSchemaToAPISchema(value);
+      if (nested)
+        result.properties[key] = nested;
+    }
+    if (Array.isArray(s.required)) {
+      result.required = s.required;
+    }
+  }
+  return result;
+}
+function specParamToAPIParam(param) {
+  const type = formatSchema(param.schema);
+  const children = specSchemaToAPISchema(param.schema);
+  const hasNestedProperties = children?.properties && Object.keys(children.properties).length > 0;
+  return {
+    name: param.name ?? "unknown",
+    type,
+    required: param.required !== false,
+    description: param.description,
+    children: hasNestedProperties ? children : undefined
+  };
+}
+function specExamplesToCodeExamples(examples, defaultLang = "typescript") {
+  if (!examples?.length)
+    return [];
+  return examples.map((ex, i) => {
+    const lang = typeof ex === "string" ? defaultLang : ex.language || defaultLang;
+    const code = typeof ex === "string" ? ex : ex.code;
+    const label = typeof ex === "string" ? getLanguageLabel(lang) : ex.title || getLanguageLabel(lang);
+    return {
+      id: `example-${i}`,
+      label,
+      code,
+      language: getLangForHighlight(lang)
+    };
+  });
+}
+function getLanguagesFromExamples(examples) {
+  if (!examples?.length)
+    return [];
+  const seen = new Set;
+  const result = [];
+  for (const ex of examples) {
+    const lang = typeof ex === "string" ? "typescript" : ex.language || "typescript";
+    if (!seen.has(lang)) {
+      seen.add(lang);
+      result.push({ id: lang, label: getLanguageLabel(lang) });
+    }
+  }
+  return result;
+}
+function buildImportStatement(exp, spec) {
+  const packageName = spec.meta?.name || "package";
+  const presentation = spec.extensions?.presentation?.[exp.id];
+  const importPath = presentation?.importPath || packageName;
+  const alias = presentation?.alias || exp.name;
+  if (exp.kind === "type" || exp.kind === "interface") {
+    return `import type { ${alias} } from '${importPath}'`;
+  }
+  return `import { ${alias} } from '${importPath}'`;
+}
 export {
   toSearchIndexJSON,
   toSearchIndex,
   toPagefindRecords,
   toAlgoliaRecords,
+  specSchemaToAPISchema,
+  specParamToAPIParam,
+  specExamplesToCodeExamples,
   sortByName,
   resolveTypeRef,
   query,
@@ -41,6 +150,9 @@ export {
   getProperties,
   getMethods,
   getMemberBadges,
+  getLanguagesFromExamples,
+  getLanguageLabel,
+  getLangForHighlight,
   getDeprecationMessage,
   formatTypeParameters,
   formatSchema,
@@ -51,6 +163,7 @@ export {
   formatBadges,
   findMissingParamDocs,
   buildSignatureString,
+  buildImportStatement,
   analyzeSpec,
   QueryBuilder
 };

package/dist/index.d.ts

@@ -745,8 +745,12 @@ import { OpenPkg as OpenPkg9, SpecExport as SpecExport4, SpecMember as SpecMembe
 interface FormatSchemaOptions {
 	/** Include package attribution for external types */
 	includePackage?: boolean;
-	/** Collapse unions with more than N members (default: no collapse) */
+	/** Collapse unions with more than N members (default: 5) */
 	collapseUnionThreshold?: number;
+	/** Max recursion depth before returning "..." (default: 3) */
+	maxDepth?: number;
+	/** @internal current recursion depth */
+	_depth?: number;
 }
 /**
 * Format a schema to a human-readable type string.
@@ -1169,8 +1173,10 @@ interface SerializerContext {
 	resolveExternalTypes: boolean;
 	typeRegistry: TypeRegistry;
 	exportedIds: Set<string>;
-	/** Track visited types to prevent infinite recursion */
+	/** Stack-style recursion guard for buildSchemaInternal (add before recurse, delete after) */
 	visitedTypes: Set<ts.Type>;
+	/** Permanent "already processed" set for registerReferencedTypes */
+	registeredTypes: Set<ts.Type>;
 	/** Flag to indicate we're processing tuple elements - skip Array prototype methods */
 	inTupleElement?: boolean;
 	/** Include private/protected class members (default: false) */
@@ -1627,7 +1633,7 @@ import ts14 from "typescript";
 declare function extractParameters(signature: ts14.Signature, ctx: SerializerContext): SpecSignatureParameter[];
 /**
 * Recursively register types referenced by a ts.Type.
-* Uses ctx.visitedTypes to prevent infinite recursion on circular types.
+* Uses ctx.registeredTypes to prevent re-processing already-registered types.
 */
 declare function registerReferencedTypes(type: ts14.Type, ctx: SerializerContext, depth?: number): void;
 import { SpecSchema as SpecSchema2 } from "@openpkg-ts/spec";

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) {
@@ -2227,40 +2229,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 +2249,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))
-      }));
-    }
-    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?.visitedTypes.has(type)) {
+    const callSignatures = type.getCallSignatures();
+    if (callSignatures.length > 0) {
+      return buildFunctionSchema(callSignatures, checker, ctx);
     }
-    if (ctx) {
-      return withDepth(ctx, () => ({
-        allOf: filteredTypes.map((t) => buildSchema(t, checker, ctx))
-      }));
+    const symbol = type.getSymbol() || type.aliasSymbol;
+    if (symbol && !isAnonymous(type)) {
+      return { $ref: `#/types/${symbol.getName()}` };
     }
-    return { allOf: filteredTypes.map((t) => buildSchema(t, checker, ctx)) };
+    return { type: checker.typeToString(type) };
   }
-  const typeString = checker.typeToString(type);
-  if (typeString === "never[]" || typeString === "[]") {
-    return { type: "array", prefixedItems: [], minItems: 0, maxItems: 0 };
+  const addedToVisited = !!(ctx && type.flags & ts3.TypeFlags.Object);
+  if (addedToVisited) {
+    ctx.visitedTypes.add(type);
   }
-  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) {
+  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?.()) {
+      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.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;
+      }
+    }
+    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))
+        }));
+      }
+      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, () => ({
-          type: "array",
-          items: buildSchema(elementType, checker, ctx)
+          allOf: filteredTypes.map((t) => buildSchema(t, checker, ctx))
         }));
       }
-      return { type: "array", items: buildSchema(elementType, 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 = () => {
@@ -2801,11 +2834,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);
@@ -3049,13 +3082,14 @@ 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,
     onTruncation: options.onTruncation
@@ -5896,6 +5930,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));
@@ -6219,20 +6288,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

package/dist/shared/{chunk-4fgxg5jj.js → chunk-hnajr1tb.js}

@@ -115,6 +115,11 @@ function formatSchema(schema, options) {
     return "unknown";
   if (typeof schema === "string")
     return schema;
+  const depth = options?._depth ?? 0;
+  const maxDepth = options?.maxDepth ?? 3;
+  if (depth >= maxDepth)
+    return "...";
+  const nextOpts = { ...options, _depth: depth + 1 };
   const withPackage = (typeStr) => {
     if (options?.includePackage && typeof schema === "object" && "x-ts-package" in schema) {
       const pkg = schema["x-ts-package"];
@@ -135,41 +140,41 @@ function formatSchema(schema, options) {
     }
     if ("x-ts-type-predicate" in schema) {
       const pred = schema["x-ts-type-predicate"];
-      return `${pred.parameterName} is ${formatSchema(pred.type, options)}`;
+      return `${pred.parameterName} is ${formatSchema(pred.type, nextOpts)}`;
     }
     if ("$ref" in schema && typeof schema.$ref === "string") {
       const baseName = schema.$ref.replace("#/types/", "");
       if ("x-ts-type-arguments" in schema && Array.isArray(schema["x-ts-type-arguments"])) {
-        const args = schema["x-ts-type-arguments"].map((s) => formatSchema(s, options)).join(", ");
+        const args = schema["x-ts-type-arguments"].map((s) => formatSchema(s, nextOpts)).join(", ");
         return withPackage(`${baseName}<${args}>`);
       }
       return withPackage(baseName);
     }
     if ("anyOf" in schema && Array.isArray(schema.anyOf)) {
-      const threshold = options?.collapseUnionThreshold;
+      const threshold = options?.collapseUnionThreshold ?? 5;
       const members = schema.anyOf;
-      if (threshold && members.length > threshold) {
+      if (members.length > threshold) {
         const shown = members.slice(0, 3);
         const remaining = members.length - 3;
-        const shownStr = shown.map((s) => formatSchema(s, options)).join(" | ");
-        return `${shownStr} | ... (${remaining} more)`;
+        const shownStr = shown.map((s) => formatSchema(s, nextOpts)).join(" | ");
+        return `${shownStr} | ... and ${remaining} more`;
       }
-      return members.map((s) => formatSchema(s, options)).join(" | ");
+      return members.map((s) => formatSchema(s, nextOpts)).join(" | ");
     }
     if ("allOf" in schema && Array.isArray(schema.allOf)) {
-      return schema.allOf.map((s) => formatSchema(s, options)).join(" & ");
+      return schema.allOf.map((s) => formatSchema(s, nextOpts)).join(" & ");
     }
     if ("type" in schema && schema.type === "array") {
-      const items = "items" in schema ? formatSchema(schema.items, options) : "unknown";
+      const items = "items" in schema ? formatSchema(schema.items, nextOpts) : "unknown";
       return `${items}[]`;
     }
     if ("type" in schema && schema.type === "tuple" && "items" in schema) {
-      const items = schema.items.map((s) => formatSchema(s, options)).join(", ");
+      const items = schema.items.map((s) => formatSchema(s, nextOpts)).join(", ");
       return `[${items}]`;
     }
     if ("type" in schema && schema.type === "object") {
       if ("properties" in schema && schema.properties) {
-        const props = Object.entries(schema.properties).map(([k, v]) => `${k}: ${formatSchema(v, options)}`).join("; ");
+        const props = Object.entries(schema.properties).map(([k, v]) => `${k}: ${formatSchema(v, nextOpts)}`).join("; ");
         return `{ ${props} }`;
       }
       return "object";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpkg-ts/sdk",
-  "version": "0.35.1",
+  "version": "0.36.0",
   "description": "TypeScript API extraction SDK - programmatic primitives for OpenPkg specs",
   "keywords": [
     "openpkg",