@voxgig/sdkgen 4.21.0 → 4.23.0

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

@@ -2,22 +2,6 @@
 import { cmp, Content } from '@voxgig/sdkgen'
 
 
-// Emit a documentation clojure-examples SYNTAX gate INTO the shared gentest run
-// body (the clojure test runner drives a single sdk.gentest/run). For each doc
-// that ships clojure examples — the repository ROOT README.md, the per-language
-// README.md, and REFERENCE.md — every ```clojure fenced block is extracted and
-// PARSED with read-string (all forms wrapped in a vector), catching a malformed
-// documented example (an unbalanced paren, a bad token, an unclosed string).
-//
-// SCOPE NOTE: like the elixir gate, this stops at the syntax check rather than
-// EXECUTING each block. Running a README fragment against the generated
-// namespaces would need the SDK loaded and the narrative requires resolved for
-// every block; the syntax gate is a real, useful guard that keeps documented
-// examples parseable as the generator evolves. A doc that is absent at test
-// time is skipped (passes), so the gate never hard-fails on a missing file.
-//
-// The emitted clojure builds the triple-backtick fence from (char 96) so this
-// TS template literal needs no embedded backticks.
 const ReadmeExamplesTest = cmp(function ReadmeExamplesTest(_props: any) {
 
   Content(`  (letfn [(fence-pat [] (re-pattern (apply str (repeat 3 (char 96)))))

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

@@ -122,13 +122,13 @@ On error, \`ok\` is \`false\` and \`err\` contains the error value.
 
 `)
   each(entityList, (ent: any) => {
-    const fields = ent.fields || []
+    const fields = Object.values(ent.fields || {})
     const opnames = Object.keys(ent.op || {})
     const ops = ent.op || {}
     const points = each(ops).map((op: any) =>
       op.points ? each(op.points) : []
     ).flat()
-    const path = points.length > 0 ? (points[0] as any).orig || '' : ''
+    const path = points.length > 0 ? (points[0] as any).o || '' : ''
 
     Content(`#### ${ent.Name}
 
@@ -136,7 +136,7 @@ On error, \`ok\` is \`false\` and \`err\` contains the error value.
 | --- | --- |
 `)
     each(fields, (field: any) => {
-      Content(`| \`${field.name}\` | ${field.short || ''} |
+      Content(`| \`${field.n}\` | ${field.sh || ''} |
 `)
     })
 

package/project/.sdk/src/cmp/clojure/ReadmeRef_clojure.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 {
@@ -66,7 +66,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)
 
@@ -174,7 +174,7 @@ Prepare a fetch definition without sending. Returns the \`fetchdef\` and raises
     // Entity reference sections
     publishedEntities.map((ent: any) => {
       const opnames = Object.keys(ent.op || {})
-      const fields = ent.fields || []
+      const fields = Object.values(ent.fields || {})
       // Model-driven id key: null when this entity has no id-like field.
       const idF = entityIdField(ent)
       const eLow = ent.name
@@ -209,9 +209,9 @@ Prepare a fetch definition without sending. Returns the \`fetchdef\` and raises
 | --- | --- | --- | --- |
 `)
         each(fields, (field: any) => {
-          const req = field.req ? 'Yes' : 'No'
-          const desc = field.short || ''
-          Content(`| \`${field.name}\` | \`${cljType(field.type)}\` | ${req} | ${desc} |
+          const req = field.r ? 'Yes' : 'No'
+          const desc = field.sh || ''
+          Content(`| \`${field.n}\` | \`${cljType(field.t)}\` | ${req} | ${desc} |
 `)
         })
 
@@ -236,7 +236,7 @@ Prepare a fetch definition without sending. Returns the \`fetchdef\` and raises
               if (fop.active === false) return '-'
               return 'Yes'
             })
-            Content(`| \`${field.name}\` | ${cols.join(' | ')} |
+            Content(`| \`${field.n}\` | ${cols.join(' | ')} |
 `)
           })
 
@@ -397,9 +397,6 @@ Features are activated via the \`feature\` option:
 \`\`\`
 
 `)
-      // 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/clojure/Schema_clojure.ts

@@ -17,26 +17,6 @@ import {
 } from './utility_clojure'
 
 
-// THE GENERATED SCHEMA NAMESPACE: the model's schemas, as data the SDK runs.
-//
-// The clojure peer of src/cmp/ts/Schema_ts.ts. Same source — OPTSPEC from
-// `main.kit.optspec` plus each feature's own `config.options`, ENTITYSPEC
-// from the entity field sentinels — built by the shared helpers, so what
-// clojure validates against and what ts validates against cannot drift.
-//
-// DATA ONLY, AND THAT IS STRUCTURAL. This namespace requires nothing and
-// exposes the raw JSON strings; `sdk.core` parses them. The parse it would
-// otherwise call, `json-parse`, is defined in sdk.core itself — and sdk.core
-// is what reads the spec — so a schema ns that required core to parse its own
-// data would close a require cycle. Holding the strings here and parsing
-// there is the only arrangement that does not.
-//
-// Chunked the way config.clj chunks its model: the JVM caps a string literal
-// at 64KB, so `cljStringChunks` splits and `str` rejoins at load.
-//
-// 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$
   const target = props.target
@@ -53,7 +33,7 @@ const Schema = cmp(async function Schema(props: any) {
     Content(`;; ${model.const.Name} ${target.Name} SDK: generated schemas. Do not edit.
 ;;
 ;; Generated from the model: main.kit.optspec and each feature's
-;; config.options for the option spec; entity fields[].type for the entity
+;; config.options for the option spec; entity fields{}.type for the entity
 ;; specs. Parsed by sdk.core — see the note in Schema_clojure.ts for why the
 ;; parse cannot live here.
 (ns sdk.schema)

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

@@ -6,12 +6,6 @@ import {
 } from '@voxgig/sdkgen'
 
 
-// Emit per-entity direct()/prepare() checks INTO the shared gentest run body
-// (the clojure test runner drives a single sdk.gentest/run). Only entities
-// with a read op get a check — matching the py/elixir TestDirect gate — so an
-// op-less entity does not fabricate a request path. The checks exercise the
-// raw-HTTP escape hatch: prepare() builds a fetchdef without sending, and
-// direct() runs a live-mode client against an in-test mock system.fetch.
 const TestDirect = cmp(function TestDirect(props: any) {
   const { model } = props.ctx$
   const entity = props.entity

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

@@ -2,13 +2,6 @@
 import { cmp, Content } from '@voxgig/sdkgen'
 
 
-// Emit per-entity model-driven checks INTO the shared gentest run body (the
-// clojure test runner drives a single sdk.gentest/run). Covers: entity
-// accessor existence, a create+list smoke run through the in-memory test-mode
-// mock transport (exercising the full operation pipeline, hooks and run-op),
-// and the streaming entity fn. API-agnostic behaviour (pipeline error
-// branches, all features, netsim, primary utility, struct corpus) lives in the
-// static template test namespaces.
 const TestEntity = cmp(function TestEntity(props: any) {
   const e = props.entity
 
@@ -46,9 +39,6 @@ const TestEntity = cmp(function TestEntity(props: any) {
 `)
   }
 
-  // stream(action, args, callopts): runs the op through the full pipeline and
-  // returns a lazy seq of items. Seeds three records via the test mock and
-  // streams them; needs only a list op.
   if (hasList) {
     Content(`  (t/run-check rec "gen-stream-${e.name}"
     (fn [] (let [seed (vs/jm "${e.name}" (vs/jm "S1" (vs/jm "id" "S1" "name" "a")

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

@@ -10,14 +10,6 @@ import { TestDirect } from './TestDirect_clojure'
 import { ReadmeExamplesTest } from './ReadmeExamplesTest_clojure'
 
 
-// Generates sdk/gentest.clj (ns sdk.gentest): the API-specific tests, driven by
-// the model. Exposes (run rec) which the template test-runner invokes. This is
-// the orchestrator: it emits the namespace form and the single (run rec) entry
-// point, then delegates the per-entity checks to TestEntity (accessor +
-// create/list smoke + stream) and TestDirect (prepare + direct escape hatch),
-// and finally the documentation clojure-examples syntax gate (ReadmeExamples).
-// API-agnostic behaviour (pipeline error branches, all features, netsim,
-// primary utility, struct corpus) lives in the static template test namespaces.
 const Test = cmp(function Test(props: any) {
   const { model } = props.ctx$
   const { target } = props

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

@@ -11,26 +11,6 @@ import {
 } from '@voxgig/apidef'
 
 
-// FEATURES WHOSE CLOJURE SOURCE LIVES OUTSIDE src/sdk/features.clj.
-//
-// Every ordinary feature is one arm of the hand-written `make-feature`
-// factory in that single module. A feature that vendors a LIBRARY cannot
-// be: `secrets` carries a whole @voxgig/sekreto port, and that port has to
-// be droppable for a project that did not ask for it. So its
-// implementation lives in the gated feature container instead
-// (`feature/secrets/sdk/feature/secrets.clj`, namespace
-// `sdk.feature.secrets`) and the generated config wires it in.
-//
-// The container is ALSO a classpath root. Clojure resolves
-// `(require 'voxgig.sekreto.chain)` to `voxgig/sekreto/chain.clj` searched
-// from each `:paths` entry - never by relative import - so the directory
-// holding `voxgig/` must itself be on the classpath. Package_clojure adds
-// `feature/<name>` to `:paths` for exactly the entries below that are
-// active. (`test/vendor/omni` is the same rule, already in that file.)
-//
-// A map rather than a convention because both halves are decisions:
-// WHICH namespace the container publishes, and WHAT the constructor is
-// called. A new one is added here, and nowhere else.
 const EXTRA: Record<string, { ns: string, ctor: string }> = {
   secrets: { ns: 'sdk.feature.secrets', ctor: 'secrets-feature' },
 }
@@ -64,20 +44,6 @@ function extraFeatures(model: Model, target: any): ExtraFeature[] {
 }
 
 
-// The plugin DEFINITIONS the model selected, per feature.
-//
-// `def.clojure` keys are FULLY-QUALIFIED vars
-// (`voxgig.sekreto.plugins.aws/awssecrets`); the namespace is the part
-// before the `/`, and one namespace may export several definitions (aws
-// exports two). Emitted as `(:require [<ns> :as p-<tail>])` plus
-// `p-<tail>/<var>` references, so an INACTIVE group leaves no require and
-// no reference - which is what makes the generate-time file trim safe.
-//
-// `only_active: false` is NOT used here, deliberately: this reads the
-// ACTIVE plugins, because these become references to files that must
-// exist. The trim (pluginExcludes, in Main_clojure) reads the unfiltered
-// map instead. Getting that backwards emits a require for a namespace the
-// trim just deleted.
 function pluginRequires(model: Model, target: any): {
   requires: { ns: string, alias: string }[],
   plugins: Record<string, string[]>,

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'
@@ -114,7 +81,7 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
 
     Content(`// Typed reference models for the ${model.const.Name} SDK (C++).
 //
-// GENERATED from the API model: main.${KIT}.entity.<e>.fields[] and per-op
+// GENERATED from the API model: main.${KIT}.entity.<e>.fields{} and per-op
 // params. The C++ SDK runtime is Value-based, so these structs are
 // DOCUMENTATION / convenience types only — the SDK neither includes nor
 // requires this header. Array fields surface as std::vector<Value>, object
@@ -140,15 +107,12 @@ namespace types {
     entityList.forEach((ent: any) => {
       const Name = ent.Name
       const fields = (ent.fields ? each(ent.fields) : [])
-        .filter((f: any) => f.active !== false)
+        .filter((f: any) => f.a !== 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,
+        name: f.n, type: f.t, optional: false === f.r,
       })), 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) {
 })