@voxgig/sdkgen 4.21.0 → 4.22.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,17 +56,6 @@ pub fn make_options_util(ctx: &Rc<Context>) -> Value {
         _ => Value::empty_map(),
     };
 
-    // THE OPTION SPEC IS GENERATED, NOT WRITTEN HERE.
-    //
-    // Built from the model: `main.kit.optspec` for the standard options, plus
-    // one entry per feature this target carries, from that feature's own
-    // `config.options` / `config.optspec`. Editing this file to add an option
-    // would put it back where it was - one of twenty hand-maintained copies of
-    // a schema nothing cross-checked - so add it to the model instead and
-    // every ported target validates it.
-    //
-    // Parsed once per thread and shared: make_options validates AGAINST the
-    // spec and writes into the options, never into the spec.
     let optspec = crate::core::schema::optspec();
 
     // Preserve system.fetch before merge/validate (validation strips it).
@@ -106,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))
@@ -174,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 {
@@ -184,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(),
@@ -214,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

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

@@ -15,12 +15,6 @@ fn parts_len(point: &Value) -> usize {
     }
 }
 
-// Does this point's path end in a parameter? A record route ends in the
-// record's identifier (/boards/{id}); a cross-reference that also returns
-// the entity ends in the relationship's name (/posts/{id}/author). That,
-// then fewest segments, is what tells the entity's own route from a
-// cross-reference. The same rule runs at generation time, in
-// helpers/opShape.ts — both sides must move together.
 fn terminal_param(point: &Value) -> bool {
     match getp(point, "parts") {
         Value::List(l) => {
@@ -127,12 +121,6 @@ pub fn make_point_util(ctx: &Rc<Context>) -> Result<Value, ProjectNameError> {
         // so nothing matches — fall back to the entity's own route rather
         // than whichever point came last.
         if !matched {
-            // A request naming an action reaches here only because that
-            // action's own point failed its exist test, so it is unbuildable
-            // whatever we pick. Refuse it BEFORE choosing a fallback: the
-            // guard below compares the chosen point's $action and would wave
-            // the request through whenever the fallback lands on the action
-            // point itself.
             let unmatched_action = getp(&reqselector, "$action");
             if !unmatched_action.is_noval() {
                 return Err(ctx.make_error(

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

@@ -65,10 +65,6 @@ pub fn make_spec_util(ctx: &Rc<Context>) -> Result<Rc<RefCell<Spec>>, ProjectNam
     };
 
     if "graphql" == kind {
-        // GraphQL addresses one endpoint: no path parts, no query string,
-        // and the body carries the operation. prepare_body is skipped
-        // deliberately — it only emits a body for data-input ops, whereas
-        // every GraphQL op posts one, including load/list/remove.
         let body = crate::utility::graphql::graphql_body_util(ctx);
         spec.borrow_mut().body = body;
         spec.borrow_mut().path = String::new();

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/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'