@openpkg-ts/sdk 0.43.0 → 0.45.0

package/dist/index.d.ts

@@ -1653,6 +1653,41 @@ import ts15 from "typescript";
 * Used for types that have specific serialization formats.
 */
 declare const BUILTIN_TYPE_SCHEMAS: Record<string, SpecSchema2>;
+/**
+* Remove `import("<abs path>").` qualifiers from checker-rendered type text.
+* Machine-specific paths must never appear in a published spec.
+*/
+declare function scrubImportQualifiers(text: string): string;
+/**
+* Render the developer-facing type text at its owning declaration.
+* NoTruncation keeps long unions intact; import() qualifiers are scrubbed.
+*/
+declare function renderTypeText(type: ts15.Type, checker: ts15.TypeChecker, enclosing?: ts15.Node, extraFlags?: ts15.TypeFormatFlags): string;
+/**
+* Strip `undefined` from a union type when optionality is already expressed
+* elsewhere (`required: false`, `flags.optional`). Used for both schema shape
+* and x-ts-type text so neither re-encodes optionality as `| undefined`.
+*/
+declare function stripUndefinedFromType(type: ts15.Type, checker: ts15.TypeChecker): ts15.Type;
+/** Declaration-modifier readonly check — matches the member-layer flags.readonly source. */
+declare function isReadonlyPropertySymbol(prop: ts15.Symbol): boolean;
+/**
+* Decorate a property schema with TS-fidelity metadata:
+* - `x-ts-type`: checker-rendered text at the owning declaration. Emitted
+*   unless trivially derivable — a bare primitive keyword, or a $ref whose
+*   target name equals the text. Optional props render without `| undefined`.
+* - `readOnly`: JSON Schema readonly marker from the declaration modifier.
+* - `x-ts-method`: declaration form marker for method-syntax members
+*   (SymbolFlags.Method survives on true methods, is stripped by mapping).
+*/
+declare function decoratePropertySchema(schema: SpecSchema2, prop: ts15.Symbol, propType: ts15.Type, checker: ts15.TypeChecker): SpecSchema2;
+/**
+* Alias-level x-ts-type is emitted when the alias RHS is a renderable
+* expression (array, instantiation, union, intersection, function, keyof, …).
+* Type-literal and mapped bodies are skipped — their structure is already
+* carried by schema.properties and the text would be the whole literal body.
+*/
+declare function shouldEmitAliasTypeText(typeNode: ts15.TypeNode): boolean;
 declare const PRIMITIVES: Set<string>;
 declare const ARRAY_PROTOTYPE_METHODS: Set<string>;
 declare const STRING_PROTOTYPE_METHODS: Set<string>;
@@ -1662,6 +1697,11 @@ declare const NUMBER_PROTOTYPE_METHODS: Set<string>;
 */
 declare function isPrimitiveName(name: string): boolean;
 /**
+* Check if a symbol is from TypeScript's built-in lib (lib.es*.d.ts).
+* Used to detect Array, Object, and other built-in types.
+*/
+declare function isBuiltinSymbol(symbol: ts15.Symbol | undefined): boolean;
+/**
 * Get the origin package name for a type if it comes from node_modules.
 * Returns undefined for types defined in the current project.
 *
@@ -1795,4 +1835,4 @@ declare function normalizeMembers(members: SpecMember3[], options?: NormalizeOpt
 import ts16 from "typescript";
 declare function isExported(node: ts16.Node): boolean;
 declare function getNodeName(node: ts16.Node): string | undefined;
-export { zodAdapter, withDescription2 as withDescription, withDeprecated, valibotAdapter, typeboxAdapter, toSearchIndexJSON, toSearchIndex2 as toSearchIndex, toPagefindRecords2 as toPagefindRecords, toNavigation2 as toNavigation, toMarkdown2 as toMarkdown, toJSONString, toJSON2 as toJSON, toHTML2 as toHTML, toFumadocsMetaJSON, toDocusaurusSidebarJS, toAlgoliaRecords2 as toAlgoliaRecords, sortByName, serializeVariable, serializeTypeAlias, serializeInterface, serializeFunctionExport, serializeEnum, serializeClass, schemasAreEqual, schemaIsAny, resolveTypeRef, resolveExportTarget, resolveCompiledPath, registerReferencedTypes, registerAdapter, recommendSemverBump, query, normalizeType, normalizeSchema, normalizeMembers, normalizeExport, mergeConfig, loadSpec, loadConfig, listExports, isTypeReference, isTypeOnlyExport, isSymbolDeprecated, isStandardJSONSchema, isSchemaType, isPureRefSchema, isProperty, isPrimitiveName, isMethod, isExported, isBuiltinGeneric, isAnonymous, hasDeprecatedTag, groupByVisibility, getTypeOrigin, getSourceLocation, getProperties, getParamDescription, getNonNullableType, getNodeName, getMethods, getMemberBadges, getJSDocComment, getExportKind, getExport2 as getExport, getDeprecationMessage, toMarkdown2 as generateDocs, formatTypeParameters, formatSchema, formatReturnType, formatParameters, formatMappedType, formatConditionalType, formatBadges, findMissingParamDocs, findDiscriminatorProperty, findAdapter, filterSpec, extractTypeParameters, extractStandardSchemasFromTs, extractStandardSchemasFromProject, extractStandardSchemas, extractSpec, extractSchemaType, extractParameters, extract, exportToMarkdown, ensureNonEmptySchema, diffSpec2 as diffSpecs, diffSpec, detectTsRuntime, deduplicateSchemas, createProgram, createDocs, categorizeBreakingChanges, calculateNextVersion, buildSignatureString, buildSchema, buildObjectSchema, buildFunctionSchema, arktypeAdapter, analyzeSpec, TypeRegistry, TypeReference2 as TypeReference, TsRuntime, StandardSchemaExtractionResult, StandardSchemaExtractionOutput, StandardJSONSchemaV1, StandardJSONSchemaTarget, StandardJSONSchemaOptions, SpecMappedType, SpecDiff, SpecDiagnostics, SpecConditionalType, SkippedExportDetail, SimplifiedSpec, SimplifiedSignature, SimplifiedReturn, SimplifiedParameter, SimplifiedMember, SimplifiedExport, SimplifiedExample, SerializerContext, SemverRecommendation, SemverBump, SearchRecord, SearchOptions, SearchIndex, SchemaExtractionResult, SchemaAdapter, STRING_PROTOTYPE_METHODS, QueryBuilder, ProjectExtractionOutput, ProjectExtractionInfo, ProgramResult, ProgramOptions, PagefindRecord, PRIMITIVES, OpenpkgConfig, NormalizeOptions, NavOptions, NavItem, NavGroup, NavFormat, NUMBER_PROTOTYPE_METHODS, MemberChangeInfo, MarkdownOptions, LoadOptions, ListExportsResult, ListExportsOptions, JSONSchema, JSONOptions, HTMLOptions, GroupBy, GetExportResult, GetExportOptions, GenericNav, FumadocsMetaItem, FumadocsMeta, FormatSchemaOptions, ForgottenExport, FilterResult, FilterCriteria, ExtractionWarningCode, ExtractionWarning, ExtractStandardSchemasOptions, ExtractResult, ExtractOptions, ExtractFromProjectOptions, ExternalsConfig, ExportVerification, ExportTracker, ExportMarkdownOptions, ExportItem, DocusaurusSidebarItem, DocusaurusSidebar, DocsInstance, DiagnosticItem, Diagnostic, CategorizedBreaking, CacheManagerOptions, CacheManager, CONFIG_FILENAME, BreakingSeverity, BUILTIN_TYPE_SCHEMAS, AlgoliaRecord, ARRAY_PROTOTYPE_METHODS };
+export { zodAdapter, withDescription2 as withDescription, withDeprecated, valibotAdapter, typeboxAdapter, toSearchIndexJSON, toSearchIndex2 as toSearchIndex, toPagefindRecords2 as toPagefindRecords, toNavigation2 as toNavigation, toMarkdown2 as toMarkdown, toJSONString, toJSON2 as toJSON, toHTML2 as toHTML, toFumadocsMetaJSON, toDocusaurusSidebarJS, toAlgoliaRecords2 as toAlgoliaRecords, stripUndefinedFromType, sortByName, shouldEmitAliasTypeText, serializeVariable, serializeTypeAlias, serializeInterface, serializeFunctionExport, serializeEnum, serializeClass, scrubImportQualifiers, schemasAreEqual, schemaIsAny, resolveTypeRef, resolveExportTarget, resolveCompiledPath, renderTypeText, registerReferencedTypes, registerAdapter, recommendSemverBump, query, normalizeType, normalizeSchema, normalizeMembers, normalizeExport, mergeConfig, loadSpec, loadConfig, listExports, isTypeReference, isTypeOnlyExport, isSymbolDeprecated, isStandardJSONSchema, isSchemaType, isReadonlyPropertySymbol, isPureRefSchema, isProperty, isPrimitiveName, isMethod, isExported, isBuiltinSymbol, isBuiltinGeneric, isAnonymous, hasDeprecatedTag, groupByVisibility, getTypeOrigin, getSourceLocation, getProperties, getParamDescription, getNonNullableType, getNodeName, getMethods, getMemberBadges, getJSDocComment, getExportKind, getExport2 as getExport, getDeprecationMessage, toMarkdown2 as generateDocs, formatTypeParameters, formatSchema, formatReturnType, formatParameters, formatMappedType, formatConditionalType, formatBadges, findMissingParamDocs, findDiscriminatorProperty, findAdapter, filterSpec, extractTypeParameters, extractStandardSchemasFromTs, extractStandardSchemasFromProject, extractStandardSchemas, extractSpec, extractSchemaType, extractParameters, extract, exportToMarkdown, ensureNonEmptySchema, diffSpec2 as diffSpecs, diffSpec, detectTsRuntime, deduplicateSchemas, decoratePropertySchema, createProgram, createDocs, categorizeBreakingChanges, calculateNextVersion, buildSignatureString, buildSchema, buildObjectSchema, buildFunctionSchema, arktypeAdapter, analyzeSpec, TypeRegistry, TypeReference2 as TypeReference, TsRuntime, StandardSchemaExtractionResult, StandardSchemaExtractionOutput, StandardJSONSchemaV1, StandardJSONSchemaTarget, StandardJSONSchemaOptions, SpecMappedType, SpecDiff, SpecDiagnostics, SpecConditionalType, SkippedExportDetail, SimplifiedSpec, SimplifiedSignature, SimplifiedReturn, SimplifiedParameter, SimplifiedMember, SimplifiedExport, SimplifiedExample, SerializerContext, SemverRecommendation, SemverBump, SearchRecord, SearchOptions, SearchIndex, SchemaExtractionResult, SchemaAdapter, STRING_PROTOTYPE_METHODS, QueryBuilder, ProjectExtractionOutput, ProjectExtractionInfo, ProgramResult, ProgramOptions, PagefindRecord, PRIMITIVES, OpenpkgConfig, NormalizeOptions, NavOptions, NavItem, NavGroup, NavFormat, NUMBER_PROTOTYPE_METHODS, MemberChangeInfo, MarkdownOptions, LoadOptions, ListExportsResult, ListExportsOptions, JSONSchema, JSONOptions, HTMLOptions, GroupBy, GetExportResult, GetExportOptions, GenericNav, FumadocsMetaItem, FumadocsMeta, FormatSchemaOptions, ForgottenExport, FilterResult, FilterCriteria, ExtractionWarningCode, ExtractionWarning, ExtractStandardSchemasOptions, ExtractResult, ExtractOptions, ExtractFromProjectOptions, ExternalsConfig, ExportVerification, ExportTracker, ExportMarkdownOptions, ExportItem, DocusaurusSidebarItem, DocusaurusSidebar, DocsInstance, DiagnosticItem, Diagnostic, CategorizedBreaking, CacheManagerOptions, CacheManager, CONFIG_FILENAME, BreakingSeverity, BUILTIN_TYPE_SCHEMAS, AlgoliaRecord, ARRAY_PROTOTYPE_METHODS };

package/dist/index.js

@@ -1875,6 +1875,51 @@ var BUILTIN_TYPE_SCHEMAS = {
 function setSchemaExtension(schema, key, value) {
   schema[key] = value;
 }
+function scrubImportQualifiers(text) {
+  return text.replace(/import\((?:"[^"]*"|'[^']*')\)\./g, "");
+}
+function renderTypeText(type, checker, enclosing, extraFlags = 0) {
+  return scrubImportQualifiers(checker.typeToString(type, enclosing, ts3.TypeFormatFlags.NoTruncation | extraFlags));
+}
+function stripUndefinedFromType(type, checker) {
+  if (!type.isUnion())
+    return type;
+  const nonUndefinedTypes = type.types.filter((t) => !(t.flags & ts3.TypeFlags.Undefined));
+  if (nonUndefinedTypes.length === 0)
+    return type;
+  if (nonUndefinedTypes.length === 1)
+    return nonUndefinedTypes[0];
+  return checker.getUnionType(nonUndefinedTypes);
+}
+function isReadonlyPropertySymbol(prop) {
+  const decls = prop.getDeclarations() ?? [];
+  return decls.some((d) => (ts3.getCombinedModifierFlags(d) & ts3.ModifierFlags.Readonly) !== 0);
+}
+function decoratePropertySchema(schema, prop, propType, checker) {
+  if (typeof schema !== "object" || schema === null || Array.isArray(schema))
+    return schema;
+  const decl = prop.valueDeclaration ?? prop.getDeclarations()?.[0];
+  const optional = !!(prop.flags & ts3.SymbolFlags.Optional);
+  const textType = optional ? stripUndefinedFromType(propType, checker) : propType;
+  const text = renderTypeText(textType, checker, decl);
+  const obj = schema;
+  const refTarget = typeof obj.$ref === "string" ? obj.$ref : Array.isArray(obj.allOf) && obj.allOf.length === 1 && isPureRefSchema(obj.allOf[0]) ? obj.allOf[0].$ref : undefined;
+  const derivable = PRIMITIVES.has(text) || refTarget === `#/types/${text}`;
+  let result = obj;
+  if (!derivable && !("x-ts-type" in obj)) {
+    result = { ...result, "x-ts-type": text };
+  }
+  if (isReadonlyPropertySymbol(prop) && !("readOnly" in obj)) {
+    result = { ...result, readOnly: true };
+  }
+  if (prop.flags & ts3.SymbolFlags.Method && !("x-ts-method" in obj)) {
+    result = { ...result, "x-ts-method": true };
+  }
+  return result;
+}
+function shouldEmitAliasTypeText(typeNode) {
+  return !ts3.isTypeLiteralNode(typeNode) && !ts3.isMappedTypeNode(typeNode);
+}
 var PRIMITIVES = new Set([
   "string",
   "number",
@@ -2482,6 +2527,7 @@ function buildObjectSchema(properties, checker, ctx, originalType) {
       if (deprecated) {
         propSchema = withDeprecated(propSchema, reason);
       }
+      propSchema = decoratePropertySchema(propSchema, prop, propType, checker);
       props[propName] = propSchema;
       if (!(prop.flags & ts3.SymbolFlags.Optional)) {
         required.push(propName);
@@ -2628,16 +2674,6 @@ function findDiscriminatorProperty(unionTypes, checker) {
 }
 
 // src/types/parameters.ts
-function stripUndefinedFromType(type, checker) {
-  if (!type.isUnion())
-    return type;
-  const nonUndefinedTypes = type.types.filter((t) => !(t.flags & ts4.TypeFlags.Undefined));
-  if (nonUndefinedTypes.length === 0)
-    return type;
-  if (nonUndefinedTypes.length === 1)
-    return nonUndefinedTypes[0];
-  return checker.getUnionType(nonUndefinedTypes);
-}
 function extractParameters(signature, ctx) {
   const { typeChecker: checker } = ctx;
   const result = [];
@@ -2965,6 +3001,12 @@ class TypeRegistry {
         schema = enumSchema;
       }
     }
+    if (kind === "type" && decl && ts5.isTypeAliasDeclaration(decl) && shouldEmitAliasTypeText(decl.type) && typeof schema === "object" && schema !== null && !("x-ts-type" in schema)) {
+      const text = renderTypeText(type, checker, decl, ts5.TypeFormatFlags.InTypeAlias);
+      if (!PRIMITIVES.has(text) && text !== name) {
+        schema["x-ts-type"] = text;
+      }
+    }
     return {
       id: name,
       name,
@@ -3011,6 +3053,19 @@ class TypeRegistry {
     if (callSignatures.length > 0 && type.getProperties().length === 0) {
       return buildFunctionSchema(callSignatures, checker, ctx);
     }
+    if (checker.isTupleType(type)) {
+      const elementTypes = checker.getTypeArguments(type) ?? [];
+      return {
+        type: "array",
+        prefixedItems: elementTypes.map((t) => buildSchema(t, checker, ctx)),
+        minItems: elementTypes.length,
+        maxItems: elementTypes.length
+      };
+    }
+    if (checker.isArrayType(type)) {
+      const elementType = checker.getTypeArguments(type)?.[0];
+      return elementType ? { type: "array", items: buildSchema(elementType, checker, ctx) } : { type: "array" };
+    }
     return this.buildObjectSchemaFromProperties(type, checker, ctx);
   }
   buildEnumSchema(symbol, checker) {
@@ -3083,6 +3138,7 @@ class TypeRegistry {
       if (deprecated) {
         propSchema = withDeprecated(propSchema, reason);
       }
+      propSchema = decoratePropertySchema(propSchema, prop, propType, checker);
       props[propName] = propSchema;
       if (!(prop.flags & ts5.SymbolFlags.Optional)) {
         required.push(propName);
@@ -3321,6 +3377,9 @@ function serializeClass(node, ctx) {
     }
   }
   members.push(...methodsByName.values());
+  if (signatures.length === 0) {
+    signatures.push(...serializeInheritedConstructors(node, ctx));
+  }
   const ownMemberNames = new Set;
   for (const member of node.members) {
     const memberName = getMemberName(member);
@@ -3401,7 +3460,7 @@ function serializeProperty(node, ctx) {
   }
   const type = checker.getTypeAtLocation(node);
   registerReferencedTypes(type, ctx);
-  const schema = buildSchema(type, checker, ctx);
+  let schema = buildSchema(type, checker, ctx);
   const flags = {};
   if (isStatic(node))
     flags.static = true;
@@ -3410,6 +3469,9 @@ function serializeProperty(node, ctx) {
   if (node.questionToken)
     flags.optional = true;
   const symbol = checker.getSymbolAtLocation(node.name ?? node);
+  if (symbol) {
+    schema = decoratePropertySchema(schema, symbol, type, checker);
+  }
   const { deprecated, reason: deprecationReason } = isSymbolDeprecated(symbol);
   return {
     name,
@@ -3440,6 +3502,7 @@ function serializeMethod(node, ctx) {
     flags.static = true;
   if (node.asteriskToken)
     flags.generator = true;
+  flags.methodSyntax = true;
   const modifiers = ts7.getModifiers(node);
   if (modifiers?.some((m) => m.kind === ts7.SyntaxKind.AsyncKeyword)) {
     flags.async = true;
@@ -3462,16 +3525,44 @@ function serializeMethod(node, ctx) {
 }
 function serializeConstructor(node, ctx) {
   const { typeChecker: checker } = ctx;
-  const { description } = getJSDocComment(node);
   const sig = checker.getSignatureFromDeclaration(node);
   if (!sig)
     return null;
+  return serializeConstructorSignature(node, sig, ctx);
+}
+function serializeConstructorSignature(node, sig, ctx) {
+  const { description, tags, examples } = getJSDocComment(node);
   const params = extractParameters(sig, ctx);
   return {
     description,
-    parameters: params.length > 0 ? params : undefined
+    parameters: params.length > 0 ? params : undefined,
+    ...tags.length > 0 ? { tags } : {},
+    ...examples.length > 0 ? { examples } : {}
   };
 }
+function serializeInheritedConstructors(node, ctx) {
+  const { typeChecker: checker } = ctx;
+  const hasExtends = node.heritageClauses?.some((c) => c.token === ts7.SyntaxKind.ExtendsKeyword);
+  if (!hasExtends)
+    return [];
+  const symbol = checker.getSymbolAtLocation(node.name ?? node);
+  if (!symbol)
+    return [];
+  const staticType = checker.getTypeOfSymbolAtLocation(symbol, node);
+  const ctorSigs = staticType.getConstructSignatures().filter((sig) => {
+    const decl = sig.getDeclaration();
+    return decl !== undefined && ts7.isConstructorDeclaration(decl);
+  });
+  return ctorSigs.map((sig, index) => {
+    const decl = sig.getDeclaration();
+    const owner = ts7.isClassLike(decl.parent) ? decl.parent.name?.text : undefined;
+    return {
+      ...serializeConstructorSignature(decl, sig, ctx),
+      ...owner ? { inheritedFrom: owner } : {},
+      ...ctorSigs.length > 1 ? { overloadIndex: index } : {}
+    };
+  });
+}
 function serializeAccessor(node, ctx) {
   const { typeChecker: checker } = ctx;
   const name = getMemberName(node);
@@ -3760,7 +3851,7 @@ function serializePropertySignature(node, ctx) {
   const name = node.name.getText();
   const { description, tags } = getJSDocComment(node);
   const type = checker.getTypeAtLocation(node);
-  const schema = buildSchema(type, checker, ctx);
+  let schema = buildSchema(type, checker, ctx);
   registerReferencedTypes(type, ctx);
   const flags = {};
   if (node.questionToken)
@@ -3769,6 +3860,9 @@ function serializePropertySignature(node, ctx) {
     flags.readonly = true;
   }
   const symbol = checker.getSymbolAtLocation(node.name);
+  if (symbol) {
+    schema = decoratePropertySchema(schema, symbol, type, checker);
+  }
   const { deprecated, reason: deprecationReason } = isSymbolDeprecated(symbol);
   return {
     name,
@@ -3790,6 +3884,7 @@ function serializeMethodSignature(node, ctx) {
   const flags = {};
   if (node.questionToken)
     flags.optional = true;
+  flags.methodSyntax = true;
   const symbol = checker.getSymbolAtLocation(node.name);
   const { deprecated, reason: deprecationReason } = isSymbolDeprecated(symbol);
   return {
@@ -3899,6 +3994,15 @@ function serializeTypeAlias(node, ctx) {
     members = serializeResolvedMembers(type, node, ctx);
   } else {
     schema = buildSchema(type, ctx.typeChecker, ctx);
+    if (isObjectShapedAlias(type, ctx)) {
+      members = serializeResolvedMembers(type, node, ctx);
+    }
+  }
+  if (shouldEmitAliasTypeText(node.type) && typeof schema === "object" && schema !== null && !("x-ts-type" in schema)) {
+    const text = renderTypeText(type, ctx.typeChecker, node, ts10.TypeFormatFlags.InTypeAlias);
+    if (!PRIMITIVES.has(text) && text !== name) {
+      schema["x-ts-type"] = text;
+    }
   }
   return {
     id: name,
@@ -3914,6 +4018,20 @@ function serializeTypeAlias(node, ctx) {
     ...examples.length > 0 ? { examples } : {}
   };
 }
+function isObjectShapedAlias(type, ctx) {
+  const { typeChecker: checker } = ctx;
+  if (!(type.flags & ts10.TypeFlags.Object))
+    return false;
+  if (checker.isArrayType(type) || checker.isTupleType(type))
+    return false;
+  const objectFlags = type.objectFlags;
+  if (!(objectFlags & ts10.ObjectFlags.Mapped)) {
+    const targetSymbol = type.target?.getSymbol?.() ?? type.getSymbol();
+    if (isBuiltinSymbol(targetSymbol))
+      return false;
+  }
+  return type.getProperties().length > 0 && type.getCallSignatures().length === 0;
+}
 function isInlineFunctionAlias(typeNode) {
   return ts10.isFunctionTypeNode(typeNode) || ts10.isTypeLiteralNode(typeNode) && typeNode.members.some(ts10.isCallSignatureDeclaration);
 }
@@ -3987,13 +4105,25 @@ function serializeResolvedMembers(type, node, ctx) {
     if (!deprecated && armAlias) {
       ({ deprecated, reason: deprecationReason } = isSymbolDeprecated(armAlias));
     }
+    const flags = {};
+    if (prop.flags & ts10.SymbolFlags.Optional)
+      flags.optional = true;
+    if (isReadonlyPropertySymbol(prop))
+      flags.readonly = true;
+    if (prop.flags & ts10.SymbolFlags.Method)
+      flags.methodSyntax = true;
+    let schema;
+    if (kind === "property") {
+      schema = decoratePropertySchema(buildSchema(propType, checker, ctx), prop, propType, checker);
+    }
     members.push({
       name: prop.getName(),
       kind,
       description,
       tags: tags.length > 0 ? tags : undefined,
-      schema: kind === "property" ? buildSchema(propType, checker, ctx) : undefined,
+      schema,
       signatures: kind === "method" ? buildSignatures(callSigs, checker, ctx) : undefined,
+      flags: Object.keys(flags).length > 0 ? flags : undefined,
       ...deprecated ? { deprecated: true, deprecationReason } : {}
     });
   }
@@ -4220,13 +4350,18 @@ function normalizeSchema(schema, options = {}) {
 }
 function normalizeSchemaInternal(schema, options) {
   const result = normalizeSchemaDispatch(schema, options);
-  if (schema && typeof schema === "object") {
+  if (schema && typeof schema === "object" && !Array.isArray(schema)) {
     const s = schema;
     if (s.deprecated === true && result.deprecated === undefined) {
       result.deprecated = true;
     }
-    if (typeof s["x-deprecated-reason"] === "string" && result["x-deprecated-reason"] === undefined) {
-      result["x-deprecated-reason"] = s["x-deprecated-reason"];
+    if (s.readOnly === true && result.readOnly === undefined) {
+      result.readOnly = true;
+    }
+    for (const key of Object.keys(s)) {
+      if (key.startsWith("x-") && s[key] !== undefined && result[key] === undefined) {
+        result[key] = s[key];
+      }
     }
   }
   return result;
@@ -4606,6 +4741,9 @@ function memberDocExtras(member) {
   if (member.description) {
     extras.description = member.description;
   }
+  if (member.flags?.readonly === true) {
+    extras.readOnly = true;
+  }
   if (member.deprecated) {
     extras.deprecated = true;
     const reason = member.deprecationReason ?? member.tags?.find((t) => t.name === "deprecated")?.text;
@@ -4653,6 +4791,9 @@ function normalizeMethodMember(member, options) {
   const result = {
     "x-ts-function": true
   };
+  if (member.flags?.methodSyntax === true) {
+    result["x-ts-method"] = true;
+  }
   if (member.signatures && member.signatures.length > 0) {
     result["x-ts-signatures"] = member.signatures.map((sig) => normalizeSignature(sig, options));
   }
@@ -6964,18 +7105,22 @@ export {
   toFumadocsMetaJSON,
   toDocusaurusSidebarJS,
   toAlgoliaRecords,
+  stripUndefinedFromType,
   sortByName,
+  shouldEmitAliasTypeText,
   serializeVariable,
   serializeTypeAlias,
   serializeInterface,
   serializeFunctionExport,
   serializeEnum,
   serializeClass,
+  scrubImportQualifiers,
   schemasAreEqual,
   schemaIsAny,
   resolveTypeRef,
   resolveExportTarget2 as resolveExportTarget,
   resolveCompiledPath,
+  renderTypeText,
   registerReferencedTypes,
   registerAdapter,
   recommendSemverBump,
@@ -6993,11 +7138,13 @@ export {
   isSymbolDeprecated,
   isStandardJSONSchema,
   isSchemaType,
+  isReadonlyPropertySymbol,
   isPureRefSchema,
   isProperty,
   isPrimitiveName,
   isMethod,
   isExported,
+  isBuiltinSymbol,
   isBuiltinGeneric,
   isAnonymous,
   hasDeprecatedTag,
@@ -7040,6 +7187,7 @@ export {
   diffSpec,
   detectTsRuntime,
   deduplicateSchemas,
+  decoratePropertySchema,
   createProgram,
   createDocs,
   categorizeBreakingChanges,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpkg-ts/sdk",
-  "version": "0.43.0",
+  "version": "0.45.0",
   "description": "TypeScript API extraction SDK - programmatic primitives for OpenPkg specs",
   "keywords": [
     "openpkg",
@@ -43,7 +43,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@openpkg-ts/spec": "^0.43.0",
+    "@openpkg-ts/spec": "^0.45.0",
     "picomatch": "4.0.3",
     "typescript": "^5.0.0"
   },