@voxgig/sdkgen 4.21.0 → 4.23.0

package/project/.sdk/tm/csharp/feature/TestFeature.cs

@@ -59,15 +59,21 @@ public class TestFeature : BaseFeature
                 if (data == null || ctx2.Point == null) { return data; }
                 var tm = StructUtils.GetProp(ctx2.Point, "transform");
                 if (StructUtils.GetProp(tm, "res") is not string spec) { return data; }
-                // Exactly `body.<key>`; a deeper path is not an envelope this
-                // mock can synthesise, so it is left alone.
+                // 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;
                 }
                 var inner = spec.Substring(6, spec.Length - 7);
-                if (inner.Length == 0 || inner.Contains('.')) { return data; }
-                return new Dictionary<string, object?> { [inner] = data };
+                if (inner.Length == 0) { return data; }
+                var segs = inner.Split('.');
+                object? built = data;
+                for (var i = segs.Length - 1; 0 <= i; i--)
+                {
+                    built = new Dictionary<string, object?> { [segs[i]] = built };
+                }
+                return built;
             }
 
             Dictionary<string, object?> Respond(int status, object? data,

package/project/.sdk/tm/elixir/lib/projectname/feature/test.ex

@@ -55,16 +55,22 @@ defmodule ProjectName.Feature.Test do
   defp envelope(fctx, data) do
     spec = S.getprop(S.getprop(S.getprop(fctx, "point"), "transform"), "res")
 
-    # 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.
     case {data, spec} do
       {nil, _} ->
         data
 
       {_, s} when is_binary(s) ->
-        case Regex.run(~r/^`body\.([^`.]+)`$/, s) do
-          [_, inner] -> S.jm([inner, data])
-          _ -> data
+        case Regex.run(~r/^`body\.(.+)`$/, s) do
+          [_, inner] ->
+            inner
+            |> String.split(".")
+            |> Enum.reverse()
+            |> Enum.reduce(data, fn seg, out -> S.jm([seg, out]) end)
+
+          _ ->
+            data
         end
 
       _ ->

package/project/.sdk/tm/go/core/context.go

@@ -21,11 +21,6 @@ type Context struct {
 	Entopts map[string]any
 	Options map[string]any
 	Opmap   map[string]*Operation
-	// Opmu guards Opmap. The map is a CACHE shared by inheritance across
-	// every context derived from the same root (see the Opmap block in
-	// NewContext), so two entity operations running on separate
-	// goroutines otherwise race resolveOp's read-then-write - the mutex
-	// travels WITH the map, inherited from the same base context.
 	Opmu     *sync.Mutex
 	Response *Response
 	Result   *Result
@@ -238,10 +233,6 @@ func NewContext(ctxmap map[string]any, basectx *Context) *Context {
 }
 
 func (ctx *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.
 	entname := ""
 	if ctx.Entity != nil {
 		entname = ctx.Entity.GetName()

package/project/.sdk/tm/go/core/types.go

@@ -29,9 +29,6 @@ type Entity interface {
 	Data(data ...any) any
 	Match(match ...any) any
 
-	// Every operation resolves to the entity; Remove additionally marks it.
-	// The instance keeps the data it held — a caller can still read what was
-	// deleted — but it is no longer a live record.
 	MarkDeleted()
 	Deleted() bool
 }

package/project/.sdk/tm/go/feature/audit_feature.go

@@ -4,15 +4,6 @@ import (
 	"GOMODULE/core"
 )
 
-// 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 the feature (bounded by `max`,
-// default 1000) and, when a `sink` callback is supplied, are also pushed to
-// it (e.g. to forward to a SIEM). 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.
 type AuditFeature struct {
 	BaseFeature
 	client  *core.ProjectNameSDK

package/project/.sdk/tm/go/feature/cache_feature.go

@@ -6,14 +6,6 @@ import (
 	"GOMODULE/core"
 )
 
-// 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 (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.
 type CacheFeature struct {
 	BaseFeature
 	client  *core.ProjectNameSDK

package/project/.sdk/tm/go/feature/clienttrack_feature.go

@@ -7,13 +7,6 @@ import (
 	"GOMODULE/core"
 )
 
-// Client tracking. 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`. This lets a server correlate all
-// traffic from one SDK instance and each individual call. Header names,
-// client name/version and the id generator (`idgen`) are configurable;
-// caller-provided User-Agent / X-Client-Id values are never clobbered.
 type ClienttrackFeature struct {
 	BaseFeature
 	client  *core.ProjectNameSDK

package/project/.sdk/tm/go/feature/cost_feature.go

@@ -9,28 +9,6 @@ import (
 	"GOMODULE/core"
 )
 
-// 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, 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 PrePoint (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 array form
-// with cost first.
 type CostFeature struct {
 	BaseFeature
 	client  *core.ProjectNameSDK
@@ -124,8 +102,6 @@ func (f *CostFeature) PrePoint(ctx *core.Context) {
 		return
 	}
 
-	// Mark the context as running through the pipeline, so charge knows a
-	// PreDone is coming and does not commit the spend itself.
 	pending, ok := ctx.Out[costPendingKey].(*costPending)
 	if !ok || pending == nil {
 		pending = &costPending{source: "none"}
@@ -171,18 +147,6 @@ func (f *CostFeature) charge(ctx *core.Context, url string, fetchdef map[string]
 
 	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.
-	//
-	// 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 error VALUE here, not a panic, so it already
-	// reaches this point and is priced from the table or unit — no separate
-	// rescue is needed, unlike the ts/js ports.
 	pending.amount += amount
 	if source == "header" || source == "body" {
 		pending.reported += amount
@@ -193,9 +157,6 @@ func (f *CostFeature) charge(ctx *core.Context, url string, fetchdef map[string]
 
 	f.Total.Attempts++
 
-	// direct() and graphql() reach the transport without dispatching any
-	// pipeline hooks, so there is no PrePoint to gate on and no PreDone to
-	// commit. Their spend is committed here, or it would never be counted.
 	if !pending.piped {
 		f.commit(ctx, pending, "_", "direct")
 		delete(ctx.Out, costPendingKey)
@@ -227,15 +188,6 @@ func (f *CostFeature) finish(ctx *core.Context, done bool) {
 	}
 	delete(ctx.Out, costPendingKey)
 
-	// 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 && pending.attempts == 0 {
 		return
 	}
@@ -250,9 +202,6 @@ func (f *CostFeature) finish(ctx *core.Context, done bool) {
 	f.commit(ctx, pending, entity, opname)
 }
 
-// commit records 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 PreDone to reach.
 func (f *CostFeature) commit(ctx *core.Context, pending *costPending, entity, opname string) {
 	amount := pending.amount
 	reported := pending.reported

package/project/.sdk/tm/go/feature/debug_feature.go

@@ -6,12 +6,6 @@ import (
 	"GOMODULE/core"
 )
 
-// Request/response capture for debugging. 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 (e.g. to
-// stream to a console). `max` caps the buffer (default 100).
 type DebugFeature struct {
 	BaseFeature
 	client  *core.ProjectNameSDK

package/project/.sdk/tm/go/feature/feature_options.go

@@ -1,16 +1,16 @@
 package feature
 
 import (
+	"encoding/json"
+	"reflect"
 	"strconv"
 	"strings"
 	"time"
 )
 
-// Shared option readers for the feature implementations. Feature options
-// arrive as map[string]any (from SDK options or test harnesses), so numeric
-// values may be int, int64 or float64 and callbacks arrive as typed Go
-// funcs. These helpers normalise access and supply defaults, mirroring the
-// `null == opts.x ? def : opts.x` pattern of the ts features.
+// Shared option readers for the feature implementations. Options arrive as
+// map[string]any, so a numeric value may be any numeric type; `json.Number` is
+// what encoding/json produces under UseNumber().
 
 func foptBool(options map[string]any, key string, def bool) bool {
 	if options == nil {
@@ -22,19 +22,113 @@ func foptBool(options map[string]any, key string, def bool) bool {
 	return def
 }
 
+// Integers do not route through float64, which cannot hold large ones exactly.
+func fnumInt(v any) (int, bool) {
+	switch n := v.(type) {
+	case int:
+		return n, true
+	case int8:
+		return int(n), true
+	case int16:
+		return int(n), true
+	case int32:
+		return int(n), true
+	case int64:
+		return int(n), true
+	case uint:
+		return int(n), true
+	case uint8:
+		return int(n), true
+	case uint16:
+		return int(n), true
+	case uint32:
+		return int(n), true
+	case uint64:
+		return int(n), true
+	case float32:
+		return int(n), true
+	case float64:
+		return int(n), true
+	case json.Number:
+		if i, err := n.Int64(); err == nil {
+			return int(i), true
+		}
+		if f, err := n.Float64(); err == nil {
+			return int(f), true
+		}
+	}
+	return rnumInt(v)
+}
+
+// A DEFINED numeric type (`type Retries int`) matches no type-switch arm, yet
+// the option validator classifies it by reflect.Kind and passes it through.
+// Reader and validator must agree on what counts as a number.
+func rnumInt(v any) (int, bool) {
+	rv := reflect.ValueOf(v)
+	switch rv.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return int(rv.Int()), true
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return int(rv.Uint()), true
+	case reflect.Float32, reflect.Float64:
+		return int(rv.Float()), true
+	}
+	return 0, false
+}
+
+func fnumFloat(v any) (float64, bool) {
+	switch n := v.(type) {
+	case int:
+		return float64(n), true
+	case int8:
+		return float64(n), true
+	case int16:
+		return float64(n), true
+	case int32:
+		return float64(n), true
+	case int64:
+		return float64(n), true
+	case uint:
+		return float64(n), true
+	case uint8:
+		return float64(n), true
+	case uint16:
+		return float64(n), true
+	case uint32:
+		return float64(n), true
+	case uint64:
+		return float64(n), true
+	case float32:
+		return float64(n), true
+	case float64:
+		return n, true
+	case json.Number:
+		if f, err := n.Float64(); err == nil {
+			return f, true
+		}
+	}
+	return rnumFloat(v)
+}
+
+func rnumFloat(v any) (float64, bool) {
+	rv := reflect.ValueOf(v)
+	switch rv.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return float64(rv.Int()), true
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return float64(rv.Uint()), true
+	case reflect.Float32, reflect.Float64:
+		return rv.Float(), true
+	}
+	return 0, false
+}
+
 func foptInt(options map[string]any, key string, def int) int {
 	if options == nil {
 		return def
 	}
-	switch n := options[key].(type) {
-	case int:
+	if n, ok := fnumInt(options[key]); ok {
 		return n
-	case int64:
-		return int(n)
-	case float64:
-		return int(n)
-	case float32:
-		return int(n)
 	}
 	return def
 }
@@ -43,15 +137,8 @@ func foptNum(options map[string]any, key string, def float64) float64 {
 	if options == nil {
 		return def
 	}
-	switch n := options[key].(type) {
-	case int:
-		return float64(n)
-	case int64:
-		return float64(n)
-	case float64:
+	if n, ok := fnumFloat(options[key]); ok {
 		return n
-	case float32:
-		return float64(n)
 	}
 	return def
 }

package/project/.sdk/tm/go/feature/idempotency_feature.go

@@ -8,12 +8,6 @@ import (
 	"GOMODULE/core"
 )
 
-// Idempotency keys for mutating operations. 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`).
 type IdempotencyFeature struct {
 	BaseFeature
 	client  *core.ProjectNameSDK

package/project/.sdk/tm/go/feature/metrics_feature.go

@@ -4,12 +4,6 @@ import (
 	"GOMODULE/core"
 )
 
-// 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 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.
 type MetricsFeature struct {
 	BaseFeature
 	client  *core.ProjectNameSDK

package/project/.sdk/tm/go/feature/netsim_feature.go

@@ -6,14 +6,6 @@ import (
 	"GOMODULE/core"
 )
 
-// Network behaviour simulation. Wraps the active transport (the live
-// net/http 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.
 type NetsimFeature struct {
 	BaseFeature
 	client  *core.ProjectNameSDK

package/project/.sdk/tm/go/feature/paging_feature.go

@@ -8,15 +8,6 @@ import (
 	"GOMODULE/core"
 )
 
-// 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-Page`/`X-Next-Page`/`X-Total-Count` headers, or
-// `next`/`cursor`/`nextCursor`/`hasMore` fields in the body — and records
-// them on `ctx.Result.Paging`. A per-call cursor/page from ctrl takes
-// priority (used by auto-iteration). Parameter names (`pageParam`,
-// `limitParam`, `cursorParam`), the page size (`limit`) and the start page
-// (`startPage`, default 1) are configurable.
 type PagingFeature struct {
 	BaseFeature
 	client  *core.ProjectNameSDK

package/project/.sdk/tm/go/feature/proxy_feature.go

@@ -8,13 +8,6 @@ import (
 	"GOMODULE/core"
 )
 
-// Outbound HTTP(S) proxy support. Wraps the active transport and annotates
-// each request's fetch definition with the proxy target (`fetchdef.proxy`).
-// The default net/http transport honours the annotation by routing the
-// request through an http.Transport with Proxy set (see utility/fetcher.go);
-// custom transports can do the same. The proxy target comes from options
-// (`url`) or, when `fromEnv` is set, the standard HTTPS_PROXY / HTTP_PROXY /
-// NO_PROXY environment variables. Hosts matching `noProxy` bypass the proxy.
 type ProxyFeature struct {
 	BaseFeature
 	client  *core.ProjectNameSDK

package/project/.sdk/tm/go/feature/ratelimit_feature.go

@@ -6,12 +6,6 @@ import (
 	"GOMODULE/core"
 )
 
-// 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`, default:
-// rate). 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.
 type RatelimitFeature struct {
 	BaseFeature
 	client  *core.ProjectNameSDK

package/project/.sdk/tm/go/feature/rbac_feature.go

@@ -4,15 +4,6 @@ import (
 	"GOMODULE/core"
 )
 
-// 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 (via ctx.Out["point"], which
-// MakePoint surfaces) 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).
 type RbacFeature struct {
 	BaseFeature
 	client  *core.ProjectNameSDK
@@ -53,7 +44,6 @@ func (f *RbacFeature) PrePoint(ctx *core.Context) {
 
 	required, has := f.required(ctx)
 	if !has {
-		// No rule: honour the default policy.
 		if foptBool(f.options, "deny", false) {
 			f.reject(ctx, "<default-deny>")
 		}

package/project/.sdk/tm/go/feature/retry_feature.go

@@ -7,12 +7,6 @@ import (
 	"GOMODULE/core"
 )
 
-// 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 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.
 type RetryFeature struct {
 	BaseFeature
 	client  *core.ProjectNameSDK