@voxgig/sdkgen 4.22.0 → 4.23.0

package/project/.sdk/tm/c/feature/test.c

@@ -30,20 +30,36 @@ static voxgig_value* envelope(Context* ctx, voxgig_value* data) {
   if (NULL == spec) {
     return data;
   }
-  // Exactly `body.<key>`; a deeper path is not an envelope this mock can
-  // synthesise, so it is left alone rather than guessed at.
+  // Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
+  // GraphQL ops unwrap `body.data.<field>` (and `body.data.<field>.<entity>`
+  // for mutation payloads), not just a single envelope property.
   size_t n = strlen(spec);
   if (n < 8 || 0 != strncmp(spec, "`body.", 6) || '`' != spec[n - 1]) {
     return data;
   }
   size_t inner_len = n - 7;
-  if (0 == inner_len || NULL != memchr(spec + 6, '.', inner_len)) {
+  if (0 == inner_len) {
     return data;
   }
   char* inner = (char*)malloc(inner_len + 1);
   memcpy(inner, spec + 6, inner_len);
   inner[inner_len] = '\0';
-  voxgig_value* out = cmap(1, inner, data);
+  // Innermost segment first, so walk back from the end, terminating each
+  // segment in place as it is consumed. cmap copies the key.
+  voxgig_value* out = data;
+  size_t pos = inner_len;
+  while (1) {
+    size_t start = pos;
+    while (start > 0 && '.' != inner[start - 1]) {
+      start--;
+    }
+    inner[pos] = '\0';
+    out = cmap(1, inner + start, out);
+    if (0 == start) {
+      break;
+    }
+    pos = start - 1;
+  }
   free(inner);
   return out;
 }

package/project/.sdk/tm/clojure/src/sdk/features.clj

@@ -124,11 +124,13 @@
                        (let [envelope (fn [data]
                                         (let [tm (vs/getprop (core/oget fctx :point) "transform")
                                               spec (vs/getprop tm "res")]
-                                          ;; Exactly `body.<key>`; a deeper path is not an
-                                          ;; envelope this mock can synthesise.
+                                          ;; Rebuild whatever nesting the transform unwraps;
+                                          ;; GraphQL ops unwrap `body.data.<field>`.
                                           (if (and (some? data) (string? spec))
-                                            (if-let [m (re-matches #"`body\.([^`.]+)`" spec)]
-                                              (vs/jm (second m) data)
+                                            (if-let [m (re-matches #"`body\.(.+)`" spec)]
+                                              (reduce (fn [out seg] (vs/jm seg out))
+                                                      data
+                                                      (reverse (str/split (second m) #"\." -1)))
                                               data)
                                             data)))
                              respond (fn [status data extra]

package/project/.sdk/tm/cpp/feature/test.hpp

@@ -68,16 +68,27 @@ private:
     Value restf = getp(tm, "res");
     if (!restf.is_string()) return data;
     std::string spec = restf.as_string();
-    // Exactly `body.<key>`; a deeper path is not an envelope this mock can
-    // synthesise, so it is left alone rather than guessed at.
+    // Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
+    // GraphQL ops unwrap `body.data.<field>`, not just one envelope property.
     if (spec.size() < 8) return data;
     if (0 != spec.compare(0, 6, "`body.")) return data;
     if ('`' != spec[spec.size() - 1]) return data;
     std::string inner = spec.substr(6, spec.size() - 7);
-    if (inner.empty() || std::string::npos != inner.find('.')) return data;
-    Value wrapped = vmap();
-    map_put(wrapped, inner, data);
-    return wrapped;
+    if (inner.empty()) return data;
+    std::vector<std::string> segs;
+    for (size_t at = 0;;) {
+      size_t dot = inner.find('.', at);
+      if (std::string::npos == dot) { segs.push_back(inner.substr(at)); break; }
+      segs.push_back(inner.substr(at, dot - at));
+      at = dot + 1;
+    }
+    Value out = data;
+    for (size_t i = segs.size(); i > 0; i--) {
+      Value wrapped = vmap();
+      map_put(wrapped, segs[i - 1], out);
+      out = wrapped;
+    }
+    return out;
   }
 
   Value respond(CtxPtr ctx, int status, const Value& data, const Value& extra) {

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

@@ -59,15 +59,21 @@ public class TestFeature : BaseFeature
                 if (data == null || ctx2.Point == null) { return data; }
                 var tm = StructUtils.GetProp(ctx2.Point, "transform");
                 if (StructUtils.GetProp(tm, "res") is not string spec) { return data; }
-                // Exactly `body.<key>`; a deeper path is not an envelope this
-                // mock can synthesise, so it is left alone.
+                // Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
+                // GraphQL ops unwrap `body.data.<field>`, not just one envelope property.
                 if (!spec.StartsWith("`body.") || !spec.EndsWith("`") || spec.Length < 8)
                 {
                     return data;
                 }
                 var inner = spec.Substring(6, spec.Length - 7);
-                if (inner.Length == 0 || inner.Contains('.')) { return data; }
-                return new Dictionary<string, object?> { [inner] = data };
+                if (inner.Length == 0) { return data; }
+                var segs = inner.Split('.');
+                object? built = data;
+                for (var i = segs.Length - 1; 0 <= i; i--)
+                {
+                    built = new Dictionary<string, object?> { [segs[i]] = built };
+                }
+                return built;
             }
 
             Dictionary<string, object?> Respond(int status, object? data,

package/project/.sdk/tm/elixir/lib/projectname/feature/test.ex

@@ -55,16 +55,22 @@ defmodule ProjectName.Feature.Test do
   defp envelope(fctx, data) do
     spec = S.getprop(S.getprop(S.getprop(fctx, "point"), "transform"), "res")
 
-    # Exactly `body.<key>`; a deeper path is not an envelope this mock can
-    # synthesise, so it is left alone rather than guessed at.
+    # Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
+    # GraphQL ops unwrap `body.data.<field>`, not just one envelope property.
     case {data, spec} do
       {nil, _} ->
         data
 
       {_, s} when is_binary(s) ->
-        case Regex.run(~r/^`body\.([^`.]+)`$/, s) do
-          [_, inner] -> S.jm([inner, data])
-          _ -> data
+        case Regex.run(~r/^`body\.(.+)`$/, s) do
+          [_, inner] ->
+            inner
+            |> String.split(".")
+            |> Enum.reverse()
+            |> Enum.reduce(data, fn seg, out -> S.jm([seg, out]) end)
+
+          _ ->
+            data
         end
 
       _ ->

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

@@ -109,18 +109,23 @@ public class TestFeature extends BaseFeature {
       return data;
     }
     String spec = (String) restf;
-    // Exactly `body.<key>`; a deeper path is not an envelope this mock can
-    // synthesise, so it is left alone rather than guessed at.
+    // Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
+    // GraphQL ops unwrap `body.data.<field>`, not just one envelope property.
     if (!spec.startsWith("`body.") || !spec.endsWith("`") || spec.length() < 8) {
       return data;
     }
     String inner = spec.substring(6, spec.length() - 1);
-    if (inner.isEmpty() || inner.contains(".")) {
+    if (inner.isEmpty()) {
       return data;
     }
-    Map<String, Object> wrapped = new LinkedHashMap<>();
-    wrapped.put(inner, data);
-    return wrapped;
+    String[] segs = inner.split("\\.", -1);
+    Object out = data;
+    for (int i = segs.length - 1; 0 <= i; i--) {
+      Map<String, Object> wrapped = new LinkedHashMap<>();
+      wrapped.put(segs[i], out);
+      out = wrapped;
+    }
+    return out;
   }
 
   private Map<String, Object> respond(Context ctx, int status, Object data, Map<String, Object> extra) {

package/project/.sdk/tm/js/test/live-entity.js

@@ -10,26 +10,26 @@ const live_runner_1 = require("./live-runner");
 const utility_1 = require("./utility");
 // The offline flow keeps its deterministic fixture assertions. Live flows
 // resolve real prerequisites per operation and collect failures until done.
-async function runLiveEntity(setup, entity, flow, accessor) {
+async function runLiveEntity(setup, entity, flow, accessor, facts = {}) {
     const { client, transport } = setup;
-    const steps = flow.step || [];
+    const steps = (flow.step || []).filter((step) => false !== step.a);
     const created = new Map();
     const listed = [];
     const marks = new Map();
     const idField = entity.id?.field || 'id';
     const copy = (value) => JSON.parse(JSON.stringify(value ?? {}));
-    const hasCreate = steps.some(step => step.op === 'create');
+    const hasCreate = steps.some(step => step.o === 'create');
     const report = await (0, live_runner_1.runLiveSteps)(steps.map((step, index) => {
-        const ref = step.input?.ref || entity.name + '_ref01';
-        const op = step.op;
+        const ref = step.i?.ref || entity.name + '_ref01';
+        const op = step.o;
         const excluded = (0, utility_1.isControlSkipped)('entityOp', entity.name + '.' + op, 'live');
         return {
             id: entity.name + '.' + op + '.' + index,
-            cleanup: op === 'remove' || (step.valid || []).some((v) => v.apply === 'ItemNotExists'),
+            cleanup: op === 'remove' || (step.v || []).some((v) => v.apply === 'ItemNotExists'),
             excluded: excluded.skip ? excluded.reason || 'Excluded by test control' : undefined,
             run: async (context) => {
                 transport.enter(context);
-                const points = entity.op?.[op]?.points || [];
+                const points = (entity.op?.[op]?.points || []).filter((point) => false !== point.a);
                 if (!points.length)
                     throw new live_runner_1.LiveBlocked('No modelled operation point');
                 const record = created.get(ref);
@@ -48,7 +48,7 @@ async function runLiveEntity(setup, entity, flow, accessor) {
                 }
                 let input = op === 'create'
                     ? copy(setup.data.new?.[entity.name]?.[ref]) : {};
-                for (const [name, binding] of Object.entries({ ...step.match, ...step.data })) {
+                for (const [name, binding] of Object.entries({ ...step.m, ...step.d })) {
                     const value = setup.idmap[binding] ?? setup.idmap[name];
                     if (undefined !== value)
                         input[name] = value;
@@ -66,22 +66,22 @@ async function runLiveEntity(setup, entity, flow, accessor) {
                 let selected;
                 const missing = new Set();
                 for (const point of points) {
-                    if (point.select?.$action !== input.$action)
+                    if (point.q?.$action !== input.$action)
                         continue;
                     const candidate = { ...input };
                     let viable = true;
-                    const params = point.args?.params || [];
-                    const query = (point.args?.query || []).filter((arg) => arg.reqd);
+                    const params = point.g?.params || [];
+                    const query = (point.g?.query || []).filter((arg) => arg.r);
                     for (const arg of [...params, ...query]) {
-                        if (undefined !== candidate[arg.name] && null !== candidate[arg.name])
+                        if (undefined !== candidate[arg.n] && null !== candidate[arg.n])
                             continue;
-                        const key = arg.name === 'id' ? entity.name + '01' : arg.name.replace(/_id$/, '') + '01';
-                        const value = setup.idmap[key] ?? setup.idmap[arg.name] ?? loaded?.[arg.name] ?? arg.example;
+                        const key = arg.n === 'id' ? entity.name + '01' : arg.n.replace(/_id$/, '') + '01';
+                        const value = setup.idmap[key] ?? setup.idmap[arg.n] ?? loaded?.[arg.n] ?? arg.ex;
                         if (undefined !== value && null !== value)
-                            candidate[arg.name] = value;
-                        else if (arg.reqd !== false) {
+                            candidate[arg.n] = value;
+                        else if (arg.r !== false) {
                             viable = false;
-                            missing.add(arg.name);
+                            missing.add(arg.n);
                         }
                     }
                     if (viable) {
@@ -93,22 +93,22 @@ async function runLiveEntity(setup, entity, flow, accessor) {
                 if (!resolved)
                     throw new live_runner_1.LiveBlocked('No usable route; missing arguments: ' + [...missing].join(', '));
                 input = resolved;
-                if (op === 'create' && selected.contract) {
-                    const facts = JSON.parse(selected.contract.json);
-                    const request = (0, live_contract_1.requestContract)(facts);
+                if (op === 'create' && facts[selected.m + ' ' + selected.o]) {
+                    const selectedFacts = facts[selected.m + ' ' + selected.o];
+                    const request = (0, live_contract_1.requestContract)(selectedFacts);
                     if (request.schema)
-                        input = { ...(0, live_contract_1.synthesizeInput)(request.schema, facts.live?.input ?? request.example) };
-                    else if (facts.protocol === 'http')
+                        input = { ...(0, live_contract_1.synthesizeInput)(request.schema, selected.li?.input ?? request.example) };
+                    else if (selectedFacts.protocol === 'http')
                         input = {};
-                    for (const arg of selected.args?.params || [])
-                        if (resolved[arg.name] !== undefined)
-                            input[arg.name] = resolved[arg.name];
+                    for (const arg of selected.g?.params || [])
+                        if (resolved[arg.n] !== undefined)
+                            input[arg.n] = resolved[arg.n];
                 }
                 let intendedMark;
                 if (op === 'update') {
-                    for (const spec of step.spec || []) {
-                        if (spec.apply === 'TextFieldMark' && step.input?.textfield) {
-                            const mark = { name: step.input.textfield, value: spec.def.mark + '_' + setup.now };
+                    for (const spec of step.s || []) {
+                        if (spec.apply === 'TextFieldMark' && step.i?.textfield) {
+                            const mark = { name: step.i.textfield, value: spec.def.mark + '_' + setup.now };
                             input[mark.name] = mark.value;
                             intendedMark = mark;
                         }
@@ -127,7 +127,7 @@ async function runLiveEntity(setup, entity, flow, accessor) {
                     });
                     listed.splice(0, listed.length, ...data);
                     context.publish(data);
-                    for (const validation of step.valid || []) {
+                    for (const validation of step.v || []) {
                         const previous = created.get(validation.def?.ref);
                         const id = previous?.[idField] ?? previous?.id;
                         if (undefined === id)

package/project/.sdk/tm/js/test/live-scenarios.js

@@ -64,10 +64,10 @@ async function runLiveScenarios(SDK, plan, envPrefix, liveDefaults = {}) {
                 let input = request.schema ? (0, live_contract_1.synthesizeInput)(request.schema, explicit) : explicit ?? {};
                 for (const kind of ['params', 'query', 'header', 'cookie'])
                     for (const arg of point.args?.[kind] || []) {
-                        if (arg.reqd && input[arg.name] === undefined) {
-                            if (arg.example === undefined)
-                                throw new live_runner_1.LiveBlocked('Missing required argument: ' + arg.name);
-                            input[arg.name] = arg.example;
+                        if (arg.r && input[arg.n] === undefined) {
+                            if (arg.ex === undefined)
+                                throw new live_runner_1.LiveBlocked('Missing required argument: ' + arg.n);
+                            input[arg.n] = arg.ex;
                         }
                     }
                 const role = hint.auth || (point.facts.security?.length === 0 || point.facts.securitySource === 'unspecified' ? 'public' : 'account');

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

@@ -63,12 +63,16 @@ class TestFeature : BaseFeature("test", "0.0.1", true) {
     if (null == data || null == ctx) return data
     val tm = Struct.getprop(ctx.point, "transform")
     val restf = Struct.getprop(tm, "res") as? String ?: return data
-    // Exactly `body.<key>`; a deeper path is not an envelope this mock can
-    // synthesise, so it is left alone rather than guessed at.
+    // Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
+    // GraphQL ops unwrap `body.data.<field>`, not just one envelope property.
     if (!restf.startsWith("`body.") || !restf.endsWith("`") || restf.length < 8) return data
     val inner = restf.substring(6, restf.length - 1)
-    if (inner.isEmpty() || inner.contains(".")) return data
-    return linkedMapOf<String, Any?>(inner to data)
+    if (inner.isEmpty()) return data
+    var out: Any? = data
+    for (seg in inner.split(".").reversed()) {
+      out = linkedMapOf<String, Any?>(seg to out)
+    }
+    return out
   }
 
   private fun respond(ctx: Context?, status: Int, data: Any?, extra: MutableMap<String, Any?>?): MutableMap<String, Any?> {

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

@@ -1394,12 +1394,14 @@ let test_feature () : feature =
       match getp (getp ctx.c_point "transform") "res" with
       | Str spec ->
         let n = String.length spec in
-        (* Exactly `body.<key>`; a deeper path is not an envelope this mock
-           can synthesise, so it is left alone rather than guessed at. *)
+        (* Rebuild whatever nesting the transform unwraps. Multi-segment on
+           purpose: GraphQL ops unwrap `body.data.<field>`. *)
         if n > 7 && String.sub spec 0 6 = "`body." && spec.[n - 1] = '`' then
           let inner = String.sub spec 6 (n - 7) in
-          if String.length inner = 0 || String.contains inner '.' then data
-          else jo [(inner, data)]
+          if String.length inner = 0 then data
+          else
+            List.fold_left (fun out seg -> jo [(seg, out)]) data
+              (List.rev (String.split_on_char '.' inner))
         else data
       | _ -> data in
   let respond ctx status data extra =

package/project/.sdk/tm/perl/feature/test_feature.pm

@@ -66,10 +66,12 @@ sub init {
     my $tm = ProjectNameHelpers::gp($fctx->{point}, 'transform');
     my $spec = ProjectNameHelpers::gp($tm, 'res');
     return $data unless defined $spec && !ref($spec);
-    # Exactly `body.<key>`; a deeper path is not an envelope this mock can
-    # synthesise, so it is left alone rather than guessed at.
-    return $data unless $spec =~ /^`body\.([^`.]+)`$/;
-    return { $1 => $data };
+    # Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
+    # GraphQL ops unwrap `body.data.<field>`, not just one envelope property.
+    return $data unless $spec =~ /^`body\.(.+)`$/;
+    my $out = $data;
+    $out = { $_ => $out } for reverse split /\./, $1, -1;
+    return $out;
   };
 
   my $respond = sub {

package/project/.sdk/tm/rb/feature/test_feature.rb

@@ -4,9 +4,10 @@ require_relative '../utility/struct/voxgig_struct'
 require_relative 'base_feature'
 
 class ProjectNameTestFeature < ProjectNameBaseFeature
-  # The `body.<key>` form of an op's response transform: the mock wraps its
-  # payload in <key> so the transform can unwrap it again.
-  ENVELOPE_RES_RE = /\A`body\.([^`.]+)`\z/
+  # The `body.<path>` form of an op's response transform: the mock rebuilds
+  # whatever nesting the transform unwraps. Multi-segment on purpose: GraphQL
+  # ops unwrap body.data.<field>, not just one level.
+  ENVELOPE_RES_RE = /\A`body\.(.+)`\z/
 
   def initialize
     super
@@ -52,7 +53,8 @@ class ProjectNameTestFeature < ProjectNameBaseFeature
         restf = transform["res"]
         next data unless restf.is_a?(String)
         m = ENVELOPE_RES_RE.match(restf)
-        m.nil? ? data : { m[1] => data }
+        next data if m.nil?
+        m[1].split('.', -1).reverse.reduce(data) { |out, seg| { seg => out } }
       }
 
       respond = ->(status, data, extra) {

package/project/.sdk/tm/rust/feature/test.rs

@@ -34,11 +34,15 @@ fn envelope(ctx: &Rc<Context>, data: Value) -> Value {
     }
     let restf = crate::core::helpers::getpath(&["transform", "res"], &ctx.point.borrow());
     if let Value::Str(spec) = restf {
-        // Exactly `body.<key>` — a deeper path is not an envelope this mock
-        // can synthesise, so it is left alone rather than guessed at.
+        // Rebuild whatever nesting the transform unwraps: a GraphQL op unwraps
+        // `body.data.<field>`, not just one envelope property.
         if let Some(inner) = spec.strip_prefix("`body.").and_then(|r| r.strip_suffix('`')) {
-            if !inner.is_empty() && !inner.contains('.') {
-                return jo(vec![(inner, data)]);
+            if !inner.is_empty() {
+                let mut out = data;
+                for seg in inner.split('.').rev() {
+                    out = jo(vec![(seg, out)]);
+                }
+                return out;
             }
         }
     }

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

@@ -50,14 +50,18 @@ class TestFeature extends BaseFeature("test", "0.0.1", true) {
     val tm = Struct.getprop(ctx.point, "transform")
     Struct.getprop(tm, "res") match {
       case spec: String =>
-        // Exactly `body.<key>`; a deeper path is not an envelope this mock
-        // can synthesise, so it is left alone rather than guessed at.
+        // Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
+        // GraphQL ops unwrap `body.data.<field>`, not just one envelope property.
         if (!spec.startsWith("`body.") || !spec.endsWith("`") || spec.length < 8) return data
         val inner = spec.substring(6, spec.length - 1)
-        if (inner.isEmpty || inner.contains(".")) return data
-        val wrapped = new java.util.LinkedHashMap[String, Object]()
-        wrapped.put(inner, data)
-        wrapped
+        if (inner.isEmpty) return data
+        var out: Object = data
+        for (seg <- inner.split("\\.", -1).reverse) {
+          val wrapped = new java.util.LinkedHashMap[String, Object]()
+          wrapped.put(seg, out)
+          out = wrapped
+        }
+        out
       case _ => data
     }
   }

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

@@ -16,14 +16,18 @@ private func testEnvelope(_ ctx: Context, _ data: Value) -> Value {
   guard let point = ctx.point else { return data }
   guard case .map(let tm)? = point.entries["transform"] else { return data }
   guard case .string(let spec)? = tm.entries["res"] else { return data }
-  // Exactly `body.<key>`; a deeper path is not an envelope this mock can
-  // synthesise, so it is left alone rather than guessed at.
+  // Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
+  // GraphQL ops unwrap `body.data.<field>`, not just one envelope property.
   guard spec.hasPrefix("`body."), spec.hasSuffix("`"), spec.count >= 8 else { return data }
   let inner = String(spec.dropFirst(6).dropLast(1))
-  guard !inner.isEmpty, !inner.contains(".") else { return data }
-  let wrapped = VMap()
-  wrapped.entries[inner] = data
-  return .map(wrapped)
+  guard !inner.isEmpty else { return data }
+  var out = data
+  for seg in inner.split(separator: ".", omittingEmptySubsequences: false).reversed() {
+    let wrapped = VMap()
+    wrapped.entries[String(seg)] = out
+    out = .map(wrapped)
+  }
+  return out
 }
 
 private func testRespond(_ ctx: Context, _ status: Int, _ data: Value, _ extra: VMap?) -> Value {

package/project/.sdk/tm/ts/test/live-entity.ts

@@ -5,26 +5,26 @@ import { isControlSkipped, liveDelayMs } from './utility'
 
 // The offline flow keeps its deterministic fixture assertions. Live flows
 // resolve real prerequisites per operation and collect failures until done.
-async function runLiveEntity(setup: any, entity: any, flow: any, accessor: string) {
+async function runLiveEntity(setup: any, entity: any, flow: any, accessor: string, facts: any = {}) {
   const { client, transport } = setup
-  const steps: any[] = flow.step || []
+  const steps: any[] = (flow.step || []).filter((step: any) => false !== step.a)
   const created = new Map<string, any>()
   const listed: any[] = []
   const marks = new Map<string, { name: string, value: any }>()
   const idField = entity.id?.field || 'id'
   const copy = (value: any) => JSON.parse(JSON.stringify(value ?? {}))
-  const hasCreate = steps.some(step => step.op === 'create')
+  const hasCreate = steps.some(step => step.o === 'create')
   const report = await runLiveSteps(steps.map((step, index) => {
-    const ref = step.input?.ref || entity.name + '_ref01'
-    const op = step.op
+    const ref = step.i?.ref || entity.name + '_ref01'
+    const op = step.o
     const excluded = isControlSkipped('entityOp', entity.name + '.' + op, 'live')
     return {
       id: entity.name + '.' + op + '.' + index,
-      cleanup: op === 'remove' || (step.valid || []).some((v: any) => v.apply === 'ItemNotExists'),
+      cleanup: op === 'remove' || (step.v || []).some((v: any) => v.apply === 'ItemNotExists'),
       excluded: excluded.skip ? excluded.reason || 'Excluded by test control' : undefined,
       run: async (context: any) => {
         transport.enter(context)
-        const points = entity.op?.[op]?.points || []
+        const points = (entity.op?.[op]?.points || []).filter((point: any) => false !== point.a)
         if (!points.length) throw new LiveBlocked('No modelled operation point')
         const record = created.get(ref)
         // A failed create must not turn a later update/remove into a write
@@ -41,7 +41,7 @@ async function runLiveEntity(setup: any, entity: any, flow: any, accessor: strin
 
         let input: any = op === 'create'
           ? copy(setup.data.new?.[entity.name]?.[ref]) : {}
-        for (const [name, binding] of Object.entries({ ...step.match, ...step.data })) {
+        for (const [name, binding] of Object.entries({ ...step.m, ...step.d })) {
           const value = setup.idmap[binding as string] ?? setup.idmap[name]
           if (undefined !== value) input[name] = value
         }
@@ -57,34 +57,34 @@ async function runLiveEntity(setup: any, entity: any, flow: any, accessor: strin
         let selected: any
         const missing = new Set<string>()
         for (const point of points) {
-          if (point.select?.$action !== input.$action) continue
+          if (point.q?.$action !== input.$action) continue
           const candidate = { ...input }
           let viable = true
-          const params = point.args?.params || []
-          const query = (point.args?.query || []).filter((arg: any) => arg.reqd)
+          const params = point.g?.params || []
+          const query = (point.g?.query || []).filter((arg: any) => arg.r)
           for (const arg of [...params, ...query]) {
-            if (undefined !== candidate[arg.name] && null !== candidate[arg.name]) continue
-            const key = arg.name === 'id' ? entity.name + '01' : arg.name.replace(/_id$/, '') + '01'
-            const value = setup.idmap[key] ?? setup.idmap[arg.name] ?? loaded?.[arg.name] ?? arg.example
-            if (undefined !== value && null !== value) candidate[arg.name] = value
-            else if (arg.reqd !== false) { viable = false; missing.add(arg.name) }
+            if (undefined !== candidate[arg.n] && null !== candidate[arg.n]) continue
+            const key = arg.n === 'id' ? entity.name + '01' : arg.n.replace(/_id$/, '') + '01'
+            const value = setup.idmap[key] ?? setup.idmap[arg.n] ?? loaded?.[arg.n] ?? arg.ex
+            if (undefined !== value && null !== value) candidate[arg.n] = value
+            else if (arg.r !== false) { viable = false; missing.add(arg.n) }
           }
           if (viable) { resolved = candidate; selected = point; break }
         }
         if (!resolved) throw new LiveBlocked('No usable route; missing arguments: ' + [...missing].join(', '))
         input = resolved
-        if (op === 'create' && selected.contract) {
-          const facts = JSON.parse(selected.contract.json)
-          const request = requestContract(facts)
-          if (request.schema) input = { ...synthesizeInput(request.schema, facts.live?.input ?? request.example) }
-          else if (facts.protocol === 'http') input = {}
-          for (const arg of selected.args?.params || []) if (resolved[arg.name] !== undefined) input[arg.name] = resolved[arg.name]
+        if (op === 'create' && facts[selected.m + ' ' + selected.o]) {
+          const selectedFacts = facts[selected.m + ' ' + selected.o]
+          const request = requestContract(selectedFacts)
+          if (request.schema) input = { ...synthesizeInput(request.schema, selected.li?.input ?? request.example) }
+          else if (selectedFacts.protocol === 'http') input = {}
+          for (const arg of selected.g?.params || []) if (resolved[arg.n] !== undefined) input[arg.n] = resolved[arg.n]
         }
         let intendedMark: { name: string, value: any } | undefined
         if (op === 'update') {
-          for (const spec of step.spec || []) {
-            if (spec.apply === 'TextFieldMark' && step.input?.textfield) {
-              const mark = { name: step.input.textfield, value: spec.def.mark + '_' + setup.now }
+          for (const spec of step.s || []) {
+            if (spec.apply === 'TextFieldMark' && step.i?.textfield) {
+              const mark = { name: step.i.textfield, value: spec.def.mark + '_' + setup.now }
               input[mark.name] = mark.value
               intendedMark = mark
             }
@@ -103,7 +103,7 @@ async function runLiveEntity(setup: any, entity: any, flow: any, accessor: strin
           })
           listed.splice(0, listed.length, ...data)
           context.publish(data)
-          for (const validation of step.valid || []) {
+          for (const validation of step.v || []) {
             const previous = created.get(validation.def?.ref)
             const id = previous?.[idField] ?? previous?.id
             if (undefined === id) continue

package/project/.sdk/tm/ts/test/live-scenarios.ts

@@ -52,9 +52,9 @@ export async function runLiveScenarios(SDK: any, plan: any[], envPrefix: string,
         const explicit = hint.input === undefined ? request.example : resolveRecipe(hint.input, ctx.values)
         let input = request.schema ? synthesizeInput(request.schema, explicit) : explicit ?? {}
         for (const kind of ['params', 'query', 'header', 'cookie']) for (const arg of point.args?.[kind] || []) {
-          if (arg.reqd && input[arg.name] === undefined) {
-            if (arg.example === undefined) throw new LiveBlocked('Missing required argument: ' + arg.name)
-            input[arg.name] = arg.example
+          if (arg.r && input[arg.n] === undefined) {
+            if (arg.ex === undefined) throw new LiveBlocked('Missing required argument: ' + arg.n)
+            input[arg.n] = arg.ex
           }
         }
         const role = hint.auth || (point.facts.security?.length === 0 || point.facts.securitySource === 'unspecified' ? 'public' : 'account')