@voxgig/sdkgen 3.5.1 → 3.7.0

package/project/.sdk/tm/cpp/utility/pipeline.hpp

@@ -330,9 +330,10 @@ inline Value makePoint(CtxPtr ctx) {
     }
 
     Value point;
+    bool matched = false;
     for (size_t i = 0; i < op->points.size(); i++) {
-      point = op->points[i];
-      Value selectDef = Helpers::toMapAny(getp(point, "select"));
+      Value cand = op->points[i];
+      Value selectDef = Helpers::toMapAny(getp(cand, "select"));
       bool found = true;
 
       if (selector.is_map() && selectDef.is_map()) {
@@ -356,7 +357,58 @@ inline Value makePoint(CtxPtr ctx) {
         if (reqAction != selectAction) found = false;
       }
 
-      if (found) break;
+      if (found) {
+        point = cand;
+        matched = true;
+        break;
+      }
+    }
+
+    // select.exist can list more than the params needed to pick a point (for
+    // /boards/{id} it is Trello's 17 optional query-includes), so a plain
+    // {id} call matches NOTHING. Fall back to the entity's own route rather
+    // than whichever point came last.
+    if (!matched) {
+      // A request naming an action reaches here only because that action's
+      // own point failed its exist test, so it is unbuildable whatever we
+      // pick. Refuse it BEFORE choosing a fallback: the guard below compares
+      // the chosen point's $action and would wave the request through
+      // whenever the fallback lands on the action point itself.
+      Value unmatchedAction = getp(reqselector, "$action", Value(nullptr));
+      if (!unmatchedAction.is_null()) {
+        throw ctx->makeError("point_action_invalid",
+            "Operation \"" + op->name + "\" action \"" +
+            Struct::stringify(unmatchedAction) + "\" is not valid.");
+      }
+
+      // A terminal parameter marks a record route (/boards/{id}); a
+      // cross-reference ends in the relationship's name (/posts/{id}/author).
+      // Failing that, the shallower path wins. The same rule runs at
+      // generation time, in helpers/opShape.ts — both sides must move
+      // together.
+      auto partsLen = [](const Value& p) -> size_t {
+        Value parts = getp(p, "parts");
+        return parts.is_list() ? parts.as_list()->size() : 0;
+      };
+      auto terminalParam = [](const Value& p) -> bool {
+        Value parts = getp(p, "parts");
+        if (!parts.is_list() || parts.as_list()->empty()) return false;
+        const Value& last = parts.as_list()->back();
+        return last.is_string() && 0 == last.as_string().rfind("{", 0);
+      };
+
+      point = op->points[0];
+      for (size_t i = 0; i < op->points.size(); i++) {
+        const Value& cand = op->points[i];
+        bool candTerm = terminalParam(cand);
+        bool bestTerm = terminalParam(point);
+        if (candTerm != bestTerm) {
+          if (candTerm) point = cand;
+        }
+        else if (partsLen(cand) < partsLen(point)) {
+          point = cand;
+        }
+      }
     }
 
     if (reqselector.is_map()) {
@@ -1159,8 +1211,16 @@ inline Value makeOptions(CtxPtr ctx) {
       std::sort(names.begin(), names.end());
       bool hasTest = std::find(names.begin(), names.end(), "test") != names.end();
       if (hasTest) featureOrder.push_back("test");
+      // Station special case, mirroring test's: its transport wrap must
+      // sit immediately outside the base transport (inside retry/cache/
+      // netsim), so map-form activation hoists it to just after test -
+      // or first, when no test entry exists. Without this the sorted
+      // default would init station last and wrap OUTSIDE the recording
+      // features, turning its wire-truth events into fiction.
+      bool hasStation = std::find(names.begin(), names.end(), "station") != names.end();
+      if (hasStation) featureOrder.push_back("station");
       for (const auto& n : names) {
-        if (n != "test") featureOrder.push_back(n);
+        if (n != "test" && n != "station") featureOrder.push_back(n);
       }
     }
   }

package/project/.sdk/tm/csharp/feature/TestFeature.cs

@@ -313,10 +313,44 @@ public class TestFeature : BaseFeature
     {
         var opname = op.Name;
 
-        // Get last point from config.
+        // Pick the entity's own endpoint from config, not a cross-reference
+        // from another resource that also returns it — the same rule
+        // MakePoint falls back to, so the seed-data query is built from the
+        // endpoint the request will actually be sent to: a terminal `{id}`
+        // marks a record route, and failing that the shallower path wins.
         var points = StructUtils.GetPath(ctx.Config,
             StructUtils.Jt("entity", ctx.Entity!.GetName(), "op", opname, "points"));
-        var point = StructUtils.GetElem(points, -1);
+        var point = StructUtils.GetElem(points, 0);
+        if (points is List<object?> pointList)
+        {
+            static int PointPartsLen(object? p) =>
+                StructUtils.GetProp(p, "parts") is List<object?> parts ? parts.Count : 0;
+            static bool PointTerminalParam(object? p)
+            {
+                if (StructUtils.GetProp(p, "parts") is not List<object?> parts || parts.Count == 0)
+                {
+                    return false;
+                }
+                return parts[parts.Count - 1] is string last && last.StartsWith("{");
+            }
+
+            foreach (var candidate in pointList)
+            {
+                var candTerm = PointTerminalParam(candidate);
+                var bestTerm = PointTerminalParam(point);
+                if (candTerm != bestTerm)
+                {
+                    if (candTerm)
+                    {
+                        point = candidate;
+                    }
+                }
+                else if (PointPartsLen(candidate) < PointPartsLen(point))
+                {
+                    point = candidate;
+                }
+            }
+        }
 
         // Get required params.
         var paramsPath = StructUtils.GetPath(point, StructUtils.Jt("args", "params"));

package/project/.sdk/tm/csharp/utility/Fetcher.cs

@@ -13,30 +13,48 @@ public static partial class SdkUtility
 {
     private static readonly HttpClient DefaultHttpClient = new();
 
-    // Proxy-routed clients, cached per proxy URL (see the proxy feature's
-    // fetchdef annotation).
+    // Non-following twin of DefaultHttpClient. The station feature's
+    // middleware sets `redirect: manual` on the fetch definition under a
+    // hosts egress policy: a 3xx must come back as a response like any
+    // other, because an automatic follow would carry injected credentials
+    // to a Location no policy approved (the ts donor's fetch honours the
+    // same key natively; redirect policy is per-handler in .NET, hence a
+    // second client).
+    private static readonly HttpClient ManualRedirectHttpClient = new(
+        new HttpClientHandler
+        {
+            AllowAutoRedirect = false,
+        });
+
+    // Proxy-routed clients, cached per proxy URL and redirect policy (see
+    // the proxy feature's fetchdef annotation).
     private static readonly Dictionary<string, HttpClient> ProxyClients = new();
     private static readonly object ProxyClientsLock = new();
 
     private static HttpClient ClientFor(Dictionary<string, object?> fetchdef)
     {
+        var manual = fetchdef.TryGetValue("redirect", out var rraw) &&
+            rraw is string redirect && redirect == "manual";
+
         if (fetchdef.TryGetValue("proxy", out var raw) && raw is string proxy && proxy != "")
         {
             lock (ProxyClientsLock)
             {
-                if (!ProxyClients.TryGetValue(proxy, out var client))
+                var key = (manual ? "manual|" : "auto|") + proxy;
+                if (!ProxyClients.TryGetValue(key, out var client))
                 {
                     client = new HttpClient(new HttpClientHandler
                     {
                         Proxy = new System.Net.WebProxy(proxy),
                         UseProxy = true,
+                        AllowAutoRedirect = !manual,
                     });
-                    ProxyClients[proxy] = client;
+                    ProxyClients[key] = client;
                 }
                 return client;
             }
         }
-        return DefaultHttpClient;
+        return manual ? ManualRedirectHttpClient : DefaultHttpClient;
     }
 
     internal static Dictionary<string, object?> DefaultHttpFetch(

package/project/.sdk/tm/csharp/utility/MakeOptions.cs

@@ -248,6 +248,19 @@ public static partial class SdkUtility
                     featureorder.Add(n);
                 }
             }
+
+            // Station special case, mirroring test's: its transport wrap must
+            // sit immediately outside the base transport (inside retry/cache/
+            // netsim), so map-form activation hoists it to just after test -
+            // or first, when no test entry exists. Without this the sorted
+            // default would init station last and wrap OUTSIDE the recording
+            // features, turning its wire-truth events into fiction.
+            var si = featureorder.IndexOf("station");
+            if (si >= 0)
+            {
+                featureorder.RemoveAt(si);
+                featureorder.Insert(featureorder.IndexOf("test") + 1, "station");
+            }
         }
 
         var derived = new Dictionary<string, object?>

package/project/.sdk/tm/csharp/utility/MakePoint.cs

@@ -6,6 +6,27 @@ namespace ProjectNameSdk.Util;
 
 public static partial class SdkUtility
 {
+    // How many path segments a point has.
+    private static int PartsLen(Dictionary<string, object?>? point)
+    {
+        return StructUtils.GetProp(point, "parts") is List<object?> parts ? parts.Count : 0;
+    }
+
+    // Does this point's path end in a parameter? A record route ends in the
+    // record's identifier (/boards/{id}); a cross-reference that also returns
+    // the entity ends in the relationship's name (/posts/{id}/author). That,
+    // then fewest segments, is what tells the entity's own route from a
+    // cross-reference. The same rule runs at generation time, in
+    // helpers/opShape.ts — both sides must move together.
+    private static bool TerminalParam(Dictionary<string, object?>? point)
+    {
+        if (StructUtils.GetProp(point, "parts") is not List<object?> parts || parts.Count == 0)
+        {
+            return false;
+        }
+        return parts[parts.Count - 1] is string last && last.StartsWith("{");
+    }
+
     internal static Dictionary<string, object?>? MakePointUtil(Context ctx)
     {
         if (ctx.Out.TryGetValue("point", out var outPoint) && outPoint != null)
@@ -62,10 +83,10 @@ public static partial class SdkUtility
             }
 
             Dictionary<string, object?>? point = null;
+            var matched = false;
             foreach (var candidate in op.Points)
             {
-                point = candidate;
-                var selectDef = Helpers.ToMapAny(StructUtils.GetProp(point, "select"));
+                var selectDef = Helpers.ToMapAny(StructUtils.GetProp(candidate, "select"));
                 var found = true;
 
                 if (selector != null && selectDef != null)
@@ -98,10 +119,52 @@ public static partial class SdkUtility
 
                 if (found)
                 {
+                    point = candidate;
+                    matched = true;
                     break;
                 }
             }
 
+            // select.exist can list more than the params needed to pick a
+            // point, so nothing matches — fall back to the entity's own
+            // route rather than the last point.
+            if (!matched)
+            {
+                // A request naming an action reaches here only because that
+                // action's own point failed its exist test, so it is
+                // unbuildable whatever we pick. Refuse it BEFORE choosing a
+                // fallback: the guard below compares the chosen point's
+                // $action and would wave the request through whenever the
+                // fallback lands on the action point itself.
+                var unmatchedAction = reqselector != null
+                    ? StructUtils.GetProp(reqselector, "$action") : null;
+                if (unmatchedAction != null)
+                {
+                    throw ctx.MakeError("point_action_invalid",
+                        "Operation \"" + op.Name +
+                        "\" action \"" + StructUtils.Stringify(unmatchedAction) +
+                        "\" is not valid.");
+                }
+
+                point = op.Points[0];
+                foreach (var candidate in op.Points)
+                {
+                    var candTerm = TerminalParam(candidate);
+                    var bestTerm = TerminalParam(point);
+                    if (candTerm != bestTerm)
+                    {
+                        if (candTerm)
+                        {
+                            point = candidate;
+                        }
+                    }
+                    else if (PartsLen(candidate) < PartsLen(point))
+                    {
+                        point = candidate;
+                    }
+                }
+            }
+
             if (reqselector != null)
             {
                 var reqAction = StructUtils.GetProp(reqselector, "$action");

package/project/.sdk/tm/dart/lib/feature/test/TestFeature.dart

@@ -214,10 +214,40 @@ class TestFeature extends BaseFeature {
     final param = ctx.utility.param;
 
     final opname = op.name;
-    final point = vs.getelem(
-        vs.getpath(ctx.config,
-            ['entity', _entname(ctx.entity), 'op', opname, 'points']),
-        -1);
+
+    // Pick the entity's own endpoint from config, not a cross-reference from
+    // another resource that also returns it — the same rule makePoint falls
+    // back to, so the seed-data query is built from the endpoint the request
+    // will actually be sent to: a terminal `{id}` marks a record route, and
+    // failing that the shallower path wins.
+    final points = vs.getpath(
+        ctx.config, ['entity', _entname(ctx.entity), 'op', opname, 'points']);
+    var point = vs.getelem(points, 0);
+    if (points is List) {
+      int pointPartsLen(dynamic p) {
+        final parts = vs.getprop(p, 'parts');
+        return parts is List ? parts.length : 0;
+      }
+
+      bool pointTerminalParam(dynamic p) {
+        final parts = vs.getprop(p, 'parts');
+        if (parts is! List || parts.isEmpty) {
+          return false;
+        }
+        final last = parts[parts.length - 1];
+        return last is String && last.startsWith('{');
+      }
+
+      for (final cand in points) {
+        if (pointTerminalParam(cand) != pointTerminalParam(point)) {
+          if (pointTerminalParam(cand)) {
+            point = cand;
+          }
+        } else if (pointPartsLen(cand) < pointPartsLen(point)) {
+          point = cand;
+        }
+      }
+    }
 
     final reqd = vs.transform(
       vs.select(vs.getpath(point, ['args', 'params']), {'reqd': true}),

package/project/.sdk/tm/dart/lib/utility/FetcherUtility.dart

@@ -46,6 +46,15 @@ Future<dynamic> httpFetch(dynamic fullurl, dynamic fetchdef) async {
 
     final req = await client.openUrl(method, uri);
 
+    // Manual redirects: fetchdef['redirect'] == 'manual' surfaces a 3xx as
+    // an ordinary response instead of auto-following it — HttpClient would
+    // otherwise replay the request, headers included, against whatever host
+    // Location names. Set by the station feature's transport middleware
+    // under an egress hosts policy (mirrors the ts fetch option).
+    if ('manual' == vs.getprop(fetchdef, 'redirect')) {
+      req.followRedirects = false;
+    }
+
     final headers = vs.getprop(fetchdef, 'headers');
     if (headers is Map) {
       headers.forEach((k, v) {

package/project/.sdk/tm/dart/lib/utility/MakeOptionsUtility.dart

@@ -47,6 +47,12 @@ dynamic makeOptions(dynamic ctx) {
       },
     },
     'utility': {},
+    // Feature INSTANCES supplied at construction (the station adopt
+    // path): consumed by the constructor's featureAdd loop, so they are
+    // class instances, not data - `$ANY` accepts them verbatim. Without
+    // this entry the seam is dead: the constructor reads
+    // options.extend, but validate rejected the key.
+    'extend': '`\$ANY`',
     'system': {},
     'test': {
       'active': false,
@@ -177,6 +183,17 @@ dynamic makeOptions(dynamic ctx) {
     } else {
       featureorder.addAll(names);
     }
+    // Station special case, mirroring test's: its transport wrap must
+    // sit immediately outside the base transport (inside retry/cache/
+    // netsim), so map-form activation hoists it to just after test -
+    // or first, when no test entry exists. Without this the sorted
+    // default would init station last and wrap OUTSIDE the recording
+    // features, turning its wire-truth events into fiction.
+    if (featureorder.contains('station')) {
+      featureorder.remove('station');
+      final ti = featureorder.indexOf('test');
+      featureorder.insert(-1 == ti ? 0 : ti + 1, 'station');
+    }
   }
 
   opts['__derived__'] = {

package/project/.sdk/tm/dart/lib/utility/MakePointUtility.dart

@@ -34,9 +34,10 @@ dynamic makePoint(dynamic ctx) {
     final selector = 'data' == op.input ? ctx.data : ctx.match;
 
     dynamic point;
+    var matched = false;
     for (var i = 0; i < op.points.length; i++) {
-      point = op.points[i];
-      final select = point.select;
+      final cand = op.points[i];
+      final select = cand.select;
       var found = true;
 
       final exist = vs.getprop(select, 'exist');
@@ -60,10 +61,55 @@ dynamic makePoint(dynamic ctx) {
       }
 
       if (found) {
+        point = cand;
+        matched = true;
         break;
       }
     }
 
+    // select.exist can list more than the params needed to pick a point, so
+    // nothing matches — fall back to the entity's own route rather than
+    // whichever point came last.
+    if (!matched) {
+      // A request naming an action reaches here only because that action's
+      // own point failed its exist test, so it is unbuildable whatever we
+      // pick. Refuse it BEFORE choosing a fallback: the guard below compares
+      // the chosen point's $action and would wave the request through
+      // whenever the fallback lands on the action point itself.
+      if (null != vs.getprop(reqselector, r'$action')) {
+        return ctx.error(
+            'point_action_invalid',
+            'Operation "' +
+                op.name.toString() +
+                '" action "' +
+                vs.getprop(reqselector, r'$action').toString() +
+                '" is not valid.');
+      }
+
+      // A terminal parameter marks a record route (/boards/{id}); a
+      // cross-reference ends in the relationship's name
+      // (/posts/{id}/author). Failing that, the shallower path wins.
+      bool terminalParam(dynamic p) {
+        final parts = p.parts;
+        if (parts.isEmpty) {
+          return false;
+        }
+        final last = parts[parts.length - 1];
+        return last is String && last.startsWith('{');
+      }
+
+      point = op.points[0];
+      for (final cand in op.points) {
+        if (terminalParam(cand) != terminalParam(point)) {
+          if (terminalParam(cand)) {
+            point = cand;
+          }
+        } else if (cand.parts.length < point.parts.length) {
+          point = cand;
+        }
+      }
+    }
+
     if (null != vs.getprop(reqselector, r'$action') &&
         null != point &&
         vs.getprop(reqselector, r'$action') !=

package/project/.sdk/tm/elixir/lib/projectname/utility.ex

@@ -261,6 +261,12 @@ defmodule ProjectName.Utility do
         "entity" => %{"`$CHILD`" => %{"`$OPEN`" => true, "active" => false, "alias" => %{}}},
         "feature" => %{"`$CHILD`" => %{"`$OPEN`" => true, "active" => false}},
         "utility" => %{},
+        # Feature INSTANCES supplied at construction (the station adopt
+        # path): consumed by the constructor's extend loop, so they are
+        # struct feature nodes, not data - `$ANY` accepts them verbatim.
+        # Without this entry the seam is dead: the constructor reads
+        # options.extend, but validate rejected the key.
+        "extend" => "`$ANY`",
         "system" => %{},
         "test" => %{"active" => false, "entity" => %{"`$OPEN`" => true}},
         "clean" => %{"keys" => "key,token,id"},
@@ -359,8 +365,29 @@ defmodule ProjectName.Utility do
           fmap = if S.ismap(fmap), do: fmap, else: S.jm([])
           names = S.keysof(fmap)
 
-          if Enum.member?(names, "test") do
-            ["test" | Enum.reject(names, &(&1 == "test"))]
+          names =
+            if Enum.member?(names, "test") do
+              ["test" | Enum.reject(names, &(&1 == "test"))]
+            else
+              names
+            end
+
+          # Station special case, mirroring test's: its transport wrap must
+          # sit immediately outside the base transport (inside retry/cache/
+          # netsim), so map-form activation hoists it to just after test -
+          # or first, when no test entry exists. Without this the sorted
+          # default would init station last and wrap OUTSIDE the recording
+          # features, turning its wire-truth events into fiction.
+          if Enum.member?(names, "station") do
+            rest = Enum.reject(names, &(&1 == "station"))
+
+            at =
+              case Enum.find_index(rest, &(&1 == "test")) do
+                nil -> 0
+                ti -> ti + 1
+              end
+
+            List.insert_at(rest, at, "station")
           else
             names
           end
@@ -465,21 +492,81 @@ defmodule ProjectName.Utility do
 
                 if found, do: {:halt, point}, else: {:cont, point}
             end)
-            |> elem(1)
 
-          err =
-            if reqselector != nil do
-              req_action = S.getprop(reqselector, "$action")
+          matched? = match?({:halt, _}, point)
 
-              if req_action != nil and point != nil do
-                point_select = H.to_map(S.getprop(point, "select"))
-                point_action = S.getprop(point_select, "$action")
+          point =
+            if matched? do
+              elem(point, 1)
+            else
+              # select.exist can list more than the params needed to pick a
+              # point, so nothing matched. Fall back to the entity's own
+              # route: a terminal parameter marks a record route
+              # (/boards/{id}) where a cross-reference ends in the
+              # relationship's name (/posts/{id}/author), and failing that
+              # the shallower path wins. The same rule runs at generation
+              # time, in helpers/opShape.ts — both sides must move together.
+              parts_len = fn p ->
+                parts = S.getprop(p, "parts")
+                if S.islist(parts), do: S.size(parts), else: 0
+              end
+
+              terminal_param? = fn p ->
+                parts = S.getprop(p, "parts")
 
-                if req_action != point_action do
-                  Context.make_error(ctx, "point_action_invalid",
-                    "Operation \"" <> opname <> "\" action \"" <> S.stringify(req_action) <> "\" is not valid.")
+                if S.islist(parts) and S.size(parts) > 0 do
+                  last = S.getelem(parts, S.size(parts) - 1)
+                  is_binary(last) and String.starts_with?(last, "{")
+                else
+                  false
                 end
               end
+
+              Enum.reduce(0..(npoints - 1), S.getelem(points, 0), fn i, best ->
+                cand = S.getelem(points, i)
+                ct = terminal_param?.(cand)
+                bt = terminal_param?.(best)
+
+                cond do
+                  ct != bt -> if ct, do: cand, else: best
+                  parts_len.(cand) < parts_len.(best) -> cand
+                  true -> best
+                end
+              end)
+            end
+
+          unmatched_action =
+            if not matched? and reqselector != nil,
+              do: S.getprop(reqselector, "$action"),
+              else: nil
+
+          err =
+            cond do
+              # A request naming an action reaches the fallback only because
+              # that action's own point failed its exist test, so it is
+              # unbuildable whatever we pick. Refuse it BEFORE the guard
+              # below, which compares the chosen point's $action and would
+              # wave the request through whenever the fallback lands on the
+              # action point itself.
+              unmatched_action != nil ->
+                Context.make_error(ctx, "point_action_invalid",
+                  "Operation \"" <> opname <> "\" action \"" <> S.stringify(unmatched_action) <> "\" is not valid.")
+
+              reqselector != nil ->
+                req_action = S.getprop(reqselector, "$action")
+
+                if req_action != nil and point != nil do
+                  point_select = H.to_map(S.getprop(point, "select"))
+                  point_action = S.getprop(point_select, "$action")
+
+                  if req_action != point_action do
+                    Context.make_error(ctx, "point_action_invalid",
+                      "Operation \"" <> opname <> "\" action \"" <> S.stringify(req_action) <> "\" is not valid.")
+                  end
+                end
+
+              true ->
+                nil
             end
 
           if err != nil do
@@ -1458,7 +1545,16 @@ defmodule ProjectName.Utility do
         {url, hlist}
       end
 
-    case :httpc.request(method, request, [], body_format: :binary) do
+    # A `redirect: "manual"` annotation (set by the station feature when a
+    # hosts egress policy is active - the same in-band channel go and rust
+    # use) disables :httpc's automatic redirect following, so a 3xx rides
+    # back as a normal response: a Location pointing off an egress
+    # allowlist must never pull an automatic credentialed follow-up
+    # request.
+    http_opts =
+      if S.getprop(fetchdef, "redirect") == "manual", do: [autoredirect: false], else: []
+
+    case :httpc.request(method, request, http_opts, body_format: :binary) do
       {:ok, {{_v, status, _reason}, resp_headers, resp_body}} ->
         rh =
           Enum.reduce(resp_headers, S.jm([]), fn {k, v}, acc ->

package/project/.sdk/tm/elixir/test/feature_test.exs

@@ -50,6 +50,25 @@ defmodule ProjectName.FeatureTest do
     assert has?("test")
   end
 
+  # === station ===
+
+  # The station adapter (installed by @voxgig/sdkgen-station) with NO open
+  # station must be an inert no-op that emits nothing and fails nothing
+  # (station design 3.1). Driven through the generated factory - never a
+  # compile-time module reference - so this file stays green both with and
+  # without the feature installed (absent, the harness simply adds no
+  # feature). Bound behaviour (registration, injection, wire events) is
+  # exercised by the station library's own suite and the consumer-side
+  # station validation, not here.
+  test "station adapter with no open station is an inert no-op" do
+    h = harness([fspec("station")])
+    res = FH.op(h, %{})
+    assert res.ok == true
+
+    # Inert: the transport is neither wrapped nor marked.
+    assert S.getprop(h.utility, "__station_wrap__") == nil
+  end
+
   # === netsim ===
 
   test "netsim fixed latency then delegate" do