typia 13.0.1-dev.20260703.1 → 13.0.2

package/native/core/programmers/llm/LlmSchemaProgrammer.go

@@ -1,846 +1,902 @@
-package llm
-
-import (
-  "fmt"
-  "reflect"
-  "sort"
-  "strconv"
-  "strings"
-
-  shimast "github.com/microsoft/typescript-go/shim/ast"
-  shimprinter "github.com/microsoft/typescript-go/shim/printer"
-  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
-  nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
-  nativeiterate "github.com/samchon/typia/packages/typia/native/core/programmers/iterate"
-  nativejson "github.com/samchon/typia/packages/typia/native/core/programmers/json"
-  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
-)
-
-type llmSchemaProgrammerNamespace struct{}
-
-var LlmSchemaProgrammer = llmSchemaProgrammerNamespace{}
-
-type LlmSchemaProgrammer_IProps struct {
-  Context nativecontext.ITypiaContext
-  Modulo  *shimast.Node
-  Type    any
-  Name    *string
-  Init    *shimast.Node
-  Config  map[string]any
-}
-
-type LlmSchemaProgrammer_IOutput struct {
-  Schema map[string]any
-  Defs   map[string]any
-}
-
-type LlmSchemaProgrammer_IWriteProps struct {
-  Context  nativecontext.ITypiaContext
-  Metadata *schemametadata.MetadataSchema
-  Config   map[string]any
-}
-
-var llmSchemaProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
-func (llmSchemaProgrammerNamespace) Write(props LlmSchemaProgrammer_IWriteProps) *shimast.Node {
-  output := LlmSchemaProgrammer.WriteSchema(struct {
-    Metadata *schemametadata.MetadataSchema
-    Config   map[string]any
-  }{
-    Metadata: props.Metadata,
-    Config:   props.Config,
-  })
-  f := nativecontext.EmitFactoryOf(llmSchemaProgrammer_factory, props.Context.Emit)
-  schemaTypeNode := llmProgrammer_import_type(props.Context, nativecontext.ImportProgrammer_TypeProps{
-    File: "typia",
-    Name: "ILlmSchema",
-  })
-  schemaLiteral := f.NewAsExpression(
-    f.NewSatisfiesExpression(
-      nativefactories.LiteralFactory.Write(output.Schema, props.Context.Emit),
-      schemaTypeNode,
-    ),
-    schemaTypeNode,
-  )
-  if len(output.Defs) == 0 {
-    return schemaLiteral
-  }
-  recordType := llmSchemaProgrammer_record_type(schemaTypeNode, props.Context.Emit)
-  return f.NewArrowFunction(
-    nil,
-    nil,
-    f.NewNodeList([]*shimast.Node{
-      nativefactories.IdentifierFactory.Parameter("$defs", recordType, nil, props.Context.Emit),
-    }),
-    schemaTypeNode,
-    nil,
-    f.NewToken(shimast.KindEqualsGreaterThanToken),
-    f.NewBlock(f.NewNodeList([]*shimast.Node{
-      f.NewExpressionStatement(
-        f.NewCallExpression(
-          f.NewIdentifier("Object.assign"),
-          nil,
-          nil,
-          f.NewNodeList([]*shimast.Node{
-            f.NewIdentifier("$defs"),
-            f.NewAsExpression(
-              nativefactories.LiteralFactory.Write(output.Defs, props.Context.Emit),
-              llmSchemaProgrammer_record_type(schemaTypeNode, props.Context.Emit),
-            ),
-          }),
-          shimast.NodeFlagsNone,
-        ),
-      ),
-      f.NewReturnStatement(schemaLiteral),
-    }), true),
-  )
-}
-
-func llmSchemaProgrammer_record_type(schemaTypeNode *shimast.Node, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(llmSchemaProgrammer_factory, emit...)
-  return f.NewTypeReferenceNode(
-    f.NewIdentifier("Record"),
-    f.NewNodeList([]*shimast.Node{
-      nativefactories.TypeFactory.Keyword("string", emit...),
-      schemaTypeNode,
-    }),
-  )
-}
-
-func (llmSchemaProgrammerNamespace) WriteSchema(props struct {
-  Metadata *schemametadata.MetadataSchema
-  Config   map[string]any
-}) LlmSchemaProgrammer_IOutput {
-  collection := nativejson.JsonSchemasProgrammer.WriteSchemas(struct {
-    Version   string
-    Metadatas []*schemametadata.MetadataSchema
-  }{
-    Version:   "3.1",
-    Metadatas: []*schemametadata.MetadataSchema{props.Metadata},
-  })
-  defs := map[string]any{}
-  schema := map[string]any{}
-  if len(collection.Schemas) != 0 {
-    schema = llmSchemaProgrammer_convert_schema_config(collection.Schemas[0], collection.Components, defs, props.Config)
-  }
-  return LlmSchemaProgrammer_IOutput{
-    Defs:   defs,
-    Schema: schema,
-  }
-}
-
-func (llmSchemaProgrammerNamespace) Validate(props struct {
-  Config   map[string]any
-  Metadata *schemametadata.MetadataSchema
-  Explore  nativefactories.MetadataFactory_IExplore
-}) []string {
-  output := []string{}
-  strict, _ := props.Config["strict"].(bool)
-  if strict {
-    for _, object := range props.Metadata.Objects {
-      for _, property := range object.Type.Properties {
-        if property.Key.IsSoleLiteral() == false && property.Value.Size() != 0 {
-          output = append(output, "Strict mode does not allow dynamic property in object.")
-          break
-        }
-      }
-    }
-    for _, object := range props.Metadata.Objects {
-      for _, property := range object.Type.Properties {
-        if property.Value.IsRequired() == false {
-          output = append(output, "Strict mode does not support optional property in object.")
-          break
-        }
-      }
-    }
-    // OpenAI strict structured outputs cannot express the `not` keyword the
-    // exclude tag compiles to (supported subset: types, enum, anyOf, $defs).
-    excluded := false
-    scan := func(matrix [][]schemametadata.IMetadataTypeTag) {
-      for _, row := range matrix {
-        for _, tag := range row {
-          if tag.Kind == "exclude" {
-            excluded = true
-          }
-        }
-      }
-    }
-    for _, atomic := range props.Metadata.Atomics {
-      scan(atomic.Tags)
-    }
-    for _, template := range props.Metadata.Templates {
-      scan(template.Tags)
-    }
-    if excluded {
-      output = append(output, "Strict mode does not support exclude type tag.")
-    }
-  }
-  if schemametadata.MetadataSchema_hasBigint(props.Metadata) {
-    output = append(output, "LLM schema does not support bigint type.")
-  }
-  if len(props.Metadata.Tuples) != 0 {
-    output = append(output, "LLM schema does not support tuple type.")
-  }
-  for _, array := range props.Metadata.Arrays {
-    if array.Type.Value.IsRequired() == false {
-      output = append(output, "LLM schema does not support undefined type in array.")
-      break
-    }
-  }
-  if len(props.Metadata.Maps) != 0 {
-    output = append(output, "LLM schema does not support Map type.")
-  }
-  if len(props.Metadata.Sets) != 0 {
-    output = append(output, "LLM schema does not support Set type.")
-  }
-  for _, native := range props.Metadata.Natives {
-    if native.Name == "BigInt" {
-      continue
-    }
-    if nativehelpers.AtomicPredicator.Native(native.Name) == false &&
-      native.Name != "Date" &&
-      native.Name != "Blob" &&
-      native.Name != "File" {
-      output = append(output, "LLM schema does not support "+native.Name+" type.")
-    }
-  }
-  return output
-}
-
-func llmSchemaProgrammer_size(metadata *schemametadata.MetadataSchema) int {
-  total := 0
-  if metadata.Escaped != nil {
-    total += llmSchemaProgrammer_size(metadata.Escaped.Returns)
-  }
-  total += len(metadata.Aliases) + len(metadata.Objects) + len(metadata.Arrays) + len(metadata.Tuples)
-  if len(metadata.Maps) != 0 {
-    total++
-  }
-  if len(metadata.Sets) != 0 {
-    total++
-  }
-  for _, atomic := range metadata.Atomics {
-    if atomic.Type == "boolean" {
-      total += len(nativeiterate.Json_schema_boolean_export(atomic))
-    } else if atomic.Type == "bigint" {
-      total += len(nativeiterate.Json_schema_bigint_export(atomic))
-    } else if atomic.Type == "number" {
-      total += len(nativeiterate.Json_schema_number_export(atomic))
-    } else {
-      total += len(nativeiterate.Json_schema_string_export(atomic))
-    }
-  }
-  for _, constant := range metadata.Constants {
-    found := false
-    for _, atomic := range metadata.Atomics {
-      if atomic.Type == constant.Type {
-        found = true
-        break
-      }
-    }
-    if found == false {
-      total++
-    }
-  }
-  total += len(metadata.Templates)
-  components := &nativeiterate.OpenApi_IComponents{Schemas: map[string]nativeiterate.JsonSchema{}}
-  for _, native := range metadata.Natives {
-    found := false
-    for _, atomic := range metadata.Atomics {
-      if atomic.Type == native.Name {
-        found = true
-        break
-      }
-    }
-    for _, constant := range metadata.Constants {
-      if constant.Type == native.Name {
-        found = true
-        break
-      }
-    }
-    if found == false {
-      total += len(nativeiterate.Json_schema_native_export(nativeiterate.Json_schema_native_export_props{
-        Components: components,
-        Native:     native,
-      }))
-    }
-  }
-  return total
-}
-
-func llmSchemaProgrammer_convert_schema(schema nativeiterate.JsonSchema, components *nativeiterate.OpenApi_IComponents, defs map[string]any) map[string]any {
-  return llmSchemaProgrammer_convert_schema_config(schema, components, defs, nil)
-}
-
-func llmSchemaProgrammer_convert_schema_config(schema nativeiterate.JsonSchema, components *nativeiterate.OpenApi_IComponents, defs map[string]any, config map[string]any) map[string]any {
-  strict := llmSchemaProgrammer_strict(config)
-  attribute := llmSchemaProgrammer_attribute(schema)
-  union := []map[string]any{}
-
-  insertConstant := func(value any) {
-    typ := llmSchemaProgrammer_constant_type(value)
-    for _, elem := range union {
-      if elem["type"] == typ {
-        elem["enum"] = append(llmSchemaProgrammer_array(elem["enum"]), value)
-        return
-      }
-    }
-    union = append(union, map[string]any{
-      "type": typ,
-      "enum": []any{value},
-    })
-  }
-  var visitConstant func(nativeiterate.JsonSchema)
-  visitConstant = func(input nativeiterate.JsonSchema) {
-    if value, ok := input["const"]; ok {
-      insertConstant(value)
-      return
-    }
-    for _, elem := range llmSchemaProgrammer_schema_array(input["oneOf"]) {
-      visitConstant(elem)
-    }
-  }
-
-  var visit func(nativeiterate.JsonSchema)
-  visit = func(input nativeiterate.JsonSchema) {
-    if oneOf := llmSchemaProgrammer_schema_array(input["oneOf"]); len(oneOf) != 0 {
-      for _, elem := range oneOf {
-        visit(elem)
-      }
-      return
-    }
-    if ref, ok := input["$ref"].(string); ok {
-      key := llmSchemaProgrammer_ref_key(ref)
-      if _, exists := defs[key]; exists == false {
-        defs[key] = map[string]any{}
-        if target, found := llmSchemaProgrammer_component(components, key); found {
-          defs[key] = llmSchemaProgrammer_convert_schema_config(target, components, defs, config)
-        }
-      }
-      union = append(union, map[string]any{"$ref": "#/$defs/" + key})
-      return
-    }
-    if input["type"] == "object" {
-      properties := map[string]any{}
-      if raw, ok := llmSchemaProgrammer_schema_map(input["properties"]); ok {
-        keys := make([]string, 0, len(raw))
-        for key := range raw {
-          keys = append(keys, key)
-        }
-        sort.Strings(keys)
-        for _, key := range keys {
-          if value, ok := llmSchemaProgrammer_schema_from_any(raw[key]); ok {
-            properties[key] = llmSchemaProgrammer_convert_schema_config(value, components, defs, config)
-          }
-        }
-      }
-      output := llmSchemaProgrammer_clone(input)
-      output["properties"] = properties
-      if additional, ok := llmSchemaProgrammer_schema_from_any(input["additionalProperties"]); ok {
-        output["additionalProperties"] = llmSchemaProgrammer_convert_schema_config(additional, components, defs, config)
-      } else if strict {
-        output["additionalProperties"] = false
-      } else if value, ok := input["additionalProperties"]; ok {
-        output["additionalProperties"] = value
-      }
-      if _, ok := input["required"]; ok {
-        output["required"] = input["required"]
-      } else {
-        output["required"] = []any{}
-      }
-      if strict {
-        if description := llmSchemaProgrammer_json_descriptor_take(input); description != nil {
-          output["description"] = *description
-        } else {
-          delete(output, "description")
-        }
-      }
-      union = append(union, output)
-      return
-    }
-    if input["type"] == "array" {
-      output := llmSchemaProgrammer_clone(input)
-      if items, ok := llmSchemaProgrammer_schema_from_any(input["items"]); ok {
-        output["items"] = llmSchemaProgrammer_convert_schema_config(items, components, defs, config)
-      }
-      if strict {
-        output = llmSchemaProgrammer_shift_array(output)
-      }
-      union = append(union, output)
-      return
-    }
-    if input["type"] == "string" {
-      output := llmSchemaProgrammer_clone(input)
-      if strict {
-        output = llmSchemaProgrammer_shift_string(output)
-      }
-      union = append(union, output)
-      return
-    }
-    if input["type"] == "number" || input["type"] == "integer" {
-      output := llmSchemaProgrammer_clone(input)
-      if strict {
-        output = llmSchemaProgrammer_shift_numeric(output)
-      }
-      union = append(union, output)
-      return
-    }
-    if _, ok := input["const"]; ok {
-      return
-    }
-    union = append(union, llmSchemaProgrammer_clone(input))
-  }
-
-  visitConstant(schema)
-  visit(schema)
-
-  if len(union) == 0 {
-    output := llmSchemaProgrammer_clone(attribute)
-    output["type"] = nil
-    return output
-  }
-  if len(union) == 1 {
-    output := llmSchemaProgrammer_merge(attribute, union[0])
-    if strict && llmSchemaProgrammer_is_reference(union[0]) {
-      delete(output, "description")
-    } else if description, ok := union[0]["description"]; ok {
-      output["description"] = description
-    } else if description, ok := attribute["description"]; ok {
-      output["description"] = description
-    }
-    return output
-  }
-  anyOf := make([]any, 0, len(union))
-  for _, elem := range union {
-    output := llmSchemaProgrammer_clone(elem)
-    if strict && llmSchemaProgrammer_is_reference(elem) {
-      delete(output, "description")
-    }
-    anyOf = append(anyOf, output)
-  }
-  output := llmSchemaProgrammer_clone(attribute)
-  output["anyOf"] = anyOf
-  if x := llmSchemaProgrammer_discriminator(schema, union); x != nil {
-    output["x-discriminator"] = x
-  }
-  return output
-}
-
-func llmSchemaProgrammer_strict(config map[string]any) bool {
-  strict, _ := config["strict"].(bool)
-  return strict
-}
-
-func llmSchemaProgrammer_attribute(schema nativeiterate.JsonSchema) map[string]any {
-  output := map[string]any{}
-  for _, key := range []string{
-    "title",
-    "description",
-    "deprecated",
-    "readOnly",
-    "writeOnly",
-    "example",
-    "examples",
-  } {
-    if value, ok := schema[key]; ok && llmSchemaProgrammer_is_nil_like(value) == false {
-      output[key] = value
-    }
-  }
-  for key, value := range schema {
-    if strings.HasPrefix(key, "x-") && llmSchemaProgrammer_is_nil_like(value) == false {
-      output[key] = value
-    }
-  }
-  return output
-}
-
-func llmSchemaProgrammer_clone(input map[string]any) map[string]any {
-  output := map[string]any{}
-  for key, value := range input {
-    if llmSchemaProgrammer_is_nil_like(value) {
-      continue
-    }
-    output[key] = value
-  }
-  return output
-}
-
-func llmSchemaProgrammer_is_nil_like(value any) bool {
-  if value == nil {
-    return true
-  }
-  reflected := reflect.ValueOf(value)
-  switch reflected.Kind() {
-  case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Pointer, reflect.Slice:
-    return reflected.IsNil()
-  default:
-    return false
-  }
-}
-
-func llmSchemaProgrammer_merge(left map[string]any, right map[string]any) map[string]any {
-  output := llmSchemaProgrammer_clone(left)
-  for key, value := range right {
-    output[key] = value
-  }
-  return output
-}
-
-func llmSchemaProgrammer_array(value any) []any {
-  switch v := value.(type) {
-  case []any:
-    return append([]any{}, v...)
-  case []string:
-    output := make([]any, 0, len(v))
-    for _, elem := range v {
-      output = append(output, elem)
-    }
-    return output
-  case []nativeiterate.JsonSchema:
-    output := make([]any, 0, len(v))
-    for _, elem := range v {
-      output = append(output, elem)
-    }
-    return output
-  default:
-    return []any{}
-  }
-}
-
-func llmSchemaProgrammer_schema_array(value any) []nativeiterate.JsonSchema {
-  switch v := value.(type) {
-  case []nativeiterate.JsonSchema:
-    return append([]nativeiterate.JsonSchema{}, v...)
-  case []map[string]any:
-    output := make([]nativeiterate.JsonSchema, 0, len(v))
-    for _, elem := range v {
-      output = append(output, nativeiterate.JsonSchema(elem))
-    }
-    return output
-  case []any:
-    output := make([]nativeiterate.JsonSchema, 0, len(v))
-    for _, elem := range v {
-      if schema, ok := llmSchemaProgrammer_schema_from_any(elem); ok {
-        output = append(output, schema)
-      }
-    }
-    return output
-  default:
-    return nil
-  }
-}
-
-func llmSchemaProgrammer_schema_map(value any) (map[string]any, bool) {
-  switch v := value.(type) {
-  case nativeiterate.JsonSchema:
-    output := map[string]any{}
-    for key, value := range v {
-      output[key] = value
-    }
-    return output, true
-  case map[string]any:
-    return v, true
-  default:
-    return nil, false
-  }
-}
-
-func llmSchemaProgrammer_schema_from_any(value any) (nativeiterate.JsonSchema, bool) {
-  switch v := value.(type) {
-  case nativeiterate.JsonSchema:
-    return v, true
-  case map[string]any:
-    return nativeiterate.JsonSchema(v), true
-  default:
-    return nil, false
-  }
-}
-
-func llmSchemaProgrammer_constant_type(value any) string {
-  reflected := reflect.ValueOf(value)
-  if reflected.IsValid() == false {
-    return fmt.Sprintf("%T", value)
-  }
-  switch reflected.Kind() {
-  case reflect.Bool:
-    return "boolean"
-  case reflect.String:
-    return "string"
-  case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
-    reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
-    reflect.Float32, reflect.Float64:
-    return "number"
-  default:
-    return fmt.Sprintf("%T", value)
-  }
-}
-
-func llmSchemaProgrammer_ref_key(ref string) string {
-  if strings.Contains(ref, "#/components/schemas/") {
-    return strings.Split(ref, "#/components/schemas/")[1]
-  }
-  index := strings.LastIndex(ref, "/")
-  if index == -1 {
-    return ref
-  }
-  return ref[index+1:]
-}
-
-func llmSchemaProgrammer_component(components *nativeiterate.OpenApi_IComponents, key string) (nativeiterate.JsonSchema, bool) {
-  if components == nil || components.Schemas == nil {
-    return nil, false
-  }
-  schema, ok := components.Schemas[key]
-  return schema, ok
-}
-
-func llmSchemaProgrammer_is_reference(schema map[string]any) bool {
-  _, ok := schema["$ref"].(string)
-  return ok
-}
-
-func llmSchemaProgrammer_is_null(schema map[string]any) bool {
-  return schema["type"] == "null"
-}
-
-func llmSchemaProgrammer_discriminator(schema nativeiterate.JsonSchema, union []map[string]any) map[string]any {
-  discriminator, ok := llmSchemaProgrammer_schema_map(schema["discriminator"])
-  if ok == false || len(llmSchemaProgrammer_schema_array(schema["oneOf"])) != len(union) {
-    return nil
-  }
-  for _, elem := range union {
-    if llmSchemaProgrammer_is_reference(elem) == false && llmSchemaProgrammer_is_null(elem) == false {
-      return nil
-    }
-  }
-  output := map[string]any{}
-  if propertyName, ok := discriminator["propertyName"].(string); ok {
-    output["propertyName"] = propertyName
-  }
-  if rawMapping, ok := llmSchemaProgrammer_schema_map(discriminator["mapping"]); ok {
-    mapping := map[string]any{}
-    for key, value := range rawMapping {
-      mapping[key] = "#/$defs/" + llmSchemaProgrammer_ref_key(fmt.Sprint(value))
-    }
-    output["mapping"] = mapping
-  }
-  if len(output) == 0 {
-    return nil
-  }
-  return output
-}
-
-func llmSchemaProgrammer_shift_array(schema map[string]any) map[string]any {
-  output := llmSchemaProgrammer_clone(schema)
-  tags := []string{}
-  if value, ok := output["minItems"]; ok {
-    tags = append(tags, "@minItems "+fmt.Sprint(value))
-    delete(output, "minItems")
-  }
-  if value, ok := output["maxItems"]; ok {
-    tags = append(tags, "@maxItems "+fmt.Sprint(value))
-    delete(output, "maxItems")
-  }
-  if value, ok := output["uniqueItems"].(bool); ok {
-    if value {
-      tags = append(tags, "@uniqueItems")
-    }
-    delete(output, "uniqueItems")
-  }
-  llmSchemaProgrammer_write_tag_with_description(output, tags)
-  return output
-}
-
-func llmSchemaProgrammer_shift_numeric(schema map[string]any) map[string]any {
-  output := llmSchemaProgrammer_clone(schema)
-  llmSchemaProgrammer_emend_exclusive(output)
-  tags := []string{}
-  for _, key := range []string{"minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf"} {
-    if value, ok := output[key]; ok {
-      tags = append(tags, "@"+key+" "+fmt.Sprint(value))
-      delete(output, key)
-    }
-  }
-  llmSchemaProgrammer_write_tag_with_description(output, tags)
-  delete(output, "default")
-  return output
-}
-
-func llmSchemaProgrammer_shift_string(schema map[string]any) map[string]any {
-  output := llmSchemaProgrammer_clone(schema)
-  tags := []string{}
-  for _, key := range []string{"minLength", "maxLength", "format", "pattern", "contentMediaType", "default"} {
-    if value, ok := output[key]; ok {
-      tags = append(tags, "@"+key+" "+fmt.Sprint(value))
-      delete(output, key)
-    }
-  }
-  llmSchemaProgrammer_write_tag_with_description(output, tags)
-  return output
-}
-
-func llmSchemaProgrammer_write_tag_with_description(schema map[string]any, tags []string) {
-  if len(tags) == 0 {
-    return
-  }
-  lines := []string{}
-  if description, ok := schema["description"].(string); ok && len(description) != 0 {
-    lines = append(lines, description, "\n")
-  }
-  lines = append(lines, tags...)
-  schema["description"] = strings.Join(lines, "\n")
-}
-
-func llmSchemaProgrammer_emend_exclusive(schema map[string]any) {
-  if exclusiveMinimum, ok := llmSchemaProgrammer_number(schema["exclusiveMinimum"]); ok {
-    if minimum, found := llmSchemaProgrammer_number(schema["minimum"]); found {
-      if minimum > exclusiveMinimum {
-        schema["minimum"] = minimum
-        delete(schema, "exclusiveMinimum")
-      } else {
-        schema["exclusiveMinimum"] = exclusiveMinimum
-        delete(schema, "minimum")
-      }
-    }
-  }
-  if exclusiveMaximum, ok := llmSchemaProgrammer_number(schema["exclusiveMaximum"]); ok {
-    if maximum, found := llmSchemaProgrammer_number(schema["maximum"]); found {
-      if maximum < exclusiveMaximum {
-        schema["maximum"] = maximum
-        delete(schema, "exclusiveMaximum")
-      } else {
-        schema["exclusiveMaximum"] = exclusiveMaximum
-        delete(schema, "maximum")
-      }
-    }
-  }
-}
-
-func llmSchemaProgrammer_number(value any) (float64, bool) {
-  reflected := reflect.ValueOf(value)
-  if reflected.IsValid() == false {
-    return 0, false
-  }
-  switch reflected.Kind() {
-  case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-    return float64(reflected.Int()), true
-  case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-    return float64(reflected.Uint()), true
-  case reflect.Float32, reflect.Float64:
-    return reflected.Convert(reflect.TypeOf(float64(0))).Float(), true
-  default:
-    return 0, false
-  }
-}
-
-func llmSchemaProgrammer_json_descriptor_take(schema nativeiterate.JsonSchema) *string {
-  parts := []string{}
-  if description, ok := schema["description"].(string); ok && len(description) != 0 {
-    parts = append(parts, description)
-  }
-  properties, ok := llmSchemaProgrammer_schema_map(schema["properties"])
-  if ok {
-    keys := make([]string, 0, len(properties))
-    for key := range properties {
-      keys = append(keys, key)
-    }
-    sort.Strings(keys)
-    for _, key := range keys {
-      value, ok := llmSchemaProgrammer_schema_from_any(properties[key])
-      if ok == false || llmSchemaProgrammer_is_reference(value) == false {
-        continue
-      }
-      description, ok := value["description"].(string)
-      if ok == false || len(description) == 0 {
-        continue
-      }
-      name := key
-      if llmSchemaProgrammer_is_variable_name(key) == false {
-        name = strconv.Quote(key)
-      }
-      parts = append(parts, "### Description of {@link "+name+"} property:\n\n"+llmSchemaProgrammer_quote_description(description))
-    }
-  }
-  if len(parts) == 0 {
-    return nil
-  }
-  output := strings.Join(parts, "\n\n")
-  return &output
-}
-
-func llmSchemaProgrammer_quote_description(description string) string {
-  lines := strings.Split(description, "\n")
-  for i, line := range lines {
-    lines[i] = "> " + line
-  }
-  return strings.Join(lines, "\n")
-}
-
-func llmSchemaProgrammer_is_variable_name(str string) bool {
-  if len(str) == 0 {
-    return false
-  }
-  for i, r := range str {
-    if i == 0 {
-      if (r >= 'A' && r <= 'Z') || (r >= 'a' && r <= 'z') || r == '_' || r == '$' {
-        continue
-      }
-      return false
-    }
-    if (r >= 'A' && r <= 'Z') || (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') || r == '_' || r == '$' {
-      continue
-    }
-    return false
-  }
-  return true
-}
-
-func llmProgrammer_internal(context nativecontext.ITypiaContext, name string) *shimast.Node {
-  if importer := context.Importer; importer != nil {
-    return importer.Internal(name)
-  }
-  f := nativecontext.EmitFactoryOf(llmSchemaProgrammer_factory, context.Emit)
-  return f.NewIdentifier(name)
-}
-
-func llmProgrammer_import_type(context nativecontext.ITypiaContext, props nativecontext.ImportProgrammer_TypeProps) *shimast.Node {
-  if importer := context.Importer; importer != nil {
-    return importer.Type(props)
-  }
-  f := nativecontext.EmitFactoryOf(llmSchemaProgrammer_factory, context.Emit)
-  if str, ok := props.Name.(string); ok {
-    return f.NewTypeReferenceNode(f.NewIdentifier(str), f.NewNodeList(props.Arguments))
-  }
-  return props.Name.(*shimast.Node)
-}
-
-func llmProgrammer_type_reference(name string, emit ...*shimprinter.EmitContext) *shimast.Node {
-  if name == "" {
-    name = "unknown"
-  }
-  f := nativecontext.EmitFactoryOf(llmSchemaProgrammer_factory, emit...)
-  return f.NewTypeReferenceNode(f.NewIdentifier(name), nil)
-}
-
-func llmProgrammer_method_text(modulo *shimast.Node) string {
-  return nativehelpers.ModuloMethodText(modulo)
-}
-
-func llmProgrammer_concat_description(summary *string, description *string) *string {
-  if summary == nil || len(*summary) == 0 || description == nil || len(*description) == 0 {
-    if summary != nil && len(*summary) != 0 {
-      return summary
-    }
-    return description
-  }
-  head := *summary
-  if strings.HasSuffix(head, ".") {
-    head = head[:len(head)-1]
-  }
-  if strings.HasPrefix(*description, head) {
-    return description
-  }
-  out := head + ".\n\n" + *description
-  return &out
-}
+package llm
+
+import (
+  "fmt"
+  "reflect"
+  "sort"
+  "strconv"
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimprinter "github.com/microsoft/typescript-go/shim/printer"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+  nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
+  nativeiterate "github.com/samchon/typia/packages/typia/native/core/programmers/iterate"
+  nativejson "github.com/samchon/typia/packages/typia/native/core/programmers/json"
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+type llmSchemaProgrammerNamespace struct{}
+
+var LlmSchemaProgrammer = llmSchemaProgrammerNamespace{}
+
+type LlmSchemaProgrammer_IProps struct {
+  Context nativecontext.ITypiaContext
+  Modulo  *shimast.Node
+  Type    any
+  Name    *string
+  Init    *shimast.Node
+  Config  map[string]any
+}
+
+type LlmSchemaProgrammer_IOutput struct {
+  Schema map[string]any
+  Defs   map[string]any
+}
+
+type LlmSchemaProgrammer_IWriteProps struct {
+  Context  nativecontext.ITypiaContext
+  Metadata *schemametadata.MetadataSchema
+  Config   map[string]any
+}
+
+var llmSchemaProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+
+func (llmSchemaProgrammerNamespace) Write(props LlmSchemaProgrammer_IWriteProps) *shimast.Node {
+  output := LlmSchemaProgrammer.WriteSchema(struct {
+    Metadata *schemametadata.MetadataSchema
+    Config   map[string]any
+  }{
+    Metadata: props.Metadata,
+    Config:   props.Config,
+  })
+  f := nativecontext.EmitFactoryOf(llmSchemaProgrammer_factory, props.Context.Emit)
+  schemaTypeNode := llmProgrammer_import_type(props.Context, nativecontext.ImportProgrammer_TypeProps{
+    File: "typia",
+    Name: "ILlmSchema",
+  })
+  schemaLiteral := f.NewAsExpression(
+    f.NewSatisfiesExpression(
+      nativefactories.LiteralFactory.Write(output.Schema, props.Context.Emit),
+      schemaTypeNode,
+    ),
+    schemaTypeNode,
+  )
+  if len(output.Defs) == 0 {
+    return schemaLiteral
+  }
+  recordType := llmSchemaProgrammer_record_type(schemaTypeNode, props.Context.Emit)
+  return f.NewArrowFunction(
+    nil,
+    nil,
+    f.NewNodeList([]*shimast.Node{
+      nativefactories.IdentifierFactory.Parameter("$defs", recordType, nil, props.Context.Emit),
+    }),
+    schemaTypeNode,
+    nil,
+    f.NewToken(shimast.KindEqualsGreaterThanToken),
+    f.NewBlock(f.NewNodeList([]*shimast.Node{
+      f.NewExpressionStatement(
+        f.NewCallExpression(
+          f.NewIdentifier("Object.assign"),
+          nil,
+          nil,
+          f.NewNodeList([]*shimast.Node{
+            f.NewIdentifier("$defs"),
+            f.NewAsExpression(
+              nativefactories.LiteralFactory.Write(output.Defs, props.Context.Emit),
+              llmSchemaProgrammer_record_type(schemaTypeNode, props.Context.Emit),
+            ),
+          }),
+          shimast.NodeFlagsNone,
+        ),
+      ),
+      f.NewReturnStatement(schemaLiteral),
+    }), true),
+  )
+}
+
+func llmSchemaProgrammer_record_type(schemaTypeNode *shimast.Node, emit ...*shimprinter.EmitContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(llmSchemaProgrammer_factory, emit...)
+  return f.NewTypeReferenceNode(
+    f.NewIdentifier("Record"),
+    f.NewNodeList([]*shimast.Node{
+      nativefactories.TypeFactory.Keyword("string", emit...),
+      schemaTypeNode,
+    }),
+  )
+}
+
+func (llmSchemaProgrammerNamespace) WriteSchema(props struct {
+  Metadata *schemametadata.MetadataSchema
+  Config   map[string]any
+}) LlmSchemaProgrammer_IOutput {
+  collection := nativejson.JsonSchemasProgrammer.WriteSchemas(struct {
+    Version   string
+    Metadatas []*schemametadata.MetadataSchema
+  }{
+    Version:   "3.1",
+    Metadatas: []*schemametadata.MetadataSchema{props.Metadata},
+  })
+  defs := map[string]any{}
+  schema := map[string]any{}
+  if len(collection.Schemas) != 0 {
+    schema = llmSchemaProgrammer_convert_schema_config(collection.Schemas[0], collection.Components, defs, props.Config)
+  }
+  return LlmSchemaProgrammer_IOutput{
+    Defs:   defs,
+    Schema: schema,
+  }
+}
+
+func (llmSchemaProgrammerNamespace) Validate(props struct {
+  Config   map[string]any
+  Metadata *schemametadata.MetadataSchema
+  Explore  nativefactories.MetadataFactory_IExplore
+}) []string {
+  output := []string{}
+  strict, _ := props.Config["strict"].(bool)
+  if strict {
+    for _, object := range props.Metadata.Objects {
+      for _, property := range object.Type.Properties {
+        if property.Key.IsSoleLiteral() == false && property.Value.Size() != 0 {
+          output = append(output, "Strict mode does not allow dynamic property in object.")
+          break
+        }
+      }
+    }
+    for _, object := range props.Metadata.Objects {
+      for _, property := range object.Type.Properties {
+        if property.Value.IsRequired() == false {
+          output = append(output, "Strict mode does not support optional property in object.")
+          break
+        }
+      }
+    }
+    // OpenAI strict structured outputs cannot express the `not` keyword the
+    // exclude tag compiles to (supported subset: types, enum, anyOf, $defs).
+    excluded := false
+    scan := func(matrix [][]schemametadata.IMetadataTypeTag) {
+      for _, row := range matrix {
+        for _, tag := range row {
+          if tag.Kind == "exclude" {
+            excluded = true
+          }
+        }
+      }
+    }
+    for _, atomic := range props.Metadata.Atomics {
+      scan(atomic.Tags)
+    }
+    for _, template := range props.Metadata.Templates {
+      scan(template.Tags)
+    }
+    if excluded {
+      output = append(output, "Strict mode does not support exclude type tag.")
+    }
+  }
+  if schemametadata.MetadataSchema_hasBigint(props.Metadata) {
+    output = append(output, "LLM schema does not support bigint type.")
+  }
+  if len(props.Metadata.Tuples) != 0 {
+    output = append(output, "LLM schema does not support tuple type.")
+  }
+  for _, array := range props.Metadata.Arrays {
+    if array.Type.Value.IsRequired() == false {
+      output = append(output, "LLM schema does not support undefined type in array.")
+      break
+    }
+  }
+  if len(props.Metadata.Maps) != 0 {
+    output = append(output, "LLM schema does not support Map type.")
+  }
+  if len(props.Metadata.Sets) != 0 {
+    output = append(output, "LLM schema does not support Set type.")
+  }
+  for _, native := range props.Metadata.Natives {
+    if native.Name == "BigInt" {
+      continue
+    }
+    if nativehelpers.AtomicPredicator.Native(native.Name) == false &&
+      native.Name != "Date" &&
+      native.Name != "Blob" &&
+      native.Name != "File" {
+      output = append(output, "LLM schema does not support "+native.Name+" type.")
+    }
+  }
+  return output
+}
+
+func llmSchemaProgrammer_size(metadata *schemametadata.MetadataSchema) int {
+  total := 0
+  if metadata.Escaped != nil {
+    total += llmSchemaProgrammer_size(metadata.Escaped.Returns)
+  }
+  total += len(metadata.Aliases) + len(metadata.Objects) + len(metadata.Arrays) + len(metadata.Tuples)
+  if len(metadata.Maps) != 0 {
+    total++
+  }
+  if len(metadata.Sets) != 0 {
+    total++
+  }
+  for _, atomic := range metadata.Atomics {
+    if atomic.Type == "boolean" {
+      total += len(nativeiterate.Json_schema_boolean_export(atomic))
+    } else if atomic.Type == "bigint" {
+      total += len(nativeiterate.Json_schema_bigint_export(atomic))
+    } else if atomic.Type == "number" {
+      total += len(nativeiterate.Json_schema_number_export(atomic))
+    } else {
+      total += len(nativeiterate.Json_schema_string_export(atomic))
+    }
+  }
+  for _, constant := range metadata.Constants {
+    found := false
+    for _, atomic := range metadata.Atomics {
+      if atomic.Type == constant.Type {
+        found = true
+        break
+      }
+    }
+    if found == false {
+      total++
+    }
+  }
+  total += len(metadata.Templates)
+  components := &nativeiterate.OpenApi_IComponents{Schemas: map[string]nativeiterate.JsonSchema{}}
+  for _, native := range metadata.Natives {
+    found := false
+    for _, atomic := range metadata.Atomics {
+      if atomic.Type == native.Name {
+        found = true
+        break
+      }
+    }
+    for _, constant := range metadata.Constants {
+      if constant.Type == native.Name {
+        found = true
+        break
+      }
+    }
+    if found == false {
+      total += len(nativeiterate.Json_schema_native_export(nativeiterate.Json_schema_native_export_props{
+        Components: components,
+        Native:     native,
+      }))
+    }
+  }
+  return total
+}
+
+func llmSchemaProgrammer_convert_schema(schema nativeiterate.JsonSchema, components *nativeiterate.OpenApi_IComponents, defs map[string]any) map[string]any {
+  return llmSchemaProgrammer_convert_schema_config(schema, components, defs, nil)
+}
+
+func llmSchemaProgrammer_convert_schema_config(schema nativeiterate.JsonSchema, components *nativeiterate.OpenApi_IComponents, defs map[string]any, config map[string]any) map[string]any {
+  strict := llmSchemaProgrammer_strict(config)
+  attribute := llmSchemaProgrammer_attribute(schema)
+  union := []map[string]any{}
+
+  insertConstant := func(value any) {
+    typ := llmSchemaProgrammer_constant_type(value)
+    for _, elem := range union {
+      if elem["type"] == typ {
+        elem["enum"] = append(llmSchemaProgrammer_array(elem["enum"]), value)
+        return
+      }
+    }
+    union = append(union, map[string]any{
+      "type": typ,
+      "enum": []any{value},
+    })
+  }
+  var visitConstant func(nativeiterate.JsonSchema)
+  visitConstant = func(input nativeiterate.JsonSchema) {
+    if value, ok := input["const"]; ok {
+      insertConstant(value)
+      return
+    }
+    for _, elem := range llmSchemaProgrammer_schema_array(input["oneOf"]) {
+      visitConstant(elem)
+    }
+  }
+
+  var visit func(nativeiterate.JsonSchema)
+  visit = func(input nativeiterate.JsonSchema) {
+    if oneOf := llmSchemaProgrammer_schema_array(input["oneOf"]); len(oneOf) != 0 {
+      for _, elem := range oneOf {
+        visit(elem)
+      }
+      return
+    }
+    if ref, ok := input["$ref"].(string); ok {
+      key := llmSchemaProgrammer_ref_key(ref)
+      if _, exists := defs[key]; exists == false {
+        defs[key] = map[string]any{}
+        if target, found := llmSchemaProgrammer_component(components, key); found {
+          defs[key] = llmSchemaProgrammer_convert_schema_config(target, components, defs, config)
+        }
+      }
+      union = append(union, map[string]any{"$ref": "#/$defs/" + key})
+      return
+    }
+    if input["type"] == "object" {
+      properties := map[string]any{}
+      propertyKeys := []string{}
+      if raw, keys, ok := llmSchemaProgrammer_schema_map_ordered(input["properties"]); ok {
+        for _, key := range keys {
+          if value, ok := llmSchemaProgrammer_schema_from_any(raw[key]); ok {
+            properties[key] = llmSchemaProgrammer_convert_schema_config(value, components, defs, config)
+            propertyKeys = append(propertyKeys, key)
+          }
+        }
+      }
+      output := llmSchemaProgrammer_clone(input)
+      output["properties"] = nativefactories.LiteralFactory_OrderedObject{
+        Keys:   propertyKeys,
+        Values: properties,
+      }
+      if additional, ok := llmSchemaProgrammer_schema_from_any(input["additionalProperties"]); ok {
+        output["additionalProperties"] = llmSchemaProgrammer_convert_schema_config(additional, components, defs, config)
+      } else if strict {
+        output["additionalProperties"] = false
+      } else if value, ok := input["additionalProperties"]; ok {
+        output["additionalProperties"] = value
+      }
+      if _, ok := input["required"]; ok {
+        output["required"] = input["required"]
+      } else {
+        output["required"] = []any{}
+      }
+      if strict {
+        if description := llmSchemaProgrammer_json_descriptor_take(input); description != nil {
+          output["description"] = *description
+        } else {
+          delete(output, "description")
+        }
+      }
+      union = append(union, output)
+      return
+    }
+    if input["type"] == "array" {
+      output := llmSchemaProgrammer_clone(input)
+      if items, ok := llmSchemaProgrammer_schema_from_any(input["items"]); ok {
+        output["items"] = llmSchemaProgrammer_convert_schema_config(items, components, defs, config)
+      }
+      if strict {
+        output = llmSchemaProgrammer_shift_array(output)
+      }
+      union = append(union, output)
+      return
+    }
+    if input["type"] == "string" {
+      output := llmSchemaProgrammer_clone(input)
+      if strict {
+        output = llmSchemaProgrammer_shift_string(output)
+      }
+      union = append(union, output)
+      return
+    }
+    if input["type"] == "number" || input["type"] == "integer" {
+      output := llmSchemaProgrammer_clone(input)
+      if strict {
+        output = llmSchemaProgrammer_shift_numeric(output)
+      }
+      union = append(union, output)
+      return
+    }
+    if _, ok := input["const"]; ok {
+      return
+    }
+    union = append(union, llmSchemaProgrammer_clone(input))
+  }
+
+  visitConstant(schema)
+  visit(schema)
+
+  if len(union) == 0 {
+    output := llmSchemaProgrammer_clone(attribute)
+    output["type"] = nil
+    return output
+  }
+  if len(union) == 1 {
+    output := llmSchemaProgrammer_merge(attribute, union[0])
+    if strict && llmSchemaProgrammer_is_reference(union[0]) {
+      delete(output, "description")
+    } else if description, ok := union[0]["description"]; ok {
+      output["description"] = description
+    } else if description, ok := attribute["description"]; ok {
+      output["description"] = description
+    }
+    return output
+  }
+  anyOf := make([]any, 0, len(union))
+  for _, elem := range union {
+    output := llmSchemaProgrammer_clone(elem)
+    if strict && llmSchemaProgrammer_is_reference(elem) {
+      delete(output, "description")
+    }
+    anyOf = append(anyOf, output)
+  }
+  output := llmSchemaProgrammer_clone(attribute)
+  output["anyOf"] = anyOf
+  if x := llmSchemaProgrammer_discriminator(schema, union); x != nil {
+    output["x-discriminator"] = x
+  }
+  return output
+}
+
+func llmSchemaProgrammer_strict(config map[string]any) bool {
+  strict, _ := config["strict"].(bool)
+  return strict
+}
+
+func llmSchemaProgrammer_attribute(schema nativeiterate.JsonSchema) map[string]any {
+  output := map[string]any{}
+  for _, key := range []string{
+    "title",
+    "description",
+    "deprecated",
+    "readOnly",
+    "writeOnly",
+    "example",
+    "examples",
+  } {
+    if value, ok := schema[key]; ok && llmSchemaProgrammer_is_nil_like(value) == false {
+      output[key] = value
+    }
+  }
+  for key, value := range schema {
+    if strings.HasPrefix(key, "x-") && llmSchemaProgrammer_is_nil_like(value) == false {
+      output[key] = value
+    }
+  }
+  return output
+}
+
+func llmSchemaProgrammer_clone(input map[string]any) map[string]any {
+  output := map[string]any{}
+  for key, value := range input {
+    if llmSchemaProgrammer_is_nil_like(value) {
+      continue
+    }
+    output[key] = value
+  }
+  return output
+}
+
+func llmSchemaProgrammer_is_nil_like(value any) bool {
+  if value == nil {
+    return true
+  }
+  reflected := reflect.ValueOf(value)
+  switch reflected.Kind() {
+  case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Pointer, reflect.Slice:
+    return reflected.IsNil()
+  default:
+    return false
+  }
+}
+
+func llmSchemaProgrammer_merge(left map[string]any, right map[string]any) map[string]any {
+  output := llmSchemaProgrammer_clone(left)
+  for key, value := range right {
+    output[key] = value
+  }
+  return output
+}
+
+func llmSchemaProgrammer_array(value any) []any {
+  switch v := value.(type) {
+  case []any:
+    return append([]any{}, v...)
+  case []string:
+    output := make([]any, 0, len(v))
+    for _, elem := range v {
+      output = append(output, elem)
+    }
+    return output
+  case []nativeiterate.JsonSchema:
+    output := make([]any, 0, len(v))
+    for _, elem := range v {
+      output = append(output, elem)
+    }
+    return output
+  default:
+    return []any{}
+  }
+}
+
+func llmSchemaProgrammer_schema_array(value any) []nativeiterate.JsonSchema {
+  switch v := value.(type) {
+  case []nativeiterate.JsonSchema:
+    return append([]nativeiterate.JsonSchema{}, v...)
+  case []map[string]any:
+    output := make([]nativeiterate.JsonSchema, 0, len(v))
+    for _, elem := range v {
+      output = append(output, nativeiterate.JsonSchema(elem))
+    }
+    return output
+  case []any:
+    output := make([]nativeiterate.JsonSchema, 0, len(v))
+    for _, elem := range v {
+      if schema, ok := llmSchemaProgrammer_schema_from_any(elem); ok {
+        output = append(output, schema)
+      }
+    }
+    return output
+  default:
+    return nil
+  }
+}
+
+func llmSchemaProgrammer_schema_map(value any) (map[string]any, bool) {
+  switch v := value.(type) {
+  case nativefactories.LiteralFactory_OrderedObject:
+    return v.Values, true
+  case *nativefactories.LiteralFactory_OrderedObject:
+    if v == nil {
+      return nil, false
+    }
+    return v.Values, true
+  case nativeiterate.JsonSchema:
+    output := map[string]any{}
+    for key, value := range v {
+      output[key] = value
+    }
+    return output, true
+  case map[string]any:
+    return v, true
+  default:
+    return nil, false
+  }
+}
+
+func llmSchemaProgrammer_schema_map_ordered(value any) (map[string]any, []string, bool) {
+  switch v := value.(type) {
+  case nativefactories.LiteralFactory_OrderedObject:
+    return v.Values, llmSchemaProgrammer_ordered_keys(v.Keys, v.Values), true
+  case *nativefactories.LiteralFactory_OrderedObject:
+    if v == nil {
+      return nil, nil, false
+    }
+    return v.Values, llmSchemaProgrammer_ordered_keys(v.Keys, v.Values), true
+  case nativeiterate.JsonSchema:
+    output := map[string]any{}
+    keys := make([]string, 0, len(v))
+    for key, value := range v {
+      output[key] = value
+      keys = append(keys, key)
+    }
+    sort.Strings(keys)
+    return output, keys, true
+  case map[string]any:
+    keys := make([]string, 0, len(v))
+    for key := range v {
+      keys = append(keys, key)
+    }
+    sort.Strings(keys)
+    return v, keys, true
+  default:
+    return nil, nil, false
+  }
+}
+
+func llmSchemaProgrammer_ordered_keys(keys []string, values map[string]any) []string {
+  output := make([]string, 0, len(values))
+  visited := map[string]bool{}
+  for _, key := range keys {
+    if _, ok := values[key]; ok && visited[key] == false {
+      output = append(output, key)
+      visited[key] = true
+    }
+  }
+  rest := make([]string, 0, len(values)-len(output))
+  for key := range values {
+    if visited[key] == false {
+      rest = append(rest, key)
+    }
+  }
+  sort.Strings(rest)
+  return append(output, rest...)
+}
+
+func llmSchemaProgrammer_schema_from_any(value any) (nativeiterate.JsonSchema, bool) {
+  switch v := value.(type) {
+  case nativeiterate.JsonSchema:
+    return v, true
+  case map[string]any:
+    return nativeiterate.JsonSchema(v), true
+  default:
+    return nil, false
+  }
+}
+
+func llmSchemaProgrammer_constant_type(value any) string {
+  reflected := reflect.ValueOf(value)
+  if reflected.IsValid() == false {
+    return fmt.Sprintf("%T", value)
+  }
+  switch reflected.Kind() {
+  case reflect.Bool:
+    return "boolean"
+  case reflect.String:
+    return "string"
+  case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+    reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
+    reflect.Float32, reflect.Float64:
+    return "number"
+  default:
+    return fmt.Sprintf("%T", value)
+  }
+}
+
+func llmSchemaProgrammer_ref_key(ref string) string {
+  if strings.Contains(ref, "#/components/schemas/") {
+    return strings.Split(ref, "#/components/schemas/")[1]
+  }
+  index := strings.LastIndex(ref, "/")
+  if index == -1 {
+    return ref
+  }
+  return ref[index+1:]
+}
+
+func llmSchemaProgrammer_component(components *nativeiterate.OpenApi_IComponents, key string) (nativeiterate.JsonSchema, bool) {
+  if components == nil || components.Schemas == nil {
+    return nil, false
+  }
+  schema, ok := components.Schemas[key]
+  return schema, ok
+}
+
+func llmSchemaProgrammer_is_reference(schema map[string]any) bool {
+  _, ok := schema["$ref"].(string)
+  return ok
+}
+
+func llmSchemaProgrammer_is_null(schema map[string]any) bool {
+  return schema["type"] == "null"
+}
+
+func llmSchemaProgrammer_discriminator(schema nativeiterate.JsonSchema, union []map[string]any) map[string]any {
+  discriminator, ok := llmSchemaProgrammer_schema_map(schema["discriminator"])
+  if ok == false || len(llmSchemaProgrammer_schema_array(schema["oneOf"])) != len(union) {
+    return nil
+  }
+  for _, elem := range union {
+    if llmSchemaProgrammer_is_reference(elem) == false && llmSchemaProgrammer_is_null(elem) == false {
+      return nil
+    }
+  }
+  output := map[string]any{}
+  if propertyName, ok := discriminator["propertyName"].(string); ok {
+    output["propertyName"] = propertyName
+  }
+  if rawMapping, ok := llmSchemaProgrammer_schema_map(discriminator["mapping"]); ok {
+    mapping := map[string]any{}
+    for key, value := range rawMapping {
+      mapping[key] = "#/$defs/" + llmSchemaProgrammer_ref_key(fmt.Sprint(value))
+    }
+    output["mapping"] = mapping
+  }
+  if len(output) == 0 {
+    return nil
+  }
+  return output
+}
+
+func llmSchemaProgrammer_shift_array(schema map[string]any) map[string]any {
+  output := llmSchemaProgrammer_clone(schema)
+  tags := []string{}
+  if value, ok := output["minItems"]; ok {
+    tags = append(tags, "@minItems "+fmt.Sprint(value))
+    delete(output, "minItems")
+  }
+  if value, ok := output["maxItems"]; ok {
+    tags = append(tags, "@maxItems "+fmt.Sprint(value))
+    delete(output, "maxItems")
+  }
+  if value, ok := output["uniqueItems"].(bool); ok {
+    if value {
+      tags = append(tags, "@uniqueItems")
+    }
+    delete(output, "uniqueItems")
+  }
+  llmSchemaProgrammer_write_tag_with_description(output, tags)
+  return output
+}
+
+func llmSchemaProgrammer_shift_numeric(schema map[string]any) map[string]any {
+  output := llmSchemaProgrammer_clone(schema)
+  llmSchemaProgrammer_emend_exclusive(output)
+  tags := []string{}
+  for _, key := range []string{"minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf"} {
+    if value, ok := output[key]; ok {
+      tags = append(tags, "@"+key+" "+fmt.Sprint(value))
+      delete(output, key)
+    }
+  }
+  llmSchemaProgrammer_write_tag_with_description(output, tags)
+  delete(output, "default")
+  return output
+}
+
+func llmSchemaProgrammer_shift_string(schema map[string]any) map[string]any {
+  output := llmSchemaProgrammer_clone(schema)
+  tags := []string{}
+  for _, key := range []string{"minLength", "maxLength", "format", "pattern", "contentMediaType", "default"} {
+    if value, ok := output[key]; ok {
+      tags = append(tags, "@"+key+" "+fmt.Sprint(value))
+      delete(output, key)
+    }
+  }
+  llmSchemaProgrammer_write_tag_with_description(output, tags)
+  return output
+}
+
+func llmSchemaProgrammer_write_tag_with_description(schema map[string]any, tags []string) {
+  if len(tags) == 0 {
+    return
+  }
+  lines := []string{}
+  if description, ok := schema["description"].(string); ok && len(description) != 0 {
+    lines = append(lines, description, "\n")
+  }
+  lines = append(lines, tags...)
+  schema["description"] = strings.Join(lines, "\n")
+}
+
+func llmSchemaProgrammer_emend_exclusive(schema map[string]any) {
+  if exclusiveMinimum, ok := llmSchemaProgrammer_number(schema["exclusiveMinimum"]); ok {
+    if minimum, found := llmSchemaProgrammer_number(schema["minimum"]); found {
+      if minimum > exclusiveMinimum {
+        schema["minimum"] = minimum
+        delete(schema, "exclusiveMinimum")
+      } else {
+        schema["exclusiveMinimum"] = exclusiveMinimum
+        delete(schema, "minimum")
+      }
+    }
+  }
+  if exclusiveMaximum, ok := llmSchemaProgrammer_number(schema["exclusiveMaximum"]); ok {
+    if maximum, found := llmSchemaProgrammer_number(schema["maximum"]); found {
+      if maximum < exclusiveMaximum {
+        schema["maximum"] = maximum
+        delete(schema, "exclusiveMaximum")
+      } else {
+        schema["exclusiveMaximum"] = exclusiveMaximum
+        delete(schema, "maximum")
+      }
+    }
+  }
+}
+
+func llmSchemaProgrammer_number(value any) (float64, bool) {
+  reflected := reflect.ValueOf(value)
+  if reflected.IsValid() == false {
+    return 0, false
+  }
+  switch reflected.Kind() {
+  case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+    return float64(reflected.Int()), true
+  case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+    return float64(reflected.Uint()), true
+  case reflect.Float32, reflect.Float64:
+    return reflected.Convert(reflect.TypeOf(float64(0))).Float(), true
+  default:
+    return 0, false
+  }
+}
+
+func llmSchemaProgrammer_json_descriptor_take(schema nativeiterate.JsonSchema) *string {
+  parts := []string{}
+  if description, ok := schema["description"].(string); ok && len(description) != 0 {
+    parts = append(parts, description)
+  }
+  properties, ok := llmSchemaProgrammer_schema_map(schema["properties"])
+  if ok {
+    keys := make([]string, 0, len(properties))
+    for key := range properties {
+      keys = append(keys, key)
+    }
+    sort.Strings(keys)
+    for _, key := range keys {
+      value, ok := llmSchemaProgrammer_schema_from_any(properties[key])
+      if ok == false || llmSchemaProgrammer_is_reference(value) == false {
+        continue
+      }
+      description, ok := value["description"].(string)
+      if ok == false || len(description) == 0 {
+        continue
+      }
+      name := key
+      if llmSchemaProgrammer_is_variable_name(key) == false {
+        name = strconv.Quote(key)
+      }
+      parts = append(parts, "### Description of {@link "+name+"} property:\n\n"+llmSchemaProgrammer_quote_description(description))
+    }
+  }
+  if len(parts) == 0 {
+    return nil
+  }
+  output := strings.Join(parts, "\n\n")
+  return &output
+}
+
+func llmSchemaProgrammer_quote_description(description string) string {
+  lines := strings.Split(description, "\n")
+  for i, line := range lines {
+    lines[i] = "> " + line
+  }
+  return strings.Join(lines, "\n")
+}
+
+func llmSchemaProgrammer_is_variable_name(str string) bool {
+  if len(str) == 0 {
+    return false
+  }
+  for i, r := range str {
+    if i == 0 {
+      if (r >= 'A' && r <= 'Z') || (r >= 'a' && r <= 'z') || r == '_' || r == '$' {
+        continue
+      }
+      return false
+    }
+    if (r >= 'A' && r <= 'Z') || (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') || r == '_' || r == '$' {
+      continue
+    }
+    return false
+  }
+  return true
+}
+
+func llmProgrammer_internal(context nativecontext.ITypiaContext, name string) *shimast.Node {
+  if importer := context.Importer; importer != nil {
+    return importer.Internal(name)
+  }
+  f := nativecontext.EmitFactoryOf(llmSchemaProgrammer_factory, context.Emit)
+  return f.NewIdentifier(name)
+}
+
+func llmProgrammer_import_type(context nativecontext.ITypiaContext, props nativecontext.ImportProgrammer_TypeProps) *shimast.Node {
+  if importer := context.Importer; importer != nil {
+    return importer.Type(props)
+  }
+  f := nativecontext.EmitFactoryOf(llmSchemaProgrammer_factory, context.Emit)
+  if str, ok := props.Name.(string); ok {
+    return f.NewTypeReferenceNode(f.NewIdentifier(str), f.NewNodeList(props.Arguments))
+  }
+  return props.Name.(*shimast.Node)
+}
+
+func llmProgrammer_type_reference(name string, emit ...*shimprinter.EmitContext) *shimast.Node {
+  if name == "" {
+    name = "unknown"
+  }
+  f := nativecontext.EmitFactoryOf(llmSchemaProgrammer_factory, emit...)
+  return f.NewTypeReferenceNode(f.NewIdentifier(name), nil)
+}
+
+func llmProgrammer_method_text(modulo *shimast.Node) string {
+  return nativehelpers.ModuloMethodText(modulo)
+}
+
+func llmProgrammer_concat_description(summary *string, description *string) *string {
+  if summary == nil || len(*summary) == 0 || description == nil || len(*description) == 0 {
+    if summary != nil && len(*summary) != 0 {
+      return summary
+    }
+    return description
+  }
+  head := *summary
+  if strings.HasSuffix(head, ".") {
+    head = head[:len(head)-1]
+  }
+  if strings.HasPrefix(*description, head) {
+    return description
+  }
+  out := head + ".\n\n" + *description
+  return &out
+}