typia 15.1.0 → 15.2.0

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

@@ -34,7 +34,7 @@ type Check_dynamic_keyProps 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_dynamic_key(props Check_dynamic_keyProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(check_dynamic_key_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   if check_dynamic_key_has_pure_string(props.Metadata) {
     return f.NewKeywordExpression(shimast.KindTrueKeyword)
   }
@@ -132,7 +132,7 @@ func Check_dynamic_key(props Check_dynamic_keyProps) *shimast.Node {
   }
 
   if len(props.Metadata.Templates) != 0 {
-    conditions = append(conditions, check_dynamic_key_atomist(Check_template(Check_templateProps{
+    conditions = append(conditions, check_dynamic_key_atomist(Check_template(Check_templateProps{Emit: props.Context.Emit,
       Context:   props.Context,
       Templates: props.Metadata.Templates,
       Input:     props.Input,
@@ -246,7 +246,7 @@ func check_dynamic_key_atomist(entry nativehelpers.ICheckEntry, emit ...*shimpri
 }
 
 func check_dynamic_key_reduce(expressions []*shimast.Node, operator shimast.Kind, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(check_dynamic_key_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   if len(expressions) == 0 {
     return f.NewKeywordExpression(shimast.KindTrueKeyword)
   }
@@ -264,7 +264,7 @@ func check_dynamic_key_reduce(expressions []*shimast.Node, operator shimast.Kind
 }
 
 func check_dynamic_key_strict_equal(left *shimast.Expression, right *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(check_dynamic_key_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   return f.NewBinaryExpression(
     nil,
     left,
@@ -278,8 +278,6 @@ func check_dynamic_key_internal(context nativecontext.ITypiaContext, name string
   if importer := context.Importer; importer != nil {
     return importer.Internal(name)
   }
-  f := nativecontext.EmitFactoryOf(check_dynamic_key_factory, context.Emit)
+  f := nativecontext.NodeFactoryOf(context.Emit)
   return f.NewIdentifier(name)
 }
-
-var check_dynamic_key_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})

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

@@ -38,7 +38,7 @@ type Check_dynamic_propertiesProps 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_dynamic_properties(props Check_dynamic_propertiesProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(check_dynamic_properties_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   length := nativefactories.IdentifierFactory.Access(
     props.Context.Emit,
     f.NewCallExpression(
@@ -135,7 +135,7 @@ func Check_dynamic_properties(props Check_dynamic_propertiesProps) *shimast.Node
 }
 
 func check_dynamic_property(props Check_dynamic_propertiesProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(check_dynamic_properties_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   key := f.NewIdentifier("key")
   value := f.NewIdentifier("value")
 
@@ -258,7 +258,7 @@ func check_dynamic_property(props Check_dynamic_propertiesProps) *shimast.Node {
 }
 
 func is_regular_property(regular []nativehelpers.IExpressionEntry, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(check_dynamic_properties_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   elements := make([]*shimast.Node, 0, len(regular))
   for _, entry := range regular {
     key := entry.Key.GetSoleLiteral()
@@ -267,14 +267,10 @@ func is_regular_property(regular []nativehelpers.IExpressionEntry, emit ...*shim
     }
   }
   return f.NewCallExpression(
-    nativefactories.IdentifierFactory.Access(
-      nil,
-      f.NewArrayLiteralExpression(
-        f.NewNodeList(elements),
-        false,
-      ),
-      "some",
-    ),
+    f.NewPropertyAccessExpression(f.NewArrayLiteralExpression(
+      f.NewNodeList(elements),
+      false,
+    ), nil, f.NewIdentifier("some"), shimast.NodeFlagsNone),
     nil,
     nil,
     f.NewNodeList([]*shimast.Node{
@@ -323,7 +319,7 @@ func check_dynamic_properties_internal(context nativecontext.ITypiaContext, name
   if importer := context.Importer; importer != nil {
     return importer.Internal(name)
   }
-  f := nativecontext.EmitFactoryOf(check_dynamic_properties_factory, context.Emit)
+  f := nativecontext.NodeFactoryOf(context.Emit)
   return f.NewIdentifier(name)
 }
 
@@ -367,7 +363,7 @@ func check_dynamic_properties_key_shape(props Check_dynamic_propertiesProps, key
       }
       conditions = append(conditions, condition)
     }
-    f := nativecontext.EmitFactoryOf(check_dynamic_properties_factory, props.Context.Emit)
+    f := nativecontext.NodeFactoryOf(props.Context.Emit)
     for _, template := range entry.Key.Templates {
       // Keep the same structural lowering as the full checker. Removing slot
       // tags first would change constrained string captures from [\s\S] to .
@@ -454,28 +450,24 @@ func check_dynamic_properties_key_expected(dynamic []nativehelpers.IExpressionEn
 // The advice `Superfluous` gives -- remove the property -- is wrong here. The
 // property is declared; its key is what broke.
 func check_dynamic_properties_invalid_key_description(emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(check_dynamic_properties_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   return f.NewCallExpression(
-    nativefactories.IdentifierFactory.Access(
-      nil,
-      f.NewArrayLiteralExpression(
-        f.NewNodeList([]*shimast.Node{
-          f.NewTemplateExpression(
-            f.NewTemplateHead("The key `", "The key \\`", shimast.TokenFlagsNone),
-            f.NewNodeList([]*shimast.Node{
-              f.NewTemplateSpan(
-                f.NewIdentifier("key"),
-                f.NewTemplateTail("` does not satisfy the type its index signature declares.", "\\` does not satisfy the type its index signature declares.", shimast.TokenFlagsNone),
-              ),
-            }),
-          ),
-          f.NewStringLiteral("", shimast.TokenFlagsNone),
-          f.NewStringLiteral("Please correct the key next time.", shimast.TokenFlagsNone),
-        }),
-        true,
-      ),
-      "join",
-    ),
+    f.NewPropertyAccessExpression(f.NewArrayLiteralExpression(
+      f.NewNodeList([]*shimast.Node{
+        f.NewTemplateExpression(
+          f.NewTemplateHead("The key `", "The key \\`", shimast.TokenFlagsNone),
+          f.NewNodeList([]*shimast.Node{
+            f.NewTemplateSpan(
+              f.NewIdentifier("key"),
+              f.NewTemplateTail("` does not satisfy the type its index signature declares.", "\\` does not satisfy the type its index signature declares.", shimast.TokenFlagsNone),
+            ),
+          }),
+        ),
+        f.NewStringLiteral("", shimast.TokenFlagsNone),
+        f.NewStringLiteral("Please correct the key next time.", shimast.TokenFlagsNone),
+      }),
+      true,
+    ), nil, f.NewIdentifier("join"), shimast.NodeFlagsNone),
     nil,
     nil,
     f.NewNodeList([]*shimast.Node{
@@ -486,28 +478,24 @@ func check_dynamic_properties_invalid_key_description(emit ...*shimprinter.EmitC
 }
 
 func check_dynamic_properties_superfluous_description(emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(check_dynamic_properties_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   return f.NewCallExpression(
-    nativefactories.IdentifierFactory.Access(
-      nil,
-      f.NewArrayLiteralExpression(
-        f.NewNodeList([]*shimast.Node{
-          f.NewTemplateExpression(
-            f.NewTemplateHead("The property `", "The property \\`", shimast.TokenFlagsNone),
-            f.NewNodeList([]*shimast.Node{
-              f.NewTemplateSpan(
-                f.NewIdentifier("key"),
-                f.NewTemplateTail("` is not defined in the object type.", "\\` is not defined in the object type.", shimast.TokenFlagsNone),
-              ),
-            }),
-          ),
-          f.NewStringLiteral("", shimast.TokenFlagsNone),
-          f.NewStringLiteral("Please remove the property next time.", shimast.TokenFlagsNone),
-        }),
-        true,
-      ),
-      "join",
-    ),
+    f.NewPropertyAccessExpression(f.NewArrayLiteralExpression(
+      f.NewNodeList([]*shimast.Node{
+        f.NewTemplateExpression(
+          f.NewTemplateHead("The property `", "The property \\`", shimast.TokenFlagsNone),
+          f.NewNodeList([]*shimast.Node{
+            f.NewTemplateSpan(
+              f.NewIdentifier("key"),
+              f.NewTemplateTail("` is not defined in the object type.", "\\` is not defined in the object type.", shimast.TokenFlagsNone),
+            ),
+          }),
+        ),
+        f.NewStringLiteral("", shimast.TokenFlagsNone),
+        f.NewStringLiteral("Please remove the property next time.", shimast.TokenFlagsNone),
+      }),
+      true,
+    ), nil, f.NewIdentifier("join"), shimast.NodeFlagsNone),
     nil,
     nil,
     f.NewNodeList([]*shimast.Node{
@@ -516,5 +504,3 @@ func check_dynamic_properties_superfluous_description(emit ...*shimprinter.EmitC
     shimast.NodeFlagsNone,
   )
 }
-
-var check_dynamic_properties_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})

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

@@ -15,9 +15,9 @@ import (
 // @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_everything(array *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(check_everything_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   return f.NewCallExpression(
-    nativefactories.IdentifierFactory.Access(nil, array, "every"),
+    f.NewPropertyAccessExpression(array, nil, f.NewIdentifier("every"), shimast.NodeFlagsNone),
     nil,
     nil,
     f.NewNodeList([]*shimast.Node{
@@ -25,7 +25,7 @@ func Check_everything(array *shimast.Expression, emit ...*shimprinter.EmitContex
         nil,
         nil,
         f.NewNodeList([]*shimast.Node{
-          nativefactories.IdentifierFactory.Parameter("flag", nativefactories.TypeFactory.Keyword("boolean"), nil),
+          nativefactories.IdentifierFactory.Parameter("flag", nativefactories.TypeFactory.Keyword("boolean", emit...), nil, emit...),
         }),
         nil,
         nil,
@@ -36,5 +36,3 @@ func Check_everything(array *shimast.Expression, emit ...*shimprinter.EmitContex
     shimast.NodeFlagsNone,
   )
 }
-
-var check_everything_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})

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

@@ -29,7 +29,7 @@ func check_exclude_condition(
   if len(values) == 0 {
     return nil
   }
-  f := nativecontext.EmitFactoryOf(check_exclude_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   var expression *shimast.Node
   for _, value := range values {
     comparison := f.NewBinaryExpression(
@@ -74,7 +74,7 @@ func check_exclude_values(tag nativemetadata.IMetadataTypeTag) []any {
 }
 
 func check_exclude_literal(typ string, value any, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(check_exclude_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   switch typ {
   case "string":
     return f.NewStringLiteral(fmt.Sprint(value), shimast.TokenFlagsNone)
@@ -84,5 +84,3 @@ func check_exclude_literal(typ string, value any, emit *shimprinter.EmitContext)
     return f.NewIdentifier(fmt.Sprint(value))
   }
 }
-
-var check_exclude_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})

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

@@ -29,8 +29,8 @@ type Check_nativeProps 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_native(props Check_nativeProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(check_native_factory, props.Emit)
-  instanceOf := nativefactories.ExpressionFactory.IsInstanceOf(props.Name, props.Input)
+  f := nativecontext.NodeFactoryOf(props.Emit)
+  instanceOf := nativefactories.ExpressionFactory.IsInstanceOf(props.Name, props.Input, props.Emit)
   if atomic, ok := nativemetadata.MetadataSchema_atomicLikeNative(props.Name); ok {
     return f.NewBinaryExpression(
       nil,
@@ -48,5 +48,3 @@ func Check_native(props Check_nativeProps) *shimast.Node {
   }
   return instanceOf
 }
-
-var check_native_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})

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

@@ -34,7 +34,7 @@ type Check_numberProps 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_number(props Check_numberProps) nativehelpers.ICheckEntry {
-  f := nativecontext.EmitFactoryOf(check_number_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   base := f.NewBinaryExpression(
     nil,
     f.NewStringLiteral("number", shimast.TokenFlagsNone),
@@ -190,7 +190,5 @@ func check_number_transpile(context nativecontext.ITypiaContext, script string)
   return nativefactories.ExpressionFactory.Transpile(nativefactories.ExpressionFactory_TranspileProps{
     Importer: importer,
     Script:   script,
-  })
+  }, context.Emit)
 }
-
-var check_number_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})

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

@@ -107,7 +107,7 @@ func check_object_regular_expression(props Check_objectProps, entry nativehelper
   if !entry.StrictOptionalUndefined || key == nil {
     return entry.Expression
   }
-  f := nativecontext.EmitFactoryOf(check_object_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   present := f.NewBinaryExpression(
     nil,
     f.NewStringLiteral(*key, shimast.TokenFlagsNone),
@@ -130,7 +130,7 @@ type check_object_reduceProps struct {
 }
 
 func check_object_reduce(props check_object_reduceProps, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(check_object_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   if len(props.Expressions) == 0 {
     return props.Config.Positive
   }
@@ -145,8 +145,6 @@ func check_object_reduce(props check_object_reduceProps, emit ...*shimprinter.Em
     f.NewArrayLiteralExpression(
       f.NewNodeList(props.Expressions),
       false,
-    ),
+    ), emit...,
   )
 }
-
-var check_object_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})

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

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

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

@@ -29,7 +29,7 @@ type Check_stringProps 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_string(props Check_stringProps) nativehelpers.ICheckEntry {
-  f := nativecontext.EmitFactoryOf(check_string_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   conditions := check_string_type_tags(props)
   return nativehelpers.ICheckEntry{
     Expected: props.Atomic.GetName(),
@@ -86,7 +86,5 @@ func check_string_transpile(context nativecontext.ITypiaContext, script string)
   return nativefactories.ExpressionFactory.Transpile(nativefactories.ExpressionFactory_TranspileProps{
     Importer: importer,
     Script:   script,
-  })
+  }, context.Emit)
 }
-
-var check_string_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})

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

@@ -35,7 +35,7 @@ type Check_templateProps 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_template(props Check_templateProps) nativehelpers.ICheckEntry {
-  f := nativecontext.EmitFactoryOf(check_template_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   conditions := []*shimast.Node{
     f.NewBinaryExpression(
       nil,
@@ -268,7 +268,7 @@ func check_template_value_conditions(props Check_templateProps, base string, ato
 }
 
 func check_template_coerce_input(kind string, input *shimast.Expression, emit *shimprinter.EmitContext) *shimast.Expression {
-  f := nativecontext.EmitFactoryOf(check_template_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   coerce := ""
   switch kind {
   case "number":
@@ -295,7 +295,7 @@ func check_template_coerce_input(kind string, input *shimast.Expression, emit *s
 // check_template_value_conditions so direct captures and backtracking slices
 // share the same path.
 func check_template_capture_input(pattern string, capture templateCapture, input *shimast.Expression, emit *shimprinter.EmitContext) *shimast.Expression {
-  f := nativecontext.EmitFactoryOf(check_template_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   element := f.NewElementAccessExpression(
     f.NewCallExpression(
       f.NewIdentifier("RegExp(/"+pattern+"/).exec"),
@@ -318,7 +318,7 @@ func check_template_capture_input(pattern string, capture templateCapture, input
 // semantics without repeating the same suffix search or committing to
 // RegExp.exec's single greedy capture.
 func check_template_backtracking(props Check_templateProps, tpl *nativemetadata.MetadataTemplate) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(check_template_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   statements := make([]*shimast.Node, 0, (len(tpl.Row)+1)*2+1)
   for index := 0; index <= len(tpl.Row); index++ {
     memoName := fmt.Sprintf("_templateMemo%d", index)
@@ -408,7 +408,7 @@ func check_template_backtracking(props Check_templateProps, tpl *nativemetadata.
 }
 
 func check_template_backtracking_step(props Check_templateProps, tpl *nativemetadata.MetadataTemplate, index int, offset *shimast.Expression) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(check_template_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   if index == len(tpl.Row) {
     return f.NewBinaryExpression(
       nil,
@@ -538,7 +538,7 @@ func check_template_backtracking_step(props Check_templateProps, tpl *nativemeta
 }
 
 func check_template_backtracking_call(index int, offset *shimast.Expression, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(check_template_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   return f.NewCallExpression(
     f.NewIdentifier(fmt.Sprintf("_templateVisit%d", index)),
     nil,
@@ -653,7 +653,7 @@ func check_template_inline_interpolation_tags(props Check_templateProps, tpl *na
 }
 
 func check_template_reduce(expressions []*shimast.Node, operator shimast.Kind, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(check_template_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   if len(expressions) == 0 {
     return f.NewKeywordExpression(shimast.KindTrueKeyword)
   }
@@ -669,5 +669,3 @@ func check_template_reduce(expressions []*shimast.Node, operator shimast.Kind, e
   }
   return output
 }
-
-var check_template_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})

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

@@ -88,7 +88,7 @@ func Decode_union_object(props Decode_union_objectProps) *shimast.Node {
       },
     })
   }
-  f := nativecontext.EmitFactoryOf(decode_union_object_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   return f.NewCallExpression(
     f.NewArrowFunction(
       nil,
@@ -126,7 +126,7 @@ type decode_union_object_IBranch struct {
 }
 
 func decode_union_object_iterate(props decode_union_object_iterateProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(decode_union_object_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   branches := []decode_union_object_IBranch{}
   for _, u := range props.Unions {
     condition := u.Is()
@@ -186,5 +186,3 @@ type decode_union_object_IUnion struct {
   Is    func() *shimast.Node
   Value func() *shimast.Node
 }
-
-var decode_union_object_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})

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

@@ -127,7 +127,7 @@ func Feature_object_entries(props Feature_object_entriesProps) []nativehelpers.I
 }
 
 func feature_object_entries_property_input(input *shimast.Expression, sole *string, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(feature_object_entries_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   if sole == nil {
     return f.NewIdentifier("value")
   }
@@ -168,7 +168,7 @@ func feature_object_entries_internal(context nativecontext.ITypiaContext, name s
   if importer := context.Importer; importer != nil {
     return importer.Internal(name)
   }
-  f := nativecontext.EmitFactoryOf(feature_object_entries_factory, context.Emit)
+  f := nativecontext.NodeFactoryOf(context.Emit)
   return f.NewIdentifier(name)
 }
 
@@ -224,5 +224,3 @@ var feature_object_entries_reserved = map[string]bool{
   "while":      true,
   "with":       true,
 }
-
-var feature_object_entries_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})

package/native/core/programmers/json/JsonAssertParseProgrammer.go

@@ -32,7 +32,7 @@ type JsonAssertParseProgrammer_DecomposeProps struct {
 }
 
 func (jsonAssertParseProgrammerNamespace) Decompose(props JsonAssertParseProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
-  f := nativecontext.EmitFactoryOf(jsonParseProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   nativefactories.JsonMetadataFactory.Analyze(nativefactories.JsonMetadataFactory_IProps{
     Method:  props.Functor.Method,
     Checker: props.Context.Checker,
@@ -116,7 +116,7 @@ func (jsonAssertParseProgrammerNamespace) Write(props nativecontext.IProgrammerP
     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/json/JsonAssertStringifyProgrammer.go

@@ -31,8 +31,6 @@ type JsonAssertStringifyProgrammer_DecomposeProps struct {
   Init    *shimast.Node
 }
 
-var jsonAssertStringifyProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (jsonAssertStringifyProgrammerNamespace) Decompose(props JsonAssertStringifyProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
   assertContext := props.Context
   functional := false
@@ -54,7 +52,7 @@ func (jsonAssertStringifyProgrammerNamespace) Decompose(props JsonAssertStringif
     Name:      props.Name,
     Validated: true,
   })
-  f := nativecontext.EmitFactoryOf(jsonAssertStringifyProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   statements := append([]*shimast.Node{}, assert.Statements...)
   statements = append(statements, stringify.Statements...)
   statements = append(statements,
@@ -109,7 +107,7 @@ func (jsonAssertStringifyProgrammerNamespace) Write(props nativecontext.IProgram
     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/json/JsonIsParseProgrammer.go

@@ -28,8 +28,6 @@ type JsonIsParseProgrammer_DecomposeProps struct {
   Name    *string
 }
 
-var jsonParseProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (jsonIsParseProgrammerNamespace) Decompose(props JsonIsParseProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
   is := nativeprogrammers.IsProgrammer.Decompose(nativeprogrammers.IsProgrammer_DecomposeProps{
     Context: jsonParseProgrammer_context(props.Context, &jsonParseProgrammer_options{
@@ -42,7 +40,7 @@ func (jsonIsParseProgrammerNamespace) Decompose(props JsonIsParseProgrammer_Deco
     Name:    props.Name,
   })
 
-  f := nativecontext.EmitFactoryOf(jsonParseProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   return nativeinternal.FeatureProgrammer_IDecomposed{
     Functions: is.Functions,
     Statements: append(append([]*shimast.Node{}, is.Statements...), nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
@@ -114,7 +112,7 @@ func (jsonIsParseProgrammerNamespace) Write(props nativecontext.IProgrammerProps
     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,
@@ -150,7 +148,7 @@ func jsonProgrammer_import_type(context nativecontext.ITypiaContext, props nativ
   if importer := context.Importer; importer != nil {
     return importer.Type(props)
   }
-  f := nativecontext.EmitFactoryOf(jsonParseProgrammer_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))
   }
@@ -158,7 +156,7 @@ func jsonProgrammer_import_type(context nativecontext.ITypiaContext, props nativ
 }
 
 func jsonProgrammer_typeReference(context nativecontext.ITypiaContext, typ *shimchecker.Type, name *string) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(jsonParseProgrammer_factory, context.Emit)
+  f := nativecontext.NodeFactoryOf(context.Emit)
   if name != nil {
     return f.NewTypeReferenceNode(f.NewIdentifier(*name), nil)
   }

package/native/core/programmers/json/JsonIsStringifyProgrammer.go

@@ -29,8 +29,6 @@ type JsonIsStringifyProgrammer_DecomposeProps struct {
   Name    *string
 }
 
-var jsonIsStringifyProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (jsonIsStringifyProgrammerNamespace) Decompose(props JsonIsStringifyProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
   isContext := props.Context
   functional := false
@@ -57,7 +55,7 @@ func (jsonIsStringifyProgrammerNamespace) Decompose(props JsonIsStringifyProgram
     Validated: true,
   })
 
-  f := nativecontext.EmitFactoryOf(jsonIsStringifyProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   statements := append([]*shimast.Node{}, is.Statements...)
   statements = append(statements, stringify.Statements...)
   statements = append(statements,
@@ -113,7 +111,7 @@ func (jsonIsStringifyProgrammerNamespace) Write(props nativecontext.IProgrammerP
     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,