@voxgig/sdkgen 4.9.0 → 4.10.0

package/project/.sdk/tm/java/feature/secrets/plugin/Refs.java

@@ -0,0 +1,171 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (java/src/voxgig/plugin/Refs.java)
+// 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.
+package JAVAPACKAGE.feature.secrets.plugin;
+
+import static JAVAPACKAGE.feature.secrets.plugin.Types.details;
+import static JAVAPACKAGE.feature.secrets.plugin.Types.fail;
+import static JAVAPACKAGE.feature.secrets.plugin.Types.newmap;
+import static JAVAPACKAGE.feature.secrets.plugin.Types.str;
+
+import java.util.Map;
+
+/**
+ * Identity: name+tag, written {@code name$tag} (§4).
+ *
+ * <p>The four pure functions, and the whole of what {@code ref} pins. They
+ * are the first thing a new port implements and the first corpus section
+ * it passes.
+ *
+ * <p>NO REGEX, and that is not an accident of style. {@code
+ * java.util.regex}'s {@code $} matches before a final line terminator, so
+ * a {@code ^...$} spelling would admit {@code "stripe\n"} as a name - the
+ * hole the ruby port surfaced in python. A character-class walk cannot
+ * have it, and the four {@code #trailing-newline} entries pass here
+ * without the port having to know they exist.
+ */
+public final class Refs {
+
+  private Refs() {}
+
+  public static final int REF_MAX = 1024;
+
+  /** §4: {@code ^[a-zA-Z@][a-zA-Z0-9.~_\-/]*$}, max 1024. */
+  public static boolean checkName(Object name) {
+    String text = str(name);
+    if (null == text || text.isEmpty() || REF_MAX < text.length()) {
+      return false;
+    }
+    char first = text.charAt(0);
+    if (!isAlpha(first) && '@' != first) {
+      return false;
+    }
+    for (int i = 1; i < text.length(); i++) {
+      char c = text.charAt(i);
+      if (!isAlpha(c) && !isDigit(c) && '.' != c && '~' != c && '_' != c && '-' != c && '/' != c) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * §4: {@code ^[a-zA-Z0-9.~_-]+$}, max 1024, or empty.
+   *
+   * <p>The asymmetry with a name is deliberate: a tag MAY start with a
+   * digit because auto-tagging assigns integer tags ({@code stripe$1}),
+   * and a tag admits neither {@code @} nor {@code /} because a name is a
+   * package specifier and a tag is not.
+   */
+  public static boolean checkTag(Object tag) {
+    String text = str(tag);
+    if (null == text) {
+      return false;
+    }
+    // The empty tag is an ordinary tag (§4 rule 2). The single-instance
+    // case writes no tag and never learns tags exist.
+    if (text.isEmpty()) {
+      return true;
+    }
+    if (REF_MAX < text.length()) {
+      return false;
+    }
+    for (int i = 0; i < text.length(); i++) {
+      char c = text.charAt(i);
+      if (!isAlpha(c) && !isDigit(c) && '.' != c && '~' != c && '_' != c && '-' != c) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  private static boolean isAlpha(char c) {
+    return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z');
+  }
+
+  private static boolean isDigit(char c) {
+    return '0' <= c && c <= '9';
+  }
+
+  /**
+   * {@code name$tag} -> the pair. Canonicalizing: {@code stripe$} and
+   * {@code stripe} both give tag "".
+   */
+  public static Map<String, Object> parseRef(Object value) {
+    String text = str(value);
+    if (null == text) {
+      fail("plugin_bad_name", "ref must be a string", null);
+    }
+
+    // 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.
+    int cut = text.indexOf('$');
+    String name = cut < 0 ? text : text.substring(0, cut);
+    String tag = cut < 0 ? "" : text.substring(cut + 1);
+
+    if (!checkName(name)) {
+      fail("plugin_bad_name", "invalid plugin name: " + name, details("name", name));
+    }
+    if (!checkTag(tag)) {
+      fail("plugin_bad_tag", "invalid plugin tag: " + tag, details("name", name, "tag", tag));
+    }
+
+    Map<String, Object> out = newmap();
+    out.put("name", name);
+    out.put("tag", tag);
+    return out;
+  }
+
+  /**
+   * The pair -> {@code name$tag}. An empty tag NEVER writes the separator,
+   * which is the half of canonicalization this owns: parse tolerates
+   * {@code stripe$}, format never produces it, so a round trip is
+   * idempotent.
+   */
+  public static String formatRef(Object name, Object tag) {
+    Object usetag = null == tag ? "" : tag;
+    if (!checkName(name)) {
+      fail("plugin_bad_name", "invalid plugin name: " + Json.write(name), details("name", name));
+    }
+    if (!checkTag(usetag)) {
+      fail(
+          "plugin_bad_tag",
+          "invalid plugin tag: " + Json.write(usetag),
+          details("name", name, "tag", usetag));
+    }
+    String text = str(usetag);
+    return text.isEmpty() ? str(name) : str(name) + "$" + text;
+  }
+
+  /**
+   * The canonical spelling of a ref. §4 rule 5: ports must canonicalize
+   * before comparison.
+   */
+  public static String canonRef(Object value) {
+    Map<String, Object> parsed = parseRef(value);
+    return formatRef(parsed.get("name"), parsed.get("tag"));
+  }
+
+  /**
+   * canonRef for the internal callers that want the input back unchanged
+   * when it is not well formed. NEVER use it where a bad ref must be
+   * reported - the corpus pins plugin_bad_name at every public entry.
+   */
+  public static String canon(String text) {
+    try {
+      return canonRef(text);
+    } catch (PluginException e) {
+      return text;
+    }
+  }
+
+  public static String refname(String text) {
+    try {
+      return str(parseRef(text).get("name"));
+    } catch (PluginException e) {
+      return text;
+    }
+  }
+}

package/project/.sdk/tm/java/feature/secrets/plugin/Resolve.java

@@ -0,0 +1,89 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (java/src/voxgig/plugin/Resolve.java)
+// 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.
+package JAVAPACKAGE.feature.secrets.plugin;
+
+import static JAVAPACKAGE.feature.secrets.plugin.Types.get;
+import static JAVAPACKAGE.feature.secrets.plugin.Types.list;
+import static JAVAPACKAGE.feature.secrets.plugin.Types.newmap;
+import static JAVAPACKAGE.feature.secrets.plugin.Types.str;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Dynamic resolution (§10.2) - name to candidate module ids.
+ *
+ * <p>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, and it is
+ * why §15.4 puts real module loading in per-port integration tests rather
+ * than here.
+ */
+public final class Resolve {
+
+  private Resolve() {}
+
+  public static List<Object> defaultSources() {
+    Map<String, Object> src = newmap();
+    src.put("kind", "module");
+    src.put("prefix", new ArrayList<>(List.of("@voxgig/plugin-", "voxgig-plugin-", "plugin-", "")));
+    List<Object> out = new ArrayList<>();
+    out.add(src);
+    return out;
+  }
+
+  public static List<Object> resolveCandidates(String name, Object sources) {
+    List<Object> out = new ArrayList<>();
+
+    // 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 (name.startsWith("@")) {
+      out.add(name);
+      return out;
+    }
+
+    List<Object> given = list(sources);
+    List<Object> useit = (null == given || given.isEmpty()) ? defaultSources() : given;
+
+    for (Object src : useit) {
+      String kind = str(get(src, "kind"));
+      if ("module".equals(kind)) {
+        List<Object> prefixes = list(get(src, "prefix"));
+        if (null == prefixes || prefixes.isEmpty()) {
+          prefixes = new ArrayList<>(List.of(""));
+        }
+        for (Object p : prefixes) {
+          String id = str(p) + name;
+          if (!out.contains(id)) {
+            out.add(id);
+          }
+        }
+      } else if ("path".equals(kind)) {
+        String dir = str(get(src, "dir"));
+        dir = null == dir ? "" : dir.replaceAll("/+$", "");
+        String id = dir + "/" + name;
+        if (!out.contains(id)) {
+          out.add(id);
+        }
+      }
+    }
+
+    return out;
+  }
+
+  /**
+   * A MODULE PATH IS NOT A NAME (§10.2). The ref grammar starts a name
+   * with a letter or {@code @}, so {@code ./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.
+   */
+  public static List<Object> resolveFrom(Object from) {
+    List<Object> out = new ArrayList<>();
+    out.add(from);
+    return out;
+  }
+}

package/project/.sdk/tm/java/feature/secrets/plugin/Types.java

@@ -0,0 +1,232 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (java/src/voxgig/plugin/Types.java)
+// 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.
+package JAVAPACKAGE.feature.secrets.plugin;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+/**
+ * Shared types and the value helpers every module reads data through.
+ *
+ * <p>Deliberately small: the design's §19 budget says the library owns
+ * naming, configuration, lifecycle, ordering, binding and teardown, and
+ * nothing else.
+ *
+ * <p>JAVA RAISES, so this port follows the CANONICAL rather than go: a
+ * failing call throws {@link PluginException}, which carries the §12 code
+ * the corpus compares by. Go and rust return their errors because their
+ * languages have no other idiom; java has one, and using it keeps the
+ * control flow the same shape as the typescript this is a port of.
+ */
+public final class Types {
+
+  private Types() {}
+
+  /**
+   * §5.1's seven statuses, and no more. A port that adds an eighth is
+   * diverging. {@code loading} and {@code closing} are observable only
+   * from inside a callback or from another thread.
+   */
+  public static final List<String> STATUSES =
+      List.of("declared", "loaded", "pending", "live", "failed", "loading", "closing");
+
+  /**
+   * §12's detail fields, IN THIS FIXED ORDER.
+   *
+   * <p>The order is part of the contract, not a formatting preference. An
+   * earlier draft named six fields while other sections promised
+   * diagnostics that had nowhere to go, which would have left each port
+   * inventing its own order and breaking message parity.
+   */
+  public static final List<String> DETAIL_ORDER =
+      List.of(
+          "host", "ref", "name", "tag", "point", "key", "capability", "range", "version", "match",
+          "candidates", "cycle", "holders", "refs", "path", "cause");
+
+  /**
+   * {@code plugin/<code>: <text> [<key>=<value> ...]}
+   *
+   * <p>Values render as COMPACT JSON, so a value containing a space or a
+   * bracket cannot break the parse, and a list renders as a JSON array.
+   * The bracket is absent entirely when no field applies.
+   */
+  public static String formaterror(String code, String text, Object details) {
+    List<String> parts = new ArrayList<>();
+    for (String key : DETAIL_ORDER) {
+      if (!has(details, key)) {
+        continue;
+      }
+      parts.add(key + "=" + Json.write(get(details, key)));
+    }
+    String tail = parts.isEmpty() ? "" : " [" + String.join(" ", parts) + "]";
+    return "plugin/" + code + ": " + text + tail;
+  }
+
+  /** Throw a §12 error. One spelling, so every raise site reads the same. */
+  public static void fail(String code, String text, Object details) {
+    throw new PluginException(code, text, details);
+  }
+
+  /**
+   * The §12 code of a throwable, or "" for one this library did not raise.
+   * The corpus compares by code, so the driver needs one place that knows
+   * how to read it.
+   */
+  public static String codeof(Throwable err) {
+    return err instanceof PluginException ? ((PluginException) err).code : "";
+  }
+
+  /** A detail map, spelled once rather than at forty call sites. */
+  public static Map<String, Object> details(Object... pairs) {
+    Map<String, Object> out = new TreeMap<>();
+    for (int i = 0; i + 1 < pairs.length; i += 2) {
+      out.put((String) pairs[i], pairs[i + 1]);
+    }
+    return out;
+  }
+
+  // -- the value helpers ----------------------------------------------
+
+  @SuppressWarnings("unchecked")
+  public static Map<String, Object> map(Object value) {
+    return value instanceof Map ? (Map<String, Object>) value : null;
+  }
+
+  @SuppressWarnings("unchecked")
+  public static List<Object> list(Object value) {
+    return value instanceof List ? (List<Object>) value : null;
+  }
+
+  public static String str(Object value) {
+    return value instanceof String ? (String) value : null;
+  }
+
+  public static Double num(Object value) {
+    return value instanceof Double ? (Double) value : null;
+  }
+
+  /**
+   * An INTEGER, and only when the value is one. §7's band is an integer
+   * the document wrote as one; {@code true} and {@code "2"} are not bands,
+   * and a port that coerced them would accept documents the canonical
+   * rejects.
+   */
+  public static Long asint(Object value) {
+    Double n = num(value);
+    if (null == n || n != Math.floor(n) || Double.isInfinite(n)) {
+      return null;
+    }
+    return (long) (double) n;
+  }
+
+  /** The value at a key, or null. Absence and null read the same here. */
+  public static Object get(Object node, String key) {
+    Map<String, Object> m = map(node);
+    return null == m ? null : m.get(key);
+  }
+
+  /** PRESENCE, which is what distinguishes an authored null from absence. */
+  public static boolean has(Object node, String key) {
+    Map<String, Object> m = map(node);
+    return null != m && m.containsKey(key);
+  }
+
+  public static Object at(Object node, int index) {
+    List<Object> l = list(node);
+    return null == l || l.size() <= index ? null : l.get(index);
+  }
+
+  /** The keys of a map, sorted - which a TreeMap already is. */
+  public static List<String> keys(Object node) {
+    Map<String, Object> m = map(node);
+    return null == m ? new ArrayList<>() : new ArrayList<>(m.keySet());
+  }
+
+  public static Map<String, Object> newmap() {
+    return new TreeMap<>();
+  }
+
+  /**
+   * Ruby's truthiness, which is not java's `if`: present, and not {@code
+   * false}. {@code 0}, {@code ""} and {@code []} are all values the corpus
+   * distinguishes from absence.
+   */
+  public static boolean truthy(Object value) {
+    return null != value && !Boolean.FALSE.equals(value);
+  }
+
+  /**
+   * JSON equality: same type, then same value.
+   *
+   * <p>{@code true} is not {@code 1} and {@code 1} is not {@code "1"} -
+   * `capability/match` has an entry for each direction. JAVA NEEDS NO
+   * GUARD FOR THAT, because {@code Boolean.equals(Double)} is false and so
+   * is {@code Double.equals(String)}; the guard php, perl and lua each
+   * carry is unreachable here, and a mutation deleting one would be a
+   * non-mutation. What java DOES need is the one-number-type rule kept at
+   * the parser: every number is a {@link Double}, so an {@link Integer}
+   * never enters the data to compare unequal against its own literal.
+   */
+  public static boolean same(Object a, Object b) {
+    Map<String, Object> ma = map(a);
+    Map<String, Object> mb = map(b);
+    if (null != ma || null != mb) {
+      if (null == ma || null == mb || ma.size() != mb.size()) {
+        return false;
+      }
+      for (Map.Entry<String, Object> e : ma.entrySet()) {
+        if (!mb.containsKey(e.getKey()) || !same(e.getValue(), mb.get(e.getKey()))) {
+          return false;
+        }
+      }
+      return true;
+    }
+    List<Object> la = list(a);
+    List<Object> lb = list(b);
+    if (null != la || null != lb) {
+      if (null == la || null == lb || la.size() != lb.size()) {
+        return false;
+      }
+      for (int i = 0; i < la.size(); i++) {
+        if (!same(la.get(i), lb.get(i))) {
+          return false;
+        }
+      }
+      return true;
+    }
+    return null == a ? null == b : a.equals(b);
+  }
+
+  /**
+   * A deep copy. NOT named `clone`: `Object.clone()` is inherited by every
+   * class, so a static import of a same-named helper silently resolves to
+   * the instance method and does not compile.
+   */
+  public static Object copy(Object value) {
+    Map<String, Object> m = map(value);
+    if (null != m) {
+      Map<String, Object> out = newmap();
+      for (Map.Entry<String, Object> e : m.entrySet()) {
+        out.put(e.getKey(), copy(e.getValue()));
+      }
+      return out;
+    }
+    List<Object> l = list(value);
+    if (null != l) {
+      List<Object> out = new ArrayList<>();
+      for (Object item : l) {
+        out.add(copy(item));
+      }
+      return out;
+    }
+    return value;
+  }
+
+  /** A list of strings as a list of values, for a detail field. */
+  public static List<Object> strings(List<String> items) {
+    return new ArrayList<>(items);
+  }
+}

package/project/.sdk/tm/java/feature/secrets/plugin/Version.java

@@ -0,0 +1,198 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (java/src/voxgig/plugin/Version.java)
+// 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.
+package JAVAPACKAGE.feature.secrets.plugin;
+
+import static JAVAPACKAGE.feature.secrets.plugin.Types.at;
+import static JAVAPACKAGE.feature.secrets.plugin.Types.details;
+import static JAVAPACKAGE.feature.secrets.plugin.Types.fail;
+import static JAVAPACKAGE.feature.secrets.plugin.Types.newmap;
+import static JAVAPACKAGE.feature.secrets.plugin.Types.num;
+import static JAVAPACKAGE.feature.secrets.plugin.Types.str;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Versions and ranges (§11.2).
+ *
+ * <p>TWO FIELDS AND ONE PREDICATE. A capability declares {@code version},
+ * a concrete version. A requirement declares {@code range}. A requirement
+ * is satisfied when the names match, the {@code match} passes, and the
+ * provider's {@code version} falls inside the requirement's {@code range}.
+ *
+ * <p>That is the whole rule. There is no third field and no second
+ * comparison - an earlier draft added a provider-side {@code compat}
+ * range, which left three values and no statement of how they combine, and
+ * three defensible readings of one declaration is worse than the ambiguity
+ * it was introduced to fix.
+ */
+public final class Version {
+
+  private Version() {}
+
+  /**
+   * A COMPONENT IS BOUNDED, and the bound is the model's, not the host
+   * language's. Java's {@code long} and JavaScript's {@code Number}
+   * disagree past 2**53, so a twenty-digit component parsed to an exact
+   * value in one and a rounded one in the other. 2**31-1 is the smallest
+   * bound every target language holds exactly, which makes it the model's.
+   */
+  public static final long COMPONENT_MAX = 2147483647L;
+
+  private static long component(String digits, String whole, String field) {
+    long value;
+    try {
+      value = Long.parseLong(digits);
+    } catch (NumberFormatException e) {
+      // Too long for a long is out of range by definition - the parse
+      // failure and the bound check are the same answer, so they give the
+      // same code.
+      value = COMPONENT_MAX + 1;
+    }
+    if (COMPONENT_MAX < value) {
+      fail(
+          "plugin_bad_range",
+          "version component out of range in " + whole + ": " + digits,
+          details(field, whole));
+    }
+    return value;
+  }
+
+  /**
+   * {@code 1}, {@code 1.2} or {@code 1.2.3}, fully anchored - and there is
+   * no regex here, so "anchored" is what the code does rather than what an
+   * engine was asked for.
+   */
+  private static long[] parts(String text, String whole, String field) {
+    String[] pieces = text.split("\\.", -1);
+    if (0 == pieces.length || 3 < pieces.length) {
+      return null;
+    }
+    long[] out = new long[] {0, 0, 0};
+    for (int i = 0; i < pieces.length; i++) {
+      String piece = pieces[i];
+      if (piece.isEmpty()) {
+        return null;
+      }
+      for (int j = 0; j < piece.length(); j++) {
+        char c = piece.charAt(j);
+        if (c < '0' || '9' < c) {
+          return null;
+        }
+      }
+      out[i] = component(piece, whole, field);
+    }
+    return out;
+  }
+
+  /**
+   * Two forms and no more (§11.2):
+   *
+   * <pre>
+   *   '2.1'    &gt;= 2.1.0 and &lt; 3.0.0
+   *   '~2.1'   &gt;= 2.1.0 and &lt; 2.2.0
+   * </pre>
+   */
+  public static Map<String, Object> parseRange(Object range) {
+    String text = str(range);
+    if (null == text || text.isEmpty()) {
+      fail("plugin_bad_range", "invalid range: " + Json.write(range), details("range", range));
+    }
+
+    boolean tilde = text.startsWith("~");
+    String body = tilde ? text.substring(1) : text;
+    long[] got = parts(body, text, "range");
+    if (null == got) {
+      fail("plugin_bad_range", "invalid range: " + text, details("range", range));
+    }
+
+    List<Object> lo = new ArrayList<>();
+    lo.add((double) got[0]);
+    lo.add((double) got[1]);
+    lo.add((double) got[2]);
+
+    List<Object> hi = new ArrayList<>();
+    if (tilde) {
+      hi.add((double) got[0]);
+      hi.add((double) (got[1] + 1));
+      hi.add(0.0);
+    } else {
+      hi.add((double) (got[0] + 1));
+      hi.add(0.0);
+      hi.add(0.0);
+    }
+
+    Map<String, Object> out = newmap();
+    out.put("lo", lo);
+    out.put("hi", hi);
+    return out;
+  }
+
+  public static long[] parseVersion(Object version) {
+    String text = str(version);
+    if (null == text) {
+      fail(
+          "plugin_bad_range",
+          "invalid version: " + Json.write(version),
+          details("version", version));
+    }
+    long[] got = parts(text, text, "version");
+    if (null == got) {
+      fail("plugin_bad_range", "invalid version: " + text, details("version", version));
+    }
+    return got;
+  }
+
+  /** The one satisfaction predicate: lo &lt;= version &lt; hi. */
+  public static boolean satisfies(Object version, Object range) {
+    long[] v = parseVersion(version);
+    Map<String, Object> r = parseRange(range);
+    return 0 <= compare(v, triple(r.get("lo"))) && 0 > compare(v, triple(r.get("hi")));
+  }
+
+  /**
+   * satisfies for the internal callers that treat an unparseable version
+   * or range as "does not satisfy" - Capability and Graph, both of which
+   * run over data the corpus has already admitted.
+   */
+  public static boolean satisfiesq(Object version, Object range) {
+    try {
+      return satisfies(version, range);
+    } catch (PluginException e) {
+      return false;
+    }
+  }
+
+  private static long[] triple(Object value) {
+    long[] out = new long[3];
+    for (int i = 0; i < 3; i++) {
+      Double n = num(at(value, i));
+      out[i] = null == n ? 0 : (long) (double) n;
+    }
+    return out;
+  }
+
+  private static int compare(long[] a, long[] b) {
+    for (int i = 0; i < 3; i++) {
+      if (a[i] != b[i]) {
+        return a[i] < b[i] ? -1 : 1;
+      }
+    }
+    return 0;
+  }
+
+  /** The version triple as a comparable key, for the capability rank. */
+  public static List<Long> versionParts(String text) {
+    List<Long> out = new ArrayList<>();
+    for (String piece : text.split("\\.", -1)) {
+      try {
+        out.add(Long.parseLong(piece));
+      } catch (NumberFormatException e) {
+        out.add(0L);
+      }
+    }
+    return out;
+  }
+}