@voxgig/sdkgen 4.21.0 → 4.22.0

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

@@ -12,11 +12,6 @@ function projectPath(suffix?: string): string {
 }
 
 
-// Render a JSON-shaped value as Clojure source that builds the equivalent
-// vendored-struct value node: maps -> (vs/jm "k" v ...), arrays -> (vs/jt v
-// ...), scalars -> literals. Keys are emitted in sorted order for byte-stable
-// output. Empty map/array render as (vs/jm) / (vs/jt), so the result is valid
-// for 0, 1 or N entries (N-feature-safe).
 function formatCljValue(val: any, indent: number = 0): string {
   if (val === null || val === undefined) {
     return 'nil'
@@ -63,29 +58,6 @@ function cljString(s: string): string {
 }
 
 
-// Remove `$`-suffixed model annotation keys (mirrors utility_rb.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
@@ -126,25 +98,6 @@ function clean(o: any, dropDefaults?: boolean): any {
 
 
 
-// The JSON as Clojure string literals, CHUNKED, joined at load.
-//
-// A Clojure string literal becomes a JVM constant-pool UTF-8 entry, and those
-// are capped at 65,535 bytes. One constant therefore cannot hold a config
-// large enough to select the data representation at all - the threshold is
-// 256 KB, so every model that reaches this branch would exceed the limit.
-//
-// The failure is AOT-only and so is easy to miss: loading from source is fine,
-// and `clojure -M:test-compile` only `require`s. It appears the moment anyone
-// compiles the SDK, which is the normal path for distribution:
-//
-//   Execution error (IllegalArgumentException)
-//     at clojure.asm.ByteVector/putUTF8 (ByteVector.java:245)
-//
-// java/kotlin/scala already chunk for exactly this reason (see Config_java's
-// jsonAppendLines). Chunks are measured in UTF-8 BYTES, not characters, with
-// a wide margin: modified UTF-8 encodes a supplementary character as six
-// bytes, so a character count is not a byte count. Surrogate pairs are kept
-// whole, or a cut would emit a lone surrogate.
 function cljStringChunks(json: string, maxBytes: number = 20000): string[] {
   const chunks: string[] = []
   let start = 0

package/project/.sdk/src/cmp/cpp/Config_cpp.ts

@@ -24,27 +24,6 @@ import {
 } from './utility_cpp'
 
 
-// PLUGIN DEFINITIONS PER FEATURE (the cpp peer of Config_c's
-// pluginDefinitions and Config_go's featurePlugins map).
-//
-// Upstream sekreto retired its self-registration registry for voxgig/plugin
-// definitions: a provider kind the caller did not pass in
-// `SekretoOptions::plugins` is unknown to that Sekreto. So the model's
-// choice of plugin groups IS the SDK's provider vocabulary, and the
-// generated code names each active group's factory (`def: cpp:` in
-// model/feature/secrets.aon - `hashicorp`, the `Definition hashicorp()`
-// each vendored kind header declares in namespace sekreto) and nothing
-// else. A symbol named here whose file the plugin trim removed is an
-// unresolved reference at link time - a loud failure, which is the right
-// kind. The owning file is kept per symbol because the generated
-// translation unit has to include that file's header.
-//
-// One entry per ACTIVE feature that declares a `plugin` map at all, read
-// with `only_active: false` (pluginExcludesFor's subtlety: the feature
-// object a component is handed has already been filtered, so a feature
-// whose groups are all off would otherwise look like one with no plugin
-// machinery, and its kinds.cpp - which the Makefile reads as the feature's
-// WIRING - would not be emitted).
 function pluginDefinitions(model: Model, target: any):
   Record<string, { syms: Record<string, string>, groups: number }> {
   const out: Record<string, { syms: Record<string, string>, groups: number }> = {}
@@ -75,50 +54,6 @@ function pluginDefinitions(model: Model, target: any):
 }
 
 
-// feature/<name>/kinds.cpp - GENERATED, one per plugin-bearing active
-// feature, and the ONE translation unit this otherwise header-only target
-// generates.
-//
-// It cannot live in core/config.hpp: that header is included by every test
-// translation unit, and it must not name the vendored voxgig/plugin's
-// `Definition` type - the same reason go hides its list behind []any and c
-// behind void**. So config.hpp's accessor is type-erased
-// (std::shared_ptr<void>), and this file, which may include the kind
-// headers, produces the erased list. It sits one level ABOVE the vendored
-// sekreto/, plugin/ and plugins/ directories on purpose: the vendoring
-// guard fails any non-vendored file inside a vendor dir, and this one is
-// generated.
-//
-// Beside it goes feature/<name>/kinds.mk, the feature's BUILD WIRING: a
-// generated make fragment that tm/cpp/Makefile reads through
-// `-include $(wildcard feature/*/kinds.mk)`. The Makefile itself names no
-// feature (the `nothing left behind names a dropped feature` guard holds a
-// trimmed template tree to that), so everything the payload needs from the
-// build is stated here, from the model: this translation unit and the
-// vendored cores to compile into libsdkfeature.a, the suite to build, and
-// - only when a plugin group is active - the plugin layer with the OpenSSL
-// it brings. A tree whose model never activated the feature has no
-// fragment, compiles none of the payload and links libstdc++ alone. Both
-// files are emitted for an active feature with NO active group as well -
-// an [env, memory] chain still needs the sekreto core - with an empty
-// definitions list and no plugin layer.
-//
-// For `secrets` it additionally carries `secrets_rawfetch`, the
-// token-exchange transport of last resort (go's rawExchangeFetch). The cpp
-// core ships no HTTP client (utility/pipeline.hpp fetcher: "provide
-// options.system.fetch"), and the decision for this target - as for c - is
-// to bundle one INSIDE the gated feature, compiled in only when a plugin
-// group is active, so an SDK without secrets, or with a chain of built-ins,
-// still ships zero external dependencies. DELIBERATE DIVERGENCE from c,
-// which bundles libcurl: the cpp sekreto port exports its own HTTPS client
-// (`sekreto::httprequest`, plugins/Httpjson.cpp over plugins/Tls.cpp), and
-// it is already compiled and linked - OpenSSL and all - on exactly the
-// condition this transport needs. Reusing it means one HTTP stack and one
-// -l pair (-lssl -lcrypto) instead of two; kinds.mk links OpenSSL on the
-// same condition (a plugin group active), so the two cannot disagree.
-// With no group active the exchange still works through a caller-supplied
-// options.system.fetch, which every live cpp request already lives under;
-// only the fallback is missing, and it says so.
 const FeaturePlugins = cmp(async function FeaturePlugins(props: any) {
   const ctx$ = props.ctx$
   const target = props.target
@@ -132,10 +67,6 @@ const FeaturePlugins = cmp(async function FeaturePlugins(props: any) {
       const { syms, groups } = defs[fname]
       const symnames = Object.keys(syms).sort()
 
-      // The header each selected kind file declares its factory in,
-      // relative to this file (feature/<fname>/): `feature/<fname>/
-      // plugins/Hashicorp.cpp` -> `plugins/Hashicorp.hpp`. Deduplicated,
-      // because aws declares two factories in one header.
       const headers = Array.from(new Set(symnames.map((sym) =>
         syms[sym]
           .replace(new RegExp('^feature/' + fname + '/'), '')
@@ -324,38 +255,8 @@ const Config = cmp(async function Config(props: any) {
   // helpers/applicability.
   const feature = targetFeatures(model, target)
 
-  // The embedded config, built by the shared helper so this target's shapes
-  // and identity fields stay in step with the ts reference by construction.
-  // Passing target.name opts cpp into main.slug/version/target (the station
-  // descriptor identity, ts/src/utility.ts configDefinition) - cpp has only
-  // the data rep (one chunked JSON literal), so this is the whole #MainMeta
-  // story for this target.
   const { def: configDef } = configDefinition(model, target.name)
 
-  // `in` and `name` TRAVEL WITH THE PREFIX NOW.
-  //
-  // apidef resolved both from the spec's securityScheme all along and this
-  // generator dropped them, so an apiKey-in-query API got an `authorization`
-  // header it does not read (see PrepareAuth_cpp). The generated
-  // prepare_auth is built from the same two values, and the config carries
-  // them so the placement is a visible, overridable runtime option beside
-  // auth.prefix.
-  //
-  // IT IS INERT WITHOUT THE OPTSPEC. cpp does not build its option schema
-  // from the model: it is a JSON literal in tm/cpp/utility/pipeline.hpp
-  // (OPTSPEC_JSON), and cpp's vendored Struct::validate SILENTLY DROPS a key
-  // that literal does not declare rather than rejecting it. So the config
-  // written here reached makeOptions and was trimmed back to `prefix` on the
-  // way in, and prepareAuth read an `auth` map with no `in`, no `name` and
-  // no `basic` - measured on a generated client before the literal was
-  // extended. That literal now declares all three; changing only this file
-  // would have changed nothing a running SDK can see.
-  //
-  // Emitted ONLY when they differ from header/Authorization, so a
-  // header-based SDK's core/config.hpp is byte-identical to what it
-  // generated before. cpp has one representation - the chunked JSON literal
-  // rendered from this same def by cppConfigLiterals - so there is no second
-  // copy to keep in step.
   const authIn = resolveAuthIn(model)
   const authName = resolveAuthName(model)
 
@@ -435,16 +336,6 @@ inline FeaturePtr makeFeature(const std::string& name) {
 }
 `)
 
-    // The plugin-definitions accessor, EMITTED UNCONDITIONALLY so a caller
-    // can always ask, and EMPTY unless a plugin-bearing feature is active:
-    // each such feature's list lives in its generated
-    // feature/<name>/kinds.cpp (see FeaturePlugins above), which this
-    // dispatches to by name, so this header never names the vendored
-    // plugin's types - the list is type-erased (std::shared_ptr<void>; the
-    // feature casts back to plugin::DefinitionPtr), the way go returns
-    // []any and c void**. The per-feature function is an ordinary extern
-    // declaration here and in the feature header alike; kinds.cpp defines
-    // it, and the generated kinds.mk has the Makefile compile it.
     const plugged = Object.keys(pluginDefinitions(model, target)).sort()
 
     Content(`

package/project/.sdk/src/cmp/cpp/EntityTypes_cpp.ts

@@ -1,27 +1,5 @@
 
 
-// Typed-model generator (C++ target). Port of EntityTypes_ts.ts / _py.ts.
-//
-// The C++ SDK runtime is fully DYNAMIC: every op takes and returns the
-// JSON-like sdk::Value, so — unlike a statically typed target — there are no
-// generated structs the runtime consumes. This module emits a DOCUMENTATION
-// header, <sdk>_types.hpp, describing the shape of each entity and its per-op
-// request/match payloads as plain C++ structs in a dedicated `sdk::types`
-// namespace. They are convenience/reference types a consumer MAY use to model
-// payloads; the SDK itself neither includes nor requires this header, so it is
-// safe (it cannot affect the runtime or the test build).
-//
-// Field/param sentinels ($STRING, $INTEGER, ...) map to concrete C++ types via
-// the SHARED canonToType 'cpp' column (the single source of truth per language
-// — do not keep a local table here). Array surfaces as std::vector<Value>,
-// object as std::map<std::string, Value>, and any/null/unknown as the dynamic
-// sdk::Value. Optional (req:false) members are marked with a trailing
-// `// optional` comment — a struct member is always present in C++, so
-// key-optionality is documented rather than encoded.
-//
-// Keep the SAME type-name scheme as every other language: <Name>,
-// <Name>LoadMatch, <Name>ListMatch, <Name>CreateData, <Name>UpdateData,
-// <Name>RemoveMatch (via the shared opTypeName helper).
 
 import {
   cmp, each, names,
@@ -39,18 +17,11 @@ import {
 const LANG = 'cpp'
 
 
-// A valid C++ identifier for a struct member; non-identifier field names have
-// no safe struct-member rendering, so they are skipped (still reachable via the
-// runtime Value map).
 function cppIdent(name: string): boolean {
   return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name)
 }
 
 
-// Emit a struct named `typeName` from a list of {name, type, optional} items.
-// An item whose name is not a legal identifier is skipped (WITH a warning —
-// the key stays reachable via the runtime Value map, but its absence from the
-// typed model should be visible, not silent).
 function emitStruct(typeName: string, items: any[], log?: any): void {
   const usable = items.filter((it: any) => it && null != it.name && cppIdent(it.name))
 
@@ -101,11 +72,7 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
   // typed names. Filter on `name` (always present), NOT `active` — parity
   // with the go emitter's fix.
   const entityList = deriveEntityNames(entity)
-  // Derive the PascalCase Name up-front — it is set LAZILY by names().
 
-  // Surface duplicate generated type names (two entities with the same
-  // PascalCase Name) — they would redeclare a type in statically-typed
-  // targets. Detection only; renaming is a model-level decision.
   warnEntityTypeCollisions(entity, log, LANG)
 
   const guard = 'SDK_' + model.const.Name.toUpperCase().replace(/[^A-Z0-9]/g, '_') + '_TYPES_HPP'
@@ -142,13 +109,10 @@ namespace types {
       const fields = (ent.fields ? each(ent.fields) : [])
         .filter((f: any) => f.active !== false)
 
-      // Entity data model: one member per field, `req:false` -> optional.
       emitStruct(Name, fields.map((f: any) => ({
         name: f.name, type: f.type, optional: false === f.req,
       })), log)
 
-      // Per active op: a request/match type. Members and their optionality
-      // come from the shared partiality policy (opRequestShape).
       const ops = ent.op || {}
       ;['load', 'list', 'create', 'update', 'remove'].forEach((opname: string) => {
         if (null == ops[opname]) {

package/project/.sdk/src/cmp/cpp/Main_cpp.ts

@@ -38,28 +38,6 @@ const Main = cmp(async function Main(props: any) {
 
   const entity: ModelEntity = getModelPath(model, `main.${KIT}.entity`)
 
-  // THE PLUGIN TRIM FOR A FEATURE THAT IS ITSELF OFF (Main_c's and
-  // Main_scala's inactivePluginExcludes, for the same reason).
-  //
-  // pluginExcludes(model) below walks only the model's ACTIVE features, so
-  // a `secrets` declared `active: false` keeps every declared group's
-  // vendored kind file in the tree. For cpp that is not merely untidy: the
-  // Makefile decides whether to compile the plugin layer - and to link
-  // OpenSSL - from whether a KIND FILE is present under
-  // feature/secrets/plugins/, so the files have to go. Every declared group
-  // of an inactive feature goes, not only the groups marked inactive: a
-  // feature that is off has no active plugins whatever its `plugin` map
-  // says (targetFeatures drops it before Config ever reads a group). The
-  // feature's own header and the vendored cores are left to the Makefile's
-  // wiring gate (feature/secrets/kinds.cpp is generated only for an active
-  // feature; without it nothing of the feature is compiled, and
-  // core/config.hpp includes no feature/secrets.hpp) and to `target add`,
-  // which trims the whole container for a real project.
-  //
-  // Rooting matches pluginExcludes': cpp's declared paths are
-  // target-root-relative, which is this Copy's root, and the other
-  // targets' paths in the same list cannot match anything in a cpp tree
-  // (every pattern is anchored at its own extension).
   const feature = targetFeatures(model, target)
   const esc = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
   const allfeature = getModelPath(model, `main.${KIT}.feature`,
@@ -82,17 +60,6 @@ const Main = cmp(async function Main(props: any) {
 
   Gitignore({})
 
-  // Copy tm/cpp verbatim (with placeholder substitution). The tm src/ subtree
-  // only stages the per-feature custom-source dirs (target add), so exclude it.
-  //
-  // pluginExcludes: 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). cpp has
-  // `srcfeature: false`, so the per-feature Copy in cmp/Feature.ts - where
-  // pluginExcludesFor normally applies this trim - never runs for it, and
-  // this whole-tree Copy is the ONLY copy the target has: without the
-  // exclude an active secrets feature would ship every inactive kind, and
-  // the Makefile would compile and link them all (Main_go.ts precedent).
   Copy({
     from: 'tm/' + target.name,
     exclude: [/src\//, TEST_CONTROL_EXCLUDE,
@@ -138,20 +105,6 @@ const Main = cmp(async function Main(props: any) {
     })
   })
 
-  // utility/prepare_auth.hpp 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_cpp.
-  //
-  // cpp had no prepare_auth template to replace - the logic was EMBEDDED in
-  // tm/cpp/utility/pipeline.hpp. It now lives in its own header, which
-  // pipeline.hpp includes; register_all still binds
-  // `u.prepareAuth = util::prepareAuth`, so every call site is unchanged.
-  //
-  // AT ROOT LEVEL, and OUTSIDE the `core` Folder above. The component opens
-  // `utility` itself, mirroring where `Copy({from:'tm/cpp'})` lands
-  // utility/pipeline.hpp; calling it beside Config would write
-  // `core/utility/prepare_auth.hpp`, which pipeline.hpp's
-  // `#include "prepare_auth.hpp"` does not resolve.
   PrepareAuth({ target })
 
   // feature/<name>/kinds.cpp — the plugin definitions an active

package/project/.sdk/src/cmp/cpp/Package_cpp.ts

@@ -4,20 +4,6 @@ import {
 } from '@voxgig/sdkgen'
 
 
-// The C++ target ships a header-only SDK built by the tm/cpp Makefile (copied
-// verbatim); there is no package manifest to generate (unlike pom.xml /
-// Cargo.toml / go.mod). This component is a no-op kept for parity with the
-// other targets' Main -> Package call.
-//
-// The Makefile stays a TEMPLATE even now that the gated `secrets` feature
-// brings a multi-translation-unit payload: the Makefile names no feature
-// and reads `-include $(wildcard feature/*/kinds.mk)`, so the same verbatim
-// file is right for every model, and everything that differs per API -
-// which payload to compile, which suite to build, which kinds were
-// selected, whether OpenSSL is linked - is emitted by Config_cpp's
-// FeaturePlugins as feature/secrets/kinds.mk and kinds.cpp, not here. (c
-// makes the same choice; rust generates a module index instead because
-// cargo has no wildcard.)
 const Package = cmp(async function Package(_props: any) {
 })
 

package/project/.sdk/src/cmp/cpp/PrepareAuth_cpp.ts

@@ -16,52 +16,6 @@ import {
 } from '@voxgig/apidef'
 
 
-// WHERE THE CREDENTIAL GOES IS A FACT ABOUT THE API, so it is generated
-// rather than templated. This is the cpp peer of PrepareAuth_ts,
-// PrepareAuth_c and PrepareAuth_go; read PrepareAuth_ts first, it carries
-// 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, hardcoding
-//
-//   static const std::string HEADER_AUTH = "authorization";
-//
-// 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 fixed at generation
-// time. In cpp it also keeps the includes honest: the base64 encoder the
-// Basic branch needs (the cpp core ships none) is emitted only by the one
-// placement that can use it.
-//
-// CPP IS THE ONE TARGET WITH NO prepare_auth TEMPLATE TO DELETE. The logic
-// was EMBEDDED in `tm/cpp/utility/pipeline.hpp`, between preparePath and
-// transformRequest, and the extraction shape is the PREFERRED one rather
-// than the whole-module fallback:
-//
-//   - the SDK runtime is HEADER-ONLY, so "its own compilation unit" is its
-//     own HEADER — `utility/prepare_auth.hpp`. Nothing has to move to a
-//     .cpp, nothing new has to be compiled or linked, and the Makefile's
-//     `SDK_HDRS := $(wildcard ... utility/*.hpp ...)` already lists it as a
-//     rebuild dependency of every test binary.
-//
-//   - the BINDING is untouched. `prepareAuth` stays `inline SpecPtr
-//     prepareAuth(CtxPtr)` in `namespace sdk::util`; pipeline.hpp includes
-//     this header at the top (beside `../core/types.hpp`, outside any
-//     namespace) and its `register_all` still binds
-//     `u.prepareAuth = util::prepareAuth;`. Every call site therefore
-//     resolves exactly as before: `utility->prepareAuth(ctx)` in
-//     pipeline.hpp's own makeSpec, `u->prepareAuth(ctx)` in
-//     core/types.hpp, and `utility->prepareAuth(ctx)` in the shipped
-//     test/pipeline_test.cpp and test/primary_utility_test.cpp.
-//
-// Generating the whole of pipeline.hpp instead would have turned 1300 lines
-// of hand-maintained runtime — every other pipeline step, makeOptions, the
-// feature hooks — into a generator string literal to buy one function.
 const PrepareAuth = cmp(async function PrepareAuth(props: any) {
   const { target } = props
   const { model } = props.ctx$
@@ -72,20 +26,6 @@ const PrepareAuth = cmp(async function PrepareAuth(props: any) {
   const prefix = resolveAuthPrefix(model)
   const basic = isHttpBasicAuth(model)
 
-  // FOLDER NESTING. Main_cpp calls this at ROOT level — after the
-  // `Folder({name:'core'})` that wraps Config and client.hpp has closed —
-  // so `utility` is opened HERE and the file lands at
-  // `<root>/utility/prepare_auth.hpp`, the sibling of the
-  // `utility/pipeline.hpp` that `Copy({from:'tm/cpp'})` brings in and that
-  // `#include "prepare_auth.hpp"`s it by that relative name.
-  //
-  // The call site matters as much as the folder. Putting this beside Config
-  // would write `core/utility/prepare_auth.hpp`: pipeline.hpp's include
-  // would not resolve and the build would fail — loudly, which is the good
-  // case. The bad case is the ts port's: opening a redundant second folder
-  // (`src` there, `utility` here — `utility/utility/prepare_auth.hpp`)
-  // emits a file nothing includes while a stale copy keeps being compiled,
-  // and no test can see it.
   Folder({ name: 'utility' }, () => {
     File({ name: 'prepare_auth.' + target.ext }, () => {
       Content(render({ active, where, name, prefix, basic }))
@@ -94,31 +34,6 @@ const PrepareAuth = cmp(async function PrepareAuth(props: any) {
 })
 
 
-// NOT `isAuthActive`, AND THE DIFFERENCE IS LOAD-BEARING (the py port found
-// this first; six of the twelve ports found it independently).
-//
-// `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, and those SDKs are still expected to
-// honour an `apikey` the caller passes. `optspec` always declares `apikey`,
-// makeOptions fills `options.auth` from the optspec defaults, so the
-// template's `is_nullish(getp(options, "auth"))` guard never actually fired
-// and every such SDK has always sent `options.apikey`.
-//
-// 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 prepareAuth then
-// places nothing. This target has a lane that catches it: generatedcompile's
-// `cpp: auth null beats an explicit apikey` builds test/authnull_probe.cpp
-// against a fixture whose model says `main: kit: info: { ... auth: false }`
-// and requires the baseline `{apikey: 'OPTKEY01'}` to reach
-// `spec->headers["authorization"]`.
-//
-// 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 })
@@ -222,10 +137,6 @@ inline std::string authBase64(const std::string& in) {
 
 `
 
-  // The template's body, unchanged except for WHICH bag the credential
-  // lands in and under what name. Same option keys (`auth`, `apikey`,
-  // `auth.prefix`), same NOT_FOUND sentinel, same `skip` test, same
-  // `throw ctx->makeError("auth_no_spec", ...)`, same Group A reads.
   const preamble = `inline SpecPtr prepareAuth(CtxPtr ctx) {
   SpecPtr spec = ctx->spec;
   if (!spec) throw ctx->makeError("auth_no_spec", "Expected context spec property to be defined.");
@@ -298,15 +209,6 @@ ${place(spec.where)}
 }
 
 
-// COOKIE SPLICING. 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 pair is spliced in and out rather than the header assigned
-// over. Splicing also makes this idempotent: a retried request cannot end
-// up carrying the credential twice.
-//
-// `cred` is a parameter rather than a file-scope constant so the one
-// constant in this file stays where the template put it — a function-local
-// static inside prepareAuth.
 function cookieHelpers(): string {
   return `// The cookie header minus our own pair, every other cookie untouched.
 inline std::string authCookieRest(const Value& headers, const std::string& cred) {
@@ -361,35 +263,16 @@ inline void authCookieApply(const Value& headers, const std::string& cred,
 }
 
 
-// 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 this SDK's own header map is keyed in lowercase
-// throughout — `content-type` in makeSpec, the `authorization` the shipped
-// test/pipeline_test.cpp and test/primary_utility_test.cpp assert on, the
-// `authorization` feature/secrets.hpp injects and retracts, and the
-// `authorization` generatedcompile's cpp auth-null probe reads — while the
-// template this replaces said `"authorization"` outright. apidef writes
-// `name: "Authorization"`, so emitting the resolver's value verbatim would
-// put the credential under a key nothing in this runtime reads.
-//
-// 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)
 }
 
 
-// The bag the credential lands in, per placement. It is both the local
-// variable name and the Spec field, which in cpp are spelled the same
-// (spec->headers / spec->query). Cookies ride the header bag because a
-// cookie IS a header.
 function bagName(where: string): string {
   return 'query' === where ? 'query' : 'headers'
 }
 
 
-// Drop any stale credential.
 function clear(where: string, indent: number): string {
   const pad = ' '.repeat(indent)
 
@@ -403,22 +286,14 @@ function clear(where: string, indent: number): string {
 
 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. makeUrl appends
-    // spec->query to the URL after this runs, so the parameter reaches the
-    // wire escaped by the same escurl every other query parameter uses.
     return `    map_put(query, CRED_NAME, Value(apikey.is_string() ? apikey.as_string() : ""));`
   }
 
   if ('cookie' === where) {
-    // NO PREFIX IN A COOKIE either — a cookie carries a bare `name=value`
-    // pair, not a header's scheme-prefixed credential.
     return `    authCookieApply(headers, CRED_NAME,
       apikey.is_string() ? apikey.as_string() : "", false);`
   }
 
-  // The template's header body, unchanged.
   return `    std::string authPrefix = as_str(Struct::getpath(options, {"auth", "prefix"}));
     std::string apikeyVal = apikey.is_string() ? apikey.as_string() : "";
     // A raw credential (empty prefix, e.g. an apiKey scheme) must go in

package/project/.sdk/src/cmp/cpp/ReadmeExamplesTest_cpp.ts

@@ -2,25 +2,6 @@
 import { cmp, Content, File } from '@voxgig/sdkgen'
 
 
-// Emits test/readme_examples_test.cpp — a structural gate over every ```cpp
-// fenced block in the docs that ship C++ examples:
-//   - the root README.md          (top-level, multi-language quick start)
-//   - the per-language cpp/README.md
-//   - the per-language cpp/REFERENCE.md
-//
-// DESIGN NOTE (mirrors ReadmeExamplesTest_c): the go gate shells out to
-// `go build`/`go run` to COMPILE and RUN every block. A faithful C++ port
-// would extract each snippet, wrap it in a translation unit, and drive the
-// bundled Makefile / c++ against the header-only runtime — a large,
-// environment-sensitive harness that cannot be authored safely here. This gate
-// instead validates that every documented C++ block is PRESENT and
-// STRUCTURALLY well-formed (balanced ()[]{}, non-empty). It is a real,
-// always-passing test that keeps the docs honest about block structure;
-// upgrading it to a true compile gate is left as a follow-up. Missing docs are
-// tolerated (a run may generate a subset of phases).
-//
-// The test binary runs with the C++ project root as its working directory, so
-// the doc paths resolve as "README.md", "REFERENCE.md", and "../README.md".
 const ReadmeExamplesTest = cmp(function ReadmeExamplesTest(props: any) {
   const { model } = props.ctx$
 

package/project/.sdk/src/cmp/cpp/ReadmeQuick_cpp.ts

@@ -67,7 +67,6 @@ ${ctor}
   if (exampleEntity) {
     const eName = nom(exampleEntity, 'Name')
     const article = /^[aeiou]/i.test(eName) ? 'an' : 'a'
-    // The client accessor is the entity's snake_case name (client->planet()).
     const acc = cppVarName(exampleEntity.name)
     const eVar = acc
     const opnames = entityOps(exampleEntity)
@@ -135,8 +134,6 @@ try {
 `)
     }
     else if (opnames.includes('load')) {
-      // Every REQUIRED load-match key (id first, then parent path params like
-      // page_id) — the same shape the runtime resolves path params from.
       const loadRequired = opRequestShape(exampleEntity, 'load').items
         .filter((it: any) => !it.optional || it.name === idF)
         .sort((a: any, b: any) =>
@@ -163,8 +160,6 @@ try {
 `)
     }
 
-    // Model-driven example fields: derive the create/update body from the op
-    // shape (opRequestShape) so the docs reference REAL writable fields.
     const examplePairs = (opname: string): string[] => {
       const items = opRequestShape(exampleEntity, opname).items
         .filter((it: any) => (it.name !== idF && it.name !== 'id') ||
@@ -208,8 +203,6 @@ client->${acc}()->update(vmap({${updatePairs.join(', ')}}), Value::undef());
 `)
       }
       if (opnames.includes('remove')) {
-        // Every REQUIRED remove-match key: the id (off the created record
-        // when possible) plus parent keys like page_id.
         const removePairs = opRequestShape(exampleEntity, 'remove').items
           .filter((it: any) => !it.optional || it.name === idF)
           .sort((a: any, b: any) =>

package/project/.sdk/src/cmp/cpp/ReadmeRef_cpp.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 {
@@ -57,7 +57,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)
 
@@ -375,9 +375,6 @@ auto client = std::make_shared<${model.const.Name}SDK>(vmap({
 \`\`\`
 
 `)
-      // 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 })
     }