typia 13.0.0-dev.20260520.2 → 13.0.0-dev.20260601.1

package/native/adapter/adapter.go

@@ -3,7 +3,6 @@ package adapter
 import (
   "fmt"
   "os"
-  "regexp"
   "runtime/debug"
   "strings"
 
@@ -138,10 +137,65 @@ func cleanupPrintedExpression(text string) string {
   return text
 }
 
-var singleParameterArrowPattern = regexp.MustCompile(`(^|[\s(=,:?])([A-Za-z_$][A-Za-z0-9_$]*) =>`)
-
+// parenthesizeSingleParameterArrows wraps a bare single-parameter arrow head
+// `x =>` into `(x) =>`. It reproduces the regex
+// `(^|[\s(=,:?])([A-Za-z_$][A-Za-z0-9_$]*) =>` -> `${1}(${2}) =>` with a manual
+// byte scan: the printed call-site expression is large and this pass ran on
+// every site, where the regex backtracker dominated the cleanup CPU.
 func parenthesizeSingleParameterArrows(text string) string {
-  return singleParameterArrowPattern.ReplaceAllString(text, `${1}(${2}) =>`)
+  arrow := strings.Index(text, " =>")
+  if arrow < 0 {
+    return text
+  }
+  var b strings.Builder
+  last := 0
+  for arrow >= 0 {
+    end := arrow // identifier ends just before the space of " =>"
+    start := end
+    for start > 0 && isArrowIdentByte(text[start-1]) {
+      start--
+    }
+    if end > start && isArrowIdentStart(text[start]) &&
+      (start == 0 || isArrowBoundaryByte(text[start-1])) {
+      if b.Cap() == 0 {
+        b.Grow(len(text) + 16)
+      }
+      b.WriteString(text[last:start])
+      b.WriteByte('(')
+      b.WriteString(text[start:end])
+      b.WriteByte(')')
+      last = end
+    }
+    next := strings.Index(text[arrow+3:], " =>")
+    if next < 0 {
+      break
+    }
+    arrow += 3 + next
+  }
+  if last == 0 {
+    return text
+  }
+  b.WriteString(text[last:])
+  return b.String()
+}
+
+func isArrowIdentStart(c byte) bool {
+  return c == '_' || c == '$' ||
+    (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
+}
+
+func isArrowIdentByte(c byte) bool {
+  return isArrowIdentStart(c) || (c >= '0' && c <= '9')
+}
+
+// isArrowBoundaryByte matches the regex class [\s(=,:?] (RE2 `\s` is
+// [\t\n\f\r ], i.e. no vertical tab).
+func isArrowBoundaryByte(c byte) bool {
+  switch c {
+  case ' ', '\t', '\n', '\f', '\r', '(', '=', ',', ':', '?':
+    return true
+  }
+  return false
 }
 
 func UnsupportedReason(site CallSite) string {

package/native/adapter/cleanup.go

@@ -5,9 +5,49 @@ import (
   "regexp"
   "sort"
   "strings"
+  "sync"
 )
 
+// Static cleanup patterns are compiled once at package load. Compiling them
+// inside the cleanup functions recompiled the same expressions on every emitted
+// file, which dominated the cleanup cost (regex compilation, not matching, was
+// the hot spot).
+const typiaCleanupTypeAtom = `([A-Za-z_$][A-Za-z0-9_$.]*(<[^()\n;{}]*>)?)`
+
+var (
+  reImportTypeLine        = regexp.MustCompile(`(?m)^import type \{([^{}\n]+)\} from`)
+  reImportTypeNormalize   = regexp.MustCompile(`^import type \{\s*([^{}\n]+?)\s*\} from`)
+  reBlankBeforeDecl       = regexp.MustCompile(`(?m)(^import [^\n]+;\n)\n+(const |let |var |export )`)
+  reInputIsParen          = regexp.MustCompile(`input is \(([A-Za-z_$][A-Za-z0-9_$.]*)\)`)
+  reBlankBeforeCall       = regexp.MustCompile(`\n\n([A-Za-z_$][A-Za-z0-9_$]*\([^;\n]*\);?)`)
+  reParenTypeArrow        = regexp.MustCompile(`: \(` + typiaCleanupTypeAtom + `\)(\s*=>)`)
+  reParenNullUndefined    = regexp.MustCompile(`\| \((null|undefined)\)`)
+  reConstAliasHead        = regexp.MustCompile(`^const (\w+) =`)
+  reImportAliasHead       = regexp.MustCompile(`^import (\w+) from`)
+  reRuntimeTransformAlias = regexp.MustCompile(`\b__typia_transform_([A-Za-z0-9_]+)\b`)
+  reESModuleOutput        = regexp.MustCompile(`(?m)^(import\s|import\{|import\*|export\s)`)
+)
+
+// dynamicRegexpCache memoizes the alias/module-parameterized patterns used when
+// checking for pre-existing runtime imports. Aliases and modules recur heavily
+// across the files of a single build, so caching amortizes compilation.
+var dynamicRegexpCache sync.Map // map[string]*regexp.Regexp
+
+func cachedRegexp(pattern string) *regexp.Regexp {
+  if v, ok := dynamicRegexpCache.Load(pattern); ok {
+    return v.(*regexp.Regexp)
+  }
+  re := regexp.MustCompile(pattern)
+  dynamicRegexpCache.Store(pattern, re)
+  return re
+}
+
 func CleanupTransformedText(text string) string {
+  // Every unused-import pattern references the "typia" module specifier, so the
+  // regex scan can be skipped entirely when the emitted file never mentions it.
+  if !strings.Contains(text, "typia") {
+    return injectRuntimeImports(text)
+  }
   for _, pattern := range unusedImportPatterns {
     loc := pattern.regex.FindStringIndex(text)
     for loc != nil {
@@ -34,14 +74,20 @@ func CleanupTransformedText(text string) string {
 func CleanupTypeScriptTransformText(text string) string {
   text = CleanupTransformedText(text)
   text = normalizeParenthesizedTypeAnnotations(text)
-  text = regexp.MustCompile(`(?m)^import type \{([^{}\n]+)\} from`).ReplaceAllStringFunc(text, func(line string) string {
-    return regexp.MustCompile(`^import type \{\s*([^{}\n]+?)\s*\} from`).ReplaceAllString(line, "import type { $1 } from")
-  })
-  text = regexp.MustCompile(`(?m)(^import [^\n]+;\n)\n+(const |let |var |export )`).ReplaceAllString(text, "$1$2")
+  if strings.Contains(text, "import type {") {
+    text = reImportTypeLine.ReplaceAllStringFunc(text, func(line string) string {
+      return reImportTypeNormalize.ReplaceAllString(line, "import type { $1 } from")
+    })
+  }
+  if strings.Contains(text, "\n\n") {
+    text = reBlankBeforeDecl.ReplaceAllString(text, "$1$2")
+  }
   text = strings.ReplaceAll(text, "=(() =>", "= (() =>")
   text = strings.ReplaceAll(text, ": (any) =>", ": any =>")
   text = strings.ReplaceAll(text, ": (boolean) =>", ": boolean =>")
-  text = regexp.MustCompile(`input is \(([A-Za-z_$][A-Za-z0-9_$.]*)\)`).ReplaceAllString(text, "input is $1")
+  if strings.Contains(text, "input is (") {
+    text = reInputIsParen.ReplaceAllString(text, "input is $1")
+  }
   text = strings.ReplaceAll(text, "return (success ? ", "return success ? ")
   text = strings.ReplaceAll(text, "}) as any;", "} as any;")
   text = strings.ReplaceAll(text, "(() => {\n    const ", "(() => { const ")
@@ -55,7 +101,9 @@ func CleanupTypeScriptTransformText(text string) string {
   text = strings.ReplaceAll(text, "\n    }); let ", "\n}); let ")
   text = strings.ReplaceAll(text, ";\n})()", "; })()")
   text = strings.ReplaceAll(text, "\n        ", "\n    ")
-  text = regexp.MustCompile(`\n\n([A-Za-z_$][A-Za-z0-9_$]*\([^;\n]*\);?)`).ReplaceAllString(text, "\n$1")
+  if strings.Contains(text, "\n\n") {
+    text = reBlankBeforeCall.ReplaceAllString(text, "\n$1")
+  }
   trimmed := strings.TrimRight(text, " \t\r\n")
   if strings.HasSuffix(trimmed, ")") && !strings.HasSuffix(trimmed, ";") {
     return trimmed + ";\n"
@@ -67,9 +115,12 @@ func CleanupTypeScriptTransformText(text string) string {
 }
 
 func normalizeParenthesizedTypeAnnotations(text string) string {
-  typeAtom := `([A-Za-z_$][A-Za-z0-9_$.]*(<[^()\n;{}]*>)?)`
-  text = regexp.MustCompile(`: \(`+typeAtom+`\)(\s*=>)`).ReplaceAllString(text, ": $1$3")
-  text = regexp.MustCompile(`\| \((null|undefined)\)`).ReplaceAllString(text, "| $1")
+  if strings.Contains(text, ": (") {
+    text = reParenTypeArrow.ReplaceAllString(text, ": $1$3")
+  }
+  if strings.Contains(text, "| (") {
+    text = reParenNullUndefined.ReplaceAllString(text, "| $1")
+  }
   return text
 }
 
@@ -82,25 +133,25 @@ var unusedImportPatterns = []unusedImportPattern{
   {
     regex: regexp.MustCompile(`(?m)^const (typia(?:_\d+)?) = __importDefault\(require\("typia"\)\);$`),
     alias: func(s string) string {
-      return firstSubmatch(`^const (\w+) =`, s)
+      return firstSubmatch(reConstAliasHead, s)
     },
   },
   {
     regex: regexp.MustCompile(`(?m)^const (typia(?:_\d+)?) = require\("typia"\);$`),
     alias: func(s string) string {
-      return firstSubmatch(`^const (\w+) =`, s)
+      return firstSubmatch(reConstAliasHead, s)
     },
   },
   {
     regex: regexp.MustCompile(`(?m)^import (\w+) from "typia";$`),
     alias: func(s string) string {
-      return firstSubmatch(`^import (\w+) from`, s)
+      return firstSubmatch(reImportAliasHead, s)
     },
   },
 }
 
-func firstSubmatch(pattern string, text string) string {
-  match := regexp.MustCompile(pattern).FindStringSubmatch(text)
+func firstSubmatch(re *regexp.Regexp, text string) string {
+  match := re.FindStringSubmatch(text)
   if len(match) < 2 {
     return ""
   }
@@ -108,10 +159,38 @@ func firstSubmatch(pattern string, text string) string {
 }
 
 func aliasStillReferenced(text, alias string, lineStart, lineEnd int) bool {
-  head := text[:lineStart]
-  tail := text[lineEnd:]
-  pattern := regexp.MustCompile(`\b` + regexp.QuoteMeta(alias) + `\b`)
-  return pattern.MatchString(head) || pattern.MatchString(tail)
+  // Equivalent to matching `\b<alias>\b`, but alias is always a `\w+` token, so
+  // a manual word-boundary scan avoids compiling a regex per import line.
+  return containsWord(text[:lineStart], alias) || containsWord(text[lineEnd:], alias)
+}
+
+// containsWord reports whether word appears in haystack delimited by ASCII word
+// boundaries, matching Go regexp's `\b<word>\b` for word-only tokens.
+func containsWord(haystack, word string) bool {
+  if word == "" {
+    return false
+  }
+  for i := 0; i+len(word) <= len(haystack); {
+    j := strings.Index(haystack[i:], word)
+    if j < 0 {
+      return false
+    }
+    start := i + j
+    end := start + len(word)
+    if (start == 0 || !isWordByte(haystack[start-1])) &&
+      (end == len(haystack) || !isWordByte(haystack[end])) {
+      return true
+    }
+    i = start + 1
+  }
+  return false
+}
+
+func isWordByte(b byte) bool {
+  return b == '_' ||
+    (b >= '0' && b <= '9') ||
+    (b >= 'a' && b <= 'z') ||
+    (b >= 'A' && b <= 'Z')
 }
 
 func injectRuntimeImports(text string) string {
@@ -141,9 +220,13 @@ func injectRuntimeImports(text string) string {
 }
 
 func collectRuntimeAliases(text string) []string {
-  re := regexp.MustCompile(`\b__typia_transform_([A-Za-z0-9_]+)\b`)
+  // The alias regex can only match where the literal prefix appears; skipping
+  // the full-text scan when it is absent avoids work on most emitted files.
+  if !strings.Contains(text, "__typia_transform_") {
+    return nil
+  }
   seen := map[string]bool{}
-  for _, match := range re.FindAllStringSubmatch(text, -1) {
+  for _, match := range reRuntimeTransformAlias.FindAllStringSubmatch(text, -1) {
     seen[match[0]] = true
   }
   aliases := make([]string, 0, len(seen))
@@ -198,14 +281,21 @@ func runtimeNameOf(alias string) string {
 }
 
 func runtimeImportAlreadyExists(text string, alias string, module string) bool {
-  return regexp.MustCompile(`(?m)^import \* as `+regexp.QuoteMeta(alias)+` from ["']`+regexp.QuoteMeta(module)+`["'];$`).MatchString(text) ||
-    regexp.MustCompile(`(?m)^import \{[^}\n]*\bas\s+`+regexp.QuoteMeta(alias)+`\b[^}\n]*\} from ["']`+regexp.QuoteMeta(module)+`["'];$`).MatchString(text) ||
-    regexp.MustCompile(`(?m)^const `+regexp.QuoteMeta(alias)+` = require\(["']`+regexp.QuoteMeta(module)+`["']\);$`).MatchString(text) ||
-    regexp.MustCompile(`(?m)^const \{[^}\n]*:\s*`+regexp.QuoteMeta(alias)+`\b[^}\n]*\} = require\(["']`+regexp.QuoteMeta(module)+`["']\);$`).MatchString(text)
+  // Fast reject: every shape below mentions both the alias and the module, so
+  // skip the regex work entirely when either is absent.
+  if !strings.Contains(text, alias) || !strings.Contains(text, module) {
+    return false
+  }
+  a := regexp.QuoteMeta(alias)
+  m := regexp.QuoteMeta(module)
+  return cachedRegexp(`(?m)^import \* as `+a+` from ["']`+m+`["'];$`).MatchString(text) ||
+    cachedRegexp(`(?m)^import \{[^}\n]*\bas\s+`+a+`\b[^}\n]*\} from ["']`+m+`["'];$`).MatchString(text) ||
+    cachedRegexp(`(?m)^const `+a+` = require\(["']`+m+`["']\);$`).MatchString(text) ||
+    cachedRegexp(`(?m)^const \{[^}\n]*:\s*`+a+`\b[^}\n]*\} = require\(["']`+m+`["']\);$`).MatchString(text)
 }
 
 func isESModuleOutput(text string) bool {
-  return regexp.MustCompile(`(?m)^(import\s|import\{|import\*|export\s)`).MatchString(text)
+  return reESModuleOutput.MatchString(text)
 }
 
 func runtimeImportInsertionIndex(text string, esModule bool) int {

package/native/core/factories/internal/metadata/MetadataHelper.go

@@ -36,10 +36,20 @@ func metadata_array_util_add_bool(array *[]bool, value bool) {
   *array = append(*array, value)
 }
 
-func metadata_type_full_name(checker *nativechecker.Checker, typ *nativechecker.Type) string {
+func metadata_type_full_name(
+  checker *nativechecker.Checker,
+  typ *nativechecker.Type,
+  cache *schemametadata.MetadataCollection,
+) string {
   if checker == nil || typ == nil {
     return ""
   }
+  if cache != nil {
+    if cached, ok := cache.LookupTypeFullName(typ); ok {
+      return cached
+    }
+  }
+  var result string
   if typ.IsUnion() || typ.IsIntersection() {
     joiner := " | "
     if typ.IsIntersection() {
@@ -48,11 +58,16 @@ func metadata_type_full_name(checker *nativechecker.Checker, typ *nativechecker.
     children := typ.Types()
     names := make([]string, 0, len(children))
     for _, child := range children {
-      names = append(names, metadata_type_full_name(checker, child))
+      names = append(names, metadata_type_full_name(checker, child, cache))
     }
-    return strings.Join(names, joiner)
+    result = strings.Join(names, joiner)
+  } else {
+    result = checker.TypeToString(typ)
+  }
+  if cache != nil {
+    cache.StoreTypeFullName(typ, result)
   }
-  return checker.TypeToString(typ)
+  return result
 }
 
 func metadata_get_type_arguments(checker *nativechecker.Checker, typ *nativechecker.Type) (output []*nativechecker.Type) {
@@ -205,7 +220,48 @@ func metadata_js_doc_parameter_name(tag *nativeast.Node) string {
   if name == nil {
     return ""
   }
-  return name.Text()
+  return metadata_js_doc_name_text(name)
+}
+
+func metadata_js_doc_name_text(node *nativeast.Node) string {
+  if text := metadata_node_source_text(node); text != "" {
+    return text
+  }
+  if node == nil {
+    return ""
+  }
+  if node.Kind == nativeast.KindQualifiedName {
+    name := node.AsQualifiedName()
+    if name == nil {
+      return ""
+    }
+    left := metadata_js_doc_name_text(name.Left)
+    right := metadata_js_doc_name_text(name.Right)
+    if left == "" {
+      return right
+    }
+    if right == "" {
+      return left
+    }
+    return left + "." + right
+  }
+  return node.Text()
+}
+
+func metadata_node_source_text(node *nativeast.Node) string {
+  if node == nil {
+    return ""
+  }
+  file := nativeast.GetSourceFileOfNode(node)
+  if file == nil {
+    return ""
+  }
+  source := file.Text()
+  start, end := node.Pos(), node.End()
+  if start < 0 || end > len(source) || start >= end {
+    return ""
+  }
+  return strings.TrimSpace(source[start:end])
 }
 
 func metadata_js_doc_type_expression_text(tag *nativeast.Node) string {

package/native/core/factories/internal/metadata/iterate_metadata.go

@@ -12,7 +12,7 @@ func Iterate_metadata(props IMetadataIteratorProps) {
   if props.Type.IsTypeParameter() == true {
     if props.Errors != nil {
       *props.Errors = append(*props.Errors, MetadataFactory_IError{
-        Name:     metadata_type_full_name(props.Checker, props.Type),
+        Name:     metadata_type_full_name(props.Checker, props.Type, props.Components),
         Explore:  props.Explore,
         Messages: []string{"non-specified generic argument found."},
       })

package/native/core/factories/internal/metadata/iterate_metadata_map.go

@@ -11,7 +11,7 @@ func Iterate_metadata_map(props IMetadataIteratorProps) bool {
     return false
   }
   typ := props.Checker.GetApparentType(props.Type)
-  name := metadata_type_full_name(props.Checker, typ)
+  name := metadata_type_full_name(props.Checker, typ, props.Components)
   if strings.HasPrefix(name, "Map<") == false {
     return false
   }

package/native/core/factories/internal/metadata/iterate_metadata_set.go

@@ -11,7 +11,7 @@ func Iterate_metadata_set(props IMetadataIteratorProps) bool {
     return false
   }
   typ := props.Checker.GetApparentType(props.Type)
-  name := metadata_type_full_name(props.Checker, typ)
+  name := metadata_type_full_name(props.Checker, typ, props.Components)
   if strings.HasPrefix(name, "Set<") == false {
     return false
   }

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

@@ -454,12 +454,14 @@ func llmApplicationProgrammer_validateFunction(name string, fn *schemametadata.M
   return messages
 }
 
+var llmApplicationProgrammer_namePattern = regexp.MustCompile(`^[a-zA-Z0-9_-]+$`)
+
 func llmApplicationProgrammer_validateName(prefix string, name string) []string {
   output := []string{}
-  if len(name) != 0 && regexp.MustCompile(`^[0-9]`).MatchString(name[:1]) {
+  if len(name) != 0 && name[0] >= '0' && name[0] <= '9' {
     output = append(output, prefix+" name cannot start with a number.")
   }
-  if regexp.MustCompile(`^[a-zA-Z0-9_-]+$`).MatchString(name) == false {
+  if llmApplicationProgrammer_namePattern.MatchString(name) == false {
     output = append(output, prefix+" name must contain only alphanumeric characters, underscores, or hyphens.")
   }
   if len(name) > 64 {

package/native/core/programmers/protobuf/ProtobufMessageProgrammer.go

@@ -26,6 +26,7 @@ type protobufMessageProgrammer_Hierarchy struct {
   Key      string
   Object   *schemametadata.MetadataObjectType
   Children map[string]*protobufMessageProgrammer_Hierarchy
+  Order    []string
 }
 
 var protobufMessageProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
@@ -86,14 +87,12 @@ func protobufMessageProgrammer_emplace(hierarchies map[string]*protobufMessagePr
       *currentOrder = append(*currentOrder, access)
     }
     current = hierarchy.Children
+    // Track insertion order per level. Ranging the Children map directly (as the
+    // emit pass previously did) made nested message output non-deterministic.
+    currentOrder = &hierarchy.Order
     if i == len(accessors)-1 {
       hierarchy.Object = object
     }
-    childOrder := []string{}
-    for key := range current {
-      childOrder = append(childOrder, key)
-    }
-    currentOrder = &childOrder
   }
   return order
 }
@@ -111,11 +110,7 @@ func protobufMessageProgrammer_write_hierarchy(hierarchy *protobufMessageProgram
     }
   }
   if len(hierarchy.Children) != 0 {
-    keys := make([]string, 0, len(hierarchy.Children))
-    for key := range hierarchy.Children {
-      keys = append(keys, key)
-    }
-    for _, key := range keys {
+    for _, key := range hierarchy.Order {
       body := protobufMessageProgrammer_write_hierarchy(hierarchy.Children[key])
       lines := strings.Split(body, "\n")
       for i, line := range lines {

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

@@ -1,6 +1,8 @@
 package metadata
 
 import (
+  "maps"
+  "slices"
   "strings"
 
   nativeast "github.com/microsoft/typescript-go/shim/ast"
@@ -27,11 +29,35 @@ type MetadataCollection struct {
   tuples_order_        []*nativechecker.Type
 
   names_                 map[string]map[*nativechecker.Type]string
+  type_full_names_       map[*nativechecker.Type]string
+  full_names_            map[*nativechecker.Type]string
   object_index_          int
   recursive_array_index_ int
   recursive_tuple_index_ int
 }
 
+// LookupTypeFullName / StoreTypeFullName memoize the pure type -> full-name
+// reconstruction (checker.TypeToString, recursing unions) per collection. The
+// Set/Map iterators recompute it for every explored type just to test a name
+// prefix, so the same pointer is resolved repeatedly within one analysis.
+func (collection *MetadataCollection) LookupTypeFullName(typ *nativechecker.Type) (string, bool) {
+  if collection.type_full_names_ == nil {
+    return "", false
+  }
+  value, ok := collection.type_full_names_[typ]
+  return value, ok
+}
+
+func (collection *MetadataCollection) StoreTypeFullName(typ *nativechecker.Type, name string) {
+  if typ == nil {
+    return
+  }
+  if collection.type_full_names_ == nil {
+    collection.type_full_names_ = map[*nativechecker.Type]string{}
+  }
+  collection.type_full_names_[typ] = name
+}
+
 func NewMetadataCollection(options ...*MetadataCollection_IOptions) *MetadataCollection {
   var opt *MetadataCollection_IOptions
   if len(options) > 0 {
@@ -60,37 +86,36 @@ func NewMetadataCollection(options ...*MetadataCollection_IOptions) *MetadataCol
 }
 
 func (collection *MetadataCollection) Clone() *MetadataCollection {
-  output := NewMetadataCollection(collection.Options)
-  for k, v := range collection.objects_ {
-    output.objects_[k] = v
+  // Clone is the snapshot taken before every intersection exploration, so it is
+  // one of the hottest allocation sites. Pre-size each destination map (maps.Clone)
+  // instead of copying into the empty maps NewMetadataCollection allocates, which
+  // forced repeated rehashing as entries were re-inserted.
+  output := &MetadataCollection{
+    Options: collection.Options,
+
+    objects_:       maps.Clone(collection.objects_),
+    object_unions_: make(map[string][]*MetadataObjectType, len(collection.object_unions_)),
+    aliases_:       maps.Clone(collection.aliases_),
+    arrays_:        maps.Clone(collection.arrays_),
+    tuples_:        maps.Clone(collection.tuples_),
+
+    objects_order_:       slices.Clone(collection.objects_order_),
+    object_unions_order_: slices.Clone(collection.object_unions_order_),
+    aliases_order_:       slices.Clone(collection.aliases_order_),
+    arrays_order_:        slices.Clone(collection.arrays_order_),
+    tuples_order_:        slices.Clone(collection.tuples_order_),
+
+    names_:                 make(map[string]map[*nativechecker.Type]string, len(collection.names_)),
+    object_index_:          collection.object_index_,
+    recursive_array_index_: collection.recursive_array_index_,
+    recursive_tuple_index_: collection.recursive_tuple_index_,
   }
   for k, v := range collection.object_unions_ {
-    output.object_unions_[k] = append([]*MetadataObjectType{}, v...)
+    output.object_unions_[k] = slices.Clone(v)
   }
-  for k, v := range collection.aliases_ {
-    output.aliases_[k] = v
-  }
-  for k, v := range collection.arrays_ {
-    output.arrays_[k] = v
-  }
-  for k, v := range collection.tuples_ {
-    output.tuples_[k] = v
-  }
-  output.objects_order_ = append([]*nativechecker.Type{}, collection.objects_order_...)
-  output.object_unions_order_ = append([]string{}, collection.object_unions_order_...)
-  output.aliases_order_ = append([]*nativechecker.Type{}, collection.aliases_order_...)
-  output.arrays_order_ = append([]*nativechecker.Type{}, collection.arrays_order_...)
-  output.tuples_order_ = append([]*nativechecker.Type{}, collection.tuples_order_...)
   for k, v := range collection.names_ {
-    duplicates := map[*nativechecker.Type]string{}
-    for kt, vt := range v {
-      duplicates[kt] = vt
-    }
-    output.names_[k] = duplicates
+    output.names_[k] = maps.Clone(v)
   }
-  output.object_index_ = collection.object_index_
-  output.recursive_array_index_ = collection.recursive_array_index_
-  output.recursive_tuple_index_ = collection.recursive_tuple_index_
   return output
 }
 
@@ -145,7 +170,22 @@ func (collection *MetadataCollection) Tuples() []*MetadataTupleType {
 }
 
 func (collection *MetadataCollection) getName(checker *nativechecker.Checker, typ *nativechecker.Type) string {
-  name := metadataCollection_getFullName(checker, typ)
+  // metadataCollection_getFullName (checker.TypeToString, recursing generics and
+  // unions) is pure for a given type pointer, but the duplicate-numbering logic
+  // below calls getName again for the same type. Cache only the full-name
+  // reconstruction; the numbering bookkeeping still runs every call so ordering
+  // is unaffected.
+  fullName, ok := collection.full_names_[typ]
+  if ok == false {
+    fullName = metadataCollection_getFullName(checker, typ)
+    if typ != nil {
+      if collection.full_names_ == nil {
+        collection.full_names_ = map[*nativechecker.Type]string{}
+      }
+      collection.full_names_[typ] = fullName
+    }
+  }
+  name := fullName
   name = strings.ToValidUTF8(name, "__")
   name = strings.ReplaceAll(name, "\uFFFD", "__")
   if collection.Options != nil && collection.Options.Replace != nil {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "13.0.0-dev.20260520.2",
+  "version": "13.0.0-dev.20260601.1",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "exports": {
@@ -44,8 +44,8 @@
     "commander": "^10.0.0",
     "inquirer": "^8.2.5",
     "randexp": "^0.5.3",
-    "@typia/interface": "^13.0.0-dev.20260520.2",
-    "@typia/utils": "^13.0.0-dev.20260520.2"
+    "@typia/interface": "^13.0.0-dev.20260601.1",
+    "@typia/utils": "^13.0.0-dev.20260601.1"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^29.0.0",
@@ -54,7 +54,7 @@
     "@types/node": "^25.3.0",
     "@typescript-eslint/eslint-plugin": "^8.1.0",
     "@typescript-eslint/parser": "^8.1.0",
-    "@typescript/native-preview": "7.0.0-dev.20260519.1",
+    "@typescript/native-preview": "7.0.0-dev.20260527.2",
     "chalk": "^4.0.0",
     "eslint-plugin-deprecation": "^3.0.0",
     "rimraf": "^6.1.2",
@@ -63,7 +63,7 @@
     "rollup-plugin-node-externals": "^8.1.2",
     "suppress-warnings": "^1.0.2",
     "tinyglobby": "^0.2.12",
-    "ttsc": "^0.12.3"
+    "ttsc": "^0.14.1"
   },
   "sideEffects": [
     "./lib/_virtual/*.mjs",