@voxgig/sdkgen 4.8.2 → 4.9.0

package/project/.sdk/tm/cpp/test/primary_utility_test.cpp

@@ -1,23 +1,88 @@
 // ProjectName SDK — drives the primary utility functions against the shared
-// test.json spec (../.sdk/test/test.json, section "primary"). Mirrors
-// java test/PrimaryUtilityTest.java + tm/go/test/primary_utility_test.go.
-
+// test.json spec (../.sdk/test/test.json, section "primary") through the
+// VENDORED omni runner (test/omni_resolver.hpp over test/vendor/omni).
+// Mirrors java test/PrimaryUtilityTest.java + tm/go/test/primary_utility_test.go.
+//
+// Subjects receive omni's native argument list: a ctx entry arrives as
+// args[0], a MAP — resolver::omni_ctx builds the typed Context a generated
+// utility takes, and resolver::omni_sync_ctx writes the observable ctx
+// state back for `match: {ctx: ...}` assertions (which the resolver has
+// rewritten to `match: {args: [...]}`; see its decision 4). A failing entry
+// throws omni::OmniError naming the entry, which T_RUN records.
+
+#include <algorithm>
 #include <memory>
+#include <set>
 #include <string>
 #include <vector>
 
-#include "runner_support.hpp"
+#include "omni_resolver.hpp"
 #include "harness.hpp"
 
 using namespace sdk;
 using namespace sdk::fh;
+namespace res = sdk::resolver;
+
+static const char* TEST_JSON_FILE = "../.sdk/test/test.json";
 
-static Value primary() {
-  return rs::get_spec(rs::load_test_spec(), {"primary"});
+// One corpus runner for the whole binary. Its client is the runner's own
+// (only a DEF.client entry would use it); each test still builds the client
+// it drives, because several of them mutate it.
+static res::Run& primaryRun() {
+  static res::Run run =
+      res::makeRunner(TEST_JSON_FILE, ProjectNameSDK::testSDK())
+          .runner("primary", Value::undef());
+  return run;
 }
 
 static std::shared_ptr<ProjectNameSDK> client() { return ProjectNameSDK::testSDK(); }
 
+// args[0], or no value at all (an entry with no in/args/ctx, which this
+// port's omni delivers as one absent argument).
+static Value arg0(std::vector<Value>& args) {
+  return args.empty() ? Value::undef() : args[0];
+}
+
+// Every corpus section this binary ASKED to run, whether or not the guard
+// below let it through. corpusCoverage() compares it against the fixture,
+// which is the only way a section that NO test names can be noticed: the
+// per-section guard cannot fire for a call nobody wrote.
+static std::set<std::string>& drivenSections() {
+  static std::set<std::string> names;
+  return names;
+}
+
+// Run one corpus section's `basic` group, failing LOUDLY when it would run
+// ZERO cases. A renamed section, a fixture that failed to compile, or an
+// empty set used to report PASS while running no assertions at all — the
+// whole point of a shared oracle lost without a single red test. (The guard
+// lives here rather than in the runner, which is vendored verbatim; the
+// shared corpus is a v0 spec, and v0 tolerates an empty set.)
+static void runsection(const std::string& name, const res::Subject& subject) {
+  drivenSections().insert(name);
+
+  Value section = Helpers::toMapAny(primaryRun().set(name));
+  if (!section.is_map()) {
+    sdktest::record_fail(name, "test corpus section \"" + name +
+                                   "\" missing - check .sdk/test/primary/");
+    return;
+  }
+  Value basic = Helpers::toMapAny(getp(section, Value("basic")));
+  Value set = basic.is_map() ? getp(basic, Value("set")) : Value::undef();
+  if (!set.is_list()) {
+    sdktest::record_fail(name, "test corpus section \"" + name +
+                                   "\" has no basic.set list - zero cases would run");
+    return;
+  }
+  if (set.as_list()->empty()) {
+    sdktest::record_fail(name, "test corpus section \"" + name +
+                                   "\" is EMPTY - zero cases would run");
+    return;
+  }
+  sdktest::checks()++;
+  primaryRun().runsetflags(name, basic, true, subject);
+}
+
 // Helper: create basic test context.
 static CtxPtr makeTestCtx(std::shared_ptr<ProjectNameSDK> client_, UtilityPtr utility) {
   CtxSpec cs;
@@ -104,15 +169,29 @@ static void cleanBasic() {
   ASSERT_TRUE(cleaned.is_map(), "cleaned should not be null");
 }
 
+// The shared corpus drives the same function over four shapes the stub above
+// cannot reach — an empty map, a bare string, a list — and asserts the value
+// that comes back, not merely that one does. (The ts and java peers pair the
+// stub with this section the same way.)
+static void cleanCorpus() {
+  auto c = client();
+  UtilityPtr utility = c->getUtility();
+  runsection("clean", [&](std::vector<Value>& args) -> Value {
+    if (2 != args.size()) {
+      throw std::runtime_error("clean: expected 2 args, got " + std::to_string(args.size()));
+    }
+    CtxPtr ctx = res::omni_ctx(args[0], c, utility);
+    return utility->clean(ctx, args[1]);
+  });
+}
+
 // --- done -------------------------------------------------------------------
 
 static void doneBasic() {
   auto c = client();
   UtilityPtr utility = c->getUtility();
-  rs::runset("done-basic", rs::get_spec(primary(), {"done", "basic"}), [&](const Value& entry) -> Value {
-    Value ctxmap = Helpers::toMapAny(getp(entry, "ctx"));
-    CtxPtr ctx = rs::make_ctx_from_map(ctxmap, c, utility);
-    rs::fixctx(ctx, c);
+  runsection("done", [&](std::vector<Value>& args) -> Value {
+    CtxPtr ctx = res::omni_ctx(arg0(args), c, utility);
     return utility->done(ctx);
   });
 }
@@ -122,19 +201,14 @@ static void doneBasic() {
 static void makeErrorBasic() {
   auto c = client();
   UtilityPtr utility = c->getUtility();
-  rs::runset("makeError-basic", rs::get_spec(primary(), {"makeError", "basic"}), [&](const Value& entry) -> Value {
-    Value args = getp(entry, "args");
-    if (!args.is_list()) args = vlist();
-    if (args.as_list()->empty()) args.as_list()->push_back(vmap());
-
-    Value ctxmap = Helpers::toMapAny(vs::getelem(args, Value(int64_t(0))));
+  runsection("makeError", [&](std::vector<Value>& args) -> Value {
+    Value ctxmap = Helpers::toMapAny(arg0(args));
     if (!ctxmap.is_map()) ctxmap = vmap();
-    CtxPtr ctx = rs::make_ctx_from_map(ctxmap, c, utility);
-    rs::fixctx(ctx, c);
+    CtxPtr ctx = res::omni_ctx(ctxmap, c, utility);
 
     SdkErrorPtr err;
-    if (args.as_list()->size() > 1) {
-      err = errFromMap(Helpers::toMapAny(vs::getelem(args, Value(int64_t(1)))));
+    if (args.size() > 1) {
+      err = errFromMap(Helpers::toMapAny(args[1]));
     }
     return utility->makeError(ctx, err);
   });
@@ -283,9 +357,8 @@ static void fetcherBlockedTestMode() {
 static void makeContextBasic() {
   auto c = client();
   UtilityPtr utility = c->getUtility();
-  rs::runset("makeContext-basic", rs::get_spec(primary(), {"makeContext", "basic"}),
-             [&](const Value& entry) -> Value {
-    Value in = Helpers::toMapAny(getp(entry, "in"));
+  runsection("makeContext", [&](std::vector<Value>& args) -> Value {
+    Value in = Helpers::toMapAny(arg0(args));
     if (!in.is_map()) return Value::undef();
     CtxPtr ctx = rs::make_ctx_from_map(in, c, utility);
     Value out = vmap();
@@ -354,9 +427,8 @@ static void makeFetchDefWithBody() {
 static void makeOptionsBasic() {
   auto c = client();
   UtilityPtr utility = c->getUtility();
-  rs::runset("makeOptions-basic", rs::get_spec(primary(), {"makeOptions", "basic"}),
-             [&](const Value& entry) -> Value {
-    Value in = Helpers::toMapAny(getp(entry, "in"));
+  runsection("makeOptions", [&](std::vector<Value>& args) -> Value {
+    Value in = Helpers::toMapAny(arg0(args));
     CtxSpec cs;
     if (in.is_map()) {
       Value opt = Helpers::toMapAny(getp(in, "options"));
@@ -376,19 +448,13 @@ static void makeOptionsBasic() {
 static void makeRequestBasic() {
   auto c = client();
   UtilityPtr utility = c->getUtility();
-  rs::runset("makeRequest-basic", rs::get_spec(primary(), {"makeRequest", "basic"}),
-             [&](const Value& entry) -> Value {
-    Value ctxmap = Helpers::toMapAny(getp(entry, "ctx"));
-    CtxPtr ctx = rs::make_ctx_from_map(ctxmap, c, utility);
+  runsection("makeRequest", [&](std::vector<Value>& args) -> Value {
+    CtxPtr ctx = res::omni_ctx(arg0(args), c, utility);
     ctx->options = c->optionsMap();
 
     utility->makeRequest(ctx);
 
-    Value entryCtx = Helpers::toMapAny(getp(entry, "ctx"));
-    if (entryCtx.is_map()) {
-      if (ctx->response) map_put(entryCtx, "response", Value("exists"));
-      if (ctx->result) map_put(entryCtx, "result", Value("exists"));
-    }
+    res::omni_sync_ctx(arg0(args), ctx);
     return Value::undef();
   });
 }
@@ -398,23 +464,12 @@ static void makeRequestBasic() {
 static void makeResponseBasic() {
   auto c = client();
   UtilityPtr utility = c->getUtility();
-  rs::runset("makeResponse-basic", rs::get_spec(primary(), {"makeResponse", "basic"}),
-             [&](const Value& entry) -> Value {
-    Value ctxmap = Helpers::toMapAny(getp(entry, "ctx"));
-    CtxPtr ctx = rs::make_ctx_from_map(ctxmap, c, utility);
-    rs::fixctx(ctx, c);
+  runsection("makeResponse", [&](std::vector<Value>& args) -> Value {
+    CtxPtr ctx = res::omni_ctx(arg0(args), c, utility);
 
     utility->makeResponse(ctx);
 
-    Value entryCtx = Helpers::toMapAny(getp(entry, "ctx"));
-    if (entryCtx.is_map() && ctx->result) {
-      map_put(entryCtx, "result", fhMap({
-          {"ok", Value(ctx->result->ok)},
-          {"status", Value(ctx->result->status)},
-          {"statusText", Value(ctx->result->statusText)},
-          {"headers", ctx->result->headers},
-          {"body", ctx->result->body}}));
-    }
+    res::omni_sync_ctx(arg0(args), ctx);
     return Value::undef();
   });
 }
@@ -482,52 +537,47 @@ static void makeResultNoResult() {
 // --- makeSpec ---------------------------------------------------------------
 
 static void makeSpecBasic() {
-  Value setupOpts = rs::get_spec(primary(), {"makeSpec", "DEF", "setup", "a"});
+  // omni stamps ctx.client with PRESENCE, not identity, so a DEF-built
+  // client cannot be read back out of the ctx map: this section's
+  // specially-optioned client is constructed here (resolver decision 5).
+  Value setupOpts = rs::get_spec(primaryRun().spec, {"makeSpec", "DEF", "setup", "a"});
   auto specClient = ProjectNameSDK::testSDK(Value::undef(), setupOpts);
   UtilityPtr specUtility = specClient->getUtility();
 
-  rs::runset("makeSpec-basic", rs::get_spec(primary(), {"makeSpec", "basic"}),
-             [&](const Value& entry) -> Value {
-    Value ctxmap = Helpers::toMapAny(getp(entry, "ctx"));
-    CtxPtr ctx = rs::make_ctx_from_map(ctxmap, specClient, specUtility);
+  runsection("makeSpec", [&](std::vector<Value>& args) -> Value {
+    CtxPtr ctx = res::omni_ctx(arg0(args), specClient, specUtility);
     ctx->options = specClient->optionsMap();
 
     specUtility->makeSpec(ctx);
 
-    Value entryCtx = Helpers::toMapAny(getp(entry, "ctx"));
-    if (entryCtx.is_map() && ctx->spec) {
-      map_put(entryCtx, "spec", fhMap({
-          {"base", Value(ctx->spec->base)},
-          {"prefix", Value(ctx->spec->prefix)},
-          {"suffix", Value(ctx->spec->suffix)},
-          {"method", Value(ctx->spec->method)},
-          {"params", ctx->spec->params},
-          {"query", ctx->spec->query},
-          {"headers", ctx->spec->headers},
-          {"step", Value(ctx->spec->step)}}));
-    }
+    res::omni_sync_ctx(arg0(args), ctx);
     return Value::undef();
   });
 }
 
 // --- makePoint --------------------------------------------------------------
 
+// Corpus-driven, like ts and java. Each entry carries the WHOLE endpoint
+// lookup in its ctx — the API config, the entity it hangs off, the options
+// that gate the operation, and the match/reqmatch that select among several
+// points — which rs::make_ctx_from_map materialises (the entity cannot
+// travel as a plain map: Context resolves the op through Entity::getName).
+// Four of the seven entries assert a chosen point; three assert a REFUSAL
+// the retired stub could not reach at all, since it only ever asserted that
+// some point came back. TS returns the error AS the value while cpp throws
+// an SdkErrorPtr, so the error is normalised to a map carrying its code
+// rather than forking the fixture per language.
 static void makePointBasic() {
   auto c = client();
   UtilityPtr utility = c->getUtility();
-  CtxPtr ctx = makeTestCtx(c, utility);
-  Value point = fhMap({
-      {"parts", vlist({Value("items"), Value("{id}")})},
-      {"args", fhMap({{"params", vlist()}})},
-      {"params", vlist()},
-      {"alias", vmap()},
-      {"select", vmap()},
-      {"active", Value(true)},
-      {"transform", vmap()}});
-  ctx->op->points = std::vector<Value>{point};
-
-  utility->makePoint(ctx);
-  ASSERT_TRUE(ctx->point.is_map(), "expected point to be set");
+  runsection("makePoint", [&](std::vector<Value>& args) -> Value {
+    CtxPtr ctx = res::omni_ctx(arg0(args), c, utility);
+    try {
+      return utility->makePoint(ctx);
+    } catch (const SdkErrorPtr& err) {
+      return fhMap({{"code", Value(err->code)}});
+    }
+  });
 }
 
 // --- makeUrl ----------------------------------------------------------------
@@ -535,10 +585,8 @@ static void makePointBasic() {
 static void makeUrlBasic() {
   auto c = client();
   UtilityPtr utility = c->getUtility();
-  rs::runset("makeUrl-basic", rs::get_spec(primary(), {"makeUrl", "basic"}),
-             [&](const Value& entry) -> Value {
-    Value ctxmap = Helpers::toMapAny(getp(entry, "ctx"));
-    CtxPtr ctx = rs::make_ctx_from_map(ctxmap, c, utility);
+  runsection("makeUrl", [&](std::vector<Value>& args) -> Value {
+    CtxPtr ctx = res::omni_ctx(arg0(args), c, utility);
     if (!ctx->result) ctx->result = std::make_shared<Result>(vmap());
     return Value(utility->makeUrl(ctx));
   });
@@ -547,9 +595,8 @@ static void makeUrlBasic() {
 // --- operator ---------------------------------------------------------------
 
 static void operatorBasic() {
-  rs::runset("operator-basic", rs::get_spec(primary(), {"operator", "basic"}),
-             [&](const Value& entry) -> Value {
-    Value in = Helpers::toMapAny(getp(entry, "in"));
+  runsection("operator", [&](std::vector<Value>& args) -> Value {
+    Value in = Helpers::toMapAny(arg0(args));
     Operation op(in.is_map() ? in : vmap());
     return fhMap({
         {"entity", Value(op.entity)},
@@ -564,34 +611,17 @@ static void operatorBasic() {
 static void paramBasic() {
   auto c = client();
   UtilityPtr utility = c->getUtility();
-  rs::runset("param-basic", rs::get_spec(primary(), {"param", "basic"}),
-             [&](const Value& entry) -> Value {
-    Value args = getp(entry, "args");
-    if (!args.is_list() || args.as_list()->size() < 2) return Value::undef();
+  runsection("param", [&](std::vector<Value>& args) -> Value {
+    if (args.size() < 2) return Value::undef();
 
-    Value ctxmap = Helpers::toMapAny(vs::getelem(args, Value(int64_t(0))));
+    Value ctxmap = Helpers::toMapAny(arg0(args));
     if (!ctxmap.is_map()) ctxmap = vmap();
-    CtxPtr ctx = rs::make_ctx_from_map(ctxmap, c, utility);
-    Value paramdef = vs::getelem(args, Value(int64_t(1)));
+    CtxPtr ctx = res::omni_ctx(ctxmap, c, utility);
+    Value paramdef = args[1];
 
     Value result = utility->param(ctx, paramdef);
 
-    // Copy spec alias back to entry ctx for matching.
-    Value matchSpec = Helpers::toMapAny(getp(entry, "match"));
-    if (matchSpec.is_map()) {
-      Value ctxMatch = Helpers::toMapAny(getp(matchSpec, "ctx"));
-      if (ctxMatch.is_map()) {
-        Value entryCtx = Helpers::toMapAny(getp(entry, "ctx"));
-        if (!entryCtx.is_map()) {
-          entryCtx = vmap();
-          map_put(entry, "ctx", entryCtx);
-        }
-        Value specMatch = Helpers::toMapAny(getp(ctxMatch, "spec"));
-        if (specMatch.is_map() && ctx->spec && getp(specMatch, "alias").is_map()) {
-          map_put(entryCtx, "spec", fhMap({{"alias", ctx->spec->alias}}));
-        }
-      }
-    }
+    res::omni_sync_ctx(arg0(args), ctx);
     return result;
   });
 }
@@ -599,22 +629,17 @@ static void paramBasic() {
 // --- prepareAuth ------------------------------------------------------------
 
 static void prepareAuthBasic() {
-  Value setupOpts = rs::get_spec(primary(), {"prepareAuth", "DEF", "setup", "a"});
+  // Constructed at the call site: see the note on makeSpec above.
+  Value setupOpts = rs::get_spec(primaryRun().spec, {"prepareAuth", "DEF", "setup", "a"});
   auto authClient = ProjectNameSDK::testSDK(Value::undef(), setupOpts);
   UtilityPtr authUtility = authClient->getUtility();
 
-  rs::runset("prepareAuth-basic", rs::get_spec(primary(), {"prepareAuth", "basic"}),
-             [&](const Value& entry) -> Value {
-    Value ctxmap = Helpers::toMapAny(getp(entry, "ctx"));
-    CtxPtr ctx = rs::make_ctx_from_map(ctxmap, authClient, authUtility);
-    rs::fixctx(ctx, authClient);
+  runsection("prepareAuth", [&](std::vector<Value>& args) -> Value {
+    CtxPtr ctx = res::omni_ctx(arg0(args), authClient, authUtility);
 
     authUtility->prepareAuth(ctx);
 
-    Value entryCtx = Helpers::toMapAny(getp(entry, "ctx"));
-    if (entryCtx.is_map() && ctx->spec) {
-      map_put(entryCtx, "spec", fhMap({{"headers", ctx->spec->headers}}));
-    }
+    res::omni_sync_ctx(arg0(args), ctx);
     return Value::undef();
   });
 }
@@ -624,11 +649,8 @@ static void prepareAuthBasic() {
 static void prepareBodyBasic() {
   auto c = client();
   UtilityPtr utility = c->getUtility();
-  rs::runset("prepareBody-basic", rs::get_spec(primary(), {"prepareBody", "basic"}),
-             [&](const Value& entry) -> Value {
-    Value ctxmap = Helpers::toMapAny(getp(entry, "ctx"));
-    CtxPtr ctx = rs::make_ctx_from_map(ctxmap, c, utility);
-    rs::fixctx(ctx, c);
+  runsection("prepareBody", [&](std::vector<Value>& args) -> Value {
+    CtxPtr ctx = res::omni_ctx(arg0(args), c, utility);
     return utility->prepareBody(ctx);
   });
 }
@@ -636,10 +658,8 @@ static void prepareBodyBasic() {
 static void prepareHeadersBasic() {
   auto c = client();
   UtilityPtr utility = c->getUtility();
-  rs::runset("prepareHeaders-basic", rs::get_spec(primary(), {"prepareHeaders", "basic"}),
-             [&](const Value& entry) -> Value {
-    Value ctxmap = Helpers::toMapAny(getp(entry, "ctx"));
-    CtxPtr ctx = rs::make_ctx_from_map(ctxmap, c, utility);
+  runsection("prepareHeaders", [&](std::vector<Value>& args) -> Value {
+    CtxPtr ctx = res::omni_ctx(arg0(args), c, utility);
     return utility->prepareHeaders(ctx);
   });
 }
@@ -647,21 +667,21 @@ static void prepareHeadersBasic() {
 static void prepareMethodBasic() {
   auto c = client();
   UtilityPtr utility = c->getUtility();
-  rs::runset("prepareMethod-basic", rs::get_spec(primary(), {"prepareMethod", "basic"}),
-             [&](const Value& entry) -> Value {
-    Value ctxmap = Helpers::toMapAny(getp(entry, "ctx"));
-    CtxPtr ctx = rs::make_ctx_from_map(ctxmap, c, utility);
-    return Value(utility->prepareMethod(ctx));
+  runsection("prepareMethod", [&](std::vector<Value>& args) -> Value {
+    CtxPtr ctx = res::omni_ctx(arg0(args), c, utility);
+    // An op the API does not define resolves NO method; ts answers
+    // undefined there and C++ answers "" — both are "no value" to the
+    // corpus (the go subject does the same).
+    std::string method = utility->prepareMethod(ctx);
+    return method.empty() ? Value::undef() : Value(method);
   });
 }
 
 static void prepareParamsBasic() {
   auto c = client();
   UtilityPtr utility = c->getUtility();
-  rs::runset("prepareParams-basic", rs::get_spec(primary(), {"prepareParams", "basic"}),
-             [&](const Value& entry) -> Value {
-    Value ctxmap = Helpers::toMapAny(getp(entry, "ctx"));
-    CtxPtr ctx = rs::make_ctx_from_map(ctxmap, c, utility);
+  runsection("prepareParams", [&](std::vector<Value>& args) -> Value {
+    CtxPtr ctx = res::omni_ctx(arg0(args), c, utility);
     return utility->prepareParams(ctx);
   });
 }
@@ -673,10 +693,8 @@ static void preparePathBasic() {
   // preparePath fixture shipped as an empty `set: []`).
   auto c = client();
   UtilityPtr utility = c->getUtility();
-  rs::runset("preparePath-basic", rs::get_spec(primary(), {"preparePath", "basic"}),
-             [&](const Value& entry) -> Value {
-    Value ctxmap = Helpers::toMapAny(getp(entry, "ctx"));
-    CtxPtr ctx = rs::make_ctx_from_map(ctxmap, c, utility);
+  runsection("preparePath", [&](std::vector<Value>& args) -> Value {
+    CtxPtr ctx = res::omni_ctx(arg0(args), c, utility);
     return Value(utility->preparePath(ctx));
   });
 }
@@ -686,10 +704,8 @@ static void preparePathBasic() {
 static void prepareQueryBasic() {
   auto c = client();
   UtilityPtr utility = c->getUtility();
-  rs::runset("prepareQuery-basic", rs::get_spec(primary(), {"prepareQuery", "basic"}),
-             [&](const Value& entry) -> Value {
-    Value ctxmap = Helpers::toMapAny(getp(entry, "ctx"));
-    CtxPtr ctx = rs::make_ctx_from_map(ctxmap, c, utility);
+  runsection("prepareQuery", [&](std::vector<Value>& args) -> Value {
+    CtxPtr ctx = res::omni_ctx(arg0(args), c, utility);
     return utility->prepareQuery(ctx);
   });
 }
@@ -699,11 +715,8 @@ static void prepareQueryBasic() {
 static void resultBasicBasic() {
   auto c = client();
   UtilityPtr utility = c->getUtility();
-  rs::runset("resultBasic-basic", rs::get_spec(primary(), {"resultBasic", "basic"}),
-             [&](const Value& entry) -> Value {
-    Value ctxmap = Helpers::toMapAny(getp(entry, "ctx"));
-    CtxPtr ctx = rs::make_ctx_from_map(ctxmap, c, utility);
-    rs::fixctx(ctx, c);
+  runsection("resultBasic", [&](std::vector<Value>& args) -> Value {
+    CtxPtr ctx = res::omni_ctx(arg0(args), c, utility);
 
     ResultPtr result = utility->resultBasic(ctx);
 
@@ -718,17 +731,12 @@ static void resultBasicBasic() {
 static void resultBodyBasic() {
   auto c = client();
   UtilityPtr utility = c->getUtility();
-  rs::runset("resultBody-basic", rs::get_spec(primary(), {"resultBody", "basic"}),
-             [&](const Value& entry) -> Value {
-    Value ctxmap = Helpers::toMapAny(getp(entry, "ctx"));
-    CtxPtr ctx = rs::make_ctx_from_map(ctxmap, c, utility);
+  runsection("resultBody", [&](std::vector<Value>& args) -> Value {
+    CtxPtr ctx = res::omni_ctx(arg0(args), c, utility);
 
     utility->resultBody(ctx);
 
-    Value entryCtx = Helpers::toMapAny(getp(entry, "ctx"));
-    if (entryCtx.is_map() && ctx->result) {
-      map_put(entryCtx, "result", fhMap({{"body", ctx->result->body}}));
-    }
+    res::omni_sync_ctx(arg0(args), ctx);
     return Value::undef();
   });
 }
@@ -736,17 +744,12 @@ static void resultBodyBasic() {
 static void resultHeadersBasic() {
   auto c = client();
   UtilityPtr utility = c->getUtility();
-  rs::runset("resultHeaders-basic", rs::get_spec(primary(), {"resultHeaders", "basic"}),
-             [&](const Value& entry) -> Value {
-    Value ctxmap = Helpers::toMapAny(getp(entry, "ctx"));
-    CtxPtr ctx = rs::make_ctx_from_map(ctxmap, c, utility);
+  runsection("resultHeaders", [&](std::vector<Value>& args) -> Value {
+    CtxPtr ctx = res::omni_ctx(arg0(args), c, utility);
 
     utility->resultHeaders(ctx);
 
-    Value entryCtx = Helpers::toMapAny(getp(entry, "ctx"));
-    if (entryCtx.is_map() && ctx->result) {
-      map_put(entryCtx, "result", fhMap({{"headers", ctx->result->headers}}));
-    }
+    res::omni_sync_ctx(arg0(args), ctx);
     return Value::undef();
   });
 }
@@ -756,18 +759,12 @@ static void resultHeadersBasic() {
 static void transformRequestBasic() {
   auto c = client();
   UtilityPtr utility = c->getUtility();
-  rs::runset("transformRequest-basic", rs::get_spec(primary(), {"transformRequest", "basic"}),
-             [&](const Value& entry) -> Value {
-    Value ctxmap = Helpers::toMapAny(getp(entry, "ctx"));
-    CtxPtr ctx = rs::make_ctx_from_map(ctxmap, c, utility);
+  runsection("transformRequest", [&](std::vector<Value>& args) -> Value {
+    CtxPtr ctx = res::omni_ctx(arg0(args), c, utility);
 
     Value result = utility->transformRequest(ctx);
 
-    Value entryCtx = Helpers::toMapAny(getp(entry, "ctx"));
-    if (entryCtx.is_map() && ctx->spec) {
-      Value specMap = Helpers::toMapAny(getp(entryCtx, "spec"));
-      if (specMap.is_map()) map_put(specMap, "step", Value(ctx->spec->step));
-    }
+    res::omni_sync_ctx(arg0(args), ctx);
     return result;
   });
 }
@@ -775,25 +772,84 @@ static void transformRequestBasic() {
 static void transformResponseBasic() {
   auto c = client();
   UtilityPtr utility = c->getUtility();
-  rs::runset("transformResponse-basic", rs::get_spec(primary(), {"transformResponse", "basic"}),
-             [&](const Value& entry) -> Value {
-    Value ctxmap = Helpers::toMapAny(getp(entry, "ctx"));
-    CtxPtr ctx = rs::make_ctx_from_map(ctxmap, c, utility);
+  runsection("transformResponse", [&](std::vector<Value>& args) -> Value {
+    CtxPtr ctx = res::omni_ctx(arg0(args), c, utility);
 
     Value result = utility->transformResponse(ctx);
 
-    Value entryCtx = Helpers::toMapAny(getp(entry, "ctx"));
-    if (entryCtx.is_map() && ctx->spec) {
-      Value specMap = Helpers::toMapAny(getp(entryCtx, "spec"));
-      if (specMap.is_map()) map_put(specMap, "step", Value(ctx->spec->step));
-    }
+    res::omni_sync_ctx(arg0(args), ctx);
     return result;
   });
 }
 
+// --- whole-corpus coverage --------------------------------------------------
+
+// Sections under `primary` that are NOT this SDK's pipeline surface, with the
+// reason each is exempt. `check` is omni's OWN runner fixture (it comes from
+// .sdk/test/struct/test.aon, which the corpus build merges into primary); no
+// port drives it from a primary suite.
+static const std::vector<std::string>& notThisSuite() {
+  static const std::vector<std::string> names = {"check"};
+  return names;
+}
+
+static std::string joinnames(const std::vector<std::string>& names) {
+  std::string out;
+  for (const auto& name : names) {
+    if (!out.empty()) out += ", ";
+    out += name;
+  }
+  return out;
+}
+
+// The guard the PER-SECTION one cannot be. runsection() only fires for a
+// section some test actually names, so a section no test names is invisible
+// to it: `clean` (4 entries) and `makePoint` (7) sat undriven behind
+// hand-written stubs while this binary reported "67 cases driven" — a number
+// that was the sum of the sections it happened to call, and so could not
+// tell full coverage from partial. Comparing the fixture against what was
+// actually driven is what makes that line evidence.
+static void corpusCoverage() {
+  Value spec = primaryRun().spec;
+  ASSERT_TRUE(spec.is_map(), "primary corpus did not resolve - no coverage to check");
+  if (!spec.is_map()) return;
+
+  std::vector<std::string> sections = Struct::keysof(spec);
+  ASSERT_TRUE(!sections.empty(), "primary corpus has NO sections - check ../.sdk/test/test.json");
+
+  std::vector<std::string> undriven;
+  std::vector<std::string> staleskip;
+
+  for (const auto& name : sections) {
+    Value section = Helpers::toMapAny(getp(spec, Value(name)));
+    Value basic = section.is_map() ? Helpers::toMapAny(getp(section, Value("basic"))) : Value::undef();
+    Value set = basic.is_map() ? getp(basic, Value("set")) : Value::undef();
+    bool hascases = set.is_list() && !set.as_list()->empty();
+
+    const auto& exempt = notThisSuite();
+    if (std::find(exempt.begin(), exempt.end(), name) != exempt.end()) {
+      // The exemption has to keep earning itself: a name that lost its cases
+      // (or was renamed away) no longer needs one, and a list nobody prunes
+      // is how the next hole gets excused.
+      if (!hascases) staleskip.push_back(name);
+      continue;
+    }
+
+    if (hascases && 0 == drivenSections().count(name)) undriven.push_back(name);
+  }
+
+  ASSERT_TRUE(undriven.empty(),
+              "primary corpus sections carry cases that NO test drives: " + joinnames(undriven) +
+                  " - add a runsection() call; until then the \"cases driven\" count is not coverage");
+  ASSERT_TRUE(staleskip.empty(),
+              "these names are exempt from the coverage check but no longer carry cases: " +
+                  joinnames(staleskip) + " - drop them from notThisSuite()");
+}
+
 int main() {
   T_RUN(exists);
   T_RUN(cleanBasic);
+  T_RUN(cleanCorpus);
   T_RUN(doneBasic);
   T_RUN(makeErrorBasic);
   T_RUN(makeErrorNoThrow);
@@ -829,5 +885,8 @@ int main() {
   T_RUN(resultHeadersBasic);
   T_RUN(transformRequestBasic);
   T_RUN(transformResponseBasic);
+  // LAST: it reads what every test above actually drove.
+  T_RUN(corpusCoverage);
+  std::cout << "primary corpus: " << res::cases() << " cases driven\n";
   return sdktest::summary("primary_utility_test");
 }