@voxgig/sdkgen 4.21.0 → 4.23.0

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

@@ -10,11 +10,6 @@ import {
 import { exampleValue } from './utility_ts'
 
 
-// A `list()` on a NESTED entity needs its parent path params. The
-// quickstart used to emit `client.Moon().list()` for an entity at
-// `/planet/{planet_id}/moon`, which 404s against a live server from a
-// half-built URL — indistinguishable from "no such record". The model
-// already marks those params `reqd: true`; matchArg renders exactly them.
 function listMatchArg(ent: any): string {
   const idF = entityIdField(ent)
   return matchArg('ts', ent, 'list', idF, idLiteral(ent, 'list', idF))
@@ -26,12 +21,8 @@ const ReadmeQuick = cmp(function ReadmeQuick(props: any) {
 
   const entity = getModelPath(model, `main.${KIT}.entity`)
 
-  // Find the first published entity for examples
   const exampleEntity = Object.values(entity).find((e: any) => e.active !== false) as any
 
-  // Find a nested entity if available: one with a parent chain
-  // (relations.ancestors), an active load op, and a required non-id load
-  // param to demonstrate (the parent key, e.g. page_id).
   const nestedEntity = Object.values(entity).find((e: any) =>
     e.active !== false &&
     e.relations && e.relations.ancestors && 0 < e.relations.ancestors.length &&
@@ -71,13 +62,9 @@ const client = ${ctor}
 
   if (exampleEntity) {
     const eName = nom(exampleEntity, 'Name')
-    // Variable-safe lowercase name — a `Delete`/`Class` entity must not bind a
-    // reserved word (`const delete = ...` is a TS1109 syntax error).
     const eVar = exampleVarName(eName.toLowerCase(), 'ts')
     const article = /^[aeiou]/i.test(eName) ? 'an' : 'a'
     const opnames = entityOps(exampleEntity)
-    // Model-driven id key: `idF` is the entity's id-like MATCH field name, or
-    // null when it has none (then load/remove match on no argument).
     const idF = entityIdField(exampleEntity)
     // The id field on the RETURNED record's data type, or null. DISTINCT from
     // idF (the match key): an entity can key its load-match on an id it does not
@@ -109,9 +96,6 @@ for (const ${eVar} of ${eVar}s) {
       const neArticle = /^[aeiou]/i.test(neName) ? 'an' : 'a'
       const loadOp = nestedEntity.op && nestedEntity.op.load
 
-      // Model-driven match: every REQUIRED load-match key — the same shape
-      // that generates <Name>LoadMatch, so the example always type-checks.
-      // Parent keys (e.g. page_id) first, the entity's own id last.
       const neIdF = entityIdField(nestedEntity)
       const neRequired = opRequestShape(nestedEntity, 'load').items
         .filter((it: any) => !it.optional)
@@ -143,8 +127,6 @@ ${neMatchLines.join('\n')}
 `)
     }
     else if (opnames.includes('load')) {
-      // Every REQUIRED load-match key (id first) — the same shape that
-      // generates <Name>LoadMatch, so the example always type-checks.
       const loadRequired = opRequestShape(exampleEntity, 'load').items
         .filter((it: any) => !it.optional || it.name === idF)
         .sort((a: any, b: any) =>
@@ -177,21 +159,12 @@ try {
     // non-id fields and render a type-correct literal per field via
     // exampleValue — never a hardcoded field the entity may not have.
     if (opnames.includes('create') || opnames.includes('update') || opnames.includes('remove')) {
-      // Writable non-id example fields for an op body. For create the REQUIRED
-      // fields must all appear or the literal is not assignable to the typed
-      // <Name>CreateData (a TS2345); update is a patch, so a couple of fields
-      // suffice.
       const exampleFields = (opname: string): string[] => {
-        // ids are rendered separately as the match key for update/remove; a
-        // REQUIRED id stays (dropping it makes the literal unassignable).
         const items = opRequestShape(exampleEntity, opname).items
           .filter((it: any) => (it.name !== idF && it.name !== 'id') ||
             ('create' === opname && !it.optional))
         const required = items.filter((it: any) => !it.optional)
         const optional = items.filter((it: any) => it.optional)
-        // Required members must all appear or the literal is not assignable
-        // to the typed <Name>{Create,Update}Data; pad update (a patch) with a
-        // sample optional field or two.
         const chosen = 'create' === opname
           ? (required.length ? required : items.slice(0, 2))
           : required.concat(optional).slice(0, Math.max(2, required.length))
@@ -199,20 +172,10 @@ try {
           `  ${jsKey(it.name)}: ${exampleValue(exampleEntity, exampleEntity.op[opname], it.name, 'example_' + it.name)},`)
       }
 
-      // The id VALUE for an update/remove match. When the entity's DATA type
-      // carries the id (dataIdF) AND a `created` record exists, take it off the
-      // returned record; otherwise use a type-correct literal — reading
-      // `created.id` off an id-less data type is a TS2339.
-      // Type of the data field we would read off `created` (e.g. number for an
-      // integer id). null when unknown.
       const dataFields: any[] = exampleEntity.fields ? each(exampleEntity.fields) : []
       const dataIdType = dataIdF
-        ? (dataFields.find((f: any) => f && f.name === dataIdF) || {}).type
+        ? (dataFields.find((f: any) => f && f.n === dataIdF) || {}).type
         : null
-      // `created.<dataIdF>` is only usable as an op's id-match value when its
-      // type matches that op's id PARAM type. An id that is integer in the data
-      // type but string in the match path (a spec quirk seen on management
-      // APIs) would be a TS2322 otherwise — fall back to a type-correct literal.
       const usesCreatedId = (opname: string): boolean => {
         if (null == dataIdF || !opnames.includes('create')) {
           return false
@@ -222,8 +185,6 @@ try {
         const matchType = matchItem ? matchItem.type : null
         return null == matchType || null == dataIdType || matchType === dataIdType
       }
-      // `create` resolves to the ENTITY, so the id is reached through
-      // `.data()` — `created.id` is a TS2339 on the entity class.
       const idValueFor = (opname: string): string => usesCreatedId(opname)
         ? `created.data().${dataIdF}!`
         : exampleValue(exampleEntity, exampleEntity.op[opname], idF as string, 'example_id')
@@ -241,8 +202,6 @@ const created = await client.${eName}().create({${createBody}})
 `)
       }
       if (opnames.includes('update')) {
-        // Match on the id (from the returned `created` record when the data
-        // type carries one, else a literal), plus a couple of patch fields.
         const updateLines = (idF ? [`  ${idF}: ${idValueFor('update')},`] : []).concat(exampleFields('update'))
         const updateBody = updateLines.length ? '\n' + updateLines.join('\n') + '\n' : ''
         Content(`// Update${usesCreatedId('update') ? ' — the id comes off the returned entity\'s data()' : ''}
@@ -251,8 +210,6 @@ const updated = await client.${eName}().update({${updateBody}})
 `)
       }
       if (opnames.includes('remove')) {
-        // Every REQUIRED remove-match key: the id (off the created record
-        // when possible) plus parent keys like page_id.
         const removeLines = opRequestShape(exampleEntity, 'remove').items
           .filter((it: any) => !it.optional || it.name === idF)
           .sort((a: any, b: any) =>

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

@@ -1,5 +1,5 @@
 
-import { cmp, each, Content, canonToType, File, isAuthActive, isHttpBasicAuth, entityIdField, entityActions, opRequestShape, safeVarName, exampleVarName, jsKey, matchArg, idLiteral } from '@voxgig/sdkgen'
+import { cmp, each, Content, canonToType, File, isAuthActive, isHttpBasicAuth, entityIdField, entityActions, opRequestShape, safeVarName, exampleVarName, jsKey, matchArg, idLiteral, targetFeatures } from '@voxgig/sdkgen'
 import { ReadmeRefFeatures } from '@voxgig/sdkgen'
 
 import {
@@ -10,11 +10,6 @@ import {
 import { exampleValue } from './utility_ts'
 
 
-// A `list()` on a NESTED entity needs its parent path params. The
-// quickstart used to emit `client.Moon().list()` for an entity at
-// `/planet/{planet_id}/moon`, which 404s against a live server from a
-// half-built URL — indistinguishable from "no such record". The model
-// already marks those params `reqd: true`; matchArg renders exactly them.
 function listMatchArg(ent: any): string {
   const idF = entityIdField(ent)
   return matchArg('ts', ent, 'list', idF, idLiteral(ent, 'list', idF))
@@ -55,7 +50,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)
 
@@ -192,11 +187,10 @@ Alias for \`${model.Name}SDK.test()\`.
     // Entity reference sections
     publishedEntities.map((ent: any) => {
       const opnames = Object.keys(ent.op || {})
-      const fields = ent.fields || []
+      const fields = Object.values(ent.fields || {})
       // Model-driven id key: null when this entity has no id-like field, in
       // which case load/remove match on no argument and update omits the id.
       const idF = entityIdField(ent)
-      // Variable-safe lowercase name (a `Delete` entity must not bind `delete`).
       const eVar = exampleVarName(ent.name, target.name)
 
       Content(`
@@ -227,9 +221,9 @@ const ${eVar} = client.${ent.Name}()
 | --- | --- | --- | --- |
 `)
         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} |
 `)
         })
 
@@ -256,7 +250,7 @@ const ${eVar} = client.${ent.Name}()
               if (fop.active === false) return '-'
               return 'Yes'
             })
-            Content(`| \`${field.name}\` | ${cols.join(' | ')} |
+            Content(`| \`${field.n}\` | ${cols.join(' | ')} |
 `)
           })
 
@@ -266,15 +260,6 @@ const ${eVar} = client.${ent.Name}()
       }
 
 
-      // Custom actions.
-      //
-      // A POST route like `/api/planet/{id}/terraform` is folded into the
-      // `create` op as an alternative point, selected at call time by
-      // `$action`. The mechanism was implemented and documented NOWHERE — so
-      // for an API with two such routes, two of its six endpoints were
-      // unreachable by anyone reading the docs. A user who wanted `terraform`
-      // had to fall back to `direct()` and rebuild the URL by hand, which is
-      // exactly what the entity model exists to spare them.
       const actions = entityActions(ent)
       if (0 < actions.length) {
         Content(`### Actions
@@ -455,9 +440,6 @@ const client = new ${model.Name}SDK({
 \`\`\`
 
 `)
-      // 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/ts/ReadmeTopQuick_ts.ts

@@ -10,11 +10,6 @@ import {
 import { exampleValue } from './utility_ts'
 
 
-// A `list()` on a NESTED entity needs its parent path params. The
-// quickstart used to emit `client.Moon().list()` for an entity at
-// `/planet/{planet_id}/moon`, which 404s against a live server from a
-// half-built URL — indistinguishable from "no such record". The model
-// already marks those params `reqd: true`; matchArg renders exactly them.
 function listMatchArg(ent: any): string {
   const idF = entityIdField(ent)
   return matchArg('ts', ent, 'list', idF, idLiteral(ent, 'list', idF))
@@ -87,9 +82,6 @@ for (const ${eVar} of ${eVar}s) {
       const neVar = exampleVarName(neName.toLowerCase(), 'ts')
       const loadOp = nestedEntity.op && nestedEntity.op.load
 
-      // Every REQUIRED load-match key (parent keys first, own id last) — the
-      // same shape that generates <Name>LoadMatch, so the example
-      // type-checks.
       const neIdF = entityIdField(nestedEntity)
       const neMatchLines = opRequestShape(nestedEntity, 'load').items
         .filter((it: any) => !it.optional || it.name === neIdF)
@@ -109,9 +101,6 @@ console.log(${neVar})
       hasCall = true
     }
 
-    // Fallback: APIs with only `load` (no list, no nested) — most public
-    // read-only services. Still show one concrete call. `load()` with no
-    // match is always valid (the match arg is optional).
     if (!hasCall && opnames.includes('load')) {
       Content(`// Load ${eName.toLowerCase()} data (returns a ${eName})
 const ${eVar} = await client.${eName}().load()

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

@@ -18,13 +18,6 @@ const ReadmeTopTest = cmp(function ReadmeTopTest(props: any) {
   // `load` on an op-less entity like Cloudsmith's `Abort`.
   const { entity: exampleEntity, primaryOp } = pickExampleEntity(entity)
 
-  // The mock SEEDS NOTHING on its own.
-  //
-  // `SDK.test()` with no argument used to be shown alongside "populated with
-  // mock data" — and returned an empty array. The seed shape
-  // (`{ entity: { <name>: { <id>: {...} } } }`) was documented nowhere; the
-  // only way to find it was to read TestFeature.ts. Offline test mode is a
-  // headline feature of these SDKs, so its one worked example has to run.
   const seedEntity = exampleEntity ? nom(exampleEntity, 'name') : ''
   const seedFields = exampleEntity ?
     opRequestShape(exampleEntity, 'create').items
@@ -74,12 +67,16 @@ const client = ${model.const.Name}SDK.test({
             it.name === idF ? 'test01' : 'example_' + it.name)}`).join(', ')} }`
         : ''
     } else if ('create' === primaryOp || 'update' === primaryOp) {
+      const isIdField = (it: any) => it.name === idF || it.name === 'id'
       const items = opRequestShape(exampleEntity, primaryOp).items
-        .filter((it: any) => it.name !== idF && it.name !== 'id')
+        .filter((it: any) => !isIdField(it) || !it.optional)
       const required = items.filter((it: any) => !it.optional)
       const chosen = required.length ? required : items.slice(0, 3)
       arg = `{ ${chosen.map((it: any) =>
-        `${jsKey(it.name)}: ${exampleValue(exampleEntity, primaryOpDef, it.name, 'example_' + it.name)}`).join(', ')} }`
+        // A required id matches the record seeded into the mock above, so the
+        // example reads as one coherent story rather than two.
+        `${jsKey(it.name)}: ${exampleValue(exampleEntity, primaryOpDef, it.name,
+          isIdField(it) ? seedId : 'example_' + it.name)}`).join(', ')} }`
     }
     Content(`const ${eVar} = await client.${eName}().${primaryOp}(${arg})
 // ${eVar} is ${'list' === primaryOp ? `an array of ${eName} entities` : `the ${eName} entity`}, populated with mock data

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

@@ -12,27 +12,6 @@ import {
 } from '@voxgig/apidef'
 
 
-// THE GENERATED SCHEMA MODULE: the model's schemas, as data the SDK can run.
-//
-// Two exports, both struct.validate specs:
-//
-//   OPTSPEC     what makeOptions validates the caller's options against —
-//               the standard options from `main.kit.optspec` plus one entry
-//               per feature this target carries, built by helpers/optspec.
-//
-//   ENTITYSPEC  per entity, `{ data, op: { <opname> } }` — the record shape
-//               and each operation's request shape, mapped from the field
-//               type sentinels the model already carries (helpers/canonSpec).
-//               Emitted as an EMPTY MAP unless the `validate` feature is
-//               active, because nothing else reads it and every byte here is
-//               a byte in the consumer's package.
-//
-// A JSON OBJECT LITERAL, not a parsed string: JSON is a subset of the
-// language's own literal syntax, so the values land as data with no parse
-// step, and the backticks the sentinels carry (`\`$STRING\``) survive because
-// JSON.stringify quotes and escapes them. The config emitter has to choose
-// between a literal and a parsed blob because the config can be megabytes;
-// the spec is bounded by the model's field count, so it does not.
 const Schema = cmp(async function Schema(props: any) {
   const ctx$ = props.ctx$
   const target = props.target
@@ -46,7 +25,7 @@ const Schema = cmp(async function Schema(props: any) {
     Content(`// ${model.const.Name} ${target.Name} SDK: generated schemas. Do not edit.
 //
 // Generated from the model: \`main.kit.optspec\` and each feature's
-// \`config.options\` for OPTSPEC; entity \`fields[].type\` for ENTITYSPEC.
+// \`config.options\` for OPTSPEC; entity \`fields{}.type\` for ENTITYSPEC.
 
 const OPTSPEC = ${JSON.stringify(optspec, null, 2)}
 

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

@@ -24,6 +24,7 @@ import {
   jsOptProp, envName, envToken, liveStrict,
   jsKey,
   pointParts,
+  hasLiveScenarios,
 } from '@voxgig/sdkgen'
 
 
@@ -42,7 +43,6 @@ const TestDirect = cmp(function TestDirect(props: any) {
 
   const ff = projectPath('src/cmp/ts/fragment/')
 
-  // Does a live run ASSERT, or merely observe? See helpers/testPolicy.
   const strict = liveStrict(model, target.name)
 
   const PROJECTNAME = envName(model)
@@ -59,16 +59,6 @@ const TestDirect = cmp(function TestDirect(props: any) {
       secret: env.${PROJECTNAME}_SECRET,` : ''}`
     : ''
 
-  // 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. Taken from the
-  // environment, the same way the apikey is.
-  //
-  // Keys are quoted and the env read is bracketed via jsKey/jsProp: a server
-  // variable name is spec-derived and need not be a JS identifier — the URL
-  // grammar admits a leading digit ({2fa}), and a declared-but-unreferenced
-  // variable ({edge-zone}) is not constrained at all. Bare `name:` and
-  // `env.PROJ_SERVER_EDGE-ZONE` are both syntax errors.
   const svars = serverVariables(model)
   const serverEnvEntry = svars
     .map((v: any) => `\n    '${serverVarEnv(PROJECTNAME, v.name)}': ${JSON.stringify(v.dflt)},`).join('')
@@ -104,7 +94,7 @@ const TestDirect = cmp(function TestDirect(props: any) {
 
         Slot({ name: 'directSetup' }, () => {
           Content(`
-function liveScenariosActive() { return ${Object.values(model.main.kit.entity || {}).some((e: any) => Object.values(e.op || {}).some((o: any) => (o.points || []).some((p: any) => p.contract && JSON.parse(p.contract.json).live)))} && process.env.${PROJECTNAME}_TEST_LIVE === 'TRUE' }
+function liveScenariosActive() { return ${hasLiveScenarios(model)} && process.env.${PROJECTNAME}_TEST_LIVE === 'TRUE' }
 function directSetup(mockres?: any) {
   const calls: any[] = []
 
@@ -184,23 +174,14 @@ function unwrapListData(data: any): any[] | null {
 })
 
 
-// GraphQL-backed op: a REST-shaped direct() call (GET, params in the URL)
-// cannot reach it — every op, including list, synthesizes POST with the
-// query/variables as a JSON body, not URL params (see
-// MakeFetchDefUtility: spec.body only ever comes from an explicit `body`
-// field, never derived from `params`). apidef already built a real, valid
-// query or mutation document per point (point.graphql.doc, with variables
-// declared to match), so reuse that verbatim through the SDK's own
-// graphql() escape hatch instead of re-deriving a REST-shaped call that
-// cannot represent one.
 function generateDirectGraphql(
   opname: 'load' | 'list',
   entity: ModelEntity,
   point: any,
   strict: boolean,
 ) {
-  const doc: string = point.graphql.doc
-  const vars: any[] = point.graphql.vars || []
+  const doc: string = point.gq.doc
+  const vars: any[] = point.gq.vars || []
 
   const varLine = (target: string, key: string, v: any) =>
     `      ${target}[${JSON.stringify(v.name)}] = ${key}`
@@ -223,10 +204,6 @@ function generateDirectGraphql(
     ? `    if (skipIfMissingIds(t, setup, ${JSON.stringify(liveIdKeys)})) return\n`
     : ''
 
-  // Asserted against the OUTGOING request body (what we sent), not the
-  // mocked response — response-shape correctness is the entity-level
-  // load/list tests' job; direct/graphql only has to prove the raw path
-  // reaches the endpoint with the right method and payload.
   const varAsserts = vars.map((_v: any, i: number) =>
     '      assert(calls[0].init.body.includes(\'direct0' + (i + 1) + '\'))\n').join('')
 
@@ -298,8 +275,8 @@ function generateDirectLoad(model: Model, entity: ModelEntity, strict: boolean)
     return
   }
 
-  const allLoadParams = loadPoint.args?.params || []
-  const loadPath = normalizePathParams(pointParts(loadPoint), allLoadParams, loadPoint.rename?.param)
+  const allLoadParams = loadPoint.g?.params || []
+  const loadPath = normalizePathParams(pointParts(loadPoint), allLoadParams, loadPoint.r?.param)
 
   // Some upstream OpenAPI specs declare a parameter as `in: path` even when
   // that path has no `{name}` placeholder for it. Only path params that
@@ -312,8 +289,7 @@ function generateDirectLoad(model: Model, entity: ModelEntity, strict: boolean)
       pathPlaceholders.add(part.slice(1, -1))
     }
   }
-  // Apply rename map (e.g. `androidId` -> `id` in parts).
-  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)
@@ -322,50 +298,44 @@ function generateDirectLoad(model: Model, entity: ModelEntity, strict: boolean)
     }
   }
   const loadParams = allLoadParams.filter((p: any) =>
-    renamedPlaceholders.has(p.name) || renamedPlaceholders.has(p.orig))
+    renamedPlaceholders.has(p.n) || renamedPlaceholders.has(p.or))
 
   // Required query params that the spec advertises an example value for.
   // Live mode needs these on the request or the API returns 4xx; mock mode
   // ignores them. Optional query params (e.g. `app`, `version`) are skipped
   // even when they have examples — only the strictly required ones are
   // necessary to satisfy the contract.
-  const loadQuery = loadPoint.args?.query || []
+  const loadQuery = loadPoint.g?.query || []
   const liveQueryEntries = loadQuery
-    .filter((q: any) => q.reqd && undefined !== q.example && null !== q.example)
+    .filter((q: any) => q.r && undefined !== q.ex && null !== q.ex)
   const hasLiveQuery = liveQueryEntries.length > 0
   const liveQueryLines = liveQueryEntries
-    .map((q: any) => `      ${jsProp('query', q.name)} = ${JSON.stringify(q.example)}`)
+    .map((q: any) => `      ${jsProp('query', q.n)} = ${JSON.stringify(q.ex)}`)
     .join('\n')
 
-  // Get list info for live mode bootstrapping
   const listOp = entity.op?.list
   const listPoint = listOp?.points?.[0]
-  const listParams = listPoint?.args?.params || []
-  const listPath = listPoint ? normalizePathParams(pointParts(listPoint), listParams, listPoint.rename?.param) : ''
+  const listParams = listPoint?.g?.params || []
+  const listPath = listPoint ? normalizePathParams(pointParts(listPoint), listParams, listPoint.r?.param) : ''
   const hasList = null != listPoint
 
-  // Ancestor params (not 'id') for live mode
-  const ancestorParams = loadParams.filter((p: any) => p.name !== 'id')
+  const ancestorParams = loadParams.filter((p: any) => p.n !== 'id')
 
   const paramAsserts = loadParams.map((p: any, i: number) =>
     '      assert(calls[0].url.includes(\'direct0' + (i + 1) + '\'))\n').join('')
 
-  // Build live list params
   const liveListParams = 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 }
   })
 
-  // Build live ancestor params for load
   const liveAncestorParams = ancestorParams.map((p: any) => {
-    const key = p.name.replace(/_id$/, '') + '01'
-    return { name: p.name, key }
+    const key = p.n.replace(/_id$/, '') + '01'
+    return { name: p.n, key }
   })
 
-  // Prefix the live block with required-query setup so it applies to both
-  // the list-bootstrapped and the no-list cases.
   const liveQueryPrefix = liveQueryLines ? liveQueryLines + '\n' : ''
 
   // Path params with spec-provided examples — when present, prefer them
@@ -374,25 +344,22 @@ function generateDirectLoad(model: Model, entity: ModelEntity, strict: boolean)
   // so they avoid the brittleness of mapping list-response field names
   // back to load path-param names.
   const liveExampleParams = loadParams.filter(
-    (p: any) => undefined !== p.example && null !== p.example
+    (p: any) => undefined !== p.ex && null !== p.ex
   )
   const allLoadParamsHaveExamples =
     loadParams.length > 0 && liveExampleParams.length === loadParams.length
 
-  // Set of idmap keys this test will read from in live mode. Used to emit
-  // a skip-on-missing-ids check so live runs without ENTID overrides skip
-  // gracefully instead of 4xx-ing on undefined params.
   let liveIdKeys: string[] = []
 
   let liveParamsBlock = ''
   if (allLoadParamsHaveExamples) {
     const exampleLines = loadParams.map(
-      (p: any) => `      ${jsProp('params', p.name)} = ${JSON.stringify(p.example)}`
+      (p: any) => `      ${jsProp('params', p.n)} = ${JSON.stringify(p.ex)}`
     ).join('\n')
     liveParamsBlock = `    if (setup.live) {
 ${liveQueryPrefix}${exampleLines}
     } else {
-${loadParams.map((p: any, i: number) => `      ${jsProp('params', p.name)} = 'direct0${i + 1}'`).join('\n')}
+${loadParams.map((p: any, i: number) => `      ${jsProp('params', p.n)} = 'direct0${i + 1}'`).join('\n')}
     }`
   }
   else if (hasList) {
@@ -405,13 +372,9 @@ ${loadParams.map((p: any, i: number) => `      ${jsProp('params', p.name)} = 'di
       `        ${lp.name}: setup.idmap['${lp.key}'],`).join('\n')
     const ancestorParamLines = liveAncestorParams.map((lp: any) =>
       `      ${jsProp('params', lp.name)} = setup.idmap['${lp.key}']`).join('\n')
-    // Try every load-path param name as the candidate field on listData[0].
-    // Some APIs name the path param differently from the response field
-    // (e.g. path uses {id} while response has mal_id), so we attempt the
-    // exact name and skip the test cleanly when no candidate value exists.
-    const idParamName = loadParams.find((p: any) => p.name === 'id')
+    const idParamName = loadParams.find((p: any) => p.n === 'id')
       ? 'id'
-      : (loadParams[0]?.name ?? 'id')
+      : (loadParams[0]?.n ?? 'id')
 
     liveParamsBlock = `    if (setup.live) {
 ${liveQueryPrefix}      const listResult: any = await client.direct({
@@ -434,7 +397,7 @@ ${listParamLines}
       ${jsProp('params', idParamName)} = candidateId
 ${ancestorParamLines}
     } else {
-${loadParams.map((p: any, i: number) => `      ${jsProp('params', p.name)} = 'direct0${i + 1}'`).join('\n')}
+${loadParams.map((p: any, i: number) => `      ${jsProp('params', p.n)} = 'direct0${i + 1}'`).join('\n')}
     }`
   } else if (hasLiveQuery || loadParams.length > 0) {
     // Synthetic-only fallback: if there are load params with no examples
@@ -442,12 +405,12 @@ ${loadParams.map((p: any, i: number) => `      ${jsProp('params', p.name)} = 'di
     // undefined values. Mark the path-param keys so the test skips when
     // ENTID overrides aren't supplied.
     if (loadParams.length > 0) {
-      liveIdKeys = loadParams.map((p: any) => p.name + '01')
+      liveIdKeys = loadParams.map((p: any) => p.n + '01')
     }
     liveParamsBlock = `    if (setup.live) {
 ${liveQueryPrefix.replace(/\n$/, '')}
     } else {
-${loadParams.map((p: any, i: number) => `      ${jsProp('params', p.name)} = 'direct0${i + 1}'`).join('\n')}
+${loadParams.map((p: any, i: number) => `      ${jsProp('params', p.n)} = 'direct0${i + 1}'`).join('\n')}
     }`
   } else {
     liveParamsBlock = ''
@@ -533,23 +496,20 @@ function generateDirectList(model: Model, entity: ModelEntity, strict: boolean)
     return
   }
 
-  const listParams = listPoint.args?.params || []
-  const listPath = normalizePathParams(pointParts(listPoint), listParams, listPoint.rename?.param)
+  const listParams = listPoint.g?.params || []
+  const listPath = normalizePathParams(pointParts(listPoint), listParams, listPoint.r?.param)
 
-  // Required query params with spec-provided examples — needed to satisfy
-  // the API contract in live mode (see generateDirectLoad for rationale).
-  const listQuery = listPoint.args?.query || []
+  const listQuery = listPoint.g?.query || []
   const liveQueryLines = listQuery
-    .filter((q: any) => q.reqd && undefined !== q.example && null !== q.example)
-    .map((q: any) => `      ${jsProp('query', q.name)} = ${JSON.stringify(q.example)}`)
+    .filter((q: any) => q.r && undefined !== q.ex && null !== q.ex)
+    .map((q: any) => `      ${jsProp('query', q.n)} = ${JSON.stringify(q.ex)}`)
     .join('\n')
 
-  // Build live params
   const liveParams = 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 }
   })
 
   const paramAsserts = listParams.map((p: any, i: number) =>
@@ -563,7 +523,7 @@ function generateDirectList(model: Model, entity: ModelEntity, strict: boolean)
         `      ${jsProp('params', lp.name)} = setup.idmap['${lp.key}']`).join('\n'),
     ].filter(Boolean).join('\n')
     const mockLines = listParams.map((p: any, i: number) =>
-      `      ${jsProp('params', p.name)} = 'direct0${i + 1}'`).join('\n')
+      `      ${jsProp('params', p.n)} = 'direct0${i + 1}'`).join('\n')
 
     paramsBlock = `    const params: any = {}
     const query: any = {}
@@ -579,8 +539,6 @@ ${mockLines}
 `
   }
 
-  // List path params come from idmap in live mode. Mark those keys so the
-  // test skips cleanly when the ENTID env var isn't set.
   const liveIdKeys: string[] = listParams.length > 0
     ? liveParams.map((lp: any) => lp.key)
     : []
@@ -588,7 +546,6 @@ ${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)
@@ -650,20 +607,12 @@ ${listChecks}
 }
 
 
-// Replace raw OpenAPI parameter names in path parts with model parameter names.
-// Path parts may have e.g. {subBreed} while model params use sub_breed.
-// When a rename mapping exists (e.g. closureId -> id), path parts contain the
-// renamed form {id} but params still use the original name closure_id.
-// The rename mapping is used to reverse-lookup the original param name.
 function normalizePathParams(
   parts: string[],
   params: any[],
   rename?: Record<string, string>
 ): string {
   return parts.map((part: string) => {
-    // Replace each {paramName} occurrence within the part.
-    // Handles both simple parts like "{id}" and compound parts like
-    // "{outputFields}.{format}" that contain multiple parameters.
     return part.replace(/\{([^}]+)\}/g, (match: string, rawName: string) => {
       const snaked = snakify(rawName)
       const depluralized = depluralize(snaked)
@@ -671,10 +620,10 @@ function normalizePathParams(
       // original name was renamed to another param's current name (e.g. badge
       // load: param 'group_id' has orig 'id', and another param has name 'id').
       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 + '}'
 
       // Reverse-lookup through rename mapping: if rawName is a renamed value
       // (e.g. "id"), find the original camelCase key (e.g. "closureId"),
@@ -685,10 +634,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 + '}'
           }
         }
       }