@voxgig/sdkgen 4.21.0 → 4.23.0

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

@@ -1,3 +1,4 @@
+import { flowSteps } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -85,17 +86,17 @@ const TestEntity = cmp(function TestEntity(props: any) {
   const idnamesStr = idnames.map(n => `"${n}"`).join(', ')
 
   // Get all update data entries for alias generation
-  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, PROJUPPER }
 
   const opNames = Array.from(new Set(
-    (allSteps as any[]).map((s: any) => s.op).filter(Boolean)))
+    (allSteps as any[]).map((s: any) => s.o).filter(Boolean)))
   const opsList = opNames.map(o => `"${o}"`).join(', ')
 
   // An entity whose basic flow has no ops must not emit the per-op skip
@@ -152,7 +153,7 @@ ${skipBlock}        // The basic flow consumes synthetic IDs from the fixture. I
 ${allSteps.length > 0 ? '        var client = setup.Client;\n\n' : ''}`)
 
     // Check if the flow has a create step; if not, bootstrap entity data
-    const flowHasCreate = allSteps.some((s: any) => s.op === 'create')
+    const flowHasCreate = allSteps.some((s: any) => s.o === 'create')
     if (!flowHasCreate) {
       const preambleRef = entity.name + '_ref01'
       const preambleVar = csVar(preambleRef)
@@ -167,8 +168,8 @@ ${allSteps.length > 0 ? '        var client = setup.Client;\n\n' : ''}`)
     }
 
     // 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')
@@ -179,11 +180,7 @@ ${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')
+    const flowHasList = allSteps.some((s: any) => s.o === 'list')
     if (flowHasList) {
       Content(`    [Fact]
     public async Task Stream()
@@ -343,18 +340,18 @@ ${allSteps.length > 0 ? '        var client = setup.Client;\n\n' : ''}`)
 
 const generateCreate: OpGen = (ctx, step, index) => {
   const { entity, flow } = ctx
-  const ref = step.input.ref ?? entity.name + '_ref01'
-  const entvar = csVar(step.input.entvar ?? ref + '_ent')
-  const datavar = csVar(step.input.datavar ?? (ref + '_data' + (step.input.suffix ?? '')))
+  const ref = step.i.ref ?? entity.name + '_ref01'
+  const entvar = csVar(step.i.entvar ?? ref + '_ent')
+  const datavar = csVar(step.i.datavar ?? (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 hasDatvar = priorSteps.some((s: any) => {
-    if ('create' === s.op) {
-      const priorRef = s.input.ref ?? entity.name + '_ref01'
-      const priorDatvar = csVar(s.input.datavar ?? (priorRef + '_data' + (s.input.suffix ?? '')))
+    if ('create' === s.o) {
+      const priorRef = s.i.ref ?? entity.name + '_ref01'
+      const priorDatvar = csVar(s.i.datavar ?? (priorRef + '_data' + (s.i.suffix ?? '')))
       return priorDatvar === datavar
     }
     return false
@@ -394,14 +391,14 @@ const generateCreate: OpGen = (ctx, step, index) => {
 
 const generateList: OpGen = (ctx, step, index) => {
   const { entity, flow } = ctx
-  const ref = step.input.ref ?? entity.name + '_ref01'
-  const entvar = csVar(step.input.entvar ?? ref + '_ent')
-  const matchvar = csVar(step.input.matchvar ?? (ref + '_match' + (step.input.suffix ?? '')))
-  const listvar = csVar(step.input.listvar ?? (ref + '_list' + (step.input.suffix ?? '')))
+  const ref = step.i.ref ?? entity.name + '_ref01'
+  const entvar = csVar(step.i.entvar ?? ref + '_ent')
+  const matchvar = csVar(step.i.matchvar ?? (ref + '_match' + (step.i.suffix ?? '')))
+  const listvar = csVar(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
 `)
@@ -434,13 +431,13 @@ const generateList: OpGen = (ctx, step, index) => {
             $"expected list result to be a list, got {${listvar}Result?.GetType()}");
 `)
 
-  // Handle validators from step.valid
-  const allSteps = Object.values(flow.step) as any[]
-  if (step.valid) {
-    for (const validator of step.valid) {
+  // Handle validators from step.v
+  const allSteps = Object.values(flowSteps(flow)) as any[]
+  if (step.v) {
+    for (const validator of step.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 = csVar(validRef + '_data')
@@ -468,16 +465,16 @@ const generateList: OpGen = (ctx, step, index) => {
 
 const generateUpdate: OpGen = (ctx, step, index) => {
   const { entity, flow } = ctx
-  const ref = step.input.ref ?? entity.name + '_ref01'
-  const entvar = csVar(step.input.entvar ?? ref + '_ent')
-  const datavar = csVar(step.input.datavar ?? (ref + '_data' + (step.input.suffix ?? '')))
-  const resdatavar = csVar(step.input.resdatavar ?? (ref + '_resdata' + (step.input.suffix ?? '')))
-  const markdefvar = csVar(step.input.markdefvar ?? (ref + '_markdef' + (step.input.suffix ?? '')))
-  const srcdatavar = csVar(step.input.srcdatavar ?? (ref + '_data' + (step.input.suffix ?? '')))
-
-  const priorSteps = Object.values(flow.step).slice(0, Number(index)) as any[]
+  const ref = step.i.ref ?? entity.name + '_ref01'
+  const entvar = csVar(step.i.entvar ?? ref + '_ent')
+  const datavar = csVar(step.i.datavar ?? (ref + '_data' + (step.i.suffix ?? '')))
+  const resdatavar = csVar(step.i.resdatavar ?? (ref + '_resdata' + (step.i.suffix ?? '')))
+  const markdefvar = csVar(step.i.markdefvar ?? (ref + '_markdef' + (step.i.suffix ?? '')))
+  const srcdatavar = csVar(step.i.srcdatavar ?? (ref + '_data' + (step.i.suffix ?? '')))
+
+  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
 
@@ -495,9 +492,9 @@ const generateUpdate: OpGen = (ctx, step, index) => {
 `)
   }
 
-  // Add data entries from step.data
-  if (step.data) {
-    const dataEntries = Object.entries(step.data).filter(([k]: any) => k !== 'id' && !k.endsWith('$'))
+  // Add data entries from step.d
+  if (step.d) {
+    const dataEntries = Object.entries(step.d).filter(([k]: any) => k !== 'id' && !k.endsWith('$'))
     for (const [key] of dataEntries) {
       Content(`            ["${key}"] = setup.Idmap["${key}"],
 `)
@@ -508,10 +505,10 @@ const generateUpdate: OpGen = (ctx, step, index) => {
 `)
 
   // Handle TextFieldMark spec
-  if (step.spec) {
-    for (const spec of step.spec) {
-      if ('TextFieldMark' === spec.apply && null != step.input.textfield) {
-        const fieldname = step.input.textfield
+  if (step.s) {
+    for (const spec of step.s) {
+      if ('TextFieldMark' === spec.apply && null != step.i.textfield) {
+        const fieldname = step.i.textfield
         const fieldvalue = spec.def?.mark ?? `Mark01-${ref}`
         Content(`
         var ${markdefvar}Name = "${fieldname}";
@@ -534,9 +531,9 @@ const generateUpdate: OpGen = (ctx, step, index) => {
   }
 
   // Assert TextFieldMark
-  if (step.spec) {
-    for (const spec of step.spec) {
-      if ('TextFieldMark' === spec.apply && null != step.input.textfield) {
+  if (step.s) {
+    for (const spec of step.s) {
+      if ('TextFieldMark' === spec.apply && null != step.i.textfield) {
         Content(`        Assert.True(Equals(${resdatavar}![${markdefvar}Name], ${markdefvar}Value),
             $"expected {${markdefvar}Name} to be updated, got {${resdatavar}[${markdefvar}Name]}");
 `)
@@ -548,24 +545,24 @@ const generateUpdate: OpGen = (ctx, step, index) => {
 
 const generateLoad: OpGen = (ctx, step, index) => {
   const { entity, flow } = ctx
-  const ref = step.input.ref ?? entity.name + '_ref01'
-  const entvar = csVar(step.input.entvar ?? ref + '_ent')
-  const matchvar = csVar(step.input.matchvar ?? (ref + '_match' + (step.input.suffix ?? '')))
-  const datavar = csVar(step.input.datavar ?? (ref + '_data' + (step.input.suffix ?? '')))
-  const srcdatavar = csVar(step.input.srcdatavar ?? (ref + '_data' + (step.input.suffix ?? '')))
+  const ref = step.i.ref ?? entity.name + '_ref01'
+  const entvar = csVar(step.i.entvar ?? ref + '_ent')
+  const matchvar = csVar(step.i.matchvar ?? (ref + '_match' + (step.i.suffix ?? '')))
+  const datavar = csVar(step.i.datavar ?? (ref + '_data' + (step.i.suffix ?? '')))
+  const srcdatavar = csVar(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))
 
   // Check if srcdatavar was declared by a prior create step or preamble
-  const flowHasCreate = Object.values(flow.step).some((s: any) => (s as any).op === 'create')
+  const flowHasCreate = Object.values(flowSteps(flow)).some((s: any) => (s as any).o === 'create')
   const preambleRef = entity.name + '_ref01'
   const hasSrcData = (!flowHasCreate && srcdatavar === csVar(preambleRef + '_data')) ||
     priorSteps.some((s: any) => {
-      if ('create' === s.op) {
-        const priorRef = s.input.ref ?? entity.name + '_ref01'
-        const priorDatvar = csVar(s.input.datavar ?? (priorRef + '_data' + (s.input.suffix ?? '')))
+      if ('create' === s.o) {
+        const priorRef = s.i.ref ?? entity.name + '_ref01'
+        const priorDatvar = csVar(s.i.datavar ?? (priorRef + '_data' + (s.i.suffix ?? '')))
         return priorDatvar === srcdatavar
       }
       return false
@@ -610,14 +607,14 @@ const generateLoad: OpGen = (ctx, step, index) => {
 
 const generateRemove: OpGen = (ctx, step, index) => {
   const { entity, flow } = ctx
-  const ref = step.input.ref ?? entity.name + '_ref01'
-  const entvar = csVar(step.input.entvar ?? ref + '_ent')
-  const matchvar = csVar(step.input.matchvar ?? (ref + '_match' + (step.input.suffix ?? '')))
-  const srcdatavar = csVar(step.input.srcdatavar ?? (ref + '_data'))
+  const ref = step.i.ref ?? entity.name + '_ref01'
+  const entvar = csVar(step.i.entvar ?? ref + '_ent')
+  const matchvar = csVar(step.i.matchvar ?? (ref + '_match' + (step.i.suffix ?? '')))
+  const srcdatavar = csVar(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/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

package/project/.sdk/src/cmp/elixir/Config_elixir.ts

@@ -37,21 +37,12 @@ const Config = cmp(async function Config(props: any) {
   const Name = model.const.Name
 
   const entity = getModelPath(model, `main.${KIT}.entity`)
-  // Gated by the applicability tags, so this target never imports or
-  // registers a feature it has no source for. One rule, one place:
-  // helpers/applicability.
   const feature = targetFeatures(model, target)
 
   const headers = getModelPath(model, `main.${KIT}.config.headers`) || {}
 
   const authActive = isAuthActive(model)
   const authPrefix = resolveAuthPrefix(model)
-  // `in` and `name` travel with the prefix now. apidef resolved both from
-  // the spec's securityScheme all along (joplin's says `in: "query",
-  // name: "token"`) and generation dropped them, so an apiKey-in-query API
-  // got an Authorization header it does not read. Emitted below ONLY when
-  // they differ from the header/Authorization defaults, so a header SDK's
-  // config.ex is byte-identical to what it generated before.
   const authIn = resolveAuthIn(model)
   const authName = resolveAuthName(model)
 
@@ -62,34 +53,8 @@ const Config = cmp(async function Config(props: any) {
     ? `        "auth" => %{"prefix" => ${elixirString(authPrefix)}},\n`
     : ''
 
-  // THE PLUGIN DEFINITIONS PER FEATURE (the elixir peer of Config_go's
-  // FeaturePlugins and Config_ts's pluginDefs).
-  //
-  // 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 model's choice
-  // of plugin groups IS the SDK's provider vocabulary. Each active plugin's
-  // `def` key is a fully-qualified elixir CALL (`Sekreto.Plugins.Hashicorp
-  // .hashicorp`), emitted here as `...()` and handed to the feature.
-  //
-  // The smallest of the four emitters: Elixir resolves modules globally, by
-  // their `defmodule`, so there is no import block to keep in step with the
-  // trim - naming the call is the whole of it.
-  //
-  // Filter on `active` HERE rather than trusting the feature object to
-  // arrive filtered (the trap Config_ts and Config_go both carry a warning
-  // about): emitting a call into a module the plugin trim just deleted is
-  // an `UndefinedFunctionError` at the first client construction.
   const featurePlugins: Record<string, string[]> = {}
 
-  // DECLARED at all, active or not - the emit gate. An SDK that selects no
-  // plugin-bearing feature gets no function, so config.ex is byte-identical
-  // to what it was before this feature existed: inactive costs nothing.
-  // (`only_active: false` for the same reason pluginExcludes needs it - the
-  // feature object a component is handed has ALREADY been filtered, so its
-  // `plugin` map holds only the ACTIVE groups and a project with the feature
-  // on but every group off would read as "no plugins declared" and lose the
-  // function the feature calls.)
   let declared = false
 
   each(feature, (f: any) => {
@@ -129,63 +94,20 @@ const Config = cmp(async function Config(props: any) {
 `
 
   Folder({ name: 'lib' }, () => {
-    // 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 in to the main slug/version/target identity
-    // fields (station descriptor input, mirrors Config_ts) - both reps below
-    // render from this same def, so the data and literal branches pick the
-    // fields up together.
     const { def: configDef } = configDefinition(model, target.name)
 
-    // THE PLACEMENT, ONTO THE CANONICAL DEFINITION RATHER THAN INTO ONE
-    // BRANCH. Both reps below render from `configDef` - the literal through
-    // formatElixir, the data through JSON - so overlaying the fact here is
-    // what keeps them the same config either side of the threshold. (Targets
-    // whose literal is a hand-assembled fragment had to emit the block twice
-    // and only did it once; elixir renders `options` whole, so it cannot
-    // drift.)
-    //
-    // The optspec in utility.ex's make_options declares `in` and `name` for
-    // exactly this reason: this port's validate REJECTS a key the spec does
-    // not list, so a config carrying a placement the optspec has never heard
-    // of does not degrade quietly - the client cannot be constructed at all
-    // (`** (Voxgig.Struct.Error) Unexpected keys at field auth: in, name`,
-    // measured by removing the optspec entry from a generated query SDK).
     if (authActive && null != configDef.options && null != configDef.options.auth) {
       if ('header' !== authIn) configDef.options.auth.in = authIn
       if ('Authorization' !== authName) configDef.options.auth.name = authName
     }
 
-    // Re-stringified AFTER the overlay, so the size the threshold is measured
-    // on is the size of the config actually emitted. For a header SDK the
-    // overlay adds nothing and this is byte-identical to configDefinition's
-    // own json.
     const configJson = JSON.stringify(configDef)
     const asData = isConfigData(configJson, configReprSetting(model))
 
-    // configDefinition's `def.entity` verbatim, NOT rebuilt here. The reduce
-    // this replaces was one of fourteen copies of that function's entityDefs
-    // loop, and when configDefinition started reconstructing a point's
-    // `parts` from apidef's segment vector (its ADR-003), only the copies
-    // that read `configDef` got it — this target's literal config emitted
-    // paths with no parts at all while its data config had them. One rule,
-    // one place.
     const entityClean = configDef.entity
 
     File({ name: 'config.ex' }, () => {
 
-      // ABOVE THE THRESHOLD: emit the model as DATA.
-      //
-      // The literal is one nested `%{}` the Elixir compiler expands and holds
-      // in the module's constant pool; a binary is one token. `Json.parse`
-      // builds the vendored struct's heap nodes DIRECTLY - the same nodes
-      // `Helpers.deep/1` produces from a plain map - so make_config returns
-      // exactly what it returned before.
-      //
-      // `ProjectName.Json` is already the SDK's response decoder (see
-      // `safe_json` in utility.ex), so this adds no dependency.
       if (asData) {
         Content(`# ${Name} SDK configuration
 #

package/project/.sdk/src/cmp/elixir/EntityTypes_elixir.ts

@@ -1,28 +1,5 @@
 
 
-// Typed-model generator (Elixir target). Port of EntityTypes_ts.ts / _rb.ts.
-//
-// Reads main.<KIT>.entity.<e>.fields[] and per-op params
-// (op.<name>.points[].args.params[]) and emits one module, lib/<app>_types.ex,
-// holding an `@type` alias per active entity plus a request/match type per
-// active op, each with a `@typedoc` documenting its concrete members.
-//
-// TYPE CHOICE: the SDK carries data as string-keyed struct value nodes, and
-// Elixir map typespecs cannot pin individual string keys (only
-// `optional(String.t()) => v`), so every alias resolves to an open string-keyed
-// map `%{optional(String.t()) => any()}`. The precise per-member shape is
-// documented in the accompanying @typedoc (the honest Elixir analogue of the
-// TS interface / rb Struct). Field/param sentinels ($STRING, $INTEGER, ...) are
-// turned into real Elixir typespec fragments (String.t(), integer(), ...) by
-// the shared sdkgen canonToType 'elixir' column (via the `elixirType`
-// delegate in utility_elixir).
-//
-// Op type-name scheme mirrors every other language — derived from the SHARED
-// OP_SUFFIX policy, snake_cased for Elixir:
-//   <ename>, <ename>_load_match, <ename>_list_match, <ename>_create_data,
-//   <ename>_update_data, <ename>_remove_match.
-// The generated entity modules reference these aliases from @spec annotations
-// on their op functions (see fragment/Entity*Op.fragment.ex).
 
 import {
   cmp, each, names,
@@ -39,16 +16,11 @@ import {
 import { elixirType } from './utility_elixir'
 
 
-// Snake_case op type name, derived from the SHARED OP_SUFFIX policy (the
-// PascalCase scheme <Name><Op><Match|Data> rendered Elixir-style):
-//   <ename>_load_match, <ename>_create_data, ...
 function elixirOpTypeName(ename: string, opname: string): string {
   return ename + '_' + opname + '_' + (OP_SUFFIX[opname] || 'Match').toLowerCase()
 }
 
 
-// Emit one `@typedoc` + `@type` alias. The alias is always an open
-// string-keyed map; the members are documented in the doc block.
 function emitType(
   typeName: string,
   doc: string,
@@ -79,10 +51,6 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
   const Name = model.const.Name
   const app = model.const.name.toLowerCase()
 
-  // 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 an entity module: the consumer scaffold
   // (create-sdkgen Root.ts) iterates entities WITHOUT an active filter, and
@@ -93,9 +61,6 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
   // Derive the PascalCase Name up-front — it is set LAZILY by names(), so an
   // entity not yet named would otherwise read `Name = undefined` below.
 
-  // 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)
 
   Folder({ name: 'lib' }, () => {
@@ -103,8 +68,8 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
 
       Content(`# Typed models for the ${Name} SDK.
 #
-# GENERATED from the API model: main.${KIT}.entity.<e>.fields[] and per-op
-# params (op.<name>.points[].args.params[]). Member types come from the
+# GENERATED from the API model: main.${KIT}.entity.<e>.fields{} and per-op
+# params (op.<name>.points[].g.params[]). Member types come from the
 # canonical type sentinels. The SDK carries data as string-keyed struct value
 # nodes, so each alias is an open string-keyed map; the @typedoc member lists
 # document the concrete shapes. Do not edit by hand.
@@ -124,17 +89,14 @@ defmodule ${Name}.Types do
         const EName = ent.Name
         const ename = ent.name
         const fields = (ent.fields ? each(ent.fields) : [])
-          .filter((f: any) => f.active !== false)
+          .filter((f: any) => f.a !== false)
 
-        // Entity data model: one member per field (`req:false` -> optional).
         emitType(
           ename,
           `${EName} entity data model.`,
-          fields.map((f: any) => ({ name: f.name, type: f.type, optional: false === f.req })),
+          fields.map((f: any) => ({ name: f.n, type: f.t, optional: false === f.r })),
         )
 
-        // Per active op: a request/match type. Members and their optionality
-        // come from the shared partiality policy (opRequestShape).
         const ops = ent.op || {}
         ;['load', 'list', 'create', 'update', 'remove'].forEach((opname: string) => {
           if (null == ops[opname]) {

package/project/.sdk/src/cmp/elixir/Main_elixir.ts

@@ -24,9 +24,6 @@ import { MainEntity } from './MainEntity_elixir'
 import { EntityTypes } from './EntityTypes_elixir'
 
 
-// #`-comment hook marker key (gotcha #1: jostraca's built-in #Name-Tag
-// replacement only matches `//` comments, so an Elixir `# #<Name>-Hook`
-// line never matches and the pipeline hook would be silently dropped).
 const HOOK_KEY =
   '/(?<indent>[ \\t]*)#[ \\t]*#(?<name>[A-Za-z0-9]+)-Hook[ \\t]*\\n?/'
 
@@ -55,16 +52,6 @@ const Main = cmp(async function Main(props: any) {
   // Generate the documented typespec module (lib/<app>_types.ex).
   EntityTypes({ target })
 
-  // Copy tm/elixir (with ProjectName/projectname substitution).
-  //
-  // THE RUNTIME DIRECTORY HAS TO CARRY THE APP NAME. Copy substitutes file
-  // CONTENTS, never path components, so a blanket copy shipped the runtime as
-  // lib/projectname/ in every generated SDK. Nothing broke — Elixir resolves
-  // modules by their `defmodule`, not by path, and those were substituted
-  // correctly — so it compiled, tested green, and published looking wrong.
-  //
-  // Copy's `to` prop names the destination, so lib/projectname is copied
-  // explicitly under the app's own name and excluded from the blanket copy.
   Copy({
     from: 'tm/' + target.name,
     exclude: [/src\//, /lib\/projectname\//],
@@ -77,20 +64,6 @@ const Main = cmp(async function Main(props: any) {
     Copy({
       from: 'tm/' + target.name + '/lib/projectname',
       to: model.const.name,
-      // pluginExcludes: the generate-time plugin trim (an INACTIVE plugin
-      // group's vendored files, declared per-target in the feature model).
-      // Rooted HERE, on lib/projectname, because that is this Copy's root
-      // and jostraca matches a candidate against the path relative to it -
-      // which is why the model's elixir plugin paths read
-      // `feature/secrets/sekreto/plugins/<kind>.ex` and not the full
-      // `lib/projectname/...`.
-      //
-      // AND THE TRIM IS INVISIBLE TO THE COMPILER HERE, unlike everywhere
-      // else. mix compiles everything under lib/ and Elixir needs no
-      // import, so a plugin file this exclude failed to remove compiles
-      // silently and SHIPS - where go fails on an unused import, py on a
-      // missing module and ts on an unresolved one. Only the parity and
-      // vendored guards can catch a broken trim in this target.
       exclude: [...pluginExcludes(model)],
       replace: {
         ...stdrep,
@@ -118,7 +91,6 @@ const Main = cmp(async function Main(props: any) {
       )
     })
 
-    // Operation pipeline (hook markers replaced here — gotcha #1).
     File({ name: 'pipeline.' + target.ext }, () => {
       Fragment({
         from: ff + 'Pipeline.fragment.ex',
@@ -158,18 +130,6 @@ end
 `)
     })
 
-    // WHERE THE CREDENTIAL GOES IS GENERATED, NOT COPIED. prepare_auth was
-    // the one pipeline utility whose answer is a fact about the API rather
-    // than about the language, and tm/ can only hold one answer - so it is
-    // extracted out of the copied utility.ex into its own module here. See
-    // PrepareAuth_elixir for the extraction and for why the registration in
-    // utility.ex still binds it.
-    //
-    // CALLED FROM INSIDE THIS `lib` FOLDER, and the component opens only
-    // `<name>`, so the file lands at lib/<name>/prepare_auth.ex - beside the
-    // utility.ex the Copy above puts at lib/<name>/utility.ex. Opening `lib`
-    // in the component too would write lib/lib/<name>/, which mix would
-    // compile anyway (it globs the whole tree) and no test could see.
     PrepareAuth({ target })
   })