@meistrari/tela-cli 0.7.53 → 0.7.54

package/dist/index.js

@@ -6,9 +6,16 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -25,6 +32,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // ../../packages/local-config/dist/credentials.js
 var require_credentials = __commonJS({
@@ -7706,10 +7714,2149 @@ var require_dist2 = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
+function createScanner(text, ignoreTrivia = false) {
+  const len = text.length;
+  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+  function scanHexDigits(count, exact) {
+    let digits = 0;
+    let value2 = 0;
+    while (digits < count || !exact) {
+      let ch = text.charCodeAt(pos);
+      if (ch >= 48 && ch <= 57) {
+        value2 = value2 * 16 + ch - 48;
+      } else if (ch >= 65 && ch <= 70) {
+        value2 = value2 * 16 + ch - 65 + 10;
+      } else if (ch >= 97 && ch <= 102) {
+        value2 = value2 * 16 + ch - 97 + 10;
+      } else {
+        break;
+      }
+      pos++;
+      digits++;
+    }
+    if (digits < count) {
+      value2 = -1;
+    }
+    return value2;
+  }
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
+  }
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+      }
+    }
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+      } else {
+        scanError = 3;
+        return text.substring(start, pos);
+      }
+    }
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
+        pos++;
+      }
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+        end = pos;
+      } else {
+        scanError = 3;
+      }
+    }
+    return text.substring(start, end);
+  }
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
+      }
+      const ch = text.charCodeAt(pos);
+      if (ch === 34) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
+      }
+      if (ch === 92) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2;
+          break;
+        }
+        const ch2 = text.charCodeAt(pos++);
+        switch (ch2) {
+          case 34:
+            result += '"';
+            break;
+          case 92:
+            result += "\\";
+            break;
+          case 47:
+            result += "/";
+            break;
+          case 98:
+            result += "\b";
+            break;
+          case 102:
+            result += "\f";
+            break;
+          case 110:
+            result += "\n";
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "	";
+            break;
+          case 117:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) {
+              result += String.fromCharCode(ch3);
+            } else {
+              scanError = 4;
+            }
+            break;
+          default:
+            scanError = 5;
+        }
+        start = pos;
+        continue;
+      }
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2;
+          break;
+        } else {
+          scanError = 6;
+        }
+      }
+      pos++;
+    }
+    return result;
+  }
+  function scanNext() {
+    value = "";
+    scanError = 0;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 && text.charCodeAt(pos) === 10) {
+        pos++;
+        value += "\n";
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      // tokens: []{}:,
+      case 123:
+        pos++;
+        return token = 1;
+      case 125:
+        pos++;
+        return token = 2;
+      case 91:
+        pos++;
+        return token = 3;
+      case 93:
+        pos++;
+        return token = 4;
+      case 58:
+        pos++;
+        return token = 6;
+      case 44:
+        pos++;
+        return token = 5;
+      // strings
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      // comments
+      case 47:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) {
+              break;
+            }
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12;
+        }
+        if (text.charCodeAt(pos + 1) === 42) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 && text.charCodeAt(pos) === 10) {
+                pos++;
+              }
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+      // numbers
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) {
+          return token = 16;
+        }
+      // found a minus, followed by a number so
+      // we fall through to proceed with scanning
+      // numbers
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        value += scanNumber();
+        return token = 11;
+      // literals and unknown symbols
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8;
+            case "false":
+              return token = 9;
+            case "null":
+              return token = 7;
+          }
+          return token = 16;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+    }
+  }
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      return false;
+    }
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
+    }
+    return true;
+  }
+  function scanNextNonTrivia() {
+    let result;
+    do {
+      result = scanNext();
+    } while (result >= 12 && result <= 15);
+    return result;
+  }
+  return {
+    setPosition,
+    getPosition: () => pos,
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    getToken: () => token,
+    getTokenValue: () => value,
+    getTokenOffset: () => tokenOffset,
+    getTokenLength: () => pos - tokenOffset,
+    getTokenStartLine: () => lineStartOffset,
+    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+    getTokenError: () => scanError
+  };
+}
+function isWhiteSpace(ch) {
+  return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+  return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+var init_scanner = __esm({
+  "../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js"() {
+    "use strict";
+    (function(CharacterCodes2) {
+      CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+      CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+      CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+      CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+      CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+      CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+      CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+      CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+      CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+      CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+      CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+      CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+      CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+      CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+      CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+      CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+      CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+      CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+      CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+      CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+      CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+      CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+      CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+      CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+      CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+      CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+      CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+      CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+      CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+      CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+      CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+      CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+      CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+      CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+      CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+      CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+      CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+      CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+      CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+      CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+      CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+      CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+      CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+      CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+      CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+      CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+      CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+      CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+      CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+      CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+      CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+      CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+      CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+      CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+      CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+      CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+      CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+      CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+      CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+      CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+      CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+      CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+      CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+      CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+      CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+      CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+      CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+      CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+      CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+      CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+      CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+      CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+      CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+      CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+      CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+      CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+      CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+      CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+      CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+      CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+    })(CharacterCodes || (CharacterCodes = {}));
+  }
+});
+
+// ../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/string-intern.js
+var cachedSpaces, maxCachedValues, cachedBreakLinesWithSpaces, supportedEols;
+var init_string_intern = __esm({
+  "../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/string-intern.js"() {
+    cachedSpaces = new Array(20).fill(0).map((_, index) => {
+      return " ".repeat(index);
+    });
+    maxCachedValues = 200;
+    cachedBreakLinesWithSpaces = {
+      " ": {
+        "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+          return "\n" + " ".repeat(index);
+        }),
+        "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+          return "\r" + " ".repeat(index);
+        }),
+        "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+          return "\r\n" + " ".repeat(index);
+        })
+      },
+      "	": {
+        "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+          return "\n" + "	".repeat(index);
+        }),
+        "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+          return "\r" + "	".repeat(index);
+        }),
+        "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+          return "\r\n" + "	".repeat(index);
+        })
+      }
+    };
+    supportedEols = ["\n", "\r", "\r\n"];
+  }
+});
+
+// ../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/format.js
+function format(documentText, range, options) {
+  let initialIndentLevel;
+  let formatText;
+  let formatTextStart;
+  let rangeStart;
+  let rangeEnd;
+  if (range) {
+    rangeStart = range.offset;
+    rangeEnd = rangeStart + range.length;
+    formatTextStart = rangeStart;
+    while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) {
+      formatTextStart--;
+    }
+    let endOffset = rangeEnd;
+    while (endOffset < documentText.length && !isEOL(documentText, endOffset)) {
+      endOffset++;
+    }
+    formatText = documentText.substring(formatTextStart, endOffset);
+    initialIndentLevel = computeIndentLevel(formatText, options);
+  } else {
+    formatText = documentText;
+    initialIndentLevel = 0;
+    formatTextStart = 0;
+    rangeStart = 0;
+    rangeEnd = documentText.length;
+  }
+  const eol = getEOL(options, documentText);
+  const eolFastPathSupported = supportedEols.includes(eol);
+  let numberLineBreaks = 0;
+  let indentLevel = 0;
+  let indentValue;
+  if (options.insertSpaces) {
+    indentValue = cachedSpaces[options.tabSize || 4] ?? repeat(cachedSpaces[1], options.tabSize || 4);
+  } else {
+    indentValue = "	";
+  }
+  const indentType = indentValue === "	" ? "	" : " ";
+  let scanner = createScanner(formatText, false);
+  let hasError = false;
+  function newLinesAndIndent() {
+    if (numberLineBreaks > 1) {
+      return repeat(eol, numberLineBreaks) + repeat(indentValue, initialIndentLevel + indentLevel);
+    }
+    const amountOfSpaces = indentValue.length * (initialIndentLevel + indentLevel);
+    if (!eolFastPathSupported || amountOfSpaces > cachedBreakLinesWithSpaces[indentType][eol].length) {
+      return eol + repeat(indentValue, initialIndentLevel + indentLevel);
+    }
+    if (amountOfSpaces <= 0) {
+      return eol;
+    }
+    return cachedBreakLinesWithSpaces[indentType][eol][amountOfSpaces];
+  }
+  function scanNext() {
+    let token = scanner.scan();
+    numberLineBreaks = 0;
+    while (token === 15 || token === 14) {
+      if (token === 14 && options.keepLines) {
+        numberLineBreaks += 1;
+      } else if (token === 14) {
+        numberLineBreaks = 1;
+      }
+      token = scanner.scan();
+    }
+    hasError = token === 16 || scanner.getTokenError() !== 0;
+    return token;
+  }
+  const editOperations = [];
+  function addEdit(text, startOffset, endOffset) {
+    if (!hasError && (!range || startOffset < rangeEnd && endOffset > rangeStart) && documentText.substring(startOffset, endOffset) !== text) {
+      editOperations.push({ offset: startOffset, length: endOffset - startOffset, content: text });
+    }
+  }
+  let firstToken = scanNext();
+  if (options.keepLines && numberLineBreaks > 0) {
+    addEdit(repeat(eol, numberLineBreaks), 0, 0);
+  }
+  if (firstToken !== 17) {
+    let firstTokenStart = scanner.getTokenOffset() + formatTextStart;
+    let initialIndent = indentValue.length * initialIndentLevel < 20 && options.insertSpaces ? cachedSpaces[indentValue.length * initialIndentLevel] : repeat(indentValue, initialIndentLevel);
+    addEdit(initialIndent, formatTextStart, firstTokenStart);
+  }
+  while (firstToken !== 17) {
+    let firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+    let secondToken = scanNext();
+    let replaceContent = "";
+    let needsLineBreak = false;
+    while (numberLineBreaks === 0 && (secondToken === 12 || secondToken === 13)) {
+      let commentTokenStart = scanner.getTokenOffset() + formatTextStart;
+      addEdit(cachedSpaces[1], firstTokenEnd, commentTokenStart);
+      firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+      needsLineBreak = secondToken === 12;
+      replaceContent = needsLineBreak ? newLinesAndIndent() : "";
+      secondToken = scanNext();
+    }
+    if (secondToken === 2) {
+      if (firstToken !== 1) {
+        indentLevel--;
+      }
+      ;
+      if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 1) {
+        replaceContent = newLinesAndIndent();
+      } else if (options.keepLines) {
+        replaceContent = cachedSpaces[1];
+      }
+    } else if (secondToken === 4) {
+      if (firstToken !== 3) {
+        indentLevel--;
+      }
+      ;
+      if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 3) {
+        replaceContent = newLinesAndIndent();
+      } else if (options.keepLines) {
+        replaceContent = cachedSpaces[1];
+      }
+    } else {
+      switch (firstToken) {
+        case 3:
+        case 1:
+          indentLevel++;
+          if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 5:
+          if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 12:
+          replaceContent = newLinesAndIndent();
+          break;
+        case 13:
+          if (numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (!needsLineBreak) {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 6:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (!needsLineBreak) {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 10:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (secondToken === 6 && !needsLineBreak) {
+            replaceContent = "";
+          }
+          break;
+        case 7:
+        case 8:
+        case 9:
+        case 11:
+        case 2:
+        case 4:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            if ((secondToken === 12 || secondToken === 13) && !needsLineBreak) {
+              replaceContent = cachedSpaces[1];
+            } else if (secondToken !== 5 && secondToken !== 17) {
+              hasError = true;
+            }
+          }
+          break;
+        case 16:
+          hasError = true;
+          break;
+      }
+      if (numberLineBreaks > 0 && (secondToken === 12 || secondToken === 13)) {
+        replaceContent = newLinesAndIndent();
+      }
+    }
+    if (secondToken === 17) {
+      if (options.keepLines && numberLineBreaks > 0) {
+        replaceContent = newLinesAndIndent();
+      } else {
+        replaceContent = options.insertFinalNewline ? eol : "";
+      }
+    }
+    const secondTokenStart = scanner.getTokenOffset() + formatTextStart;
+    addEdit(replaceContent, firstTokenEnd, secondTokenStart);
+    firstToken = secondToken;
+  }
+  return editOperations;
+}
+function repeat(s, count) {
+  let result = "";
+  for (let i = 0; i < count; i++) {
+    result += s;
+  }
+  return result;
+}
+function computeIndentLevel(content, options) {
+  let i = 0;
+  let nChars = 0;
+  const tabSize = options.tabSize || 4;
+  while (i < content.length) {
+    let ch = content.charAt(i);
+    if (ch === cachedSpaces[1]) {
+      nChars++;
+    } else if (ch === "	") {
+      nChars += tabSize;
+    } else {
+      break;
+    }
+    i++;
+  }
+  return Math.floor(nChars / tabSize);
+}
+function getEOL(options, text) {
+  for (let i = 0; i < text.length; i++) {
+    const ch = text.charAt(i);
+    if (ch === "\r") {
+      if (i + 1 < text.length && text.charAt(i + 1) === "\n") {
+        return "\r\n";
+      }
+      return "\r";
+    } else if (ch === "\n") {
+      return "\n";
+    }
+  }
+  return options && options.eol || "\n";
+}
+function isEOL(text, offset) {
+  return "\r\n".indexOf(text.charAt(offset)) !== -1;
+}
+var init_format = __esm({
+  "../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/format.js"() {
+    "use strict";
+    init_scanner();
+    init_string_intern();
+  }
+});
+
+// ../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/parser.js
+function getLocation(text, position) {
+  const segments = [];
+  const earlyReturnException = new Object();
+  let previousNode = void 0;
+  const previousNodeInst = {
+    value: {},
+    offset: 0,
+    length: 0,
+    type: "object",
+    parent: void 0
+  };
+  let isAtPropertyKey = false;
+  function setPreviousNode(value, offset, length, type) {
+    previousNodeInst.value = value;
+    previousNodeInst.offset = offset;
+    previousNodeInst.length = length;
+    previousNodeInst.type = type;
+    previousNodeInst.colonOffset = void 0;
+    previousNode = previousNodeInst;
+  }
+  try {
+    visit(text, {
+      onObjectBegin: (offset, length) => {
+        if (position <= offset) {
+          throw earlyReturnException;
+        }
+        previousNode = void 0;
+        isAtPropertyKey = position > offset;
+        segments.push("");
+      },
+      onObjectProperty: (name, offset, length) => {
+        if (position < offset) {
+          throw earlyReturnException;
+        }
+        setPreviousNode(name, offset, length, "property");
+        segments[segments.length - 1] = name;
+        if (position <= offset + length) {
+          throw earlyReturnException;
+        }
+      },
+      onObjectEnd: (offset, length) => {
+        if (position <= offset) {
+          throw earlyReturnException;
+        }
+        previousNode = void 0;
+        segments.pop();
+      },
+      onArrayBegin: (offset, length) => {
+        if (position <= offset) {
+          throw earlyReturnException;
+        }
+        previousNode = void 0;
+        segments.push(0);
+      },
+      onArrayEnd: (offset, length) => {
+        if (position <= offset) {
+          throw earlyReturnException;
+        }
+        previousNode = void 0;
+        segments.pop();
+      },
+      onLiteralValue: (value, offset, length) => {
+        if (position < offset) {
+          throw earlyReturnException;
+        }
+        setPreviousNode(value, offset, length, getNodeType(value));
+        if (position <= offset + length) {
+          throw earlyReturnException;
+        }
+      },
+      onSeparator: (sep, offset, length) => {
+        if (position <= offset) {
+          throw earlyReturnException;
+        }
+        if (sep === ":" && previousNode && previousNode.type === "property") {
+          previousNode.colonOffset = offset;
+          isAtPropertyKey = false;
+          previousNode = void 0;
+        } else if (sep === ",") {
+          const last = segments[segments.length - 1];
+          if (typeof last === "number") {
+            segments[segments.length - 1] = last + 1;
+          } else {
+            isAtPropertyKey = true;
+            segments[segments.length - 1] = "";
+          }
+          previousNode = void 0;
+        }
+      }
+    });
+  } catch (e) {
+    if (e !== earlyReturnException) {
+      throw e;
+    }
+  }
+  return {
+    path: segments,
+    previousNode,
+    isAtPropertyKey,
+    matches: (pattern) => {
+      let k = 0;
+      for (let i = 0; k < pattern.length && i < segments.length; i++) {
+        if (pattern[k] === segments[i] || pattern[k] === "*") {
+          k++;
+        } else if (pattern[k] !== "**") {
+          return false;
+        }
+      }
+      return k === pattern.length;
+    }
+  };
+}
+function parse(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentProperty = null;
+  let currentParent = [];
+  const previousParents = [];
+  function onValue(value) {
+    if (Array.isArray(currentParent)) {
+      currentParent.push(value);
+    } else if (currentProperty !== null) {
+      currentParent[currentProperty] = value;
+    }
+  }
+  const visitor = {
+    onObjectBegin: () => {
+      const object = {};
+      onValue(object);
+      previousParents.push(currentParent);
+      currentParent = object;
+      currentProperty = null;
+    },
+    onObjectProperty: (name) => {
+      currentProperty = name;
+    },
+    onObjectEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onArrayBegin: () => {
+      const array = [];
+      onValue(array);
+      previousParents.push(currentParent);
+      currentParent = array;
+      currentProperty = null;
+    },
+    onArrayEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onLiteralValue: onValue,
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  return currentParent[0];
+}
+function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentParent = { type: "array", offset: -1, length: -1, children: [], parent: void 0 };
+  function ensurePropertyComplete(endOffset) {
+    if (currentParent.type === "property") {
+      currentParent.length = endOffset - currentParent.offset;
+      currentParent = currentParent.parent;
+    }
+  }
+  function onValue(valueNode) {
+    currentParent.children.push(valueNode);
+    return valueNode;
+  }
+  const visitor = {
+    onObjectBegin: (offset) => {
+      currentParent = onValue({ type: "object", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onObjectProperty: (name, offset, length) => {
+      currentParent = onValue({ type: "property", offset, length: -1, parent: currentParent, children: [] });
+      currentParent.children.push({ type: "string", value: name, offset, length, parent: currentParent });
+    },
+    onObjectEnd: (offset, length) => {
+      ensurePropertyComplete(offset + length);
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onArrayBegin: (offset, length) => {
+      currentParent = onValue({ type: "array", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onArrayEnd: (offset, length) => {
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onLiteralValue: (value, offset, length) => {
+      onValue({ type: getNodeType(value), offset, length, parent: currentParent, value });
+      ensurePropertyComplete(offset + length);
+    },
+    onSeparator: (sep, offset, length) => {
+      if (currentParent.type === "property") {
+        if (sep === ":") {
+          currentParent.colonOffset = offset;
+        } else if (sep === ",") {
+          ensurePropertyComplete(offset);
+        }
+      }
+    },
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  const result = currentParent.children[0];
+  if (result) {
+    delete result.parent;
+  }
+  return result;
+}
+function findNodeAtLocation(root, path) {
+  if (!root) {
+    return void 0;
+  }
+  let node = root;
+  for (let segment of path) {
+    if (typeof segment === "string") {
+      if (node.type !== "object" || !Array.isArray(node.children)) {
+        return void 0;
+      }
+      let found = false;
+      for (const propertyNode of node.children) {
+        if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment && propertyNode.children.length === 2) {
+          node = propertyNode.children[1];
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        return void 0;
+      }
+    } else {
+      const index = segment;
+      if (node.type !== "array" || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
+        return void 0;
+      }
+      node = node.children[index];
+    }
+  }
+  return node;
+}
+function getNodePath(node) {
+  if (!node.parent || !node.parent.children) {
+    return [];
+  }
+  const path = getNodePath(node.parent);
+  if (node.parent.type === "property") {
+    const key = node.parent.children[0].value;
+    path.push(key);
+  } else if (node.parent.type === "array") {
+    const index = node.parent.children.indexOf(node);
+    if (index !== -1) {
+      path.push(index);
+    }
+  }
+  return path;
+}
+function getNodeValue(node) {
+  switch (node.type) {
+    case "array":
+      return node.children.map(getNodeValue);
+    case "object":
+      const obj = /* @__PURE__ */ Object.create(null);
+      for (let prop of node.children) {
+        const valueNode = prop.children[1];
+        if (valueNode) {
+          obj[prop.children[0].value] = getNodeValue(valueNode);
+        }
+      }
+      return obj;
+    case "null":
+    case "string":
+    case "number":
+    case "boolean":
+      return node.value;
+    default:
+      return void 0;
+  }
+}
+function contains(node, offset, includeRightBound = false) {
+  return offset >= node.offset && offset < node.offset + node.length || includeRightBound && offset === node.offset + node.length;
+}
+function findNodeAtOffset(node, offset, includeRightBound = false) {
+  if (contains(node, offset, includeRightBound)) {
+    const children = node.children;
+    if (Array.isArray(children)) {
+      for (let i = 0; i < children.length && children[i].offset <= offset; i++) {
+        const item = findNodeAtOffset(children[i], offset, includeRightBound);
+        if (item) {
+          return item;
+        }
+      }
+    }
+    return node;
+  }
+  return void 0;
+}
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+  const _scanner = createScanner(text, false);
+  const _jsonPath = [];
+  let suppressedCallbacks = 0;
+  function toNoArgVisit(visitFunction) {
+    return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisit(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisitWithPath(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  function toBeginVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks++;
+      } else {
+        let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+        if (cbReturn === false) {
+          suppressedCallbacks = 1;
+        }
+      }
+    } : () => true;
+  }
+  function toEndVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks--;
+      }
+      if (suppressedCallbacks === 0) {
+        visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+      }
+    } : () => true;
+  }
+  const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+  const disallowComments = options && options.disallowComments;
+  const allowTrailingComma = options && options.allowTrailingComma;
+  function scanNext() {
+    while (true) {
+      const token = _scanner.scan();
+      switch (_scanner.getTokenError()) {
+        case 4:
+          handleError(
+            14
+            /* ParseErrorCode.InvalidUnicode */
+          );
+          break;
+        case 5:
+          handleError(
+            15
+            /* ParseErrorCode.InvalidEscapeCharacter */
+          );
+          break;
+        case 3:
+          handleError(
+            13
+            /* ParseErrorCode.UnexpectedEndOfNumber */
+          );
+          break;
+        case 1:
+          if (!disallowComments) {
+            handleError(
+              11
+              /* ParseErrorCode.UnexpectedEndOfComment */
+            );
+          }
+          break;
+        case 2:
+          handleError(
+            12
+            /* ParseErrorCode.UnexpectedEndOfString */
+          );
+          break;
+        case 6:
+          handleError(
+            16
+            /* ParseErrorCode.InvalidCharacter */
+          );
+          break;
+      }
+      switch (token) {
+        case 12:
+        case 13:
+          if (disallowComments) {
+            handleError(
+              10
+              /* ParseErrorCode.InvalidCommentToken */
+            );
+          } else {
+            onComment();
+          }
+          break;
+        case 16:
+          handleError(
+            1
+            /* ParseErrorCode.InvalidSymbol */
+          );
+          break;
+        case 15:
+        case 14:
+          break;
+        default:
+          return token;
+      }
+    }
+  }
+  function handleError(error, skipUntilAfter = [], skipUntil = []) {
+    onError(error);
+    if (skipUntilAfter.length + skipUntil.length > 0) {
+      let token = _scanner.getToken();
+      while (token !== 17) {
+        if (skipUntilAfter.indexOf(token) !== -1) {
+          scanNext();
+          break;
+        } else if (skipUntil.indexOf(token) !== -1) {
+          break;
+        }
+        token = scanNext();
+      }
+    }
+  }
+  function parseString(isValue) {
+    const value = _scanner.getTokenValue();
+    if (isValue) {
+      onLiteralValue(value);
+    } else {
+      onObjectProperty(value);
+      _jsonPath.push(value);
+    }
+    scanNext();
+    return true;
+  }
+  function parseLiteral() {
+    switch (_scanner.getToken()) {
+      case 11:
+        const tokenValue = _scanner.getTokenValue();
+        let value = Number(tokenValue);
+        if (isNaN(value)) {
+          handleError(
+            2
+            /* ParseErrorCode.InvalidNumberFormat */
+          );
+          value = 0;
+        }
+        onLiteralValue(value);
+        break;
+      case 7:
+        onLiteralValue(null);
+        break;
+      case 8:
+        onLiteralValue(true);
+        break;
+      case 9:
+        onLiteralValue(false);
+        break;
+      default:
+        return false;
+    }
+    scanNext();
+    return true;
+  }
+  function parseProperty() {
+    if (_scanner.getToken() !== 10) {
+      handleError(3, [], [
+        2,
+        5
+        /* SyntaxKind.CommaToken */
+      ]);
+      return false;
+    }
+    parseString(false);
+    if (_scanner.getToken() === 6) {
+      onSeparator(":");
+      scanNext();
+      if (!parseValue()) {
+        handleError(4, [], [
+          2,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+    } else {
+      handleError(5, [], [
+        2,
+        5
+        /* SyntaxKind.CommaToken */
+      ]);
+    }
+    _jsonPath.pop();
+    return true;
+  }
+  function parseObject() {
+    onObjectBegin();
+    scanNext();
+    let needsComma = false;
+    while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 2 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (!parseProperty()) {
+        handleError(4, [], [
+          2,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+      needsComma = true;
+    }
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) {
+      handleError(7, [
+        2
+        /* SyntaxKind.CloseBraceToken */
+      ], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseArray() {
+    onArrayBegin();
+    scanNext();
+    let isFirstElement = true;
+    let needsComma = false;
+    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 4 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (isFirstElement) {
+        _jsonPath.push(0);
+        isFirstElement = false;
+      } else {
+        _jsonPath[_jsonPath.length - 1]++;
+      }
+      if (!parseValue()) {
+        handleError(4, [], [
+          4,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+      needsComma = true;
+    }
+    onArrayEnd();
+    if (!isFirstElement) {
+      _jsonPath.pop();
+    }
+    if (_scanner.getToken() !== 4) {
+      handleError(8, [
+        4
+        /* SyntaxKind.CloseBracketToken */
+      ], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseValue() {
+    switch (_scanner.getToken()) {
+      case 3:
+        return parseArray();
+      case 1:
+        return parseObject();
+      case 10:
+        return parseString(true);
+      default:
+        return parseLiteral();
+    }
+  }
+  scanNext();
+  if (_scanner.getToken() === 17) {
+    if (options.allowEmptyContent) {
+      return true;
+    }
+    handleError(4, [], []);
+    return false;
+  }
+  if (!parseValue()) {
+    handleError(4, [], []);
+    return false;
+  }
+  if (_scanner.getToken() !== 17) {
+    handleError(9, [], []);
+  }
+  return true;
+}
+function stripComments(text, replaceCh) {
+  let _scanner = createScanner(text), parts = [], kind, offset = 0, pos;
+  do {
+    pos = _scanner.getPosition();
+    kind = _scanner.scan();
+    switch (kind) {
+      case 12:
+      case 13:
+      case 17:
+        if (offset !== pos) {
+          parts.push(text.substring(offset, pos));
+        }
+        if (replaceCh !== void 0) {
+          parts.push(_scanner.getTokenValue().replace(/[^\r\n]/g, replaceCh));
+        }
+        offset = _scanner.getPosition();
+        break;
+    }
+  } while (kind !== 17);
+  return parts.join("");
+}
+function getNodeType(value) {
+  switch (typeof value) {
+    case "boolean":
+      return "boolean";
+    case "number":
+      return "number";
+    case "string":
+      return "string";
+    case "object": {
+      if (!value) {
+        return "null";
+      } else if (Array.isArray(value)) {
+        return "array";
+      }
+      return "object";
+    }
+    default:
+      return "null";
+  }
+}
+var ParseOptions;
+var init_parser = __esm({
+  "../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/parser.js"() {
+    "use strict";
+    init_scanner();
+    (function(ParseOptions2) {
+      ParseOptions2.DEFAULT = {
+        allowTrailingComma: false
+      };
+    })(ParseOptions || (ParseOptions = {}));
+  }
+});
+
+// ../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/edit.js
+function setProperty(text, originalPath, value, options) {
+  const path = originalPath.slice();
+  const errors = [];
+  const root = parseTree(text, errors);
+  let parent = void 0;
+  let lastSegment = void 0;
+  while (path.length > 0) {
+    lastSegment = path.pop();
+    parent = findNodeAtLocation(root, path);
+    if (parent === void 0 && value !== void 0) {
+      if (typeof lastSegment === "string") {
+        value = { [lastSegment]: value };
+      } else {
+        value = [value];
+      }
+    } else {
+      break;
+    }
+  }
+  if (!parent) {
+    if (value === void 0) {
+      throw new Error("Can not delete in empty document");
+    }
+    return withFormatting(text, { offset: root ? root.offset : 0, length: root ? root.length : 0, content: JSON.stringify(value) }, options);
+  } else if (parent.type === "object" && typeof lastSegment === "string" && Array.isArray(parent.children)) {
+    const existing = findNodeAtLocation(parent, [lastSegment]);
+    if (existing !== void 0) {
+      if (value === void 0) {
+        if (!existing.parent) {
+          throw new Error("Malformed AST");
+        }
+        const propertyIndex = parent.children.indexOf(existing.parent);
+        let removeBegin;
+        let removeEnd = existing.parent.offset + existing.parent.length;
+        if (propertyIndex > 0) {
+          let previous = parent.children[propertyIndex - 1];
+          removeBegin = previous.offset + previous.length;
+        } else {
+          removeBegin = parent.offset + 1;
+          if (parent.children.length > 1) {
+            let next = parent.children[1];
+            removeEnd = next.offset;
+          }
+        }
+        return withFormatting(text, { offset: removeBegin, length: removeEnd - removeBegin, content: "" }, options);
+      } else {
+        return withFormatting(text, { offset: existing.offset, length: existing.length, content: JSON.stringify(value) }, options);
+      }
+    } else {
+      if (value === void 0) {
+        return [];
+      }
+      const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
+      const index = options.getInsertionIndex ? options.getInsertionIndex(parent.children.map((p) => p.children[0].value)) : parent.children.length;
+      let edit;
+      if (index > 0) {
+        let previous = parent.children[index - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      } else if (parent.children.length === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+      } else {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty + "," };
+      }
+      return withFormatting(text, edit, options);
+    }
+  } else if (parent.type === "array" && typeof lastSegment === "number" && Array.isArray(parent.children)) {
+    const insertIndex = lastSegment;
+    if (insertIndex === -1) {
+      const newProperty = `${JSON.stringify(value)}`;
+      let edit;
+      if (parent.children.length === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+      } else {
+        const previous = parent.children[parent.children.length - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      }
+      return withFormatting(text, edit, options);
+    } else if (value === void 0 && parent.children.length >= 0) {
+      const removalIndex = lastSegment;
+      const toRemove = parent.children[removalIndex];
+      let edit;
+      if (parent.children.length === 1) {
+        edit = { offset: parent.offset + 1, length: parent.length - 2, content: "" };
+      } else if (parent.children.length - 1 === removalIndex) {
+        let previous = parent.children[removalIndex - 1];
+        let offset = previous.offset + previous.length;
+        let parentEndOffset = parent.offset + parent.length;
+        edit = { offset, length: parentEndOffset - 2 - offset, content: "" };
+      } else {
+        edit = { offset: toRemove.offset, length: parent.children[removalIndex + 1].offset - toRemove.offset, content: "" };
+      }
+      return withFormatting(text, edit, options);
+    } else if (value !== void 0) {
+      let edit;
+      const newProperty = `${JSON.stringify(value)}`;
+      if (!options.isArrayInsertion && parent.children.length > lastSegment) {
+        const toModify = parent.children[lastSegment];
+        edit = { offset: toModify.offset, length: toModify.length, content: newProperty };
+      } else if (parent.children.length === 0 || lastSegment === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: parent.children.length === 0 ? newProperty : newProperty + "," };
+      } else {
+        const index = lastSegment > parent.children.length ? parent.children.length : lastSegment;
+        const previous = parent.children[index - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      }
+      return withFormatting(text, edit, options);
+    } else {
+      throw new Error(`Can not ${value === void 0 ? "remove" : options.isArrayInsertion ? "insert" : "modify"} Array index ${insertIndex} as length is not sufficient`);
+    }
+  } else {
+    throw new Error(`Can not add ${typeof lastSegment !== "number" ? "index" : "property"} to parent of type ${parent.type}`);
+  }
+}
+function withFormatting(text, edit, options) {
+  if (!options.formattingOptions) {
+    return [edit];
+  }
+  let newText = applyEdit(text, edit);
+  let begin = edit.offset;
+  let end = edit.offset + edit.content.length;
+  if (edit.length === 0 || edit.content.length === 0) {
+    while (begin > 0 && !isEOL(newText, begin - 1)) {
+      begin--;
+    }
+    while (end < newText.length && !isEOL(newText, end)) {
+      end++;
+    }
+  }
+  const edits = format(newText, { offset: begin, length: end - begin }, { ...options.formattingOptions, keepLines: false });
+  for (let i = edits.length - 1; i >= 0; i--) {
+    const edit2 = edits[i];
+    newText = applyEdit(newText, edit2);
+    begin = Math.min(begin, edit2.offset);
+    end = Math.max(end, edit2.offset + edit2.length);
+    end += edit2.content.length - edit2.length;
+  }
+  const editLength = text.length - (newText.length - end) - begin;
+  return [{ offset: begin, length: editLength, content: newText.substring(begin, end) }];
+}
+function applyEdit(text, edit) {
+  return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
+}
+var init_edit = __esm({
+  "../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/edit.js"() {
+    "use strict";
+    init_format();
+    init_parser();
+  }
+});
+
+// ../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/main.js
+var main_exports = {};
+__export(main_exports, {
+  ParseErrorCode: () => ParseErrorCode,
+  ScanError: () => ScanError,
+  SyntaxKind: () => SyntaxKind,
+  applyEdits: () => applyEdits,
+  createScanner: () => createScanner2,
+  findNodeAtLocation: () => findNodeAtLocation2,
+  findNodeAtOffset: () => findNodeAtOffset2,
+  format: () => format2,
+  getLocation: () => getLocation2,
+  getNodePath: () => getNodePath2,
+  getNodeValue: () => getNodeValue2,
+  modify: () => modify,
+  parse: () => parse2,
+  parseTree: () => parseTree2,
+  printParseErrorCode: () => printParseErrorCode,
+  stripComments: () => stripComments2,
+  visit: () => visit2
+});
+function printParseErrorCode(code) {
+  switch (code) {
+    case 1:
+      return "InvalidSymbol";
+    case 2:
+      return "InvalidNumberFormat";
+    case 3:
+      return "PropertyNameExpected";
+    case 4:
+      return "ValueExpected";
+    case 5:
+      return "ColonExpected";
+    case 6:
+      return "CommaExpected";
+    case 7:
+      return "CloseBraceExpected";
+    case 8:
+      return "CloseBracketExpected";
+    case 9:
+      return "EndOfFileExpected";
+    case 10:
+      return "InvalidCommentToken";
+    case 11:
+      return "UnexpectedEndOfComment";
+    case 12:
+      return "UnexpectedEndOfString";
+    case 13:
+      return "UnexpectedEndOfNumber";
+    case 14:
+      return "InvalidUnicode";
+    case 15:
+      return "InvalidEscapeCharacter";
+    case 16:
+      return "InvalidCharacter";
+  }
+  return "<unknown ParseErrorCode>";
+}
+function format2(documentText, range, options) {
+  return format(documentText, range, options);
+}
+function modify(text, path, value, options) {
+  return setProperty(text, path, value, options);
+}
+function applyEdits(text, edits) {
+  let sortedEdits = edits.slice(0).sort((a, b) => {
+    const diff = a.offset - b.offset;
+    if (diff === 0) {
+      return a.length - b.length;
+    }
+    return diff;
+  });
+  let lastModifiedOffset = text.length;
+  for (let i = sortedEdits.length - 1; i >= 0; i--) {
+    let e = sortedEdits[i];
+    if (e.offset + e.length <= lastModifiedOffset) {
+      text = applyEdit(text, e);
+    } else {
+      throw new Error("Overlapping edit");
+    }
+    lastModifiedOffset = e.offset;
+  }
+  return text;
+}
+var createScanner2, ScanError, SyntaxKind, getLocation2, parse2, parseTree2, findNodeAtLocation2, findNodeAtOffset2, getNodePath2, getNodeValue2, visit2, stripComments2, ParseErrorCode;
+var init_main = __esm({
+  "../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/main.js"() {
+    "use strict";
+    init_format();
+    init_edit();
+    init_scanner();
+    init_parser();
+    createScanner2 = createScanner;
+    (function(ScanError2) {
+      ScanError2[ScanError2["None"] = 0] = "None";
+      ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+      ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+      ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+      ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+      ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+      ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+    })(ScanError || (ScanError = {}));
+    (function(SyntaxKind2) {
+      SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+      SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+      SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+      SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+      SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+      SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+      SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+      SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+      SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+      SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+      SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+      SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+      SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+      SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+      SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+      SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+      SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+    })(SyntaxKind || (SyntaxKind = {}));
+    getLocation2 = getLocation;
+    parse2 = parse;
+    parseTree2 = parseTree;
+    findNodeAtLocation2 = findNodeAtLocation;
+    findNodeAtOffset2 = findNodeAtOffset;
+    getNodePath2 = getNodePath;
+    getNodeValue2 = getNodeValue;
+    visit2 = visit;
+    stripComments2 = stripComments;
+    (function(ParseErrorCode2) {
+      ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+      ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+      ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+      ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+      ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+      ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+      ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+      ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+      ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+      ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+      ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+      ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+      ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+      ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+      ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+      ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+    })(ParseErrorCode || (ParseErrorCode = {}));
+  }
+});
+
+// ../../packages/workflow-code/dist/cli/contracts/diagnostics.js
+var require_diagnostics = __commonJS({
+  "../../packages/workflow-code/dist/cli/contracts/diagnostics.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.diagnostic = diagnostic;
+    function diagnostic(code, severity, message, hint) {
+      return Object.freeze({
+        code,
+        severity,
+        message,
+        ...hint === void 0 ? {} : { hint }
+      });
+    }
+  }
+});
+
+// ../../packages/workflow-code/dist/cli/config/load-config.js
+var require_load_config = __commonJS({
+  "../../packages/workflow-code/dist/cli/config/load-config.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.loadWorkflowCodeConfig = loadWorkflowCodeConfig;
+    var promises_1 = require("node:fs/promises");
+    var node_path_1 = require("node:path");
+    var jsonc_parser_1 = (init_main(), __toCommonJS(main_exports));
+    var diagnostics_1 = require_diagnostics();
+    async function loadWorkflowCodeConfig(cwd, configPath) {
+      const path = (0, node_path_1.resolve)(cwd, configPath ?? "workflow-code.config.jsonc");
+      let content;
+      try {
+        content = await (0, promises_1.readFile)(path, "utf8");
+      } catch (error) {
+        return {
+          ok: false,
+          diagnostics: [(0, diagnostics_1.diagnostic)("config.read_failed", "error", `Unable to read Workflow Code config at ${path}`, error instanceof Error ? error.message : void 0)]
+        };
+      }
+      const parseErrors = [];
+      const parsed = (0, jsonc_parser_1.parse)(content, parseErrors, {
+        allowTrailingComma: true,
+        disallowComments: false
+      });
+      if (parseErrors.length > 0) {
+        return {
+          ok: false,
+          diagnostics: [(0, diagnostics_1.diagnostic)("config.parse_failed", "error", `Unable to parse Workflow Code config at ${path}`, parseErrors.map((error) => (0, jsonc_parser_1.printParseErrorCode)(error.error)).join(", "))]
+        };
+      }
+      const diagnostics = validateWorkflowCodeConfig(parsed);
+      if (diagnostics.length > 0)
+        return { ok: false, diagnostics };
+      return { ok: true, value: { path, config: parsed } };
+    }
+    function validateWorkflowCodeConfig(value) {
+      const diagnostics = [];
+      if (!isRecord2(value)) {
+        return [(0, diagnostics_1.diagnostic)("config.invalid", "error", "Workflow Code config must be an object")];
+      }
+      if (value.version !== 1) {
+        diagnostics.push((0, diagnostics_1.diagnostic)("config.version.invalid", "error", "Workflow Code config version must be 1"));
+      }
+      if (value.tsconfig !== void 0 && typeof value.tsconfig !== "string") {
+        diagnostics.push((0, diagnostics_1.diagnostic)("config.tsconfig.invalid", "error", "Config field tsconfig must be a string when provided"));
+      }
+      if (value.outDir !== void 0 && typeof value.outDir !== "string") {
+        diagnostics.push((0, diagnostics_1.diagnostic)("config.out_dir.invalid", "error", "Config field outDir must be a string when provided"));
+      }
+      if (!isRecord2(value.workflows) || Object.keys(value.workflows).length === 0) {
+        diagnostics.push((0, diagnostics_1.diagnostic)("config.workflows.invalid", "error", "Config field workflows must contain at least one workflow target"));
+        return diagnostics;
+      }
+      for (const [targetName, target] of Object.entries(value.workflows)) {
+        diagnostics.push(...validateWorkflowTarget(targetName, target));
+      }
+      return diagnostics;
+    }
+    function validateWorkflowTarget(targetName, value) {
+      const diagnostics = [];
+      if (!isRecord2(value)) {
+        return [(0, diagnostics_1.diagnostic)("config.workflow.invalid", "error", `Workflow target ${targetName} must be an object`)];
+      }
+      const target = value;
+      if (!target.entry || typeof target.entry !== "string") {
+        diagnostics.push((0, diagnostics_1.diagnostic)("config.workflow.entry.invalid", "error", `Workflow target ${targetName} must define string field entry`));
+      }
+      if (!target.projectId || typeof target.projectId !== "string") {
+        diagnostics.push((0, diagnostics_1.diagnostic)("config.workflow.project_id.invalid", "error", `Workflow target ${targetName} must define string field projectId`));
+      }
+      if (target.export !== void 0 && target.export !== "default") {
+        diagnostics.push((0, diagnostics_1.diagnostic)("config.workflow.export.invalid", "error", `Workflow target ${targetName} only supports export: "default"`));
+      }
+      for (const field of ["promptId", "workflowKey", "title"]) {
+        if (target[field] !== void 0 && typeof target[field] !== "string") {
+          diagnostics.push((0, diagnostics_1.diagnostic)("config.workflow.optional_field.invalid", "error", `Workflow target ${targetName} field ${field} must be a string when provided`));
+        }
+      }
+      return diagnostics;
+    }
+    function isRecord2(value) {
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    }
+  }
+});
+
+// ../../packages/workflow-code/dist/cli/ui.js
+var require_ui2 = __commonJS({
+  "../../packages/workflow-code/dist/cli/ui.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.heading = heading;
+    exports2.pane = pane;
+    exports2.section = section;
+    exports2.kvList = kvList;
+    exports2.stepList = stepList;
+    exports2.bulletList = bulletList;
+    exports2.callout = callout;
+    exports2.resultCard = resultCard;
+    exports2.nextActions = nextActions;
+    exports2.table = table;
+    exports2.joinBlocks = joinBlocks;
+    function isDecorated(options = {}) {
+      return options.decorate ?? true;
+    }
+    function applyAnsi(text, code, options = {}) {
+      if (!isDecorated(options)) {
+        return text;
+      }
+      return `\x1B[${code}m${text}\x1B[0m`;
+    }
+    function bold(text, options = {}) {
+      return applyAnsi(text, 1, options);
+    }
+    function color(text, code, options = {}) {
+      return applyAnsi(text, code, options);
+    }
+    function linesOf(input) {
+      return Array.isArray(input) ? input.flatMap((part) => String(part).split("\n")) : String(input).split("\n");
+    }
+    function stripAnsi(input) {
+      const escape = String.fromCharCode(27);
+      return input.replace(new RegExp(`${escape}\\[[0-9;]*m`, "g"), "");
+    }
+    function visibleWidth(input) {
+      return stripAnsi(input).length;
+    }
+    function padRight(input, width) {
+      const padding = Math.max(0, width - visibleWidth(input));
+      return `${input}${" ".repeat(padding)}`;
+    }
+    function heading(text, options = {}) {
+      return bold(text, options);
+    }
+    function pane(title, content, options = {}) {
+      const decorate = isDecorated(options);
+      const inner = linesOf(content);
+      const header = decorate ? color(`\u250C\u2500 ${title}`, 36, options) : `[${title}]`;
+      const body = inner.map((line) => decorate ? `\u2502 ${line}` : line);
+      return [header, ...body].join("\n");
+    }
+    function section(title, content, options = {}) {
+      const lines = linesOf(content);
+      return [
+        heading(title, options),
+        ...lines.map((line) => line ? `  ${line}` : "")
+      ].join("\n");
+    }
+    function kvList(entries) {
+      if (entries.length === 0) {
+        return "";
+      }
+      const labelWidth = entries.reduce((max, entry) => Math.max(max, entry.label.length), 0);
+      return entries.map((entry) => `${padRight(`${entry.label}:`, labelWidth + 1)} ${entry.value}`).join("\n");
+    }
+    function stepList(steps) {
+      return steps.map((step, index) => `${index + 1}. ${step}`).join("\n");
+    }
+    function bulletList(items, prefix = "- ") {
+      return items.map((item) => `${prefix}${item}`).join("\n");
+    }
+    function callout(kind, title, content, options = {}) {
+      const prefixMap = {
+        info: { symbol: "i", color: 36 },
+        warn: { symbol: "!", color: 33 },
+        error: { symbol: "x", color: 31 },
+        success: { symbol: "\u2713", color: 32 }
+      };
+      const prefix = prefixMap[kind];
+      const decorate = isDecorated(options);
+      const marker = decorate ? color(prefix.symbol, prefix.color, options) : prefix.symbol;
+      return pane(`${marker} ${title}`, content, options);
+    }
+    function resultCard(title, sections, options = {}) {
+      return pane(title, sections.filter(Boolean).join("\n\n"), options);
+    }
+    function nextActions(actions, options = {}) {
+      return section("Next actions", stepList(actions), options);
+    }
+    function table(headers, rows, options = {}) {
+      const allRows = [headers, ...rows];
+      const widths = headers.map((_, columnIndex) => allRows.reduce((max, row) => {
+        return Math.max(max, visibleWidth(row[columnIndex] ?? ""));
+      }, 0));
+      const divider = widths.map((width) => "-".repeat(width)).join("  ");
+      const renderedRows = allRows.map((row, rowIndex) => {
+        const rendered = row.map((cell, columnIndex) => padRight(cell ?? "", widths[columnIndex] ?? 0)).join("  ");
+        if (rowIndex === 0 && isDecorated(options)) {
+          return bold(rendered, options);
+        }
+        return rendered;
+      });
+      return [renderedRows[0] ?? "", divider, ...renderedRows.slice(1)].join("\n");
+    }
+    function joinBlocks(blocks) {
+      return blocks.filter((block) => Boolean(block && block.trim())).join("\n\n");
+    }
+  }
+});
+
+// ../../packages/workflow-code/dist/cli/commands/compile.js
+var require_compile = __commonJS({
+  "../../packages/workflow-code/dist/cli/commands/compile.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.compileCommand = compileCommand;
+    var load_config_1 = require_load_config();
+    var ui_1 = require_ui2();
+    async function compileCommand(context) {
+      const configPath = typeof context.flags.config === "string" ? context.flags.config : void 0;
+      const result = await (0, load_config_1.loadWorkflowCodeConfig)(context.cwd, configPath);
+      if (!result.ok)
+        return { exitCode: 1, diagnostics: result.diagnostics };
+      const workflowNames = Object.keys(result.value.config.workflows);
+      const targetLabel = workflowNames.length === 1 ? "target" : "targets";
+      const targetList = workflowNames.map((name, index) => `${index + 1}: ${name}`).join("\n");
+      const output = [
+        `tela workflow compile scaffold: validated config for ${workflowNames.length} workflow ${targetLabel} from ${result.value.path}`,
+        targetList
+      ].filter(Boolean).join("\n");
+      return {
+        exitCode: 0,
+        output,
+        render: () => (0, ui_1.resultCard)("Workflow compile scaffold", [
+          (0, ui_1.section)("Summary", (0, ui_1.kvList)([
+            { label: "Config", value: result.value.path },
+            { label: "Targets", value: String(workflowNames.length) }
+          ])),
+          workflowNames.length ? (0, ui_1.section)("Workflow targets", (0, ui_1.stepList)(workflowNames)) : void 0
+        ])
+      };
+    }
+  }
+});
+
+// ../../packages/workflow-code/dist/cli/commands/init.js
+var require_init = __commonJS({
+  "../../packages/workflow-code/dist/cli/commands/init.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.initCommand = initCommand;
+    var promises_1 = require("node:fs/promises");
+    var node_path_1 = require("node:path");
+    var diagnostics_1 = require_diagnostics();
+    var ui_1 = require_ui2();
+    var DEFAULT_CONFIG = `{
+  // Workflow Code config for tela workflow commands.
+  "version": 1,
+  "tsconfig": "./tsconfig.json",
+  "outDir": ".workflow-code",
+  "workflows": {
+    "demo": {
+      "entry": "./src/workflows/demo.workflow.ts",
+      "projectId": "replace-with-project-id"
+    }
+  }
+}
+`;
+    async function initCommand(context) {
+      const configPath = typeof context.flags.config === "string" ? context.flags.config : "workflow-code.config.jsonc";
+      const path = (0, node_path_1.resolve)(context.cwd, configPath);
+      try {
+        await (0, promises_1.writeFile)(path, DEFAULT_CONFIG, { flag: "wx" });
+      } catch (error) {
+        if (isFileExistsError(error)) {
+          return {
+            exitCode: 1,
+            diagnostics: [(0, diagnostics_1.diagnostic)("init.config_exists", "error", `Workflow Code config already exists at ${path}`, "Move the existing file or pass --config with a different path.")]
+          };
+        }
+        return {
+          exitCode: 1,
+          diagnostics: [(0, diagnostics_1.diagnostic)("init.write_failed", "error", `Unable to write Workflow Code config at ${path}`, error instanceof Error ? error.message : void 0)]
+        };
+      }
+      return {
+        exitCode: 0,
+        output: `tela workflow init: created ${path}`,
+        render: () => (0, ui_1.resultCard)("Workflow init complete", [
+          (0, ui_1.section)("Config", (0, ui_1.kvList)([
+            { label: "Path", value: path }
+          ])),
+          (0, ui_1.nextActions)([
+            "Edit workflow targets in `workflow-code.config.jsonc`.",
+            "Run `tela workflow compile` to validate the config."
+          ])
+        ])
+      };
+    }
+    function isFileExistsError(error) {
+      return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
+    }
+  }
+});
+
+// ../../packages/workflow-code/dist/cli/commands/not-implemented.js
+var require_not_implemented = __commonJS({
+  "../../packages/workflow-code/dist/cli/commands/not-implemented.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.notImplementedCommand = notImplementedCommand;
+    var diagnostics_1 = require_diagnostics();
+    function notImplementedCommand(command) {
+      return {
+        exitCode: 1,
+        diagnostics: [(0, diagnostics_1.diagnostic)("cli.command.not_implemented", "error", `tela workflow ${command} is not yet available.`, "This command is planned for a future release.")]
+      };
+    }
+  }
+});
+
+// ../../packages/workflow-code/dist/cli.js
+var require_cli2 = __commonJS({
+  "../../packages/workflow-code/dist/cli.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.parseWorkflowCliArgs = parseWorkflowCliArgs;
+    exports2.runWorkflowCli = runWorkflowCli2;
+    var compile_1 = require_compile();
+    var init_1 = require_init();
+    var not_implemented_1 = require_not_implemented();
+    var diagnostics_1 = require_diagnostics();
+    var ui_1 = require_ui2();
+    var COMMANDS = /* @__PURE__ */ new Set([
+      "compile",
+      "init",
+      "codegen",
+      "sync",
+      "publish",
+      "run",
+      "create",
+      "watch"
+    ]);
+    function parseWorkflowCliArgs(argv) {
+      const [command = "help", ...rest] = argv;
+      const flags = {};
+      const passthrough = [];
+      for (let index = 0; index < rest.length; index += 1) {
+        const token = rest[index] ?? "";
+        if (!token.startsWith("--")) {
+          passthrough.push(token);
+          continue;
+        }
+        const key = token.slice(2);
+        if (key === "json" || key === "verbose")
+          continue;
+        const next = rest[index + 1];
+        if (!next || next.startsWith("--")) {
+          flags[key] = true;
+          continue;
+        }
+        flags[key] = next;
+        index += 1;
+      }
+      return { command, flags, passthrough };
+    }
+    async function runWorkflowCli2(argv, io, globalOptions) {
+      const { command, flags, passthrough } = parseWorkflowCliArgs(argv);
+      let result;
+      if (command === "help" || command === "--help" || command === "-h") {
+        writeHelp2(io);
+        return 0;
+      } else if (command === "compile") {
+        result = missingFlagValueResult(command, flags) ?? unexpectedPassthroughResult(command, passthrough) ?? await (0, compile_1.compileCommand)({ cwd: globalOptions.cwd ?? process.cwd(), flags, passthrough });
+      } else if (command === "init") {
+        result = missingFlagValueResult(command, flags) ?? unexpectedPassthroughResult(command, passthrough) ?? await (0, init_1.initCommand)({ cwd: globalOptions.cwd ?? process.cwd(), flags, passthrough });
+      } else if (COMMANDS.has(command)) {
+        result = (0, not_implemented_1.notImplementedCommand)(command);
+      } else {
+        result = {
+          exitCode: 1,
+          diagnostics: [{
+            code: "cli.command.unknown",
+            severity: "error",
+            message: `Unknown tela workflow command: ${command}`
+          }]
+        };
+      }
+      if (globalOptions.json === true) {
+        io.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+        return result.exitCode;
+      }
+      if (result.render) {
+        io.stdout.write(`${result.render()}
+`);
+      } else if (result.output) {
+        io.stdout.write(`${String(result.output)}
+`);
+      }
+      const diagnostics = result.diagnostics ?? [];
+      if (diagnostics.length > 0) {
+        const rendered = renderDiagnostics(diagnostics);
+        const hasErrors = diagnostics.some((item) => item.severity === "error");
+        const stream = hasErrors ? io.stderr : io.stdout;
+        stream.write(`${rendered}
+`);
+      }
+      return result.exitCode;
+    }
+    function missingFlagValueResult(command, flags) {
+      if (flags.config !== true)
+        return void 0;
+      return {
+        exitCode: 1,
+        diagnostics: [(0, diagnostics_1.diagnostic)("cli.flag.missing_value", "error", "Flag --config requires a value.", `Use --config <path>, for example: tela workflow ${command} --config workflow-code.config.jsonc`)]
+      };
+    }
+    function unexpectedPassthroughResult(command, passthrough) {
+      if (passthrough.length === 0)
+        return void 0;
+      return {
+        exitCode: 1,
+        diagnostics: [(0, diagnostics_1.diagnostic)("cli.command.unexpected_args", "error", `Unexpected positional arguments for tela workflow ${command}: ${passthrough.join(" ")}`, `Run tela workflow ${command} --help to see supported arguments.`)]
+      };
+    }
+    function writeHelp2(io) {
+      io.stdout.write(`${[
+        "Usage: tela workflow <command> [args]",
+        "",
+        "Commands:",
+        "  init [--config <path>] [--json]",
+        "  compile [--config <path>] [--json]",
+        "  codegen [--json]",
+        "  create [--json]",
+        "  sync [--json]",
+        "  publish [--json]",
+        "  run [--json]",
+        "  watch [--json]",
+        "",
+        (0, ui_1.table)(["Examples", ""], [
+          ["tela workflow init", "Create workflow-code.config.jsonc"],
+          ["tela workflow compile", "Validate local workflow config"],
+          ["tela workflow compile --config custom.jsonc", "Validate a custom config path"],
+          ["tela workflow init --json", "Create config and emit JSON result envelope"]
+        ])
+      ].join("\n")}
+`);
+    }
+    function renderDiagnostics(diagnostics) {
+      return (0, ui_1.joinBlocks)(diagnostics.map((item) => (0, ui_1.callout)(item.severity === "error" ? "error" : item.severity === "warning" ? "warn" : "info", item.severity === "error" ? "Workflow command failed" : "Workflow command notice", [
+        (0, ui_1.section)("Diagnostic", (0, ui_1.kvList)([
+          { label: "Code", value: item.code },
+          { label: "Severity", value: item.severity }
+        ])),
+        (0, ui_1.section)("Message", item.message),
+        item.hint ? (0, ui_1.section)("Hint", item.hint) : void 0
+      ].filter((part) => Boolean(part)))));
+    }
+  }
+});
+
 // src/program.ts
 var import_node_fs2 = require("node:fs");
 var import_node_path2 = require("node:path");
 var import_tela_agent = __toESM(require_dist2());
+var import_cli = __toESM(require_cli2());
 
 // src/output.ts
 function writeJson(io, value) {
@@ -8770,6 +10917,8 @@ async function runCli(argv, io) {
   if (command === "env") return runEnvCommand(rest, options, io);
   if (command === "doctor") return runDoctorCommand(rest, options, io);
   if (command === "agent") return (0, import_tela_agent.runAgentCli)(rest, io, options);
+  if (command === "workflow")
+    return (0, import_cli.runWorkflowCli)(rest, io, options);
   if (command === "update" || command === "api" || command === "docs" || command === "whoami" || command === "token") {
     return runTelactlCommand(command, rest, options, io);
   }
@@ -8813,6 +10962,9 @@ function writeHelp(io) {
   writeLine(io, "  whoami [--context <context-id>] [-p|--pretty]");
   writeLine(io, "  token [--context <context-id>]");
   writeLine(io, "  version");
+  writeLine(io, "  workflow init [--config <path>] [--json]");
+  writeLine(io, "  workflow compile [--config <path>] [--json]");
+  writeLine(io, "  workflow codegen|create|sync|publish|run|watch [--json]");
   writeLine(io, "  agent sync [repo] [--current] [--all] [--dry-run] [--json] [--verbose]");
   writeLine(io, "  agent run [--input <name=path>...] [--mode one-shot|chat] [--input-conflict fail|overwrite|rename] [--plain] [--json] [--verbose]");
   writeLine(io, "  agent push [--message <text>|--claude|--manual] [--dry-run] [--json] [--verbose]");