@voxgig/sdkgen 2.0.1 → 3.0.0

package/project/.sdk/src/cmp/js/ReadmeTopQuick_js.ts

@@ -1,5 +1,5 @@
 
-import { cmp, Content, isAuthActive, packageName, envName, entityIdField, entityOps, opRequestShape, safeVarName, exampleVarName, jsKey } from '@voxgig/sdkgen'
+import { cmp, Content, isAuthActive, packageName, envName, entityIdField, entityOps, opRequestShape, safeVarName, exampleVarName, jsKey, matchArg, idLiteral } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -10,6 +10,17 @@ import {
 import { exampleValue } from './utility_js'
 
 
+// A `list()` on a NESTED entity needs its parent path params. The
+// quickstart used to emit `client.Moon().list()` for an entity at
+// `/planet/{planet_id}/moon`, which 404s against a live server from a
+// half-built URL — indistinguishable from "no such record". The model
+// already marks those params `reqd: true`; matchArg renders exactly them.
+function listMatchArg(ent: any): string {
+  const idF = entityIdField(ent)
+  return matchArg('ts', ent, 'list', idF, idLiteral(ent, 'list', idF))
+}
+
+
 const ReadmeTopQuick = cmp(function ReadmeTopQuick(props: any) {
   const { target, ctx$: { model } } = props
 
@@ -36,7 +47,7 @@ const client = ${ctor}
 
     if (opnames.includes('list')) {
       Content(`// List all ${eName.toLowerCase()}s (returns an array)
-const ${eVar}s = await client.${eName}().list()
+const ${eVar}s = await client.${eName}().list(${listMatchArg(exampleEntity)})
 for (const ${eVar} of ${eVar}s) {
   console.log(${eVar})
 }

package/project/.sdk/src/cmp/js/ReadmeTopTest_js.ts

@@ -51,7 +51,8 @@ const client = ${model.const.Name}SDK.test()
         `${jsKey(it.name)}: ${exampleValue(exampleEntity, primaryOpDef, it.name, 'example_' + it.name)}`).join(', ')} }`
     }
     Content(`const ${eVar} = await client.${eName}().${primaryOp}(${arg})
-// ${eVar} is ${'list' === primaryOp ? 'an array of bare entities' : 'a bare entity'} populated with mock data
+// ${eVar} is ${'list' === primaryOp ? 'an array of entities' : 'the entity'}, populated with mock data
+// — call ${eVar}${'list' === primaryOp ? '[0]' : ''}.data() for the record itself
 console.log(${eVar})
 `)
   }

package/project/.sdk/src/cmp/js/TestDirect_js.ts

@@ -17,7 +17,7 @@ import {
   cmp,
   snakify,
   isAuthActive,
-  jsProp,
+  jsProp, envName, envToken
 } from '@voxgig/sdkgen'
 
 
@@ -36,8 +36,8 @@ const TestDirect = cmp(function TestDirect(props: any) {
 
   const ff = projectPath('src/cmp/js/fragment/')
 
-  const PROJECTNAME = nom(model, 'Name').toUpperCase().replace(/[^A-Z_]/g, '_')
-  const entidEnvVar = `${PROJECTNAME}_TEST_${nom(entity, 'NAME').replace(/[^A-Z_]/g, '_')}_ENTID`
+  const PROJECTNAME = envName(model)
+  const entidEnvVar = `${PROJECTNAME}_TEST_${envToken(entity.name)}_ENTID`
 
   const authActive = isAuthActive(model)
   const apikeyEnvEntry = authActive

package/project/.sdk/src/cmp/js/TestEntity_js.ts

@@ -30,7 +30,7 @@ import {
   cmp,
   each,
   isAuthActive,
-  entityDataIdField,
+  entityDataIdField, envName, envToken
 } from '@voxgig/sdkgen'
 
 
@@ -59,8 +59,8 @@ const TestEntity = cmp(function TestEntity(props: any) {
   const target = props.target
   const entity: ModelEntity = props.entity
 
-  const PROJENVNAME = nom(model.const, 'NAME').replace(/[^A-Z_]/g, '_')
-  const ENTENVNAME = nom(entity, 'NAME').replace(/[^A-Z_]/g, '_')
+  const PROJENVNAME = envName(model)
+  const ENTENVNAME = envToken(entity.name)
   const authActive = isAuthActive(model)
   const apikeyEnvEntry = authActive
     ? `\n    '${PROJENVNAME}_APIKEY': 'NONE',`
@@ -256,7 +256,7 @@ const generateCreate: OpGen = (ctx, step, index) => {
   const hasEntIdC = null != entity.id
 
   Content(`
-    ${datavar} = await ${entvar}.create(${datavar})
+    ${datavar} = (await ${entvar}.create(${datavar})).data()
 `)
   if (hasEntIdC) {
     Content(`    assert(null != ${datavar}.id)
@@ -297,7 +297,7 @@ const generateList: OpGen = (ctx, step, index) => {
   })
 
   Content(`
-    const ${listvar} = await ${entvar}.list(${matchvar})
+    const ${listvar} = (await ${entvar}.list(${matchvar})).map((e) => e.data())
 `)
   const allSteps = flow.step
   for (let vI = 0; vI < step.valid.length; vI++) {
@@ -370,7 +370,7 @@ const generateUpdate: OpGen = (ctx, step, index) => {
   }
 
   Content(`
-    const ${resdatavar} = await ${entvar}.update(${datavar})
+    const ${resdatavar} = (await ${entvar}.update(${datavar})).data()
 `)
   if (hasEntIdU) {
     Content(`    assert(${resdatavar}.id === ${datavar}.id)
@@ -435,13 +435,13 @@ const generateLoad: OpGen = (ctx, step, index) => {
   if (hasEntId) {
     Content(`    const ${matchvar} = {}
     ${matchvar}.id = ${srcdatavar}.id
-    const ${datavar} = await ${entvar}.load(${matchvar})
+    const ${datavar} = (await ${entvar}.load(${matchvar})).data()
     assert(${datavar}.id === ${srcdatavar}.id)
 `)
   }
   else {
     Content(`    const ${matchvar} = {}
-    const ${datavar} = await ${entvar}.load(${matchvar})
+    const ${datavar} = (await ${entvar}.load(${matchvar})).data()
     assert(null != ${datavar})
 `)
   }

package/project/.sdk/src/cmp/js/fragment/EntityBase.fragment.js

@@ -24,6 +24,7 @@ class ProjectNameEntityBase {
     this._entopts = entopts
     this._utility = client.utility()
     this._data = {}
+    this._deleted = false
     this._match = {}
 
     const makeContext = this._utility.makeContext
@@ -37,6 +38,21 @@ class ProjectNameEntityBase {
     featureHook(this._entctx, 'PostConstructEntity')
   }
 
+
+  // True once a successful `remove` resolves on this instance. `remove`
+  // resolves to the entity like every other operation, and the instance KEEPS
+  // the data it held — a caller can still read what was deleted — but it is
+  // no longer a live record. See AGENTS.md.
+  markDeleted() {
+    this._deleted = true
+  }
+
+
+  deleted() {
+    return true === this._deleted
+  }
+
+
   entopts() {
     return this._utility.struct.merge([{}, this._entopts])
   }
@@ -161,7 +177,12 @@ class ProjectNameEntityBase {
 
   toJSON() {
     const struct = this._utility.struct
-    return struct.merge([{}, struct.getdef(this._data, {}), { entity$: this.Name }])
+  // The marker is NAMESPACED. It used to be `entity$` — a short, generic
+  // name, and the `$`-suffix convention is not unique to sdkgen. Seneca uses
+  // `entity$` on its own entities to hold the canon, so an SDK record fed
+  // into `entize` silently overwrote it and produced entities claiming a
+  // canon that does not exist: no error, just wrong entities.
+    return struct.merge([{}, struct.getdef(this._data, {}), { 'voxgig$entity': this.Name }])
   }
 
 

package/project/.sdk/src/cmp/js/fragment/EntityCreateOp.fragment.js

@@ -83,7 +83,15 @@ class EntityOperation {
         }
       }
 
-      return done(ctx)
+      const out = done(ctx)
+
+      // An operation resolves to the ENTITY, not the raw data — the record
+      // has just been absorbed into this instance and is reached through
+      // data(). `done` still runs: it completes the pipeline and raises on
+      // failure, and when throwing is disabled it hands back the error
+      // payload, which passes through unchanged. See AGENTS.md "Entity
+      // operations return ENTITIES".
+      return (ctx.result && ctx.result.ok) ? this : out
     }
     catch (err) {
       // #PreUnexpected-Hook

package/project/.sdk/src/cmp/js/fragment/EntityLoadOp.fragment.js

@@ -88,7 +88,15 @@ class EntityOperation {
         }
       }
 
-      return done(ctx)
+      const out = done(ctx)
+
+      // An operation resolves to the ENTITY, not the raw data — the record
+      // has just been absorbed into this instance and is reached through
+      // data(). `done` still runs: it completes the pipeline and raises on
+      // failure, and when throwing is disabled it hands back the error
+      // payload, which passes through unchanged. See AGENTS.md "Entity
+      // operations return ENTITIES".
+      return (ctx.result && ctx.result.ok) ? this : out
     }
     catch (err) {
       // #PreUnexpected-Hook

package/project/.sdk/src/cmp/js/fragment/EntityRemoveOp.fragment.js

@@ -89,7 +89,21 @@ class EntityOperation {
         }
       }
 
-      return done(ctx)
+      const out = done(ctx)
+
+      // An operation resolves to the ENTITY, not the raw data — the record
+      // has just been absorbed into this instance and is reached through
+      // data(). `done` still runs: it completes the pipeline and raises on
+      // failure, and when throwing is disabled it hands back the error
+      // payload, which passes through unchanged. See AGENTS.md "Entity
+      // operations return ENTITIES".
+      if (ctx.result && ctx.result.ok) {
+        // A removed entity keeps its data but is no longer a live record.
+        this.markDeleted()
+        return this
+      }
+
+      return out
     }
     catch (err) {
       // #PreUnexpected-Hook

package/project/.sdk/src/cmp/js/fragment/EntityUpdateOp.fragment.js

@@ -89,7 +89,15 @@ class EntityOperation {
         }
       }
 
-      return done(ctx)
+      const out = done(ctx)
+
+      // An operation resolves to the ENTITY, not the raw data — the record
+      // has just been absorbed into this instance and is reached through
+      // data(). `done` still runs: it completes the pipeline and raises on
+      // failure, and when throwing is disabled it hands back the error
+      // payload, which passes through unchanged. See AGENTS.md "Entity
+      // operations return ENTITIES".
+      return (ctx.result && ctx.result.ok) ? this : out
     }
     catch (err) {
       // #PreUnexpected-Hook

package/project/.sdk/src/cmp/js/fragment/SdkError.fragment.js

@@ -10,8 +10,21 @@ class ProjectNameError extends Error {
     super(msg)
     this.code = code
     this.ctx = ctx
+
+    // HTTP status of the response that caused this error, or -1 when the
+    // request never got one (transport failure, client-side abort).
+    //
+    // PROMOTED to the top level on purpose. It used to be reachable only at
+    // `err.result.status`, so every consumer wrote the same
+    // `404 === e?.result?.status` branch and coupled itself to the internal
+    // shape of `result`.
+    this.status = -1
   }
 
+
+  // `err.notFound` rather than a magic number at every call site.
+  get notFound() { return 404 === this.status }
+
 }
 
 module.exports = {

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

@@ -4,6 +4,7 @@ import {
   File,
   cmp,
   collectDeps,
+  packageVersion,
 } from '@voxgig/sdkgen'
 
 
@@ -53,7 +54,7 @@ const Package = cmp(async function Package(props: any) {
 }
 
 group = "${group}"
-version = "0.0.1"
+version = "${packageVersion(model, target.name)}"
 
 repositories {
     mavenCentral()

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

@@ -51,7 +51,8 @@ const ReadmeHowto = cmp(function ReadmeHowto(props: any) {
   // The op-driven test-mode line, shown only when the SDK has an entity op.
   // A direct()-only SDK (no ops anywhere) shows a direct() call instead.
   const testModeExample = primaryOp
-    ? `// Entity ops return the bare record and raise on error.
+    ? `// Entity ops return the ENTITY and raises on error;
+// call data() for the record.
 val ${eVar} = client.${accessor}(null).${primaryOp}(${testArg}, null)
 // ${eVar} holds the mock response record
 println(${eVar})`

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

@@ -1,5 +1,5 @@
 
-import { cmp, Content, isPublished, repoInfo } from '@voxgig/sdkgen'
+import { cmp, Content, isPublished, repoInfo, packageVersion } from '@voxgig/sdkgen'
 
 import { gradleGroup } from './utility_kotlin'
 
@@ -16,7 +16,7 @@ const ReadmeInstall = cmp(function ReadmeInstall(props: any) {
 
 \`\`\`kotlin
 dependencies {
-    implementation("${group}:${artifactId}:0.0.1")
+    implementation("${group}:${artifactId}:${packageVersion(model, target.name)}")
 }
 \`\`\`
 

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

@@ -93,7 +93,7 @@ ${opRows}
 
 ### Result shape
 
-Entity operations return the bare result data (a \`Map\` for single-entity
+Entity operations return the ENTITY (call data() for the record) (a \`Map\` for single-entity
 ops, an aggregate \`List\` for \`list\`) as \`Any?\` and raise on error. Wrap
 calls in \`try\`/\`catch\` to handle failures.
 

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

@@ -123,7 +123,7 @@ catch (err: RuntimeException) {
       Content(`### 3. Load ${neArticle} ${neName.toLowerCase()}
 
 ${neName} is nested under ${parentName}, so provide the \`${parentParam}\`.
-\`load()\` returns the bare record (as \`Any?\`) and raises on error.
+\`load()\` returns the ENTITY — call data() for the record — and raises on error.
 
 \`\`\`kotlin
 try {
@@ -151,7 +151,7 @@ catch (err: RuntimeException) {
 
       Content(`### 3. Load ${article} ${eName.toLowerCase()}
 
-\`load()\` returns the bare record (as \`Any?\`) and raises on error.
+\`load()\` returns the ENTITY — call data() for the record — and raises on error.
 
 \`\`\`kotlin
 try {
@@ -191,7 +191,7 @@ catch (err: RuntimeException) {
 \`\`\`kotlin
 `)
       if (opnames.includes('create')) {
-        Content(`// Create — returns the bare created record (as Any?)
+        Content(`// Create — returns the ENTITY (call data() for the record)
 val created = client.${accessor}(null).create(mutableMapOf<String, Any?>(${examplePairs('create').join(', ')}), null)
 
 `)

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

@@ -11,7 +11,7 @@ import {
   File,
   cmp,
   snakify,
-  isAuthActive,
+  isAuthActive, envName, envToken
 } from '@voxgig/sdkgen'
 
 
@@ -67,7 +67,7 @@ const TestDirect = cmp(function TestDirect(props: any) {
   const entity: ModelEntity = props.entity
   const kotlinpackage: string = props.kotlinpackage
 
-  const PROJECTNAME = nom(model, 'Name').toUpperCase().replace(/[^A-Z_]/g, '_')
+  const PROJECTNAME = envName(model)
   const SDK = model.const.Name + 'SDK'
 
   const authActive = isAuthActive(model)
@@ -121,7 +121,7 @@ const TestDirect = cmp(function TestDirect(props: any) {
     ? loadParams.map((p: any) => `      params["${p.name}"] = ${kotlinLiteral(p.example)}`).join('\n')
     : ''
 
-  const entidEnvVar = `${PROJECTNAME}_TEST_${nom(entity, 'NAME').replace(/[^A-Z_]/g, '_')}_ENTID`
+  const entidEnvVar = `${PROJECTNAME}_TEST_${envToken(entity.name)}_ENTID`
 
   File({ name: entity.Name + 'DirectTest.' + target.ext }, () => {
 

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

@@ -17,7 +17,7 @@ import {
   each,
   buildIdNames,
   getMatchEntries,
-  isAuthActive,
+  isAuthActive, envName, envToken
 } from '@voxgig/sdkgen'
 
 
@@ -56,8 +56,8 @@ const TestEntity = cmp(function TestEntity(props: any) {
     return
   }
 
-  const PROJUPPER = nom(model.const, 'Name').toUpperCase().replace(/[^A-Z_]/g, '_')
-  const ENTUPPER = entity.name.toUpperCase().replace(/[^A-Z_]/g, '_')
+  const PROJUPPER = envName(model)
+  const ENTUPPER = envToken(entity.name)
   const entidEnvVar = `${PROJUPPER}_TEST_${ENTUPPER}_ENTID`
 
   const SDK = model.const.Name + 'SDK'
@@ -317,7 +317,7 @@ const generateCreate: OpGen = (ctx, step, index) => {
 
   Content(`
     val ${datavar}Result = ${entvar}.create(${datavar}, null)
-    ${datavar} = Helpers.toMapAny(${datavar}Result) ?: linkedMapOf()
+    ${datavar} = Helpers.toMapAny(if (${datavar}Result is SdkEntity) ${datavar}Result.data() else ${datavar}Result) ?: linkedMapOf()
     assertNotNull(${datavar}, "expected create result to be a map")
 `)
   if (null != ctx.entity.id) {
@@ -451,7 +451,7 @@ const generateUpdate: OpGen = (ctx, step, index) => {
 
   Content(`
     val ${resdatavar}Result = ${entvar}.update(${datavar}Up, null)
-    val ${resdatavar} = Helpers.toMapAny(${resdatavar}Result) ?: linkedMapOf()
+    val ${resdatavar} = Helpers.toMapAny(if (${resdatavar}Result is SdkEntity) ${resdatavar}Result.data() else ${resdatavar}Result) ?: linkedMapOf()
     assertNotNull(${resdatavar}, "expected update result to be a map")
 `)
   if (hasEntIdU) {
@@ -516,7 +516,7 @@ const generateLoad: OpGen = (ctx, step, index) => {
   if (hasEntId) {
     Content(`    ${matchvar}["id"] = ${srcdatavar}["id"]
     val ${datavar}Loaded = ${entvar}.load(${matchvar}, null)
-    val ${datavar}LoadResult = Helpers.toMapAny(${datavar}Loaded) ?: linkedMapOf()
+    val ${datavar}LoadResult = Helpers.toMapAny(if (${datavar}Loaded is SdkEntity) ${datavar}Loaded.data() else ${datavar}Loaded) ?: linkedMapOf()
     assertNotNull(${datavar}LoadResult, "expected load result to be a map")
     assertEquals(${srcdatavar}["id"], ${datavar}LoadResult["id"],
         "expected load result id to match")

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

@@ -71,6 +71,18 @@ abstract class EntityBase(nm: String, clientIn: SdkClient, entoptsIn: MutableMap
   // runOp drives one operation through the pipeline: for each stage the
   // feature hook fires, then the stage runs; a failing stage routes through
   // makeError (which throws, or returns fallback data when ctrl.throw false).
+  // Every operation resolves to the entity; `remove` additionally marks
+  // it. The instance KEEPS the data it held — a caller can still read
+  // what was deleted — but it is no longer a live record. See AGENTS.md.
+  private var deletedFlag: Boolean = false
+
+  fun markDeleted() {
+    this.deletedFlag = true
+  }
+
+  fun deleted(): Boolean = this.deletedFlag
+
+
   protected fun runOp(ctx: Context, postDone: () -> Unit): Any? {
     val utility = this.utility
 
@@ -104,7 +116,26 @@ abstract class EntityBase(nm: String, clientIn: SdkClient, entoptsIn: MutableMap
 
       postDone()
 
-      return utility.done(ctx)
+      val out = utility.done(ctx)
+
+      // An operation resolves to the ENTITY, not the raw data. Entities are
+      // stateful: postDone has just absorbed resdata/resmatch into this
+      // instance, and the caller reaches the record through data(). Two
+      // structural exceptions: `list` resolves to the ARRAY of entity
+      // instances makeResult built, and a failed op with throwing disabled
+      // hands back the error payload unchanged. `remove` additionally marks
+      // the entity deleted; it KEEPS its data, so a caller can still read
+      // what was removed. See AGENTS.md "Entity operations return ENTITIES".
+      val opname = ctx.op?.name
+
+      if (ctx.result != null && ctx.result!!.ok && "list" != opname) {
+        if ("remove" == opname) {
+          this.markDeleted()
+        }
+        return this
+      }
+
+      return out
     } catch (err: RuntimeException) {
       // An error already finalised by makeError (e.g. via done) must not be
       // wrapped a second time.

package/project/.sdk/src/cmp/lean/Package_lean.ts

@@ -2,6 +2,7 @@ import {
   Content,
   File,
   cmp,
+  packageVersion,
 } from '@voxgig/sdkgen'
 
 import type {
@@ -22,6 +23,7 @@ const LIBS = [
 
 const Package = cmp(async function Package(props: any) {
   const ctx$ = props.ctx$
+  const target = props.target
   const model: Model = ctx$.model
 
   const libBlocks = LIBS.map((n) =>
@@ -30,7 +32,7 @@ const Package = cmp(async function Package(props: any) {
   File({ name: 'lakefile.toml' }, () => {
     Content(`# ${model.const.Name} SDK for Lean 4 (generated by @voxgig/sdkgen).
 name = "${pkgName(model)}"
-version = "0.0.1"
+version = "${packageVersion(model, target.name)}"
 defaultTargets = ["SdkClient"]
 
 ${libBlocks}

package/project/.sdk/src/cmp/lean/Test_lean.ts

@@ -26,6 +26,21 @@ function hasParamFreePoint(op: any): boolean {
 }
 
 
+// True when an op selects a single record by path params — i.e. loading it by
+// id is meaningful. A load whose every point is param-free is a singleton
+// endpoint (`/current`): passing it an id matches no point at all, and the
+// runtime raises `has no matching endpoint`.
+function selectsByParams(op: any): boolean {
+  if (null == op) return false
+  const points = op.points || []
+  for (const pt of points) {
+    const params = ((pt.args || {}).params) || []
+    if (0 < params.length) return true
+  }
+  return false
+}
+
+
 // Synthesize a create payload from the entity's required non-id fields.
 function synthData(fields: any): any {
   const o: any = {}
@@ -64,30 +79,44 @@ const Test = cmp(async function Test(props: any) {
     const Name = e.Name || (e.name.charAt(0).toUpperCase() + e.name.slice(1))
     const ops = e.op || {}
     if (!ops.list && !ops.load) return
-    offline += `    -- ${e.name}: offline (test-mode) entity behaviour
-    (do
-      let seedPath := "../.sdk/test/entity/${e.name}/${Name}TestData.json"
-      if !(← System.FilePath.pathExists seedPath) then
-        IO.println s!"skip - ${e.name}: no seed at {seedPath}"
-      else do
-        let seed ← SdkJson.jsonRead (← IO.FS.readFile seedPath)
-        let tclient ← Sdk.testSdk0 seed
-        let existing ← SdkRuntime.gp (← SdkRuntime.gp seed "existing") "${e.name}"
-        let ids ← keysof existing
-        -- list returns every seeded entity
+
+    // Only call the ops the entity actually declares. `Entity.create` is not
+    // generated for a load-only entity, so emitting the create/remove block
+    // unconditionally fails the build with "Unknown identifier X.create".
+    // Value's constructors are spelled out (`Value.list`, not `.list`) — the
+    // expected type is not known at the match scrutinee, and Lean reports the
+    // dotted form as ambiguous against Std's own `.list`.
+    let body = ''
+
+    if (ops.list) {
+      body += `        -- list returns every seeded entity
         let items ← ${ns}.list tclient (← emptyMap) (← emptyMap)
-        let n ← (match items with | .list lid => do pure (← listItems lid).size | _ => pure 0)
+        let n ← (match items with | Value.list lid => do pure (← listItems lid).size | _ => pure 0)
         if n == ids.size then pass s!"${e.name}.list offline -> {n} seeded"
         else fail s!"${e.name}.list offline: got {n}, want {ids.size}"
-        -- load the first seeded entity by id
+`
+    }
+
+    if (ops.load && selectsByParams(ops.load)) {
+      body += `        -- load the first seeded entity by id
         if ids.size > 0 then do
           let wid := ids[0]!
-          let m ← newMap #[("id", .str wid)]
+          let m ← newMap #[("id", Value.str wid)]
           let got ← ${ns}.load tclient m (← emptyMap)
           let gid ← SdkRuntime.gpS got "id"
           if gid == wid then pass s!"${e.name}.load offline (id={wid})"
           else fail s!"${e.name}.load offline: got {gid}, want {wid}"
-        -- create -> load back -> remove, all in the store
+`
+    }
+    // A singleton load (`/current`, `/slack`) is deliberately NOT asserted
+    // here. The offline lane answers from a store keyed by entity id, so a
+    // load carrying no id has nothing to look up — the only honest assertion
+    // would need the model-driven match data the other targets build in their
+    // TestEntity components. Until this lane is model-driven too, such an
+    // entity contributes no offline block rather than a misleading one.
+
+    if (ops.create && ops.load && ops.remove) {
+      body += `        -- create -> load back -> remove, all in the store
         let newmap ← SdkRuntime.gp (← SdkRuntime.gp seed "new") "${e.name}"
         let nks ← keysof newmap
         if nks.size > 0 then do
@@ -95,7 +124,7 @@ const Test = cmp(async function Test(props: any) {
           let created ← ${ns}.create tclient payload (← emptyMap)
           let cid ← SdkRuntime.gpS created "id"
           if cid == "" then fail "${e.name}.create offline returned no id" else do
-            let m2 ← newMap #[("id", .str cid)]
+            let m2 ← newMap #[("id", Value.str cid)]
             let back ← ${ns}.load tclient m2 (← emptyMap)
             if (← SdkRuntime.gpS back "id") == cid then
               pass s!"${e.name}.create/load offline (id={cid})"
@@ -103,8 +132,26 @@ const Test = cmp(async function Test(props: any) {
             let _ ← ${ns}.remove tclient m2 (← emptyMap)
             let gone ← ${ns}.load tclient m2 (← emptyMap)
             match gone with
-            | .map _ => fail s!"${e.name}.remove offline: still present"
-            | _ => pass s!"${e.name}.remove offline (id={cid})")
+            | Value.map _ => fail s!"${e.name}.remove offline: still present"
+            | _ => pass s!"${e.name}.remove offline (id={cid})"
+`
+    }
+
+    // Nothing to assert (an entity whose only op needs path params we cannot
+    // synthesise) — skip the block rather than emit an empty `do`.
+    if ('' === body) return
+
+    offline += `    -- ${e.name}: offline (test-mode) entity behaviour
+    (do
+      let seedPath := "../.sdk/test/entity/${e.name}/${Name}TestData.json"
+      if !(← System.FilePath.pathExists seedPath) then
+        IO.println s!"skip - ${e.name}: no seed at {seedPath}"
+      else do
+        let seed ← SdkJson.jsonRead (← IO.FS.readFile seedPath)
+        let tclient ← Sdk.testSdk0 seed
+        let existing ← SdkRuntime.gp (← SdkRuntime.gp seed "existing") "${e.name}"
+        let ids ← keysof existing
+${body})
 `
   })
 
@@ -121,7 +168,7 @@ const Test = cmp(async function Test(props: any) {
     (do
       let items ← ${ns}.list client (← emptyMap) (← emptyMap)
       match items with
-      | .list lid => pass s!"${e.name}.list -> {(← listItems lid).size} items"
+      | Value.list lid => pass s!"${e.name}.list -> {(← listItems lid).size} items"
       | _ => fail "${e.name}.list did not return a list")
 `
     }
@@ -151,6 +198,13 @@ const Test = cmp(async function Test(props: any) {
   // The live lane nests two levels deeper than the offline lane.
   const liveBlocks = blocks.split('\n').map((l) => l ? '  ' + l : l).join('\n')
 
+  // A `do` block whose last statement is a `let` is a type error in Lean
+  // ("the rest of the do block has monadic result type"), and an entirely
+  // empty one does not parse at all. An API whose entities offer no op these
+  // lanes can drive leaves both empty, so terminate them explicitly.
+  const offlineBody = '' === offline ? '    pure ()\n' : offline
+  const liveBody = '' === blocks ? '      pure ()\n' : liveBlocks
+
   Folder({ name: 'test' }, () => {
   File({ name: 'Runner.' + target.ext }, () => {
     Content(`-- ${model.const.Name} SDK test runner (generated by @voxgig/sdkgen).
@@ -183,14 +237,14 @@ def main : IO UInt32 := do
   let liveBase ← IO.getEnv "SDK_TEST_BASE"
   let ctx ← mkCtx
   let offline : SIO Unit := do
-${offline}  offline.run ctx
+${offlineBody}  offline.run ctx
   match liveBase with
   | none => IO.println "skip - live lane (set SDK_TEST_BASE to enable)"
   | some base => do
     let live : SIO Unit := do
       let opts ← newMap #[("base", .str base)]
       let client ← Sdk.newSdk opts
-${liveBlocks}    live.run ctx
+${liveBody}    live.run ctx
   let p ← npass.get
   let f ← nfail.get
   IO.println ""