@voxgig/sdkgen 4.21.0 → 4.23.0

package/project/.sdk/src/cmp/rust/Main_rust.ts

@@ -45,8 +45,6 @@ const Main = cmp(async function Main(props: any) {
   // helpers/applicability.
   const feature = targetFeatures(model, target)
 
-  // The rust crate identifier (RUSTCRATE placeholder), e.g. solar_sdk —
-  // used in every `use <crate>::...` path in the test templates.
   const rustcrate = crateIdent(model)
 
   Package({ target })
@@ -69,23 +67,8 @@ const Main = cmp(async function Main(props: any) {
     }
   })
 
-  // utility/prepare_auth.rs is GENERATED, not templated: where the
-  // credential goes (header / query / cookie, and under what name) is a
-  // fact about the API, and tm/ can only hold one answer. See
-  // PrepareAuth_rust.
-  //
-  // AT ROOT LEVEL, and outside the `core` Folder below. The rust crate root
-  // IS the target root - lib.rs, core/, feature/ and utility/ all sit there
-  // - the component opens `utility` itself, and that is the same path
-  // `Copy({from:'tm/rust'})` used for the template it replaces. Calling it
-  // beside Config, inside `Folder({name:'core'})`, would emit
-  // core/utility/prepare_auth.rs instead: a file no module declares, so
-  // rustc never compiles it, while utility/mod.rs's `pub mod prepare_auth;`
-  // keeps binding whatever utility/ actually holds.
   PrepareAuth({ target })
 
-  // Generated core files: the client (sdk.rs), the API config and the
-  // branded error type.
   Folder({ name: 'core' }, () => {
 
     File({ name: 'sdk.' + target.ext }, () => {
@@ -98,7 +81,6 @@ const Main = cmp(async function Main(props: any) {
           }
         },
 
-        // Entity accessors - injected at SLOT
         () => {
           each(entity, (entity: ModelEntity) => {
             const entitySDK = getModelPath(model, `main.${KIT}.entity.${entity.name}`)
@@ -115,12 +97,6 @@ const Main = cmp(async function Main(props: any) {
     SdkError({ target })
   })
 
-  // feature/mod.rs — the feature module index.
-  //
-  // GENERATED, not templated: rust needs every module declared, and
-  // `target add` only copies source for the features the model selects. A
-  // static index listing all eighteen shipped features stops the crate from
-  // compiling the moment the set is trimmed.
   Folder({ name: 'feature' }, () => {
     File({ name: 'mod.' + target.ext }, () => {
       Content(`// ${model.const.Name} SDK feature modules (mirrors tm/go/feature).
@@ -134,29 +110,7 @@ pub mod base;
       each(feature, (feat: any) => Content(`pub mod ${feat.name};\n`))
     })
 
-    // feature/<name>/plugins.rs - a feature's PLUGIN module index.
-    //
-    // GENERATED, and it has no go/py analogue: rust compiles only the
-    // modules a parent DECLARES, and the declared set varies with the
-    // plugin trim, so a static index would either name a file the trim
-    // just deleted or leave an active kind out of the build.
-    //
-    // It sits one level ABOVE the vendored `plugins/` directory on
-    // purpose: the vendoring guard fails any non-vendored file inside a
-    // vendor dir. Nothing is lost by that - an .rs file no module
-    // declares is not compiled at all, so an inactive group's vendored
-    // file left on disk is inert whether or not the trim reached it.
-    //
-    // This is rust's replacement for go's core-emitted FeaturePlugins map
-    // (Config_go), and it is better placed: core/config.rs never has to
-    // name a feature's types.
     each(feature, (feat: any) => {
-      // `only_active: false`, the same subtlety pluginExcludesFor
-      // documents: the feature object a component is handed has already
-      // been filtered, so a feature whose plugins are ALL inactive would
-      // arrive with nothing here and the index would not be emitted at
-      // all - leaving `pub mod plugins;` in the feature source pointing
-      // at a file that does not exist.
       const declared = getModelPath(model,
         `main.${KIT}.feature.${feat.name}.plugin`,
         { required: false, only_active: false }) || {}
@@ -175,18 +129,11 @@ pub mod base;
         if (true !== plugin.active) return
 
         for (const [sym, one] of Object.entries(plugin.def?.rust || {})) {
-          // 'feature/secrets/plugins/aws.rs' -> the module `aws`.
           mods.add(String(one).replace(/^.*\//, '').replace(/\.rs$/, ''))
           syms.add(sym)
         }
       })
 
-      // The shared HTTP client the vendored vault kinds import
-      // (`use super::httpjson::...`) belongs to NO plugin group - trimming
-      // it with any one group would delete a file the others compile
-      // against - so it ships with the feature core and is DECLARED here
-      // only when something reaches for it. That is what keeps rustls out
-      // of a chain that is [dotenv, env] or [secretspec].
       const NOHTTP = ['secretspec']
       const http = Array.from(mods).some((m: string) => !NOHTTP.includes(m))
 
@@ -228,15 +175,10 @@ pub fn definitions() -> Vec<Definition> {
     })
   })
 
-  // entity/mod.rs — the entity module index.
   EntityBase({ target })
 
-  // entity/types.rs — the documentary typed models (one struct per entity +
-  // per op). Declared as a module by EntityBase so it compiles with the crate.
   EntityTypes({ target })
 
-  // lib.rs — the crate root: module declarations plus the public API
-  // re-exports (twin of the go root package file).
   File({ name: 'lib.' + target.ext }, () => {
     Content(`// ${model.const.Name} SDK for Rust (generated by @voxgig/sdkgen).
 //

package/project/.sdk/src/cmp/rust/Package_rust.ts

@@ -17,12 +17,6 @@ import type {
 import { crateIdent, crateName } from './utility_rust'
 
 
-// Cargo.toml (the rust manifest). Dependencies come from the target model
-// (`deps` block, kind prod|dev) plus any feature-declared rust deps, via
-// the shared collectDeps helper. The vendored voxgig struct port needs no
-// external crate. The lib path is the crate root `lib.rs` (the generated
-// SDK mirrors the go layout: core/, feature/, utility/, entity/ at the
-// repo root rather than under src/).
 const Package = cmp(async function Package(props: any) {
   const ctx$ = props.ctx$
   const target = props.target
@@ -74,21 +68,6 @@ path = "lib.rs"
       }
     }
 
-    // [[test]] stanzas for the feature suites.
-    //
-    // cargo auto-discovers `tests/*.rs` and `tests/<dir>/main.rs`, but NOT
-    // `tests/<dir>/<dir>/main.rs` - and the two-level path is not
-    // negotiable: a feature's tests must live inside a `feature/`
-    // container so `target add` trims them WITH the feature
-    // (helpers/featureSource), exactly as go's tm/go/test/feature/secrets/
-    // and py's tm/py/test/feature/secrets/ do. A one-level
-    // tests/secrets/main.rs would auto-discover and then be left behind in
-    // a project that does not select the feature, carrying a suite that
-    // cannot compile.
-    //
-    // So the suite is DECLARED, and only for a feature that both applies
-    // to this target and is active in the model - which is also exactly
-    // when `target add` kept its directory.
     const suites = Object.keys(targetFeatures(model, target))
       .filter((name: string) => null != FEATURE_TESTS[name])
       .sort()
@@ -113,15 +92,6 @@ const FEATURE_TESTS: Record<string, string> = {
 }
 
 
-// One Cargo dependency's value: the bare version string, or the TABLE form
-// when the model asks for anything more.
-//
-// `default: false` and `features: [...]` are not decoration. The secrets
-// feature's vendored HTTP helper speaks rustls, and `rustls = "0.23"` with
-// DEFAULT features pulls aws-lc-rs/aws-lc-sys and a cmake C build, while
-// the ring feature set is what the target's existing `ureq` dep already
-// compiles. Without the table form, turning on one feature would add a
-// native toolchain requirement to every SDK that selected it.
 function depValue(version: string, raw: any): string {
   const features: string[] = Array.isArray(raw?.features) ? raw.features : []
   const nodefault = false === raw?.default

package/project/.sdk/src/cmp/rust/PrepareAuth_rust.ts

@@ -12,26 +12,6 @@ import {
 } from '@voxgig/sdkgen'
 
 
-// WHERE THE CREDENTIAL GOES IS A FACT ABOUT THE API, so it is generated
-// rather than templated. This is the rust peer of PrepareAuth_ts; read that
-// one first, it carries the full account of the defect.
-//
-// This was a static file at `tm/rust/utility/prepare_auth.rs` that hardcoded
-//
-//   const HEADER_AUTH: &str = "authorization";
-//
-// apidef has always resolved the scheme's `in` and `name` into
-// `main.kit.info.security` — joplin's says `in: "query", name: "token"` —
-// and generation dropped both, so the SDK sent a header the API does not
-// read and never sent the query parameter it does.
-//
-// A template cannot fix this, 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 — no dead query code in a
-// bearer-token SDK, and no runtime `if` on a value that is fixed at
-// generation time. Rust makes that worth doing carefully: an import the
-// emitted body never reaches is a warning on every build of the crate, so
-// the `use` lines are chosen per placement too.
 const PrepareAuth = cmp(async function PrepareAuth(props: any) {
   const { target } = props
   const { model } = props.ctx$
@@ -42,41 +22,12 @@ const PrepareAuth = cmp(async function PrepareAuth(props: any) {
   // the way Main_rust spells it in lib.rs's re-exports.
   const errtype = model.const.Name + 'Error'
 
-  // `!isAuthSuppressed`, NOT `isAuthActive`. The latter is also false when
-  // the SPEC merely declares no security scheme (`main.kit.info.auth:
-  // false`), and those SDKs still carry a credential: optspec always
-  // declares `apikey` and makeOptions fills `options.auth` from its
-  // defaults, so the runtime guard never fired and they have always sent
-  // it. Only an explicit `main.kit.config.auth.active: false` means "no
-  // credential, ever", which is what isAuthSuppressed reads.
   const active = !isAuthSuppressed(model)
   const where = resolveAuthIn(model)
   const name = resolveAuthName(model)
-  // Resolved, and deliberately NOT baked into the source: the prefix is a
-  // runtime option (`options.auth.prefix`), and the template this replaces
-  // read it from the options map so a caller could override it per client.
-  // Only the PLACEMENT is fixed at generation time.
   const prefix = resolveAuthPrefix(model)
   const basic = isHttpBasicAuth(model)
 
-  // FOLDER NESTING. Main_rust opens NO folder around this call: the rust
-  // crate root IS the target root (lib.rs, core/, feature/, utility/ all sit
-  // there — see the `[lib] path` in tm/rust/Cargo.toml), the template this
-  // replaces lived at `tm/rust/utility/prepare_auth.rs`, and
-  // `Copy({from:'tm/rust'})` lands it at `<root>/utility/`. So the `utility`
-  // folder is opened HERE, exactly as EntityBase_rust opens `entity`.
-  //
-  // The call site matters as much. Config_rust runs inside
-  // `Folder({name:'core'})`, and putting PrepareAuth beside it would write
-  // `core/utility/prepare_auth.rs` — a path no module declares, so rustc
-  // never compiles it, while `utility/mod.rs`'s `pub mod prepare_auth;`
-  // keeps binding whatever `utility/` actually holds. Main_rust calls this
-  // at ROOT level.
-  //
-  // The file NAME is not free either: `utility/mod.rs` declares the module
-  // `prepare_auth`, and `make_spec` calls
-  // `crate::utility::prepare_auth::prepare_auth_util`. The generated file
-  // has to answer to that name.
   Folder({ name: 'utility' }, () => {
     File({ name: 'prepare_auth.' + target.ext }, () => {
       Content(render({ errtype, active, where, name, prefix, basic }))
@@ -97,10 +48,6 @@ type AuthSpec = {
 
 function render(spec: AuthSpec): string {
 
-  // NO AUTH AT ALL. A public API's SDK gets a prepare_auth that is honest
-  // about it rather than one that deletes a header nobody set. `vs`, `Value`
-  // and the helpers are left out of the imports deliberately — rustc warns
-  // on an unused import, on every build, forever.
   if (!spec.active) {
     return `// prepare_auth utility.
 //
@@ -134,9 +81,6 @@ pub fn prepare_auth_util(ctx: &Rc<Context>) -> Result<Rc<RefCell<Spec>>, ${spec.
   // where it can mean something.
   const withBasic = spec.basic && 'header' === spec.where
 
-  // `getpath` reads `options.auth.prefix`, and only a header placement has a
-  // prefix to read: a query parameter drops it, and a cookie pair has no
-  // room for one.
   const withGetpath = 'header' === spec.where
 
   const bag = bagName(spec.where)
@@ -248,8 +192,6 @@ ${place(spec.where)}
 }
 `
 
-  // The encoder goes AFTER prepare_auth_util, so the function a reader opens
-  // this file for is the first one they meet.
   const encoder = !withBasic ? '' : `
 /// Standard base64, for the \`Authorization: Basic base64(user:pass)\` value.
 ///
@@ -294,19 +236,6 @@ fn base64_encode(input: &[u8]) -> String {
 }
 
 
-// The credential's key, as it goes into the bag.
-//
-// A HEADER name is lowercased. HTTP header names are case-insensitive
-// (RFC 9110 5.1) and the fetcher writes them out as given, so nothing
-// changes on the wire — but this SDK's own header map is keyed in lowercase
-// throughout (`content-type`, and the `authorization` that tm/rust/tests/
-// pipeline_test.rs asserts on), and the shipped `prepare_auth.rs` said
-// `"authorization"`. Emitting the resolver's title-cased default here would
-// have left every header SDK's own test suite failing on a purely cosmetic
-// difference.
-//
-// A QUERY parameter and a COOKIE name are case-SENSITIVE, so those go in
-// verbatim: `?token=` is not `?Token=`.
 function credLiteral(where: string, name: string): string {
   return 'header' === where ? String(name).toLowerCase() : String(name)
 }
@@ -323,29 +252,18 @@ function credComment(where: string): string {
 }
 
 
-// The bag the credential lands in, per placement — and, in rust, the `Spec`
-// field it is read from, which is spelled the same. Cookies ride the header
-// bag because a cookie IS a header.
 function bagName(where: string): string {
   return 'query' === where ? 'query' : 'headers'
 }
 
 
 function clear(where: string): string {
-  // COOKIE clears the header named for the credential, NOT the cookie
-  // header: the cookie header may carry pairs this SDK never set, and
-  // deleting it to remove one pair would drop them all. Removing a header
-  // that placement never writes is a no-op, which is the honest outcome
-  // when there is no credential to place.
   return `vs::del_prop(${bagName(where)}, &Value::str(CRED_NAME))`
 }
 
 
 function place(where: string): string {
   if ('query' === where) {
-    // NO PREFIX IN A QUERY STRING. `?token=Bearer%20abc` is not a thing any
-    // API reads; the prefix is a header convention and is dropped here
-    // deliberately rather than silently concatenated.
     return `        let apikey_val = match &apikey {
             Value::Str(s) => s.clone(),
             _ => String::new(),
@@ -355,8 +273,6 @@ function place(where: string): string {
   }
 
   if ('cookie' === where) {
-    // Append, never replace: the cookie header may already carry pairs this
-    // SDK did not set, and clobbering it would drop them.
     return `        let apikey_val = match &apikey {
             Value::Str(s) => s.clone(),
             _ => String::new(),

package/project/.sdk/src/cmp/rust/ReadmeEntity_rust.ts

@@ -53,7 +53,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 = rustVarName(entity.name)
     const method = rustMethodName(entity.name)
@@ -99,8 +99,8 @@ const ReadmeEntity = cmp(function ReadmeEntity(props: any) {
 `)
 
       each(fields, (field: any) => {
-        const desc = field.short || ''
-        Content(`| \`${field.name}\` | \`${canonToType(field.type, target.name)}\` | ${desc} |
+        const desc = field.sh || ''
+        Content(`| \`${field.n}\` | \`${canonToType(field.t, target.name)}\` | ${desc} |
 `)
       })
 

package/project/.sdk/src/cmp/rust/ReadmeExamplesTest_rust.ts

@@ -1,22 +1,6 @@
 import { cmp, Content, File } from '@voxgig/sdkgen'
 
 
-// Emits rust/tests/readme_examples_test.rs — a structural gate over every
-// ```rust fenced block in the three docs that ship rust examples:
-//   - the root README.md (top-level, multi-language quick start)
-//   - the per-language rust/README.md
-//   - the per-language rust/REFERENCE.md
-//
-// DESIGN NOTE vs the go gate (ReadmeExamplesTest_go.ts): the go version shells
-// out to `go build`/`go run` to COMPILE and RUN every block. A faithful rust
-// port would shell out to `cargo`/`rustc` against extracted snippets — a large,
-// environment-sensitive harness that cannot be authored safely without a build
-// to validate it. This rust gate instead validates that every documented rust
-// block is PRESENT and STRUCTURALLY well-formed (balanced delimiters,
-// non-empty). It is a real, always-passing test that keeps the docs honest
-// about block structure; upgrading it to a true compile gate (a temp crate that
-// `cargo build`s each block against the generated SDK) is left as a follow-up.
-// Missing docs are tolerated (a run may generate a subset of phases).
 const ReadmeExamplesTest = cmp(function ReadmeExamplesTest(props: any) {
   const { ctx$: { model } } = props
 

package/project/.sdk/src/cmp/rust/ReadmeModel_rust.ts

@@ -119,13 +119,13 @@ On error, \`ok\` is \`false\` and \`err\` carries the error value.
 
 `)
   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}
 
@@ -133,7 +133,7 @@ On error, \`ok\` is \`false\` and \`err\` carries the error value.
 | --- | --- |
 `)
     each(fields, (field: any) => {
-      Content(`| \`${field.name}\` | ${field.short || ''} |
+      Content(`| \`${field.n}\` | ${field.sh || ''} |
 `)
     })
 

package/project/.sdk/src/cmp/rust/ReadmeRef_rust.ts

@@ -1,5 +1,5 @@
 
-import { cmp, each, Content, canonToType, canonKey, canonScalarKey, File, isAuthActive, entityIdField, opRequestShape } from '@voxgig/sdkgen'
+import { cmp, each, Content, canonToType, canonKey, canonScalarKey, File, isAuthActive, entityIdField, opRequestShape , targetFeatures } from '@voxgig/sdkgen'
 import { ReadmeRefFeatures } from '@voxgig/sdkgen'
 
 import {
@@ -29,7 +29,7 @@ const ReadmeRef = cmp(function ReadmeRef(props: any) {
 
   const rustcrate = crateIdent(model)
   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)
 
@@ -166,7 +166,7 @@ Prepare a fetch definition without sending. Returns the fetchdef on \`Ok\`.
     // 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 = rustVarName(ent.name)
       const method = rustMethodName(ent.name)
@@ -199,9 +199,9 @@ let ${eVar} = client.${method}(Value::Noval);
 | --- | --- | --- | --- |
 `)
         each(fields, (field: any) => {
-          const req = field.req ? 'Yes' : 'No'
-          const desc = field.short || ''
-          Content(`| \`${field.name}\` | \`${canonToType(field.type, target.name)}\` | ${req} | ${desc} |
+          const req = field.r ? 'Yes' : 'No'
+          const desc = field.sh || ''
+          Content(`| \`${field.n}\` | \`${canonToType(field.t, target.name)}\` | ${req} | ${desc} |
 `)
         })
 
@@ -226,7 +226,7 @@ let ${eVar} = client.${method}(Value::Noval);
               if (fop.active === false) return '-'
               return 'Yes'
             })
-            Content(`| \`${field.name}\` | ${cols.join(' | ')} |
+            Content(`| \`${field.n}\` | ${cols.join(' | ')} |
 `)
           })
 
@@ -374,9 +374,6 @@ let client = ${model.const.Name}SDK::new(jo(vec![
 \`\`\`
 
 `)
-      // 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/rust/Schema_rust.ts

@@ -17,24 +17,6 @@ import {
 } from './utility_rust'
 
 
-// THE GENERATED SCHEMA MODULE: the model's schemas, as data the SDK can run.
-//
-// The rust 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 rust 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 rust's.
-// A raw string, exactly as config.rs carries its data rep above the size
-// threshold; the spec has no threshold because it is bounded by the option
-// list and the feature set rather than by the API.
-//
-// No number-type question here, unlike Go: `Value::Num` is f64 whichever way
-// it is built. The spec holds only strings and booleans anyway, 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 +33,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.
 
 use crate::utility::jsonparse::json_parse;

package/project/.sdk/src/cmp/rust/TestDirect_rust.ts

@@ -33,10 +33,10 @@ function normalizePathParams(
       const snaked = snakify(rawName)
       const depluralized = depluralize(snaked)
       const param = params.find((p: any) =>
-          p.name === snaked || p.name === depluralized) ||
+          p.n === snaked || p.n === depluralized) ||
         params.find((p: any) =>
-          p.orig === snaked || p.orig === depluralized)
-      if (param) return '{' + param.name + '}'
+          p.or === snaked || p.or === depluralized)
+      if (param) return '{' + param.n + '}'
 
       if (rename) {
         for (const [origCamel, renamedTo] of Object.entries(rename)) {
@@ -44,10 +44,10 @@ function normalizePathParams(
             const origSnaked = snakify(origCamel)
             const origDepluralized = depluralize(origSnaked)
             const renamedParam = params.find(
-              (p: any) => p.orig === origSnaked || p.name === origSnaked ||
-                p.orig === origDepluralized || p.name === origDepluralized
+              (p: any) => p.or === origSnaked || p.n === origSnaked ||
+                p.or === origDepluralized || p.n === origDepluralized
             )
-            if (renamedParam) return '{' + renamedParam.name + '}'
+            if (renamedParam) return '{' + renamedParam.n + '}'
           }
         }
       }
@@ -76,13 +76,6 @@ const TestDirect = cmp(function TestDirect(props: any) {
     ? `("apikey", getp(&env, "${PROJECTNAME}_APIKEY"))`
     : ''
 
-  // A templated server URL (OpenAPI server variables) makes a LIVE client
-  // impossible to construct without values: makeOptions raises rather than
-  // request a URL with a literal `{account_id}` in it. So the live suite
-  // takes them from the environment the same way it takes the apikey.
-  //
-  // Emitted as a jo() tuple entry, so it carries its own leading comma only
-  // when an apikey entry precedes it - otherwise `jo(vec![, ...])`.
   const svars = serverVariables(model)
   const serverEnvEntry = svars
     .map((v: any) => `\n        ("${serverVarEnv(PROJECTNAME, v.name)}", Value::str(${JSON.stringify(v.dflt)})),`).join('')
@@ -105,8 +98,8 @@ const TestDirect = cmp(function TestDirect(props: any) {
 
   // Load point info.
   const loadPoint = loadOp?.points?.[0]
-  const loadPath = loadPoint ? normalizePathParams(pointParts(loadPoint), loadPoint?.args?.params || [], loadPoint?.rename?.param) : ''
-  const allLoadParams = loadPoint?.args?.params || []
+  const loadPath = loadPoint ? normalizePathParams(pointParts(loadPoint), loadPoint?.g?.params || [], loadPoint?.r?.param) : ''
+  const allLoadParams = loadPoint?.g?.params || []
   // Only path params that actually appear in the URL template drive the
   // direct-test path-param setup and URL-substitution asserts.
   const _pathPlaceholders = new Set<string>()
@@ -115,7 +108,7 @@ const TestDirect = cmp(function TestDirect(props: any) {
       _pathPlaceholders.add(part.slice(1, -1))
     }
   }
-  const _renameMap = (loadPoint?.rename?.param || {}) as Record<string, string>
+  const _renameMap = (loadPoint?.r?.param || {}) as Record<string, string>
   const _renamedPlaceholders = new Set<string>()
   for (const ph of _pathPlaceholders) {
     _renamedPlaceholders.add(ph)
@@ -124,12 +117,12 @@ const TestDirect = cmp(function TestDirect(props: any) {
     }
   }
   const loadParams = allLoadParams.filter((p: any) =>
-    _renamedPlaceholders.has(p.name) || _renamedPlaceholders.has(p.orig))
+    _renamedPlaceholders.has(p.n) || _renamedPlaceholders.has(p.or))
 
   // List point info.
   const listPoint = listOp?.points?.[0]
-  const listPath = listPoint ? normalizePathParams(pointParts(listPoint), listPoint?.args?.params || [], listPoint?.rename?.param) : ''
-  const listParams = listPoint?.args?.params || []
+  const listPath = listPoint ? normalizePathParams(pointParts(listPoint), listPoint?.g?.params || [], listPoint?.r?.param) : ''
+  const listParams = listPoint?.g?.params || []
 
   const entidEnvVar = `${PROJECTNAME}_TEST_${envToken(entity.name)}_ENTID`
 
@@ -231,10 +224,10 @@ fn ${evar}_direct_setup(mockres: Value) -> ${entity.Name}DirectSetup {
     if (hasList && listPoint) {
       // Live params: idmap keys per param.
       const listLiveParams = listParams.map((p: any) => {
-        const key = p.name === 'id'
+        const key = p.n === 'id'
           ? entity.name + '01'
-          : p.name.replace(/_id$/, '') + '01'
-        return { name: p.name, key }
+          : p.n.replace(/_id$/, '') + '01'
+        return { name: p.n, key }
       })
 
       Content(`
@@ -352,10 +345,10 @@ fn ${evar}_direct_list() {
     if (hasLoad && loadPoint) {
       // idmap keys consumed by load in live mode.
       const loadLiveParams = loadParams.map((p: any) => {
-        const key = p.name === 'id'
+        const key = p.n === 'id'
           ? entity.name + '01'
-          : p.name.replace(/_id$/, '') + '01'
-        return { name: p.name, key }
+          : p.n.replace(/_id$/, '') + '01'
+        return { name: p.n, key }
       })
 
       Content(`