typia 15.0.0 → 15.1.0

package/native/core/programmers/notations/notation_general_programmer_pascal_multiword_test.go

@@ -20,6 +20,11 @@ import "testing"
 //     the `PascalCase<T>` / `_notationPascal` oracle.
 //  2. Confirm single-word keys still route through `plain` unchanged.
 //  3. Confirm camel, snake, and kebab of the same keys are unaffected.
+//
+// @evidence contracts/testing.md#behavioral-verification The compile-time pascal, camel, snake and kebab conversions are called on multi-word keys with uppercase inner characters and compared with authored results.
+// @evidence contracts/testing.md#independent-expectations The expected strings follow the PascalCase and related type-level rules (and the runtime notation helper), authored in the table.
+// @evidence contracts/testing.md#distinguishing-cases Keys such as MAX_COUNT and HTTP words separate tail lowercasing from capitalization alone.
+// @evidence contracts/testing.md#execution-ownership The canonical native Go command (pnpm test:go:native) runs this same-package Test function in process. It calls the conversion functions on strings with no checker, filesystem fixture or process.
 func TestNotationGeneralProgrammerPascalMultiword(t *testing.T) {
   pascal := []struct{ input, expected string }{
     // Multi-word: every word becomes upper-first + lower-rest, byte-equal to

package/native/core/programmers/notations/notation_general_programmer_snake_prefix_test.go

@@ -9,6 +9,11 @@ import "testing"
 // produced `"foo"` and `snake("___")` produced `""`, diverging from the
 // `SnakeCase<T>` typing which preserves such keys verbatim. The kebab
 // derivation composes over snake and must inherit the corrected behavior.
+//
+// @evidence contracts/testing.md#behavioral-verification snake and kebab conversions are called on underscore-prefixed and underscore-only keys and compared with authored results.
+// @evidence contracts/testing.md#independent-expectations The SnakeCase typing preserves such keys, so expected strings are authored from the type contract.
+// @evidence contracts/testing.md#distinguishing-cases Leading and only-underscore keys are the rows; internal separators are owned by sibling cases.
+// @evidence contracts/testing.md#execution-ownership The canonical native Go command (pnpm test:go:native) runs this same-package Test function in process. It calls the conversion functions on strings with no checker, filesystem fixture or process.
 func TestNotationGeneralProgrammerSnakePrefix(t *testing.T) {
   snake := []struct{ input, expected string }{
     {"userId", "user_id"},

package/native/core/programmers/notations/notation_general_programmer_underscore_boundary_test.go

@@ -19,6 +19,11 @@ import "testing"
 //  2. Assert each equals the `*Case<T>` value byte for byte.
 //  3. Re-cover underscore-free and all-caps-segment keys so the boundary walk
 //     did not regress them (`userID`, `XMLParser`, `MAX_COUNT`, #2186's pascal).
+//
+// @evidence contracts/testing.md#behavioral-verification snake, kebab, camel and pascal conversions are called on keys mixing an underscore with a case boundary and compared with the type-level results.
+// @evidence contracts/testing.md#independent-expectations The SnakeCase, KebabCase, CamelCase and PascalCase type oracle defines each expected string; the table is authored from those types.
+// @evidence contracts/testing.md#distinguishing-cases Internal and trailing underscores combined with camel boundaries give rows for each conversion.
+// @evidence contracts/testing.md#execution-ownership The canonical native Go command (pnpm test:go:native) runs this same-package Test function in process. It calls the conversion functions on strings with no checker, filesystem fixture or process.
 func TestNotationGeneralProgrammerUnderscoreBoundary(t *testing.T) {
   type row struct {
     input  string

package/native/core/programmers/plain/PlainAssertClassifyProgrammer.go

@@ -14,12 +14,32 @@ type plainAssertClassifyProgrammerNamespace struct{}
 
 var PlainAssertClassifyProgrammer = plainAssertClassifyProgrammerNamespace{}
 
+// PlainAssertClassifyProgrammer_DecomposeProps is the input of Decompose for the
+// plain assert classify generator: Context (the transform context), Functor (the
+// collector of the helper functions that the generator emits), Type (the type to
+// generate for), Name (an optional type name), Init (the optional initializer of
+// the error factory parameter) and Modulo (the call's callee expression).
+//
+// @evidence contracts/common.md#principled-implementation Decompose needs the transform context, the collector of the helper functions that the generator emits, the type to generate for, an optional type name, the optional initializer of the error factory parameter and the call's callee expression, and the record carries them in one argument.
+// @evidence contracts/common.md#clear-and-simple-design A flat argument record of 6 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc names each field.
 type PlainAssertClassifyProgrammer_DecomposeProps struct {
+  // Context borrows the checker, emitter and importer for this transform.
   Context nativecontext.ITypiaContext
+
+  // Functor collects shared helper declarations and recursive-visit state.
   Functor *nativehelpers.FunctionProgrammer
-  Type    *shimchecker.Type
-  Name    *string
-  Init    *shimast.Node
+
+  // Type is the checker type whose input shape is analyzed.
+  Type *shimchecker.Type
+
+  // Name optionally overrides the rendered type name; nil uses the checker name.
+  Name *string
+
+  // Init optionally initializes the assertion error factory parameter.
+  Init *shimast.Node
+
   // Modulo is the call-site node; forwarded so the inner classify can resolve a
   // cross-module class value-import for from/new construction.
   Modulo *shimast.Node

package/native/core/programmers/plain/PlainAssertCloneProgrammer.go

@@ -14,12 +14,31 @@ type plainAssertCloneProgrammerNamespace struct{}
 
 var PlainAssertCloneProgrammer = plainAssertCloneProgrammerNamespace{}
 
+// PlainAssertCloneProgrammer_DecomposeProps is the input of Decompose for the
+// plain assert clone generator: Context (the transform context), Functor (the
+// collector of the helper functions that the generator emits), Type (the type to
+// generate for), Name (an optional type name) and Init (the optional initializer
+// of the error factory parameter).
+//
+// @evidence contracts/common.md#principled-implementation Decompose needs the transform context, the collector of the helper functions that the generator emits, the type to generate for, an optional type name and the optional initializer of the error factory parameter, and the record carries them in one argument.
+// @evidence contracts/common.md#clear-and-simple-design A flat argument record of 5 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc names each field.
 type PlainAssertCloneProgrammer_DecomposeProps struct {
+  // Context borrows the checker, emitter and importer for this transform.
   Context nativecontext.ITypiaContext
+
+  // Functor collects shared helper declarations and recursive-visit state.
   Functor *nativehelpers.FunctionProgrammer
-  Type    *shimchecker.Type
-  Name    *string
-  Init    *shimast.Node
+
+  // Type is the checker type whose input shape is analyzed.
+  Type *shimchecker.Type
+
+  // Name optionally overrides the rendered type name; nil uses the checker name.
+  Name *string
+
+  // Init optionally initializes the assertion error factory parameter.
+  Init *shimast.Node
 }
 
 var plainAssertCloneProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})

package/native/core/programmers/plain/PlainAssertPruneProgrammer.go

@@ -14,12 +14,31 @@ type plainAssertPruneProgrammerNamespace struct{}
 
 var PlainAssertPruneProgrammer = plainAssertPruneProgrammerNamespace{}
 
+// PlainAssertPruneProgrammer_DecomposeProps is the input of Decompose for the
+// plain assert prune generator: Context (the transform context), Functor (the
+// collector of the helper functions that the generator emits), Type (the type to
+// generate for), Name (an optional type name) and Init (the optional initializer
+// of the error factory parameter).
+//
+// @evidence contracts/common.md#principled-implementation Decompose needs the transform context, the collector of the helper functions that the generator emits, the type to generate for, an optional type name and the optional initializer of the error factory parameter, and the record carries them in one argument.
+// @evidence contracts/common.md#clear-and-simple-design A flat argument record of 5 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc names each field.
 type PlainAssertPruneProgrammer_DecomposeProps struct {
+  // Context borrows the checker, emitter and importer for this transform.
   Context nativecontext.ITypiaContext
+
+  // Functor collects shared helper declarations and recursive-visit state.
   Functor *nativehelpers.FunctionProgrammer
-  Type    *shimchecker.Type
-  Name    *string
-  Init    *shimast.Node
+
+  // Type is the checker type whose input shape is analyzed.
+  Type *shimchecker.Type
+
+  // Name optionally overrides the rendered type name; nil uses the checker name.
+  Name *string
+
+  // Init optionally initializes the assertion error factory parameter.
+  Init *shimast.Node
 }
 
 var plainAssertPruneProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})

package/native/core/programmers/plain/PlainClassifyProgrammer.go

@@ -21,12 +21,32 @@ type plainClassifyProgrammerNamespace struct{}
 
 var PlainClassifyProgrammer = plainClassifyProgrammerNamespace{}
 
+// PlainClassifyProgrammer_DecomposeProps is the input of Decompose for the plain
+// classify generator: Validated (whether an enclosing check has already
+// validated the input), Context (the transform context), Functor (the collector
+// of the helper functions that the generator emits), Type (the type to generate
+// for), Name (an optional type name) and Modulo (the call's callee expression).
+//
+// @evidence contracts/common.md#principled-implementation Decompose needs whether an enclosing check has already validated the input, the transform context, the collector of the helper functions that the generator emits, the type to generate for, an optional type name and the call's callee expression, and the record carries them in one argument.
+// @evidence contracts/common.md#clear-and-simple-design A flat argument record of 6 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc names each field.
 type PlainClassifyProgrammer_DecomposeProps struct {
+  // Validated selects a separate is-helper namespace from enclosing assertion helpers.
   Validated bool
-  Context   nativecontext.ITypiaContext
-  Functor   *nativehelpers.FunctionProgrammer
-  Type      *shimchecker.Type
-  Name      *string
+
+  // Context borrows the checker, emitter and importer for this transform.
+  Context nativecontext.ITypiaContext
+
+  // Functor collects shared helper declarations and recursive-visit state.
+  Functor *nativehelpers.FunctionProgrammer
+
+  // Type is the checker type whose input shape is analyzed.
+  Type *shimchecker.Type
+
+  // Name optionally overrides the rendered type name; nil uses the checker name.
+  Name *string
+
   // Modulo is the call-site node (the typia.plain.classify(...) call). Its
   // source file anchors cross-module class value-import specifiers for the
   // from/new construction strategies; nil falls back to a bare identifier.
@@ -737,7 +757,7 @@ func plainClassifyProgrammer_explore_arrays(props plainClassifyProgrammer_explor
             Prefix:   props.Functor.IsPrefix(),
             Input:    v.Input,
             Metadata: v.Definition.(*schemametadata.MetadataSchema),
-            Explore:  plainClassifyProgrammer_checker_explore(v.Explore),
+            Explore:  v.Explore,
           })
         },
         Decoder: func(v nativehelpers.UnionExplorer_ArrayLikeDecoderProps) *shimast.Node {
@@ -747,7 +767,7 @@ func plainClassifyProgrammer_explore_arrays(props plainClassifyProgrammer_explor
             Functor: props.Functor,
             Input:   v.Input,
             Array:   v.Definition.(*schemametadata.MetadataArray),
-            Explore: plainClassifyProgrammer_feature_explore(v.Explore),
+            Explore: v.Explore,
           })
         },
         Empty:   f.NewIdentifier("[]"),
@@ -795,7 +815,7 @@ func plainClassifyProgrammer_explore_sets(props plainClassifyProgrammer_exploreS
             Prefix:   props.Functor.IsPrefix(),
             Input:    v.Input,
             Metadata: v.Definition.(*schemametadata.MetadataSchema),
-            Explore:  plainClassifyProgrammer_checker_explore(v.Explore),
+            Explore:  v.Explore,
           })
         },
         Decoder: func(v nativehelpers.UnionExplorer_ArrayLikeDecoderProps) *shimast.Node {
@@ -809,7 +829,7 @@ func plainClassifyProgrammer_explore_sets(props plainClassifyProgrammer_exploreS
                 Functor: props.Functor,
                 Input:   v.Input,
                 Array:   v.Definition.(*schemametadata.MetadataArray),
-                Explore: plainClassifyProgrammer_feature_explore(v.Explore),
+                Explore: v.Explore,
               }),
             }),
           )
@@ -890,7 +910,7 @@ func plainClassifyProgrammer_explore_maps(props plainClassifyProgrammer_exploreM
                 Functor: props.Functor,
                 Input:   v.Input,
                 Array:   v.Definition.(*schemametadata.MetadataArray),
-                Explore: plainClassifyProgrammer_feature_explore(v.Explore),
+                Explore: v.Explore,
               }),
             }),
           )
@@ -989,14 +1009,9 @@ func plainClassifyProgrammer_configure(props struct {
   // below byte-identical.
   var unionMembers []plainClassifyProgrammer_member
   callFile := plainClassifyProgrammer_call_file(props.Modulo)
-  // classRefOf resolves a named class to a value reference for the field-copy
-  // path (Object.create(<Class>.prototype) in ClassifyJoiner and the recursion
-  // guard allocator). Bare identifier when the class is in lexical scope at the
-  // call site (same file, or source unknown); a relative value import otherwise
-  // — without it a cross-module field-copied class is referenced by an
-  // unimported identifier and throws ReferenceError at runtime. (A default-
-  // exported cross-module class still resolves via a named import here; the
-  // from/new construct path resolves default vs named precisely via class_ref.)
+  // classRefOf resolves a class's usable value reference for both the field-copy
+  // joiner and recursion allocator. Same-file values use lexical bindings;
+  // cross-module values use relative named or default imports.
   classRefOf := func(obj *schemametadata.MetadataObjectType) *shimast.Node {
     // Only a real `class` has a runtime value to Object.create against. An
     // interface / type alias / anonymous object literal (including a RECURSIVE
@@ -1007,12 +1022,9 @@ func plainClassifyProgrammer_configure(props struct {
     if obj == nil || !obj.IsClass {
       return nil
     }
-    // The runtime value reference. obj.Name is the qualified metadata name, which
-    // is already a usable value for a plain or namespaced class ("NS.Plain"
-    // prints verbatim). Two cases need a different binding: a NAMED class
-    // expression (ValueRef = the `const X` binding, since obj.Name is the inner
-    // class name), and a generic instantiation (obj.Name is "Container<string>" —
-    // strip the type arguments to the bare constructor "Container").
+    // Prefer the enclosing variable binding for named or unnamed class
+    // expressions. Otherwise the qualified metadata name identifies the class;
+    // generic instantiations remove their erased type arguments.
     name := obj.Name
     if obj.ValueRef != "" {
       name = obj.ValueRef
@@ -1082,16 +1094,10 @@ func plainClassifyProgrammer_configure(props struct {
   }
   config.Visited = props.Functor.Visited
   config.VisitGuard = func(next nativeinternal.FeatureProgrammer_VisitGuardProps) *shimast.Node {
-    // The recursion guard registers its allocator in the WeakMap as the
-    // canonical output for a revisited input, so for a named class it must be a
-    // prototype-bearing instance — otherwise Object.assign onto a plain {} drops
-    // the prototype and `x instanceof Class` fails on the recursive arm. Mirror
-    // ClassifyJoiner.Object's literal/named split (same *MetadataObjectType
-    // pointer, so IsLiteral() agrees): Object.create(<Name>.prototype) for a
-    // named class, {} for a literal/anonymous shape. The class is referenced by
-    // bare identifier (lexical scope); cross-module support arrives with the
-    // from/new Importer.Instance slice, which must update this allocator AND
-    // ClassifyJoiner.Object together.
+    // Register the same prototype-bearing output chosen by ClassifyJoiner.
+    // Nonliteral objects with a usable class reference use Object.create;
+    // literal shapes and classes without a usable value reference allocate {}.
+    // classRefOf handles lexical bindings and cross-module imports for both.
     var allocator *shimast.Node
     classRef := classRefOf(next.Object)
     if next.Object != nil && !next.Object.IsLiteral() && classRef != nil {
@@ -1118,8 +1124,7 @@ func plainClassifyProgrammer_configure(props struct {
     // _yo<index> joiner — keeps a self-referential class field-copying at nested
     // positions while still constructing at the root.
     if next.Explore.From == "top" {
-      // class-TYPE UNION: discriminate the input and construct the matched member
-      // (the tail = the ordinary union decode lets non-class members pass through).
+      // Class-TYPE UNION: construct or decode the first matched member.
       if len(unionMembers) != 0 {
         // Every union member (class + non-class) is in the ladder, so the tail is
         // the no-match fallback: return the input unchanged. Decoding next.Metadata
@@ -1162,7 +1167,7 @@ func plainClassifyProgrammer_configure(props struct {
         Prefix:   props.Functor.IsPrefix(),
         Input:    next.Input,
         Metadata: next.Metadata,
-        Explore:  plainClassifyProgrammer_checker_explore(next.Explore),
+        Explore:  next.Explore,
       })
     },
     Decoder: func(next nativeinternal.FeatureProgrammer_ObjectorDecoderProps) *shimast.Node {
@@ -1196,7 +1201,7 @@ func plainClassifyProgrammer_configure(props struct {
             Prefix:  props.Functor.IsPrefix(),
             Input:   v.Input,
             Object:  v.Object,
-            Explore: plainClassifyProgrammer_feature_explore(v.Explore),
+            Explore: v.Explore,
           })
         },
         Decoder: func(v nativeiterate.Decode_union_object_next) *shimast.Node {
@@ -1209,7 +1214,7 @@ func plainClassifyProgrammer_configure(props struct {
             Functor: props.Functor,
             Input:   v.Input,
             Object:  v.Object,
-            Explore: plainClassifyProgrammer_feature_explore(v.Explore),
+            Explore: v.Explore,
           })
         },
         Success: func(exp *shimast.Node) *shimast.Node { return exp },
@@ -1520,8 +1525,8 @@ func plainClassifyProgrammer_choose_seed(
 }
 
 // plainClassifyProgrammer_is_abstract reports whether the class TYPE is abstract
-// — its construct signature is un-`new`-able at runtime (`new C` throws "Cannot
-// create an instance of an abstract class"). The `abstract` keyword sits on the
+// — TypeScript rejects construction through its abstract construct signature,
+// although the abstract modifier is erased from JavaScript. The keyword sits on the
 // CLASS declaration, not the constructor declaration, so it is read from the
 // class symbol's declaration (the same node class_ref / emplace_metadata_object
 // read for Default/Private). An abstract class therefore field-copies, exactly
@@ -1608,11 +1613,6 @@ func plainClassifyProgrammer_tuple_seed(checker *shimchecker.Checker, restParamT
   return args[0] // first element is the seed (P in `[infer P, ...Rest]`)
 }
 
-// plainClassifyProgrammer_validation_type returns the type assertClassify /
-// validateClassify must validate the INPUT against. For a class-TYPE target the
-// input is NOT typeof C: it is the from/new SEED (validate the seed), or, when
-// field-copy is selected, the instance shape. For an instance / plain type it
-// is the type itself. Mirrors the detection in plainClassifyProgrammer_initialize.
 // plainClassifyProgrammer_call_file resolves the absolute path of the classify
 // call site (from the Modulo node) — used to decide a same-file vs cross-module
 // class reference. "" when unresolvable.
@@ -1628,6 +1628,11 @@ func plainClassifyProgrammer_call_file(modulo *shimast.Node) string {
   return ""
 }
 
+// plainClassifyProgrammer_validation_type returns the type assertClassify /
+// validateClassify must validate the INPUT against. For a class-TYPE target the
+// input is NOT typeof C: it is the from/new SEED (validate the seed), or, when
+// field-copy is selected, the instance shape. For an instance / plain type it
+// is the type itself. Mirrors the detection in plainClassifyProgrammer_initialize.
 func plainClassifyProgrammer_validation_type(ctx nativecontext.ITypiaContext, static *shimchecker.Type, callFile string) *shimchecker.Type {
   checker := ctx.Checker
   // class-TYPE UNION: assert/validate must check the SEED union (seedA | seedB |
@@ -1922,14 +1927,10 @@ type plainClassifyProgrammer_member struct {
   Strategy *plainClassifyProgrammer_strategy
 }
 
-// plainClassifyProgrammer_union_members detects, per CLASS member of a union
-// target, its construction strategy (from/new) or field-copy, plus the seed /
-// instance-shape metadata used to discriminate the input. Non-class members
-// (e.g. `number` in `typeof A | number`) are omitted — they fall through to the
-// ordinary union-decode tail. Each member's seed/shape is analyzed into the
-// shared collection so its decode helpers are emitted. Members keep declaration
-// order; the runtime ladder is first-match-wins, matching how typia's is/validate
-// resolve a structurally ambiguous union.
+// plainClassifyProgrammer_union_members analyzes each union member into the
+// shared collection in checker order. Class members select from/new or
+// field-copy; non-class members use their own shapes. A pure non-class union
+// returns nil for ordinary decoding. The construction ladder uses first match.
 func plainClassifyProgrammer_union_members(
   ctx nativecontext.ITypiaContext,
   static *shimchecker.Type,
@@ -1989,12 +1990,10 @@ func plainClassifyProgrammer_union_members(
   return members
 }
 
-// plainClassifyProgrammer_construct_union emits the root construction for a union
-// of class types: a first-match ladder over the ordered members —
-// `if (is<seedA>(input)) return A.from/new(...); if (is<seedB>(input)) return ...`
-// — then a TAIL that runs the ordinary union decode, so a mixed `typeof A |
-// number` lets the non-class members (42) pass through unchanged. The whole thing
-// is an IIFE arrow (an EXPRESSION, never a bare Block).
+// plainClassifyProgrammer_construct_union emits a first-match ladder: class
+// members construct from decoded seeds, other members decode their own shapes.
+// The supplied tail handles no match; the root caller passes input unchanged.
+// The ladder is an IIFE expression, so it can be emitted as a return value.
 func plainClassifyProgrammer_construct_union(
   ctx nativecontext.ITypiaContext,
   config nativeinternal.FeatureProgrammer_IConfig,
@@ -2148,32 +2147,9 @@ func plainClassifyProgrammer_errors(errors []nativefactories.MetadataFactory_IEr
   return output
 }
 
-func plainClassifyProgrammer_feature_explore(input any) nativeinternal.FeatureProgrammer_IExplore {
-  switch v := input.(type) {
-  case nativeinternal.FeatureProgrammer_IExplore:
-    return v
-  case *nativeinternal.FeatureProgrammer_IExplore:
-    return *v
-  default:
-    return nativeinternal.FeatureProgrammer_IExplore{}
-  }
-}
-
-func plainClassifyProgrammer_checker_explore(input any) nativeinternal.CheckerProgrammer_IExplore {
-  v := plainClassifyProgrammer_feature_explore(input)
-  return nativeinternal.CheckerProgrammer_IExplore{
-    Tracable: v.Tracable,
-    Source:   v.Source,
-    From:     v.From,
-    Postfix:  v.Postfix,
-    Start:    v.Start,
-  }
-}
-
-func plainClassifyProgrammer_checker_explore_with_postfix(input any, postfix string) nativeinternal.CheckerProgrammer_IExplore {
-  v := plainClassifyProgrammer_checker_explore(input)
-  v.Postfix = v.Postfix + postfix
-  return v
+func plainClassifyProgrammer_checker_explore_with_postfix(input nativeinternal.CheckerProgrammer_IExplore, postfix string) nativeinternal.CheckerProgrammer_IExplore {
+  input.Postfix = input.Postfix + postfix
+  return input
 }
 
 func plainClassifyProgrammer_explore_with(explore nativeinternal.FeatureProgrammer_IExplore, source string, from string) nativeinternal.FeatureProgrammer_IExplore {

package/native/core/programmers/plain/PlainCloneProgrammer.go

@@ -20,12 +20,31 @@ type plainCloneProgrammerNamespace struct{}
 
 var PlainCloneProgrammer = plainCloneProgrammerNamespace{}
 
+// PlainCloneProgrammer_DecomposeProps is the input of Decompose for the plain
+// clone generator: Validated (whether an enclosing check has already validated
+// the input), Context (the transform context), Functor (the collector of the
+// helper functions that the generator emits), Type (the type to generate for)
+// and Name (an optional type name).
+//
+// @evidence contracts/common.md#principled-implementation Decompose needs whether an enclosing check has already validated the input, the transform context, the collector of the helper functions that the generator emits, the type to generate for and an optional type name, and the record carries them in one argument.
+// @evidence contracts/common.md#clear-and-simple-design A flat argument record of 5 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc names each field.
 type PlainCloneProgrammer_DecomposeProps struct {
+  // Validated reuses enclosing checks instead of adding ordinary is-helper declarations.
   Validated bool
-  Context   nativecontext.ITypiaContext
-  Functor   *nativehelpers.FunctionProgrammer
-  Type      *shimchecker.Type
-  Name      *string
+
+  // Context borrows the checker, emitter and importer for this transform.
+  Context nativecontext.ITypiaContext
+
+  // Functor collects shared helper declarations and recursive-visit state.
+  Functor *nativehelpers.FunctionProgrammer
+
+  // Type is the checker type whose input shape is analyzed.
+  Type *shimchecker.Type
+
+  // Name optionally overrides the rendered type name; nil uses the checker name.
+  Name *string
 }
 
 const plainCloneProgrammer_PREFIX = "_c"
@@ -696,7 +715,7 @@ func plainCloneProgrammer_explore_arrays(props plainCloneProgrammer_exploreArray
             Functor:  props.Functor,
             Input:    v.Input,
             Metadata: v.Definition.(*schemametadata.MetadataSchema),
-            Explore:  plainCloneProgrammer_checker_explore(v.Explore),
+            Explore:  v.Explore,
           })
         },
         Decoder: func(v nativehelpers.UnionExplorer_ArrayLikeDecoderProps) *shimast.Node {
@@ -706,7 +725,7 @@ func plainCloneProgrammer_explore_arrays(props plainCloneProgrammer_exploreArray
             Functor: props.Functor,
             Input:   v.Input,
             Array:   v.Definition.(*schemametadata.MetadataArray),
-            Explore: plainCloneProgrammer_feature_explore(v.Explore),
+            Explore: v.Explore,
           })
         },
         Empty:   f.NewIdentifier("[]"),
@@ -753,7 +772,7 @@ func plainCloneProgrammer_explore_sets(props plainCloneProgrammer_exploreSetsPro
             Functor:  props.Functor,
             Input:    v.Input,
             Metadata: v.Definition.(*schemametadata.MetadataSchema),
-            Explore:  plainCloneProgrammer_checker_explore(v.Explore),
+            Explore:  v.Explore,
           })
         },
         Decoder: func(v nativehelpers.UnionExplorer_ArrayLikeDecoderProps) *shimast.Node {
@@ -767,7 +786,7 @@ func plainCloneProgrammer_explore_sets(props plainCloneProgrammer_exploreSetsPro
                 Functor: props.Functor,
                 Input:   v.Input,
                 Array:   v.Definition.(*schemametadata.MetadataArray),
-                Explore: plainCloneProgrammer_feature_explore(v.Explore),
+                Explore: v.Explore,
               }),
             }),
           )
@@ -846,7 +865,7 @@ func plainCloneProgrammer_explore_maps(props plainCloneProgrammer_exploreMapsPro
                 Functor: props.Functor,
                 Input:   v.Input,
                 Array:   v.Definition.(*schemametadata.MetadataArray),
-                Explore: plainCloneProgrammer_feature_explore(v.Explore),
+                Explore: v.Explore,
               }),
             }),
           )
@@ -975,7 +994,7 @@ func plainCloneProgrammer_configure(props struct {
         Functor:  props.Functor,
         Input:    next.Input,
         Metadata: next.Metadata,
-        Explore:  plainCloneProgrammer_checker_explore(next.Explore),
+        Explore:  next.Explore,
       })
     },
     Decoder: func(next nativeinternal.FeatureProgrammer_ObjectorDecoderProps) *shimast.Node {
@@ -1006,7 +1025,7 @@ func plainCloneProgrammer_configure(props struct {
             Functor: props.Functor,
             Input:   v.Input,
             Object:  v.Object,
-            Explore: plainCloneProgrammer_feature_explore(v.Explore),
+            Explore: v.Explore,
           })
         },
         Decoder: func(v nativeiterate.Decode_union_object_next) *shimast.Node {
@@ -1019,7 +1038,7 @@ func plainCloneProgrammer_configure(props struct {
             Functor: props.Functor,
             Input:   v.Input,
             Object:  v.Object,
-            Explore: plainCloneProgrammer_feature_explore(v.Explore),
+            Explore: v.Explore,
           })
         },
         Success: func(exp *shimast.Node) *shimast.Node { return exp },
@@ -1202,32 +1221,9 @@ func plainCloneProgrammer_errors(errors []nativefactories.MetadataFactory_IError
   return output
 }
 
-func plainCloneProgrammer_feature_explore(input any) nativeinternal.FeatureProgrammer_IExplore {
-  switch v := input.(type) {
-  case nativeinternal.FeatureProgrammer_IExplore:
-    return v
-  case *nativeinternal.FeatureProgrammer_IExplore:
-    return *v
-  default:
-    return nativeinternal.FeatureProgrammer_IExplore{}
-  }
-}
-
-func plainCloneProgrammer_checker_explore(input any) nativeinternal.CheckerProgrammer_IExplore {
-  v := plainCloneProgrammer_feature_explore(input)
-  return nativeinternal.CheckerProgrammer_IExplore{
-    Tracable: v.Tracable,
-    Source:   v.Source,
-    From:     v.From,
-    Postfix:  v.Postfix,
-    Start:    v.Start,
-  }
-}
-
-func plainCloneProgrammer_checker_explore_with_postfix(input any, postfix string) nativeinternal.CheckerProgrammer_IExplore {
-  v := plainCloneProgrammer_checker_explore(input)
-  v.Postfix = v.Postfix + postfix
-  return v
+func plainCloneProgrammer_checker_explore_with_postfix(input nativeinternal.CheckerProgrammer_IExplore, postfix string) nativeinternal.CheckerProgrammer_IExplore {
+  input.Postfix = input.Postfix + postfix
+  return input
 }
 
 func plainCloneProgrammer_explore_with(explore nativeinternal.FeatureProgrammer_IExplore, source string, from string) nativeinternal.FeatureProgrammer_IExplore {

package/native/core/programmers/plain/PlainIsCloneProgrammer.go

@@ -14,11 +14,27 @@ type plainIsCloneProgrammerNamespace struct{}
 
 var PlainIsCloneProgrammer = plainIsCloneProgrammerNamespace{}
 
+// PlainIsCloneProgrammer_DecomposeProps is the input of Decompose for the plain
+// is clone generator: Context (the transform context), Functor (the collector of
+// the helper functions that the generator emits), Type (the type to generate
+// for) and Name (an optional type name).
+//
+// @evidence contracts/common.md#principled-implementation Decompose needs the transform context, the collector of the helper functions that the generator emits, the type to generate for and an optional type name, and the record carries them in one argument.
+// @evidence contracts/common.md#clear-and-simple-design A flat argument record of 4 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc names each field.
 type PlainIsCloneProgrammer_DecomposeProps struct {
+  // Context borrows the checker, emitter and importer for this transform.
   Context nativecontext.ITypiaContext
+
+  // Functor collects shared helper declarations and recursive-visit state.
   Functor *nativehelpers.FunctionProgrammer
-  Type    *shimchecker.Type
-  Name    *string
+
+  // Type is the checker type whose input shape is analyzed.
+  Type *shimchecker.Type
+
+  // Name optionally overrides the rendered type name; nil uses the checker name.
+  Name *string
 }
 
 var plainIsCloneProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})

package/native/core/programmers/plain/PlainIsPruneProgrammer.go

@@ -14,11 +14,27 @@ type plainIsPruneProgrammerNamespace struct{}
 
 var PlainIsPruneProgrammer = plainIsPruneProgrammerNamespace{}
 
+// PlainIsPruneProgrammer_DecomposeProps is the input of Decompose for the plain
+// is prune generator: Context (the transform context), Functor (the collector of
+// the helper functions that the generator emits), Type (the type to generate
+// for) and Name (an optional type name).
+//
+// @evidence contracts/common.md#principled-implementation Decompose needs the transform context, the collector of the helper functions that the generator emits, the type to generate for and an optional type name, and the record carries them in one argument.
+// @evidence contracts/common.md#clear-and-simple-design A flat argument record of 4 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc names each field.
 type PlainIsPruneProgrammer_DecomposeProps struct {
+  // Context borrows the checker, emitter and importer for this transform.
   Context nativecontext.ITypiaContext
+
+  // Functor collects shared helper declarations and recursive-visit state.
   Functor *nativehelpers.FunctionProgrammer
-  Type    *shimchecker.Type
-  Name    *string
+
+  // Type is the checker type whose input shape is analyzed.
+  Type *shimchecker.Type
+
+  // Name optionally overrides the rendered type name; nil uses the checker name.
+  Name *string
 }
 
 var plainIsPruneProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})