@voxgig/sdkgen 4.8.2 → 4.9.0

package/project/.sdk/tm/php/test/vendor/omni/Util.php

@@ -0,0 +1,283 @@
+<?php
+// VENDORED: @voxgig/omni sdk-20260907-0029-0 (php/src/Util.php)
+// Source: https://github.com/voxgig/omni @ 274708cc2d12b21707d975543953f845f8444be0  [tag: sdk-20260907-0029-0]
+// License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+
+/**
+ * Omni internal JSON utilities.
+ *
+ * This module is deliberately self-contained: the omni runner must be able
+ * to test *any* library, including libraries that provide these same
+ * operations, so it can never borrow them from the system under test.
+ * Zero third-party dependencies, by design.
+ *
+ * NOTE: JSON is decoded into associative arrays, so an empty map and an
+ * empty list are the same PHP value. This is the one place where the PHP
+ * port cannot distinguish two spec values that other ports can.
+ */
+
+declare(strict_types=1);
+
+namespace Voxgig\Omni;
+
+/** PHP has no `undefined`, so absence needs its own marker. */
+final class Absent
+{
+    private static ?Absent $instance = null;
+
+    public static function mark(): Absent
+    {
+        if (null === self::$instance) {
+            self::$instance = new Absent();
+        }
+        return self::$instance;
+    }
+
+    public function __toString(): string
+    {
+        return 'ABSENT';
+    }
+}
+
+final class Util
+{
+    public const NULLMARK = '__NULL__';     // Value is JSON null.
+    public const UNDEFMARK = '__UNDEF__';   // Value is not present.
+    public const EXISTSMARK = '__EXISTS__'; // Value exists (not undefined).
+
+    /** A map (JSON object)? */
+    public static function ismap($val): bool
+    {
+        return is_array($val) && !array_is_list($val);
+    }
+
+    /** A list (JSON array)? */
+    public static function islist($val): bool
+    {
+        return is_array($val) && array_is_list($val);
+    }
+
+    /** A container (map or list)? */
+    public static function isnode($val): bool
+    {
+        return is_array($val);
+    }
+
+    /** A JSON number? Booleans are not numbers. */
+    public static function isnum($val): bool
+    {
+        return (is_int($val) || is_float($val)) && !is_bool($val);
+    }
+
+    public static function isabsent($val): bool
+    {
+        return $val instanceof Absent;
+    }
+
+    /** Deep copy a JSON value. Other values pass through by reference. */
+    public static function clone($val)
+    {
+        if (is_array($val)) {
+            $out = [];
+            foreach ($val as $key => $subval) {
+                $out[$key] = self::clone($subval);
+            }
+            return $out;
+        }
+
+        return $val;
+    }
+
+    /** Read a value by path. Returns Absent when any step is missing. */
+    public static function getpath($val, array $path)
+    {
+        $current = $val;
+
+        foreach ($path as $part) {
+            if (self::islist($current)) {
+                if (!is_numeric($part)) {
+                    return Absent::mark();
+                }
+                $index = (int) $part;
+                if ($index < 0 || $index >= count($current)) {
+                    return Absent::mark();
+                }
+                $current = $current[$index];
+            } elseif (is_array($current)) {
+                $key = (string) $part;
+                if (!array_key_exists($key, $current)) {
+                    return Absent::mark();
+                }
+                $current = $current[$key];
+            } else {
+                return Absent::mark();
+            }
+        }
+
+        return $current;
+    }
+
+    /** Depth-first walk: children first, then the containing node. */
+    public static function walk($val, callable $apply, $key = null, $parent = null, ?array $path = null)
+    {
+        $curpath = null === $path ? [] : $path;
+
+        if (is_array($val)) {
+            foreach (array_keys($val) as $childkey) {
+                $childpath = $curpath;
+                $childpath[] = $childkey;
+                $val[$childkey] = self::walk($val[$childkey], $apply, $childkey, $val, $childpath);
+            }
+        }
+
+        return $apply($key, $val, $parent, $curpath);
+    }
+
+    /** Deep structural equality: numbers by value, bools never numbers. */
+    public static function deepequal($a, $b): bool
+    {
+        if (is_bool($a) || is_bool($b)) {
+            return $a === $b;
+        }
+
+        if (self::isnum($a) && self::isnum($b)) {
+            // NaN equals NaN: deepequal is structural, not IEEE (as canonical).
+            return (float) $a === (float) $b
+                || (is_nan((float) $a) && is_nan((float) $b));
+        }
+
+        if (self::isabsent($a) || self::isabsent($b)) {
+            return $a === $b;
+        }
+
+        if (null === $a || null === $b) {
+            return $a === $b;
+        }
+
+        if (is_array($a) && is_array($b)) {
+            if (count($a) !== count($b)) {
+                return false;
+            }
+            if (self::islist($a) !== self::islist($b) && 0 < count($a)) {
+                return false;
+            }
+            foreach ($a as $key => $val) {
+                if (!array_key_exists($key, $b)) {
+                    return false;
+                }
+                if (!self::deepequal($val, $b[$key])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        if (is_array($a) !== is_array($b)) {
+            return false;
+        }
+
+        return $a === $b;
+    }
+
+    /** Render a number the same way in every port: 5.0 prints as 5. */
+    public static function numstr($val): string
+    {
+        if (is_float($val)) {
+            if (is_nan($val) || is_infinite($val)) {
+                return 'null';
+            }
+            if ($val === floor($val) && abs($val) < 9007199254740992.0) {
+                return (string) (int) $val;
+            }
+            return rtrim(rtrim(sprintf('%.17g', $val), '0'), '.');
+        }
+
+        return (string) $val;
+    }
+
+    public static function quote($val): string
+    {
+        $out = '"';
+        $text = (string) $val;
+        $len = strlen($text);
+        for ($i = 0; $i < $len; $i++) {
+            $char = $text[$i];
+            if ('"' === $char) {
+                $out .= '\\"';
+            } elseif ('\\' === $char) {
+                $out .= '\\\\';
+            } elseif ("\n" === $char) {
+                $out .= '\\n';
+            } elseif ("\r" === $char) {
+                $out .= '\\r';
+            } elseif ("\t" === $char) {
+                $out .= '\\t';
+            } elseif (ord($char) < 0x20) {
+                $out .= sprintf('\\u%04x', ord($char));
+            } else {
+                $out .= $char;
+            }
+        }
+        return $out . '"';
+    }
+
+    /** Compact JSON text with map keys sorted, identical in every port. */
+    public static function jsonstr($val): string
+    {
+        if (self::isabsent($val)) {
+            return 'undefined';
+        }
+
+        if (null === $val) {
+            return 'null';
+        }
+
+        if (is_bool($val)) {
+            return $val ? 'true' : 'false';
+        }
+
+        if (is_string($val)) {
+            return self::quote($val);
+        }
+
+        if (self::isnum($val)) {
+            return self::numstr($val);
+        }
+
+        if (self::islist($val)) {
+            $parts = [];
+            foreach ($val as $entry) {
+                $parts[] = self::jsonstr($entry);
+            }
+            return '[' . implode(',', $parts) . ']';
+        }
+
+        if (is_array($val)) {
+            $keys = array_map('strval', array_keys($val));
+            sort($keys);
+            $parts = [];
+            foreach ($keys as $key) {
+                $parts[] = self::quote($key) . ':' . self::jsonstr($val[$key]);
+            }
+            return '{' . implode(',', $parts) . '}';
+        }
+
+        if (is_callable($val)) {
+            return '[Function]';
+        }
+
+        return self::quote((string) $val);
+    }
+
+    /** Strings verbatim, everything else as compact JSON. */
+    public static function stringify($val): string
+    {
+        return is_string($val) ? $val : self::jsonstr($val);
+    }
+
+    /** Render a path as a dotted string. */
+    public static function pathify(?array $path): string
+    {
+        return implode('.', array_map('strval', $path ?? []));
+    }
+}

package/project/.sdk/tm/php/utility/MakeSpec.php

@@ -37,13 +37,20 @@ class ProjectNameMakeSpec
             'suffix' => $suffix, 'step' => 'start',
         ]);
 
-        $ctx->spec->method = ($utility->prepare_method)($ctx);
+        // prepare_method answers null for an op name outside the convention
+        // (mirrors the ts reference, where methodMap[key] is undefined) -
+        // which then fails the allow check below, never a TypeError and
+        // never a silently-allowed empty method.
+        $method = ($utility->prepare_method)($ctx);
 
         $allow_method = \Voxgig\Struct\Struct::getpath($options, 'allow.method') ?? '';
-        if (strpos($allow_method, $ctx->spec->method) === false) {
+        if (!is_string($method) || '' === $method
+            || strpos($allow_method, $method) === false) {
+            $shown = is_string($method) ? $method : '';
             return [null, $ctx->make_error('spec_method_allow',
-                "Method \"{$ctx->spec->method}\" not allowed by SDK option allow.method value: \"{$allow_method}\"")];
+                "Method \"{$shown}\" not allowed by SDK option allow.method value: \"{$allow_method}\"")];
         }
+        $ctx->spec->method = $method;
 
         $ctx->spec->params = ($utility->prepare_params)($ctx);
         $ctx->spec->query = ($utility->prepare_query)($ctx);

package/project/.sdk/tm/php/utility/PrepareBody.php

@@ -8,7 +8,13 @@ class ProjectNamePrepareBody
     public static function call(ProjectNameContext $ctx): mixed
     {
         if ($ctx->op->input === 'data') {
-            return ($ctx->utility->transform_request)($ctx);
+            $body = ($ctx->utility->transform_request)($ctx);
+            // PHP cannot tell an empty map from an empty list, and this
+            // vendored struct answers [] where the canonical transform
+            // answers NO VALUE for a reference that resolves to nothing -
+            // collapse both to "no body" (the shared corpus pins the
+            // missing-reference case to null).
+            return (is_array($body) && 0 === count($body)) ? null : $body;
         }
         return null;
     }

package/project/.sdk/tm/php/utility/PrepareMethod.php

@@ -14,7 +14,7 @@ class ProjectNamePrepareMethod
         'patch' => 'PATCH',
     ];
 
-    public static function call(ProjectNameContext $ctx): string
+    public static function call(ProjectNameContext $ctx): ?string
     {
         // The API definition is authoritative: a POST-only or PATCH-based API
         // exposes `update` as POST or PATCH, not the PUT the op name implies.
@@ -27,6 +27,10 @@ class ProjectNamePrepareMethod
             }
         }
 
-        return self::METHOD_MAP[$ctx->op->name] ?? 'GET';
+        // No default: an op name outside the convention resolves to no method,
+        // exactly as the ts reference (`methodMap[key]` is undefined there).
+        // The silent-pass inline runner hid a stray 'GET' fallback here; the
+        // shared corpus (prepareMethod, opname "bad" -> null) pins it now.
+        return self::METHOD_MAP[$ctx->op->name] ?? null;
     }
 }

package/project/.sdk/tm/py/pkg/feature/secrets/voxgig_plugin/__init__.py

@@ -0,0 +1,36 @@
+# VENDORED: @voxgig/plugin 0.1.6 (python/voxgig_plugin/__init__.py)
+# Source: https://github.com/voxgig/plugin @ b48ae643eb0eb56c5ebe3198da98cecdf6a7f7fc  [tag: sdk-20260907-0029-0]
+# License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+"""The canonical surface `make parity` checks (AGENTS.md section 4).
+
+Small on purpose (section 19): everything else is methods on the host and
+instance types, because a library that grows a second public entry point
+per feature is a library twenty ports pay for twice.
+"""
+
+from .types import PluginError, formaterror, codeof, DETAIL_ORDER, STATUSES
+from .ref import parse_ref, format_ref, check_name, check_tag, canon_ref
+from .config import normalize_config, resolve_options, check_shape
+from .order import resolve_order
+from .resolve import resolve_candidates, resolve_from
+from .env import apply_env, encode_ref
+from .version import parse_range, parse_version, satisfies
+from .capability import resolve_capability, matches
+from .graph import resolve_graph
+from .point import emit, compose, provider
+from .export import resolve_export
+from .catalog import make_catalog, Catalog
+from .host import make_host, Host, Inst
+
+__all__ = [
+    'make_host', 'make_catalog',
+    'parse_ref', 'format_ref', 'check_name', 'check_tag', 'canon_ref',
+    'normalize_config', 'resolve_options', 'check_shape',
+    'resolve_order', 'resolve_candidates', 'resolve_from',
+    'apply_env', 'encode_ref',
+    'parse_range', 'parse_version', 'satisfies',
+    'resolve_capability', 'matches', 'resolve_graph',
+    'emit', 'compose', 'provider', 'resolve_export',
+    'PluginError', 'formaterror', 'codeof', 'DETAIL_ORDER', 'STATUSES',
+    'Catalog', 'Host', 'Inst',
+]

package/project/.sdk/tm/py/pkg/feature/secrets/voxgig_plugin/capability.py

@@ -0,0 +1,141 @@
+# VENDORED: @voxgig/plugin 0.1.6 (python/voxgig_plugin/capability.py)
+# Source: https://github.com/voxgig/plugin @ b48ae643eb0eb56c5ebe3198da98cecdf6a7f7fc  [tag: sdk-20260907-0029-0]
+# License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+"""Capabilities (section 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.
+"""
+
+import functools
+
+from .version import satisfiesq
+
+
+def resolve_capability(req, candidates):
+    """Rank the matching live providers and return them best-first:
+    highest `version`, then LOWEST `priority` (default 0), then
+    declaration position `pos` ascending.
+
+    `priority` is a field on the capability rather than section 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.
+    """
+    hits = [c for c in candidates if matches(req, c.get('provides') or {})]
+    return sorted(hits, key=functools.cmp_to_key(rank))
+
+
+def rank(a, b):
+    ap, bp = a.get('provides') or {}, b.get('provides') or {}
+    av, bv = ap.get('version'), bp.get('version')
+    if av != bv:
+        # An ABSENT version sorts LAST, whatever the other is - "no
+        # version" loses to every version rather than being read as
+        # 0.0.0.
+        if None is av:
+            return 1
+        if None is bv:
+            return -1
+        found = compare(bv, av)          # highest version FIRST
+        if 0 != found:
+            return found
+    api = ap.get('priority') or 0
+    bpi = bp.get('priority') or 0
+    if api != bpi:
+        return api - bpi                 # lowest priority first
+    return (a.get('pos') or 0) - (b.get('pos') or 0)
+
+
+def matches(req, prov):
+    if req.get('name') != prov.get('name'):
+        return False
+
+    if None is not req.get('range'):
+        if None is prov.get('version'):
+            return False
+        if not 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 None is not req.get('match'):
+        attrs = prov.get('attrs') or {}
+        for key in req['match']:
+            if key not in attrs:
+                return False
+            if not matchvalue(req['match'][key], attrs[key]):
+                return False
+
+    return True
+
+
+def matchvalue(want, got):
+    """PARTIAL MATCH, RECURSING INTO MAPS (section 11.1).
+
+    Section 11.1 defines `match` as "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."
+
+    A LIST IS COMPARED LEAF-WISE AT THE SAME LENGTH, not as a subset.
+    "the first two of your three regions" is not something `match` can
+    say, and inventing a spelling for it would be inventing the filter
+    language section 11.1 explicitly declines to add.
+    """
+    if isinstance(want, dict):
+        if not isinstance(got, dict):
+            return False
+        for key in want:
+            if key not in got:
+                return False
+            if not matchvalue(want[key], got[key]):
+                return False
+        return True
+
+    if isinstance(want, list):
+        if not isinstance(got, list) or len(want) != len(got):
+            return False
+        for i in range(len(want)):
+            if not matchvalue(want[i], got[i]):
+                return False
+        return True
+
+    # PYTHON'S `True == 1` IS THE TRAP THIS LINE EXISTS FOR. The canonical
+    # compares with `===`, under which `true` and `1` are different
+    # values; Python's `==` says they are equal, so a capability
+    # advertising `transactional: 1` would satisfy a requirement for
+    # `transactional: true` here and nowhere else.
+    if isinstance(want, bool) != isinstance(got, bool):
+        return False
+    return want == got
+
+
+def compare(a, b):
+    pa = [toint(x) for x in a.split('.')]
+    pb = [toint(x) for x in b.split('.')]
+    for i in range(3):
+        x = pa[i] if i < len(pa) else 0
+        y = pb[i] if i < len(pb) else 0
+        if x != y:
+            return -1 if x < y else 1
+    return 0
+
+
+def toint(text):
+    try:
+        return int(text)
+    except ValueError:
+        return 0

package/project/.sdk/tm/py/pkg/feature/secrets/voxgig_plugin/catalog.py

@@ -0,0 +1,50 @@
+# VENDORED: @voxgig/plugin 0.1.6 (python/voxgig_plugin/catalog.py)
+# Source: https://github.com/voxgig/plugin @ b48ae643eb0eb56c5ebe3198da98cecdf6a7f7fc  [tag: sdk-20260907-0029-0]
+# License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+"""The definition catalog (section 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
+(section 9.4).
+"""
+
+from .types import fail
+from .ref import check_name
+from .config import check_shape
+
+
+class Catalog:
+    def __init__(self):
+        self._defs = {}
+
+    def add(self, definition):
+        if not isinstance(definition, dict) or \
+                not check_name(definition.get('name')):
+            name = definition.get('name') if isinstance(definition, dict) \
+                else definition
+            fail('plugin_definition_name',
+                 'invalid definition name: ' + str(name))
+        # 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 definition.get('shape'):
+            check_shape(definition['shape'])
+        self._defs[definition['name']] = definition
+
+    def get(self, name):
+        return self._defs.get(name)
+
+    def has(self, name):
+        return name in self._defs
+
+    def names(self):
+        return sorted(self._defs)
+
+
+def make_catalog(definitions=None):
+    catalog = Catalog()
+    for definition in definitions or []:
+        catalog.add(definition)
+    return catalog