@voxgig/sdkgen 4.21.0 → 4.23.0

package/project/.sdk/tm/rust/utility/voxgigstruct/consts.rs

@@ -27,7 +27,6 @@ pub const S_DTOP: &str = "$TOP";
 pub const S_DERRS: &str = "$ERRS";
 pub const S_DSPEC: &str = "$SPEC";
 
-// general
 pub const S_base: &str = "base";
 pub const S_key: &str = "key";
 pub const S_nil: &str = "nil";
@@ -37,7 +36,6 @@ pub const S_object: &str = "object";
 pub const S_list: &str = "list";
 pub const S_map: &str = "map";
 
-// chars
 pub const S_BT: &str = "`";
 pub const S_CN: &str = ":";
 pub const S_DS: &str = "$";
@@ -49,9 +47,7 @@ pub const S_SP: &str = " ";
 pub const S_CM: &str = ",";
 pub const S_VIZ: &str = ": ";
 
-// ---- type bit codes (u32) ---------------------------------------------
-// let t = 31; T_any = (1<<t--)-1; ... (see StructUtility.ts).
-pub const T_ANY: u32 = (1u32 << 31) - 1; // 0x7FFF_FFFF
+pub const T_ANY: u32 = (1u32 << 31) - 1;
 pub const T_NOVAL: u32 = 1 << 30; // property absent, undefined. NOT a scalar.
 pub const T_BOOLEAN: u32 = 1 << 29;
 pub const T_DECIMAL: u32 = 1 << 28;
@@ -65,29 +61,27 @@ pub const T_NULL: u32 = 1 << 22; // the actual JSON null value.
 pub const T_LIST: u32 = 1 << 14;
 pub const T_MAP: u32 = 1 << 13;
 pub const T_INSTANCE: u32 = 1 << 12;
-// t -= 4  => t = 7
 pub const T_SCALAR: u32 = 1 << 7;
 pub const T_NODE: u32 = 1 << 6;
 
-// TYPENAME indexed by Math.clz32(t). 26 entries (0..=25).
 pub const TYPENAME: [&str; 26] = [
-    "any",      // 0
+    "any",
     "nil",      // 1   clz32(T_noval=1<<30)
-    "boolean",  // 2   clz32(1<<29)
-    "decimal",  // 3   clz32(1<<28)
-    "integer",  // 4   clz32(1<<27)
-    "number",   // 5   clz32(1<<26)
-    "string",   // 6   clz32(1<<25)
-    "function", // 7   clz32(1<<24)
-    "symbol",   // 8   clz32(1<<23)
-    "null",     // 9   clz32(1<<22)
-    "", "", "", "", "", "", "",         // 10..=16
+    "boolean",
+    "decimal",
+    "integer",
+    "number",
+    "string",
+    "function",
+    "symbol",
+    "null",
+    "", "", "", "", "", "", "",
     "list",     // 17  clz32(1<<14)
     "map",      // 18  clz32(1<<13)
     "instance", // 19  clz32(1<<12)
-    "", "", "", "",       // 20..=23
-    "scalar", // 24  clz32(1<<7)
-    "node",   // 25  clz32(1<<6)
+    "", "", "", "",
+    "scalar",
+    "node",
 ];
 
 pub const MAXDEPTH: i64 = 32;

package/project/.sdk/tm/rust/utility/voxgigstruct/major.rs

@@ -626,7 +626,6 @@ pub fn get_path_inj(store: &Value, path: &Value, injdef: Option<&Inj>) -> Value
                         if ascends == 0 {
                             val = dparent.clone();
                         } else {
-                            // fullpath = slice(dpath, -ascends) ++ parts[p_i+1..]
                             let head = slice(
                                 Value::list(dpath.iter().cloned().map(Value::Str).collect()),
                                 Some(-ascends),
@@ -738,13 +737,7 @@ pub fn set_path(store: &Value, path: &Value, val: Value, injdef: Option<&InjectD
     parent
 }
 
-// ---------------------------------------------------------------------
-// inject / transform / validate / select — staged (see rs/PLAN.md, NOTES.md)
-// ---------------------------------------------------------------------
 
-/// Default inject handler (`_injecthandler`): if the value is a `$NAME`
-/// command function, call it; otherwise, in `val` mode for a full-string
-/// injection, write the value back into the parent.
 pub fn inject_handler_fn() -> NativeFn {
     Rc::new(inject_handler)
 }
@@ -766,7 +759,6 @@ fn inject_handler(inj: &Inj, val: &Value, r: &str, store: &Value) -> Value {
     val.clone()
 }
 
-/// `_injectstr` — substitute `` `path` `` references inside a string.
 fn injectstr(val: &str, store: &Value, inj: Option<&Inj>) -> Value {
     if val.is_empty() {
         return Value::str("");
@@ -1330,7 +1322,6 @@ fn transform_ref(inj: &Inj, val: &Value, _r: &str, store: &Value) -> Value {
         let keylen = inj.borrow().keys.borrow().len() as i64;
         inj.borrow_mut().key_i = keylen;
     }
-    // spec = ($SPEC)()
     let spec = {
         let sf = get_prop(store, &Value::str(S_DSPEC), Value::Noval);
         match &sf {
@@ -1816,7 +1807,6 @@ fn iso_now() -> String {
         .unwrap_or_default();
     let secs = dur.as_secs() as i64;
     let millis = dur.subsec_millis();
-    // days since 1970-01-01
     let days = secs.div_euclid(86_400);
     let tod = secs.rem_euclid(86_400);
     let (h, m, s) = (tod / 3600, (tod % 3600) / 60, tod % 60);
@@ -2169,8 +2159,6 @@ fn validate_exact(inj: &Inj, _v: &Value, _r: &str, _store: &Value) -> Value {
     Value::Noval
 }
 
-/// `_validation` — the modify hook installed by `validate` (runs after the
-/// per-key special commands).
 fn validation_modify(pval: &Value, key: &Value, parent: &Value, inj: &Inj, _store: &Value) {
     if pval.is_skip() {
         return;
@@ -2278,7 +2266,6 @@ fn validation_modify(pval: &Value, key: &Value, parent: &Value, inj: &Inj, _stor
     }
 }
 
-/// `_validatehandler` — `getpath`/`_injectstr` handler installed by `validate`.
 fn validatehandler(inj: &Inj, val: &Value, r: &str, store: &Value) -> Value {
     if let Some(caps) = R_META_PATH.captures(r) {
         if &caps[2] == "=" {

package/project/.sdk/tm/rust/utility/voxgigstruct/mini.rs

@@ -92,8 +92,6 @@ pub fn is_func(val: &Value) -> bool {
     matches!(val, Value::Func(_))
 }
 
-/// `size(val)` — length for lists/strings, key count for maps, integer
-/// part for numbers, 1/0 for booleans, 0 otherwise.
 pub fn size(val: &Value) -> i64 {
     match val {
         Value::List(l) => l.borrow().len() as i64,
@@ -170,7 +168,6 @@ pub fn slice(val: Value, start: Option<i64>, end: Option<i64>, mutate: bool) ->
                     }
                 }
                 Value::Str(st) => {
-                    // substring by UTF-16 units to match JS .substring
                     let units: Vec<u16> = st.encode_utf16().collect();
                     let sub: Vec<u16> = units[s as usize..e as usize].to_vec();
                     return Value::Str(String::from_utf16_lossy(&sub));
@@ -320,12 +317,6 @@ pub fn get_prop(val: &Value, key: &Value, alt: Value) -> Value {
     }
 }
 
-/// Internal raw lookup that PRESERVES a stored JSON null (Group B). Mirrors the
-/// canonical TS `_lookup` (StructUtility.ts:477): Group B callers — validate /
-/// transform commands / builders / inject internals — use this when they need
-/// the raw stored value at a slot regardless of whether it is null. The public
-/// `get_prop` / `get_elem` / `has_key` APIs treat null as absent (Group A) per
-/// UNDEF_SPEC.md. Returns `Noval` only when the key is genuinely absent.
 pub fn lookup(val: &Value, key: &Value) -> Value {
     if val.is_noval() || key.is_noval() {
         return Value::Noval;
@@ -523,7 +514,6 @@ pub fn re_find_all(pattern: &str, input: &str) -> Vec<Vec<String>> {
         .collect()
 }
 
-/// Replace every match. Supports `$&` (whole match) and `$1`..`$9` (captures).
 pub fn re_replace(pattern: &str, input: &str, replacement: &str) -> String {
     let re = match Regex::new(pattern) {
         Ok(r) => r,
@@ -826,10 +816,6 @@ pub fn stringify(val: &Value, maxlen: Option<i64>, pretty: bool) -> String {
     valstr
 }
 
-/// Compact JSON with object keys sorted (used by `stringify`). Functions and
-/// `undefined` map values are dropped. Cycles are not detected -> caller maps
-/// the failure to `__STRINGIFY_FAILED__` only if recursion overflows (which
-/// would actually panic); we approximate with a depth guard.
 fn human_json(val: &Value) -> Option<String> {
     human_json_depth(val, 0)
 }

package/project/.sdk/tm/rust/utility/voxgigstruct/mod.rs

@@ -53,8 +53,6 @@ impl std::fmt::Display for StructError {
 
 impl std::error::Error for StructError {}
 
-/// Bundle of all functions, mirroring the TS `StructUtility` class. Useful
-/// for the test harness (which looks subjects up by name).
 pub struct StructUtility;
 
 impl StructUtility {

package/project/.sdk/tm/rust/utility/voxgigstruct/ordered_map.rs

@@ -1,21 +1,3 @@
-// Minimal in-tree insertion-ordered map.
-//
-// Rust's `std::collections::HashMap` doesn't preserve insertion order, and
-// the canonical contract requires that JSON object key order survive every
-// operation. Other ports either get this for free (Python 3.7+ dict,
-// Ruby Hash, PHP array, JS object), or hand-roll an OrderedMap
-// (C / C++ / Zig). This is the Rust equivalent — keeps the port
-// dependency-free.
-//
-// Only the operations the rest of voxgig-struct uses are implemented:
-// `new`, `insert`, `get`, `contains_key`, `shift_remove`, `iter`,
-// `iter_mut`, `keys`, `values`, `len`, `is_empty`, indexing by `&str`,
-// `Clone`, `IntoIterator` and `FromIterator`.
-//
-// Parallel keys + values vectors preserve insertion order; a separate
-// `HashMap<String, usize>` indexes key -> position for O(1) lookup.
-// `shift_remove` is O(n) on a vec-shift plus an O(n) index rebuild; the
-// corpus's map sizes are modest so this is the right complexity trade.
 
 use std::collections::HashMap;
 use std::ops::Index;

package/project/.sdk/tm/rust/utility/voxgigstruct/re.rs

@@ -294,7 +294,6 @@ impl<'a> Parser<'a> {
                 && self.src[self.pos + 1] == b'P'
                 && self.src[self.pos + 2] == b'<'
             {
-                // Named group — consume name; we don't expose names but still capture.
                 self.pos += 3;
                 while self.pos < self.src.len() && self.src[self.pos] != b'>' {
                     self.pos += 1;
@@ -431,7 +430,6 @@ impl<'a> Parser<'a> {
                 // L0: SPLIT L1 L2; atom; JMP L0; L2:
                 self.code.insert(start, Insn::new(Op::Split(0, 0)));
                 self.shift_targets_after(start, 1);
-                // We've inserted one before start; compute after the atom (now end+1).
                 let after_atom = self.code.len(); // before JMP emit
                 self.emit(Op::Jmp(start as i32));
                 let exit = self.code.len();
@@ -452,7 +450,6 @@ impl<'a> Parser<'a> {
                 );
             }
             b'{' => {
-                // Emit n_lo mandatory copies (we already have one — the original atom).
                 for _ in 1..n_lo {
                     self.code_clone(start, end);
                 }
@@ -852,14 +849,6 @@ impl ThreadList {
     }
 
     fn add(&mut self, re: &Regex, input: &[u8], pc: usize, slots: &[i32], sp: usize) {
-        // Iterative epsilon-closure: we walk Jmp/Split/Save/Bol/Eol/Wb/Nwb
-        // until we hit a char-consuming op or Match. A recursive version
-        // overflows the stack on long Thompson chains (e.g. `a{0,10000}`
-        // unrolls into 10000 chained Splits — `cargo test` aborted with
-        // SIGABRT on the pathological-regex panel before this loop landed).
-        //
-        // The stack mirrors the recursive order: Split pushes y first then
-        // x, so x is processed first (priority preserved).
         let mut stack: Vec<(usize, Vec<i32>)> = vec![(pc, slots.to_vec())];
         while let Some((cur_pc, cur_slots)) = stack.pop() {
             if cur_pc >= re.code.len() {

package/project/.sdk/tm/rust/utility/voxgigstruct/value.rs

@@ -173,9 +173,6 @@ impl Value {
     }
 }
 
-// Deep, order-independent (for maps) equality — matches `deepStrictEqual`
-// semantics used by the corpus runner and the JSON-string fallback used by
-// `validate_EXACT`. Functions are never equal (pointer-eq would also do).
 impl PartialEq for Value {
     fn eq(&self, other: &Value) -> bool {
         match (self, other) {

package/project/.sdk/tm/scala/feature/TestFeature.scala

@@ -50,14 +50,18 @@ class TestFeature extends BaseFeature("test", "0.0.1", true) {
     val tm = Struct.getprop(ctx.point, "transform")
     Struct.getprop(tm, "res") match {
       case spec: String =>
-        // 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 (!spec.startsWith("`body.") || !spec.endsWith("`") || spec.length < 8) return data
         val inner = spec.substring(6, spec.length - 1)
-        if (inner.isEmpty || inner.contains(".")) return data
-        val wrapped = new java.util.LinkedHashMap[String, Object]()
-        wrapped.put(inner, data)
-        wrapped
+        if (inner.isEmpty) return data
+        var out: Object = data
+        for (seg <- inner.split("\\.", -1).reverse) {
+          val wrapped = new java.util.LinkedHashMap[String, Object]()
+          wrapped.put(seg, out)
+          out = wrapped
+        }
+        out
       case _ => data
     }
   }

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/feature/TestFeature.swift

@@ -16,14 +16,18 @@ private func testEnvelope(_ ctx: Context, _ data: Value) -> Value {
   guard let point = ctx.point else { return data }
   guard case .map(let tm)? = point.entries["transform"] else { return data }
   guard case .string(let spec)? = tm.entries["res"] else { 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.
   guard spec.hasPrefix("`body."), spec.hasSuffix("`"), spec.count >= 8 else { return data }
   let inner = String(spec.dropFirst(6).dropLast(1))
-  guard !inner.isEmpty, !inner.contains(".") else { return data }
-  let wrapped = VMap()
-  wrapped.entries[inner] = data
-  return .map(wrapped)
+  guard !inner.isEmpty else { return data }
+  var out = data
+  for seg in inner.split(separator: ".", omittingEmptySubsequences: false).reversed() {
+    let wrapped = VMap()
+    wrapped.entries[String(seg)] = out
+    out = .map(wrapped)
+  }
+  return out
 }
 
 private func testRespond(_ ctx: Context, _ status: Int, _ data: Value, _ extra: VMap?) -> Value {

package/project/.sdk/tm/ts/src/Context.ts

@@ -13,7 +13,6 @@ import { Result } from './Result'
 import { Spec } from './Spec'
 
 
-// TODO: move to own file
 class Context {
 
   id = 'C' + ('' + Math.random()).substring(2, 10)
@@ -86,10 +85,6 @@ class Context {
 
 
   resolveOp(opname: string): Operation {
-    // Cache key is `<entity>:<opname>` so two entities with the same op
-    // (e.g. both have a "list") get distinct cached Operations. Keying on
-    // opname alone caused the first-resolved entity's points to be served
-    // to every subsequent entity's call.
     const entname = getprop(this.entity, 'name', '')
     const cacheKey = entname + ':' + opname
     let op: Operation = getprop(this.opmap, cacheKey)

package/project/.sdk/tm/ts/src/feature/audit/AuditFeature.ts

@@ -5,13 +5,6 @@ import type { ProjectNameSDK } from '../../ProjectNameSDK'
 import { BaseFeature } from '../base/BaseFeature'
 
 
-// Audit trail. 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 `client._audit.records`
-// (bounded by `max`) and, when a `sink` callback is supplied, are also
-// pushed to it (e.g. to forward to a SIEM). The actor is taken from options
-// (`actor`) or a per-call `ctrl.actor`. Timestamps use the injectable
-// `now` clock so tests stay deterministic.
 class AuditFeature extends BaseFeature {
   version = '0.0.1'
   name = 'audit'

package/project/.sdk/tm/ts/src/feature/cache/CacheFeature.ts

@@ -5,14 +5,6 @@ import type { ProjectNameSDK } from '../../ProjectNameSDK'
 import { BaseFeature } from '../base/BaseFeature'
 
 
-// Response caching for safe (read) requests. 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. Only successful responses to
-// cacheable methods (default: GET) are stored, keyed by method+URL. The
-// cache is bounded (`max` entries, oldest evicted) and every hit/miss is
-// recorded on `client._cache` for inspection. One-shot response bodies are
-// normalised on capture so both the current caller and later hits can read
-// the JSON body repeatedly.
 class CacheFeature extends BaseFeature {
   version = '0.0.1'
   name = 'cache'

package/project/.sdk/tm/ts/src/feature/clienttrack/ClienttrackFeature.ts

@@ -5,13 +5,6 @@ import type { ProjectNameSDK } from '../../ProjectNameSDK'
 import { BaseFeature } from '../base/BaseFeature'
 
 
-// Client tracking. Establishes a stable per-client session id at
-// construction and stamps identifying headers on every request: a
-// `User-Agent`, an `X-Client-Id` (session), and a fresh per-request
-// `X-Request-Id`. This lets a server correlate all traffic from one SDK
-// instance and each individual call. Header names, client name/version and
-// the id generator are configurable; the session id and request counter are
-// exposed on `client._clienttrack`.
 class ClienttrackFeature extends BaseFeature {
   version = '0.0.1'
   name = 'clienttrack'

package/project/.sdk/tm/ts/src/feature/cost/CostFeature.ts

@@ -5,30 +5,6 @@ import type { ProjectNameSDK } from '../../ProjectNameSDK'
 import { BaseFeature } from '../base/BaseFeature'
 
 
-// Cost tracking and spend budget. 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 PreDone
-// attributes the running total to `<entity>.<op>` and to the caller
-// (`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 PreDone
-// instead, from the already-parsed result: the response body is a one-shot
-// stream, and consuming it at the transport seam would leave the pipeline
-// with nothing. A body figure 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 PrePoint, 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 array form
-// with cost first: [{ name: 'cost' }, { name: 'cache' }].
 class CostFeature extends BaseFeature {
   version = '0.0.1'
   name = 'cost'
@@ -81,8 +57,6 @@ class CostFeature extends BaseFeature {
       return
     }
 
-    // Mark the context as running through the pipeline, so _charge knows a
-    // PreDone is coming and does not commit the spend itself.
     let pending = this._pending.get(ctx)
     if (null == pending) {
       pending = this._newPending()
@@ -144,15 +118,6 @@ class CostFeature extends BaseFeature {
 
     pending.attempts++
 
-    // Accumulated here, committed once at PreDone. Adding each attempt to
-    // the running total and then subtracting it again when a body figure
-    // supersedes it loses precision to catastrophic cancellation
-    // (5 + (0.01 - 5) is not 0.01 in binary floating point).
-    //
-    // Reported and estimated are kept apart per ATTEMPT, not per operation:
-    // 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.
     pending.amount += priced.amount
     pending[('header' === priced.source || 'body' === priced.source) ?
       'reported' : 'estimated'] += priced.amount
@@ -160,11 +125,6 @@ class CostFeature extends BaseFeature {
 
     cost.total.attempts++
 
-    // direct() and graphql() call the transport through _rawRequest, which
-    // dispatches no pipeline hooks at all — no PrePoint to gate on, and no
-    // PreDone to commit. Their spend is committed here instead, or it would
-    // never be counted and could run past an onBudget: 'deny' ceiling
-    // indefinitely. `piped` is set by PrePoint, so its absence is the signal.
     if (!pending.piped) {
       this._commit(ctx, pending, '_', 'direct')
       this._pending.delete(ctx)
@@ -209,15 +169,6 @@ class CostFeature extends BaseFeature {
     }
     this._pending.delete(ctx)
 
-    // 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 === pending.attempts) {
       return
     }
@@ -229,9 +180,6 @@ class CostFeature extends BaseFeature {
   }
 
 
-  // Commit one operation's spend: totals, budget, per-op and per-actor
-  // attribution, and the record. Shared by PreDone and the raw-request path
-  // in _charge, which has no PreDone to reach.
   _commit(this: any, ctx: any, pending: any, entity: string, opname: string) {
     const client: any = this._client
     const cost = client._cost

package/project/.sdk/tm/ts/src/feature/debug/DebugFeature.ts

@@ -5,12 +5,6 @@ import type { ProjectNameSDK } from '../../ProjectNameSDK'
 import { BaseFeature } from '../base/BaseFeature'
 
 
-// Request/response capture for debugging. Records a bounded ring buffer of
-// per-operation traces — method, URL, redacted headers, response status and
-// timing — on `client._debug.entries`. Sensitive header values (matching
-// `redact`, default authorization/cookie/api-key style names) are masked.
-// An optional `onEntry` callback receives each finished entry (e.g. to
-// stream to a console). `max` caps the buffer (default 100).
 class DebugFeature extends BaseFeature {
   version = '0.0.1'
   name = 'debug'

package/project/.sdk/tm/ts/src/feature/metrics/MetricsFeature.ts

@@ -5,12 +5,6 @@ import type { ProjectNameSDK } from '../../ProjectNameSDK'
 import { BaseFeature } from '../base/BaseFeature'
 
 
-// Statistics capture. 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 throws (PreUnexpected). Aggregates live on `client._metrics` and can be
-// read via `client.metrics()` in the generated SDK. The clock is injectable
-// (`now`) for deterministic tests.
 class MetricsFeature extends BaseFeature {
   version = '0.0.1'
   name = 'metrics'

package/project/.sdk/tm/ts/src/feature/netsim/NetsimFeature.ts

@@ -5,14 +5,6 @@ import type { ProjectNameSDK } from '../../ProjectNameSDK'
 import { BaseFeature } from '../base/BaseFeature'
 
 
-// Network behaviour simulation. Wraps the active transport (the live
-// `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.
 class NetsimFeature extends BaseFeature {
   version = '0.0.1'
   name = 'netsim'

package/project/.sdk/tm/ts/src/feature/paging/PagingFeature.ts

@@ -5,14 +5,6 @@ import type { ProjectNameSDK } from '../../ProjectNameSDK'
 import { BaseFeature } from '../base/BaseFeature'
 
 
-// Pagination support for list operations. On the way out (PreRequest) it
-// stamps page/limit (or a cursor) into the request query; on the way back
-// (PreResult) it reads the server's pagination signals — a `Link:
-// rel="next"` header, `X-Next-Page`/`X-Total-Count` headers, or `next`/
-// `cursor`/`hasMore` fields in the body — and records them on
-// `ctx.result.paging`. Generated SDKs build auto-iteration on top of this
-// (advance the cursor/page and re-issue the list call until `hasMore` is
-// false). Parameter names and page size are configurable.
 class PagingFeature extends BaseFeature {
   version = '0.0.1'
   name = 'paging'
@@ -45,7 +37,6 @@ class PagingFeature extends BaseFeature {
     const limitParam = this._options.limitParam || 'limit'
     const cursorParam = this._options.cursorParam || 'cursor'
 
-    // A per-call cursor/page from ctrl takes priority (used by auto-iteration).
     const paging = (ctx.ctrl && ctx.ctrl.paging) || {}
 
     // GraphQL paginates through operation VARIABLES, not the query string.
@@ -94,7 +85,6 @@ class PagingFeature extends BaseFeature {
       hasMore: false,
     }
 
-    // Link: <...>; rel="next"
     const link = this._header(headers, 'link')
     if (null != link) {
       const m = /<([^>]+)>\s*;\s*rel="?next"?/i.exec(link)
@@ -126,7 +116,6 @@ class PagingFeature extends BaseFeature {
       }
     }
 
-    // Body-level cursors.
     if (body && 'object' === typeof body) {
       if (null != body.next) { paging.next = paging.next || body.next }
       if (null != body.cursor) { paging.cursor = body.cursor }
@@ -171,8 +160,6 @@ class PagingFeature extends BaseFeature {
     const afterVar = this._options.afterVar || 'after'
     const firstVar = this._options.firstVar || 'first'
 
-    // Only bind variables the operation actually declares, or the server
-    // rejects the document.
     const declared: Record<string, boolean> = {}
     for (const v of ((point.graphql && point.graphql.vars) || [])) {
       declared[v.name] = true

package/project/.sdk/tm/ts/src/feature/proxy/ProxyFeature.ts

@@ -5,14 +5,6 @@ import type { ProjectNameSDK } from '../../ProjectNameSDK'
 import { BaseFeature } from '../base/BaseFeature'
 
 
-// Outbound HTTP(S) proxy support. Wraps the active transport and attaches
-// proxy routing to each request's fetch definition. The proxy target comes
-// from options (`url`) or, when `fromEnv` is set, the standard
-// HTTPS_PROXY / HTTP_PROXY / NO_PROXY environment variables. Constructing a
-// concrete agent/dispatcher is dependency-specific, so a factory may be
-// supplied via `options.agent` (e.g. wrapping undici's ProxyAgent); when
-// absent the request is annotated with `fetchdef.proxy` for the transport
-// to honour. Hosts matching `noProxy` bypass the proxy.
 class ProxyFeature extends BaseFeature {
   version = '0.0.1'
   name = 'proxy'

package/project/.sdk/tm/ts/src/feature/ratelimit/RatelimitFeature.ts

@@ -5,12 +5,6 @@ import type { ProjectNameSDK } from '../../ProjectNameSDK'
 import { BaseFeature } from '../base/BaseFeature'
 
 
-// Client-side rate limiting via a token bucket. Each request consumes a
-// token; when the bucket is empty the request waits until the bucket
-// refills at `rate` tokens per second (with capacity `burst`). This keeps
-// the client under a server's published quota rather than discovering it
-// via 429s. The clock (`now`) and the wait (`sleep`) are injectable so the
-// accounting can be tested deterministically without wall-clock timing.
 class RatelimitFeature extends BaseFeature {
   version = '0.0.1'
   name = 'ratelimit'

package/project/.sdk/tm/ts/src/feature/rbac/RbacFeature.ts

@@ -5,14 +5,6 @@ import type { ProjectNameSDK } from '../../ProjectNameSDK'
 import { BaseFeature } from '../base/BaseFeature'
 
 
-// Client-side role/permission enforcement. Before an operation resolves its
-// endpoint, the required permission for that entity+operation is checked
-// against the permissions the client holds; a disallowed call is
-// short-circuited with an `rbac_denied` error and never touches the
-// network. Required permissions come from `rules` (keyed by
-// `<entity>.<op>`, `<op>`, or `*`); the default when no rule matches is
-// controlled by `deny` (default: allow when unspecified). Held permissions
-// are the `permissions` list (a `*` grants everything).
 class RbacFeature extends BaseFeature {
   version = '0.0.1'
   name = 'rbac'
@@ -43,7 +35,6 @@ class RbacFeature extends BaseFeature {
 
     const required = this._required(ctx)
     if (null == required) {
-      // No rule: honour the default policy.
       if (true === this._options.deny) {
         return this._reject(ctx, '<default-deny>')
       }

package/project/.sdk/tm/ts/src/feature/retry/RetryFeature.ts

@@ -5,12 +5,6 @@ import type { ProjectNameSDK } from '../../ProjectNameSDK'
 import { BaseFeature } from '../base/BaseFeature'
 
 
-// Automatic retry of transient failures with exponential backoff and
-// jitter. Wraps the active transport so a single operation call may make
-// several HTTP attempts. A failure is retryable when the transport throws
-// / returns an Error, or responds with a status in `statuses`
-// (default: 408, 425, 429, 500, 502, 503, 504). An HTTP 429/503 with a
-// `Retry-After` header overrides the computed backoff.
 class RetryFeature extends BaseFeature {
   version = '0.0.1'
   name = 'retry'