@voxgig/sdkgen 4.34.0 → 4.34.2

package/project/.sdk/src/cmp/go/ReadmeTopQuick_go.ts

@@ -1,5 +1,5 @@
 
-import { cmp, Content, isAuthActive, envName, entityIdField, entityOps, opRequestShape, goModule , serverVariables} from '@voxgig/sdkgen'
+import { cmp, Content, isAuthActive, envName, entityIdField, entityOps, opRequestShape, goModule, serverVariables, listMatchArg } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -51,12 +51,14 @@ client := ${ctor}
     let hasCall = false
 
     if (opnames.includes('list')) {
-      Content(`// List all ${eName.toLowerCase()}s
-${eVar}s, err := client.${eName}(nil).List(nil, nil)
+      Content(`// List all ${eName.toLowerCase()}s (one entity per record; err is non-nil on failure)
+${eVar}s, err := client.${eName}(nil).List(${listMatchArg('go', exampleEntity)}, nil)
 if err != nil {
     panic(err)
 }
-fmt.Println(${eVar}s)
+for _, ${eVar} := range ${eVar}s.([]any) {
+    fmt.Println(${eVar}.(sdk.Entity).Data())
+}
 `)
       hasCall = true
     }
@@ -87,14 +89,14 @@ fmt.Println(${eVar}s)
             it.name === neIdF ? 'example_id' : 'example_' + it.name)}`)
 
       Content(`
-// Load a specific ${neName.toLowerCase()}
+// Load a specific ${neName.toLowerCase()} (returns the entity; err is non-nil on failure)
 ${neVar}, err := client.${neName}(nil).Load(
     map[string]any{${neMatchPairs.join(', ')}}, nil,
 )
 if err != nil {
     panic(err)
 }
-fmt.Println(${neVar})
+fmt.Println(${neVar}.(sdk.Entity).Data())
 `)
       hasCall = true
     }
@@ -110,12 +112,12 @@ fmt.Println(${neVar})
           `"${it.name}": ${exampleValue(exampleEntity, exampleEntity.op && exampleEntity.op.load, it.name,
             it.name === idF ? 'example_id' : 'example_' + it.name)}`).join(', ')}}`
         : 'nil'
-      Content(`// Load ${eName.toLowerCase()} data
+      Content(`// Load a specific ${eName.toLowerCase()} (returns the entity; err is non-nil on failure)
 ${eVar}, err := client.${eName}(nil).Load(${loadArg}, nil)
 if err != nil {
     panic(err)
 }
-fmt.Println(${eVar})
+fmt.Println(${eVar}.(sdk.Entity).Data())
 `)
       hasCall = true
     }

package/project/.sdk/src/cmp/go/ReadmeTopTest_go.ts

@@ -1,5 +1,5 @@
 
-import { cmp, Content, canonKey, canonScalarKey, entityIdField, pickExampleEntity, opRequestShape, goModule } from '@voxgig/sdkgen'
+import { cmp, Content, canonKey, canonScalarKey, entityIdField, pickExampleEntity, opRequestShape, goModule, requiredItems, litPair } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -11,6 +11,7 @@ import {
 // A type-correct Go literal for a field's canonical type.
 function goLit(type: any): string {
   const k = canonScalarKey(type)
+  if ('NULL' === k) return 'nil'
   if ('INTEGER' === k || 'NUMBER' === k) return '1'
   if ('BOOLEAN' === k) return 'true'
   if ('ARRAY' === k) return '[]any{}'
@@ -45,12 +46,15 @@ client := sdk.Test()
     let arg = 'nil'
     if (isMatchOp) {
       arg = idF ? `map[string]any{"${idF}": "test01"}` : 'nil'
-    } else if ('create' === primaryOp || 'update' === primaryOp) {
+    } else if ('list' === primaryOp && 0 < requiredItems(exampleEntity, 'list').length) {
+      const chosen = requiredItems(exampleEntity, 'list')
+      arg = `map[string]any{${chosen.map((it: any) => litPair('go', it.name, goLit(it.type))).join(', ')}}`
+    } else if ('create' === primaryOp || 'update' === primaryOp || 'patch' === primaryOp) {
       const items = opRequestShape(exampleEntity, primaryOp).items
         .filter((it: any) => it.name !== idF && it.name !== 'id')
       const required = items.filter((it: any) => !it.optional)
       const chosen = required.length ? required : items.slice(0, 3)
-      arg = `map[string]any{${chosen.map((it: any) => `"${it.name}": ${goLit(it.type)}`).join(', ')}}`
+      arg = `map[string]any{${chosen.map((it: any) => litPair('go', it.name, goLit(it.type))).join(', ')}}`
     }
     Content(`result, err := client.${eName}(nil).${cap(primaryOp)}(
     ${arg}, nil,

package/project/.sdk/src/cmp/go/TestClean_go.ts

@@ -242,8 +242,43 @@ var cleanScenarios = []cleanScenario{
 	}},
 }
 
+// Offline, as every generated suite is: the test OPTION resolves a required
+// server variable to test-<name>, and installs no transport.
+func cleanOffline(opts map[string]any) map[string]any {
+	opts["test"] = map[string]any{"active": true}
+	return opts
+}
+
+// A client the sweep cannot build leaves nothing swept: a harness error, not
+// a leak, which cleanHarness reports instead of letting the panic end the run.
+type cleanHarnessError struct{ cause any }
+
+func cleanNew(opts map[string]any) *sdk.${Name}SDK {
+	defer func() {
+		if r := recover(); r != nil {
+			panic(cleanHarnessError{r})
+		}
+	}()
+	return sdk.New${Name}SDK(cleanOffline(opts))
+}
+
+func cleanHarness(t *testing.T) {
+	if r := recover(); r != nil {
+		if h, ok := r.(cleanHarnessError); ok {
+			t.Fatalf("clean harness: the client could not be constructed, so nothing was swept: %v",
+				h.cause)
+		}
+		panic(r)
+	}
+}
+
 func cleanMakeSdk(scenario cleanScenario, sinks *[]cleanSink, cleanopts map[string]any,
 	extra ...any) *sdk.${Name}SDK {
+	return cleanNew(cleanOptions(scenario, sinks, cleanopts, extra...))
+}
+
+func cleanOptions(scenario cleanScenario, sinks *[]cleanSink, cleanopts map[string]any,
+	extra ...any) map[string]any {
 	capture := func(name string) func(map[string]any) {
 		return func(rec map[string]any) {
 			*sinks = append(*sinks, cleanSurfaces(name, rec)...)
@@ -281,7 +316,7 @@ func cleanMakeSdk(scenario cleanScenario, sinks *[]cleanSink, cleanopts map[stri
 		clean[k] = v
 	}
 
-	return sdk.New${Name}SDK(map[string]any{
+	return map[string]any{
 		"apikey":  cleanCanary["apikey"],
 		"secret":  cleanCanary["secret"],
 		"headers": map[string]any{"X-Custom-Token": cleanCanary["header"]},
@@ -293,7 +328,7 @@ func cleanMakeSdk(scenario cleanScenario, sinks *[]cleanSink, cleanopts map[stri
 				return scenario.respond(url, fetchdef)
 			}),
 		},
-	})
+	}
 }
 
 // One operation this SDK can perform: the client method returning the
@@ -309,12 +344,12 @@ func cleanEntity(client *sdk.${Name}SDK, accessor string) reflect.Value {
 		Call([]reflect.Value{reflect.ValueOf(map[string]any(nil))})[0]
 }
 
-func cleanInvoke(client *sdk.${Name}SDK, op cleanOp, ctrl map[string]any) (any, error) {
+func cleanInvoke(entity reflect.Value, op cleanOp, ctrl map[string]any) (any, error) {
 	match := map[string]any{}
 	for k, v := range op.match {
 		match[k] = v
 	}
-	rets := cleanEntity(client, op.accessor).MethodByName(op.method).Call([]reflect.Value{
+	rets := entity.MethodByName(op.method).Call([]reflect.Value{
 		reflect.ValueOf(match),
 		reflect.ValueOf(ctrl),
 	})
@@ -348,7 +383,7 @@ func cleanFilled(client *sdk.${Name}SDK, entity string, method string) map[strin
 // returning something that answers GetName().
 func cleanUsableOp() (cleanOp, bool) {
 	plain := func() *sdk.${Name}SDK {
-		return sdk.New${Name}SDK(map[string]any{
+		return cleanNew(map[string]any{
 			"apikey": cleanCanary["apikey"],
 			"utility": map[string]any{
 				"fetcher": sdk.FetcherFunc(func(*sdk.Context, string, map[string]any) (any, error) {
@@ -383,7 +418,7 @@ func cleanUsableOp() (cleanOp, bool) {
 	sort.Strings(accessors)
 
 	for _, accessor := range accessors {
-		for _, method := range []string{"List", "Load", "Create", "Update", "Remove"} {
+		for _, method := range []string{"List", "Load", "Create", "Update", "Patch", "Remove"} {
 			om := cleanEntity(probe, accessor).MethodByName(method)
 			if !om.IsValid() || om.Type().NumIn() != 2 || om.Type().NumOut() != 2 {
 				continue
@@ -392,7 +427,7 @@ func cleanUsableOp() (cleanOp, bool) {
 				Call(nil)[0].String()
 			for _, match := range []map[string]any{{}, cleanFilled(probe, name, method)} {
 				op := cleanOp{accessor: accessor, method: method, match: match}
-				if _, err := cleanInvoke(plain(), op, map[string]any{}); err == nil {
+				if _, err := cleanInvoke(cleanEntity(plain(), accessor), op, map[string]any{}); err == nil {
 					return op, true
 				}
 			}
@@ -404,13 +439,17 @@ func cleanUsableOp() (cleanOp, bool) {
 func cleanDrive(client *sdk.${Name}SDK, op cleanOp, ctrl map[string]any, sinks *[]cleanSink) error {
 	// A caller may keep the record it passed rather than read ctrl["explain"].
 	held, _ := ctrl["explain"].(map[string]any)
-	out, err := cleanInvoke(client, op, ctrl)
+	entity := cleanEntity(client, op.accessor)
+	out, err := cleanInvoke(entity, op, ctrl)
 	if err != nil {
 		*sinks = append(*sinks, cleanSurfaces("error", err)...)
 	}
 	if out != nil {
 		*sinks = append(*sinks, cleanSurfaces("result", out)...)
 	}
+	// Raw, as a caller copying the match into another query reads it.
+	*sinks = append(*sinks, cleanSurfaces("match",
+		entity.MethodByName("Match").Call(nil)[0].Interface())...)
 	explain, ok := ctrl["explain"].(map[string]any)
 	if ok {
 		*sinks = append(*sinks, cleanSurfaces("explain", explain)...)
@@ -491,6 +530,9 @@ func (f *cleanStreamPanic) PreDone(ctx *sdk.Context) {
 func cleanCatch(name string, sinks *[]cleanSink, fn func() error) (err error) {
 	defer func() {
 		if r := recover(); r != nil {
+			if _, harness := r.(cleanHarnessError); harness {
+				panic(r)
+			}
 			*sinks = append(*sinks, cleanSurfaces(name+":panic", r)...)
 			err = fmt.Errorf("panic: %v", r)
 		}
@@ -501,6 +543,7 @@ func cleanCatch(name string, sinks *[]cleanSink, fn func() error) (err error) {
 const cleanNoOp = "no operation of this SDK completes against a plain 200; nothing to sweep"
 
 func TestCleanSweep(t *testing.T) {
+	defer cleanHarness(t)
 	op, found := cleanUsableOp()
 	if !found {
 		t.Skip(cleanNoOp)
@@ -538,15 +581,21 @@ func TestCleanSweep(t *testing.T) {
 		}
 	}
 
+	// A name given at run time replaces the declared one: the match leaves
+	// out whichever name PrepareAuth placed.
+	renamed := cleanOptions(cleanScenarios[0], &sinks, nil)
+	renamed["auth"] = map[string]any{"name": "zzcred"}
+	cleanDrive(cleanNew(renamed), op, map[string]any{}, &sinks)
+
 	// A credential mistyped as a map. The go validator substitutes the
 	// default rather than rejecting it, so there is no rejection to sweep:
 	// sweep what the constructor produced, and what clean makes of the value
 	// should anything later quote it.
 	cleanCatch("mistyped", &sinks, func() error {
-		client := sdk.New${Name}SDK(map[string]any{
+		client := sdk.New${Name}SDK(cleanOffline(map[string]any{
 			"apikey": map[string]any{"value": cleanCanary["apikey"]},
 			"clean":  map[string]any{"values": cleanCanary["value"]},
-		})
+		}))
 		sinks = append(sinks, cleanSurfaces("mistyped", client)...)
 		sinks = append(sinks, cleanSurfaces("mistyped:quoted",
 			client.GetUtility().Clean(client.GetRootCtx(), "found map: "+cleanCanary["apikey"]))...)
@@ -572,9 +621,9 @@ func TestCleanSweep(t *testing.T) {
 		}
 	}
 
-	// Stream has no error channel: a panic inside it must end the stream
-	// through MakeError, cleaned, and not crash the process. However it
-	// ends, the explain record the caller passed is left clean.
+	// A panic inside a stream must end it through MakeError, its cleaned
+	// error the last value sent, and not crash the process. However it ends,
+	// the explain record the caller passed is left clean.
 	for _, streamed := range []struct {
 		name  string
 		saw   string
@@ -597,8 +646,13 @@ func TestCleanSweep(t *testing.T) {
 			reflect.ValueOf(strings.ToLower(op.method)),
 			reflect.ValueOf(map[string]any{"reqmatch": reqmatch}),
 			reflect.ValueOf(map[string]any{"ctrl": map[string]any{"explain": explain}}),
-		})[0].Interface().(<-chan any)
-		for range items {
+		})[0].Interface().(<-chan core.StreamItem)
+		var streamerr error
+		for item := range items {
+			if item.Err != nil {
+				streamerr = item.Err
+				sinks = append(sinks, cleanSurfaces(streamed.name, item.Err)...)
+			}
 		}
 		sinks = append(sinks, cleanSurfaces(streamed.name+":explain", explain)...)
 		if 0 == len(explain) {
@@ -608,6 +662,9 @@ func TestCleanSweep(t *testing.T) {
 		if ("" == streamed.saw) != (nil == explain["err"]) || !strings.Contains(msg, streamed.saw) {
 			t.Errorf("%s: only a failing stream ends as the SDK error, got %v", streamed.name, explain)
 		}
+		if ("" == streamed.saw) != (nil == streamerr) {
+			t.Errorf("%s: only a failing stream sends an error, got %v", streamed.name, streamerr)
+		}
 	}
 
 	// A registered value used as a property name is masked; names that mask
@@ -644,7 +701,7 @@ func TestCleanSweep(t *testing.T) {
 	}
 
 	// With no clean option at all, the schema defaults still apply.
-	bare := sdk.New${Name}SDK(map[string]any{
+	bare := cleanNew(map[string]any{
 		"apikey":  cleanCanary["apikey"],
 		"secret":  cleanCanary["secret"],
 		"headers": map[string]any{"X-Custom-Token": cleanCanary["header"]},
@@ -660,12 +717,14 @@ func TestCleanSweep(t *testing.T) {
 
 	// A feature's name is not a field name: only the sensitive names inside
 	// its settings register. An entity block, of per-entity settings or seeded
-	// records keyed by entity name and id, is not read at all.
-	featured := sdk.New${Name}SDK(map[string]any{
+	// records keyed by entity name and id, is not read at all, and nor are
+	// rbac's rules, keyed by entity and operation names.
+	featured := cleanNew(map[string]any{
 		"apikey": cleanCanary["apikey"],
 		"feature": map[string]any{
 			"zzsecrets": map[string]any{"active": false, "kind": "PLAINSETTING-q8w2e4r6"},
 			"zzfeat":    map[string]any{"active": false, "apitoken": "FEATTOKEN-z9y8x7w6"},
+			"rbac":      map[string]any{"active": false, "rules": map[string]any{"zztoken.load": "PLAINRULE-k7j5h3g1"}},
 			"test": map[string]any{"active": false, "entity": map[string]any{
 				"zztoken": map[string]any{"ZZTOKEN01": map[string]any{"note": "PLAINRECORD-t5r3e1w9"}},
 			}},
@@ -684,6 +743,9 @@ func TestCleanSweep(t *testing.T) {
 			t.Errorf("an entity block was registered: %q", got)
 		}
 	}
+	if got, _ := fclean(featured.GetRootCtx(), "rule PLAINRULE-k7j5h3g1").(string); got != "rule PLAINRULE-k7j5h3g1" {
+		t.Errorf("an rbac rule keyed by entity and operation was registered: %q", got)
+	}
 
 	leaked := []string{}
 	for _, s := range sinks {
@@ -747,6 +809,7 @@ func TestCleanSweep(t *testing.T) {
 }
 
 func TestCleanSensitivity(t *testing.T) {
+	defer cleanHarness(t)
 	op, found := cleanUsableOp()
 	if !found {
 		t.Skip(cleanNoOp)

package/project/.sdk/src/cmp/go/TestDirect_go.ts

@@ -13,7 +13,7 @@ import {
   snakify,
   isAuthActive,
   serverVarEnv,
-  serverVariables, envName, envToken, liveStrict,
+  serverVariables, envName, envToken, liveStrict, liveStrictNote,
   pointParts,
 } from '@voxgig/sdkgen'
 
@@ -70,9 +70,8 @@ const TestDirect = cmp(function TestDirect(props: any) {
 
   const PROJECTNAME = envName(model)
 
-  // Does a live run ASSERT, or merely observe? See helpers/testPolicy.
-  // t.Skipf passes; t.Fatalf does not.
-  const liveFail = liveStrict(model, target.name) ? 'Fatalf' : 'Skipf'
+  const strict = liveStrict(model, target.name)
+  const strictConst = entity.name + 'DirectLiveStrict'
 
   const authActive = isAuthActive(model)
   const apikeyEnvEntry = authActive
@@ -180,11 +179,14 @@ import (
 	"${gomodule}/core"
 )
 
+${liveStrictNote(strict, '//')}
+const ${strictConst} = ${strict}
+
 func Test${entity.Name}Direct(t *testing.T) {
 `)
 
     if (hasList && listPoint && listIsGraphql) {
-      generateDirectGraphqlGo('list', entity, listPoint, liveFail)
+      generateDirectGraphqlGo('list', entity, listPoint, strictConst, entidEnvVar)
     }
 
     if (hasList && listPoint && !listIsGraphql) {
@@ -200,9 +202,7 @@ func Test${entity.Name}Direct(t *testing.T) {
         return { name: p.n, key }
       })
 
-      // Track idmap keys this test consumes in live mode. If any are
-      // missing (no ENTID override), skip — the request would 4xx on
-      // undefined path params.
+      // The idmap keys the live request needs; without them it is blocked.
       const listLiveIdKeys = listParams.length > 0
         ? listLiveParams.map((lp: any) => lp.key)
         : []
@@ -213,7 +213,7 @@ func Test${entity.Name}Direct(t *testing.T) {
         ? `		if setup.live {
 			for _, _liveKey := range ${listLiveIdKeysGoLiteral} {
 				if v := setup.idmap[_liveKey]; v == nil {
-					t.Skipf("live test needs %s via *_ENTID env var (synthetic IDs only)", _liveKey)
+					liveMiss(t, ${strictConst}, "Live test blocked: needs %s via ${entidEnvVar}", _liveKey)
 					return
 				}
 			}
@@ -271,19 +271,14 @@ ${listSkipBlock}		client := setup.client
       }
 
       Content(`		if setup.live {
-			// Live-mode leniency is a model decision
-			// (main.kit.test.live.strict): synthetic IDs 4xx constantly
-			// against an arbitrary public API, so the default SKIPS here.
-			// A project that owns its test server sets strict and FAILS.
 			if err != nil {
-				t.${liveFail}("list call failed (likely synthetic IDs against live API): %v", err)
+				liveMiss(t, ${strictConst}, "Live list failed: %v", err)
 			}
-			if result["ok"] != true {
-				t.${liveFail}("list call not ok (likely synthetic IDs against live API): %v", result)
+			if status := core.ToInt(result["status"]); result["ok"] != true || status < 200 || status >= 300 {
+				liveMiss(t, ${strictConst}, "Live list failed: %s", liveDescribe(result))
 			}
-			status := core.ToInt(result["status"])
-			if status < 200 || status >= 300 {
-				t.${liveFail}("expected 2xx status, got %v", result["status"])
+			if _, ok := liveList(result["data"]); !ok {
+				liveMiss(t, ${strictConst}, "Live list returned no list: %s", liveDescribe(result))
 			}
 		} else {
 			if err != nil {
@@ -337,7 +332,7 @@ ${listSkipBlock}		client := setup.client
     }
 
     if (hasLoad && loadPoint && loadIsGraphql) {
-      generateDirectGraphqlGo('load', entity, loadPoint, liveFail)
+      generateDirectGraphqlGo('load', entity, loadPoint, strictConst, entidEnvVar)
     }
 
     // Generate load test - in live mode, first list to get a real entity ID
@@ -349,23 +344,17 @@ ${listSkipBlock}		client := setup.client
 
       const ancestorParams = loadParams.filter((p: any) => p.n !== 'id')
 
+      const liveKey = (p: any) => p.n === 'id' ? entity.name + '01' : p.n.replace(/_id$/, '') + '01'
       let loadLiveIdKeys: string[] = []
       if (loadParams.length > 0 && !loadAllHaveExamples) {
-        if (hasList) {
-          loadLiveIdKeys = listParams.map((p: any) => {
-            return p.n === 'id'
-              ? entity.name + '01'
-              : p.n.replace(/_id$/, '') + '01'
-          })
-        } else {
-          loadLiveIdKeys = loadParams.map((p: any) => p.n + '01')
-        }
+        loadLiveIdKeys = [...new Set((hasList ?
+          [...listParams, ...loadParams.filter((p: any) => p.n !== 'id')] : loadParams).map(liveKey))]
       }
       const loadSkipBlock = loadLiveIdKeys.length > 0
         ? `		if setup.live {
 			for _, _liveKey := range []string{${loadLiveIdKeys.map(k => `"${k}"`).join(', ')}} {
 				if v := setup.idmap[_liveKey]; v == nil {
-					t.Skipf("live test needs %s via *_ENTID env var (synthetic IDs only)", _liveKey)
+					liveMiss(t, ${strictConst}, "Live test blocked: needs %s via ${entidEnvVar}", _liveKey)
 					return
 				}
 			}
@@ -424,23 +413,32 @@ ${loadSkipBlock}		client := setup.client
 				"params": listParams,
 			})
 			if listErr != nil {
-				t.${liveFail}("list call failed (likely synthetic IDs against live API): %v", listErr)
+				liveMiss(t, ${strictConst}, "Live list discovery failed: %v", listErr)
 			}
 			if listResult["ok"] != true {
-				t.${liveFail}("list call not ok (likely synthetic IDs against live API): %v", listResult)
+				liveMiss(t, ${strictConst}, "Live list discovery failed: %s", liveDescribe(listResult))
+			}
+			listData, listOk := liveList(listResult["data"])
+			if !listOk {
+				liveMiss(t, ${strictConst}, "Live list discovery returned no list: %s", liveDescribe(listResult))
 			}
-
-			// Get first entity ID from list
-			listData, _ := listResult["data"].([]any)
 			if len(listData) == 0 {
-				t.Skip("no entities to load in live mode")
+				liveEmpty(t, "The account has no ${entity.name} record to load")
 			}
 			firstEnt := core.ToMapAny(listData[0])
+			if firstEnt["id"] == nil {
+				liveMiss(t, ${strictConst}, "Live load blocked: discovery returned no usable identity")
+			}
 			params["id"] = firstEnt["id"]
 `)
           for (const p of ancestorParams) {
             const key = p.n.replace(/_id$/, '') + '01'
             Content(`			params["${p.n}"] = setup.idmap["${key}"]
+`)
+          }
+        } else if (loadParams.length > 0) {
+          for (const p of loadParams) {
+            Content(`			params["${p.n}"] = setup.idmap["${liveKey(p)}"]
 `)
           }
         }
@@ -476,19 +474,14 @@ ${loadSkipBlock}		client := setup.client
       }
       Content(`		})
 		if setup.live {
-			// Live mode is lenient: synthetic IDs frequently 4xx. Skip
-			// rather than fail when the load endpoint isn't reachable with
-			// the IDs we can construct from setup.idmap — unless the model
-			// sets main.kit.test.live.strict.
 			if err != nil {
-				t.${liveFail}("load call failed (likely synthetic IDs against live API): %v", err)
+				liveMiss(t, ${strictConst}, "Live load failed: %v", err)
 			}
-			if result["ok"] != true {
-				t.${liveFail}("load call not ok (likely synthetic IDs against live API): %v", result)
+			if status := core.ToInt(result["status"]); result["ok"] != true || status < 200 || status >= 300 {
+				liveMiss(t, ${strictConst}, "Live load failed: %s", liveDescribe(result))
 			}
-			status := core.ToInt(result["status"])
-			if status < 200 || status >= 300 {
-				t.${liveFail}("expected 2xx status, got %v", result["status"])
+			if result["data"] == nil {
+				liveMiss(t, ${strictConst}, "Live load returned no data: %s", liveDescribe(result))
 			}
 		} else {
 			if err != nil {
@@ -625,7 +618,8 @@ function generateDirectGraphqlGo(
   opname: 'load' | 'list',
   entity: ModelEntity,
   point: any,
-  liveFail: string,
+  strictConst: string,
+  entidEnvVar: string,
 ) {
   const doc: string = point.gq.doc
   const vars: any[] = point.gq.vars || []
@@ -648,7 +642,7 @@ function generateDirectGraphqlGo(
     ? `\t\tif setup.live {
 \t\t\tfor _, _liveKey := range []string{${liveIdKeys.map(k => `"${k}"`).join(', ')}} {
 \t\t\t\tif v := setup.idmap[_liveKey]; v == nil {
-\t\t\t\t\tt.Skipf("live test needs %s via *_ENTID env var (synthetic IDs only)", _liveKey)
+\t\t\t\t\tliveMiss(t, ${strictConst}, "Live test blocked: needs %s via ${entidEnvVar}", _liveKey)
 \t\t\t\t\treturn
 \t\t\t\t}
 \t\t\t}
@@ -690,14 +684,14 @@ ${mockVarLines || '\t\t// no variables'}
 		result, err := client.Graphql(${JSON.stringify(doc)}, variables, nil)
 
 		if setup.live {
-			// Live mode is lenient: synthetic ids frequently fail server-side
-			// validation. Skip rather than fail when the call doesn't come
-			// back clean.
 			if err != nil {
-				t.${liveFail}("graphql call failed (likely synthetic IDs against live API): %v", err)
+				liveMiss(t, ${strictConst}, "Live ${opname} failed: %v", err)
 			}
 			if result["ok"] != true {
-				t.${liveFail}("graphql call not ok (likely synthetic IDs against live API): %v", result)
+				liveMiss(t, ${strictConst}, "Live ${opname} failed: %s", liveDescribe(result))
+			}
+			if result["data"] == nil {
+				liveMiss(t, ${strictConst}, "Live ${opname} returned no data: %s", liveDescribe(result))
 			}
 		} else {
 			if err != nil {