@voxgig/sdkgen 1.3.8 → 1.3.10

package/project/.sdk/tm/rb/utility/make_options.rb

@@ -12,6 +12,26 @@ module ProjectNameUtilities
     opts = VoxgigStruct.clone(options)
     opts = {} unless opts.is_a?(Hash)
 
+    # Feature add-order. options["feature"] may be given as an ordered ARRAY of
+    # { "name" => ..., "active" => ..., ... } entries (the array position IS the
+    # order in which features are added), or as a { "name" => {opts} } map.
+    # Normalize an array to a map (so merge/validate/init 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.
+    featureorder = []
+    if opts["feature"].is_a?(Array)
+      fmap = {}
+      opts["feature"].each do |entry|
+        next unless entry.is_a?(Hash)
+        name = entry["name"]
+        next if name.nil?
+        fopts = entry.reject { |k, _| k == "name" }
+        fmap[name] = fopts
+        featureorder << name
+      end
+      opts["feature"] = fmap
+    end
+
     config = ctx.config || {}
     cfgopts = config["options"].is_a?(Hash) ? config["options"] : {}
 
@@ -49,7 +69,22 @@ module ProjectNameUtilities
     clean_keys = "key,token,id" unless clean_keys.is_a?(String)
     parts = clean_keys.split(",").map(&:strip).reject(&:empty?).map { |p| VoxgigStruct.escre(p) }
     keyre = parts.join("|")
+
+    # Resolve the feature add-order: an explicit array order (above) wins;
+    # otherwise order the map test-first, then the remaining names sorted, so
+    # the outcome is deterministic and `test` is always the base transport.
+    if featureorder.empty?
+      fmap = opts["feature"]
+      names = fmap.is_a?(Hash) ? fmap.keys.select { |k| k.is_a?(String) }.sort : []
+      if names.include?("test")
+        featureorder = ["test"] + names.reject { |n| n == "test" }
+      else
+        featureorder = names
+      end
+    end
+
     derived = { "clean" => keyre.empty? ? {} : { "keyre" => keyre } }
+    derived["featureorder"] = featureorder
     opts["__derived__"] = derived
 
     opts

package/project/.sdk/tm/rb/utility/make_point.rb

@@ -1,10 +1,16 @@
 # ProjectName SDK utility: make_point
 require_relative 'struct/voxgig_struct'
 require_relative '../core/helpers'
+require_relative '../core/error'
 module ProjectNameUtilities
   MakePoint = ->(ctx) {
     if ctx.out["point"]
-      ctx.point = ctx.out["point"]
+      preset = ctx.out["point"]
+      # A feature may short-circuit endpoint resolution by placing an error
+      # in ctx.out["point"] (e.g. an rbac denial): surface it as the error
+      # tuple slot so the operation fails before any network use.
+      return nil, preset if preset.is_a?(ProjectNameError)
+      ctx.point = preset
       return ctx.point, nil
     end
 

package/project/.sdk/tm/rust/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) $$const.year$$ Voxgig
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/project/.sdk/tm/rust/Makefile

@@ -0,0 +1,41 @@
+.PHONY: test build clean publish
+
+test:
+	cargo test
+
+build:
+	cargo build
+
+clean:
+	cargo clean
+
+# --- Release: tag-only for now (crates.io publish pending) -----------------
+# The crates.io registry entry is declared in the model with
+# state: 'pending' — a real deploy publishes the git tag rust/vX.Y.Z only;
+# `cargo publish` starts when the registry state flips to 'active'. Run
+# headless under the aql key vault, which injects the GitHub token so
+# nothing lands on disk or argv:
+#   aql vault exec --for=github=<alias> -- make publish
+# aql `--dry-run` injects a filler token we detect to rehearse (no tag/push).
+# set -e + tag-last: a failed push never leaves a tag behind.
+VERSION := $(shell cat VERSION)
+TAG := rust/v$(VERSION)
+AQL_DRY_RUN_FILLER := AQL-DRY-RUN-FILLER-NOT-A-REAL-SECRET
+publish:
+	@if git rev-parse -q --verify "refs/tags/$(TAG)" >/dev/null; then \
+	  echo "tag $(TAG) already exists — bump VERSION first"; exit 1; fi
+	@set -e; \
+	token="$${GITHUB_TOKEN:-$$GH_TOKEN}"; \
+	if [ "$$token" = "$(AQL_DRY_RUN_FILLER)" ]; then \
+	  echo "[dry-run] aql filler token detected: would tag $(TAG); nothing pushed."; \
+	  exit 0; \
+	fi; \
+	git tag -a "$(TAG)" -m "rust v$(VERSION)"; \
+	url=$$(git remote get-url origin | sed -E 's#^git@github.com:#https://github.com/#'); \
+	if [ -n "$$token" ] && printf '%s' "$$url" | grep -q '^https://github.com/'; then \
+	  hdr="AUTHORIZATION: basic $$(printf 'x-access-token:%s' "$$token" | base64 | tr -d '\n')"; \
+	  git -c http.extraheader="$$hdr" push "$$url" "$(TAG)"; \
+	else \
+	  git push origin "$(TAG)"; \
+	fi; \
+	echo "Tagged $(TAG)."

package/project/.sdk/tm/rust/VERSION

@@ -0,0 +1 @@
+0.0.1

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

@@ -0,0 +1,320 @@
+// 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;
+use std::rc::Rc;
+
+use crate::core::control::Control;
+use crate::core::error::ProjectNameError;
+use crate::core::helpers::{get_bool, get_str, getp, getpath, jo, rand_int, to_map};
+use crate::core::operation::Operation;
+use crate::core::response::Response;
+use crate::core::result::SdkResult;
+use crate::core::sdk::ProjectNameSDK;
+use crate::core::spec::Spec;
+use crate::core::types::{Entity, OutVal};
+use crate::core::utility_type::Utility;
+use crate::utility::voxgigstruct::Value;
+
+pub type OpMap = Rc<RefCell<HashMap<String, Rc<Operation>>>>;
+
+/// Construction spec for a Context (go passes an untyped ctxmap; rust uses
+/// this typed builder with `..Default::default()` at call sites).
+#[derive(Default)]
+pub struct CtxSpec {
+    pub opname: Option<String>,
+    pub client: Option<Rc<ProjectNameSDK>>,
+    pub utility: Option<Rc<Utility>>,
+    /// ctrl as a caller-supplied Value map ({throw, explain, actor, paging}).
+    pub ctrl: Option<Value>,
+    /// ctrl as an existing Control object.
+    pub ctrl_obj: Option<Rc<RefCell<Control>>>,
+    pub meta: Option<Value>,
+    pub config: Option<Value>,
+    pub entopts: Option<Value>,
+    pub options: Option<Value>,
+    pub entity: Option<Rc<dyn Entity>>,
+    pub shared: Option<Value>,
+    pub opmap: Option<OpMap>,
+    pub data: Option<Value>,
+    pub reqdata: Option<Value>,
+    pub mtch: Option<Value>,
+    pub reqmatch: Option<Value>,
+    pub point: Option<Value>,
+    pub spec: Option<Rc<RefCell<Spec>>>,
+    pub result: Option<Rc<RefCell<SdkResult>>>,
+    pub response: Option<Rc<RefCell<Response>>>,
+}
+
+pub struct Context {
+    pub id: String,
+    pub out: RefCell<HashMap<String, OutVal>>,
+    pub ctrl: RefCell<Rc<RefCell<Control>>>,
+    pub meta: RefCell<Value>,
+    pub client: RefCell<Option<Rc<ProjectNameSDK>>>,
+    pub utility: RefCell<Option<Rc<Utility>>>,
+    pub op: RefCell<Rc<Operation>>,
+    pub point: RefCell<Value>,
+    pub config: RefCell<Value>,
+    pub entopts: RefCell<Value>,
+    pub options: RefCell<Value>,
+    pub opmap: RefCell<OpMap>,
+    pub response: RefCell<Option<Rc<RefCell<Response>>>>,
+    pub result: RefCell<Option<Rc<RefCell<SdkResult>>>>,
+    pub spec: RefCell<Option<Rc<RefCell<Spec>>>>,
+    pub data: RefCell<Value>,
+    pub reqdata: RefCell<Value>,
+    pub mtch: RefCell<Value>,
+    pub reqmatch: RefCell<Value>,
+    pub entity: RefCell<Option<Rc<dyn Entity>>>,
+    pub shared: RefCell<Value>,
+}
+
+impl Context {
+    pub fn new(ctxspec: CtxSpec, basectx: Option<&Rc<Context>>) -> Rc<Context> {
+        let id = format!("C{}", rand_int(90000000) + 10000000);
+
+        // Client
+        let client = ctxspec
+            .client
+            .or_else(|| basectx.and_then(|b| b.client.borrow().clone()));
+
+        // Utility
+        let utility = ctxspec
+            .utility
+            .or_else(|| basectx.and_then(|b| b.utility.borrow().clone()));
+
+        // Ctrl
+        let ctrl: Rc<RefCell<Control>> = if let Some(cm) = &ctxspec.ctrl {
+            let mut c = Control::new();
+            if let Some(t) = get_bool(cm, "throw") {
+                c.throw = Some(t);
+            }
+            if let Value::Map(_) = getp(cm, "explain") {
+                c.explain = getp(cm, "explain");
+            }
+            if let Some(a) = get_str(cm, "actor") {
+                c.actor = a;
+            }
+            if let Value::Map(_) = getp(cm, "paging") {
+                c.paging = getp(cm, "paging");
+            }
+            Rc::new(RefCell::new(c))
+        } else if let Some(co) = ctxspec.ctrl_obj {
+            co
+        } else if let Some(b) = basectx {
+            b.ctrl.borrow().clone()
+        } else {
+            Rc::new(RefCell::new(Control::new()))
+        };
+
+        // Meta
+        let meta = ctxspec
+            .meta
+            .or_else(|| {
+                basectx.and_then(|b| {
+                    let m = b.meta.borrow();
+                    if matches!(&*m, Value::Map(_)) {
+                        Some(m.clone())
+                    } else {
+                        None
+                    }
+                })
+            })
+            .unwrap_or_else(Value::empty_map);
+
+        // Config / Entopts / Options / Entity / Shared: fall back to base.
+        let config = ctxspec
+            .config
+            .or_else(|| basectx.map(|b| b.config.borrow().clone()))
+            .unwrap_or(Value::Noval);
+        let entopts = ctxspec
+            .entopts
+            .or_else(|| basectx.map(|b| b.entopts.borrow().clone()))
+            .unwrap_or(Value::Noval);
+        let options = ctxspec
+            .options
+            .or_else(|| basectx.map(|b| b.options.borrow().clone()))
+            .unwrap_or(Value::Noval);
+        let entity = ctxspec
+            .entity
+            .or_else(|| basectx.and_then(|b| b.entity.borrow().clone()));
+        let shared = ctxspec
+            .shared
+            .or_else(|| {
+                basectx.and_then(|b| {
+                    let s = b.shared.borrow();
+                    if matches!(&*s, Value::Map(_)) {
+                        Some(s.clone())
+                    } else {
+                        None
+                    }
+                })
+            })
+            .unwrap_or(Value::Noval);
+
+        // Opmap (shared with the base context, like go).
+        let opmap: OpMap = ctxspec
+            .opmap
+            .or_else(|| basectx.map(|b| b.opmap.borrow().clone()))
+            .unwrap_or_else(|| Rc::new(RefCell::new(HashMap::new())));
+
+        // Data maps (never inherited).
+        let data = match ctxspec.data.map(|d| to_map(&d)) {
+            Some(Value::Map(m)) => Value::Map(m),
+            _ => Value::empty_map(),
+        };
+        let reqdata = match ctxspec.reqdata.map(|d| to_map(&d)) {
+            Some(Value::Map(m)) => Value::Map(m),
+            _ => Value::empty_map(),
+        };
+        let mtch = match ctxspec.mtch.map(|d| to_map(&d)) {
+            Some(Value::Map(m)) => Value::Map(m),
+            _ => Value::empty_map(),
+        };
+        let reqmatch = match ctxspec.reqmatch.map(|d| to_map(&d)) {
+            Some(Value::Map(m)) => Value::Map(m),
+            _ => Value::empty_map(),
+        };
+
+        // Point / Spec / Result / Response: fall back to base.
+        let point = ctxspec
+            .point
+            .or_else(|| {
+                basectx.and_then(|b| {
+                    let p = b.point.borrow();
+                    if matches!(&*p, Value::Map(_)) {
+                        Some(p.clone())
+                    } else {
+                        None
+                    }
+                })
+            })
+            .unwrap_or(Value::Noval);
+        let spec = ctxspec
+            .spec
+            .or_else(|| basectx.and_then(|b| b.spec.borrow().clone()));
+        let result = ctxspec
+            .result
+            .or_else(|| basectx.and_then(|b| b.result.borrow().clone()));
+        let response = ctxspec
+            .response
+            .or_else(|| basectx.and_then(|b| b.response.borrow().clone()));
+
+        let ctx = Rc::new(Context {
+            id,
+            out: RefCell::new(HashMap::new()),
+            ctrl: RefCell::new(ctrl),
+            meta: RefCell::new(meta),
+            client: RefCell::new(client),
+            utility: RefCell::new(utility),
+            op: RefCell::new(Rc::new(Operation::new(&Value::empty_map()))),
+            point: RefCell::new(point),
+            config: RefCell::new(config),
+            entopts: RefCell::new(entopts),
+            options: RefCell::new(options),
+            opmap: RefCell::new(opmap),
+            response: RefCell::new(response),
+            result: RefCell::new(result),
+            spec: RefCell::new(spec),
+            data: RefCell::new(data),
+            reqdata: RefCell::new(reqdata),
+            mtch: RefCell::new(mtch),
+            reqmatch: RefCell::new(reqmatch),
+            entity: RefCell::new(entity),
+            shared: RefCell::new(shared),
+        });
+
+        // Resolve operation.
+        let opname = ctxspec.opname.unwrap_or_default();
+        let op = ctx.resolve_op(&opname);
+        *ctx.op.borrow_mut() = op;
+
+        ctx
+    }
+
+    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()
+            .as_ref()
+            .map(|e| e.get_name())
+            .unwrap_or_default();
+        let cache_key = format!("{}:{}", entname, opname);
+
+        if let Some(op) = self.opmap.borrow().borrow().get(&cache_key) {
+            return op.clone();
+        }
+
+        if opname.is_empty() {
+            return Rc::new(Operation::new(&Value::empty_map()));
+        }
+
+        let opcfg = getpath(
+            &["entity", &entname, "op", opname],
+            &self.config.borrow(),
+        );
+
+        let input = if opname == "update" || opname == "create" {
+            "data"
+        } else {
+            "match"
+        };
+
+        let targets = match getp(&opcfg, "points") {
+            Value::List(l) => Value::List(l),
+            _ => Value::empty_list(),
+        };
+
+        let op = Rc::new(Operation::new(&jo(vec![
+            ("entity", Value::str(entname)),
+            ("name", Value::str(opname)),
+            ("input", Value::str(input)),
+            ("points", targets),
+        ])));
+
+        self.opmap
+            .borrow()
+            .borrow_mut()
+            .insert(cache_key, op.clone());
+        op
+    }
+
+    pub fn make_error(&self, code: &str, msg: &str) -> ProjectNameError {
+        ProjectNameError::new(code, msg)
+    }
+
+    /// The context utility (set on every pipeline context).
+    pub fn util(&self) -> Rc<Utility> {
+        self.utility
+            .borrow()
+            .clone()
+            .expect("context utility not set")
+    }
+
+    // --- ctx.out staging helpers -----------------------------------------
+
+    pub fn out_get(&self, key: &str) -> Option<OutVal> {
+        self.out.borrow().get(key).cloned()
+    }
+
+    pub fn out_set(&self, key: &str, val: OutVal) {
+        self.out.borrow_mut().insert(key.to_string(), val);
+    }
+
+    pub fn out_take(&self, key: &str) -> Option<OutVal> {
+        self.out.borrow_mut().remove(key)
+    }
+
+    /// A ctx.out entry as a Value (Noval when absent or not a Value).
+    pub fn out_val(&self, key: &str) -> Value {
+        match self.out_get(key) {
+            Some(OutVal::Val(v)) => v,
+            _ => Value::Noval,
+        }
+    }
+}

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

@@ -0,0 +1,37 @@
+// Per-call control state (mirrors go core/control.go).
+
+use crate::core::error::ProjectNameError;
+use crate::utility::voxgigstruct::Value;
+
+pub struct Control {
+    pub throw: Option<bool>,
+    pub err: Option<ProjectNameError>,
+    // explain / paging are Value maps when supplied (Noval otherwise). They
+    // are the caller's own maps (reference-shared), so recorded entries are
+    // visible to the caller after the operation completes.
+    pub explain: Value,
+    pub actor: String,
+    pub paging: Value,
+}
+
+impl Control {
+    pub fn new() -> Control {
+        Control {
+            throw: None,
+            err: None,
+            explain: Value::Noval,
+            actor: String::new(),
+            paging: Value::Noval,
+        }
+    }
+
+    pub fn has_explain(&self) -> bool {
+        matches!(self.explain, Value::Map(_))
+    }
+}
+
+impl Default for Control {
+    fn default() -> Control {
+        Control::new()
+    }
+}

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

@@ -0,0 +1,168 @@
+// Shared Value helpers for the ProjectName SDK pipeline. The SDK data model
+// is the vendored voxgig struct `Value` type (utility/voxgigstruct) — the
+// JSON-shaped, reference-stable (Rc<RefCell>) node used for ctx data, specs,
+// options, transport payloads and results, exactly as the Go SDK passes
+// map[string]any around.
+
+use std::cell::RefCell;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use crate::core::error::ProjectNameError;
+use crate::utility::voxgigstruct as vs;
+use crate::utility::voxgigstruct::major::Injection;
+use vs::Value;
+
+// UnsupportedOp is returned by entity stub methods for operations the
+// underlying API spec doesn't define. The static ProjectNameEntity trait
+// requires every CRUD method on every entity, so absent ops must still be
+// callable — they error at runtime instead of failing to compile.
+pub fn unsupported_op(opname: &str, entityname: &str) -> ProjectNameError {
+    ProjectNameError::new(
+        "unsupported_op",
+        &format!(
+            "operation '{}' not supported by entity '{}'",
+            opname, entityname
+        ),
+    )
+}
+
+/// 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)
+}
+
+/// Go `ToMapAny`: the value if it is a map, Noval otherwise.
+pub fn to_map(v: &Value) -> Value {
+    match v {
+        Value::Map(_) => v.clone(),
+        _ => Value::Noval,
+    }
+}
+
+/// Go `ToInt`: numeric coercion with -1 default.
+pub fn to_int(v: &Value) -> i64 {
+    match v {
+        Value::Num(n) => *n as i64,
+        _ => -1,
+    }
+}
+
+pub fn get_str(m: &Value, key: &str) -> Option<String> {
+    match getp(m, key) {
+        Value::Str(s) => Some(s),
+        _ => None,
+    }
+}
+
+pub fn get_bool(m: &Value, key: &str) -> Option<bool> {
+    match getp(m, key) {
+        Value::Bool(b) => Some(b),
+        _ => None,
+    }
+}
+
+pub fn get_i64(m: &Value, key: &str) -> Option<i64> {
+    match getp(m, key) {
+        Value::Num(n) => Some(n as i64),
+        _ => None,
+    }
+}
+
+pub fn get_f64(m: &Value, key: &str) -> Option<f64> {
+    match getp(m, key) {
+        Value::Num(n) => Some(n),
+        _ => None,
+    }
+}
+
+/// Wall clock in milliseconds.
+pub fn now_ms() -> i64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_millis() as 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()
+            .duration_since(UNIX_EPOCH)
+            .map(|d| d.subsec_nanos() as i64 + d.as_millis() as i64)
+            .unwrap_or(123456789)
+    );
+}
+
+/// Pseudo-random integer in [0, n).
+pub fn rand_int(n: i64) -> i64 {
+    if n <= 0 {
+        return 0;
+    }
+    RAND_SEED.with(|s| {
+        let mut seed = s.borrow_mut();
+        *seed = (seed.wrapping_mul(1103515245).wrapping_add(12345)) & 0x7fffffff;
+        *seed % n
+    })
+}
+
+/// Call a `Value::Func` callable with a single argument. The voxgig struct
+/// NativeFn signature is injector-shaped `(inj, val, ref, store)`; SDK
+/// callables (injected clocks, key generators, mock transports, custom
+/// utilities) receive their argument via `val` and ignore the rest.
+pub fn call_vfn(f: &Value, arg: &Value) -> Value {
+    match f {
+        Value::Func(nf) => {
+            let inj = Injection::from_def(None);
+            nf(&inj, arg, "", &Value::Noval)
+        }
+        _ => Value::Noval,
+    }
+}
+
+/// Wrap a plain single-argument closure as a `Value::Func`.
+pub fn vfn<F>(f: F) -> Value
+where
+    F: Fn(&Value) -> Value + 'static,
+{
+    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/mod.rs

@@ -0,0 +1,18 @@
+// ProjectName SDK core: the operation pipeline types.
+//
+// Static modules are templates (same for every API); `config` and `sdk`
+// are generated per-API by the sdkgen components.
+
+pub mod config;
+pub mod context;
+pub mod control;
+pub mod error;
+pub mod helpers;
+pub mod operation;
+pub mod point;
+pub mod response;
+pub mod result;
+pub mod sdk;
+pub mod spec;
+pub mod types;
+pub mod utility_type;