typia 15.1.0 → 15.2.0

package/native/core/programmers/http/HttpQueryProgrammer.go

@@ -57,10 +57,8 @@ type HttpQueryProgrammer_DecomposeProps struct {
   Missing bool
 }
 
-var httpQueryProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (httpQueryProgrammerNamespace) Decompose(props HttpQueryProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
-  f := nativecontext.EmitFactoryOf(httpQueryProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   collection := schemametadata.NewMetadataCollection()
   result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{
     Checker: props.Context.Checker,
@@ -153,7 +151,7 @@ func (httpQueryProgrammerNamespace) Write(props HttpQueryProgrammer_IProps) *shi
     Name:          props.Name,
     Missing:       true,
   })
-  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,
@@ -233,7 +231,7 @@ func httpQueryProgrammer_decode_object(props struct {
   Object  *schemametadata.MetadataObjectType
   Missing bool
 }) []*shimast.Node {
-  f := nativecontext.EmitFactoryOf(httpQueryProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   input := f.NewIdentifier("input")
   output := f.NewIdentifier("output")
   properties := make([]*shimast.Node, 0, len(props.Object.Properties))
@@ -286,7 +284,7 @@ func httpQueryProgrammer_decode_regular_property(props struct {
   Property *schemametadata.MetadataProperty
   Missing  bool
 }) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(httpQueryProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   key := httpProgrammer_property_key(props.Property)
   value := props.Property.Value
   typ, isArray := httpProgrammer_decode_type(value, false)
@@ -390,7 +388,7 @@ func httpQueryProgrammer_decode_value(props struct {
   Coalesce bool
   Input    *shimast.Node
 }) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(httpQueryProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   call := f.NewCallExpression(
     httpParameterProgrammer_internal(props.Context, "httpQueryRead"+httpParameterProgrammer_capitalize(props.Type)),
     nil,
@@ -411,7 +409,7 @@ func httpQueryProgrammer_decode_value(props struct {
 }
 
 func httpQueryProgrammer_assert_required_value(key string, input *shimast.Node, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(httpQueryProgrammer_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   value := f.NewIdentifier("value")
   return f.NewCallExpression(
     f.NewArrowFunction(
@@ -448,7 +446,7 @@ func httpQueryProgrammer_assert_required_value(key string, input *shimast.Node,
 }
 
 func httpQueryProgrammer_missing_error(key string, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(httpQueryProgrammer_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   return f.NewNewExpression(
     f.NewIdentifier("Error"),
     nil,
@@ -463,7 +461,7 @@ func httpQueryProgrammer_decode_array(props struct {
   Metadata *schemametadata.MetadataSchema
   Input    *shimast.Node
 }) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(httpQueryProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   if props.Metadata.Nullable == false && props.Metadata.IsRequired() == true {
     return props.Input
   }

package/native/core/programmers/http/HttpValidateFormDataProgrammer.go

@@ -30,8 +30,6 @@ type HttpValidateFormDataProgrammer_DecomposeProps struct {
   Name    *string
 }
 
-var httpValidateProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (httpValidateFormDataProgrammerNamespace) Decompose(props HttpValidateFormDataProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
   validate := nativeprogrammers.ValidateProgrammer.Decompose(nativeprogrammers.ValidateProgrammer_DecomposeProps{
     Context: httpProgrammer_context(props.Context, false, false),
@@ -59,7 +57,7 @@ func (httpValidateFormDataProgrammerNamespace) Write(props nativecontext.IProgra
     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,
@@ -67,7 +65,7 @@ func (httpValidateFormDataProgrammerNamespace) Write(props nativecontext.IProgra
 }
 
 func httpProgrammer_validate_result(context nativecontext.ITypiaContext, validate nativeinternal.FeatureProgrammer_IDecomposed, decode nativeinternal.FeatureProgrammer_IDecomposed) nativeinternal.FeatureProgrammer_IDecomposed {
-  f := nativecontext.EmitFactoryOf(httpValidateProgrammer_factory, context.Emit)
+  f := nativecontext.NodeFactoryOf(context.Emit)
   decodeArrow := decode.Arrow.AsArrowFunction()
   output := decodeArrow.Type
   if output == nil {

package/native/core/programmers/http/HttpValidateHeadersProgrammer.go

@@ -56,7 +56,7 @@ func (httpValidateHeadersProgrammerNamespace) Write(props nativecontext.IProgram
     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/http/HttpValidateQueryProgrammer.go

@@ -77,7 +77,7 @@ func (httpValidateQueryProgrammerNamespace) Write(props HttpValidateQueryProgram
     Name:          props.Name,
     AllowOptional: props.AllowOptional,
   })
-  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/internal/CheckerProgrammer.go

@@ -280,8 +280,6 @@ type CheckerProgrammer_DecodeObjectProps struct {
   Emit    *shimprinter.EmitContext
 }
 
-var checkerProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (checkerProgrammerNamespace) Compose(props CheckerProgrammer_ComposeProps) FeatureProgrammer_IComposed {
   return FeatureProgrammer.Compose(FeatureProgrammer_ComposeProps{
     Context: props.Context,
@@ -322,7 +320,7 @@ func (checkerProgrammerNamespace) Write_union_functions(props CheckerProgrammer_
 }
 
 func (checkerProgrammerNamespace) Write_array_functions(props CheckerProgrammer_WriteArrayFunctionsProps) []*shimast.Node {
-  f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   arrays := props.Collection.Arrays()
   output := []*shimast.Node{}
   for _, typ := range arrays {
@@ -371,7 +369,7 @@ func (checkerProgrammerNamespace) Write_array_functions(props CheckerProgrammer_
 }
 
 func (checkerProgrammerNamespace) Write_tuple_functions(props CheckerProgrammer_WriteTupleFunctionsProps) []*shimast.Node {
-  f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   tuples := props.Collection.Tuples()
   output := []*shimast.Node{}
   for _, tuple := range tuples {
@@ -417,7 +415,7 @@ func (checkerProgrammerNamespace) Write_tuple_functions(props CheckerProgrammer_
 }
 
 func checkerProgrammer_configure(context nativecontext.ITypiaContext, config CheckerProgrammer_IConfig, functor *nativehelpers.FunctionProgrammer) FeatureProgrammer_IConfig {
-  f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, context.Emit)
+  f := nativecontext.NodeFactoryOf(context.Emit)
   return FeatureProgrammer_IConfig{
     Types: FeatureProgrammer_IConfig_ITypes{
       Input: func(_ *shimchecker.Type, _ *string) *shimast.TypeNode {
@@ -544,7 +542,7 @@ func checkerProgrammer_configure(context nativecontext.ITypiaContext, config Che
       },
       Unionizer: func(next FeatureProgrammer_ObjectorUnionizerProps) *shimast.Node {
         if config.Equals {
-          return nativeiterate.Decode_union_object(nativeiterate.Decode_union_objectProps{
+          return nativeiterate.Decode_union_object(nativeiterate.Decode_union_objectProps{Emit: context.Emit,
             Checker: func(v nativeiterate.Decode_union_object_next) *shimast.Node {
               return CheckerProgrammer.Decode_object(CheckerProgrammer_DecodeObjectProps{
                 Config:  config,
@@ -670,7 +668,7 @@ func checkerProgrammer_configure(context nativecontext.ITypiaContext, config Che
 }
 
 func (checkerProgrammerNamespace) Decode(props CheckerProgrammer_DecodeProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   if props.Metadata.Any {
     return props.Config.Success
   }
@@ -894,7 +892,7 @@ func (checkerProgrammerNamespace) Decode(props CheckerProgrammer_DecodeProps) *s
     binaries = append(binaries, CheckerProgrammer_IBinary{
       Expression: props.Config.Atomist(CheckerProgrammer_AtomistProps{
         Explore: props.Explore,
-        Entry: nativeiterate.Check_template(nativeiterate.Check_templateProps{
+        Entry: nativeiterate.Check_template(nativeiterate.Check_templateProps{Emit: props.Context.Emit,
           Context:   props.Context,
           Templates: props.Metadata.Templates,
           Input:     props.Input,
@@ -907,7 +905,7 @@ func (checkerProgrammerNamespace) Decode(props CheckerProgrammer_DecodeProps) *s
 
   for _, native := range props.Metadata.Natives {
     binaries = append(binaries, CheckerProgrammer_IBinary{
-      Expression: nativeiterate.Check_native(nativeiterate.Check_nativeProps{Name: native.Name, Input: props.Input}),
+      Expression: nativeiterate.Check_native(nativeiterate.Check_nativeProps{Emit: props.Context.Emit, Name: native.Name, Input: props.Input}),
       Combined:   false,
     })
   }
@@ -932,7 +930,7 @@ func (checkerProgrammerNamespace) Decode(props CheckerProgrammer_DecodeProps) *s
       body = checkerProgrammer_explore_sets(checkerProgrammer_exploreSetsProps{Context: props.Context, Config: props.Config, Functor: props.Functor, Sets: props.Metadata.Sets, Input: props.Input, Explore: explore})
     }
     prepare(checkerProgrammer_IInstance{
-      Head:     nativeiterate.Check_native(nativeiterate.Check_nativeProps{Name: "Set", Input: props.Input}),
+      Head:     nativeiterate.Check_native(nativeiterate.Check_nativeProps{Emit: props.Context.Emit, Name: "Set", Input: props.Input}),
       Expected: strings.Join(names, " | "),
       Body:     body,
     })
@@ -953,7 +951,7 @@ func (checkerProgrammerNamespace) Decode(props CheckerProgrammer_DecodeProps) *s
       body = checkerProgrammer_explore_maps(checkerProgrammer_exploreMapsProps{Context: props.Context, Config: props.Config, Functor: props.Functor, Maps: props.Metadata.Maps, Input: props.Input, Explore: explore})
     }
     prepare(checkerProgrammer_IInstance{
-      Head:     nativeiterate.Check_native(nativeiterate.Check_nativeProps{Name: "Map", Input: props.Input}),
+      Head:     nativeiterate.Check_native(nativeiterate.Check_nativeProps{Emit: props.Context.Emit, Name: "Map", Input: props.Input}),
       Expected: strings.Join(names, " | "),
       Body:     body,
     })
@@ -1103,7 +1101,7 @@ func (checkerProgrammerNamespace) Decode(props CheckerProgrammer_DecodeProps) *s
   if props.Metadata.Escaped != nil {
     var expression *shimast.Node
     if props.Metadata.Escaped.Original.Size() == 1 && len(props.Metadata.Escaped.Original.Natives) == 1 {
-      expression = nativeiterate.Check_native(nativeiterate.Check_nativeProps{Name: props.Metadata.Escaped.Original.Natives[0].Name, Input: props.Input})
+      expression = nativeiterate.Check_native(nativeiterate.Check_nativeProps{Emit: props.Context.Emit, Name: props.Metadata.Escaped.Original.Natives[0].Name, Input: props.Input})
     } else {
       expression = checkerProgrammer_and(
         CheckerProgrammer.Decode(CheckerProgrammer_DecodeProps{Context: props.Context, Config: props.Config, Functor: props.Functor, Metadata: props.Metadata.Escaped.Original, Input: props.Input, Explore: props.Explore}),
@@ -1234,7 +1232,7 @@ func checkerProgrammer_decode_array(props checkerProgrammer_decodeArrayProps) *s
   if props.Array.Type.Recursive == false {
     return checkerProgrammer_decode_array_inline(props)
   }
-  f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   arrayExplore := props.Explore
   arrayExplore.Source = "function"
   arrayExplore.From = "array"
@@ -1344,7 +1342,7 @@ func checkerProgrammer_decode_tuple(props checkerProgrammer_decodeTupleProps) *s
       Explore: props.Explore,
     })
   }
-  f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   arrayExplore := props.Explore
   arrayExplore.Source = "function"
   arrayExplore.From = "array"
@@ -1375,7 +1373,7 @@ func checkerProgrammer_decode_tuple(props checkerProgrammer_decodeTupleProps) *s
 }
 
 func checkerProgrammer_decode_tuple_inline(props checkerProgrammer_decodeTupleInlineProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   binaries := []*shimast.Node{}
   for index, metadata := range props.Tuple.Elements {
     if metadata.Rest != nil {
@@ -1485,7 +1483,7 @@ type checkerProgrammer_decodeEscapedProps struct {
 }
 
 func checkerProgrammer_decode_escaped(props checkerProgrammer_decodeEscapedProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   return f.NewCallExpression(
     f.NewParenthesizedExpression(
       f.NewArrowFunction(
@@ -1532,7 +1530,7 @@ type checkerProgrammer_exploreSetsProps struct {
 }
 
 func checkerProgrammer_explore_sets(props checkerProgrammer_exploreSetsProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   return f.NewCallExpression(
     nativehelpers.UnionExplorer.Set(nativehelpers.UnionExplorer_SetProps{
       Config: nativehelpers.UnionExplorer_ArrayLikeConfig{
@@ -1581,7 +1579,7 @@ type checkerProgrammer_exploreMapsProps struct {
 }
 
 func checkerProgrammer_explore_maps(props checkerProgrammer_exploreMapsProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   return f.NewCallExpression(
     nativehelpers.UnionExplorer.Map(nativehelpers.UnionExplorer_MapProps{
       Config: nativehelpers.UnionExplorer_ArrayLikeConfig{
@@ -1787,7 +1785,7 @@ type checkerProgrammer_exploreArrayLikeUnionTypesProps struct {
 }
 
 func checkerProgrammer_explore_array_like_union_types(props checkerProgrammer_exploreArrayLikeUnionTypesProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   arrayExplore := props.Explore
   arrayExplore.Source = "function"
   arrayExplore.From = "array"
@@ -1808,7 +1806,7 @@ func checkerProgrammer_explore_array_like_union_types(props checkerProgrammer_ex
             return props.Factory(checkerProgrammer_exploreArrayLikeUnionTypesFactoryProps{
               Parameters: FeatureProgrammer.ParameterDeclarations(FeatureProgrammer_ParameterDeclarationsProps{
                 Config: FeatureProgrammer_ParameterConfig{Path: props.Config.Path, Trace: props.Config.Trace, Visited: props.Functor.Visited()},
-                Type:   nativefactories.TypeFactory.Keyword("any"),
+                Type:   nativefactories.TypeFactory.Keyword("any", props.Emit),
                 Input:  f.NewIdentifier("input"),
                 Emit:   props.Emit,
               }),
@@ -1864,7 +1862,7 @@ func checkerProgrammer_explore_objects(props checkerProgrammer_exploreObjectsPro
       names = append(names, object.GetDisplayName())
     }
     expected := "(" + strings.Join(names, " | ") + ")"
-    f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, props.Context.Emit)
+    f := nativecontext.NodeFactoryOf(props.Context.Emit)
     statements := make([]*shimast.Node, 0, len(props.Metadata.Objects)+1)
     for _, object := range props.Metadata.Objects {
       statements = append(statements, f.NewIfStatement(
@@ -1901,7 +1899,7 @@ func checkerProgrammer_explore_objects(props checkerProgrammer_exploreObjectsPro
       shimast.NodeFlagsNone,
     )
   }
-  f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   index := 0
   if props.Metadata.Union_index != nil {
     index = *props.Metadata.Union_index
@@ -1986,7 +1984,7 @@ func checkerProgrammer_decode_object_reference(props checkerProgrammer_decodeObj
 }
 
 func checkerProgrammer_entry_condition(entry nativehelpers.ICheckEntry, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   expressions := []*shimast.Node{}
   if entry.Expression != nil {
     expressions = append(expressions, entry.Expression)
@@ -2042,7 +2040,7 @@ func checkerProgrammer_definitions_have_array_type_tags(definitions []any) bool
 }
 
 func checkerProgrammer_array_tag_candidate(context nativecontext.ITypiaContext) func(nativehelpers.UnionExplorer_ArrayLikeCandidateProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, context.Emit)
+  f := nativecontext.NodeFactoryOf(context.Emit)
   return func(props nativehelpers.UnionExplorer_ArrayLikeCandidateProps) *shimast.Node {
     array, ok := props.Definition.(*nativemetadata.MetadataArray)
     if ok == false {
@@ -2057,7 +2055,7 @@ func checkerProgrammer_array_tag_candidate(context nativecontext.ITypiaContext)
 }
 
 func checkerProgrammer_array_like_config(context nativecontext.ITypiaContext, config CheckerProgrammer_IConfig, functor *nativehelpers.FunctionProgrammer, checker func(v nativehelpers.UnionExplorer_ArrayLikeCheckerProps) *shimast.Node, decoder func(v nativehelpers.UnionExplorer_ArrayLikeDecoderProps) *shimast.Node) nativehelpers.UnionExplorer_ArrayLikeConfig {
-  f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, context.Emit)
+  f := nativecontext.NodeFactoryOf(context.Emit)
   return nativehelpers.UnionExplorer_ArrayLikeConfig{
     Checker: checker,
     Decoder: decoder,
@@ -2095,7 +2093,7 @@ func checkerProgrammer_create_add(binaries *[]CheckerProgrammer_IBinary, input *
 }
 
 func checkerProgrammer_binary(left *shimast.Expression, operator shimast.Kind, right *shimast.Expression, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   return f.NewBinaryExpression(
     nil,
     left,
@@ -2128,7 +2126,7 @@ func checkerProgrammer_and(x *shimast.Expression, y *shimast.Expression, emit *s
 // value cannot poison sibling checks; each recursive function owns its own
 // `_vctx` slot for the same reason.
 func checkerProgrammer_visit_guard(key string, body *shimast.Node, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   slot := "_vctx." + key
   return nativefactories.ExpressionFactory.Conditional(
     f.NewIdentifier("("+slot+" || ("+slot+" = new WeakSet())).has(input)"),
@@ -2234,7 +2232,7 @@ func checkerProgrammer_decode_to_json(props struct {
   CheckNull bool
   Emit      *shimprinter.EmitContext
 }) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   return checkerProgrammer_and(
     nativefactories.ExpressionFactory.IsObject(nativefactories.ExpressionFactory_IsObjectProps{
       CheckArray: false,

package/native/core/programmers/internal/FeatureProgrammer.go

@@ -555,7 +555,7 @@ func (featureProgrammerNamespace) CollectionRecursive(collection *nativemetadata
 // the skip both the cycle breaker and the DAG deduplication. Handles the
 // block bodies the prune joiner produces as well as expression bodies.
 func (featureProgrammerNamespace) VisitGuardSkip(key string, body *shimast.Node, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   slot := "_vctx." + key
   has := f.NewIdentifier("(" + slot + " || (" + slot + " = new WeakSet())).has(input)")
   add := f.NewIdentifier(slot + ".add(input)")
@@ -591,14 +591,14 @@ func (featureProgrammerNamespace) VisitGuardSkip(key string, body *shimast.Node,
 // way, because re-serializing a DAG alias at another position is legal and
 // must keep working.
 func (featureProgrammerNamespace) VisitGuardSerialize(key string, thrower *shimast.Node, body *shimast.Node, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   slot := "_vctx." + key
   bodyExpression := featureProgrammer_block_to_expression(body, emit)
   finisher := f.NewArrowFunction(
     nil,
     nil,
     f.NewNodeList([]*shimast.Node{
-      nativefactories.IdentifierFactory.Parameter("_vout", nativefactories.TypeFactory.Keyword("any"), nil),
+      nativefactories.IdentifierFactory.Parameter("_vout", nativefactories.TypeFactory.Keyword("any", emit), nil, emit),
     }),
     nil,
     nil,
@@ -642,7 +642,7 @@ func (featureProgrammerNamespace) VisitGuardSerialize(key string, thrower *shima
 // so recursive references inside the body resolve to the same (still
 // filling) instance, exactly like the structured-clone algorithm.
 func (featureProgrammerNamespace) VisitGuardRebuild(key string, array bool, body *shimast.Node, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   allocator := f.NewObjectLiteralExpression(f.NewNodeList(nil), false)
   if array {
     allocator = f.NewArrayLiteralExpression(f.NewNodeList(nil), false)
@@ -659,14 +659,14 @@ func (featureProgrammerNamespace) VisitGuardRebuild(key string, array bool, body
 // registers in the WeakMap BEFORE the body evaluates, so a back-reference
 // inside the body resolves to this same (still filling) instance.
 func (featureProgrammerNamespace) VisitGuardRebuildWith(key string, allocator *shimast.Node, body *shimast.Node, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   slot := "_vctx." + key
   bodyExpression := featureProgrammer_block_to_expression(body, emit)
   filler := f.NewArrowFunction(
     nil,
     nil,
     f.NewNodeList([]*shimast.Node{
-      nativefactories.IdentifierFactory.Parameter("_vout", nativefactories.TypeFactory.Keyword("any"), nil),
+      nativefactories.IdentifierFactory.Parameter("_vout", nativefactories.TypeFactory.Keyword("any", emit), nil, emit),
     }),
     nil,
     nil,
@@ -711,8 +711,6 @@ func featureProgrammer_block_to_expression(body *shimast.Node, emit *shimprinter
   return body
 }
 
-var featureProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (featureProgrammerNamespace) Compose(props FeatureProgrammer_ComposeProps) FeatureProgrammer_IComposed {
   initialized := props.Config.Initializer(FeatureProgrammer_InitializerProps{
     Context: props.Context,
@@ -763,7 +761,7 @@ func (featureProgrammerNamespace) Compose(props FeatureProgrammer_ComposeProps)
 }
 
 func (featureProgrammerNamespace) WriteDecomposed(props FeatureProgrammer_WriteDecomposedProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   statements := []*shimast.Node{}
   statements = append(statements, props.Functor.Declare()...)
   keys := make([]string, 0, len(props.Result.Functions))
@@ -801,7 +799,7 @@ func (featureProgrammerNamespace) WriteDecomposed(props FeatureProgrammer_WriteD
 }
 
 func (featureProgrammerNamespace) Write(props FeatureProgrammer_WriteProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   initialized := props.Config.Initializer(FeatureProgrammer_InitializerProps{
     Context: props.Context,
     Functor: props.Functor,
@@ -882,14 +880,14 @@ func (featureProgrammerNamespace) Write_union_functions(props FeatureProgrammer_
 }
 
 func (featureProgrammerNamespace) Decode_array(props FeatureProgrammer_DecodeArrayProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   rand := fmt.Sprint(props.Functor.Increment())
   tail := []*shimast.Node{}
   if props.Config.Path || props.Config.Trace {
-    tail = append(tail, nativefactories.IdentifierFactory.Parameter("_index"+rand, nativefactories.TypeFactory.Keyword("number"), nil))
+    tail = append(tail, nativefactories.IdentifierFactory.Parameter("_index"+rand, nativefactories.TypeFactory.Keyword("number", props.Emit), nil, props.Emit))
   }
   parameters := []*shimast.Node{
-    nativefactories.IdentifierFactory.Parameter("elem", nativefactories.TypeFactory.Keyword("any"), nil),
+    nativefactories.IdentifierFactory.Parameter("elem", nativefactories.TypeFactory.Keyword("any", props.Emit), nil, props.Emit),
   }
   parameters = append(parameters, tail...)
   arrow := f.NewArrowFunction(
@@ -900,7 +898,7 @@ func (featureProgrammerNamespace) Decode_array(props FeatureProgrammer_DecodeArr
     nil,
     f.NewToken(shimast.KindEqualsGreaterThanToken),
     props.Config.Decoder(FeatureProgrammer_DecoderProps{
-      Input:    nativefactories.ValueFactory.INPUT(nil, "elem"),
+      Input:    nativefactories.ValueFactory.INPUT(props.Emit, "elem"),
       Metadata: props.Array.Type.Value,
       Explore: FeatureProgrammer_IExplore{
         Tracable: props.Explore.Tracable,
@@ -921,7 +919,7 @@ func (featureProgrammerNamespace) Decode_array(props FeatureProgrammer_DecodeArr
 }
 
 func (featureProgrammerNamespace) Decode_object(props FeatureProgrammer_DecodeObjectProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   return f.NewCallExpression(
     f.NewIdentifier(
       props.Functor.UseLocal(fmt.Sprintf("%so%d", props.Config.Prefix, props.Object.Index)),
@@ -953,7 +951,7 @@ func (featureProgrammerNamespace) Index(props FeatureProgrammer_IndexProps) stri
 }
 
 func (featureProgrammerNamespace) ArgumentsArray(props FeatureProgrammer_ArgumentsArrayProps) []*shimast.Node {
-  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   tail := []*shimast.Node{}
   if props.Config.Path == false && props.Config.Trace == false {
     tail = []*shimast.Node{}
@@ -992,16 +990,16 @@ func (featureProgrammerNamespace) ArgumentsArray(props FeatureProgrammer_Argumen
 }
 
 func (featureProgrammerNamespace) ParameterDeclarations(props FeatureProgrammer_ParameterDeclarationsProps) []*shimast.Node {
-  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   tail := []*shimast.Node{}
   if props.Config.Path {
-    tail = append(tail, nativefactories.IdentifierFactory.Parameter("_path", nativefactories.TypeFactory.Keyword("string"), nil))
+    tail = append(tail, nativefactories.IdentifierFactory.Parameter("_path", nativefactories.TypeFactory.Keyword("string", props.Emit), nil, props.Emit))
   }
   if props.Config.Trace {
     tail = append(tail, nativefactories.IdentifierFactory.Parameter(
       "_exceptionable",
-      nativefactories.TypeFactory.Keyword("boolean"),
-      f.NewKeywordExpression(shimast.KindTrueKeyword),
+      nativefactories.TypeFactory.Keyword("boolean", props.Emit),
+      f.NewKeywordExpression(shimast.KindTrueKeyword), props.Emit,
     ))
   }
   if props.Config.Visited {
@@ -1009,12 +1007,12 @@ func (featureProgrammerNamespace) ParameterDeclarations(props FeatureProgrammer_
     // so the default object literal only materializes at the public entry.
     tail = append(tail, nativefactories.IdentifierFactory.Parameter(
       "_vctx",
-      nativefactories.TypeFactory.Keyword("any"),
-      f.NewObjectLiteralExpression(f.NewNodeList(nil), false),
+      nativefactories.TypeFactory.Keyword("any", props.Emit),
+      f.NewObjectLiteralExpression(f.NewNodeList(nil), false), props.Emit,
     ))
   }
   return append([]*shimast.Node{
-    nativefactories.IdentifierFactory.Parameter(props.Input, props.Type, nil),
+    nativefactories.IdentifierFactory.Parameter(props.Input, props.Type, nil, props.Emit),
   }, tail...)
 }
 
@@ -1254,7 +1252,7 @@ func featureProgrammer_register_schema_unions_iterate(collection *nativemetadata
 }
 
 func featureProgrammer_write_object_functions(config FeatureProgrammer_IConfig, context nativecontext.ITypiaContext, functor *nativehelpers.FunctionProgrammer, collection *nativemetadata.MetadataCollection) []*shimast.Node {
-  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, context.Emit)
+  f := nativecontext.NodeFactoryOf(context.Emit)
   objects := collection.Objects()
   propertyFrequencies := featureProgrammer_object_property_frequencies(config, context, functor, objects)
   output := make([]*shimast.Node, 0, len(objects))
@@ -1343,7 +1341,7 @@ func featureProgrammer_write_object_functions(config FeatureProgrammer_IConfig,
         nil,
         f.NewNodeList(FeatureProgrammer.ParameterDeclarations(FeatureProgrammer_ParameterDeclarationsProps{
           Config: FeatureProgrammer_ParameterConfig{Path: config.Path, Trace: config.Trace, Visited: featureProgrammer_visited(config)},
-          Type:   nativefactories.TypeFactory.Keyword("any"),
+          Type:   nativefactories.TypeFactory.Keyword("any", context.Emit),
           Input:  nativefactories.ValueFactory.INPUT(context.Emit),
           Emit:   context.Emit,
         })),
@@ -1415,7 +1413,7 @@ func featureProgrammer_object_property_helper_key(
 }
 
 func featureProgrammer_object_property_helper_call(props featureProgrammer_objectPropertyHelperProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   helper := props.Functor.EmplaceVariableByKey(props.Config.Prefix+"p", props.Key, func(string) *shimast.Expression {
     input := nativefactories.ValueFactory.INPUT(props.Context.Emit)
     propertyInput := featureProgrammer_object_property_input(input, props.Next.Key, props.Context.Emit)
@@ -1429,7 +1427,7 @@ func featureProgrammer_object_property_helper_call(props featureProgrammer_objec
       nil,
       f.NewNodeList(FeatureProgrammer.ParameterDeclarations(FeatureProgrammer_ParameterDeclarationsProps{
         Config: FeatureProgrammer_ParameterConfig{Path: props.Config.Path, Trace: props.Config.Trace, Visited: featureProgrammer_visited(props.Config)},
-        Type:   nativefactories.TypeFactory.Keyword("any"),
+        Type:   nativefactories.TypeFactory.Keyword("any", props.Context.Emit),
         Input:  input,
         Emit:   props.Context.Emit,
       })),
@@ -1459,7 +1457,7 @@ func featureProgrammer_object_property_helper_call(props featureProgrammer_objec
 }
 
 func featureProgrammer_object_property_input(input *shimast.Expression, key *string, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   if key == nil {
     return f.NewIdentifier("value")
   }
@@ -1481,7 +1479,7 @@ func featureProgrammer_write_union_functions(config FeatureProgrammer_IConfig, c
         Config  FeatureProgrammer_IConfig
         Objects []*nativemetadata.MetadataObjectType
       }{Config: config, Objects: union}, emit),
-    }))
+    }, emit))
   }
   return output
 }
@@ -1490,17 +1488,17 @@ func featureProgrammer_write_union(props struct {
   Config  FeatureProgrammer_IConfig
   Objects []*nativemetadata.MetadataObjectType
 }, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   return f.NewArrowFunction(
     nil,
     nil,
     f.NewNodeList(FeatureProgrammer.ParameterDeclarations(FeatureProgrammer_ParameterDeclarationsProps{
       Config: FeatureProgrammer_ParameterConfig{Path: props.Config.Path, Trace: props.Config.Trace, Visited: featureProgrammer_visited(props.Config)},
-      Type:   nativefactories.TypeFactory.Keyword("any"),
-      Input:  nativefactories.ValueFactory.INPUT(nil),
+      Type:   nativefactories.TypeFactory.Keyword("any", emit),
+      Input:  nativefactories.ValueFactory.INPUT(emit),
       Emit:   emit,
     })),
-    nativefactories.TypeFactory.Keyword("any"),
+    nativefactories.TypeFactory.Keyword("any", emit),
     nil,
     f.NewToken(shimast.KindEqualsGreaterThanToken),
     nativehelpers.UnionExplorer.Object(nativehelpers.UnionExplorer_ObjectProps{
@@ -1508,7 +1506,7 @@ func featureProgrammer_write_union(props struct {
         Objector: featureProgrammer_union_objector(props.Config.Objector),
       },
       Objects: props.Objects,
-      Input:   nativefactories.ValueFactory.INPUT(nil),
+      Input:   nativefactories.ValueFactory.INPUT(emit),
       Explore: FeatureProgrammer_IExplore{
         Tracable: props.Config.Path || props.Config.Trace,
         Source:   "function",

package/native/core/programmers/iterate/check_array_length.go

@@ -75,5 +75,5 @@ func check_array_length_transpile(context nativecontext.ITypiaContext, script st
   return nativefactories.ExpressionFactory.Transpile(nativefactories.ExpressionFactory_TranspileProps{
     Importer: importer,
     Script:   script,
-  })
+  }, context.Emit)
 }

package/native/core/programmers/iterate/check_bigint.go

@@ -29,7 +29,7 @@ type Check_bigintProps struct {
 // @evidence contracts/common.md#prohibited-implementation-shortcuts Its inputs are its arguments and the context they carry, and it keeps no state of its own.
 // @evidence contracts/common.md#meaningful-documentation The doc states what it builds.
 func Check_bigint(props Check_bigintProps) nativehelpers.ICheckEntry {
-  f := nativecontext.EmitFactoryOf(check_bigint_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   conditions := check_bigint_type_tags(props)
   return nativehelpers.ICheckEntry{
     Expected: props.Atomic.GetName(),
@@ -86,7 +86,5 @@ func check_bigint_transpile(context nativecontext.ITypiaContext, script string)
   return nativefactories.ExpressionFactory.Transpile(nativefactories.ExpressionFactory_TranspileProps{
     Importer: importer,
     Script:   script,
-  })
+  }, context.Emit)
 }
-
-var check_bigint_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})