@schwabyio/gta 0.10.0 → 0.12.0

package/dist/chunks/{chunk-MZSHHPAQ.js → chunk-3NSHWS24.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}`);
     }
@@ -54864,6 +54864,35 @@ function placeholdersOf(pattern, url2) {
   return found;
 }
 
+// ../../packages/core/src/model/layers.ts
+var partsOf = (doc) => ({
+  headers: doc?.headers,
+  settings: doc?.settings,
+  before: doc?.before,
+  tests: doc?.tests
+});
+function requestLayers(sources) {
+  const layers = [];
+  if (sources.endpoint) {
+    layers.push({ kind: "endpoint-file", ...partsOf(sources.endpoint.file) });
+    layers.push({ kind: "endpoint", ...partsOf(sources.endpoint.step) });
+  }
+  if (sources.base) layers.push({ kind: "base", ...partsOf(sources.base) });
+  layers.push({ kind: "collection", ...partsOf(sources.collection) });
+  if (sources.set) layers.push({ kind: "set", ...partsOf(sources.set) });
+  layers.push({ kind: "step", before: sources.step.before, tests: sources.step.tests });
+  return layers;
+}
+function foldLayers(layers) {
+  let headers;
+  let settings = {};
+  for (const layer of layers) {
+    if (layer.headers) headers = mergeHeaders(headers, layer.headers);
+    settings = { ...settings, ...layer.settings };
+  }
+  return { headers, settings };
+}
+
 // ../../packages/core/src/paths.ts
 import fs from "node:fs/promises";
 import nodePath from "node:path";
@@ -54875,21 +54904,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) {
@@ -55062,9 +55091,9 @@ var SEGMENT = (
   // eslint-disable-next-line no-control-regex
   /\[("(?:[^"\\\u0000-\u001f]|\\["\\/bfnrt]|\\u[0-9a-fA-F]{4})*")\]|([^.[\]]+)|\[(\d*)\]/g
 );
-function parsePath(path12) {
+function parsePath(path11) {
   const segments = [];
-  for (const match of path12.matchAll(SEGMENT)) {
+  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" });
@@ -55089,16 +55118,16 @@ 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;
   }
@@ -55116,17 +55145,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;
@@ -55627,8 +55656,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("; ");
 }
 
@@ -56901,6 +56930,37 @@ async function readDotEnv(near) {
   }
 }
 
+// ../../packages/core/src/vars/secrets.ts
+async function secretValues(context) {
+  if (!context.environmentName) return [];
+  try {
+    const layer = await environmentLayer(context, context.environmentName);
+    return (layer.secrets ?? []).flatMap((name) => {
+      const value = layer.vars[name];
+      return value === void 0 || value === null || String(value) === "" ? [] : [[name, String(value)]];
+    }).sort((a, b) => b[1].length - a[1].length);
+  } catch {
+    return [];
+  }
+}
+function redact(value, secrets) {
+  if (secrets.length === 0) return value;
+  const walk = (node2) => {
+    if (typeof node2 === "string") {
+      return secrets.reduce(
+        (text, [name, secret]) => text.split(secret).join(`[secret: ${name}]`),
+        node2
+      );
+    }
+    if (Array.isArray(node2)) return node2.map(walk);
+    if (node2 !== null && typeof node2 === "object") {
+      return Object.fromEntries(Object.entries(node2).map(([key, inner]) => [key, walk(inner)]));
+    }
+    return node2;
+  };
+  return walk(value);
+}
+
 // ../../packages/core/src/http/client.ts
 var import_undici = __toESM(require_undici(), 1);
 import { Buffer as Buffer2 } from "node:buffer";
@@ -57058,7 +57118,7 @@ function statusTextFor(status) {
 // ../../packages/core/src/run/multipart.ts
 import { Buffer as Buffer3 } from "node:buffer";
 import { randomBytes } from "node:crypto";
-function partsOf(multipart) {
+function partsOf2(multipart) {
   return Object.entries(multipart).flatMap(
     ([name, field]) => (Array.isArray(field) ? field : [field]).map((part) => [name, part])
   );
@@ -57178,7 +57238,7 @@ function toBody(body) {
     };
   }
   if (body.multipart !== void 0) {
-    const parts = partsOf(body.multipart).map(
+    const parts = partsOf2(body.multipart).map(
       ([name, part]) => typeof part === "string" ? { name, value: part } : "file" in part ? {
         name,
         value: "",
@@ -57219,7 +57279,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),
@@ -57235,19 +57296,19 @@ async function prepareRequest(written, body, scope, root) {
   }
   if (body?.multipart !== void 0) {
     const parts = [];
-    for (const [field, part] of partsOf(body.multipart)) {
+    for (const [field, part] of partsOf2(body.multipart)) {
       const name = resolve(field);
       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({
@@ -57262,14 +57323,14 @@ 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
     };
@@ -57283,33 +57344,78 @@ async function prepareRequest(written, body, scope, root) {
     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 partsOf2(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 path9 from "node:path";
 
 // ../../packages/core/src/assert/evaluate.ts
 function locate(root, segments, nullAlong) {
@@ -57341,9 +57447,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) {
@@ -57643,19 +57749,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];
@@ -57674,16 +57780,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));
   }
 }
 
@@ -57737,12 +57843,12 @@ 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 segments = parsePath(path11);
     const located = locate(body, segments, isNullCheck(matcher));
-    const result = checkBody(path12, segments, matcher, located, {
+    const result = checkBody(path11, segments, matcher, located, {
       ...this.context,
       claimed: (arrayPath) => this.claimsOn(arrayPath)
     });
@@ -57755,13 +57861,13 @@ var CheckSession = class {
    * 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) {
+  bodyByStrictness(path11, matchers) {
     const body = this.body_();
     if (body === BODY_UNAVAILABLE) return null;
-    const segments = parsePath(path12);
+    const segments = parsePath(path11);
     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 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;
@@ -57772,8 +57878,8 @@ var CheckSession = class {
     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) {
@@ -57985,16 +58091,16 @@ function variableName(value) {
   }
   return value;
 }
-function pathOf2(path12, what) {
-  if (typeof path12 === "string") return path12;
-  if (!Array.isArray(path12)) {
+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(path12)}`
+      `${what} is a string, such as "user.name", or a list of keys, such as ["user", "name"]; got ${show(path11)}`
     );
   }
-  if (path12.length === 0) throw new GtaUsageError(`${what} is an empty list; it needs a key`);
+  if (path11.length === 0) throw new GtaUsageError(`${what} is an empty list; it needs a key`);
   return formatPath(
-    path12.map((key) => {
+    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)}`);
@@ -58005,14 +58111,14 @@ var isValidationEntry = (value) => value !== null && typeof value === "object" &
 function itemFrom(list, valueKey) {
   const item = {};
   for (const entry of list) {
-    const path12 = pathOf2(entry.pathToProperty, "pathToProperty");
+    const path11 = pathOf2(entry.pathToProperty, "pathToProperty");
     if (valueKey === "compareValue") {
       const value = entry.compareValue;
-      item[path12] = isRegExp(value) ? { matches: value } : value;
+      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;
 }
@@ -58021,8 +58127,8 @@ function loneNotThisValue(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 }] };
+  const path11 = pathOf2(entry.pathToProperty, "pathToProperty");
+  return { unorderedNot: [{ [path11]: isRegExp(value) ? { matches: value } : value }] };
 }
 function toList(validationList) {
   if (!Array.isArray(validationList)) {
@@ -58082,9 +58188,9 @@ function testsGta({
       session,
       "expectResponseBodyToHaveProperty",
       (...args) => {
-        const [path12, value, specialHandling] = args;
+        const [path11, value, specialHandling] = args;
         session.body(
-          pathOf2(path12, "jsonPathToProperty"),
+          pathOf2(path11, "jsonPathToProperty"),
           xtestMatcher(args.length > 1, value, specialHandling)
         );
       }
@@ -58093,22 +58199,22 @@ function testsGta({
       session,
       "expectResponseBodyToHaveUnorderedArray",
       (jsonPathToArray, validationList) => {
-        const path12 = pathOf2(jsonPathToArray, "jsonPathToArray");
+        const path11 = pathOf2(jsonPathToArray, "jsonPathToArray");
         const list = toList(validationList);
         const unordered = list.every(isValidationEntry) ? [itemFrom(list, "expectedValue")] : list;
         const lone = loneNotThisValue(list);
-        if (lone) session.bodyByStrictness(path12, { strict: { unordered }, lenient: lone });
-        else session.body(path12, { unordered });
+        if (lone) session.bodyByStrictness(path11, { strict: { unordered }, lenient: lone });
+        else session.body(path11, { unordered });
       }
     ),
     expectResponseBodyToHaveUnorderedArrayNotThisItem: guarded(
       session,
       "expectResponseBodyToHaveUnorderedArrayNotThisItem",
       (jsonPathToArray, validationList) => {
-        const path12 = pathOf2(jsonPathToArray, "jsonPathToArray");
+        const path11 = pathOf2(jsonPathToArray, "jsonPathToArray");
         const list = toList(validationList);
         const unorderedNot = list.every(isValidationEntry) ? [itemFrom(list, "compareValue")] : list;
-        session.body(path12, { unorderedNot });
+        session.body(path11, { unorderedNot });
       }
     ),
     ignoreResponseBodyProperty: guarded(
@@ -58268,6 +58374,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;
   }
@@ -58500,6 +58607,10 @@ async function projectOf(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));
@@ -58566,25 +58677,39 @@ async function referenceProblems(collection, collectionPath) {
   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") continue;
-      const stage = list === "steps" ? {} : { stage: list };
-      problems.push({ step: planned.index, ...stage, message: planned.error.message });
+      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 = {};
-  for (const layer of layers) {
-    if (layer.script === "step" || layer.script === "use") continue;
-    if (layer.headers) headers = mergeHeaders(headers, layer.headers);
-    settings = { ...settings, ...layer.settings };
-  }
+  const { headers, settings } = foldLayers(layers);
   return {
     ...collection,
     steps: [],
@@ -58592,12 +58717,15 @@ function folded(layers, collection) {
     ...Object.keys(settings).length > 0 ? { settings } : {}
   };
 }
-var partsOf2 = (doc) => ({
-  headers: doc?.headers,
-  settings: doc?.settings,
-  before: doc?.before,
-  tests: doc?.tests
-});
+var ROLES = {
+  // An endpoint base's checks are defaults: the step's own of the same thing replace them.
+  "endpoint-file": { script: "endpoint", label: "endpoint file", defaults: true },
+  endpoint: { script: "endpoint", label: "endpoint", defaults: true },
+  base: { script: "base", label: "base" },
+  collection: { script: "collection", label: "collection" },
+  set: { script: "set", label: "set" },
+  step: { script: "step", label: "" }
+};
 var needsLibrary = (input2) => input2.checks === void 0 || input2.endpoints === void 0 || input2.tls === void 0 || input2.base === void 0 && input2.collection?.extends !== void 0;
 function endpointFor(step, endpoints) {
   if (isUseStep(step) || endpoints.length === 0) return null;
@@ -58679,25 +58807,13 @@ async function runRequest(input2) {
   });
   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({
-      script: "endpoint",
-      label: "endpoint file",
-      defaults: true,
-      ...partsOf2(endpoint.file)
-    });
-    layers.push({
-      script: "endpoint",
-      label: "endpoint",
-      defaults: true,
-      ...partsOf2(endpoint.step)
-    });
-  }
-  if (base2) layers.push({ script: "base", label: "base", ...partsOf2(base2) });
-  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 });
+  const layers = requestLayers({
+    endpoint,
+    base: base2,
+    collection: input2.collection,
+    set: set2?.doc,
+    step
+  }).map(({ kind, ...parts }) => ({ ...ROLES[kind], ...parts }));
   if (useChecksThis && set2?.useTests)
     layers.push({ script: "use", label: "use", tests: set2.useTests });
   const collection = folded(layers, input2.collection);
@@ -58706,25 +58822,38 @@ async function runRequest(input2) {
     ...withLogs()
   });
   let spec;
-  let scope;
+  let run;
   let params;
   try {
-    const run = provided ?? (context ? await buildScope(context) : new VariableScope());
-    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;
+    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}`;
   let edited = null;
-  for (const layer of layers) {
+  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) {
@@ -58737,7 +58866,7 @@ async function runRequest(input2) {
         ...checks ? { checks } : {},
         globals: (adopt) => {
           view = requestView(shown, adopt);
-          return { ...shared(adopt), gta: preRequestGta(scope, control), req: view };
+          return { ...shared(adopt, index), gta: preRequestGta(scope, control), req: view };
         }
       });
       if (error62) return failed({ ...error62, script });
@@ -58767,7 +58896,11 @@ async function runRequest(input2) {
       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;
@@ -58803,18 +58936,18 @@ 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,
@@ -58826,7 +58959,7 @@ async function runRequest(input2) {
           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) {
@@ -58877,8 +59010,9 @@ function changedRequest(shown, view, body) {
   }
   return next;
 }
-function filesRoot(file2) {
-  return file2 ? projectRootOf(file2) ?? path9.dirname(file2) : null;
+async function fileRoots(step, file2, collection) {
+  if (!file2 || bodyFiles(step.body).length === 0) return null;
+  return fileRootsOf(file2, collection ?? file2);
 }
 function interpolateError(cause) {
   return {
@@ -58908,7 +59042,7 @@ function toSentRequestSafely(step, collection) {
 }
 
 // ../../packages/core/src/run/runCollection.ts
-import path10 from "node:path";
+import path9 from "node:path";
 async function runCollection(options) {
   const { collection, collectionPath = null, context, signal, onResult, bail = false } = options;
   const stage = options.stage ?? "steps";
@@ -58936,8 +59070,20 @@ async function runCollection(options) {
   const own2 = collection.params ? selfAsSet(collection, collectionPath) : void 0;
   const plan = await planSteps(running, collectionPath);
   const results = [];
-  let params = {};
+  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) => {
@@ -58969,12 +59115,13 @@ async function runCollection(options) {
       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}` };
+        params = null;
+        unstarted = null;
+        if (!set2) {
+          try {
+            paramsOf(using)();
+          } catch {
+          }
         }
       }
     }
@@ -59030,12 +59177,12 @@ async function runCollection(options) {
             ...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);
@@ -59086,7 +59233,7 @@ var useOf = (set2) => ({
 });
 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 },
@@ -59395,7 +59542,7 @@ async function runJob(job) {
       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}`,
+        source: `${path10.basename(data.path)} row ${i + 1}`,
         vars: row.values,
         label: row.label
       })) : null,
@@ -59414,7 +59561,7 @@ async function runJob(job) {
     });
     return {
       ok: true,
-      summary: redact(summary, await secretsOf(context)),
+      summary: redact(summary, await secretValues(context)),
       steps: refs,
       data: loaded.dataFile ? { file: `${COLLECTIONS_DIR}/${loaded.dataFile.relativePath}`, rows: loaded.dataFile.rows } : null
     };
@@ -59422,35 +59569,6 @@ async function runJob(job) {
     return { ok: false, message: cause instanceof Error ? cause.message : String(cause) };
   }
 }
-async function secretsOf(context) {
-  if (!context.environmentName) return [];
-  try {
-    const layer = await environmentLayer(context, context.environmentName);
-    return (layer.secrets ?? []).flatMap((name) => {
-      const value = layer.vars[name];
-      return value === void 0 || value === null || String(value) === "" ? [] : [[name, String(value)]];
-    }).sort((a, b) => b[1].length - a[1].length);
-  } catch {
-    return [];
-  }
-}
-function redact(value, secrets) {
-  if (secrets.length === 0) return value;
-  const walk = (node2) => {
-    if (typeof node2 === "string") {
-      return secrets.reduce(
-        (text, [name, secret]) => text.split(secret).join(`[secret: ${name}]`),
-        node2
-      );
-    }
-    if (Array.isArray(node2)) return node2.map(walk);
-    if (node2 !== null && typeof node2 === "object") {
-      return Object.fromEntries(Object.entries(node2).map(([key, inner]) => [key, walk(inner)]));
-    }
-    return node2;
-  };
-  return walk(value);
-}
 async function stepLines(file2) {
   const lines = { setup: [], steps: [], teardown: [] };
   try {