@voxgig/sdkgen 4.34.0 → 4.34.1

package/project/.sdk/src/cmp/kotlin/TestClean_kotlin.ts

@@ -263,8 +263,26 @@ class CleanTest {
     },
   )
 
+  // Offline, as every generated suite is: the test OPTION resolves a required
+  // server variable to test-<name>, and installs no transport.
+  private fun offline(opts: Map<String, Any?>): MutableMap<String, Any?> {
+    val out = LinkedHashMap<String, Any?>(opts)
+    out["test"] = linkedMapOf<String, Any?>("active" to true)
+    return out
+  }
+
+  // A client the sweep cannot build leaves nothing swept: a harness error, not
+  // a leak.
+  private fun construct(opts: Map<String, Any?>): ${SDK} =
+    try {
+      ${SDK}(offline(opts))
+    } catch (e: RuntimeException) {
+      throw IllegalStateException(
+        "clean harness: the client could not be constructed, so nothing was swept: " + e.message, e)
+    }
+
   private fun makeSdk(scenario: Scenario, sinks: MutableList<Sink>, cleanopts: Map<String, Any?>?,
-    vararg extra: BaseFeature): ${SDK} {
+    vararg extra: BaseFeature, auth: MutableMap<String, Any?>? = null): ${SDK} {
     val capture = { name: String -> Consumer<Any?> { rec -> sinks.addAll(surfaces(name, rec)) } }
 
     val feature = linkedMapOf<String, Any?>()
@@ -312,7 +330,10 @@ class CleanTest {
     opts["feature"] = feature
     opts["extend"] = mutableListOf<Any?>(CaptureFeature(sinks), *extra)
     opts["utility"] = linkedMapOf<String, Any?>("fetcher" to fetcher)
-    return ${SDK}(opts)
+    if (auth != null) {
+      opts["auth"] = auth
+    }
+    return construct(opts)
   }
 
   class Target(val accessor: Method, val op: String, val match: Map<String, Any?>)
@@ -340,6 +361,7 @@ class CleanTest {
       "load" -> ent.load(arg, ctrl)
       "create" -> ent.create(arg, ctrl)
       "update" -> ent.update(arg, ctrl)
+      "patch" -> ent.patch(arg, ctrl)
       "remove" -> ent.remove(arg, ctrl)
       else -> throw IllegalArgumentException("no such op: " + op)
     }
@@ -371,7 +393,7 @@ class CleanTest {
   private fun usableOp(): Target? {
     val plainFetch: (Context, String, MutableMap<String, Any?>) -> Any? =
       { _, _, _ -> response(200, linkedMapOf<String, Any?>("id" to "i1"), null) }
-    val plain = ${SDK}(linkedMapOf<String, Any?>(
+    val plain = construct(linkedMapOf<String, Any?>(
       "apikey" to canaryApikey,
       "utility" to linkedMapOf<String, Any?>("fetcher" to plainFetch)))
     val entities = Helpers.toMapAny(Config.sharedConfig()["entity"]) ?: linkedMapOf()
@@ -407,10 +429,11 @@ class CleanTest {
   private fun drive(sdk: ${SDK}, target: Target, ctrl: MutableMap<String, Any?>?, sinks: MutableList<Sink>): Throwable? {
     // A caller may keep the record it passed rather than read ctrl's entry.
     val held = ctrl?.get("explain")
+    val entity = entityOf(sdk, target.accessor)!!
     var out: Any? = null
     var err: Throwable? = null
     try {
-      out = call(entityOf(sdk, target.accessor)!!, target.op, target.match, ctrl)
+      out = call(entity, target.op, target.match, ctrl)
     } catch (e: Throwable) {
       err = e
     }
@@ -420,6 +443,8 @@ class CleanTest {
     if (out != null) {
       sinks.addAll(surfaces("result", out))
     }
+    // Raw, as a caller copying the match into another query reads it.
+    sinks.addAll(surfaces("match", entity.match()))
     val explain = ctrl?.get("explain")
     if (explain != null) {
       sinks.addAll(surfaces("explain", explain))
@@ -459,10 +484,15 @@ class CleanTest {
       }
     }
 
+    // A name given at run time replaces the declared one: the match leaves
+    // out whichever name prepareAuth placed.
+    drive(makeSdk(scenarios[0], sinks, null, auth = linkedMapOf<String, Any?>("name" to "zzcred")),
+      target, null, sinks)
+
     // No clean option at all: the schema defaults still apply.
     val bareFetch: (Context, String, MutableMap<String, Any?>) -> Any? =
       { _, url, fetchdef -> scenarios[1].respond(url, fetchdef) }
-    val bare = ${SDK}(linkedMapOf<String, Any?>(
+    val bare = construct(linkedMapOf<String, Any?>(
       "apikey" to canaryApikey,
       "secret" to canarySecret,
       "headers" to linkedMapOf<String, Any?>("X-Custom-Token" to canaryHeader),
@@ -474,9 +504,9 @@ class CleanTest {
     // no rejection to sweep: sweep the client, and what clean makes of the
     // value should anything quote it.
     try {
-      val mistyped = ${SDK}(linkedMapOf<String, Any?>(
+      val mistyped = ${SDK}(offline(linkedMapOf<String, Any?>(
         "apikey" to linkedMapOf<String, Any?>("value" to canaryApikey),
-        "clean" to linkedMapOf<String, Any?>("values" to canaryValue)))
+        "clean" to linkedMapOf<String, Any?>("values" to canaryValue))))
       sinks.addAll(surfaces("mistyped", mistyped))
       sinks.addAll(surfaces("mistyped:quoted",
         mistyped.getUtility().clean(mistyped.getRootCtx(), "found map: " + canaryApikey)))
@@ -485,7 +515,7 @@ class CleanTest {
     }
 
     // A number is registered as the text a message quotes it in.
-    val numeric = ${SDK}(linkedMapOf<String, Any?>("apikey" to 918273645))
+    val numeric = construct(linkedMapOf<String, Any?>("apikey" to 918273645))
     val numbered = numeric.getUtility().clean(numeric.getRootCtx(), "found 918273645")
 
     for (unexpected in listOf(false, true)) {
@@ -595,14 +625,17 @@ class CleanTest {
   }
 
   // An entity block, of per-entity settings or seeded records keyed by
-  // entity name and id, is not read at all.
+  // entity name and id, is not read at all, and nor are rbac's rules, keyed by
+  // entity and operation names.
   @Test
   fun aFeatureNameDoesNotMakeItsSettingsSecret() {
-    val sdk = ${SDK}(linkedMapOf<String, Any?>(
+    val sdk = construct(linkedMapOf<String, Any?>(
       "apikey" to canaryApikey,
       "feature" to linkedMapOf<String, Any?>(
         "secrets" to linkedMapOf<String, Any?>(
           "active" to false, "kind" to "SETTING-KIND-4829", "token" to canarySecret),
+        "rbac" to linkedMapOf<String, Any?>(
+          "active" to false, "rules" to linkedMapOf<String, Any?>("zztoken.load" to "PLAINRULE-k7j5h3g1")),
         "test" to linkedMapOf<String, Any?>("active" to false, "entity" to linkedMapOf<String, Any?>(
           "zztoken" to linkedMapOf<String, Any?>(
             "ZZTOKEN01" to linkedMapOf<String, Any?>("note" to "PLAINRECORD-t5r3e1w9"))))),
@@ -615,6 +648,8 @@ class CleanTest {
       sdk.getUtility().clean(root, "record PLAINRECORD-t5r3e1w9"))
     assertEquals("alias PLAINALIAS-m2n4b6v8",
       sdk.getUtility().clean(root, "alias PLAINALIAS-m2n4b6v8"))
+    assertEquals("rule PLAINRULE-k7j5h3g1",
+      sdk.getUtility().clean(root, "rule PLAINRULE-k7j5h3g1"))
   }
 
   @Test

package/project/.sdk/src/cmp/kotlin/TestDirect_kotlin.ts

@@ -13,6 +13,8 @@ import {
   snakify,
   isAuthActive, envName, envToken,
   pointParts,
+  liveStrict,
+  liveStrictNote,
 } from '@voxgig/sdkgen'
 
 
@@ -144,6 +146,14 @@ import ${kotlinpackage}.utility.Json
 @Suppress("UNCHECKED_CAST", "UNUSED_VARIABLE")
 class ${entity.Name}DirectTest {
 
+${liveStrictNote(liveStrict(model, target.name), '//', '  ')}
+  private val LIVE_STRICT = ${liveStrict(model, target.name)}
+
+  private fun liveOk(result: Map<String, Any?>): Boolean {
+    val status = Helpers.toInt(result["status"])
+    return result["err"] == null && result["ok"] == true && status in 200..299
+  }
+
 `)
 
     if (hasList && listPoint) {
@@ -160,8 +170,9 @@ class ${entity.Name}DirectTest {
       const listSkipBlock = listLiveIdKeys.length > 0
         ? `    if (setup.live) {
       for (liveKey in arrayOf<String>(${listLiveIdKeys.map((k: string) => `"${k}"`).join(', ')})) {
-        Assumptions.assumeTrue(setup.idmap[liveKey] != null,
-            "live test needs " + liveKey + " via *_ENTID env var (synthetic IDs only)")
+        if (setup.idmap[liveKey] == null) {
+          RunnerSupport.liveMiss(LIVE_STRICT, "Live test blocked: needs " + liveKey + " via ${entidEnvVar}")
+        }
       }
     }
 `
@@ -211,10 +222,12 @@ ${listSkipBlock}    val client = setup.client
       }
 
       Content(`    if (setup.live) {
-      Assumptions.assumeTrue(result["ok"] == true,
-          "list call not ok (likely synthetic IDs against live API): " + result)
-      val status = Helpers.toInt(result["status"])
-      Assumptions.assumeTrue(status in 200..299, "expected 2xx status, got " + result["status"])
+      if (!liveOk(result)) {
+        RunnerSupport.liveMiss(LIVE_STRICT, "Live list failed: " + RunnerSupport.liveDescribe(result))
+      }
+      if (RunnerSupport.liveList(result["data"]) == null) {
+        RunnerSupport.liveMiss(LIVE_STRICT, "Live list returned no list: " + RunnerSupport.liveDescribe(result))
+      }
     } else {
       assertEquals(true, result["ok"], "expected ok to be true")
       assertEquals(200, Helpers.toInt(result["status"]), "expected status 200")
@@ -252,23 +265,18 @@ ${listSkipBlock}    val client = setup.client
     if (hasLoad && loadPoint) {
       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 in arrayOf<String>(${loadLiveIdKeys.map(k => `"${k}"`).join(', ')})) {
-        Assumptions.assumeTrue(setup.idmap[liveKey] != null,
-            "live test needs " + liveKey + " via *_ENTID env var (synthetic IDs only)")
+        if (setup.idmap[liveKey] == null) {
+          RunnerSupport.liveMiss(LIVE_STRICT, "Live test blocked: needs " + liveKey + " via ${entidEnvVar}")
+        }
       }
     }
 `
@@ -317,17 +325,30 @@ ${loadSkipBlock}    val client = setup.client
           "path", "${listPath}",
           "method", "GET",
           "params", listParams))
-      Assumptions.assumeTrue(listResult["ok"] == true,
-          "list call not ok (likely synthetic IDs against live API): " + listResult)
-
-      val listData = if (listResult["data"] is List<*>) listResult["data"] as List<Any?> else mutableListOf<Any?>()
-      Assumptions.assumeTrue(listData.isNotEmpty(), "no entities to load in live mode")
+      if (!liveOk(listResult)) {
+        RunnerSupport.liveMiss(LIVE_STRICT, "Live list discovery failed: " + RunnerSupport.liveDescribe(listResult))
+      }
+      val listData = RunnerSupport.liveList(listResult["data"])
+      if (listData == null) {
+        RunnerSupport.liveMiss(LIVE_STRICT, "Live list discovery returned no list: " + RunnerSupport.liveDescribe(listResult))
+      }
+      if (listData!!.isEmpty()) {
+        RunnerSupport.liveEmpty("The account has no ${entity.name} record to load")
+      }
       val firstEnt = Helpers.toMapAny(listData[0]) ?: linkedMapOf()
+      if (firstEnt["id"] == null) {
+        RunnerSupport.liveMiss(LIVE_STRICT, "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)}"]
 `)
           }
         }
@@ -362,10 +383,12 @@ ${loadSkipBlock}    val client = setup.client
       }
 
       Content(`    if (setup.live) {
-      Assumptions.assumeTrue(result["ok"] == true,
-          "load call not ok (likely synthetic IDs against live API): " + result)
-      val status = Helpers.toInt(result["status"])
-      Assumptions.assumeTrue(status in 200..299, "expected 2xx status, got " + result["status"])
+      if (!liveOk(result)) {
+        RunnerSupport.liveMiss(LIVE_STRICT, "Live load failed: " + RunnerSupport.liveDescribe(result))
+      }
+      if (result["data"] == null) {
+        RunnerSupport.liveMiss(LIVE_STRICT, "Live load returned no data: " + RunnerSupport.liveDescribe(result))
+      }
     } else {
       assertEquals(true, result["ok"], "expected ok to be true")
       assertEquals(200, Helpers.toInt(result["status"]), "expected status 200")

package/project/.sdk/src/cmp/kotlin/TestEntity_kotlin.ts

@@ -1,4 +1,4 @@
-import { flowSteps } from '@voxgig/sdkgen'
+import { flowSteps, opReachable, invalidRequest } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -18,7 +18,8 @@ import {
   each,
   buildIdNames,
   getMatchEntries,
-  isAuthActive, envName, envToken
+  isAuthActive, envName, envToken,
+  liveFlowNeeds, liveStrict, liveStrictNote,
 } from '@voxgig/sdkgen'
 
 
@@ -43,6 +44,49 @@ type GenCtx = {
 type OpGen = (ctx: GenCtx, step: ModelEntityFlowStep, index: number) => void
 
 
+// The live prologue of a flow built from offline fixtures: blocked without
+// the ids it binds, a create-less load reading the first listed record, and
+// a lenient run observing its checks rather than failing on them.
+function liveFlowGate(entity: any, needs: any, entidEnv: string, accessor: string,
+  strict: boolean, hasSteps: boolean): string {
+  let out = ''
+  if (0 < needs.keys.length) {
+    out += `    if (setup.live) {
+      for (liveKey in arrayOf<String>(${needs.keys.map((k: string) => JSON.stringify(k)).join(', ')})) {
+        if (setup.syntheticOnly || setup.idmap?.get(liveKey) == null) {
+          RunnerSupport.liveMiss(LIVE_STRICT, "Live entity test blocked: needs " + liveKey + " via ${entidEnv}")
+        }
+      }
+    }
+`
+  }
+  if (null != needs.blocked) {
+    out += `    if (setup.live) {
+      RunnerSupport.liveMiss(LIVE_STRICT, "Live entity test blocked: " + ${JSON.stringify(needs.blocked)})
+    }
+`
+  }
+  if (!hasSteps) {
+    return out
+  }
+  out += '    val client = setup.client\n'
+  if (null != needs.discover) {
+    const match = Object.entries(needs.discover)
+      .map(([k, v]: any) => `${JSON.stringify(k)} to setup.idmap?.get(${JSON.stringify(v)})`).join(', ')
+    out += `    if (setup.live) {
+      RunnerSupport.liveExisting(setup.data!!, LIVE_STRICT, ${JSON.stringify(entity.name)}) {
+        client.${accessor}(null).list(linkedMapOf<String, Any?>(${match}), null)
+      }
+    }
+`
+  }
+  if (!strict) {
+    out += '    try {\n'
+  }
+  return out + '\n'
+}
+
+
 const TestEntity = cmp(function TestEntity(props: any) {
   const ctx$ = props.ctx$
   const model: Model = ctx$.model
@@ -77,6 +121,9 @@ const TestEntity = cmp(function TestEntity(props: any) {
 
   const genCtx: GenCtx = { model, entity, kotlinpackage, flow: basicflow, PROJUPPER, accessor }
 
+  const strict = liveStrict(model, target.name)
+  const needs = liveFlowNeeds(entity, basicflow)
+
   const stepOps = Array.from(new Set(
     (allSteps as any[]).map((s: any) => s.o).filter(Boolean)))
 
@@ -90,19 +137,27 @@ import java.nio.file.Paths
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertFalse
 import org.junit.jupiter.api.Assertions.assertNotNull
+import org.junit.jupiter.api.Assertions.assertThrows
 import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.Assumptions
 import org.junit.jupiter.api.Test
 
+import ${kotlinpackage}.core.Config
+import ${kotlinpackage}.core.Context
 import ${kotlinpackage}.core.Helpers
 import ${kotlinpackage}.core.SdkEntity
+import ${kotlinpackage}.core.SdkError
 import ${kotlinpackage}.core.${SDK}
+import ${kotlinpackage}.feature.BaseFeature
 import ${kotlinpackage}.utility.Json
 import ${kotlinpackage}.utility.struct.Struct
 
 @Suppress("UNCHECKED_CAST", "UNUSED_VARIABLE", "UNUSED_VALUE")
 class ${entity.Name}EntityTest {
 
+${liveStrictNote(strict, '//', '  ')}
+  private val LIVE_STRICT = ${strict}
+
   @Test
   fun instance() {
     val testsdk = ${SDK}.testSDK()
@@ -122,11 +177,7 @@ class ${entity.Name}EntityTest {
         if (reason == null || "" == reason) "skipped via sdk-test-control.json" else reason,
       )
     }
-    Assumptions.assumeFalse(
-      setup.syntheticOnly,
-      "live entity test uses synthetic IDs from fixture — set ${entidEnvVar} JSON to run live",
-    )
-${allSteps.length > 0 ? `    val client = setup.client\n\n` : ''}`)
+${liveFlowGate(entity, needs, entidEnvVar, accessor, strict, allSteps.length > 0)}`)
 
     const flowHasCreate = allSteps.some((s: any) => s.o === 'create')
     if (!flowHasCreate) {
@@ -149,11 +200,16 @@ ${allSteps.length > 0 ? `    val client = setup.client\n\n` : ''}`)
       }
     })
 
-    Content(`  }
+    Content(`${strict || 0 === allSteps.length ? '' : `    } catch (err: Throwable) {
+      RunnerSupport.liveObserve(err, setup.live, LIVE_STRICT)
+    }
+`}  }
 
 `)
 
-    const flowHasList = allSteps.some((s: any) => s.o === 'list')
+    // The stream test lists with no match, so a bare call must reach a route.
+    const flowHasList = allSteps.some((s: any) => s.o === 'list') &&
+      opReachable((entity.op as any)?.list, [])
     if (flowHasList) {
       Content(`  @Test
   fun stream() {
@@ -191,6 +247,8 @@ ${allSteps.length > 0 ? `    val client = setup.client\n\n` : ''}`)
 `)
     }
 
+    Content(failureTests(SDK, entity, accessor))
+
     // Setup function (companion object).
     Content(`  companion object {
     fun ${accessor}BasicSetup(extra: MutableMap<String, Any?>?): RunnerSupport.EntityTestSetup {
@@ -225,7 +283,7 @@ ${allSteps.length > 0 ? `    val client = setup.client\n\n` : ''}`)
           "\\"\`\\$VAL\`\\": [\\"\`\\$FORMAT\`\\", \\"upper\\", \\"\`\\$COPY\`\\"]" +
           "}]}"))
 
-      // Detect ENTID env override before envOverride consumes it.
+      // Whether *_ENTID supplied the idmap, read before envOverride consumes it.
       val entidEnvRaw = RunnerSupport.getenv("${entidEnvVar}")
       val idmapOverridden = entidEnvRaw != null && entidEnvRaw.trim().startsWith("{")
 
@@ -559,6 +617,106 @@ const GENERATE_OP: Record<string, OpGen> = {
 }
 
 
+// A failed operation throws from a stream as it does from the operation: a
+// transport failure, and a hook that rejects the call. A throwing hook fires
+// PreUnexpected, under throw false too. The caller's ctrl stays its own. An
+// invalid request fails with validate's own error, before it is sent.
+function failureTests(SDK: string, entity: ModelEntity, accessor: string): string {
+  const hasList = opReachable((entity.op as any)?.list, [])
+  const bad = invalidRequest(entity)
+  if (!hasList && null == bad) {
+    return ''
+  }
+
+  let out = `  private fun hasFeature(name: String): Boolean {
+    val fm = Helpers.toMapAny(Config.sharedConfig()["feature"])
+    return fm != null && fm[name] != null
+  }
+
+`
+
+  if (hasList) {
+    out += `  class FailHook : BaseFeature("failhook", "0.0.1", true) {
+    var unexpected = 0
+    override fun preSpec(ctx: Context) { throw RuntimeException("${entity.name} hook failed") }
+    override fun preUnexpected(ctx: Context) { unexpected++ }
+  }
+
+  @Test
+  fun streamError() {
+    val offline = linkedMapOf<String, Any?>("net" to linkedMapOf<String, Any?>("offline" to true))
+    val err = assertThrows(RuntimeException::class.java) {
+      ${SDK}.testSDK(offline, null).${accessor}(null).stream("list", null, null).toList()
+    }
+    assertTrue(err.message.orEmpty().contains("offline"), err.message)
+
+    ${SDK}.testSDK(offline, null).${accessor}(null).stream("list", null,
+      linkedMapOf<String, Any?>("ctrl" to linkedMapOf<String, Any?>("throw" to false))).toList()
+
+    if (hasFeature("rbac")) {
+      val denied = ${SDK}.testSDK(null, linkedMapOf<String, Any?>(
+        "feature" to linkedMapOf<String, Any?>(
+          "rbac" to linkedMapOf<String, Any?>("active" to true, "deny" to true))))
+      val denyerr = assertThrows(SdkError::class.java) {
+        denied.${accessor}(null).stream("list", null, null).toList()
+      }
+      assertEquals("rbac_denied", denyerr.code)
+    }
+  }
+
+  @Test
+  fun streamCtrl() {
+    val explain = linkedMapOf<String, Any?>()
+    val ctrl = linkedMapOf<String, Any?>("explain" to explain)
+    ${SDK}.testSDK().${accessor}(null).stream("list", null,
+      linkedMapOf<String, Any?>("ctrl" to ctrl)).toList()
+    assertEquals(listOf("explain"), ctrl.keys.toList())
+    assertTrue(explain === ctrl["explain"] && explain.isNotEmpty())
+  }
+
+  @Test
+  fun unexpected() {
+    val hook = FailHook()
+    val client = ${SDK}(linkedMapOf<String, Any?>(
+      "feature" to linkedMapOf<String, Any?>("test" to linkedMapOf<String, Any?>("active" to true)),
+      "extend" to mutableListOf<Any?>(hook)))
+
+    val err = assertThrows(RuntimeException::class.java) {
+      client.${accessor}(null).list(null, null)
+    }
+    assertTrue(err.message.orEmpty().contains("hook failed"), err.message)
+    assertTrue(0 < hook.unexpected)
+
+    val fired = hook.unexpected
+    client.${accessor}(null).list(null, linkedMapOf<String, Any?>("throw" to false))
+    assertTrue(fired < hook.unexpected)
+  }
+
+`
+  }
+
+  if (null != bad) {
+    const args = Object.entries(bad.args)
+      .map(([k, v]) => JSON.stringify(k) + ' to ' + JSON.stringify(v)).join(', ')
+    out += `  @Test
+  fun validate() {
+    Assumptions.assumeTrue(hasFeature("validate"), "feature not present in this SDK: validate")
+    val client = ${SDK}.testSDK(null, linkedMapOf<String, Any?>(
+      "feature" to linkedMapOf<String, Any?>(
+        "validate" to linkedMapOf<String, Any?>("active" to true))))
+    val err = assertThrows(SdkError::class.java) {
+      client.${accessor}(null).${bad.op}(linkedMapOf<String, Any?>(${args}), null)
+    }
+    assertEquals("validate_failed", err.code)
+  }
+
+`
+  }
+
+  return out
+}
+
+
 export {
   TestEntity
 }

package/project/.sdk/src/cmp/kotlin/fragment/Entity.fragment.kt

@@ -24,5 +24,7 @@ class EntyClass(clientIn: SdkClient, entoptsIn: MutableMap<String, Any?>?) :
 
 // #UpdateOp
 
+// #PatchOp
+
 // #RemoveOp
 }

package/project/.sdk/src/cmp/kotlin/fragment/EntityBase.fragment.kt

@@ -186,7 +186,8 @@ abstract class EntityBase(nm: String, clientIn: SdkClient, entoptsIn: MutableMap
 
     val signal = opts["signal"]
 
-    val ctrl = Helpers.toMapAny(opts["ctrl"]) ?: linkedMapOf()
+    // A copy: the caller's ctrl gains no key, and explain stays its own record.
+    val ctrl: MutableMap<String, Any?> = LinkedHashMap(Helpers.toMapAny(opts["ctrl"]) ?: linkedMapOf())
     ctrl["stream"] = opts
 
     val ctxmap = linkedMapOf<String, Any?>()

package/project/.sdk/src/cmp/kotlin/fragment/EntityPatchOp.fragment.kt

@@ -0,0 +1,40 @@
+package KOTLINPACKAGE.entity
+
+import KOTLINPACKAGE.core.Context
+import KOTLINPACKAGE.core.Helpers
+import KOTLINPACKAGE.core.SdkClient
+import KOTLINPACKAGE.utility.struct.Struct
+
+// Fragment carrier: only the section between the EJECT markers is spliced
+// into the generated entity class (which extends EntityBase).
+@Suppress("UNCHECKED_CAST")
+abstract class EntityPatchOpFragment(clientIn: SdkClient, entoptsIn: MutableMap<String, Any?>?) :
+  EntityBase("entityname", clientIn, entoptsIn) {
+
+// EJECT-START
+
+  override fun patch(reqdata: MutableMap<String, Any?>?, ctrl: MutableMap<String, Any?>?): Any? {
+    val ctxmap = linkedMapOf<String, Any?>()
+    ctxmap["opname"] = "patch"
+    ctxmap["ctrl"] = ctrl
+    ctxmap["match"] = this.match
+    ctxmap["data"] = this.data
+    ctxmap["reqdata"] = reqdata
+    val ctx = this.utility.makeContext(ctxmap, this.entctx)
+
+    return runOp(ctx) {
+      val result = ctx.result
+      if (result != null) {
+        if (result.resmatch != null) {
+          this.match = result.resmatch!!
+        }
+        if (result.resdata != null) {
+          val d = Helpers.toMapAny(Struct.clone(result.resdata))
+          this.data = d ?: linkedMapOf()
+        }
+      }
+    }
+  }
+
+// EJECT-END
+}

package/project/.sdk/src/cmp/lua/EntityTypes_lua.ts

@@ -67,7 +67,7 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
 `)
 
       const ops = ent.op || {}
-      ;['load', 'list', 'create', 'update', 'remove'].forEach((opname: string) => {
+      ;['load', 'list', 'create', 'update', 'patch', 'remove'].forEach((opname: string) => {
         if (null == ops[opname]) {
           return
         }

package/project/.sdk/src/cmp/lua/Entity_lua.ts

@@ -42,7 +42,7 @@ const Entity = cmp(function Entity(props: any) {
       const opnames = Object.keys(entity.op || {})
 
       const opfrags =
-        (['load', 'list', 'create', 'update', 'remove']
+        (['load', 'list', 'create', 'update', 'patch', 'remove']
           .reduce((a: any, opname: string) =>
           (a['-- #' + camelify(opname) + 'Op'] =
             !opnames.includes(opname) ? '' : ({ indent }: any) => {

package/project/.sdk/src/cmp/lua/Main_lua.ts

@@ -4,6 +4,7 @@ import * as Path from 'node:path'
 import {
   cmp, each, names, cmap,
   List, File, Content, Copy, Folder, Fragment, Line, FeatureHook,
+  inactiveFeatureExcludes,
   targetFeatures, pluginExcludes,
   TEST_CONTROL_EXCLUDE
 } from '@voxgig/sdkgen'
@@ -58,7 +59,7 @@ const Main = cmp(async function Main(props: any) {
   Copy({
     from: 'tm/' + target.name,
     exclude: [/src\//, TEST_CONTROL_EXCLUDE,
-      ...containerExcludes, ...pluginExcludes(model)],
+      ...containerExcludes, ...inactiveFeatureExcludes(props.ctx$, target), ...pluginExcludes(model)],
     replace: {
       ...props.ctx$.stdrep,
     }