typia 15.0.0 → 15.1.0

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

@@ -4,11 +4,11 @@
 package helpers
 
 import (
-	"testing"
+  "testing"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
-	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 // TestUnionExplorerCoverage exercises array-like union helpers.
@@ -21,115 +21,123 @@ import (
 // 2. Exercise tuple-only, array-only, and mixed array-or-tuple union paths.
 // 3. Exercise direct array disambiguation, explore copying, and return wrapping.
 // 4. Verify protobuf utility first-row extraction and numeric conversions.
+//
+// @evidence contracts/testing.md#behavioral-verification The array-like union explorer constructs tuple-only, array-only and mixed ASTs; most checks certify construction or callback inputs. The mixed failure callback must receive the exact authored type description once. Explore copies retain source and leave originals unchanged, and protobuf conversions and sequence extraction are compared with exact literals.
+// @evidence contracts/testing.md#independent-expectations Authored tuple/array names define the exact mixed failure description; authored numeric and sequence values define conversion expectations. The non-nil AST checks certify construction only and do not establish emitted runtime semantics.
+// @evidence contracts/testing.md#distinguishing-cases Tuple, array and mixed paths are each visited once without negative twins.
+// @evidence contracts/testing.md#execution-ownership The typia_native_internal Go command (go -C packages/typia/test test -tags typia_native_internal ../native/...) runs this same-package Test function in process. The tagged test builds AST nodes in memory with no checker, filesystem fixture or process.
 func TestUnionExplorerCoverage(t *testing.T) {
-	factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-	input := factory.NewIdentifier("input")
-	parameter := nativefactories.IdentifierFactory.Parameter("input", nativefactories.TypeFactory.Keyword("any"), nil)
-	stringMeta := helperAtomic("string")
-	tuple := nativemetadata.MetadataTuple_create(nativemetadata.MetadataTuple{
-		Type: nativemetadata.MetadataTupleType_create(nativemetadata.MetadataTupleType{
-			Name:      "[string]",
-			Elements:  []*nativemetadata.MetadataSchema{stringMeta},
-			Nullables: []bool{},
-		}),
-	})
-	array := nativemetadata.MetadataArray_create(nativemetadata.MetadataArray{
-		Type: nativemetadata.MetadataArrayType_create(nativemetadata.MetadataArrayType{
-			Name:      "string[]",
-			Value:     stringMeta,
-			Nullables: []bool{},
-		}),
-	})
-	config := UnionExplorer_ArrayLikeConfig{
-		Checker: func(props UnionExplorer_ArrayLikeCheckerProps) *shimast.Node {
-			if props.Input == nil || props.Definition == nil {
-				t.Fatal("union checker received incomplete props")
-			}
-			return factory.NewKeywordExpression(shimast.KindTrueKeyword)
-		},
-		Decoder: func(props UnionExplorer_ArrayLikeDecoderProps) *shimast.Node {
-			if props.Input == nil || props.Definition == nil {
-				t.Fatal("union decoder received incomplete props")
-			}
-			return factory.NewIdentifier("decoded")
-		},
-		Empty:   factory.NewIdentifier("empty"),
-		Success: factory.NewKeywordExpression(shimast.KindTrueKeyword),
-		Failure: func(props UnionExplorer_ArrayLikeFailureProps) *shimast.Node {
-			if props.Expected == "" {
-				t.Fatal("union failure should include expected name")
-			}
-			return factory.NewIdentifier("failed")
-		},
-	}
-	if UnionExplorer.Tuple(UnionExplorer_TupleProps{
-		Config:     config,
-		Parameters: []*shimast.Node{parameter},
-		Input:      input,
-		Tuples:     []*nativemetadata.MetadataTuple{tuple},
-	}) == nil {
-		t.Fatal("tuple union explorer returned nil")
-	}
-	if UnionExplorer.Array(UnionExplorer_ArrayProps{
-		Config:     config,
-		Parameters: []*shimast.Node{parameter},
-		Input:      input,
-		Arrays:     []*nativemetadata.MetadataArray{array},
-	}) == nil {
-		t.Fatal("array union explorer returned nil")
-	}
-	if UnionExplorer.Array_or_tuple(UnionExplorer_ArrayOrTupleProps{
-		Config:      config,
-		Parameters:  []*shimast.Node{parameter},
-		Input:       input,
-		Definitions: []any{tuple, array},
-	}) == nil {
-		t.Fatal("mixed array-or-tuple explorer returned nil")
-	}
+  factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+  input := factory.NewIdentifier("input")
+  parameter := nativefactories.IdentifierFactory.Parameter("input", nativefactories.TypeFactory.Keyword("any"), nil)
+  stringMeta := helperAtomic("string")
+  tuple := nativemetadata.MetadataTuple_create(nativemetadata.MetadataTuple{
+    Type: nativemetadata.MetadataTupleType_create(nativemetadata.MetadataTupleType{
+      Name:      "[string]",
+      Elements:  []*nativemetadata.MetadataSchema{stringMeta},
+      Nullables: []bool{},
+    }),
+  })
+  array := nativemetadata.MetadataArray_create(nativemetadata.MetadataArray{
+    Type: nativemetadata.MetadataArrayType_create(nativemetadata.MetadataArrayType{
+      Name:      "string[]",
+      Value:     stringMeta,
+      Nullables: []bool{},
+    }),
+  })
+  failures := 0
+  config := UnionExplorer_ArrayLikeConfig{
+    Checker: func(props UnionExplorer_ArrayLikeCheckerProps) *shimast.Node {
+      if props.Input == nil || props.Definition == nil {
+        t.Fatal("union checker received incomplete props")
+      }
+      return factory.NewKeywordExpression(shimast.KindTrueKeyword)
+    },
+    Decoder: func(props UnionExplorer_ArrayLikeDecoderProps) *shimast.Node {
+      if props.Input == nil || props.Definition == nil {
+        t.Fatal("union decoder received incomplete props")
+      }
+      return factory.NewIdentifier("decoded")
+    },
+    Empty:   factory.NewIdentifier("empty"),
+    Success: factory.NewKeywordExpression(shimast.KindTrueKeyword),
+    Failure: func(props UnionExplorer_ArrayLikeFailureProps) *shimast.Node {
+      failures++
+      if props.Expected != "([string] | string[])" || props.Input != input {
+        t.Fatalf("mixed union failure must retain input and authored type names, got %q", props.Expected)
+      }
+      return factory.NewIdentifier("failed")
+    },
+  }
+  if UnionExplorer.Tuple(UnionExplorer_TupleProps{
+    Config:     config,
+    Parameters: []*shimast.Node{parameter},
+    Input:      input,
+    Tuples:     []*nativemetadata.MetadataTuple{tuple},
+  }) == nil {
+    t.Fatal("tuple union explorer returned nil")
+  }
+  if UnionExplorer.Array(UnionExplorer_ArrayProps{
+    Config:     config,
+    Parameters: []*shimast.Node{parameter},
+    Input:      input,
+    Arrays:     []*nativemetadata.MetadataArray{array},
+  }) == nil {
+    t.Fatal("array union explorer returned nil")
+  }
+  if UnionExplorer.Array_or_tuple(UnionExplorer_ArrayOrTupleProps{
+    Config:      config,
+    Parameters:  []*shimast.Node{parameter},
+    Input:       input,
+    Definitions: []any{tuple, array},
+  }) == nil {
+    t.Fatal("mixed array-or-tuple explorer returned nil")
+  }
+  if failures != 1 {
+    t.Fatalf("mixed union must construct exactly one failure callback, got %d", failures)
+  }
 
-	iterated := false
-	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), false) == nil || !iterated {
-		t.Fatal("array disambiguation helper did not invoke iterator")
-	}
-	if unionExplorer_return_or_statement(input) == nil ||
-		unionExplorer_return_or_statement(factory.NewReturnStatement(input)).Kind != shimast.KindReturnStatement {
-		t.Fatal("return-or-statement helper returned unexpected node")
-	}
-	explore := UnionExplorer_IExplore{Source: "source"}
-	if unionExplorer_with_tracable(explore, true).(UnionExplorer_IExplore).Tracable != true ||
-		unionExplorer_with_tracable(&explore, true).(UnionExplorer_IExplore).Source != "source" ||
-		unionExplorer_with_tracable(map[string]any{"source": "source"}, true).(map[string]any)["tracable"] != true ||
-		unionExplorer_with_tracable("plain", true).(string) != "plain" {
-		t.Fatal("tracable explore helper mismatch")
-	}
-	if unionExplorer_with_postfix(explore, true, ".x").(UnionExplorer_IExplore).Postfix != ".x" ||
-		unionExplorer_with_postfix(&explore, true, ".x").(UnionExplorer_IExplore).Postfix != ".x" ||
-		unionExplorer_with_postfix(map[string]any{"source": "source"}, true, ".x").(map[string]any)["postfix"] != ".x" ||
-		unionExplorer_with_postfix("plain", true, ".x").(string) != "plain" {
-		t.Fatal("postfix explore helper mismatch")
-	}
+  iterated := false
+  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), false) == nil || !iterated {
+    t.Fatal("array disambiguation helper did not invoke iterator")
+  }
+  if unionExplorer_return_or_statement(input) == nil ||
+    unionExplorer_return_or_statement(factory.NewReturnStatement(input)).Kind != shimast.KindReturnStatement {
+    t.Fatal("return-or-statement helper returned unexpected node")
+  }
+  explore := UnionExplorer_IExplore{Source: "source"}
+  if unionExplorer_with_tracable(explore, true).Tracable != true ||
+    unionExplorer_with_tracable(explore, true).Source != "source" ||
+    explore.Tracable {
+    t.Fatal("tracable explore helper mismatch")
+  }
+  if unionExplorer_with_postfix(explore, true, ".x").Postfix != ".x" ||
+    unionExplorer_with_postfix(explore, true, ".x").Tracable != true ||
+    explore.Postfix != "" {
+    t.Fatal("postfix explore helper mismatch")
+  }
 
-	tag := nativemetadata.IMetadataTypeTag{Kind: "sequence"}
-	if len(protobufUtil_firstTagRow(nil)) != 0 ||
-		len(protobufUtil_firstTagRow([][]nativemetadata.IMetadataTypeTag{{tag}})) != 1 {
-		t.Fatal("protobuf first tag row extraction mismatch")
-	}
-	for _, value := range []any{int(1), int32(2), int64(3), uint(4), uint32(5), uint64(6), float32(7), float64(8), "9"} {
-		if protobufUtil_toFloat(value) == 0 {
-			t.Fatalf("protobuf float conversion failed for %T", value)
-		}
-	}
-	if parsed := protobufUtil_toFloat(struct{ Value int }{Value: 10}); parsed != 0 {
-		t.Fatalf("fallback float conversion should return zero for struct text, got %f", parsed)
-	}
-	if ProtobufUtil.GetSequence([]nativemetadata.IMetadataTypeTag{
-		{Kind: "format", Schema: map[string]any{"x-protobuf-sequence": 1}},
-		{Kind: "sequence", Schema: "invalid"},
-		{Kind: "sequence", Schema: map[string]any{"x-protobuf-sequence": "11"}},
-	}) == nil {
-		t.Fatal("protobuf sequence should parse string-backed sequence value")
-	}
+  tag := nativemetadata.IMetadataTypeTag{Kind: "sequence"}
+  if len(protobufUtil_firstTagRow(nil)) != 0 ||
+    len(protobufUtil_firstTagRow([][]nativemetadata.IMetadataTypeTag{{tag}})) != 1 {
+    t.Fatal("protobuf first tag row extraction mismatch")
+  }
+  for index, value := range []any{int(1), int32(2), int64(3), uint(4), uint32(5), uint64(6), float32(7), float64(8), "9"} {
+    if actual := protobufUtil_toFloat(value); actual != float64(index+1) {
+      t.Fatalf("protobuf float conversion for %T: got %v want %d", value, actual, index+1)
+    }
+  }
+  if parsed := protobufUtil_toFloat(struct{ Value int }{Value: 10}); parsed != 0 {
+    t.Fatalf("fallback float conversion should return zero for struct text, got %f", parsed)
+  }
+  if sequence := ProtobufUtil.GetSequence([]nativemetadata.IMetadataTypeTag{
+    {Kind: "format", Schema: map[string]any{"x-protobuf-sequence": 1}},
+    {Kind: "sequence", Schema: "invalid"},
+    {Kind: "sequence", Schema: map[string]any{"x-protobuf-sequence": "11"}},
+  }); sequence == nil || *sequence != 11 {
+    t.Fatal("protobuf sequence should preserve the authored string-backed value 11")
+  }
 }

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

@@ -15,6 +15,11 @@ import (
 // 1. Build two branches with a shared disjoint literal property.
 // 2. Assert both specializations select that shared property.
 // 3. Assert both specializations carry Neighbor=true.
+//
+// @evidence contracts/testing.md#behavioral-verification Object-union specialization runs on two branches with a shared disjoint literal property and every specialization must carry Neighbor=true.
+// @evidence contracts/testing.md#independent-expectations A disjoint shared property can discriminate only if emitters check its value, which the Neighbor flag requests; the authored branches state the disjointness.
+// @evidence contracts/testing.md#distinguishing-cases One two-branch union; branches without a shared property are owned by the other predicator cases.
+// @evidence contracts/testing.md#execution-ownership The canonical native Go command (pnpm test:go:native) runs this same-package Test function in process. It calls the predicator on constructed metadata with no checker, filesystem fixture or process.
 func TestUnionPredicatorChecksNeighborFlag(t *testing.T) {
   objects := []*nativemetadata.MetadataObjectType{
     unionPredicatorObject("Left",

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

@@ -15,6 +15,11 @@ import (
 // 1. Build branches sharing a primitive/native-wrapper property.
 // 2. Assert UnionPredicator chooses the branch-unique properties instead.
 // 3. Repeat for every atomic-like native wrapper.
+//
+// @evidence contracts/testing.md#behavioral-verification Union specialization runs on branches sharing a property typed as a primitive on one side and a wrapper native on the other; the property must not be chosen as the discriminator.
+// @evidence contracts/testing.md#independent-expectations String, Number and Boolean natives accept matching primitives at runtime, so the property overlaps; the authored branches and the expected choice of unique properties follow that.
+// @evidence contracts/testing.md#distinguishing-cases String, number and boolean primitive-versus-wrapper sharing are negative cases for discriminator selection; the neighbor-flag case owns shared disjoint string literals.
+// @evidence contracts/testing.md#execution-ownership The canonical native Go command (pnpm test:go:native) runs this same-package Test function in process. It calls the predicator on constructed metadata with no checker, filesystem fixture or process.
 func TestUnionPredicatorSkipsAtomicLikeNativeFields(t *testing.T) {
   cases := []struct {
     name   string

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

@@ -16,6 +16,11 @@ import (
 // 2. Build two branches sharing a Map property with different key/value schemas.
 // 3. Build two branches sharing an array/tuple property with shared values.
 // 4. Assert branch-unique properties are selected instead of the collection key.
+//
+// @evidence contracts/testing.md#behavioral-verification Union specialization runs on branches sharing Set, Map or array/tuple properties with different element schemas; none of them may be selected as a discriminator.
+// @evidence contracts/testing.md#independent-expectations Empty collections satisfy any element schema and arrays overlap tuples, so shared collection properties are unsafe; the authored shapes state the sharing.
+// @evidence contracts/testing.md#distinguishing-cases Set, Map and array-versus-tuple sharing are three negatives; collection properties unique to one branch are not asserted.
+// @evidence contracts/testing.md#execution-ownership The canonical native Go command (pnpm test:go:native) runs this same-package Test function in process. It calls the predicator on constructed metadata with no checker, filesystem fixture or process.
 func TestUnionPredicatorSkipsCollectionBucketFields(t *testing.T) {
   cases := []struct {
     name   string

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

@@ -17,6 +17,11 @@ import (
 //  2. Assert the shared native property is not selected by UnionPredicator.
 //  3. Repeat with tagged `Uint8Array` metadata whose runtime check is still name
 //     based.
+//
+// @evidence contracts/testing.md#behavioral-verification Union specialization runs on two authored two-branch layouts sharing Date or differently tagged Uint8Array fields; specialization count, indices, object/property identity, literal keys and Neighbor flags are compared.
+// @evidence contracts/testing.md#independent-expectations Native types with equal constructor names overlap, so such a field cannot discriminate; the expected specification list per layout is authored.
+// @evidence contracts/testing.md#distinguishing-cases Both layouts have shared native fields and one unique required property per branch. Date versus differently tagged Uint8Array separates constructor-name overlap from metadata identity; no layout without a unique property is asserted here.
+// @evidence contracts/testing.md#execution-ownership The canonical native Go command (pnpm test:go:native) runs this same-package Test function in process. It calls the predicator on constructed metadata with no checker, filesystem fixture or process.
 func TestUnionPredicatorSkipsSharedNativeNames(t *testing.T) {
   cases := []struct {
     name   string

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

@@ -15,6 +15,11 @@ import (
 // 1. Build two branches sharing an object-valued property.
 // 2. Give each branch one unique primitive property.
 // 3. Assert UnionPredicator selects only the branch-unique properties.
+//
+// @evidence contracts/testing.md#behavioral-verification Union specialization runs on two branches sharing an object-valued property plus one unique primitive each; the unique properties must be chosen.
+// @evidence contracts/testing.md#independent-expectations Both branches can accept object-shaped values for the shared key, so only unique properties discriminate; authored from that rule.
+// @evidence contracts/testing.md#distinguishing-cases Shared object key versus unique primitives; shared primitive keys are owned by other cases.
+// @evidence contracts/testing.md#execution-ownership The canonical native Go command (pnpm test:go:native) runs this same-package Test function in process. It calls the predicator on constructed metadata with no checker, filesystem fixture or process.
 func TestUnionPredicatorSkipsSharedObjectFields(t *testing.T) {
   objects := []*nativemetadata.MetadataObjectType{
     unionPredicatorObject("Left",

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

@@ -15,6 +15,11 @@ import (
 // 1. Build two branches with overlapping template-literal-like properties.
 // 2. Give each branch its own required property.
 // 3. Assert UnionPredicator selects the branch-unique properties instead.
+//
+// @evidence contracts/testing.md#behavioral-verification Union specialization runs on branches sharing overlapping template-literal properties plus one unique required property each; the shared template property must not be selected.
+// @evidence contracts/testing.md#independent-expectations Two template patterns may overlap at runtime, so the shared key cannot discriminate; authored from that rule.
+// @evidence contracts/testing.md#distinguishing-cases Overlapping templates against unique required keys; disjoint templates are not asserted.
+// @evidence contracts/testing.md#execution-ownership The canonical native Go command (pnpm test:go:native) runs this same-package Test function in process. It calls the predicator on constructed metadata with no checker, filesystem fixture or process.
 func TestUnionPredicatorSkipsSharedTemplateFields(t *testing.T) {
   cases := []struct {
     name  string

package/native/core/programmers/http/HttpAssertFormDataProgrammer.go

@@ -14,6 +14,15 @@ type httpAssertFormDataProgrammerNamespace struct{}
 
 var HttpAssertFormDataProgrammer = httpAssertFormDataProgrammerNamespace{}
 
+// HttpAssertFormDataProgrammer_DecomposeProps is the argument record of
+// HttpAssertFormDataProgrammer.Decompose, which builds the asserting form-data
+// decoder. Init is the default initializer of the generated `errorFactory`
+// parameter, or nil.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of HttpAssertFormDataProgrammer.Decompose, which builds the asserting form-data decoder; its 5 fields (Context, Functor, Type, Name, Init) are named so that a producer and a consumer cannot transpose them.
+// @evidence contracts/common.md#clear-and-simple-design A 5-field record with no methods.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record: it derives, defaults and validates nothing.
+// @evidence contracts/common.md#meaningful-documentation The doc states what the record is and explains its non-obvious fields.
 type HttpAssertFormDataProgrammer_DecomposeProps struct {
   Context nativecontext.ITypiaContext
   Functor *nativehelpers.FunctionProgrammer

package/native/core/programmers/http/HttpAssertHeadersProgrammer.go

@@ -13,6 +13,15 @@ type httpAssertHeadersProgrammerNamespace struct{}
 
 var HttpAssertHeadersProgrammer = httpAssertHeadersProgrammerNamespace{}
 
+// HttpAssertHeadersProgrammer_DecomposeProps is the argument record of
+// HttpAssertHeadersProgrammer.Decompose, which builds the asserting headers
+// decoder. Init is the default initializer of the generated `errorFactory`
+// parameter, or nil.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of HttpAssertHeadersProgrammer.Decompose, which builds the asserting headers decoder; its 5 fields (Context, Functor, Type, Name, Init) are named so that a producer and a consumer cannot transpose them.
+// @evidence contracts/common.md#clear-and-simple-design A 5-field record with no methods.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record: it derives, defaults and validates nothing.
+// @evidence contracts/common.md#meaningful-documentation The doc states what the record is and explains its non-obvious fields.
 type HttpAssertHeadersProgrammer_DecomposeProps struct {
   Context nativecontext.ITypiaContext
   Functor *nativehelpers.FunctionProgrammer

package/native/core/programmers/http/HttpAssertQueryProgrammer.go

@@ -13,6 +13,16 @@ type httpAssertQueryProgrammerNamespace struct{}
 
 var HttpAssertQueryProgrammer = httpAssertQueryProgrammerNamespace{}
 
+// HttpAssertQueryProgrammer_IProps is the argument record of
+// HttpAssertQueryProgrammer.Write, which builds the asserting query decoder.
+// Init is the default initializer of the generated `errorFactory` parameter, or
+// nil. AllowOptional permits an optional target query type when all properties
+// are optional; it does not make the decoder input optional.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of HttpAssertQueryProgrammer.Write, which builds the asserting query decoder; its 6 fields (Context, Modulo, Type, Name, Init, AllowOptional) are named so that a producer and a consumer cannot transpose them.
+// @evidence contracts/common.md#clear-and-simple-design A 6-field record with no methods.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record: it derives, defaults and validates nothing.
+// @evidence contracts/common.md#meaningful-documentation The doc states what the record is and explains its non-obvious fields.
 type HttpAssertQueryProgrammer_IProps struct {
   Context       nativecontext.ITypiaContext
   Modulo        *shimast.Node
@@ -22,6 +32,16 @@ type HttpAssertQueryProgrammer_IProps struct {
   AllowOptional bool
 }
 
+// HttpAssertQueryProgrammer_DecomposeProps is the argument record of
+// HttpAssertQueryProgrammer.Decompose, which builds the asserting query decoder.
+// Init is the default initializer of the generated `errorFactory` parameter, or
+// nil. AllowOptional permits an optional target query type when all properties
+// are optional; it does not make the decoder input optional.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of HttpAssertQueryProgrammer.Decompose, which builds the asserting query decoder; its 6 fields (Context, Functor, Type, Name, Init, AllowOptional) are named so that a producer and a consumer cannot transpose them.
+// @evidence contracts/common.md#clear-and-simple-design A 6-field record with no methods.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record: it derives, defaults and validates nothing.
+// @evidence contracts/common.md#meaningful-documentation The doc states what the record is and explains its non-obvious fields.
 type HttpAssertQueryProgrammer_DecomposeProps struct {
   Context       nativecontext.ITypiaContext
   Functor       *nativehelpers.FunctionProgrammer

package/native/core/programmers/http/HttpFormDataProgrammer.go

@@ -5,6 +5,7 @@ import (
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimchecker "github.com/microsoft/typescript-go/shim/checker"
+  shimprinter "github.com/microsoft/typescript-go/shim/printer"
   nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
   nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
   nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
@@ -16,6 +17,13 @@ type httpFormDataProgrammerNamespace struct{}
 
 var HttpFormDataProgrammer = httpFormDataProgrammerNamespace{}
 
+// HttpFormDataProgrammer_DecomposeProps is the argument record of
+// HttpFormDataProgrammer.Decompose, which builds the form-data decoder.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of HttpFormDataProgrammer.Decompose, which builds the form-data decoder; its 4 fields (Context, Functor, Type, Name) are named so that a producer and a consumer cannot transpose them.
+// @evidence contracts/common.md#clear-and-simple-design A 4-field record with no methods.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record: it derives, defaults and validates nothing.
+// @evidence contracts/common.md#meaningful-documentation The doc states what the record is.
 type HttpFormDataProgrammer_DecomposeProps struct {
   Context nativecontext.ITypiaContext
   Functor *nativehelpers.FunctionProgrammer
@@ -240,11 +248,13 @@ func httpFormDataProgrammer_decode_regular_property(props struct {
           httpFormDataProgrammer_decode_value(struct {
             Context  nativecontext.ITypiaContext
             Type     string
+            Nullable bool
             Coalesce bool
             Input    *shimast.Node
           }{
             Context:  props.Context,
             Type:     typ,
+            Nullable: httpProgrammer_decode_nullable(value),
             Coalesce: false,
             Input:    f.NewIdentifier("elem"),
           }),
@@ -265,12 +275,14 @@ func httpFormDataProgrammer_decode_regular_property(props struct {
     input = httpFormDataProgrammer_decode_value(struct {
       Context  nativecontext.ITypiaContext
       Type     string
+      Nullable bool
       Coalesce bool
       Input    *shimast.Node
     }{
       Context:  props.Context,
       Type:     typ,
-      Coalesce: value.Nullable == false && value.IsRequired() == false,
+      Nullable: httpProgrammer_decode_nullable(value),
+      Coalesce: value.Nullable == false && value.Any == false && value.IsRequired() == false,
       Input:    input,
     })
   }
@@ -286,6 +298,7 @@ func httpFormDataProgrammer_decode_regular_property(props struct {
 func httpFormDataProgrammer_decode_value(props struct {
   Context  nativecontext.ITypiaContext
   Type     string
+  Nullable bool
   Coalesce bool
   Input    *shimast.Node
 }) *shimast.Node {
@@ -294,7 +307,7 @@ func httpFormDataProgrammer_decode_value(props struct {
     httpParameterProgrammer_internal(props.Context, "httpFormDataRead"+httpParameterProgrammer_capitalize(props.Type)),
     nil,
     nil,
-    f.NewNodeList([]*shimast.Node{props.Input}),
+    f.NewNodeList(httpProgrammer_read_arguments(props.Type, props.Nullable, props.Input, props.Context.Emit)),
     shimast.NodeFlagsNone,
   )
   if props.Coalesce == false {
@@ -373,6 +386,39 @@ func httpProgrammer_property_key(property *schemametadata.MetadataProperty) stri
   return ""
 }
 
+// httpProgrammer_decode_nullable tells whether one decoded unit admits `null`:
+// the element for an array property, the property itself otherwise. `any` and
+// `unknown` admit it as well, and decode through the string reader.
+func httpProgrammer_decode_nullable(value *schemametadata.MetadataSchema) bool {
+  admits := func(unit *schemametadata.MetadataSchema) bool {
+    return unit != nil && (unit.Nullable || unit.Any)
+  }
+  if value == nil {
+    return false
+  }
+  if len(value.Arrays) != 0 {
+    return admits(value.Arrays[0].Type.Value)
+  }
+  if len(value.Tuples) != 0 && len(value.Tuples[0].Type.Elements) != 0 {
+    return admits(value.Tuples[0].Type.Elements[0])
+  }
+  return admits(value)
+}
+
+// httpProgrammer_read_arguments lists the arguments of one `_http*Read*` call.
+//
+// A string reader turns the text `"null"` into `null` unless told the type does
+// not admit it (samchon/typia#2450), so a non-nullable string passes `false`.
+// Every other call keeps the single argument, and so does a nullable string,
+// whose emit stays byte-identical to what earlier versions produced.
+func httpProgrammer_read_arguments(typ string, nullable bool, input *shimast.Node, emit ...*shimprinter.EmitContext) []*shimast.Node {
+  if typ != "string" || nullable {
+    return []*shimast.Node{input}
+  }
+  f := nativecontext.EmitFactoryOf(httpFormDataProgrammer_factory, emit...)
+  return []*shimast.Node{input, f.NewKeywordExpression(shimast.KindFalseKeyword)}
+}
+
 func httpProgrammer_decode_type(value *schemametadata.MetadataSchema, blob bool) (string, bool) {
   return httpProgrammer_decode_type_from_metadata(value, blob, false)
 }

package/native/core/programmers/http/HttpHeadersProgrammer.go

@@ -20,6 +20,13 @@ var HttpHeadersProgrammer = httpHeadersProgrammerNamespace{}
 
 const HttpHeadersProgrammer_INPUT_TYPE = "Record<string, string | string[] | undefined>"
 
+// HttpHeadersProgrammer_DecomposeProps is the argument record of
+// HttpHeadersProgrammer.Decompose, which builds the headers decoder.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of HttpHeadersProgrammer.Decompose, which builds the headers decoder; its 4 fields (Context, Functor, Type, Name) are named so that a producer and a consumer cannot transpose them.
+// @evidence contracts/common.md#clear-and-simple-design A 4-field record with no methods.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record: it derives, defaults and validates nothing.
+// @evidence contracts/common.md#meaningful-documentation The doc states what the record is.
 type HttpHeadersProgrammer_DecomposeProps struct {
   Context nativecontext.ITypiaContext
   Functor *nativehelpers.FunctionProgrammer
@@ -243,7 +250,13 @@ func httpHeadersProgrammer_decode_object(props struct {
         nativefactories.ExpressionFactory.Number(0, props.Context.Emit),
         nil,
         f.NewToken(shimast.KindEqualsEqualsEqualsToken),
-        nativefactories.IdentifierFactory.Access(props.Context.Emit, access, "length"),
+        f.NewBinaryExpression(
+          nil,
+          nativefactories.IdentifierFactory.Access(props.Context.Emit, access, "length", true),
+          nil,
+          f.NewToken(shimast.KindQuestionQuestionToken),
+          nativefactories.ExpressionFactory.Number(0, props.Context.Emit),
+        ),
       ),
       f.NewExpressionStatement(
         f.NewDeleteExpression(access),
@@ -272,8 +285,10 @@ func httpHeadersProgrammer_decode_regular_property(props struct {
   )
   var decoded *shimast.Node
   if isArray {
-    if key == "set-cookie" {
-      decoded = input
+    // The input is read by the key's lowercase name, so a declared
+    // `"Set-Cookie": string[]` is the same header.
+    if strings.ToLower(key) == "set-cookie" {
+      decoded = httpHeadersProgrammer_decode_set_cookie(props.Context, typ, input, value.IsRequired())
     } else {
       decoded = httpHeadersProgrammer_decode_array(struct {
         Context nativecontext.ITypiaContext
@@ -309,6 +324,50 @@ func httpHeadersProgrammer_decode_regular_property(props struct {
   )
 }
 
+// httpHeadersProgrammer_decode_set_cookie decodes `set-cookie` without the
+// list decoder: cookie attributes such as `Expires` contain `", "`, so a value
+// is never split or trimmed. It still yields an array like every other array
+// header does: a lone string is one cookie, an absent required header is `[]`
+// (samchon/typia#2447), and a non-string element type is read by the same
+// reader other array headers use.
+func httpHeadersProgrammer_decode_set_cookie(context nativecontext.ITypiaContext, typ string, input *shimast.Node, required bool) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(httpHeadersProgrammer_factory, context.Emit)
+  array := input
+  single := input
+  if typ != "string" {
+    reader := httpParameterProgrammer_internal(context, "httpHeaderRead"+httpParameterProgrammer_capitalize(typ))
+    array = f.NewCallExpression(
+      nativefactories.IdentifierFactory.Access(context.Emit, input, "map"),
+      nil,
+      nil,
+      f.NewNodeList([]*shimast.Node{reader}),
+      shimast.NodeFlagsNone,
+    )
+    single = f.NewCallExpression(reader, nil, nil, f.NewNodeList([]*shimast.Node{input}), shimast.NodeFlagsNone)
+  }
+  absent := f.NewIdentifier("undefined")
+  if required {
+    absent = f.NewArrayLiteralExpression(f.NewNodeList(nil), false)
+  }
+  return nativefactories.ExpressionFactory.Conditional(
+    nativefactories.ExpressionFactory.IsArray(input, context.Emit),
+    array,
+    nativefactories.ExpressionFactory.Conditional(
+      f.NewBinaryExpression(
+        nil,
+        f.NewIdentifier("undefined"),
+        nil,
+        f.NewToken(shimast.KindExclamationEqualsEqualsToken),
+        input,
+      ),
+      f.NewArrayLiteralExpression(f.NewNodeList([]*shimast.Node{single}), false),
+      absent,
+      context.Emit,
+    ),
+    context.Emit,
+  )
+}
+
 func httpHeadersProgrammer_decode_value(props struct {
   Context nativecontext.ITypiaContext
   Type    string
@@ -362,7 +421,7 @@ func httpHeadersProgrammer_decode_array(props struct {
     reader = httpParameterProgrammer_internal(props.Context, "httpHeaderRead"+httpParameterProgrammer_capitalize(props.Type))
   }
   delimiter := ", "
-  if props.Key == "cookie" {
+  if strings.ToLower(props.Key) == "cookie" {
     delimiter = "; "
   }
   split := f.NewCallExpression(

package/native/core/programmers/http/HttpIsFormDataProgrammer.go

@@ -15,6 +15,14 @@ type httpIsFormDataProgrammerNamespace struct{}
 
 var HttpIsFormDataProgrammer = httpIsFormDataProgrammerNamespace{}
 
+// HttpIsFormDataProgrammer_DecomposeProps is the argument record of
+// HttpIsFormDataProgrammer.Decompose, which builds the form-data decoder that
+// answers null for an invalid input.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of HttpIsFormDataProgrammer.Decompose, which builds the form-data decoder that answers null for an invalid input; its 4 fields (Context, Functor, Type, Name) are named so that a producer and a consumer cannot transpose them.
+// @evidence contracts/common.md#clear-and-simple-design A 4-field record with no methods.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record: it derives, defaults and validates nothing.
+// @evidence contracts/common.md#meaningful-documentation The doc states what the record is.
 type HttpIsFormDataProgrammer_DecomposeProps struct {
   Context nativecontext.ITypiaContext
   Functor *nativehelpers.FunctionProgrammer