@voxgig/sdkgen 4.21.0 → 4.23.0

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

@@ -16,48 +16,6 @@ import {
 } from '@voxgig/apidef'
 
 
-// WHERE THE CREDENTIAL GOES IS A FACT ABOUT THE API, so it is generated
-// rather than templated. The zig peer of PrepareAuth_ts; read that one
-// first, it carries the full account of the defect.
-//
-// zig differs from the other twelve ports in ONE way: it had no
-// prepare_auth template to delete. The logic was EMBEDDED in
-// `tm/zig/core/utility.zig` — three file-scope constants and a
-// `pub fn prepare_auth_util` in the middle of a 1500-line module that also
-// holds make_spec, make_url, the result builders and the Utility bundle
-// itself. So this is an EXTRACTION, not a replacement:
-//
-//   core/prepare_auth.zig   GENERATED here, one function.
-//   core/utility.zig        keeps
-//                             pub const prepare_auth_util =
-//                                 @import("prepare_auth.zig").prepare_auth_util;
-//
-// THE OWN-FILE SHAPE, not the whole-module-as-a-component fallback. A zig
-// file IS a struct, so a function in its own file is a first-class
-// compilation unit reached by a relative `@import` — no build.zig entry, no
-// module declaration, nothing to register. Generating the whole of
-// utility.zig instead would turn 1500 lines of hand-maintained template
-// into a TypeScript string for the sake of 40, which is the opposite of the
-// trade the other targets made.
-//
-// THE BINDING DOES NOT MOVE. Three call sites name this symbol and all three
-// keep resolving to it through the re-export:
-//   - `Utility.prepare_auth` (core/utility.zig) — the method the pipeline
-//     dispatches through, called by core/sdk.zig (Main.fragment.zig line
-//     `self.sdkUtility.prepare_auth(ctx)`) and asserted on by
-//     test/pipeline_test.zig.
-//   - `make_spec_util` (core/utility.zig) — `try prepare_auth_util(ctx)`,
-//     unqualified, so the file-scope const is what it finds.
-//   - `sdk.utilmod.prepare_auth_util` — root.zig exports core/utility.zig as
-//     `utilmod`, and test/primary_utility_test.zig drives the shared
-//     corpus's `prepareAuth` section through it.
-//
-// A template cannot fix the defect, because the three placements need three
-// different bodies and a template has to pick one. A component emits the
-// branch this API actually uses and nothing else — and zig makes that
-// stricter than most: an unused LOCAL is a compile error, so a file that
-// bound `auth_prefix` and then dropped it for a query placement would not
-// build at all.
 const PrepareAuth = cmp(async function PrepareAuth(props: any) {
   const { target } = props
   const { model } = props.ctx$
@@ -65,35 +23,9 @@ const PrepareAuth = cmp(async function PrepareAuth(props: any) {
   const active = isAuthActive_zig(model)
   const where = resolveAuthIn(model)
   const name = resolveAuthName(model)
-  // Read so the resolution is visible at generation time even though the
-  // emitted code takes the prefix from `options.auth.prefix` at RUNTIME -
-  // it has to, because the secrets feature rewrites it there.
   const prefix = resolveAuthPrefix(model)
   const basic = isHttpBasicAuth(model)
 
-  // FOLDER NESTING — NO Folder IS OPENED HERE, and that is worked out from
-  // two facts, not assumed.
-  //
-  // 1. The template this extracts from is `tm/zig/core/utility.zig`, and
-  //    Main_zig's `Copy({from: 'tm/zig'})` runs at the TARGET ROOT with no
-  //    folder open (zig's layout is flat there: core/, feature/, utility/,
-  //    entity/, test/ — Main_zig's own comment says the idiomatic src/ is
-  //    deliberately not used). So that template lands at `<root>/core/`,
-  //    and the extracted function must land in the same directory for
-  //    `@import("prepare_auth.zig")` — a SIBLING-relative path — to resolve.
-  //
-  // 2. Main_zig ALREADY opens `Folder({name: 'core'})` for core/sdk.zig and
-  //    for Config, and that is where this component is called. Config_zig
-  //    writes `File({name: 'config.zig'})` with no Folder of its own for
-  //    exactly this reason.
-  //
-  // Opening a second `core` here would write `core/core/prepare_auth.zig`:
-  // a file no `@import` names, invisible to `zig build` (which analyses only
-  // what a module root reaches), while core/utility.zig's re-export fails to
-  // resolve — or, worse in the ts port's version of this trap, silently
-  // keeps using a stale sibling. Verified by generating the target and
-  // running `zig build test` against the result, not by eye: a file zig
-  // never reaches produces no error at all.
   File({ name: 'prepare_auth.' + target.ext }, () => {
     Content(render({ active, where, name, prefix, basic }))
   })
@@ -124,9 +56,6 @@ const HEAD = `// prepare_auth — GENERATED from the model (src/cmp/zig/PrepareA
 
 
 function render(spec: AuthSpec): string {
-  // NO GENERATION-TIME GATE ON WHETHER TO PLACE A CREDENTIAL AT ALL, beyond
-  // the project's own explicit switch — see isAuthActive_zig below for why
-  // `isAuthActive` is the wrong predicate here.
   if (!spec.active) return renderInactive()
 
   if ('query' === spec.where) return renderQuery(spec)
@@ -136,11 +65,6 @@ function render(spec: AuthSpec): string {
 }
 
 
-// AUTH SWITCHED OFF BY THE PROJECT (`main.kit.config.auth.active: false`).
-// The SDK gets a prepare_auth that is honest about it rather than one that
-// deletes a header nobody set. Nothing but the Context and Spec types is
-// imported: zig tolerates an unused file-scope const, but a reader should
-// not have to decide whether `vs` here means something.
 function renderInactive(): string {
   return HEAD + `//
 // THIS SDK SENDS NO CREDENTIAL: the project set
@@ -164,10 +88,6 @@ pub fn prepare_auth_util(ctx: *Context) E!*Spec {
 }
 
 
-// HEADER — the default, and BYTE-FOR-BYTE the body that was in
-// core/utility.zig when the scheme resolves to header/Authorization. Only
-// the constant's VALUE moves with the model, plus the HTTP Basic block,
-// which is emitted only for a basic scheme.
 function renderHeader(spec: AuthSpec): string {
   const withBasic = spec.basic
 
@@ -225,10 +145,6 @@ pub fn prepare_auth_util(ctx: *Context) E!*Spec {
 }
 
 
-// QUERY — the credential is a query parameter, so it goes in spec.query and
-// the header bag is never touched. No `fmt`, because nothing is joined:
-// zig would accept an unused file-scope helper, but emitting one invites the
-// reader to look for the concatenation that is deliberately absent.
 function renderQuery(spec: AuthSpec): string {
   return HEAD + imports({ vs: true, fmt: false }) +
     facts(spec.where, false, true) + `
@@ -367,10 +283,6 @@ pub fn prepare_auth_util(ctx: *Context) E!*Spec {
 }
 
 
-// The imports and type aliases, in core/utility.zig's own order and
-// spelling. `E` comes from helpers rather than error.zig on purpose:
-// error.zig's type is `ProjectNameError`, and the placeholder rewrite is
-// applied by Copy, which this GENERATED file never travels through.
 function imports(need: { vs: boolean, fmt: boolean }): string {
   return `
 const std = @import("std");
@@ -391,8 +303,6 @@ fn fmt(comptime f: []const u8, args: anytype) []const u8 {
 }
 
 
-// Emitted only for a basic scheme in a HEADER placement, so an ordinary
-// bearer SDK carries neither the base64 encoder nor the boolean coercion.
 function basicHelpers(): string {
   return `
 // Boolean-or-absent: an option that is unset, null or a non-boolean is false
@@ -461,40 +371,11 @@ function basicBlock(): string {
 }
 
 
-// The credential's key, as it goes into the bag.
-//
-// A HEADER name is LOWERCASED. HTTP header names are case-insensitive on the
-// wire (RFC 9110 5.1), but this SDK's header bag is a plain Value map and
-// object keys are case-SENSITIVE: the extracted template said
-// `const HEADER_AUTH = "authorization";`, the shared corpus asserts
-// `ctx:spec:headers:authorization`, tm/zig/test/pipeline_test.zig reads
-// `h.getp(ctx.spec.?.headers, "authorization")`, and feature/secrets.zig
-// rewrites the same lowercase key. apidef writes `name: "Authorization"`, so
-// emitting it verbatim would put the credential where none of those look.
-//
-// A QUERY parameter and a COOKIE name are case-SENSITIVE to the API itself,
-// so those go in exactly as the spec spells them: `?token=` is not `?Token=`.
 function credLiteral(where: string, name: string): string {
   return 'header' === where ? String(name).toLowerCase() : String(name)
 }
 
 
-// NOT `isAuthActive`, AND THE DIFFERENCE IS LOAD-BEARING. That helper is also
-// false whenever the SPEC declares no security scheme
-// (`main.kit.info.auth: false`) — a statement about the DEFINITION, not a ban
-// on ever sending a credential. Such an SDK still carries one: `optspec`
-// always declares `apikey`, and make_options_util fills `options.auth` from
-// the optspec defaults (tm/zig/core/utility.zig), so the runtime
-// `h.is_noval(auth)` guard never fired and every such SDK has always sent
-// `options.apikey`. Gating the body on `isAuthActive` does not trim dead
-// code, it silently removes working authentication — and takes the secrets
-// feature with it, since that resolves a secret into `options.apikey` and
-// prepare_auth then places nothing. zig's own gated suite
-// (`zig build test-secrets`) pins exactly that.
-//
-// `main.kit.config.auth.active: false` is the project saying "this SDK sends
-// no credential, ever". It is the only signal that can honestly be honoured
-// before runtime, so it is the only one used here.
 function isAuthActive_zig(model: any): boolean {
   const auth = getModelPath(model, `main.${KIT}.config.auth`,
     { only_active: false, required: false })
@@ -502,23 +383,6 @@ function isAuthActive_zig(model: any): boolean {
 }
 
 
-// THE PLACEMENT AS A COMPTIME FACT, exported beside the function.
-//
-// The generated body has exactly ONE branch, chosen here at generation time,
-// and nothing downstream can tell which by looking at the options: a query
-// SDK's `options.auth.in` says "query", but an auth-OFF SDK is
-// indistinguishable from a header one there (Config omits `options.auth`
-// entirely when auth is inactive, and make_options' optspec then supplies the
-// same empty defaults either way).
-//
-// tm/zig/test/pipeline_test.zig needs to tell them apart. Its prepare_auth
-// cases assert the HEADER shape - `spec.headers["authorization"]` - which is
-// the right assertion for the default and the wrong one for the other three,
-// where the SDK correctly places nothing there. Rather than let a query SDK
-// ship four red tests (or delete the coverage that every header SDK does
-// want), the suite reads these two constants and skips what does not apply.
-//
-// core/utility.zig re-exports both, so the path is `sdk.utilmod.<name>`.
 function facts(where: string, basic: boolean, active: boolean): string {
   const placement = active ? where : 'none'
 

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

@@ -66,7 +66,7 @@ const ReadmeEntity = cmp(function ReadmeEntity(props: any) {
 
   publishedEntities.map((entity: any) => {
     const opnames = Object.keys(entity.op || {})
-    const fields = entity.fields || []
+    const fields = Object.values(entity.fields || {})
     const idF = entityIdField(entity)
     const eVar = zigVarName(entity.name)
     const method = zigVarName(entity.name)
@@ -115,8 +115,8 @@ carries the result \`Value\`, \`.err => |e|\` carries the branded error.
 `)
 
       each(fields, (field: any) => {
-        const desc = field.short || ''
-        Content(`| \`${field.name}\` | \`${zigType(field.type)}\` | ${desc} |
+        const desc = field.sh || ''
+        Content(`| \`${field.n}\` | \`${zigType(field.t)}\` | ${desc} |
 `)
       })
 

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

@@ -2,24 +2,6 @@
 import { cmp, Content } from '@voxgig/sdkgen'
 
 
-// Validates the documented README/REFERENCE quick-start examples for the Zig
-// SDK.
-//
-// DESIGN NOTE vs the go/rust gates (ReadmeExamplesTest_go.ts /
-// ReadmeExamplesTest_rust.ts): the go version shells out to `go build`/`go run`
-// to compile and run every fenced block; the rust version reads the doc files
-// and checks that each block is structurally well-formed. Zig's test harness
-// uses an EXPLICIT test-file list in build.zig (no auto-discovery of test/*.zig
-// and no per-block temp compilation), and the doc files are not on the package
-// path at test time — so neither a filesystem scan nor a per-snippet compile can
-// be authored safely without a build to validate against.
-//
-// Instead this gate emits a real, always-compiling zig `test` block INTO the
-// shared generated_test.zig (the only generated test file build.zig picks up).
-// It exercises the exact top-level entry points the docs advertise — the
-// test-mode constructor and the `direct()` escape hatch — so the documented
-// quick-start surface is guaranteed to exist and run. Upgrading it to a true
-// per-block compile gate is left as a follow-up.
 const ReadmeExamplesTest = cmp(function ReadmeExamplesTest(props: any) {
   const { ctx$: { model } } = props
 

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

@@ -118,13 +118,13 @@ On error, \`ok\` is \`false\` and \`err\` carries the error message.
 
 `)
   each(entityList, (ent: any) => {
-    const fields = ent.fields || []
+    const fields = Object.values(ent.fields || {})
     const opnames = Object.keys(ent.op || {})
     const ops = ent.op || {}
     const points = each(ops).map((op: any) =>
       op.points ? each(op.points) : []
     ).flat()
-    const path = points.length > 0 ? (points[0] as any).orig || '' : ''
+    const path = points.length > 0 ? (points[0] as any).o || '' : ''
 
     Content(`#### ${ent.Name}
 
@@ -132,7 +132,7 @@ On error, \`ok\` is \`false\` and \`err\` carries the error message.
 | --- | --- |
 `)
     each(fields, (field: any) => {
-      Content(`| \`${field.name}\` | ${field.short || ''} |
+      Content(`| \`${field.n}\` | ${field.sh || ''} |
 `)
     })
 

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

@@ -154,9 +154,6 @@ switch (client.${method}(h.vnull()).load(${loadArg}, h.vnull())) {
       const it = opRequestShape(exampleEntity, opname).items.find((x: any) => x.name === idF)
       return it && it.type
     }
-    // The id VALUE for an update/remove match: a type-correct literal (zig
-    // ops return an OpResult, so threading the created record's id through a
-    // switch scope would obscure the example).
     const idValueFor = (opname: string): string => zigLit(idParamType(opname), 'example_id')
 
     if (opnames.includes('create') || opnames.includes('update') || opnames.includes('remove')) {

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

@@ -1,5 +1,5 @@
 
-import { cmp, each, Content, canonKey, canonScalarKey, File, isAuthActive, entityIdField, opRequestShape } from '@voxgig/sdkgen'
+import { cmp, each, Content, canonKey, canonScalarKey, File, isAuthActive, entityIdField, opRequestShape , targetFeatures } from '@voxgig/sdkgen'
 import { ReadmeRefFeatures } from '@voxgig/sdkgen'
 
 import {
@@ -39,7 +39,7 @@ const ReadmeRef = cmp(function ReadmeRef(props: any) {
   const { model } = props.ctx$
 
   const entity = getModelPath(model, `main.${KIT}.entity`)
-  const feature = getModelPath(model, `main.${KIT}.feature`)
+  const feature = targetFeatures(model, target)
 
   const publishedEntities = each(entity).filter((e: any) => e.active !== false)
 
@@ -175,7 +175,7 @@ Prepare a fetch definition without sending. Returns the fetchdef (use
     // Entity reference sections
     publishedEntities.map((ent: any) => {
       const opnames = Object.keys(ent.op || {})
-      const fields = ent.fields || []
+      const fields = Object.values(ent.fields || {})
       const idF = entityIdField(ent)
       const eVar = zigVarName(ent.name)
       const method = zigVarName(ent.name)
@@ -208,9 +208,9 @@ const ${eVar} = client.${method}(h.vnull());
 | --- | --- | --- | --- |
 `)
         each(fields, (field: any) => {
-          const req = field.req ? 'Yes' : 'No'
-          const desc = field.short || ''
-          Content(`| \`${field.name}\` | \`${zigType(field.type)}\` | ${req} | ${desc} |
+          const req = field.r ? 'Yes' : 'No'
+          const desc = field.sh || ''
+          Content(`| \`${field.n}\` | \`${zigType(field.t)}\` | ${req} | ${desc} |
 `)
         })
 
@@ -235,7 +235,7 @@ const ${eVar} = client.${method}(h.vnull());
               if (fop.active === false) return '-'
               return 'Yes'
             })
-            Content(`| \`${field.name}\` | ${cols.join(' | ')} |
+            Content(`| \`${field.n}\` | ${cols.join(' | ')} |
 `)
           })
 
@@ -390,9 +390,6 @@ const client = sdk.${model.const.Name}SDK.new(h.jo(&.{
 \`\`\`
 
 `)
-      // The shared feature reference: options, defaults, usage and the
-      // considerations. Model facts, identical in every target, so they are
-      // written once in cmp/ReadmeRefFeatures.ts rather than here.
       ReadmeRefFeatures({ target })
     }
 

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

@@ -12,29 +12,6 @@ import {
 } from '@voxgig/apidef'
 
 
-// THE GENERATED SCHEMA MODULE: the model's schemas, as data the SDK can run.
-//
-// The zig peer of src/cmp/ts/Schema_ts.ts. Same two members, same source:
-// optspec from `main.kit.optspec` plus each feature's own `config.options`,
-// entityspec from the entity field sentinels — both built by the shared
-// helpers, so what zig validates against and what ts validates against cannot
-// drift.
-//
-// EMBEDDED AS JSON, PARSED AT LOAD, where ts emits an object literal: JSON is
-// a subset of TypeScript's own literal syntax and is not a subset of zig's.
-// A string constant, exactly as config.zig carries its data rep above the
-// size threshold, and for the same reason — a nested `h.jo(...)` literal is
-// one expression zig's comptime evaluator walks in full at every build. The
-// spec has no threshold of its own because it is bounded by the option list
-// and the feature set rather than by the API.
-//
-// The escaping is JSON.stringify's, which is valid Zig: it escapes every
-// backslash, so the JSON's own `\uXXXX` reaches the file as `\\uXXXX` and no
-// Zig escape sequence is ever formed from it.
-//
-// The round-trip is exact because the spec holds only strings and booleans:
-// pinned by "strings and booleans only, so the JSON round-trip is lossless"
-// in ts/test/optspec.test.ts.
 const Schema = cmp(async function Schema(props: any) {
   const ctx$ = props.ctx$
   const target = props.target
@@ -51,7 +28,7 @@ const Schema = cmp(async function Schema(props: any) {
     Content(`// ${model.const.Name} SDK: generated schemas. Do not edit.
 //
 // Built from the model: \`main.kit.optspec\` and each feature's
-// \`config.options\` for the option spec; entity \`fields[].type\` for the
+// \`config.options\` for the option spec; entity \`fields{}.type\` for the
 // entity specs.
 
 const h = @import("helpers.zig");

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

@@ -4,17 +4,6 @@ import { cmp, Content } from '@voxgig/sdkgen'
 import { zigVarName } from './utility_zig'
 
 
-// Per-entity direct-call smoke tests. Emits `test "..."` blocks INTO the
-// shared generated_test.zig file (opened by Test_zig) — see TestEntity_zig for
-// why zig keeps every generated test in one file.
-//
-// The go/rust TestDirect generators build a per-entity mock-fetch harness and
-// assert the exact URL/params the entity's op point resolves. Reproducing that
-// path-extraction + mock-transport harness in zig safely requires a build to
-// validate against, so this generator instead exercises the documented
-// `direct()` / `prepare()` escape hatches through the offline test transport
-// and asserts the result shape. `std`, `sdk`, `h`, `Value` and `vnull()` are
-// in scope from the Test_zig header.
 const TestDirect = cmp(function TestDirect(props: any) {
   const { entity } = props
 

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

@@ -4,14 +4,6 @@ import { cmp, Content } from '@voxgig/sdkgen'
 import { zigVarName } from './utility_zig'
 
 
-// Per-entity model-driven smoke tests. Emits `test "..."` blocks INTO the
-// shared generated_test.zig file (opened by Test_zig) — zig's build.zig uses
-// an explicit test-file list, so every generated test must live in that one
-// file rather than a per-entity file (the go/rust one-file-per-entity layout
-// relies on cargo/go auto-discovery, which zig lacks). Each test drives the
-// entity through the full pipeline via the offline `test` transport and
-// asserts a non-error result. `std`, `sdk`, `h`, `Value` and `vnull()` are in
-// scope from the Test_zig header.
 const TestEntity = cmp(function TestEntity(props: any) {
   const { target, entity } = props
 

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

@@ -10,17 +10,6 @@ import { TestDirect } from './TestDirect_zig'
 import { ReadmeExamplesTest } from './ReadmeExamplesTest_zig'
 
 
-// Generated tests. The bulk of behavioural coverage lives in the hand-written
-// template suite (test/*.zig, copied verbatim): the struct corpus, the
-// pipeline, every feature, and the cross-language gotchas. Here we emit the
-// model-driven smoke tests.
-//
-// zig's build.zig picks up an EXPLICIT test-file list, so every generated test
-// must land in the single `test/generated_test.zig` file it already lists —
-// the per-entity generators (TestEntity, TestDirect) and the readme-examples
-// gate all emit their `test` blocks INTO this one open File rather than opening
-// their own (the go/rust one-file-per-entity split relies on auto-discovery
-// zig does not have).
 const Test = cmp(function Test(props: any) {
   const { model } = props.ctx$
   const { target } = props

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

@@ -24,36 +24,12 @@ function zigVarName(name: string): string {
 }
 
 
-// The zig module identifier, e.g. solar_sdk (informational; the build module
-// is named "sdk").
-//
-// It is also the `.name` of build.zig.zon, which zig 0.16 reads as an enum
-// literal and requires to be a BARE identifier — `.@"2fa_sdk"` is rejected as
-// firmly as `.2fa_sdk` is — so a model name starting with a digit is given a
-// leading underscore. Nothing else in the target derives an identifier from
-// this, and the alternative for such a model is a package that does not build.
 function zigModuleName(model: any): string {
   const name = `${model.name}_sdk`.toLowerCase().replace(/[^a-z0-9_]/g, '_')
   return /^[0-9]/.test(name) ? '_' + name : name
 }
 
 
-// The `.fingerprint` zig 0.14+ requires in build.zig.zon, as a 0x-prefixed
-// 16-digit hex literal.
-//
-// Zig reads the field as a packed struct of two u32s: the LOW half is a free
-// `id`, and the HIGH half is a `checksum` that must equal the CRC-32 (IEEE, as
-// zlib computes it) of the package name. Get the checksum wrong and zig
-// refuses to build, printing the value it wanted; get it right and any id in
-// [1, 0xfffffffe] is accepted.
-//
-// The id exists so a fork can be told apart from what it forked. A generated
-// SDK gets a DERIVED one — FNV-1a over the same name — rather than a random
-// one, because this file is regenerated on every run: a random id would
-// rewrite build.zig.zon each time and churn the consumer's diff, and a package
-// that changes identity between two generations of the same model is worse
-// than one that shares an id with a fork of itself. Distinct names still get
-// distinct ids.
 function zigPackageFingerprint(name: string): string {
   // CRC-32 (IEEE 802.3, reflected, poly 0xEDB88320) — the one zig's
   // std.hash.Crc32 and zlib both compute.
@@ -124,29 +100,6 @@ function formatZigValue(val: any, indent: number = 0): string {
 }
 
 
-// Deep-remove meta keys (`foo$`) from a model subtree (twin of go's clean).
-// Emission-time normalisation of a model subtree (L0).
-//
-// Always drops jostraca's iteration metadata (`$`-suffixed keys: index$,
-// key$, val$). With `dropDefaults`, also drops keys whose value IS the
-// default the runtime already assumes when the key is absent, which is pure
-// payload — see CONFIG_DEFAULT.
-//
-// Rebuilds the tree rather than mutating during a walk. The previous
-// implementation walked a clone calling `delete p[k]`, but walk() assigns its
-// callback's result back over the child (`setprop(out, ckey, walk(...))`), so
-// the delete was undone on the way out and the helper silently did nothing.
-// Returning `undefined` from the callback does not fix it either: setprop
-// stores undefined rather than removing the key, which then emits as a null.
-//
-// `dropDefaults` is opt-in and must be passed ONLY for the entity subtree.
-// `active` means something different in feature config, where absent reads as
-// INACTIVE (see feature_init) — dropping `active: true` there would silently
-// disable the feature.
-// jostraca's iteration metadata, injected by each()/names() while it walks the
-// model. Listed explicitly rather than matched by trailing-dollar suffix: a
-// trailing dollar is not exclusive to jostraca -- Seneca uses entity$ as real
-// data -- so a blanket suffix match can silently drop a legitimate API field.
 const MODEL_META = ['index$', 'key$', 'val$']
 
 // Keys whose value IS the default the runtime already assumes when the key is

package/project/.sdk/tm/c/feature/test.c

@@ -30,20 +30,36 @@ static voxgig_value* envelope(Context* ctx, voxgig_value* data) {
   if (NULL == spec) {
     return data;
   }
-  // Exactly `body.<key>`; a deeper path is not an envelope this mock can
-  // synthesise, so it is left alone rather than guessed at.
+  // Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
+  // GraphQL ops unwrap `body.data.<field>` (and `body.data.<field>.<entity>`
+  // for mutation payloads), not just a single envelope property.
   size_t n = strlen(spec);
   if (n < 8 || 0 != strncmp(spec, "`body.", 6) || '`' != spec[n - 1]) {
     return data;
   }
   size_t inner_len = n - 7;
-  if (0 == inner_len || NULL != memchr(spec + 6, '.', inner_len)) {
+  if (0 == inner_len) {
     return data;
   }
   char* inner = (char*)malloc(inner_len + 1);
   memcpy(inner, spec + 6, inner_len);
   inner[inner_len] = '\0';
-  voxgig_value* out = cmap(1, inner, data);
+  // Innermost segment first, so walk back from the end, terminating each
+  // segment in place as it is consumed. cmap copies the key.
+  voxgig_value* out = data;
+  size_t pos = inner_len;
+  while (1) {
+    size_t start = pos;
+    while (start > 0 && '.' != inner[start - 1]) {
+      start--;
+    }
+    inner[pos] = '\0';
+    out = cmap(1, inner + start, out);
+    if (0 == start) {
+      break;
+    }
+    pos = start - 1;
+  }
   free(inner);
   return out;
 }

package/project/.sdk/tm/clojure/src/sdk/features.clj

@@ -124,11 +124,13 @@
                        (let [envelope (fn [data]
                                         (let [tm (vs/getprop (core/oget fctx :point) "transform")
                                               spec (vs/getprop tm "res")]
-                                          ;; Exactly `body.<key>`; a deeper path is not an
-                                          ;; envelope this mock can synthesise.
+                                          ;; Rebuild whatever nesting the transform unwraps;
+                                          ;; GraphQL ops unwrap `body.data.<field>`.
                                           (if (and (some? data) (string? spec))
-                                            (if-let [m (re-matches #"`body\.([^`.]+)`" spec)]
-                                              (vs/jm (second m) data)
+                                            (if-let [m (re-matches #"`body\.(.+)`" spec)]
+                                              (reduce (fn [out seg] (vs/jm seg out))
+                                                      data
+                                                      (reverse (str/split (second m) #"\." -1)))
                                               data)
                                             data)))
                              respond (fn [status data extra]

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

@@ -68,16 +68,27 @@ private:
     Value restf = getp(tm, "res");
     if (!restf.is_string()) return data;
     std::string spec = restf.as_string();
-    // Exactly `body.<key>`; a deeper path is not an envelope this mock can
-    // synthesise, so it is left alone rather than guessed at.
+    // Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
+    // GraphQL ops unwrap `body.data.<field>`, not just one envelope property.
     if (spec.size() < 8) return data;
     if (0 != spec.compare(0, 6, "`body.")) return data;
     if ('`' != spec[spec.size() - 1]) return data;
     std::string inner = spec.substr(6, spec.size() - 7);
-    if (inner.empty() || std::string::npos != inner.find('.')) return data;
-    Value wrapped = vmap();
-    map_put(wrapped, inner, data);
-    return wrapped;
+    if (inner.empty()) return data;
+    std::vector<std::string> segs;
+    for (size_t at = 0;;) {
+      size_t dot = inner.find('.', at);
+      if (std::string::npos == dot) { segs.push_back(inner.substr(at)); break; }
+      segs.push_back(inner.substr(at, dot - at));
+      at = dot + 1;
+    }
+    Value out = data;
+    for (size_t i = segs.size(); i > 0; i--) {
+      Value wrapped = vmap();
+      map_put(wrapped, segs[i - 1], out);
+      out = wrapped;
+    }
+    return out;
   }
 
   Value respond(CtxPtr ctx, int status, const Value& data, const Value& extra) {

package/project/.sdk/tm/csharp/feature/FeatureOptions.cs

@@ -1,9 +1,6 @@
 // ProjectName SDK - shared option readers for the feature implementations.
-// Feature options arrive as Dictionary<string, object?> (from SDK options or
-// test harnesses), so numeric values may be int, long or double and
-// callbacks arrive as typed delegates. These helpers normalise access and
-// supply defaults, mirroring the `null == opts.x ? def : opts.x` pattern of
-// the ts features.
+// Options arrive as Dictionary<string, object?>, so a numeric value may be any
+// numeric type; `decimal` is what System.Text.Json yields through JsonElement.
 
 namespace ProjectNameSdk.Feature;
 
@@ -29,8 +26,17 @@ internal static class FeatureOptions
         {
             int n => n,
             long n => (int)n,
+            short n => n,
+            sbyte n => n,
+            uint n => (int)n,
+            ulong n => (int)n,
+            ushort n => n,
+            byte n => n,
             double n => (int)n,
             float n => (int)n,
+            // Via double: decimal->int is the one conversion C# range-checks
+            // even unchecked, and no other target throws on an oversized option.
+            decimal n => (int)(double)n,
             _ => def,
         };
     }
@@ -41,8 +47,15 @@ internal static class FeatureOptions
         {
             int n => n,
             long n => n,
+            short n => n,
+            sbyte n => n,
+            uint n => n,
+            ulong n => n,
+            ushort n => n,
+            byte n => n,
             double n => n,
             float n => n,
+            decimal n => (double)n,
             _ => def,
         };
     }