@formspec/build 0.1.0-alpha.30 → 0.1.0-alpha.32

package/dist/cli.cjs

@@ -1012,9 +1012,9 @@ function collectFields(elements, properties, required, ctx) {
   for (const element of elements) {
     switch (element.kind) {
       case "field":
-        properties[getSerializedName(element.name, element.metadata)] = generateFieldSchema(element, ctx);
+        properties[getSerializedFieldName(element)] = generateFieldSchema(element, ctx);
         if (element.required) {
-          required.push(getSerializedName(element.name, element.metadata));
+          required.push(getSerializedFieldName(element));
         }
         break;
       case "group":
@@ -1085,19 +1085,21 @@ function applyPathTargetedConstraints(schema, pathConstraints, ctx, typeNode) {
     schema.items = applyPathTargetedConstraints(schema.items, pathConstraints, ctx, nestedType);
     return schema;
   }
-  const byTarget = /* @__PURE__ */ new Map();
-  for (const c of pathConstraints) {
-    const target = c.path?.segments[0];
-    if (!target) continue;
-    const group = byTarget.get(target) ?? [];
-    group.push(c);
-    byTarget.set(target, group);
-  }
-  const propertyOverrides = {};
-  for (const [target, constraints] of byTarget) {
-    const subSchema = {};
-    applyConstraints(subSchema, constraints, ctx);
-    propertyOverrides[resolveSerializedPropertyName(target, typeNode, ctx)] = subSchema;
+  const propertyOverrides = buildPropertyOverrides(pathConstraints, typeNode, ctx);
+  const nullableValueBranch = getNullableUnionValueSchema(schema);
+  if (nullableValueBranch !== void 0) {
+    const updatedNullableValueBranch = applyPathTargetedConstraints(
+      nullableValueBranch,
+      pathConstraints,
+      ctx,
+      resolveTraversableTypeNode(typeNode, ctx)
+    );
+    if (schema.oneOf !== void 0) {
+      schema.oneOf = schema.oneOf.map(
+        (branch) => branch === nullableValueBranch ? updatedNullableValueBranch : branch
+      );
+    }
+    return schema;
   }
   if (schema.$ref) {
     const { $ref, ...rest } = schema;
@@ -1112,7 +1114,7 @@ function applyPathTargetedConstraints(schema, pathConstraints, ctx, typeNode) {
     const missingOverrides = {};
     for (const [target, overrideSchema] of Object.entries(propertyOverrides)) {
       if (schema.properties[target]) {
-        Object.assign(schema.properties[target], overrideSchema);
+        mergeSchemaOverride(schema.properties[target], overrideSchema);
       } else {
         missingOverrides[target] = overrideSchema;
       }
@@ -1186,7 +1188,7 @@ function generateObjectType(type, ctx) {
   const properties = {};
   const required = [];
   for (const prop of type.properties) {
-    const propertyName = getSerializedName(prop.name, prop.metadata);
+    const propertyName = getSerializedObjectPropertyName(prop);
     properties[propertyName] = generatePropertySchema(prop, ctx);
     if (!prop.optional) {
       required.push(propertyName);
@@ -1240,7 +1242,16 @@ function isNullableUnion(type) {
   return nullCount === 1;
 }
 function generateReferenceType(type, ctx) {
-  return { $ref: `#/$defs/${ctx.typeNameMap[type.name] ?? type.name}` };
+  return { $ref: `#/$defs/${getSerializedTypeName(type.name, ctx)}` };
+}
+function getSerializedFieldName(field) {
+  return getSerializedName(field.name, field.metadata);
+}
+function getSerializedObjectPropertyName(property) {
+  return getSerializedName(property.name, property.metadata);
+}
+function getSerializedTypeName(logicalName, ctx) {
+  return ctx.typeNameMap[logicalName] ?? logicalName;
 }
 function applyResolvedMetadata(schema, metadata) {
   const displayName = getDisplayName(metadata);
@@ -1251,17 +1262,148 @@ function applyResolvedMetadata(schema, metadata) {
 function resolveReferencedType(type, ctx) {
   return ctx.typeRegistry[type.name]?.type;
 }
+function dereferenceTypeNode(typeNode, ctx) {
+  if (typeNode?.kind !== "reference") {
+    return typeNode;
+  }
+  return resolveReferencedType(typeNode, ctx);
+}
+function unwrapNullableTypeNode(typeNode) {
+  if (typeNode?.kind !== "union" || !isNullableUnion(typeNode)) {
+    return typeNode;
+  }
+  return typeNode.members.find(
+    (member) => !(member.kind === "primitive" && member.primitiveKind === "null")
+  );
+}
+function resolveTraversableTypeNode(typeNode, ctx) {
+  const dereferenced = dereferenceTypeNode(typeNode, ctx);
+  const unwrapped = unwrapNullableTypeNode(dereferenced);
+  if (unwrapped !== dereferenced) {
+    return resolveTraversableTypeNode(unwrapped, ctx);
+  }
+  return dereferenced;
+}
 function resolveSerializedPropertyName(logicalName, typeNode, ctx) {
-  if (typeNode?.kind === "object") {
-    const property = typeNode.properties.find((candidate) => candidate.name === logicalName);
-    return property === void 0 ? logicalName : getSerializedName(property.name, property.metadata);
+  const effectiveType = resolveTraversableTypeNode(typeNode, ctx);
+  if (effectiveType?.kind === "array") {
+    return resolveSerializedPropertyName(logicalName, effectiveType.items, ctx);
   }
-  if (typeNode?.kind === "reference") {
-    const referencedType = resolveReferencedType(typeNode, ctx);
-    return referencedType === void 0 ? logicalName : resolveSerializedPropertyName(logicalName, referencedType, ctx);
+  if (effectiveType?.kind === "object") {
+    const property = effectiveType.properties.find((candidate) => candidate.name === logicalName);
+    return property === void 0 ? logicalName : getSerializedObjectPropertyName(property);
   }
   return logicalName;
 }
+function resolveTargetTypeNode(logicalName, typeNode, ctx) {
+  const effectiveType = resolveTraversableTypeNode(typeNode, ctx);
+  if (effectiveType?.kind === "array") {
+    return resolveTargetTypeNode(logicalName, effectiveType.items, ctx);
+  }
+  if (effectiveType?.kind !== "object") {
+    return void 0;
+  }
+  return effectiveType.properties.find((candidate) => candidate.name === logicalName)?.type;
+}
+function buildPropertyOverrides(pathConstraints, typeNode, ctx) {
+  const byTarget = /* @__PURE__ */ new Map();
+  for (const constraint of pathConstraints) {
+    const target = constraint.path?.segments[0];
+    if (!target) {
+      continue;
+    }
+    const grouped = byTarget.get(target) ?? [];
+    grouped.push(constraint);
+    byTarget.set(target, grouped);
+  }
+  const overrides = {};
+  for (const [target, constraints] of byTarget) {
+    overrides[resolveSerializedPropertyName(target, typeNode, ctx)] = buildPathOverrideSchema(
+      constraints.map(stripLeadingPathSegment),
+      resolveTargetTypeNode(target, typeNode, ctx),
+      ctx
+    );
+  }
+  return overrides;
+}
+function buildPathOverrideSchema(constraints, typeNode, ctx) {
+  const schema = {};
+  const directConstraints = [];
+  const nestedConstraints = [];
+  for (const constraint of constraints) {
+    if (constraint.path === void 0 || constraint.path.segments.length === 0) {
+      directConstraints.push(constraint);
+    } else {
+      nestedConstraints.push(constraint);
+    }
+  }
+  applyConstraints(schema, directConstraints, ctx);
+  if (nestedConstraints.length === 0) {
+    return schema;
+  }
+  const effectiveType = resolveTraversableTypeNode(typeNode, ctx);
+  if (effectiveType?.kind === "array") {
+    schema.items = buildPathOverrideSchema(nestedConstraints, effectiveType.items, ctx);
+    return schema;
+  }
+  schema.properties = buildPropertyOverrides(nestedConstraints, effectiveType, ctx);
+  return schema;
+}
+function mergeSchemaOverride(target, override) {
+  const nullableValueBranch = getNullableUnionValueSchema(target);
+  if (nullableValueBranch !== void 0) {
+    mergeSchemaOverride(nullableValueBranch, override);
+    return;
+  }
+  if (override.properties !== void 0) {
+    const mergedProperties = target.properties ?? {};
+    for (const [name, propertyOverride] of Object.entries(override.properties)) {
+      const existing = mergedProperties[name];
+      if (existing === void 0) {
+        mergedProperties[name] = propertyOverride;
+      } else {
+        mergeSchemaOverride(existing, propertyOverride);
+      }
+    }
+    target.properties = mergedProperties;
+  }
+  if (override.items !== void 0) {
+    if (target.items === void 0) {
+      target.items = override.items;
+    } else {
+      mergeSchemaOverride(target.items, override.items);
+    }
+  }
+  for (const [key, value] of Object.entries(override)) {
+    if (key === "properties" || key === "items") {
+      continue;
+    }
+    target[key] = value;
+  }
+}
+function stripLeadingPathSegment(constraint) {
+  const segments = constraint.path?.segments;
+  if (segments === void 0 || segments.length === 0) {
+    return constraint;
+  }
+  const [, ...rest] = segments;
+  if (rest.length === 0) {
+    const { path: _path, ...stripped } = constraint;
+    return stripped;
+  }
+  return {
+    ...constraint,
+    path: { segments: rest }
+  };
+}
+function getNullableUnionValueSchema(schema) {
+  if (schema.oneOf?.length !== 2) {
+    return void 0;
+  }
+  const valueSchema = schema.oneOf.find((branch) => branch.type !== "null");
+  const nullSchema = schema.oneOf.find((branch) => branch.type === "null");
+  return valueSchema !== void 0 && nullSchema !== void 0 ? valueSchema : void 0;
+}
 function generateDynamicType(type) {
   if (type.dynamicKind === "enum") {
     const schema = {
@@ -2845,6 +2987,27 @@ function resolveNodeMetadata(metadataPolicy, declarationKind, logicalName, node,
     makeMetadataContext("tsdoc", declarationKind, logicalName, buildContext)
   );
 }
+function analyzeDeclarationRootInfo(declaration, checker, file = "", extensionRegistry, metadataPolicy) {
+  const normalizedMetadataPolicy = normalizeMetadataPolicy(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,
+    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 name = classDecl.name?.text ?? "AnonymousClass";
@@ -3259,10 +3422,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;
   }
@@ -4221,14 +4381,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);
@@ -4876,6 +5061,362 @@ var init_class_schema = __esm({
   }
 });
 
+// src/static-build.ts
+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 ts6;
+var init_static_build = __esm({
+  "src/static-build.ts"() {
+    "use strict";
+    ts6 = __toESM(require("typescript"), 1);
+    init_program();
+  }
+});
+
+// src/generators/discovered-schema.ts
+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: import_internals5.IR_VERSION,
+      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,
+    normalizeMetadataPolicy(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 ts7, import_internals5;
+var init_discovered_schema = __esm({
+  "src/generators/discovered-schema.ts"() {
+    "use strict";
+    ts7 = __toESM(require("typescript"), 1);
+    init_class_analyzer();
+    init_class_schema();
+    init_ir_generator();
+    import_internals5 = require("@formspec/core/internals");
+    init_metadata();
+  }
+});
+
 // src/generators/mixed-authoring.ts
 function buildMixedAuthoringSchemas(options) {
   const { filePath, typeName, overlays, ...schemaOptions } = options;
@@ -5082,12 +5623,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
 });
@@ -5125,6 +5674,8 @@ var init_index = __esm({
     init_generator();
     init_generator2();
     init_class_schema();
+    init_static_build();
+    init_discovered_schema();
     init_mixed_authoring();
   }
 });