@voxgig/sdkgen 4.21.0 → 4.23.0

package/project/.sdk/src/cmp/c/ReadmeRef_c.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 {
@@ -47,7 +47,7 @@ const ReadmeRef = cmp(function ReadmeRef(props: any) {
   const ident = cIdent(model)
   const Name = model.const.Name
   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)
 
@@ -174,7 +174,7 @@ Prepare a fetch definition without sending. Returns the fetchdef and sets
     // 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 = cVarName(ent.name)
       const acc = `${ident}_${evar}`
@@ -207,9 +207,9 @@ Entity* ${evar} = ${acc}(client, NULL);
 | --- | --- | --- | --- |
 `)
         each(fields, (field: any) => {
-          const req = field.req ? 'Yes' : 'No'
-          const desc = field.short || ''
-          Content(`| \`${field.name}\` | \`${cType(field.type)}\` | ${req} | ${desc} |
+          const req = field.r ? 'Yes' : 'No'
+          const desc = field.sh || ''
+          Content(`| \`${field.n}\` | \`${cType(field.t)}\` | ${req} | ${desc} |
 `)
         })
 
@@ -234,7 +234,7 @@ Entity* ${evar} = ${acc}(client, NULL);
               if (fop.active === false) return '-'
               return 'Yes'
             })
-            Content(`| \`${field.name}\` | ${cols.join(' | ')} |
+            Content(`| \`${field.n}\` | ${cols.join(' | ')} |
 `)
           })
 
@@ -388,9 +388,6 @@ ${Name}SDK* client = ${ident}_sdk_new(cmap(1,
 \`\`\`
 
 `)
-      // 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/c/ReadmeTopQuick_c.ts

@@ -23,8 +23,6 @@ function cLit(type: any, placeholder: string = 'example'): string {
 }
 
 
-// cmap(...) for a set of `"key", <lit>` pairs, or NULL when empty (ops accept
-// a NULL match/data argument).
 function cmapExpr(pairs: string[]): string {
   return pairs.length ? `cmap(${pairs.length}, ${pairs.join(', ')})` : 'NULL'
 }

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

@@ -17,25 +17,6 @@ import {
 } from './utility_c'
 
 
-// THE GENERATED SCHEMA MODULE: the model's schemas, as data the SDK can run.
-//
-// The c 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 c 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 c's. A
-// string constant, exactly as config.c carries its data rep above the size
-// threshold, and for the same reason — a nested `cmap(...)` literal is one
-// expression whose depth is what makes a C compiler's parser and register
-// allocator quadratic. 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 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$
 
@@ -54,7 +35,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.
 
 #include "api.h"

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

@@ -30,10 +30,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)) {
@@ -41,10 +41,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,15 +76,15 @@ const TestDirect = cmp(function TestDirect(props: any) {
   const listOp = (entity.op as any)?.list
 
   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 || []
   const _pathPlaceholders = new Set<string>()
   for (const part of pointParts(loadPoint)) {
     if (typeof part === 'string' && part.startsWith('{') && part.endsWith('}')) {
       _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)
@@ -93,11 +93,11 @@ 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))
 
   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 || []
 
   File({ name: entity.name + '_direct_test.c' }, () => {
 

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

@@ -23,13 +23,6 @@ function cVarName(name: string): string {
 }
 
 
-// The C project identifier used as a function-name prefix, e.g. solar. Must
-// match the SQUASHED `projectname` token that the umbrella header/fragment use
-// for the constructor (`<ident>_sdk_new`): a hyphenated slug
-// (bluefin-decryptx-p2pe) squashes to `bluefindecryptxp2pe`, so drop every
-// non-alphanumeric char rather than mapping them to `_` (which produced
-// `bluefin_decryptx_p2pe_sdk_new` callers that never linked against the
-// squashed definition). No-op for single-word names.
 function cIdent(model: any): string {
   return String(model.name).toLowerCase().replace(/[^a-z0-9]/g, '')
 }
@@ -88,29 +81,6 @@ function formatCValue(val: any, indent: number = 0): string {
 }
 
 
-// Deep-remove meta keys (`foo$`) from a model subtree (twin of go/rust 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
@@ -151,23 +121,6 @@ function clean(o: any, dropDefaults?: boolean): any {
 
 
 
-// The JSON as a C string literal, split into ADJACENT literals.
-//
-// C99 only guarantees 4095 characters in a single string literal, and a real
-// model runs to hundreds of kilobytes. Adjacent literals are concatenated by
-// the translation phase before that limit applies, so this stays portable
-// rather than relying on gcc/clang having no practical limit.
-//
-// Only `\` and `"` need escaping: JSON.stringify output contains no raw
-// control characters (it writes them as the six TEXT characters \u00XX), and
-// C string literals take UTF-8 bytes verbatim. Escaping the backslash also
-// means no `\uXXXX` ever reaches the C lexer, which matters - a universal
-// character name below 0xA0 is ill-formed C, so the JSON's own escapes would
-// have been rejected if they had been passed through.
-//
-// Chunks are cut from the RAW text and escaped afterwards, so a cut can never
-// land inside an escape sequence. Surrogate pairs are kept whole, or the cut
-// would emit a lone surrogate as invalid UTF-8.
 function cStringLiteral(json: string, chunkSize: number = 2000): string {
   const parts: string[] = []
   let i = 0

package/project/.sdk/src/cmp/clojure/Config_clojure.ts

@@ -44,33 +44,8 @@ const Config = cmp(async function Config(props: any) {
 
   const model: Model = ctx$.model
 
-  // The canonical config OBJECT and its JSON, from the shared helper. Both
-  // representations render from the same `def`, so they cannot describe
-  // different configs - and this target picks up `options.server` (the OpenAPI
-  // server-variable defaults), which the hand-rolled build here omitted.
-  // Passing target.name opts this target into the main slug/version/target
-  // identity fields (read by station's descriptor - see configDefinition).
   const { def: config, json: baseJson } = configDefinition(model, target.name)
 
-  // WHERE THE CREDENTIAL GOES, AND UNDER WHAT NAME, travel with the prefix
-  // now. apidef resolved `in` and `name` from the spec's securityScheme all
-  // along and generation dropped them, so an apiKey-in-query API got an
-  // Authorization header it does not read.
-  //
-  // Emitted ONLY when they differ from the header/Authorization defaults, so
-  // a header-based SDK's config.clj is byte-identical to what it generated
-  // before - the `asData` threshold included, since that is measured on the
-  // JSON built here.
-  //
-  // Both representations still render from this ONE `def` (the literal
-  // through formatCljValue, the data rep through the JSON), so they cannot
-  // describe different configs. The shared configDefinition is deliberately
-  // NOT changed: it feeds every target, and this is the clojure rollout.
-  //
-  // core.clj's optspec had to learn the two keys as well ("auth" (vs/jm
-  // "prefix" "" "basic" false "in" "" "name" "")) - `vs/validate` refuses a
-  // key it does not name, so without that an SDK carrying this block could
-  // not be constructed at all.
   const authIn = resolveAuthIn(model)
   const authName = resolveAuthName(model)
   const configAuth = config?.options?.auth
@@ -83,28 +58,6 @@ const Config = cmp(async function Config(props: any) {
 
   const asData = isConfigData(configJson, configReprSetting(model))
 
-  // THE FEATURE WIRING (the clojure peer of Config_go's pluginImports /
-  // FeaturePlugins, and of Config_ts's pluginDefs).
-  //
-  // Two maps, both always emitted so sdk.features can name them without
-  // knowing whether this SDK selected anything:
-  //
-  //   feature-plugins  the voxgig/plugin DEFINITIONS the model's plugin
-  //                    groups selected, per feature. Upstream sekreto's
-  //                    contract since the registry was retired is that a
-  //                    provider kind not passed in is unknown to that
-  //                    Sekreto - so this map IS the SDK's provider
-  //                    vocabulary, and an inactive group leaves neither a
-  //                    require nor a reference behind.
-  //
-  //   feature-extra    the constructor for each feature whose source lives
-  //                    outside src/sdk/features.clj. make-feature consults
-  //                    it rather than requiring the container directly,
-  //                    which is what keeps the ~35 vendored namespaces out
-  //                    of every clojure SDK's load graph.
-  //
-  // Emitted HERE (not in the feature container) so the load order is
-  // core -> feature/secrets -> config -> features -> client, with no cycle.
   const extra = extraFeatures(model, target)
   const { requires: plugreq, plugins: featplugins } = pluginRequires(model, target)
 
@@ -126,17 +79,6 @@ const Config = cmp(async function Config(props: any) {
 
   File({ name: 'config.clj' }, () => {
 
-    // ABOVE THE THRESHOLD: emit the model as DATA.
-    //
-    // The literal is one nested form the Clojure reader walks and the compiler
-    // turns into constructor calls at load; a string is one token, and
-    // `sdk.core/json-parse` builds the same LinkedHashMap/ArrayList nodes
-    // `vs/jm` and `vs/jt` produce. It is already the SDK's response decoder,
-    // so this adds no dependency.
-    //
-    // JSON.stringify output is a valid Clojure string literal: it escapes
-    // every backslash, so the JSON's own `\uXXXX` reaches the reader as
-    // `\\uXXXX` and no Clojure escape is ever formed from it.
     if (asData) {
       Content(`;; ${model.const.Name} SDK configuration (generated by @voxgig/sdkgen).
 ;;
@@ -166,11 +108,6 @@ ${wireBlock}`)
 })
 
 
-// The augmentation above must be a NO-OP for a header/Authorization SDK, and
-// that is the whole byte-identity claim - so it is checked rather than
-// asserted in a comment. A future change to configDefinition that starts
-// emitting `in`/`name` itself would make this fire rather than silently
-// double up.
 function assertHeaderIdentity(now: string, before: string, authIn: string, authName: string) {
   const defaults = 'header' === authIn && 'Authorization' === authName
   if (defaults && now !== before) {

package/project/.sdk/src/cmp/clojure/Entity_clojure.ts

@@ -24,7 +24,6 @@ const Entity = cmp(function Entity(props: any) {
 
   const ff = Path.normalize(__dirname + '/../../../src/cmp/clojure/fragment/')
 
-  // Entity files go to src/sdk/entity/<name>.clj (ns sdk.entity.<name>).
   Folder({ name: 'src' }, () => {
     Folder({ name: 'sdk' }, () => {
       Folder({ name: 'entity' }, () => {

package/project/.sdk/src/cmp/clojure/Main_clojure.ts

@@ -26,11 +26,6 @@ import { MainEntity } from './MainEntity_clojure'
 import { PrepareAuth } from './PrepareAuth_clojure'
 
 
-// Features that ship a top-level `feature/<name>/` container in
-// tm/clojure. Listed rather than discovered: a component cannot walk the
-// template tree, and the list is short and changes with the templates it
-// describes. Anything named here is EXCLUDED from the verbatim copy unless
-// the model selects it (see the Copy below).
 const CONTAINED = ['secrets']
 
 
@@ -45,33 +40,6 @@ const Main = cmp(async function Main(props: any) {
 
   Gitignore({})
 
-  // Copy tm/clojure verbatim (runtime under src/, the test suite under test/,
-  // Makefile/LICENSE/VERSION). The feature-add scaffolding under src/feature
-  // is excluded — the clojure target does not use per-feature custom source.
-  //
-  // THE TOP-LEVEL feature/ CONTAINER IS GATED HERE, at generate time.
-  //
-  // clojure declares `feature: trim: false` (model/target/clojure.aon)
-  // because every ordinary feature lives in the single generated module
-  // src/sdk/features.clj, so `target add` copies the whole template tree.
-  // That was harmless while nothing per-feature existed. It stopped being
-  // harmless with `secrets`: its container holds a vendored
-  // @voxgig/sekreto port and the voxgig/plugin runtime, and an SDK that
-  // never asked for secrets would otherwise ship ~35 files of key-store,
-  // request-signing and child-process code. So the container is excluded
-  // unless the model SELECTS the feature — the top-level-container peer of
-  // the `srcFeatureExcludes` gate ts and js apply to src/feature/<name>/.
-  //
-  // pluginExcludes: one level deeper, the generate-time plugin trim. An
-  // INACTIVE plugin group's declared files stay out of the tree; the
-  // model's `path` entries are target-root-relative, which is this Copy's
-  // root. It runs independently of `feature.trim`, so the group trim works
-  // while that decision stands.
-  //
-  // The gated feature's own TEST suite goes with it, and is named
-  // separately: it lives at test/sdk/test/feature/<name>.clj (a file, so
-  // the container pattern's trailing slash does not reach it) because
-  // Clojure resolves `sdk.test.feature.<name>` to that exact path.
   const featureGate = extraFeatures(model, target).map((f: any) => f.name)
   const containerExcludes = CONTAINED
     .filter((name: string) => !featureGate.includes(name))
@@ -88,15 +56,6 @@ const Main = cmp(async function Main(props: any) {
     }
   })
 
-  // Generated config namespace (src/sdk/config.clj), and the generated
-  // credential placement (src/sdk/prepare_auth.clj).
-  //
-  // BOTH SIT IN THIS ONE src/sdk PAIR, and neither opens a folder of its own.
-  // The Copy above roots tm/clojure at the target root, so the copied
-  // core.clj lands at src/sdk/core.clj; prepare_auth.clj has to be its
-  // SIBLING, because core.clj reads it with `(load "prepare_auth")` and that
-  // resolves to the classpath resource `sdk/prepare_auth.clj` under
-  // deps.edn's `:paths ["src"]`.
   Folder({ name: 'src' }, () => {
     Folder({ name: 'sdk' }, () => {
       Config({ target })

package/project/.sdk/src/cmp/clojure/Package_clojure.ts

@@ -16,26 +16,6 @@ import {
 } from './featureextra_clojure'
 
 
-// deps.edn — the tools.deps manifest. The vendored voxgig struct port needs no
-// external dependency; the library itself only needs org.clojure/clojure. The
-// tools.deps shim used to run the tests supports `-M:alias` reading :paths /
-// :extra-paths / :main-opts, but NOT per-alias :extra-deps, so every dependency
-// lives at the top-level :deps.
-//
-// `test/vendor/omni` is a SECOND test source root, not a subdirectory of the
-// first: the vendored @voxgig/omni port declares `voxgig.omni.runner`, so its
-// namespaces resolve only when the directory holding `voxgig/` is itself on
-// the classpath. Rooting it at `test` instead would demand the namespace
-// `vendor.omni.voxgig.omni.runner`, which the vendored file cannot carry -
-// it is read-only, resynced from upstream.
-//
-// A feature whose source ships as its own tree - `secrets`, which vendors
-// a whole @voxgig/sekreto port - needs the SAME treatment for the SAME
-// reason: the vendored files declare `voxgig.sekreto.chain`, so they
-// resolve only when the directory holding `voxgig/` is on the classpath.
-// So `feature/<name>` joins :paths, and only when the model selects that
-// feature: an SDK that did not ask for secrets gets the deps.edn it always
-// had, naming no directory that is not there.
 const Package = cmp(async function Package(props: any) {
   const ctx$ = props.ctx$
   const target = props.target

package/project/.sdk/src/cmp/clojure/PrepareAuth_clojure.ts

@@ -16,66 +16,10 @@ import {
 } from '@voxgig/apidef'
 
 
-// WHERE THE CREDENTIAL GOES IS A FACT ABOUT THE API, so it is generated
-// rather than templated. The clojure port of cmp/ts/PrepareAuth_ts.ts; see
-// that file for the full account of the defect.
-//
-// 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. Four repos in the cedar
-// fleet ship that way: joplin (`token`), pipedrive (`api_token`), trello
-// (`key`), lm-umbrella (`apiKey`).
-//
-// CLOJURE HAD NO prepare_auth TEMPLATE TO REPLACE. The other twelve targets
-// each had a standalone file; here the logic was EMBEDDED in
-// tm/clojure/src/sdk/core.clj as `u-prepare-auth`, three constants above it,
-// and the `:prepare-auth u-prepare-auth` entry in `base-utility-map`.
-//
-// THE EXTRACTION SHAPE: its own FILE, still inside the sdk.core NAMESPACE.
-//
-// A separate namespace is not available, and not for a stylistic reason.
-// `u-prepare-auth` calls `oget`, `ctx-error` and `client-options-map`, all
-// defined in sdk.core, while sdk.core's `base-utility-map` must reference
-// `u-prepare-auth` — so `(:require [sdk.prepare-auth])` from sdk.core plus
-// `(:require [sdk.core])` back is a load cycle, which Clojure refuses
-// outright ("Cyclic load dependency"). The alternatives are worse: passing
-// four core functions in as arguments, or late-binding through an atom the
-// way kotlin's `lateinit var prepareAuth` does, would both restructure the
-// runtime to work around a problem Clojure already has an answer for.
-//
-// That answer is `load`, the idiom clojure.core itself uses to split across
-// files (core.clj does `(load "core_deftype")`, `(load "core_print")`, …).
-// The generated file opens with `(in-ns 'sdk.core)` and is READ INTO sdk.core
-// at the exact point the defn used to sit, so:
-//
-//   - every helper it calls is already defined above it, unchanged;
-//   - the symbol `u-prepare-auth` resolves in `base-utility-map` exactly as
-//     before, so the `:prepare-auth` binding is untouched;
-//   - `core/HEADER-AUTH`, which feature/secrets/sdk/feature/secrets.clj
-//     reads, is still a public var of sdk.core;
-//   - and the call sites — `(ucall ctx :prepare-auth)` in core.clj's
-//     `u-make-spec`, `((core/uget ctx :prepare-auth) ctx)` in client.clj's
-//     `prepare`, and the same spelling in test/sdk/test/pipeline.clj and
-//     test/sdk/test/primary.clj — all still go through the utility map.
-//
-// A template cannot fix the defect, because the three placements need three
-// different bodies and a template has to pick one. This emits the branch the
-// 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.
 const PrepareAuth = cmp(async function PrepareAuth(props: any) {
   const { target } = props
   const model: Model = props.ctx$.model
 
-  // NO FOLDER IS OPENED HERE, and that is the whole of the placement
-  // decision. Main_clojure calls this inside its `Folder({name:'src'}) >
-  // Folder({name:'sdk'})` pair — the same pair Config sits in, and Config
-  // opens no folder of its own either. The file has to land beside the
-  // copied core.clj at `src/sdk/prepare_auth.clj`, because deps.edn declares
-  // `:paths ["src"]` and `(load "prepare_auth")` from the namespace sdk.core
-  // resolves to the CLASSPATH RESOURCE `sdk/prepare_auth.clj`. Opening a
-  // second `src`/`sdk` here would write `src/sdk/src/sdk/prepare_auth.clj`,
-  // which is not that resource.
   File({ name: 'prepare_auth.' + target.ext }, () => {
     Content(render({
       Name: model.const.Name,
@@ -83,9 +27,6 @@ const PrepareAuth = cmp(async function PrepareAuth(props: any) {
       where: resolveAuthIn(model),
       name: resolveAuthName(model),
       basic: isHttpBasicAuth(model),
-      // Read so the resolution is visible at generation time even though the
-      // emitted code takes the prefix from options at runtime (the secrets
-      // feature rewrites it there).
       prefix: resolveAuthPrefix(model),
     }))
   })
@@ -122,45 +63,16 @@ function render(spec: AuthSpec): string {
 }
 
 
-// HEADER NAMES ARE LOWER-CASED; QUERY PARAMETER AND COOKIE NAMES ARE NOT.
-//
-// `resolveAuthName` answers 'Authorization' by default, but the whole clojure
-// runtime spells header names in lower case: the template this replaces held
-// `(def HEADER-AUTH "authorization")`, the shipped
-// test/sdk/test/feature/secrets.clj reads `(vs/getprop headers
-// "authorization")`, test/sdk/test/pipeline.clj asserts on the same key, and
-// the shared corpus asserts `ctx:spec:headers:authorization`. The spec's
-// headers are a java.util.LinkedHashMap, whose keys are case-SENSITIVE, so
-// emitting "Authorization" would put the credential under a key nothing
-// reads. HTTP header names are case-insensitive on the wire, so lower-casing
-// costs nothing. A query parameter and a cookie ARE case-sensitive (`?Token=`
-// is not `?token=`), so those go in verbatim.
 function headerName(name: string): string {
   return String(name).toLowerCase()
 }
 
 
-// `core/HEADER-AUTH` IS PART OF sdk.core's PUBLIC SURFACE, so it is emitted
-// for every placement: feature/secrets/sdk/feature/secrets.clj writes the
-// re-authenticated credential with `(.put ^java.util.Map headers
-// core/HEADER-AUTH ...)`, and an SDK that resolves secrets would not compile
-// without the var.
-//
-// For a header scheme it is the header this SDK actually uses, so the two
-// writers agree by construction. For a query or cookie scheme the secrets
-// feature has no header of its own to name — its re-auth is an Authorization
-// rewrite, and the shipped suite asserts that literal — so the var keeps the
-// value it has always had rather than being pointed at a query parameter
-// name that means nothing in a header.
 function headerAuthConst(spec: AuthSpec): string {
   return 'header' === spec.where ? headerName(spec.name) : 'authorization'
 }
 
 
-// HEADER. Byte-for-byte the block that was in core.clj when the scheme
-// resolves to the defaults (header / Authorization), so every header-based
-// SDK regenerates unchanged — only the constant's VALUE moves with the model,
-// plus the HTTP Basic branch, which is emitted only for a basic scheme.
 function renderHeader(spec: AuthSpec, head: string): string {
   return head + `(def HEADER-AUTH ${cljstr(headerName(spec.name))})
 (def OPTION-APIKEY "apikey")
@@ -182,9 +94,6 @@ ${spec.basic ? basicBlock() : headerPlace(14)}
 }
 
 
-// The template's own body, unchanged: an empty prefix (a raw apiKey
-// credential) must not add a leading space, and a missing credential deletes
-// whatever was there rather than leaving a stale value behind.
 function headerPlace(col: number): string {
   const p = ' '.repeat(col)
   return `${p}(if (or (nil? apikey) (and (string? apikey) (or (= apikey NOT-FOUND) (= apikey ""))))
@@ -196,11 +105,6 @@ ${p}          (if (= auth-prefix "") apikey-val (str auth-prefix " " apikey-val)
 }
 
 
-// HTTP Basic is header-only by definition: the scheme is
-// `Authorization: Basic base64(user:pass)`. It cannot be expressed as a query
-// parameter or a cookie, so the branch is emitted only where it can mean
-// something — and only when the model says the scheme IS basic, so an
-// ordinary bearer SDK carries no dead code.
 function basicBlock(): string {
   return `              ;; True HTTP Basic Auth needs TWO credentials, base64-joined - a
               ;; single token in the header (the branch below) can never
@@ -221,9 +125,6 @@ ${headerPlace(16)})`
 }
 
 
-// QUERY. The credential is a query parameter, so it goes in the spec's query
-// map (which u-make-url turns into the query string) and the headers are
-// never touched.
 function renderQuery(spec: AuthSpec, head: string): string {
   return head + `;; Retained for feature/secrets, whose re-auth writes an Authorization
 ;; header; this SDK's own credential is a query parameter (see QUERY-AUTH).
@@ -253,11 +154,6 @@ function renderQuery(spec: AuthSpec, head: string): string {
 }
 
 
-// COOKIE. A cookie IS a header, so the credential rides the header bag — but
-// the `cookie` header is SHARED with whatever cookies the caller set, so our
-// own pair is spliced in and out rather than the header being assigned over.
-// Splicing also makes this idempotent: a retried request cannot end up
-// carrying the credential twice.
 function renderCookie(spec: AuthSpec, head: string): string {
   return head + `;; Retained for feature/secrets, whose re-auth writes an Authorization
 ;; header; this SDK's own credential is a cookie (see COOKIE-AUTH).
@@ -331,30 +227,6 @@ function renderInactive(spec: AuthSpec, head: string): string {
 }
 
 
-// NOT `isAuthActive`, AND THE DIFFERENCE IS LOAD-BEARING (the py and rb ports
-// found this first; same reasoning, same fix).
-//
-// `isAuthActive` is false whenever the SPEC declares no security scheme
-// (`main.kit.info.auth: false`). That is a statement about the DEFINITION,
-// not a ban on ever sending a credential: apidef writes it for every spec
-// with no securitySchemes block — GitHub's official OpenAPI included, and
-// sdkgen's own generate fixture — and those SDKs are still expected to honour
-// an `apikey` the caller passes. core.clj's optspec ALWAYS declares `apikey`
-// and `auth`, and make-options fills `options.auth` from those defaults, so
-// the runtime `(nil? (vs/getprop options "auth"))` guard never fires and the
-// credential has always gone out.
-//
-// Gating the body on `isAuthActive` therefore does not trim dead code, it
-// deletes working authentication — and takes the secrets feature with it,
-// since that resolves a secret into `options.apikey` and prepare-auth then
-// places nothing. The shipped tm/clojure/test/sdk/test/feature/secrets.clj
-// suite, which sdkgen's own `clojure: the secrets feature runs with the
-// feature active` lane runs, is what catches it.
-//
-// So the no-op is emitted only when the PROJECT says so:
-// `main.kit.config.auth.active: false`, an explicit per-SDK switch nobody
-// sets by accident. A spec that is merely silent keeps the credential path it
-// has always had.
 function authSwitchedOn(model: any): boolean {
   const auth = getModelPath(model, `main.${KIT}.config.auth`,
     { only_active: false, required: false })
@@ -362,8 +234,6 @@ function authSwitchedOn(model: any): boolean {
 }
 
 
-// A Clojure string literal. The reader's escapes are backslash-led, so only
-// the backslash and the double quote need handling.
 function cljstr(s: string): string {
   return '"' + String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"') + '"'
 }

package/project/.sdk/src/cmp/clojure/ReadmeEntity_clojure.ts

@@ -65,7 +65,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 || {})
     // Model-driven id key: null when this entity has no id-like field.
     const idF = entityIdField(entity)
     const eLow = entity.name
@@ -111,8 +111,8 @@ const ReadmeEntity = cmp(function ReadmeEntity(props: any) {
 `)
 
       each(fields, (field: any) => {
-        const desc = field.short || ''
-        Content(`| \`${field.name}\` | \`${cljType(field.type)}\` | ${desc} |
+        const desc = field.sh || ''
+        Content(`| \`${field.n}\` | \`${cljType(field.t)}\` | ${desc} |
 `)
       })