@voxgig/sdkgen 4.21.0 → 4.22.0

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

@@ -45,8 +45,6 @@ const Main = cmp(async function Main(props: any) {
   // helpers/applicability.
   const feature = targetFeatures(model, target)
 
-  // The rust crate identifier (RUSTCRATE placeholder), e.g. solar_sdk —
-  // used in every `use <crate>::...` path in the test templates.
   const rustcrate = crateIdent(model)
 
   Package({ target })
@@ -69,23 +67,8 @@ const Main = cmp(async function Main(props: any) {
     }
   })
 
-  // utility/prepare_auth.rs is GENERATED, not templated: where the
-  // credential goes (header / query / cookie, and under what name) is a
-  // fact about the API, and tm/ can only hold one answer. See
-  // PrepareAuth_rust.
-  //
-  // AT ROOT LEVEL, and outside the `core` Folder below. The rust crate root
-  // IS the target root - lib.rs, core/, feature/ and utility/ all sit there
-  // - the component opens `utility` itself, and that is the same path
-  // `Copy({from:'tm/rust'})` used for the template it replaces. Calling it
-  // beside Config, inside `Folder({name:'core'})`, would emit
-  // core/utility/prepare_auth.rs instead: a file no module declares, so
-  // rustc never compiles it, while utility/mod.rs's `pub mod prepare_auth;`
-  // keeps binding whatever utility/ actually holds.
   PrepareAuth({ target })
 
-  // Generated core files: the client (sdk.rs), the API config and the
-  // branded error type.
   Folder({ name: 'core' }, () => {
 
     File({ name: 'sdk.' + target.ext }, () => {
@@ -98,7 +81,6 @@ const Main = cmp(async function Main(props: any) {
           }
         },
 
-        // Entity accessors - injected at SLOT
         () => {
           each(entity, (entity: ModelEntity) => {
             const entitySDK = getModelPath(model, `main.${KIT}.entity.${entity.name}`)
@@ -115,12 +97,6 @@ const Main = cmp(async function Main(props: any) {
     SdkError({ target })
   })
 
-  // feature/mod.rs — the feature module index.
-  //
-  // GENERATED, not templated: rust needs every module declared, and
-  // `target add` only copies source for the features the model selects. A
-  // static index listing all eighteen shipped features stops the crate from
-  // compiling the moment the set is trimmed.
   Folder({ name: 'feature' }, () => {
     File({ name: 'mod.' + target.ext }, () => {
       Content(`// ${model.const.Name} SDK feature modules (mirrors tm/go/feature).
@@ -134,29 +110,7 @@ pub mod base;
       each(feature, (feat: any) => Content(`pub mod ${feat.name};\n`))
     })
 
-    // feature/<name>/plugins.rs - a feature's PLUGIN module index.
-    //
-    // GENERATED, and it has no go/py analogue: rust compiles only the
-    // modules a parent DECLARES, and the declared set varies with the
-    // plugin trim, so a static index would either name a file the trim
-    // just deleted or leave an active kind out of the build.
-    //
-    // It sits one level ABOVE the vendored `plugins/` directory on
-    // purpose: the vendoring guard fails any non-vendored file inside a
-    // vendor dir. Nothing is lost by that - an .rs file no module
-    // declares is not compiled at all, so an inactive group's vendored
-    // file left on disk is inert whether or not the trim reached it.
-    //
-    // This is rust's replacement for go's core-emitted FeaturePlugins map
-    // (Config_go), and it is better placed: core/config.rs never has to
-    // name a feature's types.
     each(feature, (feat: any) => {
-      // `only_active: false`, the same subtlety pluginExcludesFor
-      // documents: the feature object a component is handed has already
-      // been filtered, so a feature whose plugins are ALL inactive would
-      // arrive with nothing here and the index would not be emitted at
-      // all - leaving `pub mod plugins;` in the feature source pointing
-      // at a file that does not exist.
       const declared = getModelPath(model,
         `main.${KIT}.feature.${feat.name}.plugin`,
         { required: false, only_active: false }) || {}
@@ -175,18 +129,11 @@ pub mod base;
         if (true !== plugin.active) return
 
         for (const [sym, one] of Object.entries(plugin.def?.rust || {})) {
-          // 'feature/secrets/plugins/aws.rs' -> the module `aws`.
           mods.add(String(one).replace(/^.*\//, '').replace(/\.rs$/, ''))
           syms.add(sym)
         }
       })
 
-      // The shared HTTP client the vendored vault kinds import
-      // (`use super::httpjson::...`) belongs to NO plugin group - trimming
-      // it with any one group would delete a file the others compile
-      // against - so it ships with the feature core and is DECLARED here
-      // only when something reaches for it. That is what keeps rustls out
-      // of a chain that is [dotenv, env] or [secretspec].
       const NOHTTP = ['secretspec']
       const http = Array.from(mods).some((m: string) => !NOHTTP.includes(m))
 
@@ -228,15 +175,10 @@ pub fn definitions() -> Vec<Definition> {
     })
   })
 
-  // entity/mod.rs — the entity module index.
   EntityBase({ target })
 
-  // entity/types.rs — the documentary typed models (one struct per entity +
-  // per op). Declared as a module by EntityBase so it compiles with the crate.
   EntityTypes({ target })
 
-  // lib.rs — the crate root: module declarations plus the public API
-  // re-exports (twin of the go root package file).
   File({ name: 'lib.' + target.ext }, () => {
     Content(`// ${model.const.Name} SDK for Rust (generated by @voxgig/sdkgen).
 //

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

@@ -17,12 +17,6 @@ import type {
 import { crateIdent, crateName } from './utility_rust'
 
 
-// Cargo.toml (the rust manifest). Dependencies come from the target model
-// (`deps` block, kind prod|dev) plus any feature-declared rust deps, via
-// the shared collectDeps helper. The vendored voxgig struct port needs no
-// external crate. The lib path is the crate root `lib.rs` (the generated
-// SDK mirrors the go layout: core/, feature/, utility/, entity/ at the
-// repo root rather than under src/).
 const Package = cmp(async function Package(props: any) {
   const ctx$ = props.ctx$
   const target = props.target
@@ -74,21 +68,6 @@ path = "lib.rs"
       }
     }
 
-    // [[test]] stanzas for the feature suites.
-    //
-    // cargo auto-discovers `tests/*.rs` and `tests/<dir>/main.rs`, but NOT
-    // `tests/<dir>/<dir>/main.rs` - and the two-level path is not
-    // negotiable: a feature's tests must live inside a `feature/`
-    // container so `target add` trims them WITH the feature
-    // (helpers/featureSource), exactly as go's tm/go/test/feature/secrets/
-    // and py's tm/py/test/feature/secrets/ do. A one-level
-    // tests/secrets/main.rs would auto-discover and then be left behind in
-    // a project that does not select the feature, carrying a suite that
-    // cannot compile.
-    //
-    // So the suite is DECLARED, and only for a feature that both applies
-    // to this target and is active in the model - which is also exactly
-    // when `target add` kept its directory.
     const suites = Object.keys(targetFeatures(model, target))
       .filter((name: string) => null != FEATURE_TESTS[name])
       .sort()
@@ -113,15 +92,6 @@ const FEATURE_TESTS: Record<string, string> = {
 }
 
 
-// One Cargo dependency's value: the bare version string, or the TABLE form
-// when the model asks for anything more.
-//
-// `default: false` and `features: [...]` are not decoration. The secrets
-// feature's vendored HTTP helper speaks rustls, and `rustls = "0.23"` with
-// DEFAULT features pulls aws-lc-rs/aws-lc-sys and a cmake C build, while
-// the ring feature set is what the target's existing `ureq` dep already
-// compiles. Without the table form, turning on one feature would add a
-// native toolchain requirement to every SDK that selected it.
 function depValue(version: string, raw: any): string {
   const features: string[] = Array.isArray(raw?.features) ? raw.features : []
   const nodefault = false === raw?.default

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

@@ -12,26 +12,6 @@ import {
 } from '@voxgig/sdkgen'
 
 
-// WHERE THE CREDENTIAL GOES IS A FACT ABOUT THE API, so it is generated
-// rather than templated. This is the rust peer of PrepareAuth_ts; read that
-// one first, it carries the full account of the defect.
-//
-// This was a static file at `tm/rust/utility/prepare_auth.rs` that hardcoded
-//
-//   const HEADER_AUTH: &str = "authorization";
-//
-// apidef has always resolved the scheme's `in` and `name` into
-// `main.kit.info.security` — joplin's says `in: "query", name: "token"` —
-// and generation dropped both, so the SDK sent a header the API does not
-// read and never sent the query parameter it does.
-//
-// A template cannot fix this, because the three placements need three
-// different bodies and a template has to pick one. A component emits the
-// branch this API actually uses and nothing else — no dead query code in a
-// bearer-token SDK, and no runtime `if` on a value that is fixed at
-// generation time. Rust makes that worth doing carefully: an import the
-// emitted body never reaches is a warning on every build of the crate, so
-// the `use` lines are chosen per placement too.
 const PrepareAuth = cmp(async function PrepareAuth(props: any) {
   const { target } = props
   const { model } = props.ctx$
@@ -42,41 +22,12 @@ const PrepareAuth = cmp(async function PrepareAuth(props: any) {
   // the way Main_rust spells it in lib.rs's re-exports.
   const errtype = model.const.Name + 'Error'
 
-  // `!isAuthSuppressed`, NOT `isAuthActive`. The latter is also false when
-  // the SPEC merely declares no security scheme (`main.kit.info.auth:
-  // false`), and those SDKs still carry a credential: optspec always
-  // declares `apikey` and makeOptions fills `options.auth` from its
-  // defaults, so the runtime guard never fired and they have always sent
-  // it. Only an explicit `main.kit.config.auth.active: false` means "no
-  // credential, ever", which is what isAuthSuppressed reads.
   const active = !isAuthSuppressed(model)
   const where = resolveAuthIn(model)
   const name = resolveAuthName(model)
-  // Resolved, and deliberately NOT baked into the source: the prefix is a
-  // runtime option (`options.auth.prefix`), and the template this replaces
-  // read it from the options map so a caller could override it per client.
-  // Only the PLACEMENT is fixed at generation time.
   const prefix = resolveAuthPrefix(model)
   const basic = isHttpBasicAuth(model)
 
-  // FOLDER NESTING. Main_rust opens NO folder around this call: the rust
-  // crate root IS the target root (lib.rs, core/, feature/, utility/ all sit
-  // there — see the `[lib] path` in tm/rust/Cargo.toml), the template this
-  // replaces lived at `tm/rust/utility/prepare_auth.rs`, and
-  // `Copy({from:'tm/rust'})` lands it at `<root>/utility/`. So the `utility`
-  // folder is opened HERE, exactly as EntityBase_rust opens `entity`.
-  //
-  // The call site matters as much. Config_rust runs inside
-  // `Folder({name:'core'})`, and putting PrepareAuth beside it would write
-  // `core/utility/prepare_auth.rs` — a path no module declares, so rustc
-  // never compiles it, while `utility/mod.rs`'s `pub mod prepare_auth;`
-  // keeps binding whatever `utility/` actually holds. Main_rust calls this
-  // at ROOT level.
-  //
-  // The file NAME is not free either: `utility/mod.rs` declares the module
-  // `prepare_auth`, and `make_spec` calls
-  // `crate::utility::prepare_auth::prepare_auth_util`. The generated file
-  // has to answer to that name.
   Folder({ name: 'utility' }, () => {
     File({ name: 'prepare_auth.' + target.ext }, () => {
       Content(render({ errtype, active, where, name, prefix, basic }))
@@ -97,10 +48,6 @@ type AuthSpec = {
 
 function render(spec: AuthSpec): string {
 
-  // NO AUTH AT ALL. A public API's SDK gets a prepare_auth that is honest
-  // about it rather than one that deletes a header nobody set. `vs`, `Value`
-  // and the helpers are left out of the imports deliberately — rustc warns
-  // on an unused import, on every build, forever.
   if (!spec.active) {
     return `// prepare_auth utility.
 //
@@ -134,9 +81,6 @@ pub fn prepare_auth_util(ctx: &Rc<Context>) -> Result<Rc<RefCell<Spec>>, ${spec.
   // where it can mean something.
   const withBasic = spec.basic && 'header' === spec.where
 
-  // `getpath` reads `options.auth.prefix`, and only a header placement has a
-  // prefix to read: a query parameter drops it, and a cookie pair has no
-  // room for one.
   const withGetpath = 'header' === spec.where
 
   const bag = bagName(spec.where)
@@ -248,8 +192,6 @@ ${place(spec.where)}
 }
 `
 
-  // The encoder goes AFTER prepare_auth_util, so the function a reader opens
-  // this file for is the first one they meet.
   const encoder = !withBasic ? '' : `
 /// Standard base64, for the \`Authorization: Basic base64(user:pass)\` value.
 ///
@@ -294,19 +236,6 @@ fn base64_encode(input: &[u8]) -> String {
 }
 
 
-// The credential's key, as it goes into the bag.
-//
-// A HEADER name is lowercased. HTTP header names are case-insensitive
-// (RFC 9110 5.1) and the fetcher writes them out as given, so nothing
-// changes on the wire — but this SDK's own header map is keyed in lowercase
-// throughout (`content-type`, and the `authorization` that tm/rust/tests/
-// pipeline_test.rs asserts on), and the shipped `prepare_auth.rs` said
-// `"authorization"`. Emitting the resolver's title-cased default here would
-// have left every header SDK's own test suite failing on a purely cosmetic
-// difference.
-//
-// A QUERY parameter and a COOKIE name are case-SENSITIVE, so those go in
-// verbatim: `?token=` is not `?Token=`.
 function credLiteral(where: string, name: string): string {
   return 'header' === where ? String(name).toLowerCase() : String(name)
 }
@@ -323,29 +252,18 @@ function credComment(where: string): string {
 }
 
 
-// The bag the credential lands in, per placement — and, in rust, the `Spec`
-// field it is read from, which is spelled the same. Cookies ride the header
-// bag because a cookie IS a header.
 function bagName(where: string): string {
   return 'query' === where ? 'query' : 'headers'
 }
 
 
 function clear(where: string): string {
-  // COOKIE clears the header named for the credential, NOT the cookie
-  // header: the cookie header may carry pairs this SDK never set, and
-  // deleting it to remove one pair would drop them all. Removing a header
-  // that placement never writes is a no-op, which is the honest outcome
-  // when there is no credential to place.
   return `vs::del_prop(${bagName(where)}, &Value::str(CRED_NAME))`
 }
 
 
 function place(where: string): string {
   if ('query' === where) {
-    // NO PREFIX IN A QUERY STRING. `?token=Bearer%20abc` is not a thing any
-    // API reads; the prefix is a header convention and is dropped here
-    // deliberately rather than silently concatenated.
     return `        let apikey_val = match &apikey {
             Value::Str(s) => s.clone(),
             _ => String::new(),
@@ -355,8 +273,6 @@ function place(where: string): string {
   }
 
   if ('cookie' === where) {
-    // Append, never replace: the cookie header may already carry pairs this
-    // SDK did not set, and clobbering it would drop them.
     return `        let apikey_val = match &apikey {
             Value::Str(s) => s.clone(),
             _ => String::new(),

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

@@ -1,22 +1,6 @@
 import { cmp, Content, File } from '@voxgig/sdkgen'
 
 
-// Emits rust/tests/readme_examples_test.rs — a structural gate over every
-// ```rust fenced block in the three docs that ship rust examples:
-//   - the root README.md (top-level, multi-language quick start)
-//   - the per-language rust/README.md
-//   - the per-language rust/REFERENCE.md
-//
-// DESIGN NOTE vs the go gate (ReadmeExamplesTest_go.ts): the go version shells
-// out to `go build`/`go run` to COMPILE and RUN every block. A faithful rust
-// port would shell out to `cargo`/`rustc` against extracted snippets — a large,
-// environment-sensitive harness that cannot be authored safely without a build
-// to validate it. This rust gate instead validates that every documented rust
-// block is PRESENT and STRUCTURALLY well-formed (balanced delimiters,
-// non-empty). It is a real, always-passing test that keeps the docs honest
-// about block structure; upgrading it to a true compile gate (a temp crate that
-// `cargo build`s each block against the generated SDK) is left as a follow-up.
-// Missing docs are tolerated (a run may generate a subset of phases).
 const ReadmeExamplesTest = cmp(function ReadmeExamplesTest(props: any) {
   const { ctx$: { model } } = props
 

package/project/.sdk/src/cmp/rust/ReadmeRef_rust.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 {
@@ -29,7 +29,7 @@ const ReadmeRef = cmp(function ReadmeRef(props: any) {
 
   const rustcrate = crateIdent(model)
   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)
 
@@ -374,9 +374,6 @@ let client = ${model.const.Name}SDK::new(jo(vec![
 \`\`\`
 
 `)
-      // 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/rust/Schema_rust.ts

@@ -17,24 +17,6 @@ import {
 } from './utility_rust'
 
 
-// THE GENERATED SCHEMA MODULE: the model's schemas, as data the SDK can run.
-//
-// The rust 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 rust 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 rust's.
-// A raw string, exactly as config.rs carries its data rep above the size
-// threshold; the spec has no threshold because it is bounded by the option
-// list and the feature set rather than by the API.
-//
-// No number-type question here, unlike Go: `Value::Num` is f64 whichever way
-// it is built. The spec holds only strings and booleans anyway, 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/rust/TestDirect_rust.ts

@@ -76,13 +76,6 @@ const TestDirect = cmp(function TestDirect(props: any) {
     ? `("apikey", getp(&env, "${PROJECTNAME}_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(PROJECTNAME, v.name)}", Value::str(${JSON.stringify(v.dflt)})),`).join('')

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

@@ -26,8 +26,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 +62,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('')

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))) {