@voxgig/sdkgen 4.21.0 → 4.22.0

package/project/.sdk/src/cmp/scala/Config_scala.ts

@@ -41,29 +41,10 @@ const Config = cmp(async function Config(props: any) {
 
   const entity = getModelPath(model, `main.${KIT}.entity`)
   const { def: configDef } = configDefinition(model, target.name)
-  // 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`) || {}
 
-  // PLUGIN DEFINITIONS, per feature (the scala peer of Config_go's
-  // featurePlugins map and Config_ts's pluginDefs).
-  //
-  // Since sekreto retired its import-time registry, provider kinds are
-  // voxgig/plugin definitions: a kind the caller did not pass in via
-  // `plugins` is unknown to that Sekreto. So the config names each active
-  // plugin's exported Definition and hands the list to the feature.
-  //
-  // The scala symbols are fully-qualified top-level `val`s
-  // (`com.voxgig.sekreto.plugins.hashicorp`), so unlike go there is no
-  // import to emit - and an inactive group therefore leaves no reference at
-  // all behind for the generate-time plugin trim to dangle.
-  //
-  // Typed List[Any], never List[Definition]: core must not name a vendored
-  // type, or a tree carrying the feature source without the feature selected
-  // would fail to compile.
   const featurePlugins: Record<string, string[]> = {}
   each(feature, (f: any) => {
     const syms: string[] = []
@@ -113,12 +94,6 @@ const Config = cmp(async function Config(props: any) {
   }
   if (authActive) {
     const auth: Record<string, any> = { prefix: authPrefix }
-    // ONLY WHEN THEY DIFFER FROM THE DEFAULT. `in: 'header'` and
-    // `name: 'Authorization'` are what resolveAuthIn/resolveAuthName answer
-    // for a spec that says nothing, and what the generated
-    // utility/PrepareAuth.scala assumes, so emitting them would be pure
-    // payload AND would move every existing header SDK's Config.scala. An
-    // apiKey-in-query API (joplin's `?token=`) is the case that needs them.
     if (authBasic) auth.basic = true
     if ('header' !== authIn) auth.in = authIn
     if ('Authorization' !== authName) auth.name = authName
@@ -127,12 +102,6 @@ const Config = cmp(async function Config(props: any) {
   options.headers = headers
   options.entity = optionsEntity
 
-  // configDefinition's `def.entity` verbatim, NOT rebuilt here. This reduce
-  // was one of fourteen copies of that function's entityDefs loop, and when
-  // configDefinition started reconstructing a point's `parts` from apidef's
-  // segment vector (its ADR-003), only the copies that read `configDef` got
-  // it — this target's literal config emitted paths with no parts at all
-  // while its data config had them. One rule, one place.
   const entityConfig = configDef.entity
 
   const config = {

package/project/.sdk/src/cmp/scala/EntityTypes_scala.ts

@@ -1,37 +1,5 @@
 
 
-// Typed-model generator (Scala target). Port of EntityTypes_java.ts /
-// EntityTypes_py.ts.
-//
-// Reads main.<KIT>.entity.<e>.fields[] and per-op params
-// (op.<name>.points[].args.params[]) and emits ONE file, core/<Name>Types.scala,
-// holding an `object <Name>Types` with a nested `final case class` per active
-// entity plus a request/match case class per active op.
-//
-// WHY A CONTAINER OBJECT: keeps the whole reference model in one file whatever
-// the entity count and matches the java target's single-container layout
-// (<Name>Types.java). Scala permits multiple top-level types per file, but a
-// container object mirrors the JVM sibling and keeps the generated core/ dir
-// tidy.
-//
-// TYPE CHOICE: reference `case class` types with BOXED (nullable) component
-// types, NOT the wired runtime type. The generated ops take/return the loose
-// object model (java.util.Map[String, Object] / Object), so these case classes
-// are NOT wired into the op signatures — they are documentation/DX reference
-// shapes a caller may use to describe a payload before converting it to a map.
-// This mirrors the java target's reference records and the JS target's JSDoc
-// typedefs (annotation only, no runtime effect). Emitting unused case classes
-// is harmless — they compile and have no runtime effect.
-//
-// OPTIONAL FIELDS: every component is a boxed reference type, hence inherently
-// nullable, so a `req:false` field/param needs no distinct rendering in Scala.
-//
-// Sentinels map to Scala types via the SHARED canonToType 'scala' column (the
-// single source of truth per language — do not keep a local table here).
-//
-// Keep the SAME type-name scheme as every other language: <Name>,
-// <Name>LoadMatch, <Name>ListMatch, <Name>CreateData, <Name>UpdateData,
-// <Name>RemoveMatch (via the shared opTypeName helper).
 
 import {
   cmp, each, names,
@@ -62,20 +30,11 @@ const SCALA_KEYWORDS = new Set<string>([
 ])
 
 
-// A field/param name that has a safe Scala identifier rendering. Names that are
-// not valid identifiers (hyphens, leading digits) have no clean parameter form
-// and are skipped — they remain reachable via the runtime map.
 function scalaIdent(name: string): boolean {
   return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) && !SCALA_KEYWORDS.has(name)
 }
 
 
-// Emit a nested `final case class <typeName>(...)` from {name, type} items. An
-// item whose name is not a legal identifier is skipped (WITH a warning — the
-// key stays reachable via the runtime map, but its absence from the typed
-// model should be visible, not silent); a duplicate component name (after the
-// identifier filter) is dropped. An empty case class is a valid,
-// zero-parameter shape.
 function emitCaseClass(typeName: string, items: any[], log?: any): void {
   const seen = new Set<string>()
   const usable = items.filter((it: any) => {
@@ -123,10 +82,6 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
 
   const scalapackage = props.scalapackage || scalaPackage(model)
 
-  // only_active:false — getModelPath DROPS active:false entries by default,
-  // but the consumer scaffold (create-sdkgen Root.ts) iterates the RAW entity
-  // collection, so inactive entities still get generated entity code that
-  // references these typed names. The typed model must cover them too.
   const entity = getModelPath(model, `main.${KIT}.entity`, { only_active: false, required: false })
   // Emit for EVERY entity that gets generated entity code: the consumer
   // scaffold (create-sdkgen Root.ts) iterates entities WITHOUT an active
@@ -138,9 +93,6 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
   // entity not yet named (e.g. a fieldless placeholder) would otherwise read
   // `Name = undefined` below. Parity with the go/py/java/csharp emitter's fix.
 
-  // 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)
 
   File({ name: model.const.Name + 'Types.' + ext }, () => {
@@ -170,13 +122,10 @@ object ${model.const.Name}Types {
       const fields = (ent.fields ? each(ent.fields) : [])
         .filter((f: any) => f.active !== false)
 
-      // Entity data model: one component per field.
       emitCaseClass(Name, fields.map((f: any) => ({
         name: f.name, type: f.type,
       })), log)
 
-      // Per active op: a request/match case class. Members 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/scala/Main_scala.ts

@@ -46,31 +46,6 @@ const Main = cmp(async function Main(props: any) {
   // The Scala package root for every runtime piece (like GOMODULE for go).
   const scalapackage = scalaPackage(model)
 
-  // THE PLUGIN TRIM, over the WHOLE model rather than its active half.
-  //
-  // pluginExcludes(model) walks only the model's ACTIVE features
-  // (helpers/featureSource), which is right for a target whose feature trim
-  // is on: an inactive feature's whole tree is already gone at `target add`,
-  // so it has no plugin files left to exclude. Scala's feature trim is OFF
-  // (see the Copy below), so the opposite holds - an inactive feature's tree
-  // is all still here, and its plugins are the part of it that costs the
-  // most. Before this, a scala SDK whose model never mentioned `secrets`
-  // shipped and compiled all nine vendored provider clients: the one trim
-  // the target has walked straight past the feature that owns them.
-  //
-  // EVERY declared group of an inactive feature goes, not just the groups
-  // marked inactive. A feature that is off has no active plugins whatever
-  // its `plugin` map says - `main: kit: feature: secrets: { active: false
-  // plugin: vault: active: true }` selects nothing, because targetFeatures
-  // drops the feature before Config ever reads a group - so shipping vault's
-  // files for it would leave a provider client in the tree that nothing in
-  // the SDK can reach. That is why this reads the declared paths directly
-  // rather than reusing pluginExcludesFor, whose rule (exclude the groups
-  // marked `active: false`) is the right one only for a LIVE feature.
-  //
-  // Rooting matches pluginExcludes': scala's declared paths are
-  // target-root-relative, which is this Copy's root, and the other targets'
-  // paths in the same list cannot match anything in a scala tree.
   const esc = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
   const allfeature = getModelPath(model, `main.${KIT}.feature`,
     { required: false, only_active: false }) || {}
@@ -88,27 +63,6 @@ const Main = cmp(async function Main(props: any) {
     }
   }
 
-  // THE FEATURE THE MODEL NEVER MENTIONS AT ALL.
-  //
-  // inactivePluginExcludes above walks the model's DECLARED features and skips
-  // the active ones, which covers `secrets: { active: false }`. It cannot cover
-  // the case that actually shipped: a model that does not mention secrets
-  // anywhere. Then `main.kit.feature` has no `secrets` key, the loop never sees
-  // it, nothing is excluded, and all nine provider clients are copied and
-  // compiled — which is what `vocabulary.off.notrimmed` reports, and it failed
-  // on 12 of the 68 cedar SDKs.
-  //
-  // PRECISE, NOT THE WHOLE TREE. The first cut of this excluded
-  // `feature/<inactive>/` wholesale and broke the build: SecretsFeature.scala
-  // ships to every scala SDK regardless (this target's feature trim is off) and
-  // imports `com.voxgig.sekreto` and `voxgig.plugin`, so removing the vendored
-  // cores left it uncompilable — "value voxgig is not a member of com".
-  //
-  // What may go is exactly the nine provider clients under sekreto/plugins.
-  // Httpjson.scala and Sigv4.scala live there too and must STAY: both belong to
-  // no group and are shared, which model/feature/secrets.aon documents at
-  // length after a cloud-only trim once deleted Sigv4 and scalac failed with
-  // four "Not found: uriescape".
   const SHARED_SEKRETO_PLUGINS = ['Httpjson.scala', 'Sigv4.scala']
   const pluginDirExcludes: RegExp[] = []
   if (null == (feature as any).secrets) {
@@ -126,25 +80,6 @@ const Main = cmp(async function Main(props: any) {
   // ProjectName carries the SDK name into vendored template strings.
   Copy({
     from: 'tm/' + target.name,
-    // The generate-time plugin trim, in both halves: pluginExcludes for an
-    // ACTIVE feature's inactive groups, inactivePluginExcludes (above) for
-    // the groups of a feature that is itself off. An inactive group's
-    // declared files stay out of the tree - the model's `path` entries are
-    // target-root-relative, which is this Copy's root.
-    //
-    // Scala's FEATURE-level trim is off (model/target/scala.aon `feature: {
-    // trim: false }`, because the cross-feature tests are fused into one
-    // sdktest/SdkTestMain.scala, which constructs fifteen feature classes by
-    // name), so this is the ONLY trim the target has, and what it does NOT
-    // reach is worth stating rather than leaving to be discovered: every
-    // feature's own source ships to every scala SDK whatever the model says,
-    // secrets included, so a secrets-off SDK still carries SecretsFeature,
-    // the vendored sekreto and voxgig/plugin cores, and the two UNGROUPED
-    // plugin files (plugins/Sigv4.scala's HMAC-SHA256 signer and
-    // plugins/Httpjson.scala's fetch + ProcessBuilder helpers, which belong
-    // to no group because four and eight kinds respectively compile against
-    // them). What it DOES reach is the nine provider clients, and they are
-    // the bulk: measured on a feature-off SDK, 26 files rather than 35.
     exclude: [
       /src\//,
       TEST_CONTROL_EXCLUDE,
@@ -162,20 +97,8 @@ const Main = cmp(async function Main(props: any) {
   // Shared entity runtime (entity/EntityBase.scala).
   EntityBase({ target })
 
-  // utility/PrepareAuth.scala. WHERE the credential goes (header, query or
-  // cookie) and under what name is a fact about THIS API, and
-  // tm/scala/utility/Prepare.scala can only hold one answer - which is why
-  // its `object PrepareAuth` was removed and this generates the object
-  // instead. See PrepareAuth_scala.
-  //
-  // CALLED AT THE TOP LEVEL, NOT INSIDE `Folder({ name: 'core' })` below:
-  // the component opens `utility` itself, reproducing the path the blanket
-  // Copy above gives every other tm/scala/utility file. Nested in core/ it
-  // would write core/utility/PrepareAuth.scala, contradicting its own
-  // package declaration while Register.scala bound nothing.
   PrepareAuth({ target })
 
-  // Generate the client class and config in core/.
   Folder({ name: 'core' }, () => {
 
     File({ name: model.const.Name + 'SDK.' + target.ext }, () => {
@@ -190,7 +113,6 @@ const Main = cmp(async function Main(props: any) {
           }
         },
 
-        // Entities - injected at SLOT
         () => {
           each(entity, (entity: ModelEntity) => {
             const entitySDK = getModelPath(model, `main.${KIT}.entity.${entity.name}`)

package/project/.sdk/src/cmp/scala/PrepareAuth_scala.ts

@@ -15,102 +15,23 @@ import {
 import { scalaPackage } from './utility_scala'
 
 
-// WHERE THE CREDENTIAL GOES IS A FACT ABOUT THE API, so it is generated
-// rather than templated. The scala port of cmp/ts/PrepareAuth_ts.ts; see
-// that file for the full account.
-//
-// scala had no prepare_auth template to delete. The logic was an `object
-// PrepareAuth` EMBEDDED in `tm/scala/utility/Prepare.scala` alongside the
-// six other prepare steps, hardcoding `val HEADER_AUTH = "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.
-//
-// EXTRACTED INTO ITS OWN FILE rather than generating the whole of
-// Prepare.scala. A Scala `object` is not tied to a file name: the compiler
-// resolves `PrepareAuth.prepareAuth` by PACKAGE, and every caller —
-// utility/Register.scala's `u.prepareAuth = (ctx) => PrepareAuth
-// .prepareAuth(ctx)`, which is the only binding — already names it
-// unqualified from inside `package SCALAPACKAGE.utility`. So moving the
-// object into `utility/PrepareAuth.scala` in the same package leaves
-// Register, core/Utility.scala's `var prepareAuth` field, utility/MakeSpec
-// .scala's `utility.prepareAuth(ctx)` and core/SdkClient.scala's call
-// site all resolving exactly as before, with no edit to any of them. The
-// other six objects in Prepare.scala (PreparePath, PrepareMethod,
-// PrepareParams, PrepareQuery, PrepareHeaders, PrepareBody) are placement-
-// independent and stay templated, so the generated surface is exactly the
-// part that varies with the API.
-//
-// 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.
 const PrepareAuth = cmp(async function PrepareAuth(props: any) {
   const { target } = props
   const { model } = props.ctx$
 
   const where = resolveAuthIn(model)
 
-  // LOWERCASED FOR A HEADER, VERBATIM OTHERWISE. apidef writes
-  // `name: "Authorization"`, the deleted `object PrepareAuth` hardcoded
-  // `"authorization"`, and the whole scala runtime reads the lower-case
-  // key: the shared primary corpus asserts
-  // `ctx:spec:headers:authorization`, SecretsFeature.reauth rewrites
-  // `headers.put("authorization", ...)` in place on a token refresh, and
-  // spec.headers is a plain case-sensitive LinkedHashMap. Emitting
-  // `Authorization` verbatim would put the credential under a key nothing
-  // reads. A query parameter and a cookie ARE case-sensitive, so they keep
-  // the spec's spelling exactly.
   const resolved = resolveAuthName(model)
   const name = 'header' === where ? resolved.toLowerCase() : resolved
 
   const 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).
   const prefix = resolveAuthPrefix(model)
 
-  // NOT `isAuthActive`, AND THE DIFFERENCE IS LOAD-BEARING. See
-  // isAuthSuppressed in sdkgen's utility.ts: `isAuthActive` is ALSO false
-  // whenever `main.kit.info.auth` is false, which says only that the SPEC
-  // declared no security scheme — such an SDK still carries a credential,
-  // because Make.scala's optspec always declares `apikey` and fills
-  // `options.auth` from its `{ "prefix": "" }` default, so the runtime
-  // `options.get("auth") == null` guard never fires and every such SDK has
-  // always sent `options.apikey`. Emitting a no-op for those would
-  // silently remove working authentication and take the secrets feature
-  // with it (SecretsFeature 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, so it is the only one used.
   const active = !isAuthSuppressed(model)
 
   const scalapackage = scalaPackage(model)
 
-  // FOLDER NESTING: exactly one segment, `utility`.
-  //
-  // Worked out from the deleted code's own path and from Main_scala's call
-  // site. Main_scala's blanket `Copy({ from: 'tm/scala' })` runs at the
-  // TARGET ROOT (its excludes and the scala tree are root-relative, and
-  // project.scala/Makefile sit beside core/, utility/, entity/), so
-  // `tm/scala/utility/Prepare.scala` lands at `<root>/utility/Prepare
-  // .scala`. Reproducing that path from Main's TOP LEVEL therefore needs
-  // `utility` and nothing above it — the same one-segment shape
-  // EntityBase_scala uses for `entity`.
-  //
-  // So this component must be invoked from Main_scala's top level and NOT
-  // from inside its `Folder({ name: 'core' })`, where Config and
-  // EntityTypes are written: nested there it would emit
-  // `core/utility/PrepareAuth.scala`, whose `package <pkg>.utility`
-  // declaration contradicts its directory, while Register.scala kept
-  // binding the stale object. There is no `src` folder in a scala SDK at
-  // all, so the ts port's `src/src/utility/` failure has no scala twin —
-  // the scala twin would be `core/`.
   Folder({ name: 'utility' }, () => {
     File({ name: 'PrepareAuth.' + target.ext }, () => {
       Content(render({ scalapackage, active, where, name, prefix, basic }))
@@ -130,19 +51,10 @@ type AuthSpec = {
 
 
 function render(spec: AuthSpec): string {
-  // The package line alone. Each placement emits its OWN import block,
-  // because they need different ones and the scala templates put the
-  // java.* imports first - Prepare.scala, Make.scala and Spec.scala all
-  // read `import java.util...` then the SDK's own packages.
   const head = `package ${spec.scalapackage}.utility
 
 `
 
-  // NO AUTH AT ALL - the project switched it off explicitly (see `active`
-  // above for why only an EXPLICIT switch counts). The SDK gets a
-  // prepareAuth that is honest about it rather than one that removes a
-  // header nobody set; Struct is not imported, because nothing here reads
-  // an option.
   if (!spec.active) {
     return head + `import ${spec.scalapackage}.core.{Context, Spec}
 
@@ -169,12 +81,6 @@ object PrepareAuth {
 }
 
 
-// HEADER. Behaviourally the deleted `object PrepareAuth` when the scheme
-// resolves to the defaults (header / Authorization): the same option names,
-// the same `skip` idiom for a missing credential, the same auth_no_spec
-// error, the same empty-prefix rule. Only the constant's VALUE moves with
-// the model, plus the HTTP Basic block, which is emitted only for a basic
-// scheme.
 function renderHeader(spec: AuthSpec, head: string): string {
   return head + `${spec.basic ? `import java.nio.charset.StandardCharsets
 import java.util.Base64
@@ -266,9 +172,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. This is the placement joplin, pipedrive,
-// trello and lm-umbrella declare and no generated SDK ever emitted.
 function renderQuery(spec: AuthSpec, head: string): string {
   return head + `import ${spec.scalapackage}.core.{Context, Spec}
 import ${spec.scalapackage}.utility.struct.Struct
@@ -321,11 +224,6 @@ object PrepareAuth {
 }
 
 
-// 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 also makes this idempotent: a retried request cannot end up
-// carrying the credential twice.
 function renderCookie(spec: AuthSpec, head: string): string {
   return head + `import java.util.{Map => JMap}
 

package/project/.sdk/src/cmp/scala/ReadmeEntity_scala.ts

@@ -11,7 +11,6 @@ import { scalaVarName } from './utility_scala'
 
 // Type names come from the shared canonToType 'scala' column (single source of truth).
 
-// A type-correct Scala literal for a field's canonical type.
 function scalaLit(type: any, placeholder: string = 'example'): string {
   const k = canonScalarKey(type)
   if ('INTEGER' === k) return '1L'

package/project/.sdk/src/cmp/scala/ReadmeExamplesTest_scala.ts

@@ -2,29 +2,6 @@
 import { cmp, File, Content } from '@voxgig/sdkgen'
 
 
-// Emits sdktest/ReadmeExamplesTest.scala — a PRESENCE + STRUCTURE gate over
-// every scala fenced block in the repository ROOT README.md, the per-language
-// scala/README.md, AND the per-language scala/REFERENCE.md. It is a
-// default-package scala-cli object exposing run(rep) and is driven by the
-// generated SdkEntityTestMain aggregator (mirrors the generated per-entity
-// test objects).
-//
-// SCOPE NOTE (deliberate, documented): the Python/TS/Go equivalents EXECUTE and
-// type-check every documented block. That is infeasible here — the generated
-// Scala SDK compiles with scala-cli only (no in-process Scala 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. every doc exists and contains at least one scala block (nothing was
-//      dropped);
-//   2. every scala block is structurally well-formed — its braces, parentheses
-//      and brackets balance (catches a truncated or malformed generated
-//      snippet).
-// A per-doc summary line makes the coverage visible in the test output.
-//
-// The emitted Scala is written WITHOUT literal backticks (the fence marker is
-// built at runtime as 96.toChar.toString.repeat(3)) so this TS template literal
-// stays clean.
 const ReadmeExamplesTest = cmp(function ReadmeExamplesTest(props: any) {
   const { target, ctx$: { model } } = props
 

package/project/.sdk/src/cmp/scala/ReadmeRef_scala.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)
 
@@ -378,9 +378,6 @@ val client = new ${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/scala/ReadmeTopQuick_scala.ts

@@ -54,15 +54,10 @@ val client = new ${SDK}(options)
   }
 
   if (exampleEntity) {
-    // Sanitise the local variable name — an entity whose camelCased name is a
-    // Scala keyword gets a trailing underscore (scalaVarName) so the snippet
-    // compiles.
     const eVar = scalaVarName(exampleEntity.name)
     const accessor = scalaVarName(exampleEntity.name)
     const eNameLower = nom(exampleEntity, 'Name').toLowerCase()
     const opnames = Object.keys(exampleEntity.op || {})
-    // Model-driven id key: null when the entity has no id-like field, in which
-    // case the load example takes an empty match.
     const idF = entityIdField(exampleEntity)
 
     if (opnames.includes('list')) {

package/project/.sdk/src/cmp/scala/Schema_scala.ts

@@ -18,25 +18,6 @@ import {
 } from './utility_scala'
 
 
-// THE GENERATED SCHEMA MODULE: the model's schemas, as data the SDK can run.
-//
-// The scala 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 scala 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 scala's.
-// Chunked StringBuilder appends, exactly as Config.scala carries its config,
-// keep every string constant far below the JVM's 64KB limit no matter how
-// many features or entities the model grows.
-//
-// 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 scala type and struct reads a spec BY EXAMPLE, so one
-// number in here would mean something different in scala than in ts.
 const Schema = cmp(async function Schema(props: any) {
   const ctx$ = props.ctx$
   const target = props.target

package/project/.sdk/src/cmp/scala/TestEntity_scala.ts

@@ -24,11 +24,6 @@ import {
 import { scalaVarName } from './utility_scala'
 
 
-// Scala GenCtx mirrors the java donor's shape (see TestEntity_java.ts). The
-// scala per-entity test is a dependency-free scala-cli object (default
-// package) exposing run(rep) — driven by the generated SdkEntityTestMain
-// aggregator. Only the offline unit path is emitted: the in-memory test
-// transport serves the fixtures, so there is no live/env/synthetic machinery.
 type GenCtx = {
   model: Model
   entity: ModelEntity
@@ -217,9 +212,6 @@ const generateList: OpGen = (ctx, step, index) => {
 `)
   }
 
-  // Select-by-id assertions require the DATA type to carry an id field
-  // (entityDataIdField); an entity keyed only on a load-MATCH id it does not
-  // return as data has no `.get("id")` to compare, so skip them.
   const hasDataId = null != entityDataIdField(entity)
   const allSteps = Object.values(flow.step) as any[]
   const listvarUsed = hasDataId && !!step.valid?.some((v: any) => {

package/project/.sdk/src/cmp/scala/Test_scala.ts

@@ -62,9 +62,6 @@ const Test = cmp(function Test(props: any) {
       }
     })
 
-    // Documentation scala-examples presence + structure gate over the root
-    // README, scala/README.md and scala/REFERENCE.md. Driven through the same
-    // shared report by the SdkEntityTestMain aggregator below.
     ReadmeExamplesTest({ target, scalapackage })
 
     // Aggregating main: run every generated per-entity test through one

package/project/.sdk/src/cmp/scala/utility_scala.ts

@@ -17,12 +17,6 @@ function projectPath(suffix?: string): string {
 }
 
 
-// The Scala package root for the generated SDK, mirroring how the go target
-// derives GOMODULE and the java target derives its package: org segment from
-// model.origin, name segment from the model name (e.g. origin voxgig-sdk +
-// name solardemo -> voxgig.solardemosdk). Each runtime piece lives under it:
-// <pkg>.core, <pkg>.utility, <pkg>.utility.struct, <pkg>.feature,
-// <pkg>.entity, <pkg>.sdktest.
 function scalaPackage(model: any): string {
   const org = String(model.origin || 'voxgig-sdk')
     .replace(/-sdk$/, '')
@@ -55,8 +49,6 @@ const SCALA_KEYWORDS = new Set([
 ])
 
 
-// A camelCase Scala identifier for a snake_case model name
-// (`status_embed_config` -> `statusEmbedConfig`), with a reserved-word guard.
 function scalaVarName(name: string): string {
   const pascal = camelify(name)
   const out = pascal.charAt(0).toLowerCase() + pascal.slice(1)
@@ -64,29 +56,6 @@ function scalaVarName(name: string): string {
 }
 
 
-// Strip model bookkeeping keys (ending in $) from a config subtree.
-// 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