typia 13.0.1-dev.20260703.1 → 13.0.2

package/native/core/programmers/helpers/RandomJoiner.go

@@ -1,805 +1,805 @@
-package helpers
-
-import (
-  "fmt"
-  "sort"
-
-  shimast "github.com/microsoft/typescript-go/shim/ast"
-  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"
-  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
-)
-
-type randomJoinerNamespace struct{}
-
-var RandomJoiner = randomJoinerNamespace{}
-
-type RandomJoiner_Decoder func(metadata *nativemetadata.MetadataSchema) *shimast.Node
-
-type RandomJoiner_ArrayProps struct {
-  Decode     RandomJoiner_Decoder
-  Recursive  bool
-  Expression *shimast.Expression
-  Array      *nativemetadata.MetadataArrayType
-  Schema     map[string]any
-  Emit       *shimprinter.EmitContext
-}
-
-type RandomJoiner_RecursiveArrayGuardProps struct {
-  Array  *nativemetadata.MetadataArrayType
-  Object *nativemetadata.MetadataObjectType
-  Tuple  *nativemetadata.MetadataTupleType
-}
-
-type RandomJoiner_TupleProps struct {
-  Decode          RandomJoiner_Decoder
-  Elements        []*nativemetadata.MetadataSchema
-  ArrayExpression *shimast.Expression
-  // HasDepth marks that the surrounding function exposes `_depth`, so a
-  // recursive rest spread may guard itself with the depth cutoff. A tuple
-  // inlined at the top level has no `_depth`, and its element recursion already
-  // terminates through its own helper, so the guard must be omitted there.
-  HasDepth bool
-  Emit     *shimprinter.EmitContext
-}
-
-type RandomJoiner_ObjectProps struct {
-  Decode                  RandomJoiner_Decoder
-  Object                  *nativemetadata.MetadataObjectType
-  OptionalProperty        func(*nativemetadata.MetadataSchema) bool
-  StrictOptionalUndefined func(*nativemetadata.MetadataSchema) bool
-  Optional                func() *shimast.Node
-  Emit                    *shimprinter.EmitContext
-}
-
-type randomJoiner_DynamicPropertyProps struct {
-  Decode   RandomJoiner_Decoder
-  Property *nativemetadata.MetadataProperty
-  Emit     *shimprinter.EmitContext
-}
-
-var randomJoiner_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
-func (randomJoinerNamespace) Array(props RandomJoiner_ArrayProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomJoiner_factory, props.Emit)
-  properties := []*shimast.Node{}
-  if props.Schema != nil {
-    keys := make([]string, 0, len(props.Schema))
-    for key := range props.Schema {
-      if key != "items" {
-        keys = append(keys, key)
-      }
-    }
-    sort.Strings(keys)
-    for _, key := range keys {
-      properties = append(properties, f.NewPropertyAssignment(
-        nil,
-        nativefactories.IdentifierFactory.Identifier(key, props.Emit),
-        nil,
-        nil,
-        nativefactories.LiteralFactory.Write(props.Schema[key], props.Emit),
-      ))
-    }
-  } else {
-    properties = append(properties, f.NewSpreadAssignment(f.NewIdentifier("_schema")))
-  }
-  if RandomJoiner.IsRecursiveArray(props.Array) {
-    properties = append(properties, f.NewPropertyAssignment(
-      nil,
-      f.NewIdentifier("recursive"),
-      nil,
-      nil,
-      f.NewKeywordExpression(shimast.KindTrueKeyword),
-    ))
-  }
-  properties = append(properties, f.NewPropertyAssignment(
-    nil,
-    f.NewIdentifier("element"),
-    nil,
-    nil,
-    f.NewArrowFunction(
-      nil,
-      nil,
-      f.NewNodeList(nil),
-      nil,
-      nil,
-      f.NewToken(shimast.KindEqualsGreaterThanToken),
-      props.Decode(props.Array.Value),
-    ),
-  ))
-  call := f.NewCallExpression(
-    props.Expression,
-    nil,
-    nil,
-    f.NewNodeList([]*shimast.Node{
-      f.NewObjectLiteralExpression(
-        f.NewNodeList(properties),
-        true,
-      ),
-    }),
-    shimast.NodeFlagsNone,
-  )
-  if !props.Recursive {
-    return call
-  }
-  return nativefactories.ExpressionFactory.Conditional(
-    f.NewBinaryExpression(
-      nil,
-      nativefactories.ExpressionFactory.Number(5, props.Emit),
-      nil,
-      f.NewToken(shimast.KindGreaterThanEqualsToken),
-      f.NewIdentifier("_depth"),
-    ),
-    call,
-    f.NewArrayLiteralExpression(f.NewNodeList(nil), false),
-    props.Emit,
-  )
-}
-
-func (randomJoinerNamespace) IsRecursiveArray(array *nativemetadata.MetadataArrayType) bool {
-  return randomJoiner_is_recursive_array_type(
-    array,
-    map[*nativemetadata.MetadataSchema]bool{},
-  )
-}
-
-func (randomJoinerNamespace) RequiresRecursiveArrayGuardFor(props RandomJoiner_RecursiveArrayGuardProps) bool {
-  return randomJoiner_requires_recursive_array_guard(
-    props.Array,
-    props.Object,
-    props.Tuple,
-    map[*nativemetadata.MetadataSchema]bool{},
-    map[*nativemetadata.MetadataObjectType]bool{},
-    map[*nativemetadata.MetadataTupleType]bool{},
-  )
-}
-
-func (randomJoinerNamespace) HasRecursiveOwnerPathFor(props RandomJoiner_RecursiveArrayGuardProps) bool {
-  return randomJoiner_has_recursive_owner_array_path(
-    props.Array,
-    props.Object,
-    props.Tuple,
-    map[*nativemetadata.MetadataSchema]bool{},
-    map[*nativemetadata.MetadataArrayType]bool{},
-    map[*nativemetadata.MetadataObjectType]bool{},
-    map[*nativemetadata.MetadataTupleType]bool{},
-  )
-}
-
-func (randomJoinerNamespace) HasDirectRecursiveOwnerPathFor(props RandomJoiner_RecursiveArrayGuardProps) bool {
-  return randomJoiner_has_direct_recursive_owner_array_path(
-    props.Array,
-    props.Object,
-    props.Tuple,
-    map[*nativemetadata.MetadataSchema]bool{},
-    map[*nativemetadata.MetadataArrayType]bool{},
-    map[*nativemetadata.MetadataObjectType]bool{},
-    map[*nativemetadata.MetadataTupleType]bool{},
-  )
-}
-
-func randomJoiner_is_recursive_array_type(
-  array *nativemetadata.MetadataArrayType,
-  visited map[*nativemetadata.MetadataSchema]bool,
-) bool {
-  if array == nil {
-    return false
-  }
-  return array.Recursive || randomJoiner_is_recursive_metadata(array.Value, visited)
-}
-
-func randomJoiner_requires_recursive_array_guard(
-  array *nativemetadata.MetadataArrayType,
-  object *nativemetadata.MetadataObjectType,
-  tuple *nativemetadata.MetadataTupleType,
-  visited map[*nativemetadata.MetadataSchema]bool,
-  visitedObjects map[*nativemetadata.MetadataObjectType]bool,
-  visitedTuples map[*nativemetadata.MetadataTupleType]bool,
-) bool {
-  if array == nil {
-    return false
-  }
-  return array.Recursive || randomJoiner_requires_recursive_guard_metadata(
-    array.Value,
-    object,
-    tuple,
-    visited,
-    visitedObjects,
-    visitedTuples,
-  )
-}
-
-func randomJoiner_requires_recursive_guard_metadata(
-  meta *nativemetadata.MetadataSchema,
-  object *nativemetadata.MetadataObjectType,
-  ownerTuple *nativemetadata.MetadataTupleType,
-  visited map[*nativemetadata.MetadataSchema]bool,
-  visitedObjects map[*nativemetadata.MetadataObjectType]bool,
-  visitedTuples map[*nativemetadata.MetadataTupleType]bool,
-) bool {
-  if meta == nil {
-    return false
-  } else if visited[meta] {
-    return false
-  }
-  visited[meta] = true
-  if meta.Escaped != nil && randomJoiner_requires_recursive_guard_metadata(meta.Escaped.Returns, object, ownerTuple, visited, visitedObjects, visitedTuples) {
-    return true
-  } else if randomJoiner_requires_recursive_guard_metadata(meta.Rest, object, ownerTuple, visited, visitedObjects, visitedTuples) {
-    return true
-  }
-  for _, alias := range meta.Aliases {
-    if alias.Type != nil &&
-      randomJoiner_requires_recursive_guard_metadata(alias.Type.Value, object, ownerTuple, visited, visitedObjects, visitedTuples) {
-      return true
-    }
-  }
-  for _, item := range meta.Tuples {
-    if item.Type == nil {
-      continue
-    } else if item.Type == ownerTuple {
-      return true
-    } else if visitedTuples[item.Type] {
-      continue
-    }
-    visitedTuples[item.Type] = true
-    for _, elem := range item.Type.Elements {
-      if randomJoiner_requires_recursive_guard_metadata(elem, object, ownerTuple, visited, visitedObjects, visitedTuples) {
-        return true
-      }
-    }
-  }
-  for _, item := range meta.Objects {
-    if item.Type == nil {
-      continue
-    } else if item.Type == object {
-      return true
-    } else if visitedObjects[item.Type] {
-      continue
-    }
-    visitedObjects[item.Type] = true
-    for _, property := range item.Type.Properties {
-      if randomJoiner_requires_recursive_guard_metadata(property.Value, object, ownerTuple, visited, visitedObjects, visitedTuples) {
-        return true
-      }
-    }
-  }
-  return false
-}
-
-// UnsatisfiableRecursives reports which of the given object and tuple types can
-// never be randomly generated. Every terminating recursive shape has an escape
-// the generator uses to stop: an array/set/map (or a tuple rest spread) empties
-// at the depth cutoff, a nullable edge becomes `null`, an optional or
-// index-signature property is omitted, or a union picks a finite variant. This
-// is a least-fixpoint "can a finite value be built" analysis — a schema
-// terminates if ANY of its union options does, an object terminates if ALL of
-// its required literal properties do — so a recursive type with no finite
-// inhabitant the generator can reach is rejected at compile time instead of
-// overflowing the stack at runtime. The collection already enumerates every
-// reachable object and tuple, so the fixpoint runs once over the whole domain.
-func (randomJoinerNamespace) UnsatisfiableRecursives(
-  objects []*nativemetadata.MetadataObjectType,
-  tuples []*nativemetadata.MetadataTupleType,
-) (map[*nativemetadata.MetadataObjectType]bool, map[*nativemetadata.MetadataTupleType]bool) {
-  objectSet := map[*nativemetadata.MetadataObjectType]bool{}
-  for _, object := range objects {
-    if object != nil {
-      objectSet[object] = true
-    }
-  }
-  tupleSet := map[*nativemetadata.MetadataTupleType]bool{}
-  for _, tuple := range tuples {
-    if tuple != nil {
-      tupleSet[tuple] = true
-    }
-  }
-  knownObjects, knownTuples := randomJoiner_terminable_fixpoint(objectSet, tupleSet)
-  unsatisfiableObjects := map[*nativemetadata.MetadataObjectType]bool{}
-  for object := range objectSet {
-    if knownObjects[object] == false {
-      unsatisfiableObjects[object] = true
-    }
-  }
-  unsatisfiableTuples := map[*nativemetadata.MetadataTupleType]bool{}
-  for tuple := range tupleSet {
-    if knownTuples[tuple] == false {
-      unsatisfiableTuples[tuple] = true
-    }
-  }
-  return unsatisfiableObjects, unsatisfiableTuples
-}
-
-// randomJoiner_terminable_fixpoint marks every object/tuple that has a finite
-// inhabitant, growing the known set until it stabilizes (monotone least fixpoint,
-// so the result is independent of iteration order).
-func randomJoiner_terminable_fixpoint(
-  objects map[*nativemetadata.MetadataObjectType]bool,
-  tuples map[*nativemetadata.MetadataTupleType]bool,
-) (map[*nativemetadata.MetadataObjectType]bool, map[*nativemetadata.MetadataTupleType]bool) {
-  knownObjects := map[*nativemetadata.MetadataObjectType]bool{}
-  knownTuples := map[*nativemetadata.MetadataTupleType]bool{}
-  for {
-    changed := false
-    for object := range objects {
-      if knownObjects[object] == false && randomJoiner_object_terminable(object, knownObjects, knownTuples) {
-        knownObjects[object] = true
-        changed = true
-      }
-    }
-    for tuple := range tuples {
-      if knownTuples[tuple] == false && randomJoiner_tuple_terminable(tuple, knownObjects, knownTuples) {
-        knownTuples[tuple] = true
-        changed = true
-      }
-    }
-    if changed == false {
-      break
-    }
-  }
-  return knownObjects, knownTuples
-}
-
-func randomJoiner_object_terminable(
-  object *nativemetadata.MetadataObjectType,
-  knownObjects map[*nativemetadata.MetadataObjectType]bool,
-  knownTuples map[*nativemetadata.MetadataTupleType]bool,
-) bool {
-  for _, property := range object.Properties {
-    if property.Value == nil {
-      continue
-    } else if property.Key == nil || property.Key.IsSoleLiteral() == false {
-      continue // index signature: the object may carry zero such entries
-    } else if property.Value.IsRequired() == false {
-      continue // optional property: it may be omitted
-    } else if randomJoiner_schema_terminable(property.Value, knownObjects, knownTuples, map[*nativemetadata.MetadataSchema]bool{}) == false {
-      return false
-    }
-  }
-  return true
-}
-
-func randomJoiner_tuple_terminable(
-  tuple *nativemetadata.MetadataTupleType,
-  knownObjects map[*nativemetadata.MetadataObjectType]bool,
-  knownTuples map[*nativemetadata.MetadataTupleType]bool,
-) bool {
-  for _, elem := range tuple.Elements {
-    if elem == nil {
-      continue
-    } else if elem.Rest != nil {
-      continue // `...X[]` spreads a possibly-empty array: it may carry no value
-    } else if elem.Optional {
-      continue // optional tuple member: it may be omitted
-    } else if randomJoiner_schema_terminable(elem, knownObjects, knownTuples, map[*nativemetadata.MetadataSchema]bool{}) == false {
-      return false
-    }
-  }
-  return true
-}
-
-func randomJoiner_schema_terminable(
-  meta *nativemetadata.MetadataSchema,
-  knownObjects map[*nativemetadata.MetadataObjectType]bool,
-  knownTuples map[*nativemetadata.MetadataTupleType]bool,
-  visited map[*nativemetadata.MetadataSchema]bool,
-) bool {
-  if meta == nil {
-    return false
-  } else if meta.Any || meta.Nullable {
-    return true
-  } else if len(meta.Atomics) > 0 || len(meta.Constants) > 0 || len(meta.Templates) > 0 ||
-    len(meta.Natives) > 0 || len(meta.Functions) > 0 {
-    return true
-  } else if len(meta.Arrays) > 0 || len(meta.Sets) > 0 || len(meta.Maps) > 0 {
-    return true // an empty container is a finite value
-  } else if visited[meta] {
-    return false
-  }
-  visited[meta] = true
-  if meta.Escaped != nil && randomJoiner_schema_terminable(meta.Escaped.Returns, knownObjects, knownTuples, visited) {
-    return true
-  } else if meta.Rest != nil && randomJoiner_schema_terminable(meta.Rest, knownObjects, knownTuples, visited) {
-    return true
-  }
-  for _, alias := range meta.Aliases {
-    if alias.Type != nil && randomJoiner_schema_terminable(alias.Type.Value, knownObjects, knownTuples, visited) {
-      return true
-    }
-  }
-  for _, object := range meta.Objects {
-    if object.Type != nil && knownObjects[object.Type] {
-      return true
-    }
-  }
-  for _, tuple := range meta.Tuples {
-    if tuple.Type != nil && knownTuples[tuple.Type] {
-      return true
-    }
-  }
-  return false
-}
-
-func randomJoiner_has_recursive_owner_array_path(
-  array *nativemetadata.MetadataArrayType,
-  object *nativemetadata.MetadataObjectType,
-  tuple *nativemetadata.MetadataTupleType,
-  visited map[*nativemetadata.MetadataSchema]bool,
-  visitedArrays map[*nativemetadata.MetadataArrayType]bool,
-  visitedObjects map[*nativemetadata.MetadataObjectType]bool,
-  visitedTuples map[*nativemetadata.MetadataTupleType]bool,
-) bool {
-  if array == nil || visitedArrays[array] {
-    return false
-  }
-  visitedArrays[array] = true
-  return randomJoiner_has_recursive_owner_metadata_path(
-    array.Value,
-    object,
-    tuple,
-    visited,
-    visitedArrays,
-    visitedObjects,
-    visitedTuples,
-  )
-}
-
-func randomJoiner_has_direct_recursive_owner_array_path(
-  array *nativemetadata.MetadataArrayType,
-  object *nativemetadata.MetadataObjectType,
-  tuple *nativemetadata.MetadataTupleType,
-  visited map[*nativemetadata.MetadataSchema]bool,
-  visitedArrays map[*nativemetadata.MetadataArrayType]bool,
-  visitedObjects map[*nativemetadata.MetadataObjectType]bool,
-  visitedTuples map[*nativemetadata.MetadataTupleType]bool,
-) bool {
-  if array == nil {
-    return false
-  }
-  return randomJoiner_has_direct_recursive_owner_metadata_path(
-    array.Value,
-    object,
-    tuple,
-    visited,
-    visitedArrays,
-    visitedObjects,
-    visitedTuples,
-  )
-}
-
-func randomJoiner_has_direct_recursive_owner_metadata_path(
-  meta *nativemetadata.MetadataSchema,
-  object *nativemetadata.MetadataObjectType,
-  ownerTuple *nativemetadata.MetadataTupleType,
-  visited map[*nativemetadata.MetadataSchema]bool,
-  visitedArrays map[*nativemetadata.MetadataArrayType]bool,
-  visitedObjects map[*nativemetadata.MetadataObjectType]bool,
-  visitedTuples map[*nativemetadata.MetadataTupleType]bool,
-) bool {
-  if meta == nil {
-    return false
-  } else if visited[meta] {
-    return false
-  }
-  visited[meta] = true
-  if meta.Escaped != nil && randomJoiner_has_direct_recursive_owner_metadata_path(meta.Escaped.Returns, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) {
-    return true
-  } else if randomJoiner_has_direct_recursive_owner_metadata_path(meta.Rest, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) {
-    return true
-  }
-  for _, alias := range meta.Aliases {
-    if alias.Type != nil &&
-      randomJoiner_has_direct_recursive_owner_metadata_path(alias.Type.Value, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) {
-      return true
-    }
-  }
-  for _, item := range meta.Tuples {
-    if item.Type == nil {
-      continue
-    } else if item.Type == ownerTuple {
-      return true
-    } else if visitedTuples[item.Type] {
-      continue
-    }
-    visitedTuples[item.Type] = true
-    for _, elem := range item.Type.Elements {
-      if randomJoiner_has_recursive_owner_metadata_path(elem, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) {
-        return true
-      }
-    }
-  }
-  for _, item := range meta.Objects {
-    if item.Type == nil {
-      continue
-    } else if item.Type == object {
-      return true
-    } else if visitedObjects[item.Type] {
-      continue
-    }
-    visitedObjects[item.Type] = true
-    for _, property := range item.Type.Properties {
-      if randomJoiner_has_recursive_owner_metadata_path(property.Value, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) {
-        return true
-      }
-    }
-  }
-  return false
-}
-
-func randomJoiner_has_recursive_owner_metadata_path(
-  meta *nativemetadata.MetadataSchema,
-  object *nativemetadata.MetadataObjectType,
-  ownerTuple *nativemetadata.MetadataTupleType,
-  visited map[*nativemetadata.MetadataSchema]bool,
-  visitedArrays map[*nativemetadata.MetadataArrayType]bool,
-  visitedObjects map[*nativemetadata.MetadataObjectType]bool,
-  visitedTuples map[*nativemetadata.MetadataTupleType]bool,
-) bool {
-  if meta == nil {
-    return false
-  } else if visited[meta] {
-    return false
-  }
-  visited[meta] = true
-  if meta.Escaped != nil && randomJoiner_has_recursive_owner_metadata_path(meta.Escaped.Returns, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) {
-    return true
-  } else if randomJoiner_has_recursive_owner_metadata_path(meta.Rest, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) {
-    return true
-  }
-  for _, alias := range meta.Aliases {
-    if alias.Type != nil &&
-      randomJoiner_has_recursive_owner_metadata_path(alias.Type.Value, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) {
-      return true
-    }
-  }
-  for _, item := range meta.Arrays {
-    if item.Type != nil &&
-      randomJoiner_has_recursive_owner_array_path(item.Type, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) {
-      return true
-    }
-  }
-  for _, item := range meta.Tuples {
-    if item.Type == nil {
-      continue
-    } else if item.Type == ownerTuple {
-      return true
-    } else if visitedTuples[item.Type] {
-      continue
-    }
-    visitedTuples[item.Type] = true
-    for _, elem := range item.Type.Elements {
-      if randomJoiner_has_recursive_owner_metadata_path(elem, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) {
-        return true
-      }
-    }
-  }
-  for _, item := range meta.Objects {
-    if item.Type == nil {
-      continue
-    } else if item.Type == object {
-      return true
-    } else if visitedObjects[item.Type] {
-      continue
-    }
-    visitedObjects[item.Type] = true
-    for _, property := range item.Type.Properties {
-      if randomJoiner_has_recursive_owner_metadata_path(property.Value, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) {
-        return true
-      }
-    }
-  }
-  for _, item := range meta.Sets {
-    if randomJoiner_has_recursive_owner_metadata_path(item.Value, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) {
-      return true
-    }
-  }
-  for _, item := range meta.Maps {
-    if randomJoiner_has_recursive_owner_metadata_path(item.Key, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) ||
-      randomJoiner_has_recursive_owner_metadata_path(item.Value, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) {
-      return true
-    }
-  }
-  return false
-}
-
-func randomJoiner_is_recursive_tuple_type(
-  tuple *nativemetadata.MetadataTupleType,
-  visited map[*nativemetadata.MetadataSchema]bool,
-) bool {
-  if tuple == nil {
-    return false
-  } else if tuple.Recursive {
-    return true
-  }
-  for _, elem := range tuple.Elements {
-    if randomJoiner_is_recursive_metadata(elem, visited) {
-      return true
-    }
-  }
-  return false
-}
-
-func randomJoiner_is_recursive_metadata(
-  meta *nativemetadata.MetadataSchema,
-  visited map[*nativemetadata.MetadataSchema]bool,
-) bool {
-  if meta == nil {
-    return false
-  } else if visited[meta] {
-    return false
-  }
-  visited[meta] = true
-  if meta.Escaped != nil &&
-    (randomJoiner_is_recursive_metadata(meta.Escaped.Original, visited) ||
-      randomJoiner_is_recursive_metadata(meta.Escaped.Returns, visited)) {
-    return true
-  } else if randomJoiner_is_recursive_metadata(meta.Rest, visited) {
-    return true
-  }
-  for _, alias := range meta.Aliases {
-    if alias.Type != nil &&
-      (alias.Type.Recursive ||
-        randomJoiner_is_recursive_metadata(alias.Type.Value, visited)) {
-      return true
-    }
-  }
-  for _, array := range meta.Arrays {
-    if randomJoiner_is_recursive_array_type(array.Type, visited) {
-      return true
-    }
-  }
-  for _, tuple := range meta.Tuples {
-    if randomJoiner_is_recursive_tuple_type(tuple.Type, visited) {
-      return true
-    }
-  }
-  for _, object := range meta.Objects {
-    if object.Type != nil && object.Type.Recursive {
-      return true
-    }
-  }
-  for _, set := range meta.Sets {
-    if randomJoiner_is_recursive_metadata(set.Value, visited) {
-      return true
-    }
-  }
-  for _, entry := range meta.Maps {
-    if randomJoiner_is_recursive_metadata(entry.Key, visited) ||
-      randomJoiner_is_recursive_metadata(entry.Value, visited) {
-      return true
-    }
-  }
-  return false
-}
-
-func (randomJoinerNamespace) Tuple(props RandomJoiner_TupleProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomJoiner_factory, props.Emit)
-  elements := make([]*shimast.Node, 0, len(props.Elements))
-  for _, elem := range props.Elements {
-    if elem != nil && elem.Rest != nil {
-      // `...X[]` spreads a possibly-empty array of `X`. Routing it through the
-      // array helper gives the spread the same `recursive` cutoff a real array
-      // gets, so the array empties at the depth limit and a recursive rest
-      // element terminates instead of overflowing.
-      arrayType := nativemetadata.MetadataArrayType_create(nativemetadata.MetadataArrayType{
-        Name:        "..." + elem.Rest.GetName(),
-        DisplayName: "..." + elem.Rest.GetDisplayName(),
-        Value:       elem.Rest,
-        Nullables:   []bool{},
-        Recursive:   false,
-        Index:       nil,
-      })
-      elements = append(elements, f.NewSpreadElement(RandomJoiner.Array(RandomJoiner_ArrayProps{
-        Decode:     props.Decode,
-        Recursive:  props.HasDepth && RandomJoiner.IsRecursiveArray(arrayType),
-        Expression: props.ArrayExpression,
-        Array:      arrayType,
-        Schema:     map[string]any{"type": "array"},
-        Emit:       props.Emit,
-      })))
-      continue
-    }
-    elements = append(elements, props.Decode(elem))
-  }
-  return f.NewArrayLiteralExpression(
-    f.NewNodeList(elements),
-    true,
-  )
-}
-
-func (randomJoinerNamespace) Object(props RandomJoiner_ObjectProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomJoiner_factory, props.Emit)
-  if len(props.Object.Properties) == 0 {
-    return nativefactories.LiteralFactory.Write(map[string]any{}, props.Emit)
-  }
-
-  properties := []*shimast.Node{}
-  for _, property := range props.Object.Properties {
-    if !property.Key.IsSoleLiteral() {
-      continue
-    }
-    str := property.Key.GetSoleLiteral()
-    metadata := property.Value
-    optionalProperty := props.OptionalProperty != nil && props.OptionalProperty(property.Value)
-    strictOptionalUndefined := props.StrictOptionalUndefined != nil && props.StrictOptionalUndefined(property.Value)
-    if strictOptionalUndefined {
-      metadata = property.Value.ShallowClone()
-      metadata.Optional = false
-    }
-    propertyAssignment := f.NewPropertyAssignment(
-      nil,
-      nativefactories.IdentifierFactory.Identifier(*str, props.Emit),
-      nil,
-      nil,
-      props.Decode(metadata),
-    )
-    if optionalProperty {
-      condition := f.NewKeywordExpression(shimast.KindTrueKeyword)
-      if props.Optional != nil {
-        condition = props.Optional()
-      }
-      properties = append(properties, f.NewSpreadAssignment(
-        f.NewParenthesizedExpression(nativefactories.ExpressionFactory.Conditional(
-          condition,
-          f.NewObjectLiteralExpression(f.NewNodeList([]*shimast.Node{propertyAssignment}), false),
-          f.NewObjectLiteralExpression(f.NewNodeList(nil), false),
-          props.Emit,
-        )),
-      ))
-    } else {
-      properties = append(properties, propertyAssignment)
-    }
-  }
-  for _, property := range props.Object.Properties {
-    if property.Key.IsSoleLiteral() {
-      continue
-    }
-    properties = append(properties, f.NewSpreadAssignment(randomJoiner_dynamicProperty(randomJoiner_DynamicPropertyProps{
-      Decode:   props.Decode,
-      Property: property,
-      Emit:     props.Emit,
-    })))
-  }
-  return f.NewObjectLiteralExpression(
-    f.NewNodeList(properties),
-    true,
-  )
-}
-
-func randomJoiner_dynamicProperty(props randomJoiner_DynamicPropertyProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomJoiner_factory, props.Emit)
-  tuple := nativemetadata.MetadataTuple_create(nativemetadata.MetadataTuple{
-    Type: nativemetadata.MetadataTupleType_create(nativemetadata.MetadataTupleType{
-      Name:      fmt.Sprintf("[%s, %s]", props.Property.Key.GetName(), props.Property.Value.GetName()),
-      Elements:  []*nativemetadata.MetadataSchema{props.Property.Key, props.Property.Value},
-      Index:     nil,
-      Recursive: false,
-      Nullables: []bool{false},
-    }),
-    Tags: [][]nativemetadata.IMetadataTypeTag{},
-  })
-  value := nativemetadata.MetadataSchema_initialize()
-  value.Tuples = []*nativemetadata.MetadataTuple{tuple}
-  array := nativemetadata.MetadataArray_create(nativemetadata.MetadataArray{
-    Type: nativemetadata.MetadataArrayType_create(nativemetadata.MetadataArrayType{
-      Name:      fmt.Sprintf("Array<[%s, %s]>", props.Property.Key.GetName(), props.Property.Value.GetName()),
-      Value:     value,
-      Nullables: []bool{false},
-      Recursive: false,
-      Index:     nil,
-    }),
-    Tags: [][]nativemetadata.IMetadataTypeTag{{}},
-  })
-  metadata := nativemetadata.MetadataSchema_initialize()
-  metadata.Arrays = []*nativemetadata.MetadataArray{array}
-  return f.NewCallExpression(
-    nativefactories.IdentifierFactory.Access(nil, f.NewIdentifier("Object"), "fromEntries"),
-    nil,
-    nil,
-    f.NewNodeList([]*shimast.Node{
-      props.Decode(metadata),
-    }),
-    shimast.NodeFlagsNone,
-  )
-}
+package helpers
+
+import (
+  "fmt"
+  "sort"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  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"
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+type randomJoinerNamespace struct{}
+
+var RandomJoiner = randomJoinerNamespace{}
+
+type RandomJoiner_Decoder func(metadata *nativemetadata.MetadataSchema) *shimast.Node
+
+type RandomJoiner_ArrayProps struct {
+  Decode     RandomJoiner_Decoder
+  Recursive  bool
+  Expression *shimast.Expression
+  Array      *nativemetadata.MetadataArrayType
+  Schema     map[string]any
+  Emit       *shimprinter.EmitContext
+}
+
+type RandomJoiner_RecursiveArrayGuardProps struct {
+  Array  *nativemetadata.MetadataArrayType
+  Object *nativemetadata.MetadataObjectType
+  Tuple  *nativemetadata.MetadataTupleType
+}
+
+type RandomJoiner_TupleProps struct {
+  Decode          RandomJoiner_Decoder
+  Elements        []*nativemetadata.MetadataSchema
+  ArrayExpression *shimast.Expression
+  // HasDepth marks that the surrounding function exposes `_depth`, so a
+  // recursive rest spread may guard itself with the depth cutoff. A tuple
+  // inlined at the top level has no `_depth`, and its element recursion already
+  // terminates through its own helper, so the guard must be omitted there.
+  HasDepth bool
+  Emit     *shimprinter.EmitContext
+}
+
+type RandomJoiner_ObjectProps struct {
+  Decode                  RandomJoiner_Decoder
+  Object                  *nativemetadata.MetadataObjectType
+  OptionalProperty        func(*nativemetadata.MetadataSchema) bool
+  StrictOptionalUndefined func(*nativemetadata.MetadataSchema) bool
+  Optional                func() *shimast.Node
+  Emit                    *shimprinter.EmitContext
+}
+
+type randomJoiner_DynamicPropertyProps struct {
+  Decode   RandomJoiner_Decoder
+  Property *nativemetadata.MetadataProperty
+  Emit     *shimprinter.EmitContext
+}
+
+var randomJoiner_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+
+func (randomJoinerNamespace) Array(props RandomJoiner_ArrayProps) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(randomJoiner_factory, props.Emit)
+  properties := []*shimast.Node{}
+  if props.Schema != nil {
+    keys := make([]string, 0, len(props.Schema))
+    for key := range props.Schema {
+      if key != "items" {
+        keys = append(keys, key)
+      }
+    }
+    sort.Strings(keys)
+    for _, key := range keys {
+      properties = append(properties, f.NewPropertyAssignment(
+        nil,
+        nativefactories.IdentifierFactory.Identifier(key, props.Emit),
+        nil,
+        nil,
+        nativefactories.LiteralFactory.Write(props.Schema[key], props.Emit),
+      ))
+    }
+  } else {
+    properties = append(properties, f.NewSpreadAssignment(f.NewIdentifier("_schema")))
+  }
+  if RandomJoiner.IsRecursiveArray(props.Array) {
+    properties = append(properties, f.NewPropertyAssignment(
+      nil,
+      f.NewIdentifier("recursive"),
+      nil,
+      nil,
+      f.NewKeywordExpression(shimast.KindTrueKeyword),
+    ))
+  }
+  properties = append(properties, f.NewPropertyAssignment(
+    nil,
+    f.NewIdentifier("element"),
+    nil,
+    nil,
+    f.NewArrowFunction(
+      nil,
+      nil,
+      f.NewNodeList(nil),
+      nil,
+      nil,
+      f.NewToken(shimast.KindEqualsGreaterThanToken),
+      props.Decode(props.Array.Value),
+    ),
+  ))
+  call := f.NewCallExpression(
+    props.Expression,
+    nil,
+    nil,
+    f.NewNodeList([]*shimast.Node{
+      f.NewObjectLiteralExpression(
+        f.NewNodeList(properties),
+        true,
+      ),
+    }),
+    shimast.NodeFlagsNone,
+  )
+  if !props.Recursive {
+    return call
+  }
+  return nativefactories.ExpressionFactory.Conditional(
+    f.NewBinaryExpression(
+      nil,
+      nativefactories.ExpressionFactory.Number(5, props.Emit),
+      nil,
+      f.NewToken(shimast.KindGreaterThanEqualsToken),
+      f.NewIdentifier("_depth"),
+    ),
+    call,
+    f.NewArrayLiteralExpression(f.NewNodeList(nil), false),
+    props.Emit,
+  )
+}
+
+func (randomJoinerNamespace) IsRecursiveArray(array *nativemetadata.MetadataArrayType) bool {
+  return randomJoiner_is_recursive_array_type(
+    array,
+    map[*nativemetadata.MetadataSchema]bool{},
+  )
+}
+
+func (randomJoinerNamespace) RequiresRecursiveArrayGuardFor(props RandomJoiner_RecursiveArrayGuardProps) bool {
+  return randomJoiner_requires_recursive_array_guard(
+    props.Array,
+    props.Object,
+    props.Tuple,
+    map[*nativemetadata.MetadataSchema]bool{},
+    map[*nativemetadata.MetadataObjectType]bool{},
+    map[*nativemetadata.MetadataTupleType]bool{},
+  )
+}
+
+func (randomJoinerNamespace) HasRecursiveOwnerPathFor(props RandomJoiner_RecursiveArrayGuardProps) bool {
+  return randomJoiner_has_recursive_owner_array_path(
+    props.Array,
+    props.Object,
+    props.Tuple,
+    map[*nativemetadata.MetadataSchema]bool{},
+    map[*nativemetadata.MetadataArrayType]bool{},
+    map[*nativemetadata.MetadataObjectType]bool{},
+    map[*nativemetadata.MetadataTupleType]bool{},
+  )
+}
+
+func (randomJoinerNamespace) HasDirectRecursiveOwnerPathFor(props RandomJoiner_RecursiveArrayGuardProps) bool {
+  return randomJoiner_has_direct_recursive_owner_array_path(
+    props.Array,
+    props.Object,
+    props.Tuple,
+    map[*nativemetadata.MetadataSchema]bool{},
+    map[*nativemetadata.MetadataArrayType]bool{},
+    map[*nativemetadata.MetadataObjectType]bool{},
+    map[*nativemetadata.MetadataTupleType]bool{},
+  )
+}
+
+func randomJoiner_is_recursive_array_type(
+  array *nativemetadata.MetadataArrayType,
+  visited map[*nativemetadata.MetadataSchema]bool,
+) bool {
+  if array == nil {
+    return false
+  }
+  return array.Recursive || randomJoiner_is_recursive_metadata(array.Value, visited)
+}
+
+func randomJoiner_requires_recursive_array_guard(
+  array *nativemetadata.MetadataArrayType,
+  object *nativemetadata.MetadataObjectType,
+  tuple *nativemetadata.MetadataTupleType,
+  visited map[*nativemetadata.MetadataSchema]bool,
+  visitedObjects map[*nativemetadata.MetadataObjectType]bool,
+  visitedTuples map[*nativemetadata.MetadataTupleType]bool,
+) bool {
+  if array == nil {
+    return false
+  }
+  return array.Recursive || randomJoiner_requires_recursive_guard_metadata(
+    array.Value,
+    object,
+    tuple,
+    visited,
+    visitedObjects,
+    visitedTuples,
+  )
+}
+
+func randomJoiner_requires_recursive_guard_metadata(
+  meta *nativemetadata.MetadataSchema,
+  object *nativemetadata.MetadataObjectType,
+  ownerTuple *nativemetadata.MetadataTupleType,
+  visited map[*nativemetadata.MetadataSchema]bool,
+  visitedObjects map[*nativemetadata.MetadataObjectType]bool,
+  visitedTuples map[*nativemetadata.MetadataTupleType]bool,
+) bool {
+  if meta == nil {
+    return false
+  } else if visited[meta] {
+    return false
+  }
+  visited[meta] = true
+  if meta.Escaped != nil && randomJoiner_requires_recursive_guard_metadata(meta.Escaped.Returns, object, ownerTuple, visited, visitedObjects, visitedTuples) {
+    return true
+  } else if randomJoiner_requires_recursive_guard_metadata(meta.Rest, object, ownerTuple, visited, visitedObjects, visitedTuples) {
+    return true
+  }
+  for _, alias := range meta.Aliases {
+    if alias.Type != nil &&
+      randomJoiner_requires_recursive_guard_metadata(alias.Type.Value, object, ownerTuple, visited, visitedObjects, visitedTuples) {
+      return true
+    }
+  }
+  for _, item := range meta.Tuples {
+    if item.Type == nil {
+      continue
+    } else if item.Type == ownerTuple {
+      return true
+    } else if visitedTuples[item.Type] {
+      continue
+    }
+    visitedTuples[item.Type] = true
+    for _, elem := range item.Type.Elements {
+      if randomJoiner_requires_recursive_guard_metadata(elem, object, ownerTuple, visited, visitedObjects, visitedTuples) {
+        return true
+      }
+    }
+  }
+  for _, item := range meta.Objects {
+    if item.Type == nil {
+      continue
+    } else if item.Type == object {
+      return true
+    } else if visitedObjects[item.Type] {
+      continue
+    }
+    visitedObjects[item.Type] = true
+    for _, property := range item.Type.Properties {
+      if randomJoiner_requires_recursive_guard_metadata(property.Value, object, ownerTuple, visited, visitedObjects, visitedTuples) {
+        return true
+      }
+    }
+  }
+  return false
+}
+
+// UnsatisfiableRecursives reports which of the given object and tuple types can
+// never be randomly generated. Every terminating recursive shape has an escape
+// the generator uses to stop: an array/set/map (or a tuple rest spread) empties
+// at the depth cutoff, a nullable edge becomes `null`, an optional or
+// index-signature property is omitted, or a union picks a finite variant. This
+// is a least-fixpoint "can a finite value be built" analysis — a schema
+// terminates if ANY of its union options does, an object terminates if ALL of
+// its required literal properties do — so a recursive type with no finite
+// inhabitant the generator can reach is rejected at compile time instead of
+// overflowing the stack at runtime. The collection already enumerates every
+// reachable object and tuple, so the fixpoint runs once over the whole domain.
+func (randomJoinerNamespace) UnsatisfiableRecursives(
+  objects []*nativemetadata.MetadataObjectType,
+  tuples []*nativemetadata.MetadataTupleType,
+) (map[*nativemetadata.MetadataObjectType]bool, map[*nativemetadata.MetadataTupleType]bool) {
+  objectSet := map[*nativemetadata.MetadataObjectType]bool{}
+  for _, object := range objects {
+    if object != nil {
+      objectSet[object] = true
+    }
+  }
+  tupleSet := map[*nativemetadata.MetadataTupleType]bool{}
+  for _, tuple := range tuples {
+    if tuple != nil {
+      tupleSet[tuple] = true
+    }
+  }
+  knownObjects, knownTuples := randomJoiner_terminable_fixpoint(objectSet, tupleSet)
+  unsatisfiableObjects := map[*nativemetadata.MetadataObjectType]bool{}
+  for object := range objectSet {
+    if knownObjects[object] == false {
+      unsatisfiableObjects[object] = true
+    }
+  }
+  unsatisfiableTuples := map[*nativemetadata.MetadataTupleType]bool{}
+  for tuple := range tupleSet {
+    if knownTuples[tuple] == false {
+      unsatisfiableTuples[tuple] = true
+    }
+  }
+  return unsatisfiableObjects, unsatisfiableTuples
+}
+
+// randomJoiner_terminable_fixpoint marks every object/tuple that has a finite
+// inhabitant, growing the known set until it stabilizes (monotone least fixpoint,
+// so the result is independent of iteration order).
+func randomJoiner_terminable_fixpoint(
+  objects map[*nativemetadata.MetadataObjectType]bool,
+  tuples map[*nativemetadata.MetadataTupleType]bool,
+) (map[*nativemetadata.MetadataObjectType]bool, map[*nativemetadata.MetadataTupleType]bool) {
+  knownObjects := map[*nativemetadata.MetadataObjectType]bool{}
+  knownTuples := map[*nativemetadata.MetadataTupleType]bool{}
+  for {
+    changed := false
+    for object := range objects {
+      if knownObjects[object] == false && randomJoiner_object_terminable(object, knownObjects, knownTuples) {
+        knownObjects[object] = true
+        changed = true
+      }
+    }
+    for tuple := range tuples {
+      if knownTuples[tuple] == false && randomJoiner_tuple_terminable(tuple, knownObjects, knownTuples) {
+        knownTuples[tuple] = true
+        changed = true
+      }
+    }
+    if changed == false {
+      break
+    }
+  }
+  return knownObjects, knownTuples
+}
+
+func randomJoiner_object_terminable(
+  object *nativemetadata.MetadataObjectType,
+  knownObjects map[*nativemetadata.MetadataObjectType]bool,
+  knownTuples map[*nativemetadata.MetadataTupleType]bool,
+) bool {
+  for _, property := range object.Properties {
+    if property.Value == nil {
+      continue
+    } else if property.Key == nil || property.Key.IsSoleLiteral() == false {
+      continue // index signature: the object may carry zero such entries
+    } else if property.Value.IsRequired() == false {
+      continue // optional property: it may be omitted
+    } else if randomJoiner_schema_terminable(property.Value, knownObjects, knownTuples, map[*nativemetadata.MetadataSchema]bool{}) == false {
+      return false
+    }
+  }
+  return true
+}
+
+func randomJoiner_tuple_terminable(
+  tuple *nativemetadata.MetadataTupleType,
+  knownObjects map[*nativemetadata.MetadataObjectType]bool,
+  knownTuples map[*nativemetadata.MetadataTupleType]bool,
+) bool {
+  for _, elem := range tuple.Elements {
+    if elem == nil {
+      continue
+    } else if elem.Rest != nil {
+      continue // `...X[]` spreads a possibly-empty array: it may carry no value
+    } else if elem.Optional {
+      continue // optional tuple member: it may be omitted
+    } else if randomJoiner_schema_terminable(elem, knownObjects, knownTuples, map[*nativemetadata.MetadataSchema]bool{}) == false {
+      return false
+    }
+  }
+  return true
+}
+
+func randomJoiner_schema_terminable(
+  meta *nativemetadata.MetadataSchema,
+  knownObjects map[*nativemetadata.MetadataObjectType]bool,
+  knownTuples map[*nativemetadata.MetadataTupleType]bool,
+  visited map[*nativemetadata.MetadataSchema]bool,
+) bool {
+  if meta == nil {
+    return false
+  } else if meta.Any || meta.Nullable {
+    return true
+  } else if len(meta.Atomics) > 0 || len(meta.Constants) > 0 || len(meta.Templates) > 0 ||
+    len(meta.Natives) > 0 || len(meta.Functions) > 0 {
+    return true
+  } else if len(meta.Arrays) > 0 || len(meta.Sets) > 0 || len(meta.Maps) > 0 {
+    return true // an empty container is a finite value
+  } else if visited[meta] {
+    return false
+  }
+  visited[meta] = true
+  if meta.Escaped != nil && randomJoiner_schema_terminable(meta.Escaped.Returns, knownObjects, knownTuples, visited) {
+    return true
+  } else if meta.Rest != nil && randomJoiner_schema_terminable(meta.Rest, knownObjects, knownTuples, visited) {
+    return true
+  }
+  for _, alias := range meta.Aliases {
+    if alias.Type != nil && randomJoiner_schema_terminable(alias.Type.Value, knownObjects, knownTuples, visited) {
+      return true
+    }
+  }
+  for _, object := range meta.Objects {
+    if object.Type != nil && knownObjects[object.Type] {
+      return true
+    }
+  }
+  for _, tuple := range meta.Tuples {
+    if tuple.Type != nil && knownTuples[tuple.Type] {
+      return true
+    }
+  }
+  return false
+}
+
+func randomJoiner_has_recursive_owner_array_path(
+  array *nativemetadata.MetadataArrayType,
+  object *nativemetadata.MetadataObjectType,
+  tuple *nativemetadata.MetadataTupleType,
+  visited map[*nativemetadata.MetadataSchema]bool,
+  visitedArrays map[*nativemetadata.MetadataArrayType]bool,
+  visitedObjects map[*nativemetadata.MetadataObjectType]bool,
+  visitedTuples map[*nativemetadata.MetadataTupleType]bool,
+) bool {
+  if array == nil || visitedArrays[array] {
+    return false
+  }
+  visitedArrays[array] = true
+  return randomJoiner_has_recursive_owner_metadata_path(
+    array.Value,
+    object,
+    tuple,
+    visited,
+    visitedArrays,
+    visitedObjects,
+    visitedTuples,
+  )
+}
+
+func randomJoiner_has_direct_recursive_owner_array_path(
+  array *nativemetadata.MetadataArrayType,
+  object *nativemetadata.MetadataObjectType,
+  tuple *nativemetadata.MetadataTupleType,
+  visited map[*nativemetadata.MetadataSchema]bool,
+  visitedArrays map[*nativemetadata.MetadataArrayType]bool,
+  visitedObjects map[*nativemetadata.MetadataObjectType]bool,
+  visitedTuples map[*nativemetadata.MetadataTupleType]bool,
+) bool {
+  if array == nil {
+    return false
+  }
+  return randomJoiner_has_direct_recursive_owner_metadata_path(
+    array.Value,
+    object,
+    tuple,
+    visited,
+    visitedArrays,
+    visitedObjects,
+    visitedTuples,
+  )
+}
+
+func randomJoiner_has_direct_recursive_owner_metadata_path(
+  meta *nativemetadata.MetadataSchema,
+  object *nativemetadata.MetadataObjectType,
+  ownerTuple *nativemetadata.MetadataTupleType,
+  visited map[*nativemetadata.MetadataSchema]bool,
+  visitedArrays map[*nativemetadata.MetadataArrayType]bool,
+  visitedObjects map[*nativemetadata.MetadataObjectType]bool,
+  visitedTuples map[*nativemetadata.MetadataTupleType]bool,
+) bool {
+  if meta == nil {
+    return false
+  } else if visited[meta] {
+    return false
+  }
+  visited[meta] = true
+  if meta.Escaped != nil && randomJoiner_has_direct_recursive_owner_metadata_path(meta.Escaped.Returns, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) {
+    return true
+  } else if randomJoiner_has_direct_recursive_owner_metadata_path(meta.Rest, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) {
+    return true
+  }
+  for _, alias := range meta.Aliases {
+    if alias.Type != nil &&
+      randomJoiner_has_direct_recursive_owner_metadata_path(alias.Type.Value, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) {
+      return true
+    }
+  }
+  for _, item := range meta.Tuples {
+    if item.Type == nil {
+      continue
+    } else if item.Type == ownerTuple {
+      return true
+    } else if visitedTuples[item.Type] {
+      continue
+    }
+    visitedTuples[item.Type] = true
+    for _, elem := range item.Type.Elements {
+      if randomJoiner_has_recursive_owner_metadata_path(elem, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) {
+        return true
+      }
+    }
+  }
+  for _, item := range meta.Objects {
+    if item.Type == nil {
+      continue
+    } else if item.Type == object {
+      return true
+    } else if visitedObjects[item.Type] {
+      continue
+    }
+    visitedObjects[item.Type] = true
+    for _, property := range item.Type.Properties {
+      if randomJoiner_has_recursive_owner_metadata_path(property.Value, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) {
+        return true
+      }
+    }
+  }
+  return false
+}
+
+func randomJoiner_has_recursive_owner_metadata_path(
+  meta *nativemetadata.MetadataSchema,
+  object *nativemetadata.MetadataObjectType,
+  ownerTuple *nativemetadata.MetadataTupleType,
+  visited map[*nativemetadata.MetadataSchema]bool,
+  visitedArrays map[*nativemetadata.MetadataArrayType]bool,
+  visitedObjects map[*nativemetadata.MetadataObjectType]bool,
+  visitedTuples map[*nativemetadata.MetadataTupleType]bool,
+) bool {
+  if meta == nil {
+    return false
+  } else if visited[meta] {
+    return false
+  }
+  visited[meta] = true
+  if meta.Escaped != nil && randomJoiner_has_recursive_owner_metadata_path(meta.Escaped.Returns, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) {
+    return true
+  } else if randomJoiner_has_recursive_owner_metadata_path(meta.Rest, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) {
+    return true
+  }
+  for _, alias := range meta.Aliases {
+    if alias.Type != nil &&
+      randomJoiner_has_recursive_owner_metadata_path(alias.Type.Value, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) {
+      return true
+    }
+  }
+  for _, item := range meta.Arrays {
+    if item.Type != nil &&
+      randomJoiner_has_recursive_owner_array_path(item.Type, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) {
+      return true
+    }
+  }
+  for _, item := range meta.Tuples {
+    if item.Type == nil {
+      continue
+    } else if item.Type == ownerTuple {
+      return true
+    } else if visitedTuples[item.Type] {
+      continue
+    }
+    visitedTuples[item.Type] = true
+    for _, elem := range item.Type.Elements {
+      if randomJoiner_has_recursive_owner_metadata_path(elem, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) {
+        return true
+      }
+    }
+  }
+  for _, item := range meta.Objects {
+    if item.Type == nil {
+      continue
+    } else if item.Type == object {
+      return true
+    } else if visitedObjects[item.Type] {
+      continue
+    }
+    visitedObjects[item.Type] = true
+    for _, property := range item.Type.Properties {
+      if randomJoiner_has_recursive_owner_metadata_path(property.Value, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) {
+        return true
+      }
+    }
+  }
+  for _, item := range meta.Sets {
+    if randomJoiner_has_recursive_owner_metadata_path(item.Value, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) {
+      return true
+    }
+  }
+  for _, item := range meta.Maps {
+    if randomJoiner_has_recursive_owner_metadata_path(item.Key, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) ||
+      randomJoiner_has_recursive_owner_metadata_path(item.Value, object, ownerTuple, visited, visitedArrays, visitedObjects, visitedTuples) {
+      return true
+    }
+  }
+  return false
+}
+
+func randomJoiner_is_recursive_tuple_type(
+  tuple *nativemetadata.MetadataTupleType,
+  visited map[*nativemetadata.MetadataSchema]bool,
+) bool {
+  if tuple == nil {
+    return false
+  } else if tuple.Recursive {
+    return true
+  }
+  for _, elem := range tuple.Elements {
+    if randomJoiner_is_recursive_metadata(elem, visited) {
+      return true
+    }
+  }
+  return false
+}
+
+func randomJoiner_is_recursive_metadata(
+  meta *nativemetadata.MetadataSchema,
+  visited map[*nativemetadata.MetadataSchema]bool,
+) bool {
+  if meta == nil {
+    return false
+  } else if visited[meta] {
+    return false
+  }
+  visited[meta] = true
+  if meta.Escaped != nil &&
+    (randomJoiner_is_recursive_metadata(meta.Escaped.Original, visited) ||
+      randomJoiner_is_recursive_metadata(meta.Escaped.Returns, visited)) {
+    return true
+  } else if randomJoiner_is_recursive_metadata(meta.Rest, visited) {
+    return true
+  }
+  for _, alias := range meta.Aliases {
+    if alias.Type != nil &&
+      (alias.Type.Recursive ||
+        randomJoiner_is_recursive_metadata(alias.Type.Value, visited)) {
+      return true
+    }
+  }
+  for _, array := range meta.Arrays {
+    if randomJoiner_is_recursive_array_type(array.Type, visited) {
+      return true
+    }
+  }
+  for _, tuple := range meta.Tuples {
+    if randomJoiner_is_recursive_tuple_type(tuple.Type, visited) {
+      return true
+    }
+  }
+  for _, object := range meta.Objects {
+    if object.Type != nil && object.Type.Recursive {
+      return true
+    }
+  }
+  for _, set := range meta.Sets {
+    if randomJoiner_is_recursive_metadata(set.Value, visited) {
+      return true
+    }
+  }
+  for _, entry := range meta.Maps {
+    if randomJoiner_is_recursive_metadata(entry.Key, visited) ||
+      randomJoiner_is_recursive_metadata(entry.Value, visited) {
+      return true
+    }
+  }
+  return false
+}
+
+func (randomJoinerNamespace) Tuple(props RandomJoiner_TupleProps) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(randomJoiner_factory, props.Emit)
+  elements := make([]*shimast.Node, 0, len(props.Elements))
+  for _, elem := range props.Elements {
+    if elem != nil && elem.Rest != nil {
+      // `...X[]` spreads a possibly-empty array of `X`. Routing it through the
+      // array helper gives the spread the same `recursive` cutoff a real array
+      // gets, so the array empties at the depth limit and a recursive rest
+      // element terminates instead of overflowing.
+      arrayType := nativemetadata.MetadataArrayType_create(nativemetadata.MetadataArrayType{
+        Name:        "..." + elem.Rest.GetName(),
+        DisplayName: "..." + elem.Rest.GetDisplayName(),
+        Value:       elem.Rest,
+        Nullables:   []bool{},
+        Recursive:   false,
+        Index:       nil,
+      })
+      elements = append(elements, f.NewSpreadElement(RandomJoiner.Array(RandomJoiner_ArrayProps{
+        Decode:     props.Decode,
+        Recursive:  props.HasDepth && RandomJoiner.IsRecursiveArray(arrayType),
+        Expression: props.ArrayExpression,
+        Array:      arrayType,
+        Schema:     map[string]any{"type": "array"},
+        Emit:       props.Emit,
+      })))
+      continue
+    }
+    elements = append(elements, props.Decode(elem))
+  }
+  return f.NewArrayLiteralExpression(
+    f.NewNodeList(elements),
+    true,
+  )
+}
+
+func (randomJoinerNamespace) Object(props RandomJoiner_ObjectProps) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(randomJoiner_factory, props.Emit)
+  if len(props.Object.Properties) == 0 {
+    return nativefactories.LiteralFactory.Write(map[string]any{}, props.Emit)
+  }
+
+  properties := []*shimast.Node{}
+  for _, property := range props.Object.Properties {
+    if !property.Key.IsSoleLiteral() {
+      continue
+    }
+    str := property.Key.GetSoleLiteral()
+    metadata := property.Value
+    optionalProperty := props.OptionalProperty != nil && props.OptionalProperty(property.Value)
+    strictOptionalUndefined := props.StrictOptionalUndefined != nil && props.StrictOptionalUndefined(property.Value)
+    if strictOptionalUndefined {
+      metadata = property.Value.ShallowClone()
+      metadata.Optional = false
+    }
+    propertyAssignment := f.NewPropertyAssignment(
+      nil,
+      nativefactories.IdentifierFactory.Identifier(*str, props.Emit),
+      nil,
+      nil,
+      props.Decode(metadata),
+    )
+    if optionalProperty {
+      condition := f.NewKeywordExpression(shimast.KindTrueKeyword)
+      if props.Optional != nil {
+        condition = props.Optional()
+      }
+      properties = append(properties, f.NewSpreadAssignment(
+        f.NewParenthesizedExpression(nativefactories.ExpressionFactory.Conditional(
+          condition,
+          f.NewObjectLiteralExpression(f.NewNodeList([]*shimast.Node{propertyAssignment}), false),
+          f.NewObjectLiteralExpression(f.NewNodeList(nil), false),
+          props.Emit,
+        )),
+      ))
+    } else {
+      properties = append(properties, propertyAssignment)
+    }
+  }
+  for _, property := range props.Object.Properties {
+    if property.Key.IsSoleLiteral() {
+      continue
+    }
+    properties = append(properties, f.NewSpreadAssignment(randomJoiner_dynamicProperty(randomJoiner_DynamicPropertyProps{
+      Decode:   props.Decode,
+      Property: property,
+      Emit:     props.Emit,
+    })))
+  }
+  return f.NewObjectLiteralExpression(
+    f.NewNodeList(properties),
+    true,
+  )
+}
+
+func randomJoiner_dynamicProperty(props randomJoiner_DynamicPropertyProps) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(randomJoiner_factory, props.Emit)
+  tuple := nativemetadata.MetadataTuple_create(nativemetadata.MetadataTuple{
+    Type: nativemetadata.MetadataTupleType_create(nativemetadata.MetadataTupleType{
+      Name:      fmt.Sprintf("[%s, %s]", props.Property.Key.GetName(), props.Property.Value.GetName()),
+      Elements:  []*nativemetadata.MetadataSchema{props.Property.Key, props.Property.Value},
+      Index:     nil,
+      Recursive: false,
+      Nullables: []bool{false},
+    }),
+    Tags: [][]nativemetadata.IMetadataTypeTag{},
+  })
+  value := nativemetadata.MetadataSchema_initialize()
+  value.Tuples = []*nativemetadata.MetadataTuple{tuple}
+  array := nativemetadata.MetadataArray_create(nativemetadata.MetadataArray{
+    Type: nativemetadata.MetadataArrayType_create(nativemetadata.MetadataArrayType{
+      Name:      fmt.Sprintf("Array<[%s, %s]>", props.Property.Key.GetName(), props.Property.Value.GetName()),
+      Value:     value,
+      Nullables: []bool{false},
+      Recursive: false,
+      Index:     nil,
+    }),
+    Tags: [][]nativemetadata.IMetadataTypeTag{{}},
+  })
+  metadata := nativemetadata.MetadataSchema_initialize()
+  metadata.Arrays = []*nativemetadata.MetadataArray{array}
+  return f.NewCallExpression(
+    nativefactories.IdentifierFactory.Access(nil, f.NewIdentifier("Object"), "fromEntries"),
+    nil,
+    nil,
+    f.NewNodeList([]*shimast.Node{
+      props.Decode(metadata),
+    }),
+    shimast.NodeFlagsNone,
+  )
+}