typia 13.1.1 → 13.2.0

package/native/core/programmers/helpers/joiner_branch_coverage_test.go

@@ -4,11 +4,11 @@
 package helpers
 
 import (
-	"testing"
+  "testing"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 // TestJoinerBranchCoverage exercises joiner helper branches.
@@ -23,125 +23,123 @@ import (
 // 3. Exercise function programmer variable declaration and declaration-disable branches.
 // 4. Verify string joining, internal import fallback, and metadata pattern helpers.
 func TestJoinerBranchCoverage(t *testing.T) {
-	factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-	input := factory.NewIdentifier("input")
-	value := factory.NewIdentifier("value")
-	literalKey := helperLiteralKey("known")
-	dynamicKey := helperAtomic("string")
-	numberKey := helperAtomic("number")
-	booleanKey := helperAtomic("boolean")
-	templateKey := nativemetadata.MetadataSchema_initialize()
-	templateKey.Templates = append(templateKey.Templates, nativemetadata.MetadataTemplate_create(nativemetadata.MetadataTemplate{
-		Row: []*nativemetadata.MetadataSchema{literalKey, numberKey},
-	}))
-	required := helperAtomic("string")
-	optional := helperAtomic("string")
-	optional.Optional = true
-	optional.Required = false
-	functional := nativemetadata.MetadataSchema_initialize()
-	functional.Functions = append(functional.Functions, nativemetadata.MetadataFunction_create(nativemetadata.MetadataFunction{
-		Output: helperAtomic("string"),
-	}))
-	entries := []IExpressionEntry{
-		{Input: input, Key: literalKey, Meta: required, Expression: value},
-		{Input: input, Key: dynamicKey, Meta: optional, Expression: value},
-	}
-	if CloneJoiner.Tuple(CloneJoiner_TupleProps{Elements: []*shimast.Expression{value}, Rest: input}) == nil ||
-		CloneJoiner.Array(CloneJoiner_ArrayProps{Input: input, Arrow: value}) == nil ||
-		CloneJoiner.Object(CloneJoiner_ObjectProps{Input: input, Entries: entries}) == nil {
-		t.Fatal("clone joiner returned nil")
-	}
-	if NotationJoiner.Object(NotationJoiner_ObjectProps{
-		Rename:  func(str string) string { return str },
-		Input:   input,
-		Entries: entries,
-	}) == nil ||
-		NotationJoiner.Tuple(NotationJoiner_TupleProps{Elements: []*shimast.Expression{value}, Rest: input}) == nil ||
-		NotationJoiner.Array(NotationJoiner_ArrayProps{Input: input, Arrow: value}) == nil {
-		t.Fatal("notation joiner returned nil")
-	}
-	object := nativemetadata.MetadataObjectType_create(nativemetadata.MetadataObjectType{
-		Name: "Object",
-		Properties: []*nativemetadata.MetadataProperty{
-			nativemetadata.MetadataProperty_create(nativemetadata.MetadataProperty{Key: literalKey, Value: required}),
-			nativemetadata.MetadataProperty_create(nativemetadata.MetadataProperty{Key: dynamicKey, Value: required}),
-		},
-	})
-	if PruneJoiner.Tuple(PruneJoiner_TupleProps{Elements: []*shimast.ConciseBody{value}, Rest: value}) == nil ||
-		PruneJoiner.Array(PruneJoiner_ArrayProps{Input: input, Arrow: value}) == nil ||
-		PruneJoiner.Object(PruneJoiner_ObjectProps{Input: input, Entries: entries, Object: object}) == nil {
-		t.Fatal("prune joiner returned nil")
-	}
-	if StringifyJoiner.Tuple(StringifyJoiner_TupleProps{}) == nil ||
-		StringifyJoiner.Tuple(StringifyJoiner_TupleProps{
-			Elements: []*shimast.Expression{
-				factory.NewStringLiteral("a", shimast.TokenFlagsNone),
-				factory.NewStringLiteral("b", shimast.TokenFlagsNone),
-			},
-		}) == nil ||
-		StringifyJoiner.Tuple(StringifyJoiner_TupleProps{Elements: []*shimast.Expression{value}, Rest: input}) == nil ||
-		StringifyJoiner.Array(StringifyJoiner_ArrayProps{Input: input, Arrow: value}) == nil {
-		t.Fatal("stringify tuple or array joiner returned nil")
-	}
-	stringifyEntries := []IExpressionEntry{
-		{Input: input, Key: literalKey, Meta: functional, Expression: value},
-		{Input: input, Key: dynamicKey, Meta: optional, Expression: value},
-	}
-	if StringifyJoiner.Object(StringifyJoiner_ObjectProps{Context: nativecontext.ITypiaContext{}, Entries: stringifyEntries}) == nil {
-		t.Fatal("stringify object joiner returned nil")
-	}
-	if stringifyJoiner_regular_condition(IExpressionEntry{Input: input, Meta: functional}) == nil ||
-		stringifyJoiner_regular_arrow() == nil ||
-		stringifyJoiner_binding_pattern() == nil ||
-		stringifyJoiner_reduce([]*shimast.Node{input, value}, shimast.KindAmpersandAmpersandToken) == nil ||
-		stringifyJoiner_internal(nativecontext.ITypiaContext{}, "helper") == nil {
-		t.Fatal("stringify helper returned nil")
-	}
-	if joinStrings([]string{}, ",") != "" || joinStrings([]string{"a", "b"}, ",") != "a,b" {
-		t.Fatal("joinStrings returned unexpected output")
-	}
-	if cloneJoiner_regular_skip([]IExpressionEntry{{Key: literalKey}}) == nil ||
-		cloneJoiner_metadata_to_pattern(struct {
-			top      bool
-			metadata *nativemetadata.MetadataSchema
-		}{top: true, metadata: booleanKey}) == "" ||
-		cloneJoiner_metadata_to_pattern(struct {
-			top      bool
-			metadata *nativemetadata.MetadataSchema
-		}{top: true, metadata: templateKey}) == "" ||
-		cloneJoiner_template_to_pattern(struct {
-			top      bool
-			template []*nativemetadata.MetadataSchema
-		}{top: true, template: []*nativemetadata.MetadataSchema{literalKey, numberKey}}) == "" {
-		t.Fatal("clone pattern helper returned empty output")
-	}
+  factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+  input := factory.NewIdentifier("input")
+  value := factory.NewIdentifier("value")
+  literalKey := helperLiteralKey("known")
+  dynamicKey := helperAtomic("string")
+  numberKey := helperAtomic("number")
+  booleanKey := helperAtomic("boolean")
+  templateKey := nativemetadata.MetadataSchema_initialize()
+  templateKey.Templates = append(templateKey.Templates, nativemetadata.MetadataTemplate_create(nativemetadata.MetadataTemplate{
+    Row: []*nativemetadata.MetadataSchema{literalKey, numberKey},
+  }))
+  required := helperAtomic("string")
+  optional := helperAtomic("string")
+  optional.Optional = true
+  optional.Required = false
+  functional := nativemetadata.MetadataSchema_initialize()
+  functional.Functions = append(functional.Functions, nativemetadata.MetadataFunction_create(nativemetadata.MetadataFunction{
+    Output: helperAtomic("string"),
+  }))
+  entries := []IExpressionEntry{
+    {Input: input, Key: literalKey, Meta: required, Expression: value},
+    {Input: input, Key: dynamicKey, Meta: optional, Expression: value},
+  }
+  if CloneJoiner.Tuple(CloneJoiner_TupleProps{Elements: []*shimast.Expression{value}, Rest: input}) == nil ||
+    CloneJoiner.Array(CloneJoiner_ArrayProps{Input: input, Arrow: value}) == nil ||
+    CloneJoiner.Object(CloneJoiner_ObjectProps{Input: input, Entries: entries}) == nil {
+    t.Fatal("clone joiner returned nil")
+  }
+  if NotationJoiner.Object(NotationJoiner_ObjectProps{
+    Rename:        func(str string) string { return str },
+    DynamicRename: func() *shimast.Node { return factory.NewIdentifier("rename") },
+    DynamicAssign: func() *shimast.Node { return factory.NewIdentifier("assign") },
+    Input:         input,
+    Entries:       entries,
+  }) == nil ||
+    NotationJoiner.Tuple(NotationJoiner_TupleProps{Elements: []*shimast.Expression{value}, Rest: input}) == nil ||
+    NotationJoiner.Array(NotationJoiner_ArrayProps{Input: input, Arrow: value}) == nil {
+    t.Fatal("notation joiner returned nil")
+  }
+  object := nativemetadata.MetadataObjectType_create(nativemetadata.MetadataObjectType{
+    Name: "Object",
+    Properties: []*nativemetadata.MetadataProperty{
+      nativemetadata.MetadataProperty_create(nativemetadata.MetadataProperty{Key: literalKey, Value: required}),
+      nativemetadata.MetadataProperty_create(nativemetadata.MetadataProperty{Key: dynamicKey, Value: required}),
+    },
+  })
+  if PruneJoiner.Tuple(PruneJoiner_TupleProps{Elements: []*shimast.ConciseBody{value}, Rest: value}) == nil ||
+    PruneJoiner.Array(PruneJoiner_ArrayProps{Input: input, Arrow: value}) == nil ||
+    PruneJoiner.Object(PruneJoiner_ObjectProps{Input: input, Entries: entries, Object: object}) == nil {
+    t.Fatal("prune joiner returned nil")
+  }
+  if StringifyJoiner.Tuple(StringifyJoiner_TupleProps{}) == nil ||
+    StringifyJoiner.Tuple(StringifyJoiner_TupleProps{
+      Elements: []*shimast.Expression{
+        factory.NewStringLiteral("a", shimast.TokenFlagsNone),
+        factory.NewStringLiteral("b", shimast.TokenFlagsNone),
+      },
+    }) == nil ||
+    StringifyJoiner.Tuple(StringifyJoiner_TupleProps{Elements: []*shimast.Expression{value}, Rest: input}) == nil ||
+    StringifyJoiner.Array(StringifyJoiner_ArrayProps{Input: input, Arrow: value}) == nil {
+    t.Fatal("stringify tuple or array joiner returned nil")
+  }
+  stringifyEntries := []IExpressionEntry{
+    {Input: input, Key: literalKey, Meta: functional, Expression: value},
+    {Input: input, Key: dynamicKey, Meta: optional, Expression: value},
+  }
+  if StringifyJoiner.Object(StringifyJoiner_ObjectProps{Context: nativecontext.ITypiaContext{}, Entries: stringifyEntries}) == nil {
+    t.Fatal("stringify object joiner returned nil")
+  }
+  if stringifyJoiner_regular_condition(IExpressionEntry{Input: input, Meta: functional}) == nil ||
+    stringifyJoiner_regular_arrow() == nil ||
+    stringifyJoiner_binding_pattern() == nil ||
+    stringifyJoiner_reduce([]*shimast.Node{input, value}, shimast.KindAmpersandAmpersandToken) == nil ||
+    stringifyJoiner_internal(nativecontext.ITypiaContext{}, "helper") == nil {
+    t.Fatal("stringify helper returned nil")
+  }
+  if joinStrings([]string{}, ",") != "" || joinStrings([]string{"a", "b"}, ",") != "a,b" {
+    t.Fatal("joinStrings returned unexpected output")
+  }
+  if cloneJoiner_regular_skip([]IExpressionEntry{{Key: literalKey}}) == nil ||
+    cloneJoiner_metadata_to_pattern(struct {
+      top      bool
+      metadata *nativemetadata.MetadataSchema
+    }{top: true, metadata: booleanKey}) == "" ||
+    cloneJoiner_metadata_to_pattern(struct {
+      top      bool
+      metadata *nativemetadata.MetadataSchema
+    }{top: true, metadata: templateKey}) == "" ||
+    cloneJoiner_template_to_pattern(struct {
+      top      bool
+      template []*nativemetadata.MetadataSchema
+    }{top: true, template: []*nativemetadata.MetadataSchema{literalKey, numberKey}}) == "" {
+    t.Fatal("clone pattern helper returned empty output")
+  }
 
-	programmer := NewFunctionProgrammer("joiner")
-	if programmer.EmplaceVariable("cached", value) == nil || len(programmer.Declare(false)) == 0 {
-		t.Fatal("function programmer variable branch failed")
-	}
-	programmer.disableDeclare = true
-	if len(programmer.Declare()) != 0 || len(programmer.DeclareUnions()) != 0 {
-		t.Fatal("disabled function programmer should not declare")
-	}
-	if stringifyJoiner_internal(nativecontext.ITypiaContext{Importer: nativecontext.NewImportProgrammer()}, "jsonStringifyTail") == nil {
-		t.Fatal("stringify internal importer branch returned nil")
-	}
+  programmer := NewFunctionProgrammer("joiner")
+  if programmer.EmplaceVariable("cached", value) == nil || len(programmer.Declare(false)) == 0 {
+    t.Fatal("function programmer variable branch failed")
+  }
+  if stringifyJoiner_internal(nativecontext.ITypiaContext{Importer: nativecontext.NewImportProgrammer()}, "jsonStringifyTail") == nil {
+    t.Fatal("stringify internal importer branch returned nil")
+  }
 }
 
 func helperLiteralKey(value string) *nativemetadata.MetadataSchema {
-	meta := nativemetadata.MetadataSchema_initialize()
-	meta.Constants = append(meta.Constants, nativemetadata.MetadataConstant_create(nativemetadata.MetadataConstant{
-		Type: "string",
-		Values: []*nativemetadata.MetadataConstantValue{
-			nativemetadata.MetadataConstantValue_create(nativemetadata.MetadataConstantValue{Value: value}),
-		},
-	}))
-	return meta
+  meta := nativemetadata.MetadataSchema_initialize()
+  meta.Constants = append(meta.Constants, nativemetadata.MetadataConstant_create(nativemetadata.MetadataConstant{
+    Type: "string",
+    Values: []*nativemetadata.MetadataConstantValue{
+      nativemetadata.MetadataConstantValue_create(nativemetadata.MetadataConstantValue{Value: value}),
+    },
+  }))
+  return meta
 }
 
 func helperAtomic(kind string) *nativemetadata.MetadataSchema {
-	meta := nativemetadata.MetadataSchema_initialize()
-	meta.Atomics = append(meta.Atomics, nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: kind}))
-	return meta
+  meta := nativemetadata.MetadataSchema_initialize()
+  meta.Atomics = append(meta.Atomics, nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: kind}))
+  return meta
 }

package/native/core/programmers/helpers/union_explorer_coverage_test.go

@@ -91,7 +91,7 @@ func TestUnionExplorerCoverage(t *testing.T) {
 	if unionExplorer_array_if(func(init string, from *shimast.Expression, ifStatement *shimast.Node) *shimast.Node {
 		iterated = init == "pred" && from != nil && ifStatement != nil
 		return ifStatement
-	}, input, input, factory.NewKeywordExpression(shimast.KindTrueKeyword)) == nil || !iterated {
+	}, input, input, factory.NewKeywordExpression(shimast.KindTrueKeyword), false) == nil || !iterated {
 		t.Fatal("array disambiguation helper did not invoke iterator")
 	}
 	if unionExplorer_return_or_statement(input) == nil ||

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

@@ -826,21 +826,27 @@ func (checkerProgrammerNamespace) Decode(props CheckerProgrammer_DecodeProps) *s
         body = checkerProgrammer_explore_tuples(checkerProgrammer_exploreTuplesProps{Config: props.Config, Context: props.Context, Functor: props.Functor, Tuples: props.Metadata.Tuples, Input: props.Input, Explore: explore})
       }
     } else if checkerProgrammer_array_any(props.Metadata.Arrays) {
-      // Any-element arrays need no element exploration, but a sole array's
-      // validating wrapper tags (MinItems, custom predicates, ...) still
-      // constrain the container and survive on the entry conditions. Unions
-      // mixing a tag-constrained any-element array with other array-like
-      // variants keep the historical wholesale acceptance: the union
-      // explorer discriminates by element checks, which an any element
-      // satisfies trivially, so honoring those tags needs branch
-      // backtracking (tracked on #1933).
-      body = nil
+      // A sole any-element array only needs its wrapper predicates. In a
+      // union, however, those predicates participate in branch selection:
+      // a failed tagged-any candidate must backtrack to a concrete array or
+      // tuple candidate instead of accepting or rejecting the whole bucket.
       if len(props.Metadata.Arrays) == 1 && len(props.Metadata.Tuples) == 0 {
+        body = nil
         conditions = nativeiterate.Check_array_length(nativeiterate.Check_array_lengthProps{
           Context: props.Context,
           Array:   props.Metadata.Arrays[0],
           Input:   props.Input,
         }).Conditions
+      } else if checkerProgrammer_has_array_type_tags(props.Metadata.Arrays) {
+        explore := props.Explore
+        explore.From = "array"
+        if len(props.Metadata.Tuples) == 0 {
+          body = checkerProgrammer_explore_arrays(checkerProgrammer_exploreArraysProps{Config: props.Config, Context: props.Context, Functor: props.Functor, Arrays: props.Metadata.Arrays, Input: props.Input, Explore: explore})
+        } else {
+          body = checkerProgrammer_explore_arrays_and_tuples(checkerProgrammer_exploreArraysAndTuplesProps{Config: props.Config, Context: props.Context, Functor: props.Functor, Definitions: checkerProgrammer_array_tuple_definitions(props.Metadata.Arrays, props.Metadata.Tuples), Input: props.Input, Explore: explore})
+        }
+      } else {
+        body = nil
       }
     } else if len(props.Metadata.Tuples) == 0 {
       explore := props.Explore
@@ -1540,14 +1546,18 @@ func checkerProgrammer_explore_arrays(props checkerProgrammer_exploreArraysProps
       for _, value := range next.Definitions {
         arrays = append(arrays, value.(*nativemetadata.MetadataArray))
       }
+      config := checkerProgrammer_array_like_config(props.Context, props.Config, props.Functor,
+        func(v nativehelpers.UnionExplorer_ArrayLikeCheckerProps) *shimast.Node {
+          return CheckerProgrammer.Decode(CheckerProgrammer_DecodeProps{Context: props.Context, Config: props.Config, Functor: props.Functor, Metadata: v.Definition.(*nativemetadata.MetadataSchema), Input: v.Input, Explore: featureProgrammer_as_explore(v.Explore)})
+        },
+        func(v nativehelpers.UnionExplorer_ArrayLikeDecoderProps) *shimast.Node {
+          return checkerProgrammer_decode_array(checkerProgrammer_decodeArrayProps{Context: props.Context, Config: props.Config, Functor: props.Functor, Array: v.Definition.(*nativemetadata.MetadataArray), Input: v.Input, Explore: featureProgrammer_as_explore(v.Explore)})
+        })
+      if checkerProgrammer_has_array_type_tags(arrays) {
+        config.Candidate = checkerProgrammer_array_tag_candidate(props.Context)
+      }
       return nativehelpers.UnionExplorer.Array(nativehelpers.UnionExplorer_ArrayProps{
-        Config: checkerProgrammer_array_like_config(props.Context, props.Config, props.Functor,
-          func(v nativehelpers.UnionExplorer_ArrayLikeCheckerProps) *shimast.Node {
-            return CheckerProgrammer.Decode(CheckerProgrammer_DecodeProps{Context: props.Context, Config: props.Config, Functor: props.Functor, Metadata: v.Definition.(*nativemetadata.MetadataSchema), Input: v.Input, Explore: featureProgrammer_as_explore(v.Explore)})
-          },
-          func(v nativehelpers.UnionExplorer_ArrayLikeDecoderProps) *shimast.Node {
-            return checkerProgrammer_decode_array(checkerProgrammer_decodeArrayProps{Context: props.Context, Config: props.Config, Functor: props.Functor, Array: v.Definition.(*nativemetadata.MetadataArray), Input: v.Input, Explore: featureProgrammer_as_explore(v.Explore)})
-          }),
+        Config:     config,
         Parameters: next.Parameters,
         Arrays:     arrays,
         Input:      next.Input,
@@ -1562,37 +1572,41 @@ func checkerProgrammer_explore_arrays_and_tuples(props checkerProgrammer_explore
   return checkerProgrammer_explore_array_like_union_types(checkerProgrammer_exploreArrayLikeUnionTypesProps{
     Config: props.Config, Functor: props.Functor, Definitions: props.Definitions, Input: props.Input, Explore: props.Explore, Emit: props.Context.Emit,
     Factory: func(next checkerProgrammer_exploreArrayLikeUnionTypesFactoryProps) *shimast.Node {
-      return nativehelpers.UnionExplorer.Array_or_tuple(nativehelpers.UnionExplorer_ArrayOrTupleProps{
-        Config: checkerProgrammer_array_like_config(props.Context, props.Config, props.Functor,
-          func(v nativehelpers.UnionExplorer_ArrayLikeCheckerProps) *shimast.Node {
-            if tuple, ok := v.Definition.(*nativemetadata.MetadataTuple); ok {
-              return checkerProgrammer_decode_tuple(checkerProgrammer_decodeTupleProps{Config: props.Config, Context: props.Context, Functor: props.Functor, Input: v.Input, Tuple: tuple, Explore: featureProgrammer_as_explore(v.Explore)})
-            }
-            expected := []string{}
-            for _, elem := range props.Definitions {
-              switch x := elem.(type) {
-              case *nativemetadata.MetadataArray:
-                expected = append(expected, x.GetDisplayName())
-              case *nativemetadata.MetadataTuple:
-                expected = append(expected, x.Type.GetDisplayName())
-              }
-            }
-            return props.Config.Atomist(CheckerProgrammer_AtomistProps{
-              Explore: featureProgrammer_as_explore(v.Explore),
-              Entry: nativehelpers.ICheckEntry{
-                Expected:   strings.Join(expected, " | "),
-                Expression: CheckerProgrammer.Decode(CheckerProgrammer_DecodeProps{Functor: props.Functor, Context: props.Context, Config: props.Config, Metadata: v.Definition.(*nativemetadata.MetadataSchema), Input: v.Input, Explore: featureProgrammer_as_explore(v.Explore)}),
-                Conditions: [][]nativehelpers.ICheckEntry_ICondition{},
-              },
-              Input: v.Container,
-            })
-          },
-          func(v nativehelpers.UnionExplorer_ArrayLikeDecoderProps) *shimast.Node {
-            if tuple, ok := v.Definition.(*nativemetadata.MetadataTuple); ok {
-              return checkerProgrammer_decode_tuple(checkerProgrammer_decodeTupleProps{Context: props.Context, Config: props.Config, Functor: props.Functor, Input: v.Input, Tuple: tuple, Explore: featureProgrammer_as_explore(v.Explore)})
+      config := checkerProgrammer_array_like_config(props.Context, props.Config, props.Functor,
+        func(v nativehelpers.UnionExplorer_ArrayLikeCheckerProps) *shimast.Node {
+          if tuple, ok := v.Definition.(*nativemetadata.MetadataTuple); ok {
+            return checkerProgrammer_decode_tuple(checkerProgrammer_decodeTupleProps{Config: props.Config, Context: props.Context, Functor: props.Functor, Input: v.Input, Tuple: tuple, Explore: featureProgrammer_as_explore(v.Explore)})
+          }
+          expected := []string{}
+          for _, elem := range props.Definitions {
+            switch x := elem.(type) {
+            case *nativemetadata.MetadataArray:
+              expected = append(expected, x.GetDisplayName())
+            case *nativemetadata.MetadataTuple:
+              expected = append(expected, x.Type.GetDisplayName())
             }
-            return checkerProgrammer_decode_array(checkerProgrammer_decodeArrayProps{Context: props.Context, Config: props.Config, Functor: props.Functor, Input: v.Input, Array: v.Definition.(*nativemetadata.MetadataArray), Explore: featureProgrammer_as_explore(v.Explore)})
-          }),
+          }
+          return props.Config.Atomist(CheckerProgrammer_AtomistProps{
+            Explore: featureProgrammer_as_explore(v.Explore),
+            Entry: nativehelpers.ICheckEntry{
+              Expected:   strings.Join(expected, " | "),
+              Expression: CheckerProgrammer.Decode(CheckerProgrammer_DecodeProps{Functor: props.Functor, Context: props.Context, Config: props.Config, Metadata: v.Definition.(*nativemetadata.MetadataSchema), Input: v.Input, Explore: featureProgrammer_as_explore(v.Explore)}),
+              Conditions: [][]nativehelpers.ICheckEntry_ICondition{},
+            },
+            Input: v.Container,
+          })
+        },
+        func(v nativehelpers.UnionExplorer_ArrayLikeDecoderProps) *shimast.Node {
+          if tuple, ok := v.Definition.(*nativemetadata.MetadataTuple); ok {
+            return checkerProgrammer_decode_tuple(checkerProgrammer_decodeTupleProps{Context: props.Context, Config: props.Config, Functor: props.Functor, Input: v.Input, Tuple: tuple, Explore: featureProgrammer_as_explore(v.Explore)})
+          }
+          return checkerProgrammer_decode_array(checkerProgrammer_decodeArrayProps{Context: props.Context, Config: props.Config, Functor: props.Functor, Input: v.Input, Array: v.Definition.(*nativemetadata.MetadataArray), Explore: featureProgrammer_as_explore(v.Explore)})
+        })
+      if checkerProgrammer_definitions_have_array_type_tags(next.Definitions) {
+        config.Candidate = checkerProgrammer_array_tag_candidate(props.Context)
+      }
+      return nativehelpers.UnionExplorer.Array_or_tuple(nativehelpers.UnionExplorer_ArrayOrTupleProps{
+        Config:      config,
         Parameters:  next.Parameters,
         Definitions: next.Definitions,
         Input:       next.Input,
@@ -1785,7 +1799,7 @@ func checkerProgrammer_check_object_reference(props checkerProgrammer_decodeObje
   }
   return checkerProgrammer_and(
     decoded,
-    checkerProgrammer_object_type_tags_condition(tags, props.Context.Emit),
+    checkerProgrammer_entry_condition(tags, props.Context.Emit),
     props.Context.Emit,
   )
 }
@@ -1819,7 +1833,7 @@ func checkerProgrammer_decode_object_reference(props checkerProgrammer_decodeObj
   )
 }
 
-func checkerProgrammer_object_type_tags_condition(entry nativehelpers.ICheckEntry, emit *shimprinter.EmitContext) *shimast.Node {
+func checkerProgrammer_entry_condition(entry nativehelpers.ICheckEntry, emit *shimprinter.EmitContext) *shimast.Node {
   f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, emit)
   expressions := []*shimast.Node{}
   if entry.Expression != nil {
@@ -1852,6 +1866,44 @@ func checkerProgrammer_has_object_type_tags(objects []*nativemetadata.MetadataOb
   return false
 }
 
+func checkerProgrammer_has_array_type_tags(arrays []*nativemetadata.MetadataArray) bool {
+  for _, array := range arrays {
+    for _, row := range array.Tags {
+      for _, tag := range row {
+        if tag.Validate != "" {
+          return true
+        }
+      }
+    }
+  }
+  return false
+}
+
+func checkerProgrammer_definitions_have_array_type_tags(definitions []any) bool {
+  arrays := []*nativemetadata.MetadataArray{}
+  for _, definition := range definitions {
+    if array, ok := definition.(*nativemetadata.MetadataArray); ok {
+      arrays = append(arrays, array)
+    }
+  }
+  return checkerProgrammer_has_array_type_tags(arrays)
+}
+
+func checkerProgrammer_array_tag_candidate(context nativecontext.ITypiaContext) func(nativehelpers.UnionExplorer_ArrayLikeCandidateProps) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, context.Emit)
+  return func(props nativehelpers.UnionExplorer_ArrayLikeCandidateProps) *shimast.Node {
+    array, ok := props.Definition.(*nativemetadata.MetadataArray)
+    if ok == false {
+      return f.NewKeywordExpression(shimast.KindTrueKeyword)
+    }
+    return checkerProgrammer_entry_condition(nativeiterate.Check_array_length(nativeiterate.Check_array_lengthProps{
+      Context: context,
+      Array:   array,
+      Input:   props.Input,
+    }), context.Emit)
+  }
+}
+
 func checkerProgrammer_array_like_config(context nativecontext.ITypiaContext, config CheckerProgrammer_IConfig, functor *nativehelpers.FunctionProgrammer, checker func(v nativehelpers.UnionExplorer_ArrayLikeCheckerProps) *shimast.Node, decoder func(v nativehelpers.UnionExplorer_ArrayLikeDecoderProps) *shimast.Node) nativehelpers.UnionExplorer_ArrayLikeConfig {
   f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, context.Emit)
   return nativehelpers.UnionExplorer_ArrayLikeConfig{