@piyushdoorwar/yamlet 1.12.0 → 1.13.0

package/dist/yamlet.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // cli/src/index.ts
-import { existsSync as existsSync4, readFileSync, statSync as statSync2, writeFileSync } from "node:fs";
+import { existsSync as existsSync4, readFileSync, statSync as statSync3, writeFileSync } from "node:fs";
 import { basename, resolve } from "node:path";
 
 // core/src/requestExecutor.ts
@@ -2090,49 +2090,53 @@ function parseDataFile(text, filename) {
 }
 
 // core/src/workspaceStore.ts
-import { existsSync as existsSync3, promises as fs2, statSync } from "node:fs";
+import { existsSync as existsSync3, promises as fs2, statSync as statSync2 } from "node:fs";
 import path3 from "node:path";
 
+// core/src/localValues.ts
+var environmentScope = (id) => `environment:${id}`;
+var collectionScope = (id) => `collection:${id}`;
+var GLOBALS_SCOPE = "globals";
+
 // core/src/pathNaming.ts
-import { existsSync as existsSync2 } from "node:fs";
+import { existsSync as existsSync2, statSync } 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}`);
+var RESERVED = /^(con|prn|aux|nul|com\d|lpt\d)$/i;
+function fileSafeName(name, fallback = "Untitled") {
+  let out = (name ?? "").replace(/[<>:"/\\|?*\u0000-\u001f\u007f]/g, "-").replace(/\s+/g, " ").trim().replace(/^\.+/, "").replace(/[. ]+$/, "");
+  if (out.length > 120) out = out.slice(0, 120).trimEnd();
+  if (!out) return fallback;
+  return RESERVED.test(out) ? `${out}_` : out;
+}
+function uniqueFilePath(directory, base, suffix, except) {
+  let candidate = path2.join(directory, base + suffix);
+  for (let n = 2; existsSync2(candidate) && !samePath(candidate, except); n++) {
+    candidate = path2.join(directory, `${base} ${n}${suffix}`);
   }
   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}`);
+  for (let n = 2; existsSync2(candidate) && !samePath(candidate, except); n++) {
+    candidate = path2.join(parent, `${name} ${n}`);
   }
   return candidate;
 }
+function samePath(a, b) {
+  if (!b) return false;
+  if (a === b) return true;
+  if (a.toLowerCase() !== b.toLowerCase()) return false;
+  try {
+    const x = statSync(a);
+    const y = statSync(b);
+    return x.ino === y.ino && x.dev === y.dev;
+  } catch {
+    return false;
+  }
+}
 
 // core/src/yamlDtos.ts
-import { Document, isAlias, isMap, isScalar, isSeq, parseDocument, stringify } from "yaml";
+import { Document, isAlias, isMap, isScalar, isSeq, parseDocument, Scalar, visit } from "yaml";
 function loadYaml(text) {
   if (!text?.trim()) return {};
   const doc = parseDocument(text, { uniqueKeys: false });
@@ -2156,26 +2160,57 @@ function loadYaml(text) {
   };
   return toPlain(doc.contents) ?? {};
 }
-var STRINGIFY_OPTS = { lineWidth: 0 };
-function dumpYaml(value) {
-  return stringify(value, STRINGIFY_OPTS);
+var OPTS = { lineWidth: 0 };
+function styled(doc, style) {
+  if (style?.quoteValues) {
+    visit(doc, {
+      Pair(_, pair) {
+        if (isScalar(pair.key) && pair.key.value === "value" && isScalar(pair.value) && typeof pair.value.value === "string") {
+          pair.value.type = Scalar.QUOTE_SINGLE;
+        }
+      }
+    });
+  }
+  return doc.toString(OPTS);
+}
+function dumpYaml(value, style) {
+  return styled(new Document(value), style);
 }
-function dumpYamlPreserving(value, original, known) {
-  if (!original?.trim()) return dumpYaml(value);
+function dumpYamlPreserving(value, original, known, style) {
+  if (!original?.trim()) return dumpYaml(value, style);
   try {
     const orig = parseDocument(original);
-    if (orig.errors.length || !isMap(orig.contents)) return dumpYaml(value);
+    if (orig.errors.length || !isMap(orig.contents)) return dumpYaml(value, style);
     const doc = new Document(value);
     const target = doc.contents;
-    if (!isMap(target)) return dumpYaml(value);
+    if (!isMap(target)) return dumpYaml(value, style);
     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);
+    return styled(doc, style);
   } catch {
-    return dumpYaml(value);
+    return dumpYaml(value, style);
+  }
+}
+function keepEquivalent(out, original, readers) {
+  if (!original) return;
+  for (const [key, read] of Object.entries(readers)) {
+    if (!(key in out) || !(key in original)) continue;
+    try {
+      if (JSON.stringify(read(original[key])) === JSON.stringify(read(out[key]))) out[key] = original[key];
+    } catch {
+    }
+  }
+}
+function parsedObj(text) {
+  if (!text?.trim()) return void 0;
+  try {
+    const o = loadYaml(text);
+    return isObj(o) && o.$kind !== void 0 ? o : void 0;
+  } catch {
+    return void 0;
   }
 }
 var isDropped = (key) => /^_[a-z0-9]+_[a-z_]+$/i.test(key);
@@ -2227,6 +2262,7 @@ 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;
+    if (bool(r.o.local) === true) v.local = true;
     return v;
   });
 }
@@ -2234,20 +2270,47 @@ function writeKeyValues(list) {
   if (!list?.length) return void 0;
   return list.map((kv) => {
     const o = { key: kv.key, value: kv.value ?? "" };
+    if (kv.enabled === false) o.disabled = true;
     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 ?? "" };
+    const o = { key: v.key, value: v.local ? "" : v.value ?? "" };
     if (v.secret) o.type = "secret";
     if (v.enabled === false) o.enabled = false;
+    if (v.local) o.local = true;
     return o;
   });
 }
+function writeVariableMap(list) {
+  const values = {};
+  const settings = {};
+  for (const v of list) {
+    values[v.key] = v.local ? "" : v.value ?? "";
+    const flags = {};
+    if (v.enabled === false) flags.enabled = false;
+    if (v.secret) flags.secret = true;
+    if (v.local) flags.local = true;
+    if (Object.keys(flags).length) settings[v.key] = flags;
+    else delete settings[v.key];
+  }
+  return Object.keys(settings).length ? { values, settings } : { values };
+}
+function applyVariableSettings(vars, raw) {
+  if (!isObj(raw)) return vars;
+  return vars.map((v) => {
+    const flags = raw[v.key];
+    if (!isObj(flags)) return v;
+    const out = { ...v };
+    if (bool(flags.enabled) === false) out.enabled = false;
+    if (bool(flags.secret) === true) out.secret = true;
+    if (bool(flags.local) === true) out.local = true;
+    return out;
+  });
+}
 function authType(raw) {
   switch (str(raw).trim().toLowerCase()) {
     case "bearer":
@@ -2327,15 +2390,15 @@ 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);
+  const cred = (block, key) => credential(raw[block], key) ?? credential(raw.credentials, key) ?? str(raw[key]);
+  a.token = cred("bearer", "token");
+  a.username = cred("basic", "username");
+  a.password = cred("basic", "password");
+  a.apiKeyName = credential(raw.apikey, "key") ?? (type === "apikey" ? credential(raw.credentials, "key") : void 0) ?? str(raw.key);
+  a.apiKeyValue = credential(raw.apikey, "value") ?? (type === "apikey" ? credential(raw.credentials, "value") : void 0) ?? str(raw.value);
+  a.apiKeyIn = (credential(raw.apikey, "in") ?? credential(raw.credentials, "in") ?? str(raw.in)).toLowerCase() === "query" ? "query" : "header";
+  a.cookie = credential(raw.credentials, "cookie") ?? str(raw.cookie);
+  if (raw.credentials && (type === "oauth2" || isObj(raw.credentials))) a.oauth2 = readOAuth2(raw.credentials);
   else if (raw.oauth2 !== void 0) a.oauth2 = readOAuth2(raw.oauth2);
   return a;
 }
@@ -2357,24 +2420,83 @@ function writeOAuth2(o) {
   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";
+  out.addTokenTo = o.addTokenTo === "query" ? "queryParams" : "header";
+  out.client_authentication = o.clientAuthentication === "body" ? "body" : "header";
   if (o.challengeAlgorithm === "plain") out.challengeAlgorithm = "plain";
   return out;
 }
+var MODELED_CREDENTIALS = new Set(
+  [
+    "token",
+    "username",
+    "password",
+    "key",
+    "value",
+    "in",
+    "cookie",
+    "grant_type",
+    "grantType",
+    "accessToken",
+    "access_token",
+    "refreshToken",
+    "refresh_token",
+    "headerPrefix",
+    "tokenType",
+    "accessTokenUrl",
+    "tokenUrl",
+    "access_token_url",
+    "authUrl",
+    "authorizationUrl",
+    "auth_url",
+    "clientId",
+    "client_id",
+    "clientSecret",
+    "client_secret",
+    "scope",
+    "redirect_uri",
+    "redirectUri",
+    "redirect_url",
+    "callbackUrl",
+    "addTokenTo",
+    "client_authentication",
+    "clientAuthentication",
+    "challengeAlgorithm"
+  ].map((k) => k.toLowerCase())
+);
+var normalizedAuth = (v) => writeAuth(readAuth(v, "none"));
+function mergeAuth(ours, original) {
+  if (!isObj(original) || str(original.type).toLowerCase() !== str(ours.type).toLowerCase() || !isObj(original.credentials)) return ours;
+  const extra = Object.entries(original.credentials).filter(([k]) => !MODELED_CREDENTIALS.has(k.toLowerCase()));
+  if (!extra.length) return ours;
+  return { ...ours, credentials: { ...isObj(ours.credentials) ? ours.credentials : {}, ...Object.fromEntries(extra) } };
+}
 function writeAuth(a) {
   const out = { type: a.type === "none" ? "noauth" : a.type };
+  const creds = {};
   const put = (k, v) => {
-    if (v) out[k] = v;
+    if (v) creds[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);
+  switch (a.type) {
+    case "bearer":
+      put("token", a.token);
+      break;
+    case "basic":
+      put("username", a.username);
+      put("password", a.password);
+      break;
+    case "apikey":
+      put("key", a.apiKeyName);
+      put("value", a.apiKeyValue);
+      creds.in = a.apiKeyIn === "query" ? "query" : "header";
+      break;
+    case "cookie":
+      put("cookie", a.cookie);
+      break;
+    case "oauth2":
+      Object.assign(creds, writeOAuth2(a.oauth2));
+      break;
+  }
+  if (Object.keys(creds).length) out.credentials = creds;
   return out;
 }
 function isPreScriptType(type) {
@@ -2398,10 +2520,11 @@ function readScripts(raw) {
   }
   return { pre: pre.join("\n\n"), post: post.join("\n\n") };
 }
-function writeScripts(pre, post) {
+var SCRIPT_LANGUAGE = "text/javascript";
+function writeScripts(pre, post, prefix = "") {
   const list = [];
-  if (pre) list.push({ type: "preRequest", code: pre });
-  if (post) list.push({ type: "afterResponse", code: post });
+  if (pre) list.push({ type: `${prefix}beforeRequest`, code: pre, language: SCRIPT_LANGUAGE });
+  if (post) list.push({ type: `${prefix}afterResponse`, code: post, language: SCRIPT_LANGUAGE });
   return list.length ? list : void 0;
 }
 function bodyType(raw) {
@@ -2456,47 +2579,58 @@ function readBody(raw) {
   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;
+  const gql = isObj(raw.graphql) ? raw.graphql : b.type === "graphql" && isObj(content) ? content : 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 : ""));
+  const src = Array.isArray(raw.src) ? raw.src[0] : raw.src;
+  b.binaryFile = str(raw.file ?? raw.binaryFile ?? (b.type === "binary" && typeof src === "string" ? 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;
+function writeField(f, multipart) {
+  const o = multipart ? { type: f.isFile ? "file" : "text", key: f.key } : { key: f.key };
+  if (multipart && f.isFile) o.src = [f.value.startsWith("@") ? f.value.slice(1) : f.value];
   else o.value = f.value ?? "";
+  if (f.enabled === false) o.disabled = true;
   if (f.description) o.description = f.description;
-  if (f.enabled === false) o.enabled = false;
   return o;
 }
 var BODY_TYPE_NAMES = {
   none: "none",
-  raw: "raw",
+  raw: "text",
   json: "json",
   xml: "xml",
   text: "text",
   html: "html",
-  "form-data": "form-data",
-  urlencoded: "x-www-form-urlencoded",
+  "form-data": "formdata",
+  urlencoded: "urlencoded",
   graphql: "graphql",
-  binary: "binary"
+  binary: "file"
 };
 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;
+  switch (b.type) {
+    case "none":
+      return void 0;
+    case "form-data":
+    case "urlencoded": {
+      const fields = b.fields?.filter((f) => f.key?.trim() || f.value);
+      out.content = (fields ?? []).map((f) => writeField(f, b.type === "form-data"));
+      break;
+    }
+    case "graphql": {
+      const g = { query: b.graphqlQuery ?? "" };
+      if (b.graphqlVariables) g.variables = b.graphqlVariables;
+      out.content = g;
+      break;
+    }
+    case "binary":
+      out.src = b.binaryFile ?? "";
+      break;
+    default:
+      out.content = b.raw ?? "";
+  }
   return out;
 }
 function readSettings(o) {
@@ -2546,6 +2680,7 @@ function writeExamples(list) {
   });
 }
 var REQUEST_KEYS = /* @__PURE__ */ new Set([
+  "$kind",
   "id",
   "name",
   "description",
@@ -2565,6 +2700,8 @@ var REQUEST_KEYS = /* @__PURE__ */ new Set([
   "ssl",
   "protocolProfileBehavior"
 ]);
+var REQUEST_KIND = "http-request";
+var COLLECTION_KIND = "collection";
 function deriveNameFromFile(filePath) {
   let name = filePath.split(/[\\/]/).pop() ?? filePath;
   name = name.replace(/\.ya?ml$/i, "");
@@ -2599,12 +2736,12 @@ function requestFromDto(raw, sourceFilePath) {
   if (sourceFilePath) req.sourceFilePath = sourceFilePath;
   return req;
 }
-function requestToDto(r) {
-  const o = { id: r.id, name: r.name };
+function requestToDto(r, filePath) {
+  const o = { $kind: REQUEST_KIND };
+  if (!filePath || deriveNameFromFile(filePath) !== r.name) o.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 ?? "";
+  o.method = (r.method || "GET").toUpperCase();
   const put = (k, v) => {
     if (v !== void 0) o[k] = v;
   };
@@ -2618,23 +2755,41 @@ function requestToDto(r) {
       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));
+  o.order = r.order ?? 0;
+  o.id = r.id;
+  put("variables", writeVariables(r.variables));
   put("settings", writeSettings(r.settings));
   put("examples", writeExamples(r.examples));
   return o;
 }
-function requestToYaml(r, original) {
-  return dumpYamlPreserving(requestToDto(r), original, REQUEST_KEYS);
+var sameRows = (v) => readRows(v).map(({ o: _o, ...row }) => row);
+var REQUEST_READERS = {
+  headers: sameRows,
+  queryParams: sameRows,
+  pathVariables: sameRows,
+  variables: readVariables,
+  auth: normalizedAuth,
+  body: (v) => writeBody(readBody(v)),
+  scripts: readScripts
+};
+function requestToYaml(r, original, filePath) {
+  const out = requestToDto(r, filePath);
+  const prev = parsedObj(original);
+  if (isObj(out.auth)) out.auth = mergeAuth(out.auth, prev?.auth);
+  keepEquivalent(out, prev, REQUEST_READERS);
+  return dumpYamlPreserving(out, original, REQUEST_KEYS);
 }
 var COLLECTION_KEYS = /* @__PURE__ */ new Set([
+  "$kind",
   "id",
   "name",
   "description",
   "order",
   "variables",
+  "variableSettings",
   "auth",
   "scripts",
   // Read-only aliases from the collection v2.1 shape; migrated on save.
@@ -2675,9 +2830,12 @@ function applyCollectionMetadata(c, raw) {
 }
 function applyCollectionDefinition(c, raw) {
   if (!isObj(raw)) return;
+  if (str(raw.id).trim()) c.id = str(raw.id);
   if (str(raw.name).trim()) c.name = str(raw.name);
   if (raw.description) c.description = str(raw.description);
-  const vars = readVariables(raw.variables);
+  const order = int(raw.order);
+  if (order !== void 0) c.order = order;
+  const vars = applyVariableSettings(readVariables(raw.variables), raw.variableSettings);
   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");
@@ -2686,20 +2844,27 @@ function applyCollectionDefinition(c, raw) {
   if (scripts.post) c.postResponseScript = scripts.post;
 }
 function collectionToDto(c) {
-  const o = { id: c.id, name: c.name };
+  const o = { $kind: COLLECTION_KIND, 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);
+  const vars = c.variables?.length ? writeVariableMap(c.variables) : void 0;
+  if (vars) o.variables = vars.values;
+  const scripts = writeScripts(c.preRequestScript, c.postResponseScript, "http:");
   if (scripts) o.scripts = scripts;
+  if (c.auth && c.auth.type !== "none" && c.auth.type !== "inherit") o.auth = writeAuth(c.auth);
+  o.order = c.order ?? 0;
+  o.id = c.id;
+  if (vars?.settings) o.variableSettings = vars.settings;
   return o;
 }
 function collectionToYaml(c, original) {
-  return dumpYamlPreserving(collectionToDto(c), original, COLLECTION_KEYS);
-}
-var FOLDER_KEYS = /* @__PURE__ */ new Set(["id", "name", "description", "order"]);
+  const out = collectionToDto(c);
+  const prev = parsedObj(original);
+  const prevAuth = Array.isArray(prev?.auth) ? prev.auth.find(isObj) : prev?.auth;
+  if (isObj(out.auth)) out.auth = mergeAuth(out.auth, prevAuth);
+  keepEquivalent(out, prev && { ...prev, auth: prevAuth }, { auth: normalizedAuth, scripts: readScripts });
+  return dumpYamlPreserving(out, original, COLLECTION_KEYS);
+}
+var FOLDER_KEYS = /* @__PURE__ */ new Set(["$kind", "id", "name", "description", "order"]);
 function applyFolderMetadata(f, raw) {
   if (!isObj(raw)) return;
   if (str(raw.id).trim()) f.id = str(raw.id);
@@ -2708,14 +2873,16 @@ function applyFolderMetadata(f, raw) {
   const order = int(raw.order);
   if (order !== void 0) f.order = order;
 }
-function folderToDto(f) {
-  const o = { id: f.id, name: f.name };
+function folderToDto(f, directoryName) {
+  const o = { $kind: COLLECTION_KIND };
+  if (directoryName === void 0 || directoryName !== f.name) o.name = f.name;
   if (f.description) o.description = f.description;
   o.order = f.order ?? 0;
+  o.id = f.id;
   return o;
 }
-function folderToYaml(f, original) {
-  return dumpYamlPreserving(folderToDto(f), original, FOLDER_KEYS);
+function folderToYaml(f, original, directoryName) {
+  return dumpYamlPreserving(folderToDto(f, directoryName), original, FOLDER_KEYS);
 }
 var ENVIRONMENT_KEYS = /* @__PURE__ */ new Set(["id", "name", "variables", "values"]);
 function deriveEnvironmentName(filePath) {
@@ -2733,23 +2900,20 @@ function environmentFromDto(raw, 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;
+  return { name: e.name, values: writeVariables(e.variables) ?? [], id: e.id };
 }
 function environmentFromYaml(text, filePath) {
   return environmentFromDto(loadYaml(text), filePath);
 }
 function environmentToYaml(e, original) {
-  return dumpYamlPreserving(environmentToDto(e), original, ENVIRONMENT_KEYS);
+  return dumpYamlPreserving(environmentToDto(e), original, ENVIRONMENT_KEYS, { quoteValues: true });
 }
 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"]));
+  return dumpYamlPreserving({ name: "Globals", values: writeVariables(vars) ?? [] }, original, /* @__PURE__ */ new Set(["name", "variables", "values"]), { quoteValues: true });
 }
 
 // core/src/workspaceStore.ts
@@ -2757,14 +2921,17 @@ 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 GLOBALS_FILE = "workspace.globals.yaml";
 var DEFINITION_FILE = path3.join(".resources", "definition.yaml");
-var REQUEST_EXTENSION = ".yaml";
+var REQUEST_SUFFIX = ".request.yaml";
+var ENVIRONMENT_SUFFIX = ".environment.yaml";
+var LEGACY_COLLECTION_FILE = "collection.yaml";
+var LEGACY_FOLDER_FILE = "folder.yaml";
+var LEGACY_GLOBALS_FILE = "globals.yaml";
+var ORDER_STEP = 1e3;
 var isDir = (p) => {
   try {
-    return statSync(p).isDirectory();
+    return statSync2(p).isDirectory();
   } catch {
     return false;
   }
@@ -2780,7 +2947,7 @@ function stableId(prefix, key) {
 }
 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);
+var nextOrder = (list) => list.reduce((m, x) => Math.max(m, (x.order ?? 0) + ORDER_STEP), ORDER_STEP);
 async function readIfExists(p) {
   if (!p) return void 0;
   try {
@@ -2828,8 +2995,11 @@ function copyName(name) {
 var WorkspaceStore = class _WorkspaceStore {
   workspace;
   queue = Promise.resolve();
-  constructor(workspace) {
+  local;
+  constructor(workspace, options) {
     this.workspace = workspace;
+    this.local = options.localValues;
+    if (this.local) applyLocalValues(workspace, this.local);
   }
   // ---- Opening -------------------------------------------------------------
   /** The picked folder if it already holds collections/ + environments/ (or is named `yamlet`), else `<dir>/yamlet`. */
@@ -2843,22 +3013,22 @@ var WorkspaceStore = class _WorkspaceStore {
     return isDir(path3.join(_WorkspaceStore.resolveRoot(dir), COLLECTIONS_DIR));
   }
   /** Opens an existing workspace. Does not create anything on disk. */
-  static async open(dir) {
+  static async open(dir, options = {}) {
     const root = _WorkspaceStore.resolveRoot(dir);
     if (!isDir(root)) throw new Error(`No Yamlet workspace found at ${dir}`);
-    return new _WorkspaceStore(await loadWorkspace(root));
+    return new _WorkspaceStore(await loadWorkspace(root), options);
   }
   /** Creates the workspace skeleton (seeding globals) where missing, then opens it. */
-  static async create(dir) {
+  static async create(dir, options = {}) {
     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)) {
+    if (!existsSync3(globals) && !existsSync3(path3.join(root, GLOBALS_DIR, LEGACY_GLOBALS_FILE))) {
       await writeFileAtomic(globals, globalsToYaml([{ key: "appName", value: "Yamlet", enabled: true }]));
     }
-    return _WorkspaceStore.open(root);
+    return _WorkspaceStore.open(root, options);
   }
   get rootPath() {
     return this.workspace.rootPath;
@@ -2866,6 +3036,7 @@ var WorkspaceStore = class _WorkspaceStore {
   async reload() {
     return this.enqueue(async () => {
       this.workspace = await loadWorkspace(this.workspace.rootPath);
+      if (this.local) applyLocalValues(this.workspace, this.local);
       return this.workspace;
     });
   }
@@ -2939,12 +3110,13 @@ var WorkspaceStore = class _WorkspaceStore {
     return this.enqueue(async () => {
       const ws = this.workspace;
       await fs2.mkdir(ws.collectionsPath, { recursive: true });
-      const dir = uniqueDirectoryPath(ws.collectionsPath, slugify(name, "collection"));
+      const display = name.trim() || "New Collection";
+      const dir = uniqueDirectoryPath(ws.collectionsPath, fileSafeName(display, "New Collection"));
       await fs2.mkdir(dir, { recursive: true });
       const c = newCollection({
-        name: name.trim() || "New Collection",
+        name: display,
         directoryPath: dir,
-        filePath: path3.join(dir, COLLECTION_FILE),
+        filePath: path3.join(dir, DEFINITION_FILE),
         order: nextOrder(ws.collections)
       });
       await this.writeCollection(c);
@@ -2955,10 +3127,7 @@ var WorkspaceStore = class _WorkspaceStore {
   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.name !== void 0 && patch.name.trim()) c.name = patch.name;
       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;
@@ -2972,6 +3141,7 @@ var WorkspaceStore = class _WorkspaceStore {
     return this.enqueue(async () => {
       const c = this.requireCollection(id);
       if (c.directoryPath) await fs2.rm(c.directoryPath, { recursive: true, force: true });
+      await this.local?.set(collectionScope(c.id), void 0);
       this.workspace.collections = this.workspace.collections.filter((x) => x !== c);
       return c;
     });
@@ -2981,13 +3151,13 @@ var WorkspaceStore = class _WorkspaceStore {
       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"));
+      const dir = uniqueDirectoryPath(this.workspace.collectionsPath, fileSafeName(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.filePath = path3.join(dir, DEFINITION_FILE);
       c.order = nextOrder(this.workspace.collections);
       await this.writeTree(c);
       this.workspace.collections.push(c);
@@ -3001,26 +3171,27 @@ var WorkspaceStore = class _WorkspaceStore {
       const c = structuredClone(imported);
       freshIds(c);
       c.name = c.name?.trim() || "Imported Collection";
-      const dir = uniqueDirectoryPath(ws.collectionsPath, slugify(c.name, "collection"));
+      const dir = uniqueDirectoryPath(ws.collectionsPath, fileSafeName(c.name, "Imported Collection"));
       await fs2.mkdir(dir, { recursive: true });
       c.directoryPath = dir;
-      c.filePath = path3.join(dir, COLLECTION_FILE);
+      c.filePath = path3.join(dir, DEFINITION_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));
+          r.order = (i + 1) * ORDER_STEP;
+          r.sourceFilePath = uniqueFilePath(nodeDir, fileSafeName(r.name, "New Request"), REQUEST_SUFFIX);
+          await writeFileAtomic(r.sourceFilePath, requestToYaml(r, void 0, r.sourceFilePath));
         }
         for (const [i, f] of node.folders.entries()) {
-          f.order = i;
-          f.directoryPath = uniqueDirectoryPath(nodeDir, slugify(f.name, "folder"));
+          f.order = (i + 1) * ORDER_STEP;
+          f.directoryPath = uniqueDirectoryPath(nodeDir, fileSafeName(f.name, "New Folder"));
           await fs2.mkdir(f.directoryPath, { recursive: true });
-          await writeFileAtomic(path3.join(f.directoryPath, FOLDER_FILE), folderToYaml(f));
+          await writeFileAtomic(path3.join(f.directoryPath, DEFINITION_FILE), folderToYaml(f, void 0, path3.basename(f.directoryPath)));
           await placeAndWrite(f, f.directoryPath);
         }
       };
       await placeAndWrite(c, dir);
+      await this.saveLocal(collectionScope(c.id), c.variables);
       await writeFileAtomic(c.filePath, collectionToYaml(c));
       ws.collections.push(c);
       return c;
@@ -3030,9 +3201,10 @@ var WorkspaceStore = class _WorkspaceStore {
   async createFolder(collectionId, parentFolderId, name) {
     return this.enqueue(async () => {
       const { node, dir } = this.container(collectionId, parentFolderId);
-      const folderDir = uniqueDirectoryPath(dir, slugify(name, "folder"));
+      const display = name.trim() || "New Folder";
+      const folderDir = uniqueDirectoryPath(dir, fileSafeName(display, "New Folder"));
       await fs2.mkdir(folderDir, { recursive: true });
-      const f = newFolder({ name: name.trim() || "New Folder", directoryPath: folderDir, order: nextOrder(node.folders) });
+      const f = newFolder({ name: display, directoryPath: folderDir, order: nextOrder(node.folders) });
       await this.writeFolder(f);
       node.folders.push(f);
       return f;
@@ -3043,11 +3215,7 @@ var WorkspaceStore = class _WorkspaceStore {
       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.name !== void 0 && patch.name.trim()) f.name = patch.name;
       if (patch.description !== void 0) f.description = patch.description;
       await this.writeFolder(f);
       return f;
@@ -3069,7 +3237,7 @@ var WorkspaceStore = class _WorkspaceStore {
       const src = hit.folder;
       const srcDir = src.directoryPath;
       const name = copyName(src.name);
-      const dir = uniqueDirectoryPath(path3.dirname(srcDir), slugify(name, "folder"));
+      const dir = uniqueDirectoryPath(path3.dirname(srcDir), fileSafeName(name, "Folder"));
       await fs2.cp(srcDir, dir, { recursive: true });
       const f = structuredClone(src);
       repathTree(f, srcDir, dir);
@@ -3086,16 +3254,16 @@ var WorkspaceStore = class _WorkspaceStore {
     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 file = uniqueFilePath(dir, fileSafeName(name, "New Request"), REQUEST_SUFFIX);
       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));
+      await writeFileAtomic(file, requestToYaml(r, void 0, file));
       node.requests.push(r);
       return r;
     });
   }
-  /** Replaces a request by id and rewrites its file, renaming the file when the name changed. */
+  /** Replaces a request by id and rewrites its file, renaming the file to match the name. */
   async saveRequest(request3) {
     return this.enqueue(async () => {
       const hit = this.locateRequest(request3.id);
@@ -3107,17 +3275,9 @@ var WorkspaceStore = class _WorkspaceStore {
         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)));
+      if (!existing.sourceFilePath) throw new Error("Request has no file path");
+      if (!updated.name.trim()) updated.name = existing.name;
+      await this.writeRequest(updated);
       hit.list[hit.list.indexOf(existing)] = updated;
       return updated;
     });
@@ -3140,8 +3300,8 @@ var WorkspaceStore = class _WorkspaceStore {
       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)));
+      r.sourceFilePath = uniqueFilePath(path3.dirname(src.sourceFilePath), fileSafeName(r.name, "New Request"), REQUEST_SUFFIX);
+      await writeFileAtomic(r.sourceFilePath, requestToYaml(r, await readIfExists(src.sourceFilePath), r.sourceFilePath));
       hit.list.splice(hit.list.indexOf(src) + 1, 0, r);
       await this.saveContainerOrder(hit.collection, hit.folders.at(-1) ?? null);
       return r;
@@ -3163,7 +3323,7 @@ var WorkspaceStore = class _WorkspaceStore {
         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));
+          const dest = uniqueFilePath(target.dir, fileSafeName(r.name, "New Request"), REQUEST_SUFFIX);
           await fs2.rename(r.sourceFilePath, dest);
           r.sourceFilePath = dest;
         }
@@ -3197,13 +3357,15 @@ var WorkspaceStore = class _WorkspaceStore {
   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)));
+      const order = (i + 1) * ORDER_STEP;
+      if (r.order === order && existsSync3(r.sourceFilePath ?? "")) continue;
+      r.order = order;
+      if (r.sourceFilePath) await this.writeRequest(r);
     }
     for (const [i, f] of node.folders.entries()) {
-      if (f.order === i && existsSync3(path3.join(f.directoryPath ?? "", FOLDER_FILE))) continue;
-      f.order = i;
+      const order = (i + 1) * ORDER_STEP;
+      if (f.order === order && existsSync3(path3.join(f.directoryPath ?? "", DEFINITION_FILE))) continue;
+      f.order = order;
       await this.writeFolder(f);
     }
   }
@@ -3211,8 +3373,9 @@ var WorkspaceStore = class _WorkspaceStore {
   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 });
+      const display = name.trim() || "New Environment";
+      const file = uniqueFilePath(ws.environmentsPath, fileSafeName(display, "New Environment"), ENVIRONMENT_SUFFIX);
+      const env = newEnvironment({ name: display, filePath: file });
       await writeFileAtomic(file, environmentToYaml(env));
       ws.environments.push(env);
       return env;
@@ -3222,7 +3385,8 @@ var WorkspaceStore = class _WorkspaceStore {
     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");
+      env.filePath = uniqueFilePath(ws.environmentsPath, fileSafeName(env.name, "Imported Environment"), ENVIRONMENT_SUFFIX);
+      await this.saveLocal(environmentScope(env.id), env.variables);
       await writeFileAtomic(env.filePath, environmentToYaml(env));
       ws.environments.push(env);
       return env;
@@ -3234,16 +3398,14 @@ var WorkspaceStore = class _WorkspaceStore {
       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)));
+      const name = env.name.trim() ? env.name : existing.name;
+      const dir = existing.filePath ? path3.dirname(existing.filePath) : this.workspace.environmentsPath;
+      const target = uniqueFilePath(dir, fileSafeName(name, "New Environment"), ENVIRONMENT_SUFFIX, existing.filePath);
+      const original = await readIfExists(existing.filePath);
+      if (existing.filePath && target !== existing.filePath && existsSync3(existing.filePath)) await fs2.rename(existing.filePath, target);
+      const updated = { ...structuredClone(env), name, filePath: target };
+      await this.saveLocal(environmentScope(updated.id), updated.variables);
+      await writeFileAtomic(target, environmentToYaml(updated, original));
       list[idx] = updated;
       return updated;
     });
@@ -3254,6 +3416,7 @@ var WorkspaceStore = class _WorkspaceStore {
       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 });
+      await this.local?.set(environmentScope(env.id), void 0);
       list.splice(list.indexOf(env), 1);
       return env;
     });
@@ -3264,7 +3427,8 @@ var WorkspaceStore = class _WorkspaceStore {
       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");
+      env.filePath = uniqueFilePath(this.workspace.environmentsPath, fileSafeName(env.name, "Environment"), ENVIRONMENT_SUFFIX);
+      await this.saveLocal(environmentScope(env.id), env.variables);
       await writeFileAtomic(env.filePath, environmentToYaml(env, await readIfExists(src.filePath)));
       list.splice(list.indexOf(src) + 1, 0, env);
       return env;
@@ -3273,7 +3437,10 @@ var WorkspaceStore = class _WorkspaceStore {
   async saveGlobals(vars) {
     return this.enqueue(async () => {
       const file = path3.join(this.workspace.globalsPath, GLOBALS_FILE);
-      await writeFileAtomic(file, globalsToYaml(vars, await readIfExists(file)));
+      const legacy = path3.join(this.workspace.globalsPath, LEGACY_GLOBALS_FILE);
+      await this.saveLocal(GLOBALS_SCOPE, vars);
+      await writeFileAtomic(file, globalsToYaml(vars, await readIfExists(file) ?? await readIfExists(legacy)));
+      await fs2.rm(legacy, { force: true });
       this.workspace.globals = structuredClone(vars);
       return this.workspace.globals;
     });
@@ -3295,23 +3462,50 @@ var WorkspaceStore = class _WorkspaceStore {
     await fs2.rename(from, to);
     repathTree(node, from, to);
   }
+  /** Stores a scope's local values (the YAML gets blanks for them). */
+  async saveLocal(scope, vars) {
+    if (!this.local) return;
+    const values = {};
+    for (const v of vars) if (v.local && v.key) values[v.key] = v.value ?? "";
+    await this.local.set(scope, values);
+  }
+  /** Writes a request, first renaming its file to `<name>.request.yaml` (older names move over). */
+  async writeRequest(r) {
+    const file = r.sourceFilePath;
+    if (!file) return;
+    const original = await readIfExists(file);
+    const target = uniqueFilePath(path3.dirname(file), fileSafeName(r.name, "New Request"), REQUEST_SUFFIX, file);
+    if (target !== file && existsSync3(file)) await fs2.rename(file, target);
+    r.sourceFilePath = target;
+    await writeFileAtomic(target, requestToYaml(r, original, target));
+  }
+  /** Writes `.resources/definition.yaml` (renaming the directory to match the name) and drops a legacy collection.yaml. */
   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)));
+    await this.renameNodeDir(c, this.workspace.collectionsPath, fileSafeName(c.name, "New Collection"));
+    const file = path3.join(c.directoryPath, DEFINITION_FILE);
+    const legacy = path3.join(c.directoryPath, LEGACY_COLLECTION_FILE);
+    const original = await readIfExists(file) ?? await readIfExists(legacy);
+    c.filePath = file;
+    await this.saveLocal(collectionScope(c.id), c.variables);
+    await writeFileAtomic(file, collectionToYaml(c, original));
+    await fs2.rm(legacy, { force: true });
   }
   async writeFolder(f) {
     if (!f.directoryPath) return;
-    const file = path3.join(f.directoryPath, FOLDER_FILE);
-    await writeFileAtomic(file, folderToYaml(f, await readIfExists(file)));
+    await this.renameNodeDir(f, path3.dirname(f.directoryPath), fileSafeName(f.name, "New Folder"));
+    const dir = f.directoryPath;
+    const file = path3.join(dir, DEFINITION_FILE);
+    const legacy = path3.join(dir, LEGACY_FOLDER_FILE);
+    const original = await readIfExists(file) ?? await readIfExists(legacy);
+    await writeFileAtomic(file, folderToYaml(f, original, path3.basename(dir)));
+    await fs2.rm(legacy, { force: true });
   }
   /** 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 r of node.requests) await this.writeRequest(r);
     for (const f of node.folders) await this.writeTree(f);
   }
 };
@@ -3347,7 +3541,7 @@ async function loadWorkspace(root) {
     } catch {
     }
   }
-  const globalsText = await readIfExists(path3.join(ws.globalsPath, GLOBALS_FILE));
+  const globalsText = await readIfExists(path3.join(ws.globalsPath, GLOBALS_FILE)) ?? await readIfExists(path3.join(ws.globalsPath, LEGACY_GLOBALS_FILE));
   if (globalsText) {
     try {
       ws.globals = globalsFromYaml(globalsText);
@@ -3363,11 +3557,11 @@ async function loadCollection(dir, rel) {
     id: stableId("c", rel(dir)),
     name: path3.basename(dir),
     directoryPath: dir,
-    filePath: path3.join(dir, COLLECTION_FILE)
+    filePath: path3.join(dir, DEFINITION_FILE)
   });
-  const definition = await readIfExists(path3.join(dir, DEFINITION_FILE));
+  const definition = await readIfExists(c.filePath);
   if (definition) applyCollectionDefinition(c, loadYaml(definition));
-  const metadata = await readIfExists(c.filePath);
+  const metadata = await readIfExists(path3.join(dir, LEGACY_COLLECTION_FILE));
   if (metadata) applyCollectionMetadata(c, loadYaml(metadata));
   c.requests = await loadRequests(dir, rel);
   c.folders = await loadFolders(dir, rel);
@@ -3379,8 +3573,9 @@ async function loadFolders(parentDir, rel) {
     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) {
+    for (const file of [DEFINITION_FILE, LEGACY_FOLDER_FILE]) {
+      const meta = await readIfExists(path3.join(dir, file));
+      if (!meta) continue;
       try {
         applyFolderMetadata(f, loadYaml(meta));
       } catch {
@@ -3397,11 +3592,12 @@ async function loadRequests(dir, rel) {
   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;
+    if (lower === LEGACY_COLLECTION_FILE || lower === LEGACY_FOLDER_FILE) continue;
     const file = path3.join(dir, entry.name);
     try {
       const raw = loadYaml(await fs2.readFile(file, "utf8"));
       if (!isObj(raw)) continue;
+      if (raw.$kind !== void 0 && String(raw.$kind) !== REQUEST_KIND) continue;
       const r = requestFromDto(raw, file);
       if (!String(raw.id ?? "").trim()) r.id = stableId("r", rel(file));
       requests.push(r);
@@ -3431,9 +3627,22 @@ function ensureUniqueIds(ws, rel) {
   }
   for (const e of ws.environments) e.id = claim(e.id, "e", rel(e.filePath ?? e.name));
 }
+function applyLocalValues(ws, local) {
+  const overlay = (vars, stored) => {
+    if (!stored) return;
+    for (const v of vars) {
+      if (!Object.hasOwn(stored, v.key) || !v.local && v.value) continue;
+      v.value = stored[v.key];
+      v.local = true;
+    }
+  };
+  for (const e of ws.environments) overlay(e.variables, local.get(environmentScope(e.id)));
+  for (const c of ws.collections) overlay(c.variables, local.get(collectionScope(c.id)));
+  overlay(ws.globals, local.get(GLOBALS_SCOPE));
+}
 
 // cli/src/index.ts
-var VERSION = true ? "1.12.0" : "0.0.0-dev";
+var VERSION = true ? "1.13.0" : "0.0.0-dev";
 setYamletVersion(VERSION);
 var CliError = class extends Error {
 };
@@ -3533,7 +3742,7 @@ function parseArgs(argv) {
 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);
+  if (existsSync4(path4) && statSync3(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) {
@@ -3631,7 +3840,7 @@ function formatJson(summary) {
 }
 async function run(args) {
   const dir = resolve(args.workspace);
-  if (!existsSync4(dir) || !statSync2(dir).isDirectory()) throw new CliError(`Workspace folder not found: ${dir}`);
+  if (!existsSync4(dir) || !statSync3(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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@piyushdoorwar/yamlet",
-  "version": "1.12.0",
+  "version": "1.13.0",
   "description": "Run Yamlet API collections (Git-friendly YAML) from the command line or CI.",
   "type": "module",
   "bin": {