typia 15.0.0 → 15.1.0

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/HttpParameterProgrammer.go

@@ -68,9 +68,7 @@ func (httpParameterProgrammerNamespace) Write(props nativecontext.IProgrammerPro
         httpParameterProgrammer_internal(props.Context, "httpParameterRead"+httpParameterProgrammer_capitalize(atomic)),
         nil,
         nil,
-        f.NewNodeList([]*shimast.Node{
-          f.NewIdentifier("input"),
-        }),
+        f.NewNodeList(httpProgrammer_read_arguments(atomic, result.Data.Nullable, f.NewIdentifier("input"), props.Context.Emit)),
         shimast.NodeFlagsNone,
       ),
     }, props.Context.Emit),

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

@@ -15,21 +15,46 @@ 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
   AllowOptional bool
   Type          *shimchecker.Type
   Name          *string
+
+  // Missing makes the decoder throw `Error("missing <key>")` for an absent
+  // required non-array property. Only `http.query`, which validates nothing
+  // else, asks for it. The `is`, `assert`, and `validate` variants decode
+  // through this same function and must report the absence through their own
+  // contract instead (`null`, an `IValidation` failure, `TypeGuardError`), so
+  // they leave it off (samchon/typia#2444).
+  Missing bool
 }
 
 var httpQueryProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
@@ -78,9 +103,11 @@ func (httpQueryProgrammerNamespace) Decompose(props HttpQueryProgrammer_Decompos
   statements := httpQueryProgrammer_decode_object(struct {
     Context nativecontext.ITypiaContext
     Object  *schemametadata.MetadataObjectType
+    Missing bool
   }{
     Context: props.Context,
     Object:  object,
+    Missing: props.Missing,
   })
   return nativeinternal.FeatureProgrammer_IDecomposed{
     Functions:  map[string]*shimast.Node{},
@@ -124,6 +151,7 @@ func (httpQueryProgrammerNamespace) Write(props HttpQueryProgrammer_IProps) *shi
     AllowOptional: props.AllowOptional,
     Type:          props.Type,
     Name:          props.Name,
+    Missing:       true,
   })
   return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{
     Modulo:  props.Modulo,
@@ -203,6 +231,7 @@ func (httpQueryProgrammerNamespace) Validate(props struct {
 func httpQueryProgrammer_decode_object(props struct {
   Context nativecontext.ITypiaContext
   Object  *schemametadata.MetadataObjectType
+  Missing bool
 }) []*shimast.Node {
   f := nativecontext.EmitFactoryOf(httpQueryProgrammer_factory, props.Context.Emit)
   input := f.NewIdentifier("input")
@@ -212,9 +241,11 @@ func httpQueryProgrammer_decode_object(props struct {
     properties = append(properties, httpQueryProgrammer_decode_regular_property(struct {
       Context  nativecontext.ITypiaContext
       Property *schemametadata.MetadataProperty
+      Missing  bool
     }{
       Context:  props.Context,
       Property: p,
+      Missing:  props.Missing,
     }))
   }
   return []*shimast.Node{
@@ -253,6 +284,7 @@ func httpQueryProgrammer_decode_object(props struct {
 func httpQueryProgrammer_decode_regular_property(props struct {
   Context  nativecontext.ITypiaContext
   Property *schemametadata.MetadataProperty
+  Missing  bool
 }) *shimast.Node {
   f := nativecontext.EmitFactoryOf(httpQueryProgrammer_factory, props.Context.Emit)
   key := httpProgrammer_property_key(props.Property)
@@ -277,9 +309,9 @@ func httpQueryProgrammer_decode_regular_property(props struct {
       }),
       shimast.NodeFlagsNone,
     )
-    if value.IsRequired() {
-      input = httpQueryProgrammer_assert_required_array(key, input, props.Context.Emit)
-    }
+    // An absent key reads as an empty list. A query string has no other
+    // spelling for `[]`, so a required array decodes it as `[]` rather than as
+    // a missing property, and a nullable one as `null` (samchon/typia#2444).
     input = f.NewCallExpression(
       nativefactories.IdentifierFactory.Access(
         props.Context.Emit,
@@ -301,11 +333,13 @@ func httpQueryProgrammer_decode_regular_property(props struct {
           httpQueryProgrammer_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"),
           }),
@@ -323,18 +357,20 @@ func httpQueryProgrammer_decode_regular_property(props struct {
       Input:    input,
     })
   } else {
-    if value.IsRequired() {
+    if value.IsRequired() && props.Missing {
       input = httpQueryProgrammer_assert_required_value(key, input, props.Context.Emit)
     }
     input = httpQueryProgrammer_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,
     })
   }
@@ -350,6 +386,7 @@ func httpQueryProgrammer_decode_regular_property(props struct {
 func httpQueryProgrammer_decode_value(props struct {
   Context  nativecontext.ITypiaContext
   Type     string
+  Nullable bool
   Coalesce bool
   Input    *shimast.Node
 }) *shimast.Node {
@@ -358,7 +395,7 @@ func httpQueryProgrammer_decode_value(props struct {
     httpParameterProgrammer_internal(props.Context, "httpQueryRead"+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 {
@@ -410,43 +447,6 @@ func httpQueryProgrammer_assert_required_value(key string, input *shimast.Node,
   )
 }
 
-func httpQueryProgrammer_assert_required_array(key string, input *shimast.Node, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(httpQueryProgrammer_factory, emit...)
-  value := f.NewIdentifier("value")
-  return f.NewCallExpression(
-    f.NewArrowFunction(
-      nil,
-      nil,
-      f.NewNodeList(nil),
-      nil,
-      nil,
-      f.NewToken(shimast.KindEqualsGreaterThanToken),
-      f.NewBlock(f.NewNodeList([]*shimast.Node{
-        nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-          Name:  "value",
-          Value: input,
-        }, emit...),
-        f.NewIfStatement(
-          f.NewBinaryExpression(
-            nil,
-            nativefactories.ExpressionFactory.Number(0, emit...),
-            nil,
-            f.NewToken(shimast.KindEqualsEqualsEqualsToken),
-            nativefactories.IdentifierFactory.Access(nil, value, "length"),
-          ),
-          f.NewThrowStatement(httpQueryProgrammer_missing_error(key, emit...)),
-          nil,
-        ),
-        f.NewReturnStatement(value),
-      }), true),
-    ),
-    nil,
-    nil,
-    nil,
-    shimast.NodeFlagsNone,
-  )
-}
-
 func httpQueryProgrammer_missing_error(key string, emit ...*shimprinter.EmitContext) *shimast.Node {
   f := nativecontext.EmitFactoryOf(httpQueryProgrammer_factory, emit...)
   return f.NewNewExpression(

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

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

@@ -4,11 +4,11 @@
 package http
 
 import (
-	"testing"
+  "testing"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-	schemametadata "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"
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 // TestHttpProgrammerHelperCoverage exercises HTTP array helpers.
@@ -21,100 +21,105 @@ import (
 // 2. Build nullable and optional form-data array readers.
 // 3. Build header array readers for string, number, and cookie delimiters.
 // 4. Verify HTTP import, property-key, type decoding, and debug helpers.
+//
+// @evidence contracts/testing.md#behavioral-verification HTTP array reader helpers are called for required, nullable, optional, string, number and cookie-delimited cases; the required array has identity equality and method/property-key helpers have exact text checks; debug requires nonempty text, array/import builders require non-nil nodes, and the metadata decoder checks only the array-output flag.
+// @evidence contracts/testing.md#independent-expectations Exact checks use authored text; the non-nil checks have no independent oracle and certify only construction.
+// @evidence contracts/testing.md#distinguishing-cases Required, nullable, optional and delimiter variants are each visited once; few negatives exist.
+// @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 TestHttpProgrammerHelperCoverage(t *testing.T) {
-	factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-	input := factory.NewIdentifier("input")
-	required := httpMetadata("string", true, false)
-	optional := httpMetadata("string", false, false)
-	nullable := httpMetadata("string", true, true)
-	if httpFormDataProgrammer_decode_array(struct {
-		Context  nativecontext.ITypiaContext
-		Metadata *schemametadata.MetadataSchema
-		Input    *shimast.Node
-	}{Metadata: required, Input: input}) != input {
-		t.Fatal("required form-data array should return input unchanged")
-	}
-	if httpFormDataProgrammer_decode_array(struct {
-		Context  nativecontext.ITypiaContext
-		Metadata *schemametadata.MetadataSchema
-		Input    *shimast.Node
-	}{Metadata: optional, Input: input}) == nil ||
-		httpFormDataProgrammer_decode_array(struct {
-			Context  nativecontext.ITypiaContext
-			Metadata *schemametadata.MetadataSchema
-			Input    *shimast.Node
-		}{Metadata: nullable, Input: input}) == nil {
-		t.Fatal("form-data array reader returned nil")
-	}
-	if httpHeadersProgrammer_decode_array(struct {
-		Context nativecontext.ITypiaContext
-		Type    string
-		Key     string
-		Value   *schemametadata.MetadataSchema
-		Input   *shimast.Node
-	}{Type: "string", Key: "accept", Value: required, Input: input}) == nil ||
-		httpHeadersProgrammer_decode_array(struct {
-			Context nativecontext.ITypiaContext
-			Type    string
-			Key     string
-			Value   *schemametadata.MetadataSchema
-			Input   *shimast.Node
-		}{Type: "number", Key: "cookie", Value: optional, Input: input}) == nil {
-		t.Fatal("header array reader returned nil")
-	}
-	if httpProgrammer_debug([]string{"a", "b"}) == "" {
-		t.Fatal("HTTP debug helper returned empty text")
-	}
-	if httpProgrammer_method_text(nil) != "" ||
-		httpProgrammer_method_text(factory.NewIdentifier("method")) != "method" {
-		t.Fatal("HTTP method text helper mismatch")
-	}
-	if httpProgrammer_import_type(nativecontext.ITypiaContext{}, nativecontext.ImportProgrammer_TypeProps{Name: "Alias"}) == nil ||
-		httpProgrammer_import_type(nativecontext.ITypiaContext{}, nativecontext.ImportProgrammer_TypeProps{Name: factory.NewIdentifier("AliasNode")}) == nil ||
-		httpProgrammer_import_type(nativecontext.ITypiaContext{Importer: nativecontext.NewImportProgrammer()}, nativecontext.ImportProgrammer_TypeProps{Name: "Alias"}) == nil {
-		t.Fatal("HTTP import type helper returned nil")
-	}
-	if httpProgrammer_property_key(nil) != "" ||
-		httpProgrammer_property_key(schemametadata.MetadataProperty_create(schemametadata.MetadataProperty{Key: httpLiteral("field")})) != "field" {
-		t.Fatal("HTTP property key helper mismatch")
-	}
-	nativeBlob := schemametadata.MetadataSchema_initialize()
-	nativeBlob.Natives = append(nativeBlob.Natives, schemametadata.MetadataNative_create(schemametadata.MetadataNative{Name: "Blob"}))
-	nativeFile := schemametadata.MetadataSchema_initialize()
-	nativeFile.Natives = append(nativeFile.Natives, schemametadata.MetadataNative_create(schemametadata.MetadataNative{Name: "File"}))
-	array := schemametadata.MetadataSchema_initialize()
-	array.Arrays = append(array.Arrays, schemametadata.MetadataArray_create(schemametadata.MetadataArray{
-		Type: schemametadata.MetadataArrayType_create(schemametadata.MetadataArrayType{Name: "string[]", Value: required}),
-	}))
-	tuple := schemametadata.MetadataSchema_initialize()
-	tuple.Tuples = append(tuple.Tuples, schemametadata.MetadataTuple_create(schemametadata.MetadataTuple{
-		Type: schemametadata.MetadataTupleType_create(schemametadata.MetadataTupleType{Name: "[string]", Elements: []*schemametadata.MetadataSchema{required}}),
-	}))
-	constant := schemametadata.MetadataSchema_initialize()
-	constant.Constants = append(constant.Constants, schemametadata.MetadataConstant_create(schemametadata.MetadataConstant{Type: "number"}))
-	for _, meta := range []*schemametadata.MetadataSchema{nil, required, constant, nativeBlob, nativeFile, array, tuple} {
-		if _, ok := httpProgrammer_decode_type_from_metadata(meta, true, false); meta != nil && !ok && len(meta.Arrays) != 0 {
-			t.Fatal("HTTP array decode type should report array output")
-		}
-	}
+  factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+  input := factory.NewIdentifier("input")
+  required := httpMetadata("string", true, false)
+  optional := httpMetadata("string", false, false)
+  nullable := httpMetadata("string", true, true)
+  if httpFormDataProgrammer_decode_array(struct {
+    Context  nativecontext.ITypiaContext
+    Metadata *schemametadata.MetadataSchema
+    Input    *shimast.Node
+  }{Metadata: required, Input: input}) != input {
+    t.Fatal("required form-data array should return input unchanged")
+  }
+  if httpFormDataProgrammer_decode_array(struct {
+    Context  nativecontext.ITypiaContext
+    Metadata *schemametadata.MetadataSchema
+    Input    *shimast.Node
+  }{Metadata: optional, Input: input}) == nil ||
+    httpFormDataProgrammer_decode_array(struct {
+      Context  nativecontext.ITypiaContext
+      Metadata *schemametadata.MetadataSchema
+      Input    *shimast.Node
+    }{Metadata: nullable, Input: input}) == nil {
+    t.Fatal("form-data array reader returned nil")
+  }
+  if httpHeadersProgrammer_decode_array(struct {
+    Context nativecontext.ITypiaContext
+    Type    string
+    Key     string
+    Value   *schemametadata.MetadataSchema
+    Input   *shimast.Node
+  }{Type: "string", Key: "accept", Value: required, Input: input}) == nil ||
+    httpHeadersProgrammer_decode_array(struct {
+      Context nativecontext.ITypiaContext
+      Type    string
+      Key     string
+      Value   *schemametadata.MetadataSchema
+      Input   *shimast.Node
+    }{Type: "number", Key: "cookie", Value: optional, Input: input}) == nil {
+    t.Fatal("header array reader returned nil")
+  }
+  if httpProgrammer_debug([]string{"a", "b"}) == "" {
+    t.Fatal("HTTP debug helper returned empty text")
+  }
+  if httpProgrammer_method_text(nil) != "" ||
+    httpProgrammer_method_text(factory.NewIdentifier("method")) != "method" {
+    t.Fatal("HTTP method text helper mismatch")
+  }
+  if httpProgrammer_import_type(nativecontext.ITypiaContext{}, nativecontext.ImportProgrammer_TypeProps{Name: "Alias"}) == nil ||
+    httpProgrammer_import_type(nativecontext.ITypiaContext{}, nativecontext.ImportProgrammer_TypeProps{Name: factory.NewIdentifier("AliasNode")}) == nil ||
+    httpProgrammer_import_type(nativecontext.ITypiaContext{Importer: nativecontext.NewImportProgrammer()}, nativecontext.ImportProgrammer_TypeProps{Name: "Alias"}) == nil {
+    t.Fatal("HTTP import type helper returned nil")
+  }
+  if httpProgrammer_property_key(nil) != "" ||
+    httpProgrammer_property_key(schemametadata.MetadataProperty_create(schemametadata.MetadataProperty{Key: httpLiteral("field")})) != "field" {
+    t.Fatal("HTTP property key helper mismatch")
+  }
+  nativeBlob := schemametadata.MetadataSchema_initialize()
+  nativeBlob.Natives = append(nativeBlob.Natives, schemametadata.MetadataNative_create(schemametadata.MetadataNative{Name: "Blob"}))
+  nativeFile := schemametadata.MetadataSchema_initialize()
+  nativeFile.Natives = append(nativeFile.Natives, schemametadata.MetadataNative_create(schemametadata.MetadataNative{Name: "File"}))
+  array := schemametadata.MetadataSchema_initialize()
+  array.Arrays = append(array.Arrays, schemametadata.MetadataArray_create(schemametadata.MetadataArray{
+    Type: schemametadata.MetadataArrayType_create(schemametadata.MetadataArrayType{Name: "string[]", Value: required}),
+  }))
+  tuple := schemametadata.MetadataSchema_initialize()
+  tuple.Tuples = append(tuple.Tuples, schemametadata.MetadataTuple_create(schemametadata.MetadataTuple{
+    Type: schemametadata.MetadataTupleType_create(schemametadata.MetadataTupleType{Name: "[string]", Elements: []*schemametadata.MetadataSchema{required}}),
+  }))
+  constant := schemametadata.MetadataSchema_initialize()
+  constant.Constants = append(constant.Constants, schemametadata.MetadataConstant_create(schemametadata.MetadataConstant{Type: "number"}))
+  for _, meta := range []*schemametadata.MetadataSchema{nil, required, constant, nativeBlob, nativeFile, array, tuple} {
+    if _, ok := httpProgrammer_decode_type_from_metadata(meta, true, false); meta != nil && !ok && len(meta.Arrays) != 0 {
+      t.Fatal("HTTP array decode type should report array output")
+    }
+  }
 }
 
 func httpMetadata(kind string, required bool, nullable bool) *schemametadata.MetadataSchema {
-	meta := schemametadata.MetadataSchema_initialize()
-	meta.Required = required
-	meta.Optional = !required
-	meta.Nullable = nullable
-	meta.Atomics = append(meta.Atomics, schemametadata.MetadataAtomic_create(schemametadata.MetadataAtomic{Type: kind}))
-	return meta
+  meta := schemametadata.MetadataSchema_initialize()
+  meta.Required = required
+  meta.Optional = !required
+  meta.Nullable = nullable
+  meta.Atomics = append(meta.Atomics, schemametadata.MetadataAtomic_create(schemametadata.MetadataAtomic{Type: kind}))
+  return meta
 }
 
 func httpLiteral(value string) *schemametadata.MetadataSchema {
-	meta := schemametadata.MetadataSchema_initialize()
-	meta.Constants = append(meta.Constants, schemametadata.MetadataConstant_create(schemametadata.MetadataConstant{
-		Type: "string",
-		Values: []*schemametadata.MetadataConstantValue{
-			schemametadata.MetadataConstantValue_create(schemametadata.MetadataConstantValue{Value: value}),
-		},
-	}))
-	return meta
+  meta := schemametadata.MetadataSchema_initialize()
+  meta.Constants = append(meta.Constants, schemametadata.MetadataConstant_create(schemametadata.MetadataConstant{
+    Type: "string",
+    Values: []*schemametadata.MetadataConstantValue{
+      schemametadata.MetadataConstantValue_create(schemametadata.MetadataConstantValue{Value: value}),
+    },
+  }))
+  return meta
 }