typia 13.0.0-dev.20260511 → 13.0.0-dev.20260519

package/README.md

@@ -1,4 +1,5 @@
 # Typia
+
 ![Typia Logo](https://typia.io/logo.png)
 
 [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/samchon/typia/blob/master/LICENSE)
@@ -57,7 +58,30 @@ export function random<T>(g?: Partial<IRandomGenerator>): T;
 > - JSON serialization is **200x faster** than `class-transformer`
 > - LLM function calling harness turns **6.75% → 100%** accuracy
 
+<!--
+## Setup
+
+Install `typia@next` with the [`ttsc`](https://github.com/samchon/ttsc) toolchain.
+
+```bash
+# install
+npm i typia@next
+npm i -D ttsc @typescript/native-preview
+
+# build
+npx ttsc
+
+# run a script directly
+npx ttsx src/index.ts
+```
+
+You **must** use `ttsc` and `ttsx`. The stock `tsc`, `ts-node`, and `tsx` cannot apply the `typia` transform, so they will not work.
+
+For bundler integration (Vite, Next.js, Webpack, Rollup, esbuild, ...), use [`@ttsc/unplugin`](https://github.com/samchon/ttsc/tree/master/packages/unplugin).
+-->
+
 ## Transformation
+
 If you call `typia` function, it would be compiled like below.
 
 This is the key concept of `typia`, transforming TypeScript type to a runtime function. The `typia.is<T>()` function is transformed to a dedicated type checker by analyzing the target type `T` in the compilation level.
@@ -80,37 +104,34 @@ export const checkString = (() => {
 })();
 ```
 
-
-
 ## Sponsors
-Thanks for your support.
-
-Your donation encourages `typia` development.
-
-Also, `typia` is re-distributing quarter of donations to [`nonara/ts-patch`](https://github.com/nonara/ts-patch).
-
-[![Sponsors](https://opencollective.com/typia/badge.svg?avatarHeight=75&width=600)](https://opencollective.com/typia)
 
+[![Backers](https://opencollective.com/typia/backers.svg?avatarHeight=75&width=600)](https://opencollective.com/typia)
 
+Thanks for your support.
 
+Your [donation](https://opencollective.com/typia) encourages `typia` development.
 
 ## Playground
-You can experience how typia works by [playground website](https://typia.io/playground):
-
-  - 💻 https://typia.io/playground
-
 
+You can experience how typia works by [playground website](https://typia.io/playground):
 
+- 💻 https://typia.io/playground
 
 ## Guide Documents
+
 Check out the document in the [website](https://typia.io/docs/):
 
 ### 🏠 Home
+
 - [Introduction](https://typia.io/docs/)
 - [Setup](https://typia.io/docs/setup/)
+  - [Legacy (TypeScript v6)](https://typia.io/docs/setup/legacy)
+  - [TSGO (TypeScript v7)](https://typia.io/docs/setup/tsgo)
 - [Pure TypeScript](https://typia.io/docs/pure/)
   
 ### 📖 Features
+
 - Runtime Validators
   - [`assert()` function](https://typia.io/docs/validators/assert/)
   - [`is()` function](https://typia.io/docs/validators/is/)
@@ -134,6 +155,7 @@ Check out the document in the [website](https://typia.io/docs/):
 - [Miscellaneous](https://typia.io/docs/misc/)
 
 ### 🔗 Appendix
+
 - [API Documents](https://typia.io/api)
 - Utilization Cases
   - [MCP](https://typia.io/docs/utilization/mcp/)
@@ -144,9 +166,6 @@ Check out the document in the [website](https://typia.io/docs/):
 - [⇲ Benchmark Result](https://github.com/samchon/typia/tree/master/benchmark/results/11th%20Gen%20Intel(R)%20Core(TM)%20i5-1135G7%20%40%202.40GHz)
 - [⇲ `dev.to` Articles](https://dev.to/samchon/series/22474)
 
-
-
-
 ## Inspired By
+
 - [`typescript-is`](https://github.com/woutervh-/typescript-is)
-- [`ts-patch`](https://github.com/nonara/ts-patch)

package/native/adapter/adapter.go

@@ -79,10 +79,20 @@ func emitCallWithOptions(program *driver.Program, site CallSite, plugin PluginOp
       }
     }
   }()
-  node := nativetransform.CallExpressionTransformer.Transform(nativetransform.CallExpressionTransformer_TransformProps{
-    Context:    context,
-    Expression: site.Call,
-  })
+  var node *shimast.Node
+  if site.Module != "" && site.Method != "" {
+    node = nativetransform.CallExpressionTransformer.TransformKnown(nativetransform.CallExpressionTransformer_TransformKnownProps{
+      Context:    context,
+      Expression: site.Call,
+      Module:     site.Module,
+      Method:     site.Method,
+    })
+  } else {
+    node = nativetransform.CallExpressionTransformer.Transform(nativetransform.CallExpressionTransformer_TransformProps{
+      Context:    context,
+      Expression: site.Call,
+    })
+  }
   if node == nil || node == site.Call.AsNode() {
     return "", false, nil
   }

package/native/adapter/imports.go

@@ -4,15 +4,25 @@ import (
   "path/filepath"
   "strconv"
   "strings"
+  "sync"
   "unicode"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
+type commonJSImportIdentifierSubstitutionsCacheEntry struct {
+  value map[string]string
+}
+
+var commonJSImportIdentifierSubstitutionsCache sync.Map
+
 func commonJSImportIdentifierSubstitutions(file *shimast.SourceFile) map[string]string {
   if file == nil || file.Statements == nil {
     return nil
   }
+  if cached, ok := commonJSImportIdentifierSubstitutionsCache.Load(file); ok {
+    return cached.(commonJSImportIdentifierSubstitutionsCacheEntry).value
+  }
   output := map[string]string{}
   counts := map[string]int{}
   for _, stmt := range file.Statements.Nodes {
@@ -61,8 +71,9 @@ func commonJSImportIdentifierSubstitutions(file *shimast.SourceFile) map[string]
     }
   }
   if len(output) == 0 {
-    return nil
+    output = nil
   }
+  commonJSImportIdentifierSubstitutionsCache.Store(file, commonJSImportIdentifierSubstitutionsCacheEntry{value: output})
   return output
 }
 

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

@@ -1,3 +1,5 @@
+//go:build !js
+
 package main
 
 import (

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

@@ -0,0 +1,226 @@
+//go:build js && wasm
+
+package main
+
+import (
+  "bytes"
+  "fmt"
+  "io"
+  "os"
+  "runtime"
+  "syscall/js"
+  "time"
+)
+
+// Reuse the same package-level identifiers the native CLI declares. Under
+// `js && wasm`, the native `main.go` is excluded, so we re-declare them here.
+var (
+  version = "0.1.0-dev"
+  commit  = "dev"
+  date    = "unknown"
+)
+
+var (
+  stdout io.Writer = os.Stdout
+  stderr io.Writer = os.Stderr
+)
+
+// main keeps the Go runtime alive forever after registering the JS entry
+// points. JS code calls `globalThis.ttscTypia.transform({...})` repeatedly;
+// each call reuses the same Go process (no re-instantiation cost).
+func main() {
+  api := map[string]any{
+    "transform": js.FuncOf(jsTransform),
+    "build":     js.FuncOf(jsBuild),
+    "version":   js.FuncOf(jsVersion),
+  }
+  js.Global().Set("ttscTypia", js.ValueOf(api))
+
+  // Signal readiness so the JS host can resolve a "ready" promise.
+  if ready := js.Global().Get("ttscTypiaReady"); ready.Type() == js.TypeFunction {
+    ready.Invoke()
+  }
+
+  // A perpetual idle goroutine prevents Go's wasm deadlock detector from
+  // tripping while syscall.fsCall callbacks are in flight. `select {}` alone
+  // is wrongly classified as "all goroutines asleep" the moment the FS path
+  // hands the request off to JS.
+  go func() {
+    for {
+      time.Sleep(time.Hour)
+    }
+  }()
+  select {}
+}
+
+// jsVersion returns the build metadata for this wasm binary.
+func jsVersion(this js.Value, args []js.Value) any {
+  return js.ValueOf(map[string]any{
+    "version": version,
+    "commit":  commit,
+    "date":    date,
+    "go":      runtime.Version(),
+    "goos":    runtime.GOOS,
+    "goarch":  runtime.GOARCH,
+  })
+}
+
+// jsTransform runs the project transform pipeline on a single file.
+//
+// JS input shape:
+//   {
+//     cwd:      string,   // absolute virtual path
+//     tsconfig: string,   // absolute path to tsconfig.json
+//     file?:    string,   // absolute path of the .ts file to rewrite. Omit
+//                         // for project-wide JSON output.
+//     output?:  "ts"|"js",
+//   }
+//
+// JS output: Promise<{ code: number, stdout: string, stderr: string }>.
+//
+// The handler returns a Promise so the JS event loop can drain while Go
+// services its own asynchronous file-system callbacks. Returning a synchronous
+// value would re-enter JS and deadlock on `fs.stat` callbacks.
+//
+// Caller is responsible for populating an in-memory filesystem (via the
+// `globalThis.fs` shim picked up by wasm_exec.js) with every path referenced
+// here before invoking transform.
+func jsTransform(this js.Value, args []js.Value) any {
+  if len(args) == 0 || args[0].Type() != js.TypeObject {
+    return errorPromise(2, "ttsc-typia: transform requires an options object")
+  }
+  argv := transformArgs(args[0])
+  return makePromise(func() any {
+    return runWithCapturedIO(func() int { return runTransform(argv) })
+  })
+}
+
+// jsBuild runs the project build pipeline. JS input mirrors jsTransform but
+// has no `file`/`output`. Returns a Promise.
+func jsBuild(this js.Value, args []js.Value) any {
+  if len(args) == 0 || args[0].Type() != js.TypeObject {
+    return errorPromise(2, "ttsc-typia: build requires an options object")
+  }
+  argv := buildArgs(args[0])
+  return makePromise(func() any {
+    return runWithCapturedIO(func() int { return runBuild(argv) })
+  })
+}
+
+// makePromise wraps a Go computation as a JS Promise. The returned object is
+// `new Promise((resolve, reject) => { ... })`. The executor synchronously
+// captures the callbacks; the work itself runs in a goroutine so the JS event
+// loop can drive `fs.stat` and friends to completion before we ask Go to
+// receive the callback.
+func makePromise(work func() any) js.Value {
+  var executor js.Func
+  executor = js.FuncOf(func(this js.Value, args []js.Value) any {
+    resolve := args[0]
+    reject := args[1]
+    go func() {
+      defer func() {
+        if r := recover(); r != nil {
+          err := js.Global().Get("Error").New(fmt.Sprintf("%v", r))
+          reject.Invoke(err)
+        }
+        executor.Release()
+      }()
+      resolve.Invoke(work())
+    }()
+    return nil
+  })
+  return js.Global().Get("Promise").New(executor)
+}
+
+func errorPromise(code int, message string) js.Value {
+  return makePromise(func() any { return errorResponse(code, message) })
+}
+
+func transformArgs(opts js.Value) []string {
+  out := []string{}
+  if v := stringProp(opts, "cwd"); v != "" {
+    out = append(out, "--cwd="+v)
+  }
+  if v := stringProp(opts, "tsconfig"); v != "" {
+    out = append(out, "--tsconfig="+v)
+  } else {
+    out = append(out, "--tsconfig=tsconfig.json")
+  }
+  if v := stringProp(opts, "file"); v != "" {
+    out = append(out, "--file="+v)
+  }
+  if v := stringProp(opts, "output"); v != "" {
+    out = append(out, "--output="+v)
+  } else {
+    out = append(out, "--output=ts")
+  }
+  return out
+}
+
+func buildArgs(opts js.Value) []string {
+  out := []string{}
+  if v := stringProp(opts, "cwd"); v != "" {
+    out = append(out, "--cwd="+v)
+  }
+  if v := stringProp(opts, "tsconfig"); v != "" {
+    out = append(out, "--tsconfig="+v)
+  } else {
+    out = append(out, "--tsconfig=tsconfig.json")
+  }
+  if outDir := stringProp(opts, "outDir"); outDir != "" {
+    out = append(out, "--outDir="+outDir)
+  }
+  if boolProp(opts, "emit") {
+    out = append(out, "--emit")
+  }
+  if boolProp(opts, "noEmit") {
+    out = append(out, "--noEmit")
+  }
+  return out
+}
+
+func runWithCapturedIO(task func() int) any {
+  // Swap the package-level writers so the inner Go functions feel like a
+  // normal CLI invocation but their output lands in JS-visible buffers.
+  // This is safe under the contract that JS calls are serialized (no
+  // concurrent invocations from JS).
+  oldOut, oldErr := stdout, stderr
+  var outBuf, errBuf bytes.Buffer
+  stdout = &outBuf
+  stderr = &errBuf
+  defer func() {
+    stdout = oldOut
+    stderr = oldErr
+  }()
+
+  code := task()
+  return js.ValueOf(map[string]any{
+    "code":   code,
+    "stdout": outBuf.String(),
+    "stderr": errBuf.String(),
+  })
+}
+
+func errorResponse(code int, message string) any {
+  return js.ValueOf(map[string]any{
+    "code":   code,
+    "stdout": "",
+    "stderr": fmt.Sprintf("%s\n", message),
+  })
+}
+
+func stringProp(obj js.Value, key string) string {
+  v := obj.Get(key)
+  if v.Type() != js.TypeString {
+    return ""
+  }
+  return v.String()
+}
+
+func boolProp(obj js.Value, key string) bool {
+  v := obj.Get(key)
+  if v.Type() != js.TypeBoolean {
+    return false
+  }
+  return v.Bool()
+}

package/native/core/factories/MetadataFactory.go

@@ -29,6 +29,24 @@ func init() {
       Explore: props.Explore,
     })
   }
+  nativemetadata.MetadataCommentTagAnalyzer = func(props struct {
+    Errors   *[]nativemetadata.MetadataFactory_IError
+    Metadata *schemametadata.MetadataSchema
+    Tags     []schemametadata.IJsDocTagInfo
+    Explore  nativemetadata.MetadataFactory_IExplore
+  }) {
+    MetadataCommentTagFactory.Analyze(struct {
+      Errors   *[]MetadataFactory_IError
+      Metadata *schemametadata.MetadataSchema
+      Tags     []schemametadata.IJsDocTagInfo
+      Explore  MetadataFactory_IExplore
+    }{
+      Errors:   props.Errors,
+      Metadata: props.Metadata,
+      Tags:     props.Tags,
+      Explore:  props.Explore,
+    })
+  }
 }
 
 type MetadataFactory_Validator = func(props struct {

package/native/core/factories/internal/metadata/IMetadataIteratorProps.go

@@ -54,3 +54,10 @@ var MetadataTypeTagAnalyzer func(props struct {
   Objects []*schemametadata.MetadataObjectType
   Explore MetadataFactory_IExplore
 }) []schemametadata.IMetadataTypeTag
+
+var MetadataCommentTagAnalyzer func(props struct {
+  Errors   *[]MetadataFactory_IError
+  Metadata *schemametadata.MetadataSchema
+  Tags     []schemametadata.IJsDocTagInfo
+  Explore  MetadataFactory_IExplore
+})

package/native/core/factories/internal/metadata/MetadataHelper.go

@@ -5,6 +5,7 @@ import (
 
   nativeast "github.com/microsoft/typescript-go/shim/ast"
   nativechecker "github.com/microsoft/typescript-go/shim/checker"
+  nativescanner "github.com/microsoft/typescript-go/shim/scanner"
   schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
@@ -133,6 +134,12 @@ func metadata_node_js_doc_tags(symbol *nativeast.Symbol) []schemametadata.IJsDoc
             Text: name,
           })
         }
+        if text := metadata_js_doc_type_expression_text(tag); text != "" {
+          texts = append(texts, schemametadata.IJsDocTagInfo_IText{
+            Kind: "text",
+            Text: text,
+          })
+        }
         if text := metadata_js_doc_comment_text(tag.CommentList()); text != "" {
           texts = append(texts, schemametadata.IJsDocTagInfo_IText{
             Kind: "text",
@@ -194,11 +201,39 @@ func metadata_js_doc_parameter_name(tag *nativeast.Node) string {
   if tag.Kind.String() != "KindJSDocParameterTag" && tag.Kind.String() != "KindJSDocPropertyTag" {
     return ""
   }
-  name := tag.AsJSDocParameterOrPropertyTag().Name()
-  if name == nil {
+  // `name` is a DeclarationName: typically an Identifier, but for nested
+  // JSDoc parameter names like `@param obj.field description` the parser
+  // produces a QualifiedName, and upstream's (*Node).Text() panics with
+  // `Unhandled case in Node.Text: *ast.QualifiedName` if we call .Text()
+  // directly. NodeText in the ttsc shim covers QualifiedName and any
+  // other DeclarationName Kind that upstream's switch doesn't.
+  return nativeast.NodeText(tag.AsJSDocParameterOrPropertyTag().Name())
+}
+
+func metadata_js_doc_type_expression_text(tag *nativeast.Node) string {
+  if tag == nil {
+    return ""
+  }
+  switch tag.Kind {
+  case nativeast.KindJSDocTypeTag,
+    nativeast.KindJSDocParameterTag,
+    nativeast.KindJSDocPropertyTag,
+    nativeast.KindJSDocReturnTag,
+    nativeast.KindJSDocTypedefTag,
+    nativeast.KindJSDocSatisfiesTag,
+    nativeast.KindJSDocThrowsTag:
+  default:
+    return ""
+  }
+  expr := tag.TypeExpression()
+  if expr == nil {
+    return ""
+  }
+  typ := expr.Type()
+  if typ == nil {
     return ""
   }
-  return name.Text()
+  return metadata_clean_js_doc_text(nativescanner.GetTextOfNode(typ))
 }
 
 func metadata_js_doc_comment_text(list *nativeast.NodeList) string {

package/native/core/factories/internal/metadata/iterate_metadata_comment_tags.go

@@ -6,15 +6,29 @@ func Iterate_metadata_comment_tags(props struct {
   Errors *[]MetadataFactory_IError
   Object *schemametadata.MetadataObjectType
 }) {
-  if props.Object == nil || props.Object.Tagged_ == true {
+  if props.Object == nil || props.Object.Tagged_ == true || MetadataCommentTagAnalyzer == nil {
     return
   }
   props.Object.Tagged_ = true
 
   for _, property := range props.Object.Properties {
-    _ = property
-    // JSDoc extraction through the TypeScript-Go shim is not yet complete.
-    // The traversal point is kept in the original file location so the
-    // MetadataCommentTagFactory port can be wired without changing callers.
+    if property == nil || property.Value == nil || len(property.JsDocTags) == 0 {
+      continue
+    }
+    MetadataCommentTagAnalyzer(struct {
+      Errors   *[]MetadataFactory_IError
+      Metadata *schemametadata.MetadataSchema
+      Tags     []schemametadata.IJsDocTagInfo
+      Explore  MetadataFactory_IExplore
+    }{
+      Errors:   props.Errors,
+      Metadata: property.Value,
+      Tags:     property.JsDocTags,
+      Explore: MetadataFactory_IExplore{
+        Top:      false,
+        Object:   props.Object,
+        Property: property,
+      },
+    })
   }
 }

package/native/go.work

@@ -0,0 +1,22 @@
+go 1.26
+
+use (
+	.
+	../../../../ttsc/packages/ttsc
+	../../../../ttsc/packages/ttsc/shim/ast
+	../../../../ttsc/packages/ttsc/shim/bundled
+	../../../../ttsc/packages/ttsc/shim/checker
+	../../../../ttsc/packages/ttsc/shim/compiler
+	../../../../ttsc/packages/ttsc/shim/core
+	../../../../ttsc/packages/ttsc/shim/diagnosticwriter
+	../../../../ttsc/packages/ttsc/shim/parser
+	../../../../ttsc/packages/ttsc/shim/printer
+	../../../../ttsc/packages/ttsc/shim/scanner
+	../../../../ttsc/packages/ttsc/shim/tsoptions
+	../../../../ttsc/packages/ttsc/shim/tspath
+	../../../../ttsc/packages/ttsc/shim/vfs
+	../../../../ttsc/packages/ttsc/shim/vfs/cachedvfs
+	../../../../ttsc/packages/ttsc/shim/vfs/osvfs
+)
+
+replace github.com/samchon/ttsc/packages/ttsc v0.0.0 => ../../../../ttsc/packages/ttsc

package/native/transform/CallExpressionTransformer.go

@@ -29,10 +29,19 @@ type CallExpressionTransformer_TransformProps struct {
   Expression *shimast.CallExpression
 }
 
+type CallExpressionTransformer_TransformKnownProps struct {
+  Context    nativecontext.ITypiaContext
+  Expression *shimast.CallExpression
+  Module     string
+  Method     string
+}
+
 type callExpressionTransformerTask func(props ITransformProps) *shimast.Node
 
 type callExpressionTransformerFunctor func() callExpressionTransformerTask
 
+var callExpressionTransformer_functors = callExpressionTransformer_createFunctors()
+
 func (callExpressionTransformerNamespace) Transform(props CallExpressionTransformer_TransformProps) *shimast.Node {
   if props.Expression == nil {
     return nil
@@ -59,8 +68,20 @@ func (callExpressionTransformerNamespace) Transform(props CallExpressionTransfor
     return props.Expression.AsNode()
   }
   name := typ.Symbol().Name
+  return CallExpressionTransformer.TransformKnown(CallExpressionTransformer_TransformKnownProps{
+    Context:    props.Context,
+    Expression: props.Expression,
+    Module:     module,
+    Method:     name,
+  })
+}
+
+func (callExpressionTransformerNamespace) TransformKnown(props CallExpressionTransformer_TransformKnownProps) *shimast.Node {
+  if props.Expression == nil {
+    return nil
+  }
   functors := callExpressionTransformer_FUNCTORS()
-  functor, ok := functors[module][name]
+  functor, ok := functors[props.Module][props.Method]
   if ok == false {
     return props.Expression.AsNode()
   }
@@ -101,6 +122,10 @@ func callExpressionTransformer_sourceFile(node *shimast.Node) *shimast.SourceFil
 }
 
 func callExpressionTransformer_FUNCTORS() map[string]map[string]callExpressionTransformerFunctor {
+  return callExpressionTransformer_functors
+}
+
+func callExpressionTransformer_createFunctors() map[string]map[string]callExpressionTransformerFunctor {
   return map[string]map[string]callExpressionTransformerFunctor{
     "module": {
       "assert": func() callExpressionTransformerTask {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "13.0.0-dev.20260511",
+  "version": "13.0.0-dev.20260519",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "exports": {
@@ -44,8 +44,8 @@
     "commander": "^10.0.0",
     "inquirer": "^8.2.5",
     "randexp": "^0.5.3",
-    "@typia/interface": "^13.0.0-dev.20260511",
-    "@typia/utils": "^13.0.0-dev.20260511"
+    "@typia/interface": "^13.0.0-dev.20260519",
+    "@typia/utils": "^13.0.0-dev.20260519"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^29.0.0",
@@ -54,7 +54,7 @@
     "@types/node": "^25.3.0",
     "@typescript-eslint/eslint-plugin": "^8.1.0",
     "@typescript-eslint/parser": "^8.1.0",
-    "@typescript/native-preview": "7.0.0-dev.20260510.1",
+    "@typescript/native-preview": "7.0.0-dev.20260518.1",
     "chalk": "^4.0.0",
     "eslint-plugin-deprecation": "^3.0.0",
     "rimraf": "^6.1.2",
@@ -63,7 +63,7 @@
     "rollup-plugin-node-externals": "^8.1.2",
     "suppress-warnings": "^1.0.2",
     "tinyglobby": "^0.2.12",
-    "ttsc": "^0.10.0"
+    "ttsc": "^0.12.3"
   },
   "sideEffects": [
     "./lib/_virtual/*.mjs",