@voxgig/sdkgen 4.21.0 → 4.22.0

package/project/.sdk/model/target/zig.aon

@@ -8,15 +8,6 @@ main: kit: target: zig: {
   base: 'BASE'
   srcfeature: false
 
-  # Applicability (docs/design/feature-tags.md): the `secrets` feature is a
-  # thin layer over a VENDORED sekreto port and declares `needs: { sekreto:
-  # true }`; a target that does not say it carries one never gets the
-  # feature. This target does: tm/zig/feature/secrets/{sekreto,plugin,
-  # plugins} are the zig ports of @voxgig/sekreto and voxgig/plugin at the
-  # shared vendor tag, wired as the named build modules `sekreto`, `plugin`
-  # and `sekretoplugins` by the generated build.zig (Main_zig) - and ONLY
-  # when the feature is active, so an SDK without secrets declares none of
-  # them and compiles nothing of it. Mirrors ts.aon / go.aon / rust.aon.
   provides: { sekreto: true, schema: true }
 
   # Files earlier toolchains generated that this target has RETIRED
@@ -41,27 +32,6 @@ main: kit: feature: &: target: zig: deps: &: {
 }
 
 
-# Publication: Zig has no central registry — publishing IS the git tag.
-# The `registry: { state:'pending', name:'none' }` placeholder (same as c/cpp)
-# routes deploy-zig to the root tag-push recipe. WITHOUT it, Deploy.ts falls
-# through to `make -C zig publish` — but zig's Makefile has no `publish` target,
-# so the deploy fails. Mirror c.aon exactly.
-#
-# `target add <t>` OVERWRITES this file, so a project must never set its
-# publication values here — voxgig-solardemo-sdk lost its pinned npm package
-# name exactly that way. Set them in the project's own overlay
-# (`model/project.aon`), which create-sdkgen creates once and never
-# overwrites — NOT `model/sdk.aon`, which it rewrites on every scaffold.
-#
-# For that to work this file must LEAVE THOSE KEYS UNSET: in aontu a concrete
-# value does not yield to another concrete value, it CONFLICTS, and two
-# defaults conflict too. The schema (@voxgig/sdkgen/model/sdkgen.aon)
-# already defaults `tag.active`, `registry.state`, `registry.active` and
-# `registry.package`, so a project's concrete value wins over the default and
-# repeating them here would only take that away.
-#
-# What remains below is per-target registry IDENTITY, which is not a project
-# choice and stays concrete.
 main: kit: target: zig: publish: {
   registry: {
     name: 'none'
@@ -71,26 +41,6 @@ main: kit: target: zig: publish: {
 }
 
 
-# Feature source is NOT trimmed to the model's selection here: root.zig
-# re-exports every BUILT-IN feature type with @import("feature/<name>.zig"),
-# and build.zig names test/feature_test.zig explicitly, so a trimmed tree
-# fails to build. Trimming stays off until those static exports are driven
-# from the model too.
-#
-# THE FORCING CASE is `secrets`, the first GATED feature this target
-# carries. With the trim off, its whole tree - feature/secrets.zig, the
-# vendored sekreto and voxgig/plugin cores and the provider plugins - ships
-# in EVERY zig SDK whatever the model says. What keeps that honest is that
-# zig compiles only what a module root reaches, so the generated build.zig
-# and root.zig (Main_zig, from the marker-slotted fragments) name the
-# feature's modules, its root export and its test step ONLY when the
-# feature is active: a secrets-off SDK carries the files as dead weight and
-# compiles none of them, and `make lint` (`zig fmt --check .`) is the one
-# gate that still reads them. Main_zig also drops the provider plugins of
-# an INACTIVE feature and the inactive groups of an active one (the scala
-# shape), so the dead weight is the two cores plus the ungrouped
-# httpjson/sigv4 helpers, never the nine vault clients. When the feature
-# trim lands here, that second exclude list becomes redundant, not wrong.
 main: kit: target: zig: feature: {
   trim: false
 }

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

@@ -29,25 +29,6 @@ import {
 } from './utility_c'
 
 
-// PLUGIN DEFINITIONS PER FEATURE (the c peer of Config_go's featurePlugins
-// map and Main_rust's generated plugins.rs).
-//
-// Upstream sekreto retired its self-registration registry for voxgig/plugin
-// definitions: a provider kind the caller did not pass in `sek_options.
-// 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 constructor symbol (`def: c:` in model/feature/secrets.aon
-// - `sek_plugin_hashicorp`, the `Definition *(void)` each vendored kind
-// file defines) 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.
-//
-// 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.c - which the Makefile reads as the feature's
-// WIRING - would not be emitted).
 function pluginDefinitions(model: Model, target: any):
   Record<string, { syms: string[], groups: number }> {
   const out: Record<string, { syms: string[], groups: number }> = {}
@@ -78,39 +59,6 @@ function pluginDefinitions(model: Model, target: any):
 }
 
 
-// feature/<name>/kinds.c - GENERATED, one per plugin-bearing active feature.
-//
-// It cannot live in core/config.c: that translation unit must not name the
-// vendored voxgig/plugin's `Definition` type, which is why sdk.h types the
-// accessor as void** (the same reason go hides its list behind []any). 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/c/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 a payload needs from the
-// build is stated here, from the model: the vendored cores to compile, the
-// suite to run, and - only when a plugin group is active - the plugin layer
-// with the external libraries it brings. A tree whose model never
-// activated the feature has no fragment, compiles none of the payload and
-// links libc 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 c
-// core ships no HTTP client (utility/fetcher.c), and the decision for this
-// target is to bundle one INSIDE the gated feature: libcurl, compiled in
-// only when a plugin group is active, so that an SDK without secrets - or
-// with secrets and a chain of built-ins - still ships zero external
-// dependencies. The Makefile adds -lcurl on the same condition (a kind file
-// present), so the two cannot disagree. With no group active the exchange
-// still works through a caller-supplied options.system.fetch, which every
-// live c 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
@@ -124,11 +72,6 @@ const FeaturePlugins = cmp(async function FeaturePlugins(props: any) {
       const { syms, groups } = defs[fname]
 
       Folder({ name: fname }, () => {
-        // The build wiring (see above). Paths are SDK-root-relative, as the
-        // Makefile's own globs are. `feature/<name>.c` is NOT listed: the
-        // Makefile's feature/*.c glob already compiles every feature's own
-        // file, and its headers are on INC through the generic payload
-        // -I paths.
         File({ name: 'kinds.mk' }, () => {
           Content(`# Generated beside kinds.c: what the \`${fname}\` feature needs from the
 # build, read by the Makefile through \`-include $(wildcard feature/*/kinds.mk)\`.
@@ -365,12 +308,6 @@ const Config = cmp(async function Config(props: any) {
   let baseUrl = ''
   try { baseUrl = getModelPath(model, `main.${KIT}.info.servers.0.url`) } catch (_e) { }
 
-  // The same config as an OBJECT, built by the shared helper so this target's
-  // literal and the data that replaces it above the threshold are the same
-  // config by construction. The JSON is what the threshold is measured on -
-  // emitted source size varies by language, the model does not. Passing
-  // target.name opts this target into the main slug/version/target identity
-  // fields (read by station's descriptor - see configDefinition).
   const { def: configDef, json: configJson } = configDefinition(model, target.name)
   const asData = isConfigData(configJson, configReprSetting(model))
 
@@ -402,12 +339,6 @@ const Config = cmp(async function Config(props: any) {
     }
   }
 
-  // configDefinition's `def.entity` verbatim, NOT rebuilt here. This reduce
-  // was one of fourteen copies of that function's entityDefs loop, and when
-  // configDefinition started reconstructing a point's `parts` from apidef's
-  // segment vector (its ADR-003), only the copies that read `configDef` got
-  // it — this target's literal config emitted paths with no parts at all
-  // while its data config had them. One rule, one place.
   const entityConfig = configDef.entity
 
   const config = {
@@ -422,15 +353,6 @@ const Config = cmp(async function Config(props: any) {
 
   File({ name: 'config.c' }, () => {
 
-    // ABOVE THE THRESHOLD: emit the model as DATA.
-    //
-    // The literal is a single nested `cmap(...)`/`clist(...)` expression. For a
-    // real model that is one function whose expression nests hundreds of
-    // thousands of calls deep - the shape that makes a C compiler's parser and
-    // register allocator quadratic, and the reason gcc can be seen taking
-    // minutes on a generated config. A string constant is one token, and
-    // `json_parse` (declared in sdk.h, reached through api.h) builds the same
-    // voxgig_value tree at runtime.
     if (asData) {
       Content(`// Generated API configuration (mirrors core/config.go).
 
@@ -509,28 +431,12 @@ voxgig_value* shared_config(void) {
 `)
     }
 
-    // Dispatch to the features the MODEL declares, and only those.
-    //
-    // This used to merge in a hardcoded list of every feature the C target
-    // ships, on the reasoning that the runtime templates
-    // (tm/c/feature/*.c) are always present. `target add` now trims feature
-    // source to the model's selection, so that reasoning is false: a
-    // reference to `feature_timeout_new` for an undeclared feature is an
-    // unresolved symbol at LINK time — the whole test suite fails to link,
-    // which is how this was found. Sorted for byte-stability.
     const featureNames = new Set<string>()
     each(feature, (f: any) => {
       if (f.name && f.name !== 'base') featureNames.add(f.name)
     })
     const sortedNames = Array.from(featureNames).sort()
 
-    // Constructor prototypes for every declared feature. sdk.h declares the
-    // BUNDLED set, but an externally-installed feature (e.g. station, whose
-    // source arrives by package overlay) is not in sdk.h — and without a
-    // prototype its make_feature arm is an implicit int-returning
-    // declaration: a warning that happens to link on gcc 13, a hard error on
-    // gcc 14+/clang 15+. Redeclaring the bundled ones is identical-prototype
-    // C, which is legal and keeps this a single sorted list.
     Content(`
 `)
     for (const fname of sortedNames) {
@@ -550,12 +456,6 @@ Feature* make_feature(const char* name) {
 }
 `)
 
-    // The plugin-definitions accessor (sdk.h feature_plugins), EMITTED
-    // UNCONDITIONALLY so the prototype in sdk.h always has a definition,
-    // and EMPTY unless a plugin-bearing feature is active: each such
-    // feature's list lives in its generated feature/<name>/kinds.c (see
-    // FeaturePlugins above), which this dispatches to by name, so this
-    // translation unit never names the vendored plugin's types.
     const plugged = Object.keys(pluginDefinitions(model, target)).sort()
 
     Content(`

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

@@ -1,31 +1,5 @@
 
 
-// Typed-model generator (C target). Port of EntityTypes_rust.ts / _go.ts.
-//
-// Reads main.<KIT>.entity.<e>.fields[] and per-op params
-// (op.<name>.points[].args.params[]) and emits one header, entity/types.h,
-// with a C `typedef struct { ... } <Name>;` per entity plus a request/match
-// struct per active op. Field/param sentinels ($STRING, $INTEGER, ...) map to
-// C types via the SHARED canonToType 'c' column (the single source of truth
-// per language — do not keep a local table here).
-//
-// DESIGN NOTE (C specifics vs the rust/go reference):
-//   * The C runtime is fully DYNAMIC: every op takes and returns the vendored
-//     `voxgig_value*` (with a trailing PNError** out-param), and the entity
-//     fragments emit no typed wrappers. These structs are therefore
-//     DOCUMENTARY — they mirror the entity/op shapes for reference and IDE
-//     support, but nothing in the runtime consumes them. types.h is a
-//     standalone header (guarded, includes sdk.h for the primitive types); it
-//     is not #included by any generated .c, so it never affects the build.
-//   * C has no Option<T> / optional struct members: a `req:false` field is
-//     still declared, with a trailing `// optional` marker. Absence is
-//     represented at runtime by the value simply not being present in the map.
-//   * Member names are snake_case + keyword-safe via cVarName; duplicate
-//     idents are dropped so a struct never declares the same member twice.
-//
-// Keep the SAME type-name scheme as every other language: <Name>,
-// <Name>LoadMatch, <Name>ListMatch, <Name>CreateData, <Name>UpdateData,
-// <Name>RemoveMatch.
 
 import {
   cmp, each,
@@ -54,10 +28,6 @@ function memberLine(name: string, sentinel: any, optional: boolean): string {
 }
 
 
-// Emit a `typedef struct { ... } <typeName>;` from {name, type, optional}
-// items, dropping duplicate C identifiers (two model names can collapse to
-// one ident). An empty shape gets a placeholder member (a struct with no
-// members is not valid ISO C).
 function emitStruct(comment: string, typeName: string, items: any[]): void {
   Content(`${comment}
 typedef struct {
@@ -95,9 +65,6 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
   // with the go/rust emitters' fix).
   const entityList = deriveEntityNames(entity)
 
-  // 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 = String(model.const.Name).toUpperCase().replace(/[^A-Z0-9_]/g, '_') + '_ENTITY_TYPES_H'
@@ -129,15 +96,12 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
         const fields = (ent.fields ? each(ent.fields) : [])
           .filter((f: any) => f.active !== false)
 
-        // Entity data model: one member per model field. req:false -> optional.
         emitStruct(
           `// ${Name} is the typed data model for the ${ent.name} entity.`,
           Name,
           fields.map((f: any) => ({ name: f.name, type: f.type, optional: false === f.req }))
         )
 
-        // Per active op: a request/match struct. 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/c/Main_c.ts

@@ -37,26 +37,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_scala's
-  // inactivePluginExcludes, for the same reason one target over).
-  //
-  // 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 c that is not merely untidy: the
-  // Makefile decides whether to compile the plugin layer - and to link
-  // OpenSSL and libcurl - 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 source and the vendored cores are left to the Makefile's
-  // wiring gate (feature/secrets/kinds.c is generated only for an active
-  // feature; without it nothing of the feature is compiled) and to
-  // `target add`, which trims the whole container for a real project.
-  //
-  // Rooting matches pluginExcludes': c'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 c tree.
   const feature = targetFeatures(model, target)
   const esc = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
   const allfeature = getModelPath(model, `main.${KIT}.feature`,
@@ -79,17 +59,6 @@ const Main = cmp(async function Main(props: any) {
 
   Gitignore({})
 
-  // Copy tm/c files with replacements. The tm src/ subtree only stages the
-  // per-feature custom-source dirs (target add), so it is excluded here.
-  //
-  // 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). c 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\//, ...pluginExcludes(model), ...inactivePluginExcludes],
@@ -113,7 +82,6 @@ const Main = cmp(async function Main(props: any) {
           }
         },
 
-        // Entity accessors — injected at SLOT.
         () => {
           each(entity, (entity: ModelEntity) => {
             MainEntity({ target, entity })
@@ -126,18 +94,6 @@ const Main = cmp(async function Main(props: any) {
     Schema({ target })
   })
 
-  // utility/prepare_auth.c 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_c.
-  //
-  // AT ROOT LEVEL, and OUTSIDE the `core` Folder above. c's layout is flat at
-  // the target root (core/, utility/, feature/, entity/, tests/), the template
-  // this replaces lived at `tm/c/utility/prepare_auth.c`, and the whole-tree
-  // `Copy({from:'tm/c'})` landed it at `<root>/utility/`. The component opens
-  // `utility` itself, so calling it beside Config - inside `Folder({name:
-  // 'core'})` - would emit `core/utility/prepare_auth.c`, which the Makefile's
-  // `$(wildcard core/*.c utility/*.c ...)` does not match: nothing would
-  // compile it and `prepare_auth_util` would be unresolved at link time.
   PrepareAuth({ target })
 
   // feature/<name>/kinds.c — the plugin definitions an active plugin-bearing

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

@@ -4,21 +4,7 @@ import {
 } from '@voxgig/sdkgen'
 
 
-// C has no package manifest — the build is driven by the template Makefile
-// (tm/c/Makefile, copied verbatim). Package is a no-op for the C target,
-// kept so the Main component can call it uniformly across targets.
-//
-// This is also why the secrets feature's build model is not emitted from
-// here, unlike Package_rust's rustls dependency table or Package_swift's
-// targets: the Makefile is feature-agnostic (a trimmed template tree must
-// name no feature) and `-include`s a GENERATED feature/<name>/kinds.mk that
-// Config_c emits only when the model activates the feature for this
-// target - the vendored payload to compile, the suite to run, and the
-// plugin layer with its OpenSSL and libcurl only when a plugin group is
-// active. Nothing here has to restate the model's choice, so nothing here
-// can drift from it.
 const Package = cmp(async function Package(_props: any) {
-  // intentionally empty
 })
 
 

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

@@ -17,27 +17,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 c peer of PrepareAuth_ts and
-// PrepareAuth_go; read PrepareAuth_ts first, it carries the full account of
-// the defect.
-//
-// This was a static file at `tm/c/utility/prepare_auth.c` that hardcoded
-//
-//   #define HEADER_AUTH "authorization"
-//
-// apidef has always resolved the scheme's `in` and `name` into
-// `main.kit.info.security` — joplin's says `in: "query", name: "token"` —
-// and generation dropped both, so the SDK sent a header the API does not
-// read and never sent the query parameter it does.
-//
-// A template cannot fix this, because the three placements need three
-// different bodies and a template has to pick one. A component emits the
-// branch this API actually uses and nothing else — no dead query code in a
-// bearer-token SDK, and no runtime `if` on a value fixed at generation
-// time. In c that also keeps the includes honest: `<stdio.h>` is pulled in
-// only by the placements that actually call snprintf, and the base64
-// encoder only by the one placement that can use it.
 const PrepareAuth = cmp(async function PrepareAuth(props: any) {
   const { target } = props
   const { model } = props.ctx$
@@ -48,19 +27,6 @@ const PrepareAuth = cmp(async function PrepareAuth(props: any) {
   const prefix = resolveAuthPrefix(model)
   const basic = isHttpBasicAuth(model)
 
-  // FOLDER NESTING. Main_c opens NO folder around this call, so `utility` is
-  // opened HERE and the file lands at `<root>/utility/prepare_auth.c` —
-  // exactly where `Copy({from:'tm/c'})` used to land the template, which is
-  // what the Makefile's `$(wildcard core/*.c utility/*.c ...)` compiles and
-  // what `core/sdk.h` declares `prepare_auth_util` for.
-  //
-  // The call site matters as much as the folder. Config_c is inside
-  // `Folder({name:'core'})`, and putting PrepareAuth beside it would write
-  // `core/utility/prepare_auth.c` — a path no glob in the Makefile matches,
-  // so nothing would compile it, `prepare_auth_util` would be an unresolved
-  // symbol at link time, and any stale `utility/prepare_auth.c` left in the
-  // tree would keep being the one that runs. Main_c calls this at ROOT
-  // level, after the `core` Folder closes.
   Folder({ name: 'utility' }, () => {
     File({ name: 'prepare_auth.c' }, () => {
       Content(render({ active, where, name, prefix, basic }))
@@ -69,28 +35,6 @@ const PrepareAuth = cmp(async function PrepareAuth(props: any) {
 })
 
 
-// NOT `isAuthActive`, AND THE DIFFERENCE IS LOAD-BEARING (the py port found
-// this first, php's lane proved it, and c's lane proves it again here).
-//
-// `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. The template placed the credential
-// unconditionally, so they did.
-//
-// Gating the body on `isAuthActive` therefore does not trim dead code, it
-// deletes working authentication. MEASURED, not assumed: with the wider gate
-// this component emitted the no-op for generatedcompile's own fixture
-// (`main: kit: info: { ... auth: false }`) and the c lane went red -
-//
-//   c: auth null beats an explicit apikey
-//     FAIL: baseline broken: an ordinary apikey was not sent
-//
-// So the no-op is emitted only when the PROJECT says so:
-// `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 })
@@ -109,10 +53,6 @@ type AuthSpec = {
 
 function render(spec: AuthSpec): string {
 
-  // AUTH SWITCHED OFF BY THE PROJECT (see authSwitchedOn for why only an
-  // EXPLICIT switch counts). The SDK gets a prepare_auth that is honest
-  // about it rather than one that deletes a header nobody set. Nothing
-  // beyond sdk.h is included: this body calls neither snprintf nor strcmp.
   if (!spec.active) {
     return `// prepare_auth utility (mirrors utility/prepare_auth.rs).
 //
@@ -144,8 +84,6 @@ Spec* prepare_auth_util(Context* ctx, PNError** err) {
   // it can mean something.
   const withBasic = spec.basic && 'header' === spec.where
 
-  // snprintf is used by every placement except query, which writes the raw
-  // credential straight in.
   const withStdio = 'query' !== spec.where
 
   const bag = bagName(spec.where)
@@ -283,19 +221,6 @@ ${place(spec.where)}
 }
 
 
-// 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 make_spec.c, and the `authorization` that
-// the shipped tests/pipeline_test.c asserts on - while the template this
-// replaces said `"authorization"`. Emitting the resolver's title-cased
-// default here would have left every header SDK's own suite failing on a
-// purely cosmetic difference. (PrepareAuth_go reaches the same conclusion
-// for the same reason.)
-//
-// 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)
 }
@@ -310,9 +235,6 @@ function bagName(where: string): string {
 }
 
 
-// Drop any stale credential. voxgig_delprop takes a voxgig_value* key, so
-// the key is built and released around the call - the template's idiom,
-// kept verbatim.
 function clear(where: string, indent: number): string {
   const pad = ' '.repeat(indent)
   return `${pad}voxgig_value* k = voxgig_new_string(CRED_NAME);
@@ -323,17 +245,11 @@ ${pad}voxgig_release(k);`
 
 function place(where: string): string {
   if ('query' === where) {
-    // NO PREFIX IN A QUERY STRING. `?token=Bearer%20abc` is not a thing any
-    // API reads; the prefix is a header convention and is dropped here
-    // deliberately rather than silently concatenated.
     return `    const char* apikey_val = voxgig_is_string(apikey) ? voxgig_as_string(apikey) : "";
     setp(query, CRED_NAME, v_str(apikey_val));`
   }
 
   if ('cookie' === where) {
-    // Append, never replace: the cookie header may already carry pairs this
-    // SDK did not set, and clobbering it would drop them. No prefix either -
-    // a cookie is `name=value`, not `name=Bearer value`.
     return `    const char* apikey_val = voxgig_is_string(apikey) ? voxgig_as_string(apikey) : "";
     const char* existing = get_str(headers, COOKIE_HEADER);
     char buf[2048];
@@ -345,7 +261,6 @@ function place(where: string): string {
     setp(headers, COOKIE_HEADER, v_str(buf));`
   }
 
-  // The template's header body, unchanged.
   return `    voxgig_value* prefix_v = getpath2(options, "auth", "prefix");
     const char* auth_prefix = voxgig_is_string(prefix_v) ? voxgig_as_string(prefix_v) : "";
     const char* apikey_val = voxgig_is_string(apikey) ? voxgig_as_string(apikey) : "";

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

@@ -2,26 +2,6 @@
 import { cmp, Content, File } from '@voxgig/sdkgen'
 
 
-// Emits tests/readme_examples_test.c — a structural gate over every ```c
-// fenced block in the docs that ship C examples:
-//   - the root README.md          (top-level, multi-language quick start)
-//   - the per-language c/README.md
-//   - the per-language c/REFERENCE.md
-//
-// DESIGN NOTE vs the go gate (ReadmeExamplesTest_go.ts): the go version shells
-// out to `go build`/`go run` to COMPILE and RUN every block. A faithful C port
-// would extract each snippet, wrap it in a translation unit, and drive the
-// bundled Makefile / cc against the generated libsdk.a — a large,
-// environment-sensitive harness that cannot be authored safely without a build
-// to validate it. This C 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 (the
-// Makefile invokes `./tests/<name>.out` from there), 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/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)
 
@@ -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$