@voxgig/sdkgen 2.0.2 → 3.1.0

package/project/.sdk/src/cmp/ts/TestDirect_ts.ts

@@ -18,7 +18,7 @@ import {
   snakify,
   isAuthActive,
   jsProp,
-  jsOptProp,
+  jsOptProp, envName, envToken, liveStrict
 } from '@voxgig/sdkgen'
 
 
@@ -37,8 +37,11 @@ const TestDirect = cmp(function TestDirect(props: any) {
 
   const ff = projectPath('src/cmp/ts/fragment/')
 
-  const PROJECTNAME = nom(model, 'Name').toUpperCase().replace(/[^A-Z_]/g, '_')
-  const entidEnvVar = `${PROJECTNAME}_TEST_${nom(entity, 'NAME').replace(/[^A-Z_]/g, '_')}_ENTID`
+  // Does a live run ASSERT, or merely observe? See helpers/testPolicy.
+  const strict = liveStrict(model, target.name)
+
+  const PROJECTNAME = envName(model)
+  const entidEnvVar = `${PROJECTNAME}_TEST_${envToken(entity.name)}_ENTID`
 
   const authActive = isAuthActive(model)
   const apikeyEnvEntry = authActive
@@ -136,11 +139,11 @@ function unwrapListData(data: any): any[] | null {
         Slot({ name: 'direct' }, () => {
 
           if (hasLoad) {
-            generateDirectLoad(model, entity)
+            generateDirectLoad(model, entity, strict)
           }
 
           if (hasList) {
-            generateDirectList(model, entity)
+            generateDirectList(model, entity, strict)
           }
         })
 
@@ -150,7 +153,7 @@ function unwrapListData(data: any): any[] | null {
 })
 
 
-function generateDirectLoad(model: Model, entity: ModelEntity) {
+function generateDirectLoad(model: Model, entity: ModelEntity, strict: boolean) {
   const loadOp = entity.op?.load
   const loadPoint: ModelPoint | undefined = loadOp?.points?.[0]
 
@@ -318,6 +321,31 @@ ${loadParams.map((p: any, i: number) => `      ${jsProp('params', p.name)} = 'di
     ? `    if (skipIfMissingIds(t, setup, ${JSON.stringify(liveIdKeys)})) return\n`
     : ''
 
+  // Live-mode leniency is a MODEL decision (main.kit.test.live.strict).
+  // The default stays lenient: a fleet SDK generated against an arbitrary
+  // public API 4xxes on synthetic IDs, and asserting would mean permanent
+  // red. A project that owns its test server wants the opposite — without
+  // it, the suite passes with nothing listening on the port.
+  const offlineChecks = `      assert(result.ok === true)
+      assert(result.status === 200)
+      assert(null != result.data)
+      assert(result.data.id === 'direct01')
+      assert(calls.length === 1)
+      assert(calls[0].init.method === 'GET')
+${paramAsserts}`
+
+  const loadChecks = strict ?
+    offlineChecks.replace(/^ {6}/gm, '    ').replace(/^ {4}$/gm, '') :
+    `    if (setup.live) {
+      // Live mode is lenient: synthetic IDs frequently 4xx. Skip rather
+      // than fail when the load endpoint isn't reachable with the IDs we
+      // can construct from setup.idmap.
+      if (!result.ok || result.status < 200 || result.status >= 300) {
+        return
+      }
+    } else {
+${offlineChecks}    }`
+
   Content(`
   test('direct-load-${entity.name}', async (t: any) => {
     const setup = directSetup({ id: 'direct01' })
@@ -335,27 +363,13 @@ ${liveParamsBlock}
       query,
     })
 
-    if (setup.live) {
-      // Live mode is lenient: synthetic IDs frequently 4xx. Skip rather
-      // than fail when the load endpoint isn't reachable with the IDs we
-      // can construct from setup.idmap.
-      if (!result.ok || result.status < 200 || result.status >= 300) {
-        return
-      }
-    } else {
-      assert(result.ok === true)
-      assert(result.status === 200)
-      assert(null != result.data)
-      assert(result.data.id === 'direct01')
-      assert(calls.length === 1)
-      assert(calls[0].init.method === 'GET')
-${paramAsserts}    }
+${loadChecks}
   })
 `)
 }
 
 
-function generateDirectList(model: Model, entity: ModelEntity) {
+function generateDirectList(model: Model, entity: ModelEntity, strict: boolean) {
   const listOp = entity.op?.list
   const listPoint: ModelPoint | undefined = listOp?.points?.[0]
 
@@ -418,6 +432,33 @@ ${mockLines}
     ? `    if (skipIfMissingIds(t, setup, ${JSON.stringify(liveIdKeys)})) return\n`
     : ''
 
+  // See generateDirectLoad: leniency is main.kit.test.live.strict.
+  const offlineChecks = `      assert(result.ok === true)
+      assert(result.status === 200)
+      assert(null != result.data)
+      const listArr = unwrapListData(result.data)
+      assert(Array.isArray(listArr))
+      assert(listArr!.length === 2)
+      assert(calls.length === 1)
+      assert(calls[0].init.method === 'GET')
+${paramAsserts}`
+
+  const listChecks = strict ?
+    offlineChecks.replace(/^ {6}/gm, '    ').replace(/^ {4}$/gm, '') :
+    `    if (setup.live) {
+      // Live mode is lenient: synthetic IDs frequently 4xx and the list-
+      // response shape varies wildly across public APIs. Skip rather than
+      // fail when the call doesn't return a usable list.
+      if (!result.ok || result.status < 200 || result.status >= 300) {
+        return
+      }
+      const listArr = unwrapListData(result.data)
+      if (!Array.isArray(listArr)) {
+        return
+      }
+    } else {
+${offlineChecks}    }`
+
   Content(`
   test('direct-list-${entity.name}', async (t: any) => {
     const setup = directSetup([{ id: 'direct01' }, { id: 'direct02' }])
@@ -432,27 +473,7 @@ ${paramsBlock}
       query,
     })
 
-    if (setup.live) {
-      // Live mode is lenient: synthetic IDs frequently 4xx and the list-
-      // response shape varies wildly across public APIs. Skip rather than
-      // fail when the call doesn't return a usable list.
-      if (!result.ok || result.status < 200 || result.status >= 300) {
-        return
-      }
-      const listArr = unwrapListData(result.data)
-      if (!Array.isArray(listArr)) {
-        return
-      }
-    } else {
-      assert(result.ok === true)
-      assert(result.status === 200)
-      assert(null != result.data)
-      const listArr = unwrapListData(result.data)
-      assert(Array.isArray(listArr))
-      assert(listArr!.length === 2)
-      assert(calls.length === 1)
-      assert(calls[0].init.method === 'GET')
-${paramAsserts}    }
+${listChecks}
   })
 `)
 }

package/project/.sdk/src/cmp/ts/TestEntity_ts.ts

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

package/project/.sdk/src/cmp/ts/fragment/Direct.test.fragment.ts

@@ -19,8 +19,8 @@ import {
 describe('EntityNameDirect', async () => {
 
   // Per-test live pacing. Delay is read from sdk-test-control.json's
-  // `test.live.delayMs`; only sleeps when PROJECTNAME_TEST_LIVE=TRUE.
-  afterEach(liveDelay('PROJECTNAME_TEST_LIVE'))
+  // `test.live.delayMs`; only sleeps when PROJECTENV_TEST_LIVE=TRUE.
+  afterEach(liveDelay('PROJECTENV_TEST_LIVE'))
 
   test('direct-exists', async () => {
     const sdk = new ProjectNameSDK({

package/project/.sdk/src/cmp/ts/fragment/Entity.test.fragment.ts

@@ -26,8 +26,8 @@ import {
 describe('EntityNameEntity', async () => {
 
   // Per-test live pacing. Delay is read from sdk-test-control.json's
-  // `test.live.delayMs`; only sleeps when PROJECTNAME_TEST_LIVE=TRUE.
-  afterEach(liveDelay('PROJECTNAME_TEST_LIVE'))
+  // `test.live.delayMs`; only sleeps when PROJECTENV_TEST_LIVE=TRUE.
+  afterEach(liveDelay('PROJECTENV_TEST_LIVE'))
 
   test('instance', async () => {
     const testsdk = ProjectNameSDK.test()

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

@@ -32,6 +32,11 @@ class ProjectNameEntityBase<D = any> {
   _match: Partial<D>
   _entctx: Context
 
+  // Set once a successful `remove` resolves on this instance. The entity
+  // KEEPS the data it held — a caller can still read what was deleted — but
+  // it is no longer a live record.
+  _deleted: boolean
+
 
   constructor(client: ProjectNameSDK, entopts: any) {
     entopts = entopts || {}
@@ -42,6 +47,7 @@ class ProjectNameEntityBase<D = any> {
     this._utility = client.utility()
     this._data = {}
     this._match = {}
+    this._deleted = false
 
     const makeContext = this._utility.makeContext
 
@@ -54,6 +60,19 @@ class ProjectNameEntityBase<D = any> {
     featureHook(this._entctx, 'PostConstructEntity')
   }
 
+  // True once `remove` has succeeded on this instance. `remove` resolves to
+  // the entity like every other operation, so this is how a caller tells a
+  // removed record from a live one.
+  markDeleted(this: any): void {
+    this._deleted = true
+  }
+
+
+  deleted(this: any): boolean {
+    return true === this._deleted
+  }
+
+
   entopts() {
     return this._utility.struct.merge([{}, this._entopts])
   }
@@ -178,7 +197,12 @@ class ProjectNameEntityBase<D = any> {
 
   toJSON() {
     const struct = this._utility.struct
-    return struct.merge([{}, struct.getdef(this._data, {}), { entity$: this.Name }])
+  // The marker is NAMESPACED. It used to be `entity$` — a short, generic
+  // name, and the `$`-suffix convention is not unique to sdkgen. Seneca uses
+  // `entity$` on its own entities to hold the canon, so an SDK record fed
+  // into `entize` silently overwrote it and produced entities claiming a
+  // canon that does not exist: no error, just wrong entities.
+    return struct.merge([{}, struct.getdef(this._data, {}), { 'voxgig$entity': this.Name }])
   }
 
 

package/project/.sdk/src/cmp/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 {