@voxgig/sdkgen 4.21.0 → 4.22.0

package/project/.sdk/src/cmp/c/utility_c.ts

@@ -23,13 +23,6 @@ function cVarName(name: string): string {
 }
 
 
-// The C project identifier used as a function-name prefix, e.g. solar. Must
-// match the SQUASHED `projectname` token that the umbrella header/fragment use
-// for the constructor (`<ident>_sdk_new`): a hyphenated slug
-// (bluefin-decryptx-p2pe) squashes to `bluefindecryptxp2pe`, so drop every
-// non-alphanumeric char rather than mapping them to `_` (which produced
-// `bluefin_decryptx_p2pe_sdk_new` callers that never linked against the
-// squashed definition). No-op for single-word names.
 function cIdent(model: any): string {
   return String(model.name).toLowerCase().replace(/[^a-z0-9]/g, '')
 }
@@ -88,29 +81,6 @@ function formatCValue(val: any, indent: number = 0): string {
 }
 
 
-// Deep-remove meta keys (`foo$`) from a model subtree (twin of go/rust clean).
-// 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
@@ -151,23 +121,6 @@ function clean(o: any, dropDefaults?: boolean): any {
 
 
 
-// The JSON as a C string literal, split into ADJACENT literals.
-//
-// C99 only guarantees 4095 characters in a single string literal, and a real
-// model runs to hundreds of kilobytes. Adjacent literals are concatenated by
-// the translation phase before that limit applies, so this stays portable
-// rather than relying on gcc/clang having no practical limit.
-//
-// Only `\` and `"` need escaping: JSON.stringify output contains no raw
-// control characters (it writes them as the six TEXT characters \u00XX), and
-// C string literals take UTF-8 bytes verbatim. Escaping the backslash also
-// means no `\uXXXX` ever reaches the C lexer, which matters - a universal
-// character name below 0xA0 is ill-formed C, so the JSON's own escapes would
-// have been rejected if they had been passed through.
-//
-// Chunks are cut from the RAW text and escaped afterwards, so a cut can never
-// land inside an escape sequence. Surrogate pairs are kept whole, or the cut
-// would emit a lone surrogate as invalid UTF-8.
 function cStringLiteral(json: string, chunkSize: number = 2000): string {
   const parts: string[] = []
   let i = 0

package/project/.sdk/src/cmp/clojure/Config_clojure.ts

@@ -44,33 +44,8 @@ const Config = cmp(async function Config(props: any) {
 
   const model: Model = ctx$.model
 
-  // The canonical config OBJECT and its JSON, from the shared helper. Both
-  // representations render from the same `def`, so they cannot describe
-  // different configs - and this target picks up `options.server` (the OpenAPI
-  // server-variable defaults), which the hand-rolled build here omitted.
-  // Passing target.name opts this target into the main slug/version/target
-  // identity fields (read by station's descriptor - see configDefinition).
   const { def: config, json: baseJson } = configDefinition(model, target.name)
 
-  // WHERE THE CREDENTIAL GOES, AND UNDER WHAT NAME, travel with the prefix
-  // now. apidef resolved `in` and `name` from the spec's securityScheme all
-  // along 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
-  // a header-based SDK's config.clj is byte-identical to what it generated
-  // before - the `asData` threshold included, since that is measured on the
-  // JSON built here.
-  //
-  // Both representations still render from this ONE `def` (the literal
-  // through formatCljValue, the data rep through the JSON), so they cannot
-  // describe different configs. The shared configDefinition is deliberately
-  // NOT changed: it feeds every target, and this is the clojure rollout.
-  //
-  // core.clj's optspec had to learn the two keys as well ("auth" (vs/jm
-  // "prefix" "" "basic" false "in" "" "name" "")) - `vs/validate` refuses a
-  // key it does not name, so without that an SDK carrying this block could
-  // not be constructed at all.
   const authIn = resolveAuthIn(model)
   const authName = resolveAuthName(model)
   const configAuth = config?.options?.auth
@@ -83,28 +58,6 @@ const Config = cmp(async function Config(props: any) {
 
   const asData = isConfigData(configJson, configReprSetting(model))
 
-  // THE FEATURE WIRING (the clojure peer of Config_go's pluginImports /
-  // FeaturePlugins, and of Config_ts's pluginDefs).
-  //
-  // Two maps, both always emitted so sdk.features can name them without
-  // knowing whether this SDK selected anything:
-  //
-  //   feature-plugins  the voxgig/plugin DEFINITIONS the model's plugin
-  //                    groups selected, per feature. Upstream sekreto's
-  //                    contract since the registry was retired is that a
-  //                    provider kind not passed in is unknown to that
-  //                    Sekreto - so this map IS the SDK's provider
-  //                    vocabulary, and an inactive group leaves neither a
-  //                    require nor a reference behind.
-  //
-  //   feature-extra    the constructor for each feature whose source lives
-  //                    outside src/sdk/features.clj. make-feature consults
-  //                    it rather than requiring the container directly,
-  //                    which is what keeps the ~35 vendored namespaces out
-  //                    of every clojure SDK's load graph.
-  //
-  // Emitted HERE (not in the feature container) so the load order is
-  // core -> feature/secrets -> config -> features -> client, with no cycle.
   const extra = extraFeatures(model, target)
   const { requires: plugreq, plugins: featplugins } = pluginRequires(model, target)
 
@@ -126,17 +79,6 @@ const Config = cmp(async function Config(props: any) {
 
   File({ name: 'config.clj' }, () => {
 
-    // ABOVE THE THRESHOLD: emit the model as DATA.
-    //
-    // The literal is one nested form the Clojure reader walks and the compiler
-    // turns into constructor calls at load; a string is one token, and
-    // `sdk.core/json-parse` builds the same LinkedHashMap/ArrayList nodes
-    // `vs/jm` and `vs/jt` produce. It is already the SDK's response decoder,
-    // so this adds no dependency.
-    //
-    // JSON.stringify output is a valid Clojure string literal: it escapes
-    // every backslash, so the JSON's own `\uXXXX` reaches the reader as
-    // `\\uXXXX` and no Clojure escape is ever formed from it.
     if (asData) {
       Content(`;; ${model.const.Name} SDK configuration (generated by @voxgig/sdkgen).
 ;;
@@ -166,11 +108,6 @@ ${wireBlock}`)
 })
 
 
-// The augmentation above must be a NO-OP for a header/Authorization SDK, and
-// that is the whole byte-identity claim - so it is checked rather than
-// asserted in a comment. A future change to configDefinition that starts
-// emitting `in`/`name` itself would make this fire rather than silently
-// double up.
 function assertHeaderIdentity(now: string, before: string, authIn: string, authName: string) {
   const defaults = 'header' === authIn && 'Authorization' === authName
   if (defaults && now !== before) {

package/project/.sdk/src/cmp/clojure/Entity_clojure.ts

@@ -24,7 +24,6 @@ const Entity = cmp(function Entity(props: any) {
 
   const ff = Path.normalize(__dirname + '/../../../src/cmp/clojure/fragment/')
 
-  // Entity files go to src/sdk/entity/<name>.clj (ns sdk.entity.<name>).
   Folder({ name: 'src' }, () => {
     Folder({ name: 'sdk' }, () => {
       Folder({ name: 'entity' }, () => {

package/project/.sdk/src/cmp/clojure/Main_clojure.ts

@@ -26,11 +26,6 @@ import { MainEntity } from './MainEntity_clojure'
 import { PrepareAuth } from './PrepareAuth_clojure'
 
 
-// Features that ship a top-level `feature/<name>/` container in
-// tm/clojure. Listed rather than discovered: a component cannot walk the
-// template tree, and the list is short and changes with the templates it
-// describes. Anything named here is EXCLUDED from the verbatim copy unless
-// the model selects it (see the Copy below).
 const CONTAINED = ['secrets']
 
 
@@ -45,33 +40,6 @@ const Main = cmp(async function Main(props: any) {
 
   Gitignore({})
 
-  // Copy tm/clojure verbatim (runtime under src/, the test suite under test/,
-  // Makefile/LICENSE/VERSION). The feature-add scaffolding under src/feature
-  // is excluded — the clojure target does not use per-feature custom source.
-  //
-  // THE TOP-LEVEL feature/ CONTAINER IS GATED HERE, at generate time.
-  //
-  // clojure declares `feature: trim: false` (model/target/clojure.aon)
-  // because every ordinary feature lives in the single generated module
-  // src/sdk/features.clj, so `target add` copies the whole template tree.
-  // That was harmless while nothing per-feature existed. It stopped being
-  // harmless with `secrets`: its container holds a vendored
-  // @voxgig/sekreto port and the voxgig/plugin runtime, and an SDK that
-  // never asked for secrets would otherwise ship ~35 files of key-store,
-  // request-signing and child-process code. So the container is excluded
-  // unless the model SELECTS the feature — the top-level-container peer of
-  // the `srcFeatureExcludes` gate ts and js apply to src/feature/<name>/.
-  //
-  // pluginExcludes: one level deeper, the generate-time plugin trim. An
-  // INACTIVE plugin group's declared files stay out of the tree; the
-  // model's `path` entries are target-root-relative, which is this Copy's
-  // root. It runs independently of `feature.trim`, so the group trim works
-  // while that decision stands.
-  //
-  // The gated feature's own TEST suite goes with it, and is named
-  // separately: it lives at test/sdk/test/feature/<name>.clj (a file, so
-  // the container pattern's trailing slash does not reach it) because
-  // Clojure resolves `sdk.test.feature.<name>` to that exact path.
   const featureGate = extraFeatures(model, target).map((f: any) => f.name)
   const containerExcludes = CONTAINED
     .filter((name: string) => !featureGate.includes(name))
@@ -88,15 +56,6 @@ const Main = cmp(async function Main(props: any) {
     }
   })
 
-  // Generated config namespace (src/sdk/config.clj), and the generated
-  // credential placement (src/sdk/prepare_auth.clj).
-  //
-  // BOTH SIT IN THIS ONE src/sdk PAIR, and neither opens a folder of its own.
-  // The Copy above roots tm/clojure at the target root, so the copied
-  // core.clj lands at src/sdk/core.clj; prepare_auth.clj has to be its
-  // SIBLING, because core.clj reads it with `(load "prepare_auth")` and that
-  // resolves to the classpath resource `sdk/prepare_auth.clj` under
-  // deps.edn's `:paths ["src"]`.
   Folder({ name: 'src' }, () => {
     Folder({ name: 'sdk' }, () => {
       Config({ target })

package/project/.sdk/src/cmp/clojure/Package_clojure.ts

@@ -16,26 +16,6 @@ import {
 } from './featureextra_clojure'
 
 
-// deps.edn — the tools.deps manifest. The vendored voxgig struct port needs no
-// external dependency; the library itself only needs org.clojure/clojure. The
-// tools.deps shim used to run the tests supports `-M:alias` reading :paths /
-// :extra-paths / :main-opts, but NOT per-alias :extra-deps, so every dependency
-// lives at the top-level :deps.
-//
-// `test/vendor/omni` is a SECOND test source root, not a subdirectory of the
-// first: the vendored @voxgig/omni port declares `voxgig.omni.runner`, so its
-// namespaces resolve only when the directory holding `voxgig/` is itself on
-// the classpath. Rooting it at `test` instead would demand the namespace
-// `vendor.omni.voxgig.omni.runner`, which the vendored file cannot carry -
-// it is read-only, resynced from upstream.
-//
-// A feature whose source ships as its own tree - `secrets`, which vendors
-// a whole @voxgig/sekreto port - needs the SAME treatment for the SAME
-// reason: the vendored files declare `voxgig.sekreto.chain`, so they
-// resolve only when the directory holding `voxgig/` is on the classpath.
-// So `feature/<name>` joins :paths, and only when the model selects that
-// feature: an SDK that did not ask for secrets gets the deps.edn it always
-// had, naming no directory that is not there.
 const Package = cmp(async function Package(props: any) {
   const ctx$ = props.ctx$
   const target = props.target

package/project/.sdk/src/cmp/clojure/PrepareAuth_clojure.ts

@@ -16,66 +16,10 @@ import {
 } from '@voxgig/apidef'
 
 
-// WHERE THE CREDENTIAL GOES IS A FACT ABOUT THE API, so it is generated
-// rather than templated. The clojure port of cmp/ts/PrepareAuth_ts.ts; see
-// that file for 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 that way: joplin (`token`), pipedrive (`api_token`), trello
-// (`key`), lm-umbrella (`apiKey`).
-//
-// CLOJURE HAD NO prepare_auth TEMPLATE TO REPLACE. The other twelve targets
-// each had a standalone file; here the logic was EMBEDDED in
-// tm/clojure/src/sdk/core.clj as `u-prepare-auth`, three constants above it,
-// and the `:prepare-auth u-prepare-auth` entry in `base-utility-map`.
-//
-// THE EXTRACTION SHAPE: its own FILE, still inside the sdk.core NAMESPACE.
-//
-// A separate namespace is not available, and not for a stylistic reason.
-// `u-prepare-auth` calls `oget`, `ctx-error` and `client-options-map`, all
-// defined in sdk.core, while sdk.core's `base-utility-map` must reference
-// `u-prepare-auth` — so `(:require [sdk.prepare-auth])` from sdk.core plus
-// `(:require [sdk.core])` back is a load cycle, which Clojure refuses
-// outright ("Cyclic load dependency"). The alternatives are worse: passing
-// four core functions in as arguments, or late-binding through an atom the
-// way kotlin's `lateinit var prepareAuth` does, would both restructure the
-// runtime to work around a problem Clojure already has an answer for.
-//
-// That answer is `load`, the idiom clojure.core itself uses to split across
-// files (core.clj does `(load "core_deftype")`, `(load "core_print")`, …).
-// The generated file opens with `(in-ns 'sdk.core)` and is READ INTO sdk.core
-// at the exact point the defn used to sit, so:
-//
-//   - every helper it calls is already defined above it, unchanged;
-//   - the symbol `u-prepare-auth` resolves in `base-utility-map` exactly as
-//     before, so the `:prepare-auth` binding is untouched;
-//   - `core/HEADER-AUTH`, which feature/secrets/sdk/feature/secrets.clj
-//     reads, is still a public var of sdk.core;
-//   - and the call sites — `(ucall ctx :prepare-auth)` in core.clj's
-//     `u-make-spec`, `((core/uget ctx :prepare-auth) ctx)` in client.clj's
-//     `prepare`, and the same spelling in test/sdk/test/pipeline.clj and
-//     test/sdk/test/primary.clj — all still go through the utility map.
-//
-// A template cannot fix the defect, because the three placements need three
-// different bodies and a template has to pick one. This emits the branch the
-// 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.
 const PrepareAuth = cmp(async function PrepareAuth(props: any) {
   const { target } = props
   const model: Model = props.ctx$.model
 
-  // NO FOLDER IS OPENED HERE, and that is the whole of the placement
-  // decision. Main_clojure calls this inside its `Folder({name:'src'}) >
-  // Folder({name:'sdk'})` pair — the same pair Config sits in, and Config
-  // opens no folder of its own either. The file has to land beside the
-  // copied core.clj at `src/sdk/prepare_auth.clj`, because deps.edn declares
-  // `:paths ["src"]` and `(load "prepare_auth")` from the namespace sdk.core
-  // resolves to the CLASSPATH RESOURCE `sdk/prepare_auth.clj`. Opening a
-  // second `src`/`sdk` here would write `src/sdk/src/sdk/prepare_auth.clj`,
-  // which is not that resource.
   File({ name: 'prepare_auth.' + target.ext }, () => {
     Content(render({
       Name: model.const.Name,
@@ -83,9 +27,6 @@ const PrepareAuth = cmp(async function PrepareAuth(props: any) {
       where: resolveAuthIn(model),
       name: resolveAuthName(model),
       basic: isHttpBasicAuth(model),
-      // Read so the resolution is visible at generation time even though the
-      // emitted code takes the prefix from options at runtime (the secrets
-      // feature rewrites it there).
       prefix: resolveAuthPrefix(model),
     }))
   })
@@ -122,45 +63,16 @@ function render(spec: AuthSpec): string {
 }
 
 
-// HEADER NAMES ARE LOWER-CASED; QUERY PARAMETER AND COOKIE NAMES ARE NOT.
-//
-// `resolveAuthName` answers 'Authorization' by default, but the whole clojure
-// runtime spells header names in lower case: the template this replaces held
-// `(def HEADER-AUTH "authorization")`, the shipped
-// test/sdk/test/feature/secrets.clj reads `(vs/getprop headers
-// "authorization")`, test/sdk/test/pipeline.clj asserts on the same key, and
-// the shared corpus asserts `ctx:spec:headers:authorization`. The spec's
-// headers are a java.util.LinkedHashMap, whose keys are case-SENSITIVE, so
-// emitting "Authorization" would put the credential under a key nothing
-// reads. 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 go in verbatim.
 function headerName(name: string): string {
   return String(name).toLowerCase()
 }
 
 
-// `core/HEADER-AUTH` IS PART OF sdk.core's PUBLIC SURFACE, so it is emitted
-// for every placement: feature/secrets/sdk/feature/secrets.clj writes the
-// re-authenticated credential with `(.put ^java.util.Map headers
-// core/HEADER-AUTH ...)`, and an SDK that resolves secrets would not compile
-// without the var.
-//
-// For a header scheme it is the header this SDK actually uses, so the two
-// writers agree by construction. For a query or cookie scheme the secrets
-// feature has no header of its own to name — its re-auth is an Authorization
-// rewrite, and the shipped suite asserts that literal — so the var keeps the
-// value it has always had rather than being pointed at a query parameter
-// name that means nothing in a header.
 function headerAuthConst(spec: AuthSpec): string {
   return 'header' === spec.where ? headerName(spec.name) : 'authorization'
 }
 
 
-// HEADER. Byte-for-byte the block that was in core.clj when the scheme
-// resolves to the defaults (header / Authorization), so every header-based
-// SDK regenerates unchanged — only the constant's VALUE moves with the model,
-// plus the HTTP Basic branch, which is emitted only for a basic scheme.
 function renderHeader(spec: AuthSpec, head: string): string {
   return head + `(def HEADER-AUTH ${cljstr(headerName(spec.name))})
 (def OPTION-APIKEY "apikey")
@@ -182,9 +94,6 @@ ${spec.basic ? basicBlock() : headerPlace(14)}
 }
 
 
-// The template's own body, unchanged: an empty prefix (a raw apiKey
-// credential) must not add a leading space, and a missing credential deletes
-// whatever was there rather than leaving a stale value behind.
 function headerPlace(col: number): string {
   const p = ' '.repeat(col)
   return `${p}(if (or (nil? apikey) (and (string? apikey) (or (= apikey NOT-FOUND) (= apikey ""))))
@@ -196,11 +105,6 @@ ${p}          (if (= auth-prefix "") apikey-val (str auth-prefix " " apikey-val)
 }
 
 
-// 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.
 function basicBlock(): string {
   return `              ;; True HTTP Basic Auth needs TWO credentials, base64-joined - a
               ;; single token in the header (the branch below) can never
@@ -221,9 +125,6 @@ ${headerPlace(16)})`
 }
 
 
-// QUERY. The credential is a query parameter, so it goes in the spec's query
-// map (which u-make-url turns into the query string) and the headers are
-// never touched.
 function renderQuery(spec: AuthSpec, head: string): string {
   return head + `;; Retained for feature/secrets, whose re-auth writes an Authorization
 ;; header; this SDK's own credential is a query parameter (see QUERY-AUTH).
@@ -253,11 +154,6 @@ function renderQuery(spec: AuthSpec, head: string): string {
 }
 
 
-// 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 our
-// own pair is spliced in and out rather than the header being assigned over.
-// Splicing also makes this idempotent: a retried request cannot end up
-// carrying the credential twice.
 function renderCookie(spec: AuthSpec, head: string): string {
   return head + `;; Retained for feature/secrets, whose re-auth writes an Authorization
 ;; header; this SDK's own credential is a cookie (see COOKIE-AUTH).
@@ -331,30 +227,6 @@ function renderInactive(spec: AuthSpec, head: string): string {
 }
 
 
-// NOT `isAuthActive`, AND THE DIFFERENCE IS LOAD-BEARING (the py and rb ports
-// 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
-// sdkgen's own generate fixture — and those SDKs are still expected to honour
-// an `apikey` the caller passes. core.clj's optspec ALWAYS declares `apikey`
-// and `auth`, and make-options fills `options.auth` from those defaults, so
-// the runtime `(nil? (vs/getprop options "auth"))` guard never fires and the
-// credential has always gone out.
-//
-// 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. The shipped tm/clojure/test/sdk/test/feature/secrets.clj
-// suite, which sdkgen's own `clojure: the secrets feature runs with the
-// feature active` lane runs, is what catches it.
-//
-// So the no-op is emitted only when the PROJECT says so:
-// `main.kit.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 })
@@ -362,8 +234,6 @@ function authSwitchedOn(model: any): boolean {
 }
 
 
-// A Clojure string literal. The reader's escapes are backslash-led, so only
-// the backslash and the double quote need handling.
 function cljstr(s: string): string {
   return '"' + String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"') + '"'
 }

package/project/.sdk/src/cmp/clojure/ReadmeExamplesTest_clojure.ts

@@ -2,22 +2,6 @@
 import { cmp, Content } from '@voxgig/sdkgen'
 
 
-// Emit a documentation clojure-examples SYNTAX gate INTO the shared gentest run
-// body (the clojure test runner drives a single sdk.gentest/run). For each doc
-// that ships clojure examples — the repository ROOT README.md, the per-language
-// README.md, and REFERENCE.md — every ```clojure fenced block is extracted and
-// PARSED with read-string (all forms wrapped in a vector), catching a malformed
-// documented example (an unbalanced paren, a bad token, an unclosed string).
-//
-// SCOPE NOTE: like the elixir gate, this stops at the syntax check rather than
-// EXECUTING each block. Running a README fragment against the generated
-// namespaces would need the SDK loaded and the narrative requires resolved for
-// every block; the syntax gate is a real, useful guard that keeps documented
-// examples parseable as the generator evolves. A doc that is absent at test
-// time is skipped (passes), so the gate never hard-fails on a missing file.
-//
-// The emitted clojure builds the triple-backtick fence from (char 96) so this
-// TS template literal needs no embedded backticks.
 const ReadmeExamplesTest = cmp(function ReadmeExamplesTest(_props: any) {
 
   Content(`  (letfn [(fence-pat [] (re-pattern (apply str (repeat 3 (char 96)))))

package/project/.sdk/src/cmp/clojure/ReadmeRef_clojure.ts

@@ -1,5 +1,5 @@
 
-import { cmp, each, Content, canonKey, canonScalarKey, File, isAuthActive, entityIdField, opRequestShape } from '@voxgig/sdkgen'
+import { cmp, each, Content, canonKey, canonScalarKey, File, isAuthActive, entityIdField, opRequestShape , targetFeatures } from '@voxgig/sdkgen'
 import { ReadmeRefFeatures } from '@voxgig/sdkgen'
 
 import {
@@ -66,7 +66,7 @@ const ReadmeRef = cmp(function ReadmeRef(props: any) {
   const { model } = props.ctx$
 
   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)
 
@@ -397,9 +397,6 @@ Features are activated via the \`feature\` option:
 \`\`\`
 
 `)
-      // 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/clojure/Schema_clojure.ts

@@ -17,26 +17,6 @@ import {
 } from './utility_clojure'
 
 
-// THE GENERATED SCHEMA NAMESPACE: the model's schemas, as data the SDK runs.
-//
-// The clojure peer of src/cmp/ts/Schema_ts.ts. 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
-// clojure validates against and what ts validates against cannot drift.
-//
-// DATA ONLY, AND THAT IS STRUCTURAL. This namespace requires nothing and
-// exposes the raw JSON strings; `sdk.core` parses them. The parse it would
-// otherwise call, `json-parse`, is defined in sdk.core itself — and sdk.core
-// is what reads the spec — so a schema ns that required core to parse its own
-// data would close a require cycle. Holding the strings here and parsing
-// there is the only arrangement that does not.
-//
-// Chunked the way config.clj chunks its model: the JVM caps a string literal
-// at 64KB, so `cljStringChunks` splits and `str` rejoins at load.
-//
-// 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

package/project/.sdk/src/cmp/clojure/TestDirect_clojure.ts

@@ -6,12 +6,6 @@ import {
 } from '@voxgig/sdkgen'
 
 
-// Emit per-entity direct()/prepare() checks INTO the shared gentest run body
-// (the clojure test runner drives a single sdk.gentest/run). Only entities
-// with a read op get a check — matching the py/elixir TestDirect gate — so an
-// op-less entity does not fabricate a request path. The checks exercise the
-// raw-HTTP escape hatch: prepare() builds a fetchdef without sending, and
-// direct() runs a live-mode client against an in-test mock system.fetch.
 const TestDirect = cmp(function TestDirect(props: any) {
   const { model } = props.ctx$
   const entity = props.entity

package/project/.sdk/src/cmp/clojure/TestEntity_clojure.ts

@@ -2,13 +2,6 @@
 import { cmp, Content } from '@voxgig/sdkgen'
 
 
-// Emit per-entity model-driven checks INTO the shared gentest run body (the
-// clojure test runner drives a single sdk.gentest/run). Covers: entity
-// accessor existence, a create+list smoke run through the in-memory test-mode
-// mock transport (exercising the full operation pipeline, hooks and run-op),
-// and the streaming entity fn. API-agnostic behaviour (pipeline error
-// branches, all features, netsim, primary utility, struct corpus) lives in the
-// static template test namespaces.
 const TestEntity = cmp(function TestEntity(props: any) {
   const e = props.entity
 
@@ -46,9 +39,6 @@ const TestEntity = cmp(function TestEntity(props: any) {
 `)
   }
 
-  // stream(action, args, callopts): runs the op through the full pipeline and
-  // returns a lazy seq of items. Seeds three records via the test mock and
-  // streams them; needs only a list op.
   if (hasList) {
     Content(`  (t/run-check rec "gen-stream-${e.name}"
     (fn [] (let [seed (vs/jm "${e.name}" (vs/jm "S1" (vs/jm "id" "S1" "name" "a")

package/project/.sdk/src/cmp/clojure/Test_clojure.ts

@@ -10,14 +10,6 @@ import { TestDirect } from './TestDirect_clojure'
 import { ReadmeExamplesTest } from './ReadmeExamplesTest_clojure'
 
 
-// Generates sdk/gentest.clj (ns sdk.gentest): the API-specific tests, driven by
-// the model. Exposes (run rec) which the template test-runner invokes. This is
-// the orchestrator: it emits the namespace form and the single (run rec) entry
-// point, then delegates the per-entity checks to TestEntity (accessor +
-// create/list smoke + stream) and TestDirect (prepare + direct escape hatch),
-// and finally the documentation clojure-examples syntax gate (ReadmeExamples).
-// API-agnostic behaviour (pipeline error branches, all features, netsim,
-// primary utility, struct corpus) lives in the static template test namespaces.
 const Test = cmp(function Test(props: any) {
   const { model } = props.ctx$
   const { target } = props

package/project/.sdk/src/cmp/clojure/featureextra_clojure.ts

@@ -11,26 +11,6 @@ import {
 } from '@voxgig/apidef'
 
 
-// FEATURES WHOSE CLOJURE SOURCE LIVES OUTSIDE src/sdk/features.clj.
-//
-// Every ordinary feature is one arm of the hand-written `make-feature`
-// factory in that single module. A feature that vendors a LIBRARY cannot
-// be: `secrets` carries a whole @voxgig/sekreto port, and that port has to
-// be droppable for a project that did not ask for it. So its
-// implementation lives in the gated feature container instead
-// (`feature/secrets/sdk/feature/secrets.clj`, namespace
-// `sdk.feature.secrets`) and the generated config wires it in.
-//
-// The container is ALSO a classpath root. Clojure resolves
-// `(require 'voxgig.sekreto.chain)` to `voxgig/sekreto/chain.clj` searched
-// from each `:paths` entry - never by relative import - so the directory
-// holding `voxgig/` must itself be on the classpath. Package_clojure adds
-// `feature/<name>` to `:paths` for exactly the entries below that are
-// active. (`test/vendor/omni` is the same rule, already in that file.)
-//
-// A map rather than a convention because both halves are decisions:
-// WHICH namespace the container publishes, and WHAT the constructor is
-// called. A new one is added here, and nowhere else.
 const EXTRA: Record<string, { ns: string, ctor: string }> = {
   secrets: { ns: 'sdk.feature.secrets', ctor: 'secrets-feature' },
 }
@@ -64,20 +44,6 @@ function extraFeatures(model: Model, target: any): ExtraFeature[] {
 }
 
 
-// The plugin DEFINITIONS the model selected, per feature.
-//
-// `def.clojure` keys are FULLY-QUALIFIED vars
-// (`voxgig.sekreto.plugins.aws/awssecrets`); the namespace is the part
-// before the `/`, and one namespace may export several definitions (aws
-// exports two). Emitted as `(:require [<ns> :as p-<tail>])` plus
-// `p-<tail>/<var>` references, so an INACTIVE group leaves no require and
-// no reference - which is what makes the generate-time file trim safe.
-//
-// `only_active: false` is NOT used here, deliberately: this reads the
-// ACTIVE plugins, because these become references to files that must
-// exist. The trim (pluginExcludes, in Main_clojure) reads the unfiltered
-// map instead. Getting that backwards emits a require for a namespace the
-// trim just deleted.
 function pluginRequires(model: Model, target: any): {
   requires: { ns: string, alias: string }[],
   plugins: Record<string, string[]>,