typia 15.2.0 → 15.2.1

package/native/cmd/ttsc-typia/json_schema_recursive_array_alias_transform_test.go

@@ -0,0 +1,79 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestJsonSchemaRecursiveArrayAliasTransform verifies recursive arrays survive
+// analysis and produce finite, repeatable schema literals.
+//
+// The alias and array metadata may share an identity; constructed metadata alone
+// cannot establish which names the TypeScript checker actually supplies.
+//
+// 1. Transform recursive, constrained and nonrecursive declarations together.
+// 2. Compare named structural bodies and distinct use-site constraints.
+// 3. Repeat emission and require identical complete JavaScript bytes.
+//
+// @evidence contracts/testing.md#behavioral-verification Runs the native transform in process, decodes emitted schema literals and compares array bodies and tagged properties; complete output equality pins deterministic emission.
+// @evidence contracts/testing.md#independent-expectations The authored recursive type requires an array whose items reference the value union. Explicit max/min tags constrain different properties and must not modify an untagged sibling.
+// @evidence contracts/testing.md#distinguishing-cases Union-root and array-root traversal, two tagged sibling uses and an untagged sibling coexist with an ordinary array control; emitted identity and constraint placement are asserted separately.
+// @evidence contracts/testing.md#execution-ownership pnpm test:go:native discovers this test; runTransform and AST decoding execute in process using one fixture project, without compiler or JavaScript subprocesses.
+func TestJsonSchemaRecursiveArrayAliasTransform(t *testing.T) {
+  dir := ttscTypiaTestFixtureDirectory(t, "recursive-array-schema-")
+  if err := os.MkdirAll(filepath.Join(dir, "src"), 0o755); err != nil {
+    t.Fatal(err)
+  }
+  for name, source := range map[string]string{
+    "tsconfig.json": atomicIntersectionSchemaTSConfig,
+    "src/main.ts": `import typia, { tags } from "typia";
+type JsonArray = JsonValue[];
+type JsonObject = { [key: string]: JsonValue };
+type JsonValue = string | number | boolean | null | JsonArray | JsonObject;
+interface Constrained {
+  small: JsonArray & tags.MaxItems<1>;
+  many: JsonArray & tags.MinItems<2>;
+  plain: JsonArray;
+}
+export const schemas = typia.json.schemas<[JsonValue, JsonArray, Constrained, string[]]>();
+`,
+  } {
+    if err := os.WriteFile(filepath.Join(dir, filepath.FromSlash(name)), []byte(source), 0o644); err != nil {
+      t.Fatal(err)
+    }
+  }
+  var previous string
+  for i := 0; i < 3; i++ {
+    output, stderr, code := ttscTypiaTestCapture(func() int {
+      return runTransform([]string{"--cwd", dir, "--tsconfig", "tsconfig.json", "--file", "src/main.ts", "--output", "js"})
+    })
+    if code != 0 {
+      t.Fatalf("transform failed (%d): %s", code, stderr)
+    }
+    unit := ttscTypiaTestSchemaLiteral(t, output)
+    if i != 0 && output != previous {
+      t.Error("unchanged source produced different bytes")
+    }
+    previous = output
+    schemas := ttscTypiaTestSchemaPath(t, unit, "components", "schemas").(map[string]any)
+    body := schemas["JsonArray"].(map[string]any)
+    ttscTypiaTestSchemaEqual(t, body, map[string]any{"type": "array", "items": map[string]any{"$ref": "#/components/schemas/JsonValue"}})
+    properties := ttscTypiaTestSchemaPath(t, unit, "components", "schemas", "Constrained", "properties").(map[string]any)
+    for _, sample := range []struct {
+      name       string
+      constraint string
+      value      any
+    }{
+      {"small", "maxItems", float64(1)}, {"many", "minItems", float64(2)}, {"plain", "", nil},
+    } {
+      ref := properties[sample.name].(map[string]any)["$ref"].(string)
+      target := schemas[ref[len("#/components/schemas/"):]].(map[string]any)
+      expected := map[string]any{"type": "array", "items": map[string]any{"$ref": "#/components/schemas/JsonValue"}}
+      if sample.constraint != "" {
+        expected[sample.constraint] = sample.value
+      }
+      ttscTypiaTestSchemaEqual(t, target, expected)
+    }
+  }
+}

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

@@ -327,7 +327,10 @@ func Iterate_metadata_intersection(props IMetadataIteratorProps) bool {
   options := props.Options
   options.Functional = false
   explore := props.Explore
-  explore.Aliased = false
+  // Attach tags to the surviving structure, not to a new alias wrapper whose
+  // array/object bucket would be empty here. Nested members clear Aliased again
+  // when they descend, so recursive references still retain their aliases.
+  explore.Aliased = true
   explore.Escaped = false
   // Re-explore the surviving base alone (`Intersected: true` short-circuits the
   // intersection handler at the top of this function). TypeScript flattens nested

package/native/core/programmers/RandomProgrammer.go

@@ -806,7 +806,7 @@ func randomProgrammer_decode_array(props randomProgrammer_decodeArrayProps) []*s
     Components: components,
     Array:      props.Array,
   })
-  schemaList = randomProgrammer_array_schema_list(props.Array, components, schemaList)
+  schemaList = randomProgrammer_array_schema_list(components, schemaList)
   f := nativecontext.NodeFactoryOf(props.Context.Emit)
   output := make([]*shimast.Node, 0, len(schemaList))
   if props.Array.Type.Recursive {
@@ -1414,25 +1414,30 @@ func randomProgrammer_schema_without_items(schema nativeiterate.JsonSchema, emit
 }
 
 func randomProgrammer_array_schema_list(
-  array *schemametadata.MetadataArray,
   components *nativeiterate.OpenApi_IComponents,
   schemaList []nativeiterate.JsonSchema,
 ) []nativeiterate.JsonSchema {
-  if array == nil ||
-    array.Type == nil ||
-    array.Type.Recursive == false ||
-    components == nil ||
-    components.Schemas == nil {
+  if components == nil || components.Schemas == nil {
     return schemaList
   }
-  schema, ok := components.Schemas[array.Type.Name]
-  if ok == false || len(schema) == 0 {
-    return schemaList
-  }
-  if oneOf, ok := schema["oneOf"].([]nativeiterate.JsonSchema); ok {
-    return oneOf
+  output := make([]nativeiterate.JsonSchema, 0, len(schemaList))
+  for _, schema := range schemaList {
+    // The producer's reference identifies this use's component, which can
+    // differ from the underlying array type when schema tags are present.
+    ref, isReference := schema["$ref"].(string)
+    key, isLocal := strings.CutPrefix(ref, "#/components/schemas/")
+    target, exists := components.Schemas[key]
+    if !isReference || !isLocal || !exists || len(target) == 0 {
+      output = append(output, schema)
+      continue
+    }
+    if oneOf, ok := target["oneOf"].([]nativeiterate.JsonSchema); ok {
+      output = append(output, oneOf...)
+    } else {
+      output = append(output, target)
+    }
   }
-  return []nativeiterate.JsonSchema{schema}
+  return output
 }
 
 func randomProgrammer_internal(context nativecontext.ITypiaContext, name string) *shimast.Node {

package/native/core/programmers/internal/CheckerProgrammer.go

@@ -1240,7 +1240,7 @@ func checkerProgrammer_decode_array(props checkerProgrammer_decodeArrayProps) *s
   if props.Array.Type.Index != nil {
     index = *props.Array.Type.Index
   }
-  return checkerProgrammer_or(
+  main := checkerProgrammer_or(
     f.NewCallExpression(
       f.NewIdentifier(props.Functor.UseLocal(fmt.Sprintf("%sa%d", props.Config.Prefix, index))),
       nil,
@@ -1260,14 +1260,12 @@ func checkerProgrammer_decode_array(props checkerProgrammer_decodeArrayProps) *s
     }),
     props.Context.Emit,
   )
+  // Structural traversal is shared and visit-guarded, but this use's tags must
+  // be checked even when that helper has already visited the same array value.
+  return checkerProgrammer_check_array(props, main)
 }
 
 func checkerProgrammer_decode_array_inline(props checkerProgrammer_decodeArrayInlineProps) *shimast.Node {
-  length := nativeiterate.Check_array_length(nativeiterate.Check_array_lengthProps{
-    Context: props.Context,
-    Array:   props.Array,
-    Input:   props.Input,
-  })
   main := FeatureProgrammer.Decode_array(FeatureProgrammer_DecodeArrayProps{
     Config: FeatureProgrammer_DecodeArrayConfig{
       Prefix: props.Config.Prefix,
@@ -1299,6 +1297,15 @@ func checkerProgrammer_decode_array_inline(props checkerProgrammer_decodeArrayIn
     Explore: props.Explore,
     Emit:    props.Context.Emit,
   })
+  return checkerProgrammer_check_array(props, main)
+}
+
+func checkerProgrammer_check_array(props checkerProgrammer_decodeArrayProps, main *shimast.Node) *shimast.Node {
+  length := nativeiterate.Check_array_length(nativeiterate.Check_array_lengthProps{
+    Context: props.Context,
+    Array:   props.Array,
+    Input:   props.Input,
+  })
   if length.Expression == nil && len(length.Conditions) == 0 {
     return main
   }

package/native/core/programmers/iterate/json_schema_alias.go

@@ -25,38 +25,36 @@ func json_schema_alias(props struct {
     props.components.emplaceSchemaKey(props.alias.Type.Name)
     props.components.Schemas[props.alias.Type.Name] = JsonSchema{}
 
-    attribute := JsonSchema{}
-    if json_schema_has_tag(props.alias.Type.JsDocTags, "deprecated") {
-      attribute["deprecated"] = true
-    }
-    if title := json_schema_title(struct {
-      description *string
-      jsDocTags   []nativemetadata.IJsDocTagInfo
-    }{
-      description: props.alias.Type.Description,
-      jsDocTags:   props.alias.Type.JsDocTags,
-    }); title != nil {
-      attribute["title"] = *title
-    }
-    if description := json_schema_description(struct {
-      description *string
-      jsDocTags   []nativemetadata.IJsDocTagInfo
-    }{
-      description: props.alias.Type.Description,
-      jsDocTags:   props.alias.Type.JsDocTags,
-    }); description != nil {
-      attribute["description"] = *description
-    }
     schema := json_schema_station(json_schema_station_props{
       blockNever: props.blockNever,
       components: props.components,
-      attribute:  attribute,
+      attribute:  JsonSchema{},
       metadata:   props.alias.Type.Value,
+      definition: props.alias.Type.Name,
     })
     if schema != nil {
-      json_schema_jsDocTags(schema, props.alias.Type.JsDocTags)
       json_schema_assign(props.components.Schemas[props.alias.Type.Name], schema)
     }
   }
+  // An array may reserve this component before encountering its alias through
+  // an item. Apply alias annotations even to that in-progress definition; the
+  // structural owner subsequently fills the same map without losing them.
+  target := props.components.Schemas[props.alias.Type.Name]
+  if json_schema_has_tag(props.alias.Type.JsDocTags, "deprecated") {
+    target["deprecated"] = true
+  }
+  if title := json_schema_title(struct {
+    description *string
+    jsDocTags   []nativemetadata.IJsDocTagInfo
+  }{description: props.alias.Type.Description, jsDocTags: props.alias.Type.JsDocTags}); title != nil {
+    target["title"] = *title
+  }
+  if description := json_schema_description(struct {
+    description *string
+    jsDocTags   []nativemetadata.IJsDocTagInfo
+  }{description: props.alias.Type.Description, jsDocTags: props.alias.Type.JsDocTags}); description != nil {
+    target["description"] = *description
+  }
+  json_schema_jsDocTags(target, props.alias.Type.JsDocTags)
   return []JsonSchema{{"$ref": ref}}
 }

package/native/core/programmers/iterate/json_schema_array.go

@@ -17,6 +17,7 @@ type Json_schema_array_export_props struct {
 func json_schema_array(props struct {
   components *OpenApi_IComponents
   array      *nativemetadata.MetadataArray
+  definition string
 }) []JsonSchema {
   factory := func() []JsonSchema {
     return json_schema_plugin(struct {
@@ -35,27 +36,28 @@ func json_schema_array(props struct {
       tags: props.array.Tags,
     })
   }
-  if props.array.Type.Recursive {
+  key := props.components.arraySchemaName(props.array)
+  if props.array.Type.Recursive && key != props.definition {
     out := func() []JsonSchema {
-      return []JsonSchema{{"$ref": "#/components/schemas/" + props.array.Type.Name}}
+      return []JsonSchema{{"$ref": "#/components/schemas/" + key}}
     }
     if props.components.Schemas != nil {
-      if _, ok := props.components.Schemas[props.array.Type.Name]; ok {
+      if _, ok := props.components.Schemas[key]; ok {
         return out()
       }
     }
     if props.components.Schemas == nil {
       props.components.Schemas = map[string]JsonSchema{}
     }
-    if _, ok := props.components.Schemas[props.array.Type.Name]; ok == false {
-      props.components.emplaceSchemaKey(props.array.Type.Name)
-      props.components.Schemas[props.array.Type.Name] = JsonSchema{}
+    if _, ok := props.components.Schemas[key]; ok == false {
+      props.components.emplaceSchemaKey(key)
+      props.components.Schemas[key] = JsonSchema{}
     }
     oneOf := factory()
     if len(oneOf) == 1 {
-      json_schema_assign(props.components.Schemas[props.array.Type.Name], oneOf[0])
+      json_schema_assign(props.components.Schemas[key], oneOf[0])
     } else {
-      props.components.Schemas[props.array.Type.Name]["oneOf"] = oneOf
+      props.components.Schemas[key]["oneOf"] = oneOf
     }
     return out()
   }
@@ -65,9 +67,10 @@ func json_schema_array(props struct {
 // Json_schema_array_export converts an array type to its JSON schemas: an
 // `array` schema whose items come from the element metadata, or a reference to
 // the component of a recursive array type, which is registered the first time it
-// is met.
+// is met. Recursive uses with different schema tags get distinct components,
+// so a length constraint cannot leak into another use of the same array type.
 //
-// @evidence contracts/common.md#principled-implementation It converts an array type to its JSON schemas: an `array` schema whose items come from the element metadata, or a reference to the component of a recursive array type, which is registered the first time it is met.
+// @evidence contracts/common.md#principled-implementation A recursive array reserves its component before descending into items. Schema-bearing tags participate in component identity, and a same-named alias body is built inline instead of becoming its own reference. Nested stations retain references, terminating recursive expansion.
 // @evidence contracts/common.md#clear-and-simple-design One exported function; the pieces that repeat live in private helpers of the same file.
 // @evidence contracts/common.md#prohibited-implementation-shortcuts The only state it changes is the components record it is given.
 // @evidence contracts/common.md#meaningful-documentation The doc states what it builds.
@@ -75,6 +78,7 @@ func Json_schema_array_export(props Json_schema_array_export_props) []JsonSchema
   return json_schema_array(struct {
     components *OpenApi_IComponents
     array      *nativemetadata.MetadataArray
+    definition string
   }{
     components: props.Components,
     array:      props.Array,

package/native/core/programmers/iterate/json_schema_array_names.go

@@ -0,0 +1,113 @@
+package iterate
+
+import (
+  "encoding/json"
+  "strconv"
+
+  metadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+// ReserveSchemaNames reserves named definitions reachable from every root before
+// generated array-variant names are allocated. Callers sharing components across
+// several roots must supply all roots before generating any of them.
+//
+// @evidence contracts/common.md#principled-implementation A visited-set graph walk reserves aliases, arrays, tuples, objects and native names before variant allocation. Reserving all roots prevents a generated variant from taking a later declaration's name, including through recursive or shared edges.
+// @evidence contracts/common.md#clear-and-simple-design Component-local maps own both visited metadata and reserved names; the walk follows only edges consumed by schema generation.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Reservations use metadata identity and names, without fixture names or foreign mutations.
+// @evidence contracts/common.md#meaningful-documentation The comment states why reservations precede generation and the obligation for multiple roots.
+func (components *OpenApi_IComponents) ReserveSchemaNames(roots []*metadata.MetadataSchema) {
+  if components.reservedSchemaNames == nil {
+    components.reservedSchemaNames = map[string]bool{}
+    components.reservedMetadata = map[*metadata.MetadataSchema]bool{}
+  }
+  var visit func(*metadata.MetadataSchema)
+  visit = func(schema *metadata.MetadataSchema) {
+    if schema == nil || components.reservedMetadata[schema] {
+      return
+    }
+    components.reservedMetadata[schema] = true
+    for _, alias := range schema.Aliases {
+      components.reservedSchemaNames[alias.Type.Name] = true
+      visit(alias.Type.Value)
+    }
+    for _, array := range schema.Arrays {
+      components.reservedSchemaNames[array.Type.Name] = true
+      visit(array.Type.Value)
+    }
+    for _, tuple := range schema.Tuples {
+      components.reservedSchemaNames[tuple.Type.Name] = true
+      for _, element := range tuple.Type.Elements {
+        visit(element)
+      }
+    }
+    for _, object := range schema.Objects {
+      components.reservedSchemaNames[object.Type.Name] = true
+      for _, property := range object.Type.Properties {
+        visit(property.Value)
+      }
+    }
+    for _, native := range schema.Natives {
+      components.reservedSchemaNames[native.Name] = true
+    }
+    if schema.Escaped != nil {
+      visit(schema.Escaped.Returns)
+    }
+    visit(schema.Rest)
+  }
+  for _, root := range roots {
+    visit(root)
+  }
+}
+
+// arraySchemaName distinguishes recursive uses by the JSON schema tag rows that
+// actually affect emission. JSON map encoding is key-sorted, so equivalent schema
+// maps share an identity independently of their Go insertion order.
+func (components *OpenApi_IComponents) arraySchemaName(array *metadata.MetadataArray) string {
+  if !array.Type.Recursive {
+    return array.Type.Name
+  }
+  rows := [][]any{}
+  for _, row := range array.Tags {
+    schemas := []any{}
+    for _, tag := range row {
+      if tag.Schema != nil {
+        schemas = append(schemas, tag.Schema)
+      }
+    }
+    if len(schemas) != 0 {
+      rows = append(rows, schemas)
+    }
+  }
+  if len(rows) == 0 {
+    return array.Type.Name
+  }
+  encoded, err := json.Marshal(rows)
+  if err != nil {
+    panic("array schema tags must be JSON serializable: " + err.Error())
+  }
+  identity := array.Type.Name + "\x00" + string(encoded)
+  if key, ok := components.arraySchemaNames[identity]; ok {
+    return key
+  }
+  components.ReserveSchemaNames([]*metadata.MetadataSchema{{Arrays: []*metadata.MetadataArray{array}}})
+  base := array.Type.Name + "-array"
+  index := components.arraySchemaCounters[base]
+  key := base
+  if index != 0 {
+    key = base + "-" + strconv.Itoa(index)
+  }
+  for components.reservedSchemaNames[key] || components.Schemas[key] != nil {
+    index++
+    key = base + "-" + strconv.Itoa(index)
+  }
+  components.reservedSchemaNames[key] = true
+  if components.arraySchemaNames == nil {
+    components.arraySchemaNames = map[string]string{}
+  }
+  if components.arraySchemaCounters == nil {
+    components.arraySchemaCounters = map[string]int{}
+  }
+  components.arraySchemaNames[identity] = key
+  components.arraySchemaCounters[base] = index + 1
+  return key
+}

package/native/core/programmers/iterate/json_schema_native.go

@@ -6,10 +6,11 @@ import (
 )
 
 // OpenApi_IComponents is the `components` of a JSON schema document being built:
-// the named schemas and the order in which they were first registered.
+// the named schemas, their discovery order and the name reservations used by
+// tagged recursive array variants. All state belongs to one generated document.
 //
-// @evidence contracts/common.md#principled-implementation It is the `components` of a JSON schema document being built: the named schemas and the order in which they were first registered; its 2 fields (Schemas, Order) are named so that a producer and a consumer cannot transpose them.
-// @evidence contracts/common.md#clear-and-simple-design The schema map owns lookup while Order owns discovery sequence; registration and literal rendering are methods on that shared store.
+// @evidence contracts/common.md#principled-implementation Schemas owns component bodies and Order preserves registration sequence. Private reservations prevent generated array variants from colliding with declared names; their identity map distinguishes schema-bearing tag rows within one document.
+// @evidence contracts/common.md#clear-and-simple-design Public schema data stays separate from private allocation state. Registration, name reservation and literal rendering belong to the shared document store.
 // @evidence contracts/common.md#prohibited-implementation-shortcuts Registration records new keys before insertion and rendering follows the recorded sequence rather than relying on Go map iteration.
 // @evidence contracts/common.md#meaningful-documentation The doc states what the record is.
 type OpenApi_IComponents struct {
@@ -20,6 +21,12 @@ type OpenApi_IComponents struct {
   // collection was a plain object keyed in insertion order. A Go map is
   // unordered, so the bare map alone would scramble the keys.
   Order []string
+
+  // Private allocation state is discarded with this document after emission.
+  reservedSchemaNames map[string]bool
+  reservedMetadata    map[*nativemetadata.MetadataSchema]bool
+  arraySchemaNames    map[string]string
+  arraySchemaCounters map[string]int
 }
 
 // ToLiteral renders the components as an order-preserving object literal input

package/native/core/programmers/iterate/json_schema_recursive_array_identity_test.go

@@ -0,0 +1,75 @@
+package iterate
+
+import (
+  "reflect"
+  "testing"
+
+  metadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+// TestJsonSchemaRecursiveArrayIdentity verifies variant names cannot capture
+// later declared names and recursive tagged edges reach their own definition.
+//
+// Type names alone cannot distinguish constraints, while generated names must
+// coexist with every declared root regardless of its traversal order.
+//
+// 1. Reserve a later alias with the preferred generated variant name.
+// 2. Build self-tagged arrays with equivalent and different schema tag maps.
+// 3. Check reuse, separation, recursive targets and the untouched later alias.
+//
+// @evidence contracts/testing.md#behavioral-verification Exercises the array component allocator and writer on a cyclic tagged graph; checks name collision avoidance, exact tagged self-reference, equivalent-map reuse and constraint separation.
+// @evidence contracts/testing.md#independent-expectations A tagged recursive element must reference the same constrained component at every depth. A separately declared string alias must remain a string even if its name matches a generated candidate.
+// @evidence contracts/testing.md#distinguishing-cases Equivalent maps in opposite insertion order share a component, different constraints do not, a later declared name wins its reservation and an untagged component remains separate.
+// @evidence contracts/testing.md#execution-ownership pnpm test:go:native discovers this unit test and executes the owning writer in process with authored metadata and no product subprocess.
+func TestJsonSchemaRecursiveArrayIdentity(t *testing.T) {
+  value := metadata.MetadataSchema_initialize()
+  array := &metadata.MetadataArrayType{Name: "Tree", Recursive: true, Value: value}
+  first := map[string]any{"minItems": 1, "maxItems": 3}
+  second := map[string]any{}
+  second["maxItems"] = 3
+  second["minItems"] = 1
+  tagged := &metadata.MetadataArray{Type: array, Tags: [][]metadata.IMetadataTypeTag{{{Schema: first}}}}
+  value.Arrays = []*metadata.MetadataArray{tagged}
+  root := metadata.MetadataSchema_initialize()
+  root.Arrays = []*metadata.MetadataArray{tagged}
+  later := metadata.MetadataSchema_initialize()
+  later.Aliases = []*metadata.MetadataAlias{{Type: &metadata.MetadataAliasType{
+    Name: "Tree-array", Value: &metadata.MetadataSchema{Atomics: []*metadata.MetadataAtomic{{Type: "string"}}},
+  }}}
+  components := &OpenApi_IComponents{}
+  components.ReserveSchemaNames([]*metadata.MetadataSchema{root, later})
+  output := Json_schema_station(Json_schema_station_props{Components: components, Metadata: root})
+  ref := output["$ref"].(string)
+  key := ref[len("#/components/schemas/"):]
+  if key == "Tree-array" {
+    t.Fatal("variant captured a later declaration")
+  }
+  expected := JsonSchema{"type": "array", "minItems": 1, "maxItems": 3, "items": JsonSchema{"$ref": ref}}
+  if !reflect.DeepEqual(components.Schemas[key], expected) {
+    t.Errorf("recursive tagged body: %#v", components.Schemas[key])
+  }
+  equivalent := Json_schema_array_export(Json_schema_array_export_props{Components: components, Array: &metadata.MetadataArray{
+    Type: array, Tags: [][]metadata.IMetadataTypeTag{{{Schema: second}}},
+  }})
+  if !reflect.DeepEqual(equivalent, []JsonSchema{output}) {
+    t.Errorf("equivalent tags changed identity: %#v", equivalent)
+  }
+  other := Json_schema_array_export(Json_schema_array_export_props{Components: components, Array: &metadata.MetadataArray{
+    Type: array, Tags: [][]metadata.IMetadataTypeTag{{{Schema: map[string]any{"minItems": 2}}}},
+  }})
+  if reflect.DeepEqual(other, equivalent) {
+    t.Fatal("different constraints shared one identity")
+  }
+  Json_schema_station(Json_schema_station_props{Components: components, Metadata: later})
+  if !reflect.DeepEqual(components.Schemas["Tree-array"], JsonSchema{"type": "string"}) {
+    t.Errorf("later alias was overwritten: %#v", components.Schemas["Tree-array"])
+  }
+  plain := Json_schema_array_export(Json_schema_array_export_props{Components: components, Array: &metadata.MetadataArray{Type: array}})
+  if !reflect.DeepEqual(plain, []JsonSchema{{"$ref": "#/components/schemas/Tree"}}) {
+    t.Errorf("plain identity changed: %#v", plain)
+  }
+  expectedPlain := JsonSchema{"type": "array", "items": JsonSchema{"$ref": ref}}
+  if !reflect.DeepEqual(components.Schemas["Tree"], expectedPlain) {
+    t.Errorf("plain use inherited tags: %#v", components.Schemas["Tree"])
+  }
+}

package/native/core/programmers/iterate/json_schema_recursive_array_ownership_test.go

@@ -0,0 +1,112 @@
+package iterate
+
+import (
+  "reflect"
+  "testing"
+
+  metadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+// TestJsonSchemaRecursiveArrayOwnership verifies aliases define their array body
+// and array constraints belong to each use rather than the shared component.
+//
+// A reserved component is a recursion anchor, not evidence that its structural
+// body has already been generated. Array tags describe a use of that anchor.
+//
+// 1. Generate an alias and its same-named recursive array in both visit orders.
+// 2. Generate two differently tagged uses of a shared recursive array.
+// 3. Compare complete definitions and references with authored array semantics.
+//
+// @evidence contracts/testing.md#behavioral-verification Calls the schema station on cyclic metadata and compares complete component bodies, returned references, tag rows and registration order.
+// @evidence contracts/testing.md#independent-expectations An array definition has type array and an items schema; a recursive reference alone cannot define it. Min/max item constraints are per-use intersections, independently of traversal order.
+// @evidence contracts/testing.md#distinguishing-cases Alias-first and array-first roots retain the alias description; tagged and untagged uses, one and multiple tag rows and nonrecursive controls are separate subcases. Nullable and distinct-name declarations are covered by the TypeScript producer matrix.
+// @evidence contracts/testing.md#execution-ownership pnpm test:go:native discovers this in-process unit test; constructed metadata exercises the owning schema writer without a compiler or subprocess.
+func TestJsonSchemaRecursiveArrayOwnership(t *testing.T) {
+  for _, arrayFirst := range []bool{false, true} {
+    t.Run(map[bool]string{false: "alias-first", true: "array-first"}[arrayFirst], func(t *testing.T) {
+      description := "Recursive tree."
+      alias := &metadata.MetadataAliasType{Name: "Tree", Description: &description}
+      reference := metadata.MetadataSchema_initialize()
+      reference.Aliases = []*metadata.MetadataAlias{{Type: alias}}
+      array := &metadata.MetadataArrayType{Name: "Tree", Recursive: true, Value: reference}
+      body := metadata.MetadataSchema_initialize()
+      body.Arrays = []*metadata.MetadataArray{{Type: array}}
+      alias.Value = body
+      components := &OpenApi_IComponents{}
+      roots := []*metadata.MetadataSchema{reference, body}
+      if arrayFirst {
+        roots[0], roots[1] = roots[1], roots[0]
+      }
+      for _, root := range roots {
+        actual := Json_schema_station(Json_schema_station_props{Components: components, Metadata: root})
+        if !reflect.DeepEqual(actual, JsonSchema{"$ref": "#/components/schemas/Tree"}) {
+          t.Errorf("root: %#v", actual)
+        }
+      }
+      expected := JsonSchema{"type": "array", "items": JsonSchema{"$ref": "#/components/schemas/Tree"}, "description": description}
+      if !reflect.DeepEqual(components.Schemas["Tree"], expected) {
+        t.Errorf("definition: %#v, want %#v", components.Schemas["Tree"], expected)
+      }
+      if !reflect.DeepEqual(components.Order, []string{"Tree"}) {
+        t.Errorf("registration order: %#v", components.Order)
+      }
+    })
+  }
+  for _, recursive := range []bool{false, true} {
+    t.Run(map[bool]string{false: "inline-tags", true: "recursive-tags"}[recursive], func(t *testing.T) {
+      value := metadata.MetadataSchema_initialize()
+      array := &metadata.MetadataArrayType{Name: "Nested", Recursive: recursive, Value: value}
+      if recursive {
+        value.Arrays = []*metadata.MetadataArray{{Type: array}}
+      } else {
+        value.Atomics = []*metadata.MetadataAtomic{{Type: "string"}}
+      }
+      components := &OpenApi_IComponents{}
+      for _, sample := range []struct {
+        tags        [][]metadata.IMetadataTypeTag
+        constraints []JsonSchema
+      }{
+        {[][]metadata.IMetadataTypeTag{{{Schema: map[string]any{"minItems": 1}}}}, []JsonSchema{{"minItems": 1}}},
+        {[][]metadata.IMetadataTypeTag{{{Schema: map[string]any{"maxItems": 2}}}, {{Schema: map[string]any{"minItems": 3}}}}, []JsonSchema{{"maxItems": 2}, {"minItems": 3}}},
+        {nil, []JsonSchema{{}}},
+      } {
+        actual := Json_schema_array_export(Json_schema_array_export_props{Components: components, Array: &metadata.MetadataArray{Type: array, Tags: sample.tags}})
+        base := JsonSchema{"type": "array", "items": JsonSchema{"type": "string"}}
+        if recursive {
+          if len(actual) != 1 {
+            t.Fatalf("expected one component reference: %#v", actual)
+          }
+          ref, ok := actual[0]["$ref"].(string)
+          if !ok {
+            t.Fatalf("expected a component reference: %#v", actual)
+          }
+          base = JsonSchema{"type": "array", "items": JsonSchema{"$ref": "#/components/schemas/Nested"}}
+          key := ref[len("#/components/schemas/"):]
+          actual = []JsonSchema{components.Schemas[key]}
+          if branches, ok := actual[0]["oneOf"].([]JsonSchema); ok {
+            actual = branches
+          }
+        }
+        expected := []JsonSchema{}
+        for _, constraint := range sample.constraints {
+          schema := cloneJsonSchema(base)
+          for key, value := range constraint {
+            schema[key] = value
+          }
+          expected = append(expected, schema)
+        }
+        if !reflect.DeepEqual(actual, expected) {
+          t.Errorf("uses: %#v, want %#v", actual, expected)
+        }
+      }
+      if recursive {
+        expected := JsonSchema{"type": "array", "items": JsonSchema{"$ref": "#/components/schemas/Nested"}}
+        if !reflect.DeepEqual(components.Schemas["Nested"], expected) {
+          t.Errorf("tags polluted definition: %#v", components.Schemas["Nested"])
+        }
+      } else if len(components.Schemas) != 0 {
+        t.Errorf("nonrecursive array registered components: %#v", components.Schemas)
+      }
+    })
+  }
+}

package/native/core/programmers/iterate/json_schema_station.go

@@ -10,6 +10,9 @@ type json_schema_station_props struct {
   components *OpenApi_IComponents
   attribute  JsonSchema
   metadata   *nativemetadata.MetadataSchema
+  // definition is the alias component whose body this station is filling.
+  // Only this level may inline a same-named array; nested stations use refs.
+  definition string
 }
 
 // Json_schema_station_props is the argument record of Json_schema_station, which
@@ -110,7 +113,8 @@ func json_schema_station(props json_schema_station_props) JsonSchema {
     for _, schema := range json_schema_array(struct {
       components *OpenApi_IComponents
       array      *nativemetadata.MetadataArray
-    }{components: props.components, array: array}) {
+      definition string
+    }{components: props.components, array: array, definition: props.definition}) {
       insert(schema)
     }
   }

package/native/core/programmers/json/JsonSchemasProgrammer.go

@@ -141,6 +141,7 @@ func jsonSchemasProgrammer_writeV3_1(metadataList []*nativemetadata.MetadataSche
   components := &nativeiterate.OpenApi_IComponents{
     Schemas: map[string]nativeiterate.JsonSchema{},
   }
+  components.ReserveSchemaNames(metadataList)
   generator := func(metadata *nativemetadata.MetadataSchema) nativeiterate.JsonSchema {
     return nativeiterate.Json_schema_station(nativeiterate.Json_schema_station_props{
       BlockNever: true,

package/native/core/programmers/random_programmer_array_schema_reference_test.go

@@ -0,0 +1,53 @@
+package programmers
+
+import (
+  "reflect"
+  "testing"
+
+  iterate "github.com/samchon/typia/packages/typia/native/core/programmers/iterate"
+)
+
+// TestRandomProgrammerArraySchemaReference verifies random generation consumes
+// the schema writer's selected recursive variant rather than the bare type name.
+//
+// A recursive array can have several constrained schema components; only the
+// returned reference identifies the constraints of the current use.
+//
+// 1. Supply a decoy plain component and a referenced maximum-zero variant.
+// 2. Resolve a variant with multiple alternative tag rows.
+// 3. Preserve inline, external and unresolved schemas without inventing a target.
+//
+// @evidence contracts/testing.md#behavioral-verification Resolves authored component references and compares complete schema lists, including explicit zero bounds and alternatives, as consumed by the random generator.
+// @evidence contracts/testing.md#independent-expectations A local reference selects its named component, not a similarly named unconstrained component; literal array schema maps establish the expected constraints.
+// @evidence contracts/testing.md#distinguishing-cases Distinguishes plain versus constrained targets, zero bounds, one versus multiple rows, inline schemas, nil components, absent targets and external references.
+// @evidence contracts/testing.md#execution-ownership pnpm test:go:native discovers this same-package unit test; it executes the schema consumer in memory with no compiler or product process.
+func TestRandomProgrammerArraySchemaReference(t *testing.T) {
+  empty := iterate.JsonSchema{"type": "array", "maxItems": 0}
+  multiple := []iterate.JsonSchema{empty, {"type": "array", "minItems": 2}}
+  components := &iterate.OpenApi_IComponents{Schemas: map[string]iterate.JsonSchema{
+    "Tree": {"type": "array"}, "Tree-array": empty,
+    "Tree-array-1": {"oneOf": multiple},
+  }}
+  for _, sample := range []struct {
+    name     string
+    schema   iterate.JsonSchema
+    expected []iterate.JsonSchema
+  }{
+    {"selected tagged target", iterate.JsonSchema{"$ref": "#/components/schemas/Tree-array"}, []iterate.JsonSchema{empty}},
+    {"alternative rows", iterate.JsonSchema{"$ref": "#/components/schemas/Tree-array-1"}, multiple},
+    {"inline", empty, []iterate.JsonSchema{empty}},
+    {"missing", iterate.JsonSchema{"$ref": "#/components/schemas/Missing"}, []iterate.JsonSchema{{"$ref": "#/components/schemas/Missing"}}},
+    {"external", iterate.JsonSchema{"$ref": "other.json#/Tree-array"}, []iterate.JsonSchema{{"$ref": "other.json#/Tree-array"}}},
+  } {
+    t.Run(sample.name, func(t *testing.T) {
+      actual := randomProgrammer_array_schema_list(components, []iterate.JsonSchema{sample.schema})
+      if !reflect.DeepEqual(actual, sample.expected) {
+        t.Errorf("got %#v, want %#v", actual, sample.expected)
+      }
+    })
+  }
+  original := []iterate.JsonSchema{empty}
+  if !reflect.DeepEqual(randomProgrammer_array_schema_list(nil, original), original) {
+    t.Error("nil components changed inline schema")
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "15.2.0",
+  "version": "15.2.1",
   "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": "^15.2.0",
-    "@typia/utils": "^15.2.0"
+    "@typia/interface": "^15.2.1",
+    "@typia/utils": "^15.2.1"
   },
   "peerDependencies": {
     "ttsc": ">=0.34.1"