@voxgig/sdkgen 4.8.3 → 4.10.0

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

@@ -0,0 +1,173 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (java/src/voxgig/plugin/Inst.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.asint;
+import static JAVAPACKAGE.feature.secrets.plugin.Types.details;
+import static JAVAPACKAGE.feature.secrets.plugin.Types.fail;
+import static JAVAPACKAGE.feature.secrets.plugin.Types.str;
+
+import java.util.Map;
+
+/**
+ * What a definition's callbacks see.
+ *
+ * <p>Deliberately not the internal record: a plugin that could reach
+ * {@code status} could also write it.
+ */
+public final class Inst {
+
+  public final Host host;
+  public final String ref;
+  public final String name;
+  public final String tag;
+
+  private final Entry entry;
+
+  Inst(Host host, Entry entry) {
+    this.host = host;
+    this.entry = entry;
+    this.ref = entry.ref;
+    Map<String, Object> parsed = Refs.parseRef(entry.ref);
+    this.name = str(parsed.get("name"));
+    this.tag = str(parsed.get("tag"));
+  }
+
+  /**
+   * The resolved options, READ FRESH. {@code apply} and {@code options}
+   * replace the map wholesale, so a callback that cached this at {@code
+   * define} would hold the values a later document already changed.
+   */
+  public Object options() {
+    return entry.options;
+  }
+
+  /**
+   * The instance's own state (§5.4), LIVE: a java map is a reference, so a
+   * callback that keeps this sees every later write, and the counter
+   * surviving a deactivate/activate cycle is that reference and nothing
+   * else.
+   */
+  public Map<String, Object> state() {
+    return entry.state;
+  }
+
+  /**
+   * Foreign resources the host did not hand out are registered explicitly
+   * (§8.3); host calls are recorded automatically.
+   *
+   * <p>SYMMETRIC WITH {@code acquire}, and it has to be: {@code open}
+   * counts the resources CURRENTLY HELD, so an entry that is registered
+   * and then unwound must leave the count where it found it.
+   */
+  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".equals(host.phase())) {
+      fail("plugin_release_scope", "release called outside activate", null);
+    }
+    boolean[] done = new boolean[] {false};
+    entry.scope.add(
+        () -> {
+          if (done[0]) {
+            return;
+          }
+          done[0] = true;
+          host.opendec();
+          func.run();
+        });
+    host.openinc();
+  }
+
+  /**
+   * The synthetic counter the driver owns, so "what is open" is data
+   * rather than an assertion each port words differently.
+   *
+   * <p>Returns its own release, so a plugin can hand one back early. The
+   * scope still holds the entry and unwinding it twice is a no-op -
+   * releasing early must not make teardown wrong.
+   */
+  public Entry.ScopeFn acquire() {
+    // §8.1: resources are "acquired during `activate` - the scope's actual
+    // job". Same reason as `release` above.
+    if (!"activate".equals(host.phase())) {
+      fail("plugin_release_scope", "acquire called outside activate", null);
+    }
+    boolean[] done = new boolean[] {false};
+    Entry.ScopeFn rel =
+        () -> {
+          if (done[0]) {
+            return;
+          }
+          done[0] = true;
+          host.opendec();
+        };
+    entry.scope.add(rel);
+    host.openinc();
+    return rel;
+  }
+
+  /**
+   * Bind into a host point. Declared in {@code define}; the host inserts
+   * it only after {@code activate} returns successfully (§8.1), which is
+   * why a failing activate leaves no live binding behind.
+   */
+  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: a binding added from `activate`
+    // went live without being part of the loaded definition, and a
+    // deactivate/activate cycle appended it again.
+    if (!"define".equals(host.phase())) {
+      fail(
+          "plugin_bind_scope",
+          "bind called outside define: " + point,
+          details("ref", ref, "point", point));
+    }
+    if (!host.haspoint(point)) {
+      fail("plugin_point_unknown", "no such point: " + point, details("point", point));
+    }
+    Long value = asint(band);
+    entry.bindings.add(new Point.Bound(ref, point, func, null == value ? 0 : value));
+  }
+
+  /** Published for other plugins and for the application (§11). */
+  public void export(String key, Object value) {
+    entry.exports.put(key, value);
+  }
+
+  /** What this instance can do for others (§11.1). */
+  public void provides(Object prov) {
+    entry.provides.add(prov);
+  }
+
+  /**
+   * 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. Verification tells a plugin it was misplaced; a pin (§7)
+   * stops the misplacement from being expressible at all. The two are not
+   * substitutes.
+   */
+  public Object position(String point) {
+    return host.positionof(ref, point);
+  }
+
+  /**
+   * 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.
+   */
+  public Host nest(Object nestopts) {
+    if (!host.intransition()) {
+      fail("plugin_release_scope", "nest called outside a lifecycle callback", null);
+    }
+    Host inner = new Host(nestopts);
+    entry.scope.add(inner::close);
+    entry.inner = inner;
+    return inner;
+  }
+}

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

@@ -0,0 +1,339 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (java/src/voxgig/plugin/Json.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;
+
+/**
+ * The JSON value model, and the only parser this port has.
+ *
+ * <p>NO JACKSON, NO GSON, NO JUNIT (§16). The library is allowed exactly
+ * one runtime dependency, {@code voxgig/struct}, which has no java port;
+ * everything else is the JDK. Parsing the corpus is two hundred lines, and
+ * two hundred lines is cheaper than a dependency every embedding host
+ * inherits.
+ *
+ * <p>THE VALUE MODEL IS PLAIN {@code Object}, and each JSON type has ONE
+ * java spelling: {@code null}, {@link Boolean}, {@link Double}, {@link
+ * String}, {@code List<Object>}, {@code Map<String,Object>}. A map is
+ * always a {@link TreeMap} - every port has to sort its keys before
+ * iterating, and a sorted map makes that the default rather than a
+ * discipline to remember.
+ *
+ * <p>A NUMBER IS ALWAYS A {@code Double}, because JSON has one number type
+ * and the canonical is javascript. An {@code Integer} anywhere in this
+ * data would compare unequal to the {@code Double} the parser produced for
+ * the same literal - {@code Integer.valueOf(1).equals(Double.valueOf(1))}
+ * is false - and the corpus would fail on a distinction the model does not
+ * have.
+ */
+public final class Json {
+
+  private Json() {}
+
+  public static Object parse(String text) {
+    Parser parser = new Parser(text);
+    parser.skipws();
+    Object value = parser.value();
+    parser.skipws();
+    if (parser.at < parser.chars.length) {
+      throw new IllegalArgumentException("trailing input at " + parser.at);
+    }
+    return value;
+  }
+
+  /** Compact JSON, map keys in sorted order (which a TreeMap already is). */
+  public static String write(Object value) {
+    StringBuilder out = new StringBuilder();
+    writeTo(value, out);
+    return out.toString();
+  }
+
+  @SuppressWarnings("unchecked")
+  private static void writeTo(Object value, StringBuilder out) {
+    if (null == value) {
+      out.append("null");
+      return;
+    }
+    if (value instanceof Boolean) {
+      out.append(((Boolean) value) ? "true" : "false");
+      return;
+    }
+    if (value instanceof Double) {
+      double n = (Double) value;
+      // An integral double prints without a fractional part, so a `pos` of
+      // 3 renders as `3` and not `3.0` - JSON has one number type and the
+      // corpus writes them as it means them.
+      if (n == Math.floor(n) && !Double.isInfinite(n) && Math.abs(n) < 1e15) {
+        out.append((long) n);
+      } else {
+        out.append(n);
+      }
+      return;
+    }
+    if (value instanceof String) {
+      writeString((String) value, out);
+      return;
+    }
+    if (value instanceof List) {
+      out.append('[');
+      boolean first = true;
+      for (Object item : (List<Object>) value) {
+        if (!first) {
+          out.append(',');
+        }
+        first = false;
+        writeTo(item, out);
+      }
+      out.append(']');
+      return;
+    }
+    if (value instanceof Map) {
+      out.append('{');
+      boolean first = true;
+      for (Map.Entry<String, Object> e : ((Map<String, Object>) value).entrySet()) {
+        if (!first) {
+          out.append(',');
+        }
+        first = false;
+        writeString(e.getKey(), out);
+        out.append(':');
+        writeTo(e.getValue(), 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('"');
+    for (int i = 0; i < text.length(); i++) {
+      char c = text.charAt(i);
+      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(String.format("\\u%04x", (int) c));
+          } else {
+            out.append(c);
+          }
+      }
+    }
+    out.append('"');
+  }
+
+  private static final class Parser {
+    private final char[] chars;
+    private int at;
+
+    Parser(String text) {
+      this.chars = text.toCharArray();
+      this.at = 0;
+    }
+
+    void skipws() {
+      while (at < chars.length
+          && (' ' == chars[at] || '\t' == chars[at] || '\n' == chars[at] || '\r' == chars[at])) {
+        at++;
+      }
+    }
+
+    Object value() {
+      if (chars.length <= at) {
+        throw new IllegalArgumentException("unexpected end of input");
+      }
+      switch (chars[at]) {
+        case '{':
+          return map();
+        case '[':
+          return list();
+        case '"':
+          return string();
+        case 't':
+          return literal("true", Boolean.TRUE);
+        case 'f':
+          return literal("false", Boolean.FALSE);
+        case 'n':
+          return literal("null", null);
+        default:
+          return number();
+      }
+    }
+
+    Object literal(String word, Object value) {
+      for (int i = 0; i < word.length(); i++) {
+        if (chars.length <= at + i || chars[at + i] != word.charAt(i)) {
+          throw new IllegalArgumentException("bad literal at " + at);
+        }
+      }
+      at += word.length();
+      return value;
+    }
+
+    Object map() {
+      Map<String, Object> out = new TreeMap<>();
+      at++;
+      skipws();
+      if (at < chars.length && '}' == chars[at]) {
+        at++;
+        return out;
+      }
+      while (true) {
+        skipws();
+        String key = string();
+        skipws();
+        if (chars.length <= at || ':' != chars[at]) {
+          throw new IllegalArgumentException("expected ':' at " + at);
+        }
+        at++;
+        skipws();
+        out.put(key, value());
+        skipws();
+        if (chars.length <= at) {
+          throw new IllegalArgumentException("unexpected end in object");
+        }
+        if (',' == chars[at]) {
+          at++;
+          continue;
+        }
+        if ('}' == chars[at]) {
+          at++;
+          return out;
+        }
+        throw new IllegalArgumentException("expected ',' or '}' at " + at);
+      }
+    }
+
+    Object list() {
+      List<Object> out = new ArrayList<>();
+      at++;
+      skipws();
+      if (at < chars.length && ']' == chars[at]) {
+        at++;
+        return out;
+      }
+      while (true) {
+        skipws();
+        out.add(value());
+        skipws();
+        if (chars.length <= at) {
+          throw new IllegalArgumentException("unexpected end in array");
+        }
+        if (',' == chars[at]) {
+          at++;
+          continue;
+        }
+        if (']' == chars[at]) {
+          at++;
+          return out;
+        }
+        throw new IllegalArgumentException("expected ',' or ']' at " + at);
+      }
+    }
+
+    String string() {
+      if (chars.length <= at || '"' != chars[at]) {
+        throw new IllegalArgumentException("expected a string at " + at);
+      }
+      at++;
+      StringBuilder out = new StringBuilder();
+      while (at < chars.length) {
+        char c = chars[at];
+        at++;
+        if ('"' == c) {
+          return out.toString();
+        }
+        if ('\\' != c) {
+          out.append(c);
+          continue;
+        }
+        if (chars.length <= at) {
+          throw new IllegalArgumentException("unexpected end in string");
+        }
+        char e = chars[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 java char IS a UTF-16 code unit, so a surrogate pair needs
+            // no joining here: appending both halves is the string.
+            if (chars.length < at + 4) {
+              throw new IllegalArgumentException("bad \\u escape at " + at);
+            }
+            out.append((char) Integer.parseInt(new String(chars, at, 4), 16));
+            at += 4;
+            break;
+          default:
+            throw new IllegalArgumentException("bad escape at " + at);
+        }
+      }
+      throw new IllegalArgumentException("unterminated string");
+    }
+
+    Object number() {
+      int start = at;
+      if (at < chars.length && '-' == chars[at]) {
+        at++;
+      }
+      while (at < chars.length
+          && (Character.isDigit(chars[at])
+              || '.' == chars[at]
+              || 'e' == chars[at]
+              || 'E' == chars[at]
+              || '+' == chars[at]
+              || '-' == chars[at])) {
+        at++;
+      }
+      String text = new String(chars, start, at - start);
+      try {
+        return Double.valueOf(text);
+      } catch (NumberFormatException e) {
+        throw new IllegalArgumentException("bad number " + text + " at " + start);
+      }
+    }
+  }
+}