typia 13.0.1-dev.20260703.1 → 13.0.2

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

@@ -1,1361 +1,1361 @@
-package internal
-
-import (
-  "fmt"
-  "sort"
-  "strings"
-
-  shimast "github.com/microsoft/typescript-go/shim/ast"
-  shimchecker "github.com/microsoft/typescript-go/shim/checker"
-  shimprinter "github.com/microsoft/typescript-go/shim/printer"
-  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
-  nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
-  nativeiterate "github.com/samchon/typia/packages/typia/native/core/programmers/iterate"
-  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
-)
-
-type featureProgrammerNamespace struct{}
-
-var FeatureProgrammer = featureProgrammerNamespace{}
-
-type FeatureProgrammer_IConfig struct {
-  Types         FeatureProgrammer_IConfig_ITypes
-  Prefix        string
-  Path          bool
-  Trace         bool
-  Addition      func(collection *nativemetadata.MetadataCollection) []*shimast.Node
-  Initializer   func(props FeatureProgrammer_InitializerProps) FeatureProgrammer_InitializerOutput
-  Decoder       func(props FeatureProgrammer_DecoderProps) *shimast.Node
-  Objector      FeatureProgrammer_IConfig_IObjector
-  Generator     FeatureProgrammer_IConfig_IGenerator
-  ObjectParents bool
-  // Visited reports whether the analyzed type graph carries a recursive
-  // component (issue #1820). It is a closure (usually the functor's Visited
-  // method) because the answer is unknown until metadata analysis runs,
-  // which happens after the config is constructed. When true, generated
-  // functions thread a per-invocation `_vctx` visit context.
-  Visited func() bool
-  // VisitGuard wraps a recursive function's body with the feature's own
-  // cycle handling (e.g. checkers report a revisited object as valid). Nil
-  // keeps the body untouched even when Visited is on.
-  VisitGuard func(props FeatureProgrammer_VisitGuardProps) *shimast.Node
-}
-
-type FeatureProgrammer_VisitGuardProps struct {
-  // Key names the `_vctx` slot of the guarded function (e.g. "o3" for the
-  // object function of index 3), so each recursive function tracks its own
-  // visit set and union-branch probing cannot pollute sibling checks.
-  Key   string
-  Input *shimast.Expression
-  Body  *shimast.Node
-  // Object is the recursive object being guarded, so a feature's VisitGuard can
-  // choose a prototype-bearing allocator (classify: Object.create(Name.prototype)
-  // for a named class, matching ClassifyJoiner.Object). nil keeps the legacy
-  // plain-container ({}/[]) behavior used by clone, notation, and the rest.
-  Object *nativemetadata.MetadataObjectType
-}
-
-type FeatureProgrammer_IConfig_ITypes struct {
-  Input  func(t *shimchecker.Type, name *string) *shimast.TypeNode
-  Output func(t *shimchecker.Type, name *string) *shimast.TypeNode
-}
-
-type FeatureProgrammer_IConfig_IObjector struct {
-  Checker   func(props FeatureProgrammer_ObjectorCheckerProps) *shimast.Node
-  Decoder   func(props FeatureProgrammer_ObjectorDecoderProps) *shimast.Node
-  Joiner    func(props FeatureProgrammer_ObjectorJoinerProps) *shimast.Node
-  Unionizer func(props FeatureProgrammer_ObjectorUnionizerProps) *shimast.Node
-  Failure   func(props FeatureProgrammer_ObjectorFailureProps) *shimast.Node
-  Is        func(exp *shimast.Expression) *shimast.Node
-  Required  func(exp *shimast.Expression) *shimast.Node
-  Full      func(props FeatureProgrammer_ObjectorFullProps) *shimast.Node
-  Type      *shimast.TypeNode
-}
-
-type FeatureProgrammer_IConfig_IGenerator struct {
-  Objects func(collection *nativemetadata.MetadataCollection) []*shimast.Node
-  Unions  func(collection *nativemetadata.MetadataCollection) []*shimast.Node
-  Arrays  func(collection *nativemetadata.MetadataCollection) []*shimast.Node
-  Tuples  func(collection *nativemetadata.MetadataCollection) []*shimast.Node
-}
-
-type FeatureProgrammer_IExplore = nativehelpers.UnionExplorer_IExplore
-
-type FeatureProgrammer_InitializerProps struct {
-  Context nativecontext.ITypiaContext
-  Functor *nativehelpers.FunctionProgrammer
-  Type    *shimchecker.Type
-}
-
-type FeatureProgrammer_InitializerOutput struct {
-  Collection *nativemetadata.MetadataCollection
-  Metadata   *nativemetadata.MetadataSchema
-}
-
-type FeatureProgrammer_DecoderProps struct {
-  Metadata *nativemetadata.MetadataSchema
-  Input    *shimast.Expression
-  Explore  FeatureProgrammer_IExplore
-}
-
-type FeatureProgrammer_ObjectorCheckerProps struct {
-  Metadata *nativemetadata.MetadataSchema
-  Input    *shimast.Expression
-  Explore  FeatureProgrammer_IExplore
-}
-
-type FeatureProgrammer_ObjectorDecoderProps struct {
-  Input   *shimast.Expression
-  Object  *nativemetadata.MetadataObjectType
-  Explore FeatureProgrammer_IExplore
-}
-
-type FeatureProgrammer_ObjectorJoinerProps struct {
-  Entries []nativehelpers.IExpressionEntry
-  Input   *shimast.Expression
-  Object  *nativemetadata.MetadataObjectType
-}
-
-type FeatureProgrammer_ObjectorUnionizerProps struct {
-  Objects []*nativemetadata.MetadataObjectType
-  Input   *shimast.Expression
-  Explore FeatureProgrammer_IExplore
-}
-
-type FeatureProgrammer_ObjectorFailureProps struct {
-  Input    *shimast.Expression
-  Expected string
-  Explore  *FeatureProgrammer_IExplore
-}
-
-type FeatureProgrammer_ObjectorFullProps struct {
-  Condition *shimast.Expression
-  Input     *shimast.Expression
-  Expected  string
-  Explore   FeatureProgrammer_IExplore
-}
-
-type FeatureProgrammer_Decoder[T any] func(props struct {
-  Input      *shimast.Expression
-  Definition T
-  Explore    FeatureProgrammer_IExplore
-}) *shimast.Node
-
-type FeatureProgrammer_IComposed struct {
-  Body       *shimast.Node
-  Parameters []*shimast.Node
-  Functions  map[string]*shimast.Node
-  Statements []*shimast.Node
-  Response   *shimast.TypeNode
-}
-
-type FeatureProgrammer_IDecomposed struct {
-  Functions  map[string]*shimast.Node
-  Statements []*shimast.Node
-  Arrow      *shimast.Node
-}
-
-type FeatureProgrammer_ComposeProps struct {
-  Context nativecontext.ITypiaContext
-  Config  FeatureProgrammer_IConfig
-  Functor *nativehelpers.FunctionProgrammer
-  Type    *shimchecker.Type
-  Name    *string
-}
-
-type FeatureProgrammer_WriteDecomposedProps struct {
-  Modulo        *shimast.Expression
-  Functor       *nativehelpers.FunctionProgrammer
-  Result        FeatureProgrammer_IDecomposed
-  ReturnWrapper func(arrow *shimast.Node) *shimast.Node
-  Emit          *shimprinter.EmitContext
-}
-
-type FeatureProgrammer_WriteProps struct {
-  Context nativecontext.ITypiaContext
-  Config  FeatureProgrammer_IConfig
-  Functor *nativehelpers.FunctionProgrammer
-  Type    *shimchecker.Type
-  Name    *string
-}
-
-type FeatureProgrammer_WriteObjectFunctionsProps struct {
-  Config     FeatureProgrammer_IConfig
-  Context    nativecontext.ITypiaContext
-  Functor    *nativehelpers.FunctionProgrammer
-  Collection *nativemetadata.MetadataCollection
-}
-
-type FeatureProgrammer_WriteUnionFunctionsProps struct {
-  Config     FeatureProgrammer_IConfig
-  Collection *nativemetadata.MetadataCollection
-  Emit       *shimprinter.EmitContext
-}
-
-type FeatureProgrammer_DecodeArrayConfig struct {
-  Trace   bool
-  Path    bool
-  Decoder func(props FeatureProgrammer_DecoderProps) *shimast.Node
-  Prefix  string
-}
-
-type FeatureProgrammer_DecodeArrayProps struct {
-  Config   FeatureProgrammer_DecodeArrayConfig
-  Functor  *nativehelpers.FunctionProgrammer
-  Combiner func(next struct {
-    Input *shimast.Expression
-    Arrow *shimast.Node
-  }) *shimast.Node
-  Array   *nativemetadata.MetadataArray
-  Input   *shimast.Expression
-  Explore FeatureProgrammer_IExplore
-  Emit    *shimprinter.EmitContext
-}
-
-type FeatureProgrammer_DecodeObjectConfig struct {
-  Trace  bool
-  Path   bool
-  Prefix string
-  // Visited threads the per-invocation `_vctx` argument to the called object
-  // function. It must come from the calling feature's own config — not from
-  // the (possibly shared) functor — so a visit-tracking feature composed with
-  // a non-tracking one (e.g. assert + clone) cannot leak the argument into
-  // functions that do not declare it.
-  Visited bool
-}
-
-type FeatureProgrammer_DecodeObjectProps struct {
-  Config  FeatureProgrammer_DecodeObjectConfig
-  Functor *nativehelpers.FunctionProgrammer
-  Object  *nativemetadata.MetadataObjectType
-  Input   *shimast.Expression
-  Explore FeatureProgrammer_IExplore
-  Emit    *shimprinter.EmitContext
-}
-
-type FeatureProgrammer_IndexProps struct {
-  Start   *int
-  Postfix string
-  Rand    string
-}
-
-type FeatureProgrammer_ArgumentsArrayProps struct {
-  Config  FeatureProgrammer_ArgumentsArrayConfig
-  Input   *shimast.Expression
-  Explore FeatureProgrammer_IExplore
-  Emit    *shimprinter.EmitContext
-}
-
-type FeatureProgrammer_ArgumentsArrayConfig struct {
-  Path    bool
-  Trace   bool
-  Visited bool
-}
-
-type FeatureProgrammer_ParameterDeclarationsProps struct {
-  Config FeatureProgrammer_ParameterConfig
-  Type   *shimast.TypeNode
-  Input  *shimast.Node
-  Emit   *shimprinter.EmitContext
-}
-
-type FeatureProgrammer_ParameterConfig struct {
-  Path    bool
-  Trace   bool
-  Visited bool
-}
-
-// featureProgrammer_visited resolves the late-bound recursion flag; the
-// closure is nil for features that do not participate in visit tracking.
-func featureProgrammer_visited(config FeatureProgrammer_IConfig) bool {
-  return config.Visited != nil && config.Visited()
-}
-
-// VisitKey names a recursive function's `_vctx` slot after the function
-// itself (its prefixed name minus the leading underscore, e.g. "io0", "co2").
-// Composed features share one context object — clone embeds is-checks for
-// union discrimination, for instance — so the slot must carry the feature
-// prefix or two families would clash on the same key with different
-// container kinds.
-func (featureProgrammerNamespace) VisitKey(prefix string, kind string, index int) string {
-  return strings.TrimPrefix(fmt.Sprintf("%s%s%d", prefix, kind, index), "_")
-}
-
-// CollectionRecursive reports whether the analyzed type graph carries any
-// recursive component — the precondition for a runtime value to drive the
-// generated function call graph into a cycle (issue #1820).
-func (featureProgrammerNamespace) CollectionRecursive(collection *nativemetadata.MetadataCollection) bool {
-  for _, object := range collection.Objects() {
-    if object.Recursive {
-      return true
-    }
-  }
-  for _, array := range collection.Arrays() {
-    if array.Recursive {
-      return true
-    }
-  }
-  for _, tuple := range collection.Tuples() {
-    if tuple.Recursive {
-      return true
-    }
-  }
-  return false
-}
-
-// VisitGuardSkip wraps a recursive in-place walker (prune) so a revisited
-// object is simply skipped: pruning is idempotent per instance, which makes
-// 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)
-  slot := "_vctx." + key
-  has := f.NewIdentifier("(" + slot + " || (" + slot + " = new WeakSet())).has(input)")
-  add := f.NewIdentifier(slot + ".add(input)")
-  if body != nil && body.Kind == shimast.KindBlock {
-    statements := []*shimast.Node{
-      f.NewIfStatement(has, f.NewReturnStatement(nil), nil),
-      f.NewExpressionStatement(add),
-    }
-    statements = append(statements, body.Statements()...)
-    return f.NewBlock(f.NewNodeList(statements), true)
-  }
-  return nativefactories.ExpressionFactory.Conditional(
-    has,
-    f.NewIdentifier("undefined"),
-    f.NewParenthesizedExpression(
-      f.NewBinaryExpression(
-        nil,
-        add,
-        nil,
-        f.NewToken(shimast.KindCommaToken),
-        f.NewParenthesizedExpression(body),
-      ),
-    ),
-    emit,
-  )
-}
-
-// VisitGuardSerialize wraps a recursive serializer function (json.stringify,
-// protobuf.encode) with on-stack cycle detection: JSON and protobuf cannot
-// represent cycles, so a value met again while still being serialized raises
-// the feature's thrower instead of overflowing the stack. Unlike the checker
-// and rebuilder guards the entry is removed after the body finishes either
-// 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)
-  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),
-    }),
-    nil,
-    nil,
-    f.NewToken(shimast.KindEqualsGreaterThanToken),
-    f.NewParenthesizedExpression(
-      f.NewBinaryExpression(
-        nil,
-        f.NewIdentifier(slot+".delete(input)"),
-        nil,
-        f.NewToken(shimast.KindCommaToken),
-        f.NewIdentifier("_vout"),
-      ),
-    ),
-  )
-  return nativefactories.ExpressionFactory.Conditional(
-    f.NewIdentifier("("+slot+" || ("+slot+" = new WeakSet())).has(input)"),
-    thrower,
-    f.NewParenthesizedExpression(
-      f.NewBinaryExpression(
-        nil,
-        f.NewIdentifier(slot+".add(input)"),
-        nil,
-        f.NewToken(shimast.KindCommaToken),
-        f.NewCallExpression(
-          f.NewParenthesizedExpression(finisher),
-          nil,
-          nil,
-          f.NewNodeList([]*shimast.Node{bodyExpression}),
-          shimast.NodeFlagsNone,
-        ),
-      ),
-    ),
-    emit,
-  )
-}
-
-// VisitGuardRebuild wraps a recursive rebuilder function (clone, notations)
-// so a revisited source object returns the output instance allocated on its
-// first visit — reproducing runtime cycles and deduplicating DAG aliases.
-// The output container registers in the WeakMap BEFORE the body evaluates,
-// 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)
-  allocator := f.NewObjectLiteralExpression(f.NewNodeList(nil), false)
-  if array {
-    allocator = f.NewArrayLiteralExpression(f.NewNodeList(nil), false)
-  }
-  return FeatureProgrammer.VisitGuardRebuildWith(key, allocator, body, emit)
-}
-
-// VisitGuardRebuildWith is VisitGuardRebuild with a caller-supplied output
-// container. clone/notation pass a plain {} (or [] for arrays); classify passes
-// Object.create(<Class>.prototype) for a named class so the WeakMap-registered
-// instance carries the right prototype — `x instanceof Class` then holds even on
-// the recursive arm, where the joiner body's own (unregistered) instance is
-// merged onto this allocator by Object.assign and discarded. The allocator
-// 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)
-  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),
-    }),
-    nil,
-    nil,
-    f.NewToken(shimast.KindEqualsGreaterThanToken),
-    f.NewParenthesizedExpression(
-      f.NewBinaryExpression(
-        nil,
-        f.NewIdentifier(slot+".set(input, _vout)"),
-        nil,
-        f.NewToken(shimast.KindCommaToken),
-        f.NewCallExpression(
-          f.NewIdentifier("Object.assign"),
-          nil,
-          nil,
-          f.NewNodeList([]*shimast.Node{
-            f.NewIdentifier("_vout"),
-            bodyExpression,
-          }),
-          shimast.NodeFlagsNone,
-        ),
-      ),
-    ),
-  )
-  return nativefactories.ExpressionFactory.Conditional(
-    f.NewIdentifier("("+slot+" || ("+slot+" = new WeakMap())).has(input)"),
-    f.NewIdentifier(slot+".get(input)"),
-    f.NewCallExpression(
-      f.NewParenthesizedExpression(filler),
-      nil,
-      nil,
-      f.NewNodeList([]*shimast.Node{allocator}),
-      shimast.NodeFlagsNone,
-    ),
-    emit,
-  )
-}
-
-func featureProgrammer_block_to_expression(body *shimast.Node, emit *shimprinter.EmitContext) *shimast.Node {
-  if body != nil && body.Kind == shimast.KindBlock {
-    return nativefactories.ExpressionFactory.SelfCall(emit, body)
-  }
-  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,
-    Functor: props.Functor,
-    Type:    props.Type,
-  })
-  featureProgrammer_compact_object_parents(props.Config, initialized.Collection)
-  featureProgrammer_register_schema_unions(initialized.Collection, initialized.Metadata, map[*nativemetadata.MetadataSchema]bool{})
-  body := props.Config.Decoder(FeatureProgrammer_DecoderProps{
-    Input:    nativefactories.ValueFactory.INPUT(props.Context.Emit),
-    Metadata: initialized.Metadata,
-    Explore: FeatureProgrammer_IExplore{
-      Tracable: props.Config.Path || props.Config.Trace,
-      Source:   "top",
-      From:     "top",
-      Postfix:  "\"\"",
-    },
-  })
-  statements := []*shimast.Node{}
-  if props.Config.Addition != nil {
-    statements = props.Config.Addition(initialized.Collection)
-  }
-  functions := map[string]*shimast.Node{}
-  for i, v := range featureProgrammer_object_functions(props, initialized.Collection) {
-    functions[fmt.Sprintf("%so%d", props.Config.Prefix, i)] = v
-  }
-  for i, v := range featureProgrammer_union_functions(props.Config, initialized.Collection, props.Context.Emit) {
-    functions[fmt.Sprintf("%su%d", props.Config.Prefix, i)] = v
-  }
-  for i, v := range props.Config.Generator.Arrays(initialized.Collection) {
-    functions[fmt.Sprintf("%sa%d", props.Config.Prefix, i)] = v
-  }
-  for i, v := range props.Config.Generator.Tuples(initialized.Collection) {
-    functions[fmt.Sprintf("%st%d", props.Config.Prefix, i)] = v
-  }
-  return FeatureProgrammer_IComposed{
-    Body:       body,
-    Statements: statements,
-    Functions:  functions,
-    Parameters: FeatureProgrammer.ParameterDeclarations(FeatureProgrammer_ParameterDeclarationsProps{
-      Config: FeatureProgrammer_ParameterConfig{Path: props.Config.Path, Trace: props.Config.Trace, Visited: featureProgrammer_visited(props.Config)},
-      Type:   props.Config.Types.Input(props.Type, props.Name),
-      Input:  nativefactories.ValueFactory.INPUT(props.Context.Emit),
-      Emit:   props.Context.Emit,
-    }),
-    Response: props.Config.Types.Output(props.Type, props.Name),
-  }
-}
-
-func (featureProgrammerNamespace) WriteDecomposed(props FeatureProgrammer_WriteDecomposedProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, props.Emit)
-  statements := []*shimast.Node{}
-  statements = append(statements, props.Functor.Declare()...)
-  keys := make([]string, 0, len(props.Result.Functions))
-  for key := range props.Result.Functions {
-    keys = append(keys, key)
-  }
-  sort.Strings(keys)
-  for _, key := range keys {
-    if props.Functor != nil && props.Functor.HasLocal(key) == false {
-      continue
-    }
-    statements = append(statements, props.Result.Functions[key])
-  }
-  statements = append(statements, props.Result.Statements...)
-  response := props.Result.Arrow
-  if props.ReturnWrapper != nil {
-    response = props.ReturnWrapper(props.Result.Arrow)
-  }
-  statements = append(statements, f.NewReturnStatement(response))
-  return f.NewCallExpression(
-    f.NewArrowFunction(
-      nil,
-      nil,
-      f.NewNodeList(nil),
-      nil,
-      nil,
-      f.NewToken(shimast.KindEqualsGreaterThanToken),
-      f.NewBlock(f.NewNodeList(statements), true),
-    ),
-    nil,
-    nil,
-    nil,
-    shimast.NodeFlagsNone,
-  )
-}
-
-func (featureProgrammerNamespace) Write(props FeatureProgrammer_WriteProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, props.Context.Emit)
-  initialized := props.Config.Initializer(FeatureProgrammer_InitializerProps{
-    Context: props.Context,
-    Functor: props.Functor,
-    Type:    props.Type,
-  })
-  featureProgrammer_compact_object_parents(props.Config, initialized.Collection)
-  featureProgrammer_register_schema_unions(initialized.Collection, initialized.Metadata, map[*nativemetadata.MetadataSchema]bool{})
-  output := props.Config.Decoder(FeatureProgrammer_DecoderProps{
-    Metadata: initialized.Metadata,
-    Input:    nativefactories.ValueFactory.INPUT(props.Context.Emit),
-    Explore: FeatureProgrammer_IExplore{
-      Tracable: props.Config.Path || props.Config.Trace,
-      Source:   "top",
-      From:     "top",
-      Postfix:  "\"\"",
-    },
-  })
-
-  objects := featureProgrammer_object_functions(FeatureProgrammer_ComposeProps{
-    Config:  props.Config,
-    Context: props.Context,
-    Functor: props.Functor,
-    Type:    props.Type,
-    Name:    props.Name,
-  }, initialized.Collection)
-  unions := featureProgrammer_union_functions(props.Config, initialized.Collection, props.Context.Emit)
-  arrays := props.Config.Generator.Arrays(initialized.Collection)
-  tuples := props.Config.Generator.Tuples(initialized.Collection)
-
-  added := []*shimast.Node{}
-  if props.Config.Addition != nil {
-    added = props.Config.Addition(initialized.Collection)
-  }
-
-  statements := append([]*shimast.Node{}, added...)
-  statements = append(statements, props.Functor.Declare()...)
-  for _, v := range objects {
-    statements = append(statements, v)
-  }
-  for _, v := range unions {
-    statements = append(statements, v)
-  }
-  for _, v := range arrays {
-    statements = append(statements, v)
-  }
-  for _, v := range tuples {
-    statements = append(statements, v)
-  }
-  if output != nil && output.Kind == shimast.KindBlock {
-    statements = append(statements, output.Statements()...)
-  } else {
-    statements = append(statements, f.NewReturnStatement(output))
-  }
-
-  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:   props.Config.Types.Input(props.Type, props.Name),
-      Input:  nativefactories.ValueFactory.INPUT(props.Context.Emit),
-      Emit:   props.Context.Emit,
-    })),
-    props.Config.Types.Output(props.Type, props.Name),
-    nil,
-    f.NewToken(shimast.KindEqualsGreaterThanToken),
-    f.NewBlock(f.NewNodeList(statements), true),
-  )
-}
-
-func (featureProgrammerNamespace) Write_object_functions(props FeatureProgrammer_WriteObjectFunctionsProps) []*shimast.Node {
-  featureProgrammer_compact_object_parents(props.Config, props.Collection)
-  return featureProgrammer_write_object_functions(props.Config, props.Context, props.Functor, props.Collection)
-}
-
-func (featureProgrammerNamespace) Write_union_functions(props FeatureProgrammer_WriteUnionFunctionsProps) []*shimast.Node {
-  return featureProgrammer_write_union_functions(props.Config, props.Collection, props.Emit)
-}
-
-func (featureProgrammerNamespace) Decode_array(props FeatureProgrammer_DecodeArrayProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, 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))
-  }
-  parameters := []*shimast.Node{
-    nativefactories.IdentifierFactory.Parameter("elem", nativefactories.TypeFactory.Keyword("any"), nil),
-  }
-  parameters = append(parameters, tail...)
-  arrow := f.NewArrowFunction(
-    nil,
-    nil,
-    f.NewNodeList(parameters),
-    nil,
-    nil,
-    f.NewToken(shimast.KindEqualsGreaterThanToken),
-    props.Config.Decoder(FeatureProgrammer_DecoderProps{
-      Input:    nativefactories.ValueFactory.INPUT(nil, "elem"),
-      Metadata: props.Array.Type.Value,
-      Explore: FeatureProgrammer_IExplore{
-        Tracable: props.Explore.Tracable,
-        Source:   props.Explore.Source,
-        From:     "array",
-        Postfix: FeatureProgrammer.Index(FeatureProgrammer_IndexProps{
-          Start:   props.Explore.Start,
-          Postfix: props.Explore.Postfix,
-          Rand:    rand,
-        }),
-      },
-    }),
-  )
-  return props.Combiner(struct {
-    Input *shimast.Expression
-    Arrow *shimast.Node
-  }{Input: props.Input, Arrow: arrow})
-}
-
-func (featureProgrammerNamespace) Decode_object(props FeatureProgrammer_DecodeObjectProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, props.Emit)
-  return f.NewCallExpression(
-    f.NewIdentifier(
-      props.Functor.UseLocal(fmt.Sprintf("%so%d", props.Config.Prefix, props.Object.Index)),
-    ),
-    nil,
-    nil,
-    f.NewNodeList(FeatureProgrammer.ArgumentsArray(FeatureProgrammer_ArgumentsArrayProps{
-      Config:  FeatureProgrammer_ArgumentsArrayConfig{Path: props.Config.Path, Trace: props.Config.Trace, Visited: props.Config.Visited},
-      Input:   props.Input,
-      Explore: props.Explore,
-      Emit:    props.Emit,
-    })),
-    shimast.NodeFlagsNone,
-  )
-}
-
-func (featureProgrammerNamespace) Index(props FeatureProgrammer_IndexProps) string {
-  tail := "\"[\" + _index" + props.Rand + " + \"]\""
-  if props.Start != nil {
-    tail = "\"[\" + (" + fmt.Sprint(*props.Start) + " + _index" + props.Rand + ") + \"]\""
-  }
-  if props.Postfix == "" {
-    return tail
-  }
-  if props.Postfix[len(props.Postfix)-1:] == "\"" {
-    return props.Postfix[:len(props.Postfix)-1] + tail[1:]
-  }
-  return props.Postfix + " + " + tail
-}
-
-func (featureProgrammerNamespace) ArgumentsArray(props FeatureProgrammer_ArgumentsArrayProps) []*shimast.Node {
-  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, props.Emit)
-  tail := []*shimast.Node{}
-  if props.Config.Path == false && props.Config.Trace == false {
-    tail = []*shimast.Node{}
-  } else if props.Config.Path && props.Config.Trace {
-    path := "_path"
-    if props.Explore.Postfix != "" {
-      path = "_path + " + props.Explore.Postfix
-    }
-    tail = append(tail, f.NewIdentifier(path))
-    if props.Explore.Source == "function" {
-      tail = append(tail, f.NewIdentifier(fmt.Sprintf("%t && _exceptionable", props.Explore.Tracable)))
-    } else if props.Explore.Tracable {
-      tail = append(tail, f.NewKeywordExpression(shimast.KindTrueKeyword))
-    } else {
-      tail = append(tail, f.NewKeywordExpression(shimast.KindFalseKeyword))
-    }
-  } else if props.Config.Path {
-    path := "_path"
-    if props.Explore.Postfix != "" {
-      path = "_path + " + props.Explore.Postfix
-    }
-    tail = append(tail, f.NewIdentifier(path))
-  } else {
-    if props.Explore.Source == "function" {
-      tail = append(tail, f.NewIdentifier(fmt.Sprintf("%t && _exceptionable", props.Explore.Tracable)))
-    } else if props.Explore.Tracable {
-      tail = append(tail, f.NewKeywordExpression(shimast.KindTrueKeyword))
-    } else {
-      tail = append(tail, f.NewKeywordExpression(shimast.KindFalseKeyword))
-    }
-  }
-  if props.Config.Visited {
-    tail = append(tail, f.NewIdentifier("_vctx"))
-  }
-  return append([]*shimast.Node{props.Input}, tail...)
-}
-
-func (featureProgrammerNamespace) ParameterDeclarations(props FeatureProgrammer_ParameterDeclarationsProps) []*shimast.Node {
-  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, props.Emit)
-  tail := []*shimast.Node{}
-  if props.Config.Path {
-    tail = append(tail, nativefactories.IdentifierFactory.Parameter("_path", nativefactories.TypeFactory.Keyword("string"), nil))
-  }
-  if props.Config.Trace {
-    tail = append(tail, nativefactories.IdentifierFactory.Parameter(
-      "_exceptionable",
-      nativefactories.TypeFactory.Keyword("boolean"),
-      f.NewKeywordExpression(shimast.KindTrueKeyword),
-    ))
-  }
-  if props.Config.Visited {
-    // The per-invocation visit context: internal calls always pass it along,
-    // 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),
-    ))
-  }
-  return append([]*shimast.Node{
-    nativefactories.IdentifierFactory.Parameter(props.Input, props.Type, nil),
-  }, tail...)
-}
-
-func featureProgrammer_object_functions(props FeatureProgrammer_ComposeProps, collection *nativemetadata.MetadataCollection) []*shimast.Node {
-  if props.Config.Generator.Objects != nil {
-    return props.Config.Generator.Objects(collection)
-  }
-  return featureProgrammer_write_object_functions(props.Config, props.Context, props.Functor, collection)
-}
-
-func featureProgrammer_union_functions(config FeatureProgrammer_IConfig, collection *nativemetadata.MetadataCollection, emit *shimprinter.EmitContext) []*shimast.Node {
-  if config.Generator.Unions != nil {
-    if generated := config.Generator.Unions(collection); generated != nil {
-      return generated
-    }
-  }
-  return featureProgrammer_write_union_functions(config, collection, emit)
-}
-
-type featureProgrammer_schemaUnionVisit struct {
-  Schemas map[*nativemetadata.MetadataSchema]bool
-  Objects map[*nativemetadata.MetadataObjectType]bool
-}
-
-const featureProgrammer_objectParentMinProperties = 8
-
-type featureProgrammer_objectPropertySet struct {
-  Properties map[string]*nativemetadata.MetadataProperty
-  Order      []string
-  Anchor     string
-}
-
-func featureProgrammer_compact_object_parents(config FeatureProgrammer_IConfig, collection *nativemetadata.MetadataCollection) {
-  if config.ObjectParents == false || collection == nil {
-    return
-  }
-  objects := collection.Objects()
-  signatures := make([]featureProgrammer_objectPropertySet, len(objects))
-  frequencies := map[string]int{}
-  for i, object := range objects {
-    signatures[i] = featureProgrammer_object_property_set(object)
-    for _, key := range signatures[i].Order {
-      frequencies[key]++
-    }
-  }
-  buckets := map[string][]int{}
-  for i := range objects {
-    if len(signatures[i].Order) < featureProgrammer_objectParentMinProperties {
-      continue
-    }
-    anchor := featureProgrammer_object_parent_anchor(signatures[i], frequencies)
-    if anchor == "" {
-      continue
-    }
-    signatures[i].Anchor = anchor
-    buckets[anchor] = append(buckets[anchor], i)
-  }
-  for i, object := range objects {
-    if object.Check_properties_ != nil || len(object.Properties) <= featureProgrammer_objectParentMinProperties {
-      continue
-    }
-    current := signatures[i]
-    if len(current.Order) <= featureProgrammer_objectParentMinProperties {
-      continue
-    }
-    best := -1
-    bestSize := 0
-    visited := map[int]bool{}
-    for _, key := range current.Order {
-      for _, candidate := range buckets[key] {
-        if visited[candidate] || candidate == i {
-          continue
-        }
-        visited[candidate] = true
-        candidateSize := len(signatures[candidate].Order)
-        if candidateSize <= bestSize || candidateSize >= len(current.Order) {
-          continue
-        }
-        if featureProgrammer_object_parent_covers(current, signatures[candidate]) {
-          best = candidate
-          bestSize = candidateSize
-        }
-      }
-    }
-    if best == -1 {
-      continue
-    }
-    parent := objects[best]
-    object.Parent_objects_ = append(object.Parent_objects_, nativemetadata.MetadataObject_create(nativemetadata.MetadataObject{
-      Type: parent,
-      Tags: [][]nativemetadata.IMetadataTypeTag{},
-    }))
-    object.Check_properties_ = featureProgrammer_object_remaining_properties(object.Properties, signatures[best])
-  }
-}
-
-func featureProgrammer_object_property_set(object *nativemetadata.MetadataObjectType) featureProgrammer_objectPropertySet {
-  if object == nil {
-    return featureProgrammer_objectPropertySet{}
-  }
-  output := featureProgrammer_objectPropertySet{
-    Properties: map[string]*nativemetadata.MetadataProperty{},
-    Order:      []string{},
-  }
-  for _, property := range object.Properties {
-    if property == nil || property.Key == nil {
-      return featureProgrammer_objectPropertySet{}
-    }
-    key := property.Key.GetSoleLiteral()
-    if key == nil {
-      return featureProgrammer_objectPropertySet{}
-    }
-    signature := featureProgrammer_object_property_signature(property)
-    if signature == "" {
-      return featureProgrammer_objectPropertySet{}
-    }
-    output.Properties[signature] = property
-    output.Order = append(output.Order, signature)
-  }
-  return output
-}
-
-func featureProgrammer_object_property_signature(property *nativemetadata.MetadataProperty) string {
-  if property == nil || property.Key == nil || property.Value == nil {
-    return ""
-  }
-  key := property.Key.GetSoleLiteral()
-  if key == nil {
-    return ""
-  }
-  return *key + "\x00" +
-    property.Key.GetName() + "\x00" +
-    property.Value.GetName() + "\x00" +
-    fmt.Sprintf("%t\x00%t", property.Value.Optional, property.Value.Nullable)
-}
-
-func featureProgrammer_object_parent_anchor(set featureProgrammer_objectPropertySet, frequencies map[string]int) string {
-  anchor := ""
-  score := 0
-  for _, key := range set.Order {
-    next := frequencies[key]
-    if anchor == "" || next < score {
-      anchor = key
-      score = next
-    }
-  }
-  return anchor
-}
-
-func featureProgrammer_object_parent_covers(
-  current featureProgrammer_objectPropertySet,
-  candidate featureProgrammer_objectPropertySet,
-) bool {
-  if len(candidate.Order) == 0 || len(candidate.Order) >= len(current.Order) {
-    return false
-  }
-  for _, key := range candidate.Order {
-    if current.Properties[key] == nil {
-      return false
-    }
-  }
-  return true
-}
-
-func featureProgrammer_object_remaining_properties(
-  properties []*nativemetadata.MetadataProperty,
-  parent featureProgrammer_objectPropertySet,
-) []*nativemetadata.MetadataProperty {
-  output := make([]*nativemetadata.MetadataProperty, 0, len(properties)-len(parent.Order))
-  for _, property := range properties {
-    if parent.Properties[featureProgrammer_object_property_signature(property)] != nil {
-      continue
-    }
-    output = append(output, property)
-  }
-  return output
-}
-
-func featureProgrammer_register_schema_unions(collection *nativemetadata.MetadataCollection, metadata *nativemetadata.MetadataSchema, visited map[*nativemetadata.MetadataSchema]bool) {
-  if visited == nil {
-    visited = map[*nativemetadata.MetadataSchema]bool{}
-  }
-  featureProgrammer_register_schema_unions_iterate(collection, metadata, &featureProgrammer_schemaUnionVisit{
-    Schemas: visited,
-    Objects: map[*nativemetadata.MetadataObjectType]bool{},
-  })
-}
-
-func featureProgrammer_register_schema_unions_iterate(collection *nativemetadata.MetadataCollection, metadata *nativemetadata.MetadataSchema, visited *featureProgrammer_schemaUnionVisit) {
-  if collection == nil || metadata == nil || visited.Schemas[metadata] {
-    return
-  }
-  visited.Schemas[metadata] = true
-
-  if len(metadata.Objects) > 1 {
-    index := collection.GetUnionIndex(metadata)
-    metadata.Union_index = &index
-  }
-  if metadata.Escaped != nil {
-    featureProgrammer_register_schema_unions_iterate(collection, metadata.Escaped.Returns, visited)
-  }
-  if metadata.Rest != nil {
-    featureProgrammer_register_schema_unions_iterate(collection, metadata.Rest, visited)
-  }
-  for _, alias := range metadata.Aliases {
-    if alias.Type != nil {
-      featureProgrammer_register_schema_unions_iterate(collection, alias.Type.Value, visited)
-    }
-  }
-  for _, array := range metadata.Arrays {
-    if array.Type != nil {
-      featureProgrammer_register_schema_unions_iterate(collection, array.Type.Value, visited)
-    }
-  }
-  for _, tuple := range metadata.Tuples {
-    if tuple.Type != nil {
-      for _, element := range tuple.Type.Elements {
-        featureProgrammer_register_schema_unions_iterate(collection, element, visited)
-      }
-    }
-  }
-  for _, object := range metadata.Objects {
-    if object.Type != nil && visited.Objects[object.Type] == false {
-      visited.Objects[object.Type] = true
-      for _, property := range object.Type.Properties {
-        featureProgrammer_register_schema_unions_iterate(collection, property.Value, visited)
-      }
-    }
-  }
-  for _, set := range metadata.Sets {
-    featureProgrammer_register_schema_unions_iterate(collection, set.Value, visited)
-  }
-  for _, item := range metadata.Maps {
-    featureProgrammer_register_schema_unions_iterate(collection, item.Key, visited)
-    featureProgrammer_register_schema_unions_iterate(collection, item.Value, visited)
-  }
-}
-
-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)
-  objects := collection.Objects()
-  propertyFrequencies := featureProgrammer_object_property_frequencies(config, context, functor, objects)
-  output := make([]*shimast.Node, 0, len(objects))
-  for _, object := range objects {
-    input := f.NewIdentifier("input")
-    objectType := config.Objector.Type
-    if objectType == nil {
-      objectType = nativefactories.TypeFactory.Keyword("any", context.Emit)
-    }
-    entriesObject := object
-    if config.ObjectParents && len(object.Parent_objects_) != 0 {
-      entriesObject = &nativemetadata.MetadataObjectType{
-        Name:        object.Name,
-        DisplayName: object.DisplayName,
-        Properties:  object.CheckProperties(),
-        Description: object.Description,
-        JsDocTags:   object.JsDocTags,
-        Index:       object.Index,
-        Validated:   object.Validated,
-        Recursive:   object.Recursive,
-        Nullables:   object.Nullables,
-      }
-    }
-    helperAllProperties := config.ObjectParents && functor != nil && len(entriesObject.Properties) >= 16
-    body := config.Objector.Joiner(FeatureProgrammer_ObjectorJoinerProps{
-      Input: input,
-      Entries: nativeiterate.Feature_object_entries(nativeiterate.Feature_object_entriesProps{
-        Config: nativeiterate.Feature_object_entriesConfig{
-          Path:  config.Path,
-          Trace: config.Trace,
-          Decoder: func(next nativeiterate.Feature_object_entriesDecoderProps) *shimast.Node {
-            if key := featureProgrammer_object_property_helper_key(context, next.Property, next.Metadata); key != "" && (propertyFrequencies[key] > 1 || helperAllProperties) {
-              return featureProgrammer_object_property_helper_call(featureProgrammer_objectPropertyHelperProps{
-                Config:     config,
-                Context:    context,
-                Functor:    functor,
-                Input:      input,
-                ReturnType: objectType,
-                Next:       next,
-                Key:        key,
-              })
-            }
-            return config.Decoder(FeatureProgrammer_DecoderProps{
-              Input:    next.Input,
-              Metadata: next.Metadata,
-              Explore:  featureProgrammer_from_iterate_explore(next.Explore),
-            })
-          },
-        },
-        Context: context,
-        Input:   input,
-        Object:  entriesObject,
-      }),
-      Object: object,
-    })
-    if config.ObjectParents && len(object.Parent_objects_) != 0 {
-      expressions := make([]*shimast.Node, 0, len(object.Parent_objects_)+1)
-      explore := FeatureProgrammer_IExplore{
-        Tracable: config.Path || config.Trace,
-        Source:   "function",
-        From:     "object",
-        Postfix:  "",
-      }
-      for _, parent := range object.Parent_objects_ {
-        expressions = append(expressions, config.Objector.Decoder(FeatureProgrammer_ObjectorDecoderProps{
-          Input:   input,
-          Object:  parent.Type,
-          Explore: explore,
-        }))
-      }
-      expressions = append(expressions, body)
-      body = checkerProgrammer_reduce(expressions, shimast.KindAmpersandAmpersandToken, f.NewKeywordExpression(shimast.KindTrueKeyword), context.Emit)
-    }
-    if object.Recursive && config.VisitGuard != nil && featureProgrammer_visited(config) {
-      body = config.VisitGuard(FeatureProgrammer_VisitGuardProps{
-        Key:    FeatureProgrammer.VisitKey(config.Prefix, "o", object.Index),
-        Input:  input,
-        Body:   body,
-        Object: object,
-      })
-    }
-    output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-      Name: fmt.Sprintf("%so%d", config.Prefix, object.Index),
-      Value: f.NewArrowFunction(
-        nil,
-        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"),
-          Input:  nativefactories.ValueFactory.INPUT(context.Emit),
-          Emit:   context.Emit,
-        })),
-        objectType,
-        nil,
-        f.NewToken(shimast.KindEqualsGreaterThanToken),
-        body,
-      ),
-    }, context.Emit))
-  }
-  return output
-}
-
-type featureProgrammer_objectPropertyHelperProps struct {
-  Config     FeatureProgrammer_IConfig
-  Context    nativecontext.ITypiaContext
-  Functor    *nativehelpers.FunctionProgrammer
-  Input      *shimast.Expression
-  ReturnType *shimast.TypeNode
-  Next       nativeiterate.Feature_object_entriesDecoderProps
-  Key        string
-}
-
-func featureProgrammer_object_property_frequencies(
-  config FeatureProgrammer_IConfig,
-  context nativecontext.ITypiaContext,
-  functor *nativehelpers.FunctionProgrammer,
-  objects []*nativemetadata.MetadataObjectType,
-) map[string]int {
-  output := map[string]int{}
-  if config.ObjectParents == false || functor == nil {
-    return output
-  }
-  for _, object := range objects {
-    for _, property := range object.CheckProperties() {
-      if property == nil || property.Key == nil || property.Value == nil {
-        continue
-      }
-      metadata := property.Value
-      if property.Key.GetSoleLiteral() != nil && nativehelpers.OptionPredicator.StrictOptionalUndefined(context, property.Value) {
-        metadata = property.Value.ShallowClone()
-        metadata.Optional = false
-      }
-      key := featureProgrammer_object_property_helper_key(context, property, metadata)
-      if key != "" {
-        output[key]++
-      }
-    }
-  }
-  return output
-}
-
-func featureProgrammer_object_property_helper_key(
-  context nativecontext.ITypiaContext,
-  property *nativemetadata.MetadataProperty,
-  metadata *nativemetadata.MetadataSchema,
-) string {
-  if property == nil || property.Key == nil || metadata == nil {
-    return ""
-  }
-  key := property.Key.GetSoleLiteral()
-  if key == nil {
-    return ""
-  }
-  return *key + "\x00" +
-    property.Key.GetName() + "\x00" +
-    metadata.GetName() + "\x00" +
-    fmt.Sprintf("%t\x00%t\x00%t", metadata.Optional, metadata.Nullable, nativehelpers.OptionPredicator.Numeric(context.Options))
-}
-
-func featureProgrammer_object_property_helper_call(props featureProgrammer_objectPropertyHelperProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, 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)
-    body := props.Config.Decoder(FeatureProgrammer_DecoderProps{
-      Input:    propertyInput,
-      Metadata: props.Next.Metadata,
-      Explore:  featureProgrammer_from_iterate_explore(props.Next.Explore),
-    })
-    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:  input,
-        Emit:   props.Context.Emit,
-      })),
-      props.ReturnType,
-      nil,
-      f.NewToken(shimast.KindEqualsGreaterThanToken),
-      body,
-    )
-  })
-  return f.NewCallExpression(
-    helper,
-    nil,
-    nil,
-    f.NewNodeList(FeatureProgrammer.ArgumentsArray(FeatureProgrammer_ArgumentsArrayProps{
-      Config: FeatureProgrammer_ArgumentsArrayConfig{Path: props.Config.Path, Trace: props.Config.Trace, Visited: featureProgrammer_visited(props.Config)},
-      Input:  props.Input,
-      Explore: FeatureProgrammer_IExplore{
-        Tracable: props.Config.Path || props.Config.Trace,
-        Source:   "function",
-        From:     "object",
-        Postfix:  "",
-      },
-      Emit: props.Context.Emit,
-    })),
-    shimast.NodeFlagsNone,
-  )
-}
-
-func featureProgrammer_object_property_input(input *shimast.Expression, key *string, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, emit...)
-  if key == nil {
-    return f.NewIdentifier("value")
-  }
-  return f.NewElementAccessExpression(
-    input,
-    nil,
-    f.NewStringLiteral(*key, shimast.TokenFlagsNone),
-    shimast.NodeFlagsNone,
-  )
-}
-
-func featureProgrammer_write_union_functions(config FeatureProgrammer_IConfig, collection *nativemetadata.MetadataCollection, emit *shimprinter.EmitContext) []*shimast.Node {
-  unions := collection.Unions()
-  output := make([]*shimast.Node, 0, len(unions))
-  for i, union := range unions {
-    output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-      Name: fmt.Sprintf("%su%d", config.Prefix, i),
-      Value: featureProgrammer_write_union(struct {
-        Config  FeatureProgrammer_IConfig
-        Objects []*nativemetadata.MetadataObjectType
-      }{Config: config, Objects: union}, emit),
-    }))
-  }
-  return output
-}
-
-func featureProgrammer_write_union(props struct {
-  Config  FeatureProgrammer_IConfig
-  Objects []*nativemetadata.MetadataObjectType
-}, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, 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),
-      Emit:   emit,
-    })),
-    nativefactories.TypeFactory.Keyword("any"),
-    nil,
-    f.NewToken(shimast.KindEqualsGreaterThanToken),
-    nativehelpers.UnionExplorer.Object(nativehelpers.UnionExplorer_ObjectProps{
-      Config: nativehelpers.UnionExplorer_ObjectConfig{
-        Objector: featureProgrammer_union_objector(props.Config.Objector),
-      },
-      Objects: props.Objects,
-      Input:   nativefactories.ValueFactory.INPUT(nil),
-      Explore: FeatureProgrammer_IExplore{
-        Tracable: props.Config.Path || props.Config.Trace,
-        Source:   "function",
-        From:     "object",
-        Postfix:  "",
-      },
-      Emit: emit,
-    }),
-  )
-}
-
-func featureProgrammer_union_objector(objector FeatureProgrammer_IConfig_IObjector) nativehelpers.UnionExplorer_IObjector {
-  return nativehelpers.UnionExplorer_IObjector{
-    Checker: func(props nativehelpers.UnionExplorer_ObjectorCheckerProps) *shimast.Node {
-      return objector.Checker(FeatureProgrammer_ObjectorCheckerProps{
-        Metadata: props.Metadata,
-        Input:    props.Input,
-        Explore:  featureProgrammer_as_explore(props.Explore),
-      })
-    },
-    Decoder: func(props nativehelpers.UnionExplorer_ObjectorDecoderProps) *shimast.Node {
-      return objector.Decoder(FeatureProgrammer_ObjectorDecoderProps{
-        Input:   props.Input,
-        Object:  props.Object,
-        Explore: featureProgrammer_as_explore(props.Explore),
-      })
-    },
-    Unionizer: func(props nativehelpers.UnionExplorer_ObjectorUnionizerProps) *shimast.Node {
-      return objector.Unionizer(FeatureProgrammer_ObjectorUnionizerProps{
-        Objects: props.Objects,
-        Input:   props.Input,
-        Explore: featureProgrammer_as_explore(props.Explore),
-      })
-    },
-    Failure: func(props nativehelpers.UnionExplorer_ObjectorFailureProps) *shimast.Node {
-      explore := featureProgrammer_as_explore(props.Explore)
-      return objector.Failure(FeatureProgrammer_ObjectorFailureProps{
-        Input:    props.Input,
-        Expected: props.Expected,
-        Explore:  &explore,
-      })
-    },
-    Is:       objector.Is,
-    Required: objector.Required,
-    Full: func(props nativehelpers.UnionExplorer_ObjectorFullProps) *shimast.Node {
-      if objector.Full == nil {
-        return props.Condition
-      }
-      return objector.Full(FeatureProgrammer_ObjectorFullProps{
-        Condition: props.Condition,
-        Input:     props.Input,
-        Expected:  props.Expected,
-        Explore:   featureProgrammer_as_explore(props.Explore),
-      })
-    },
-    Type: objector.Type,
-  }
-}
-
-func featureProgrammer_from_iterate_explore(input nativeiterate.Feature_object_entriesExplore) FeatureProgrammer_IExplore {
-  return FeatureProgrammer_IExplore{
-    Tracable: input.Tracable,
-    Source:   input.Source,
-    From:     input.From,
-    Postfix:  input.Postfix,
-  }
-}
-
-func featureProgrammer_as_explore(input any) FeatureProgrammer_IExplore {
-  switch value := input.(type) {
-  case FeatureProgrammer_IExplore:
-    return value
-  case *FeatureProgrammer_IExplore:
-    return *value
-  case map[string]any:
-    output := FeatureProgrammer_IExplore{}
-    if v, ok := value["tracable"].(bool); ok {
-      output.Tracable = v
-    }
-    if v, ok := value["source"].(string); ok {
-      output.Source = v
-    }
-    if v, ok := value["from"].(string); ok {
-      output.From = v
-    }
-    if v, ok := value["postfix"].(string); ok {
-      output.Postfix = v
-    }
-    if v, ok := value["start"].(int); ok {
-      output.Start = &v
-    }
-    return output
-  default:
-    return FeatureProgrammer_IExplore{}
-  }
-}
+package internal
+
+import (
+  "fmt"
+  "sort"
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+  shimprinter "github.com/microsoft/typescript-go/shim/printer"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+  nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
+  nativeiterate "github.com/samchon/typia/packages/typia/native/core/programmers/iterate"
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+type featureProgrammerNamespace struct{}
+
+var FeatureProgrammer = featureProgrammerNamespace{}
+
+type FeatureProgrammer_IConfig struct {
+  Types         FeatureProgrammer_IConfig_ITypes
+  Prefix        string
+  Path          bool
+  Trace         bool
+  Addition      func(collection *nativemetadata.MetadataCollection) []*shimast.Node
+  Initializer   func(props FeatureProgrammer_InitializerProps) FeatureProgrammer_InitializerOutput
+  Decoder       func(props FeatureProgrammer_DecoderProps) *shimast.Node
+  Objector      FeatureProgrammer_IConfig_IObjector
+  Generator     FeatureProgrammer_IConfig_IGenerator
+  ObjectParents bool
+  // Visited reports whether the analyzed type graph carries a recursive
+  // component (issue #1820). It is a closure (usually the functor's Visited
+  // method) because the answer is unknown until metadata analysis runs,
+  // which happens after the config is constructed. When true, generated
+  // functions thread a per-invocation `_vctx` visit context.
+  Visited func() bool
+  // VisitGuard wraps a recursive function's body with the feature's own
+  // cycle handling (e.g. checkers report a revisited object as valid). Nil
+  // keeps the body untouched even when Visited is on.
+  VisitGuard func(props FeatureProgrammer_VisitGuardProps) *shimast.Node
+}
+
+type FeatureProgrammer_VisitGuardProps struct {
+  // Key names the `_vctx` slot of the guarded function (e.g. "o3" for the
+  // object function of index 3), so each recursive function tracks its own
+  // visit set and union-branch probing cannot pollute sibling checks.
+  Key   string
+  Input *shimast.Expression
+  Body  *shimast.Node
+  // Object is the recursive object being guarded, so a feature's VisitGuard can
+  // choose a prototype-bearing allocator (classify: Object.create(Name.prototype)
+  // for a named class, matching ClassifyJoiner.Object). nil keeps the legacy
+  // plain-container ({}/[]) behavior used by clone, notation, and the rest.
+  Object *nativemetadata.MetadataObjectType
+}
+
+type FeatureProgrammer_IConfig_ITypes struct {
+  Input  func(t *shimchecker.Type, name *string) *shimast.TypeNode
+  Output func(t *shimchecker.Type, name *string) *shimast.TypeNode
+}
+
+type FeatureProgrammer_IConfig_IObjector struct {
+  Checker   func(props FeatureProgrammer_ObjectorCheckerProps) *shimast.Node
+  Decoder   func(props FeatureProgrammer_ObjectorDecoderProps) *shimast.Node
+  Joiner    func(props FeatureProgrammer_ObjectorJoinerProps) *shimast.Node
+  Unionizer func(props FeatureProgrammer_ObjectorUnionizerProps) *shimast.Node
+  Failure   func(props FeatureProgrammer_ObjectorFailureProps) *shimast.Node
+  Is        func(exp *shimast.Expression) *shimast.Node
+  Required  func(exp *shimast.Expression) *shimast.Node
+  Full      func(props FeatureProgrammer_ObjectorFullProps) *shimast.Node
+  Type      *shimast.TypeNode
+}
+
+type FeatureProgrammer_IConfig_IGenerator struct {
+  Objects func(collection *nativemetadata.MetadataCollection) []*shimast.Node
+  Unions  func(collection *nativemetadata.MetadataCollection) []*shimast.Node
+  Arrays  func(collection *nativemetadata.MetadataCollection) []*shimast.Node
+  Tuples  func(collection *nativemetadata.MetadataCollection) []*shimast.Node
+}
+
+type FeatureProgrammer_IExplore = nativehelpers.UnionExplorer_IExplore
+
+type FeatureProgrammer_InitializerProps struct {
+  Context nativecontext.ITypiaContext
+  Functor *nativehelpers.FunctionProgrammer
+  Type    *shimchecker.Type
+}
+
+type FeatureProgrammer_InitializerOutput struct {
+  Collection *nativemetadata.MetadataCollection
+  Metadata   *nativemetadata.MetadataSchema
+}
+
+type FeatureProgrammer_DecoderProps struct {
+  Metadata *nativemetadata.MetadataSchema
+  Input    *shimast.Expression
+  Explore  FeatureProgrammer_IExplore
+}
+
+type FeatureProgrammer_ObjectorCheckerProps struct {
+  Metadata *nativemetadata.MetadataSchema
+  Input    *shimast.Expression
+  Explore  FeatureProgrammer_IExplore
+}
+
+type FeatureProgrammer_ObjectorDecoderProps struct {
+  Input   *shimast.Expression
+  Object  *nativemetadata.MetadataObjectType
+  Explore FeatureProgrammer_IExplore
+}
+
+type FeatureProgrammer_ObjectorJoinerProps struct {
+  Entries []nativehelpers.IExpressionEntry
+  Input   *shimast.Expression
+  Object  *nativemetadata.MetadataObjectType
+}
+
+type FeatureProgrammer_ObjectorUnionizerProps struct {
+  Objects []*nativemetadata.MetadataObjectType
+  Input   *shimast.Expression
+  Explore FeatureProgrammer_IExplore
+}
+
+type FeatureProgrammer_ObjectorFailureProps struct {
+  Input    *shimast.Expression
+  Expected string
+  Explore  *FeatureProgrammer_IExplore
+}
+
+type FeatureProgrammer_ObjectorFullProps struct {
+  Condition *shimast.Expression
+  Input     *shimast.Expression
+  Expected  string
+  Explore   FeatureProgrammer_IExplore
+}
+
+type FeatureProgrammer_Decoder[T any] func(props struct {
+  Input      *shimast.Expression
+  Definition T
+  Explore    FeatureProgrammer_IExplore
+}) *shimast.Node
+
+type FeatureProgrammer_IComposed struct {
+  Body       *shimast.Node
+  Parameters []*shimast.Node
+  Functions  map[string]*shimast.Node
+  Statements []*shimast.Node
+  Response   *shimast.TypeNode
+}
+
+type FeatureProgrammer_IDecomposed struct {
+  Functions  map[string]*shimast.Node
+  Statements []*shimast.Node
+  Arrow      *shimast.Node
+}
+
+type FeatureProgrammer_ComposeProps struct {
+  Context nativecontext.ITypiaContext
+  Config  FeatureProgrammer_IConfig
+  Functor *nativehelpers.FunctionProgrammer
+  Type    *shimchecker.Type
+  Name    *string
+}
+
+type FeatureProgrammer_WriteDecomposedProps struct {
+  Modulo        *shimast.Expression
+  Functor       *nativehelpers.FunctionProgrammer
+  Result        FeatureProgrammer_IDecomposed
+  ReturnWrapper func(arrow *shimast.Node) *shimast.Node
+  Emit          *shimprinter.EmitContext
+}
+
+type FeatureProgrammer_WriteProps struct {
+  Context nativecontext.ITypiaContext
+  Config  FeatureProgrammer_IConfig
+  Functor *nativehelpers.FunctionProgrammer
+  Type    *shimchecker.Type
+  Name    *string
+}
+
+type FeatureProgrammer_WriteObjectFunctionsProps struct {
+  Config     FeatureProgrammer_IConfig
+  Context    nativecontext.ITypiaContext
+  Functor    *nativehelpers.FunctionProgrammer
+  Collection *nativemetadata.MetadataCollection
+}
+
+type FeatureProgrammer_WriteUnionFunctionsProps struct {
+  Config     FeatureProgrammer_IConfig
+  Collection *nativemetadata.MetadataCollection
+  Emit       *shimprinter.EmitContext
+}
+
+type FeatureProgrammer_DecodeArrayConfig struct {
+  Trace   bool
+  Path    bool
+  Decoder func(props FeatureProgrammer_DecoderProps) *shimast.Node
+  Prefix  string
+}
+
+type FeatureProgrammer_DecodeArrayProps struct {
+  Config   FeatureProgrammer_DecodeArrayConfig
+  Functor  *nativehelpers.FunctionProgrammer
+  Combiner func(next struct {
+    Input *shimast.Expression
+    Arrow *shimast.Node
+  }) *shimast.Node
+  Array   *nativemetadata.MetadataArray
+  Input   *shimast.Expression
+  Explore FeatureProgrammer_IExplore
+  Emit    *shimprinter.EmitContext
+}
+
+type FeatureProgrammer_DecodeObjectConfig struct {
+  Trace  bool
+  Path   bool
+  Prefix string
+  // Visited threads the per-invocation `_vctx` argument to the called object
+  // function. It must come from the calling feature's own config — not from
+  // the (possibly shared) functor — so a visit-tracking feature composed with
+  // a non-tracking one (e.g. assert + clone) cannot leak the argument into
+  // functions that do not declare it.
+  Visited bool
+}
+
+type FeatureProgrammer_DecodeObjectProps struct {
+  Config  FeatureProgrammer_DecodeObjectConfig
+  Functor *nativehelpers.FunctionProgrammer
+  Object  *nativemetadata.MetadataObjectType
+  Input   *shimast.Expression
+  Explore FeatureProgrammer_IExplore
+  Emit    *shimprinter.EmitContext
+}
+
+type FeatureProgrammer_IndexProps struct {
+  Start   *int
+  Postfix string
+  Rand    string
+}
+
+type FeatureProgrammer_ArgumentsArrayProps struct {
+  Config  FeatureProgrammer_ArgumentsArrayConfig
+  Input   *shimast.Expression
+  Explore FeatureProgrammer_IExplore
+  Emit    *shimprinter.EmitContext
+}
+
+type FeatureProgrammer_ArgumentsArrayConfig struct {
+  Path    bool
+  Trace   bool
+  Visited bool
+}
+
+type FeatureProgrammer_ParameterDeclarationsProps struct {
+  Config FeatureProgrammer_ParameterConfig
+  Type   *shimast.TypeNode
+  Input  *shimast.Node
+  Emit   *shimprinter.EmitContext
+}
+
+type FeatureProgrammer_ParameterConfig struct {
+  Path    bool
+  Trace   bool
+  Visited bool
+}
+
+// featureProgrammer_visited resolves the late-bound recursion flag; the
+// closure is nil for features that do not participate in visit tracking.
+func featureProgrammer_visited(config FeatureProgrammer_IConfig) bool {
+  return config.Visited != nil && config.Visited()
+}
+
+// VisitKey names a recursive function's `_vctx` slot after the function
+// itself (its prefixed name minus the leading underscore, e.g. "io0", "co2").
+// Composed features share one context object — clone embeds is-checks for
+// union discrimination, for instance — so the slot must carry the feature
+// prefix or two families would clash on the same key with different
+// container kinds.
+func (featureProgrammerNamespace) VisitKey(prefix string, kind string, index int) string {
+  return strings.TrimPrefix(fmt.Sprintf("%s%s%d", prefix, kind, index), "_")
+}
+
+// CollectionRecursive reports whether the analyzed type graph carries any
+// recursive component — the precondition for a runtime value to drive the
+// generated function call graph into a cycle (issue #1820).
+func (featureProgrammerNamespace) CollectionRecursive(collection *nativemetadata.MetadataCollection) bool {
+  for _, object := range collection.Objects() {
+    if object.Recursive {
+      return true
+    }
+  }
+  for _, array := range collection.Arrays() {
+    if array.Recursive {
+      return true
+    }
+  }
+  for _, tuple := range collection.Tuples() {
+    if tuple.Recursive {
+      return true
+    }
+  }
+  return false
+}
+
+// VisitGuardSkip wraps a recursive in-place walker (prune) so a revisited
+// object is simply skipped: pruning is idempotent per instance, which makes
+// 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)
+  slot := "_vctx." + key
+  has := f.NewIdentifier("(" + slot + " || (" + slot + " = new WeakSet())).has(input)")
+  add := f.NewIdentifier(slot + ".add(input)")
+  if body != nil && body.Kind == shimast.KindBlock {
+    statements := []*shimast.Node{
+      f.NewIfStatement(has, f.NewReturnStatement(nil), nil),
+      f.NewExpressionStatement(add),
+    }
+    statements = append(statements, body.Statements()...)
+    return f.NewBlock(f.NewNodeList(statements), true)
+  }
+  return nativefactories.ExpressionFactory.Conditional(
+    has,
+    f.NewIdentifier("undefined"),
+    f.NewParenthesizedExpression(
+      f.NewBinaryExpression(
+        nil,
+        add,
+        nil,
+        f.NewToken(shimast.KindCommaToken),
+        f.NewParenthesizedExpression(body),
+      ),
+    ),
+    emit,
+  )
+}
+
+// VisitGuardSerialize wraps a recursive serializer function (json.stringify,
+// protobuf.encode) with on-stack cycle detection: JSON and protobuf cannot
+// represent cycles, so a value met again while still being serialized raises
+// the feature's thrower instead of overflowing the stack. Unlike the checker
+// and rebuilder guards the entry is removed after the body finishes either
+// 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)
+  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),
+    }),
+    nil,
+    nil,
+    f.NewToken(shimast.KindEqualsGreaterThanToken),
+    f.NewParenthesizedExpression(
+      f.NewBinaryExpression(
+        nil,
+        f.NewIdentifier(slot+".delete(input)"),
+        nil,
+        f.NewToken(shimast.KindCommaToken),
+        f.NewIdentifier("_vout"),
+      ),
+    ),
+  )
+  return nativefactories.ExpressionFactory.Conditional(
+    f.NewIdentifier("("+slot+" || ("+slot+" = new WeakSet())).has(input)"),
+    thrower,
+    f.NewParenthesizedExpression(
+      f.NewBinaryExpression(
+        nil,
+        f.NewIdentifier(slot+".add(input)"),
+        nil,
+        f.NewToken(shimast.KindCommaToken),
+        f.NewCallExpression(
+          f.NewParenthesizedExpression(finisher),
+          nil,
+          nil,
+          f.NewNodeList([]*shimast.Node{bodyExpression}),
+          shimast.NodeFlagsNone,
+        ),
+      ),
+    ),
+    emit,
+  )
+}
+
+// VisitGuardRebuild wraps a recursive rebuilder function (clone, notations)
+// so a revisited source object returns the output instance allocated on its
+// first visit — reproducing runtime cycles and deduplicating DAG aliases.
+// The output container registers in the WeakMap BEFORE the body evaluates,
+// 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)
+  allocator := f.NewObjectLiteralExpression(f.NewNodeList(nil), false)
+  if array {
+    allocator = f.NewArrayLiteralExpression(f.NewNodeList(nil), false)
+  }
+  return FeatureProgrammer.VisitGuardRebuildWith(key, allocator, body, emit)
+}
+
+// VisitGuardRebuildWith is VisitGuardRebuild with a caller-supplied output
+// container. clone/notation pass a plain {} (or [] for arrays); classify passes
+// Object.create(<Class>.prototype) for a named class so the WeakMap-registered
+// instance carries the right prototype — `x instanceof Class` then holds even on
+// the recursive arm, where the joiner body's own (unregistered) instance is
+// merged onto this allocator by Object.assign and discarded. The allocator
+// 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)
+  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),
+    }),
+    nil,
+    nil,
+    f.NewToken(shimast.KindEqualsGreaterThanToken),
+    f.NewParenthesizedExpression(
+      f.NewBinaryExpression(
+        nil,
+        f.NewIdentifier(slot+".set(input, _vout)"),
+        nil,
+        f.NewToken(shimast.KindCommaToken),
+        f.NewCallExpression(
+          f.NewIdentifier("Object.assign"),
+          nil,
+          nil,
+          f.NewNodeList([]*shimast.Node{
+            f.NewIdentifier("_vout"),
+            bodyExpression,
+          }),
+          shimast.NodeFlagsNone,
+        ),
+      ),
+    ),
+  )
+  return nativefactories.ExpressionFactory.Conditional(
+    f.NewIdentifier("("+slot+" || ("+slot+" = new WeakMap())).has(input)"),
+    f.NewIdentifier(slot+".get(input)"),
+    f.NewCallExpression(
+      f.NewParenthesizedExpression(filler),
+      nil,
+      nil,
+      f.NewNodeList([]*shimast.Node{allocator}),
+      shimast.NodeFlagsNone,
+    ),
+    emit,
+  )
+}
+
+func featureProgrammer_block_to_expression(body *shimast.Node, emit *shimprinter.EmitContext) *shimast.Node {
+  if body != nil && body.Kind == shimast.KindBlock {
+    return nativefactories.ExpressionFactory.SelfCall(emit, body)
+  }
+  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,
+    Functor: props.Functor,
+    Type:    props.Type,
+  })
+  featureProgrammer_compact_object_parents(props.Config, initialized.Collection)
+  featureProgrammer_register_schema_unions(initialized.Collection, initialized.Metadata, map[*nativemetadata.MetadataSchema]bool{})
+  body := props.Config.Decoder(FeatureProgrammer_DecoderProps{
+    Input:    nativefactories.ValueFactory.INPUT(props.Context.Emit),
+    Metadata: initialized.Metadata,
+    Explore: FeatureProgrammer_IExplore{
+      Tracable: props.Config.Path || props.Config.Trace,
+      Source:   "top",
+      From:     "top",
+      Postfix:  "\"\"",
+    },
+  })
+  statements := []*shimast.Node{}
+  if props.Config.Addition != nil {
+    statements = props.Config.Addition(initialized.Collection)
+  }
+  functions := map[string]*shimast.Node{}
+  for i, v := range featureProgrammer_object_functions(props, initialized.Collection) {
+    functions[fmt.Sprintf("%so%d", props.Config.Prefix, i)] = v
+  }
+  for i, v := range featureProgrammer_union_functions(props.Config, initialized.Collection, props.Context.Emit) {
+    functions[fmt.Sprintf("%su%d", props.Config.Prefix, i)] = v
+  }
+  for i, v := range props.Config.Generator.Arrays(initialized.Collection) {
+    functions[fmt.Sprintf("%sa%d", props.Config.Prefix, i)] = v
+  }
+  for i, v := range props.Config.Generator.Tuples(initialized.Collection) {
+    functions[fmt.Sprintf("%st%d", props.Config.Prefix, i)] = v
+  }
+  return FeatureProgrammer_IComposed{
+    Body:       body,
+    Statements: statements,
+    Functions:  functions,
+    Parameters: FeatureProgrammer.ParameterDeclarations(FeatureProgrammer_ParameterDeclarationsProps{
+      Config: FeatureProgrammer_ParameterConfig{Path: props.Config.Path, Trace: props.Config.Trace, Visited: featureProgrammer_visited(props.Config)},
+      Type:   props.Config.Types.Input(props.Type, props.Name),
+      Input:  nativefactories.ValueFactory.INPUT(props.Context.Emit),
+      Emit:   props.Context.Emit,
+    }),
+    Response: props.Config.Types.Output(props.Type, props.Name),
+  }
+}
+
+func (featureProgrammerNamespace) WriteDecomposed(props FeatureProgrammer_WriteDecomposedProps) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, props.Emit)
+  statements := []*shimast.Node{}
+  statements = append(statements, props.Functor.Declare()...)
+  keys := make([]string, 0, len(props.Result.Functions))
+  for key := range props.Result.Functions {
+    keys = append(keys, key)
+  }
+  sort.Strings(keys)
+  for _, key := range keys {
+    if props.Functor != nil && props.Functor.HasLocal(key) == false {
+      continue
+    }
+    statements = append(statements, props.Result.Functions[key])
+  }
+  statements = append(statements, props.Result.Statements...)
+  response := props.Result.Arrow
+  if props.ReturnWrapper != nil {
+    response = props.ReturnWrapper(props.Result.Arrow)
+  }
+  statements = append(statements, f.NewReturnStatement(response))
+  return f.NewCallExpression(
+    f.NewArrowFunction(
+      nil,
+      nil,
+      f.NewNodeList(nil),
+      nil,
+      nil,
+      f.NewToken(shimast.KindEqualsGreaterThanToken),
+      f.NewBlock(f.NewNodeList(statements), true),
+    ),
+    nil,
+    nil,
+    nil,
+    shimast.NodeFlagsNone,
+  )
+}
+
+func (featureProgrammerNamespace) Write(props FeatureProgrammer_WriteProps) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, props.Context.Emit)
+  initialized := props.Config.Initializer(FeatureProgrammer_InitializerProps{
+    Context: props.Context,
+    Functor: props.Functor,
+    Type:    props.Type,
+  })
+  featureProgrammer_compact_object_parents(props.Config, initialized.Collection)
+  featureProgrammer_register_schema_unions(initialized.Collection, initialized.Metadata, map[*nativemetadata.MetadataSchema]bool{})
+  output := props.Config.Decoder(FeatureProgrammer_DecoderProps{
+    Metadata: initialized.Metadata,
+    Input:    nativefactories.ValueFactory.INPUT(props.Context.Emit),
+    Explore: FeatureProgrammer_IExplore{
+      Tracable: props.Config.Path || props.Config.Trace,
+      Source:   "top",
+      From:     "top",
+      Postfix:  "\"\"",
+    },
+  })
+
+  objects := featureProgrammer_object_functions(FeatureProgrammer_ComposeProps{
+    Config:  props.Config,
+    Context: props.Context,
+    Functor: props.Functor,
+    Type:    props.Type,
+    Name:    props.Name,
+  }, initialized.Collection)
+  unions := featureProgrammer_union_functions(props.Config, initialized.Collection, props.Context.Emit)
+  arrays := props.Config.Generator.Arrays(initialized.Collection)
+  tuples := props.Config.Generator.Tuples(initialized.Collection)
+
+  added := []*shimast.Node{}
+  if props.Config.Addition != nil {
+    added = props.Config.Addition(initialized.Collection)
+  }
+
+  statements := append([]*shimast.Node{}, added...)
+  statements = append(statements, props.Functor.Declare()...)
+  for _, v := range objects {
+    statements = append(statements, v)
+  }
+  for _, v := range unions {
+    statements = append(statements, v)
+  }
+  for _, v := range arrays {
+    statements = append(statements, v)
+  }
+  for _, v := range tuples {
+    statements = append(statements, v)
+  }
+  if output != nil && output.Kind == shimast.KindBlock {
+    statements = append(statements, output.Statements()...)
+  } else {
+    statements = append(statements, f.NewReturnStatement(output))
+  }
+
+  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:   props.Config.Types.Input(props.Type, props.Name),
+      Input:  nativefactories.ValueFactory.INPUT(props.Context.Emit),
+      Emit:   props.Context.Emit,
+    })),
+    props.Config.Types.Output(props.Type, props.Name),
+    nil,
+    f.NewToken(shimast.KindEqualsGreaterThanToken),
+    f.NewBlock(f.NewNodeList(statements), true),
+  )
+}
+
+func (featureProgrammerNamespace) Write_object_functions(props FeatureProgrammer_WriteObjectFunctionsProps) []*shimast.Node {
+  featureProgrammer_compact_object_parents(props.Config, props.Collection)
+  return featureProgrammer_write_object_functions(props.Config, props.Context, props.Functor, props.Collection)
+}
+
+func (featureProgrammerNamespace) Write_union_functions(props FeatureProgrammer_WriteUnionFunctionsProps) []*shimast.Node {
+  return featureProgrammer_write_union_functions(props.Config, props.Collection, props.Emit)
+}
+
+func (featureProgrammerNamespace) Decode_array(props FeatureProgrammer_DecodeArrayProps) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, 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))
+  }
+  parameters := []*shimast.Node{
+    nativefactories.IdentifierFactory.Parameter("elem", nativefactories.TypeFactory.Keyword("any"), nil),
+  }
+  parameters = append(parameters, tail...)
+  arrow := f.NewArrowFunction(
+    nil,
+    nil,
+    f.NewNodeList(parameters),
+    nil,
+    nil,
+    f.NewToken(shimast.KindEqualsGreaterThanToken),
+    props.Config.Decoder(FeatureProgrammer_DecoderProps{
+      Input:    nativefactories.ValueFactory.INPUT(nil, "elem"),
+      Metadata: props.Array.Type.Value,
+      Explore: FeatureProgrammer_IExplore{
+        Tracable: props.Explore.Tracable,
+        Source:   props.Explore.Source,
+        From:     "array",
+        Postfix: FeatureProgrammer.Index(FeatureProgrammer_IndexProps{
+          Start:   props.Explore.Start,
+          Postfix: props.Explore.Postfix,
+          Rand:    rand,
+        }),
+      },
+    }),
+  )
+  return props.Combiner(struct {
+    Input *shimast.Expression
+    Arrow *shimast.Node
+  }{Input: props.Input, Arrow: arrow})
+}
+
+func (featureProgrammerNamespace) Decode_object(props FeatureProgrammer_DecodeObjectProps) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, props.Emit)
+  return f.NewCallExpression(
+    f.NewIdentifier(
+      props.Functor.UseLocal(fmt.Sprintf("%so%d", props.Config.Prefix, props.Object.Index)),
+    ),
+    nil,
+    nil,
+    f.NewNodeList(FeatureProgrammer.ArgumentsArray(FeatureProgrammer_ArgumentsArrayProps{
+      Config:  FeatureProgrammer_ArgumentsArrayConfig{Path: props.Config.Path, Trace: props.Config.Trace, Visited: props.Config.Visited},
+      Input:   props.Input,
+      Explore: props.Explore,
+      Emit:    props.Emit,
+    })),
+    shimast.NodeFlagsNone,
+  )
+}
+
+func (featureProgrammerNamespace) Index(props FeatureProgrammer_IndexProps) string {
+  tail := "\"[\" + _index" + props.Rand + " + \"]\""
+  if props.Start != nil {
+    tail = "\"[\" + (" + fmt.Sprint(*props.Start) + " + _index" + props.Rand + ") + \"]\""
+  }
+  if props.Postfix == "" {
+    return tail
+  }
+  if props.Postfix[len(props.Postfix)-1:] == "\"" {
+    return props.Postfix[:len(props.Postfix)-1] + tail[1:]
+  }
+  return props.Postfix + " + " + tail
+}
+
+func (featureProgrammerNamespace) ArgumentsArray(props FeatureProgrammer_ArgumentsArrayProps) []*shimast.Node {
+  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, props.Emit)
+  tail := []*shimast.Node{}
+  if props.Config.Path == false && props.Config.Trace == false {
+    tail = []*shimast.Node{}
+  } else if props.Config.Path && props.Config.Trace {
+    path := "_path"
+    if props.Explore.Postfix != "" {
+      path = "_path + " + props.Explore.Postfix
+    }
+    tail = append(tail, f.NewIdentifier(path))
+    if props.Explore.Source == "function" {
+      tail = append(tail, f.NewIdentifier(fmt.Sprintf("%t && _exceptionable", props.Explore.Tracable)))
+    } else if props.Explore.Tracable {
+      tail = append(tail, f.NewKeywordExpression(shimast.KindTrueKeyword))
+    } else {
+      tail = append(tail, f.NewKeywordExpression(shimast.KindFalseKeyword))
+    }
+  } else if props.Config.Path {
+    path := "_path"
+    if props.Explore.Postfix != "" {
+      path = "_path + " + props.Explore.Postfix
+    }
+    tail = append(tail, f.NewIdentifier(path))
+  } else {
+    if props.Explore.Source == "function" {
+      tail = append(tail, f.NewIdentifier(fmt.Sprintf("%t && _exceptionable", props.Explore.Tracable)))
+    } else if props.Explore.Tracable {
+      tail = append(tail, f.NewKeywordExpression(shimast.KindTrueKeyword))
+    } else {
+      tail = append(tail, f.NewKeywordExpression(shimast.KindFalseKeyword))
+    }
+  }
+  if props.Config.Visited {
+    tail = append(tail, f.NewIdentifier("_vctx"))
+  }
+  return append([]*shimast.Node{props.Input}, tail...)
+}
+
+func (featureProgrammerNamespace) ParameterDeclarations(props FeatureProgrammer_ParameterDeclarationsProps) []*shimast.Node {
+  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, props.Emit)
+  tail := []*shimast.Node{}
+  if props.Config.Path {
+    tail = append(tail, nativefactories.IdentifierFactory.Parameter("_path", nativefactories.TypeFactory.Keyword("string"), nil))
+  }
+  if props.Config.Trace {
+    tail = append(tail, nativefactories.IdentifierFactory.Parameter(
+      "_exceptionable",
+      nativefactories.TypeFactory.Keyword("boolean"),
+      f.NewKeywordExpression(shimast.KindTrueKeyword),
+    ))
+  }
+  if props.Config.Visited {
+    // The per-invocation visit context: internal calls always pass it along,
+    // 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),
+    ))
+  }
+  return append([]*shimast.Node{
+    nativefactories.IdentifierFactory.Parameter(props.Input, props.Type, nil),
+  }, tail...)
+}
+
+func featureProgrammer_object_functions(props FeatureProgrammer_ComposeProps, collection *nativemetadata.MetadataCollection) []*shimast.Node {
+  if props.Config.Generator.Objects != nil {
+    return props.Config.Generator.Objects(collection)
+  }
+  return featureProgrammer_write_object_functions(props.Config, props.Context, props.Functor, collection)
+}
+
+func featureProgrammer_union_functions(config FeatureProgrammer_IConfig, collection *nativemetadata.MetadataCollection, emit *shimprinter.EmitContext) []*shimast.Node {
+  if config.Generator.Unions != nil {
+    if generated := config.Generator.Unions(collection); generated != nil {
+      return generated
+    }
+  }
+  return featureProgrammer_write_union_functions(config, collection, emit)
+}
+
+type featureProgrammer_schemaUnionVisit struct {
+  Schemas map[*nativemetadata.MetadataSchema]bool
+  Objects map[*nativemetadata.MetadataObjectType]bool
+}
+
+const featureProgrammer_objectParentMinProperties = 8
+
+type featureProgrammer_objectPropertySet struct {
+  Properties map[string]*nativemetadata.MetadataProperty
+  Order      []string
+  Anchor     string
+}
+
+func featureProgrammer_compact_object_parents(config FeatureProgrammer_IConfig, collection *nativemetadata.MetadataCollection) {
+  if config.ObjectParents == false || collection == nil {
+    return
+  }
+  objects := collection.Objects()
+  signatures := make([]featureProgrammer_objectPropertySet, len(objects))
+  frequencies := map[string]int{}
+  for i, object := range objects {
+    signatures[i] = featureProgrammer_object_property_set(object)
+    for _, key := range signatures[i].Order {
+      frequencies[key]++
+    }
+  }
+  buckets := map[string][]int{}
+  for i := range objects {
+    if len(signatures[i].Order) < featureProgrammer_objectParentMinProperties {
+      continue
+    }
+    anchor := featureProgrammer_object_parent_anchor(signatures[i], frequencies)
+    if anchor == "" {
+      continue
+    }
+    signatures[i].Anchor = anchor
+    buckets[anchor] = append(buckets[anchor], i)
+  }
+  for i, object := range objects {
+    if object.Check_properties_ != nil || len(object.Properties) <= featureProgrammer_objectParentMinProperties {
+      continue
+    }
+    current := signatures[i]
+    if len(current.Order) <= featureProgrammer_objectParentMinProperties {
+      continue
+    }
+    best := -1
+    bestSize := 0
+    visited := map[int]bool{}
+    for _, key := range current.Order {
+      for _, candidate := range buckets[key] {
+        if visited[candidate] || candidate == i {
+          continue
+        }
+        visited[candidate] = true
+        candidateSize := len(signatures[candidate].Order)
+        if candidateSize <= bestSize || candidateSize >= len(current.Order) {
+          continue
+        }
+        if featureProgrammer_object_parent_covers(current, signatures[candidate]) {
+          best = candidate
+          bestSize = candidateSize
+        }
+      }
+    }
+    if best == -1 {
+      continue
+    }
+    parent := objects[best]
+    object.Parent_objects_ = append(object.Parent_objects_, nativemetadata.MetadataObject_create(nativemetadata.MetadataObject{
+      Type: parent,
+      Tags: [][]nativemetadata.IMetadataTypeTag{},
+    }))
+    object.Check_properties_ = featureProgrammer_object_remaining_properties(object.Properties, signatures[best])
+  }
+}
+
+func featureProgrammer_object_property_set(object *nativemetadata.MetadataObjectType) featureProgrammer_objectPropertySet {
+  if object == nil {
+    return featureProgrammer_objectPropertySet{}
+  }
+  output := featureProgrammer_objectPropertySet{
+    Properties: map[string]*nativemetadata.MetadataProperty{},
+    Order:      []string{},
+  }
+  for _, property := range object.Properties {
+    if property == nil || property.Key == nil {
+      return featureProgrammer_objectPropertySet{}
+    }
+    key := property.Key.GetSoleLiteral()
+    if key == nil {
+      return featureProgrammer_objectPropertySet{}
+    }
+    signature := featureProgrammer_object_property_signature(property)
+    if signature == "" {
+      return featureProgrammer_objectPropertySet{}
+    }
+    output.Properties[signature] = property
+    output.Order = append(output.Order, signature)
+  }
+  return output
+}
+
+func featureProgrammer_object_property_signature(property *nativemetadata.MetadataProperty) string {
+  if property == nil || property.Key == nil || property.Value == nil {
+    return ""
+  }
+  key := property.Key.GetSoleLiteral()
+  if key == nil {
+    return ""
+  }
+  return *key + "\x00" +
+    property.Key.GetName() + "\x00" +
+    property.Value.GetName() + "\x00" +
+    fmt.Sprintf("%t\x00%t", property.Value.Optional, property.Value.Nullable)
+}
+
+func featureProgrammer_object_parent_anchor(set featureProgrammer_objectPropertySet, frequencies map[string]int) string {
+  anchor := ""
+  score := 0
+  for _, key := range set.Order {
+    next := frequencies[key]
+    if anchor == "" || next < score {
+      anchor = key
+      score = next
+    }
+  }
+  return anchor
+}
+
+func featureProgrammer_object_parent_covers(
+  current featureProgrammer_objectPropertySet,
+  candidate featureProgrammer_objectPropertySet,
+) bool {
+  if len(candidate.Order) == 0 || len(candidate.Order) >= len(current.Order) {
+    return false
+  }
+  for _, key := range candidate.Order {
+    if current.Properties[key] == nil {
+      return false
+    }
+  }
+  return true
+}
+
+func featureProgrammer_object_remaining_properties(
+  properties []*nativemetadata.MetadataProperty,
+  parent featureProgrammer_objectPropertySet,
+) []*nativemetadata.MetadataProperty {
+  output := make([]*nativemetadata.MetadataProperty, 0, len(properties)-len(parent.Order))
+  for _, property := range properties {
+    if parent.Properties[featureProgrammer_object_property_signature(property)] != nil {
+      continue
+    }
+    output = append(output, property)
+  }
+  return output
+}
+
+func featureProgrammer_register_schema_unions(collection *nativemetadata.MetadataCollection, metadata *nativemetadata.MetadataSchema, visited map[*nativemetadata.MetadataSchema]bool) {
+  if visited == nil {
+    visited = map[*nativemetadata.MetadataSchema]bool{}
+  }
+  featureProgrammer_register_schema_unions_iterate(collection, metadata, &featureProgrammer_schemaUnionVisit{
+    Schemas: visited,
+    Objects: map[*nativemetadata.MetadataObjectType]bool{},
+  })
+}
+
+func featureProgrammer_register_schema_unions_iterate(collection *nativemetadata.MetadataCollection, metadata *nativemetadata.MetadataSchema, visited *featureProgrammer_schemaUnionVisit) {
+  if collection == nil || metadata == nil || visited.Schemas[metadata] {
+    return
+  }
+  visited.Schemas[metadata] = true
+
+  if len(metadata.Objects) > 1 {
+    index := collection.GetUnionIndex(metadata)
+    metadata.Union_index = &index
+  }
+  if metadata.Escaped != nil {
+    featureProgrammer_register_schema_unions_iterate(collection, metadata.Escaped.Returns, visited)
+  }
+  if metadata.Rest != nil {
+    featureProgrammer_register_schema_unions_iterate(collection, metadata.Rest, visited)
+  }
+  for _, alias := range metadata.Aliases {
+    if alias.Type != nil {
+      featureProgrammer_register_schema_unions_iterate(collection, alias.Type.Value, visited)
+    }
+  }
+  for _, array := range metadata.Arrays {
+    if array.Type != nil {
+      featureProgrammer_register_schema_unions_iterate(collection, array.Type.Value, visited)
+    }
+  }
+  for _, tuple := range metadata.Tuples {
+    if tuple.Type != nil {
+      for _, element := range tuple.Type.Elements {
+        featureProgrammer_register_schema_unions_iterate(collection, element, visited)
+      }
+    }
+  }
+  for _, object := range metadata.Objects {
+    if object.Type != nil && visited.Objects[object.Type] == false {
+      visited.Objects[object.Type] = true
+      for _, property := range object.Type.Properties {
+        featureProgrammer_register_schema_unions_iterate(collection, property.Value, visited)
+      }
+    }
+  }
+  for _, set := range metadata.Sets {
+    featureProgrammer_register_schema_unions_iterate(collection, set.Value, visited)
+  }
+  for _, item := range metadata.Maps {
+    featureProgrammer_register_schema_unions_iterate(collection, item.Key, visited)
+    featureProgrammer_register_schema_unions_iterate(collection, item.Value, visited)
+  }
+}
+
+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)
+  objects := collection.Objects()
+  propertyFrequencies := featureProgrammer_object_property_frequencies(config, context, functor, objects)
+  output := make([]*shimast.Node, 0, len(objects))
+  for _, object := range objects {
+    input := f.NewIdentifier("input")
+    objectType := config.Objector.Type
+    if objectType == nil {
+      objectType = nativefactories.TypeFactory.Keyword("any", context.Emit)
+    }
+    entriesObject := object
+    if config.ObjectParents && len(object.Parent_objects_) != 0 {
+      entriesObject = &nativemetadata.MetadataObjectType{
+        Name:        object.Name,
+        DisplayName: object.DisplayName,
+        Properties:  object.CheckProperties(),
+        Description: object.Description,
+        JsDocTags:   object.JsDocTags,
+        Index:       object.Index,
+        Validated:   object.Validated,
+        Recursive:   object.Recursive,
+        Nullables:   object.Nullables,
+      }
+    }
+    helperAllProperties := config.ObjectParents && functor != nil && len(entriesObject.Properties) >= 16
+    body := config.Objector.Joiner(FeatureProgrammer_ObjectorJoinerProps{
+      Input: input,
+      Entries: nativeiterate.Feature_object_entries(nativeiterate.Feature_object_entriesProps{
+        Config: nativeiterate.Feature_object_entriesConfig{
+          Path:  config.Path,
+          Trace: config.Trace,
+          Decoder: func(next nativeiterate.Feature_object_entriesDecoderProps) *shimast.Node {
+            if key := featureProgrammer_object_property_helper_key(context, next.Property, next.Metadata); key != "" && (propertyFrequencies[key] > 1 || helperAllProperties) {
+              return featureProgrammer_object_property_helper_call(featureProgrammer_objectPropertyHelperProps{
+                Config:     config,
+                Context:    context,
+                Functor:    functor,
+                Input:      input,
+                ReturnType: objectType,
+                Next:       next,
+                Key:        key,
+              })
+            }
+            return config.Decoder(FeatureProgrammer_DecoderProps{
+              Input:    next.Input,
+              Metadata: next.Metadata,
+              Explore:  featureProgrammer_from_iterate_explore(next.Explore),
+            })
+          },
+        },
+        Context: context,
+        Input:   input,
+        Object:  entriesObject,
+      }),
+      Object: object,
+    })
+    if config.ObjectParents && len(object.Parent_objects_) != 0 {
+      expressions := make([]*shimast.Node, 0, len(object.Parent_objects_)+1)
+      explore := FeatureProgrammer_IExplore{
+        Tracable: config.Path || config.Trace,
+        Source:   "function",
+        From:     "object",
+        Postfix:  "",
+      }
+      for _, parent := range object.Parent_objects_ {
+        expressions = append(expressions, config.Objector.Decoder(FeatureProgrammer_ObjectorDecoderProps{
+          Input:   input,
+          Object:  parent.Type,
+          Explore: explore,
+        }))
+      }
+      expressions = append(expressions, body)
+      body = checkerProgrammer_reduce(expressions, shimast.KindAmpersandAmpersandToken, f.NewKeywordExpression(shimast.KindTrueKeyword), context.Emit)
+    }
+    if object.Recursive && config.VisitGuard != nil && featureProgrammer_visited(config) {
+      body = config.VisitGuard(FeatureProgrammer_VisitGuardProps{
+        Key:    FeatureProgrammer.VisitKey(config.Prefix, "o", object.Index),
+        Input:  input,
+        Body:   body,
+        Object: object,
+      })
+    }
+    output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+      Name: fmt.Sprintf("%so%d", config.Prefix, object.Index),
+      Value: f.NewArrowFunction(
+        nil,
+        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"),
+          Input:  nativefactories.ValueFactory.INPUT(context.Emit),
+          Emit:   context.Emit,
+        })),
+        objectType,
+        nil,
+        f.NewToken(shimast.KindEqualsGreaterThanToken),
+        body,
+      ),
+    }, context.Emit))
+  }
+  return output
+}
+
+type featureProgrammer_objectPropertyHelperProps struct {
+  Config     FeatureProgrammer_IConfig
+  Context    nativecontext.ITypiaContext
+  Functor    *nativehelpers.FunctionProgrammer
+  Input      *shimast.Expression
+  ReturnType *shimast.TypeNode
+  Next       nativeiterate.Feature_object_entriesDecoderProps
+  Key        string
+}
+
+func featureProgrammer_object_property_frequencies(
+  config FeatureProgrammer_IConfig,
+  context nativecontext.ITypiaContext,
+  functor *nativehelpers.FunctionProgrammer,
+  objects []*nativemetadata.MetadataObjectType,
+) map[string]int {
+  output := map[string]int{}
+  if config.ObjectParents == false || functor == nil {
+    return output
+  }
+  for _, object := range objects {
+    for _, property := range object.CheckProperties() {
+      if property == nil || property.Key == nil || property.Value == nil {
+        continue
+      }
+      metadata := property.Value
+      if property.Key.GetSoleLiteral() != nil && nativehelpers.OptionPredicator.StrictOptionalUndefined(context, property.Value) {
+        metadata = property.Value.ShallowClone()
+        metadata.Optional = false
+      }
+      key := featureProgrammer_object_property_helper_key(context, property, metadata)
+      if key != "" {
+        output[key]++
+      }
+    }
+  }
+  return output
+}
+
+func featureProgrammer_object_property_helper_key(
+  context nativecontext.ITypiaContext,
+  property *nativemetadata.MetadataProperty,
+  metadata *nativemetadata.MetadataSchema,
+) string {
+  if property == nil || property.Key == nil || metadata == nil {
+    return ""
+  }
+  key := property.Key.GetSoleLiteral()
+  if key == nil {
+    return ""
+  }
+  return *key + "\x00" +
+    property.Key.GetName() + "\x00" +
+    metadata.GetName() + "\x00" +
+    fmt.Sprintf("%t\x00%t\x00%t", metadata.Optional, metadata.Nullable, nativehelpers.OptionPredicator.Numeric(context.Options))
+}
+
+func featureProgrammer_object_property_helper_call(props featureProgrammer_objectPropertyHelperProps) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, 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)
+    body := props.Config.Decoder(FeatureProgrammer_DecoderProps{
+      Input:    propertyInput,
+      Metadata: props.Next.Metadata,
+      Explore:  featureProgrammer_from_iterate_explore(props.Next.Explore),
+    })
+    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:  input,
+        Emit:   props.Context.Emit,
+      })),
+      props.ReturnType,
+      nil,
+      f.NewToken(shimast.KindEqualsGreaterThanToken),
+      body,
+    )
+  })
+  return f.NewCallExpression(
+    helper,
+    nil,
+    nil,
+    f.NewNodeList(FeatureProgrammer.ArgumentsArray(FeatureProgrammer_ArgumentsArrayProps{
+      Config: FeatureProgrammer_ArgumentsArrayConfig{Path: props.Config.Path, Trace: props.Config.Trace, Visited: featureProgrammer_visited(props.Config)},
+      Input:  props.Input,
+      Explore: FeatureProgrammer_IExplore{
+        Tracable: props.Config.Path || props.Config.Trace,
+        Source:   "function",
+        From:     "object",
+        Postfix:  "",
+      },
+      Emit: props.Context.Emit,
+    })),
+    shimast.NodeFlagsNone,
+  )
+}
+
+func featureProgrammer_object_property_input(input *shimast.Expression, key *string, emit ...*shimprinter.EmitContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, emit...)
+  if key == nil {
+    return f.NewIdentifier("value")
+  }
+  return f.NewElementAccessExpression(
+    input,
+    nil,
+    f.NewStringLiteral(*key, shimast.TokenFlagsNone),
+    shimast.NodeFlagsNone,
+  )
+}
+
+func featureProgrammer_write_union_functions(config FeatureProgrammer_IConfig, collection *nativemetadata.MetadataCollection, emit *shimprinter.EmitContext) []*shimast.Node {
+  unions := collection.Unions()
+  output := make([]*shimast.Node, 0, len(unions))
+  for i, union := range unions {
+    output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+      Name: fmt.Sprintf("%su%d", config.Prefix, i),
+      Value: featureProgrammer_write_union(struct {
+        Config  FeatureProgrammer_IConfig
+        Objects []*nativemetadata.MetadataObjectType
+      }{Config: config, Objects: union}, emit),
+    }))
+  }
+  return output
+}
+
+func featureProgrammer_write_union(props struct {
+  Config  FeatureProgrammer_IConfig
+  Objects []*nativemetadata.MetadataObjectType
+}, emit *shimprinter.EmitContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(featureProgrammer_factory, 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),
+      Emit:   emit,
+    })),
+    nativefactories.TypeFactory.Keyword("any"),
+    nil,
+    f.NewToken(shimast.KindEqualsGreaterThanToken),
+    nativehelpers.UnionExplorer.Object(nativehelpers.UnionExplorer_ObjectProps{
+      Config: nativehelpers.UnionExplorer_ObjectConfig{
+        Objector: featureProgrammer_union_objector(props.Config.Objector),
+      },
+      Objects: props.Objects,
+      Input:   nativefactories.ValueFactory.INPUT(nil),
+      Explore: FeatureProgrammer_IExplore{
+        Tracable: props.Config.Path || props.Config.Trace,
+        Source:   "function",
+        From:     "object",
+        Postfix:  "",
+      },
+      Emit: emit,
+    }),
+  )
+}
+
+func featureProgrammer_union_objector(objector FeatureProgrammer_IConfig_IObjector) nativehelpers.UnionExplorer_IObjector {
+  return nativehelpers.UnionExplorer_IObjector{
+    Checker: func(props nativehelpers.UnionExplorer_ObjectorCheckerProps) *shimast.Node {
+      return objector.Checker(FeatureProgrammer_ObjectorCheckerProps{
+        Metadata: props.Metadata,
+        Input:    props.Input,
+        Explore:  featureProgrammer_as_explore(props.Explore),
+      })
+    },
+    Decoder: func(props nativehelpers.UnionExplorer_ObjectorDecoderProps) *shimast.Node {
+      return objector.Decoder(FeatureProgrammer_ObjectorDecoderProps{
+        Input:   props.Input,
+        Object:  props.Object,
+        Explore: featureProgrammer_as_explore(props.Explore),
+      })
+    },
+    Unionizer: func(props nativehelpers.UnionExplorer_ObjectorUnionizerProps) *shimast.Node {
+      return objector.Unionizer(FeatureProgrammer_ObjectorUnionizerProps{
+        Objects: props.Objects,
+        Input:   props.Input,
+        Explore: featureProgrammer_as_explore(props.Explore),
+      })
+    },
+    Failure: func(props nativehelpers.UnionExplorer_ObjectorFailureProps) *shimast.Node {
+      explore := featureProgrammer_as_explore(props.Explore)
+      return objector.Failure(FeatureProgrammer_ObjectorFailureProps{
+        Input:    props.Input,
+        Expected: props.Expected,
+        Explore:  &explore,
+      })
+    },
+    Is:       objector.Is,
+    Required: objector.Required,
+    Full: func(props nativehelpers.UnionExplorer_ObjectorFullProps) *shimast.Node {
+      if objector.Full == nil {
+        return props.Condition
+      }
+      return objector.Full(FeatureProgrammer_ObjectorFullProps{
+        Condition: props.Condition,
+        Input:     props.Input,
+        Expected:  props.Expected,
+        Explore:   featureProgrammer_as_explore(props.Explore),
+      })
+    },
+    Type: objector.Type,
+  }
+}
+
+func featureProgrammer_from_iterate_explore(input nativeiterate.Feature_object_entriesExplore) FeatureProgrammer_IExplore {
+  return FeatureProgrammer_IExplore{
+    Tracable: input.Tracable,
+    Source:   input.Source,
+    From:     input.From,
+    Postfix:  input.Postfix,
+  }
+}
+
+func featureProgrammer_as_explore(input any) FeatureProgrammer_IExplore {
+  switch value := input.(type) {
+  case FeatureProgrammer_IExplore:
+    return value
+  case *FeatureProgrammer_IExplore:
+    return *value
+  case map[string]any:
+    output := FeatureProgrammer_IExplore{}
+    if v, ok := value["tracable"].(bool); ok {
+      output.Tracable = v
+    }
+    if v, ok := value["source"].(string); ok {
+      output.Source = v
+    }
+    if v, ok := value["from"].(string); ok {
+      output.From = v
+    }
+    if v, ok := value["postfix"].(string); ok {
+      output.Postfix = v
+    }
+    if v, ok := value["start"].(int); ok {
+      output.Start = &v
+    }
+    return output
+  default:
+    return FeatureProgrammer_IExplore{}
+  }
+}