@voxgig/sdkgen 2.0.2 → 3.1.0

package/project/.sdk/src/cmp/py/TestEntity_py.ts

@@ -24,7 +24,7 @@ import {
   buildIdNames,
   getMatchEntries,
   isAuthActive,
-  entityDataIdField,
+  entityDataIdField, envName, envToken
 } from '@voxgig/sdkgen'
 
 
@@ -56,7 +56,7 @@ const TestEntity = cmp(function TestEntity(props: any) {
     return
   }
 
-  const PROJUPPER = nom(model.const, 'Name').toUpperCase().replace(/[^A-Z_]/g, '_')
+  const PROJUPPER = envName(model)
 
   const authActive = isAuthActive(model)
   const apikeyEnvEntry = authActive
@@ -158,7 +158,7 @@ ${hasList ? `
         # without an *_ENTID env override, those IDs hit the live API and 4xx.
         if setup.get("synthetic_only"):
             pytest.skip("live entity test uses synthetic IDs from fixture — "
-                        "set ${PROJUPPER}_TEST_${entity.name.toUpperCase().replace(/[^A-Z_]/g, '_')}_ENTID JSON to run live")
+                        "set ${PROJUPPER}_TEST_${envToken(entity.name)}_ENTID JSON to run live")
         client = setup["client"]
 
 `)
@@ -229,17 +229,17 @@ def _${entity.name}_basic_setup(extra):
     # mode is on without a real override, the basic test runs against synthetic
     # IDs from the fixture and 4xx's. We surface this so the test can skip.
     _entid_env_raw = os.environ.get(
-        "${PROJUPPER}_TEST_${entity.name.toUpperCase().replace(/[^A-Z_]/g, '_')}_ENTID")
+        "${PROJUPPER}_TEST_${envToken(entity.name)}_ENTID")
     _idmap_overridden = _entid_env_raw is not None and _entid_env_raw.strip().startswith("{")
 
     env = runner.env_override({
-        "${PROJUPPER}_TEST_${entity.name.toUpperCase().replace(/[^A-Z_]/g, '_')}_ENTID": idmap,
+        "${PROJUPPER}_TEST_${envToken(entity.name)}_ENTID": idmap,
         "${PROJUPPER}_TEST_LIVE": "FALSE",
         "${PROJUPPER}_TEST_EXPLAIN": "FALSE",${apikeyEnvEntry}
     })
 
     idmap_resolved = helpers.to_map(
-        env.get("${PROJUPPER}_TEST_${entity.name.toUpperCase().replace(/[^A-Z_]/g, '_')}_ENTID"))
+        env.get("${PROJUPPER}_TEST_${envToken(entity.name)}_ENTID"))
     if idmap_resolved is None:
         idmap_resolved = helpers.to_map(idmap)
 `)
@@ -321,7 +321,7 @@ const generateCreate: OpGen = (ctx, step, index) => {
   const hasEntIdC = null != ctx.entity.id
 
   Content(`
-        ${datavar} = helpers.to_map(${entvar}.create(${datavar}, None))
+        ${datavar} = helpers.to_map(runner.entity_data(${entvar}.create(${datavar}, None)))
         assert ${datavar} is not None
 `)
   if (hasEntIdC) {
@@ -454,7 +454,7 @@ const generateUpdate: OpGen = (ctx, step, index) => {
   }
 
   Content(`
-        ${resdatavar} = helpers.to_map(${entvar}.update(${datavar}_up, None))
+        ${resdatavar} = helpers.to_map(runner.entity_data(${entvar}.update(${datavar}_up, None)))
         assert ${resdatavar} is not None
 `)
   if (hasEntIdU) {
@@ -518,7 +518,7 @@ const generateLoad: OpGen = (ctx, step, index) => {
             "id": ${srcdatavar}["id"],
         }
         ${datavar}_loaded = ${entvar}.load(${matchvar}, None)
-        ${datavar}_load_result = helpers.to_map(${datavar}_loaded)
+        ${datavar}_load_result = helpers.to_map(runner.entity_data(${datavar}_loaded))
         assert ${datavar}_load_result is not None
         assert ${datavar}_load_result["id"] == ${srcdatavar}["id"]
 `)

package/project/.sdk/src/cmp/py/fragment/Entity.fragment.py

@@ -24,6 +24,7 @@ class EntyClass:
         self._utility = client.get_utility()
         self._entopts = entopts
         self._data = {}
+        self._deleted = False
         self._match = {}
 
         self._entctx = self._utility.make_context({
@@ -36,6 +37,16 @@ class EntyClass:
     def get_name(self):
         return self._name
 
+    # 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.
+    def mark_deleted(self):
+        self._deleted = True
+
+    def deleted(self):
+        return True is self._deleted
+
+
     def make(self):
         opts = {}
         for k, v in self._entopts.items():
@@ -214,7 +225,24 @@ class EntyClass:
 
             post_done()
 
-            return utility.done(ctx)
+            out = utility.done(ctx)
+
+    # An operation resolves to the ENTITY, not the raw data. Entities are
+    # stateful: post_done 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 make_result 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".
+            opname = None if ctx.op is None else ctx.op.name
+
+            if ctx.result is not None and ctx.result.ok and opname != "list":
+                if opname == "remove":
+                    self.mark_deleted()
+                return self
+
+            return out
 
         except Exception:
             # #PreUnexpected-Hook

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

@@ -7,8 +7,19 @@ class ProjectNameError(Exception):
         self.code = code
         self.msg = msg
         self.sdk = "ProjectName"
+
+        # HTTP status of the response that caused this error, or -1 when the
+        # request never got one. PROMOTED to the top level: it used to be
+        # reachable only at `err.result.status`, so every consumer coupled
+        # itself to the internal shape of `result`.
+        self.status = -1
+
         super().__init__(self.error())
 
+    @property
+    def not_found(self):
+        return 404 == self.status
+
     def error(self):
         return self.sdk + ": " + self.code + ": " + self.msg
 

package/project/.sdk/src/cmp/py-data/Main_py-data.ts

@@ -6,6 +6,7 @@ import {
   collectDeps, pkgDescription, keywords, repoInfo, envName, apiName,
   packageName, registryState, serverVariables,
   SdkGenError,
+  packageVersion,
 } from '@voxgig/sdkgen'
 
 import {
@@ -147,7 +148,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "${distName}"
-version = "0.0.1"
+version = "${packageVersion(model, target.name)}"
 description = "${pkgDescription(model, 'py-data')}"
 readme = "README.md"
 license = "MIT"

package/project/.sdk/src/cmp/rb/Package_rb.ts

@@ -5,7 +5,8 @@ import {
   cmp,
   collectDeps,
   pkgDescription,
-  repoInfo,
+  repoInfo, packageName,
+  packageVersion
 } from '@voxgig/sdkgen'
 
 
@@ -25,7 +26,7 @@ const Package = cmp(async function Package(props: any) {
   // path (`${model.name}_sdk`) is unchanged.
   const ns = model.origin || 'voxgig-sdk'
   const pkgBase = ns.endsWith('-sdk') ? model.name : `${model.name}-sdk`
-  const gemName = `${ns}-${pkgBase}`
+  const gemName = packageName(model, 'rb')
   const { repoUrl, issuesUrl, changelogUrl } = repoInfo(model)
 
   const versionOf = (d: { version: string; source: 'feature' | 'target' }) =>
@@ -56,7 +57,7 @@ gemspec
 
     Content(`Gem::Specification.new do |spec|
   spec.name          = "${gemName}"
-  spec.version       = "0.0.1"
+  spec.version       = "${packageVersion(model, target.name)}"
   spec.authors       = ["Voxgig"]
   spec.summary       = "${pkgDescription(model, 'rb')}"
   spec.description   = "${pkgDescription(model, 'rb')}"

package/project/.sdk/src/cmp/rb/ReadmeEntity_rb.ts

@@ -126,7 +126,7 @@ const ReadmeEntity = cmp(function ReadmeEntity(props: any) {
       Content(`#### Example: Load
 
 \`\`\`ruby
-# load returns the bare ${entity.Name} record (raises on error).
+# load returns the ENTITY — call data_get for the ${entity.Name} record (raises on error).
 ${eVar} = client.${entity.Name}.load(${loadArg})
 \`\`\`
 

package/project/.sdk/src/cmp/rb/ReadmeHowto_rb.ts

@@ -65,7 +65,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 mock record (raises on error).
+    ? `# Entity ops return the ENTITY (raises on error);
+// call data_get for the mock record.
 ${eVar} = client.${eName}.${primaryOp}(${testCallArg})
 puts ${eVar}`
     : `result = client.direct({ "path" => "/api/resource", "method" => "GET" })

package/project/.sdk/src/cmp/rb/ReadmeQuick_rb.ts

@@ -125,7 +125,7 @@ ${neName} is nested under ${parentName}, so provide the \`${parentParam}\`.
 
 \`\`\`ruby
 begin
-  # load returns the bare ${neName} record (raises on error).
+  # load returns the ENTITY — call data_get for the ${neName} record (raises on error).
   ${neVar} = client.${neName}.load({ ${neMatch.join(', ')} })
   puts ${neVar}
 rescue => err
@@ -153,7 +153,7 @@ end
 
 \`\`\`ruby
 begin
-  # load returns the bare ${eName} record (raises on error).
+  # load returns the ENTITY — call data_get for the ${eName} record (raises on error).
   ${eVar} = client.${eName}.load(${loadArg})
   puts ${eVar}
 rescue => err
@@ -193,7 +193,7 @@ end
       return it && it.type
     }
     const idValueFor = (opname: string): string => (null != dataIdF && opnames.includes('create'))
-      ? `created["${dataIdF}"]`
+      ? `created.data_get["${dataIdF}"]`
       : rbLit(idParamType(opname), 'example_id')
 
     if (opnames.includes('create') || opnames.includes('update') || opnames.includes('remove')) {
@@ -202,7 +202,7 @@ end
 \`\`\`ruby
 `)
       if (opnames.includes('create')) {
-        Content(`# create returns the bare created ${eName} record.
+        Content(`# create returns the ENTITY — call data_get for the created ${eName} record.
 created = client.${eName}.create({ ${examplePairs('create').join(', ')} })
 
 `)
@@ -210,7 +210,7 @@ created = client.${eName}.create({ ${examplePairs('create').join(', ')} })
       if (opnames.includes('update')) {
         const updatePairs = (idF ? [`"${idF}" => ${idValueFor('update')}`] : []).concat(examplePairs('update'))
         const fromCreated = null != dataIdF && opnames.includes('create')
-        Content(`# Update${fromCreated ? ` — index the bare record directly (created["${dataIdF}"]).` : ''}
+        Content(`# Update${fromCreated ? ` — index the record via data_get (created.data_get["${dataIdF}"]).` : ''}
 client.${eName}.update({ ${updatePairs.join(', ')} })
 
 `)

package/project/.sdk/src/cmp/rb/ReadmeTopQuick_rb.ts

@@ -75,7 +75,7 @@ puts ${eVar}s
             it.name === idF ? 'example_id' : 'example_' + it.name)}`).join(', ')} }`
         : ''
       Content(`
-# Load a specific ${eName.toLowerCase()} (returns the bare record; raises on error)
+# Load a specific ${eName.toLowerCase()} (returns the ENTITY; call data_get for the record)
 ${eVar} = client.${eName}.load(${loadArg})
 puts ${eVar}
 `)

package/project/.sdk/src/cmp/rb/TestDirect_rb.ts

@@ -11,7 +11,7 @@ import {
   File,
   cmp,
   snakify,
-  isAuthActive,
+  isAuthActive, envName, envToken
 } from '@voxgig/sdkgen'
 
 
@@ -60,7 +60,7 @@ const TestDirect = cmp(function TestDirect(props: any) {
   const target = props.target
   const entity: ModelEntity = props.entity
 
-  const PROJECTNAME = nom(model, 'Name').toUpperCase().replace(/[^A-Z_]/g, '_')
+  const PROJECTNAME = envName(model)
 
   const authActive = isAuthActive(model)
   const apikeyEnvEntry = authActive
@@ -125,7 +125,7 @@ const TestDirect = cmp(function TestDirect(props: any) {
     ? loadParams.map((p: any) => `      params["${p.name}"] = ${JSON.stringify(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 + '_direct_test.' + target.ext }, () => {
 

package/project/.sdk/src/cmp/rb/TestEntity_rb.ts

@@ -24,7 +24,7 @@ import {
   buildIdNames,
   getMatchEntries,
   isAuthActive,
-  entityDataIdField,
+  entityDataIdField, envName, envToken
 } from '@voxgig/sdkgen'
 
 
@@ -58,7 +58,7 @@ const TestEntity = cmp(function TestEntity(props: any) {
     return
   }
 
-  const PROJUPPER = nom(model.const, 'Name').toUpperCase().replace(/[^A-Z_]/g, '_')
+  const PROJUPPER = envName(model)
 
   const authActive = isAuthActive(model)
   const apikeyEnvEntry = authActive
@@ -146,7 +146,7 @@ ${hasList ? `
     # The basic flow consumes synthetic IDs from the fixture. In live mode
     # without an *_ENTID env override, those IDs hit the live API and 4xx.
     if setup[:synthetic_only]
-      skip "live entity test uses synthetic IDs from fixture — set ${PROJUPPER}_TEST_${entity.name.toUpperCase().replace(/[^A-Z_]/g, '_')}_ENTID JSON to run live"
+      skip "live entity test uses synthetic IDs from fixture — set ${PROJUPPER}_TEST_${envToken(entity.name)}_ENTID JSON to run live"
       return
     end
     client = setup[:client]
@@ -221,17 +221,17 @@ end
     Content(`  # Detect ENTID env override before envOverride consumes it. When live
   # mode is on without a real override, the basic test runs against synthetic
   # IDs from the fixture and 4xx's. Surface this so the test can skip.
-  entid_env_raw = ENV["${PROJUPPER}_TEST_${entity.name.toUpperCase().replace(/[^A-Z_]/g, '_')}_ENTID"]
+  entid_env_raw = ENV["${PROJUPPER}_TEST_${envToken(entity.name)}_ENTID"]
   idmap_overridden = !entid_env_raw.nil? && entid_env_raw.strip.start_with?("{")
 
   env = Runner.env_override({
-    "${PROJUPPER}_TEST_${entity.name.toUpperCase().replace(/[^A-Z_]/g, '_')}_ENTID" => idmap,
+    "${PROJUPPER}_TEST_${envToken(entity.name)}_ENTID" => idmap,
     "${PROJUPPER}_TEST_LIVE" => "FALSE",
     "${PROJUPPER}_TEST_EXPLAIN" => "FALSE",${apikeyEnvEntry}
   })
 
   idmap_resolved = Helpers.to_map(
-    env["${PROJUPPER}_TEST_${entity.name.toUpperCase().replace(/[^A-Z_]/g, '_')}_ENTID"])
+    env["${PROJUPPER}_TEST_${envToken(entity.name)}_ENTID"])
   if idmap_resolved.nil?
     idmap_resolved = Helpers.to_map(idmap)
   end
@@ -316,7 +316,7 @@ const generateCreate: OpGen = (ctx, step, index) => {
 
   Content(`
     ${datavar}_result = ${entvar}.create(${datavar}, nil)
-    ${datavar} = Helpers.to_map(${datavar}_result)
+    ${datavar} = Helpers.to_map(${datavar}_result.respond_to?(:data_get) ? ${datavar}_result.data_get : ${datavar}_result)
     assert !${datavar}.nil?
 `)
   if (null != ctx.entity.id) {
@@ -450,7 +450,7 @@ const generateUpdate: OpGen = (ctx, step, index) => {
 
   Content(`
     ${resdatavar}_result = ${entvar}.update(${datavar}_up, nil)
-    ${resdatavar} = Helpers.to_map(${resdatavar}_result)
+    ${resdatavar} = Helpers.to_map(${resdatavar}_result.respond_to?(:data_get) ? ${resdatavar}_result.data_get : ${resdatavar}_result)
     assert !${resdatavar}.nil?
 `)
   if (hasEntIdU) {
@@ -515,7 +515,7 @@ const generateLoad: OpGen = (ctx, step, index) => {
       "id" => ${srcdatavar}["id"],
     }
     ${datavar}_loaded = ${entvar}.load(${matchvar}, nil)
-    ${datavar}_load_result = Helpers.to_map(${datavar}_loaded)
+    ${datavar}_load_result = Helpers.to_map(${datavar}_loaded.respond_to?(:data_get) ? ${datavar}_loaded.data_get : ${datavar}_loaded)
     assert !${datavar}_load_result.nil?
     assert_equal ${datavar}_load_result["id"], ${srcdatavar}["id"]
 `)

package/project/.sdk/src/cmp/rb/fragment/Entity.fragment.rb

@@ -19,6 +19,7 @@ class EntyClass
     @_utility = client.get_utility
     @_entopts = entopts
     @_data = {}
+    @_deleted = false
     @_match = {}
 
     @_entctx = @_utility.make_context.call({
@@ -33,6 +34,18 @@ class EntyClass
     @_name
   end
 
+  # 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.
+  def mark_deleted
+    @_deleted = true
+  end
+
+  def deleted
+    true == @_deleted
+  end
+
+
   def make
     opts = @_entopts.dup
     EntyClass.new(@_client, opts)
@@ -207,7 +220,24 @@ class EntyClass
 
       post_done.call
 
-      utility.done.call(ctx)
+      out = utility.done.call(ctx)
+
+    # An operation resolves to the ENTITY, not the raw data. Entities are
+    # stateful: post_done 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 make_result 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".
+      opname = ctx.op&.name
+
+      if ctx.result && ctx.result.ok && opname != "list"
+        mark_deleted if opname == "remove"
+        return self
+      end
+
+      out
     rescue StandardError => operr
       # #PreUnexpected-Hook
 

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

@@ -1,13 +1,22 @@
 # ProjectName SDK error
 
 class ProjectNameError < StandardError
-  attr_accessor :code, :msg, :sdk
+  # `status` is the HTTP status of the response that caused this error, or
+  # -1 when the request never got one. PROMOTED to the top level: it used to
+  # be reachable only at `err.result.status`, so every consumer coupled
+  # itself to the internal shape of `result`.
+  attr_accessor :code, :msg, :sdk, :status
 
   def initialize(code = "", msg = "")
     super(msg)
     @code = code
     @msg = msg
     @sdk = "ProjectName"
+    @status = -1
+  end
+
+  def not_found?
+    404 == @status
   end
 
   def error

package/project/.sdk/src/cmp/rust/Entity_rust.ts

@@ -53,7 +53,11 @@ const Entity = cmp(function Entity(props: any) {
               ({ indent }: any) => {
                 const arg = ('create' === opname || 'update' === opname) ?
                   'reqdata' : 'reqmatch'
-                Content({ indent }, `fn ${opname}(&self, _${arg}: Value, _ctrl: Value) -> Result<Value, ${model.const.Name}Error> {
+                // The stub mirrors the real signature: ops resolve to the
+                // ENTITY (`list` to a vector of them), so an unsupported op
+                // has to declare the same return type to satisfy the trait.
+                const ret = 'list' === opname ? 'Vec<Rc<Self>>' : 'Rc<Self>'
+                Content({ indent }, `fn ${opname}(self: &Rc<Self>, _${arg}: Value, _ctrl: Value) -> Result<${ret}, ${model.const.Name}Error> {
     Err(crate::core::helpers::unsupported_op("${opname}", &self.name))
 }
 `)

package/project/.sdk/src/cmp/rust/Main_rust.ts

@@ -35,6 +35,7 @@ const Main = cmp(async function Main(props: any) {
   const { model } = props.ctx$
 
   const entity: ModelEntity = getModelPath(model, `main.${KIT}.entity`)
+  const feature = getModelPath(model, `main.${KIT}.feature`)
 
   // The rust crate identifier (RUSTCRATE placeholder), e.g. solar_sdk —
   // used in every `use <crate>::...` path in the test templates.
@@ -85,6 +86,26 @@ const Main = cmp(async function Main(props: any) {
     SdkError({ target })
   })
 
+  // feature/mod.rs — the feature module index.
+  //
+  // GENERATED, not templated: rust needs every module declared, and
+  // `target add` only copies source for the features the model selects. A
+  // static index listing all eighteen shipped features stops the crate from
+  // compiling the moment the set is trimmed.
+  Folder({ name: 'feature' }, () => {
+    File({ name: 'mod.' + target.ext }, () => {
+      Content(`// ${model.const.Name} SDK feature modules (mirrors tm/go/feature).
+// Each feature is a Feature trait object registered on the client;
+// \`support\` carries the shared option readers (go feature_options.go).
+
+pub mod support;
+
+pub mod base;
+`)
+      each(feature, (feat: any) => Content(`pub mod ${feat.name};\n`))
+    })
+  })
+
   // entity/mod.rs — the entity module index.
   EntityBase({ target })
 

package/project/.sdk/src/cmp/rust/Package_rust.ts

@@ -4,6 +4,7 @@ import {
   File,
   cmp,
   collectDeps,
+  packageVersion,
 } from '@voxgig/sdkgen'
 
 
@@ -30,7 +31,7 @@ const Package = cmp(async function Package(props: any) {
   File({ name: 'Cargo.toml' }, () => {
     Content(`[package]
 name = "${crateName(model)}"
-version = "0.0.1"
+version = "${packageVersion(model, target.name)}"
 edition = "2021"
 description = "${model.const.Name} SDK for Rust (generated by @voxgig/sdkgen)"
 license = "MIT"

package/project/.sdk/src/cmp/rust/TestDirect_rust.ts

@@ -11,7 +11,7 @@ import {
   File,
   cmp,
   snakify,
-  isAuthActive,
+  isAuthActive, envName, envToken
 } from '@voxgig/sdkgen'
 
 
@@ -63,7 +63,7 @@ const TestDirect = cmp(function TestDirect(props: any) {
   const entity: ModelEntity = props.entity
   const rustcrate: string = props.rustcrate
 
-  const PROJECTNAME = nom(model, 'Name').toUpperCase().replace(/[^A-Z_]/g, '_')
+  const PROJECTNAME = envName(model)
 
   const authActive = isAuthActive(model)
   const apikeyEnvEntry = authActive
@@ -112,7 +112,7 @@ const TestDirect = cmp(function TestDirect(props: any) {
   const listPath = listPoint ? normalizePathParams(listPoint.parts || [], listPoint?.args?.params || [], listPoint?.rename?.param) : ''
   const listParams = listPoint?.args?.params || []
 
-  const entidEnvVar = `${PROJECTNAME}_TEST_${nom(entity, 'NAME').replace(/[^A-Z_]/g, '_')}_ENTID`
+  const entidEnvVar = `${PROJECTNAME}_TEST_${envToken(entity.name)}_ENTID`
 
   const evar = rustVarName(entity.name)
 

package/project/.sdk/src/cmp/rust/TestEntity_rust.ts

@@ -17,7 +17,7 @@ import {
   each,
   buildIdNames,
   getMatchEntries,
-  isAuthActive,
+  isAuthActive, envName, envToken
 } from '@voxgig/sdkgen'
 
 
@@ -51,8 +51,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 authActive = isAuthActive(model)
   const apikeyEnvEntry = authActive
@@ -351,7 +351,7 @@ const generateCreate: OpGen = (ctx, step, index) => {
     let ${datavar}_result = ${entvar}
         .create(${datavar}.clone(), Value::Noval)
         .expect("create failed");
-    let ${datavar} = to_map(&${datavar}_result);
+    let ${datavar} = to_map(&${datavar}_result.data(None));
     assert!(
         matches!(${datavar}, Value::Map(_)),
         "expected create result to be a map"
@@ -403,10 +403,9 @@ const generateList: OpGen = (ctx, step, index) => {
     let ${listvar} = ${entvar}
         .list(${matchvar}.clone(), Value::Noval)
         .expect("list failed");
-    assert!(
-        matches!(${listvar}, Value::List(_)),
-        "expected list result to be an array"
-    );
+    // list resolves to one ENTITY per record; the flow asserts on the
+    // records, so map each through data().
+    let ${listvar} = ja(${listvar}.iter().map(|e| e.data(None)).collect::<Vec<Value>>());
 `)
 
   // Validators from step.valid.
@@ -507,7 +506,7 @@ const generateUpdate: OpGen = (ctx, step, index) => {
     let ${resdatavar}_result = ${entvar}
         .update(${datavar}_up.clone(), Value::Noval)
         .expect("update failed");
-    let ${resdatavar} = to_map(&${resdatavar}_result);
+    let ${resdatavar} = to_map(&${resdatavar}_result.data(None));
     assert!(
         matches!(${resdatavar}, Value::Map(_)),
         "expected update result to be a map"
@@ -586,7 +585,7 @@ const generateLoad: OpGen = (ctx, step, index) => {
     let ${datavar}_loaded = ${entvar}
         .load(${matchvar}.clone(), Value::Noval)
         .expect("load failed");
-    let ${datavar}_load_result = to_map(&${datavar}_loaded);
+    let ${datavar}_load_result = to_map(&${datavar}_loaded.data(None));
     assert!(
         matches!(${datavar}_load_result, Value::Map(_)),
         "expected load result to be a map"
@@ -603,9 +602,10 @@ const generateLoad: OpGen = (ctx, step, index) => {
     let ${datavar}_loaded = ${entvar}
         .load(${matchvar}.clone(), Value::Noval)
         .expect("load failed");
+    // load resolves to the ENTITY; the record is reached through data().
     assert!(
-        !${datavar}_loaded.is_noval(),
-        "expected load result to be non-nil"
+        !${datavar}_loaded.data(None).is_noval(),
+        "expected load result to carry data"
     );
 `)
   }

package/project/.sdk/src/cmp/rust/fragment/Entity.fragment.rs

@@ -24,6 +24,8 @@ pub struct EntyClass {
     data: RefCell<Value>,
     mtch: RefCell<Value>,
     entctx: RefCell<Option<Rc<Context>>>,
+    // Set once a successful `remove` resolves on this instance.
+    deleted: RefCell<bool>,
 }
 
 impl EntyClass {
@@ -46,6 +48,7 @@ impl EntyClass {
             data: RefCell::new(Value::empty_map()),
             mtch: RefCell::new(Value::empty_map()),
             entctx: RefCell::new(None),
+            deleted: RefCell::new(false),
         });
 
         let entctx = e.utility.make_context(
@@ -71,6 +74,10 @@ impl EntyClass {
             .expect("entity context not initialised")
     }
 
+    // Runs the pipeline and returns the terminal result VALUE. The entity
+    // contract lives one level up, in the op methods below: they call this,
+    // then hand back the entity (see AGENTS.md). It is split that way because
+    // `Value` is a closed data union that cannot carry an entity.
     fn run_op(
         &self,
         ctx: &Rc<Context>,
@@ -232,6 +239,17 @@ impl Entity for EntyClass {
         self.name.clone()
     }
 
+    // `remove` resolves to the entity, marked. The instance KEEPS the data
+    // it held — a caller can still read what was deleted — but it is no
+    // longer a live record.
+    fn mark_deleted(&self) {
+        *self.deleted.borrow_mut() = true;
+    }
+
+    fn deleted(&self) -> bool {
+        *self.deleted.borrow()
+    }
+
     fn make(&self) -> Rc<dyn Entity> {
         let opts = Value::empty_map();
         if let Value::Map(m) = &self.entopts {