@voxgig/sdkgen 4.21.0 → 4.23.0

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

@@ -1,3 +1,4 @@
+import { flowSteps } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -54,16 +55,16 @@ const TestEntity = cmp(function TestEntity(props: any) {
   const idnames = buildIdNames(entity, basicflow)
   const idnamesStr = idnames.map(n => `Value("${n}")`).join(', ')
 
-  const allSteps = Object.values(basicflow.step) as any[]
-  const updateStep = allSteps.find((s: any) => s.op === 'update')
-  const updateData = updateStep?.data
-    ? Object.entries(updateStep.data).filter(([k]: any) => k !== 'id' && !k.endsWith('$'))
+  const allSteps = Object.values(flowSteps(basicflow)) as any[]
+  const updateStep = allSteps.find((s: any) => s.o === 'update')
+  const updateData = updateStep?.d
+    ? Object.entries(updateStep.d).filter(([k]: any) => k !== 'id' && !k.endsWith('$'))
     : []
   const aliases = updateData.map(([k, v]: any) => [k, v])
 
   const genCtx: GenCtx = { model, entity, flow: basicflow }
 
-  const opsList = Array.from(new Set(allSteps.map((s: any) => s.op).filter(Boolean)))
+  const opsList = Array.from(new Set(allSteps.map((s: any) => s.o).filter(Boolean)))
     .map(o => `"${o}"`).join(', ')
 
   const method = cppVarName(entity.name)
@@ -133,7 +134,7 @@ static ${entity.Name}Setup ${evar}_basic_setup(const Value& extra) {
 
   ${entity.Name}Setup s;
   s.client = client;
-  s.data = entity_data;
+  s.d = entity_data;
   s.idmap = idmap_resolved;
   s.env = env;
   s.live = live;
@@ -153,7 +154,7 @@ static void ${evar}_entity_instance() {
     // The stream test drives the list op; only emit it when the entity has a
     // list op (a create/load-only entity has no list endpoint, so
     // stream("list") throws "Operation \"list\" has no endpoint definitions").
-    const flowHasList = allSteps.some((s: any) => 'list' === s.op)
+    const flowHasList = allSteps.some((s: any) => 'list' === s.o)
     if (flowHasList) {
       Content(`
 static void ${evar}_entity_stream() {
@@ -192,7 +193,7 @@ static void ${evar}_entity_basic() {
 `)
 
     // No create step: bootstrap entity data from existing fixtures.
-    const flowHasCreate = allSteps.some((s: any) => s.op === 'create')
+    const flowHasCreate = allSteps.some((s: any) => s.o === 'create')
     if (!flowHasCreate) {
       const preambleVar = cppVarName(entity.name + '_ref01')
       Content(`
@@ -211,8 +212,8 @@ static void ${evar}_entity_basic() {
     }
 
     // Model-driven step iteration.
-    each(basicflow.step, (step: any, index: any) => {
-      const opgen: OpGen = GENERATE_OP[step.op]
+    each(flowSteps(basicflow), (step: any, index: any) => {
+      const opgen: OpGen = GENERATE_OP[step.o]
       if (opgen) {
         opgen(genCtx, step, index)
         Content('\n')
@@ -231,9 +232,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)
@@ -246,9 +244,9 @@ const declaredVars = new Set<string>()
 
 const generateCreate: OpGen = (ctx, step: any, index) => {
   const { entity } = ctx
-  const ref = step.input?.ref ?? entity.name + '_ref01'
-  const datavar = cppVarName(step.input?.datavar ?? (ref + '_data' + (step.input?.suffix ?? '')))
-  const entvar = cppVarName(step.input?.entvar ?? ref + '_ent')
+  const ref = step.i?.ref ?? entity.name + '_ref01'
+  const datavar = cppVarName(step.i?.datavar ?? (ref + '_data' + (step.i?.suffix ?? '')))
+  const entvar = cppVarName(step.i?.entvar ?? ref + '_ent')
 
   Content(`  // CREATE
   auto ${entvar} = client->${cppVarName(entity.name)}();
@@ -280,14 +278,14 @@ const generateCreate: OpGen = (ctx, step: any, index) => {
 
 const generateList: OpGen = (ctx, step: any, index) => {
   const { entity, flow } = ctx
-  const ref = step.input?.ref ?? entity.name + '_ref01'
-  const entvar = cppVarName(step.input?.entvar ?? ref + '_ent')
-  const matchvar = cppVarName(step.input?.matchvar ?? (ref + '_match' + (step.input?.suffix ?? '')))
-  const listvar = cppVarName(step.input?.listvar ?? (ref + '_list' + (step.input?.suffix ?? '')))
+  const ref = step.i?.ref ?? entity.name + '_ref01'
+  const entvar = cppVarName(step.i?.entvar ?? ref + '_ent')
+  const matchvar = cppVarName(step.i?.matchvar ?? (ref + '_match' + (step.i?.suffix ?? '')))
+  const listvar = cppVarName(step.i?.listvar ?? (ref + '_list' + (step.i?.suffix ?? '')))
 
-  const priorSteps = Object.values(flow.step).slice(0, Number(index)) as any[]
+  const priorSteps = Object.values(flowSteps(flow)).slice(0, Number(index)) as any[]
   const needsEnt = !priorSteps.some((s: any) =>
-    ['create', 'list', 'load', 'update', 'remove'].includes(s.op))
+    ['create', 'list', 'load', 'update', 'remove'].includes(s.o))
 
   Content(`  // LIST
 `)
@@ -309,12 +307,12 @@ const generateList: OpGen = (ctx, step: any, index) => {
   ASSERT_TRUE(${listvar}.is_list(), "expected list result to be an array");
 `)
 
-  const allSteps = Object.values(flow.step) as any[]
-  if (step.valid) {
-    for (const validator of (step as any).valid) {
+  const allSteps = Object.values(flowSteps(flow)) as any[]
+  if (step.v) {
+    for (const validator of (step as any).v) {
       const validRef = validator.def?.ref
-      const hasRefData = validRef && allSteps.some((s: any) => 'create' === s.op &&
-        ((s.input?.ref ?? entity.name + '_ref01') === validRef))
+      const hasRefData = validRef && allSteps.some((s: any) => 'create' === s.o &&
+        ((s.i?.ref ?? entity.name + '_ref01') === validRef))
       if ('ItemExists' === validator.apply && hasRefData) {
         const refDataVar = cppVarName(validRef + '_data')
         Content(`  {
@@ -337,15 +335,15 @@ const generateList: OpGen = (ctx, step: any, index) => {
 
 const generateUpdate: OpGen = (ctx, step: any, index) => {
   const { entity, flow } = ctx
-  const ref = step.input?.ref ?? entity.name + '_ref01'
-  const entvar = cppVarName(step.input?.entvar ?? ref + '_ent')
-  const datavar = cppVarName(step.input?.datavar ?? (ref + '_data' + (step.input?.suffix ?? '')))
-  const resdatavar = cppVarName(step.input?.resdatavar ?? (ref + '_resdata' + (step.input?.suffix ?? '')))
-  const srcdatavar = cppVarName(step.input?.srcdatavar ?? (ref + '_data' + (step.input?.suffix ?? '')))
+  const ref = step.i?.ref ?? entity.name + '_ref01'
+  const entvar = cppVarName(step.i?.entvar ?? ref + '_ent')
+  const datavar = cppVarName(step.i?.datavar ?? (ref + '_data' + (step.i?.suffix ?? '')))
+  const resdatavar = cppVarName(step.i?.resdatavar ?? (ref + '_resdata' + (step.i?.suffix ?? '')))
+  const srcdatavar = cppVarName(step.i?.srcdatavar ?? (ref + '_data' + (step.i?.suffix ?? '')))
 
-  const priorSteps = Object.values(flow.step).slice(0, Number(index)) as any[]
+  const priorSteps = Object.values(flowSteps(flow)).slice(0, Number(index)) as any[]
   const needsEnt = !priorSteps.some((s: any) =>
-    ['create', 'list', 'load', 'update', 'remove'].includes(s.op))
+    ['create', 'list', 'load', 'update', 'remove'].includes(s.o))
   const hasEntIdU = null != entity.id
 
   Content(`  // UPDATE
@@ -360,8 +358,8 @@ const generateUpdate: OpGen = (ctx, step: any, index) => {
     Content(`  setp(${datavar}_up, "id", getp(${srcdatavar}, "id"));
 `)
   }
-  if (step.data) {
-    const dataEntries = Object.entries(step.data).filter(([k]: any) => k !== 'id' && !k.endsWith('$'))
+  if (step.d) {
+    const dataEntries = Object.entries(step.d).filter(([k]: any) => k !== 'id' && !k.endsWith('$'))
     for (const [key] of dataEntries) {
       Content(`  setp(${datavar}_up, "${key}", getp(setup.idmap, "${key}"));
 `)
@@ -369,10 +367,10 @@ const generateUpdate: OpGen = (ctx, step: any, index) => {
   }
   let markname = ''
   let markval = ''
-  if (step.spec) {
-    for (const spec of (step as any).spec) {
-      if ('TextFieldMark' === spec.apply && null != step.input?.textfield) {
-        markname = step.input.textfield
+  if (step.s) {
+    for (const spec of (step as any).s) {
+      if ('TextFieldMark' === spec.apply && null != step.i?.textfield) {
+        markname = step.i.textfield
         const fieldvalue = spec.def?.mark ?? `Mark01-${ref}`
         markval = `${fieldvalue}_`
         Content(`  std::string ${datavar}_markval = std::string("${fieldvalue}_") + std::to_string(setup.now);
@@ -399,15 +397,15 @@ const generateUpdate: OpGen = (ctx, step: any, index) => {
 
 const generateLoad: OpGen = (ctx, step: any, index) => {
   const { entity, flow } = ctx
-  const ref = step.input?.ref ?? entity.name + '_ref01'
-  const entvar = cppVarName(step.input?.entvar ?? ref + '_ent')
-  const matchvar = cppVarName(step.input?.matchvar ?? (ref + '_match' + (step.input?.suffix ?? '')))
-  const datavar = cppVarName(step.input?.datavar ?? (ref + '_data' + (step.input?.suffix ?? '')))
-  const srcdatavar = cppVarName(step.input?.srcdatavar ?? (ref + '_data' + (step.input?.suffix ?? '')))
+  const ref = step.i?.ref ?? entity.name + '_ref01'
+  const entvar = cppVarName(step.i?.entvar ?? ref + '_ent')
+  const matchvar = cppVarName(step.i?.matchvar ?? (ref + '_match' + (step.i?.suffix ?? '')))
+  const datavar = cppVarName(step.i?.datavar ?? (ref + '_data' + (step.i?.suffix ?? '')))
+  const srcdatavar = cppVarName(step.i?.srcdatavar ?? (ref + '_data' + (step.i?.suffix ?? '')))
 
-  const priorSteps = Object.values(flow.step).slice(0, Number(index)) as any[]
+  const priorSteps = Object.values(flowSteps(flow)).slice(0, Number(index)) as any[]
   const hasEntVar = priorSteps.some((s: any) =>
-    ['create', 'list', 'load', 'update', 'remove'].includes(s.op))
+    ['create', 'list', 'load', 'update', 'remove'].includes(s.o))
   const hasEntId = null != entity.id
 
   Content(`  // LOAD
@@ -434,14 +432,14 @@ const generateLoad: OpGen = (ctx, step: any, index) => {
 
 const generateRemove: OpGen = (ctx, step: any, index) => {
   const { entity, flow } = ctx
-  const ref = step.input?.ref ?? entity.name + '_ref01'
-  const entvar = cppVarName(step.input?.entvar ?? ref + '_ent')
-  const matchvar = cppVarName(step.input?.matchvar ?? (ref + '_match' + (step.input?.suffix ?? '')))
-  const srcdatavar = cppVarName(step.input?.srcdatavar ?? (ref + '_data'))
+  const ref = step.i?.ref ?? entity.name + '_ref01'
+  const entvar = cppVarName(step.i?.entvar ?? ref + '_ent')
+  const matchvar = cppVarName(step.i?.matchvar ?? (ref + '_match' + (step.i?.suffix ?? '')))
+  const srcdatavar = cppVarName(step.i?.srcdatavar ?? (ref + '_data'))
 
-  const priorSteps = Object.values(flow.step).slice(0, Number(index)) as any[]
+  const priorSteps = Object.values(flowSteps(flow)).slice(0, Number(index)) as any[]
   const needsEnt = !priorSteps.some((s: any) =>
-    ['create', 'list', 'load', 'update', 'remove'].includes(s.op))
+    ['create', 'list', 'load', 'update', 'remove'].includes(s.o))
 
   Content(`  // REMOVE
 `)

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,17 +94,14 @@ 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 }, () => {
 
     Content(`// Typed reference models for the ${model.const.Name} SDK.
 //
-// GENERATED from the API model: main.${KIT}.entity.<e>.fields[] and per-op
-// params (op.<name>.points[].args.params[]). Field/param types come from the
+// GENERATED from the API model: main.${KIT}.entity.<e>.fields{} and per-op
+// params (op.<name>.points[].g.params[]). Field/param types come from the
 // canonical type sentinels (source of truth: @voxgig/apidef VALID_CANON). Do
 // not edit by hand.
 //
@@ -165,15 +118,12 @@ namespace ${model.const.Name}Sdk.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 property per field, `req:false` -> nullable.
       emitRecord(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 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'