@nestia/core 12.0.0-dev.20260601.1 → 12.0.0-dev.20260612.2

package/native/transform/core_transform.go

@@ -1,1713 +1,1996 @@
-package transform
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"regexp"
-	"runtime/debug"
-	"sort"
-	"strconv"
-	"strings"
-	"sync"
-	"unicode"
-
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	shimchecker "github.com/microsoft/typescript-go/shim/checker"
-	shimscanner "github.com/microsoft/typescript-go/shim/scanner"
-	"github.com/samchon/nestia/packages/core/native/plugin"
-	"github.com/samchon/ttsc/packages/ttsc/driver"
-	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
-	nativeprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers"
-	nativehttp "github.com/samchon/typia/packages/typia/native/core/programmers/http"
-	nativejson "github.com/samchon/typia/packages/typia/native/core/programmers/json"
-	nativellm "github.com/samchon/typia/packages/typia/native/core/programmers/llm"
-	nativemisc "github.com/samchon/typia/packages/typia/native/core/programmers/misc"
-	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
-)
-
-type nestiaCoreOptions struct {
-	Validate      string
-	Stringify     string
-	StringifyNull bool
-	Llm           bool
-	LlmStrict     bool
-}
-
-type nestiaCoreSite struct {
-	File      *shimast.SourceFile
-	FilePath  string
-	Call      *shimast.CallExpression
-	Modulo    *shimast.Node
-	Kind      string
-	Type      *shimchecker.Type
-	ArgCount  int
-	Segments  []string
-	Arguments []string
-}
-
-type nestiaCoreTransformState struct {
-	prog        *driver.Program
-	options     nestiaCoreOptions
-	cache       map[nestiaCoreCacheKey][]string
-	cacheHits   int
-	cacheMisses int
-}
-
-type nestiaCoreCacheKey struct {
-	Kind          string
-	Type          *shimchecker.Type
-	TypeName      string
-	Modulo        string
-	Validate      string
-	Stringify     string
-	StringifyNull bool
-	Llm           bool
-	LlmStrict     bool
-	ArgCount      int
-	AllowOptional bool
-}
-
-func newNestiaCoreTransformState(prog *driver.Program, options nestiaCoreOptions) *nestiaCoreTransformState {
-	return &nestiaCoreTransformState{
-		prog:    prog,
-		options: options,
-		cache:   map[nestiaCoreCacheKey][]string{},
-	}
-}
-
-var nestiaCoreFactory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
-const NestiaCoreKindDecorator = shimast.KindDecorator
-
-type nestiaCoreFileContext struct {
-	file        *shimast.SourceFile
-	coreImports map[string]string
-}
-
-func readNestiaCoreOptions(plan plugin.Plan) nestiaCoreOptions {
-	options := nestiaCoreOptions{}
-	for _, entry := range plan.Entries {
-		if entry.Name != "@nestia/core" && !strings.Contains(entry.Transform, "@nestia/core") {
-			continue
-		}
-		if value, ok := entry.Config["validate"].(string); ok {
-			options.Validate = value
-		}
-		if value, ok := entry.Config["stringify"]; ok {
-			if value == nil {
-				options.StringifyNull = true
-			} else if text, ok := value.(string); ok {
-				options.Stringify = text
-			}
-		}
-		if value, ok := entry.Config["llm"]; ok {
-			switch v := value.(type) {
-			case bool:
-				options.Llm = v
-			case map[string]any:
-				options.Llm = true
-				if strict, ok := v["strict"].(bool); ok {
-					options.LlmStrict = strict
-				}
-			}
-		}
-	}
-	return options
-}
-
-func collectNestiaCoreSourceRewriteMap(
-	prog *driver.Program,
-	plan plugin.Plan,
-	onlyFile string,
-) (map[string][]SourceRewrite, []Diagnostic) {
-	if plan.Core == false {
-		return map[string][]SourceRewrite{}, nil
-	}
-	options := readNestiaCoreOptions(plan)
-	sites, diagnostics := collectNestiaCoreSites(newNestiaCoreTransformState(prog, options))
-	rewrites := map[string][]SourceRewrite{}
-	for _, site := range sites {
-		if onlyFile != "" && filepath.ToSlash(site.FilePath) != filepath.ToSlash(onlyFile) {
-			continue
-		}
-		source, ok := SourceFileText(site.File)
-		if !ok {
-			diagnostics = append(diagnostics, nestiaCoreDiagnostic(site, "source text is unavailable"))
-			continue
-		}
-		open, close, ok := callArgumentBounds(source, site.Call)
-		if !ok {
-			diagnostics = append(diagnostics, nestiaCoreDiagnostic(site, "failed to locate decorator arguments"))
-			continue
-		}
-		replacement := appendArgumentsText(source[open+1:close], site.Arguments)
-		rewrites[filepath.ToSlash(site.FilePath)] = append(rewrites[filepath.ToSlash(site.FilePath)], SourceRewrite{
-			start:       open + 1,
-			end:         close,
-			replacement: replacement,
-		})
-	}
-	return rewrites, diagnostics
-}
-
-func collectNestiaCoreBuildRewrites(
-	prog *driver.Program,
-	plan plugin.Plan,
-	rewrites *nativeRewriteSet,
-) []Diagnostic {
-	if plan.Core == false {
-		return nil
-	}
-	options := readNestiaCoreOptions(plan)
-	sites, diagnostics := collectNestiaCoreSites(newNestiaCoreTransformState(prog, options))
-	for _, site := range sites {
-		expectedArgumentCount := site.ArgCount
-		expectedArgumentsText := nestiaCoreStableOriginalArgumentText(site)
-		rewrites.Add(nativeRewrite{
-			FilePath:                   site.FilePath,
-			RootName:                   site.Segments[0],
-			Namespaces:                 site.Segments[1:],
-			AppendArguments:            site.Arguments,
-			TargetExpressionCandidates: nestiaCoreTargetCandidates(prog, site),
-			SourceStart:                site.Call.AsNode().Pos(),
-			ExpectedArgumentCount:      &expectedArgumentCount,
-			ExpectedArgumentsText:      expectedArgumentsText,
-		})
-	}
-	return diagnostics
-}
-
-func nestiaCoreOriginalArgumentText(site nestiaCoreSite) string {
-	source, ok := SourceFileText(site.File)
-	if !ok {
-		return ""
-	}
-	open, close, ok := callArgumentBounds(source, site.Call)
-	if !ok {
-		return ""
-	}
-	return strings.TrimSpace(source[open+1 : close])
-}
-
-func nestiaCoreStableOriginalArgumentText(site nestiaCoreSite) string {
-	text := nestiaCoreOriginalArgumentText(site)
-	if strings.Contains(text, "=>") || strings.Contains(text, "function") {
-		return ""
-	}
-	return text
-}
-
-func collectNestiaCoreSites(state *nestiaCoreTransformState) ([]nestiaCoreSite, []Diagnostic) {
-	sites := []nestiaCoreSite{}
-	diagnostics := []Diagnostic{}
-	prog := state.prog
-	if nestiaCoreStrictMode(prog) == false {
-		diagnostics = append(diagnostics, nestiaCoreGlobalDiagnostic("@nestia/core", "strict mode is required."))
-	}
-	for _, file := range prog.SourceFiles() {
-		if file == nil || file.IsDeclarationFile {
-			continue
-		}
-		context := newNestiaCoreFileContext(file)
-		file.ForEachChild(func(node *shimast.Node) bool {
-			visitNestiaCoreNode(state, context, node, &sites, &diagnostics)
-			return false
-		})
-	}
-	if os.Getenv("TTSC_NESTIA_PROFILE") != "" {
-		fmt.Fprintf(stderr, "ttsc-nestia profile: core-cache hits=%d misses=%d\n", state.cacheHits, state.cacheMisses)
-	}
-	return sites, diagnostics
-}
-
-func visitNestiaCoreNode(
-	state *nestiaCoreTransformState,
-	context nestiaCoreFileContext,
-	node *shimast.Node,
-	sites *[]nestiaCoreSite,
-	diagnostics *[]Diagnostic,
-) {
-	if node == nil {
-		return
-	}
-	switch node.Kind {
-	case shimast.KindParameter:
-		decorators := node.Decorators()
-		if len(decorators) == 0 {
-			break
-		}
-		type candidate struct {
-			decorator *shimast.Node
-			call      *shimast.CallExpression
-			segments  []string
-			kind      string
-		}
-		candidates := []candidate{}
-		for _, decorator := range decorators {
-			call, segments, ok := nestiaCoreRawDecoratorCall(decorator)
-			if !ok {
-				continue
-			}
-			canonical := nestiaCoreCanonicalSegments(context, segments)
-			kind := nestiaCoreParameterKind(canonical)
-			if kind == "" || nestiaCoreDecoratorReference(state.prog, context, decorator, segments, canonical) == false {
-				continue
-			}
-			candidates = append(candidates, candidate{
-				decorator: decorator,
-				call:      call,
-				segments:  segments,
-				kind:      kind,
-			})
-		}
-		if len(candidates) == 0 {
-			break
-		}
-		typ := state.prog.Checker.GetTypeAtLocation(node)
-		for _, candidate := range candidates {
-			site, ok, err := transformNestiaCoreParameterDecorator(
-				state,
-				context.file,
-				candidate.call,
-				candidate.segments,
-				candidate.kind,
-				typ,
-			)
-			if err != nil {
-				*diagnostics = append(*diagnostics, nestiaCoreDiagnostic(site, err.Error()))
-			} else if ok {
-				*sites = append(*sites, site)
-			}
-		}
-	case shimast.KindMethodDeclaration:
-		decorators := node.Decorators()
-		if len(decorators) == 0 {
-			break
-		}
-		type candidate struct {
-			call     *shimast.CallExpression
-			segments []string
-			kind     string
-		}
-		candidates := []candidate{}
-		for _, decorator := range decorators {
-			call, segments, ok := nestiaCoreRawDecoratorCall(decorator)
-			if !ok {
-				continue
-			}
-			canonical := nestiaCoreCanonicalSegments(context, segments)
-			if nestiaCoreDecoratorReference(state.prog, context, decorator, segments, canonical) == false {
-				continue
-			}
-			if len(canonical) != 0 && canonical[len(canonical)-1] == "WebSocketRoute" {
-				*diagnostics = append(*diagnostics, validateNestiaCoreWebSocketRoute(state.prog, context, node, call, canonical)...)
-			}
-			kind := nestiaCoreMethodKind(canonical)
-			if kind == "" || nestiaCoreShouldSkipMethodDecorator(state.prog, call) {
-				continue
-			}
-			candidates = append(candidates, candidate{
-				call:     call,
-				segments: segments,
-				kind:     kind,
-			})
-		}
-		if len(candidates) == 0 {
-			break
-		}
-		typ := NestiaCoreMethodReturnType(state.prog, node)
-		if typ != nil {
-			for _, candidate := range candidates {
-				site, ok, err := transformNestiaCoreMethodDecorator(
-					state,
-					context.file,
-					candidate.call,
-					candidate.segments,
-					candidate.kind,
-					typ,
-				)
-				if err != nil {
-					*diagnostics = append(*diagnostics, nestiaCoreDiagnostic(site, err.Error()))
-				} else if ok {
-					*sites = append(*sites, site)
-				}
-			}
-		}
-	}
-	node.ForEachChild(func(child *shimast.Node) bool {
-		visitNestiaCoreNode(state, context, child, sites, diagnostics)
-		return false
-	})
-}
-
-func transformNestiaCoreParameterDecorator(
-	state *nestiaCoreTransformState,
-	file *shimast.SourceFile,
-	call *shimast.CallExpression,
-	segments []string,
-	kind string,
-	typ *shimchecker.Type,
-) (nestiaCoreSite, bool, error) {
-	modulo := nestiaCoreModuloNode(call.Expression)
-	arguments, ok, err := state.parameterArguments(call, segments, modulo, kind, typ)
-	if err != nil || !ok {
-		return nestiaCoreSite{
-			File:     file,
-			FilePath: file.FileName(),
-			Call:     call,
-			Modulo:   modulo,
-			Kind:     kind,
-			Type:     typ,
-			Segments: segments,
-		}, ok, err
-	}
-	return nestiaCoreSite{
-		File:      file,
-		FilePath:  file.FileName(),
-		Call:      call,
-		Modulo:    modulo,
-		Kind:      kind,
-		Type:      typ,
-		ArgCount:  nestiaCoreArgumentCount(call),
-		Segments:  segments,
-		Arguments: arguments,
-	}, true, nil
-}
-
-func transformNestiaCoreMethodDecorator(
-	state *nestiaCoreTransformState,
-	file *shimast.SourceFile,
-	call *shimast.CallExpression,
-	segments []string,
-	kind string,
-	typ *shimchecker.Type,
-) (nestiaCoreSite, bool, error) {
-	modulo := nestiaCoreModuloNode(call.Expression)
-	arguments, err := state.methodArguments(file, segments, modulo, kind, typ, nestiaCoreArgumentCount(call))
-	if err != nil {
-		return nestiaCoreSite{
-			File:     file,
-			FilePath: file.FileName(),
-			Call:     call,
-			Modulo:   modulo,
-			Kind:     kind,
-			Type:     typ,
-			Segments: segments,
-		}, false, err
-	}
-	return nestiaCoreSite{
-		File:      file,
-		FilePath:  file.FileName(),
-		Call:      call,
-		Modulo:    modulo,
-		Kind:      kind,
-		Type:      typ,
-		ArgCount:  nestiaCoreArgumentCount(call),
-		Segments:  segments,
-		Arguments: arguments,
-	}, true, nil
-}
-
-func (state *nestiaCoreTransformState) parameterArguments(
-	call *shimast.CallExpression,
-	segments []string,
-	modulo *shimast.Node,
-	kind string,
-	typ *shimchecker.Type,
-) ([]string, bool, error) {
-	key := state.cacheKey(segments, kind, typ, nestiaCoreArgumentCount(call), kind == "TypedQuery")
-	return state.cachedArguments(key, func() ([]string, bool, error) {
-		return nestiaCoreParameterArguments(state.prog, state.options, call, modulo, kind, typ)
-	})
-}
-
-func (state *nestiaCoreTransformState) methodArguments(
-	file *shimast.SourceFile,
-	segments []string,
-	modulo *shimast.Node,
-	kind string,
-	typ *shimchecker.Type,
-	argCount int,
-) ([]string, error) {
-	key := state.cacheKey(segments, kind, typ, argCount, kind == "TypedQueryRoute")
-	arguments, _, err := state.cachedArguments(key, func() ([]string, bool, error) {
-		arg, err := safeNestiaCoreGenerate(func() (*shimast.Node, error) {
-			switch kind {
-			case "TypedQueryRoute":
-				return nestiaCoreGenerateTypedQueryRoute(state.prog, state.options, modulo, typ), nil
-			default:
-				return nestiaCoreGenerateTypedRoute(state.prog, state.options, modulo, typ), nil
-			}
-		}, state.prog, file, false)
-		if err != nil {
-			return nil, false, err
-		}
-		return []string{arg}, true, nil
-	})
-	return arguments, err
-}
-
-func (state *nestiaCoreTransformState) cachedArguments(
-	key nestiaCoreCacheKey,
-	generate func() ([]string, bool, error),
-) ([]string, bool, error) {
-	if cached, ok := state.cache[key]; ok {
-		state.cacheHits++
-		return append([]string(nil), cached...), true, nil
-	}
-	state.cacheMisses++
-	arguments, ok, err := generate()
-	if err != nil || ok == false {
-		return arguments, ok, err
-	}
-	state.cache[key] = append([]string(nil), arguments...)
-	return append([]string(nil), arguments...), true, nil
-}
-
-func (state *nestiaCoreTransformState) cacheKey(
-	segments []string,
-	kind string,
-	typ *shimchecker.Type,
-	argCount int,
-	allowOptional bool,
-) nestiaCoreCacheKey {
-	return nestiaCoreCacheKey{
-		Kind:          kind,
-		Type:          typ,
-		TypeName:      nestiaCoreTypeNameText(state.prog, typ),
-		Modulo:        strings.Join(segments, "."),
-		Validate:      state.options.Validate,
-		Stringify:     state.options.Stringify,
-		StringifyNull: state.options.StringifyNull,
-		Llm:           state.options.Llm,
-		LlmStrict:     state.options.LlmStrict,
-		ArgCount:      argCount,
-		AllowOptional: allowOptional,
-	}
-}
-
-func nestiaCoreRawDecoratorCall(decorator *shimast.Node) (*shimast.CallExpression, []string, bool) {
-	if decorator == nil || decorator.Kind != NestiaCoreKindDecorator {
-		return nil, nil, false
-	}
-	expression := decorator.AsDecorator().Expression
-	if expression == nil || expression.Kind != shimast.KindCallExpression {
-		return nil, nil, false
-	}
-	call := expression.AsCallExpression()
-	segments := NestiaCoreExpressionSegments(call.Expression)
-	if len(segments) == 0 {
-		return nil, nil, false
-	}
-	return call, segments, true
-}
-
-func nestiaCoreDecoratorCall(prog *driver.Program, decorator *shimast.Node) (*shimast.CallExpression, []string, bool) {
-	call, segments, ok := nestiaCoreRawDecoratorCall(decorator)
-	if !ok {
-		return nil, nil, false
-	}
-	context := newNestiaCoreFileContext(shimast.GetSourceFileOfNode(decorator))
-	canonical := nestiaCoreCanonicalSegments(context, segments)
-	if nestiaCoreDecoratorReference(prog, context, decorator, segments, canonical) == false {
-		return nil, nil, false
-	}
-	return call, canonical, true
-}
-
-func newNestiaCoreFileContext(file *shimast.SourceFile) nestiaCoreFileContext {
-	context := nestiaCoreFileContext{
-		file:        file,
-		coreImports: map[string]string{},
-	}
-	if file == nil || file.Statements == nil {
-		return context
-	}
-	for _, stmt := range file.Statements.Nodes {
-		if stmt == nil || stmt.Kind != shimast.KindImportDeclaration {
-			continue
-		}
-		decl := stmt.AsImportDeclaration()
-		if decl == nil || decl.ImportClause == nil || decl.ModuleSpecifier == nil || decl.ModuleSpecifier.Kind != shimast.KindStringLiteral {
-			continue
-		}
-		if decl.ModuleSpecifier.Text() != "@nestia/core" {
-			continue
-		}
-		clause := decl.ImportClause.AsImportClause()
-		if clause == nil || clause.PhaseModifier == shimast.KindTypeKeyword {
-			continue
-		}
-		if name := clause.Name(); name != nil {
-			context.coreImports[name.Text()] = name.Text()
-		}
-		if clause.NamedBindings == nil || clause.NamedBindings.Kind != shimast.KindNamedImports {
-			continue
-		}
-		named := clause.NamedBindings.AsNamedImports()
-		if named == nil || named.Elements == nil {
-			continue
-		}
-		for _, elem := range named.Elements.Nodes {
-			if elem == nil {
-				continue
-			}
-			spec := elem.AsImportSpecifier()
-			if spec == nil || spec.IsTypeOnly {
-				continue
-			}
-			name := spec.Name()
-			if name != nil {
-				imported := name.Text()
-				if spec.PropertyName != nil {
-					imported = spec.PropertyName.Text()
-				}
-				context.coreImports[name.Text()] = imported
-			}
-		}
-	}
-	return context
-}
-
-func nestiaCoreCanonicalSegments(context nestiaCoreFileContext, segments []string) []string {
-	if len(segments) == 0 {
-		return segments
-	}
-	imported, ok := context.coreImports[segments[0]]
-	if !ok || imported == "" || imported == segments[0] {
-		return segments
-	}
-	canonical := append([]string{}, segments...)
-	canonical[0] = imported
-	return canonical
-}
-
-func nestiaCoreDecoratorReference(
-	prog *driver.Program,
-	context nestiaCoreFileContext,
-	decorator *shimast.Node,
-	segments []string,
-	canonical []string,
-) bool {
-	if len(segments) == 0 {
-		return false
-	}
-	if _, ok := context.coreImports[segments[0]]; ok {
-		return true
-	}
-	if nestiaCorePotentialDecoratorSegments(canonical) == false {
-		return false
-	}
-	return IsNestiaCoreCall(prog, decorator.AsDecorator().Expression)
-}
-
-func nestiaCorePotentialDecoratorSegments(segments []string) bool {
-	return nestiaCoreParameterKind(segments) != "" ||
-		nestiaCoreMethodKind(segments) != "" ||
-		(len(segments) != 0 && segments[len(segments)-1] == "WebSocketRoute")
-}
-
-func IsNestiaCoreCall(prog *driver.Program, node *shimast.Node) bool {
-	signature := prog.Checker.GetResolvedSignature(node)
-	if signature == nil || signature.Declaration() == nil {
-		return false
-	}
-	source := shimast.GetSourceFileOfNode(signature.Declaration())
-	if source == nil {
-		return false
-	}
-	location := filepath.ToSlash(source.FileName())
-	return strings.Contains(location, "@nestia/core/lib/") ||
-		strings.Contains(location, "packages/core/lib/") ||
-		strings.Contains(location, "@nestia/core/src/decorators/") ||
-		strings.Contains(location, "packages/core/src/decorators/")
-}
-
-func isNestiaCoreImportedExpression(node *shimast.Node, segments []string) bool {
-	if len(segments) == 0 {
-		return false
-	}
-	source := shimast.GetSourceFileOfNode(node)
-	if source == nil || source.Statements == nil {
-		return false
-	}
-	root := segments[0]
-	for _, stmt := range source.Statements.Nodes {
-		if stmt == nil || stmt.Kind != shimast.KindImportDeclaration {
-			continue
-		}
-		decl := stmt.AsImportDeclaration()
-		if decl == nil || decl.ImportClause == nil || decl.ModuleSpecifier == nil || decl.ModuleSpecifier.Kind != shimast.KindStringLiteral {
-			continue
-		}
-		if decl.ModuleSpecifier.Text() != "@nestia/core" {
-			continue
-		}
-		clause := decl.ImportClause.AsImportClause()
-		if clause == nil || clause.PhaseModifier == shimast.KindTypeKeyword {
-			continue
-		}
-		if name := clause.Name(); name != nil && name.Text() == root {
-			return true
-		}
-		if clause.NamedBindings == nil || clause.NamedBindings.Kind != shimast.KindNamedImports {
-			continue
-		}
-		named := clause.NamedBindings.AsNamedImports()
-		if named == nil || named.Elements == nil {
-			continue
-		}
-		for _, elem := range named.Elements.Nodes {
-			if elem == nil {
-				continue
-			}
-			spec := elem.AsImportSpecifier()
-			if spec == nil || spec.IsTypeOnly {
-				continue
-			}
-			name := spec.Name()
-			if name != nil && name.Text() == root {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-func nestiaCoreParameterKind(segments []string) string {
-	suffixes := map[string]string{
-		"EncryptedBody":         "TypedBody",
-		"TypedBody":             "TypedBody",
-		"TypedHeaders":          "TypedHeaders",
-		"TypedParam":            "TypedParam",
-		"TypedQuery":            "TypedQuery",
-		"TypedQuery.Body":       "TypedQueryBody",
-		"TypedFormData.Body":    "TypedFormDataBody",
-		"PlainBody":             "PlainBody",
-		"WebSocketRoute.Header": "TypedBody",
-		"WebSocketRoute.Param":  "TypedParam",
-		"WebSocketRoute.Query":  "TypedQuery",
-	}
-	for suffix, kind := range suffixes {
-		if nestiaCoreSegmentsHaveSuffix(segments, strings.Split(suffix, ".")) {
-			return kind
-		}
-	}
-	return ""
-}
-
-func nestiaCoreMethodKind(segments []string) string {
-	if len(segments) < 2 {
-		return ""
-	}
-	methods := map[string]bool{"Get": true, "Post": true, "Patch": true, "Put": true, "Delete": true}
-	if methods[segments[len(segments)-1]] == false {
-		return ""
-	}
-	switch segments[len(segments)-2] {
-	case "EncryptedRoute", "TypedRoute":
-		return "TypedRoute"
-	case "TypedQuery":
-		return "TypedQueryRoute"
-	default:
-		return ""
-	}
-}
-
-func nestiaCoreParameterArguments(
-	prog *driver.Program,
-	options nestiaCoreOptions,
-	call *shimast.CallExpression,
-	modulo *shimast.Node,
-	kind string,
-	typ *shimchecker.Type,
-) ([]string, bool, error) {
-	argCount := nestiaCoreArgumentCount(call)
-	switch kind {
-	case "TypedBody", "TypedHeaders", "TypedQuery", "TypedQueryBody", "PlainBody":
-		if argCount != 0 {
-			return nil, false, nil
-		}
-	case "TypedParam":
-		if argCount != 1 {
-			return nil, false, nil
-		}
-	case "TypedFormDataBody":
-		if argCount > 1 {
-			return nil, false, nil
-		}
-	}
-	expr, err := safeNestiaCoreGenerate(func() (*shimast.Node, error) {
-		switch kind {
-		case "TypedBody":
-			return nestiaCoreGenerateTypedBody(prog, options, modulo, typ), nil
-		case "TypedHeaders":
-			return nestiaCoreGenerateTypedHeaders(prog, options, modulo, typ), nil
-		case "TypedParam":
-			return nestiaCoreGenerateTypedParam(prog, modulo, typ), nil
-		case "TypedQuery":
-			return nestiaCoreGenerateTypedQuery(prog, options, modulo, typ, true), nil
-		case "TypedQueryBody":
-			return nestiaCoreGenerateTypedQuery(prog, options, modulo, typ, false), nil
-		case "TypedFormDataBody":
-			return nestiaCoreGenerateTypedFormDataBody(prog, options, modulo, typ), nil
-		case "PlainBody":
-			return nestiaCoreGeneratePlainBody(prog, modulo, typ), nil
-		default:
-			return nil, fmt.Errorf("unsupported parameter decorator %s", kind)
-		}
-	}, prog, shimast.GetSourceFileOfNode(call.AsNode()), false)
-	if err != nil {
-		return nil, false, err
-	}
-	output := []string{}
-	if kind == "TypedFormDataBody" && argCount == 0 {
-		output = append(output, "undefined")
-	}
-	output = append(output, expr)
-	// TypedParam takes a third `validate?: boolean` argument (see
-	// packages/core/src/decorators/TypedParam.ts). When the configured
-	// validate mode starts with "validate", emit `true` so the runtime
-	// returns the detailed report shape instead of the single-error shape.
-	// The legacy TypedParamProgrammer applied the same conditional.
-	if kind == "TypedParam" && strings.HasPrefix(options.Validate, "validate") {
-		output = append(output, "true")
-	}
-	return output, true, nil
-}
-
-func nestiaCoreGenerateTypedBody(
-	prog *driver.Program,
-	options nestiaCoreOptions,
-	modulo *shimast.Node,
-	typ *shimchecker.Type,
-) *shimast.Node {
-	nestiaCoreValidateTypedBody(prog, options, typ)
-	context := nestiaCoreTypiaContext(prog, false, false, false)
-	name := nestiaCoreTypeName(prog, typ)
-	category := options.Validate
-	switch category {
-	case "assert":
-		return nestiaCoreValidatorObject("type", "assert", nativeprogrammers.AssertProgrammer.Write(nativeprogrammers.AssertProgrammer_IProps{
-			Context: context, Modulo: modulo, Type: typ, Name: name,
-			Config: nativeprogrammers.AssertProgrammer_IConfig{Equals: false, Guard: false},
-		}))
-	case "is":
-		return nestiaCoreValidatorObject("type", "is", nativeprogrammers.IsProgrammer.Write(nativeprogrammers.IsProgrammer_IProps{
-			Context: context, Modulo: modulo, Type: typ, Name: name,
-			Config: nativeprogrammers.IsProgrammer_IConfig{Equals: false},
-		}))
-	case "validateEquals":
-		return nestiaCoreValidatorObject("type", "validate", nativeprogrammers.ValidateProgrammer.Write(nativeprogrammers.ValidateProgrammer_IProps{
-			Context: context, Modulo: modulo, Type: typ, Name: name,
-			Config: nativeprogrammers.ValidateProgrammer_IConfig{Equals: true},
-		}))
-	case "equals":
-		return nestiaCoreValidatorObject("type", "is", nativeprogrammers.IsProgrammer.Write(nativeprogrammers.IsProgrammer_IProps{
-			Context: context, Modulo: modulo, Type: typ, Name: name,
-			Config: nativeprogrammers.IsProgrammer_IConfig{Equals: true},
-		}))
-	case "assertEquals":
-		return nestiaCoreValidatorObject("type", "assert", nativeprogrammers.AssertProgrammer.Write(nativeprogrammers.AssertProgrammer_IProps{
-			Context: context, Modulo: modulo, Type: typ, Name: name,
-			Config: nativeprogrammers.AssertProgrammer_IConfig{Equals: true, Guard: false},
-		}))
-	case "assertClone":
-		return nestiaCoreValidatorObject("type", "assert", nativemisc.MiscAssertCloneProgrammer.Write(nativecontext.IProgrammerProps{
-			Context: context, Modulo: modulo, Type: typ, Name: name,
-		}))
-	case "validateClone":
-		return nestiaCoreValidatorObject("type", "validate", nativemisc.MiscValidateCloneProgrammer.Write(nativecontext.IProgrammerProps{
-			Context: context, Modulo: modulo, Type: typ, Name: name,
-		}))
-	case "assertPrune":
-		return nestiaCoreValidatorObject("type", "assert", nativemisc.MiscAssertPruneProgrammer.Write(nativecontext.IProgrammerProps{
-			Context: context, Modulo: modulo, Type: typ, Name: name,
-		}))
-	case "validatePrune":
-		return nestiaCoreValidatorObject("type", "validate", nativemisc.MiscValidatePruneProgrammer.Write(nativecontext.IProgrammerProps{
-			Context: context, Modulo: modulo, Type: typ, Name: name,
-		}))
-	default:
-		return nestiaCoreValidatorObject("type", "validate", nativeprogrammers.ValidateProgrammer.Write(nativeprogrammers.ValidateProgrammer_IProps{
-			Context: context, Modulo: modulo, Type: typ, Name: name,
-			Config: nativeprogrammers.ValidateProgrammer_IConfig{Equals: false},
-		}))
-	}
-}
-
-// nestiaCoreGenerateTypedHeaders intentionally collapses the 10-mode validate
-// option down to {assert, is, validate}. Header values are strings keyed by
-// name; deep-clone and prune semantics that @TypedBody honors (assertClone,
-// assertPrune, validateClone, validatePrune, etc.) have no meaningful effect
-// on a flat string→string map. Pass-through to the base programmer is the
-// intended behavior, not a fallthrough — matches v6 parity. See also
-// nestiaCoreGenerateTypedQuery and nestiaCoreGenerateTypedFormDataBody.
-func nestiaCoreGenerateTypedHeaders(prog *driver.Program, options nestiaCoreOptions, modulo *shimast.Node, typ *shimchecker.Type) *shimast.Node {
-	context := nestiaCoreTypiaContext(prog, false, false, false)
-	name := nestiaCoreTypeName(prog, typ)
-	category := options.Validate
-	if category == "is" || category == "equals" {
-		return nestiaCoreValidatorObject("type", "is", nativehttp.HttpIsHeadersProgrammer.Write(nativecontext.IProgrammerProps{Context: context, Modulo: modulo, Type: typ, Name: name}))
-	}
-	if strings.HasPrefix(category, "validate") {
-		return nestiaCoreValidatorObject("type", "validate", nativehttp.HttpValidateHeadersProgrammer.Write(nativecontext.IProgrammerProps{Context: context, Modulo: modulo, Type: typ, Name: name}))
-	}
-	return nestiaCoreValidatorObject("type", "assert", nativehttp.HttpAssertHeadersProgrammer.Write(nativecontext.IProgrammerProps{Context: context, Modulo: modulo, Type: typ, Name: name}))
-}
-
-func nestiaCoreGenerateTypedParam(prog *driver.Program, modulo *shimast.Node, typ *shimchecker.Type) *shimast.Node {
-	return nativehttp.HttpParameterProgrammer.Write(nativecontext.IProgrammerProps{
-		Context: nestiaCoreTypiaContext(prog, true, false, false),
-		Modulo:  modulo,
-		Type:    typ,
-		Name:    nestiaCoreTypeName(prog, typ),
-	})
-}
-
-func nestiaCoreGenerateTypedQuery(prog *driver.Program, options nestiaCoreOptions, modulo *shimast.Node, typ *shimchecker.Type, allowOptional bool) *shimast.Node {
-	nestiaCoreValidateTypedQuery(prog, options, typ, allowOptional, "@nestia.core.TypedQuery")
-	context := nestiaCoreTypiaContext(prog, false, false, false)
-	name := nestiaCoreTypeName(prog, typ)
-	category := options.Validate
-	if category == "is" || category == "equals" {
-		return nestiaCoreValidatorObject("type", "is", nativehttp.HttpIsQueryProgrammer.Write(nativehttp.HttpIsQueryProgrammer_IProps{Context: context, Modulo: modulo, Type: typ, Name: name, AllowOptional: allowOptional}))
-	}
-	if category == "validate" || category == "validateEquals" || category == "validateClone" || category == "validatePrune" {
-		return nestiaCoreValidatorObject("type", "validate", nativehttp.HttpValidateQueryProgrammer.Write(nativehttp.HttpValidateQueryProgrammer_IProps{Context: context, Modulo: modulo, Type: typ, Name: name, AllowOptional: allowOptional}))
-	}
-	return nestiaCoreValidatorObject("type", "assert", nativehttp.HttpAssertQueryProgrammer.Write(nativehttp.HttpAssertQueryProgrammer_IProps{Context: context, Modulo: modulo, Type: typ, Name: name, AllowOptional: allowOptional}))
-}
-
-func nestiaCoreGenerateTypedFormDataBody(prog *driver.Program, options nestiaCoreOptions, modulo *shimast.Node, typ *shimchecker.Type) *shimast.Node {
-	context := nestiaCoreTypiaContext(prog, false, false, false)
-	name := nestiaCoreTypeName(prog, typ)
-	category := options.Validate
-	files := nestiaCoreFormDataFiles(prog, typ)
-	validator := nativehttp.HttpAssertFormDataProgrammer.Write(nativecontext.IProgrammerProps{Context: context, Modulo: modulo, Type: typ, Name: name})
-	key := "assert"
-	if category == "is" || category == "equals" {
-		key = "is"
-		validator = nativehttp.HttpIsFormDataProgrammer.Write(nativecontext.IProgrammerProps{Context: context, Modulo: modulo, Type: typ, Name: name})
-	} else if category == "validate" || category == "validateEquals" || category == "validateClone" || category == "validatePrune" {
-		key = "validate"
-		validator = nativehttp.HttpValidateFormDataProgrammer.Write(nativecontext.IProgrammerProps{Context: context, Modulo: modulo, Type: typ, Name: name})
-	}
-	return nestiaCoreFactory.NewObjectLiteralExpression(nestiaCoreFactory.NewNodeList([]*shimast.Node{
-		nestiaCoreProperty("files", nestiaCoreFormDataFilesExpression(files)),
-		nestiaCoreProperty("validator", nestiaCoreValidatorObject("type", key, validator)),
-	}), true)
-}
-
-type nestiaCoreFormDataFile struct {
-	Name  string
-	Limit *int
-}
-
-func nestiaCoreFormDataFiles(prog *driver.Program, typ *shimchecker.Type) []nestiaCoreFormDataFile {
-	collection := schemametadata.NewMetadataCollection()
-	result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{
-		Checker: prog.Checker,
-		Options: nativefactories.MetadataFactory_IOptions{
-			Escape:   false,
-			Constant: true,
-			Absorb:   true,
-			Validate: nativehttp.HttpFormDataProgrammer.Validate,
-		},
-		Components: collection,
-		Type:       typ,
-	})
-	if result.Success == false {
-		panic(fmt.Errorf("failed to analyze form-data metadata: %d error(s)", len(result.Errors)))
-	}
-	files := []nestiaCoreFormDataFile{}
-	if result.Data == nil || len(result.Data.Objects) == 0 || result.Data.Objects[0] == nil || result.Data.Objects[0].Type == nil {
-		return files
-	}
-	for _, property := range result.Data.Objects[0].Type.Properties {
-		if property == nil || property.Value == nil {
-			continue
-		}
-		direct := nestiaCoreMetadataHasFile(property.Value)
-		array := nestiaCoreMetadataArrayHasFile(property.Value)
-		if direct == false && array == false {
-			continue
-		}
-		name, ok := nestiaCorePropertyStringKey(property)
-		if ok == false {
-			continue
-		}
-		var limit *int
-		if direct {
-			one := 1
-			limit = &one
-		}
-		files = append(files, nestiaCoreFormDataFile{
-			Name:  name,
-			Limit: limit,
-		})
-	}
-	return files
-}
-
-func nestiaCoreMetadataHasFile(metadata *schemametadata.MetadataSchema) bool {
-	if metadata == nil {
-		return false
-	}
-	for _, native := range metadata.Natives {
-		if native != nil && (native.Name == "File" || native.Name == "Blob") {
-			return true
-		}
-	}
-	return false
-}
-
-func nestiaCoreMetadataArrayHasFile(metadata *schemametadata.MetadataSchema) bool {
-	if metadata == nil {
-		return false
-	}
-	for _, array := range metadata.Arrays {
-		if array == nil || array.Type == nil || array.Type.Value == nil {
-			continue
-		}
-		if nestiaCoreMetadataHasFile(array.Type.Value) {
-			return true
-		}
-	}
-	return false
-}
-
-func nestiaCorePropertyStringKey(property *schemametadata.MetadataProperty) (string, bool) {
-	if property == nil || property.Key == nil {
-		return "", false
-	}
-	for _, constant := range property.Key.Constants {
-		if constant == nil || constant.Type != "string" {
-			continue
-		}
-		for _, value := range constant.Values {
-			if value == nil {
-				continue
-			}
-			name, ok := value.Value.(string)
-			if ok {
-				return name, true
-			}
-		}
-	}
-	return "", false
-}
-
-func nestiaCoreFormDataFilesExpression(files []nestiaCoreFormDataFile) *shimast.Node {
-	elements := make([]*shimast.Node, 0, len(files))
-	for _, file := range files {
-		limit := nestiaCoreFactory.NewKeywordExpression(shimast.KindNullKeyword)
-		if file.Limit != nil {
-			limit = nativefactories.LiteralFactory.Write(*file.Limit)
-		}
-		elements = append(elements, nestiaCoreFactory.NewObjectLiteralExpression(nestiaCoreFactory.NewNodeList([]*shimast.Node{
-			nestiaCoreProperty("name", nativefactories.LiteralFactory.Write(file.Name)),
-			nestiaCoreProperty("limit", limit),
-		}), true))
-	}
-	return nestiaCoreFactory.NewArrayLiteralExpression(nestiaCoreFactory.NewNodeList(elements), true)
-}
-
-func nestiaCoreGeneratePlainBody(prog *driver.Program, modulo *shimast.Node, typ *shimchecker.Type) *shimast.Node {
-	nestiaCoreValidatePlainBody(prog, typ)
-	return nativeprogrammers.AssertProgrammer.Write(nativeprogrammers.AssertProgrammer_IProps{
-		Context: nestiaCoreTypiaContext(prog, false, false, false),
-		Modulo:  modulo,
-		Type:    typ,
-		Name:    nestiaCoreTypeName(prog, typ),
-		Config:  nativeprogrammers.AssertProgrammer_IConfig{Equals: false, Guard: false},
-	})
-}
-
-func nestiaCoreGenerateTypedRoute(prog *driver.Program, options nestiaCoreOptions, modulo *shimast.Node, typ *shimchecker.Type) *shimast.Node {
-	nestiaCoreValidateTypedRoute(prog, options, typ)
-	if options.StringifyNull {
-		return nestiaCoreFactory.NewKeywordExpression(shimast.KindNullKeyword)
-	}
-	context := nestiaCoreTypiaContext(prog, false, false, false)
-	name := nestiaCoreTypeName(prog, typ)
-	switch options.Stringify {
-	case "is":
-		return nestiaCoreValidatorObject("type", "is", nativejson.JsonIsStringifyProgrammer.Write(nativecontext.IProgrammerProps{Context: context, Modulo: modulo, Type: typ, Name: name}))
-	case "validate":
-		return nestiaCoreValidatorObject("type", "validate", nativejson.JsonValidateStringifyProgrammer.Write(nativecontext.IProgrammerProps{Context: context, Modulo: modulo, Type: typ, Name: name}))
-	case "stringify":
-		return nestiaCoreValidatorObject("type", "stringify", nativejson.JsonStringifyProgrammer.Write(nativecontext.IProgrammerProps{Context: context, Modulo: modulo, Type: typ, Name: name}))
-	case "validate.log":
-		return nestiaCoreValidatorObjectWithKey("type", "validate.log", "validate", nativejson.JsonValidateStringifyProgrammer.Write(nativecontext.IProgrammerProps{Context: context, Modulo: modulo, Type: typ, Name: name}))
-	default:
-		return nestiaCoreValidatorObject("type", "assert", nativejson.JsonAssertStringifyProgrammer.Write(nativecontext.IProgrammerProps{Context: context, Modulo: modulo, Type: typ, Name: name}))
-	}
-}
-
-func nestiaCoreGenerateTypedQueryRoute(prog *driver.Program, options nestiaCoreOptions, modulo *shimast.Node, typ *shimchecker.Type) *shimast.Node {
-	nestiaCoreValidateTypedQueryRoute(prog, options, typ)
-	if options.StringifyNull {
-		return nestiaCoreFactory.NewKeywordExpression(shimast.KindNullKeyword)
-	}
-	switch options.Stringify {
-	case "is":
-		return nestiaCoreValidatorObject("type", "is", nestiaCoreHttpIsQuerifyProgrammer(prog, modulo, typ))
-	case "validate":
-		return nestiaCoreValidatorObject("type", "validate", nestiaCoreHttpValidateQuerifyProgrammer(prog, modulo, typ))
-	case "stringify":
-		return nestiaCoreValidatorObject("type", "stringify", nestiaCoreHttpQuerifyProgrammer(prog, typ))
-	default:
-		return nestiaCoreValidatorObject("type", "assert", nestiaCoreHttpAssertQuerifyProgrammer(prog, modulo, typ))
-	}
-}
-
-func nestiaCoreTypiaContext(prog *driver.Program, numeric bool, finite bool, functional bool) nativecontext.ITypiaContext {
-	return nativecontext.ITypiaContext{
-		Program:         prog,
-		CompilerOptions: prog.ParsedConfig.ParsedConfig.CompilerOptions,
-		Checker:         prog.Checker,
-		Options: nativecontext.ITransformOptions{
-			Numeric:    &numeric,
-			Finite:     &finite,
-			Functional: &functional,
-			Runtime:    "typia",
-		},
-		Importer: nativeprogrammers.NewImportProgrammer(nativeprogrammers.ImportProgrammer_IOptions{
-			InternalPrefix: "typia_transform_",
-			Runtime:        "typia",
-		}),
-	}
-}
-
-func nestiaCoreStrictMode(prog *driver.Program) bool {
-	if prog == nil || prog.ParsedConfig == nil || prog.ParsedConfig.ParsedConfig == nil || prog.ParsedConfig.ParsedConfig.CompilerOptions == nil {
-		return true
-	}
-	options := prog.ParsedConfig.ParsedConfig.CompilerOptions
-	return options.GetStrictOptionValue(options.StrictNullChecks)
-}
-
-func nestiaCoreLlmConfig(options nestiaCoreOptions) map[string]any {
-	return map[string]any{"strict": options.LlmStrict}
-}
-
-func nestiaCoreValidateTypedBody(prog *driver.Program, options nestiaCoreOptions, typ *shimchecker.Type) {
-	var validate nativefactories.MetadataFactory_Validator
-	if options.Llm {
-		validate = func(next struct {
-			Metadata *schemametadata.MetadataSchema
-			Explore  nativefactories.MetadataFactory_IExplore
-			Top      *schemametadata.MetadataSchema
-		}) []string {
-			return nativellm.LlmSchemaProgrammer.Validate(struct {
-				Config   map[string]any
-				Metadata *schemametadata.MetadataSchema
-				Explore  nativefactories.MetadataFactory_IExplore
-			}{
-				Config:   nestiaCoreLlmConfig(options),
-				Metadata: next.Metadata,
-				Explore:  next.Explore,
-			})
-		}
-	}
-	nativefactories.JsonMetadataFactory.Analyze(nativefactories.JsonMetadataFactory_IProps{
-		Method:   "@nestia.core.TypedBody",
-		Checker:  prog.Checker,
-		Type:     typ,
-		Validate: validate,
-	})
-}
-
-func nestiaCoreValidateTypedRoute(prog *driver.Program, options nestiaCoreOptions, typ *shimchecker.Type) {
-	if options.Llm == false {
-		return
-	}
-	nativefactories.JsonMetadataFactory.Analyze(nativefactories.JsonMetadataFactory_IProps{
-		Method:  "@nestia.core.TypedRoute",
-		Checker: prog.Checker,
-		Type:    typ,
-		Validate: func(next struct {
-			Metadata *schemametadata.MetadataSchema
-			Explore  nativefactories.MetadataFactory_IExplore
-			Top      *schemametadata.MetadataSchema
-		}) []string {
-			if next.Metadata == nil || next.Metadata.Size() == 0 {
-				return nil
-			}
-			return nativellm.LlmParametersProgrammer.Validate(struct {
-				Config   map[string]any
-				Metadata *schemametadata.MetadataSchema
-				Explore  nativefactories.MetadataFactory_IExplore
-			}{
-				Config:   nestiaCoreLlmConfig(options),
-				Metadata: next.Metadata,
-				Explore:  next.Explore,
-			})
-		},
-	})
-}
-
-func nestiaCoreValidateTypedQuery(prog *driver.Program, options nestiaCoreOptions, typ *shimchecker.Type, allowOptional bool, code string) {
-	if options.Llm == false {
-		return
-	}
-	collection := schemametadata.NewMetadataCollection()
-	result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{
-		Checker: prog.Checker,
-		Options: nativefactories.MetadataFactory_IOptions{
-			Escape:   false,
-			Constant: true,
-			Absorb:   true,
-			Validate: func(next struct {
-				Metadata *schemametadata.MetadataSchema
-				Explore  nativefactories.MetadataFactory_IExplore
-				Top      *schemametadata.MetadataSchema
-			}) []string {
-				errors := nativehttp.HttpQueryProgrammer.Validate(struct {
-					Metadata      *schemametadata.MetadataSchema
-					Explore       nativefactories.MetadataFactory_IExplore
-					Top           *schemametadata.MetadataSchema
-					AllowOptional bool
-				}{
-					Metadata:      next.Metadata,
-					Explore:       next.Explore,
-					Top:           next.Top,
-					AllowOptional: allowOptional,
-				})
-				errors = append(errors, nativellm.LlmSchemaProgrammer.Validate(struct {
-					Config   map[string]any
-					Metadata *schemametadata.MetadataSchema
-					Explore  nativefactories.MetadataFactory_IExplore
-				}{
-					Config:   nestiaCoreLlmConfig(options),
-					Metadata: next.Metadata,
-					Explore:  next.Explore,
-				})...)
-				return errors
-			},
-		},
-		Components: collection,
-		Type:       typ,
-	})
-	if result.Success == false {
-		panic(nativecontext.TransformerError_from(struct {
-			Code   string
-			Errors []nativecontext.TransformerError_MetadataFactory_IError
-		}{
-			Code:   code,
-			Errors: nestiaCoreMetadataErrors(result.Errors),
-		}))
-	}
-}
-
-func nestiaCoreValidateTypedQueryRoute(prog *driver.Program, options nestiaCoreOptions, typ *shimchecker.Type) {
-	if options.Llm == false {
-		return
-	}
-	collection := schemametadata.NewMetadataCollection()
-	result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{
-		Checker: prog.Checker,
-		Options: nativefactories.MetadataFactory_IOptions{
-			Escape:   false,
-			Constant: true,
-			Absorb:   true,
-			Validate: func(next struct {
-				Metadata *schemametadata.MetadataSchema
-				Explore  nativefactories.MetadataFactory_IExplore
-				Top      *schemametadata.MetadataSchema
-			}) []string {
-				errors := nativehttp.HttpQueryProgrammer.Validate(struct {
-					Metadata      *schemametadata.MetadataSchema
-					Explore       nativefactories.MetadataFactory_IExplore
-					Top           *schemametadata.MetadataSchema
-					AllowOptional bool
-				}{
-					Metadata:      next.Metadata,
-					Explore:       next.Explore,
-					Top:           next.Top,
-					AllowOptional: true,
-				})
-				if next.Metadata != nil && next.Metadata.Size() != 0 {
-					errors = append(errors, nativellm.LlmParametersProgrammer.Validate(struct {
-						Config   map[string]any
-						Metadata *schemametadata.MetadataSchema
-						Explore  nativefactories.MetadataFactory_IExplore
-					}{
-						Config:   nestiaCoreLlmConfig(options),
-						Metadata: next.Metadata,
-						Explore:  next.Explore,
-					})...)
-				}
-				return errors
-			},
-		},
-		Components: collection,
-		Type:       typ,
-	})
-	if result.Success == false {
-		panic(nativecontext.TransformerError_from(struct {
-			Code   string
-			Errors []nativecontext.TransformerError_MetadataFactory_IError
-		}{
-			Code:   "@nestia.core.TypedQueryRoute",
-			Errors: nestiaCoreMetadataErrors(result.Errors),
-		}))
-	}
-}
-
-func nestiaCoreValidatePlainBody(prog *driver.Program, typ *shimchecker.Type) {
-	collection := schemametadata.NewMetadataCollection()
-	result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{
-		Checker: prog.Checker,
-		Options: nativefactories.MetadataFactory_IOptions{
-			Escape:   false,
-			Constant: true,
-			Absorb:   true,
-			Validate: func(next struct {
-				Metadata *schemametadata.MetadataSchema
-				Explore  nativefactories.MetadataFactory_IExplore
-				Top      *schemametadata.MetadataSchema
-			}) []string {
-				return nestiaCoreValidatePlainBodyMetadata(next.Metadata)
-			},
-		},
-		Components: collection,
-		Type:       typ,
-	})
-	if result.Success == false {
-		panic(nativecontext.TransformerError_from(struct {
-			Code   string
-			Errors []nativecontext.TransformerError_MetadataFactory_IError
-		}{
-			Code:   "nestia.core.PlainBody",
-			Errors: nestiaCoreMetadataErrors(result.Errors),
-		}))
-	}
-}
-
-func nestiaCoreValidatePlainBodyMetadata(metadata *schemametadata.MetadataSchema) []string {
-	if metadata == nil {
-		return nil
-	}
-	errors := []string{}
-	expected := 0
-	for _, atomic := range metadata.Atomics {
-		if atomic != nil && atomic.Type == "string" {
-			expected = 1
-			break
-		}
-	}
-	expected += len(metadata.Templates)
-	for _, constant := range metadata.Constants {
-		if constant != nil && constant.Type == "string" {
-			expected += len(constant.Values)
-		}
-	}
-	if expected == 0 || expected != metadata.Size() {
-		errors = append(errors, "only string type is allowed")
-	}
-	if metadata.Nullable {
-		errors = append(errors, "do not allow nullable type")
-	} else if metadata.Any {
-		errors = append(errors, "do not allow any type")
-	}
-	return errors
-}
-
-func nestiaCoreMetadataErrors(errors []nativefactories.MetadataFactory_IError) []nativecontext.TransformerError_MetadataFactory_IError {
-	output := make([]nativecontext.TransformerError_MetadataFactory_IError, 0, len(errors))
-	for _, err := range errors {
-		output = append(output, nativecontext.TransformerError_MetadataFactory_IError{
-			Name: err.Name,
-			Explore: nativecontext.TransformerError_MetadataFactory_IExplore{
-				Object:    err.Explore.Object,
-				Property:  err.Explore.Property,
-				Parameter: err.Explore.Parameter,
-				Output:    err.Explore.Output,
-			},
-			Messages: err.Messages,
-		})
-	}
-	return output
-}
-
-func nestiaCoreValidatorObject(typeKey string, key string, validator *shimast.Node) *shimast.Node {
-	return nestiaCoreValidatorObjectWithKey(typeKey, key, key, validator)
-}
-
-func nestiaCoreValidatorObjectWithKey(typeKey string, typeValue string, validatorKey string, validator *shimast.Node) *shimast.Node {
-	return nestiaCoreFactory.NewObjectLiteralExpression(nestiaCoreFactory.NewNodeList([]*shimast.Node{
-		nestiaCoreProperty(typeKey, nestiaCoreFactory.NewStringLiteral(typeValue, shimast.TokenFlagsNone)),
-		nestiaCoreProperty(validatorKey, validator),
-	}), true)
-}
-
-func nestiaCoreProperty(name string, initializer *shimast.Node) *shimast.Node {
-	return nestiaCoreFactory.NewPropertyAssignment(
-		nil,
-		nativefactories.IdentifierFactory.Identifier(name),
-		nil,
-		nil,
-		initializer,
-	)
-}
-
-func safeNestiaCoreGenerate(
-	generator func() (*shimast.Node, error),
-	prog *driver.Program,
-	file *shimast.SourceFile,
-	preserveTypes bool,
-) (text string, err error) {
-	defer func() {
-		if exp := recover(); exp != nil {
-			if os.Getenv("NESTIA_NATIVE_DEBUG_STACK") != "" {
-				err = fmt.Errorf("%v\n%s", exp, debug.Stack())
-			} else {
-				err = fmt.Errorf("%v", exp)
-			}
-		}
-	}()
-	node, err := generator()
-	if err != nil {
-		return "", err
-	}
-	return emitNestiaCoreExpression(prog, file, node, preserveTypes), nil
-}
-
-func emitNestiaCoreExpression(prog *driver.Program, file *shimast.SourceFile, node *shimast.Node, preserveTypes bool) string {
-	var text string
-	if preserveTypes {
-		text = emitNestiaPreservingTypesWithIdentifierSubstitutions(node, file, nil)
-	} else {
-		text = emitNestiaWithIdentifierSubstitutions(
-			node,
-			file,
-			identifierSubstitutionsForEmit(prog, file),
-		)
-	}
-	return cleanupNestiaCorePrintedExpression(text)
-}
-
-func cleanupNestiaCorePrintedExpression(text string) string {
-	text = strings.TrimSpace(text)
-	text = strings.TrimSuffix(text, ";")
-	text = nestiaCoreSingleParameterArrowPattern.ReplaceAllString(text, `${1}(${2}) =>`)
-	if strings.HasPrefix(text, "(") && strings.HasSuffix(text, ")") {
-		return text
-	}
-	if strings.Contains(text, "=>") || strings.Contains(text, "function") {
-		return "(" + text + ")"
-	}
-	return text
-}
-
-var nestiaCoreSingleParameterArrowPattern = regexp.MustCompile(`(^|[\s(=,:?])([A-Za-z_$][A-Za-z0-9_$]*) =>`)
-
-func NestiaCoreMethodReturnType(prog *driver.Program, node *shimast.Node) *shimchecker.Type {
-	signature := prog.Checker.GetSignatureFromDeclaration(node)
-	if signature == nil {
-		return nil
-	}
-	typ := prog.Checker.GetReturnTypeOfSignature(signature)
-	if typ == nil {
-		return nil
-	}
-	symbol := typ.Symbol()
-	if symbol != nil && symbol.Name == "Promise" {
-		args := prog.Checker.GetTypeArguments(typ)
-		if len(args) == 1 {
-			return args[0]
-		}
-	}
-	return typ
-}
-
-func nestiaCoreShouldSkipMethodDecorator(prog *driver.Program, call *shimast.CallExpression) bool {
-	count := nestiaCoreArgumentCount(call)
-	if count >= 2 {
-		return true
-	}
-	if count == 1 {
-		last := call.Arguments.Nodes[0]
-		if last.Kind == shimast.KindObjectLiteralExpression {
-			return true
-		}
-		if nestiaCoreHasPathLiteralArgument(call) {
-			return false
-		}
-		typ := prog.Checker.GetTypeAtLocation(last)
-		if typ != nil && typ.Flags()&shimchecker.TypeFlagsObject != 0 &&
-			shimchecker.IsTupleType(typ) == false &&
-			shimchecker.Checker_isArrayType(prog.Checker, typ) == false {
-			return true
-		}
-	}
-	return false
-}
-
-func nestiaCoreHasPathLiteralArgument(call *shimast.CallExpression) bool {
-	source, ok := SourceFileText(shimast.GetSourceFileOfNode(call.AsNode()))
-	if !ok {
-		return false
-	}
-	open, close, ok := callArgumentBounds(source, call)
-	if !ok {
-		return false
-	}
-	text := strings.TrimSpace(source[open+1 : close])
-	return strings.HasPrefix(text, `"`) ||
-		strings.HasPrefix(text, `'`) ||
-		strings.HasPrefix(text, "`") ||
-		strings.HasPrefix(text, "[")
-}
-
-func nestiaCoreArgumentCount(call *shimast.CallExpression) int {
-	if call == nil || call.Arguments == nil {
-		return 0
-	}
-	return len(call.Arguments.Nodes)
-}
-
-func callArgumentBounds(source string, call *shimast.CallExpression) (int, int, bool) {
-	if call == nil || call.AsNode() == nil || call.Expression == nil {
-		return 0, 0, false
-	}
-	start := call.Expression.End()
-	end := call.AsNode().End()
-	if start < 0 || end > len(source) || start >= end {
-		start = call.AsNode().Pos()
-	}
-	open := strings.IndexByte(source[start:end], '(')
-	if open < 0 {
-		return 0, 0, false
-	}
-	open += start
-	close, ok := matchNativeParen(source, open)
-	return open, close, ok
-}
-
-func appendArgumentsText(current string, arguments []string) string {
-	current = strings.TrimSpace(current)
-	next := strings.Join(arguments, ", ")
-	if current == "" {
-		return next
-	}
-	return current + ", " + next
-}
-
-func NestiaCoreExpressionSegments(node *shimast.Node) []string {
-	if node == nil {
-		return nil
-	}
-	if node.Kind == shimast.KindIdentifier {
-		if id := node.AsIdentifier(); id != nil {
-			return []string{id.Text}
-		}
-	}
-	if node.Kind == shimast.KindPropertyAccessExpression {
-		access := node.AsPropertyAccessExpression()
-		if access == nil {
-			return nil
-		}
-		left := NestiaCoreExpressionSegments(access.Expression)
-		name := access.Name()
-		if len(left) == 0 || name == nil || name.Kind != shimast.KindIdentifier {
-			return nil
-		}
-		return append(left, name.AsIdentifier().Text)
-	}
-	return nil
-}
-
-func nestiaCoreModuloNode(node *shimast.Node) *shimast.Node {
-	segments := NestiaCoreExpressionSegments(node)
-	if len(segments) == 0 {
-		return nestiaCoreFactory.NewIdentifier("nestia_core_transform")
-	}
-	return nestiaCoreFactory.NewIdentifier(strings.Join(segments, "_"))
-}
-
-func nestiaCoreTypeName(prog *driver.Program, typ *shimchecker.Type) *string {
-	name := nestiaCoreTypeNameText(prog, typ)
-	return &name
-}
-
-type nestiaCoreTypeNameCacheKey struct {
-	checker *shimchecker.Checker
-	typ     *shimchecker.Type
-}
-
-var nestiaCoreTypeNameCache sync.Map
-
-func nestiaCoreTypeNameText(prog *driver.Program, typ *shimchecker.Type) string {
-	if prog != nil && prog.Checker != nil && typ != nil {
-		key := nestiaCoreTypeNameCacheKey{checker: prog.Checker, typ: typ}
-		if cached, ok := nestiaCoreTypeNameCache.Load(key); ok {
-			return cached.(string)
-		}
-		name := prog.Checker.TypeToString(typ)
-		nestiaCoreTypeNameCache.Store(key, name)
-		return name
-	}
-	return "any"
-}
-
-func nestiaCoreSegmentsHaveSuffix(segments []string, suffix []string) bool {
-	if len(suffix) > len(segments) {
-		return false
-	}
-	offset := len(segments) - len(suffix)
-	for i, part := range suffix {
-		if segments[offset+i] != part {
-			return false
-		}
-	}
-	return true
-}
-
-func nestiaCoreTargetCandidates(prog *driver.Program, site nestiaCoreSite) []string {
-	if len(site.Segments) == 0 {
-		return nil
-	}
-	candidates := []string{strings.Join(site.Segments, ".")}
-	substitutions := identifierSubstitutionsForEmit(prog, site.File)
-	if substitutions != nil {
-		if mapped, ok := substitutions[site.Segments[0]]; ok {
-			parts := append([]string{mapped}, site.Segments[1:]...)
-			candidates = append(candidates, strings.Join(parts, "."))
-		}
-	}
-	sort.SliceStable(candidates, func(i, j int) bool {
-		return len(candidates[i]) > len(candidates[j])
-	})
-	return candidates
-}
-
-func identifierSubstitutionsForEmit(program *driver.Program, file any) map[string]string {
-	if program == nil {
-		return nil
-	}
-	sourceFile, ok := file.(*shimast.SourceFile)
-	if ok == false {
-		return nil
-	}
-	return commonJSImportIdentifierSubstitutions(sourceFile)
-}
-
-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 {
-		if stmt == nil || stmt.Kind != shimast.KindImportDeclaration {
-			continue
-		}
-		decl := stmt.AsImportDeclaration()
-		if decl == nil || decl.ImportClause == nil || decl.ModuleSpecifier == nil || decl.ModuleSpecifier.Kind != shimast.KindStringLiteral {
-			continue
-		}
-		clause := decl.ImportClause.AsImportClause()
-		if clause == nil || clause.PhaseModifier == shimast.KindTypeKeyword {
-			continue
-		}
-		base := commonJSImportAliasBase(decl.ModuleSpecifier.Text())
-		counts[base]++
-		moduleAlias := base + "_" + strconv.Itoa(counts[base])
-		if name := clause.Name(); name != nil {
-			output[name.Text()] = moduleAlias + ".default"
-		}
-		if clause.NamedBindings == nil || clause.NamedBindings.Kind != shimast.KindNamedImports {
-			continue
-		}
-		named := clause.NamedBindings.AsNamedImports()
-		if named == nil || named.Elements == nil {
-			continue
-		}
-		for _, elem := range named.Elements.Nodes {
-			if elem == nil {
-				continue
-			}
-			spec := elem.AsImportSpecifier()
-			if spec == nil || spec.IsTypeOnly {
-				continue
-			}
-			name := spec.Name()
-			if name == nil {
-				continue
-			}
-			local := name.Text()
-			imported := local
-			if spec.PropertyName != nil {
-				imported = spec.PropertyName.Text()
-			}
-			output[local] = moduleAlias + "." + imported
-		}
-	}
-	if len(output) == 0 {
-		output = nil
-	}
-	commonJSImportIdentifierSubstitutionsCache.Store(file, commonJSImportIdentifierSubstitutionsCacheEntry{value: output})
-	return output
-}
-
-func commonJSImportAliasBase(module string) string {
-	base := strings.TrimSuffix(filepath.Base(module), filepath.Ext(module))
-	if base == "" || base == "." || base == string(filepath.Separator) {
-		base = "mod"
-	}
-	var builder strings.Builder
-	for _, r := range base {
-		if r == '_' || r == '$' || unicode.IsLetter(r) || unicode.IsDigit(r) {
-			builder.WriteRune(r)
-		} else {
-			builder.WriteByte('_')
-		}
-	}
-	text := builder.String()
-	if text == "" {
-		text = "mod"
-	}
-	first := []rune(text)[0]
-	if first != '_' && first != '$' && !unicode.IsLetter(first) {
-		text = "_" + text
-	}
-	return text
-}
-
-func nestiaCoreDiagnostic(site nestiaCoreSite, message string) Diagnostic {
-	line, column := 0, 0
-	if site.File != nil && site.Call != nil {
-		if pos := site.Call.AsNode().Pos(); pos >= 0 {
-			l, c := shimscanner.GetECMALineAndByteOffsetOfPosition(site.File, pos)
-			line, column = l+1, c+1
-		}
-	}
-	return Diagnostic{
-		File:    site.FilePath,
-		Line:    line,
-		Column:  column,
-		Code:    "nestia.core." + site.Kind,
-		Message: message,
-	}
-}
-
-func nestiaCoreGlobalDiagnostic(code string, message string) Diagnostic {
-	return Diagnostic{
-		Code:    code,
-		Message: message,
-	}
-}
+package transform
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime/debug"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"unicode"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+	shimprinter "github.com/microsoft/typescript-go/shim/printer"
+	shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+	"github.com/samchon/nestia/packages/core/native/plugin"
+	"github.com/samchon/ttsc/packages/ttsc/driver"
+	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+	nativeprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers"
+	nativehttp "github.com/samchon/typia/packages/typia/native/core/programmers/http"
+	nativejson "github.com/samchon/typia/packages/typia/native/core/programmers/json"
+	nativellm "github.com/samchon/typia/packages/typia/native/core/programmers/llm"
+	nativemisc "github.com/samchon/typia/packages/typia/native/core/programmers/misc"
+	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+type nestiaCoreOptions struct {
+	Validate      string
+	Stringify     string
+	StringifyNull bool
+	Llm           bool
+	LlmStrict     bool
+}
+
+type nestiaCoreSite struct {
+	File             *shimast.SourceFile
+	FilePath         string
+	Call             *shimast.CallExpression
+	Modulo           *shimast.Node
+	Kind             string
+	Type             *shimchecker.Type
+	ArgCount         int
+	Segments         []string
+	Arguments        []string
+	ReplaceArguments bool
+}
+
+type nestiaCoreTransformState struct {
+	prog    *driver.Program
+	options nestiaCoreOptions
+	// importer is the file-scoped ImportProgrammer shared by every validator
+	// generated for the current file on the AST-integration emit path; nil on
+	// the legacy text-splice paths, where each generation gets a throwaway
+	// importer. When set, generation result caching is disabled: the cache keys
+	// on text, but ec-mode nodes embed per-file NewGeneratedNameForNode imports
+	// that cannot be reused verbatim across files.
+	importer *nativecontext.ImportProgrammer
+	// ec is the emit EmitContext on the AST-integration path (nil on the legacy
+	// text path). Threaded into ITypiaContext.Emit so typia's per-programmer
+	// factories build emit-tracked nodes.
+	ec          *shimprinter.EmitContext
+	cache       map[nestiaCoreCacheKey][]string
+	cacheHits   int
+	cacheMisses int
+}
+
+type nestiaCoreCacheKey struct {
+	Kind          string
+	Type          *shimchecker.Type
+	TypeName      string
+	Modulo        string
+	Validate      string
+	Stringify     string
+	StringifyNull bool
+	Llm           bool
+	LlmStrict     bool
+	ArgCount      int
+	AllowOptional bool
+}
+
+func newNestiaCoreTransformState(prog *driver.Program, options nestiaCoreOptions) *nestiaCoreTransformState {
+	return &nestiaCoreTransformState{
+		prog:    prog,
+		options: options,
+		cache:   map[nestiaCoreCacheKey][]string{},
+	}
+}
+
+var nestiaCoreFactory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+
+const NestiaCoreKindDecorator = shimast.KindDecorator
+
+type nestiaCoreFileContext struct {
+	file        *shimast.SourceFile
+	coreImports map[string]string
+}
+
+func readNestiaCoreOptions(plan plugin.Plan) nestiaCoreOptions {
+	options := nestiaCoreOptions{}
+	for _, entry := range plan.Entries {
+		if entry.Name != "@nestia/core" && !strings.Contains(entry.Transform, "@nestia/core") {
+			continue
+		}
+		if value, ok := entry.Config["validate"].(string); ok {
+			options.Validate = value
+		}
+		if value, ok := entry.Config["stringify"]; ok {
+			if value == nil {
+				options.StringifyNull = true
+			} else if text, ok := value.(string); ok {
+				options.Stringify = text
+			}
+		}
+		if value, ok := entry.Config["llm"]; ok {
+			switch v := value.(type) {
+			case bool:
+				options.Llm = v
+			case map[string]any:
+				options.Llm = true
+				if strict, ok := v["strict"].(bool); ok {
+					options.LlmStrict = strict
+				}
+			}
+		}
+	}
+	return options
+}
+
+func collectNestiaCoreSourceRewriteMap(
+	prog *driver.Program,
+	plan plugin.Plan,
+	onlyFile string,
+) (map[string][]SourceRewrite, []Diagnostic) {
+	if plan.Core == false {
+		return map[string][]SourceRewrite{}, nil
+	}
+	options := readNestiaCoreOptions(plan)
+	sites, diagnostics := collectNestiaCoreSites(newNestiaCoreTransformState(prog, options))
+	rewrites := map[string][]SourceRewrite{}
+	for _, site := range sites {
+		if onlyFile != "" && filepath.ToSlash(site.FilePath) != filepath.ToSlash(onlyFile) {
+			continue
+		}
+		source, ok := SourceFileText(site.File)
+		if !ok {
+			diagnostics = append(diagnostics, nestiaCoreDiagnostic(site, "source text is unavailable"))
+			continue
+		}
+		open, close, ok := callArgumentBounds(source, site.Call)
+		if !ok {
+			diagnostics = append(diagnostics, nestiaCoreDiagnostic(site, "failed to locate decorator arguments"))
+			continue
+		}
+		replacement := strings.Join(site.Arguments, ", ")
+		if site.ReplaceArguments == false {
+			replacement = appendArgumentsText(source[open+1:close], site.Arguments)
+		}
+		rewrites[filepath.ToSlash(site.FilePath)] = append(rewrites[filepath.ToSlash(site.FilePath)], SourceRewrite{
+			start:       open + 1,
+			end:         close,
+			replacement: replacement,
+		})
+	}
+	return rewrites, diagnostics
+}
+
+func collectNestiaCoreBuildRewrites(
+	prog *driver.Program,
+	plan plugin.Plan,
+	rewrites *nativeRewriteSet,
+) []Diagnostic {
+	if plan.Core == false {
+		return nil
+	}
+	options := readNestiaCoreOptions(plan)
+	sites, diagnostics := collectNestiaCoreSites(newNestiaCoreTransformState(prog, options))
+	for _, site := range sites {
+		expectedArgumentCount := site.ArgCount
+		expectedArgumentsText := nestiaCoreStableOriginalArgumentText(site)
+		rewrites.Add(nativeRewrite{
+			FilePath:                   site.FilePath,
+			RootName:                   site.Segments[0],
+			Namespaces:                 site.Segments[1:],
+			AppendArguments:            site.Arguments,
+			ReplaceArguments:           site.ReplaceArguments,
+			TargetExpressionCandidates: nestiaCoreTargetCandidates(prog, site),
+			SourceStart:                site.Call.AsNode().Pos(),
+			ExpectedArgumentCount:      &expectedArgumentCount,
+			ExpectedArgumentsText:      expectedArgumentsText,
+		})
+	}
+	return diagnostics
+}
+
+func nestiaCoreOriginalArgumentText(site nestiaCoreSite) string {
+	source, ok := SourceFileText(site.File)
+	if !ok {
+		return ""
+	}
+	open, close, ok := callArgumentBounds(source, site.Call)
+	if !ok {
+		return ""
+	}
+	return strings.TrimSpace(source[open+1 : close])
+}
+
+func nestiaCoreStableOriginalArgumentText(site nestiaCoreSite) string {
+	text := nestiaCoreOriginalArgumentText(site)
+	if strings.Contains(text, "=>") || strings.Contains(text, "function") {
+		return ""
+	}
+	return text
+}
+
+func collectNestiaCoreSites(state *nestiaCoreTransformState) ([]nestiaCoreSite, []Diagnostic) {
+	sites := []nestiaCoreSite{}
+	diagnostics := []Diagnostic{}
+	prog := state.prog
+	if nestiaCoreStrictMode(prog) == false {
+		diagnostics = append(diagnostics, nestiaCoreGlobalDiagnostic("@nestia/core", "strict mode is required."))
+	}
+	for _, file := range prog.SourceFiles() {
+		if file == nil || file.IsDeclarationFile {
+			continue
+		}
+		context := newNestiaCoreFileContext(file)
+		file.ForEachChild(func(node *shimast.Node) bool {
+			visitNestiaCoreNode(state, context, node, &sites, &diagnostics)
+			return false
+		})
+	}
+	if os.Getenv("TTSC_NESTIA_PROFILE") != "" {
+		fmt.Fprintf(stderr, "ttsc-nestia profile: core-cache hits=%d misses=%d\n", state.cacheHits, state.cacheMisses)
+	}
+	return sites, diagnostics
+}
+
+func visitNestiaCoreNode(
+	state *nestiaCoreTransformState,
+	context nestiaCoreFileContext,
+	node *shimast.Node,
+	sites *[]nestiaCoreSite,
+	diagnostics *[]Diagnostic,
+) {
+	if node == nil {
+		return
+	}
+	switch node.Kind {
+	case shimast.KindParameter:
+		decorators := node.Decorators()
+		if len(decorators) == 0 {
+			break
+		}
+		type candidate struct {
+			decorator *shimast.Node
+			call      *shimast.CallExpression
+			segments  []string
+			kind      string
+		}
+		candidates := []candidate{}
+		for _, decorator := range decorators {
+			call, segments, ok := nestiaCoreRawDecoratorCall(decorator)
+			if !ok {
+				continue
+			}
+			canonical := nestiaCoreCanonicalSegments(context, segments)
+			kind := nestiaCoreParameterKind(canonical)
+			if kind == "" || nestiaCoreDecoratorReference(state.prog, context, decorator, segments, canonical) == false {
+				continue
+			}
+			candidates = append(candidates, candidate{
+				decorator: decorator,
+				call:      call,
+				segments:  segments,
+				kind:      kind,
+			})
+		}
+		if len(candidates) == 0 {
+			break
+		}
+		typ := state.prog.Checker.GetTypeAtLocation(node)
+		for _, candidate := range candidates {
+			site, ok, err := transformNestiaCoreParameterDecorator(
+				state,
+				context.file,
+				candidate.call,
+				candidate.segments,
+				candidate.kind,
+				typ,
+			)
+			if err != nil {
+				*diagnostics = append(*diagnostics, nestiaCoreDiagnostic(site, err.Error()))
+			} else if ok {
+				*sites = append(*sites, site)
+			}
+		}
+	case shimast.KindMethodDeclaration:
+		decorators := node.Decorators()
+		if len(decorators) == 0 {
+			break
+		}
+		type candidate struct {
+			call     *shimast.CallExpression
+			segments []string
+			kind     string
+		}
+		candidates := []candidate{}
+		for _, decorator := range decorators {
+			call, segments, ok := nestiaCoreRawDecoratorCall(decorator)
+			if !ok {
+				continue
+			}
+			canonical := nestiaCoreCanonicalSegments(context, segments)
+			if nestiaCoreDecoratorReference(state.prog, context, decorator, segments, canonical) == false {
+				continue
+			}
+			if len(canonical) != 0 && canonical[len(canonical)-1] == "WebSocketRoute" {
+				*diagnostics = append(*diagnostics, validateNestiaCoreWebSocketRoute(state.prog, context, node, call, canonical)...)
+			}
+			kind := nestiaCoreMethodKind(canonical)
+			if kind == "" {
+				continue
+			}
+			if kind == "McpRoute" {
+				if nestiaCoreMcpRouteAlreadyTransformed(call) {
+					continue
+				}
+			} else if nestiaCoreShouldSkipMethodDecorator(state.prog, call) {
+				continue
+			}
+			candidates = append(candidates, candidate{
+				call:     call,
+				segments: segments,
+				kind:     kind,
+			})
+		}
+		if len(candidates) == 0 {
+			break
+		}
+		typ := NestiaCoreMethodReturnType(state.prog, node)
+		if typ != nil {
+			for _, candidate := range candidates {
+				site, ok, err := transformNestiaCoreMethodDecorator(
+					state,
+					context.file,
+					node,
+					candidate.call,
+					candidate.segments,
+					candidate.kind,
+					typ,
+				)
+				if err != nil {
+					*diagnostics = append(*diagnostics, nestiaCoreDiagnostic(site, err.Error()))
+				} else if ok {
+					*sites = append(*sites, site)
+				}
+			}
+		}
+	}
+	node.ForEachChild(func(child *shimast.Node) bool {
+		visitNestiaCoreNode(state, context, child, sites, diagnostics)
+		return false
+	})
+}
+
+func transformNestiaCoreParameterDecorator(
+	state *nestiaCoreTransformState,
+	file *shimast.SourceFile,
+	call *shimast.CallExpression,
+	segments []string,
+	kind string,
+	typ *shimchecker.Type,
+) (nestiaCoreSite, bool, error) {
+	modulo := nestiaCoreModuloNode(call.Expression)
+	arguments, ok, err := state.parameterArguments(call, segments, modulo, kind, typ)
+	if err != nil || !ok {
+		return nestiaCoreSite{
+			File:     file,
+			FilePath: file.FileName(),
+			Call:     call,
+			Modulo:   modulo,
+			Kind:     kind,
+			Type:     typ,
+			Segments: segments,
+		}, ok, err
+	}
+	return nestiaCoreSite{
+		File:      file,
+		FilePath:  file.FileName(),
+		Call:      call,
+		Modulo:    modulo,
+		Kind:      kind,
+		Type:      typ,
+		ArgCount:  nestiaCoreArgumentCount(call),
+		Segments:  segments,
+		Arguments: arguments,
+	}, true, nil
+}
+
+func transformNestiaCoreMethodDecorator(
+	state *nestiaCoreTransformState,
+	file *shimast.SourceFile,
+	method *shimast.Node,
+	call *shimast.CallExpression,
+	segments []string,
+	kind string,
+	typ *shimchecker.Type,
+) (nestiaCoreSite, bool, error) {
+	modulo := nestiaCoreModuloNode(call.Expression)
+	if kind == "McpRoute" {
+		arguments, err := state.mcpRouteArguments(file, method, call, typ)
+		if err != nil {
+			return nestiaCoreSite{
+				File:      file,
+				FilePath:  file.FileName(),
+				Call:      call,
+				Modulo:    modulo,
+				Kind:      kind,
+				Type:      typ,
+				Segments:  segments,
+				Arguments: arguments,
+			}, false, err
+		}
+		return nestiaCoreSite{
+			File:             file,
+			FilePath:         file.FileName(),
+			Call:             call,
+			Modulo:           modulo,
+			Kind:             kind,
+			Type:             typ,
+			ArgCount:         nestiaCoreArgumentCount(call),
+			Segments:         segments,
+			Arguments:        arguments,
+			ReplaceArguments: true,
+		}, true, nil
+	}
+	arguments, err := state.methodArguments(file, segments, modulo, kind, typ, nestiaCoreArgumentCount(call))
+	if err != nil {
+		return nestiaCoreSite{
+			File:     file,
+			FilePath: file.FileName(),
+			Call:     call,
+			Modulo:   modulo,
+			Kind:     kind,
+			Type:     typ,
+			Segments: segments,
+		}, false, err
+	}
+	return nestiaCoreSite{
+		File:      file,
+		FilePath:  file.FileName(),
+		Call:      call,
+		Modulo:    modulo,
+		Kind:      kind,
+		Type:      typ,
+		ArgCount:  nestiaCoreArgumentCount(call),
+		Segments:  segments,
+		Arguments: arguments,
+	}, true, nil
+}
+
+func (state *nestiaCoreTransformState) parameterArguments(
+	call *shimast.CallExpression,
+	segments []string,
+	modulo *shimast.Node,
+	kind string,
+	typ *shimchecker.Type,
+) ([]string, bool, error) {
+	key := state.cacheKey(segments, kind, typ, nestiaCoreArgumentCount(call), kind == "TypedQuery")
+	return state.cachedArguments(key, func() ([]string, bool, error) {
+		return nestiaCoreParameterArguments(state.prog, state.options, call, modulo, kind, typ)
+	})
+}
+
+func (state *nestiaCoreTransformState) methodArguments(
+	file *shimast.SourceFile,
+	segments []string,
+	modulo *shimast.Node,
+	kind string,
+	typ *shimchecker.Type,
+	argCount int,
+) ([]string, error) {
+	key := state.cacheKey(segments, kind, typ, argCount, kind == "TypedQueryRoute")
+	arguments, _, err := state.cachedArguments(key, func() ([]string, bool, error) {
+		node, err := nestiaCoreMethodArgumentNode(state.prog, state.importer, state.ec, state.options, modulo, kind, typ)
+		if err != nil {
+			return nil, false, err
+		}
+		return []string{emitNestiaCoreExpression(state.prog, file, node, false)}, true, nil
+	})
+	return arguments, err
+}
+
+func (state *nestiaCoreTransformState) mcpRouteArguments(
+	file *shimast.SourceFile,
+	method *shimast.Node,
+	call *shimast.CallExpression,
+	typ *shimchecker.Type,
+) ([]string, error) {
+	node, err := nestiaCoreMcpRouteArgumentNode(state.prog, nil, nil, state.options, file, method, call, typ)
+	if err != nil {
+		return nil, err
+	}
+	return []string{emitNestiaCoreExpression(state.prog, file, node, false)}, nil
+}
+
+// nestiaCoreMethodArgumentNode builds the single appended decorator-argument
+// node for a method decorator (TypedRoute / TypedQueryRoute). The importer is
+// the shared ec-mode ImportProgrammer on the node-emit path; nil on the legacy
+// text path.
+func nestiaCoreMethodArgumentNode(
+	prog *driver.Program,
+	importer *nativecontext.ImportProgrammer, ec *shimprinter.EmitContext,
+	options nestiaCoreOptions,
+	modulo *shimast.Node,
+	kind string,
+	typ *shimchecker.Type,
+) (*shimast.Node, error) {
+	return safeNestiaCoreGenerateNode(func() (*shimast.Node, error) {
+		switch kind {
+		case "TypedQueryRoute":
+			return nestiaCoreGenerateTypedQueryRoute(prog, importer, ec, options, modulo, typ), nil
+		default:
+			return nestiaCoreGenerateTypedRoute(prog, importer, ec, options, modulo, typ), nil
+		}
+	})
+}
+
+func (state *nestiaCoreTransformState) cachedArguments(
+	key nestiaCoreCacheKey,
+	generate func() ([]string, bool, error),
+) ([]string, bool, error) {
+	if cached, ok := state.cache[key]; ok {
+		state.cacheHits++
+		return append([]string(nil), cached...), true, nil
+	}
+	state.cacheMisses++
+	arguments, ok, err := generate()
+	if err != nil || ok == false {
+		return arguments, ok, err
+	}
+	state.cache[key] = append([]string(nil), arguments...)
+	return append([]string(nil), arguments...), true, nil
+}
+
+func (state *nestiaCoreTransformState) cacheKey(
+	segments []string,
+	kind string,
+	typ *shimchecker.Type,
+	argCount int,
+	allowOptional bool,
+) nestiaCoreCacheKey {
+	return nestiaCoreCacheKey{
+		Kind:          kind,
+		Type:          typ,
+		TypeName:      nestiaCoreTypeNameText(state.prog, typ),
+		Modulo:        strings.Join(segments, "."),
+		Validate:      state.options.Validate,
+		Stringify:     state.options.Stringify,
+		StringifyNull: state.options.StringifyNull,
+		Llm:           state.options.Llm,
+		LlmStrict:     state.options.LlmStrict,
+		ArgCount:      argCount,
+		AllowOptional: allowOptional,
+	}
+}
+
+func nestiaCoreRawDecoratorCall(decorator *shimast.Node) (*shimast.CallExpression, []string, bool) {
+	if decorator == nil || decorator.Kind != NestiaCoreKindDecorator {
+		return nil, nil, false
+	}
+	expression := decorator.AsDecorator().Expression
+	if expression == nil || expression.Kind != shimast.KindCallExpression {
+		return nil, nil, false
+	}
+	call := expression.AsCallExpression()
+	segments := NestiaCoreExpressionSegments(call.Expression)
+	if len(segments) == 0 {
+		return nil, nil, false
+	}
+	return call, segments, true
+}
+
+func nestiaCoreDecoratorCall(prog *driver.Program, decorator *shimast.Node) (*shimast.CallExpression, []string, bool) {
+	call, segments, ok := nestiaCoreRawDecoratorCall(decorator)
+	if !ok {
+		return nil, nil, false
+	}
+	context := newNestiaCoreFileContext(shimast.GetSourceFileOfNode(decorator))
+	canonical := nestiaCoreCanonicalSegments(context, segments)
+	if nestiaCoreDecoratorReference(prog, context, decorator, segments, canonical) == false {
+		return nil, nil, false
+	}
+	return call, canonical, true
+}
+
+func newNestiaCoreFileContext(file *shimast.SourceFile) nestiaCoreFileContext {
+	context := nestiaCoreFileContext{
+		file:        file,
+		coreImports: map[string]string{},
+	}
+	if file == nil || file.Statements == nil {
+		return context
+	}
+	for _, stmt := range file.Statements.Nodes {
+		if stmt == nil || stmt.Kind != shimast.KindImportDeclaration {
+			continue
+		}
+		decl := stmt.AsImportDeclaration()
+		if decl == nil || decl.ImportClause == nil || decl.ModuleSpecifier == nil || decl.ModuleSpecifier.Kind != shimast.KindStringLiteral {
+			continue
+		}
+		if decl.ModuleSpecifier.Text() != "@nestia/core" {
+			continue
+		}
+		clause := decl.ImportClause.AsImportClause()
+		if clause == nil || clause.PhaseModifier == shimast.KindTypeKeyword {
+			continue
+		}
+		if name := clause.Name(); name != nil {
+			context.coreImports[name.Text()] = name.Text()
+		}
+		if clause.NamedBindings == nil || clause.NamedBindings.Kind != shimast.KindNamedImports {
+			continue
+		}
+		named := clause.NamedBindings.AsNamedImports()
+		if named == nil || named.Elements == nil {
+			continue
+		}
+		for _, elem := range named.Elements.Nodes {
+			if elem == nil {
+				continue
+			}
+			spec := elem.AsImportSpecifier()
+			if spec == nil || spec.IsTypeOnly {
+				continue
+			}
+			name := spec.Name()
+			if name != nil {
+				imported := name.Text()
+				if spec.PropertyName != nil {
+					imported = spec.PropertyName.Text()
+				}
+				context.coreImports[name.Text()] = imported
+			}
+		}
+	}
+	return context
+}
+
+func nestiaCoreCanonicalSegments(context nestiaCoreFileContext, segments []string) []string {
+	if len(segments) == 0 {
+		return segments
+	}
+	imported, ok := context.coreImports[segments[0]]
+	if !ok || imported == "" || imported == segments[0] {
+		return segments
+	}
+	canonical := append([]string{}, segments...)
+	canonical[0] = imported
+	return canonical
+}
+
+func nestiaCoreDecoratorReference(
+	prog *driver.Program,
+	context nestiaCoreFileContext,
+	decorator *shimast.Node,
+	segments []string,
+	canonical []string,
+) bool {
+	if len(segments) == 0 {
+		return false
+	}
+	if _, ok := context.coreImports[segments[0]]; ok {
+		return true
+	}
+	if nestiaCorePotentialDecoratorSegments(canonical) == false {
+		return false
+	}
+	return IsNestiaCoreCall(prog, decorator.AsDecorator().Expression)
+}
+
+func nestiaCorePotentialDecoratorSegments(segments []string) bool {
+	return nestiaCoreParameterKind(segments) != "" ||
+		nestiaCoreMethodKind(segments) != "" ||
+		(len(segments) != 0 && segments[len(segments)-1] == "WebSocketRoute")
+}
+
+func IsNestiaCoreCall(prog *driver.Program, node *shimast.Node) bool {
+	signature := prog.Checker.GetResolvedSignature(node)
+	if signature == nil || signature.Declaration() == nil {
+		return false
+	}
+	source := shimast.GetSourceFileOfNode(signature.Declaration())
+	if source == nil {
+		return false
+	}
+	location := filepath.ToSlash(source.FileName())
+	return strings.Contains(location, "@nestia/core/lib/") ||
+		strings.Contains(location, "packages/core/lib/") ||
+		strings.Contains(location, "@nestia/core/src/decorators/") ||
+		strings.Contains(location, "packages/core/src/decorators/")
+}
+
+func isNestiaCoreImportedExpression(node *shimast.Node, segments []string) bool {
+	if len(segments) == 0 {
+		return false
+	}
+	source := shimast.GetSourceFileOfNode(node)
+	if source == nil || source.Statements == nil {
+		return false
+	}
+	root := segments[0]
+	for _, stmt := range source.Statements.Nodes {
+		if stmt == nil || stmt.Kind != shimast.KindImportDeclaration {
+			continue
+		}
+		decl := stmt.AsImportDeclaration()
+		if decl == nil || decl.ImportClause == nil || decl.ModuleSpecifier == nil || decl.ModuleSpecifier.Kind != shimast.KindStringLiteral {
+			continue
+		}
+		if decl.ModuleSpecifier.Text() != "@nestia/core" {
+			continue
+		}
+		clause := decl.ImportClause.AsImportClause()
+		if clause == nil || clause.PhaseModifier == shimast.KindTypeKeyword {
+			continue
+		}
+		if name := clause.Name(); name != nil && name.Text() == root {
+			return true
+		}
+		if clause.NamedBindings == nil || clause.NamedBindings.Kind != shimast.KindNamedImports {
+			continue
+		}
+		named := clause.NamedBindings.AsNamedImports()
+		if named == nil || named.Elements == nil {
+			continue
+		}
+		for _, elem := range named.Elements.Nodes {
+			if elem == nil {
+				continue
+			}
+			spec := elem.AsImportSpecifier()
+			if spec == nil || spec.IsTypeOnly {
+				continue
+			}
+			name := spec.Name()
+			if name != nil && name.Text() == root {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func nestiaCoreParameterKind(segments []string) string {
+	suffixes := map[string]string{
+		"EncryptedBody":         "TypedBody",
+		"TypedBody":             "TypedBody",
+		"TypedHeaders":          "TypedHeaders",
+		"TypedParam":            "TypedParam",
+		"TypedQuery":            "TypedQuery",
+		"TypedQuery.Body":       "TypedQueryBody",
+		"TypedFormData.Body":    "TypedFormDataBody",
+		"McpRoute.Params":       "McpRouteParams",
+		"PlainBody":             "PlainBody",
+		"WebSocketRoute.Header": "TypedBody",
+		"WebSocketRoute.Param":  "TypedParam",
+		"WebSocketRoute.Query":  "TypedQuery",
+	}
+	for suffix, kind := range suffixes {
+		if nestiaCoreSegmentsHaveSuffix(segments, strings.Split(suffix, ".")) {
+			return kind
+		}
+	}
+	return ""
+}
+
+func nestiaCoreMethodKind(segments []string) string {
+	if len(segments) != 0 && segments[len(segments)-1] == "McpRoute" {
+		return "McpRoute"
+	}
+	if len(segments) < 2 {
+		return ""
+	}
+	methods := map[string]bool{"Get": true, "Post": true, "Patch": true, "Put": true, "Delete": true}
+	if methods[segments[len(segments)-1]] == false {
+		return ""
+	}
+	switch segments[len(segments)-2] {
+	case "EncryptedRoute", "TypedRoute":
+		return "TypedRoute"
+	case "TypedQuery":
+		return "TypedQueryRoute"
+	default:
+		return ""
+	}
+}
+
+func nestiaCoreParameterArguments(
+	prog *driver.Program,
+	options nestiaCoreOptions,
+	call *shimast.CallExpression,
+	modulo *shimast.Node,
+	kind string,
+	typ *shimchecker.Type,
+) ([]string, bool, error) {
+	nodes, ok, err := nestiaCoreParameterArgumentNodes(prog, nil, nil, options, call, modulo, kind, typ)
+	if err != nil || !ok {
+		return nil, ok, err
+	}
+	file := shimast.GetSourceFileOfNode(call.AsNode())
+	output := make([]string, 0, len(nodes))
+	for _, node := range nodes {
+		output = append(output, nestiaCoreArgumentNodeToText(prog, file, node))
+	}
+	return output, true, nil
+}
+
+// nestiaCoreArgumentNodeToText prints a single appended decorator-argument node
+// for the legacy text-splice path. Keyword nodes (undefined / true) print as
+// their literal text; validator nodes go through the type-stripping printer.
+func nestiaCoreArgumentNodeToText(prog *driver.Program, file *shimast.SourceFile, node *shimast.Node) string {
+	switch node.Kind {
+	case shimast.KindUndefinedKeyword:
+		return "undefined"
+	case shimast.KindTrueKeyword:
+		return "true"
+	}
+	return emitNestiaCoreExpression(prog, file, node, false)
+}
+
+// nestiaCoreParameterArgumentNodes builds the appended decorator-argument nodes
+// for a parameter decorator. The importer is the file-scoped ImportProgrammer:
+// on the node-emit path it is the shared ec-mode importer, so the validator's
+// runtime references resolve to tsgo-aliased namespace imports; nil keeps the
+// legacy text behavior. Returning nodes (not text) is the single source of truth
+// shared by the text path (nestiaCoreParameterArguments) and the AST emit path.
+func nestiaCoreParameterArgumentNodes(
+	prog *driver.Program,
+	importer *nativecontext.ImportProgrammer, ec *shimprinter.EmitContext,
+	options nestiaCoreOptions,
+	call *shimast.CallExpression,
+	modulo *shimast.Node,
+	kind string,
+	typ *shimchecker.Type,
+) ([]*shimast.Node, bool, error) {
+	argCount := nestiaCoreArgumentCount(call)
+	switch kind {
+	case "TypedBody", "TypedHeaders", "TypedQuery", "TypedQueryBody", "McpRouteParams", "PlainBody":
+		if argCount != 0 {
+			return nil, false, nil
+		}
+	case "TypedParam":
+		if argCount != 1 {
+			return nil, false, nil
+		}
+	case "TypedFormDataBody":
+		if argCount > 1 {
+			return nil, false, nil
+		}
+	}
+	node, err := safeNestiaCoreGenerateNode(func() (*shimast.Node, error) {
+		switch kind {
+		case "TypedBody":
+			return nestiaCoreGenerateTypedBody(prog, importer, ec, options, modulo, typ), nil
+		case "McpRouteParams":
+			return nestiaCoreGenerateMcpRouteParams(prog, importer, ec, options, modulo, typ), nil
+		case "TypedHeaders":
+			return nestiaCoreGenerateTypedHeaders(prog, importer, ec, options, modulo, typ), nil
+		case "TypedParam":
+			return nestiaCoreGenerateTypedParam(prog, importer, ec, modulo, typ), nil
+		case "TypedQuery":
+			return nestiaCoreGenerateTypedQuery(prog, importer, ec, options, modulo, typ, true), nil
+		case "TypedQueryBody":
+			return nestiaCoreGenerateTypedQuery(prog, importer, ec, options, modulo, typ, false), nil
+		case "TypedFormDataBody":
+			return nestiaCoreGenerateTypedFormDataBody(prog, importer, ec, options, modulo, typ), nil
+		case "PlainBody":
+			return nestiaCoreGeneratePlainBody(prog, importer, ec, modulo, typ), nil
+		default:
+			return nil, fmt.Errorf("unsupported parameter decorator %s", kind)
+		}
+	})
+	if err != nil {
+		return nil, false, err
+	}
+	output := []*shimast.Node{}
+	if kind == "TypedFormDataBody" && argCount == 0 {
+		output = append(output, nestiaCoreFactory.NewKeywordExpression(shimast.KindUndefinedKeyword))
+	}
+	output = append(output, node)
+	// TypedParam takes a third `validate?: boolean` argument (see
+	// packages/core/src/decorators/TypedParam.ts). When the configured
+	// validate mode starts with "validate", emit `true` so the runtime
+	// returns the detailed report shape instead of the single-error shape.
+	// The legacy TypedParamProgrammer applied the same conditional.
+	if kind == "TypedParam" && strings.HasPrefix(options.Validate, "validate") {
+		output = append(output, nestiaCoreFactory.NewKeywordExpression(shimast.KindTrueKeyword))
+	}
+	return output, true, nil
+}
+
+func nestiaCoreGenerateTypedBody(
+	prog *driver.Program,
+	importer *nativecontext.ImportProgrammer, ec *shimprinter.EmitContext,
+	options nestiaCoreOptions,
+	modulo *shimast.Node,
+	typ *shimchecker.Type,
+) *shimast.Node {
+	nestiaCoreValidateTypedBody(prog, options, typ)
+	context := nestiaCoreTypiaContext(prog, importer, ec, false, false, false)
+	name := nestiaCoreTypeName(prog, typ)
+	category := options.Validate
+	switch category {
+	case "assert":
+		return nestiaCoreValidatorObject("type", "assert", nativeprogrammers.AssertProgrammer.Write(nativeprogrammers.AssertProgrammer_IProps{
+			Context: context, Modulo: modulo, Type: typ, Name: name,
+			Config: nativeprogrammers.AssertProgrammer_IConfig{Equals: false, Guard: false},
+		}), ec)
+	case "is":
+		return nestiaCoreValidatorObject("type", "is", nativeprogrammers.IsProgrammer.Write(nativeprogrammers.IsProgrammer_IProps{
+			Context: context, Modulo: modulo, Type: typ, Name: name,
+			Config: nativeprogrammers.IsProgrammer_IConfig{Equals: false},
+		}), ec)
+	case "validateEquals":
+		return nestiaCoreValidatorObject("type", "validate", nativeprogrammers.ValidateProgrammer.Write(nativeprogrammers.ValidateProgrammer_IProps{
+			Context: context, Modulo: modulo, Type: typ, Name: name,
+			Config: nativeprogrammers.ValidateProgrammer_IConfig{Equals: true},
+		}), ec)
+	case "equals":
+		return nestiaCoreValidatorObject("type", "is", nativeprogrammers.IsProgrammer.Write(nativeprogrammers.IsProgrammer_IProps{
+			Context: context, Modulo: modulo, Type: typ, Name: name,
+			Config: nativeprogrammers.IsProgrammer_IConfig{Equals: true},
+		}), ec)
+	case "assertEquals":
+		return nestiaCoreValidatorObject("type", "assert", nativeprogrammers.AssertProgrammer.Write(nativeprogrammers.AssertProgrammer_IProps{
+			Context: context, Modulo: modulo, Type: typ, Name: name,
+			Config: nativeprogrammers.AssertProgrammer_IConfig{Equals: true, Guard: false},
+		}), ec)
+	case "assertClone":
+		return nestiaCoreValidatorObject("type", "assert", nativemisc.MiscAssertCloneProgrammer.Write(nativecontext.IProgrammerProps{
+			Context: context, Modulo: modulo, Type: typ, Name: name,
+		}), ec)
+	case "validateClone":
+		return nestiaCoreValidatorObject("type", "validate", nativemisc.MiscValidateCloneProgrammer.Write(nativecontext.IProgrammerProps{
+			Context: context, Modulo: modulo, Type: typ, Name: name,
+		}), ec)
+	case "assertPrune":
+		return nestiaCoreValidatorObject("type", "assert", nativemisc.MiscAssertPruneProgrammer.Write(nativecontext.IProgrammerProps{
+			Context: context, Modulo: modulo, Type: typ, Name: name,
+		}), ec)
+	case "validatePrune":
+		return nestiaCoreValidatorObject("type", "validate", nativemisc.MiscValidatePruneProgrammer.Write(nativecontext.IProgrammerProps{
+			Context: context, Modulo: modulo, Type: typ, Name: name,
+		}), ec)
+	default:
+		return nestiaCoreValidatorObject("type", "validate", nativeprogrammers.ValidateProgrammer.Write(nativeprogrammers.ValidateProgrammer_IProps{
+			Context: context, Modulo: modulo, Type: typ, Name: name,
+			Config: nativeprogrammers.ValidateProgrammer_IConfig{Equals: false},
+		}), ec)
+	}
+}
+
+// nestiaCoreGenerateTypedHeaders intentionally collapses the 10-mode validate
+// option down to {assert, is, validate}. Header values are strings keyed by
+// name; deep-clone and prune semantics that @TypedBody honors (assertClone,
+// assertPrune, validateClone, validatePrune, etc.) have no meaningful effect
+// on a flat string→string map. Pass-through to the base programmer is the
+// intended behavior, not a fallthrough — matches v6 parity. See also
+// nestiaCoreGenerateTypedQuery and nestiaCoreGenerateTypedFormDataBody.
+func nestiaCoreGenerateTypedHeaders(prog *driver.Program, importer *nativecontext.ImportProgrammer, ec *shimprinter.EmitContext, options nestiaCoreOptions, modulo *shimast.Node, typ *shimchecker.Type) *shimast.Node {
+	context := nestiaCoreTypiaContext(prog, importer, ec, false, false, false)
+	name := nestiaCoreTypeName(prog, typ)
+	category := options.Validate
+	if category == "is" || category == "equals" {
+		return nestiaCoreValidatorObject("type", "is", nativehttp.HttpIsHeadersProgrammer.Write(nativecontext.IProgrammerProps{Context: context, Modulo: modulo, Type: typ, Name: name}), ec)
+	}
+	if strings.HasPrefix(category, "validate") {
+		return nestiaCoreValidatorObject("type", "validate", nativehttp.HttpValidateHeadersProgrammer.Write(nativecontext.IProgrammerProps{Context: context, Modulo: modulo, Type: typ, Name: name}), ec)
+	}
+	return nestiaCoreValidatorObject("type", "assert", nativehttp.HttpAssertHeadersProgrammer.Write(nativecontext.IProgrammerProps{Context: context, Modulo: modulo, Type: typ, Name: name}), ec)
+}
+
+func nestiaCoreGenerateTypedParam(prog *driver.Program, importer *nativecontext.ImportProgrammer, ec *shimprinter.EmitContext, modulo *shimast.Node, typ *shimchecker.Type) *shimast.Node {
+	return nativehttp.HttpParameterProgrammer.Write(nativecontext.IProgrammerProps{
+		Context: nestiaCoreTypiaContext(prog, importer, ec, true, false, false),
+		Modulo:  modulo,
+		Type:    typ,
+		Name:    nestiaCoreTypeName(prog, typ),
+	})
+}
+
+func nestiaCoreGenerateTypedQuery(prog *driver.Program, importer *nativecontext.ImportProgrammer, ec *shimprinter.EmitContext, options nestiaCoreOptions, modulo *shimast.Node, typ *shimchecker.Type, allowOptional bool) *shimast.Node {
+	nestiaCoreValidateTypedQuery(prog, options, typ, allowOptional, "@nestia.core.TypedQuery")
+	context := nestiaCoreTypiaContext(prog, importer, ec, false, false, false)
+	name := nestiaCoreTypeName(prog, typ)
+	category := options.Validate
+	if category == "is" || category == "equals" {
+		return nestiaCoreValidatorObject("type", "is", nativehttp.HttpIsQueryProgrammer.Write(nativehttp.HttpIsQueryProgrammer_IProps{Context: context, Modulo: modulo, Type: typ, Name: name, AllowOptional: allowOptional}), ec)
+	}
+	if category == "validate" || category == "validateEquals" || category == "validateClone" || category == "validatePrune" {
+		return nestiaCoreValidatorObject("type", "validate", nativehttp.HttpValidateQueryProgrammer.Write(nativehttp.HttpValidateQueryProgrammer_IProps{Context: context, Modulo: modulo, Type: typ, Name: name, AllowOptional: allowOptional}), ec)
+	}
+	return nestiaCoreValidatorObject("type", "assert", nativehttp.HttpAssertQueryProgrammer.Write(nativehttp.HttpAssertQueryProgrammer_IProps{Context: context, Modulo: modulo, Type: typ, Name: name, AllowOptional: allowOptional}), ec)
+}
+
+func nestiaCoreGenerateTypedFormDataBody(prog *driver.Program, importer *nativecontext.ImportProgrammer, ec *shimprinter.EmitContext, options nestiaCoreOptions, modulo *shimast.Node, typ *shimchecker.Type) *shimast.Node {
+	context := nestiaCoreTypiaContext(prog, importer, ec, false, false, false)
+	name := nestiaCoreTypeName(prog, typ)
+	category := options.Validate
+	files := nestiaCoreFormDataFiles(prog, typ)
+	validator := nativehttp.HttpAssertFormDataProgrammer.Write(nativecontext.IProgrammerProps{Context: context, Modulo: modulo, Type: typ, Name: name})
+	key := "assert"
+	if category == "is" || category == "equals" {
+		key = "is"
+		validator = nativehttp.HttpIsFormDataProgrammer.Write(nativecontext.IProgrammerProps{Context: context, Modulo: modulo, Type: typ, Name: name})
+	} else if category == "validate" || category == "validateEquals" || category == "validateClone" || category == "validatePrune" {
+		key = "validate"
+		validator = nativehttp.HttpValidateFormDataProgrammer.Write(nativecontext.IProgrammerProps{Context: context, Modulo: modulo, Type: typ, Name: name})
+	}
+	f := nativecontext.EmitFactoryOf(nestiaCoreFactory, ec)
+	return f.NewObjectLiteralExpression(f.NewNodeList([]*shimast.Node{
+		nestiaCoreProperty("files", nestiaCoreFormDataFilesExpression(files, ec), ec),
+		nestiaCoreProperty("validator", nestiaCoreValidatorObject("type", key, validator, ec), ec),
+	}), true)
+}
+
+type nestiaCoreFormDataFile struct {
+	Name  string
+	Limit *int
+}
+
+func nestiaCoreFormDataFiles(prog *driver.Program, typ *shimchecker.Type) []nestiaCoreFormDataFile {
+	collection := schemametadata.NewMetadataCollection()
+	result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{
+		Checker: prog.Checker,
+		Options: nativefactories.MetadataFactory_IOptions{
+			Escape:   false,
+			Constant: true,
+			Absorb:   true,
+			Validate: nativehttp.HttpFormDataProgrammer.Validate,
+		},
+		Components: collection,
+		Type:       typ,
+	})
+	if result.Success == false {
+		panic(fmt.Errorf("failed to analyze form-data metadata: %d error(s)", len(result.Errors)))
+	}
+	files := []nestiaCoreFormDataFile{}
+	if result.Data == nil || len(result.Data.Objects) == 0 || result.Data.Objects[0] == nil || result.Data.Objects[0].Type == nil {
+		return files
+	}
+	for _, property := range result.Data.Objects[0].Type.Properties {
+		if property == nil || property.Value == nil {
+			continue
+		}
+		direct := nestiaCoreMetadataHasFile(property.Value)
+		array := nestiaCoreMetadataArrayHasFile(property.Value)
+		if direct == false && array == false {
+			continue
+		}
+		name, ok := nestiaCorePropertyStringKey(property)
+		if ok == false {
+			continue
+		}
+		var limit *int
+		if direct {
+			one := 1
+			limit = &one
+		}
+		files = append(files, nestiaCoreFormDataFile{
+			Name:  name,
+			Limit: limit,
+		})
+	}
+	return files
+}
+
+func nestiaCoreMetadataHasFile(metadata *schemametadata.MetadataSchema) bool {
+	if metadata == nil {
+		return false
+	}
+	for _, native := range metadata.Natives {
+		if native != nil && (native.Name == "File" || native.Name == "Blob") {
+			return true
+		}
+	}
+	return false
+}
+
+func nestiaCoreMetadataArrayHasFile(metadata *schemametadata.MetadataSchema) bool {
+	if metadata == nil {
+		return false
+	}
+	for _, array := range metadata.Arrays {
+		if array == nil || array.Type == nil || array.Type.Value == nil {
+			continue
+		}
+		if nestiaCoreMetadataHasFile(array.Type.Value) {
+			return true
+		}
+	}
+	return false
+}
+
+func nestiaCorePropertyStringKey(property *schemametadata.MetadataProperty) (string, bool) {
+	if property == nil || property.Key == nil {
+		return "", false
+	}
+	for _, constant := range property.Key.Constants {
+		if constant == nil || constant.Type != "string" {
+			continue
+		}
+		for _, value := range constant.Values {
+			if value == nil {
+				continue
+			}
+			name, ok := value.Value.(string)
+			if ok {
+				return name, true
+			}
+		}
+	}
+	return "", false
+}
+
+func nestiaCoreFormDataFilesExpression(files []nestiaCoreFormDataFile, ec *shimprinter.EmitContext) *shimast.Node {
+	f := nativecontext.EmitFactoryOf(nestiaCoreFactory, ec)
+	elements := make([]*shimast.Node, 0, len(files))
+	for _, file := range files {
+		limit := f.NewKeywordExpression(shimast.KindNullKeyword)
+		if file.Limit != nil {
+			limit = nativefactories.LiteralFactory.Write(*file.Limit)
+		}
+		elements = append(elements, f.NewObjectLiteralExpression(f.NewNodeList([]*shimast.Node{
+			nestiaCoreProperty("name", nativefactories.LiteralFactory.Write(file.Name), ec),
+			nestiaCoreProperty("limit", limit, ec),
+		}), true))
+	}
+	return f.NewArrayLiteralExpression(f.NewNodeList(elements), true)
+}
+
+func nestiaCoreGeneratePlainBody(prog *driver.Program, importer *nativecontext.ImportProgrammer, ec *shimprinter.EmitContext, modulo *shimast.Node, typ *shimchecker.Type) *shimast.Node {
+	nestiaCoreValidatePlainBody(prog, typ)
+	return nativeprogrammers.AssertProgrammer.Write(nativeprogrammers.AssertProgrammer_IProps{
+		Context: nestiaCoreTypiaContext(prog, importer, ec, false, false, false),
+		Modulo:  modulo,
+		Type:    typ,
+		Name:    nestiaCoreTypeName(prog, typ),
+		Config:  nativeprogrammers.AssertProgrammer_IConfig{Equals: false, Guard: false},
+	})
+}
+
+func nestiaCoreGenerateTypedRoute(prog *driver.Program, importer *nativecontext.ImportProgrammer, ec *shimprinter.EmitContext, options nestiaCoreOptions, modulo *shimast.Node, typ *shimchecker.Type) *shimast.Node {
+	nestiaCoreValidateTypedRoute(prog, options, typ)
+	if options.StringifyNull {
+		return nestiaCoreFactory.NewKeywordExpression(shimast.KindNullKeyword)
+	}
+	context := nestiaCoreTypiaContext(prog, importer, ec, false, false, false)
+	name := nestiaCoreTypeName(prog, typ)
+	switch options.Stringify {
+	case "is":
+		return nestiaCoreValidatorObject("type", "is", nativejson.JsonIsStringifyProgrammer.Write(nativecontext.IProgrammerProps{Context: context, Modulo: modulo, Type: typ, Name: name}), ec)
+	case "validate":
+		return nestiaCoreValidatorObject("type", "validate", nativejson.JsonValidateStringifyProgrammer.Write(nativecontext.IProgrammerProps{Context: context, Modulo: modulo, Type: typ, Name: name}), ec)
+	case "stringify":
+		return nestiaCoreValidatorObject("type", "stringify", nativejson.JsonStringifyProgrammer.Write(nativecontext.IProgrammerProps{Context: context, Modulo: modulo, Type: typ, Name: name}), ec)
+	case "validate.log":
+		return nestiaCoreValidatorObjectWithKey("type", "validate.log", "validate", nativejson.JsonValidateStringifyProgrammer.Write(nativecontext.IProgrammerProps{Context: context, Modulo: modulo, Type: typ, Name: name}), ec)
+	default:
+		return nestiaCoreValidatorObject("type", "assert", nativejson.JsonAssertStringifyProgrammer.Write(nativecontext.IProgrammerProps{Context: context, Modulo: modulo, Type: typ, Name: name}), ec)
+	}
+}
+
+func nestiaCoreGenerateTypedQueryRoute(prog *driver.Program, importer *nativecontext.ImportProgrammer, ec *shimprinter.EmitContext, options nestiaCoreOptions, modulo *shimast.Node, typ *shimchecker.Type) *shimast.Node {
+	nestiaCoreValidateTypedQueryRoute(prog, options, typ)
+	if options.StringifyNull {
+		return nestiaCoreFactory.NewKeywordExpression(shimast.KindNullKeyword)
+	}
+	switch options.Stringify {
+	case "is":
+		return nestiaCoreValidatorObject("type", "is", nestiaCoreHttpIsQuerifyProgrammer(prog, importer, ec, modulo, typ), ec)
+	case "validate":
+		return nestiaCoreValidatorObject("type", "validate", nestiaCoreHttpValidateQuerifyProgrammer(prog, importer, ec, modulo, typ), ec)
+	case "stringify":
+		return nestiaCoreValidatorObject("type", "stringify", nestiaCoreHttpQuerifyProgrammer(prog, ec, typ), ec)
+	default:
+		return nestiaCoreValidatorObject("type", "assert", nestiaCoreHttpAssertQuerifyProgrammer(prog, importer, ec, modulo, typ), ec)
+	}
+}
+
+// nestiaCoreTypiaContext builds the typia transform context for a single
+// validator generation. The importer argument is the file-scoped ImportProgrammer:
+// on the AST-integration emit path it is the shared, ec-mode importer (so every
+// generated validator references namespace imports tsgo's module-transform
+// aliases, and all injected imports collapse into one ToStatements() set). When
+// importer is nil a throwaway importer is allocated, preserving the legacy
+// text-splice behavior used by the `transform` / `check` source paths.
+func nestiaCoreTypiaContext(prog *driver.Program, importer *nativecontext.ImportProgrammer, ec *shimprinter.EmitContext, numeric bool, finite bool, functional bool) nativecontext.ITypiaContext {
+	if importer == nil {
+		importer = nativecontext.NewImportProgrammer(nativecontext.ImportProgrammer_IOptions{
+			InternalPrefix: "typia_transform_",
+			Runtime:        "typia",
+		})
+	}
+	return nativecontext.ITypiaContext{
+		Program:         prog,
+		CompilerOptions: prog.ParsedConfig.ParsedConfig.CompilerOptions,
+		Checker:         prog.Checker,
+		Options: nativecontext.ITransformOptions{
+			Numeric:    &numeric,
+			Finite:     &finite,
+			Functional: &functional,
+			Runtime:    "typia",
+		},
+		Importer: importer,
+		// Seed the emit context so typia's per-programmer factories
+		// (EmitFactoryOf(..., Context.Emit)) build emit-tracked nodes; without it
+		// the generated validator/stringifier nodes have no original link and
+		// tsgo's MarkLinkedReferences pass nil-panics during emit. nil on the
+		// legacy text path.
+		Emit: ec,
+	}
+}
+
+func nestiaCoreStrictMode(prog *driver.Program) bool {
+	if prog == nil || prog.ParsedConfig == nil || prog.ParsedConfig.ParsedConfig == nil || prog.ParsedConfig.ParsedConfig.CompilerOptions == nil {
+		return true
+	}
+	options := prog.ParsedConfig.ParsedConfig.CompilerOptions
+	return options.GetStrictOptionValue(options.StrictNullChecks)
+}
+
+func nestiaCoreLlmConfig(options nestiaCoreOptions) map[string]any {
+	return map[string]any{"strict": options.LlmStrict}
+}
+
+func nestiaCoreValidateTypedBody(prog *driver.Program, options nestiaCoreOptions, typ *shimchecker.Type) {
+	var validate nativefactories.MetadataFactory_Validator
+	if options.Llm {
+		validate = func(next struct {
+			Metadata *schemametadata.MetadataSchema
+			Explore  nativefactories.MetadataFactory_IExplore
+			Top      *schemametadata.MetadataSchema
+		}) []string {
+			return nativellm.LlmSchemaProgrammer.Validate(struct {
+				Config   map[string]any
+				Metadata *schemametadata.MetadataSchema
+				Explore  nativefactories.MetadataFactory_IExplore
+			}{
+				Config:   nestiaCoreLlmConfig(options),
+				Metadata: next.Metadata,
+				Explore:  next.Explore,
+			})
+		}
+	}
+	nativefactories.JsonMetadataFactory.Analyze(nativefactories.JsonMetadataFactory_IProps{
+		Method:   "@nestia.core.TypedBody",
+		Checker:  prog.Checker,
+		Type:     typ,
+		Validate: validate,
+	})
+}
+
+func nestiaCoreValidateTypedRoute(prog *driver.Program, options nestiaCoreOptions, typ *shimchecker.Type) {
+	if options.Llm == false {
+		return
+	}
+	nativefactories.JsonMetadataFactory.Analyze(nativefactories.JsonMetadataFactory_IProps{
+		Method:  "@nestia.core.TypedRoute",
+		Checker: prog.Checker,
+		Type:    typ,
+		Validate: func(next struct {
+			Metadata *schemametadata.MetadataSchema
+			Explore  nativefactories.MetadataFactory_IExplore
+			Top      *schemametadata.MetadataSchema
+		}) []string {
+			if next.Metadata == nil || next.Metadata.Size() == 0 {
+				return nil
+			}
+			return nativellm.LlmParametersProgrammer.Validate(struct {
+				Config   map[string]any
+				Metadata *schemametadata.MetadataSchema
+				Explore  nativefactories.MetadataFactory_IExplore
+			}{
+				Config:   nestiaCoreLlmConfig(options),
+				Metadata: next.Metadata,
+				Explore:  next.Explore,
+			})
+		},
+	})
+}
+
+func nestiaCoreValidateTypedQuery(prog *driver.Program, options nestiaCoreOptions, typ *shimchecker.Type, allowOptional bool, code string) {
+	if options.Llm == false {
+		return
+	}
+	collection := schemametadata.NewMetadataCollection()
+	result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{
+		Checker: prog.Checker,
+		Options: nativefactories.MetadataFactory_IOptions{
+			Escape:   false,
+			Constant: true,
+			Absorb:   true,
+			Validate: func(next struct {
+				Metadata *schemametadata.MetadataSchema
+				Explore  nativefactories.MetadataFactory_IExplore
+				Top      *schemametadata.MetadataSchema
+			}) []string {
+				errors := nativehttp.HttpQueryProgrammer.Validate(struct {
+					Metadata      *schemametadata.MetadataSchema
+					Explore       nativefactories.MetadataFactory_IExplore
+					Top           *schemametadata.MetadataSchema
+					AllowOptional bool
+				}{
+					Metadata:      next.Metadata,
+					Explore:       next.Explore,
+					Top:           next.Top,
+					AllowOptional: allowOptional,
+				})
+				errors = append(errors, nativellm.LlmSchemaProgrammer.Validate(struct {
+					Config   map[string]any
+					Metadata *schemametadata.MetadataSchema
+					Explore  nativefactories.MetadataFactory_IExplore
+				}{
+					Config:   nestiaCoreLlmConfig(options),
+					Metadata: next.Metadata,
+					Explore:  next.Explore,
+				})...)
+				return errors
+			},
+		},
+		Components: collection,
+		Type:       typ,
+	})
+	if result.Success == false {
+		panic(nativecontext.TransformerError_from(struct {
+			Code   string
+			Errors []nativecontext.TransformerError_MetadataFactory_IError
+		}{
+			Code:   code,
+			Errors: nestiaCoreMetadataErrors(result.Errors),
+		}))
+	}
+}
+
+func nestiaCoreValidateTypedQueryRoute(prog *driver.Program, options nestiaCoreOptions, typ *shimchecker.Type) {
+	if options.Llm == false {
+		return
+	}
+	collection := schemametadata.NewMetadataCollection()
+	result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{
+		Checker: prog.Checker,
+		Options: nativefactories.MetadataFactory_IOptions{
+			Escape:   false,
+			Constant: true,
+			Absorb:   true,
+			Validate: func(next struct {
+				Metadata *schemametadata.MetadataSchema
+				Explore  nativefactories.MetadataFactory_IExplore
+				Top      *schemametadata.MetadataSchema
+			}) []string {
+				errors := nativehttp.HttpQueryProgrammer.Validate(struct {
+					Metadata      *schemametadata.MetadataSchema
+					Explore       nativefactories.MetadataFactory_IExplore
+					Top           *schemametadata.MetadataSchema
+					AllowOptional bool
+				}{
+					Metadata:      next.Metadata,
+					Explore:       next.Explore,
+					Top:           next.Top,
+					AllowOptional: true,
+				})
+				if next.Metadata != nil && next.Metadata.Size() != 0 {
+					errors = append(errors, nativellm.LlmParametersProgrammer.Validate(struct {
+						Config   map[string]any
+						Metadata *schemametadata.MetadataSchema
+						Explore  nativefactories.MetadataFactory_IExplore
+					}{
+						Config:   nestiaCoreLlmConfig(options),
+						Metadata: next.Metadata,
+						Explore:  next.Explore,
+					})...)
+				}
+				return errors
+			},
+		},
+		Components: collection,
+		Type:       typ,
+	})
+	if result.Success == false {
+		panic(nativecontext.TransformerError_from(struct {
+			Code   string
+			Errors []nativecontext.TransformerError_MetadataFactory_IError
+		}{
+			Code:   "@nestia.core.TypedQueryRoute",
+			Errors: nestiaCoreMetadataErrors(result.Errors),
+		}))
+	}
+}
+
+func nestiaCoreValidatePlainBody(prog *driver.Program, typ *shimchecker.Type) {
+	collection := schemametadata.NewMetadataCollection()
+	result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{
+		Checker: prog.Checker,
+		Options: nativefactories.MetadataFactory_IOptions{
+			Escape:   false,
+			Constant: true,
+			Absorb:   true,
+			Validate: func(next struct {
+				Metadata *schemametadata.MetadataSchema
+				Explore  nativefactories.MetadataFactory_IExplore
+				Top      *schemametadata.MetadataSchema
+			}) []string {
+				return nestiaCoreValidatePlainBodyMetadata(next.Metadata)
+			},
+		},
+		Components: collection,
+		Type:       typ,
+	})
+	if result.Success == false {
+		panic(nativecontext.TransformerError_from(struct {
+			Code   string
+			Errors []nativecontext.TransformerError_MetadataFactory_IError
+		}{
+			Code:   "nestia.core.PlainBody",
+			Errors: nestiaCoreMetadataErrors(result.Errors),
+		}))
+	}
+}
+
+func nestiaCoreValidatePlainBodyMetadata(metadata *schemametadata.MetadataSchema) []string {
+	if metadata == nil {
+		return nil
+	}
+	errors := []string{}
+	expected := 0
+	for _, atomic := range metadata.Atomics {
+		if atomic != nil && atomic.Type == "string" {
+			expected = 1
+			break
+		}
+	}
+	expected += len(metadata.Templates)
+	for _, constant := range metadata.Constants {
+		if constant != nil && constant.Type == "string" {
+			expected += len(constant.Values)
+		}
+	}
+	if expected == 0 || expected != metadata.Size() {
+		errors = append(errors, "only string type is allowed")
+	}
+	if metadata.Nullable {
+		errors = append(errors, "do not allow nullable type")
+	} else if metadata.Any {
+		errors = append(errors, "do not allow any type")
+	}
+	return errors
+}
+
+func nestiaCoreMetadataErrors(errors []nativefactories.MetadataFactory_IError) []nativecontext.TransformerError_MetadataFactory_IError {
+	output := make([]nativecontext.TransformerError_MetadataFactory_IError, 0, len(errors))
+	for _, err := range errors {
+		output = append(output, nativecontext.TransformerError_MetadataFactory_IError{
+			Name: err.Name,
+			Explore: nativecontext.TransformerError_MetadataFactory_IExplore{
+				Object:    err.Explore.Object,
+				Property:  err.Explore.Property,
+				Parameter: err.Explore.Parameter,
+				Output:    err.Explore.Output,
+			},
+			Messages: err.Messages,
+		})
+	}
+	return output
+}
+
+func nestiaCoreValidatorObject(typeKey string, key string, validator *shimast.Node, ec *shimprinter.EmitContext) *shimast.Node {
+	return nestiaCoreValidatorObjectWithKey(typeKey, key, key, validator, ec)
+}
+
+func nestiaCoreValidatorObjectWithKey(typeKey string, typeValue string, validatorKey string, validator *shimast.Node, ec *shimprinter.EmitContext) *shimast.Node {
+	f := nativecontext.EmitFactoryOf(nestiaCoreFactory, ec)
+	return f.NewObjectLiteralExpression(f.NewNodeList([]*shimast.Node{
+		nestiaCoreProperty(typeKey, f.NewStringLiteral(typeValue, shimast.TokenFlagsNone), ec),
+		nestiaCoreProperty(validatorKey, validator, ec),
+	}), true)
+}
+
+func nestiaCoreProperty(name string, initializer *shimast.Node, ec *shimprinter.EmitContext) *shimast.Node {
+	f := nativecontext.EmitFactoryOf(nestiaCoreFactory, ec)
+	return f.NewPropertyAssignment(
+		nil,
+		nativefactories.IdentifierFactory.Identifier(name),
+		nil,
+		nil,
+		initializer,
+	)
+}
+
+// safeNestiaCoreGenerateNode runs a validator generator, recovering any panic
+// (a typia programmer raises one for user-facing transform errors) into an
+// error so the caller can surface a diagnostic instead of crashing the emit.
+// It is the node-emit twin of safeNestiaCoreGenerate, which additionally prints
+// the node to text for the legacy splice path.
+func safeNestiaCoreGenerateNode(generator func() (*shimast.Node, error)) (node *shimast.Node, err error) {
+	defer func() {
+		if exp := recover(); exp != nil {
+			if os.Getenv("NESTIA_NATIVE_DEBUG_STACK") != "" {
+				err = fmt.Errorf("%v\n%s", exp, debug.Stack())
+			} else {
+				err = fmt.Errorf("%v", exp)
+			}
+		}
+	}()
+	return generator()
+}
+
+func safeNestiaCoreGenerate(
+	generator func() (*shimast.Node, error),
+	prog *driver.Program,
+	file *shimast.SourceFile,
+	preserveTypes bool,
+) (text string, err error) {
+	defer func() {
+		if exp := recover(); exp != nil {
+			if os.Getenv("NESTIA_NATIVE_DEBUG_STACK") != "" {
+				err = fmt.Errorf("%v\n%s", exp, debug.Stack())
+			} else {
+				err = fmt.Errorf("%v", exp)
+			}
+		}
+	}()
+	node, err := generator()
+	if err != nil {
+		return "", err
+	}
+	return emitNestiaCoreExpression(prog, file, node, preserveTypes), nil
+}
+
+func emitNestiaCoreExpression(prog *driver.Program, file *shimast.SourceFile, node *shimast.Node, preserveTypes bool) string {
+	var text string
+	if preserveTypes {
+		text = emitNestiaPreservingTypesWithIdentifierSubstitutions(node, file, nil)
+	} else {
+		text = emitNestiaWithIdentifierSubstitutions(
+			node,
+			file,
+			identifierSubstitutionsForEmit(prog, file),
+		)
+	}
+	return cleanupNestiaCorePrintedExpression(text)
+}
+
+func cleanupNestiaCorePrintedExpression(text string) string {
+	text = strings.TrimSpace(text)
+	text = strings.TrimSuffix(text, ";")
+	text = nestiaCoreSingleParameterArrowPattern.ReplaceAllString(text, `${1}(${2}) =>`)
+	if strings.HasPrefix(text, "(") && strings.HasSuffix(text, ")") {
+		return text
+	}
+	if strings.Contains(text, "=>") || strings.Contains(text, "function") {
+		return "(" + text + ")"
+	}
+	return text
+}
+
+var nestiaCoreSingleParameterArrowPattern = regexp.MustCompile(`(^|[\s(=,:?])([A-Za-z_$][A-Za-z0-9_$]*) =>`)
+
+func NestiaCoreMethodReturnType(prog *driver.Program, node *shimast.Node) *shimchecker.Type {
+	if typ := nestiaCoreExplicitAsyncReturnType(prog, node); typ != nil {
+		return typ
+	}
+	signature := prog.Checker.GetSignatureFromDeclaration(node)
+	if signature == nil {
+		return nil
+	}
+	typ := prog.Checker.GetReturnTypeOfSignature(signature)
+	if typ == nil {
+		return nil
+	}
+	symbol := typ.Symbol()
+	if symbol != nil &&
+		nestiaCoreIsAsyncReturnWrapperSymbol(symbol.Name, symbol.Declarations) {
+		args := prog.Checker.GetTypeArguments(typ)
+		if len(args) == 1 {
+			return args[0]
+		}
+	}
+	return typ
+}
+
+func nestiaCoreExplicitAsyncReturnType(prog *driver.Program, node *shimast.Node) *shimchecker.Type {
+	if prog == nil || prog.Checker == nil || node == nil || node.FunctionLikeData() == nil {
+		return nil
+	}
+	typeNode := node.FunctionLikeData().Type
+	if typeNode == nil || typeNode.Kind != shimast.KindTypeReference {
+		return nil
+	}
+	ref := typeNode.AsTypeReferenceNode()
+	if ref == nil || ref.TypeArguments == nil || len(ref.TypeArguments.Nodes) != 1 {
+		return nil
+	}
+	if nestiaCoreIsAsyncReturnWrapperReference(prog, ref.TypeName) == false {
+		return nil
+	}
+	return prog.Checker.GetTypeFromTypeNode(ref.TypeArguments.Nodes[0])
+}
+
+func nestiaCoreIsAsyncReturnWrapperReference(
+	prog *driver.Program,
+	node *shimast.Node,
+) bool {
+	name := nestiaCoreTypeNodeText(node)
+	if name == "Promise" {
+		return true
+	}
+	if name != "Observable" || prog == nil || prog.Checker == nil {
+		return false
+	}
+	symbol := prog.Checker.GetSymbolAtLocation(node)
+	return nestiaCoreIsRxjsObservableImport(node) ||
+		(symbol != nil && nestiaCoreIsRxjsDeclarations(symbol.Declarations))
+}
+
+func nestiaCoreIsAsyncReturnWrapperSymbol(
+	name string,
+	declarations []*shimast.Node,
+) bool {
+	if name == "Promise" {
+		return true
+	}
+	return name == "Observable" && nestiaCoreIsRxjsDeclarations(declarations)
+}
+
+func nestiaCoreIsRxjsDeclarations(declarations []*shimast.Node) bool {
+	for _, decl := range declarations {
+		sourceFile := shimast.GetSourceFileOfNode(decl)
+		if sourceFile == nil {
+			continue
+		}
+		file := filepath.ToSlash(sourceFile.FileName())
+		if strings.Contains(file, "/node_modules/rxjs/") {
+			return true
+		}
+	}
+	return false
+}
+
+func nestiaCoreIsRxjsObservableImport(node *shimast.Node) bool {
+	source, ok := SourceFileText(shimast.GetSourceFileOfNode(node))
+	return ok && nestiaCoreHasNamedImport(source, "rxjs", "Observable", "Observable")
+}
+
+func nestiaCoreHasNamedImport(
+	source string,
+	module string,
+	imported string,
+	local string,
+) bool {
+	for _, match := range nestiaCoreImportFromPattern.FindAllStringSubmatch(source, -1) {
+		if len(match) < 3 || match[2] != module {
+			continue
+		}
+		open := strings.Index(match[1], "{")
+		close := strings.LastIndex(match[1], "}")
+		if open < 0 || close <= open {
+			continue
+		}
+		for _, part := range strings.Split(match[1][open+1:close], ",") {
+			fields := strings.Fields(strings.TrimPrefix(strings.TrimSpace(part), "type "))
+			if len(fields) == 1 && fields[0] == local && imported == local {
+				return true
+			}
+			if len(fields) == 3 &&
+				fields[0] == imported &&
+				fields[1] == "as" &&
+				fields[2] == local {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+var nestiaCoreImportFromPattern = regexp.MustCompile(
+	`(?s)import\s+(?:type\s+)?(.+?)\s+from\s+["']([^"']+)["']`,
+)
+
+func nestiaCoreTypeNodeText(node *shimast.Node) string {
+	if node == nil {
+		return ""
+	}
+	source, ok := SourceFileText(shimast.GetSourceFileOfNode(node))
+	if ok == false {
+		return ""
+	}
+	start, end := node.Pos(), node.End()
+	if start < 0 || end > len(source) || start >= end {
+		return ""
+	}
+	return strings.TrimSpace(source[start:end])
+}
+
+func nestiaCoreShouldSkipMethodDecorator(prog *driver.Program, call *shimast.CallExpression) bool {
+	count := nestiaCoreArgumentCount(call)
+	if count >= 2 {
+		return true
+	}
+	if count == 1 {
+		last := call.Arguments.Nodes[0]
+		if last.Kind == shimast.KindObjectLiteralExpression {
+			return true
+		}
+		if nestiaCoreHasPathLiteralArgument(call) {
+			return false
+		}
+		typ := prog.Checker.GetTypeAtLocation(last)
+		if typ != nil && typ.Flags()&shimchecker.TypeFlagsObject != 0 &&
+			shimchecker.IsTupleType(typ) == false &&
+			shimchecker.Checker_isArrayType(prog.Checker, typ) == false {
+			return true
+		}
+	}
+	return false
+}
+
+func nestiaCoreHasPathLiteralArgument(call *shimast.CallExpression) bool {
+	source, ok := SourceFileText(shimast.GetSourceFileOfNode(call.AsNode()))
+	if !ok {
+		return false
+	}
+	open, close, ok := callArgumentBounds(source, call)
+	if !ok {
+		return false
+	}
+	text := strings.TrimSpace(source[open+1 : close])
+	return strings.HasPrefix(text, `"`) ||
+		strings.HasPrefix(text, `'`) ||
+		strings.HasPrefix(text, "`") ||
+		strings.HasPrefix(text, "[")
+}
+
+func nestiaCoreArgumentCount(call *shimast.CallExpression) int {
+	if call == nil || call.Arguments == nil {
+		return 0
+	}
+	return len(call.Arguments.Nodes)
+}
+
+func callArgumentBounds(source string, call *shimast.CallExpression) (int, int, bool) {
+	if call == nil || call.AsNode() == nil || call.Expression == nil {
+		return 0, 0, false
+	}
+	start := call.Expression.End()
+	end := call.AsNode().End()
+	if start < 0 || end > len(source) || start >= end {
+		start = call.AsNode().Pos()
+	}
+	open := strings.IndexByte(source[start:end], '(')
+	if open < 0 {
+		return 0, 0, false
+	}
+	open += start
+	close, ok := matchNativeParen(source, open)
+	return open, close, ok
+}
+
+func appendArgumentsText(current string, arguments []string) string {
+	current = strings.TrimSpace(current)
+	next := strings.Join(arguments, ", ")
+	if current == "" {
+		return next
+	}
+	return current + ", " + next
+}
+
+func NestiaCoreExpressionSegments(node *shimast.Node) []string {
+	if node == nil {
+		return nil
+	}
+	if node.Kind == shimast.KindIdentifier {
+		if id := node.AsIdentifier(); id != nil {
+			return []string{id.Text}
+		}
+	}
+	if node.Kind == shimast.KindPropertyAccessExpression {
+		access := node.AsPropertyAccessExpression()
+		if access == nil {
+			return nil
+		}
+		left := NestiaCoreExpressionSegments(access.Expression)
+		name := access.Name()
+		if len(left) == 0 || name == nil || name.Kind != shimast.KindIdentifier {
+			return nil
+		}
+		return append(left, name.AsIdentifier().Text)
+	}
+	return nil
+}
+
+func nestiaCoreModuloNode(node *shimast.Node) *shimast.Node {
+	segments := NestiaCoreExpressionSegments(node)
+	if len(segments) == 0 {
+		return nestiaCoreFactory.NewIdentifier("nestia_core_transform")
+	}
+	return nestiaCoreFactory.NewIdentifier(strings.Join(segments, "_"))
+}
+
+func nestiaCoreTypeName(prog *driver.Program, typ *shimchecker.Type) *string {
+	name := nestiaCoreTypeNameText(prog, typ)
+	return &name
+}
+
+type nestiaCoreTypeNameCacheKey struct {
+	checker *shimchecker.Checker
+	typ     *shimchecker.Type
+}
+
+var nestiaCoreTypeNameCache sync.Map
+
+func nestiaCoreTypeNameText(prog *driver.Program, typ *shimchecker.Type) string {
+	if prog != nil && prog.Checker != nil && typ != nil {
+		key := nestiaCoreTypeNameCacheKey{checker: prog.Checker, typ: typ}
+		if cached, ok := nestiaCoreTypeNameCache.Load(key); ok {
+			return cached.(string)
+		}
+		name := prog.Checker.TypeToString(typ)
+		nestiaCoreTypeNameCache.Store(key, name)
+		return name
+	}
+	return "any"
+}
+
+func nestiaCoreSegmentsHaveSuffix(segments []string, suffix []string) bool {
+	if len(suffix) > len(segments) {
+		return false
+	}
+	offset := len(segments) - len(suffix)
+	for i, part := range suffix {
+		if segments[offset+i] != part {
+			return false
+		}
+	}
+	return true
+}
+
+func nestiaCoreTargetCandidates(prog *driver.Program, site nestiaCoreSite) []string {
+	if len(site.Segments) == 0 {
+		return nil
+	}
+	candidates := []string{strings.Join(site.Segments, ".")}
+	substitutions := identifierSubstitutionsForEmit(prog, site.File)
+	if substitutions != nil {
+		if mapped, ok := substitutions[site.Segments[0]]; ok {
+			parts := append([]string{mapped}, site.Segments[1:]...)
+			candidates = append(candidates, strings.Join(parts, "."))
+		}
+	}
+	sort.SliceStable(candidates, func(i, j int) bool {
+		return len(candidates[i]) > len(candidates[j])
+	})
+	return candidates
+}
+
+func identifierSubstitutionsForEmit(program *driver.Program, file any) map[string]string {
+	if program == nil {
+		return nil
+	}
+	sourceFile, ok := file.(*shimast.SourceFile)
+	if ok == false {
+		return nil
+	}
+	return commonJSImportIdentifierSubstitutions(sourceFile)
+}
+
+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 {
+		if stmt == nil || stmt.Kind != shimast.KindImportDeclaration {
+			continue
+		}
+		decl := stmt.AsImportDeclaration()
+		if decl == nil || decl.ImportClause == nil || decl.ModuleSpecifier == nil || decl.ModuleSpecifier.Kind != shimast.KindStringLiteral {
+			continue
+		}
+		clause := decl.ImportClause.AsImportClause()
+		if clause == nil || clause.PhaseModifier == shimast.KindTypeKeyword {
+			continue
+		}
+		base := commonJSImportAliasBase(decl.ModuleSpecifier.Text())
+		counts[base]++
+		moduleAlias := base + "_" + strconv.Itoa(counts[base])
+		if name := clause.Name(); name != nil {
+			output[name.Text()] = moduleAlias + ".default"
+		}
+		if clause.NamedBindings == nil || clause.NamedBindings.Kind != shimast.KindNamedImports {
+			continue
+		}
+		named := clause.NamedBindings.AsNamedImports()
+		if named == nil || named.Elements == nil {
+			continue
+		}
+		for _, elem := range named.Elements.Nodes {
+			if elem == nil {
+				continue
+			}
+			spec := elem.AsImportSpecifier()
+			if spec == nil || spec.IsTypeOnly {
+				continue
+			}
+			name := spec.Name()
+			if name == nil {
+				continue
+			}
+			local := name.Text()
+			imported := local
+			if spec.PropertyName != nil {
+				imported = spec.PropertyName.Text()
+			}
+			output[local] = moduleAlias + "." + imported
+		}
+	}
+	if len(output) == 0 {
+		output = nil
+	}
+	commonJSImportIdentifierSubstitutionsCache.Store(file, commonJSImportIdentifierSubstitutionsCacheEntry{value: output})
+	return output
+}
+
+func commonJSImportAliasBase(module string) string {
+	base := strings.TrimSuffix(filepath.Base(module), filepath.Ext(module))
+	if base == "" || base == "." || base == string(filepath.Separator) {
+		base = "mod"
+	}
+	var builder strings.Builder
+	for _, r := range base {
+		if r == '_' || r == '$' || unicode.IsLetter(r) || unicode.IsDigit(r) {
+			builder.WriteRune(r)
+		} else {
+			builder.WriteByte('_')
+		}
+	}
+	text := builder.String()
+	if text == "" {
+		text = "mod"
+	}
+	first := []rune(text)[0]
+	if first != '_' && first != '$' && !unicode.IsLetter(first) {
+		text = "_" + text
+	}
+	return text
+}
+
+func nestiaCoreDiagnostic(site nestiaCoreSite, message string) Diagnostic {
+	line, column := 0, 0
+	if site.File != nil && site.Call != nil {
+		if pos := site.Call.AsNode().Pos(); pos >= 0 {
+			l, c := shimscanner.GetECMALineAndByteOffsetOfPosition(site.File, pos)
+			line, column = l+1, c+1
+		}
+	}
+	return Diagnostic{
+		File:    site.FilePath,
+		Line:    line,
+		Column:  column,
+		Code:    "nestia.core." + site.Kind,
+		Message: message,
+	}
+}
+
+func nestiaCoreGlobalDiagnostic(code string, message string) Diagnostic {
+	return Diagnostic{
+		Code:    code,
+		Message: message,
+	}
+}