@voxgig/sdkgen 3.5.1 → 3.7.0

package/project/.sdk/tm/rust/utility/make_point.rs

@@ -7,6 +7,33 @@ use crate::core::types::OutVal;
 use crate::utility::voxgigstruct as vs;
 use crate::utility::voxgigstruct::Value;
 
+// How many path segments a point has.
+fn parts_len(point: &Value) -> usize {
+    match getp(point, "parts") {
+        Value::List(l) => l.borrow().len(),
+        _ => 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.
+fn terminal_param(point: &Value) -> bool {
+    match getp(point, "parts") {
+        Value::List(l) => {
+            let parts = l.borrow();
+            match parts.last() {
+                Some(Value::Str(s)) => s.starts_with('{'),
+                _ => false,
+            }
+        }
+        _ => false,
+    }
+}
+
 pub fn make_point_util(ctx: &Rc<Context>) -> Result<Value, ProjectNameError> {
     match ctx.out_get("point") {
         // A PrePoint feature hook (e.g. rbac) may short-circuit the
@@ -60,9 +87,10 @@ pub fn make_point_util(ctx: &Rc<Context>) -> Result<Value, ProjectNameError> {
         };
 
         let mut point = Value::Noval;
+        let mut matched = false;
         for i in 0..plen {
-            point = vs::get_elem(&points, &Value::Num(i as f64), Value::Noval);
-            let select_def = to_map(&getp(&point, "select"));
+            let cand = vs::get_elem(&points, &Value::Num(i as f64), Value::Noval);
+            let select_def = to_map(&getp(&cand, "select"));
             let mut found = true;
 
             if !selector.is_noval() && !select_def.is_noval() {
@@ -89,10 +117,49 @@ pub fn make_point_util(ctx: &Rc<Context>) -> Result<Value, ProjectNameError> {
             }
 
             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.
+            let unmatched_action = getp(&reqselector, "$action");
+            if !unmatched_action.is_noval() {
+                return Err(ctx.make_error(
+                    "point_action_invalid",
+                    &format!(
+                        "Operation \"{}\" action \"{}\" is not valid.",
+                        op.name,
+                        vs::stringify(&unmatched_action, None, false)
+                    ),
+                ));
+            }
+
+            point = vs::get_elem(&points, &Value::Num(0.0), Value::Noval);
+            for i in 0..plen {
+                let cand = vs::get_elem(&points, &Value::Num(i as f64), Value::Noval);
+                let cand_term = terminal_param(&cand);
+                let best_term = terminal_param(&point);
+                if cand_term != best_term {
+                    if cand_term {
+                        point = cand;
+                    }
+                } else if parts_len(&cand) < parts_len(&point) {
+                    point = cand;
+                }
+            }
+        }
+
         let req_action = getp(&reqselector, "$action");
         if !req_action.is_noval() && !point.is_noval() {
             let point_select = to_map(&getp(&point, "select"));

package/project/.sdk/tm/scala/feature/TestFeature.scala

@@ -215,9 +215,44 @@ class TestFeature extends BaseFeature("test", "0.0.1", true) {
   private def buildArgs(ctx: Context, op: Operation, args: JMap[String, Object]): Object = {
     val opname = op.name
 
+    // 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,
       java.util.List.of("entity", if (ctx.entity == null) "" else ctx.entity.getName(), "op", opname, "points"))
-    val point = Struct.getelem(points, java.lang.Integer.valueOf(-1))
+    var point = Struct.getelem(points, java.lang.Integer.valueOf(0))
+    points match {
+      case plist: java.util.List[_] =>
+        def pointPartsLen(p: Object): Int =
+          Struct.getprop(p, "parts") match {
+            case parts: java.util.List[_] => parts.size()
+            case _ => 0
+          }
+        def pointTerminalParam(p: Object): Boolean =
+          Struct.getprop(p, "parts") match {
+            case parts: java.util.List[_] if parts.size() > 0 =>
+              parts.get(parts.size() - 1) match {
+                case s: String => s.startsWith("{")
+                case _ => false
+              }
+            case _ => false
+          }
+        var k = 0
+        while (k < plist.size()) {
+          val cand = plist.get(k).asInstanceOf[Object]
+          val candTerm = pointTerminalParam(cand)
+          val bestTerm = pointTerminalParam(point)
+          if (candTerm != bestTerm) {
+            if (candTerm) point = cand
+          } else if (pointPartsLen(cand) < pointPartsLen(point)) {
+            point = cand
+          }
+          k += 1
+        }
+      case _ =>
+    }
 
     val paramsPath = Struct.getpath(point, java.util.List.of("args", "params"))
     val reqdParams = Struct.select(paramsPath, Struct.jm("reqd", java.lang.Boolean.TRUE))

package/project/.sdk/tm/scala/utility/Make.scala

@@ -94,11 +94,12 @@ object MakePoint {
       val selector: JMap[String, Object] = if ("data" == op.input) ctx.data else ctx.matchData
 
       var point: JMap[String, Object] = null
+      var matched = false
       var i = 0
       var break = false
       while (i < op.points.size() && !break) {
-        point = op.points.get(i)
-        val selectDef = Helpers.toMapAny(Struct.getprop(point, "select"))
+        val cand = op.points.get(i)
+        val selectDef = Helpers.toMapAny(Struct.getprop(cand, "select"))
         var found = true
 
         if (selector != null && selectDef != null) {
@@ -122,7 +123,60 @@ object MakePoint {
           if (!Objects.equals(reqAction, selectAction)) found = false
         }
 
-        if (found) break = true else i += 1
+        if (found) { point = cand; matched = true; break = true } else i += 1
+      }
+
+      // 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.
+        val unmatchedAction =
+          if (reqselector != null) Struct.getprop(reqselector, "$action", null) else null
+        if (unmatchedAction != 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.
+        def partsLen(p: JMap[String, Object]): Int =
+          Struct.getprop(p, "parts") match {
+            case parts: JList[_] => parts.size()
+            case _ => 0
+          }
+        def terminalParam(p: JMap[String, Object]): Boolean =
+          Struct.getprop(p, "parts") match {
+            case parts: JList[_] if parts.size() > 0 =>
+              parts.get(parts.size() - 1) match {
+                case s: String => s.startsWith("{")
+                case _ => false
+              }
+            case _ => false
+          }
+
+        point = op.points.get(0)
+        var j = 0
+        while (j < op.points.size()) {
+          val cand = op.points.get(j)
+          val candTerm = terminalParam(cand)
+          val bestTerm = terminalParam(point)
+          if (candTerm != bestTerm) {
+            if (candTerm) point = cand
+          } else if (partsLen(cand) < partsLen(point)) {
+            point = cand
+          }
+          j += 1
+        }
       }
 
       if (reqselector != null) {

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/feature/TestFeature.swift

@@ -38,7 +38,35 @@ private func testBuildArgs(_ ctx: Context, _ op: Operation, _ args: VMap?) -> Va
 
   let cfg: Value = ctx.config == nil ? .noval : .map(ctx.config!)
   let points = getpath(cfg, jtp("entity", ctx.entity!.getName(), "op", opname, "points"))
-  let point = getelem(points, .int(-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.
+  func pointPartsLen(_ p: Value) -> Int {
+    return getprop(p, .string("parts")).asList?.items.count ?? 0
+  }
+  func pointTerminalParam(_ p: Value) -> Bool {
+    guard let items = getprop(p, .string("parts")).asList?.items, let last = items.last else {
+      return false
+    }
+    return (last.asString ?? "").hasPrefix("{")
+  }
+
+  var point = getelem(points, .int(0))
+  if let candidates = points.asList?.items {
+    for cand in candidates {
+      let candTerm = pointTerminalParam(cand)
+      let bestTerm = pointTerminalParam(point)
+      if candTerm != bestTerm {
+        if candTerm { point = cand }
+      }
+      else if pointPartsLen(cand) < pointPartsLen(point) {
+        point = cand
+      }
+    }
+  }
 
   let paramsPath = getpath(point, jtp("args", "params"))
   let reqdParams = select(paramsPath, .map(vm(("reqd", .bool(true)))))

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/utility/Fetcher.swift

@@ -6,6 +6,27 @@ import Foundation
 import FoundationNetworking
 #endif
 
+// Non-following twin of URLSession.shared. 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-delegate in URLSession,
+// hence a second session).
+private final class ManualRedirectDelegate: NSObject, URLSessionTaskDelegate {
+  func urlSession(
+    _ session: URLSession, task: URLSessionTask,
+    willPerformHTTPRedirection response: HTTPURLResponse,
+    newRequest request: URLRequest,
+    completionHandler: @escaping (URLRequest?) -> Void
+  ) {
+    completionHandler(nil)
+  }
+}
+
+private let manualRedirectSession = URLSession(
+  configuration: .default, delegate: ManualRedirectDelegate(), delegateQueue: nil)
+
 func defaultHttpFetch(_ fullurl: String, _ fetchdef: VMap) throws -> Value {
   guard let url = URL(string: fullurl) else {
     let m = VMap()
@@ -45,7 +66,9 @@ func defaultHttpFetch(_ fullurl: String, _ fetchdef: VMap) throws -> Value {
   }
   let box = FetchBox()
   let sem = DispatchSemaphore(value: 0)
-  let task = URLSession.shared.dataTask(with: req) { d, r, e in
+  let session = gp(fetchdef, "redirect").asString == "manual"
+    ? manualRedirectSession : URLSession.shared
+  let task = session.dataTask(with: req) { d, r, e in
     box.data = d; box.resp = r; box.err = e; sem.signal()
   }
   task.resume()

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/utility/Make.swift

@@ -40,8 +40,8 @@ func makePointUtil(_ ctx: Context) throws -> VMap? {
     }
 
     var point: VMap? = nil
+    var matched = false
     for candidate in op.points {
-      point = candidate
       let selectDef = gp(candidate, "select").asMap
       var found = true
 
@@ -62,7 +62,56 @@ func makePointUtil(_ ctx: Context) throws -> VMap? {
         if reqAction != selectAction { found = false }
       }
 
-      if found { break }
+      if found {
+        point = candidate
+        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.
+      let unmatchedAction = gp(reqselector, "$action")
+      if !isNil(unmatchedAction) {
+        throw ctx.makeError("point_action_invalid",
+          "Operation \"\(op.name)\" action \"\(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.
+      func partsLen(_ p: VMap) -> Int {
+        return gp(p, "parts").asList?.items.count ?? 0
+      }
+      func terminalParam(_ p: VMap) -> Bool {
+        guard let items = gp(p, "parts").asList?.items, let last = items.last else {
+          return false
+        }
+        return (last.asString ?? "").hasPrefix("{")
+      }
+
+      point = op.points.first
+      for candidate in op.points {
+        guard let best = point else { break }
+        let candTerm = terminalParam(candidate)
+        let bestTerm = terminalParam(best)
+        if candTerm != bestTerm {
+          if candTerm { point = candidate }
+        }
+        else if partsLen(candidate) < partsLen(best) {
+          point = candidate
+        }
+      }
     }
 
     let reqAction = gp(reqselector, "$action")

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/utility/MakeOptions.swift

@@ -139,6 +139,18 @@ func makeOptionsUtil(_ ctx: Context) -> VMap {
     } else {
       for n in names { featureorder.append(.string(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.
+    if let si = featureorder.firstIndex(where: { $0.asString == "station" }) {
+      featureorder.remove(at: si)
+      let ti = featureorder.firstIndex(where: { $0.asString == "test" })
+      featureorder.insert(.string("station"), at: (ti ?? -1) + 1)
+    }
   }
 
   let derived = VMap()

package/project/.sdk/tm/ts/src/feature/test/TestFeature.ts

@@ -253,9 +253,28 @@ class TestFeature extends BaseFeature {
     const isempty = struct.isempty
 
     const opname = getprop(op, 'name')
-    const point =
-      getelem(getpath(ctx.config, [
-        'entity', getprop(ctx.entity, 'name'), 'op', opname, 'points']), -1)
+    const points = getpath(ctx.config, [
+      'entity', getprop(ctx.entity, 'name'), 'op', opname, 'points']) || []
+
+    // Pick the entity's own endpoint, 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.
+    const isterm = (pt: any) => {
+      const parts = pt.parts
+      const last = 0 < parts.length ? parts[parts.length - 1] : ''
+      return 'string' === typeof last && 0 === last.indexOf('{')
+    }
+
+    let point = getelem(points, 0)
+    for (let i = 1; i < points.length; i++) {
+      const cand = getelem(points, i)
+      if (isterm(cand) !== isterm(point) ? isterm(cand) :
+        cand.parts.length < point.parts.length) {
+        point = cand
+      }
+    }
 
     const reqd = transform(
       select(getpath(point, ['args', 'params']), { reqd: true }),

package/project/.sdk/tm/ts/src/utility/MakeOptionsUtility.ts

@@ -71,6 +71,12 @@ function makeOptions(ctx: Context) {
       }
     },
     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`' as any,
     system: {
       fetch: undefined as any
     },
@@ -134,10 +140,22 @@ function makeOptions(ctx: Context) {
   // otherwise order the map test-first, then the remaining names sorted, so
   // the outcome is deterministic and `test` is always the base transport.
   if (0 === featureorder.length) {
-    const names = Object.keys(opts.feature || {}).sort()
-    featureorder = names.indexOf('test') < 0
+    let names = Object.keys(opts.feature || {}).sort()
+    names = names.indexOf('test') < 0
       ? names
       : ['test'].concat(names.filter((n: string) => 'test' !== 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.
+    const si = names.indexOf('station')
+    if (0 <= si) {
+      names.splice(si, 1)
+      names.splice(names.indexOf('test') + 1, 0, 'station')
+    }
+    featureorder = names
   }
 
   opts.__derived__ = {

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

@@ -2,6 +2,52 @@
 import { Context, Point } from '../types'
 
 
+// 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 `shortestPoint`/`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: any): boolean {
+  const parts = point.parts
+  const last = 0 < parts.length ? parts[parts.length - 1] : ''
+  return 'string' === typeof last && 0 === last.indexOf('{')
+}
+
+
+function ownPoint(points: any[]): any {
+  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: Context): Point | Error {
   if (ctx.out.point) {
     return ctx.point = ctx.out.point
@@ -31,9 +77,10 @@ function makePoint(ctx: Context): Point | Error {
     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) {
@@ -56,10 +103,33 @@ function makePoint(ctx: Context): Point | Error {
       }
 
       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/ts/test/utility/Corpus.test.ts

@@ -0,0 +1,85 @@
+import { test, describe } from 'node:test'
+import { ok, equal } from 'node:assert'
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { TEST_JSON_FILE } from './index'
+
+
+// Guards the shared corpus AS A WHOLE, which the per-section guard in the
+// language runners cannot do.
+//
+// That guard only fires for a section some test actually runs. Seven sections
+// — fetcher, makeFetchDef, makePoint, makeResult, featureAdd, featureHook and
+// featureInit — had no test calling them at all, so they sat at `set: []`
+// through two reviews reporting nothing. A fixture nobody runs is
+// indistinguishable from a fixture that passes.
+//
+// Deferral is therefore DATA (`basic.pending`), not a comment: comments do not
+// survive compilation to test.json, so a marker written only in the .aontu
+// source cannot be checked by the thing that consumes it. Being data, these
+// invariants hold for every port, not just this one.
+describe('Corpus', () => {
+
+  // Resolved the same way runner.ts resolves it — from dist-test/, one level
+  // up from this file's dist-test/utility/.
+  const corpus = JSON.parse(
+    readFileSync(join(__dirname, '..', TEST_JSON_FILE), 'utf8'))
+
+  const primary: Record<string, any> = corpus.primary || {}
+  const names = Object.keys(primary).sort()
+
+
+  test('the corpus is not empty', () => {
+    ok(0 < names.length, 'no primary sections found — check TEST_JSON_FILE')
+  })
+
+
+  // A section that compiles to zero cases must say why, in the fixture.
+  test('every empty section declares why it is deferred', () => {
+    const undeclared = names.filter((n) => {
+      const basic = primary[n]?.basic
+      return Array.isArray(basic?.set) && 0 === basic.set.length &&
+        'string' !== typeof basic?.pending
+    })
+    equal(undeclared.join(','), '',
+      'these sections compile to ZERO cases and carry no `basic: pending` ' +
+      'reason — add cases, or state the blocker in .sdk/test/primary/<name>.aontu')
+  })
+
+
+  // "PENDING" with no reason is just a way to keep a hole open.
+  test('every deferral gives a real reason', () => {
+    for (const n of names) {
+      const pending = primary[n]?.basic?.pending
+      if (null == pending) continue
+      ok(20 < String(pending).length,
+        `${n}: 'pending' needs a reason, not just a marker`)
+    }
+  })
+
+
+  // The other direction: a section that has gained cases must drop its
+  // deferral, or the marker rots into a lie and the runners keep excusing it.
+  test('a deferred section that gained cases is promoted', () => {
+    const stale = names.filter((n) => {
+      const basic = primary[n]?.basic
+      return null != basic?.pending && Array.isArray(basic?.set) &&
+        0 < basic.set.length
+    })
+    equal(stale.join(','), '',
+      'these sections now have cases — remove `basic: pending` from the ' +
+      'fixture and from the PENDING list in the language runners')
+  })
+
+
+  // Every section must actually be a section: `basic.set` is what the runners
+  // iterate, and a fixture that failed to compile silently loses it.
+  test('every section has a basic.set list', () => {
+    for (const n of names) {
+      ok(Array.isArray(primary[n]?.basic?.set),
+        `${n}: no basic.set list — the fixture did not compile as expected`)
+    }
+  })
+
+})