@voxgig/sdkgen 4.21.0 → 4.22.0

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

@@ -17,27 +17,6 @@ import {
 } from './utility_cpp'
 
 
-// THE GENERATED SCHEMA MODULE: the model's schemas, as data the SDK can run.
-//
-// The cpp 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 cpp 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 cpp's.
-// Chunked adjacent string literals, exactly as config.hpp carries its config,
-// so no single literal approaches an implementation's minimum-supported
-// length however large the model grows.
-//
-// This REPLACES the OPTSPEC_JSON() that used to sit in pipeline.hpp — a
-// hand-maintained copy of the spec that nothing cross-checked, and which had
-// already drifted (no `extend`, no `server`, no `auth.basic`).
-//
-// 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

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

@@ -231,9 +231,6 @@ ${flowHasList ? `  T_RUN(${evar}_entity_stream);\n` : ''}  T_RUN(${evar}_entity_
 })
 
 
-// declare a data var (C++ needs declaration); track declared vars per file is
-// hard across generators, so each op declares with `Value` unless it's a known
-// pre-declared ref. We use a simple convention: the first use declares it.
 function decl(varname: string, declared: Set<string>): string {
   if (declared.has(varname)) return ''
   declared.add(varname)

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

@@ -16,9 +16,6 @@ const Test = cmp(function Test(props: any) {
   const { model } = props.ctx$
   const { target } = props
 
-  // The static test suite (exists / pipeline / primary / feature / custom /
-  // netsim / struct corpus) ships as tm/cpp/test templates (copied verbatim).
-  // Here we generate the per-entity model-driven tests into test/.
   Folder({ name: 'test' }, () => {
 
     // Write-once: a project's edited control file survives regeneration.

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

@@ -5,7 +5,6 @@ import {
 } from '@voxgig/struct'
 
 
-// C++ reserved words illegal as identifiers.
 const CPP_RESERVED = new Set<string>([
   'alignas', 'alignof', 'and', 'and_eq', 'asm', 'auto', 'bitand', 'bitor',
   'bool', 'break', 'case', 'catch', 'char', 'char16_t', 'char32_t', 'class',
@@ -22,40 +21,14 @@ const CPP_RESERVED = new Set<string>([
 ])
 
 
-// A collision-free snake_case C++ identifier for a model name.
 function cppVarName(name: string): string {
   const snake = String(name).replace(/[^a-zA-Z0-9_]/g, '_').toLowerCase()
   return CPP_RESERVED.has(snake) ? snake + '_' : snake
 }
 
 
-// Deep-remove meta keys (`foo$`) from a model subtree.
-// 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
-// absent, so emitting them is pure payload.
 const CONFIG_DEFAULT: Record<string, any> = {
   active: true,
   req: false,
@@ -91,7 +64,6 @@ function cleanModel(o: any, dropDefaults?: boolean): any {
 }
 
 
-// Escape a string for embedding inside a C++ double-quoted string literal.
 function cppEscape(s: string): string {
   return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"')
 }

package/project/.sdk/src/cmp/csharp/Config_csharp.ts

@@ -42,36 +42,8 @@ const Config = cmp(async function Config(props: any) {
   // helpers/applicability.
   const feature = targetFeatures(model, target)
 
-  // 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 main.slug / main.version /
-  // main.target (the three station descriptor fields, station design §4):
-  // both reps flow from this one call - the literal via formatCsMap(configDef)
-  // and the data rep via csStringLiteral(configJson) - so they cannot
-  // disagree on identity (mirrors Config_ts's #MainMeta block).
   const { def: configDef, json: baseJson } = 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_csharp). The generated
-  // prepareAuth is built from the same two values, and the config carries
-  // them so the placement is a visible, overridable runtime option beside
-  // auth.prefix - which is also what stops the SDK's own MakeOptions from
-  // rejecting its own config: the auth optspec in tm/csharp/utility/
-  // MakeOptions.cs is a CLOSED map, and an undeclared key there fails
-  // validate with "Unexpected keys at field auth".
-  //
-  // Emitted ONLY when they differ from header/Authorization, so a
-  // header-based SDK's Config.cs is byte-identical to what it generated
-  // before. Both representations are patched through the one object, so
-  // the literal (formatCsMap) and the data rep (csStringLiteral) cannot
-  // disagree - the json is re-derived from the def, exactly as
-  // configDefinition derives it.
   const authIn = resolveAuthIn(model)
   const authName = resolveAuthName(model)
   let configJson = baseJson
@@ -93,19 +65,6 @@ const Config = cmp(async function Config(props: any) {
 
   const asData = isConfigData(configJson, configReprSetting(model))
 
-  // THE FEATURE PLUGIN MAP (the csharp peer of Config_go's featurePlugins).
-  //
-  // Upstream sekreto replaced its self-registration registry with
-  // voxgig/plugin definitions: a provider kind the caller did not pass in
-  // via `Plugins: [...]` is unknown to that Sekreto. So the config names
-  // each active plugin's exported Definition (the model's per-target `def`
-  // map - `AwsPlugins.Secrets`, a C# static field) and hands the list to
-  // the feature through SdkConfig.FeaturePlugins.
-  //
-  // FULLY QUALIFIED with `global::`, which is what makes an inactive model
-  // cost nothing: no `using` is emitted, so a config for a project with no
-  // plugin groups names no sekreto type at all and the generated file is
-  // byte-identical to one from a tree that has never heard of the feature.
   const featurePlugins: Record<string, string[]> = {}
 
   each(feature, (f: any) => {
@@ -147,18 +106,6 @@ public static class SdkConfig
 {
 `)
 
-    // ABOVE THE THRESHOLD: emit the model as DATA.
-    //
-    // A composite Dictionary literal is a single expression the C# compiler
-    // must bind, type and lower node by node, and every entry becomes IL the
-    // JIT executes on first call. A string constant is one token, and
-    // System.Text.Json builds the same dictionary from it far faster.
-    //
-    // JSON.stringify output is ALMOST a valid C# string literal: every escape
-    // it emits (\\", \\\\, \\b, \\f, \\n, \\r, \\t, \\uXXXX) means the same thing in C#,
-    // and it never emits \\/ or \\0, neither of which C# would accept. What it
-    // does leave raw is U+0085/U+2028/U+2029, which C# counts as line
-    // terminators and forbids inside a quoted literal - hence csStringLiteral.
     if (asData) {
       Content(`    // THE API MODEL, EMBEDDED AS DATA (sdkgen rung L1).
     //
@@ -246,16 +193,6 @@ public static class SdkConfig
 `)
     }
 
-    // SHARED CONFIG (sdkgen rung L2).
-    //
-    // The SDK reads the config on every request and never writes to it, so one
-    // instance is shared by every client rather than rebuilt per client. Above
-    // the size threshold MakeConfig re-parses the whole embedded JSON, so this
-    // is the difference between parsing the model once per process and once
-    // per client.
-    //
-    // Lazy<T> defaults to ExecutionAndPublication, so concurrent first calls
-    // build it exactly once - the C# twin of go's sync.Once.
     Content(`
     private static readonly Lazy<Dictionary<string, object?>> SharedConfigVal =
         new(MakeConfig);
@@ -270,22 +207,6 @@ public static class SdkConfig
     }
 `)
 
-    // ALWAYS EMITTED, even with no case at all - the same rule Config_py
-    // states for FEATURE_PLUGINS, and for the same reason. csharp's feature
-    // source is copied by Main's blanket `tm/<target>` copy whether or not
-    // the model declares the feature (only `target add` trims it, and only
-    // for a project that runs it), so SecretsFeature.cs can be present in a
-    // tree whose model has secrets switched off. Emitting this
-    // conditionally was tried and it breaks exactly there: `error CS0117:
-    // 'SdkConfig' does not contain a definition for 'FeaturePlugins'`,
-    // which takes the whole assembly down rather than leaving one unused
-    // class behind.
-    //
-    // The cost of always emitting is five inert lines and NO type
-    // reference: the return is List<object?>, so a Config.cs for a project
-    // with no plugin groups names nothing from the vendored trees and needs
-    // no `using`. The feature reads the list back and type-tests, which is
-    // go's shape too.
     Content(`
     public static List<object?> FeaturePlugins(string name)
     {

package/project/.sdk/src/cmp/csharp/EntityOperation_csharp.ts

@@ -9,9 +9,6 @@ const EntityOperation = cmp(function Operation(props: any) {
   const { model } = props.ctx$
   const { ff, opname, entity, entrep, cls } = props
 
-  // The op markers sit inside the class body, so the captured indent (the
-  // class-member indent, 4 spaces) is applied to the whole spliced
-  // fragment; the fragment's EJECT region is written at column 0.
   const { indent } = props
 
   Fragment({

package/project/.sdk/src/cmp/csharp/EntityTypes_csharp.ts

@@ -1,33 +1,5 @@
 
 
-// Typed-model generator (C# target). Port of EntityTypes_py.ts / EntityTypes_js.ts.
-//
-// Reads main.<KIT>.entity.<e>.fields[] and per-op params
-// (op.<name>.points[].args.params[]) and emits one file, core/<Name>Types.cs,
-// with a `public record <Name>` per active entity plus a request/match record
-// per active op.
-//
-// TYPE CHOICE: reference `record` types with nullable `init` properties, NOT
-// the wired runtime type. The generated ops take/return the loose object model
-// (`Dictionary<string, object?>` / `object?`), so these records are NOT wired
-// into the op signatures — they are documentation/DX reference shapes a caller
-// may use to describe a payload before converting it to a dictionary. This
-// mirrors the JS target's JSDoc typedefs (annotation only, no runtime effect):
-// C# has no annotation-only type, so a `record` is the closest zero-behaviour
-// analogue. Emitting unused records is harmless — they compile and have no
-// runtime effect.
-//
-// OPTIONAL FIELDS: a `req:false` field/param becomes a nullable property
-// (`T?`), a required one the plain type (`T`). Nullability warnings for
-// uninitialised required reference properties (CS8618) are already suppressed
-// by the generated csproj, so no initialisation is forced.
-//
-// Sentinels map to C# types via the SHARED canonToType 'csharp' column (the
-// single source of truth per language — do not keep a local table here).
-//
-// 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,
@@ -45,7 +17,6 @@ import {
 const LANG = 'csharp'
 
 
-// C# keywords that need the `@` verbatim prefix to be legal identifiers.
 const CS_KEYWORDS = new Set<string>([
   'abstract', 'as', 'base', 'bool', 'break', 'byte', 'case', 'catch',
   'char', 'checked', 'class', 'const', 'continue', 'decimal', 'default',
@@ -61,26 +32,16 @@ const CS_KEYWORDS = new Set<string>([
 ])
 
 
-// A field/param name that has a safe C# property rendering (valid identifier).
-// Names that are not valid identifiers (hyphens, leading digits) have no clean
-// property form and are skipped — they remain reachable via the runtime dict.
 function csIdent(name: string): boolean {
   return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name)
 }
 
 
-// A legal C# property identifier: keyword names get the `@` verbatim prefix.
 function csProp(name: string): string {
   return CS_KEYWORDS.has(name) ? '@' + name : name
 }
 
 
-// Emit `public record <typeName>` from {name, type, optional} items. Optional
-// items become nullable properties (`T?`); required items the plain type. An
-// item whose name is not a legal identifier is skipped (WITH a warning — the
-// key stays reachable via the runtime dict, but its absence from the typed
-// model should be visible, not silent). An empty record is a valid,
-// zero-member shape.
 function emitRecord(typeName: string, items: any[], log?: any): void {
   const usable = items.filter((it: any) => it && null != it.name && csIdent(it.name))
 
@@ -107,7 +68,6 @@ function emitRecord(typeName: string, items: any[], log?: any): void {
 `)
   usable.forEach((it: any) => {
     const base = canonToType(it.type, LANG)
-    // `object?` is already nullable; other types get a trailing `?` when optional.
     const t = it.optional && !base.endsWith('?') ? base + '?' : base
     Content(`    public ${t} ${csProp(it.name)} { get; init; }
 `)
@@ -123,10 +83,6 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
   const target = props.target || {}
   const ext = target.ext || 'cs'
 
-  // only_active:false — getModelPath DROPS active:false entries by default,
-  // but the consumer scaffold (create-sdkgen Root.ts) iterates the RAW entity
-  // collection, so inactive entities still get generated entity code that
-  // references these typed names. The typed model must cover them too.
   const entity = getModelPath(model, `main.${KIT}.entity`, { only_active: false, required: false })
   // Emit for EVERY entity that gets generated entity code: the consumer
   // scaffold (create-sdkgen Root.ts) iterates entities WITHOUT an active
@@ -138,9 +94,6 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
   // entity not yet named (e.g. a fieldless placeholder) would otherwise read
   // `Name = undefined` below. Parity with the go/py emitter's fix.
 
-  // 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)
 
   File({ name: model.const.Name + 'Types.' + ext }, () => {
@@ -167,13 +120,10 @@ namespace ${model.const.Name}Sdk.Types;
       const fields = (ent.fields ? each(ent.fields) : [])
         .filter((f: any) => f.active !== false)
 
-      // Entity data model: one property per field, `req:false` -> nullable.
       emitRecord(Name, fields.map((f: any) => ({
         name: f.name, type: f.type, optional: false === f.req,
       })), log)
 
-      // Per active op: a request/match record. 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/csharp/Entity_csharp.ts

@@ -33,7 +33,6 @@ const Entity = cmp(function Entity(props: any) {
 
   const ff = Path.normalize(__dirname + '/../../../src/cmp/csharp/fragment/')
 
-  // Entity files go to entity/ with PascalCase class-file names.
   Folder({ name: 'entity' }, () => {
 
     File({ name: cls + '.' + target.ext }, () => {

package/project/.sdk/src/cmp/csharp/Main_csharp.ts

@@ -42,15 +42,6 @@ const Main = cmp(async function Main(props: any) {
 
   Gitignore({})
 
-  // Copy tm/csharp files with replacements. `src/` holds only the
-  // per-feature extension folders (not shipped into the SDK output).
-  //
-  // pluginExcludes: the generate-time plugin trim (a DECLARED-but-INACTIVE
-  // plugin group's files are never copied). Without it every group's files
-  // ship regardless of the model, and an SDK whose chain is [dotenv, env]
-  // carries AWS request signing and seven HTTP vault clients - the whole
-  // point of the trim. Feature-level trimming happens at `target add`
-  // time; this is the per-plugin cut inside a feature that IS selected.
   Copy({
     from: 'tm/' + target.name,
     exclude: [/src\//, TEST_CONTROL_EXCLUDE, ...pluginExcludes(model)],
@@ -59,21 +50,6 @@ const Main = cmp(async function Main(props: any) {
     }
   })
 
-  // GENERATED, NOT COPIED. Where the credential goes is a fact about the
-  // API, and tm/ can only hold one answer. See PrepareAuth_csharp.
-  //
-  // CALLED HERE, AT THE ROOT, and NOT inside the core/ Folder below. The
-  // template it replaces lived at `tm/csharp/utility/PrepareAuth.cs`, so
-  // the blanket Copy above put it at `<out>/utility/PrepareAuth.cs` -
-  // beside Register.cs, which wires `u.PrepareAuth = PrepareAuthUtil` from
-  // the same `partial class SdkUtility`. The component opens its own
-  // `utility` Folder; moving this call next to Config would nest it under
-  // core/ and write `core/utility/PrepareAuth.cs`, where nothing compiles
-  // it into the utility partial.
-  //
-  // The template MUST be deleted for the same reason it is generated: the
-  // Copy above and this component would otherwise both claim
-  // `utility/PrepareAuth.cs`, and jostraca refuses a duplicate output path.
   PrepareAuth({ target })
 
   // Generated files live in core/ beside the copied runtime.

package/project/.sdk/src/cmp/csharp/Package_csharp.ts

@@ -22,12 +22,6 @@ import {
 } from '@voxgig/apidef'
 
 
-// Emits the two MSBuild project files (the C# twin of Package_go's go.mod):
-//   <Name>SDK.csproj       - the library, compiling everything except test/
-//   test/<Name>SDKTest.csproj - the xunit test project (mirrors the
-//                            voxgig/struct csharp two-csproj layout)
-// PackageReference entries come from collectDeps (feature + target deps);
-// the runtime itself is BCL-only.
 const Package = cmp(async function Package(props: any) {
   const ctx$ = props.ctx$
   const target = props.target
@@ -50,20 +44,6 @@ const Package = cmp(async function Package(props: any) {
     ? `  <ItemGroup>\n${depRefs}\n  </ItemGroup>\n`
     : ''
 
-  // CS8619, and ONLY when the secrets feature's `aws` plugin group is
-  // selected. Upstream sekreto builds its plugin assembly with <Nullable>
-  // disabled; vendored into an SDK that enables it, plugins/Aws.cs:87
-  // reports one nullability mismatch on a tuple conversion. It is a
-  // VENDORED file, so it cannot be fixed here (a silent tweak to vendored
-  // source is exactly what the vendoring guard exists to prevent), and it
-  // is the only such warning in the whole vendored set.
-  //
-  // Gated rather than added to the standing list because the standing list
-  // is a promise about EVERY generated SDK: CS8619 catches a real class of
-  // bug in ordinary code, and switching it off for everyone to quiet one
-  // line in one vendored file would be paying for a feature that is off by
-  // default. `getModelPath` is active-filtered, so this reads as present
-  // only when the group is really on.
   const awsPlugin = getModelPath(model,
     `main.${KIT}.feature.secrets.plugin.aws`, { required: false })
   const vendorNoWarn = null == awsPlugin ? '' : ';CS8619'

package/project/.sdk/src/cmp/csharp/PrepareAuth_csharp.ts

@@ -16,30 +16,6 @@ import {
 } from '@voxgig/apidef'
 
 
-// WHERE THE CREDENTIAL GOES IS A FACT ABOUT THE API, so it is generated
-// rather than templated.
-//
-// This was a static file at `tm/csharp/utility/PrepareAuth.cs` that
-// hardcoded `authorization` and a header. 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. The result
-// was an SDK that sent a header the API does not read and never sent the
-// query parameter it does, so it could not authenticate at all. Four
-// repos in the cedar fleet shipped that way: joplin (`token`), pipedrive
-// (`api_token`), trello (`key`), lm-umbrella (`apiKey`).
-//
-// 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 that is fixed at
-// generation time.
-//
-// This is the csharp port of PrepareAuth_ts, and it keeps the C# file's
-// own idioms (lazy prefix read, `TryGetValue` for a suppressed auth
-// block, `Remove` rather than a struct delprop): the credential MOVES,
-// nothing else changes. For the default header placement the rendered
-// file is BYTE-IDENTICAL to the template it replaces, so every
-// header-based csharp SDK regenerates with no diff at all.
 const PrepareAuth = cmp(async function PrepareAuth(props: any) {
   const { target } = props
   const { model } = props.ctx$
@@ -49,19 +25,6 @@ const PrepareAuth = cmp(async function PrepareAuth(props: any) {
   const name = resolveAuthName(model)
   const basic = isHttpBasicAuth(model)
 
-  // `utility`, opened HERE, and the call site in Main_csharp is at the
-  // ROOT - deliberately outside `Folder({ name: 'core' })`.
-  //
-  // csharp's layout is not ts's. Main_csharp copies `tm/csharp` at the
-  // root, so the template this replaces landed at `<out>/utility/
-  // PrepareAuth.cs`, beside MakeSpec.cs and Register.cs - which is the
-  // one path that compiles, since Register.cs wires `u.PrepareAuth =
-  // PrepareAuthUtil` from the same `partial class SdkUtility`. The
-  // generated files (Config, SdkError, EntityBase, EntityTypes) sit one
-  // level down in `core/` because Main opens that Folder around them; a
-  // call from inside it would write `core/utility/PrepareAuth.cs`, which
-  // nothing compiles into the utility partial and which would leave the
-  // stale copy at `utility/` being used instead.
   Folder({ name: 'utility' }, () => {
     File({ name: 'PrepareAuth.' + target.ext }, () => {
       Content(render({
@@ -76,30 +39,6 @@ const PrepareAuth = cmp(async function PrepareAuth(props: any) {
 })
 
 
-// DELIBERATELY NARROWER THAN isAuthActive, and measured rather than assumed.
-//
-// isAuthActive answers TWO different questions with one boolean:
-//
-//   1. `main.kit.config.auth.active: false` - this SDK is deliberately
-//      built WITHOUT auth. A per-SDK decision.
-//   2. `main.kit.info.auth: false`          - the SPEC declares no security
-//      scheme. A fact about the API.
-//
-// Only (1) may silence prepareAuth. (2) says nothing about whether the
-// CALLER holds a credential, and csharp has always let one through: the
-// optspec in tm/csharp/utility/MakeOptions.cs supplies an `auth` default
-// map whether or not the generated config carries one, so `options.auth` is
-// non-null at runtime and the old template placed `options.apikey` in the
-// authorization header regardless of what the spec declared. The generated
-// secrets feature and the auth-null probe both depend on exactly that.
-//
-// Gating the no-op on isAuthActive instead turns two csharp tests red -
-// `csharp: auth null beats an explicit apikey` ("baseline broken: an
-// ordinary apikey was not sent") and `csharp: the secrets feature runs with
-// the feature active` - because the generate harness model IS case (2)
-// (`main: kit: info: { ..., auth: false }`). Losing the ability to
-// authenticate is the defect this whole change exists to fix, so it is not
-// worth re-introducing at the other end.
 function authSwitchedOff(model: any): boolean {
   const auth = getModelPath(model, `main.${KIT}.config.auth`,
     { only_active: false, required: false })
@@ -112,9 +51,6 @@ function render(spec: {
 }): string {
   const Name = spec.Name
 
-  // AUTH SWITCHED OFF FOR THIS SDK (`config.auth.active: false`). The
-  // project has said it wants no credential placed, so prepareAuth places
-  // none - rather than one that deletes a header nobody set.
   if (!spec.active) {
     return `// ${Name} SDK utility: prepareAuth - this SDK is built with auth
 // switched off, so there is no credential to place.
@@ -142,22 +78,10 @@ public static partial class SdkUtility
     return renderCookie(Name, csstr(spec.name))
   }
 
-  // HEADER NAMES ARE LOWERCASED, and the rest of the generated C# is why.
-  // `spec.Headers` is a plain Dictionary<string, object?> - case-SENSITIVE -
-  // and every other writer of an auth header in this target spells it
-  // lowercase: SecretsFeature re-writes `headers["authorization"]` on a
-  // refresh, MakeSpec sets `headers["content-type"]`, and the generated
-  // tests assert `Headers["authorization"]`. An `Authorization` key here
-  // would sit BESIDE those rather than replace them and go out as a second
-  // header. Header names are case-insensitive on the wire (RFC 7230) and
-  // lowercase on HTTP/2, so nothing is lost. Query parameter and cookie
-  // names, which ARE case-sensitive, are emitted verbatim above.
   return renderHeader(Name, csstr(String(spec.name).toLowerCase()), spec.basic)
 }
 
 
-// HEADER. Byte-identical to the template it replaces whenever the resolved
-// name is the default (`authorization`) and the scheme is not HTTP Basic.
 function renderHeader(Name: string, cred: string, basic: boolean): string {
   // HTTP Basic is header-only by definition: the scheme is
   // `Authorization: Basic base64(user:pass)`. It cannot be expressed as a
@@ -320,9 +244,6 @@ public static partial class SdkUtility
 }
 
 
-// COOKIE. A cookie IS a header, so the credential rides in the shared
-// `cookie` header - APPENDED to whatever options.headers (or an earlier
-// feature) already put there, never assigned over it.
 function renderCookie(Name: string, cred: string): string {
   return `// ${Name} SDK utility: prepareAuth - carry the API credential in the
 // ${cred} cookie, from the client options.
@@ -380,8 +301,6 @@ public static partial class SdkUtility
 }
 
 
-// A C# double-quoted string literal body. These names come from the API's
-// own securityScheme, so they are not guaranteed to be bare identifiers.
 function csstr(s: string): string {
   return String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"')
 }

package/project/.sdk/src/cmp/csharp/ReadmeEntity_csharp.ts

@@ -56,7 +56,6 @@ const ReadmeEntity = cmp(function ReadmeEntity(props: any) {
   publishedEntities.map((entity: any) => {
     const opnames = Object.keys(entity.op || {})
     const fields = entity.fields || []
-    // Model-driven id key: null when this entity has no id-like field.
     const idF = entityIdField(entity)
     // Sanitise the local variable name — a camelCased C# keyword gets a
     // trailing underscore (csVarName) so the snippet compiles.

package/project/.sdk/src/cmp/csharp/ReadmeExamplesTest_csharp.ts

@@ -2,29 +2,6 @@
 import { cmp, File, Content } from '@voxgig/sdkgen'
 
 
-// Emits test/ReadmeExamplesTest.cs — an xUnit PRESENCE + STRUCTURE gate over
-// every ```csharp fenced block in the repository ROOT README.md, the
-// per-language csharp/README.md, AND the per-language csharp/REFERENCE.md.
-//
-// SCOPE NOTE (deliberate, documented): the Python/TS/Go equivalents EXECUTE and
-// type-check every documented block. That is infeasible here — the generated
-// C# SDK targets the .NET BCL only (no Roslyn scripting dependency), so a test
-// project cannot compile-and-run arbitrary doc snippets at test time without a
-// dependency the target explicitly forbids. This gate therefore guarantees the
-// weaker-but-real invariant that keeps the docs honest as the generator
-// evolves:
-//   1. every doc exists and contains at least one ```csharp block (nothing was
-//      dropped);
-//   2. every ```csharp block is structurally well-formed — its braces,
-//      parentheses and brackets balance (catches a truncated or malformed
-//      generated snippet), and it references the SDK/client surface so it is a
-//      real example, not an empty fence.
-// A per-doc summary line makes the coverage visible in the test output.
-//
-// The emitted C# is written WITHOUT literal backticks (the fence marker is
-// built at runtime as new string((char)96, 3)) so this TS template literal
-// stays clean — the only interpolations are the SDK class name and the
-// generated entity map.
 const ReadmeExamplesTest = cmp(function ReadmeExamplesTest(props: any) {
   const { target, ctx$: { model } } = props
 

package/project/.sdk/src/cmp/csharp/ReadmeRef_csharp.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 {
@@ -58,7 +58,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)
 
@@ -380,9 +380,6 @@ var client = new ${model.const.Name}SDK(new Dictionary<string, object?>
 \`\`\`
 
 `)
-      // 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/csharp/ReadmeTopQuick_csharp.ts

@@ -49,8 +49,6 @@ var client = ${ctor};
     // C# keyword gets a trailing underscore (csVarName) so the snippet compiles.
     const eVar = csVarName(exampleEntity.name)
     const opnames = Object.keys(exampleEntity.op || {})
-    // Model-driven id key: null when the entity has no id-like field, in which
-    // case the load example takes an empty match.
     const idF = entityIdField(exampleEntity)
 
     if (opnames.includes('list')) {