typia 13.1.1 → 13.2.0

package/native/core/programmers/RandomProgrammer.go

@@ -615,27 +615,36 @@ type randomProgrammer_composedAtomic struct {
 func randomProgrammer_compose_atomic(atomicType string, schema nativeiterate.JsonSchema, emit *shimprinter.EmitContext) randomProgrammer_composedAtomic {
   f := nativecontext.EmitFactoryOf(randomProgrammer_factory, emit)
   if atomicType == "string" {
+    // A string leaf that also carries a length tag needs the bounds forwarded
+    // to the format and pattern generators; only the plain-string fall-through
+    // used to receive the full schema, so a format or pattern combined with
+    // minLength/maxLength was generated at the wrong length and failed its own
+    // validator (issue #2189).
+    lengthArgs := randomProgrammer_length_argument(schema, emit)
     if raw, ok := schema["format"].(string); ok && raw != "" {
       if raw == "date-time" {
-        return randomProgrammer_composedAtomic{Method: "datetime", Internal: "randomFormatDatetime"}
+        return randomProgrammer_composedAtomic{Method: "datetime", Internal: "randomFormatDatetime", Arguments: lengthArgs}
       }
       method := randomProgrammer_format_method(raw)
       return randomProgrammer_composedAtomic{
-        Method:   method,
-        Internal: "randomFormat" + randomProgrammer_format_pascal(raw),
+        Method:    method,
+        Internal:  "randomFormat" + randomProgrammer_format_pascal(raw),
+        Arguments: lengthArgs,
       }
     }
     if pattern, ok := schema["pattern"].(string); ok && pattern != "" {
+      arguments := []*shimast.Node{
+        f.NewNewExpression(
+          f.NewIdentifier("RegExp"),
+          nil,
+          f.NewNodeList([]*shimast.Node{f.NewStringLiteral(pattern, shimast.TokenFlagsNone)}),
+        ),
+      }
+      arguments = append(arguments, lengthArgs...)
       return randomProgrammer_composedAtomic{
-        Method:   "pattern",
-        Internal: "randomPattern",
-        Arguments: []*shimast.Node{
-          f.NewNewExpression(
-            f.NewIdentifier("RegExp"),
-            nil,
-            f.NewNodeList([]*shimast.Node{f.NewStringLiteral(pattern, shimast.TokenFlagsNone)}),
-          ),
-        },
+        Method:    "pattern",
+        Internal:  "randomPattern",
+        Arguments: arguments,
       }
     }
   } else if atomicType == "number" {
@@ -659,6 +668,24 @@ func randomProgrammer_compose_atomic(atomicType string, schema nativeiterate.Jso
   }
 }
 
+// randomProgrammer_length_argument forwards the minLength/maxLength bounds of a
+// string leaf to the format and pattern generators as a
+// `{ minLength?, maxLength? }` object literal, or nil when the leaf carries no
+// length tag so the format-only and pattern-only emission stays byte-identical.
+func randomProgrammer_length_argument(schema nativeiterate.JsonSchema, emit *shimprinter.EmitContext) []*shimast.Node {
+  length := map[string]any{}
+  if value, ok := schema["minLength"]; ok {
+    length["minLength"] = value
+  }
+  if value, ok := schema["maxLength"]; ok {
+    length["maxLength"] = value
+  }
+  if len(length) == 0 {
+    return nil
+  }
+  return []*shimast.Node{nativefactories.LiteralFactory.Write(length, emit)}
+}
+
 func randomProgrammer_decode_template(props struct {
   Context  nativecontext.ITypiaContext
   Functor  *nativehelpers.FunctionProgrammer
@@ -1407,6 +1434,16 @@ func randomProgrammer_is_typed_array(name string) bool {
   }
 }
 
+// randomProgrammer_typed_array_range reports the type tag and range a TypedArray's
+// elements are generated from.
+//
+// These bounds are a generation hint, not a validation gate, and they are the one
+// copy of the 64-bit bound that is deliberately inexact. They become `minimum` and
+// `maximum` comment tags on a number-typed JSON schema, and `number` cannot
+// represent 2**63 - 1 or 2**64 - 1 -- both arrive rounded up to the next power of
+// two. That costs nothing here: the generator only picks a value from the range,
+// and the TypedArray constructor wraps whatever it is handed. Validation owns
+// exactness instead, in _isTypeInt64Bigint and its siblings.
 func randomProgrammer_typed_array_range(name string) (string, string, string) {
   switch name {
   case "Uint8Array", "Uint8ClampedArray":
@@ -1424,9 +1461,9 @@ func randomProgrammer_typed_array_range(name string) (string, string, string) {
   case "Int32Array":
     return "int32", "-2147483648", "2147483647"
   case "BigInt64Array":
-    return "uint64", "-9223372036854775808", "9223372036854775807"
+    return "int64", "-9223372036854775808", "9223372036854775807"
   case "Float32Array":
-    return "float", "-1.175494351e38", "3.4028235e38"
+    return "float", "-3.4028235e38", "3.4028235e38"
   default:
     return "double", fmt.Sprint(math.SmallestNonzeroFloat64), fmt.Sprint(math.MaxFloat64)
   }

package/native/core/programmers/compare/CompareEqualProgrammer.go

@@ -12,6 +12,7 @@ import (
   nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
   nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
   nativeinternal "github.com/samchon/typia/packages/typia/native/core/programmers/internal"
+  nativeiterate "github.com/samchon/typia/packages/typia/native/core/programmers/iterate"
   schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
@@ -31,9 +32,14 @@ type CompareEqualProgrammer_IProps struct {
 }
 
 type compareEqualProgrammerGenerator struct {
-  Config    CompareEqualProgrammer_IConfig
-  Recursive bool
-  Counter   int
+  Config     CompareEqualProgrammer_IConfig
+  Functional bool
+  Recursive  bool
+  Counter    int
+  // Member-resolution checkers (`_ui<index>`) emitted on demand for the object
+  // unions that need the is-match ladder, keyed by the object's collection index.
+  Matchers     []string
+  MatcherIndex map[int]bool
 }
 
 var compareEqualProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
@@ -71,8 +77,10 @@ func (compareEqualProgrammerNamespace) Write(props CompareEqualProgrammer_IProps
   }
 
   generator := &compareEqualProgrammerGenerator{
-    Config:    props.Config,
-    Recursive: nativeinternal.FeatureProgrammer.CollectionRecursive(collection),
+    Config:       props.Config,
+    Functional:   nativehelpers.OptionPredicator.Functional(props.Context.Options),
+    Recursive:    nativeinternal.FeatureProgrammer.CollectionRecursive(collection),
+    MatcherIndex: map[int]bool{},
   }
   body := generator.schema(result.Data, "x", "y")
   statements := []string{}
@@ -89,6 +97,12 @@ func (compareEqualProgrammerNamespace) Write(props CompareEqualProgrammer_IProps
       statements = append(statements, generator.tupleFunction(tuple))
     }
   }
+  // The member matchers are collected last because every generation step above
+  // may request one. They are `const` arrow functions in the same scope as the
+  // `_eo`/`_ea`/`_et` helpers and are only ever called after this IIFE returns,
+  // so declaring them at the end is free of temporal-dead-zone hazards — the
+  // same placement `is` uses for the `_io` checkers it appends after `_cu`.
+  statements = append(statements, generator.Matchers...)
   if generator.Recursive {
     statements = append(statements, "return (x, y) => { const _vctx = {}; return "+body+"; };")
   } else {
@@ -155,8 +169,28 @@ func (g *compareEqualProgrammerGenerator) schema(metadata *schemametadata.Metada
   for _, array := range metadata.Arrays {
     branches = append(branches, g.array(array, x, y))
   }
-  for _, object := range metadata.Objects {
-    branches = append(branches, g.objectCall(object.Type, x, y))
+  // A union of two or more object types must discriminate: route each operand
+  // to exactly one member and compare within that single member. A flat OR of
+  // member comparators lets a wrong member's comparator match spuriously — its
+  // literal discriminant is satisfied by the always-present `x[k] === y[k]`
+  // branch and its absent payload keys compare `undefined === undefined`. The
+  // discrimination reuses the shared UnionPredicator specialization the sibling
+  // programmers (is/clone/classify/...) route through, so `equals` agrees with
+  // `is` on which member a value is. A union no discriminant can split (every
+  // distinguishing key optional, e.g. `{ a?: number } | { b?: string }`) routes
+  // through the first-is-match ladder instead — never a flat OR, which admits
+  // the same spurious match through absent keys comparing
+  // `undefined === undefined` (issue #2225).
+  if len(metadata.Objects) >= 2 {
+    expr := g.objectUnion(metadata.Objects, x, y)
+    if guard := g.notNatives(metadata.Natives, x, y); guard != "" {
+      expr = g.and(guard, expr)
+    }
+    branches = append(branches, expr)
+  } else {
+    for _, object := range metadata.Objects {
+      branches = append(branches, g.objectFlatBranch(object.Type, metadata.Natives, x, y))
+    }
   }
   for _, alias := range metadata.Aliases {
     branches = append(branches, g.schema(alias.Type.Value, x, y))
@@ -233,7 +267,27 @@ func (g *compareEqualProgrammerGenerator) tupleInline(tuple *schemametadata.Meta
     g.same(g.access(x, "length"), g.access(y, "length")),
   }
   if rest == nil {
-    checks = append(checks, g.same(g.access(x, "length"), strconv.Itoa(fixed)))
+    // An omitted optional trailing element makes the tuple's length a range
+    // [required, fixed] — exactly the gate `is` emits. A hard `=== fixed`
+    // rejects a value `is` accepts and breaks reflexivity of `equals`; the
+    // per-element `x[i] === y[i]` prefix already treats both-absent as equal,
+    // so only the length gate needs the range. A fully-required tuple keeps
+    // its byte-identical `x.length === fixed`.
+    required := 0
+    allRequired := true
+    for i := 0; i < fixed; i++ {
+      if tuple.Elements[i].Optional {
+        allRequired = false
+      } else {
+        required++
+      }
+    }
+    if allRequired {
+      checks = append(checks, g.same(g.access(x, "length"), strconv.Itoa(fixed)))
+    } else {
+      length := g.access(x, "length")
+      checks = append(checks, fmt.Sprintf("%d <= %s && %d >= %s", required, length, fixed, length))
+    }
   } else {
     checks = append(checks, fmt.Sprintf("%s.length >= %d", g.wrap(x), fixed))
   }
@@ -256,6 +310,326 @@ func (g *compareEqualProgrammerGenerator) objectCall(object *schemametadata.Meta
   return fmt.Sprintf("_eo%d(%s, %s)", object.Index, g.wrap(x), g.wrap(y))
 }
 
+// objectFlatBranch renders a single object member as a guarded comparator. A
+// multi-object union always uses objectUnion's member dispatch instead.
+func (g *compareEqualProgrammerGenerator) objectFlatBranch(object *schemametadata.MetadataObjectType, natives []*schemametadata.MetadataNative, x string, y string) string {
+  // Guard the object branch against the sibling native instances. `_eo` admits
+  // any `typeof === "object" && !Array.isArray` value, so a native (a Date is
+  // an object) would be compared by the object's declared keys, which the
+  // native lacks — two different Dates then look equal on their absent keys and
+  // the OR wrongly accepts. Excluding what a native branch owns makes the arms
+  // mutually exclusive, matching the clone/classify ladder whose object arm is
+  // unreachable once a native arm matches.
+  call := g.objectCall(object, x, y)
+  if guard := g.notNatives(natives, x, y); guard != "" {
+    call = g.and(guard, call)
+  }
+  return call
+}
+
+// objectUnion renders a discriminated comparison for a union of two or more
+// object types. It mirrors the is/clone/classify discrimination: each operand is
+// routed to exactly one member, and only when both land on the same member does
+// that member's comparator run. This replaces the flat OR whose wrong-member
+// comparator could match spuriously.
+//
+// Routing prefers the shared UnionPredicator discriminants (issue #2214). When
+// no discriminant splits the members — every distinguishing key is optional, so
+// UnionPredicator yields no specialization, or more than one member is left
+// unspecialized — routing falls back to the first-is-match ladder that
+// clone/classify/prune reach through Decode_union_object (issue #2225). There is
+// no flat-OR fallback: the flat OR is the defect both issues describe.
+func (g *compareEqualProgrammerGenerator) objectUnion(objects []*schemametadata.MetadataObject, x string, y string) string {
+  types := make([]*schemametadata.MetadataObjectType, 0, len(objects))
+  for _, object := range objects {
+    types = append(types, object.Type)
+  }
+  ladder, ok := g.discriminantLadder(types)
+  if ok == false {
+    ladder = g.matchLadder(types)
+  }
+
+  tag := g.local("utag")
+  tx := g.local("utx")
+  // Dispatch: with the shared member index, run only that member's comparator.
+  dispatch := "false"
+  for i := len(types) - 1; i >= 0; i-- {
+    dispatch = fmt.Sprintf("%s === %d ? %s : %s", tx, types[i].Index, g.objectCall(types[i], "x", "y"), dispatch)
+  }
+  body := fmt.Sprintf(
+    "((x, y) => { const %s = (v) => (%s) ? (%s) : -1; const %s = %s(x); return %s !== -1 && %s === %s(y) && (%s); })(%s, %s)",
+    tag, g.isObject("v"), ladder, tx, tag, tx, tx, tag, dispatch, g.wrap(x), g.wrap(y),
+  )
+  return body
+}
+
+// discriminantLadder renders the routing ternary from the shared UnionPredicator
+// specialization: `<discriminant of member i> ? <index of member i> : ...`,
+// ending in the lone unspecialized member (the unconditional else the
+// discriminant ladder leaves) or -1 for "no member". It reports ok=false when
+// the members carry no usable discriminant, when more than one member is left
+// unspecialized, or when a discriminant value cannot be rendered as a check —
+// the caller then routes by is-match instead.
+func (g *compareEqualProgrammerGenerator) discriminantLadder(types []*schemametadata.MetadataObjectType) (string, bool) {
+  specs := nativehelpers.UnionPredicator.Object(types)
+  if len(specs) == 0 {
+    return "", false
+  }
+  specialized := map[*schemametadata.MetadataObjectType]bool{}
+  for _, spec := range specs {
+    specialized[spec.Object] = true
+  }
+  remained := []*schemametadata.MetadataObjectType{}
+  for _, object := range types {
+    if specialized[object] == false {
+      remained = append(remained, object)
+    }
+  }
+  if len(remained) > 1 {
+    return "", false
+  }
+  fallback := "-1"
+  if len(remained) == 1 {
+    fallback = strconv.Itoa(remained[0].Index)
+  }
+  ladder := fallback
+  for i := len(specs) - 1; i >= 0; i-- {
+    check, ok := g.discriminant(specs[i], "v")
+    if ok == false {
+      return "", false
+    }
+    ladder = fmt.Sprintf("%s ? %d : %s", check, specs[i].Object.Index, ladder)
+  }
+  return ladder, true
+}
+
+// matchLadder renders the routing ternary for a union no discriminant splits:
+// the first member the value is-matches wins, exactly as `clone`/`classify`/
+// `prune` resolve membership through Decode_union_object's `if (_io0(input))
+// return ...; if (_io1(input)) ...` ladder. A value matching no member yields
+// -1, which makes `equals` false rather than letting a wrong member's comparator
+// decide.
+func (g *compareEqualProgrammerGenerator) matchLadder(types []*schemametadata.MetadataObjectType) string {
+  calls := make([]string, 0, len(types))
+  for _, object := range types {
+    // Declared in member order so the emitted matchers read in the same order
+    // as the ladder that calls them; the ladder itself is folded back to front.
+    calls = append(calls, g.matchCall(object, "v"))
+  }
+  ladder := "-1"
+  for i := len(types) - 1; i >= 0; i-- {
+    ladder = fmt.Sprintf("%s ? %d : %s", calls[i], types[i].Index, ladder)
+  }
+  return ladder
+}
+
+// matchCall returns a call to the member's `_ui<index>` matcher, declaring the
+// matcher on first request. The index is registered before the body is rendered
+// so a recursive member refers to its own matcher instead of recursing forever
+// at generation time.
+func (g *compareEqualProgrammerGenerator) matchCall(object *schemametadata.MetadataObjectType, v string) string {
+  name := fmt.Sprintf("_ui%d", object.Index)
+  if g.MatcherIndex[object.Index] == false {
+    g.MatcherIndex[object.Index] = true
+    g.Matchers = append(g.Matchers, fmt.Sprintf("const %s = (v) => %s;", name, g.matchObject(object, "v")))
+  }
+  return fmt.Sprintf("%s(%s)", name, g.wrap(v))
+}
+
+// matchObject renders the structural is-check of one object member: every
+// declared regular key must hold a value of its declared type (an optional key
+// may be absent), and every extra key a dynamic index signature declares must
+// hold a value of the signature's type. It mirrors the `_io` checkers `is`
+// emits, at the abstraction level the rest of this programmer works at — shape
+// and typeof, plus structural template patterns. Function-valued properties
+// participate in this routing check whenever `is` makes them meaningful; they
+// remain excluded from object value comparison after a member is selected. It
+// deliberately ignores `typia.tags.*` constraints.
+func (g *compareEqualProgrammerGenerator) matchObject(object *schemametadata.MetadataObjectType, v string) string {
+  checks := []string{}
+  regularKeys := []string{}
+  dynamic := []*schemametadata.MetadataProperty{}
+  for _, property := range object.Properties {
+    if sole := property.Key.GetSoleLiteral(); sole != nil {
+      regularKeys = append(regularKeys, *sole)
+      checks = append(checks, g.matchSlot(property.Value, g.property(v, *sole)))
+    } else {
+      dynamic = append(dynamic, property)
+    }
+  }
+  if len(dynamic) != 0 {
+    key := g.local("key")
+    regularCheck := compareEqualProgrammer_regularKeyCheck(regularKeys)
+    conditions := []string{}
+    for _, property := range dynamic {
+      conditions = append(conditions, g.and(g.dynamicKey(property.Key, key), g.matchSlot(property.Value, g.index(v, key))))
+    }
+    checks = append(checks, fmt.Sprintf("Object.keys(%s).every((%s) => %s)", g.wrap(v), key, g.or(regularCheck(key), g.or(conditions...))))
+  }
+  return g.and(checks...)
+}
+
+// matchSlot renders the is-check of a value slot — an object property or a tuple
+// element — allowing the slot to be absent when it is optional.
+func (g *compareEqualProgrammerGenerator) matchSlot(metadata *schemametadata.MetadataSchema, v string) string {
+  check := g.match(metadata, v)
+  if metadata != nil && metadata.IsRequired() == false {
+    return g.or(g.same(v, "undefined"), check)
+  }
+  return check
+}
+
+// match renders the structural is-check of one metadata schema as the OR of its
+// buckets, the same bucket walk `schema` compares over. An unconstrained bucket
+// (anything the compare feature already rejects, or a bucket carrying no shape
+// to test) renders as "true", which keeps the ladder's first-match order the
+// deciding factor exactly as it is in `is`.
+func (g *compareEqualProgrammerGenerator) match(metadata *schemametadata.MetadataSchema, v string) string {
+  if metadata == nil {
+    return "true"
+  }
+  metadata = schemametadata.MetadataSchema_unalias(metadata)
+  if metadata.Any {
+    return "true"
+  }
+  branches := []string{}
+  if metadata.Nullable {
+    branches = append(branches, g.same(v, "null"))
+  }
+  for _, constant := range metadata.Constants {
+    for _, value := range constant.Values {
+      branches = append(branches, g.same(v, compareEqualProgrammer_literal(value.Value, constant.Type)))
+    }
+  }
+  for _, atomic := range metadata.Atomics {
+    branches = append(branches, g.typeof(v, atomic.Type))
+  }
+  if len(metadata.Templates) != 0 {
+    branches = append(branches, g.and(g.typeof(v, "string"), g.template(metadata.Templates, v)))
+  }
+  if len(metadata.Functions) != 0 && (g.Functional || metadata.Size() != 1) {
+    branches = append(branches, g.typeof(v, "function"))
+  }
+  for _, native := range metadata.Natives {
+    branches = append(branches, g.instanceof(v, native.Name))
+  }
+  for _, tuple := range metadata.Tuples {
+    branches = append(branches, g.matchTuple(tuple.Type, v))
+  }
+  for _, array := range metadata.Arrays {
+    elem := g.local("elem")
+    branches = append(branches, g.and(g.isArray(v), fmt.Sprintf("%s.every((%s) => %s)", g.wrap(v), elem, g.match(array.Type.Value, elem))))
+  }
+  if len(metadata.Objects) != 0 {
+    calls := []string{}
+    for _, object := range metadata.Objects {
+      calls = append(calls, g.matchCall(object.Type, v))
+    }
+    branches = append(branches, g.and(g.isObject(v), g.or(calls...)))
+  }
+  for _, alias := range metadata.Aliases {
+    branches = append(branches, g.match(alias.Type.Value, v))
+  }
+  if metadata.Escaped != nil {
+    branches = append(branches, g.match(metadata.Escaped.Original, v))
+  }
+  if metadata.Rest != nil {
+    branches = append(branches, g.match(metadata.Rest, v))
+  }
+  if len(branches) == 0 {
+    return "true"
+  }
+  return g.or(branches...)
+}
+
+// matchTuple renders the is-check of a tuple: the array gate, the length range
+// an omitted optional trailing element makes legal (the same range `tupleInline`
+// compares over), and each element's own check.
+func (g *compareEqualProgrammerGenerator) matchTuple(tuple *schemametadata.MetadataTupleType, v string) string {
+  fixed := len(tuple.Elements)
+  var rest *schemametadata.MetadataSchema
+  if fixed != 0 && tuple.Elements[fixed-1].Rest != nil {
+    rest = tuple.Elements[fixed-1].Rest
+    fixed--
+  }
+  checks := []string{g.isArray(v)}
+  length := g.access(v, "length")
+  if rest == nil {
+    required := 0
+    allRequired := true
+    for i := 0; i < fixed; i++ {
+      if tuple.Elements[i].Optional {
+        allRequired = false
+      } else {
+        required++
+      }
+    }
+    if allRequired {
+      checks = append(checks, g.same(length, strconv.Itoa(fixed)))
+    } else {
+      checks = append(checks, fmt.Sprintf("%d <= %s && %d >= %s", required, length, fixed, length))
+    }
+  } else {
+    checks = append(checks, fmt.Sprintf("%s >= %d", length, fixed))
+  }
+  for i := 0; i < fixed; i++ {
+    checks = append(checks, g.matchSlot(tuple.Elements[i], g.index(v, strconv.Itoa(i))))
+  }
+  if rest != nil {
+    elem := g.local("elem")
+    checks = append(checks, fmt.Sprintf("%s.slice(%d).every((%s) => %s)", g.wrap(v), fixed, elem, g.match(rest, elem)))
+  }
+  return g.and(checks...)
+}
+
+// discriminant renders the routing predicate for one specialized union member,
+// matching how `is` decides membership: presence (`v[key] !== undefined`) for a
+// key unique to this member, or a value check (literal equality for constants,
+// typeof for atomics/templates) for a shared key whose value distinguishes it.
+// It returns ok=false for any discriminant value it cannot render as such a
+// check, so the caller falls back rather than emit a weaker predicate.
+func (g *compareEqualProgrammerGenerator) discriminant(spec nativehelpers.UnionPredicator_ISpecialized, v string) (string, bool) {
+  sole := spec.Property.Key.GetSoleLiteral()
+  if sole == nil {
+    return "", false
+  }
+  access := g.property(v, *sole)
+  if spec.Neighbor == false {
+    return fmt.Sprintf("%s !== undefined", g.wrap(access)), true
+  }
+  meta := schemametadata.MetadataSchema_unalias(spec.Property.Value)
+  if meta == nil || meta.Any {
+    return "", false
+  }
+  if len(meta.Objects) != 0 || len(meta.Arrays) != 0 || len(meta.Tuples) != 0 ||
+    len(meta.Natives) != 0 || len(meta.Sets) != 0 || len(meta.Maps) != 0 ||
+    len(meta.Aliases) != 0 || len(meta.Functions) != 0 || meta.Escaped != nil || meta.Rest != nil {
+    return "", false
+  }
+  checks := []string{}
+  if meta.Nullable {
+    // A nullable discriminant (e.g. `type: "a" | null`) routes a null value to
+    // this member exactly as `is` does, so `equals(null-arm, null-arm)` stays
+    // reflexive rather than falling through to no member.
+    checks = append(checks, g.same(access, "null"))
+  }
+  for _, constant := range meta.Constants {
+    for _, value := range constant.Values {
+      checks = append(checks, g.same(access, compareEqualProgrammer_literal(value.Value, constant.Type)))
+    }
+  }
+  for _, atomic := range meta.Atomics {
+    checks = append(checks, g.typeof(access, atomic.Type))
+  }
+  if len(meta.Templates) != 0 {
+    checks = append(checks, g.typeof(access, "string"))
+  }
+  if len(checks) == 0 {
+    return "", false
+  }
+  return g.or(checks...), true
+}
+
 func (g *compareEqualProgrammerGenerator) arrayCall(array *schemametadata.MetadataArrayType, x string, y string) string {
   index := 0
   if array.Index != nil {
@@ -394,6 +768,19 @@ func (g *compareEqualProgrammerGenerator) dynamicKey(metadata *schemametadata.Me
   return g.or(checks...)
 }
 
+// template renders the structural membership test shared with the authoritative
+// runtime template checker. Compare still ignores typia tag predicates when it
+// compares values, but it must retain the template-literal domain while routing
+// an object union to a declared member.
+func (g *compareEqualProgrammerGenerator) template(templates []*schemametadata.MetadataTemplate, input string) string {
+  checks := make([]string, 0, len(templates))
+  for _, template := range templates {
+    pattern := nativeiterate.TemplateRuntimePattern(template.Row)
+    checks = append(checks, fmt.Sprintf("RegExp(%s).test(%s)", strconv.Quote(pattern), g.wrap(input)))
+  }
+  return g.or(checks...)
+}
+
 func (g *compareEqualProgrammerGenerator) visit(kind string, index int) string {
   slot := fmt.Sprintf("_vctx.%s%d", kind, index)
   return fmt.Sprintf("const _map = %s || (%s = new WeakMap()); let _set = _map.get(x); if (_set && _set.has(y)) return true; if (!_set) _map.set(x, (_set = new WeakSet())); _set.add(y);", slot, slot)
@@ -409,6 +796,21 @@ func (g *compareEqualProgrammerGenerator) objectGuard(x string, y string) string
   return g.and(g.isObject(x), g.isObject(y))
 }
 
+// notNatives builds "neither x nor y is one of the union's native instances",
+// so the object branch never claims a value a native branch owns. Empty when
+// the union declares no native, keeping the object-only output unchanged.
+func (g *compareEqualProgrammerGenerator) notNatives(natives []*schemametadata.MetadataNative, x string, y string) string {
+  if len(natives) == 0 {
+    return ""
+  }
+  checks := []string{}
+  for _, native := range natives {
+    checks = append(checks, "!"+g.wrap(g.instanceof(x, native.Name)))
+    checks = append(checks, "!"+g.wrap(g.instanceof(y, native.Name)))
+  }
+  return g.and(checks...)
+}
+
 func (g *compareEqualProgrammerGenerator) isObject(input string) string {
   return fmt.Sprintf("typeof %s === \"object\" && %s !== null && !Array.isArray(%s)", g.wrap(input), g.wrap(input), g.wrap(input))
 }

package/native/core/programmers/compare/CompareLessProgrammer.go

@@ -219,9 +219,11 @@ func (g *compareLessProgrammerGenerator) core(metadata *schemametadata.MetadataS
 }
 
 // primitive renders the scalar three-way comparator (works for number, string,
-// boolean and bigint via the relational operators).
+// boolean and bigint via the relational operators). Self-inequality detects NaN
+// without coercing other scalar types and places it after every ordinary number.
 func (g *compareLessProgrammerGenerator) primitive(x string, y string) string {
-  return fmt.Sprintf("(%s < %s ? -1 : %s > %s ? 1 : 0)", g.wrap(x), g.wrap(y), g.wrap(x), g.wrap(y))
+  return fmt.Sprintf("(%s !== %s ? (%s !== %s ? 0 : 1) : %s !== %s ? -1 : %s < %s ? -1 : %s > %s ? 1 : 0)",
+    g.wrap(x), g.wrap(x), g.wrap(y), g.wrap(y), g.wrap(y), g.wrap(y), g.wrap(x), g.wrap(y), g.wrap(x), g.wrap(y))
 }
 
 func (g *compareLessProgrammerGenerator) native(name string, x string, y string) string {

package/native/core/programmers/functional/FunctionalAssertFunctionProgrammer.go

@@ -66,13 +66,11 @@ func (functionalAssertFunctionProgrammerNamespace) Write(props FunctionalAssertF
   }
   body = append(body, f.NewReturnStatement(r.Value))
   statements = append(statements, f.NewReturnStatement(
-    f.NewArrowFunction(
-      functionalIsProgrammer_asyncModifiers(r.Async, props.Context.Emit),
-      nil,
-      functionalIsProgrammer_parameters(props.Declaration, props.Context.Emit),
+    functionalIsProgrammer_function(
+      props.Context,
+      props.Declaration,
+      r.Async,
       functionalAssertProgrammer_returnType(props.Declaration),
-      nil,
-      f.NewToken(shimast.KindEqualsGreaterThanToken),
       f.NewBlock(f.NewNodeList(body), true),
     ),
   ))

package/native/core/programmers/functional/FunctionalAssertParametersProgrammer.go

@@ -66,21 +66,13 @@ func (functionalAssertParametersProgrammerNamespace) Write(props FunctionalAsser
   for _, exp := range result.Expressions {
     body = append(body, f.NewExpressionStatement(exp))
   }
-  body = append(body, f.NewReturnStatement(f.NewCallExpression(
-    props.Expression,
-    nil,
-    nil,
-    f.NewNodeList(functionalIsProgrammer_parameterIdentifiers(props.Declaration, props.Context.Emit)),
-    shimast.NodeFlagsNone,
-  )))
+  body = append(body, f.NewReturnStatement(functionalIsProgrammer_call(props.Context, props.Expression, props.Declaration)))
   statements = append(statements, f.NewReturnStatement(
-    f.NewArrowFunction(
-      functionalIsProgrammer_asyncModifiers(output.Async, props.Context.Emit),
-      nil,
-      functionalIsProgrammer_parameters(props.Declaration, props.Context.Emit),
+    functionalIsProgrammer_function(
+      props.Context,
+      props.Declaration,
+      output.Async,
       functionalAssertProgrammer_returnType(props.Declaration),
-      nil,
-      f.NewToken(shimast.KindEqualsGreaterThanToken),
       f.NewBlock(f.NewNodeList(body), true),
     ),
   ))

package/native/core/programmers/functional/FunctionalAssertReturnProgrammer.go

@@ -62,14 +62,12 @@ func (functionAssertReturnProgrammerNamespace) Write(props FunctionAssertReturnP
   statements := []*shimast.Node{wrapper.Variable}
   statements = append(statements, result.Functions...)
   statements = append(statements, f.NewReturnStatement(
-    f.NewArrowFunction(
-      functionalIsProgrammer_asyncModifiers(result.Async, props.Context.Emit),
-      nil,
-      functionalIsProgrammer_parameters(props.Declaration, props.Context.Emit),
+    functionalIsProgrammer_function(
+      props.Context,
+      props.Declaration,
+      result.Async,
       functionalAssertProgrammer_returnType(props.Declaration),
-      nil,
-      f.NewToken(shimast.KindEqualsGreaterThanToken),
-      result.Value,
+      f.NewBlock(f.NewNodeList([]*shimast.Node{f.NewReturnStatement(result.Value)}), true),
     ),
   ))
   return nativefactories.ExpressionFactory.SelfCall(
@@ -84,13 +82,7 @@ func (functionAssertReturnProgrammerNamespace) Decompose(props FunctionAssertRet
     Checker:     props.Context.Checker,
     Declaration: props.Declaration,
   })
-  caller := f.NewCallExpression(
-    props.Expression,
-    nil,
-    nil,
-    f.NewNodeList(functionalIsProgrammer_parameterIdentifiers(props.Declaration, props.Context.Emit)),
-    shimast.NodeFlagsNone,
-  )
+  caller := functionalIsProgrammer_call(props.Context, props.Expression, props.Declaration)
   value := caller
   if output.Async {
     value = f.NewAwaitExpression(caller)