proschi 0.13.0 → 0.14.0

package/dist/cli.cjs

@@ -242,8 +242,8 @@ var require_scope = __commonJS({
         super(nameStr);
         this.prefix = prefix;
       }
-      setValue(value, { property, itemIndex }) {
-        this.value = value;
+      setValue(value2, { property, itemIndex }) {
+        this.value = value2;
         this.scopePath = (0, code_1._)`.${new code_1.Name(property)}[${itemIndex}]`;
       }
     };
@@ -262,13 +262,13 @@ var require_scope = __commonJS({
       name(prefix) {
         return new ValueScopeName(prefix, this._newName(prefix));
       }
-      value(nameOrPrefix, value) {
+      value(nameOrPrefix, value2) {
         var _a;
-        if (value.ref === void 0)
+        if (value2.ref === void 0)
           throw new Error("CodeGen: ref must be passed in value");
         const name = this.toName(nameOrPrefix);
         const { prefix } = name;
-        const valueKey = (_a = value.key) !== null && _a !== void 0 ? _a : value.ref;
+        const valueKey = (_a = value2.key) !== null && _a !== void 0 ? _a : value2.ref;
         let vs = this._values[prefix];
         if (vs) {
           const _name = vs.get(valueKey);
@@ -280,8 +280,8 @@ var require_scope = __commonJS({
         vs.set(valueKey, name);
         const s = this._scope[prefix] || (this._scope[prefix] = []);
         const itemIndex = s.length;
-        s[itemIndex] = value.ref;
-        name.setValue(value, { property: prefix, itemIndex });
+        s[itemIndex] = value2.ref;
+        name.setValue(value2, { property: prefix, itemIndex });
         return name;
       }
       getValue(prefix, keyOrRef) {
@@ -751,8 +751,8 @@ var require_codegen = __commonJS({
         return this._extScope.name(prefix);
       }
       // reserves unique name in the external scope and assigns value to it
-      scopeValue(prefixOrName, value) {
-        const name = this._extScope.value(prefixOrName, value);
+      scopeValue(prefixOrName, value2) {
+        const name = this._extScope.value(prefixOrName, value2);
         const vs = this._values[name.prefix] || (this._values[name.prefix] = /* @__PURE__ */ new Set());
         vs.add(name);
         return name;
@@ -806,13 +806,13 @@ var require_codegen = __commonJS({
       // returns code for object literal for the passed argument list of key-value pairs
       object(...keyValues) {
         const code = ["{"];
-        for (const [key, value] of keyValues) {
+        for (const [key, value2] of keyValues) {
           if (code.length > 1)
             code.push(",");
           code.push(key);
-          if (key !== value || this.opts.es5) {
+          if (key !== value2 || this.opts.es5) {
             code.push(":");
-            (0, code_1.addCodeArg)(code, value);
+            (0, code_1.addCodeArg)(code, value2);
           }
         }
         code.push("}");
@@ -891,10 +891,10 @@ var require_codegen = __commonJS({
         return this._leafNode(new Break(label));
       }
       // `return` statement
-      return(value) {
+      return(value2) {
         const node = new Return();
         this._blockNode(node);
-        this.code(value);
+        this.code(value2);
         if (node.nodes.length !== 1)
           throw new Error('CodeGen: "return" should have one node');
         return this._endBlockNode(Return);
@@ -4200,13 +4200,13 @@ var require_fast_uri = __commonJS({
       if (typeof uri !== "string" && typeof uri !== "object") {
         return void 0;
       }
-      let value;
+      let value2;
       try {
-        value = typeof uri === "string" ? uri : serialize(uri, opts);
+        value2 = typeof uri === "string" ? uri : serialize(uri, opts);
       } catch {
         return void 0;
       }
-      const { normalized, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = normalizeStringWithStatus(value, opts);
+      const { normalized, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = normalizeStringWithStatus(value2, opts);
       return malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? void 0 : normalized;
     }
     var fastUri = {
@@ -5073,13 +5073,13 @@ var require_ucs2length = __commonJS({
       const len2 = str.length;
       let length = 0;
       let pos = 0;
-      let value;
+      let value2;
       while (pos < len2) {
         length++;
-        value = str.charCodeAt(pos++);
-        if (value >= 55296 && value <= 56319 && pos < len2) {
-          value = str.charCodeAt(pos);
-          if ((value & 64512) === 56320)
+        value2 = str.charCodeAt(pos++);
+        if (value2 >= 55296 && value2 <= 56319 && pos < len2) {
+          value2 = str.charCodeAt(pos);
+          if ((value2 & 64512) === 56320)
             pos++;
         }
       }
@@ -7970,26 +7970,26 @@ var require_toJS = __commonJS({
   "node_modules/yaml/dist/nodes/toJS.js"(exports2) {
     "use strict";
     var identity = require_identity();
-    function toJS(value, arg, ctx) {
-      if (Array.isArray(value))
-        return value.map((v, i) => toJS(v, String(i), ctx));
-      if (value && typeof value.toJSON === "function") {
-        if (!ctx || !identity.hasAnchor(value))
-          return value.toJSON(arg, ctx);
+    function toJS(value2, arg, ctx) {
+      if (Array.isArray(value2))
+        return value2.map((v, i) => toJS(v, String(i), ctx));
+      if (value2 && typeof value2.toJSON === "function") {
+        if (!ctx || !identity.hasAnchor(value2))
+          return value2.toJSON(arg, ctx);
         const data = { aliasCount: 0, count: 1, res: void 0 };
-        ctx.anchors.set(value, data);
+        ctx.anchors.set(value2, data);
         ctx.onCreate = (res2) => {
           data.res = res2;
           delete ctx.onCreate;
         };
-        const res = value.toJSON(arg, ctx);
+        const res = value2.toJSON(arg, ctx);
         if (ctx.onCreate)
           ctx.onCreate(res);
         return res;
       }
-      if (typeof value === "bigint" && !ctx?.keep)
-        return Number(value);
-      return value;
+      if (typeof value2 === "bigint" && !ctx?.keep)
+        return Number(value2);
+      return value2;
     }
     exports2.toJS = toJS;
   }
@@ -8161,11 +8161,11 @@ var require_Scalar = __commonJS({
     var identity = require_identity();
     var Node = require_Node();
     var toJS = require_toJS();
-    var isScalarValue = (value) => !value || typeof value !== "function" && typeof value !== "object";
+    var isScalarValue = (value2) => !value2 || typeof value2 !== "function" && typeof value2 !== "object";
     var Scalar = class extends Node.NodeBase {
-      constructor(value) {
+      constructor(value2) {
         super(identity.SCALAR);
-        this.value = value;
+        this.value = value2;
       }
       toJSON(arg, ctx) {
         return ctx?.keep ? this.value : toJS.toJS(this.value, arg, ctx);
@@ -8192,7 +8192,7 @@ var require_createNode = __commonJS({
     var identity = require_identity();
     var Scalar = require_Scalar();
     var defaultTagPrefix = "tag:yaml.org,2002:";
-    function findTagObject(value, tagName, tags) {
+    function findTagObject(value2, tagName, tags) {
       if (tagName) {
         const match = tags.filter((t) => t.tag === tagName);
         const tagObj = match.find((t) => !t.format) ?? match[0];
@@ -8200,53 +8200,53 @@ var require_createNode = __commonJS({
           throw new Error(`Tag ${tagName} not found`);
         return tagObj;
       }
-      return tags.find((t) => t.identify?.(value) && !t.format);
+      return tags.find((t) => t.identify?.(value2) && !t.format);
     }
-    function createNode(value, tagName, ctx) {
-      if (identity.isDocument(value))
-        value = value.contents;
-      if (identity.isNode(value))
-        return value;
-      if (identity.isPair(value)) {
+    function createNode(value2, tagName, ctx) {
+      if (identity.isDocument(value2))
+        value2 = value2.contents;
+      if (identity.isNode(value2))
+        return value2;
+      if (identity.isPair(value2)) {
         const map = ctx.schema[identity.MAP].createNode?.(ctx.schema, null, ctx);
-        map.items.push(value);
+        map.items.push(value2);
         return map;
       }
-      if (value instanceof String || value instanceof Number || value instanceof Boolean || typeof BigInt !== "undefined" && value instanceof BigInt) {
-        value = value.valueOf();
+      if (value2 instanceof String || value2 instanceof Number || value2 instanceof Boolean || typeof BigInt !== "undefined" && value2 instanceof BigInt) {
+        value2 = value2.valueOf();
       }
       const { aliasDuplicateObjects, onAnchor, onTagObj, schema, sourceObjects } = ctx;
       let ref = void 0;
-      if (aliasDuplicateObjects && value && typeof value === "object") {
-        ref = sourceObjects.get(value);
+      if (aliasDuplicateObjects && value2 && typeof value2 === "object") {
+        ref = sourceObjects.get(value2);
         if (ref) {
-          ref.anchor ?? (ref.anchor = onAnchor(value));
+          ref.anchor ?? (ref.anchor = onAnchor(value2));
           return new Alias.Alias(ref.anchor);
         } else {
           ref = { anchor: null, node: null };
-          sourceObjects.set(value, ref);
+          sourceObjects.set(value2, ref);
         }
       }
       if (tagName?.startsWith("!!"))
         tagName = defaultTagPrefix + tagName.slice(2);
-      let tagObj = findTagObject(value, tagName, schema.tags);
+      let tagObj = findTagObject(value2, tagName, schema.tags);
       if (!tagObj) {
-        if (value && typeof value.toJSON === "function") {
-          value = value.toJSON();
+        if (value2 && typeof value2.toJSON === "function") {
+          value2 = value2.toJSON();
         }
-        if (!value || typeof value !== "object") {
-          const node2 = new Scalar.Scalar(value);
+        if (!value2 || typeof value2 !== "object") {
+          const node2 = new Scalar.Scalar(value2);
           if (ref)
             ref.node = node2;
           return node2;
         }
-        tagObj = value instanceof Map ? schema[identity.MAP] : Symbol.iterator in Object(value) ? schema[identity.SEQ] : schema[identity.MAP];
+        tagObj = value2 instanceof Map ? schema[identity.MAP] : Symbol.iterator in Object(value2) ? schema[identity.SEQ] : schema[identity.MAP];
       }
       if (onTagObj) {
         onTagObj(tagObj);
         delete ctx.onTagObj;
       }
-      const node = tagObj?.createNode ? tagObj.createNode(ctx.schema, value, ctx) : typeof tagObj?.nodeClass?.from === "function" ? tagObj.nodeClass.from(ctx.schema, value, ctx) : new Scalar.Scalar(value);
+      const node = tagObj?.createNode ? tagObj.createNode(ctx.schema, value2, ctx) : typeof tagObj?.nodeClass?.from === "function" ? tagObj.nodeClass.from(ctx.schema, value2, ctx) : new Scalar.Scalar(value2);
       if (tagName)
         node.tag = tagName;
       else if (!tagObj.default)
@@ -8266,8 +8266,8 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path, value) {
-      let v = value;
+    function collectionFromPath(schema, path, value2) {
+      let v = value2;
       for (let i = path.length - 1; i >= 0; --i) {
         const k = path[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
@@ -8318,16 +8318,16 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path, value) {
+      addIn(path, value2) {
         if (isEmptyPath(path))
-          this.add(value);
+          this.add(value2);
         else {
           const [key, ...rest] = path;
           const node = this.get(key, true);
           if (identity.isCollection(node))
-            node.addIn(rest, value);
+            node.addIn(rest, value2);
           else if (node === void 0 && this.schema)
-            this.set(key, collectionFromPath(this.schema, rest, value));
+            this.set(key, collectionFromPath(this.schema, rest, value2));
           else
             throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
         }
@@ -8381,16 +8381,16 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path, value) {
+      setIn(path, value2) {
         const [key, ...rest] = path;
         if (rest.length === 0) {
-          this.set(key, value);
+          this.set(key, value2);
         } else {
           const node = this.get(key, true);
           if (identity.isCollection(node))
-            node.setIn(rest, value);
+            node.setIn(rest, value2);
           else if (node === void 0 && this.schema)
-            this.set(key, collectionFromPath(this.schema, rest, value));
+            this.set(key, collectionFromPath(this.schema, rest, value2));
           else
             throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
         }
@@ -8585,13 +8585,13 @@ var require_stringifyString = __commonJS({
       }
       return true;
     }
-    function doubleQuotedString(value, ctx) {
-      const json2 = JSON.stringify(value);
+    function doubleQuotedString(value2, ctx) {
+      const json2 = JSON.stringify(value2);
       if (ctx.options.doubleQuotedAsJSON)
         return json2;
       const { implicitKey } = ctx;
       const minMultiLineLength = ctx.options.doubleQuotedMinMultiLineLength;
-      const indent2 = ctx.indent || (containsDocumentMarker(value) ? "  " : "");
+      const indent2 = ctx.indent || (containsDocumentMarker(value2) ? "  " : "");
       let str = "";
       let start = 0;
       for (let i = 0, ch = json2[i]; ch; ch = json2[++i]) {
@@ -8665,22 +8665,22 @@ var require_stringifyString = __commonJS({
       str = start ? str + json2.slice(start) : json2;
       return implicitKey ? str : foldFlowLines.foldFlowLines(str, indent2, foldFlowLines.FOLD_QUOTED, getFoldOptions(ctx, false));
     }
-    function singleQuotedString(value, ctx) {
-      if (ctx.options.singleQuote === false || ctx.implicitKey && value.includes("\n") || /[ \t]\n|\n[ \t]/.test(value))
-        return doubleQuotedString(value, ctx);
-      const indent2 = ctx.indent || (containsDocumentMarker(value) ? "  " : "");
-      const res = "'" + value.replace(/'/g, "''").replace(/\n+/g, `$&
+    function singleQuotedString(value2, ctx) {
+      if (ctx.options.singleQuote === false || ctx.implicitKey && value2.includes("\n") || /[ \t]\n|\n[ \t]/.test(value2))
+        return doubleQuotedString(value2, ctx);
+      const indent2 = ctx.indent || (containsDocumentMarker(value2) ? "  " : "");
+      const res = "'" + value2.replace(/'/g, "''").replace(/\n+/g, `$&
 ${indent2}`) + "'";
       return ctx.implicitKey ? res : foldFlowLines.foldFlowLines(res, indent2, foldFlowLines.FOLD_FLOW, getFoldOptions(ctx, false));
     }
-    function quotedString(value, ctx) {
+    function quotedString(value2, ctx) {
       const { singleQuote } = ctx.options;
       let qs;
       if (singleQuote === false)
         qs = doubleQuotedString;
       else {
-        const hasDouble = value.includes('"');
-        const hasSingle = value.includes("'");
+        const hasDouble = value2.includes('"');
+        const hasSingle = value2.includes("'");
         if (hasDouble && !hasSingle)
           qs = singleQuotedString;
         else if (hasSingle && !hasDouble)
@@ -8688,7 +8688,7 @@ ${indent2}`) + "'";
         else
           qs = singleQuote ? singleQuotedString : doubleQuotedString;
       }
-      return qs(value, ctx);
+      return qs(value2, ctx);
     }
     var blockEndNewlines;
     try {
@@ -8696,27 +8696,27 @@ ${indent2}`) + "'";
     } catch {
       blockEndNewlines = /\n+(?!\n|$)/g;
     }
-    function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
+    function blockString({ comment, type, value: value2 }, ctx, onComment, onChompKeep) {
       const { blockQuote, commentString, lineWidth } = ctx.options;
-      if (!blockQuote || /\n[\t ]+$/.test(value)) {
-        return quotedString(value, ctx);
+      if (!blockQuote || /\n[\t ]+$/.test(value2)) {
+        return quotedString(value2, ctx);
       }
-      const indent2 = ctx.indent || (ctx.forceBlockIndent || containsDocumentMarker(value) ? "  " : "");
-      const literal = blockQuote === "literal" ? true : blockQuote === "folded" || type === Scalar.Scalar.BLOCK_FOLDED ? false : type === Scalar.Scalar.BLOCK_LITERAL ? true : !lineLengthOverLimit(value, lineWidth, indent2.length);
-      if (!value)
+      const indent2 = ctx.indent || (ctx.forceBlockIndent || containsDocumentMarker(value2) ? "  " : "");
+      const literal = blockQuote === "literal" ? true : blockQuote === "folded" || type === Scalar.Scalar.BLOCK_FOLDED ? false : type === Scalar.Scalar.BLOCK_LITERAL ? true : !lineLengthOverLimit(value2, lineWidth, indent2.length);
+      if (!value2)
         return literal ? "|\n" : ">\n";
       let chomp;
       let endStart;
-      for (endStart = value.length; endStart > 0; --endStart) {
-        const ch = value[endStart - 1];
+      for (endStart = value2.length; endStart > 0; --endStart) {
+        const ch = value2[endStart - 1];
         if (ch !== "\n" && ch !== "	" && ch !== " ")
           break;
       }
-      let end = value.substring(endStart);
+      let end = value2.substring(endStart);
       const endNlPos = end.indexOf("\n");
       if (endNlPos === -1) {
         chomp = "-";
-      } else if (value === end || endNlPos !== end.length - 1) {
+      } else if (value2 === end || endNlPos !== end.length - 1) {
         chomp = "+";
         if (onChompKeep)
           onChompKeep();
@@ -8724,7 +8724,7 @@ ${indent2}`) + "'";
         chomp = "";
       }
       if (end) {
-        value = value.slice(0, -end.length);
+        value2 = value2.slice(0, -end.length);
         if (end[end.length - 1] === "\n")
           end = end.slice(0, -1);
         end = end.replace(blockEndNewlines, `$&${indent2}`);
@@ -8732,8 +8732,8 @@ ${indent2}`) + "'";
       let startWithSpace = false;
       let startEnd;
       let startNlPos = -1;
-      for (startEnd = 0; startEnd < value.length; ++startEnd) {
-        const ch = value[startEnd];
+      for (startEnd = 0; startEnd < value2.length; ++startEnd) {
+        const ch = value2[startEnd];
         if (ch === " ")
           startWithSpace = true;
         else if (ch === "\n")
@@ -8741,9 +8741,9 @@ ${indent2}`) + "'";
         else
           break;
       }
-      let start = value.substring(0, startNlPos < startEnd ? startNlPos + 1 : startEnd);
+      let start = value2.substring(0, startNlPos < startEnd ? startNlPos + 1 : startEnd);
       if (start) {
-        value = value.substring(start.length);
+        value2 = value2.substring(start.length);
         start = start.replace(/\n+/g, `$&${indent2}`);
       }
       const indentSize = indent2 ? "2" : "1";
@@ -8754,7 +8754,7 @@ ${indent2}`) + "'";
           onComment();
       }
       if (!literal) {
-        const foldedValue = value.replace(/\n+/g, "\n$&").replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, "$1$2").replace(/\n+/g, `$&${indent2}`);
+        const foldedValue = value2.replace(/\n+/g, "\n$&").replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, "$1$2").replace(/\n+/g, `$&${indent2}`);
         let literalFallback = false;
         const foldOptions = getFoldOptions(ctx, true);
         if (blockQuote !== "folded" && type !== Scalar.Scalar.BLOCK_FOLDED) {
@@ -8767,37 +8767,37 @@ ${indent2}`) + "'";
           return `>${header}
 ${indent2}${body}`;
       }
-      value = value.replace(/\n+/g, `$&${indent2}`);
+      value2 = value2.replace(/\n+/g, `$&${indent2}`);
       return `|${header}
-${indent2}${start}${value}${end}`;
+${indent2}${start}${value2}${end}`;
     }
     function plainString(item, ctx, onComment, onChompKeep) {
-      const { type, value } = item;
+      const { type, value: value2 } = item;
       const { actualString, implicitKey, indent: indent2, indentStep, inFlow } = ctx;
-      if (implicitKey && value.includes("\n") || inFlow && /[[\]{},]/.test(value)) {
-        return quotedString(value, ctx);
+      if (implicitKey && value2.includes("\n") || inFlow && /[[\]{},]/.test(value2)) {
+        return quotedString(value2, ctx);
       }
-      if (/^[\n\t ,[\]{}#&*!|>'"%@`]|^[?-]$|^[?-][ \t]|[\n:][ \t]|[ \t]\n|[\n\t ]#|[\n\t :]$/.test(value)) {
-        return implicitKey || inFlow || !value.includes("\n") ? quotedString(value, ctx) : blockString(item, ctx, onComment, onChompKeep);
+      if (/^[\n\t ,[\]{}#&*!|>'"%@`]|^[?-]$|^[?-][ \t]|[\n:][ \t]|[ \t]\n|[\n\t ]#|[\n\t :]$/.test(value2)) {
+        return implicitKey || inFlow || !value2.includes("\n") ? quotedString(value2, ctx) : blockString(item, ctx, onComment, onChompKeep);
       }
-      if (!implicitKey && !inFlow && type !== Scalar.Scalar.PLAIN && value.includes("\n")) {
+      if (!implicitKey && !inFlow && type !== Scalar.Scalar.PLAIN && value2.includes("\n")) {
         return blockString(item, ctx, onComment, onChompKeep);
       }
-      if (containsDocumentMarker(value)) {
+      if (containsDocumentMarker(value2)) {
         if (indent2 === "") {
           ctx.forceBlockIndent = true;
           return blockString(item, ctx, onComment, onChompKeep);
         } else if (implicitKey && indent2 === indentStep) {
-          return quotedString(value, ctx);
+          return quotedString(value2, ctx);
         }
       }
-      const str = value.replace(/\n+/g, `$&
+      const str = value2.replace(/\n+/g, `$&
 ${indent2}`);
       if (actualString) {
         const test = (tag) => tag.default && tag.tag !== "tag:yaml.org,2002:str" && tag.test?.test(str);
         const { compat, tags } = ctx.doc.schema;
         if (tags.some(test) || compat?.some(test))
-          return quotedString(value, ctx);
+          return quotedString(value2, ctx);
       }
       return implicitKey ? str : foldFlowLines.foldFlowLines(str, indent2, foldFlowLines.FOLD_FLOW, getFoldOptions(ctx, false));
     }
@@ -8970,7 +8970,7 @@ var require_stringifyPair = __commonJS({
     var Scalar = require_Scalar();
     var stringify = require_stringify();
     var stringifyComment = require_stringifyComment();
-    function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
+    function stringifyPair({ key, value: value2 }, ctx, onComment, onChompKeep) {
       const { allNullValues, doc, indent: indent2, indentStep, options: { commentString, indentSeq, simpleKeys } } = ctx;
       let keyComment = identity.isNode(key) && key.comment || null;
       if (simpleKeys) {
@@ -8982,7 +8982,7 @@ var require_stringifyPair = __commonJS({
           throw new Error(msg);
         }
       }
-      let explicitKey = !simpleKeys && (!key || keyComment && value == null && !ctx.inFlow || identity.isCollection(key) || (identity.isScalar(key) ? key.type === Scalar.Scalar.BLOCK_FOLDED || key.type === Scalar.Scalar.BLOCK_LITERAL : typeof key === "object"));
+      let explicitKey = !simpleKeys && (!key || keyComment && value2 == null && !ctx.inFlow || identity.isCollection(key) || (identity.isScalar(key) ? key.type === Scalar.Scalar.BLOCK_FOLDED || key.type === Scalar.Scalar.BLOCK_LITERAL : typeof key === "object"));
       ctx = Object.assign({}, ctx, {
         allNullValues: false,
         implicitKey: !explicitKey && (simpleKeys || !allNullValues),
@@ -8997,12 +8997,12 @@ var require_stringifyPair = __commonJS({
         explicitKey = true;
       }
       if (ctx.inFlow) {
-        if (allNullValues || value == null) {
+        if (allNullValues || value2 == null) {
           if (keyCommentDone && onComment)
             onComment();
           return str === "" ? "?" : explicitKey ? `? ${str}` : str;
         }
-      } else if (allNullValues && !simpleKeys || value == null && explicitKey) {
+      } else if (allNullValues && !simpleKeys || value2 == null && explicitKey) {
         str = `? ${str}`;
         if (keyComment && !keyCommentDone) {
           str += stringifyComment.lineComment(str, ctx.indent, commentString(keyComment));
@@ -9023,26 +9023,26 @@ ${indent2}:`;
           str += stringifyComment.lineComment(str, ctx.indent, commentString(keyComment));
       }
       let vsb, vcb, valueComment;
-      if (identity.isNode(value)) {
-        vsb = !!value.spaceBefore;
-        vcb = value.commentBefore;
-        valueComment = value.comment;
+      if (identity.isNode(value2)) {
+        vsb = !!value2.spaceBefore;
+        vcb = value2.commentBefore;
+        valueComment = value2.comment;
       } else {
         vsb = false;
         vcb = null;
         valueComment = null;
-        if (value && typeof value === "object")
-          value = doc.createNode(value);
+        if (value2 && typeof value2 === "object")
+          value2 = doc.createNode(value2);
       }
       ctx.implicitKey = false;
-      if (!explicitKey && !keyComment && identity.isScalar(value))
+      if (!explicitKey && !keyComment && identity.isScalar(value2))
         ctx.indentAtStart = str.length + 1;
       chompKeep = false;
-      if (!indentSeq && indentStep.length >= 2 && !ctx.inFlow && !explicitKey && identity.isSeq(value) && !value.flow && !value.tag && !value.anchor) {
+      if (!indentSeq && indentStep.length >= 2 && !ctx.inFlow && !explicitKey && identity.isSeq(value2) && !value2.flow && !value2.tag && !value2.anchor) {
         ctx.indent = ctx.indent.substring(2);
       }
       let valueCommentDone = false;
-      const valueStr = stringify.stringify(value, ctx, () => valueCommentDone = true, () => chompKeep = true);
+      const valueStr = stringify.stringify(value2, ctx, () => valueCommentDone = true, () => chompKeep = true);
       let ws = " ";
       if (keyComment || vsb || vcb) {
         ws = vsb ? "\n" : "";
@@ -9058,11 +9058,11 @@ ${stringifyComment.indentComment(cs, ctx.indent)}`;
           ws += `
 ${ctx.indent}`;
         }
-      } else if (!explicitKey && identity.isCollection(value)) {
+      } else if (!explicitKey && identity.isCollection(value2)) {
         const vs0 = valueStr[0];
         const nl0 = valueStr.indexOf("\n");
         const hasNewline = nl0 !== -1;
-        const flow = ctx.inFlow ?? value.flow ?? value.items.length === 0;
+        const flow = ctx.inFlow ?? value2.flow ?? value2.items.length === 0;
         if (hasNewline || !flow) {
           let hasPropsLine = false;
           if (hasNewline && (vs0 === "&" || vs0 === "!")) {
@@ -9125,7 +9125,7 @@ var require_merge = __commonJS({
     var Scalar = require_Scalar();
     var MERGE_KEY = "<<";
     var merge = {
-      identify: (value) => value === MERGE_KEY || typeof value === "symbol" && value.description === MERGE_KEY,
+      identify: (value2) => value2 === MERGE_KEY || typeof value2 === "symbol" && value2.description === MERGE_KEY,
       default: "key",
       tag: "tag:yaml.org,2002:merge",
       test: /^<<$/,
@@ -9135,8 +9135,8 @@ var require_merge = __commonJS({
       stringify: () => MERGE_KEY
     };
     var isMergeKey = (ctx, key) => (merge.identify(key) || identity.isScalar(key) && (!key.type || key.type === Scalar.Scalar.PLAIN) && merge.identify(key.value)) && ctx?.doc.schema.tags.some((tag) => tag.tag === merge.tag && tag.default);
-    function addMergeToJSMap(ctx, map, value) {
-      const source2 = resolveAliasValue(ctx, value);
+    function addMergeToJSMap(ctx, map, value2) {
+      const source2 = resolveAliasValue(ctx, value2);
       if (identity.isSeq(source2))
         for (const it of source2.items)
           mergeValue(ctx, map, it);
@@ -9146,20 +9146,20 @@ var require_merge = __commonJS({
       else
         mergeValue(ctx, map, source2);
     }
-    function mergeValue(ctx, map, value) {
-      const source2 = resolveAliasValue(ctx, value);
+    function mergeValue(ctx, map, value2) {
+      const source2 = resolveAliasValue(ctx, value2);
       if (!identity.isMap(source2))
         throw new Error("Merge sources must be maps or map aliases");
       const srcMap = source2.toJSON(null, ctx, Map);
-      for (const [key, value2] of srcMap) {
+      for (const [key, value3] of srcMap) {
         if (map instanceof Map) {
           if (!map.has(key))
-            map.set(key, value2);
+            map.set(key, value3);
         } else if (map instanceof Set) {
           map.add(key);
         } else if (!Object.prototype.hasOwnProperty.call(map, key)) {
           Object.defineProperty(map, key, {
-            value: value2,
+            value: value3,
             writable: true,
             enumerable: true,
             configurable: true
@@ -9168,8 +9168,8 @@ var require_merge = __commonJS({
       }
       return map;
     }
-    function resolveAliasValue(ctx, value) {
-      return ctx && identity.isAlias(value) ? value.resolve(ctx.doc, ctx) : value;
+    function resolveAliasValue(ctx, value2) {
+      return ctx && identity.isAlias(value2) ? value2.resolve(ctx.doc, ctx) : value2;
     }
     exports2.addMergeToJSMap = addMergeToJSMap;
     exports2.isMergeKey = isMergeKey;
@@ -9186,20 +9186,20 @@ var require_addPairToJSMap = __commonJS({
     var stringify = require_stringify();
     var identity = require_identity();
     var toJS = require_toJS();
-    function addPairToJSMap(ctx, map, { key, value }) {
+    function addPairToJSMap(ctx, map, { key, value: value2 }) {
       if (identity.isNode(key) && key.addToJSMap)
-        key.addToJSMap(ctx, map, value);
+        key.addToJSMap(ctx, map, value2);
       else if (merge.isMergeKey(ctx, key))
-        merge.addMergeToJSMap(ctx, map, value);
+        merge.addMergeToJSMap(ctx, map, value2);
       else {
         const jsKey = toJS.toJS(key, "", ctx);
         if (map instanceof Map) {
-          map.set(jsKey, toJS.toJS(value, jsKey, ctx));
+          map.set(jsKey, toJS.toJS(value2, jsKey, ctx));
         } else if (map instanceof Set) {
           map.add(jsKey);
         } else {
           const stringKey = stringifyKey(key, jsKey, ctx);
-          const jsValue = toJS.toJS(value, stringKey, ctx);
+          const jsValue = toJS.toJS(value2, stringKey, ctx);
           if (stringKey in map)
             Object.defineProperty(map, stringKey, {
               value: jsValue,
@@ -9249,24 +9249,24 @@ var require_Pair = __commonJS({
     var stringifyPair = require_stringifyPair();
     var addPairToJSMap = require_addPairToJSMap();
     var identity = require_identity();
-    function createPair(key, value, ctx) {
+    function createPair(key, value2, ctx) {
       const k = createNode.createNode(key, void 0, ctx);
-      const v = createNode.createNode(value, void 0, ctx);
+      const v = createNode.createNode(value2, void 0, ctx);
       return new Pair(k, v);
     }
     var Pair = class _Pair {
-      constructor(key, value = null) {
+      constructor(key, value2 = null) {
         Object.defineProperty(this, identity.NODE_TYPE, { value: identity.PAIR });
         this.key = key;
-        this.value = value;
+        this.value = value2;
       }
       clone(schema) {
-        let { key, value } = this;
+        let { key, value: value2 } = this;
         if (identity.isNode(key))
           key = key.clone(schema);
-        if (identity.isNode(value))
-          value = value.clone(schema);
-        return new _Pair(key, value);
+        if (identity.isNode(value2))
+          value2 = value2.clone(schema);
+        return new _Pair(key, value2);
       }
       toJSON(_, ctx) {
         const pair = ctx?.mapAsMap ? /* @__PURE__ */ new Map() : {};
@@ -9469,17 +9469,17 @@ var require_YAMLMap = __commonJS({
       static from(schema, obj, ctx) {
         const { keepUndefined, replacer } = ctx;
         const map = new this(schema);
-        const add = (key, value) => {
+        const add = (key, value2) => {
           if (typeof replacer === "function")
-            value = replacer.call(obj, key, value);
+            value2 = replacer.call(obj, key, value2);
           else if (Array.isArray(replacer) && !replacer.includes(key))
             return;
-          if (value !== void 0 || keepUndefined)
-            map.items.push(Pair.createPair(key, value, ctx));
+          if (value2 !== void 0 || keepUndefined)
+            map.items.push(Pair.createPair(key, value2, ctx));
         };
         if (obj instanceof Map) {
-          for (const [key, value] of obj)
-            add(key, value);
+          for (const [key, value2] of obj)
+            add(key, value2);
         } else if (obj && typeof obj === "object") {
           for (const key of Object.keys(obj))
             add(key, obj[key]);
@@ -9537,8 +9537,8 @@ var require_YAMLMap = __commonJS({
       has(key) {
         return !!findPair(this.items, key);
       }
-      set(key, value) {
-        this.add(new Pair.Pair(key, value), true);
+      set(key, value2) {
+        this.add(new Pair.Pair(key, value2), true);
       }
       /**
        * @param ctx - Conversion context, originally set in Document#toJS()
@@ -9616,8 +9616,8 @@ var require_YAMLSeq = __commonJS({
         super(identity.SEQ, schema);
         this.items = [];
       }
-      add(value) {
-        this.items.push(value);
+      add(value2) {
+        this.items.push(value2);
       }
       /**
        * Removes a value from the collection.
@@ -9658,15 +9658,15 @@ var require_YAMLSeq = __commonJS({
        * If `key` does not contain a representation of an integer, this will throw.
        * It may be wrapped in a `Scalar`.
        */
-      set(key, value) {
+      set(key, value2) {
         const idx = asItemIndex(key);
         if (typeof idx !== "number")
           throw new Error(`Expected a valid index, not ${key}.`);
         const prev = this.items[idx];
-        if (identity.isScalar(prev) && Scalar.isScalarValue(value))
-          prev.value = value;
+        if (identity.isScalar(prev) && Scalar.isScalarValue(value2))
+          prev.value = value2;
         else
-          this.items[idx] = value;
+          this.items[idx] = value2;
       }
       toJSON(_, ctx) {
         const seq = [];
@@ -9742,7 +9742,7 @@ var require_string = __commonJS({
     "use strict";
     var stringifyString = require_stringifyString();
     var string = {
-      identify: (value) => typeof value === "string",
+      identify: (value2) => typeof value2 === "string",
       default: true,
       tag: "tag:yaml.org,2002:str",
       resolve: (str) => str,
@@ -9761,7 +9761,7 @@ var require_null = __commonJS({
     "use strict";
     var Scalar = require_Scalar();
     var nullTag = {
-      identify: (value) => value == null,
+      identify: (value2) => value2 == null,
       createNode: () => new Scalar.Scalar(null),
       default: true,
       tag: "tag:yaml.org,2002:null",
@@ -9779,18 +9779,18 @@ var require_bool = __commonJS({
     "use strict";
     var Scalar = require_Scalar();
     var boolTag = {
-      identify: (value) => typeof value === "boolean",
+      identify: (value2) => typeof value2 === "boolean",
       default: true,
       tag: "tag:yaml.org,2002:bool",
       test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,
       resolve: (str) => new Scalar.Scalar(str[0] === "t" || str[0] === "T"),
-      stringify({ source: source2, value }, ctx) {
+      stringify({ source: source2, value: value2 }, ctx) {
         if (source2 && boolTag.test.test(source2)) {
           const sv = source2[0] === "t" || source2[0] === "T";
-          if (value === sv)
+          if (value2 === sv)
             return source2;
         }
-        return value ? ctx.options.trueStr : ctx.options.falseStr;
+        return value2 ? ctx.options.trueStr : ctx.options.falseStr;
       }
     };
     exports2.boolTag = boolTag;
@@ -9801,13 +9801,13 @@ var require_bool = __commonJS({
 var require_stringifyNumber = __commonJS({
   "node_modules/yaml/dist/stringify/stringifyNumber.js"(exports2) {
     "use strict";
-    function stringifyNumber({ format: format3, minFractionDigits, tag, value }) {
-      if (typeof value === "bigint")
-        return String(value);
-      const num = typeof value === "number" ? value : Number(value);
+    function stringifyNumber({ format: format3, minFractionDigits, tag, value: value2 }) {
+      if (typeof value2 === "bigint")
+        return String(value2);
+      const num = typeof value2 === "number" ? value2 : Number(value2);
       if (!isFinite(num))
         return isNaN(num) ? ".nan" : num < 0 ? "-.inf" : ".inf";
-      let n = Object.is(value, -0) ? "-0" : JSON.stringify(value);
+      let n = Object.is(value2, -0) ? "-0" : JSON.stringify(value2);
       if (!format3 && minFractionDigits && (!tag || tag === "tag:yaml.org,2002:float") && /^-?\d/.test(n) && !n.includes("e")) {
         let i = n.indexOf(".");
         if (i < 0) {
@@ -9831,7 +9831,7 @@ var require_float = __commonJS({
     var Scalar = require_Scalar();
     var stringifyNumber = require_stringifyNumber();
     var floatNaN = {
-      identify: (value) => typeof value === "number",
+      identify: (value2) => typeof value2 === "number",
       default: true,
       tag: "tag:yaml.org,2002:float",
       test: /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/,
@@ -9839,7 +9839,7 @@ var require_float = __commonJS({
       stringify: stringifyNumber.stringifyNumber
     };
     var floatExp = {
-      identify: (value) => typeof value === "number",
+      identify: (value2) => typeof value2 === "number",
       default: true,
       tag: "tag:yaml.org,2002:float",
       format: "EXP",
@@ -9851,7 +9851,7 @@ var require_float = __commonJS({
       }
     };
     var float = {
-      identify: (value) => typeof value === "number",
+      identify: (value2) => typeof value2 === "number",
       default: true,
       tag: "tag:yaml.org,2002:float",
       test: /^[-+]?(?:\.[0-9]+|[0-9]+\.[0-9]*)$/,
@@ -9875,16 +9875,16 @@ var require_int = __commonJS({
   "node_modules/yaml/dist/schema/core/int.js"(exports2) {
     "use strict";
     var stringifyNumber = require_stringifyNumber();
-    var intIdentify = (value) => typeof value === "bigint" || Number.isInteger(value);
+    var intIdentify = (value2) => typeof value2 === "bigint" || Number.isInteger(value2);
     var intResolve = (str, offset, radix, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str.substring(offset), radix);
     function intStringify(node, radix, prefix) {
-      const { value } = node;
-      if (intIdentify(value) && value >= 0)
-        return prefix + value.toString(radix);
+      const { value: value2 } = node;
+      if (intIdentify(value2) && value2 >= 0)
+        return prefix + value2.toString(radix);
       return stringifyNumber.stringifyNumber(node);
     }
     var intOct = {
-      identify: (value) => intIdentify(value) && value >= 0,
+      identify: (value2) => intIdentify(value2) && value2 >= 0,
       default: true,
       tag: "tag:yaml.org,2002:int",
       format: "OCT",
@@ -9901,7 +9901,7 @@ var require_int = __commonJS({
       stringify: stringifyNumber.stringifyNumber
     };
     var intHex = {
-      identify: (value) => intIdentify(value) && value >= 0,
+      identify: (value2) => intIdentify(value2) && value2 >= 0,
       default: true,
       tag: "tag:yaml.org,2002:int",
       format: "HEX",
@@ -9950,20 +9950,20 @@ var require_schema3 = __commonJS({
     var Scalar = require_Scalar();
     var map = require_map();
     var seq = require_seq();
-    function intIdentify(value) {
-      return typeof value === "bigint" || Number.isInteger(value);
+    function intIdentify(value2) {
+      return typeof value2 === "bigint" || Number.isInteger(value2);
     }
-    var stringifyJSON = ({ value }) => JSON.stringify(value);
+    var stringifyJSON = ({ value: value2 }) => JSON.stringify(value2);
     var jsonScalars = [
       {
-        identify: (value) => typeof value === "string",
+        identify: (value2) => typeof value2 === "string",
         default: true,
         tag: "tag:yaml.org,2002:str",
         resolve: (str) => str,
         stringify: stringifyJSON
       },
       {
-        identify: (value) => value == null,
+        identify: (value2) => value2 == null,
         createNode: () => new Scalar.Scalar(null),
         default: true,
         tag: "tag:yaml.org,2002:null",
@@ -9972,7 +9972,7 @@ var require_schema3 = __commonJS({
         stringify: stringifyJSON
       },
       {
-        identify: (value) => typeof value === "boolean",
+        identify: (value2) => typeof value2 === "boolean",
         default: true,
         tag: "tag:yaml.org,2002:bool",
         test: /^true$|^false$/,
@@ -9985,10 +9985,10 @@ var require_schema3 = __commonJS({
         tag: "tag:yaml.org,2002:int",
         test: /^-?(?:0|[1-9][0-9]*)$/,
         resolve: (str, _onError, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str, 10),
-        stringify: ({ value }) => intIdentify(value) ? value.toString() : JSON.stringify(value)
+        stringify: ({ value: value2 }) => intIdentify(value2) ? value2.toString() : JSON.stringify(value2)
       },
       {
-        identify: (value) => typeof value === "number",
+        identify: (value2) => typeof value2 === "number",
         default: true,
         tag: "tag:yaml.org,2002:float",
         test: /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/,
@@ -10018,7 +10018,7 @@ var require_binary = __commonJS({
     var Scalar = require_Scalar();
     var stringifyString = require_stringifyString();
     var binary = {
-      identify: (value) => value instanceof Uint8Array,
+      identify: (value2) => value2 instanceof Uint8Array,
       // Buffer inherits from Uint8Array
       default: false,
       tag: "tag:yaml.org,2002:binary",
@@ -10044,10 +10044,10 @@ var require_binary = __commonJS({
           return src;
         }
       },
-      stringify({ comment, type, value }, ctx, onComment, onChompKeep) {
-        if (!value)
+      stringify({ comment, type, value: value2 }, ctx, onComment, onChompKeep) {
+        if (!value2)
           return "";
-        const buf = value;
+        const buf = value2;
         let str;
         if (typeof node_buffer.Buffer === "function") {
           str = buf instanceof node_buffer.Buffer ? buf.toString("base64") : node_buffer.Buffer.from(buf.buffer).toString("base64");
@@ -10119,25 +10119,25 @@ ${cn.comment}` : item.comment;
         for (let it of iterable) {
           if (typeof replacer === "function")
             it = replacer.call(iterable, String(i++), it);
-          let key, value;
+          let key, value2;
           if (Array.isArray(it)) {
             if (it.length === 2) {
               key = it[0];
-              value = it[1];
+              value2 = it[1];
             } else
               throw new TypeError(`Expected [key, value] tuple: ${it}`);
           } else if (it && it instanceof Object) {
             const keys = Object.keys(it);
             if (keys.length === 1) {
               key = keys[0];
-              value = it[key];
+              value2 = it[key];
             } else {
               throw new TypeError(`Expected tuple with one key, not ${keys.length} keys`);
             }
           } else {
             key = it;
           }
-          pairs2.items.push(Pair.createPair(key, value, ctx));
+          pairs2.items.push(Pair.createPair(key, value2, ctx));
         }
       return pairs2;
     }
@@ -10184,16 +10184,16 @@ var require_omap = __commonJS({
         if (ctx?.onCreate)
           ctx.onCreate(map);
         for (const pair of this.items) {
-          let key, value;
+          let key, value2;
           if (identity.isPair(pair)) {
             key = toJS.toJS(pair.key, "", ctx);
-            value = toJS.toJS(pair.value, key, ctx);
+            value2 = toJS.toJS(pair.value, key, ctx);
           } else {
             key = toJS.toJS(pair, "", ctx);
           }
           if (map.has(key))
             throw new Error("Ordered maps must not include duplicate keys");
-          map.set(key, value);
+          map.set(key, value2);
         }
         return map;
       }
@@ -10207,7 +10207,7 @@ var require_omap = __commonJS({
     YAMLOMap.tag = "tag:yaml.org,2002:omap";
     var omap = {
       collection: "seq",
-      identify: (value) => value instanceof Map,
+      identify: (value2) => value2 instanceof Map,
       nodeClass: YAMLOMap,
       default: false,
       tag: "tag:yaml.org,2002:omap",
@@ -10237,14 +10237,14 @@ var require_bool2 = __commonJS({
   "node_modules/yaml/dist/schema/yaml-1.1/bool.js"(exports2) {
     "use strict";
     var Scalar = require_Scalar();
-    function boolStringify({ value, source: source2 }, ctx) {
-      const boolObj = value ? trueTag : falseTag;
+    function boolStringify({ value: value2, source: source2 }, ctx) {
+      const boolObj = value2 ? trueTag : falseTag;
       if (source2 && boolObj.test.test(source2))
         return source2;
-      return value ? ctx.options.trueStr : ctx.options.falseStr;
+      return value2 ? ctx.options.trueStr : ctx.options.falseStr;
     }
     var trueTag = {
-      identify: (value) => value === true,
+      identify: (value2) => value2 === true,
       default: true,
       tag: "tag:yaml.org,2002:bool",
       test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/,
@@ -10252,7 +10252,7 @@ var require_bool2 = __commonJS({
       stringify: boolStringify
     };
     var falseTag = {
-      identify: (value) => value === false,
+      identify: (value2) => value2 === false,
       default: true,
       tag: "tag:yaml.org,2002:bool",
       test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/,
@@ -10271,7 +10271,7 @@ var require_float2 = __commonJS({
     var Scalar = require_Scalar();
     var stringifyNumber = require_stringifyNumber();
     var floatNaN = {
-      identify: (value) => typeof value === "number",
+      identify: (value2) => typeof value2 === "number",
       default: true,
       tag: "tag:yaml.org,2002:float",
       test: /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/,
@@ -10279,7 +10279,7 @@ var require_float2 = __commonJS({
       stringify: stringifyNumber.stringifyNumber
     };
     var floatExp = {
-      identify: (value) => typeof value === "number",
+      identify: (value2) => typeof value2 === "number",
       default: true,
       tag: "tag:yaml.org,2002:float",
       format: "EXP",
@@ -10291,7 +10291,7 @@ var require_float2 = __commonJS({
       }
     };
     var float = {
-      identify: (value) => typeof value === "number",
+      identify: (value2) => typeof value2 === "number",
       default: true,
       tag: "tag:yaml.org,2002:float",
       test: /^[-+]?(?:[0-9][0-9_]*)?\.[0-9_]*$/,
@@ -10318,7 +10318,7 @@ var require_int2 = __commonJS({
   "node_modules/yaml/dist/schema/yaml-1.1/int.js"(exports2) {
     "use strict";
     var stringifyNumber = require_stringifyNumber();
-    var intIdentify = (value) => typeof value === "bigint" || Number.isInteger(value);
+    var intIdentify = (value2) => typeof value2 === "bigint" || Number.isInteger(value2);
     function intResolve(str, offset, radix, { intAsBigInt }) {
       const sign = str[0];
       if (sign === "-" || sign === "+")
@@ -10343,10 +10343,10 @@ var require_int2 = __commonJS({
       return sign === "-" ? -1 * n : n;
     }
     function intStringify(node, radix, prefix) {
-      const { value } = node;
-      if (intIdentify(value)) {
-        const str = value.toString(radix);
-        return value < 0 ? "-" + prefix + str.substr(1) : prefix + str;
+      const { value: value2 } = node;
+      if (intIdentify(value2)) {
+        const str = value2.toString(radix);
+        return value2 < 0 ? "-" + prefix + str.substr(1) : prefix + str;
       }
       return stringifyNumber.stringifyNumber(node);
     }
@@ -10424,13 +10424,13 @@ var require_set = __commonJS({
         const pair = YAMLMap.findPair(this.items, key);
         return !keepPair && identity.isPair(pair) ? identity.isScalar(pair.key) ? pair.key.value : pair.key : pair;
       }
-      set(key, value) {
-        if (typeof value !== "boolean")
-          throw new Error(`Expected boolean value for set(key, value) in a YAML set, not ${typeof value}`);
+      set(key, value2) {
+        if (typeof value2 !== "boolean")
+          throw new Error(`Expected boolean value for set(key, value) in a YAML set, not ${typeof value2}`);
         const prev = YAMLMap.findPair(this.items, key);
-        if (prev && !value) {
+        if (prev && !value2) {
           this.items.splice(this.items.indexOf(prev), 1);
-        } else if (!prev && value) {
+        } else if (!prev && value2) {
           this.items.push(new Pair.Pair(key));
         }
       }
@@ -10449,10 +10449,10 @@ var require_set = __commonJS({
         const { replacer } = ctx;
         const set2 = new this(schema);
         if (iterable && Symbol.iterator in Object(iterable))
-          for (let value of iterable) {
+          for (let value2 of iterable) {
             if (typeof replacer === "function")
-              value = replacer.call(iterable, value, value);
-            set2.items.push(Pair.createPair(value, null, ctx));
+              value2 = replacer.call(iterable, value2, value2);
+            set2.items.push(Pair.createPair(value2, null, ctx));
           }
         return set2;
       }
@@ -10460,7 +10460,7 @@ var require_set = __commonJS({
     YAMLSet.tag = "tag:yaml.org,2002:set";
     var set = {
       collection: "map",
-      identify: (value) => value instanceof Set,
+      identify: (value2) => value2 instanceof Set,
       nodeClass: YAMLSet,
       default: false,
       tag: "tag:yaml.org,2002:set",
@@ -10494,33 +10494,33 @@ var require_timestamp = __commonJS({
       return sign === "-" ? num(-1) * res : res;
     }
     function stringifySexagesimal(node) {
-      let { value } = node;
+      let { value: value2 } = node;
       let num = (n) => n;
-      if (typeof value === "bigint")
+      if (typeof value2 === "bigint")
         num = (n) => BigInt(n);
-      else if (isNaN(value) || !isFinite(value))
+      else if (isNaN(value2) || !isFinite(value2))
         return stringifyNumber.stringifyNumber(node);
       let sign = "";
-      if (value < 0) {
+      if (value2 < 0) {
         sign = "-";
-        value *= num(-1);
+        value2 *= num(-1);
       }
       const _60 = num(60);
-      const parts = [value % _60];
-      if (value < 60) {
+      const parts = [value2 % _60];
+      if (value2 < 60) {
         parts.unshift(0);
       } else {
-        value = (value - parts[0]) / _60;
-        parts.unshift(value % _60);
-        if (value >= 60) {
-          value = (value - parts[0]) / _60;
-          parts.unshift(value);
+        value2 = (value2 - parts[0]) / _60;
+        parts.unshift(value2 % _60);
+        if (value2 >= 60) {
+          value2 = (value2 - parts[0]) / _60;
+          parts.unshift(value2);
         }
       }
       return sign + parts.map((n) => String(n).padStart(2, "0")).join(":").replace(/000000\d*$/, "");
     }
     var intTime = {
-      identify: (value) => typeof value === "bigint" || Number.isInteger(value),
+      identify: (value2) => typeof value2 === "bigint" || Number.isInteger(value2),
       default: true,
       tag: "tag:yaml.org,2002:int",
       format: "TIME",
@@ -10529,7 +10529,7 @@ var require_timestamp = __commonJS({
       stringify: stringifySexagesimal
     };
     var floatTime = {
-      identify: (value) => typeof value === "number",
+      identify: (value2) => typeof value2 === "number",
       default: true,
       tag: "tag:yaml.org,2002:float",
       format: "TIME",
@@ -10538,7 +10538,7 @@ var require_timestamp = __commonJS({
       stringify: stringifySexagesimal
     };
     var timestamp = {
-      identify: (value) => value instanceof Date,
+      identify: (value2) => value2 instanceof Date,
       default: true,
       tag: "tag:yaml.org,2002:timestamp",
       // If the time zone is omitted, the timestamp is assumed to be specified in UTC. The time part
@@ -10551,17 +10551,17 @@ var require_timestamp = __commonJS({
           throw new Error("!!timestamp expects a date, starting with yyyy-mm-dd");
         const [, year, month, day, hour, minute, second] = match.map(Number);
         const millisec = match[7] ? Number((match[7] + "00").substr(1, 3)) : 0;
-        let date = Date.UTC(year, month - 1, day, hour || 0, minute || 0, second || 0, millisec);
+        let date2 = Date.UTC(year, month - 1, day, hour || 0, minute || 0, second || 0, millisec);
         const tz = match[8];
         if (tz && tz !== "Z") {
           let d = parseSexagesimal(tz, false);
           if (Math.abs(d) < 30)
             d *= 60;
-          date -= 6e4 * d;
+          date2 -= 6e4 * d;
         }
-        return new Date(date);
+        return new Date(date2);
       },
-      stringify: ({ value }) => value?.toISOString().replace(/(T00:00:00)?\.000Z$/, "") ?? ""
+      stringify: ({ value: value2 }) => value2?.toISOString().replace(/(T00:00:00)?\.000Z$/, "") ?? ""
     };
     exports2.floatTime = floatTime;
     exports2.intTime = intTime;
@@ -10835,7 +10835,7 @@ var require_Document = __commonJS({
     var createNode = require_createNode();
     var directives = require_directives();
     var Document = class _Document {
-      constructor(value, replacer, options) {
+      constructor(value2, replacer, options) {
         this.commentBefore = null;
         this.comment = null;
         this.errors = [];
@@ -10867,7 +10867,7 @@ var require_Document = __commonJS({
         } else
           this.directives = new directives.Directives({ version });
         this.setSchema(version, options);
-        this.contents = value === void 0 ? null : this.createNode(value, _replacer, options);
+        this.contents = value2 === void 0 ? null : this.createNode(value2, _replacer, options);
       }
       /**
        * Create a deep copy of this Document and its contents.
@@ -10892,14 +10892,14 @@ var require_Document = __commonJS({
         return copy;
       }
       /** Adds a value to the document. */
-      add(value) {
+      add(value2) {
         if (assertCollection(this.contents))
-          this.contents.add(value);
+          this.contents.add(value2);
       }
       /** Adds a value to the document. */
-      addIn(path, value) {
+      addIn(path, value2) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path, value);
+          this.contents.addIn(path, value2);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -10918,10 +10918,10 @@ var require_Document = __commonJS({
         }
         return new Alias.Alias(node.anchor);
       }
-      createNode(value, replacer, options) {
+      createNode(value2, replacer, options) {
         let _replacer = void 0;
         if (typeof replacer === "function") {
-          value = replacer.call({ "": value }, "", value);
+          value2 = replacer.call({ "": value2 }, "", value2);
           _replacer = replacer;
         } else if (Array.isArray(replacer)) {
           const keyToStr = (v) => typeof v === "number" || v instanceof String || v instanceof Number;
@@ -10948,7 +10948,7 @@ var require_Document = __commonJS({
           schema: this.schema,
           sourceObjects
         };
-        const node = createNode.createNode(value, tag, ctx);
+        const node = createNode.createNode(value2, tag, ctx);
         if (flow && identity.isCollection(node))
           node.flow = true;
         setAnchors();
@@ -10958,9 +10958,9 @@ var require_Document = __commonJS({
        * Convert a key and a value into a `Pair` using the current schema,
        * recursively wrapping all values as `Scalar` or `Collection` nodes.
        */
-      createPair(key, value, options = {}) {
+      createPair(key, value2, options = {}) {
         const k = this.createNode(key, null, options);
-        const v = this.createNode(value, null, options);
+        const v = this.createNode(value2, null, options);
         return new Pair.Pair(k, v);
       }
       /**
@@ -11019,24 +11019,24 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      set(key, value) {
+      set(key, value2) {
         if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, [key], value);
+          this.contents = Collection.collectionFromPath(this.schema, [key], value2);
         } else if (assertCollection(this.contents)) {
-          this.contents.set(key, value);
+          this.contents.set(key, value2);
         }
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path, value) {
+      setIn(path, value2) {
         if (Collection.isEmptyPath(path)) {
-          this.contents = value;
+          this.contents = value2;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path), value2);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path, value);
+          this.contents.setIn(path, value2);
         }
       }
       /**
@@ -11422,7 +11422,7 @@ var require_resolve_block_map = __commonJS({
       let offset = bm.offset;
       let commentEnd = null;
       for (const collItem of bm.items) {
-        const { start, key, sep: sep2, value } = collItem;
+        const { start, key, sep: sep2, value: value2 } = collItem;
         const keyProps = resolveProps.resolveProps(start, {
           indicator: "explicit-key-ind",
           next: key ?? sep2?.[0],
@@ -11465,7 +11465,7 @@ var require_resolve_block_map = __commonJS({
           onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
         const valueProps = resolveProps.resolveProps(sep2 ?? [], {
           indicator: "map-value-ind",
-          next: value,
+          next: value2,
           offset: keyNode.range[2],
           onError,
           parentIndent: bm.indent,
@@ -11474,14 +11474,14 @@ var require_resolve_block_map = __commonJS({
         offset = valueProps.end;
         if (valueProps.found) {
           if (implicitKey) {
-            if (value?.type === "block-map" && !valueProps.hasNewline)
+            if (value2?.type === "block-map" && !valueProps.hasNewline)
               onError(offset, "BLOCK_AS_IMPLICIT_KEY", "Nested mappings are not allowed in compact mappings");
             if (ctx.options.strict && keyProps.start < valueProps.found.offset - 1024)
               onError(keyNode.range, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit block mapping key");
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep2, null, valueProps, onError);
+          const valueNode = value2 ? composeNode(ctx, value2, valueProps, onError) : composeEmptyNode(ctx, offset, sep2, null, valueProps, onError);
           if (ctx.schema.compat)
-            utilFlowIndentCheck.flowIndentCheck(bm.indent, value, onError);
+            utilFlowIndentCheck.flowIndentCheck(bm.indent, value2, onError);
           offset = valueNode.range[2];
           const pair = new Pair.Pair(keyNode, valueNode);
           if (ctx.options.keepSourceTokens)
@@ -11527,18 +11527,18 @@ var require_resolve_block_seq = __commonJS({
         ctx.atKey = false;
       let offset = bs.offset;
       let commentEnd = null;
-      for (const { start, value } of bs.items) {
+      for (const { start, value: value2 } of bs.items) {
         const props = resolveProps.resolveProps(start, {
           indicator: "seq-item-ind",
-          next: value,
+          next: value2,
           offset,
           onError,
           parentIndent: bs.indent,
           startOnNewline: true
         });
         if (!props.found) {
-          if (props.anchor || props.tag || value) {
-            if (value?.type === "block-seq")
+          if (props.anchor || props.tag || value2) {
+            if (value2?.type === "block-seq")
               onError(props.end, "BAD_INDENT", "All sequence items must start at the same column");
             else
               onError(offset, "MISSING_CHAR", "Sequence item without - indicator");
@@ -11549,9 +11549,9 @@ var require_resolve_block_seq = __commonJS({
             continue;
           }
         }
-        const node = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, start, null, props, onError);
+        const node = value2 ? composeNode(ctx, value2, props, onError) : composeEmptyNode(ctx, props.end, start, null, props, onError);
         if (ctx.schema.compat)
-          utilFlowIndentCheck.flowIndentCheck(bs.indent, value, onError);
+          utilFlowIndentCheck.flowIndentCheck(bs.indent, value2, onError);
         offset = node.range[2];
         seq.items.push(node);
       }
@@ -11633,7 +11633,7 @@ var require_resolve_flow_collection = __commonJS({
       let offset = fc.offset + fc.start.source.length;
       for (let i = 0; i < fc.items.length; ++i) {
         const collItem = fc.items[i];
-        const { start, key, sep: sep2, value } = collItem;
+        const { start, key, sep: sep2, value: value2 } = collItem;
         const props = resolveProps.resolveProps(start, {
           flow: fcName,
           indicator: "explicit-key-ind",
@@ -11644,7 +11644,7 @@ var require_resolve_flow_collection = __commonJS({
           startOnNewline: false
         });
         if (!props.found) {
-          if (!props.anchor && !props.tag && !sep2 && !value) {
+          if (!props.anchor && !props.tag && !sep2 && !value2) {
             if (i === 0 && props.comma)
               onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
             else if (i < fc.items.length - 1)
@@ -11699,10 +11699,10 @@ var require_resolve_flow_collection = __commonJS({
           }
         }
         if (!isMap && !sep2 && !props.found) {
-          const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep2, null, props, onError);
+          const valueNode = value2 ? composeNode(ctx, value2, props, onError) : composeEmptyNode(ctx, props.end, sep2, null, props, onError);
           coll.items.push(valueNode);
           offset = valueNode.range[2];
-          if (isBlock(value))
+          if (isBlock(value2))
             onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
         } else {
           ctx.atKey = true;
@@ -11714,7 +11714,7 @@ var require_resolve_flow_collection = __commonJS({
           const valueProps = resolveProps.resolveProps(sep2 ?? [], {
             flow: fcName,
             indicator: "map-value-ind",
-            next: value,
+            next: value2,
             offset: keyNode.range[2],
             onError,
             parentIndent: fc.indent,
@@ -11734,15 +11734,15 @@ var require_resolve_flow_collection = __commonJS({
               if (props.start < valueProps.found.offset - 1024)
                 onError(valueProps.found, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit flow sequence key");
             }
-          } else if (value) {
-            if ("source" in value && value.source?.[0] === ":")
-              onError(value, "MISSING_CHAR", `Missing space after : in ${fcName}`);
+          } else if (value2) {
+            if ("source" in value2 && value2.source?.[0] === ":")
+              onError(value2, "MISSING_CHAR", `Missing space after : in ${fcName}`);
             else
               onError(valueProps.start, "MISSING_CHAR", `Missing , or : between ${fcName} items`);
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep2, null, valueProps, onError) : null;
+          const valueNode = value2 ? composeNode(ctx, value2, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep2, null, valueProps, onError) : null;
           if (valueNode) {
-            if (isBlock(value))
+            if (isBlock(value2))
               onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
           } else if (valueProps.comment) {
             if (keyNode.comment)
@@ -11885,11 +11885,11 @@ var require_resolve_block_scalar = __commonJS({
           break;
       }
       if (chompStart === 0) {
-        const value2 = header.chomp === "+" && lines.length > 0 ? "\n".repeat(Math.max(1, lines.length - 1)) : "";
+        const value3 = header.chomp === "+" && lines.length > 0 ? "\n".repeat(Math.max(1, lines.length - 1)) : "";
         let end2 = start + header.length;
         if (scalar2.source)
           end2 += scalar2.source.length;
-        return { value: value2, type, comment: header.comment, range: [start, end2, end2] };
+        return { value: value3, type, comment: header.comment, range: [start, end2, end2] };
       }
       let trimIndent = scalar2.indent + header.indent;
       let offset = scalar2.offset + header.length;
@@ -11919,11 +11919,11 @@ var require_resolve_block_scalar = __commonJS({
         if (lines[i][0].length > trimIndent)
           chompStart = i + 1;
       }
-      let value = "";
+      let value2 = "";
       let sep2 = "";
       let prevMoreIndented = false;
       for (let i = 0; i < contentStart; ++i)
-        value += lines[i][0].slice(trimIndent) + "\n";
+        value2 += lines[i][0].slice(trimIndent) + "\n";
       for (let i = contentStart; i < chompStart; ++i) {
         let [indent2, content] = lines[i];
         offset += indent2.length + content.length + 1;
@@ -11937,23 +11937,23 @@ var require_resolve_block_scalar = __commonJS({
           indent2 = "";
         }
         if (type === Scalar.Scalar.BLOCK_LITERAL) {
-          value += sep2 + indent2.slice(trimIndent) + content;
+          value2 += sep2 + indent2.slice(trimIndent) + content;
           sep2 = "\n";
         } else if (indent2.length > trimIndent || content[0] === "	") {
           if (sep2 === " ")
             sep2 = "\n";
           else if (!prevMoreIndented && sep2 === "\n")
             sep2 = "\n\n";
-          value += sep2 + indent2.slice(trimIndent) + content;
+          value2 += sep2 + indent2.slice(trimIndent) + content;
           sep2 = "\n";
           prevMoreIndented = true;
         } else if (content === "") {
           if (sep2 === "\n")
-            value += "\n";
+            value2 += "\n";
           else
             sep2 = "\n";
         } else {
-          value += sep2 + content;
+          value2 += sep2 + content;
           sep2 = " ";
           prevMoreIndented = false;
         }
@@ -11963,15 +11963,15 @@ var require_resolve_block_scalar = __commonJS({
           break;
         case "+":
           for (let i = chompStart; i < lines.length; ++i)
-            value += "\n" + lines[i][0].slice(trimIndent);
-          if (value[value.length - 1] !== "\n")
-            value += "\n";
+            value2 += "\n" + lines[i][0].slice(trimIndent);
+          if (value2[value2.length - 1] !== "\n")
+            value2 += "\n";
           break;
         default:
-          value += "\n";
+          value2 += "\n";
       }
       const end = start + header.length + scalar2.source.length;
-      return { value, type, comment: header.comment, range: [start, end, end] };
+      return { value: value2, type, comment: header.comment, range: [start, end, end] };
     }
     function parseBlockScalarHeader({ offset, props }, strict, onError) {
       if (props[0].type !== "block-scalar-header") {
@@ -12056,20 +12056,20 @@ var require_resolve_flow_scalar = __commonJS({
     function resolveFlowScalar(scalar2, strict, onError) {
       const { offset, type, source: source2, end } = scalar2;
       let _type;
-      let value;
+      let value2;
       const _onError = (rel, code, msg) => onError(offset + rel, code, msg);
       switch (type) {
         case "scalar":
           _type = Scalar.Scalar.PLAIN;
-          value = plainValue(source2, _onError);
+          value2 = plainValue(source2, _onError);
           break;
         case "single-quoted-scalar":
           _type = Scalar.Scalar.QUOTE_SINGLE;
-          value = singleQuotedValue(source2, _onError);
+          value2 = singleQuotedValue(source2, _onError);
           break;
         case "double-quoted-scalar":
           _type = Scalar.Scalar.QUOTE_DOUBLE;
-          value = doubleQuotedValue(source2, _onError);
+          value2 = doubleQuotedValue(source2, _onError);
           break;
         /* istanbul ignore next should not happen */
         default:
@@ -12084,7 +12084,7 @@ var require_resolve_flow_scalar = __commonJS({
       const valueEnd = offset + source2.length;
       const re = resolveEnd.resolveEnd(end, valueEnd, strict, onError);
       return {
-        value,
+        value: value2,
         type: _type,
         comment: re.comment,
         range: [offset, valueEnd, re.offset]
@@ -12277,28 +12277,28 @@ var require_compose_scalar = __commonJS({
     var resolveBlockScalar = require_resolve_block_scalar();
     var resolveFlowScalar = require_resolve_flow_scalar();
     function composeScalar(ctx, token, tagToken, onError) {
-      const { value, type, comment, range } = token.type === "block-scalar" ? resolveBlockScalar.resolveBlockScalar(ctx, token, onError) : resolveFlowScalar.resolveFlowScalar(token, ctx.options.strict, onError);
+      const { value: value2, type, comment, range } = token.type === "block-scalar" ? resolveBlockScalar.resolveBlockScalar(ctx, token, onError) : resolveFlowScalar.resolveFlowScalar(token, ctx.options.strict, onError);
       const tagName = tagToken ? ctx.directives.tagName(tagToken.source, (msg) => onError(tagToken, "TAG_RESOLVE_FAILED", msg)) : null;
       let tag;
       if (ctx.options.stringKeys && ctx.atKey) {
         tag = ctx.schema[identity.SCALAR];
       } else if (tagName)
-        tag = findScalarTagByName(ctx.schema, value, tagName, tagToken, onError);
+        tag = findScalarTagByName(ctx.schema, value2, tagName, tagToken, onError);
       else if (token.type === "scalar")
-        tag = findScalarTagByTest(ctx, value, token, onError);
+        tag = findScalarTagByTest(ctx, value2, token, onError);
       else
         tag = ctx.schema[identity.SCALAR];
       let scalar2;
       try {
-        const res = tag.resolve(value, (msg) => onError(tagToken ?? token, "TAG_RESOLVE_FAILED", msg), ctx.options);
+        const res = tag.resolve(value2, (msg) => onError(tagToken ?? token, "TAG_RESOLVE_FAILED", msg), ctx.options);
         scalar2 = identity.isScalar(res) ? res : new Scalar.Scalar(res);
       } catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
         onError(tagToken ?? token, "TAG_RESOLVE_FAILED", msg);
-        scalar2 = new Scalar.Scalar(value);
+        scalar2 = new Scalar.Scalar(value2);
       }
       scalar2.range = range;
-      scalar2.source = value;
+      scalar2.source = value2;
       if (type)
         scalar2.type = type;
       if (tagName)
@@ -12309,7 +12309,7 @@ var require_compose_scalar = __commonJS({
         scalar2.comment = comment;
       return scalar2;
     }
-    function findScalarTagByName(schema, value, tagName, tagToken, onError) {
+    function findScalarTagByName(schema, value2, tagName, tagToken, onError) {
       if (tagName === "!")
         return schema[identity.SCALAR];
       const matchWithTest = [];
@@ -12322,7 +12322,7 @@ var require_compose_scalar = __commonJS({
         }
       }
       for (const tag of matchWithTest)
-        if (tag.test?.test(value))
+        if (tag.test?.test(value2))
           return tag;
       const kt = schema.knownTags[tagName];
       if (kt && !kt.collection) {
@@ -12332,10 +12332,10 @@ var require_compose_scalar = __commonJS({
       onError(tagToken, "TAG_RESOLVE_FAILED", `Unresolved tag: ${tagName}`, tagName !== "tag:yaml.org,2002:str");
       return schema[identity.SCALAR];
     }
-    function findScalarTagByTest({ atKey, directives, schema }, value, token, onError) {
-      const tag = schema.tags.find((tag2) => (tag2.default === true || atKey && tag2.default === "key") && tag2.test?.test(value)) || schema[identity.SCALAR];
+    function findScalarTagByTest({ atKey, directives, schema }, value2, token, onError) {
+      const tag = schema.tags.find((tag2) => (tag2.default === true || atKey && tag2.default === "key") && tag2.test?.test(value2)) || schema[identity.SCALAR];
       if (schema.compat) {
-        const compat = schema.compat.find((tag2) => tag2.default && tag2.test?.test(value)) ?? schema[identity.SCALAR];
+        const compat = schema.compat.find((tag2) => tag2.default && tag2.test?.test(value2)) ?? schema[identity.SCALAR];
         if (tag.tag !== compat.tag) {
           const ts = directives.tagString(tag.tag);
           const cs = directives.tagString(compat.tag);
@@ -12493,7 +12493,7 @@ var require_compose_doc = __commonJS({
     var composeNode = require_compose_node();
     var resolveEnd = require_resolve_end();
     var resolveProps = require_resolve_props();
-    function composeDoc(options, directives, { offset, start, value, end }, onError) {
+    function composeDoc(options, directives, { offset, start, value: value2, end }, onError) {
       const opts = Object.assign({ _directives: directives }, options);
       const doc = new Document.Document(void 0, opts);
       const ctx = {
@@ -12505,7 +12505,7 @@ var require_compose_doc = __commonJS({
       };
       const props = resolveProps.resolveProps(start, {
         indicator: "doc-start",
-        next: value ?? end?.[0],
+        next: value2 ?? end?.[0],
         offset,
         onError,
         parentIndent: 0,
@@ -12513,10 +12513,10 @@ var require_compose_doc = __commonJS({
       });
       if (props.found) {
         doc.directives.docStart = true;
-        if (value && (value.type === "block-map" || value.type === "block-seq") && !props.hasNewline)
+        if (value2 && (value2.type === "block-map" || value2.type === "block-seq") && !props.hasNewline)
           onError(props.end, "MISSING_CHAR", "Block collection cannot start on same line with directives-end marker");
       }
-      doc.contents = value ? composeNode.composeNode(ctx, value, props, onError) : composeNode.composeEmptyNode(ctx, props.end, start, null, props, onError);
+      doc.contents = value2 ? composeNode.composeNode(ctx, value2, props, onError) : composeNode.composeEmptyNode(ctx, props.end, start, null, props, onError);
       const contentEnd = doc.contents.range[2];
       const re = resolveEnd.resolveEnd(end, contentEnd, false, onError);
       if (re.comment)
@@ -12764,9 +12764,9 @@ var require_cst_scalar = __commonJS({
       }
       return null;
     }
-    function createScalarToken(value, context) {
+    function createScalarToken(value2, context) {
       const { implicitKey = false, indent: indent2, inFlow = false, offset = -1, type = "PLAIN" } = context;
-      const source2 = stringifyString.stringifyString({ type, value }, {
+      const source2 = stringifyString.stringifyString({ type, value: value2 }, {
         implicitKey,
         indent: indent2 > 0 ? " ".repeat(indent2) : "",
         inFlow,
@@ -12796,7 +12796,7 @@ var require_cst_scalar = __commonJS({
           return { type: "scalar", offset, indent: indent2, source: source2, end };
       }
     }
-    function setScalarValue(token, value, context = {}) {
+    function setScalarValue(token, value2, context = {}) {
       let { afterKey = false, implicitKey = false, inFlow = false, type } = context;
       let indent2 = "indent" in token ? token.indent : null;
       if (afterKey && typeof indent2 === "number")
@@ -12819,7 +12819,7 @@ var require_cst_scalar = __commonJS({
           default:
             type = "PLAIN";
         }
-      const source2 = stringifyString.stringifyString({ type, value }, {
+      const source2 = stringifyString.stringifyString({ type, value: value2 }, {
         implicitKey: implicitKey || indent2 === null,
         indent: indent2 !== null && indent2 > 0 ? " ".repeat(indent2) : "",
         inFlow,
@@ -12965,7 +12965,7 @@ var require_cst_stringify = __commonJS({
         }
       }
     }
-    function stringifyItem({ start, key, sep: sep2, value }) {
+    function stringifyItem({ start, key, sep: sep2, value: value2 }) {
       let res = "";
       for (const st of start)
         res += st.source;
@@ -12974,8 +12974,8 @@ var require_cst_stringify = __commonJS({
       if (sep2)
         for (const st of sep2)
           res += st.source;
-      if (value)
-        res += stringifyToken(value);
+      if (value2)
+        res += stringifyToken(value2);
       return res;
     }
     exports2.stringify = stringify;
@@ -14708,7 +14708,7 @@ var require_public_api = __commonJS({
       }
       return doc.toJS(Object.assign({ reviver: _reviver }, options));
     }
-    function stringify(value, replacer, options) {
+    function stringify(value2, replacer, options) {
       let _replacer = null;
       if (typeof replacer === "function" || Array.isArray(replacer)) {
         _replacer = replacer;
@@ -14721,14 +14721,14 @@ var require_public_api = __commonJS({
         const indent2 = Math.round(options);
         options = indent2 < 1 ? void 0 : indent2 > 8 ? { indent: 8 } : { indent: indent2 };
       }
-      if (value === void 0) {
+      if (value2 === void 0) {
         const { keepUndefined } = options ?? replacer ?? {};
         if (!keepUndefined)
           return void 0;
       }
-      if (identity.isDocument(value) && !_replacer)
-        return value.toString(options);
-      return new Document.Document(value, _replacer, options).toString(options);
+      if (identity.isDocument(value2) && !_replacer)
+        return value2.toString(options);
+      return new Document.Document(value2, _replacer, options).toString(options);
     }
     exports2.parse = parse2;
     exports2.parseAllDocuments = parseAllDocuments;
@@ -14896,7 +14896,7 @@ var require_lz_string = __commonJS({
         },
         _compress: function(uncompressed, bitsPerChar, getCharFromInt) {
           if (uncompressed == null) return "";
-          var i, value, context_dictionary = {}, context_dictionaryToCreate = {}, context_c = "", context_wc = "", context_w = "", context_enlargeIn = 2, context_dictSize = 3, context_numBits = 2, context_data = [], context_data_val = 0, context_data_position = 0, ii;
+          var i, value2, context_dictionary = {}, context_dictionaryToCreate = {}, context_c = "", context_wc = "", context_w = "", context_enlargeIn = 2, context_dictSize = 3, context_numBits = 2, context_data = [], context_data_val = 0, context_data_position = 0, ii;
           for (ii = 0; ii < uncompressed.length; ii += 1) {
             context_c = uncompressed.charAt(ii);
             if (!Object.prototype.hasOwnProperty.call(context_dictionary, context_c)) {
@@ -14919,9 +14919,9 @@ var require_lz_string = __commonJS({
                       context_data_position++;
                     }
                   }
-                  value = context_w.charCodeAt(0);
+                  value2 = context_w.charCodeAt(0);
                   for (i = 0; i < 8; i++) {
-                    context_data_val = context_data_val << 1 | value & 1;
+                    context_data_val = context_data_val << 1 | value2 & 1;
                     if (context_data_position == bitsPerChar - 1) {
                       context_data_position = 0;
                       context_data.push(getCharFromInt(context_data_val));
@@ -14929,12 +14929,12 @@ var require_lz_string = __commonJS({
                     } else {
                       context_data_position++;
                     }
-                    value = value >> 1;
+                    value2 = value2 >> 1;
                   }
                 } else {
-                  value = 1;
+                  value2 = 1;
                   for (i = 0; i < context_numBits; i++) {
-                    context_data_val = context_data_val << 1 | value;
+                    context_data_val = context_data_val << 1 | value2;
                     if (context_data_position == bitsPerChar - 1) {
                       context_data_position = 0;
                       context_data.push(getCharFromInt(context_data_val));
@@ -14942,11 +14942,11 @@ var require_lz_string = __commonJS({
                     } else {
                       context_data_position++;
                     }
-                    value = 0;
+                    value2 = 0;
                   }
-                  value = context_w.charCodeAt(0);
+                  value2 = context_w.charCodeAt(0);
                   for (i = 0; i < 16; i++) {
-                    context_data_val = context_data_val << 1 | value & 1;
+                    context_data_val = context_data_val << 1 | value2 & 1;
                     if (context_data_position == bitsPerChar - 1) {
                       context_data_position = 0;
                       context_data.push(getCharFromInt(context_data_val));
@@ -14954,7 +14954,7 @@ var require_lz_string = __commonJS({
                     } else {
                       context_data_position++;
                     }
-                    value = value >> 1;
+                    value2 = value2 >> 1;
                   }
                 }
                 context_enlargeIn--;
@@ -14964,9 +14964,9 @@ var require_lz_string = __commonJS({
                 }
                 delete context_dictionaryToCreate[context_w];
               } else {
-                value = context_dictionary[context_w];
+                value2 = context_dictionary[context_w];
                 for (i = 0; i < context_numBits; i++) {
-                  context_data_val = context_data_val << 1 | value & 1;
+                  context_data_val = context_data_val << 1 | value2 & 1;
                   if (context_data_position == bitsPerChar - 1) {
                     context_data_position = 0;
                     context_data.push(getCharFromInt(context_data_val));
@@ -14974,7 +14974,7 @@ var require_lz_string = __commonJS({
                   } else {
                     context_data_position++;
                   }
-                  value = value >> 1;
+                  value2 = value2 >> 1;
                 }
               }
               context_enlargeIn--;
@@ -14999,9 +14999,9 @@ var require_lz_string = __commonJS({
                     context_data_position++;
                   }
                 }
-                value = context_w.charCodeAt(0);
+                value2 = context_w.charCodeAt(0);
                 for (i = 0; i < 8; i++) {
-                  context_data_val = context_data_val << 1 | value & 1;
+                  context_data_val = context_data_val << 1 | value2 & 1;
                   if (context_data_position == bitsPerChar - 1) {
                     context_data_position = 0;
                     context_data.push(getCharFromInt(context_data_val));
@@ -15009,12 +15009,12 @@ var require_lz_string = __commonJS({
                   } else {
                     context_data_position++;
                   }
-                  value = value >> 1;
+                  value2 = value2 >> 1;
                 }
               } else {
-                value = 1;
+                value2 = 1;
                 for (i = 0; i < context_numBits; i++) {
-                  context_data_val = context_data_val << 1 | value;
+                  context_data_val = context_data_val << 1 | value2;
                   if (context_data_position == bitsPerChar - 1) {
                     context_data_position = 0;
                     context_data.push(getCharFromInt(context_data_val));
@@ -15022,11 +15022,11 @@ var require_lz_string = __commonJS({
                   } else {
                     context_data_position++;
                   }
-                  value = 0;
+                  value2 = 0;
                 }
-                value = context_w.charCodeAt(0);
+                value2 = context_w.charCodeAt(0);
                 for (i = 0; i < 16; i++) {
-                  context_data_val = context_data_val << 1 | value & 1;
+                  context_data_val = context_data_val << 1 | value2 & 1;
                   if (context_data_position == bitsPerChar - 1) {
                     context_data_position = 0;
                     context_data.push(getCharFromInt(context_data_val));
@@ -15034,7 +15034,7 @@ var require_lz_string = __commonJS({
                   } else {
                     context_data_position++;
                   }
-                  value = value >> 1;
+                  value2 = value2 >> 1;
                 }
               }
               context_enlargeIn--;
@@ -15044,9 +15044,9 @@ var require_lz_string = __commonJS({
               }
               delete context_dictionaryToCreate[context_w];
             } else {
-              value = context_dictionary[context_w];
+              value2 = context_dictionary[context_w];
               for (i = 0; i < context_numBits; i++) {
-                context_data_val = context_data_val << 1 | value & 1;
+                context_data_val = context_data_val << 1 | value2 & 1;
                 if (context_data_position == bitsPerChar - 1) {
                   context_data_position = 0;
                   context_data.push(getCharFromInt(context_data_val));
@@ -15054,7 +15054,7 @@ var require_lz_string = __commonJS({
                 } else {
                   context_data_position++;
                 }
-                value = value >> 1;
+                value2 = value2 >> 1;
               }
             }
             context_enlargeIn--;
@@ -15063,9 +15063,9 @@ var require_lz_string = __commonJS({
               context_numBits++;
             }
           }
-          value = 2;
+          value2 = 2;
           for (i = 0; i < context_numBits; i++) {
-            context_data_val = context_data_val << 1 | value & 1;
+            context_data_val = context_data_val << 1 | value2 & 1;
             if (context_data_position == bitsPerChar - 1) {
               context_data_position = 0;
               context_data.push(getCharFromInt(context_data_val));
@@ -15073,7 +15073,7 @@ var require_lz_string = __commonJS({
             } else {
               context_data_position++;
             }
-            value = value >> 1;
+            value2 = value2 >> 1;
           }
           while (true) {
             context_data_val = context_data_val << 1;
@@ -15253,8 +15253,8 @@ __export(cli_exports, {
   run: () => run
 });
 module.exports = __toCommonJS(cli_exports);
-var import_node_fs14 = require("node:fs");
-var import_node_path13 = require("node:path");
+var import_node_fs15 = require("node:fs");
+var import_node_path14 = require("node:path");
 
 // src/openapi/config.ts
 var import_node_fs2 = require("node:fs");
@@ -15668,9 +15668,9 @@ function tokenizeLine(text, line) {
       break;
     }
     if (ch === '"') {
-      const { value, end, closed } = readString(text, i);
+      const { value: value2, end, closed } = readString(text, i);
       if (!closed) error("Unterminated string", start + 1, text.length - start);
-      tokens.push({ kind: "string", value, col: start + 1, length: end - start });
+      tokens.push({ kind: "string", value: value2, col: start + 1, length: end - start });
       i = end;
       continue;
     }
@@ -15689,9 +15689,9 @@ function tokenizeLine(text, line) {
       const arrow = ["->>", "-->", "->"].find((a) => text.startsWith(a, i));
       const failed = text.startsWith("-x", i) && !IDENT_PART.test(text[i + 2] ?? "");
       if (arrow || failed) {
-        const value = arrow ?? "-x";
-        tokens.push({ kind: "arrow", value, col: start + 1, length: value.length });
-        i += value.length;
+        const value2 = arrow ?? "-x";
+        tokens.push({ kind: "arrow", value: value2, col: start + 1, length: value2.length });
+        i += value2.length;
         continue;
       }
       if (DIGIT.test(text[i + 1] ?? "")) {
@@ -15703,15 +15703,15 @@ function tokenizeLine(text, line) {
     }
     if (DIGIT.test(ch)) {
       i = readQuantity(text, i);
-      const value = text.slice(start, i).replace(/[ \t]+/g, "");
-      const kind = /^\d+$/.test(value) ? "number" : "quantity";
-      tokens.push({ kind, value, col: start + 1, length: i - start });
+      const value2 = text.slice(start, i).replace(/[ \t]+/g, "");
+      const kind = /^\d+$/.test(value2) ? "number" : "quantity";
+      tokens.push({ kind, value: value2, col: start + 1, length: i - start });
       continue;
     }
     if (ch === "<" || ch === ">") {
-      const value = text[i + 1] === "=" ? ch + "=" : ch;
-      tokens.push({ kind: "op", value, col: start + 1, length: value.length });
-      i += value.length;
+      const value2 = text[i + 1] === "=" ? ch + "=" : ch;
+      tokens.push({ kind: "op", value: value2, col: start + 1, length: value2.length });
+      i += value2.length;
       continue;
     }
     if (ch === "@") {
@@ -15764,20 +15764,20 @@ function readQuantity(text, start) {
   return i;
 }
 function readString(text, start) {
-  let value = "";
+  let value2 = "";
   let i = start + 1;
   while (i < text.length) {
     const ch = text[i];
     if (ch === "\\" && i + 1 < text.length) {
-      value += text[i + 1];
+      value2 += text[i + 1];
       i += 2;
       continue;
     }
-    if (ch === '"') return { value, end: i + 1, closed: true };
-    value += ch;
+    if (ch === '"') return { value: value2, end: i + 1, closed: true };
+    value2 += ch;
     i++;
   }
-  return { value, end: text.length, closed: false };
+  return { value: value2, end: text.length, closed: false };
 }
 function stripTrailingComment(text) {
   let depth = 0;
@@ -15823,6 +15823,19 @@ var BracketCounter = class {
     return this.depth;
   }
 };
+function qualify(tokens) {
+  let out;
+  for (let i = 0; i < tokens.length; i++) {
+    const [t, next] = [tokens[i], tokens[i + 1]];
+    const joined = t.kind === "ident" && next?.kind === "tag" && next.col === t.col + t.length;
+    if (joined && (tokens[i + 2]?.kind === "arrow" || tokens[i - 1]?.kind === "arrow")) {
+      out ??= tokens.slice(0, i);
+      out.push({ ...t, value: `${t.value}.${next.value}`, length: t.length + next.length });
+      i++;
+    } else out?.push(t);
+  }
+  return out ?? tokens;
+}
 
 // ../frontend/src/dsl/format.ts
 function format(source2) {
@@ -15859,7 +15872,8 @@ function classify(lines) {
       entries2.push({ kind: "blank", depth, text: "" });
       continue;
     }
-    const { tokens, diagnostics } = tokenizeLine(raw, i + 1);
+    const { tokens: lexed, diagnostics } = tokenizeLine(raw, i + 1);
+    const tokens = qualify(lexed);
     if (diagnostics.some((d) => d.severity === "error") || tokens.length === 0) {
       entries2.push({ kind: "line", depth, text: original });
       continue;
@@ -16014,7 +16028,8 @@ function join(raw, tokens) {
   return out;
 }
 function sameTokens(text, tokens) {
-  const { tokens: again, diagnostics } = tokenizeLine(text, 1);
+  const { tokens: lexed, diagnostics } = tokenizeLine(text, 1);
+  const again = qualify(lexed);
   return diagnostics.length === 0 && again.length === tokens.length && again.every((t, i) => t.kind === tokens[i].kind && t.value === tokens[i].value);
 }
 function reindent(line, delta) {
@@ -16538,14 +16553,14 @@ var Parser = class _Parser {
     return index;
   }
   parseTitle(tokens, line) {
-    const value = tokens[1];
-    if (!value || value.kind !== "string" && value.kind !== "ident") {
+    const value2 = tokens[1];
+    if (!value2 || value2.kind !== "string" && value2.kind !== "ident") {
       this.error('Expected a title, e.g. title "My System"', this.locOf(tokens[0], line));
       return;
     }
     const summary = tokens[2]?.kind === "string" ? tokens[2] : void 0;
     if (this.file === this.rootFile) {
-      this.title = value.value;
+      this.title = value2.value;
       if (summary) this.summary = summary.value;
     }
     this.expectEnd(tokens, summary ? 3 : 2, line);
@@ -16557,13 +16572,13 @@ var Parser = class _Parser {
   }
   /** `direction down|right|up|left`: at the top level for the whole diagram, inside a group for its members. */
   parseDirection(tokens, line) {
-    const [keyword, value] = tokens;
-    const loc = this.locOf(value, line);
-    if (!DIRECTIONS.includes(value.value)) {
-      this.error(`Unknown direction '${value.value}'; use direction down, right, up or left`, loc);
+    const [keyword, value2] = tokens;
+    const loc = this.locOf(value2, line);
+    if (!DIRECTIONS.includes(value2.value)) {
+      this.error(`Unknown direction '${value2.value}'; use direction down, right, up or left`, loc);
       return;
     }
-    const direction = value.value;
+    const direction = value2.value;
     const top = this.top();
     if (top?.kind === "group") {
       const group = this.nodes.get(top.id);
@@ -16586,10 +16601,10 @@ var Parser = class _Parser {
   }
   /** `layout ordered`: lay edges out by declaration order. */
   parseLayoutMode(tokens, line) {
-    const [keyword, value] = tokens;
-    const loc = this.locOf(value, line);
-    if (value.value !== "ordered") {
-      this.error(`Unknown layout mode '${value.value}'; the only one is layout ordered`, loc);
+    const [keyword, value2] = tokens;
+    const loc = this.locOf(value2, line);
+    if (value2.value !== "ordered") {
+      this.error(`Unknown layout mode '${value2.value}'; the only one is layout ordered`, loc);
       return;
     }
     if (this.top()) {
@@ -16612,22 +16627,22 @@ var Parser = class _Parser {
   readRank(tokens, i, line, current) {
     const t = tokens[i];
     if (!isWord(t, "rank")) return 0;
-    const value = tokens[i + 1];
+    const value2 = tokens[i + 1];
     const help = "a layer number from 0 (rank 0, rank 1, \u2026), rank first or rank last";
     if (current.rank !== void 0) {
       this.error(`A node takes one rank; rank ${current.rank} is already set`, this.locOf(t, line));
       return void 0;
     }
-    if (value?.kind === "number" && /^\d+$/.test(value.value)) {
-      current.rank = Number(value.value);
+    if (value2?.kind === "number" && /^\d+$/.test(value2.value)) {
+      current.rank = Number(value2.value);
       return 2;
     }
-    if (value?.kind === "ident" && (value.value === "first" || value.value === "last")) {
-      current.rank = value.value;
+    if (value2?.kind === "ident" && (value2.value === "first" || value2.value === "last")) {
+      current.rank = value2.value;
       return 2;
     }
-    const numeric = value?.kind === "number" || value?.kind === "quantity";
-    this.error(numeric ? `'${value.value}' is not a layer number; use ${help}` : `Expected ${help} after rank`, this.locOf(value ?? t, line));
+    const numeric = value2?.kind === "number" || value2?.kind === "quantity";
+    this.error(numeric ? `'${value2.value}' is not a layer number; use ${help}` : `Expected ${help} after rank`, this.locOf(value2 ?? t, line));
     return void 0;
   }
   parseImport(tokens, line) {
@@ -16886,11 +16901,11 @@ var Parser = class _Parser {
         stub.rps = rps;
         i++;
       } else if (isWord(t, "p99") || isWord(t, "latency") || isWord(t, "availability")) {
-        const value = this.quantityOf(i + 1 < to ? tokens[i + 1] : void 0, t.value === "availability" ? "%" : "ms", t, line);
-        if (value === void 0) return;
-        if (t.value === "p99") stub.p99Ms = value;
-        else if (t.value === "latency") stub.latencyMs = value;
-        else stub.availability = value;
+        const value2 = this.quantityOf(i + 1 < to ? tokens[i + 1] : void 0, t.value === "availability" ? "%" : "ms", t, line);
+        if (value2 === void 0) return;
+        if (t.value === "p99") stub.p99Ms = value2;
+        else if (t.value === "latency") stub.latencyMs = value2;
+        else stub.availability = value2;
         i += 2;
       } else {
         this.error(`Expected ${STUB_HELP}`, this.locOf(t, line));
@@ -17272,10 +17287,10 @@ var Parser = class _Parser {
         else if (n < 1) this.error("A fan-out needs at least one call per request: x1, x2, \u2026", at(match[0].length));
         else out.multiplier = n;
       } else {
-        const bytes = parseSize(size[1]);
+        const bytes2 = parseSize(size[1]);
         if (out.sizeBytes !== void 0) this.error("The payload size is given twice; write one ~<size>", at(match[0].length));
-        else if ("error" in bytes) this.error(bytes.error, at(match[0].length));
-        else out.sizeBytes = bytes.value;
+        else if ("error" in bytes2) this.error(bytes2.error, at(match[0].length));
+        else out.sizeBytes = bytes2.value;
       }
       offset += match[0].length;
       offset += label.slice(offset).length - label.slice(offset).trimStart().length;
@@ -17345,9 +17360,9 @@ var Parser = class _Parser {
       return 1;
     }
     if (isWord(t, "color")) {
-      const value = this.readColor(tokens[i + 1], t, line);
-      if (value === void 0) return void 0;
-      parts.color = value;
+      const value2 = this.readColor(tokens[i + 1], t, line);
+      if (value2 === void 0) return void 0;
+      parts.color = value2;
       return 2;
     }
     if (isNode && isWord(t, "critical")) {
@@ -17619,12 +17634,12 @@ var Parser = class _Parser {
       } else if (isWord(t, "latency") || isWord(t, "availability") || isWord(t, "cost") || isWord(t, "timeout")) {
         part = t.value;
         const unit = part === "latency" || part === "timeout" ? "ms" : part === "availability" ? "%" : "usd/month";
-        const value = this.quantityOf(tokens[i + 1], unit, t, line);
-        if (value === void 0) return;
-        if (part === "latency") override.latencyMs = value;
-        else if (part === "timeout") override.timeoutMs = value;
-        else if (part === "availability") override.availability = value;
-        else override.costUsd = value;
+        const value2 = this.quantityOf(tokens[i + 1], unit, t, line);
+        if (value2 === void 0) return;
+        if (part === "latency") override.latencyMs = value2;
+        else if (part === "timeout") override.timeoutMs = value2;
+        else if (part === "availability") override.availability = value2;
+        else override.costUsd = value2;
         i += 2;
       } else if (isWord(t, "durable") || isWord(t, "volatile")) {
         part = "durable or volatile";
@@ -17632,10 +17647,10 @@ var Parser = class _Parser {
         i++;
       } else if (isWord(t, "reads") || isWord(t, "writes")) {
         part = t.value;
-        const value = this.quantityOf(tokens[i + 1], "rps", t, line);
-        if (value === void 0) return;
-        if (part === "reads") override.readRps = value;
-        else override.writeRps = value;
+        const value2 = this.quantityOf(tokens[i + 1], "rps", t, line);
+        if (value2 === void 0) return;
+        if (part === "reads") override.readRps = value2;
+        else override.writeRps = value2;
         i += 2;
       } else if (isWord(t, "shards")) {
         part = "shards";
@@ -17648,33 +17663,33 @@ var Parser = class _Parser {
         i += 2;
       } else if (isWord(t, "size")) {
         part = "size";
-        const value = tokens[i + 1];
-        if (!isWord(value, "S") && !isWord(value, "M") && !isWord(value, "L")) {
-          this.error(`Expected S, M or L after size${value ? `, not ${describe(value)}` : ""}`, this.locOf(value ?? t, line));
+        const value2 = tokens[i + 1];
+        if (!isWord(value2, "S") && !isWord(value2, "M") && !isWord(value2, "L")) {
+          this.error(`Expected S, M or L after size${value2 ? `, not ${describe(value2)}` : ""}`, this.locOf(value2 ?? t, line));
           return;
         }
-        override.size = value.value;
+        override.size = value2.value;
         i += 2;
       } else if (isWord(t, "consistency")) {
         part = "consistency";
-        const value = tokens[i + 1];
-        if (!isWord(value, "strong") && !isWord(value, "eventual")) {
-          this.error(`Expected strong or eventual after consistency${value ? `, not ${describe(value)}` : ""}`, this.locOf(value ?? t, line));
+        const value2 = tokens[i + 1];
+        if (!isWord(value2, "strong") && !isWord(value2, "eventual")) {
+          this.error(`Expected strong or eventual after consistency${value2 ? `, not ${describe(value2)}` : ""}`, this.locOf(value2 ?? t, line));
           return;
         }
-        override.consistency = value.value;
+        override.consistency = value2.value;
         i += 2;
       } else if (isWord(t, "bandwidth") || isWord(t, "egress")) {
         part = t.value;
-        const value = this.quantityOf(tokens[i + 1], part === "bandwidth" ? "MBps" : "usd/GB", t, line);
-        if (value === void 0) return;
+        const value2 = this.quantityOf(tokens[i + 1], part === "bandwidth" ? "MBps" : "usd/GB", t, line);
+        if (value2 === void 0) return;
         if (part === "bandwidth") {
-          if (value <= 0) {
+          if (value2 <= 0) {
             this.error("Bandwidth must be more than 0", this.locOf(tokens[i + 1], line));
             return;
           }
-          override.bandwidthMBps = value;
-        } else override.egressUsdPerGb = value;
+          override.bandwidthMBps = value2;
+        } else override.egressUsdPerGb = value2;
         i += 2;
       } else {
         this.error(`Unexpected ${describe(t)}; expected ${CAPACITY_PARTS}`, this.locOf(t, line));
@@ -18123,8 +18138,8 @@ var Parser = class _Parser {
       let id = base;
       for (let n = 2; taken.has(id); n++) id = `${base}-${n}`;
       taken.add(id);
-      const steps3 = this.buildSteps(useCase.id, id, path.steps);
-      const entry2 = steps3[0];
+      const steps4 = this.buildSteps(useCase.id, id, path.steps);
+      const entry2 = steps4[0];
       const failedEntry = !!entry2 && (entry2.failed || (entry2.statusCode ?? 0) >= 400);
       const condition = path.conditions.join(" \xB7 ");
       return {
@@ -18132,22 +18147,22 @@ var Parser = class _Parser {
         name: path.names.length ? path.names.join(" \u203A ") : useCase.name,
         outcome: failedEntry ? "error" : "success",
         ...condition ? { condition } : {},
-        steps: steps3,
+        steps: steps4,
         loc: path.locs.at(-1) ?? useCase.loc
       };
     });
-    const steps2 = scenarios[0]?.steps ?? [];
-    const entry = steps2[0];
+    const steps3 = scenarios[0]?.steps ?? [];
+    const entry = steps3[0];
     return {
       ...useCase,
       entryServiceId: entry?.fromServiceId,
       endpoint: entry?.httpMethod ? `${entry.httpMethod} ${entry.endpoint}` : void 0,
-      steps: steps2,
+      steps: steps3,
       scenarios
     };
   }
   buildSteps(useCaseId, scenarioId, raw) {
-    const steps2 = [];
+    const steps3 = [];
     const answered = /* @__PURE__ */ new Set();
     const prefix = scenarioId === "main" ? useCaseId : `${useCaseId}-${scenarioId}`;
     for (const step of raw) {
@@ -18155,7 +18170,7 @@ var Parser = class _Parser {
       if (step.arrow === "-->") {
         const [respFrom] = this.splitRef(step.from);
         const [respTo] = this.splitRef(step.to);
-        const request2 = [...steps2].reverse().find((s) => s.fromServiceId === respTo && s.toServiceId === respFrom && !answered.has(s) && !s.failed);
+        const request2 = [...steps3].reverse().find((s) => s.fromServiceId === respTo && s.toServiceId === respFrom && !answered.has(s) && !s.failed);
         if (!request2) {
           this.warning(`Response has no matching request from '${step.to}' to '${step.from}'`, step.loc);
           continue;
@@ -18179,9 +18194,9 @@ var Parser = class _Parser {
       const port = toPort ?? this.onlyEntry(to, step.loc);
       const target = this.nodes.get(to);
       const isAsync = step.arrow === "->>";
-      steps2.push({
-        id: `${prefix}-${steps2.length + 1}`,
-        stepOrder: steps2.length,
+      steps3.push({
+        id: `${prefix}-${steps3.length + 1}`,
+        stepOrder: steps3.length,
         stepName: label.name || `${step.from} \u2192 ${step.to}`,
         fromServiceId: from,
         toServiceId: to,
@@ -18205,7 +18220,7 @@ var Parser = class _Parser {
         ...fromPort !== void 0 ? { fromPort } : {}
       });
     }
-    return steps2;
+    return steps3;
   }
   /**
    * Warns when a step talks between two nodes the architecture never connects.
@@ -18357,19 +18372,6 @@ function expand(items) {
   }
   return paths;
 }
-function qualify(tokens) {
-  let out;
-  for (let i = 0; i < tokens.length; i++) {
-    const [t, next] = [tokens[i], tokens[i + 1]];
-    const joined = t.kind === "ident" && next?.kind === "tag" && next.col === t.col + t.length;
-    if (joined && (tokens[i + 2]?.kind === "arrow" || tokens[i - 1]?.kind === "arrow")) {
-      out ??= tokens.slice(0, i);
-      out.push({ ...t, value: `${t.value}.${next.value}`, length: t.length + next.length });
-      i++;
-    } else out?.push(t);
-  }
-  return out ?? tokens;
-}
 function findUseCaseIn(diagram, name) {
   const lower = name.toLowerCase();
   return diagram.useCases.find((u) => u.name === name) ?? diagram.useCases.find((u) => u.name.toLowerCase() === lower) ?? diagram.useCases.find((u) => u.id === name);
@@ -18395,8 +18397,8 @@ function splitPayload(input) {
   const formats = { json: "JSON", xml: "XML", text: "FREE_TEXT" };
   const leading = text.match(/^(json|xml|text)\s+([\s\S]+)$/i);
   if (leading) return { text: "", format: formats[leading[1].toLowerCase()], body: leading[2].trim() };
-  const keyed = text.match(/^([\s\S]*?)\s+(json|xml)\s+([{[<][\s\S]*)$/i);
-  if (keyed) return { text: keyed[1].trim(), format: formats[keyed[2].toLowerCase()], body: keyed[3].trim() };
+  const keyed2 = text.match(/^([\s\S]*?)\s+(json|xml)\s+([{[<][\s\S]*)$/i);
+  if (keyed2) return { text: keyed2[1].trim(), format: formats[keyed2[2].toLowerCase()], body: keyed2[3].trim() };
   const bare = text.search(/(^|\s)[{[<]/);
   if (bare !== -1) {
     const body = text.slice(bare).trim();
@@ -18426,9 +18428,9 @@ function parseSize(text) {
   if (!m) return { error: `Expected a payload size after ~, e.g. ~2MB, ~500KB or ~1.5GB${text ? `, not '~${text}'` : ""}` };
   const factor = SIZE_UNITS[m[2]];
   if (factor === void 0) return { error: m[2] ? `Unknown size unit '${m[2]}' in '~${text}'; use B, KB, MB, GB or TB` : `'~${text}' needs a unit: B, KB, MB, GB or TB` };
-  const value = Math.round(Number(m[1]) * factor);
-  if (value <= 0) return { error: `A payload size must be more than 0, not '~${text}'` };
-  return { value };
+  const value2 = Math.round(Number(m[1]) * factor);
+  if (value2 <= 0) return { error: `A payload size must be more than 0, not '~${text}'` };
+  return { value: value2 };
 }
 function inferProtocol(isAsync, method, target) {
   if (isAsync || target?.type === "queue" || target?.type === "broker") return "MESSAGING";
@@ -18550,8 +18552,8 @@ function nodeLine(node) {
   if (node.description) parts.push(quote(node.description));
   return parts.join(" ");
 }
-function stepLines(steps2, indent2, out) {
-  for (const step of steps2) {
+function stepLines(steps3, indent2, out) {
+  for (const step of steps3) {
     if (step.kind === "step") {
       out.push(`${indent2}${step.from} ${step.arrow} ${step.to}${step.label ? ` : ${step.label}` : ""}`);
     } else if (step.kind === "par") {
@@ -18787,8 +18789,8 @@ var OpenApiSpec = class {
     const item = this.resolve(`/paths/${esc(path)}`);
     if (!item || !isObject2(item.value)) return void 0;
     const m = method.toLowerCase();
-    const value = item.value[m];
-    return isObject2(value) ? { path, method: method.toUpperCase(), pointer: `${item.pointer}/${m}`, value } : void 0;
+    const value2 = item.value[m];
+    return isObject2(value2) ? { path, method: method.toUpperCase(), pointer: `${item.pointer}/${m}`, value: value2 } : void 0;
   }
   /** Documented response keys of an operation: `201`, `4XX`, `default`. */
   statuses(op) {
@@ -18830,23 +18832,23 @@ var OpenApiSpec = class {
   }
   /** Follows local `$ref`s from the value at a JSON pointer; returns the final pointer and value. */
   resolve(pointer) {
-    let value = this.at(pointer);
-    for (let hops = 0; isObject2(value) && typeof value.$ref === "string" && hops < 20; hops++) {
-      if (!value.$ref.startsWith("#")) return void 0;
-      pointer = decodeURIComponent(value.$ref.slice(1));
-      value = this.at(pointer);
+    let value2 = this.at(pointer);
+    for (let hops = 0; isObject2(value2) && typeof value2.$ref === "string" && hops < 20; hops++) {
+      if (!value2.$ref.startsWith("#")) return void 0;
+      pointer = decodeURIComponent(value2.$ref.slice(1));
+      value2 = this.at(pointer);
     }
-    return value === void 0 ? void 0 : { pointer, value };
+    return value2 === void 0 ? void 0 : { pointer, value: value2 };
   }
   at(pointer) {
-    let value = this.doc;
+    let value2 = this.doc;
     for (const raw of pointer.split("/").slice(1)) {
       const key = raw.replace(/~1/g, "/").replace(/~0/g, "~");
-      if (Array.isArray(value)) value = value[Number(key)];
-      else if (isObject2(value)) value = value[key];
+      if (Array.isArray(value2)) value2 = value2[Number(key)];
+      else if (isObject2(value2)) value2 = value2[key];
       else return void 0;
     }
-    return value;
+    return value2;
   }
 };
 function describeError(e) {
@@ -18857,11 +18859,11 @@ function describeError(e) {
   if (e.keyword === "enum" && Array.isArray(p.allowedValues)) message += `: ${p.allowedValues.map((v) => JSON.stringify(v)).join(", ")}`;
   return `${where} ${message}`;
 }
-function from30(value) {
-  if (Array.isArray(value)) return value.map(from30);
-  if (!isObject2(value)) return value;
+function from30(value2) {
+  if (Array.isArray(value2)) return value2.map(from30);
+  if (!isObject2(value2)) return value2;
   const out = {};
-  for (const [k, v] of Object.entries(value)) out[k] = from30(v);
+  for (const [k, v] of Object.entries(value2)) out[k] = from30(v);
   for (const [bool, bound] of [
     ["exclusiveMinimum", "minimum"],
     ["exclusiveMaximum", "maximum"]
@@ -19019,10 +19021,10 @@ function readConfig(file) {
   configs.set(file, { mtimeMs, config });
   return config;
 }
-function parseSpecFlag(value) {
-  const eq = value.indexOf("=");
-  if (eq <= 0 || eq === value.length - 1) return void 0;
-  return [value.slice(0, eq), (0, import_node_path3.resolve)(value.slice(eq + 1))];
+function parseSpecFlag(value2) {
+  const eq = value2.indexOf("=");
+  if (eq <= 0 || eq === value2.length - 1) return void 0;
+  return [value2.slice(0, eq), (0, import_node_path3.resolve)(value2.slice(eq + 1))];
 }
 function openApiDiagnostics(file, diagram, overrides = {}) {
   let specs = {};
@@ -19058,6 +19060,152 @@ var RENDER_HELP = `render  Writes the diagram as static files into --out (defaul
 var import_node_fs3 = require("node:fs");
 var import_node_path4 = require("node:path");
 
+// ../frontend/src/dsl/diff.ts
+var byKey2 = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function canonical(value2) {
+  return JSON.stringify(value2, (key, v) => {
+    if (key === "loc" || key === "responseLoc") return void 0;
+    if (v && typeof v === "object" && !Array.isArray(v)) return Object.fromEntries(Object.entries(v).sort(([a], [b]) => byKey2(a, b)));
+    return v;
+  });
+}
+function keyed(items, key) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const base = key(item);
+    let k = base;
+    for (let n = 2; map.has(k); n++) k = `${base}#${n}`;
+    map.set(k, item);
+  }
+  return map;
+}
+function fieldChanges(before2, after2) {
+  return [.../* @__PURE__ */ new Set([...Object.keys(before2), ...Object.keys(after2)])].filter((field) => canonical(before2[field]) !== canonical(after2[field])).map((field) => ({ field, before: before2[field], after: after2[field] }));
+}
+function diffBy(before2, after2, key, fields, keyAfter = key) {
+  const old = keyed(before2, key);
+  const next = keyed(after2, keyAfter);
+  const diff = { added: [], removed: [], changed: [] };
+  for (const k of [...old.keys()].sort(byKey2)) if (!next.has(k)) diff.removed.push(old.get(k));
+  for (const k of [...next.keys()].sort(byKey2)) {
+    const b = old.get(k);
+    const a = next.get(k);
+    if (b === void 0) {
+      diff.added.push(a);
+      continue;
+    }
+    const changes = fieldChanges(fields(b), fields(a));
+    if (changes.length) diff.changed.push({ key: k, before: b, after: a, changes });
+  }
+  return diff;
+}
+function withoutLoc({ loc: _loc, ...rest }) {
+  void _loc;
+  return rest;
+}
+function stepText(step) {
+  const arrow = step.failed ? "-x" : step.executionType === "SYNC_REQUEST_RESPONSE" ? "->" : "->>";
+  const prefixes = `${step.multiplier !== void 0 ? `x${step.multiplier} ` : ""}${step.sizeBytes !== void 0 ? `~${step.sizeBytes}B ` : ""}`;
+  const label = `${prefixes}${step.stepName}`.trim();
+  const reply = [step.statusCode, step.responseBody].filter((x) => x !== void 0 && x !== "").join(" ");
+  const flags = `${step.isParallel ? " [par]" : ""}${step.isConditional ? ` [if ${step.conditionExpression ?? ""}]` : ""}`;
+  return `${step.fromServiceId} ${arrow} ${step.toServiceId}${label ? ` : ${label}` : ""}${reply ? ` --> ${reply}` : ""}${flags}`;
+}
+var steps2 = (list) => list.map(stepText);
+var nodeFields = (n) => ({
+  kind: n.kind,
+  name: n.name,
+  type: n.type,
+  techStack: n.techStack,
+  ownerTeam: n.ownerTeam,
+  description: n.description,
+  parent: n.parent,
+  replicas: n.replicas,
+  color: n.color,
+  tag: n.tag,
+  critical: n.critical,
+  rank: n.rank,
+  direction: n.direction,
+  style: n.style,
+  system: n.system,
+  position: n.position
+});
+function edgeKey(edges) {
+  const pairs = /* @__PURE__ */ new Map();
+  for (const e of edges) pairs.set(`${e.source}->${e.target}`, (pairs.get(`${e.source}->${e.target}`) ?? 0) + 1);
+  return (e) => {
+    const pair = `${e.source}->${e.target}`;
+    return pairs.get(pair) > 1 ? `${pair} : ${e.label ?? ""}` : pair;
+  };
+}
+var edgeFields = (e) => ({ label: e.label, tag: e.tag, style: e.style, sourcePort: e.sourcePort, targetPort: e.targetPort });
+var useCaseFields = (u) => ({
+  name: u.name,
+  description: u.description,
+  entryServiceId: u.entryServiceId,
+  endpoint: u.endpoint,
+  steps: steps2(u.steps)
+});
+var scenarioFields = ({ scenario: s }) => ({ name: s.name, outcome: s.outcome, condition: s.condition, steps: steps2(s.steps) });
+var scenariosOf = (d) => d.useCases.flatMap((u) => u.scenarios.map((scenario) => ({ useCase: u.id, scenario })));
+function requirementKey(r) {
+  switch (r.kind) {
+    case "latency":
+      return `latency p${r.percentile} ${r.useCase ?? "*"}${r.scenario ? `/${r.scenario}` : ""}`;
+    case "availability":
+      return `availability ${r.useCase ?? "*"}`;
+    case "durable":
+      return `durable ${r.useCase}`;
+    case "survive":
+      return `survive ${canonical(r.target)}`;
+    case "cost":
+      return "cost";
+  }
+}
+function requirementFields(r) {
+  switch (r.kind) {
+    case "latency":
+      return { maxMs: r.maxMs };
+    case "availability":
+      return { minPercent: r.minPercent };
+    case "cost":
+      return { maxUsdPerMonth: r.maxUsdPerMonth };
+    default:
+      return {};
+  }
+}
+var systemFields = (s) => ({
+  from: s.from,
+  entries: s.entries.map((e) => `${e.id}${e.name !== e.id ? ` "${e.name}"` : ""}${e.useCase ? ` -> "${e.useCase}"` : ""}`),
+  stub: s.stub && withoutLoc(s.stub)
+});
+function diffDiagrams(before2, after2) {
+  return {
+    diagram: fieldChanges({ title: before2.title, summary: before2.summary }, { title: after2.title, summary: after2.summary }),
+    nodes: diffBy(before2.nodes, after2.nodes, (n) => n.id, nodeFields),
+    edges: diffBy(before2.edges, after2.edges, edgeKey(before2.edges), edgeFields, edgeKey(after2.edges)),
+    useCases: diffBy(before2.useCases, after2.useCases, (u) => u.id, useCaseFields),
+    scenarios: diffBy(scenariosOf(before2), scenariosOf(after2), (s) => `${s.useCase}/${s.scenario.id}`, scenarioFields),
+    requirements: diffBy(before2.requirements ?? [], after2.requirements ?? [], requirementKey, requirementFields),
+    traffic: diffBy(before2.traffic ?? [], after2.traffic ?? [], (t) => t.useCase, (t) => ({ rps: t.rps, mix: t.mix })),
+    capacity: diffBy(before2.capacity ?? [], after2.capacity ?? [], (c) => c.node, withoutLoc),
+    systems: diffBy(before2.systems ?? [], after2.systems ?? [], (s) => s.id, systemFields)
+  };
+}
+var DIFF_SECTIONS = ["nodes", "edges", "useCases", "scenarios", "requirements", "traffic", "capacity", "systems"];
+function summarizeDiff(diff) {
+  const total = { added: 0, removed: 0, changed: diff.diagram.length };
+  const counts = { total };
+  for (const section2 of DIFF_SECTIONS) {
+    const { added, removed, changed } = diff[section2];
+    counts[section2] = { added: added.length, removed: removed.length, changed: changed.length };
+    total.added += added.length;
+    total.removed += removed.length;
+    total.changed += changed.length;
+  }
+  return counts;
+}
+
 // ../frontend/src/dsl/sequence.ts
 var PAYLOAD_LIMIT = 40;
 function shorten(text, max = PAYLOAD_LIMIT) {
@@ -19109,9 +19257,9 @@ function buildSequence(useCase, scenario, nodes = []) {
     const depth = stack.map((s) => s.toServiceId).lastIndexOf(from);
     while (stack.length > depth + 1) emit(response(stack.pop()));
   };
-  const steps2 = scenario.steps;
-  for (let i = 0; i < steps2.length; i++) {
-    const step = steps2[i];
+  const steps3 = scenario.steps;
+  for (let i = 0; i < steps3.length; i++) {
+    const step = steps3[i];
     if (step.parallelGroup === void 0) {
       unwindFor(step.fromServiceId);
       emit(request(step));
@@ -19119,7 +19267,7 @@ function buildSequence(useCase, scenario, nodes = []) {
       continue;
     }
     const group = [];
-    while (i < steps2.length && steps2[i].parallelGroup === step.parallelGroup) group.push(steps2[i++]);
+    while (i < steps3.length && steps3[i].parallelGroup === step.parallelGroup) group.push(steps3[i++]);
     i--;
     unwindFor(step.fromServiceId);
     items.push({ kind: "par", branches: group.map((s) => hasResponse(s) ? [request(s), response(s)] : [request(s)]) });
@@ -19134,7 +19282,7 @@ function buildSequence(useCase, scenario, nodes = []) {
     const node = byId.get(id);
     participants.push({ id, name: node?.name ?? id, tech: node && !node.implicit ? node.techStack : void 0 });
   };
-  for (const step of steps2) {
+  for (const step of steps3) {
     add(step.fromServiceId);
     add(step.toServiceId);
   }
@@ -19622,7 +19770,7 @@ function sharedLoad(root, rootInbound) {
     }
   };
   visit(root, "");
-  const send = (d, prefix, inbound) => {
+  const send2 = (d, prefix, inbound) => {
     for (const s of d.systems ?? []) {
       if (!s.diagram) continue;
       const key = teamKey(s);
@@ -19632,12 +19780,12 @@ function sharedLoad(root, rootInbound) {
       if (rps > 0) load.callers.push({ path: prefix ? `${prefix}.${s.id}` : s.id, ...d.title !== void 0 ? { from: d.title } : {}, rps });
     }
   };
-  send(root, "", rootInbound);
+  send2(root, "", rootInbound);
   for (const key of order.reverse()) {
     const { diagram, path, loc } = designs.get(key);
     if (!diagram.systems?.length) continue;
     const combined = withExtraTraffic(diagram, byFile.get(key)?.useCases ?? /* @__PURE__ */ new Map(), loc);
-    send(diagram, path, inboundLoad(combined, resolveTraffic(combined)));
+    send2(diagram, path, inboundLoad(combined, resolveTraffic(combined)));
   }
   return { byFile, analyses: /* @__PURE__ */ new Map() };
 }
@@ -19755,8 +19903,8 @@ function breachesOf(team, sent, analysis) {
       if (r.scenario !== void 0 && !scenario) continue;
       const what = `${key} of "${u.name}"${scenario ? ` scenario "${scenario.name}"` : ""}`;
       const name = `${what} < ${formatMs(r.maxMs)}`;
-      const steps2 = scenario ? scenario.steps : u.scenarios.flatMap((s) => s.steps);
-      const saturated = steps2.map((s) => nodes.get(s.toServiceId)).reduce((best, n) => n?.saturated && (!best || n.utilization > best.utilization) ? n : best, void 0);
+      const steps3 = scenario ? scenario.steps : u.scenarios.flatMap((s) => s.steps);
+      const saturated = steps3.map((s) => nodes.get(s.toServiceId)).reduce((best, n) => n?.saturated && (!best || n.utilization > best.utilization) ? n : best, void 0);
       if (saturated) {
         breaches.push({ requirement: name, message: `${what}: ${saturated.id} is saturated (${usageText(saturated)}) ${under} (limit ${formatMs(r.maxMs)})` });
         continue;
@@ -19848,13 +19996,13 @@ function computeEgressGb(diagram, traffic, kindOf2 = (id) => profileOfId(diagram
 }
 var BANDWIDTH_BOUND = (kind) => !["client", "external", "dns", "other", "storage", "cdn"].includes(kind);
 function computeBytesPerSecond(diagram, traffic) {
-  const bytes = /* @__PURE__ */ new Map();
+  const bytes2 = /* @__PURE__ */ new Map();
   forEachStepRate(diagram, traffic, (step, rate) => {
     if (!step.sizeBytes || step.sizeBytes <= 0) return;
     const b = rate * multiplierOf(step) * step.sizeBytes;
-    for (const id of /* @__PURE__ */ new Set([step.fromServiceId, step.toServiceId])) bytes.set(id, (bytes.get(id) ?? 0) + b);
+    for (const id of /* @__PURE__ */ new Set([step.fromServiceId, step.toServiceId])) bytes2.set(id, (bytes2.get(id) ?? 0) + b);
   });
-  return bytes;
+  return bytes2;
 }
 function profileOfId(diagram, id) {
   const node = diagram.nodes.find((n) => n.id === id);
@@ -20010,14 +20158,14 @@ function analyze(diagram, options = {}) {
   const traffic = resolveTraffic(diagram, warnings);
   const load = computeLoad(diagram, traffic);
   const egress = computeEgressGb(diagram, traffic, kindOf2);
-  const bytes = computeBytesPerSecond(diagram, traffic);
+  const bytes2 = computeBytesPerSecond(diagram, traffic);
   const systems = diagram.systems?.length ? analyzeSystems(diagram, traffic, options) : void 0;
   const hops = /* @__PURE__ */ new Map();
   const nodeResults = nodes.map((n) => {
     const p = profiles.get(n.id);
     const replicas = Math.max(1, options.replicas?.get(n.id) ?? replicasOf(n));
     const { read, write } = load.get(n.id) ?? { read: 0, write: 0 };
-    const usage = usageOf(p, replicas, read, write, bytes.get(n.id) ?? 0);
+    const usage = usageOf(p, replicas, read, write, bytes2.get(n.id) ?? 0);
     const servers = serversOf(usage, replicas);
     const hop = hopModel(p.latencyMs, usage.utilization, servers);
     hops.set(n.id, hop);
@@ -20193,7 +20341,7 @@ var CATEGORY = {
 };
 var percentileName = (q) => PERCENTILE_KEYS[q];
 var lineOf = (loc) => `${loc.file ? `${loc.file}:` : "line "}${loc.line}`;
-function stepText(step) {
+function stepText2(step) {
   const arrow = step.failed ? "-x" : step.executionType === "SYNC_REQUEST_RESPONSE" ? "->" : "->>";
   const label = requestLabel(step);
   return `${step.fromServiceId} ${arrow} ${step.toServiceId}${label ? ` : ${label}` : ""} at ${lineOf(step.loc)}`;
@@ -20248,10 +20396,10 @@ function unknownUseCase(run2, name) {
   const hint = near.length ? `Use one of ${near.map((u) => quote2(u.name)).join(", ")}` : `Add usecase ${quote2(name)} { \u2026 }`;
   return { ...fail(`No use case named ${quote2(name)}`, hint), missing: `use case ${name}` };
 }
-function saturatedOn(run2, ids, value, maxMs) {
+function saturatedOn(run2, ids, value2, maxMs) {
   const n = [...new Set(ids)].map((id) => run2.nodes.get(id)).find((x) => !!x?.saturated);
   if (!n) return void 0;
-  const v = value(n);
+  const v = value2(n);
   return { ...fail(`${v} (limit ${formatMs(maxMs)})`, saturationHint(run2, n)), value: v };
 }
 function latency(run2, u, q, maxMs) {
@@ -20262,12 +20410,12 @@ function latency(run2, u, q, maxMs) {
   const saturated = saturatedOn(run2, touched, (n) => `${key} of ${u.name}: ${n.id} is saturated (${usageText(n)})`, maxMs);
   if (saturated) return saturated;
   const ms = result.percentiles[key];
-  const value = `${key} of ${u.name} is ${formatMs(ms)}${result.rps > 0 ? "" : " with no traffic"}`;
-  const message = `${value} (limit ${formatMs(maxMs)})`;
-  if (ms < maxMs) return { ...pass(message), value };
+  const value2 = `${key} of ${u.name} is ${formatMs(ms)}${result.rps > 0 ? "" : " with no traffic"}`;
+  const message = `${value2} (limit ${formatMs(maxMs)})`;
+  if (ms < maxMs) return { ...pass(message), value: value2 };
   const index = Math.min(result.tailScenario[key] ?? 0, u.scenarios.length - 1);
   const lead = u.scenarios.length > 1 ? `The "${u.scenarios[index].name}" path (${formatPercent(result.scenarios[index].share)} of traffic) sets ${key}. ` : "";
-  return { ...fail(message, lead + latencyHint(run2, u, u.scenarios[index])), value };
+  return { ...fail(message, lead + latencyHint(run2, u, u.scenarios[index])), value: value2 };
 }
 function scenarioLatency(run2, useCase, scenario, q, maxMs) {
   const sc = scope(run2, useCase, scenario);
@@ -20308,14 +20456,14 @@ function latencyHint(run2, u, scenario) {
   const sized = hops.find((h) => (h.step.sizeBytes ?? 0) > 0);
   const node = run2.nodes.get(slowest.target);
   if (node && node.utilization > HOT) return `${label} runs at ${formatPercent(node.utilization)} and queues requests; add replicas to it.`;
-  const payload = sized ? ` Payloads add transfer time too (${stepText(sized.step)}): send fewer bytes or let the client fetch them from a CDN or storage directly.` : "";
+  const payload = sized ? ` Payloads add transfer time too (${stepText2(sized.step)}): send fewer bytes or let the client fetch them from a CDN or storage directly.` : "";
   return `Its slowest hop is ${label} at ${formatMs(cost3(slowest))}: put a cache in front of it, run independent calls in par, or move work off the request path with ->>.${payload}`;
 }
 function availability(run2, u, minPercent) {
   const result = run2.useCases.get(u.id);
-  const value = `availability of ${u.name} is ${formatAvailability(result.availability)}`;
-  const message = `${value} (limit ${minPercent}%)`;
-  if (result.availability * 100 >= minPercent - 1e-9) return { ...pass(message), value };
+  const value2 = `availability of ${u.name} is ${formatAvailability(result.availability)}`;
+  const message = `${value2} (limit ${minPercent}%)`;
+  if (result.availability * 100 >= minPercent - 1e-9) return { ...pass(message), value: value2 };
   const shares = run2.shares.get(u.id) ?? [];
   const main = u.scenarios.length ? pathNodes(u, u.scenarios[mainScenarioIndex(shares)]) : [];
   const writes = mainWrites(u, shares, run2.isWrite);
@@ -20323,7 +20471,7 @@ function availability(run2, u, minPercent) {
   const weakest = main.filter((id) => fallbacksFor(u, id).length === 0).map((id) => run2.nodes.get(id)).filter((n) => !!n && effective(n) < 1).sort((a, b) => effective(a) - effective(b))[0];
   const primaryBound = weakest && writes.has(weakest.id) && weakest.writeAvailability < weakest.availability;
   const hint = !weakest ? "Add replicas to the nodes on the main path, or fallback scenarios that complete without them" : primaryBound ? `The weakest link is writing to ${nodeLabel(run2.diagram, weakest.id)}: writes need its primary, ${formatAvailability(weakest.writeAvailability)} with failover${weakest.replicas < 2 ? " (none without a second replica; add one)" : ` (a replica takes over, but about ${formatPercent(FAILOVER_SHARE)} of each outage is lost)`}. Move the writes to a partitioned store, or add a fallback scenario that calls it with -x and still completes` : `The weakest link is ${nodeLabel(run2.diagram, weakest.id)} at ${formatAvailability(effective(weakest))}: add a replica (x${weakest.replicas + 1}) or a fallback scenario that calls it with -x and still completes`;
-  return { ...fail(message, hint), value };
+  return { ...fail(message, hint), value: value2 };
 }
 function writeGap(run2, u, s, accept) {
   const { requests, beforeResponse } = requestOrder(u, s);
@@ -20350,11 +20498,11 @@ function writesCheck(run2, u, scenarios, accept, what) {
   const text = (s, gap) => {
     switch (gap.kind) {
       case "async":
-        return `${where(s)} writes to ${what} only asynchronously: ${stepText(gap.step)}`;
+        return `${where(s)} writes to ${what} only asynchronously: ${stepText2(gap.step)}`;
       case "after":
-        return `${where(s)} writes to ${what} only after responding: ${stepText(gap.step)}`;
+        return `${where(s)} writes to ${what} only after responding: ${stepText2(gap.step)}`;
       case "read":
-        return `${where(s)} only reads from ${what} before responding: ${stepText(gap.step)} is a read`;
+        return `${where(s)} only reads from ${what} before responding: ${stepText2(gap.step)} is a read`;
       case "none":
         return `${where(s)} never writes to ${what} before responding`;
     }
@@ -20548,7 +20696,7 @@ function calls(run2, a) {
     const first = calling[0];
     const step = called(first)[0];
     return fail(
-      `${multi ? quote2(first.name) : sc.label} calls ${nodeLabel(run2.diagram, step.toServiceId)}: ${stepText(step)}`,
+      `${multi ? quote2(first.name) : sc.label} calls ${nodeLabel(run2.diagram, step.toServiceId)}: ${stepText2(step)}`,
       `Take the call to ${step.toServiceId} out of ${quote2(first.name)}, e.g. serve it from a cache`
     );
   }
@@ -20579,7 +20727,7 @@ function before(run2, a) {
     if (ix < 0 || ix > iy) {
       const where = sc.scenarios.length > 1 || a.scenario ? `In ${quote2(s.name)}` : `In ${quote2(sc.u.name)}`;
       return fail(
-        ix < 0 ? `${where}, ${order[iy].to} is called (${stepText(order[iy].step)}) but ${x} never is` : `${where}, ${order[iy].to} is called (${stepText(order[iy].step)}) before ${order[ix].to} (${stepText(order[ix].step)})`,
+        ix < 0 ? `${where}, ${order[iy].to} is called (${stepText2(order[iy].step)}) but ${x} never is` : `${where}, ${order[iy].to} is called (${stepText2(order[iy].step)}) before ${order[ix].to} (${stepText2(order[ix].step)})`,
         `Call ${x} before the first call to ${y}`
       );
     }
@@ -20597,7 +20745,7 @@ function neverWaits(run2, a) {
     if (hop) {
       const where = sc.scenarios.length > 1 ? quote2(s.name) : sc.label;
       return fail(
-        `${where} waits for ${nodeLabel(run2.diagram, hop.target)} before responding: ${stepText(hop.step)}${hop.failed ? " times out on the request path" : " is synchronous"}`,
+        `${where} waits for ${nodeLabel(run2.diagram, hop.target)} before responding: ${stepText2(hop.step)}${hop.failed ? " times out on the request path" : " is synchronous"}`,
         `Send it with ->> (through a queue if it must not be lost), or move it after the line that answers the entry request`
       );
     }
@@ -20623,7 +20771,7 @@ function after(run2, a) {
     if (iy < ix) {
       const where = sc.scenarios.length > 1 || a.scenario ? `In ${quote2(s.name)}` : `In ${quote2(sc.u.name)}`;
       return fail(
-        `${where}, the last call to ${y} (${stepText(order[iy].step)}) comes before the first call to ${x} (${stepText(order[ix].step)})`,
+        `${where}, the last call to ${y} (${stepText2(order[iy].step)}) comes before the first call to ${x} (${stepText2(order[ix].step)})`,
         `Call ${y} after ${x}: move the step to ${order[iy].to} below the call to ${order[ix].to}`
       );
     }
@@ -20652,9 +20800,9 @@ function senderCalls(run2, a) {
       const step = s.steps.find((st) => from.has(st.fromServiceId) && to.has(st.toServiceId));
       if (!step) continue;
       const where = u.scenarios.length > 1 ? `${quote2(u.name)} scenario ${quote2(s.name)}` : quote2(u.name);
-      if (a.quantifier === "some") return pass(`${x} calls ${y}${within}: ${stepText(step)} in ${where}`);
+      if (a.quantifier === "some") return pass(`${x} calls ${y}${within}: ${stepText2(step)} in ${where}`);
       return fail(
-        `${x} calls ${y}${within}: ${stepText(step)} in ${where}`,
+        `${x} calls ${y}${within}: ${stepText2(step)} in ${where}`,
         `Let another node make this call (e.g. the client uploads to storage with a presigned URL), or remove the step`
       );
     }
@@ -20675,7 +20823,7 @@ function startsAt(run2, a) {
   const wrong = entries2.find((s) => !ids.has(s.fromServiceId));
   if (wrong) {
     return fail(
-      `${quote2(u.name)} starts at ${nodeLabel(run2.diagram, wrong.fromServiceId)}, not ${what}: ${stepText(wrong)}`,
+      `${quote2(u.name)} starts at ${nodeLabel(run2.diagram, wrong.fromServiceId)}, not ${what}: ${stepText2(wrong)}`,
       `Make the first step of "${u.name}" a step sent by ${what}`
     );
   }
@@ -20765,6 +20913,10 @@ var import_node_path6 = require("node:path");
 var ImportError = class extends Error {
   name = "ImportError";
 };
+var LATEST_TAG = "latest";
+var VERSION_TAG = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+var CLOUD_NAME_SEGMENT = /^[A-Za-z0-9_][A-Za-z0-9._+-]*$/;
+var MAX_CLOUD_NAME = 200;
 var MAX_SPEC_LENGTH = 1024;
 var SEGMENT = /^[A-Za-z0-9_][A-Za-z0-9._ +-]*$/;
 var HOST = /^[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?(?:\.[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?)*(?::\d{1,5})?$/;
@@ -20812,8 +20964,9 @@ function parseRemoteSpec(spec) {
     checkRef(ref, spec);
     return { kind: "git", repo, path, ref };
   }
+  if (scheme === "cloud") return parseCloudSpec(spec);
   if (scheme === "http") throw new ImportError(`'${spec}' uses http://; only https:// imports are allowed`);
-  if (scheme !== "https") throw new ImportError(`'${spec}' is not a supported import source; use a relative path, git: or https://`);
+  if (scheme !== "https") throw new ImportError(`'${spec}' is not a supported import source; use a relative path, git:, https:// or cloud:`);
   let url;
   try {
     url = new URL(spec);
@@ -20825,15 +20978,51 @@ function parseRemoteSpec(spec) {
   if (!HOST.test(url.host)) throw new ImportError(`'${spec}' has an invalid host`);
   return { kind: "https", url: url.href };
 }
+function parseCloudSpec(spec) {
+  const body = spec.slice("cloud:".length);
+  const split2 = body.indexOf("//");
+  const head = split2 === -1 ? body : body.slice(0, split2);
+  const parts = head.split(":");
+  if (parts.length > 2) throw new ImportError(`'${spec}' is not a cloud source; write cloud:<name> or cloud:<name>:<tag>`);
+  const name = parts[0].endsWith(".proschi") ? parts[0].slice(0, -".proschi".length) : parts[0];
+  if (!name || name.length > MAX_CLOUD_NAME || name.split("/").some((p) => !CLOUD_NAME_SEGMENT.test(p) || p === "." || p === "..")) {
+    throw new ImportError(
+      `'${spec}' names an invalid diagram '${parts[0]}'; use the diagram's file name (letters, digits, '.', '_', '+', '-' and '/', no spaces), with or without .proschi`
+    );
+  }
+  const tag = parts.length === 2 ? parts[1] : LATEST_TAG;
+  if (!VERSION_TAG.test(tag)) {
+    throw new ImportError(`'${spec}' has an invalid version tag '${tag}'; use up to 64 letters, digits, '.', '_' and '-', starting with a letter or digit, e.g. 2026-11-01`);
+  }
+  if (split2 === -1) return { kind: "cloud", name, tag };
+  return { kind: "cloud", name, tag, path: repoPathSegments(body.slice(split2 + 2), spec).join("/") };
+}
 function formatRemoteSpec(spec) {
+  if (spec.kind === "cloud") return `cloud:${spec.name}:${spec.tag}${spec.path ? `//${spec.path}` : ""}`;
   return spec.kind === "git" ? `git:${spec.repo}//${spec.path}@${spec.ref}` : spec.url;
 }
+function cloudDocumentName(spec) {
+  return `${spec.name}.proschi`;
+}
 function resolveImportPath(fromPath, importPath) {
   if (importPath.includes("\0")) throw new ImportError(`'${importPath.replace(/\0/g, "")}' contains a NUL character`);
   const remote = parseRemoteSpec(importPath);
+  if (remote?.kind === "cloud" && fromPath && isRemoteSpec(fromPath) && parseRemoteSpec(fromPath)?.kind !== "cloud") {
+    throw new ImportError(`'${importPath}' is a cloud import inside ${fromPath}; cloud: sources only work from your own diagrams`);
+  }
   if (remote) return formatRemoteSpec(remote);
   if (isAbsolutePath(importPath)) throw new ImportError(`'${importPath}' is an absolute path; imports must be relative to the importing file`);
   const from = fromPath && isRemoteSpec(fromPath) ? parseRemoteSpec(fromPath) : void 0;
+  if (from?.kind === "cloud") {
+    const parts2 = (from.path ?? "").split("/").slice(0, -1);
+    for (const part of importPath.split("/")) {
+      if (part === "" || part === ".") continue;
+      if (part !== "..") parts2.push(part);
+      else if (parts2.length > 0) parts2.pop();
+      else throw new ImportError(`'${importPath}' leaves the files saved with cloud:${from.name}:${from.tag}`);
+    }
+    return formatRemoteSpec({ ...from, path: repoPathSegments(parts2.join("/"), importPath).join("/") });
+  }
   if (from?.kind === "git") {
     const parts2 = from.path.split("/").slice(0, -1);
     for (const part of importPath.split("/")) {
@@ -20867,6 +21056,15 @@ function joinImportPath(fromPath, importPath) {
     throw e;
   }
 }
+function isImportKey(key) {
+  if (key.includes("\0")) return false;
+  if (!isRemoteSpec(key)) return !isAbsolutePath(key);
+  try {
+    return resolveImportPath(void 0, key) === key;
+  } catch {
+    return false;
+  }
+}
 function mapResolver(files) {
   const paths = Object.keys(files).filter((p) => !isRemoteSpec(p));
   return (importPath, fromPath) => {
@@ -20935,12 +21133,12 @@ function parseArgs(args, styles, err) {
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === "--format") {
-      const value = args[++i];
-      if (!styles.includes(value)) {
-        err(`Unknown format '${value ?? ""}'; use ${styles.join(", ")}`);
+      const value2 = args[++i];
+      if (!styles.includes(value2)) {
+        err(`Unknown format '${value2 ?? ""}'; use ${styles.join(", ")}`);
         return void 0;
       }
-      style = value;
+      style = value2;
     } else if (arg.startsWith("-")) {
       err(`Unknown option ${arg}
 
@@ -21054,11 +21252,14 @@ var LOCK_FILE = "proschi.lock";
 var CACHE_DIR = ".proschi/cache";
 var HASH = /^[0-9a-f]{64}$/;
 var COMMIT = /^[0-9a-f]{40}([0-9a-f]{24})?$/;
-var emptyLock = () => ({ version: 1, git: {}, https: {} });
+var emptyLock = () => ({ version: 1, git: {}, https: {}, cloud: {} });
 var gitKey = (repo, ref) => `${repo}@${ref}`;
+var cloudKey = (name, tag) => `${name}:${tag}`;
 var remoteError = {
   noLock: (spec) => new ImportError(`'${spec}' is a remote import and there is no ${LOCK_FILE}; run proschi imports sync`),
-  notLocked: (spec) => new ImportError(`'${spec}' is not in ${LOCK_FILE}; run proschi imports sync`),
+  notLocked: (spec) => spec.startsWith("cloud:") ? remoteError.cloud(spec) : new ImportError(`'${spec}' is not in ${LOCK_FILE}; run proschi imports sync`),
+  /** A cloud version that is not pinned yet (docs/design/versions-and-cloud.md). */
+  cloud: (spec) => new ImportError(`'${spec}' is a version in your Proschi account; run proschi imports sync to pin it (cloud sources need proschi login)`),
   notCached: (spec) => new ImportError(`'${spec}' is not in the import cache (${CACHE_DIR}); run proschi imports sync`),
   altered: (spec) => new ImportError(`The cached copy of '${spec}' does not match its hash in ${LOCK_FILE}; run proschi imports sync`)
 };
@@ -21075,7 +21276,8 @@ function parseLock(text) {
   const lock = emptyLock();
   const git = json2.git ?? {};
   const https = json2.https ?? {};
-  if (!isRecord(git) || !isRecord(https)) throw invalid('"git" and "https" must be objects');
+  const cloud = json2.cloud ?? {};
+  if (!isRecord(git) || !isRecord(https) || !isRecord(cloud)) throw invalid('"git", "https" and "cloud" must be objects');
   for (const [key, entry] of Object.entries(git)) {
     const at = key.lastIndexOf("@");
     const valid = at > 0 && isRecord(entry) && typeof entry.commit === "string" && COMMIT.test(entry.commit) && isRecord(entry.files) && Object.entries(entry.files).every(([path, hash]) => typeof hash === "string" && HASH.test(hash) && isGitSpec(`git:${key.slice(0, at)}//${path}@${key.slice(at + 1)}`));
@@ -21086,8 +21288,28 @@ function parseLock(text) {
     if (typeof hash !== "string" || !HASH.test(hash) || parseRemoteSpec(url)?.kind !== "https") throw invalid(`bad https entry '${url}'`);
     lock.https[url] = hash;
   }
+  for (const [key, entry] of Object.entries(cloud)) {
+    const hash = (v) => typeof v === "string" && HASH.test(v);
+    const valid = isCanonicalSpec(`cloud:${key}`, "cloud") && isRecord(entry) && typeof entry.tag === "string" && VERSION_TAG.test(entry.tag) && entry.tag !== LATEST_TAG && Number.isSafeInteger(entry.seq) && entry.seq > 0 && hash(entry.sha256) && (entry.source === void 0 || hash(entry.source)) && isRecord(entry.files) && Object.entries(entry.files).every(([path, h]) => hash(h) && isCanonicalSpec(`cloud:${key}//${path}`, "cloud"));
+    if (!valid) throw invalid(`bad cloud entry '${key}'`);
+    lock.cloud[key] = {
+      tag: entry.tag,
+      seq: entry.seq,
+      sha256: entry.sha256,
+      ...entry.source === void 0 ? {} : { source: entry.source },
+      files: { ...entry.files }
+    };
+  }
   return lock;
 }
+function isCanonicalSpec(spec, kind) {
+  try {
+    const remote = parseRemoteSpec(spec);
+    return remote?.kind === kind && formatRemoteSpec(remote) === spec;
+  } catch {
+    return false;
+  }
+}
 function isGitSpec(spec) {
   try {
     return parseRemoteSpec(spec)?.kind === "git";
@@ -21099,18 +21321,23 @@ function lockedHash(lock, spec) {
   const remote = parseRemoteSpec(spec);
   if (remote?.kind === "git") return lock.git[gitKey(remote.repo, remote.ref)]?.files[remote.path];
   if (remote?.kind === "https") return lock.https[remote.url];
+  if (remote?.kind === "cloud") {
+    const entry = lock.cloud[cloudKey(remote.name, remote.tag)];
+    return remote.path === void 0 ? entry?.source : entry?.files[remote.path];
+  }
   return void 0;
 }
 
 // src/lock.ts
-var sha256 = (bytes) => (0, import_node_crypto.createHash)("sha256").update(bytes).digest("hex");
+var sha256 = (bytes2) => (0, import_node_crypto.createHash)("sha256").update(bytes2).digest("hex");
 function readLock(root) {
   const file = (0, import_node_path5.join)(root, LOCK_FILE);
   return (0, import_node_fs4.existsSync)(file) ? parseLock((0, import_node_fs4.readFileSync)(file, "utf8")) : void 0;
 }
 var sorted = (o, map = (v) => v) => Object.fromEntries(Object.keys(o).sort().map((k) => [k, map(o[k])]));
 function formatLock(lock) {
-  return JSON.stringify({ version: 1, git: sorted(lock.git, (e) => ({ commit: e.commit, files: sorted(e.files) })), https: sorted(lock.https) }, null, 2) + "\n";
+  const cloud = Object.keys(lock.cloud).length ? { cloud: sorted(lock.cloud, (e) => ({ tag: e.tag, seq: e.seq, sha256: e.sha256, ...e.source ? { source: e.source } : {}, files: sorted(e.files) })) } : {};
+  return JSON.stringify({ version: 1, git: sorted(lock.git, (e) => ({ commit: e.commit, files: sorted(e.files) })), https: sorted(lock.https), ...cloud }, null, 2) + "\n";
 }
 function writeLock(root, lock) {
   (0, import_node_fs4.writeFileSync)((0, import_node_path5.join)(root, LOCK_FILE), formatLock(lock));
@@ -21120,16 +21347,16 @@ function readCached(root, hash, spec) {
   if (!HASH.test(hash)) return void 0;
   const file = cacheFile(root, hash);
   if (!(0, import_node_fs4.existsSync)(file)) return void 0;
-  const bytes = (0, import_node_fs4.readFileSync)(file);
-  if (sha256(bytes) !== hash) throw remoteError.altered(spec);
-  return bytes;
+  const bytes2 = (0, import_node_fs4.readFileSync)(file);
+  if (sha256(bytes2) !== hash) throw remoteError.altered(spec);
+  return bytes2;
 }
-function writeCached(root, bytes) {
-  const hash = sha256(bytes);
+function writeCached(root, bytes2) {
+  const hash = sha256(bytes2);
   const dir = (0, import_node_path5.join)(root, CACHE_DIR);
   (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
   const tmp = (0, import_node_path5.join)(dir, `${hash}.${process.pid}.tmp`);
-  (0, import_node_fs4.writeFileSync)(tmp, bytes);
+  (0, import_node_fs4.writeFileSync)(tmp, bytes2);
   (0, import_node_fs4.renameSync)(tmp, cacheFile(root, hash));
   return hash;
 }
@@ -21173,9 +21400,9 @@ function fileResolver({ entry, read = () => void 0, toPath = (p) => p, remote }
     if (!lock) throw remoteError.noLock(spec);
     const hash = lockedHash(lock, spec);
     if (!hash) throw remoteError.notLocked(spec);
-    const bytes = readCached(root, hash, spec);
-    if (!bytes) throw remoteError.notCached(spec);
-    return bytes.toString("utf8");
+    const bytes2 = readCached(root, hash, spec);
+    if (!bytes2) throw remoteError.notCached(spec);
+    return bytes2.toString("utf8");
   };
   const loadRemote = remote ?? fromCache;
   const found = (path, source2, level) => {
@@ -21301,9 +21528,9 @@ function scalar(text, line, inFlow) {
   return text;
 }
 function stringItem(text, line, inFlow) {
-  const value = scalar(text, line, inFlow);
-  if (typeof value !== "string") throw new FrontMatterError(`List items must be strings; quote ${text}`, line);
-  return value;
+  const value2 = scalar(text, line, inFlow);
+  if (typeof value2 !== "string") throw new FrontMatterError(`List items must be strings; quote ${text}`, line);
+  return value2;
 }
 function flowItems(inner, line) {
   const items = [];
@@ -21346,9 +21573,9 @@ function parseFrontMatter(text) {
     const item = raw.match(/^ +- (.*)$/) ?? raw.match(/^ +-()$/);
     if (item) {
       if (!list) throw new FrontMatterError('A list item must follow a key with no value, e.g. "hints:"', line);
-      const value2 = item[1].trim();
-      if (value2 === "") throw new FrontMatterError("Empty list item", line);
-      list.items.push(stringItem(value2, line, false));
+      const value3 = item[1].trim();
+      if (value3 === "") throw new FrontMatterError("Empty list item", line);
+      list.items.push(stringItem(value3, line, false));
       continue;
     }
     if (/^\s/.test(raw)) throw new FrontMatterError(`Unexpected indented line: ${raw.trim()}`, line);
@@ -21357,19 +21584,19 @@ function parseFrontMatter(text) {
     if (!m) throw new FrontMatterError(`Expected "key: value", got: ${raw}`, line);
     const [, key, rest] = m;
     if (Object.prototype.hasOwnProperty.call(data, key)) throw new FrontMatterError(`Duplicate key '${key}'`, line);
-    const value = (rest ?? "").trim();
-    if (value === "") {
+    const value2 = (rest ?? "").trim();
+    if (value2 === "") {
       list = { key, items: [] };
       data[key] = list.items;
-    } else if (value.startsWith("[")) {
-      if (!value.endsWith("]")) throw new FrontMatterError(`A list must close on the same line: ${value}`, line);
-      data[key] = flowItems(value.slice(1, -1), line);
+    } else if (value2.startsWith("[")) {
+      if (!value2.endsWith("]")) throw new FrontMatterError(`A list must close on the same line: ${value2}`, line);
+      data[key] = flowItems(value2.slice(1, -1), line);
     } else {
-      data[key] = scalar(value, line, false);
+      data[key] = scalar(value2, line, false);
     }
   }
-  for (const [key, value] of Object.entries(data)) {
-    if (Array.isArray(value) && value.length === 0) {
+  for (const [key, value2] of Object.entries(data)) {
+    if (Array.isArray(value2) && value2.length === 0) {
       const line = lines.findIndex((l, i) => i > 0 && i < end && l.startsWith(`${key}:`)) + 1;
       throw new FrontMatterError(`'${key}' has no value`, line);
     }
@@ -21444,11 +21671,11 @@ function readMistake(source2) {
     const m = FIELD_LINE.exec(lines[i]);
     if (!m) continue;
     const field = m[1];
-    const value = m[2];
-    if (value === "") issues.push({ message: `"# ${field}:" is empty`, line: i + 1 });
-    if (field === "explain") values.explain = values.explain ? `${values.explain} ${value}` : value;
+    const value2 = m[2];
+    if (value2 === "") issues.push({ message: `"# ${field}:" is empty`, line: i + 1 });
+    if (field === "explain") values.explain = values.explain ? `${values.explain} ${value2}` : value2;
     else if (values[field] !== void 0) issues.push({ message: `"# ${field}:" appears twice`, line: i + 1 });
-    else values[field] = value;
+    else values[field] = value2;
   }
   if (values.mistake === void 0) return { issues };
   const cards = (values.cards ?? "").split(",").map((c) => c.trim()).filter(Boolean);
@@ -21929,8 +22156,8 @@ function readSelector(text) {
 }
 function parseGuided(text) {
   const issues = [];
-  const steps2 = [];
-  if (!text.trim()) return { steps: steps2, issues: [{ message: "The walkthrough is empty" }] };
+  const steps3 = [];
+  if (!text.trim()) return { steps: steps3, issues: [{ message: "The walkthrough is empty" }] };
   const { preamble, parts } = splitAt(numberedLines(text), 2);
   if (hasText(preamble)) issues.push({ message: 'Each step is a "## " heading; nothing goes before the first one', line: preamble.find((l) => l.text.trim())?.line });
   for (const part of parts) {
@@ -21964,11 +22191,11 @@ function parseGuided(text) {
     }
     if (meta.size === 0) bad(item.line, "a step needs at least one check (- node, - edge, - usecase, - replicas or - test)");
     if (!item.body) bad(item.line, "write what to do and why under the checks");
-    steps2.push({ title: item.title, explanation: item.body, checks });
+    steps3.push({ title: item.title, explanation: item.body, checks });
   }
-  if (steps2.length < MIN_STEPS) issues.push({ message: `At least ${MIN_STEPS} steps (there are ${steps2.length})` });
-  if (steps2.length > MAX_STEPS) issues.push({ message: `At most ${MAX_STEPS} steps (there are ${steps2.length})` });
-  return { steps: steps2, issues };
+  if (steps3.length < MIN_STEPS) issues.push({ message: `At least ${MIN_STEPS} steps (there are ${steps3.length})` });
+  if (steps3.length > MAX_STEPS) issues.push({ message: `At most ${MAX_STEPS} steps (there are ${steps3.length})` });
+  return { steps: steps3, issues };
 }
 function matches2(node, s) {
   return "id" in s ? node.id === s.id : kindMatches(kindOf(node), s.kind);
@@ -22032,12 +22259,12 @@ function evaluateChecks(checks, diagram, tests) {
   });
 }
 function guidedIssues(text, solution, solutionTests) {
-  const { steps: steps2, issues } = parseGuided(text);
+  const { steps: steps3, issues } = parseGuided(text);
   const ids = new Set(solution.nodes.map((n) => n.id));
   const testNames = new Set((solutionTests ?? []).map((r) => r.name));
   const lines = text.split("\n");
   const lineOf3 = (title) => lines.findIndex((l) => /^##\s/.test(l) && l.includes(title)) + 1 || void 0;
-  for (const step of steps2) {
+  for (const step of steps3) {
     const line = lineOf3(step.title);
     for (const c of step.checks) {
       const selectors = c.type === "edge" ? [c.from, c.to] : c.type === "node" || c.type === "replicas" ? [c.node] : [];
@@ -22307,8 +22534,8 @@ function parseNumber(text) {
     if (!Object.prototype.hasOwnProperty.call(SUFFIX, suffix)) return void 0;
     factor = SUFFIX[suffix];
   }
-  const value = Number(digits.replace(/[, _]/g, "")) * 10 ** Number(exponent ?? 0) * factor * (sign === "-" ? -1 : 1);
-  return Number.isFinite(value) ? value : void 0;
+  const value2 = Number(digits.replace(/[, _]/g, "")) * 10 ** Number(exponent ?? 0) * factor * (sign === "-" ? -1 : 1);
+  return Number.isFinite(value2) ? value2 : void 0;
 }
 function hashText(text) {
   let h = 2166136261;
@@ -22798,12 +23025,12 @@ function problemCheck(args, out, err, cwd) {
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === "--format") {
-      const value = args[++i];
-      if (value !== "text" && value !== "github" && value !== "json") {
-        err(`Unknown format '${value ?? ""}'; use text, github or json`);
+      const value2 = args[++i];
+      if (value2 !== "text" && value2 !== "github" && value2 !== "json") {
+        err(`Unknown format '${value2 ?? ""}'; use text, github or json`);
         return 2;
       }
-      style = value;
+      style = value2;
     } else if (arg.startsWith("-")) {
       err(`Unknown option ${arg}
 
@@ -23089,12 +23316,12 @@ function parseArgs2(args, err, allowFormat) {
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (allowFormat && arg === "--format") {
-      const value = args[++i];
-      if (value !== "text" && value !== "github" && value !== "json") {
-        err(`Unknown format '${value ?? ""}'; use text, github or json`);
+      const value2 = args[++i];
+      if (value2 !== "text" && value2 !== "github" && value2 !== "json") {
+        err(`Unknown format '${value2 ?? ""}'; use text, github or json`);
         return void 0;
       }
-      parsed.style = value;
+      parsed.style = value2;
     } else if (allowFormat && arg === "--problems") {
       parsed.problems = args[++i];
       if (!parsed.problems) {
@@ -23416,19 +23643,19 @@ function parseArgs3(args, err) {
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === "--format") {
-      const value = args[++i];
-      if (value !== "text" && value !== "github" && value !== "json") {
-        err(`Unknown format '${value ?? ""}'; use text, github or json`);
+      const value2 = args[++i];
+      if (value2 !== "text" && value2 !== "github" && value2 !== "json") {
+        err(`Unknown format '${value2 ?? ""}'; use text, github or json`);
         return void 0;
       }
-      parsed.style = value;
+      parsed.style = value2;
     } else if (arg === "--problems" || arg === "--cards") {
-      const value = args[++i];
-      if (!value) {
+      const value2 = args[++i];
+      if (!value2) {
         err(`Expected a directory after ${arg}`);
         return void 0;
       }
-      parsed[arg === "--problems" ? "problems" : "cards"] = value;
+      parsed[arg === "--problems" ? "problems" : "cards"] = value2;
     } else if (arg.startsWith("-")) {
       err(`Unknown option ${arg}
 
@@ -23671,26 +23898,26 @@ function compile(scenario, board, components2, useCases, situation = CALM, optio
   if (situation.bots) {
     const chain = chainTo(() => true) ?? [board.nodes.find((n) => n.component === USERS)?.id ?? USERS];
     const stop = chain.findIndex((id) => roleOf2(id) === "waf" || roleOf2(id) === "gateway");
-    const steps2 = [];
+    const steps3 = [];
     const path = stop >= 0 ? chain.slice(0, stop + 1) : chain;
-    for (let i = 0; i + 1 < path.length; i++) steps2.push(`  ${path[i]} -> ${path[i + 1]} : GET /random-${i}`);
+    for (let i = 0; i + 1 < path.length; i++) steps3.push(`  ${path[i]} -> ${path[i + 1]} : GET /random-${i}`);
     const last = path[path.length - 1];
     if (stop < 0 && roleOf2(last) === "app") {
       const db = wired(last, "db");
-      if (db) steps2.push(`  ${last} -> ${db} : SELECT random key`, `  ${db} --> ${last} : nothing`);
+      if (db) steps3.push(`  ${last} -> ${db} : SELECT random key`, `  ${db} --> ${last} : nothing`);
     }
     const status = stop >= 0 ? roleOf2(path[stop]) === "waf" ? 403 : 429 : 404;
-    for (let i = path.length - 1; i > 0; i--) steps2.push(`  ${path[i]} --> ${path[i - 1]} : ${status}`);
-    if (steps2.length) bodies.push(`usecase ${quote4(BOTS)} "Scrapers and credential stuffers" {`, ...steps2, "}", "");
+    for (let i = path.length - 1; i > 0; i--) steps3.push(`  ${path[i]} --> ${path[i - 1]} : ${status}`);
+    if (steps3.length) bodies.push(`usecase ${quote4(BOTS)} "Scrapers and credential stuffers" {`, ...steps3, "}", "");
     bots = { stoppedBy: stop >= 0 ? path[stop] : void 0, chain: path };
   }
   function routeUseCase(key, uc, chain, handler) {
-    const steps2 = uc.steps;
+    const steps3 = uc.steps;
     const queue = wired(handler, "queue");
     const worker = queue ? wired(queue, "worker", true) : void 0;
     const viaWorker = (s) => !!(s.async && queue && worker);
     const targets2 = [];
-    for (const s of steps2) {
+    for (const s of steps3) {
       const from = viaWorker(s) ? worker : handler;
       const target = s.op === "call" ? wiredTo(from, s.to) ? s.to : void 0 : wired(from, s.to);
       if (!target) {
@@ -23706,9 +23933,9 @@ function compile(scenario, board, components2, useCases, situation = CALM, optio
     const cacheNode = uc.cache !== void 0 && !uc.strong ? wired(handler, "cache", true) : void 0;
     const cacheable = (s) => s.op === "read" && s.to !== "blob" && !viaWorker(s);
     const direct = (s) => !!options.presigned && s.op === "write" && s.to === "blob" && !viaWorker(s);
-    const directUpload = steps2.some(direct);
+    const directUpload = steps3.some(direct);
     const chainSize = directUpload ? "" : sizeLabel(uc.size, options.payload);
-    const usesCache = cacheNode !== void 0 && steps2.some(cacheable);
+    const usesCache = cacheNode !== void 0 && steps3.some(cacheable);
     const cacheStates = !usesCache ? ["none"] : down.has(cacheNode) ? ["down"] : ["hit", "miss", "down"];
     const regions = situation.global ? [false, true] : [false];
     const plans = [];
@@ -23724,8 +23951,8 @@ function compile(scenario, board, components2, useCases, situation = CALM, optio
       const verb = s.op === "call" ? "SEND" : STORE_VERB[s.to]?.[write ? 1 : 0] ?? (write ? "WRITE" : "GET");
       return `${prefix ? `${prefix} ` : ""}${verb} ${s.entity ?? (s.op === "call" ? "message" : "data")}`;
     };
-    const cacheKey = steps2.find(cacheable)?.entity ?? "item";
-    const hasBackground = steps2.some(viaWorker);
+    const cacheKey = steps3.find(cacheable)?.entity ?? "item";
+    const hasBackground = steps3.some(viaWorker);
     const scenarioText = (p) => {
       const t = [];
       const path = p.edge === "hit" ? chain.slice(0, chain.indexOf(cdn) + 1) : chain;
@@ -23739,7 +23966,7 @@ function compile(scenario, board, components2, useCases, situation = CALM, optio
         if (p.cache === "hit") t.push(`${handler} -> ${cacheNode} : GET ${cacheKey}`, `${cacheNode} --> ${handler} : hit`);
         else if (p.cache === "miss") t.push(`${handler} -> ${cacheNode} : GET ${cacheKey}`, `${cacheNode} --> ${handler} : miss`);
         else if (p.cache === "down") t.push(`${handler} -x ${cacheNode} : GET ${cacheKey}`);
-        steps2.forEach((s, i) => {
+        steps3.forEach((s, i) => {
           if (viaWorker(s)) return;
           if (p.cache === "hit" && cacheable(s)) return;
           const write = s.op !== "read";
@@ -23749,7 +23976,7 @@ function compile(scenario, board, components2, useCases, situation = CALM, optio
         if (hasBackground) t.push(`${handler} ->> ${queue} : ENQUEUE ${uc.name.replace(/[^A-Za-z0-9 ]/g, "")}`);
       }
       for (let i = hops.length - 1; i > 0; i--) t.push(`${hops[i]} --> ${hops[i - 1]} : ${uc.status}`);
-      if (p.edge !== "hit") steps2.forEach((s, i) => {
+      if (p.edge !== "hit") steps3.forEach((s, i) => {
         if (direct(s)) t.push(`${hops[0]} -> ${targets2[i]} : ${sizeLabel(s.size ?? uc.size, options.payload)} PUT ${s.entity ?? "file"}`, `${targets2[i]} --> ${hops[0]} : 200`);
       });
       return t;
@@ -23766,13 +23993,13 @@ function compile(scenario, board, components2, useCases, situation = CALM, optio
     text.push("}", "");
     let background;
     if (hasBackground) {
-      const stalled = down.has(worker) || steps2.some((s, i) => viaWorker(s) && (down.has(targets2[i]) || s.op === "write" && writesDown.has(targets2[i])));
+      const stalled = down.has(worker) || steps3.some((s, i) => viaWorker(s) && (down.has(targets2[i]) || s.op === "write" && writesDown.has(targets2[i])));
       const batching = options.writeShare < 1;
       const bgName = `${uc.name} (background)`;
       const bgScenarios = batching ? [{ name: "Write", writes: true }, { name: "Buffer", writes: false }] : [{ name: "Write", writes: true }];
       const bgText = (writes) => {
         const t = [`${queue} -> ${worker} : job`];
-        steps2.forEach((s, i) => {
+        steps3.forEach((s, i) => {
           if (!viaWorker(s)) return;
           if (!writes && s.op === "write") return;
           const write = s.op !== "read";
@@ -24230,7 +24457,7 @@ function eventFromFile(file, text) {
   const requires = f.list("requires");
   for (const r of requires) if (!ROLES.includes(r)) throw new ContentError(file, `"requires:" lists component roles (${ROLES.join(", ")}), not ${r}`);
   const target = f.optionalString("target");
-  const value = f.optionalNumber("value");
+  const value2 = f.optionalNumber("value");
   const from = f.optionalNumber("from");
   const then = f.optionalString("then");
   return {
@@ -24242,7 +24469,7 @@ function eventFromFile(file, text) {
     learn: f.list("learn"),
     effect: f.oneOf("effect", EVENT_EFFECTS),
     ...target !== void 0 ? { target } : {},
-    ...value !== void 0 ? { value } : {},
+    ...value2 !== void 0 ? { value: value2 } : {},
     ...values.length ? { values } : {},
     duration: f.number("duration", 1),
     ...from !== void 0 ? { from } : {},
@@ -24623,14 +24850,14 @@ function indexOf(content) {
 function mergeRequirements(current, added) {
   const out = [...current];
   for (const line of added) {
-    const key = requirementKey(line);
-    const at = out.findIndex((l) => requirementKey(l) === key);
+    const key = requirementKey2(line);
+    const at = out.findIndex((l) => requirementKey2(l) === key);
     if (at >= 0) out[at] = line;
     else out.push(line);
   }
   return out;
 }
-function requirementKey(line) {
+function requirementKey2(line) {
   const t = line.trim();
   const uc = /"([^"]*)"/.exec(t)?.[1] ?? "";
   const head = /^(p\d+(?:\.\d+)?|availability|durable|survive|cost)/.exec(t)?.[1] ?? t;
@@ -26164,9 +26391,9 @@ var Game = class _Game {
     const jobs = [];
     for (const m of this.mode.mechanics) m.shapeUseCases?.(this, useCases, jobs);
     const served = [...s.useCases.filter((k) => this.mode.mechanics.every((m) => m.serves?.(this, k) ?? true)), ...jobs.map((j) => j.key)];
-    const value = { useCases, served, jobs };
-    this.effectiveCache = { key, value };
-    return value;
+    const value2 = { useCases, served, jobs };
+    this.effectiveCache = { key, value: value2 };
+    return value2;
   }
   /** @internal The board compiled to a diagram for a situation, cached. */
   compileFor(board, situation) {
@@ -26698,26 +26925,26 @@ function parseArgs4(args, err) {
   const a = { style: "text", positional: [] };
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
-    const value = () => {
+    const value2 = () => {
       const v = args[++i];
       if (v === void 0) err(`Expected a value after ${arg}`);
       return v;
     };
     if (arg === "--format") {
-      const v = value();
+      const v = value2();
       if (v !== "text" && v !== "github" && v !== "json") {
         err(`Unknown format '${v ?? ""}'; use text, github or json`);
         return void 0;
       }
       a.style = v;
     } else if (arg === "--run") {
-      a.run = value();
+      a.run = value2();
       if (a.run === void 0) return void 0;
     } else if (arg === "--seed") {
-      a.seed = value();
+      a.seed = value2();
       if (a.seed === void 0) return void 0;
     } else if (arg === "--ascension") {
-      const v = Number(value());
+      const v = Number(value2());
       if (!Number.isInteger(v) || v < 0) {
         err("--ascension takes a whole number from 0");
         return void 0;
@@ -26931,12 +27158,12 @@ function runShareLink(args, out, err) {
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === "--base") {
-      const value = args[++i];
-      if (!value || !/^https?:\/\//.test(value)) {
-        err(`Expected --base <http(s) url>, got '${value ?? ""}'`);
+      const value2 = args[++i];
+      if (!value2 || !/^https?:\/\//.test(value2)) {
+        err(`Expected --base <http(s) url>, got '${value2 ?? ""}'`);
         return 2;
       }
-      base = value;
+      base = value2;
     } else if (arg.startsWith("-")) {
       err(`Unknown option ${arg}
 
@@ -26997,8 +27224,8 @@ function readFrontMatter(block) {
   }
   block.lines = block.lines.slice(close + 1);
 }
-function unquoteYaml(value) {
-  const v = value.trim();
+function unquoteYaml(value2) {
+  const v = value2.trim();
   if (v.startsWith('"')) {
     try {
       return String(JSON.parse(v));
@@ -27393,12 +27620,12 @@ function readSequence(block, b, start, index) {
     b.warn(line, `Could not read '${statement}'; left out`);
   }
   const name = title || block.title || (index === 0 ? "Sequence" : `Sequence ${index + 1}`);
-  const steps2 = new SequenceConverter(b).convert(root, false);
-  if (!steps2.some(hasStep)) {
+  const steps3 = new SequenceConverter(b).convert(root, false);
+  if (!steps3.some(hasStep)) {
     b.warn(block.lines[start]?.line, `Sequence diagram '${name}' has no messages; left out`);
     return;
   }
-  b.design.useCases.push({ name, steps: steps2, ...scenario ? { scenario } : {} });
+  b.design.useCases.push({ name, steps: steps3, ...scenario ? { scenario } : {} });
 }
 var hasStep = (s) => s.kind === "step" || (s.kind === "par" ? s.steps.some(hasStep) : s.branches.some((br) => br.steps.some(hasStep)));
 var SequenceConverter = class {
@@ -27427,14 +27654,14 @@ var SequenceConverter = class {
           for (const br of branches) out.push(...this.convert(br.items, true));
           continue;
         }
-        const steps2 = branches.flatMap((br) => {
+        const steps3 = branches.flatMap((br) => {
           const converted = this.convert(br.items, true);
           if (converted.filter((s) => s.kind === "step" && s.arrow !== "-->").length > 1) {
             this.b.warn(line, `A par branch${br.label ? ` ('${br.label}')` : ""} makes several calls; Proschi runs every step of a par block in parallel`);
           }
           return converted;
         });
-        if (steps2.length) out.push({ kind: "par", steps: steps2 });
+        if (steps3.length) out.push({ kind: "par", steps: steps3 });
       } else {
         if (inPar) {
           this.b.warn(line, `${type} inside par: only its first branch is imported`);
@@ -27479,27 +27706,27 @@ var SequenceConverter = class {
 function mergeScenarios(useCases) {
   const out = [];
   const alts = /* @__PURE__ */ new Map();
-  const branch = (scenario, steps2) => ({ name: scenario.name, ...scenario.when ? { when: scenario.when } : {}, steps: steps2 });
-  for (const { name, description, steps: steps2, scenario } of useCases) {
+  const branch = (scenario, steps3) => ({ name: scenario.name, ...scenario.when ? { when: scenario.when } : {}, steps: steps3 });
+  for (const { name, description, steps: steps3, scenario } of useCases) {
     const alt = scenario && alts.get(name);
     if (alt) {
       let branchName = scenario.name;
       for (let n = 2; alt.branches.some((br) => br.name === branchName); n++) branchName = `${scenario.name} ${n}`;
-      alt.branches.push(branch({ ...scenario, name: branchName }, steps2));
+      alt.branches.push(branch({ ...scenario, name: branchName }, steps3));
       continue;
     }
     if (scenario && !alts.has(name) && useCases.filter((u) => u.name === name && u.scenario).length > 1) {
-      const created = { kind: "alt", branches: [branch(scenario, steps2)] };
+      const created = { kind: "alt", branches: [branch(scenario, steps3)] };
       alts.set(name, created);
       out.push({ name, ...description ? { description } : {}, steps: [created] });
       continue;
     }
-    out.push({ name, ...description ? { description } : {}, steps: steps2 });
+    out.push({ name, ...description ? { description } : {}, steps: steps3 });
   }
   return out;
 }
-function connectSteps(b, steps2) {
-  for (const step of steps2) {
+function connectSteps(b, steps3) {
+  for (const step of steps3) {
     if (step.kind === "par") connectSteps(b, step.steps);
     else if (step.kind === "alt") step.branches.forEach((br) => connectSteps(b, br.steps));
     else if (step.arrow !== "-->" && step.from !== step.to && !b.connected(step.from, step.to)) b.edge(step.from, step.to, void 0);
@@ -27579,13 +27806,327 @@ ${IMPORT_USAGE}`);
 }
 
 // src/sync.ts
-var import_node_fs13 = require("node:fs");
+var import_node_fs14 = require("node:fs");
 
-// src/fetchers.ts
-var import_node_child_process = require("node:child_process");
+// src/credentials.ts
 var import_node_fs12 = require("node:fs");
 var import_node_os = require("node:os");
 var import_node_path12 = require("node:path");
+var DEFAULT_SITE = "https://proschi.app";
+function credentialsPath(env = process.env, platform = process.platform, home = (0, import_node_os.homedir)()) {
+  if (platform === "win32") return (0, import_node_path12.join)(env.APPDATA || (0, import_node_path12.join)(home, "AppData", "Roaming"), "proschi", "credentials.json");
+  const config = env.XDG_CONFIG_HOME && env.XDG_CONFIG_HOME.startsWith("/") ? env.XDG_CONFIG_HOME : (0, import_node_path12.join)(home, ".config");
+  return (0, import_node_path12.join)(config, "proschi", "credentials.json");
+}
+function normalizeBase(value2) {
+  let url;
+  try {
+    url = new URL(value2);
+  } catch {
+    throw new Error(`'${value2}' is not a URL; use e.g. ${DEFAULT_SITE}`);
+  }
+  const local = url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "[::1]";
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && local)) {
+    throw new Error(`'${value2}' is not https; only https:// sites (or http://localhost and http://127.0.0.1 for development) are allowed`);
+  }
+  if (url.username || url.password || url.search || url.hash || url.pathname !== "/" && url.pathname !== "") {
+    throw new Error(`'${value2}' must be the site's address only, like ${DEFAULT_SITE}`);
+  }
+  return url.origin;
+}
+var isSession = (v) => !!v && typeof v === "object" && typeof v.accessToken === "string" && typeof v.refreshToken === "string" && typeof v.expiresAt === "number";
+var CredentialStore = class {
+  constructor(file = credentialsPath()) {
+    this.file = file;
+  }
+  file;
+  read() {
+    if (!(0, import_node_fs12.existsSync)(this.file)) return { version: 1, sessions: {} };
+    let json2;
+    try {
+      json2 = JSON.parse((0, import_node_fs12.readFileSync)(this.file, "utf8"));
+    } catch {
+      throw new Error(`${this.file} is not valid JSON; delete it and run proschi login`);
+    }
+    const sessions = {};
+    const stored = json2?.sessions;
+    if (stored && typeof stored === "object") {
+      for (const [base, s] of Object.entries(stored)) if (isSession(s)) sessions[base] = s;
+    }
+    return { version: 1, sessions };
+  }
+  /** Writes the file with mode 0600 through a temp file in the same folder, so a reader never sees half a file. */
+  write(data) {
+    const dir = (0, import_node_path12.dirname)(this.file);
+    (0, import_node_fs12.mkdirSync)(dir, { recursive: true, mode: 448 });
+    const tmp = `${this.file}.${process.pid}.${Date.now()}.tmp`;
+    const fd = (0, import_node_fs12.openSync)(tmp, "wx", 384);
+    try {
+      (0, import_node_fs12.writeSync)(fd, JSON.stringify(data, null, 2) + "\n");
+    } finally {
+      (0, import_node_fs12.closeSync)(fd);
+    }
+    if (process.platform !== "win32") (0, import_node_fs12.chmodSync)(tmp, 384);
+    (0, import_node_fs12.renameSync)(tmp, this.file);
+  }
+  get(base) {
+    return this.read().sessions[base];
+  }
+  set(base, session) {
+    const data = this.read();
+    data.sessions[base] = session;
+    this.write(data);
+  }
+  delete(base) {
+    const data = this.read();
+    if (!(base in data.sessions)) return;
+    delete data.sessions[base];
+    this.write(data);
+  }
+  /**
+   * Runs `fn` holding the lock file next to the credentials, so two
+   * processes never refresh with the same token. A lock older than
+   * `staleMs` (a crashed process) is taken over.
+   */
+  async locked(fn, { timeoutMs = 15e3, staleMs = 3e4 } = {}) {
+    const lock = `${this.file}.lock`;
+    (0, import_node_fs12.mkdirSync)((0, import_node_path12.dirname)(lock), { recursive: true, mode: 448 });
+    const start = Date.now();
+    for (; ; ) {
+      try {
+        (0, import_node_fs12.closeSync)((0, import_node_fs12.openSync)(lock, "wx", 384));
+        break;
+      } catch (e) {
+        if (e.code !== "EEXIST") throw e;
+        try {
+          if (Date.now() - (0, import_node_fs12.statSync)(lock).mtimeMs > staleMs) (0, import_node_fs12.rmSync)(lock, { force: true });
+        } catch {
+        }
+        if (Date.now() - start > timeoutMs) throw new Error(`Another proschi process holds ${lock}; try again, or delete it if none runs`);
+        await new Promise((r) => setTimeout(r, 50));
+      }
+    }
+    try {
+      return await fn();
+    } finally {
+      (0, import_node_fs12.rmSync)(lock, { force: true });
+    }
+  }
+};
+
+// src/api.ts
+var TIMEOUT_MS = 3e4;
+var MAX_RESPONSE_BYTES = 4e6;
+var EXPIRY_MARGIN_MS = 6e4;
+var NotSignedInError = class extends Error {
+  name = "NotSignedInError";
+};
+var ApiError = class extends Error {
+  constructor(message, status, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+  status;
+  code;
+  name = "ApiError";
+};
+async function readJson(response2) {
+  const reader = response2.body?.getReader();
+  const chunks = [];
+  let size = 0;
+  for (; ; ) {
+    const chunk = reader ? await reader.read() : { done: true, value: void 0 };
+    if (chunk.done) break;
+    size += chunk.value.byteLength;
+    if (size > MAX_RESPONSE_BYTES) {
+      await reader?.cancel();
+      throw new Error("The answer is too large");
+    }
+    chunks.push(chunk.value);
+  }
+  const text = Buffer.concat(chunks).toString("utf8");
+  if (!text) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(`The answer (HTTP ${response2.status}) is not JSON`);
+  }
+}
+async function send(fetchImpl, url, init = {}) {
+  try {
+    return await fetchImpl(url, { ...init, redirect: "error", signal: AbortSignal.timeout(TIMEOUT_MS) });
+  } catch (e) {
+    throw new Error(`Cannot reach ${new URL(url).origin}: ${e.message}`);
+  }
+}
+var messageOf = (body) => {
+  if (!body || typeof body !== "object") return {};
+  const { error, message, error_description } = body;
+  return {
+    code: typeof error === "string" ? error : void 0,
+    message: typeof message === "string" ? message.slice(0, 300) : typeof error_description === "string" ? error_description.slice(0, 300) : void 0
+  };
+};
+function sessionFrom(body, now = Date.now()) {
+  const b = body ?? {};
+  if (typeof b.access_token !== "string" || !b.access_token || typeof b.refresh_token !== "string" || !b.refresh_token) {
+    throw new Error("The sign-in answer has no tokens");
+  }
+  const expiresIn = typeof b.expires_in === "number" && b.expires_in > 0 ? b.expires_in : 3600;
+  return { accessToken: b.access_token, refreshToken: b.refresh_token, expiresAt: now + expiresIn * 1e3 };
+}
+async function requestTokens(fetchImpl, base, body) {
+  const response2 = await send(fetchImpl, `${base}/auth/token`, {
+    method: "POST",
+    headers: { "content-type": "application/json", accept: "application/json" },
+    body: JSON.stringify(body)
+  });
+  const json2 = await readJson(response2).catch(() => void 0);
+  if (!response2.ok) {
+    const { code, message } = messageOf(json2);
+    throw new ApiError(`Sign-in failed (HTTP ${response2.status}${code ? `, ${code}` : ""})${message ? `: ${message}` : ""}`, response2.status, code);
+  }
+  return sessionFrom(json2);
+}
+var ApiClient = class {
+  base;
+  store;
+  fetchImpl;
+  now;
+  constructor({ base, store = new CredentialStore(), fetch: fetchImpl = fetch, now = Date.now }) {
+    this.base = base;
+    this.store = store;
+    this.fetchImpl = fetchImpl;
+    this.now = now;
+  }
+  notSignedIn() {
+    return new NotSignedInError(`Not signed in to ${this.base}; run proschi login`);
+  }
+  /** Whether tokens are stored for the site (they may still have expired). */
+  signedIn() {
+    return this.store.get(this.base) !== void 0;
+  }
+  /**
+   * New tokens for the stored refresh token `used`, unless another process
+   * already refreshed it (then its tokens). An invalid refresh token ends
+   * the sign-in.
+   */
+  async refresh(used2) {
+    return this.store.locked(async () => {
+      const current = this.store.get(this.base);
+      if (!current) throw this.notSignedIn();
+      if (current.refreshToken !== used2.refreshToken) return current;
+      let next;
+      try {
+        next = await requestTokens(this.fetchImpl, this.base, { grant_type: "refresh_token", refresh_token: current.refreshToken });
+      } catch (e) {
+        if (e instanceof ApiError && (e.code === "invalid_grant" || e.status === 401)) {
+          this.store.delete(this.base);
+          throw new NotSignedInError(`The sign-in to ${this.base} has ended; run proschi login`);
+        }
+        throw e;
+      }
+      this.store.set(this.base, next);
+      return next;
+    });
+  }
+  /** GETs a JSON path of the API as the signed-in user; an ApiError for an error answer. */
+  async get(path) {
+    let session = this.store.get(this.base);
+    if (!session) throw this.notSignedIn();
+    if (session.expiresAt - EXPIRY_MARGIN_MS <= this.now()) session = await this.refresh(session);
+    for (let attempt = 0; ; attempt++) {
+      const response2 = await send(this.fetchImpl, `${this.base}${path}`, {
+        headers: { authorization: `Bearer ${session.accessToken}`, accept: "application/json" }
+      });
+      if (response2.status === 401 && attempt === 0) {
+        await response2.body?.cancel();
+        session = await this.refresh(session);
+        continue;
+      }
+      if (response2.status === 401) throw new NotSignedInError(`${this.base} refused the sign-in; run proschi login`);
+      const json2 = await readJson(response2).catch((e) => {
+        if (response2.ok) throw e;
+        return void 0;
+      });
+      if (!response2.ok) {
+        const { code, message } = messageOf(json2);
+        throw new ApiError(message ?? `HTTP ${response2.status}`, response2.status, code);
+      }
+      return json2;
+    }
+  }
+};
+
+// src/cloud.ts
+var import_node_crypto2 = require("node:crypto");
+function canonicalSha256(source2, imports) {
+  const pairs = Object.entries(imports ?? {}).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  return (0, import_node_crypto2.createHash)("sha256").update(JSON.stringify([source2, pairs]), "utf8").digest("hex");
+}
+function cloudName(name) {
+  if (name.includes(":") || name.includes("//")) throw new Error(`'${name}' is not a diagram name; write it without cloud: or a tag, e.g. orders`);
+  const spec = parseRemoteSpec(`cloud:${name}`);
+  if (spec?.kind !== "cloud") throw new Error(`'${name}' is not a diagram name`);
+  return spec;
+}
+var isRecord3 = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var HASH2 = /^[0-9a-f]{64}$/;
+async function resolveVersion(client, spec, tag) {
+  const where = `cloud:${spec.name}:${tag}`;
+  let body;
+  try {
+    body = await client.get(`/api/me/versions/resolve?name=${encodeURIComponent(cloudDocumentName(spec))}&tag=${encodeURIComponent(tag)}`);
+  } catch (e) {
+    if (e instanceof ApiError && e.status === 404) throw new Error(`'${where}': your account has no diagram ${cloudDocumentName(spec)} with ${tag === LATEST_TAG ? "a saved version" : `a version tagged ${tag}`}`);
+    if (e instanceof ApiError && e.code === "ambiguous_name") throw new Error(`'${where}': several of your diagrams are named ${cloudDocumentName(spec)}; rename one`);
+    if (e instanceof ApiError) throw new Error(`'${where}': ${e.message}`);
+    throw e;
+  }
+  const b = isRecord3(body) ? body : {};
+  const imports = b.imports ?? {};
+  const valid = typeof b.documentId === "string" && typeof b.name === "string" && typeof b.tag === "string" && VERSION_TAG.test(b.tag) && b.tag !== LATEST_TAG && (tag === LATEST_TAG || b.tag === tag) && Number.isSafeInteger(b.seq) && b.seq > 0 && typeof b.sha256 === "string" && HASH2.test(b.sha256) && typeof b.source === "string" && isRecord3(imports) && Object.entries(imports).every(([k, v]) => typeof v === "string" && isImportKey(k));
+  if (!valid) throw new Error(`'${where}': the versions API gave an answer that is not a version`);
+  const version = { ...b, imports };
+  if (canonicalSha256(version.source, version.imports) !== version.sha256) {
+    throw new Error(`'${where}': the content does not match its sha256 ${version.sha256.slice(0, 12)}; try again`);
+  }
+  return {
+    documentId: version.documentId,
+    name: version.name,
+    tag: version.tag,
+    seq: version.seq,
+    sha256: version.sha256,
+    source: version.source,
+    imports: version.imports
+  };
+}
+async function findDocument(client, spec) {
+  const body = await client.get("/api/me/documents");
+  const documents = isRecord3(body) && Array.isArray(body.documents) ? body.documents : [];
+  const wanted = cloudDocumentName(spec);
+  const matches3 = documents.filter(
+    (d) => isRecord3(d) && typeof d.id === "string" && !d.deletedAt && (d.name === spec.name || d.name === wanted)
+  );
+  if (matches3.length === 0) throw new Error(`Your account has no diagram named ${wanted}`);
+  if (matches3.length > 1) throw new Error(`Several of your diagrams are named ${wanted}; rename one`);
+  return { id: matches3[0].id, name: matches3[0].name };
+}
+async function listVersions(client, documentId) {
+  const body = await client.get(`/api/me/documents/${encodeURIComponent(documentId)}/versions`);
+  const list = isRecord3(body) && Array.isArray(body.versions) ? body.versions : void 0;
+  const ok = (v) => isRecord3(v) && typeof v.tag === "string" && Number.isSafeInteger(v.seq) && typeof v.createdAt === "number" && typeof v.size === "number" && typeof v.sha256 === "string";
+  if (!list || !list.every(ok)) throw new Error("The versions API gave an answer that is not a list of versions");
+  const limit = isRecord3(body) && typeof body.limit === "number" ? body.limit : void 0;
+  return { versions: list.map((v) => ({ tag: v.tag, seq: v.seq, note: typeof v.note === "string" ? v.note : null, createdAt: v.createdAt, size: v.size, sha256: v.sha256 })), limit };
+}
+
+// src/fetchers.ts
+var import_node_child_process = require("node:child_process");
+var import_node_fs13 = require("node:fs");
+var import_node_os2 = require("node:os");
+var import_node_path13 = require("node:path");
 var GIT_TIMEOUT_MS = 12e4;
 var HTTPS_TIMEOUT_MS = 3e4;
 var MAX_REDIRECTS = 5;
@@ -27612,11 +28153,11 @@ function gitEnv() {
   return env;
 }
 var GitScratch = class {
-  dir = (0, import_node_fs12.mkdtempSync)((0, import_node_path12.join)((0, import_node_os.tmpdir)(), "proschi-git-"));
-  repo = (0, import_node_path12.join)(this.dir, "repo.git");
-  noHooks = (0, import_node_path12.join)(this.dir, "no-hooks");
+  dir = (0, import_node_fs13.mkdtempSync)((0, import_node_path13.join)((0, import_node_os2.tmpdir)(), "proschi-git-"));
+  repo = (0, import_node_path13.join)(this.dir, "repo.git");
+  noHooks = (0, import_node_path13.join)(this.dir, "no-hooks");
   constructor() {
-    (0, import_node_fs12.mkdirSync)(this.noHooks);
+    (0, import_node_fs13.mkdirSync)(this.noHooks);
     this.git(["init", "--bare", "--quiet", this.repo], false);
   }
   git(args, inRepo = true, encoding = "utf8") {
@@ -27650,7 +28191,7 @@ var GitScratch = class {
     return this.git(["cat-file", "blob", oid], true, "buffer");
   }
   dispose() {
-    (0, import_node_fs12.rmSync)(this.dir, { recursive: true, force: true });
+    (0, import_node_fs13.rmSync)(this.dir, { recursive: true, force: true });
   }
 };
 async function fetchHttps(url, fetchImpl = fetch) {
@@ -27690,32 +28231,72 @@ async function fetchHttps(url, fetchImpl = fetch) {
 }
 
 // src/sync.ts
-var IMPORTS_USAGE = `  proschi imports sync [--frozen] [<file|dir>...]`;
+var IMPORTS_USAGE = `  proschi imports sync [--frozen | --update [<cloud:spec>...]] [--base <url>] [<file|dir>...]`;
 var IMPORTS_HELP = `imports sync
-        Downloads the git: and https:// imports of the files (default: the
-        current folder) into .proschi/cache and pins them in proschi.lock.
-        No other command uses the network. --frozen fails instead of
-        changing proschi.lock (for CI).`;
+        Downloads the git:, https:// and cloud: imports of the files (default:
+        the current folder) into .proschi/cache and pins them in proschi.lock:
+        a git ref to its commit, cloud:<name> (latest) or cloud:<name>:<tag>
+        to the version's tag, seq and sha256. A pinned import stays pinned;
+        --update moves the given cloud:<name> imports (default: all of them)
+        to their newest saved version (a concrete tag never moves). cloud:
+        sources need proschi login (--base: the site, default
+        ${DEFAULT_SITE}). No other command fetches imports. --frozen fails
+        instead of changing proschi.lock (for CI).`;
 var staleLock = (what) => new ImportError(`${LOCK_FILE} is out of date: ${what}; run proschi imports sync and commit ${LOCK_FILE}`);
-async function syncImports(entries2, { frozen = false, fetch: fetch2, gitUrl = defaultGitUrl } = {}) {
+async function syncImports(entries2, { frozen = false, update, fetch: fetch2, gitUrl = defaultGitUrl, api } = {}) {
+  const updated = {};
   const roots = [...new Set(entries2.map((e) => projectRoot(e)))];
   if (roots.length !== 1) {
     const errors2 = roots.length ? [`The files belong to different project roots (${roots.map((r) => displayPath3(r)).join(", ")}); sync each separately`] : ["No .proschi files to sync"];
-    return { root: roots[0] ?? "", lock: emptyLock(), errors: errors2, written: false };
+    return { root: roots[0] ?? "", lock: emptyLock(), errors: errors2, written: false, updated };
   }
   const [root] = roots;
   const lock = emptyLock();
+  const fail2 = (errors2) => ({ root, lock, errors: errors2, written: false, updated });
+  if (frozen && update) return fail2(["--update and --frozen cannot be used together"]);
+  let moving;
+  const asked = [];
+  if (update === true) moving = true;
+  else if (update) {
+    moving = /* @__PURE__ */ new Set();
+    for (const spec of update) {
+      let remote;
+      try {
+        remote = parseRemoteSpec(spec);
+      } catch (e) {
+        return fail2([e.message]);
+      }
+      if (remote?.kind !== "cloud" || remote.path !== void 0) return fail2([`--update takes cloud:<name> imports, not '${spec}'`]);
+      const key = cloudKey(remote.name, remote.tag);
+      asked.push(key);
+      if (remote.tag === LATEST_TAG) moving.add(key);
+    }
+  }
+  const moves = (key) => moving === true ? key.endsWith(`:${LATEST_TAG}`) : !!moving?.has(key);
   let old;
   try {
     old = readLock(root);
   } catch (e) {
-    return { root, lock, errors: [e.message], written: false };
+    return fail2([e.message]);
   }
-  if (frozen && !old) return { root, lock, errors: [`${LOCK_FILE} is missing; run proschi imports sync and commit it`], written: false };
+  if (frozen && !old) return fail2([`${LOCK_FILE} is missing; run proschi imports sync and commit it`]);
   const texts = /* @__PURE__ */ new Map();
   const failed = /* @__PURE__ */ new Map();
   const scratches = /* @__PURE__ */ new Map();
   const commits = /* @__PURE__ */ new Map();
+  const versions = /* @__PURE__ */ new Map();
+  const version = (spec, remote, tag) => {
+    const key = cloudKey(remote.name, tag);
+    if (!versions.has(key)) {
+      const client = api ??= new ApiClient({ base: DEFAULT_SITE });
+      const got = client.signedIn() ? resolveVersion(client, remote, tag).catch((e) => {
+        throw e instanceof ImportError ? e : new ImportError(e.message.startsWith("'cloud:") ? e.message : `'${spec}': ${e.message}`);
+      }) : Promise.reject(new ImportError(`'${spec}': cloud: sources need \`proschi login\``));
+      got.catch(() => void 0);
+      versions.set(key, got);
+    }
+    return versions.get(key);
+  };
   const obtain = async (spec) => {
     const remote = parseRemoteSpec(spec);
     const cached = (hash) => {
@@ -27726,25 +28307,50 @@ async function syncImports(entries2, { frozen = false, fetch: fetch2, gitUrl = d
       }
     };
     const changed = (pin) => new ImportError(`'${spec}' does not match its sha256 in ${LOCK_FILE} (${pin}); its content changed. If that is expected, delete its entry from ${LOCK_FILE} and sync again`);
+    if (remote.kind === "cloud") {
+      const key2 = cloudKey(remote.name, remote.tag);
+      const pinned = moves(key2) ? void 0 : old?.cloud[key2];
+      const pinnedHash2 = remote.path === void 0 ? pinned?.source : pinned?.files[remote.path];
+      if (frozen && !pinnedHash2) throw staleLock(`'${spec}' is not locked`);
+      let bytes3 = cached(pinnedHash2);
+      let at = pinned;
+      if (!bytes3) {
+        const got = await version(spec, remote, pinned?.tag ?? remote.tag);
+        if (pinned && (got.sha256 !== pinned.sha256 || got.seq !== pinned.seq)) {
+          throw changed(`version ${pinned.tag}, seq ${pinned.seq}, sha256 ${pinned.sha256.slice(0, 12)}`);
+        }
+        const text2 = remote.path === void 0 ? got.source : got.imports[remote.path];
+        if (text2 === void 0) throw new ImportError(`'${spec}': no file ${remote.path} is saved with cloud:${remote.name}:${got.tag}`);
+        bytes3 = Buffer.from(text2, "utf8");
+        if (pinnedHash2 && sha256(bytes3) !== pinnedHash2) throw changed(`version ${got.tag}`);
+        writeCached(root, bytes3);
+        at = { tag: got.tag, seq: got.seq, sha256: got.sha256, files: {} };
+        if (moves(key2)) updated[key2] = { from: old?.cloud[key2]?.tag, to: got.tag };
+      }
+      const entry = lock.cloud[key2] ??= { tag: at.tag, seq: at.seq, sha256: at.sha256, files: {} };
+      if (remote.path === void 0) entry.source = sha256(bytes3);
+      else entry.files[remote.path] = sha256(bytes3);
+      return bytes3;
+    }
     if (remote.kind === "https") {
       const pinned = old?.https[remote.url];
       if (frozen && !pinned) throw staleLock(`'${spec}' is not locked`);
-      let bytes2 = cached(pinned);
-      if (!bytes2) {
-        bytes2 = await fetchHttps(remote.url, fetch2);
-        if (pinned && sha256(bytes2) !== pinned) throw changed(`sha256 ${pinned.slice(0, 12)}`);
-        writeCached(root, bytes2);
+      let bytes3 = cached(pinned);
+      if (!bytes3) {
+        bytes3 = await fetchHttps(remote.url, fetch2);
+        if (pinned && sha256(bytes3) !== pinned) throw changed(`sha256 ${pinned.slice(0, 12)}`);
+        writeCached(root, bytes3);
       }
-      lock.https[remote.url] = sha256(bytes2);
-      return bytes2;
+      lock.https[remote.url] = sha256(bytes3);
+      return bytes3;
     }
     const key = gitKey(remote.repo, remote.ref);
     const pinnedEntry = old?.git[key];
     const pinnedHash = pinnedEntry?.files[remote.path];
     if (frozen && !pinnedHash) throw staleLock(`'${spec}' is not locked`);
-    let bytes = cached(pinnedHash);
+    let bytes2 = cached(pinnedHash);
     let commit = pinnedEntry?.commit;
-    if (!bytes) {
+    if (!bytes2) {
       let scratch = scratches.get(remote.repo);
       if (!scratch) scratches.set(remote.repo, scratch = new GitScratch());
       if (!commits.has(key)) {
@@ -27754,13 +28360,13 @@ async function syncImports(entries2, { frozen = false, fetch: fetch2, gitUrl = d
         commits.set(key, got);
       }
       commit = commits.get(key);
-      bytes = scratch.read(commit, remote.path, spec);
-      if (pinnedHash && sha256(bytes) !== pinnedHash) throw changed(`commit ${commit.slice(0, 12)}`);
-      writeCached(root, bytes);
+      bytes2 = scratch.read(commit, remote.path, spec);
+      if (pinnedHash && sha256(bytes2) !== pinnedHash) throw changed(`commit ${commit.slice(0, 12)}`);
+      writeCached(root, bytes2);
     }
     lock.git[key] ??= { commit, files: {} };
-    lock.git[key].files[remote.path] = sha256(bytes);
-    return bytes;
+    lock.git[key].files[remote.path] = sha256(bytes2);
+    return bytes2;
   };
   let errors = [];
   try {
@@ -27776,7 +28382,7 @@ async function syncImports(entries2, { frozen = false, fetch: fetch2, gitUrl = d
             return void 0;
           }
         });
-        parse((0, import_node_fs13.readFileSync)(entry, "utf8"), { path: entry, resolve: resolver });
+        parse((0, import_node_fs14.readFileSync)(entry, "utf8"), { path: entry, resolve: resolver });
         for (const [where, message] of resolver.errors) {
           const from = where.split("\0")[0] || entry;
           found.add(`${isRemoteSpec(from) ? from : displayPath3(from)}: ${message}`);
@@ -27799,15 +28405,18 @@ async function syncImports(entries2, { frozen = false, fetch: fetch2, gitUrl = d
     for (const scratch of scratches.values()) scratch.dispose();
   }
   errors.push(...failed.values());
-  if (errors.length) return { root, lock, errors, written: false };
+  for (const key of asked) if (!lock.cloud[key]) errors.push(`--update: 'cloud:${key}' is not imported by these files`);
+  if (errors.length) return fail2(errors);
   const text = formatLock(lock);
   if (old && text !== formatLock(old)) {
-    if (frozen) return { root, lock, errors: [staleLock("it locks imports that are no longer used").message], written: false };
+    if (frozen) return fail2([staleLock("it locks imports that are no longer used").message]);
   }
-  const write = !frozen && (old ? text !== formatLock(old) : Object.keys(lock.git).length + Object.keys(lock.https).length > 0);
+  const write = !frozen && (old ? text !== formatLock(old) : lockedSources(lock) > 0);
   if (write) writeLock(root, lock);
-  return { root, lock, errors, written: write };
+  return { root, lock, errors, written: write, updated };
 }
+var lockedSources = (lock) => Object.keys(lock.git).length + Object.keys(lock.https).length + Object.keys(lock.cloud).length;
+var lockedFiles = (lock) => Object.values(lock.git).reduce((n, g) => n + Object.keys(g.files).length, 0) + Object.keys(lock.https).length + Object.values(lock.cloud).reduce((n, c) => n + Object.keys(c.files).length + (c.source ? 1 : 0), 0);
 async function runImports(args, collectFiles2, out, err, options = {}) {
   const [sub, ...rest] = args;
   if (sub !== "sync") {
@@ -27816,10 +28425,22 @@ ${IMPORTS_USAGE}`);
     return 2;
   }
   let frozen = false;
+  let update;
+  let base;
   const paths = [];
-  for (const arg of rest) {
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
     if (arg === "--frozen") frozen = true;
-    else if (arg.startsWith("-")) {
+    else if (arg === "--update") update ??= true;
+    else if (update && arg.startsWith("cloud:")) update = [...update === true ? [] : update, arg];
+    else if (arg === "--base") {
+      try {
+        base = normalizeBase(rest[++i] ?? "");
+      } catch (e) {
+        err(e.message);
+        return 2;
+      }
+    } else if (arg.startsWith("-")) {
       err(`Unknown option ${arg}
 
 Usage:
@@ -27834,21 +28455,332 @@ ${IMPORTS_USAGE}`);
     err(String(e.message));
     return 2;
   }
-  const result = await syncImports(files, { ...options, frozen });
+  const api = options.api ?? (base ? new ApiClient({ base }) : void 0);
+  const result = await syncImports(files, { ...options, api, frozen, update });
   if (result.errors.length) {
     err(result.errors.map((e) => `error: ${e}`).join("\n"));
     return 1;
   }
-  const sources = Object.keys(result.lock.git).length + Object.keys(result.lock.https).length;
-  const filesLocked = Object.values(result.lock.git).reduce((n, g) => n + Object.keys(g.files).length, 0) + Object.keys(result.lock.https).length;
+  for (const [key, { from, to }] of Object.entries(result.updated)) out(from === to ? `cloud:${key}: ${to} (already the newest)` : `cloud:${key}: ${from ?? "(not pinned)"} -> ${to}`);
+  const sources = lockedSources(result.lock);
+  const filesLocked = lockedFiles(result.lock);
   const lockPath = displayPath3(`${result.root}/${LOCK_FILE}`);
-  if (!sources) out("No git: or https:// imports to sync");
+  if (!sources) out("No git:, https:// or cloud: imports to sync");
   else out(`${filesLocked} remote file(s) from ${sources} source(s) ${result.written ? "locked in" : "match"} ${lockPath}`);
   return 0;
 }
 
+// src/login.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_crypto3 = require("node:crypto");
+var import_node_http = require("node:http");
+var LOGIN_USAGE = `  proschi login [--provider github|google] [--base <url>]
+  proschi logout [--base <url>]
+  proschi whoami [--base <url>]`;
+var LOGIN_HELP = `login   Signs in to your Proschi account in the browser (the link is printed
+        too, for a machine without one) and stores the tokens in your user's
+        config folder (readable by you only). cloud: imports and proschi
+        versions need it. --base sets the site (default ${DEFAULT_SITE}).
+logout  Ends the sign-in and deletes its tokens.
+whoami  Prints the account you are signed in as.`;
+var PROVIDERS = ["github", "google"];
+var LOGIN_TIMEOUT_MS = 5 * 6e4;
+var base64url = (bytes2) => bytes2.toString("base64url");
+function openBrowser(url) {
+  const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["rundll32", ["url.dll,FileProtocolHandler", url]] : ["xdg-open", [url]];
+  return new Promise((resolve8, reject) => {
+    const child = (0, import_node_child_process2.execFile)(command, args, { timeout: 1e4, windowsHide: true }, (error) => error ? reject(error) : resolve8());
+    child.on("error", reject);
+  });
+}
+var page = (title, text) => `<!doctype html><html lang="en"><head><meta charset="utf-8"><title>${title}</title><meta name="viewport" content="width=device-width,initial-scale=1"><style>body{font:16px/1.5 system-ui,sans-serif;margin:0;min-height:100vh;display:grid;place-items:center;background:#f8fafc;color:#0f172a}main{max-width:28rem;padding:2rem;text-align:center}h1{font-size:1.25rem}@media(prefers-color-scheme:dark){body{background:#0f172a;color:#e2e8f0}}</style></head><body><main><h1>${title}</h1><p>${text}</p></main></body></html>`;
+var sameText = (a, b) => {
+  const x = Buffer.from(a);
+  const y = Buffer.from(b);
+  return x.length === y.length && (0, import_node_crypto3.timingSafeEqual)(x, y);
+};
+async function login({
+  base = DEFAULT_SITE,
+  provider = "github",
+  store = new CredentialStore(),
+  fetch: fetchImpl = fetch,
+  open = openBrowser,
+  print = () => void 0,
+  timeoutMs = LOGIN_TIMEOUT_MS
+} = {}) {
+  const verifier = base64url((0, import_node_crypto3.randomBytes)(32));
+  const challenge = base64url((0, import_node_crypto3.createHash)("sha256").update(verifier).digest());
+  const state = base64url((0, import_node_crypto3.randomBytes)(24));
+  let settle;
+  const callback = new Promise((resolve8, reject) => settle = { resolve: resolve8, reject });
+  let done = false;
+  const server = (0, import_node_http.createServer)((req, res) => {
+    const reply = (status, title, text) => {
+      res.writeHead(status, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store", "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'" });
+      res.end(page(title, text));
+    };
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    if (done || req.method !== "GET" || url.pathname !== "/callback") return reply(404, "Not found", "Nothing here.");
+    done = true;
+    const got = url.searchParams.get("state") ?? "";
+    const code = url.searchParams.get("code");
+    const error = url.searchParams.get("error");
+    if (!sameText(got, state)) {
+      reply(400, "Sign-in failed", "This sign-in did not come from the proschi login that is waiting. Run proschi login again.");
+      settle.reject(new Error("The sign-in answer does not match this login (state mismatch); run proschi login again"));
+    } else if (error || !code) {
+      reply(400, "Sign-in failed", error === "access_denied" ? "The sign-in was cancelled. You can close this tab." : "The sign-in did not finish. You can close this tab and try again.");
+      settle.reject(new Error(error === "access_denied" ? "The sign-in was cancelled" : `The sign-in failed${error ? ` (${error.replace(/[^\w-]/g, "").slice(0, 40)})` : ""}`));
+    } else {
+      reply(200, "Signed in to Proschi", "You can close this tab and return to the terminal.");
+      settle.resolve(code);
+    }
+  });
+  server.keepAliveTimeout = 1;
+  await new Promise((resolve8, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => resolve8());
+  });
+  const address = server.address();
+  const port = typeof address === "object" && address ? address.port : 0;
+  const redirectUri = `http://127.0.0.1:${port}/callback`;
+  const timer = setTimeout(() => settle.reject(new Error(`No sign-in within ${Math.round(timeoutMs / 6e4) || 1} minute(s); run proschi login again`)), timeoutMs);
+  try {
+    const start = new URL(`${base}/auth/${provider}/start`);
+    start.search = new URLSearchParams({ client: "proschi-cli", redirect_uri: redirectUri, code_challenge: challenge, code_challenge_method: "S256", state }).toString();
+    print(`Opening your browser to sign in to ${base}. If it does not open, visit:
+
+  ${start.href}
+`);
+    open(start.href).catch(() => print("Could not open a browser; open the link above."));
+    const code = await callback;
+    const session = await requestTokens(fetchImpl, base, { grant_type: "authorization_code", code, code_verifier: verifier, redirect_uri: redirectUri });
+    store.set(base, session);
+  } finally {
+    clearTimeout(timer);
+    server.closeAllConnections?.();
+    server.close();
+  }
+}
+async function logout({ base = DEFAULT_SITE, store = new CredentialStore(), fetch: fetchImpl = fetch } = {}) {
+  const session = store.get(base);
+  if (!session) return { signedIn: false, revoked: false };
+  let revoked = false;
+  try {
+    const response2 = await send(fetchImpl, `${base}/auth/revoke`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ token: session.refreshToken })
+    });
+    await response2.body?.cancel();
+    revoked = response2.ok;
+  } catch {
+  }
+  store.delete(base);
+  return { signedIn: true, revoked };
+}
+async function runAuth(command, args, out, err, deps = {}) {
+  let base = DEFAULT_SITE;
+  let provider = "github";
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--base") {
+      try {
+        base = normalizeBase(args[++i] ?? "");
+      } catch (e) {
+        err(e.message);
+        return 2;
+      }
+    } else if (arg === "--provider" && command === "login") {
+      const value2 = args[++i];
+      if (!PROVIDERS.includes(value2)) {
+        err(`Unknown provider '${value2 ?? ""}'; use ${PROVIDERS.join(" or ")}`);
+        return 2;
+      }
+      provider = value2;
+    } else {
+      err(`Unknown option ${arg}
+
+Usage:
+${LOGIN_USAGE}`);
+      return 2;
+    }
+  }
+  try {
+    if (command === "login") {
+      await login({ base, provider, ...deps, print: err });
+      out(`Signed in to ${base}`);
+      return 0;
+    }
+    if (command === "logout") {
+      const { signedIn, revoked } = await logout({ base, ...deps });
+      if (!signedIn) out(`Not signed in to ${base}`);
+      else out(revoked ? `Signed out of ${base}` : `Deleted the stored sign-in for ${base} (the site could not be reached to end it; it expires on its own)`);
+      return 0;
+    }
+    const me = await new ApiClient({ base, store: deps.store, fetch: deps.fetch }).get("/api/me");
+    const name = typeof me?.user?.displayName === "string" ? me.user.displayName : "an account without a name";
+    out(`Signed in to ${base} as ${name}`);
+    return 0;
+  } catch (e) {
+    err(`error: ${e.message}`);
+    return 1;
+  }
+}
+
+// src/versions.ts
+var VERSIONS_USAGE = `  proschi versions list [--json] [--base <url>] <name>
+  proschi versions diff [--json] [--base <url>] <name> <base-tag> [<target-tag>|<file.proschi>]`;
+var VERSIONS_HELP = `versions
+        Reads the saved versions of a diagram in your account (proschi login
+        first; <name> is its file name, with or without .proschi). list
+        prints them, newest first. diff prints what changed from <base-tag>
+        to <target-tag> (default: latest), or to a local file (a target
+        ending in .proschi or containing a /). --json prints the result for
+        scripts. Never changes proschi.lock or the cache.`;
+var SECTION_TITLES = {
+  nodes: "Nodes",
+  edges: "Edges",
+  useCases: "Use cases",
+  scenarios: "Scenarios",
+  requirements: "Requirements",
+  traffic: "Traffic",
+  capacity: "Capacity",
+  systems: "Systems"
+};
+function itemLabel(section2, item) {
+  switch (section2) {
+    case "edges": {
+      const e = item;
+      return `${e.source} -> ${e.target}${e.label ? ` : ${e.label}` : ""}`;
+    }
+    case "scenarios": {
+      const s = item;
+      return `${s.useCase}/${s.scenario.id}`;
+    }
+    case "requirements":
+      return requirementKey(item);
+    case "traffic":
+      return item.useCase;
+    case "capacity":
+      return item.node;
+    case "systems":
+      return item.id;
+    default:
+      return item.id;
+  }
+}
+var value = (v) => v === void 0 || v === null ? "(none)" : typeof v === "string" ? JSON.stringify(v) : typeof v === "object" ? JSON.stringify(v) : String(v);
+function changeLines({ field, before: before2, after: after2 }, indent2) {
+  const list = (v) => Array.isArray(v) && v.every((x) => typeof x === "string");
+  if ((list(before2) || before2 === void 0) && (list(after2) || after2 === void 0) && (before2 !== void 0 || after2 !== void 0)) {
+    const old = before2 ?? [];
+    const next = after2 ?? [];
+    const lines = [`${indent2}${field}:`];
+    for (const line of old) if (!next.includes(line)) lines.push(`${indent2}  - ${line}`);
+    for (const line of next) if (!old.includes(line)) lines.push(`${indent2}  + ${line}`);
+    if (lines.length === 1) lines.push(`${indent2}  (reordered)`);
+    return lines;
+  }
+  return [`${indent2}${field}: ${value(before2)} \u2192 ${value(after2)}`];
+}
+function formatDiff(diff, from, to) {
+  const lines = [`${from} \u2192 ${to}`, ""];
+  if (diff.diagram.length) {
+    lines.push("Diagram");
+    for (const c of diff.diagram) lines.push(...changeLines(c, "  ~ "));
+  }
+  for (const section2 of DIFF_SECTIONS) {
+    const { added, removed, changed } = diff[section2];
+    if (!added.length && !removed.length && !changed.length) continue;
+    lines.push(SECTION_TITLES[section2]);
+    for (const item of added) lines.push(`  + ${itemLabel(section2, item)}`);
+    for (const item of removed) lines.push(`  - ${itemLabel(section2, item)}`);
+    for (const item of changed) {
+      lines.push(`  ~ ${item.key}`);
+      for (const c of item.changes) lines.push(...changeLines(c, "      "));
+    }
+  }
+  const { total } = summarizeDiff(diff);
+  if (lines.length === 2) lines.push("No changes");
+  else lines.push("", `${total.added} added, ${total.removed} removed, ${total.changed} changed`);
+  return lines.join("\n");
+}
+var parseVersion = (v) => parse(v.source, { path: v.name, resolve: mapResolver(v.imports) });
+var date = (ms) => new Date(ms).toISOString().slice(0, 16).replace("T", " ");
+var bytes = (n) => n < 1024 ? `${n} B` : `${(n / 1024).toFixed(1)} KB`;
+function formatVersionList(name, versions, limit) {
+  const head = `${name}: ${versions.length} version${versions.length === 1 ? "" : "s"}${limit !== void 0 ? ` (keeps up to ${limit})` : ""}`;
+  if (!versions.length) return `${head}
+  Save one in the editor (Versions) to import it as cloud:${name.replace(/\.proschi$/, "")}:<tag>`;
+  const rows = [["TAG", "SEQ", "SAVED (UTC)", "SIZE", "NOTE"], ...versions.map((v) => [v.tag, `#${v.seq}`, date(v.createdAt), bytes(v.size), v.note ?? ""])];
+  const widths = rows[0].map((_, i) => Math.max(...rows.map((r) => r[i].length)));
+  return [head, ...rows.map((r) => `  ${r.map((c, i) => i === r.length - 1 ? c : c.padEnd(widths[i])).join("  ")}`.trimEnd())].join("\n");
+}
+async function runVersions(args, out, err, deps = {}) {
+  const [sub, ...rest] = args;
+  let json2 = false;
+  let base = DEFAULT_SITE;
+  const positional = [];
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === "--json") json2 = true;
+    else if (arg === "--base") {
+      try {
+        base = normalizeBase(rest[++i] ?? "");
+      } catch (e) {
+        err(e.message);
+        return 2;
+      }
+    } else if (arg.startsWith("-")) {
+      err(`Unknown option ${arg}
+
+Usage:
+${VERSIONS_USAGE}`);
+      return 2;
+    } else positional.push(arg);
+  }
+  const usage = () => (err(`Usage:
+${VERSIONS_USAGE}`), 2);
+  if (sub === "list" ? positional.length !== 1 : sub === "diff" ? positional.length < 2 || positional.length > 3 : true) return usage();
+  const client = new ApiClient({ base, store: deps.store, fetch: deps.fetch });
+  try {
+    const spec = cloudName(positional[0]);
+    if (sub === "list") {
+      const doc = await findDocument(client, spec);
+      const { versions, limit } = await listVersions(client, doc.id);
+      out(json2 ? JSON.stringify({ name: doc.name, documentId: doc.id, versions, limit }, null, 2) : formatVersionList(doc.name, versions, limit));
+      return 0;
+    }
+    const [, baseTag, target = LATEST_TAG] = positional;
+    const isFile = target.endsWith(".proschi") || target.includes("/") || target.includes("\\");
+    for (const tag of isFile ? [baseTag] : [baseTag, target]) {
+      if (!VERSION_TAG.test(tag)) throw new Error(`'${tag}' is not a version tag (letters, digits, '.', '_' and '-'), or latest`);
+    }
+    const before2 = await resolveVersion(client, spec, baseTag);
+    const after2 = isFile ? void 0 : await resolveVersion(client, spec, target);
+    const left = parseVersion(before2);
+    const right = after2 ? parseVersion(after2) : parseFile(target);
+    const label = (v, asked) => `cloud:${spec.name}:${v.tag} (#${v.seq}${asked === LATEST_TAG ? ", latest" : ""})`;
+    const toLabel = after2 ? label(after2, target) : displayPath3(target);
+    for (const [what, r] of [[label(before2, baseTag), left], [toLabel, right]]) {
+      const errors = r.diagnostics.filter((d) => d.severity === "error").length;
+      if (errors) err(`warning: ${what} has ${errors} error(s); the diff covers what parsed`);
+    }
+    const diff = diffDiagrams(left.diagram, right.diagram);
+    if (json2) {
+      const side = (v) => ({ tag: v.tag, seq: v.seq, sha256: v.sha256 });
+      out(JSON.stringify({ name: spec.name, base: side(before2), target: after2 ? side(after2) : { file: displayPath3(target) }, summary: summarizeDiff(diff), diff }, null, 2));
+    } else out(formatDiff(diff, label(before2, baseTag), toLabel));
+    return 0;
+  } catch (e) {
+    err(`error: ${e.message}`);
+    return 1;
+  }
+}
+
 // src/cli.ts
-var VERSION2 = true ? "0.13.0" : "dev";
+var VERSION2 = true ? "0.14.0" : "dev";
 var USAGE = `Usage:
   proschi check [--strict] [--format text|github|json] [--openapi <node>=<spec>]... <file|dir>...
   proschi parse <file>
@@ -27862,6 +28794,8 @@ ${GAME_USAGE}
 ${SHARE_USAGE}
 ${IMPORT_USAGE}
 ${IMPORTS_USAGE}
+${LOGIN_USAGE}
+${VERSIONS_USAGE}
   proschi --version
 
 check   Reports errors and warnings. Directories are searched for *.proschi files.
@@ -27881,19 +28815,21 @@ ${ACHIEVEMENTS_HELP}
 ${GAME_HELP}
 ${SHARE_HELP}
 ${IMPORT_HELP}
-${IMPORTS_HELP}`;
+${IMPORTS_HELP}
+${LOGIN_HELP}
+${VERSIONS_HELP}`;
 function collectFiles(paths) {
   const out = [];
   const walk = (dir) => {
-    for (const entry of (0, import_node_fs14.readdirSync)(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+    for (const entry of (0, import_node_fs15.readdirSync)(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const full = (0, import_node_path13.join)(dir, entry.name);
+      const full = (0, import_node_path14.join)(dir, entry.name);
       if (entry.isDirectory()) walk(full);
       else if (entry.name.endsWith(".proschi")) out.push(full);
     }
   };
   for (const p of paths) {
-    if ((0, import_node_fs14.statSync)(p).isDirectory()) walk(p);
+    if ((0, import_node_fs15.statSync)(p).isDirectory()) walk(p);
     else out.push(p);
   }
   return out;
@@ -27948,6 +28884,8 @@ function run(argv, out = console.log, err = console.error) {
   if (command === "share-link") return runShareLink(rest, out, err);
   if (command === "import") return runImport(rest, out, err);
   if (command === "imports") return runImports(rest, collectFiles, out, err);
+  if (command === "login" || command === "logout" || command === "whoami") return runAuth(command, rest, out, err);
+  if (command === "versions") return runVersions(rest, out, err);
   if (command === "check") {
     let strict = false;
     let style = "text";
@@ -27957,12 +28895,12 @@ function run(argv, out = console.log, err = console.error) {
       const arg = rest[i];
       if (arg === "--strict") strict = true;
       else if (arg === "--format") {
-        const value = rest[++i];
-        if (value !== "text" && value !== "github" && value !== "json") {
-          err(`Unknown format '${value ?? ""}'; use text, github or json`);
+        const value2 = rest[++i];
+        if (value2 !== "text" && value2 !== "github" && value2 !== "json") {
+          err(`Unknown format '${value2 ?? ""}'; use text, github or json`);
           return 2;
         }
-        style = value;
+        style = value2;
       } else if (arg === "--openapi") {
         const spec = parseSpecFlag(rest[++i] ?? "");
         if (!spec) {