typia 14.0.6 → 15.0.0

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

@@ -0,0 +1,113 @@
+package llm
+
+import (
+  "strings"
+
+  nativeiterate "github.com/samchon/typia/packages/typia/native/core/programmers/iterate"
+)
+
+// llmReferenceDescription_root describes a parameters root that was reached
+// through `$ref`, the way `LlmSchemaConverter.parameters` does with
+// `JsonDescriptor.cascade({ escape: true })`: the type's own description, then
+// each described namespace parent quoted, or `Current Type: {@link Name}` when
+// the type carries none (samchon/typia#2405). A root that is not a reference
+// keeps `own`.
+func llmReferenceDescription_root(
+  schema nativeiterate.JsonSchema,
+  components *nativeiterate.OpenApi_IComponents,
+  own *string,
+) *string {
+  ref, ok := schema["$ref"].(string)
+  if ok == false {
+    return own
+  }
+  key, ok := llmReferenceDescription_key(ref)
+  if ok == false {
+    return own
+  }
+  return llmReferenceDescription_cascade(key, components, own)
+}
+
+// llmReferenceDescription_cascade ports `JsonDescriptor.cascade` with
+// `escape: true`.
+func llmReferenceDescription_cascade(
+  key string,
+  components *nativeiterate.OpenApi_IComponents,
+  own *string,
+) *string {
+  type parent struct {
+    key         string
+    description *string
+  }
+  accessors := strings.Split(key, ".")
+  parents := []parent{}
+  for i := len(accessors); i >= 1; i-- {
+    current := strings.Join(accessors[:i], ".")
+    var description *string
+    if components != nil && components.Schemas != nil {
+      if target, found := components.Schemas[current]; found {
+        if text, ok := target["description"].(string); ok {
+          description = &text
+        }
+      }
+    }
+    // the type itself always stays; a parent only when it is described
+    if i == len(accessors) || (description != nil && *description != "") {
+      parents = append(parents, parent{key: current, description: description})
+    }
+  }
+  if (own == nil || *own == "") && len(parents) == 0 {
+    return nil
+  }
+  parts := []string{}
+  if own != nil && *own != "" {
+    parts = append(parts, *own)
+  }
+  for i, p := range parents {
+    if p.description == nil {
+      parts = append(parts, "Current Type: {@link "+p.key+"}")
+      continue
+    }
+    role := "parent"
+    if i == 0 {
+      role = "current"
+    }
+    lines := strings.Split(*p.description, "\n")
+    for j, line := range lines {
+      lines[j] = "> " + line
+    }
+    parts = append(parts, "Description of the "+role+" {@link "+p.key+"} type:\n\n"+strings.Join(lines, "\n"))
+  }
+  output := strings.Join(parts, "\n\n------------------------------\n\n")
+  return &output
+}
+
+// llmReferenceDescription_key reads the component key of a
+// `#/components/schemas/` reference. Native references carry the raw key, the
+// one `components.schemas` is indexed by; `LlmReference.readOpenApi` decodes
+// the escaped form of the same key in an emitted document.
+func llmReferenceDescription_key(ref string) (string, bool) {
+  const prefix = "#/components/schemas/"
+  if strings.HasPrefix(ref, prefix) == false {
+    return "", false
+  }
+  return strings.TrimPrefix(ref, prefix), true
+}
+
+// llmReferenceDescription_assign sets the cascaded root description on a
+// converted parameters object, removing it when the cascade yields none.
+func llmReferenceDescription_assign(
+  output map[string]any,
+  schema nativeiterate.JsonSchema,
+  components *nativeiterate.OpenApi_IComponents,
+) {
+  var own *string
+  if text, ok := output["description"].(string); ok {
+    own = &text
+  }
+  if description := llmReferenceDescription_root(schema, components, own); description != nil {
+    output["description"] = *description
+  } else {
+    delete(output, "description")
+  }
+}

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

@@ -0,0 +1,134 @@
+package llm
+
+import (
+  "testing"
+
+  nativeiterate "github.com/samchon/typia/packages/typia/native/core/programmers/iterate"
+)
+
+// TestLlmReferenceDescription locks the root description of a parameters
+// object reached through `$ref` to `JsonDescriptor.cascade({ escape: true })`,
+// the description `LlmSchemaConverter.parameters` writes for the same
+// collection (samchon/typia#2405).
+func TestLlmReferenceDescription(t *testing.T) {
+  t.Parallel()
+  const separator = "\n\n------------------------------\n\n"
+  text := func(value string) *string { return &value }
+  components := &nativeiterate.OpenApi_IComponents{
+    Schemas: map[string]nativeiterate.JsonSchema{
+      "IPlain":               {"type": "object"},
+      "IMember":              {"type": "object", "description": "Member.\nSecond line."},
+      "IMember.ICreate":      {"type": "object", "description": "Creation."},
+      "IMember.IBare":        {"type": "object"},
+      "IMember.Deep":         {"type": "object"},
+      "IMember.Deep.ILeaf":   {"type": "object"},
+      "IMember.IEmpty":       {"type": "object", "description": ""},
+      "INamespaceless.IItem": {"type": "object"},
+    },
+  }
+  cases := []struct {
+    name     string
+    schema   nativeiterate.JsonSchema
+    own      *string
+    expected *string
+  }{
+    {
+      name:     "undescribed",
+      schema:   nativeiterate.JsonSchema{"$ref": "#/components/schemas/IPlain"},
+      expected: text("Current Type: {@link IPlain}"),
+    },
+    {
+      name:   "described",
+      schema: nativeiterate.JsonSchema{"$ref": "#/components/schemas/IMember"},
+      own:    text("Member.\nSecond line."),
+      expected: text("Member.\nSecond line." + separator +
+        "Description of the current {@link IMember} type:\n\n> Member.\n> Second line."),
+    },
+    {
+      name:   "described child of a described parent",
+      schema: nativeiterate.JsonSchema{"$ref": "#/components/schemas/IMember.ICreate"},
+      own:    text("Creation."),
+      expected: text("Creation." + separator +
+        "Description of the current {@link IMember.ICreate} type:\n\n> Creation." + separator +
+        "Description of the parent {@link IMember} type:\n\n> Member.\n> Second line."),
+    },
+    {
+      name:   "undescribed child of a described parent",
+      schema: nativeiterate.JsonSchema{"$ref": "#/components/schemas/IMember.IBare"},
+      expected: text("Current Type: {@link IMember.IBare}" + separator +
+        "Description of the parent {@link IMember} type:\n\n> Member.\n> Second line."),
+    },
+    {
+      name:   "undescribed middle parent is skipped",
+      schema: nativeiterate.JsonSchema{"$ref": "#/components/schemas/IMember.Deep.ILeaf"},
+      expected: text("Current Type: {@link IMember.Deep.ILeaf}" + separator +
+        "Description of the parent {@link IMember} type:\n\n> Member.\n> Second line."),
+    },
+    {
+      name:   "empty own description renders quoted",
+      schema: nativeiterate.JsonSchema{"$ref": "#/components/schemas/IMember.IEmpty"},
+      own:    text(""),
+      expected: text("Description of the current {@link IMember.IEmpty} type:\n\n> " + separator +
+        "Description of the parent {@link IMember} type:\n\n> Member.\n> Second line."),
+    },
+    {
+      name:     "parent missing from components",
+      schema:   nativeiterate.JsonSchema{"$ref": "#/components/schemas/INamespaceless.IItem"},
+      expected: text("Current Type: {@link INamespaceless.IItem}"),
+    },
+    {
+      name:     "inline object keeps its own description",
+      schema:   nativeiterate.JsonSchema{"type": "object"},
+      own:      text("Inline."),
+      expected: text("Inline."),
+    },
+    {
+      name:   "inline object without description",
+      schema: nativeiterate.JsonSchema{"type": "object"},
+    },
+    {
+      name:     "foreign reference keeps its own description",
+      schema:   nativeiterate.JsonSchema{"$ref": "#/$defs/IPlain"},
+      own:      text("Own."),
+      expected: text("Own."),
+    },
+  }
+  for _, c := range cases {
+    actual := llmReferenceDescription_root(c.schema, components, c.own)
+    if (actual == nil) != (c.expected == nil) || (actual != nil && *actual != *c.expected) {
+      t.Errorf("%s:\nexpected %s\nactual   %s", c.name, llmReferenceDescriptionTest_show(c.expected), llmReferenceDescriptionTest_show(actual))
+    }
+  }
+}
+
+// TestLlmReferenceDescriptionAssign locks that the parameters object loses a
+// stale description when the cascade yields none, and gains the cascade
+// otherwise.
+func TestLlmReferenceDescriptionAssign(t *testing.T) {
+  t.Parallel()
+  components := &nativeiterate.OpenApi_IComponents{
+    Schemas: map[string]nativeiterate.JsonSchema{"IPlain": {"type": "object"}},
+  }
+  output := map[string]any{"type": "object"}
+  llmReferenceDescription_assign(output, nativeiterate.JsonSchema{"$ref": "#/components/schemas/IPlain"}, components)
+  if output["description"] != "Current Type: {@link IPlain}" {
+    t.Fatalf("reference root: got %#v", output["description"])
+  }
+  inline := map[string]any{"type": "object", "description": ""}
+  llmReferenceDescription_assign(inline, nativeiterate.JsonSchema{"type": "object"}, components)
+  if value, ok := inline["description"]; ok == false || value != "" {
+    t.Fatalf("inline root must keep its own description: got %#v", inline)
+  }
+  bare := map[string]any{"type": "object"}
+  llmReferenceDescription_assign(bare, nativeiterate.JsonSchema{"type": "object"}, components)
+  if _, ok := bare["description"]; ok {
+    t.Fatalf("inline root without description must stay undescribed: got %#v", bare)
+  }
+}
+
+func llmReferenceDescriptionTest_show(value *string) string {
+  if value == nil {
+    return "<nil>"
+  }
+  return "\"" + *value + "\""
+}

package/native/core/schemas/metadata/MetadataDependency.go

@@ -91,6 +91,15 @@ func MetadataDependency_active(checker *nativechecker.Checker) bool {
   return metadataDependency_listener(checker).active()
 }
 
+// MetadataDependency_touchFile reports a source file consulted outside the
+// metadata iterator, so a complete transform dependency list still watches it.
+func MetadataDependency_touchFile(checker *nativechecker.Checker, fileName string) {
+  listener := metadataDependency_listener(checker)
+  if listener.File != nil {
+    listener.File(fileName)
+  }
+}
+
 // MetadataDependency_touchType reports the declaration files of a consulted
 // type: both the structural symbol (interface / class / enum / object literal)
 // and the type-name symbol (a `type` alias), which differ for aliased types.

package/native/transform/CallExpressionTransformer.go

@@ -469,6 +469,7 @@ func callExpressionTransformer_createFunctors() map[string]map[string]callExpres
       "structuredOutput": func() callExpressionTransformerTask {
         return nativellmtransformers.LlmStructuredOutputTransformer.Transform
       },
+      "evaluation":  func() callExpressionTransformerTask { return nativellmtransformers.LlmEvaluationTransformer.Transform },
       "parameters":  func() callExpressionTransformerTask { return nativellmtransformers.LlmParametersTransformer.Transform },
       "schema":      func() callExpressionTransformerTask { return nativellmtransformers.LlmSchemaTransformer.Transform },
       "parse":       func() callExpressionTransformerTask { return nativellmtransformers.LlmParseTransformer.Transform },

package/native/transform/FileTransformer.go

@@ -33,6 +33,10 @@ var fileTransformer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
 var fileTransformer_jsDocParsingMode sync.Map
 
 func (fileTransformerNamespace) Transform(environments FileTransformer_IEnvironments) func(transformer any) FileTransformer_Type {
+  shared := environments.Extras.Shared
+  if shared == nil {
+    shared = &sync.Map{}
+  }
   return func(transformer any) FileTransformer_Type {
     return func(file *shimast.SourceFile) *shimast.SourceFile {
       if file == nil || file.IsDeclarationFile {
@@ -53,6 +57,7 @@ func (fileTransformerNamespace) Transform(environments FileTransformer_IEnvironm
         Emit:            environments.EmitContext,
         Importer:        importer,
         Extras:          environments.Extras,
+        Shared:          shared,
       }
       _ = transformer
       fileTransformer_checkJsDocParsingMode(context, file)

package/native/transform/features/llm/LlmEvaluationProbabilityDeclarations.go

@@ -0,0 +1,94 @@
+package llm
+
+import (
+  "fmt"
+  "strings"
+  "sync"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  nativellmprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/llm"
+)
+
+func llmEvaluation_cachedDeclarationProbabilityErrors(context nativecontext.ITypiaContext) []nativellmprogrammers.LlmEvaluationProgrammer_IError {
+  if context.Program == nil {
+    return nil
+  }
+  return llmEvaluation_onceDeclarationProbabilityErrors(context.Shared, func() []nativellmprogrammers.LlmEvaluationProgrammer_IError {
+    return llmEvaluation_declarationProbabilityErrors(context.Program.SourceFiles())
+  })
+}
+
+func llmEvaluation_onceDeclarationProbabilityErrors(shared *sync.Map, analyze func() []nativellmprogrammers.LlmEvaluationProgrammer_IError) []nativellmprogrammers.LlmEvaluationProgrammer_IError {
+  if shared == nil {
+    return analyze()
+  }
+  cached, _ := shared.LoadOrStore("llm.evaluation.probability.declarations", sync.OnceValue(analyze))
+  return cached.(func() []nativellmprogrammers.LlmEvaluationProgrammer_IError)()
+}
+
+// Primitive aliases lose their declaration identity when TypeScript resolves
+// them (boolean aliases become the same boolean type). Consequently, no walk
+// of the resolved evaluation type can reliably distinguish a used annotation
+// from an unused one. Validate tag placement syntactically across a program
+// that uses llm.evaluation: only properties and enum members can carry it.
+func llmEvaluation_declarationProbabilityErrors(files []*shimast.SourceFile) []nativellmprogrammers.LlmEvaluationProgrammer_IError {
+  errors := []nativellmprogrammers.LlmEvaluationProgrammer_IError{}
+  for _, file := range files {
+    if file == nil || !strings.Contains(file.Text(), "@probability") {
+      continue
+    }
+    var walk func(*shimast.Node)
+    walk = func(node *shimast.Node) {
+      if node == nil {
+        return
+      }
+      allowed := node.Kind == shimast.KindPropertySignature ||
+        node.Kind == shimast.KindPropertyDeclaration ||
+        node.Kind == shimast.KindGetAccessor ||
+        node.Kind == shimast.KindSetAccessor ||
+        node.Kind == shimast.KindEnumMember
+      if !allowed {
+        for _, doc := range node.JSDoc(nil) {
+          parsed := doc.AsJSDoc()
+          if parsed == nil || parsed.Tags == nil {
+            continue
+          }
+          for _, tag := range parsed.Tags.Nodes {
+            if tag != nil && tag.TagName() != nil && tag.TagName().Text() == "probability" {
+              name := "<anonymous>"
+              if identifier := node.Name(); identifier != nil {
+                switch identifier.Kind {
+                case shimast.KindIdentifier, shimast.KindStringLiteral, shimast.KindNumericLiteral, shimast.KindNoSubstitutionTemplateLiteral:
+                  name = identifier.Text()
+                }
+              }
+              kind := "declaration"
+              switch node.Kind {
+              case shimast.KindTypeAliasDeclaration:
+                kind = "type alias"
+              case shimast.KindInterfaceDeclaration:
+                kind = "interface"
+              case shimast.KindClassDeclaration, shimast.KindClassExpression:
+                kind = "class"
+              case shimast.KindEnumDeclaration:
+                kind = "enum"
+              }
+              errors = append(errors, nativellmprogrammers.LlmEvaluationProgrammer_IError{
+                Accessor: "$input",
+                Message:  fmt.Sprintf("LLM evaluation @probability on %s %s in %s is unsupported; put it on a decision property or enum member.", kind, name, file.FileName()),
+              })
+              break
+            }
+          }
+        }
+      }
+      node.ForEachChild(func(child *shimast.Node) bool {
+        walk(child)
+        return false
+      })
+    }
+    walk(file.AsNode())
+  }
+  return errors
+}

package/native/transform/features/llm/LlmEvaluationProbabilityDeclarations_test.go

@@ -0,0 +1,50 @@
+package llm
+
+import (
+  "sync"
+  "sync/atomic"
+  "testing"
+
+  nativellmprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/llm"
+)
+
+// TestLlmEvaluationDeclarationProbabilityCache verifies one placement scan
+// runs for every transform invocation sharing a program cache.
+//
+// File callbacks can run concurrently and must receive the same diagnostic
+// result without redoing the program-wide scan. A new program gets a new map.
+//
+//  1. Read the result concurrently through one shared map.
+//  2. Require one calculation and identical diagnostics for every reader.
+//  3. Require a fresh map and an uncached call to calculate independently.
+func TestLlmEvaluationDeclarationProbabilityCache(t *testing.T) {
+  var calls atomic.Int32
+  analyze := func() []nativellmprogrammers.LlmEvaluationProgrammer_IError {
+    calls.Add(1)
+    return []nativellmprogrammers.LlmEvaluationProgrammer_IError{{
+      Accessor: "$input",
+      Message:  "unsupported declaration",
+    }}
+  }
+  shared := &sync.Map{}
+  var group sync.WaitGroup
+  for range 16 {
+    group.Add(1)
+    go func() {
+      defer group.Done()
+      errors := llmEvaluation_onceDeclarationProbabilityErrors(shared, analyze)
+      if len(errors) != 1 || errors[0].Message != "unsupported declaration" {
+        t.Errorf("cached diagnostic changed: %+v", errors)
+      }
+    }()
+  }
+  group.Wait()
+  if count := calls.Load(); count != 1 {
+    t.Fatalf("one program must scan once, got %d scans", count)
+  }
+  llmEvaluation_onceDeclarationProbabilityErrors(&sync.Map{}, analyze)
+  llmEvaluation_onceDeclarationProbabilityErrors(nil, analyze)
+  if count := calls.Load(); count != 3 {
+    t.Fatalf("fresh and uncached programs must recalculate, got %d scans", count)
+  }
+}

package/native/transform/features/llm/LlmEvaluationTransformer.go

@@ -0,0 +1,59 @@
+package llm
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+  nativellmprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/llm"
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  nativetransform "github.com/samchon/typia/packages/typia/native/transform/internal"
+)
+
+type llmEvaluationTransformerNamespace struct{}
+
+var LlmEvaluationTransformer = llmEvaluationTransformerNamespace{}
+
+func (llmEvaluationTransformerNamespace) Transform(props nativetransform.ITransformProps) *shimast.Node {
+  top, typ, ok := llmTransformer_type_argument(props, "typia.llm.evaluation")
+  if ok == false {
+    return props.Expression.AsNode()
+  }
+  if typ != nil && typ.IsTypeParameter() {
+    panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{Code: "typia.llm.evaluation", Message: "non-specified generic argument."}))
+  }
+  metadata := llmTransformer_analyze(llmTransformer_analyzeProps{
+    Context:             props.Context,
+    Type:                typ,
+    Code:                "typia.llm.evaluation",
+    Absorb:              true,
+    StrictObjectMembers: true,
+    Validate: func(struct {
+      Metadata *schemametadata.MetadataSchema
+      Explore  nativefactories.MetadataFactory_IExplore
+      Top      *schemametadata.MetadataSchema
+    }) []string {
+      return nil
+    },
+  })
+  plan, errors := nativellmprogrammers.LlmEvaluationProgrammer.Compose(metadata)
+  errors = append(errors, llmEvaluation_cachedDeclarationProbabilityErrors(props.Context)...)
+  // The placement scan depends on every program source, including files with
+  // no tag today: adding one later must invalidate a cached successful emit.
+  if props.Context.Program != nil && schemametadata.MetadataDependency_active(props.Context.Checker) {
+    for _, file := range props.Context.Program.SourceFiles() {
+      if file != nil {
+        schemametadata.MetadataDependency_touchFile(props.Context.Checker, file.FileName())
+      }
+    }
+  }
+  if len(errors) != 0 {
+    panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{
+      Code:    "typia.llm.evaluation",
+      Message: nativellmprogrammers.LlmEvaluationProgrammer.Message(errors),
+    }))
+  }
+  return nativellmprogrammers.LlmEvaluationProgrammer.Write(nativellmprogrammers.LlmEvaluationProgrammer_IWriteProps{
+    Context:  props.Context,
+    Metadata: metadata,
+    Name:     llmTransformer_type_name(top),
+  }, plan)
+}

package/native/transform/features/llm/LlmSchemaTransformer.go

@@ -68,12 +68,13 @@ func (llmSchemaTransformerNamespace) Transform(props nativetransform.ITransformP
 }
 
 type llmTransformer_analyzeProps struct {
-  Context    nativecontext.ITypiaContext
-  Type       *shimchecker.Type
-  Code       string
-  Absorb     bool
-  Functional bool
-  Validate   func(props struct {
+  Context             nativecontext.ITypiaContext
+  Type                *shimchecker.Type
+  Code                string
+  Absorb              bool
+  Functional          bool
+  StrictObjectMembers bool
+  Validate            func(props struct {
     Metadata *schemametadata.MetadataSchema
     Explore  nativefactories.MetadataFactory_IExplore
     Top      *schemametadata.MetadataSchema
@@ -105,11 +106,13 @@ func llmTransformer_analyze(props llmTransformer_analyzeProps) *schemametadata.M
   result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{
     Checker: props.Context.Checker,
     Options: nativefactories.MetadataFactory_IOptions{
-      Absorb:     props.Absorb,
-      Escape:     true,
-      Constant:   true,
-      Functional: props.Functional,
-      Validate:   props.Validate,
+      Absorb:              props.Absorb,
+      Escape:              true,
+      Constant:            true,
+      Functional:          props.Functional,
+      Methods:             props.StrictObjectMembers,
+      StrictObjectMembers: props.StrictObjectMembers,
+      Validate:            props.Validate,
     },
     Components: schemametadata.NewMetadataCollection(&schemametadata.MetadataCollection_IOptions{
       Replace: schemametadata.MetadataCollection_replace,

package/native/transform/features/llm/llm_transformer_entry_coverage_test.go

@@ -4,9 +4,9 @@
 package llm
 
 import (
-	"testing"
+  "testing"
 
-	nativetransform "github.com/samchon/typia/packages/typia/native/transform/internal"
+  nativetransform "github.com/samchon/typia/packages/typia/native/transform/internal"
 )
 
 // TestLLMTransformerEntryCoverage exercises LLM transform entrypoints.
@@ -16,33 +16,35 @@ import (
 // guards. Empty transform props visit those entrypoints and recover their guard
 // failures deterministically.
 //
-// 1. Visit schema, parameters, application, and structured-output wrappers.
-// 2. Visit controller and parse/coerce scalar wrappers.
-// 3. Visit create-parse and create-coerce factory wrappers.
-// 4. Recover expected guard panics for every wrapper call.
+//  1. Visit schema, parameters, application, structured-output, and evaluation
+//     wrappers.
+//  2. Visit controller and parse/coerce scalar wrappers.
+//  3. Visit create-parse and create-coerce factory wrappers.
+//  4. Recover expected guard panics for every wrapper call.
 func TestLLMTransformerEntryCoverage(t *testing.T) {
-	props := nativetransform.ITransformProps{}
-	for _, run := range []func(){
-		func() { LlmSchemaTransformer.Transform(props) },
-		func() { LlmParametersTransformer.Transform(props) },
-		func() { LlmApplicationTransformer.Transform(props) },
-		func() { LlmStructuredOutputTransformer.Transform(props) },
-		func() { LlmControllerTransformer.Transform(props) },
-		func() { LlmParseTransformer.Transform(props) },
-		func() { LlmCoerceTransformer.Transform(props) },
-		func() { LlmCreateParseTransformer.Transform(props) },
-		func() { LlmCreateCoerceTransformer.Transform(props) },
-	} {
-		expectLLMPanic(t, run)
-	}
+  props := nativetransform.ITransformProps{}
+  for _, run := range []func(){
+    func() { LlmSchemaTransformer.Transform(props) },
+    func() { LlmParametersTransformer.Transform(props) },
+    func() { LlmApplicationTransformer.Transform(props) },
+    func() { LlmStructuredOutputTransformer.Transform(props) },
+    func() { LlmEvaluationTransformer.Transform(props) },
+    func() { LlmControllerTransformer.Transform(props) },
+    func() { LlmParseTransformer.Transform(props) },
+    func() { LlmCoerceTransformer.Transform(props) },
+    func() { LlmCreateParseTransformer.Transform(props) },
+    func() { LlmCreateCoerceTransformer.Transform(props) },
+  } {
+    expectLLMPanic(t, run)
+  }
 }
 
 func expectLLMPanic(t *testing.T, run func()) {
-	t.Helper()
-	defer func() {
-		if recover() == nil {
-			t.Fatal("expected LLM transformer panic")
-		}
-	}()
-	run()
+  t.Helper()
+  defer func() {
+    if recover() == nil {
+      t.Fatal("expected LLM transformer panic")
+    }
+  }()
+  run()
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "14.0.6",
+  "version": "15.0.0",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "exports": {
@@ -43,8 +43,8 @@
   "homepage": "https://typia.io",
   "dependencies": {
     "randexp": "^0.5.3",
-    "@typia/interface": "^14.0.6",
-    "@typia/utils": "^14.0.6"
+    "@typia/utils": "^15.0.0",
+    "@typia/interface": "^15.0.0"
   },
   "peerDependencies": {
     "ttsc": ">=0.19.2"