@voxgig/sdkgen 4.5.2 → 4.6.0

package/project/.sdk/tm/go/utility/struct/voxgigstruct.go

@@ -1,3 +1,6 @@
+// VENDORED: @voxgig/struct 0.1.3 (go/voxgigstruct.go)
+// Source: https://github.com/voxgig/struct @ 94409354d0a60fda8098c83e290583b7dee76c84
+// License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
 /* Copyright (c) 2025 Voxgig Ltd. MIT LICENSE. */
 
 /* Voxgig Struct
@@ -53,10 +56,10 @@ package voxgigstruct
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"math"
 	"math/bits"
-	"net/url"
 	"reflect"
 	"regexp"
 	"sort"
@@ -135,8 +138,8 @@ const (
 	T_map      = 1 << 13
 	T_instance = 1 << 12
 	// 4 bits reserved
-	T_scalar   = 1 << 7
-	T_node     = 1 << 6
+	T_scalar = 1 << 7
+	T_node   = 1 << 6
 )
 
 // TYPENAME maps bit position (via leading zeros count) to type name string.
@@ -167,6 +170,20 @@ type _sentinel struct{ name string }
 var SKIP = &_sentinel{"SKIP"}
 var DELETE = &_sentinel{"DELETE"}
 
+// NOVAL is Go's no-value: the third state canonical spells `undefined`.
+//
+// Go's value domain has nil and it has real values, and nothing between,
+// so `Typify(nil)` is T_scalar|T_null and T_noval was unreachable - this
+// port could not express `typify()` as distinct from `typify(null)`, which
+// the corpus pins as two different results (1073741824 vs 4194432). Every
+// other port models the distinction, natively or with a sentinel of its
+// own; NOVAL is Go's.
+//
+// It is recognised AHEAD of the reflect dispatch, in Typify, IsEmpty and
+// Clone. That ordering is the whole trick: a Go sentinel is a struct
+// pointer, so reflect would otherwise class it as a node.
+var NOVAL = &_sentinel{"NOVAL"}
+
 // Regex matching integer keys (including negative).
 var reIntegerKey = regexp.MustCompile(`^[-0-9]+$`)
 
@@ -364,6 +381,10 @@ func (inj *Injection) String(prefix ...string) string {
 }
 
 // Function applied to each node and leaf when walking a node structure depth first.
+// The `path` argument is a single mutable slice per depth, shared across all
+// callback invocations for the lifetime of a top-level Walk call. Callbacks
+// that need to retain the path MUST clone it (e.g. `append([]string(nil), path...)`);
+// otherwise its contents will be overwritten by subsequent visits.
 type WalkApply func(
 	// Map keys are strings, list keys are numbers, top key is nil
 	key *string,
@@ -418,7 +439,26 @@ func IsKey(val any) bool {
 }
 
 // Check for an "empty" value - nil, empty string, array, object.
+
+// denoval collapses NOVAL to nil. Canonical distinguishes undefined from
+// null in exactly one place - typify - and treats them alike everywhere
+// else (`null == val` in JavaScript is true for both). The functions below
+// follow canonical, so they take a value that has already been collapsed.
+//
+// The Group A readers - GetDef, GetProp, GetElem and (through GetProp)
+// HasKey - collapse it on the way in AND on the way out, so a NOVAL reached
+// as a container, a key, or a stored value reads as absent and yields the
+// alt. That is canonical: `getprop({a: undefined}, 'a', alt)` is alt, and
+// `haskey` is false, because `undefined == null` in JavaScript.
+func denoval(val any) any {
+	if NOVAL == val {
+		return nil
+	}
+	return val
+}
+
 func IsEmpty(val any) bool {
+	val = denoval(val)
 	if val == nil {
 		return true
 	}
@@ -440,8 +480,9 @@ func IsFunc(val any) bool {
 	return reflect.ValueOf(val).Kind() == reflect.Func
 }
 
-// Get a defined value. Returns alt if val is nil.
+// Get a defined value. Returns alt if val is nil or NOVAL.
 func GetDef(val any, alt any) any {
+	val = denoval(val)
 	if nil == val {
 		return alt
 	}
@@ -456,6 +497,12 @@ func Typify(value any) int {
 		return T_scalar | T_null
 	}
 
+	// Before the reflect dispatch: NOVAL is a struct pointer, and reflect
+	// would class it as a node.
+	if NOVAL == value {
+		return T_noval
+	}
+
 	if _, ok := value.(*ListRef[any]); ok {
 		return T_node | T_list
 	}
@@ -507,7 +554,7 @@ func Typename(t int) string {
 	if t <= 0 {
 		return S_any
 	}
-	idx := bits.LeadingZeros32(uint32(t))
+	idx := bits.LeadingZeros32(uint32(t)) // #nosec G115 -- t is a small type bitcode (well under 2^31).
 	if idx < len(TYPENAME) && TYPENAME[idx] != "" {
 		return TYPENAME[idx]
 	}
@@ -701,6 +748,9 @@ func GetElem(val any, key any, alts ...any) any {
 		alt = alts[0]
 	}
 
+	val = denoval(val)
+	key = denoval(key)
+
 	if nil == val || nil == key {
 		return alt
 	}
@@ -726,7 +776,7 @@ func GetElem(val any, key any, alts ...any) any {
 		}
 	}
 
-	if nil == out {
+	if nil == denoval(out) {
 		if 0 < (T_function & Typify(alt)) {
 			fn := reflect.ValueOf(alt)
 			results := fn.Call(nil)
@@ -751,6 +801,9 @@ func GetProp(val any, key any, alts ...any) any {
 		alt = alts[0]
 	}
 
+	val = denoval(val)
+	key = denoval(key)
+
 	if nil == val || nil == key {
 		return alt
 	}
@@ -805,7 +858,7 @@ func GetProp(val any, key any, alts ...any) any {
 
 	} else {
 		valRef := reflect.ValueOf(val)
-		if valRef.Kind() == reflect.Ptr {
+		if valRef.Kind() == reflect.Pointer {
 			valRef = valRef.Elem()
 		}
 
@@ -822,7 +875,7 @@ func GetProp(val any, key any, alts ...any) any {
 		}
 	}
 
-	if nil == out {
+	if nil == denoval(out) {
 		return alt
 	}
 
@@ -858,20 +911,18 @@ func KeysOf(val any) []string {
 	return make([]string, 0)
 }
 
-
 // Value of property with name key in node val is defined.
 func HasKey(val any, key any) bool {
 	return nil != GetProp(val, key)
 }
 
-
 // List the sorted keys of a map or list as an array of tuples of the form [key, value].
 func Items(val any) [][2]any {
 	if IsMap(val) {
 		m := val.(map[string]any)
 		out := make([][2]any, 0, len(m))
 
-    keys := KeysOf(val)
+		keys := KeysOf(val)
 		// keys := make([]string, 0, len(m))
 		// for k := range m {
 		// 	keys = append(keys, k)
@@ -895,7 +946,7 @@ func Items(val any) [][2]any {
 		return out
 	}
 
-	return make([][2]any, 0, 0)
+	return make([][2]any, 0)
 }
 
 // List items with an optional apply callback that maps over each [key, value] tuple.
@@ -955,7 +1006,6 @@ func Filter(val any, check func([2]any) bool) []any {
 	return out
 }
 
-
 // Escape regular expression.
 func EscRe(s string) string {
 	if s == "" {
@@ -965,9 +1015,78 @@ func EscRe(s string) string {
 	return re.ReplaceAllString(s, `\${0}`)
 }
 
-// Escape URLs.
+// ---------------------------------------------------------------------------
+// Regex utility — uniform Re* API (see /REGEX_API.md). Go's stdlib `regexp`
+// IS the RE2 reference implementation, so the wrappers are direct passthroughs.
+// ---------------------------------------------------------------------------
+
+// ReCompile compiles a pattern. Accepts a string or an already-compiled *regexp.Regexp.
+func ReCompile(pattern string) *regexp.Regexp {
+	return regexp.MustCompile(pattern)
+}
+
+// ReFind returns [whole, capture1, ...] for the first match, or nil.
+func ReFind(pattern, input string) []string {
+	return regexp.MustCompile(pattern).FindStringSubmatch(input)
+}
+
+// ReFindRe is the *regexp.Regexp form.
+func ReFindRe(re *regexp.Regexp, input string) []string {
+	return re.FindStringSubmatch(input)
+}
+
+// ReFindAll returns all non-overlapping match-group arrays.
+func ReFindAll(pattern, input string) [][]string {
+	return regexp.MustCompile(pattern).FindAllStringSubmatch(input, -1)
+}
+
+// ReReplace replaces every match. The replacement supports Go's $0..$N
+// reference syntax (functionally equivalent to JS $&..$N).
+//
+// Note: Go's `regexp` (RE2) suppresses an empty match immediately
+// following a non-empty match at the same offset. This is RE2's
+// chosen convention and differs from ECMAScript / Python / Java etc:
+// `re_replace("a*", "abc", "X")` returns "XbXcX" here, "XXbXcX" on
+// PCRE/ECMA engines. The variance is inherent to the host regex
+// package; see REGEX_PATHOLOGICAL.md.
+func ReReplace(pattern, input, replacement string) string {
+	return regexp.MustCompile(pattern).ReplaceAllString(input, replacement)
+}
+
+// ReReplaceFunc replaces every match via the callback.
+func ReReplaceFunc(pattern, input string, fn func([]string) string) string {
+	re := regexp.MustCompile(pattern)
+	return re.ReplaceAllStringFunc(input, func(m string) string {
+		groups := re.FindStringSubmatch(m)
+		return fn(groups)
+	})
+}
+
+// ReTest reports whether the input matches.
+func ReTest(pattern, input string) bool {
+	return regexp.MustCompile(pattern).MatchString(input)
+}
+
+// ReEscape is an alias for EscRe.
+func ReEscape(s string) string { return EscRe(s) }
+
+// Escape URLs. Mirrors the canonical encodeURIComponent: every byte is
+// percent-encoded except the unreserved set A-Za-z0-9 and -_.!~*'().
+// In particular a space encodes as %20 (url.QueryEscape would emit '+').
 func EscUrl(s string) string {
-	return url.QueryEscape(s)
+	var b strings.Builder
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		if (c >= 'A' && c <= 'Z') ||
+			(c >= 'a' && c <= 'z') ||
+			(c >= '0' && c <= '9') ||
+			strings.IndexByte("-_.!~*'()", c) >= 0 {
+			b.WriteByte(c)
+		} else {
+			fmt.Fprintf(&b, "%%%02X", c)
+		}
+	}
+	return b.String()
 }
 
 var (
@@ -980,7 +1099,7 @@ var (
 func JoinUrl(parts []any) string {
 	var filtered []string
 	for _, p := range parts {
-		if "" != p && nil != p {
+		if p != "" && p != nil {
 			ps, ok := p.(string)
 			if !ok {
 				ps = Stringify(p)
@@ -1012,7 +1131,6 @@ func JoinUrl(parts []any) string {
 	return strings.Join(finalParts, "/")
 }
 
-
 // Concatenate string array elements, merging separator chars as needed.
 // Optional args: sep (string, default ","), url (bool, default false).
 func Join(arr []any, args ...any) string {
@@ -1033,7 +1151,7 @@ func Join(arr []any, args ...any) string {
 	}
 
 	var sepre string
-	if 1 == len(sep) {
+	if len(sep) == 1 {
 		sepre = EscRe(sep)
 	}
 
@@ -1065,7 +1183,7 @@ func Join(arr []any, args ...any) string {
 			reLeading := regexp.MustCompile(`^` + sepre + `+`)
 			reInternal := regexp.MustCompile(`([^` + sepre + `])` + sepre + `+([^` + sepre + `])`)
 
-			if urlMode && 0 == idx {
+			if urlMode && idx == 0 {
 				s = reTrailing.ReplaceAllString(s, S_MT)
 			} else {
 				if 0 < idx {
@@ -1088,7 +1206,6 @@ func Join(arr []any, args ...any) string {
 	return strings.Join(parts, sep)
 }
 
-
 // Output JSON in a "standard" format, with 2 space indents, each property on a new line,
 // and spaces after {[: and before ]}. Any "weird" values (NaN, etc) are output as null.
 // In general, the behavior of JavaScript's JSON.stringify(val,null,2) is followed.
@@ -1112,9 +1229,17 @@ func Jsonify(val any, flags ...map[string]any) string {
 	}
 
 	if nil != val {
-		indentStr := strings.Repeat(" ", indent)
-		offsetStr := strings.Repeat(" ", offset)
-		b, err := json.MarshalIndent(val, offsetStr, indentStr)
+		// Canonical: indent==0 → compact JSON (json.Marshal). Otherwise
+		// pretty-print with the given indent and prefix.
+		var b []byte
+		var err error
+		if indent == 0 {
+			b, err = json.Marshal(val)
+		} else {
+			indentStr := strings.Repeat(" ", indent)
+			offsetStr := strings.Repeat(" ", offset)
+			b, err = json.MarshalIndent(val, offsetStr, indentStr)
+		}
 		if err != nil {
 			str = S_null
 		} else {
@@ -1126,9 +1251,13 @@ func Jsonify(val any, flags ...map[string]any) string {
 }
 
 // Safely stringify a value for humans (NOT JSON!).
+//
+// In Go, nil represents a JSON null (there is no separate undefined),
+// so it stringifies to the literal "null" — matching the canonical
+// JSON.stringify(null) === "null".
 func Stringify(val any, maxlen ...int) string {
 	if nil == val {
-		return S_MT
+		return S_null
 	}
 
 	if lr, ok := val.(*ListRef[any]); ok {
@@ -1285,6 +1414,7 @@ func Clone(val any) any {
 }
 
 func CloneFlags(val any, flags map[string]bool) any {
+	val = denoval(val)
 	if val == nil {
 		return nil
 	}
@@ -1335,9 +1465,9 @@ func CloneFlags(val any, flags map[string]bool) any {
 	}
 }
 
-// Define a JSON Object from alternating key-value arguments.
-// jo("a", 1, "b", 2) => {"a": 1, "b": 2}
-func Jo(kv ...any) map[string]any {
+// Jm defines a JSON object from alternating key/value arguments.
+// Jm("a", 1, "b", 2) => {"a": 1, "b": 2}
+func Jm(kv ...any) map[string]any {
 	o := make(map[string]any)
 	kvsize := len(kv)
 	for i := 0; i < kvsize; i += 2 {
@@ -1351,9 +1481,9 @@ func Jo(kv ...any) map[string]any {
 	return o
 }
 
-// Define a JSON Array from arguments.
-// ja(1, "x", true) => [1, "x", true]
-func Ja(v ...any) []any {
+// Jt defines a JSON array (tuple) from positional arguments.
+// Jt(1, "x", true) => [1, "x", true]
+func Jt(v ...any) []any {
 	a := make([]any, len(v))
 	for i := 0; i < len(v); i++ {
 		a[i] = GetProp(v, i)
@@ -1379,8 +1509,6 @@ func DelProp(parent any, key any) any {
 		if err != nil {
 			return parent
 		}
-		ki = int(math.Floor(float64(ki)))
-
 		if lr, isLR := parent.(*ListRef[any]); isLR {
 			psize := len(lr.List)
 			if 0 <= ki && ki < psize {
@@ -1545,13 +1673,18 @@ func SetProp(parent any, key any, newval any) any {
 // Walk(val, before, after, maxdepth) - with maximum recursion depth.
 // Pass nil for before or after to skip that callback.
 // For backward compatibility, Walk(val, apply) applies the callback after children (post-order).
+//
+// The `path` passed to callbacks is a single mutable slice per depth, reused
+// across recursive calls. Callbacks must clone it (see WalkApply) if they want
+// to retain it beyond the invocation.
 func Walk(
 	val any,
 	apply WalkApply,
 	opts ...any,
 ) any {
+	val = denoval(val)
 	var after WalkApply
-	var maxdepth int = 32
+	maxdepth := 32
 
 	if len(opts) > 0 {
 		if opts[0] != nil {
@@ -1573,17 +1706,25 @@ func Walk(
 		}
 	}
 
+	// Allocate the path-pool once per top-level Walk. pool[n] is a backing
+	// array of length n that holds the current path for depth n; it is
+	// grown on demand and mutated in place by _walkDescend.
+	pool := [][]string{nil}
+
 	if after != nil {
 		// Two-callback mode: apply is before, after is after.
-		return _walkDescend(val, apply, after, maxdepth, nil, nil, nil)
+		return _walkDescend(val, apply, after, maxdepth, nil, nil, nil, pool)
 	}
 
 	// Single-callback mode: apply is called before children (pre-order),
 	// matching the TS implementation where walk(val, before) is pre-order.
-	return _walkDescend(val, apply, nil, maxdepth, nil, nil, nil)
+	return _walkDescend(val, apply, nil, maxdepth, nil, nil, nil, pool)
 }
 
-
+// WalkDescend performs a post-order walk from an arbitrary start point
+// (with explicit key, parent, and path). Unlike Walk it does not share a
+// pool across recursive calls: it allocates per-call path arrays. Intended
+// for ad-hoc recursive descents from a non-root position.
 func WalkDescend(
 	val any,
 	apply WalkApply,
@@ -1591,10 +1732,14 @@ func WalkDescend(
 	parent any,
 	path []string,
 ) any {
-	return _walkDescend(val, nil, apply, 32, key, parent, path)
+	return _walkDescendAlloc(val, nil, apply, 32, key, parent, path)
 }
 
-
+// _walkDescend is the pool-threaded core used by Walk. The `path` slice it
+// hands to callbacks is reused across sibling visits: each recursive call
+// reuses pool[depth+1] (growing the pool on demand), writes its own key in
+// the last slot, and passes the slice down. Callbacks must clone it if they
+// want to retain it.
 func _walkDescend(
 	val any,
 	before WalkApply,
@@ -1603,8 +1748,14 @@ func _walkDescend(
 	key *string,
 	parent any,
 	path []string,
+	pool [][]string,
 ) any {
 
+	if path == nil {
+		path = pool[0]
+	}
+	depth := len(path)
+
 	out := val
 
 	// Apply before callback.
@@ -1613,6 +1764,69 @@ func _walkDescend(
 	}
 
 	// Check depth limit.
+	if 0 == maxdepth || (0 < maxdepth && maxdepth <= depth) {
+		return out
+	}
+
+	if IsNode(out) {
+		childDepth := depth + 1
+		// Grow pool on demand.
+		for len(pool) <= childDepth {
+			pool = append(pool, nil)
+		}
+		childPath := pool[childDepth]
+		if childPath == nil {
+			childPath = make([]string, childDepth)
+			pool[childDepth] = childPath
+		}
+		// Sync prefix [0..depth-1] from the current path. Only needed
+		// once per parent: siblings share the same prefix and will each
+		// overwrite slot [depth] below.
+		for i := 0; i < depth; i++ {
+			childPath[i] = path[i]
+		}
+
+		for _, kv := range Items(out) {
+			ckey := kv[0]
+			child := kv[1]
+			ckeyStr := StrKey(ckey)
+			childPath[depth] = ckeyStr
+			newChild := _walkDescend(child, before, after, maxdepth, &ckeyStr, out, childPath, pool)
+			out = SetProp(out, ckey, newChild)
+		}
+
+		if nil != parent && nil != key {
+			SetProp(parent, *key, out)
+		}
+	}
+
+	// Apply after callback.
+	if nil != after {
+		out = after(key, out, parent, path)
+	}
+
+	return out
+}
+
+// _walkDescendAlloc is the legacy per-call-allocating descent used by
+// WalkDescend, preserved for callers that enter the recursion at an
+// arbitrary point without a shared pool.
+func _walkDescendAlloc(
+	val any,
+	before WalkApply,
+	after WalkApply,
+	maxdepth int,
+	key *string,
+	parent any,
+	path []string,
+) any {
+
+	out := val
+
+	if nil != before {
+		out = before(key, out, parent, path)
+	}
+
 	if 0 == maxdepth || (nil != path && 0 < maxdepth && maxdepth <= len(path)) {
 		return out
 	}
@@ -1625,7 +1839,7 @@ func _walkDescend(
 			newPath := make([]string, len(path)+1)
 			copy(newPath, path)
 			newPath[len(path)] = ckeyStr
-			newChild := _walkDescend(child, before, after, maxdepth, &ckeyStr, out, newPath)
+			newChild := _walkDescendAlloc(child, before, after, maxdepth, &ckeyStr, out, newPath)
 			out = SetProp(out, ckey, newChild)
 		}
 
@@ -1634,7 +1848,6 @@ func _walkDescend(
 		}
 	}
 
-	// Apply after callback.
 	if nil != after {
 		out = after(key, out, parent, path)
 	}
@@ -1648,6 +1861,7 @@ func _walkDescend(
 // modified.
 // Optional maxdepth parameter limits recursion depth.
 func Merge(val any, maxdepths ...int) any {
+	val = denoval(val)
 	md := 32
 	if len(maxdepths) > 0 {
 		if maxdepths[0] < 0 {
@@ -1657,7 +1871,7 @@ func Merge(val any, maxdepths ...int) any {
 		}
 	}
 
-	var out any = nil
+	var out any
 
 	if !IsList(val) {
 		return val
@@ -1780,7 +1994,7 @@ func Merge(val any, maxdepths ...int) any {
 // resolved against the `current` argument, if defined.  Integer path
 // parts are used as array indexes.  The inj argument allows for
 // custom handling when called from `inject` or `transform`.
-func GetPath(path any, store any, injdefs ...*Injection) any {
+func GetPath(store any, path any, injdefs ...*Injection) any {
 	var inj *Injection
 	if len(injdefs) > 0 {
 		inj = injdefs[0]
@@ -1856,20 +2070,20 @@ func GetPath(path any, store any, injdefs ...*Injection) any {
 				} else if inj != nil && strings.HasPrefix(part, "$GET:") {
 					// $GET:path$ -> get store value, use as path part
 					subpath := part[5 : len(part)-1]
-					result := GetPath(subpath, src)
+					result := GetPath(src, subpath)
 					part = Stringify(result)
 				} else if inj != nil && strings.HasPrefix(part, "$REF:") {
 					// $REF:refpath$ -> get spec value, use as path part
 					subpath := part[5 : len(part)-1]
 					specVal := GetProp(store, S_DSPEC)
 					if specVal != nil {
-						result := GetPath(subpath, specVal)
+						result := GetPath(specVal, subpath)
 						part = Stringify(result)
 					}
 				} else if inj != nil && strings.HasPrefix(part, "$META:") {
 					// $META:metapath$ -> get meta value, use as path part
 					subpath := part[6 : len(part)-1]
-					result := GetPath(subpath, inj.Meta)
+					result := GetPath(inj.Meta, subpath)
 					part = Stringify(result)
 				}
 
@@ -1903,7 +2117,7 @@ func GetPath(path any, store any, injdefs ...*Injection) any {
 							}
 
 							if ascends <= len(dpath) {
-								val = GetPath(fullpath, store)
+								val = GetPath(store, fullpath)
 							} else {
 								val = nil
 							}
@@ -2030,7 +2244,7 @@ func _injectStr(
 		}
 
 		// Get the extracted path reference.
-		out := GetPath(pathref, store, inj)
+		out := GetPath(store, pathref, inj)
 
 		return out
 	}
@@ -2048,7 +2262,7 @@ func _injectStr(
 		if nil != inj {
 			inj.Full = false
 		}
-		found := GetPath(ref, store, inj)
+		found := GetPath(store, ref, inj)
 
 		if nil == found {
 			return S_MT
@@ -2195,11 +2409,6 @@ func Inject(
 				// Perform the val mode injection on the child value.
 				Inject(childval, store, childinj)
 
-				// The injection may modify child processing.
-				nkI = childinj.KeyI
-				nodekeys = childinj.Keys.List
-				val = childinj.Parent
-
 				// Perform the key:post mode injection on the child key.
 				childinj.Mode = M_KEYPOST
 				_injectStr(nodekey, store, childinj)
@@ -2394,7 +2603,7 @@ var Transform_MERGE Injector = func(
 		}
 
 		// Remove the $MERGE command from a parent map.
-    DelProp(inj.Parent, inj.Key)
+		DelProp(inj.Parent, inj.Key)
 
 		list, ok := _asList(args)
 		if !ok {
@@ -2416,7 +2625,6 @@ var Transform_MERGE Injector = func(
 	return nil
 }
 
-
 // Convert a node to a list.
 // Format: ['`$EACH`', '`source-path-of-node`', child-template]
 var Transform_EACH Injector = func(
@@ -2453,7 +2661,7 @@ var Transform_EACH Injector = func(
 
 	// Source data.
 	srcstore := GetProp(store, inj.Base, store)
-	src := GetPath(srcpath, srcstore, inj)
+	src := GetPath(srcstore, srcpath, inj)
 	srctype := Typify(src)
 
 	// Create parallel data structures
@@ -2518,9 +2726,7 @@ var Transform_EACH Injector = func(
 		copy(tpath, inj.Path.List[:len(inj.Path.List)-1])
 
 		dpath := []string{S_DTOP}
-		for _, p := range strings.Split(srcpath, S_DT) {
-			dpath = append(dpath, p)
-		}
+		dpath = append(dpath, strings.Split(srcpath, S_DT)...)
 		dpath = append(dpath, "$:"+ckey)
 
 		// Parent structure.
@@ -2562,7 +2768,6 @@ var Transform_EACH Injector = func(
 	return nil
 }
 
-
 // transform_PACK => `$PACK`
 var Transform_PACK Injector = func(
 	inj *Injection,
@@ -2604,7 +2809,7 @@ var Transform_PACK Injector = func(
 
 	// Source data
 	srcstore := GetProp(store, inj.Base, store)
-	src := GetPath(srcpath, srcstore, inj)
+	src := GetPath(srcstore, srcpath, inj)
 
 	// Prepare source as a list.
 	if !IsList(src) {
@@ -2654,7 +2859,7 @@ var Transform_PACK Injector = func(
 				return ks
 			}
 		} else {
-			kval := GetPath(keypathStr, srcItem, inj)
+			kval := GetPath(srcItem, keypathStr, inj)
 			if ks, ok := kval.(string); ok {
 				return ks
 			}
@@ -2706,9 +2911,7 @@ var Transform_PACK Injector = func(
 		}
 
 		dpath := []string{S_DTOP}
-		for _, p := range strings.Split(srcpath, S_DT) {
-			dpath = append(dpath, p)
-		}
+		dpath = append(dpath, strings.Split(srcpath, S_DT)...)
 		dpath = append(dpath, "$:"+ckey)
 
 		tcur := map[string]any{ckey: tsrc}
@@ -2780,9 +2983,9 @@ var Transform_REF Injector = func(
 	if len(inj.Path.List) > 1 {
 		dpath = append(dpath, inj.Path.List[1:]...)
 	}
-	refResult := GetPath(refpath, spec, &Injection{
+	refResult := GetPath(spec, refpath, &Injection{
 		Dpath:   dpath,
-		Dparent: GetPath(dpath, spec),
+		Dparent: GetPath(spec, dpath),
 	})
 
 	hasSubRef := false
@@ -2807,8 +3010,8 @@ var Transform_REF Injector = func(
 	}
 	tpath = tpath[:len(tpath)-1]
 
-	tcur := GetPath(cpath, store)
-	tval := GetPath(tpath, store)
+	tcur := GetPath(store, cpath)
+	tval := GetPath(store, tpath)
 
 	var rval any
 
@@ -2935,7 +3138,6 @@ var Transform_APPLY Injector = func(
 	return out
 }
 
-
 // transform_FORMAT => `$FORMAT`
 // injectChild resolves a child value via injection, going up the injection chain
 // to get the correct data context.
@@ -3120,8 +3322,7 @@ var Transform_FORMAT Injector = func(
 		return nil
 	}
 
-	var out any
-	out = Walk(resolved, formatter)
+	out := Walk(resolved, formatter)
 
 	// Set on parent output
 	if target != nil {
@@ -3131,28 +3332,71 @@ var Transform_FORMAT Injector = func(
 	return out
 }
 
-
 // ---------------------------------------------------------------------
 // Transform function: top-level
 
+// Transform returns an error when the transform collected any - an unknown
+// `$FORMAT`, say - and the caller did not supply their own error collector.
+// Canonical TypeScript throws at exactly that point (StructUtility.ts:
+// `const generr = 0 < size(errs) && !collect`), and Validate in this port
+// already surfaces it the same way. Transform did not, so every error a
+// transform collected was silently dropped: `Transform(nil, ["`$FORMAT`",
+// "not-a-format", "a"])` returned nil rather than reporting the unknown
+// format. The corpus pins that behaviour in transform/format, a group this
+// port's own test runner used to skip in full.
 func Transform(
 	data any, // source data
 	spec any, // transform specification
 	injdefs ...*Injection,
-) any {
+) (any, error) {
 	if len(injdefs) > 0 && injdefs[0] != nil {
 		injdef := injdefs[0]
-		return TransformModifyHandler(
+
+		// A caller-supplied collector means the errors are theirs to
+		// inspect, and canonical generates nothing.
+		collecterrs := injdef.Errs
+		errs := collecterrs
+		if nil == errs {
+			errs = ListRefCreate[any]()
+		}
+
+		out := TransformModifyHandler(
 			data,
 			spec,
 			injdef.Extra,
 			injdef.Modify,
 			injdef.Handler,
-			injdef.Errs,
+			errs,
 			injdef.Meta,
 		)
+
+		if nil != collecterrs {
+			return out, nil
+		}
+		return out, generatederr(errs)
 	}
-	return TransformModify(data, spec, nil, nil)
+
+	out, errs := transformModifyCore(data, spec, nil, nil)
+	return out, generatederr(errs)
+}
+
+// generatederr joins collected error strings into the single error canonical
+// throws. Nil when nothing was collected.
+func generatederr(errs *ListRef[any]) error {
+	if nil == errs || 0 == len(errs.List) {
+		return nil
+	}
+
+	errmsgs := make([]string, len(errs.List))
+	for i, e := range errs.List {
+		if s, ok := e.(string); ok {
+			errmsgs[i] = s
+		} else {
+			errmsgs[i] = fmt.Sprintf("%v", e)
+		}
+	}
+
+	return errors.New(strings.Join(errmsgs, " | "))
 }
 
 // TransformModifyHandler is like TransformModify but allows a custom handler and injection inj.
@@ -3187,10 +3431,6 @@ func TransformModifyHandler(
 		}
 	}
 
-	if extraData == nil {
-		extraData = map[string]any{}
-	}
-
 	var dataClone any
 	if data == nil {
 		dataClone = nil
@@ -3205,10 +3445,10 @@ func TransformModifyHandler(
 	_ = origspec
 
 	store := map[string]any{
-		S_DTOP: dataClone,
+		S_DTOP:  dataClone,
 		S_DSPEC: func() any { return origspec },
-		"$BT": func() any { return S_BT },
-		"$DS": func() any { return S_DS },
+		"$BT":   func() any { return S_BT },
+		"$DS":   func() any { return S_DS },
 		"$WHEN": func() any {
 			return time.Now().UTC().Format(time.RFC3339)
 		},
@@ -3280,10 +3520,7 @@ func transformModifyCore(
 		}
 	}
 
-	// Create empty maps if nil
-	if extraData == nil {
-		extraData = map[string]any{}
-	}
+	// Create empty map if nil
 	if data == nil {
 		data = map[string]any{}
 	}
@@ -3396,42 +3633,6 @@ var validate_STRING Injector = func(
 	return out
 }
 
-var validate_NUMBER Injector = func(
-	inj *Injection,
-	_val any,
-	ref *string,
-	store any,
-) any {
-	out := GetProp(inj.Dparent, inj.Key)
-
-	t := Typify(out)
-	if 0 == (T_number & t) {
-		msg := _invalidTypeMsg(inj.Path.List, S_number, Typename(t), out)
-		inj.Errs.Append(msg)
-		return nil
-	}
-
-	return out
-}
-
-var validate_BOOLEAN Injector = func(
-	inj *Injection,
-	_val any,
-	ref *string,
-	store any,
-) any {
-	out := GetProp(inj.Dparent, inj.Key)
-
-	t := Typify(out)
-	if 0 == (T_boolean & t) {
-		msg := _invalidTypeMsg(inj.Path.List, S_boolean, Typename(t), out)
-		inj.Errs.Append(msg)
-		return nil
-	}
-
-	return out
-}
-
 var validate_OBJECT Injector = func(
 	inj *Injection,
 	_val any,
@@ -3446,7 +3647,7 @@ var validate_OBJECT Injector = func(
 		msg := _invalidTypeMsg(inj.Path.List, S_object, Typename(t), out)
 		inj.Errs.Append(msg)
 
-    return nil
+		return nil
 	}
 
 	return out
@@ -3470,24 +3671,6 @@ var validate_ARRAY Injector = func(
 	return out
 }
 
-var validate_FUNCTION Injector = func(
-	inj *Injection,
-	_val any,
-	ref *string,
-	store any,
-) any {
-	out := GetProp(inj.Dparent, inj.Key)
-
-	t := Typify(out)
-	if 0 == (T_function & t) {
-		msg := _invalidTypeMsg(inj.Path.List, S_function, Typename(t), out)
-		inj.Errs.Append(msg)
-		return nil
-	}
-
-	return out
-}
-
 var validate_ANY Injector = func(
 	inj *Injection,
 	_val any,
@@ -3632,10 +3815,20 @@ var validate_CHILD Injector = func(
 			inj.Parent = newParent
 		}
 
-		inj.KeyI = 0
+		// NOTE: modifying inj! This extends the child value loop in inject
+		// to cover every cloned child.
+		for ckeyI := len(inj.Keys.List); ckeyI < length; ckeyI++ {
+			inj.Keys.Append(StrKey(ckeyI))
+		}
 
-		out := GetProp(dparent, 0)
-		return out
+		// Restart the child value loop at the first element (the loop
+		// increments KeyI on resume) so that the first element is also
+		// validated against the child template.
+		inj.KeyI = -1
+
+		// SKIP leaves the cloned child template in place at the first
+		// element so the resumed loop can validate it.
+		return SKIP
 	}
 
 	return nil
@@ -3680,7 +3873,7 @@ func init_validate_ONE() {
 
 			// Clean up structure by replacing [$ONE, ...] with current value
 			SetProp(grandparent, grandkey, inj.Dparent)
-      inj.Parent = inj.Dparent
+			inj.Parent = inj.Dparent
 
 			// Adjust the path
 			inj.Path.List = inj.Path.List[:len(inj.Path.List)-1]
@@ -3786,7 +3979,7 @@ func init_validate_EXACT() {
 
 			// Clean up structure by replacing [$EXACT, ...] with current value
 			SetProp(grandparent, grandkey, inj.Dparent)
-      inj.Parent = inj.Dparent
+			inj.Parent = inj.Dparent
 
 			// Adjust the path
 			inj.Path.List = inj.Path.List[:len(inj.Path.List)-1]
@@ -3806,21 +3999,21 @@ func init_validate_EXACT() {
 			// See if we can find an exact value match
 			var currentStr *string
 			for _, tval := range tvals {
-        exactMatch := false
-
-        if !exactMatch {
-          // Unwrap ListRefs for comparison since data and spec may have
-          // different wrapping levels.
-          unwrapFlags := map[string]bool{"unwrap": true}
-          utval := CloneFlags(tval, unwrapFlags)
-          ucurrent := CloneFlags(inj.Dparent, unwrapFlags)
-          exactMatch = reflect.DeepEqual(utval, ucurrent)
-        }
-        
+				exactMatch := false
+
+				if !exactMatch {
+					// Unwrap ListRefs for comparison since data and spec may have
+					// different wrapping levels.
+					unwrapFlags := map[string]bool{"unwrap": true}
+					utval := CloneFlags(tval, unwrapFlags)
+					ucurrent := CloneFlags(inj.Dparent, unwrapFlags)
+					exactMatch = reflect.DeepEqual(utval, ucurrent)
+				}
+
 				if !exactMatch && IsNode(tval) {
 					if nil == currentStr {
 						tmpstr := Stringify(inj.Dparent)
-            currentStr = &tmpstr
+						currentStr = &tmpstr
 					}
 					tvalStr := Stringify(tval)
 					exactMatch = tvalStr == *currentStr
@@ -3900,7 +4093,7 @@ func makeValidation(exact bool) Modify {
 		ptype := Typify(pval)
 
 		// Delete any special commands remaining.
-		if 0 < (T_string & ptype) && pval != nil {
+		if 0 < (T_string&ptype) && pval != nil {
 			if strVal, ok := pval.(string); ok && strings.Contains(strVal, S_DS) {
 				return
 			}
@@ -3931,6 +4124,10 @@ func makeValidation(exact bool) Modify {
 
 			// Empty spec object {} means object can be open (any keys).
 			if len(pkeys) > 0 && GetProp(pval, "`$OPEN`") != true {
+				// Literal presence: the shape DECLARES ckey even when its value
+				// is nil. Canonical uses `NONE === _lookup`; HasKey is Group A
+				// (value-based) and would drop records with a nil field from an
+				// open ($AND) select. Test map key presence on the shape (pval).
 				badkeys := []string{}
 				pvalMap, pvalIsMap := pval.(map[string]any)
 				for _, ckey := range ckeys {
@@ -3987,8 +4184,6 @@ func makeValidation(exact bool) Modify {
 			// Spec value was a default, copy over data
 			SetProp(parent, key, cval)
 		}
-
-		return
 	}
 }
 
@@ -4002,7 +4197,7 @@ var _validatehandler Injector = func(
 	ref *string,
 	store any,
 ) any {
-	out := val
+	var out any
 
 	refStr := ""
 	if ref != nil {
@@ -4046,7 +4241,6 @@ func Validate(
 		errs = ListRefCreate[any]()
 	}
 
-  
 	// Initialize validate_ONE if not already initialized.
 	// This avoids a circular reference error, validate_ONE calls Validate.
 	if validate_ONE == nil {
@@ -4062,7 +4256,7 @@ func Validate(
 	store := map[string]any{
 		// Remove the transform commands
 		"$DELETE": nil,
-		"$COPY":   nil, 
+		"$COPY":   nil,
 		"$KEY":    nil,
 		"$META":   nil,
 		"$MERGE":  nil,
@@ -4093,10 +4287,8 @@ func Validate(
 	}
 
 	// Add any extra validation commands
-	if extra != nil {
-		for k, fn := range extra {
-			store[k] = fn
-		}
+	for k, fn := range extra {
+		store[k] = fn
 	}
 
 	// A special top level value to collect errors
@@ -4126,7 +4318,7 @@ func Validate(
 	// Run the transformation with validation and _validatehandler
 	out := TransformModifyHandler(data, spec, store, validationFn, _validatehandler, errs, meta)
 
-	// Generate an error if we collected any errors and the caller didn't provide 
+	// Generate an error if we collected any errors and the caller didn't provide
 	// their own error collection
 	var err error
 	generr := 0 < len(errs.List) && collecterrs == nil
@@ -4146,7 +4338,6 @@ func Validate(
 	return out, err
 }
 
-
 // Mode names for injection modes.
 var MODENAME = map[int]string{
 	M_VAL:     "val",
@@ -4207,7 +4398,6 @@ func InjectorArgs(argTypes []int, args []any) []any {
 	return found
 }
 
-
 // Select helpers - internal injectors for query matching.
 
 var select_AND Injector = func(
@@ -4221,7 +4411,7 @@ var select_AND Injector = func(
 
 		pathList := inj.Path.List
 		ppath := pathList[:len(pathList)-1]
-		point := GetPath(ppath, store)
+		point := GetPath(store, ppath)
 
 		vstore := Merge([]any{map[string]any{}, store})
 		SetProp(vstore, S_DTOP, point)
@@ -4257,7 +4447,7 @@ var select_OR Injector = func(
 
 		pathList := inj.Path.List
 		ppath := pathList[:len(pathList)-1]
-		point := GetPath(ppath, store)
+		point := GetPath(store, ppath)
 
 		vstore := Merge([]any{map[string]any{}, store})
 		SetProp(vstore, S_DTOP, point)
@@ -4294,7 +4484,7 @@ var select_NOT Injector = func(
 
 		pathList := inj.Path.List
 		ppath := pathList[:len(pathList)-1]
-		point := GetPath(ppath, store)
+		point := GetPath(store, ppath)
 
 		vstore := Merge([]any{map[string]any{}, store})
 		SetProp(vstore, S_DTOP, point)
@@ -4328,7 +4518,7 @@ var select_CMP Injector = func(
 
 		pathList := inj.Path.List
 		ppath := pathList[:len(pathList)-1]
-		point := GetPath(ppath, store)
+		point := GetPath(store, ppath)
 
 		pass := false
 		refStr := ""
@@ -4379,7 +4569,6 @@ var select_CMP Injector = func(
 	return nil
 }
 
-
 // Internal exact-mode validation for Select.
 // Like Validate but uses exact scalar comparison.
 func validateCollectExact(
@@ -4431,10 +4620,8 @@ func validateCollectExact(
 		"$EXACT":    validate_EXACT,
 	}
 
-	if extra != nil {
-		for k, fn := range extra {
-			store[k] = fn
-		}
+	for k, fn := range extra {
+		store[k] = fn
 	}
 
 	store["$ERRS"] = errs
@@ -4443,7 +4630,6 @@ func validateCollectExact(
 	TransformModifyHandler(data, spec, store, makeValidation(true), _validatehandler, errs, meta)
 }
 
-
 // Select children from a node that match a query.
 // Uses validate internally with query operators ($AND, $OR, $NOT,
 // $GT, $LT, $GTE, $LTE, $LIKE).
@@ -4515,7 +4701,6 @@ func Select(children any, query any) []any {
 	return results
 }
 
-
 // Internal utilities
 // ==================
 
@@ -4529,25 +4714,14 @@ func ListRefCreate[T any]() *ListRef[T] {
 	}
 }
 
-
 func (l *ListRef[T]) Append(elem T) {
 	l.List = append(l.List, elem)
 }
 
-
 func (l *ListRef[T]) Prepend(elem T) {
 	l.List = append([]T{elem}, l.List...)
 }
 
-func _join(vals []any, sep string) string {
-	strVals := make([]string, len(vals))
-	for i, v := range vals {
-		strVals[i] = fmt.Sprint(v)
-	}
-	return strings.Join(strVals, sep)
-}
-
-
 func _invalidTypeMsg(path []string, needtype string, vt string, v any, whence ...string) string {
 	vs := "no value"
 	if v != nil {
@@ -4575,14 +4749,6 @@ func _invalidTypeMsg(path []string, needtype string, vt string, v any, whence ..
 	return message + "."
 }
 
-func _getType(v any) string {
-	if nil == v {
-		return "nil"
-	}
-	return reflect.TypeOf(v).String()
-}
-
-
 // StrKey converts different types of keys to string representation.
 // String keys are returned as is.
 // Number keys are converted to strings.
@@ -4620,7 +4786,6 @@ func StrKey(key any) string {
 	}
 }
 
-
 func _resolveStrings(input []any) []string {
 	var result []string
 
@@ -4635,7 +4800,6 @@ func _resolveStrings(input []any) []string {
 	return result
 }
 
-
 // Extract a bare []any from either a []any or a *ListRef[any].
 // Recursively unwrap *ListRef[any] to []any for JSON marshaling.
 func _unwrapListRefs(val any) any {
@@ -4680,7 +4844,6 @@ func _asList(val any) ([]any, bool) {
 	return nil, false
 }
 
-
 func _listify(src any) []any {
 	if lr, ok := src.(*ListRef[any]); ok {
 		return lr.List
@@ -4708,7 +4871,6 @@ func _listify(src any) []any {
 	return nil
 }
 
-
 // toFloat64 helps unify numeric types for floor conversion.
 func _toFloat64(val any) (float64, error) {
 	switch n := val.(type) {
@@ -4742,12 +4904,11 @@ func _toFloat64(val any) (float64, error) {
 	}
 }
 
-
 // _parseInt is a helper to convert a string to int safely.
 func _parseInt(s string) (int, error) {
 	// We'll do a very simple parse:
 	var x int
-	var sign int = 1
+	sign := 1
 	for i, c := range s {
 		if c == '-' && i == 0 {
 			sign = -1
@@ -4761,15 +4922,12 @@ func _parseInt(s string) (int, error) {
 	return x * sign, nil
 }
 
-
 type ParseIntError struct{ input string }
 
-
 func (e *ParseIntError) Error() string {
 	return "cannot parse int from: " + e.input
 }
 
-
 func _makeArrayType(values []any, target any) any {
 	targetElem := reflect.TypeOf(target).Elem()
 	out := reflect.MakeSlice(reflect.SliceOf(targetElem), len(values), len(values))
@@ -4786,7 +4944,6 @@ func _makeArrayType(values []any, target any) any {
 	return out.Interface()
 }
 
-
 func _stringifyValue(v any) string {
 	switch vv := v.(type) {
 	case string:
@@ -4797,97 +4954,3 @@ func _stringifyValue(v any) string {
 		return Stringify(v)
 	}
 }
-
-
-
-
-// DEBUG
-
-func fdt(data any) string {
-	return fdti(data, "")
-}
-
-func fdti(data any, indent string) string {
-	result := ""
-
-	if data == nil {
-		return indent + "nil\n"
-	}
-
-	// Get a pointer for memory address
-	memoryAddr := "0x???"
-	val := reflect.ValueOf(data)
-
-	// For non-pointer types that are addressable, get their pointer
-	if val.Kind() != reflect.Ptr && val.CanAddr() {
-		ptr := val.Addr()
-		memoryAddr = fmt.Sprintf("0x%x", ptr.Pointer())
-	} else if val.Kind() == reflect.Ptr {
-		// For pointer types, use the pointer value directly
-		memoryAddr = fmt.Sprintf("0x%x", val.Pointer())
-	} else if val.Kind() == reflect.Map || val.Kind() == reflect.Slice {
-		// For maps and slices, use the pointer to internal data
-		memoryAddr = fmt.Sprintf("0x%x", val.Pointer())
-	}
-
-	switch v := data.(type) {
-	case map[string]any:
-		result += indent + fmt.Sprintf("{ @%s\n", memoryAddr)
-		for key, value := range v {
-			result += fmt.Sprintf("%s  \"%s\": %s", indent, key, fdti(value, indent+"  "))
-		}
-		result += indent + "}\n"
-
-	case []any:
-		result += indent + fmt.Sprintf("[ @%s\n", memoryAddr)
-		for _, value := range v {
-			result += fmt.Sprintf("%s  - %s", indent, fdti(value, indent+"  "))
-		}
-		result += indent + "]\n"
-
-	default:
-		// Check if it's a struct using reflection
-		typ := val.Type()
-
-		// Handle pointers by dereferencing
-		isPtr := false
-		if val.Kind() == reflect.Ptr {
-			isPtr = true
-			if val.IsNil() {
-				return indent + "nil\n"
-			}
-			val = val.Elem()
-			typ = val.Type()
-		}
-
-		if val.Kind() == reflect.Struct {
-			structName := typ.Name()
-			if isPtr {
-				structName = "*" + structName
-			}
-			result += indent + fmt.Sprintf("struct %s @%s {\n", structName, memoryAddr)
-
-			// Iterate over all fields of the struct
-			for i := 0; i < val.NumField(); i++ {
-				field := val.Field(i)
-				fieldType := typ.Field(i)
-
-				// Skip unexported fields (lowercase field names)
-				if !fieldType.IsExported() {
-					continue
-				}
-
-				fieldName := fieldType.Name
-				fieldValue := field.Interface()
-
-				result += fmt.Sprintf("%s  %s: %s", indent, fieldName, fdti(fieldValue, indent+"  "))
-			}
-			result += indent + "}\n"
-		} else {
-			// For non-struct types, just format value with its type
-			result += fmt.Sprintf("%v (%s) @%s\n", v, reflect.TypeOf(v), memoryAddr)
-		}
-	}
-
-	return result
-}