typia 14.0.3 → 14.0.5

package/native/core/programmers/plain/PlainCloneProgrammer.go

@@ -96,12 +96,16 @@ func plainCloneProgrammer_write_array_functions(props struct {
 }) []*shimast.Node {
   f := nativecontext.EmitFactoryOf(plainCloneProgrammer_factory, props.Context.Emit)
   output := []*shimast.Node{}
-  for i, typ := range props.Collection.Arrays() {
+  for _, typ := range props.Collection.Arrays() {
     if typ.Recursive == false {
       continue
     }
+    index := 0
+    if typ.Index != nil {
+      index = *typ.Index
+    }
     output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-      Name: fmt.Sprintf("%sa%d", props.Config.Prefix, i),
+      Name: fmt.Sprintf("%sa%d", props.Config.Prefix, index),
       Value: f.NewArrowFunction(
         nil,
         nil,
@@ -114,7 +118,7 @@ func plainCloneProgrammer_write_array_functions(props struct {
         nil,
         f.NewToken(shimast.KindEqualsGreaterThanToken),
         nativeinternal.FeatureProgrammer.VisitGuardRebuild(
-          nativeinternal.FeatureProgrammer.VisitKey(props.Config.Prefix, "a", i),
+          nativeinternal.FeatureProgrammer.VisitKey(props.Config.Prefix, "a", index),
           true,
           plainCloneProgrammer_decode_array_inline(plainCloneProgrammer_decodeArrayProps{
             Context: props.Context,
@@ -148,12 +152,16 @@ func plainCloneProgrammer_write_tuple_functions(props struct {
 }) []*shimast.Node {
   f := nativecontext.EmitFactoryOf(plainCloneProgrammer_factory, props.Context.Emit)
   output := []*shimast.Node{}
-  for i, tuple := range props.Collection.Tuples() {
+  for _, tuple := range props.Collection.Tuples() {
     if tuple.Recursive == false {
       continue
     }
+    index := 0
+    if tuple.Index != nil {
+      index = *tuple.Index
+    }
     output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-      Name: fmt.Sprintf("%st%d", props.Config.Prefix, i),
+      Name: fmt.Sprintf("%st%d", props.Config.Prefix, index),
       Value: f.NewArrowFunction(
         nil,
         nil,
@@ -166,7 +174,7 @@ func plainCloneProgrammer_write_tuple_functions(props struct {
         nil,
         f.NewToken(shimast.KindEqualsGreaterThanToken),
         nativeinternal.FeatureProgrammer.VisitGuardRebuild(
-          nativeinternal.FeatureProgrammer.VisitKey(props.Config.Prefix, "t", i),
+          nativeinternal.FeatureProgrammer.VisitKey(props.Config.Prefix, "t", index),
           true,
           plainCloneProgrammer_decode_tuple_inline(plainCloneProgrammer_decodeTupleInlineProps{
             Context: props.Context,

package/native/core/programmers/plain/PlainPruneProgrammer.go

@@ -93,12 +93,16 @@ func plainPruneProgrammer_write_array_functions(props struct {
 }) []*shimast.Node {
   f := nativecontext.EmitFactoryOf(plainPruneProgrammer_factory, props.Context.Emit)
   output := []*shimast.Node{}
-  for i, typ := range props.Collection.Arrays() {
+  for _, typ := range props.Collection.Arrays() {
     if typ.Recursive == false {
       continue
     }
+    index := 0
+    if typ.Index != nil {
+      index = *typ.Index
+    }
     output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-      Name: fmt.Sprintf("%sa%d", props.Config.Prefix, i),
+      Name: fmt.Sprintf("%sa%d", props.Config.Prefix, index),
       Value: f.NewArrowFunction(
         nil,
         nil,
@@ -111,7 +115,7 @@ func plainPruneProgrammer_write_array_functions(props struct {
         nil,
         f.NewToken(shimast.KindEqualsGreaterThanToken),
         nativeinternal.FeatureProgrammer.VisitGuardSkip(
-          nativeinternal.FeatureProgrammer.VisitKey(props.Config.Prefix, "a", i),
+          nativeinternal.FeatureProgrammer.VisitKey(props.Config.Prefix, "a", index),
           plainPruneProgrammer_decode_array_inline(plainPruneProgrammer_decodeArrayProps{
             Context: props.Context,
             Config:  props.Config,
@@ -144,12 +148,16 @@ func plainPruneProgrammer_write_tuple_functions(props struct {
 }) []*shimast.Node {
   f := nativecontext.EmitFactoryOf(plainPruneProgrammer_factory, props.Context.Emit)
   output := []*shimast.Node{}
-  for i, tuple := range props.Collection.Tuples() {
+  for _, tuple := range props.Collection.Tuples() {
     if tuple.Recursive == false {
       continue
     }
+    index := 0
+    if tuple.Index != nil {
+      index = *tuple.Index
+    }
     output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-      Name: fmt.Sprintf("%st%d", props.Config.Prefix, i),
+      Name: fmt.Sprintf("%st%d", props.Config.Prefix, index),
       Value: f.NewArrowFunction(
         nil,
         nil,
@@ -162,7 +170,7 @@ func plainPruneProgrammer_write_tuple_functions(props struct {
         nil,
         f.NewToken(shimast.KindEqualsGreaterThanToken),
         nativeinternal.FeatureProgrammer.VisitGuardSkip(
-          nativeinternal.FeatureProgrammer.VisitKey(props.Config.Prefix, "t", i),
+          nativeinternal.FeatureProgrammer.VisitKey(props.Config.Prefix, "t", index),
           plainPruneProgrammer_decode_tuple_inline(plainPruneProgrammer_decodeTupleInlineProps{
             Context: props.Context,
             Config:  props.Config,
@@ -805,6 +813,14 @@ func plainPruneProgrammer_initializer(props nativeinternal.FeatureProgrammer_Ini
 }
 
 func plainPruneProgrammer_filter(metadata *schemametadata.MetadataSchema) bool {
+  return plainPruneProgrammer_filter_visited(metadata, map[*schemametadata.MetadataSchema]bool{})
+}
+
+func plainPruneProgrammer_filter_visited(metadata *schemametadata.MetadataSchema, visited map[*schemametadata.MetadataSchema]bool) bool {
+  if visited[metadata] {
+    return false
+  }
+  visited[metadata] = true
   if metadata.Any {
     return false
   }
@@ -812,12 +828,12 @@ func plainPruneProgrammer_filter(metadata *schemametadata.MetadataSchema) bool {
     return true
   }
   for _, tuple := range metadata.Tuples {
-    if plainPruneProgrammer_tuple_filter(tuple) {
+    if plainPruneProgrammer_tuple_filter_visited(tuple, visited) {
       return true
     }
   }
   for _, array := range metadata.Arrays {
-    if plainPruneProgrammer_filter(array.Type.Value) {
+    if plainPruneProgrammer_filter_visited(array.Type.Value, visited) {
       return true
     }
   }
@@ -825,11 +841,15 @@ func plainPruneProgrammer_filter(metadata *schemametadata.MetadataSchema) bool {
 }
 
 func plainPruneProgrammer_tuple_filter(tuple *schemametadata.MetadataTuple) bool {
+  return plainPruneProgrammer_tuple_filter_visited(tuple, map[*schemametadata.MetadataSchema]bool{})
+}
+
+func plainPruneProgrammer_tuple_filter_visited(tuple *schemametadata.MetadataTuple, visited map[*schemametadata.MetadataSchema]bool) bool {
   return len(tuple.Type.Elements) != 0 && plainPruneProgrammer_some_schema(tuple.Type.Elements, func(elem *schemametadata.MetadataSchema) bool {
     if elem.Rest != nil {
-      return plainPruneProgrammer_filter(elem.Rest)
+      return plainPruneProgrammer_filter_visited(elem.Rest, visited)
     }
-    return plainPruneProgrammer_filter(elem)
+    return plainPruneProgrammer_filter_visited(elem, visited)
   })
 }
 

package/native/core/programmers/reflect/ReflectLiteralsProgrammer.go

@@ -29,24 +29,12 @@ func (reflectLiteralsProgrammerNamespace) Write(props ReflectLiteralsProgrammer_
       Escape:   true,
       Constant: true,
       Absorb:   true,
-      // Accept exactly what the emitter below can render: constant literals,
-      // the `boolean` atomic (the `true | false` union), and `null`. `null` is
-      // a `MetadataSchema` flag rather than a bucket, so `Size()` cannot see
-      // it; weighing it on both sides keeps `length` meaning "renderable
-      // members" against `size` meaning "members", which is what lets a
-      // rejected argument carry the diagnostic its composition calls for
-      // instead of collapsing onto `NO`.
-      //
-      // Equal counts with no member at all is an uninhabited argument: the
-      // `never` keyword, an alias or `Exclude`/`Extract` that filters
-      // everything away, or an intersection whose every distributed member
-      // prunes to never. Its literal set is empty and
-      // `literals<never>(): never[]` has exactly one inhabitant, so it emits
-      // `[]` rather than a diagnostic (issue #2377). `undefined` and `void`
-      // coalesce to the same empty metadata, but neither satisfies the public
-      // `T extends Atomic.Type | null` bound, and typia refuses to transform
-      // at all without `strictNullChecks` (`transform/transform.go`), so
-      // neither reaches this predicate.
+      // Only a constant literal, the `boolean` atomic (which stands for the
+      // `true | false` constants), and `null` beside them are members this
+      // operation can hand back. Anything else -- an unconstrained atomic, a
+      // template, a bucket of any other kind -- is rejected, and so is an
+      // argument carrying no member at all: `never` has no literal to list, so
+      // it is a compile error rather than an empty array (issue #2377).
       Validate: func(next struct {
         Metadata *nativemetadata.MetadataSchema
         Explore  nativefactories.MetadataFactory_IExplore
@@ -61,18 +49,13 @@ func (reflectLiteralsProgrammerNamespace) Write(props ReflectLiteralsProgrammer_
             length++
           }
         }
-        size := next.Metadata.Size()
-        if next.Metadata.Nullable {
-          length++
-          size++
-        }
-        if size == length {
-          return []string{}
-        }
         if length == 0 {
           return []string{string(ReflectLiteralsProgrammer_ErrorMessages_NO)}
         }
-        return []string{string(ReflectLiteralsProgrammer_ErrorMessages_ONLY)}
+        if next.Metadata.Size() != length {
+          return []string{string(ReflectLiteralsProgrammer_ErrorMessages_ONLY)}
+        }
+        return []string{}
       },
     },
     Components: nativemetadata.NewMetadataCollection(),

package/native/core/schemas/metadata/MetadataBigint.go

@@ -0,0 +1,37 @@
+package metadata
+
+// MetadataBigint is the value of a `bigint` constant.
+//
+// typescript-go reports a bigint literal as a `jsnum.PseudoBigInt`, a struct in
+// an internal package the shim does not re-export. Nothing downstream could
+// name it, so consumers that had to render the value reflected its fields
+// instead and emitted `{ base10Value: "2", negative: false }` where the caller
+// declared `bigint`. This is the nameable stand-in.
+//
+// It is a comparable struct on purpose. Every other value a
+// `MetadataConstantValue` carries -- `string`, `bool`, the number -- is
+// comparable, and the factories compare those values with `==`; the
+// intersection tag assigner is one such site. A pointer type such as
+// `*math/big.Int` would compare identity there and, for bigints alone,
+// silently drop whatever the comparison decides.
+type MetadataBigint struct {
+  // Text is the exact value in base 10, prefixed with `-` when negative. A
+  // bigint exists to hold what a float64 cannot, so the digits are the only
+  // representation that stays exact at every magnitude.
+  Text string
+}
+
+// String renders the base-10 digits, which is what every consumer that lowers a
+// bigint into emitted code reads through `fmt.Sprint`.
+func (obj MetadataBigint) String() string {
+  return obj.Text
+}
+
+// MarshalJSON writes the digits unquoted, so metadata marshaled by a
+// downstream tool carries the same JSON number a plain integer would.
+func (obj MetadataBigint) MarshalJSON() ([]byte, error) {
+  if obj.Text == "" {
+    return []byte("0"), nil
+  }
+  return []byte(obj.Text), nil
+}

package/native/core/schemas/metadata/metadata_bigint_is_comparable_test.go

@@ -0,0 +1,65 @@
+package metadata
+
+import (
+  "encoding/json"
+  "fmt"
+  "testing"
+)
+
+// TestMetadataBigintIsComparable pins the property the whole representation
+// rests on: two independently built values of the same bigint are `==`.
+//
+// A `MetadataConstantValue.Value` is compared with `==` inside the factories --
+// the intersection tag assigner matches a child's constant against the merged
+// parent's that way -- and every other value it can hold (`string`, `bool`, the
+// number) is a comparable value. A pointer stand-in such as `*math/big.Int`
+// builds a fresh allocation per literal, so those comparisons would test
+// identity and, for bigints alone, silently decide "not the same constant":
+// `(1n | 2n) & tags.Type<"int64">` lost its tag that way. This is the guard,
+// held one level below the transform so a future change to the representation
+// fails here rather than as a dropped tag three packages away.
+//
+//  1. Build the same value twice, independently, and compare with `==`.
+//  2. Compare a different value, and a negative against its positive.
+//  3. Check the two renderings every consumer reads: `fmt.Sprint` for the emit
+//     and `encoding/json` for metadata a downstream tool marshals.
+func TestMetadataBigintIsComparable(t *testing.T) {
+  const digits = "9007199254740993"
+  left := MetadataBigint{Text: digits}
+  right := MetadataBigint{Text: digits}
+  if left != right {
+    t.Fatalf("two values of the same bigint must be ==: %v vs %v", left, right)
+  }
+  var boxed any = left
+  if boxed != any(right) {
+    t.Fatalf("the same bigint must stay == once boxed in the `any` a constant value holds")
+  }
+  if left == (MetadataBigint{Text: "9007199254740992"}) {
+    t.Fatalf("distinct bigints must not compare equal")
+  }
+  if left == (MetadataBigint{Text: "-" + digits}) {
+    t.Fatalf("a negative must not compare equal to its positive")
+  }
+
+  if got := fmt.Sprint(left); got != digits {
+    t.Fatalf("fmt.Sprint must render the base-10 digits, got %q", got)
+  }
+  if got := fmt.Sprint(MetadataBigint{Text: "-5"}); got != "-5" {
+    t.Fatalf("a negative must keep its sign, got %q", got)
+  }
+
+  encoded, err := json.Marshal(left)
+  if err != nil {
+    t.Fatalf("marshal bigint: %v", err)
+  }
+  if string(encoded) != digits {
+    t.Fatalf("marshaled bigint must be the unquoted digits, got %s", encoded)
+  }
+  zero, err := json.Marshal(MetadataBigint{})
+  if err != nil {
+    t.Fatalf("marshal zero bigint: %v", err)
+  }
+  if string(zero) != "0" {
+    t.Fatalf("the zero value must marshal as 0, got %s", zero)
+  }
+}

package/native/transform/features/reflect/ReflectSchemaTransformer.go

@@ -1,10 +1,7 @@
 package reflect
 
 import (
-  "encoding/json"
   "strings"
-  "unicode"
-  "unicode/utf8"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimprinter "github.com/microsoft/typescript-go/shim/printer"
@@ -67,50 +64,22 @@ func (reflectSchemaTransformerNamespace) Transform(props nativetransform.ITransf
   }, props.Context.Emit)
 }
 
+// reflectTransformer_literal lowers a metadata tree into its object literal.
+//
+// This used to round-trip the tree through `encoding/json` and then lowercase
+// each key's initial, which is exactly what `LiteralFactory` already does when
+// it reflects a struct. The round trip was not merely redundant: JSON has no
+// bigint, so a `bigint` constant -- the one value in the tree that is neither
+// a string nor a JSON number -- could not survive it. It came back as the
+// object its fields happened to spell, and `IMetadataSchema.IValue` declares
+// `bigint` there.
+//
+// Writing the tree directly leaves every other member identical (diffed over a
+// metadata tree spanning objects, optional and nullable members, tags, arrays,
+// tuples, sets, maps, natives, functions, aliases, and unions: the bigint
+// values were the only difference) and lets a bigint stay a bigint.
 func reflectTransformer_literal(value any, emit ...*shimprinter.EmitContext) *shimast.Node {
-  return nativefactories.LiteralFactory.Write(reflectTransformer_toPrimitive(value), emit...)
-}
-
-func reflectTransformer_toPrimitive(value any) any {
-  data, err := json.Marshal(value)
-  if err != nil {
-    return nil
-  }
-  var decoded any
-  if err := json.Unmarshal(data, &decoded); err != nil {
-    return nil
-  }
-  return reflectTransformer_lowerKeys(decoded)
-}
-
-func reflectTransformer_lowerKeys(value any) any {
-  switch v := value.(type) {
-  case map[string]any:
-    output := map[string]any{}
-    for key, elem := range v {
-      output[reflectTransformer_lowerInitial(key)] = reflectTransformer_lowerKeys(elem)
-    }
-    return output
-  case []any:
-    output := make([]any, 0, len(v))
-    for _, elem := range v {
-      output = append(output, reflectTransformer_lowerKeys(elem))
-    }
-    return output
-  default:
-    return value
-  }
-}
-
-func reflectTransformer_lowerInitial(str string) string {
-  if str == "" {
-    return str
-  }
-  r, size := utf8.DecodeRuneInString(str)
-  if r == utf8.RuneError && size == 0 {
-    return str
-  }
-  return string(unicode.ToLower(r)) + str[size:]
+  return nativefactories.LiteralFactory.Write(value, emit...)
 }
 
 func reflectTransformer_errors(errors []nativefactories.MetadataFactory_IError) []nativetransform.TransformerError_MetadataFactory_IError {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "14.0.3",
+  "version": "14.0.5",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "exports": {
@@ -43,8 +43,8 @@
   "homepage": "https://typia.io",
   "dependencies": {
     "randexp": "^0.5.3",
-    "@typia/interface": "^14.0.3",
-    "@typia/utils": "^14.0.3"
+    "@typia/interface": "^14.0.5",
+    "@typia/utils": "^14.0.5"
   },
   "peerDependencies": {
     "ttsc": ">=0.19.2"

package/native/cmd/ttsc-typia/reflect_literals_empty_union_transform_test.go

@@ -1,161 +0,0 @@
-package main
-
-import (
-  "os"
-  "os/exec"
-  "path/filepath"
-  "testing"
-)
-
-// TestReflectLiteralsEmptyUnionTransform pins issue #2377: the literal set of an
-// empty union is the empty array, not a transform error.
-//
-// The programmer admits a type argument by counting the members it can render,
-// and it renders three kinds -- constant literals, the `boolean` atomic, and
-// `null`. `null` is a `MetadataSchema` flag rather than a bucket, so it was
-// missing from the count, which made two admissible arguments look like "no
-// constant literal type found": `never`, whose union is empty on both sides of
-// the comparison, and `null`, which the public
-// `literals<T extends Atomic.Type | null>()` signature documents. `never` is
-// vacuously literal-only and `literals<never>(): never[]` has exactly one
-// inhabitant, so both must transform and run.
-//
-//  1. Transform a module whose `reflect.literals` arguments span every
-//     uninhabited spelling a caller reaches -- the keyword, an alias, an
-//     exhaustive `Exclude`, an empty `Extract`, a TypeScript-collapsed
-//     intersection, and one typia prunes itself -- plus `null`, a fully mixed
-//     literal union, and the plain `boolean` atomic.
-//  2. Execute the emitted CommonJS.
-//  3. Assert `never` yields `[]`, `null` yields `[null]`, and the arguments that
-//     already worked keep their exact members and order, including the sort the
-//     guide documents.
-func TestReflectLiteralsEmptyUnionTransform(t *testing.T) {
-  node, err := exec.LookPath("node")
-  if err != nil {
-    t.Skip("node executable not found")
-  }
-  root := ttscTypiaTestRepoRoot(t)
-  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
-  if err := os.MkdirAll(base, 0o755); err != nil {
-    t.Fatalf("mkdir temp base: %v", err)
-  }
-  dir, err := os.MkdirTemp(base, "reflect-literals-empty-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
-  src := filepath.Join(dir, "src")
-  if err := os.MkdirAll(src, 0o755); err != nil {
-    t.Fatalf("mkdir fixture src: %v", err)
-  }
-  if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(atomicIntersectionSchemaTSConfig), 0o644); err != nil {
-    t.Fatalf("write tsconfig: %v", err)
-  }
-  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(reflectLiteralsEmptyUnionSource), 0o644); err != nil {
-    t.Fatalf("write source: %v", err)
-  }
-  ttscTypiaTestTypecheck(t, dir)
-
-  out, errText, code := ttscTypiaTestCapture(func() int {
-    return runTransform([]string{
-      "--cwd", dir,
-      "--tsconfig", "tsconfig.json",
-      "--file", "src/main.ts",
-      "--output", "js",
-    })
-  })
-  if code != 0 {
-    t.Fatalf("reflect.literals empty union transform failed: code=%d stderr=\n%s", code, errText)
-  }
-
-  runtimeDir := filepath.Join(dir, "runtime")
-  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
-    t.Fatalf("mkdir runtime dir: %v", err)
-  }
-  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
-  runtimeJS := ttscTypiaTestRewriteCommonJS(t, out)
-  if err := os.WriteFile(filepath.Join(runtimeDir, "main.cjs"), []byte(runtimeJS), 0o644); err != nil {
-    t.Fatalf("write runtime module: %v", err)
-  }
-  runner := filepath.Join(runtimeDir, "run.cjs")
-  if err := os.WriteFile(runner, []byte(reflectLiteralsEmptyUnionRunner), 0o644); err != nil {
-    t.Fatalf("write runtime runner: %v", err)
-  }
-  cmd := exec.Command(node, runner)
-  cmd.Dir = runtimeDir
-  output, err := cmd.CombinedOutput()
-  if err != nil {
-    t.Fatalf("reflect.literals empty union runtime cases failed: %v\n%s", err, output)
-  }
-}
-
-const reflectLiteralsEmptyUnionSource = `import typia from "typia";
-
-type Color = "red" | "green" | "blue";
-type Empty = never;
-
-// The empty union: no member on either side of the admission comparison. Every
-// spelling a caller reaches it through has to transform, not only the keyword:
-// an alias hides it behind a name, and a conditional or an exhaustive Exclude
-// is how a generic caller produces one without writing "never" at all.
-export const empty = typia.reflect.literals<never>();
-export const emptyAlias = typia.reflect.literals<Empty>();
-export const emptyExclude = typia.reflect.literals<Exclude<Color, Color>>();
-export const emptyExtract = typia.reflect.literals<Extract<Color, "cyan">>();
-
-// Uninhabited without the keyword: TypeScript collapses one to never itself,
-// while the other stays an intersection whose every distributed member typia
-// prunes away. Both are empty on both sides of the comparison, so the rule the
-// keyword exercises has to cover them too.
-export const emptyCollapsed = typia.reflect.literals<string & number>();
-export const emptyPruned = typia.reflect.literals<(string | number) & { data: number }>();
-
-// A union whose only member is the nullable flag, which carries no bucket.
-export const onlyNull = typia.reflect.literals<null>();
-
-// Controls that already transformed: the flag must join the count without
-// displacing a constant, a boolean atomic, or their order.
-export const mixed = typia.reflect.literals<"a" | 1 | true | null>();
-export const booleanAtomic = typia.reflect.literals<boolean>();
-export const booleanAtomicNull = typia.reflect.literals<boolean | null>();
-
-// Declaration order deliberately disagrees with the emitted order: values of
-// one primitive type are sorted (iterate_metadata_sort), which is the behavior
-// the reflect.literals guide states.
-export const sorted = typia.reflect.literals<"b" | "a" | 10 | 2>();
-`
-
-const reflectLiteralsEmptyUnionRunner = `const mod = require("./main.cjs");
-
-const check = (label, actual, expected) => {
-  if (Array.isArray(actual) === false) {
-    throw new Error(label + ": expected an array, got " + JSON.stringify(actual));
-  }
-  if (
-    actual.length !== expected.length ||
-    actual.some((item, index) => item !== expected[index])
-  ) {
-    throw new Error(
-      label +
-        ": expected " +
-        JSON.stringify(expected) +
-        ", got " +
-        JSON.stringify(actual),
-    );
-  }
-};
-
-check("never", mod.empty, []);
-check("never alias", mod.emptyAlias, []);
-check("exhaustive Exclude", mod.emptyExclude, []);
-check("empty Extract", mod.emptyExtract, []);
-check("collapsed intersection", mod.emptyCollapsed, []);
-check("pruned intersection", mod.emptyPruned, []);
-check("null", mod.onlyNull, [null]);
-check("mixed", mod.mixed, ["a", 1, true, null]);
-check("booleanAtomic", mod.booleanAtomic, [true, false]);
-check("booleanAtomicNull", mod.booleanAtomicNull, [true, false, null]);
-check("sorted", mod.sorted, ["a", "b", 2, 10]);
-
-console.log("ok");
-`