typia 13.1.1 → 13.1.19

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

@@ -4,6 +4,7 @@
 package main
 
 import (
+	"encoding/json"
 	"path/filepath"
 	"strings"
 	"testing"
@@ -16,10 +17,19 @@ import (
 // Running them through the same project transform mode gives Go coverage for
 // those native branches without duplicating that TypeScript corpus here.
 //
+// Each project is held to what its purpose guarantees, never to what its sources
+// happen to contain today. The feature projects exist to compile accepted typia
+// call sites, so they must transform without a diagnostic. `tests/test-error`
+// exists to hold call sites typia rejects, so it must report them. `tests/debug`
+// is a scratchpad whose contents are arbitrary by design (samchon/typia#2141): a
+// valid sample and a deliberately broken one are equally legitimate states, so
+// only the envelope contract itself is asserted for it. Asserting that the
+// scratchpad reports diagnostics is asserting that it always holds broken code.
+//
 // 1. Resolve existing TypeScript catalog projects from the repository root.
 // 2. Run project transform mode so every source file contributes call sites.
 // 3. Require JSON project output to include a TypeScript map.
-// 4. Fail on any native transform diagnostic from the catalog project.
+// 4. Hold each project to its own purpose's diagnostic contract.
 func TestProjectCatalogTransformCoverage(t *testing.T) {
 	root := transformCoverageRepoRoot(t)
 	for _, project := range []string{
@@ -35,14 +45,7 @@ func TestProjectCatalogTransformCoverage(t *testing.T) {
 	} {
 		project := project
 		t.Run(project, func(t *testing.T) {
-			cwd := filepath.Join(root, "tests", project)
-			out, errText, code := transformCoverageCapture(func() int {
-				return runTransform([]string{
-					"--cwd", cwd,
-					"--tsconfig", "tsconfig.json",
-					"--output", "ts",
-				})
-			})
+			out, errText, code := transformCatalogProject(root, project)
 			if code != 0 {
 				t.Fatalf("%s transform failed: code=%d stderr=\n%s", project, code, errText)
 			}
@@ -51,23 +54,66 @@ func TestProjectCatalogTransformCoverage(t *testing.T) {
 			}
 		})
 	}
-	for _, project := range []string{"debug", "test-error"} {
-		project := project
-		t.Run(project, func(t *testing.T) {
-			cwd := filepath.Join(root, "tests", project)
-			out, _, code := transformCoverageCapture(func() int {
-				return runTransform([]string{
-					"--cwd", cwd,
-					"--tsconfig", "tsconfig.json",
-					"--output", "ts",
-				})
-			})
-			if code != 3 {
-				t.Fatalf("%s transform should report diagnostics with code 3, got %d", project, code)
-			}
-			if !strings.Contains(out, `"diagnostics"`) || !strings.Contains(out, `"typescript"`) {
-				t.Fatalf("%s output should include diagnostics and TypeScript map:\n%s", project, out)
-			}
+	// tests/test-error compiles deliberately invalid call sites, and reporting them
+	// is that workspace's entire reason to exist. Its diagnostics are a contract,
+	// not an accident of what it currently holds.
+	t.Run("test-error", func(t *testing.T) {
+		out, _, code := transformCatalogProject(root, "test-error")
+		if code != 3 {
+			t.Fatalf("test-error transform should report diagnostics with code 3, got %d", code)
+		}
+		if !strings.Contains(out, `"diagnostics"`) || !strings.Contains(out, `"typescript"`) {
+			t.Fatalf("test-error output should include diagnostics and TypeScript map:\n%s", out)
+		}
+	})
+	// tests/debug is a one-off repro scratchpad, so nothing about its sources is
+	// promised: it holds valid code between investigations and invalid code during
+	// one. What survives both states is the project transform's own envelope
+	// contract, so that is what this pins. The project must resolve and reach a
+	// transform decision rather than fail to load (exit 2), it must still
+	// contribute transformed sources, and its exit code must agree with the
+	// envelope it published.
+	//
+	// Accepting either 0 or 3 is derived, not observed: transform mode never
+	// typechecks, so exit 2 is reachable only from a flag, cwd, or tsconfig-load
+	// failure (semantic diagnostics belong to the build route). No source content a
+	// repro leaves behind can produce it -- even an outright type error still exits
+	// 0 here -- which is what makes the band content-agnostic.
+	//
+	// The envelope is decoded rather than substring-matched because `"typescript"`
+	// carries no `omitempty` and runTransformProject initializes the map before its
+	// source loop: the key is present even when the workspace resolved no source at
+	// all. That empty envelope is the shape a `rootDir` or `include` rot leaves
+	// behind, and this workspace is the one that already shipped such a rot
+	// (samchon/typia#2132), so a key-presence check would pass over the one failure
+	// worth catching here.
+	t.Run("debug", func(t *testing.T) {
+		out, errText, code := transformCatalogProject(root, "debug")
+		if code != 0 && code != 3 {
+			t.Fatalf("debug transform should load and transform the project, got code=%d stderr=\n%s", code, errText)
+		}
+		var envelope transformProjectOutput
+		if err := json.Unmarshal([]byte(out), &envelope); err != nil {
+			t.Fatalf("debug project output should be a transform envelope: %v\n%s", err, out)
+		}
+		if len(envelope.TypeScript) == 0 {
+			t.Fatalf("debug project should contribute transformed sources, got an empty TypeScript map:\n%s", out)
+		}
+		if diagnosed := len(envelope.Diagnostics) > 0; diagnosed != (code == 3) {
+			t.Fatalf("debug exit code %d disagrees with its envelope (diagnostics present: %v):\n%s", code, diagnosed, out)
+		}
+	})
+}
+
+// transformCatalogProject runs project transform mode over one repository test
+// project and returns its captured stdout, stderr, and exit code.
+func transformCatalogProject(root string, project string) (string, string, int) {
+	cwd := filepath.Join(root, "tests", project)
+	return transformCoverageCapture(func() int {
+		return runTransform([]string{
+			"--cwd", cwd,
+			"--tsconfig", "tsconfig.json",
+			"--output", "ts",
 		})
-	}
+	})
 }

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

@@ -0,0 +1,120 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestProjectDependenciesBarrelReexportTransform verifies every barrel a type
+// is reached through registers, and no sibling the barrel merely also exports.
+//
+// A barrel re-export is an intermediate whose CONTENTS select which declaration
+// the reference reaches: re-pointing `export { Alpha } from "./alpha"` at
+// another module changes the generated validator. Resolving the alias straight
+// to its terminus reported only the concrete module, so a bundler cache had no
+// edge to invalidate and served a stale validator (samchon/typia#2126). The
+// negative twin pins the other direction — the chain must report the modules it
+// walked, not everything the barrels export.
+//
+//  1. Build a project where `a.ts` validates `Alpha` imported from `barrel.ts`,
+//     which re-exports it from `inner.ts`, which re-exports it from `alpha.ts`;
+//     `barrel.ts` also re-exports an unconsumed `Beta` from `beta.ts`.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert `dependencies["src/a.ts"]` contains both barrels (`barrel.ts`,
+//     `inner.ts`) and the concrete module `alpha.ts`.
+//  4. Assert it does NOT contain `beta.ts`, which no consulted type reaches.
+func TestProjectDependenciesBarrelReexportTransform(t *testing.T) {
+  project := projectDependenciesBarrelReexportProject(t)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--output", "ts",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("project transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  var envelope struct {
+    Dependencies map[string][]string `json:"dependencies"`
+  }
+  if err := json.Unmarshal([]byte(out), &envelope); err != nil {
+    t.Fatalf("decode envelope: %v\n%s", err, out)
+  }
+  entries := envelope.Dependencies["src/a.ts"]
+  found := map[string]bool{}
+  for _, entry := range entries {
+    found[entry] = true
+  }
+  if !found["src/barrel.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain the barrel src/barrel.ts: %v", entries)
+  }
+  if !found["src/inner.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain the chained barrel src/inner.ts: %v", entries)
+  }
+  if !found["src/alpha.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain the concrete module src/alpha.ts: %v", entries)
+  }
+  if found["src/beta.ts"] {
+    t.Fatalf("dependencies of src/a.ts must not contain src/beta.ts, which the barrel exports but no consulted type reaches: %v", entries)
+  }
+}
+
+func projectDependenciesBarrelReexportProject(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, "project-dependencies-barrel-reexport-")
+  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(projectDependenciesEnvelopeTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  for name, body := range map[string]string{
+    "a.ts":      projectDependenciesBarrelReexportSourceA,
+    "barrel.ts": projectDependenciesBarrelReexportSourceBarrel,
+    "inner.ts":  projectDependenciesBarrelReexportSourceInner,
+    "alpha.ts":  projectDependenciesBarrelReexportSourceAlpha,
+    "beta.ts":   projectDependenciesBarrelReexportSourceBeta,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesBarrelReexportSourceA = `import typia from "typia";
+
+import { Alpha } from "./barrel";
+
+export const validateAlpha = (input: unknown) => typia.validate<Alpha>(input);
+`
+
+const projectDependenciesBarrelReexportSourceBarrel = `export { Alpha } from "./inner";
+export { Beta } from "./beta";
+`
+
+const projectDependenciesBarrelReexportSourceInner = `export { Alpha } from "./alpha";
+`
+
+const projectDependenciesBarrelReexportSourceAlpha = `export interface Alpha {
+  id: string;
+}
+`
+
+const projectDependenciesBarrelReexportSourceBeta = `export interface Beta {
+  flag: boolean;
+}
+`

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

@@ -0,0 +1,134 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestProjectDependenciesCollapsedAliasTransform verifies written references
+// register files the checker's type graph collapses, and nothing more.
+//
+// An alias of an intrinsic (`type Inner = number`) is interned by the checker
+// without an alias symbol, so the semantic type-graph touches alone can never
+// see its declaring file — only the WRITTEN reference walk can. The negative
+// twin pins the walk's boundary: a type referenced only inside a method BODY
+// is not part of the consulted type surface and must not register.
+//
+//  1. Build a project where `a.ts` validates `Outer` (`t.ts`, an alias whose
+//     property type is the collapsed alias `Inner` from `u.ts`), the directly
+//     collapsed alias `Direct` from `v.ts`, and a class from `m.ts` whose
+//     method body (and only its body) references a type from `w.ts`.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert `dependencies["src/a.ts"]` contains `t.ts`, `u.ts`, and `v.ts`.
+//  4. Assert it does NOT contain `w.ts` (body-only reference).
+func TestProjectDependenciesCollapsedAliasTransform(t *testing.T) {
+  project := projectDependenciesCollapsedAliasProject(t)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--output", "ts",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("project transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  var envelope struct {
+    Dependencies map[string][]string `json:"dependencies"`
+  }
+  if err := json.Unmarshal([]byte(out), &envelope); err != nil {
+    t.Fatalf("decode envelope: %v\n%s", err, out)
+  }
+  entries := envelope.Dependencies["src/a.ts"]
+  found := map[string]bool{}
+  for _, entry := range entries {
+    found[entry] = true
+  }
+  if !found["src/t.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain the outer alias file src/t.ts: %v", entries)
+  }
+  if !found["src/u.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain the collapsed property alias file src/u.ts: %v", entries)
+  }
+  if !found["src/v.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain the collapsed top-level alias file src/v.ts: %v", entries)
+  }
+  if found["src/w.ts"] {
+    t.Fatalf("dependencies of src/a.ts must not contain the body-only reference file src/w.ts: %v", entries)
+  }
+}
+
+func projectDependenciesCollapsedAliasProject(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, "project-dependencies-collapsed-alias-")
+  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(projectDependenciesEnvelopeTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  for name, body := range map[string]string{
+    "a.ts": projectDependenciesCollapsedAliasSourceA,
+    "t.ts": projectDependenciesCollapsedAliasSourceT,
+    "u.ts": projectDependenciesCollapsedAliasSourceU,
+    "v.ts": projectDependenciesCollapsedAliasSourceV,
+    "m.ts": projectDependenciesCollapsedAliasSourceM,
+    "w.ts": projectDependenciesCollapsedAliasSourceW,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesCollapsedAliasSourceA = `import typia from "typia";
+
+import { WithMethod } from "./m";
+import { Outer } from "./t";
+import { Direct } from "./v";
+
+export const validateOuter = (input: unknown) => typia.validate<Outer>(input);
+export const validateDirect = (input: unknown) => typia.validate<Direct>(input);
+export const validateWithMethod = (input: unknown) => typia.validate<WithMethod>(input);
+`
+
+const projectDependenciesCollapsedAliasSourceT = `import { Inner } from "./u";
+
+export type Outer = { value: Inner };
+`
+
+const projectDependenciesCollapsedAliasSourceU = `export type Inner = number;
+`
+
+const projectDependenciesCollapsedAliasSourceV = `export type Direct = string;
+`
+
+const projectDependenciesCollapsedAliasSourceM = `import { BodyOnly } from "./w";
+
+export class WithMethod {
+  public id!: string;
+
+  public describe(): string {
+    const helper: BodyOnly = { tag: "x" };
+    return helper.tag;
+  }
+}
+`
+
+const projectDependenciesCollapsedAliasSourceW = `export interface BodyOnly {
+  tag: string;
+}
+`

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

@@ -0,0 +1,135 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestProjectDependenciesCustomLibNameTransform verifies a project-owned
+// ambient declaration file named `lib.custom.d.ts` appears in the transform
+// envelope's `dependencies`.
+//
+// Default-library exclusion must come from the compiler's own classification,
+// never from a filename pattern: a basename predicate (`lib.*.d.ts`) silently
+// drops a project's own ambient file with that common naming, so its changes
+// never invalidate consumers and persistent bundler caches serve stale
+// validators (samchon/typia#2108). Compiler-owned default libraries must still
+// stay excluded.
+//
+//  1. Build a project where `a.ts` calls `typia.validate<Bee>()` with `Bee`
+//     declared in `b.ts` consuming the ambient `CustomAmbient` interface
+//     declared in `src/lib.custom.d.ts`, plus a `Date` property so the
+//     analysis touches real default libraries.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert `dependencies["src/a.ts"]` contains `src/lib.custom.d.ts`.
+//  4. Assert no compiler-owned default library (virtual `bundled:///` URI or
+//     any value outside the project) leaks into the entry.
+func TestProjectDependenciesCustomLibNameTransform(t *testing.T) {
+  project := projectDependenciesCustomLibNameProject(t)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--output", "ts",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("project transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  var envelope struct {
+    TypeScript   map[string]string   `json:"typescript"`
+    Dependencies map[string][]string `json:"dependencies"`
+  }
+  if err := json.Unmarshal([]byte(out), &envelope); err != nil {
+    t.Fatalf("decode envelope: %v\n%s", err, out)
+  }
+  entries := envelope.Dependencies["src/a.ts"]
+  if len(entries) == 0 {
+    t.Fatalf("dependencies must contain an entry for src/a.ts:\n%s", out)
+  }
+  found := map[string]bool{}
+  for _, entry := range entries {
+    found[entry] = true
+    if strings.Contains(entry, "://") {
+      t.Fatalf("dependencies must exclude virtual URI sources, got %q in %v", entry, entries)
+    }
+    if filepath.IsAbs(filepath.FromSlash(entry)) || strings.HasPrefix(entry, "../") {
+      t.Fatalf("dependencies must not report files outside the project, got %q in %v", entry, entries)
+    }
+  }
+  if !found["src/lib.custom.d.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain the project-owned src/lib.custom.d.ts: %v", entries)
+  }
+  if !found["src/b.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain the direct declaration file src/b.ts: %v", entries)
+  }
+}
+
+func projectDependenciesCustomLibNameProject(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, "project-dependencies-custom-lib-name-")
+  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(projectDependenciesCustomLibNameTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  for name, body := range map[string]string{
+    "a.ts":            projectDependenciesCustomLibNameSourceA,
+    "b.ts":            projectDependenciesCustomLibNameSourceB,
+    "lib.custom.d.ts": projectDependenciesCustomLibNameSourceLib,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesCustomLibNameTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}
+`
+
+const projectDependenciesCustomLibNameSourceA = `import typia from "typia";
+
+import { Bee } from "./b";
+
+export const validateBee = (input: unknown) => typia.validate<Bee>(input);
+`
+
+const projectDependenciesCustomLibNameSourceB = `export interface Bee {
+  id: string;
+  when: Date;
+  ambient: CustomAmbient;
+}
+`
+
+const projectDependenciesCustomLibNameSourceLib = `declare interface CustomAmbient {
+  tag: string;
+}
+`

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

@@ -0,0 +1,114 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestProjectDependenciesDefaultBarrelTransform verifies a default-export
+// barrel reports the module it forwards to, and never a same-named sibling.
+//
+// A default import binds `default`, not its own local name, so an alias walk
+// that stepped through the local name would look up whatever the barrel happens
+// to export under it — reporting a module the reference never consults and
+// invalidating consumers on edits that cannot reach them. `dependencies` names
+// every file whose edit can change the generated output and ONLY those, so this
+// pins both halves of that invariant on one fixture (samchon/typia#2126).
+//
+//  1. Build a project where `a.ts` validates the default import `Alpha` from
+//     `barrel.ts`, which forwards `default` from `real.ts` while separately
+//     exporting an unrelated NAMED `Alpha` from `unrelated.ts`.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert `dependencies["src/a.ts"]` contains `barrel.ts` and `real.ts`.
+//  4. Assert it does NOT contain `unrelated.ts`, whose only tie to the walk is
+//     sharing the local name of the default import.
+func TestProjectDependenciesDefaultBarrelTransform(t *testing.T) {
+  project := projectDependenciesDefaultBarrelProject(t)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--output", "ts",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("project transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  var envelope struct {
+    Dependencies map[string][]string `json:"dependencies"`
+  }
+  if err := json.Unmarshal([]byte(out), &envelope); err != nil {
+    t.Fatalf("decode envelope: %v\n%s", err, out)
+  }
+  entries := envelope.Dependencies["src/a.ts"]
+  found := map[string]bool{}
+  for _, entry := range entries {
+    found[entry] = true
+  }
+  if !found["src/barrel.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain the default barrel src/barrel.ts: %v", entries)
+  }
+  if !found["src/real.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain the forwarded module src/real.ts: %v", entries)
+  }
+  if found["src/unrelated.ts"] {
+    t.Fatalf("dependencies of src/a.ts must not contain src/unrelated.ts: the default import never consults the barrel's same-named export: %v", entries)
+  }
+}
+
+func projectDependenciesDefaultBarrelProject(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, "project-dependencies-default-barrel-")
+  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(projectDependenciesEnvelopeTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  for name, body := range map[string]string{
+    "a.ts":         projectDependenciesDefaultBarrelSourceA,
+    "barrel.ts":    projectDependenciesDefaultBarrelSourceBarrel,
+    "real.ts":      projectDependenciesDefaultBarrelSourceReal,
+    "unrelated.ts": projectDependenciesDefaultBarrelSourceUnrelated,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesDefaultBarrelSourceA = `import typia from "typia";
+
+import Alpha from "./barrel";
+
+export const validateAlpha = (input: unknown) => typia.validate<Alpha>(input);
+`
+
+const projectDependenciesDefaultBarrelSourceBarrel = `export { default } from "./real";
+export { Alpha } from "./unrelated";
+`
+
+const projectDependenciesDefaultBarrelSourceReal = `interface Real {
+  id: string;
+}
+
+export default Real;
+`
+
+const projectDependenciesDefaultBarrelSourceUnrelated = `export interface Alpha {
+  nope: boolean;
+}
+`