@schwabyio/gta 0.9.0 → 0.10.0

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

@@ -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({
@@ -54996,25 +55058,32 @@ function decodeEntities(text) {
 }
 
 // ../../packages/core/src/model/path.ts
+var SEGMENT = (
+  // eslint-disable-next-line no-control-regex
+  /\[("(?:[^"\\\u0000-\u001f]|\\["\\/bfnrt]|\\u[0-9a-fA-F]{4})*")\]|([^.[\]]+)|\[(\d*)\]/g
+);
 function parsePath(path12) {
   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 path12.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 }];
@@ -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(),
@@ -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;
 }
@@ -57130,7 +57275,11 @@ async function prepareRequest(written, body, scope, root) {
     };
   }
   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
   };
 }
@@ -57160,9 +57309,20 @@ async function readBodyFile(root, path12, what) {
 
 // ../../packages/core/src/run/runRequest.ts
 import assert3 from "node:assert/strict";
-import path8 from "node:path";
+import path9 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 })}`;
@@ -57207,7 +57367,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 +57379,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 +57418,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 +57429,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 +57543,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;
@@ -57538,6 +57703,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 +57722,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(
@@ -57571,10 +57741,36 @@ var CheckSession = class {
     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 located = locate(body, segments, isNullCheck(matcher));
+    const result = checkBody(path12, 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(path12, matchers) {
+    const body = this.body_();
+    if (body === BODY_UNAVAILABLE) return null;
+    const segments = parsePath(path12);
+    const located = locate(body, segments, false);
+    const strict = checkBody(path12, segments, matchers.strict, located, this.context);
+    const lenient = checkBody(path12, 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) });
@@ -57614,9 +57810,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,13 +57985,30 @@ function variableName(value) {
   }
   return value;
 }
+function pathOf2(path12, what) {
+  if (typeof path12 === "string") return path12;
+  if (!Array.isArray(path12)) {
+    throw new GtaUsageError(
+      `${what} is a string, such as "user.name", or a list of keys, such as ["user", "name"]; got ${show(path12)}`
+    );
+  }
+  if (path12.length === 0) throw new GtaUsageError(`${what} is an empty list; it needs a key`);
+  return formatPath(
+    path12.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 path12 = pathOf2(entry.pathToProperty, "pathToProperty");
     if (valueKey === "compareValue") {
-      item[path12] = entry.compareValue;
+      const value = entry.compareValue;
+      item[path12] = isRegExp(value) ? { matches: value } : value;
       continue;
     }
     const matcher = xtestMatcher(valueKey in entry, entry[valueKey], entry.specialHandling);
@@ -57795,12 +58016,22 @@ function itemFrom(list, valueKey) {
   }
   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 path12 = pathOf2(entry.pathToProperty, "pathToProperty");
+  return { unorderedNot: [{ [path12]: 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 +58042,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",
@@ -57837,39 +58083,62 @@ function testsGta({ session, scope, pending, warn = () => {
       "expectResponseBodyToHaveProperty",
       (...args) => {
         const [path12, value, specialHandling] = args;
-        session.body(path12, xtestMatcher(args.length > 1, value, specialHandling));
+        session.body(
+          pathOf2(path12, "jsonPathToProperty"),
+          xtestMatcher(args.length > 1, value, specialHandling)
+        );
       }
     ),
     expectResponseBodyToHaveUnorderedArray: guarded(
       session,
       "expectResponseBodyToHaveUnorderedArray",
       (jsonPathToArray, validationList) => {
+        const path12 = 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(path12, { strict: { unordered }, lenient: lone });
+        else session.body(path12, { unordered });
       }
     ),
     expectResponseBodyToHaveUnorderedArrayNotThisItem: guarded(
       session,
       "expectResponseBodyToHaveUnorderedArrayNotThisItem",
       (jsonPathToArray, validationList) => {
+        const path12 = pathOf2(jsonPathToArray, "jsonPathToArray");
         const list = toList(validationList);
         const unorderedNot = list.every(isValidationEntry) ? [itemFrom(list, "compareValue")] : list;
-        session.body(jsonPathToArray, { unorderedNot });
+        session.body(path12, { 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 +58177,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 +58208,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
@@ -58165,7 +58456,127 @@ 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 };
+}
+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;
+    for (const planned of await planSteps({ ...collection, steps }, collectionPath)) {
+      if (planned.kind !== "broken") continue;
+      const stage = list === "steps" ? {} : { stage: list };
+      problems.push({ step: planned.index, ...stage, message: planned.error.message });
+    }
+  }
+  return problems;
+}
+
 // ../../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 +58616,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 +58630,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 +58667,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,7 +58698,8 @@ 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),
@@ -58294,40 +58707,64 @@ async function runRequest(input2) {
   });
   let spec;
   let scope;
+  let params;
   try {
     const run = provided ?? (context ? await buildScope(context) : new VariableScope());
-    scope = params ? new ParamsScope(run, params) : run;
+    params = set2?.params ?? input2.params ?? (input2.collection?.params ? resolveParams(input2.collection.params, {}, run) : void 0);
+    const own2 = params ? new ParamsScope(run, params) : run;
+    scope = each ? new OverlayScope(own2, /* @__PURE__ */ new Map([["item", itemText(each.value)]]), "forEach") : own2;
   } catch (cause) {
     return failed(interpolateError(cause));
   }
   const shared = (adopt) => ({
     assert: assert3,
     ...params ? { 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}`;
+  let edited = null;
   for (const layer of layers) {
     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), 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)
@@ -58382,6 +58819,7 @@ async function runRequest(input2) {
             session,
             scope,
             pending,
+            control,
             warn: (message) => logs.push({ level: "warn", phase: "tests", message })
           }),
           req: requestView(outcome.request, adopt),
@@ -58411,8 +58849,36 @@ async function runRequest(input2) {
     durationMs: performance.now() - startedHr
   };
 }
+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;
+}
 function filesRoot(file2) {
-  return file2 ? projectRootOf(file2) ?? path8.dirname(file2) : null;
+  return file2 ? projectRootOf(file2) ?? path9.dirname(file2) : null;
 }
 function interpolateError(cause) {
   return {
@@ -58443,81 +58909,15 @@ 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 +58932,88 @@ 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 unstarted = null;
+  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) {
-          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;
-          }
+      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) {
+        try {
+          params = resolveParams(using.doc.params, using.with, scope);
+          unstarted = null;
+        } catch (cause) {
+          params = {};
+          unstarted = { phase: "use", message: `use: ${using.name} \u2014 ${cause.message}` };
         }
       }
-      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;
+      }
+    }
+    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;
       }
-      result = await runRequest({
+      const control = newStepControl();
+      const result = await runRequest({
         step: planned.step,
         collection,
         itemPath: collectionPath,
@@ -58583,10 +59021,13 @@ 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,
@@ -58597,31 +59038,59 @@ async function runCollection(options) {
         } : own2 ? { 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",
     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 +59126,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 +59145,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 +59389,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: `${path11.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 +59452,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 +59479,9 @@ export {
   samePath,
   relativePosix,
   environmentNames,
+  resultName,
   parseMarkdown,
+  require_dist,
   COLLECTIONS_DIR,
   SETTINGS_FILE,
   DOC_EXTENSION,
@@ -58968,6 +59490,7 @@ export {
   projectEnvironments,
   loadProjectCollections,
   loadProjectTls,
+  referenceProblems,
   resolveFlags,
   flagOverrides,
   unattempted,