@voxgig/sdkgen 4.20.0 → 4.22.0

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/tests/vendor/omni/json.rs

@@ -1,5 +1,5 @@
-// VENDORED: @voxgig/omni sdk-20260908-1556-0 (rust/src/json.rs)
-// Source: https://github.com/voxgig/omni @ 274708cc2d12b21707d975543953f845f8444be0  [tag: sdk-20260911-2013-0]
+// VENDORED: @voxgig/omni sdk-20260917-1242-0 (rust/src/json.rs)
+// Source: https://github.com/voxgig/omni @ b9e6085d185e174be84f9e6123be807ccd9fcb4e  [tag: sdk-20260917-1242-0]
 // License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
 //! The omni JSON value model, with a small in-tree parser.
 //!

package/project/.sdk/tm/rust/tests/vendor/omni/mod.rs

@@ -1,5 +1,5 @@
-// VENDORED: @voxgig/omni sdk-20260908-1556-0 (rust/src/lib.rs)
-// Source: https://github.com/voxgig/omni @ 274708cc2d12b21707d975543953f845f8444be0  [tag: sdk-20260911-2013-0]
+// VENDORED: @voxgig/omni sdk-20260917-1242-0 (rust/src/lib.rs)
+// Source: https://github.com/voxgig/omni @ b9e6085d185e174be84f9e6123be807ccd9fcb4e  [tag: sdk-20260917-1242-0]
 // License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
 //! voxgig_omni - the shared multi-language test runner.
 //!

package/project/.sdk/tm/rust/tests/vendor/omni/regex.rs

@@ -1,5 +1,5 @@
-// VENDORED: @voxgig/omni sdk-20260908-1556-0 (rust/src/regex.rs)
-// Source: https://github.com/voxgig/omni @ 274708cc2d12b21707d975543953f845f8444be0  [tag: sdk-20260911-2013-0]
+// VENDORED: @voxgig/omni sdk-20260917-1242-0 (rust/src/regex.rs)
+// Source: https://github.com/voxgig/omni @ b9e6085d185e174be84f9e6123be807ccd9fcb4e  [tag: sdk-20260917-1242-0]
 // License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
 //! A small backtracking regex engine.
 //!

package/project/.sdk/tm/rust/tests/vendor/omni/runner.rs

@@ -1,5 +1,5 @@
-// VENDORED: @voxgig/omni sdk-20260908-1556-0 (rust/src/runner.rs)
-// Source: https://github.com/voxgig/omni @ 274708cc2d12b21707d975543953f845f8444be0  [tag: sdk-20260911-2013-0]
+// VENDORED: @voxgig/omni sdk-20260917-1242-0 (rust/src/runner.rs)
+// Source: https://github.com/voxgig/omni @ b9e6085d185e174be84f9e6123be807ccd9fcb4e  [tag: sdk-20260917-1242-0]
 // License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
 //! Omni: the shared multi-language test runner.
 //!

package/project/.sdk/tm/rust/tests/vendor/omni/util.rs

@@ -1,5 +1,5 @@
-// VENDORED: @voxgig/omni sdk-20260908-1556-0 (rust/src/util.rs)
-// Source: https://github.com/voxgig/omni @ 274708cc2d12b21707d975543953f845f8444be0  [tag: sdk-20260911-2013-0]
+// VENDORED: @voxgig/omni sdk-20260917-1242-0 (rust/src/util.rs)
+// Source: https://github.com/voxgig/omni @ b9e6085d185e174be84f9e6123be807ccd9fcb4e  [tag: sdk-20260917-1242-0]
 // License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
 //! Omni internal JSON utilities.
 //!

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);
     }

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

@@ -4,23 +4,7 @@ use crate::core::context::Context;
 use crate::core::helpers::{getp, setp};
 use crate::utility::voxgigstruct::Value;
 
-// GraphQL transport. API-INDEPENDENT: every GraphQL SDK this generator
-// produces uses this file unchanged. The API-specific part — which
-// operations exist and what each one's document is — is model data,
-// computed once by apidef and emitted into Config.
-//
-// Two jobs:
-//
-//   graphql_body_util   — build { query, variables } for a point, binding
-//                         the op's arguments to the document's declared
-//                         variables.
-//
-//   graphql_errors_util — lift a GraphQL failure into an SDK error.
-//                         GraphQL reports failures as a top-level `errors`
-//                         array under HTTP 200, so the status-driven path
-//                         in result_basic never sees them.
-
-/// Content type every GraphQL-over-HTTP request uses.
+
 pub const GRAPHQL_CONTENT_TYPE: &str = "application/json";
 
 fn as_str(v: &Value) -> String {
@@ -62,12 +46,6 @@ pub fn graphql_error_code(gqlerr: &Value) -> &'static str {
     "request_graphql"
 }
 
-/// Build the request body for a GraphQL point.
-///
-/// Variables come from the op's own arguments: a named variable binds to
-/// the like-named argument (`from`), and the input-object variable (empty
-/// `from`) takes the request data as a whole — which is what makes a
-/// generated create/update call look exactly like its REST equivalent.
 pub fn graphql_body_util(ctx: &Rc<Context>) -> Value {
     let point = ctx.point.borrow().clone();
     let gql = getp(&point, "graphql");
@@ -145,13 +123,6 @@ pub fn graphql_body_util(ctx: &Rc<Context>) -> Value {
     out
 }
 
-/// Inspect a decoded GraphQL response body and record a failure when the
-/// server reported one. Returns true when an error was recorded.
-///
-/// Partial data (`data` alongside `errors`) is treated as failure: the
-/// REST surface has no partial-success concept, and silently returning
-/// half an object would be worse than failing. The raw envelope stays
-/// available on the result for callers that need it.
 pub fn graphql_errors_util(ctx: &Rc<Context>) -> bool {
     let point = ctx.point.borrow().clone();
 

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

@@ -63,8 +63,6 @@ pub fn make_error_util(
     sdk_err.result = crate::utility::clean::clean_util(ctx, &result.borrow().to_value());
     sdk_err.spec = crate::utility::clean::clean_util(ctx, &spec_val);
 
-    // Promote the HTTP status to the top level, so a consumer can branch on
-    // `err.status` / `err.not_found()` rather than reaching into `err.result`.
     sdk_err.status = result.borrow().status;
 
     ctrl.borrow_mut().err = Some(sdk_err.clone());

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

@@ -23,17 +23,6 @@ pub fn make_options_util(ctx: &Rc<Context>) -> Value {
         }
     }
 
-    // `auth: null` is the documented way to disable auth outright, and
-    // prepare_auth honours it before it ever reads the apikey. It cannot
-    // survive validate: depending on the struct port a stored null is either
-    // REPLACED by the optspec default - transmitting the credential the
-    // caller withheld - or REJECTED outright. Withhold the key for validate,
-    // then put the null back. Same fix as ts/js/go make_options.
-    //
-    // Read the map DIRECTLY rather than through get_prop: get_prop applies
-    // the Group A rule and returns 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 auth_suppressed = match &options {
         Value::Map(m) => matches!(m.borrow().get("auth"), Some(Value::Null)),
         _ => false,
@@ -45,12 +34,6 @@ pub fn make_options_util(ctx: &Rc<Context>) -> Value {
         opts = vs::del_prop(opts, &Value::str("auth"));
     }
 
-    // Feature add-order. `options.feature` may be an ordered List of
-    // { name, active, ...opts } entries (the List position IS the order in
-    // which features are added), or a { name: {opts} } map. Normalize a List
-    // to a map (so merge/validate are unchanged) and remember the explicit
-    // order; a map defaults to test-first so the `test` mock transport is
-    // installed as the base of the transport wrapper chain.
     let mut feature_order: Vec<String> = Vec::new();
     if let Value::List(fl) = getp(&opts, "feature") {
         let fmap = Value::empty_map();
@@ -73,69 +56,7 @@ pub fn make_options_util(ctx: &Rc<Context>) -> Value {
         _ => Value::empty_map(),
     };
 
-    let optspec = jo(vec![
-        ("apikey", Value::str("")),
-        ("base", Value::str("http://localhost:8000")),
-        ("prefix", Value::str("")),
-        ("suffix", Value::str("")),
-        // CLOSED - validate rejects any key it does not declare - so without
-        // `in` and `name` an apiKey-in-query SDK fails to construct on its
-        // own config with "Unexpected keys at field auth: in, name".
-        // '' means "take what the spec said".
-        (
-            "auth",
-            jo(vec![
-                ("prefix", Value::str("")),
-                ("basic", Value::Bool(false)),
-                ("in", Value::str("")),
-                ("name", Value::str("")),
-            ]),
-        ),
-        ("headers", jo(vec![("`$CHILD`", Value::str("`$STRING`"))])),
-        (
-            "allow",
-            jo(vec![
-                ("method", Value::str("GET,PUT,POST,PATCH,DELETE,OPTIONS")),
-                ("op", Value::str("create,update,load,list,remove,command,direct,graphql")),
-            ]),
-        ),
-        (
-            "entity",
-            jo(vec![(
-                "`$CHILD`",
-                jo(vec![
-                    ("`$OPEN`", Value::Bool(true)),
-                    ("active", Value::Bool(false)),
-                    ("alias", Value::empty_map()),
-                ]),
-            )]),
-        ),
-        (
-            "feature",
-            jo(vec![(
-                "`$CHILD`",
-                jo(vec![
-                    ("`$OPEN`", Value::Bool(true)),
-                    ("active", Value::Bool(false)),
-                ]),
-            )]),
-        ),
-        ("utility", Value::empty_map()),
-        ("system", Value::empty_map()),
-        (
-            "test",
-            jo(vec![
-                ("active", Value::Bool(false)),
-                ("entity", jo(vec![("`$OPEN`", Value::Bool(true))])),
-            ]),
-        ),
-        ("clean", jo(vec![("keys", Value::str("key,token,id"))])),
-        // Server-variable values for a templated base URL (OpenAPI server
-        // variables): {name} placeholders in "base" are substituted from this
-        // map at construction. Spec defaults arrive via the generated config;
-        // user values override them. Mirrors go's make_options optspec.
-        ("server", jo(vec![("`$CHILD`", Value::str(""))])),
-    ]);
+    let optspec = crate::core::schema::optspec();
 
     // Preserve system.fetch before merge/validate (validation strips it).
     let sys_fetch = getpath(&["system", "fetch"], &opts);
@@ -157,16 +78,6 @@ pub fn make_options_util(ctx: &Rc<Context>) -> Value {
         setp(&opts, "auth", Value::Null);
     }
 
-    // Resolve a templated base URL (e.g. https://{tenant_id}.hanko.io).
-    // Every placeholder must resolve to a non-empty value: from options.server
-    // (user), else the Config default. A placeholder that resolves to "" is a
-    // construction ERROR in live mode - the URL cannot work - but in test mode
-    // substitutes the deterministic value "test-<name>" so offline tests need
-    // no configuration. The SDK constructor has no error return, so a missing
-    // required variable PANICS: construction-time misconfiguration.
-    //
-    // Scanned by hand rather than with vs::re_replace, whose replacement is a
-    // fixed string and cannot vary per placeholder.
     if let Value::Str(base) = getp(&opts, "base") {
         if base.contains('{') {
             let testmode = matches!(getpath(&["test", "active"], &opts), Value::Bool(true))
@@ -225,7 +136,6 @@ pub fn make_options_util(ctx: &Rc<Context>) -> Value {
         }
     }
 
-    // Restore system.fetch.
     if !sys_fetch.is_noval() {
         let sys = getp(&opts, "system");
         if let Value::Map(_) = sys {
@@ -235,7 +145,6 @@ pub fn make_options_util(ctx: &Rc<Context>) -> Value {
         }
     }
 
-    // Derived clean config.
     let clean_keys = match getpath(&["clean", "keys"], &opts) {
         Value::Str(s) => s,
         _ => "key,token,id".to_string(),
@@ -265,12 +174,6 @@ pub fn make_options_util(ctx: &Rc<Context>) -> Value {
             } else {
                 feature_order = names;
             }
-            // Station special case, mirroring test's: its transport wrap must
-            // sit immediately outside the base transport (inside retry/cache/
-            // netsim), so map-form activation hoists it to just after test -
-            // or first, when no test entry exists. Without this the sorted
-            // default would init station last and wrap OUTSIDE the recording
-            // features, turning its wire-truth events into fiction.
             if let Some(si) = feature_order.iter().position(|n| n == "station") {
                 feature_order.remove(si);
                 let at = feature_order