typia 15.0.1 → 15.1.0

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

@@ -8,12 +8,27 @@ import (
   nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
+// Check_array_lengthProps is the argument record of Check_array_length, which
+// builds the check entry of an array type's type-tag conditions.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of Check_array_length, which builds the check entry of an array type's type-tag conditions; its 3 fields (Context, Array, Input) are named so that a producer and a consumer cannot transpose them.
+// @evidence contracts/common.md#clear-and-simple-design A 3-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 Check_array_lengthProps struct {
   Context nativecontext.ITypiaContext
   Array   *nativemetadata.MetadataArray
   Input   *shimast.Expression
 }
 
+// Check_array_length builds the check entry of an array type: its display name
+// as the expected description and its type-tag conditions, with no guard
+// expression of its own.
+//
+// @evidence contracts/common.md#principled-implementation It builds the check entry of an array type: its display name as the expected description and its type-tag conditions, with no guard expression of its own.
+// @evidence contracts/common.md#clear-and-simple-design One exported function; the pieces that repeat live in private helpers of the same file.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Its inputs are its arguments and the context they carry, and it keeps no state of its own.
+// @evidence contracts/common.md#meaningful-documentation The doc states what it builds.
 func Check_array_length(props Check_array_lengthProps) nativehelpers.ICheckEntry {
   conditions := check_array_type_tags(props)
   return nativehelpers.ICheckEntry{

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

@@ -8,12 +8,26 @@ import (
   nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
+// Check_bigintProps is the argument record of Check_bigint, which builds the
+// check entry of a bigint atomic.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of Check_bigint, which builds the check entry of a bigint atomic; its 3 fields (Context, Atomic, Input) are named so that a producer and a consumer cannot transpose them.
+// @evidence contracts/common.md#clear-and-simple-design A 3-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 Check_bigintProps struct {
   Context nativecontext.ITypiaContext
   Atomic  *nativemetadata.MetadataAtomic
   Input   *shimast.Expression
 }
 
+// Check_bigint builds the check entry of a bigint atomic: a `typeof input ===
+// "bigint"` guard plus the atomic's type-tag conditions.
+//
+// @evidence contracts/common.md#principled-implementation It builds the check entry of a bigint atomic: a `typeof input === "bigint"` guard plus the atomic's type-tag conditions.
+// @evidence contracts/common.md#clear-and-simple-design One exported function; the pieces that repeat live in private helpers of the same file.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Its inputs are its arguments and the context they carry, and it keeps no state of its own.
+// @evidence contracts/common.md#meaningful-documentation The doc states what it builds.
 func Check_bigint(props Check_bigintProps) nativehelpers.ICheckEntry {
   f := nativecontext.EmitFactoryOf(check_bigint_factory, props.Context.Emit)
   conditions := check_bigint_type_tags(props)

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

@@ -10,12 +10,29 @@ import (
   nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
+// Check_dynamic_keyProps is the argument record of Check_dynamic_key, which
+// tests a dynamic key against the metadata of an index signature.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of Check_dynamic_key, which tests a dynamic key against the metadata of an index signature; its 3 fields (Context, Metadata, Input) are named so that a producer and a consumer cannot transpose them.
+// @evidence contracts/common.md#clear-and-simple-design A 3-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 Check_dynamic_keyProps struct {
   Context  nativecontext.ITypiaContext
   Metadata *nativemetadata.MetadataSchema
   Input    *shimast.Expression
 }
 
+// Check_dynamic_key builds the condition that a dynamic key, which is a string
+// at runtime, spells a value of the index signature's key metadata: `true` for a
+// pure string key, and otherwise a disjunction of the spellings that the
+// metadata admits. A string shortcut applies only when no runtime type-tag
+// condition is emitted, including exclusions carried by schema fragments.
+//
+// @evidence contracts/common.md#principled-implementation It builds the condition that a dynamic key, which is a string at runtime, spells a value of the index signature's key metadata: `true` for a pure string key, and otherwise a disjunction of the spellings that the metadata admits.
+// @evidence contracts/common.md#clear-and-simple-design One exported function; the pieces that repeat live in private helpers of the same file.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Its inputs are its arguments and the context they carry, and it keeps no state of its own.
+// @evidence contracts/common.md#meaningful-documentation The doc states what it builds.
 func Check_dynamic_key(props Check_dynamic_keyProps) *shimast.Node {
   f := nativecontext.EmitFactoryOf(check_dynamic_key_factory, props.Context.Emit)
   if check_dynamic_key_has_pure_string(props.Metadata) {
@@ -180,8 +197,22 @@ func Check_dynamic_key(props Check_dynamic_keyProps) *shimast.Node {
 func check_dynamic_key_has_pure_string(metadata *nativemetadata.MetadataSchema) bool {
   if len(metadata.Atomics) != 0 {
     for _, atomic := range metadata.Atomics {
-      if atomic.Type == "string" && len(check_dynamic_key_fully_validated_tag_rows(atomic.Tags)) == 0 {
-        return true
+      if atomic.Type == "string" {
+        constrained := false
+        for _, row := range atomic.Tags {
+          for _, tag := range row {
+            if tag.Validate != "" || (tag.Kind == "exclude" && len(check_exclude_values(tag)) != 0) {
+              constrained = true
+              break
+            }
+          }
+          if constrained {
+            break
+          }
+        }
+        if !constrained {
+          return true
+        }
       }
     }
   }
@@ -195,23 +226,6 @@ func check_dynamic_key_has_pure_string(metadata *nativemetadata.MetadataSchema)
   return false
 }
 
-func check_dynamic_key_fully_validated_tag_rows(rows [][]nativemetadata.IMetadataTypeTag) [][]nativemetadata.IMetadataTypeTag {
-  output := [][]nativemetadata.IMetadataTypeTag{}
-  for _, row := range rows {
-    passed := true
-    for _, tag := range row {
-      if tag.Validate == "" {
-        passed = false
-        break
-      }
-    }
-    if passed {
-      output = append(output, row)
-    }
-  }
-  return output
-}
-
 func check_dynamic_key_atomist(entry nativehelpers.ICheckEntry, emit ...*shimprinter.EmitContext) *shimast.Node {
   expressions := []*shimast.Node{}
   if entry.Expression != nil {

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

@@ -4,43 +4,70 @@
 package iterate
 
 import (
-	"testing"
+  "testing"
 
-	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
-// TestCheckDynamicKeyTagRows filters fully validated tag rows.
+// TestCheckDynamicKeyTagRows verifies runtime constraints prevent pure-string shortcuts.
 //
-// Dynamic key validation must only treat a string atomic as constrained when
-// every tag in a row supplies a runtime validation expression. Empty rows are
-// valid, partially specified rows are not, and native String keys remain pure.
+// Default and schema-only tags do not emit a condition. MinLength and schema
+// exclusions do, including beside Default in the same row. Their conditions
+// must survive dynamic-key checking instead of an unconditional string shortcut.
 //
-// 1. Build tag rows with empty, fully validated, and partially validated rows.
-// 2. Assert only rows whose tags all validate are returned.
-// 3. Build string atomic metadata with a partially validated row.
-// 4. Assert that metadata is still treated as a pure string key.
+// 1. Build empty, schema-only, fully validated and mixed string tag rows.
+// 2. Check the active pure-string predicate with authored true/false controls.
+// 3. Keep native String as a pure positive control.
+//
+// @evidence contracts/testing.md#behavioral-verification The consumed string-constraint predicate runs on empty, schema-only, fully validating, mixed Default/MinLength and exclusion rows, plus native String keys.
+// @evidence contracts/testing.md#independent-expectations Authored runtime conditions constrain strings even beside schema-only tags, matching what Check_string emits. Default.ts/MinLength.ts and MetadataTypeTagFactory preserve these tags together; no expected boolean comes from the shortcut.
+// @evidence contracts/testing.md#distinguishing-cases Original empty/full/partial and annotation/native distinctions exercise the consumed predicate; the obsolete unused all-validating filter has no product contract. Default-only stays pure, while Default/MinLength and exclusion do not.
+// @evidence contracts/testing.md#execution-ownership The typia_native_internal Go runner calls the actual same-package predicate on constructed metadata in process, without checker or subprocess; factory provenance is source-reviewed, not executed by this case.
 func TestCheckDynamicKeyTagRows(t *testing.T) {
-	rows := [][]nativemetadata.IMetadataTypeTag{
-		{},
-		{{Name: "MinLength", Validate: "input.length >= 1"}},
-		{{Name: "Format"}, {Name: "Pattern", Validate: "pattern.test(input)"}},
-	}
-	filtered := check_dynamic_key_fully_validated_tag_rows(rows)
-	if len(filtered) != 2 {
-		t.Fatalf("expected two fully validated rows, got %#v", filtered)
-	}
+  meta := nativemetadata.MetadataSchema_create(nativemetadata.MetadataSchema{
+    Atomics: []*nativemetadata.MetadataAtomic{
+      nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{
+        Type: "string",
+        Tags: [][]nativemetadata.IMetadataTypeTag{{
+          {Name: "Format"},
+        }},
+      }),
+    },
+  })
+  if !check_dynamic_key_has_pure_string(meta) {
+    t.Fatal("string atomic with non-validating tags should be treated as pure string")
+  }
 
-	meta := nativemetadata.MetadataSchema_create(nativemetadata.MetadataSchema{
-		Atomics: []*nativemetadata.MetadataAtomic{
-			nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{
-				Type: "string",
-				Tags: [][]nativemetadata.IMetadataTypeTag{{
-					{Name: "Format"},
-				}},
-			}),
-		},
-	})
-	if !check_dynamic_key_has_pure_string(meta) {
-		t.Fatal("string atomic with non-validating tags should be treated as pure string")
-	}
+  for _, tc := range []struct {
+    name string
+    tags [][]nativemetadata.IMetadataTypeTag
+    pure bool
+  }{
+    {name: "empty", tags: [][]nativemetadata.IMetadataTypeTag{{}}, pure: true},
+    {name: "schema-only", tags: [][]nativemetadata.IMetadataTypeTag{{{Name: "Format"}}}, pure: true},
+    {name: "validated", tags: [][]nativemetadata.IMetadataTypeTag{{{Name: "MinLength", Validate: "input.length >= 1"}}}, pure: false},
+    {name: "default-only", tags: [][]nativemetadata.IMetadataTypeTag{{{Name: "Default", Kind: "default", Value: "x", Schema: map[string]any{"default": "x"}}}}, pure: true},
+    {name: "default-minLength", tags: [][]nativemetadata.IMetadataTypeTag{{{Name: "Default", Kind: "default", Value: "x", Schema: map[string]any{"default": "x"}}, {Name: "MinLength", Kind: "minLength", Value: 1, Validate: "$input.length >= 1", Schema: map[string]any{"minLength": 1}}}}, pure: false},
+    {name: "exclude-only", tags: [][]nativemetadata.IMetadataTypeTag{{{Name: "Exclude", Kind: "exclude", Schema: map[string]any{"not": map[string]any{"enum": []any{"no"}}}}}}, pure: false},
+    {name: "mixed", tags: [][]nativemetadata.IMetadataTypeTag{{{Name: "Format"}, {Name: "Pattern", Validate: "pattern.test(input)"}}}, pure: false},
+  } {
+    t.Run(tc.name, func(t *testing.T) {
+      key := nativemetadata.MetadataSchema_create(nativemetadata.MetadataSchema{
+        Atomics: []*nativemetadata.MetadataAtomic{
+          nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: "string", Tags: tc.tags}),
+        },
+      })
+      if got := check_dynamic_key_has_pure_string(key); got != tc.pure {
+        t.Fatalf("pure string = %t, want %t", got, tc.pure)
+      }
+    })
+  }
+  native := nativemetadata.MetadataSchema_create(nativemetadata.MetadataSchema{
+    Natives: []*nativemetadata.MetadataNative{
+      nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "String"}),
+    },
+  })
+  if !check_dynamic_key_has_pure_string(native) {
+    t.Fatal("native String key should remain pure")
+  }
 }

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

@@ -11,6 +11,15 @@ import (
   nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
+// Check_dynamic_propertiesProps is the argument record of
+// Check_dynamic_properties, which checks the keys of an object that is exact or
+// has index signatures. Regular holds the entries of the sole-literal keys and
+// Dynamic those of the index signatures.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of Check_dynamic_properties, which checks the keys of an object that is exact or has index signatures; its 5 fields (Config, Context, Regular, Dynamic, Input) 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 Check_dynamic_propertiesProps struct {
   Config  Check_object_IConfig
   Context nativecontext.ITypiaContext
@@ -19,6 +28,15 @@ type Check_dynamic_propertiesProps struct {
   Input   *shimast.Expression
 }
 
+// Check_dynamic_properties builds the check over an object's keys: for an exact
+// object without index signatures it compares the number of keys with the
+// declared ones, and with index signatures it tests every key that no regular
+// property claims.
+//
+// @evidence contracts/common.md#principled-implementation It builds the check over an object's keys: for an exact object without index signatures it compares the number of keys with the declared ones, and with index signatures it tests every key that no regular property claims.
+// @evidence contracts/common.md#clear-and-simple-design One exported function; the pieces that repeat live in private helpers of the same file.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Its inputs are its arguments and the context they carry, and it keeps no state of its own.
+// @evidence contracts/common.md#meaningful-documentation The doc states what it builds.
 func Check_dynamic_properties(props Check_dynamic_propertiesProps) *shimast.Node {
   f := nativecontext.EmitFactoryOf(check_dynamic_properties_factory, props.Context.Emit)
   length := nativefactories.IdentifierFactory.Access(
@@ -313,8 +331,10 @@ func check_dynamic_properties_internal(context nativecontext.ITypiaContext, name
 // type while breaking that signature's type tags -- the question the tail has
 // to answer to tell an invalid key from a surplus property.
 //
-// It is the same `Check_dynamic_key` question asked of every signature with its
-// type tags removed, joined with `||`. The tail runs only after each full
+// It asks every signature's structural key question without runtime tag
+// predicates, joined with `||`. Templates keep the full checker's structural
+// lowering so discarding predicates does not change substring grammar.
+// The tail runs only after each full
 // condition returned false, so a signature whose declared type still answers
 // yes is one whose tags are what the key broke.
 //
@@ -334,15 +354,32 @@ func check_dynamic_properties_key_shape(props Check_dynamic_propertiesProps, key
   }
   conditions := make([]*shimast.Node, 0, len(props.Dynamic))
   for _, entry := range props.Dynamic {
-    condition := Check_dynamic_key(Check_dynamic_keyProps{
-      Context:  props.Context,
-      Metadata: check_dynamic_properties_key_untagged(entry.Key),
-      Input:    key,
-    })
-    if condition.Kind == shimast.KindTrueKeyword {
-      return condition
+    untagged := check_dynamic_properties_key_untagged(entry.Key)
+    if len(untagged.Atomics) != 0 || len(untagged.Constants) != 0 || len(untagged.Natives) != 0 ||
+      untagged.Any || untagged.Nullable || !untagged.IsRequired() {
+      condition := Check_dynamic_key(Check_dynamic_keyProps{
+        Context:  props.Context,
+        Metadata: untagged,
+        Input:    key,
+      })
+      if condition.Kind == shimast.KindTrueKeyword {
+        return condition
+      }
+      conditions = append(conditions, condition)
+    }
+    f := nativecontext.EmitFactoryOf(check_dynamic_properties_factory, props.Context.Emit)
+    for _, template := range entry.Key.Templates {
+      // Keep the same structural lowering as the full checker. Removing slot
+      // tags first would change constrained string captures from [\s\S] to .
+      // and misclassify a newline-bearing declared key as a surplus property.
+      conditions = append(conditions, f.NewCallExpression(
+        f.NewIdentifier("RegExp(/"+TemplateRuntimePattern(template.Row)+"/).test"),
+        nil,
+        nil,
+        f.NewNodeList([]*shimast.Node{key}),
+        shimast.NodeFlagsNone,
+      ))
     }
-    conditions = append(conditions, condition)
   }
   return check_dynamic_key_reduce(conditions, shimast.KindBarBarToken, props.Context.Emit)
 }
@@ -361,23 +398,40 @@ func check_dynamic_properties_key_shape(props Check_dynamic_propertiesProps, key
 // every full condition refused the key, so a stripped condition equal to one of
 // them refuses it too.
 func check_dynamic_properties_key_tagged(metadata *nativemetadata.MetadataSchema) bool {
-  for _, atomic := range metadata.Atomics {
-    for _, row := range atomic.Tags {
+  tagged := func(rows [][]nativemetadata.IMetadataTypeTag) bool {
+    for _, row := range rows {
       for _, tag := range row {
-        if tag.Validate != "" {
+        if tag.Validate != "" || (tag.Kind == "exclude" && len(check_exclude_values(tag)) != 0) {
           return true
         }
       }
     }
+    return false
+  }
+  for _, atomic := range metadata.Atomics {
+    if tagged(atomic.Tags) {
+      return true
+    }
+  }
+  for _, template := range metadata.Templates {
+    if tagged(template.Tags) {
+      return true
+    }
+    for _, child := range template.Row {
+      if _, _, ok := template_constrained_capture(child); ok {
+        return true
+      }
+    }
   }
   return false
 }
 
-// The key declaration with its type tags removed, leaving the declared type
-// alone. Templates, constants, and natives carry no tags, so only the atomics
-// are rebuilt; the clone keeps the original reportable name untouched.
+// The non-template key declaration with its atomic tags removed. Templates use
+// their original structural pattern in key_shape, so discarding runtime tag
+// predicates cannot change capture grammar. Original metadata stays untouched.
 func check_dynamic_properties_key_untagged(metadata *nativemetadata.MetadataSchema) *nativemetadata.MetadataSchema {
   clone := *metadata
+  clone.Templates = nil
   clone.Atomics = make([]*nativemetadata.MetadataAtomic, 0, len(metadata.Atomics))
   for _, atomic := range metadata.Atomics {
     clone.Atomics = append(clone.Atomics, nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{

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

@@ -7,6 +7,13 @@ import (
   nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
 )
 
+// Check_everything builds `array.every((flag: boolean) => flag)` for an array of
+// check results.
+//
+// @evidence contracts/common.md#principled-implementation It builds `array.every((flag: boolean) => flag)` for an array of check results.
+// @evidence contracts/common.md#clear-and-simple-design One exported function; the pieces that repeat live in private helpers of the same file.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Its inputs are its arguments and the context they carry, and it keeps no state of its own.
+// @evidence contracts/common.md#meaningful-documentation The doc states what it builds.
 func Check_everything(array *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
   f := nativecontext.EmitFactoryOf(check_everything_factory, emit...)
   return f.NewCallExpression(

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

@@ -8,12 +8,26 @@ import (
   nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
+// Check_nativeProps is the argument record of Check_native, which tests a
+// built-in class.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of Check_native, which tests a built-in class; its 3 fields (Name, Input, Emit) are named so that a producer and a consumer cannot transpose them.
+// @evidence contracts/common.md#clear-and-simple-design A 3-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 Check_nativeProps struct {
   Name  string
   Input *shimast.Expression
   Emit  *shimprinter.EmitContext
 }
 
+// Check_native builds the test of a built-in class: `instanceof Name`, preceded
+// by a `typeof` test for the natives that also have an atomic form.
+//
+// @evidence contracts/common.md#principled-implementation It builds the test of a built-in class: `instanceof Name`, preceded by a `typeof` test for the natives that also have an atomic form.
+// @evidence contracts/common.md#clear-and-simple-design One exported function; the pieces that repeat live in private helpers of the same file.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Its inputs are its arguments and the context they carry, and it keeps no state of its own.
+// @evidence contracts/common.md#meaningful-documentation The doc states what it builds.
 func Check_native(props Check_nativeProps) *shimast.Node {
   f := nativecontext.EmitFactoryOf(check_native_factory, props.Emit)
   instanceOf := nativefactories.ExpressionFactory.IsInstanceOf(props.Name, props.Input)

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

@@ -10,6 +10,14 @@ import (
   nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
+// Check_numberProps is the argument record of Check_number, which builds the
+// check entry of a number atomic. Numeric says whether the number is also tested
+// for being finite or not NaN, as the options decide.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of Check_number, which builds the check entry of a number atomic; its 4 fields (Numeric, Context, Atomic, Input) 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 and explains its non-obvious fields.
 type Check_numberProps struct {
   Numeric bool
   Context nativecontext.ITypiaContext
@@ -17,6 +25,14 @@ type Check_numberProps struct {
   Input   *shimast.Expression
 }
 
+// Check_number builds the check entry of a number atomic: a `typeof input ===
+// "number"` guard, extended by `Number.isFinite` or `!Number.isNaN` when the
+// options ask for it, plus the atomic's type-tag conditions.
+//
+// @evidence contracts/common.md#principled-implementation It builds the check entry of a number atomic: a `typeof input === "number"` guard, extended by `Number.isFinite` or `!Number.isNaN` when the options ask for it, plus the atomic's type-tag conditions.
+// @evidence contracts/common.md#clear-and-simple-design One exported function; the pieces that repeat live in private helpers of the same file.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Its inputs are its arguments and the context they carry, and it keeps no state of its own.
+// @evidence contracts/common.md#meaningful-documentation The doc states what it builds.
 func Check_number(props Check_numberProps) nativehelpers.ICheckEntry {
   f := nativecontext.EmitFactoryOf(check_number_factory, props.Context.Emit)
   base := f.NewBinaryExpression(

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

@@ -0,0 +1,84 @@
+package iterate
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  metadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  "testing"
+)
+
+// TestCheckNumberOptionContractMatrix verifies numeric/finite admission ASTs.
+//
+// The untagged number contract always guards typeof, numeric rejects NaN and
+// finite rejects NaN and both infinities. The Numeric producer switch can
+// deliberately suppress both additions without suppressing the number guard.
+//
+// @evidence contracts/testing.md#behavioral-verification Builds actual Check_number results for five numeric/finite option rows and both producer-switch values, inspecting guards, operators, callee names and input identity.
+// @evidence contracts/testing.md#independent-expectations The authored rows require no extra predicate, !Number.isNaN or Number.isFinite according to number admission semantics. No generated snapshot supplies expectations.
+// @evidence contracts/testing.md#distinguishing-cases Finite-only must reject infinities even with numeric off; both flags use finite rather than only NaN rejection. Numeric producer false suppresses additions in every row while retaining rejection of ill-typed values through typeof.
+// @evidence contracts/testing.md#execution-ownership The native Go runner executes this same-package unit using in-memory AST nodes, with no compiler or JavaScript subprocess. Runtime NaN and infinity input verdicts remain owned by the four actual TS producer profiles.
+func TestCheckNumberOptionContractMatrix(t *testing.T) {
+  yes, no := true, false
+  rows := []struct {
+    name            string
+    numeric, finite *bool
+    addition        string
+  }{
+    {"default", nil, nil, ""}, {"explicit-off", &no, &no, ""},
+    {"numeric-only", &yes, &no, "Number.isNaN"},
+    {"finite-only", &no, &yes, "Number.isFinite"},
+    {"numeric-and-finite", &yes, &yes, "Number.isFinite"},
+  }
+  factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+  input := factory.NewIdentifier("candidate")
+  for _, row := range rows {
+    for _, enabled := range []bool{false, true} {
+      name := row.name + "/producer-off"
+      if enabled {
+        name = row.name + "/producer-on"
+      }
+      t.Run(name, func(t *testing.T) {
+        entry := Check_number(Check_numberProps{Numeric: enabled, Context: nativecontext.ITypiaContext{Options: nativecontext.ITransformOptions{Numeric: row.numeric, Finite: row.finite}}, Atomic: metadata.MetadataAtomic_create(metadata.MetadataAtomic{Type: "number"}), Input: input})
+        if entry.Expected != "number" || len(entry.Conditions) != 0 {
+          t.Fatalf("untagged number contract changed: %#v", entry)
+        }
+        expression := entry.Expression
+        expected := row.addition
+        if !enabled {
+          expected = ""
+        }
+        var addition *shimast.Node
+        if expected != "" {
+          if expression.Kind != shimast.KindBinaryExpression || expression.AsBinaryExpression().OperatorToken.Kind != shimast.KindAmpersandAmpersandToken {
+            t.Fatal("number guard must precede additional admission through &&")
+          }
+          addition = expression.AsBinaryExpression().Right
+          expression = expression.AsBinaryExpression().Left
+        }
+        if expression.Kind != shimast.KindBinaryExpression {
+          t.Fatal("missing number typeof equality")
+        }
+        guard := expression.AsBinaryExpression()
+        if guard.OperatorToken.Kind != shimast.KindEqualsEqualsEqualsToken || guard.Left.Kind != shimast.KindStringLiteral || shimast.NodeText(guard.Left) != "number" || guard.Right.Kind != shimast.KindTypeOfExpression || guard.Right.AsTypeOfExpression().Expression != input {
+          t.Fatal("guard must compare literal number with typeof the original input")
+        }
+        if expected == "" {
+          return
+        }
+        if expected == "Number.isNaN" {
+          if addition.Kind != shimast.KindPrefixUnaryExpression || addition.AsPrefixUnaryExpression().Operator != shimast.KindExclamationToken {
+            t.Fatal("numeric must negate isNaN")
+          }
+          addition = addition.AsPrefixUnaryExpression().Operand
+        }
+        if addition.Kind != shimast.KindCallExpression {
+          t.Fatal("missing numeric admission call")
+        }
+        call := addition.AsCallExpression()
+        if shimast.NodeText(call.Expression) != expected || call.Arguments == nil || len(call.Arguments.Nodes) != 1 || call.Arguments.Nodes[0] != input {
+          t.Fatalf("admission must call %s on the original input", expected)
+        }
+      })
+    }
+  }
+}

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

@@ -7,6 +7,13 @@ import (
   nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
 )
 
+// Check_objectProps is the argument record of Check_object, which combines the
+// checks of an object's property entries.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of Check_object, which combines the checks of an object's property entries; its 4 fields (Config, Context, Input, Entries) 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 Check_objectProps struct {
   Config  Check_object_IConfig
   Context nativecontext.ITypiaContext
@@ -14,6 +21,19 @@ type Check_objectProps struct {
   Entries []nativehelpers.IExpressionEntry
 }
 
+// Check_object_IConfig is the configuration of Check_object and
+// Check_dynamic_properties, which tells how the checks of an object are combined
+// and reported. Equals rejects properties beyond the declared ones. Assert
+// combines the checks with Reduce, and otherwise they are collected with
+// `every`. Positive is the expression that stands for success. Undefined makes
+// the key count exact and combines it with the key test by `||` instead of `&&`.
+// Halt wraps the key check, and Superfluous reports a surplus property.
+// Entries optionally replaces the built-in key visitor collection.
+//
+// @evidence contracts/common.md#principled-implementation It is the configuration of Check_object and Check_dynamic_properties, which tells how the checks of an object are combined and reported; its 9 members (Equals, Assert, Undefined, Halt, Reduce, Positive, Superfluous, InvalidKey, Entries) are supplied by the caller, so the shared programmer holds no feature-specific behavior.
+// @evidence contracts/common.md#clear-and-simple-design A 9-member record of values and callbacks.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A declaration only.
+// @evidence contracts/common.md#meaningful-documentation The doc states the role and the meaning of the members that are not obvious.
 type Check_object_IConfig struct {
   Equals      bool
   Assert      bool
@@ -36,6 +56,14 @@ type Check_object_IConfig struct {
   Entries    *shimast.Expression
 }
 
+// Check_object splits the entries into regular and dynamic properties, checks
+// each regular one and, for an exact object or one with dynamic properties, adds
+// the key check, then combines every check.
+//
+// @evidence contracts/common.md#principled-implementation It splits the entries into regular and dynamic properties, checks each regular one and, for an exact object or one with dynamic properties, adds the key check, then combines every check.
+// @evidence contracts/common.md#clear-and-simple-design One exported function; the pieces that repeat live in private helpers of the same file.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Its inputs are its arguments and the context they carry, and it keeps no state of its own.
+// @evidence contracts/common.md#meaningful-documentation The doc states what it builds.
 func Check_object(props Check_objectProps) *shimast.Node {
   regular := []nativehelpers.IExpressionEntry{}
   dynamic := []nativehelpers.IExpressionEntry{}

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

@@ -11,13 +11,18 @@ import (
 
 // TestCheckObjectStrictOptionalUndefinedAllowsMissingKey verifies strict optional guards.
 //
-// Exact optional properties must reject a present own `undefined` value without
+// Exact optional properties must reject a present `undefined` value without
 // rejecting a missing optional key. The object checker therefore wraps strict
 // optional property expressions with a key-presence short circuit.
 //
 // 1. Build a strict optional regular entry.
 // 2. Assert its object-check expression first tests property absence.
 // 3. Assert the original strict property expression stays on the right branch.
+//
+// @evidence contracts/testing.md#behavioral-verification The object checker's strict optional property expression is built and its AST is inspected: it must be an || whose left side negates a key-presence in test.
+// @evidence contracts/testing.md#independent-expectations Exact optional semantics reject a present undefined but not a missing key, so a key-presence short circuit is required; the expected shape is authored.
+// @evidence contracts/testing.md#distinguishing-cases Only the strict optional expression is asserted; non-strict optional is owned by the predicator case.
+// @evidence contracts/testing.md#execution-ownership The canonical native Go command (pnpm test:go:native) runs this same-package Test function in process. It builds AST nodes in memory and inspects them, with no checker, filesystem fixture or process.
 func TestCheckObjectStrictOptionalUndefinedAllowsMissingKey(t *testing.T) {
   factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
   input := factory.NewIdentifier("input")

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

@@ -8,12 +8,27 @@ import (
   nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
+// Check_object_type_tagsProps is the argument record of Check_object_type_tags,
+// which builds the check entry of an object type's type-tag conditions.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of Check_object_type_tags, which builds the check entry of an object type's type-tag conditions; its 3 fields (Context, Object, Input) are named so that a producer and a consumer cannot transpose them.
+// @evidence contracts/common.md#clear-and-simple-design A 3-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 Check_object_type_tagsProps struct {
   Context nativecontext.ITypiaContext
   Object  *nativemetadata.MetadataObject
   Input   *shimast.Expression
 }
 
+// Check_object_type_tags builds the check entry of an object type: its display
+// name as the expected description and its type-tag conditions, with no guard
+// expression of its own.
+//
+// @evidence contracts/common.md#principled-implementation It builds the check entry of an object type: its display name as the expected description and its type-tag conditions, with no guard expression of its own.
+// @evidence contracts/common.md#clear-and-simple-design One exported function; the pieces that repeat live in private helpers of the same file.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Its inputs are its arguments and the context they carry, and it keeps no state of its own.
+// @evidence contracts/common.md#meaningful-documentation The doc states what it builds.
 func Check_object_type_tags(props Check_object_type_tagsProps) nativehelpers.ICheckEntry {
   conditions := check_object_type_tags(props)
   return nativehelpers.ICheckEntry{