typia 15.0.1 → 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

@@ -17,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

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

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

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

@@ -13,6 +13,14 @@ type httpIsHeadersProgrammerNamespace struct{}
 
 var HttpIsHeadersProgrammer = httpIsHeadersProgrammerNamespace{}
 
+// HttpIsHeadersProgrammer_DecomposeProps is the argument record of
+// HttpIsHeadersProgrammer.Decompose, which builds the headers decoder that
+// answers null for an invalid input.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of HttpIsHeadersProgrammer.Decompose, which builds the headers 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 HttpIsHeadersProgrammer_DecomposeProps struct {
   Context nativecontext.ITypiaContext
   Functor *nativehelpers.FunctionProgrammer

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

@@ -13,15 +13,33 @@ type httpIsQueryProgrammerNamespace struct{}
 
 var HttpIsQueryProgrammer = httpIsQueryProgrammerNamespace{}
 
+// HttpIsQueryProgrammer_IProps is the argument record of
+// HttpIsQueryProgrammer.Write, which builds the query decoder that answers null
+// for an invalid input. 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 HttpIsQueryProgrammer.Write, which builds the query decoder that answers null for an invalid input; its 5 fields (Context, Modulo, Type, Name, AllowOptional) 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 HttpIsQueryProgrammer_IProps struct {
   Context       nativecontext.ITypiaContext
   Modulo        *shimast.Node
   Type          *shimchecker.Type
   Name          *string
-  Init          *shimast.Node
   AllowOptional bool
 }
 
+// HttpIsQueryProgrammer_DecomposeProps is the argument record of
+// HttpIsQueryProgrammer.Decompose, which builds the query decoder that answers
+// null for an invalid input. 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 HttpIsQueryProgrammer.Decompose, which builds the query decoder that answers null for an invalid input; its 5 fields (Context, Functor, Type, Name, AllowOptional) 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 HttpIsQueryProgrammer_DecomposeProps struct {
   Context       nativecontext.ITypiaContext
   Functor       *nativehelpers.FunctionProgrammer

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

@@ -15,15 +15,32 @@ type httpQueryProgrammerNamespace struct{}
 
 var HttpQueryProgrammer = httpQueryProgrammerNamespace{}
 
+// HttpQueryProgrammer_IProps is the argument record of
+// HttpQueryProgrammer.Write, which builds the query decoder.
+// 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 HttpQueryProgrammer.Write, which builds the query decoder; its 5 fields (Context, Modulo, Type, Name, AllowOptional) 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 HttpQueryProgrammer_IProps struct {
   Context       nativecontext.ITypiaContext
   Modulo        *shimast.Node
   Type          *shimchecker.Type
   Name          *string
-  Init          *shimast.Node
   AllowOptional bool
 }
 
+// HttpQueryProgrammer_DecomposeProps is the argument record of
+// HttpQueryProgrammer.Decompose, which builds the query decoder.
+// 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 HttpQueryProgrammer.Decompose, which builds the query decoder; its 6 fields (Context, Functor, AllowOptional, Type, Name, Missing) 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 HttpQueryProgrammer_DecomposeProps struct {
   Context       nativecontext.ITypiaContext
   Functor       *nativehelpers.FunctionProgrammer

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

@@ -14,6 +14,14 @@ type httpValidateFormDataProgrammerNamespace struct{}
 
 var HttpValidateFormDataProgrammer = httpValidateFormDataProgrammerNamespace{}
 
+// HttpValidateFormDataProgrammer_DecomposeProps is the argument record of
+// HttpValidateFormDataProgrammer.Decompose, which builds the form-data decoder
+// that returns an IValidation.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of HttpValidateFormDataProgrammer.Decompose, which builds the form-data decoder that returns an IValidation; its 5 fields (Context, Modulo, Functor, Type, Name) 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.
 type HttpValidateFormDataProgrammer_DecomposeProps struct {
   Context nativecontext.ITypiaContext
   Modulo  *shimast.Node

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

@@ -13,6 +13,14 @@ type httpValidateHeadersProgrammerNamespace struct{}
 
 var HttpValidateHeadersProgrammer = httpValidateHeadersProgrammerNamespace{}
 
+// HttpValidateHeadersProgrammer_DecomposeProps is the argument record of
+// HttpValidateHeadersProgrammer.Decompose, which builds the headers decoder that
+// returns an IValidation.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of HttpValidateHeadersProgrammer.Decompose, which builds the headers decoder that returns an IValidation; its 5 fields (Context, Modulo, Functor, Type, Name) 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.
 type HttpValidateHeadersProgrammer_DecomposeProps struct {
   Context nativecontext.ITypiaContext
   Modulo  *shimast.Node

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

@@ -13,15 +13,32 @@ type httpValidateQueryProgrammerNamespace struct{}
 
 var HttpValidateQueryProgrammer = httpValidateQueryProgrammerNamespace{}
 
+// HttpValidateQueryProgrammer_IProps is the argument record of
+// HttpValidateQueryProgrammer.Write, which builds the query decoder that returns
+// an IValidation. 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 HttpValidateQueryProgrammer.Write, which builds the query decoder that returns an IValidation; its 5 fields (Context, Modulo, Type, Name, AllowOptional) 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 HttpValidateQueryProgrammer_IProps struct {
   Context       nativecontext.ITypiaContext
   Modulo        *shimast.Node
   Type          *shimchecker.Type
   Name          *string
-  Init          *shimast.Node
   AllowOptional bool
 }
 
+// HttpValidateQueryProgrammer_DecomposeProps is the argument record of
+// HttpValidateQueryProgrammer.Decompose, which builds the query decoder that
+// returns an IValidation. 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 HttpValidateQueryProgrammer.Decompose, which builds the query decoder that returns an IValidation; its 6 fields (Context, Modulo, Functor, Type, Name, 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 HttpValidateQueryProgrammer_DecomposeProps struct {
   Context       nativecontext.ITypiaContext
   Modulo        *shimast.Node