typia 15.1.0 → 15.2.0

package/native/core/programmers/protobuf/ProtobufEncodeProgrammer.go

@@ -61,10 +61,8 @@ type protobufEncodeProgrammer_IUnion struct {
 
 const protobufEncodeProgrammer_PREFIX = "_pe"
 
-var protobufEncodeProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (protobufEncodeProgrammerNamespace) Decompose(props ProtobufEncodeProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
-  f := nativecontext.EmitFactoryOf(protobufEncodeProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   collection := schemametadata.NewMetadataCollection()
   metadata := nativefactories.ProtobufFactory.Metadata(nativefactories.ProtobufFactory_IProps{
     Method:     protobufEncodeProgrammer_method_text(props.Modulo),
@@ -148,7 +146,7 @@ func (protobufEncodeProgrammerNamespace) Write(props ProtobufEncodeProgrammer_IP
     Type:    props.Type,
     Name:    props.Name,
   })
-  return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{
+  return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{Emit: props.Context.Emit,
     Modulo:  props.Modulo,
     Functor: functor,
     Result:  result,
@@ -163,7 +161,7 @@ type protobufEncodeProgrammer_writeEncoderProps struct {
 }
 
 func protobufEncodeProgrammer_write_encoder(props protobufEncodeProgrammer_writeEncoderProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufEncodeProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   functors := []*shimast.Node{}
   for _, object := range props.Collection.Objects() {
     if nativehelpers.ProtobufUtil.IsStaticObject(object) == false {
@@ -260,7 +258,7 @@ type protobufEncodeProgrammer_writeObjectFunctionProps struct {
 }
 
 func protobufEncodeProgrammer_write_object_function(props protobufEncodeProgrammer_writeObjectFunctionProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufEncodeProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   body := []*shimast.Node{}
   guarded := props.Object.Recursive && props.Functor.Visited()
   if guarded {
@@ -331,7 +329,7 @@ type protobufEncodeProgrammer_decodePropertyProps struct {
 }
 
 func protobufEncodeProgrammer_decode_property(props protobufEncodeProgrammer_decodePropertyProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufEncodeProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   union := []protobufEncodeProgrammer_IUnion{}
   bigintCandidates := protobufEncodeProgrammer_bigintCandidates(props.Protobuf.Union)
   numberCandidates := protobufEncodeProgrammer_numberCandidates(props.Protobuf.Union)
@@ -542,7 +540,7 @@ func protobufEncodeProgrammer_decode_bigint(props struct {
   Input      *shimast.Node
   Index      *int
 }, emit *shimprinter.EmitContext) protobufEncodeProgrammer_IUnion {
-  f := nativecontext.EmitFactoryOf(protobufEncodeProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   return protobufEncodeProgrammer_IUnion{
     Is: func() *shimast.Node {
       typeof := protobufEncodeProgrammer_strict_equal(
@@ -553,7 +551,7 @@ func protobufEncodeProgrammer_decode_bigint(props struct {
       if len(props.Candidates) == 1 {
         return typeof
       }
-      return protobufEncodeProgrammer_logical_and(typeof, nativefactories.NumericRangeFactory.Bigint(props.Type, props.Input), emit)
+      return protobufEncodeProgrammer_logical_and(typeof, nativefactories.NumericRangeFactory.Bigint(props.Type, props.Input, emit), emit)
     },
     Value: func() *shimast.Node {
       expressions := []*shimast.Node{}
@@ -575,7 +573,7 @@ func protobufEncodeProgrammer_decode_number(props struct {
   Input      *shimast.Node
   Index      *int
 }, emit *shimprinter.EmitContext) protobufEncodeProgrammer_IUnion {
-  f := nativecontext.EmitFactoryOf(protobufEncodeProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   return protobufEncodeProgrammer_IUnion{
     Is: func() *shimast.Node {
       typeof := protobufEncodeProgrammer_strict_equal(
@@ -586,7 +584,7 @@ func protobufEncodeProgrammer_decode_number(props struct {
       if len(props.Candidates) == 1 {
         return typeof
       }
-      return protobufEncodeProgrammer_logical_and(typeof, nativefactories.NumericRangeFactory.Number(props.Type, props.Input), emit)
+      return protobufEncodeProgrammer_logical_and(typeof, nativefactories.NumericRangeFactory.Number(props.Type, props.Input, emit), emit)
     },
     Value: func() *shimast.Node {
       expressions := []*shimast.Node{}
@@ -688,7 +686,7 @@ type protobufEncodeProgrammer_decodeArrayProps struct {
 }
 
 func protobufEncodeProgrammer_decode_array(props protobufEncodeProgrammer_decodeArrayProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufEncodeProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   value := props.Schema.Value
   wire := nativehelpers.VARIANT
   if protobufEncodeProgrammer_schemaType(value) == "object" || protobufEncodeProgrammer_schemaType(value) == "bytes" || protobufEncodeProgrammer_schemaType(value) == "string" {
@@ -760,7 +758,7 @@ type protobufEncodeProgrammer_decodeObjectProps struct {
 }
 
 func protobufEncodeProgrammer_decode_object(props protobufEncodeProgrammer_decodeObjectProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufEncodeProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   object := protobufEncodeProgrammer_objectSchema(props.Schema)
   objectIndex := 0
   if object != nil {
@@ -791,7 +789,7 @@ type protobufEncodeProgrammer_decodeMapProps struct {
 }
 
 func protobufEncodeProgrammer_decode_map(props protobufEncodeProgrammer_decodeMapProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufEncodeProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   each := []*shimast.Node{
     f.NewExpressionStatement(protobufEncodeProgrammer_decode_tag(struct {
       Wire  nativehelpers.ProtobufWire
@@ -839,7 +837,7 @@ type protobufEncodeProgrammer_exploreObjectsProps struct {
 }
 
 func protobufEncodeProgrammer_explore_objects(props protobufEncodeProgrammer_exploreObjectsProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufEncodeProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   out := func(schema schemaprotobuf.IProtobufPropertyType) *shimast.Node {
     if protobufEncodeProgrammer_schemaType(schema) == "object" {
       return protobufEncodeProgrammer_decode_object(protobufEncodeProgrammer_decodeObjectProps{
@@ -880,7 +878,7 @@ func protobufEncodeProgrammer_explore_objects(props protobufEncodeProgrammer_exp
   }
   specifications := nativehelpers.UnionPredicator.Object(objects)
   if len(specifications) == 0 {
-    condition := nativeiterate.Decode_union_object(nativeiterate.Decode_union_objectProps{
+    condition := nativeiterate.Decode_union_object(nativeiterate.Decode_union_objectProps{Emit: props.Context.Emit,
       Checker: func(v nativeiterate.Decode_union_object_next) *shimast.Node {
         return nativeprogrammers.IsProgrammer.Decode_object(nativeprogrammers.IsProgrammer_DecodeObjectProps{
           Context: props.Context,
@@ -1023,7 +1021,7 @@ type protobufEncodeProgrammer_throwProps struct {
 }
 
 func protobufEncodeProgrammer_create_throw_error(props protobufEncodeProgrammer_throwProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufEncodeProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   return f.NewExpressionStatement(
     f.NewCallExpression(
       protobufEncodeProgrammer_internal(props.Context, "throwTypeGuardError"),
@@ -1042,7 +1040,7 @@ func protobufEncodeProgrammer_create_throw_error(props protobufEncodeProgrammer_
 }
 
 func protobufEncodeProgrammer_callWriter(method string, args []*shimast.Node, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufEncodeProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   return f.NewCallExpression(
     nativefactories.IdentifierFactory.Access(emit, f.NewIdentifier("writer"), method),
     nil,
@@ -1053,7 +1051,7 @@ func protobufEncodeProgrammer_callWriter(method string, args []*shimast.Node, em
 }
 
 func protobufEncodeProgrammer_expressionBlock(expressions []*shimast.Node, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufEncodeProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   statements := make([]*shimast.Node, 0, len(expressions))
   for _, expr := range expressions {
     statements = append(statements, f.NewExpressionStatement(expr))
@@ -1062,7 +1060,7 @@ func protobufEncodeProgrammer_expressionBlock(expressions []*shimast.Node, emit
 }
 
 func protobufEncodeProgrammer_chainUnion(union []protobufEncodeProgrammer_IUnion, context nativecontext.ITypiaContext, functor *nativehelpers.FunctionProgrammer, input *shimast.Node, expected string) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufEncodeProgrammer_factory, context.Emit)
+  f := nativecontext.NodeFactoryOf(context.Emit)
   var next *shimast.Node
   for i := len(union) - 1; i >= 0; i-- {
     var elseStatement *shimast.Node
@@ -1086,17 +1084,17 @@ func protobufEncodeProgrammer_chainUnion(union []protobufEncodeProgrammer_IUnion
 }
 
 func protobufEncodeProgrammer_strict_equal(left *shimast.Node, right *shimast.Node, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufEncodeProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   return f.NewBinaryExpression(nil, left, nil, f.NewToken(shimast.KindEqualsEqualsEqualsToken), right)
 }
 
 func protobufEncodeProgrammer_strict_not_equal(left *shimast.Node, right *shimast.Node, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufEncodeProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   return f.NewBinaryExpression(nil, left, nil, f.NewToken(shimast.KindExclamationEqualsEqualsToken), right)
 }
 
 func protobufEncodeProgrammer_logical_and(left *shimast.Node, right *shimast.Node, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufEncodeProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   return f.NewBinaryExpression(nil, left, nil, f.NewToken(shimast.KindAmpersandAmpersandToken), right)
 }
 
@@ -1249,7 +1247,7 @@ func protobufEncodeProgrammer_import_type(context nativecontext.ITypiaContext, p
   if importer := context.Importer; importer != nil {
     return importer.Type(props)
   }
-  f := nativecontext.EmitFactoryOf(protobufEncodeProgrammer_factory, context.Emit)
+  f := nativecontext.NodeFactoryOf(context.Emit)
   if str, ok := props.Name.(string); ok {
     return f.NewTypeReferenceNode(f.NewIdentifier(str), f.NewNodeList(props.Arguments))
   }
@@ -1260,7 +1258,7 @@ func protobufEncodeProgrammer_internal(context nativecontext.ITypiaContext, name
   if importer := context.Importer; importer != nil {
     return importer.Internal(name)
   }
-  f := nativecontext.EmitFactoryOf(protobufEncodeProgrammer_factory, context.Emit)
+  f := nativecontext.NodeFactoryOf(context.Emit)
   return f.NewIdentifier(name)
 }
 

package/native/core/programmers/protobuf/ProtobufIsDecodeProgrammer.go

@@ -48,10 +48,8 @@ type ProtobufIsDecodeProgrammer_DecomposeProps struct {
   Name    *string
 }
 
-var protobufIsDecodeProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (protobufIsDecodeProgrammerNamespace) Decompose(props ProtobufIsDecodeProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
-  f := nativecontext.EmitFactoryOf(protobufIsDecodeProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   isContext := props.Context
   functional := false
   numeric := false
@@ -132,7 +130,7 @@ func (protobufIsDecodeProgrammerNamespace) Write(props ProtobufIsDecodeProgramme
     Type:    props.Type,
     Name:    props.Name,
   })
-  return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{
+  return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{Emit: props.Context.Emit,
     Modulo:  props.Modulo,
     Functor: functor,
     Result:  result,

package/native/core/programmers/protobuf/ProtobufIsEncodeProgrammer.go

@@ -48,10 +48,8 @@ type ProtobufIsEncodeProgrammer_DecomposeProps struct {
   Name    *string
 }
 
-var protobufIsEncodeProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (protobufIsEncodeProgrammerNamespace) Decompose(props ProtobufIsEncodeProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
-  f := nativecontext.EmitFactoryOf(protobufIsEncodeProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   isContext := props.Context
   functional := false
   finite := true
@@ -125,7 +123,7 @@ func (protobufIsEncodeProgrammerNamespace) Write(props ProtobufIsEncodeProgramme
     Type:    props.Type,
     Name:    props.Name,
   })
-  return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{
+  return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{Emit: props.Context.Emit,
     Modulo:  props.Modulo,
     Functor: functor,
     Result:  result,

package/native/core/programmers/protobuf/ProtobufMessageProgrammer.go

@@ -36,10 +36,8 @@ type protobufMessageProgrammer_Hierarchy struct {
   Order    []string
 }
 
-var protobufMessageProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (protobufMessageProgrammerNamespace) Write(props ProtobufMessageProgrammer_IProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufMessageProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   collection := schemametadata.NewMetadataCollection()
   nativefactories.ProtobufFactory.Metadata(nativefactories.ProtobufFactory_IProps{
     Method:     "typia.protobuf.message",

package/native/core/programmers/protobuf/ProtobufValidateDecodeProgrammer.go

@@ -48,10 +48,8 @@ type ProtobufValidateDecodeProgrammer_DecomposeProps struct {
   Name    *string
 }
 
-var protobufValidateDecodeProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (protobufValidateDecodeProgrammerNamespace) Decompose(props ProtobufValidateDecodeProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
-  f := nativecontext.EmitFactoryOf(protobufValidateDecodeProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   validateContext := props.Context
   functional := false
   numeric := false
@@ -121,7 +119,7 @@ func (protobufValidateDecodeProgrammerNamespace) Write(props ProtobufValidateDec
     Type:    props.Type,
     Name:    props.Name,
   })
-  return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{
+  return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{Emit: props.Context.Emit,
     Modulo:  props.Modulo,
     Functor: functor,
     Result:  result,

package/native/core/programmers/protobuf/ProtobufValidateEncodeProgrammer.go

@@ -48,10 +48,8 @@ type ProtobufValidateEncodeProgrammer_DecomposeProps struct {
   Name    *string
 }
 
-var protobufValidateEncodeProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (protobufValidateEncodeProgrammerNamespace) Decompose(props ProtobufValidateEncodeProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
-  f := nativecontext.EmitFactoryOf(protobufValidateEncodeProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   validateContext := props.Context
   functional := false
   finite := true
@@ -144,7 +142,7 @@ func (protobufValidateEncodeProgrammerNamespace) Write(props ProtobufValidateEnc
     Type:    props.Type,
     Name:    props.Name,
   })
-  return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{
+  return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{Emit: props.Context.Emit,
     Modulo:  props.Modulo,
     Functor: functor,
     Result:  result,
@@ -155,7 +153,7 @@ func protobufValidateEncodeProgrammer_import_type(context nativecontext.ITypiaCo
   if importer := context.Importer; importer != nil {
     return importer.Type(props)
   }
-  f := nativecontext.EmitFactoryOf(protobufValidateEncodeProgrammer_factory, context.Emit)
+  f := nativecontext.NodeFactoryOf(context.Emit)
   if str, ok := props.Name.(string); ok {
     return f.NewTypeReferenceNode(f.NewIdentifier(str), f.NewNodeList(props.Arguments))
   }

package/native/core/programmers/protobuf/protobuf_programmer_helper_coverage_test.go

@@ -335,7 +335,7 @@ func TestProtobufProgrammerHelperCoverage(t *testing.T) {
   }
   if protobufDecodeProgrammer_write_object_function_body(protobufDecodeProgrammer_objectBodyProps{
     Context: nativecontext.ITypiaContext{},
-    Condition: protobufDecodeProgrammer_factory.NewKeywordExpression(
+    Condition: nativecontext.NodeFactoryOf().NewKeywordExpression(
       shimast.KindTrueKeyword,
     ),
     Tag:    "tag",

package/native/core/programmers/reflect/ReflectLiteralsProgrammer.go

@@ -26,10 +26,8 @@ type ReflectLiteralsProgrammer_IProps struct {
   Type    *shimchecker.Type
 }
 
-var reflectLiteralsProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (reflectLiteralsProgrammerNamespace) Write(props ReflectLiteralsProgrammer_IProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(reflectLiteralsProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{
     Checker: props.Context.Checker,
     Options: nativefactories.MetadataFactory_IOptions{

package/native/core/schemas/metadata/MetadataCollection.go

@@ -1158,10 +1158,10 @@ func metadataCollection_markVisiting(
 }
 
 func metadataCollection_getName(symbol *nativeast.Symbol) string {
-  if symbol == nil || len(symbol.Declarations) == 0 || symbol.Declarations[0].Parent == nil {
+  if symbol == nil || len(nativeast.SymbolDeclarationsOf(symbol)) == 0 || nativeast.SymbolDeclarationsOf(symbol)[0].Parent == nil {
     return "__type"
   }
-  return metadataCollection_exploreName(symbol.Declarations[0].Parent, strings.ReplaceAll(symbol.Name, "\uFFFD", "__"))
+  return metadataCollection_exploreName(nativeast.SymbolDeclarationsOf(symbol)[0].Parent, strings.ReplaceAll(nativeast.SymbolNameOf(symbol), "\uFFFD", "__"))
 }
 
 func metadataCollection_exploreName(node *nativeast.Node, name string) string {

package/native/core/schemas/metadata/MetadataDefaultLibrary.go

@@ -80,7 +80,7 @@ func MetadataDefaultLibrary_is(checker *nativechecker.Checker, source *nativeast
       }
     }
   }
-  return MetadataDefaultLibrary_isFileNamed(source.FileName())
+  return MetadataDefaultLibrary_isFileNamed(string(source.FileName()))
 }
 
 // MetadataDefaultLibrary_isFileNamed is the registry's file-name fallback,

package/native/core/schemas/metadata/MetadataDependency.go

@@ -358,15 +358,15 @@ func metadataDependency_touchDeclarations(
   // name selects, so all of it belongs to the identity channel -- the alias hops
   // as much as the terminus.
   report := listener.Callee
-  if symbol.Flags&nativeast.SymbolFlagsAlias != 0 {
+  if nativeast.SymbolFlagsOf(symbol)&nativeast.SymbolFlagsAlias != 0 {
     metadataDependency_touchPath(checker, listener, symbol, report)
     if resolved := nativechecker.Checker_getAliasedSymbol(checker, symbol); resolved != nil {
       symbol = resolved
     }
   }
-  for _, declaration := range symbol.Declarations {
+  for _, declaration := range nativeast.SymbolDeclarationsOf(symbol) {
     if src := nativeast.GetSourceFileOfNode(declaration); src != nil {
-      report(src.FileName())
+      report(string(src.FileName()))
     }
     if nested && metadataDependency_calleeBounded(declaration) == false {
       listener.unbounded()
@@ -420,12 +420,12 @@ func metadataDependency_touchVisited(
     return
   }
   visited[symbol] = true
-  for _, declaration := range symbol.Declarations {
+  for _, declaration := range nativeast.SymbolDeclarationsOf(symbol) {
     if declaration == nil {
       continue
     }
     if src := nativeast.GetSourceFileOfNode(declaration); src != nil {
-      listener.File(src.FileName())
+      listener.File(string(src.FileName()))
     }
     if metadataDependency_bounded(declaration) == false {
       listener.unbounded()
@@ -890,7 +890,7 @@ func metadataDependency_resolve(
   if symbol == nil {
     return nil
   }
-  if symbol.Flags&nativeast.SymbolFlagsAlias != 0 {
+  if nativeast.SymbolFlagsOf(symbol)&nativeast.SymbolFlagsAlias != 0 {
     // The type walk: a hop reached here was reached because a consulted type is
     // built from what it publishes, so it reports on the consultation channel.
     metadataDependency_touchPath(checker, listener, symbol, listener.File)
@@ -921,7 +921,7 @@ func metadataDependency_touchPath(
   report func(fileName string),
 ) {
   visited := map[*nativeast.Symbol]bool{}
-  for symbol != nil && symbol.Flags&nativeast.SymbolFlagsAlias != 0 && visited[symbol] == false {
+  for symbol != nil && nativeast.SymbolFlagsOf(symbol)&nativeast.SymbolFlagsAlias != 0 && visited[symbol] == false {
     visited[symbol] = true
     declaration := nativechecker.Checker_getDeclarationOfAliasSymbol(checker, symbol)
     if declaration == nil {
@@ -929,7 +929,7 @@ func metadataDependency_touchPath(
     }
     // The file that WRITES this hop (the barrel's own `export ... from` line).
     if src := nativeast.GetSourceFileOfNode(declaration); src != nil {
-      report(src.FileName())
+      report(string(src.FileName()))
     }
     specifier := metadataDependency_moduleSpecifier(declaration)
     if specifier == nil {
@@ -948,9 +948,9 @@ func metadataDependency_touchPath(
     if module == nil {
       return
     }
-    for _, moduleDeclaration := range module.Declarations {
+    for _, moduleDeclaration := range nativeast.SymbolDeclarationsOf(module) {
       if src := nativeast.GetSourceFileOfNode(moduleDeclaration); src != nil {
-        report(src.FileName())
+        report(string(src.FileName()))
       }
     }
     symbol = metadataDependency_exported(module, declaration)
@@ -969,13 +969,13 @@ func metadataDependency_touchPath(
 // stops the walk at the module already reported, which loses no edge: the
 // terminus is resolved separately by the checker.
 func metadataDependency_exported(module *nativeast.Symbol, declaration *nativeast.Node) *nativeast.Symbol {
-  if module.Exports == nil {
+  if nativeast.SymbolExportsOf(module) == nil {
     return nil
   }
   switch declaration.Kind {
   case nativeast.KindImportClause:
     // ast.InternalSymbolNameDefault, which the shim does not re-export.
-    return module.Exports["default"]
+    return nativeast.SymbolExportsOf(module)["default"]
   case nativeast.KindImportSpecifier, nativeast.KindExportSpecifier:
     name := declaration.PropertyNameOrName()
     if name == nil {
@@ -983,7 +983,7 @@ func metadataDependency_exported(module *nativeast.Symbol, declaration *nativeas
     }
     switch name.Kind {
     case nativeast.KindIdentifier, nativeast.KindStringLiteral:
-      return module.Exports[name.Text()]
+      return nativeast.SymbolExportsOf(module)[name.Text()]
     }
   }
   return nil

package/native/core/utils/PromiseTypeFactory.go

@@ -55,13 +55,13 @@ func (promiseTypeFactoryNamespace) satisfiesGlobalContract(checker *shimchecker.
     return false
   }
   for _, property := range checker.GetPropertiesOfType(contract) {
-    if property.Name == "then" || (len(property.Name) != 0 && property.Name[0] == 0xfe) {
+    if shimast.SymbolNameOf(property) == "then" || (len(shimast.SymbolNameOf(property)) != 0 && shimast.SymbolNameOf(property)[0] == 0xfe) {
       // GetPromisedTypeOfPromise verifies the thenable shape. Conditional
       // Promise inference ignores well-known-symbol augmentations.
       continue
     }
-    required := checker.GetTypeOfPropertyOfType(contract, property.Name)
-    candidate := checker.GetTypeOfPropertyOfType(t, property.Name)
+    required := checker.GetTypeOfPropertyOfType(contract, shimast.SymbolNameOf(property))
+    candidate := checker.GetTypeOfPropertyOfType(t, shimast.SymbolNameOf(property))
     if required == nil || candidate == nil || !checker.IsTypeAssignableTo(candidate, required) {
       return false
     }

package/native/go.mod

@@ -2,9 +2,8 @@ module github.com/samchon/typia/packages/typia/native
 
 go 1.26
 
-// Build-time floor: the driver reference-graph SDK
-// (driver.NewTransformGraph / driver.TransformGraph / driver.TransformOutputKey)
-// this plugin consumes exists only in ttsc >= 0.19.2. That floor is enforced
+// Build-time floor: the version-neutral Symbol and path APIs consumed by
+// this plugin exist only in ttsc >= 0.34.0. That floor is enforced
 // through typia's package.json `ttsc` peerDependency, not here: ttsc builds
 // this plugin from source on the user's machine and its buildSourcePlugin
 // generates `replace github.com/samchon/ttsc/packages/ttsc v0.0.0 =>
@@ -18,6 +17,7 @@ require (
 	github.com/microsoft/typescript-go/shim/parser v0.0.0
 	github.com/microsoft/typescript-go/shim/printer v0.0.0
 	github.com/microsoft/typescript-go/shim/scanner v0.0.0
+	github.com/microsoft/typescript-go/shim/tspath v0.0.0
 	github.com/samchon/ttsc/packages/ttsc v0.0.0
 	golang.org/x/text v0.36.0
 )
@@ -29,7 +29,6 @@ require (
 	github.com/microsoft/typescript-go/shim/bundled v0.0.0 // indirect
 	github.com/microsoft/typescript-go/shim/diagnosticwriter v0.0.0 // indirect
 	github.com/microsoft/typescript-go/shim/tsoptions v0.0.0 // indirect
-	github.com/microsoft/typescript-go/shim/tspath v0.0.0 // indirect
 	github.com/microsoft/typescript-go/shim/vfs v0.0.0 // indirect
 	github.com/microsoft/typescript-go/shim/vfs/cachedvfs v0.0.0 // indirect
 	github.com/microsoft/typescript-go/shim/vfs/osvfs v0.0.0 // indirect

package/native/go.work

@@ -1,4 +1,4 @@
-go 1.26
+go 1.27
 
 use (
 	.

package/native/transform/CallExpressionTransformer.go

@@ -92,7 +92,7 @@ func (callExpressionTransformerNamespace) Transform(props CallExpressionTransfor
   if sourceFile == nil {
     return props.Expression.AsNode()
   }
-  location, _ := filepath.Abs(sourceFile.FileName())
+  location, _ := filepath.Abs(string(sourceFile.FileName()))
   module, ok := callExpressionTransformer_targetModule(location)
   if ok == false {
     callExpressionTransformer_rejectShadowedTypia(props, location)
@@ -102,7 +102,7 @@ func (callExpressionTransformerNamespace) Transform(props CallExpressionTransfor
   if typ == nil || typ.Symbol() == nil {
     return props.Expression.AsNode()
   }
-  name := typ.Symbol().Name
+  name := shimast.SymbolNameOf(typ.Symbol())
   return CallExpressionTransformer.TransformKnown(CallExpressionTransformer_TransformKnownProps{
     Context:    props.Context,
     Expression: props.Expression,
@@ -210,10 +210,10 @@ func callExpressionTransformer_rejectShadowedTypia(props CallExpressionTransform
     return
   }
   symbol := props.Context.Checker.GetSymbolAtLocation(root)
-  if symbol == nil || symbol.Flags&shimast.SymbolFlagsAlias == 0 {
+  if symbol == nil || shimast.SymbolFlagsOf(symbol)&shimast.SymbolFlagsAlias == 0 {
     return
   }
-  for _, declaration := range symbol.Declarations {
+  for _, declaration := range shimast.SymbolDeclarationsOf(symbol) {
     if callExpressionTransformer_importsTypia(declaration) == false {
       continue
     }

package/native/transform/FileTransformer.go

@@ -54,8 +54,6 @@ type FileTransformer_IEnvironments struct {
 // @evidence contracts/common.md#meaningful-documentation The doc states the mapping.
 type FileTransformer_Type func(file *shimast.SourceFile) *shimast.SourceFile
 
-var fileTransformer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 // Transform builds the per-file transformer of a host. Every file gets its own importer, a TransformerError raised while a node is
 // transformed becomes a diagnostic and leaves the node unchanged, and the
 // importer's statements are inserted after the leading directive prologue.
@@ -114,7 +112,7 @@ func fileTransformer_iterate_file(context nativecontext.ITypiaContext, file *shi
   if context.Emit != nil {
     visitor = context.Emit.NewNodeVisitor(visit)
   } else {
-    visitor = shimast.NewNodeVisitor(visit, fileTransformer_factory, shimast.NodeVisitorHooks{})
+    visitor = shimast.NewNodeVisitor(visit, nativecontext.NodeFactoryOf(context.Emit), shimast.NodeVisitorHooks{})
   }
   output := visitor.VisitNode(file.AsNode())
   if output == nil {
@@ -192,7 +190,7 @@ func fileTransformer_inject_imports(file *shimast.SourceFile, imports []*shimast
   if file == nil || len(imports) == 0 {
     return file
   }
-  f := nativecontext.EmitFactoryOf(fileTransformer_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   index := fileTransformer_find_import_injection_index(file)
   nodes := make([]*shimast.Node, 0, len(file.Statements.Nodes)+len(imports))
   nodes = append(nodes, file.Statements.Nodes[:index]...)

package/native/transform/features/RandomTransformer.go

@@ -15,10 +15,8 @@ type randomTransformerNamespace struct{}
 
 var RandomTransformer = randomTransformerNamespace{}
 
-var randomTransformer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (randomTransformerNamespace) Transform(props nativetransform.ITransformProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomTransformer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   if props.Expression == nil || props.Expression.TypeArguments == nil || len(props.Expression.TypeArguments.Nodes) == 0 {
     panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{
       Code:    nativehelpers.ModuloMethodText(props.Modulo),

package/native/transform/features/compare/CompareEqualTransformer.go

@@ -16,7 +16,7 @@ func (compareEqualTransformerNamespace) Transform(props nativeinternal.ITransfor
 }
 
 func compareEqualTransformer_scalar(props nativeinternal.ITransformProps, method string, cover bool) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(shimast.NewNodeFactory(shimast.NodeFactoryHooks{}), props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   if props.Expression == nil || props.Expression.Arguments == nil || len(props.Expression.Arguments.Nodes) < 2 {
     panic(nativeinternal.NewTransformerError(nativeinternal.TransformerError_IProps{
       Code:    "typia." + method,

package/native/transform/features/compare/CompareLessTransformer.go

@@ -16,7 +16,7 @@ func (compareLessTransformerNamespace) Transform(props nativeinternal.ITransform
 }
 
 func compareLessTransformer_scalar(props nativeinternal.ITransformProps, method string) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(shimast.NewNodeFactory(shimast.NodeFactoryHooks{}), props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   if props.Expression == nil || props.Expression.Arguments == nil || len(props.Expression.Arguments.Nodes) < 2 {
     panic(nativeinternal.NewTransformerError(nativeinternal.TransformerError_IProps{
       Code:    "typia." + method,

package/native/transform/features/functional/FunctionalGenericTransformer.go

@@ -90,8 +90,8 @@ func (functionalGenericTransformerNamespace) Transform(spec FunctionalGenericTra
     }
 
     var declaration *shimast.Node
-    if symbol := typ.Symbol(); symbol != nil && len(symbol.Declarations) != 0 {
-      declaration = symbol.Declarations[0]
+    if symbol := typ.Symbol(); symbol != nil && len(shimast.SymbolDeclarationsOf(symbol)) != 0 {
+      declaration = shimast.SymbolDeclarationsOf(symbol)[0]
     }
     var init *shimast.Node
     if props.Expression.Arguments != nil && len(props.Expression.Arguments.Nodes) > 1 {

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

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

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

@@ -76,7 +76,7 @@ func llmEvaluation_declarationProbabilityErrors(files []*shimast.SourceFile) []n
               }
               errors = append(errors, nativellmprogrammers.LlmEvaluationProgrammer_IError{
                 Accessor: "$input",
-                Message:  fmt.Sprintf("LLM evaluation @probability on %s %s in %s is unsupported; put it on a decision property or enum member.", kind, name, file.FileName()),
+                Message:  fmt.Sprintf("LLM evaluation @probability on %s %s in %s is unsupported; put it on a decision property or enum member.", kind, name, string(file.FileName())),
               })
               break
             }

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

@@ -46,7 +46,7 @@ func (llmEvaluationTransformerNamespace) Transform(props nativetransform.ITransf
   if props.Context.Program != nil && schemametadata.MetadataDependency_active(props.Context.Checker) {
     for _, file := range props.Context.Program.SourceFiles() {
       if file != nil {
-        schemametadata.MetadataDependency_touchFile(props.Context.Checker, file.FileName())
+        schemametadata.MetadataDependency_touchFile(props.Context.Checker, string(file.FileName()))
       }
     }
   }