@voxgig/sdkgen 4.8.2 → 4.8.3

package/project/.sdk/tm/elixir/test/vendor/omni/util.ex

@@ -0,0 +1,187 @@
+# VENDORED: @voxgig/omni sdk-20260904-1610-0 (elixir/lib/util.ex)
+# Source: https://github.com/voxgig/omni @ 8c3e1b573a8d35796f7fc45e3226b977023cabf7  [tag: sdk-20260904-1610-0]
+# License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+# Omni internal JSON utilities.
+#
+# Self-contained by design: the omni runner must be able to test *any*
+# library, including libraries that provide these same operations.
+
+defmodule Voxgig.Omni.Util do
+  @moduledoc "JSON value helpers for the omni test runner."
+
+  # Value is JSON null.
+  def nullmark, do: "__NULL__"
+  # Value is not present.
+  def undefmark, do: "__UNDEF__"
+  # Value exists (not undefined).
+  def existsmark, do: "__EXISTS__"
+
+  # Elixir has nil for null, so absence needs its own marker.
+  def absent, do: :"$omni_absent"
+
+  def isabsent(val), do: val == absent()
+
+  def ismap(val), do: is_map(val) and not is_struct(val)
+
+  def islist(val), do: is_list(val)
+
+  def isnode(val), do: ismap(val) or islist(val)
+
+  # A JSON number? Booleans are not numbers.
+  def isnum(val), do: is_number(val) and not is_boolean(val)
+
+  def isstr(val), do: is_binary(val)
+
+  def isnone(val), do: is_nil(val) or isabsent(val)
+
+  @doc "Deep copy a JSON value (Elixir values are immutable)."
+  def clone(val), do: val
+
+  @doc "Read a map entry. Returns the absence marker when missing."
+  def get(val, key) do
+    if ismap(val) do
+      Map.get(val, key, absent())
+    else
+      absent()
+    end
+  end
+
+  def has(val, key), do: ismap(val) and Map.has_key?(val, key)
+
+  @doc "Read a value by path. Returns the absence marker when a step is missing."
+  def getpath(val, path) do
+    Enum.reduce_while(path, val, fn part, current ->
+      cond do
+        islist(current) ->
+          case Integer.parse(to_string(part)) do
+            {index, ""} when index >= 0 ->
+              if index < length(current) do
+                {:cont, Enum.at(current, index)}
+              else
+                {:halt, absent()}
+              end
+
+            _ ->
+              {:halt, absent()}
+          end
+
+        ismap(current) ->
+          if Map.has_key?(current, to_string(part)) do
+            {:cont, Map.get(current, to_string(part))}
+          else
+            {:halt, absent()}
+          end
+
+        true ->
+          {:halt, absent()}
+      end
+    end)
+  end
+
+  @doc "Depth-first walk: children first, then the containing node."
+  def walk(val, apply, path \\ []) do
+    next =
+      cond do
+        islist(val) ->
+          val
+          |> Enum.with_index()
+          |> Enum.map(fn {entry, index} -> walk(entry, apply, path ++ [to_string(index)]) end)
+
+        ismap(val) ->
+          Map.new(val, fn {key, entry} -> {key, walk(entry, apply, path ++ [key])} end)
+
+        true ->
+          val
+      end
+
+    apply.(next, path)
+  end
+
+  @doc "Deep structural equality: numbers by value, bools never numbers."
+  def deepequal(a, b) do
+    cond do
+      is_boolean(a) or is_boolean(b) -> a === b
+      isnum(a) or isnum(b) -> isnum(a) and isnum(b) and a == b
+      isabsent(a) or isabsent(b) -> isabsent(a) and isabsent(b)
+      is_nil(a) or is_nil(b) -> is_nil(a) and is_nil(b)
+      islist(a) or islist(b) -> equal_lists(a, b)
+      ismap(a) or ismap(b) -> equal_maps(a, b)
+      true -> a === b
+    end
+  end
+
+  defp equal_lists(a, b) do
+    islist(a) and islist(b) and length(a) == length(b) and
+      Enum.all?(Enum.zip(a, b), fn {x, y} -> deepequal(x, y) end)
+  end
+
+  defp equal_maps(a, b) do
+    ismap(a) and ismap(b) and map_size(a) == map_size(b) and
+      Enum.all?(a, fn {key, entry} ->
+        Map.has_key?(b, key) and deepequal(entry, Map.get(b, key))
+      end)
+  end
+
+  @doc "Render a number the same way in every port: 5.0 prints as 5."
+  def numstr(val) do
+    asfloat = val / 1
+
+    cond do
+      asfloat == Float.round(asfloat) and abs(asfloat) < 9_007_199_254_740_992.0 ->
+        Integer.to_string(trunc(asfloat))
+
+      true ->
+        Float.to_string(asfloat)
+    end
+  end
+
+  @doc "Render a string as a JSON string literal."
+  def quote_str(val) do
+    escaped =
+      val
+      |> String.to_charlist()
+      |> Enum.map(fn ch ->
+        case ch do
+          ?" -> "\\\""
+          ?\\ -> "\\\\"
+          ?\n -> "\\n"
+          ?\r -> "\\r"
+          ?\t -> "\\t"
+          other when other < 0x20 -> "\\u" <> String.pad_leading(Integer.to_string(other, 16), 4, "0")
+          other -> <<other::utf8>>
+        end
+      end)
+      |> Enum.join()
+
+    "\"" <> escaped <> "\""
+  end
+
+  @doc "Compact JSON text with map keys sorted, identical in every port."
+  def jsonstr(val) do
+    cond do
+      isabsent(val) -> "undefined"
+      is_nil(val) -> "null"
+      is_boolean(val) -> if val, do: "true", else: "false"
+      isstr(val) -> quote_str(val)
+      isnum(val) -> numstr(val)
+      islist(val) -> "[" <> Enum.map_join(val, ",", &jsonstr/1) <> "]"
+      ismap(val) -> "{" <> map_body(val) <> "}"
+      true -> quote_str(inspect(val))
+    end
+  end
+
+  defp map_body(val) do
+    val
+    |> Map.keys()
+    |> Enum.sort()
+    |> Enum.map_join(",", fn key -> quote_str(to_string(key)) <> ":" <> jsonstr(Map.get(val, key)) end)
+  end
+
+  @doc "Strings verbatim, everything else as compact JSON."
+  def stringify(val) do
+    if isstr(val), do: val, else: jsonstr(val)
+  end
+
+  @doc "Render a path as a dotted string."
+  def pathify(path), do: Enum.join(path, ".")
+end

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

@@ -3,23 +3,30 @@ package core
 import (
 	"math/rand"
 	"strconv"
+	"sync"
 
 	vs "github.com/voxgig/struct"
 )
 
 type Context struct {
-	Id       string
-	Out      map[string]any
-	Ctrl     *Control
-	Meta     map[string]any
-	Client   *ProjectNameSDK
-	Utility  *Utility
-	Op       *Operation
-	Point    map[string]any
-	Config   map[string]any
-	Entopts  map[string]any
-	Options  map[string]any
-	Opmap    map[string]*Operation
+	Id      string
+	Out     map[string]any
+	Ctrl    *Control
+	Meta    map[string]any
+	Client  *ProjectNameSDK
+	Utility *Utility
+	Op      *Operation
+	Point   map[string]any
+	Config  map[string]any
+	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
 	Spec     *Spec
@@ -156,10 +163,14 @@ func NewContext(ctxmap map[string]any, basectx *Context) *Context {
 	}
 	if ctx.Opmap == nil && basectx != nil {
 		ctx.Opmap = basectx.Opmap
+		ctx.Opmu = basectx.Opmu
 	}
 	if ctx.Opmap == nil {
 		ctx.Opmap = map[string]*Operation{}
 	}
+	if ctx.Opmu == nil {
+		ctx.Opmu = &sync.Mutex{}
+	}
 
 	// Data
 	ctx.Data = ToMapAny(getCtxProp(ctxmap, "data"))
@@ -237,7 +248,10 @@ func (ctx *Context) resolveOp(opname string) *Operation {
 	}
 	cacheKey := entname + ":" + opname
 
-	if op, ok := ctx.Opmap[cacheKey]; ok && op != nil {
+	ctx.Opmu.Lock()
+	cached, cachedok := ctx.Opmap[cacheKey]
+	ctx.Opmu.Unlock()
+	if op, ok := cached, cachedok; ok && op != nil {
 		return op
 	}
 
@@ -267,13 +281,15 @@ func (ctx *Context) resolveOp(opname string) *Operation {
 	}
 
 	op := NewOperation(map[string]any{
-		"entity":  entname,
-		"name":    opname,
-		"input":   input,
+		"entity": entname,
+		"name":   opname,
+		"input":  input,
 		"points": targets,
 	})
 
+	ctx.Opmu.Lock()
 	ctx.Opmap[cacheKey] = op
+	ctx.Opmu.Unlock()
 	return op
 }
 

package/project/.sdk/tm/go/feature/secrets/plugin/capability.go

@@ -0,0 +1,261 @@
+// VENDORED: @voxgig/plugin 0.1.6 (go/plugin/capability.go)
+// Source: https://github.com/voxgig/plugin @ 8d8968afc0a2008fbd795b41ab166307d989f02a  [tag: sdk-20260904-1610-0]
+// License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+/* Capabilities (§11.1).
+ *
+ * A DEPENDENCY IS ON A CAPABILITY, NOT ON A REF — because it is a
+ * dependency on something that can do the job, and which instance is
+ * doing it is exactly the configuration detail a plugin must not care
+ * about.
+ *
+ * But A BINDING IS TO AN INSTANCE, not to a capability, which is what
+ * decides behaviour when the bound provider leaves while another match
+ * remains. */
+
+package plugin
+
+import (
+	"sort"
+	"strconv"
+	"strings"
+)
+
+type Provided struct {
+	Name     string         `json:"name"`
+	Version  string         `json:"version,omitempty"`
+	Priority *int           `json:"priority,omitempty"`
+	Attrs    map[string]any `json:"attrs,omitempty"`
+}
+
+type Required struct {
+	Name     string         `json:"name"`
+	Range    string         `json:"range,omitempty"`
+	Match    map[string]any `json:"match,omitempty"`
+	Optional bool           `json:"optional,omitempty"`
+	// Policy is §11.3: `static` restarts the consumer when its SELECTED
+	// provider leaves, even though another still matches; `dynamic` says
+	// in writing that it can survive the swap. Static is the default
+	// because most plugins cannot, and the cost of wrongly assuming they
+	// can is a live instance holding a dead reference.
+	Policy string `json:"policy,omitempty"`
+}
+
+type Candidate struct {
+	Ref      string   `json:"ref"`
+	Pos      int      `json:"pos"`
+	Provides Provided `json:"provides"`
+}
+
+// ResolveCapability ranks the matching live providers and returns them
+// best-first: highest `version`, then LOWEST `priority` (default 0),
+// then declaration position `pos` ascending.
+//
+// `priority` is a field on the capability rather than §7's `order` band,
+// because bands live on POINT BINDINGS: a provider may have several
+// bindings with different bands, or none at all, so a rank reaching for
+// one would be undefined in the common case.
+//
+// Without a total rank, "any provider satisfies" is true of the GRAPH
+// and useless to the PLUGIN — two ports could bind different `store`
+// instances, both resolve green, and behave differently, which is
+// precisely the divergence a shared corpus exists to catch.
+func ResolveCapability(req Required, candidates []Candidate) []Candidate {
+	hits := []Candidate{}
+	for _, c := range candidates {
+		if Matches(req, c.Provides) {
+			hits = append(hits, c)
+		}
+	}
+	// SortStable, because the canonical's comparator falls through to
+	// `pos` and JavaScript's sort is stable — a Go quicksort would
+	// reorder equal-`pos` candidates and diverge on nothing the corpus
+	// could name.
+	sort.SliceStable(hits, func(i, j int) bool {
+		a, b := hits[i], hits[j]
+		av, bv := a.Provides.Version, b.Provides.Version
+		if av != bv {
+			// An ABSENT version sorts last, whatever the other is: the
+			// canonical returns 1 for an absent `a` before it ever
+			// compares, so "no version" loses to every version rather
+			// than being read as 0.0.0.
+			if "" == av {
+				return false
+			}
+			if "" == bv {
+				return true
+			}
+			if c := compareversion(bv, av); 0 != c { // highest version FIRST
+				return 0 > c
+			}
+		}
+		ap, bp := priorityof(a.Provides), priorityof(b.Provides)
+		if ap != bp {
+			return ap < bp // lowest priority first
+		}
+		return a.Pos < b.Pos
+	})
+	return hits
+}
+
+func priorityof(p Provided) int {
+	if nil == p.Priority {
+		return 0
+	}
+	return *p.Priority
+}
+
+func Matches(req Required, prov Provided) bool {
+	if req.Name != prov.Name {
+		return false
+	}
+
+	if "" != req.Range {
+		if "" == prov.Version {
+			return false
+		}
+		if !satisfiesq(prov.Version, req.Range) {
+			return false
+		}
+	}
+
+	// `match` is checked against the provider's `attrs`, key by key. A
+	// key the provider does not carry is a miss, not a pass: a
+	// requirement asking for `transactional: true` must not be satisfied
+	// by a provider that never said.
+	if nil != req.Match {
+		attrs := prov.Attrs
+		if nil == attrs {
+			attrs = map[string]any{}
+		}
+		for k, want := range req.Match {
+			got, ok := attrs[k]
+			if !ok || !matchvalue(want, got) {
+				return false
+			}
+		}
+	}
+
+	return true
+}
+
+func compareversion(a string, b string) int {
+	pa, pb := parts(a), parts(b)
+	for i := 0; i < 3; i++ {
+		x, y := at(pa, i), at(pb, i)
+		if x != y {
+			if x < y {
+				return -1
+			}
+			return 1
+		}
+	}
+	return 0
+}
+
+func parts(v string) []int {
+	out := []int{}
+	for _, s := range strings.Split(v, ".") {
+		n, err := strconv.Atoi(s)
+		if nil != err {
+			n = 0
+		}
+		out = append(out, n)
+	}
+	return out
+}
+
+/* PARTIAL MATCH, RECURSING INTO MAPS (§11.1).
+ *
+ * §11.1 says `match` is "a partial match against `attrs`, with exactly
+ * the semantics voxgig/struct and the omni corpus already define for
+ * `match` — every leaf in the requirement must be present and equal in
+ * the capability, keys not mentioned are not checked."
+ *
+ * THE CANONICAL DID NOT IMPLEMENT THAT. It compared `attrs[k] !==
+ * req.match[k]`, which for any compound value is JavaScript reference
+ * identity: a requirement and a capability are declared in different
+ * places and are never the same object, so `match: {limits: {max: 5}}`
+ * could not be satisfied by ANY provider, including one declaring
+ * exactly that. The flat reading is invisible while every corpus entry
+ * is scalar, which is why P4 found it and P2 did not.
+ *
+ * Fixed in the canonical (AGENTS.md: change canonical first), pinned by
+ * `capability/nested`, and ported here. */
+func matchvalue(want any, got any) bool {
+	switch w := want.(type) {
+
+	case map[string]any:
+		g, ok := got.(map[string]any)
+		if !ok {
+			return false
+		}
+		for k, wv := range w {
+			gv, present := g[k]
+			if !present || !matchvalue(wv, gv) {
+				return false
+			}
+		}
+		return true
+
+	case []any:
+		g, ok := got.([]any)
+		if !ok || len(g) != len(w) {
+			return false
+		}
+		for i := range w {
+			if !matchvalue(w[i], g[i]) {
+				return false
+			}
+		}
+		return true
+
+	default:
+		// GO HAS MANY NUMBER TYPES AND THE MODEL HAS ONE. Corpus JSON
+		// decodes every number as float64, but a Go host declaring
+		// `Attrs: map[string]any{"max": 5}` writes an int, and `any(5)
+		// == any(5.0)` is false — so an attribute that matched in every
+		// other port silently missed here. Canonical is type-strict
+		// between KINDS (`true` never matches `1`), not between Go's
+		// spellings of one kind.
+		if wn, wok := numval(want); wok {
+			if gn, gok := numval(got); gok {
+				return wn == gn
+			}
+			return false
+		}
+		return want == got
+	}
+}
+
+// numval reports a value's numeric value, and whether it had one. `bool`
+// is deliberately absent: Go does not make it numeric and neither does
+// the model.
+func numval(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
+	}
+	return 0, false
+}

package/project/.sdk/tm/go/feature/secrets/plugin/catalog.go

@@ -0,0 +1,78 @@
+// VENDORED: @voxgig/plugin 0.1.6 (go/plugin/catalog.go)
+// Source: https://github.com/voxgig/plugin @ 8d8968afc0a2008fbd795b41ab166307d989f02a  [tag: sdk-20260904-1610-0]
+// License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+/* The definition catalog (§10.1).
+ *
+ * A definition is registered once and may back many instances. Option
+ * shapes are validated AT REGISTRATION, not when a document happens to
+ * exercise a key — so a malformed shape fails once, and in the same
+ * place everywhere (§9.4). */
+
+package plugin
+
+// Definition is what a plugin author writes.
+//
+// GO RETURNS ERRORS FROM LIFECYCLE CALLBACKS (§18, P4). The canonical
+// throws; a Go callback returns `error`, and the host treats a non-nil
+// return exactly as the canonical treats a throw — including
+// `plugin_activate_failed`'s unwind and the `failed` status.
+type Definition struct {
+	Name        string
+	Shape       any
+	Define      func(inst *Inst) error
+	Activate    func(inst *Inst) error
+	Deactivate  func(inst *Inst) error
+	Close       func(inst *Inst) error
+	Reconfigure func(inst *Inst, options map[string]any, previous map[string]any) error
+}
+
+type Catalog struct {
+	defs map[string]Definition
+}
+
+// MakeCatalog builds a catalog, adding each definition in turn.
+//
+// GO IS TIER S (§10.3): "package `init()` registration ... or an
+// explicit list handed to makeHost", and both spellings land here. A Go
+// developer's experience is "add the import, add one line to the config"
+// rather than "write a factory".
+func MakeCatalog(defs ...Definition) (*Catalog, error) {
+	c := &Catalog{defs: map[string]Definition{}}
+	for _, d := range defs {
+		if err := c.Add(d); nil != err {
+			return nil, err
+		}
+	}
+	return c, nil
+}
+
+func (c *Catalog) Add(def Definition) error {
+	if !CheckName(def.Name) {
+		return Fail("plugin_definition_name", "invalid definition name: "+def.Name, nil)
+	}
+	// Validate the shape HERE. Deferring it to resolution time means a
+	// malformed shape surfaces at a different moment in every host that
+	// loads it, which is the divergence the stated domain exists to
+	// prevent.
+	if nil != def.Shape {
+		if err := CheckShape(def.Shape); nil != err {
+			return err
+		}
+	}
+	c.defs[def.Name] = def
+	return nil
+}
+
+func (c *Catalog) Get(name string) (Definition, bool) {
+	d, ok := c.defs[name]
+	return d, ok
+}
+
+func (c *Catalog) Has(name string) bool {
+	_, ok := c.defs[name]
+	return ok
+}
+
+func (c *Catalog) Names() []string {
+	return sortedkeys(c.defs)
+}