@voxgig/sdkgen 4.21.0 → 4.22.0

package/project/.sdk/tm/rust/tests/feature/secrets/main.rs

@@ -1,28 +1,3 @@
-// Behavioural tests for the secrets feature (vendored @voxgig/sekreto).
-//
-// The contract under test: the `apikey` OPTION keeps its exact old meaning
-// and always wins, because the feature places it FIRST in the provider
-// chain (a `memory` store named `options`) - explicit-beats-lookup falls
-// out of sekreto's first-hit rule rather than from special-case logic. With
-// the feature inactive nothing changes at all. With it active and the
-// option unset, the chain supplies the credential instead.
-//
-// EVERY CLIENT HERE IS LIVE, and the thing counted is `system.fetch` - the
-// real transport the whole fetcher chain ends at. That is deliberate, and
-// it is the mistake this file exists to avoid: under `test_sdk` the test
-// feature REPLACES the transport with its own in-memory mock, so a counter
-// hung off `system.fetch` is never reached, and "no request was sent" would
-// hold for a healthy SDK carrying no secrets feature at all. An assertion
-// that cannot fail pins no rule. So each fail-closed case proves its own
-// counter FIRST, with the same construction and a WORKING provider: one
-// request must reach `system.fetch` carrying the resolved credential. Only
-// then does a zero from the broken provider mean REFUSED rather than
-// UNWIRED. And the refusal is matched on the PROVIDER'S OWN message, so an
-// unrelated failure cannot stand in for fail-closed.
-//
-// This file lives in the `feature/` container on purpose: `target add`
-// trims it, along with the feature source and the vendored library, for a
-// project whose model does not select `secrets`.
 
 use std::cell::RefCell;
 use std::rc::Rc;
@@ -38,14 +13,6 @@ const BASE: &str = "http://secrets.test/api";
 
 // ---- the counted transport ---------------------------------------------
 
-/// One recorded request, SNAPSHOT at the moment it was handed to the
-/// transport.
-///
-/// A snapshot, not the fetchdef itself, and that is load-bearing: the
-/// fetchdef's `headers` map is an Rc the retry path rewrites IN PLACE, so
-/// a recorder that kept the live map would report every earlier call as
-/// carrying the LAST token - and "the retry carried a new credential"
-/// would pass whether or not it did.
 #[derive(Clone)]
 struct Call {
     url: String,
@@ -205,12 +172,6 @@ fn authof(fetchdef: &Value) -> Option<String> {
     }
 }
 
-// The Authorization header carries the SPEC's credential prefix, which a
-// TEMPLATE cannot know: an OpenAPI `http`/`bearer` scheme gives
-// `Bearer <token>`, an apiKey scheme the raw token. So assert on the
-// CREDENTIAL and let the prefix be whatever this SDK's API declares -
-// pinning the whole header value passes only for a prefix-less API, and
-// this file ships to every project that selects the feature.
 fn credential_is(header: Option<String>, token: &str) {
     let got = header.unwrap_or_default();
     assert!(
@@ -227,14 +188,6 @@ fn call_auth(calls: &[Call], i: usize) -> Option<String> {
 
 // ---- clients ------------------------------------------------------------
 
-// `allow.op` is named explicitly: a project that narrows the default set
-// would otherwise turn the raw-path cases into a false RED (the control leg
-// refused before it reached the transport), and the rule under test lives
-// at the transport, downstream of the allow gate either way.
-//
-// `base` is named explicitly too: a LIVE client whose model has a templated
-// base URL panics on a missing server variable at construction, and this
-// file ships to every project.
 fn sdk(wire: &Wire, secrets: Vec<(&str, Value)>) -> Rc<ProjectNameSDK> {
     let fopts = jo(vec![("active", Value::Bool(true))]);
     for (k, v) in secrets {
@@ -303,15 +256,6 @@ fn secrets_call(client: &Rc<ProjectNameSDK>, args: Vec<Value>) -> Value {
 
 // ---- the ENTITY path ----------------------------------------------------
 
-/// One request through the REAL entity-request utility, on the client's own
-/// utility - the one the feature wrapped.
-///
-/// `direct()` and `graphql()` are the raw paths and are exercised as
-/// themselves below; this is the OTHER half, and it cannot be reached by
-/// naming an entity because this file is a TEMPLATE and no project's entity
-/// names are known here. `make_request` is the utility every generated
-/// entity op ends at, so driving it directly exercises the same seam with
-/// the same wiring.
 fn entity_request(client: &Rc<ProjectNameSDK>, path: &str) -> Option<String> {
     let rootctx = client.get_root_ctx();
     let utility = rootctx.util();
@@ -514,12 +458,6 @@ fn auth_null_suppresses_the_credential_chain_or_no_chain() {
         wire.trace()
     );
 
-    // The suppression survives option validation rather than being replaced
-    // by the optspec's default auth map.
-    //
-    // Read from the RAW map: `getp` applies the Group A rule and answers
-    // the alt for a stored null, so it cannot tell an absent auth from a
-    // suppressed one - and only the latter is a suppression.
     let opts = client.options_map();
     let suppressed = match &opts {
         Value::Map(m) => matches!(m.borrow().get("auth"), Some(Value::Null)),
@@ -787,13 +725,6 @@ fn an_unknown_provider_kind_refuses_rather_than_sending() {
     assert_eq!(control.sent(), 1, "the control request never reached the wire");
 }
 
-// A MALFORMED entry is the same rule again, and the one a typed port can
-// get wrong silently: `providers` is a Value list, so an entry that is
-// neither a callable nor a spec map (a bare "hashicorp" where a spec was
-// meant) matches no arm. Dropping it leaves the chain quietly SHORTER than
-// the options say - a fail-OPEN that sends the request without the
-// credential the project configured. It must refuse instead, carrying
-// sekreto's own wording, on every wire path.
 const MALFORMED_MSG: &str = "sekreto: not a provider or a provider spec";
 
 #[test]
@@ -879,15 +810,6 @@ fn the_selected_plugin_kinds_have_distinct_names() {
     );
 }
 
-// A SELECTED plugin kind is really in the vocabulary.
-//
-// Construction is where an unknown kind is refused, so a chain that names
-// the kind and still reaches the wire IS the check. The memory store comes
-// FIRST so sekreto's first-hit rule answers from it and the vault is never
-// contacted - the kind has to be declarable, not reachable.
-//
-// Conditional on the kind being selected, because this file ships to
-// projects that take the feature without the `vault` plugin group.
 #[test]
 fn a_selected_plugin_kind_is_in_the_sdk_vocabulary() {
     let defs = RUSTCRATE::feature::secrets::plugins::definitions();
@@ -990,13 +912,10 @@ fn cache_false_asks_the_chain_on_every_request() {
 }
 
 // A MISS IS NOT A CACHEABLE ANSWER - sekreto's own rule, which this feature
-// used to override from the layer above.
 //
 // DEFAULT caching here, which is the whole point: `cache: true` is about
 // holding a HIT (the test below pins that half), and keeping the settled
 // resolution after a miss meant the chain was never asked again for the life
-// of the client. A secret provisioned after startup (a mounted file, a vault
-// policy granted a minute late) was invisible forever.
 #[test]
 fn cache_true_re_asks_after_a_miss() {
     let wire = Wire::new();
@@ -1153,12 +1072,6 @@ fn sekreto_is_live_for_arbitrary_secrets_and_redaction() {
     );
 }
 
-// ---- ACCESS-TOKEN EXCHANGE ----------------------------------------------
-//
-// What the chain resolves is a REFRESH token, which is POSTed to a token
-// endpoint for a short-lived ACCESS token; the access token is what the
-// Authorization header carries; and when the API answers 401 the client
-// buys another and tries the same request again, once.
 
 const REFRESH: &str = "REFRESH01";
 
@@ -1252,7 +1165,6 @@ fn an_expiry_buys_another_token_and_retries_the_same_request() {
     assert_eq!(wire.token().len(), 2, "expected a second token purchase");
     assert_eq!(wire.api().len(), 2, "expected the request to be retried");
     credential_is(call_auth(&wire.api(), 0), "ACCESS01");
-    // The retry must carry the NEW token, not the spent one.
     credential_is(call_auth(&wire.api(), 1), "ACCESS02");
     assert_eq!(
         getp(&res, "ok"),
@@ -1489,7 +1401,6 @@ fn exchange_auth_null_suppresses_and_is_never_retried() {
     );
 
     // AND NO PURCHASE. resolve() runs before with_refresh's suppression
-    // check, so the refresh token used to go to the token endpoint in a
     // request body even here. Stopping the retry does not unsend it, and
     // only the token endpoint can see this.
     assert_eq!(
@@ -1501,12 +1412,6 @@ fn exchange_auth_null_suppresses_and_is_never_retried() {
     );
 }
 
-// The exchange with NO system.fetch: the ordinary case, where make_options
-// leaves the seam unset and the purchase takes its own raw HTTP path. There
-// is no token endpoint to talk to here, so what this pins is that the
-// fallback EXISTS and reports - before this, `buy` with no custom transport
-// simply had nothing to call - and that a failed purchase refuses the
-// operation rather than sending it unauthenticated.
 #[test]
 fn the_exchange_has_a_raw_transport_when_no_system_fetch_is_given() {
     // Port 1 is reserved and never listening, so the connection is refused

package/project/.sdk/tm/rust/tests/feature_test.rs

@@ -1,10 +1,3 @@
-// Behavioural tests for the enterprise features shipped with this SDK
-// (mirrors tm/go/test/feature_test.go). Feature behaviour is unit-tested
-// by driving each feature through a faithful miniature of the real
-// operation pipeline against a configurable mock transport — the same hook
-// order and short-circuit rules as the generated entity op code, but with
-// no live server and no API-specific fixtures. Each block runs only when
-// its feature is present in this SDK (see common::fh_present).
 
 mod common;
 
@@ -1828,15 +1821,6 @@ fn feature_proxy_inactive_does_not_wrap() {
 
 // --- station --------------------------------------------------------------------
 
-// The station adapter (installed by @voxgig/sdkgen-station) with NO open
-// station must be an inert no-op that emits nothing and fails nothing
-// (station design 3.1). Constructed through the generated make_feature
-// factory - never a compile-time module reference - so this file stays
-// compilable both with and without the station feature installed: absent,
-// the factory answers with the inert BaseFeature and fh_present skips the
-// assertions. Bound behaviour (registration, injection, wire events) is
-// exercised by the station library's own suite and the consumer-side
-// station validation, not here.
 #[test]
 fn feature_station_inert_without_open_station() {
     if !fh_present(&["station"]) {

package/project/.sdk/tm/rust/tests/netsim_test.rs

@@ -1,9 +1,3 @@
-// Network-behaviour simulation over the offline mock transport (mirrors
-// tm/go/test/netsim_test.go). The `test` feature accepts an optional `net`
-// config so unit tests can exercise slow, failing and offline conditions
-// without a live server. These checks drive the transport through
-// direct(), which needs no entity, so they run for every generated SDK
-// regardless of its API shape.
 
 use RUSTCRATE::core::helpers::{getp, jo, now_ms};
 use RUSTCRATE::{test_sdk, Value};

package/project/.sdk/tm/rust/tests/omni_resolver/mod.rs

@@ -1,88 +1,3 @@
-// The corpus test runner: vendored @voxgig/omni driven through its NATIVE
-// API (`omni::runner::make_runner` / `RunPack::runsetflags_args`), presented
-// to the corpus suites in the struct-runner shape they already use
-// (`run.spec`, `run.set`, `run.run_set`, `run.run_set_fallible`,
-// `run.passed`, `run.failures`). No compat shim is vendored: the adapter
-// below IS the whole bridge, per language, per the vendor-tag rollout
-// (docs/design/vendor-tag-rollout.md, Decision 4). It supersedes the whole
-// of the retired `tests/struct_runner/mod.rs` and the corpus ENGINE half of
-// `tests/common/mod.rs` (`runset`/`runset_named`/`match_deep`/`match_string`
-// went with it; that file's SUPPORT half — env, sdk-test-control, ctx
-// construction, the fh harness — is retained under its own name, so the
-// emitted call sites did not move).
-//
-// It is the Rust peer of tm/csharp/test/OmniResolver.cs,
-// tm/java/test/OmniResolver.java and
-// tm/swift/Tests/ProjectNameSDKTests/OmniResolver.swift, and it follows the
-// bridge voxgig/struct's own rust corpus harness already uses
-// (struct/rust/corpus/tests/omni.rs) — the portable answer for a statically
-// typed port with no reflection: omni's `Provider` is closure-based, so
-// nothing in omni ever has to name this SDK's types.
-//
-// Rust-specific decisions, each load-bearing:
-//
-// 1. TWO VALUE MODELS, ONE CONVERSION PAIR. omni's `Json` and the SDK's
-//    `voxgigstruct::Value` are different enums, so every crossing is an
-//    explicit `tostruct` / `toomni`. `Json::Absent` <-> `Value::Noval` and
-//    `Json::Null` <-> `Value::Null` keep the two no-value states the corpus
-//    distinguishes apart — which is also why Rust needs neither go's
-//    `novalargs` spec rewrite nor lua/php's compat shim for the corpus's
-//    zero-argument entries (an entry with no `in`/`args`/`ctx` arrives as
-//    one `Json::Absent`, and becomes exactly this port's own NOVAL).
-//
-// 2. ARGUMENTS ARE WRITTEN BACK. `SubjectArgs` (`Fn(&mut [Json])`) is the
-//    channel omni provides for a subject that MUTATES its arguments, which
-//    `match: {args: ...}` then asserts on — `struct/minor/setpath` and
-//    `struct/merge/integrity` turn on it. Decision 1 handed the subject a
-//    CONVERTED COPY, so every subject here runs through `runsetflags_args`
-//    and the wrapper converts the (possibly mutated) `Value` arguments back
-//    into omni's own slice after the call. A dynamic port's shim gets this
-//    for free from shared object identity; Rust cannot.
-//
-// 3. `match: {ctx: ...}` IS RETARGETED ONTO `match: {args: {"0": ...}}`.
-//    The one place this port cannot follow canonical omni as written, and a
-//    VALUE-SEMANTICS consequence, not a choice. omni's `Json` is a plain
-//    enum: `resolveargs` stores `entry.ctx` and `args[0]` as two COPIES of
-//    the contextified map, and `checkresult` reads `entry.get("ctx")` for
-//    the ctx base — so a subject's post-call writes (decision 2) can never
-//    reach the copy `entry.ctx` holds, and nine `primary` entries assert
-//    exactly that post-call state. args[0] IS the ctx of a ctx entry (omni
-//    itself sets `args = [entry.get("ctx")]`), so moving the assertion from
-//    `ctx` to `args.0` reads the SAME map, post-call, and preserves every
-//    leaf: nothing is dropped, weakened or skipped. `retargetctx` below does
-//    that rewrite on the spec handed to the engine. Swift faces the identical
-//    problem and answers it identically; the upstream fix is for the Rust
-//    port's `drive` to re-point `entry.ctx` at the returned `args[0]`, the
-//    way JS object identity does implicitly — filed as a follow-up, not
-//    worked around by editing a vendored file.
-//
-// 4. NUMBERS NEED NOTHING. omni's parser reads every JSON number as `f64`
-//    and this port's `Value::Num` is also `f64` — unlike go/csharp/java,
-//    where an integral double had to be narrowed before a subject saw it.
-//
-// 5. KEY ORDER. omni models a map as a `BTreeMap`, which sorts; this port's
-//    `OrderedMap` preserves insertion order. Every map in the shared corpus
-//    is already in sorted key order, so the round-trip is lossless over it —
-//    but an out-of-order map authored later WOULD be reordered on the way
-//    in, and `raw_unsorted_keys` below is the tripwire that says so instead
-//    of failing an order-sensitive subject (`keysof`, `items`, `stringify`)
-//    with a mystery diff. It reads the corpus FILE with its own
-//    order-preserving scanner and never touches `Json`: a check fed by
-//    omni's parser would be comparing an already-sorted map against itself
-//    and could not fail. See `corpus_maps_are_in_sorted_key_order`.
-//
-// 7. WHAT RAN IS COUNTED, NOT WHAT WAS DECLARED. `drive` counts SUBJECT
-//    INVOCATIONS, not `entrycount(set)`: a number derived from the spec
-//    cannot tell a working engine from a disconnected one, and would read as
-//    evidence while proving nothing. It also compares the two and fails the
-//    group when they differ. `report` then refuses to pass on a group that
-//    is absent from the corpus, or present in the corpus but driven by
-//    nothing — the two ways a suite quietly stops checking.
-//
-// 6. FAILURES ARE ACCUMULATED, NOT RAISED. omni stops a group at its first
-//    bad entry and returns an `OmniError`; the struct suite reports the whole
-//    corpus in one panic at the end. `drive` records the message and carries
-//    on, so one run still names every broken GROUP.
 
 #![allow(dead_code)]
 // The vendored port re-exports its whole surface; a test crate uses part of
@@ -106,11 +21,7 @@ use RUSTCRATE::utility::voxgigstruct::value::Value;
 use RUSTCRATE::utility::voxgigstruct::InjectDef;
 use RUSTCRATE::ProjectNameError;
 
-// ---------------------------------------------------------------------------
-// The two value models (decision 1)
-// ---------------------------------------------------------------------------
 
-/// omni's model -> this SDK's.
 pub fn tostruct(val: &Json) -> Value {
     match val {
         Json::Absent => Value::Noval,
@@ -129,15 +40,6 @@ pub fn tostruct(val: &Json) -> Value {
     }
 }
 
-/// This SDK's model -> omni's.
-///
-/// `Value::Func` has no JSON shape at all. It reaches here only when a corpus
-/// entry puts a callable in data (`get_elem` with a callable `alt`, `$APPLY`,
-/// a user `$FORMAT`), and in every such case the corpus asserts on what the
-/// call RETURNED, not on the callable. `Json::Absent` is the honest answer:
-/// it is what omni's own model says about a value that is not JSON, and
-/// omni's `fixjson` then renders it as NULLMARK under the null flag — the
-/// same place the retired hand-written `fix_json` put it.
 pub fn toomni(val: &Value) -> Json {
     match val {
         Value::Noval => Json::Absent,
@@ -168,19 +70,6 @@ pub struct KeyOrderScan {
     pub unsorted: Option<String>,
 }
 
-/// Scan RAW JSON TEXT for a map whose keys are not in sorted order.
-///
-/// This deliberately does NOT go through `omni::runner::loadspec`: omni's
-/// `Json::Map` is a `BTreeMap`, so a parse has already sorted every map and
-/// the disorder this exists to catch is gone before the check can see it. A
-/// tripwire fed by the thing it is watching cannot fire, so the scanner
-/// below walks the file itself and keeps keys in the order they were
-/// authored. `String`'s ordering is byte-lexicographic on UTF-8, which is
-/// exactly the ordering a `BTreeMap<String, _>` imposes, so a sorted scan
-/// means a lossless crossing.
-///
-/// Panics on malformed JSON: a corpus this cannot parse must be loud, not a
-/// silent zero-map pass.
 pub fn raw_unsorted_keys(text: &str) -> KeyOrderScan {
     let mut scan = RawScan {
         src: text.as_bytes(),
@@ -464,18 +353,15 @@ pub fn spec_path() -> String {
     path.to_string_lossy().into_owned()
 }
 
-/// The whole corpus, as omni loaded it.
 pub fn corpus() -> Json {
     omni::runner::loadspec(SpecRef::Path(spec_path()))
         .unwrap_or_else(|err| panic!("omni: {}", err.message))
 }
 
-/// A child node by key (absent when missing).
 pub fn jget(val: &Json, key: &str) -> Json {
     val.get(key)
 }
 
-/// A child node by path.
 pub fn jpath(val: &Json, keys: &[&str]) -> Json {
     let mut current = val.clone();
     for key in keys {
@@ -484,7 +370,6 @@ pub fn jpath(val: &Json, keys: &[&str]) -> Json {
     current
 }
 
-/// How many entries a group declares.
 pub fn entrycount(set: &Json) -> usize {
     set.get("set").aslist().map(|list| list.len()).unwrap_or(0)
 }
@@ -500,7 +385,6 @@ pub struct Run {
     /// The whole corpus (sections outside this one: `DEF` blocks, the
     /// `primary/check` client group the struct suite drives by hand).
     pub all: Json,
-    /// The resolved section.
     pub spec: Json,
     pub failures: Vec<String>,
     pub passed: usize,
@@ -515,7 +399,6 @@ pub struct Run {
 }
 
 impl Run {
-    /// A runner over one named section of the shared corpus.
     pub fn section(name: &str) -> Run {
         Run::over(corpus(), name)
     }
@@ -540,7 +423,6 @@ impl Run {
         }
     }
 
-    /// A named group of the resolved section.
     pub fn set(&self, keys: &[&str]) -> Json {
         jpath(&self.spec, keys)
     }
@@ -594,7 +476,6 @@ impl Run {
         });
     }
 
-    /// Hand one group to omni and record the outcome.
     fn drive<F>(&mut self, set: &Json, nullflag: bool, label: &str, subject: F)
     where
         F: Fn(&mut [Json]) -> Result<Json, String> + 'static,
@@ -642,14 +523,10 @@ impl Run {
     }
 
     /// Every `<category>-<group>` in this section that carries a non-empty
-    /// `set` — the groups a suite over this section is expected to drive.
-    ///
-    /// Shape-specific: it assumes the `struct` section's two levels
     /// (`<category>.<group>.set`) and the `"<category>-<group>"` labels the
     /// struct suite passes to `run_set`. The `primary` section nests
     /// differently (`primary.<name>.basic`) and labels its groups `<name>`,
     /// so it guards zero-case runs in `runsection` instead — see
-    /// tests/primary_utility_test.rs.
     pub fn corpus_groups(&self) -> Vec<(String, usize)> {
         let mut found: Vec<(String, usize)> = Vec::new();
         let categories = match self.spec.asmap() {
@@ -660,7 +537,6 @@ impl Run {
             let groups = match node.asmap() {
                 Some(map) => map,
                 // `<category>.name` is a string and `<category>.set` an empty
-                // list; neither is a group.
                 None => continue,
             };
             for (name, group) in groups.iter() {
@@ -673,14 +549,6 @@ impl Run {
         found
     }
 
-    /// Fail the test with every accumulated failure, or report the count.
-    ///
-    /// `expectedskips` names the groups THIS SDK's corpus subset does not
-    /// carry. It is exhaustive in both directions: a group that goes absent
-    /// without being listed fails, and a listed group that is no longer
-    /// absent fails too. Without that a renamed or deleted group would take
-    /// its whole check count with it and the suite would still say `ok` —
-    /// the exact silence the shared oracle exists to prevent.
     pub fn report(&self, what: &str, expectedskips: &[&str]) {
         let mut problems: Vec<String> = self.failures.clone();
 
@@ -749,7 +617,6 @@ fn writeback(args: &mut [Json], index: usize, val: &Value) {
 
 /// Retarget `match: {ctx: ...}` onto `match: {args: {"0": ...}}` — decision 3.
 /// Only when the entry HAS a ctx or args (so args[0] is that map) and the
-/// check does not already assert on `args`.
 fn retargetctx(testspec: &Json) -> Json {
     let set = match testspec.get("set") {
         Json::List(list) => list,
@@ -768,8 +635,6 @@ fn retargetctx(testspec: &Json) -> Json {
             let mut newcheck = BTreeMap::new();
             if let Json::Map(fields) = &check {
                 for (key, val) in fields.iter() {
-                    // Drop the original leaf: it would read the stale
-                    // pre-call copy omni keeps in `entry.ctx`.
                     if "ctx" != key {
                         newcheck.insert(key.clone(), val.clone());
                     }

package/project/.sdk/tm/rust/tests/omni_smoke_test.rs

@@ -1,10 +1,3 @@
-// Smoke tests for the vendored omni runner itself: a runner that cannot FAIL
-// a bad entry would turn every corpus suite vacuously green, so pin the
-// failure paths, not just the happy one. (The Rust peer of
-// tm/ts/test/omni.test.ts and tm/go/test/omnismoke_test.go.)
-//
-// The resolver accumulates group failures rather than panicking, so these
-// tests can assert that a failure HAPPENED without failing themselves.
 
 mod omni_resolver;
 
@@ -193,14 +186,6 @@ fn omni_absent_group_is_named_not_silent() {
     assert_eq!(vec!["smoke-missing".to_string()], run.skipped);
 }
 
-// Decision 5's tripwire: omni's BTreeMap sorts map keys, so an out-of-order
-// map in the corpus would be silently reordered on the way into a subject.
-//
-// It reads the corpus FILE. Going through `corpus()` would hand the check a
-// `Json::Map`, which is a `BTreeMap` — already sorted by the parse — so the
-// comparison would be a sorted list against itself and the tripwire could
-// never fire. `key_order_scan_fires_on_an_out_of_order_map` below is the
-// proof that this one can.
 #[test]
 fn corpus_maps_are_in_sorted_key_order() {
     let path = spec_path();

package/project/.sdk/tm/rust/tests/pipeline_test.rs

@@ -1,9 +1,3 @@
-// Direct unit tests for the operation-pipeline utilities (mirrors
-// tm/go/test/pipeline_test.go). The generated entity tests exercise the
-// happy path; these drive the error and edge branches (missing
-// spec/response/result, 4xx handling, transport failures, feature add
-// semantics, auth header shaping) that a normal success-path op never
-// reaches.
 
 mod common;
 

package/project/.sdk/tm/rust/tests/primary_utility_test.rs

@@ -1,13 +1,3 @@
-// Primary utility tests — run the shared `primary` subtree of
-// ../.sdk/test/test.json against the SDK pipeline utilities (mirrors
-// tm/go/test/primary_utility_test.go).
-//
-// The corpus is driven by the VENDORED omni runner through the adapter in
-// tests/omni_resolver/mod.rs. Subjects receive omni's native argument list:
-// a `ctx` entry arrives as args[0], a MAP — `make_ctx_from_map` builds the
-// typed context a generated utility takes, and the subject writes the
-// observable ctx state back into that same map, which is what a
-// `match: {ctx: ...}` assertion reads (see the resolver's decision 3).
 
 mod common;
 mod omni_resolver;
@@ -25,9 +15,6 @@ use RUSTCRATE::{
     ProjectNameError, ProjectNameSDK, SdkResult, Spec, Utility, Value,
 };
 
-// Sections deliberately left empty in the shared corpus
-// (.sdk/test/primary/<name>.aon carries a PENDING header). Everything else
-// MUST contribute cases.
 const PENDING_SECTIONS: &[&str] = &[
     "fetcher", "makeFetchDef", "makeResult", "featureAdd",
     "featureHook", "featureInit",
@@ -42,13 +29,6 @@ fn primary_run() -> Run {
     run
 }
 
-/// Run one corpus section, failing loudly when it would run ZERO cases.
-///
-/// A renamed section, a fixture that failed to compile, or an empty set used
-/// to report PASS while running zero assertions — the whole point of a shared
-/// oracle lost without a single red test. The guard lives here rather than in
-/// the runner, which is vendored verbatim; the shared corpus is a v0 spec,
-/// and v0 tolerates an empty set.
 fn runsection<F>(run: &mut Run, name: &str, subject: F)
 where
     F: FnMut(&mut Vec<Value>) -> Result<Value, ProjectNameError> + 'static,
@@ -749,7 +729,6 @@ fn primary_param_basic() {
 
         // Write the resolved spec alias back into args[0] — the map a
         // `match: {ctx: {spec: {alias: ...}}}` assertion reads (resolver
-        // decision 3 retargets it onto `args.0`).
         if let Some(spec) = ctx.spec.borrow().clone() {
             setp(
                 &ctxmap,
@@ -837,7 +816,6 @@ fn primary_prepare_params_basic() {
     });
 }
 
-// Was two hand-written cases that had drifted out of the shared corpus (the
 // preparePath fixture shipped as an empty `set: []`). Now driven by the
 // corpus like every other section, so all ports assert the same separator /
 // blank-segment behaviour.

package/project/.sdk/tm/rust/tests/struct_utility_test.rs

@@ -1,10 +1,3 @@
-// Struct utility tests — run the shared `struct` corpus subtree from
-// ../.sdk/test/test.json against the vendored voxgig struct port.
-//
-// The corpus is driven by the VENDORED omni runner through the adapter in
-// tests/omni_resolver/mod.rs (which superseded the hand-written
-// tests/struct_runner/mod.rs). Group labels, null flags and subjects are
-// unchanged; the engine underneath them is now the shared one.
 
 mod omni_resolver;
 
@@ -18,18 +11,6 @@ use RUSTCRATE::utility::voxgigstruct::value::Value;
 use RUSTCRATE::utility::voxgigstruct::*;
 
 
-/// Groups this SDK's corpus subset does not carry, so a run over it reports
-/// zero checks for them BY DESIGN.
-///
-/// `Run::report` holds this list to the corpus in both directions: a group
-/// that goes absent without being named here fails the suite, and a name
-/// here that is no longer absent fails it too. Nothing else stops a renamed
-/// or deleted group from taking its whole check count away while `cargo
-/// test` still prints `ok`.
-///
-/// `sentinels` is the Group A null-unification block (UNDEF_SPEC.md): the
-/// subjects below are wired and ready, and the entries arrive with the
-/// corpus refresh that adds `struct.sentinels`.
 const EXPECTED_SKIPS: &[&str] = &[
     "sentinels-getprop_unify",
     "sentinels-getelem_absent",
@@ -271,7 +252,6 @@ fn struct_utility() {
         };
         walk(vin, Some(&mut walkpath), None, None)
     });
-    // walk.log — three runs (after-only / before-only / both) of a logging callback.
     {
         let log_spec = tostruct(&jpath(&s, &["walk", "log"]));
         let input = clone(&vget(&log_spec, "in"));
@@ -650,9 +630,6 @@ fn struct_utility() {
         );
     }
 
-    // -------- primary / SDK ------------------------------------------
-    // A tiny mock SDK (mirrors ts/test/sdk.ts): check(ctx) ->
-    //   { zed: 'ZED' + (opts.foo ?? '') + '_' + (ctx.meta?.bar ?? '0') }
     fn sdk_check(opts: &Value, ctx: &Value) -> Value {
         let foo = get_prop(opts, &Value::str("foo"), Value::Noval);
         let foo_s = if foo.is_nullish() {
@@ -711,8 +688,6 @@ fn struct_utility() {
     run.report("corpus", EXPECTED_SKIPS);
 }
 
-// Function values embedded in data: `get_elem` with a callable `alt`, and
-// `$APPLY` / a user `$FORMAT` formatter — see rs/README.md "Function values".
 #[test]
 fn function_values() {
     // get_elem: absent element + callable alt -> alt is invoked

package/project/.sdk/tm/rust/utility/fetcher.rs

@@ -19,11 +19,6 @@ fn default_http_fetch(fullurl: &str, fetchdef: &Value) -> Result<Value, ProjectN
             builder = builder.proxy(p);
         }
     }
-    // A `redirect: "manual"` annotation (set by the station feature when a
-    // hosts policy is active - the same in-band channel as `proxy` above)
-    // disables automatic redirect following, so a 3xx rides back as a normal
-    // response: a Location pointing off an egress allowlist must never pull
-    // an automatic credentialed follow-up request.
     if get_str(fetchdef, "redirect").as_deref() == Some("manual") {
         builder = builder.redirects(0);
     }