@voxgig/sdkgen 4.9.0 → 4.11.0

package/project/.sdk/tm/cpp/feature/secrets/plugin/point.hpp

@@ -0,0 +1,79 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (cpp/src/point.hpp)
+// 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.
+/* Extension points (§6). Three kinds, chosen because they are what the
+ * two existing systems actually needed, and no more.
+ *
+ * A PLUGIN NEVER MUTATES THE HOST. That inversion is what makes
+ * deactivation possible: sdkgen's `utility.fetcher = wrapped` is not
+ * undoable, but "this instance holds slot 3 of the request chain" is
+ * undoable in O(1). OSGi named it the whiteboard pattern in 2004, in a
+ * paper called *Listeners Considered Harmful*, and for exactly this
+ * reason.
+ *
+ * A CLOSURE IS A CLOSURE, which is the whole difference from the `c`
+ * port. `std::function` captures, so a chain binding receives its
+ * `next` as a callable the composition built — the same shape the
+ * canonical writes — instead of c's explicit `Chain *` walked by index.
+ * Nothing else about the composition changes. */
+
+#ifndef VOXGIG_PLUGIN_POINT_HPP
+#define VOXGIG_PLUGIN_POINT_HPP
+
+#include <functional>
+#include <string>
+#include <vector>
+
+#include "types.hpp"
+#include "value.hpp"
+
+namespace plugin {
+
+/* A hook or provider binding. */
+using Hook = std::function<V(const V& arg)>;
+/* The remaining composition, as seen by one chain binding. A binding
+ * may CALL it and must not store it — a plugin that stashes `next` and
+ * calls it after deactivation is a bug the host cannot prevent, and
+ * saying so is better than pretending otherwise (§6.2). */
+using Next = std::function<V(const V& arg)>;
+using ChainFn = std::function<V(const Next& next, const V& arg)>;
+
+struct Bound {
+  std::string ref;
+  std::string point;
+  /* `provider` ranks by HIGHEST band, unlike hook and chain which run
+   * lowest first. Kept as declared so the two rules stay visibly
+   * different rather than one being derived from the other by a reader
+   * who then gets it backwards. */
+  double band = 0;
+  Hook hook;
+  ChainFn chain;
+};
+
+/* Fan-out. Return values are ignored except in `bail`.
+ *
+ * §6.1: "fan-out" is not one answer but four. In a language with
+ * asynchrony, "call every binding" hides a decision — start them all
+ * and wait, await each in turn, or do not wait — and a design that
+ * leaves it unsaid gets four different answers from four ports, in the
+ * concurrency behaviour of production code no corpus entry happens to
+ * cover. This port is synchronous, so all four modes are sequential
+ * here and only the ERROR and RETURN handling distinguishes them.
+ *
+ * `errors` receives the collected raises for the gathering modes. */
+V pointemit(const std::vector<Bound>& bindings, const std::string& mode,
+            const V& arg, V& errors);
+
+/* Composition: b1(b2(b3(base))), FIRST BINDING OUTERMOST (§6.2). */
+V pointcall(const std::vector<Bound>& bindings, const Hook& base, const V& arg);
+
+/* At most one live implementation (§6.3). The winner is the highest
+ * band, ties broken by ref sort, and THE LOSERS ARE VISIBLE rather than
+ * silently ignored. Returns the winner's index (or -1) and fills
+ * `shadowed` with the losing refs, in ranked order. */
+long pointprovider(const std::vector<Bound>& bindings, bool exclusive,
+                   V& shadowed);
+
+}  // namespace plugin
+
+#endif

package/project/.sdk/tm/cpp/feature/secrets/plugin/ref.cpp

@@ -0,0 +1,136 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (cpp/src/ref.cpp)
+// 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.
+/* Identity: name+tag (§4). */
+
+#include "ref.hpp"
+
+namespace plugin {
+
+static const size_t MAX_REF = 1024;
+
+static bool isnamehead(char c) {
+  return ('a' <= c && 'z' >= c) || ('A' <= c && 'Z' >= c) || '@' == c;
+}
+
+static bool isnamebody(char c) {
+  return ('a' <= c && 'z' >= c) || ('A' <= c && 'Z' >= c) ||
+         ('0' <= c && '9' >= c) ||
+         '.' == c || '~' == c || '_' == c || '-' == c || '/' == c;
+}
+
+static bool istagchar(char c) {
+  return ('a' <= c && 'z' >= c) || ('A' <= c && 'Z' >= c) ||
+         ('0' <= c && '9' >= c) ||
+         '.' == c || '~' == c || '_' == c || '-' == c;
+}
+
+static bool namely(const std::string& name) {
+  if (name.empty() || MAX_REF < name.size()) return false;
+  if (!isnamehead(name[0])) return false;
+  for (size_t i = 1; i < name.size(); i++) {
+    if (!isnamebody(name[i])) return false;
+  }
+  return true;
+}
+
+static bool tagly(const std::string& tag) {
+  /* The empty tag is an ordinary tag (§4 rule 2). The single-instance
+   * case writes no tag and never learns tags exist. */
+  if (tag.empty()) return true;
+  if (MAX_REF < tag.size()) return false;
+  for (char c : tag) {
+    if (!istagchar(c)) return false;
+  }
+  return true;
+}
+
+bool checkname(const V& name) {
+  /* A non-string is not a name. Every port has to answer this the same
+   * way, and `ref/name` pins it for numbers, nulls and maps alike. */
+  if (!isstr(name)) return false;
+  return namely(asstr(name));
+}
+
+bool checktag(const V& tag) {
+  if (!isstr(tag)) return false;
+  return tagly(asstr(tag));
+}
+
+/* Split on the FIRST `$`. Nothing in the grammar decides this — `$` is
+ * in neither character class — so the corpus is the arbiter (§4 rule
+ * 5), and it picks the split that blames the part actually at fault:
+ * `a$b$c` is a good name with a bad tag, not the reverse. */
+static void split(const std::string& s, std::string& name, std::string& tag) {
+  size_t cut = s.find('$');
+  if (std::string::npos == cut) { name = s; tag = ""; return; }
+  name = s.substr(0, cut);
+  tag = s.substr(cut + 1);
+}
+
+V parseref(const V& str) {
+  if (!isstr(str)) fail("plugin_bad_name", "ref must be a string");
+
+  std::string name, tag;
+  split(asstr(str), name, tag);
+
+  if (!namely(name)) {
+    fail("plugin_bad_name", "invalid plugin name: " + name,
+         details1("name", vstr(name)));
+  }
+  if (!tagly(tag)) {
+    fail("plugin_bad_tag", "invalid plugin tag: " + tag,
+         details2("name", vstr(name), "tag", vstr(tag)));
+  }
+
+  V out = vmap();
+  set(out, "name", vstr(name));
+  set(out, "tag", vstr(tag));
+  return out;
+}
+
+std::string formatref(const V& name, const V& tag) {
+  bool tagok = isnull(tag) || isstr(tag);
+  std::string t = isstr(tag) ? asstr(tag) : "";
+
+  if (!checkname(name)) {
+    std::string shown = isstr(name) ? asstr(name) : "";
+    fail("plugin_bad_name", "invalid plugin name: " + shown,
+         details1("name", isnull(name) ? vnull() : name));
+  }
+  if (!tagok || !tagly(t)) {
+    fail("plugin_bad_tag", "invalid plugin tag: " + t,
+         details2("name", name, "tag", isnull(tag) ? vstr("") : tag));
+  }
+
+  if (t.empty()) return asstr(name);
+  return asstr(name) + "$" + t;
+}
+
+std::string canonref(const V& str) {
+  V r = parseref(str);
+  return formatref(get(r, "name"), get(r, "tag"));
+}
+
+std::string canonref(const std::string& str) { return canonref(vstr(str)); }
+
+bool tryref(const std::string& str, std::string& out) {
+  std::string name, tag;
+  split(str, name, tag);
+  if (!namely(name) || !tagly(tag)) return false;
+  out = tag.empty() ? name : name + "$" + tag;
+  return true;
+}
+
+std::string canon(const std::string& str) {
+  std::string out;
+  return tryref(str, out) ? out : str;
+}
+
+std::string refname(const std::string& str) {
+  size_t cut = str.find('$');
+  std::string name = (std::string::npos == cut) ? str : str.substr(0, cut);
+  return namely(name) ? name : str;
+}
+
+}  // namespace plugin

package/project/.sdk/tm/cpp/feature/secrets/plugin/ref.hpp

@@ -0,0 +1,60 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (cpp/src/ref.hpp)
+// 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.
+/* Identity: name+tag, written `name$tag` (§4).
+ *
+ * The four pure functions, and the whole of what `ref` pins. They are
+ * the first thing a new port implements and the first corpus section it
+ * passes. */
+
+#ifndef VOXGIG_PLUGIN_REF_HPP
+#define VOXGIG_PLUGIN_REF_HPP
+
+#include <string>
+
+#include "types.hpp"
+#include "value.hpp"
+
+namespace plugin {
+
+/* §4: `^[a-zA-Z@][a-zA-Z0-9.~_\-/]*$`, max 1024. */
+bool checkname(const V& name);
+/* §4: `^[a-zA-Z0-9.~_-]+$`, max 1024, or empty.
+ *
+ * The asymmetry with a name is deliberate: a tag MAY start with a digit
+ * because auto-tagging assigns integer tags (`stripe$1`), and a tag
+ * admits neither `@` nor `/` because a name is a package specifier and
+ * a tag is not. */
+bool checktag(const V& tag);
+
+/* `name$tag` -> {name, tag}. Canonicalizing: `stripe$` and `stripe`
+ * both give tag ''. Raises plugin_bad_name / plugin_bad_tag. */
+V parseref(const V& str);
+/* {name, tag} -> `name$tag`. An empty tag NEVER writes the separator,
+ * which is the half of canonicalization formatref owns: parse tolerates
+ * `stripe$`, format never produces it, so a round trip is idempotent. */
+std::string formatref(const V& name, const V& tag);
+/* The canonical spelling. §4 rule 5: canonicalize before comparison. */
+std::string canonref(const V& str);
+std::string canonref(const std::string& str);
+
+/* The canonical ref this string denotes, or empty if it denotes none —
+ * the TOLERANT half of `canonref`, and the one a requirement name needs
+ * (§11.1). Capability names are free-form, so `2fa` is a good one and
+ * no ref could be called that; `canonref` RAISES on those, and asking
+ * it "is this a ref?" made a legal document kill the host.
+ *
+ * Answers through the bool return rather than by an empty string, so a
+ * caller cannot mistake "not a ref" for "the empty ref". */
+bool tryref(const std::string& str, std::string& out);
+
+/* `canonref` for internal callers that want the input back unchanged
+ * when it is not well formed. NEVER use where a bad ref must be
+ * reported — the corpus pins plugin_bad_name at every public entry. */
+std::string canon(const std::string& str);
+/* The name half, for internal callers that only compare. */
+std::string refname(const std::string& str);
+
+}  // namespace plugin
+
+#endif

package/project/.sdk/tm/cpp/feature/secrets/plugin/resolve.cpp

@@ -0,0 +1,82 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (cpp/src/resolve.cpp)
+// 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.
+/* Dynamic resolution (§10.2). See resolve.hpp. */
+
+#include "resolve.hpp"
+
+namespace plugin {
+
+static void pushuniq(const V& out, const std::string& id) {
+  for (size_t i = 0; i < len(out); i++) {
+    if (asstr(at(out, i)) == id) return;
+  }
+  push(out, vstr(id));
+}
+
+V resolvecandidates(const V& name, const V& sources) {
+  V out = vlist();
+  const std::string n = isstr(name) ? asstr(name) : "";
+
+  /* A SCOPED NAME RESOLVES VERBATIM ONLY (§10.2). `@acme/thing` is
+   * already a package id; prefixing it produces
+   * `@voxgig/plugin-@acme/thing`, which is not a thing that can exist. */
+  if (!n.empty() && '@' == n[0]) {
+    push(out, vstr(n));
+    return out;
+  }
+
+  static const char* const DEFAULT_PREFIX[] = {
+    "@voxgig/plugin-", "voxgig-plugin-", "plugin-", "", nullptr
+  };
+
+  bool given = islist(sources) && 0 < len(sources);
+  if (!given) {
+    for (int i = 0; nullptr != DEFAULT_PREFIX[i]; i++) {
+      pushuniq(out, std::string(DEFAULT_PREFIX[i]) + n);
+    }
+    return out;
+  }
+
+  for (size_t si = 0; si < len(sources); si++) {
+    V src = at(sources, si);
+    const std::string kind = asstr(get(src, "kind"));
+
+    if ("module" == kind) {
+      V prefix = get(src, "prefix");
+      if (islist(prefix) && 0 < len(prefix)) {
+        for (size_t pi = 0; pi < len(prefix); pi++) {
+          pushuniq(out, asstr(at(prefix, pi)) + n);
+        }
+      }
+      else {
+        pushuniq(out, n);
+      }
+    }
+    else if ("path" == kind) {
+      std::string dir = asstr(get(src, "dir"));
+      /* Trailing slashes are trimmed, so `lib/` and `lib` give one id
+       * rather than two spellings of it. */
+      while (!dir.empty() && '/' == dir.back()) dir.pop_back();
+      pushuniq(out, dir + "/" + n);
+    }
+  }
+
+  return out;
+}
+
+/* A MODULE PATH IS NOT A NAME (§10.2). The ref grammar starts a name
+ * with a letter or `@`, so `./local/thing` is not a ref and never
+ * reaches candidate generation — seneca allows a path where a plugin
+ * name goes, and this design deliberately does not, because a ref is an
+ * ADDRESS WITHIN A HOST and a path is a LOCATION ON A DISK.
+ *
+ * Loading from an explicit location bypasses candidate generation
+ * entirely: `from` is passed to the resolver verbatim. */
+V resolvefrom(const V& from) {
+  V out = vlist();
+  push(out, isnull(from) ? vnull() : from);
+  return out;
+}
+
+}  // namespace plugin

package/project/.sdk/tm/cpp/feature/secrets/plugin/resolve.hpp

@@ -0,0 +1,25 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (cpp/src/resolve.hpp)
+// 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.
+/* Dynamic resolution (§10.2) — name to candidate module ids.
+ *
+ * PURE. It returns the ids a host WOULD try, in order; it does not load
+ * anything. That separation is what lets the corpus pin resolution in
+ * every language including those with no dynamic loading at all — cpp
+ * among them — and it is why §15.4 puts real module loading in per-port
+ * integration tests rather than here. */
+
+#ifndef VOXGIG_PLUGIN_RESOLVE_HPP
+#define VOXGIG_PLUGIN_RESOLVE_HPP
+
+#include "types.hpp"
+#include "value.hpp"
+
+namespace plugin {
+
+V resolvecandidates(const V& name, const V& sources);
+V resolvefrom(const V& from);
+
+}  // namespace plugin
+
+#endif

package/project/.sdk/tm/cpp/feature/secrets/plugin/types.cpp

@@ -0,0 +1,90 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (cpp/src/types.cpp)
+// 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.
+/* Errors and the raise mechanism. See types.hpp for why exceptions. */
+
+#include "types.hpp"
+
+namespace plugin {
+
+/* §12's detail fields, IN THIS FIXED ORDER. The order is part of the
+ * contract: an earlier draft named six fields while other sections
+ * promised diagnostics with nowhere to go, which would have left each
+ * port inventing its own order and breaking message parity. */
+static const char* const DETAIL_ORDER[] = {
+  "host", "ref", "name", "tag", "point", "key", "capability",
+  "range", "version", "match", "candidates", "cycle", "holders",
+  "refs", "path", "cause", nullptr
+};
+
+std::string formaterror(const std::string& code, const std::string& text,
+                        const V& details) {
+  /* Values render as COMPACT JSON, so a value containing a space or a
+   * bracket cannot break the parse and a list renders as an array. The
+   * bracket is absent entirely when no field applies. */
+  std::string tail;
+  for (int i = 0; nullptr != DETAIL_ORDER[i]; i++) {
+    const std::string k = DETAIL_ORDER[i];
+    if (!has(details, k)) continue;
+    if (!tail.empty()) tail += ' ';
+    tail += k;
+    tail += '=';
+    tail += json(get(details, k));
+  }
+
+  std::string out = "plugin/" + code + ": " + text;
+  if (!tail.empty()) out += " [" + tail + "]";
+  return out;
+}
+
+PluginError::PluginError(std::string c, std::string t, V d)
+    : code(std::move(c)),
+      text(std::move(t)),
+      details(d ? d : vmap()),
+      message(formaterror(code, text, details)) {}
+
+void fail(const std::string& code, const std::string& text, const V& details) {
+  throw PluginError(code, text, details);
+}
+
+V details1(const std::string& k, const V& v) {
+  V d = vmap();
+  set(d, k, v);
+  return d;
+}
+
+V details2(const std::string& k1, const V& v1, const std::string& k2,
+           const V& v2) {
+  V d = vmap();
+  set(d, k1, v1);
+  set(d, k2, v2);
+  return d;
+}
+
+V mergevalue(const V& a, const V& b) {
+  if (!ismap(a) || !ismap(b)) return b ? b : a;
+  V out = vmap();
+  for (const auto& k : keys(a)) set(out, k, get(a, k));
+  for (const auto& k : keys(b)) {
+    V bv = get(b, k);
+    V av = get(out, k);
+    if (ismap(av) && ismap(bv)) set(out, k, mergevalue(av, bv));
+    else set(out, k, bv);
+  }
+  return out;
+}
+
+bool matchvalue(const V& want, const V& have) {
+  if (isnull(want)) return true;
+  if (ismap(want)) {
+    if (!ismap(have)) return false;
+    for (const auto& k : keys(want)) {
+      if (!has(have, k)) return false;
+      if (!matchvalue(get(want, k), get(have, k))) return false;
+    }
+    return true;
+  }
+  return same(want, have);
+}
+
+}  // namespace plugin

package/project/.sdk/tm/cpp/feature/secrets/plugin/types.hpp

@@ -0,0 +1,65 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (cpp/src/types.hpp)
+// 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.
+/* Errors, and the raise mechanism (§12).
+ *
+ * A REAL EXCEPTION, which is the whole difference from the `c` port.
+ * The canonical RAISES: a failing call abandons the rest of the
+ * function, and the corpus is full of entries that assert exactly what
+ * survived a raise mid-sequence (`resource/unwind`, `lifecycle/fail`).
+ * c reaches that with setjmp/longjmp and pays for it in `volatile`
+ * locals and an arena; C++ has the construct, so it is used, and the
+ * destructors run on the way out.
+ *
+ * Ports compare by CODE and never by message: wording is a port's own
+ * business. The FORMAT is pinned, because a parseable message is what
+ * makes a log searchable across twenty languages. */
+
+#ifndef VOXGIG_PLUGIN_TYPES_HPP
+#define VOXGIG_PLUGIN_TYPES_HPP
+
+#include <exception>
+#include <string>
+
+#include "value.hpp"
+
+namespace plugin {
+
+class PluginError : public std::exception {
+ public:
+  std::string code;
+  std::string text;
+  V details;
+  std::string message;
+
+  PluginError(std::string c, std::string t, V d);
+  const char* what() const noexcept override { return message.c_str(); }
+};
+
+/* Raise. Never returns — declared [[noreturn]] so the compiler knows a
+ * `fail` ends a branch and no caller needs a dead return after it. */
+[[noreturn]] void fail(const std::string& code, const std::string& text,
+                       const V& details = nullptr);
+
+/* §12's detail fields render in a FIXED ORDER — part of the contract,
+ * not a formatting preference, because otherwise each port invents its
+ * own and message parity is gone. */
+std::string formaterror(const std::string& code, const std::string& text,
+                        const V& details);
+
+/* Convenience: small details maps. */
+V details1(const std::string& k, const V& v);
+V details2(const std::string& k1, const V& v1, const std::string& k2,
+           const V& v2);
+
+/* Deep merge, struct's semantics: maps merge, everything else replaces.
+ * §16 permits voxgig/struct for this and C++ has no port of it. */
+V mergevalue(const V& a, const V& b);
+
+/* §11.1's partial match: every leaf in `want` must be present and equal
+ * in `have`; keys not mentioned are not checked. */
+bool matchvalue(const V& want, const V& have);
+
+}  // namespace plugin
+
+#endif