@voxgig/sdkgen 4.21.0 → 4.22.0

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

@@ -17,24 +17,6 @@ import {
 } from './utility_csharp'
 
 
-// THE GENERATED SCHEMA MODULE: the model's schemas, as data the SDK can run.
-//
-// The csharp peer of src/cmp/ts/Schema_ts.ts. Same two members, same source:
-// Optspec from `main.kit.optspec` plus each feature's own `config.options`,
-// Entityspec from the entity field sentinels — both built by the shared
-// helpers, so what csharp validates against and what ts validates against
-// cannot drift.
-//
-// A COLLECTION LITERAL, not embedded JSON, where go and the JVM targets
-// parse a string. SdkConfig switches to a JSON constant above a size
-// threshold because a large composite literal is slow for the compiler to
-// bind and the JIT to run; the spec has no such spread. It is bounded by the
-// option list and the feature set — a few hundred entries whatever the API
-// looks like — and in C# the literal is also the SAFER rep: a `false` here
-// stays `false` rather than arriving as a JsonElement to be mapped back, and
-// the number ladder SdkConfig's ConfigValue exists to reproduce is a question
-// the spec never asks (it holds only strings and booleans, pinned by "strings
-// and booleans only" in ts/test/optspec.test.ts).
 const Schema = cmp(async function Schema(props: any) {
   const ctx$ = props.ctx$
   const target = props.target

package/project/.sdk/src/cmp/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

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' }, () => {
@@ -126,15 +91,12 @@ defmodule ${Name}.Types do
         const fields = (ent.fields ? each(ent.fields) : [])
           .filter((f: any) => f.active !== 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 })),
         )
 
-        // 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 })
   })
 

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

@@ -15,12 +15,6 @@ import type {
 } from '@voxgig/apidef'
 
 
-// Generate mix.exs for the Elixir SDK. The vendored struct library has zero
-// third-party runtime deps, so a bare SDK ships with none - but dependencies
-// declared by the model DO flow: the target's own `deps` block plus any
-// feature-declared elixir deps (e.g. the station feature's voxgig_station),
-// via the shared collectDeps helper, exactly like rust/dart/go. A model with
-// no deps emits the byte-identical `defp deps, do: []` it always has.
 const Package = cmp(async function Package(props: any) {
   const ctx$ = props.ctx$
   const target = props.target
@@ -32,13 +26,6 @@ const Package = cmp(async function Package(props: any) {
   const app = String(model.const.name).replace(/-/g, '_')
   const { repoUrl } = repoInfo(model)
 
-  // Render one mix deps entry per collected dependency. Hex package names
-  // share the atom alphabet, but a hyphen in a model dep name is mapped to
-  // '_' rather than emitted broken. Version -> Mix requirement: an explicit
-  // operator is kept (spaced, the mix convention: '>=0.0.1' -> '>= 0.0.1');
-  // a bare version gets hex's customary '~>'; a target dep with no version
-  // accepts anything. kind: 'dev' scopes to [:dev, :test]; 'peer'/'prod'
-  // (and anything else) are runtime deps - mix has no peer notion.
   const entries: string[] = []
   for (const d of collectDeps(model, target.name, target.deps, ctx$.log)) {
     const atom = String(d.name).replace(/-/g, '_')

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

@@ -22,78 +22,10 @@ import {
 } from './utility_elixir'
 
 
-// WHERE THE CREDENTIAL GOES IS A FACT ABOUT THE API, so it is generated
-// rather than templated. The elixir port of cmp/ts/PrepareAuth_ts.ts; see
-// that file for the full account, and cmp/rb/PrepareAuth_rb.ts for the
-// cookie-splice and basic-auth shapes this one follows.
-//
-// 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.
-//
-// ELIXIR IS THE ODD ONE OUT: it had NO prepare_auth template. The logic was
-// embedded in `tm/elixir/lib/projectname/utility.ex` as `prepare_auth_impl/1`,
-// one clause among thirty in the 1670-line runtime module. So this is an
-// EXTRACTION as well as a port, and the extraction is into the function's
-// OWN compilation unit — the PREFERRED shape — because Elixir has no reason
-// to need the fallback:
-//
-//   * mix compiles every `.ex` under `lib/`, with no manifest, include list
-//     or import to keep in step. A new file in lib/<app>/ is compiled by
-//     virtue of existing.
-//   * Elixir resolves modules by their `defmodule`, never by path, so a
-//     module in its own file is indistinguishable at every call site from
-//     the same code inlined elsewhere.
-//   * THE BINDING IS A VALUE, NOT A LEXICAL REFERENCE. utility.ex builds the
-//     utility node by setprop-ing a function into each slot
-//     (`{"prepare_auth", &prepare_auth_impl/1}`), and every caller reaches it
-//     through `u(ctx, "prepare_auth").(ctx)`. A remote capture
-//     `&PrepareAuth.prepare_auth_impl/1` is the same kind of value, so the
-//     registrar, the feature-override contract (a feature setprops over the
-//     slot on the reference-stable node) and the `Utility.prepare_auth/1`
-//     dispatch wrapper are all untouched. `Utility.prepare_auth(ctx)` —
-//     which is what Main.fragment.ex, make_spec_impl, pipeline_test.exs and
-//     primary_utility_test.exs all call — still resolves, still dispatches
-//     through the node, and still honours an override.
 const PrepareAuth = cmp(async function PrepareAuth(props: any) {
   const { target } = props
   const { model } = props.ctx$
 
-  // FOLDER NESTING, worked out from the template's own path rather than
-  // guessed. utility.ex lives at `tm/elixir/lib/projectname/utility.ex`, and
-  // Main_elixir copies that directory with
-  //
-  //   Folder({name:'lib'}, () => Copy({from:'tm/elixir/lib/projectname',
-  //                                    to: model.const.name}))
-  //
-  // so the runtime lands at `lib/<name>/`. This component is CALLED from
-  // inside Main's second `Folder({ name: 'lib' })` block — the one that
-  // writes the generated (as opposed to copied) lib files — so `lib` is
-  // ALREADY OPEN at the call site and only `<name>` is opened here. The
-  // result is `lib/<name>/prepare_auth.ex`, beside the utility.ex that
-  // registers it.
-  //
-  // Opening `lib` again here would write `lib/lib/<name>/prepare_auth.ex`.
-  // That is the ts port's `src/src/utility/` trap, and it is WORSE in elixir
-  // than anywhere else: mix compiles everything under lib/ regardless of
-  // depth, so the module would still compile, still be found by name, and
-  // the mistake would be invisible to every test — only the published tree
-  // would look wrong. (Main_elixir carries the same warning about
-  // lib/projectname/ for the same reason.)
-  //
-  // Main's two `Folder({ name: 'lib' })` blocks are SIBLINGS, not nested:
-  // jostraca folders are scoped to their callback, so both resolve to
-  // `lib/` and this component sees exactly one of them open.
   Folder({ name: model.const.name }, () => {
     File({ name: 'prepare_auth.' + target.ext }, () => {
       Content(render({
@@ -139,8 +71,6 @@ defmodule ${spec.Name}.PrepareAuth do
 
 `
 
-  // NO AUTH AT ALL — the project switched it off. See authSwitchedOn for why
-  // ONLY an explicit switch counts.
   if (!spec.active) {
     return head + `  # This SDK is configured with authentication off, so there is no
   # credential to place. The function stays in the pipeline because
@@ -162,27 +92,8 @@ end
   const query = 'query' === spec.where
   const cookie = 'cookie' === spec.where
 
-  // HTTP Basic is header-only by definition: the scheme is
-  // `Authorization: Basic base64(user:pass)`. It cannot be expressed as a
-  // query parameter or a cookie, so the branch is emitted only where it can
-  // mean something — and only when the model says the scheme IS basic, so an
-  // ordinary bearer SDK carries no dead code and regenerates byte-identical
-  // to what utility.ex produced.
   const basicHere = spec.basic && 'header' === spec.where
 
-  // HEADER NAMES ARE LOWER-CASED; QUERY AND COOKIE NAMES ARE NOT.
-  //
-  // `resolveAuthName` answers 'Authorization' by default, but the whole
-  // elixir runtime spells header names in lower case: the extracted code
-  // said `S.delprop(headers, "authorization")`, feature/secrets.ex rewrites
-  // `headers["authorization"]`, feature/debug.ex masks the same key, the
-  // shared corpus asserts `ctx:spec:headers:authorization`, and
-  // pipeline_test.exs reads it. A struct map key is case-sensitive, so
-  // emitting "Authorization" verbatim would put the credential under a key
-  // nothing reads and leave the secrets feature writing a SECOND header.
-  // HTTP header names are case-insensitive on the wire, so lower-casing
-  // costs nothing. A query parameter and a cookie ARE case-sensitive
-  // (`?Token=` is not `?token=`), so those keep the spec's spelling.
   const credName = query || cookie ? spec.name : spec.name.toLowerCase()
 
   const attrs = `  @cred_name ${elixirString(credName)}
@@ -203,9 +114,6 @@ end
     ? `      query = S.getprop(spec, "query")`
     : `      headers = S.getprop(spec, "headers")`
 
-  // Clearing: a query parameter and a header are a plain delprop, but a
-  // cookie header is SHARED with whatever cookies the caller set, so only
-  // our own pair comes out.
   const clear = query
     ? 'S.delprop(query, @cred_name)'
     : cookie
@@ -266,8 +174,6 @@ ${indent(place(spec, clear), 1)}
 }
 
 
-// The one thing that actually differs between placements: where the
-// credential is written, and whether the prefix travels with it.
 function place(spec: AuthSpec, clear: string): string {
   const guard = `        if (is_binary(apikey) and apikey == @not_found) or apikey == nil or apikey == "" do
           ${clear}
@@ -294,7 +200,6 @@ function place(spec: AuthSpec, clear: string): string {
 `
   }
 
-  // HEADER: the extracted body, unchanged.
   return guard + `          ap = S.getpath(options, "auth.prefix")
           auth_prefix = if is_binary(ap), do: ap, else: ""
           apikey_val = if is_binary(apikey), do: apikey, else: ""
@@ -306,11 +211,6 @@ function place(spec: AuthSpec, clear: string): string {
 }
 
 
-// The private helpers the emitted body needs. `opts_map/1` is the one
-// utility.ex keeps for itself (it is `defp` there, so it could not be
-// called across the module boundary) - eight lines, reproduced rather than
-// made public, because widening a private helper to export one caller is a
-// bigger change to utility.ex than this extraction is.
 function helpers(spec: AuthSpec): string {
   const optsMap = `  # The client's options as a MAP, cloned. The clone is load-bearing: the
   # secrets feature rewrites options.apikey on the live client, and
@@ -383,29 +283,6 @@ function indent(block: string, n: number): string {
 }
 
 
-// NOT `isAuthActive`, AND THE DIFFERENCE IS LOAD-BEARING (the py port found
-// this first; same reasoning, same fix).
-//
-// `isAuthActive` is false whenever the SPEC declares no security scheme
-// (`main.kit.info.auth: false`). That is a statement about the DEFINITION,
-// not a ban on ever sending a credential: apidef writes it for every spec
-// with no securitySchemes block, GitHub's official OpenAPI included, and
-// those SDKs are still expected to honour an `apikey` the caller passes.
-// `optspec` always declares `apikey` and make_options fills `options.auth`
-// from its defaults, so the runtime `S.getprop(options, "auth") == nil`
-// guard never fired and every such SDK has always sent `options.apikey`.
-//
-// Gating the body on `isAuthActive` therefore does not trim dead code, it
-// deletes working authentication - and takes the secrets feature with it,
-// since that resolves a secret into options.apikey and prepare_auth then
-// places nothing. elixir is one of the three targets in generatedcompile's
-// AUTHNULL_STANDALONE list, whose lane (`elixir: the secrets feature runs
-// with the feature active`) runs the shipped secrets suite against a LIVE
-// client on a real mix and names its two auth-nil cases.
-//
-// So the no-op is emitted only when the PROJECT says so: `config.auth.active:
-// false`, an explicit per-SDK switch nobody sets by accident. A spec that is
-// merely silent keeps the credential path it has always had.
 function authSwitchedOn(model: any): boolean {
   const auth = getModelPath(model, `main.${KIT}.config.auth`,
     { only_active: false, required: false })