@voxgig/sdkgen 4.9.0 → 4.11.0

package/project/.sdk/tm/csharp/feature/secrets/plugin/Inst.cs

@@ -0,0 +1,177 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (csharp/src/Inst.cs)
+// Source: https://github.com/voxgig/plugin @ 48392f5e2b6d1434ee9b1a4a9a11f4480aaeb46a  [tag: sdk-20260908-1556-0]
+// License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+using System;
+using System.Collections.Generic;
+
+namespace Voxgig.Plugin
+{
+    /// <summary>
+    /// What a definition's callbacks see.
+    ///
+    /// <para>Deliberately not the internal record: a plugin that could
+    /// reach <c>status</c> could also write it.</para>
+    /// </summary>
+    public sealed class Inst
+    {
+        public readonly Host HostRef;
+        public readonly string Ref;
+        public readonly string Name;
+        public readonly string Tag;
+
+        private readonly Entry entry;
+
+        internal Inst(Host host, Entry entry)
+        {
+            HostRef = host;
+            this.entry = entry;
+            Ref = entry.Ref;
+            var parsed = Refs.ParseRef(entry.Ref);
+            Name = Types.Str(parsed["name"]);
+            Tag = Types.Str(parsed["tag"]);
+        }
+
+        /// <summary>
+        /// The resolved options, READ FRESH. <c>Apply</c> and
+        /// <c>Options</c> replace the map wholesale, so a callback that
+        /// cached this at <c>define</c> would hold the values a later
+        /// document already changed.
+        /// </summary>
+        public object Options()
+        {
+            return entry.Options;
+        }
+
+        /// The instance's own state (§5.4), LIVE.
+        public SortedDictionary<string, object> State()
+        {
+            return entry.State;
+        }
+
+        /// <summary>
+        /// Foreign resources the host did not hand out are registered
+        /// explicitly (§8.3); host calls are recorded automatically.
+        /// SYMMETRIC WITH <c>Acquire</c>, and it has to be: <c>open</c>
+        /// counts the resources CURRENTLY HELD.
+        /// </summary>
+        public void Release(Entry.ScopeFn func)
+        {
+            // §8.3: "`inst.release` outside `activate` is
+            // `plugin_release_scope`". A flag saying merely that a
+            // transition is running is true in `define` too, and a scope
+            // entry registered there is never unwound.
+            if ("activate" != HostRef.Phase())
+            {
+                Types.Fail("plugin_release_scope", "release called outside activate", null);
+            }
+            var done = false;
+            entry.Scope.Add(() =>
+            {
+                if (done)
+                {
+                    return;
+                }
+                done = true;
+                HostRef.OpenDec();
+                func();
+            });
+            HostRef.OpenInc();
+        }
+
+        /// <summary>
+        /// The synthetic counter the driver owns, so "what is open" is
+        /// data rather than an assertion each port words differently.
+        /// Returns its own release, so a plugin can hand one back early;
+        /// unwinding it twice is a no-op.
+        /// </summary>
+        public Entry.ScopeFn Acquire()
+        {
+            // §8.1: resources are "acquired during `activate` - the
+            // scope's actual job". Same reason as `Release` above.
+            if ("activate" != HostRef.Phase())
+            {
+                Types.Fail("plugin_release_scope", "acquire called outside activate", null);
+            }
+            var done = false;
+            Entry.ScopeFn rel = () =>
+            {
+                if (done)
+                {
+                    return;
+                }
+                done = true;
+                HostRef.OpenDec();
+            };
+            entry.Scope.Add(rel);
+            HostRef.OpenInc();
+            return rel;
+        }
+
+        /// <summary>
+        /// Bind into a host point. Declared in <c>define</c>; the host
+        /// inserts it only after <c>activate</c> returns successfully
+        /// (§8.1), which is why a failing activate leaves no live binding
+        /// behind.
+        /// </summary>
+        public void Bind(string point, Point.BindFn func, object band)
+        {
+            // §12 has carried `plugin_bind_scope` - "binding declared
+            // outside `define`" - since before anything raised it. §8.1
+            // puts binding DECLARATION in `define` and INSERTION at a
+            // successful activate, and the guard was the half nobody
+            // wrote.
+            if ("define" != HostRef.Phase())
+            {
+                Types.Fail("plugin_bind_scope", "bind called outside define: " + point,
+                           Types.Details("ref", Ref, "point", point));
+            }
+            if (!HostRef.HasPoint(point))
+            {
+                Types.Fail("plugin_point_unknown", "no such point: " + point,
+                           Types.Details("point", point));
+            }
+            entry.Bindings.Add(new Point.Bound(Ref, point, func, Types.AsInt(band) ?? 0));
+        }
+
+        /// Published for other plugins and for the application (§11).
+        public void Export(string key, object value)
+        {
+            entry.Exports[key] = value;
+        }
+
+        /// What this instance can do for others (§11.1).
+        public void Provides(object prov)
+        {
+            entry.Provides.Add(prov);
+        }
+
+        /// <summary>
+        /// Where this binding landed (§6.6) - the plugin-side counterpart
+        /// to a host pin. THE HOST DOES NOT POLICE THIS; it just makes the
+        /// fact available.
+        /// </summary>
+        public object Position(string point)
+        {
+            return HostRef.PositionOf(Ref, point);
+        }
+
+        /// <summary>
+        /// AN INSTANCE MAY ITSELF BE A HOST (§6.5), and THE OUTER ONE OWNS
+        /// THE INNER ONE'S LIFETIME. Registering the teardown in the
+        /// instance scope is what makes that true rather than
+        /// aspirational.
+        /// </summary>
+        public Host Nest(object nestopts)
+        {
+            if (!HostRef.InTransition())
+            {
+                Types.Fail("plugin_release_scope",
+                           "nest called outside a lifecycle callback", null);
+            }
+            var inner = new Host(nestopts);
+            entry.Scope.Add(() => inner.Close());
+            entry.Inner = inner;
+            return inner;
+        }
+    }
+}

package/project/.sdk/tm/csharp/feature/secrets/plugin/Json.cs

@@ -0,0 +1,326 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (csharp/src/Json.cs)
+// Source: https://github.com/voxgig/plugin @ 48392f5e2b6d1434ee9b1a4a9a11f4480aaeb46a  [tag: sdk-20260908-1556-0]
+// License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Text;
+
+namespace Voxgig.Plugin
+{
+    /// <summary>
+    /// The JSON value model's parser and writer, and the only one this
+    /// port has.
+    ///
+    /// <para>NO System.Text.Json AND NO NEWTONSOFT (§16). The library is
+    /// allowed exactly one runtime dependency, <c>voxgig/struct</c>, which
+    /// has no csharp port; everything else is the BCL, and a parser is two
+    /// hundred lines. It also keeps `dotnet restore` with nothing to
+    /// fetch, which is what makes `make test` work offline.</para>
+    ///
+    /// <para>A NUMBER IS ALWAYS A <c>double</c>, because JSON has one
+    /// number type and the canonical is javascript. A boxed <c>int</c>
+    /// anywhere in this data would compare unequal to the <c>double</c>
+    /// the parser produced for the same literal, and the corpus would fail
+    /// on a distinction the model does not have.</para>
+    /// </summary>
+    public static class Json
+    {
+        public static object Parse(string text)
+        {
+            var at = 0;
+            SkipWs(text, ref at);
+            var value = ParseValue(text, ref at);
+            SkipWs(text, ref at);
+            if (at < text.Length)
+            {
+                throw new ArgumentException("trailing input at " + at);
+            }
+            return value;
+        }
+
+        /// Compact JSON, map keys in sorted order (which the map already is).
+        public static string Write(object value)
+        {
+            var out_ = new StringBuilder();
+            WriteTo(value, out_);
+            return out_.ToString();
+        }
+
+        private static void WriteTo(object value, StringBuilder out_)
+        {
+            if (null == value)
+            {
+                out_.Append("null");
+                return;
+            }
+            if (value is bool b)
+            {
+                out_.Append(b ? "true" : "false");
+                return;
+            }
+            if (value is double d)
+            {
+                out_.Append(Types.NumText(d));
+                return;
+            }
+            if (value is string s)
+            {
+                WriteString(s, out_);
+                return;
+            }
+            var list = Types.List(value);
+            if (null != list)
+            {
+                out_.Append('[');
+                for (var i = 0; i < list.Count; i++)
+                {
+                    if (0 < i)
+                    {
+                        out_.Append(',');
+                    }
+                    WriteTo(list[i], out_);
+                }
+                out_.Append(']');
+                return;
+            }
+            var map = Types.Map(value);
+            if (null != map)
+            {
+                out_.Append('{');
+                var first = true;
+                foreach (var pair in map)
+                {
+                    if (!first)
+                    {
+                        out_.Append(',');
+                    }
+                    first = false;
+                    WriteString(pair.Key, out_);
+                    out_.Append(':');
+                    WriteTo(pair.Value, out_);
+                }
+                out_.Append('}');
+                return;
+            }
+            // A host object published through `exports` (§11) - the library
+            // never inspects one and nothing in the corpus compares one.
+            out_.Append("\"(opaque)\"");
+        }
+
+        private static void WriteString(string text, StringBuilder out_)
+        {
+            out_.Append('"');
+            foreach (var c in text)
+            {
+                switch (c)
+                {
+                    case '"': out_.Append("\\\""); break;
+                    case '\\': out_.Append("\\\\"); break;
+                    case '\n': out_.Append("\\n"); break;
+                    case '\r': out_.Append("\\r"); break;
+                    case '\t': out_.Append("\\t"); break;
+                    default:
+                        if (c < 0x20)
+                        {
+                            out_.Append("\\u").Append(((int)c).ToString("x4", CultureInfo.InvariantCulture));
+                        }
+                        else
+                        {
+                            out_.Append(c);
+                        }
+                        break;
+                }
+            }
+            out_.Append('"');
+        }
+
+        private static void SkipWs(string s, ref int at)
+        {
+            while (at < s.Length && (' ' == s[at] || '\t' == s[at] || '\n' == s[at] || '\r' == s[at]))
+            {
+                at++;
+            }
+        }
+
+        private static object ParseValue(string s, ref int at)
+        {
+            if (s.Length <= at)
+            {
+                throw new ArgumentException("unexpected end of input");
+            }
+            switch (s[at])
+            {
+                case '{': return ParseMap(s, ref at);
+                case '[': return ParseList(s, ref at);
+                case '"': return ParseString(s, ref at);
+                case 't': return Literal(s, ref at, "true", true);
+                case 'f': return Literal(s, ref at, "false", false);
+                case 'n': return Literal(s, ref at, "null", null);
+                default: return ParseNumber(s, ref at);
+            }
+        }
+
+        private static object Literal(string s, ref int at, string word, object value)
+        {
+            if (s.Length < at + word.Length || word != s.Substring(at, word.Length))
+            {
+                throw new ArgumentException("bad literal at " + at);
+            }
+            at += word.Length;
+            return value;
+        }
+
+        private static object ParseMap(string s, ref int at)
+        {
+            var out_ = Types.NewMap();
+            at++;
+            SkipWs(s, ref at);
+            if (at < s.Length && '}' == s[at])
+            {
+                at++;
+                return out_;
+            }
+            while (true)
+            {
+                SkipWs(s, ref at);
+                var key = ParseString(s, ref at);
+                SkipWs(s, ref at);
+                if (s.Length <= at || ':' != s[at])
+                {
+                    throw new ArgumentException("expected ':' at " + at);
+                }
+                at++;
+                SkipWs(s, ref at);
+                out_[key] = ParseValue(s, ref at);
+                SkipWs(s, ref at);
+                if (s.Length <= at)
+                {
+                    throw new ArgumentException("unexpected end in object");
+                }
+                if (',' == s[at])
+                {
+                    at++;
+                    continue;
+                }
+                if ('}' == s[at])
+                {
+                    at++;
+                    return out_;
+                }
+                throw new ArgumentException("expected ',' or '}' at " + at);
+            }
+        }
+
+        private static object ParseList(string s, ref int at)
+        {
+            var out_ = new List<object>();
+            at++;
+            SkipWs(s, ref at);
+            if (at < s.Length && ']' == s[at])
+            {
+                at++;
+                return out_;
+            }
+            while (true)
+            {
+                SkipWs(s, ref at);
+                out_.Add(ParseValue(s, ref at));
+                SkipWs(s, ref at);
+                if (s.Length <= at)
+                {
+                    throw new ArgumentException("unexpected end in array");
+                }
+                if (',' == s[at])
+                {
+                    at++;
+                    continue;
+                }
+                if (']' == s[at])
+                {
+                    at++;
+                    return out_;
+                }
+                throw new ArgumentException("expected ',' or ']' at " + at);
+            }
+        }
+
+        private static string ParseString(string s, ref int at)
+        {
+            if (s.Length <= at || '"' != s[at])
+            {
+                throw new ArgumentException("expected a string at " + at);
+            }
+            at++;
+            var out_ = new StringBuilder();
+            while (at < s.Length)
+            {
+                var c = s[at];
+                at++;
+                if ('"' == c)
+                {
+                    return out_.ToString();
+                }
+                if ('\\' != c)
+                {
+                    out_.Append(c);
+                    continue;
+                }
+                if (s.Length <= at)
+                {
+                    throw new ArgumentException("unexpected end in string");
+                }
+                var e = s[at];
+                at++;
+                switch (e)
+                {
+                    case '"': out_.Append('"'); break;
+                    case '\\': out_.Append('\\'); break;
+                    case '/': out_.Append('/'); break;
+                    case 'b': out_.Append('\b'); break;
+                    case 'f': out_.Append('\f'); break;
+                    case 'n': out_.Append('\n'); break;
+                    case 'r': out_.Append('\r'); break;
+                    case 't': out_.Append('\t'); break;
+                    case 'u':
+                        // A csharp char IS a UTF-16 code unit, so a
+                        // surrogate pair needs no joining: appending both
+                        // halves is the string.
+                        if (s.Length < at + 4)
+                        {
+                            throw new ArgumentException("bad \\u escape at " + at);
+                        }
+                        out_.Append((char)Convert.ToInt32(s.Substring(at, 4), 16));
+                        at += 4;
+                        break;
+                    default:
+                        throw new ArgumentException("bad escape at " + at);
+                }
+            }
+            throw new ArgumentException("unterminated string");
+        }
+
+        private static object ParseNumber(string s, ref int at)
+        {
+            var start = at;
+            if (at < s.Length && '-' == s[at])
+            {
+                at++;
+            }
+            while (at < s.Length
+                   && (char.IsDigit(s[at]) || '.' == s[at] || 'e' == s[at] || 'E' == s[at]
+                       || '+' == s[at] || '-' == s[at]))
+            {
+                at++;
+            }
+            var text = s.Substring(start, at - start);
+            // INVARIANT culture: a machine whose decimal separator is a
+            // comma would otherwise parse `1.5` as 15.
+            if (!double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var n))
+            {
+                throw new ArgumentException("bad number " + text + " at " + start);
+            }
+            return n;
+        }
+    }
+}