typia 14.0.4 → 14.0.5

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

@@ -0,0 +1,206 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestRecursiveContainerHelperIndexTransform verifies recursive container helpers
+// remain callable when ordinary containers precede them in collection order.
+func TestRecursiveContainerHelperIndexTransform(t *testing.T) {
+  project := recursiveContainerHelperIndexProject(t)
+  js := recursiveContainerHelperIndexTransform(t, project)
+  recursiveContainerHelperIndexRunRuntimeCases(t, project, js)
+}
+
+func recursiveContainerHelperIndexProject(t *testing.T) string {
+  t.Helper()
+  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, "recursive-container-helper-index-")
+  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(recursiveContainerHelperIndexTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(recursiveContainerHelperIndexSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func recursiveContainerHelperIndexTransform(t *testing.T, project string) string {
+  t.Helper()
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/main.ts",
+      "--output", "js",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("recursive container helper transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  return out
+}
+
+func recursiveContainerHelperIndexRunRuntimeCases(t *testing.T, project string, js string) {
+  t.Helper()
+  node, err := exec.LookPath("node")
+  if err != nil {
+    t.Skip("node executable not found")
+  }
+  runtimeDir := filepath.Join(project, "runtime")
+  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
+    t.Fatalf("mkdir runtime dir: %v", err)
+  }
+  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
+  if err := os.WriteFile(filepath.Join(runtimeDir, "feature-stub.cjs"), []byte(recursiveContainerHelperIndexFeatureStub), 0o644); err != nil {
+    t.Fatalf("write feature stub: %v", err)
+  }
+  for _, helper := range []string{
+    "_jsonStringifyNumber",
+    "_jsonStringifyString",
+    "_randomArray",
+    "_randomNumber",
+    "_randomPick",
+    "_throwTypeGuardError",
+  } {
+    js = strings.ReplaceAll(
+      js,
+      `require("typia/lib/internal/`+helper+`")`,
+      `require("./feature-stub.cjs")`,
+    )
+  }
+  if err := os.WriteFile(filepath.Join(runtimeDir, "main.cjs"), []byte(ttscTypiaTestRewriteCommonJS(t, js)), 0o644); err != nil {
+    t.Fatalf("write runtime module: %v", err)
+  }
+  runner := filepath.Join(runtimeDir, "run.cjs")
+  if err := os.WriteFile(runner, []byte(recursiveContainerHelperIndexRuntimeRunner), 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("recursive container helper runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const recursiveContainerHelperIndexTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const recursiveContainerHelperIndexSource = `import typia from "typia";
+
+type JsonPrimitive = string | number | boolean | null;
+type JsonArray = JsonValue[];
+type JsonObject = { [key: string]: JsonValue };
+type JsonValue = JsonPrimitive | JsonArray | JsonObject;
+
+interface ArrayWitness {
+  ordinary: string[];
+  value: JsonValue;
+}
+
+type RecursiveTuple = [string, RecursiveTuple | null];
+interface TupleWitness {
+  ordinary: [number];
+  value: RecursiveTuple;
+}
+
+type RandomArray = Array<string | RandomArray>;
+interface RandomArrayWitness {
+  ordinary: string[];
+  value: RandomArray;
+}
+
+export const isArray = typia.createIs<ArrayWitness>();
+export const isTuple = typia.createIs<TupleWitness>();
+export const stringifyArray = typia.json.createStringify<ArrayWitness>();
+export const stringifyTuple = typia.json.createStringify<TupleWitness>();
+export const camelArray = typia.notations.createCamel<ArrayWitness>();
+export const camelTuple = typia.notations.createCamel<TupleWitness>();
+export const cloneArray = typia.plain.createClone<ArrayWitness>();
+export const cloneTuple = typia.plain.createClone<TupleWitness>();
+export const classifyArray = typia.plain.createClassify<ArrayWitness>();
+export const classifyTuple = typia.plain.createClassify<TupleWitness>();
+export const pruneArray = typia.plain.createPrune<ArrayWitness>();
+export const pruneTuple = typia.plain.createPrune<TupleWitness>();
+export const randomArray = typia.createRandom<RandomArrayWitness>({
+  array: () => [],
+  string: () => "generated",
+});
+export const randomTuple = typia.createRandom<TupleWitness>({
+  boolean: () => false,
+  number: () => 1,
+  string: () => "generated",
+});
+`
+
+const recursiveContainerHelperIndexRuntimeRunner = `const mod = require("./main.cjs");
+
+const arrayValue = { ordinary: ["a"], value: [1, { nested: [true, null] }] };
+const tupleValue = { ordinary: [1], value: ["root", ["child", null]] };
+
+const expect = (label, actual, expected) => {
+  if (actual !== expected) {
+    throw new Error(label + ": expected " + expected + ", got " + actual);
+  }
+};
+
+expect("is array", mod.isArray(arrayValue), true);
+expect("is tuple", mod.isTuple(tupleValue), true);
+expect("stringify array", mod.stringifyArray(arrayValue), JSON.stringify(arrayValue));
+expect("stringify tuple", mod.stringifyTuple(tupleValue), JSON.stringify(tupleValue));
+expect("notation array", mod.camelArray(arrayValue).value[1].nested[0], true);
+expect("notation tuple", mod.camelTuple(tupleValue).value[1][0], "child");
+expect("clone array", mod.cloneArray(arrayValue).value[1].nested[1], null);
+expect("clone tuple", mod.cloneTuple(tupleValue).value[1][0], "child");
+expect("classify array", mod.classifyArray(arrayValue).value[1].nested[0], true);
+expect("classify tuple", mod.classifyTuple(tupleValue).value[1][0], "child");
+
+const prunedArray = { ...arrayValue, extra: true };
+mod.pruneArray(prunedArray);
+expect("prune array", "extra" in prunedArray, false);
+const prunedTuple = { ...tupleValue, extra: true };
+mod.pruneTuple(prunedTuple);
+expect("prune tuple", "extra" in prunedTuple, false);
+
+const generatedArray = mod.randomArray();
+expect("random array", Array.isArray(generatedArray.value), true);
+const generatedTuple = mod.randomTuple();
+expect("random tuple", generatedTuple.value[0], "generated");
+`
+
+const recursiveContainerHelperIndexFeatureStub = `module.exports._jsonStringifyNumber = (value) => Number.isFinite(value) ? value : null;
+module.exports._jsonStringifyString = (value) => JSON.stringify(value);
+module.exports._randomArray = () => [];
+module.exports._randomNumber = () => 1;
+module.exports._randomPick = (values) => values[0];
+module.exports._throwTypeGuardError = (props) => { throw Object.assign(new Error(props.expected), props); };
+`

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

@@ -0,0 +1,88 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestWrongTypeTagTargetDiagnostic verifies a rejected tag names its declared
+// target once and leaves a compatible tag untouched.
+func TestWrongTypeTagTargetDiagnostic(t *testing.T) {
+  project := wrongTypeTagTargetDiagnosticProject(t)
+  _, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/main.ts",
+      "--output", "js",
+    })
+  })
+  if code == 0 {
+    t.Fatal("wrong-target tag unexpectedly transformed without diagnostics")
+  }
+  const expected = `the property ["typia.tag"] target must contain array type.`
+  if count := strings.Count(errText, expected); count != 1 {
+    t.Fatalf("wrong-target diagnostic count mismatch: got %d, want 1\n%s", count, errText)
+  }
+  if count := strings.Count(errText, "Payload.invalid:"); count != 1 {
+    t.Fatalf("diagnostic ownership mismatch: got %d, want 1\n%s", count, errText)
+  }
+  if strings.Contains(errText, "target must contain boolean type") {
+    t.Fatalf("diagnostic named the host type:\n%s", errText)
+  }
+  if strings.Contains(errText, "Payload.valid:") {
+    t.Fatalf("valid array control produced a diagnostic:\n%s", errText)
+  }
+}
+
+func wrongTypeTagTargetDiagnosticProject(t *testing.T) string {
+  t.Helper()
+  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)
+  }
+  project, err := os.MkdirTemp(base, "wrong-tag-target-")
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() { _ = os.RemoveAll(project) })
+  src := filepath.Join(project, "src")
+  if err := os.MkdirAll(src, 0o755); err != nil {
+    t.Fatalf("mkdir fixture src: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(project, "tsconfig.json"), []byte(wrongTypeTagTargetDiagnosticTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(wrongTypeTagTargetDiagnosticSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return project
+}
+
+const wrongTypeTagTargetDiagnosticTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const wrongTypeTagTargetDiagnosticSource = `import typia, { tags } from "typia";
+
+interface Payload {
+  invalid: boolean & tags.MinItems<1>;
+  valid: string[] & tags.MinItems<1>;
+}
+
+export const test = (input: unknown) => typia.is<Payload>(input);
+`

package/native/core/factories/MetadataTypeTagFactory.go

@@ -2,6 +2,7 @@ package factories
 
 import (
   "fmt"
+  "reflect"
   "strings"
 
   schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
@@ -162,12 +163,15 @@ func (metadataTypeTagFactoryNamespace) Analyze(props struct {
     if tag == nil {
       continue
     }
-    target := ""
-    if metadataTypeTagFactory_includes(tag.Target, props.Type) {
-      target = props.Type
+    if metadataTypeTagFactory_includes(tag.Target, props.Type) == false {
+      report(struct {
+        Property *string
+        Message  string
+      }{Property: nil, Message: metadataTypeTagFactory_target_message(tag.Target)})
+      continue
     }
     output = append(output, schemametadata.IMetadataTypeTag{
-      Target:    target,
+      Target:    props.Type,
       Name:      tag.Name,
       Kind:      tag.Kind,
       Value:     tag.Value,
@@ -195,7 +199,7 @@ func (metadataTypeTagFactoryNamespace) Analyze(props struct {
       for _, object := range props.Objects {
         names = append(names, object.Name)
       }
-      *props.Errors = append(*props.Errors, MetadataFactory_IError{
+      metadataTypeTagFactory_append_error(props.Errors, MetadataFactory_IError{
         Name:     strings.Join(names, " & "),
         Explore:  props.Explore,
         Messages: messages,
@@ -218,10 +222,14 @@ func (metadataTypeTagFactoryNamespace) Validate(props struct {
   for _, tag := range props.Tags {
     if tag.Target != props.Type {
       if success {
+        target := tag.Target
+        if target == "" {
+          target = props.Type
+        }
         success = props.Report(struct {
           Property *string
           Message  string
-        }{Property: nil, Message: "target must contain " + props.Type + " type"})
+        }{Property: nil, Message: metadataTypeTagFactory_target_message([]string{target})})
       }
     }
   }
@@ -570,3 +578,16 @@ func metadataTypeTagFactory_essentialFieldsMessage() string {
   }
   return strings.Join(values, ", ")
 }
+
+func metadataTypeTagFactory_target_message(targets []string) string {
+  return "target must contain " + strings.Join(targets, " or ") + " type"
+}
+
+func metadataTypeTagFactory_append_error(errors *[]MetadataFactory_IError, next MetadataFactory_IError) {
+  for _, previous := range *errors {
+    if reflect.DeepEqual(previous, next) {
+      return
+    }
+  }
+  *errors = append(*errors, next)
+}

package/native/core/programmers/RandomProgrammer.go

@@ -345,11 +345,14 @@ func randomProgrammer_write_array_functions(props struct {
 }) []*shimast.Node {
   f := nativecontext.EmitFactoryOf(randomProgrammer_factory, props.Context.Emit)
   output := []*shimast.Node{}
-  for i, array := range props.Collection.Arrays() {
+  for _, array := range props.Collection.Arrays() {
     if array.Recursive == false {
       continue
     }
-    index := i
+    index := 0
+    if array.Index != nil {
+      index = *array.Index
+    }
     array := array
     output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
       Name: randomProgrammer_prefix_array(index),
@@ -396,11 +399,14 @@ func randomProgrammer_write_tuple_functions(props struct {
   f := nativecontext.EmitFactoryOf(randomProgrammer_factory, props.Context.Emit)
   output := []*shimast.Node{}
   _, unsatisfiableTuples := nativehelpers.RandomJoiner.UnsatisfiableRecursives(props.Collection.Objects(), props.Collection.Tuples())
-  for i, tuple := range props.Collection.Tuples() {
+  for _, tuple := range props.Collection.Tuples() {
     if tuple.Recursive == false {
       continue
     }
-    index := i
+    index := 0
+    if tuple.Index != nil {
+      index = *tuple.Index
+    }
     tuple := tuple
     if unsatisfiableTuples[tuple] {
       panic(nativecontext.NewTransformerError(nativecontext.TransformerError_IProps{

package/native/core/programmers/internal/CheckerProgrammer.go

@@ -181,13 +181,17 @@ func (checkerProgrammerNamespace) Write_array_functions(props CheckerProgrammer_
   f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, props.Context.Emit)
   arrays := props.Collection.Arrays()
   output := []*shimast.Node{}
-  for i, typ := range arrays {
+  for _, typ := range arrays {
     if typ.Recursive == false {
       continue
     }
+    index := 0
+    if typ.Index != nil {
+      index = *typ.Index
+    }
     input := f.NewIdentifier("input")
     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,
@@ -200,7 +204,7 @@ func (checkerProgrammerNamespace) Write_array_functions(props CheckerProgrammer_
         nativefactories.TypeFactory.Keyword("any", props.Context.Emit),
         nil,
         f.NewToken(shimast.KindEqualsGreaterThanToken),
-        checkerProgrammer_visit_guard(FeatureProgrammer.VisitKey(props.Config.Prefix, "a", i), checkerProgrammer_decode_array_inline(checkerProgrammer_decodeArrayInlineProps{
+        checkerProgrammer_visit_guard(FeatureProgrammer.VisitKey(props.Config.Prefix, "a", index), checkerProgrammer_decode_array_inline(checkerProgrammer_decodeArrayInlineProps{
           Config:  props.Config,
           Context: props.Context,
           Functor: props.Functor,
@@ -226,13 +230,17 @@ func (checkerProgrammerNamespace) Write_tuple_functions(props CheckerProgrammer_
   f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, props.Context.Emit)
   tuples := props.Collection.Tuples()
   output := []*shimast.Node{}
-  for i, tuple := range tuples {
+  for _, tuple := range tuples {
     if tuple.Recursive == false {
       continue
     }
+    index := 0
+    if tuple.Index != nil {
+      index = *tuple.Index
+    }
     input := f.NewIdentifier("input")
     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,
@@ -245,7 +253,7 @@ func (checkerProgrammerNamespace) Write_tuple_functions(props CheckerProgrammer_
         nativefactories.TypeFactory.Keyword("any", props.Context.Emit),
         nil,
         f.NewToken(shimast.KindEqualsGreaterThanToken),
-        checkerProgrammer_visit_guard(FeatureProgrammer.VisitKey(props.Config.Prefix, "t", i), checkerProgrammer_decode_tuple_inline(checkerProgrammer_decodeTupleInlineProps{
+        checkerProgrammer_visit_guard(FeatureProgrammer.VisitKey(props.Config.Prefix, "t", index), checkerProgrammer_decode_tuple_inline(checkerProgrammer_decodeTupleInlineProps{
           Config:  props.Config,
           Context: props.Context,
           Functor: props.Functor,

package/native/core/programmers/json/JsonStringifyProgrammer.go

@@ -100,12 +100,16 @@ func jsonStringifyProgrammer_write_array_functions(props struct {
 }) []*shimast.Node {
   f := nativecontext.EmitFactoryOf(jsonStringifyProgrammer_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,
@@ -118,7 +122,7 @@ func jsonStringifyProgrammer_write_array_functions(props struct {
         nil,
         f.NewToken(shimast.KindEqualsGreaterThanToken),
         nativeinternal.FeatureProgrammer.VisitGuardSerialize(
-          nativeinternal.FeatureProgrammer.VisitKey(props.Config.Prefix, "a", i),
+          nativeinternal.FeatureProgrammer.VisitKey(props.Config.Prefix, "a", index),
           jsonStringifyProgrammer_circular_thrower(props.Context, props.Functor),
           jsonStringifyProgrammer_decode_array_inline(jsonStringifyProgrammer_decodeArrayProps{
             Context: props.Context,
@@ -153,12 +157,16 @@ func jsonStringifyProgrammer_write_tuple_functions(props struct {
 }) []*shimast.Node {
   f := nativecontext.EmitFactoryOf(jsonStringifyProgrammer_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,
@@ -171,7 +179,7 @@ func jsonStringifyProgrammer_write_tuple_functions(props struct {
         nil,
         f.NewToken(shimast.KindEqualsGreaterThanToken),
         nativeinternal.FeatureProgrammer.VisitGuardSerialize(
-          nativeinternal.FeatureProgrammer.VisitKey(props.Config.Prefix, "t", i),
+          nativeinternal.FeatureProgrammer.VisitKey(props.Config.Prefix, "t", index),
           jsonStringifyProgrammer_circular_thrower(props.Context, props.Functor),
           jsonStringifyProgrammer_decode_tuple_inline(jsonStringifyProgrammer_decodeTupleInlineProps{
             Context:   props.Context,

package/native/core/programmers/notations/NotationGeneralProgrammer.go

@@ -131,12 +131,16 @@ func notationGeneralProgrammer_write_array_functions(props struct {
 }) []*shimast.Node {
   f := nativecontext.EmitFactoryOf(notationGeneralProgrammer_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,
@@ -149,7 +153,7 @@ func notationGeneralProgrammer_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,
           notationGeneralProgrammer_decode_array_inline(notationGeneralProgrammer_decodeArrayProps{
             Context: props.Context,
@@ -184,12 +188,16 @@ func notationGeneralProgrammer_write_tuple_functions(props struct {
 }) []*shimast.Node {
   f := nativecontext.EmitFactoryOf(notationGeneralProgrammer_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,
@@ -202,7 +210,7 @@ func notationGeneralProgrammer_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,
           notationGeneralProgrammer_decode_tuple_inline(notationGeneralProgrammer_decodeTupleInlineProps{
             Context: props.Context,

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

@@ -135,12 +135,16 @@ func plainClassifyProgrammer_write_array_functions(props struct {
 }) []*shimast.Node {
   f := nativecontext.EmitFactoryOf(plainClassifyProgrammer_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,
@@ -153,7 +157,7 @@ func plainClassifyProgrammer_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,
           plainClassifyProgrammer_decode_array_inline(plainClassifyProgrammer_decodeArrayProps{
             Context: props.Context,
@@ -187,12 +191,16 @@ func plainClassifyProgrammer_write_tuple_functions(props struct {
 }) []*shimast.Node {
   f := nativecontext.EmitFactoryOf(plainClassifyProgrammer_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,
@@ -205,7 +213,7 @@ func plainClassifyProgrammer_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,
           plainClassifyProgrammer_decode_tuple_inline(plainClassifyProgrammer_decodeTupleInlineProps{
             Context: props.Context,

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "14.0.4",
+  "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.4",
-    "@typia/utils": "^14.0.4"
+    "@typia/interface": "^14.0.5",
+    "@typia/utils": "^14.0.5"
   },
   "peerDependencies": {
     "ttsc": ">=0.19.2"