@voxgig/sdkgen 2.0.2 → 3.1.0

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

@@ -14,6 +14,8 @@ typedef struct entyvar_entity {
   voxgig_value* data;     // Map
   voxgig_value* mtch;     // Map
   Context* entctx;
+  // Set once a successful `remove` resolves on this instance.
+  bool deleted;
 } entyvar_entity;
 
 typedef void (*entyvar_postdone_fn)(entyvar_entity* self, Context* ctx);
@@ -24,11 +26,14 @@ static const char* entyvar_get_name(Entity* e);
 static Entity* entyvar_make(Entity* e);
 static voxgig_value* entyvar_data(Entity* e, voxgig_value* args);
 static voxgig_value* entyvar_matchv(Entity* e, voxgig_value* args);
-static voxgig_value* entyvar_load(Entity* e, voxgig_value* reqmatch, voxgig_value* ctrl, PNError** err);
-static voxgig_value* entyvar_list(Entity* e, voxgig_value* reqmatch, voxgig_value* ctrl, PNError** err);
-static voxgig_value* entyvar_create(Entity* e, voxgig_value* reqdata, voxgig_value* ctrl, PNError** err);
-static voxgig_value* entyvar_update(Entity* e, voxgig_value* reqdata, voxgig_value* ctrl, PNError** err);
-static voxgig_value* entyvar_remove(Entity* e, voxgig_value* reqmatch, voxgig_value* ctrl, PNError** err);
+// Ops resolve to the ENTITY (`list` to a NULL-terminated array of them).
+static Entity* entyvar_load(Entity* e, voxgig_value* reqmatch, voxgig_value* ctrl, PNError** err);
+static Entity** entyvar_list(Entity* e, voxgig_value* reqmatch, voxgig_value* ctrl, PNError** err);
+static Entity* entyvar_create(Entity* e, voxgig_value* reqdata, voxgig_value* ctrl, PNError** err);
+static Entity* entyvar_update(Entity* e, voxgig_value* reqdata, voxgig_value* ctrl, PNError** err);
+static Entity* entyvar_remove(Entity* e, voxgig_value* reqmatch, voxgig_value* ctrl, PNError** err);
+static void entyvar_mark_deleted(Entity* e);
+static bool entyvar_deleted(Entity* e);
 
 static Context* entyvar_ent_ctx(entyvar_entity* self) {
   return self->entctx;
@@ -252,11 +257,24 @@ static voxgig_value* entyvar_matchv(Entity* e, voxgig_value* args) {
 
 // #RemoveOp
 
+// `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.
+static void entyvar_mark_deleted(Entity* e) {
+  ((entyvar_entity*)e)->deleted = true;
+}
+
+static bool entyvar_deleted(Entity* e) {
+  return ((entyvar_entity*)e)->deleted;
+}
+
 static const EntityVT entyvar_VT = {
   entyvar_get_name,
   entyvar_make,
   entyvar_data,
   entyvar_matchv,
+  entyvar_mark_deleted,
+  entyvar_deleted,
   entyvar_load,
   entyvar_list,
   entyvar_create,

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

@@ -11,7 +11,7 @@ static void entyvar_create_postdone(entyvar_entity* self, Context* ctx) {
   }
 }
 
-static voxgig_value* entyvar_create(Entity* e, voxgig_value* reqdata, voxgig_value* ctrl, PNError** err) {
+static Entity* entyvar_create(Entity* e, voxgig_value* reqdata, voxgig_value* ctrl, PNError** err) {
   entyvar_entity* self = (entyvar_entity*)e;
   CtxSpec cs;
   memset(&cs, 0, sizeof(cs));
@@ -21,7 +21,14 @@ static voxgig_value* entyvar_create(Entity* e, voxgig_value* reqdata, voxgig_val
   cs.data = self->data;
   cs.reqdata = reqdata;
   Context* ctx = make_context_util(cs, entyvar_ent_ctx(self));
-  return entyvar_run_op(self, ctx, entyvar_create_postdone, err);
+  entyvar_run_op(self, ctx, entyvar_create_postdone, err);
+  if (*err) return NULL;
+
+  // The operation resolves to THIS entity: run_op has just absorbed the
+  // result into it, and the caller reaches the record through vt->data.
+  // See AGENTS.md "Entity operations return ENTITIES".
+
+  return e;
 }
 
 // EJECT-END

package/project/.sdk/src/cmp/c/fragment/EntityListOp.fragment.c

@@ -8,7 +8,7 @@ static void entyvar_list_postdone(entyvar_entity* self, Context* ctx) {
   }
 }
 
-static voxgig_value* entyvar_list(Entity* e, voxgig_value* reqmatch, voxgig_value* ctrl, PNError** err) {
+static Entity** entyvar_list(Entity* e, voxgig_value* reqmatch, voxgig_value* ctrl, PNError** err) {
   entyvar_entity* self = (entyvar_entity*)e;
   CtxSpec cs;
   memset(&cs, 0, sizeof(cs));
@@ -18,7 +18,24 @@ static voxgig_value* entyvar_list(Entity* e, voxgig_value* reqmatch, voxgig_valu
   cs.data = self->data;
   cs.reqmatch = reqmatch;
   Context* ctx = make_context_util(cs, entyvar_ent_ctx(self));
-  return entyvar_run_op(self, ctx, entyvar_list_postdone, err);
+  voxgig_value* out = entyvar_run_op(self, ctx, entyvar_list_postdone, err);
+  if (*err) return NULL;
+
+  // `list` resolves to one ENTITY per record. make_result cannot build them
+  // here - it works in voxgig_value, which has no slot for an entity - so the
+  // op does, mirroring what the dynamic targets get from make_result. The
+  // array is NULL-terminated.
+  size_t n = voxgig_is_list(out) ? voxgig_as_list(out)->len : 0;
+  Entity** items = (Entity**)calloc(n + 1, sizeof(Entity*));
+  for (size_t i = 0; i < n; i++) {
+    voxgig_value* entry = voxgig_as_list(out)->items[i];
+    Entity* ent = e->vt->make(e);
+    if (voxgig_is_map(entry)) ent->vt->data(ent, entry);
+    items[i] = ent;
+  }
+  items[n] = NULL;
+
+  return items;
 }
 
 // EJECT-END

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

@@ -13,7 +13,7 @@ static void entyvar_load_postdone(entyvar_entity* self, Context* ctx) {
   }
 }
 
-static voxgig_value* entyvar_load(Entity* e, voxgig_value* reqmatch, voxgig_value* ctrl, PNError** err) {
+static Entity* entyvar_load(Entity* e, voxgig_value* reqmatch, voxgig_value* ctrl, PNError** err) {
   entyvar_entity* self = (entyvar_entity*)e;
   CtxSpec cs;
   memset(&cs, 0, sizeof(cs));
@@ -23,7 +23,14 @@ static voxgig_value* entyvar_load(Entity* e, voxgig_value* reqmatch, voxgig_valu
   cs.data = self->data;
   cs.reqmatch = reqmatch;
   Context* ctx = make_context_util(cs, entyvar_ent_ctx(self));
-  return entyvar_run_op(self, ctx, entyvar_load_postdone, err);
+  entyvar_run_op(self, ctx, entyvar_load_postdone, err);
+  if (*err) return NULL;
+
+  // The operation resolves to THIS entity: run_op has just absorbed the
+  // result into it, and the caller reaches the record through vt->data.
+  // See AGENTS.md "Entity operations return ENTITIES".
+
+  return e;
 }
 
 // EJECT-END

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

@@ -13,7 +13,7 @@ static void entyvar_remove_postdone(entyvar_entity* self, Context* ctx) {
   }
 }
 
-static voxgig_value* entyvar_remove(Entity* e, voxgig_value* reqmatch, voxgig_value* ctrl, PNError** err) {
+static Entity* entyvar_remove(Entity* e, voxgig_value* reqmatch, voxgig_value* ctrl, PNError** err) {
   entyvar_entity* self = (entyvar_entity*)e;
   CtxSpec cs;
   memset(&cs, 0, sizeof(cs));
@@ -23,7 +23,17 @@ static voxgig_value* entyvar_remove(Entity* e, voxgig_value* reqmatch, voxgig_va
   cs.data = self->data;
   cs.reqmatch = reqmatch;
   Context* ctx = make_context_util(cs, entyvar_ent_ctx(self));
-  return entyvar_run_op(self, ctx, entyvar_remove_postdone, err);
+  entyvar_run_op(self, ctx, entyvar_remove_postdone, err);
+  if (*err) return NULL;
+
+  // The operation resolves to THIS entity: run_op has just absorbed the
+  // result into it, and the caller reaches the record through vt->data.
+  // See AGENTS.md "Entity operations return ENTITIES".
+
+  // A removed entity keeps its data but is no longer a live record.
+  self->deleted = true;
+
+  return e;
 }
 
 // EJECT-END

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

@@ -13,7 +13,7 @@ static void entyvar_update_postdone(entyvar_entity* self, Context* ctx) {
   }
 }
 
-static voxgig_value* entyvar_update(Entity* e, voxgig_value* reqdata, voxgig_value* ctrl, PNError** err) {
+static Entity* entyvar_update(Entity* e, voxgig_value* reqdata, voxgig_value* ctrl, PNError** err) {
   entyvar_entity* self = (entyvar_entity*)e;
   CtxSpec cs;
   memset(&cs, 0, sizeof(cs));
@@ -23,7 +23,14 @@ static voxgig_value* entyvar_update(Entity* e, voxgig_value* reqdata, voxgig_val
   cs.data = self->data;
   cs.reqdata = reqdata;
   Context* ctx = make_context_util(cs, entyvar_ent_ctx(self));
-  return entyvar_run_op(self, ctx, entyvar_update_postdone, err);
+  entyvar_run_op(self, ctx, entyvar_update_postdone, err);
+  if (*err) return NULL;
+
+  // The operation resolves to THIS entity: run_op has just absorbed the
+  // result into it, and the caller reaches the record through vt->data.
+  // See AGENTS.md "Entity operations return ENTITIES".
+
+  return e;
 }
 
 // EJECT-END

package/project/.sdk/src/cmp/c/fragment/Main.fragment.c

@@ -2,6 +2,7 @@
 
 #include "api.h"
 
+#include <stdio.h>   // snprintf
 #include <stdlib.h>
 #include <string.h>
 

package/project/.sdk/src/cmp/clojure/TestEntity_clojure.ts

@@ -29,13 +29,16 @@ const TestEntity = cmp(function TestEntity(props: any) {
                  ent (api/${e.name} sdk nil)]
 `)
     if (hasCreate) {
-      Content(`             (let [res (e-${e.name}/create ent (vs/jm "name" "smoke") nil)]
-               (t/is-true (vs/ismap res) "create returns a record map")
-               (t/is-true (some? (vs/getprop res "id")) "created record has an id"))
+      Content(`             (let [res (e-${e.name}/create ent (vs/jm "name" "smoke") nil)
+                   rec (if (map? res) ((:data-get res)) res)]
+               ;; create resolves to the ENTITY; the record is data-get.
+               (t/is-true (vs/ismap rec) "create resolves to an entity carrying a record")
+               (t/is-true (some? (vs/getprop rec "id")) "created record has an id"))
 `)
     }
     if (hasList) {
       Content(`             (let [items (e-${e.name}/list ent (vs/jm) nil)]
+               ;; list resolves to one entity per record.
                (t/is-true (sequential? items) "list returns a sequential collection"))
 `)
     }

package/project/.sdk/src/cmp/clojure/fragment/Entity.fragment.clj

@@ -34,9 +34,11 @@
         utility (core/get-utility client)
         data (atom (vs/jm))
         match (atom (vs/jm))
+        ;; Set once a successful `remove` resolves on this instance.
+        deleted (atom false)
         entctx (core/make-context (vs/jm "entopts" entopts) (core/client-root-ctx client))
         ent {:_name "entityname" :_client client :_utility utility :_entopts entopts
-             :_data data :_match match :_entctx entctx
+             :_data data :_match match :_deleted deleted :_entctx entctx
              :get-name (fn [] "entityname")
              :make (fn [] (new-entity client (vs/clone entopts)))}
         ent (assoc ent
@@ -56,6 +58,21 @@
 ;; when throwing is disabled). The hook marker lines below are rewritten to
 ;; (core/feature-hook ctx "<Stage>") by the component's hook regex — a `;`
 ;; comment form, since jostraca's built-in tag replacement only matches `//`.
+;; Every operation resolves to the ENTITY, not the raw data — the record is
+;; reached through data-get. run-op returns the terminal result value, so the
+;; op hands that back only when the pipeline FAILED; on success it hands back
+;; the entity. See AGENTS.md "Entity operations return ENTITIES".
+(defn- op-return [ent ctx out]
+  (let [result (core/oget ctx :result)]
+    (if (and result (true? (core/oget result :ok))) ent out)))
+
+;; `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.
+(defn mark-deleted [ent] (reset! (:_deleted ent) true) ent)
+
+(defn deleted [ent] (true? (deref (:_deleted ent))))
+
 (defn- run-op [ctx post-done]
   (try
     ; #PrePoint-Hook

package/project/.sdk/src/cmp/clojure/fragment/EntityCreateOp.fragment.clj

@@ -5,10 +5,10 @@
              (vs/jm "opname" "create" "ctrl" ctrl
                     "match" (deref (:_match ent)) "data" (deref (:_data ent)) "reqdata" reqdata)
              (:_entctx ent))]
-    (run-op ctx
+    (op-return ent ctx (run-op ctx
             (fn []
               (when-let [result (core/oget ctx :result)]
                 (when (core/oget result :resdata)
                   (reset! (:_data ent)
-                          (let [m (core/to-map (vs/clone (core/oget result :resdata)))] (if m m (vs/jm))))))))))
+                          (let [m (core/to-map (vs/clone (core/oget result :resdata)))] (if m m (vs/jm)))))))))))
 ; EJECT-END

package/project/.sdk/src/cmp/clojure/fragment/EntityLoadOp.fragment.clj

@@ -5,11 +5,11 @@
              (vs/jm "opname" "load" "ctrl" ctrl
                     "match" (deref (:_match ent)) "data" (deref (:_data ent)) "reqmatch" reqmatch)
              (:_entctx ent))]
-    (run-op ctx
+    (op-return ent ctx (run-op ctx
             (fn []
               (when-let [result (core/oget ctx :result)]
                 (when (core/oget result :resmatch) (reset! (:_match ent) (core/oget result :resmatch)))
                 (when (core/oget result :resdata)
                   (reset! (:_data ent)
-                          (let [m (core/to-map (vs/clone (core/oget result :resdata)))] (if m m (vs/jm))))))))))
+                          (let [m (core/to-map (vs/clone (core/oget result :resdata)))] (if m m (vs/jm)))))))))))
 ; EJECT-END

package/project/.sdk/src/cmp/clojure/fragment/EntityRemoveOp.fragment.clj

@@ -1,15 +1,19 @@
 ; EJECT-START
 ;; Remove an EntityName matching the criteria (reqmatch: id/query fields).
+;; Resolves to THIS entity, marked as deleted (see AGENTS.md). The instance
+;; keeps the data it held, so a caller can still read what was removed.
 (defn remove [ent reqmatch ctrl]
   (let [ctx (core/make-context
              (vs/jm "opname" "remove" "ctrl" ctrl
                     "match" (deref (:_match ent)) "data" (deref (:_data ent)) "reqmatch" reqmatch)
-             (:_entctx ent))]
-    (run-op ctx
-            (fn []
-              (when-let [result (core/oget ctx :result)]
-                (when (core/oget result :resmatch) (reset! (:_match ent) (core/oget result :resmatch)))
-                (when (core/oget result :resdata)
-                  (reset! (:_data ent)
-                          (let [m (core/to-map (vs/clone (core/oget result :resdata)))] (if m m (vs/jm))))))))))
+             (:_entctx ent))
+        out (op-return ent ctx
+                       (run-op ctx
+                               (fn []
+                                 (when-let [result (core/oget ctx :result)]
+                                   (when (core/oget result :resmatch) (reset! (:_match ent) (core/oget result :resmatch)))
+                                   (when (core/oget result :resdata)
+                                     (reset! (:_data ent)
+                                             (let [m (core/to-map (vs/clone (core/oget result :resdata)))] (if m m (vs/jm)))))))))]
+    (if (= out ent) (mark-deleted ent) out)))
 ; EJECT-END

package/project/.sdk/src/cmp/clojure/fragment/EntityUpdateOp.fragment.clj

@@ -5,11 +5,11 @@
              (vs/jm "opname" "update" "ctrl" ctrl
                     "match" (deref (:_match ent)) "data" (deref (:_data ent)) "reqdata" reqdata)
              (:_entctx ent))]
-    (run-op ctx
+    (op-return ent ctx (run-op ctx
             (fn []
               (when-let [result (core/oget ctx :result)]
                 (when (core/oget result :resmatch) (reset! (:_match ent) (core/oget result :resmatch)))
                 (when (core/oget result :resdata)
                   (reset! (:_data ent)
-                          (let [m (core/to-map (vs/clone (core/oget result :resdata)))] (if m m (vs/jm))))))))))
+                          (let [m (core/to-map (vs/clone (core/oget result :resdata)))] (if m m (vs/jm)))))))))))
 ; EJECT-END

package/project/.sdk/src/cmp/cpp/Entity_cpp.ts

@@ -45,7 +45,11 @@ const Entity = cmp(function Entity(props: any) {
               ({ indent }: any) => {
                 const arg = ('create' === opname || 'update' === opname) ?
                   'reqdata' : 'reqmatch'
-                Content({ indent }, `Value ${opname}(const Value& ${arg}, const Value& ctrl) override {
+                // 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 SdkEntity.
+                const ret = 'list' === opname ? 'std::vector<SdkEntityPtr>' : 'SdkEntityPtr'
+                Content({ indent }, `${ret} ${opname}(const Value& ${arg}, const Value& ctrl) override {
     (void)${arg}; (void)ctrl;
     throw Helpers::unsupportedOp("${opname}", this->name_);
   }

package/project/.sdk/src/cmp/cpp/TestEntity_cpp.ts

@@ -16,7 +16,7 @@ import {
   cmp,
   each,
   buildIdNames,
-  getMatchEntries,
+  getMatchEntries, envName, envToken
 } from '@voxgig/sdkgen'
 
 
@@ -43,7 +43,7 @@ const TestEntity = cmp(function TestEntity(props: any) {
   const entity: ModelEntity = props.entity
 
   const ProjectName = model.const.Name
-  const PROJUPPER = nom(model.const, 'Name').toUpperCase().replace(/[^A-Z_]/g, '_')
+  const PROJUPPER = envName(model)
 
   const basicflow: ModelEntityFlow | undefined =
     getModelPath(model, `main.${KIT}.flow.Basic${nom(entity, 'Name')}Flow`)
@@ -111,12 +111,12 @@ static ${entity.Name}Setup ${evar}_basic_setup(const Value& extra) {
   if (!idmap.is_map()) idmap = vmap();
 
   Value env = env_override(vmap({
-    {"${PROJUPPER}_TEST_${nom(entity, 'NAME').replace(/[^A-Z_]/g, '_')}_ENTID", idmap},
+    {"${PROJUPPER}_TEST_${envToken(entity.name)}_ENTID", idmap},
     {"${PROJUPPER}_TEST_LIVE", Value("FALSE")},
     {"${PROJUPPER}_TEST_EXPLAIN", Value("FALSE")}
   }));
 
-  Value idmap_resolved = Helpers::toMapAny(getp(env, "${PROJUPPER}_TEST_${nom(entity, 'NAME').replace(/[^A-Z_]/g, '_')}_ENTID"));
+  Value idmap_resolved = Helpers::toMapAny(getp(env, "${PROJUPPER}_TEST_${envToken(entity.name)}_ENTID"));
   if (!idmap_resolved.is_map()) idmap_resolved = idmap;
 `)
 
@@ -264,7 +264,7 @@ const generateCreate: OpGen = (ctx, step: any, index) => {
   }
 
   Content(`  {
-    Value ${datavar}_result = ${entvar}->create(Struct::clone(${datavar}), Value::undef());
+    Value ${datavar}_result = ${entvar}->create(Struct::clone(${datavar}), Value::undef())->data();
     ${datavar} = Helpers::toMapAny(${datavar}_result);
     if (!${datavar}.is_map()) ${datavar} = vmap();
     ASSERT_TRUE(${datavar}.is_map(), "expected create result to be a map");
@@ -302,7 +302,10 @@ const generateList: OpGen = (ctx, step: any, index) => {
     Content(`  setp(${matchvar}, "${key}", getp(setup.idmap, "${val}"));
 `)
   }
-  Content(`  Value ${listvar} = ${entvar}->list(Struct::clone(${matchvar}), Value::undef());
+  Content(`  auto ${listvar}_ents = ${entvar}->list(Struct::clone(${matchvar}), Value::undef());
+  // list resolves to one ENTITY per record; the flow asserts on the records.
+  Value ${listvar} = vlist();
+  for (const auto& e : ${listvar}_ents) { ${listvar}.as_list()->push_back(e->data()); }
   ASSERT_TRUE(${listvar}.is_list(), "expected list result to be an array");
 `)
 
@@ -378,7 +381,7 @@ const generateUpdate: OpGen = (ctx, step: any, index) => {
       }
     }
   }
-  Content(`  Value ${resdatavar}_result = ${entvar}->update(Struct::clone(${datavar}_up), Value::undef());
+  Content(`  Value ${resdatavar}_result = ${entvar}->update(Struct::clone(${datavar}_up), Value::undef())->data();
   Value ${resdatavar} = Helpers::toMapAny(${resdatavar}_result);
   if (!${resdatavar}.is_map()) ${resdatavar} = vmap();
   ASSERT_TRUE(${resdatavar}.is_map(), "expected update result to be a map");
@@ -415,14 +418,14 @@ const generateLoad: OpGen = (ctx, step: any, index) => {
   }
   if (hasEntId) {
     Content(`  Value ${matchvar} = vmap({{"id", getp(${srcdatavar}, "id")}});
-  Value ${datavar}_loaded = ${entvar}->load(Struct::clone(${matchvar}), Value::undef());
+  Value ${datavar}_loaded = ${entvar}->load(Struct::clone(${matchvar}), Value::undef())->data();
   Value ${datavar}_load_result = Helpers::toMapAny(${datavar}_loaded);
   ASSERT_TRUE(${datavar}_load_result.is_map(), "expected load result to be a map");
   ASSERT_EQ_VAL(getp(${datavar}_load_result, "id"), getp(${srcdatavar}, "id"), "expected load result id to match");
 `)
   } else {
     Content(`  Value ${matchvar} = vmap();
-  Value ${datavar}_loaded = ${entvar}->load(${matchvar}, Value::undef());
+  Value ${datavar}_loaded = ${entvar}->load(${matchvar}, Value::undef())->data();
   ASSERT_TRUE(!${datavar}_loaded.is_undef(), "expected load result to be non-nil");
 `)
   }

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

@@ -1,6 +1,6 @@
 // EJECT-START
 
-  Value create(const Value& reqdata, const Value& ctrl) override {
+  SdkEntityPtr create(const Value& reqdata, const Value& ctrl) override {
     CtxSpec cs;
     cs.setOpname("create");
     cs.ctrlMap = ctrl.is_map() ? ctrl : vmap();
@@ -9,7 +9,7 @@
     cs.reqdata = reqdata.is_map() ? reqdata : vmap();
     CtxPtr ctx = this->utility->makeContext(cs, this->entctx);
 
-    return runOp(ctx, [this, ctx]() {
+    runOp(ctx, [this, ctx]() {
       if (ctx->result) {
         if (!is_nullish(ctx->result->resdata)) {
           Value d = Helpers::toMapAny(Struct::clone(ctx->result->resdata));
@@ -17,6 +17,12 @@
         }
       }
     });
+
+    // The operation resolves to THIS entity: runOp has just absorbed the
+    // result into it, and the caller reaches the record through data().
+    // See AGENTS.md "Entity operations return ENTITIES".
+
+    return this->self();
   }
 
 // EJECT-END

package/project/.sdk/src/cmp/cpp/fragment/EntityListOp.fragment.cpp

@@ -1,6 +1,6 @@
 // EJECT-START
 
-  Value list(const Value& reqmatch, const Value& ctrl) override {
+  std::vector<SdkEntityPtr> list(const Value& reqmatch, const Value& ctrl) override {
     CtxSpec cs;
     cs.setOpname("list");
     cs.ctrlMap = ctrl.is_map() ? ctrl : vmap();
@@ -9,13 +9,29 @@
     cs.reqmatch = reqmatch.is_map() ? reqmatch : vmap();
     CtxPtr ctx = this->utility->makeContext(cs, this->entctx);
 
-    return runOp(ctx, [this, ctx]() {
+    Value out = runOp(ctx, [this, ctx]() {
       if (ctx->result) {
         if (ctx->result->resmatch.is_map()) {
           this->match_ = ctx->result->resmatch;
         }
       }
     });
+
+    // `list` resolves to one ENTITY per record. makeResult cannot build them
+    // here - it works in Value, which has no slot for an entity - so the op
+    // does, mirroring what the dynamic targets get from makeResult.
+    std::vector<SdkEntityPtr> items;
+    if (out.is_list()) {
+      for (const auto& entry : *out.as_list()) {
+        SdkEntityPtr ent = std::static_pointer_cast<SdkEntity>(this->make());
+        if (entry.is_map()) {
+          ent->data(entry);
+        }
+        items.push_back(ent);
+      }
+    }
+
+    return items;
   }
 
 // EJECT-END

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

@@ -1,6 +1,6 @@
 // EJECT-START
 
-  Value load(const Value& reqmatch, const Value& ctrl) override {
+  SdkEntityPtr load(const Value& reqmatch, const Value& ctrl) override {
     CtxSpec cs;
     cs.setOpname("load");
     cs.ctrlMap = ctrl.is_map() ? ctrl : vmap();
@@ -9,7 +9,7 @@
     cs.reqmatch = reqmatch.is_map() ? reqmatch : vmap();
     CtxPtr ctx = this->utility->makeContext(cs, this->entctx);
 
-    return runOp(ctx, [this, ctx]() {
+    runOp(ctx, [this, ctx]() {
       if (ctx->result) {
         if (ctx->result->resmatch.is_map()) {
           this->match_ = ctx->result->resmatch;
@@ -20,6 +20,12 @@
         }
       }
     });
+
+    // The operation resolves to THIS entity: runOp has just absorbed the
+    // result into it, and the caller reaches the record through data().
+    // See AGENTS.md "Entity operations return ENTITIES".
+
+    return this->self();
   }
 
 // EJECT-END

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

@@ -1,6 +1,6 @@
 // EJECT-START
 
-  Value remove(const Value& reqmatch, const Value& ctrl) override {
+  SdkEntityPtr remove(const Value& reqmatch, const Value& ctrl) override {
     CtxSpec cs;
     cs.setOpname("remove");
     cs.ctrlMap = ctrl.is_map() ? ctrl : vmap();
@@ -9,13 +9,22 @@
     cs.reqmatch = reqmatch.is_map() ? reqmatch : vmap();
     CtxPtr ctx = this->utility->makeContext(cs, this->entctx);
 
-    return runOp(ctx, [this, ctx]() {
+    runOp(ctx, [this, ctx]() {
       if (ctx->result) {
         if (ctx->result->resmatch.is_map()) {
           this->match_ = ctx->result->resmatch;
         }
       }
     });
+
+    // The operation resolves to THIS entity: runOp has just absorbed the
+    // result into it, and the caller reaches the record through data().
+    // See AGENTS.md "Entity operations return ENTITIES".
+
+    // A removed entity keeps its data but is no longer a live record.
+    this->markDeleted();
+
+    return this->self();
   }
 
 // EJECT-END

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

@@ -1,6 +1,6 @@
 // EJECT-START
 
-  Value update(const Value& reqdata, const Value& ctrl) override {
+  SdkEntityPtr update(const Value& reqdata, const Value& ctrl) override {
     CtxSpec cs;
     cs.setOpname("update");
     cs.ctrlMap = ctrl.is_map() ? ctrl : vmap();
@@ -9,7 +9,7 @@
     cs.reqdata = reqdata.is_map() ? reqdata : vmap();
     CtxPtr ctx = this->utility->makeContext(cs, this->entctx);
 
-    return runOp(ctx, [this, ctx]() {
+    runOp(ctx, [this, ctx]() {
       if (ctx->result) {
         if (!is_nullish(ctx->result->resdata)) {
           Value d = Helpers::toMapAny(Struct::clone(ctx->result->resdata));
@@ -17,6 +17,12 @@
         }
       }
     });
+
+    // The operation resolves to THIS entity: runOp has just absorbed the
+    // result into it, and the caller reaches the record through data().
+    // See AGENTS.md "Entity operations return ENTITIES".
+
+    return this->self();
   }
 
 // EJECT-END

package/project/.sdk/src/cmp/csharp/Package_csharp.ts

@@ -7,6 +7,7 @@ import {
   collectDeps,
   pkgDescription,
   repoInfo,
+  packageVersion,
 } from '@voxgig/sdkgen'
 
 
@@ -56,7 +57,7 @@ const Package = cmp(async function Package(props: any) {
     <NoWarn>$(NoWarn);CS8600;CS8601;CS8602;CS8603;CS8604;CS8618;CS8625;CS1591</NoWarn>
 
     <!-- NuGet package metadata (publication pending; see Makefile). -->
-    <Version>0.0.1</Version>
+    <Version>${packageVersion(model, target.name)}</Version>
     <PackageId>${Name}.Sdk</PackageId>
     <Authors>Voxgig</Authors>
     <Description>${pkgDescription(model, 'csharp')}</Description>

package/project/.sdk/src/cmp/csharp/TestDirect_csharp.ts

@@ -11,7 +11,7 @@ import {
   File,
   cmp,
   snakify,
-  isAuthActive,
+  isAuthActive, envName, envToken
 } from '@voxgig/sdkgen'
 
 import { formatCsValue } from './utility_csharp'
@@ -62,8 +62,8 @@ const TestDirect = cmp(function TestDirect(props: any) {
   const entity: ModelEntity = props.entity
 
   const Name = model.const.Name
-  const PROJECTNAME = nom(model, 'Name').toUpperCase().replace(/[^A-Z_]/g, '_')
-  const ENTUPPER = nom(entity, 'NAME').replace(/[^A-Z_]/g, '_')
+  const PROJECTNAME = envName(model)
+  const ENTUPPER = envToken(entity.name)
 
   const authActive = isAuthActive(model)
   const apikeyEnvEntry = authActive