typia 13.3.0 → 14.0.1

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

@@ -0,0 +1,115 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestProjectDependenciesCalleeBarrelTransform verifies the modules an import
+// chain traverses to reach a typia callee are reported for the file that calls
+// it.
+//
+// typia decides its own call sites by the file that declares the resolved
+// signature, so a barrel between the caller and typia chooses whether the call
+// is rewritten at all: re-pointing `export { is } from "typia"` at a local
+// helper turns a generated validator back into a plain call. The consulted-type
+// touches cannot see that -- they report what the validated type is, never what
+// selected the callee -- so without this the barrel is nowhere in the reported
+// list, and a consumer that narrows to that list serves the stale validator
+// (samchon/typia#2357).
+//
+//  1. Build a project where `consumer.ts` calls `is<Alpha>` imported from
+//     `barrel.ts`, which re-exports it from `typia`.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert the call was rewritten, so the barrel really did select typia.
+//  4. Assert `dependencies["src/consumer.ts"]` contains `src/barrel.ts`, and
+//     not `src/unused.ts`, which the barrel also re-exports but this reference
+//     never traverses.
+func TestProjectDependenciesCalleeBarrelTransform(t *testing.T) {
+  project := projectDependenciesCalleeBarrelProject(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)
+  }
+  if text := envelope.TypeScript["src/consumer.ts"]; !strings.Contains(text, "input is") {
+    t.Fatalf("the re-exported callee must still be recognized as typia's, got:\n%s", text)
+  }
+  entries := envelope.Dependencies["src/consumer.ts"]
+  found := map[string]bool{}
+  for _, entry := range entries {
+    found[entry] = true
+  }
+  if !found["src/barrel.ts"] {
+    t.Fatalf("dependencies of src/consumer.ts must contain the barrel src/barrel.ts that selects the typia callee: %v", entries)
+  }
+  if found["src/unused.ts"] {
+    t.Fatalf("dependencies of src/consumer.ts must not contain src/unused.ts, which the barrel re-exports but this reference never traverses: %v", entries)
+  }
+}
+
+func projectDependenciesCalleeBarrelProject(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-callee-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{
+    "consumer.ts": projectDependenciesCalleeBarrelSourceConsumer,
+    "barrel.ts":   projectDependenciesCalleeBarrelSourceBarrel,
+    "alpha.ts":    projectDependenciesCalleeBarrelSourceAlpha,
+    "unused.ts":   projectDependenciesCalleeBarrelSourceUnused,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesCalleeBarrelSourceConsumer = `import { is } from "./barrel";
+
+import { Alpha } from "./alpha";
+
+export const checkAlpha = (input: unknown) => is<Alpha>(input);
+`
+
+const projectDependenciesCalleeBarrelSourceBarrel = `export { is } from "typia";
+export { unused } from "./unused";
+`
+
+const projectDependenciesCalleeBarrelSourceAlpha = `export interface Alpha {
+  id: string;
+}
+`
+
+const projectDependenciesCalleeBarrelSourceUnused = `export const unused = (): number => 1;
+`

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

@@ -0,0 +1,285 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestProjectDependenciesCalleeInferenceTransform verifies a nested call whose
+// identity comes from an inferred return type or a borrowed constant withholds
+// its file, while the same indirection written with a type keeps it.
+//
+// The callee walk reports which files a callee's name resolves through, and for
+// the OUTERMOST callee that is the whole answer: the identity is the resolved
+// declaration, whose file is reported. One call in it stops being the answer,
+// because there the identity is the inner call's return type. `const getNs = ()
+// => ns` and `const FLAG = RAW` both carry it from a file no name on the chain
+// writes, so reporting the names without admitting that declared the caller
+// complete while an edit to the unreported file deleted the generated validator
+// outright (samchon/typia#2360).
+//
+// A function DECLARATION with an inferred return type is the same defect one
+// keyword apart, and it needs its own case: the shared boundedness predicate
+// calls every callable bounded, because the type walk emits one as `typeof x
+// === "function"` and never reads its signature. On this channel the signature
+// is the whole question.
+//
+// The bounded twins are what keep the fix from degenerating into "withhold on
+// every nested call": an indirection with a written return type pins its
+// identity in the file that declares it, and that file must stay declared.
+//
+// The third shape samchon/typia#2360 reports -- an overload selected by a
+// borrowed VALUE -- is NOT pinned here, and the fixture keeps it as the record
+// of that. `const FLAG = RAW` is structurally identical to `const ns = typia`,
+// whose caller must stay declared (samchon/typia#2357), so no boundedness
+// answer separates them; reporting the initializer chain would.
+//
+//  1. Build a project with three unbounded shapes -- a computed argument, a
+//     computed callee, and a function declaration with an inferred return type
+//     -- plus a written-type twin for the `const` and the `function` spellings,
+//     and the borrowed-value overload that stays declared.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert each file really was rewritten into a validator, so the test is
+//     measuring the shape it intends rather than a call typia never touched.
+//  4. Assert the three unbounded files are absent from `dependenciesComplete`.
+//  5. Assert both annotated twins are present, and that a file whose OUTERMOST
+//     callee resolves to a local `const helper = () => ...` keeps its
+//     declaration -- that name decides nothing, and charging it costs 65 more
+//     files across the test workspaces than the fix needs.
+func TestProjectDependenciesCalleeInferenceTransform(t *testing.T) {
+  project := projectDependenciesCalleeInferenceProject(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)
+  }
+
+  // Guard first: an assertion about dependencies means nothing on a file the
+  // transform never rewrote, and that is exactly how this class hides.
+  for _, file := range []string{
+    "src/main_computed_arg.ts",
+    "src/main_computed_callee.ts",
+    "src/main_overload.ts",
+    "src/main_annotated.ts",
+    "src/main_function.ts",
+    "src/main_function_annotated.ts",
+    "src/main_outermost.ts",
+  } {
+    if text := envelope.TypeScript[file]; !strings.Contains(text, "input is Foo") {
+      t.Fatalf("%s must have been rewritten into a validator, got:\n%s", file, text)
+    }
+  }
+
+  declared := map[string]bool{}
+  for _, key := range envelope.DependenciesComplete {
+    declared[key] = true
+  }
+  for _, file := range []string{
+    "src/main_computed_arg.ts",
+    "src/main_computed_callee.ts",
+    "src/main_function.ts",
+  } {
+    if declared[file] {
+      t.Fatalf(
+        "%s must be withheld: its callee identity comes from an inferred "+
+          "return type or a borrowed constant, and %v does not name the file "+
+          "that decides it",
+        file,
+        envelope.Dependencies[file],
+      )
+    }
+  }
+  for _, file := range []string{
+    "src/main_annotated.ts",
+    "src/main_function_annotated.ts",
+  } {
+    if declared[file] {
+      continue
+    }
+    t.Fatalf(
+      "%s must stay declared: its indirection carries a written return type, "+
+        "so the reported files do pin the identity. Withholding it means the "+
+        "boundedness answer stopped reading the written type: %v",
+      file,
+      envelope.DependenciesComplete,
+    )
+  }
+  if !declared["src/main_outermost.ts"] {
+    t.Fatalf(
+      "src/main_outermost.ts must stay declared: its outermost callee IS the "+
+        "declaration it resolves to, so a local arrow with an inferred return "+
+        "type decides nothing. Withholding it means the nested guard is gone, "+
+        "which costs 65 more files across the test workspaces: %v",
+      envelope.DependenciesComplete,
+    )
+  }
+}
+
+func projectDependenciesCalleeInferenceProject(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-callee-inference-")
+  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{
+    "foo.ts":                     projectDependenciesCalleeInferenceSourceFoo,
+    "ns.ts":                      projectDependenciesCalleeInferenceSourceNs,
+    "getns.ts":                   projectDependenciesCalleeInferenceSourceGetNs,
+    "pick.ts":                    projectDependenciesCalleeInferenceSourcePick,
+    "rawflag.ts":                 projectDependenciesCalleeInferenceSourceRawFlag,
+    "flag.ts":                    projectDependenciesCalleeInferenceSourceFlag,
+    "other.ts":                   projectDependenciesCalleeInferenceSourceOther,
+    "sel.ts":                     projectDependenciesCalleeInferenceSourceSel,
+    "main_computed_arg.ts":       projectDependenciesCalleeInferenceSourceComputedArg,
+    "main_computed_callee.ts":    projectDependenciesCalleeInferenceSourceComputedCallee,
+    "main_overload.ts":           projectDependenciesCalleeInferenceSourceOverload,
+    "main_annotated.ts":          projectDependenciesCalleeInferenceSourceAnnotated,
+    "main_function.ts":           projectDependenciesCalleeInferenceSourceFunction,
+    "main_function_annotated.ts": projectDependenciesCalleeInferenceSourceFunctionAnnotated,
+    "main_outermost.ts":          projectDependenciesCalleeInferenceSourceOutermost,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesCalleeInferenceSourceFoo = `export interface Foo {
+  id: string;
+}
+`
+
+const projectDependenciesCalleeInferenceSourceNs = `import typia from "typia";
+
+export const ns = typia;
+`
+
+// The return type is inferred, so nothing written here says the result is
+// typia's namespace; `ns.ts` decides it and no name on the callee chain reaches
+// that file.
+const projectDependenciesCalleeInferenceSourceGetNs = `import { ns } from "./ns";
+
+export const getNs = () => ns;
+
+export const getNsAnnotated: () => typeof ns = () => ns;
+
+export function getNsFn() {
+  return ns;
+}
+
+export function getNsFnAnnotated(): typeof ns {
+  return ns;
+}
+`
+
+const projectDependenciesCalleeInferenceSourcePick = `export const pick = <T>(value: T): T => value;
+`
+
+const projectDependenciesCalleeInferenceSourceRawFlag = `export const RAW = 1;
+`
+
+// The value is borrowed from another file, so the overload this selects is
+// decided by `rawflag.ts`.
+const projectDependenciesCalleeInferenceSourceFlag = `import { RAW } from "./rawflag";
+
+export const FLAG = RAW;
+`
+
+const projectDependenciesCalleeInferenceSourceOther = `export const other = {
+  is: <T>(_input: unknown): _input is T => false,
+};
+`
+
+const projectDependenciesCalleeInferenceSourceSel = `import typia from "typia";
+
+import { other } from "./other";
+
+export function sel(x: 0): typeof other;
+export function sel(x: 1): typeof typia;
+export function sel(x: number): unknown {
+  return x === 1 ? typia : other;
+}
+`
+
+const projectDependenciesCalleeInferenceSourceComputedArg = `import { Foo } from "./foo";
+import { getNs } from "./getns";
+import { pick } from "./pick";
+
+export const check = (input: unknown) => pick(getNs()).is<Foo>(input);
+`
+
+const projectDependenciesCalleeInferenceSourceComputedCallee = `import { Foo } from "./foo";
+import { getNs } from "./getns";
+
+export const check = (input: unknown) => getNs().is<Foo>(input);
+`
+
+const projectDependenciesCalleeInferenceSourceOverload = `import { Foo } from "./foo";
+import { FLAG } from "./flag";
+import { sel } from "./sel";
+
+export const check = (input: unknown) => sel(FLAG).is<Foo>(input);
+`
+
+// The bounded twin: the indirection's return type is written, so `getns.ts`
+// pins the identity and this file must keep its declaration.
+const projectDependenciesCalleeInferenceSourceAnnotated = `import { Foo } from "./foo";
+import { getNsAnnotated } from "./getns";
+
+export const check = (input: unknown) => getNsAnnotated().is<Foo>(input);
+`
+
+const projectDependenciesCalleeInferenceSourceFunction = `import { Foo } from "./foo";
+import { getNsFn } from "./getns";
+
+export const check = (input: unknown) => getNsFn().is<Foo>(input);
+`
+
+const projectDependenciesCalleeInferenceSourceFunctionAnnotated = `import { Foo } from "./foo";
+import { getNsFnAnnotated } from "./getns";
+
+export const check = (input: unknown) => getNsFnAnnotated().is<Foo>(input);
+`
+
+// The outermost callee's identity IS the declaration it resolves to, so a local
+// arrow with an inferred return type decides nothing here and must not withhold
+// the file. Measured: charging it drops the eight test workspaces from 806
+// declared to 741.
+const projectDependenciesCalleeInferenceSourceOutermost = `import typia from "typia";
+
+import { Foo } from "./foo";
+
+const label = () => "x";
+
+export const check = (input: unknown) => typia.is<Foo>(input) && label() !== "";
+`

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

@@ -0,0 +1,117 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestProjectDependenciesCalleeShapeTransform verifies where the callee walk
+// stops, in both directions.
+//
+// A function literal written directly in callee position is the most bounded
+// declaration there is: the call resolves to the literal itself, in this very
+// file, so its body is nobody's dependency and the file stays declarable.
+// Reached through a nested call the same literal is the opposite -- the identity
+// is whatever its body returns, and no set of files describes that -- so the
+// file has to be withheld from the completeness declaration instead
+// (samchon/typia#2357).
+//
+//  1. Build a project where `direct.ts` calls an IIFE whose body names a type
+//     from `deep.ts`, while `indirect.ts` calls what an IIFE returns and
+//     `tagged.ts` calls what a tagged template returns.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert `direct.ts` is declared complete and reports nothing from its own
+//     IIFE body, so the walk neither charged nor withheld the body's names.
+//  4. Assert `indirect.ts` and `tagged.ts` are withheld, so a call-like form
+//     other than `()` does not quietly escape the same rule.
+func TestProjectDependenciesCalleeShapeTransform(t *testing.T) {
+  project := projectDependenciesCalleeShapeProject(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)
+  }
+  declared := map[string]bool{}
+  for _, key := range envelope.DependenciesComplete {
+    declared[key] = true
+  }
+  if !declared["src/direct.ts"] {
+    t.Fatalf("a call to a function literal written in callee position resolves to that literal and must stay declarable: %v", envelope.DependenciesComplete)
+  }
+  for _, entry := range envelope.Dependencies["src/direct.ts"] {
+    if entry == "src/deep.ts" {
+      t.Fatalf("the walk must not charge src/direct.ts with names its own IIFE body uses: %v", envelope.Dependencies["src/direct.ts"])
+    }
+  }
+  if declared["src/indirect.ts"] {
+    t.Fatalf("a call to what a function literal returns has no bounded identity and must be withheld: %v", envelope.DependenciesComplete)
+  }
+  if declared["src/tagged.ts"] {
+    t.Fatalf("a tagged template is a call, so what it returns has no bounded identity either: %v", envelope.DependenciesComplete)
+  }
+}
+
+func projectDependenciesCalleeShapeProject(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-callee-shape-")
+  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{
+    "direct.ts":   projectDependenciesCalleeShapeSourceDirect,
+    "indirect.ts": projectDependenciesCalleeShapeSourceIndirect,
+    "tagged.ts":   projectDependenciesCalleeShapeSourceTagged,
+    "deep.ts":     projectDependenciesCalleeShapeSourceDeep,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesCalleeShapeSourceDirect = `import { Deep } from "./deep";
+
+export const value = (() => {
+  const held: Deep = { id: "x" };
+  return held.id;
+})();
+`
+
+const projectDependenciesCalleeShapeSourceIndirect = `export const value = (() => (input: string): string => input)()("x");
+`
+
+const projectDependenciesCalleeShapeSourceTagged = `export const value = ((_: TemplateStringsArray) => (input: string): string => input)` + "`x`" + `("y");
+`
+
+const projectDependenciesCalleeShapeSourceDeep = `export interface Deep {
+  id: string;
+}
+`

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

@@ -0,0 +1,121 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestProjectDependenciesCalleeUntransformedBarrelTransform verifies a file
+// typia did not transform still reports the modules its callees resolve
+// through, which is what makes declaring that file complete honest.
+//
+// A file with no typia call is declared complete with an empty dependency list,
+// and the claim behind it is that nothing outside the file can change a
+// faithful re-print. Exactly one thing can: an edit that makes one of its calls
+// a typia call. Re-pointing `export { is } from "./local"` at `"typia"` does
+// that without touching the caller, so the barrel has to be in the caller's
+// reported list even though the caller consulted no type at all -- otherwise
+// the narrowed bound has nothing left to invalidate it (samchon/typia#2357).
+//
+//  1. Build a project where `plain.ts` calls `is<Alpha>` imported from
+//     `barrel.ts`, which re-exports a local helper rather than typia.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert `plain.ts` was left untransformed, so it is a class-2 file.
+//  4. Assert it is declared complete, and that its reported list nevertheless
+//     carries `src/barrel.ts` and the `src/local.ts` the barrel resolves to.
+func TestProjectDependenciesCalleeUntransformedBarrelTransform(t *testing.T) {
+  project := projectDependenciesCalleeUntransformedBarrelProject(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)
+  }
+  text := envelope.TypeScript["src/plain.ts"]
+  if !strings.Contains(text, "is<Alpha>(input)") {
+    t.Fatalf("src/plain.ts calls a non-typia helper and must be left untransformed, got:\n%s", text)
+  }
+  declared := map[string]bool{}
+  for _, key := range envelope.DependenciesComplete {
+    declared[key] = true
+  }
+  if !declared["src/plain.ts"] {
+    t.Fatalf("an untransformed file must be declared complete: %v", envelope.DependenciesComplete)
+  }
+  entries := envelope.Dependencies["src/plain.ts"]
+  found := map[string]bool{}
+  for _, entry := range entries {
+    found[entry] = true
+  }
+  if !found["src/barrel.ts"] {
+    t.Fatalf("dependencies of src/plain.ts must contain src/barrel.ts, whose retarget would make the call typia's: %v", entries)
+  }
+  if !found["src/local.ts"] {
+    t.Fatalf("dependencies of src/plain.ts must contain src/local.ts, which currently declares the callee: %v", entries)
+  }
+}
+
+func projectDependenciesCalleeUntransformedBarrelProject(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-callee-untransformed-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{
+    "plain.ts":  projectDependenciesCalleeUntransformedBarrelSourcePlain,
+    "barrel.ts": projectDependenciesCalleeUntransformedBarrelSourceBarrel,
+    "local.ts":  projectDependenciesCalleeUntransformedBarrelSourceLocal,
+    "alpha.ts":  projectDependenciesCalleeUntransformedBarrelSourceAlpha,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesCalleeUntransformedBarrelSourcePlain = `import { is } from "./barrel";
+
+import { Alpha } from "./alpha";
+
+export const checkAlpha = (input: unknown) => is<Alpha>(input);
+`
+
+const projectDependenciesCalleeUntransformedBarrelSourceBarrel = `export { is } from "./local";
+`
+
+const projectDependenciesCalleeUntransformedBarrelSourceLocal = `export const is = <T>(input: unknown): input is T => input !== null;
+`
+
+const projectDependenciesCalleeUntransformedBarrelSourceAlpha = `export interface Alpha {
+  id: string;
+}
+`