@voxgig/sdkgen 4.30.0 → 4.30.1

package/project/.sdk/tm/rust/feature/secrets/plugin/config.rs

@@ -1,20 +1,6 @@
-// VENDORED: @voxgig/plugin sdk-20260917-1242-0 (rust/src/config.rs)
-// Source: https://github.com/voxgig/plugin @ 721de3a1bb5ac879b5c118dd9fc55c474a8730c4  [tag: sdk-20260917-1242-0]
+// VENDORED: @voxgig/plugin sdk-20260925-1316-0 (rust/src/config.rs)
+// Source: https://github.com/voxgig/plugin @ 43acbf266b0dbcf52e5ab5463d85c822da9cd234  [tag: sdk-20260925-1316-0]
 // License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
-//! The declarative document (§9): normalization, and the ten-level
-//! precedence ladder.
-//!
-//! TWO FUNCTIONS, AND THE SPLIT BETWEEN THEM IS FORCED.
-//!
-//! `normalize_config` normalizes STRUCTURE and ENTRY KEYS. It does not
-//! merge options, and cannot: §9.4 makes merge behaviour a property of the
-//! definition's option SHAPE, which normalization has never seen. A
-//! normalizer that flattened the option layers would make `$MERGE: append`
-//! unimplementable at load time, because the layers it must concatenate
-//! would already be collapsed.
-//!
-//! `resolve_options` applies the ladder, and it is the only place that
-//! knows the shape.
 
 use std::collections::BTreeMap;
 
@@ -32,11 +18,6 @@ pub fn normalize_config(input: &Value) -> Result<Value, PluginError> {
     let reserved = input.get("reserved");
     let profile = input.get("profile");
 
-    // The rename is applied at TWO PLACES AND NO OTHERS: the document
-    // root, and every profile.<name> overlay root (§9.1). A rename applied
-    // only at the root would leave `profile.prod.sdk` untranslated and
-    // silently drop every environment override the host depends on.
-    // Recursing further would be worse: option data is the definition's.
     let baseinst = doc.get(&ikey);
     let basedef = doc.get(&dkey);
 
@@ -85,16 +66,10 @@ pub fn normalize_config(input: &Value) -> Result<Value, PluginError> {
         let b = base.0.get(eref);
         let o = over.0.get(eref);
 
-        // MERGE THE ENTRIES AS AUTHORED, THEN APPLY DEFAULTS TO THE RESULT
-        // (§9.3). A safety rule, not a tidiness one: if the overlay had
-        // its defaults filled in before merging it would carry a
-        // synthesized active:true and overwrite a base's false - silently
-        // re-enabling a deliberately disabled integration in production.
         let active = config_pick(o, "active", config_pick(b, "active", Value::Bool(true)));
         let start = config_pick(o, "start", config_pick(b, "start", Value::str("eager")));
         let block = config_pick(o, "order", config_pick(b, "order", Value::Null));
 
-        // Option layers, levels 3-6, IN LADDER ORDER. Never merged here.
         let nm = refname(eref);
         let mut layers: Vec<Value> = Vec::new();
         let bd = basedef.get(&nm);
@@ -205,9 +180,6 @@ fn config_pick(src: Option<&Value>, key: &str, dflt: Value) -> Value {
     }
 }
 
-// ---------------------------------------------------------------------
-// resolve_options - §9.3's ten levels, and 9.4's directives
-// ---------------------------------------------------------------------
 
 pub fn resolve_options(input: &Value) -> Result<Value, PluginError> {
     let shape = input.get("shape");
@@ -228,22 +200,17 @@ pub fn resolve_options(input: &Value) -> Result<Value, PluginError> {
         Value::map()
     };
 
-    // ONE ordered merge, lowest to highest. Levels 3-6 are not two
-    // namespaces collapsed separately and composed afterwards: that
-    // inverts the rule that PROFILE SPECIFICITY OUTRANKS DEFINITION
-    // SPECIFICITY, so a prod per-definition default would lose to a base
-    // instance value.
     let layers = [
-        config_defaultsof(&shape),                              // 1
-        input.get("hostdefaults"),                              // 2
-        config_optsof(&doc.get("default"), &name)?,             // 3
-        config_optsof(&doc.get("instance"), &eref)?,            // 4
-        config_optsof(&overlay.get("default"), &name)?,         // 5
-        config_optsof(&overlay.get("instance"), &eref)?,        // 6
-        input.get("env"),                                       // 7
-        input.get("hostoptions"),                               // 8
-        input.get("loadoptions"),                               // 9
-        input.get("patch"),                                     // 10
+        config_defaultsof(&shape),
+        input.get("hostdefaults"),
+        config_optsof(&doc.get("default"), &name)?,
+        config_optsof(&doc.get("instance"), &eref)?,
+        config_optsof(&overlay.get("default"), &name)?,
+        config_optsof(&overlay.get("instance"), &eref)?,
+        input.get("env"),
+        input.get("hostoptions"),
+        input.get("loadoptions"),
+        input.get("patch"),
     ];
 
     let mut out = Value::map();
@@ -256,7 +223,6 @@ pub fn resolve_options(input: &Value) -> Result<Value, PluginError> {
     Ok(out)
 }
 
-/// The shape's non-directive values are the level-1 defaults.
 fn config_defaultsof(shape: &Value) -> Value {
     let mut out = Value::map();
     for k in shape.keys() {
@@ -274,7 +240,6 @@ fn config_optsof(src: &Value, key: &str) -> Result<Value, PluginError> {
         return Ok(Value::Null);
     }
 
-    // The array form is equivalent to the map form (§9.1).
     if let Some(items) = src.as_list() {
         for item in items.iter() {
             if canon_ref(&item.get("ref"))? == key {
@@ -297,10 +262,6 @@ fn config_optsof(src: &Value, key: &str) -> Result<Value, PluginError> {
     Ok(Value::Null)
 }
 
-/// Merge ONE layer onto the accumulator, honouring the shape's directives.
-/// The directive holds at EVERY precedence level, not only between
-/// document levels - §9.4 makes it a property of the shape, which does not
-/// know which layer a value arrived from.
 fn config_mergeone(base: &Value, over: &Value, shape: &Value) -> Value {
     if over.is_null() {
         return base.clone();
@@ -344,7 +305,6 @@ fn config_mergeone(base: &Value, over: &Value, shape: &Value) -> Value {
     Value::Map(out)
 }
 
-/// Merge N levels below this key, replace below that.
 fn config_deepto(base: &Value, over: &Value, n: f64) -> Value {
     if n <= 0.0 {
         return over.clone();
@@ -361,11 +321,6 @@ fn config_deepto(base: &Value, over: &Value, n: f64) -> Value {
     Value::Map(out)
 }
 
-/// §9.4: N is an integer of at least 1, and everything else is an error.
-///
-/// `{"deep": 0}` is rejected DESPITE having an obvious reading, because
-/// "replace at this key" already has a spelling and two spellings for one
-/// behaviour is the defect class this repo exists to avoid.
 pub fn check_shape(shape: &Value) -> Result<(), PluginError> {
     if shape.as_map().is_none() {
         return Ok(());

package/project/.sdk/tm/rust/feature/secrets/plugin/depend.rs

@@ -1,32 +1,6 @@
-// VENDORED: @voxgig/plugin sdk-20260917-1242-0 (rust/src/depend.rs)
-// Source: https://github.com/voxgig/plugin @ 721de3a1bb5ac879b5c118dd9fc55c474a8730c4  [tag: sdk-20260917-1242-0]
+// VENDORED: @voxgig/plugin sdk-20260925-1316-0 (rust/src/depend.rs)
+// Source: https://github.com/voxgig/plugin @ 43acbf266b0dbcf52e5ab5463d85c822da9cd234  [tag: sdk-20260925-1316-0]
 // License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
-//! Dependency cardinality, policy, and the restart graph (§11.3).
-//!
-//! TWO AXES, BOTH DECLARED BY THE DEFINITION THAT HAS THE REQUIREMENT,
-//! because only it knows what it can cope with:
-//!
-//! ```text
-//!                | static (default)          | dynamic
-//!   -------------|---------------------------|--------------------------
-//!   mandatory    | unmet -> pending;         | unmet -> pending;
-//!   (default)    | lost  -> pending,         | lost  -> STAYS LIVE,
-//!                |          recursively      |          notified
-//!   -------------|---------------------------|--------------------------
-//!   optional:true| never gates activation;   | never gates activation;
-//!                | a change deactivates and  | a change is a
-//!                | reactivates               | notification, nothing else
-//! ```
-//!
-//! `dynamic` means the plugin has said, IN WRITING, that it can survive
-//! its provider being swapped underneath it. It is not the default because
-//! most plugins cannot, and the cost of wrongly assuming they can is a
-//! live instance holding a dead reference.
-//!
-//! The rebinding-preference axis is deliberately omitted. OSGi has
-//! reluctant vs greedy and it is a knob every author must understand to
-//! read anyone else's component; we take always-reluctant. Three axes were
-//! more than the model can carry across twenty ports.
 
 use std::collections::{BTreeMap, BTreeSet};
 
@@ -47,20 +21,6 @@ pub fn normrequire(raw: &Value) -> Value {
     }
 }
 
-/// The requirements a definition declared, normalized.
-///
-/// BOTH AXES ARE READ AT TWO LEVELS, AND THE PER-REQUIREMENT ONE WINS.
-///
-/// The instance-level `policy` and `optional` list are how a DOCUMENT
-/// states the axis without editing the definition, and they apply to every
-/// requirement. The per-requirement form is the one §11.1's object syntax
-/// exists for, and it is strictly more expressive: an instance that is
-/// `static` on its store and `dynamic` on its metrics cannot be written at
-/// all at the instance level.
-///
-/// `optional` unions rather than overriding - both spellings are
-/// statements that this requirement need not gate activation, and there is
-/// no reading under which one of them means "actually, mandatory".
 pub fn requirements(options: &Value) -> Vec<Value> {
     let raw = options.get("requires");
     let marked = options.get("optional");
@@ -84,65 +44,26 @@ pub fn requirements(options: &Value) -> Vec<Value> {
     out
 }
 
-/// Does losing this requirement's SELECTED provider restart the consumer?
-/// The mandatory ones under `static`, and the `static` optional ones -
-/// both make a capability change deactivate and reactivate. `dynamic`
-/// never restarts.
 pub fn restartsonloss(req: &Value) -> bool {
     let policy = req.get("policy");
     policy.as_str().unwrap_or("static") != "dynamic"
 }
 
-/// Does an unmet requirement keep the consumer out of `live`?
-///
-/// Cardinality alone decides this, NOT policy. `dynamic` is a statement
-/// about surviving a SWAP, not about starting without the thing at all - a
-/// mandatory-dynamic consumer still waits in `pending` for its first
-/// provider.
 pub fn gatesactivation(req: &Value) -> bool {
     !matches!(req.get("optional"), Value::Bool(true))
 }
 
-/// Edges that can cause a restart, which is exactly the set a cycle must
-/// be detected over (§11.3).
-///
-/// ONLY `dynamic` OPTIONAL EDGES ARE EXCLUDED, and they are the ones the
-/// exclusion was for: two plugins that optionally and dynamically consume
-/// each other's capabilities both activate happily, neither gates on the
-/// other, and each is merely notified when the other appears. Nothing
-/// restarts, so nothing oscillates.
-///
-/// An earlier draft of §11.3 excluded EVERY optional edge and thereby
-/// admitted the non-terminating case it was trying to permit.
 pub fn restartcausing(req: &Value) -> bool {
     gatesactivation(req) || restartsonloss(req)
 }
 
-/// One node of the requirement graph, as plain data for the pure detector.
 pub struct Node {
     pub eref: String,
     pub provides: Vec<String>,
     pub requires: Vec<Value>,
 }
 
-/// A cycle through restart-causing requirements is
-/// `plugin_dependency_cycle`, detected AT LOAD - before anything runs,
-/// because the failure it describes is a non-terminating reconcile and the
-/// only safe time to report that is before it starts.
-///
-/// The graph is over capabilities, not refs: an edge runs from a consumer
-/// to EVERY node that provides what it needs, because any of them could be
-/// the one selected and a cycle through any is a cycle. A node also
-/// satisfies its own name as a ref (§11.1), which is why the ref is a
-/// provider of itself here.
 pub fn dependencycycle(nodes: &[Node]) -> Option<Vec<String>> {
-    // TWO INDEXES, NOT ONE MERGED MAP. Capability names and refs are
-    // matched differently - a capability by its exact name, a ref through
-    // the canonical spelling (section 4 rule 5) - and one map keyed by
-    // both can only do one of them. Keyed by both and looked up raw, as
-    // this was, a cycle spelled `a$`/`b$` found no providers and EVADED
-    // the load-time check that exists to catch a non-terminating
-    // reconcile.
     let mut bycap: BTreeMap<String, Vec<String>> = BTreeMap::new();
     let mut isref: BTreeSet<String> = BTreeSet::new();
     for n in nodes.iter() {
@@ -180,8 +101,6 @@ pub fn dependencycycle(nodes: &[Node]) -> Option<Vec<String>> {
         edges.insert(n.eref.clone(), out);
     }
 
-    // Iterative DFS with an explicit stack: twenty ports, and several of
-    // them have no recursion budget worth relying on.
     const WHITE: u8 = 0;
     const GREY: u8 = 1;
     const BLACK: u8 = 2;

package/project/.sdk/tm/rust/feature/secrets/plugin/env.rs

@@ -1,24 +1,6 @@
-// VENDORED: @voxgig/plugin sdk-20260917-1242-0 (rust/src/env.rs)
-// Source: https://github.com/voxgig/plugin @ 721de3a1bb5ac879b5c118dd9fc55c474a8730c4  [tag: sdk-20260917-1242-0]
+// VENDORED: @voxgig/plugin sdk-20260925-1316-0 (rust/src/env.rs)
+// Source: https://github.com/voxgig/plugin @ 43acbf266b0dbcf52e5ab5463d85c822da9cd234  [tag: sdk-20260925-1316-0]
 // License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
-//! Environment overrides (§9.5) - level 7 of the ladder.
-//!
-//! One prefix, so nothing drifts: `VOXGIG_PLUGIN_*`.
-//!
-//! ```text
-//!   VOXGIG_PLUGIN_PROFILE            the profile name
-//!   VOXGIG_PLUGIN_<REF>_<PATH>       one option
-//!   VOXGIG_PLUGIN_ACTIVE/INACTIVE    comma-separated refs, INACTIVE wins
-//! ```
-//!
-//! THE ENCODING IS LOSSY, AND THIS SAYS SO RATHER THAN PRETENDING
-//! OTHERWISE. Ref and path are upper-snake with `$` -> `__` and `.` ->
-//! `_`. But `_` is legal in a name and in a tag, and the mapping folds
-//! case, so `retry$fast` and `retry__fast` both encode to `RETRY__FAST`.
-//!
-//! Rather than restrict a grammar the rest of the stack already uses, the
-//! host DETECTS THE COLLISION: it encodes every ref it holds, and a key
-//! two refs claim is `plugin_env_ambiguous`, naming both.
 
 use std::collections::BTreeMap;
 
@@ -28,7 +10,6 @@ use super::value::{self, Value};
 
 pub const ENV_PREFIX: &str = "VOXGIG_PLUGIN_";
 
-/// `retry$fast` -> `RETRY__FAST`.
 pub fn encode_ref(eref: &str) -> String {
     eref.replace('$', "__").replace('.', "_").to_uppercase()
 }
@@ -76,8 +57,6 @@ pub fn apply_env(input: &Value) -> Result<Value, PluginError> {
         );
     }
 
-    // Longest encoded ref first, so `retry$fast` wins over `retry` on
-    // `RETRY__FAST_MIN`. Shortest-first would read the tag as a path.
     let mut encoded: Vec<String> = byencoded.keys().cloned().collect();
     stable_sort_by(&mut encoded, |e| -(e.len() as i64));
 
@@ -97,11 +76,6 @@ pub fn apply_env(input: &Value) -> Result<Value, PluginError> {
             let mut list = out.get(field).as_list().cloned().unwrap_or_default();
             for raw in env_split(&env.get(&key)) {
                 let eref = canon_ref(&Value::str(&raw))?;
-                // The reservation covers EVERY input layer (§9.1).
-                // VOXGIG_PLUGIN_INACTIVE=station is easier to set than
-                // editing a config file, and INACTIVE has the final word -
-                // so guarding documents alone would leave the one lever
-                // this mechanism exists to deny wide open.
                 env_checkreserved(&eref, &reserved)?;
                 list.push(Value::str(&eref));
             }
@@ -145,10 +119,6 @@ pub fn apply_env(input: &Value) -> Result<Value, PluginError> {
     Ok(out)
 }
 
-/// Write a value at a dotted path, creating maps on the way down. A map is
-/// REPLACED when the path needs to descend through a scalar - the same
-/// rule every other port applies, and the reason it is written out here is
-/// that rust cannot express it as a chain of `//=`.
 fn set_path(node: &mut Value, path: &[String], value: Value) {
     if 1 == path.len() {
         node.set(&path[0], value);
@@ -189,9 +159,6 @@ fn env_checkreserved(eref: &str, reserved: &Value) -> Result<(), PluginError> {
     )
 }
 
-/// Values parse as JSON, FALLING BACK TO STRING - so `8080` is a number,
-/// `true` is a boolean, `{"a":1}` is a map, and `hello` is the string it
-/// looks like rather than a parse error.
 fn env_parsevalue(value: &Value) -> Value {
     match value.as_str() {
         Some(text) => value::parse(text).unwrap_or_else(|_| value.clone()),

package/project/.sdk/tm/rust/feature/secrets/plugin/export.rs

@@ -1,17 +1,6 @@
-// VENDORED: @voxgig/plugin sdk-20260917-1242-0 (rust/src/export.rs)
-// Source: https://github.com/voxgig/plugin @ 721de3a1bb5ac879b5c118dd9fc55c474a8730c4  [tag: sdk-20260917-1242-0]
+// VENDORED: @voxgig/plugin sdk-20260925-1316-0 (rust/src/export.rs)
+// Source: https://github.com/voxgig/plugin @ 43acbf266b0dbcf52e5ab5463d85c822da9cd234  [tag: sdk-20260925-1316-0]
 // License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
-//! Exports (§11).
-//!
-//! An instance publishes values for other plugins and for the application.
-//! Read with `host.exports("retry$fast/client")`.
-//!
-//! THE UNQUALIFIED ALIAS IS THE INTERESTING PART. `retry/client` resolves
-//! to the UNTAGGED instance if one exists; if not, and exactly one tagged
-//! instance exports that key, it resolves to that one; if two do, it is
-//! `plugin_export_ambiguous` - deliberately diverging from seneca's silent
-//! last-wins, because with multi-instance as a headline feature an
-//! ambiguous alias is a defect waiting for production.
 
 use super::refs::{canon, parse_ref, refname};
 use super::types::{details, fail, PluginError};

package/project/.sdk/tm/rust/feature/secrets/plugin/graph.rs

@@ -1,23 +1,6 @@
-// VENDORED: @voxgig/plugin sdk-20260917-1242-0 (rust/src/graph.rs)
-// Source: https://github.com/voxgig/plugin @ 721de3a1bb5ac879b5c118dd9fc55c474a8730c4  [tag: sdk-20260917-1242-0]
+// VENDORED: @voxgig/plugin sdk-20260925-1316-0 (rust/src/graph.rs)
+// Source: https://github.com/voxgig/plugin @ 43acbf266b0dbcf52e5ab5463d85c822da9cd234  [tag: sdk-20260925-1316-0]
 // License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
-//! Whole-graph resolution (§11.4) - a phase, not a discovery.
-//!
-//! "Activate, and wait in `pending` if you must" is correct and, on its
-//! own, produces a terrible experience: apply twenty instances against a
-//! registry missing one thing and you get NINETEEN pending rows and no
-//! statement of what is actually wrong.
-//!
-//! `resolve_graph` is a PURE FUNCTION of the registry and the intended
-//! activation set. No callbacks run, no state changes, nothing is touched.
-//! It answers for the whole graph at once which instances can be live, and
-//! for each blocked one THE SPECIFIC REQUIREMENT that is unmet, and why.
-//!
-//! The failure mode being designed against is a famous one: OSGi's
-//! resolver is correct and its diagnostics are legendarily unusable. A
-//! resolver that says "blocked" without saying WHY has moved the problem
-//! rather than solved it, so `why` is part of the contract and the corpus
-//! pins its shape.
 
 use std::collections::{BTreeMap, BTreeSet};
 
@@ -36,10 +19,6 @@ pub fn resolve_graph(nodes: &Value) -> Value {
     let mut resolved: BTreeSet<String> = BTreeSet::new();
     let mut blocked: BTreeMap<String, Value> = BTreeMap::new();
 
-    // Fixed point: a node resolves when every mandatory requirement is met
-    // by an ALREADY-RESOLVED provider. Iterating to a fixed point is what
-    // makes a provider that is itself blocked propagate, rather than each
-    // node being judged against the raw registry.
     let mut moved = true;
     while moved {
         moved = false;
@@ -78,10 +57,6 @@ pub fn resolve_graph(nodes: &Value) -> Value {
     out
 }
 
-/// The FIRST unmet requirement, with the most specific explanation
-/// available. Order matters: "no provider at all" and "a provider at the
-/// wrong version" are different problems and a reader must not have to
-/// guess which they have.
 fn firstunmet(
     node: &Value,
     byref: &BTreeMap<String, Value>,