@voxgig/sdkgen 4.21.0 → 4.22.0

package/project/.sdk/src/cmp/swift/Config_swift.ts

@@ -29,42 +29,10 @@ const Config = cmp(async function Config(props: any) {
 
   const model: Model = ctx$.model
 
-  // 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)
 
-  // The config as data, built by the shared helper so every target embeds
-  // the same model by construction. Passing target.name opts this target
-  // into main.slug / main.version / main.target (the three station
-  // descriptor identity fields, station design §4); swift has only the
-  // JSON-literal rep, so that one call covers every rep this target emits.
-  //
-  // `def` rather than the helper's own `json`, because `in` and `name` are
-  // added to the auth block below and the JSON has to be re-serialised over
-  // that. When nothing is added, `JSON.stringify(def)` IS the helper's
-  // `json` - same object, same key order - so a header SDK's config is
-  // byte-identical to what it was.
   const { def } = configDefinition(model, target.name)
 
-  // `in` and `name` TRAVEL WITH THE PREFIX NOW. apidef resolved both from
-  // the spec's securityScheme all along (main.kit.info.security - 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 ONLY when they differ from the header/Authorization defaults, so
-  // every header-based SDK regenerates byte-identical. The generated
-  // prepareAuth bakes the placement in at generation time (see
-  // PrepareAuth_swift); these carry it in the config so a running SDK, and
-  // anything reading its descriptor, can say what its scheme actually is.
-  //
-  // THE OPTSPEC HAS TO NAME THEM TOO. `main.kit.optspec.auth` does, but
-  // swift does not read the model for its option spec - buildOptSpec() in
-  // tm/swift/Sources/ProjectNameSDK/utility/MakeOptions.swift is written out
-  // by hand - so both were added there in the same change. Without that this
-  // block is inert at best: makeOptions merges the config's options and
-  // validates the result against that spec, and a key the spec does not name
-  // is dropped or rejected.
   const authIn = resolveAuthIn(model)
   const authName = resolveAuthName(model)
   const authOpt: any = (def as any)?.options?.auth
@@ -75,42 +43,12 @@ const Config = cmp(async function Config(props: any) {
 
   const json = JSON.stringify(def)
 
-  // Model-data defaults may carry the ProjectName placeholder (e.g. the
-  // clienttrack clientName); resolve it to the API name so the embedded JSON
-  // matches the token-replaced runtime.
   const configJson = json.replace(/ProjectName/g, model.const.Name)
 
-  // PLUGIN DEFINITIONS AND THE featurePlugins MAP (the swift peer of
-  // Config_go's featurePlugins / 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 config names each
-  // active plugin's exported Definition BY SYMBOL (the model's per-target
-  // `def.swift` map - `hashicorp`, a top-level `let` in the vendored
-  // SekretoPlugins module) and hands the list to the feature through
-  // SdkConfig.featurePlugins.
-  //
-  // Typed `[String: [Any]]`, as go types it `[]any`, so Config never has to
-  // name `Definition` - and so needs `import SekretoPlugins` only when a
-  // definition is actually listed. The feature reads the list back and
-  // downcasts.
-  //
-  // The ACCESSOR IS EMITTED UNCONDITIONALLY (empty map when nothing is
-  // selected). Its caller, feature/SecretsFeature.swift, ships whenever the
-  // feature is active, and java gated the accessor on "a feature declares a
-  // plugin block" - which a project that never selected secrets does not
-  // have - and shipped an SDK that did not compile (.handover-briefs/
-  // fixb-java.md). One rule: what a template may reference, Config always
-  // declares.
   const featurePlugins: Record<string, string[]> = {}
   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
-      // names a definition the trim just deleted, and swiftc fails the
-      // whole module on the unresolved symbol).
       if (false === plugin.active || null == plugin.active) return
       for (const sym of Object.keys(plugin.def?.swift || {})) {
         syms.push(sym)

package/project/.sdk/src/cmp/swift/EntityOperation_swift.ts

@@ -9,9 +9,6 @@ const EntityOperation = cmp(function Operation(props: any) {
   const { model } = props.ctx$
   const { ff, opname, entity, entrep, cls } = props
 
-  // The op markers sit inside the class body; the captured indent (2-space
-  // class-member indent) is applied to the whole spliced EJECT region, which
-  // is written at column 0.
   const { indent } = props
 
   Fragment({

package/project/.sdk/src/cmp/swift/EntityTypes_swift.ts

@@ -1,24 +1,4 @@
 
-// Typed-model generator (Swift target). Port of EntityTypes_rust.ts /
-// EntityTypes_go.ts.
-//
-// Reads main.<KIT>.entity.<e>.fields[] and per-op params
-// (op.<name>.points[].args.params[]) and emits one file,
-// Sources/ProjectNameSDK/entity/<Name>Types.swift, with a `struct <Name>` per
-// entity plus a request/match struct per active op. Field/param sentinels
-// ($STRING, $INTEGER, ...) map to Swift types via the SHARED canonToType
-// 'swift' column (the single source of truth per language — do not keep a
-// local table here).
-//
-// DESIGN NOTE: the Swift runtime is fully DYNAMIC — every op takes and returns
-// the vendored `Value` enum (throws on error) and the op fragments emit no
-// typed wrappers. These typed models are therefore DOCUMENTARY: they mirror the
-// entity/op shapes for reference and IDE support, but are not wired into the op
-// signatures. They compile as part of the SwiftPM target (every .swift under
-// Sources/ProjectNameSDK is built) so they stay in sync with the model.
-//   * Optional (req:false) member -> `T?`.
-//   * Unknown/missing sentinel -> the dynamic `Value` (never fails), matching
-//     the runtime's open shape.
 
 import {
   cmp, each,
@@ -48,9 +28,6 @@ function propLine(name: string, sentinel: any, optional: boolean): string {
 }
 
 
-// Emit a `struct <typeName>` from {name, type, optional} items, dropping
-// duplicate Swift identifiers (two model names can collapse to one ident). An
-// empty struct is a valid, zero-property shape.
 function emitStruct(comment: string, typeName: string, items: any[]): void {
   Content(`${comment}
 public struct ${typeName} {
@@ -78,14 +55,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 (filter on `name`, always
-  // present; derive `Name` here so the struct set is deterministic — parity
-  // with the rust/go emitter's fix).
   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: 'Sources' }, () => {
@@ -113,13 +84,6 @@ import Foundation
             const fields = (ent.fields ? each(ent.fields) : [])
               .filter((f: any) => f.active !== false)
 
-            // Entity data model: one property per field. req:false -> optional.
-            //
-            // Swift has no intra-module namespacing, so a spec schema named
-            // after one of our own runtime types (e.g. `Response`) would be a
-            // redeclaration and fail the build. swiftSafeTypeName appends
-            // `Type` on collision only — `Response` -> `ResponseType` — so
-            // non-colliding SDKs generate byte-identical output to before.
             const TypeName = swiftSafeTypeName(Name)
             emitStruct(
               `/// ${TypeName} is the typed data model for the ${ent.name} entity.`,
@@ -127,9 +91,6 @@ import Foundation
               fields.map((f: any) => ({ name: f.name, type: f.type, optional: false === f.req }))
             )
 
-            // Per active op: a request/match struct. 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/swift/Main_swift.ts

@@ -39,19 +39,6 @@ const Main = cmp(async function Main(props: any) {
 
   const entity: ModelEntity = getModelPath(model, `main.${KIT}.entity`)
 
-  // THE SECRETS TRIM, at generate time, and swift NEEDS it where go, py and
-  // dart leave the feature-level trim to `target add` (vendor-tag rollout,
-  // Decision 5). DELIBERATE DIVERGENCE, and the reason is the build: the
-  // feature's three vendored trees are separate SwiftPM MODULES that
-  // Package_swift declares only when the feature is active (see the note
-  // there). With the feature off, a tree still in Sources/<Name>Sdk/ would
-  // be folded into the SDK target and fail it on five redeclarations, and
-  // feature/SecretsFeature.swift would fail on `import Sekreto` naming a
-  // module the manifest never declared. Every other swift feature is a
-  // single file the SDK module compiles regardless, so it needs no such
-  // exclude. Keyed on the SAME predicate the manifest uses, so the two
-  // cannot disagree. The gated suite under Tests/.../feature/secrets/ goes
-  // with it: it imports Sekreto too.
   const secrets = swiftSecretsActive(model, target)
   const secretsSourceExcludes: RegExp[] = secrets ? [] : [
     /(^|\/)feature\/SecretsFeature\.swift$/,
@@ -65,19 +52,6 @@ const Main = cmp(async function Main(props: any) {
 
   Gitignore({})
 
-  // Copy tm/swift files with replacements. `src/` holds only the per-feature
-  // extension folders (not shipped into the SDK output).
-  // THE COPIED TREE HAS TO CARRY THE API NAME TOO.
-  //
-  // Copy substitutes file CONTENTS, never path components, so a blanket copy
-  // of tm/swift landed the runtime in a directory literally called
-  // ProjectNameSDK. Package.swift papered over it with an explicit `path:`,
-  // so it compiled and every swift suite passed — while every published SDK
-  // shipped `Sources/ProjectNameSDK/`, and SwiftPM's own convention
-  // (Sources/<target>) was broken in all of them.
-  //
-  // Copy's `to` prop names the destination, so the two placeholder subtrees
-  // are copied explicitly and the rest of tm/swift blanket-copied as before.
   Copy({
     from: 'tm/' + target.name,
     exclude: [/src\//, /Sources\//, /Tests\//],
@@ -91,15 +65,6 @@ const Main = cmp(async function Main(props: any) {
     Copy({
       from: 'tm/' + target.name + '/Sources/ProjectNameSDK',
       to: swiftTargetDir(model),
-      // pluginExcludes: the generate-time plugin trim (an ACTIVE feature's
-      // INACTIVE plugin group's declared files stay out of the tree). The
-      // model's swift `path` entries are relative to THIS Copy's root
-      // (`feature/secrets/plugins/Aws.swift`, not `Sources/ProjectNameSDK/
-      // ...`), as py's are to its pkg copy - helpers/featureSource documents
-      // that getting the root wrong makes the trim a silent no-op. No
-      // verbatim carve-out is needed for the vendored trees: none of the
-      // upstream swift files carries a ProjectName/PROJECTENV token, so the
-      // blanket replace is inert over them.
       exclude: [...secretsSourceExcludes, ...pluginExcludes(model)],
       replace: {
         ...props.ctx$.stdrep,
@@ -171,13 +136,6 @@ const Main = cmp(async function Main(props: any) {
     })
   })
 
-  // utility/PrepareAuth.swift — GENERATED, NOT COPIED. Where the credential
-  // goes (header, query or cookie, and under what name) is a fact about the
-  // API, and tm/ can only hold one answer; the function was extracted from
-  // the copied utility/Prepare.swift, which no longer declares it. Called at
-  // THIS level, not inside the `core` folder above: the component opens the
-  // whole `Sources/<Name>Sdk/utility` path itself, exactly as EntityTypes
-  // does for `entity`. See PrepareAuth_swift.
   PrepareAuth({ target })
 
   // entity/<Name>Types.swift — documentary typed models (one struct per entity

package/project/.sdk/src/cmp/swift/Package_swift.ts

@@ -13,73 +13,6 @@ import type {
 } from '@voxgig/apidef'
 
 
-// Emits Package.swift (the SwiftPM manifest; the Swift twin of Package_go's
-// go.mod / Package_csharp's csproj). The library target compiles everything
-// under Sources/<Name>Sdk (the copied runtime + generated sources); the test
-// target compiles Tests/<Name>SdkTests. Both directories carry the API name:
-// Copy does not rewrite path components, so Main_swift copies the two
-// placeholder subtrees explicitly via Copy's `to` prop rather than letting a
-// blanket copy ship them as ProjectNameSDK.
-//
-// Dependencies: the runtime itself is dependency-free (Foundation + the
-// vendored struct), but declared target/feature deps flow into the manifest
-// via collectDeps. SwiftPM cannot name a package by product alone, so a
-// swift deps entry carries its coordinates in a documented convention:
-//
-//   deps: swift: {
-//     'VoxgigStation': { active: true, version: '0.0.1', kind: prod,
-//       url: 'https://github.com/voxgig/station-swift' }
-//   }
-//
-//   - the entry KEY is the SwiftPM PRODUCT name (also the module the
-//     generated source imports);
-//   - the extra `url` field is the git repository SwiftPM resolves
-//     (`.package(url:from:)`); the package identity SwiftPM derives from it
-//     is the URL's last path component (minus any .git), which is what the
-//     `.product(name:package:)` reference must use;
-//   - `version` feeds `from:` - a plain semver (any leading range operator
-//     like '>=' is stripped, since `from:` already means >=).
-//
-// An entry WITHOUT a `url` is not expressible in a SwiftPM manifest (no
-// registry-less by-name dependencies), so it is skipped - unadorned entries
-// keep today's zero-dependency output.
-//
-// The `Omni` target is the VENDORED corpus test engine (Tests/vendor/omni,
-// @voxgig/omni at the shared tag). It has to be its own MODULE, not files
-// folded into the test target: the port calls `Omni.errify` by module name,
-// and its top-level `clone`/`getpath`/`walk`/`stringify`/`pathify` collide
-// head-on with the struct utility's functions of the same names. It is
-// declared as a .testTarget rather than a .target so `swift build` - a
-// consumer's library build - never compiles the test engine; `swift test`
-// builds it and the suite target depends on it.
-//
-// THE SECRETS FEATURE ADDS THREE MORE MODULES, and this is the same
-// precedent, load-bearing rather than tidy. The vendored @voxgig/plugin
-// host, the @voxgig/sekreto core and its plugins live under
-// Sources/<Name>Sdk/feature/secrets/{plugin,sekreto,plugins} and are
-// compiled as VoxgigPlugin, Sekreto and SekretoPlugins - upstream's own
-// three-module boundary (sekreto's swift Makefile builds exactly these). A
-// flat layout collides on five names: plugin's `Value` and `Point` against
-// the SDK's, sekreto's `Json` against plugin's, and `dropsuffix`/`getenv`,
-// which sekreto declares in BOTH src/ and plugins/ because upstream never
-// compiles them as one module. So, when the feature is active for this
-// target:
-//
-//   - three `.target`s are declared over the three directories;
-//   - the SDK target gains them as dependencies and `exclude: ["feature/
-//     secrets"]`, so SwiftPM does not ALSO fold the files into the SDK
-//     module (`exclude:` must come AFTER `path:` in the argument list, or
-//     the manifest itself fails to compile);
-//   - the library product vends all four, because `SecretsFeature.sekreto()`
-//     is public API returning a `Sekreto`, and a downstream package may only
-//     `import Sekreto` if the product exposes it;
-//   - the test target depends on Sekreto and VoxgigPlugin as well, since
-//     the gated suite builds providers against Sekreto's `Provider`
-//     protocol and reads the selected `Definition`s' kinds back.
-//
-// Keyed on swiftSecretsActive - the SAME predicate Main_swift's Copy uses
-// to ship or withhold the trees - so the manifest and the tree agree by
-// construction (a manifest naming a missing path fails the whole package).
 const Package = cmp(async function Package(props: any) {
   const ctx$ = props.ctx$
   const target = props.target
@@ -109,8 +42,6 @@ const Package = cmp(async function Package(props: any) {
   const secrets = swiftSecretsActive(model, target)
   const srcdir = `Sources/${swiftTargetDir(model)}`
 
-  // The SDK target's dependency list: declared package products, then the
-  // three vendored secrets modules when the feature is active.
   const sdkdeps: string[] = deps.map((d) =>
     `.product(name: "${d.product}", package: "${d.identity}")`)
   if (secrets) {

package/project/.sdk/src/cmp/swift/PrepareAuth_swift.ts

@@ -14,131 +14,21 @@ import {
 import { swiftString, swiftTargetDir } from './utility_swift'
 
 
-// WHERE THE CREDENTIAL GOES IS A FACT ABOUT THE API, so it is generated
-// rather than templated. The swift peer of cmp/ts/PrepareAuth_ts.ts; read
-// that one first, it carries the full account of the defect.
-//
-// 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. Four repos in the cedar
-// fleet ship SDKs that cannot authenticate for this reason: 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.
-//
-// SWIFT WAS THE ODD ONE OUT: it had no prepare_auth template to delete.
-// `prepareAuthUtil` was one function among eight in
-// `tm/swift/Sources/ProjectNameSDK/utility/Prepare.swift`, beside
-// prepareMethod/Path/Params/Query/Headers/Body and paramUtil — none of
-// which is model-dependent. So the EXTRACTION is the move, not a rewrite of
-// the module: `prepareAuthUtil` and its three private constants move out of
-// Prepare.swift into this generated `utility/PrepareAuth.swift`, and the
-// other seven functions stay templated where they are.
-//
-// SWIFT LETS THAT WORK WITH NO REWIRING AT ALL. Every .swift file in the
-// SwiftPM target is one MODULE, and a top-level `func` is `internal` by
-// default — visible to the whole module, importable by nothing, declared
-// once. So moving the function to another file in the same target changes
-// no name and no import:
-//
-//   core/Utility.swift      `public var prepareAuth: ((Context) throws -> Spec)!`
-//   utility/Register.swift  `u.prepareAuth = prepareAuthUtil`   <- resolves here
-//   utility/Make.swift      `let spec = try utility.prepareAuth(ctx)`
-//   cmp/swift/fragment/Main.fragment.swift  `_ = try utility.prepareAuth(ctx)`
-//
-// all stand unchanged. The one thing swift does NOT tolerate is the
-// function existing in BOTH files — same module, same name, "invalid
-// redeclaration of 'prepareAuthUtil'", which fails the whole target — so
-// the template copy is deleted in the same change. That is the check that
-// makes a stale copy impossible here, and it is a compile error rather than
-// the silent double-life the ts port hit (see the folder note below).
 const PrepareAuth = cmp(async function PrepareAuth(props: any) {
   const { target } = props
   const { model } = props.ctx$
 
-  // AUTH SWITCHED OFF BY THE PROJECT — and ONLY by that.
-  //
-  // NOT `isAuthActive`, and the difference is load-bearing. That helper is
-  // false whenever `main.kit.info.auth` is false, which only says the SPEC
-  // declared no security scheme; such an SDK still carries a credential,
-  // because `optspec` always declares `apikey` and makeOptions fills
-  // `options.auth` from the optspec defaults — so the runtime
-  // `isNil(auth)` guard below never fires and these SDKs have ALWAYS sent
-  // `options.apikey`. Emitting a no-op for them silently breaks working
-  // authentication and takes the secrets feature with it (it resolves a
-  // secret into `options.apikey`, and prepareAuth then places nothing).
-  //
-  // `main.kit.config.auth.active: false` is the project saying "this SDK
-  // sends no credential, ever" — the only signal that can honestly be
-  // honoured before runtime. `isAuthSuppressed` in @voxgig/sdkgen IS that
-  // predicate (utility.ts), so it is used here rather than re-derived: the
-  // py port wrote its own `isAuthActive_py` before the shared helper
-  // existed, and two copies of one rule is how they drift.
   const suppressed = isAuthSuppressed(model)
 
   const where = resolveAuthIn(model)
 
-  // LOWERCASED FOR A HEADER, VERBATIM OTHERWISE. HTTP header names are
-  // case-insensitive on the wire (RFC 9110 5.1), but this SDK's header bag
-  // is a plain `VMap` keyed in lower case throughout: the code being
-  // extracted said `private let headerAuth = "authorization"`, the shared
-  // corpus asserts `ctx:spec:headers:authorization`, the shipped
-  // PipelineTest reads `headers.entries["authorization"]`, and
-  // SecretsFeature.swift writes `headers.entries["authorization"]` as the
-  // other credential writer. apidef writes `name: "Authorization"`, so
-  // emitting it verbatim would put the credential under a key nothing in
-  // this SDK reads. A query parameter and a cookie ARE case-sensitive
-  // (`?token=` is not `?Token=`), so those keep the spec's spelling.
   const resolvedName = resolveAuthName(model)
   const name = 'header' === where ? resolvedName.toLowerCase() : resolvedName
 
-  // Resolved, and deliberately NOT baked into the emitted source: the
-  // prefix is a RUNTIME option (`options.auth.prefix`) and the code being
-  // extracted read it from the options map, so a caller — and the secrets
-  // feature, which rewrites it there — can still override it per client.
-  // Only the PLACEMENT is fixed at generation time.
   const prefix = resolveAuthPrefix(model)
 
   const basic = isHttpBasicAuth(model)
 
-  // FOLDER NESTING, worked out from the template's own path and from
-  // Main_swift, not guessed.
-  //
-  // The file being replaced lives at
-  // `tm/swift/Sources/ProjectNameSDK/utility/Prepare.swift`, and Main_swift
-  // copies that tree with `Folder({name:'Sources'})` +
-  // `Copy({from:'tm/swift/Sources/ProjectNameSDK', to: swiftTargetDir(model)})`
-  // — note the `to`, which is why the runtime lands under the API's own
-  // name (`Sources/<Name>Sdk/utility/`) rather than under the placeholder
-  // directory. So the full destination is
-  // `Sources/<Name>Sdk/utility/PrepareAuth.swift`.
-  //
-  // ALL THREE SEGMENTS ARE OPENED HERE, and Main calls this at its TOP
-  // level, beside `EntityTypes({ target })` — which is the swift precedent
-  // for exactly this (EntityTypes_swift opens
-  // `Sources`/`swiftTargetDir`/`entity` itself). Two other call sites were
-  // available and both are wrong:
-  //
-  //   * inside Main's generated-sources block, beside `Config({target})`.
-  //     That block sits inside `Folder({name:'core'})`, so this would write
-  //     `Sources/<Name>Sdk/core/utility/PrepareAuth.swift`.
-  //   * inside that block but one level out, opening only `utility`. That
-  //     is correct TODAY and breaks the moment the surrounding folders
-  //     move; self-contained is what EntityTypes_swift chose.
-  //
-  // Getting it wrong is not merely a misplaced file: SwiftPM compiles
-  // EVERY .swift under `Sources/<target>/`, so a stray copy at the wrong
-  // path is still in the module and still collides with the real one. Here
-  // that is a hard build failure — which is the good case, and the reason
-  // the ts port's `src/src/utility/` accident (a second `Folder('src')`,
-  // the stale file still imported, invisible to the suite) cannot repeat on
-  // swift.
   Folder({ name: 'Sources' }, () => {
     Folder({ name: swiftTargetDir(model) }, () => {
       Folder({ name: 'utility' }, () => {
@@ -165,12 +55,6 @@ type AuthSpec = {
 
 
 function render(spec: AuthSpec): string {
-  // Foundation on every file is the tm/swift convention (Prepare.swift,
-  // Make.swift, MakeOptions.swift, Spec.swift all open with it), and the
-  // basic and cookie branches genuinely need it — `base64EncodedString()`
-  // and `trimmingCharacters(in:)` are Foundation. Swift does not warn on an
-  // unused import, so the header branch carrying it costs nothing and keeps
-  // the file shaped like its neighbours.
   const head = `// ${spec.Name} SDK utility: prepareAuth - place the API credential.
 //
 // GENERATED, not templated: WHERE the credential goes - header, query or
@@ -186,9 +70,6 @@ import Foundation
 `
 
   if (spec.suppressed) {
-    // The project set `main.kit.config.auth.active: false`. No credential,
-    // ever — so the SDK gets a prepareAuth that is honest about it rather
-    // than one that pops a header nobody set.
     return head + `
 // This SDK is configured with authentication OFF
 // (main.kit.config.auth.active is false), so there is no credential to
@@ -211,11 +92,6 @@ func prepareAuthUtil(_ ctx: Context) throws -> Spec {
 }
 
 
-// HEADER. Byte-for-byte the function that was in Prepare.swift when the
-// scheme resolves to the defaults (header / Authorization) and is not
-// Basic — same constant names, same `skip` shape, same removeValue /
-// entries[...] idioms, same error. Only the constant's VALUE moves with the
-// model, plus the Basic block, which is emitted only for a basic scheme.
 function renderHeader(spec: AuthSpec): string {
   const basicConst = spec.basic ? `
 private let optionSecret = "secret"` : ''
@@ -300,11 +176,6 @@ function basicBlock(spec: AuthSpec): string {
 }
 
 
-// QUERY. The credential is a query parameter, so it goes in `spec.query` and
-// the headers are never touched. `spec.query` is the bag makeUrl builds the
-// query string from (utility/Make.swift), and prepareAuth runs AFTER
-// prepareQuery in makeSpec, so the credential joins the op's own arguments
-// rather than being overwritten by them.
 function renderQuery(spec: AuthSpec): string {
   return `
 private let queryAuth = ${swiftString(spec.name)}
@@ -349,11 +220,6 @@ func prepareAuthUtil(_ ctx: Context) throws -> Spec {
 }
 
 
-// COOKIE. A cookie IS a header, so the credential rides the header bag -
-// but the `cookie` header is SHARED with whatever cookies the caller set, so
-// the pair is spliced in and out rather than the header assigned over.
-// Splicing is also what makes it idempotent: a retried request cannot end up
-// carrying the credential twice.
 function renderCookie(spec: AuthSpec): string {
   return `
 private let cookieHeader = "cookie"

package/project/.sdk/src/cmp/swift/ReadmeEntity_swift.ts

@@ -11,7 +11,6 @@ import { swiftVarName } from './utility_swift'
 
 // Type names come from the shared canonToType 'swift' column (single source of truth).
 
-// A type-correct Swift `Value` literal for a field's canonical type.
 function swiftLit(type: any, placeholder: string = 'example'): string {
   const k = canonScalarKey(type)
   if ('INTEGER' === k) return '.int(1)'
@@ -57,7 +56,6 @@ const ReadmeEntity = cmp(function ReadmeEntity(props: any) {
   publishedEntities.map((entity: any) => {
     const opnames = Object.keys(entity.op || {})
     const fields = entity.fields || []
-    // Model-driven id key: null when this entity has no id-like field.
     const idF = entityIdField(entity)
     // Sanitise the local variable name — a camelCased Swift keyword gets a
     // trailing underscore (swiftVarName) so the snippet compiles.

package/project/.sdk/src/cmp/swift/ReadmeExamplesTest_swift.ts

@@ -2,28 +2,6 @@
 import { cmp, File, Content } from '@voxgig/sdkgen'
 
 
-// Emits Tests/ProjectNameSDKTests/ReadmeExamplesTest.swift — a PRESENCE +
-// STRUCTURE gate over every swift fenced block in the repository ROOT
-// README.md, the per-language swift/README.md, AND swift/REFERENCE.md. It is a
-// plain XCTestCase (no @testable import — it only reads the doc files off
-// disk), resolved relative to the test file via #filePath.
-//
-// SCOPE NOTE (deliberate, documented): the Python/TS/Go equivalents EXECUTE and
-// type-check every documented block. That is infeasible here — the generated
-// Swift SDK compiles with SwiftPM only (no in-process Swift compiler wired into
-// the test runtime), so a test cannot compile-and-run arbitrary doc snippets at
-// test time. This gate therefore guarantees the weaker-but-real invariant that
-// keeps the docs honest as the generator evolves:
-//   1. PRESENCE: every scanned doc that exists holds at least one swift block
-//      (nothing was dropped);
-//   2. STRUCTURE: every swift block's braces / parens / brackets balance
-//      (ignoring string literals and line comments), catching a truncated or
-//      malformed generated snippet.
-//
-// The emitted Swift is written WITHOUT literal backticks (the fence marker is
-// built at runtime as String(repeating: "\u{60}", count: 3)) so this TS
-// template literal stays clean, and uses string concatenation instead of Swift
-// interpolation to keep backslash-escaping in this template minimal.
 const ReadmeExamplesTest = cmp(function ReadmeExamplesTest(props: any) {
   const { ctx$: { model } } = props
 

package/project/.sdk/src/cmp/swift/ReadmeRef_swift.ts

@@ -1,5 +1,5 @@
 
-import { cmp, each, Content, canonToType, canonKey, canonScalarKey, File, isAuthActive, entityIdField, opRequestShape } from '@voxgig/sdkgen'
+import { cmp, each, Content, canonToType, canonKey, canonScalarKey, File, isAuthActive, entityIdField, opRequestShape , targetFeatures } from '@voxgig/sdkgen'
 import { ReadmeRefFeatures } from '@voxgig/sdkgen'
 
 import {
@@ -60,7 +60,7 @@ const ReadmeRef = cmp(function ReadmeRef(props: any) {
   const SDK = model.const.Name + 'SDK'
 
   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)
 
@@ -377,9 +377,6 @@ let client = ${SDK}(options)
 \`\`\`
 
 `)
-      // 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/swift/Schema_swift.ts

@@ -12,24 +12,6 @@ import {
 } from '@voxgig/apidef'
 
 
-// THE GENERATED SCHEMA MODULE: the model's schemas, as data the SDK can run.
-//
-// The swift 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 swift validates against and what ts validates against
-// cannot drift.
-//
-// EMBEDDED AS JSON, PARSED AT LOAD, where ts emits an object literal: JSON is
-// a subset of TypeScript's own literal syntax and is not a subset of swift's.
-// A raw string literal, exactly as Config.swift carries its config — raw
-// (`#"""`) so the spec's own backslashes and quotes need no re-escaping.
-//
-// 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. That is not incidental — JSON.parse decodes a
-// JSON number to one Value case and struct reads a spec BY EXAMPLE, so one
-// number in here would mean something different in swift than in ts.
 const Schema = cmp(async function Schema(props: any) {
   const ctx$ = props.ctx$
   const target = props.target

package/project/.sdk/src/cmp/swift/TestEntity_swift.ts

@@ -33,10 +33,6 @@ final class ${entity.Name}EntityTest: XCTestCase {
   }
 `)
 
-    // Stream test (PR #4): the entity `stream` method runs the op pipeline and
-    // returns an AsyncStream. 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 that support list.
     if (hasList) {
       Content(`
   func testStream() async throws {