@formspec/build 0.1.0-alpha.31 → 0.1.0-alpha.33

package/dist/cli.js

@@ -1854,13 +1854,34 @@ var init_generator2 = __esm({
 });
 
 // src/extensions/registry.ts
+import {
+  BUILTIN_CONSTRAINT_DEFINITIONS,
+  normalizeConstraintTagName
+} from "@formspec/core/internals";
+import {
+  getTagDefinition,
+  normalizeFormSpecTagName
+} from "@formspec/analysis/internal";
+function buildConstraintTagSources(extensions) {
+  return extensions.map((extension) => ({
+    extensionId: extension.extensionId,
+    ...extension.constraintTags !== void 0 ? {
+      constraintTags: extension.constraintTags.map((tag) => ({
+        tagName: normalizeFormSpecTagName(tag.tagName)
+      }))
+    } : {}
+  }));
+}
 function createExtensionRegistry(extensions) {
+  const reservedTagSources = buildConstraintTagSources(extensions);
   const typeMap = /* @__PURE__ */ new Map();
   const typeNameMap = /* @__PURE__ */ new Map();
   const constraintMap = /* @__PURE__ */ new Map();
   const constraintTagMap = /* @__PURE__ */ new Map();
   const builtinBroadeningMap = /* @__PURE__ */ new Map();
   const annotationMap = /* @__PURE__ */ new Map();
+  const metadataSlotMap = /* @__PURE__ */ new Map();
+  const metadataTagMap = /* @__PURE__ */ new Map();
   for (const ext of extensions) {
     if (ext.types !== void 0) {
       for (const type of ext.types) {
@@ -1903,10 +1924,11 @@ function createExtensionRegistry(extensions) {
     }
     if (ext.constraintTags !== void 0) {
       for (const tag of ext.constraintTags) {
-        if (constraintTagMap.has(tag.tagName)) {
-          throw new Error(`Duplicate custom constraint tag: "@${tag.tagName}"`);
+        const canonicalTagName = normalizeFormSpecTagName(tag.tagName);
+        if (constraintTagMap.has(canonicalTagName)) {
+          throw new Error(`Duplicate custom constraint tag: "@${canonicalTagName}"`);
         }
-        constraintTagMap.set(tag.tagName, {
+        constraintTagMap.set(canonicalTagName, {
           extensionId: ext.extensionId,
           registration: tag
         });
@@ -1921,20 +1943,63 @@ function createExtensionRegistry(extensions) {
         annotationMap.set(qualifiedId, annotation);
       }
     }
+    if (ext.metadataSlots !== void 0) {
+      for (const slot of ext.metadataSlots) {
+        if (metadataSlotMap.has(slot.slotId)) {
+          throw new Error(`Duplicate metadata slot ID: "${slot.slotId}"`);
+        }
+        metadataSlotMap.set(slot.slotId, true);
+        const canonicalTagName = normalizeFormSpecTagName(slot.tagName);
+        if (slot.allowBare === false && (slot.qualifiers?.length ?? 0) === 0) {
+          throw new Error(
+            `Metadata tag "@${canonicalTagName}" must allow bare usage or declare at least one qualifier.`
+          );
+        }
+        if (metadataTagMap.has(canonicalTagName)) {
+          throw new Error(`Duplicate metadata tag: "@${canonicalTagName}"`);
+        }
+        if (BUILTIN_METADATA_TAGS.has(canonicalTagName)) {
+          throw new Error(
+            `Metadata tag "@${canonicalTagName}" conflicts with built-in metadata tags.`
+          );
+        }
+        if (constraintTagMap.has(canonicalTagName)) {
+          throw new Error(
+            `Metadata tag "@${canonicalTagName}" conflicts with existing FormSpec tag "@${canonicalTagName}".`
+          );
+        }
+        if (Object.hasOwn(BUILTIN_CONSTRAINT_DEFINITIONS, normalizeConstraintTagName(canonicalTagName))) {
+          throw new Error(
+            `Metadata tag "@${canonicalTagName}" conflicts with existing FormSpec tag "@${normalizeConstraintTagName(canonicalTagName)}".`
+          );
+        }
+        const existingTag = getTagDefinition(canonicalTagName, reservedTagSources);
+        if (existingTag !== null) {
+          throw BUILTIN_METADATA_TAGS.has(existingTag.canonicalName) ? new Error(
+            `Metadata tag "@${canonicalTagName}" conflicts with built-in metadata tags.`
+          ) : new Error(
+            `Metadata tag "@${canonicalTagName}" conflicts with existing FormSpec tag "@${existingTag.canonicalName}".`
+          );
+        }
+        metadataTagMap.set(canonicalTagName, true);
+      }
+    }
   }
   return {
     extensions,
     findType: (typeId) => typeMap.get(typeId),
     findTypeByName: (typeName) => typeNameMap.get(typeName),
     findConstraint: (constraintId) => constraintMap.get(constraintId),
-    findConstraintTag: (tagName) => constraintTagMap.get(tagName),
+    findConstraintTag: (tagName) => constraintTagMap.get(normalizeFormSpecTagName(tagName)),
     findBuiltinConstraintBroadening: (typeId, tagName) => builtinBroadeningMap.get(`${typeId}:${tagName}`),
     findAnnotation: (annotationId) => annotationMap.get(annotationId)
   };
 }
+var BUILTIN_METADATA_TAGS;
 var init_registry = __esm({
   "src/extensions/registry.ts"() {
     "use strict";
+    BUILTIN_METADATA_TAGS = /* @__PURE__ */ new Set(["apiName", "displayName"]);
   }
 });
 
@@ -2019,8 +2084,9 @@ import * as ts from "typescript";
 import {
   checkSyntheticTagApplication,
   extractPathTarget as extractSharedPathTarget,
-  getTagDefinition,
+  getTagDefinition as getTagDefinition2,
   hasTypeSemanticCapability,
+  normalizeFormSpecTagName as normalizeFormSpecTagName2,
   parseConstraintTagValue,
   parseDefaultValueTagValue,
   resolveDeclarationPlacement,
@@ -2040,14 +2106,14 @@ import {
   TextRange
 } from "@microsoft/tsdoc";
 import {
-  BUILTIN_CONSTRAINT_DEFINITIONS,
-  normalizeConstraintTagName,
+  BUILTIN_CONSTRAINT_DEFINITIONS as BUILTIN_CONSTRAINT_DEFINITIONS2,
+  normalizeConstraintTagName as normalizeConstraintTagName2,
   isBuiltinConstraintName
 } from "@formspec/core/internals";
 import "@formspec/core/internals";
 function createFormSpecTSDocConfig(extensionTagNames = []) {
   const config = new TSDocConfiguration();
-  for (const tagName of Object.keys(BUILTIN_CONSTRAINT_DEFINITIONS)) {
+  for (const tagName of Object.keys(BUILTIN_CONSTRAINT_DEFINITIONS2)) {
     config.addTagDefinition(
       new TSDocTagDefinition({
         tagName: "@" + tagName,
@@ -2056,7 +2122,7 @@ function createFormSpecTSDocConfig(extensionTagNames = []) {
       })
     );
   }
-  for (const tagName of ["displayName", "format", "placeholder"]) {
+  for (const tagName of ["apiName", "displayName", "format", "placeholder"]) {
     config.addTagDefinition(
       new TSDocTagDefinition({
         tagName: "@" + tagName,
@@ -2089,6 +2155,16 @@ function sharedTagValueOptions(options) {
     ...options?.fieldType !== void 0 ? { fieldType: options.fieldType } : {}
   };
 }
+function getExtensionTypeNames(registry) {
+  if (registry === void 0) {
+    return /* @__PURE__ */ new Set();
+  }
+  return new Set(
+    registry.extensions.flatMap(
+      (ext) => (ext.types ?? []).flatMap((t) => t.tsTypeNames ?? [t.typeName])
+    )
+  );
+}
 function collectImportedNames(sourceFile) {
   const importedNames = /* @__PURE__ */ new Set();
   for (const statement of sourceFile.statements) {
@@ -2128,6 +2204,9 @@ function isNonReferenceIdentifier(node) {
   return false;
 }
 function statementReferencesImportedName(statement, importedNames) {
+  if (importedNames.size === 0) {
+    return false;
+  }
   let referencesImportedName = false;
   const visit = (node) => {
     if (referencesImportedName) {
@@ -2142,14 +2221,17 @@ function statementReferencesImportedName(statement, importedNames) {
   visit(statement);
   return referencesImportedName;
 }
-function buildSupportingDeclarations(sourceFile) {
+function buildSupportingDeclarations(sourceFile, extensionTypeNames) {
   const importedNames = collectImportedNames(sourceFile);
+  const importedNamesToSkip = new Set(
+    [...importedNames].filter((name) => !extensionTypeNames.has(name))
+  );
   return sourceFile.statements.filter((statement) => {
     if (ts.isImportDeclaration(statement)) return false;
     if (ts.isImportEqualsDeclaration(statement)) return false;
     if (ts.isExportDeclaration(statement) && statement.moduleSpecifier !== void 0)
       return false;
-    if (importedNames.size > 0 && statementReferencesImportedName(statement, importedNames)) {
+    if (statementReferencesImportedName(statement, importedNamesToSkip)) {
       return false;
     }
     return true;
@@ -2302,7 +2384,7 @@ function buildCompilerBackedConstraintDiagnostics(node, sourceFile, tagName, par
   if (placement === null) {
     return [];
   }
-  const definition = getTagDefinition(tagName, options?.extensionRegistry?.extensions);
+  const definition = getTagDefinition2(tagName, options?.extensionRegistry?.extensions);
   if (definition === null) {
     return [];
   }
@@ -2406,6 +2488,14 @@ function buildCompilerBackedConstraintDiagnostics(node, sourceFile, tagName, par
         extensionId: extension.extensionId,
         ...extension.constraintTags !== void 0 ? {
           constraintTags: extension.constraintTags.map((tag) => ({ tagName: tag.tagName }))
+        } : {},
+        ...extension.metadataSlots !== void 0 ? {
+          metadataSlots: extension.metadataSlots
+        } : {},
+        ...extension.types !== void 0 ? {
+          customTypes: extension.types.map((t) => ({
+            tsTypeNames: t.tsTypeNames ?? [t.typeName]
+          }))
         } : {}
       }))
     } : {}
@@ -2425,7 +2515,10 @@ function buildCompilerBackedConstraintDiagnostics(node, sourceFile, tagName, par
 function getParser(options) {
   const extensionTagNames = [
     ...options?.extensionRegistry?.extensions.flatMap(
-      (extension) => (extension.constraintTags ?? []).map((tag) => tag.tagName)
+      (extension) => (extension.constraintTags ?? []).map((tag) => normalizeFormSpecTagName2(tag.tagName))
+    ) ?? [],
+    ...options?.extensionRegistry?.extensions.flatMap(
+      (extension) => (extension.metadataSlots ?? []).map((slot) => normalizeFormSpecTagName2(slot.tagName))
     ) ?? []
   ].sort();
   const cacheKey = extensionTagNames.join("|");
@@ -2445,7 +2538,16 @@ function getExtensionRegistryCacheKey(registry) {
     (extension) => JSON.stringify({
       extensionId: extension.extensionId,
       typeNames: extension.types?.map((type) => type.typeName) ?? [],
-      constraintTags: extension.constraintTags?.map((tag) => tag.tagName) ?? []
+      constraintTags: extension.constraintTags?.map((tag) => normalizeFormSpecTagName2(tag.tagName)) ?? [],
+      metadataSlots: extension.metadataSlots?.map((slot) => ({
+        tagName: normalizeFormSpecTagName2(slot.tagName),
+        declarationKinds: [...slot.declarationKinds].sort(),
+        allowBare: slot.allowBare !== false,
+        qualifiers: (slot.qualifiers ?? []).map((qualifier) => ({
+          qualifier: qualifier.qualifier,
+          ...qualifier.sourceQualifier !== void 0 ? { sourceQualifier: qualifier.sourceQualifier } : {}
+        })).sort((left, right) => left.qualifier.localeCompare(right.qualifier))
+      })) ?? []
     })
   ).join("|");
 }
@@ -2480,7 +2582,8 @@ function parseTSDocTags(node, file = "", options) {
   const rawTextTags = [];
   const sourceFile = node.getSourceFile();
   const sourceText = sourceFile.getFullText();
-  const supportingDeclarations = buildSupportingDeclarations(sourceFile);
+  const extensionTypeNames = getExtensionTypeNames(options?.extensionRegistry);
+  const supportingDeclarations = buildSupportingDeclarations(sourceFile, extensionTypeNames);
   const commentRanges = ts.getLeadingCommentRanges(sourceText, node.getFullStart());
   const rawTextFallbacks = collectRawTextFallbacks(node, file);
   if (commentRanges) {
@@ -2518,7 +2621,7 @@ function parseTSDocTags(node, file = "", options) {
         }
       }
       for (const block of docComment.customBlocks) {
-        const tagName = normalizeConstraintTagName(block.blockTag.tagName.substring(1));
+        const tagName = normalizeConstraintTagName2(block.blockTag.tagName.substring(1));
         const parsedTag = nextParsedTag(tagName);
         if (tagName === "displayName" || tagName === "format" || tagName === "placeholder") {
           const text2 = getBestBlockPayloadText(parsedTag, commentText, range.pos, block);
@@ -2550,7 +2653,7 @@ function parseTSDocTags(node, file = "", options) {
         }
         if (TAGS_REQUIRING_RAW_TEXT.has(tagName)) continue;
         const text = getBestBlockPayloadText(parsedTag, commentText, range.pos, block);
-        const expectedType = isBuiltinConstraintName(tagName) ? BUILTIN_CONSTRAINT_DEFINITIONS[tagName] : void 0;
+        const expectedType = isBuiltinConstraintName(tagName) ? BUILTIN_CONSTRAINT_DEFINITIONS2[tagName] : void 0;
         if (text === "" && expectedType !== "boolean") continue;
         const provenance = parsedTag !== null ? provenanceForParsedTag(parsedTag, sourceFile, file) : provenanceForComment(range, sourceFile, file, tagName);
         const compilerDiagnostics = buildCompilerBackedConstraintDiagnostics(
@@ -2781,7 +2884,7 @@ function getBestBlockPayloadText(tag, commentText, commentOffset, block) {
 function collectRawTextFallbacks(node, file) {
   const fallbacks = /* @__PURE__ */ new Map();
   for (const tag of ts.getJSDocTags(node)) {
-    const tagName = normalizeConstraintTagName(tag.tagName.text);
+    const tagName = normalizeConstraintTagName2(tag.tagName.text);
     if (!TAGS_REQUIRING_RAW_TEXT.has(tagName)) continue;
     const commentText = getTagCommentText(tag)?.trim() ?? "";
     if (commentText === "") continue;
@@ -2904,6 +3007,7 @@ var init_jsdoc_constraints = __esm({
 // src/analyzer/class-analyzer.ts
 import * as ts3 from "typescript";
 import {
+  analyzeMetadataForNodeWithChecker,
   parseCommentBlock as parseCommentBlock2
 } from "@formspec/analysis/internal";
 function isObjectType(type) {
@@ -2924,76 +3028,79 @@ function makeParseOptions(extensionRegistry, fieldType, checker, subjectType, ho
     ...hostType !== void 0 && { hostType }
   };
 }
-function makeExplicitScalarMetadata(value) {
-  return value === void 0 || value === "" ? void 0 : { value, source: "explicit" };
+function createAnalyzerMetadataPolicy(input) {
+  return {
+    raw: input,
+    normalized: normalizeMetadataPolicy(input)
+  };
 }
-function extractExplicitMetadata(node) {
-  let apiName;
-  let displayName;
-  let apiNamePlural;
-  let displayNamePlural;
-  for (const tag of getLeadingParsedTags(node)) {
-    const value = tag.argumentText.trim();
-    if (value === "") {
-      continue;
-    }
-    if (tag.normalizedTagName === "apiName") {
-      if (tag.target === null) {
-        apiName ??= value;
-      } else if (tag.target.kind === "variant") {
-        if (tag.target.rawText === "singular") {
-          apiName ??= value;
-        } else if (tag.target.rawText === "plural") {
-          apiNamePlural ??= value;
-        }
-      }
-      continue;
-    }
-    if (tag.normalizedTagName === "displayName") {
-      if (tag.target === null) {
-        displayName ??= value;
-      } else if (tag.target.kind === "variant") {
-        if (tag.target.rawText === "singular") {
-          displayName ??= value;
-        } else if (tag.target.rawText === "plural") {
-          displayNamePlural ??= value;
-        }
-      }
-    }
+function resolveNodeMetadata(metadataPolicy, declarationKind, logicalName, node, checker, extensionRegistry, buildContext) {
+  const analysis = analyzeMetadataForNodeWithChecker({
+    checker,
+    node,
+    logicalName,
+    metadata: metadataPolicy.raw,
+    extensions: extensionRegistry?.extensions,
+    ...buildContext !== void 0 && { buildContext }
+  });
+  const resolvedMetadata = analysis?.resolvedMetadata;
+  const declarationPolicy = getDeclarationMetadataPolicy(
+    metadataPolicy.normalized,
+    declarationKind
+  );
+  if (resolvedMetadata?.apiName === void 0 && declarationPolicy.apiName.mode === "require-explicit") {
+    throw new Error(
+      `Metadata policy requires explicit apiName for ${declarationKind} "${logicalName}" on the tsdoc surface.`
+    );
   }
-  const resolvedApiName = makeExplicitScalarMetadata(apiName);
-  const resolvedDisplayName = makeExplicitScalarMetadata(displayName);
-  const resolvedApiNamePlural = makeExplicitScalarMetadata(apiNamePlural);
-  const resolvedDisplayNamePlural = makeExplicitScalarMetadata(displayNamePlural);
-  const metadata = {
-    ...resolvedApiName !== void 0 && { apiName: resolvedApiName },
-    ...resolvedDisplayName !== void 0 && { displayName: resolvedDisplayName },
-    ...resolvedApiNamePlural !== void 0 && { apiNamePlural: resolvedApiNamePlural },
-    ...resolvedDisplayNamePlural !== void 0 && {
-      displayNamePlural: resolvedDisplayNamePlural
-    }
-  };
-  return Object.keys(metadata).length === 0 ? void 0 : metadata;
+  if (resolvedMetadata?.displayName === void 0 && declarationPolicy.displayName.mode === "require-explicit") {
+    throw new Error(
+      `Metadata policy requires explicit displayName for ${declarationKind} "${logicalName}" on the tsdoc surface.`
+    );
+  }
+  if (resolvedMetadata?.apiNamePlural === void 0 && declarationPolicy.apiName.pluralization.mode === "require-explicit") {
+    throw new Error(
+      `Metadata policy requires explicit apiNamePlural for ${declarationKind} "${logicalName}" on the tsdoc surface.`
+    );
+  }
+  if (resolvedMetadata?.displayNamePlural === void 0 && declarationPolicy.displayName.pluralization.mode === "require-explicit") {
+    throw new Error(
+      `Metadata policy requires explicit displayNamePlural for ${declarationKind} "${logicalName}" on the tsdoc surface.`
+    );
+  }
+  return resolvedMetadata;
 }
-function resolveNodeMetadata(metadataPolicy, declarationKind, logicalName, node, buildContext) {
-  const explicit = extractExplicitMetadata(node);
-  return resolveMetadata(
+function analyzeDeclarationRootInfo(declaration, checker, file = "", extensionRegistry, metadataPolicy) {
+  const normalizedMetadataPolicy = createAnalyzerMetadataPolicy(metadataPolicy);
+  const declarationType = checker.getTypeAtLocation(declaration);
+  const logicalName = ts3.isClassDeclaration(declaration) ? declaration.name?.text ?? "AnonymousClass" : declaration.name.text;
+  const docResult = extractJSDocParseResult(
+    declaration,
+    file,
+    makeParseOptions(extensionRegistry, void 0, checker, declarationType, declarationType)
+  );
+  const metadata = resolveNodeMetadata(
+    normalizedMetadataPolicy,
+    "type",
+    logicalName,
+    declaration,
+    checker,
+    extensionRegistry,
     {
-      ...explicit?.apiName !== void 0 && { apiName: explicit.apiName.value },
-      ...explicit?.displayName !== void 0 && { displayName: explicit.displayName.value },
-      ...explicit?.apiNamePlural !== void 0 && {
-        apiNamePlural: explicit.apiNamePlural.value
-      },
-      ...explicit?.displayNamePlural !== void 0 && {
-        displayNamePlural: explicit.displayNamePlural.value
-      }
-    },
-    getDeclarationMetadataPolicy(metadataPolicy, declarationKind),
-    makeMetadataContext("tsdoc", declarationKind, logicalName, buildContext)
+      checker,
+      declaration,
+      subjectType: declarationType,
+      hostType: declarationType
+    }
   );
+  return {
+    ...metadata !== void 0 && { metadata },
+    annotations: docResult.annotations,
+    diagnostics: docResult.diagnostics
+  };
 }
 function analyzeClassToIR(classDecl, checker, file = "", extensionRegistry, metadataPolicy) {
-  const normalizedMetadataPolicy = normalizeMetadataPolicy(metadataPolicy);
+  const normalizedMetadataPolicy = createAnalyzerMetadataPolicy(metadataPolicy);
   const name = classDecl.name?.text ?? "AnonymousClass";
   const fields = [];
   const fieldLayouts = [];
@@ -3048,12 +3155,20 @@ function analyzeClassToIR(classDecl, checker, file = "", extensionRegistry, meta
     diagnostics,
     normalizedMetadataPolicy
   );
-  const metadata = resolveNodeMetadata(normalizedMetadataPolicy, "type", name, classDecl, {
+  const metadata = resolveNodeMetadata(
+    normalizedMetadataPolicy,
+    "type",
+    name,
+    classDecl,
     checker,
-    declaration: classDecl,
-    subjectType: classType,
-    hostType: classType
-  });
+    extensionRegistry,
+    {
+      checker,
+      declaration: classDecl,
+      subjectType: classType,
+      hostType: classType
+    }
+  );
   return {
     name,
     ...metadata !== void 0 && { metadata },
@@ -3067,7 +3182,7 @@ function analyzeClassToIR(classDecl, checker, file = "", extensionRegistry, meta
   };
 }
 function analyzeInterfaceToIR(interfaceDecl, checker, file = "", extensionRegistry, metadataPolicy) {
-  const normalizedMetadataPolicy = normalizeMetadataPolicy(metadataPolicy);
+  const normalizedMetadataPolicy = createAnalyzerMetadataPolicy(metadataPolicy);
   const name = interfaceDecl.name.text;
   const fields = [];
   const typeRegistry = {};
@@ -3109,12 +3224,20 @@ function analyzeInterfaceToIR(interfaceDecl, checker, file = "", extensionRegist
     normalizedMetadataPolicy
   );
   const fieldLayouts = specializedFields.map(() => ({}));
-  const metadata = resolveNodeMetadata(normalizedMetadataPolicy, "type", name, interfaceDecl, {
+  const metadata = resolveNodeMetadata(
+    normalizedMetadataPolicy,
+    "type",
+    name,
+    interfaceDecl,
     checker,
-    declaration: interfaceDecl,
-    subjectType: interfaceType,
-    hostType: interfaceType
-  });
+    extensionRegistry,
+    {
+      checker,
+      declaration: interfaceDecl,
+      subjectType: interfaceType,
+      hostType: interfaceType
+    }
+  );
   return {
     name,
     ...metadata !== void 0 && { metadata },
@@ -3138,7 +3261,7 @@ function analyzeTypeAliasToIR(typeAlias, checker, file = "", extensionRegistry,
     };
   }
   const typeLiteral = typeAlias.type;
-  const normalizedMetadataPolicy = normalizeMetadataPolicy(metadataPolicy);
+  const normalizedMetadataPolicy = createAnalyzerMetadataPolicy(metadataPolicy);
   const name = typeAlias.name.text;
   const fields = [];
   const typeRegistry = {};
@@ -3179,12 +3302,20 @@ function analyzeTypeAliasToIR(typeAlias, checker, file = "", extensionRegistry,
     diagnostics,
     normalizedMetadataPolicy
   );
-  const metadata = resolveNodeMetadata(normalizedMetadataPolicy, "type", name, typeAlias, {
+  const metadata = resolveNodeMetadata(
+    normalizedMetadataPolicy,
+    "type",
+    name,
+    typeAlias,
     checker,
-    declaration: typeAlias,
-    subjectType: aliasType,
-    hostType: aliasType
-  });
+    extensionRegistry,
+    {
+      checker,
+      declaration: typeAlias,
+      subjectType: aliasType,
+      hostType: aliasType
+    }
+  );
   return {
     ok: true,
     analysis: {
@@ -3406,10 +3537,7 @@ function resolveLiteralDiscriminatorPropertyValue(boundType, fieldName, checker,
   if (resolvedAnchorNode === null) {
     return void 0;
   }
-  const propertyType = checker.getTypeOfSymbolAtLocation(
-    propertySymbol,
-    resolvedAnchorNode
-  );
+  const propertyType = checker.getTypeOfSymbolAtLocation(propertySymbol, resolvedAnchorNode);
   if (propertyType.isStringLiteral()) {
     return propertyType.value;
   }
@@ -3440,6 +3568,8 @@ function resolveDiscriminatorApiName(boundType, checker, metadataPolicy) {
     "type",
     getDiscriminatorLogicalName(boundType, declaration, checker),
     declaration,
+    checker,
+    void 0,
     {
       checker,
       declaration,
@@ -3676,12 +3806,20 @@ function analyzeFieldToIR(prop, checker, file, typeRegistry, visiting, diagnosti
     annotations.push(defaultAnnotation);
   }
   ({ type, annotations } = applyEnumMemberDisplayNames(type, annotations));
-  const metadata = resolveNodeMetadata(metadataPolicy, "field", name, prop, {
+  const metadata = resolveNodeMetadata(
+    metadataPolicy,
+    "field",
+    name,
+    prop,
     checker,
-    declaration: prop,
-    subjectType: tsType,
-    hostType
-  });
+    extensionRegistry,
+    {
+      checker,
+      declaration: prop,
+      subjectType: tsType,
+      hostType
+    }
+  );
   return {
     kind: "field",
     name,
@@ -3728,12 +3866,20 @@ function analyzeInterfacePropertyToIR(prop, checker, file, typeRegistry, visitin
   let annotations = [];
   annotations.push(...docResult.annotations);
   ({ type, annotations } = applyEnumMemberDisplayNames(type, annotations));
-  const metadata = resolveNodeMetadata(metadataPolicy, "field", name, prop, {
+  const metadata = resolveNodeMetadata(
+    metadataPolicy,
+    "field",
+    name,
+    prop,
     checker,
-    declaration: prop,
-    subjectType: tsType,
-    hostType
-  });
+    extensionRegistry,
+    {
+      checker,
+      declaration: prop,
+      subjectType: tsType,
+      hostType
+    }
+  );
   return {
     kind: "field",
     name,
@@ -3862,7 +4008,7 @@ function getTypeNodeRegistrationName(typeNode) {
   }
   return null;
 }
-function resolveTypeNode(type, checker, file, typeRegistry, visiting, sourceNode, metadataPolicy = normalizeMetadataPolicy(void 0), extensionRegistry, diagnostics) {
+function resolveTypeNode(type, checker, file, typeRegistry, visiting, sourceNode, metadataPolicy = createAnalyzerMetadataPolicy(void 0), extensionRegistry, diagnostics) {
   const customType = resolveRegisteredCustomType(sourceNode, extensionRegistry, checker);
   if (customType) {
     return customType;
@@ -3952,7 +4098,7 @@ function resolveTypeNode(type, checker, file, typeRegistry, visiting, sourceNode
   }
   return { kind: "primitive", primitiveKind: "string" };
 }
-function tryResolveNamedPrimitiveAlias(type, checker, file, typeRegistry, visiting, sourceNode, metadataPolicy = normalizeMetadataPolicy(void 0), extensionRegistry, diagnostics) {
+function tryResolveNamedPrimitiveAlias(type, checker, file, typeRegistry, visiting, sourceNode, metadataPolicy = createAnalyzerMetadataPolicy(void 0), extensionRegistry, diagnostics) {
   if (!(type.flags & (ts3.TypeFlags.String | ts3.TypeFlags.Number | ts3.TypeFlags.BigInt | ts3.TypeFlags.BigIntLiteral | ts3.TypeFlags.Boolean | ts3.TypeFlags.Null))) {
     return null;
   }
@@ -3972,11 +4118,19 @@ function tryResolveNamedPrimitiveAlias(type, checker, file, typeRegistry, visiti
       file,
       makeParseOptions(extensionRegistry)
     );
-    const metadata = resolveNodeMetadata(metadataPolicy, "type", aliasName, aliasDecl, {
+    const metadata = resolveNodeMetadata(
+      metadataPolicy,
+      "type",
+      aliasName,
+      aliasDecl,
       checker,
-      declaration: aliasDecl,
-      subjectType: aliasType
-    });
+      extensionRegistry,
+      {
+        checker,
+        declaration: aliasDecl,
+        subjectType: aliasType
+      }
+    );
     typeRegistry[aliasName] = {
       name: aliasName,
       ...metadata !== void 0 && { metadata },
@@ -4015,7 +4169,7 @@ function shouldEmitPrimitiveAliasDefinition(typeNode, checker) {
   const resolved = checker.getTypeFromTypeNode(aliasDecl.type);
   return !!(resolved.flags & (ts3.TypeFlags.String | ts3.TypeFlags.Number | ts3.TypeFlags.BigInt | ts3.TypeFlags.BigIntLiteral | ts3.TypeFlags.Boolean | ts3.TypeFlags.Null));
 }
-function resolveAliasedPrimitiveTarget(type, checker, file, typeRegistry, visiting, metadataPolicy = normalizeMetadataPolicy(void 0), extensionRegistry, diagnostics) {
+function resolveAliasedPrimitiveTarget(type, checker, file, typeRegistry, visiting, metadataPolicy = createAnalyzerMetadataPolicy(void 0), extensionRegistry, diagnostics) {
   const nestedAliasDecl = type.aliasSymbol?.declarations?.find(ts3.isTypeAliasDeclaration);
   if (nestedAliasDecl !== void 0) {
     return resolveAliasedPrimitiveTarget(
@@ -4041,7 +4195,7 @@ function resolveAliasedPrimitiveTarget(type, checker, file, typeRegistry, visiti
     diagnostics
   );
 }
-function resolveUnionType(type, checker, file, typeRegistry, visiting, sourceNode, metadataPolicy = normalizeMetadataPolicy(void 0), extensionRegistry, diagnostics) {
+function resolveUnionType(type, checker, file, typeRegistry, visiting, sourceNode, metadataPolicy = createAnalyzerMetadataPolicy(void 0), extensionRegistry, diagnostics) {
   const typeName = getNamedTypeName(type);
   const namedDecl = getNamedTypeDeclaration(type);
   if (typeName && typeName in typeRegistry) {
@@ -4076,11 +4230,19 @@ function resolveUnionType(type, checker, file, typeRegistry, visiting, sourceNod
       return result;
     }
     const annotations = namedDecl ? extractJSDocAnnotationNodes(namedDecl, file, makeParseOptions(extensionRegistry)) : void 0;
-    const metadata = namedDecl !== void 0 ? resolveNodeMetadata(metadataPolicy, "type", typeName, namedDecl, {
+    const metadata = namedDecl !== void 0 ? resolveNodeMetadata(
+      metadataPolicy,
+      "type",
+      typeName,
+      namedDecl,
       checker,
-      declaration: namedDecl,
-      subjectType: type
-    }) : void 0;
+      extensionRegistry,
+      {
+        checker,
+        declaration: namedDecl,
+        subjectType: type
+      }
+    ) : void 0;
     typeRegistry[typeName] = {
       name: typeName,
       ...metadata !== void 0 && { metadata },
@@ -4165,7 +4327,7 @@ function resolveUnionType(type, checker, file, typeRegistry, visiting, sourceNod
   }
   return registerNamed({ kind: "union", members });
 }
-function resolveArrayType(type, checker, file, typeRegistry, visiting, sourceNode, metadataPolicy = normalizeMetadataPolicy(void 0), extensionRegistry, diagnostics) {
+function resolveArrayType(type, checker, file, typeRegistry, visiting, sourceNode, metadataPolicy = createAnalyzerMetadataPolicy(void 0), extensionRegistry, diagnostics) {
   const typeArgs = isTypeReference(type) ? type.typeArguments : void 0;
   const elementType = typeArgs?.[0];
   const elementSourceNode = extractArrayElementTypeNode(sourceNode, checker);
@@ -4182,7 +4344,7 @@ function resolveArrayType(type, checker, file, typeRegistry, visiting, sourceNod
   ) : { kind: "primitive", primitiveKind: "string" };
   return { kind: "array", items };
 }
-function tryResolveRecordType(type, checker, file, typeRegistry, visiting, metadataPolicy = normalizeMetadataPolicy(void 0), extensionRegistry, diagnostics) {
+function tryResolveRecordType(type, checker, file, typeRegistry, visiting, metadataPolicy = createAnalyzerMetadataPolicy(void 0), extensionRegistry, diagnostics) {
   if (type.getProperties().length > 0) {
     return null;
   }
@@ -4243,7 +4405,7 @@ function shouldEmitResolvedObjectProperty(property, declaration) {
   }
   return true;
 }
-function resolveObjectType(type, checker, file, typeRegistry, visiting, sourceNode, metadataPolicy = normalizeMetadataPolicy(void 0), extensionRegistry, diagnostics) {
+function resolveObjectType(type, checker, file, typeRegistry, visiting, sourceNode, metadataPolicy = createAnalyzerMetadataPolicy(void 0), extensionRegistry, diagnostics) {
   const collectedDiagnostics = diagnostics ?? [];
   const typeName = getNamedTypeName(type);
   const namedTypeName = typeName ?? void 0;
@@ -4319,11 +4481,19 @@ function resolveObjectType(type, checker, file, typeRegistry, visiting, sourceNo
         return recordNode;
       }
       const annotations = namedDecl ? extractJSDocAnnotationNodes(namedDecl, file, makeParseOptions(extensionRegistry)) : void 0;
-      const metadata = namedDecl !== void 0 ? resolveNodeMetadata(metadataPolicy, "type", registryTypeName, namedDecl, {
+      const metadata = namedDecl !== void 0 ? resolveNodeMetadata(
+        metadataPolicy,
+        "type",
+        registryTypeName,
+        namedDecl,
         checker,
-        declaration: namedDecl,
-        subjectType: type
-      }) : void 0;
+        extensionRegistry,
+        {
+          checker,
+          declaration: namedDecl,
+          subjectType: type
+        }
+      ) : void 0;
       typeRegistry[registryTypeName] = {
         name: registryTypeName,
         ...metadata !== void 0 && { metadata },
@@ -4368,14 +4538,39 @@ function resolveObjectType(type, checker, file, typeRegistry, visiting, sourceNo
       collectedDiagnostics
     );
     const fieldNodeInfo = fieldInfoMap?.get(prop.name);
+    const inlineFieldNodeInfo = fieldNodeInfo === void 0 ? ts3.isPropertySignature(declaration) ? analyzeInterfacePropertyToIR(
+      declaration,
+      checker,
+      file,
+      typeRegistry,
+      visiting,
+      collectedDiagnostics,
+      type,
+      metadataPolicy,
+      extensionRegistry
+    ) : ts3.isPropertyDeclaration(declaration) ? analyzeFieldToIR(
+      declaration,
+      checker,
+      file,
+      typeRegistry,
+      visiting,
+      collectedDiagnostics,
+      type,
+      metadataPolicy,
+      extensionRegistry
+    ) : null : null;
+    const resolvedFieldNodeInfo = fieldNodeInfo ?? inlineFieldNodeInfo;
+    const resolvedPropertyType = inlineFieldNodeInfo?.type ?? propTypeNode;
     properties.push({
       name: prop.name,
-      ...fieldNodeInfo?.metadata !== void 0 && { metadata: fieldNodeInfo.metadata },
-      type: propTypeNode,
+      ...resolvedFieldNodeInfo?.metadata !== void 0 && {
+        metadata: resolvedFieldNodeInfo.metadata
+      },
+      type: resolvedPropertyType,
       optional,
-      constraints: fieldNodeInfo?.constraints ?? [],
-      annotations: fieldNodeInfo?.annotations ?? [],
-      provenance: fieldNodeInfo?.provenance ?? provenanceForFile(file)
+      constraints: resolvedFieldNodeInfo?.constraints ?? [],
+      annotations: resolvedFieldNodeInfo?.annotations ?? [],
+      provenance: resolvedFieldNodeInfo?.provenance ?? provenanceForFile(file)
     });
   }
   visiting.delete(type);
@@ -4394,11 +4589,19 @@ function resolveObjectType(type, checker, file, typeRegistry, visiting, sourceNo
   };
   if (registryTypeName !== void 0 && shouldRegisterNamedType) {
     const annotations = namedDecl ? extractJSDocAnnotationNodes(namedDecl, file, makeParseOptions(extensionRegistry)) : void 0;
-    const metadata = namedDecl !== void 0 ? resolveNodeMetadata(metadataPolicy, "type", registryTypeName, namedDecl, {
+    const metadata = namedDecl !== void 0 ? resolveNodeMetadata(
+      metadataPolicy,
+      "type",
+      registryTypeName,
+      namedDecl,
       checker,
-      declaration: namedDecl,
-      subjectType: type
-    }) : void 0;
+      extensionRegistry,
+      {
+        checker,
+        declaration: namedDecl,
+        subjectType: type
+      }
+    ) : void 0;
     typeRegistry[registryTypeName] = {
       name: registryTypeName,
       ...metadata !== void 0 && { metadata },
@@ -5020,6 +5223,360 @@ var init_class_schema = __esm({
   }
 });
 
+// src/static-build.ts
+import * as ts6 from "typescript";
+function toStaticBuildContext(context) {
+  return context;
+}
+function createStaticBuildContext(filePath) {
+  return toStaticBuildContext(createProgramContext(filePath));
+}
+function createStaticBuildContextFromProgram(program, filePath) {
+  return toStaticBuildContext(createProgramContextFromProgram(program, filePath));
+}
+function getModuleSymbol(context) {
+  const sourceFileWithSymbol = context.sourceFile;
+  return context.checker.getSymbolAtLocation(context.sourceFile) ?? sourceFileWithSymbol.symbol;
+}
+function isSchemaSourceDeclaration(declaration) {
+  return ts6.isClassDeclaration(declaration) || ts6.isInterfaceDeclaration(declaration) || ts6.isTypeAliasDeclaration(declaration);
+}
+function resolveModuleExport(context, exportName = "default") {
+  const moduleSymbol = getModuleSymbol(context);
+  if (moduleSymbol === void 0) {
+    return null;
+  }
+  const exportSymbol = context.checker.getExportsOfModule(moduleSymbol).find((candidate) => candidate.name === exportName) ?? null;
+  if (exportSymbol === null) {
+    return null;
+  }
+  return exportSymbol.flags & ts6.SymbolFlags.Alias ? context.checker.getAliasedSymbol(exportSymbol) : exportSymbol;
+}
+function resolveModuleExportDeclaration(context, exportName = "default") {
+  return resolveModuleExport(context, exportName)?.declarations?.find(isSchemaSourceDeclaration) ?? null;
+}
+var init_static_build = __esm({
+  "src/static-build.ts"() {
+    "use strict";
+    init_program();
+  }
+});
+
+// src/generators/discovered-schema.ts
+import * as ts7 from "typescript";
+import { IR_VERSION as IR_VERSION3 } from "@formspec/core/internals";
+function toDiscoveredTypeSchemas(result) {
+  return result;
+}
+function isNamedTypeDeclaration(declaration) {
+  return ts7.isClassDeclaration(declaration) || ts7.isInterfaceDeclaration(declaration) || ts7.isTypeAliasDeclaration(declaration);
+}
+function hasConcreteTypeArguments(type, checker) {
+  if ("aliasTypeArguments" in type && Array.isArray(type.aliasTypeArguments) && type.aliasTypeArguments.length > 0) {
+    return true;
+  }
+  if ((type.flags & ts7.TypeFlags.Object) === 0) {
+    return false;
+  }
+  const objectType = type;
+  if ((objectType.objectFlags & ts7.ObjectFlags.Reference) === 0) {
+    return false;
+  }
+  return checker.getTypeArguments(objectType).length > 0;
+}
+function getNamedTypeDeclaration2(type) {
+  const symbol = type.getSymbol();
+  if (symbol?.declarations !== void 0) {
+    const declaration = symbol.declarations[0];
+    if (declaration !== void 0 && isNamedTypeDeclaration(declaration)) {
+      return declaration;
+    }
+  }
+  const aliasDeclaration = type.aliasSymbol?.declarations?.find(ts7.isTypeAliasDeclaration);
+  return aliasDeclaration;
+}
+function getFallbackName(sourceNode, fallback = "AnonymousType") {
+  if (sourceNode !== void 0 && "name" in sourceNode) {
+    const namedNode = sourceNode;
+    if (namedNode.name !== void 0 && ts7.isIdentifier(namedNode.name)) {
+      return namedNode.name.text;
+    }
+  }
+  return fallback;
+}
+function createObjectRootAnalysis(name, properties, typeRegistry, metadata, annotations) {
+  const fields = properties.map((property) => ({
+    kind: "field",
+    name: property.name,
+    ...property.metadata !== void 0 && { metadata: property.metadata },
+    type: property.type,
+    required: !property.optional,
+    constraints: property.constraints,
+    annotations: property.annotations,
+    provenance: property.provenance
+  }));
+  return {
+    name,
+    ...metadata !== void 0 && { metadata },
+    fields,
+    fieldLayouts: fields.map(() => ({})),
+    typeRegistry,
+    ...annotations !== void 0 && annotations.length > 0 && { annotations },
+    instanceMethods: [],
+    staticMethods: [],
+    diagnostics: []
+  };
+}
+function omitApiName(metadata) {
+  if (metadata?.apiName === void 0) {
+    return metadata;
+  }
+  const { apiName: _apiName, ...rest } = metadata;
+  return Object.keys(rest).length > 0 ? rest : void 0;
+}
+function describeRootType(rootType, typeRegistry, fallbackName) {
+  if (rootType.kind !== "reference") {
+    return {
+      name: fallbackName,
+      type: rootType
+    };
+  }
+  const definition = typeRegistry[rootType.name];
+  if (definition === void 0) {
+    return {
+      name: rootType.name,
+      type: rootType
+    };
+  }
+  return {
+    name: definition.name,
+    ...definition.metadata !== void 0 && { metadata: definition.metadata },
+    ...definition.annotations !== void 0 && definition.annotations.length > 0 && { annotations: definition.annotations },
+    type: definition.type
+  };
+}
+function toStandaloneJsonSchema(root, typeRegistry, options) {
+  const syntheticFieldMetadata = omitApiName(root.metadata);
+  const syntheticField = {
+    kind: "field",
+    name: "__result",
+    ...syntheticFieldMetadata !== void 0 && { metadata: syntheticFieldMetadata },
+    type: root.type,
+    required: true,
+    constraints: [],
+    annotations: [...root.annotations ?? []],
+    provenance: {
+      surface: "tsdoc",
+      file: "",
+      line: 1,
+      column: 0
+    }
+  };
+  const schema = generateJsonSchemaFromIR(
+    {
+      kind: "form-ir",
+      name: root.name,
+      irVersion: IR_VERSION3,
+      elements: [syntheticField],
+      ...root.metadata !== void 0 && { metadata: root.metadata },
+      ...root.annotations !== void 0 && root.annotations.length > 0 && { rootAnnotations: root.annotations },
+      typeRegistry,
+      provenance: syntheticField.provenance
+    },
+    {
+      extensionRegistry: options?.extensionRegistry,
+      vendorPrefix: options?.vendorPrefix
+    }
+  );
+  const result = schema.properties?.["__result"];
+  if (result === void 0) {
+    throw new Error("FormSpec failed to extract the standalone schema root from the synthetic IR.");
+  }
+  if (schema.$defs === void 0 || Object.keys(schema.$defs).length === 0) {
+    return {
+      ...schema.$schema !== void 0 && { $schema: schema.$schema },
+      ...result
+    };
+  }
+  return {
+    ...schema.$schema !== void 0 && { $schema: schema.$schema },
+    ...result,
+    $defs: schema.$defs
+  };
+}
+function generateSchemasFromAnalysis(analysis, filePath, options) {
+  return toDiscoveredTypeSchemas(
+    generateClassSchemas(
+      analysis,
+      { file: filePath },
+      {
+        extensionRegistry: options?.extensionRegistry,
+        metadata: options?.metadata,
+        vendorPrefix: options?.vendorPrefix
+      }
+    )
+  );
+}
+function generateSchemasFromResolvedType(options, skipNamedDeclaration = false, rootOverride) {
+  const namedDeclaration = skipNamedDeclaration || hasConcreteTypeArguments(options.type, options.context.checker) ? void 0 : getNamedTypeDeclaration2(options.type);
+  if (namedDeclaration !== void 0) {
+    return generateSchemasFromDeclaration({
+      ...options,
+      declaration: namedDeclaration
+    });
+  }
+  const filePath = options.sourceNode?.getSourceFile().fileName ?? options.context.sourceFile.fileName;
+  const typeRegistry = {};
+  const diagnostics = [];
+  const rootType = resolveTypeNode(
+    options.type,
+    options.context.checker,
+    filePath,
+    typeRegistry,
+    /* @__PURE__ */ new Set(),
+    options.sourceNode,
+    createAnalyzerMetadataPolicy(options.metadata),
+    options.extensionRegistry,
+    diagnostics
+  );
+  if (diagnostics.length > 0) {
+    const diagnosticDetails = diagnostics.map((diagnostic) => `${diagnostic.code}: ${diagnostic.message}`).join("; ");
+    throw new Error(
+      `FormSpec validation failed while generating discovered type schemas. ${diagnosticDetails}`
+    );
+  }
+  const describedRoot = describeRootType(
+    rootType,
+    typeRegistry,
+    options.name ?? getFallbackName(options.sourceNode)
+  );
+  const mergedMetadata = mergeResolvedMetadata(describedRoot.metadata, rootOverride?.metadata);
+  const root = {
+    ...describedRoot,
+    ...rootOverride?.name !== void 0 && { name: rootOverride.name },
+    ...mergedMetadata !== void 0 && { metadata: mergedMetadata },
+    ...rootOverride?.annotations !== void 0 && { annotations: rootOverride.annotations }
+  };
+  if (root.type.kind === "object") {
+    return generateSchemasFromAnalysis(
+      createObjectRootAnalysis(
+        options.name ?? root.name,
+        root.type.properties,
+        typeRegistry,
+        root.metadata,
+        root.annotations
+      ),
+      filePath,
+      options
+    );
+  }
+  return {
+    jsonSchema: toStandaloneJsonSchema(root, typeRegistry, options),
+    uiSchema: null
+  };
+}
+function generateSchemasFromDeclaration(options) {
+  const filePath = options.declaration.getSourceFile().fileName;
+  if (ts7.isClassDeclaration(options.declaration)) {
+    return generateSchemasFromAnalysis(
+      analyzeClassToIR(
+        options.declaration,
+        options.context.checker,
+        filePath,
+        options.extensionRegistry,
+        options.metadata
+      ),
+      filePath,
+      options
+    );
+  }
+  if (ts7.isInterfaceDeclaration(options.declaration)) {
+    return generateSchemasFromAnalysis(
+      analyzeInterfaceToIR(
+        options.declaration,
+        options.context.checker,
+        filePath,
+        options.extensionRegistry,
+        options.metadata
+      ),
+      filePath,
+      options
+    );
+  }
+  if (ts7.isTypeAliasDeclaration(options.declaration)) {
+    const analyzedAlias = analyzeTypeAliasToIR(
+      options.declaration,
+      options.context.checker,
+      filePath,
+      options.extensionRegistry,
+      options.metadata
+    );
+    if (analyzedAlias.ok) {
+      return generateSchemasFromAnalysis(analyzedAlias.analysis, filePath, options);
+    }
+    const aliasRootInfo = analyzeDeclarationRootInfo(
+      options.declaration,
+      options.context.checker,
+      filePath,
+      options.extensionRegistry,
+      options.metadata
+    );
+    if (aliasRootInfo.diagnostics.length > 0) {
+      const diagnosticDetails = aliasRootInfo.diagnostics.map((diagnostic) => `${diagnostic.code}: ${diagnostic.message}`).join("; ");
+      throw new Error(
+        `FormSpec validation failed while generating discovered type schemas. ${diagnosticDetails}`
+      );
+    }
+    return generateSchemasFromResolvedType(
+      {
+        ...options,
+        type: options.context.checker.getTypeAtLocation(options.declaration),
+        sourceNode: options.declaration,
+        name: options.declaration.name.text
+      },
+      true,
+      {
+        name: options.declaration.name.text,
+        ...aliasRootInfo.metadata !== void 0 && { metadata: aliasRootInfo.metadata },
+        ...aliasRootInfo.annotations.length > 0 && { annotations: aliasRootInfo.annotations }
+      }
+    );
+  }
+  const _exhaustive = options.declaration;
+  return _exhaustive;
+}
+function generateSchemasFromType(options) {
+  return generateSchemasFromResolvedType(options);
+}
+function generateSchemasFromParameter(options) {
+  return generateSchemasFromResolvedType({
+    ...options,
+    type: options.context.checker.getTypeAtLocation(options.parameter),
+    sourceNode: options.parameter,
+    name: getFallbackName(options.parameter, "Parameter")
+  });
+}
+function generateSchemasFromReturnType(options) {
+  const signature = options.context.checker.getSignatureFromDeclaration(options.declaration);
+  const type = signature !== void 0 ? options.context.checker.getReturnTypeOfSignature(signature) : options.context.checker.getTypeAtLocation(options.declaration);
+  const fallbackName = options.declaration.name !== void 0 && ts7.isIdentifier(options.declaration.name) ? `${options.declaration.name.text}ReturnType` : "ReturnType";
+  return generateSchemasFromResolvedType({
+    ...options,
+    type,
+    sourceNode: options.declaration.type ?? options.declaration,
+    name: fallbackName
+  });
+}
+var init_discovered_schema = __esm({
+  "src/generators/discovered-schema.ts"() {
+    "use strict";
+    init_class_analyzer();
+    init_class_schema();
+    init_ir_generator();
+    init_metadata();
+  }
+});
+
 // src/generators/mixed-authoring.ts
 function buildMixedAuthoringSchemas(options) {
   const { filePath, typeName, overlays, ...schemaOptions } = options;
@@ -5226,12 +5783,20 @@ __export(index_exports, {
   buildFormSchemas: () => buildFormSchemas,
   buildMixedAuthoringSchemas: () => buildMixedAuthoringSchemas,
   createExtensionRegistry: () => createExtensionRegistry,
+  createStaticBuildContext: () => createStaticBuildContext,
+  createStaticBuildContextFromProgram: () => createStaticBuildContextFromProgram,
   generateJsonSchema: () => generateJsonSchema,
   generateSchemas: () => generateSchemas,
   generateSchemasFromClass: () => generateSchemasFromClass,
+  generateSchemasFromDeclaration: () => generateSchemasFromDeclaration,
+  generateSchemasFromParameter: () => generateSchemasFromParameter,
   generateSchemasFromProgram: () => generateSchemasFromProgram,
+  generateSchemasFromReturnType: () => generateSchemasFromReturnType,
+  generateSchemasFromType: () => generateSchemasFromType,
   generateUiSchema: () => generateUiSchema,
   jsonSchema7Schema: () => jsonSchema7Schema,
+  resolveModuleExport: () => resolveModuleExport,
+  resolveModuleExportDeclaration: () => resolveModuleExportDeclaration,
   uiSchemaSchema: () => uiSchema,
   writeSchemas: () => writeSchemas
 });
@@ -5268,6 +5833,8 @@ var init_index = __esm({
     init_generator();
     init_generator2();
     init_class_schema();
+    init_static_build();
+    init_discovered_schema();
     init_mixed_authoring();
   }
 });