typia 15.1.0 → 15.2.0

package/native/core/programmers/AssertProgrammer.go

@@ -74,10 +74,8 @@ type assertProgrammerGuardianNamespace struct{}
 
 var Guardian = assertProgrammerGuardianNamespace{}
 
-var assertProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (assertProgrammerNamespace) Decompose(props AssertProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   is := IsProgrammer.Decompose(IsProgrammer_DecomposeProps{
     Config:  IsProgrammer_IConfig{Equals: props.Config.Equals},
     Context: props.Context,
@@ -223,7 +221,7 @@ func (assertProgrammerNamespace) Write(props AssertProgrammer_IProps) *shimast.N
     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,
@@ -231,7 +229,7 @@ func (assertProgrammerNamespace) Write(props AssertProgrammer_IProps) *shimast.N
 }
 
 func assertProgrammer_atomist(props AssertProgrammer_DecomposeProps) func(next nativeinternal.CheckerProgrammer_AtomistProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   return func(next nativeinternal.CheckerProgrammer_AtomistProps) *shimast.Node {
     expressions := []*shimast.Node{}
     if next.Entry.Expression != nil {
@@ -273,7 +271,7 @@ func assertProgrammer_combiner(props struct {
   Context nativecontext.ITypiaContext
   Functor *nativehelpers.FunctionProgrammer
 }) nativeinternal.CheckerProgrammer_IConfig_Combiner {
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   return func(next nativeinternal.CheckerProgrammer_CombinerProps) *shimast.Node {
     if next.Explore.Tracable == false {
       options := &IsProgrammer_CONFIG_IOptions{
@@ -326,7 +324,7 @@ type assertProgrammer_assertObjectProps struct {
 }
 
 func assertProgrammer_assert_object(props assertProgrammer_assertObjectProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   return nativeiterate.Check_object(nativeiterate.Check_objectProps{
     Config: nativeiterate.Check_object_IConfig{
       Equals:    props.Config.Equals,
@@ -379,7 +377,7 @@ func assertProgrammer_assert_object(props assertProgrammer_assertObjectProps) *s
 }
 
 func assertProgrammer_joiner(props AssertProgrammer_DecomposeProps) nativeinternal.CheckerProgrammer_IConfig_IJoiner {
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   joiner := nativeinternal.CheckerProgrammer_IConfig_IJoiner{
     Object: func(next nativeinternal.CheckerProgrammer_JoinerObjectProps) *shimast.Node {
       return assertProgrammer_assert_object(assertProgrammer_assertObjectProps{Config: props.Config, Context: props.Context, Functor: props.Functor, Entries: next.Entries, Input: next.Input})
@@ -417,7 +415,7 @@ type assertProgrammer_createGuardCallProps struct {
 }
 
 func assertProgrammer_create_guard_call(props assertProgrammer_createGuardCallProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   exceptionable := props.Exceptionable
   if exceptionable == nil {
     exceptionable = f.NewIdentifier("_exceptionable")
@@ -441,7 +439,7 @@ func assertProgrammer_create_guard_call(props assertProgrammer_createGuardCallPr
 }
 
 func assertProgrammer_expected_expression(props assertProgrammer_createGuardCallProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   if props.Functor == nil || len(props.Expected) < 128 {
     return f.NewStringLiteral(props.Expected, shimast.TokenFlagsNone)
   }
@@ -451,7 +449,7 @@ func assertProgrammer_expected_expression(props assertProgrammer_createGuardCall
 }
 
 func (assertProgrammerGuardianNamespace) Identifier(emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   return f.NewIdentifier("errorFactory")
 }
 
@@ -459,7 +457,7 @@ func (assertProgrammerGuardianNamespace) Parameter(props struct {
   Context nativecontext.ITypiaContext
   Init    *shimast.Node
 }) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   init := props.Init
   if init == nil {
     init = f.NewToken(shimast.KindQuestionToken)
@@ -468,7 +466,7 @@ func (assertProgrammerGuardianNamespace) Parameter(props struct {
 }
 
 func (assertProgrammerGuardianNamespace) Type(context nativecontext.ITypiaContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, context.Emit)
+  f := nativecontext.NodeFactoryOf(context.Emit)
   return f.NewFunctionTypeNode(
     nil,
     f.NewNodeList([]*shimast.Node{
@@ -497,7 +495,7 @@ func assertProgrammer_reduce(expressions []*shimast.Node, operator shimast.Kind,
 }
 
 func assertProgrammer_binary(left *shimast.Expression, operator shimast.Kind, right *shimast.Expression, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   return f.NewBinaryExpression(nil, left, nil, f.NewToken(operator), right)
 }
 
@@ -510,7 +508,7 @@ func assertProgrammer_or(left *shimast.Expression, right *shimast.Expression, em
 }
 
 func assertProgrammer_exceptionable(explore nativeinternal.FeatureProgrammer_IExplore, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   if explore.From == "top" || explore.Source == "top" {
     return f.NewKeywordExpression(shimast.KindTrueKeyword)
   }
@@ -518,7 +516,7 @@ func assertProgrammer_exceptionable(explore nativeinternal.FeatureProgrammer_IEx
 }
 
 func assertProgrammer_path(explore nativeinternal.FeatureProgrammer_IExplore, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   if explore.Postfix != "" {
     return f.NewIdentifier("_path + " + explore.Postfix)
   }
@@ -536,14 +534,14 @@ func assertProgrammer_internal(context nativecontext.ITypiaContext, name string)
   if importer := context.Importer; importer != nil {
     return importer.Internal(name)
   }
-  return nativecontext.EmitFactoryOf(assertProgrammer_factory, context.Emit).NewIdentifier(name)
+  return nativecontext.NodeFactoryOf(context.Emit).NewIdentifier(name)
 }
 
 func assertProgrammer_import_type(context nativecontext.ITypiaContext, props nativecontext.ImportProgrammer_TypeProps) *shimast.Node {
   if importer := context.Importer; importer != nil {
     return importer.Type(props)
   }
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, context.Emit)
+  f := nativecontext.NodeFactoryOf(context.Emit)
   return f.NewTypeReferenceNode(f.NewIdentifier(props.Name.(string)), nil)
 }
 

package/native/core/programmers/IsProgrammer.go

@@ -154,14 +154,12 @@ type IsProgrammer_DecodeObjectProps struct {
   Prefix string
 }
 
-var isProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (isProgrammerNamespace) Configure(props struct {
   Options *IsProgrammer_CONFIG_IOptions
   Context nativecontext.ITypiaContext
   Functor *nativehelpers.FunctionProgrammer
 }) nativeinternal.CheckerProgrammer_IConfig {
-  f := nativecontext.EmitFactoryOf(isProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   options := props.Options
   return nativeinternal.CheckerProgrammer_IConfig{
     Prefix:        "_i",
@@ -246,7 +244,7 @@ func (isProgrammerNamespace) Configure(props struct {
 }
 
 func (isProgrammerNamespace) Decompose(props IsProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
-  f := nativecontext.EmitFactoryOf(isProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   options := &IsProgrammer_CONFIG_IOptions{
     Numeric: props.Context.Options.Numeric,
     Finite:  props.Context.Options.Finite,
@@ -314,7 +312,7 @@ func (isProgrammerNamespace) Write(props IsProgrammer_IProps) *shimast.Node {
     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,
@@ -393,7 +391,7 @@ func (isProgrammerNamespace) Decode_object(props IsProgrammer_DecodeObjectProps)
   if props.Prefix != "" {
     config.Prefix = props.Prefix
   }
-  return nativeinternal.CheckerProgrammer.Decode_object(nativeinternal.CheckerProgrammer_DecodeObjectProps{
+  return nativeinternal.CheckerProgrammer.Decode_object(nativeinternal.CheckerProgrammer_DecodeObjectProps{Emit: props.Context.Emit,
     Config:  config,
     Context: props.Context,
     Functor: props.Functor,
@@ -407,7 +405,7 @@ func (isProgrammerNamespace) Decode_to_json(props struct {
   Input     *shimast.Expression
   CheckNull bool
 }, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(isProgrammer_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   var ec *shimprinter.EmitContext
   if len(emit) != 0 {
     ec = emit[0]
@@ -417,12 +415,12 @@ func (isProgrammerNamespace) Decode_to_json(props struct {
       CheckArray: false,
       CheckNull:  props.CheckNull,
       Input:      props.Input,
-    }),
+    }, emit...),
     shimast.KindAmpersandAmpersandToken,
     isProgrammer_binary(
       f.NewStringLiteral("function", shimast.TokenFlagsNone),
       shimast.KindEqualsEqualsEqualsToken,
-      nativefactories.ValueFactory.TYPEOF(nativefactories.IdentifierFactory.Access(ec, props.Input, "toJSON")),
+      nativefactories.ValueFactory.TYPEOF(nativefactories.IdentifierFactory.Access(ec, props.Input, "toJSON"), emit...),
       ec,
     ),
     ec,
@@ -430,7 +428,7 @@ func (isProgrammerNamespace) Decode_to_json(props struct {
 }
 
 func (isProgrammerNamespace) Decode_functional(input *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(isProgrammer_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   var ec *shimprinter.EmitContext
   if len(emit) != 0 {
     ec = emit[0]
@@ -438,7 +436,7 @@ func (isProgrammerNamespace) Decode_functional(input *shimast.Expression, emit .
   return isProgrammer_binary(
     f.NewStringLiteral("function", shimast.TokenFlagsNone),
     shimast.KindEqualsEqualsEqualsToken,
-    nativefactories.ValueFactory.TYPEOF(input),
+    nativefactories.ValueFactory.TYPEOF(input, emit...),
     ec,
   )
 }
@@ -455,7 +453,7 @@ func isProgrammer_reduce(expressions []*shimast.Node, operator shimast.Kind, ini
 }
 
 func isProgrammer_binary(left *shimast.Expression, operator shimast.Kind, right *shimast.Expression, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(isProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   return f.NewBinaryExpression(
     nil,
     left,

package/native/core/programmers/RandomProgrammer.go

@@ -104,10 +104,8 @@ const (
   randomProgrammer_PREFIX_TUPLE  = "_rt"
 )
 
-var randomProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (randomProgrammerNamespace) Decompose(props RandomProgrammer_IDecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
-  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   collection := schemametadata.NewMetadataCollection()
   result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{
     Checker: props.Context.Checker,
@@ -230,7 +228,7 @@ func (randomProgrammerNamespace) Write(props RandomProgrammer_IProps) *shimast.N
     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,
@@ -303,7 +301,7 @@ func randomProgrammer_write_object_functions(props struct {
   Functor    *nativehelpers.FunctionProgrammer
   Collection *schemametadata.MetadataCollection
 }) []*shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   output := []*shimast.Node{}
   unsatisfiableObjects, _ := nativehelpers.RandomJoiner.UnsatisfiableRecursives(props.Collection.Objects(), props.Collection.Tuples())
   for i, obj := range props.Collection.Objects() {
@@ -369,7 +367,7 @@ func randomProgrammer_write_array_functions(props struct {
   Functor    *nativehelpers.FunctionProgrammer
   Collection *schemametadata.MetadataCollection
 }) []*shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   output := []*shimast.Node{}
   for _, array := range props.Collection.Arrays() {
     if array.Recursive == false {
@@ -422,7 +420,7 @@ func randomProgrammer_write_tuple_functions(props struct {
   Functor    *nativehelpers.FunctionProgrammer
   Collection *schemametadata.MetadataCollection
 }) []*shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   output := []*shimast.Node{}
   _, unsatisfiableTuples := nativehelpers.RandomJoiner.UnsatisfiableRecursives(props.Collection.Objects(), props.Collection.Tuples())
   for _, tuple := range props.Collection.Tuples() {
@@ -477,7 +475,7 @@ func randomProgrammer_write_tuple_functions(props struct {
 }
 
 func randomProgrammer_decode(props randomProgrammer_decodeProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   expressions := []*shimast.Node{}
   if props.Metadata.Any {
     expressions = append(expressions, f.NewStringLiteral("any type used...", shimast.TokenFlagsNone))
@@ -598,7 +596,7 @@ func randomProgrammer_decode(props randomProgrammer_decodeProps) *shimast.Node {
 // randomProgrammer_decode_pick selects a lazy candidate through the optional pick hook or uniform built-in fallback.
 // The custom hook receives its generator object as the receiver; only the selected candidate executes.
 func randomProgrammer_decode_pick(props randomProgrammer_decodeProps, expressions []*shimast.Node) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   pickers := make([]*shimast.Node, 0, len(expressions))
   for _, expr := range expressions {
     value := expr
@@ -664,7 +662,7 @@ func randomProgrammer_recursion_escape(props randomProgrammer_decodeProps) *shim
   if recursive == false {
     return nil
   }
-  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   if props.Metadata.Nullable {
     return f.NewKeywordExpression(shimast.KindNullKeyword)
   }
@@ -685,7 +683,7 @@ func randomProgrammer_decode_atomic(props randomProgrammer_decodeAtomicProps) []
   } else {
     schemaList = nativeiterate.Json_schema_number_export(props.Atomic)
   }
-  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   output := make([]*shimast.Node, 0, len(schemaList))
   for _, schema := range schemaList {
     composed := randomProgrammer_compose_atomic(props.Atomic.Type, schema, props.Context.Emit)
@@ -711,7 +709,7 @@ type randomProgrammer_composedAtomic struct {
 }
 
 func randomProgrammer_compose_atomic(atomicType string, schema nativeiterate.JsonSchema, emit *shimprinter.EmitContext) randomProgrammer_composedAtomic {
-  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   if atomicType == "string" {
     // A string leaf that also carries a length tag needs the bounds forwarded
     // to the format and pattern generators; only the plain-string fall-through
@@ -809,7 +807,7 @@ func randomProgrammer_decode_array(props randomProgrammer_decodeArrayProps) []*s
     Array:      props.Array,
   })
   schemaList = randomProgrammer_array_schema_list(props.Array, components, schemaList)
-  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   output := make([]*shimast.Node, 0, len(schemaList))
   if props.Array.Type.Recursive {
     if tag := randomProgrammer_find_positive_min_items(props.Array.Tags); tag != nil {
@@ -889,7 +887,7 @@ func randomProgrammer_decode_array(props randomProgrammer_decodeArrayProps) []*s
 }
 
 func randomProgrammer_decode_tuple(props randomProgrammer_decodeTupleProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   if props.Tuple.Type.Recursive {
     depth := nativefactories.ExpressionFactory.Number(0, props.Context.Emit)
     if props.Explore.Recursive {
@@ -929,7 +927,7 @@ func randomProgrammer_decode_tuple(props randomProgrammer_decodeTupleProps) *shi
 }
 
 func randomProgrammer_decode_object(props randomProgrammer_decodeObjectProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   var args *shimast.NodeList
   if props.Explore.Function {
     recursive := f.NewIdentifier("_recursive")
@@ -967,7 +965,7 @@ func randomProgrammer_decode_set(props struct {
   Explore randomProgrammer_IExplore
   Set     *schemametadata.MetadataSet
 }) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   array := schemametadata.MetadataArray_create(schemametadata.MetadataArray{
     Tags: [][]schemametadata.IMetadataTypeTag{},
     Type: schemametadata.MetadataArrayType_create(schemametadata.MetadataArrayType{
@@ -998,7 +996,7 @@ func randomProgrammer_decode_map(props struct {
   Explore randomProgrammer_IExplore
   Map     *schemametadata.MetadataMap
 }) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   ofMap := true
   tupleType := schemametadata.MetadataTupleType_create(schemametadata.MetadataTupleType{
     Name:      fmt.Sprintf("[%s, %s]", props.Map.Key.GetName(), props.Map.Value.GetName()),
@@ -1085,12 +1083,12 @@ func randomProgrammer_decode_native(props struct {
   if props.Name == "RegExp" {
     return randomProgrammer_decode_regexp(props.Context)
   }
-  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   return f.NewNewExpression(f.NewIdentifier(props.Name), nil, f.NewNodeList(nil))
 }
 
 func randomProgrammer_decode_native_date(context nativecontext.ITypiaContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, context.Emit)
+  f := nativecontext.NodeFactoryOf(context.Emit)
   return f.NewNewExpression(
     f.NewIdentifier("Date"),
     nil,
@@ -1106,7 +1104,7 @@ func randomProgrammer_decode_native_byte_array(props struct {
   Explore randomProgrammer_IExplore
   Name    string
 }) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   protobufType, minimum, maximum := randomProgrammer_typed_array_range(props.Name)
   atomic := "number"
   if props.Name == "BigInt64Array" || props.Name == "BigUint64Array" {
@@ -1163,7 +1161,7 @@ func randomProgrammer_decode_native_blob(props struct {
   Explore randomProgrammer_IExplore
   Name    string
 }) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   return f.NewNewExpression(
     f.NewIdentifier("Blob"),
     nil,
@@ -1186,7 +1184,7 @@ func randomProgrammer_decode_native_file(props struct {
   Explore randomProgrammer_IExplore
   Name    string
 }) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   return f.NewNewExpression(
     f.NewIdentifier("File"),
     nil,
@@ -1222,7 +1220,7 @@ func randomProgrammer_decode_native_array_buffer(props struct {
   Explore randomProgrammer_IExplore
   Name    string
 }) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   if props.Name == "ArrayBuffer" {
     return nativefactories.IdentifierFactory.Access(
       props.Context.Emit,
@@ -1333,7 +1331,7 @@ func randomProgrammer_decode_native_data_view(props struct {
   Explore randomProgrammer_IExplore
   Name    string
 }) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   return f.NewNewExpression(
     f.NewIdentifier("DataView"),
     nil,
@@ -1353,7 +1351,7 @@ func randomProgrammer_decode_native_data_view(props struct {
 }
 
 func randomProgrammer_decode_regexp(context nativecontext.ITypiaContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, context.Emit)
+  f := nativecontext.NodeFactoryOf(context.Emit)
   return f.NewNewExpression(
     f.NewIdentifier("RegExp"),
     nil,
@@ -1385,7 +1383,7 @@ func randomProgrammer_write_ranged_string(context nativecontext.ITypiaContext, m
 }
 
 func randomProgrammer_coalesce(context nativecontext.ITypiaContext, method string, internal string) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, context.Emit)
+  f := nativecontext.NodeFactoryOf(context.Emit)
   return nativefactories.ExpressionFactory.Coalesce(
     nativefactories.IdentifierFactory.Access(context.Emit, f.NewIdentifier("_generator"), method, true),
     randomProgrammer_internal(context, internal),
@@ -1394,7 +1392,7 @@ func randomProgrammer_coalesce(context nativecontext.ITypiaContext, method strin
 }
 
 func randomProgrammer_schema_without_items(schema nativeiterate.JsonSchema, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   keys := make([]string, 0, len(schema))
   for key := range schema {
     if key != "items" {
@@ -1441,14 +1439,14 @@ func randomProgrammer_internal(context nativecontext.ITypiaContext, name string)
   if importer := context.Importer; importer != nil {
     return importer.Internal(name)
   }
-  return nativecontext.EmitFactoryOf(randomProgrammer_factory, context.Emit).NewIdentifier(name)
+  return nativecontext.NodeFactoryOf(context.Emit).NewIdentifier(name)
 }
 
 func randomProgrammer_import_type(context nativecontext.ITypiaContext, props nativecontext.ImportProgrammer_TypeProps) *shimast.Node {
   if importer := context.Importer; importer != nil {
     return importer.Type(props)
   }
-  f := nativecontext.EmitFactoryOf(randomProgrammer_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))
   }
@@ -1456,7 +1454,7 @@ func randomProgrammer_import_type(context nativecontext.ITypiaContext, props nat
 }
 
 func randomProgrammer_type_reference(context nativecontext.ITypiaContext, typ *shimchecker.Type, name *string) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, context.Emit)
+  f := nativecontext.NodeFactoryOf(context.Emit)
   if name != nil {
     return f.NewTypeReferenceNode(f.NewIdentifier(*name), nil)
   }
@@ -1577,7 +1575,7 @@ func randomProgrammer_tags(base []schemametadata.IMetadataTypeTag, rows ...[]sch
 
 func randomProgrammer_first(list []*shimast.Node, emit *shimprinter.EmitContext) *shimast.Node {
   if len(list) == 0 {
-    return nativecontext.EmitFactoryOf(randomProgrammer_factory, emit).NewIdentifier("undefined")
+    return nativecontext.NodeFactoryOf(emit).NewIdentifier("undefined")
   }
   return list[0]
 }

package/native/core/programmers/ValidateProgrammer.go

@@ -65,10 +65,8 @@ type ValidateProgrammer_DecomposeProps struct {
   Name    *string
 }
 
-var validateProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (validateProgrammerNamespace) Decompose(props ValidateProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
-  f := nativecontext.EmitFactoryOf(validateProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   is := IsProgrammer.Decompose(IsProgrammer_DecomposeProps{
     Context: props.Context,
     Functor: props.Functor,
@@ -209,12 +207,12 @@ func (validateProgrammerNamespace) Write(props ValidateProgrammer_IProps) *shima
   })
   var wrapper func(arrow *shimast.Node) *shimast.Node
   if props.Config.StandardSchema {
-    f := nativecontext.EmitFactoryOf(validateProgrammer_factory, props.Context.Emit)
+    f := nativecontext.NodeFactoryOf(props.Context.Emit)
     wrapper = func(arrow *shimast.Node) *shimast.Node {
       return f.NewCallExpression(validateProgrammer_internal(props.Context, "createStandardSchema"), nil, nil, f.NewNodeList([]*shimast.Node{arrow}), shimast.NodeFlagsNone)
     }
   }
-  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,
@@ -223,7 +221,7 @@ func (validateProgrammerNamespace) Write(props ValidateProgrammer_IProps) *shima
 }
 
 func validateProgrammer_atomist(props ValidateProgrammer_DecomposeProps) func(next nativeinternal.CheckerProgrammer_AtomistProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(validateProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   return func(next nativeinternal.CheckerProgrammer_AtomistProps) *shimast.Node {
     expressions := []*shimast.Node{}
     if next.Entry.Expression != nil {
@@ -265,7 +263,7 @@ func validateProgrammer_combine(props struct {
   Context nativecontext.ITypiaContext
   Functor *nativehelpers.FunctionProgrammer
 }) nativeinternal.CheckerProgrammer_IConfig_Combiner {
-  f := nativecontext.EmitFactoryOf(validateProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   return func(next nativeinternal.CheckerProgrammer_CombinerProps) *shimast.Node {
     if next.Explore.Tracable == false {
       options := &IsProgrammer_CONFIG_IOptions{
@@ -314,7 +312,7 @@ type validateProgrammer_validateObjectProps struct {
 }
 
 func validateProgrammer_validate_object(props validateProgrammer_validateObjectProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(validateProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   return nativeiterate.Check_object(nativeiterate.Check_objectProps{
     Config: nativeiterate.Check_object_IConfig{
       Equals:    props.Config.Equals,
@@ -365,13 +363,13 @@ func validateProgrammer_validate_object(props validateProgrammer_validateObjectP
 }
 
 func validateProgrammer_joiner(props ValidateProgrammer_DecomposeProps) nativeinternal.CheckerProgrammer_IConfig_IJoiner {
-  f := nativecontext.EmitFactoryOf(validateProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   return nativeinternal.CheckerProgrammer_IConfig_IJoiner{
     Object: func(v nativeinternal.CheckerProgrammer_JoinerObjectProps) *shimast.Node {
       return validateProgrammer_validate_object(validateProgrammer_validateObjectProps{Context: props.Context, Functor: props.Functor, Config: props.Config, Entries: v.Entries, Input: v.Input})
     },
     Array: func(v nativeinternal.CheckerProgrammer_JoinerArrayProps) *shimast.Node {
-      return nativeiterate.Check_everything(f.NewCallExpression(nativefactories.IdentifierFactory.Access(props.Context.Emit, v.Input, "map"), nil, nil, f.NewNodeList([]*shimast.Node{v.Arrow}), shimast.NodeFlagsNone))
+      return nativeiterate.Check_everything(f.NewCallExpression(nativefactories.IdentifierFactory.Access(props.Context.Emit, v.Input, "map"), nil, nil, f.NewNodeList([]*shimast.Node{v.Arrow}), shimast.NodeFlagsNone), props.Context.Emit)
     },
     Failure: func(next nativeinternal.CheckerProgrammer_JoinerFailureProps) *shimast.Node {
       explore := nativeinternal.FeatureProgrammer_IExplore{}
@@ -381,13 +379,13 @@ func validateProgrammer_joiner(props ValidateProgrammer_DecomposeProps) nativein
       return validateProgrammer_create_report_call(validateProgrammer_createReportCallProps{Exceptionable: validateProgrammer_exceptionable(explore, props.Context.Emit), Path: validateProgrammer_path(explore, props.Context.Emit), Expected: next.Expected, Value: next.Input, Functor: props.Functor, Emit: props.Context.Emit})
     },
     Tuple: func(binaries []*shimast.Node) *shimast.Node {
-      return nativeiterate.Check_everything(f.NewArrayLiteralExpression(f.NewNodeList(binaries), true))
+      return nativeiterate.Check_everything(f.NewArrayLiteralExpression(f.NewNodeList(binaries), true), props.Context.Emit)
     },
   }
 }
 
 func validateProgrammer_create_output(emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(validateProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   return nativefactories.ExpressionFactory.Conditional(
     f.NewIdentifier("success"),
     f.NewObjectLiteralExpression(f.NewNodeList([]*shimast.Node{
@@ -414,7 +412,7 @@ type validateProgrammer_createReportCallProps struct {
 }
 
 func validateProgrammer_create_report_call(props validateProgrammer_createReportCallProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(validateProgrammer_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   exceptionable := props.Exceptionable
   if exceptionable == nil {
     exceptionable = f.NewIdentifier("_exceptionable")
@@ -440,7 +438,7 @@ func validateProgrammer_create_report_call(props validateProgrammer_createReport
 }
 
 func validateProgrammer_expected_expression(props validateProgrammer_createReportCallProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(validateProgrammer_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   if props.Functor == nil || len(props.Expected) < 128 {
     return f.NewStringLiteral(props.Expected, shimast.TokenFlagsNone)
   }
@@ -461,7 +459,7 @@ func validateProgrammer_reduce(expressions []*shimast.Node, operator shimast.Kin
 }
 
 func validateProgrammer_binary(left *shimast.Expression, operator shimast.Kind, right *shimast.Expression, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(validateProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   return f.NewBinaryExpression(nil, left, nil, f.NewToken(operator), right)
 }
 
@@ -474,17 +472,17 @@ func validateProgrammer_or(left *shimast.Expression, right *shimast.Expression,
 }
 
 func validateProgrammer_property(name string, value *shimast.Expression, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(validateProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   return f.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier(name, emit), nil, nil, value)
 }
 
 func validateProgrammer_shorthand(name string, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(validateProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   return f.NewShorthandPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier(name, emit), nil, nil, nil, nil)
 }
 
 func validateProgrammer_exceptionable(explore nativeinternal.FeatureProgrammer_IExplore, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(validateProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   if explore.From == "top" || explore.Source == "top" {
     return f.NewKeywordExpression(shimast.KindTrueKeyword)
   }
@@ -492,7 +490,7 @@ func validateProgrammer_exceptionable(explore nativeinternal.FeatureProgrammer_I
 }
 
 func validateProgrammer_path(explore nativeinternal.FeatureProgrammer_IExplore, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(validateProgrammer_factory, emit)
+  f := nativecontext.NodeFactoryOf(emit)
   if explore.Postfix != "" {
     return f.NewIdentifier("_path + " + explore.Postfix)
   }
@@ -500,7 +498,7 @@ func validateProgrammer_path(explore nativeinternal.FeatureProgrammer_IExplore,
 }
 
 func validateProgrammer_type_reference(context nativecontext.ITypiaContext, typ *nativechecker.Type, name *string) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(validateProgrammer_factory, context.Emit)
+  f := nativecontext.NodeFactoryOf(context.Emit)
   if name != nil {
     return f.NewTypeReferenceNode(f.NewIdentifier(*name), nil)
   }
@@ -511,7 +509,7 @@ func validateProgrammer_import_type(context nativecontext.ITypiaContext, props n
   if importer := context.Importer; importer != nil {
     return importer.Type(props)
   }
-  f := nativecontext.EmitFactoryOf(validateProgrammer_factory, context.Emit)
+  f := nativecontext.NodeFactoryOf(context.Emit)
   if str, ok := props.Name.(string); ok {
     return f.NewTypeReferenceNode(f.NewIdentifier(str), nil)
   }
@@ -522,7 +520,7 @@ func validateProgrammer_internal(context nativecontext.ITypiaContext, name strin
   if importer := context.Importer; importer != nil {
     return importer.Internal(name)
   }
-  return nativecontext.EmitFactoryOf(validateProgrammer_factory, context.Emit).NewIdentifier(name)
+  return nativecontext.NodeFactoryOf(context.Emit).NewIdentifier(name)
 }
 
 func validateProgrammer_bool_ptr(value bool) *bool {

package/native/core/programmers/compare/CompareEqualProgrammer.go

@@ -65,10 +65,8 @@ type compareEqualProgrammerGenerator struct {
   MatcherIndex map[int]bool
 }
 
-var compareEqualProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (compareEqualProgrammerNamespace) Write(props CompareEqualProgrammer_IProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(compareEqualProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   method := nativehelpers.ModuloMethodText(props.Modulo)
   collection := schemametadata.NewMetadataCollection()
   result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{