@voxgig/sdkgen 4.20.0 → 4.22.0

package/project/.sdk/tm/rb/feature/secrets/voxgig_sekreto/plugins/onepassword.rb

@@ -1,5 +1,5 @@
-# VENDORED: @voxgig/sekreto sdk-20260908-1556-0 (ruby/lib/voxgig_sekreto/plugins/onepassword.rb)
-# Source: https://github.com/voxgig/sekreto @ 1267ee2e5f49566bc92695bc9eb3a60ef4924998  [tag: sdk-20260911-2013-0]
+# VENDORED: @voxgig/sekreto sdk-20260917-1242-0 (ruby/lib/voxgig_sekreto/plugins/onepassword.rb)
+# Source: https://github.com/voxgig/sekreto @ 108c4a914bee7b6534c30d1c68c25cd1b9377696  [tag: sdk-20260917-1242-0]
 # License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
 # frozen_string_literal: true
 

package/project/.sdk/tm/rb/feature/secrets/voxgig_sekreto/plugins/secretspec.rb

@@ -1,5 +1,5 @@
-# VENDORED: @voxgig/sekreto sdk-20260908-1556-0 (ruby/lib/voxgig_sekreto/plugins/secretspec.rb)
-# Source: https://github.com/voxgig/sekreto @ 1267ee2e5f49566bc92695bc9eb3a60ef4924998  [tag: sdk-20260911-2013-0]
+# VENDORED: @voxgig/sekreto sdk-20260917-1242-0 (ruby/lib/voxgig_sekreto/plugins/secretspec.rb)
+# Source: https://github.com/voxgig/sekreto @ 108c4a914bee7b6534c30d1c68c25cd1b9377696  [tag: sdk-20260917-1242-0]
 # License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
 # frozen_string_literal: true
 

package/project/.sdk/tm/rb/feature/secrets/voxgig_sekreto/plugins/sigv4.rb

@@ -1,5 +1,5 @@
-# VENDORED: @voxgig/sekreto sdk-20260908-1556-0 (ruby/lib/voxgig_sekreto/plugins/sigv4.rb)
-# Source: https://github.com/voxgig/sekreto @ 1267ee2e5f49566bc92695bc9eb3a60ef4924998  [tag: sdk-20260911-2013-0]
+# VENDORED: @voxgig/sekreto sdk-20260917-1242-0 (ruby/lib/voxgig_sekreto/plugins/sigv4.rb)
+# Source: https://github.com/voxgig/sekreto @ 108c4a914bee7b6534c30d1c68c25cd1b9377696  [tag: sdk-20260917-1242-0]
 # License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
 # frozen_string_literal: true
 

package/project/.sdk/tm/rb/feature/secrets/voxgig_sekreto/providers.rb

@@ -1,5 +1,5 @@
-# VENDORED: @voxgig/sekreto sdk-20260908-1556-0 (ruby/lib/voxgig_sekreto/providers.rb)
-# Source: https://github.com/voxgig/sekreto @ 1267ee2e5f49566bc92695bc9eb3a60ef4924998  [tag: sdk-20260911-2013-0]
+# VENDORED: @voxgig/sekreto sdk-20260917-1242-0 (ruby/lib/voxgig_sekreto/providers.rb)
+# Source: https://github.com/voxgig/sekreto @ 108c4a914bee7b6534c30d1c68c25cd1b9377696  [tag: sdk-20260917-1242-0]
 # License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
 # frozen_string_literal: true
 
@@ -20,8 +20,9 @@
 #
 # THIS FILE REQUIRES NO net/http, NO openssl AND NO open3. What makes a
 # kind built in is that it needs nothing of the platform beyond reading a
-# local file; every kind that opens a socket, signs a request or spawns a
-# process is a plugin under plugins/, its own file, required only by a
+# local file; every kind that opens a socket, signs a request, spawns a
+# process or does cryptography is a plugin under plugins/, its own file,
+# required only by a
 # program that names it (docs/design/plugin-providers.md).
 #
 # A port of typescript/src/provider/support.ts and
@@ -204,7 +205,7 @@ module VoxgigSekreto
     'builtin' => %w[env memory dotenv file].freeze,
     'plugin' => %w[
       hashicorp boru awssecrets awsparams gcpsecrets azuresecrets
-      onepassword doppler infisical secretspec
+      onepassword doppler infisical secretspec minivault
     ].freeze
   }.freeze
 end

package/project/.sdk/tm/rb/feature/secrets/voxgig_sekreto/sekreto.rb

@@ -1,5 +1,5 @@
-# VENDORED: @voxgig/sekreto sdk-20260908-1556-0 (ruby/lib/voxgig_sekreto/sekreto.rb)
-# Source: https://github.com/voxgig/sekreto @ 1267ee2e5f49566bc92695bc9eb3a60ef4924998  [tag: sdk-20260911-2013-0]
+# VENDORED: @voxgig/sekreto sdk-20260917-1242-0 (ruby/lib/voxgig_sekreto/sekreto.rb)
+# Source: https://github.com/voxgig/sekreto @ 108c4a914bee7b6534c30d1c68c25cd1b9377696  [tag: sdk-20260917-1242-0]
 # License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
 # frozen_string_literal: true
 

package/project/.sdk/tm/rb/feature/secrets/voxgig_sekreto.rb

@@ -1,5 +1,5 @@
-# VENDORED: @voxgig/sekreto sdk-20260908-1556-0 (ruby/lib/voxgig_sekreto.rb)
-# Source: https://github.com/voxgig/sekreto @ 1267ee2e5f49566bc92695bc9eb3a60ef4924998  [tag: sdk-20260911-2013-0]
+# VENDORED: @voxgig/sekreto sdk-20260917-1242-0 (ruby/lib/voxgig_sekreto.rb)
+# Source: https://github.com/voxgig/sekreto @ 108c4a914bee7b6534c30d1c68c25cd1b9377696  [tag: sdk-20260917-1242-0]
 # License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
 # frozen_string_literal: true
 

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

@@ -0,0 +1,265 @@
+# ProjectName SDK validate feature
+#
+# Payload validation against the model's own field types. The ruby port of
+# tm/ts/src/feature/validate/ValidateFeature.ts.
+#
+# The specs are NOT written here and not written in the model either: every
+# entity field already carries a canonical type sentinel ("$STRING",
+# "$INTEGER", the "$ONE" union for an OpenAPI multi-type), which is the same
+# vocabulary VoxgigStruct.validate speaks. The generator maps them once
+# (helpers/canonSpec) and emits ProjectNameSchema::ENTITYSPEC, so a field
+# whose type changes in the API spec changes what this feature enforces with
+# no edit anywhere.
+#
+# WHAT IS CHECKED
+#   outbound (PreSpec)  the payload the caller asked to send, against
+#                       spec["op"][opname] - the operation's request shape.
+#   inbound  (PreDone)  each record the operation returned, against
+#                       spec["data"] - the entity's own field types.
+#
+# WHAT IS NOT. The model carries no array element types, no nested object
+# schemas, no enums, formats or bounds, so this checks the shape the model
+# knows and nothing more.
+
+require_relative 'base_feature'
+require_relative '../schema'
+require_relative '../utility/struct/voxgig_struct'
+
+class ProjectNameValidateFeature < ProjectNameBaseFeature
+  # Built rather than written, so the backticks cannot be lost in an edit.
+  OPEN = 96.chr + "$OPEN" + 96.chr
+
+  def initialize
+    super
+    @version = "0.0.1"
+    @name = "validate"
+    # Inactive until init (feature_init only fires init when active).
+    @active = false
+    @client = nil
+    @options = {}
+    @spec = {}
+    @request = true
+    @response = false
+    @mode = "throw"
+  end
+
+  def init(ctx, options)
+    @client = ctx.client
+    @options = options.is_a?(Hash) ? options : {}
+    @active = @options["active"] == true
+
+    # DEFAULTS ARE APPLIED HERE, not by the option spec. The model's
+    # config.options documents them and types them; it does not inject them,
+    # because each feature entry in the spec is optional and struct fills in
+    # nothing through an optional union.
+    @request = @options["request"] != false
+    @response = @options["response"] == true
+
+    # FAIL CLOSED. Only the exact string "report" selects report mode, so a
+    # typo (mode: "thow") still rejects rather than silently turning
+    # enforcement off. The option spec rejects the typo outright; this is what
+    # happens if it ever does not.
+    @mode = @options["mode"] == "report" ? "report" : "throw"
+
+    # `strict` is applied ONCE, here, by rebuilding the spec tree without the
+    # `$OPEN` markers - rather than per call, which would clone a spec for
+    # every request an SDK ever makes.
+    @spec = @options["strict"] == true ?
+      _close(ProjectNameSchema::ENTITYSPEC) : ProjectNameSchema::ENTITYSPEC
+  end
+
+  # Outbound. make_spec short-circuits on a ctx.out["spec"] that is already
+  # set, so assigning the error here rejects the operation before the request
+  # is built - the same seam rbac uses one stage earlier.
+  def PreSpec(ctx)
+    return unless @active && @request
+
+    opname = _opname(ctx)
+    espec = _entity_spec(ctx)
+    ops = espec.is_a?(Hash) ? espec["op"] : nil
+    opspec = ops.is_a?(Hash) ? ops[opname] : nil
+
+    return if opspec.nil?
+
+    errs = _check(ctx, _payload(ctx, opname), opspec, "request")
+    return if errs.empty? || @mode == "report"
+
+    err = ctx.make_error("validate_failed",
+      "Invalid #{opname} request for entity \"#{_entname(ctx)}\": #{errs.join('; ')}")
+    ctx.out["spec"] = err
+    err
+  end
+
+  # Inbound. PreDone rather than PreResult: the records are extracted from the
+  # response body by make_result, which runs between the two, so at PreResult
+  # there is nothing to check but the envelope.
+  #
+  # HOOK ORDER MATTERS HERE, and the default order is not the one you want.
+  # PreDone hooks fire in feature ADD order, which defaults to `test` first and
+  # then names sorted - and `validate` sorts last, after audit, cost, debug,
+  # metrics and telemetry. Those observers therefore record the operation as a
+  # success before this hook has looked at it. Activating features as an
+  # ORDERED ARRAY fixes it.
+  def PreDone(ctx)
+    return unless @active && @response
+
+    espec = _entity_spec(ctx)
+    return unless espec.is_a?(Hash)
+
+    dataspec = espec["data"]
+    return if dataspec.nil?
+
+    result = ctx.result
+    return if result.nil? || result.resdata.nil?
+
+    # A list op returns many records and a load returns one; both are checked
+    # against the same record spec, because they are the same entity.
+    records = result.resdata.is_a?(Array) ? result.resdata : [result.resdata]
+
+    errs = []
+    records.each do |record|
+      next if record.nil?
+
+      # A NON-OBJECT IS A FAILURE, not something to skip. A load that answered
+      # 42 where the entity's spec wants a record must not pass this feature
+      # silently - struct rejects it with the field it could not find.
+      errs.concat(_check(ctx, _unwrap(record), dataspec, "response"))
+    end
+
+    return if errs.empty? || @mode == "report"
+
+    err = ctx.make_error("validate_failed",
+      "Invalid response for entity \"#{_entname(ctx)}\": #{errs.join('; ')}")
+
+    # BOTH, and `ok` is the load-bearing half: done returns resdata whenever
+    # result.ok is true and never looks at err, so setting the error alone
+    # would hand the caller the very records that failed the spec.
+    result.ok = false
+    result.err = err
+
+    # AND THE DATA GOES. The load/update paths copy result.resdata into the
+    # entity's own state on any non-nil value, BEFORE done raises - so
+    # rejecting the operation while leaving the records in place would leave
+    # the caller holding an entity populated from a payload this feature had
+    # just declared invalid.
+    result.resdata = nil
+
+    err
+  end
+
+  # The payload an operation is about to send.
+  #
+  # TWO SLOTS, AND THE OP PICKS. A body op (create/update/patch) carries the
+  # caller's argument in reqdata over the entity's data; a match op
+  # (load/list/remove) carries it in reqmatch over match. That is what the
+  # entity operations pass to make_context and what make_point reads - so
+  # reading reqdata for every op would check a load({id}) against the entity's
+  # STALE stored match and reject it for the id the caller had just supplied.
+  def _payload(ctx, opname)
+    body = ["create", "update", "patch"].include?(opname)
+
+    base = body ? ctx.data : ctx.match
+    req = body ? ctx.reqdata : ctx.reqmatch
+
+    out = {}
+    out.merge!(base) if base.is_a?(Hash)
+    out.merge!(req) if req.is_a?(Hash)
+
+    # `$action` SELECTS A CUSTOM ENDPOINT; it is not a field of the record.
+    # make_point reads it off this same argument and the request transformer
+    # drops it before the body is built, so a spec built from the API's own
+    # fields will never name it - and under `strict` every custom-action call
+    # would be rejected for the one key that made it reachable.
+    out.delete("$action")
+
+    out
+  end
+
+  def _entity_spec(ctx)
+    return nil unless @spec.is_a?(Hash)
+    @spec[_entname(ctx)]
+  end
+
+  def _opname(ctx)
+    name = ctx.op.nil? ? nil : ctx.op.name
+    name.is_a?(String) ? name : ""
+  end
+
+  def _entname(ctx)
+    name = ctx.entity.nil? ? nil : ctx.entity.name
+    return name if name.is_a?(String) && !name.empty?
+
+    entname = ctx.op.nil? ? nil : ctx.op.entity
+    entname.is_a?(String) ? entname : ""
+  end
+
+  # One validate call. Errors are COLLECTED, never raised: struct raises on the
+  # first failure unless given an errs array, and a caller fixing a payload
+  # wants every problem with it, not the first one.
+  def _check(ctx, data, spec, direction)
+    errs = []
+
+    begin
+      VoxgigStruct.validate(data, spec, { "errs" => errs })
+    rescue StandardError => e
+      # A spec this port cannot run at all (rather than a payload that fails
+      # it) must not take the operation down with it: report it like any other
+      # failure and let `mode` decide.
+      errs << e.message if errs.empty?
+    end
+
+    errs = errs.map(&:to_s)
+
+    if !errs.empty?
+      on_invalid = @options["onInvalid"]
+      if on_invalid.respond_to?(:call)
+        begin
+          on_invalid.call({
+            "entity" => _entname(ctx),
+            "op" => _opname(ctx),
+            "direction" => direction,
+            "errs" => errs,
+            "data" => data,
+          })
+        rescue StandardError
+          nil
+        end
+      end
+    end
+
+    errs
+  end
+
+  # A RESULT RECORD AS DATA.
+  #
+  # make_result turns every record of a LIST into an entity instance, so what
+  # reaches PreDone for a list is wrappers, not records - and a wrapper checked
+  # against a field spec fails on every required field while its actual data
+  # goes unchecked. A load returns the record itself, so this handles both.
+  def _unwrap(record)
+    if record.respond_to?(:data)
+      begin
+        data = record.data
+      rescue StandardError
+        return record
+      end
+      return data unless data.nil?
+    end
+    record
+  end
+
+  # The spec tree with every `$OPEN` marker removed, so an undeclared key is an
+  # error rather than a pass. Rebuilt rather than mutated: ENTITYSPEC is a
+  # module constant shared by every client in the process.
+  def _close(node)
+    return node.map { |n| _close(n) } if node.is_a?(Array)
+
+    if node.is_a?(Hash)
+      out = {}
+      node.each { |k, v| out[k] = _close(v) unless k == OPEN }
+      return out
+    end
+
+    node
+  end
+end

package/project/.sdk/tm/rb/test/vendor/omni/runner.rb

@@ -1,5 +1,5 @@
-# VENDORED: @voxgig/omni sdk-20260908-1556-0 (ruby/lib/voxgig_omni/runner.rb)
-# Source: https://github.com/voxgig/omni @ 274708cc2d12b21707d975543953f845f8444be0  [tag: sdk-20260911-2013-0]
+# VENDORED: @voxgig/omni sdk-20260917-1242-0 (ruby/lib/voxgig_omni/runner.rb)
+# Source: https://github.com/voxgig/omni @ b9e6085d185e174be84f9e6123be807ccd9fcb4e  [tag: sdk-20260917-1242-0]
 # License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
 # Omni: the shared multi-language test runner.
 #

package/project/.sdk/tm/rb/test/vendor/omni/util.rb

@@ -1,5 +1,5 @@
-# VENDORED: @voxgig/omni sdk-20260908-1556-0 (ruby/lib/voxgig_omni/util.rb)
-# Source: https://github.com/voxgig/omni @ 274708cc2d12b21707d975543953f845f8444be0  [tag: sdk-20260911-2013-0]
+# VENDORED: @voxgig/omni sdk-20260917-1242-0 (ruby/lib/voxgig_omni/util.rb)
+# Source: https://github.com/voxgig/omni @ b9e6085d185e174be84f9e6123be807ccd9fcb4e  [tag: sdk-20260917-1242-0]
 # License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
 # Omni internal JSON utilities.
 #

package/project/.sdk/tm/rb/test/vendor/omni/voxgig_omni.rb

@@ -1,5 +1,5 @@
-# VENDORED: @voxgig/omni sdk-20260908-1556-0 (ruby/lib/voxgig_omni.rb)
-# Source: https://github.com/voxgig/omni @ 274708cc2d12b21707d975543953f845f8444be0  [tag: sdk-20260911-2013-0]
+# VENDORED: @voxgig/omni sdk-20260917-1242-0 (ruby/lib/voxgig_omni.rb)
+# Source: https://github.com/voxgig/omni @ b9e6085d185e174be84f9e6123be807ccd9fcb4e  [tag: sdk-20260917-1242-0]
 # License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
 # voxgig_omni - shared multi-language test runner.
 

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

@@ -1,5 +1,6 @@
 # ProjectName SDK utility: make_options
 require_relative 'struct/voxgig_struct'
+require_relative '../schema'
 module ProjectNameUtilities
   MakeOptions = ->(ctx) {
     options = ctx.options || {}
@@ -80,38 +81,20 @@ module ProjectNameUtilities
     config = ctx.config || {}
     cfgopts = config["options"].is_a?(Hash) ? config["options"] : {}
 
-    optspec = {
-      "apikey" => "",
-      "base" => "http://localhost:8000",
-      "secret" => "",
-      "prefix" => "",
-      "suffix" => "",
-      # `basic` and `secret`: HTTP Basic Auth needs a second credential and
-      # a flag to say the pair is Basic rather than a single bearer token.
-      "auth" => { "prefix" => "", "basic" => false },
-      "headers" => { "`$CHILD`" => "`$STRING`" },
-      "allow" => {
-        "method" => "GET,PUT,POST,PATCH,DELETE,OPTIONS",
-        "op" => "create,update,load,list,remove,command,direct,graphql",
-      },
-      "entity" => { "`$CHILD`" => { "`$OPEN`" => true, "active" => false, "alias" => {} } },
-      "feature" => { "`$CHILD`" => { "`$OPEN`" => true, "active" => false } },
-      "utility" => {},
-      # Feature INSTANCES supplied at construction (the station adopt
-      # path): consumed by the constructor's feature_add loop, so they are
-      # class instances, not data — `$ANY` accepts them verbatim. Without
-      # this entry the seam is dead: the constructor reads
-      # options["extend"], but validate rejected the key.
-      "extend" => "`$ANY`",
-      "system" => {},
-      "test" => { "active" => false, "entity" => { "`$OPEN`" => true } },
-      "clean" => { "keys" => "key,token,id" },
-      # Server-variable values for a templated base URL (OpenAPI server
-      # variables): {name} placeholders in "base" are substituted from this
-      # map at construction. Spec defaults arrive via the generated config;
-      # user values override them.
-      "server" => { "`$CHILD`" => "" },
-    }
+    # THE OPTION SPEC IS GENERATED, NOT WRITTEN HERE.
+    #
+    # `ProjectNameSchema::OPTSPEC` is built from the model:
+    # `main.kit.optspec` for the standard options, plus one entry per
+    # feature this target carries, taken 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.
+    #
+    # NOT MUTATED. It is a frozen module constant shared by every client
+    # this process constructs; anything defaulted below is applied to the
+    # RESULT, never to the spec.
+    optspec = ProjectNameSchema::OPTSPEC
 
     sys_fetch = VoxgigStruct.getpath(opts, "system.fetch")
 

package/project/.sdk/tm/rb/utility/struct/voxgig_struct.rb

@@ -1740,7 +1740,30 @@ module VoxgigStruct
       end
 
       inj.keyI = size(inj.keys)
-      inj.setval(inj.dparent, 2)
+
+      # PATCH (optspec port, pending upstream fix): DELETE the `[$ONE, ...]`
+      # node when the data has no value there, as the ts reference does.
+      #
+      # setval carries a deliberate special case - "nil with ancestor: set to
+      # nil in grandparent (preserves key for $ONE/$EXACT)" - where ts deletes
+      # in BOTH branches. The consequence is that an OPTIONAL entry
+      # (`['`$ONE`', <spec>, '`$NIL`']`) the caller OMITTED comes back as a
+      # nil-valued key rather than staying absent, which is exactly what that
+      # encoding exists to prevent. In an SDK's option spec that put an entry
+      # in `options.feature` for every feature the model declares, and the
+      # feature ADD ORDER is derived from those keys.
+      #
+      # Confined to $ONE so $EXACT keeps the behaviour the special case was
+      # written for. ruby cannot tell an absent key from a stored nil here
+      # (getprop answers nil for both), so a stored nil under a $ONE is
+      # dropped too; ts would keep it. That is the narrower of the two
+      # divergences and the one nothing in this SDK relies on.
+      if inj.dparent.nil?
+        delprop(getelem(inj.nodes, -2), getelem(inj.path, -2))
+      else
+        inj.setval(inj.dparent, 2)
+      end
+
       inj.path = inj.path[0...-1]
       inj.key = getelem(inj.path, -1)
 

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

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

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

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

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

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

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

@@ -1,7 +1,7 @@
 // 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.
+// Static modules are templates (same for every API); `config`, `schema` and
+// `sdk` are generated per-API by the sdkgen components.
 
 pub mod config;
 pub mod context;
@@ -12,6 +12,7 @@ pub mod operation;
 pub mod point;
 pub mod response;
 pub mod result;
+pub mod schema;
 pub mod sdk;
 pub mod spec;
 pub mod types;

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

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

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

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

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

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

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

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

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

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