typia 14.0.0 → 14.0.2

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

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

@@ -0,0 +1,116 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestProjectDependenciesCompleteDiagnosticTransform verifies a file whose
+// typia call raised a diagnostic is withheld from the completeness declaration.
+//
+// A diagnostic means the analysis stopped partway, so what it consulted before
+// giving up is not that file's whole input set: an edit to a declaration it
+// never reached could make the same call succeed and publish different text.
+// The envelope is a failure result either way and the protocol allows a partial
+// declaration, but a claim that is false is worth withholding rather than
+// explaining (samchon/typia#2357).
+//
+//  1. Build a project where `rejected.ts` asks for a protobuf message over
+//     `bigint`, which no protobuf entry point supports, beside a `control.ts`
+//     that transforms cleanly.
+//  2. Run project transform mode; the host reports the diagnostic and exits 3
+//     after printing the envelope.
+//  3. Assert the diagnostic names `rejected.ts`, so the fixture failed for the
+//     reason the test intends.
+//  4. Assert `control.ts` is declared complete and `rejected.ts` is not.
+func TestProjectDependenciesCompleteDiagnosticTransform(t *testing.T) {
+  project := projectDependenciesCompleteDiagnosticProject(t)
+  out, _, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--output", "ts",
+    })
+  })
+  if code != 3 {
+    t.Fatalf("a rejected call must fail the project transform with code 3, got %d:\n%s", code, out)
+  }
+  var envelope struct {
+    Diagnostics []struct {
+      File *string `json:"file"`
+    } `json:"diagnostics"`
+    DependenciesComplete []string `json:"dependenciesComplete"`
+  }
+  if err := json.Unmarshal([]byte(out), &envelope); err != nil {
+    t.Fatalf("decode envelope: %v\n%s", err, out)
+  }
+  named := false
+  for _, diagnostic := range envelope.Diagnostics {
+    if diagnostic.File != nil && filepath.Base(filepath.FromSlash(*diagnostic.File)) == "rejected.ts" {
+      named = true
+    }
+  }
+  if !named {
+    t.Fatalf("the diagnostic must name src/rejected.ts, so the fixture failed for the intended reason: %s", out)
+  }
+  declared := map[string]bool{}
+  for _, key := range envelope.DependenciesComplete {
+    declared[key] = true
+  }
+  if !declared["src/control.ts"] {
+    t.Fatalf("a file that transformed cleanly must still be declared complete: %v", envelope.DependenciesComplete)
+  }
+  if declared["src/rejected.ts"] {
+    t.Fatalf("a file whose call typia could not lower must be withheld from the completeness declaration: %v", envelope.DependenciesComplete)
+  }
+}
+
+func projectDependenciesCompleteDiagnosticProject(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-complete-diagnostic-")
+  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{
+    "rejected.ts": projectDependenciesCompleteDiagnosticSourceRejected,
+    "control.ts":  projectDependenciesCompleteDiagnosticSourceControl,
+    "shape.ts":    projectDependenciesCompleteDiagnosticSourceShape,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesCompleteDiagnosticSourceRejected = `import typia from "typia";
+
+export const message = typia.protobuf.message<bigint>();
+`
+
+const projectDependenciesCompleteDiagnosticSourceControl = `import typia from "typia";
+
+import { Shape } from "./shape";
+
+export const validateShape = (input: unknown) => typia.is<Shape>(input);
+`
+
+const projectDependenciesCompleteDiagnosticSourceShape = `export interface Shape {
+  id: string;
+}
+`

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

@@ -0,0 +1,115 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "sort"
+  "testing"
+)
+
+// TestProjectDependenciesCompleteEnvelopeTransform verifies the project
+// transform envelope declares every file it published as having a complete
+// dependency list.
+//
+// `dependencies` alone only widens the consumer's bound; `dependenciesComplete`
+// is what lets the consumer stop widening and validate the ~10 declarations
+// typia consulted instead of the file's whole reference closure plus every
+// global-scope declaration, once per delivered module. The claim covers both
+// classes of envelope file, and the second one is the larger half: a file with
+// no typia call receives no contribution at all, so its empty entry is the
+// strongest claim the envelope carries (samchon/typia#2357).
+//
+//  1. Build a project where `a.ts` validates `Bee` from `b.ts` (which reaches
+//     `Cee` in `c.ts`), plus `d.ts` with no typia call at all.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert `dependenciesComplete` names exactly the published `typescript`
+//     keys, so neither the transformed file nor the untouched ones are left on
+//     the conservative bound.
+//  4. Assert the declared list for `src/a.ts` still carries `src/b.ts` and
+//     `src/c.ts`, because the declaration narrows to that entry and an entry
+//     that lost a consulted file would now serve a stale validator.
+func TestProjectDependenciesCompleteEnvelopeTransform(t *testing.T) {
+  project := projectDependenciesCompleteEnvelopeProject(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)
+  }
+
+  published := make([]string, 0, len(envelope.TypeScript))
+  for key := range envelope.TypeScript {
+    published = append(published, key)
+  }
+  sort.Strings(published)
+  declared := append([]string{}, envelope.DependenciesComplete...)
+  sort.Strings(declared)
+  if len(published) != len(declared) {
+    t.Fatalf("dependenciesComplete must name every published file; published=%v declared=%v", published, declared)
+  }
+  for index, key := range published {
+    if declared[index] != key {
+      t.Fatalf("dependenciesComplete must name every published file; published=%v declared=%v", published, declared)
+    }
+  }
+
+  entries := envelope.Dependencies["src/a.ts"]
+  found := map[string]bool{}
+  for _, entry := range entries {
+    found[entry] = true
+  }
+  if !found["src/b.ts"] {
+    t.Fatalf("the declared entry for src/a.ts must keep the direct declaration file src/b.ts: %v", entries)
+  }
+  if !found["src/c.ts"] {
+    t.Fatalf("the declared entry for src/a.ts must keep the transitive declaration file src/c.ts: %v", entries)
+  }
+  if _, ok := envelope.Dependencies["src/d.ts"]; ok {
+    t.Fatalf("src/d.ts has no typia call and must be declared with no dependency at all: %v", envelope.Dependencies["src/d.ts"])
+  }
+}
+
+func projectDependenciesCompleteEnvelopeProject(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-complete-envelope-")
+  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": projectDependenciesEnvelopeSourceA,
+    "b.ts": projectDependenciesEnvelopeSourceB,
+    "c.ts": projectDependenciesEnvelopeSourceC,
+    "d.ts": projectDependenciesEnvelopeSourceD,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}

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

@@ -0,0 +1,127 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestProjectDependenciesCompleteInferredTypeTransform verifies a file whose
+// typia call takes its validated type from the value argument is withheld from
+// the completeness declaration, while its written-type-argument twin is not.
+//
+// A written type argument bounds the analysis: every declaration reachable from
+// it is touched and reported, so the reported list is the whole input set. An
+// inferred one does not, because contextual typing can put the deciding
+// annotation in a file the resolved type never names -- `const handler:
+// Handler = (input) => typia.assert(input)` validates whatever `Handler`
+// declares, and `Handler`'s file is nowhere in the consulted-declaration set.
+// Declaring such a file complete would drop the reference closure that is the
+// only thing still watching it (samchon/typia#2357).
+//
+//  1. Build a project where `written.ts` calls `typia.assert<Shape>(input)` and
+//     `inferred.ts` calls `typia.assert(input)` on a parameter contextually
+//     typed through `handler.ts`.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert both files transformed, so the two differ only in where the type
+//     came from.
+//  4. Assert `written.ts` is declared complete and `inferred.ts` is not, and
+//     that `inferred.ts` still keeps its reported dependency entry -- it falls
+//     back to the host-owned bound, it is not stripped of what it did report.
+func TestProjectDependenciesCompleteInferredTypeTransform(t *testing.T) {
+  project := projectDependenciesCompleteInferredTypeProject(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/written.ts", "src/inferred.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/written.ts"] {
+    t.Fatalf("a call with a written type argument bounds its inputs and must be declared complete: %v", envelope.DependenciesComplete)
+  }
+  if declared["src/inferred.ts"] {
+    t.Fatalf("a call that infers its type from the value argument must be withheld from the completeness declaration: %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)
+  }
+}
+
+func projectDependenciesCompleteInferredTypeProject(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-complete-inferred-")
+  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{
+    "shape.ts":    projectDependenciesCompleteInferredSourceShape,
+    "handler.ts":  projectDependenciesCompleteInferredSourceHandler,
+    "written.ts":  projectDependenciesCompleteInferredSourceWritten,
+    "inferred.ts": projectDependenciesCompleteInferredSourceInferred,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesCompleteInferredSourceShape = `export interface Shape {
+  id: string;
+}
+`
+
+const projectDependenciesCompleteInferredSourceHandler = `import { Shape } from "./shape";
+
+export type Handler = (input: Shape) => unknown;
+`
+
+const projectDependenciesCompleteInferredSourceWritten = `import typia from "typia";
+
+import { Shape } from "./shape";
+
+export const validateShape = (input: Shape) => typia.assert<Shape>(input);
+`
+
+const projectDependenciesCompleteInferredSourceInferred = `import typia from "typia";
+
+import { Handler } from "./handler";
+
+export const handle: Handler = (input) => typia.assert(input);
+`