@voxgig/sdkgen 4.9.0 → 4.11.0

package/project/.sdk/tm/rb/feature/secrets/voxgig_plugin/order.rb

@@ -0,0 +1,169 @@
+# VENDORED: @voxgig/plugin sdk-20260908-1556-0 (ruby/lib/voxgig_plugin/order.rb)
+# 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.
+# frozen_string_literal: true
+
+# Ordering (section 7) - one rule, one place.
+#
+# sdkgen grew two special cases in `makeOptions` (`test`, then `station`)
+# and the third was not far off. This sort is the whole replacement, and
+# the tiers are in this order for a reason:
+#
+#   1 constraints   before/after edges, by ref or by name
+#   2 bands         integer, lower first, default 0
+#   3 declaration   ties break by `pos`
+#
+# CONSTRAINTS BEAT BANDS precisely so the correct tool wins when both are
+# present. A band expresses a genuine cross-cutting layer; a constraint
+# expresses a relationship between two specific things; and a band chosen
+# by trial and error to fix an ordering bug is a bug wearing a number.
+
+require_relative 'types'
+require_relative 'ref'
+
+module VoxgigPlugin
+  def self.resolve_order(bindings, pin = nil)
+    nodes = bindings.dup
+    byref = {}
+    nodes.each { |b| byref[b['ref']] = b }
+
+    # Constraints are edges. A constraint naming an ABSENT binding is
+    # satisfied VACUOUSLY (section 7) - a plugin ordered `after: 'test'`
+    # must load in a host with no test plugin. That is sdkgen's
+    # __after__ behaviour, kept.
+    edges = {}
+    nodes.each { |b| edges[b['ref']] = [] }
+
+    nodes.each do |b|
+      block = b['order'] || {}
+      # An ABSENT constraint and an EMPTY LIST are both "no constraint".
+      if order_declared(block['after'])
+        order_targets(block['after'], nodes).each { |t| edges[t] << b['ref'] }
+      end
+      if order_declared(block['before'])
+        order_targets(block['before'], nodes).each { |t| edges[b['ref']] << t }
+      end
+    end
+
+    # Stable topological sort. Among ready nodes, band first (lower runs
+    # first), then `pos` - the position the DOCUMENT visibly states, not
+    # the order instances happened to load and not the incarnation `seq`.
+    indeg = {}
+    nodes.each { |b| indeg[b['ref']] = 0 }
+    edges.each_value { |tos| tos.each { |to| indeg[to] += 1 } }
+
+    out = []
+    ready = nodes.select { |b| indeg[b['ref']].zero? }
+
+    until ready.empty?
+      ready = Util.stable_sort_by(ready) { |b| [order_band(b), b['pos'] || 0] }
+      nxt = ready.shift
+      out << nxt['ref']
+      edges[nxt['ref']].each do |to|
+        indeg[to] -= 1
+        ready << byref[to] if indeg[to].zero?
+      end
+    end
+
+    if out.length != nodes.length
+      stuck = nodes.reject { |b| out.include?(b['ref']) }.map { |b| b['ref'] }
+      fail_with('plugin_order_cycle',
+                "before/after constraints cycle: #{stuck.join(' -> ')}",
+                { 'cycle' => stuck })
+    end
+
+    applypin(out, edges, pin)
+  end
+
+  def self.order_band(binding)
+    block = binding['order'] || {}
+    value = block['band']
+    value.is_a?(Integer) ? value : 0
+  end
+
+  # Matching is by REF, or by NAME across all of that definition's
+  # instances (section 7) - which is the whole reason the two spellings
+  # exist.
+  # Was a constraint stated? An absent value and an EMPTY LIST are both
+  # no-constraint - and [] is truthy in Ruby, which is exactly how this
+  # class of bug survives a reading.
+  def self.order_declared(spec)
+    return false if spec.nil?
+    return spec.any? { |one| '' != one } if spec.is_a?(Array)
+
+    '' != spec
+  end
+
+  # One spelling or a LIST of them. A list fans out to the UNION of what
+  # each names, so after: ['a','b'] means after BOTH, and the same
+  # instance named twice - once by name, once by ref - is one edge.
+  def self.order_targets(spec, nodes)
+    specs = spec.is_a?(Array) ? spec : [spec]
+    hit = []
+    specs.each do |one|
+      nodes.each do |b|
+        next if hit.include?(b['ref'])
+
+        hit << b['ref'] if b['ref'] == one || refname(b['ref']) == one
+      end
+    end
+    hit
+  end
+
+  # A PIN IS NOT A CONSTRAINT (section 7).
+  #
+  # Constraints and bands are negotiable by definition - they are what
+  # plugins and documents say they want, and the sort's job is to satisfy
+  # them all. A pin is the host stating a structural invariant of its own
+  # architecture, which is a different kind of claim and must not lose a
+  # tie to a document.
+  #
+  # So a pin PLACES the binding at the named end, and an ordering that
+  # would move it away is `plugin_order_pinned` - rejected, not honoured
+  # into a broken wrap.
+  def self.applypin(order, edges, pin)
+    return order if pin.nil?
+
+    out = order.dup
+
+    # SORTED, not insertion order. A pin map is data - it can arrive from
+    # a host's own construction options in any order, and two names
+    # pinned to the same end are order-sensitive (`{b:'first',
+    # a:'first'}` and `{a:'first', b:'first'}` give different results).
+    # Ruby hashes are insertion-ordered and a Go map has no order at all,
+    # so leaving it unstated made the same declaration mean different
+    # things in different ports.
+    pin.keys.sort.each do |name|
+      want = pin[name]
+      idx = out.index { |r| refname(r) == name }
+      next if idx.nil?
+
+      # `first`/`outermost` is index 0; `last`/`innermost` is the end.
+      # Section 6.2 makes the first chain binding outermost, which is why
+      # the vocabulary is positional and why the two spellings pair this
+      # way.
+      wantfirst = %w[first outermost].include?(want)
+      ref = out.delete_at(idx)
+      wantfirst ? out.unshift(ref) : out.push(ref)
+    end
+
+    # Now check that the placement did not break a constraint. This is
+    # the half that makes a pin a rejection rather than an override: the
+    # host wins on position, but it does not get to silently discard a
+    # relationship a plugin declared.
+    at = {}
+    out.each_with_index { |r, i| at[r] = i }
+    edges.each do |from, tos|
+      tos.each do |to|
+        next unless at[from] > at[to]
+
+        fail_with('plugin_order_pinned',
+                  'a pin would move a binding an ordering constrains: ' \
+                  "#{from} must precede #{to}",
+                  { 'before' => from, 'after' => to })
+      end
+    end
+
+    out
+  end
+end

package/project/.sdk/tm/rb/feature/secrets/voxgig_plugin/point.rb

@@ -0,0 +1,93 @@
+# VENDORED: @voxgig/plugin sdk-20260908-1556-0 (ruby/lib/voxgig_plugin/point.rb)
+# 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.
+# frozen_string_literal: true
+
+# Extension points (section 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.
+
+require_relative 'types'
+
+module VoxgigPlugin
+  # Section 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.
+  MODES = %w[emit parallel serial bail].freeze
+
+  # Fan-out. Return values are ignored except in `bail`.
+  def self.point_emit(bindings, mode, arg)
+    if mode == 'bail'
+      # Stops at the first binding that RETURNS A VALUE - the "handled,
+      # stop" case. A `nil` RETURN DECLINES (section 6.1): ruby has one
+      # way to say nothing, and the model's rule is written to that
+      # rather than to JavaScript's null/undefined pair. `unless
+      # v.nil?`, NOT `if v` - `false` is a value.
+      bindings.each do |b|
+        v = b['fn'].call(arg)
+        return v unless v.nil?
+      end
+      return nil
+    end
+
+    errors = []
+    bindings.each do |b|
+      begin
+        b['fn'].call(arg)
+      rescue StandardError => e
+        # `emit` raises synchronously; the collecting modes gather.
+        raise if mode == 'emit'
+
+        errors << e
+      end
+    end
+    mode == 'emit' ? nil : errors
+  end
+
+  # Composition: b1(b2(b3(base))), FIRST BINDING OUTERMOST (section 6.2).
+  #
+  # Recomputed by the host whenever the live set changes, and cached
+  # between changes. Plugins receive `next` as an argument; they never
+  # see or store the previous value of anything. A plugin that stashes
+  # `next` and calls it after deactivation is a bug the host cannot
+  # prevent, and this says so rather than pretending otherwise.
+  def self.compose(bindings, base)
+    nxt = base
+    (bindings.length - 1).downto(0) do |i|
+      fn = bindings[i]['fn']
+      inner = nxt
+      # `fn` and `inner` are block-local here, so each layer closes over
+      # its own pair - ruby's blocks capture the binding, and reusing one
+      # variable would leave every layer calling the last one.
+      nxt = ->(*args) { fn.call(inner, *args) }
+    end
+    nxt
+  end
+
+  # At most one live implementation (section 6.3). The winner is the
+  # highest band, ties broken by ref sort, and THE LOSERS ARE VISIBLE
+  # rather than silently ignored.
+  def self.point_provider(bindings, spec)
+    return { 'winner' => nil, 'shadowed' => [] } if bindings.empty?
+
+    if spec['exclusive'] && bindings.length > 1
+      refs = bindings.map { |b| b['ref'] }.sort
+      fail_with('plugin_point_exclusive',
+                "point is exclusive and has #{bindings.length} bindings: " \
+                "#{refs.join(', ')}",
+                { 'refs' => refs })
+    end
+
+    ranked = Util.stable_sort_by(bindings) { |b| [-b['band'], b['ref']] }
+    { 'winner' => ranked[0], 'shadowed' => ranked[1..].map { |b| b['ref'] } }
+  end
+end

package/project/.sdk/tm/rb/feature/secrets/voxgig_plugin/ref.rb

@@ -0,0 +1,112 @@
+# VENDORED: @voxgig/plugin sdk-20260908-1556-0 (ruby/lib/voxgig_plugin/ref.rb)
+# 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.
+# frozen_string_literal: true
+
+# Identity: name+tag, written `name$tag` (section 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.
+
+require_relative 'types'
+
+module VoxgigPlugin
+  # Section 4: `^[a-zA-Z@][a-zA-Z0-9.~_\-/]*$`, max 1024.
+  #
+  # \A and \z, NOT ^ and $. Ruby's ^ and $ match at a LINE boundary, so
+  # "a\nb$c" would pass a ^...$ anchored name check - a ref grammar with
+  # a newline in it, admitted by exactly the port whose regex idiom
+  # differs from every other language's.
+  NAME_RE = /\A[a-zA-Z@][a-zA-Z0-9.~_\-\/]*\z/.freeze
+
+  # Section 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.
+  TAG_RE = /\A[a-zA-Z0-9.~_-]+\z/.freeze
+
+  REF_MAX = 1024
+
+  def self.check_name(name)
+    return false unless name.is_a?(String)
+    return false if name.empty? || REF_MAX < name.length
+
+    !NAME_RE.match(name).nil?
+  end
+
+  def self.check_tag(tag)
+    return false unless tag.is_a?(String)
+    # The empty tag is an ordinary tag (section 4 rule 2). The
+    # single-instance case writes no tag and never learns tags exist.
+    return true if tag.empty?
+    return false if REF_MAX < tag.length
+
+    !TAG_RE.match(tag).nil?
+  end
+
+  # `name$tag` -> the pair. Canonicalizing: `stripe$` and `stripe` both
+  # give tag ''.
+  def self.parse_ref(str)
+    fail_with('plugin_bad_name', 'ref must be a string') unless str.is_a?(String)
+
+    # Split on the FIRST `$`. Nothing in the grammar decides this - `$`
+    # is in neither character class - so the corpus is the arbiter
+    # (section 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.
+    cut = str.index('$')
+    name = cut.nil? ? str : str[0, cut]
+    tag = cut.nil? ? '' : str[(cut + 1)..]
+
+    unless check_name(name)
+      fail_with('plugin_bad_name', "invalid plugin name: #{name}", { 'name' => name })
+    end
+    unless check_tag(tag)
+      fail_with('plugin_bad_tag', "invalid plugin tag: #{tag}",
+                { 'name' => name, 'tag' => tag })
+    end
+
+    { 'name' => name, 'tag' => tag }
+  end
+
+  # The pair -> `name$tag`. An empty tag NEVER writes the separator,
+  # which is the half of canonicalization format_ref owns: parse
+  # tolerates `stripe$`, format never produces it, so a round trip is
+  # idempotent.
+  def self.format_ref(name, tag = nil)
+    tag = '' if tag.nil?
+    unless check_name(name)
+      fail_with('plugin_bad_name', "invalid plugin name: #{name}", { 'name' => name })
+    end
+    unless check_tag(tag)
+      fail_with('plugin_bad_tag', "invalid plugin tag: #{tag}",
+                { 'name' => name, 'tag' => tag })
+    end
+    tag.empty? ? name : "#{name}$#{tag}"
+  end
+
+  # The canonical spelling of a ref. Section 4 rule 5: ports must
+  # canonicalize before comparison.
+  def self.canon_ref(str)
+    r = parse_ref(str)
+    format_ref(r['name'], r['tag'])
+  end
+
+  # canon_ref 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.
+  def self.canon(str)
+    canon_ref(str)
+  rescue PluginError
+    str
+  end
+
+  def self.refname(str)
+    parse_ref(str)['name']
+  rescue PluginError
+    str
+  end
+end

package/project/.sdk/tm/rb/feature/secrets/voxgig_plugin/resolve.rb

@@ -0,0 +1,56 @@
+# VENDORED: @voxgig/plugin sdk-20260908-1556-0 (ruby/lib/voxgig_plugin/resolve.rb)
+# 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.
+# frozen_string_literal: true
+
+# Dynamic resolution (section 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, and it
+# is why section 15.4 puts real module loading in per-port integration
+# tests rather than here.
+
+module VoxgigPlugin
+  DEFAULT_SOURCES = [
+    { 'kind' => 'module',
+      'prefix' => ['@voxgig/plugin-', 'voxgig-plugin-', 'plugin-', ''] }
+  ].freeze
+
+  def self.resolve_candidates(name, sources = nil)
+    out = []
+
+    # A SCOPED NAME RESOLVES VERBATIM ONLY (section 10.2). `@acme/thing`
+    # is already a package id; prefixing it produces
+    # `@voxgig/plugin-@acme/thing`, which is not a thing that can exist.
+    return [name] if name.start_with?('@')
+
+    list = sources.nil? || sources.empty? ? DEFAULT_SOURCES : sources
+
+    list.each do |src|
+      case src['kind']
+      when 'module'
+        prefixes = src['prefix']
+        prefixes = [''] if prefixes.nil? || prefixes.empty?
+        prefixes.each do |p|
+          id = p + name
+          out << id unless out.include?(id)
+        end
+      when 'path'
+        id = "#{src['dir'].sub(%r{/+\z}, '')}/#{name}"
+        out << id unless out.include?(id)
+      end
+    end
+
+    out
+  end
+
+  # A MODULE PATH IS NOT A NAME (section 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.
+  def self.resolve_from(from)
+    [from]
+  end
+end

package/project/.sdk/tm/rb/feature/secrets/voxgig_plugin/types.rb

@@ -0,0 +1,99 @@
+# VENDORED: @voxgig/plugin sdk-20260908-1556-0 (ruby/lib/voxgig_plugin/types.rb)
+# 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.
+# frozen_string_literal: true
+
+# Shared types. Deliberately small: the design's section 19 budget says
+# the library owns naming, configuration, lifecycle, ordering, binding
+# and teardown, and nothing else.
+#
+# RUBY'S ONE STRUCTURAL HAZARD IS SORT STABILITY. Array#sort and
+# #sort_by are NOT guaranteed stable, and the canonical leans on
+# JavaScript's stable sort in three places. Every sort in this port goes
+# through `Util.stable_sort_by`, which decorates with the original index.
+
+require 'json'
+
+module VoxgigPlugin
+  # Section 5.1's seven statuses, and no more. A port that adds an eighth
+  # is diverging. `loading` and `closing` are observable only from inside
+  # a callback or from another thread.
+  STATUSES = %w[declared loaded pending live failed loading closing].freeze
+
+  # Section 12's detail fields, IN THIS FIXED ORDER.
+  #
+  # 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.
+  DETAIL_ORDER = %w[
+    host ref name tag point key capability
+    range version match candidates cycle holders
+    refs path cause
+  ].freeze
+
+  # `plugin/<code>: <text> [<key>=<value> ...]`
+  #
+  # 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.
+  def self.formaterror(code, text, details = nil)
+    details ||= {}
+    parts = DETAIL_ORDER.filter_map do |k|
+      next unless details.key?(k)
+
+      "#{k}=#{JSON.generate(details[k])}"
+    end
+    tail = parts.empty? ? '' : " [#{parts.join(' ')}]"
+    "plugin/#{code}: #{text}#{tail}"
+  end
+
+  # Every error carries a section 12 code. Ports compare by CODE and
+  # never by message: wording is a port's own business, and pinning the
+  # words would make every translation a corpus change. The FORMAT,
+  # however, is pinned - a parseable message is what makes a log
+  # searchable across twenty languages.
+  class PluginError < StandardError
+    attr_reader :code, :text, :details
+
+    def initialize(code, text, details = nil)
+      @code = code
+      @text = text
+      @details = details || {}
+      super(VoxgigPlugin.formaterror(code, text, details))
+    end
+  end
+
+  def self.fail_with(code, text, details = nil)
+    raise PluginError.new(code, text, details)
+  end
+
+  # The section 12 code of an error, 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.
+  def self.codeof(err)
+    err.respond_to?(:code) ? err.code : ''
+  end
+
+  module Util
+    # STABLE sort by a computed key. Ruby's own sort is not stable, and
+    # the canonical's comparators fall through to a tie-break that
+    # JavaScript's stable sort resolves by position - so an unstable
+    # sort here diverges on nothing the corpus could name.
+    def self.stable_sort_by(list)
+      list.each_with_index.sort_by { |item, i| [yield(item), i] }.map(&:first)
+    end
+
+    def self.map?(value)
+      value.is_a?(Hash)
+    end
+
+    def self.clone_value(value)
+      case value
+      when Array then value.map { |v| clone_value(v) }
+      when Hash then value.each_with_object({}) { |(k, v), o| o[k] = clone_value(v) }
+      else value
+      end
+    end
+  end
+end

package/project/.sdk/tm/rb/feature/secrets/voxgig_plugin/version.rb

@@ -0,0 +1,106 @@
+# VENDORED: @voxgig/plugin sdk-20260908-1556-0 (ruby/lib/voxgig_plugin/version.rb)
+# 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.
+# frozen_string_literal: true
+
+# Versions and ranges (section 11.2).
+#
+# TWO FIELDS AND ONE PREDICATE. A capability declares `version`, a
+# concrete version. A requirement declares `range`. A requirement is
+# satisfied when the names match, the `match` passes, and:
+#
+#   the provider's `version` falls inside the requirement's `range`.
+#
+# That is the whole rule. There is no third field and no second
+# comparison - an earlier draft added a provider-side `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.
+
+require_relative 'types'
+
+module VoxgigPlugin
+  VERSION_RE = /\A(\d+)(?:\.(\d+))?(?:\.(\d+))?\z/.freeze
+
+  # A COMPONENT IS BOUNDED, and the bound is the model's, not the host
+  # language's. Ruby integers are unbounded and JavaScript's stop being
+  # exact past 2**53, so `9223372036854775808.0.0` parsed to an exact
+  # value here and a rounded one there. 2**31-1 is the smallest bound
+  # every target language holds exactly, which makes it the model's.
+  COMPONENT_MAX = 2_147_483_647
+
+  def self.component(digits, whole, field)
+    value = digits.to_i
+    if COMPONENT_MAX < value
+      fail_with('plugin_bad_range',
+                "version component out of range in #{whole}: #{digits}",
+                { field => whole })
+    end
+    value
+  end
+
+  # Two forms and no more (section 11.2):
+  #
+  #   '2.1'    >= 2.1.0 and < 3.0.0
+  #   '~2.1'   >= 2.1.0 and < 2.2.0
+  def self.parse_range(range)
+    unless range.is_a?(String) && !range.empty?
+      fail_with('plugin_bad_range', "invalid range: #{range}", { 'range' => range })
+    end
+
+    tilde = range.start_with?('~')
+    body = tilde ? range[1..] : range
+    m = VERSION_RE.match(body)
+    if m.nil?
+      fail_with('plugin_bad_range', "invalid range: #{range}", { 'range' => range })
+    end
+
+    major = component(m[1], range, 'range')
+    minor = m[2].nil? ? 0 : component(m[2], range, 'range')
+    patch = m[3].nil? ? 0 : component(m[3], range, 'range')
+
+    lo = [major, minor, patch]
+    hi = tilde ? [major, minor + 1, 0] : [major + 1, 0, 0]
+    { 'lo' => lo, 'hi' => hi }
+  end
+
+  def self.parse_version(version)
+    unless version.is_a?(String)
+      fail_with('plugin_bad_range', "invalid version: #{version}",
+                { 'version' => version })
+    end
+    m = VERSION_RE.match(version)
+    if m.nil?
+      fail_with('plugin_bad_range', "invalid version: #{version}",
+                { 'version' => version })
+    end
+    [component(m[1], version, 'version'),
+     m[2].nil? ? 0 : component(m[2], version, 'version'),
+     m[3].nil? ? 0 : component(m[3], version, 'version')]
+  end
+
+  # The one satisfaction predicate: lo <= version < hi.
+  def self.satisfies(version, range)
+    v = parse_version(version)
+    r = parse_range(range)
+    version_cmp(v, r['lo']) >= 0 && version_cmp(v, r['hi']) < 0
+  end
+
+  # 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.
+  def self.satisfiesq(version, range)
+    satisfies(version, range)
+  rescue PluginError
+    false
+  end
+
+  def self.version_cmp(a, b)
+    3.times do |i|
+      x = a[i] || 0
+      y = b[i] || 0
+      return x < y ? -1 : 1 if x != y
+    end
+    0
+  end
+end

package/project/.sdk/tm/rb/feature/secrets/voxgig_plugin.rb

@@ -0,0 +1,24 @@
+# VENDORED: @voxgig/plugin sdk-20260908-1556-0 (ruby/lib/voxgig_plugin.rb)
+# 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.
+# frozen_string_literal: true
+
+# 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.
+
+require_relative 'voxgig_plugin/types'
+require_relative 'voxgig_plugin/ref'
+require_relative 'voxgig_plugin/version'
+require_relative 'voxgig_plugin/capability'
+require_relative 'voxgig_plugin/resolve'
+require_relative 'voxgig_plugin/graph'
+require_relative 'voxgig_plugin/order'
+require_relative 'voxgig_plugin/config'
+require_relative 'voxgig_plugin/env'
+require_relative 'voxgig_plugin/export'
+require_relative 'voxgig_plugin/point'
+require_relative 'voxgig_plugin/catalog'
+require_relative 'voxgig_plugin/depend'
+require_relative 'voxgig_plugin/host'