typia 13.1.1 → 13.1.19

package/native/core/factories/protobuf_recovery_ownership_test.go

@@ -0,0 +1,64 @@
+package factories
+
+import (
+  "slices"
+  "testing"
+
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+// TestProtobufEmplacerRecoveryOwnership verifies unexpected panics stay visible.
+//
+// Unsupported metadata is diagnosed before emission, but an invariant failure
+// inside the Protobuf emplacer must not be converted into a successful semantic
+// result by a blanket recover.
+//
+//  1. Verify unsupported metadata remains an ordinary diagnostic.
+//  2. Build a static object with an impossible empty semantic schema.
+//  3. Require the panic to escape the post-validation emplacement pass.
+func TestProtobufEmplacerRecoveryOwnership(t *testing.T) {
+  unsupported := schemametadata.MetadataSchema_initialize()
+  unsupported.Any = true
+  errors := protobufFactory_validate()(struct {
+    Metadata *schemametadata.MetadataSchema
+    Explore  MetadataFactory_IExplore
+    Top      *schemametadata.MetadataSchema
+  }{
+    Metadata: unsupported,
+    Explore:  MetadataFactory_IExplore{Top: true},
+    Top:      unsupported,
+  })
+  if !slices.Contains(errors, "does not support any type") {
+    t.Fatalf("unsupported any fallback mismatch: %v", errors)
+  }
+
+  key := MetadataFactory.SoleLiteral("value")
+  dynamicKey := schemametadata.MetadataSchema_initialize()
+  dynamicKey.Atomics = append(dynamicKey.Atomics, schemametadata.MetadataAtomic_create(schemametadata.MetadataAtomic{Type: "string"}))
+  dynamic := schemametadata.MetadataObjectType_create(schemametadata.MetadataObjectType{
+    Name: "BrokenMap",
+    Properties: []*schemametadata.MetadataProperty{
+      schemametadata.MetadataProperty_create(schemametadata.MetadataProperty{
+        Key:   dynamicKey,
+        Value: schemametadata.MetadataSchema_initialize(),
+      }),
+    },
+  })
+  value := schemametadata.MetadataSchema_initialize()
+  value.Objects = append(value.Objects, schemametadata.MetadataObject_create(schemametadata.MetadataObject{Type: dynamic}))
+  object := schemametadata.MetadataObjectType_create(schemametadata.MetadataObjectType{
+    Name: "Broken",
+    Properties: []*schemametadata.MetadataProperty{
+      schemametadata.MetadataProperty_create(schemametadata.MetadataProperty{
+        Key:   key,
+        Value: value,
+      }),
+    },
+  })
+  defer func() {
+    if recover() == nil {
+      t.Fatal("unexpected Protobuf emplacer panic was swallowed")
+    }
+  }()
+  protobufFactory_emplaceObjects([]*schemametadata.MetadataObjectType{object})
+}

package/native/core/programmers/IsProgrammer.go

@@ -18,6 +18,7 @@ var IsProgrammer = isProgrammerNamespace{}
 
 type IsProgrammer_CONFIG_IOptions struct {
   Numeric   *bool
+  Finite    *bool
   Undefined *bool
   Object    func(props IsProgrammer_CONFIG_IOptions_ObjectProps) *shimast.Node
 }
@@ -182,6 +183,7 @@ func (isProgrammerNamespace) Decompose(props IsProgrammer_DecomposeProps) native
   f := nativecontext.EmitFactoryOf(isProgrammer_factory, props.Context.Emit)
   options := &IsProgrammer_CONFIG_IOptions{
     Numeric: props.Context.Options.Numeric,
+    Finite:  props.Context.Options.Finite,
     Object: func(v IsProgrammer_CONFIG_IOptions_ObjectProps) *shimast.Node {
       return nativeiterate.Check_object(nativeiterate.Check_objectProps{
         Config: nativeiterate.Check_object_IConfig{
@@ -397,8 +399,20 @@ func isProgrammer_binary(left *shimast.Expression, operator shimast.Kind, right
   )
 }
 
+// isProgrammer_option_numeric reports whether the number leaf gate must be
+// emitted at all. It opens on `finite` as well as `numeric` so that `finite:true`
+// alone rejects NaN and Infinity, matching how assert/validate open the same gate
+// via OptionPredicator.Numeric (which is likewise finite || numeric) and the
+// documented independence of the two flags (samchon/typia#2196). The gate only
+// decides whether check_number emits a guard; check_number's own inner selection
+// then picks Number.isFinite for `finite` or !Number.isNaN for `numeric`.
 func isProgrammer_option_numeric(options *IsProgrammer_CONFIG_IOptions) bool {
-  return options != nil && options.Numeric != nil && *options.Numeric
+  if options == nil {
+    return false
+  }
+  finite := options.Finite != nil && *options.Finite
+  numeric := options.Numeric != nil && *options.Numeric
+  return finite || numeric
 }
 
 func isProgrammer_option_undefined(options *IsProgrammer_CONFIG_IOptions) bool {

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

@@ -34,6 +34,10 @@ type compareEqualProgrammerGenerator struct {
   Config    CompareEqualProgrammer_IConfig
   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 +75,9 @@ func (compareEqualProgrammerNamespace) Write(props CompareEqualProgrammer_IProps
   }
 
   generator := &compareEqualProgrammerGenerator{
-    Config:    props.Config,
-    Recursive: nativeinternal.FeatureProgrammer.CollectionRecursive(collection),
+    Config:       props.Config,
+    Recursive:    nativeinternal.FeatureProgrammer.CollectionRecursive(collection),
+    MatcherIndex: map[int]bool{},
   }
   body := generator.schema(result.Data, "x", "y")
   statements := []string{}
@@ -89,6 +94,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 +166,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 +264,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 +307,328 @@ func (g *compareEqualProgrammerGenerator) objectCall(object *schemametadata.Meta
   return fmt.Sprintf("_eo%d(%s, %s)", object.Index, g.wrap(x), g.wrap(y))
 }
 
+// objectFlatBranch renders one member of an object union as a guarded member
+// comparator (the pre-discrimination form). It is used for a single-object
+// "union" and as the fallback for a union no supported predicate can split.
+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, not the value constraints (`typia.tags.*`, template patterns)
+// `compare` deliberately ignores.
+func (g *compareEqualProgrammerGenerator) matchObject(object *schemametadata.MetadataObjectType, v string) string {
+  checks := []string{}
+  regularKeys := []string{}
+  dynamic := []*schemametadata.MetadataProperty{}
+  for _, property := range object.Properties {
+    if compareProgrammer_isMethod(property) {
+      continue // methods carry no comparable data, so they do not route either
+    }
+    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.typeof(v, "string"))
+  }
+  if len(metadata.Functions) != 0 {
+    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 {
@@ -409,6 +782,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 {