@voxgig/sdkgen 2.0.2 → 3.0.0

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

@@ -10,7 +10,7 @@ class EntityOperation {
 
   // EJECT-START
 
-  async create(this: any, reqdata?: EntityNameCreateData, ctrl?: Control): Promise<EntityName> {
+  async create(this: any, reqdata?: EntityNameCreateData, ctrl?: Control): Promise<EntyClass> {
 
     const utility = this._utility
     const {
@@ -84,7 +84,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: any) {
       // #PreUnexpected-Hook

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

@@ -10,7 +10,7 @@ class EntityOperation {
 
   // EJECT-START
 
-  async list(this: any, reqmatch?: EntityNameListMatch, ctrl?: Control): Promise<EntityName[]> {
+  async list(this: any, reqmatch?: EntityNameListMatch, ctrl?: Control): Promise<EntyClass[]> {
 
     const utility = this._utility
 

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

@@ -10,7 +10,7 @@ class EntityOperation {
 
   // EJECT-START
 
-  async load(this: any, reqmatch?: EntityNameLoadMatch, ctrl?: Control): Promise<EntityName> {
+  async load(this: any, reqmatch?: EntityNameLoadMatch, ctrl?: Control): Promise<EntyClass> {
 
     const utility = this._utility
 
@@ -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: any) {
       // #PreUnexpected-Hook

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

@@ -10,7 +10,17 @@ class EntityOperation {
 
   // EJECT-START
 
-  async remove(this: any, reqmatch?: EntityNameRemoveMatch, ctrl?: Control): Promise<EntityName> {
+  // Resolves to THIS entity, marked as deleted — like every other operation,
+  // which resolve to the entity too (see AGENTS.md). The instance keeps the
+  // data it held, so a caller can still read what was removed; `deleted()`
+  // reports that it is no longer a live record.
+  //
+  // A DELETE that answers 204 No Content therefore still resolves to
+  // something useful, where returning the raw body resolved to `undefined`
+  // against a signature that promised a record.
+  async remove(
+    this: any, reqmatch?: EntityNameRemoveMatch, ctrl?: Control,
+  ): Promise<EntyClass> {
 
     const utility = this._utility
 
@@ -90,7 +100,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: any) {
       // #PreUnexpected-Hook
@@ -102,7 +126,7 @@ class EntityOperation {
       }
       else {
         // Off-happy-path (throw disabled): typed as any so the method's
-        // Promise<EntityName> return stays clean under strict null checks.
+        // Promise<EntyClass> return stays clean under strict null checks.
         return undefined as any
       }
     }

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

@@ -10,7 +10,7 @@ class EntityOperation {
 
   // EJECT-START
 
-  async update(this: any, reqdata?: EntityNameUpdateData, ctrl?: Control): Promise<EntityName> {
+  async update(this: any, reqdata?: EntityNameUpdateData, ctrl?: Control): Promise<EntyClass> {
 
     const utility = this._utility
 
@@ -90,7 +90,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: any) {
       // #PreUnexpected-Hook

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

@@ -11,6 +11,21 @@ class ProjectNameError extends Error {
   code: string
   ctx: Context
 
+  // 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` — two levels into an object that reads as internal —
+  // so every consumer of every generated SDK wrote the same
+  // `404 === e?.result?.status` branch and coupled itself to the internal
+  // shape of `result`. Mapping "not found" to a null result is table stakes
+  // for a client integration.
+  status: number = -1
+
+
+  // `err.notFound` rather than a magic number at every call site.
+  get notFound(): boolean { return 404 === this.status }
+
   constructor(code: string, msg: string, ctx: Context) {
     super(msg)
     this.code = code

package/project/.sdk/src/cmp/zig/Entity_zig.ts

@@ -48,7 +48,11 @@ const Entity = cmp(function Entity(props: any) {
               ({ indent }: any) => {
                 const arg = ('create' === opname || 'update' === opname) ?
                   'reqdata' : 'reqmatch'
-                Content({ indent }, `pub fn ${opname}(self: *${cls}, _${arg}: Value, _ctrl: Value) OpResult {
+                // The stub mirrors the real signature: ops resolve to the
+                // ENTITY (`list` to a slice of them), so an unsupported op
+                // declares the same per-entity result union.
+                const ret = 'list' === opname ? 'EntListResult' : 'EntResult'
+                Content({ indent }, `pub fn ${opname}(self: *${cls}, _${arg}: Value, _ctrl: Value) ${ret} {
     _ = _${arg};
     _ = _ctrl;
     return .{ .err = h.unsupported_op("${opname}", self.name) };

package/project/.sdk/src/cmp/zig/Package_zig.ts

@@ -3,6 +3,7 @@ import {
   Content,
   File,
   cmp,
+  packageVersion,
 } from '@voxgig/sdkgen'
 
 
@@ -35,6 +36,7 @@ import { zigModuleName } from './utility_zig'
 // pin there.
 const Package = cmp(async function Package(props: any) {
   const ctx$ = props.ctx$
+  const target = props.target
   const model: Model = ctx$.model
 
   const name = zigModuleName(model)
@@ -42,7 +44,7 @@ const Package = cmp(async function Package(props: any) {
   File({ name: 'build.zig.zon' }, () => {
     Content(`.{
     .name = "${name}",
-    .version = "0.0.1",
+    .version = "${packageVersion(model, target.name)}",
     .dependencies = .{},
     .paths = .{
         "src",

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

@@ -17,6 +17,23 @@ const OpResult = types.OpResult;
 const OutVal = types.OutVal;
 const Entity = types.Entity;
 
+// Every operation resolves to the ENTITY, not the raw data — `list` to a
+// slice of them, one per record; the record is reached through `data()`.
+// See AGENTS.md "Entity operations return ENTITIES".
+//
+// `Value` cannot carry an entity (it is a closed data union) and the shared
+// `OpResult` cannot name a per-entity type, so each entity declares its own
+// result unions and the CONTRACT lives in those signatures.
+pub const EntResult = union(enum) {
+    ok: *EntyClass,
+    err: *errmod.ProjectNameError,
+};
+
+pub const EntListResult = union(enum) {
+    ok: []*EntyClass,
+    err: *errmod.ProjectNameError,
+};
+
 pub const EntyClass = struct {
     name: []const u8 = "entityname",
     client: *sdk.ProjectNameSDK,
@@ -25,6 +42,8 @@ pub const EntyClass = struct {
     data: Value,
     mtch: Value,
     entctx: ?*Context = null,
+    // Set once a successful `remove` resolves on this instance.
+    deleted: bool = false,
 
     pub fn new(client: *sdk.ProjectNameSDK, entopts_in: Value) *EntyClass {
         const entopts: Value = switch (entopts_in) {
@@ -73,6 +92,26 @@ pub const EntyClass = struct {
         return .{ .ok = v };
     }
 
+    // Runs the pipeline and hands back THIS entity: run_op has just absorbed
+    // the result into it. See AGENTS.md "Entity operations return ENTITIES".
+    fn run_op_ent(self: *EntyClass, ctx: *Context, post_done: *const fn (*EntyClass, *Context) void) EntResult {
+        return switch (self.run_op(ctx, post_done)) {
+            .err => |e| EntResult{ .err = e },
+            .ok => EntResult{ .ok = self },
+        };
+    }
+
+    // `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.
+    pub fn mark_deleted(self: *EntyClass) void {
+        self.deleted = true;
+    }
+
+    pub fn is_deleted(self: *EntyClass) bool {
+        return self.deleted;
+    }
+
     fn run_op(self: *EntyClass, ctx: *Context, post_done: *const fn (*EntyClass, *Context) void) OpResult {
         const utility = self.utility;
 

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

@@ -1,6 +1,6 @@
 // EJECT-START
 
-pub fn create(self: *EntyClass, reqdata: Value, ctrl: Value) OpResult {
+pub fn create(self: *EntyClass, reqdata: Value, ctrl: Value) EntResult {
     const ctx = self.utility.make_context(CtxSpec{
         .opname = "create",
         .ctrl = ctrl,
@@ -8,7 +8,7 @@ pub fn create(self: *EntyClass, reqdata: Value, ctrl: Value) OpResult {
         .data = self.data,
         .reqdata = reqdata,
     }, self.ent_ctx());
-    return self.run_op(ctx, create_post_done);
+    return self.run_op_ent(ctx, create_post_done);
 }
 
 fn create_post_done(self: *EntyClass, ctx: *Context) void {

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

@@ -1,6 +1,6 @@
 // EJECT-START
 
-pub fn list(self: *EntyClass, reqmatch: Value, ctrl: Value) OpResult {
+pub fn list(self: *EntyClass, reqmatch: Value, ctrl: Value) EntListResult {
     const ctx = self.utility.make_context(CtxSpec{
         .opname = "list",
         .ctrl = ctrl,
@@ -8,7 +8,26 @@ pub fn list(self: *EntyClass, reqmatch: Value, ctrl: Value) OpResult {
         .data = self.data,
         .reqmatch = reqmatch,
     }, self.ent_ctx());
-    return self.run_op(ctx, list_post_done);
+    const out = switch (self.run_op(ctx, list_post_done)) {
+        .err => |e| return EntListResult{ .err = e },
+        .ok => |v| v,
+    };
+
+    // `list` resolves to one ENTITY per record. make_result 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 make_result.
+    var items = std.ArrayList(*EntyClass).init(h.A());
+    if (out == .array) {
+        for (out.array.data.items) |entry| {
+            const ent = EntyClass.new(self.client, h.clone(self.entopts));
+            if (entry == .object) {
+                _ = ent.data_impl(entry);
+            }
+            items.append(ent) catch {};
+        }
+    }
+
+    return EntListResult{ .ok = items.toOwnedSlice() catch &[_]*EntyClass{} };
 }
 
 fn list_post_done(self: *EntyClass, ctx: *Context) void {

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

@@ -1,6 +1,6 @@
 // EJECT-START
 
-pub fn load(self: *EntyClass, reqmatch: Value, ctrl: Value) OpResult {
+pub fn load(self: *EntyClass, reqmatch: Value, ctrl: Value) EntResult {
     const ctx = self.utility.make_context(CtxSpec{
         .opname = "load",
         .ctrl = ctrl,
@@ -8,7 +8,7 @@ pub fn load(self: *EntyClass, reqmatch: Value, ctrl: Value) OpResult {
         .data = self.data,
         .reqmatch = reqmatch,
     }, self.ent_ctx());
-    return self.run_op(ctx, load_post_done);
+    return self.run_op_ent(ctx, load_post_done);
 }
 
 fn load_post_done(self: *EntyClass, ctx: *Context) void {

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

@@ -1,6 +1,6 @@
 // EJECT-START
 
-pub fn remove(self: *EntyClass, reqmatch: Value, ctrl: Value) OpResult {
+pub fn remove(self: *EntyClass, reqmatch: Value, ctrl: Value) EntResult {
     const ctx = self.utility.make_context(CtxSpec{
         .opname = "remove",
         .ctrl = ctrl,
@@ -8,7 +8,10 @@ pub fn remove(self: *EntyClass, reqmatch: Value, ctrl: Value) OpResult {
         .data = self.data,
         .reqmatch = reqmatch,
     }, self.ent_ctx());
-    return self.run_op(ctx, remove_post_done);
+    const res = self.run_op_ent(ctx, remove_post_done);
+    // A removed entity keeps its data but is no longer a live record.
+    if (res == .ok) self.mark_deleted();
+    return res;
 }
 
 fn remove_post_done(self: *EntyClass, ctx: *Context) void {

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

@@ -1,6 +1,6 @@
 // EJECT-START
 
-pub fn update(self: *EntyClass, reqdata: Value, ctrl: Value) OpResult {
+pub fn update(self: *EntyClass, reqdata: Value, ctrl: Value) EntResult {
     const ctx = self.utility.make_context(CtxSpec{
         .opname = "update",
         .ctrl = ctrl,
@@ -8,7 +8,7 @@ pub fn update(self: *EntyClass, reqdata: Value, ctrl: Value) OpResult {
         .data = self.data,
         .reqdata = reqdata,
     }, self.ent_ctx());
-    return self.run_op(ctx, update_post_done);
+    return self.run_op_ent(ctx, update_post_done);
 }
 
 fn update_post_done(self: *EntyClass, ctx: *Context) void {

package/project/.sdk/tm/c/VERSION

@@ -1 +1 @@
-0.0.1
+PROJECTVERSION

package/project/.sdk/tm/c/core/helpers.c

@@ -5,6 +5,7 @@
 #include "sdk.h"
 
 #include <stdarg.h>
+#include <stdio.h>   // snprintf
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>

package/project/.sdk/tm/c/core/sdk.h

@@ -303,17 +303,33 @@ voxgig_value* utility_fetch(Utility* u, Context* ctx, const char* url,
 // Entity (vtable; mirrors core/types.rs Entity + ProjectNameEntity)
 // ===========================================================================
 
+// Every operation resolves to the ENTITY, not the raw data. `list` resolves
+// to a NULL-terminated array of them, one per record; the record is reached
+// through `data`. See AGENTS.md "Entity operations return ENTITIES".
+//
+// `voxgig_value` cannot carry an entity - it is a closed data union
+// (UNDEF|NULL|BOOL|INT|DOUBLE|STRING|LIST|MAP|FUNC|SENTINEL), and adding a
+// variant to a general-purpose struct library to hold SDK objects would be
+// wrong - so the CONTRACT lives in these signatures instead.
 typedef struct EntityVT {
   const char* (*get_name)(Entity*);
   Entity* (*make)(Entity*);
   voxgig_value* (*data)(Entity*, voxgig_value* args);   // args NULL => none
   voxgig_value* (*matchv)(Entity*, voxgig_value* args); // args NULL => none
-  // CRUD ops (ProjectNameEntity). On error set *err.
-  voxgig_value* (*load)(Entity*, voxgig_value* reqmatch, voxgig_value* ctrl, PNError** err);
-  voxgig_value* (*list)(Entity*, voxgig_value* reqmatch, voxgig_value* ctrl, PNError** err);
-  voxgig_value* (*create)(Entity*, voxgig_value* reqdata, voxgig_value* ctrl, PNError** err);
-  voxgig_value* (*update)(Entity*, voxgig_value* reqdata, voxgig_value* ctrl, PNError** err);
-  voxgig_value* (*remove)(Entity*, voxgig_value* reqmatch, voxgig_value* ctrl, PNError** err);
+
+  // `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.
+  void (*mark_deleted)(Entity*);
+  bool (*deleted)(Entity*);
+
+  // CRUD ops (ProjectNameEntity). On error set *err and return NULL.
+  Entity* (*load)(Entity*, voxgig_value* reqmatch, voxgig_value* ctrl, PNError** err);
+  // Returns a NULL-terminated Entity* array (never NULL on success).
+  Entity** (*list)(Entity*, voxgig_value* reqmatch, voxgig_value* ctrl, PNError** err);
+  Entity* (*create)(Entity*, voxgig_value* reqdata, voxgig_value* ctrl, PNError** err);
+  Entity* (*update)(Entity*, voxgig_value* reqdata, voxgig_value* ctrl, PNError** err);
+  Entity* (*remove)(Entity*, voxgig_value* reqmatch, voxgig_value* ctrl, PNError** err);
 } EntityVT;
 
 struct Entity {

package/project/.sdk/tm/c/tests/feature_harness.h

@@ -15,6 +15,7 @@
 #include "ctest.h" // -> api.h -> sdk.h, plus voxgig_struct.h
 
 #include <ctype.h>
+#include <stdio.h>   // snprintf
 #include <stdlib.h>
 #include <string.h>
 

package/project/.sdk/tm/c/tests/primary_utility_test.c

@@ -241,7 +241,10 @@ static void test_primary_make_fetch_def_basic(void) {
 static void test_primary_make_fetch_def_with_body(void) {
   base_client();
   Context* ctx = full_ctx();
-  ctx->spec = spec_new(cmap(9, "base", v_str("http://localhost:8080"), "prefix", v_str(""),
+  // 8 pairs, not 9 - cmap is variadic and reads exactly npairs, so an
+  // overcount walks off the argument list and the trailing entry (method) is
+  // whatever the read finds.
+  ctx->spec = spec_new(cmap(8, "base", v_str("http://localhost:8080"), "prefix", v_str(""),
                             "path", v_str("items"), "suffix", v_str(""), "params", v_map(),
                             "query", v_map(), "headers", v_map(), "method", v_str("POST")));
   ctx->spec->body = cmap(1, "name", v_str("test"));

package/project/.sdk/tm/c/utility/make_url.c

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

package/project/.sdk/tm/c/utility/param.c

@@ -2,6 +2,7 @@
 
 #include "sdk.h"
 
+#include <stdio.h>   // snprintf
 #include <string.h>
 
 voxgig_value* param_util(Context* ctx, voxgig_value* paramdef) {

package/project/.sdk/tm/clojure/VERSION

@@ -1 +1 @@
-0.0.1
+PROJECTVERSION

package/project/.sdk/tm/cpp/VERSION

@@ -1 +1 @@
-0.0.1
+PROJECTVERSION

package/project/.sdk/tm/cpp/core/types.hpp

@@ -347,6 +347,12 @@ public:
   virtual EntityPtr make() = 0;
   virtual Value data(const Value& arg = Value::undef()) = 0;
   virtual Value match(const Value& arg = Value::undef()) = 0;
+
+  // `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.
+  virtual void markDeleted() = 0;
+  virtual bool deleted() = 0;
 };
 
 // ---- Feature contract -------------------------------------------------
@@ -575,22 +581,33 @@ public:
 
 // ---- SdkEntity contract -----------------------------------------------
 
+class SdkEntity;
+using SdkEntityPtr = std::shared_ptr<SdkEntity>;
+
+// Every operation resolves to the ENTITY, not the raw data - `list` to a
+// vector of them, one per record. The record is reached through `data()`.
+// See AGENTS.md "Entity operations return ENTITIES".
+//
+// `Value` cannot carry an entity: it is a closed data union, and adding a
+// variant to a general-purpose struct library to hold SDK objects would be
+// wrong. So the CONTRACT lives in these signatures instead.
 class SdkEntity : public Entity {
 public:
-  virtual Value load(const Value& reqmatch, const Value& ctrl) = 0;
-  virtual Value list(const Value& reqmatch, const Value& ctrl) = 0;
-  virtual Value create(const Value& reqdata, const Value& ctrl) = 0;
-  virtual Value update(const Value& reqdata, const Value& ctrl) = 0;
-  virtual Value remove(const Value& reqmatch, const Value& ctrl) = 0;
+  virtual SdkEntityPtr load(const Value& reqmatch, const Value& ctrl) = 0;
+  virtual std::vector<SdkEntityPtr> list(const Value& reqmatch, const Value& ctrl) = 0;
+  virtual SdkEntityPtr create(const Value& reqdata, const Value& ctrl) = 0;
+  virtual SdkEntityPtr update(const Value& reqdata, const Value& ctrl) = 0;
+  virtual SdkEntityPtr remove(const Value& reqmatch, const Value& ctrl) = 0;
 };
 
-using SdkEntityPtr = std::shared_ptr<SdkEntity>;
-
 // ---- EntityBase (shared entity runtime + runOp) -----------------------
 
-class EntityBase : public SdkEntity {
+class EntityBase : public SdkEntity,
+                   public std::enable_shared_from_this<EntityBase> {
 public:
   std::string name_ = "";
+  // Set once a successful `remove` resolves on this instance.
+  bool deleted_ = false;
   SdkClient* client = nullptr;
   UtilityPtr utility;
   Value entopts = Value::undef();
@@ -602,6 +619,14 @@ public:
 
   std::string getName() override { return name_; }
 
+  void markDeleted() override { deleted_ = true; }
+  bool deleted() override { return deleted_; }
+
+  // The handle for this instance, as the ops return it.
+  SdkEntityPtr self() {
+    return std::static_pointer_cast<SdkEntity>(shared_from_this());
+  }
+
   Value data(const Value& arg = Value::undef()) override;
   Value match(const Value& arg = Value::undef()) override;
 

package/project/.sdk/tm/cpp/test/pipeline_test.cpp

@@ -43,6 +43,11 @@ struct PlEntity : public Entity {
     return Value::undef();
   }
   Value match(const Value& arg = Value::undef()) override { return Value::undef(); }
+
+  // Every operation resolves to the entity; `remove` marks it. The fake has
+  // to satisfy the same interface the real entities do.
+  void markDeleted() override {}
+  bool deleted() override { return false; }
 };
 
 static std::string errCodeOf(const std::function<void()>& fn) {

package/project/.sdk/tm/cpp/test/runner_support.hpp

@@ -74,8 +74,8 @@ inline std::string getenv_local(const std::string& key) {
 }
 
 inline Value env_override(Value m) {
-  std::string live = getenv_local("PROJECTNAME_TEST_LIVE");
-  std::string over = getenv_local("PROJECTNAME_TEST_OVERRIDE");
+  std::string live = getenv_local("PROJECTENV_TEST_LIVE");
+  std::string over = getenv_local("PROJECTENV_TEST_OVERRIDE");
   if (live == "TRUE" || over == "TRUE") {
     if (m.is_map()) {
       for (const auto& k : Struct::keysof(m)) {
@@ -92,8 +92,8 @@ inline Value env_override(Value m) {
       }
     }
   }
-  std::string explain = getenv_local("PROJECTNAME_TEST_EXPLAIN");
-  if (!explain.empty()) map_put(m, "PROJECTNAME_TEST_EXPLAIN", Value(explain));
+  std::string explain = getenv_local("PROJECTENV_TEST_EXPLAIN");
+  if (!explain.empty()) map_put(m, "PROJECTENV_TEST_EXPLAIN", Value(explain));
   return m;
 }
 

package/project/.sdk/tm/csharp/VERSION

@@ -1 +1 @@
-0.0.1
+PROJECTVERSION

package/project/.sdk/tm/csharp/core/Types.cs

@@ -11,6 +11,12 @@ public interface IEntity
     IEntity Make();
     object? Data(object? data = null);
     object? Match(object? match = null);
+
+    // 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.
+    void MarkDeleted();
+    bool Deleted();
 }
 
 // Transport function: performs the HTTP (or mock) request. Returns a