typia 15.2.0 → 15.2.2

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

@@ -0,0 +1,91 @@
+package iterate
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimprinter "github.com/microsoft/typescript-go/shim/printer"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+// TestCheckStringCachesOnlyStaticPatterns verifies the string check's cache boundary.
+//
+// Pattern-kind metadata alone cannot justify replacing arbitrary validation
+// code. Only a flag-free constructor with the authored source and input has
+// the standard tag's stateless behavior.
+//
+//  1. Build real string-check expressions for standard and custom tag forms.
+//  2. Require one lazy var slot for repeated standard sources in compiler mode.
+//  3. Preserve inline checks without new names in standalone mode, and preserve
+//     custom expressions in both modes.
+//
+// @evidence contracts/testing.md#behavioral-verification Check_string builds AST checks from tag metadata. Standard and empty sources register one lazy uninitialized var after repeated compiler-integrated calls; flags, altered source, altered input, arbitrary predicates and other tag kinds register none. Standalone mode retains the inline constructor and emits no potentially conflicting name.
+// @evidence contracts/testing.md#independent-expectations A flag-free RegExp(source).test(input) can reuse one stateless object. Additional flags or authored expressions are independent behavior and must remain unchanged; uninitialized var slots preserve lazy and early-module use.
+// @evidence contracts/testing.md#distinguishing-cases Standard, empty and invalid sources have custom flags, mismatched source, mismatched input, custom predicate, non-pattern kind and absent importer negative twins. Two distinct sources require two slots; repeated requests reuse one. Standalone mode contrasts with compiler mode because it cannot safely allocate a name beside authored declarations.
+// @evidence contracts/testing.md#execution-ownership The native Go suite discovers this in-process unit test. It calls the real checker builder and importer with in-memory AST and metadata; no compiler artifact or JavaScript subprocess is needed. The schema E2E case owns actual module lowering and construction counts.
+func TestCheckStringCachesOnlyStaticPatterns(t *testing.T) {
+  for _, emit := range []*shimprinter.EmitContext{nil, shimprinter.NewEmitContext()} {
+    for _, row := range []struct {
+      source string
+      script string
+      kind   string
+      cached bool
+    }{
+      {"x", `RegExp("x").test($input)`, "pattern", true},
+      {"", `RegExp("").test($input)`, "pattern", true},
+      {"[", `RegExp("[").test($input)`, "pattern", true},
+      {"x", `RegExp("x", "g").test($input)`, "pattern", false},
+      {"x", `RegExp("y").test($input)`, "pattern", false},
+      {"x", `RegExp("x").test("other")`, "pattern", false},
+      {"x", `$input === "allow"`, "pattern", false},
+      {"x", `RegExp("x").test($input)`, "custom", false},
+    } {
+      importer := nativecontext.NewImportProgrammer()
+      if emit != nil {
+        importer.SetEmitContext(emit)
+      }
+      props := Check_stringProps{
+        Context: nativecontext.ITypiaContext{Emit: emit, Importer: importer},
+        Input:   nativecontext.NodeFactoryOf(emit).NewIdentifier("input"),
+        Atomic: &nativemetadata.MetadataAtomic{Type: "string", Tags: [][]nativemetadata.IMetadataTypeTag{{{
+          Target: "string", Name: "test", Kind: row.kind, Value: row.source, Validate: row.script,
+        }}}},
+      }
+      first := Check_string(props).Conditions[0][0].Expression
+      Check_string(props)
+      statements := importer.ToStatements()
+      expected := 0
+      if row.cached && emit != nil {
+        expected = 1
+      }
+      if len(statements) != expected {
+        t.Fatalf("%s: expected %d cache slots, got %d", row.script, expected, len(statements))
+      }
+      if row.cached && emit == nil {
+        receiver := first.AsCallExpression().Expression.AsPropertyAccessExpression().Expression
+        if receiver.Kind != shimast.KindCallExpression {
+          t.Fatal("standalone mode must preserve the inline constructor without a new binding")
+        }
+      }
+      if expected != 0 {
+        declaration := statements[0].AsVariableStatement().DeclarationList.AsVariableDeclarationList()
+        if declaration.Flags&(shimast.NodeFlagsLet|shimast.NodeFlagsConst) != 0 || declaration.Declarations.Nodes[0].AsVariableDeclaration().Initializer != nil {
+          t.Fatalf("%s: cache must use an uninitialized var", row.script)
+        }
+        receiver := first.AsCallExpression().Expression.AsPropertyAccessExpression().Expression
+        if receiver.Kind != shimast.KindParenthesizedExpression || receiver.AsParenthesizedExpression().Expression.AsBinaryExpression().OperatorToken.Kind != shimast.KindQuestionQuestionEqualsToken {
+          t.Fatalf("%s: construction must be lazy", row.script)
+        }
+        props.Atomic.Tags[0][0].Value = "different"
+        props.Atomic.Tags[0][0].Validate = `RegExp("different").test($input)`
+        Check_string(props)
+        if len(importer.ToStatements()) != 2 {
+          t.Fatal("distinct sources must have distinct slots")
+        }
+      }
+      props.Context.Importer = nil
+      Check_string(props)
+    }
+  }
+}

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

@@ -30,7 +30,7 @@ type Check_templateProps struct {
 // guard plus one `RegExp(...).test` per template, with the type tags inlined
 // into the member when several templates are neighbors.
 //
-// @evidence contracts/common.md#principled-implementation It builds the check entry of template literal types: a string guard plus one `RegExp(...).test` per template, with the type tags inlined into the member when several templates are neighbors.
+// @evidence contracts/common.md#principled-implementation It builds the check entry of template literal types: a string guard plus one structural regex per template. Whole-string and captured-placeholder tag conditions use the common string-tag lowering, including backtracking and union members, so standard Pattern tags share the file cache without changing structural matching.
 // @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 Its inputs are its arguments and the context they carry, and it keeps no state of its own.
 // @evidence contracts/common.md#meaningful-documentation The doc states what it builds.
@@ -125,7 +125,7 @@ func check_template_type_tags(props Check_templateProps, tpl *nativemetadata.Met
     for _, tag := range tags {
       conditions = append(conditions, nativehelpers.ICheckEntry_ICondition{
         Expected:   tpl.GetBaseName() + " & " + tag.Name,
-        Expression: check_string_transpile(props.Context, tag.Validate)(props.Input),
+        Expression: check_string_transpile(props.Context, tag)(props.Input),
       })
     }
     for _, tag := range row {
@@ -253,7 +253,7 @@ func check_template_value_conditions(props Check_templateProps, base string, ato
       for _, tag := range check_string_filter_validate(row) {
         conditions = append(conditions, nativehelpers.ICheckEntry_ICondition{
           Expected:   base + " & " + tag.Name,
-          Expression: check_string_transpile(props.Context, tag.Validate)(input),
+          Expression: check_string_transpile(props.Context, tag)(input),
         })
       }
       for _, tag := range row {
@@ -611,7 +611,7 @@ func check_template_inline_tags(props Check_templateProps, tpl *nativemetadata.M
     tags := check_string_filter_validate(row)
     expressions := make([]*shimast.Node, 0, len(tags))
     for _, tag := range tags {
-      expressions = append(expressions, check_string_transpile(props.Context, tag.Validate)(props.Input))
+      expressions = append(expressions, check_string_transpile(props.Context, tag)(props.Input))
     }
     for _, tag := range row {
       if condition := check_exclude_condition("string", tag, props.Input, props.Emit); condition != nil {

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,