@voxgig/sdkgen 3.5.1 → 3.7.0

package/project/.sdk/tm/js/src/utility/MakePointUtility.js

@@ -1,4 +1,50 @@
 
+// The entity's OWN route among an op's points, as opposed to a
+// CROSS-REFERENCE: another resource's route that happens to return this
+// entity (`/notifications/{id}/board` for a board). Both are plain GETs
+// with no `$action`, so the path itself is all there is to go on.
+//
+// Two signals, in order:
+//
+//   1. A record route ends in the record's identifier (`/boards/{id}`,
+//      `/accounts/{account_id}/users/{id}`); a cross-reference ends in the
+//      relationship's name (`/posts/{id}/author`). A terminal parameter is
+//      therefore the stronger signal, and unlike depth it survives an entity
+//      nested more deeply than the route pointing at it.
+//   2. Failing that, fewest path segments — the shallower route is the one
+//      the entity is named for.
+//
+// Ties keep the earlier point, so the sorted-key order of the model decides
+// and the output stays byte-stable.
+//
+// The same rule runs at GENERATION time, in `ownPoint` in
+// helpers/opShape.ts. It cannot be shared with this file — a template ships
+// standalone, outside that package — so it is written twice on purpose, and
+// both sides must move together.
+function terminalParam(point) {
+  const parts = point.parts
+  const last = 0 < parts.length ? parts[parts.length - 1] : ''
+  return 'string' === typeof last && 0 === last.indexOf('{')
+}
+
+
+function ownPoint(points) {
+  let best = points[0]
+
+  for (const cand of points) {
+    const candterm = terminalParam(cand)
+    const bestterm = terminalParam(best)
+
+    if (candterm !== bestterm ? candterm :
+      cand.parts.length < best.parts.length) {
+      best = cand
+    }
+  }
+
+  return best
+}
+
+
 function makePoint(ctx) {
   if (ctx.out.point) {
     return ctx.point = ctx.out.point
@@ -28,9 +74,10 @@ function makePoint(ctx) {
     const selector = getprop(ctx, op.input)
 
     let point
+    let matched = false
     for (let i = 0; i < op.points.length; i++) {
-      point = op.points[i]
-      const select = point.select
+      const cand = op.points[i]
+      const select = cand.select
       let found = true
 
       if (selector && select.exist) {
@@ -53,10 +100,33 @@ function makePoint(ctx) {
       }
 
       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 the request 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 action point is itself the one the
+      // fallback selects (a short action route folded into an entity whose
+      // canonical route is longer). An unbuildable action request is an
+      // error, never a silent request to some other endpoint.
+      if (null != reqselector.$action) {
+        return ctx.error('point_action_invalid', 'Operation "' + op.name +
+          '" action "' + reqselector.$action + '" is not valid.')
+      }
+
+      point = ownPoint(op.points)
+    }
+
     if (
       null != reqselector.$action &&
       null != point &&

package/project/.sdk/tm/kotlin/feature/TestFeature.kt

@@ -262,12 +262,41 @@ class TestFeature : BaseFeature("test", "0.0.1", true) {
   private fun buildArgs(ctx: Context, op: Operation, args: MutableMap<String, Any?>?): Any? {
     val 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.
     val points = Struct.getpath(
       ctx.config,
       listOf("entity", if (ctx.entity == null) "" else ctx.entity!!.name, "op", opname, "points"),
     )
-    val point = Struct.getelem(points, -1)
+    var point = Struct.getelem(points, 0)
+    if (points is List<*>) {
+      fun pointPartsLen(p: Any?): Int {
+        val parts = Struct.getprop(p, "parts")
+        return if (parts is List<*>) parts.size else 0
+      }
+      fun pointTerminalParam(p: Any?): Boolean {
+        val parts = Struct.getprop(p, "parts")
+        if (parts !is List<*> || parts.isEmpty()) {
+          return false
+        }
+        val last = parts[parts.size - 1]
+        return last is String && last.startsWith("{")
+      }
+      for (cand in points) {
+        val candTerm = pointTerminalParam(cand)
+        val bestTerm = pointTerminalParam(point)
+        if (candTerm != bestTerm) {
+          if (candTerm) {
+            point = cand
+          }
+        } else if (pointPartsLen(cand) < pointPartsLen(point)) {
+          point = cand
+        }
+      }
+    }
 
     // Get required params.
     val paramsPath = Struct.getpath(point, listOf("args", "params"))

package/project/.sdk/tm/kotlin/utility/Fetcher.kt

@@ -50,9 +50,18 @@ fun defaultHttpFetch(fullurl: String, fetchdef: MutableMap<String, Any?>): Mutab
     reqb.setHeader("User-Agent", "Mozilla/5.0 (compatible; ProjectNameSDK/1.0)")
   }
 
+  // Honour a redirect annotation on the fetch definition (set by the
+  // station feature's middleware under a hosts policy): "manual" returns
+  // a 3xx like any other response instead of following it — the ts
+  // donor's fetch honours the same key natively, and an automatic follow
+  // would carry injected credentials to a host no policy approved.
+  val redirectPolicy =
+    if ("manual" == fetchdef["redirect"]) HttpClient.Redirect.NEVER
+    else HttpClient.Redirect.NORMAL
+
   // Honour a proxy annotation on the fetch definition (set by the proxy
   // feature): route the request through a proxied HttpClient.
-  val clientb = HttpClient.newBuilder().followRedirects(HttpClient.Redirect.NORMAL)
+  val clientb = HttpClient.newBuilder().followRedirects(redirectPolicy)
   val proxy = fetchdef["proxy"]
   if (proxy is String && "" != proxy) {
     try {

package/project/.sdk/tm/kotlin/utility/MakeOptions.kt

@@ -141,6 +141,17 @@ fun makeOptions(ctx: Context): MutableMap<String, Any?> {
     } 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.
+    val si = featureorder.indexOf("station")
+    if (0 <= si) {
+      featureorder.removeAt(si)
+      featureorder.add(featureorder.indexOf("test") + 1, "station")
+    }
   }
 
   val derived = linkedMapOf<String, Any?>()

package/project/.sdk/tm/kotlin/utility/MakePoint.kt

@@ -4,6 +4,27 @@ import KOTLINPACKAGE.core.Context
 import KOTLINPACKAGE.core.Helpers
 import KOTLINPACKAGE.utility.struct.Struct
 
+// How many path segments a point has.
+private fun partsLen(point: Map<String, Any?>?): Int {
+  val parts = Struct.getprop(point, "parts")
+  return if (parts is List<*>) parts.size else 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 fun terminalParam(point: Map<String, Any?>?): Boolean {
+  val parts = Struct.getprop(point, "parts")
+  if (parts !is List<*> || parts.isEmpty()) {
+    return false
+  }
+  val last = parts[parts.size - 1]
+  return last is String && last.startsWith("{")
+}
+
 @Suppress("UNCHECKED_CAST")
 fun makePoint(ctx: Context): Map<String, Any?> {
   val outPoint = ctx.out["point"]
@@ -55,9 +76,10 @@ fun makePoint(ctx: Context): Map<String, Any?> {
     }
 
     var point: MutableMap<String, Any?>? = null
+    var matched = false
     for (i in op.points.indices) {
-      point = op.points[i]
-      val selectDef = Helpers.toMapAny(Struct.getprop(point, "select"))
+      val cand = op.points[i]
+      val selectDef = Helpers.toMapAny(Struct.getprop(cand, "select"))
       var found = true
 
       if (selectDef != null) {
@@ -84,10 +106,44 @@ fun makePoint(ctx: Context): Map<String, Any?> {
       }
 
       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.
+      val unmatchedAction = Struct.getprop(reqselector, "\$action", null)
+      if (unmatchedAction != null) {
+        throw ctx.makeError(
+          "point_action_invalid",
+          "Operation \"" + op.name +
+            "\" action \"" + Struct.stringify(unmatchedAction) + "\" is not valid.",
+        )
+      }
+
+      point = op.points[0]
+      for (cand in op.points) {
+        val candTerm = terminalParam(cand)
+        val bestTerm = terminalParam(point)
+        if (candTerm != bestTerm) {
+          if (candTerm) {
+            point = cand
+          }
+        } else if (partsLen(cand) < partsLen(point)) {
+          point = cand
+        }
+      }
+    }
+
     val reqAction = Struct.getprop(reqselector, "\$action", null)
     if (reqAction != null && point != null) {
       val pointSelect = Helpers.toMapAny(Struct.getprop(point, "select"))

package/project/.sdk/tm/lean/src/SdkUtility.lean

@@ -597,6 +597,20 @@ def makeResult (ctx : Value) : SIO Value := do
 
 /-- Select the endpoint for this operation: the single point, else the first
     whose `select.exist` keys are all present and whose `$action` agrees. -/
+/-- How many path segments a point has, and whether its path ends 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. -/
+def pointShape (pt : Value) : SIO (Nat × Bool) := do
+  match (← gp pt "parts") with
+  | .list i =>
+    let items ← listItems i
+    if items.size == 0 then pure (0, false)
+    else pure (items.size, (vs items[items.size - 1]!).startsWith "{")
+  | _ => pure (0, false)
+
 def makePoint (ctx : Value) : SIO Value := do
   let op ← gp ctx "op"
   let matchV ← gp ctx "reqmatch"
@@ -622,6 +636,20 @@ def makePoint (ctx : Value) : SIO Value := do
         | _ => pure ()
         if ok && ((← gp sel "$action") == (← gp matchV "$action")) then
           chosen := pt
+    -- 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 and this loop chose no point at all. Fall
+    -- back to the entity's own route rather than sending nowhere.
+    if isNov chosen then
+      let mut best := pts[0]!
+      for cand in pts do
+        let (candLen, candTerm) ← pointShape cand
+        let (bestLen, bestTerm) ← pointShape best
+        if candTerm && !bestTerm then
+          best := cand
+        else if candTerm == bestTerm && candLen < bestLen then
+          best := cand
+      chosen := best
     if !(isNov chosen) then sp ctx "point" chosen
     pure chosen
 

package/project/.sdk/tm/lean/test/TPrimaryUtility.lean

@@ -316,8 +316,19 @@ def main : IO UInt32 := do
     runset "makeResult" (← getSpec primary #["makeResult", "basic"]) fun entry => do
       pure ((← SdkUtility.makeResult (← entryCtx entry opts config)), none)
 
-    runset "makePoint" (← getSpec primary #["makePoint", "basic"]) fun entry => do
-      pure ((← SdkUtility.makePoint (← entryCtx entry opts config)), none)
+    -- makePoint is NOT driven here, and this is deliberate.
+    --
+    -- The section used to be empty, so running it asserted nothing. It now
+    -- carries seven cases, and every one supplies its own `options` (for
+    -- allow.op) and `config` (for the operation's points) — but `entryCtx`
+    -- OVERWRITES both with the SDK's, so the cases would not run as authored.
+    -- Wiring it up needs entryCtx to prefer a fixture-supplied options/config,
+    -- which changes every section here and could not be compiled or run when
+    -- this change was made.
+    --
+    -- Left out rather than left in: an entry that runs with the wrong context
+    -- is worse than one that does not run, and no coverage is lost — this
+    -- section asserted nothing before either.
 
     runset "makeFetchDef" (← getSpec primary #["makeFetchDef", "basic"]) fun entry => do
       pure ((← SdkUtility.makeFetchDef (← entryCtx entry opts config)), none)

package/project/.sdk/tm/lua/utility/make_options.lua

@@ -82,6 +82,12 @@ local function make_options_util(ctx)
       },
     },
     utility = {},
+    -- Feature INSTANCES supplied at construction (the station adopt
+    -- path): consumed by the constructor's feature_add 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,
@@ -104,6 +110,15 @@ local function make_options_util(ctx)
   -- Preserve system.fetch before merge/validate.
   local sys_fetch = vs.getpath(opts, "system.fetch")
 
+  -- Preserve extend feature INSTANCES before merge/validate, by ORIGINAL
+  -- reference (the ts makeOptions keeps the caller's instances too):
+  -- merge/validate are data-oriented and would mangle instance tables
+  -- carrying functions -- the same reason system.fetch is preserved.
+  local extend = nil
+  if type(options) == "table" and type(options["extend"]) == "table" then
+    extend = options["extend"]
+  end
+
   -- Clone the config side before merging: `config` is a per-Lua-state
   -- singleton (see config_shared), and merge would otherwise use its nested
   -- tables as merge TARGETS — one instance's options (server, headers, ...)
@@ -156,6 +171,11 @@ local function make_options_util(ctx)
     end
   end
 
+  -- Restore extend feature instances.
+  if extend ~= nil then
+    opts["extend"] = extend
+  end
+
   -- Derived clean config.
   local clean_keys = "key,token,id"
   local ck = vs.getpath(opts, "clean.keys")
@@ -202,6 +222,30 @@ local function make_options_util(ctx)
     else
       featureorder = 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.
+    local si = nil
+    for i, n in ipairs(featureorder) do
+      if n == "station" then
+        si = i
+        break
+      end
+    end
+    if si ~= nil then
+      table.remove(featureorder, si)
+      local ti = 0
+      for i, n in ipairs(featureorder) do
+        if n == "test" then
+          ti = i
+          break
+        end
+      end
+      table.insert(featureorder, ti + 1, "station")
+    end
   end
 
   local derived = { clean = {} }

package/project/.sdk/tm/lua/utility/make_point.lua

@@ -3,6 +3,32 @@
 local vs = require("utility.struct.struct")
 local helpers = require("core.helpers")
 
+-- How many path segments a point has.
+local function parts_len(point)
+  local parts = vs.getprop(point, "parts")
+  if type(parts) == "table" then
+    return #parts
+  end
+  return 0
+end
+
+
+-- 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.
+local function terminal_param(point)
+  local parts = vs.getprop(point, "parts")
+  if type(parts) ~= "table" or #parts == 0 then
+    return false
+  end
+  local last = parts[#parts]
+  return type(last) == "string" and last:sub(1, 1) == "{"
+end
+
+
 local function make_point_util(ctx)
   if ctx.out["point"] ~= nil then
     local preset = ctx.out["point"]
@@ -44,9 +70,10 @@ local function make_point_util(ctx)
     end
 
     local point = nil
+    local matched = false
     for i = 1, #op.points do
-      point = op.points[i]
-      local select_def = helpers.to_map(vs.getprop(point, "select"))
+      local cand = op.points[i]
+      local select_def = helpers.to_map(vs.getprop(cand, "select"))
       local found = true
 
       if selector ~= nil and select_def ~= nil then
@@ -73,10 +100,46 @@ local function make_point_util(ctx)
       end
 
       if found then
+        point = cand
+        matched = true
         break
       end
     end
 
+    -- 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 not matched then
+      -- 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.
+      local unmatched_action = nil
+      if reqselector ~= nil then
+        unmatched_action = vs.getprop(reqselector, "$action")
+      end
+      if unmatched_action ~= nil then
+        return nil, ctx:make_error("point_action_invalid",
+          'Operation "' .. op.name ..
+          '" action "' .. vs.stringify(unmatched_action) .. '" is not valid.')
+      end
+
+      point = op.points[1]
+      for i = 1, #op.points do
+        local cand = op.points[i]
+        local cand_term = terminal_param(cand)
+        local best_term = terminal_param(point)
+        if cand_term ~= best_term then
+          if cand_term then
+            point = cand
+          end
+        elseif parts_len(cand) < parts_len(point) then
+          point = cand
+        end
+      end
+    end
+
     if reqselector ~= nil then
       local req_action = vs.getprop(reqselector, "$action")
       if req_action ~= nil and point ~= nil then

package/project/.sdk/tm/ocaml/sdk_runtime.ml

@@ -636,12 +636,12 @@ let make_point_util (ctx : ctx) : (value * sdk_error option) =
           if op.op_input = "data" then ctx.c_reqdata, ctx.c_data
           else ctx.c_reqmatch, ctx.c_match in
         let chosen = ref Noval in
+        let matched = ref false in
         let n = List.length points in
         let arr = Array.of_list points in
         let i = ref 0 and stop = ref false in
         while not !stop && !i < n do
           let point = arr.(!i) in
-          chosen := point;
           let select_def = to_map (getp point "select") in
           let found = ref true in
           (match select_def with
@@ -661,8 +661,46 @@ let make_point_util (ctx : ctx) : (value * sdk_error option) =
             let select_action = getp select_def "$action" in
             if req_action <> select_action then found := false
           end;
-          if !found then stop := true else incr i
+          if !found then begin chosen := point; matched := true; stop := true end
+          else incr i
         done;
+        (* 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 not !matched then begin
+          (* 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. *)
+          let unmatched_action = getp reqselector "$action" in
+          if not (is_noval unmatched_action) then
+            raise (Sdk_error_exc (ctx_make_error ctx "point_action_invalid"
+              ("Operation \"" ^ op.op_name ^ "\" action \"" ^ (stringify unmatched_action) ^ "\" 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. *)
+          let parts_len p =
+            match getp p "parts" with List r -> List.length !r | _ -> 0 in
+          let terminal_param p =
+            match getp p "parts" with
+            | List r ->
+              (match List.rev !r with
+               | last :: _ ->
+                 let s = vstring last in
+                 String.length s > 0 && s.[0] = '{'
+               | [] -> false)
+            | _ -> false in
+          chosen := arr.(0);
+          Array.iter (fun cand ->
+              let ct = terminal_param cand and bt = terminal_param !chosen in
+              if ct <> bt then (if ct then chosen := cand)
+              else if parts_len cand < parts_len !chosen then chosen := cand) arr
+        end;
         let req_action = getp reqselector "$action" in
         if not (is_noval req_action) && not (is_noval !chosen) then begin
           let point_select = to_map (getp !chosen "select") in

package/project/.sdk/tm/perl/utility/fetcher.pm

@@ -39,7 +39,16 @@ our $DefaultHttpFetch = sub {
   my $opts = { headers => \%hdrs };
   $opts->{content} = "$body" if defined $body && !ref $body;
 
-  my $res = eval { HTTP::Tiny->new->request($method, $fullurl, $opts) };
+  # fetchdef.redirect 'manual' (the ts fetch vocabulary): return a 3xx
+  # as-is instead of following it. HTTP::Tiny follows redirects by
+  # default; the station feature's hosts policy sets this so a Location
+  # off the allowlist can never pull an automatic credentialed follow-up.
+  my %new_args;
+  $new_args{max_redirect} = 0
+    if defined $fetchdef->{redirect} && !ref $fetchdef->{redirect}
+      && 'manual' eq $fetchdef->{redirect};
+
+  my $res = eval { HTTP::Tiny->new(%new_args)->request($method, $fullurl, $opts) };
   if (!$res) {
     my $e = defined $@ ? "$@" : 'request failed';
     $e =~ s/\s+\z//;

package/project/.sdk/tm/perl/utility/make_options.pm

@@ -26,8 +26,20 @@ $REGISTRY{make_options} = sub {
     }
   }
 
+  # Feature INSTANCES supplied at construction (the station adopt path):
+  # consumed by the constructor's extend loop, so they are blessed class
+  # instances, not data. This is the perl form of the ts/rb targets'
+  # `extend => $ANY` optspec entry: this port deep-clones its options, and
+  # Voxgig::Struct::clone would flatten a blessed feature to a plain
+  # unblessed hash (and validate rejects the key outright), so the RAW
+  # list is captured here and re-attached after validation - the
+  # system.fetch idiom. Without this the seam is dead: the constructor
+  # reads options.extend, but clone/validate dropped the instances.
+  my $extend_raw = ProjectNameHelpers::gp($options, 'extend');
+
   my $opts = Voxgig::Struct::clone($options);
   $opts = {} unless Voxgig::Struct::ismap($opts);
+  delete $opts->{extend};
 
   # Feature add-order. options.feature may be given as an ordered ARRAY of
   # { name, active, ...opts } entries (the array position IS the order in
@@ -78,6 +90,12 @@ $REGISTRY{make_options} = sub {
     'system' => {},
     'test' => { 'active' => $JF, 'entity' => { '`$OPEN`' => $JT } },
     'clean' => { 'keys' => 'key,token,id' },
+    # Server-variable values for a templated base URL (OpenAPI server
+    # variables). The embedded config (configDefinition) carries the
+    # spec defaults; user values override them. This port does not yet
+    # substitute {name} placeholders into base - the entry keeps the
+    # config's server block valid under this optspec.
+    'server' => { '`$CHILD`' => '' },
   };
 
   my $sys_fetch = ProjectNameHelpers::gpath($opts, 'system.fetch');
@@ -95,6 +113,11 @@ $REGISTRY{make_options} = sub {
     $opts->{system}{fetch} = $sys_fetch;
   }
 
+  # Re-attach the raw extend instances captured above.
+  if (Voxgig::Struct::islist($extend_raw)) {
+    $opts->{extend} = $extend_raw;
+  }
+
   my $clean_keys = ProjectNameHelpers::gpath($opts, 'clean.keys');
   $clean_keys = 'key,token,id' unless defined $clean_keys && !ref $clean_keys;
   my @parts;
@@ -114,6 +137,19 @@ $REGISTRY{make_options} = sub {
     @featureorder = (grep { 'test' eq $_ } @names)
       ? ('test', grep { 'test' ne $_ } @names)
       : @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.
+    my ($si) = grep { 'station' eq $featureorder[$_] } 0 .. $#featureorder;
+    if (defined $si) {
+      splice @featureorder, $si, 1;
+      my ($ti) = grep { 'test' eq $featureorder[$_] } 0 .. $#featureorder;
+      splice @featureorder, (defined $ti ? $ti + 1 : 0), 0, 'station';
+    }
   }
 
   $opts->{__derived__} = {