typia 14.0.0 → 14.0.2

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

@@ -0,0 +1,153 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestProjectDependenciesCompleteReplacedLibraryTransform verifies a file whose
+// analysis consulted an on-disk default library is withheld from the
+// completeness declaration.
+//
+// The envelope has never reported a file the compiler classifies as a default
+// library, because a bundled library is a toolchain input rather than a project
+// input (samchon/typia#2108). Under `libReplacement` that file is nevertheless a
+// real path the ttsc reference graph carries in `graph.globals`, so the
+// host-owned bound watches it. Declaring such a file complete drops `globals`
+// and would stop watching an input the default bound watches -- editing the
+// replacement lib would then serve a stale validator. Withholding the
+// declaration keeps that file on the sound bound while every file that consulted
+// no replaced library still narrows (samchon/typia#2357).
+//
+//  1. Publish `@typescript/lib-es2015/collection.d.ts` and enable
+//     `libReplacement`, so `Map` is declared by an on-disk file.
+//  2. Transform a project where `replaced.ts` validates `Map<string, number>`
+//     and `control.ts` validates a project-declared interface.
+//  3. Assert both files transformed, so they differ only in what they consulted.
+//  4. Assert `control.ts` is declared complete and `replaced.ts` is not, and
+//     that the replacement file never leaked into the reported dependencies.
+//  5. Assert `nocall.ts` -- no typia call at all, only a CALL on a method the
+//     replaced library declares -- keeps its declaration. Touching a default
+//     library while deciding which declaration a call resolves to cannot change
+//     the emit: typia recognizes its own calls by a `/typia/lib` or `/typia/src`
+//     path, which a compiler-classified default library never has. Withholding
+//     there cost a file its declaration for writing `table.get(...)`, and under
+//     `noembed` -- where every library is on disk -- for calling anything at all
+//     (samchon/typia#2361). `nocall2.ts` is the control that only annotates the
+//     same type, and `replaced.ts` above is the twin that must stay withheld, so
+//     the fix cannot degenerate into never withholding on a library.
+func TestProjectDependenciesCompleteReplacedLibraryTransform(t *testing.T) {
+  project := projectDependenciesCompleteReplacedLibraryProject(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/replaced.ts", "src/control.ts"} {
+    if text := envelope.TypeScript[key]; !strings.Contains(text, "input is") {
+      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/control.ts"] {
+    t.Fatalf("a file that consulted no replaced library must still be declared complete: %v", envelope.DependenciesComplete)
+  }
+  if declared["src/replaced.ts"] {
+    t.Fatalf("a file that consulted an on-disk default library must be withheld from the completeness declaration: %v", envelope.DependenciesComplete)
+  }
+  for _, entry := range envelope.Dependencies["src/replaced.ts"] {
+    if strings.Contains(entry, "@typescript/lib-es2015") {
+      t.Fatalf("the reported dependencies must keep excluding compiler-classified default libraries, got %q", entry)
+    }
+  }
+  for _, key := range []string{"src/nocall.ts", "src/nocall2.ts"} {
+    if !declared[key] {
+      t.Fatalf(
+        "%s holds no typia call, so nothing about the replaced library can "+
+          "change its emitted text; withholding it means the identity channel "+
+          "is still charging a default-library touch: %v",
+        key,
+        envelope.DependenciesComplete,
+      )
+    }
+  }
+}
+
+func projectDependenciesCompleteReplacedLibraryProject(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-replaced-library-")
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  for name, content := range map[string]string{
+    "tsconfig.json": libReplacementNativeIdentityTSConfig,
+    "node_modules/@typescript/lib-es2015/package.json":    libReplacementNativeIdentityPackageJSON,
+    "node_modules/@typescript/lib-es2015/collection.d.ts": libReplacementNativeIdentityCollectionLib,
+    "src/replaced.ts": projectDependenciesCompleteReplacedLibrarySourceReplaced,
+    "src/control.ts":  projectDependenciesCompleteReplacedLibrarySourceControl,
+    "src/shape.ts":    projectDependenciesCompleteReplacedLibrarySourceShape,
+    "src/nocall.ts":   projectDependenciesCompleteReplacedLibrarySourceNoCall,
+    "src/nocall2.ts":  projectDependenciesCompleteReplacedLibrarySourceNoCall2,
+  } {
+    path := filepath.Join(dir, filepath.FromSlash(name))
+    if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+      t.Fatalf("mkdir fixture path %s: %v", filepath.Dir(path), err)
+    }
+    if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
+      t.Fatalf("write fixture file %s: %v", path, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesCompleteReplacedLibrarySourceReplaced = `import typia from "typia";
+
+export const validateMap = (input: unknown) => typia.is<Map<string, number>>(input);
+`
+
+const projectDependenciesCompleteReplacedLibrarySourceControl = `import typia from "typia";
+
+import { Shape } from "./shape";
+
+export const validateShape = (input: unknown) => typia.is<Shape>(input);
+`
+
+const projectDependenciesCompleteReplacedLibrarySourceShape = `export interface Shape {
+  id: string;
+}
+`
+
+// No typia call anywhere, and a CALL on a method the replaced library declares.
+const projectDependenciesCompleteReplacedLibrarySourceNoCall = `const table = new Map<string, number>();
+
+export const lookup = (key: string): number | undefined => table.get(key);
+`
+
+// The control: the same type, annotated but never called on.
+const projectDependenciesCompleteReplacedLibrarySourceNoCall2 = `export const size = (table: Map<string, number>): number => table.size;
+`

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

@@ -0,0 +1,155 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestProjectDependenciesCompleteUntouchedReprintTransform verifies a file typia
+// left untouched is re-printed without any type-driven lowering, which is the
+// premise under which the envelope declares such a file complete.
+//
+// Declaring a file complete with an empty dependency list claims that nothing
+// the type system knows about any other file can change its published text.
+// That holds only because this host prints the parsed AST through a printer
+// handed neither a Checker nor an emit resolver and runs none of the JS script
+// transformers, so no type-driven import elision, `design:type` metadata,
+// `enum`, or `namespace` lowering can reach the envelope. Were any of them to
+// run, an edit to a consulted declaration would change the output of a file
+// with nothing left watching it (samchon/typia#2357, samchon/ttsc#1259).
+//
+//  1. Compile a project with `experimentalDecorators` and
+//     `emitDecoratorMetadata` on, whose `untouched.ts` has no typia call and
+//     carries a type-only import, an `enum`, a `namespace`, `as const`, and a
+//     decorated class with an annotated member.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert the published text preserves each construct verbatim and emits no
+//     `design:type` metadata, so nothing type-driven ran.
+//  4. Assert the file is declared complete with no dependency entry at all.
+func TestProjectDependenciesCompleteUntouchedReprintTransform(t *testing.T) {
+  project := projectDependenciesCompleteUntouchedReprintProject(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, ok := envelope.TypeScript["src/untouched.ts"]
+  if !ok {
+    t.Fatalf("the envelope must publish src/untouched.ts:\n%s", out)
+  }
+  for _, preserved := range []string{
+    "import type { Shape }",
+    "enum Color",
+    "namespace Space",
+    "as const",
+    "@seal",
+  } {
+    if !strings.Contains(text, preserved) {
+      t.Fatalf("the re-print must preserve %q, got:\n%s", preserved, text)
+    }
+  }
+  if strings.Contains(text, "design:type") {
+    t.Fatalf("the transform envelope must not carry emitDecoratorMetadata output, got:\n%s", text)
+  }
+  declared := map[string]bool{}
+  for _, key := range envelope.DependenciesComplete {
+    declared[key] = true
+  }
+  if !declared["src/untouched.ts"] {
+    t.Fatalf("a faithfully re-printed file must be declared complete: %v", envelope.DependenciesComplete)
+  }
+  if entries, ok := envelope.Dependencies["src/untouched.ts"]; ok {
+    t.Fatalf("a file typia never touched must be declared with no dependency entry: %v", entries)
+  }
+}
+
+func projectDependenciesCompleteUntouchedReprintProject(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-untouched-reprint-")
+  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(projectDependenciesCompleteUntouchedReprintTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  for name, body := range map[string]string{
+    "untouched.ts": projectDependenciesCompleteUntouchedReprintSourceUntouched,
+    "shape.ts":     projectDependenciesCompleteUntouchedReprintSourceShape,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesCompleteUntouchedReprintTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}
+`
+
+const projectDependenciesCompleteUntouchedReprintSourceUntouched = `import type { Shape } from "./shape";
+
+export enum Color {
+  Red = 1,
+}
+
+export namespace Space {
+  export const unit = 1;
+}
+
+export const palette = ["red", "blue"] as const;
+
+export const seal = (target: unknown): void => {
+  void target;
+};
+
+@seal
+export class Holder {
+  public shape?: Shape;
+}
+`
+
+const projectDependenciesCompleteUntouchedReprintSourceShape = `export interface Shape {
+  id: string;
+}
+`

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",
+}
+`