typia 15.1.0 → 15.2.0

package/native/transform/features/llm/LlmParseTransformer.go

@@ -14,7 +14,7 @@ type llmParseTransformerNamespace struct{}
 var LlmParseTransformer = llmParseTransformerNamespace{}
 
 func (llmParseTransformerNamespace) Transform(props nativetransform.ITransformProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(llmTransformer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   llmTransformer_require_argument(props, "typia.llm.parse", 0, "no input value.")
   top, typ, ok := llmTransformer_type_argument(props, "typia.llm.parse")
   if ok == false {

package/native/transform/features/llm/LlmSchemaTransformer.go

@@ -17,10 +17,8 @@ type llmSchemaTransformerNamespace struct{}
 
 var LlmSchemaTransformer = llmSchemaTransformerNamespace{}
 
-var llmTransformer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (llmSchemaTransformerNamespace) Transform(props nativetransform.ITransformProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(llmTransformer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   top, typ, ok := llmTransformer_type_argument(props, "typia.llm.schema")
   if ok == false {
     return props.Expression.AsNode()

package/native/transform/features/reflect/ReflectNameTransformer.go

@@ -13,10 +13,8 @@ type reflectNameTransformerNamespace struct{}
 
 var ReflectNameTransformer = reflectNameTransformerNamespace{}
 
-var reflectNameTransformer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (reflectNameTransformerNamespace) Transform(props nativetransform.ITransformProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(reflectNameTransformer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   if props.Expression == nil || props.Expression.TypeArguments == nil || len(props.Expression.TypeArguments.Nodes) == 0 {
     panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{
       Code:    "typia.reflect.metadata",

package/native/transform/file_transformer_coverage_test.go

@@ -11,6 +11,7 @@ import (
   shimcore "github.com/microsoft/typescript-go/shim/core"
   shimparser "github.com/microsoft/typescript-go/shim/parser"
   shimprinter "github.com/microsoft/typescript-go/shim/printer"
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
   nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
 )
 
@@ -32,7 +33,7 @@ import (
 // @evidence contracts/testing.md#execution-ownership The typia_native_internal Go command (go -C packages/typia/test test -tags typia_native_internal ../native/...) runs this same-package Test function in process. The tagged test parses in-memory sources with the typescript-go parser, with no filesystem fixture or process.
 func TestFileTransformerCoverage(t *testing.T) {
   file := shimparser.ParseSourceFile(
-    shimast.SourceFileParseOptions{FileName: filepath.ToSlash(filepath.Join(t.TempDir(), "file.ts"))},
+    shimast.SourceFileParseOptions{FileName: shimtspath.RootedFilePath(filepath.ToSlash(filepath.Join(t.TempDir(), "file.ts")))},
     `"use strict";
 export const value = 1;
 `,

package/native/transform/internal/GenericTransformer.go

@@ -90,10 +90,8 @@ type GenericTransformer_IProps struct {
   Write func(props nativecontext.IProgrammerProps) *shimast.Node
 }
 
-var genericTransformer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (genericTransformerNamespace) Scalar(props GenericTransformer_IProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(genericTransformer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   if props.Expression == nil || props.Expression.Arguments == nil || len(props.Expression.Arguments.Nodes) == 0 {
     panic(NewTransformerError(TransformerError_IProps{
       Code:    "typia." + props.Method,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "15.1.0",
+  "version": "15.2.0",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "exports": {
@@ -43,11 +43,11 @@
   "homepage": "https://typia.io",
   "dependencies": {
     "randexp": "^0.5.3",
-    "@typia/interface": "^15.1.0",
-    "@typia/utils": "^15.1.0"
+    "@typia/interface": "^15.2.0",
+    "@typia/utils": "^15.2.0"
   },
   "peerDependencies": {
-    "ttsc": ">=0.19.2"
+    "ttsc": ">=0.34.1"
   },
   "peerDependenciesMeta": {
     "ttsc": {
@@ -58,8 +58,8 @@
     "@types/node": "^25.3.0",
     "rimraf": "^6.1.2",
     "rolldown": "^1.1.5",
-    "ttsc": "^0.30.4",
-    "typescript": "^7.0.2"
+    "ttsc": "^0.34.1",
+    "typescript": "7.1.0-dev.20261020.3"
   },
   "sideEffects": false,
   "files": [

package/src/transform.ts

@@ -9,13 +9,16 @@ import type { ITtscPlugin, ITtscPluginFactoryContext } from "ttsc";
  * resolver is anchored on the consuming project to find typia's own package
  * root. The returned descriptor names the plugin and the Go command under
  * `native/cmd/ttsc-typia`; the transform itself is not written in TypeScript.
+ * No file is read outside the module graph. Ttsc records the package
+ * resolution, so an empty hostInputHashes declaration permits safe descriptor
+ * replay.
  *
  * @param context Plugin factory context of ttsc
  *
  * @returns Plugin descriptor
  *
- * @evidence contracts/common.md#principled-implementation The ttsc loader runs this file as an ES module where `require` is absent, so the function builds a CommonJS resolver anchored at the consuming project and resolves typia's own `package.json`, whose directory holds the native sources; the returned descriptor names the plugin and the Go command directory under `native/cmd/ttsc-typia`.
- * @evidence contracts/common.md#clear-and-simple-design One function that returns a two-field descriptor and no transformer; the default export repeats the same function for loaders that read it.
+ * @evidence contracts/common.md#principled-implementation The ttsc loader runs this file as an ES module where `require` is absent, so the function builds a CommonJS resolver anchored at the consuming project and resolves typia's own `package.json`, whose directory holds the native sources. No external file is read; ttsc records that module lookup and invalidates descriptor replay when its module graph or factory inputs change. The descriptor names the plugin and Go command under `native/cmd/ttsc-typia`.
+ * @evidence contracts/common.md#clear-and-simple-design One function returns the plugin name, Go source and external-input declaration; the default export repeats the same function for loaders that read it.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts The package root comes from the installed typia through the supported resolver and not from path substrings, so it works for npm consumers and workspaces alike; the transform itself stays in Go.
  * @evidence contracts/common.md#meaningful-documentation A comment explains the purpose, the ESM resolution reason and the descriptor.
  */
@@ -32,6 +35,7 @@ export function createTtscPlugin(
   return {
     name: "typia",
     source: path.resolve(root, "native", "cmd", "ttsc-typia"),
+    hostInputHashes: {},
   };
 }