typia 13.3.0 → 14.0.1

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

@@ -0,0 +1,206 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestDynamicKeyTagsTransform verifies a type tag on a dynamic key is enforced.
+//
+// `Check_dynamic_key` has always held a complete implementation: it filters the
+// key's tag rows through `check_dynamic_key_fully_validated_tag_rows` and routes
+// a tagged string atomic into `Check_string`, a tagged numeric one into
+// `Check_number`. Nothing reached it, so `[key: string & tags.MinLength<3>]`
+// accepted a two-character key and every other key tag was equally inert
+// (#2347).
+//
+// Values were always checked, which is what made this invisible: the
+// `@typia/template` `DynamicTag` fixture declares exactly this shape and every
+// one of its spoilers corrupts a value, never a key.
+//
+//  1. Transform a fixture whose index signatures carry a pattern, a length, and
+//     a numeric range on the key.
+//  2. Require the emitted checker to contain a key predicate at all.
+//  3. Execute runtime cases: a key violating its tag must be rejected, a key
+//     satisfying it accepted, and neither a plain `[key: string]` signature nor
+//     a template literal one may become constrained.
+//
+// The two negative controls carry the boundary. What the fix makes binding is a
+// broken *tag* on a key the declaration covers; a key no signature's *type*
+// covers is declared nowhere, which is what a surplus property is, and stays
+// accepted. `test_validate_dynamic_key_surplus` pins that distinction against
+// both spellings of the same predicate.
+//
+// The report such a key produces is its own concern. `Superfluous`, the report
+// an extra property already used, says the property is not defined in the object
+// type and advises removing it -- false and unhelpful when the property is
+// declared and only its key broke a constraint. `InvalidKey` names the key type
+// instead, and `test_validate_dynamic_key_report` covers the wording.
+func TestDynamicKeyTagsTransform(t *testing.T) {
+  project := dynamicKeyTagsProject(t)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/main.ts",
+      "--output", "js",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("dynamic key tags transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  // The key is read into a local before it is tested, so its predicate is the
+  // one place the emitted text can show the check exists at all.
+  if !strings.Contains(out, "RegExp(") || !strings.Contains(out, "_stringLength") {
+    t.Fatalf("emitted checker should test the dynamic key, not only its value:\n%s", out)
+  }
+  dynamicKeyTagsRunRuntimeCases(t, project, out)
+}
+
+func dynamicKeyTagsProject(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, "dynamic-key-tags-")
+  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(dynamicKeyTagsTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(dynamicKeyTagsSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func dynamicKeyTagsRunRuntimeCases(t *testing.T, project string, js string) {
+  t.Helper()
+  node, err := exec.LookPath("node")
+  if err != nil {
+    t.Skip("node executable not found")
+  }
+  runtimeDir := filepath.Join(project, "runtime")
+  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
+    t.Fatalf("mkdir runtime dir: %v", err)
+  }
+  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
+  runtimeJS := ttscTypiaTestRewriteCommonJS(t, js)
+  if err := os.WriteFile(filepath.Join(runtimeDir, "main.cjs"), []byte(runtimeJS), 0o644); err != nil {
+    t.Fatalf("write runtime module: %v", err)
+  }
+  runner := filepath.Join(runtimeDir, "run.cjs")
+  if err := os.WriteFile(runner, []byte(dynamicKeyTagsRuntimeRunner), 0o644); err != nil {
+    t.Fatalf("write runtime runner: %v", err)
+  }
+  cmd := exec.Command(node, runner)
+  cmd.Dir = runtimeDir
+  output, err := cmd.CombinedOutput()
+  if err != nil {
+    t.Fatalf("dynamic key tags runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const dynamicKeyTagsTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const dynamicKeyTagsSource = `import typia, { tags } from "typia";
+
+interface IPatternKey {
+  [key: string & tags.Pattern<"^ab+$">]: string;
+}
+interface ILengthKey {
+  [key: string & tags.MinLength<3>]: string;
+}
+interface INumericKey {
+  [key: number & tags.Minimum<0> & tags.Maximum<9>]: string;
+}
+interface IPlainKey {
+  [key: string]: string;
+}
+interface ITemplateKey {
+  [key: ` + "`" + `prefix_${string}` + "`" + `]: string;
+}
+
+export const isPatternKey = typia.createIs<IPatternKey>();
+export const isLengthKey = typia.createIs<ILengthKey>();
+export const isNumericKey = typia.createIs<INumericKey>();
+export const isPlainKey = typia.createIs<IPlainKey>();
+export const isTemplateKey = typia.createIs<ITemplateKey>();
+`
+
+const dynamicKeyTagsRuntimeRunner = `const assert = require("assert");
+const main = require("./main.cjs");
+
+// A key that satisfies its tag is accepted; one that violates it is not. Both
+// directions matter: before the fix every one of these returned true.
+assert.strictEqual(main.isPatternKey({ abb: "x" }), true, "pattern key accepted");
+assert.strictEqual(main.isPatternKey({ zzz: "x" }), false, "non-pattern key rejected");
+
+assert.strictEqual(main.isLengthKey({ abc: "x" }), true, "long enough key accepted");
+assert.strictEqual(main.isLengthKey({ ab: "x" }), false, "too short key rejected");
+
+// The length is counted in characters, as MinLength means everywhere else: two
+// astral characters are four code units but two characters, so they are short.
+assert.strictEqual(
+  main.isLengthKey({ "\u{1f600}\u{1f600}\u{1f600}": "x" }),
+  true,
+  "three astral characters accepted",
+);
+assert.strictEqual(
+  main.isLengthKey({ "\u{1f600}\u{1f600}": "x" }),
+  false,
+  "two astral characters rejected",
+);
+
+assert.strictEqual(main.isNumericKey({ 5: "x" }), true, "in-range numeric key accepted");
+assert.strictEqual(main.isNumericKey({ 10: "x" }), false, "out-of-range numeric key rejected");
+assert.strictEqual(main.isNumericKey({ "-1": "x" }), false, "negative numeric key rejected");
+
+// NEGATIVE CONTROL: an untagged signature stays unconstrained, so the fix
+// constrains only what was declared.
+assert.strictEqual(main.isPlainKey({ "anything at all": "x" }), true, "plain key accepted");
+assert.strictEqual(main.isPlainKey({ "": "x" }), true, "empty plain key accepted");
+
+// NEGATIVE CONTROL: a template literal constrains the key's *type*, not a tag on
+// it, so a key outside it is declared nowhere -- a surplus property, which "is"
+// accepts as it accepts any surplus property. Rejecting this one alongside a
+// broken tag is what the first attempt at the fix did, and it made the
+// equals-mode surplus report unreachable for the DynamicTemplate, DynamicUnion,
+// and DynamicComposite shapes.
+assert.strictEqual(main.isTemplateKey({ prefix_a: "x" }), true, "matching template key accepted");
+assert.strictEqual(main.isTemplateKey({ prefix_a: 1 }), false, "matching template key with a wrong value rejected");
+assert.strictEqual(
+  main.isTemplateKey({ prefix_a: "x", wrong: "y" }),
+  true,
+  "a key outside the template is surplus, not a violation",
+);
+
+// The value is still checked, which it always was.
+assert.strictEqual(main.isLengthKey({ abc: 1 }), false, "wrong value type rejected");
+`

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

@@ -18,8 +18,8 @@ import (
 //  1. Transform a fixture covering camelCase, snake_case, leading-underscore,
 //     consecutive-uppercase (the acronym run collapses, so `XMLParser` becomes
 //     `xmlparser`), and nested property names. The matching compile-time
-//     `KebabCase<T>` assertions live in the test-typia-generate fixture, where
-//     ttsc enforces type diagnostics.
+//     `KebabCase<T>` assertions live in the test-interface fixture, where ttsc
+//     enforces type diagnostics.
 //  2. Require the emitted converter to reference the kebab-case keys.
 //  3. Execute kebab, isKebab, assertKebab, and validateKebab runtime cases
 //     over valid and invalid inputs.

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

@@ -4,16 +4,16 @@
 package main
 
 import (
-	"encoding/json"
-	"path/filepath"
-	"strings"
-	"testing"
+  "encoding/json"
+  "path/filepath"
+  "strings"
+  "testing"
 )
 
 // TestProjectCatalogTransformCoverage reuses broad TypeScript test projects.
 //
 // The focused ttsc fixtures are intentionally small, but the repository already
-// has schema and generation projects that exercise many more typia API shapes.
+// has feature projects that exercise many more typia API shapes.
 // Running them through the same project transform mode gives Go coverage for
 // those native branches without duplicating that TypeScript corpus here.
 //
@@ -31,89 +31,88 @@ import (
 // 3. Require JSON project output to include a TypeScript map.
 // 4. Hold each project to its own purpose's diagnostic contract.
 func TestProjectCatalogTransformCoverage(t *testing.T) {
-	root := transformCoverageRepoRoot(t)
-	for _, project := range []string{
-		"template",
-		"test-langchain",
-		"test-mcp",
-		"test-typia-automated",
-		"test-typia-generate",
-		"test-typia-schema",
-		"test-utils",
-		"test-utils-automated",
-		"test-vercel",
-	} {
-		project := project
-		t.Run(project, func(t *testing.T) {
-			out, errText, code := transformCatalogProject(root, project)
-			if code != 0 {
-				t.Fatalf("%s transform failed: code=%d stderr=\n%s", project, code, errText)
-			}
-			if !strings.Contains(out, `"typescript"`) {
-				t.Fatalf("%s project output should include TypeScript map:\n%s", project, out)
-			}
-		})
-	}
-	// tests/test-error compiles deliberately invalid call sites, and reporting them
-	// is that workspace's entire reason to exist. Its diagnostics are a contract,
-	// not an accident of what it currently holds.
-	t.Run("test-error", func(t *testing.T) {
-		out, _, code := transformCatalogProject(root, "test-error")
-		if code != 3 {
-			t.Fatalf("test-error transform should report diagnostics with code 3, got %d", code)
-		}
-		if !strings.Contains(out, `"diagnostics"`) || !strings.Contains(out, `"typescript"`) {
-			t.Fatalf("test-error output should include diagnostics and TypeScript map:\n%s", out)
-		}
-	})
-	// tests/debug is a one-off repro scratchpad, so nothing about its sources is
-	// promised: it holds valid code between investigations and invalid code during
-	// one. What survives both states is the project transform's own envelope
-	// contract, so that is what this pins. The project must resolve and reach a
-	// transform decision rather than fail to load (exit 2), it must still
-	// contribute transformed sources, and its exit code must agree with the
-	// envelope it published.
-	//
-	// Accepting either 0 or 3 is derived, not observed: transform mode never
-	// typechecks, so exit 2 is reachable only from a flag, cwd, or tsconfig-load
-	// failure (semantic diagnostics belong to the build route). No source content a
-	// repro leaves behind can produce it -- even an outright type error still exits
-	// 0 here -- which is what makes the band content-agnostic.
-	//
-	// The envelope is decoded rather than substring-matched because `"typescript"`
-	// carries no `omitempty` and runTransformProject initializes the map before its
-	// source loop: the key is present even when the workspace resolved no source at
-	// all. That empty envelope is the shape a `rootDir` or `include` rot leaves
-	// behind, and this workspace is the one that already shipped such a rot
-	// (samchon/typia#2132), so a key-presence check would pass over the one failure
-	// worth catching here.
-	t.Run("debug", func(t *testing.T) {
-		out, errText, code := transformCatalogProject(root, "debug")
-		if code != 0 && code != 3 {
-			t.Fatalf("debug transform should load and transform the project, got code=%d stderr=\n%s", code, errText)
-		}
-		var envelope transformProjectOutput
-		if err := json.Unmarshal([]byte(out), &envelope); err != nil {
-			t.Fatalf("debug project output should be a transform envelope: %v\n%s", err, out)
-		}
-		if len(envelope.TypeScript) == 0 {
-			t.Fatalf("debug project should contribute transformed sources, got an empty TypeScript map:\n%s", out)
-		}
-		if diagnosed := len(envelope.Diagnostics) > 0; diagnosed != (code == 3) {
-			t.Fatalf("debug exit code %d disagrees with its envelope (diagnostics present: %v):\n%s", code, diagnosed, out)
-		}
-	})
+  root := transformCoverageRepoRoot(t)
+  for _, project := range []string{
+    "template",
+    "test-langchain",
+    "test-mcp",
+    "test-typia-automated",
+    "test-typia-schema",
+    "test-utils",
+    "test-utils-automated",
+    "test-vercel",
+  } {
+    project := project
+    t.Run(project, func(t *testing.T) {
+      out, errText, code := transformCatalogProject(root, project)
+      if code != 0 {
+        t.Fatalf("%s transform failed: code=%d stderr=\n%s", project, code, errText)
+      }
+      if !strings.Contains(out, `"typescript"`) {
+        t.Fatalf("%s project output should include TypeScript map:\n%s", project, out)
+      }
+    })
+  }
+  // tests/test-error compiles deliberately invalid call sites, and reporting them
+  // is that workspace's entire reason to exist. Its diagnostics are a contract,
+  // not an accident of what it currently holds.
+  t.Run("test-error", func(t *testing.T) {
+    out, _, code := transformCatalogProject(root, "test-error")
+    if code != 3 {
+      t.Fatalf("test-error transform should report diagnostics with code 3, got %d", code)
+    }
+    if !strings.Contains(out, `"diagnostics"`) || !strings.Contains(out, `"typescript"`) {
+      t.Fatalf("test-error output should include diagnostics and TypeScript map:\n%s", out)
+    }
+  })
+  // tests/debug is a one-off repro scratchpad, so nothing about its sources is
+  // promised: it holds valid code between investigations and invalid code during
+  // one. What survives both states is the project transform's own envelope
+  // contract, so that is what this pins. The project must resolve and reach a
+  // transform decision rather than fail to load (exit 2), it must still
+  // contribute transformed sources, and its exit code must agree with the
+  // envelope it published.
+  //
+  // Accepting either 0 or 3 is derived, not observed: transform mode never
+  // typechecks, so exit 2 is reachable only from a flag, cwd, or tsconfig-load
+  // failure (semantic diagnostics belong to the build route). No source content a
+  // repro leaves behind can produce it -- even an outright type error still exits
+  // 0 here -- which is what makes the band content-agnostic.
+  //
+  // The envelope is decoded rather than substring-matched because `"typescript"`
+  // carries no `omitempty` and runTransformProject initializes the map before its
+  // source loop: the key is present even when the workspace resolved no source at
+  // all. That empty envelope is the shape a `rootDir` or `include` rot leaves
+  // behind, and this workspace is the one that already shipped such a rot
+  // (samchon/typia#2132), so a key-presence check would pass over the one failure
+  // worth catching here.
+  t.Run("debug", func(t *testing.T) {
+    out, errText, code := transformCatalogProject(root, "debug")
+    if code != 0 && code != 3 {
+      t.Fatalf("debug transform should load and transform the project, got code=%d stderr=\n%s", code, errText)
+    }
+    var envelope transformProjectOutput
+    if err := json.Unmarshal([]byte(out), &envelope); err != nil {
+      t.Fatalf("debug project output should be a transform envelope: %v\n%s", err, out)
+    }
+    if len(envelope.TypeScript) == 0 {
+      t.Fatalf("debug project should contribute transformed sources, got an empty TypeScript map:\n%s", out)
+    }
+    if diagnosed := len(envelope.Diagnostics) > 0; diagnosed != (code == 3) {
+      t.Fatalf("debug exit code %d disagrees with its envelope (diagnostics present: %v):\n%s", code, diagnosed, out)
+    }
+  })
 }
 
 // transformCatalogProject runs project transform mode over one repository test
 // project and returns its captured stdout, stderr, and exit code.
 func transformCatalogProject(root string, project string) (string, string, int) {
-	cwd := filepath.Join(root, "tests", project)
-	return transformCoverageCapture(func() int {
-		return runTransform([]string{
-			"--cwd", cwd,
-			"--tsconfig", "tsconfig.json",
-			"--output", "ts",
-		})
-	})
+  cwd := filepath.Join(root, "tests", project)
+  return transformCoverageCapture(func() int {
+    return runTransform([]string{
+      "--cwd", cwd,
+      "--tsconfig", "tsconfig.json",
+      "--output", "ts",
+    })
+  })
 }

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

@@ -0,0 +1,177 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestProjectDependenciesCalleeArgumentTransform verifies a nested call's
+// arguments report the names they write, and that their shape never withholds
+// the caller.
+//
+// The callee chain names every indirection a caller writes -- a factory, a
+// barrel, a namespace alias -- but a generic pass-through carries identity
+// through what the call is APPLIED to instead: `pick(ns).is<Foo>(x)` is rewritten
+// because `ns` holds the typia namespace, so `ns.ts` decides whether this file
+// becomes a validator at all. Reproduced: the envelope declared the caller
+// complete while reporting only `foo.ts` and `pick.ts`, so re-pointing `ns.ts`
+// would have turned the validator back into a plain call with nothing to
+// invalidate it (samchon/typia#2357).
+//
+// The twin is why the walk's answer is dropped rather than combined: a callback
+// handed to a chained array method decides nothing about which `join` the outer
+// call names, and withholding on it would cost every file that chains one.
+//
+//  1. Build a project where `main.ts` calls `pick(ns).is<Foo>(input)` for a
+//     `pick` that returns its argument, and `chain.ts` writes
+//     `["a"].map((x) => x + HIDDEN).join(",")` for a `HIDDEN` from another file.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert `main.ts` really was rewritten into a validator, so the pass-through
+//     is the shape the test intends.
+//  4. Assert `dependencies["src/main.ts"]` carries `src/ns.ts` and `src/pick.ts`,
+//     and that the file is declared complete.
+//  5. Assert `chain.ts` is declared complete and never reports `src/hidden.ts`,
+//     the name only its callback body writes.
+//  6. Assert the tagged-template spelling of the same pass-through --
+//     “tag`x${ns}`.is<Foo>(input)“ -- reports `src/ns.ts` as well, because a
+//     template is what its tag is applied to.
+func TestProjectDependenciesCalleeArgumentTransform(t *testing.T) {
+  project := projectDependenciesCalleeArgumentProject(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/main.ts"]; !strings.Contains(text, "input is Foo") {
+    t.Fatalf("the pass-through call must have been rewritten into a validator, got:\n%s", text)
+  }
+  entries := envelope.Dependencies["src/main.ts"]
+  found := map[string]bool{}
+  for _, entry := range entries {
+    found[entry] = true
+  }
+  if !found["src/ns.ts"] {
+    t.Fatalf("dependencies of src/main.ts must contain src/ns.ts, the argument that makes this call typia's: %v", entries)
+  }
+  if !found["src/pick.ts"] {
+    t.Fatalf("dependencies of src/main.ts must contain src/pick.ts, the pass-through on the callee chain: %v", entries)
+  }
+  declared := map[string]bool{}
+  for _, key := range envelope.DependenciesComplete {
+    declared[key] = true
+  }
+  if !declared["src/main.ts"] {
+    t.Fatalf("src/main.ts must be declared complete, so the reported entry is the whole bound: %v", envelope.DependenciesComplete)
+  }
+  if !declared["src/chain.ts"] {
+    t.Fatalf("a callback handed to a chained array method decides no callee identity and must not withhold its file: %v", envelope.DependenciesComplete)
+  }
+  for _, entry := range envelope.Dependencies["src/chain.ts"] {
+    if entry == "src/hidden.ts" {
+      t.Fatalf("the walk must stop at a function literal, so src/hidden.ts must not be charged to src/chain.ts: %v", envelope.Dependencies["src/chain.ts"])
+    }
+  }
+  if text := envelope.TypeScript["src/tagged.ts"]; !strings.Contains(text, "input is Foo") {
+    t.Fatalf("the tagged-template pass-through must have been rewritten into a validator, got:\n%s", text)
+  }
+  tagged := map[string]bool{}
+  for _, entry := range envelope.Dependencies["src/tagged.ts"] {
+    tagged[entry] = true
+  }
+  if !tagged["src/ns.ts"] {
+    t.Fatalf("dependencies of src/tagged.ts must contain src/ns.ts, the substitution that makes this call typia's: %v", envelope.Dependencies["src/tagged.ts"])
+  }
+  if !declared["src/tagged.ts"] {
+    t.Fatalf("src/tagged.ts must be declared complete, so the reported entry is the whole bound: %v", envelope.DependenciesComplete)
+  }
+}
+
+func projectDependenciesCalleeArgumentProject(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-argument-")
+  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{
+    "main.ts":   projectDependenciesCalleeArgumentSourceMain,
+    "ns.ts":     projectDependenciesCalleeArgumentSourceNs,
+    "pick.ts":   projectDependenciesCalleeArgumentSourcePick,
+    "foo.ts":    projectDependenciesCalleeArgumentSourceFoo,
+    "chain.ts":  projectDependenciesCalleeArgumentSourceChain,
+    "hidden.ts": projectDependenciesCalleeArgumentSourceHidden,
+    "tagged.ts": projectDependenciesCalleeArgumentSourceTagged,
+    "tag.ts":    projectDependenciesCalleeArgumentSourceTag,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesCalleeArgumentSourceMain = `import { Foo } from "./foo";
+import { ns } from "./ns";
+import { pick } from "./pick";
+
+export const check = (input: unknown) => pick(ns).is<Foo>(input);
+`
+
+const projectDependenciesCalleeArgumentSourceNs = `import typia from "typia";
+
+export const ns = typia;
+`
+
+const projectDependenciesCalleeArgumentSourcePick = `export const pick = <T>(value: T): T => value;
+`
+
+const projectDependenciesCalleeArgumentSourceFoo = `export interface Foo {
+  id: string;
+}
+`
+
+const projectDependenciesCalleeArgumentSourceChain = `import { HIDDEN } from "./hidden";
+
+export const joined = ["a"].map((x) => x + HIDDEN).join(",");
+`
+
+const projectDependenciesCalleeArgumentSourceHidden = `export const HIDDEN = "hidden";
+`
+
+const projectDependenciesCalleeArgumentSourceTagged = `import { Foo } from "./foo";
+import { ns } from "./ns";
+import { tag } from "./tag";
+
+export const check = (input: unknown) => tag` + "`" + `x${ns}` + "`" + `.is<Foo>(input);
+`
+
+const projectDependenciesCalleeArgumentSourceTag = `export const tag = <T>(_strings: TemplateStringsArray, value: T): T => value;
+`