@voxgig/sdkgen 4.20.0 → 4.22.0

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

@@ -22,6 +22,7 @@ import {
 
 import { Package } from './Package_csharp'
 import { Config } from './Config_csharp'
+import { Schema } from './Schema_csharp'
 import { PrepareAuth } from './PrepareAuth_csharp'
 import { Gitignore } from './Gitignore_csharp'
 import { MainEntity } from './MainEntity_csharp'
@@ -41,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)],
@@ -58,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.
@@ -107,6 +84,8 @@ const Main = cmp(async function Main(props: any) {
 
     Config({ target })
 
+    Schema({ target })
+
     SdkError({ target })
 
     EntityBase({ target })

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')) {

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

@@ -0,0 +1,67 @@
+import {
+  Content,
+  File,
+  cmp,
+  entitySpecMap,
+  optionSpec,
+} from '@voxgig/sdkgen'
+
+
+import {
+  Model,
+} from '@voxgig/apidef'
+
+
+import {
+  formatCsMap,
+} from './utility_csharp'
+
+
+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.cs, and for the same reason: core owns the generated data,
+  // so nothing in the copied runtime has to reach up for it.
+  File({ name: 'Schema.' + target.ext }, () => {
+
+    Content(`// ${model.const.Name} SDK - generated schemas. GENERATED from the API model -
+// do not edit by hand.
+//
+// Built from the model: \`main.kit.optspec\` and each feature's
+// \`config.options\` for Optspec; entity \`fields[].type\` for Entityspec.
+
+namespace ${model.const.Name}Sdk;
+
+public static class SdkSchema
+{
+    // Built ONCE, on first use. The spec is read on every client construction
+    // and never mutated, so rebuilding it per call would be pure waste — and
+    // a shared dictionary is safe for the same reason the spec is a constant:
+    // MakeOptions validates AGAINST it and writes into the options, never
+    // into the spec.
+    //
+    // A static field initializer, so the CLR's type initializer gives the
+    // once-only, thread-safe guarantee with no locking on the read path.
+
+    /// <summary>The option spec MakeOptions validates client options against.</summary>
+    public static readonly Dictionary<string, object?> Optspec =
+        ${formatCsMap(optspec, 2)};
+
+    /// <summary>Per-entity data and request specs, keyed by entity name.</summary>
+    public static readonly Dictionary<string, object?> Entityspec =
+        ${formatCsMap(entityspec, 2)};
+}
+`)
+  })
+})
+
+
+export {
+  Schema
+}

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

@@ -179,10 +179,6 @@ ${allSteps.length > 0 ? '        var client = setup.Client;\n\n' : ''}`)
 
 `)
 
-    // Stream test (PR #4): the entity `stream` method runs the op pipeline and
-    // returns an async iterator. With the streaming feature active it yields
-    // from the feature's incremental iterator; otherwise it falls back to the
-    // materialised items. Only emitted for entities whose flow lists.
     const flowHasList = allSteps.some((s: any) => s.op === 'list')
     if (flowHasList) {
       Content(`    [Fact]

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

@@ -19,10 +19,6 @@ function projectPath(suffix?: string): string {
 }
 
 
-// A camelCase C# local-variable identifier for a snake_case model name
-// (`status_embed_config` -> `statusEmbedConfig`). C# contextual keywords
-// that are illegal as locals get the shared reserved-word guard (js set is
-// the closest match for C#'s expression keywords like `new`/`this`).
 function csVarName(name: string): string {
   const pascal = camelify(name)
   const lower = pascal.charAt(0).toLowerCase() + pascal.slice(1)
@@ -30,13 +26,11 @@ function csVarName(name: string): string {
 }
 
 
-// A PascalCase C# identifier for a snake_case model name.
 function csPascalName(name: string): string {
   return camelify(name)
 }
 
 
-// C# keywords - illegal as a plain local-variable binding.
 const CS_RESERVED = new Set<string>([
   'abstract', 'as', 'base', 'bool', 'break', 'byte', 'case', 'catch',
   'char', 'checked', 'class', 'const', 'continue', 'decimal', 'default',
@@ -86,20 +80,6 @@ function formatCsMap(obj: any, indent: number = 0): string {
 }
 
 
-// C# NEW-LINE CHARACTERS, which a regular quoted string literal may not
-// contain: U+000D, U+000A, U+0085 (NEL), U+2028 (LINE SEPARATOR) and U+2029
-// (PARAGRAPH SEPARATOR) - C# language spec, "Line terminators".
-//
-// The first two everyone escapes. The other three are the trap: they are
-// ordinary characters in JSON, in every other target language, and to the eye,
-// so a model string carrying one (an OpenAPI description, default or example
-// pasted from a word processor) emits a C# source file that fails to compile
-// with `error CS1010: Newline in constant`. Verified against .NET 8.
-//
-// Written as ESCAPES, not as the characters themselves: U+2028 and U+2029
-// are line terminators in JavaScript too, so a regex literal containing them
-// verbatim does not parse ("Invalid regular expression: missing /") and this
-// module fails to load. The same trap, one language up.
 const CS_NEWLINE = /[\u0085\u2028\u2029]/g
 
 function csEscapeNewlines(s: string): string {
@@ -128,36 +108,6 @@ function csStringLiteral(s: string): string {
 }
 
 
-// A number as a C# literal whose BOXED TYPE is predictable.
-//
-// C# gives an unsuffixed integer literal the first type of int/uint/long/ulong
-// that fits it, so `3000000000` boxes as uint while `5` boxes as int and
-// `5000000000` as long. Boxed numerics compare by exact type - (object)5L does
-// not Equals (object)5 - so the type a config number lands with is observable
-// to every consumer, and the L1 data branch has to be able to reproduce it.
-// Reproducing a uint band nothing else in the SDK ever produces is not worth
-// it, so the suffix is made explicit instead and the ladder is just int -> long
-// -> double, which SdkConfig.ConfigValue mirrors exactly.
-//
-// THE RANGE TEST IS ON THE EMITTED TEXT, not on the JS number.
-//
-// `String(val)` is exactly what JSON.stringify puts in the data branch, and it
-// prints a double as the SHORTEST decimal that round-trips - which for a value
-// near the 64-bit boundary is not the value's exact decimal expansion. The
-// clearest case is long.MinValue: `String(-9223372036854775808)` is
-// "-9223372036854776000", which is BELOW long.MinValue, so TryGetInt64 refuses
-// it and the data branch yields a double. Deciding from the JS value instead
-// emitted `long.MinValue` and the two branches disagreed at exactly that
-// boundary. Comparing the text as a BigInt makes both sides ask the same
-// question of the same digits.
-//
-// int.MinValue is written by name: `-2147483648` parses as unary minus applied
-// to a literal that does not itself fit in an int, and relying on the special
-// case for that is needless subtlety. There is deliberately no long.MinValue
-// twin - no JS number prints as that text, so it is unreachable.
-//
-// A non-finite value emits `null`, because that is what JSON.stringify does
-// with it - so the two representations still agree.
 const CS_INT_MIN = -2147483648n
 const CS_INT_MAX = 2147483647n
 const CS_LONG_MIN = -9223372036854775808n
@@ -209,28 +159,6 @@ function formatCsValue(val: any, indent: number = 0): string {
 }
 
 
-// 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