@voxgig/sdkgen 4.21.0 → 4.23.0

package/project/.sdk/src/cmp/rust/TestEntity_rust.ts

@@ -1,3 +1,4 @@
+import { flowSteps } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -26,8 +27,6 @@ import {
 import { rustVarName, rustMethodName } from './utility_rust'
 
 
-// Rust's GenCtx mirrors the shared shape (see TestEntity_ts.ts) plus the
-// crate ident used to build qualified paths in emitted code.
 type GenCtx = {
   model: Model
   entity: ModelEntity
@@ -64,13 +63,6 @@ const TestEntity = cmp(function TestEntity(props: any) {
     ? `("apikey", getp(&env, "${PROJUPPER}_APIKEY"))`
     : ''
 
-  // A templated server URL (OpenAPI server variables) makes a LIVE client
-  // impossible to construct without values: makeOptions raises rather than
-  // request a URL with a literal `{account_id}` in it. So the live suite
-  // takes them from the environment the same way it takes the apikey.
-  //
-  // Emitted as a jo() tuple entry, so it carries its own leading comma only
-  // when an apikey entry precedes it - otherwise `jo(vec![, ...])`.
   const svars = serverVariables(model)
   const serverEnvEntry = svars
     .map((v: any) => `\n        ("${serverVarEnv(PROJUPPER, v.name)}", Value::str(${JSON.stringify(v.dflt)})),`).join('')
@@ -84,16 +76,16 @@ const TestEntity = cmp(function TestEntity(props: any) {
   const idnamesStr = idnames.map(n => `Value::str("${n}")`).join(', ')
 
   // All update data entries for alias generation.
-  const allSteps = Object.values(basicflow.step) as any[]
-  const updateStep = allSteps.find((s: any) => s.op === 'update')
-  const updateData = updateStep?.data
-    ? Object.entries(updateStep.data).filter(([k]: any) => k !== 'id' && !k.endsWith('$'))
+  const allSteps = Object.values(flowSteps(basicflow)) as any[]
+  const updateStep = allSteps.find((s: any) => s.o === 'update')
+  const updateData = updateStep?.d
+    ? Object.entries(updateStep.d).filter(([k]: any) => k !== 'id' && !k.endsWith('$'))
     : []
   const aliases = updateData.map(([k, v]: any) => [k, v])
 
   const genCtx: GenCtx = { model, entity, rustcrate, flow: basicflow, PROJUPPER }
 
-  const opNames = Array.from(new Set(allSteps.map((s: any) => s.op).filter(Boolean)))
+  const opNames = Array.from(new Set(allSteps.map((s: any) => s.o).filter(Boolean)))
   const opsList = opNames.map(o => `"${o}"`).join(', ')
 
   // Same hazard as the csharp target: an entity whose basic flow has no ops
@@ -149,7 +141,7 @@ fn ${evar}_entity_instance() {
     // The stream test drives the list op; only emit it when the entity has a
     // list op (a create/load-only entity has no list endpoint, so
     // stream("list") panics with point_no_points).
-    const flowHasList = allSteps.some((s: any) => 'list' === s.op)
+    const flowHasList = allSteps.some((s: any) => 'list' === s.o)
     if (flowHasList) {
       Content(`
 #[test]
@@ -207,7 +199,7 @@ ${skipBlock}    // The basic flow consumes synthetic IDs from the fixture. In li
 ${allSteps.length > 0 ? '    let client = setup.client.clone();\n' : ''}`)
 
     // No create step: bootstrap entity data from existing fixture data.
-    const flowHasCreate = allSteps.some((s: any) => s.op === 'create')
+    const flowHasCreate = allSteps.some((s: any) => s.o === 'create')
     if (!flowHasCreate) {
       const preambleVar = rustVarName(entity.name + '_ref01')
       Content(`
@@ -222,8 +214,8 @@ ${allSteps.length > 0 ? '    let client = setup.client.clone();\n' : ''}`)
     }
 
     // Model-driven step iteration.
-    each(basicflow.step, (step: any, index: any) => {
-      const opgen: OpGen = GENERATE_OP[step.op]
+    each(flowSteps(basicflow), (step: any, index: any) => {
+      const opgen: OpGen = GENERATE_OP[step.o]
       if (opgen) {
         opgen(genCtx, step, index)
         Content('\n')
@@ -352,13 +344,13 @@ ${allSteps.length > 0 ? '    let client = setup.client.clone();\n' : ''}`)
 
 const generateCreate: OpGen = (ctx, step, index) => {
   const { entity, flow } = ctx
-  const ref = step.input.ref ?? entity.name + '_ref01'
-  const entvar = rustVarName(step.input.entvar ?? ref + '_ent')
-  const datavar = rustVarName(step.input.datavar ?? (ref + '_data' + (step.input.suffix ?? '')))
+  const ref = step.i.ref ?? entity.name + '_ref01'
+  const entvar = rustVarName(step.i.entvar ?? ref + '_ent')
+  const datavar = rustVarName(step.i.datavar ?? (ref + '_data' + (step.i.suffix ?? '')))
 
-  const priorSteps = Object.values(flow.step).slice(0, Number(index)) as any[]
+  const priorSteps = Object.values(flowSteps(flow)).slice(0, Number(index)) as any[]
   const needsEnt = !priorSteps.some((s: any) =>
-    ['create', 'list', 'load', 'update', 'remove'].includes(s.op))
+    ['create', 'list', 'load', 'update', 'remove'].includes(s.o))
 
   Content(`    // CREATE
 `)
@@ -402,14 +394,14 @@ const generateCreate: OpGen = (ctx, step, index) => {
 
 const generateList: OpGen = (ctx, step, index) => {
   const { entity, flow } = ctx
-  const ref = step.input.ref ?? entity.name + '_ref01'
-  const entvar = rustVarName(step.input.entvar ?? ref + '_ent')
-  const matchvar = rustVarName(step.input.matchvar ?? (ref + '_match' + (step.input.suffix ?? '')))
-  const listvar = rustVarName(step.input.listvar ?? (ref + '_list' + (step.input.suffix ?? '')))
+  const ref = step.i.ref ?? entity.name + '_ref01'
+  const entvar = rustVarName(step.i.entvar ?? ref + '_ent')
+  const matchvar = rustVarName(step.i.matchvar ?? (ref + '_match' + (step.i.suffix ?? '')))
+  const listvar = rustVarName(step.i.listvar ?? (ref + '_list' + (step.i.suffix ?? '')))
 
-  const priorSteps = Object.values(flow.step).slice(0, Number(index)) as any[]
+  const priorSteps = Object.values(flowSteps(flow)).slice(0, Number(index)) as any[]
   const needsEnt = !priorSteps.some((s: any) =>
-    ['create', 'list', 'load', 'update', 'remove'].includes(s.op))
+    ['create', 'list', 'load', 'update', 'remove'].includes(s.o))
 
   Content(`    // LIST
 `)
@@ -441,13 +433,13 @@ const generateList: OpGen = (ctx, step, index) => {
     let ${listvar} = ja(${listvar}.iter().map(|e| e.data(None)).collect::<Vec<Value>>());
 `)
 
-  // Validators from step.valid.
-  const allSteps = Object.values(flow.step) as any[]
-  if (step.valid) {
-    for (const validator of (step as any).valid) {
+  // Validators from step.v.
+  const allSteps = Object.values(flowSteps(flow)) as any[]
+  if (step.v) {
+    for (const validator of (step as any).v) {
       const validRef = validator.def?.ref
-      const hasRefData = validRef && allSteps.some((s: any) => 'create' === s.op &&
-        ((s.input.ref ?? entity.name + '_ref01') === validRef))
+      const hasRefData = validRef && allSteps.some((s: any) => 'create' === s.o &&
+        ((s.i.ref ?? entity.name + '_ref01') === validRef))
 
       if ('ItemExists' === validator.apply && hasRefData) {
         const refDataVar = rustVarName(validRef + '_data')
@@ -481,16 +473,16 @@ const generateList: OpGen = (ctx, step, index) => {
 
 const generateUpdate: OpGen = (ctx, step, index) => {
   const { entity, flow } = ctx
-  const ref = step.input.ref ?? entity.name + '_ref01'
-  const entvar = rustVarName(step.input.entvar ?? ref + '_ent')
-  const datavar = rustVarName(step.input.datavar ?? (ref + '_data' + (step.input.suffix ?? '')))
-  const resdatavar = rustVarName(step.input.resdatavar ?? (ref + '_resdata' + (step.input.suffix ?? '')))
-  const markdefvar = rustVarName(step.input.markdefvar ?? (ref + '_markdef' + (step.input.suffix ?? '')))
-  const srcdatavar = rustVarName(step.input.srcdatavar ?? (ref + '_data' + (step.input.suffix ?? '')))
-
-  const priorSteps = Object.values(flow.step).slice(0, Number(index)) as any[]
+  const ref = step.i.ref ?? entity.name + '_ref01'
+  const entvar = rustVarName(step.i.entvar ?? ref + '_ent')
+  const datavar = rustVarName(step.i.datavar ?? (ref + '_data' + (step.i.suffix ?? '')))
+  const resdatavar = rustVarName(step.i.resdatavar ?? (ref + '_resdata' + (step.i.suffix ?? '')))
+  const markdefvar = rustVarName(step.i.markdefvar ?? (ref + '_markdef' + (step.i.suffix ?? '')))
+  const srcdatavar = rustVarName(step.i.srcdatavar ?? (ref + '_data' + (step.i.suffix ?? '')))
+
+  const priorSteps = Object.values(flowSteps(flow)).slice(0, Number(index)) as any[]
   const needsEnt = !priorSteps.some((s: any) =>
-    ['create', 'list', 'load', 'update', 'remove'].includes(s.op))
+    ['create', 'list', 'load', 'update', 'remove'].includes(s.o))
 
   const hasEntIdU = null != entity.id
 
@@ -507,9 +499,9 @@ const generateUpdate: OpGen = (ctx, step, index) => {
 `)
   }
 
-  // Data entries from step.data.
-  if (step.data) {
-    const dataEntries = Object.entries(step.data).filter(([k]: any) => k !== 'id' && !k.endsWith('$'))
+  // Data entries from step.d.
+  if (step.d) {
+    const dataEntries = Object.entries(step.d).filter(([k]: any) => k !== 'id' && !k.endsWith('$'))
     for (const [key] of dataEntries) {
       Content(`    setp(&${datavar}_up, "${key}", getp(&setup.idmap, "${key}"));
 `)
@@ -517,10 +509,10 @@ const generateUpdate: OpGen = (ctx, step, index) => {
   }
 
   // TextFieldMark spec.
-  if (step.spec) {
-    for (const spec of (step as any).spec) {
-      if ('TextFieldMark' === spec.apply && null != step.input.textfield) {
-        const fieldname = step.input.textfield
+  if (step.s) {
+    for (const spec of (step as any).s) {
+      if ('TextFieldMark' === spec.apply && null != step.i.textfield) {
+        const fieldname = step.i.textfield
         const fieldvalue = spec.def?.mark ?? `Mark01-${ref}`
         Content(`
     let ${markdefvar}_name = "${fieldname}";
@@ -555,9 +547,9 @@ const generateUpdate: OpGen = (ctx, step, index) => {
   }
 
   // Assert TextFieldMark.
-  if (step.spec) {
-    for (const spec of (step as any).spec) {
-      if ('TextFieldMark' === spec.apply && null != step.input.textfield) {
+  if (step.s) {
+    for (const spec of (step as any).s) {
+      if ('TextFieldMark' === spec.apply && null != step.i.textfield) {
         Content(`    assert_eq!(
         getp(&${resdatavar}, ${markdefvar}_name),
         Value::str(${markdefvar}_value.clone()),
@@ -573,24 +565,24 @@ const generateUpdate: OpGen = (ctx, step, index) => {
 
 const generateLoad: OpGen = (ctx, step, index) => {
   const { entity, flow } = ctx
-  const ref = step.input.ref ?? entity.name + '_ref01'
-  const entvar = rustVarName(step.input.entvar ?? ref + '_ent')
-  const matchvar = rustVarName(step.input.matchvar ?? (ref + '_match' + (step.input.suffix ?? '')))
-  const datavar = rustVarName(step.input.datavar ?? (ref + '_data' + (step.input.suffix ?? '')))
-  const srcdatavar = rustVarName(step.input.srcdatavar ?? (ref + '_data' + (step.input.suffix ?? '')))
+  const ref = step.i.ref ?? entity.name + '_ref01'
+  const entvar = rustVarName(step.i.entvar ?? ref + '_ent')
+  const matchvar = rustVarName(step.i.matchvar ?? (ref + '_match' + (step.i.suffix ?? '')))
+  const datavar = rustVarName(step.i.datavar ?? (ref + '_data' + (step.i.suffix ?? '')))
+  const srcdatavar = rustVarName(step.i.srcdatavar ?? (ref + '_data' + (step.i.suffix ?? '')))
 
-  const priorSteps = Object.values(flow.step).slice(0, Number(index)) as any[]
+  const priorSteps = Object.values(flowSteps(flow)).slice(0, Number(index)) as any[]
   const hasEntVar = priorSteps.some((s: any) =>
-    ['create', 'list', 'load', 'update', 'remove'].includes(s.op))
+    ['create', 'list', 'load', 'update', 'remove'].includes(s.o))
 
   // Was srcdatavar declared by a prior create step or the preamble?
-  const flowHasCreate = Object.values(flow.step).some((s: any) => (s as any).op === 'create')
+  const flowHasCreate = Object.values(flowSteps(flow)).some((s: any) => (s as any).o === 'create')
   const preambleRef = entity.name + '_ref01'
   const hasSrcData = (!flowHasCreate && srcdatavar === rustVarName(preambleRef + '_data')) ||
     priorSteps.some((s: any) => {
-      if ('create' === s.op) {
-        const priorRef = s.input.ref ?? entity.name + '_ref01'
-        const priorDatvar = rustVarName(s.input.datavar ?? (priorRef + '_data' + (s.input.suffix ?? '')))
+      if ('create' === s.o) {
+        const priorRef = s.i.ref ?? entity.name + '_ref01'
+        const priorDatvar = rustVarName(s.i.datavar ?? (priorRef + '_data' + (s.i.suffix ?? '')))
         return priorDatvar === srcdatavar
       }
       return false
@@ -647,14 +639,14 @@ const generateLoad: OpGen = (ctx, step, index) => {
 
 const generateRemove: OpGen = (ctx, step, index) => {
   const { entity, flow } = ctx
-  const ref = step.input.ref ?? entity.name + '_ref01'
-  const entvar = rustVarName(step.input.entvar ?? ref + '_ent')
-  const matchvar = rustVarName(step.input.matchvar ?? (ref + '_match' + (step.input.suffix ?? '')))
-  const srcdatavar = rustVarName(step.input.srcdatavar ?? (ref + '_data'))
+  const ref = step.i.ref ?? entity.name + '_ref01'
+  const entvar = rustVarName(step.i.entvar ?? ref + '_ent')
+  const matchvar = rustVarName(step.i.matchvar ?? (ref + '_match' + (step.i.suffix ?? '')))
+  const srcdatavar = rustVarName(step.i.srcdatavar ?? (ref + '_data'))
 
-  const priorSteps = Object.values(flow.step).slice(0, Number(index)) as any[]
+  const priorSteps = Object.values(flowSteps(flow)).slice(0, Number(index)) as any[]
   const needsEnt = !priorSteps.some((s: any) =>
-    ['create', 'list', 'load', 'update', 'remove'].includes(s.op))
+    ['create', 'list', 'load', 'update', 'remove'].includes(s.o))
 
   Content(`    // REMOVE
 `)

package/project/.sdk/src/cmp/rust/fragment/Entity.fragment.rs

@@ -132,17 +132,6 @@ impl EntyClass {
         utility.done(ctx)
     }
 
-    /// Streaming operation. Runs `action` through the full pipeline and
-    /// returns an iterator over the result items, so the `streaming`
-    /// feature's incremental output is reachable from a generated entity (a
-    /// normal op call materialises the whole result). This runtime is
-    /// synchronous, so the returned iterator is a lazy cursor over items the
-    /// pipeline produced. `callopts` parameterises the call:
-    ///   - inbound (download): iterate items/chunks from the streaming
-    ///     feature when active, else the materialised items;
-    ///   - outbound (upload): a `body` in `callopts` is attached to the
-    ///     request (reqdata `body$`) so the transport can stream a payload;
-    ///   - `ctrl` (pipeline control) threads pipeline options.
     pub fn stream(
         &self,
         action: &str,
@@ -239,9 +228,6 @@ impl Entity for EntyClass {
         self.name.clone()
     }
 
-    // `remove` resolves to the entity, marked. The instance KEEPS the data
-    // it held — a caller can still read what was deleted — but it is no
-    // longer a live record.
     fn mark_deleted(&self) {
         *self.deleted.borrow_mut() = true;
     }

package/project/.sdk/src/cmp/rust/fragment/EntityRemoveOp.fragment.rs

@@ -31,10 +31,6 @@ fn remove(self: &Rc<Self>, reqmatch: Value, ctrl: Value) -> Result<Rc<Self>, Pro
         }
     })?;
 
-    // The operation resolves to THIS entity: `run_op` has just absorbed the
-    // result into it, and the caller reaches the record through `.data(None)`.
-    // See AGENTS.md "Entity operations return ENTITIES". A removed entity
-    // keeps its data but is no longer a live record.
     self.mark_deleted();
 
     Ok(self.clone())

package/project/.sdk/src/cmp/rust/fragment/Main.fragment.rs

@@ -57,12 +57,6 @@ impl ProjectNameSDK {
         *rootctx.options.borrow_mut() = opts.clone();
         *sdk.rootctx.borrow_mut() = Some(rootctx.clone());
 
-        // Add features in the resolved order (make_options puts an explicit
-        // List order first, else defaults to test-first). Ordering matters:
-        // the `test` feature installs the base mock transport and the
-        // transport features (retry/cache/netsim/proxy/ratelimit) wrap
-        // whatever is current, so `test` must be added before them to sit at
-        // the base of the transport wrapper chain.
         let feature_opts = to_map(&getp(&opts, "feature"));
         if let Value::List(order) = getpath(&["__derived__", "featureorder"], &opts) {
             let names: Vec<String> = order
@@ -302,18 +296,6 @@ impl ProjectNameSDK {
         ]))
     }
 
-    // Raw GraphQL access: the pressure valve that makes the generated
-    // surface's deliberate omissions (per-call selection sets, typed filter
-    // builders, batching, subscriptions) livable — the whole schema stays
-    // reachable.
-    //
-    // Thin wrapper over the same prepare/fetch path direct uses, with the one
-    // thing raw direct cannot do for GraphQL: a GraphQL failure rides HTTP
-    // 200 as a top-level `errors` array, so status alone would report a
-    // failed query as ok.
-    //
-    // NOTE: like direct, this bypasses the feature pipeline — no retry,
-    // ratelimit or paging features apply.
     pub fn graphql(
         &self, query: &str, variables: Value, ctrl: Value,
     ) -> Result<Value, ProjectNameError> {
@@ -342,7 +324,6 @@ impl ProjectNameSDK {
         // { errors: [...] } body, and the raw path represents a non-2xx as
         // ok:false with no err — so returning early on status would discard
         // the server's own diagnostics, which are the only useful part of
-        // that response.
         let errors = getpath(&["data", "errors"], &res);
 
         if let Value::List(items) = &errors {
@@ -377,7 +358,6 @@ pub fn test_sdk(testopts: Value, sdkopts: Value) -> Rc<ProjectNameSDK> {
     setp(&testopts, "active", Value::Bool(true));
 
     // set_path mutates `sdkopts` in place and returns the inner parent node;
-    // discard the return so we pass the full options root (mirrors go's
     // vs.SetPath(sdkopts, ...) which does not rebind).
     vs::set_path(
         &sdkopts,

package/project/.sdk/src/cmp/rust/fragment/SdkError.fragment.rs

@@ -1,5 +1,3 @@
-// ProjectNameError: the SDK error type (mirrors go core/error.go). The
-// pipeline error discipline is Result<T, ProjectNameError> throughout.
 
 use crate::utility::voxgigstruct::Value;
 
@@ -11,10 +9,6 @@ pub struct ProjectNameError {
     // Cleaned snapshots attached by makeError (Noval until then).
     pub result: Value,
     pub spec: Value,
-    // HTTP status of the response that caused this error, or -1 when the
-    // request never got one. PROMOTED to the top level: it used to be
-    // reachable only inside `result`, so every consumer coupled itself to
-    // the internal shape of that snapshot.
     pub status: i64,
 }
 

package/project/.sdk/src/cmp/rust/utility_rust.ts

@@ -18,17 +18,6 @@ const RUST_RESERVED = new Set<string>([
 ])
 
 
-// Method names on a generated struct that must never be an entity accessor.
-//
-// An entity called `clone` generated `pub fn clone(&self, Value)` on the SDK
-// struct, which SHADOWS Clone::clone — so every `sdk.clone()` the generated
-// code makes elsewhere resolved to the entity accessor and the crate failed
-// with "this method takes 1 argument but 0 arguments were supplied", 16 times
-// over, pointing at the call sites and never at the entity that caused it.
-// `new` would collide with the struct's own constructor the same way.
-//
-// These are not Rust keywords, so RUST_RESERVED does not catch them; they are
-// inherent or std-trait methods the generated code actually calls.
 const RUST_METHOD_RESERVED = new Set<string>([
   'clone', 'new', 'default', 'drop', 'from', 'into', 'to_string',
   'as_ref', 'as_mut', 'borrow', 'borrow_mut', 'deref', 'deref_mut',
@@ -44,13 +33,8 @@ function rustMethodName(name: string): string {
 }
 
 
-// A collision-free snake_case rust identifier for a model name.
 function rustVarName(name: string): string {
   let snake = name.replace(/[^a-zA-Z0-9_]/g, '_').toLowerCase()
-  // No Rust identifier may begin with a digit. A `3d_id` field became
-  // `pub 3_d_id: String`, which does not compile ("expected identifier, found
-  // `3_d_id`") and took the whole crate with it. Prefixed with an underscore,
-  // the convention cmp/c/utility_c.ts already applies.
   if (/^[0-9]/.test(snake)) {
     snake = '_' + snake
   }
@@ -58,8 +42,6 @@ function rustVarName(name: string): string {
 }
 
 
-// The Cargo package name, e.g. voxgig-solar-sdk (mirrors the go module
-// naming: org prefix from model.origin).
 function crateName(model: any): string {
   const org = (model.origin || 'voxgig-sdk').replace(/-sdk$/, '')
   return `${org}-${model.name}-sdk`.toLowerCase().replace(/[^a-z0-9-]/g, '-')
@@ -117,29 +99,6 @@ function formatRustValue(val: any, indent: number = 0): string {
 }
 
 
-// Deep-remove meta keys (`foo$`) from a model subtree (twin of go's 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
@@ -180,12 +139,6 @@ function clean(o: any, dropDefaults?: boolean): any {
 
 
 
-// The JSON as a Rust RAW string literal.
-//
-// A raw string processes no escapes, so the JSON's own `\n` and `\uXXXX`
-// survive byte for byte and reach the JSON parser as written - which a normal
-// Rust string would not, having consumed them itself. The hash level is raised
-// until its terminator does not occur in the text.
 function rustRawString(s: string): string {
   let level = 0
   while (s.includes('"' + '#'.repeat(level))) {

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 }, () => {
@@ -149,8 +101,8 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
 
 // Typed reference models for the ${model.const.Name} SDK.
 //
-// GENERATED from the API model: main.${KIT}.entity.<e>.fields[] and per-op
-// params (op.<name>.points[].args.params[]). Field/param types come from the
+// GENERATED from the API model: main.${KIT}.entity.<e>.fields{} and per-op
+// params (op.<name>.points[].g.params[]). Field/param types come from the
 // canonical type sentinels (source of truth: @voxgig/apidef VALID_CANON). Do
 // not edit by hand.
 //
@@ -168,15 +120,12 @@ object ${model.const.Name}Types {
     entityList.forEach((ent: any) => {
       const Name = ent.Name
       const fields = (ent.fields ? each(ent.fields) : [])
-        .filter((f: any) => f.active !== false)
+        .filter((f: any) => f.a !== false)
 
-      // Entity data model: one component per field.
       emitCaseClass(Name, fields.map((f: any) => ({
-        name: f.name, type: f.type,
+        name: f.n, type: f.t,
       })), 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]) {