@voxgig/sdkgen 4.21.0 → 4.23.0

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 })

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

@@ -49,7 +49,7 @@ takes an entity handle built from the client:
     const EName = entity.Name
     const eVar = entity.name
     const opnames = Object.keys(entity.op || {})
-    const fields = entity.fields || []
+    const fields = Object.values(entity.fields || {})
     const idF = entityIdField(entity)
 
     Content(`
@@ -93,8 +93,8 @@ takes an entity handle built from the client:
 `)
 
       each(fields, (field: any) => {
-        const desc = field.short || ''
-        Content(`| \`${field.name}\` | \`${canonToType(field.type, target.name)}\` | ${desc} |
+        const desc = field.sh || ''
+        Content(`| \`${field.n}\` | \`${canonToType(field.t, target.name)}\` | ${desc} |
 `)
       })
 

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

@@ -2,25 +2,6 @@
 import { cmp, Content, File } from '@voxgig/sdkgen'
 
 
-// Emits elixir/test/readme_examples_test.exs — an ExUnit SYNTAX + PRESENCE
-// gate over every ```elixir fenced block in the three docs that ship elixir
-// examples: the repository ROOT README.md, the per-language elixir/README.md,
-// and the per-language elixir/REFERENCE.md.
-//
-// For each block, tagged by (source doc, index), the gate PARSES it with
-// `Code.string_to_quoted/1` — catching malformed examples (a missing `end`, a
-// bad token, an unbalanced `%{}`). It also asserts each doc that exists ships
-// at least one elixir block.
-//
-// SCOPE NOTE: unlike the Python/Lua gates this does NOT execute blocks in a
-// seeded offline subprocess. Elixir's compile model makes running a README
-// fragment against the generated `<Name>` modules substantially heavier (each
-// block would need the SDK compiled and loaded, and the narrative aliases
-// resolved), so this port stops at the syntax gate — a real, useful guard that
-// keeps documented examples parseable as the generator evolves.
-//
-// The emitted Elixir avoids backticks (chr 96 via <<96>>) so this TS template
-// literal stays clean; the only interpolation is the SDK module name.
 const ReadmeExamplesTest = cmp(function ReadmeExamplesTest(props: any) {
   const { ctx$: { model } } = props
 

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

@@ -116,13 +116,13 @@ On error, \`ok\` is \`false\` and \`err\` carries the error value.
 
 `)
   each(entityList, (ent: any) => {
-    const fields = ent.fields || []
+    const fields = Object.values(ent.fields || {})
     const opnames = Object.keys(ent.op || {})
     const ops = ent.op || {}
     const points = each(ops).map((op: any) =>
       op.points ? each(op.points) : []
     ).flat()
-    const path = points.length > 0 ? (points[0] as any).orig || '' : ''
+    const path = points.length > 0 ? (points[0] as any).o || '' : ''
 
     Content(`#### ${ent.Name}
 
@@ -130,7 +130,7 @@ On error, \`ok\` is \`false\` and \`err\` carries the error value.
 | --- | --- |
 `)
     each(fields, (field: any) => {
-      Content(`| \`${field.name}\` | ${field.short || ''} |
+      Content(`| \`${field.n}\` | ${field.sh || ''} |
 `)
     })
 

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

@@ -1,5 +1,5 @@
 
-import { cmp, each, Content, canonToType, File, isAuthActive, entityIdField, opRequestShape } from '@voxgig/sdkgen'
+import { cmp, each, Content, canonToType, File, isAuthActive, entityIdField, opRequestShape , targetFeatures } from '@voxgig/sdkgen'
 import { ReadmeRefFeatures } from '@voxgig/sdkgen'
 
 import {
@@ -41,7 +41,7 @@ const ReadmeRef = cmp(function ReadmeRef(props: any) {
 
   const Name = model.const.Name
   const entity = getModelPath(model, `main.${KIT}.entity`)
-  const feature = getModelPath(model, `main.${KIT}.feature`)
+  const feature = targetFeatures(model, target)
 
   const publishedEntities = each(entity).filter((e: any) => e.active !== false)
 
@@ -140,7 +140,7 @@ on error.
       const EName = ent.Name
       const eVar = ent.name
       const opnames = Object.keys(ent.op || {})
-      const fields = ent.fields || []
+      const fields = Object.values(ent.fields || {})
       const idF = entityIdField(ent)
 
       Content(`
@@ -171,9 +171,9 @@ ${eVar} = ${Name}.${eVar}(sdk)
 | --- | --- | --- | --- |
 `)
         each(fields, (field: any) => {
-          const req = field.req ? 'Yes' : 'No'
-          const desc = field.short || ''
-          Content(`| \`${field.name}\` | \`${canonToType(field.type, target.name)}\` | ${req} | ${desc} |
+          const req = field.r ? 'Yes' : 'No'
+          const desc = field.sh || ''
+          Content(`| \`${field.n}\` | \`${canonToType(field.t, target.name)}\` | ${req} | ${desc} |
 `)
         })
 
@@ -323,9 +323,6 @@ sdk = ${Name}.new(${Name}.Helpers.deep(%{
 \`\`\`
 
 `)
-      // The shared feature reference: options, defaults, usage and the
-      // considerations. Model facts, identical in every target, so they are
-      // written once in cmp/ReadmeRefFeatures.ts rather than here.
       ReadmeRefFeatures({ target })
     }
 

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

@@ -18,23 +18,6 @@ import {
 } from './utility_elixir'
 
 
-// THE GENERATED SCHEMA MODULE: the model's schemas, as data the SDK can run.
-//
-// The elixir peer of src/cmp/ts/Schema_ts.ts. Same two exports, same source —
-// OPTSPEC from `main.kit.optspec` plus each feature's own `config.options`,
-// ENTITYSPEC from the entity field sentinels — built by the shared helpers,
-// so what elixir validates against and what ts validates against cannot
-// drift.
-//
-// EMBEDDED AS JSON IN A MODULE ATTRIBUTE, PARSED AT COMPILE TIME, exactly as
-// config.ex carries the model. `elixirString` escapes every `#` for the
-// reason recorded there: elixir interpolates `#{...}` inside a double-quoted
-// string, so an unescaped one would be evaluated as code rather than emitted
-// as text.
-//
-// The round-trip is exact because the spec holds only strings and booleans —
-// pinned by "strings and booleans only, so the JSON round-trip is lossless"
-// in ts/test/optspec.test.ts.
 const Schema = cmp(async function Schema(props: any) {
   const ctx$ = props.ctx$
   const target = props.target
@@ -45,20 +28,13 @@ const Schema = cmp(async function Schema(props: any) {
   const optspec = optionSpec(model, target.name)
   const entityspec = entitySpecMap(model, target.name) || {}
 
-  // UNDER lib/, like config.ex and for a reason that bites immediately: mix's
-  // `elixirc_paths` is ["lib"] (plus test/ under :test), so a module at the
-  // SDK ROOT is never compiled. This file used to be emitted there, and
-  // `Schema.optspec/0` was therefore undefined in every generated elixir SDK
-  // — make_options raised UndefinedFunctionError on the first client
-  // construction. The elixir compile lane skips where no toolchain is
-  // installed, so nothing caught it.
   Folder({ name: 'lib' }, () => {
 
   File({ name: 'schema.ex' }, () => {
     Content(`# ${Name} ${target.Name} SDK: generated schemas. Do not edit.
 #
 # Generated from the model: \`main.kit.optspec\` and each feature's
-# \`config.options\` for OPTSPEC; entity \`fields[].type\` for ENTITYSPEC.
+# \`config.options\` for OPTSPEC; entity \`fields{}.type\` for ENTITYSPEC.
 
 defmodule ${Name}.Schema do
   @optspec_data ${elixirString(JSON.stringify(optspec))}

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

@@ -23,9 +23,6 @@ function elixirType(sentinel: unknown): string {
 }
 
 
-// A type-correct, executable Elixir literal for a field/param of the given
-// canonical type. Strings render the quoted placeholder; numeric/boolean/
-// collection types render a real literal so example blocks parse and run.
 function elixirLit(sentinel: unknown, placeholder: string = 'example'): string {
   switch (canonScalarKey(sentinel)) {
     case 'INTEGER':
@@ -43,10 +40,6 @@ function projectPath(suffix?: string): string {
 }
 
 
-// Render a JS value as an Elixir literal term (maps -> %{"k" => v}, lists ->
-// [..], strings -> "..", booleans -> true/false, null -> nil). The result is
-// fed to ProjectName.Helpers.deep/1 at runtime, which lifts native terms
-// into the vendored struct's node representation.
 function formatElixir(obj: any, indent: number = 0): string {
   const pad = '  '.repeat(indent)
   const padInner = '  '.repeat(indent + 1)
@@ -104,41 +97,14 @@ function elixirString(s: string): 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
-// absent, so emitting them is pure payload.
 const CONFIG_DEFAULT: Record<string, any> = {
   active: true,
   req: false,
   reqd: false,
 }
 
-// Subtrees carrying user payload rather than schema. An active:true inside an
-// OpenAPI example is DATA, not a default, so default-pruning stops at these
-// keys and everything below them is passed through untouched.
 const PAYLOAD_KEYS = ['default', 'example', 'examples']
 
 function clean(o: any, dropDefaults?: boolean): any {

package/project/.sdk/src/cmp/go/Config_go.ts

@@ -44,22 +44,16 @@ const Config = cmp(async function Config(props: any) {
   const model: Model = ctx$.model
 
   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)
-  // config.auth.prefix override -> spec-derived info.security.prefix -> 'Bearer'
   const authPrefix = resolveAuthPrefix(model)
 
   let baseUrl = ''
   try { baseUrl = getModelPath(model, `main.${KIT}.info.servers.0.url`) } catch (_e) { }
 
-  // Templated server URL: emit the spec's server-variable defaults so the
-  // runtime can substitute {name} placeholders in base (see make_options).
   const svars = serverVariables(model)
   const serverBlock = 0 === svars.length ? '' :
     '\t\t\t"server": map[string]any{\n' +
@@ -81,27 +75,9 @@ const Config = cmp(async function Config(props: any) {
 			},\n`
     : ''
 
-  // 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.
   const { def: configDef, json: configJson } = configDefinition(model, target.name)
   const asData = isConfigData(configJson, configReprSetting(model))
 
-  // PLUGIN DEFINITION IMPORTS AND THE FeaturePlugins MAP (the go peer of
-  // Config_ts's pluginImports/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 config imports
-  // each active plugin's exported Definition BY NAME (the model's
-  // per-target `def` map - `aws.Secrets`, a package-qualified go symbol)
-  // and hands the list to the feature through core.FeaturePlugins.
-  //
-  // Emitted in core (not in the feature package) so the dependency runs
-  // core -> plugins -> sekreto -> plugin with no cycle; the feature reads
-  // it back as []any and type-asserts, so a tree with the feature present
-  // but never selected still compiles.
   const gomodule = goModule(model, target.name)
   const pluginPaths = new Set<string>()
   const featurePlugins: Record<string, string[]> = {}
@@ -109,12 +85,8 @@ const Config = cmp(async function Config(props: any) {
   each(feature, (f: any) => {
     const syms: string[] = []
     each(f.plugin, (plugin: any) => {
-      // Filter on `active` HERE rather than trusting the feature object to
-      // arrive filtered (see Config_ts.pluginImports: getting this wrong
-      // emits an import for a package the trim just deleted).
       if (false === plugin.active || null == plugin.active) return
       for (const [sym, one] of Object.entries(plugin.def?.go || {})) {
-        // 'feature/secrets/plugins/aws/aws.go' -> its PACKAGE directory.
         pluginPaths.add(String(one).replace(/\/[^/]+$/, ''))
         syms.push(sym)
       }
@@ -137,17 +109,6 @@ const Config = cmp(async function Config(props: any) {
 
   File({ name: 'config.' + target.ext }, () => {
 
-    // ABOVE THE THRESHOLD: emit the model as DATA.
-    //
-    // A composite literal makes the compiler walk every node of the model;
-    // a string constant is one token. On the real gitlab model that is 30.8 s
-    // and 2.49 GB of compiler memory versus 0.34 s and 0.06 GB, and a binary
-    // 2.1x smaller. MakeConfig still returns the same map, so nothing
-    // downstream can tell which representation it got.
-    //
-    // JSON escapes work in Go interpreted strings; formatGoString also
-    // escapes BOM characters that Go forbids literally inside source files. A raw (backtick) literal could NOT be used - the model
-    // contains backticks in values like `$STRING`.
     if (asData) {
       Content(`package core
 
@@ -297,8 +258,6 @@ func makeFeature(name string) Feature {
 `)
 
     each(feature, (f: any) => {
-      // MUST match Main_go.ts, which DECLARES these identifiers in registry.go
-      // and the root init(); see goFeatureName.
       const fname = goFeatureName(f)
       if (f.name !== 'base') {
         Content(`	case "${f.name}":