typia 15.0.0 → 15.1.0

package/native/core/factories/internal/metadata/js_doc_type_tag_blank_separation_test.go

@@ -0,0 +1,88 @@
+//go:build typia_native_internal
+// +build typia_native_internal
+
+package metadata
+
+import (
+  "path/filepath"
+  "reflect"
+  "testing"
+
+  nativeast "github.com/microsoft/typescript-go/shim/ast"
+  nativecore "github.com/microsoft/typescript-go/shim/core"
+  nativeparser "github.com/microsoft/typescript-go/shim/parser"
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+// TestJsDocTypeTagBlankSeparation verifies blank comment lines preserve tag data.
+//
+// Formatting separates native JSDoc groups with blank starred lines. Those
+// separators are comment syntax, not literal payload added to a type tag;
+// genuine asterisks in a tag's description must remain data.
+//
+//  1. Parse compact, braced and blank-separated tags with native whitespace spellings.
+//  2. Extract tags through the same metadata helper used by the native producer.
+//  3. Compare exact payloads, keeping literal stars, linked-text separation and
+//     Unicode prefixes that the JSDoc scanner treats as content.
+//
+// @evidence contracts/testing.md#behavioral-verification ParseSourceFile creates actual JSDoc nodes and metadata_node_js_doc_tags extracts their public metadata values; exact tag arrays expose added star payload or dropped legitimate description text.
+// @evidence contracts/testing.md#independent-expectations Literal arrays follow the JSDoc scanner's ASCII-started whitespace and CR/LF delimiter rules; Unicode-only prefixes and Unicode line characters remain content, as confirmed against TypeScript's independent JSDoc parser. Expected link labels, integer values and literal stars are authored separately from the metadata helper.
+// @evidence contracts/testing.md#distinguishing-cases Compact and braced tags, CRLF and ASCII horizontal whitespace, and ASCII-started mixed Unicode horizontal whitespace retain integer meaning; inline and continuation literal stars, Unicode-only prefix content and Unicode line characters prevent over-removal. Line and paragraph separators after an ASCII space must not be crossed to strip a genuine star. Linked descriptions retain their separating newline. All nineteen spellings report independent subtest identities.
+// @evidence contracts/testing.md#execution-ownership This tagged same-package Go unit directly calls the parser and owning private metadata helper in one test process, with an in-memory source and no native plugin host or filesystem fixture; the canonical typia_native_internal Go command executes its Test entry and subtests.
+func TestJsDocTypeTagBlankSeparation(t *testing.T) {
+  filename, err := filepath.Abs("type-tag.ts")
+  if err != nil {
+    t.Fatal(err)
+  }
+  for _, fixture := range []struct {
+    name        string
+    text        string
+    description string
+    minimum     string
+  }{
+    {"adjacent", "* @type int\n * @minimum 3\n * @title literal * marks", "", "3"},
+    {"ascii-unicode-line-content", "* @type int\n \u2028*\n * @minimum 3\n * @title literal * marks", "*", "3"},
+    {"ascii-unicode-paragraph-content", "* @type int\n \u2029*\n * @minimum 3\n * @title literal * marks", "*", "3"},
+    {"separated", "* @type int\n *\n * @minimum 3\n *\n * @title literal * marks", "", "3"},
+    {"braced", "* @type {int}\n *\n * @minimum 3\n *\n * @title literal * marks", "", "3"},
+    {"inline-star", "* @type int *\n * @minimum 3\n * @title literal * marks", "*", "3"},
+    {"next-line-star", "* @type int\n * *\n * @minimum 3\n * @title literal * marks", "*", "3"},
+    {"linked-description", "* @type int\n * {@link Left}\n * {@link Right}\n * @minimum 3\n * @title literal * marks", "Left\nRight", "3"},
+    {"crlf-separated", "* @type int\r\n *\r\n * @minimum 3\r\n *\r\n * @title literal * marks", "", "3"},
+    {"tab-separated", "* @type int\n\t*\n\t* @minimum 3\n\t*\n\t* @title literal * marks", "", "3"},
+    {"vertical-tab-separated", "* @type int\n\v*\n\v* @minimum 3\n\v*\n\v* @title literal * marks", "", "3"},
+    {"form-feed-separated", "* @type int\n\f*\n\f* @minimum 3\n\f*\n\f* @title literal * marks", "", "3"},
+    {"space-nbsp-separated", "* @type int\n \u00a0*\n \u00a0* @minimum 3\n \u00a0*\n \u00a0* @title literal * marks", "", "3"},
+    {"space-bom-separated", "* @type int\n \ufeff*\n \ufeff* @minimum 3\n \ufeff*\n \ufeff* @title literal * marks", "", "3"},
+    {"space-zero-width-separated", "* @type int\n \u200b*\n \u200b* @minimum 3\n \u200b*\n \u200b* @title literal * marks", "", "3"},
+    {"nbsp-content", "* @type int\n\u00a0*\n\u00a0* @minimum 3\n\u00a0*\n\u00a0* @title literal * marks", "*", "3\n\u00a0*\n\u00a0*"},
+    {"bom-content", "* @type int\n\ufeff*\n\ufeff* @minimum 3\n\ufeff*\n\ufeff* @title literal * marks", "*", "3\n\ufeff*\n\ufeff*"},
+    {"zero-width-content", "* @type int\n\u200b*\n\u200b* @minimum 3\n\u200b*\n\u200b* @title literal * marks", "*", "3\n\u200b*\n\u200b*"},
+    {"unicode-line-content", "* @type int\u2028 *\u2028 * @minimum 3\u2029 *\u2029 * @title literal * marks", "*", "3\u2029 *\u2029 *"},
+  } {
+    t.Run(fixture.name, func(t *testing.T) {
+      file := nativeparser.ParseSourceFile(
+        nativeast.SourceFileParseOptions{FileName: filepath.ToSlash(filename)},
+        "interface Box {\n /**\n "+fixture.text+"\n */\n field: number;\n}\n",
+        nativecore.ScriptKindTS,
+      )
+      member := file.Statements.Nodes[0].AsInterfaceDeclaration().Members.Nodes[0]
+      symbol := &nativeast.Symbol{
+        Name:             "field",
+        ValueDeclaration: member,
+        Declarations:     []*nativeast.Node{member},
+      }
+      wanted := []schemametadata.IJsDocTagInfo{
+        {Name: "type", Text: []schemametadata.IJsDocTagInfo_IText{{Kind: "text", Text: "int"}}},
+        {Name: "minimum", Text: []schemametadata.IJsDocTagInfo_IText{{Kind: "text", Text: fixture.minimum}}},
+        {Name: "title", Text: []schemametadata.IJsDocTagInfo_IText{{Kind: "text", Text: "literal * marks"}}},
+      }
+      if fixture.description != "" {
+        wanted[0].Text = append(wanted[0].Text, schemametadata.IJsDocTagInfo_IText{Kind: "text", Text: fixture.description})
+      }
+      if actual := metadata_node_js_doc_tags(symbol); !reflect.DeepEqual(actual, wanted) {
+        t.Fatalf("tag payload changed: got %#v, want %#v", actual, wanted)
+      }
+    })
+  }
+}

package/native/core/factories/internal/metadata/sort_constants_coverage_test.go

@@ -4,10 +4,10 @@
 package metadata
 
 import (
-	"math"
-	"testing"
+  "reflect"
+  "testing"
 
-	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 // TestSortConstantsCoverage exercises metadata sort helpers.
@@ -20,44 +20,55 @@ import (
 // 2. Sort number, string, bigint, and boolean constant buckets.
 // 3. Verify the metadata union index path runs with an empty collection.
 // 4. Assert sorted values land in deterministic ascending order.
+//
+// @evidence contracts/testing.md#behavioral-verification Numeric conversion helpers are compared with exact authored float values, including zero and a negative value; unknown input must convert to zero. Every sorted bucket is compared with its complete authored value sequence, preserving each value's representation.
+// @evidence contracts/testing.md#independent-expectations Numeric ordering of authored constants defines the expected order.
+// @evidence contracts/testing.md#distinguishing-cases Each numeric representation and four constant types are exercised, with unknown conversion, zero and a negative input as controls. Complete sequence checks detect lost or incorrectly ordered trailing values; stability and bigint lexical-versus-numeric ordering are not distinguished by these inputs.
+// @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 calls the helpers on constructed metadata with no program load or process.
 func TestSortConstantsCoverage(t *testing.T) {
-	for _, value := range []any{float64(1.5), float32(2.5), int(3), int64(4), int32(5), uint(6), uint64(7), uint32(8)} {
-		if iterate_metadata_sort_float(value) == 0 {
-			t.Fatalf("numeric conversion failed for %T", value)
-		}
-	}
-	if iterate_metadata_sort_float(struct{}{}) != 0 {
-		t.Fatal("unknown numeric conversion should return zero")
-	}
-	meta := schemametadata.MetadataSchema_initialize()
-	meta.Constants = append(meta.Constants,
-		sortCoverageConstant("number", 3, float32(1.5), uint64(2)),
-		sortCoverageConstant("string", "b", "a"),
-		sortCoverageConstant("bigint", uint64(3), int64(-1)),
-		sortCoverageConstant("boolean", true, false),
-	)
-	Iterate_metadata_sort(struct {
-		Collection *schemametadata.MetadataCollection
-		Metadata   *schemametadata.MetadataSchema
-	}{
-		Collection: schemametadata.NewMetadataCollection(),
-		Metadata:   meta,
-	})
-	if math.Abs(iterate_metadata_sort_float(meta.Constants[0].Values[0].Value)-1.5) > 0.0001 ||
-		meta.Constants[1].Values[0].Value != "a" ||
-		meta.Constants[2].Values[0].Value != int64(-1) ||
-		meta.Constants[3].Values[0].Value != false {
-		t.Fatal("metadata constants were not sorted as expected")
-	}
+  for _, item := range []struct {
+    value    any
+    expected float64
+  }{{float64(1.5), 1.5}, {float32(2.5), 2.5}, {int(3), 3}, {int64(4), 4}, {int32(5), 5}, {uint(6), 6}, {uint64(7), 7}, {uint32(8), 8}, {int(0), 0}, {int(-1), -1}} {
+    if actual := iterate_metadata_sort_float(item.value); actual != item.expected {
+      t.Fatalf("numeric conversion for %T: got %v, want %v", item.value, actual, item.expected)
+    }
+  }
+  if iterate_metadata_sort_float(struct{}{}) != 0 {
+    t.Fatal("unknown numeric conversion should return zero")
+  }
+  meta := schemametadata.MetadataSchema_initialize()
+  meta.Constants = append(meta.Constants,
+    sortCoverageConstant("number", 3, float32(1.5), uint64(2)),
+    sortCoverageConstant("string", "b", "a"),
+    sortCoverageConstant("bigint", uint64(3), int64(-1)),
+    sortCoverageConstant("boolean", true, false),
+  )
+  Iterate_metadata_sort(struct {
+    Collection *schemametadata.MetadataCollection
+    Metadata   *schemametadata.MetadataSchema
+  }{
+    Collection: schemametadata.NewMetadataCollection(),
+    Metadata:   meta,
+  })
+  for index, expected := range [][]any{{float32(1.5), uint64(2), int(3)}, {"a", "b"}, {int64(-1), uint64(3)}, {false, true}} {
+    actual := make([]any, len(meta.Constants[index].Values))
+    for position, value := range meta.Constants[index].Values {
+      actual[position] = value.Value
+    }
+    if !reflect.DeepEqual(actual, expected) {
+      t.Fatalf("%s constants: got %#v, want %#v", meta.Constants[index].Type, actual, expected)
+    }
+  }
 }
 
 func sortCoverageConstant(kind string, values ...any) *schemametadata.MetadataConstant {
-	output := make([]*schemametadata.MetadataConstantValue, 0, len(values))
-	for _, value := range values {
-		output = append(output, schemametadata.MetadataConstantValue_create(schemametadata.MetadataConstantValue{Value: value}))
-	}
-	return schemametadata.MetadataConstant_create(schemametadata.MetadataConstant{
-		Type:   kind,
-		Values: output,
-	})
+  output := make([]*schemametadata.MetadataConstantValue, 0, len(values))
+  for _, value := range values {
+    output = append(output, schemametadata.MetadataConstantValue_create(schemametadata.MetadataConstantValue{Value: value}))
+  }
+  return schemametadata.MetadataConstant_create(schemametadata.MetadataConstant{
+    Type:   kind,
+    Values: output,
+  })
 }

package/native/core/factories/internal/metadata/type_arguments_precondition_test.go

@@ -18,6 +18,11 @@ import (
 //  1. Load primitive and generic reference declarations through the checker.
 //  2. Verify the primitive follows the unsupported-input fallback.
 //  3. Verify the reference returns its sole string argument.
+//
+// @evidence contracts/testing.md#behavioral-verification A temporary TypeScript project is loaded in-process and the type-arguments helper is called on a primitive and on a generic reference; the primitive must yield none and the reference its arguments.
+// @evidence contracts/testing.md#independent-expectations TypeScript semantics (only object-reference types have type arguments) decide the expectation, observed through the checker.
+// @evidence contracts/testing.md#distinguishing-cases Primitive and generic reference form the pair.
+// @evidence contracts/testing.md#execution-ownership The canonical native Go command (pnpm test:go:native) runs this same-package Test function in process. It writes a temporary project and loads it with the in-process typescript-go program API; no tsc or ttsc process or native command build is started.
 func TestMetadataTypeArgumentsPrecondition(t *testing.T) {
   dir := t.TempDir()
   if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(`{

package/native/core/factories/json_metadata_factory_dedupes_bigint_diagnostics_test.go

@@ -16,6 +16,11 @@ import (
 // 1. Build metadata holding atomic bigint, a bigint constant, and native BigInt.
 // 2. Validate it through `JsonMetadataFactory`.
 // 3. Require exactly one bigint diagnostic.
+//
+// @evidence contracts/testing.md#behavioral-verification JSON metadata validation runs on a schema holding atomic bigint, a bigint constant and native BigInt, and exactly one bigint diagnostic must be reported.
+// @evidence contracts/testing.md#independent-expectations The union fills three buckets for one unsupported type, so the authored expectation is one message.
+// @evidence contracts/testing.md#distinguishing-cases One three-bucket union; a single bucket is covered by the native rejection 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 calls the validator on constructed metadata with no checker, filesystem fixture or process.
 func TestJsonMetadataFactoryDedupesBigintDiagnostics(t *testing.T) {
   meta := schemametadata.MetadataSchema_initialize()
   meta.Atomics = append(meta.Atomics, schemametadata.MetadataAtomic_create(schemametadata.MetadataAtomic{Type: "bigint"}))

package/native/core/factories/json_metadata_factory_rejects_bigint_native_test.go

@@ -16,6 +16,11 @@ import (
 // 1. Build metadata with only a native `BigInt` bucket.
 // 2. Validate it through `JsonMetadataFactory`.
 // 3. Require the bigint unsupported diagnostic.
+//
+// @evidence contracts/testing.md#behavioral-verification JSON metadata validation runs on a schema with only a native BigInt bucket and must report the unsupported-bigint diagnostic.
+// @evidence contracts/testing.md#independent-expectations JSON cannot serialize boxed BigInt, so rejection is the authored expectation.
+// @evidence contracts/testing.md#distinguishing-cases Native BigInt alone is the positive rejection; native Number or other wrappers 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 validator on constructed metadata with no checker, filesystem fixture or process.
 func TestJsonMetadataFactoryRejectsBigIntNative(t *testing.T) {
   meta := schemametadata.MetadataSchema_initialize()
   meta.Natives = append(meta.Natives, schemametadata.MetadataNative_create(schemametadata.MetadataNative{Name: "BigInt"}))

package/native/core/factories/literal_factory_null_survives_objects_test.go

@@ -19,6 +19,11 @@ import (
 //  2. Assert the marker is written as null and the plain nil is omitted where
 //     the writer omits it.
 //  3. Assert the marker is not nil-like.
+//
+// @evidence contracts/testing.md#behavioral-verification The null marker is marshaled in a plain map; an ordered object then compares the retained null marker with an omitted plain nil. The nil-like classifier must reject the marker and accept nil.
+// @evidence contracts/testing.md#independent-expectations JSON null must survive while Go nil is dropped by object writers; the expected JSON text is authored.
+// @evidence contracts/testing.md#distinguishing-cases Marker versus nil is checked in the ordered object and in the classifier; the plain map checks only marker serialization. The emitted AST is owned by the named TypeScript integration test.
+// @evidence contracts/testing.md#execution-ownership The canonical native Go command (pnpm test:go:native) runs this same-package Test function in process. It marshals in memory with no checker, filesystem fixture or process.
 func TestLiteralFactoryNullSurvivesObjects(t *testing.T) {
   encoded, err := json.Marshal(map[string]any{"example": LiteralFactory_Null{}})
   if err != nil || string(encoded) != `{"example":null}` {

package/native/core/factories/literal_factory_ordered_object_marshals_json_test.go

@@ -15,6 +15,11 @@ import (
 // The JSON form must be the plain object the printer would emit: entries in
 // Keys order, entries absent from Values skipped, nil-like values skipped,
 // and nested ordered objects (value or pointer) serialized the same way.
+//
+// @evidence contracts/testing.md#behavioral-verification An ordered object is marshaled with encoding/json and the whole text is compared with the expected JSON object.
+// @evidence contracts/testing.md#independent-expectations The expected JSON object, keys in insertion order, is authored from the OpenAPI schema shape consumers need.
+// @evidence contracts/testing.md#distinguishing-cases The authored object distinguishes key-list order from map order, missing and nil values from present values, unlisted values from listed ones, and includes a nested ordered-object pointer. Empty objects and nested value-form objects 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 marshals in memory with no checker, filesystem fixture or process.
 func TestLiteralFactoryOrderedObjectMarshalsJSON(t *testing.T) {
   input := LiteralFactory_OrderedObject{
     Keys: []string{"second", "first", "absent", "nil", "nested"},

package/native/core/factories/metadata_comment_tag_factory_coverage_test.go

@@ -20,6 +20,11 @@ import (
 // 3. Verify unsupported metadata targets are reported as factory errors.
 // 4. Cover parser aliases, invalid numeric values, and date-time fallback paths.
 // 5. Confirm exported Get returns typed comment tags and panics on missing tags.
+//
+// @evidence contracts/testing.md#behavioral-verification JSDoc comment tags are parsed and applied to array, string, number and bigint metadata, with unknown and missing-value tags and typed numeric comments; many assertions are exact (tag kinds, normalized numbers, reports) and some only check presence.
+// @evidence contracts/testing.md#independent-expectations Authored comment texts and the expected normalized values or reports are literals; presence-only checks carry no independent value and are a limitation.
+// @evidence contracts/testing.md#distinguishing-cases Unknown, missing-value, unique-items and typed numeric cases and unsupported targets give positives and negatives; many branches share one test so failures are located by message.
+// @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. It calls the comment tag factory on constructed metadata with no checker, filesystem fixture or process.
 func TestMetadataCommentTagFactoryCoverage(t *testing.T) {
   reports := []string{}
   report := func(msg string) any {

package/native/core/factories/metadata_comment_tag_factory_exclusivity_matches_interface_test.go

@@ -21,11 +21,16 @@ import (
 // metadataTypeTagFactoryTestDeclarations -- the same mirror the type-tag tests
 // use -- and asserts the comment factory now produces the identical list.
 //
-// 1. Build the array-form authority (kind -> exclusive kinds) from the shared
-//    declaration mirror, and note the kinds that declare a bare `true`.
-// 2. Parse one representative JSDoc comment per tag kind through the factory.
-// 3. Assert the produced tag's kind and `Exclusive` match the authority exactly,
-//    so `@format`/`@pattern` carry `["format", "pattern"]` and no list drifts.
+//  1. Build the array-form authority (kind -> exclusive kinds) from the shared
+//     declaration mirror, and note the kinds that declare a bare `true`.
+//  2. Parse one representative JSDoc comment per tag kind through the factory.
+//  3. Assert the produced tag's kind and `Exclusive` match the authority exactly,
+//     so `@format`/`@pattern` carry `["format", "pattern"]` and no list drifts.
+//
+// @evidence contracts/testing.md#behavioral-verification Every JSDoc comment tag is parsed and the produced tag key and Exclusive list are compared with the @typia/interface declaration transcribed in the test.
+// @evidence contracts/testing.md#independent-expectations The interface declarations are the specification of exclusivity; the transcription is authored separately from the factory's per-parser copies.
+// @evidence contracts/testing.md#distinguishing-cases One row per tag, so a drifted exclusive list on any single tag fails; tags added to the interface later are not detected automatically.
+// @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 factory in memory with no checker, filesystem fixture or process.
 func TestMetadataCommentTagFactoryExclusivityMatchesInterface(t *testing.T) {
   arrayForm := map[string][]string{}
   for _, declaration := range metadataTypeTagFactoryTestDeclarations() {

package/native/core/factories/metadata_comment_tag_factory_holds_bigint_tags_exact_test.go

@@ -0,0 +1,173 @@
+package factories
+
+import (
+  "fmt"
+  "testing"
+
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+// TestMetadataCommentTagFactoryHoldsBigintTagsExact verifies a numeric comment
+// tag states a bigint bound only when it can state it exactly.
+//
+// The bigint arm of `@minimum`, `@maximum`, `@exclusiveMinimum`,
+// `@exclusiveMaximum`, and `@multipleOf` read its value through a double, so
+// `@minimum 9007199254740993` was enforced as 9007199254740992: the bound
+// validators splice a number literal JavaScript rounds, and `random` drew from
+// the rounded schema while the `@multipleOf` check stayed exact
+// (samchon/typia#2457). Every consumer of the bigint record holds its value as
+// a double, so the record now admits an integer only when a double represents
+// it exactly, within the int64 range of samchon/typia#2352, and splices its
+// exact digits into the bigint check. A number target keeps reading the text
+// as `Number()` does.
+//
+//  1. Admit integers a double represents exactly, whatever their spelling, and
+//     splice their exact digits into the bigint check.
+//  2. Refuse every other finite value as a bigint bound: integers a double
+//     cannot represent, integers beyond int64, and non-integers, including
+//     ones `Number()` rounds to an integer.
+//  3. Report a refused value on a bigint property, and on the bigint part of a
+//     `number | bigint` one, while a number property and the number part
+//     still take the tag, and report text that is no finite number once.
+//
+// @evidence contracts/testing.md#behavioral-verification Numeric comment tags on bigint targets are parsed from large integers, non-integers, infinities and malformed text; exact bigint values, spliced checks and the single refusal report are compared, and number targets must still apply.
+// @evidence contracts/testing.md#independent-expectations Authored int64 values and decimal splice strings establish the accepted exact integers independently of the parser. Rejection inputs distinguish values outside the supported int64/exact-double representation; the test compares integer results directly, not via float64.
+// @evidence contracts/testing.md#distinguishing-cases Exactly representable and rounding-hazard values, non-finite text and the number-target control separate exact bigint bounds from lossy ones.
+// @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 factory in memory with no checker, filesystem fixture or process.
+func TestMetadataCommentTagFactoryHoldsBigintTagsExact(t *testing.T) {
+  //----
+  // 1. exact integers
+  //----
+  for _, item := range []struct {
+    text  string
+    value int64
+  }{
+    {"9007199254740991", 9007199254740991},
+    {"9007199254740992", 9007199254740992},
+    {"18014398509481984", 18014398509481984},     // 2^54
+    {"54043195528445952", 54043195528445952},     // 3 * 2^54, although `String()` spells it ...950
+    {"1152921504606846976", 1152921504606846976}, // 2^60
+    {"1.152921504606846976e18", 1152921504606846976},
+    {"-9007199254740992", -9007199254740992},
+    {"1e3", 1000},
+    {"0x10", 16},
+    {"-0", 0},
+    {"0e999999999", 0},
+    {"0E5", 0},
+    {"0e99999999999999999999", 0}, // an exponent `big.Rat` cannot parse
+    {"0x0", 0},
+    {"10000000000000000", 10000000000000000},
+  } {
+    value, numeric, ok := metadataCommentTagFactory_bigint(item.text)
+    if ok == false || numeric == false || value != item.value {
+      t.Fatalf("%s must be the bigint %d, got %d (numeric=%v ok=%v)", item.text, item.value, value, numeric, ok)
+    }
+    if spliced := metadataCommentTagFactory_splice_integer(item.text); spliced != fmt.Sprint(item.value) {
+      t.Fatalf("%s must splice into a bigint check as %d, got %s", item.text, item.value, spliced)
+    }
+  }
+
+  //----
+  // 2. finite values no bigint tag states, and text that is no number
+  //----
+  for _, text := range []string{
+    "9007199254740993",     // rounds to ...992
+    "9007199254740993.0",   // the same integer, spelled with a point
+    "9.007199254740993e15", // and with an exponent
+    "-9007199254740993",
+    "0x20000000000001",     // 2^53 + 1 in hexadecimal
+    "1152921504606847000",  // `String(2 ** 60)`, which is not 2^60
+    "10000000000000000000", // beyond int64
+    "1.5",
+    "1e-3",
+    "5.0000000000000001", // `Number()` reads 5
+    "1e-400",             // `Number()` reads 0
+    "1e-1000001",         // underflows to 0, but writes no zero
+  } {
+    if _, numeric, ok := metadataCommentTagFactory_bigint(text); ok || numeric == false {
+      t.Fatalf("%s must be a finite value no bigint tag states (numeric=%v ok=%v)", text, numeric, ok)
+    }
+  }
+  for _, text := range []string{"Infinity", "abc", "1_000"} {
+    if _, numeric, ok := metadataCommentTagFactory_bigint(text); ok || numeric {
+      t.Fatalf("%s is no finite number (numeric=%v ok=%v)", text, numeric, ok)
+    }
+  }
+
+  //----
+  // 3. where the refusal is reported
+  //----
+  analyze := func(types []string, name string, text string) (*schemametadata.MetadataSchema, []string) {
+    atomics := []*schemametadata.MetadataAtomic{}
+    for _, typ := range types {
+      atomics = append(atomics, schemametadata.MetadataAtomic_create(schemametadata.MetadataAtomic{Type: typ}))
+    }
+    meta := schemametadata.MetadataSchema_create(schemametadata.MetadataSchema{Atomics: atomics})
+    errors := []MetadataFactory_IError{}
+    MetadataCommentTagFactory.Analyze(struct {
+      Errors   *[]MetadataFactory_IError
+      Metadata *schemametadata.MetadataSchema
+      Tags     []schemametadata.IJsDocTagInfo
+      Explore  MetadataFactory_IExplore
+    }{
+      Errors:   &errors,
+      Metadata: meta,
+      Tags:     []schemametadata.IJsDocTagInfo{{Name: name, Text: []schemametadata.IJsDocTagInfo_IText{{Text: text}}}},
+    })
+    messages := []string{}
+    for _, err := range errors {
+      messages = append(messages, err.Messages...)
+    }
+    return meta, messages
+  }
+  refusal := "bigint value 9007199254740993 is not an int64 integer that a number represents exactly"
+  for _, name := range []string{"minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf"} {
+    if _, messages := analyze([]string{"bigint"}, name, "9007199254740993"); len(messages) != 1 || messages[0] != refusal {
+      t.Fatalf("@%s on a bigint must report the refusal alone, got %#v", name, messages)
+    }
+    meta, messages := analyze([]string{"number"}, name, "9007199254740993")
+    if len(messages) != 0 || len(meta.Atomics[0].Tags) != 1 {
+      t.Fatalf("@%s on a number must apply, got %#v", name, messages)
+    }
+    meta, messages = analyze([]string{"number", "bigint"}, name, "9007199254740993")
+    if len(messages) != 1 || messages[0] != refusal {
+      t.Fatalf("@%s on number | bigint must report the bigint part, got %#v", name, messages)
+    }
+    if len(meta.Atomics[0].Tags) != 1 || len(meta.Atomics[1].Tags) != 0 {
+      t.Fatalf("@%s on number | bigint must constrain the number part only", name)
+    }
+    if meta, messages := analyze([]string{"bigint"}, name, "9007199254740992"); len(messages) != 0 || len(meta.Atomics[0].Tags) != 1 {
+      t.Fatalf("@%s 9007199254740992 on a bigint must apply, got %#v", name, messages)
+    }
+  }
+  // A value `Number()` rounds to an integer still names no bigint bound: the
+  // number part takes it as 5, and the bigint part is reported, not dropped.
+  meta, messages := analyze([]string{"number", "bigint"}, "minimum", "5.0000000000000001")
+  if len(messages) != 1 || messages[0] != "bigint value 5.0000000000000001 is not an int64 integer that a number represents exactly" {
+    t.Fatalf("@minimum 5.0000000000000001 on number | bigint must report the bigint part, got %#v", messages)
+  }
+  if len(meta.Atomics[0].Tags) != 1 || meta.Atomics[0].Tags[0][0].Validate != "5 <= $input" || len(meta.Atomics[1].Tags) != 0 {
+    t.Fatal("@minimum 5.0000000000000001 on number | bigint must constrain the number part only")
+  }
+  if _, messages := analyze([]string{"bigint"}, "minimum", "1.5"); len(messages) != 1 || messages[0] != "bigint value 1.5 is not an int64 integer that a number represents exactly" {
+    t.Fatalf("@minimum 1.5 on a bigint must be refused, got %#v", messages)
+  }
+  if _, messages := analyze([]string{"number", "bigint"}, "minimum", "1e-1000001"); len(messages) != 1 || messages[0] != "bigint value 1e-1000001 is not an int64 integer that a number represents exactly" {
+    t.Fatalf("@minimum 1e-1000001 on number | bigint must report the bigint part, got %#v", messages)
+  }
+  // Text that is no finite number is reported once, as such, on any target.
+  for _, item := range []struct {
+    text    string
+    message string
+  }{
+    {"abc", "invalid number"},
+    {"Infinity", "non-finite number"},
+    {"1e400", "non-finite number"},
+  } {
+    for _, types := range [][]string{{"bigint"}, {"number", "bigint"}} {
+      if _, messages := analyze(types, "minimum", item.text); len(messages) != 1 || messages[0] != item.message {
+        t.Fatalf("@minimum %s on %v must report %q alone, got %#v", item.text, types, item.message, messages)
+      }
+    }
+  }
+}

package/native/core/factories/metadata_comment_tag_factory_reads_javascript_numbers_test.go

@@ -0,0 +1,163 @@
+package factories
+
+import (
+  "reflect"
+  "testing"
+
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+// TestMetadataCommentTagFactoryReadsJavaScriptNumbers verifies numeric JSDoc
+// comment tags read JavaScript numbers and splice their values.
+//
+// The tags used Go's float syntax, and each record spliced the raw tag text into
+// the emitted validator (samchon/typia#2442). Go-only spellings therefore became
+// broken JavaScript: `@minimum inf` emitted `inf <= $input`, a ReferenceError,
+// while `@minimum 0x10`, which JavaScript reads as 16, was rejected. The bigint
+// splice appended `n` to the text, so an integer spelled `1e3` emitted `1e3n`,
+// which is no BigInt literal. A non-finite value has no JSON spelling for the
+// schema keyword and is reported (samchon/typia#2452). The expectations are the
+// values `Number(text)` yields in JavaScript.
+//
+//  1. Read `0x10`, `1e3`, `+5`, and `.5` as their JavaScript values, and splice
+//     the value into both the number and the bigint records, with integer
+//     spellings keeping their exact digits.
+//  2. Report Go-only spellings as invalid numbers and infinities as non-finite.
+//  3. Keep ordinary spellings byte-identical, and every tag name in its source
+//     spelling.
+//
+// @evidence contracts/testing.md#behavioral-verification Numeric comment tags are parsed from JavaScript number spellings (hex, exponent, infinity) and Go-only spellings; accepted tags must carry the right value and splice a JavaScript-valid validator text.
+// @evidence contracts/testing.md#independent-expectations The JavaScript number grammar defines which spellings are numbers and what they evaluate to; expected values and spliced text are authored.
+// @evidence contracts/testing.md#distinguishing-cases Accepted JavaScript spellings, rejected Go-only spellings and several tag targets give positive and negative rows.
+// @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 factory in memory with no checker, filesystem fixture or process.
+func TestMetadataCommentTagFactoryReadsJavaScriptNumbers(t *testing.T) {
+  parse := func(name string, value string) (metadataCommentTagFactory_TagRecord, []string) {
+    messages := []string{}
+    record := metadataCommentTagFactory_parse(struct {
+      Report func(msg string) any
+      Tag    schemametadata.IJsDocTagInfo
+    }{
+      Report: func(msg string) any {
+        messages = append(messages, msg)
+        return nil
+      },
+      Tag: schemametadata.IJsDocTagInfo{
+        Name: name,
+        Text: []schemametadata.IJsDocTagInfo_IText{{Text: value, Kind: "text"}},
+      },
+    })
+    return record, messages
+  }
+  single := func(record metadataCommentTagFactory_TagRecord, target string) schemametadata.IMetadataTypeTag {
+    t.Helper()
+    tags := record[target]
+    if len(tags) != 1 {
+      t.Fatalf("expected one %s record, got %#v", target, record)
+    }
+    return tags[0]
+  }
+
+  //----
+  // 1. JavaScript spellings, spliced as values
+  //----
+  for _, item := range []struct {
+    name     string
+    value    string
+    target   string
+    number   float64
+    validate string
+  }{
+    {"minimum", "0x10", "number", 16, "16 <= $input"},
+    {"minimum", "0x10", "bigint", 16, "16 <= $input"},
+    {"maximum", "+5", "number", 5, "$input <= 5"},
+    {"exclusiveMinimum", ".5", "number", 0.5, "0.5 < $input"},
+    {"multipleOf", "1e3", "bigint", 1000, "$input % 1000n === 0n"},
+    {"multipleOf", "1.0", "bigint", 1, "$input % 1n === 0n"},
+    {"multipleOf", "1e3", "number", 1000, "$importInternal(\"_isMultipleOf\")($input, 1000)"},
+    {"minItems", "0b11", "array", 3, "3 <= $input.length"},
+    {"minLength", "0o7", "string", 7, "$importInternal(\"_stringLengthGte\")($input, 7)"},
+    {"multipleOf", "+5", "bigint", 5, "$input % 5n === 0n"},
+    {"multipleOf", "007", "bigint", 7, "$input % 7n === 0n"},
+    // Beyond 2^53 a bigint keeps an integer a double represents exactly; any
+    // other value gets an empty bigint record, which `Analyze` reports
+    // (samchon/typia#2457).
+    {"multipleOf", "18014398509481984", "bigint", 18014398509481984, "$input % 18014398509481984n === 0n"},
+    {"maximum", "0.0000001", "number", 1e-7, "$input <= 1e-7"},
+  } {
+    record, messages := parse(item.name, item.value)
+    if len(messages) != 0 {
+      t.Fatalf("@%s %s must be accepted, reports=%#v", item.name, item.value, messages)
+    }
+    tag := single(record, item.target)
+    if tag.Validate != item.validate {
+      t.Fatalf("@%s %s on %s should validate %q, got %q", item.name, item.value, item.target, item.validate, tag.Validate)
+    }
+    var value float64
+    switch v := tag.Value.(type) {
+    case float64:
+      value = v
+    case int64:
+      value = float64(v)
+    default:
+      t.Fatalf("@%s %s on %s carried a %T value", item.name, item.value, item.target, tag.Value)
+    }
+    if value != item.number {
+      t.Fatalf("@%s %s on %s should carry %v, got %v", item.name, item.value, item.target, item.number, value)
+    }
+  }
+
+  //----
+  // 2. Go-only spellings and infinities
+  //----
+  for _, item := range []struct {
+    name    string
+    value   string
+    message string
+  }{
+    {"minimum", "inf", "invalid number"},
+    {"minimum", "NaN", "invalid number"},
+    {"minimum", "0x1p4", "invalid number"},
+    {"maximum", "1_000", "invalid number"},
+    {"multipleOf", "-0x10", "invalid number"},
+    {"minimum", "Infinity", "non-finite number"},
+    {"exclusiveMaximum", "-Infinity", "non-finite number"},
+    {"maximum", "1e400", "non-finite number"},
+  } {
+    _, messages := parse(item.name, item.value)
+    found := false
+    for _, message := range messages {
+      if message == item.message {
+        found = true
+      }
+    }
+    if found == false {
+      t.Fatalf("@%s %s should report %q, got %#v", item.name, item.value, item.message, messages)
+    }
+  }
+
+  //----
+  // 3. ordinary spellings are unchanged
+  //----
+  record, messages := parse("minimum", "3")
+  if len(messages) != 0 {
+    t.Fatalf("@minimum 3 must be accepted, reports=%#v", messages)
+  }
+  expected := schemametadata.IMetadataTypeTag{
+    Name:      "Minimum<3>",
+    Target:    "number",
+    Kind:      "minimum",
+    Value:     float64(3),
+    Validate:  "3 <= $input",
+    Exclusive: metadataCommentTagFactory_exclusive("minimum"),
+    Schema:    map[string]any{"minimum": float64(3)},
+  }
+  if actual := single(record, "number"); reflect.DeepEqual(actual, expected) == false {
+    t.Fatalf("@minimum 3 changed:\nexpected %#v\nactual   %#v", expected, actual)
+  }
+  // Only the splice is respelled; the tag name keeps the source spelling, so
+  // validation messages and reflected metadata do not change.
+  record, _ = parse("minimum", "1.0")
+  if tag := single(record, "number"); tag.Name != "Minimum<1.0>" || tag.Validate != "1 <= $input" {
+    t.Fatalf("@minimum 1.0 should keep its name and splice 1, got %q / %q", tag.Name, tag.Validate)
+  }
+}