typia 13.1.1 → 13.1.19

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

@@ -0,0 +1,147 @@
+package metadata
+
+import (
+  "regexp"
+  "testing"
+)
+
+// TestMetadataCollectionNameAllocation verifies every minted component id is
+// unique across the whole collection rather than within its base-name bucket.
+//
+// The allocator used to key its bookkeeping on the base name and mint
+// `<Base>.o<N>` without ever comparing that id against the ids already handed
+// out. A type whose real full name was exactly `Foo.o1` therefore collided with
+// the id minted for a second `Foo`, one of the two schemas was dropped from the
+// document outright, and the surviving `$ref` documented the wrong type.
+//
+// The per-base counter that survives is an optimization only. Uniqueness must
+// rest on the taken set, so a stale or wrong counter has to cost a scan rather
+// than a collision.
+//
+//  1. Allocate a free base name, then its duplicates in order.
+//  2. Allocate against a taken set that already owns every id a base name would
+//     mint, including the ids its minted ids would mint.
+//  3. Prove a real type's name is never overwritten by an invented one, in
+//     either discovery order.
+//  4. Prove a cross-base-name collision, which no counter can see, is still
+//     kept apart by the set.
+//  5. Prove the counter is honored when it is right and overridden when it is
+//     wrong.
+func TestMetadataCollectionNameAllocation(t *testing.T) {
+  grammar := regexp.MustCompile(`^[a-zA-Z0-9.\-_]+$`)
+  allocate := func(taken map[string]bool, name string, from int) string {
+    allocated, index := metadataCollection_allocateName(taken, name, from)
+    if index < from {
+      t.Fatalf("allocator moved the counter backwards: name=%q from=%d index=%d", name, from, index)
+    }
+    taken[allocated] = true
+    return allocated
+  }
+
+  // 1. A FREE NAME KEEPS ITSELF; DUPLICATES COUNT UP
+  taken := map[string]bool{}
+  ordered := []string{}
+  for i := 0; i != 3; i++ {
+    ordered = append(ordered, allocate(taken, "Foo", i))
+  }
+  if ordered[0] != "Foo" {
+    t.Fatalf("a free base name lost its own name: actual=%q", ordered[0])
+  }
+  for i, allocated := range ordered {
+    for j, other := range ordered {
+      if i != j && allocated == other {
+        t.Fatalf("duplicate allocation collided: index=%d other=%d id=%q", i, j, allocated)
+      }
+    }
+    if grammar.MatchString(allocated) == false {
+      t.Fatalf("illegal allocated component key: id=%q", allocated)
+    }
+  }
+
+  // 2. A MINTED ID NEVER SQUATS A NAME ANOTHER TYPE ALREADY OWNS
+  //
+  // Every id these base names can mint is pre-taken by the loop itself, so the
+  // allocator can only pass by consulting the whole taken set.
+  for _, name := range []string{"Foo", "Qualified.Member", "Escaped-x0", "_"} {
+    reserved := map[string]bool{}
+    for i := 0; i != 8; i++ {
+      allocated, _ := metadataCollection_allocateName(reserved, name, 0)
+      if reserved[allocated] {
+        t.Fatalf("allocator handed out a taken id: name=%q id=%q", name, allocated)
+      }
+      if grammar.MatchString(allocated) == false {
+        t.Fatalf("illegal allocated component key: name=%q id=%q", name, allocated)
+      }
+      reserved[allocated] = true
+    }
+  }
+
+  // 3. A REAL TYPE'S NAME IS NEVER OVERWRITTEN BY AN INVENTED ONE
+  //
+  // The real `namespace Foo { interface o1 }` member owns `Foo.o1`. Whichever
+  // order the two arrive in, both must survive with distinct ids.
+  for _, order := range [][]string{
+    {"Foo", "Foo", "Foo.o1"},
+    {"Foo.o1", "Foo", "Foo"},
+  } {
+    reserved := map[string]bool{}
+    counters := map[string]int{}
+    allocations := []string{}
+    for _, name := range order {
+      allocated, index := metadataCollection_allocateName(reserved, name, counters[name])
+      reserved[allocated] = true
+      counters[name] = index + 1
+      allocations = append(allocations, allocated)
+    }
+    if len(reserved) != len(order) {
+      t.Fatalf("distinct types collapsed onto one id: order=%v allocations=%v", order, allocations)
+    }
+  }
+
+  // 4. A COUNTER CANNOT SEE ACROSS BASE NAMES; THE TAKEN SET CAN
+  //
+  // This is the class the set exists for, and nothing else covers it. A second
+  // `GenNs` mints `GenNs-o1` from its own counter, while `Gen<Ns.o1>` normalizes
+  // to the base name `GenNs-o1` and mints that from a different counter. Neither
+  // counter can see the other. Both orders must keep three types apart.
+  for _, order := range [][]string{
+    {"GenNs", "GenNs", "Gen<Ns.o1>"},
+    {"Gen<Ns.o1>", "GenNs", "GenNs"},
+  } {
+    reserved := map[string]bool{}
+    counters := map[string]int{}
+    allocations := []string{}
+    for _, declared := range order {
+      name := MetadataCollection_replaceOpenApi(declared)
+      allocated, index := metadataCollection_allocateName(reserved, name, counters[name])
+      reserved[allocated] = true
+      counters[name] = index + 1
+      allocations = append(allocations, allocated)
+    }
+    if len(reserved) != len(order) {
+      t.Fatalf("a cross-base-name collision dropped a type: order=%v allocations=%v", order, allocations)
+    }
+  }
+
+  // 5. THE COUNTER IS AN OPTIMIZATION, NOT THE UNIQUENESS ARGUMENT
+  //
+  // A right counter settles where it starts, and that returned index is the
+  // whole point: every anonymous type shares the name `__type`, so an allocator
+  // that rescanned the run from zero each time would be quadratic in a
+  // program's anonymous type count.
+  run := map[string]bool{}
+  for i := 0; i != 64; i++ {
+    run[metadataCollection_composeName("__type", i)] = true
+  }
+  if _, index := metadataCollection_allocateName(run, "__type", 64); index != 64 {
+    t.Fatalf("a correct counter was not honored: index=%d expected=64", index)
+  }
+  // A wrong counter costs a scan, never a collision.
+  allocated, index := metadataCollection_allocateName(run, "__type", 0)
+  if run[allocated] {
+    t.Fatalf("a stale counter handed out a taken id: id=%q", allocated)
+  }
+  if index != 64 {
+    t.Fatalf("a stale counter did not scan to the first free id: index=%d expected=64", index)
+  }
+}

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

@@ -0,0 +1,55 @@
+package metadata
+
+import (
+  "strings"
+  "testing"
+)
+
+// TestMetadataCollectionOpenApiNameCascade verifies the allocator never invents
+// a namespace parent for an escaped component name.
+//
+// JsonDescriptor.cascade reads every dotted prefix of a component key as a
+// parent namespace and inherits that parent's description. A disambiguating
+// suffix joined with "." would therefore present an escaped name's own base as
+// a fake parent, and an unrelated component owning that base would leak its
+// description into the escaped type's schema.
+//
+//  1. Allocate a legal name and the escaped name that shares its base.
+//  2. Collect every dotted prefix each allocation exposes.
+//  3. Require no allocation to expose another allocation as its parent.
+func TestMetadataCollectionOpenApiNameCascade(t *testing.T) {
+  inputs := []string{
+    "A_x2F_B",
+    "A/B",
+    "Recursive",
+    `Recursive<"">`,
+    `Recursive<"A/B">`,
+    "Qualified.Member",
+    "Café",
+    "$Plain",
+    "",
+  }
+  allocated := map[string]string{}
+  for _, input := range inputs {
+    output := MetadataCollection_replaceOpenApi(input)
+    if previous, ok := allocated[output]; ok {
+      t.Fatalf("allocation collided: %q and %q both produced %q", previous, input, output)
+    }
+    allocated[output] = input
+  }
+  for output, input := range allocated {
+    segments := strings.Split(output, ".")
+    for i := 1; i < len(segments); i++ {
+      parent := strings.Join(segments[:i], ".")
+      if owner, ok := allocated[parent]; ok {
+        t.Fatalf(
+          "allocation %q (from %q) claims unrelated allocation %q (from %q) as a namespace parent",
+          output,
+          input,
+          parent,
+          owner,
+        )
+      }
+    }
+  }
+}

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

@@ -0,0 +1,68 @@
+package metadata
+
+import (
+  "regexp"
+  "testing"
+)
+
+// TestMetadataCollectionOpenApiName verifies the OpenAPI-specific metadata
+// name allocator preserves legal controls while encoding every other rune.
+//
+// The schema generators use the allocated name as both a Components Object
+// key and a local-reference token. Deleting punctuation is insufficient:
+// distinct names can collapse, and the surviving key can still violate OAS.
+//
+//  1. Preserve ordinary, dotted, hyphenated, and underscored legal controls.
+//  2. Encode empty, punctuation, percent, fragment, and Unicode boundaries.
+//  3. Prove formerly colliding inputs remain legal, distinct, and repeatable.
+func TestMetadataCollectionOpenApiName(t *testing.T) {
+  legal := map[string]string{
+    "Plain":            "Plain",
+    "Qualified.Member": "Qualified.Member",
+    "A-B":              "A-B",
+    "A_B":              "A_B",
+    "A_x2F_B":          "A_x2F_B",
+    "_":                "_",
+    "Recursive":        "Recursive",
+  }
+  outputs := map[string]string{}
+  for input, expected := range legal {
+    actual := MetadataCollection_replaceOpenApi(input)
+    if actual != expected {
+      t.Fatalf("legal OpenAPI component name changed: input=%q actual=%q expected=%q", input, actual, expected)
+    }
+    outputs[actual] = input
+  }
+
+  inputs := []string{
+    "",
+    "$Plain",
+    "A/B",
+    `Recursive<"">`,
+    `Recursive<"A/B">`,
+    `Recursive<"T~N">`,
+    `Recursive<"C%D">`,
+    `Recursive<"A#B">`,
+    `Recursive<"A B">`,
+    `Recursive<"A:B">`,
+    `Recursive<"AB">`,
+    `Recursive<"///">`,
+    "Café",
+    "한글",
+  }
+  grammar := regexp.MustCompile(`^[a-zA-Z0-9.\-_]+$`)
+  for _, input := range inputs {
+    first := MetadataCollection_replaceOpenApi(input)
+    second := MetadataCollection_replaceOpenApi(input)
+    if first != second {
+      t.Fatalf("OpenAPI component allocation is not repeatable: input=%q first=%q second=%q", input, first, second)
+    }
+    if grammar.MatchString(first) == false {
+      t.Fatalf("illegal OpenAPI component name: input=%q output=%q", input, first)
+    }
+    if previous, ok := outputs[first]; ok && previous != input {
+      t.Fatalf("OpenAPI component allocation collided: first=%q second=%q output=%q", previous, input, first)
+    }
+    outputs[first] = input
+  }
+}

package/native/core/utils/PatternUtil.go

@@ -38,6 +38,19 @@ func (patternUtilNamespace) Escape(str string) string {
       builder.WriteRune(ch)
     case '-':
       builder.WriteString("\\x2d")
+    // The four ECMAScript LineTerminators cannot appear raw inside a regex
+    // literal (`RegExp(/.../)`) -- the sink every structural pattern feeds -- so a
+    // raw one turns the emitted module into a SyntaxError. Emit the regex escape
+    // instead; it stays valid in the literal and keeps matching the terminator
+    // (#2211).
+    case '\n':
+      builder.WriteString("\\n")
+    case '\r':
+      builder.WriteString("\\r")
+    case '\u2028':
+      builder.WriteString("\\u2028")
+    case '\u2029':
+      builder.WriteString("\\u2029")
     default:
       builder.WriteRune(ch)
     }

package/native/core/utils/PromiseTypeFactory.go

@@ -0,0 +1,59 @@
+package utils
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+type promiseTypeFactoryNamespace struct{}
+
+var PromiseTypeFactory = promiseTypeFactoryNamespace{}
+
+type PromiseTypeFactory_IOutput struct {
+  Type  *shimchecker.Type
+  Async bool
+}
+
+func (promiseTypeFactoryNamespace) Resolve(checker *shimchecker.Checker, t *shimchecker.Type) PromiseTypeFactory_IOutput {
+  if checker != nil && t != nil {
+    promised := checker.GetPromisedTypeOfPromise(t)
+    if promised != nil && PromiseTypeFactory.satisfiesGlobalContract(checker, t) {
+      return PromiseTypeFactory_IOutput{
+        Type:  promised,
+        Async: true,
+      }
+    }
+  }
+  return PromiseTypeFactory_IOutput{
+    Type:  t,
+    Async: false,
+  }
+}
+
+func (promiseTypeFactoryNamespace) satisfiesGlobalContract(checker *shimchecker.Checker, t *shimchecker.Type) bool {
+  symbol := checker.GetGlobalSymbol("Promise", shimast.SymbolFlagsValue, nil)
+  if symbol == nil {
+    return false
+  }
+  constructor := checker.GetTypeOfSymbol(symbol)
+  if constructor == nil {
+    return false
+  }
+  contract := checker.GetTypeOfPropertyOfType(constructor, "prototype")
+  if contract == nil {
+    return false
+  }
+  for _, property := range checker.GetPropertiesOfType(contract) {
+    if property.Name == "then" || (len(property.Name) != 0 && property.Name[0] == 0xfe) {
+      // GetPromisedTypeOfPromise verifies the thenable shape. Conditional
+      // Promise inference ignores well-known-symbol augmentations.
+      continue
+    }
+    required := checker.GetTypeOfPropertyOfType(contract, property.Name)
+    candidate := checker.GetTypeOfPropertyOfType(t, property.Name)
+    if required == nil || candidate == nil || !checker.IsTypeAssignableTo(candidate, required) {
+      return false
+    }
+  }
+  return true
+}

package/native/core/utils/ProtobufNameEncoder.go

@@ -44,4 +44,12 @@ var protobufNameEncoder_replacers = []protobufNameEncoder_replacer{
   {Before: "'", After: "_singlequote_"},
   {Before: "\"", After: "_doublequote_"},
   {Before: " ", After: "_space_"},
+  // A Protocol Buffers message name is an identifier, so a hyphen has to be
+  // encoded like any other rune the grammar rejects. It is not exotic: the
+  // metadata collection joins a duplicated name's counter with one, and a
+  // quoted type argument can carry one of its own, as `Gen<"a-b">` does. The
+  // dot is deliberately absent from this table — `protobufMessageProgrammer_emplace`
+  // splits a name on it to nest a namespace member in its parent's message, and
+  // a qualified reference is legal in the grammar.
+  {Before: "-", After: "_hyphen_"},
 }

package/native/core/utils/promise_type_factory_semantics_test.go

@@ -0,0 +1,118 @@
+package utils
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestPromiseTypeFactorySemantics verifies semantic promised-type resolution.
+//
+// Promise identity is structural in the checker rather than a symbol spelling.
+// Derived classes, interfaces, and branded intersections must unwrap while an
+// unrelated class named Promise and weaker PromiseLike contracts must remain
+// synchronous, even when a thenable adds only part of the Promise surface.
+//
+//  1. Load ten return-shape declarations through the real checker.
+//  2. Resolve the fulfilled type for every genuine Promise shape.
+//  3. Reject plain, partial, and malformed PromiseLike controls without replacing their types.
+func TestPromiseTypeFactorySemantics(t *testing.T) {
+  dir := t.TempDir()
+  if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(`{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}`), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.MkdirAll(filepath.Join(dir, "src"), 0o755); err != nil {
+    t.Fatalf("mkdir src: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(dir, "src", "main.ts"), []byte(`
+class DerivedPromise<T> extends Promise<T> {}
+interface InterfacePromise<T> extends Promise<T> {}
+type BrandedPromise<T> = Promise<T> & { readonly __brand: unique symbol };
+type CatchablePromiseLike<T> = PromiseLike<T> & {
+  catch(onrejected?: (reason: any) => any): CatchablePromiseLike<T>;
+};
+type MalformedPromiseLike<T> = PromiseLike<T> & {
+  catch(): number;
+  finally(): number;
+};
+namespace Shadow { export class Promise<T> { public constructor(public value: T) {} } }
+let builtin!: Promise<string>;
+let derivedClass!: DerivedPromise<number>;
+let derivedInterface!: InterfacePromise<boolean>;
+let branded!: BrandedPromise<bigint>;
+let shadowed!: Shadow.Promise<Date>;
+let synchronous!: { value: RegExp };
+let promiseLike!: PromiseLike<string>;
+let structural!: Pick<Promise<URL>, "then" | "catch" | "finally">;
+let catchablePromiseLike!: CatchablePromiseLike<string>;
+let malformedPromiseLike!: MalformedPromiseLike<string>;
+const structuralBoundary: Pick<Promise<URL>, "then" | "catch" | "finally"> extends Promise<infer _> ? true : false = true;
+const catchableBoundary: CatchablePromiseLike<string> extends Promise<infer _> ? true : false = false;
+const malformedBoundary: MalformedPromiseLike<string> extends Promise<infer _> ? true : false = false;
+`), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  program, diagnostics, err := driver.LoadProgram(dir, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatalf("load program: %v", err)
+  }
+  if len(diagnostics) != 0 {
+    t.Fatalf("fixture diagnostics: %+v", diagnostics)
+  }
+  defer program.Close()
+
+  source := program.SourceFile(filepath.Join(dir, "src", "main.ts"))
+  if source == nil || source.Statements == nil || len(source.Statements.Nodes) != 19 {
+    t.Fatal("fixture declarations were not loaded")
+  }
+  variableType := func(index int) *shimchecker.Type {
+    declaration := source.Statements.Nodes[index].AsVariableStatement().DeclarationList.AsVariableDeclarationList().Declarations.Nodes[0]
+    return program.Checker.GetTypeAtLocation(declaration)
+  }
+  tests := []struct {
+    name      string
+    index     int
+    async     bool
+    fulfilled string
+  }{
+    {"builtin", 6, true, "string"},
+    {"derived-class", 7, true, "number"},
+    {"derived-interface", 8, true, "boolean"},
+    {"branded-intersection", 9, true, "bigint"},
+    {"shadowed-name", 10, false, ""},
+    {"synchronous", 11, false, ""},
+    {"promise-like", 12, false, ""},
+    {"structural", 13, true, "URL"},
+    {"catchable-promise-like", 14, false, ""},
+    {"malformed-promise-like", 15, false, ""},
+  }
+  for _, tc := range tests {
+    t.Run(tc.name, func(t *testing.T) {
+      input := variableType(tc.index)
+      output := PromiseTypeFactory.Resolve(program.Checker, input)
+      if output.Async != tc.async {
+        t.Fatalf("async mismatch: got %v, want %v", output.Async, tc.async)
+      }
+      if tc.async {
+        if got := program.Checker.TypeToString(output.Type); got != tc.fulfilled {
+          t.Fatalf("fulfilled type mismatch: got %q, want %q", got, tc.fulfilled)
+        }
+      } else if output.Type != input {
+        t.Fatal("non-Promise type was replaced")
+      }
+    })
+  }
+}

package/native/go.mod

@@ -2,6 +2,14 @@ module github.com/samchon/typia/packages/typia/native
 
 go 1.26
 
+// Build-time floor: the driver reference-graph SDK
+// (driver.NewTransformGraph / driver.TransformGraph / driver.TransformOutputKey)
+// this plugin consumes exists only in ttsc >= 0.19.2. That floor is enforced
+// through typia's package.json peerDependencies (ttsc / @ttsc/unplugin), not
+// here: ttsc builds this plugin from source on the user's machine and its
+// buildSourcePlugin generates `replace github.com/samchon/ttsc/packages/ttsc
+// v0.0.0 => <installed ttsc root>`, so the require below must stay v0.0.0 or the
+// generated replace no longer matches and the plugin build fails to resolve.
 require (
 	github.com/microsoft/typescript-go/shim/ast v0.0.0
 	github.com/microsoft/typescript-go/shim/checker v0.0.0
@@ -11,6 +19,7 @@ require (
 	github.com/microsoft/typescript-go/shim/printer v0.0.0
 	github.com/microsoft/typescript-go/shim/scanner v0.0.0
 	github.com/samchon/ttsc/packages/ttsc v0.0.0
+	golang.org/x/text v0.36.0
 )
 
 require (
@@ -27,5 +36,4 @@ require (
 	github.com/zeebo/xxh3 v1.1.0 // indirect
 	golang.org/x/sync v0.20.0 // indirect
 	golang.org/x/sys v0.43.0 // indirect
-	golang.org/x/text v0.36.0 // indirect
 )

package/native/transform/CallExpressionTransformer.go

@@ -9,6 +9,7 @@ import (
   nativeprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers"
   nativefunctionalprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/functional"
   nativenotationprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/notations"
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
   nativefeatures "github.com/samchon/typia/packages/typia/native/transform/features"
   nativecomparetransformers "github.com/samchon/typia/packages/typia/native/transform/features/compare"
   nativefunctionaltransformers "github.com/samchon/typia/packages/typia/native/transform/features/functional"
@@ -86,6 +87,17 @@ func (callExpressionTransformerNamespace) TransformKnown(props CallExpressionTra
   if ok == false {
     return props.Expression.AsNode()
   }
+  // Report the WRITTEN type arguments of the typia call to the dependency
+  // listener (project transform mode only; a no-op otherwise). The metadata
+  // analysis touches every checker type it reads, but a top-level alias of an
+  // intrinsic (`typia.validate<Id>()` with `type Id = string` elsewhere) leaves
+  // no symbol on the resolved type, so the call site's own syntax is the only
+  // anchor that registers such an alias' declaring file.
+  if props.Expression.TypeArguments != nil {
+    for _, argument := range props.Expression.TypeArguments.Nodes {
+      schemametadata.MetadataDependency_touchTypeNode(props.Context.Checker, argument)
+    }
+  }
   // Keep the full callee expression (e.g. `typia.assertEquals`) as the modulo,
   // mirroring the TypeScript transformer. Programmers render it into the
   // TypeGuardError method label via nativehelpers.ModuloMethodText, which reads

package/native/transform/features/json/JsonApplicationTransformer.go

@@ -43,7 +43,7 @@ func (jsonApplicationTransformerNamespace) Transform(props nativetransform.ITran
 
   typ := props.Context.Checker.GetTypeFromTypeNode(top)
   collection := schemametadata.NewMetadataCollection(&schemametadata.MetadataCollection_IOptions{
-    Replace: schemametadata.MetadataCollection_replace,
+    Replace: schemametadata.MetadataCollection_replaceOpenApi,
   })
   result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{
     Checker: props.Context.Checker,

package/native/transform/features/json/JsonSchemaTransformer.go

@@ -66,7 +66,7 @@ func (jsonSchemaTransformerNamespace) Transform(props nativetransform.ITransform
         Validate: validator,
       },
       Components: schemametadata.NewMetadataCollection(&schemametadata.MetadataCollection_IOptions{
-        Replace: schemametadata.MetadataCollection_replace,
+        Replace: schemametadata.MetadataCollection_replaceOpenApi,
       }),
       Type: typ,
     })

package/native/transform/features/json/JsonSchemasTransformer.go

@@ -64,6 +64,9 @@ func (jsonSchemasTransformerNamespace) Transform(props nativetransform.ITransfor
   analyze := func(validate bool) []*schemametadata.MetadataSchema {
     metadatas := []*schemametadata.MetadataSchema{}
     errors := []nativefactories.MetadataFactory_IError{}
+    collection := schemametadata.NewMetadataCollection(&schemametadata.MetadataCollection_IOptions{
+      Replace: schemametadata.MetadataCollection_replaceOpenApi,
+    })
     var validator nativefactories.MetadataFactory_Validator
     if validate {
       validator = jsonTransformer_schemasValidator
@@ -77,10 +80,8 @@ func (jsonSchemasTransformerNamespace) Transform(props nativetransform.ITransfor
           Escape:   true,
           Validate: validator,
         },
-        Components: schemametadata.NewMetadataCollection(&schemametadata.MetadataCollection_IOptions{
-          Replace: schemametadata.MetadataCollection_replace,
-        }),
-        Type: typ,
+        Components: collection,
+        Type:       typ,
       })
       if result.Success == false {
         errors = append(errors, result.Errors...)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "13.1.1",
+  "version": "13.1.19",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "exports": {
@@ -50,8 +50,20 @@
     "inquirer": "^8.2.5",
     "randexp": "^0.5.3",
     "tinyglobby": "^0.2.12",
-    "@typia/interface": "^13.1.1",
-    "@typia/utils": "^13.1.1"
+    "@typia/interface": "^13.1.19",
+    "@typia/utils": "^13.1.19"
+  },
+  "peerDependencies": {
+    "@ttsc/unplugin": ">=0.19.2",
+    "ttsc": ">=0.19.2"
+  },
+  "peerDependenciesMeta": {
+    "@ttsc/unplugin": {
+      "optional": true
+    },
+    "ttsc": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@types/inquirer": "^8.2.5",
@@ -60,7 +72,7 @@
     "rimraf": "^6.1.2",
     "rolldown": "^1.1.5",
     "suppress-warnings": "^1.0.2",
-    "ttsc": "^0.18.4",
+    "ttsc": "^0.19.2",
     "typescript": "^7.0.2"
   },
   "sideEffects": false,