@voxgig/sdkgen 4.21.0 → 4.23.0

package/project/.sdk/tm/js/test/live-entity.js

@@ -10,26 +10,26 @@ const live_runner_1 = require("./live-runner");
 const utility_1 = require("./utility");
 // The offline flow keeps its deterministic fixture assertions. Live flows
 // resolve real prerequisites per operation and collect failures until done.
-async function runLiveEntity(setup, entity, flow, accessor) {
+async function runLiveEntity(setup, entity, flow, accessor, facts = {}) {
     const { client, transport } = setup;
-    const steps = flow.step || [];
+    const steps = (flow.step || []).filter((step) => false !== step.a);
     const created = new Map();
     const listed = [];
     const marks = new Map();
     const idField = entity.id?.field || 'id';
     const copy = (value) => JSON.parse(JSON.stringify(value ?? {}));
-    const hasCreate = steps.some(step => step.op === 'create');
+    const hasCreate = steps.some(step => step.o === 'create');
     const report = await (0, live_runner_1.runLiveSteps)(steps.map((step, index) => {
-        const ref = step.input?.ref || entity.name + '_ref01';
-        const op = step.op;
+        const ref = step.i?.ref || entity.name + '_ref01';
+        const op = step.o;
         const excluded = (0, utility_1.isControlSkipped)('entityOp', entity.name + '.' + op, 'live');
         return {
             id: entity.name + '.' + op + '.' + index,
-            cleanup: op === 'remove' || (step.valid || []).some((v) => v.apply === 'ItemNotExists'),
+            cleanup: op === 'remove' || (step.v || []).some((v) => v.apply === 'ItemNotExists'),
             excluded: excluded.skip ? excluded.reason || 'Excluded by test control' : undefined,
             run: async (context) => {
                 transport.enter(context);
-                const points = entity.op?.[op]?.points || [];
+                const points = (entity.op?.[op]?.points || []).filter((point) => false !== point.a);
                 if (!points.length)
                     throw new live_runner_1.LiveBlocked('No modelled operation point');
                 const record = created.get(ref);
@@ -48,7 +48,7 @@ async function runLiveEntity(setup, entity, flow, accessor) {
                 }
                 let input = op === 'create'
                     ? copy(setup.data.new?.[entity.name]?.[ref]) : {};
-                for (const [name, binding] of Object.entries({ ...step.match, ...step.data })) {
+                for (const [name, binding] of Object.entries({ ...step.m, ...step.d })) {
                     const value = setup.idmap[binding] ?? setup.idmap[name];
                     if (undefined !== value)
                         input[name] = value;
@@ -66,22 +66,22 @@ async function runLiveEntity(setup, entity, flow, accessor) {
                 let selected;
                 const missing = new Set();
                 for (const point of points) {
-                    if (point.select?.$action !== input.$action)
+                    if (point.q?.$action !== input.$action)
                         continue;
                     const candidate = { ...input };
                     let viable = true;
-                    const params = point.args?.params || [];
-                    const query = (point.args?.query || []).filter((arg) => arg.reqd);
+                    const params = point.g?.params || [];
+                    const query = (point.g?.query || []).filter((arg) => arg.r);
                     for (const arg of [...params, ...query]) {
-                        if (undefined !== candidate[arg.name] && null !== candidate[arg.name])
+                        if (undefined !== candidate[arg.n] && null !== candidate[arg.n])
                             continue;
-                        const key = arg.name === 'id' ? entity.name + '01' : arg.name.replace(/_id$/, '') + '01';
-                        const value = setup.idmap[key] ?? setup.idmap[arg.name] ?? loaded?.[arg.name] ?? arg.example;
+                        const key = arg.n === 'id' ? entity.name + '01' : arg.n.replace(/_id$/, '') + '01';
+                        const value = setup.idmap[key] ?? setup.idmap[arg.n] ?? loaded?.[arg.n] ?? arg.ex;
                         if (undefined !== value && null !== value)
-                            candidate[arg.name] = value;
-                        else if (arg.reqd !== false) {
+                            candidate[arg.n] = value;
+                        else if (arg.r !== false) {
                             viable = false;
-                            missing.add(arg.name);
+                            missing.add(arg.n);
                         }
                     }
                     if (viable) {
@@ -93,22 +93,22 @@ async function runLiveEntity(setup, entity, flow, accessor) {
                 if (!resolved)
                     throw new live_runner_1.LiveBlocked('No usable route; missing arguments: ' + [...missing].join(', '));
                 input = resolved;
-                if (op === 'create' && selected.contract) {
-                    const facts = JSON.parse(selected.contract.json);
-                    const request = (0, live_contract_1.requestContract)(facts);
+                if (op === 'create' && facts[selected.m + ' ' + selected.o]) {
+                    const selectedFacts = facts[selected.m + ' ' + selected.o];
+                    const request = (0, live_contract_1.requestContract)(selectedFacts);
                     if (request.schema)
-                        input = { ...(0, live_contract_1.synthesizeInput)(request.schema, facts.live?.input ?? request.example) };
-                    else if (facts.protocol === 'http')
+                        input = { ...(0, live_contract_1.synthesizeInput)(request.schema, selected.li?.input ?? request.example) };
+                    else if (selectedFacts.protocol === 'http')
                         input = {};
-                    for (const arg of selected.args?.params || [])
-                        if (resolved[arg.name] !== undefined)
-                            input[arg.name] = resolved[arg.name];
+                    for (const arg of selected.g?.params || [])
+                        if (resolved[arg.n] !== undefined)
+                            input[arg.n] = resolved[arg.n];
                 }
                 let intendedMark;
                 if (op === 'update') {
-                    for (const spec of step.spec || []) {
-                        if (spec.apply === 'TextFieldMark' && step.input?.textfield) {
-                            const mark = { name: step.input.textfield, value: spec.def.mark + '_' + setup.now };
+                    for (const spec of step.s || []) {
+                        if (spec.apply === 'TextFieldMark' && step.i?.textfield) {
+                            const mark = { name: step.i.textfield, value: spec.def.mark + '_' + setup.now };
                             input[mark.name] = mark.value;
                             intendedMark = mark;
                         }
@@ -127,7 +127,7 @@ async function runLiveEntity(setup, entity, flow, accessor) {
                     });
                     listed.splice(0, listed.length, ...data);
                     context.publish(data);
-                    for (const validation of step.valid || []) {
+                    for (const validation of step.v || []) {
                         const previous = created.get(validation.def?.ref);
                         const id = previous?.[idField] ?? previous?.id;
                         if (undefined === id)

package/project/.sdk/tm/js/test/live-scenarios.js

@@ -64,10 +64,10 @@ async function runLiveScenarios(SDK, plan, envPrefix, liveDefaults = {}) {
                 let input = request.schema ? (0, live_contract_1.synthesizeInput)(request.schema, explicit) : explicit ?? {};
                 for (const kind of ['params', 'query', 'header', 'cookie'])
                     for (const arg of point.args?.[kind] || []) {
-                        if (arg.reqd && input[arg.name] === undefined) {
-                            if (arg.example === undefined)
-                                throw new live_runner_1.LiveBlocked('Missing required argument: ' + arg.name);
-                            input[arg.name] = arg.example;
+                        if (arg.r && input[arg.n] === undefined) {
+                            if (arg.ex === undefined)
+                                throw new live_runner_1.LiveBlocked('Missing required argument: ' + arg.n);
+                            input[arg.n] = arg.ex;
                         }
                     }
                 const role = hint.auth || (point.facts.security?.length === 0 || point.facts.securitySource === 'unspecified' ? 'public' : 'account');

package/project/.sdk/tm/kotlin/feature/TestFeature.kt

@@ -63,12 +63,16 @@ class TestFeature : BaseFeature("test", "0.0.1", true) {
     if (null == data || null == ctx) return data
     val tm = Struct.getprop(ctx.point, "transform")
     val restf = Struct.getprop(tm, "res") as? String ?: return data
-    // Exactly `body.<key>`; a deeper path is not an envelope this mock can
-    // synthesise, so it is left alone rather than guessed at.
+    // Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
+    // GraphQL ops unwrap `body.data.<field>`, not just one envelope property.
     if (!restf.startsWith("`body.") || !restf.endsWith("`") || restf.length < 8) return data
     val inner = restf.substring(6, restf.length - 1)
-    if (inner.isEmpty() || inner.contains(".")) return data
-    return linkedMapOf<String, Any?>(inner to data)
+    if (inner.isEmpty()) return data
+    var out: Any? = data
+    for (seg in inner.split(".").reversed()) {
+      out = linkedMapOf<String, Any?>(seg to out)
+    }
+    return out
   }
 
   private fun respond(ctx: Context?, status: Int, data: Any?, extra: MutableMap<String, Any?>?): MutableMap<String, Any?> {

package/project/.sdk/tm/ocaml/sdk_features.ml

@@ -1394,12 +1394,14 @@ let test_feature () : feature =
       match getp (getp ctx.c_point "transform") "res" with
       | Str spec ->
         let n = String.length spec in
-        (* Exactly `body.<key>`; a deeper path is not an envelope this mock
-           can synthesise, so it is left alone rather than guessed at. *)
+        (* Rebuild whatever nesting the transform unwraps. Multi-segment on
+           purpose: GraphQL ops unwrap `body.data.<field>`. *)
         if n > 7 && String.sub spec 0 6 = "`body." && spec.[n - 1] = '`' then
           let inner = String.sub spec 6 (n - 7) in
-          if String.length inner = 0 || String.contains inner '.' then data
-          else jo [(inner, data)]
+          if String.length inner = 0 then data
+          else
+            List.fold_left (fun out seg -> jo [(seg, out)]) data
+              (List.rev (String.split_on_char '.' inner))
         else data
       | _ -> data in
   let respond ctx status data extra =

package/project/.sdk/tm/perl/feature/test_feature.pm

@@ -66,10 +66,12 @@ sub init {
     my $tm = ProjectNameHelpers::gp($fctx->{point}, 'transform');
     my $spec = ProjectNameHelpers::gp($tm, 'res');
     return $data unless defined $spec && !ref($spec);
-    # Exactly `body.<key>`; a deeper path is not an envelope this mock can
-    # synthesise, so it is left alone rather than guessed at.
-    return $data unless $spec =~ /^`body\.([^`.]+)`$/;
-    return { $1 => $data };
+    # Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
+    # GraphQL ops unwrap `body.data.<field>`, not just one envelope property.
+    return $data unless $spec =~ /^`body\.(.+)`$/;
+    my $out = $data;
+    $out = { $_ => $out } for reverse split /\./, $1, -1;
+    return $out;
   };
 
   my $respond = sub {

package/project/.sdk/tm/rb/feature/test_feature.rb

@@ -4,9 +4,10 @@ require_relative '../utility/struct/voxgig_struct'
 require_relative 'base_feature'
 
 class ProjectNameTestFeature < ProjectNameBaseFeature
-  # The `body.<key>` form of an op's response transform: the mock wraps its
-  # payload in <key> so the transform can unwrap it again.
-  ENVELOPE_RES_RE = /\A`body\.([^`.]+)`\z/
+  # The `body.<path>` form of an op's response transform: the mock rebuilds
+  # whatever nesting the transform unwraps. Multi-segment on purpose: GraphQL
+  # ops unwrap body.data.<field>, not just one level.
+  ENVELOPE_RES_RE = /\A`body\.(.+)`\z/
 
   def initialize
     super
@@ -52,7 +53,8 @@ class ProjectNameTestFeature < ProjectNameBaseFeature
         restf = transform["res"]
         next data unless restf.is_a?(String)
         m = ENVELOPE_RES_RE.match(restf)
-        m.nil? ? data : { m[1] => data }
+        next data if m.nil?
+        m[1].split('.', -1).reverse.reduce(data) { |out, seg| { seg => out } }
       }
 
       respond = ->(status, data, extra) {

package/project/.sdk/tm/rust/core/context.rs

@@ -1,6 +1,3 @@
-// Operation context (mirrors go core/context.go). Fields use interior
-// mutability (RefCell) since the pipeline mutates the context in place;
-// contexts are shared as Rc<Context>.
 
 use std::cell::RefCell;
 use std::collections::HashMap;
@@ -236,8 +233,6 @@ impl Context {
     }
 
     fn resolve_op(&self, opname: &str) -> Rc<Operation> {
-        // Cache key is `<entity>:<opname>` so two entities with the same op
-        // (e.g. both have a "list") get distinct cached Operations.
         let entname = self
             .entity
             .borrow()

package/project/.sdk/tm/rust/core/control.rs

@@ -1,4 +1,3 @@
-// Per-call control state (mirrors go core/control.go).
 
 use crate::core::error::ProjectNameError;
 use crate::utility::voxgigstruct::Value;

package/project/.sdk/tm/rust/core/helpers.rs

@@ -26,28 +26,23 @@ pub fn unsupported_op(opname: &str, entityname: &str) -> ProjectNameError {
     )
 }
 
-/// Property read: `getp(map, "key")` — Noval when absent (mirrors GetProp).
 pub fn getp(val: &Value, key: &str) -> Value {
     vs::get_prop(val, &Value::str(key), Value::Noval)
 }
 
-/// Path read on a Value store.
 pub fn getpath(path: &[&str], store: &Value) -> Value {
     let p = Value::list(path.iter().map(|s| Value::str(*s)).collect());
     vs::get_path(store, &p, None)
 }
 
-/// Property write (no-op when val is not a node).
 pub fn setp(val: &Value, key: &str, newval: Value) {
     vs::set_prop(val.clone(), &Value::str(key), newval);
 }
 
-/// Map literal builder: `jo(vec![("a", v)])`.
 pub fn jo(pairs: Vec<(&str, Value)>) -> Value {
     Value::map_of(pairs.into_iter().map(|(k, v)| (k.to_string(), v)))
 }
 
-/// List literal builder.
 pub fn ja(items: Vec<Value>) -> Value {
     Value::list(items)
 }
@@ -60,7 +55,6 @@ pub fn to_map(v: &Value) -> Value {
     }
 }
 
-/// Go `ToInt`: numeric coercion with -1 default.
 pub fn to_int(v: &Value) -> i64 {
     match v {
         Value::Num(n) => *n as i64,
@@ -96,7 +90,6 @@ pub fn get_f64(m: &Value, key: &str) -> Option<f64> {
     }
 }
 
-/// Wall clock in milliseconds.
 pub fn now_ms() -> i64 {
     SystemTime::now()
         .duration_since(UNIX_EPOCH)
@@ -104,15 +97,12 @@ pub fn now_ms() -> i64 {
         .unwrap_or(0)
 }
 
-/// Real sleep in milliseconds.
 pub fn sleep_ms(ms: i64) {
     if ms > 0 {
         std::thread::sleep(std::time::Duration::from_millis(ms as u64));
     }
 }
 
-// Small thread-local LCG for ids and jitter (std has no rand; determinism
-// is not required here — injectable generators cover the tests).
 thread_local! {
     static RAND_SEED: RefCell<i64> = RefCell::new(
         SystemTime::now()
@@ -122,7 +112,6 @@ thread_local! {
     );
 }
 
-/// Pseudo-random integer in [0, n).
 pub fn rand_int(n: i64) -> i64 {
     if n <= 0 {
         return 0;
@@ -148,7 +137,6 @@ pub fn call_vfn(f: &Value, arg: &Value) -> Value {
     }
 }
 
-/// Wrap a plain single-argument closure as a `Value::Func`.
 pub fn vfn<F>(f: F) -> Value
 where
     F: Fn(&Value) -> Value + 'static,
@@ -156,13 +144,10 @@ where
     Value::func(move |_inj, val, _r, _s| f(val))
 }
 
-/// Call the transport-shaped response `json` entry (a `Value::Func`)
-/// yielding the parsed body.
 pub fn call_json(json: &Value) -> Value {
     call_vfn(json, &Value::Noval)
 }
 
-/// Build a `json` thunk that returns a fixed value.
 pub fn json_thunk(data: Value) -> Value {
     Value::func(move |_i, _v, _r, _s| data.clone())
 }

package/project/.sdk/tm/rust/core/operation.rs

@@ -1,4 +1,3 @@
-// Operation description (mirrors go core/operation.go).
 
 use crate::core::helpers::{get_str, getp, to_map};
 use crate::utility::voxgigstruct::Value;

package/project/.sdk/tm/rust/core/point.rs

@@ -1,6 +1,3 @@
-// Endpoint point description (mirrors go core/target.go NewPoint). Points
-// stay Value maps in the pipeline; this typed view is a convenience for
-// callers that want field access.
 
 use crate::core::helpers::{get_bool, get_str, getp, jo, to_map};
 use crate::utility::voxgigstruct::Value;

package/project/.sdk/tm/rust/core/response.rs

@@ -1,5 +1,3 @@
-// Transport response wrapper (mirrors go core/response.go). The `json`
-// entry stays a Value::Func thunk so bodies can be re-read repeatedly.
 
 use crate::core::error::ProjectNameError;
 use crate::core::helpers::{get_str, getp, to_int};

package/project/.sdk/tm/rust/core/result.rs

@@ -1,4 +1,3 @@
-// Operation result (mirrors go core/result.go).
 
 use std::rc::Rc;
 

package/project/.sdk/tm/rust/core/spec.rs

@@ -1,4 +1,3 @@
-// Request specification (mirrors go core/spec.go).
 
 use crate::core::helpers::{get_str, getp};
 use crate::utility::voxgigstruct::Value;

package/project/.sdk/tm/rust/core/types.rs

@@ -1,4 +1,3 @@
-// Core traits and shared type aliases (mirrors go core/types.go).
 
 use std::cell::RefCell;
 use std::rc::Rc;
@@ -20,7 +19,6 @@ pub trait Feature {
     fn name(&self) -> String;
     fn active(&self) -> bool;
 
-    /// Ordering options consulted by the featureAdd utility. Default: None.
     fn add_options(&self) -> Option<Value> {
         None
     }
@@ -42,11 +40,8 @@ pub trait Feature {
     fn pre_done(&mut self, _ctx: &Rc<Context>) {}
     fn pre_unexpected(&mut self, _ctx: &Rc<Context>) {}
 
-    /// Non-standard hooks (go dispatches these reflectively; rust routes
-    /// unknown hook names here).
     fn custom_hook(&mut self, _name: &str, _ctx: &Rc<Context>) {}
 
-    /// Hook dispatch by name (called by the featureHook utility).
     fn dispatch(&mut self, name: &str, ctx: &Rc<Context>) {
         match name {
             "PostConstruct" => self.post_construct(ctx),
@@ -77,9 +72,6 @@ pub trait Entity {
     fn data(&self, args: Option<&Value>) -> Value;
     fn matchv(&self, args: Option<&Value>) -> Value;
 
-    /// `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);
     fn deleted(&self) -> bool;
 }
@@ -87,16 +79,6 @@ pub trait Entity {
 /// ProjectNameEntity: the full CRUD contract every generated entity
 /// implements. Ops the API spec doesn't define are runtime-error stubs.
 pub trait ProjectNameEntity: Entity + Sized {
-    /// Every operation resolves to the ENTITY, not the raw data — `list` to a
-    /// vector of them, one per record. The record is reached through
-    /// `.data(None)`. See AGENTS.md "Entity operations return ENTITIES".
-    ///
-    /// The receivers are `&Rc<Self>` because the result IS this entity: the
-    /// op absorbs `resdata`/`resmatch` into it and hands the handle back.
-    /// `Value` cannot carry an entity — it is a closed data union
-    /// (Noval|Null|Bool|Num|Str|List|Map|Func|Sentinel) and adding a variant
-    /// to a general-purpose struct library to carry SDK objects would be
-    /// wrong — so the CONTRACT lives in these signatures instead.
     fn load(self: &Rc<Self>, reqmatch: Value, ctrl: Value) -> Result<Rc<Self>, ProjectNameError>;
     fn list(self: &Rc<Self>, reqmatch: Value, ctrl: Value) -> Result<Vec<Rc<Self>>, ProjectNameError>;
     fn create(self: &Rc<Self>, reqdata: Value, ctrl: Value) -> Result<Rc<Self>, ProjectNameError>;
@@ -109,8 +91,6 @@ pub trait ProjectNameEntity: Entity + Sized {
 pub type FetcherFn =
     Rc<dyn Fn(&Rc<Context>, &str, &Value) -> Result<Value, ProjectNameError>>;
 
-/// Pipeline stage products staged on ctx.out (go stores these in the
-/// untyped ctx.Out map; rust keeps them in one typed enum).
 #[derive(Clone)]
 pub enum OutVal {
     Val(Value),

package/project/.sdk/tm/rust/core/utility_type.rs

@@ -1,8 +1,3 @@
-// The Utility bundle (mirrors go core/utility_type.go). Go carries the
-// utilities as swappable function pointers; rust binds them statically and
-// keeps the two members that genuinely vary per client swappable: the
-// transport (`fetcher`, wrapped by features like retry/cache/netsim) and
-// the `custom` map of caller-supplied utility callables.
 
 use std::cell::RefCell;
 use std::rc::Rc;

package/project/.sdk/tm/rust/feature/audit.rs

@@ -1,12 +1,3 @@
-// Audit trail (mirrors go feature/audit_feature.go). Emits a structured
-// record for every operation — who (actor), what (entity + op), the
-// outcome, and a correlation id — suitable for compliance logging. Records
-// accumulate on the feature (bounded by `max`, default 1000) and, when a
-// `sink` callback is supplied, are also pushed to it. The actor is the
-// per-call ctrl actor, falling back to the options `actor`, then
-// "anonymous". Each operation is audited exactly once (the per-context
-// marker in ctx.out prevents a PreDone + PreUnexpected double-log).
-// Timestamps use the injectable `now` clock so tests stay deterministic.
 
 use std::rc::Rc;
 

package/project/.sdk/tm/rust/feature/base.rs

@@ -1,6 +1,3 @@
-// BaseFeature: the no-op feature every hook defaults to (mirrors go
-// feature/base_feature.go). Custom features can embed it for name/active
-// bookkeeping and add_options ordering support.
 
 use crate::core::types::Feature;
 use crate::utility::voxgigstruct::Value;

package/project/.sdk/tm/rust/feature/cache.rs

@@ -1,12 +1,3 @@
-// Response caching for safe (read) requests (mirrors go
-// feature/cache_feature.go). Wraps the active transport and serves a fresh
-// cached snapshot instead of hitting the network when the same method+URL
-// was fetched within `ttl` ms (default: 5000). Only successful (2xx)
-// responses to cacheable methods (default: GET) are stored, keyed by
-// method+URL. The cache is bounded (`max` entries, default 256, oldest
-// evicted first) and every hit/miss/bypass is counted. Bodies are
-// snapshotted on capture so both the current caller and later hits can
-// re-read the JSON body repeatedly.
 
 use std::cell::RefCell;
 use std::collections::HashMap;

package/project/.sdk/tm/rust/feature/clienttrack.rs

@@ -1,10 +1,3 @@
-// Client tracking (mirrors go feature/clienttrack_feature.go). Establishes
-// a stable per-client session id at construction and stamps identifying
-// headers on every request: a `User-Agent` (`<clientName>/<clientVersion>`),
-// an `X-Client-Id` (session), and a fresh per-request `X-Request-Id`.
-// Header names, client name/version and the id generator (`idgen`) are
-// configurable; caller-provided User-Agent / X-Client-Id values are never
-// clobbered.
 
 use std::rc::Rc;
 

package/project/.sdk/tm/rust/feature/cost.rs

@@ -1,26 +1,3 @@
-// Cost tracking and spend budget (mirrors ts
-// src/feature/cost/CostFeature.ts). Uses BOTH seams, which is the point of
-// the feature: money is spent per HTTP ATTEMPT (a retried call is charged
-// again, because the upstream API charges it again), but it is owed by an
-// OPERATION. So the transport wrap prices each attempt, and pre_done
-// attributes the running total to `<entity>.<op>` and to the caller (the
-// per-call ctrl actor, the same actor the audit feature records).
-//
-// The price of an attempt comes from the first source that answers: a
-// response header (`header` x `perUnit`), the rate table (`rates`, keyed
-// `<entity>.<op>` / `<op>` / `*`), then the flat `unit`. A body figure
-// (`path` x `perUnit`, e.g. "usage.total_tokens") is read at pre_done
-// instead, from the already-parsed result, and describes the whole call, so
-// it REPLACES the per-attempt estimate rather than adding to it.
-//
-// `budget` caps total spend. With `onBudget: "deny"` a further operation is
-// refused at pre_point (via ctx.out["point"], which MakePoint surfaces),
-// before an endpoint is resolved and before anything reaches the network.
-//
-// ORDER MATTERS. Cost must sit INSIDE the cache, or a response served from
-// cache is charged for money that was never spent. The default (map) order
-// puts cache innermost and cost outside it, so activate them in list form
-// with cost first.
 
 use std::cell::RefCell;
 use std::collections::HashMap;
@@ -232,14 +209,6 @@ fn charge(
     let attempts = get_f64(&pending, "attempts").unwrap_or(0.0) + 1.0;
     let total = get_f64(&pending, "amount").unwrap_or(0.0) + amount;
 
-    // Reported and estimated are kept apart per ATTEMPT: a 503 priced from the
-    // rate table followed by a 200 carrying the cost header is part estimate,
-    // part reported, and collapsing both into the final attempt's category
-    // would corrupt the split.
-    //
-    // A failed transport is an Err VALUE here, not a panic, so it already
-    // reaches this point and is priced from the table or unit - no separate
-    // catch is needed, unlike the ts/js ports.
     let bucket = if "header" == source || "body" == source { "reported" } else { "estimated" };
     let prev = get_f64(&pending, bucket).unwrap_or(0.0);
     setp(&pending, bucket, Value::Num(prev + amount));
@@ -252,9 +221,6 @@ fn charge(
 
     track.borrow_mut().attempts += 1;
 
-    // direct() and graphql() reach the transport without dispatching any
-    // pipeline hooks, so there is no pre_point to gate on and no pre_done to
-    // commit. Their spend is committed here, or it would never be counted.
     if !piped {
         commit(track, options, ctx, &pending, "_", "direct");
         ctx.out_take(COST_PENDING_KEY);
@@ -278,9 +244,6 @@ fn new_pending() -> Value {
 }
 
 
-// Commit one operation's spend: totals, budget, per-op and per-actor
-// attribution, and the record. Shared by finish and the raw-request path in
-// charge, which has no pre_done to reach.
 fn commit(
     track: &Rc<RefCell<CostTrack>>,
     options: &Value,
@@ -400,8 +363,6 @@ impl Feature for CostFeature {
             (t.limit, t.amount, t.currency.clone())
         };
 
-        // Mark the context as running through the pipeline, so charge knows a
-        // pre_done is coming and does not commit the spend itself.
         let pending = match ctx.out_take(COST_PENDING_KEY) {
             Some(OutVal::Val(v)) if matches!(v, Value::Map(_)) => v,
             other => {
@@ -468,15 +429,6 @@ impl CostFeature {
             }
         };
 
-        // A FAILED operation that made no attempt never reached the network:
-        // PrePoint creates the pending entry to mark the context as piped, and
-        // then the budget gate refuses the call (rbac, or an unresolvable
-        // endpoint, short-circuits just as early). Committing it would count a
-        // call that never happened and file a zero-amount record as `last`.
-        //
-        // A SUCCEEDED operation that made no attempt is the opposite case: it was
-        // served from the cache. That is a real call, and the fact that it cost
-        // nothing is the whole point of ordering cost inside the cache.
         if !done && 0.0 == get_f64(&pending, "attempts").unwrap_or(0.0) {
             return;
         }

package/project/.sdk/tm/rust/feature/debug.rs

@@ -1,10 +1,3 @@
-// Request/response capture for debugging (mirrors go
-// feature/debug_feature.go). Records a bounded ring buffer of
-// per-operation traces — method, URL, redacted headers, response status
-// and timing — on the feature's entries. Sensitive header values (matching
-// `redact`, default authorization/cookie/api-key style names) are masked.
-// An optional `onEntry` callback receives each finished entry. `max` caps
-// the buffer (default 100).
 
 use std::rc::Rc;
 

package/project/.sdk/tm/rust/feature/idempotency.rs

@@ -1,10 +1,3 @@
-// Idempotency keys for mutating operations (mirrors go
-// feature/idempotency_feature.go). Adds an `Idempotency-Key` header (name
-// configurable via `header`) to unsafe requests so a server can
-// de-duplicate retried writes. The key is set once, at PreRequest, before
-// the request is built — so it is stable across transport-level retries of
-// the same call. A caller-supplied header is never overwritten
-// (case-insensitive). The key generator is injectable (`keygen`).
 
 use std::rc::Rc;
 

package/project/.sdk/tm/rust/feature/log.rs

@@ -1,6 +1,3 @@
-// Structured hook logging (mirrors go feature/log_feature.go, using stderr
-// lines instead of slog). Logs every pipeline hook with the operation and
-// spec summary when active; `level` filters (debug < info < warn < error).
 
 use std::rc::Rc;
 

package/project/.sdk/tm/rust/feature/metrics.rs

@@ -1,10 +1,3 @@
-// Statistics capture (mirrors go feature/metrics_feature.go). Records
-// per-operation counters and latency for every call: totals plus a
-// breakdown keyed by `<entity>.<op>`. Timing starts at endpoint resolution
-// (PrePoint) and stops when the call returns (PreDone) or fails
-// (PreUnexpected); each operation is recorded exactly once (the
-// per-context start marker in ctx.out is consumed on record). The clock is
-// injectable (`now`) for deterministic tests.
 
 use std::collections::HashMap;
 use std::rc::Rc;

package/project/.sdk/tm/rust/feature/netsim.rs

@@ -1,12 +1,3 @@
-// Network behaviour simulation (mirrors go feature/netsim_feature.go).
-// Wraps the active transport (the live ureq fetch or the `test` feature's
-// in-memory mock) and injects realistic network conditions so offline unit
-// tests can exercise slowness, transient failures, rate limiting and
-// outages deterministically.
-//
-// Every injection mode is counter-driven (per client instance) so tests
-// are reproducible without mocking timers. `failRate` adds optional
-// pseudo-random failures via a seeded LCG for coverage-style testing.
 
 use std::cell::RefCell;
 use std::rc::Rc;