@voxgig/sdkgen 4.21.0 → 4.22.0

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/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)
 
@@ -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,13 +28,6 @@ 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' }, () => {

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}":

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

@@ -1,30 +1,5 @@
 
 
-// Typed-model generator (Go target).
-//
-// Reads main.<KIT>.entity.<e>.fields[] and per-op params
-// (op.<name>.points[].args.params[]) and emits one file, entity/types.go, in
-// the `entity` package, with a Go `type <Name> struct { ... }` per entity plus
-// a request/match struct per active op. Field/param sentinels ($STRING,
-// $INTEGER, ...) are turned into real Go types by the shared sdkgen helper
-// `canonToType` (source of truth: @voxgig/apidef VALID_CANON).
-//
-// PORT NOTES (Go specifics vs the TS reference):
-//   * Types live in the SAME package as the entity methods (`entity`), so the
-//     generated typed accessors reference them without an import (task step B).
-//   * Go has no method overloading and go-cli / go-mcp dispatch entities
-//     dynamically through the untyped `core.ProjectNameEntity` interface
-//     (Load/List/... (map[string]any) (any, error)). That interface — and the
-//     untyped concrete methods that satisfy it — are therefore KEPT unchanged.
-//     Typed access is delivered ADDITIVELY: the op fragments emit `LoadTyped`
-//     / `ListTyped` / ... alongside the untyped methods, and Entity.fragment.go
-//     emits `DataTyped` / `MatchTyped`. All are thin typed wrappers over the
-//     untyped runtime (identical behaviour), converting at the typed boundary
-//     via the JSON-round-trip helpers emitted at the bottom of this file.
-//   * `list` typed op returns []<Name>; other typed ops return <Name>.
-//   * op WITH params -> a struct of those params (reqd:false -> pointer +
-//     ,omitempty). op WITHOUT params -> a struct mirroring the entity fields
-//     with every field optional (Go's analog of TS `Partial<Name>`).
 
 import {
   cmp, each,
@@ -47,8 +22,6 @@ function cap(s: string): string {
 }
 
 
-// A model field/param name -> an exported Go field identifier:
-//   advice -> Advice, some_field -> SomeField, id -> Id.
 function goField(name: string): string {
   const out = String(name)
     .replace(/[^A-Za-z0-9]+/g, ' ')
@@ -57,30 +30,10 @@ function goField(name: string): string {
     .filter(Boolean)
     .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
     .join('')
-  // Go identifiers can't start with a digit.
   return /^[A-Za-z_]/.test(out) ? out : 'F' + out
 }
 
 
-// The json struct tag is the WIRE CONTRACT: it decides the key requests
-// marshal under and the key responses populate from.
-//
-// Can this spec-derived name be carried in a Go json struct tag AT ALL?
-//
-// It cannot always be. `encoding/json`'s isValidTag accepts letters, digits and
-// a fixed punctuation set; a name containing a double quote, a backtick or a
-// backslash is REJECTED, and Go then silently falls back to the Go FIELD name.
-// Verified against go1.24 — for a field named `na"me`:
-//
-//   raw literal      `json:"na"me"`        -> marshals as {"na": ...}   (truncated)
-//   escaped literal  "json:\"na\\\"me\""   -> marshals as {"NaMe": ...} (tag ignored)
-//
-// So there is no encoding that preserves such a name. An earlier version here
-// stripped the offending characters, which is worse than either: it silently
-// changed the wire contract, marshalling under a key the API never uses and
-// never populating from the real response key. Names that cannot be
-// represented are skipped with a warning instead — the same treatment
-// csharp/java give names with no legal identifier form.
 const GO_TAG_PUNCT = '!#$%&()*+-./:;<=>?@[]^_{|}~ '
 
 function goTaggable(name: string): boolean {
@@ -113,15 +66,6 @@ function fieldLine(name: string, sentinel: any, optional: boolean, ident?: strin
 }
 
 
-// Collision-free Go field identifiers for one struct's members.
-//
-// goField() is lossy — it strips every non-alphanumeric character — so
-// `some_field`, `some-field` and `someField` all map to `SomeField`. Emitting
-// them into the same struct is a "field redeclared" compile error, and Go is
-// the only target exposed to it (ts/py/… keep the raw key). Later duplicates
-// get a numeric suffix; the FIRST occurrence keeps the natural name, and the
-// json tag always keeps the original wire name, so behaviour is unchanged.
-// Deterministic: members arrive in sorted-key order from opRequestShape/each.
 function uniqueGoFields(members: { name: string }[]): string[] {
   const taken: Record<string, boolean> = {}
   return members.map((m) => {
@@ -174,18 +118,8 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
   // 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 file. Main_go.ts / Entity_go.ts
-  // iterate entities WITHOUT an `active` filter and reference the typed data
-  // type `<Name>` in every *_entity.go, so a struct is required for each or the
-  // package won't compile. deriveEntityNames() selects on `name` (always
-  // present) and derives the lazily-set PascalCase `Name` up front, so the
-  // struct set is deterministic and matches the *_entity.go set regardless of
-  // which component runs first.
   const entityList = deriveEntityNames(entity)
 
-  // 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: 'entity' }, () => {
@@ -213,7 +147,6 @@ import (
         const fields = (ent.fields ? each(ent.fields) : [])
           .filter((f: any) => f.active !== false)
 
-        // Entity data model: one field per model field. req:false -> pointer.
         Content(`// ${Name} is the typed data model for the ${ent.name} entity.
 type ${Name} struct {
 `)
@@ -227,10 +160,6 @@ type ${Name} struct {
 
 `)
 
-        // Per active op: a request/match struct (same package as the entity
-        // methods, so no import is needed there). Members and their optionality
-        // come from the shared partiality policy (opRequestShape); this file
-        // only renders them as a Go struct (optional -> pointer + ,omitempty).
         const ops = ent.op || {}
         ;['load', 'list', 'create', 'update', 'remove'].forEach((opname: string) => {
           if (null == ops[opname]) {

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

@@ -19,8 +19,6 @@ const Entity = cmp(function Entity(props: any) {
   const { model, stdrep } = props.ctx$
   const { target, entity } = props
 
-  // Module name: concatenated lowercase
-  // Go module path == repo path on GitHub (org from model.origin).
   const gomodule = goModule(model, target.name)
 
   // Collision-free entity CLASS name (see entityClassName): normally
@@ -37,7 +35,6 @@ const Entity = cmp(function Entity(props: any) {
 
   const ff = Path.normalize(__dirname + '/../../../src/cmp/go/fragment/')
 
-  // Entity files go to entity/ folder with snake_case names
   Folder({ name: 'entity' }, () => {
 
     File({ name: entity.name + '_entity.' + target.ext }, () => {
@@ -74,8 +71,6 @@ const Entity = cmp(function Entity(props: any) {
           EntityName: entity.Name,
           entityname: entity.name,
 
-          // Class/constructor tokens are decoupled from the EntityName data-type
-          // token in Entity.fragment.go so the class can be renamed independently.
           EntyClass: cls,
           NewEntyClass: 'New' + cls,
 

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

@@ -53,13 +53,6 @@ const Main = cmp(async function Main(props: any) {
 
   Gitignore({})
 
-  // Copy tm/go files with replacements.
-  //
-  // Rewrite the placeholder `github.com/voxgig/struct` import (used in the
-  // template since it's a self-contained module there) to its in-SDK path.
-  // The struct package is inlined under `<gomodule>/utility/struct` so the
-  // module is fully self-contained — no external go.mod required by
-  // downstream consumers.
   Copy({
     from: 'tm/' + target.name,
     // pluginExcludes: the generate-time plugin trim (an INACTIVE plugin
@@ -76,24 +69,10 @@ const Main = cmp(async function Main(props: any) {
     }
   })
 
-  // Typed models: entity/types.go (package entity), emitted alongside the
-  // generated *_entity.go files so the typed accessors resolve without imports.
   EntityTypes({ target })
 
-  // utility/prepare_auth.go is GENERATED, not templated: where the
-  // credential goes (header / query / cookie, and under what name) is a
-  // fact about the API, and tm/ can only hold one answer. See
-  // PrepareAuth_go.
-  //
-  // AT ROOT LEVEL, and outside the `core` Folder below. Go's layout is flat
-  // at the target root, and the component opens `utility` itself - the same
-  // path `Copy({from:'tm/go'})` used for the template it replaces. Calling
-  // it beside Config, inside `Folder({name:'core'})`, would emit
-  // core/utility/prepare_auth.go instead: a package nothing imports, while
-  // registerAll keeps binding whatever utility/ actually holds.
   PrepareAuth({ target })
 
-  // Generate main SDK file in core/ folder
   Folder({ name: 'core' }, () => {
 
     File({ name: model.name + '_sdk.' + target.ext }, () => {
@@ -121,7 +100,6 @@ s.utility.FeatureHook(s.rootctx, "${name}")
           }
         },
 
-        // Entities - injected at SLOT
         () => {
           each(entity, (entity: ModelEntity) => {
             const entitySDK = getModelPath(model, `main.${KIT}.entity.${entity.name}`)
@@ -143,7 +121,6 @@ var UtilityRegistrar func(u *Utility)
 var NewBaseFeatureFunc func() Feature
 
 `)
-      // Feature constructor function vars (non-base)
       each(feature, (feat: any) => {
         if (feat.name !== 'base') {
           const fname = goFeatureName(feat)
@@ -153,7 +130,6 @@ var NewBaseFeatureFunc func() Feature
         }
       })
 
-      // Entity constructor function vars
       each(entity, (ent: any) => {
         Content(`var New${ent.Name}EntityFunc func(client *${model.const.Name}SDK, entopts map[string]any) ${model.const.Name}Entity
 
@@ -162,7 +138,6 @@ var NewBaseFeatureFunc func() Feature
     })
   })
 
-  // Generate root package file
   const hasEntities = Object.keys(entity || {}).length > 0
   const entityImport = hasEntities ? `\n\t"${gomodule}/entity"` : ''
   File({ name: model.name + '.' + target.ext }, () => {
@@ -195,13 +170,11 @@ type BaseFeature = feature.BaseFeature
 func init() {
 `)
 
-    // Register feature constructors - base is always present
     Content(`	core.NewBaseFeatureFunc = func() core.Feature {
 		return feature.NewBaseFeature()
 	}
 `)
 
-    // Register non-base feature constructors
     each(feature, (feat: any) => {
       if (feat.name !== 'base') {
         const fname = goFeatureName(feat)
@@ -212,7 +185,6 @@ func init() {
       }
     })
 
-    // Register entity constructors
     each(entity, (ent: any) => {
       Content(`	core.New${ent.Name}EntityFunc = func(client *core.${model.const.Name}SDK, entopts map[string]any) core.${model.const.Name}Entity {
 		return entity.New${entityClassName(ent, entityCollection(model))}(client, entopts)

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

@@ -18,11 +18,6 @@ const Package = cmp(async function Package(props: any) {
 
   const model: Model = ctx$.model
 
-  // Module path and language version both come from the model — see
-  // goModule / goVersion. Neither is derivable from the slug alone: the repo
-  // may not be named `<slug>-sdk`, and the hardcoded `go 1.20` this used to
-  // emit could not compile sdkgen's own `log` feature (it imports log/slog,
-  // which needs 1.21).
   const gomodule = goModule(model, target.name)
 
   File({ name: 'go.mod' }, () => {
@@ -35,8 +30,6 @@ go ${goVersion(model, target.name)}
     const deps: Record<string, string> = {}
     const replaceDirs: Record<string, string> = {}
     for (const d of collectDeps(model, target.name, target.deps, ctx$.log)) {
-      // Target-level deps default to 'v0.0.0' when version is absent;
-      // feature deps require an explicit version.
       deps[d.name] = d.source === 'target' ? (d.version || 'v0.0.0') : d.version
       if (d.source === 'target' && d.raw?.replace) {
         replaceDirs[d.name] = d.raw.replace

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

@@ -18,26 +18,6 @@ import {
 } from '@voxgig/apidef'
 
 
-// WHERE THE CREDENTIAL GOES IS A FACT ABOUT THE API, so it is generated
-// rather than templated. This is the go peer of PrepareAuth_ts; read that
-// one first, it carries the full account of the defect.
-//
-// This was a static file at `tm/go/utility/prepare_auth.go` that hardcoded
-//
-//   const headerAuth = "authorization"
-//
-// 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, so the SDK sent a header the API does not
-// read and never sent the query parameter it does.
-//
-// 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 fixed at generation
-// time. Go makes that stricter than most targets: an unused local is a
-// COMPILE ERROR, so a file that resolved `authPrefix` and then dropped it
-// for a query placement would not build at all.
 const PrepareAuth = cmp(async function PrepareAuth(props: any) {
   const { target } = props
   const { model } = props.ctx$
@@ -54,16 +34,6 @@ const PrepareAuth = cmp(async function PrepareAuth(props: any) {
   const prefix = resolveAuthPrefix(model)
   const basic = isHttpBasicAuth(model)
 
-  // FOLDER NESTING. Main_go opens NO folder around this call: go's layout is
-  // flat at the target root (core/, utility/, feature/, entity/, test/), the
-  // template this replaces lived at `tm/go/utility/prepare_auth.go`, and
-  // `Copy({from:'tm/go'})` lands it at `<root>/utility/`. So the `utility`
-  // folder is opened HERE, exactly as EntityTypes_go opens `entity`.
-  //
-  // The call site matters as much: Config is inside `Folder({name:'core'})`,
-  // and putting PrepareAuth beside it would write `core/utility/prepare_auth.go`
-  // — a second `package utility` nobody imports, while the registrar keeps
-  // calling whatever `utility/` still holds. Main_go calls this at ROOT level.
   Folder({ name: 'utility' }, () => {
     File({ name: 'prepare_auth.' + target.ext }, () => {
       Content(render({ gomodule, active, where, name, prefix, basic }))
@@ -84,9 +54,6 @@ type AuthSpec = {
 
 function render(spec: AuthSpec): string {
 
-  // NO AUTH AT ALL. A public API's SDK gets a prepareAuth that is honest
-  // about it rather than one that deletes a header nobody set. `vs` is left
-  // out of the imports deliberately — go rejects an unused import.
   if (!spec.active) {
     return `package utility
 
@@ -209,19 +176,6 @@ ${place(spec.where)}
 }
 
 
-// The credential's key, as it goes into the bag.
-//
-// A HEADER name is lowercased. HTTP header names are case-insensitive
-// (RFC 9110 5.1) and go's `req.Header.Set` canonicalises on the wire, so
-// nothing changes over the socket — but this SDK's own header map is keyed
-// in lowercase throughout (`content-type`, and the `authorization` that the
-// generated pipeline/feature/secrets tests assert on), and the shipped
-// `prepare_auth.go` said `"authorization"`. Emitting the resolver's
-// title-cased default here would have left every header SDK's own test
-// suite failing on a purely cosmetic difference.
-//
-// A QUERY parameter and a COOKIE name are case-SENSITIVE, so those go in
-// verbatim: `?token=` is not `?Token=`.
 function credLiteral(where: string, name: string): string {
   return 'header' === where ? String(name).toLowerCase() : String(name)
 }
@@ -246,9 +200,6 @@ function clear(where: string): string {
 
 function place(where: string): string {
   if ('query' === where) {
-    // NO PREFIX IN A QUERY STRING. `?token=Bearer%20abc` is not a thing any
-    // API reads; the prefix is a header convention and is dropped here
-    // deliberately rather than silently concatenated.
     return `		apikeyVal := ""
 		if av, ok := apikey.(string); ok {
 			apikeyVal = av
@@ -257,8 +208,6 @@ function place(where: string): string {
   }
 
   if ('cookie' === where) {
-    // Append, never replace: the cookie header may already carry pairs this
-    // SDK did not set, and clobbering it would drop them.
     return `		apikeyVal := ""
 		if av, ok := apikey.(string); ok {
 			apikeyVal = av
@@ -302,19 +251,6 @@ export {
 }
 
 
-// NOT `isAuthActive`, AND THE DIFFERENCE IS LOAD-BEARING. That helper is
-// also false whenever the SPEC declares no security scheme
-// (`main.kit.info.auth: false`) — a statement about the DEFINITION, not a
-// ban on ever sending a credential. `optspec` still declares `apikey` and
-// makeOptions fills `options.auth` from its defaults, so the runtime
-// `options.auth == null` guard never fired and those SDKs have always sent
-// the credential. Gating the body on `isAuthActive` does not trim dead
-// code, it removes working authentication — which
-// `go: auth null suppresses the credential` catches, and which takes the
-// secrets feature down with it.
-//
-// `main.kit.config.auth.active: false` is the project saying "no credential,
-// ever", and it is the only signal that can be honoured before runtime.
 function isAuthActive_go(model: any): boolean {
   const auth = getModelPath(model, `main.${KIT}.config.auth`,
     { only_active: false, required: false })

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

@@ -41,14 +41,9 @@ const ReadmeEntity = cmp(function ReadmeEntity(props: any) {
 `)
 
   publishedEntities.map((entity: any) => {
-    // ACTIVE ops only — an inactive op generates no method, so an example
-    // calling it would not compile.
     const opnames = entityOps(entity)
     const fields = entity.fields || []
-    // Model-driven id key: null when this entity has no id-like field.
     const idF = entityIdField(entity)
-    // camelCase Go identifier (a `status_embed_config` entity must not bind a
-    // snake_case Go variable, and a `type`/`range` entity not a Go keyword).
     const eVar = goVarName(entity.name)
 
     Content(`