@voxgig/sdkgen 4.20.0 → 4.22.0

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

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

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

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

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

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

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

@@ -1,5 +1,5 @@
 
-import { cmp, each, Content, canonToType, canonKey, canonScalarKey, File, isAuthActive, entityIdField, opRequestShape } from '@voxgig/sdkgen'
+import { cmp, each, Content, canonToType, canonKey, canonScalarKey, File, isAuthActive, entityIdField, opRequestShape , targetFeatures } from '@voxgig/sdkgen'
 import { ReadmeRefFeatures } from '@voxgig/sdkgen'
 
 import {
@@ -57,7 +57,7 @@ const ReadmeRef = cmp(function ReadmeRef(props: any) {
   const { model } = props.ctx$
 
   const entity = getModelPath(model, `main.${KIT}.entity`)
-  const feature = getModelPath(model, `main.${KIT}.feature`)
+  const feature = targetFeatures(model, target)
 
   const publishedEntities = each(entity).filter((e: any) => e.active !== false)
 
@@ -375,9 +375,6 @@ auto client = std::make_shared<${model.const.Name}SDK>(vmap({
 \`\`\`
 
 `)
-      // The shared feature reference: options, defaults, usage and the
-      // considerations. Model facts, identical in every target, so they are
-      // written once in cmp/ReadmeRefFeatures.ts rather than here.
       ReadmeRefFeatures({ target })
     }
 

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

@@ -0,0 +1,84 @@
+import {
+  Content,
+  File,
+  cmp,
+  entitySpecMap,
+  optionSpec,
+} from '@voxgig/sdkgen'
+
+
+import {
+  Model,
+} from '@voxgig/apidef'
+
+
+import {
+  cppConfigLiterals,
+} from './utility_cpp'
+
+
+const Schema = cmp(async function Schema(props: any) {
+  const ctx$ = props.ctx$
+  const target = props.target
+
+  const model: Model = ctx$.model
+
+  const optspec = optionSpec(model, target.name)
+  const entityspec = entitySpecMap(model, target.name) || {}
+
+  // Beside config.hpp, in core, and for the same reason: core owns the
+  // generated data, so nothing in utility or feature has to reach up for it.
+  File({ name: 'schema.' + target.ext }, () => {
+
+    Content(`// ${model.const.Name} SDK: generated schemas. Do not edit.
+//
+// Built from the model: \`main.kit.optspec\` and each feature's
+// \`config.options\` for the option spec; entity \`fields[].type\` for the
+// entity specs.
+
+#ifndef SDK_CORE_SCHEMA_HPP
+#define SDK_CORE_SCHEMA_HPP
+
+#include "../core/struct.hpp"
+
+namespace sdk {
+
+inline const char* optspec_json() {
+  return
+${cppConfigLiterals(optspec)};
+}
+
+inline const char* entityspec_json() {
+  return
+${cppConfigLiterals(entityspec)};
+}
+
+// SHARED SPECS, the shape sharedConfig uses and for the same reasons: the
+// spec is read on every client construction and never mutated, so a per-call
+// parse would be pure waste. A function-local static in an inline function is
+// one object across every translation unit, and its initialisation is
+// thread-safe by the standard.
+//
+// The results are SHARED: treat them as read-only. makeOptions validates
+// AGAINST the spec and writes into the options, never into the spec.
+inline const Value& sharedOptspec() {
+  static const Value shared = vs::parse_json(optspec_json());
+  return shared;
+}
+
+inline const Value& sharedEntityspec() {
+  static const Value shared = vs::parse_json(entityspec_json());
+  return shared;
+}
+
+}  // namespace sdk
+
+#endif  // SDK_CORE_SCHEMA_HPP
+`)
+  })
+})
+
+
+export {
+  Schema
+}

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({