@voxgig/sdkgen-langpack 0.0.1

package/.sdk/tm/dart/lib/feature/secrets/plugin/capability.dart

@@ -0,0 +1,105 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (dart/lib/capability.dart)
+// 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.
+/// Capabilities (section 11.1).
+///
+/// A DEPENDENCY IS ON A CAPABILITY, NOT ON A REF - because it is a
+/// dependency on something that can do the job, and which instance is doing
+/// it is exactly the configuration detail a plugin must not care about.
+///
+/// But A BINDING IS TO AN INSTANCE, not to a capability, which is what
+/// decides behaviour when the bound provider leaves while another match
+/// remains.
+library;
+
+import 'types.dart' as t;
+import 'version.dart' as v;
+
+/// Rank the matching live providers and return them best-first: highest
+/// `version`, then LOWEST `priority` (default 0), then declaration position
+/// `pos` ascending.
+///
+/// `priority` is a field on the capability rather than section 7's `order`
+/// band, because bands live on POINT BINDINGS: a provider may have several
+/// bindings with different bands, or none at all, so a rank reaching for
+/// one would be undefined in the common case.
+///
+/// Without a total rank, "any provider satisfies" is true of the GRAPH and
+/// useless to the PLUGIN - two ports could bind different `store`
+/// instances, both resolve green, and behave differently, which is
+/// precisely the divergence a shared corpus exists to catch.
+List<dynamic> resolveCapability(dynamic req, dynamic candidates) {
+  final hits = (candidates as List)
+      .where((c) => matches(req, t.get(c, 'provides') ?? {}))
+      .toList();
+  return t.stableSortBy(hits, rankKey);
+}
+
+/// An ABSENT version sorts LAST, whatever the other is - "no version" loses
+/// to every version rather than being read as 0.0.0. The leading flag is
+/// what expresses that in a sort KEY rather than a comparator.
+List<Object> rankKey(dynamic cand) {
+  final prov = t.get(cand, 'provides') ?? {};
+  final version = t.get(prov, 'version');
+  return [
+    version == null ? 1 : 0,
+    version == null
+        ? <Object>[0, 0, 0]
+        : v.versionParts(version as String).map((n) => -n).toList().cast<Object>(),
+    (t.get(prov, 'priority') ?? 0) as Object,
+    (t.get(cand, 'pos') ?? 0) as Object,
+  ];
+}
+
+bool matches(dynamic req, dynamic prov) {
+  if (t.get(req, 'name') != t.get(prov, 'name')) return false;
+
+  if (t.get(req, 'range') != null) {
+    if (t.get(prov, 'version') == null) return false;
+    if (!v.satisfiesq(t.get(prov, 'version'), t.get(req, 'range'))) return false;
+  }
+
+  // `match` is checked against the provider's `attrs`, key by key. A key the
+  // provider does not carry is a miss, not a pass: a requirement asking for
+  // `transactional: true` must not be satisfied by a provider that never
+  // said.
+  final want = t.get(req, 'match');
+  if (want != null) {
+    final attrs = t.get(prov, 'attrs') ?? {};
+    for (final k in t.sortedKeys(want)) {
+      if (!t.has(attrs, k)) return false;
+      if (!matchValue(t.get(want, k), t.get(attrs, k))) return false;
+    }
+  }
+  return true;
+}
+
+/// PARTIAL MATCH, RECURSING INTO MAPS (section 11.1).
+///
+/// Every leaf in the requirement must be present and equal in the
+/// capability, keys not mentioned are not checked. Equality is by JSON TYPE
+/// as well as value: `transactional: 1` does not satisfy
+/// `transactional: true`. DART NEEDS NO GUARD FOR THAT - `true == 1` is
+/// false, because `bool` and `int` are unrelated types with no coercion.
+/// Python, PHP, Perl and Lua all need one, and `capability/match` pins the
+/// behaviour for every port rather than trusting each language's `==`.
+///
+/// A LIST IS COMPARED LEAF-WISE AT THE SAME LENGTH, not as a subset.
+bool matchValue(dynamic want, dynamic got) {
+  if (want is Map) {
+    if (got is! Map) return false;
+    for (final k in t.sortedKeys(want)) {
+      if (!got.containsKey(k)) return false;
+      if (!matchValue(want[k], got[k])) return false;
+    }
+    return true;
+  }
+  if (want is List) {
+    if (got is! List || want.length != got.length) return false;
+    for (var i = 0; i < want.length; i++) {
+      if (!matchValue(want[i], got[i])) return false;
+    }
+    return true;
+  }
+  return t.same(want, got);
+}

package/.sdk/tm/dart/lib/feature/secrets/plugin/catalog.dart

@@ -0,0 +1,46 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (dart/lib/catalog.dart)
+// 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.
+/// The definition catalog (section 10.1).
+///
+/// A definition is registered once and may back many instances. Option
+/// shapes are validated AT REGISTRATION, not when a document happens to
+/// exercise a key - so a malformed shape fails once, and in the same place
+/// everywhere (section 9.4).
+library;
+
+import 'types.dart' as t;
+import 'ref.dart' as r;
+import 'config.dart' as config;
+
+class Catalog {
+  final Map<String, dynamic> _defs = {};
+
+  void add(dynamic definition) {
+    final name = t.get(definition, 'name');
+    if (definition is! Map || !r.checkName(name)) {
+      final shown = definition is Map ? name : definition;
+      t.fail('plugin_definition_name', 'invalid definition name: $shown');
+    }
+    // Validate the shape HERE. Deferring it to resolution time means a
+    // malformed shape surfaces at a different moment in every host that
+    // loads it, which is the divergence the stated domain exists to prevent.
+    final shape = t.get(definition, 'shape');
+    if (shape != null) config.checkShape(shape);
+    _defs[name as String] = definition;
+  }
+
+  dynamic get(String name) => _defs[name];
+
+  bool has(String name) => _defs.containsKey(name);
+
+  List<String> names() => _defs.keys.toList()..sort();
+}
+
+Catalog makeCatalog([List<dynamic>? definitions]) {
+  final catalog = Catalog();
+  for (final d in definitions ?? const []) {
+    catalog.add(d);
+  }
+  return catalog;
+}

package/.sdk/tm/dart/lib/feature/secrets/plugin/config.dart

@@ -0,0 +1,297 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (dart/lib/config.dart)
+// 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.
+/// The declarative document (section 9): normalization, and the ten-level
+/// precedence ladder.
+///
+/// TWO FUNCTIONS, AND THE SPLIT BETWEEN THEM IS FORCED.
+///
+/// `normalizeConfig` normalizes STRUCTURE and ENTRY KEYS. It does not merge
+/// options, and cannot: section 9.4 makes merge behaviour a property of the
+/// definition's option SHAPE, which normalization has never seen. A
+/// normalizer that flattened the option layers would make `$MERGE: append`
+/// unimplementable at load time, because the layers it must concatenate
+/// would already be collapsed.
+///
+/// `resolveOptions` applies the ladder, and it is the only place that knows
+/// the shape.
+library;
+
+import 'types.dart' as t;
+import 'ref.dart' as r;
+
+const mergeWords = ['replace', 'append'];
+
+class _Entries {
+  final Map<String, dynamic> map = {};
+  final List<String> order = [];
+}
+
+/// Both document forms reduce to {ref -> entry} plus the order the form
+/// implies: array POSITION for the array form, sorted refs for the map form.
+_Entries _entries(dynamic src) {
+  final out = _Entries();
+  if (src == null) return out;
+
+  if (src is List) {
+    for (final item in src) {
+      final ref = r.canonRef(t.get(item, 'ref'));
+      out.map[ref] = item;
+      out.order.add(ref);
+    }
+    return out;
+  }
+
+  // Map-form refs arrive as KEYS, through a different path than an array
+  // element's `ref` field - and must canonicalize the same way.
+  for (final key in t.sortedKeys(src)) {
+    out.map[r.canonRef(key)] = t.get(src, key);
+  }
+  // Byte-wise, NOT locale-aware and NOT case-folded. All-lowercase refs sort
+  // identically under all three, so only mixed input discriminates: '@' is
+  // 0x40, uppercase 0x41-0x5A, lowercase 0x61-0x7A. Dart's String.compareTo
+  // is UTF-16 code unit order, which is exactly that for a ref.
+  out.order.addAll(out.map.keys.toList()..sort());
+  return out;
+}
+
+void _checkReserved(String ref, List reserved) {
+  if (!reserved.contains(r.refName(ref))) return;
+  t.fail('plugin_ref_reserved', 'ref is reserved by the host: $ref',
+      {'ref': ref});
+}
+
+/// PRESENCE decides, not truthiness and not null. A JSON `null` is a present
+/// value in JavaScript (`undefined !== null`), so it must be one here.
+dynamic _pick(dynamic src, String key, dynamic dflt) =>
+    t.has(src, key) ? t.get(src, key) : dflt;
+
+Map<String, dynamic> normalizeConfig(dynamic input) {
+  final doc = t.get(input, 'doc') ?? {};
+  final keys = t.get(input, 'keys') ?? {};
+  final ikey = (t.get(keys, 'instance') ?? 'instance') as String;
+  final dkey = (t.get(keys, 'default') ?? 'default') as String;
+  final reserved = (t.get(input, 'reserved') ?? []) as List;
+  final profile = t.get(input, 'profile');
+
+  // The rename is applied at TWO PLACES AND NO OTHERS: the document root,
+  // and every profile.<name> overlay root (section 9.1). A rename applied
+  // only at the root would leave `profile.prod.sdk` untranslated and
+  // silently drop every environment override the host depends on. Recursing
+  // further would be worse: option data is the definition's.
+  final basedef = t.get(doc, dkey) ?? {};
+  var overlay = profile == null ? null : t.get(t.get(doc, 'profile'), profile);
+  if (overlay is! Map) overlay = {};
+  final overdef = t.get(overlay, dkey) ?? {};
+
+  final base = _entries(t.get(doc, ikey));
+  final over = _entries(t.get(overlay, ikey));
+
+  for (final group in [
+    base.map.keys.toList(),
+    over.map.keys.toList(),
+    t.sortedKeys(basedef),
+    t.sortedKeys(overdef)
+  ]) {
+    for (final ref in group) {
+      _checkReserved(ref, reserved);
+    }
+  }
+
+  // A PARTIAL ARRAY IS NOT A FILTER (section 9.1). sdkgen learned this the
+  // hard way: deriving order from a partial array silently dropped
+  // config-activated features. Refs in the base but absent from the overlay
+  // still load, in sorted position AFTER the listed ones. A profile may also
+  // INTRODUCE a ref the base never declared. The remainder keeps the BASE's
+  // own order.
+  final order = <String>[];
+  for (final ref in [...over.order, ...base.order]) {
+    if (!order.contains(ref)) order.add(ref);
+  }
+
+  final instance = <String, dynamic>{};
+  for (var i = 0; i < order.length; i++) {
+    final ref = order[i];
+    final b = base.map[ref];
+    final o = over.map[ref];
+
+    // MERGE THE ENTRIES AS AUTHORED, THEN APPLY DEFAULTS TO THE RESULT
+    // (section 9.3). A safety rule, not a tidiness one: if the overlay had
+    // its defaults filled in before merging it would carry a synthesized
+    // active:true and overwrite a base's false - silently re-enabling a
+    // deliberately disabled integration in production.
+    final block = _pick(o, 'order', _pick(b, 'order', null));
+
+    // Option layers, levels 3-6, IN LADDER ORDER. Never merged here.
+    final nm = r.refName(ref);
+    final layers = <dynamic>[];
+    for (final src in [t.get(basedef, nm), b, t.get(overdef, nm), o]) {
+      if (t.has(src, 'options')) layers.add(t.get(src, 'options'));
+    }
+
+    final ent = <String, dynamic>{
+      'pos': i,
+      'active': _pick(o, 'active', _pick(b, 'active', true)),
+      'start': _pick(o, 'start', _pick(b, 'start', 'eager')),
+      'optionlayers': layers,
+    };
+    if (block != null) ent['order'] = block;
+    instance[ref] = ent;
+  }
+
+  // `default` DECLARES NOTHING (section 9.3). It is a base for every
+  // instance of that definition; it does not create one, and an entry for a
+  // name with no instances is inert rather than an error - which is what
+  // makes a shared library of defaults shippable.
+  final defout = <String, dynamic>{};
+  for (final k in t.sortedKeys(basedef)) {
+    defout[k] = t.get(basedef, k);
+  }
+  for (final k in t.sortedKeys(overdef)) {
+    defout[k] = t.get(overdef, k);
+  }
+
+  return {'instance': instance, 'order': order, 'default': defout};
+}
+
+/// Section 9.4: N is an integer of at least 1, and everything else is an
+/// error.
+///
+/// `{"deep": 0}` is rejected DESPITE having an obvious reading, because
+/// "replace at this key" already has a spelling and two spellings for one
+/// behaviour is the defect class this repo exists to avoid.
+void checkShape(dynamic shape) {
+  if (shape is! Map) return;
+  for (final k in t.sortedKeys(shape)) {
+    final v = t.get(shape, k);
+    if (!t.has(v, r'$MERGE')) continue;
+    final directive = t.get(v, r'$MERGE');
+
+    if (directive is String) {
+      if (mergeWords.contains(directive)) continue;
+      t.fail('plugin_shape_invalid', 'invalid \$MERGE directive at $k: $directive',
+          {'key': k, 'directive': directive});
+    }
+    if (t.has(directive, 'deep')) {
+      final n = t.get(directive, 'deep');
+      // `true is int` is false in dart, so the boolean case falls out for
+      // free here - unlike python, where it does not.
+      if (n is int && n >= 1) continue;
+      t.fail('plugin_shape_invalid',
+          'invalid \$MERGE deep at $k: ${t.encode(n)}',
+          {'key': k, 'directive': directive});
+    }
+    t.fail('plugin_shape_invalid',
+        'invalid \$MERGE directive at $k: ${t.encode(directive)}',
+        {'key': k, 'directive': directive});
+  }
+}
+
+/// The shape's non-directive values are the level-1 defaults.
+Map<String, dynamic> _defaultsOf(dynamic shape) {
+  final out = <String, dynamic>{};
+  for (final k in t.sortedKeys(shape)) {
+    final v = t.get(shape, k);
+    if (t.has(v, r'$MERGE')) continue;
+    out[k] = v;
+  }
+  return out;
+}
+
+dynamic _optsOf(dynamic src, String key) {
+  if (src == null) return null;
+  // The array form is equivalent to the map form (section 9.1).
+  if (src is List) {
+    for (final item in src) {
+      if (r.canonRef(t.get(item, 'ref')) == key) return t.get(item, 'options');
+    }
+    return null;
+  }
+  for (final k in t.sortedKeys(src)) {
+    if (r.canonRef(k) != key) continue;
+    final entry = t.get(src, k);
+    return entry is Map ? t.get(entry, 'options') : null;
+  }
+  return null;
+}
+
+/// Merge N levels below this key, replace below that.
+dynamic _deepTo(dynamic base, dynamic over, int n) {
+  if (n <= 0) return over;
+  if (base is! Map || over is! Map) return over;
+  final out = Map<String, dynamic>.from(base);
+  for (final k in t.sortedKeys(over)) {
+    out[k] = _deepTo(out[k], over[k], n - 1);
+  }
+  return out;
+}
+
+/// Merge ONE layer onto the accumulator, honouring the shape's directives.
+/// The directive holds at EVERY precedence level, not only between document
+/// levels - section 9.4 makes it a property of the shape, which does not
+/// know which layer a value arrived from.
+dynamic _mergeOne(dynamic base, dynamic over, dynamic shape) {
+  if (over == null) return base;
+  if (base is! Map || over is! Map) return over;
+
+  final out = Map<String, dynamic>.from(base);
+  for (final k in t.sortedKeys(over)) {
+    final o = over[k];
+    final b = out[k];
+    final directive = t.get(t.get(shape, k), r'$MERGE');
+
+    if (directive == 'replace') {
+      out[k] = o;
+    } else if (directive == 'append') {
+      final bl = b is List ? b : [];
+      final ol = o is List ? o : [o];
+      out[k] = [...bl, ...ol];
+    } else if (t.has(directive, 'deep')) {
+      out[k] = _deepTo(b, o, t.get(directive, 'deep') as int);
+    } else {
+      // Library default: deep for maps, REPLACE for lists. struct.merge is
+      // element-wise by index, which for option maps is nearly always wrong
+      // - ["a"] over ["x","y","z"] yielding ["a","y","z"] is the defect
+      // station hit on secrets.providers.
+      out[k] = (b is Map && o is Map) ? _mergeOne(b, o, null) : o;
+    }
+  }
+  return out;
+}
+
+Map<String, dynamic> resolveOptions(dynamic input) {
+  final shape = t.get(input, 'shape') ?? {};
+  checkShape(shape);
+
+  final ref = r.canonRef(t.get(input, 'ref'));
+  final name = r.refName(ref);
+  final doc = t.get(input, 'doc') ?? {};
+  final profile = t.get(input, 'profile');
+
+  var overlay = profile == null ? null : t.get(t.get(doc, 'profile'), profile);
+  if (overlay is! Map) overlay = {};
+
+  // ONE ordered merge, lowest to highest. Levels 3-6 are not two namespaces
+  // collapsed separately and composed afterwards: that inverts the rule that
+  // PROFILE SPECIFICITY OUTRANKS DEFINITION SPECIFICITY, so a prod
+  // per-definition default would lose to a base instance value.
+  final layers = [
+    _defaultsOf(shape), // 1
+    t.get(input, 'hostdefaults'), // 2
+    _optsOf(t.get(doc, 'default'), name), // 3
+    _optsOf(t.get(doc, 'instance'), ref), // 4
+    _optsOf(t.get(overlay, 'default'), name), // 5
+    _optsOf(t.get(overlay, 'instance'), ref), // 6
+    t.get(input, 'env'), // 7
+    t.get(input, 'hostoptions'), // 8
+    t.get(input, 'loadoptions'), // 9
+    t.get(input, 'patch'), // 10
+  ];
+
+  dynamic out = <String, dynamic>{};
+  for (final layer in layers) {
+    if (layer == null) continue;
+    out = _mergeOne(out, layer, shape);
+  }
+  return out as Map<String, dynamic>;
+}

package/.sdk/tm/dart/lib/feature/secrets/plugin/depend.dart

@@ -0,0 +1,198 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (dart/lib/depend.dart)
+// 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.
+/// Dependency cardinality, policy, and the restart graph (section 11.3).
+///
+/// TWO AXES, BOTH DECLARED BY THE DEFINITION THAT HAS THE REQUIREMENT,
+/// because only it knows what it can cope with:
+///
+///                | static (default)          | dynamic
+///   -------------|---------------------------|--------------------------
+///   mandatory    | unmet -> pending;         | unmet -> pending;
+///   (default)    | lost  -> pending,         | lost  -> STAYS LIVE,
+///                |          recursively      |          notified
+///   -------------|---------------------------|--------------------------
+///   optional:true| never gates activation;   | never gates activation;
+///                | a change deactivates and  | a change is a
+///                | reactivates               | notification, nothing else
+///
+/// `dynamic` means the plugin has said, IN WRITING, that it can survive its
+/// provider being swapped underneath it. It is not the default because most
+/// plugins cannot, and the cost of wrongly assuming they can is a live
+/// instance holding a dead reference.
+///
+/// The rebinding-preference axis is deliberately omitted. OSGi has
+/// reluctant vs greedy and it is a knob every author must understand to read
+/// anyone else's component; we take always-reluctant. Three axes were more
+/// than the model can carry across twenty ports.
+library;
+
+import 'types.dart' as t;
+import 'ref.dart' as r;
+
+/// One node of the requirement graph. An internal shape, never a corpus
+/// value.
+class GraphNode {
+  final String ref;
+  final List<String> provides;
+  final List<dynamic> requires;
+  GraphNode(this.ref, this.provides, this.requires);
+}
+
+/// A bare string is shorthand for `{name}`.
+Map<String, dynamic> normRequire(dynamic raw) {
+  if (raw is String) return {'name': raw};
+  if (raw is Map) return Map<String, dynamic>.from(raw);
+  return {};
+}
+
+/// The requirements a definition declared, normalized.
+///
+/// BOTH AXES ARE READ AT TWO LEVELS, AND THE PER-REQUIREMENT ONE WINS.
+///
+/// The instance-level `policy` and `optional` list are how a DOCUMENT states
+/// the axis without editing the definition, and they apply to every
+/// requirement. The per-requirement form is the one section 11.1's object
+/// syntax exists for, and it is strictly more expressive: an instance that
+/// is `static` on its store and `dynamic` on its metrics cannot be written
+/// at all at the instance level.
+///
+/// `optional` unions rather than overriding - both spellings are statements
+/// that this requirement need not gate activation, and there is no reading
+/// under which one of them means "actually, mandatory".
+List<Map<String, dynamic>> requirements(dynamic options) {
+  final raw = (t.get(options, 'requires') ?? []) as List;
+  final marked = t.get(options, 'optional');
+  final fallback = t.get(options, 'policy');
+
+  return raw.map((item) {
+    final req = normRequire(item);
+    if (t.truthy(req['optional']) ||
+        (marked is List && marked.contains(req['name']))) {
+      req['optional'] = true;
+    }
+    if (req['policy'] == null && fallback != null) req['policy'] = fallback;
+    return req;
+  }).toList();
+}
+
+/// Does losing this requirement's SELECTED provider restart the consumer?
+/// The mandatory ones under `static`, and the `static` optional ones - both
+/// make a capability change deactivate and reactivate. `dynamic` never
+/// restarts.
+bool restartsOnLoss(dynamic req) =>
+    (t.get(req, 'policy') ?? 'static') != 'dynamic';
+
+/// Does an unmet requirement keep the consumer out of `live`?
+///
+/// Cardinality alone decides this, NOT policy. `dynamic` is a statement
+/// about surviving a SWAP, not about starting without the thing at all - a
+/// mandatory-dynamic consumer still waits in `pending` for its first
+/// provider.
+bool gatesActivation(dynamic req) => t.get(req, 'optional') != true;
+
+/// Edges that can cause a restart, which is exactly the set a cycle must be
+/// detected over (section 11.3).
+///
+/// ONLY `dynamic` OPTIONAL EDGES ARE EXCLUDED, and they are the ones the
+/// exclusion was for: two plugins that optionally and dynamically consume
+/// each other's capabilities both activate happily, neither gates on the
+/// other, and each is merely notified when the other appears. Nothing
+/// restarts, so nothing oscillates. An earlier draft of section 11.3
+/// excluded EVERY optional edge and thereby admitted the non-terminating
+/// case it was trying to permit.
+bool restartCausing(dynamic req) =>
+    gatesActivation(req) || restartsOnLoss(req);
+
+/// A cycle through restart-causing requirements is
+/// `plugin_dependency_cycle`, detected AT LOAD - before anything runs,
+/// because the failure it describes is a non-terminating reconcile and the
+/// only safe time to report that is before it starts.
+///
+/// The graph is over capabilities, not refs: an edge runs from a consumer to
+/// EVERY node that provides what it needs, because any of them could be the
+/// one selected and a cycle through any is a cycle. A node also satisfies
+/// its own name as a ref (section 11.1), which is why the ref is a provider
+/// of itself here.
+List<String>? dependencyCycle(List<GraphNode> nodes) {
+  // TWO INDEXES, NOT ONE MERGED MAP. Capability names and refs are matched
+  // differently - a capability by its exact name, a ref through the
+  // canonical spelling (section 4 rule 5) - and one map keyed by both can
+  // only do one of them. Keyed by both and looked up raw, as this was, a
+  // cycle spelled `a$`/`b$` found no providers and EVADED the load-time
+  // check that exists to catch a non-terminating reconcile.
+  final bycap = <String, List<String>>{};
+  final isref = <String>{};
+  for (final n in nodes) {
+    isref.add(n.ref);
+    for (final cap in n.provides) {
+      bycap.putIfAbsent(cap, () => []).add(n.ref);
+    }
+  }
+
+  final edges = <String, List<String>>{};
+  for (final n in nodes) {
+    final out = <String>[];
+    for (final req in n.requires) {
+      if (!restartCausing(req)) continue;
+      final reqname = t.get(req, 'name');
+      final from = <String>[...(bycap[reqname] ?? const <String>[])];
+      // A node satisfies its own name AS A REF (section 11.1),
+      // canonically - exactly what `providersOf` does at runtime. `canon`
+      // hands back a name no ref could have unchanged, and no instance ref
+      // can equal one, so it is the tolerant test.
+      final asref = r.canon(reqname);
+      if (isref.contains(asref) && !from.contains(asref)) from.add(asref);
+      for (final p in from) {
+        if (p != n.ref && !out.contains(p)) out.add(p);
+      }
+    }
+    edges[n.ref] = out..sort();
+  }
+
+  // Iterative DFS with an explicit stack: twenty ports, and several of them
+  // have no recursion budget worth relying on.
+  const white = 0, grey = 1, black = 2;
+  final colour = {for (final n in nodes) n.ref: white};
+
+  for (final start in edges.keys.toList()..sort()) {
+    if (colour[start] != white) continue;
+
+    final path = <String>[start];
+    final stack = <List<dynamic>>[
+      [start, 0]
+    ];
+    colour[start] = grey;
+
+    while (stack.isNotEmpty) {
+      final top = stack.last;
+      final node = top[0] as String;
+      if ((top[1] as int) >= edges[node]!.length) {
+        colour[node] = black;
+        stack.removeLast();
+        path.removeLast();
+        continue;
+      }
+      final next = edges[node]![top[1] as int];
+      top[1] = (top[1] as int) + 1;
+      if (colour[next] == grey) {
+        // Report the cycle itself, not the walk that found it.
+        return [...path.sublist(path.indexOf(next)), next];
+      }
+      if (colour[next] == black) continue;
+      colour[next] = grey;
+      path.add(next);
+      stack.add([next, 0]);
+    }
+  }
+  return null;
+}
+
+/// Raise on a cycle, naming it. Separate from the detector so the detector
+/// stays pure and corpus-testable.
+void checkCycle(List<GraphNode> nodes) {
+  final cycle = dependencyCycle(nodes);
+  if (cycle == null) return;
+  t.fail('plugin_dependency_cycle', 'requirements cycle: ${cycle.join(' -> ')}',
+      {'cycle': cycle});
+}