@voxgig/sdkgen 2.0.2 → 3.0.0

package/project/.sdk/model/target/rb.aontu

@@ -24,11 +24,23 @@ main: kit: feature: &: target: rb: deps: &: {
 
 
 # Publication: rubygems registry (declared, publish pending — git-tag only).
+#
+# `target add <t>` OVERWRITES this file, so a project must never set its
+# publication values here — voxgig-solardemo-sdk lost its pinned npm package
+# name exactly that way. Set them in the project's own model
+# (`model/sdk.aontu`), where they survive a resync.
+#
+# For that to work this file must LEAVE THOSE KEYS UNSET: in aontu a concrete
+# value does not yield to another concrete value, it CONFLICTS, and two
+# defaults conflict too. The schema (@voxgig/sdkgen/model/sdkgen.aontu)
+# already defaults `tag.active`, `registry.state`, `registry.active` and
+# `registry.package`, so a project's concrete value wins over the default and
+# repeating them here would only take that away.
+#
+# What remains below is per-target registry IDENTITY, which is not a project
+# choice and stays concrete.
 main: kit: target: rb: publish: {
-  tag: { active: true }
   registry: {
-    state: 'pending'
-    active: false
     name: 'rubygems'
     url: 'https://rubygems.org'
     vault: { recipe: 'gem', alias: 'gem' }

package/project/.sdk/model/target/rust.aontu

@@ -25,13 +25,35 @@ main: kit: feature: &: target: rust: deps: &: {
 
 
 # Publication: crates.io registry (declared, publish pending — git-tag only).
+#
+# `target add <t>` OVERWRITES this file, so a project must never set its
+# publication values here — voxgig-solardemo-sdk lost its pinned npm package
+# name exactly that way. Set them in the project's own model
+# (`model/sdk.aontu`), where they survive a resync.
+#
+# For that to work this file must LEAVE THOSE KEYS UNSET: in aontu a concrete
+# value does not yield to another concrete value, it CONFLICTS, and two
+# defaults conflict too. The schema (@voxgig/sdkgen/model/sdkgen.aontu)
+# already defaults `tag.active`, `registry.state`, `registry.active` and
+# `registry.package`, so a project's concrete value wins over the default and
+# repeating them here would only take that away.
+#
+# What remains below is per-target registry IDENTITY, which is not a project
+# choice and stays concrete.
 main: kit: target: rust: publish: {
-  tag: { active: true }
   registry: {
-    state: 'pending'
-    active: false
     name: 'crates.io'
     url: 'https://crates.io'
     vault: { alias: 'cratesio', env: 'CARGO_REGISTRY_TOKEN' }
   }
 }
+
+
+# Feature source may be trimmed to the model's selection. The one template
+# needing the COMPLETE set is the cross-feature test suite, which `use`s
+# every feature module — so it is dropped alongside the features it
+# exercises whenever the set is trimmed.
+main: kit: target: rust: feature: {
+  trim: true
+  fullset: ['tests/feature_test.rs']
+}

package/project/.sdk/model/target/scala.aontu

@@ -25,13 +25,35 @@ main: kit: feature: &: target: scala: deps: &: {
 
 # Publication: tag-only for now (tag scala/vX.Y.Z) — Maven Central
 # publication via the Sonatype Central Portal is declared but pending.
+# Publication.
+#
+# `target add <t>` OVERWRITES this file, so a project must never set its
+# publication values here — voxgig-solardemo-sdk lost its pinned npm package
+# name exactly that way. Set them in the project's own model
+# (`model/sdk.aontu`), where they survive a resync.
+#
+# For that to work this file must LEAVE THOSE KEYS UNSET: in aontu a concrete
+# value does not yield to another concrete value, it CONFLICTS, and two
+# defaults conflict too. The schema (@voxgig/sdkgen/model/sdkgen.aontu)
+# already defaults `tag.active`, `registry.state`, `registry.active` and
+# `registry.package`, so a project's concrete value wins over the default and
+# repeating them here would only take that away.
+#
+# What remains below is per-target registry IDENTITY, which is not a project
+# choice and stays concrete.
 main: kit: target: scala: publish: {
-  tag: { active: true }
   registry: {
-    state: 'pending'
-    active: false
     name: 'maven-central'
     url: 'https://central.sonatype.com'
     vault: { recipe: 'maven', alias: 'central' }
   }
 }
+
+
+# Feature source is NOT trimmed to the model's selection here: the cross-
+# feature tests live inside sdktest/SdkTestMain.scala, the single test
+# entry point, so they cannot be dropped without losing every other test
+# too. Trimming stays off until that suite is split per feature.
+main: kit: target: scala: feature: {
+  trim: false
+}

package/project/.sdk/model/target/swift.aontu

@@ -23,13 +23,35 @@ main: kit: feature: &: target: swift: deps: &: {
 
 
 # Publication: SwiftPM registry is git-tag only (publish pending).
+#
+# `target add <t>` OVERWRITES this file, so a project must never set its
+# publication values here — voxgig-solardemo-sdk lost its pinned npm package
+# name exactly that way. Set them in the project's own model
+# (`model/sdk.aontu`), where they survive a resync.
+#
+# For that to work this file must LEAVE THOSE KEYS UNSET: in aontu a concrete
+# value does not yield to another concrete value, it CONFLICTS, and two
+# defaults conflict too. The schema (@voxgig/sdkgen/model/sdkgen.aontu)
+# already defaults `tag.active`, `registry.state`, `registry.active` and
+# `registry.package`, so a project's concrete value wins over the default and
+# repeating them here would only take that away.
+#
+# What remains below is per-target registry IDENTITY, which is not a project
+# choice and stays concrete.
 main: kit: target: swift: publish: {
-  tag: { active: true }
   registry: {
-    state: 'pending'
-    active: false
     name: 'swiftpm'
     url: 'https://swift.org/package-manager'
     vault: { alias: 'swiftpm', env: 'SWIFTPM_TOKEN' }
   }
 }
+
+
+# Feature source may be trimmed to the model's selection. The one template
+# needing the COMPLETE set is the cross-feature test suite, which
+# constructs every *Feature type — so it is dropped alongside the
+# features it exercises whenever the set is trimmed.
+main: kit: target: swift: feature: {
+  trim: true
+  fullset: ['Tests/ProjectNameSDKTests/FeatureTest.swift']
+}

package/project/.sdk/model/target/ts.aontu

@@ -27,11 +27,23 @@ main: kit: feature: &: target: ts: deps: &: {
 
 
 # Publication: npm registry (declared, publish pending — git-tag only).
+#
+# `target add <t>` OVERWRITES this file, so a project must never set its
+# publication values here — voxgig-solardemo-sdk lost its pinned npm package
+# name exactly that way. Set them in the project's own model
+# (`model/sdk.aontu`), where they survive a resync.
+#
+# For that to work this file must LEAVE THOSE KEYS UNSET: in aontu a concrete
+# value does not yield to another concrete value, it CONFLICTS, and two
+# defaults conflict too. The schema (@voxgig/sdkgen/model/sdkgen.aontu)
+# already defaults `tag.active`, `registry.state`, `registry.active` and
+# `registry.package`, so a project's concrete value wins over the default and
+# repeating them here would only take that away.
+#
+# What remains below is per-target registry IDENTITY, which is not a project
+# choice and stays concrete.
 main: kit: target: ts: publish: {
-  tag: { active: true }
   registry: {
-    state: 'pending'
-    active: false
     name: 'npm'
     url: 'https://registry.npmjs.org'
     vault: { recipe: 'npm', alias: 'npm' }

package/project/.sdk/model/target/zig.aontu

@@ -25,13 +25,36 @@ main: kit: feature: &: target: zig: deps: &: {
 # routes deploy-zig to the root tag-push recipe. WITHOUT it, Deploy.ts falls
 # through to `make -C zig publish` — but zig's Makefile has no `publish` target,
 # so the deploy fails. Mirror c.aontu exactly.
+# Publication.
+#
+# `target add <t>` OVERWRITES this file, so a project must never set its
+# publication values here — voxgig-solardemo-sdk lost its pinned npm package
+# name exactly that way. Set them in the project's own model
+# (`model/sdk.aontu`), where they survive a resync.
+#
+# For that to work this file must LEAVE THOSE KEYS UNSET: in aontu a concrete
+# value does not yield to another concrete value, it CONFLICTS, and two
+# defaults conflict too. The schema (@voxgig/sdkgen/model/sdkgen.aontu)
+# already defaults `tag.active`, `registry.state`, `registry.active` and
+# `registry.package`, so a project's concrete value wins over the default and
+# repeating them here would only take that away.
+#
+# What remains below is per-target registry IDENTITY, which is not a project
+# choice and stays concrete.
 main: kit: target: zig: publish: {
-  tag: { active: true }
   registry: {
-    state: 'pending'
-    active: false
     name: 'none'
     url: ''
     vault: { alias: 'none', env: 'NONE' }
   }
 }
+
+
+# Feature source is NOT trimmed to the model's selection here: root.zig
+# re-exports every feature type with @import("feature/<name>.zig"), and
+# build.zig names test/feature_test.zig explicitly, so a trimmed tree
+# fails to build. Trimming stays off until root.zig's feature exports are
+# driven from the model.
+main: kit: target: zig: feature: {
+  trim: false
+}

package/project/.sdk/src/cmp/c/Config_c.ts

@@ -90,17 +90,16 @@ voxgig_value* make_config(void) {
 Feature* make_feature(const char* name) {
 `)
 
-    // The C target ships the full transport/observability feature set as
-    // fixed runtime templates (tm/c/feature/*.c, declared in core/sdk.h), so
-    // make_feature must dispatch to every shipped feature — not only those the
-    // current API model happens to configure. Merge the model's feature names
-    // with the standard shipped set; emit in sorted order for byte-stability.
-    const SHIPPED_FEATURES = [
-      'audit', 'cache', 'clienttrack', 'debug', 'idempotency', 'log',
-      'metrics', 'netsim', 'paging', 'proxy', 'ratelimit', 'rbac', 'retry',
-      'streaming', 'telemetry', 'test', 'timeout',
-    ]
-    const featureNames = new Set<string>(SHIPPED_FEATURES)
+    // Dispatch to the features the MODEL declares, and only those.
+    //
+    // This used to merge in a hardcoded list of every feature the C target
+    // ships, on the reasoning that the runtime templates
+    // (tm/c/feature/*.c) are always present. `target add` now trims feature
+    // source to the model's selection, so that reasoning is false: a
+    // reference to `feature_timeout_new` for an undeclared feature is an
+    // unresolved symbol at LINK time — the whole test suite fails to link,
+    // which is how this was found. Sorted for byte-stability.
+    const featureNames = new Set<string>()
     each(feature, (f: any) => {
       if (f.name && f.name !== 'base') featureNames.add(f.name)
     })

package/project/.sdk/src/cmp/c/Entity_c.ts

@@ -46,7 +46,11 @@ const Entity = cmp(function Entity(props: any) {
           (a['#' + camelify(opname) + 'Op'] =
             !opnames.includes(opname) ?
               ({ indent }: any) => {
-                Content({ indent }, `static voxgig_value* ${evar}_${opname}(Entity* e, voxgig_value* reqarg, voxgig_value* ctrl, PNError** err) {
+                // The stub mirrors the real signature: ops resolve to the
+                // ENTITY (`list` to a NULL-terminated array of them), so an
+                // unsupported op declares the same return type as the vtable.
+                const ret = 'list' === opname ? 'Entity**' : 'Entity*'
+                Content({ indent }, `static ${ret} ${evar}_${opname}(Entity* e, voxgig_value* reqarg, voxgig_value* ctrl, PNError** err) {
   (void)e; (void)reqarg; (void)ctrl;
   *err = unsupported_op("${opname}", "${entity.name}");
   return NULL;

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_);
   }