typia 13.3.0 → 14.0.1

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

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