@voxgig/create-sdkgen 0.24.0 → 0.25.0

package/project/standard/.sdk/test/primary/featureInit.aon

@@ -1,14 +1,4 @@
 
-# PENDING — this section is deliberately empty.
-#
-# featureInit(ctx, f) calls f.init(ctx, fopts). `init` is a function, and a
-# fixture compiles to JSON, so the subject of the test cannot be expressed
-# here at all. Covered per-language by the feature suites.
-#
-# An empty `set` runs ZERO cases. Runners must not treat that as a pass by
-# accident: `basic: pending` below is the MACHINE-READABLE form of this note,
-# so the guard travels into test.json with the fixture instead of living only
-# in a comment the consumer never sees.
 
 basic: pending: 'featureInit calls f.init(ctx, fopts); init is a function, and a fixture compiles to JSON, so the subject cannot be expressed here.'
 basic: set: []

package/project/standard/.sdk/test/primary/fetcher.aon

@@ -1,14 +1,4 @@
 
-# PENDING — this section is deliberately empty.
-#
-# Needs a live or mocked transport and a client instance; the shared runner
-# has no transport-injection hook. Covered per-language by the netsim and
-# feature suites until this fixture can express a transport.
-#
-# An empty `set` runs ZERO cases. Runners must not treat that as a pass by
-# accident: `basic: pending` below is the MACHINE-READABLE form of this note,
-# so the guard travels into test.json with the fixture instead of living only
-# in a comment the consumer never sees.
 
 basic: pending: 'Needs a live or mocked transport and a client instance; the shared runner has no transport-injection hook.'
 basic: set: []

package/project/standard/.sdk/test/primary/makeFetchDef.aon

@@ -1,14 +1,4 @@
 
-# PENDING — this section is deliberately empty.
-#
-# Depends on a fully built ctx (spec + point + options) that the shared
-# runner cannot assemble from a literal map. Covered indirectly by
-# makeSpec/makeUrl, and by the per-language pipeline suites.
-#
-# An empty `set` runs ZERO cases. Runners must not treat that as a pass by
-# accident: `basic: pending` below is the MACHINE-READABLE form of this note,
-# so the guard travels into test.json with the fixture instead of living only
-# in a comment the consumer never sees.
 
 basic: pending: 'Depends on a fully built ctx (spec + point + options) that the runner cannot assemble from a literal map.'
 basic: set: []

package/project/standard/.sdk/test/primary/makePoint.aon

@@ -1,22 +1,4 @@
 
-# makePoint chooses which endpoint definition ("point") an operation call
-# should use, and records it on ctx.point.
-#
-# The whole selection is driven by DATA: `op` is rebuilt by Context from
-# `opname` + `entity.name` + `config.entity.<name>.op.<opname>.points`, and
-# `options.allow.op` gates the call. So every branch below is expressible as
-# a literal ctx, contrary to the deferral note this fixture used to carry,
-# which claimed it needed a real client.
-#
-# Errors are RETURNED, not thrown, and their JSON embeds a random ctx id, so
-# the error cases assert `match: out: code` rather than a whole-value `out`.
-# Go returns the error as a second result instead, and its runner normalises
-# it to the same `{code}` shape.
-#
-# `allow.op` is a COMMA-SEPARATED STRING, not a list — that is what the client
-# actually carries. Go reads it with strings.Contains and type-asserts to
-# string, so a list here silently denies every operation; TS's .includes()
-# accepts either and would have hidden the mismatch.
 
 basic: set: [
 
@@ -59,8 +41,6 @@ basic: set: [
     match: { out: { code: 'point_no_points' } }
   }
 
-  # Two points: `select.exist` picks the one whose required keys are present
-  # in the match. `id` is supplied, so the by-id point wins.
   {
     ctx: {
       opname: 'list'
@@ -75,8 +55,6 @@ basic: set: [
     out: { method: 'GET', path: ['byid'], select: { exist: ['id'] } }
   }
 
-  # Same two points, but `id` is absent — the exist check fails and selection
-  # falls through to the unconstrained point.
   {
     ctx: {
       opname: 'list'

package/project/standard/.sdk/test/primary/makeResult.aon

@@ -1,18 +1,4 @@
 
-# PENDING — this section is deliberately empty.
-#
-# makeResult needs a ctx carrying a constructed Spec AND Result, built via the
-# SDK's own NewSpec/NewResult constructors, plus the absent-error path for
-# each. The runner builds ctx from a literal map and has no constructor hook,
-# so these cannot be expressed here yet — covered per-language today (e.g.
-# go's makeResult-basic / -no-spec / -no-result), which is exactly the drift
-# this corpus exists to remove. Promoting it needs a runner change, not just
-# fixture data.
-#
-# An empty `set` runs ZERO cases. Runners must not treat that as a pass by
-# accident: `basic: pending` below is the MACHINE-READABLE form of this note,
-# so the guard travels into test.json with the fixture instead of living only
-# in a comment the consumer never sees.
 
 basic: pending: 'Needs a ctx carrying a Spec AND Result built via the SDK constructors; the runner builds ctx from a literal map and has no constructor hook.'
 basic: set: []

package/project/standard/.sdk/test/primary/prepareAuth.aon

@@ -1,10 +1,5 @@
 
 DEF: {
-  # auth pinned explicitly (not left to a spec's own derived prefix/scheme):
-  # this corpus tests the raw single-token mechanics in isolation, so it
-  # must not silently inherit whatever a given SDK's real spec declares
-  # (e.g. genuine HTTP Basic Auth, a non-empty prefix, two credentials) -
-  # that has its own dedicated coverage elsewhere.
   setup: a: { apikey: 'APIKEY01', auth: { prefix: '', basic: false } }
 }
 

package/project/standard/.sdk/test/primary/preparePath.aon

@@ -1,11 +1,4 @@
 
-# preparePath: join ctx.point.parts with '/', dropping empty segments.
-#
-# Path templating is the highest-risk request-shaping step, and this fixture
-# was an empty `set: []` — so every language "passed" it while running zero
-# cases. The cases below were lifted from the per-language hand-written tests
-# (go/py) that had drifted out of the shared corpus, plus the empty/blank
-# segment edges that `join(..., true)` is specifically responsible for.
 
 basic: set: [
   # Multi-segment path, placeholder left intact (params are substituted later,

package/project/standard/.sdk/test/struct/nullsem.aon

@@ -1,102 +1,21 @@
 
-# STORED-NULL SEMANTICS.
-#
-# One question, asked of every reader: when a key is PRESENT and holds a JSON
-# null, is that "no value" (the same as an absent key) or is it a value?
-#
-# Nothing in the corpus asked it before. `minor.getprop` and `minor.haskey`
-# have ~50 cases each and not one stores a null: every entry is an absent key
-# or a non-null value. So the ports diverged silently, and they HAVE:
-#
-#   port   getprop({x:null},'x','ALT')   haskey({x:null},'x')
-#   ────   ───────────────────────────   ────────────────────
-#   go     'ALT'                         false
-#   py     'ALT'                         false
-#   perl   'ALT'                         false
-#   rb      null                         true
-#   php     null                         true
-#   js      null                         true
-#
-# That is not academic. It is the direct cause of the `auth: null` bug family:
-# `auth: null` is the documented way to suppress auth outright, and where a
-# stored null reads as "no value" the optspec `auth` default fires, the
-# suppression becomes "use the default auth", and the credential the caller
-# withheld goes out on the wire.
-#
-# 0.3.2 answers "no value" — the top three rows. This section pins that.
-#
-#
-# THIS SECTION IS OPT-IN, AND DELIBERATELY SO.
-#
-# Half the tree still vendors a struct that answers the other way. Putting
-# these cases in `minor` would red those targets today and gate the whole
-# corpus on finishing the struct migration everywhere first. Instead a target
-# wires this section up as it migrates:
-#
-#   runsetflags(nullsemSpec["getprop"], {"null": False}, getprop_wrapper)
-#
-# so the section becomes that target's null-semantics gate, and a target that
-# has not migrated simply does not reference it yet.
-#
-#
-# `null: false` IS NOT OPTIONAL HERE.
-#
-# The runner's default fixJSON rewrites every JSON null - on BOTH the `in` and
-# `out` sides - to the string '__NULL__' before the subject ever sees it. Run
-# without the flag, every case below would pass the STRING '__NULL__' as the
-# stored value, which is not a null and is not the question. The section would
-# then pass on every port while asserting nothing about null at all - the
-# exact "green while checking nothing" failure the corpus guards exist to
-# prevent. `minor.getelem` and `minor.clone` already run with the flag for the
-# same reason.
-#
-# With the flag, an entry with NO `out` expects a null result, and `out:` with
-# a value expects that value.
-#
-#
-# VERIFIED AGAINST THE REFERENCE, NOT GUESSED.
-#
-# All 33 cases below were run against upstream @voxgig/struct 0.3.2
-# (typescript/src/StructUtility.ts, the canonical port) and all 33 pass. They
-# are what the reference DOES, not what it was assumed to do.
-#
-# That mattered on the first run: `getprop([null], 0, 'ALT')` was assumed to
-# be a formality and turned out to be a live defect in the py port's vendored
-# copy. Canonical getprop tests `isnode(val)` - map AND list - and then
-# applies the null rule once to whatever it read. The py copy branches on
-# ismap/islist and its list branch does `return val[key]`, an early return
-# that skips the null check entirely, so it hands back the stored null where
-# every other reader would substitute the alt. Its map path is correct, which
-# is why nothing noticed.
-#
-# So py cannot opt in to this section until its vendored struct is resynced.
-# That is the section working as intended: it says "not yet" in a test result
-# instead of in a comment.
-
-
-# Does the ALT fire for a stored null, as it does for an absent key?
+
+
 getprop: {
   set: [
-    # THE CASE. Absent and stored-null must answer alike.
     { in: { val: {x:null}, key: x, alt: 'ALT' }, out: 'ALT' }
     { in: { val: {},       key: x, alt: 'ALT' }, out: 'ALT' }
 
-    # No alt: a stored null reads back as null either way, so this pins that
-    # the rule does not turn a null into something else.
     { in: { val: {x:null}, key: x } }
 
     # A stored null must not leak past its own key.
     { in: { val: {x:null, y:1}, key: y, alt: 'ALT' }, out: 1 }
     { in: { val: {x:1, y:null}, key: x, alt: 'ALT' }, out: 1 }
 
-    # false, 0 and '' are VALUES, not absence. A port that collapses "nullish"
-    # to "falsy" passes every case above and fails these.
     { in: { val: {x:false}, key: x, alt: 'ALT' }, out: false }
     { in: { val: {x:0},     key: x, alt: 'ALT' }, out: 0 }
     { in: { val: {x:''},    key: x, alt: 'ALT' }, out: '' }
 
-    # Lists too: index 0 holding a null is the list-shaped form of the same
-    # question, and a port can easily fix one and not the other.
     { in: { val: [null], key: 0, alt: 'ALT' }, out: 'ALT' }
     { in: { val: [null, 1], key: 1, alt: 'ALT' }, out: 1 }
   ]
@@ -111,8 +30,6 @@ getelem: {
     { in: { val: [10, null, 30], key: 1, alt: 'ALT' }, out: 'ALT' }
     { in: { val: [10, null, 30], key: 2, alt: 'ALT' }, out: 30 }
 
-    # Negative indices are getelem's whole reason for existing; a stored null
-    # at a negative index is the case a port is most likely to miss.
     { in: { val: [10, null], key: -1, alt: 'ALT' }, out: 'ALT' }
     { in: { val: [null, 20], key: -1, alt: 'ALT' }, out: 20 }
 
@@ -137,15 +54,12 @@ getpath: {
 }
 
 
-# Presence, asked directly. This is the reader the auth-null fix needs in
-# every port, and the one whose answer splits the tree.
 haskey: {
   set: [
     { in: { src: {x:null}, key: x }, out: false }
     { in: { src: {},       key: x }, out: false }
     { in: { src: {x:1},    key: x }, out: true }
 
-    # Again: falsy is not absent.
     { in: { src: {x:false}, key: x }, out: true }
     { in: { src: {x:0},     key: x }, out: true }
     { in: { src: {x:''},    key: x }, out: true }
@@ -156,13 +70,6 @@ haskey: {
 }
 
 
-# The other direction, and the reason `auth: null` is expressible at all:
-# presence is STRUCTURAL. keysof lists a null-valued key, because the key IS
-# there - it is only the READERS above that treat its value as no value.
-#
-# A port that made haskey false by DELETING the key would pass every case
-# above and fail here, and it would also make the suppression unwritable:
-# there would be nothing left for makeOptions to detect.
 keysof: {
   set: [
     { in: {a:null}, out: [a] }

package/project/standard/.sdk/test/struct/select.aon

@@ -2,41 +2,39 @@
 basic: {
   set: [
     # Basic equality matching
-    { in: { query: {age:30}, obj: {a:{name:'Alice',age:30}, b:{name:'Bob',age:25}} }, 
+    { in: { query: {age:30}, obj: {a:{name:'Alice',age:30}, b:{name:'Bob',age:25}} },
       out: [{name:'Alice',age:30,'$KEY':'a'}] }
 
-      { in: { query: {name:'Bob'}, obj: {a:{name:'Alice',age:30}, b:{name:'Bob',age:25}} }, 
+      { in: { query: {name:'Bob'}, obj: {a:{name:'Alice',age:30}, b:{name:'Bob',age:25}} },
       out: [{name:'Bob',age:25,'$KEY':'b'}] }
-    
+
     # Multiple field equality
-    { in: { query: {age:30,city:'NYC'}, obj: {a:{age:30,city:'NYC'}, b:{age:30,city:'LA'}} }, 
+    { in: { query: {age:30,city:'NYC'}, obj: {a:{age:30,city:'NYC'}, b:{age:30,city:'LA'}} },
       out: [{age:30,city:'NYC','$KEY':'a'}] }
-    
-    # Array children
+
     { in: { query: {type:'user'},
-            obj: [{id:1,type:'user'}, {id:2,type:'admin'}, {id:3,type:'user'}] }, 
+            obj: [{id:1,type:'user'}, {id:2,type:'admin'}, {id:3,type:'user'}] },
       out: [{id:1,type:'user','$KEY':0}, {id:3,type:'user','$KEY':2}] }
-    
-    # No matches
-    { in: { query: {age:40}, obj: {a:{age:30}, b:{age:25}} }, 
+
+    { in: { query: {age:40}, obj: {a:{age:30}, b:{age:25}} },
       out: [] }
-    
+
     # Empty query matches all
-    { in: { query: {}, obj: {a:{x:1}, b:{x:2}} }, 
+    { in: { query: {}, obj: {a:{x:1}, b:{x:2}} },
       out: [{x:1,'$KEY':'a'}, {x:2,'$KEY':'b'}] }
-    
+
     # Non-object input
     { in: { query: {x:1}, obj: 'hello' }, out: [] }
     { in: { query: {x:1}, obj: 42 }, out: [] }
     { in: { query: {x:1}, obj: null }, out: [] }
     { in: { query: {x:1}, obj: undefined }, out: [] }
-    
+
     # Deep equality for objects
-    { in: { query: {data:{x:1,y:2}}, obj: {a:{data:{x:1,y:2}}, b:{data:{x:1,y:3}}} }, 
+    { in: { query: {data:{x:1,y:2}}, obj: {a:{data:{x:1,y:2}}, b:{data:{x:1,y:3}}} },
       out: [{data:{x:1,y:2},'$KEY':'a'}] }
-    
+
     # Deep equality for arrays
-    { in: { query: {tags:['a','b']}, obj: {a:{tags:['a','b']}, b:{tags:['a','c']}} }, 
+    { in: { query: {tags:['a','b']}, obj: {a:{tags:['a','b']}, b:{tags:['a','c']}} },
       out: [{tags:['a','b'],'$KEY':'a'}] }
   ]
 }
@@ -44,156 +42,141 @@ basic: {
 operators: {
   set: [
     # `$AND` operator
-    { in: { query: {'`$AND`':[{age:30}, {city:'NYC'}]}, 
-            obj: {a:{age:30,city:'NYC'}, b:{age:30,city:'LA'}, c:{age:25,city:'NYC'}} }, 
+    { in: { query: {'`$AND`':[{age:30}, {city:'NYC'}]},
+            obj: {a:{age:30,city:'NYC'}, b:{age:30,city:'LA'}, c:{age:25,city:'NYC'}} },
       out: [{age:30,city:'NYC','$KEY':'a'}] }
-    
+
     # `$AND` with no matches
-    { in: { query: {'`$AND`':[{age:30}, {city:'Boston'}]}, 
-            obj: {a:{age:30,city:'NYC'}, b:{age:30,city:'LA'}} }, 
+    { in: { query: {'`$AND`':[{age:30}, {city:'Boston'}]},
+            obj: {a:{age:30,city:'NYC'}, b:{age:30,city:'LA'}} },
       out: [] }
-    
-    # `$OR` operator
-    { in: { query: {'`$OR`':['x', 'y']}, 
-            obj: {a:'x', b:'z', c:'y'} }, 
+
+    { in: { query: {'`$OR`':['x', 'y']},
+            obj: {a:'x', b:'z', c:'y'} },
       out: ['x', 'y'] }
 
 
-    # TODO: review
-   
-    # { in: { query: {'$KEY':{'`$OR`':['b', 'c']}}, 
-    #         obj: {a:'x', b:'z', c:'y'} }, 
-    #   out: ['z', 'y'] }
 
-    # { in: { query: {'`$OR`':[{'$KEY':'b'}, {'$KEY':'c'}]}, 
-    #         obj: {a:'x', b:'z', c:'y'} }, 
-    #   out: ['z', 'y'] }
 
-      
-    { in: { query: {'`$OR`':[{age:25}, {age:35}]}, 
-            obj: {a:{age:30}, b:{age:25}, c:{age:35}} }, 
+
+
+    { in: { query: {'`$OR`':[{age:25}, {age:35}]},
+            obj: {a:{age:30}, b:{age:25}, c:{age:35}} },
       out: [{age:25,'$KEY':'b'}, {age:35,'$KEY':'c'}] }
-    
+
     # `$OR` with all matches
-    { in: { query: {'`$OR`':[{type:'user'}, {type:'admin'}]}, 
-            obj: [{type:'user'}, {type:'admin'}, {type:'guest'}] }, 
+    { in: { query: {'`$OR`':[{type:'user'}, {type:'admin'}]},
+            obj: [{type:'user'}, {type:'admin'}, {type:'guest'}] },
       out: [{type:'user','$KEY':0}, {type:'admin','$KEY':1}] }
-    
+
     # Nested `$AND` within `$OR`
-    { in: { query: {'`$OR`':[{'`$AND`':[{role:'user'}, {active:true}]}, {'`$AND`':[{role:'admin'}, {age:30}]}]}, 
-            obj: {a:{role:'admin',age:30,active:true}, b:{role:'user',age:25,active:true}, 
-                  c:{role:'user',age:30,active:false}, d:{role:'admin',age:30,active:false}} }, 
-      out: [{role:'admin',age:30,active:true,'$KEY':'a'}, {role:'user',age:25,active:true,'$KEY':'b'}, 
+    { in: { query: {'`$OR`':[{'`$AND`':[{role:'user'}, {active:true}]}, {'`$AND`':[{role:'admin'}, {age:30}]}]},
+            obj: {a:{role:'admin',age:30,active:true}, b:{role:'user',age:25,active:true},
+                  c:{role:'user',age:30,active:false}, d:{role:'admin',age:30,active:false}} },
+      out: [{role:'admin',age:30,active:true,'$KEY':'a'}, {role:'user',age:25,active:true,'$KEY':'b'},
             {role:'admin',age:30,active:false,'$KEY':'d'}] }
-    
+
     # Complex nested operators
-    { in: { query: {'`$AND`':[{'`$OR`':[{status:'active'}, {status:'pending'}]}, {priority:'high'}]}, 
-            obj: {a:{status:'active',priority:'high'}, b:{status:'active',priority:'low'}, 
-                  c:{status:'pending',priority:'high'}, d:{status:'done',priority:'high'}} }, 
+    { in: { query: {'`$AND`':[{'`$OR`':[{status:'active'}, {status:'pending'}]}, {priority:'high'}]},
+            obj: {a:{status:'active',priority:'high'}, b:{status:'active',priority:'low'},
+                  c:{status:'pending',priority:'high'}, d:{status:'done',priority:'high'}} },
       out: [{status:'active',priority:'high','$KEY':'a'}, {status:'pending',priority:'high','$KEY':'c'}] }
-    
+
     # Empty `$AND` array (should match all)
-    { in: { query: {'`$AND`':[]}, obj: {a:{x:1}, b:{x:2}} }, 
+    { in: { query: {'`$AND`':[]}, obj: {a:{x:1}, b:{x:2}} },
       out: [{x:1,'$KEY':'a'}, {x:2,'$KEY':'b'}] }
-    
+
     # Empty `$OR` array (should match none)
-    { in: { query: {'`$OR`':[]}, obj: {a:{x:1}, b:{x:2}} }, 
+    { in: { query: {'`$OR`':[]}, obj: {a:{x:1}, b:{x:2}} },
       out: [] }
 
 
-    { in: { query: {a:{'`$GT`':10}}, obj: [{a:9},{a:10},{a:11},{a:12}] }, 
+    { in: { query: {a:{'`$GT`':10}}, obj: [{a:9},{a:10},{a:11},{a:12}] },
       out: [{a:11,'$KEY':2},{a:12,'$KEY':3}] }
 
-    { in: { query: {a:{'`$GTE`':10}}, obj: [{a:9},{a:10},{a:11},{a:12}] }, 
+    { in: { query: {a:{'`$GTE`':10}}, obj: [{a:9},{a:10},{a:11},{a:12}] },
       out: [{a:10,'$KEY':1},{a:11,'$KEY':2},{a:12,'$KEY':3}] }
 
-      
-    { in: { query: {b:{'`$LT`':10}}, obj: [{b:9},{b:10},{b:11},{b:12}] }, 
+
+    { in: { query: {b:{'`$LT`':10}}, obj: [{b:9},{b:10},{b:11},{b:12}] },
       out: [{b:9,'$KEY':0}] }
 
-    { in: { query: {b:{'`$LTE`':10}}, obj: [{b:9},{b:10},{b:11},{b:12}] }, 
+    { in: { query: {b:{'`$LTE`':10}}, obj: [{b:9},{b:10},{b:11},{b:12}] },
       out: [{b:9,'$KEY':0},{b:10,'$KEY':1}] }
 
-      
-    { in: { query: {a:b:'`$LT`':10}, obj: [{a:b:9},{a:b:10},{a:b:11},{a:b:12}] }, 
+
+    { in: { query: {a:b:'`$LT`':10}, obj: [{a:b:9},{a:b:10},{a:b:11},{a:b:12}] },
       out: [{a:b:9,'$KEY':0}] }
 
-           
-    { in: { query: {x:{y:20}}, obj: [{x:{y:20,z:220}},{x:{y:21,z:221}}] }, 
+
+    { in: { query: {x:{y:20}}, obj: [{x:{y:20,z:220}},{x:{y:21,z:221}}] },
       out: [{x:{y:20,z:220},'$KEY':0}] }
 
-    { in: { query: {s0:'`$LIKE`':'[aA][bB][cC]'}, obj: [{s0:'DEf'},{s0:'ABc'}] }, 
+    { in: { query: {s0:'`$LIKE`':'[aA][bB][cC]'}, obj: [{s0:'DEf'},{s0:'ABc'}] },
       out: [{s0:'ABc','$KEY':1}] }
 
 
-    { in: { query: {'`$NOT`':10}, obj: [9,10,11] }, 
+    { in: { query: {'`$NOT`':10}, obj: [9,10,11] },
       out: [9,11] }
 
-    { in: { query: {'`$NOT`':{n0:'x'}}, obj: [{n0:x},{n0:y},{n0:z}] }, 
+    { in: { query: {'`$NOT`':{n0:'x'}}, obj: [{n0:x},{n0:y},{n0:z}] },
       out: [{n0:y,'$KEY':1},{n0:z,'$KEY':2}] }
 
     { in: { query: {'`$NOT`':{'`$OR`':[{x:1},{y:2}]}},
-            obj: [{x:1,y:3},{x:2,y:2},{x:3,y:1}] }, 
+            obj: [{x:1,y:3},{x:2,y:2},{x:3,y:1}] },
       out: [{x:3,y:1,'$KEY':2}] }
-      
+
   ]
 }
 
 edge: {
   set: [
     # Mixed equality and operators
-    { in: { query: {type:'user', '`$OR`':[{status:'active'}, {admin:true}]}, 
-            obj: [{type:'user',status:'active'}, {type:'user',status:'inactive',admin:true}, 
-                  {type:'guest',status:'active'}] }, 
+    { in: { query: {type:'user', '`$OR`':[{status:'active'}, {admin:true}]},
+            obj: [{type:'user',status:'active'}, {type:'user',status:'inactive',admin:true},
+                  {type:'guest',status:'active'}] },
       out: [{type:'user',status:'active','$KEY':0}, {type:'user',status:'inactive',admin:true,'$KEY':1}] }
-    
-    
-    { in: { query: {value:q}, obj: {a:{value:q}, b:{value:p},c:{}} }, 
+
+
+    { in: { query: {value:q}, obj: {a:{value:q}, b:{value:p},c:{}} },
       out: [{value:q,'$KEY':'a'}] }
 
-    { in: { query: {value:null}, obj: {a:{value:null}, b:{value:0}, c:{}} }, 
+    { in: { query: {value:null}, obj: {a:{value:null}, b:{value:0}, c:{}} },
       out: [{value:null,'$KEY':'a'}] }
-    
-    { in: { query: {active:true}, obj: {a:{active:true}, b:{active:false}, c:{active:1}} }, 
+
+    { in: { query: {active:true}, obj: {a:{active:true}, b:{active:false}, c:{active:1}} },
       out: [{active:true,'$KEY':'a'}] }
-    
+
     # Number comparison (exact match)
-    { in: { query: {count:0}, obj: {a:{count:0}, b:{count:false}, c:{count:'0'}} }, 
+    { in: { query: {count:0}, obj: {a:{count:0}, b:{count:false}, c:{count:'0'}} },
       out: [{count:0,'$KEY':'a'}] }
 
-      
-    { in: { query: {'`$OR`':[{a:1},{a:2}]}, obj: [{a:0}, {a:1}, {a:2}, {a:3}] }, 
+
+    { in: { query: {'`$OR`':[{a:1},{a:2}]}, obj: [{a:0}, {a:1}, {a:2}, {a:3}] },
       out: [{a:1,'$KEY':1}, {a:2,'$KEY':2}] }
 
-    { in: { query: {a:{'`$OR`':[10,20]}}, obj: [{a:0}, {a:10}, {a:20}, {a:30}] }, 
+    { in: { query: {a:{'`$OR`':[10,20]}}, obj: [{a:0}, {a:10}, {a:20}, {a:30}] },
       out: [{a:10,'$KEY':1}, {a:20,'$KEY':2}] }
 
     { in: { query: {a2:{'`$OR`':[{b2:1},{b2:2}]}},
-            obj: [{a2:{b2:0}}, {a2:{b2:1}}, {a2:{b2:2}}, {a2:{b2:3}}] }, 
+            obj: [{a2:{b2:0}}, {a2:{b2:1}}, {a2:{b2:2}}, {a2:{b2:3}}] },
       out: [{a2:{b2:1},'$KEY':1}, {a2:{b2:2},'$KEY':2}] }
 
-    { in: { query: {'`$OR`':[{a3:{'`$OR`':[1]}}]}, obj: [{a3:0}, {a3:1}, {a3:2}] }, 
+    { in: { query: {'`$OR`':[{a3:{'`$OR`':[1]}}]}, obj: [{a3:0}, {a3:1}, {a3:2}] },
       out: [{a3:1,'$KEY':1}] }
 
 
     { in: { query: {c0:{'`$AND`':[{x:1},{y:2}]}},
-            obj: [{c0:{x:1,y:3,z:0}}, {c0:{x:1,y:2,z:1}}] }, 
+            obj: [{c0:{x:1,y:3,z:0}}, {c0:{x:1,y:2,z:1}}] },
       out: [{c0:{x:1,y:2,z:1},'$KEY':1}] }
 
     { in: { query: {c0:{'`$AND`':[{x:1},{y:{'`$OR`':[2,3]}}]}},
-            obj: [{c0:{x:1,y:3,z:0}}, {c0:{x:1,y:2,z:1}}, {c0:{x:1,y:1,z:2}}] }, 
-      out: [{c0:{x:1,y:3,z:0},'$KEY':0}, {c0:{x:1,y:2,z:1},'$KEY':1}] }     
+            obj: [{c0:{x:1,y:3,z:0}}, {c0:{x:1,y:2,z:1}}, {c0:{x:1,y:1,z:2}}] },
+      out: [{c0:{x:1,y:3,z:0},'$KEY':0}, {c0:{x:1,y:2,z:1},'$KEY':1}] }
   ]
 }
 
 
-# path alternates selection
-# NOTES FOR SDK:
-#  build query by union of all select keys, getting values from operation spec, match
-#  need a deterministic sort of alts so multiple selects (should not happen) have at least
-#    a stable list of returned alts order. also $path as get out of jail
-#      normalize: /a/{x}/b/ -> path$:'/a/{}/b'
-#  if no alt found, use select to indicate missing select options
 alts: {
   data: obj0: [
     { select:foo_id:true, x:1 }
@@ -211,7 +194,7 @@ alts: {
     { select:{'$action':foo,zed_id:true}, x:31 }
     { select:{'$action':bar,zed_id:true}, x:32 }
   ]
-  
+
   set: [
     { in: { query: select: {
               foo_id:true  # boolean true means value exists (incl. JSON null)
@@ -236,12 +219,12 @@ alts: {
              obj: $.struct.select.alts.data.obj2 }
        out: [{ '$KEY': 0, select: { query:q0:v0 }, x: 21} ]
      }
-     
+
      { in: { query: select: { '$action':bar, zed_id:true }
              obj: $.struct.select.alts.data.obj3 }
        out: [{ '$KEY': 1, select: {'$action':bar,zed_id:true}, x: 32} ]
      }
-     
+
 
   ]
 }

package/src/create-sdkgen.ts

@@ -45,8 +45,6 @@ const { names, Jostraca } = JostracaModule
 const SDK_FOLDER = '.sdk'
 
 
-// TODO: CreateSdkGen opts and generate opts should be mostly the same, and
-// generate should override
 function CreateSdkGen(opts: FullCreateSdkGenOptions) {
   const fs = opts.fs || Fs
 
@@ -107,12 +105,6 @@ function CreateSdkGen(opts: FullCreateSdkGenOptions) {
       folder,
       log: log.child({ cmp: 'jostraca' }),
       meta: { spec },
-      // Overwrite the scaffolded project (.sdk components, templates, build
-      // config) rather than 3-way merge. The scaffold is toolchain-derived and
-      // not hand-edited; merging against a drifting .jostraca base keeps STALE
-      // components/templates on a toolchain bump (so a fix never propagates) and
-      // can inject <<<<<<< markers. See @voxgig/sdkgen
-      // docs/explanation/regeneration-overwrite.md.
       existing: {
         txt: {
           write: true,
@@ -166,7 +158,6 @@ function CreateSdkGen(opts: FullCreateSdkGenOptions) {
 
     projectFolder = Path.resolve(Path.join(__dirname, 'project', spec.project))
 
-    // TODO: support auto install project npm package (specific version) in a special cache folder
 
     if (!fs.existsSync(projectFolder)) {
       projectFolder = spec.project
@@ -275,17 +266,6 @@ async function installNpm(spec: GenerateSpec, opts: any, model: any) {
     await runNpm(['install'], spawn_opts)
   }
 
-  // `-t` / `-f` are INDEPENDENT of `--no-install`: the documented contract is
-  // that --no-install skips `npm install`, not that it drops the requested
-  // targets and features. Adding them is still valid without an install when
-  // the project already has its toolchain (re-scaffolding an existing folder
-  // is a supported flow — "if run against an existing folder generated files
-  // will be overwritten").
-  //
-  // They ARE npm run scripts that resolve @voxgig/sdkgen from node_modules, so
-  // without one they cannot work. Fail with an actionable message rather than
-  // the raw module-resolution error — and rather than silently skipping, which
-  // reports success while leaving config.aon without the requested entries.
   const wanted = [
     (spec.target ?? []).length ? '--target' : '',
     (spec.feature ?? []).length ? '--feature' : '',
@@ -342,21 +322,6 @@ async function installFeatures(spec: GenerateSpec, opts: any, model: any, spawn_
 }
 
 
-/*
-function logfiles(info: any, log: ReturnType<typeof Pino>) {
-  const cwd = process.cwd()
-
-    ; Object.keys(info.files).map(action => {
-      let entries = info.files[action]
-      if (0 < entries.length) {
-        log.debug({
-          point: 'file-' + action, entries,
-          note: '\n' + entries.map((n: any) => n.replace(cwd, '.')).join('\n')
-        })
-      }
-    })
-}
-*/
 
 export type {
   CreateSdkGenOptions,