typia 13.3.0 → 14.0.1

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

@@ -0,0 +1,218 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestProjectDependenciesComputedKeyTransform verifies a computed member key
+// reports the file that decides the name, and withholds the declaration when
+// that name is borrowed from a file the written surface cannot enumerate.
+//
+// `interface Doc { [Kind.A]: number }` emits `input.alpha`, so the enum
+// member's value is read into the validator exactly the way an `enum` member's
+// own value is — and the checker interns the resolved key as a bare string
+// literal with no symbol to follow, so neither the declaration's written type
+// nor the type graph names `kind.ts`. Renaming `Kind.A` changed the generated
+// validator with no reported edge, which is invisible while a file keeps the
+// reference closure and serves a stale validator once it is declared complete
+// (samchon/typia#2126, samchon/typia#2357).
+//
+//  1. Build a project where `a.ts` validates `Doc`, whose only key is
+//     `[Kind.A]` reached through a barrel, and where `b.ts` validates `Spare`,
+//     whose key is a constant that borrows its value from a third file.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert `dependencies["src/a.ts"]` contains `src/kind.ts` and the
+//     `src/barrel.ts` the reference traveled, and that `a.ts` is declared
+//     complete so the narrowed bound is the one that carries them.
+//  4. Assert it omits `src/unused.ts`, a sibling export the reference never
+//     traverses.
+//  5. Assert `b.ts` is withheld: `const BORROWED = VALUE` takes its value from
+//     a file no written key names, which is the same answer an enum member
+//     borrowing a value gets.
+//  6. Assert `c.ts` stays declared: `["gamma"]` is written where it is used, so
+//     treating every computed key as unbounded would cost narrowing for a name
+//     no other file can decide.
+//  7. Assert `d.ts` stays declared AND reports `src/keyconst.ts`: a bare name
+//     whose constant fixes its own value is the bounded twin of `b.ts`, and it
+//     is the only case that pins both halves of the bare-name branch.
+func TestProjectDependenciesComputedKeyTransform(t *testing.T) {
+  project := projectDependenciesComputedKeyProject(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/kind.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain src/kind.ts, whose enum member decides the emitted key: %v", entries)
+  }
+  if !found["src/barrel.ts"] {
+    t.Fatalf("dependencies of src/a.ts must contain src/barrel.ts, which selects the enum the key reads: %v", entries)
+  }
+  if found["src/unused.ts"] {
+    t.Fatalf("dependencies of src/a.ts must not contain src/unused.ts, a sibling the reference never traverses: %v", entries)
+  }
+  declared := map[string]bool{}
+  for _, key := range envelope.DependenciesComplete {
+    declared[key] = true
+  }
+  if !declared["src/a.ts"] {
+    t.Fatalf("src/a.ts must be declared complete, so the reported entry is the whole bound: %v", envelope.DependenciesComplete)
+  }
+  if declared["src/b.ts"] {
+    t.Fatalf("a key whose constant borrows its value from another file is not bounded by any written name, so src/b.ts must be withheld: %v", envelope.DependenciesComplete)
+  }
+  if !declared["src/c.ts"] {
+    t.Fatalf("a computed key written as a literal names no other file and must stay declared: %v", envelope.DependenciesComplete)
+  }
+  if !declared["src/d.ts"] {
+    t.Fatalf("a key whose constant fixes its own value is bounded and must stay declared: %v", envelope.DependenciesComplete)
+  }
+  bare := map[string]bool{}
+  for _, entry := range envelope.Dependencies["src/d.ts"] {
+    bare[entry] = true
+  }
+  if !bare["src/keyconst.ts"] {
+    t.Fatalf("dependencies of src/d.ts must contain src/keyconst.ts, whose constant decides the emitted key: %v", envelope.Dependencies["src/d.ts"])
+  }
+}
+
+func projectDependenciesComputedKeyProject(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-computed-key-")
+  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":        projectDependenciesComputedKeySourceA,
+    "b.ts":        projectDependenciesComputedKeySourceB,
+    "c.ts":        projectDependenciesComputedKeySourceC,
+    "d.ts":        projectDependenciesComputedKeySourceD,
+    "doc.ts":      projectDependenciesComputedKeySourceDoc,
+    "spare.ts":    projectDependenciesComputedKeySourceSpare,
+    "plain.ts":    projectDependenciesComputedKeySourcePlain,
+    "bare.ts":     projectDependenciesComputedKeySourceBare,
+    "keyconst.ts": projectDependenciesComputedKeySourceKeyConst,
+    "barrel.ts":   projectDependenciesComputedKeySourceBarrel,
+    "kind.ts":     projectDependenciesComputedKeySourceKind,
+    "unused.ts":   projectDependenciesComputedKeySourceUnused,
+    "borrow.ts":   projectDependenciesComputedKeySourceBorrow,
+    "value.ts":    projectDependenciesComputedKeySourceValue,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesComputedKeySourceA = `import typia from "typia";
+
+import { Doc } from "./doc";
+
+export const check = (input: unknown) => typia.is<Doc>(input);
+`
+
+const projectDependenciesComputedKeySourceB = `import typia from "typia";
+
+import { Spare } from "./spare";
+
+export const check = (input: unknown) => typia.is<Spare>(input);
+`
+
+const projectDependenciesComputedKeySourceC = `import typia from "typia";
+
+import { Plain } from "./plain";
+
+export const check = (input: unknown) => typia.is<Plain>(input);
+`
+
+const projectDependenciesComputedKeySourcePlain = `export interface Plain {
+  ["gamma"]: number;
+}
+`
+
+const projectDependenciesComputedKeySourceD = `import typia from "typia";
+
+import { Bare } from "./bare";
+
+export const check = (input: unknown) => typia.is<Bare>(input);
+`
+
+const projectDependenciesComputedKeySourceBare = `import { KEY } from "./keyconst";
+
+export interface Bare {
+  [KEY]: number;
+}
+`
+
+const projectDependenciesComputedKeySourceKeyConst = `export const KEY = "epsilon";
+`
+
+const projectDependenciesComputedKeySourceDoc = `import { Kind } from "./barrel";
+
+export interface Doc {
+  [Kind.A]: number;
+}
+`
+
+const projectDependenciesComputedKeySourceSpare = `import { BORROWED } from "./borrow";
+
+export interface Spare {
+  [BORROWED]: number;
+}
+`
+
+const projectDependenciesComputedKeySourceBarrel = `export { Kind } from "./kind";
+export { Unused } from "./unused";
+`
+
+const projectDependenciesComputedKeySourceKind = `export enum Kind {
+  A = "alpha",
+}
+`
+
+const projectDependenciesComputedKeySourceUnused = `export enum Unused {
+  B = "beta",
+}
+`
+
+const projectDependenciesComputedKeySourceBorrow = `import { VALUE } from "./value";
+
+export const BORROWED = VALUE;
+`
+
+const projectDependenciesComputedKeySourceValue = `export const VALUE = "delta";
+`

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

@@ -25,8 +25,12 @@ import (
 //     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.
+//  4. Assert no compiler-owned default library leaks into the entry. Under this
+//     fixture they are the program's virtual `bundled:///` sources, so the URI
+//     shape is what proves the classification still excludes them. Being outside
+//     the project is not evidence of one: the envelope reports a `node_modules`
+//     declaration file like any other, and the files that decide a callee's
+//     typia identity are exactly such files.
 func TestProjectDependenciesCustomLibNameTransform(t *testing.T) {
   project := projectDependenciesCustomLibNameProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -56,9 +60,6 @@ func TestProjectDependenciesCustomLibNameTransform(t *testing.T) {
     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)

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

@@ -0,0 +1,131 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestProjectDependenciesEnumMemberValueTransform verifies an enum whose member
+// borrows its value from another file withholds the completeness declaration,
+// while an enum that writes its own values keeps it.
+//
+// An enum member's value is read straight into the generated validator, so
+// `Kind.A === input` becomes `"x" === input` and changes the moment the value
+// changes. When the member writes a literal — including the negative form, which
+// TypeScript reads as one constant — that value is written here and no other
+// file can decide it. When it borrows one (`A = Other.X`), the value lives
+// somewhere the type graph never names: the checker hands the analysis the
+// resolved literal, not the reference that produced it (samchon/typia#2357).
+//
+//  1. Build a project with `plain.ts`, whose enum writes a string and a negative
+//     number, and `kind.ts`, whose enum takes a member value from `other.ts`.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert both callers transformed into a literal comparison, so both enums
+//     really did reach the validator.
+//  4. Assert the caller of the self-contained enum is declared complete and the
+//     caller of the borrowing enum is not.
+func TestProjectDependenciesEnumMemberValueTransform(t *testing.T) {
+  project := projectDependenciesEnumMemberValueProject(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/own.ts"]; !strings.Contains(text, `"a" === input`) || !strings.Contains(text, "-1 === input") {
+    t.Fatalf("src/own.ts must compare against both written member values, got:\n%s", text)
+  }
+  if text := envelope.TypeScript["src/borrowed.ts"]; !strings.Contains(text, `"x" === input`) {
+    t.Fatalf("src/borrowed.ts must compare against the borrowed member value, got:\n%s", text)
+  }
+  declared := map[string]bool{}
+  for _, key := range envelope.DependenciesComplete {
+    declared[key] = true
+  }
+  if !declared["src/own.ts"] {
+    t.Fatalf("an enum that writes its own member values bounds them and must be declared complete: %v", envelope.DependenciesComplete)
+  }
+  if declared["src/borrowed.ts"] {
+    t.Fatalf("an enum member that borrows its value must withhold the declaration: %v", envelope.DependenciesComplete)
+  }
+}
+
+func projectDependenciesEnumMemberValueProject(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-enum-member-value-")
+  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{
+    "own.ts":      projectDependenciesEnumMemberValueSourceOwn,
+    "borrowed.ts": projectDependenciesEnumMemberValueSourceBorrowed,
+    "plain.ts":    projectDependenciesEnumMemberValueSourcePlain,
+    "kind.ts":     projectDependenciesEnumMemberValueSourceKind,
+    "other.ts":    projectDependenciesEnumMemberValueSourceOther,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesEnumMemberValueSourceOwn = `import typia from "typia";
+
+import { Plain } from "./plain";
+
+export const check = (input: unknown) => typia.is<Plain>(input);
+`
+
+const projectDependenciesEnumMemberValueSourceBorrowed = `import typia from "typia";
+
+import { Kind } from "./kind";
+
+export const check = (input: unknown) => typia.is<Kind>(input);
+`
+
+const projectDependenciesEnumMemberValueSourcePlain = `export enum Plain {
+  Text = "a",
+  Negative = -1,
+}
+`
+
+const projectDependenciesEnumMemberValueSourceKind = `import { Other } from "./other";
+
+export enum Kind {
+  Borrowed = Other.Value,
+}
+`
+
+const projectDependenciesEnumMemberValueSourceOther = `export enum Other {
+  Value = "x",
+}
+`

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;
+`