typia 15.1.0 → 15.2.0

package/native/core/programmers/plain/PlainIsPruneProgrammer.go

@@ -37,10 +37,8 @@ type PlainIsPruneProgrammer_DecomposeProps struct {
   Name *string
 }
 
-var plainIsPruneProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (plainIsPruneProgrammerNamespace) Decompose(props PlainIsPruneProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
-  f := nativecontext.EmitFactoryOf(plainIsPruneProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   is := nativeprogrammers.IsProgrammer.Decompose(nativeprogrammers.IsProgrammer_DecomposeProps{
     Context: props.Context,
     Functor: props.Functor,
@@ -114,7 +112,7 @@ func (plainIsPruneProgrammerNamespace) Write(props nativecontext.IProgrammerProp
     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/plain/PlainPruneProgrammer.go

@@ -49,10 +49,8 @@ type PlainPruneProgrammer_DecomposeProps struct {
 
 const plainPruneProgrammer_PREFIX = "_p"
 
-var plainPruneProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (plainPruneProgrammerNamespace) Decompose(props PlainPruneProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
-  f := nativecontext.EmitFactoryOf(plainPruneProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   config := plainPruneProgrammer_configure(struct {
     Context nativecontext.ITypiaContext
     Functor *nativehelpers.FunctionProgrammer
@@ -97,7 +95,7 @@ func (plainPruneProgrammerNamespace) Write(props nativecontext.IProgrammerProps)
     Name:      props.Name,
     Validated: false,
   })
-  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,
@@ -110,7 +108,7 @@ func plainPruneProgrammer_write_array_functions(props struct {
   Functor    *nativehelpers.FunctionProgrammer
   Collection *schemametadata.MetadataCollection
 }) []*shimast.Node {
-  f := nativecontext.EmitFactoryOf(plainPruneProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   output := []*shimast.Node{}
   for _, typ := range props.Collection.Arrays() {
     if typ.Recursive == false {
@@ -125,7 +123,7 @@ func plainPruneProgrammer_write_array_functions(props struct {
       Value: f.NewArrowFunction(
         nil,
         nil,
-        f.NewNodeList(nativeinternal.FeatureProgrammer.ParameterDeclarations(nativeinternal.FeatureProgrammer_ParameterDeclarationsProps{
+        f.NewNodeList(nativeinternal.FeatureProgrammer.ParameterDeclarations(nativeinternal.FeatureProgrammer_ParameterDeclarationsProps{Emit: props.Context.Emit,
           Config: nativeinternal.FeatureProgrammer_ParameterConfig{Path: props.Config.Path, Trace: props.Config.Trace, Visited: props.Functor.Visited()},
           Type:   nativefactories.TypeFactory.Keyword("any", props.Context.Emit),
           Input:  f.NewIdentifier("input"),
@@ -165,7 +163,7 @@ func plainPruneProgrammer_write_tuple_functions(props struct {
   Functor    *nativehelpers.FunctionProgrammer
   Collection *schemametadata.MetadataCollection
 }) []*shimast.Node {
-  f := nativecontext.EmitFactoryOf(plainPruneProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   output := []*shimast.Node{}
   for _, tuple := range props.Collection.Tuples() {
     if tuple.Recursive == false {
@@ -180,7 +178,7 @@ func plainPruneProgrammer_write_tuple_functions(props struct {
       Value: f.NewArrowFunction(
         nil,
         nil,
-        f.NewNodeList(nativeinternal.FeatureProgrammer.ParameterDeclarations(nativeinternal.FeatureProgrammer_ParameterDeclarationsProps{
+        f.NewNodeList(nativeinternal.FeatureProgrammer.ParameterDeclarations(nativeinternal.FeatureProgrammer_ParameterDeclarationsProps{Emit: props.Context.Emit,
           Config: nativeinternal.FeatureProgrammer_ParameterConfig{Path: props.Config.Path, Trace: props.Config.Trace, Visited: props.Functor.Visited()},
           Type:   nativefactories.TypeFactory.Keyword("any", props.Context.Emit),
           Input:  f.NewIdentifier("input"),
@@ -219,7 +217,7 @@ func plainPruneProgrammer_decode(props struct {
   Metadata *schemametadata.MetadataSchema
   Explore  nativeinternal.FeatureProgrammer_IExplore
 }) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(plainPruneProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   if plainPruneProgrammer_filter(props.Metadata) == false {
     return f.NewBlock(f.NewNodeList(nil), false)
   }
@@ -265,7 +263,7 @@ func plainPruneProgrammer_decode(props struct {
     unions = append(unions, plainPruneProgrammer_IUnion{
       Type: "array",
       Is: func() *shimast.Node {
-        return nativefactories.ExpressionFactory.IsArray(props.Input)
+        return nativefactories.ExpressionFactory.IsArray(props.Input, props.Context.Emit)
       },
       Value: func() *shimast.Node {
         explore := props.Explore
@@ -286,7 +284,7 @@ func plainPruneProgrammer_decode(props struct {
     unions = append(unions, plainPruneProgrammer_IUnion{
       Type: "native",
       Is: func() *shimast.Node {
-        return nativefactories.ExpressionFactory.IsInstanceOf(native.Name, props.Input)
+        return nativefactories.ExpressionFactory.IsInstanceOf(native.Name, props.Input, props.Context.Emit)
       },
       Value: func() *shimast.Node {
         return f.NewBlock(f.NewNodeList(nil), true)
@@ -297,7 +295,7 @@ func plainPruneProgrammer_decode(props struct {
     unions = append(unions, plainPruneProgrammer_IUnion{
       Type: "set",
       Is: func() *shimast.Node {
-        return nativefactories.ExpressionFactory.IsInstanceOf("Set", props.Input)
+        return nativefactories.ExpressionFactory.IsInstanceOf("Set", props.Input, props.Context.Emit)
       },
       Value: func() *shimast.Node {
         return f.NewBlock(f.NewNodeList(nil), true)
@@ -308,7 +306,7 @@ func plainPruneProgrammer_decode(props struct {
     unions = append(unions, plainPruneProgrammer_IUnion{
       Type: "map",
       Is: func() *shimast.Node {
-        return nativefactories.ExpressionFactory.IsInstanceOf("Map", props.Input)
+        return nativefactories.ExpressionFactory.IsInstanceOf("Map", props.Input, props.Context.Emit)
       },
       Value: func() *shimast.Node {
         return f.NewBlock(f.NewNodeList(nil), true)
@@ -323,7 +321,7 @@ func plainPruneProgrammer_decode(props struct {
           CheckNull:  true,
           CheckArray: false,
           Input:      props.Input,
-        })
+        }, props.Context.Emit)
       },
       Value: func() *shimast.Node {
         explore := props.Explore
@@ -375,12 +373,12 @@ func plainPruneProgrammer_to_statement(node *shimast.Node, emit *shimprinter.Emi
   if node == nil || node.Kind == shimast.KindBlock || node.Kind == shimast.KindReturnStatement {
     return node
   }
-  f := nativecontext.EmitFactoryOf(plainPruneProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   return f.NewExpressionStatement(node)
 }
 
 func plainPruneProgrammer_top_level_body(body *shimast.Node, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(plainPruneProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   statements := []*shimast.Node{}
   if body != nil && body.Kind == shimast.KindBlock {
     statements = append(statements, body.Statements()...)
@@ -423,13 +421,13 @@ type plainPruneProgrammer_decodeArrayProps struct {
 }
 
 func plainPruneProgrammer_decode_array(props plainPruneProgrammer_decodeArrayProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(plainPruneProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   if props.Array.Type.Recursive {
     return f.NewCallExpression(
       f.NewIdentifier(props.Functor.UseLocal(fmt.Sprintf("%sa%d", props.Config.Prefix, *props.Array.Type.Index))),
       nil,
       nil,
-      f.NewNodeList(nativeinternal.FeatureProgrammer.ArgumentsArray(nativeinternal.FeatureProgrammer_ArgumentsArrayProps{
+      f.NewNodeList(nativeinternal.FeatureProgrammer.ArgumentsArray(nativeinternal.FeatureProgrammer_ArgumentsArrayProps{Emit: props.Context.Emit,
         Config:  nativeinternal.FeatureProgrammer_ArgumentsArrayConfig{Path: props.Config.Path, Trace: props.Config.Trace, Visited: props.Functor.Visited()},
         Explore: plainCloneProgrammer_explore_with(props.Explore, "function", "array"),
         Input:   props.Input,
@@ -441,7 +439,7 @@ func plainPruneProgrammer_decode_array(props plainPruneProgrammer_decodeArrayPro
 }
 
 func plainPruneProgrammer_decode_array_inline(props plainPruneProgrammer_decodeArrayProps) *shimast.Node {
-  return nativeinternal.FeatureProgrammer.Decode_array(nativeinternal.FeatureProgrammer_DecodeArrayProps{
+  return nativeinternal.FeatureProgrammer.Decode_array(nativeinternal.FeatureProgrammer_DecodeArrayProps{Emit: props.Context.Emit,
     Config: nativeinternal.FeatureProgrammer_DecodeArrayConfig{
       Trace:   props.Config.Trace,
       Path:    props.Config.Path,
@@ -475,13 +473,13 @@ type plainPruneProgrammer_decodeTupleProps struct {
 }
 
 func plainPruneProgrammer_decode_tuple(props plainPruneProgrammer_decodeTupleProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(plainPruneProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   if props.Tuple.Type.Recursive {
     return f.NewCallExpression(
       f.NewIdentifier(props.Functor.UseLocal(fmt.Sprintf("%st%d", props.Config.Prefix, *props.Tuple.Type.Index))),
       nil,
       nil,
-      f.NewNodeList(nativeinternal.FeatureProgrammer.ArgumentsArray(nativeinternal.FeatureProgrammer_ArgumentsArrayProps{
+      f.NewNodeList(nativeinternal.FeatureProgrammer.ArgumentsArray(nativeinternal.FeatureProgrammer_ArgumentsArrayProps{Emit: props.Context.Emit,
         Config:  nativeinternal.FeatureProgrammer_ArgumentsArrayConfig{Path: props.Config.Path, Trace: props.Config.Trace, Visited: props.Functor.Visited()},
         Explore: plainCloneProgrammer_explore_with(props.Explore, "function", props.Explore.From),
         Input:   props.Input,
@@ -509,7 +507,7 @@ type plainPruneProgrammer_decodeTupleInlineProps struct {
 }
 
 func plainPruneProgrammer_decode_tuple_inline(props plainPruneProgrammer_decodeTupleInlineProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(plainPruneProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   elements := []*shimast.Node{}
   for index, elem := range props.Tuple.Elements {
     if elem.Rest != nil || plainPruneProgrammer_filter(elem) == false {
@@ -585,7 +583,7 @@ type plainPruneProgrammer_exploreArraysProps struct {
 }
 
 func plainPruneProgrammer_explore_arrays(props plainPruneProgrammer_exploreArraysProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(plainPruneProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   return f.NewCallExpression(
     nativehelpers.UnionExplorer.Array(nativehelpers.UnionExplorer_ArrayProps{
       Config: nativehelpers.UnionExplorer_ArrayLikeConfig{
@@ -642,7 +640,7 @@ type plainPruneProgrammer_exploreObjectsProps struct {
 }
 
 func plainPruneProgrammer_explore_objects(props plainPruneProgrammer_exploreObjectsProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(plainPruneProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   if len(props.Metadata.Objects) == 1 {
     return plainPruneProgrammer_decode_object(struct {
       Functor *nativehelpers.FunctionProgrammer
@@ -664,7 +662,7 @@ func plainPruneProgrammer_explore_objects(props plainPruneProgrammer_exploreObje
     f.NewIdentifier(props.Functor.UseLocal(fmt.Sprintf("%su%d", plainPruneProgrammer_PREFIX, index))),
     nil,
     nil,
-    f.NewNodeList(nativeinternal.FeatureProgrammer.ArgumentsArray(nativeinternal.FeatureProgrammer_ArgumentsArrayProps{
+    f.NewNodeList(nativeinternal.FeatureProgrammer.ArgumentsArray(nativeinternal.FeatureProgrammer_ArgumentsArrayProps{Emit: props.Context.Emit,
       Config:  nativeinternal.FeatureProgrammer_ArgumentsArrayConfig{Path: props.Config.Path, Trace: props.Config.Trace, Visited: props.Functor.Visited()},
       Input:   props.Input,
       Explore: props.Explore,
@@ -677,14 +675,14 @@ func plainPruneProgrammer_configure(props struct {
   Context nativecontext.ITypiaContext
   Functor *nativehelpers.FunctionProgrammer
 }) nativeinternal.FeatureProgrammer_IConfig {
-  f := nativecontext.EmitFactoryOf(plainPruneProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   config := nativeinternal.FeatureProgrammer_IConfig{}
   config.Types = nativeinternal.FeatureProgrammer_IConfig_ITypes{
     Input: func(t *shimchecker.Type, name *string) *shimast.TypeNode {
       return f.NewTypeReferenceNode(f.NewIdentifier(plainCloneProgrammer_type_name(props.Context, t, name)), nil)
     },
     Output: func(_ *shimchecker.Type, _ *string) *shimast.TypeNode {
-      return nativefactories.TypeFactory.Keyword("void")
+      return nativefactories.TypeFactory.Keyword("void", props.Context.Emit)
     },
   }
   config.Prefix = plainPruneProgrammer_PREFIX
@@ -739,7 +737,7 @@ func plainPruneProgrammer_configure(props struct {
       })
     },
     Unionizer: func(next nativeinternal.FeatureProgrammer_ObjectorUnionizerProps) *shimast.Node {
-      return nativeiterate.Decode_union_object(nativeiterate.Decode_union_objectProps{
+      return 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,

package/native/core/programmers/plain/PlainValidateClassifyProgrammer.go

@@ -41,10 +41,8 @@ type PlainValidateClassifyProgrammer_DecomposeProps struct {
   Name *string
 }
 
-var plainValidateClassifyProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (plainValidateClassifyProgrammerNamespace) Decompose(props PlainValidateClassifyProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
-  f := nativecontext.EmitFactoryOf(plainValidateClassifyProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   // Validate the INPUT against the redirected type (from/new seed or field-copy
   // instance shape for a class-TYPE target; the type itself otherwise) — never
   // typeof C's static members.
@@ -138,7 +136,7 @@ func (plainValidateClassifyProgrammerNamespace) Write(props nativecontext.IProgr
     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/plain/PlainValidateCloneProgrammer.go

@@ -41,10 +41,8 @@ type PlainValidateCloneProgrammer_DecomposeProps struct {
   Name *string
 }
 
-var plainValidateCloneProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (plainValidateCloneProgrammerNamespace) Decompose(props PlainValidateCloneProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
-  f := nativecontext.EmitFactoryOf(plainValidateCloneProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   validate := nativeprogrammers.ValidateProgrammer.Decompose(nativeprogrammers.ValidateProgrammer_DecomposeProps{
     Context: props.Context,
     Modulo:  props.Modulo,
@@ -134,7 +132,7 @@ func (plainValidateCloneProgrammerNamespace) Write(props nativecontext.IProgramm
     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/plain/PlainValidatePruneProgrammer.go

@@ -41,10 +41,8 @@ type PlainValidatePruneProgrammer_DecomposeProps struct {
   Name *string
 }
 
-var plainValidatePruneProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (plainValidatePruneProgrammerNamespace) Decompose(props PlainValidatePruneProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
-  f := nativecontext.EmitFactoryOf(plainValidatePruneProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   validate := nativeprogrammers.ValidateProgrammer.Decompose(nativeprogrammers.ValidateProgrammer_DecomposeProps{
     Context: props.Context,
     Modulo:  props.Modulo,
@@ -125,7 +123,7 @@ func (plainValidatePruneProgrammerNamespace) Write(props nativecontext.IProgramm
     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/ProtobufAssertDecodeProgrammer.go

@@ -50,10 +50,8 @@ type ProtobufAssertDecodeProgrammer_DecomposeProps struct {
   Init    *shimast.Node
 }
 
-var protobufAssertDecodeProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (protobufAssertDecodeProgrammerNamespace) Decompose(props ProtobufAssertDecodeProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
-  f := nativecontext.EmitFactoryOf(protobufAssertDecodeProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   assertContext := props.Context
   functional := false
   numeric := false
@@ -129,7 +127,7 @@ func (protobufAssertDecodeProgrammerNamespace) Write(props ProtobufAssertDecodeP
     Name:    props.Name,
     Init:    props.Init,
   })
-  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/ProtobufAssertEncodeProgrammer.go

@@ -50,10 +50,8 @@ type ProtobufAssertEncodeProgrammer_DecomposeProps struct {
   Init    *shimast.Node
 }
 
-var protobufAssertEncodeProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (protobufAssertEncodeProgrammerNamespace) Decompose(props ProtobufAssertEncodeProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
-  f := nativecontext.EmitFactoryOf(protobufAssertEncodeProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   assertContext := props.Context
   functional := false
   finite := true
@@ -133,7 +131,7 @@ func (protobufAssertEncodeProgrammerNamespace) Write(props ProtobufAssertEncodeP
     Name:    props.Name,
     Init:    props.Init,
   })
-  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/ProtobufDecodeProgrammer.go

@@ -93,11 +93,8 @@ type protobufDecodeProgrammer_decodeMapProps struct {
 
 const protobufDecodeProgrammer_PREFIX = "_pd"
 
-var protobufDecodeProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-var protobufDecodeProgrammer_objectSequence = 0
-
 func (protobufDecodeProgrammerNamespace) Decompose(props ProtobufDecodeProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
-  f := nativecontext.EmitFactoryOf(protobufDecodeProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   collection := schemametadata.NewMetadataCollection()
   meta := nativefactories.ProtobufFactory.Metadata(nativefactories.ProtobufFactory_IProps{
     Method:     protobufDecodeProgrammer_method_text(props.Modulo),
@@ -179,7 +176,7 @@ func (protobufDecodeProgrammerNamespace) Write(props ProtobufDecodeProgrammer_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,
@@ -191,7 +188,7 @@ func protobufDecodeProgrammer_write_object_function(props struct {
   Functor *nativehelpers.FunctionProgrammer
   Object  *schemametadata.MetadataObjectType
 }) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufDecodeProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   body := protobufDecodeProgrammer_write_object_function_body(protobufDecodeProgrammer_objectBodyProps{
     Context:   props.Context,
     Condition: protobufDecodeProgrammer_lessThan(protobufDecodeProgrammer_callReader("index", nil, props.Context.Emit), protobufDecodeProgrammer_callReader("size", nil, props.Context.Emit), props.Context.Emit),
@@ -220,7 +217,7 @@ func protobufDecodeProgrammer_write_object_function(props struct {
 }
 
 func protobufDecodeProgrammer_write_object_function_body(props protobufDecodeProgrammer_objectBodyProps) []*shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufDecodeProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   if protobufDecodeProgrammer_objectNeedsProtobuf(props.Object) {
     nativefactories.ProtobufFactory.EmplaceObject(props.Object)
   }
@@ -290,7 +287,7 @@ func protobufDecodeProgrammer_write_object_function_body(props protobufDecodePro
 }
 
 func protobufDecodeProgrammer_write_property_default_value(value *schemametadata.MetadataSchema, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufDecodeProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   var expression *shimast.Node
   if value.Nullable {
     expression = f.NewKeywordExpression(shimast.KindNullKeyword)
@@ -341,7 +338,7 @@ func protobufDecodeProgrammer_decode_property(props protobufDecodeProgrammer_dec
 }
 
 func protobufDecodeProgrammer_decode_property_type(props protobufDecodeProgrammer_decodePropertyTypeProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufDecodeProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   outExpr := func(title string, value *shimast.Node) *shimast.Node {
     return protobufDecodeProgrammer_caseClause(protobufDecodeProgrammer_indexValue(protobufDecodeProgrammer_propertyIndex(props.Schema)), title, []*shimast.Node{
       f.NewExpressionStatement(protobufDecodeProgrammer_assignment(props.Accessor, shimast.KindEqualsToken, value, props.Context.Emit)),
@@ -432,7 +429,7 @@ func protobufDecodeProgrammer_decode_property_type(props protobufDecodeProgramme
 }
 
 func protobufDecodeProgrammer_decode_number(schema schemaprotobuf.IProtobufSchema, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufDecodeProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   name := protobufDecodeProgrammer_numberName(schema)
   value := protobufDecodeProgrammer_callReader(name, nil, emit)
   if name == "int64" || name == "uint64" {
@@ -448,7 +445,7 @@ func protobufDecodeProgrammer_decode_number(schema schemaprotobuf.IProtobufSchem
 }
 
 func protobufDecodeProgrammer_decode_array(props protobufDecodeProgrammer_decodeArrayProps, emit *shimprinter.EmitContext) []*shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufDecodeProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   statements := []*shimast.Node{}
   if props.Required == false {
     statements = append(statements, f.NewExpressionStatement(
@@ -495,7 +492,7 @@ func protobufDecodeProgrammer_decode_regular_object(props struct {
   Top    bool
   Object *schemametadata.MetadataObjectType
 }, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufDecodeProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   index := 0
   if props.Object != nil {
     index = props.Object.Index
@@ -514,7 +511,7 @@ func protobufDecodeProgrammer_decode_regular_object(props struct {
 }
 
 func protobufDecodeProgrammer_decode_map(props protobufDecodeProgrammer_decodeMapProps) []*shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufDecodeProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   statements := []*shimast.Node{}
   if props.Required {
     statements = append(statements, f.NewExpressionStatement(
@@ -576,7 +573,7 @@ func protobufDecodeProgrammer_decode_array_value(schema schemaprotobuf.IProtobuf
 }
 
 func protobufDecodeProgrammer_callReader(method string, args []*shimast.Node, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufDecodeProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   return f.NewCallExpression(
     nativefactories.IdentifierFactory.Access(emit, f.NewIdentifier("reader"), method),
     nil,
@@ -587,7 +584,7 @@ func protobufDecodeProgrammer_callReader(method string, args []*shimast.Node, em
 }
 
 func protobufDecodeProgrammer_caseClause(index int, title string, statements []*shimast.Node, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufDecodeProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   body := []*shimast.Node{
     f.NewExpressionStatement(f.NewIdentifier("// " + title)),
   }
@@ -600,6 +597,10 @@ func protobufDecodeProgrammer_caseClause(index int, title string, statements []*
   )
 }
 
+// protobufDecodeProgrammer_createObjectType supplies the temporary key/value
+// properties of a wire map entry. Only its properties reach the body writer and
+// ProtobufFactory.EmplaceObject; it never enters a metadata collection or a
+// name-indexed cache, so it needs no synthetic type identity or shared counter.
 func protobufDecodeProgrammer_createObjectType(definitions []struct {
   Key   string
   Value *schemametadata.MetadataSchema
@@ -612,9 +613,7 @@ func protobufDecodeProgrammer_createObjectType(definitions []struct {
       JsDocTags: []schemametadata.IJsDocTagInfo{},
     }))
   }
-  protobufDecodeProgrammer_objectSequence++
   obj := schemametadata.MetadataObjectType_create(schemametadata.MetadataObjectType{
-    Name:       fmt.Sprintf("object.o%d", protobufDecodeProgrammer_objectSequence),
     Properties: properties,
     JsDocTags:  []schemametadata.IJsDocTagInfo{},
     Index:      -1,
@@ -690,7 +689,7 @@ func protobufDecodeProgrammer_objectNeedsProtobuf(object *schemametadata.Metadat
 }
 
 func protobufDecodeProgrammer_arrayPush(accessor *shimast.Node, value *shimast.Node, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufDecodeProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   return f.NewCallExpression(
     nativefactories.IdentifierFactory.Access(emit, accessor, "push"),
     nil,
@@ -701,27 +700,27 @@ func protobufDecodeProgrammer_arrayPush(accessor *shimast.Node, value *shimast.N
 }
 
 func protobufDecodeProgrammer_assignment(left *shimast.Node, operator shimast.Kind, right *shimast.Node, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufDecodeProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   return f.NewBinaryExpression(nil, left, nil, f.NewToken(operator), right)
 }
 
 func protobufDecodeProgrammer_lessThan(left *shimast.Node, right *shimast.Node, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufDecodeProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   return f.NewBinaryExpression(nil, left, nil, f.NewToken(shimast.KindLessThanToken), right)
 }
 
 func protobufDecodeProgrammer_unsigned_right_shift(left *shimast.Node, right *shimast.Node, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufDecodeProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   return f.NewBinaryExpression(nil, left, nil, f.NewToken(shimast.KindGreaterThanGreaterThanGreaterThanToken), right)
 }
 
 func protobufDecodeProgrammer_bitwise_and(left *shimast.Node, right *shimast.Node, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufDecodeProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   return f.NewBinaryExpression(nil, left, nil, f.NewToken(shimast.KindAmpersandToken), right)
 }
 
 func protobufDecodeProgrammer_strict_equal(left *shimast.Node, right *shimast.Node, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufDecodeProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   return f.NewBinaryExpression(nil, left, nil, f.NewToken(shimast.KindEqualsEqualsEqualsToken), right)
 }
 
@@ -868,7 +867,7 @@ func protobufDecodeProgrammer_import_type(context nativecontext.ITypiaContext, p
   if importer := context.Importer; importer != nil {
     return importer.Type(props)
   }
-  f := nativecontext.EmitFactoryOf(protobufDecodeProgrammer_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))
   }
@@ -879,7 +878,7 @@ func protobufDecodeProgrammer_internal(context nativecontext.ITypiaContext, name
   if importer := context.Importer; importer != nil {
     return importer.Internal(name)
   }
-  f := nativecontext.EmitFactoryOf(protobufDecodeProgrammer_factory, context.Emit)
+  f := nativecontext.NodeFactoryOf(context.Emit)
   return f.NewIdentifier(name)
 }