@schwabyio/gta 0.9.0 → 0.11.0

package/dist/chunks/{chunk-VRAFYQNE.js → chunk-OM3ZR56O.js}

@@ -118,17 +118,17 @@ var require_visit = __commonJS({
     visit2.BREAK = BREAK;
     visit2.SKIP = SKIP;
     visit2.REMOVE = REMOVE;
-    function visit_(key, node2, visitor, path12) {
-      const ctrl = callVisitor(key, node2, visitor, path12);
+    function visit_(key, node2, visitor, path11) {
+      const ctrl = callVisitor(key, node2, visitor, path11);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path12, ctrl);
-        return visit_(key, ctrl, visitor, path12);
+        replaceNode(key, path11, ctrl);
+        return visit_(key, ctrl, visitor, path11);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node2)) {
-          path12 = Object.freeze(path12.concat(node2));
+          path11 = Object.freeze(path11.concat(node2));
           for (let i = 0; i < node2.items.length; ++i) {
-            const ci = visit_(i, node2.items[i], visitor, path12);
+            const ci = visit_(i, node2.items[i], visitor, path11);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -139,13 +139,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node2)) {
-          path12 = Object.freeze(path12.concat(node2));
-          const ck = visit_("key", node2.key, visitor, path12);
+          path11 = Object.freeze(path11.concat(node2));
+          const ck = visit_("key", node2.key, visitor, path11);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node2.key = null;
-          const cv = visit_("value", node2.value, visitor, path12);
+          const cv = visit_("value", node2.value, visitor, path11);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -166,17 +166,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node2, visitor, path12) {
-      const ctrl = await callVisitor(key, node2, visitor, path12);
+    async function visitAsync_(key, node2, visitor, path11) {
+      const ctrl = await callVisitor(key, node2, visitor, path11);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path12, ctrl);
-        return visitAsync_(key, ctrl, visitor, path12);
+        replaceNode(key, path11, ctrl);
+        return visitAsync_(key, ctrl, visitor, path11);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node2)) {
-          path12 = Object.freeze(path12.concat(node2));
+          path11 = Object.freeze(path11.concat(node2));
           for (let i = 0; i < node2.items.length; ++i) {
-            const ci = await visitAsync_(i, node2.items[i], visitor, path12);
+            const ci = await visitAsync_(i, node2.items[i], visitor, path11);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -187,13 +187,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node2)) {
-          path12 = Object.freeze(path12.concat(node2));
-          const ck = await visitAsync_("key", node2.key, visitor, path12);
+          path11 = Object.freeze(path11.concat(node2));
+          const ck = await visitAsync_("key", node2.key, visitor, path11);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node2.key = null;
-          const cv = await visitAsync_("value", node2.value, visitor, path12);
+          const cv = await visitAsync_("value", node2.value, visitor, path11);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -220,23 +220,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node2, visitor, path12) {
+    function callVisitor(key, node2, visitor, path11) {
       if (typeof visitor === "function")
-        return visitor(key, node2, path12);
+        return visitor(key, node2, path11);
       if (identity.isMap(node2))
-        return visitor.Map?.(key, node2, path12);
+        return visitor.Map?.(key, node2, path11);
       if (identity.isSeq(node2))
-        return visitor.Seq?.(key, node2, path12);
+        return visitor.Seq?.(key, node2, path11);
       if (identity.isPair(node2))
-        return visitor.Pair?.(key, node2, path12);
+        return visitor.Pair?.(key, node2, path11);
       if (identity.isScalar(node2))
-        return visitor.Scalar?.(key, node2, path12);
+        return visitor.Scalar?.(key, node2, path11);
       if (identity.isAlias(node2))
-        return visitor.Alias?.(key, node2, path12);
+        return visitor.Alias?.(key, node2, path11);
       return void 0;
     }
-    function replaceNode(key, path12, node2) {
-      const parent = path12[path12.length - 1];
+    function replaceNode(key, path11, node2) {
+      const parent = path11[path11.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node2;
       } else if (identity.isPair(parent)) {
@@ -848,10 +848,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path12, value) {
+    function collectionFromPath(schema, path11, value) {
       let v = value;
-      for (let i = path12.length - 1; i >= 0; --i) {
-        const k = path12[i];
+      for (let i = path11.length - 1; i >= 0; --i) {
+        const k = path11[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a = [];
           a[k] = v;
@@ -870,7 +870,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path12) => path12 == null || typeof path12 === "object" && !!path12[Symbol.iterator]().next().done;
+    var isEmptyPath = (path11) => path11 == null || typeof path11 === "object" && !!path11[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -900,11 +900,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path12, value) {
-        if (isEmptyPath(path12))
+      addIn(path11, value) {
+        if (isEmptyPath(path11))
           this.add(value);
         else {
-          const [key, ...rest] = path12;
+          const [key, ...rest] = path11;
           const node2 = this.get(key, true);
           if (identity.isCollection(node2))
             node2.addIn(rest, value);
@@ -918,8 +918,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path12) {
-        const [key, ...rest] = path12;
+      deleteIn(path11) {
+        const [key, ...rest] = path11;
         if (rest.length === 0)
           return this.delete(key);
         const node2 = this.get(key, true);
@@ -933,8 +933,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path12, keepScalar) {
-        const [key, ...rest] = path12;
+      getIn(path11, keepScalar) {
+        const [key, ...rest] = path11;
         const node2 = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node2) ? node2.value : node2;
@@ -952,8 +952,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path12) {
-        const [key, ...rest] = path12;
+      hasIn(path11) {
+        const [key, ...rest] = path11;
         if (rest.length === 0)
           return this.has(key);
         const node2 = this.get(key, true);
@@ -963,8 +963,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path12, value) {
-        const [key, ...rest] = path12;
+      setIn(path11, value) {
+        const [key, ...rest] = path11;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -3479,9 +3479,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path12, value) {
+      addIn(path11, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path12, value);
+          this.contents.addIn(path11, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -3556,14 +3556,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path12) {
-        if (Collection.isEmptyPath(path12)) {
+      deleteIn(path11) {
+        if (Collection.isEmptyPath(path11)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path12) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path11) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -3578,10 +3578,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path12, keepScalar) {
-        if (Collection.isEmptyPath(path12))
+      getIn(path11, keepScalar) {
+        if (Collection.isEmptyPath(path11))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path12, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path11, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -3592,10 +3592,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path12) {
-        if (Collection.isEmptyPath(path12))
+      hasIn(path11) {
+        if (Collection.isEmptyPath(path11))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path12) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path11) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -3612,13 +3612,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path12, value) {
-        if (Collection.isEmptyPath(path12)) {
+      setIn(path11, value) {
+        if (Collection.isEmptyPath(path11)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path12), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path11), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path12, value);
+          this.contents.setIn(path11, value);
         }
       }
       /**
@@ -5579,9 +5579,9 @@ var require_cst_visit = __commonJS({
     visit2.BREAK = BREAK;
     visit2.SKIP = SKIP;
     visit2.REMOVE = REMOVE;
-    visit2.itemAtPath = (cst, path12) => {
+    visit2.itemAtPath = (cst, path11) => {
       let item = cst;
-      for (const [field, index] of path12) {
+      for (const [field, index] of path11) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -5590,23 +5590,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit2.parentCollection = (cst, path12) => {
-      const parent = visit2.itemAtPath(cst, path12.slice(0, -1));
-      const field = path12[path12.length - 1][0];
+    visit2.parentCollection = (cst, path11) => {
+      const parent = visit2.itemAtPath(cst, path11.slice(0, -1));
+      const field = path11[path11.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path12, item, visitor) {
-      let ctrl = visitor(item, path12);
+    function _visit(path11, item, visitor) {
+      let ctrl = visitor(item, path11);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci = _visit(Object.freeze(path12.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path11.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -5617,10 +5617,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path12);
+            ctrl = ctrl(item, path11);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path12) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path11) : ctrl;
     }
     exports.visit = visit2;
   }
@@ -8480,14 +8480,14 @@ var require_util = __commonJS({
         }
         const port = url2.port != null ? url2.port : url2.protocol === "https:" ? 443 : 80;
         let origin = url2.origin != null ? url2.origin : `${url2.protocol || ""}//${url2.hostname || ""}:${port}`;
-        let path12 = url2.path != null ? url2.path : `${url2.pathname || ""}${url2.search || ""}`;
+        let path11 = url2.path != null ? url2.path : `${url2.pathname || ""}${url2.search || ""}`;
         if (origin[origin.length - 1] === "/") {
           origin = origin.slice(0, origin.length - 1);
         }
-        if (path12 && path12[0] !== "/") {
-          path12 = `/${path12}`;
+        if (path11 && path11[0] !== "/") {
+          path11 = `/${path11}`;
         }
-        return new URL(`${origin}${path12}`);
+        return new URL(`${origin}${path11}`);
       }
       if (!isHttpOrHttpsPrefixed(url2.origin || url2.protocol)) {
         throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
@@ -9358,9 +9358,9 @@ var require_diagnostics = __commonJS({
         "undici:client:sendHeaders",
         (evt) => {
           const {
-            request: { method, path: path12, origin }
+            request: { method, path: path11, origin }
           } = evt;
-          debugLog("sending request to %s %s%s", method, origin, path12);
+          debugLog("sending request to %s %s%s", method, origin, path11);
         }
       );
     }
@@ -9378,14 +9378,14 @@ var require_diagnostics = __commonJS({
         "undici:request:headers",
         (evt) => {
           const {
-            request: { method, path: path12, origin },
+            request: { method, path: path11, origin },
             response: { statusCode }
           } = evt;
           debugLog(
             "received response to %s %s%s - HTTP %d",
             method,
             origin,
-            path12,
+            path11,
             statusCode
           );
         }
@@ -9394,23 +9394,23 @@ var require_diagnostics = __commonJS({
         "undici:request:trailers",
         (evt) => {
           const {
-            request: { method, path: path12, origin }
+            request: { method, path: path11, origin }
           } = evt;
-          debugLog("trailers received from %s %s%s", method, origin, path12);
+          debugLog("trailers received from %s %s%s", method, origin, path11);
         }
       );
       diagnosticsChannel.subscribe(
         "undici:request:error",
         (evt) => {
           const {
-            request: { method, path: path12, origin },
+            request: { method, path: path11, origin },
             error: error62
           } = evt;
           debugLog(
             "request to %s %s%s errored - %s",
             method,
             origin,
-            path12,
+            path11,
             error62.message
           );
         }
@@ -9565,7 +9565,7 @@ var require_request = __commonJS({
     };
     var Request = class {
       constructor(origin, {
-        path: path12,
+        path: path11,
         method,
         body,
         headers,
@@ -9582,11 +9582,11 @@ var require_request = __commonJS({
         maxRedirections,
         typeOfService
       }, handler) {
-        if (typeof path12 !== "string") {
+        if (typeof path11 !== "string") {
           throw new InvalidArgumentError("path must be a string");
-        } else if (path12[0] !== "/" && !(path12.startsWith("http://") || path12.startsWith("https://")) && method !== "CONNECT") {
+        } else if (path11[0] !== "/" && !(path11.startsWith("http://") || path11.startsWith("https://")) && method !== "CONNECT") {
           throw new InvalidArgumentError("path must be an absolute URL or start with a slash");
-        } else if (invalidPathRegex.test(path12)) {
+        } else if (invalidPathRegex.test(path11)) {
           throw new InvalidArgumentError("invalid request path");
         }
         if (typeof method !== "string") {
@@ -9661,7 +9661,7 @@ var require_request = __commonJS({
         this.completed = false;
         this.aborted = false;
         this.upgrade = upgrade || null;
-        this.path = query ? serializePathWithQuery(path12, query) : path12;
+        this.path = query ? serializePathWithQuery(path11, query) : path11;
         this.origin = origin;
         this.protocol = getProtocolFromUrlString(origin);
         this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" || method === "QUERY" : idempotent;
@@ -14770,7 +14770,7 @@ var require_client_h1 = __commonJS({
       }
     }
     function writeH1(client, request) {
-      const { method, path: path12, host, upgrade, blocking, reset } = request;
+      const { method, path: path11, host, upgrade, blocking, reset } = request;
       let { body, headers, contentLength } = request;
       const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH" || method === "QUERY" || method === "PROPFIND" || method === "PROPPATCH";
       if (util.isFormDataLike(body)) {
@@ -14846,7 +14846,7 @@ var require_client_h1 = __commonJS({
         socket[kBlocking] = true;
       }
       setTypeOfService(socket, request);
-      let header = `${method} ${path12} HTTP/1.1\r
+      let header = `${method} ${path11} HTTP/1.1\r
 `;
       if (typeof host === "string") {
         header += `host: ${host}\r
@@ -15929,7 +15929,7 @@ var require_client_h2 = __commonJS({
       const headersTimeout = request.headersTimeout ?? client[kHeadersTimeout];
       const bodyTimeout = request.bodyTimeout ?? client[kBodyTimeout];
       const session = client[kHTTP2Session];
-      const { method, path: path12, host, upgrade, expectContinue, signal, protocol, headers: reqHeaders } = request;
+      const { method, path: path11, host, upgrade, expectContinue, signal, protocol, headers: reqHeaders } = request;
       if (upgrade != null && upgrade !== "websocket") {
         util.errorRequest(client, request, new InvalidArgumentError(`Custom upgrade "${upgrade}" not supported over HTTP/2`));
         return false;
@@ -15994,7 +15994,7 @@ var require_client_h2 = __commonJS({
           }
           headers[HTTP2_HEADER_METHOD] = "CONNECT";
           headers[HTTP2_HEADER_PROTOCOL] = "websocket";
-          headers[HTTP2_HEADER_PATH] = path12;
+          headers[HTTP2_HEADER_PATH] = path11;
           if (protocol === "ws:" || protocol === "wss:") {
             headers[HTTP2_HEADER_SCHEME] = protocol === "ws:" ? "http" : "https";
           } else {
@@ -16016,7 +16016,7 @@ var require_client_h2 = __commonJS({
         setupUpgradeStream(stream, state);
         return true;
       }
-      headers[HTTP2_HEADER_PATH] = path12;
+      headers[HTTP2_HEADER_PATH] = path11;
       headers[HTTP2_HEADER_SCHEME] = protocol === "http:" ? "http" : "https";
       const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH" || method === "QUERY" || method === "PROPFIND" || method === "PROPPATCH";
       let body = state.body;
@@ -18772,10 +18772,10 @@ var require_proxy_agent = __commonJS({
         };
         const {
           origin,
-          path: path12 = "/",
+          path: path11 = "/",
           headers = {}
         } = opts;
-        opts.path = origin + path12;
+        opts.path = origin + path11;
         if (!("host" in headers) && !("Host" in headers)) {
           const { host } = new URL(origin);
           headers.host = host;
@@ -21128,20 +21128,20 @@ var require_mock_utils = __commonJS({
       }
       return normalizedQp;
     }
-    function safeUrl(path12) {
-      if (typeof path12 !== "string") {
-        return path12;
+    function safeUrl(path11) {
+      if (typeof path11 !== "string") {
+        return path11;
       }
-      const pathSegments = path12.split("?", 3);
+      const pathSegments = path11.split("?", 3);
       if (pathSegments.length !== 2) {
-        return path12;
+        return path11;
       }
       const qp = new URLSearchParams(pathSegments.pop());
       qp.sort();
       return [...pathSegments, qp.toString()].join("?");
     }
-    function matchKey(mockDispatch2, { path: path12, method, body, headers }) {
-      const pathMatch = matchValue(mockDispatch2.path, path12);
+    function matchKey(mockDispatch2, { path: path11, method, body, headers }) {
+      const pathMatch = matchValue(mockDispatch2.path, path11);
       const methodMatch = matchValue(mockDispatch2.method, method);
       const bodyMatch = typeof mockDispatch2.body !== "undefined" ? matchValue(mockDispatch2.body, body) : true;
       const headersMatch = matchHeaders(mockDispatch2, headers);
@@ -21168,8 +21168,8 @@ var require_mock_utils = __commonJS({
       const basePath = key.query ? serializePathWithQuery(key.path, key.query) : key.path;
       const resolvedPath = typeof basePath === "string" ? safeUrl(basePath) : basePath;
       const resolvedPathWithoutTrailingSlash = removeTrailingSlash(resolvedPath);
-      let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path12, ignoreTrailingSlash }) => {
-        return ignoreTrailingSlash ? matchValue(removeTrailingSlash(safeUrl(path12)), resolvedPathWithoutTrailingSlash) : matchValue(safeUrl(path12), resolvedPath);
+      let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path11, ignoreTrailingSlash }) => {
+        return ignoreTrailingSlash ? matchValue(removeTrailingSlash(safeUrl(path11)), resolvedPathWithoutTrailingSlash) : matchValue(safeUrl(path11), resolvedPath);
       });
       if (matchedMockDispatches.length === 0) {
         throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`);
@@ -21208,22 +21208,22 @@ var require_mock_utils = __commonJS({
         mockDispatches.splice(index, 1);
       }
     }
-    function removeTrailingSlash(path12) {
-      if (typeof path12 !== "string") {
-        return path12;
+    function removeTrailingSlash(path11) {
+      if (typeof path11 !== "string") {
+        return path11;
       }
-      while (path12.endsWith("/")) {
-        path12 = path12.slice(0, -1);
+      while (path11.endsWith("/")) {
+        path11 = path11.slice(0, -1);
       }
-      if (path12.length === 0) {
-        path12 = "/";
+      if (path11.length === 0) {
+        path11 = "/";
       }
-      return path12;
+      return path11;
     }
     function buildKey(opts) {
-      const { path: path12, method, body, headers, query } = opts;
+      const { path: path11, method, body, headers, query } = opts;
       return {
-        path: path12,
+        path: path11,
         method,
         body,
         headers,
@@ -22092,10 +22092,10 @@ var require_pending_interceptors_formatter = __commonJS({
       }
       format(pendingInterceptors) {
         const withPrettyHeaders = pendingInterceptors.map(
-          ({ method, path: path12, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
+          ({ method, path: path11, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
             Method: method,
             Origin: origin,
-            Path: path12,
+            Path: path11,
             "Status code": statusCode,
             Persistent: persist ? PERSISTENT : NOT_PERSISTENT,
             Invocations: timesInvoked,
@@ -22185,9 +22185,9 @@ var require_mock_agent = __commonJS({
           }
         }
         if (acceptNonStandardSearchParameters && dispatchOpts.path) {
-          const [path12, searchParams] = dispatchOpts.path.split("?");
+          const [path11, searchParams] = dispatchOpts.path.split("?");
           const normalizedSearchParams = normalizeSearchParams(searchParams, acceptNonStandardSearchParameters);
-          dispatchOpts.path = `${path12}?${normalizedSearchParams}`;
+          dispatchOpts.path = `${path11}?${normalizedSearchParams}`;
         }
         return this[kAgent].dispatch(dispatchOpts, handler);
       }
@@ -22603,12 +22603,12 @@ var require_snapshot_recorder = __commonJS({
        * @return {Promise<void>} - Resolves when snapshots are loaded
        */
       async loadSnapshots(filePath) {
-        const path12 = filePath || this.#snapshotPath;
-        if (!path12) {
+        const path11 = filePath || this.#snapshotPath;
+        if (!path11) {
           throw new InvalidArgumentError("Snapshot path is required");
         }
         try {
-          const data = await readFile(resolve(path12), "utf8");
+          const data = await readFile(resolve(path11), "utf8");
           const parsed = JSON.parse(data);
           if (Array.isArray(parsed)) {
             this.#snapshots.clear();
@@ -22622,7 +22622,7 @@ var require_snapshot_recorder = __commonJS({
           if (error62.code === "ENOENT") {
             this.#snapshots.clear();
           } else {
-            throw new UndiciError(`Failed to load snapshots from ${path12}`, { cause: error62 });
+            throw new UndiciError(`Failed to load snapshots from ${path11}`, { cause: error62 });
           }
         }
       }
@@ -22633,11 +22633,11 @@ var require_snapshot_recorder = __commonJS({
        * @returns {Promise<void>} - Resolves when snapshots are saved
        */
       async saveSnapshots(filePath) {
-        const path12 = filePath || this.#snapshotPath;
-        if (!path12) {
+        const path11 = filePath || this.#snapshotPath;
+        if (!path11) {
           throw new InvalidArgumentError("Snapshot path is required");
         }
-        const resolvedPath = resolve(path12);
+        const resolvedPath = resolve(path11);
         await mkdir(dirname(resolvedPath), { recursive: true });
         const data = Array.from(this.#snapshots.entries()).map(([hash2, snapshot]) => ({
           hash: hash2,
@@ -23287,15 +23287,15 @@ var require_redirect_handler = __commonJS({
         }
         const baseUrl = requestOrigin ? new URL(this.opts.path, requestOrigin) : void 0;
         const { origin, pathname, search } = util.parseURL(new URL(this.location, baseUrl));
-        const path12 = search ? `${pathname}${search}` : pathname;
-        const redirectUrlString = `${origin}${path12}`;
+        const path11 = search ? `${pathname}${search}` : pathname;
+        const redirectUrlString = `${origin}${path11}`;
         for (const historyUrl of this.history) {
           if (historyUrl.toString() === redirectUrlString) {
             throw new InvalidArgumentError(`Redirect loop detected. Cannot redirect to ${origin}. This typically happens when using a Client or Pool with cross-origin redirects. Use an Agent for cross-origin redirects.`);
           }
         }
         this.opts.headers = cleanRequestHeaders(this.opts.headers, removeContentHeaders, requestOrigin !== origin, this.stripHeadersOnRedirect, this.stripHeadersOnCrossOriginRedirect);
-        this.opts.path = path12;
+        this.opts.path = path11;
         this.opts.origin = origin;
         this.opts[kRequestOrigin] = origin;
         this.opts.query = null;
@@ -25146,10 +25146,10 @@ var require_cache_handler = __commonJS({
       }
       return locationUrl.pathname + locationUrl.search;
     }
-    function deleteCachedUri(store, cacheKey, path12) {
+    function deleteCachedUri(store, cacheKey, path11) {
       deleteCachedValue(store, {
         ...cacheKey,
-        path: path12
+        path: path11
       });
       for (let i = 0; i < util.safeHTTPMethods.length; i++) {
         const method = util.safeHTTPMethods[i];
@@ -25157,7 +25157,7 @@ var require_cache_handler = __commonJS({
           deleteCachedValue(store, {
             ...cacheKey,
             method,
-            path: path12
+            path: path11
           });
         }
       }
@@ -25168,9 +25168,9 @@ var require_cache_handler = __commonJS({
       }
       const values = Array.isArray(headerValue) ? headerValue : [headerValue];
       for (let i = 0; i < values.length; i++) {
-        const path12 = getSameOriginPath(cacheKey, values[i]);
-        if (path12 !== void 0) {
-          deleteCachedUri(store, cacheKey, path12);
+        const path11 = getSameOriginPath(cacheKey, values[i]);
+        if (path11 !== void 0) {
+          deleteCachedUri(store, cacheKey, path11);
         }
       }
     }
@@ -30297,13 +30297,13 @@ var require_fetch = __commonJS({
       function dispatch({ body }) {
         const url2 = requestCurrentURL(request);
         const agent = fetchParams.controller.dispatcher;
-        const path12 = url2.pathname + url2.search;
+        const path11 = url2.pathname + url2.search;
         const hasTrailingQuestionMark = url2.search.length === 0 && url2.href[url2.href.length - url2.hash.length - 1] === "?";
         return dispatchWithProtocolPreference(body);
         function dispatchWithProtocolPreference(body2, allowH2) {
           return new Promise((resolve, reject) => agent.dispatch(
             {
-              path: hasTrailingQuestionMark ? `${path12}?` : path12,
+              path: hasTrailingQuestionMark ? `${path11}?` : path11,
               origin: url2.origin,
               method: request.method,
               body: agent.isMockActive ? request.body && (request.body.source || request.body.stream) : body2,
@@ -31218,9 +31218,9 @@ var require_util4 = __commonJS({
         }
       }
     }
-    function validateCookiePath(path12) {
-      for (let i = 0; i < path12.length; ++i) {
-        const code = path12.charCodeAt(i);
+    function validateCookiePath(path11) {
+      for (let i = 0; i < path11.length; ++i) {
+        const code = path11.charCodeAt(i);
         if (code < 32 || // exclude CTLs (0-31)
         code > 126 || // exclude non-ascii and DEL
         code === 59) {
@@ -34628,11 +34628,11 @@ var require_undici = __commonJS({
           if (typeof opts.path !== "string") {
             throw new InvalidArgumentError("invalid opts.path");
           }
-          let path12 = opts.path;
+          let path11 = opts.path;
           if (!opts.path.startsWith("/")) {
-            path12 = `/${path12}`;
+            path11 = `/${path11}`;
           }
-          url2 = new URL(util.parseOrigin(url2).origin + path12);
+          url2 = new URL(util.parseOrigin(url2).origin + path11);
         } else {
           if (!opts) {
             opts = typeof url2 === "object" ? url2 : {};
@@ -34744,7 +34744,7 @@ ${captureLines}` : capture2.stack;
 // src/job.ts
 var import_yaml7 = __toESM(require_dist(), 1);
 import fs9 from "node:fs/promises";
-import path11 from "node:path";
+import path10 from "node:path";
 
 // ../../node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -35562,10 +35562,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path12) {
-  if (!path12)
+function getElementAtPath(obj, path11) {
+  if (!path11)
     return obj;
-  return path12.reduce((acc, key) => acc?.[key], obj);
+  return path11.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -35905,11 +35905,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path12, issues) {
+function prefixIssues(path11, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path12);
+    iss.path.unshift(path11);
     return iss;
   });
 }
@@ -36359,16 +36359,16 @@ function flattenError(error62, mapper = (issue2) => issue2.message) {
 }
 function formatError(error62, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error63, path12 = []) => {
+  const processError = (error63, path11 = []) => {
     for (const issue2 of error63.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path12, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path11, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
       } else {
-        const fullpath = [...path12, ...issue2.path];
+        const fullpath = [...path11, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -36407,17 +36407,17 @@ function formatError(error62, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error62, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error63, path12 = []) => {
+  const processError = (error63, path11 = []) => {
     var _a3;
     for (const issue2 of error63.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path12, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path11, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
       } else {
-        const fullpath = [...path12, ...issue2.path];
+        const fullpath = [...path11, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -36456,8 +36456,8 @@ function treeifyError(error62, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path12 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path12) {
+  const path11 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path11) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -53559,13 +53559,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path12 = ref.slice(1).split("/").filter(Boolean);
-  if (path12.length === 0) {
+  const path11 = ref.slice(1).split("/").filter(Boolean);
+  if (path11.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path12[0] === defsKey) {
-    const key = path12[1] === void 0 ? void 0 : decodeJSONPointerSegment(path12[1]);
+  if (path11[0] === defsKey) {
+    const key = path11[1] === void 0 ? void 0 : decodeJSONPointerSegment(path11[1]);
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -54452,8 +54452,8 @@ var MultipartPartSchema = external_exports.union(
       file: relativePath("a multipart file"),
       /** Absent: from the file's extension, else application/octet-stream. */
       contentType: external_exports.string().min(1).optional(),
-      /** The name sent for it; absent, the file's own. */
-      filename: external_exports.string().min(1).optional()
+      /** The name sent for it; absent, the file's own. `''`, as a browser sends no file chosen. */
+      filename: external_exports.string().optional()
     })
   ],
   {
@@ -54539,6 +54539,16 @@ var StepSchema = external_exports.looseObject({
   tags: TagsSchema.optional(),
   /** Feature flags this step needs; unmet, it is skipped (SPEC.md §2.9). */
   flags: FlagConditionsSchema.optional(),
+  /**
+   * Send the request once for each item of a list, read as `{{item}}` and
+   * `item` in code: `'{{roots}}'`, a variable holding a JSON array (SPEC.md §2.1).
+   */
+  forEach: external_exports.string().min(1).optional(),
+  /**
+   * In a request set: the use step's own `tests` check this step's response,
+   * rather than the set's last (SPEC.md §2.5). At most one step has it.
+   */
+  useTests: external_exports.literal(true).optional(),
   docs: external_exports.string().optional(),
   headers: HeadersSchema.optional(),
   body: BodySchema.optional(),
@@ -54558,6 +54568,13 @@ var StepSchema = external_exports.looseObject({
   }
   const methods = HTTP_METHODS.filter((m) => m in step);
   if ("use" in step) {
+    if ("forEach" in step) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["forEach"],
+        message: "forEach repeats one request, so a use: step cannot have it (SPEC.md \xA72.1)"
+      });
+    }
     const own2 = [...methods, ...USE_FORBIDDEN.filter((key) => key in step)];
     for (const key of own2) {
       ctx.addIssue({
@@ -54606,6 +54623,8 @@ var STEP_KEYS = /* @__PURE__ */ new Set([
   "tests",
   "tags",
   "flags",
+  "forEach",
+  "useTests",
   "base",
   "docs"
 ]);
@@ -54688,8 +54707,49 @@ var CollectionSchema = external_exports.strictObject({
    * and as `params.name` in code.
    */
   params: external_exports.record(external_exports.string(), ParamSpecSchema).optional(),
-  steps: external_exports.array(StepSchema).default([])
+  /**
+   * Steps run once before `steps`, and before every row of a data file:
+   * what they set lasts the whole run (SPEC.md §2.10).
+   */
+  setup: external_exports.array(StepSchema).optional(),
+  steps: external_exports.array(StepSchema).default([]),
+  /** Steps run once after the rest, even when they failed (SPEC.md §2.10). */
+  teardown: external_exports.array(StepSchema).optional()
 }).superRefine((collection, ctx) => {
+  for (const stage of STAGES) {
+    if (!collection[stage]) continue;
+    if (collection.params) {
+      ctx.addIssue({
+        code: "custom",
+        path: [stage],
+        message: `a request set runs inside another collection, so it has no ${stage} (SPEC.md \xA72.10)`
+      });
+    }
+    collection[stage].forEach((step, index) => {
+      if (step.tags) {
+        ctx.addIssue({
+          code: "custom",
+          path: [stage, index, "tags"],
+          message: `a ${stage} step runs whenever its collection does, so it has no tags (SPEC.md \xA72.10)`
+        });
+      }
+    });
+  }
+  const marked = collection.steps.flatMap((step, index) => step.useTests ? [index] : []);
+  if (marked.length > 0 && !collection.params) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["steps", marked[0], "useTests"],
+      message: "useTests marks the request set step whose response a use step's tests check; this collection has no params, so it is not a request set (SPEC.md \xA72.5)"
+    });
+  }
+  if (marked.length > 1) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["steps", marked[1], "useTests"],
+      message: `only one step can have useTests; step ${marked[0] + 1} has it already (SPEC.md \xA72.5)`
+    });
+  }
   if (collection.params) {
     collection.steps.forEach((step, index) => {
       if (isUseStep(step)) {
@@ -54719,6 +54779,8 @@ var CollectionSchema = external_exports.strictObject({
     }
   });
 });
+var STAGES = ["setup", "teardown"];
+var STEP_LISTS = ["setup", "steps", "teardown"];
 var EnvironmentVarSchema = external_exports.union([
   VarValueSchema,
   external_exports.strictObject({
@@ -54813,21 +54875,21 @@ async function canonical(target) {
     return absolute;
   }
 }
-function isInside(parent, child, path12 = nodePath) {
-  const relative = path12.relative(parent, child);
-  const leaves = relative === ".." || relative.startsWith(`..${path12.sep}`);
-  return relative === "" || !leaves && !path12.isAbsolute(relative);
+function isInside(parent, child, path11 = nodePath) {
+  const relative = path11.relative(parent, child);
+  const leaves = relative === ".." || relative.startsWith(`..${path11.sep}`);
+  return relative === "" || !leaves && !path11.isAbsolute(relative);
 }
-var samePath = (a, b, path12 = nodePath) => path12.relative(a, b) === "";
+var samePath = (a, b, path11 = nodePath) => path11.relative(a, b) === "";
 var toPosix = (relative) => relative.split(/[\\/]+/).join("/");
 var isAbsoluteAnywhere = (target) => nodePath.posix.isAbsolute(target) || nodePath.win32.isAbsolute(target);
-function resolveRelative(root, relative, path12 = nodePath) {
+function resolveRelative(root, relative, path11 = nodePath) {
   if (isAbsoluteAnywhere(relative)) {
     throw new Error(`"${relative}" must be a relative path, so it works on every machine`);
   }
-  return path12.resolve(root, ...relative.split(/[\\/]+/).filter(Boolean));
+  return path11.resolve(root, ...relative.split(/[\\/]+/).filter(Boolean));
 }
-var relativePosix = (from, to, path12 = nodePath) => toPosix(path12.relative(from, to)) || ".";
+var relativePosix = (from, to, path11 = nodePath) => toPosix(path11.relative(from, to)) || ".";
 var RESERVED = /^(con|prn|aux|nul|conin\$|conout\$|com[0-9¹²³]|lpt[0-9¹²³])(\..*)?$/i;
 var FORBIDDEN = /[<>:"/\\|?*\u0000-\u001f]/;
 function nameProblem(name) {
@@ -54996,40 +55058,47 @@ function decodeEntities(text) {
 }
 
 // ../../packages/core/src/model/path.ts
-function parsePath(path12) {
+var SEGMENT = (
+  // eslint-disable-next-line no-control-regex
+  /\[("(?:[^"\\\u0000-\u001f]|\\["\\/bfnrt]|\\u[0-9a-fA-F]{4})*")\]|([^.[\]]+)|\[(\d*)\]/g
+);
+function parsePath(path11) {
   const segments = [];
-  const pattern = /([^.[\]]+)|\[(\d*)\]/g;
-  for (const match of path12.matchAll(pattern)) {
-    if (match[1] !== void 0) segments.push({ kind: "key", key: match[1] });
-    else if (match[2] === "") segments.push({ kind: "each" });
-    else segments.push({ kind: "index", index: Number(match[2]) });
+  for (const match of path11.matchAll(SEGMENT)) {
+    if (match[1] !== void 0) segments.push({ kind: "key", key: JSON.parse(match[1]) });
+    else if (match[2] !== void 0) segments.push({ kind: "key", key: match[2] });
+    else if (match[3] === "") segments.push({ kind: "each" });
+    else segments.push({ kind: "index", index: Number(match[3]) });
   }
   return segments;
 }
 function formatPath(segments) {
   let out = "";
   for (const segment of segments) {
-    if (segment.kind === "key") out += out === "" ? segment.key : `.${segment.key}`;
-    else if (segment.kind === "index") out += `[${segment.index}]`;
+    if (segment.kind === "key") {
+      if (!plainKey(segment.key)) out += `[${JSON.stringify(segment.key)}]`;
+      else out += out === "" ? segment.key : `.${segment.key}`;
+    } else if (segment.kind === "index") out += `[${segment.index}]`;
     else out += "[]";
   }
   return out;
 }
+var plainKey = (key) => key !== "" && !/[.[\]]/.test(key);
 var isIndexKey = (key) => /^\d+$/.test(key);
 function resolvePath(root, pattern) {
   let frontier = [{ path: [], value: root }];
   for (const segment of pattern) {
     const next = [];
-    for (const { path: path12, value } of frontier) {
+    for (const { path: path11, value } of frontier) {
       if (segment.kind === "each") {
         if (!Array.isArray(value)) continue;
         value.forEach(
-          (item, index) => next.push({ path: [...path12, { kind: "index", index }], value: item })
+          (item, index) => next.push({ path: [...path11, { kind: "index", index }], value: item })
         );
         continue;
       }
       const step = childOf(value, segment);
-      if (step) next.push({ path: [...path12, step.segment], value: step.value });
+      if (step) next.push({ path: [...path11, step.segment], value: step.value });
     }
     frontier = next;
   }
@@ -55047,17 +55116,17 @@ function childOf(value, segment) {
 }
 function sortArraysBy(value, properties) {
   const paths = properties.map(parsePath);
-  const sortValue = (item, path12) => item !== null && typeof item === "object" && !Array.isArray(item) ? resolvePath(item, path12)[0]?.value : void 0;
+  const sortValue = (item, path11) => item !== null && typeof item === "object" && !Array.isArray(item) ? resolvePath(item, path11)[0]?.value : void 0;
   const visit2 = (node2) => {
     if (Array.isArray(node2)) {
       const items = node2.map(visit2);
       const sortable = paths.some(
-        (path12) => items.some((item) => sortValue(item, path12) !== void 0)
+        (path11) => items.some((item) => sortValue(item, path11) !== void 0)
       );
       if (!sortable) return items;
       return items.map((item, index) => ({ item, index })).sort((a, b) => {
-        for (const path12 of paths) {
-          const order = compareAlphanumerically(sortValue(a.item, path12), sortValue(b.item, path12));
+        for (const path11 of paths) {
+          const order = compareAlphanumerically(sortValue(a.item, path11), sortValue(b.item, path11));
           if (order !== 0) return order;
         }
         return a.index - b.index;
@@ -55156,7 +55225,7 @@ var RunErrorSchema = external_exports.object({
    * Which stage failed, so the UI can say where without guessing. `body` is a
    * file the body names that could not be read (SPEC.md §2.2).
    */
-  phase: external_exports.enum(["use", "flags", "interpolate", "body", "pre-request", "http", "tests"]),
+  phase: external_exports.enum(["use", "flags", "forEach", "interpolate", "body", "pre-request", "http", "tests"]),
   message: external_exports.string(),
   code: external_exports.string().optional(),
   stack: external_exports.string().optional(),
@@ -55188,16 +55257,30 @@ var RunResultSchema = external_exports.object({
   logs: external_exports.array(LogEntrySchema).optional(),
   error: RunErrorSchema.nullable(),
   status: RunStatusSchema,
-  /** Why a `skipped` step did not run: a feature flag it needs (SPEC.md §2.9). */
+  /**
+   * Why a `skipped` step did not run: a feature flag it needs (SPEC.md §2.9),
+   * `gta.skip` or `gta.skipRest` (§5), or an empty `forEach` list.
+   */
   skipped: external_exports.object({ reason: external_exports.string() }).optional(),
   /** Wall-clock milliseconds for the whole item, scripts included. */
   durationMs: external_exports.number(),
   /**
-   * For a request run by a use step: which step of the set it was (0-based),
-   * of how many, and the set's file. Absent for a collection's own request.
+   * For a request run by a use step: the set as `use:` names it, the use
+   * step's own `name` when it has one, and which step of the set it was
+   * (0-based) of how many. Absent for a collection's own request.
    */
-  use: external_exports.object({ set: external_exports.string(), child: external_exports.number(), of: external_exports.number() }).optional()
-});
+  use: external_exports.object({ set: external_exports.string(), name: external_exports.string().optional(), child: external_exports.number(), of: external_exports.number() }).optional(),
+  /** For a `setup` or `teardown` step: which list it is in (SPEC.md §2.10). Absent for `steps`. */
+  stage: external_exports.enum(["setup", "teardown"]).optional(),
+  /** For a step with `forEach`: which item this request was for, from 0, of how many. */
+  forEach: external_exports.object({ index: external_exports.number(), of: external_exports.number(), item: external_exports.string() }).optional()
+});
+function resultName(result) {
+  const use = result.use;
+  const name = !use?.name ? result.item.name : use.of === 1 ? use.name : `${use.name} \u203A ${result.item.name}`;
+  const each = result.forEach ? ` (item ${result.forEach.index + 1} of ${result.forEach.of})` : "";
+  return `${result.stage ? `${result.stage} \u203A ` : ""}${name}${each}`;
+}
 var CollectionRunSummarySchema = external_exports.object({
   total: external_exports.number(),
   passed: external_exports.number(),
@@ -55544,8 +55627,8 @@ var FormatError = class extends Error {
 };
 function describeValidation(error62) {
   return error62.issues.map((issue2) => {
-    const path12 = issue2.path.join(".");
-    return path12 ? `${path12}: ${issue2.message}` : issue2.message;
+    const path11 = issue2.path.join(".");
+    return path11 ? `${path11}: ${issue2.message}` : issue2.message;
   }).join("; ");
 }
 
@@ -55578,8 +55661,10 @@ var STEP_KEY_ORDER = [
   "use",
   "with",
   ...HTTP_METHODS,
+  "forEach",
   "tags",
   "flags",
+  "useTests",
   "base",
   "docs",
   "headers",
@@ -55631,116 +55716,36 @@ var runtime = defaultRuntime();
 // ../../packages/core/src/git/diff.ts
 var MAX_DIFF_BYTES = 2 * 1024 * 1024;
 
-// ../../packages/core/src/workspace/collection.ts
-import fs4 from "node:fs/promises";
-import path4 from "node:path";
-
-// ../../packages/core/src/workspace/ids.ts
-import path from "node:path";
-var ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
-var idOfFile = (file2) => path.basename(file2, DOC_EXTENSION);
-function idProblem(doc, file2) {
-  const expected = idOfFile(file2);
-  if (!ID_PATTERN.test(expected)) {
-    return `${expected}${DOC_EXTENSION}: a collection's file name is its id, and an id is letters, digits and - _ . (SPEC.md \xA72)`;
-  }
-  const unusable = nameProblem(path.basename(file2));
-  if (unusable) return `${path.basename(file2)}: ${unusable} (SPEC.md \xA71.2)`;
-  if (doc.id === void 0) {
-    return `id: missing \u2014 a collection file says its id, its file name: id: ${expected} (SPEC.md \xA72)`;
-  }
-  if (doc.id !== expected) {
-    return `id: ${doc.id} does not match the file name, ${expected}${DOC_EXTENSION} \u2014 they must be the same (SPEC.md \xA72)`;
-  }
-  return null;
-}
-function duplicateIds(files, home) {
-  const byId = /* @__PURE__ */ new Map();
-  for (const file2 of files) {
-    const key = idOfFile(file2).toLowerCase();
-    byId.set(key, [...byId.get(key) ?? [], file2]);
-  }
-  const problems = /* @__PURE__ */ new Map();
-  for (const group of byId.values()) {
-    if (group.length < 2) continue;
-    for (const file2 of group) {
-      const others = group.filter((other) => other !== file2).map((other) => `${path.basename(home)}/${relativePosix(home, other)}`);
-      problems.set(
-        file2,
-        `id: ${idOfFile(file2)} is also the id of ${others.join(", ")} \u2014 an id is unique in ${path.basename(home)}/, ignoring case (SPEC.md \xA72)`
-      );
-    }
-  }
-  return problems;
-}
-
-// ../../packages/core/src/workspace/dataFile.ts
-import fs2 from "node:fs/promises";
-import path2 from "node:path";
-var MAX_BYTES = 10 * 1024 * 1024;
-async function findDataFile(collectionFile) {
-  const base2 = collectionFile.endsWith(DOC_EXTENSION) ? collectionFile.slice(0, -DOC_EXTENSION.length) : collectionFile;
-  for (const extension of [".csv", ".json"]) {
-    try {
-      const candidate = `${base2}${extension}`;
-      const names = await fs2.readdir(path2.dirname(candidate));
-      if (names.includes(path2.basename(candidate))) return candidate;
-    } catch {
-      return null;
-    }
-  }
-  return null;
-}
-async function readDataTable(file2) {
-  const stat = await fs2.stat(file2);
-  if (stat.size > MAX_BYTES) {
-    throw new DataFileError(`${path2.basename(file2)}: larger than ${MAX_BYTES / 1024 / 1024} MB`);
-  }
-  const source = await fs2.readFile(file2, "utf8");
-  return { source, table: parseDataTable(source, path2.basename(file2), dataKindOf(file2)) };
-}
-var rowsOf = (table) => table.rows.map((values) => ({ values, label: rowLabel(values) }));
-async function readDataFile(file2) {
-  const { table } = await readDataTable(file2);
-  const problem = dataTableProblems(table)[0];
-  if (problem) throw new DataFileError(`${path2.basename(file2)}: ${problem}`);
-  return { path: file2, rows: rowsOf(table) };
-}
-async function loadDataFile(collectionFile) {
-  const file2 = await findDataFile(collectionFile);
-  return file2 ? readDataFile(file2) : null;
-}
-
 // ../../packages/core/src/workspace/project.ts
-import fs3 from "node:fs/promises";
-import path3 from "node:path";
+import fs2 from "node:fs/promises";
+import path from "node:path";
 var HOMES = /* @__PURE__ */ new Set([COLLECTIONS_DIR, REQUESTS_DIR, ENDPOINTS_DIR, BASES_DIR]);
 function projectRootOf(collectionFile) {
-  const directory = path3.dirname(path3.resolve(collectionFile));
-  if (HOMES.has(path3.basename(directory))) return path3.dirname(directory);
-  const parent = path3.dirname(directory);
-  if (HOMES.has(path3.basename(parent))) return path3.dirname(parent);
+  const directory = path.dirname(path.resolve(collectionFile));
+  if (HOMES.has(path.basename(directory))) return path.dirname(directory);
+  const parent = path.dirname(directory);
+  if (HOMES.has(path.basename(parent))) return path.dirname(parent);
   return null;
 }
 function directoryOf(collectionFile) {
-  const directory = path3.dirname(path3.resolve(collectionFile));
-  return HOMES.has(path3.basename(directory)) ? null : path3.basename(directory);
+  const directory = path.dirname(path.resolve(collectionFile));
+  return HOMES.has(path.basename(directory)) ? null : path.basename(directory);
 }
 var isHidden = (name) => name.startsWith(".") || IGNORED_DIRECTORIES.has(name);
 var isCollectionFile = (name) => name.endsWith(DOC_EXTENSION) && !name.startsWith(".");
 async function discoverProject(root) {
-  const collectionsDir = path3.join(root, COLLECTIONS_DIR);
+  const collectionsDir = path.join(root, COLLECTIONS_DIR);
   const layout = { root, collectionsDir, files: [], directories: [], problems: [] };
   const entries2 = await readDir(collectionsDir);
   for (const entry of entries2) {
     if (entry.isFile() && isCollectionFile(entry.name)) {
-      layout.files.push(path3.join(collectionsDir, entry.name));
+      layout.files.push(path.join(collectionsDir, entry.name));
     } else if (entry.isDirectory() && !isHidden(entry.name)) {
       layout.directories.push(entry.name);
-      const directory = path3.join(collectionsDir, entry.name);
+      const directory = path.join(collectionsDir, entry.name);
       for (const inner of await readDir(directory)) {
         if (inner.isFile() && isCollectionFile(inner.name)) {
-          layout.files.push(path3.join(directory, inner.name));
+          layout.files.push(path.join(directory, inner.name));
         } else if (inner.isDirectory() && !isHidden(inner.name)) {
           layout.problems.push({
             path: `${entry.name}/${inner.name}`,
@@ -55780,14 +55785,14 @@ async function portabilityProblems(root) {
     }
   }
   for (const home of [COLLECTIONS_DIR, REQUESTS_DIR, ENDPOINTS_DIR, BASES_DIR]) {
-    const directories = (await readDir(path3.join(root, home))).filter((entry) => entry.isDirectory() && !isHidden(entry.name)).map((entry) => entry.name);
+    const directories = (await readDir(path.join(root, home))).filter((entry) => entry.isDirectory() && !isHidden(entry.name)).map((entry) => entry.name);
     problems.push(...portableNameProblems(home, directories));
   }
   for (const [home, extension] of [
     [ENVIRONMENTS_DIR, DOC_EXTENSION],
     [CHECKS_DIR, ".js"]
   ]) {
-    const files = (await readDir(path3.join(root, home))).filter((entry) => entry.isFile() && entry.name.endsWith(extension)).map((entry) => entry.name);
+    const files = (await readDir(path.join(root, home))).filter((entry) => entry.isFile() && entry.name.endsWith(extension)).map((entry) => entry.name);
     problems.push(...portableNameProblems(home, files));
   }
   return problems;
@@ -55856,7 +55861,7 @@ async function readProject(root) {
 async function readProjectFile(root) {
   let source;
   try {
-    source = await fs3.readFile(path3.join(root, PROJECT_FILE), "utf8");
+    source = await fs2.readFile(path.join(root, PROJECT_FILE), "utf8");
   } catch {
     return { doc: null, source: null, problem: null };
   }
@@ -55874,18 +55879,18 @@ async function readProjectFile(root) {
   }
 }
 async function projectEnvironments(root, global) {
-  const own2 = await readEnvironments(path3.join(root, ENVIRONMENTS_DIR), "project");
-  const shared = global ? await readEnvironments(path3.join(global.root, ENVIRONMENTS_DIR), "global") : [];
+  const own2 = await readEnvironments(path.join(root, ENVIRONMENTS_DIR), "project");
+  const shared = global ? await readEnvironments(path.join(global.root, ENVIRONMENTS_DIR), "global") : [];
   return [...own2, ...shared];
 }
 async function readEnvironments(directory, source = "project") {
   const environments = [];
   for (const entry of await readDir(directory)) {
     if (!entry.isFile() || !entry.name.endsWith(DOC_EXTENSION)) continue;
-    const file2 = path3.join(directory, entry.name);
-    let name = path3.basename(entry.name, DOC_EXTENSION);
+    const file2 = path.join(directory, entry.name);
+    let name = path.basename(entry.name, DOC_EXTENSION);
     try {
-      name = parseEnvironment(await fs3.readFile(file2, "utf8"), file2).data.name ?? name;
+      name = parseEnvironment(await fs2.readFile(file2, "utf8"), file2).data.name ?? name;
     } catch {
     }
     environments.push({ name, path: file2, source });
@@ -55894,12 +55899,92 @@ async function readEnvironments(directory, source = "project") {
 }
 async function readDir(directory) {
   try {
-    return await fs3.readdir(directory, { withFileTypes: true });
+    return await fs2.readdir(directory, { withFileTypes: true });
   } catch {
     return [];
   }
 }
 
+// ../../packages/core/src/workspace/collection.ts
+import fs4 from "node:fs/promises";
+import path4 from "node:path";
+
+// ../../packages/core/src/workspace/ids.ts
+import path2 from "node:path";
+var ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+var idOfFile = (file2) => path2.basename(file2, DOC_EXTENSION);
+function idProblem(doc, file2) {
+  const expected = idOfFile(file2);
+  if (!ID_PATTERN.test(expected)) {
+    return `${expected}${DOC_EXTENSION}: a collection's file name is its id, and an id is letters, digits and - _ . (SPEC.md \xA72)`;
+  }
+  const unusable = nameProblem(path2.basename(file2));
+  if (unusable) return `${path2.basename(file2)}: ${unusable} (SPEC.md \xA71.2)`;
+  if (doc.id === void 0) {
+    return `id: missing \u2014 a collection file says its id, its file name: id: ${expected} (SPEC.md \xA72)`;
+  }
+  if (doc.id !== expected) {
+    return `id: ${doc.id} does not match the file name, ${expected}${DOC_EXTENSION} \u2014 they must be the same (SPEC.md \xA72)`;
+  }
+  return null;
+}
+function duplicateIds(files, home) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const file2 of files) {
+    const key = idOfFile(file2).toLowerCase();
+    byId.set(key, [...byId.get(key) ?? [], file2]);
+  }
+  const problems = /* @__PURE__ */ new Map();
+  for (const group of byId.values()) {
+    if (group.length < 2) continue;
+    for (const file2 of group) {
+      const others = group.filter((other) => other !== file2).map((other) => `${path2.basename(home)}/${relativePosix(home, other)}`);
+      problems.set(
+        file2,
+        `id: ${idOfFile(file2)} is also the id of ${others.join(", ")} \u2014 an id is unique in ${path2.basename(home)}/, ignoring case (SPEC.md \xA72)`
+      );
+    }
+  }
+  return problems;
+}
+
+// ../../packages/core/src/workspace/dataFile.ts
+import fs3 from "node:fs/promises";
+import path3 from "node:path";
+var MAX_BYTES = 10 * 1024 * 1024;
+async function findDataFile(collectionFile) {
+  const base2 = collectionFile.endsWith(DOC_EXTENSION) ? collectionFile.slice(0, -DOC_EXTENSION.length) : collectionFile;
+  for (const extension of [".csv", ".json"]) {
+    try {
+      const candidate = `${base2}${extension}`;
+      const names = await fs3.readdir(path3.dirname(candidate));
+      if (names.includes(path3.basename(candidate))) return candidate;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+async function readDataTable(file2) {
+  const stat = await fs3.stat(file2);
+  if (stat.size > MAX_BYTES) {
+    throw new DataFileError(`${path3.basename(file2)}: larger than ${MAX_BYTES / 1024 / 1024} MB`);
+  }
+  const source = await fs3.readFile(file2, "utf8");
+  return { source, table: parseDataTable(source, path3.basename(file2), dataKindOf(file2)) };
+}
+var rowsOf = (table) => table.rows.map((values) => ({ values, label: rowLabel(values) }));
+async function readDataFile(file2) {
+  const { table } = await readDataTable(file2);
+  const problem = dataTableProblems(table)[0];
+  if (problem) throw new DataFileError(`${path3.basename(file2)}: ${problem}`);
+  return { path: file2, rows: rowsOf(table) };
+}
+async function loadDataFile(collectionFile) {
+  const file2 = await findDataFile(collectionFile);
+  return file2 ? readDataFile(file2) : null;
+}
+
 // ../../packages/core/src/workspace/collection.ts
 async function loadCollection(file2, root) {
   const absolute = path4.resolve(file2);
@@ -56223,6 +56308,7 @@ async function loadEndpoints(root, global) {
 }
 function baseProblem(doc) {
   if (doc.steps.length > 0) return "a base collection has no steps of its own";
+  if (doc.setup || doc.teardown) return "a base collection has no setup or teardown";
   if (doc.params) return "a base collection has no params";
   if (doc.extends) return "a base collection cannot extend another (SPEC.md \xA72.7)";
   return void 0;
@@ -56451,6 +56537,14 @@ var VariableScope = class {
    * `gta.flag`; null when none are known, so any flag named is unknown.
    */
   flags = null;
+  /**
+   * Values that last the whole collection run, across its data rows and into
+   * teardown (SPEC.md §2.10): where `gta.set(…, { scope: 'run' })` writes.
+   * Null outside a collection run, where there is nothing to outlast.
+   */
+  runValues = null;
+  /** In setup and teardown, every value set lasts the run. */
+  runWide = false;
   values = /* @__PURE__ */ new Map();
   origins = /* @__PURE__ */ new Map();
   secrets = /* @__PURE__ */ new Set();
@@ -56494,6 +56588,12 @@ var VariableScope = class {
   set(name, value, source = "runtime") {
     this.values.set(name, value);
     this.origins.set(name, source);
+    if (this.runWide) this.runValues?.set(name, value);
+  }
+  /** `set`, and keep the value for every row after this one and for teardown. */
+  setForRun(name, value, source = "runtime") {
+    this.set(name, value, source);
+    this.runValues?.set(name, value);
   }
   names() {
     return [...this.values.keys()].sort();
@@ -56503,35 +56603,49 @@ var VariableScope = class {
     return Object.fromEntries(this.values);
   }
 };
-var ParamsScope = class extends VariableScope {
-  constructor(run, params) {
+var OverlayScope = class extends VariableScope {
+  constructor(run, own2, origin) {
     super();
     this.run = run;
-    this.params = new Map(Object.entries(params).map(([name, value]) => [`params.${name}`, value]));
+    this.own = own2;
+    this.origin = origin;
     this.flags = run.flags;
   }
   run;
-  params;
+  own;
+  origin;
   has(name) {
-    return this.params.has(name) || this.run.has(name);
+    return this.own.has(name) || this.run.has(name);
   }
   get(name) {
-    return this.params.has(name) ? this.params.get(name) : this.run.get(name);
+    return this.own.has(name) ? this.own.get(name) : this.run.get(name);
   }
   isSecret(name) {
-    return !this.params.has(name) && this.run.isSecret(name);
+    return !this.own.has(name) && this.run.isSecret(name);
   }
   originOf(name) {
-    return this.params.has(name) ? "params" : this.run.originOf(name);
+    return this.own.has(name) ? this.origin : this.run.originOf(name);
   }
   set(name, value, source = "runtime") {
     this.run.set(name, value, source);
   }
+  setForRun(name, value, source = "runtime") {
+    this.run.setForRun(name, value, source);
+  }
   names() {
-    return [.../* @__PURE__ */ new Set([...this.params.keys(), ...this.run.names()])].sort();
+    return [.../* @__PURE__ */ new Set([...this.own.keys(), ...this.run.names()])].sort();
   }
   all() {
-    return { ...this.run.all(), ...Object.fromEntries(this.params) };
+    return { ...this.run.all(), ...Object.fromEntries(this.own) };
+  }
+};
+var ParamsScope = class extends OverlayScope {
+  constructor(run, params) {
+    super(
+      run,
+      new Map(Object.entries(params).map(([name, value]) => [`params.${name}`, value])),
+      "params"
+    );
   }
 };
 var BUILT_INS = {
@@ -56545,19 +56659,19 @@ var BUILT_INS = {
 var REFERENCE = /\{\{\s*([^{}\s]+)\s*\}\}/g;
 var SOLE_REFERENCE = /^\{\{\s*([^{}\s]+)\s*\}\}$/;
 var MAX_DEPTH = 16;
-function interpolate(value, scope) {
+function interpolate(value, scope, options = {}) {
   const sole = SOLE_REFERENCE.exec(value);
   if (sole?.[1]) {
     const resolved = resolveName(sole[1], scope, []);
-    return typeof resolved === "string" ? resolveString(resolved, scope, [sole[1]]) : resolved;
+    return typeof resolved === "string" ? resolveString(resolved, scope, [sole[1]], options) : resolved;
   }
-  return resolveString(value, scope, []);
+  return resolveString(value, scope, [], options);
 }
-function interpolateToString(value, scope) {
-  const result = interpolate(value, scope);
-  return result === null || result === void 0 ? "" : String(result);
+function interpolateToString(value, scope, options = {}) {
+  const result = interpolate(value, scope, options);
+  return result === null || result === void 0 ? options.nullAs ?? "" : String(result);
 }
-function resolveString(text, scope, seen) {
+function resolveString(text, scope, seen, options) {
   if (seen.length > MAX_DEPTH) {
     throw new InterpolationError(
       `Variable nesting is too deep (${seen.join(" -> ")}); this is probably a loop`
@@ -56571,11 +56685,12 @@ function resolveString(text, scope, seen) {
       );
     }
     const resolved = resolveName(name, scope, seen);
-    if (resolved === null || resolved === void 0) return "";
-    return typeof resolved === "string" ? resolveString(resolved, scope, [...seen, name]) : String(resolved);
+    if (resolved === null || resolved === void 0) return options.nullAs ?? "";
+    return typeof resolved === "string" ? resolveString(resolved, scope, [...seen, name], options) : String(resolved);
   });
 }
 function resolveName(name, scope, seen) {
+  if (name.length > 1 && name.startsWith("@")) return resolveNamed(name, scope, seen);
   const builtIn = BUILT_INS[name];
   if (builtIn) return builtIn();
   if (!scope.has(name)) {
@@ -56592,6 +56707,31 @@ function resolveName(name, scope, seen) {
   }
   return value;
 }
+function resolveNamed(name, scope, seen) {
+  const holder = name.slice(1);
+  const through = [...seen, name];
+  const held = resolveName(holder, scope, through);
+  const target = typeof held === "string" ? resolveString(held, scope, [...through, holder], {}) : held;
+  if (typeof target !== "string" || target.trim() === "") {
+    throw new InterpolationError(
+      `{{${name}}} reads the variable ${holder} names, but ${holder} is ${JSON.stringify(target)}, not a variable name`,
+      holder
+    );
+  }
+  if (through.includes(target)) {
+    throw new InterpolationError(
+      `Variable "${target}" refers to itself: ${[...through, target].join(" -> ")}`,
+      target
+    );
+  }
+  if (!BUILT_INS[target] && !target.startsWith("@") && !scope.has(target)) {
+    throw new InterpolationError(
+      `Variable "${target}", which {{${name}}} names, is not defined in this environment.`,
+      target
+    );
+  }
+  return resolveName(target, scope, through);
+}
 
 // ../../packages/core/src/vars/resolve.ts
 import fs7 from "node:fs/promises";
@@ -56623,9 +56763,14 @@ async function buildScope(context) {
   if (context.environmentName) {
     layers.push(...await environmentLayers(context, context.environmentName));
   }
+  if (context.run) layers.push({ source: "run", vars: Object.fromEntries(context.run.values) });
   const row = context.dataRow !== void 0 ? context.dataRow : await firstRow(context.collectionPath);
   if (row) layers.push(row);
   const scope = new VariableScope(layers, context.env ?? process.env);
+  if (context.run) {
+    scope.runValues = context.run.values;
+    scope.runWide = context.run.wide === true;
+  }
   scope.flags = context.flags !== void 0 ? context.flags : context.environmentName ? (await environmentFlags(root, context.environmentName, context.environments)).values : null;
   return scope;
 }
@@ -57074,7 +57219,8 @@ import fs8 from "node:fs/promises";
 var BodyFileError = class extends Error {
   name = "BodyFileError";
 };
-async function prepareRequest(written, body, scope, root) {
+var GLOBAL_FILE = "global:";
+async function prepareRequest(written, body, scope, files) {
   const resolve = (text) => interpolateToString(text, scope);
   const headers = written.headers.map((header) => ({
     name: resolve(header.name),
@@ -57095,14 +57241,14 @@ async function prepareRequest(written, body, scope, root) {
       if (typeof part === "string") {
         parts.push({ name, value: resolve(part) });
       } else if ("file" in part) {
-        const path12 = resolve(part.file);
-        const bytes2 = await readBodyFile(root, path12, `multipart field ${name}`);
+        const path11 = resolve(part.file);
+        const { bytes: bytes2, shown } = await readBodyFile(files, path11, `multipart field ${name}`);
         parts.push({
           name,
           value: bytes2,
-          filename: part.filename !== void 0 ? resolve(part.filename) : baseName(path12),
-          contentType: part.contentType ? resolve(part.contentType) : contentTypeFor(path12),
-          shown: fileMarker(path12, bytes2.byteLength)
+          filename: part.filename !== void 0 ? resolve(part.filename) : baseName(path11),
+          contentType: part.contentType ? resolve(part.contentType) : contentTypeFor(path11),
+          shown: fileMarker(shown, bytes2.byteLength)
         });
       } else {
         parts.push({
@@ -57117,52 +57263,112 @@ async function prepareRequest(written, body, scope, root) {
     return { request: { ...request, headers: typed.headers, body: text }, payload: bytes };
   }
   if (body?.file !== void 0) {
-    const path12 = resolve(body.file);
-    const bytes = await readBodyFile(root, path12, "body.file");
+    const path11 = resolve(body.file);
+    const { bytes, shown } = await readBodyFile(files, path11, "body.file");
     const declared = headers.some((header) => header.name.toLowerCase() === "content-type");
     return {
       request: {
         ...request,
-        headers: declared ? headers : [...headers, { name: "Content-Type", value: contentTypeFor(path12) }],
-        body: fileMarker(path12, bytes.byteLength)
+        headers: declared ? headers : [...headers, { name: "Content-Type", value: contentTypeFor(path11) }],
+        body: fileMarker(shown, bytes.byteLength)
       },
       payload: bytes
     };
   }
   return {
-    request: { ...request, body: written.body === null ? null : resolve(written.body) },
+    request: {
+      ...request,
+      // In a JSON body a null is JSON's own, not a gap that leaves it malformed.
+      body: written.body === null ? null : body?.json !== void 0 ? interpolateToString(written.body, scope, { nullAs: "null" }) : resolve(written.body)
+    },
     payload: null
   };
 }
-var baseName = (path12) => path12.split(/[\\/]/).pop() ?? path12;
-async function readBodyFile(root, path12, what) {
-  if (root === null) {
-    throw new BodyFileError(
-      `${what}: ${path12} \u2014 files are read from the project folder, so save the collection in a project first`
+var baseName = (path11) => withoutGlobal(path11).split(/[\\/]/).pop() ?? path11;
+var withoutGlobal = (path11) => path11.startsWith(GLOBAL_FILE) ? path11.slice(GLOBAL_FILE.length) : path11;
+function bodyFiles(body) {
+  if (body?.file !== void 0) return [{ what: "body.file", written: body.file }];
+  if (body?.multipart === void 0) return [];
+  return partsOf(body.multipart).flatMap(
+    ([field, part]) => typeof part !== "string" && "file" in part ? [{ what: `multipart field ${field}`, written: part.file }] : []
+  );
+}
+async function readBodyFile(roots, written, what) {
+  const { file: file2, shown } = await findBodyFile(roots, written, what);
+  try {
+    return { bytes: await fs8.readFile(file2), shown };
+  } catch (cause) {
+    throw new BodyFileError(`${what}: ${written} \u2014 ${cause.message}`);
+  }
+}
+async function findBodyFile(roots, written, what) {
+  const missing = (reason) => new BodyFileError(`${what}: ${written} \u2014 ${reason}`);
+  if (roots === null) {
+    throw missing(
+      "files are read from the project folder, so save the collection in a project first"
     );
   }
+  const relative = withoutGlobal(written);
+  if (relative !== written) {
+    if (!roots.global) throw missing("this project does not use a global project");
+    const file3 = await fileIn(roots.global, relative, written, what);
+    if (file3) return { file: file3, shown: written };
+    throw missing("no such file in the global project folder");
+  }
+  const file2 = await fileIn(roots.project, relative, written, what);
+  if (file2) return { file: file2, shown: written };
+  const global = roots.global && !samePath(roots.global, roots.project) ? roots.global : null;
+  if (!global || !isInside(roots.project, resolveRelative(roots.project, relative))) {
+    throw missing("no such file in the project folder");
+  }
+  const shared = await fileIn(global, relative, written, what);
+  if (shared) return { file: shared, shown: `${GLOBAL_FILE}${toPosix(relative)}` };
+  throw missing(
+    `no such file in the project folder, or in its global project's (${relativePosix(roots.project, global)})`
+  );
+}
+async function fileIn(root, relative, written, what) {
   let file2;
   try {
-    file2 = resolveRelative(root, path12);
+    file2 = resolveRelative(root, relative);
   } catch (cause) {
     throw new BodyFileError(`${what}: ${cause.message}`);
   }
-  const misspelled = await spellingProblem(root, path12);
+  if (written.startsWith(GLOBAL_FILE) && !isInside(root, file2)) {
+    throw new BodyFileError(
+      `${what}: ${written} \u2014 a global: path stays in the global project folder`
+    );
+  }
+  const misspelled = await spellingProblem(root, relative);
   if (misspelled) throw new BodyFileError(`${what}: ${misspelled}`);
+  let stat;
   try {
-    return await fs8.readFile(file2);
+    stat = await fs8.stat(file2);
   } catch (cause) {
     const code = cause.code;
-    const reason = code === "ENOENT" ? "no such file in the project folder" : code === "EISDIR" ? "is a directory, not a file" : cause.message;
-    throw new BodyFileError(`${what}: ${path12} \u2014 ${reason}`);
+    if (code === "ENOENT" || code === "ENOTDIR") return null;
+    throw new BodyFileError(`${what}: ${written} \u2014 ${cause.message}`);
   }
+  if (stat.isDirectory())
+    throw new BodyFileError(`${what}: ${written} \u2014 is a directory, not a file`);
+  return file2;
 }
 
 // ../../packages/core/src/run/runRequest.ts
 import assert3 from "node:assert/strict";
-import path8 from "node:path";
 
 // ../../packages/core/src/assert/evaluate.ts
+function locate(root, segments, nullAlong) {
+  const located = resolvePath(root, segments);
+  if (located.length > 0 || !nullAlong || segments.some((s) => s.kind === "each")) return located;
+  for (let end = 1; end < segments.length; end++) {
+    const [reached] = resolvePath(root, segments.slice(0, end));
+    if (!reached) return [];
+    if (reached.value === null) return [reached];
+  }
+  return [];
+}
+var isNullCheck = (wanted) => wanted.equals === null && Object.keys(wanted).length === 1;
 function checkScalarTarget(target, label, wanted, found, context) {
   const base2 = { target, expected: describe3(wanted) };
   const name = `${label} ${describe3(wanted, { brief: true })}`;
@@ -57181,9 +57387,9 @@ function checkScalarTarget(target, label, wanted, found, context) {
   capture(wanted, value, context.scope);
   return failure2 ? { ...base2, ...actual, name, status: "fail", message: failure2 } : { ...base2, ...actual, name, status: "pass" };
 }
-function checkBody(path12, segments, wanted, located, context) {
-  const base2 = { target: "body", path: path12, expected: describe3(wanted) };
-  const name = `${path12} ${describe3(wanted, { brief: true })}`;
+function checkBody(path11, segments, wanted, located, context) {
+  const base2 = { target: "body", path: path11, expected: describe3(wanted) };
+  const name = `${path11} ${describe3(wanted, { brief: true })}`;
   const fanOut = segments.some((s) => s.kind === "each");
   const actual = located.length === 0 ? {} : { actual: fanOut ? show(located.map((l) => l.value)) : show(located[0].value) };
   if (wanted.absent) {
@@ -57207,7 +57413,7 @@ function checkBody(path12, segments, wanted, located, context) {
   const covered = [];
   let failure2 = null;
   for (const { path: at, value } of located) {
-    const check2 = checkBodyValue(wanted, value, context);
+    const check2 = checkBodyValue(wanted, value, context, context.claimed?.(formatPath(at)));
     covered.push(...check2.covered.map((c) => ({ ...c, pattern: [...at, ...c.pattern] })));
     if (check2.failure && !failure2) {
       failure2 = fanOut ? `At ${formatPath(at)}: ${check2.failure}` : check2.failure;
@@ -57219,7 +57425,7 @@ function checkBody(path12, segments, wanted, located, context) {
     covered
   };
 }
-function checkBodyValue(wanted, value, context) {
+function checkBodyValue(wanted, value, context, claimed = /* @__PURE__ */ new Set()) {
   const failures = [];
   let whole = !(value !== null && typeof value === "object");
   const covered = [];
@@ -57258,7 +57464,7 @@ function checkBodyValue(wanted, value, context) {
       const used = /* @__PURE__ */ new Set();
       for (const expected of wanted.unordered) {
         const matches = value.map((item, index) => ({ index, match: matchItem(item, expected, context) })).filter((candidate) => candidate.match !== null);
-        const chosen = matches.find((m) => !used.has(m.index)) ?? matches[0];
+        const chosen = matches.find((m) => !used.has(m.index) && !claimed.has(m.index)) ?? matches.find((m) => !used.has(m.index)) ?? matches[0];
         if (!chosen) {
           missing.push(expected);
           continue;
@@ -57269,6 +57475,7 @@ function checkBodyValue(wanted, value, context) {
           covered.push({ pattern: [{ kind: "index", index: chosen.index }, ...c.pattern] });
         }
       }
+      for (const index of used) claimed.add(index);
       if (missing.length > 0)
         failures.push(`Missing from the array: ${missing.map(show).join(", ")}`);
     }
@@ -57382,7 +57589,11 @@ function matchItem(item, expected, context) {
   const captures = [];
   for (const [key, want] of entries2) {
     const segments = parsePath(key);
-    const located = resolvePath(item, segments);
+    const located = locate(
+      item,
+      segments,
+      isMatcherObject(want) ? isNullCheck(want) : want === null
+    );
     if (isMatcherObject(want)) {
       if (want.absent) {
         if (located.length > 0) return null;
@@ -57478,19 +57689,19 @@ var REMOVED = /* @__PURE__ */ Symbol("removed");
 function findUnasserted(body, covered) {
   const root = { value: structuredClone(body) };
   for (const coverage of covered) {
-    for (const { path: path12 } of resolvePath(root.value, coverage.pattern)) remove(root, path12);
+    for (const { path: path11 } of resolvePath(root.value, coverage.pattern)) remove(root, path11);
   }
   const leaves = [];
   collectLeaves(prune(root.value), [], leaves);
   return leaves;
 }
-function remove(root, path12) {
-  if (path12.length === 0) {
+function remove(root, path11) {
+  if (path11.length === 0) {
     root.value = REMOVED;
     return;
   }
-  const parent = resolvePath(root.value, path12.slice(0, -1))[0]?.value;
-  const last = path12[path12.length - 1];
+  const parent = resolvePath(root.value, path11.slice(0, -1))[0]?.value;
+  const last = path11[path11.length - 1];
   if (Array.isArray(parent) && last.kind === "index") parent[last.index] = REMOVED;
   else if (parent !== null && typeof parent === "object" && last.kind === "key") {
     delete parent[last.key];
@@ -57509,16 +57720,16 @@ function prune(value) {
   }
   return value;
 }
-function collectLeaves(value, path12, out) {
+function collectLeaves(value, path11, out) {
   if (value === void 0) return;
   if (Array.isArray(value)) {
-    value.forEach((item, index) => collectLeaves(item, [...path12, { kind: "index", index }], out));
+    value.forEach((item, index) => collectLeaves(item, [...path11, { kind: "index", index }], out));
   } else if (value !== null && typeof value === "object") {
     for (const [key, child] of Object.entries(value)) {
-      collectLeaves(child, [...path12, { kind: "key", key }], out);
+      collectLeaves(child, [...path11, { kind: "key", key }], out);
     }
   } else {
-    out.push(formatPath(path12));
+    out.push(formatPath(path11));
   }
 }
 
@@ -57538,6 +57749,10 @@ var CheckSession = class {
   /** While true, checks recorded are defaults: an endpoint base's (SPEC.md §2.6). */
   recordingDefaults = false;
   defaults = /* @__PURE__ */ new Set();
+  /** Checks whose meaning waits on strict validation: what each would be with it on. */
+  byStrictness = [];
+  /** Items of each array unordered checks matched, by the array's path. */
+  claims = /* @__PURE__ */ new Map();
   /** Turn strict validation on or off. The last word wins. */
   setStrict(strict) {
     this.strict = strict;
@@ -57553,6 +57768,7 @@ var CheckSession = class {
     if (properties.length === 0) return;
     this.sortKeys = [...properties, ...this.sortKeys];
     this.sorted = void 0;
+    this.claims.clear();
   }
   status(matcher) {
     return this.record(
@@ -57567,17 +57783,43 @@ var CheckSession = class {
       path: name
     });
   }
-  body(path12, matcher) {
+  body(path11, matcher) {
     const body = this.body_();
     if (body === BODY_UNAVAILABLE) return null;
-    const segments = parsePath(path12);
-    const result = checkBody(path12, segments, matcher, resolvePath(body, segments), this.context);
+    const segments = parsePath(path11);
+    const located = locate(body, segments, isNullCheck(matcher));
+    const result = checkBody(path11, segments, matcher, located, {
+      ...this.context,
+      claimed: (arrayPath) => this.claimsOn(arrayPath)
+    });
     this.covered.push(...result.covered);
     return this.record(result.assertion);
   }
+  /**
+   * A body check that means one thing under strict validation and another
+   * without, as xtest's lone `notThisExpectedValue` entry did (SPEC.md §3).
+   * Both are checked now, against the body as it is now, and `finish()` keeps
+   * the one the step's last word on strict validation asks for.
+   */
+  bodyByStrictness(path11, matchers) {
+    const body = this.body_();
+    if (body === BODY_UNAVAILABLE) return null;
+    const segments = parsePath(path11);
+    const located = locate(body, segments, false);
+    const strict = checkBody(path11, segments, matchers.strict, located, this.context);
+    const lenient = checkBody(path11, segments, matchers.lenient, located, this.context);
+    const assertion = this.record(lenient.assertion);
+    this.byStrictness.push({ assertion, strict });
+    return assertion;
+  }
+  claimsOn(arrayPath) {
+    let claimed = this.claims.get(arrayPath);
+    if (!claimed) this.claims.set(arrayPath, claimed = /* @__PURE__ */ new Set());
+    return claimed;
+  }
   /** Account for a path under strict validation without asserting anything. */
-  ignore(path12) {
-    this.covered.push({ pattern: parsePath(path12) });
+  ignore(path11) {
+    this.covered.push({ pattern: parsePath(path11) });
   }
   /** Add a result to the report — every check's, and a named check's from code. */
   record(assertion) {
@@ -57614,9 +57856,17 @@ var CheckSession = class {
     }
   }
   finish() {
+    if (this.strict) {
+      for (const { assertion, strict } of this.byStrictness) {
+        for (const key of Object.keys(assertion)) delete assertion[key];
+        Object.assign(assertion, strict.assertion);
+        this.covered.push(...strict.covered);
+      }
+    }
     this.replaceDefaults();
     if (this.strict) {
-      const body = this.body_();
+      const readable = !["binary", "html"].includes(this.context.response.bodyKind);
+      const body = readable ? this.body_() : {};
       if (body !== BODY_UNAVAILABLE) {
         const unasserted = findUnasserted(body, this.covered);
         this.assertions.push({
@@ -57781,26 +58031,53 @@ function variableName(value) {
   }
   return value;
 }
+function pathOf2(path11, what) {
+  if (typeof path11 === "string") return path11;
+  if (!Array.isArray(path11)) {
+    throw new GtaUsageError(
+      `${what} is a string, such as "user.name", or a list of keys, such as ["user", "name"]; got ${show(path11)}`
+    );
+  }
+  if (path11.length === 0) throw new GtaUsageError(`${what} is an empty list; it needs a key`);
+  return formatPath(
+    path11.map((key) => {
+      if (typeof key === "string") return { kind: "key", key };
+      if (typeof key === "number") return { kind: "key", key: String(key) };
+      throw new GtaUsageError(`${what}'s keys are strings or numbers; got ${show(key)}`);
+    })
+  );
+}
 var isValidationEntry = (value) => value !== null && typeof value === "object" && "pathToProperty" in value;
 function itemFrom(list, valueKey) {
   const item = {};
   for (const entry of list) {
-    const path12 = entry.pathToProperty;
+    const path11 = pathOf2(entry.pathToProperty, "pathToProperty");
     if (valueKey === "compareValue") {
-      item[path12] = entry.compareValue;
+      const value = entry.compareValue;
+      item[path11] = isRegExp(value) ? { matches: value } : value;
       continue;
     }
     const matcher = xtestMatcher(valueKey in entry, entry[valueKey], entry.specialHandling);
-    item[path12] = { ...item[path12], ...matcher };
+    item[path11] = { ...item[path11], ...matcher };
   }
   return item;
 }
+function loneNotThisValue(list) {
+  const [entry] = list;
+  if (list.length !== 1 || !isValidationEntry(entry)) return null;
+  if (entry.specialHandling !== "notThisExpectedValue" || !("expectedValue" in entry)) return null;
+  const value = entry.expectedValue;
+  const path11 = pathOf2(entry.pathToProperty, "pathToProperty");
+  return { unorderedNot: [{ [path11]: isRegExp(value) ? { matches: value } : value }] };
+}
 function toList(validationList) {
   if (!Array.isArray(validationList)) {
     throw new GtaUsageError(`validationList must be an array, got ${show(validationList)}`);
   }
   return validationList;
 }
+var newStepControl = () => ({ skip: null, rest: null });
+var reasonOf = (reason, fallback) => reason === void 0 || reason === null || String(reason).trim() === "" ? fallback : String(reason);
 function guarded(session, label, fn) {
   return (...args) => {
     try {
@@ -57811,11 +58088,26 @@ function guarded(session, label, fn) {
     }
   };
 }
-function testsGta({ session, scope, pending, warn = () => {
-} }) {
+function testsGta({
+  session,
+  scope,
+  pending,
+  warn = () => {
+  },
+  control = newStepControl()
+}) {
   const shared = sharedGta(scope);
   return {
     ...shared,
+    skip() {
+      throw new Error(
+        "gta.skip() stops a request before it is sent, so it belongs in before.script; gta.skipRest() skips the steps after this one"
+      );
+    },
+    /** Run none of the steps after this one in this row; the next row, and teardown, still run. */
+    skipRest(reason) {
+      control.rest ??= reasonOf(reason, "gta.skipRest() in an earlier step");
+    },
     expectResponseStatusCodeToBe: guarded(
       session,
       "expectResponseStatusCodeToBe",
@@ -57836,40 +58128,63 @@ function testsGta({ session, scope, pending, warn = () => {
       session,
       "expectResponseBodyToHaveProperty",
       (...args) => {
-        const [path12, value, specialHandling] = args;
-        session.body(path12, xtestMatcher(args.length > 1, value, specialHandling));
+        const [path11, value, specialHandling] = args;
+        session.body(
+          pathOf2(path11, "jsonPathToProperty"),
+          xtestMatcher(args.length > 1, value, specialHandling)
+        );
       }
     ),
     expectResponseBodyToHaveUnorderedArray: guarded(
       session,
       "expectResponseBodyToHaveUnorderedArray",
       (jsonPathToArray, validationList) => {
+        const path11 = pathOf2(jsonPathToArray, "jsonPathToArray");
         const list = toList(validationList);
         const unordered = list.every(isValidationEntry) ? [itemFrom(list, "expectedValue")] : list;
-        session.body(jsonPathToArray, { unordered });
+        const lone = loneNotThisValue(list);
+        if (lone) session.bodyByStrictness(path11, { strict: { unordered }, lenient: lone });
+        else session.body(path11, { unordered });
       }
     ),
     expectResponseBodyToHaveUnorderedArrayNotThisItem: guarded(
       session,
       "expectResponseBodyToHaveUnorderedArrayNotThisItem",
       (jsonPathToArray, validationList) => {
+        const path11 = pathOf2(jsonPathToArray, "jsonPathToArray");
         const list = toList(validationList);
         const unorderedNot = list.every(isValidationEntry) ? [itemFrom(list, "compareValue")] : list;
-        session.body(jsonPathToArray, { unorderedNot });
+        session.body(path11, { unorderedNot });
+      }
+    ),
+    ignoreResponseBodyProperty: guarded(
+      session,
+      "ignoreResponseBodyProperty",
+      (jsonPathToProperty) => {
+        session.ignore(pathOf2(jsonPathToProperty, "jsonPathToProperty"));
+      }
+    ),
+    ignoreResponseBodyArrayObjectProperty: guarded(
+      session,
+      "ignoreResponseBodyArrayObjectProperty",
+      (jsonPathToArray, jsonPathOfObjectProperty) => {
+        const array2 = parsePath(pathOf2(jsonPathToArray, "jsonPathToArray"));
+        const property = parsePath(pathOf2(jsonPathOfObjectProperty, "jsonPathOfObjectProperty"));
+        session.ignore(formatPath([...array2, { kind: "each" }, ...property]));
       }
     ),
-    ignoreResponseBodyProperty(jsonPathToProperty) {
-      session.ignore(jsonPathToProperty);
-    },
-    ignoreResponseBodyArrayObjectProperty(jsonPathToArray, jsonPathOfObjectProperty) {
-      session.ignore(`${jsonPathToArray}[].${jsonPathOfObjectProperty}`);
-    },
     sortResponseBodyArrays(propertyName) {
-      if (typeof propertyName !== "string" || propertyName === "") {
+      const named = typeof propertyName === "string" && propertyName !== "" || Array.isArray(propertyName) && propertyName.length > 0;
+      if (!named) {
         warn("gta.sortResponseBodyArrays() needs a property name to sort by; nothing was sorted");
         return;
       }
-      session.sortBy([propertyName]);
+      try {
+        session.sortBy([pathOf2(propertyName, "propertyName")]);
+      } catch (cause) {
+        if (!(cause instanceof GtaUsageError)) throw cause;
+        warn(`gta.sortResponseBodyArrays(): ${cause.message}; nothing was sorted`);
+      }
     },
     /** Strict validation for this step. Replaces `startXTest`'s second argument. */
     useStrictValidation(enabled = true) {
@@ -57908,12 +58223,25 @@ function testsGta({ session, scope, pending, warn = () => {
     }
   };
 }
-function preRequestGta(scope) {
+function preRequestGta(scope, control = newStepControl()) {
   const notHere = (name) => () => {
     throw new Error(`gta.${name}() checks a response, so it belongs in tests, not before.script`);
   };
   return {
     ...sharedGta(scope),
+    /**
+     * Send nothing for this step, and report it skipped with the reason. The
+     * script runs to its end; no later `before.script` does.
+     */
+    skip(reason) {
+      control.skip ??= reasonOf(reason, "gta.skip() in before.script");
+    },
+    /** `skip`, and run none of the steps after this one in this row either. */
+    skipRest(reason) {
+      const given = reasonOf(reason, "gta.skipRest() in before.script");
+      control.skip ??= given;
+      control.rest ??= given;
+    },
     expectResponseStatusCodeToBe: notHere("expectResponseStatusCodeToBe"),
     expectResponseToHaveHeader: notHere("expectResponseToHaveHeader"),
     expectResponseBodyToHaveProperty: notHere("expectResponseBodyToHaveProperty"),
@@ -57926,9 +58254,18 @@ function sharedGta(scope) {
     get(name) {
       return scope.get(name);
     },
-    /** Set a variable for the rest of this run, like a capture. */
-    set(name, value) {
-      scope.set(String(name), toVarValue2(value), "script");
+    /**
+     * Set a variable for the rest of this run, like a capture. With
+     * `{ scope: 'run' }` it lasts past this data row too, into every row after
+     * it and teardown (SPEC.md §2.10).
+     */
+    set(name, value, options) {
+      const lasting = options?.scope;
+      if (lasting !== void 0 && lasting !== "run") {
+        throw new Error(`gta.set(): scope is 'run' or left out, got ${show(lasting)}`);
+      }
+      if (lasting === "run") scope.setForRun(String(name), toVarValue2(value), "script");
+      else scope.set(String(name), toVarValue2(value), "script");
     },
     /**
      * A feature flag's value in this run (SPEC.md §2.9) — to check something
@@ -57977,6 +58314,7 @@ function uuidv72(now = Date.now()) {
 }
 var isThenable = (value) => value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
 function toVarValue2(value) {
+  if (value === void 0) return null;
   if (value === null || ["string", "number", "boolean"].includes(typeof value)) {
     return value;
   }
@@ -58165,7 +58503,151 @@ function captureConsole(logs, phase) {
   return { log: write("log"), info: write("info"), warn: write("warn"), error: write("error") };
 }
 
+// ../../packages/core/src/run/plan.ts
+import path8 from "node:path";
+async function planSteps(collection, collectionPath) {
+  const planned = [];
+  let project;
+  for (const [index, step] of collection.steps.entries()) {
+    if (!isUseStep(step)) {
+      planned.push({ kind: "request", index, step });
+      continue;
+    }
+    try {
+      if (!collectionPath)
+        throw new Error(`use: ${step.use} \u2014 save the collection in a project first`);
+      project ??= await projectOf(collectionPath);
+      const set2 = await resolveRequestSet(project.root, project.global, step.use);
+      checkWith(step.use, set2.doc, step.with ?? {});
+      if (set2.doc.steps.length === 0) throw new Error(`use: ${step.use} \u2014 the set has no steps`);
+      const planSet = {
+        name: step.use,
+        useName: step.name?.trim() ? step.name : void 0,
+        path: set2.path,
+        doc: set2.doc,
+        with: step.with ?? {},
+        useTests: step.tests
+      };
+      set2.doc.steps.forEach((child, number4) => {
+        planned.push({ kind: "request", index, step: child, set: planSet, child: number4 });
+      });
+    } catch (cause) {
+      planned.push({
+        kind: "broken",
+        index,
+        step,
+        error: { phase: "use", message: cause instanceof Error ? cause.message : String(cause) }
+      });
+    }
+  }
+  return planned;
+}
+async function projectOf(collectionPath) {
+  const root = projectRootOf(collectionPath) ?? path8.dirname(collectionPath);
+  const { global } = await readProject(root);
+  return { root, global };
+}
+async function fileRootsOf(file2, collectionPath) {
+  const { global } = await projectOf(collectionPath);
+  return { project: projectRootOf(file2) ?? path8.dirname(file2), global: global?.root ?? null };
+}
+function checkWith(name, set2, given) {
+  const params = set2.params ?? {};
+  const unknown2 = Object.keys(given).filter((key) => !(key in params));
+  if (unknown2.length > 0) {
+    const takes = Object.keys(params).join(", ") || "none";
+    throw new Error(`use: ${name} \u2014 it takes no ${unknown2.join(", ")} (it takes: ${takes})`);
+  }
+  const missing = Object.entries(params).filter(([key, spec]) => readParam(spec).required && !(key in given)).map(([key]) => key);
+  if (missing.length > 0) {
+    throw new Error(`use: ${name} \u2014 needs ${missing.join(", ")} in with:`);
+  }
+}
+function resolveParams(specs, given, scope) {
+  const params = {};
+  const defaults = /* @__PURE__ */ new Map();
+  for (const [key, spec] of Object.entries(specs ?? {})) {
+    const value = given[key];
+    if (value !== void 0)
+      params[key] = typeof value === "string" ? interpolate(value, scope) : value;
+    else {
+      const fallback = readParam(spec).default;
+      if (fallback !== void 0) defaults.set(key, fallback);
+    }
+  }
+  const resolving = [];
+  const resolve = (key) => {
+    const fallback = defaults.get(key);
+    if (fallback === void 0 || Object.hasOwn(params, key)) return;
+    if (resolving.includes(key)) {
+      const chain = [...resolving, key].map((name) => `params.${name}`);
+      throw new InterpolationError(
+        `params.${key} refers to itself: ${chain.join(" -> ")}`,
+        `params.${key}`
+      );
+    }
+    if (typeof fallback !== "string") {
+      params[key] = fallback;
+      return;
+    }
+    resolving.push(key);
+    for (const [, name] of fallback.matchAll(PARAM_REFERENCE)) resolve(name);
+    resolving.pop();
+    try {
+      params[key] = interpolate(fallback, new ParamsScope(scope, params));
+    } catch (cause) {
+      if (!(cause instanceof InterpolationError)) throw cause;
+      throw new InterpolationError(`params.${key}'s default: ${cause.message}`, cause.variable);
+    }
+  };
+  for (const key of defaults.keys()) resolve(key);
+  return params;
+}
+var PARAM_REFERENCE = /\{\{\s*params\.([^{}\s]+)\s*\}\}/g;
+async function referenceProblems(collection, collectionPath) {
+  const problems = [];
+  if (collection.extends) {
+    try {
+      const { root, global } = await projectOf(collectionPath);
+      await resolveBase(root, global, collection.extends);
+    } catch (cause) {
+      problems.push({ step: null, message: cause.message });
+    }
+  }
+  for (const list of STEP_LISTS) {
+    const steps = collection[list];
+    if (!steps) continue;
+    const stage = list === "steps" ? {} : { stage: list };
+    for (const planned of await planSteps({ ...collection, steps }, collectionPath)) {
+      if (planned.kind === "broken") {
+        problems.push({ step: planned.index, ...stage, message: planned.error.message });
+        continue;
+      }
+      for (const message of await missingFiles(planned, collectionPath)) {
+        problems.push({ step: planned.index, ...stage, message });
+      }
+    }
+  }
+  return problems;
+}
+async function missingFiles(planned, collectionPath) {
+  const named = bodyFiles(planned.step.body).filter(({ written }) => !written.includes("{{"));
+  if (named.length === 0) return [];
+  const roots = await fileRootsOf(planned.set?.path ?? collectionPath, collectionPath);
+  const messages = [];
+  for (const { what, written } of named) {
+    try {
+      await findBodyFile(roots, written, what);
+    } catch (cause) {
+      if (!(cause instanceof BodyFileError)) throw cause;
+      messages.push(planned.set ? `use: ${planned.set.name} \u2014 ${cause.message}` : cause.message);
+    }
+  }
+  return messages;
+}
+
 // ../../packages/core/src/run/runRequest.ts
+var itemText = (value) => value === null || ["string", "number", "boolean"].includes(typeof value) ? value : JSON.stringify(value) ?? String(value);
 function folded(layers, collection) {
   let headers;
   let settings = {};
@@ -58205,16 +58687,9 @@ function endpointValues(endpoint, step, scope) {
   }
   return values;
 }
-function defaultsOf(params) {
-  const defaults = {};
-  for (const [key, spec] of Object.entries(params)) {
-    const value = readParam(spec).default;
-    if (value !== void 0) defaults[key] = value;
-  }
-  return defaults;
-}
 async function runRequest(input2) {
-  const { step, itemPath = null, signal, context, scope: provided, set: set2 } = input2;
+  const { step, itemPath = null, signal, context, scope: provided, set: set2, item: each } = input2;
+  const control = input2.control ?? newStepControl();
   if (isUseStep(step)) {
     return {
       item: { path: itemPath, name: stepLabel(step), seq: null },
@@ -58226,7 +58701,6 @@ async function runRequest(input2) {
       durationMs: 0
     };
   }
-  const params = set2?.params ?? input2.params ?? (input2.collection?.params ? defaultsOf(input2.collection.params) : void 0);
   const library = context && needsLibrary(input2) ? await loadLibrary(context.collectionPath) : null;
   const checks = input2.checks ?? library?.checks;
   const endpoints = input2.endpoints ?? library?.endpoints ?? [];
@@ -58264,9 +58738,18 @@ async function runRequest(input2) {
   const logs = [];
   const withLogs = () => ({
     ...logs.length > 0 ? { logs } : {},
-    ...set2 ? { use: { set: set2.name, child: set2.child, of: set2.of } } : {}
+    ...each ? { forEach: { index: each.index, of: each.of, item: String(itemText(each.value)) } } : {},
+    ...set2 ? {
+      use: {
+        set: set2.name,
+        ...set2.useName ? { name: set2.useName } : {},
+        child: set2.child,
+        of: set2.of
+      }
+    } : {}
   });
-  const last = set2 ? set2.child === set2.of - 1 : false;
+  const marked = set2 ? set2.doc.steps.findIndex((s) => s.useTests === true) : -1;
+  const useChecksThis = set2 ? set2.child === (marked >= 0 ? marked : set2.of - 1) : false;
   const layers = [];
   if (endpoint) {
     layers.push({
@@ -58286,51 +58769,93 @@ async function runRequest(input2) {
   layers.push({ script: "collection", label: "collection", ...partsOf2(input2.collection) });
   if (set2) layers.push({ script: "set", label: "set", ...partsOf2(set2.doc) });
   layers.push({ script: "step", label: "", before: step.before, tests: step.tests });
-  if (last && set2?.useTests) layers.push({ script: "use", label: "use", tests: set2.useTests });
+  if (useChecksThis && set2?.useTests)
+    layers.push({ script: "use", label: "use", tests: set2.useTests });
   const collection = folded(layers, input2.collection);
   const failed = (error62) => ({
     ...failedBeforeSending(step, collection, item, error62, startedHr, logs),
     ...withLogs()
   });
   let spec;
-  let scope;
+  let run;
+  let params;
   try {
-    const run = provided ?? (context ? await buildScope(context) : new VariableScope());
-    scope = params ? new ParamsScope(run, params) : run;
+    run = provided ?? (context ? await buildScope(context) : new VariableScope());
+    if (!set2)
+      params = input2.params ?? (input2.collection?.params ? resolveParams(input2.collection.params, {}, run) : void 0);
   } catch (cause) {
     return failed(interpolateError(cause));
   }
-  const shared = (adopt) => ({
+  const scopeOf = (known) => {
+    const own2 = known ? new ParamsScope(run, known) : run;
+    return each ? new OverlayScope(own2, /* @__PURE__ */ new Map([["item", itemText(each.value)]]), "forEach") : own2;
+  };
+  let scope = scopeOf(params);
+  const opens = set2 ? layers.findIndex((layer) => layer.script === "set") : 0;
+  const shared = (adopt, index) => ({
     assert: assert3,
-    ...params ? { params: adopt(params) } : {},
+    ...params && index >= opens ? { params: adopt(params) } : {},
+    ...each ? { item: adopt(each.value) } : {},
     ...endpoint ? { endpoint: adopt(endpointValues(endpoint, step, scope)) } : {}
   });
   const filenameOf = (layer, kind) => layer.label === "" ? kind : `${layer.label} ${kind}`;
-  for (const layer of layers) {
+  let edited = null;
+  for (const [index, layer] of layers.entries()) {
+    if (set2 && index === opens) {
+      try {
+        params = set2.params();
+      } catch (cause) {
+        return failed({ phase: "use", message: cause.message });
+      }
+      scope = scopeOf(params);
+    }
     const before = layer.before;
     const script = layer.script;
     if (before?.script) {
+      const shown = edited ?? toSentRequestSafely(step, collection);
+      let view;
       const error62 = await runScript(before.script, {
         phase: "pre-request",
         filename: filenameOf(layer, "before.script"),
         logs,
         ...checks ? { checks } : {},
-        globals: (adopt) => ({
-          ...shared(adopt),
-          gta: preRequestGta(scope),
-          req: requestView(toSentRequestSafely(step, collection), adopt)
-        })
+        globals: (adopt) => {
+          view = requestView(shown, adopt);
+          return { ...shared(adopt, index), gta: preRequestGta(scope, control), req: view };
+        }
       });
       if (error62) return failed({ ...error62, script });
+      try {
+        edited = changedRequest(shown, view, step.body) ?? edited;
+      } catch (cause) {
+        return failed({ phase: "pre-request", message: cause.message, script });
+      }
+      if (control.skip !== null) {
+        return {
+          item,
+          request: edited ?? toSentRequestSafely(step, collection),
+          response: null,
+          assertions: [],
+          ...withLogs(),
+          error: null,
+          status: "skipped",
+          skipped: { reason: control.skip },
+          durationMs: performance.now() - startedHr
+        };
+      }
     }
   }
   let payload;
   try {
     const prepared = await prepareRequest(
-      toSentRequest(step, collection),
+      edited ?? toSentRequest(step, collection),
       step.body,
       scope,
-      filesRoot(set2?.path ?? context?.collectionPath ?? itemPath)
+      await fileRoots(
+        step,
+        set2?.path ?? context?.collectionPath ?? itemPath,
+        context?.collectionPath ?? itemPath
+      )
     );
     spec = prepared.request;
     payload = prepared.payload;
@@ -58366,29 +58891,30 @@ async function runRequest(input2) {
   const session = new CheckSession({ response, scope });
   let testsError = null;
   try {
-    for (const layer of layers) {
+    for (const [index, layer] of layers.entries()) {
       const code = layer.tests;
       if (!code || testsError) continue;
       const pending = [];
-      const run = () => runScript(code, {
+      const run2 = () => runScript(code, {
         phase: "tests",
         filename: filenameOf(layer, "tests"),
         logs,
         ...checks ? { checks } : {},
         pending: () => pending,
         globals: (adopt) => ({
-          ...shared(adopt),
+          ...shared(adopt, index),
           gta: testsGta({
             session,
             scope,
             pending,
+            control,
             warn: (message) => logs.push({ level: "warn", phase: "tests", message })
           }),
           req: requestView(outcome.request, adopt),
           res: responseView(response, adopt)
         })
       });
-      const scriptError = layer.defaults ? await session.asDefaults(run) : await run();
+      const scriptError = layer.defaults ? await session.asDefaults(run2) : await run2();
       if (scriptError) testsError = { ...scriptError, script: layer.script };
     }
   } catch (cause) {
@@ -58411,8 +58937,37 @@ async function runRequest(input2) {
     durationMs: performance.now() - startedHr
   };
 }
-function filesRoot(file2) {
-  return file2 ? projectRootOf(file2) ?? path8.dirname(file2) : null;
+function changedRequest(shown, view, body) {
+  if (!view) return null;
+  let next = null;
+  if (view.body !== shown.body) {
+    if (typeof view.body !== "string") {
+      throw new Error(`req.body is the body's text; a script set it to ${typeof view.body}`);
+    }
+    const text = body?.json ?? body?.xml ?? body?.text ?? body?.graphql;
+    if (text === void 0) {
+      throw new Error(
+        "req.body can be changed for a json, xml, text or graphql body; a form, multipart or file body is built from its parts, and a step with no body has none to change"
+      );
+    }
+    next = { ...shown, body: view.body };
+  }
+  const was = Object.fromEntries(shown.headers.map((header) => [header.name, header.value]));
+  if (JSON.stringify(view.headers) !== JSON.stringify(was)) {
+    const headers = view.headers;
+    if (headers === null || typeof headers !== "object" || Array.isArray(headers)) {
+      throw new Error("req.headers is a map of header names to their values");
+    }
+    next = {
+      ...next ?? shown,
+      headers: Object.entries(headers).filter(([, value]) => value !== void 0 && value !== null).map(([name, value]) => ({ name, value: String(value) }))
+    };
+  }
+  return next;
+}
+async function fileRoots(step, file2, collection) {
+  if (!file2 || bodyFiles(step.body).length === 0) return null;
+  return fileRootsOf(file2, collection ?? file2);
 }
 function interpolateError(cause) {
   return {
@@ -58442,82 +58997,16 @@ function toSentRequestSafely(step, collection) {
 }
 
 // ../../packages/core/src/run/runCollection.ts
-import path10 from "node:path";
-
-// ../../packages/core/src/run/plan.ts
 import path9 from "node:path";
-async function planSteps(collection, collectionPath) {
-  const planned = [];
-  let project;
-  for (const [index, step] of collection.steps.entries()) {
-    if (!isUseStep(step)) {
-      planned.push({ kind: "request", index, step });
-      continue;
-    }
-    try {
-      if (!collectionPath)
-        throw new Error(`use: ${step.use} \u2014 save the collection in a project first`);
-      project ??= await projectOf(collectionPath);
-      const set2 = await resolveRequestSet(project.root, project.global, step.use);
-      checkWith(step.use, set2.doc, step.with ?? {});
-      if (set2.doc.steps.length === 0) throw new Error(`use: ${step.use} \u2014 the set has no steps`);
-      const planSet = {
-        name: step.use,
-        path: set2.path,
-        doc: set2.doc,
-        with: step.with ?? {},
-        useTests: step.tests
-      };
-      set2.doc.steps.forEach((child, number4) => {
-        planned.push({ kind: "request", index, step: child, set: planSet, child: number4 });
-      });
-    } catch (cause) {
-      planned.push({
-        kind: "broken",
-        index,
-        step,
-        error: { phase: "use", message: cause instanceof Error ? cause.message : String(cause) }
-      });
-    }
-  }
-  return planned;
-}
-async function projectOf(collectionPath) {
-  const root = projectRootOf(collectionPath) ?? path9.dirname(collectionPath);
-  const { global } = await readProject(root);
-  return { root, global };
-}
-function checkWith(name, set2, given) {
-  const params = set2.params ?? {};
-  const unknown2 = Object.keys(given).filter((key) => !(key in params));
-  if (unknown2.length > 0) {
-    const takes = Object.keys(params).join(", ") || "none";
-    throw new Error(`use: ${name} \u2014 it takes no ${unknown2.join(", ")} (it takes: ${takes})`);
-  }
-  const missing = Object.entries(params).filter(([key, spec]) => readParam(spec).required && !(key in given)).map(([key]) => key);
-  if (missing.length > 0) {
-    throw new Error(`use: ${name} \u2014 needs ${missing.join(", ")} in with:`);
-  }
-}
-function resolveParams(set2, scope) {
-  const params = {};
-  for (const [key, spec] of Object.entries(set2.doc.params ?? {})) {
-    const given = set2.with[key];
-    if (given !== void 0)
-      params[key] = typeof given === "string" ? interpolate(given, scope) : given;
-    else {
-      const fallback = readParam(spec).default;
-      if (fallback !== void 0) params[key] = fallback;
-    }
-  }
-  return params;
-}
-
-// ../../packages/core/src/run/runCollection.ts
 async function runCollection(options) {
   const { collection, collectionPath = null, context, signal, onResult, bail = false } = options;
+  const stage = options.stage ?? "steps";
   const startedHr = performance.now();
-  const scope = context ? await buildScope({ collectionExtends: collection.extends ?? null, ...context }) : new VariableScope();
+  const scope = context ? await buildScope({
+    collectionExtends: collection.extends ?? null,
+    ...context,
+    ...options.run ? { run: options.run } : {}
+  }) : withRun(new VariableScope(), options.run);
   const library = collectionPath ? await loadLibrary(collectionPath) : null;
   const checks = library?.checks ?? [];
   const endpoints = library?.endpoints ?? [];
@@ -58532,50 +59021,101 @@ async function runCollection(options) {
       baseError = { phase: "use", message: cause.message };
     }
   }
+  const running = stage === "steps" ? collection : { ...collection, steps: collection[stage] ?? [] };
   const own2 = collection.params ? selfAsSet(collection, collectionPath) : void 0;
-  const plan = await planSteps(collection, collectionPath);
+  const plan = await planSteps(running, collectionPath);
   const results = [];
-  let params = {};
-  for (const planned of plan) {
+  let params = null;
+  let unstarted = null;
+  const paramsOf = (using) => () => {
+    if (unstarted) throw new Error(unstarted.message);
+    if (!params) {
+      try {
+        params = resolveParams(using.doc.params, using.with, scope);
+      } catch (cause) {
+        unstarted = { phase: "use", message: `use: ${using.name} \u2014 ${cause.message}` };
+        throw new Error(unstarted.message);
+      }
+    }
+    return params;
+  };
+  let rest = null;
+  let attempted = 0;
+  const emit = (index, result) => {
+    const marked = stage === "steps" ? result : { ...result, stage };
+    results.push(marked);
+    onResult?.(index, marked);
+  };
+  const failing = (result) => result.status === "fail" || result.status === "error";
+  planning: for (const planned of plan) {
     if (signal?.aborted) break;
-    let result;
+    attempted++;
     if (baseError) {
-      result = brokenUse(planned.step, baseError, collectionPath);
-    } else if (planned.kind === "broken") {
-      result = brokenUse(planned.step, planned.error, collectionPath);
-    } else {
-      const set2 = planned.set ? positionOf(planned.set, planned.child ?? 0) : void 0;
-      if (set2 || own2) {
-        const starting = set2 ? set2.child === 0 : planned.index === 0;
-        if (starting) {
+      emit(planned.index, brokenUse(planned.step, baseError, collectionPath));
+      if (bail) break;
+      continue;
+    }
+    if (planned.kind === "broken") {
+      emit(planned.index, brokenUse(planned.step, planned.error, collectionPath));
+      if (bail) break;
+      continue;
+    }
+    const set2 = planned.set ? positionOf(planned.set, planned.child ?? 0) : void 0;
+    const inSet = set2 ? { use: useOf(set2) } : {};
+    if (rest !== null) {
+      emit(planned.index, { ...skipped(planned.step, rest, collectionPath), ...inSet });
+      continue;
+    }
+    if (set2 || own2) {
+      const using = set2?.planned ?? own2;
+      const starting = set2 ? set2.child === 0 : planned.index === 0;
+      if (starting) {
+        params = null;
+        unstarted = null;
+        if (!set2) {
           try {
-            params = resolveParams(set2?.planned ?? own2, scope);
-          } catch (cause) {
-            params = {};
-            result = brokenUse(
-              planned.step,
-              {
-                phase: "use",
-                message: `use: ${(set2?.planned ?? own2).name} \u2014 ${cause.message}`
-              },
-              collectionPath
-            );
-            results.push(result);
-            onResult?.(planned.index, result);
-            if (bail) break;
-            continue;
+            paramsOf(using)();
+          } catch {
           }
         }
       }
-      const gate = flagGate(collection, planned.index, planned.step, scope);
-      if (gate) {
-        result = gate(collectionPath);
-        results.push(result);
-        onResult?.(planned.index, result);
-        if (bail && result.status === "error") break;
+    }
+    const gate = flagGate(running, planned.index, planned.step, scope);
+    if (gate) {
+      const result = gate(collectionPath);
+      emit(planned.index, result);
+      if (bail && result.status === "error") break;
+      continue;
+    }
+    if (unstarted && (set2 || own2)) {
+      emit(planned.index, { ...brokenUse(planned.step, unstarted, collectionPath), ...inSet });
+      if (bail) break;
+      continue;
+    }
+    let items = [null];
+    if (planned.step.forEach !== void 0) {
+      try {
+        items = forEachItems(planned.step.forEach, scope).map((value) => ({ value }));
+      } catch (cause) {
+        const error62 = { phase: "forEach", message: cause.message };
+        emit(planned.index, { ...brokenUse(planned.step, error62, collectionPath), ...inSet });
+        if (bail) break;
+        continue;
+      }
+      if (items.length === 0) {
+        const reason = `forEach: ${planned.step.forEach} is an empty list`;
+        emit(planned.index, { ...skipped(planned.step, reason, collectionPath), ...inSet });
         continue;
       }
-      result = await runRequest({
+    }
+    for (const [index, each] of items.entries()) {
+      if (signal?.aborted) break planning;
+      if (rest !== null) {
+        emit(planned.index, { ...skipped(planned.step, rest, collectionPath), ...inSet });
+        continue;
+      }
+      const control = newStepControl();
+      const result = await runRequest({
         step: planned.step,
         collection,
         itemPath: collectionPath,
@@ -58583,45 +59123,76 @@ async function runCollection(options) {
         checks,
         endpoints,
         base: base2,
+        control,
         ...library ? { tls: library.tls } : {},
+        ...each ? { item: { value: each.value, index, of: items.length } } : {},
         ...set2 ? {
           set: {
             name: set2.planned.name,
+            ...set2.planned.useName ? { useName: set2.planned.useName } : {},
             path: set2.planned.path,
             doc: set2.planned.doc,
-            params,
+            params: paramsOf(set2.planned),
             child: set2.child,
             of: set2.of,
             useTests: set2.planned.useTests
           }
-        } : own2 ? { params } : {},
+        } : own2 ? { params: params ?? {} } : {},
         ...signal ? { signal } : {}
       });
+      emit(planned.index, result);
+      rest ??= control.rest;
+      if (bail && failing(result)) break planning;
     }
-    results.push(result);
-    onResult?.(planned.index, result);
-    if (bail && result.status !== "pass") break;
   }
+  const notBegun = plan.length - attempted;
   return {
-    total: plan.length,
+    total: results.length + notBegun,
     passed: results.filter((r) => r.status === "pass").length,
     failed: results.filter((r) => r.status === "fail").length,
     errored: results.filter((r) => r.status === "error").length,
-    // A step a feature flag skipped, and one never attempted, are both not run.
-    skipped: plan.length - results.length + results.filter((r) => r.status === "skipped").length,
+    // A step a feature flag or a script skipped, and one never begun, are all not run.
+    skipped: notBegun + results.filter((r) => r.status === "skipped").length,
     durationMs: performance.now() - startedHr,
     results
   };
 }
+function withRun(scope, run) {
+  if (!run) return scope;
+  const built = new VariableScope([{ source: "run", vars: Object.fromEntries(run.values) }]);
+  built.runValues = run.values;
+  built.runWide = run.wide === true;
+  return built;
+}
+function forEachItems(expression, scope) {
+  const value = interpolate(expression, scope);
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      if (Array.isArray(parsed)) return parsed;
+    } catch {
+    }
+  }
+  throw new Error(
+    `forEach: ${expression} is ${show(value)}, not a list; it needs a JSON array, such as ["a", "b"]`
+  );
+}
 function positionOf(planned, child) {
   return { planned, child, of: planned.doc.steps.length };
 }
+var useOf = (set2) => ({
+  set: set2.planned.name,
+  ...set2.planned.useName ? { name: set2.planned.useName } : {},
+  child: set2.child,
+  of: set2.of
+});
 function selfAsSet(collection, collectionPath) {
   return {
-    name: collectionPath ? path10.basename(collectionPath, ".yml") : collection.id ?? "set",
+    name: collectionPath ? path9.basename(collectionPath, ".yml") : collection.id ?? "set",
     path: collectionPath ?? "",
     // Its own before, tests, headers and settings already apply as the collection's.
     doc: { params: collection.params, steps: collection.steps },
+    useName: void 0,
     with: {},
     useTests: void 0
   };
@@ -58657,6 +59228,10 @@ function flagGate(collection, index, step, scope) {
     return (collectionPath) => brokenUse(step, { phase: "flags", message: cause.message }, collectionPath);
   }
 }
+var skipped = (step, reason, collectionPath) => ({
+  ...notRun(step, collectionPath),
+  skipped: { reason }
+});
 var notRun = (step, collectionPath) => ({
   item: { path: collectionPath, name: stepLabel(step), seq: null },
   request: {
@@ -58672,6 +59247,62 @@ var notRun = (step, collectionPath) => ({
   durationMs: 0
 });
 
+// ../../packages/core/src/run/runSuite.ts
+async function runSuite(options) {
+  const { collection, collectionPath = null, context, signal, bail = false, onResult } = options;
+  const values = /* @__PURE__ */ new Map();
+  const summaries = [];
+  const once = (stage, stopEarly) => runCollection({
+    collection,
+    collectionPath,
+    stage,
+    run: { values, wide: true },
+    ...context ? { context: { ...context, dataRow: null } } : {},
+    ...signal ? { signal } : {},
+    bail: stopEarly,
+    onResult: (index, result) => onResult?.(index, result, void 0)
+  });
+  let stopped = false;
+  if (collection.setup?.length) {
+    const setup = await once("setup", bail);
+    summaries.push(setup);
+    stopped = setup.failed + setup.errored > 0;
+  }
+  const rows = options.rows?.length ? options.rows : null;
+  const passes = rows ?? [null];
+  let unrun = 0;
+  for (const [i, row] of passes.entries()) {
+    if (stopped || signal?.aborted) {
+      unrun = (await planSteps(collection, collectionPath)).length * (passes.length - i);
+      break;
+    }
+    const iteration = rows && row ? { index: i + 1, of: rows.length, label: row.label } : void 0;
+    const summary = await runCollection({
+      collection,
+      collectionPath,
+      run: { values },
+      ...context ? {
+        context: row ? { ...context, dataRow: { source: row.source, vars: row.vars } } : context
+      } : {},
+      ...signal ? { signal } : {},
+      bail,
+      onResult: (index, result) => onResult?.(index, result, iteration)
+    });
+    summaries.push(summary);
+    if (bail && summary.failed + summary.errored > 0) stopped = true;
+  }
+  if (collection.teardown?.length && !signal?.aborted) summaries.push(await once("teardown", false));
+  return {
+    total: summaries.reduce((n, s) => n + s.total, 0) + unrun,
+    passed: summaries.reduce((n, s) => n + s.passed, 0),
+    failed: summaries.reduce((n, s) => n + s.failed, 0),
+    errored: summaries.reduce((n, s) => n + s.errored, 0),
+    skipped: summaries.reduce((n, s) => n + s.skipped, 0) + unrun,
+    durationMs: summaries.reduce((n, s) => n + s.durationMs, 0),
+    results: summaries.flatMap((s) => s.results)
+  };
+}
+
 // ../../packages/core/src/flags/resolve.ts
 import { spawn } from "node:child_process";
 var FLAG_COMMAND_TIMEOUT_MS = 6e4;
@@ -58860,41 +59491,29 @@ async function runJob(job) {
     const context = { collectionPath: loaded.path, environmentName: job.environment };
     const lines = await stepLines(loaded.path);
     const data = loaded.dataFile ? await readDataFile(loaded.dataFile.path) : null;
-    const rows = data ? data.rows : [null];
-    const summaries = [];
     const refs = [];
-    let unrun = 0;
-    for (const [i, row] of rows.entries()) {
-      const iteration = row ? { index: i + 1, of: rows.length, label: row.label } : void 0;
-      const summary2 = await runCollection({
-        collection,
-        collectionPath: loaded.path,
-        context: {
-          ...context,
-          flags: job.flags,
-          dataRow: row ? { source: `${path11.basename(data.path)} row ${i + 1}`, vars: row.values } : null
-        },
-        bail: job.bail,
-        onResult: (index) => {
-          const step = job.steps ? job.steps[index] ?? index : index;
-          refs.push({ index: step, line: lines[step] ?? null, ...iteration ? { iteration } : {} });
-        }
-      });
-      summaries.push(summary2);
-      if (job.bail && summary2.failed + summary2.errored > 0) {
-        unrun = summary2.total * (rows.length - i - 1);
-        break;
+    const summary = await runSuite({
+      collection,
+      collectionPath: loaded.path,
+      context: { ...context, flags: job.flags, dataRow: null },
+      rows: data ? data.rows.map((row, i) => ({
+        source: `${path10.basename(data.path)} row ${i + 1}`,
+        vars: row.values,
+        label: row.label
+      })) : null,
+      bail: job.bail,
+      // Each result reports the step it ran under — a use step's requests all under it.
+      onResult: (index, result, iteration) => {
+        const stage = result.stage;
+        const step = stage ? index : job.steps ? job.steps[index] ?? index : index;
+        refs.push({
+          index: step,
+          line: lines[stage ?? "steps"][step] ?? null,
+          ...stage ? { stage } : {},
+          ...iteration ? { iteration } : {}
+        });
       }
-    }
-    const summary = {
-      total: summaries.reduce((n, s) => n + s.total, 0) + unrun,
-      passed: summaries.reduce((n, s) => n + s.passed, 0),
-      failed: summaries.reduce((n, s) => n + s.failed, 0),
-      errored: summaries.reduce((n, s) => n + s.errored, 0),
-      skipped: summaries.reduce((n, s) => n + s.skipped, 0) + unrun,
-      durationMs: summaries.reduce((n, s) => n + s.durationMs, 0),
-      results: summaries.flatMap((s) => s.results)
-    };
+    });
     return {
       ok: true,
       summary: redact(summary, await secretsOf(context)),
@@ -58935,22 +59554,25 @@ function redact(value, secrets) {
   return walk(value);
 }
 async function stepLines(file2) {
+  const lines = { setup: [], steps: [], teardown: [] };
   try {
     const counter = new import_yaml7.LineCounter();
     const document = (0, import_yaml7.parseDocument)(await fs9.readFile(file2, "utf8"), { lineCounter: counter });
-    const steps = document.get("steps", true);
-    if (!steps || typeof steps !== "object" || !("items" in steps)) return [];
-    return steps.items.map(
-      (item) => item?.range ? counter.linePos(item.range[0]).line : null
-    );
+    const of = (key) => {
+      const list = document.get(key, true);
+      if (!list || typeof list !== "object" || !("items" in list)) return [];
+      return list.items.map(
+        (item) => item?.range ? counter.linePos(item.range[0]).line : null
+      );
+    };
+    return { setup: of("setup"), steps: of("steps"), teardown: of("teardown") };
   } catch {
-    return [];
+    return lines;
   }
 }
 
 export {
   __toESM,
-  require_dist,
   external_exports,
   TagSchema,
   stepsForTags,
@@ -58959,7 +59581,9 @@ export {
   samePath,
   relativePosix,
   environmentNames,
+  resultName,
   parseMarkdown,
+  require_dist,
   COLLECTIONS_DIR,
   SETTINGS_FILE,
   DOC_EXTENSION,
@@ -58968,6 +59592,7 @@ export {
   projectEnvironments,
   loadProjectCollections,
   loadProjectTls,
+  referenceProblems,
   resolveFlags,
   flagOverrides,
   unattempted,