typia 14.0.0 → 14.0.2

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

@@ -0,0 +1,159 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestProjectDependenciesInferredDeclarationTransform verifies a validated type
+// that reaches a declaration with no written annotation withholds the
+// completeness declaration, while its annotated twin keeps it.
+//
+// The written surface exists because the checker erases an alias of an
+// intrinsic: `type Id = string` interns as the bare intrinsic and leaves no
+// symbol for the type graph to follow, so only the syntax naming the alias can
+// register its file (samchon/typia#2126). A `const` with an annotation has that
+// syntax. A `const` typed by its initializer alone does not, and recovering it
+// means following type inference over arbitrary expressions -- a call's return
+// type, an overload's selection, a contextually typed parameter -- which is
+// exactly the unbounded problem a typia call with no written type argument has.
+// Both get the same answer rather than a partial walk that would leave the file
+// declared on an incomplete list (samchon/typia#2357).
+//
+//  1. Build a project where `cfg.ts` exports one annotated constant, one
+//     inferred constant of the same shape, and one destructured binding, and
+//     three callers validate `typeof` each.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert every caller transformed, so the set differs only in where the
+//     type was written.
+//  4. Assert the annotated caller is declared complete and names the
+//     annotation's own file, and that the inferred caller is withheld while
+//     keeping what it did report.
+//  5. Assert the destructured caller is withheld too. A binding element is a
+//     declaration kind the predicate names nowhere, so it answers through the
+//     default -- which is what pins that the default is "withhold".
+func TestProjectDependenciesInferredDeclarationTransform(t *testing.T) {
+  project := projectDependenciesInferredDeclarationProject(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"`
+    DependenciesComplete []string            `json:"dependenciesComplete"`
+  }
+  if err := json.Unmarshal([]byte(out), &envelope); err != nil {
+    t.Fatalf("decode envelope: %v\n%s", err, out)
+  }
+  for _, key := range []string{"src/annotated.ts", "src/inferred.ts", "src/destructured.ts"} {
+    if text := envelope.TypeScript[key]; !strings.Contains(text, "typeof input") {
+      t.Fatalf("%s must have been transformed into a generated validator, got:\n%s", key, text)
+    }
+  }
+  declared := map[string]bool{}
+  for _, key := range envelope.DependenciesComplete {
+    declared[key] = true
+  }
+  if !declared["src/annotated.ts"] {
+    t.Fatalf("a validated type written as an annotation bounds its inputs and must be declared complete: %v", envelope.DependenciesComplete)
+  }
+  found := map[string]bool{}
+  for _, entry := range envelope.Dependencies["src/annotated.ts"] {
+    found[entry] = true
+  }
+  if !found["src/shape.ts"] {
+    t.Fatalf("the annotated constant's own annotation file must be reported: %v", envelope.Dependencies["src/annotated.ts"])
+  }
+  if declared["src/inferred.ts"] {
+    t.Fatalf("a validated type that reaches a declaration typed by its initializer alone must be withheld: %v", envelope.DependenciesComplete)
+  }
+  if len(envelope.Dependencies["src/inferred.ts"]) == 0 {
+    t.Fatalf("withholding the declaration must not strip what src/inferred.ts did report: %v", envelope.Dependencies)
+  }
+  if declared["src/destructured.ts"] {
+    t.Fatalf("a declaration kind the predicate names nowhere must answer through the default and withhold: %v", envelope.DependenciesComplete)
+  }
+}
+
+func projectDependenciesInferredDeclarationProject(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-inferred-declaration-")
+  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{
+    "annotated.ts":    projectDependenciesInferredDeclarationSourceAnnotated,
+    "inferred.ts":     projectDependenciesInferredDeclarationSourceInferred,
+    "destructured.ts": projectDependenciesInferredDeclarationSourceDestructured,
+    "cfg.ts":          projectDependenciesInferredDeclarationSourceCfg,
+    "shape.ts":        projectDependenciesInferredDeclarationSourceShape,
+    "id.ts":           projectDependenciesInferredDeclarationSourceId,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesInferredDeclarationSourceAnnotated = `import typia from "typia";
+
+import { written } from "./cfg";
+
+export const check = (input: unknown) => typia.is<typeof written>(input);
+`
+
+const projectDependenciesInferredDeclarationSourceInferred = `import typia from "typia";
+
+import { guessed } from "./cfg";
+
+export const check = (input: unknown) => typia.is<typeof guessed>(input);
+`
+
+const projectDependenciesInferredDeclarationSourceDestructured = `import typia from "typia";
+
+import { picked } from "./cfg";
+
+export const check = (input: unknown) => typia.is<typeof picked>(input);
+`
+
+const projectDependenciesInferredDeclarationSourceCfg = `import { Id } from "./id";
+import { Shape } from "./shape";
+
+export const written: Shape = { id: "w" };
+
+export const guessed = { id: "g" as Id };
+
+export const { id: picked } = written;
+`
+
+const projectDependenciesInferredDeclarationSourceShape = `export interface Shape {
+  id: string;
+}
+`
+
+const projectDependenciesInferredDeclarationSourceId = `export type Id = string;
+`

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

@@ -0,0 +1,134 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestProjectDependenciesJsDocTypedefTransform verifies an `allowJs` project
+// whose type is written as a JSDoc typedef reports the file behind a
+// `@property` tag and still declares the consumer complete.
+//
+// A JSDoc typedef reaches the walk as a `JSTypeAliasDeclaration`, so its whole
+// node is surfaced and every reference written inside it -- including the
+// `import("./id").Id` a `@property` tag names -- resolves from there. The tags
+// themselves never arrive at the boundedness predicate, so this is what pins
+// that they do not need to: were a property enumeration to start handing tags
+// over, the default would withhold and this file would stop being declared
+// (samchon/typia#2357).
+//
+//  1. Build an `allowJs` project where `main.ts` validates a typedef declared
+//     in `doc.js`, whose `@property` tag names a typedef in `id.js`.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert `dependencies["src/main.ts"]` carries both `src/doc.js` and
+//     `src/id.js`.
+//  4. Assert `src/main.ts` is declared complete, so the narrowed bound is the
+//     one carrying them.
+func TestProjectDependenciesJsDocTypedefTransform(t *testing.T) {
+  project := projectDependenciesJsDocTypedefProject(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"`
+    DependenciesComplete []string            `json:"dependenciesComplete"`
+  }
+  if err := json.Unmarshal([]byte(out), &envelope); err != nil {
+    t.Fatalf("decode envelope: %v\n%s", err, out)
+  }
+  entries := envelope.Dependencies["src/main.ts"]
+  found := map[string]bool{}
+  for _, entry := range entries {
+    found[entry] = true
+  }
+  if !found["src/doc.js"] {
+    t.Fatalf("dependencies of src/main.ts must contain the typedef's own file src/doc.js: %v", entries)
+  }
+  if !found["src/id.js"] {
+    t.Fatalf("dependencies of src/main.ts must contain src/id.js, which a @property tag names: %v", entries)
+  }
+  declared := false
+  for _, key := range envelope.DependenciesComplete {
+    if key == "src/main.ts" {
+      declared = true
+    }
+  }
+  if !declared {
+    t.Fatalf("src/main.ts must be declared complete, so the reported entry is the whole bound: %v", envelope.DependenciesComplete)
+  }
+}
+
+func projectDependenciesJsDocTypedefProject(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-jsdoc-typedef-")
+  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(projectDependenciesJsDocTypedefTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  for name, body := range map[string]string{
+    "main.ts": projectDependenciesJsDocTypedefSourceMain,
+    "doc.js":  projectDependenciesJsDocTypedefSourceDoc,
+    "id.js":   projectDependenciesJsDocTypedefSourceId,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesJsDocTypedefTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "allowJs": true,
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}
+`
+
+const projectDependenciesJsDocTypedefSourceMain = `import typia from "typia";
+
+export const check = (input: unknown) => typia.is<import("./doc").Doc>(input);
+`
+
+const projectDependenciesJsDocTypedefSourceDoc = `/**
+ * @typedef {Object} Doc
+ * @property {import("./id").Id} id
+ */
+
+export const marker = 1;
+`
+
+const projectDependenciesJsDocTypedefSourceId = `/** @typedef {string} Id */
+
+export const marker = 1;
+`

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

@@ -0,0 +1,123 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestProjectDependenciesNamedTupleMemberTransform verifies a named tuple
+// member's written type reaches the reported dependencies, and that the file
+// consulting it is still declared complete.
+//
+// `[id: Id]` writes its type as plainly as a property annotation does, and the
+// checker interns `type Id = string` as the bare intrinsic, so the written
+// surface is the only thing that can register `id.ts` (samchon/typia#2126). The
+// member is a declaration kind of its own, so it needs its own place in both the
+// surface that walks a written type and the predicate that decides whether a
+// file may be declared on the strength of one — a kind in the second without the
+// first is exactly an over-declaration (samchon/typia#2357).
+//
+//  1. Build a project where `a.ts` validates a tuple alias whose first member is
+//     named and typed `Id`, beside an alias the tuple never uses.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert `dependencies["src/a.ts"]` contains `src/id.ts` and that `a.ts` is
+//     declared complete, so the narrowed bound is the one carrying it.
+//  4. Assert it omits `src/unused.ts`, which no consulted member names.
+func TestProjectDependenciesNamedTupleMemberTransform(t *testing.T) {
+  project := projectDependenciesNamedTupleMemberProject(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"`
+    DependenciesComplete []string            `json:"dependenciesComplete"`
+  }
+  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/pair.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain the declaring file src/pair.ts: %v", entries)
+  }
+  if !found["src/id.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain src/id.ts, which the named tuple member's type names: %v", entries)
+  }
+  if found["src/unused.ts"] {
+    t.Fatalf("dependencies of src/a.ts must not contain src/unused.ts, which no consulted member names: %v", entries)
+  }
+  declared := false
+  for _, key := range envelope.DependenciesComplete {
+    if key == "src/a.ts" {
+      declared = true
+    }
+  }
+  if !declared {
+    t.Fatalf("src/a.ts must be declared complete, so the reported entry is the whole bound: %v", envelope.DependenciesComplete)
+  }
+}
+
+func projectDependenciesNamedTupleMemberProject(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-named-tuple-member-")
+  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":      projectDependenciesNamedTupleMemberSourceA,
+    "pair.ts":   projectDependenciesNamedTupleMemberSourcePair,
+    "id.ts":     projectDependenciesNamedTupleMemberSourceId,
+    "unused.ts": projectDependenciesNamedTupleMemberSourceUnused,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesNamedTupleMemberSourceA = `import typia from "typia";
+
+import { Pair } from "./pair";
+
+export const check = (input: unknown) => typia.is<Pair>(input);
+`
+
+const projectDependenciesNamedTupleMemberSourcePair = `import { Id } from "./id";
+import { Unused } from "./unused";
+
+export type Pair = [id: Id, count: number];
+
+export type Spare = [label: Unused];
+`
+
+const projectDependenciesNamedTupleMemberSourceId = `export type Id = string;
+`
+
+const projectDependenciesNamedTupleMemberSourceUnused = `export type Unused = string;
+`

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

@@ -0,0 +1,141 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestProjectDependenciesQualifiedBarrelTransform verifies a QUALIFIED type
+// reference reports the barrel that selected its namespace half, not only the
+// module declaring its terminus.
+//
+// `TestProjectDependenciesBarrelReexportTransform` pins the bare spelling, and
+// it works because the checker answers `Alpha` with the local import alias, whose
+// path metadataDependency_touchPath walks. `Kind.A` is answered with the enum
+// member instead -- not an alias, no path to walk -- so the barrel between the
+// caller and the enum went unreported while its value went straight into the
+// validator as `"alpha" === input.kind`. Re-pointing that barrel at another enum
+// changed the emitted constant with nothing left to invalidate the file
+// (samchon/typia#2126, samchon/typia#2357).
+//
+//  1. Build a project where `main.ts` validates `Doc`, whose member type is
+//     `Kind.A` for a `Kind` imported from `barrel.ts`, which re-exports it from
+//     `kind.ts` and also re-exports an unconsumed `Unused` from `unused.ts`.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert the emitted validator compares against the enum member's value, so
+//     the fixture really does read `kind.ts` into its output.
+//  4. Assert `dependencies["src/main.ts"]` contains `src/barrel.ts` and
+//     `src/kind.ts`, and that `src/main.ts` is declared complete.
+//  5. Assert it omits `src/unused.ts`, the sibling the reference never traverses.
+func TestProjectDependenciesQualifiedBarrelTransform(t *testing.T) {
+  project := projectDependenciesQualifiedBarrelProject(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"`
+    DependenciesComplete []string            `json:"dependenciesComplete"`
+  }
+  if err := json.Unmarshal([]byte(out), &envelope); err != nil {
+    t.Fatalf("decode envelope: %v\n%s", err, out)
+  }
+  if text := envelope.TypeScript["src/main.ts"]; !strings.Contains(text, `"alpha"`) {
+    t.Fatalf("the validator must compare against the enum member's value, so the fixture reads kind.ts into its output, got:\n%s", text)
+  }
+  entries := envelope.Dependencies["src/main.ts"]
+  found := map[string]bool{}
+  for _, entry := range entries {
+    found[entry] = true
+  }
+  if !found["src/kind.ts"] {
+    t.Fatalf("dependencies of src/main.ts must contain src/kind.ts, which declares the member the type names: %v", entries)
+  }
+  if !found["src/barrel.ts"] {
+    t.Fatalf("dependencies of src/main.ts must contain src/barrel.ts, which selects the enum the qualified name reads: %v", entries)
+  }
+  if found["src/unused.ts"] {
+    t.Fatalf("dependencies of src/main.ts must not contain src/unused.ts, a sibling the reference never traverses: %v", entries)
+  }
+  declared := false
+  for _, key := range envelope.DependenciesComplete {
+    if key == "src/main.ts" {
+      declared = true
+    }
+  }
+  if !declared {
+    t.Fatalf("src/main.ts must be declared complete, so the reported entry is the whole bound: %v", envelope.DependenciesComplete)
+  }
+}
+
+func projectDependenciesQualifiedBarrelProject(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-qualified-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{
+    "main.ts":   projectDependenciesQualifiedBarrelSourceMain,
+    "doc.ts":    projectDependenciesQualifiedBarrelSourceDoc,
+    "barrel.ts": projectDependenciesQualifiedBarrelSourceBarrel,
+    "kind.ts":   projectDependenciesQualifiedBarrelSourceKind,
+    "unused.ts": projectDependenciesQualifiedBarrelSourceUnused,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesQualifiedBarrelSourceMain = `import typia from "typia";
+
+import { Doc } from "./doc";
+
+export const check = (input: unknown) => typia.is<Doc>(input);
+`
+
+const projectDependenciesQualifiedBarrelSourceDoc = `import { Kind } from "./barrel";
+
+export interface Doc {
+  kind: Kind.A;
+}
+`
+
+const projectDependenciesQualifiedBarrelSourceBarrel = `export { Kind } from "./kind";
+export { Unused } from "./unused";
+`
+
+const projectDependenciesQualifiedBarrelSourceKind = `export enum Kind {
+  A = "alpha",
+  B = "beta",
+}
+`
+
+const projectDependenciesQualifiedBarrelSourceUnused = `export enum Unused {
+  C = "gamma",
+}
+`

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

@@ -0,0 +1,127 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestProjectDependenciesTypeParameterDefaultTransform verifies an interface's
+// type-parameter default reports the file its alias comes from.
+//
+// `typia.is<Wrapper>()` over `interface Wrapper<T = Id>` validates whatever `Id`
+// is, and the checker interns `type Id = string` as the bare intrinsic, so the
+// resolved type carries no symbol the type graph can follow to `id.ts`
+// (samchon/typia#2126). The equivalent `type AliasWrapper<T = Id> = { v: T }`
+// always reported it, because a `type` alias surfaces its whole node; an
+// interface surfaced only its index signatures, one declaration kind away from
+// the same defect (samchon/typia#2357).
+//
+//  1. Build a project where `a.ts` validates `Wrapper` from `wrapper.ts`, whose
+//     type parameter defaults to `Id` from `id.ts`, and where the same file
+//     declares a second interface defaulting to `Unused` from `unused.ts`.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert `dependencies["src/a.ts"]` contains `src/id.ts`, and that `a.ts`
+//     is declared complete so the narrowed bound is the one that carries it.
+//  4. Assert it omits `src/unused.ts`, whose interface the call never reaches.
+func TestProjectDependenciesTypeParameterDefaultTransform(t *testing.T) {
+  project := projectDependenciesTypeParameterDefaultProject(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"`
+    DependenciesComplete []string            `json:"dependenciesComplete"`
+  }
+  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/wrapper.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain the declaring file src/wrapper.ts: %v", entries)
+  }
+  if !found["src/id.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain src/id.ts, which the type-parameter default names: %v", entries)
+  }
+  if found["src/unused.ts"] {
+    t.Fatalf("dependencies of src/a.ts must not contain src/unused.ts, which no consulted type reaches: %v", entries)
+  }
+  declared := false
+  for _, key := range envelope.DependenciesComplete {
+    if key == "src/a.ts" {
+      declared = true
+    }
+  }
+  if !declared {
+    t.Fatalf("src/a.ts must be declared complete, so the reported entry is the whole bound: %v", envelope.DependenciesComplete)
+  }
+}
+
+func projectDependenciesTypeParameterDefaultProject(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-type-parameter-default-")
+  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":       projectDependenciesTypeParameterDefaultSourceA,
+    "wrapper.ts": projectDependenciesTypeParameterDefaultSourceWrapper,
+    "id.ts":      projectDependenciesTypeParameterDefaultSourceId,
+    "unused.ts":  projectDependenciesTypeParameterDefaultSourceUnused,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesTypeParameterDefaultSourceA = `import typia from "typia";
+
+import { Wrapper } from "./wrapper";
+
+export const check = (input: unknown) => typia.is<Wrapper>(input);
+`
+
+const projectDependenciesTypeParameterDefaultSourceWrapper = `import { Id } from "./id";
+import { Unused } from "./unused";
+
+export interface Wrapper<T = Id> {
+  value: T;
+}
+
+export interface Spare<T = Unused> {
+  value: T;
+}
+`
+
+const projectDependenciesTypeParameterDefaultSourceId = `export type Id = string;
+`
+
+const projectDependenciesTypeParameterDefaultSourceUnused = `export type Unused = number;
+`