@piyushdoorwar/yamlet 1.0.1

package/dist/yamlet.js

@@ -0,0 +1,3607 @@
+#!/usr/bin/env node
+
+// cli/src/index.ts
+import { existsSync as existsSync4, readFileSync, statSync as statSync2, writeFileSync } from "node:fs";
+import { basename, resolve } from "node:path";
+
+// core/src/requestExecutor.ts
+import { existsSync, promises as fs } from "node:fs";
+import { STATUS_CODES } from "node:http";
+import path from "node:path";
+import { performance } from "node:perf_hooks";
+import { Agent, FormData, request as request2 } from "undici";
+
+// core/src/cookieJar.ts
+function parseSetCookie(header) {
+  const parts = header.split(";");
+  const first = parts.shift() ?? "";
+  const eq = first.indexOf("=");
+  if (eq <= 0) return void 0;
+  const cookie = { name: first.slice(0, eq).trim(), value: first.slice(eq + 1).trim() };
+  if (!cookie.name) return void 0;
+  if (cookie.value.length >= 2 && cookie.value.startsWith('"') && cookie.value.endsWith('"')) cookie.value = cookie.value.slice(1, -1);
+  let maxAge;
+  for (const raw of parts) {
+    const i = raw.indexOf("=");
+    const key = (i >= 0 ? raw.slice(0, i) : raw).trim().toLowerCase();
+    const val = i >= 0 ? raw.slice(i + 1).trim() : "";
+    switch (key) {
+      case "domain":
+        if (val) cookie.domain = val.replace(/^\./, "").toLowerCase();
+        break;
+      case "path":
+        if (val.startsWith("/")) cookie.path = val;
+        break;
+      case "expires": {
+        const t = Date.parse(val);
+        if (!Number.isNaN(t)) cookie.expires = new Date(t).toISOString();
+        break;
+      }
+      case "max-age": {
+        const n = parseInt(val, 10);
+        if (!Number.isNaN(n)) maxAge = n;
+        break;
+      }
+      case "secure":
+        cookie.secure = true;
+        break;
+      case "httponly":
+        cookie.httpOnly = true;
+        break;
+      case "samesite":
+        cookie.sameSite = val;
+        break;
+    }
+  }
+  if (maxAge !== void 0) cookie.expires = new Date(Date.now() + maxAge * 1e3).toISOString();
+  return cookie;
+}
+function defaultPath(pathname) {
+  if (!pathname.startsWith("/")) return "/";
+  const last = pathname.lastIndexOf("/");
+  return last <= 0 ? "/" : pathname.slice(0, last);
+}
+function domainMatches(host, domain) {
+  return host === domain || host.endsWith("." + domain) && !/^\d+\.\d+\.\d+\.\d+$/.test(host);
+}
+function pathMatches(reqPath, cookiePath) {
+  if (reqPath === cookiePath) return true;
+  if (!reqPath.startsWith(cookiePath)) return false;
+  return cookiePath.endsWith("/") || reqPath[cookiePath.length] === "/";
+}
+function parseUrl(url) {
+  try {
+    return new URL(url);
+  } catch {
+    return void 0;
+  }
+}
+var CookieJar = class _CookieJar {
+  cookies = [];
+  /** Stores cookies from a response's Set-Cookie headers. */
+  setFromResponse(url, setCookie) {
+    const u = parseUrl(url);
+    if (!u) return;
+    const host = u.hostname.toLowerCase();
+    for (const header of setCookie) {
+      const c = parseSetCookie(header);
+      if (!c) continue;
+      let domain = host;
+      let hostOnly = true;
+      if (c.domain) {
+        if (!domainMatches(host, c.domain)) continue;
+        domain = c.domain;
+        hostOnly = false;
+      }
+      const stored = {
+        name: c.name,
+        value: c.value,
+        domain,
+        path: c.path ?? defaultPath(u.pathname),
+        hostOnly,
+        secure: !!c.secure,
+        httpOnly: !!c.httpOnly,
+        sameSite: c.sameSite,
+        expires: c.expires,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const idx = this.cookies.findIndex((x) => x.name === stored.name && x.domain === stored.domain && x.path === stored.path);
+      if (idx >= 0) stored.createdAt = this.cookies[idx].createdAt;
+      const expired = stored.expires !== void 0 && Date.parse(stored.expires) <= Date.now();
+      if (idx >= 0) this.cookies.splice(idx, 1);
+      if (!expired) this.cookies.push(stored);
+    }
+  }
+  /** Cookies that apply to a request URL, longest path first. */
+  cookiesFor(url) {
+    const u = parseUrl(url);
+    if (!u) return [];
+    this.purgeExpired();
+    const host = u.hostname.toLowerCase();
+    const secure = u.protocol === "https:" || u.protocol === "wss:";
+    return this.cookies.filter((c) => c.hostOnly ? host === c.domain : domainMatches(host, c.domain)).filter((c) => pathMatches(u.pathname || "/", c.path)).filter((c) => !c.secure || secure || host === "localhost" || host === "127.0.0.1").sort((a, b) => b.path.length - a.path.length || a.createdAt.localeCompare(b.createdAt));
+  }
+  cookieHeaderFor(url) {
+    const list = this.cookiesFor(url);
+    return list.length ? list.map((c) => `${c.name}=${c.value}`).join("; ") : void 0;
+  }
+  list() {
+    this.purgeExpired();
+    return this.cookies.map((c) => ({ ...c }));
+  }
+  /** Adds or replaces a cookie directly (e.g. from a cookie manager UI). */
+  set(cookie) {
+    const domain = cookie.domain.replace(/^\./, "").toLowerCase();
+    this.remove(domain, cookie.name, cookie.path);
+    this.cookies.push({ ...cookie, domain, hostOnly: cookie.hostOnly ?? false, createdAt: cookie.createdAt ?? (/* @__PURE__ */ new Date()).toISOString() });
+  }
+  remove(domain, name, path4) {
+    const d = domain.replace(/^\./, "").toLowerCase();
+    this.cookies = this.cookies.filter((c) => !(c.domain === d && c.name === name && (path4 === void 0 || c.path === path4)));
+  }
+  clear(domain) {
+    if (domain === void 0) this.cookies = [];
+    else {
+      const d = domain.replace(/^\./, "").toLowerCase();
+      this.cookies = this.cookies.filter((c) => c.domain !== d);
+    }
+  }
+  toJSON() {
+    return { cookies: this.list() };
+  }
+  static fromJSON(json) {
+    const jar = new _CookieJar();
+    const list = Array.isArray(json) ? json : json?.cookies;
+    if (Array.isArray(list)) {
+      for (const c of list) {
+        if (c && typeof c === "object" && typeof c.name === "string" && typeof c.domain === "string") {
+          jar.cookies.push({
+            name: c.name,
+            value: String(c.value ?? ""),
+            domain: c.domain.replace(/^\./, "").toLowerCase(),
+            path: typeof c.path === "string" ? c.path : "/",
+            hostOnly: !!c.hostOnly,
+            secure: !!c.secure,
+            httpOnly: !!c.httpOnly,
+            sameSite: c.sameSite,
+            expires: c.expires,
+            createdAt: c.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+      }
+    }
+    jar.purgeExpired();
+    return jar;
+  }
+  purgeExpired() {
+    const now = Date.now();
+    this.cookies = this.cookies.filter((c) => c.expires === void 0 || Date.parse(c.expires) > now);
+  }
+};
+
+// core/src/models.ts
+function newId() {
+  return globalThis.crypto.randomUUID();
+}
+function defaultOAuth2() {
+  return {
+    grantType: "client_credentials",
+    accessToken: "",
+    refreshToken: "",
+    headerPrefix: "Bearer",
+    accessTokenUrl: "",
+    authUrl: "",
+    clientId: "",
+    clientSecret: "",
+    scope: "",
+    redirectUri: "",
+    username: "",
+    password: "",
+    addTokenTo: "header",
+    clientAuthentication: "basic",
+    challengeAlgorithm: "S256"
+  };
+}
+function defaultAuth(type = "inherit") {
+  return {
+    type,
+    token: "",
+    username: "",
+    password: "",
+    apiKeyName: "",
+    apiKeyValue: "",
+    apiKeyIn: "header",
+    cookie: "",
+    oauth2: defaultOAuth2()
+  };
+}
+function defaultBody() {
+  return { type: "none", raw: "", fields: [], graphqlQuery: "", graphqlVariables: "", binaryFile: "" };
+}
+function defaultSettings() {
+  return { timeoutMs: 0, followRedirects: true, skipSslVerification: false };
+}
+function newRequest(partial = {}) {
+  return {
+    id: newId(),
+    name: "New Request",
+    method: "GET",
+    url: "",
+    headers: [],
+    queryParams: [],
+    pathVariables: [],
+    body: defaultBody(),
+    auth: defaultAuth("inherit"),
+    variables: [],
+    description: "",
+    preRequestScript: "",
+    postResponseScript: "",
+    settings: defaultSettings(),
+    examples: [],
+    order: 0,
+    ...partial
+  };
+}
+function newFolder(partial = {}) {
+  return { id: newId(), name: "New Folder", folders: [], requests: [], order: 0, ...partial };
+}
+function newCollection(partial = {}) {
+  return {
+    id: newId(),
+    name: "New Collection",
+    folders: [],
+    requests: [],
+    variables: [],
+    auth: defaultAuth("none"),
+    preRequestScript: "",
+    postResponseScript: "",
+    order: 0,
+    ...partial
+  };
+}
+function newEnvironment(partial = {}) {
+  return { id: newId(), name: "New Environment", variables: [], ...partial };
+}
+var YAMLET_USER_AGENT = "Yamlet/1.0.0";
+
+// core/src/oauth2.ts
+import { request } from "undici";
+function parseTokenBody(text, contentType) {
+  let raw;
+  if (contentType.includes("x-www-form-urlencoded") || !text.trim().startsWith("{") && text.includes("access_token=")) {
+    raw = Object.fromEntries(new URLSearchParams(text));
+  } else {
+    try {
+      raw = JSON.parse(text);
+    } catch {
+      throw new Error(`Token endpoint returned a non-JSON response: ${text.slice(0, 200)}`);
+    }
+  }
+  const o = raw ?? {};
+  const accessToken = typeof o.access_token === "string" ? o.access_token : "";
+  if (!accessToken) {
+    const err = o.error ? `${o.error}${o.error_description ? `: ${o.error_description}` : ""}` : "no access_token in response";
+    throw new Error(`Token request failed: ${err}`);
+  }
+  const expires = Number(o.expires_in);
+  const result = { accessToken, raw };
+  if (typeof o.refresh_token === "string" && o.refresh_token) result.refreshToken = o.refresh_token;
+  if (typeof o.token_type === "string" && o.token_type) result.tokenType = o.token_type;
+  if (Number.isFinite(expires) && expires > 0) result.expiresIn = expires;
+  return result;
+}
+async function requestToken(cfg, resolve2, form, opts = {}) {
+  const url = resolve2(cfg.accessTokenUrl).trim();
+  if (!url) throw new Error("OAuth 2.0 access token URL is not set");
+  const clientId = resolve2(cfg.clientId);
+  const clientSecret = resolve2(cfg.clientSecret);
+  const headers = {
+    "content-type": "application/x-www-form-urlencoded",
+    accept: "application/json"
+  };
+  const body = new URLSearchParams(form);
+  if (cfg.clientAuthentication === "body") {
+    if (clientId) body.set("client_id", clientId);
+    if (clientSecret) body.set("client_secret", clientSecret);
+  } else if (clientId || clientSecret) {
+    headers.authorization = `Basic ${Buffer.from(`${clientId}:${clientSecret}`, "utf8").toString("base64")}`;
+  }
+  const res = await request(url, {
+    method: "POST",
+    headers,
+    body: body.toString(),
+    dispatcher: opts.dispatcher,
+    signal: opts.signal
+  });
+  const text = await res.body.text();
+  if (res.statusCode < 200 || res.statusCode >= 300) {
+    throw new Error(`Token request failed (${res.statusCode}): ${text.slice(0, 500)}`);
+  }
+  const ct = res.headers["content-type"];
+  return parseTokenBody(text, String(Array.isArray(ct) ? ct[0] : ct ?? ""));
+}
+async function fetchToken(cfg, resolve2, opts) {
+  const form = {};
+  if (cfg.grantType === "password") {
+    form.grant_type = "password";
+    form.username = resolve2(cfg.username);
+    form.password = resolve2(cfg.password);
+  } else if (cfg.grantType === "client_credentials") {
+    form.grant_type = "client_credentials";
+  } else {
+    throw new Error("The authorization-code grant needs the browser flow; use buildAuthorizationUrl + exchangeAuthorizationCode");
+  }
+  const scope = resolve2(cfg.scope).trim();
+  if (scope) form.scope = scope;
+  return requestToken(cfg, resolve2, form, opts);
+}
+var cache = /* @__PURE__ */ new Map();
+var EXPIRY_MARGIN_MS = 3e4;
+var DEFAULT_LIFETIME_S = 3600;
+function cacheKey(cfg, resolve2) {
+  return [cfg.grantType, resolve2(cfg.accessTokenUrl), resolve2(cfg.clientId), resolve2(cfg.scope), resolve2(cfg.username), cfg.clientAuthentication].join("|");
+}
+function canFetchAutomatically(cfg, resolve2) {
+  if (cfg.grantType !== "client_credentials" && cfg.grantType !== "password") return false;
+  if (!resolve2(cfg.accessTokenUrl).trim() || !resolve2(cfg.clientId).trim()) return false;
+  return cfg.grantType !== "password" || !!resolve2(cfg.username).trim();
+}
+async function getCachedToken(cfg, resolve2, opts) {
+  const key = cacheKey(cfg, resolve2);
+  const hit = cache.get(key);
+  if (hit && hit.expiresAt - EXPIRY_MARGIN_MS > Date.now()) return hit.token;
+  const token = await fetchToken(cfg, resolve2, opts);
+  cache.set(key, { token, expiresAt: Date.now() + (token.expiresIn ?? DEFAULT_LIFETIME_S) * 1e3 });
+  return token;
+}
+
+// core/src/dynamicVariables.ts
+var rnd = (maxExclusive) => Math.floor(Math.random() * maxExclusive);
+var between = (min, maxExclusive) => min + rnd(maxExclusive - min);
+var pick = (pool) => pool[rnd(pool.length)];
+var randomString = (alphabet, length) => Array.from({ length }, () => alphabet[rnd(alphabet.length)]).join("");
+var capitalize = (s) => s ? s[0].toUpperCase() + s.slice(1) : s;
+var times = (n, fn) => Array.from({ length: n }, fn);
+function uuid() {
+  const c = globalThis.crypto;
+  if (c?.randomUUID) return c.randomUUID();
+  const hex = randomString("0123456789abcdef", 32).split("");
+  hex[12] = "4";
+  hex[16] = "89ab"[rnd(4)];
+  const h = hex.join("");
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+}
+function jsDate(d) {
+  return d.toString().replace(/\s*\(.*\)\s*$/, "");
+}
+var ALPHA_NUMERIC = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+var ALPHA_NUMERIC_UPPER = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+var UPPER = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var COLORS = ["red", "green", "blue", "yellow", "purple", "fuchsia", "grey", "white", "black", "orange", "cyan", "lime"];
+var ABBREVIATIONS = ["SQL", "PCI", "JSON", "HTTP", "TCP", "SSL", "API", "XML", "HDD", "SSD", "RAM", "USB"];
+var LOCALES = ["ny", "sr", "si", "en", "fr", "de", "es", "it", "pt", "ja", "zh", "ru"];
+var USER_AGENTS = [
+  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0 Safari/537.36",
+  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15",
+  "Mozilla/5.0 (X11; Linux x86_64; rv:121.0) Gecko/20100101 Firefox/121.0",
+  "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148"
+];
+var FIRST_NAMES = ["Ethan", "Chandler", "Megane", "Connie", "Sylvan", "Jonathon", "Pablo", "Ruthe", "Iva", "Talon", "Quinten", "Casey", "Alia", "Lottie", "Jarrell", "Gwen", "Jaden", "Donnell"];
+var LAST_NAMES = ["Schaden", "Schneider", "Willms", "Runolfsdottir", "Fay", "Kunze", "Gutkowski", "Smitham", "Kovacek", "Kerluke", "Johns", "Grady", "Armando", "Trevor", "Gracie"];
+var JOB_AREAS = ["Mobility", "Intranet", "Configuration", "Operations", "Marketing", "Optimization", "Accountability", "Functionality", "Identity"];
+var JOB_DESCRIPTORS = ["Forward", "Corporate", "Senior", "International", "Lead", "Global", "Dynamic", "Regional", "Principal", "Chief"];
+var JOB_TYPES = ["Supervisor", "Manager", "Coordinator", "Director", "Engineer", "Specialist", "Liaison", "Analyst", "Administrator", "Officer"];
+var CITIES = ["Spinkahaven", "Korbinburgh", "Lefflerport", "New Audreanne", "Port Domenica", "Lake Gabe", "East Citlalli", "South Anibal"];
+var COUNTRIES = ["Lao People's Democratic Republic", "Kazakhstan", "Austria", "Cape Verde", "Moldova", "Chad", "Norway", "Brazil", "Japan", "Kenya"];
+var COUNTRY_CODES = ["CV", "MD", "TD", "US", "GB", "DE", "FR", "JP", "BR", "IN", "KE", "AU"];
+var CURRENCY_CODES = ["CDF", "ZMK", "GNF", "USD", "EUR", "GBP", "JPY", "INR", "BRL", "AUD"];
+var CURRENCY_NAMES = ["CFP Franc", "Cordoba Oro", "Pound Sterling", "US Dollar", "Euro", "Japanese Yen", "Indian Rupee", "Brazilian Real"];
+var BS_ADJECTIVES = ["viral", "24/7", "24/365", "back-end", "next-generation", "value-added", "frictionless", "robust"];
+var BS_BUZZ = ["repurpose", "harness", "transition", "leverage", "synergize", "incentivize", "morph", "engage"];
+var BS_NOUNS = ["e-services", "markets", "interfaces", "schemas", "channels", "paradigms", "deliverables", "bandwidth"];
+var CATCH_ADJECTIVES = ["Future-proofed", "Self-enabling", "Business-focused", "Down-sized", "Streamlined", "Synergistic", "Open-architected"];
+var CATCH_DESCRIPTORS = ["heuristic", "bandwidth-monitored", "needs-based", "homogeneous", "client-server", "actuating", "executive"];
+var CATCH_NOUNS = ["open architecture", "secured line", "superstructure", "installation", "infrastructure", "framework", "capability"];
+var NOUNS = ["matrix", "bus", "bandwidth", "circuit", "transmitter", "protocol", "interface", "capacitor", "monitor", "firewall"];
+var VERBS = ["parse", "quantify", "navigate", "synthesize", "calculate", "transmit", "program", "index", "override", "compress"];
+var ING_VERBS = ["synthesizing", "navigating", "backing up", "parsing", "quantifying", "indexing", "transmitting", "compressing"];
+var ADJECTIVES = ["auxiliary", "multi-byte", "back-end", "primary", "open-source", "virtual", "digital", "redundant", "solid state", "cross-platform"];
+var WORD_POOL = ["withdrawal", "infrastructures", "circuit", "bandwidth", "matrix", "protocol", "synergy", "capacitor", "interface", "array"];
+var LOREM_WORDS = [
+  "lorem",
+  "ipsum",
+  "dolor",
+  "sit",
+  "amet",
+  "consectetur",
+  "adipiscing",
+  "elit",
+  "sed",
+  "do",
+  "eiusmod",
+  "tempor",
+  "incididunt",
+  "labore",
+  "magna",
+  "aliqua",
+  "enim",
+  "minim",
+  "veniam",
+  "quis",
+  "nostrud",
+  "exercitation",
+  "ullamco",
+  "laboris",
+  "aliquip",
+  "commodo",
+  "consequat",
+  "duis",
+  "aute",
+  "irure",
+  "voluptate",
+  "velit"
+];
+var loremWords = (n) => times(n, () => pick(LOREM_WORDS)).join(" ");
+var loremSentence = () => capitalize(loremWords(between(4, 10))) + ".";
+var loremParagraph = () => times(between(3, 7), loremSentence).join(" ");
+var hex2 = (n) => n.toString(16).padStart(2, "0");
+var img = (topic) => `https://loremflickr.com/640/480${topic ? "/" + topic : ""}`;
+var DEFINITIONS = [
+  // Common
+  ["$guid", "A uuid-v4 style guid", uuid],
+  ["$timestamp", "The current UNIX timestamp in seconds", () => String(Math.floor(Date.now() / 1e3))],
+  ["$isoTimestamp", "The current ISO timestamp at zero UTC", () => (/* @__PURE__ */ new Date()).toISOString()],
+  ["$randomUUID", "A random 36-character UUID", uuid],
+  // Text, numbers, and colors
+  ["$randomAlphaNumeric", "A random alpha-numeric character", () => ALPHA_NUMERIC[rnd(ALPHA_NUMERIC.length)]],
+  ["$randomBoolean", "A random boolean value", () => String(rnd(2) === 0)],
+  ["$randomInt", "A random integer between 0 and 1000", () => String(rnd(1001))],
+  ["$randomColor", "A random color", () => pick(COLORS)],
+  ["$randomHexColor", "A random hex value", () => "#" + rnd(16777216).toString(16).padStart(6, "0")],
+  ["$randomAbbreviation", "A random abbreviation", () => pick(ABBREVIATIONS)],
+  // Internet and IP addresses
+  ["$randomIP", "A random IPv4 address", () => `${between(1, 256)}.${rnd(256)}.${rnd(256)}.${between(1, 256)}`],
+  ["$randomIPV6", "A random IPv6 address", () => times(8, () => rnd(65536).toString(16).padStart(4, "0")).join(":")],
+  ["$randomMACAddress", "A random MAC address", () => times(6, () => hex2(rnd(256))).join(":")],
+  ["$randomPassword", "A random 15-character alpha-numeric password", () => randomString(ALPHA_NUMERIC, 15)],
+  ["$randomLocale", "A random two-letter language code (ISO 639-1)", () => pick(LOCALES)],
+  ["$randomUserAgent", "A random user agent", () => pick(USER_AGENTS)],
+  ["$randomProtocol", "A random internet protocol", () => pick(["http", "https"])],
+  ["$randomSemver", "A random semantic version number", () => `${rnd(10)}.${rnd(20)}.${rnd(20)}`],
+  // Names
+  ["$randomFirstName", "A random first name", () => pick(FIRST_NAMES)],
+  ["$randomLastName", "A random last name", () => pick(LAST_NAMES)],
+  ["$randomFullName", "A random first and last name", () => `${pick(FIRST_NAMES)} ${pick(LAST_NAMES)}`],
+  ["$randomNamePrefix", "A random name prefix", () => pick(["Dr.", "Ms.", "Mr.", "Mrs.", "Miss", "Mx."])],
+  ["$randomNameSuffix", "A random name suffix", () => pick(["I", "II", "III", "IV", "Jr.", "Sr.", "MD", "DDS", "PhD", "DVM"])],
+  // Profession
+  ["$randomJobArea", "A random job area", () => pick(JOB_AREAS)],
+  ["$randomJobDescriptor", "A random job descriptor", () => pick(JOB_DESCRIPTORS)],
+  ["$randomJobTitle", "A random job title", () => `${pick(JOB_DESCRIPTORS)} ${pick(JOB_AREAS)} ${pick(JOB_TYPES)}`],
+  ["$randomJobType", "A random job type", () => pick(JOB_TYPES)],
+  // Phone, address, and location
+  ["$randomPhoneNumber", "A random ten-digit phone number", () => `${between(200, 999)}-${between(100, 999)}-${between(1e3, 9999)}`],
+  ["$randomPhoneNumberExt", "A random phone number with extension (12 digits)", () => `${between(10, 99)}-${between(100, 999)}-${between(100, 999)}-${between(1e3, 9999)}`],
+  ["$randomCity", "A random city name", () => pick(CITIES)],
+  ["$randomStreetName", "A random street name", () => `${pick(LAST_NAMES)} ${pick(["Street", "Island", "Springs", "Orchard", "Avenue", "Lane"])}`],
+  ["$randomStreetAddress", "A random street address", () => `${between(100, 99999)} ${pick(LAST_NAMES)} ${pick(["Streets", "Orchard", "Avenue", "Lane", "Way"])}`],
+  ["$randomCountry", "A random country", () => pick(COUNTRIES)],
+  ["$randomCountryCode", "A random two-letter country code (ISO 3166-1 alpha-2)", () => pick(COUNTRY_CODES)],
+  ["$randomLatitude", "A random latitude coordinate", () => (Math.random() * 180 - 90).toFixed(4)],
+  ["$randomLongitude", "A random longitude coordinate", () => (Math.random() * 360 - 180).toFixed(4)],
+  // Images
+  ["$randomAvatarImage", "A random avatar image", () => `https://avatars.githubusercontent.com/u/${rnd(1e5)}`],
+  ["$randomImageUrl", "A URL of a random image", () => img()],
+  ["$randomAbstractImage", "A URL of a random abstract image", () => img("abstract")],
+  ["$randomAnimalsImage", "A URL of a random animal image", () => img("animals")],
+  ["$randomBusinessImage", "A URL of a random stock business image", () => img("business")],
+  ["$randomCatsImage", "A URL of a random cat image", () => img("cats")],
+  ["$randomCityImage", "A URL of a random city image", () => img("city")],
+  ["$randomFoodImage", "A URL of a random food image", () => img("food")],
+  ["$randomNightlifeImage", "A URL of a random nightlife image", () => img("nightlife")],
+  ["$randomFashionImage", "A URL of a random fashion image", () => img("fashion")],
+  ["$randomPeopleImage", "A URL of a random image of a person", () => img("people")],
+  ["$randomNatureImage", "A URL of a random nature image", () => img("nature")],
+  ["$randomSportsImage", "A URL of a random sports image", () => img("sports")],
+  ["$randomTransportImage", "A URL of a random transportation image", () => img("transport")],
+  ["$randomImageDataUri", "A random image data URI", () => "data:image/svg+xml;charset=UTF-8,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%2F%3E"],
+  // Finance
+  ["$randomBankAccount", "A random 8-digit bank account number", () => String(between(1e7, 99999999))],
+  ["$randomBankAccountName", "A random bank account name", () => pick(["Home Loan Account", "Checking Account", "Savings Account", "Auto Loan Account", "Personal Loan Account", "Credit Card Account"])],
+  ["$randomCreditCardMask", "A random masked credit card number", () => String(between(1e3, 9999))],
+  ["$randomBankAccountBic", "A random BIC (Bank Identifier Code)", () => randomString(UPPER, 4) + randomString(UPPER, 2) + randomString(ALPHA_NUMERIC_UPPER, 2)],
+  ["$randomBankAccountIban", "A random 15-31 character IBAN", () => randomString(UPPER, 2) + between(10, 99) + randomString(ALPHA_NUMERIC_UPPER, between(11, 27))],
+  ["$randomTransactionType", "A random transaction type", () => pick(["invoice", "payment", "deposit", "withdrawal"])],
+  ["$randomCurrencyCode", "A random 3-letter currency code (ISO-4217)", () => pick(CURRENCY_CODES)],
+  ["$randomCurrencyName", "A random currency name", () => pick(CURRENCY_NAMES)],
+  ["$randomCurrencySymbol", "A random currency symbol", () => pick(["$", "\xA3", "\u20AC", "\xA5", "\u20B9", "\u20A9"])],
+  ["$randomBitcoin", "A random bitcoin address", () => pick(["1", "3", "bc1"]) + randomString(ALPHA_NUMERIC, between(25, 34))],
+  // Business
+  ["$randomCompanyName", "A random company name", () => `${pick(LAST_NAMES)} ${pick(["- " + pick(LAST_NAMES), "LLC", "Inc", "Group", "and Sons"])}`],
+  ["$randomCompanySuffix", "A random company suffix", () => pick(["Inc", "LLC", "Group", "and Sons", "Ltd"])],
+  ["$randomBs", "A random phrase of business-speak", () => `${pick(BS_ADJECTIVES)} ${pick(BS_BUZZ)} ${pick(BS_NOUNS)}`],
+  ["$randomBsAdjective", "A random business-speak adjective", () => pick(BS_ADJECTIVES)],
+  ["$randomBsBuzz", "A random business-speak buzzword", () => pick(BS_BUZZ)],
+  ["$randomBsNoun", "A random business-speak noun", () => pick(BS_NOUNS)],
+  // Catchphrases
+  ["$randomCatchPhrase", "A random catchphrase", () => `${pick(CATCH_ADJECTIVES)} ${pick(CATCH_DESCRIPTORS)} ${pick(CATCH_NOUNS)}`],
+  ["$randomCatchPhraseAdjective", "A random catchphrase adjective", () => pick(CATCH_ADJECTIVES)],
+  ["$randomCatchPhraseDescriptor", "A random catchphrase descriptor", () => pick(CATCH_DESCRIPTORS)],
+  ["$randomCatchPhraseNoun", "A random catchphrase noun", () => pick(CATCH_NOUNS)],
+  // Databases
+  ["$randomDatabaseColumn", "A random database column name", () => pick(["id", "title", "name", "email", "password", "group", "avatar", "status", "createdAt", "updatedAt", "token"])],
+  ["$randomDatabaseType", "A random database type", () => pick(["tinyint", "smallint", "mediumint", "int", "bigint", "varchar", "text", "blob", "timestamp", "datetime", "decimal"])],
+  ["$randomDatabaseCollation", "A random database collation", () => pick(["utf8_general_ci", "utf8_unicode_ci", "cp1250_bin", "cp1250_general_ci", "latin1_swedish_ci"])],
+  ["$randomDatabaseEngine", "A random database engine", () => pick(["InnoDB", "MyISAM", "Memory", "CSV", "Archive", "Federated"])],
+  // Dates
+  ["$randomDateFuture", "A random future datetime", () => jsDate(new Date(Date.now() + between(1, 365) * 864e5))],
+  ["$randomDatePast", "A random past datetime", () => jsDate(new Date(Date.now() - between(1, 365) * 864e5))],
+  ["$randomDateRecent", "A random recent datetime", () => jsDate(new Date(Date.now() - between(1, 10080) * 6e4))],
+  ["$randomWeekday", "A random weekday", () => pick(["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"])],
+  ["$randomMonth", "A random month", () => pick(["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"])],
+  // Domains, emails, and usernames
+  ["$randomDomainName", "A random domain name", () => `${pick(FIRST_NAMES).toLowerCase()}.${pick(["biz", "info", "name", "com", "net"])}`],
+  ["$randomDomainSuffix", "A random domain suffix", () => pick(["com", "net", "org", "biz", "info", "name", "io"])],
+  ["$randomDomainWord", "A random unqualified domain name", () => pick(FIRST_NAMES).toLowerCase()],
+  ["$randomEmail", "A random email address", () => `${pick(FIRST_NAMES)}${rnd(100)}@${pick(["gmail.com", "hotmail.com", "yahoo.com"])}`],
+  ["$randomExampleEmail", "A random email address from an example domain", () => `${pick(FIRST_NAMES)}${rnd(100)}@${pick(["example.com", "example.net", "example.org"])}`],
+  ["$randomUserName", "A random username", () => `${pick(FIRST_NAMES)}${pick([".", "_", ""])}${pick(LAST_NAMES)}${rnd(100)}`],
+  ["$randomUrl", "A random URL", () => `${pick(["https://", "http://"])}${pick(FIRST_NAMES).toLowerCase()}.${pick(["net", "com", "name", "info"])}`],
+  // Files and directories
+  ["$randomFileName", "A random file name", () => `${pick(LOREM_WORDS)}_${pick(LOREM_WORDS)}.${pick(["gdoc", "gif", "mp4v", "key", "sql", "txt"])}`],
+  ["$randomFileType", "A random file type", () => pick(["application", "audio", "image", "message", "model", "multipart", "text", "video"])],
+  ["$randomFileExt", "A random file extension", () => pick(["war", "book", "fsc", "gif", "key", "html", "mp3", "war", "wav"])],
+  ["$randomCommonFileName", "A random common file name", () => `${pick(LOREM_WORDS)}.${pick(["mp4", "wav", "png", "jpg", "csv", "doc"])}`],
+  ["$randomCommonFileType", "A random common file type", () => pick(["application", "audio", "image", "text", "video"])],
+  ["$randomCommonFileExt", "A random common file extension", () => pick(["m2v", "wav", "png", "jpeg", "pdf", "doc", "csv"])],
+  ["$randomFilePath", "A random file path", () => `/home/${pick(LOREM_WORDS)}_${pick(LOREM_WORDS)}.${pick(["cpio", "txt", "png", "log"])}`],
+  ["$randomDirectoryPath", "A random directory path", () => pick(["/usr/bin", "/root", "/usr/local/bin", "/opt", "/var/log", "/home", "/etc"])],
+  ["$randomMimeType", "A random MIME type", () => pick(["application/json", "text/plain", "image/png", "audio/mpeg", "video/mp4", "application/xml"])],
+  // Stores
+  ["$randomPrice", "A random price between 0.00 and 1000.00", () => (Math.random() * 1e3).toFixed(2)],
+  ["$randomProduct", "A random product", () => pick(["Towels", "Pizza", "Pants", "Cheese", "Chair", "Computer", "Shoes", "Gloves"])],
+  ["$randomProductAdjective", "A random product adjective", () => pick(["Unbranded", "Incredible", "Tasty", "Handcrafted", "Refined", "Generic", "Rustic", "Ergonomic"])],
+  ["$randomProductMaterial", "A random product material", () => pick(["Steel", "Plastic", "Frozen", "Concrete", "Cotton", "Granite", "Rubber", "Wooden"])],
+  ["$randomProductName", "A random product name", () => `${pick(["Handmade", "Refined", "Ergonomic", "Rustic"])} ${pick(["Concrete", "Steel", "Rubber", "Cotton"])} ${pick(["Tuna", "Hat", "Chair", "Shoes"])}`],
+  ["$randomDepartment", "A random commerce category", () => pick(["Tools", "Movies", "Electronics", "Books", "Garden", "Toys", "Health", "Music"])],
+  // Grammar
+  ["$randomNoun", "A random noun", () => pick(NOUNS)],
+  ["$randomVerb", "A random verb", () => pick(VERBS)],
+  ["$randomIngverb", "A random verb ending in -ing", () => pick(ING_VERBS)],
+  ["$randomAdjective", "A random adjective", () => pick(ADJECTIVES)],
+  ["$randomWord", "A random word", () => pick(WORD_POOL)],
+  ["$randomWords", "Some random words", () => capitalize(times(between(2, 6), () => pick(WORD_POOL)).join(" "))],
+  ["$randomPhrase", "A random phrase", () => `${pick(["You can't", "Try to", "We need to", "I'll"])} ${pick(VERBS)} the ${pick(NOUNS)}!`],
+  // Lorem ipsum
+  ["$randomLoremWord", "A random word of lorem ipsum text", () => pick(LOREM_WORDS)],
+  ["$randomLoremWords", "Some random words of lorem ipsum text", () => loremWords(between(2, 5))],
+  ["$randomLoremSentence", "A random sentence of lorem ipsum text", loremSentence],
+  ["$randomLoremSentences", "A random 2 to 6 sentences of lorem ipsum text", () => times(between(2, 7), loremSentence).join(" ")],
+  ["$randomLoremParagraph", "A random paragraph of lorem ipsum text", loremParagraph],
+  ["$randomLoremParagraphs", "3 random paragraphs of lorem ipsum text", () => times(3, loremParagraph).join("\n")],
+  ["$randomLoremText", "A random amount of lorem ipsum text", () => times(between(3, 8), loremSentence).join(" ")],
+  ["$randomLoremSlug", "A random lorem ipsum URL slug", () => times(3, () => pick(LOREM_WORDS)).join("-")],
+  ["$randomLoremLines", "1 to 5 random lines of lorem ipsum", () => times(between(1, 6), loremSentence).join("\n")]
+];
+var GENERATORS = new Map(DEFINITIONS.map(([name, , gen]) => [name.toLowerCase(), gen]));
+function example(gen) {
+  try {
+    const s = gen();
+    return s.length > 48 ? s.slice(0, 48) + "..." : s;
+  } catch {
+    return "";
+  }
+}
+var DYNAMIC_VARIABLES = DEFINITIONS.map(([name, description, gen]) => ({
+  name,
+  description,
+  example: example(gen)
+}));
+var CATALOG = new Map(DYNAMIC_VARIABLES.map((d) => [d.name.toLowerCase(), d]));
+function tryGenerate(name) {
+  if (!name) return void 0;
+  const gen = GENERATORS.get(name.trim().toLowerCase());
+  if (!gen) return void 0;
+  try {
+    return gen();
+  } catch {
+    return void 0;
+  }
+}
+
+// core/src/variableResolver.ts
+var PLACEHOLDER = /\{\{\s*([^{}\s]+)\s*\}\}/g;
+function layerFromVariables(scope, vars) {
+  if (!vars?.length) return void 0;
+  const values = /* @__PURE__ */ new Map();
+  for (const v of vars) {
+    if (v && v.enabled !== false && v.key) values.set(v.key.toLowerCase(), v.value ?? "");
+  }
+  return { scope, values };
+}
+function layers(ctx) {
+  const data = ctx.iterationData ? {
+    scope: "data",
+    values: new Map(Object.entries(ctx.iterationData).map(([k, v]) => [k.toLowerCase(), v == null ? "" : String(v)]))
+  } : void 0;
+  return [
+    layerFromVariables("request", ctx.request),
+    data,
+    layerFromVariables("collection", ctx.collection),
+    layerFromVariables("environment", ctx.environment),
+    layerFromVariables("globals", ctx.globals)
+  ].filter((l) => !!l);
+}
+function lookupIn(ls, name) {
+  const key = name.toLowerCase();
+  for (const l of ls) {
+    const v = l.values.get(key);
+    if (v !== void 0) return { value: v, scope: l.scope };
+  }
+  return void 0;
+}
+function lookupVariable(name, ctx) {
+  const found = lookupIn(layers(ctx), name.trim());
+  if (found) return found;
+  const generated = tryGenerate(name);
+  return generated === void 0 ? void 0 : { value: generated, scope: "dynamic" };
+}
+function mergedVariables(ctx) {
+  const out = {};
+  const seen = /* @__PURE__ */ new Set();
+  const add = (k, v) => {
+    const lk = k.toLowerCase();
+    if (seen.has(lk)) return;
+    seen.add(lk);
+    out[k] = v;
+  };
+  const addVars = (vars) => {
+    if (!vars) return;
+    for (let i = vars.length - 1; i >= 0; i--) {
+      const v = vars[i];
+      if (v && v.enabled !== false && v.key) add(v.key, v.value ?? "");
+    }
+  };
+  addVars(ctx.request);
+  if (ctx.iterationData) for (const [k, v] of Object.entries(ctx.iterationData)) add(k, v == null ? "" : String(v));
+  addVars(ctx.collection);
+  addVars(ctx.environment);
+  addVars(ctx.globals);
+  return out;
+}
+function resolveVariables(text, ctx) {
+  if (!text) return text ?? "";
+  if (!text.includes("{{")) return text;
+  const ls = layers(ctx);
+  return text.replace(PLACEHOLDER, (match, name) => {
+    const found = lookupIn(ls, name);
+    if (found) return found.value;
+    return tryGenerate(name) ?? match;
+  });
+}
+
+// core/src/requestBuilder.ts
+var DEFAULT_CONTENT_TYPES = {
+  raw: "text/plain",
+  text: "text/plain",
+  json: "application/json",
+  xml: "application/xml",
+  html: "text/html",
+  graphql: "application/json"
+};
+function effectiveAuth(request3, collection) {
+  if (request3.auth?.type === "inherit") {
+    return collection?.auth && collection.auth.type !== "inherit" ? collection.auth : { ...request3.auth, type: "none" };
+  }
+  return request3.auth;
+}
+function encodeQueryComponent(s) {
+  return encodeURIComponent(s);
+}
+function appendQuery(url, pairs) {
+  if (!pairs.length) return url;
+  const hashAt = url.indexOf("#");
+  const base = hashAt >= 0 ? url.slice(0, hashAt) : url;
+  const hash = hashAt >= 0 ? url.slice(hashAt) : "";
+  const query = pairs.map((p) => `${encodeQueryComponent(p.key)}=${encodeQueryComponent(p.value)}`).join("&");
+  const sep = base.includes("?") ? base.endsWith("?") || base.endsWith("&") ? "" : "&" : "?";
+  return base + sep + query + hash;
+}
+function utf8ToBase64(s) {
+  const bytes = new TextEncoder().encode(s);
+  let bin = "";
+  for (const b of bytes) bin += String.fromCharCode(b);
+  return btoa(bin);
+}
+function applyPathVariables(url, vars) {
+  if (!vars.length) return url;
+  const schemeEnd = url.indexOf("://");
+  const pathStart = url.indexOf("/", schemeEnd >= 0 ? schemeEnd + 3 : 0);
+  if (pathStart < 0) return url;
+  const qAt = url.search(/[?#]/);
+  const pathEnd = qAt >= 0 && qAt > pathStart ? qAt : url.length;
+  let path4 = url.slice(pathStart, pathEnd);
+  for (const v of vars) {
+    if (!v.key) continue;
+    const key = v.key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    path4 = path4.replace(new RegExp(`(?<=/):${key}(?=[/.;]|$)`, "g"), () => v.value);
+  }
+  return url.slice(0, pathStart) + path4 + url.slice(pathEnd);
+}
+function isFileField(f) {
+  return !!f.isFile || f.value.startsWith("@") || (f.description ?? "").trim().toLowerCase() === "file";
+}
+function buildRequest(request3, opts) {
+  const r = (s) => resolveVariables(s ?? "", opts.ctx);
+  const method = (request3.method || "GET").trim().toUpperCase();
+  let url = r(request3.url).trim();
+  url = applyPathVariables(
+    url,
+    (request3.pathVariables ?? []).map((p) => ({ key: p.key, value: r(p.value) }))
+  );
+  const query = (request3.queryParams ?? []).filter((p) => p.enabled !== false && p.key?.trim()).map((p) => ({ key: r(p.key), value: r(p.value) }));
+  url = appendQuery(url, query);
+  const headers = [{ key: "User-Agent", value: YAMLET_USER_AGENT, enabled: true }];
+  for (const h of request3.headers ?? []) {
+    if (h.enabled === false || !h.key?.trim()) continue;
+    const key = r(h.key).trim();
+    if (key.toLowerCase() === "user-agent") continue;
+    headers.push({ key, value: r(h.value), enabled: true });
+  }
+  const hasHeader = (name) => headers.some((h) => h.key.toLowerCase() === name.toLowerCase());
+  const auth = effectiveAuth(request3, opts.collection);
+  switch (auth.type) {
+    case "bearer": {
+      const token = r(auth.token);
+      if (token.trim()) headers.push({ key: "Authorization", value: `Bearer ${token}`, enabled: true });
+      break;
+    }
+    case "basic": {
+      const encoded = utf8ToBase64(`${r(auth.username)}:${r(auth.password)}`);
+      headers.push({ key: "Authorization", value: `Basic ${encoded}`, enabled: true });
+      break;
+    }
+    case "apikey": {
+      const name = r(auth.apiKeyName).trim();
+      if (!name) break;
+      const value = r(auth.apiKeyValue);
+      if (auth.apiKeyIn === "query") url = appendQuery(url, [{ key: name, value }]);
+      else headers.push({ key: name, value, enabled: true });
+      break;
+    }
+    case "cookie": {
+      const cookie = r(auth.cookie);
+      if (cookie.trim()) headers.push({ key: "Cookie", value: cookie, enabled: true });
+      break;
+    }
+    case "oauth2": {
+      const o = auth.oauth2;
+      const token = opts.oauthToken?.trim() ? opts.oauthToken : r(o.accessToken);
+      if (!token?.trim()) break;
+      if (o.addTokenTo === "query") url = appendQuery(url, [{ key: "access_token", value: token }]);
+      else {
+        const prefix = o.headerPrefix?.trim() ? r(o.headerPrefix).trim() : "Bearer";
+        headers.push({ key: "Authorization", value: prefix ? `${prefix} ${token}` : token, enabled: true });
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  const b = request3.body;
+  let body = { kind: "none" };
+  switch (b?.type) {
+    case "raw":
+    case "json":
+    case "xml":
+    case "text":
+    case "html": {
+      if (b.raw) body = { kind: "text", text: r(b.raw), contentType: DEFAULT_CONTENT_TYPES[b.type] };
+      break;
+    }
+    case "graphql": {
+      const query2 = r(b.graphqlQuery);
+      const varsText = r(b.graphqlVariables).trim();
+      let variables = void 0;
+      if (varsText) {
+        try {
+          variables = JSON.parse(varsText);
+        } catch {
+          variables = void 0;
+        }
+      }
+      const payload = { query: query2 };
+      if (variables !== void 0) payload.variables = variables;
+      body = { kind: "text", text: JSON.stringify(payload), contentType: "application/json" };
+      break;
+    }
+    case "urlencoded": {
+      body = {
+        kind: "urlencoded",
+        fields: (b.fields ?? []).filter((f) => f.enabled !== false && f.key?.trim()).map((f) => ({ key: r(f.key), value: r(f.value) }))
+      };
+      break;
+    }
+    case "form-data": {
+      body = {
+        kind: "form-data",
+        fields: (b.fields ?? []).filter((f) => f.enabled !== false && f.key?.trim()).map((f) => {
+          const value = r(f.value);
+          const file = isFileField({ ...f, value });
+          return { key: r(f.key), value: file && value.startsWith("@") ? value.slice(1) : value, isFile: file };
+        })
+      };
+      break;
+    }
+    case "binary": {
+      const file = r(b.binaryFile).trim();
+      if (file) body = { kind: "binary", file: file.startsWith("@") ? file.slice(1) : file, contentType: "application/octet-stream" };
+      break;
+    }
+    default:
+      break;
+  }
+  if (!hasHeader("content-type")) {
+    if ((body.kind === "text" || body.kind === "binary") && body.contentType) {
+      headers.push({ key: "Content-Type", value: body.contentType, enabled: true });
+    } else if (body.kind === "urlencoded") {
+      headers.push({ key: "Content-Type", value: "application/x-www-form-urlencoded", enabled: true });
+    }
+  } else if (body.kind === "text" || body.kind === "binary") {
+    body = { ...body, contentType: headers.find((h) => h.key.toLowerCase() === "content-type").value };
+  }
+  return { method, url, headers, body };
+}
+function encodeUrlEncodedBody(fields) {
+  return new URLSearchParams(fields.map((f) => [f.key, f.value])).toString();
+}
+
+// core/src/scriptRunner.ts
+import { randomUUID } from "node:crypto";
+import { inspect } from "node:util";
+import vm from "node:vm";
+import * as chai from "chai";
+var DEFAULT_SCRIPT_TIMEOUT_MS = 5e3;
+var ScriptVariables = class {
+  request;
+  iterationData;
+  collection;
+  environment;
+  globals;
+  /** pm.variables.set values: highest precedence, never persisted. */
+  local = /* @__PURE__ */ new Map();
+  dirty = /* @__PURE__ */ new Set();
+  constructor(init = {}) {
+    this.request = init.request ?? [];
+    this.iterationData = init.iterationData;
+    this.collection = init.collection;
+    this.environment = init.environment;
+    this.globals = init.globals;
+  }
+  toContext() {
+    return {
+      request: [...this.request, ...this.local.values()],
+      iterationData: this.iterationData,
+      collection: this.collection,
+      environment: this.environment,
+      globals: this.globals
+    };
+  }
+  list(scope) {
+    return scope === "environment" ? this.environment : scope === "collection" ? this.collection : scope === "globals" ? this.globals : void 0;
+  }
+  get(scope, key) {
+    if (scope === "local") {
+      const hit = lookupVariable(key, this.toContext());
+      return hit && hit.scope !== "dynamic" ? hit.value : void 0;
+    }
+    const list = this.list(scope);
+    const lk = key.toLowerCase();
+    if (!list) return this.local.get(lk)?.value;
+    for (let i = list.length - 1; i >= 0; i--) {
+      if (list[i].enabled !== false && list[i].key.toLowerCase() === lk) return list[i].value;
+    }
+    return void 0;
+  }
+  set(scope, key, value) {
+    if (!key?.trim()) return;
+    const list = this.list(scope);
+    if (scope === "local" || !list) {
+      this.local.set(key.toLowerCase(), { key, value, enabled: true });
+      this.dirty.add("local");
+      return;
+    }
+    const existing = list.find((v) => v.key.toLowerCase() === key.toLowerCase());
+    if (existing) {
+      existing.value = value;
+      existing.enabled = true;
+    } else list.push({ key, value, enabled: true });
+    this.dirty.add(scope);
+  }
+  unset(scope, key) {
+    const list = this.list(scope);
+    const lk = key.toLowerCase();
+    if (scope === "local" || !list) {
+      if (this.local.delete(lk)) this.dirty.add("local");
+      return;
+    }
+    const before = list.length;
+    for (let i = list.length - 1; i >= 0; i--) if (list[i].key.toLowerCase() === lk) list.splice(i, 1);
+    if (list.length !== before) this.dirty.add(scope);
+  }
+  clear(scope) {
+    const list = this.list(scope);
+    if (scope === "local" || !list) {
+      this.local.clear();
+      return;
+    }
+    if (list.length) {
+      list.splice(0, list.length);
+      this.dirty.add(scope);
+    }
+  }
+  toObject(scope) {
+    if (scope === "local") return mergedVariables(this.toContext());
+    const out = {};
+    for (const v of this.list(scope) ?? []) if (v.enabled !== false && v.key) out[v.key] = v.value;
+    return out;
+  }
+  /** Full new lists for each persisted scope a script changed. */
+  changes() {
+    const out = {};
+    if (this.dirty.has("environment") && this.environment) out.environment = structuredClone(this.environment);
+    if (this.dirty.has("collection") && this.collection) out.collectionVariables = structuredClone(this.collection);
+    if (this.dirty.has("globals") && this.globals) out.globals = structuredClone(this.globals);
+    return out;
+  }
+};
+var RESPONSE = /* @__PURE__ */ Symbol.for("yamlet.scriptResponse");
+var pluginInstalled = false;
+function installResponsePlugin() {
+  if (pluginInstalled) return;
+  pluginInstalled = true;
+  chai.use((c, utils) => {
+    const A = c.Assertion;
+    const resp = (a) => utils.flag(a, "object")?.[RESPONSE];
+    const need = (a) => {
+      const r = resp(a);
+      if (!r) throw new Error("expected a response object");
+      return r;
+    };
+    A.addMethod("status", function(expected) {
+      const r = need(this);
+      if (typeof expected === "number")
+        this.assert(r.statusCode === expected, "expected response to have status code #{exp} but got #{act}", "expected response to not have status code #{act}", expected, r.statusCode);
+      else
+        this.assert(r.reasonPhrase === expected, "expected response to have status reason #{exp} but got #{act}", "expected response to not have status reason #{act}", expected, r.reasonPhrase);
+    });
+    A.addMethod("header", function(name, value) {
+      const r = need(this);
+      const h = r.headers.find((x) => x.key.toLowerCase() === String(name).toLowerCase());
+      if (value === void 0) this.assert(!!h, `expected response to have header ${name}`, `expected response to not have header ${name}`, name, void 0);
+      else this.assert(h?.value === value, `expected response header ${name} to be #{exp} but got #{act}`, `expected response header ${name} to not be #{act}`, value, h?.value);
+    });
+    A.addMethod("body", function(expected) {
+      const r = need(this);
+      if (expected === void 0) this.assert(r.body.length > 0, "expected response to have a body", "expected response to not have a body", void 0, void 0);
+      else if (typeof expected === "string") this.assert(r.body === expected, "expected response body to equal #{exp}", "expected response body to not equal #{exp}", expected, r.body);
+      else {
+        let parsed;
+        try {
+          parsed = JSON.parse(r.body);
+        } catch {
+          parsed = void 0;
+        }
+        this.assert(utils.eql(parsed, expected), "expected response JSON body to deeply equal #{exp}", "expected response JSON body to not deeply equal #{exp}", expected, parsed);
+      }
+    });
+    A.addMethod("jsonBody", function(pathOrValue, value) {
+      const r = need(this);
+      let parsed;
+      let ok = true;
+      try {
+        parsed = JSON.parse(r.body);
+      } catch {
+        ok = false;
+      }
+      if (pathOrValue === void 0) {
+        this.assert(ok, "expected response to have a JSON body", "expected response to not have a JSON body", void 0, void 0);
+        return;
+      }
+      if (typeof pathOrValue === "string") {
+        const got = pathOrValue.split(".").reduce((o, k) => o && typeof o === "object" ? o[k] : void 0, parsed);
+        if (value === void 0) this.assert(got !== void 0, `expected response JSON to have path ${pathOrValue}`, `expected response JSON to not have path ${pathOrValue}`, void 0, void 0);
+        else this.assert(utils.eql(got, value), `expected response JSON at ${pathOrValue} to deeply equal #{exp} but got #{act}`, `expected response JSON at ${pathOrValue} to not deeply equal #{exp}`, value, got);
+        return;
+      }
+      this.assert(utils.eql(parsed, pathOrValue), "expected response JSON body to deeply equal #{exp}", "expected response JSON body to not deeply equal #{exp}", pathOrValue, parsed);
+    });
+    A.addMethod("responseTime", function() {
+      need(this);
+    });
+    A.overwriteProperty(
+      "ok",
+      (_super) => function() {
+        const r = resp(this);
+        if (!r) return _super.call(this);
+        this.assert(r.statusCode >= 200 && r.statusCode < 300, "expected response to be ok (2xx) but got #{act}", "expected response to not be ok but got #{act}", void 0, r.statusCode);
+      }
+    );
+    const statusProps = [
+      ["success", (s) => s >= 200 && s < 300, "successful (2xx)"],
+      ["info", (s) => s >= 100 && s < 200, "informational (1xx)"],
+      ["redirection", (s) => s >= 300 && s < 400, "a redirection (3xx)"],
+      ["clientError", (s) => s >= 400 && s < 500, "a client error (4xx)"],
+      ["serverError", (s) => s >= 500, "a server error (5xx)"],
+      ["error", (s) => s >= 400, "an error (4xx/5xx)"],
+      ["accepted", (s) => s === 202, "accepted (202)"],
+      ["badRequest", (s) => s === 400, "a bad request (400)"],
+      ["unauthorized", (s) => s === 401, "unauthorized (401)"],
+      ["forbidden", (s) => s === 403, "forbidden (403)"],
+      ["notFound", (s) => s === 404, "not found (404)"],
+      ["rateLimited", (s) => s === 429, "rate limited (429)"]
+    ];
+    for (const [name, test, label] of statusProps) {
+      A.addProperty(name, function() {
+        const r = need(this);
+        this.assert(test(r.statusCode), `expected response to be ${label} but got #{act}`, `expected response to not be ${label}`, void 0, r.statusCode);
+      });
+    }
+    A.addProperty("json", function() {
+      const r = need(this);
+      let ok = true;
+      try {
+        JSON.parse(r.body);
+      } catch {
+        ok = false;
+      }
+      this.assert(ok, "expected response body to be valid JSON", "expected response body to not be JSON", void 0, void 0);
+    });
+    A.addProperty("withBody", function() {
+      const r = need(this);
+      this.assert(r.body.length > 0, "expected response to have a body", "expected response to not have a body", void 0, void 0);
+    });
+  });
+}
+var errMessage = (e) => e && typeof e === "object" && "message" in e ? String(e.message) : String(e);
+function decodeBody(r) {
+  return r.bodyEncoding === "base64" ? Buffer.from(r.body, "base64").toString("utf8") : r.body;
+}
+function headerList(list) {
+  const find = (name) => list.find((h) => h.key.toLowerCase() === String(name).toLowerCase());
+  return {
+    get: (name) => find(name)?.value,
+    has: (name) => !!find(name),
+    all: () => list.map((h) => ({ key: h.key, value: h.value })),
+    toObject: () => Object.fromEntries(list.map((h) => [h.key, h.value])),
+    each: (fn) => list.forEach((h) => fn({ key: h.key, value: h.value })),
+    count: () => list.length
+  };
+}
+function responseFacade(r) {
+  const facade = {
+    [RESPONSE]: r,
+    code: r.statusCode,
+    status: r.reasonPhrase,
+    responseTime: r.durationMs,
+    responseSize: r.sizeBytes,
+    headers: headerList(r.headers),
+    cookies: {
+      get: (name) => r.cookies.find((c) => c.name === name)?.value,
+      has: (name) => r.cookies.some((c) => c.name === name),
+      toObject: () => Object.fromEntries(r.cookies.map((c) => [c.name, c.value])),
+      all: () => r.cookies.map((c) => ({ ...c }))
+    },
+    text: () => decodeBody(r),
+    json: () => JSON.parse(decodeBody(r) || "null"),
+    size: () => ({ body: r.sizeBytes, header: 0, total: r.sizeBytes }),
+    get to() {
+      return chai.expect(facade).to;
+    }
+  };
+  return facade;
+}
+function splitUrl(url) {
+  const hashAt = url.indexOf("#");
+  const noHash = hashAt >= 0 ? url.slice(0, hashAt) : url;
+  const qAt = noHash.indexOf("?");
+  if (qAt < 0) return { base: url, query: [] };
+  const decode = (s) => {
+    try {
+      return decodeURIComponent(s.replace(/\+/g, " "));
+    } catch {
+      return s;
+    }
+  };
+  const query = noHash.slice(qAt + 1).split("&").filter(Boolean).map((pair) => {
+    const eq = pair.indexOf("=");
+    return { key: decode(eq >= 0 ? pair.slice(0, eq) : pair), value: eq >= 0 ? decode(pair.slice(eq + 1)) : "", enabled: true };
+  });
+  return { base: noHash.slice(0, qAt), query };
+}
+function requestFacade(req) {
+  const upsertHeader = (h, value) => {
+    const key = typeof h === "string" ? h : String(h?.key ?? h?.name ?? "");
+    const val = typeof h === "string" ? value : h?.value;
+    if (!key.trim()) return;
+    const existing = req.headers.find((x) => x.key.toLowerCase() === key.toLowerCase());
+    const text = val === void 0 || val === null ? "" : String(val);
+    if (existing) {
+      existing.value = text;
+      existing.enabled = true;
+    } else req.headers.push({ key, value: text, enabled: true });
+  };
+  const removeHeader = (name) => {
+    const key = (typeof name === "string" ? name : name?.key ?? "").toLowerCase();
+    req.headers = req.headers.filter((h) => h.key.toLowerCase() !== key);
+  };
+  const enabledHeaders = () => req.headers.filter((h) => h.enabled !== false);
+  const queryApi = {
+    add: (p) => req.queryParams.push({ key: String(p.key), value: String(p.value ?? ""), enabled: true }),
+    upsert: (p) => {
+      const hit = req.queryParams.find((q) => q.key === p.key);
+      if (hit) {
+        hit.value = String(p.value ?? "");
+        hit.enabled = true;
+      } else queryApi.add(p);
+    },
+    remove: (key) => {
+      req.queryParams = req.queryParams.filter((q) => q.key !== key);
+    },
+    get: (key) => req.queryParams.find((q) => q.key === key && q.enabled !== false)?.value,
+    has: (key) => req.queryParams.some((q) => q.key === key && q.enabled !== false),
+    all: () => req.queryParams.filter((q) => q.enabled !== false).map((q) => ({ key: q.key, value: q.value })),
+    toObject: () => Object.fromEntries(req.queryParams.filter((q) => q.enabled !== false).map((q) => [q.key, q.value]))
+  };
+  const full = () => appendQuery(req.url, req.queryParams.filter((q) => q.enabled !== false && q.key));
+  const setUrl = (value) => {
+    const { base, query } = splitUrl(String(value ?? ""));
+    req.url = base;
+    if (query.length || String(value).includes("?")) req.queryParams = query;
+  };
+  const urlFacade = {
+    toString: full,
+    update: setUrl,
+    getHost: () => {
+      try {
+        return new URL(full()).hostname;
+      } catch {
+        return req.url.replace(/^[a-z]+:\/\//i, "").split(/[/?#]/)[0];
+      }
+    },
+    getPath: () => req.url.replace(/^[a-z]+:\/\/[^/]+/i, "").replace(/[?#].*$/, "") || "/",
+    getQueryString: () => full().split("?")[1] ?? "",
+    query: queryApi
+  };
+  const body = {
+    get mode() {
+      return req.body.type;
+    },
+    get raw() {
+      return req.body.raw;
+    },
+    set raw(v) {
+      req.body.raw = v === void 0 || v === null ? "" : String(v);
+    },
+    update(v) {
+      if (typeof v === "string") req.body.raw = v;
+      else if (v && typeof v === "object") {
+        const o = v;
+        if (o.mode === "raw" || o.raw !== void 0) {
+          req.body.raw = String(o.raw ?? "");
+          if (req.body.type === "none") req.body.type = "raw";
+        }
+        const fields = o.urlencoded ?? o.formdata;
+        if (fields) {
+          req.body.type = o.urlencoded ? "urlencoded" : "form-data";
+          req.body.fields = fields.map((f) => ({ key: String(f.key), value: String(f.value ?? ""), enabled: true }));
+        }
+      }
+    },
+    toString: () => req.body.raw
+  };
+  const headersApi = {
+    add: upsertHeader,
+    upsert: upsertHeader,
+    remove: removeHeader,
+    get: (name) => enabledHeaders().find((h) => h.key.toLowerCase() === String(name).toLowerCase())?.value,
+    has: (name) => enabledHeaders().some((h) => h.key.toLowerCase() === String(name).toLowerCase()),
+    all: () => enabledHeaders().map((h) => ({ key: h.key, value: h.value })),
+    toObject: () => Object.fromEntries(enabledHeaders().map((h) => [h.key, h.value])),
+    each: (fn) => enabledHeaders().forEach((h) => fn({ key: h.key, value: h.value }))
+  };
+  return {
+    get id() {
+      return req.id;
+    },
+    get name() {
+      return req.name;
+    },
+    get url() {
+      return urlFacade;
+    },
+    set url(v) {
+      setUrl(v);
+    },
+    get method() {
+      return req.method;
+    },
+    set method(v) {
+      const m = String(v ?? "").trim();
+      if (m) req.method = m.toUpperCase();
+    },
+    headers: headersApi,
+    body,
+    addHeader: upsertHeader,
+    removeHeader
+  };
+}
+function scopeApi(vars, scope, ctxForReplace, extra = {}) {
+  const text = (v) => v === void 0 || v === null ? "" : typeof v === "object" ? JSON.stringify(v) : String(v);
+  return {
+    get: (key) => vars.get(scope, String(key)),
+    set: (key, value) => vars.set(scope, String(key), text(value)),
+    unset: (key) => vars.unset(scope, String(key)),
+    has: (key) => vars.get(scope, String(key)) !== void 0,
+    clear: () => vars.clear(scope),
+    toObject: () => vars.toObject(scope),
+    replaceIn: (template) => resolveVariables(text(template), ctxForReplace()),
+    ...extra
+  };
+}
+function normalizeSendSpec(input) {
+  if (typeof input === "string") return { url: input, method: "GET", headers: [] };
+  const o = input ?? {};
+  const url = typeof o.url === "string" ? o.url : String(o.url?.toString?.() ?? "");
+  const headers = [];
+  const rawHeaders = o.header ?? o.headers;
+  if (Array.isArray(rawHeaders)) {
+    for (const h of rawHeaders) if (h && typeof h === "object") headers.push({ key: String(h.key ?? h.name ?? ""), value: String(h.value ?? ""), enabled: true });
+    else if (typeof h === "string" && h.includes(":")) headers.push({ key: h.slice(0, h.indexOf(":")).trim(), value: h.slice(h.indexOf(":") + 1).trim(), enabled: true });
+  } else if (rawHeaders && typeof rawHeaders === "object") {
+    for (const [k, v] of Object.entries(rawHeaders)) headers.push({ key: k, value: String(v), enabled: true });
+  }
+  let body;
+  const b = o.body;
+  if (typeof b === "string") body = b;
+  else if (b && typeof b === "object") {
+    const bo = b;
+    if (bo.mode === "urlencoded" && Array.isArray(bo.urlencoded)) {
+      body = new URLSearchParams(bo.urlencoded.map((f) => [String(f.key), String(f.value ?? "")])).toString();
+      if (!headers.some((h) => h.key.toLowerCase() === "content-type"))
+        headers.push({ key: "Content-Type", value: "application/x-www-form-urlencoded", enabled: true });
+    } else if (bo.raw !== void 0) body = typeof bo.raw === "string" ? bo.raw : JSON.stringify(bo.raw);
+  }
+  return { url, method: String(o.method ?? "GET").toUpperCase(), headers, body };
+}
+function withDeadline(p, ms, what) {
+  let timer;
+  return Promise.race([
+    p,
+    new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error(`${what} timed out after ${ms} ms`)), ms);
+    })
+  ]).finally(() => clearTimeout(timer));
+}
+async function runScript(opts) {
+  if (!opts.script?.trim()) return;
+  installResponsePlugin();
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_SCRIPT_TIMEOUT_MS;
+  const started = Date.now();
+  const { variables: vars, tests, logs } = opts;
+  const pending = [];
+  const asyncFailures = [];
+  const timers = /* @__PURE__ */ new Set();
+  const record = (name, passed, error) => {
+    const r = { name, passed };
+    if (!passed && error) r.error = error;
+    tests.push(r);
+  };
+  const fmt = (args) => args.map((a) => typeof a === "string" ? a : inspect(a, { depth: 4, breakLength: Infinity, compact: true })).join(" ");
+  const consoleApi = {
+    log: (...a) => logs.push(fmt(a)),
+    info: (...a) => logs.push(fmt(a)),
+    debug: (...a) => logs.push(fmt(a)),
+    trace: (...a) => logs.push(fmt(a)),
+    warn: (...a) => logs.push("[warn] " + fmt(a)),
+    error: (...a) => logs.push("[error] " + fmt(a)),
+    clear: () => void 0
+  };
+  const test = (name, fn) => {
+    const testName = String(name);
+    if (typeof fn !== "function") return;
+    try {
+      let ret;
+      if (fn.length > 0) {
+        ret = new Promise((resolve2, reject) => {
+          fn((err) => err ? reject(err) : resolve2());
+        });
+      } else ret = fn();
+      if (ret && typeof ret.then === "function") {
+        pending.push(
+          Promise.resolve(ret).then(
+            () => record(testName, true),
+            (e) => {
+              record(testName, false, errMessage(e));
+              asyncFailures.push(`${testName}: ${errMessage(e)}`);
+            }
+          )
+        );
+      } else record(testName, true);
+    } catch (e) {
+      record(testName, false, errMessage(e));
+      if (opts.throwOnFailure) throw e;
+    }
+  };
+  test.skip = (_name) => void 0;
+  const ctxForReplace = () => vars.toContext();
+  const iterationData = opts.variables.iterationData ?? {};
+  const response = opts.response ? responseFacade(opts.response) : void 0;
+  const sendRequest = (spec, cb) => {
+    const p = (async () => {
+      if (!opts.sendRequest) throw new Error("pm.sendRequest is not available here");
+      const s = normalizeSendSpec(spec);
+      const resolve2 = (t) => resolveVariables(t, ctxForReplace());
+      const res = await opts.sendRequest({
+        url: resolve2(s.url),
+        method: s.method,
+        headers: s.headers.map((h) => ({ ...h, key: resolve2(h.key), value: resolve2(h.value) })),
+        body: s.body === void 0 ? void 0 : resolve2(s.body)
+      });
+      if (res.isError) throw new Error(res.errorMessage ?? "Request failed");
+      return responseFacade(res);
+    })();
+    const settled = p.then(
+      (res) => {
+        cb?.(null, res);
+        return res;
+      },
+      (err) => {
+        if (cb) cb(err, void 0);
+        else throw err;
+      }
+    );
+    pending.push(settled.catch(() => void 0));
+    return settled;
+  };
+  const pm = {
+    info: {
+      eventName: opts.phase === "pre" ? "prerequest" : "test",
+      requestName: opts.info?.requestName ?? opts.request.name,
+      requestId: opts.info?.requestId ?? opts.request.id,
+      iteration: opts.info?.iteration ?? 0,
+      iterationCount: opts.info?.iterationCount ?? 1
+    },
+    variables: scopeApi(vars, "local", ctxForReplace),
+    environment: scopeApi(vars, "environment", ctxForReplace, { name: opts.info?.environmentName ?? "" }),
+    collectionVariables: scopeApi(vars, "collection", ctxForReplace),
+    globals: scopeApi(vars, "globals", ctxForReplace),
+    iterationData: {
+      get: (key) => iterationData[key],
+      has: (key) => key in iterationData,
+      toObject: () => ({ ...iterationData }),
+      toJSON: () => ({ ...iterationData })
+    },
+    replaceIn: (template) => resolveVariables(template == null ? "" : String(template), ctxForReplace()),
+    request: requestFacade(opts.request),
+    response,
+    cookies: response?.cookies ?? { get: () => void 0, has: () => false, toObject: () => ({}), all: () => [] },
+    test,
+    expect: chai.expect,
+    sendRequest
+  };
+  const modules = { chai, uuid: { v4: randomUUID } };
+  const sandbox = {
+    pm,
+    console: consoleApi,
+    atob,
+    btoa,
+    URL,
+    URLSearchParams,
+    TextEncoder,
+    TextDecoder,
+    structuredClone,
+    crypto: globalThis.crypto,
+    setTimeout: (fn, ms, ...args) => {
+      const t = setTimeout(() => {
+        timers.delete(t);
+        try {
+          fn(...args);
+        } catch (e) {
+          logs.push(`[error] ${errMessage(e)}`);
+        }
+      }, ms);
+      timers.add(t);
+      return t;
+    },
+    clearTimeout: (t) => {
+      timers.delete(t);
+      clearTimeout(t);
+    },
+    require: (name) => {
+      if (name in modules) return modules[name];
+      throw new Error(`Module "${name}" is not available in Yamlet scripts`);
+    }
+  };
+  const context = vm.createContext(sandbox, { name: `yamlet-${opts.phase}-script` });
+  const script = new vm.Script(`(async () => {
+${opts.script}
+})()`, { filename: `${opts.phase === "pre" ? "pre-request" : "post-response"}.js` });
+  try {
+    const result = script.runInContext(context, { timeout: timeoutMs });
+    const remaining = () => Math.max(1, timeoutMs - (Date.now() - started));
+    await withDeadline(Promise.resolve(result), remaining(), "Script");
+    while (pending.length || timers.size) {
+      if (pending.length) {
+        const batch = pending.splice(0, pending.length);
+        await withDeadline(Promise.allSettled(batch), remaining(), "Script");
+      } else await withDeadline(new Promise((r) => setTimeout(r, 5)), remaining(), "Script");
+    }
+  } finally {
+    for (const t of timers) clearTimeout(t);
+    timers.clear();
+  }
+  if (opts.throwOnFailure && asyncFailures.length) throw new Error(asyncFailures[0]);
+}
+
+// core/src/requestExecutor.ts
+var MAX_REDIRECTS = 10;
+var insecure;
+var insecureAgent = () => insecure ??= new Agent({ connect: { rejectUnauthorized: false } });
+var errMessage2 = (e) => {
+  if (e && typeof e === "object") {
+    const err = e;
+    const base = String(err.message ?? e);
+    const cause = err.cause?.code ?? err.cause?.message;
+    return cause && !base.includes(String(cause)) ? `${base} (${cause})` : base;
+  }
+  return String(e);
+};
+function headerValue(headers, name) {
+  const v = headers[name.toLowerCase()];
+  return Array.isArray(v) ? v.join(", ") : v;
+}
+function toHeaderList(headers) {
+  const out = [];
+  for (const [key, v] of Object.entries(headers)) {
+    if (v === void 0) continue;
+    for (const value of Array.isArray(v) ? v : [v]) out.push({ key, value, enabled: true });
+  }
+  return out;
+}
+function toUndiciHeaders(list) {
+  const out = {};
+  for (const h of list) {
+    const k = h.key.toLowerCase();
+    const prev = out[k];
+    out[k] = prev === void 0 ? h.value : Array.isArray(prev) ? [...prev, h.value] : [prev, h.value];
+  }
+  return out;
+}
+var TEXTUAL = /^text\/|json|xml|javascript|ecmascript|yaml|csv|x-www-form-urlencoded|graphql|html/i;
+function isTextual(contentType, bytes) {
+  if (contentType) return TEXTUAL.test(contentType);
+  if (bytes.includes(0)) return false;
+  try {
+    new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function decodeText(bytes, contentType) {
+  const charset = /charset\s*=\s*"?([^";\s]+)/i.exec(contentType)?.[1];
+  try {
+    return new TextDecoder(charset || "utf-8").decode(bytes);
+  } catch {
+    return new TextDecoder("utf-8").decode(bytes);
+  }
+}
+function resolveFile(p, workspaceRoot, requestFile) {
+  if (path.isAbsolute(p)) return p;
+  const fromRoot = path.resolve(workspaceRoot, p);
+  if (existsSync(fromRoot) || !requestFile) return fromRoot;
+  const fromRequest = path.resolve(path.dirname(requestFile), p);
+  return existsSync(fromRequest) ? fromRequest : fromRoot;
+}
+async function prepareBody(built, workspaceRoot, requestFile) {
+  const b = built.body;
+  switch (b.kind) {
+    case "text":
+      return { body: b.text, display: b.text };
+    case "urlencoded": {
+      const text = encodeUrlEncodedBody(b.fields);
+      return { body: text, display: text };
+    }
+    case "form-data": {
+      const form = new FormData();
+      const lines = [];
+      for (const f of b.fields) {
+        if (f.isFile) {
+          const file = resolveFile(f.value, workspaceRoot, requestFile);
+          const data = await fs.readFile(file);
+          form.append(f.key, new Blob([data]), path.basename(file));
+          lines.push(`${f.key}: [file ${f.value}, ${data.length} bytes]`);
+        } else {
+          form.append(f.key, f.value);
+          lines.push(`${f.key}: ${f.value}`);
+        }
+      }
+      return { body: form, display: `[multipart form-data]
+${lines.join("\n")}` };
+    }
+    case "binary": {
+      const file = resolveFile(b.file, workspaceRoot, requestFile);
+      const data = await fs.readFile(file);
+      return { body: data, display: `[binary file ${b.file}, ${data.length} bytes]` };
+    }
+    default:
+      return {};
+  }
+}
+async function exchange(opts) {
+  let { url, method, body } = opts;
+  let headers = opts.headers.filter((h) => !(body instanceof FormData && h.key.toLowerCase() === "content-type" && !/boundary=/i.test(h.value)));
+  let explicitCookie = headers.find((h) => h.key.toLowerCase() === "cookie")?.value;
+  const start = performance.now();
+  for (let hop = 0; ; hop++) {
+    const sent = headers.filter((h) => h.key.toLowerCase() !== "cookie");
+    const fromJar = opts.jar?.cookieHeaderFor(url);
+    const cookie = [explicitCookie, fromJar].filter(Boolean).join("; ");
+    if (cookie) sent.push({ key: "Cookie", value: cookie, enabled: true });
+    new URL(url);
+    const res = await request2(url, {
+      method,
+      headers: toUndiciHeaders(sent),
+      body,
+      dispatcher: opts.dispatcher,
+      signal: opts.signal
+    });
+    const firstByteMs = performance.now() - start;
+    const setCookie = res.headers["set-cookie"];
+    if (opts.jar && setCookie) opts.jar.setFromResponse(url, Array.isArray(setCookie) ? setCookie : [setCookie]);
+    const location = headerValue(res.headers, "location");
+    if (opts.followRedirects && location && [301, 302, 303, 307, 308].includes(res.statusCode) && hop < MAX_REDIRECTS) {
+      await res.body.dump();
+      const next = new URL(location, url);
+      if (next.host !== new URL(url).host) {
+        headers = headers.filter((h) => !["authorization", "cookie"].includes(h.key.toLowerCase()));
+        explicitCookie = void 0;
+      }
+      if (res.statusCode === 303 || (res.statusCode === 301 || res.statusCode === 302) && method === "POST") {
+        if (method !== "HEAD") method = "GET";
+        body = void 0;
+        headers = headers.filter((h) => !["content-type", "content-length"].includes(h.key.toLowerCase()));
+      }
+      url = next.toString();
+      continue;
+    }
+    const bytes = Buffer.from(await res.body.arrayBuffer());
+    return { status: res.statusCode, headers: res.headers, bytes, sentHeaders: sent, firstByteMs, totalMs: performance.now() - start };
+  }
+}
+function cookiesOf(url, headers) {
+  const raw = headers["set-cookie"];
+  const list = raw === void 0 ? [] : Array.isArray(raw) ? raw : [raw];
+  let host = "";
+  try {
+    host = new URL(url).hostname;
+  } catch {
+  }
+  return list.map((h) => parseSetCookie(h)).filter((c) => !!c).map((c) => ({ ...c, domain: c.domain ?? host }));
+}
+function formatHeaders(list) {
+  return list.length ? list.map((h) => `  ${h.key}: ${h.value}`).join("\n") : "  [none]";
+}
+function consoleText(r) {
+  const lines = [`${r.method} ${r.resolvedUrl}`, "", "Request Headers", formatHeaders(r.requestHeaders), "", "Request Body", r.requestBody || "[empty]", "", "Response"];
+  if (r.isError) lines.push(`Error: ${r.errorMessage ?? "Request failed."}`);
+  else {
+    lines.push(`HTTP ${r.statusCode} ${r.reasonPhrase}`, "Response Headers", formatHeaders(r.headers), "", "Response Body");
+    lines.push(r.bodyEncoding === "base64" ? `[binary body, ${r.sizeBytes} bytes]` : r.body || "[empty]");
+  }
+  return lines.join("\n");
+}
+function emptyResponse(method, url) {
+  return {
+    statusCode: 0,
+    reasonPhrase: "",
+    durationMs: 0,
+    sizeBytes: 0,
+    resolvedUrl: url,
+    method,
+    requestHeaders: [],
+    headers: [],
+    cookies: [],
+    body: "",
+    bodyEncoding: "utf8",
+    contentType: "",
+    timings: { total: 0 },
+    testResults: [],
+    scriptLogs: [],
+    consoleText: "",
+    isError: false
+  };
+}
+function errorResponse(base, message) {
+  const r = { ...base, isError: true, errorMessage: message };
+  r.consoleText = consoleText(r);
+  return r;
+}
+async function scriptSend(spec, input, dispatcher) {
+  const base = emptyResponse(spec.method, spec.url);
+  try {
+    const headers = spec.headers.some((h) => h.key.toLowerCase() === "user-agent") ? spec.headers : [{ key: "User-Agent", value: YAMLET_USER_AGENT, enabled: true }, ...spec.headers];
+    const ex = await exchange({ url: spec.url, method: spec.method, headers, body: spec.body, dispatcher, signal: input.signal, followRedirects: true, jar: input.cookieJar });
+    const contentType = headerValue(ex.headers, "content-type") ?? "";
+    const textual = isTextual(contentType, ex.bytes);
+    return {
+      ...base,
+      statusCode: ex.status,
+      reasonPhrase: STATUS_CODES[ex.status] ?? "",
+      durationMs: Math.round(ex.totalMs),
+      sizeBytes: ex.bytes.length,
+      requestHeaders: ex.sentHeaders,
+      requestBody: spec.body,
+      headers: toHeaderList(ex.headers),
+      cookies: cookiesOf(spec.url, ex.headers),
+      body: textual ? decodeText(ex.bytes, contentType) : ex.bytes.toString("base64"),
+      bodyEncoding: textual ? "utf8" : "base64",
+      contentType,
+      timings: { total: Math.round(ex.totalMs), firstByte: Math.round(ex.firstByteMs) }
+    };
+  } catch (e) {
+    return errorResponse(base, errMessage2(e));
+  }
+}
+async function execute(input) {
+  const req = structuredClone(input.request);
+  const collection = input.collection;
+  const vars = new ScriptVariables({
+    request: req.variables ?? [],
+    iterationData: input.iterationData,
+    collection: collection ? structuredClone(collection.variables ?? []) : void 0,
+    environment: input.environment ? structuredClone(input.environment.variables ?? []) : void 0,
+    globals: structuredClone(input.globals ?? [])
+  });
+  const tests = [];
+  const logs = [];
+  const settings = { ...defaultSettings(), ...req.settings };
+  const dispatcher = input.dispatcher ?? (settings.skipSslVerification ? insecureAgent() : void 0);
+  const scriptBase = {
+    request: req,
+    variables: vars,
+    tests,
+    logs,
+    info: {
+      requestName: req.name,
+      requestId: req.id,
+      environmentName: input.environment?.name,
+      iteration: input.iteration,
+      iterationCount: input.iterationCount
+    },
+    sendRequest: (spec) => scriptSend(spec, input, dispatcher)
+  };
+  const finish = (response2) => {
+    const r = { ...response2, testResults: tests, scriptLogs: logs };
+    r.consoleText = consoleText(r);
+    return { response: r, changes: vars.changes() };
+  };
+  if (collection?.preRequestScript?.trim()) {
+    try {
+      await runScript({ ...scriptBase, script: collection.preRequestScript, phase: "pre" });
+    } catch (e) {
+      logs.push(`[error] Collection pre-request script: ${errMessage2(e)}`);
+    }
+  }
+  if (req.preRequestScript?.trim()) {
+    try {
+      await runScript({ ...scriptBase, script: req.preRequestScript, phase: "pre", throwOnFailure: input.throwOnTestFailure });
+    } catch (e) {
+      return finish(errorResponse(emptyResponse(req.method, req.url), `Pre-request script error: ${errMessage2(e)}`));
+    }
+  }
+  const ctx = vars.toContext();
+  const resolve2 = (s) => resolveVariables(s ?? "", ctx);
+  const auth = effectiveAuth(req, collection);
+  let oauthToken;
+  if (auth.type === "oauth2" && canFetchAutomatically(auth.oauth2, resolve2)) {
+    try {
+      oauthToken = (await getCachedToken(auth.oauth2, resolve2, { dispatcher, signal: input.signal })).accessToken;
+    } catch (e) {
+      return finish(errorResponse(emptyResponse(req.method, resolve2(req.url)), `OAuth 2.0 token request failed: ${errMessage2(e)}`));
+    }
+  }
+  const built = buildRequest(req, { ctx, collection, oauthToken });
+  let response = emptyResponse(built.method, built.url);
+  response.requestHeaders = built.headers;
+  const timeoutMs = settings.timeoutMs > 0 ? settings.timeoutMs : input.defaultTimeoutMs ?? 0;
+  const timeoutSignal = timeoutMs > 0 ? AbortSignal.timeout(timeoutMs) : void 0;
+  const signals = [input.signal, timeoutSignal].filter((s) => !!s);
+  const signal = signals.length > 1 ? AbortSignal.any(signals) : signals[0];
+  try {
+    const prepared = await prepareBody(built, input.workspaceRoot, req.sourceFilePath);
+    response.requestBody = prepared.display;
+    const ex = await exchange({
+      url: built.url,
+      method: built.method,
+      headers: built.headers,
+      body: prepared.body,
+      dispatcher,
+      signal,
+      followRedirects: settings.followRedirects !== false,
+      jar: input.cookieJar
+    });
+    const contentType = headerValue(ex.headers, "content-type") ?? "";
+    const textual = isTextual(contentType, ex.bytes);
+    response = {
+      ...response,
+      statusCode: ex.status,
+      reasonPhrase: STATUS_CODES[ex.status] ?? "",
+      durationMs: Math.round(ex.totalMs),
+      sizeBytes: ex.bytes.length,
+      requestHeaders: ex.sentHeaders,
+      headers: toHeaderList(ex.headers),
+      cookies: cookiesOf(built.url, ex.headers),
+      body: textual ? decodeText(ex.bytes, contentType) : ex.bytes.toString("base64"),
+      bodyEncoding: textual ? "utf8" : "base64",
+      contentType,
+      timings: { total: Math.round(ex.totalMs), firstByte: Math.round(ex.firstByteMs), download: Math.max(0, Math.round(ex.totalMs - ex.firstByteMs)) }
+    };
+  } catch (e) {
+    const message = input.signal?.aborted ? "Request was cancelled." : timeoutSignal?.aborted ? `Request timed out after ${timeoutMs} ms` : errMessage2(e);
+    return finish(errorResponse(response, message));
+  }
+  if (req.postResponseScript?.trim()) {
+    const before = tests.length;
+    try {
+      await runScript({ ...scriptBase, script: req.postResponseScript, phase: "post", response, throwOnFailure: input.throwOnTestFailure });
+    } catch (e) {
+      const message = errMessage2(e);
+      const last = tests.at(-1);
+      if (!(tests.length > before && last && !last.passed && last.error === message)) {
+        tests.push({ name: "Post-response script", passed: false, error: message });
+      }
+      logs.push(`[error] Post-response script: ${message}`);
+    }
+  }
+  if (collection?.postResponseScript?.trim()) {
+    try {
+      await runScript({ ...scriptBase, script: collection.postResponseScript, phase: "post", response });
+    } catch (e) {
+      logs.push(`[error] Collection post-response script: ${errMessage2(e)}`);
+    }
+  }
+  return finish(response);
+}
+
+// core/src/collectionRunner.ts
+function walk(collection, node, chain, out) {
+  for (const f of node.folders) walk(collection, f, [...chain, f.name], out);
+  for (const request3 of node.requests) out.push({ request: request3, collection, path: chain });
+}
+function findFolderNode(node, id, chain) {
+  for (const f of node.folders) {
+    if (f.id === id) return { folder: f, chain: [...chain, f.name] };
+    const hit = findFolderNode(f, id, [...chain, f.name]);
+    if (hit) return hit;
+  }
+  return void 0;
+}
+function planRun(workspace, opts) {
+  const collections = [...workspace.collections].sort((a, b) => a.order - b.order).filter((c) => !opts.collectionIds?.length || opts.collectionIds.includes(c.id));
+  const all = [];
+  if (opts.folderId) {
+    for (const c of collections) {
+      const hit = findFolderNode(c, opts.folderId, []);
+      if (hit) {
+        walk(c, hit.folder, hit.chain, all);
+        break;
+      }
+    }
+  } else for (const c of collections) walk(c, c, [], all);
+  if (!opts.requestIds?.length) return all;
+  const everywhere = [];
+  for (const c of collections) walk(c, c, [], everywhere);
+  const byId = new Map(everywhere.map((p) => [p.request.id, p]));
+  return opts.requestIds.map((id) => byId.get(id)).filter((p) => !!p);
+}
+function sleep(ms, signal) {
+  return new Promise((resolve2) => {
+    if (ms <= 0 || signal?.aborted) return resolve2();
+    const t = setTimeout(done, ms);
+    function done() {
+      clearTimeout(t);
+      signal?.removeEventListener("abort", done);
+      resolve2();
+    }
+    signal?.addEventListener("abort", done, { once: true });
+  });
+}
+async function runCollection(opts) {
+  const workspace = opts.workspace ?? opts.store?.workspace;
+  if (!workspace) throw new Error("runCollection needs a workspace or a store");
+  const started = Date.now();
+  const plan = planRun(workspace, opts);
+  const iterations = opts.data?.length ? opts.data.length : Math.max(1, Math.floor(opts.iterations ?? 1));
+  let environment = opts.environment ? structuredClone(opts.environment) : void 0;
+  let globals = structuredClone(opts.globals ?? []);
+  const collectionVars = /* @__PURE__ */ new Map();
+  const collectionFor = (c) => {
+    if (!collectionVars.has(c.id)) collectionVars.set(c.id, structuredClone(c.variables ?? []));
+    return { ...c, variables: collectionVars.get(c.id) };
+  };
+  const results = [];
+  let stopped = false;
+  outer: for (let iteration = 0; iteration < iterations; iteration++) {
+    for (const item of plan) {
+      if (opts.signal?.aborted) {
+        stopped = true;
+        break outer;
+      }
+      if (results.length && opts.delayMs) await sleep(opts.delayMs, opts.signal);
+      if (opts.signal?.aborted) {
+        stopped = true;
+        break outer;
+      }
+      const collection = collectionFor(item.collection);
+      const { response, changes } = await execute({
+        request: item.request,
+        collection,
+        environment,
+        globals,
+        workspaceRoot: opts.workspaceRoot,
+        cookieJar: opts.cookieJar,
+        iterationData: opts.data?.[iteration],
+        dispatcher: opts.dispatcher,
+        signal: opts.signal,
+        defaultTimeoutMs: opts.defaultTimeoutMs,
+        iteration,
+        iterationCount: iterations
+      });
+      if (changes.environment && environment) environment = { ...environment, variables: changes.environment };
+      if (changes.globals) globals = changes.globals;
+      if (changes.collectionVariables) collectionVars.set(item.collection.id, changes.collectionVariables);
+      const transportError = response.isError;
+      const statusOk = response.statusCode >= 200 && response.statusCode <= 399;
+      const passed = !transportError && statusOk && response.testResults.every((t) => t.passed);
+      const result = {
+        iteration,
+        requestId: item.request.id,
+        name: item.request.name,
+        path: item.path,
+        collectionId: item.collection.id,
+        collectionName: item.collection.name,
+        method: response.method || item.request.method,
+        url: response.resolvedUrl || item.request.url,
+        status: response.statusCode,
+        durationMs: response.durationMs,
+        sizeBytes: response.sizeBytes,
+        tests: response.testResults,
+        passed
+      };
+      if (transportError) result.error = response.errorMessage ?? "Request failed";
+      else if (!statusOk) result.error = `Unexpected status ${response.statusCode}${response.reasonPhrase ? " " + response.reasonPhrase : ""}`;
+      results.push(result);
+      opts.onResult?.(result);
+      if (opts.bail && !passed) {
+        stopped = true;
+        break outer;
+      }
+    }
+  }
+  const failed = results.filter((r) => !r.passed).length;
+  return {
+    results,
+    total: results.length,
+    passed: results.length - failed,
+    failed,
+    durationMs: Date.now() - started,
+    iterations,
+    assertions: {
+      total: results.reduce((n, r) => n + r.tests.length, 0),
+      failed: results.reduce((n, r) => n + r.tests.filter((t) => !t.passed).length, 0)
+    },
+    variables: { environment: environment?.variables, globals, collections: Object.fromEntries(collectionVars) },
+    stopped
+  };
+}
+function parseCsv(text) {
+  const rows = [];
+  let row = [];
+  let field = "";
+  let quoted = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (quoted) {
+      if (ch === '"') {
+        if (text[i + 1] === '"') {
+          field += '"';
+          i++;
+        } else quoted = false;
+      } else field += ch;
+      continue;
+    }
+    if (ch === '"' && field === "") quoted = true;
+    else if (ch === ",") {
+      row.push(field);
+      field = "";
+    } else if (ch === "\n" || ch === "\r") {
+      if (ch === "\r" && text[i + 1] === "\n") i++;
+      row.push(field);
+      rows.push(row);
+      row = [];
+      field = "";
+    } else field += ch;
+  }
+  if (field !== "" || row.length) {
+    row.push(field);
+    rows.push(row);
+  }
+  return rows.filter((r) => !(r.length === 1 && r[0].trim() === ""));
+}
+var cell = (v) => v === null || v === void 0 ? "" : typeof v === "object" ? JSON.stringify(v) : String(v);
+function parseDataFile(text, filename) {
+  const body = text.replace(/^/, "");
+  const isJson = /\.json$/i.test(filename) || !/\.csv$/i.test(filename) && /^\s*[[{]/.test(body);
+  if (isJson) {
+    const parsed = JSON.parse(body);
+    const list = Array.isArray(parsed) ? parsed : [parsed];
+    return list.map((item, i) => {
+      if (!item || typeof item !== "object" || Array.isArray(item)) throw new Error(`Row ${i + 1} is not an object`);
+      return Object.fromEntries(Object.entries(item).map(([k, v]) => [k, cell(v)]));
+    });
+  }
+  const rows = parseCsv(body);
+  if (!rows.length) return [];
+  const header = rows[0].map((h) => h.trim());
+  return rows.slice(1).map((r) => Object.fromEntries(header.map((h, i) => [h, r[i] ?? ""])));
+}
+
+// core/src/workspaceStore.ts
+import { existsSync as existsSync3, promises as fs2, statSync } from "node:fs";
+import path3 from "node:path";
+
+// core/src/pathNaming.ts
+import { existsSync as existsSync2 } from "node:fs";
+import path2 from "node:path";
+function slugify(name, fallback = "untitled") {
+  if (!name?.trim()) return fallback;
+  let out = "";
+  let lastHyphen = false;
+  for (const ch of name.trim().toLowerCase()) {
+    if (/[a-z0-9]/.test(ch)) {
+      out += ch;
+      lastHyphen = false;
+    } else if (" -_./".includes(ch)) {
+      if (!lastHyphen && out.length > 0) {
+        out += "-";
+        lastHyphen = true;
+      }
+    }
+  }
+  out = out.replace(/^-+|-+$/g, "");
+  return out || fallback;
+}
+function uniqueFilePath(directory, fileName, except) {
+  const ext = path2.extname(fileName);
+  const base = fileName.slice(0, fileName.length - ext.length);
+  let candidate = path2.join(directory, fileName);
+  for (let n = 2; existsSync2(candidate) && candidate !== except; n++) {
+    candidate = path2.join(directory, `${base}-${n}${ext}`);
+  }
+  return candidate;
+}
+function uniqueDirectoryPath(parent, name, except) {
+  let candidate = path2.join(parent, name);
+  for (let n = 2; existsSync2(candidate) && candidate !== except; n++) {
+    candidate = path2.join(parent, `${name}-${n}`);
+  }
+  return candidate;
+}
+
+// core/src/yamlDtos.ts
+import { Document, isAlias, isMap, isScalar, isSeq, parseDocument, stringify } from "yaml";
+function loadYaml(text) {
+  if (!text?.trim()) return {};
+  const doc = parseDocument(text, { uniqueKeys: false });
+  if (doc.errors.length) throw doc.errors[0];
+  const toPlain = (n) => {
+    if (isAlias(n)) return toPlain(n.resolve(doc));
+    if (isMap(n)) {
+      const o = {};
+      for (const p of n.items) {
+        const k = isScalar(p.key) ? String(p.key.value ?? "") : String(p.key ?? "");
+        o[k] = toPlain(p.value);
+      }
+      return o;
+    }
+    if (isSeq(n)) return n.items.map(toPlain);
+    if (isScalar(n)) {
+      if (typeof n.value === "number" || typeof n.value === "bigint") return n.source ?? String(n.value);
+      return n.value;
+    }
+    return n ?? null;
+  };
+  return toPlain(doc.contents) ?? {};
+}
+var STRINGIFY_OPTS = { lineWidth: 0 };
+function dumpYaml(value) {
+  return stringify(value, STRINGIFY_OPTS);
+}
+function dumpYamlPreserving(value, original, known) {
+  if (!original?.trim()) return dumpYaml(value);
+  try {
+    const orig = parseDocument(original);
+    if (orig.errors.length || !isMap(orig.contents)) return dumpYaml(value);
+    const doc = new Document(value);
+    const target = doc.contents;
+    if (!isMap(target)) return dumpYaml(value);
+    for (const pair of orig.contents.items) {
+      const key = isScalar(pair.key) ? String(pair.key.value) : void 0;
+      if (!key || known.has(key) || isDropped(key) || doc.has(key)) continue;
+      target.items.push(pair);
+    }
+    return doc.toString(STRINGIFY_OPTS);
+  } catch {
+    return dumpYaml(value);
+  }
+}
+var isDropped = (key) => /^_[a-z0-9]+_[a-z_]+$/i.test(key);
+var isObj = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+function str(v) {
+  if (v === null || v === void 0) return "";
+  if (typeof v === "string") return v;
+  if (Array.isArray(v) && v.every((x) => typeof x === "string")) return v.join("\n");
+  if (typeof v === "object") return JSON.stringify(v);
+  return String(v);
+}
+var optStr = (v) => v === null || v === void 0 ? void 0 : str(v);
+function bool(v) {
+  if (v === true || v === false) return v;
+  if (typeof v === "string") {
+    const t = v.trim().toLowerCase();
+    if (t === "true") return true;
+    if (t === "false") return false;
+  }
+  return void 0;
+}
+function int(v) {
+  if (typeof v === "number") return Math.trunc(v);
+  if (typeof v === "string" && /^-?\d+(\.\d+)?$/.test(v.trim())) return Math.trunc(Number(v));
+  return void 0;
+}
+function readEnabled(o) {
+  const disabled = bool(o.disabled);
+  if (disabled !== void 0) return !disabled;
+  return bool(o.enabled) ?? true;
+}
+function readRows(raw) {
+  if (Array.isArray(raw)) {
+    return raw.filter(isObj).map((o) => ({ key: str(o.key ?? o.name), value: str(o.value), description: optStr(o.description), enabled: readEnabled(o), o }));
+  }
+  if (isObj(raw)) {
+    return Object.entries(raw).map(([key, value]) => ({ key, value: str(value), enabled: true, o: {} }));
+  }
+  return [];
+}
+function readKeyValues(raw) {
+  return readRows(raw).map((r) => {
+    const kv = { key: r.key, value: r.value, enabled: r.enabled };
+    if (r.description) kv.description = r.description;
+    return kv;
+  });
+}
+function readVariables(raw) {
+  return readRows(raw).map((r) => {
+    const v = { key: r.key, value: r.value, enabled: r.enabled };
+    if (str(r.o.type).toLowerCase() === "secret" || bool(r.o.secret) === true) v.secret = true;
+    return v;
+  });
+}
+function writeKeyValues(list) {
+  if (!list?.length) return void 0;
+  return list.map((kv) => {
+    const o = { key: kv.key, value: kv.value ?? "" };
+    if (kv.description) o.description = kv.description;
+    if (kv.enabled === false) o.enabled = false;
+    return o;
+  });
+}
+function writeVariables(list) {
+  if (!list?.length) return void 0;
+  return list.map((v) => {
+    const o = { key: v.key, value: v.value ?? "" };
+    if (v.secret) o.type = "secret";
+    if (v.enabled === false) o.enabled = false;
+    return o;
+  });
+}
+function authType(raw) {
+  switch (str(raw).trim().toLowerCase()) {
+    case "bearer":
+      return "bearer";
+    case "basic":
+      return "basic";
+    case "apikey":
+    case "api-key":
+    case "api_key":
+      return "apikey";
+    case "cookie":
+      return "cookie";
+    case "oauth2":
+      return "oauth2";
+    case "inherit":
+    case "inherited":
+      return "inherit";
+    default:
+      return "none";
+  }
+}
+function grantType(raw) {
+  switch (str(raw).trim().toLowerCase()) {
+    case "authorization_code":
+    case "authorization-code":
+    case "authorization_code_with_pkce":
+      return "authorization_code";
+    case "password":
+    case "password_credentials":
+      return "password";
+    default:
+      return "client_credentials";
+  }
+}
+function credential(block, key) {
+  if (Array.isArray(block)) {
+    const hit = block.filter(isObj).find((kv) => str(kv.key).toLowerCase() === key.toLowerCase());
+    return hit ? str(hit.value) : void 0;
+  }
+  if (isObj(block)) {
+    const k = Object.keys(block).find((x) => x.toLowerCase() === key.toLowerCase());
+    return k ? str(block[k]) : void 0;
+  }
+  return void 0;
+}
+function readOAuth2(o) {
+  const get = (...keys) => {
+    for (const k of keys) {
+      const v = credential(o, k);
+      if (v !== void 0) return v;
+    }
+    return void 0;
+  };
+  const d = defaultOAuth2();
+  const addTo = (get("addTokenTo") ?? "").toLowerCase();
+  const clientAuth = (get("client_authentication", "clientAuthentication") ?? "").toLowerCase();
+  const challenge = get("challengeAlgorithm");
+  return {
+    grantType: grantType(get("grant_type", "grantType")),
+    accessToken: get("accessToken", "access_token") ?? "",
+    refreshToken: get("refreshToken", "refresh_token") ?? "",
+    headerPrefix: get("headerPrefix", "tokenType")?.trim() || d.headerPrefix,
+    accessTokenUrl: get("accessTokenUrl", "tokenUrl", "access_token_url") ?? "",
+    authUrl: get("authUrl", "authorizationUrl", "auth_url") ?? "",
+    clientId: get("clientId", "client_id") ?? "",
+    clientSecret: get("clientSecret", "client_secret") ?? "",
+    scope: get("scope") ?? "",
+    redirectUri: get("redirect_uri", "redirectUri", "redirect_url", "callbackUrl") ?? "",
+    username: get("username") ?? "",
+    password: get("password") ?? "",
+    addTokenTo: addTo === "queryparams" || addTo === "query" ? "query" : "header",
+    clientAuthentication: clientAuth === "body" ? "body" : "basic",
+    challengeAlgorithm: challenge?.trim().toLowerCase() === "plain" ? "plain" : "S256"
+  };
+}
+function readAuth(raw, fallback = "none") {
+  if (!isObj(raw)) return defaultAuth(fallback);
+  const type = raw.type === void 0 ? fallback : authType(raw.type);
+  const a = defaultAuth(type);
+  const typed = (name) => raw[name];
+  a.token = credential(typed("bearer"), "token") ?? str(raw.token);
+  a.username = credential(typed("basic"), "username") ?? str(raw.username);
+  a.password = credential(typed("basic"), "password") ?? str(raw.password);
+  a.apiKeyName = credential(typed("apikey"), "key") ?? str(raw.key);
+  a.apiKeyValue = credential(typed("apikey"), "value") ?? str(raw.value);
+  a.apiKeyIn = (credential(typed("apikey"), "in") ?? str(raw.in)).toLowerCase() === "query" ? "query" : "header";
+  a.cookie = str(raw.cookie);
+  if (isObj(raw.credentials)) a.oauth2 = readOAuth2(raw.credentials);
+  else if (raw.oauth2 !== void 0) a.oauth2 = readOAuth2(raw.oauth2);
+  return a;
+}
+function writeOAuth2(o) {
+  const out = {
+    grant_type: o.grantType === "authorization_code" ? "authorization_code" : o.grantType === "password" ? "password_credentials" : "client_credentials"
+  };
+  const put = (k, v) => {
+    if (v) out[k] = v;
+  };
+  put("accessTokenUrl", o.accessTokenUrl);
+  put("authUrl", o.authUrl);
+  put("clientId", o.clientId);
+  put("clientSecret", o.clientSecret);
+  put("scope", o.scope);
+  put("redirect_uri", o.redirectUri);
+  put("username", o.username);
+  put("password", o.password);
+  put("accessToken", o.accessToken);
+  put("refreshToken", o.refreshToken);
+  if (o.headerPrefix && o.headerPrefix !== "Bearer") out.tokenType = o.headerPrefix;
+  if (o.addTokenTo === "query") out.addTokenTo = "queryParams";
+  if (o.clientAuthentication === "body") out.client_authentication = "body";
+  if (o.challengeAlgorithm === "plain") out.challengeAlgorithm = "plain";
+  return out;
+}
+function writeAuth(a) {
+  const out = { type: a.type === "none" ? "noauth" : a.type };
+  const put = (k, v) => {
+    if (v) out[k] = v;
+  };
+  put("token", a.token);
+  put("username", a.username);
+  put("password", a.password);
+  put("key", a.apiKeyName);
+  put("value", a.apiKeyValue);
+  if (a.type === "apikey") out.in = a.apiKeyIn === "query" ? "query" : "header";
+  put("cookie", a.cookie);
+  if (a.type === "oauth2") out.credentials = writeOAuth2(a.oauth2);
+  return out;
+}
+function isPreScriptType(type) {
+  const t = str(type).toLowerCase().replace(/-/g, "");
+  return t.includes("pre") || t.includes("before");
+}
+function readScripts(raw) {
+  const pre = [];
+  const post = [];
+  if (Array.isArray(raw)) {
+    for (const s of raw.filter(isObj)) {
+      const code = str(s.code ?? s.exec ?? s.script);
+      if (!code) continue;
+      (isPreScriptType(s.type) ? pre : post).push(code);
+    }
+  } else if (isObj(raw)) {
+    for (const [type, code] of Object.entries(raw)) {
+      const c = str(code);
+      if (c) (isPreScriptType(type) ? pre : post).push(c);
+    }
+  }
+  return { pre: pre.join("\n\n"), post: post.join("\n\n") };
+}
+function writeScripts(pre, post) {
+  const list = [];
+  if (pre) list.push({ type: "preRequest", code: pre });
+  if (post) list.push({ type: "afterResponse", code: post });
+  return list.length ? list : void 0;
+}
+function bodyType(raw) {
+  switch (str(raw).trim().toLowerCase()) {
+    case "raw":
+      return "raw";
+    case "json":
+      return "json";
+    case "xml":
+      return "xml";
+    case "text":
+      return "text";
+    case "html":
+      return "html";
+    case "graphql":
+      return "graphql";
+    case "form-data":
+    case "formdata":
+    case "multipart-form":
+    case "multipart":
+      return "form-data";
+    case "x-www-form-urlencoded":
+    case "urlencoded":
+    case "form-urlencoded":
+      return "urlencoded";
+    case "binary":
+    case "file":
+      return "binary";
+    default:
+      return "none";
+  }
+}
+function readField(o) {
+  const isFile = str(o.type).toLowerCase() === "file" || bool(o.isFile) === true;
+  const src = Array.isArray(o.src) ? str(o.src[0]) : optStr(o.src);
+  const field = {
+    key: str(o.key ?? o.name),
+    value: isFile ? src ?? str(o.value) : str(o.value),
+    enabled: readEnabled(o)
+  };
+  if (o.description !== void 0 && o.description !== null) field.description = str(o.description);
+  if (isFile) field.isFile = true;
+  return field;
+}
+function readBody(raw) {
+  const b = defaultBody();
+  if (!isObj(raw)) return b;
+  b.type = bodyType(raw.type ?? raw.mode);
+  const content = raw.content;
+  b.raw = optStr(raw.raw) ?? (typeof content === "string" ? content : "");
+  const fieldsRaw = Array.isArray(raw.fields) ? raw.fields : Array.isArray(content) ? content : void 0;
+  if (fieldsRaw) b.fields = fieldsRaw.filter(isObj).map(readField);
+  else if (isObj(content) && (b.type === "form-data" || b.type === "urlencoded"))
+    b.fields = Object.entries(content).map(([key, value]) => ({ key, value: str(value), enabled: true }));
+  const gql = isObj(raw.graphql) ? raw.graphql : raw;
+  b.graphqlQuery = str(gql.query);
+  b.graphqlVariables = gql.variables === void 0 || gql.variables === null ? "" : typeof gql.variables === "string" ? gql.variables : JSON.stringify(gql.variables, null, 2);
+  if (b.type === "graphql" && !b.graphqlQuery && b.raw) b.graphqlQuery = b.raw;
+  b.binaryFile = str(raw.file ?? raw.binaryFile ?? (b.type === "binary" && typeof raw.src === "string" ? raw.src : ""));
+  if (b.type === "binary" && !b.binaryFile && b.raw) b.binaryFile = b.raw;
+  return b;
+}
+function writeField(f) {
+  const o = { type: f.isFile ? "file" : "text", key: f.key };
+  if (f.isFile) o.src = f.value.startsWith("@") ? f.value.slice(1) : f.value;
+  else o.value = f.value ?? "";
+  if (f.description) o.description = f.description;
+  if (f.enabled === false) o.enabled = false;
+  return o;
+}
+var BODY_TYPE_NAMES = {
+  none: "none",
+  raw: "raw",
+  json: "json",
+  xml: "xml",
+  text: "text",
+  html: "html",
+  "form-data": "form-data",
+  urlencoded: "x-www-form-urlencoded",
+  graphql: "graphql",
+  binary: "binary"
+};
+function writeBody(b) {
+  const out = { type: BODY_TYPE_NAMES[b.type] ?? "none" };
+  if (b.raw) out.raw = b.raw;
+  const fields = b.fields?.filter((f) => f.key?.trim() || f.value);
+  if (fields?.length) out.content = fields.map(writeField);
+  if (b.graphqlQuery || b.graphqlVariables) {
+    const g = {};
+    if (b.graphqlQuery) g.query = b.graphqlQuery;
+    if (b.graphqlVariables) g.variables = b.graphqlVariables;
+    out.graphql = g;
+  }
+  if (b.binaryFile) out.file = b.binaryFile;
+  if (b.type === "none" && Object.keys(out).length === 1) return void 0;
+  return out;
+}
+function readSettings(o) {
+  const s = defaultSettings();
+  const raw = isObj(o.settings) ? o.settings : {};
+  s.timeoutMs = int(raw.timeoutMs ?? raw.timeout) ?? 0;
+  s.followRedirects = bool(raw.followRedirects) ?? true;
+  const ssl = isObj(o.ssl) ? o.ssl : {};
+  s.skipSslVerification = bool(raw.skipSslVerification) ?? bool(o.skipSslVerification) ?? bool(ssl.skipVerification) ?? (bool(ssl.verify) === false ? true : void 0) ?? false;
+  return s;
+}
+function writeSettings(s) {
+  if (!s) return void 0;
+  const out = {};
+  if (s.timeoutMs > 0) out.timeoutMs = s.timeoutMs;
+  if (s.followRedirects === false) out.followRedirects = false;
+  if (s.skipSslVerification) out.skipSslVerification = true;
+  return Object.keys(out).length ? out : void 0;
+}
+function readExamples(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.filter(isObj).map((o) => {
+    const e = {
+      id: str(o.id) || newId(),
+      name: str(o.name),
+      status: int(o.status ?? o.code) ?? 0,
+      headers: readKeyValues(o.headers),
+      body: str(o.body)
+    };
+    if (o.contentType) e.contentType = str(o.contentType);
+    if (o.savedAt) e.savedAt = str(o.savedAt);
+    return e;
+  });
+}
+function writeExamples(list) {
+  if (!list?.length) return void 0;
+  return list.map((e) => {
+    const o = { id: e.id, name: e.name, status: e.status };
+    const h = writeKeyValues(e.headers);
+    if (h) o.headers = h;
+    if (e.contentType) o.contentType = e.contentType;
+    if (e.body) o.body = e.body;
+    if (e.savedAt) o.savedAt = e.savedAt;
+    return o;
+  });
+}
+var REQUEST_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "name",
+  "description",
+  "order",
+  "method",
+  "url",
+  "queryParams",
+  "headers",
+  "pathVariables",
+  "variables",
+  "auth",
+  "body",
+  "scripts",
+  "settings",
+  "examples",
+  "skipSslVerification",
+  "ssl"
+]);
+function deriveNameFromFile(filePath) {
+  let name = filePath.split(/[\\/]/).pop() ?? filePath;
+  name = name.replace(/\.ya?ml$/i, "");
+  return name.replace(/\.request$/i, "");
+}
+function requestFromDto(raw, sourceFilePath) {
+  const o = isObj(raw) ? raw : {};
+  const name = str(o.name).trim() ? str(o.name) : sourceFilePath ? deriveNameFromFile(sourceFilePath) : "";
+  const scripts = readScripts(o.scripts);
+  const req = {
+    id: str(o.id).trim() || newId(),
+    name,
+    method: str(o.method).trim() ? str(o.method).trim().toUpperCase() : "GET",
+    url: str(o.url),
+    headers: readKeyValues(o.headers),
+    queryParams: readKeyValues(o.queryParams),
+    pathVariables: readRows(o.pathVariables).map((r) => {
+      const p = { key: r.key, value: r.value };
+      if (r.description) p.description = r.description;
+      return p;
+    }),
+    body: readBody(o.body),
+    auth: o.auth === void 0 || o.auth === null ? defaultAuth("inherit") : readAuth(o.auth, "none"),
+    variables: readVariables(o.variables),
+    description: str(o.description),
+    preRequestScript: scripts.pre,
+    postResponseScript: scripts.post,
+    settings: readSettings(o),
+    examples: readExamples(o.examples),
+    order: int(o.order) ?? 0
+  };
+  if (sourceFilePath) req.sourceFilePath = sourceFilePath;
+  return req;
+}
+function requestToDto(r) {
+  const o = { id: r.id, name: r.name };
+  if (r.description) o.description = r.description;
+  o.order = r.order ?? 0;
+  o.method = (r.method || "GET").toUpperCase();
+  o.url = r.url ?? "";
+  const put = (k, v) => {
+    if (v !== void 0) o[k] = v;
+  };
+  put("queryParams", writeKeyValues(r.queryParams));
+  put("headers", writeKeyValues(r.headers));
+  put(
+    "pathVariables",
+    r.pathVariables?.length ? r.pathVariables.map((p) => {
+      const x = { key: p.key, value: p.value ?? "" };
+      if (p.description) x.description = p.description;
+      return x;
+    }) : void 0
+  );
+  put("variables", writeVariables(r.variables));
+  if (r.auth && r.auth.type !== "inherit") o.auth = writeAuth(r.auth);
+  put("body", r.body ? writeBody(r.body) : void 0);
+  put("scripts", writeScripts(r.preRequestScript, r.postResponseScript));
+  put("settings", writeSettings(r.settings));
+  put("examples", writeExamples(r.examples));
+  return o;
+}
+function requestToYaml(r, original) {
+  return dumpYamlPreserving(requestToDto(r), original, REQUEST_KEYS);
+}
+var COLLECTION_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "name",
+  "description",
+  "order",
+  "variables",
+  "auth",
+  "scripts",
+  // Read-only aliases from the collection v2.1 shape; migrated on save.
+  "info",
+  "item",
+  "variable",
+  "event"
+]);
+function eventScript(events, listen) {
+  if (!Array.isArray(events)) return "";
+  const ev = events.filter(isObj).find((e) => str(e.listen).toLowerCase() === listen);
+  if (!ev) return "";
+  const script = isObj(ev.script) ? ev.script : {};
+  const exec = script.exec;
+  return Array.isArray(exec) ? exec.map(str).join("\n") : str(exec);
+}
+function applyCollectionMetadata(c, raw) {
+  if (!isObj(raw)) return;
+  const info = isObj(raw.info) ? raw.info : void 0;
+  const legacyIdKey = info ? Object.keys(info).find((k) => /^_[a-z0-9]+_id$/i.test(k)) : void 0;
+  const id = legacyIdKey && str(info[legacyIdKey]) || str(raw.id);
+  const name = info && str(info.name) || str(raw.name);
+  if (id.trim()) c.id = id;
+  if (name.trim()) c.name = name;
+  const description = (info && optStr(info.description)) ?? optStr(raw.description);
+  if (description) c.description = description;
+  const order = int(raw.order);
+  if (order !== void 0) c.order = order;
+  if (isObj(raw.auth)) c.auth = readAuth(raw.auth, "none");
+  const legacyVars = Array.isArray(raw.variable) ? readVariables(raw.variable) : [];
+  const vars = legacyVars.length ? legacyVars : readVariables(raw.variables);
+  if (vars.length) c.variables = vars;
+  const scripts = readScripts(raw.scripts);
+  const pre = eventScript(raw.event, "prerequest") || scripts.pre;
+  const post = eventScript(raw.event, "test") || scripts.post;
+  if (pre) c.preRequestScript = pre;
+  if (post) c.postResponseScript = post;
+}
+function applyCollectionDefinition(c, raw) {
+  if (!isObj(raw)) return;
+  if (str(raw.name).trim()) c.name = str(raw.name);
+  if (raw.description) c.description = str(raw.description);
+  const vars = readVariables(raw.variables);
+  if (vars.length) c.variables = vars;
+  const auth = Array.isArray(raw.auth) ? raw.auth.find(isObj) : isObj(raw.auth) ? raw.auth : void 0;
+  if (auth) c.auth = readAuth(auth, "none");
+  const scripts = readScripts(raw.scripts);
+  if (scripts.pre) c.preRequestScript = scripts.pre;
+  if (scripts.post) c.postResponseScript = scripts.post;
+}
+function collectionToDto(c) {
+  const o = { id: c.id, name: c.name };
+  if (c.description) o.description = c.description;
+  o.order = c.order ?? 0;
+  const vars = writeVariables(c.variables);
+  if (vars) o.variables = vars;
+  if (c.auth && c.auth.type !== "none" && c.auth.type !== "inherit") o.auth = writeAuth(c.auth);
+  const scripts = writeScripts(c.preRequestScript, c.postResponseScript);
+  if (scripts) o.scripts = scripts;
+  return o;
+}
+function collectionToYaml(c, original) {
+  return dumpYamlPreserving(collectionToDto(c), original, COLLECTION_KEYS);
+}
+var FOLDER_KEYS = /* @__PURE__ */ new Set(["id", "name", "description", "order"]);
+function applyFolderMetadata(f, raw) {
+  if (!isObj(raw)) return;
+  if (str(raw.id).trim()) f.id = str(raw.id);
+  if (str(raw.name).trim()) f.name = str(raw.name);
+  if (raw.description) f.description = str(raw.description);
+  const order = int(raw.order);
+  if (order !== void 0) f.order = order;
+}
+function folderToDto(f) {
+  const o = { id: f.id, name: f.name };
+  if (f.description) o.description = f.description;
+  o.order = f.order ?? 0;
+  return o;
+}
+function folderToYaml(f, original) {
+  return dumpYamlPreserving(folderToDto(f), original, FOLDER_KEYS);
+}
+var ENVIRONMENT_KEYS = /* @__PURE__ */ new Set(["id", "name", "variables", "values"]);
+function deriveEnvironmentName(filePath) {
+  return deriveNameFromFile(filePath).replace(/\.environment$/i, "");
+}
+function environmentFromDto(raw, filePath) {
+  const o = isObj(raw) ? raw : {};
+  const vars = o.variables !== void 0 && o.variables !== null ? o.variables : o.values;
+  const env = {
+    id: str(o.id).trim() || newId(),
+    name: str(o.name).trim() ? str(o.name) : filePath ? deriveEnvironmentName(filePath) : "",
+    variables: readVariables(vars)
+  };
+  if (filePath) env.filePath = filePath;
+  return env;
+}
+function environmentToDto(e) {
+  const o = { id: e.id, name: e.name };
+  const vars = writeVariables(e.variables);
+  if (vars) o.variables = vars;
+  return o;
+}
+function environmentFromYaml(text, filePath) {
+  return environmentFromDto(loadYaml(text), filePath);
+}
+function environmentToYaml(e, original) {
+  return dumpYamlPreserving(environmentToDto(e), original, ENVIRONMENT_KEYS);
+}
+function globalsFromYaml(text) {
+  const o = loadYaml(text);
+  return isObj(o) ? readVariables(o.variables ?? o.values) : [];
+}
+function globalsToYaml(vars, original) {
+  return dumpYamlPreserving({ variables: writeVariables(vars) ?? [] }, original, /* @__PURE__ */ new Set(["variables", "values"]));
+}
+
+// core/src/workspaceStore.ts
+var ROOT_DIR_NAME = "yamlet";
+var COLLECTIONS_DIR = "collections";
+var ENVIRONMENTS_DIR = "environments";
+var GLOBALS_DIR = "globals";
+var GLOBALS_FILE = "globals.yaml";
+var COLLECTION_FILE = "collection.yaml";
+var FOLDER_FILE = "folder.yaml";
+var DEFINITION_FILE = path3.join(".resources", "definition.yaml");
+var REQUEST_EXTENSION = ".yaml";
+var isDir = (p) => {
+  try {
+    return statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+};
+var isYamlFile = (name) => /\.ya?ml$/i.test(name);
+function stableId(prefix, key) {
+  let h = 0xcbf29ce484222325n;
+  for (const b of new TextEncoder().encode(key)) {
+    h ^= BigInt(b);
+    h = h * 0x100000001b3n & 0xffffffffffffffffn;
+  }
+  return `${prefix}-${h.toString(16).padStart(16, "0")}`;
+}
+var ordinal = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+var byOrder = (list) => list.sort((a, b) => a.order - b.order);
+var nextOrder = (list) => list.reduce((m, x) => Math.max(m, (x.order ?? 0) + 1), 0);
+async function readIfExists(p) {
+  if (!p) return void 0;
+  try {
+    return await fs2.readFile(p, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+async function writeFileAtomic(p, content) {
+  await fs2.mkdir(path3.dirname(p), { recursive: true });
+  const tmp = `${p}.${process.pid}.${Date.now().toString(36)}.tmp`;
+  await fs2.writeFile(tmp, content, "utf8");
+  await fs2.rename(tmp, p);
+}
+async function listDir(dir) {
+  try {
+    const entries = await fs2.readdir(dir, { withFileTypes: true });
+    return entries.map((e) => ({ name: e.name, dir: e.isDirectory() })).sort((a, b) => ordinal(a.name, b.name));
+  } catch {
+    return [];
+  }
+}
+function repath(p, from, to) {
+  if (!p) return p;
+  if (p === from) return to;
+  return p.startsWith(from + path3.sep) ? to + p.slice(from.length) : p;
+}
+function repathTree(node, from, to) {
+  node.directoryPath = repath(node.directoryPath, from, to);
+  if ("filePath" in node) node.filePath = repath(node.filePath, from, to);
+  for (const r of node.requests) r.sourceFilePath = repath(r.sourceFilePath, from, to);
+  for (const f of node.folders) repathTree(f, from, to);
+}
+function freshIds(node) {
+  node.id = newId();
+  for (const r of node.requests) {
+    r.id = newId();
+    for (const e of r.examples ?? []) e.id = newId();
+  }
+  for (const f of node.folders) freshIds(f);
+}
+function copyName(name) {
+  return `${name} Copy`;
+}
+var WorkspaceStore = class _WorkspaceStore {
+  workspace;
+  queue = Promise.resolve();
+  constructor(workspace) {
+    this.workspace = workspace;
+  }
+  // ---- Opening -------------------------------------------------------------
+  /** The picked folder if it already holds collections/ + environments/ (or is named `yamlet`), else `<dir>/yamlet`. */
+  static resolveRoot(dir) {
+    const abs = path3.resolve(dir);
+    const looksLikeRoot = isDir(path3.join(abs, COLLECTIONS_DIR)) && isDir(path3.join(abs, ENVIRONMENTS_DIR));
+    if (looksLikeRoot || path3.basename(abs).toLowerCase() === ROOT_DIR_NAME) return abs;
+    return path3.join(abs, ROOT_DIR_NAME);
+  }
+  static async isWorkspace(dir) {
+    return isDir(path3.join(_WorkspaceStore.resolveRoot(dir), COLLECTIONS_DIR));
+  }
+  /** Opens an existing workspace. Does not create anything on disk. */
+  static async open(dir) {
+    const root = _WorkspaceStore.resolveRoot(dir);
+    if (!isDir(root)) throw new Error(`No Yamlet workspace found at ${dir}`);
+    return new _WorkspaceStore(await loadWorkspace(root));
+  }
+  /** Creates the workspace skeleton (seeding globals) where missing, then opens it. */
+  static async create(dir) {
+    const root = _WorkspaceStore.resolveRoot(dir);
+    await fs2.mkdir(path3.join(root, COLLECTIONS_DIR), { recursive: true });
+    await fs2.mkdir(path3.join(root, ENVIRONMENTS_DIR), { recursive: true });
+    await fs2.mkdir(path3.join(root, GLOBALS_DIR), { recursive: true });
+    const globals = path3.join(root, GLOBALS_DIR, GLOBALS_FILE);
+    if (!existsSync3(globals)) {
+      await writeFileAtomic(globals, globalsToYaml([{ key: "appName", value: "Yamlet", enabled: true }]));
+    }
+    return _WorkspaceStore.open(root);
+  }
+  get rootPath() {
+    return this.workspace.rootPath;
+  }
+  async reload() {
+    return this.enqueue(async () => {
+      this.workspace = await loadWorkspace(this.workspace.rootPath);
+      return this.workspace;
+    });
+  }
+  // ---- Lookups -------------------------------------------------------------
+  findCollection(id) {
+    return this.workspace.collections.find((c) => c.id === id);
+  }
+  findEnvironment(id) {
+    return this.workspace.environments.find((e) => e.id === id);
+  }
+  findRequest(id) {
+    const hit = this.locateRequest(id);
+    return hit && { request: hit.request, collection: hit.collection, folders: hit.folders };
+  }
+  findFolder(id) {
+    const hit = this.locateFolder(id);
+    return hit && { folder: hit.folder, collection: hit.collection, folders: hit.folders };
+  }
+  locateRequest(id) {
+    for (const collection of this.workspace.collections) {
+      const walk2 = (node, chain) => {
+        const request3 = node.requests.find((r) => r.id === id);
+        if (request3) return { request: request3, collection, folders: chain, list: node.requests };
+        for (const f of node.folders) {
+          const hit2 = walk2(f, [...chain, f]);
+          if (hit2) return hit2;
+        }
+        return void 0;
+      };
+      const hit = walk2(collection, []);
+      if (hit) return hit;
+    }
+    return void 0;
+  }
+  locateFolder(id) {
+    for (const collection of this.workspace.collections) {
+      const walk2 = (node, chain) => {
+        for (const f of node.folders) {
+          if (f.id === id) return { folder: f, collection, folders: chain, list: node.folders };
+          const hit2 = walk2(f, [...chain, f]);
+          if (hit2) return hit2;
+        }
+        return void 0;
+      };
+      const hit = walk2(collection, []);
+      if (hit) return hit;
+    }
+    return void 0;
+  }
+  requireCollection(id) {
+    const c = this.findCollection(id);
+    if (!c) throw new Error(`Collection not found: ${id}`);
+    return c;
+  }
+  /** The container (collection root or folder) that new children go into. */
+  container(collectionId, folderId) {
+    const collection = this.requireCollection(collectionId);
+    let folder = null;
+    if (folderId) {
+      const hit = this.locateFolder(folderId);
+      if (!hit || hit.collection !== collection) throw new Error(`Folder not found in collection: ${folderId}`);
+      folder = hit.folder;
+    }
+    const node = folder ?? collection;
+    const dir = node.directoryPath;
+    if (!dir) throw new Error("Container has no directory");
+    return { collection, folder, node, dir };
+  }
+  // ---- Collections ---------------------------------------------------------
+  async createCollection(name) {
+    return this.enqueue(async () => {
+      const ws = this.workspace;
+      await fs2.mkdir(ws.collectionsPath, { recursive: true });
+      const dir = uniqueDirectoryPath(ws.collectionsPath, slugify(name, "collection"));
+      await fs2.mkdir(dir, { recursive: true });
+      const c = newCollection({
+        name: name.trim() || "New Collection",
+        directoryPath: dir,
+        filePath: path3.join(dir, COLLECTION_FILE),
+        order: nextOrder(ws.collections)
+      });
+      await this.writeCollection(c);
+      ws.collections.push(c);
+      return c;
+    });
+  }
+  async updateCollection(id, patch) {
+    return this.enqueue(async () => {
+      const c = this.requireCollection(id);
+      if (patch.name !== void 0 && patch.name.trim() && patch.name !== c.name) {
+        c.name = patch.name;
+        await this.renameNodeDir(c, this.workspace.collectionsPath, slugify(c.name, "collection"));
+      }
+      if (patch.description !== void 0) c.description = patch.description;
+      if (patch.variables !== void 0) c.variables = patch.variables;
+      if (patch.auth !== void 0) c.auth = patch.auth;
+      if (patch.preRequestScript !== void 0) c.preRequestScript = patch.preRequestScript;
+      if (patch.postResponseScript !== void 0) c.postResponseScript = patch.postResponseScript;
+      await this.writeCollection(c);
+      return c;
+    });
+  }
+  async deleteCollection(id) {
+    return this.enqueue(async () => {
+      const c = this.requireCollection(id);
+      if (c.directoryPath) await fs2.rm(c.directoryPath, { recursive: true, force: true });
+      this.workspace.collections = this.workspace.collections.filter((x) => x !== c);
+      return c;
+    });
+  }
+  async duplicateCollection(id) {
+    return this.enqueue(async () => {
+      const src = this.requireCollection(id);
+      if (!src.directoryPath) throw new Error("Collection has no directory");
+      const name = copyName(src.name);
+      const dir = uniqueDirectoryPath(this.workspace.collectionsPath, slugify(name, "collection"));
+      await fs2.cp(src.directoryPath, dir, { recursive: true });
+      const c = structuredClone(src);
+      repathTree(c, src.directoryPath, dir);
+      freshIds(c);
+      c.name = name;
+      c.filePath = path3.join(dir, COLLECTION_FILE);
+      c.order = nextOrder(this.workspace.collections);
+      await this.writeTree(c);
+      this.workspace.collections.push(c);
+      return c;
+    });
+  }
+  /** Writes an in-memory collection (e.g. from an importer) as a new collection with fresh ids. */
+  async importCollection(imported) {
+    return this.enqueue(async () => {
+      const ws = this.workspace;
+      const c = structuredClone(imported);
+      freshIds(c);
+      c.name = c.name?.trim() || "Imported Collection";
+      const dir = uniqueDirectoryPath(ws.collectionsPath, slugify(c.name, "collection"));
+      await fs2.mkdir(dir, { recursive: true });
+      c.directoryPath = dir;
+      c.filePath = path3.join(dir, COLLECTION_FILE);
+      c.order = nextOrder(ws.collections);
+      const placeAndWrite = async (node, nodeDir) => {
+        for (const [i, r] of node.requests.entries()) {
+          r.order = i;
+          r.sourceFilePath = uniqueFilePath(nodeDir, slugify(r.name, "request") + REQUEST_EXTENSION);
+          await writeFileAtomic(r.sourceFilePath, requestToYaml(r));
+        }
+        for (const [i, f] of node.folders.entries()) {
+          f.order = i;
+          f.directoryPath = uniqueDirectoryPath(nodeDir, slugify(f.name, "folder"));
+          await fs2.mkdir(f.directoryPath, { recursive: true });
+          await writeFileAtomic(path3.join(f.directoryPath, FOLDER_FILE), folderToYaml(f));
+          await placeAndWrite(f, f.directoryPath);
+        }
+      };
+      await placeAndWrite(c, dir);
+      await writeFileAtomic(c.filePath, collectionToYaml(c));
+      ws.collections.push(c);
+      return c;
+    });
+  }
+  // ---- Folders -------------------------------------------------------------
+  async createFolder(collectionId, parentFolderId, name) {
+    return this.enqueue(async () => {
+      const { node, dir } = this.container(collectionId, parentFolderId);
+      const folderDir = uniqueDirectoryPath(dir, slugify(name, "folder"));
+      await fs2.mkdir(folderDir, { recursive: true });
+      const f = newFolder({ name: name.trim() || "New Folder", directoryPath: folderDir, order: nextOrder(node.folders) });
+      await this.writeFolder(f);
+      node.folders.push(f);
+      return f;
+    });
+  }
+  async updateFolder(id, patch) {
+    return this.enqueue(async () => {
+      const hit = this.locateFolder(id);
+      if (!hit) throw new Error(`Folder not found: ${id}`);
+      const f = hit.folder;
+      if (patch.name !== void 0 && patch.name.trim() && patch.name !== f.name) {
+        f.name = patch.name;
+        const parentDir = path3.dirname(f.directoryPath);
+        await this.renameNodeDir(f, parentDir, slugify(f.name, "folder"));
+      }
+      if (patch.description !== void 0) f.description = patch.description;
+      await this.writeFolder(f);
+      return f;
+    });
+  }
+  async deleteFolder(id) {
+    return this.enqueue(async () => {
+      const hit = this.locateFolder(id);
+      if (!hit) throw new Error(`Folder not found: ${id}`);
+      if (hit.folder.directoryPath) await fs2.rm(hit.folder.directoryPath, { recursive: true, force: true });
+      hit.list.splice(hit.list.indexOf(hit.folder), 1);
+      return hit.folder;
+    });
+  }
+  async duplicateFolder(id) {
+    return this.enqueue(async () => {
+      const hit = this.locateFolder(id);
+      if (!hit?.folder.directoryPath) throw new Error(`Folder not found: ${id}`);
+      const src = hit.folder;
+      const srcDir = src.directoryPath;
+      const name = copyName(src.name);
+      const dir = uniqueDirectoryPath(path3.dirname(srcDir), slugify(name, "folder"));
+      await fs2.cp(srcDir, dir, { recursive: true });
+      const f = structuredClone(src);
+      repathTree(f, srcDir, dir);
+      freshIds(f);
+      f.name = name;
+      await this.writeTree(f);
+      hit.list.splice(hit.list.indexOf(src) + 1, 0, f);
+      await this.saveContainerOrder(hit.collection, hit.folders.at(-1) ?? null);
+      return f;
+    });
+  }
+  // ---- Requests ------------------------------------------------------------
+  async createRequest(collectionId, parentFolderId, init) {
+    return this.enqueue(async () => {
+      const { node, dir } = this.container(collectionId, parentFolderId);
+      const name = init?.name?.trim() ? init.name : "New Request";
+      const file = uniqueFilePath(dir, slugify(name, "request") + REQUEST_EXTENSION);
+      const id = init?.id && !this.idInUse(init.id) ? init.id : newId();
+      const r = newRequest({ ...init, id, name, sourceFilePath: file, order: nextOrder(node.requests) });
+      r.method = (r.method || "GET").toUpperCase();
+      await writeFileAtomic(file, requestToYaml(r));
+      node.requests.push(r);
+      return r;
+    });
+  }
+  /** Replaces a request by id and rewrites its file, renaming the file when the name changed. */
+  async saveRequest(request3) {
+    return this.enqueue(async () => {
+      const hit = this.locateRequest(request3.id);
+      if (!hit) throw new Error(`Request not found: ${request3.id}`);
+      const existing = hit.request;
+      const updated = {
+        ...structuredClone(request3),
+        method: (request3.method || "GET").toUpperCase(),
+        order: existing.order,
+        sourceFilePath: existing.sourceFilePath
+      };
+      let file = existing.sourceFilePath;
+      if (!file) throw new Error("Request has no file path");
+      if (updated.name !== existing.name && updated.name.trim()) {
+        const target = uniqueFilePath(path3.dirname(file), slugify(updated.name, "request") + REQUEST_EXTENSION, file);
+        if (target !== file) {
+          if (existsSync3(file)) await fs2.rename(file, target);
+          file = target;
+        }
+      }
+      updated.sourceFilePath = file;
+      await writeFileAtomic(file, requestToYaml(updated, await readIfExists(file)));
+      hit.list[hit.list.indexOf(existing)] = updated;
+      return updated;
+    });
+  }
+  async deleteRequest(id) {
+    return this.enqueue(async () => {
+      const hit = this.locateRequest(id);
+      if (!hit) throw new Error(`Request not found: ${id}`);
+      if (hit.request.sourceFilePath) await fs2.rm(hit.request.sourceFilePath, { force: true });
+      hit.list.splice(hit.list.indexOf(hit.request), 1);
+      return hit.request;
+    });
+  }
+  async duplicateRequest(id) {
+    return this.enqueue(async () => {
+      const hit = this.locateRequest(id);
+      if (!hit?.request.sourceFilePath) throw new Error(`Request not found: ${id}`);
+      const src = hit.request;
+      const r = structuredClone(src);
+      r.id = newId();
+      for (const e of r.examples ?? []) e.id = newId();
+      r.name = copyName(src.name);
+      r.sourceFilePath = uniqueFilePath(path3.dirname(src.sourceFilePath), slugify(r.name, "request") + REQUEST_EXTENSION);
+      await writeFileAtomic(r.sourceFilePath, requestToYaml(r, await readIfExists(src.sourceFilePath)));
+      hit.list.splice(hit.list.indexOf(src) + 1, 0, r);
+      await this.saveContainerOrder(hit.collection, hit.folders.at(-1) ?? null);
+      return r;
+    });
+  }
+  // ---- Moving --------------------------------------------------------------
+  /**
+   * Moves a request or folder into a target container at `index` (position in the target's
+   * list after removal from its source). Files/directories move on disk when the parent
+   * changes; both containers are renumbered.
+   */
+  async move(kind, id, targetCollectionId, targetFolderId, index) {
+    return this.enqueue(async () => {
+      const target = this.container(targetCollectionId, targetFolderId);
+      const clampInsert = (list, item) => list.splice(Math.max(0, Math.min(index, list.length)), 0, item);
+      if (kind === "request") {
+        const hit2 = this.locateRequest(id);
+        if (!hit2) throw new Error(`Request not found: ${id}`);
+        const r = hit2.request;
+        hit2.list.splice(hit2.list.indexOf(r), 1);
+        if (r.sourceFilePath && path3.dirname(r.sourceFilePath) !== target.dir) {
+          const dest = uniqueFilePath(target.dir, path3.basename(r.sourceFilePath));
+          await fs2.rename(r.sourceFilePath, dest);
+          r.sourceFilePath = dest;
+        }
+        clampInsert(target.node.requests, r);
+        await this.saveContainerOrder(target.collection, target.folder);
+        const source2 = hit2.folders.at(-1) ?? null;
+        if (hit2.collection !== target.collection || source2 !== target.folder) await this.saveContainerOrder(hit2.collection, source2);
+        return r;
+      }
+      const hit = this.locateFolder(id);
+      if (!hit) throw new Error(`Folder not found: ${id}`);
+      const f = hit.folder;
+      if (targetFolderId === f.id || targetFolderId && this.locateFolder(targetFolderId)?.folders.some((a) => a.id === f.id)) {
+        throw new Error("Cannot move a folder into itself");
+      }
+      hit.list.splice(hit.list.indexOf(f), 1);
+      const from = f.directoryPath;
+      if (path3.dirname(from) !== target.dir) {
+        const dest = uniqueDirectoryPath(target.dir, path3.basename(from));
+        await fs2.rename(from, dest);
+        repathTree(f, from, dest);
+      }
+      clampInsert(target.node.folders, f);
+      await this.saveContainerOrder(target.collection, target.folder);
+      const source = hit.folders.at(-1) ?? null;
+      if (hit.collection !== target.collection || source !== target.folder) await this.saveContainerOrder(hit.collection, source);
+      return f;
+    });
+  }
+  /** Renumbers a container's direct children to their list order; rewrites only changed files. */
+  async saveContainerOrder(collection, folder) {
+    const node = folder ?? collection;
+    for (const [i, r] of node.requests.entries()) {
+      if (r.order === i && existsSync3(r.sourceFilePath ?? "")) continue;
+      r.order = i;
+      if (r.sourceFilePath) await writeFileAtomic(r.sourceFilePath, requestToYaml(r, await readIfExists(r.sourceFilePath)));
+    }
+    for (const [i, f] of node.folders.entries()) {
+      if (f.order === i && existsSync3(path3.join(f.directoryPath ?? "", FOLDER_FILE))) continue;
+      f.order = i;
+      await this.writeFolder(f);
+    }
+  }
+  // ---- Environments and globals --------------------------------------------
+  async createEnvironment(name) {
+    return this.enqueue(async () => {
+      const ws = this.workspace;
+      const file = uniqueFilePath(ws.environmentsPath, slugify(name, "environment") + ".yaml");
+      const env = newEnvironment({ name: name.trim() || "New Environment", filePath: file });
+      await writeFileAtomic(file, environmentToYaml(env));
+      ws.environments.push(env);
+      return env;
+    });
+  }
+  async importEnvironment(imported) {
+    return this.enqueue(async () => {
+      const ws = this.workspace;
+      const env = { ...structuredClone(imported), id: newId(), name: imported.name?.trim() || "Imported Environment" };
+      env.filePath = uniqueFilePath(ws.environmentsPath, slugify(env.name, "environment") + ".yaml");
+      await writeFileAtomic(env.filePath, environmentToYaml(env));
+      ws.environments.push(env);
+      return env;
+    });
+  }
+  async saveEnvironment(env) {
+    return this.enqueue(async () => {
+      const list = this.workspace.environments;
+      const idx = list.findIndex((e) => e.id === env.id);
+      if (idx < 0) throw new Error(`Environment not found: ${env.id}`);
+      const existing = list[idx];
+      let file = existing.filePath ?? uniqueFilePath(this.workspace.environmentsPath, slugify(env.name, "environment") + ".yaml");
+      if (env.name !== existing.name && env.name.trim() && existing.filePath) {
+        const target = uniqueFilePath(path3.dirname(file), slugify(env.name, "environment") + ".yaml", file);
+        if (target !== file) {
+          if (existsSync3(file)) await fs2.rename(file, target);
+          file = target;
+        }
+      }
+      const updated = { ...structuredClone(env), filePath: file };
+      await writeFileAtomic(file, environmentToYaml(updated, await readIfExists(file)));
+      list[idx] = updated;
+      return updated;
+    });
+  }
+  async deleteEnvironment(id) {
+    return this.enqueue(async () => {
+      const list = this.workspace.environments;
+      const env = list.find((e) => e.id === id);
+      if (!env) throw new Error(`Environment not found: ${id}`);
+      if (env.filePath) await fs2.rm(env.filePath, { force: true });
+      list.splice(list.indexOf(env), 1);
+      return env;
+    });
+  }
+  async duplicateEnvironment(id) {
+    return this.enqueue(async () => {
+      const list = this.workspace.environments;
+      const src = list.find((e) => e.id === id);
+      if (!src) throw new Error(`Environment not found: ${id}`);
+      const env = { ...structuredClone(src), id: newId(), name: copyName(src.name) };
+      env.filePath = uniqueFilePath(this.workspace.environmentsPath, slugify(env.name, "environment") + ".yaml");
+      await writeFileAtomic(env.filePath, environmentToYaml(env, await readIfExists(src.filePath)));
+      list.splice(list.indexOf(src) + 1, 0, env);
+      return env;
+    });
+  }
+  async saveGlobals(vars) {
+    return this.enqueue(async () => {
+      const file = path3.join(this.workspace.globalsPath, GLOBALS_FILE);
+      await writeFileAtomic(file, globalsToYaml(vars, await readIfExists(file)));
+      this.workspace.globals = structuredClone(vars);
+      return this.workspace.globals;
+    });
+  }
+  // ---- Internals -----------------------------------------------------------
+  enqueue(fn) {
+    const run2 = this.queue.then(fn, fn);
+    this.queue = run2.catch(() => void 0);
+    return run2;
+  }
+  idInUse(id) {
+    return !!(this.findCollection(id) || this.locateRequest(id) || this.locateFolder(id) || this.findEnvironment(id));
+  }
+  async renameNodeDir(node, parentDir, slug) {
+    const from = node.directoryPath;
+    if (!from || path3.basename(from) === slug) return;
+    const to = uniqueDirectoryPath(parentDir, slug, from);
+    if (to === from) return;
+    await fs2.rename(from, to);
+    repathTree(node, from, to);
+  }
+  async writeCollection(c) {
+    if (!c.directoryPath) throw new Error("Collection has no directory");
+    c.filePath = path3.join(c.directoryPath, COLLECTION_FILE);
+    await writeFileAtomic(c.filePath, collectionToYaml(c, await readIfExists(c.filePath)));
+  }
+  async writeFolder(f) {
+    if (!f.directoryPath) return;
+    const file = path3.join(f.directoryPath, FOLDER_FILE);
+    await writeFileAtomic(file, folderToYaml(f, await readIfExists(file)));
+  }
+  /** Rewrites every metadata and request file under a node (used after copying a directory). */
+  async writeTree(node) {
+    if ("variables" in node) await this.writeCollection(node);
+    else await this.writeFolder(node);
+    for (const r of node.requests) {
+      if (r.sourceFilePath) await writeFileAtomic(r.sourceFilePath, requestToYaml(r, await readIfExists(r.sourceFilePath)));
+    }
+    for (const f of node.folders) await this.writeTree(f);
+  }
+};
+async function loadWorkspace(root) {
+  const base = path3.basename(root);
+  const ws = {
+    name: base.toLowerCase() === ROOT_DIR_NAME ? path3.basename(path3.dirname(root)) || base : base,
+    rootPath: root,
+    collectionsPath: path3.join(root, COLLECTIONS_DIR),
+    environmentsPath: path3.join(root, ENVIRONMENTS_DIR),
+    globalsPath: path3.join(root, GLOBALS_DIR),
+    collections: [],
+    environments: [],
+    globals: []
+  };
+  const rel = (p) => path3.relative(root, p).split(path3.sep).join("/");
+  for (const entry of await listDir(ws.collectionsPath)) {
+    if (!entry.dir || entry.name.startsWith(".")) continue;
+    try {
+      ws.collections.push(await loadCollection(path3.join(ws.collectionsPath, entry.name), rel));
+    } catch {
+    }
+  }
+  byOrder(ws.collections);
+  for (const entry of await listDir(ws.environmentsPath)) {
+    if (entry.dir || !isYamlFile(entry.name)) continue;
+    const file = path3.join(ws.environmentsPath, entry.name);
+    try {
+      const raw = loadYaml(await fs2.readFile(file, "utf8"));
+      const env = environmentFromDto(raw, file);
+      if (!isObj(raw) || !String(raw.id ?? "").trim()) env.id = stableId("e", rel(file));
+      ws.environments.push(env);
+    } catch {
+    }
+  }
+  const globalsText = await readIfExists(path3.join(ws.globalsPath, GLOBALS_FILE));
+  if (globalsText) {
+    try {
+      ws.globals = globalsFromYaml(globalsText);
+    } catch {
+      ws.globals = [];
+    }
+  }
+  ensureUniqueIds(ws, rel);
+  return ws;
+}
+async function loadCollection(dir, rel) {
+  const c = newCollection({
+    id: stableId("c", rel(dir)),
+    name: path3.basename(dir),
+    directoryPath: dir,
+    filePath: path3.join(dir, COLLECTION_FILE)
+  });
+  const definition = await readIfExists(path3.join(dir, DEFINITION_FILE));
+  if (definition) applyCollectionDefinition(c, loadYaml(definition));
+  const metadata = await readIfExists(c.filePath);
+  if (metadata) applyCollectionMetadata(c, loadYaml(metadata));
+  c.requests = await loadRequests(dir, rel);
+  c.folders = await loadFolders(dir, rel);
+  return c;
+}
+async function loadFolders(parentDir, rel) {
+  const folders = [];
+  for (const entry of await listDir(parentDir)) {
+    if (!entry.dir || entry.name.startsWith(".")) continue;
+    const dir = path3.join(parentDir, entry.name);
+    const f = newFolder({ id: stableId("f", rel(dir)), name: entry.name, directoryPath: dir });
+    const meta = await readIfExists(path3.join(dir, FOLDER_FILE));
+    if (meta) {
+      try {
+        applyFolderMetadata(f, loadYaml(meta));
+      } catch {
+      }
+    }
+    f.requests = await loadRequests(dir, rel);
+    f.folders = await loadFolders(dir, rel);
+    folders.push(f);
+  }
+  return byOrder(folders);
+}
+async function loadRequests(dir, rel) {
+  const requests = [];
+  for (const entry of await listDir(dir)) {
+    if (entry.dir || !isYamlFile(entry.name)) continue;
+    const lower = entry.name.toLowerCase();
+    if (lower === COLLECTION_FILE || lower === FOLDER_FILE) continue;
+    const file = path3.join(dir, entry.name);
+    try {
+      const raw = loadYaml(await fs2.readFile(file, "utf8"));
+      if (!isObj(raw)) continue;
+      const r = requestFromDto(raw, file);
+      if (!String(raw.id ?? "").trim()) r.id = stableId("r", rel(file));
+      requests.push(r);
+    } catch {
+    }
+  }
+  return byOrder(requests);
+}
+function ensureUniqueIds(ws, rel) {
+  const seen = /* @__PURE__ */ new Set();
+  const claim = (current, prefix, key) => {
+    let id = current;
+    for (let n = 0; !id || seen.has(id); n++) id = stableId(prefix, `${key}#${n}`);
+    seen.add(id);
+    return id;
+  };
+  const walk2 = (node) => {
+    for (const r of node.requests) r.id = claim(r.id, "r", rel(r.sourceFilePath ?? r.name));
+    for (const f of node.folders) {
+      f.id = claim(f.id, "f", rel(f.directoryPath ?? f.name));
+      walk2(f);
+    }
+  };
+  for (const c of ws.collections) {
+    c.id = claim(c.id, "c", rel(c.directoryPath ?? c.name));
+    walk2(c);
+  }
+  for (const e of ws.environments) e.id = claim(e.id, "e", rel(e.filePath ?? e.name));
+}
+
+// cli/src/index.ts
+var VERSION = true ? "0.0.0-dev" : "0.0.0-dev";
+var CliError = class extends Error {
+};
+var USAGE = `Yamlet CLI: run Yamlet API collections headlessly.
+
+Usage:
+  yamlet run <workspace> [options]
+
+Arguments:
+  <workspace>               A Yamlet workspace folder (contains collections/ and
+                            environments/), or its parent.
+
+Options:
+  -e, --env <name|file>     Environment to use: a name from the workspace, or a
+                            path to an environment YAML file.
+  -g, --globals <file>      Use these globals instead of the workspace's.
+  -c, --collection <name>   Only run this collection (repeatable).
+  -n, --iterations <n>      Run everything n times (default 1).
+  -d, --data <file>         CSV or JSON data file; one iteration per row.
+      --delay <ms>          Wait between requests.
+      --bail                Stop after the first failing request.
+  -r, --reporter <name>     table (default), json, or junit.
+  -o, --out <file>          Write the json/junit report to a file instead of stdout.
+      --no-color            Disable ANSI colors (also honors NO_COLOR).
+  -h, --help                Show this help.
+  -v, --version             Show the version.
+
+A request fails on a network error, a status outside 2xx/3xx, or a failed
+pm.test assertion. The exit code is 1 if anything failed, else 0.
+
+Example:
+  yamlet run ./my-workspace --env dev --reporter junit --out results.xml`;
+function parseArgs(argv) {
+  const args = { workspace: "", collections: [], delayMs: 0, bail: false, reporter: "table", color: !process.env.NO_COLOR };
+  const value = (i, flag) => {
+    const v = argv[i + 1];
+    if (v === void 0 || v.startsWith("-")) throw new CliError(`Option '${flag}' requires a value.`);
+    return v;
+  };
+  const int2 = (raw, flag, min) => {
+    const n = Number(raw);
+    if (!Number.isInteger(n) || n < min) throw new CliError(`Option '${flag}' needs a whole number of at least ${min}.`);
+    return n;
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    switch (a) {
+      case "-e":
+      case "--env":
+        args.env = value(i++, a);
+        break;
+      case "-g":
+      case "--globals":
+        args.globals = value(i++, a);
+        break;
+      case "-c":
+      case "--collection":
+        args.collections.push(value(i++, a));
+        break;
+      case "-n":
+      case "--iterations":
+        args.iterations = int2(value(i++, a), a, 1);
+        break;
+      case "-d":
+      case "--data":
+        args.data = value(i++, a);
+        break;
+      case "--delay":
+        args.delayMs = int2(value(i++, a), a, 0);
+        break;
+      case "--bail":
+        args.bail = true;
+        break;
+      case "-r":
+      case "--reporter": {
+        const r = value(i++, a);
+        if (r !== "table" && r !== "json" && r !== "junit") throw new CliError(`Unknown reporter '${r}'. Use table, json or junit.`);
+        args.reporter = r;
+        break;
+      }
+      case "-o":
+      case "--out":
+        args.out = value(i++, a);
+        break;
+      case "--no-color":
+        args.color = false;
+        break;
+      default:
+        if (a.startsWith("-")) throw new CliError(`Unknown option '${a}'.`);
+        if (args.workspace) throw new CliError(`Unexpected argument '${a}'.`);
+        args.workspace = a;
+    }
+  }
+  if (!args.workspace) throw new CliError("Missing <workspace> path. Usage: yamlet run <workspace> [--env <name>]");
+  return args;
+}
+function resolveEnvironment(ws, arg) {
+  if (!arg) return void 0;
+  const path4 = resolve(arg);
+  if (existsSync4(path4) && statSync2(path4).isFile()) return environmentFromYaml(readFileSync(path4, "utf8"), path4);
+  const stem = basename(arg).replace(/\.(environment\.)?ya?ml$/i, "");
+  const match = ws.environments.find((e) => e.name.toLowerCase() === arg.toLowerCase() || e.name.toLowerCase() === stem.toLowerCase());
+  if (!match) {
+    const names = ws.environments.map((e) => e.name).join(", ") || "none";
+    throw new CliError(`Environment '${arg}' not found (no such file, and the workspace has: ${names}).`);
+  }
+  return match;
+}
+var SGR = { green: "32", red: "31", cyan: "36", dim: "2", bold: "1" };
+function paint(text, color, ...tones) {
+  const codes = tones.filter((t) => !!t).map((t) => SGR[t]);
+  return color && codes.length ? `\x1B[${codes.join(";")}m${text}\x1B[0m` : text;
+}
+var fmtMs = (ms) => ms >= 1e3 ? `${(ms / 1e3).toFixed(2)} s` : `${Math.round(ms)} ms`;
+function truncate(s, max) {
+  return s.length <= max ? s : `${s.slice(0, Math.max(1, max - 1))}\u2026`;
+}
+function table(headers, right, rows, color, out) {
+  const widths = headers.map((h, c) => Math.max(h.length, ...rows.map((r) => r[c].text.length)));
+  const rule = (l, m, r) => l + widths.map((w) => "\u2500".repeat(w + 2)).join(m) + r;
+  const line = (cells, bold = false) => "\u2502" + cells.map((cell2, c) => ` ${paint(right[c] ? cell2.text.padStart(widths[c]) : cell2.text.padEnd(widths[c]), color, bold ? "bold" : void 0, cell2.tone)} \u2502`).join("");
+  out.push(rule("\u250C", "\u252C", "\u2510"), line(headers.map((text) => ({ text })), true), rule("\u251C", "\u253C", "\u2524"));
+  for (const r of rows) out.push(line(r));
+  out.push(rule("\u2514", "\u2534", "\u2518"));
+}
+function formatTable(summary, color, columns = 120) {
+  const out = [];
+  const results = summary.results;
+  const multiCollection = new Set(results.map((r) => r.collectionId)).size > 1;
+  const multiIteration = summary.iterations > 1;
+  const headers = [...multiIteration ? ["#"] : [], "Result", ...multiCollection ? ["Collection"] : [], "Method", "URL", "Status", "Time", "Tests"];
+  const right = headers.map((h) => h === "Time" || h === "Tests" || h === "#");
+  const fixed = 3 * headers.length + 1 + 6 + 7 + 10 + 12 + 6 + (multiCollection ? 18 : 0) + (multiIteration ? 4 : 0);
+  const urlMax = Math.max(24, columns - fixed);
+  const rows = results.map((r) => {
+    const tp = r.tests.filter((t) => t.passed).length;
+    return [
+      ...multiIteration ? [{ text: String(r.iteration + 1) }] : [],
+      r.passed ? { text: "PASS", tone: "green" } : { text: "FAIL", tone: "red" },
+      ...multiCollection ? [{ text: truncate(r.collectionName, 16) }] : [],
+      { text: r.method, tone: "cyan" },
+      { text: truncate(r.url, urlMax) },
+      { text: r.error && !r.status ? "ERROR" : String(r.status), tone: r.passed ? "green" : "red" },
+      { text: fmtMs(r.durationMs) },
+      r.tests.length ? { text: `${tp}/${r.tests.length}`, tone: tp === r.tests.length ? "green" : "red" } : { text: "-" }
+    ];
+  });
+  table(headers, right, rows, color, out);
+  const failed = results.filter((r) => !r.passed);
+  if (failed.length) {
+    out.push("", paint("Failures:", color, "red", "bold"));
+    for (const r of failed) {
+      const label = [...r.path, r.name].join(" / ") + (multiIteration ? ` (iteration ${r.iteration + 1})` : "");
+      const bad = r.tests.filter((t) => !t.passed);
+      for (const t of bad) out.push("  " + paint(`${label} > ${t.name}${t.error ? `: ${t.error}` : ""}`, color, "red"));
+      if (!bad.length) out.push("  " + paint(`${label} (${r.method} ${r.url}): ${r.error ?? `HTTP ${r.status}`}`, color, "red"));
+    }
+  }
+  out.push("");
+  const req = `${summary.total} requests, ${paint(`${summary.passed} passed`, color, summary.passed ? "green" : void 0)}, ${paint(`${summary.failed} failed`, color, summary.failed ? "red" : void 0)}`;
+  const asserts = `${summary.assertions.total} assertions, ${paint(`${summary.assertions.failed} failed`, color, summary.assertions.failed ? "red" : void 0)}`;
+  out.push(`Summary: ${req}; ${asserts}; ${fmtMs(summary.durationMs)} total.`);
+  out.push(summary.failed ? paint("RESULT: FAIL", color, "red", "bold") : paint("RESULT: PASS", color, "green", "bold"));
+  return out.join("\n");
+}
+var xml = (s) => s.replace(/[<>&"']/g, (c) => ({ "<": "&lt;", ">": "&gt;", "&": "&amp;", '"': "&quot;", "'": "&apos;" })[c]);
+function formatJunit(summary) {
+  const byCollection = /* @__PURE__ */ new Map();
+  for (const r of summary.results) byCollection.set(r.collectionName, [...byCollection.get(r.collectionName) ?? [], r]);
+  const lines = [`<?xml version="1.0" encoding="UTF-8"?>`, `<testsuites name="yamlet" tests="${summary.total}" failures="${summary.failed}" time="${(summary.durationMs / 1e3).toFixed(3)}">`];
+  for (const [name, results] of byCollection) {
+    const failures = results.filter((r) => !r.passed).length;
+    const time = results.reduce((t, r) => t + r.durationMs, 0) / 1e3;
+    lines.push(`  <testsuite name="${xml(name)}" tests="${results.length}" failures="${failures}" time="${time.toFixed(3)}">`);
+    for (const r of results) {
+      const case_ = `${[...r.path, r.name].join(" / ")}${summary.iterations > 1 ? ` [${r.iteration + 1}]` : ""}`;
+      lines.push(`    <testcase classname="${xml(name)}" name="${xml(case_)}" time="${(r.durationMs / 1e3).toFixed(3)}">`);
+      if (!r.passed) {
+        const bad = r.tests.filter((t) => !t.passed);
+        const message = bad.length ? bad.map((t) => `${t.name}${t.error ? `: ${t.error}` : ""}`).join("; ") : r.error ?? `HTTP ${r.status}`;
+        lines.push(`      <failure message="${xml(message)}">${xml(`${r.method} ${r.url}
+${message}`)}</failure>`);
+      }
+      lines.push(`      <system-out>${xml(`${r.method} ${r.url} -> ${r.status || "ERROR"} in ${r.durationMs} ms`)}</system-out>`);
+      lines.push("    </testcase>");
+    }
+    lines.push("  </testsuite>");
+  }
+  lines.push("</testsuites>");
+  return lines.join("\n");
+}
+function formatJson(summary) {
+  const { variables: _v, ...rest } = summary;
+  return JSON.stringify(rest, null, 2);
+}
+async function run(args) {
+  const dir = resolve(args.workspace);
+  if (!existsSync4(dir) || !statSync2(dir).isDirectory()) throw new CliError(`Workspace folder not found: ${dir}`);
+  if (!await WorkspaceStore.isWorkspace(dir)) throw new CliError(`Not a Yamlet workspace (no collections/ and environments/): ${dir}`);
+  const store = await WorkspaceStore.open(dir);
+  const ws = store.workspace;
+  let globals = ws.globals;
+  if (args.globals) {
+    const path4 = resolve(args.globals);
+    if (!existsSync4(path4)) throw new CliError(`Globals file not found: ${path4}`);
+    globals = globalsFromYaml(readFileSync(path4, "utf8"));
+  }
+  const environment = resolveEnvironment(ws, args.env);
+  let collectionIds;
+  if (args.collections.length) {
+    collectionIds = args.collections.map((name) => {
+      const c2 = ws.collections.find((x) => x.name.toLowerCase() === name.toLowerCase() || basename(x.directoryPath ?? "") === name);
+      if (!c2) throw new CliError(`Collection '${name}' not found. Available: ${ws.collections.map((x) => x.name).join(", ") || "none"}.`);
+      return c2.id;
+    });
+  }
+  let data;
+  if (args.data) {
+    const path4 = resolve(args.data);
+    if (!existsSync4(path4)) throw new CliError(`Data file not found: ${path4}`);
+    try {
+      data = parseDataFile(readFileSync(path4, "utf8"), path4);
+    } catch (err) {
+      throw new CliError(`Could not read data file ${path4}: ${err.message}`);
+    }
+    if (!data.length) throw new CliError(`Data file has no rows: ${path4}`);
+  }
+  const table2 = args.reporter === "table";
+  const log = (s = "") => table2 ? console.log(s) : console.error(s);
+  const c = args.color && (table2 ? process.stdout.isTTY !== false : process.stderr.isTTY !== false);
+  log(paint(`Yamlet ${VERSION}`, c, "bold"));
+  log(`${paint("Workspace:  ", c, "dim")} ${ws.rootPath}`);
+  log(`${paint("Environment:", c, "dim")} ${environment?.name ?? "(none)"}`);
+  if (data) log(`${paint("Data:       ", c, "dim")} ${basename(args.data)} (${data.length} rows)`);
+  log();
+  const summary = await runCollection({
+    workspace: ws,
+    workspaceRoot: ws.rootPath,
+    collectionIds,
+    environment,
+    globals,
+    iterations: args.iterations,
+    data,
+    delayMs: args.delayMs,
+    bail: args.bail,
+    cookieJar: new CookieJar()
+  });
+  if (summary.total === 0) {
+    console.error("No requests found to run.");
+    return 1;
+  }
+  if (table2) {
+    console.log(formatTable(summary, c, process.stdout.columns || 120));
+  } else {
+    const report = args.reporter === "junit" ? formatJunit(summary) : formatJson(summary);
+    if (args.out) {
+      writeFileSync(resolve(args.out), report + "\n");
+      log(`Wrote ${args.reporter} report to ${resolve(args.out)}`);
+    } else {
+      console.log(report);
+    }
+    log(`${summary.total} requests, ${summary.passed} passed, ${summary.failed} failed; ${fmtMs(summary.durationMs)} total.`);
+  }
+  return summary.failed ? 1 : 0;
+}
+async function main(argv) {
+  const [cmd, ...rest] = argv;
+  if (!cmd || cmd === "-h" || cmd === "--help" || cmd === "help") {
+    console.log(USAGE);
+    return cmd ? 0 : 1;
+  }
+  if (cmd === "-v" || cmd === "--version") {
+    console.log(VERSION);
+    return 0;
+  }
+  if (cmd !== "run") {
+    console.error(`Unknown command '${cmd}'.
+`);
+    console.log(USAGE);
+    return 1;
+  }
+  if (rest.includes("-h") || rest.includes("--help")) {
+    console.log(USAGE);
+    return 0;
+  }
+  try {
+    return await run(parseArgs(rest));
+  } catch (err) {
+    if (err instanceof CliError) {
+      console.error(`error: ${err.message}`);
+      return 1;
+    }
+    throw err;
+  }
+}
+
+// cli/src/bin.ts
+main(process.argv.slice(2)).then(
+  (code) => {
+    process.exitCode = code;
+  },
+  (err) => {
+    console.error(err instanceof Error ? err.stack ?? err.message : err);
+    process.exitCode = 1;
+  }
+);