@voxgig/sdkgen 4.9.0 → 4.10.0

package/project/.sdk/tm/php/feature/secrets/plugin/Config.php

@@ -0,0 +1,444 @@
+<?php
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (php/src/Config.php)
+// 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 (§9): normalization, and the ten-level
+ * precedence ladder.
+ *
+ * TWO FUNCTIONS, AND THE SPLIT BETWEEN THEM IS FORCED.
+ *
+ * `normalize_config` normalizes STRUCTURE and ENTRY KEYS. It does not
+ * merge options, and cannot: §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.
+ *
+ * `resolve_options` applies the ladder, and it is the only place that
+ * knows the shape.
+ */
+
+declare(strict_types=1);
+
+namespace Voxgig\Plugin;
+
+const MERGE_WORDS = ['replace', 'append'];
+
+/**
+ * @param array<string,mixed>|null $input
+ * @return array<string,mixed>
+ */
+function normalize_config(?array $input): array
+{
+    $input = $input ?? [];
+    $doc = $input['doc'] ?? [];
+    $keys = $input['keys'] ?? [];
+    $ikey = (is_array($keys) ? ($keys['instance'] ?? null) : null) ?? 'instance';
+    $dkey = (is_array($keys) ? ($keys['default'] ?? null) : null) ?? 'default';
+    $reserved = $input['reserved'] ?? [];
+    $profile = $input['profile'] ?? null;
+
+    // The rename is applied at TWO PLACES AND NO OTHERS: the document
+    // root, and every profile.<name> overlay root (§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.
+    $baseinst = $doc[$ikey] ?? null;
+    $basedef = $doc[$dkey] ?? [];
+
+    $overlay = null;
+    if (null !== $profile) {
+        $overlay = ($doc['profile'] ?? [])[$profile] ?? null;
+    }
+    if (!is_array($overlay)) {
+        $overlay = [];
+    }
+    $overinst = $overlay[$ikey] ?? null;
+    $overdef = $overlay[$dkey] ?? [];
+
+    // Entry layers, base then overlay, each as {ref -> entry} plus the
+    // order the form implies.
+    $base = config_entries($baseinst);
+    $over = config_entries($overinst);
+
+    foreach ([array_keys($base['map']), array_keys($over['map']),
+              array_keys($basedef), array_keys($overdef)] as $group) {
+        foreach ($group as $r) {
+            config_checkreserved((string)$r, $reserved);
+        }
+    }
+
+    // A PARTIAL ARRAY IS NOT A FILTER (§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.
+    $order = [];
+    foreach ($over['order'] as $r) {
+        if (!in_array($r, $order, true)) {
+            $order[] = $r;
+        }
+    }
+    // The remainder keeps the BASE's own order - array position for the
+    // array form, sorted refs for the map form.
+    foreach ($base['order'] as $r) {
+        if (!in_array($r, $order, true)) {
+            $order[] = $r;
+        }
+    }
+
+    $instance = [];
+    foreach ($order as $i => $ref) {
+        $b = $base['map'][$ref] ?? null;
+        $o = $over['map'][$ref] ?? null;
+
+        // MERGE THE ENTRIES AS AUTHORED, THEN APPLY DEFAULTS TO THE RESULT
+        // (§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.
+        $active = config_pick($o, 'active', config_pick($b, 'active', true));
+        $start = config_pick($o, 'start', config_pick($b, 'start', 'eager'));
+        $block = config_pick($o, 'order', config_pick($b, 'order', null));
+
+        // Option layers, levels 3-6, IN LADDER ORDER. Never merged here.
+        $layers = [];
+        $nm = refname($ref);
+        foreach ([$basedef[$nm] ?? null, $b, $overdef[$nm] ?? null, $o] as $src) {
+            if (is_array($src) && array_key_exists('options', $src)) {
+                $layers[] = $src['options'];
+            }
+        }
+
+        $ent = ['pos' => $i, 'active' => $active, 'start' => $start,
+                'optionlayers' => $layers];
+        if (null !== $block) {
+            $ent['order'] = $block;
+        }
+        $instance[$ref] = $ent;
+    }
+
+    // `default` DECLARES NOTHING (§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.
+    $defout = [];
+    foreach ($basedef as $n => $v) {
+        $defout[$n] = $v;
+    }
+    foreach ($overdef as $n => $v) {
+        $defout[$n] = $v;
+    }
+
+    return ['instance' => $instance, 'order' => $order, 'default' => $defout];
+}
+
+/**
+ * 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.
+ *
+ * @param mixed $src
+ * @return array{map:array<string,mixed>,order:string[]}
+ */
+function config_entries($src): array
+{
+    $out = ['map' => [], 'order' => []];
+    if (null === $src) {
+        return $out;
+    }
+
+    if (is_array($src) && array_is_list($src)) {
+        foreach ($src as $item) {
+            $ref = canon_ref($item['ref'] ?? null);
+            $out['map'][$ref] = $item;
+            $out['order'][] = $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.
+    foreach ($src as $key => $value) {
+        $out['map'][canon_ref((string)$key)] = $value;
+    }
+    // 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. PHP's default
+    // `sort` is NEITHER - it reads numeric-looking strings as numbers - so
+    // this goes through Util::sortstrings and its SORT_STRING flag.
+    $out['order'] = Util::sortedkeys($out['map']);
+    return $out;
+}
+
+/**
+ * §9.1: reservation is all-or-nothing per NAME, so the tagged forms go
+ * too. A configuration surface that can disable the thing reading it is
+ * not a surface, it is a trap.
+ *
+ * @param string[] $reserved
+ */
+function config_checkreserved(string $ref, array $reserved): void
+{
+    if (empty($reserved)) {
+        return;
+    }
+    if (!in_array(refname($ref), $reserved, true)) {
+        return;
+    }
+    fail_with('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 - and in PHP `isset()` reads a present null as absent, which is why
+ * this asks `array_key_exists`.
+ *
+ * @param mixed $src
+ * @param mixed $dflt
+ * @return mixed
+ */
+function config_pick($src, string $key, $dflt)
+{
+    return is_array($src) && array_key_exists($key, $src) ? $src[$key] : $dflt;
+}
+
+// ---------------------------------------------------------------------
+// resolve_options - §9.3's ten levels, and 9.4's directives
+// ---------------------------------------------------------------------
+
+/**
+ * @param array<string,mixed> $input
+ * @return array<string,mixed>
+ */
+function resolve_options(array $input): array
+{
+    $shape = $input['shape'] ?? [];
+    if (!is_array($shape)) {
+        $shape = [];
+    }
+    check_shape($shape);
+
+    $ref = canon_ref($input['ref'] ?? null);
+    $name = refname($ref);
+    $doc = $input['doc'] ?? [];
+    $profile = $input['profile'] ?? null;
+
+    $overlay = null;
+    if (null !== $profile) {
+        $overlay = ($doc['profile'] ?? [])[$profile] ?? null;
+    }
+    if (!is_array($overlay)) {
+        $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.
+    $layers = [
+        config_defaultsof($shape),                             // 1
+        $input['hostdefaults'] ?? null,                        // 2
+        config_optsof($doc['default'] ?? null, $name),         // 3
+        config_optsof($doc['instance'] ?? null, $ref),         // 4
+        config_optsof($overlay['default'] ?? null, $name),     // 5
+        config_optsof($overlay['instance'] ?? null, $ref),     // 6
+        $input['env'] ?? null,                                 // 7
+        $input['hostoptions'] ?? null,                         // 8
+        $input['loadoptions'] ?? null,                         // 9
+        $input['patch'] ?? null,                               // 10
+    ];
+
+    $out = [];
+    foreach ($layers as $layer) {
+        if (null === $layer) {
+            continue;
+        }
+        $out = config_mergeone($out, $layer, $shape);
+    }
+    return $out;
+}
+
+/**
+ * The shape's non-directive values are the level-1 defaults.
+ *
+ * @param array<string,mixed> $shape
+ * @return array<string,mixed>
+ */
+function config_defaultsof(array $shape): array
+{
+    $out = [];
+    foreach ($shape as $k => $v) {
+        if (is_array($v) && array_key_exists('$MERGE', $v)) {
+            continue;
+        }
+        $out[$k] = $v;
+    }
+    return $out;
+}
+
+/**
+ * @param mixed $src
+ * @return mixed
+ */
+function config_optsof($src, string $key)
+{
+    if (null === $src) {
+        return null;
+    }
+
+    // The array form is equivalent to the map form (§9.1).
+    if (is_array($src) && array_is_list($src)) {
+        foreach ($src as $item) {
+            if (canon_ref($item['ref'] ?? null) === $key) {
+                return $item['options'] ?? null;
+            }
+        }
+        return null;
+    }
+
+    foreach ($src as $k => $entry) {
+        if (canon_ref((string)$k) !== $key) {
+            continue;
+        }
+        return is_array($entry) ? ($entry['options'] ?? null) : null;
+    }
+    return null;
+}
+
+/**
+ * Merge ONE layer onto the accumulator, honouring the shape's directives.
+ * The directive holds at EVERY precedence level, not only between document
+ * levels - §9.4 makes it a property of the shape, which does not know
+ * which layer a value arrived from.
+ *
+ * @param mixed $base
+ * @param mixed $over
+ * @param array<string,mixed>|null $shape
+ * @return mixed
+ */
+function config_mergeone($base, $over, ?array $shape)
+{
+    if (null === $over) {
+        return $base;
+    }
+    if (!is_array($base) || !is_array($over)) {
+        return Util::clone_value($over);
+    }
+
+    $out = $base;
+
+    foreach ($over as $k => $o) {
+        $directive = null;
+        if (is_array($shape) && is_array($shape[$k] ?? null)) {
+            $directive = $shape[$k]['$MERGE'] ?? null;
+        }
+        $b = $out[$k] ?? null;
+
+        if ('replace' === $directive) {
+            $out[$k] = Util::clone_value($o);
+        } elseif ('append' === $directive) {
+            $bl = is_array($b) ? $b : [];
+            $ol = is_array($o) ? $o : [$o];
+            $out[$k] = array_merge(array_values($bl), array_values($ol));
+        } elseif (is_array($directive) && array_key_exists('deep', $directive)) {
+            $out[$k] = config_deepto($b, $o, $directive['deep']);
+        } 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.
+            //
+            // PHP HAS ONE ARRAY TYPE, so "both are maps" is
+            // `Util::maplike` - anything but a non-empty list - and
+            // Types.php says why the empty case reads as a map.
+            if (Util::maplike($b) && Util::maplike($o)) {
+                $out[$k] = config_mergeone($b, $o, null);
+            } else {
+                $out[$k] = Util::clone_value($o);
+            }
+        }
+    }
+    return $out;
+}
+
+/**
+ * Merge N levels below this key, replace below that.
+ *
+ * @param mixed $base
+ * @param mixed $over
+ * @param mixed $n
+ * @return mixed
+ */
+function config_deepto($base, $over, $n)
+{
+    if ($n <= 0) {
+        return Util::clone_value($over);
+    }
+    if (!Util::maplike($base) || !Util::maplike($over)) {
+        return Util::clone_value($over);
+    }
+
+    $out = $base;
+    foreach ($over as $k => $v) {
+        $out[$k] = config_deepto($out[$k] ?? null, $v, $n - 1);
+    }
+    return $out;
+}
+
+/**
+ * §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.
+ *
+ * @param mixed $shape
+ */
+function check_shape($shape): void
+{
+    if (!is_array($shape)) {
+        return;
+    }
+
+    foreach ($shape as $k => $v) {
+        if (!is_array($v) || !array_key_exists('$MERGE', $v)) {
+            continue;
+        }
+
+        $directive = $v['$MERGE'];
+
+        if (is_string($directive)) {
+            if (in_array($directive, MERGE_WORDS, true)) {
+                continue;
+            }
+            fail_with('plugin_shape_invalid',
+                      'invalid $MERGE directive at ' . $k . ': ' . $directive,
+                      ['key' => $k, 'directive' => $directive]);
+        }
+
+        if (is_array($directive) && array_key_exists('deep', $directive)) {
+            $n = $directive['deep'];
+            // `is_int` excludes `true`, which PHP would otherwise read as
+            // 1 in a numeric comparison - the same hole python has to
+            // guard and ruby does not.
+            if (is_int($n) && $n >= 1) {
+                continue;
+            }
+
+            fail_with('plugin_shape_invalid',
+                      'invalid $MERGE deep at ' . $k . ': ' . Util::json($n),
+                      ['key' => $k, 'directive' => $directive]);
+        }
+
+        fail_with('plugin_shape_invalid',
+                  'invalid $MERGE directive at ' . $k . ': ' . Util::json($directive),
+                  ['key' => $k, 'directive' => $directive]);
+    }
+}

package/project/.sdk/tm/php/feature/secrets/plugin/Depend.php

@@ -0,0 +1,262 @@
+<?php
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (php/src/Depend.php)
+// 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 (§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.
+ */
+
+declare(strict_types=1);
+
+namespace Voxgig\Plugin;
+
+/**
+ * A bare string is shorthand for `{name}`.
+ *
+ * @param mixed $raw
+ * @return array<string,mixed>
+ */
+function normrequire($raw): array
+{
+    if (is_string($raw)) {
+        return ['name' => $raw];
+    }
+    return is_array($raw) ? $raw : [];
+}
+
+/**
+ * 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 §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".
+ *
+ * @param array<string,mixed>|null $options
+ * @return array<int,array<string,mixed>>
+ */
+function requirements(?array $options): array
+{
+    $options = $options ?? [];
+    $raw = $options['requires'] ?? [];
+    $marked = $options['optional'] ?? [];
+    $fallback = $options['policy'] ?? null;
+
+    $out = [];
+    foreach ($raw as $item) {
+        $req = normrequire($item);
+        if (Util::truthy($req['optional'] ?? null)
+            || (is_array($marked) && in_array($req['name'] ?? null, $marked, true))) {
+            $req['optional'] = true;
+        }
+        if (null === ($req['policy'] ?? null) && null !== $fallback) {
+            $req['policy'] = $fallback;
+        }
+        $out[] = $req;
+    }
+    return $out;
+}
+
+/**
+ * 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.
+ *
+ * @param array<string,mixed> $req
+ */
+function restartsonloss(array $req): bool
+{
+    return 'dynamic' !== ($req['policy'] ?? 'static');
+}
+
+/**
+ * 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.
+ *
+ * @param array<string,mixed> $req
+ */
+function gatesactivation(array $req): bool
+{
+    return true !== ($req['optional'] ?? null);
+}
+
+/**
+ * Edges that can cause a restart, which is exactly the set a cycle must be
+ * detected over (§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 §11.3 excluded EVERY optional edge and thereby
+ * admitted the non-terminating case it was trying to permit.
+ *
+ * @param array<string,mixed> $req
+ */
+function restartcausing(array $req): bool
+{
+    return 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 (§11.1), which is why the ref is a
+ * provider of itself here.
+ *
+ * @param array<int,array<string,mixed>> $nodes
+ * @return string[]|null
+ */
+function dependencycycle(array $nodes): ?array
+{
+    // 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 (§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.
+    $bycap = [];
+    $isref = [];
+    foreach ($nodes as $n) {
+        $isref[$n['ref']] = true;
+        foreach ($n['provides'] as $cap) {
+            if (!array_key_exists($cap, $bycap)) {
+                $bycap[$cap] = [];
+            }
+            $bycap[$cap][] = $n['ref'];
+        }
+    }
+
+    $edges = [];
+    foreach ($nodes as $n) {
+        $out = [];
+        foreach ($n['requires'] as $req) {
+            if (!restartcausing($req)) {
+                continue;
+            }
+            $from = $bycap[$req['name']] ?? [];
+            // A node satisfies its own name AS A REF (§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.
+            $asref = canon($req['name']);
+            if (($isref[$asref] ?? false) && !in_array($asref, $from, true)) {
+                $from[] = $asref;
+            }
+            foreach ($from as $p) {
+                if ($p !== $n['ref'] && !in_array($p, $out, true)) {
+                    $out[] = $p;
+                }
+            }
+        }
+        $edges[$n['ref']] = Util::sortstrings($out);
+    }
+
+    // Iterative DFS with an explicit stack: twenty ports, and several of
+    // them have no recursion budget worth relying on.
+    $white = 0;
+    $grey = 1;
+    $black = 2;
+    $colour = [];
+    foreach ($nodes as $n) {
+        $colour[$n['ref']] = $white;
+    }
+
+    foreach (Util::sortedkeys($edges) as $start) {
+        if ($colour[$start] !== $white) {
+            continue;
+        }
+
+        $path = [$start];
+        $stack = [[$start, 0]];
+        $colour[$start] = $grey;
+
+        while (!empty($stack)) {
+            $top = &$stack[count($stack) - 1];
+            if ($top[1] >= count($edges[$top[0]])) {
+                $colour[$top[0]] = $black;
+                unset($top);
+                array_pop($stack);
+                array_pop($path);
+                continue;
+            }
+            $nxt = $edges[$top[0]][$top[1]];
+            $top[1]++;
+            unset($top);
+            if ($colour[$nxt] === $grey) {
+                // Report the cycle itself, not the walk that found it.
+                $at = array_search($nxt, $path, true);
+                return array_merge(array_slice($path, (int)$at), [$nxt]);
+            }
+            if ($colour[$nxt] === $black) {
+                continue;
+            }
+            $colour[$nxt] = $grey;
+            $path[] = $nxt;
+            $stack[] = [$nxt, 0];
+        }
+    }
+    return null;
+}
+
+/**
+ * Raise on a cycle, naming it. Separate from the detector so the detector
+ * stays pure and corpus-testable.
+ *
+ * @param array<int,array<string,mixed>> $nodes
+ */
+function checkcycle(array $nodes): void
+{
+    $cycle = dependencycycle($nodes);
+    if (null === $cycle) {
+        return;
+    }
+    fail_with('plugin_dependency_cycle',
+              'requirements cycle: ' . implode(' -> ', $cycle),
+              ['cycle' => $cycle]);
+}