typia 13.1.1 → 13.1.19

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

@@ -7,13 +7,16 @@ import (
   "fmt"
   "os"
   "path/filepath"
+  "sort"
   "strings"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
   shimprinter "github.com/microsoft/typescript-go/shim/printer"
   "github.com/samchon/ttsc/packages/ttsc/driver"
+  typiaadapter "github.com/samchon/typia/packages/typia/native/adapter"
   nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
   nativetransform "github.com/samchon/typia/packages/typia/native/transform"
 )
 
@@ -24,6 +27,10 @@ import (
 // transformers), so injected namespace imports stay as ES imports the caller
 // can type-strip per file. With no --file it emits a JSON envelope of every
 // project source keyed by its cwd-relative path; with --file it prints one file.
+//
+// Every host here consults the same transformDiags before choosing its exit code
+// and before publishing anything: runTransformProject encodes them and returns 3,
+// runTransformSingle reports them and withholds the artifact.
 func runTransform(args []string) int {
   fs := flag.NewFlagSet("transform", flag.ContinueOnError)
   fs.SetOutput(stderr)
@@ -33,7 +40,7 @@ func runTransform(args []string) int {
   out := fs.String("out", "", "write single-file output to PATH instead of stdout")
   rewriteMode := fs.String("rewrite-mode", "typia", "native rewrite backend id")
   output := fs.String("output", defaultTransformOutput(), "single-file output kind: js or ts")
-  _ = fs.String("plugins-json", "", "ordered ttsc plugin payload")
+  pluginsJSON := fs.String("plugins-json", "", "ordered ttsc plugin payload")
   if err := fs.Parse(args); err != nil {
     return 2
   }
@@ -45,11 +52,17 @@ func runTransform(args []string) int {
     fmt.Fprintf(stderr, "ttsc-typia transform: unknown --output value %q\n", *output)
     return 2
   }
+  // Resolve the options before loading the program: they come from the payload
+  // alone, so an unreadable manifest is a usage error to report now rather than
+  // after a full transform has already run under the wrong configuration.
+  pluginOptions, err := typiaadapter.ReadPluginOptions(*pluginsJSON)
+  if err != nil {
+    fmt.Fprintf(stderr, "ttsc-typia transform: %v\n", err)
+    return 2
+  }
   cwd := *cwdOverride
   if cwd == "" {
-    var err error
-    cwd, err = os.Getwd()
-    if err != nil {
+    if cwd, err = os.Getwd(); err != nil {
       fmt.Fprintf(stderr, "ttsc-typia transform: cwd: %v\n", err)
       return 2
     }
@@ -69,7 +82,6 @@ func runTransform(args []string) int {
   defer prog.Close()
 
   transformDiags := []typiaTransformDiagnostic{}
-  pluginOptions := readTypiaPluginOptions(cwd, *tsconfigPath)
   transformOptions := pluginOptions.TransformOptions()
   extras := nativecontext.ITypiaContext_Extras{
     AddDiagnostic: func(diag *nativecontext.ITypiaDiagnostic) int {
@@ -102,15 +114,59 @@ func runTransform(args []string) int {
     fmt.Fprintf(stderr, "ttsc-typia transform: source file is not in program: %s\n", absFile)
     return 2
   }
-  if *output == "js" {
-    return runTransformSingleJS(prog, typiaTransform, target, absFile, *out)
+  return runTransformSingle(cwd, *out, &transformDiags, func() (string, int) {
+    if *output == "js" {
+      return transformSingleToJavaScript(prog, typiaTransform, target)
+    }
+    return transformFileToTypeScript(prog, typiaTransform, target), 0
+  })
+}
+
+// runTransformSingle is the single-file counterpart of runTransformProject's
+// diagnostic decision: produce the artifact into memory, then publish it only
+// when typia's analysis reported nothing. Every single-file output mode routes
+// through this one commit point, so a mode cannot exit 0 over a diagnostic and
+// publish an untransformed `typia.is<T>(input)` call by forgetting its own check
+// (samchon/typia#2117).
+//
+// Diagnostics outrank the producer's own failure code: when typia could not
+// lower a call, that diagnostic is the cause a caller needs, not the "no output
+// produced" symptom it leaves behind.
+func runTransformSingle(
+  cwd string,
+  outPath string,
+  transformDiags *[]typiaTransformDiagnostic,
+  produce func() (string, int),
+) int {
+  text, code := produce()
+  if len(*transformDiags) > 0 {
+    writeTypiaTransformDiagnostics(stderr, *transformDiags, cwd)
+    return 3
+  }
+  if code != 0 {
+    return code
   }
-  text := transformFileToTypeScript(prog, typiaTransform, target)
-  return writeSingleOutput(text, *out)
+  return writeSingleOutput(text, outPath)
 }
 
 // runTransformProject prints every non-declaration project source as transformed
-// TypeScript and encodes the JSON envelope the ttsc host expects.
+// TypeScript and encodes the JSON envelope the ttsc host expects. Alongside the
+// transformed sources it reports two invalidation channels the ttsc consumer
+// registers with the bundler so persistent caches and watch mode invalidate
+// generated validators soundly:
+//
+//   - `graph`, the host-owned reference graph of the loaded program (direct
+//     resolved edges, ambient globals, tsconfig extends chain) computed by the
+//     ttsc driver SDK. It is the plugin-agnostic sound baseline under `tsc
+//     --incremental` semantics; the consumer registers, per file F,
+//     reach(edges, F) ∪ globals ∪ configs.
+//   - `dependencies`, typia's precise per-file list of the source files owning
+//     the declarations the typia analysis consulted for each transformed file.
+//
+// The consumer unions the two (reach(edges, F) ∪ globals ∪ configs ∪
+// dependencies[F]), so graph is added alongside dependencies, not a replacement.
+// Every section keys through driver.TransformOutputKey, so the consumer joins
+// them by key.
 func runTransformProject(
   prog *driver.Program,
   cwd string,
@@ -121,16 +177,29 @@ func runTransformProject(
     Diagnostics: []transformCompilerDiagnostic{},
     TypeScript:  map[string]string{},
   }
+  // Compute the reference graph from the loaded program before the transform
+  // loop runs typia's per-file node transformer: the graph must describe the
+  // original source's resolved references (the transform's inputs), matching
+  // ttsc's own `api-transform` host.
+  out.Graph = driver.NewTransformGraph(prog, cwd)
+  collector := newTransformDependencyCollector(cwd, func(fileName string) bool {
+    sf := prog.SourceFile(fileName)
+    return sf != nil && prog.TSProgram.IsLibFile(sf)
+  })
+  schemametadata.MetadataDependency_listen(prog.Checker, collector.Touch)
+  defer schemametadata.MetadataDependency_release(prog.Checker)
   for _, sf := range prog.SourceFiles() {
     if sf.IsDeclarationFile {
       continue
     }
-    key := sourceFileKey(cwd, filepath.ToSlash(sf.FileName()))
+    key := driver.TransformOutputKey(cwd, sf.FileName())
     if filepath.IsAbs(key) || key == ".." || strings.HasPrefix(key, "../") {
       continue
     }
+    collector.Begin(key)
     out.TypeScript[key] = transformFileToTypeScript(prog, typiaTransform, sf)
   }
+  out.Dependencies = collector.ToJSON()
   for _, diag := range *transformDiags {
     out.Diagnostics = append(out.Diagnostics, transformDiagnosticToCompilerDiagnostic(diag))
   }
@@ -165,21 +234,45 @@ func transformFileToTypeScript(
   return writer.String()
 }
 
-// runTransformSingleJS emits a single file's JS through the full node-path emit
-// pipeline and writes it to stdout or --out.
-func runTransformSingleJS(
+// transformSingleToJavaScript emits a single file's JS through the full node-path
+// emit pipeline and returns the captured text. It only produces; publishing is
+// runTransformSingle's decision, so a diagnostic can withhold the artifact.
+//
+// The emit pass covers every file in the program, so unlike the `ts` mode -- which
+// transforms only the target -- a diagnostic raised by any project source reaches
+// runTransformSingle and withholds this file's artifact. That is deliberate and
+// matches the build host, which fails the whole build on any transform diagnostic:
+// the emit that produced this text is the same one that could not lower the other
+// call, so its success is not independently trustworthy.
+//
+// The emit writes every project output through one callback, so the target's own
+// artifact has to be identified among them. That identity comes from the
+// compiler's output-path resolution rather than from a resemblance between the
+// source and emitted paths, because the emit chooses its write path with that
+// same resolution: `outDir`, `rootDir`, and nested source directories may move
+// the artifact anywhere without the two disagreeing, and two sources sharing a
+// basename in different directories resolve to different artifacts instead of
+// collapsing onto one. Deriving the path instead of matching stems is what fixed
+// samchon/typia#2134, where a whole-path-stem match asked whether `dist/main`
+// equaled `src/main` and so reported "no output produced" for every project
+// with an `outDir`.
+func transformSingleToJavaScript(
   prog *driver.Program,
   typiaTransform driver.PluginTransform,
   target *shimast.SourceFile,
-  absFile string,
-  outPath string,
-) int {
+) (string, int) {
+  // The resolution answers with an empty path for a source that has no
+  // JavaScript lane of its own -- a JSON module that would be emitted over
+  // itself. Nothing the emit writes is then this file's artifact, so guard the
+  // comparison rather than let an empty expectation match anything.
+  expected := ""
+  if paths := shimcompiler.GetOutputPathsFor(target, prog.TSProgram.Options(), prog.TSProgram, false); paths != nil {
+    expected = filepath.ToSlash(paths.JsFilePath())
+  }
   var captured string
   found := false
-  targetKey := filepath.ToSlash(absFile)
   writeFile := shimcompiler.WriteFile(func(fileName, text string, _ *shimcompiler.WriteFileData) error {
-    // The emitted .js maps back to its .ts; match on basename stem.
-    if sameSourceStem(targetKey, fileName) {
+    if expected != "" && filepath.ToSlash(fileName) == expected {
       captured = text
       found = true
     }
@@ -187,20 +280,13 @@ func runTransformSingleJS(
   })
   if _, err := prog.EmitWithPluginTransformers([]driver.PluginTransform{typiaTransform}, writeFile); err != nil {
     fmt.Fprintf(stderr, "ttsc-typia transform: emit: %v\n", err)
-    return 3
+    return "", 3
   }
   if !found {
-    fmt.Fprintf(stderr, "ttsc-typia transform: no output produced for %s\n", absFile)
-    return 3
+    fmt.Fprintf(stderr, "ttsc-typia transform: no output produced for %s\n", target.FileName())
+    return "", 3
   }
-  return writeSingleOutput(captured, outPath)
-}
-
-// sameSourceStem reports whether an emitted .js path corresponds to a .ts source
-// path by comparing their extension-stripped values.
-func sameSourceStem(tsPath, jsPath string) bool {
-  return strings.TrimSuffix(filepath.ToSlash(jsPath), filepath.Ext(jsPath)) ==
-    strings.TrimSuffix(tsPath, filepath.Ext(tsPath))
+  return captured, 0
 }
 
 func writeSingleOutput(text, outPath string) int {
@@ -234,6 +320,117 @@ func defaultTransformOutput() string {
 type transformProjectOutput struct {
   Diagnostics []transformCompilerDiagnostic `json:"diagnostics,omitempty"`
   TypeScript  map[string]string             `json:"typescript"`
+  // Graph is the host-owned reference graph of the loaded program produced by
+  // the ttsc driver SDK (driver.NewTransformGraph): direct resolved reference
+  // edges, ambient global-scope files, and the tsconfig extends chain, keyed
+  // like TypeScript through driver.TransformOutputKey. It is the plugin-agnostic
+  // sound invalidation baseline; the consumer unions it with Dependencies.
+  // Omitted only when the program is nil (never here — a nil program returns
+  // earlier).
+  Graph *driver.TransformGraph `json:"graph,omitempty"`
+  // Dependencies maps each transformed file (same project-relative keys as
+  // TypeScript) to the source files owning the declarations typia's analysis
+  // consulted for it. Values are project-relative when the file lives under the
+  // project and absolute otherwise; the consumer absolutizes against the
+  // project root and drops the file itself. Compiler-owned default library
+  // files are excluded (toolchain-versioned, not project inputs);
+  // `node_modules` declaration files are included.
+  Dependencies map[string][]string `json:"dependencies,omitempty"`
+}
+
+// transformDependencyCollector accumulates the consulted-declaration files the
+// metadata dependency listener reports while one project file is transformed,
+// attributing them to that file's envelope key.
+type transformDependencyCollector struct {
+  cwd     string
+  current string
+  files   map[string]map[string]bool
+  // isLibraryFile reports the compiler's own classification of a file as a
+  // default library. Classification must come from the program, never from a
+  // filename pattern: a project's own ambient declaration file may legitimately
+  // be named `lib.custom.d.ts`, and dropping it by basename silently loses
+  // cache invalidation for the types it declares (samchon/typia#2108).
+  isLibraryFile func(fileName string) bool
+  // values memoizes fileName -> envelope value ("" for a dropped file): the
+  // listener reports the same declaration files repeatedly across call sites.
+  values map[string]string
+}
+
+func newTransformDependencyCollector(
+  cwd string,
+  isLibraryFile func(fileName string) bool,
+) *transformDependencyCollector {
+  return &transformDependencyCollector{
+    cwd:           cwd,
+    isLibraryFile: isLibraryFile,
+    files:         map[string]map[string]bool{},
+    values:        map[string]string{},
+  }
+}
+
+// Begin attributes subsequent touches to the given envelope key.
+func (collector *transformDependencyCollector) Begin(key string) {
+  collector.current = key
+}
+
+// Touch records one consulted declaration file for the current key. Default
+// library files, virtual URI sources (e.g. tsgo's `bundled:///` libraries),
+// and the transformed file itself are dropped so the envelope carries only
+// actionable project inputs.
+func (collector *transformDependencyCollector) Touch(fileName string) {
+  if collector.current == "" {
+    return
+  }
+  value, memoized := collector.values[fileName]
+  if memoized == false {
+    value = collector.value(fileName)
+    collector.values[fileName] = value
+  }
+  if value == "" || value == collector.current {
+    return
+  }
+  set := collector.files[collector.current]
+  if set == nil {
+    set = map[string]bool{}
+    collector.files[collector.current] = set
+  }
+  set[value] = true
+}
+
+// value renders one reported file as its envelope value, or "" when the file
+// must be dropped: virtual URI sources (e.g. tsgo's `bundled:///` embedded
+// libraries) cannot be watched, and files the compiler classifies as default
+// libraries (on-disk in `noembed` or `libReplacement` configurations) are
+// toolchain inputs, not project inputs.
+func (collector *transformDependencyCollector) value(fileName string) string {
+  if strings.Contains(fileName, "://") || collector.isLibraryFile(fileName) {
+    return ""
+  }
+  return driver.TransformOutputKey(collector.cwd, fileName)
+}
+
+// ToJSON renders the collected sets as the envelope's `dependencies` map with
+// deterministically sorted values, or nil when nothing was collected.
+func (collector *transformDependencyCollector) ToJSON() map[string][]string {
+  if len(collector.files) == 0 {
+    return nil
+  }
+  output := map[string][]string{}
+  for key, set := range collector.files {
+    if len(set) == 0 {
+      continue
+    }
+    values := make([]string, 0, len(set))
+    for value := range set {
+      values = append(values, value)
+    }
+    sort.Strings(values)
+    output[key] = values
+  }
+  if len(output) == 0 {
+    return nil
+  }
+  return output
 }
 
 type transformCompilerDiagnostic struct {
@@ -245,14 +442,6 @@ type transformCompilerDiagnostic struct {
   MessageText string  `json:"messageText"`
 }
 
-func sourceFileKey(cwd string, file string) string {
-  rel, err := filepath.Rel(cwd, filepath.FromSlash(file))
-  if err != nil {
-    return filepath.ToSlash(file)
-  }
-  return filepath.ToSlash(rel)
-}
-
 func transformDiagnosticToCompilerDiagnostic(diag typiaTransformDiagnostic) transformCompilerDiagnostic {
   var ptr *string
   if diag.File != "" {

package/native/cmd/ttsc-typia/{transform_declaration_source_produces_no_js_test.go → transform_declaration_source_produces_no_javascript_test.go}

@@ -10,17 +10,25 @@ import (
 	"testing"
 )
 
-// TestTransformDeclarationSourceProducesNoJS verifies JS transform reports empty emission.
+// TestTransformDeclarationSourceProducesNoJavaScript verifies JS transform reports empty emission.
 //
 // Declaration files can belong to the program while producing no JavaScript
 // output. The single-file transform path must detect that empty capture instead
 // of returning a successful but blank result.
 //
+// The file name deliberately spells out "javascript". Go reads a trailing `_js`
+// on a source file name as a `GOOS=js` build constraint, so under the earlier
+// name `..._produces_no_js_test.go` this case built only for `GOOS=js` -- where
+// `main.go` (`//go:build !js`) drops out and the test package does not compile
+// at all. It therefore ran on no platform whatsoever, and the tag it carries was
+// never the reason. Keep a `_js`, `_windows`, `_linux`, or `_darwin` ending off
+// a Go file name unless that constraint is meant.
+//
 // 1. Create a project that includes only a declaration source file.
 // 2. Run single-file transform with JavaScript output.
 // 3. Capture the command diagnostics.
 // 4. Assert the command reports that no output was produced.
-func TestTransformDeclarationSourceProducesNoJS(t *testing.T) {
+func TestTransformDeclarationSourceProducesNoJavaScript(t *testing.T) {
 	root := transformCoverageRepoRoot(t)
 	base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
 	if err := os.MkdirAll(base, 0o755); err != nil {

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

@@ -20,9 +20,19 @@ import (
 // directly, which makes transformer, adapter, and programmer code visible to
 // `-coverpkg`.
 //
+// The `_js` lane asserted the opposite of this until samchon/typia#2134 was
+// fixed: it required every fixture to report "no output produced". These
+// projects all set `rootDir`/`outDir`, and the old identity check compared whole
+// path stems, so it asked whether `dist/main` equaled `src/main` and never
+// found the artifact the emit had just written. Reading those exit 3s as the
+// specification turned this suite into the defect's own guard rail -- it would
+// have failed the repair -- and left the JS emit path it exists to cover
+// unreached, since the run stopped at the identity check.
+//
 // 1. Create isolated temporary TypeScript projects under the native package.
 // 2. Transform each project's `src/main.ts` to TypeScript output in memory.
-// 3. Exercise JavaScript single-file output error handling for synthetic projects.
+// 3. Transform each project's `src/main.ts` to JavaScript and require emitted
+//    CommonJS, which is what reaches the printer and the emit path.
 // 4. Cover reflect metadata, protobuf maps, and object-union emit paths.
 // 5. Run build/check/project-transform command paths against the same project.
 func TestTransformSyntheticEmitCoverage(t *testing.T) {
@@ -63,7 +73,7 @@ func TestTransformSyntheticEmitCoverage(t *testing.T) {
   for _, tc := range cases {
     tc := tc
     t.Run(tc.name+"_js", func(t *testing.T) {
-      _, errText, code := transformCoverageCapture(func() int {
+      out, errText, code := transformCoverageCapture(func() int {
         return runTransform([]string{
           "--cwd", projects[tc.name],
           "--tsconfig", "tsconfig.json",
@@ -71,8 +81,15 @@ func TestTransformSyntheticEmitCoverage(t *testing.T) {
           "--output", "js",
         })
       })
-      if code != 3 || !strings.Contains(errText, "no output produced") {
-        t.Fatalf("transform js should report no output for %s: code=%d stderr=\n%s", tc.name, code, errText)
+      if code != 0 {
+        t.Fatalf("transform js failed for %s: code=%d stderr=\n%s", tc.name, code, errText)
+      }
+      // These fixtures compile as `commonjs`, so a real emit is module-wrapped
+      // JavaScript. The lowering itself is pinned by the dedicated single-file
+      // `js` cases; what this lane adds is that every fixture's shape reaches
+      // the printer at all.
+      if !strings.Contains(out, `"use strict"`) || !strings.Contains(out, "exports.") {
+        t.Fatalf("transform js output for %s is not emitted CommonJS:\n%s", tc.name, out)
       }
     })
   }

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

@@ -3,12 +3,26 @@ package main
 import (
   "bytes"
   "os"
+  "os/exec"
   "path/filepath"
   "runtime"
   "strings"
   "testing"
 )
 
+func ttscTypiaTestTypecheck(t *testing.T, project string) {
+  t.Helper()
+  pnpm, err := exec.LookPath("pnpm")
+  if err != nil {
+    t.Skip("pnpm executable not found")
+  }
+  cmd := exec.Command(pnpm, "exec", "ttsc", "--noEmit", "-p", "tsconfig.json")
+  cmd.Dir = project
+  if output, err := cmd.CombinedOutput(); err != nil {
+    t.Fatalf("fixture typecheck failed: %v\n%s", err, output)
+  }
+}
+
 func ttscTypiaTestRepoRoot(t *testing.T) string {
   t.Helper()
   _, file, _, ok := runtime.Caller(0)
@@ -50,7 +64,10 @@ func ttscTypiaTestWriteCommonRuntimeStubs(t *testing.T, runtimeDir string) {
     "validate-report-stub.cjs":   ttscTypiaTestValidateReportStub,
     "standard-schema-stub.cjs":   ttscTypiaTestStandardSchemaStub,
     "assert-guard-stub.cjs":      ttscTypiaTestAssertGuardStub,
+    "functional-error-stub.cjs":  ttscTypiaTestFunctionalErrorStub,
     "access-expression-stub.cjs": ttscTypiaTestAccessExpressionStub,
+    "string-length-stub.cjs":     ttscTypiaTestStringLengthStub,
+    "notation-stub.cjs":          ttscTypiaTestNotationStub,
   }
   for name, content := range files {
     if err := os.WriteFile(filepath.Join(runtimeDir, name), []byte(content), 0o644); err != nil {
@@ -65,7 +82,16 @@ func ttscTypiaTestRewriteCommonJS(t *testing.T, js string) string {
   runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_validateReport")`, `require("./validate-report-stub.cjs")`)
   runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_createStandardSchema")`, `require("./standard-schema-stub.cjs")`)
   runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_assertGuard")`, `require("./assert-guard-stub.cjs")`)
+  runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_functionalTypeGuardErrorFactory")`, `require("./functional-error-stub.cjs")`)
   runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_accessExpressionAsString")`, `require("./access-expression-stub.cjs")`)
+  runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_stringLength")`, `require("./string-length-stub.cjs")`)
+  for _, helper := range []string{"_notationAssign", "_notationCamel", "_notationKebab", "_notationKeyCollision", "_notationPascal", "_notationSnake"} {
+    runtimeJS = strings.ReplaceAll(
+      runtimeJS,
+      `require("typia/lib/internal/`+helper+`")`,
+      `require("./notation-stub.cjs")`,
+    )
+  }
   for _, needle := range []string{`require("typia")`, `require('typia')`, `from "typia"`, `from 'typia'`, `typia/lib/internal/`} {
     if strings.Contains(runtimeJS, needle) {
       t.Fatalf("runtime module still contains unresolved typia import %q", needle)
@@ -75,10 +101,14 @@ func ttscTypiaTestRewriteCommonJS(t *testing.T, js string) string {
 }
 
 const ttscTypiaTestValidateReportStub = `module.exports._validateReport = (array) => {
+  const isAncestor = (ancestor, descendant) =>
+    descendant === ancestor ||
+    descendant.startsWith(ancestor + ".") ||
+    descendant.startsWith(ancestor + "[");
   const reportable = (path) => {
     if (array.length === 0) return true;
     const last = array[array.length - 1].path;
-    return path.length > last.length || last.substring(0, path.length) !== path;
+    return !isAncestor(path, last) && !isAncestor(last, path);
   };
   return (exceptable, error) => {
     if (exceptable && reportable(error.path)) {
@@ -108,6 +138,17 @@ const ttscTypiaTestAssertGuardStub = `module.exports._assertGuard = (exceptionab
 };
 `
 
+const ttscTypiaTestFunctionalErrorStub = `module.exports._functionalTypeGuardErrorFactory = (props) =>
+  Object.assign(new Error(props.expected), props);
+`
+
+const ttscTypiaTestStringLengthStub = `module.exports._stringLength = (value) => {
+  let count = 0;
+  for (const _ of value) ++count;
+  return count;
+};
+`
+
 const ttscTypiaTestAccessExpressionStub = `const reserved = new Set([
   "break",
   "case",
@@ -153,3 +194,120 @@ module.exports._accessExpressionAsString = (key) => {
     : "[" + JSON.stringify(key) + "]";
 };
 `
+
+// ttscTypiaTestNotationStub stands in for typia/lib/internal/_notation*, which
+// the emitted converter requires for dynamic (index-signature) keys.
+//
+// These tests assert that the statically emitted key and the runtime helper
+// agree, so this stub is that assertion's oracle and has to stay a faithful
+// transcription of packages/typia/src/internal/_notation{Camel,Pascal,Snake,
+// Kebab}.ts and private/__notationRename.ts — an approximation turns "emit ==
+// runtime" into "emit == whatever this file happens to say". Keep it a direct
+// transcription: same routing on underscore presence (not on segment count),
+// the same CamelizeSnakeString/PascalizeSnakeString recursions, and the same
+// per-segment case-boundary walk in snake. It deliberately uses string
+// concatenation rather than template literals because it is embedded in a Go
+// raw string literal, which is backtick-delimited.
+const ttscTypiaTestNotationStub = `const __notationRename = (props) => (str) => {
+  let prefix = "";
+  while (str.startsWith("_")) {
+    prefix += "_";
+    str = str.substring(1);
+  }
+  if (str.length === 0) return prefix;
+  return prefix + (str.includes("_") ? props.snake(str) : props.plain(str));
+};
+
+const _notationCamelSnake = (str) => {
+  while (str.startsWith("_")) str = str.substring(1);
+  if (str.length === 0) return "";
+  const index = str.indexOf("_");
+  if (index < 0) return str.toLowerCase();
+  const middle = str[index + 1];
+  if (middle === undefined) return str.toLowerCase();
+  return middle === "_"
+    ? _notationCamelSnake(str.substring(0, index) + "_" + str.substring(index + 2))
+    : str.substring(0, index).toLowerCase() +
+      middle.toUpperCase() +
+      _notationCamelSnake(str.substring(index + 2));
+};
+
+const _notationPascalSnake = (str) => {
+  while (str.startsWith("_")) str = str.substring(1);
+  if (str.length === 0) return "";
+  const index = str.indexOf("_");
+  return index < 0
+    ? str[0].toUpperCase() + str.substring(1).toLowerCase()
+    : str[0].toUpperCase() +
+      str.substring(1, index).toLowerCase() +
+      _notationPascalSnake(str.substring(index + 1));
+};
+
+const _notationSnakeWord = (str) => {
+  const indexes = [];
+  for (let i = 0; i < str.length; i++) {
+    const code = str.charCodeAt(i);
+    if (65 <= code && code <= 90) indexes.push(i);
+  }
+  for (let i = indexes.length - 1; i > 0; --i)
+    if (indexes[i] - indexes[i - 1] === 1) indexes.splice(i, 1);
+  if (indexes.length !== 0 && indexes[0] === 0) indexes.splice(0, 1);
+  if (indexes.length === 0) return str.toLowerCase();
+  let ret = "";
+  for (let i = 0; i < indexes.length; i++) {
+    ret += str.substring(i === 0 ? 0 : indexes[i - 1], indexes[i]).toLowerCase();
+    ret += "_";
+  }
+  ret += str.substring(indexes[indexes.length - 1]).toLowerCase();
+  return ret;
+};
+
+module.exports._notationCamel = __notationRename({
+  plain: (str) =>
+    str === str.toUpperCase()
+      ? str.toLowerCase()
+      : str[0].toLowerCase() + str.substring(1),
+  snake: _notationCamelSnake,
+});
+module.exports._notationPascal = __notationRename({
+  plain: (str) => str[0].toUpperCase() + str.substring(1),
+  snake: _notationPascalSnake,
+});
+module.exports._notationSnake = (str) => {
+  if (str.length === 0) return str;
+  let prefix = "";
+  for (let i = 0; i < str.length; i++) {
+    if (str[i] === "_") prefix += "_";
+    else break;
+  }
+  if (prefix.length !== 0) str = str.substring(prefix.length);
+  return prefix + str.split("_").map(_notationSnakeWord).join("_");
+};
+module.exports._notationKebab = (str) => {
+  let snaked = module.exports._notationSnake(str);
+  let prefix = "";
+  while (snaked.startsWith("_")) {
+    prefix += "_";
+    snaked = snaked.substring(1);
+  }
+  return prefix + snaked.replaceAll("_", "-");
+};
+module.exports._notationAssign = (output, sources, source, value, rename) => {
+  const destination = rename(source);
+  if (Object.hasOwn(output, destination))
+    module.exports._notationKeyCollision(sources[destination], source, destination);
+  Object.defineProperty(output, destination, {
+    configurable: true,
+    enumerable: true,
+    value,
+    writable: true,
+  });
+  sources[destination] = source;
+};
+module.exports._notationKeyCollision = (first, second, destination) => {
+  throw new Error(
+    "typia.notations cannot rename both " + JSON.stringify(first) +
+    " and " + JSON.stringify(second) + " to " + JSON.stringify(destination) + ".",
+  );
+};
+`